linux/drivers/nfc/st95hf/core.c
<<
>>
Prefs
   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
  88struct 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
  96struct 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 */
 109enum 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
 121static 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 */
 187struct 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 */
 219struct 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 */
 244static 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
 305static 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
 332static 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
 360static 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
 376static 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
 452static 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 */
 474static 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
 501static 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
 533static 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
 604static 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
 650static 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
 695static 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
 754static 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
 768static 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
 857end:
 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 */
 871static 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
 903static 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
 917static 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
 987free_skb_resp:
 988        kfree_skb(skb_resp);
 989error:
 990        return rc;
 991}
 992
 993/* p2p will be supported in a later release ! */
 994static int st95hf_tg_configure_hw(struct nfc_digital_dev *ddev,
 995                                  int type,
 996                                  int param)
 997{
 998        return 0;
 999}
1000
1001static 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
1010static 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
1018static int st95hf_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)
1019{
1020        return 0;
1021}
1022
1023static 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 */
1039static void st95hf_abort_cmd(struct nfc_digital_dev *ddev)
1040{
1041}
1042
1043static 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
1056static const struct spi_device_id st95hf_id[] = {
1057        { "st95hf", 0 },
1058        {}
1059};
1060MODULE_DEVICE_TABLE(spi, st95hf_id);
1061
1062static const struct of_device_id st95hf_spi_of_match[] = {
1063        { .compatible = "st,st95hf" },
1064        { },
1065};
1066MODULE_DEVICE_TABLE(of, st95hf_spi_of_match);
1067
1068static 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
1196err_free_digital_device:
1197        nfc_digital_free_device(st95context->ddev);
1198err_disable_regulator:
1199        if (st95context->st95hf_supply)
1200                regulator_disable(st95context->st95hf_supply);
1201
1202        return ret;
1203}
1204
1205static 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 */
1250static 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
1261module_spi_driver(st95hf_driver);
1262
1263MODULE_AUTHOR("Shikha Singh <shikha.singh@st.com>");
1264MODULE_DESCRIPTION("ST NFC Transceiver ST95HF driver");
1265MODULE_LICENSE("GPL v2");
1266