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