networking: add and use skb_put_u8()
[sfrench/cifs-2.6.git] / drivers / nfc / st95hf / core.c
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");