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