drivers/nfc/trf7970a.c

   1 /*
   2  * TI TRF7970a RFID/NFC Transceiver Driver
   3  *
   4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
   5  *
   6  * Author: Erick Macias <emacias@ti.com>
   7  * Author: Felipe Balbi <balbi@ti.com>
   8  * Author: Mark A. Greer <mgreer@animalcreek.com>
   9  *
  10  * This program is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2  of
  12  * the License as published by the Free Software Foundation.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/device.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/pm_runtime.h>
  20 #include <linux/nfc.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/delay.h>
  23 #include <linux/gpio.h>
  24 #include <linux/of.h>
  25 #include <linux/of_gpio.h>
  26 #include <linux/spi/spi.h>
  27 #include <linux/regulator/consumer.h>
  28
  29 #include <net/nfc/nfc.h>
  30 #include <net/nfc/digital.h>
  31
  32 /* There are 3 ways the host can communicate with the trf7970a:
  33  * parallel mode, SPI with Slave Select (SS) mode, and SPI without
  34  * SS mode.  The driver only supports the two SPI modes.
  35  *
  36  * The trf7970a is very timing sensitive and the VIN, EN2, and EN
  37  * pins must asserted in that order and with specific delays in between.
  38  * The delays used in the driver were provided by TI and have been
  39  * confirmed to work with this driver.  There is a bug with the current
  40  * version of the trf7970a that requires that EN2 remain low no matter
  41  * what.  If it goes high, it will generate an RF field even when in
  42  * passive target mode.  TI has indicated that the chip will work okay
  43  * when EN2 is left low.  The 'en2-rf-quirk' device tree property
  44  * indicates that trf7970a currently being used has the erratum and
  45  * that EN2 must be kept low.
  46  *
  47  * Timeouts are implemented using the delayed workqueue kernel facility.
  48  * Timeouts are required so things don't hang when there is no response
  49  * from the trf7970a (or tag).  Using this mechanism creates a race with
  50  * interrupts, however.  That is, an interrupt and a timeout could occur
  51  * closely enough together that one is blocked by the mutex while the other
  52  * executes.  When the timeout handler executes first and blocks the
  53  * interrupt handler, it will eventually set the state to IDLE so the
  54  * interrupt handler will check the state and exit with no harm done.
  55  * When the interrupt handler executes first and blocks the timeout handler,
  56  * the cancel_delayed_work() call will know that it didn't cancel the
  57  * work item (i.e., timeout) and will return zero.  That return code is
  58  * used by the timer handler to indicate that it should ignore the timeout
  59  * once its unblocked.
  60  *
  61  * Aborting an active command isn't as simple as it seems because the only
  62  * way to abort a command that's already been sent to the tag is so turn
  63  * off power to the tag.  If we do that, though, we'd have to go through
  64  * the entire anticollision procedure again but the digital layer doesn't
  65  * support that.  So, if an abort is received before trf7970a_send_cmd()
  66  * has sent the command to the tag, it simply returns -ECANCELED.  If the
  67  * command has already been sent to the tag, then the driver continues
  68  * normally and recieves the response data (or error) but just before
  69  * sending the data upstream, it frees the rx_skb and sends -ECANCELED
  70  * upstream instead.  If the command failed, that error will be sent
  71  * upstream.
  72  *
  73  * When recieving data from a tag and the interrupt status register has
  74  * only the SRX bit set, it means that all of the data has been received
  75  * (once what's in the fifo has been read).  However, depending on timing
  76  * an interrupt status with only the SRX bit set may not be recived.  In
  77  * those cases, the timeout mechanism is used to wait 20 ms in case more
  78  * data arrives.  After 20 ms, it is assumed that all of the data has been
  79  * received and the accumulated rx data is sent upstream.  The
  80  * 'TRF7970A_ST_WAIT_FOR_RX_DATA_CONT' state is used for this purpose
  81  * (i.e., it indicates that some data has been received but we're not sure
  82  * if there is more coming so a timeout in this state means all data has
  83  * been received and there isn't an error).  The delay is 20 ms since delays
  84  * of ~16 ms have been observed during testing.
  85  *
  86  * When transmitting a frame larger than the FIFO size (127 bytes), the
  87  * driver will wait 20 ms for the FIFO to drain past the low-watermark
  88  * and generate an interrupt.  The low-watermark set to 32 bytes so the
  89  * interrupt should fire after 127 - 32 = 95 bytes have been sent.  At
  90  * the lowest possible bit rate (6.62 kbps for 15693), it will take up
  91  * to ~14.35 ms so 20 ms is used for the timeout.
  92  *
  93  * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
  94  * Having only 4 bits in the FIFO won't normally generate an interrupt so
  95  * driver enables the '4_bit_RX' bit of the Special Functions register 1
  96  * to cause an interrupt in that case.  Leaving that bit for a read command
  97  * messes up the data returned so it is only enabled when the framing is
  98  * 'NFC_DIGITAL_FRAMING_NFCA_T2T' and the command is not a read command.
  99  * Unfortunately, that means that the driver has to peek into tx frames
 100  * when the framing is 'NFC_DIGITAL_FRAMING_NFCA_T2T'.  This is done by
 101  * the trf7970a_per_cmd_config() routine.
 102  *
 103  * ISO/IEC 15693 frames specify whether to use single or double sub-carrier
 104  * frequencies and whether to use low or high data rates in the flags byte
 105  * of the frame.  This means that the driver has to peek at all 15693 frames
 106  * to determine what speed to set the communication to.  In addition, write
 107  * and lock commands use the OPTION flag to indicate that an EOF must be
 108  * sent to the tag before it will send its response.  So the driver has to
 109  * examine all frames for that reason too.
 110  *
 111  * It is unclear how long to wait before sending the EOF.  According to the
 112  * Note under Table 1-1 in section 1.6 of
 113  * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
 114  * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
 115  * enough so 20 ms is used.  So the timer is set to 40 ms - 20 ms to drain
 116  * up to 127 bytes in the FIFO at the lowest bit rate plus another 20 ms to
 117  * ensure the wait is long enough before sending the EOF.  This seems to work
 118  * reliably.
 119  */
 120
 121 #define TRF7970A_SUPPORTED_PROTOCOLS \
 122                 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK |      \
 123                  NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \
 124                  NFC_PROTO_ISO15693_MASK | NFC_PROTO_NFC_DEP_MASK)
 125
 126 #define TRF7970A_AUTOSUSPEND_DELAY              30000 /* 30 seconds */
 127
 128 #define TRF7970A_RX_SKB_ALLOC_SIZE              256
 129
 130 #define TRF7970A_FIFO_SIZE                      127
 131
 132 /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
 133 #define TRF7970A_TX_MAX                         (4096 - 1)
 134
 135 #define TRF7970A_WAIT_FOR_TX_IRQ                20
 136 #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT       20
 137 #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT    20
 138 #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF     40
 139
 140 /* Guard times for various RF technologies (in us) */
 141 #define TRF7970A_GUARD_TIME_NFCA                5000
 142 #define TRF7970A_GUARD_TIME_NFCB                5000
 143 #define TRF7970A_GUARD_TIME_NFCF                20000
 144 #define TRF7970A_GUARD_TIME_15693               1000
 145
 146 /* Quirks */
 147 /* Erratum: When reading IRQ Status register on trf7970a, we must issue a
 148  * read continuous command for IRQ Status and Collision Position registers.
 149  */
 150 #define TRF7970A_QUIRK_IRQ_STATUS_READ          BIT(0)
 151 #define TRF7970A_QUIRK_EN2_MUST_STAY_LOW        BIT(1)
 152 #define TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE       BIT(2)
 153
 154 /* Direct commands */
 155 #define TRF7970A_CMD_IDLE                       0x00
 156 #define TRF7970A_CMD_SOFT_INIT                  0x03
 157 #define TRF7970A_CMD_RF_COLLISION               0x04
 158 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_N    0x05
 159 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_0    0x06
 160 #define TRF7970A_CMD_FIFO_RESET                 0x0f
 161 #define TRF7970A_CMD_TRANSMIT_NO_CRC            0x10
 162 #define TRF7970A_CMD_TRANSMIT                   0x11
 163 #define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC      0x12
 164 #define TRF7970A_CMD_DELAY_TRANSMIT             0x13
 165 #define TRF7970A_CMD_EOF                        0x14
 166 #define TRF7970A_CMD_CLOSE_SLOT                 0x15
 167 #define TRF7970A_CMD_BLOCK_RX                   0x16
 168 #define TRF7970A_CMD_ENABLE_RX                  0x17
 169 #define TRF7970A_CMD_TEST_INT_RF                0x18
 170 #define TRF7970A_CMD_TEST_EXT_RF                0x19
 171 #define TRF7970A_CMD_RX_GAIN_ADJUST             0x1a
 172
 173 /* Bits determining whether its a direct command or register R/W,
 174  * whether to use a continuous SPI transaction or not, and the actual
 175  * direct cmd opcode or regster address.
 176  */
 177 #define TRF7970A_CMD_BIT_CTRL                   BIT(7)
 178 #define TRF7970A_CMD_BIT_RW                     BIT(6)
 179 #define TRF7970A_CMD_BIT_CONTINUOUS             BIT(5)
 180 #define TRF7970A_CMD_BIT_OPCODE(opcode)         ((opcode) & 0x1f)
 181
 182 /* Registers addresses */
 183 #define TRF7970A_CHIP_STATUS_CTRL               0x00
 184 #define TRF7970A_ISO_CTRL                       0x01
 185 #define TRF7970A_ISO14443B_TX_OPTIONS           0x02
 186 #define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
 187 #define TRF7970A_TX_TIMER_SETTING_H_BYTE        0x04
 188 #define TRF7970A_TX_TIMER_SETTING_L_BYTE        0x05
 189 #define TRF7970A_TX_PULSE_LENGTH_CTRL           0x06
 190 #define TRF7970A_RX_NO_RESPONSE_WAIT            0x07
 191 #define TRF7970A_RX_WAIT_TIME                   0x08
 192 #define TRF7970A_MODULATOR_SYS_CLK_CTRL         0x09
 193 #define TRF7970A_RX_SPECIAL_SETTINGS            0x0a
 194 #define TRF7970A_REG_IO_CTRL                    0x0b
 195 #define TRF7970A_IRQ_STATUS                     0x0c
 196 #define TRF7970A_COLLISION_IRQ_MASK             0x0d
 197 #define TRF7970A_COLLISION_POSITION             0x0e
 198 #define TRF7970A_RSSI_OSC_STATUS                0x0f
 199 #define TRF7970A_SPECIAL_FCN_REG1               0x10
 200 #define TRF7970A_SPECIAL_FCN_REG2               0x11
 201 #define TRF7970A_RAM1                           0x12
 202 #define TRF7970A_RAM2                           0x13
 203 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS      0x14
 204 #define TRF7970A_NFC_LOW_FIELD_LEVEL            0x16
 205 #define TRF7970A_NFCID1                         0x17
 206 #define TRF7970A_NFC_TARGET_LEVEL               0x18
 207 #define TRF79070A_NFC_TARGET_PROTOCOL           0x19
 208 #define TRF7970A_TEST_REGISTER1                 0x1a
 209 #define TRF7970A_TEST_REGISTER2                 0x1b
 210 #define TRF7970A_FIFO_STATUS                    0x1c
 211 #define TRF7970A_TX_LENGTH_BYTE1                0x1d
 212 #define TRF7970A_TX_LENGTH_BYTE2                0x1e
 213 #define TRF7970A_FIFO_IO_REGISTER               0x1f
 214
 215 /* Chip Status Control Register Bits */
 216 #define TRF7970A_CHIP_STATUS_VRS5_3             BIT(0)
 217 #define TRF7970A_CHIP_STATUS_REC_ON             BIT(1)
 218 #define TRF7970A_CHIP_STATUS_AGC_ON             BIT(2)
 219 #define TRF7970A_CHIP_STATUS_PM_ON              BIT(3)
 220 #define TRF7970A_CHIP_STATUS_RF_PWR             BIT(4)
 221 #define TRF7970A_CHIP_STATUS_RF_ON              BIT(5)
 222 #define TRF7970A_CHIP_STATUS_DIRECT             BIT(6)
 223 #define TRF7970A_CHIP_STATUS_STBY               BIT(7)
 224
 225 /* ISO Control Register Bits */
 226 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662    0x00
 227 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662  0x01
 228 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648   0x02
 229 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
 230 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a   0x04
 231 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667  0x05
 232 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669   0x06
 233 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
 234 #define TRF7970A_ISO_CTRL_14443A_106            0x08
 235 #define TRF7970A_ISO_CTRL_14443A_212            0x09
 236 #define TRF7970A_ISO_CTRL_14443A_424            0x0a
 237 #define TRF7970A_ISO_CTRL_14443A_848            0x0b
 238 #define TRF7970A_ISO_CTRL_14443B_106            0x0c
 239 #define TRF7970A_ISO_CTRL_14443B_212            0x0d
 240 #define TRF7970A_ISO_CTRL_14443B_424            0x0e
 241 #define TRF7970A_ISO_CTRL_14443B_848            0x0f
 242 #define TRF7970A_ISO_CTRL_FELICA_212            0x1a
 243 #define TRF7970A_ISO_CTRL_FELICA_424            0x1b
 244 #define TRF7970A_ISO_CTRL_NFC_NFCA_106          0x01
 245 #define TRF7970A_ISO_CTRL_NFC_NFCF_212          0x02
 246 #define TRF7970A_ISO_CTRL_NFC_NFCF_424          0x03
 247 #define TRF7970A_ISO_CTRL_NFC_CE_14443A         0x00
 248 #define TRF7970A_ISO_CTRL_NFC_CE_14443B         0x01
 249 #define TRF7970A_ISO_CTRL_NFC_CE                BIT(2)
 250 #define TRF7970A_ISO_CTRL_NFC_ACTIVE            BIT(3)
 251 #define TRF7970A_ISO_CTRL_NFC_INITIATOR         BIT(4)
 252 #define TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE       BIT(5)
 253 #define TRF7970A_ISO_CTRL_RFID                  BIT(5)
 254 #define TRF7970A_ISO_CTRL_DIR_MODE              BIT(6)
 255 #define TRF7970A_ISO_CTRL_RX_CRC_N              BIT(7)  /* true == No CRC */
 256
 257 #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK       0x1f
 258
 259 /* Modulator and SYS_CLK Control Register Bits */
 260 #define TRF7970A_MODULATOR_DEPTH(n)             ((n) & 0x7)
 261 #define TRF7970A_MODULATOR_DEPTH_ASK10          (TRF7970A_MODULATOR_DEPTH(0))
 262 #define TRF7970A_MODULATOR_DEPTH_OOK            (TRF7970A_MODULATOR_DEPTH(1))
 263 #define TRF7970A_MODULATOR_DEPTH_ASK7           (TRF7970A_MODULATOR_DEPTH(2))
 264 #define TRF7970A_MODULATOR_DEPTH_ASK8_5         (TRF7970A_MODULATOR_DEPTH(3))
 265 #define TRF7970A_MODULATOR_DEPTH_ASK13          (TRF7970A_MODULATOR_DEPTH(4))
 266 #define TRF7970A_MODULATOR_DEPTH_ASK16          (TRF7970A_MODULATOR_DEPTH(5))
 267 #define TRF7970A_MODULATOR_DEPTH_ASK22          (TRF7970A_MODULATOR_DEPTH(6))
 268 #define TRF7970A_MODULATOR_DEPTH_ASK30          (TRF7970A_MODULATOR_DEPTH(7))
 269 #define TRF7970A_MODULATOR_EN_ANA               BIT(3)
 270 #define TRF7970A_MODULATOR_CLK(n)               (((n) & 0x3) << 4)
 271 #define TRF7970A_MODULATOR_CLK_DISABLED         (TRF7970A_MODULATOR_CLK(0))
 272 #define TRF7970A_MODULATOR_CLK_3_6              (TRF7970A_MODULATOR_CLK(1))
 273 #define TRF7970A_MODULATOR_CLK_6_13             (TRF7970A_MODULATOR_CLK(2))
 274 #define TRF7970A_MODULATOR_CLK_13_27            (TRF7970A_MODULATOR_CLK(3))
 275 #define TRF7970A_MODULATOR_EN_OOK               BIT(6)
 276 #define TRF7970A_MODULATOR_27MHZ                BIT(7)
 277
 278 #define TRF7970A_RX_SPECIAL_SETTINGS_NO_LIM     BIT(0)
 279 #define TRF7970A_RX_SPECIAL_SETTINGS_AGCR       BIT(1)
 280 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_0DB     (0x0 << 2)
 281 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_5DB     (0x1 << 2)
 282 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_10DB    (0x2 << 2)
 283 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_15DB    (0x3 << 2)
 284 #define TRF7970A_RX_SPECIAL_SETTINGS_HBT        BIT(4)
 285 #define TRF7970A_RX_SPECIAL_SETTINGS_M848       BIT(5)
 286 #define TRF7970A_RX_SPECIAL_SETTINGS_C424       BIT(6)
 287 #define TRF7970A_RX_SPECIAL_SETTINGS_C212       BIT(7)
 288
 289 #define TRF7970A_REG_IO_CTRL_VRS(v)             ((v) & 0x07)
 290 #define TRF7970A_REG_IO_CTRL_IO_LOW             BIT(5)
 291 #define TRF7970A_REG_IO_CTRL_EN_EXT_PA          BIT(6)
 292 #define TRF7970A_REG_IO_CTRL_AUTO_REG           BIT(7)
 293
 294 /* IRQ Status Register Bits */
 295 #define TRF7970A_IRQ_STATUS_NORESP              BIT(0) /* ISO15693 only */
 296 #define TRF7970A_IRQ_STATUS_NFC_COL_ERROR       BIT(0)
 297 #define TRF7970A_IRQ_STATUS_COL                 BIT(1)
 298 #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR   BIT(2)
 299 #define TRF7970A_IRQ_STATUS_NFC_RF              BIT(2)
 300 #define TRF7970A_IRQ_STATUS_PARITY_ERROR        BIT(3)
 301 #define TRF7970A_IRQ_STATUS_NFC_SDD             BIT(3)
 302 #define TRF7970A_IRQ_STATUS_CRC_ERROR           BIT(4)
 303 #define TRF7970A_IRQ_STATUS_NFC_PROTO_ERROR     BIT(4)
 304 #define TRF7970A_IRQ_STATUS_FIFO                BIT(5)
 305 #define TRF7970A_IRQ_STATUS_SRX                 BIT(6)
 306 #define TRF7970A_IRQ_STATUS_TX                  BIT(7)
 307
 308 #define TRF7970A_IRQ_STATUS_ERROR                               \
 309                 (TRF7970A_IRQ_STATUS_COL |                      \
 310                  TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR |        \
 311                  TRF7970A_IRQ_STATUS_PARITY_ERROR |             \
 312                  TRF7970A_IRQ_STATUS_CRC_ERROR)
 313
 314 #define TRF7970A_RSSI_OSC_STATUS_RSSI_MASK      (BIT(2) | BIT(1) | BIT(0))
 315 #define TRF7970A_RSSI_OSC_STATUS_RSSI_X_MASK    (BIT(5) | BIT(4) | BIT(3))
 316 #define TRF7970A_RSSI_OSC_STATUS_RSSI_OSC_OK    BIT(6)
 317
 318 #define TRF7970A_SPECIAL_FCN_REG1_COL_7_6               BIT(0)
 319 #define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL           BIT(1)
 320 #define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX              BIT(2)
 321 #define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE           BIT(3)
 322 #define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US        BIT(4)
 323 #define TRF7970A_SPECIAL_FCN_REG1_PAR43                 BIT(5)
 324
 325 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124      (0x0 << 2)
 326 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120      (0x1 << 2)
 327 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112      (0x2 << 2)
 328 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96       (0x3 << 2)
 329 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4        0x0
 330 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8        0x1
 331 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16       0x2
 332 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32       0x3
 333
 334 #define TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(v)   ((v) & 0x07)
 335 #define TRF7970A_NFC_LOW_FIELD_LEVEL_CLEX_DIS   BIT(7)
 336
 337 #define TRF7970A_NFC_TARGET_LEVEL_RFDET(v)      ((v) & 0x07)
 338 #define TRF7970A_NFC_TARGET_LEVEL_HI_RF         BIT(3)
 339 #define TRF7970A_NFC_TARGET_LEVEL_SDD_EN        BIT(5)
 340 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_4BYTES   (0x0 << 6)
 341 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_7BYTES   (0x1 << 6)
 342 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_10BYTES  (0x2 << 6)
 343
 344 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106         BIT(0)
 345 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212         BIT(1)
 346 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424         (BIT(0) | BIT(1))
 347 #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B        BIT(2)
 348 #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_106           BIT(3)
 349 #define TRF79070A_NFC_TARGET_PROTOCOL_FELICA            BIT(4)
 350 #define TRF79070A_NFC_TARGET_PROTOCOL_RF_L              BIT(6)
 351 #define TRF79070A_NFC_TARGET_PROTOCOL_RF_H              BIT(7)
 352
 353 #define TRF79070A_NFC_TARGET_PROTOCOL_106A              \
 354          (TRF79070A_NFC_TARGET_PROTOCOL_RF_H |          \
 355           TRF79070A_NFC_TARGET_PROTOCOL_RF_L |          \
 356           TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 |       \
 357           TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
 358
 359 #define TRF79070A_NFC_TARGET_PROTOCOL_106B              \
 360          (TRF79070A_NFC_TARGET_PROTOCOL_RF_H |          \
 361           TRF79070A_NFC_TARGET_PROTOCOL_RF_L |          \
 362           TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B |    \
 363           TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
 364
 365 #define TRF79070A_NFC_TARGET_PROTOCOL_212F              \
 366          (TRF79070A_NFC_TARGET_PROTOCOL_RF_H |          \
 367           TRF79070A_NFC_TARGET_PROTOCOL_RF_L |          \
 368           TRF79070A_NFC_TARGET_PROTOCOL_FELICA |        \
 369           TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212)
 370
 371 #define TRF79070A_NFC_TARGET_PROTOCOL_424F              \
 372          (TRF79070A_NFC_TARGET_PROTOCOL_RF_H |          \
 373           TRF79070A_NFC_TARGET_PROTOCOL_RF_L |          \
 374           TRF79070A_NFC_TARGET_PROTOCOL_FELICA |        \
 375           TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424)
 376
 377 #define TRF7970A_FIFO_STATUS_OVERFLOW           BIT(7)
 378
 379 /* NFC (ISO/IEC 14443A) Type 2 Tag commands */
 380 #define NFC_T2T_CMD_READ                        0x30
 381
 382 /* ISO 15693 commands codes */
 383 #define ISO15693_CMD_INVENTORY                  0x01
 384 #define ISO15693_CMD_READ_SINGLE_BLOCK          0x20
 385 #define ISO15693_CMD_WRITE_SINGLE_BLOCK         0x21
 386 #define ISO15693_CMD_LOCK_BLOCK                 0x22
 387 #define ISO15693_CMD_READ_MULTIPLE_BLOCK        0x23
 388 #define ISO15693_CMD_WRITE_MULTIPLE_BLOCK       0x24
 389 #define ISO15693_CMD_SELECT                     0x25
 390 #define ISO15693_CMD_RESET_TO_READY             0x26
 391 #define ISO15693_CMD_WRITE_AFI                  0x27
 392 #define ISO15693_CMD_LOCK_AFI                   0x28
 393 #define ISO15693_CMD_WRITE_DSFID                0x29
 394 #define ISO15693_CMD_LOCK_DSFID                 0x2a
 395 #define ISO15693_CMD_GET_SYSTEM_INFO            0x2b
 396 #define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
 397
 398 /* ISO 15693 request and response flags */
 399 #define ISO15693_REQ_FLAG_SUB_CARRIER           BIT(0)
 400 #define ISO15693_REQ_FLAG_DATA_RATE             BIT(1)
 401 #define ISO15693_REQ_FLAG_INVENTORY             BIT(2)
 402 #define ISO15693_REQ_FLAG_PROTOCOL_EXT          BIT(3)
 403 #define ISO15693_REQ_FLAG_SELECT                BIT(4)
 404 #define ISO15693_REQ_FLAG_AFI                   BIT(4)
 405 #define ISO15693_REQ_FLAG_ADDRESS               BIT(5)
 406 #define ISO15693_REQ_FLAG_NB_SLOTS              BIT(5)
 407 #define ISO15693_REQ_FLAG_OPTION                BIT(6)
 408
 409 #define ISO15693_REQ_FLAG_SPEED_MASK \
 410                 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
 411
 412 enum trf7970a_state {
 413         TRF7970A_ST_PWR_OFF,
 414         TRF7970A_ST_RF_OFF,
 415         TRF7970A_ST_IDLE,
 416         TRF7970A_ST_IDLE_RX_BLOCKED,
 417         TRF7970A_ST_WAIT_FOR_TX_FIFO,
 418         TRF7970A_ST_WAIT_FOR_RX_DATA,
 419         TRF7970A_ST_WAIT_FOR_RX_DATA_CONT,
 420         TRF7970A_ST_WAIT_TO_ISSUE_EOF,
 421         TRF7970A_ST_LISTENING,
 422         TRF7970A_ST_LISTENING_MD,
 423         TRF7970A_ST_MAX
 424 };
 425
 426 struct trf7970a {
 427         enum trf7970a_state             state;
 428         struct device                   *dev;
 429         struct spi_device               *spi;
 430         struct regulator                *regulator;
 431         struct nfc_digital_dev          *ddev;
 432         u32                             quirks;
 433         bool                            is_initiator;
 434         bool                            aborting;
 435         struct sk_buff                  *tx_skb;
 436         struct sk_buff                  *rx_skb;
 437         nfc_digital_cmd_complete_t      cb;
 438         void                            *cb_arg;
 439         u8                              chip_status_ctrl;
 440         u8                              iso_ctrl;
 441         u8                              iso_ctrl_tech;
 442         u8                              modulator_sys_clk_ctrl;
 443         u8                              special_fcn_reg1;
 444         unsigned int                    guard_time;
 445         int                             technology;
 446         int                             framing;
 447         u8                              md_rf_tech;
 448         u8                              tx_cmd;
 449         bool                            issue_eof;
 450         bool                            adjust_resp_len;
 451         int                             en2_gpio;
 452         int                             en_gpio;
 453         struct mutex                    lock;
 454         unsigned int                    timeout;
 455         bool                            ignore_timeout;
 456         struct delayed_work             timeout_work;
 457 };
 458
 459
 460 static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)
 461 {
 462         u8 cmd = TRF7970A_CMD_BIT_CTRL | TRF7970A_CMD_BIT_OPCODE(opcode);
 463         int ret;
 464
 465         dev_dbg(trf->dev, "cmd: 0x%x\n", cmd);
 466
 467         ret = spi_write(trf->spi, &cmd, 1);
 468         if (ret)
 469                 dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd,
 470                                 ret);
 471         return ret;
 472 }
 473
 474 static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
 475 {
 476         u8 addr = TRF7970A_CMD_BIT_RW | reg;
 477         int ret;
 478
 479         ret = spi_write_then_read(trf->spi, &addr, 1, val, 1);
 480         if (ret)
 481                 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
 482                                 ret);
 483
 484         dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val);
 485
 486         return ret;
 487 }
 488
 489 static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf, size_t len)
 490 {
 491         u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS;
 492         struct spi_transfer t[2];
 493         struct spi_message m;
 494         int ret;
 495
 496         dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
 497
 498         spi_message_init(&m);
 499
 500         memset(&t, 0, sizeof(t));
 501
 502         t[0].tx_buf = &addr;
 503         t[0].len = sizeof(addr);
 504         spi_message_add_tail(&t[0], &m);
 505
 506         t[1].rx_buf = buf;
 507         t[1].len = len;
 508         spi_message_add_tail(&t[1], &m);
 509
 510         ret = spi_sync(trf->spi, &m);
 511         if (ret)
 512                 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
 513                                 ret);
 514         return ret;
 515 }
 516
 517 static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)
 518 {
 519         u8 buf[2] = { reg, val };
 520         int ret;
 521
 522         dev_dbg(trf->dev, "write(0x%x): 0x%x\n", reg, val);
 523
 524         ret = spi_write(trf->spi, buf, 2);
 525         if (ret)
 526                 dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__,
 527                                 buf[0], buf[1], ret);
 528
 529         return ret;
 530 }
 531
 532 static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
 533 {
 534         int ret;
 535         u8 buf[2];
 536         u8 addr;
 537
 538         addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW;
 539
 540         if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ) {
 541                 addr |= TRF7970A_CMD_BIT_CONTINUOUS;
 542                 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
 543         } else {
 544                 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 1);
 545         }
 546
 547         if (ret)
 548                 dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n",
 549                                 __func__, ret);
 550         else
 551                 *status = buf[0];
 552
 553         return ret;
 554 }
 555
 556 static int trf7970a_read_target_proto(struct trf7970a *trf, u8 *target_proto)
 557 {
 558         int ret;
 559         u8 buf[2];
 560         u8 addr;
 561
 562         addr = TRF79070A_NFC_TARGET_PROTOCOL | TRF7970A_CMD_BIT_RW |
 563                 TRF7970A_CMD_BIT_CONTINUOUS;
 564
 565         ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
 566         if (ret)
 567                 dev_err(trf->dev, "%s - target_proto: Read failed: %d\n",
 568                                 __func__, ret);
 569         else
 570                 *target_proto = buf[0];
 571
 572         return ret;
 573 }
 574
 575 static int trf7970a_mode_detect(struct trf7970a *trf, u8 *rf_tech)
 576 {
 577         int ret;
 578         u8 target_proto, tech;
 579
 580         ret = trf7970a_read_target_proto(trf, &target_proto);
 581         if (ret)
 582                 return ret;
 583
 584         switch (target_proto) {
 585         case TRF79070A_NFC_TARGET_PROTOCOL_106A:
 586                 tech = NFC_DIGITAL_RF_TECH_106A;
 587                 break;
 588         case TRF79070A_NFC_TARGET_PROTOCOL_106B:
 589                 tech = NFC_DIGITAL_RF_TECH_106B;
 590                 break;
 591         case TRF79070A_NFC_TARGET_PROTOCOL_212F:
 592                 tech = NFC_DIGITAL_RF_TECH_212F;
 593                 break;
 594         case TRF79070A_NFC_TARGET_PROTOCOL_424F:
 595                 tech = NFC_DIGITAL_RF_TECH_424F;
 596                 break;
 597         default:
 598                 dev_dbg(trf->dev, "%s - mode_detect: target_proto: 0x%x\n",
 599                                 __func__, target_proto);
 600                 return -EIO;
 601         }
 602
 603         *rf_tech = tech;
 604
 605         return ret;
 606 }
 607
 608 static void trf7970a_send_upstream(struct trf7970a *trf)
 609 {
 610         dev_kfree_skb_any(trf->tx_skb);
 611         trf->tx_skb = NULL;
 612
 613         if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)
 614                 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE,
 615                                 16, 1, trf->rx_skb->data, trf->rx_skb->len,
 616                                 false);
 617
 618         trf->state = TRF7970A_ST_IDLE;
 619
 620         if (trf->aborting) {
 621                 dev_dbg(trf->dev, "Abort process complete\n");
 622
 623                 if (!IS_ERR(trf->rx_skb)) {
 624                         kfree_skb(trf->rx_skb);
 625                         trf->rx_skb = ERR_PTR(-ECANCELED);
 626                 }
 627
 628                 trf->aborting = false;
 629         }
 630
 631         if (trf->adjust_resp_len) {
 632                 if (trf->rx_skb)
 633                         skb_trim(trf->rx_skb, trf->rx_skb->len - 1);
 634
 635                 trf->adjust_resp_len = false;
 636         }
 637
 638         trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb);
 639
 640         trf->rx_skb = NULL;
 641 }
 642
 643 static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
 644 {
 645         dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
 646
 647         cancel_delayed_work(&trf->timeout_work);
 648
 649         kfree_skb(trf->rx_skb);
 650         trf->rx_skb = ERR_PTR(errno);
 651
 652         trf7970a_send_upstream(trf);
 653 }
 654
 655 static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
 656                 unsigned int len, u8 *prefix, unsigned int prefix_len)
 657 {
 658         struct spi_transfer t[2];
 659         struct spi_message m;
 660         unsigned int timeout;
 661         int ret;
 662
 663         print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE,
 664                         16, 1, skb->data, len, false);
 665
 666         spi_message_init(&m);
 667
 668         memset(&t, 0, sizeof(t));
 669
 670         t[0].tx_buf = prefix;
 671         t[0].len = prefix_len;
 672         spi_message_add_tail(&t[0], &m);
 673
 674         t[1].tx_buf = skb->data;
 675         t[1].len = len;
 676         spi_message_add_tail(&t[1], &m);
 677
 678         ret = spi_sync(trf->spi, &m);
 679         if (ret) {
 680                 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
 681                                 ret);
 682                 return ret;
 683         }
 684
 685         skb_pull(skb, len);
 686
 687         if (skb->len > 0) {
 688                 trf->state = TRF7970A_ST_WAIT_FOR_TX_FIFO;
 689                 timeout = TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT;
 690         } else {
 691                 if (trf->issue_eof) {
 692                         trf->state = TRF7970A_ST_WAIT_TO_ISSUE_EOF;
 693                         timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF;
 694                 } else {
 695                         trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
 696
 697                         if (!trf->timeout)
 698                                 timeout = TRF7970A_WAIT_FOR_TX_IRQ;
 699                         else
 700                                 timeout = trf->timeout;
 701                 }
 702         }
 703
 704         dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout,
 705                         trf->state);
 706
 707         schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
 708
 709         return 0;
 710 }
 711
 712 static void trf7970a_fill_fifo(struct trf7970a *trf)
 713 {
 714         struct sk_buff *skb = trf->tx_skb;
 715         unsigned int len;
 716         int ret;
 717         u8 fifo_bytes;
 718         u8 prefix;
 719
 720         ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
 721         if (ret) {
 722                 trf7970a_send_err_upstream(trf, ret);
 723                 return;
 724         }
 725
 726         dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
 727
 728         fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
 729
 730         /* Calculate how much more data can be written to the fifo */
 731         len = TRF7970A_FIFO_SIZE - fifo_bytes;
 732         if (!len) {
 733                 schedule_delayed_work(&trf->timeout_work,
 734                         msecs_to_jiffies(TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT));
 735                 return;
 736         }
 737
 738         len = min(skb->len, len);
 739
 740         prefix = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_FIFO_IO_REGISTER;
 741
 742         ret = trf7970a_transmit(trf, skb, len, &prefix, sizeof(prefix));
 743         if (ret)
 744                 trf7970a_send_err_upstream(trf, ret);
 745 }
 746
 747 static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
 748 {
 749         struct sk_buff *skb = trf->rx_skb;
 750         int ret;
 751         u8 fifo_bytes;
 752
 753         if (status & TRF7970A_IRQ_STATUS_ERROR) {
 754                 trf7970a_send_err_upstream(trf, -EIO);
 755                 return;
 756         }
 757
 758         ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
 759         if (ret) {
 760                 trf7970a_send_err_upstream(trf, ret);
 761                 return;
 762         }
 763
 764         dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
 765
 766         fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
 767
 768         if (!fifo_bytes)
 769                 goto no_rx_data;
 770
 771         if (fifo_bytes > skb_tailroom(skb)) {
 772                 skb = skb_copy_expand(skb, skb_headroom(skb),
 773                                 max_t(int, fifo_bytes,
 774                                         TRF7970A_RX_SKB_ALLOC_SIZE),
 775                                 GFP_KERNEL);
 776                 if (!skb) {
 777                         trf7970a_send_err_upstream(trf, -ENOMEM);
 778                         return;
 779                 }
 780
 781                 kfree_skb(trf->rx_skb);
 782                 trf->rx_skb = skb;
 783         }
 784
 785         ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER,
 786                         skb_put(skb, fifo_bytes), fifo_bytes);
 787         if (ret) {
 788                 trf7970a_send_err_upstream(trf, ret);
 789                 return;
 790         }
 791
 792         /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
 793         if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) &&
 794                         (trf->special_fcn_reg1 ==
 795                                  TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) {
 796                 skb->data[0] >>= 4;
 797                 status = TRF7970A_IRQ_STATUS_SRX;
 798         } else {
 799                 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
 800
 801                 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
 802                 if (ret) {
 803                         trf7970a_send_err_upstream(trf, ret);
 804                         return;
 805                 }
 806
 807                 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
 808
 809                 /* If there are bytes in the FIFO, set status to '0' so
 810                  * the if stmt below doesn't fire and the driver will wait
 811                  * for the trf7970a to generate another RX interrupt.
 812                  */
 813                 if (fifo_bytes)
 814                         status = 0;
 815         }
 816
 817 no_rx_data:
 818         if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */
 819                 trf7970a_send_upstream(trf);
 820                 return;
 821         }
 822
 823         dev_dbg(trf->dev, "Setting timeout for %d ms\n",
 824                         TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT);
 825
 826         schedule_delayed_work(&trf->timeout_work,
 827                         msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT));
 828 }
 829
 830 static irqreturn_t trf7970a_irq(int irq, void *dev_id)
 831 {
 832         struct trf7970a *trf = dev_id;
 833         int ret;
 834         u8 status, fifo_bytes, iso_ctrl;
 835
 836         mutex_lock(&trf->lock);
 837
 838         if (trf->state == TRF7970A_ST_RF_OFF) {
 839                 mutex_unlock(&trf->lock);
 840                 return IRQ_NONE;
 841         }
 842
 843         ret = trf7970a_read_irqstatus(trf, &status);
 844         if (ret) {
 845                 mutex_unlock(&trf->lock);
 846                 return IRQ_NONE;
 847         }
 848
 849         dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state,
 850                         status);
 851
 852         if (!status) {
 853                 mutex_unlock(&trf->lock);
 854                 return IRQ_NONE;
 855         }
 856
 857         switch (trf->state) {
 858         case TRF7970A_ST_IDLE:
 859         case TRF7970A_ST_IDLE_RX_BLOCKED:
 860                 /* If initiator and getting interrupts caused by RF noise,
 861                  * turn off the receiver to avoid unnecessary interrupts.
 862                  * It will be turned back on in trf7970a_send_cmd() when
 863                  * the next command is issued.
 864                  */
 865                 if (trf->is_initiator && (status & TRF7970A_IRQ_STATUS_ERROR)) {
 866                         trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
 867                         trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
 868                 }
 869
 870                 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
 871                 break;
 872         case TRF7970A_ST_WAIT_FOR_TX_FIFO:
 873                 if (status & TRF7970A_IRQ_STATUS_TX) {
 874                         trf->ignore_timeout =
 875                                 !cancel_delayed_work(&trf->timeout_work);
 876                         trf7970a_fill_fifo(trf);
 877                 } else {
 878                         trf7970a_send_err_upstream(trf, -EIO);
 879                 }
 880                 break;
 881         case TRF7970A_ST_WAIT_FOR_RX_DATA:
 882         case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
 883                 if (status & TRF7970A_IRQ_STATUS_SRX) {
 884                         trf->ignore_timeout =
 885                                 !cancel_delayed_work(&trf->timeout_work);
 886                         trf7970a_drain_fifo(trf, status);
 887                 } else if (status & TRF7970A_IRQ_STATUS_FIFO) {
 888                         ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS,
 889                                         &fifo_bytes);
 890
 891                         fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
 892
 893                         if (ret)
 894                                 trf7970a_send_err_upstream(trf, ret);
 895                         else if (!fifo_bytes)
 896                                 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
 897                 } else if ((status == TRF7970A_IRQ_STATUS_TX) ||
 898                                 (!trf->is_initiator &&
 899                                  (status == (TRF7970A_IRQ_STATUS_TX |
 900                                              TRF7970A_IRQ_STATUS_NFC_RF)))) {
 901                         trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
 902
 903                         if (!trf->timeout) {
 904                                 trf->ignore_timeout = !cancel_delayed_work(
 905                                                 &trf->timeout_work);
 906                                 trf->rx_skb = ERR_PTR(0);
 907                                 trf7970a_send_upstream(trf);
 908                                 break;
 909                         }
 910
 911                         if (trf->is_initiator)
 912                                 break;
 913
 914                         iso_ctrl = trf->iso_ctrl;
 915
 916                         switch (trf->framing) {
 917                         case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
 918                                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
 919                                 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
 920                                 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
 921                                 break;
 922                         case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
 923                                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
 924                                 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
 925                                 trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
 926                                 break;
 927                         case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
 928                                 ret = trf7970a_write(trf,
 929                                         TRF7970A_SPECIAL_FCN_REG1,
 930                                         TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL);
 931                                 if (ret)
 932                                         goto err_unlock_exit;
 933
 934                                 trf->special_fcn_reg1 =
 935                                         TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL;
 936                                 break;
 937                         default:
 938                                 break;
 939                         }
 940
 941                         if (iso_ctrl != trf->iso_ctrl) {
 942                                 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
 943                                                 iso_ctrl);
 944                                 if (ret)
 945                                         goto err_unlock_exit;
 946
 947                                 trf->iso_ctrl = iso_ctrl;
 948                         }
 949                 } else {
 950                         trf7970a_send_err_upstream(trf, -EIO);
 951                 }
 952                 break;
 953         case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
 954                 if (status != TRF7970A_IRQ_STATUS_TX)
 955                         trf7970a_send_err_upstream(trf, -EIO);
 956                 break;
 957         case TRF7970A_ST_LISTENING:
 958                 if (status & TRF7970A_IRQ_STATUS_SRX) {
 959                         trf->ignore_timeout =
 960                                 !cancel_delayed_work(&trf->timeout_work);
 961                         trf7970a_drain_fifo(trf, status);
 962                 } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
 963                         trf7970a_send_err_upstream(trf, -EIO);
 964                 }
 965                 break;
 966         case TRF7970A_ST_LISTENING_MD:
 967                 if (status & TRF7970A_IRQ_STATUS_SRX) {
 968                         trf->ignore_timeout =
 969                                 !cancel_delayed_work(&trf->timeout_work);
 970
 971                         ret = trf7970a_mode_detect(trf, &trf->md_rf_tech);
 972                         if (ret) {
 973                                 trf7970a_send_err_upstream(trf, ret);
 974                         } else {
 975                                 trf->state = TRF7970A_ST_LISTENING;
 976                                 trf7970a_drain_fifo(trf, status);
 977                         }
 978                 } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
 979                         trf7970a_send_err_upstream(trf, -EIO);
 980                 }
 981                 break;
 982         default:
 983                 dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
 984                                 __func__, trf->state);
 985         }
 986
 987 err_unlock_exit:
 988         mutex_unlock(&trf->lock);
 989         return IRQ_HANDLED;
 990 }
 991
 992 static void trf7970a_issue_eof(struct trf7970a *trf)
 993 {
 994         int ret;
 995
 996         dev_dbg(trf->dev, "Issuing EOF\n");
 997
 998         ret = trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
 999         if (ret)
1000                 trf7970a_send_err_upstream(trf, ret);
1001
1002         ret = trf7970a_cmd(trf, TRF7970A_CMD_EOF);
1003         if (ret)
1004                 trf7970a_send_err_upstream(trf, ret);
1005
1006         trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
1007
1008         dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n",
1009                         trf->timeout, trf->state);
1010
1011         schedule_delayed_work(&trf->timeout_work,
1012                         msecs_to_jiffies(trf->timeout));
1013 }
1014
1015 static void trf7970a_timeout_work_handler(struct work_struct *work)
1016 {
1017         struct trf7970a *trf = container_of(work, struct trf7970a,
1018                         timeout_work.work);
1019
1020         dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n",
1021                         trf->state, trf->ignore_timeout);
1022
1023         mutex_lock(&trf->lock);
1024
1025         if (trf->ignore_timeout)
1026                 trf->ignore_timeout = false;
1027         else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
1028                 trf7970a_drain_fifo(trf, TRF7970A_IRQ_STATUS_SRX);
1029         else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
1030                 trf7970a_issue_eof(trf);
1031         else
1032                 trf7970a_send_err_upstream(trf, -ETIMEDOUT);
1033
1034         mutex_unlock(&trf->lock);
1035 }
1036
1037 static int trf7970a_init(struct trf7970a *trf)
1038 {
1039         int ret;
1040
1041         dev_dbg(trf->dev, "Initializing device - state: %d\n", trf->state);
1042
1043         ret = trf7970a_cmd(trf, TRF7970A_CMD_SOFT_INIT);
1044         if (ret)
1045                 goto err_out;
1046
1047         ret = trf7970a_cmd(trf, TRF7970A_CMD_IDLE);
1048         if (ret)
1049                 goto err_out;
1050
1051         ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
1052         if (ret)
1053                 goto err_out;
1054
1055         usleep_range(1000, 2000);
1056
1057         trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
1058
1059         ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL, 0);
1060         if (ret)
1061                 goto err_out;
1062
1063         trf->modulator_sys_clk_ctrl = 0;
1064
1065         ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
1066                         TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 |
1067                         TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32);
1068         if (ret)
1069                 goto err_out;
1070
1071         ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 0);
1072         if (ret)
1073                 goto err_out;
1074
1075         trf->special_fcn_reg1 = 0;
1076
1077         trf->iso_ctrl = 0xff;
1078         return 0;
1079
1080 err_out:
1081         dev_dbg(trf->dev, "Couldn't init device: %d\n", ret);
1082         return ret;
1083 }
1084
1085 static void trf7970a_switch_rf_off(struct trf7970a *trf)
1086 {
1087         if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1088                         (trf->state == TRF7970A_ST_RF_OFF))
1089                 return;
1090
1091         dev_dbg(trf->dev, "Switching rf off\n");
1092
1093         trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
1094
1095         trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
1096
1097         trf->aborting = false;
1098         trf->state = TRF7970A_ST_RF_OFF;
1099
1100         pm_runtime_mark_last_busy(trf->dev);
1101         pm_runtime_put_autosuspend(trf->dev);
1102 }
1103
1104 static int trf7970a_switch_rf_on(struct trf7970a *trf)
1105 {
1106         int ret;
1107
1108         dev_dbg(trf->dev, "Switching rf on\n");
1109
1110         pm_runtime_get_sync(trf->dev);
1111
1112         if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */
1113                 dev_err(trf->dev, "%s - Incorrect state: %d\n", __func__,
1114                                 trf->state);
1115                 return -EINVAL;
1116         }
1117
1118         ret = trf7970a_init(trf);
1119         if (ret) {
1120                 dev_err(trf->dev, "%s - Can't initialize: %d\n", __func__, ret);
1121                 return ret;
1122         }
1123
1124         trf->state = TRF7970A_ST_IDLE;
1125
1126         return 0;
1127 }
1128
1129 static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
1130 {
1131         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1132         int ret = 0;
1133
1134         dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
1135
1136         mutex_lock(&trf->lock);
1137
1138         if (on) {
1139                 switch (trf->state) {
1140                 case TRF7970A_ST_PWR_OFF:
1141                 case TRF7970A_ST_RF_OFF:
1142                         ret = trf7970a_switch_rf_on(trf);
1143                         break;
1144                 case TRF7970A_ST_IDLE:
1145                 case TRF7970A_ST_IDLE_RX_BLOCKED:
1146                         break;
1147                 default:
1148                         dev_err(trf->dev, "%s - Invalid request: %d %d\n",
1149                                         __func__, trf->state, on);
1150                         trf7970a_switch_rf_off(trf);
1151                         ret = -EINVAL;
1152                 }
1153         } else {
1154                 switch (trf->state) {
1155                 case TRF7970A_ST_PWR_OFF:
1156                 case TRF7970A_ST_RF_OFF:
1157                         break;
1158                 default:
1159                         dev_err(trf->dev, "%s - Invalid request: %d %d\n",
1160                                         __func__, trf->state, on);
1161                         ret = -EINVAL;
1162                         /* FALLTHROUGH */
1163                 case TRF7970A_ST_IDLE:
1164                 case TRF7970A_ST_IDLE_RX_BLOCKED:
1165                 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1166                 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1167                         trf7970a_switch_rf_off(trf);
1168                 }
1169         }
1170
1171         mutex_unlock(&trf->lock);
1172         return ret;
1173 }
1174
1175 static int trf7970a_in_config_rf_tech(struct trf7970a *trf, int tech)
1176 {
1177         int ret = 0;
1178
1179         dev_dbg(trf->dev, "rf technology: %d\n", tech);
1180
1181         switch (tech) {
1182         case NFC_DIGITAL_RF_TECH_106A:
1183                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
1184                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1185                 trf->guard_time = TRF7970A_GUARD_TIME_NFCA;
1186                 break;
1187         case NFC_DIGITAL_RF_TECH_106B:
1188                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
1189                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1190                 trf->guard_time = TRF7970A_GUARD_TIME_NFCB;
1191                 break;
1192         case NFC_DIGITAL_RF_TECH_212F:
1193                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212;
1194                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1195                 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
1196                 break;
1197         case NFC_DIGITAL_RF_TECH_424F:
1198                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424;
1199                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1200                 trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
1201                 break;
1202         case NFC_DIGITAL_RF_TECH_ISO15693:
1203                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
1204                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1205                 trf->guard_time = TRF7970A_GUARD_TIME_15693;
1206                 break;
1207         default:
1208                 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1209                 return -EINVAL;
1210         }
1211
1212         trf->technology = tech;
1213
1214         /* If in initiator mode and not changing the RF tech due to a
1215          * PSL sequence (indicated by 'trf->iso_ctrl == 0xff' from
1216          * trf7970a_init()), clear the NFC Target Detection Level register
1217          * due to erratum.
1218          */
1219         if (trf->iso_ctrl == 0xff)
1220                 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
1221
1222         return ret;
1223 }
1224
1225 static int trf7970a_is_rf_field(struct trf7970a *trf, bool *is_rf_field)
1226 {
1227         int ret;
1228         u8 rssi;
1229
1230         ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1231                         trf->chip_status_ctrl | TRF7970A_CHIP_STATUS_REC_ON);
1232         if (ret)
1233                 return ret;
1234
1235         ret = trf7970a_cmd(trf, TRF7970A_CMD_TEST_EXT_RF);
1236         if (ret)
1237                 return ret;
1238
1239         usleep_range(50, 60);
1240
1241         ret = trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
1242         if (ret)
1243                 return ret;
1244
1245         ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1246                         trf->chip_status_ctrl);
1247         if (ret)
1248                 return ret;
1249
1250         if (rssi & TRF7970A_RSSI_OSC_STATUS_RSSI_MASK)
1251                 *is_rf_field = true;
1252         else
1253                 *is_rf_field = false;
1254
1255         return 0;
1256 }
1257
1258 static int trf7970a_in_config_framing(struct trf7970a *trf, int framing)
1259 {
1260         u8 iso_ctrl = trf->iso_ctrl_tech;
1261         bool is_rf_field = false;
1262         int ret;
1263
1264         dev_dbg(trf->dev, "framing: %d\n", framing);
1265
1266         switch (framing) {
1267         case NFC_DIGITAL_FRAMING_NFCA_SHORT:
1268         case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
1269                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1270                 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
1271                 break;
1272         case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
1273         case NFC_DIGITAL_FRAMING_NFCA_T4T:
1274         case NFC_DIGITAL_FRAMING_NFCB:
1275         case NFC_DIGITAL_FRAMING_NFCB_T4T:
1276         case NFC_DIGITAL_FRAMING_NFCF:
1277         case NFC_DIGITAL_FRAMING_NFCF_T3T:
1278         case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
1279         case NFC_DIGITAL_FRAMING_ISO15693_T5T:
1280         case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
1281         case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
1282                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1283                 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
1284                 break;
1285         case NFC_DIGITAL_FRAMING_NFCA_T2T:
1286                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1287                 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
1288                 break;
1289         default:
1290                 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1291                 return -EINVAL;
1292         }
1293
1294         trf->framing = framing;
1295
1296         if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1297                 ret = trf7970a_is_rf_field(trf, &is_rf_field);
1298                 if (ret)
1299                         return ret;
1300
1301                 if (is_rf_field)
1302                         return -EBUSY;
1303         }
1304
1305         if (iso_ctrl != trf->iso_ctrl) {
1306                 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1307                 if (ret)
1308                         return ret;
1309
1310                 trf->iso_ctrl = iso_ctrl;
1311
1312                 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1313                                 trf->modulator_sys_clk_ctrl);
1314                 if (ret)
1315                         return ret;
1316         }
1317
1318         if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1319                 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1320                                 trf->chip_status_ctrl |
1321                                         TRF7970A_CHIP_STATUS_RF_ON);
1322                 if (ret)
1323                         return ret;
1324
1325                 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1326
1327                 usleep_range(trf->guard_time, trf->guard_time + 1000);
1328         }
1329
1330         return 0;
1331 }
1332
1333 static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,
1334                 int param)
1335 {
1336         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1337         int ret;
1338
1339         dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1340
1341         mutex_lock(&trf->lock);
1342
1343         trf->is_initiator = true;
1344
1345         if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1346                         (trf->state == TRF7970A_ST_RF_OFF)) {
1347                 ret = trf7970a_switch_rf_on(trf);
1348                 if (ret)
1349                         goto err_unlock;
1350         }
1351
1352         switch (type) {
1353         case NFC_DIGITAL_CONFIG_RF_TECH:
1354                 ret = trf7970a_in_config_rf_tech(trf, param);
1355                 break;
1356         case NFC_DIGITAL_CONFIG_FRAMING:
1357                 ret = trf7970a_in_config_framing(trf, param);
1358                 break;
1359         default:
1360                 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1361                 ret = -EINVAL;
1362         }
1363
1364 err_unlock:
1365         mutex_unlock(&trf->lock);
1366         return ret;
1367 }
1368
1369 static int trf7970a_is_iso15693_write_or_lock(u8 cmd)
1370 {
1371         switch (cmd) {
1372         case ISO15693_CMD_WRITE_SINGLE_BLOCK:
1373         case ISO15693_CMD_LOCK_BLOCK:
1374         case ISO15693_CMD_WRITE_MULTIPLE_BLOCK:
1375         case ISO15693_CMD_WRITE_AFI:
1376         case ISO15693_CMD_LOCK_AFI:
1377         case ISO15693_CMD_WRITE_DSFID:
1378         case ISO15693_CMD_LOCK_DSFID:
1379                 return 1;
1380                 break;
1381         default:
1382                 return 0;
1383         }
1384 }
1385
1386 static int trf7970a_per_cmd_config(struct trf7970a *trf, struct sk_buff *skb)
1387 {
1388         u8 *req = skb->data;
1389         u8 special_fcn_reg1, iso_ctrl;
1390         int ret;
1391
1392         trf->issue_eof = false;
1393
1394         /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
1395          * special functions register 1 is cleared; otherwise, its a write or
1396          * sector select command and '4_bit_RX' must be set.
1397          *
1398          * When issuing an ISO 15693 command, inspect the flags byte to see
1399          * what speed to use.  Also, remember if the OPTION flag is set on
1400          * a Type 5 write or lock command so the driver will know that it
1401          * has to send an EOF in order to get a response.
1402          */
1403         if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
1404                         (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
1405                 if (req[0] == NFC_T2T_CMD_READ)
1406                         special_fcn_reg1 = 0;
1407                 else
1408                         special_fcn_reg1 = TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX;
1409
1410                 if (special_fcn_reg1 != trf->special_fcn_reg1) {
1411                         ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
1412                                         special_fcn_reg1);
1413                         if (ret)
1414                                 return ret;
1415
1416                         trf->special_fcn_reg1 = special_fcn_reg1;
1417                 }
1418         } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
1419                 iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
1420
1421                 switch (req[0] & ISO15693_REQ_FLAG_SPEED_MASK) {
1422                 case 0x00:
1423                         iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662;
1424                         break;
1425                 case ISO15693_REQ_FLAG_SUB_CARRIER:
1426                         iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a;
1427                         break;
1428                 case ISO15693_REQ_FLAG_DATA_RATE:
1429                         iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
1430                         break;
1431                 case (ISO15693_REQ_FLAG_SUB_CARRIER |
1432                                 ISO15693_REQ_FLAG_DATA_RATE):
1433                         iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669;
1434                         break;
1435                 }
1436
1437                 if (iso_ctrl != trf->iso_ctrl) {
1438                         ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1439                         if (ret)
1440                                 return ret;
1441
1442                         trf->iso_ctrl = iso_ctrl;
1443                 }
1444
1445                 if (trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) {
1446                         if (trf7970a_is_iso15693_write_or_lock(req[1]) &&
1447                                         (req[0] & ISO15693_REQ_FLAG_OPTION))
1448                                 trf->issue_eof = true;
1449                         else if ((trf->quirks &
1450                                         TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE) &&
1451                                  (req[1] == ISO15693_CMD_READ_MULTIPLE_BLOCK))
1452                                 trf->adjust_resp_len = true;
1453                 }
1454         }
1455
1456         return 0;
1457 }
1458
1459 static int trf7970a_send_cmd(struct nfc_digital_dev *ddev,
1460                 struct sk_buff *skb, u16 timeout,
1461                 nfc_digital_cmd_complete_t cb, void *arg)
1462 {
1463         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1464         u8 prefix[5];
1465         unsigned int len;
1466         int ret;
1467         u8 status;
1468
1469         dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1470                         trf->state, timeout, skb->len);
1471
1472         if (skb->len > TRF7970A_TX_MAX)
1473                 return -EINVAL;
1474
1475         mutex_lock(&trf->lock);
1476
1477         if ((trf->state != TRF7970A_ST_IDLE) &&
1478                         (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1479                 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1480                                 trf->state);
1481                 ret = -EIO;
1482                 goto out_err;
1483         }
1484
1485         if (trf->aborting) {
1486                 dev_dbg(trf->dev, "Abort process complete\n");
1487                 trf->aborting = false;
1488                 ret = -ECANCELED;
1489                 goto out_err;
1490         }
1491
1492         if (timeout) {
1493                 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1494                                 GFP_KERNEL);
1495                 if (!trf->rx_skb) {
1496                         dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1497                         ret = -ENOMEM;
1498                         goto out_err;
1499                 }
1500         }
1501
1502         if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
1503                 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1504                 if (ret)
1505                         goto out_err;
1506
1507                 trf->state = TRF7970A_ST_IDLE;
1508         }
1509
1510         if (trf->is_initiator) {
1511                 ret = trf7970a_per_cmd_config(trf, skb);
1512                 if (ret)
1513                         goto out_err;
1514         }
1515
1516         trf->ddev = ddev;
1517         trf->tx_skb = skb;
1518         trf->cb = cb;
1519         trf->cb_arg = arg;
1520         trf->timeout = timeout;
1521         trf->ignore_timeout = false;
1522
1523         len = skb->len;
1524
1525         /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1526          * on what the current framing is, the address of the TX length byte 1
1527          * register (0x1d), and the 2 byte length of the data to be transmitted.
1528          * That totals 5 bytes.
1529          */
1530         prefix[0] = TRF7970A_CMD_BIT_CTRL |
1531                         TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET);
1532         prefix[1] = TRF7970A_CMD_BIT_CTRL |
1533                         TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
1534         prefix[2] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1;
1535
1536         if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
1537                 prefix[3] = 0x00;
1538                 prefix[4] = 0x0f; /* 7 bits */
1539         } else {
1540                 prefix[3] = (len & 0xf00) >> 4;
1541                 prefix[3] |= ((len & 0xf0) >> 4);
1542                 prefix[4] = ((len & 0x0f) << 4);
1543         }
1544
1545         len = min_t(int, skb->len, TRF7970A_FIFO_SIZE);
1546
1547         /* Clear possible spurious interrupt */
1548         ret = trf7970a_read_irqstatus(trf, &status);
1549         if (ret)
1550                 goto out_err;
1551
1552         ret = trf7970a_transmit(trf, skb, len, prefix, sizeof(prefix));
1553         if (ret) {
1554                 kfree_skb(trf->rx_skb);
1555                 trf->rx_skb = NULL;
1556         }
1557
1558 out_err:
1559         mutex_unlock(&trf->lock);
1560         return ret;
1561 }
1562
1563 static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)
1564 {
1565         int ret = 0;
1566
1567         dev_dbg(trf->dev, "rf technology: %d\n", tech);
1568
1569         switch (tech) {
1570         case NFC_DIGITAL_RF_TECH_106A:
1571                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1572                         TRF7970A_ISO_CTRL_NFC_CE |
1573                         TRF7970A_ISO_CTRL_NFC_CE_14443A;
1574                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
1575                 break;
1576         case NFC_DIGITAL_RF_TECH_212F:
1577                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1578                         TRF7970A_ISO_CTRL_NFC_NFCF_212;
1579                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1580                 break;
1581         case NFC_DIGITAL_RF_TECH_424F:
1582                 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
1583                         TRF7970A_ISO_CTRL_NFC_NFCF_424;
1584                 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
1585                 break;
1586         default:
1587                 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
1588                 return -EINVAL;
1589         }
1590
1591         trf->technology = tech;
1592
1593         /* Normally we write the ISO_CTRL register in
1594          * trf7970a_tg_config_framing() because the framing can change
1595          * the value written.  However, when sending a PSL RES,
1596          * digital_tg_send_psl_res_complete() doesn't call
1597          * trf7970a_tg_config_framing() so we must write the register
1598          * here.
1599          */
1600         if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&
1601                         (trf->iso_ctrl_tech != trf->iso_ctrl)) {
1602                 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
1603                                 trf->iso_ctrl_tech);
1604
1605                 trf->iso_ctrl = trf->iso_ctrl_tech;
1606         }
1607
1608         return ret;
1609 }
1610
1611 /* Since this is a target routine, several of the framing calls are
1612  * made between receiving the request and sending the response so they
1613  * should take effect until after the response is sent.  This is accomplished
1614  * by skipping the ISO_CTRL register write here and doing it in the interrupt
1615  * handler.
1616  */
1617 static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)
1618 {
1619         u8 iso_ctrl = trf->iso_ctrl_tech;
1620         int ret;
1621
1622         dev_dbg(trf->dev, "framing: %d\n", framing);
1623
1624         switch (framing) {
1625         case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
1626                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
1627                 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
1628                 break;
1629         case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
1630         case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
1631         case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
1632                 /* These ones are applied in the interrupt handler */
1633                 iso_ctrl = trf->iso_ctrl; /* Don't write to ISO_CTRL yet */
1634                 break;
1635         case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
1636                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1637                 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
1638                 break;
1639         case NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED:
1640                 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
1641                 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
1642                 break;
1643         default:
1644                 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
1645                 return -EINVAL;
1646         }
1647
1648         trf->framing = framing;
1649
1650         if (iso_ctrl != trf->iso_ctrl) {
1651                 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1652                 if (ret)
1653                         return ret;
1654
1655                 trf->iso_ctrl = iso_ctrl;
1656
1657                 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
1658                                 trf->modulator_sys_clk_ctrl);
1659                 if (ret)
1660                         return ret;
1661         }
1662
1663         if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
1664                 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
1665                                 trf->chip_status_ctrl |
1666                                         TRF7970A_CHIP_STATUS_RF_ON);
1667                 if (ret)
1668                         return ret;
1669
1670                 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
1671         }
1672
1673         return 0;
1674 }
1675
1676 static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, int type,
1677                 int param)
1678 {
1679         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1680         int ret;
1681
1682         dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
1683
1684         mutex_lock(&trf->lock);
1685
1686         trf->is_initiator = false;
1687
1688         if ((trf->state == TRF7970A_ST_PWR_OFF) ||
1689                         (trf->state == TRF7970A_ST_RF_OFF)) {
1690                 ret = trf7970a_switch_rf_on(trf);
1691                 if (ret)
1692                         goto err_unlock;
1693         }
1694
1695         switch (type) {
1696         case NFC_DIGITAL_CONFIG_RF_TECH:
1697                 ret = trf7970a_tg_config_rf_tech(trf, param);
1698                 break;
1699         case NFC_DIGITAL_CONFIG_FRAMING:
1700                 ret = trf7970a_tg_config_framing(trf, param);
1701                 break;
1702         default:
1703                 dev_dbg(trf->dev, "Unknown type: %d\n", type);
1704                 ret = -EINVAL;
1705         }
1706
1707 err_unlock:
1708         mutex_unlock(&trf->lock);
1709         return ret;
1710 }
1711
1712 static int _trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
1713                 nfc_digital_cmd_complete_t cb, void *arg, bool mode_detect)
1714 {
1715         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1716         int ret;
1717
1718         mutex_lock(&trf->lock);
1719
1720         if ((trf->state != TRF7970A_ST_IDLE) &&
1721                         (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1722                 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1723                                 trf->state);
1724                 ret = -EIO;
1725                 goto out_err;
1726         }
1727
1728         if (trf->aborting) {
1729                 dev_dbg(trf->dev, "Abort process complete\n");
1730                 trf->aborting = false;
1731                 ret = -ECANCELED;
1732                 goto out_err;
1733         }
1734
1735         trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1736                         GFP_KERNEL);
1737         if (!trf->rx_skb) {
1738                 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1739                 ret = -ENOMEM;
1740                 goto out_err;
1741         }
1742
1743         ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS,
1744                         TRF7970A_RX_SPECIAL_SETTINGS_HBT |
1745                         TRF7970A_RX_SPECIAL_SETTINGS_M848 |
1746                         TRF7970A_RX_SPECIAL_SETTINGS_C424 |
1747                         TRF7970A_RX_SPECIAL_SETTINGS_C212);
1748         if (ret)
1749                 goto out_err;
1750
1751         ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
1752                         TRF7970A_REG_IO_CTRL_VRS(0x1));
1753         if (ret)
1754                 goto out_err;
1755
1756         ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL,
1757                         TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3));
1758         if (ret)
1759                 goto out_err;
1760
1761         ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL,
1762                         TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7));
1763         if (ret)
1764                 goto out_err;
1765
1766         trf->ddev = ddev;
1767         trf->cb = cb;
1768         trf->cb_arg = arg;
1769         trf->timeout = timeout;
1770         trf->ignore_timeout = false;
1771
1772         ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1773         if (ret)
1774                 goto out_err;
1775
1776         trf->state = mode_detect ? TRF7970A_ST_LISTENING_MD :
1777                                    TRF7970A_ST_LISTENING;
1778
1779         schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
1780
1781 out_err:
1782         mutex_unlock(&trf->lock);
1783         return ret;
1784 }
1785
1786 static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
1787                 nfc_digital_cmd_complete_t cb, void *arg)
1788 {
1789         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1790
1791         dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n",
1792                         trf->state, timeout);
1793
1794         return _trf7970a_tg_listen(ddev, timeout, cb, arg, false);
1795 }
1796
1797 static int trf7970a_tg_listen_md(struct nfc_digital_dev *ddev,
1798                 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1799 {
1800         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1801         int ret;
1802
1803         dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n",
1804                         trf->state, timeout);
1805
1806         ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1807                         NFC_DIGITAL_RF_TECH_106A);
1808         if (ret)
1809                 return ret;
1810
1811         ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1812                         NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1813         if (ret)
1814                 return ret;
1815
1816         return _trf7970a_tg_listen(ddev, timeout, cb, arg, true);
1817 }
1818
1819 static int trf7970a_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)
1820 {
1821         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1822
1823         dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n",
1824                         trf->state, trf->md_rf_tech);
1825
1826         *rf_tech = trf->md_rf_tech;
1827
1828         return 0;
1829 }
1830
1831 static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
1832 {
1833         struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1834
1835         dev_dbg(trf->dev, "Abort process initiated\n");
1836
1837         mutex_lock(&trf->lock);
1838
1839         switch (trf->state) {
1840         case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1841         case TRF7970A_ST_WAIT_FOR_RX_DATA:
1842         case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1843         case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1844                 trf->aborting = true;
1845                 break;
1846         case TRF7970A_ST_LISTENING:
1847                 trf->ignore_timeout = !cancel_delayed_work(&trf->timeout_work);
1848                 trf7970a_send_err_upstream(trf, -ECANCELED);
1849                 dev_dbg(trf->dev, "Abort process complete\n");
1850                 break;
1851         default:
1852                 break;
1853         }
1854
1855         mutex_unlock(&trf->lock);
1856 }
1857
1858 static struct nfc_digital_ops trf7970a_nfc_ops = {
1859         .in_configure_hw        = trf7970a_in_configure_hw,
1860         .in_send_cmd            = trf7970a_send_cmd,
1861         .tg_configure_hw        = trf7970a_tg_configure_hw,
1862         .tg_send_cmd            = trf7970a_send_cmd,
1863         .tg_listen              = trf7970a_tg_listen,
1864         .tg_listen_md           = trf7970a_tg_listen_md,
1865         .tg_get_rf_tech         = trf7970a_tg_get_rf_tech,
1866         .switch_rf              = trf7970a_switch_rf,
1867         .abort_cmd              = trf7970a_abort_cmd,
1868 };
1869
1870 static int trf7970a_power_up(struct trf7970a *trf)
1871 {
1872         int ret;
1873
1874         dev_dbg(trf->dev, "Powering up - state: %d\n", trf->state);
1875
1876         if (trf->state != TRF7970A_ST_PWR_OFF)
1877                 return 0;
1878
1879         ret = regulator_enable(trf->regulator);
1880         if (ret) {
1881                 dev_err(trf->dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1882                 return ret;
1883         }
1884
1885         usleep_range(5000, 6000);
1886
1887         if (!(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) {
1888                 gpio_set_value(trf->en2_gpio, 1);
1889                 usleep_range(1000, 2000);
1890         }
1891
1892         gpio_set_value(trf->en_gpio, 1);
1893
1894         usleep_range(20000, 21000);
1895
1896         trf->state = TRF7970A_ST_RF_OFF;
1897
1898         return 0;
1899 }
1900
1901 static int trf7970a_power_down(struct trf7970a *trf)
1902 {
1903         int ret;
1904
1905         dev_dbg(trf->dev, "Powering down - state: %d\n", trf->state);
1906
1907         if (trf->state == TRF7970A_ST_PWR_OFF)
1908                 return 0;
1909
1910         if (trf->state != TRF7970A_ST_RF_OFF) {
1911                 dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n",
1912                                 trf->state);
1913                 return -EBUSY;
1914         }
1915
1916         gpio_set_value(trf->en_gpio, 0);
1917         gpio_set_value(trf->en2_gpio, 0);
1918
1919         ret = regulator_disable(trf->regulator);
1920         if (ret)
1921                 dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__,
1922                                 ret);
1923
1924         trf->state = TRF7970A_ST_PWR_OFF;
1925
1926         return ret;
1927 }
1928
1929 static int trf7970a_startup(struct trf7970a *trf)
1930 {
1931         int ret;
1932
1933         ret = trf7970a_power_up(trf);
1934         if (ret)
1935                 return ret;
1936
1937         pm_runtime_set_active(trf->dev);
1938         pm_runtime_enable(trf->dev);
1939         pm_runtime_mark_last_busy(trf->dev);
1940
1941         return 0;
1942 }
1943
1944 static void trf7970a_shutdown(struct trf7970a *trf)
1945 {
1946         switch (trf->state) {
1947         case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1948         case TRF7970A_ST_WAIT_FOR_RX_DATA:
1949         case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1950         case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1951         case TRF7970A_ST_LISTENING:
1952                 trf7970a_send_err_upstream(trf, -ECANCELED);
1953                 /* FALLTHROUGH */
1954         case TRF7970A_ST_IDLE:
1955         case TRF7970A_ST_IDLE_RX_BLOCKED:
1956                 trf7970a_switch_rf_off(trf);
1957                 break;
1958         default:
1959                 break;
1960         }
1961
1962         pm_runtime_disable(trf->dev);
1963         pm_runtime_set_suspended(trf->dev);
1964
1965         trf7970a_power_down(trf);
1966 }
1967
1968 static int trf7970a_get_autosuspend_delay(struct device_node *np)
1969 {
1970         int autosuspend_delay, ret;
1971
1972         ret = of_property_read_u32(np, "autosuspend-delay", &autosuspend_delay);
1973         if (ret)
1974                 autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY;
1975
1976         return autosuspend_delay;
1977 }
1978
1979 static int trf7970a_get_vin_voltage_override(struct device_node *np,
1980                 u32 *vin_uvolts)
1981 {
1982         return of_property_read_u32(np, "vin-voltage-override", vin_uvolts);
1983 }
1984
1985 static int trf7970a_probe(struct spi_device *spi)
1986 {
1987         struct device_node *np = spi->dev.of_node;
1988         struct trf7970a *trf;
1989         int uvolts, autosuspend_delay, ret;
1990
1991         if (!np) {
1992                 dev_err(&spi->dev, "No Device Tree entry\n");
1993                 return -EINVAL;
1994         }
1995
1996         trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
1997         if (!trf)
1998                 return -ENOMEM;
1999
2000         trf->state = TRF7970A_ST_PWR_OFF;
2001         trf->dev = &spi->dev;
2002         trf->spi = spi;
2003
2004         spi->mode = SPI_MODE_1;
2005         spi->bits_per_word = 8;
2006
2007         ret = spi_setup(spi);
2008         if (ret < 0) {
2009                 dev_err(trf->dev, "Can't set up SPI Communication\n");
2010                 return ret;
2011         }
2012
2013         if (of_property_read_bool(np, "t5t-rmb-extra-byte-quirk"))
2014                 trf->quirks |= TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE;
2015
2016         if (of_property_read_bool(np, "irq-status-read-quirk"))
2017                 trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ;
2018
2019         /* There are two enable pins - both must be present */
2020         trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0);
2021         if (!gpio_is_valid(trf->en_gpio)) {
2022                 dev_err(trf->dev, "No EN GPIO property\n");
2023                 return trf->en_gpio;
2024         }
2025
2026         ret = devm_gpio_request_one(trf->dev, trf->en_gpio,
2027                         GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN");
2028         if (ret) {
2029                 dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret);
2030                 return ret;
2031         }
2032
2033         trf->en2_gpio = of_get_named_gpio(np, "ti,enable-gpios", 1);
2034         if (!gpio_is_valid(trf->en2_gpio)) {
2035                 dev_err(trf->dev, "No EN2 GPIO property\n");
2036                 return trf->en2_gpio;
2037         }
2038
2039         ret = devm_gpio_request_one(trf->dev, trf->en2_gpio,
2040                         GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN2");
2041         if (ret) {
2042                 dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret);
2043                 return ret;
2044         }
2045
2046         if (of_property_read_bool(np, "en2-rf-quirk"))
2047                 trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW;
2048
2049         ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
2050                         trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2051                         "trf7970a", trf);
2052         if (ret) {
2053                 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
2054                 return ret;
2055         }
2056
2057         mutex_init(&trf->lock);
2058         INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
2059
2060         trf->regulator = devm_regulator_get(&spi->dev, "vin");
2061         if (IS_ERR(trf->regulator)) {
2062                 ret = PTR_ERR(trf->regulator);
2063                 dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
2064                 goto err_destroy_lock;
2065         }
2066
2067         ret = regulator_enable(trf->regulator);
2068         if (ret) {
2069                 dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
2070                 goto err_destroy_lock;
2071         }
2072
2073         ret = trf7970a_get_vin_voltage_override(np, &uvolts);
2074         if (ret)
2075                 uvolts = regulator_get_voltage(trf->regulator);
2076
2077         if (uvolts > 4000000)
2078                 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
2079
2080         trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
2081                         TRF7970A_SUPPORTED_PROTOCOLS,
2082                         NFC_DIGITAL_DRV_CAPS_IN_CRC |
2083                                 NFC_DIGITAL_DRV_CAPS_TG_CRC, 0, 0);
2084         if (!trf->ddev) {
2085                 dev_err(trf->dev, "Can't allocate NFC digital device\n");
2086                 ret = -ENOMEM;
2087                 goto err_disable_regulator;
2088         }
2089
2090         nfc_digital_set_parent_dev(trf->ddev, trf->dev);
2091         nfc_digital_set_drvdata(trf->ddev, trf);
2092         spi_set_drvdata(spi, trf);
2093
2094         autosuspend_delay = trf7970a_get_autosuspend_delay(np);
2095
2096         pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
2097         pm_runtime_use_autosuspend(trf->dev);
2098
2099         ret = trf7970a_startup(trf);
2100         if (ret)
2101                 goto err_free_ddev;
2102
2103         ret = nfc_digital_register_device(trf->ddev);
2104         if (ret) {
2105                 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
2106                                 ret);
2107                 goto err_shutdown;
2108         }
2109
2110         return 0;
2111
2112 err_shutdown:
2113         trf7970a_shutdown(trf);
2114 err_free_ddev:
2115         nfc_digital_free_device(trf->ddev);
2116 err_disable_regulator:
2117         regulator_disable(trf->regulator);
2118 err_destroy_lock:
2119         mutex_destroy(&trf->lock);
2120         return ret;
2121 }
2122
2123 static int trf7970a_remove(struct spi_device *spi)
2124 {
2125         struct trf7970a *trf = spi_get_drvdata(spi);
2126
2127         mutex_lock(&trf->lock);
2128
2129         trf7970a_shutdown(trf);
2130
2131         mutex_unlock(&trf->lock);
2132
2133         nfc_digital_unregister_device(trf->ddev);
2134         nfc_digital_free_device(trf->ddev);
2135
2136         regulator_disable(trf->regulator);
2137
2138         mutex_destroy(&trf->lock);
2139
2140         return 0;
2141 }
2142
2143 #ifdef CONFIG_PM_SLEEP
2144 static int trf7970a_suspend(struct device *dev)
2145 {
2146         struct spi_device *spi = to_spi_device(dev);
2147         struct trf7970a *trf = spi_get_drvdata(spi);
2148
2149         dev_dbg(dev, "Suspend\n");
2150
2151         mutex_lock(&trf->lock);
2152
2153         trf7970a_shutdown(trf);
2154
2155         mutex_unlock(&trf->lock);
2156
2157         return 0;
2158 }
2159
2160 static int trf7970a_resume(struct device *dev)
2161 {
2162         struct spi_device *spi = to_spi_device(dev);
2163         struct trf7970a *trf = spi_get_drvdata(spi);
2164         int ret;
2165
2166         dev_dbg(dev, "Resume\n");
2167
2168         mutex_lock(&trf->lock);
2169
2170         ret = trf7970a_startup(trf);
2171
2172         mutex_unlock(&trf->lock);
2173
2174         return ret;
2175 }
2176 #endif
2177
2178 #ifdef CONFIG_PM
2179 static int trf7970a_pm_runtime_suspend(struct device *dev)
2180 {
2181         struct spi_device *spi = to_spi_device(dev);
2182         struct trf7970a *trf = spi_get_drvdata(spi);
2183         int ret;
2184
2185         dev_dbg(dev, "Runtime suspend\n");
2186
2187         mutex_lock(&trf->lock);
2188
2189         ret = trf7970a_power_down(trf);
2190
2191         mutex_unlock(&trf->lock);
2192
2193         return ret;
2194 }
2195
2196 static int trf7970a_pm_runtime_resume(struct device *dev)
2197 {
2198         struct spi_device *spi = to_spi_device(dev);
2199         struct trf7970a *trf = spi_get_drvdata(spi);
2200         int ret;
2201
2202         dev_dbg(dev, "Runtime resume\n");
2203
2204         ret = trf7970a_power_up(trf);
2205         if (!ret)
2206                 pm_runtime_mark_last_busy(dev);
2207
2208         return ret;
2209 }
2210 #endif
2211
2212 static const struct dev_pm_ops trf7970a_pm_ops = {
2213         SET_SYSTEM_SLEEP_PM_OPS(trf7970a_suspend, trf7970a_resume)
2214         SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend,
2215                         trf7970a_pm_runtime_resume, NULL)
2216 };
2217
2218 static const struct of_device_id trf7970a_of_match[] = {
2219         { .compatible = "ti,trf7970a", },
2220         { /* sentinel */ },
2221 };
2222 MODULE_DEVICE_TABLE(of, trf7970a_of_match);
2223
2224 static const struct spi_device_id trf7970a_id_table[] = {
2225         { "trf7970a", 0 },
2226         { }
2227 };
2228 MODULE_DEVICE_TABLE(spi, trf7970a_id_table);
2229
2230 static struct spi_driver trf7970a_spi_driver = {
2231         .probe          = trf7970a_probe,
2232         .remove         = trf7970a_remove,
2233         .id_table       = trf7970a_id_table,
2234         .driver         = {
2235                 .name   = "trf7970a",
2236                 .of_match_table = of_match_ptr(trf7970a_of_match),
2237                 .pm     = &trf7970a_pm_ops,
2238         },
2239 };
2240
2241 module_spi_driver(trf7970a_spi_driver);
2242
2243 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
2244 MODULE_LICENSE("GPL v2");
2245 MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");