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"); 2246