drivers/nfc/st95hf/core.c

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

DEFINITIONS
