drivers/nfc/st95hf/core.c

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