?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
watchdog/core: Rename some softlockup_* functions
[linux/fpc-iii.git] / drivers / nfc / st95hf / core.c
blob2b26f762fbc3b3f5f837e27267d0de9fc1b9e5c8
1 /*
2 * --------------------------------------------------------------------
3 * Driver for ST NFC Transceiver ST95HF
4 * --------------------------------------------------------------------
5 * Copyright (C) 2015 STMicroelectronics Pvt. Ltd. All rights reserved.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <linux/err.h>
21 #include <linux/gpio.h>
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/irq.h>
25 #include <linux/module.h>
26 #include <linux/netdevice.h>
27 #include <linux/nfc.h>
28 #include <linux/of_gpio.h>
29 #include <linux/of.h>
30 #include <linux/of_irq.h>
31 #include <linux/property.h>
32 #include <linux/regulator/consumer.h>
33 #include <linux/wait.h>
34 #include <net/nfc/digital.h>
35 #include <net/nfc/nfc.h>
36
37 #include "spi.h"
38
39 /* supported protocols */
40 #define ST95HF_SUPPORTED_PROT (NFC_PROTO_ISO14443_MASK | \
41 NFC_PROTO_ISO14443_B_MASK | \
42 NFC_PROTO_ISO15693_MASK)
43 /* driver capabilities */
44 #define ST95HF_CAPABILITIES NFC_DIGITAL_DRV_CAPS_IN_CRC
45
46 /* Command Send Interface */
47 /* ST95HF_COMMAND_SEND CMD Ids */
48 #define ECHO_CMD 0x55
49 #define WRITE_REGISTER_CMD 0x9
50 #define PROTOCOL_SELECT_CMD 0x2
51 #define SEND_RECEIVE_CMD 0x4
52
53 /* Select protocol codes */
54 #define ISO15693_PROTOCOL_CODE 0x1
55 #define ISO14443A_PROTOCOL_CODE 0x2
56 #define ISO14443B_PROTOCOL_CODE 0x3
57
58 /*
59 * head room len is 3
60 * 1 byte for control byte
61 * 1 byte for cmd
62 * 1 byte for size
63 */
64 #define ST95HF_HEADROOM_LEN 3
65
66 /*
67 * tailroom is 1 for ISO14443A
68 * and 0 for ISO14443B/ISO15693,
69 * hence the max value 1 should be
70 * taken.
71 */
72 #define ST95HF_TAILROOM_LEN 1
73
74 /* Command Response interface */
75 #define MAX_RESPONSE_BUFFER_SIZE 280
76 #define ECHORESPONSE 0x55
77 #define ST95HF_ERR_MASK 0xF
78 #define ST95HF_TIMEOUT_ERROR 0x87
79 #define ST95HF_NFCA_CRC_ERR_MASK 0x20
80 #define ST95HF_NFCB_CRC_ERR_MASK 0x01
81
82 /* ST95HF transmission flag values */
83 #define TRFLAG_NFCA_SHORT_FRAME 0x07
84 #define TRFLAG_NFCA_STD_FRAME 0x08
85 #define TRFLAG_NFCA_STD_FRAME_CRC 0x28
86
87 /* Misc defs */
88 #define HIGH 1
89 #define LOW 0
90 #define ISO14443A_RATS_REQ 0xE0
91 #define RATS_TB1_PRESENT_MASK 0x20
92 #define RATS_TA1_PRESENT_MASK 0x10
93 #define TB1_FWI_MASK 0xF0
94 #define WTX_REQ_FROM_TAG 0xF2
95
96 #define MAX_CMD_LEN 0x7
97
98 #define MAX_CMD_PARAMS 4
99 struct cmd {
100 int cmd_len;
101 unsigned char cmd_id;
102 unsigned char no_cmd_params;
103 unsigned char cmd_params[MAX_CMD_PARAMS];
104 enum req_type req;
105 };
106
107 struct param_list {
108 int param_offset;
109 int new_param_val;
110 };
111
112 /*
113 * List of top-level cmds to be used internally by the driver.
114 * All these commands are build on top of ST95HF basic commands
115 * such as SEND_RECEIVE_CMD, PROTOCOL_SELECT_CMD, etc.
116 * These top level cmds are used internally while implementing various ops of
117 * digital layer/driver probe or extending the digital framework layer for
118 * features that are not yet implemented there, for example, WTX cmd handling.
119 */
120 enum st95hf_cmd_list {
121 CMD_ECHO,
122 CMD_ISO14443A_CONFIG,
123 CMD_ISO14443A_DEMOGAIN,
124 CMD_ISO14443B_DEMOGAIN,
125 CMD_ISO14443A_PROTOCOL_SELECT,
126 CMD_ISO14443B_PROTOCOL_SELECT,
127 CMD_WTX_RESPONSE,
128 CMD_FIELD_OFF,
129 CMD_ISO15693_PROTOCOL_SELECT,
130 };
131
132 static const struct cmd cmd_array[] = {
133 [CMD_ECHO] = {
134 .cmd_len = 0x2,
135 .cmd_id = ECHO_CMD,
136 .no_cmd_params = 0,
137 .req = SYNC,
138 },
139 [CMD_ISO14443A_CONFIG] = {
140 .cmd_len = 0x7,
141 .cmd_id = WRITE_REGISTER_CMD,
142 .no_cmd_params = 0x4,
143 .cmd_params = {0x3A, 0x00, 0x5A, 0x04},
144 .req = SYNC,
145 },
146 [CMD_ISO14443A_DEMOGAIN] = {
147 .cmd_len = 0x7,
148 .cmd_id = WRITE_REGISTER_CMD,
149 .no_cmd_params = 0x4,
150 .cmd_params = {0x68, 0x01, 0x01, 0xDF},
151 .req = SYNC,
152 },
153 [CMD_ISO14443B_DEMOGAIN] = {
154 .cmd_len = 0x7,
155 .cmd_id = WRITE_REGISTER_CMD,
156 .no_cmd_params = 0x4,
157 .cmd_params = {0x68, 0x01, 0x01, 0x51},
158 .req = SYNC,
159 },
160 [CMD_ISO14443A_PROTOCOL_SELECT] = {
161 .cmd_len = 0x7,
162 .cmd_id = PROTOCOL_SELECT_CMD,
163 .no_cmd_params = 0x4,
164 .cmd_params = {ISO14443A_PROTOCOL_CODE, 0x00, 0x01, 0xA0},
165 .req = SYNC,
166 },
167 [CMD_ISO14443B_PROTOCOL_SELECT] = {
168 .cmd_len = 0x7,
169 .cmd_id = PROTOCOL_SELECT_CMD,
170 .no_cmd_params = 0x4,
171 .cmd_params = {ISO14443B_PROTOCOL_CODE, 0x01, 0x03, 0xFF},
172 .req = SYNC,
173 },
174 [CMD_WTX_RESPONSE] = {
175 .cmd_len = 0x6,
176 .cmd_id = SEND_RECEIVE_CMD,
177 .no_cmd_params = 0x3,
178 .cmd_params = {0xF2, 0x00, TRFLAG_NFCA_STD_FRAME_CRC},
179 .req = ASYNC,
180 },
181 [CMD_FIELD_OFF] = {
182 .cmd_len = 0x5,
183 .cmd_id = PROTOCOL_SELECT_CMD,
184 .no_cmd_params = 0x2,
185 .cmd_params = {0x0, 0x0},
186 .req = SYNC,
187 },
188 [CMD_ISO15693_PROTOCOL_SELECT] = {
189 .cmd_len = 0x5,
190 .cmd_id = PROTOCOL_SELECT_CMD,
191 .no_cmd_params = 0x2,
192 .cmd_params = {ISO15693_PROTOCOL_CODE, 0x0D},
193 .req = SYNC,
194 },
195 };
196
197 /* st95_digital_cmd_complete_arg stores client context */
198 struct st95_digital_cmd_complete_arg {
199 struct sk_buff *skb_resp;
200 nfc_digital_cmd_complete_t complete_cb;
201 void *cb_usrarg;
202 bool rats;
203 };
204
205 /*
206 * structure containing ST95HF driver specific data.
207 * @spicontext: structure containing information required
208 * for spi communication between st95hf and host.
209 * @ddev: nfc digital device object.
210 * @nfcdev: nfc device object.
211 * @enable_gpio: gpio used to enable st95hf transceiver.
212 * @complete_cb_arg: structure to store various context information
213 * that is passed from nfc requesting thread to the threaded ISR.
214 * @st95hf_supply: regulator "consumer" for NFC device.
215 * @sendrcv_trflag: last byte of frame send by sendrecv command
216 * of st95hf. This byte contains transmission flag info.
217 * @exchange_lock: semaphore used for signaling the st95hf_remove
218 * function that the last outstanding async nfc request is finished.
219 * @rm_lock: mutex for ensuring safe access of nfc digital object
220 * from threaded ISR. Usage of this mutex avoids any race between
221 * deletion of the object from st95hf_remove() and its access from
222 * the threaded ISR.
223 * @nfcdev_free: flag to have the state of nfc device object.
224 * [alive | died]
225 * @current_protocol: current nfc protocol.
226 * @current_rf_tech: current rf technology.
227 * @fwi: frame waiting index, received in reply of RATS according to
228 * digital protocol.
229 */
230 struct st95hf_context {
231 struct st95hf_spi_context spicontext;
232 struct nfc_digital_dev *ddev;
233 struct nfc_dev *nfcdev;
234 unsigned int enable_gpio;
235 struct st95_digital_cmd_complete_arg complete_cb_arg;
236 struct regulator *st95hf_supply;
237 unsigned char sendrcv_trflag;
238 struct semaphore exchange_lock;
239 struct mutex rm_lock;
240 bool nfcdev_free;
241 u8 current_protocol;
242 u8 current_rf_tech;
243 int fwi;
244 };
245
246 /*
247 * st95hf_send_recv_cmd() is for sending commands to ST95HF
248 * that are described in the cmd_array[]. It can optionally
249 * receive the response if the cmd request is of type
250 * SYNC. For that to happen caller must pass true to recv_res.
251 * For ASYNC request, recv_res is ignored and the
252 * function will never try to receive the response on behalf
253 * of the caller.
254 */
255 static int st95hf_send_recv_cmd(struct st95hf_context *st95context,
256 enum st95hf_cmd_list cmd,
257 int no_modif,
258 struct param_list *list_array,
259 bool recv_res)
260 {
261 unsigned char spi_cmd_buffer[MAX_CMD_LEN];
262 int i, ret;
263 struct device *dev = &st95context->spicontext.spidev->dev;
264
265 if (cmd_array[cmd].cmd_len > MAX_CMD_LEN)
266 return -EINVAL;
267 if (cmd_array[cmd].no_cmd_params < no_modif)
268 return -EINVAL;
269 if (no_modif && !list_array)
270 return -EINVAL;
271
272 spi_cmd_buffer[0] = ST95HF_COMMAND_SEND;
273 spi_cmd_buffer[1] = cmd_array[cmd].cmd_id;
274 spi_cmd_buffer[2] = cmd_array[cmd].no_cmd_params;
275
276 memcpy(&spi_cmd_buffer[3], cmd_array[cmd].cmd_params,
277 spi_cmd_buffer[2]);
278
279 for (i = 0; i < no_modif; i++) {
280 if (list_array[i].param_offset >= cmd_array[cmd].no_cmd_params)
281 return -EINVAL;
282 spi_cmd_buffer[3 + list_array[i].param_offset] =
283 list_array[i].new_param_val;
284 }
285
286 ret = st95hf_spi_send(&st95context->spicontext,
287 spi_cmd_buffer,
288 cmd_array[cmd].cmd_len,
289 cmd_array[cmd].req);
290 if (ret) {
291 dev_err(dev, "st95hf_spi_send failed with error %d\n", ret);
292 return ret;
293 }
294
295 if (cmd_array[cmd].req == SYNC && recv_res) {
296 unsigned char st95hf_response_arr[2];
297
298 ret = st95hf_spi_recv_response(&st95context->spicontext,
299 st95hf_response_arr);
300 if (ret < 0) {
301 dev_err(dev, "spi error from st95hf_spi_recv_response(), err = 0x%x\n",
302 ret);
303 return ret;
304 }
305
306 if (st95hf_response_arr[0]) {
307 dev_err(dev, "st95hf error from st95hf_spi_recv_response(), err = 0x%x\n",
308 st95hf_response_arr[0]);
309 return -EIO;
310 }
311 }
312
313 return 0;
314 }
315
316 static int st95hf_echo_command(struct st95hf_context *st95context)
317 {
318 int result = 0;
319 unsigned char echo_response;
320
321 result = st95hf_send_recv_cmd(st95context, CMD_ECHO, 0, NULL, false);
322 if (result)
323 return result;
324
325 /* If control reached here, response can be taken */
326 result = st95hf_spi_recv_echo_res(&st95context->spicontext,
327 &echo_response);
328 if (result) {
329 dev_err(&st95context->spicontext.spidev->dev,
330 "err: echo response receieve error = 0x%x\n", result);
331 return result;
332 }
333
334 if (echo_response == ECHORESPONSE)
335 return 0;
336
337 dev_err(&st95context->spicontext.spidev->dev, "err: echo res is 0x%x\n",
338 echo_response);
339
340 return -EIO;
341 }
342
343 static int secondary_configuration_type4a(struct st95hf_context *stcontext)
344 {
345 int result = 0;
346 struct device *dev = &stcontext->nfcdev->dev;
347
348 /* 14443A config setting after select protocol */
349 result = st95hf_send_recv_cmd(stcontext,
350 CMD_ISO14443A_CONFIG,
351 0,
352 NULL,
353 true);
354 if (result) {
355 dev_err(dev, "type a config cmd, err = 0x%x\n", result);
356 return result;
357 }
358
359 /* 14443A demo gain setting */
360 result = st95hf_send_recv_cmd(stcontext,
361 CMD_ISO14443A_DEMOGAIN,
362 0,
363 NULL,
364 true);
365 if (result)
366 dev_err(dev, "type a demogain cmd, err = 0x%x\n", result);
367
368 return result;
369 }
370
371 static int secondary_configuration_type4b(struct st95hf_context *stcontext)
372 {
373 int result = 0;
374 struct device *dev = &stcontext->nfcdev->dev;
375
376 result = st95hf_send_recv_cmd(stcontext,
377 CMD_ISO14443B_DEMOGAIN,
378 0,
379 NULL,
380 true);
381 if (result)
382 dev_err(dev, "type b demogain cmd, err = 0x%x\n", result);
383
384 return result;
385 }
386
387 static int st95hf_select_protocol(struct st95hf_context *stcontext, int type)
388 {
389 int result = 0;
390 struct device *dev;
391
392 dev = &stcontext->nfcdev->dev;
393
394 switch (type) {
395 case NFC_DIGITAL_RF_TECH_106A:
396 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_106A;
397 result = st95hf_send_recv_cmd(stcontext,
398 CMD_ISO14443A_PROTOCOL_SELECT,
399 0,
400 NULL,
401 true);
402 if (result) {
403 dev_err(dev, "protocol sel, err = 0x%x\n",
404 result);
405 return result;
406 }
407
408 /* secondary config. for 14443Type 4A after protocol select */
409 result = secondary_configuration_type4a(stcontext);
410 if (result) {
411 dev_err(dev, "type a secondary config, err = 0x%x\n",
412 result);
413 return result;
414 }
415 break;
416 case NFC_DIGITAL_RF_TECH_106B:
417 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_106B;
418 result = st95hf_send_recv_cmd(stcontext,
419 CMD_ISO14443B_PROTOCOL_SELECT,
420 0,
421 NULL,
422 true);
423 if (result) {
424 dev_err(dev, "protocol sel send, err = 0x%x\n",
425 result);
426 return result;
427 }
428
429 /*
430 * delay of 5-6 ms is required after select protocol
431 * command in case of ISO14443 Type B
432 */
433 usleep_range(50000, 60000);
434
435 /* secondary config. for 14443Type 4B after protocol select */
436 result = secondary_configuration_type4b(stcontext);
437 if (result) {
438 dev_err(dev, "type b secondary config, err = 0x%x\n",
439 result);
440 return result;
441 }
442 break;
443 case NFC_DIGITAL_RF_TECH_ISO15693:
444 stcontext->current_rf_tech = NFC_DIGITAL_RF_TECH_ISO15693;
445 result = st95hf_send_recv_cmd(stcontext,
446 CMD_ISO15693_PROTOCOL_SELECT,
447 0,
448 NULL,
449 true);
450 if (result) {
451 dev_err(dev, "protocol sel send, err = 0x%x\n",
452 result);
453 return result;
454 }
455 break;
456 default:
457 return -EINVAL;
458 }
459
460 return 0;
461 }
462
463 static void st95hf_send_st95enable_negativepulse(struct st95hf_context *st95con)
464 {
465 /* First make irq_in pin high */
466 gpio_set_value(st95con->enable_gpio, HIGH);
467
468 /* wait for 1 milisecond */
469 usleep_range(1000, 2000);
470
471 /* Make irq_in pin low */
472 gpio_set_value(st95con->enable_gpio, LOW);
473
474 /* wait for minimum interrupt pulse to make st95 active */
475 usleep_range(1000, 2000);
476
477 /* At end make it high */
478 gpio_set_value(st95con->enable_gpio, HIGH);
479 }
480
481 /*
482 * Send a reset sequence over SPI bus (Reset command + wait 3ms +
483 * negative pulse on st95hf enable gpio
484 */
485 static int st95hf_send_spi_reset_sequence(struct st95hf_context *st95context)
486 {
487 int result = 0;
488 unsigned char reset_cmd = ST95HF_COMMAND_RESET;
489
490 result = st95hf_spi_send(&st95context->spicontext,
491 &reset_cmd,
492 ST95HF_RESET_CMD_LEN,
493 ASYNC);
494 if (result) {
495 dev_err(&st95context->spicontext.spidev->dev,
496 "spi reset sequence cmd error = %d", result);
497 return result;
498 }
499
500 /* wait for 3 milisecond to complete the controller reset process */
501 usleep_range(3000, 4000);
502
503 /* send negative pulse to make st95hf active */
504 st95hf_send_st95enable_negativepulse(st95context);
505
506 /* wait for 10 milisecond : HFO setup time */
507 usleep_range(10000, 20000);
508
509 return result;
510 }
511
512 static int st95hf_por_sequence(struct st95hf_context *st95context)
513 {
514 int nth_attempt = 1;
515 int result;
516
517 st95hf_send_st95enable_negativepulse(st95context);
518
519 usleep_range(5000, 6000);
520 do {
521 /* send an ECHO command and checks ST95HF response */
522 result = st95hf_echo_command(st95context);
523
524 dev_dbg(&st95context->spicontext.spidev->dev,
525 "response from echo function = 0x%x, attempt = %d\n",
526 result, nth_attempt);
527
528 if (!result)
529 return 0;
530
531 /* send an pulse on IRQ in case of the chip is on sleep state */
532 if (nth_attempt == 2)
533 st95hf_send_st95enable_negativepulse(st95context);
534 else
535 st95hf_send_spi_reset_sequence(st95context);
536
537 /* delay of 50 milisecond */
538 usleep_range(50000, 51000);
539 } while (nth_attempt++ < 3);
540
541 return -ETIMEDOUT;
542 }
543
544 static int iso14443_config_fdt(struct st95hf_context *st95context, int wtxm)
545 {
546 int result = 0;
547 struct device *dev = &st95context->spicontext.spidev->dev;
548 struct nfc_digital_dev *nfcddev = st95context->ddev;
549 unsigned char pp_typeb;
550 struct param_list new_params[2];
551
552 pp_typeb = cmd_array[CMD_ISO14443B_PROTOCOL_SELECT].cmd_params[2];
553
554 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443 &&
555 st95context->fwi < 4)
556 st95context->fwi = 4;
557
558 new_params[0].param_offset = 2;
559 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443)
560 new_params[0].new_param_val = st95context->fwi;
561 else if (nfcddev->curr_protocol == NFC_PROTO_ISO14443_B)
562 new_params[0].new_param_val = pp_typeb;
563
564 new_params[1].param_offset = 3;
565 new_params[1].new_param_val = wtxm;
566
567 switch (nfcddev->curr_protocol) {
568 case NFC_PROTO_ISO14443:
569 result = st95hf_send_recv_cmd(st95context,
570 CMD_ISO14443A_PROTOCOL_SELECT,
571 2,
572 new_params,
573 true);
574 if (result) {
575 dev_err(dev, "WTX type a sel proto, err = 0x%x\n",
576 result);
577 return result;
578 }
579
580 /* secondary config. for 14443Type 4A after protocol select */
581 result = secondary_configuration_type4a(st95context);
582 if (result) {
583 dev_err(dev, "WTX type a second. config, err = 0x%x\n",
584 result);
585 return result;
586 }
587 break;
588 case NFC_PROTO_ISO14443_B:
589 result = st95hf_send_recv_cmd(st95context,
590 CMD_ISO14443B_PROTOCOL_SELECT,
591 2,
592 new_params,
593 true);
594 if (result) {
595 dev_err(dev, "WTX type b sel proto, err = 0x%x\n",
596 result);
597 return result;
598 }
599
600 /* secondary config. for 14443Type 4B after protocol select */
601 result = secondary_configuration_type4b(st95context);
602 if (result) {
603 dev_err(dev, "WTX type b second. config, err = 0x%x\n",
604 result);
605 return result;
606 }
607 break;
608 default:
609 return -EINVAL;
610 }
611
612 return 0;
613 }
614
615 static int st95hf_handle_wtx(struct st95hf_context *stcontext,
616 bool new_wtx,
617 int wtx_val)
618 {
619 int result = 0;
620 unsigned char val_mm = 0;
621 struct param_list new_params[1];
622 struct nfc_digital_dev *nfcddev = stcontext->ddev;
623 struct device *dev = &stcontext->nfcdev->dev;
624
625 if (new_wtx) {
626 result = iso14443_config_fdt(stcontext, wtx_val & 0x3f);
627 if (result) {
628 dev_err(dev, "Config. setting error on WTX req, err = 0x%x\n",
629 result);
630 return result;
631 }
632
633 /* Send response of wtx with ASYNC as no response expected */
634 new_params[0].param_offset = 1;
635 new_params[0].new_param_val = wtx_val;
636
637 result = st95hf_send_recv_cmd(stcontext,
638 CMD_WTX_RESPONSE,
639 1,
640 new_params,
641 false);
642 if (result)
643 dev_err(dev, "WTX response send, err = 0x%x\n", result);
644 return result;
645 }
646
647 /* if no new wtx, cofigure with default values */
648 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443)
649 val_mm = cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[3];
650 else if (nfcddev->curr_protocol == NFC_PROTO_ISO14443_B)
651 val_mm = cmd_array[CMD_ISO14443B_PROTOCOL_SELECT].cmd_params[3];
652
653 result = iso14443_config_fdt(stcontext, val_mm);
654 if (result)
655 dev_err(dev, "Default config. setting error after WTX processing, err = 0x%x\n",
656 result);
657
658 return result;
659 }
660
661 static int st95hf_error_handling(struct st95hf_context *stcontext,
662 struct sk_buff *skb_resp,
663 int res_len)
664 {
665 int result = 0;
666 unsigned char error_byte;
667 struct device *dev = &stcontext->nfcdev->dev;
668
669 /* First check ST95HF specific error */
670 if (skb_resp->data[0] & ST95HF_ERR_MASK) {
671 if (skb_resp->data[0] == ST95HF_TIMEOUT_ERROR)
672 result = -ETIMEDOUT;
673 else
674 result = -EIO;
675 return result;
676 }
677
678 /* Check for CRC err only if CRC is present in the tag response */
679 switch (stcontext->current_rf_tech) {
680 case NFC_DIGITAL_RF_TECH_106A:
681 if (stcontext->sendrcv_trflag == TRFLAG_NFCA_STD_FRAME_CRC) {
682 error_byte = skb_resp->data[res_len - 3];
683 if (error_byte & ST95HF_NFCA_CRC_ERR_MASK) {
684 /* CRC error occurred */
685 dev_err(dev, "CRC error, byte received = 0x%x\n",
686 error_byte);
687 result = -EIO;
688 }
689 }
690 break;
691 case NFC_DIGITAL_RF_TECH_106B:
692 case NFC_DIGITAL_RF_TECH_ISO15693:
693 error_byte = skb_resp->data[res_len - 1];
694 if (error_byte & ST95HF_NFCB_CRC_ERR_MASK) {
695 /* CRC error occurred */
696 dev_err(dev, "CRC error, byte received = 0x%x\n",
697 error_byte);
698 result = -EIO;
699 }
700 break;
701 }
702
703 return result;
704 }
705
706 static int st95hf_response_handler(struct st95hf_context *stcontext,
707 struct sk_buff *skb_resp,
708 int res_len)
709 {
710 int result = 0;
711 int skb_len;
712 unsigned char val_mm;
713 struct nfc_digital_dev *nfcddev = stcontext->ddev;
714 struct device *dev = &stcontext->nfcdev->dev;
715 struct st95_digital_cmd_complete_arg *cb_arg;
716
717 cb_arg = &stcontext->complete_cb_arg;
718
719 /* Process the response */
720 skb_put(skb_resp, res_len);
721
722 /* Remove st95 header */
723 skb_pull(skb_resp, 2);
724
725 skb_len = skb_resp->len;
726
727 /* check if it is case of RATS request reply & FWI is present */
728 if (nfcddev->curr_protocol == NFC_PROTO_ISO14443 && cb_arg->rats &&
729 (skb_resp->data[1] & RATS_TB1_PRESENT_MASK)) {
730 if (skb_resp->data[1] & RATS_TA1_PRESENT_MASK)
731 stcontext->fwi =
732 (skb_resp->data[3] & TB1_FWI_MASK) >> 4;
733 else
734 stcontext->fwi =
735 (skb_resp->data[2] & TB1_FWI_MASK) >> 4;
736
737 val_mm = cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[3];
738
739 result = iso14443_config_fdt(stcontext, val_mm);
740 if (result) {
741 dev_err(dev, "error in config_fdt to handle fwi of ATS, error=%d\n",
742 result);
743 return result;
744 }
745 }
746 cb_arg->rats = false;
747
748 /* Remove CRC bytes only if received frames data has an eod (CRC) */
749 switch (stcontext->current_rf_tech) {
750 case NFC_DIGITAL_RF_TECH_106A:
751 if (stcontext->sendrcv_trflag == TRFLAG_NFCA_STD_FRAME_CRC)
752 skb_trim(skb_resp, (skb_len - 5));
753 else
754 skb_trim(skb_resp, (skb_len - 3));
755 break;
756 case NFC_DIGITAL_RF_TECH_106B:
757 case NFC_DIGITAL_RF_TECH_ISO15693:
758 skb_trim(skb_resp, (skb_len - 3));
759 break;
760 }
761
762 return result;
763 }
764
765 static irqreturn_t st95hf_irq_handler(int irq, void *st95hfcontext)
766 {
767 struct st95hf_context *stcontext =
768 (struct st95hf_context *)st95hfcontext;
769
770 if (stcontext->spicontext.req_issync) {
771 complete(&stcontext->spicontext.done);
772 stcontext->spicontext.req_issync = false;
773 return IRQ_HANDLED;
774 }
775
776 return IRQ_WAKE_THREAD;
777 }
778
779 static irqreturn_t st95hf_irq_thread_handler(int irq, void *st95hfcontext)
780 {
781 int result = 0;
782 int res_len;
783 static bool wtx;
784 struct device *dev;
785 struct device *spidevice;
786 struct nfc_digital_dev *nfcddev;
787 struct sk_buff *skb_resp;
788 struct st95hf_context *stcontext =
789 (struct st95hf_context *)st95hfcontext;
790 struct st95_digital_cmd_complete_arg *cb_arg;
791
792 spidevice = &stcontext->spicontext.spidev->dev;
793
794 /*
795 * check semaphore, if not down() already, then we don't
796 * know in which context the ISR is called and surely it
797 * will be a bug. Note that down() of the semaphore is done
798 * in the corresponding st95hf_in_send_cmd() and then
799 * only this ISR should be called. ISR will up() the
800 * semaphore before leaving. Hence when the ISR is called
801 * the correct behaviour is down_trylock() should always
802 * return 1 (indicating semaphore cant be taken and hence no
803 * change in semaphore count).
804 * If not, then we up() the semaphore and crash on
805 * a BUG() !
806 */
807 if (!down_trylock(&stcontext->exchange_lock)) {
808 up(&stcontext->exchange_lock);
809 WARN(1, "unknown context in ST95HF ISR");
810 return IRQ_NONE;
811 }
812
813 cb_arg = &stcontext->complete_cb_arg;
814 skb_resp = cb_arg->skb_resp;
815
816 mutex_lock(&stcontext->rm_lock);
817 res_len = st95hf_spi_recv_response(&stcontext->spicontext,
818 skb_resp->data);
819 if (res_len < 0) {
820 dev_err(spidevice, "TISR spi response err = 0x%x\n", res_len);
821 result = res_len;
822 goto end;
823 }
824
825 /* if stcontext->nfcdev_free is true, it means remove already ran */
826 if (stcontext->nfcdev_free) {
827 result = -ENODEV;
828 goto end;
829 }
830
831 dev = &stcontext->nfcdev->dev;
832 nfcddev = stcontext->ddev;
833 if (skb_resp->data[2] == WTX_REQ_FROM_TAG) {
834 /* Request for new FWT from tag */
835 result = st95hf_handle_wtx(stcontext, true, skb_resp->data[3]);
836 if (result)
837 goto end;
838
839 wtx = true;
840 mutex_unlock(&stcontext->rm_lock);
841 return IRQ_HANDLED;
842 }
843
844 result = st95hf_error_handling(stcontext, skb_resp, res_len);
845 if (result)
846 goto end;
847
848 result = st95hf_response_handler(stcontext, skb_resp, res_len);
849 if (result)
850 goto end;
851
852 /*
853 * If select protocol is done on wtx req. do select protocol
854 * again with default values
855 */
856 if (wtx) {
857 wtx = false;
858 result = st95hf_handle_wtx(stcontext, false, 0);
859 if (result)
860 goto end;
861 }
862
863 /* call digital layer callback */
864 cb_arg->complete_cb(stcontext->ddev, cb_arg->cb_usrarg, skb_resp);
865
866 /* up the semaphore before returning */
867 up(&stcontext->exchange_lock);
868 mutex_unlock(&stcontext->rm_lock);
869
870 return IRQ_HANDLED;
871
872 end:
873 kfree_skb(skb_resp);
874 wtx = false;
875 cb_arg->rats = false;
876 skb_resp = ERR_PTR(result);
877 /* call of callback with error */
878 cb_arg->complete_cb(stcontext->ddev, cb_arg->cb_usrarg, skb_resp);
879 /* up the semaphore before returning */
880 up(&stcontext->exchange_lock);
881 mutex_unlock(&stcontext->rm_lock);
882 return IRQ_HANDLED;
883 }
884
885 /* NFC ops functions definition */
886 static int st95hf_in_configure_hw(struct nfc_digital_dev *ddev,
887 int type,
888 int param)
889 {
890 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev);
891
892 if (type == NFC_DIGITAL_CONFIG_RF_TECH)
893 return st95hf_select_protocol(stcontext, param);
894
895 if (type == NFC_DIGITAL_CONFIG_FRAMING) {
896 switch (param) {
897 case NFC_DIGITAL_FRAMING_NFCA_SHORT:
898 stcontext->sendrcv_trflag = TRFLAG_NFCA_SHORT_FRAME;
899 break;
900 case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
901 stcontext->sendrcv_trflag = TRFLAG_NFCA_STD_FRAME;
902 break;
903 case NFC_DIGITAL_FRAMING_NFCA_T4T:
904 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
905 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
906 stcontext->sendrcv_trflag = TRFLAG_NFCA_STD_FRAME_CRC;
907 break;
908 case NFC_DIGITAL_FRAMING_NFCB:
909 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
910 case NFC_DIGITAL_FRAMING_ISO15693_T5T:
911 break;
912 }
913 }
914
915 return 0;
916 }
917
918 static int rf_off(struct st95hf_context *stcontext)
919 {
920 int rc;
921 struct device *dev;
922
923 dev = &stcontext->nfcdev->dev;
924
925 rc = st95hf_send_recv_cmd(stcontext, CMD_FIELD_OFF, 0, NULL, true);
926 if (rc)
927 dev_err(dev, "protocol sel send field off, err = 0x%x\n", rc);
928
929 return rc;
930 }
931
932 static int st95hf_in_send_cmd(struct nfc_digital_dev *ddev,
933 struct sk_buff *skb,
934 u16 timeout,
935 nfc_digital_cmd_complete_t cb,
936 void *arg)
937 {
938 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev);
939 int rc;
940 struct sk_buff *skb_resp;
941 int len_data_to_tag = 0;
942
943 skb_resp = nfc_alloc_recv_skb(MAX_RESPONSE_BUFFER_SIZE, GFP_KERNEL);
944 if (!skb_resp) {
945 rc = -ENOMEM;
946 goto error;
947 }
948
949 switch (stcontext->current_rf_tech) {
950 case NFC_DIGITAL_RF_TECH_106A:
951 len_data_to_tag = skb->len + 1;
952 skb_put_u8(skb, stcontext->sendrcv_trflag);
953 break;
954 case NFC_DIGITAL_RF_TECH_106B:
955 case NFC_DIGITAL_RF_TECH_ISO15693:
956 len_data_to_tag = skb->len;
957 break;
958 default:
959 rc = -EINVAL;
960 goto free_skb_resp;
961 }
962
963 skb_push(skb, 3);
964 skb->data[0] = ST95HF_COMMAND_SEND;
965 skb->data[1] = SEND_RECEIVE_CMD;
966 skb->data[2] = len_data_to_tag;
967
968 stcontext->complete_cb_arg.skb_resp = skb_resp;
969 stcontext->complete_cb_arg.cb_usrarg = arg;
970 stcontext->complete_cb_arg.complete_cb = cb;
971
972 if ((skb->data[3] == ISO14443A_RATS_REQ) &&
973 ddev->curr_protocol == NFC_PROTO_ISO14443)
974 stcontext->complete_cb_arg.rats = true;
975
976 /*
977 * down the semaphore to indicate to remove func that an
978 * ISR is pending, note that it will not block here in any case.
979 * If found blocked, it is a BUG!
980 */
981 rc = down_killable(&stcontext->exchange_lock);
982 if (rc) {
983 WARN(1, "Semaphore is not found up in st95hf_in_send_cmd\n");
984 return rc;
985 }
986
987 rc = st95hf_spi_send(&stcontext->spicontext, skb->data,
988 skb->len,
989 ASYNC);
990 if (rc) {
991 dev_err(&stcontext->nfcdev->dev,
992 "Error %d trying to perform data_exchange", rc);
993 /* up the semaphore since ISR will never come in this case */
994 up(&stcontext->exchange_lock);
995 goto free_skb_resp;
996 }
997
998 kfree_skb(skb);
999
1000 return rc;
1001
1002 free_skb_resp:
1003 kfree_skb(skb_resp);
1004 error:
1005 return rc;
1006 }
1007
1008 /* p2p will be supported in a later release ! */
1009 static int st95hf_tg_configure_hw(struct nfc_digital_dev *ddev,
1010 int type,
1011 int param)
1012 {
1013 return 0;
1014 }
1015
1016 static int st95hf_tg_send_cmd(struct nfc_digital_dev *ddev,
1017 struct sk_buff *skb,
1018 u16 timeout,
1019 nfc_digital_cmd_complete_t cb,
1020 void *arg)
1021 {
1022 return 0;
1023 }
1024
1025 static int st95hf_tg_listen(struct nfc_digital_dev *ddev,
1026 u16 timeout,
1027 nfc_digital_cmd_complete_t cb,
1028 void *arg)
1029 {
1030 return 0;
1031 }
1032
1033 static int st95hf_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)
1034 {
1035 return 0;
1036 }
1037
1038 static int st95hf_switch_rf(struct nfc_digital_dev *ddev, bool on)
1039 {
1040 u8 rf_tech;
1041 struct st95hf_context *stcontext = nfc_digital_get_drvdata(ddev);
1042
1043 rf_tech = ddev->curr_rf_tech;
1044
1045 if (on)
1046 /* switch on RF field */
1047 return st95hf_select_protocol(stcontext, rf_tech);
1048
1049 /* switch OFF RF field */
1050 return rf_off(stcontext);
1051 }
1052
1053 /* TODO st95hf_abort_cmd */
1054 static void st95hf_abort_cmd(struct nfc_digital_dev *ddev)
1055 {
1056 }
1057
1058 static struct nfc_digital_ops st95hf_nfc_digital_ops = {
1059 .in_configure_hw = st95hf_in_configure_hw,
1060 .in_send_cmd = st95hf_in_send_cmd,
1061
1062 .tg_listen = st95hf_tg_listen,
1063 .tg_configure_hw = st95hf_tg_configure_hw,
1064 .tg_send_cmd = st95hf_tg_send_cmd,
1065 .tg_get_rf_tech = st95hf_tg_get_rf_tech,
1066
1067 .switch_rf = st95hf_switch_rf,
1068 .abort_cmd = st95hf_abort_cmd,
1069 };
1070
1071 static const struct spi_device_id st95hf_id[] = {
1072 { "st95hf", 0 },
1073 {}
1074 };
1075 MODULE_DEVICE_TABLE(spi, st95hf_id);
1076
1077 static int st95hf_probe(struct spi_device *nfc_spi_dev)
1078 {
1079 int ret;
1080
1081 struct st95hf_context *st95context;
1082 struct st95hf_spi_context *spicontext;
1083
1084 nfc_info(&nfc_spi_dev->dev, "ST95HF driver probe called.\n");
1085
1086 st95context = devm_kzalloc(&nfc_spi_dev->dev,
1087 sizeof(struct st95hf_context),
1088 GFP_KERNEL);
1089 if (!st95context)
1090 return -ENOMEM;
1091
1092 spicontext = &st95context->spicontext;
1093
1094 spicontext->spidev = nfc_spi_dev;
1095
1096 st95context->fwi =
1097 cmd_array[CMD_ISO14443A_PROTOCOL_SELECT].cmd_params[2];
1098
1099 if (device_property_present(&nfc_spi_dev->dev, "st95hfvin")) {
1100 st95context->st95hf_supply =
1101 devm_regulator_get(&nfc_spi_dev->dev,
1102 "st95hfvin");
1103 if (IS_ERR(st95context->st95hf_supply)) {
1104 dev_err(&nfc_spi_dev->dev, "failed to acquire regulator\n");
1105 return PTR_ERR(st95context->st95hf_supply);
1106 }
1107
1108 ret = regulator_enable(st95context->st95hf_supply);
1109 if (ret) {
1110 dev_err(&nfc_spi_dev->dev, "failed to enable regulator\n");
1111 return ret;
1112 }
1113 }
1114
1115 init_completion(&spicontext->done);
1116 mutex_init(&spicontext->spi_lock);
1117
1118 /*
1119 * Store spicontext in spi device object for using it in
1120 * remove function
1121 */
1122 dev_set_drvdata(&nfc_spi_dev->dev, spicontext);
1123
1124 st95context->enable_gpio =
1125 of_get_named_gpio(nfc_spi_dev->dev.of_node,
1126 "enable-gpio",
1127 0);
1128 if (!gpio_is_valid(st95context->enable_gpio)) {
1129 dev_err(&nfc_spi_dev->dev, "No valid enable gpio\n");
1130 ret = st95context->enable_gpio;
1131 goto err_disable_regulator;
1132 }
1133
1134 ret = devm_gpio_request_one(&nfc_spi_dev->dev, st95context->enable_gpio,
1135 GPIOF_DIR_OUT | GPIOF_INIT_HIGH,
1136 "enable_gpio");
1137 if (ret)
1138 goto err_disable_regulator;
1139
1140 if (nfc_spi_dev->irq > 0) {
1141 if (devm_request_threaded_irq(&nfc_spi_dev->dev,
1142 nfc_spi_dev->irq,
1143 st95hf_irq_handler,
1144 st95hf_irq_thread_handler,
1145 IRQF_TRIGGER_FALLING,
1146 "st95hf",
1147 (void *)st95context) < 0) {
1148 dev_err(&nfc_spi_dev->dev, "err: irq request for st95hf is failed\n");
1149 ret = -EINVAL;
1150 goto err_disable_regulator;
1151 }
1152 } else {
1153 dev_err(&nfc_spi_dev->dev, "not a valid IRQ associated with ST95HF\n");
1154 ret = -EINVAL;
1155 goto err_disable_regulator;
1156 }
1157
1158 /*
1159 * First reset SPI to handle warm reset of the system.
1160 * It will put the ST95HF device in Power ON state
1161 * which make the state of device identical to state
1162 * at the time of cold reset of the system.
1163 */
1164 ret = st95hf_send_spi_reset_sequence(st95context);
1165 if (ret) {
1166 dev_err(&nfc_spi_dev->dev, "err: spi_reset_sequence failed\n");
1167 goto err_disable_regulator;
1168 }
1169
1170 /* call PowerOnReset sequence of ST95hf to activate it */
1171 ret = st95hf_por_sequence(st95context);
1172 if (ret) {
1173 dev_err(&nfc_spi_dev->dev, "err: por seq failed for st95hf\n");
1174 goto err_disable_regulator;
1175 }
1176
1177 /* create NFC dev object and register with NFC Subsystem */
1178 st95context->ddev = nfc_digital_allocate_device(&st95hf_nfc_digital_ops,
1179 ST95HF_SUPPORTED_PROT,
1180 ST95HF_CAPABILITIES,
1181 ST95HF_HEADROOM_LEN,
1182 ST95HF_TAILROOM_LEN);
1183 if (!st95context->ddev) {
1184 ret = -ENOMEM;
1185 goto err_disable_regulator;
1186 }
1187
1188 st95context->nfcdev = st95context->ddev->nfc_dev;
1189 nfc_digital_set_parent_dev(st95context->ddev, &nfc_spi_dev->dev);
1190
1191 ret = nfc_digital_register_device(st95context->ddev);
1192 if (ret) {
1193 dev_err(&st95context->nfcdev->dev, "st95hf registration failed\n");
1194 goto err_free_digital_device;
1195 }
1196
1197 /* store st95context in nfc device object */
1198 nfc_digital_set_drvdata(st95context->ddev, st95context);
1199
1200 sema_init(&st95context->exchange_lock, 1);
1201 mutex_init(&st95context->rm_lock);
1202
1203 return ret;
1204
1205 err_free_digital_device:
1206 nfc_digital_free_device(st95context->ddev);
1207 err_disable_regulator:
1208 if (st95context->st95hf_supply)
1209 regulator_disable(st95context->st95hf_supply);
1210
1211 return ret;
1212 }
1213
1214 static int st95hf_remove(struct spi_device *nfc_spi_dev)
1215 {
1216 int result = 0;
1217 unsigned char reset_cmd = ST95HF_COMMAND_RESET;
1218 struct st95hf_spi_context *spictx = dev_get_drvdata(&nfc_spi_dev->dev);
1219
1220 struct st95hf_context *stcontext = container_of(spictx,
1221 struct st95hf_context,
1222 spicontext);
1223
1224 mutex_lock(&stcontext->rm_lock);
1225
1226 nfc_digital_unregister_device(stcontext->ddev);
1227 nfc_digital_free_device(stcontext->ddev);
1228 stcontext->nfcdev_free = true;
1229
1230 mutex_unlock(&stcontext->rm_lock);
1231
1232 /* if last in_send_cmd's ISR is pending, wait for it to finish */
1233 result = down_killable(&stcontext->exchange_lock);
1234 if (result == -EINTR)
1235 dev_err(&spictx->spidev->dev, "sleep for semaphore interrupted by signal\n");
1236
1237 /* next reset the ST95HF controller */
1238 result = st95hf_spi_send(&stcontext->spicontext,
1239 &reset_cmd,
1240 ST95HF_RESET_CMD_LEN,
1241 ASYNC);
1242 if (result) {
1243 dev_err(&spictx->spidev->dev,
1244 "ST95HF reset failed in remove() err = %d\n", result);
1245 return result;
1246 }
1247
1248 /* wait for 3 ms to complete the controller reset process */
1249 usleep_range(3000, 4000);
1250
1251 /* disable regulator */
1252 if (stcontext->st95hf_supply)
1253 regulator_disable(stcontext->st95hf_supply);
1254
1255 return result;
1256 }
1257
1258 /* Register as SPI protocol driver */
1259 static struct spi_driver st95hf_driver = {
1260 .driver = {
1261 .name = "st95hf",
1262 .owner = THIS_MODULE,
1263 },
1264 .id_table = st95hf_id,
1265 .probe = st95hf_probe,
1266 .remove = st95hf_remove,
1267 };
1268
1269 module_spi_driver(st95hf_driver);
1270
1271 MODULE_AUTHOR("Shikha Singh <shikha.singh@st.com>");
1272 MODULE_DESCRIPTION("ST NFC Transceiver ST95HF driver");
1273 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support