2 * TI TRF7970a RFID/NFC Transceiver Driver
4 * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
6 * Author: Erick Macias <emacias@ti.com>
7 * Author: Felipe Balbi <balbi@ti.com>
8 * Author: Mark A. Greer <mgreer@animalcreek.com>
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.
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>
25 #include <linux/of_gpio.h>
26 #include <linux/spi/spi.h>
27 #include <linux/regulator/consumer.h>
29 #include <net/nfc/nfc.h>
30 #include <net/nfc/digital.h>
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.
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.
41 * Timeouts are implemented using the delayed workqueue kernel facility.
42 * Timeouts are required so things don't hang when there is no response
43 * from the trf7970a (or tag). Using this mechanism creates a race with
44 * interrupts, however. That is, an interrupt and a timeout could occur
45 * closely enough together that one is blocked by the mutex while the other
46 * executes. When the timeout handler executes first and blocks the
47 * interrupt handler, it will eventually set the state to IDLE so the
48 * interrupt handler will check the state and exit with no harm done.
49 * When the interrupt handler executes first and blocks the timeout handler,
50 * the cancel_delayed_work() call will know that it didn't cancel the
51 * work item (i.e., timeout) and will return zero. That return code is
52 * used by the timer handler to indicate that it should ignore the timeout
55 * Aborting an active command isn't as simple as it seems because the only
56 * way to abort a command that's already been sent to the tag is so turn
57 * off power to the tag. If we do that, though, we'd have to go through
58 * the entire anticollision procedure again but the digital layer doesn't
59 * support that. So, if an abort is received before trf7970a_in_send_cmd()
60 * has sent the command to the tag, it simply returns -ECANCELED. If the
61 * command has already been sent to the tag, then the driver continues
62 * normally and recieves the response data (or error) but just before
63 * sending the data upstream, it frees the rx_skb and sends -ECANCELED
64 * upstream instead. If the command failed, that error will be sent
67 * When recieving data from a tag and the interrupt status register has
68 * only the SRX bit set, it means that all of the data has been received
69 * (once what's in the fifo has been read). However, depending on timing
70 * an interrupt status with only the SRX bit set may not be recived. In
71 * those cases, the timeout mechanism is used to wait 20 ms in case more
72 * data arrives. After 20 ms, it is assumed that all of the data has been
73 * received and the accumulated rx data is sent upstream. The
74 * 'TRF7970A_ST_WAIT_FOR_RX_DATA_CONT' state is used for this purpose
75 * (i.e., it indicates that some data has been received but we're not sure
76 * if there is more coming so a timeout in this state means all data has
77 * been received and there isn't an error). The delay is 20 ms since delays
78 * of ~16 ms have been observed during testing.
80 * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
81 * Having only 4 bits in the FIFO won't normally generate an interrupt so
82 * driver enables the '4_bit_RX' bit of the Special Functions register 1
83 * to cause an interrupt in that case. Leaving that bit for a read command
84 * messes up the data returned so it is only enabled when the framing is
85 * 'NFC_DIGITAL_FRAMING_NFCA_T2T' and the command is not a read command.
86 * Unfortunately, that means that the driver has to peek into tx frames
87 * when the framing is 'NFC_DIGITAL_FRAMING_NFCA_T2T'. This is done by
88 * the trf7970a_per_cmd_config() routine.
90 * ISO/IEC 15693 frames specify whether to use single or double sub-carrier
91 * frequencies and whether to use low or high data rates in the flags byte
92 * of the frame. This means that the driver has to peek at all 15693 frames
93 * to determine what speed to set the communication to. In addition, write
94 * and lock commands use the OPTION flag to indicate that an EOF must be
95 * sent to the tag before it will send its response. So the driver has to
96 * examine all frames for that reason too.
98 * It is unclear how long to wait before sending the EOF. According to the
99 * Note under Table 1-1 in section 1.6 of
100 * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
101 * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
102 * enough. For this reason, the driver waits 20 ms which seems to work
106 #define TRF7970A_SUPPORTED_PROTOCOLS \
107 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \
108 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_ISO15693_MASK)
110 #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
112 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
113 * on what the current framing is, the address of the TX length byte 1
114 * register (0x1d), and the 2 byte length of the data to be transmitted.
115 * That totals 5 bytes.
117 #define TRF7970A_TX_SKB_HEADROOM 5
119 #define TRF7970A_RX_SKB_ALLOC_SIZE 256
121 #define TRF7970A_FIFO_SIZE 128
123 /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
124 #define TRF7970A_TX_MAX (4096 - 1)
126 #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
127 #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 3
128 #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 20
131 /* Erratum: When reading IRQ Status register on trf7970a, we must issue a
132 * read continuous command for IRQ Status and Collision Position registers.
134 #define TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA BIT(0)
136 /* Direct commands */
137 #define TRF7970A_CMD_IDLE 0x00
138 #define TRF7970A_CMD_SOFT_INIT 0x03
139 #define TRF7970A_CMD_RF_COLLISION 0x04
140 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0x05
141 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0x06
142 #define TRF7970A_CMD_FIFO_RESET 0x0f
143 #define TRF7970A_CMD_TRANSMIT_NO_CRC 0x10
144 #define TRF7970A_CMD_TRANSMIT 0x11
145 #define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0x12
146 #define TRF7970A_CMD_DELAY_TRANSMIT 0x13
147 #define TRF7970A_CMD_EOF 0x14
148 #define TRF7970A_CMD_CLOSE_SLOT 0x15
149 #define TRF7970A_CMD_BLOCK_RX 0x16
150 #define TRF7970A_CMD_ENABLE_RX 0x17
151 #define TRF7970A_CMD_TEST_EXT_RF 0x18
152 #define TRF7970A_CMD_TEST_INT_RF 0x19
153 #define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
155 /* Bits determining whether its a direct command or register R/W,
156 * whether to use a continuous SPI transaction or not, and the actual
157 * direct cmd opcode or regster address.
159 #define TRF7970A_CMD_BIT_CTRL BIT(7)
160 #define TRF7970A_CMD_BIT_RW BIT(6)
161 #define TRF7970A_CMD_BIT_CONTINUOUS BIT(5)
162 #define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0x1f)
164 /* Registers addresses */
165 #define TRF7970A_CHIP_STATUS_CTRL 0x00
166 #define TRF7970A_ISO_CTRL 0x01
167 #define TRF7970A_ISO14443B_TX_OPTIONS 0x02
168 #define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
169 #define TRF7970A_TX_TIMER_SETTING_H_BYTE 0x04
170 #define TRF7970A_TX_TIMER_SETTING_L_BYTE 0x05
171 #define TRF7970A_TX_PULSE_LENGTH_CTRL 0x06
172 #define TRF7970A_RX_NO_RESPONSE_WAIT 0x07
173 #define TRF7970A_RX_WAIT_TIME 0x08
174 #define TRF7970A_MODULATOR_SYS_CLK_CTRL 0x09
175 #define TRF7970A_RX_SPECIAL_SETTINGS 0x0a
176 #define TRF7970A_REG_IO_CTRL 0x0b
177 #define TRF7970A_IRQ_STATUS 0x0c
178 #define TRF7970A_COLLISION_IRQ_MASK 0x0d
179 #define TRF7970A_COLLISION_POSITION 0x0e
180 #define TRF7970A_RSSI_OSC_STATUS 0x0f
181 #define TRF7970A_SPECIAL_FCN_REG1 0x10
182 #define TRF7970A_SPECIAL_FCN_REG2 0x11
183 #define TRF7970A_RAM1 0x12
184 #define TRF7970A_RAM2 0x13
185 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0x14
186 #define TRF7970A_NFC_LOW_FIELD_LEVEL 0x16
187 #define TRF7970A_NFCID1 0x17
188 #define TRF7970A_NFC_TARGET_LEVEL 0x18
189 #define TRF79070A_NFC_TARGET_PROTOCOL 0x19
190 #define TRF7970A_TEST_REGISTER1 0x1a
191 #define TRF7970A_TEST_REGISTER2 0x1b
192 #define TRF7970A_FIFO_STATUS 0x1c
193 #define TRF7970A_TX_LENGTH_BYTE1 0x1d
194 #define TRF7970A_TX_LENGTH_BYTE2 0x1e
195 #define TRF7970A_FIFO_IO_REGISTER 0x1f
197 /* Chip Status Control Register Bits */
198 #define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0)
199 #define TRF7970A_CHIP_STATUS_REC_ON BIT(1)
200 #define TRF7970A_CHIP_STATUS_AGC_ON BIT(2)
201 #define TRF7970A_CHIP_STATUS_PM_ON BIT(3)
202 #define TRF7970A_CHIP_STATUS_RF_PWR BIT(4)
203 #define TRF7970A_CHIP_STATUS_RF_ON BIT(5)
204 #define TRF7970A_CHIP_STATUS_DIRECT BIT(6)
205 #define TRF7970A_CHIP_STATUS_STBY BIT(7)
207 /* ISO Control Register Bits */
208 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0x00
209 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0x01
210 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0x02
211 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
212 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0x04
213 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0x05
214 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0x06
215 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
216 #define TRF7970A_ISO_CTRL_14443A_106 0x08
217 #define TRF7970A_ISO_CTRL_14443A_212 0x09
218 #define TRF7970A_ISO_CTRL_14443A_424 0x0a
219 #define TRF7970A_ISO_CTRL_14443A_848 0x0b
220 #define TRF7970A_ISO_CTRL_14443B_106 0x0c
221 #define TRF7970A_ISO_CTRL_14443B_212 0x0d
222 #define TRF7970A_ISO_CTRL_14443B_424 0x0e
223 #define TRF7970A_ISO_CTRL_14443B_848 0x0f
224 #define TRF7970A_ISO_CTRL_FELICA_212 0x1a
225 #define TRF7970A_ISO_CTRL_FELICA_424 0x1b
226 #define TRF7970A_ISO_CTRL_RFID BIT(5)
227 #define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
228 #define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
230 #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0x1f
232 /* Modulator and SYS_CLK Control Register Bits */
233 #define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0x7)
234 #define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0))
235 #define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1))
236 #define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2))
237 #define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3))
238 #define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4))
239 #define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5))
240 #define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6))
241 #define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7))
242 #define TRF7970A_MODULATOR_EN_ANA BIT(3)
243 #define TRF7970A_MODULATOR_CLK(n) (((n) & 0x3) << 4)
244 #define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0))
245 #define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1))
246 #define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2))
247 #define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3))
248 #define TRF7970A_MODULATOR_EN_OOK BIT(6)
249 #define TRF7970A_MODULATOR_27MHZ BIT(7)
251 /* IRQ Status Register Bits */
252 #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
253 #define TRF7970A_IRQ_STATUS_COL BIT(1)
254 #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
255 #define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
256 #define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
257 #define TRF7970A_IRQ_STATUS_FIFO BIT(5)
258 #define TRF7970A_IRQ_STATUS_SRX BIT(6)
259 #define TRF7970A_IRQ_STATUS_TX BIT(7)
261 #define TRF7970A_IRQ_STATUS_ERROR \
262 (TRF7970A_IRQ_STATUS_COL | \
263 TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR | \
264 TRF7970A_IRQ_STATUS_PARITY_ERROR | \
265 TRF7970A_IRQ_STATUS_CRC_ERROR)
267 #define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
268 #define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
269 #define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
270 #define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3)
271 #define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4)
272 #define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5)
274 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0x0 << 2)
275 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0x1 << 2)
276 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0x2 << 2)
277 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0x3 << 2)
278 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0x0
279 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0x1
280 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
281 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
283 #define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
285 /* NFC (ISO/IEC 14443A) Type 2 Tag commands */
286 #define NFC_T2T_CMD_READ 0x30
288 /* ISO 15693 commands codes */
289 #define ISO15693_CMD_INVENTORY 0x01
290 #define ISO15693_CMD_READ_SINGLE_BLOCK 0x20
291 #define ISO15693_CMD_WRITE_SINGLE_BLOCK 0x21
292 #define ISO15693_CMD_LOCK_BLOCK 0x22
293 #define ISO15693_CMD_READ_MULTIPLE_BLOCK 0x23
294 #define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0x24
295 #define ISO15693_CMD_SELECT 0x25
296 #define ISO15693_CMD_RESET_TO_READY 0x26
297 #define ISO15693_CMD_WRITE_AFI 0x27
298 #define ISO15693_CMD_LOCK_AFI 0x28
299 #define ISO15693_CMD_WRITE_DSFID 0x29
300 #define ISO15693_CMD_LOCK_DSFID 0x2a
301 #define ISO15693_CMD_GET_SYSTEM_INFO 0x2b
302 #define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
304 /* ISO 15693 request and response flags */
305 #define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0)
306 #define ISO15693_REQ_FLAG_DATA_RATE BIT(1)
307 #define ISO15693_REQ_FLAG_INVENTORY BIT(2)
308 #define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3)
309 #define ISO15693_REQ_FLAG_SELECT BIT(4)
310 #define ISO15693_REQ_FLAG_AFI BIT(4)
311 #define ISO15693_REQ_FLAG_ADDRESS BIT(5)
312 #define ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
313 #define ISO15693_REQ_FLAG_OPTION BIT(6)
315 #define ISO15693_REQ_FLAG_SPEED_MASK \
316 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
318 enum trf7970a_state {
321 TRF7970A_ST_IDLE_RX_BLOCKED,
322 TRF7970A_ST_WAIT_FOR_TX_FIFO,
323 TRF7970A_ST_WAIT_FOR_RX_DATA,
324 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT,
325 TRF7970A_ST_WAIT_TO_ISSUE_EOF,
330 enum trf7970a_state state;
332 struct spi_device *spi;
333 struct regulator *regulator;
334 struct nfc_digital_dev *ddev;
337 struct sk_buff *tx_skb;
338 struct sk_buff *rx_skb;
339 nfc_digital_cmd_complete_t cb;
344 u8 modulator_sys_clk_ctrl;
353 unsigned int timeout;
355 struct delayed_work timeout_work;
359 static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)
361 u8 cmd = TRF7970A_CMD_BIT_CTRL | TRF7970A_CMD_BIT_OPCODE(opcode);
364 dev_dbg(trf->dev, "cmd: 0x%x\n", cmd);
366 ret = spi_write(trf->spi, &cmd, 1);
368 dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd,
373 static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
375 u8 addr = TRF7970A_CMD_BIT_RW | reg;
378 ret = spi_write_then_read(trf->spi, &addr, 1, val, 1);
380 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
383 dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val);
388 static int trf7970a_read_cont(struct trf7970a *trf, u8 reg,
391 u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS;
394 dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
396 ret = spi_write_then_read(trf->spi, &addr, 1, buf, len);
398 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
403 static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)
405 u8 buf[2] = { reg, val };
408 dev_dbg(trf->dev, "write(0x%x): 0x%x\n", reg, val);
410 ret = spi_write(trf->spi, buf, 2);
412 dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__,
413 buf[0], buf[1], ret);
418 static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
424 addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW;
426 if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA) {
427 addr |= TRF7970A_CMD_BIT_CONTINUOUS;
428 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
430 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 1);
434 dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n",
442 static void trf7970a_send_upstream(struct trf7970a *trf)
446 dev_kfree_skb_any(trf->tx_skb);
449 if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)
450 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE,
451 16, 1, trf->rx_skb->data, trf->rx_skb->len,
454 /* According to the manual it is "good form" to reset the fifo and
455 * read the RSSI levels & oscillator status register here. It doesn't
458 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
459 trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
461 trf->state = TRF7970A_ST_IDLE;
464 dev_dbg(trf->dev, "Abort process complete\n");
466 if (!IS_ERR(trf->rx_skb)) {
467 kfree_skb(trf->rx_skb);
468 trf->rx_skb = ERR_PTR(-ECANCELED);
471 trf->aborting = false;
474 trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb);
479 static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
481 dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
483 kfree_skb(trf->rx_skb);
484 trf->rx_skb = ERR_PTR(errno);
486 trf7970a_send_upstream(trf);
489 static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
492 unsigned int timeout;
495 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE,
496 16, 1, skb->data, len, false);
498 ret = spi_write(trf->spi, skb->data, len);
500 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
508 trf->state = TRF7970A_ST_WAIT_FOR_TX_FIFO;
509 timeout = TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT;
511 if (trf->issue_eof) {
512 trf->state = TRF7970A_ST_WAIT_TO_ISSUE_EOF;
513 timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF;
515 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
516 timeout = trf->timeout;
520 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout,
523 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
528 static void trf7970a_fill_fifo(struct trf7970a *trf)
530 struct sk_buff *skb = trf->tx_skb;
535 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
537 trf7970a_send_err_upstream(trf, ret);
541 dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
543 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) {
544 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
546 trf7970a_send_err_upstream(trf, -EIO);
550 /* Calculate how much more data can be written to the fifo */
551 len = TRF7970A_FIFO_SIZE - fifo_bytes;
552 len = min(skb->len, len);
554 ret = trf7970a_transmit(trf, skb, len);
556 trf7970a_send_err_upstream(trf, ret);
559 static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
561 struct sk_buff *skb = trf->rx_skb;
565 if (status & TRF7970A_IRQ_STATUS_ERROR) {
566 trf7970a_send_err_upstream(trf, -EIO);
570 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
572 trf7970a_send_err_upstream(trf, ret);
576 dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
581 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) {
582 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
584 trf7970a_send_err_upstream(trf, -EIO);
588 if (fifo_bytes > skb_tailroom(skb)) {
589 skb = skb_copy_expand(skb, skb_headroom(skb),
590 max_t(int, fifo_bytes,
591 TRF7970A_RX_SKB_ALLOC_SIZE),
594 trf7970a_send_err_upstream(trf, -ENOMEM);
598 kfree_skb(trf->rx_skb);
602 ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER,
603 skb_put(skb, fifo_bytes), fifo_bytes);
605 trf7970a_send_err_upstream(trf, ret);
609 /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
610 if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) &&
611 (trf->special_fcn_reg1 ==
612 TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) {
614 status = TRF7970A_IRQ_STATUS_SRX;
616 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
620 if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */
621 trf7970a_send_upstream(trf);
625 dev_dbg(trf->dev, "Setting timeout for %d ms\n",
626 TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT);
628 schedule_delayed_work(&trf->timeout_work,
629 msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT));
632 static irqreturn_t trf7970a_irq(int irq, void *dev_id)
634 struct trf7970a *trf = dev_id;
638 mutex_lock(&trf->lock);
640 if (trf->state == TRF7970A_ST_OFF) {
641 mutex_unlock(&trf->lock);
645 ret = trf7970a_read_irqstatus(trf, &status);
647 mutex_unlock(&trf->lock);
651 dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state,
655 mutex_unlock(&trf->lock);
659 switch (trf->state) {
660 case TRF7970A_ST_IDLE:
661 case TRF7970A_ST_IDLE_RX_BLOCKED:
662 /* If getting interrupts caused by RF noise, turn off the
663 * receiver to avoid unnecessary interrupts. It will be
664 * turned back on in trf7970a_in_send_cmd() when the next
667 if (status & TRF7970A_IRQ_STATUS_ERROR) {
668 trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
669 trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
672 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
674 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
675 if (status & TRF7970A_IRQ_STATUS_TX) {
676 trf->ignore_timeout =
677 !cancel_delayed_work(&trf->timeout_work);
678 trf7970a_fill_fifo(trf);
680 trf7970a_send_err_upstream(trf, -EIO);
683 case TRF7970A_ST_WAIT_FOR_RX_DATA:
684 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
685 if (status & TRF7970A_IRQ_STATUS_SRX) {
686 trf->ignore_timeout =
687 !cancel_delayed_work(&trf->timeout_work);
688 trf7970a_drain_fifo(trf, status);
689 } else if (status == TRF7970A_IRQ_STATUS_TX) {
690 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
692 trf7970a_send_err_upstream(trf, -EIO);
695 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
696 if (status != TRF7970A_IRQ_STATUS_TX)
697 trf7970a_send_err_upstream(trf, -EIO);
700 dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
701 __func__, trf->state);
704 mutex_unlock(&trf->lock);
708 static void trf7970a_issue_eof(struct trf7970a *trf)
712 dev_dbg(trf->dev, "Issuing EOF\n");
714 ret = trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
716 trf7970a_send_err_upstream(trf, ret);
718 ret = trf7970a_cmd(trf, TRF7970A_CMD_EOF);
720 trf7970a_send_err_upstream(trf, ret);
722 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
724 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n",
725 trf->timeout, trf->state);
727 schedule_delayed_work(&trf->timeout_work,
728 msecs_to_jiffies(trf->timeout));
731 static void trf7970a_timeout_work_handler(struct work_struct *work)
733 struct trf7970a *trf = container_of(work, struct trf7970a,
736 dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n",
737 trf->state, trf->ignore_timeout);
739 mutex_lock(&trf->lock);
741 if (trf->ignore_timeout)
742 trf->ignore_timeout = false;
743 else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
744 trf7970a_send_upstream(trf); /* No more rx data so send up */
745 else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
746 trf7970a_issue_eof(trf);
748 trf7970a_send_err_upstream(trf, -ETIMEDOUT);
750 mutex_unlock(&trf->lock);
753 static int trf7970a_init(struct trf7970a *trf)
757 dev_dbg(trf->dev, "Initializing device - state: %d\n", trf->state);
759 ret = trf7970a_cmd(trf, TRF7970A_CMD_SOFT_INIT);
763 ret = trf7970a_cmd(trf, TRF7970A_CMD_IDLE);
767 /* Must clear NFC Target Detection Level reg due to erratum */
768 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
772 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
773 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 |
774 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32);
778 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 0);
782 trf->special_fcn_reg1 = 0;
784 trf->iso_ctrl = 0xff;
788 dev_dbg(trf->dev, "Couldn't init device: %d\n", ret);
792 static void trf7970a_switch_rf_off(struct trf7970a *trf)
794 dev_dbg(trf->dev, "Switching rf off\n");
796 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
798 trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
800 trf->aborting = false;
801 trf->state = TRF7970A_ST_OFF;
803 pm_runtime_mark_last_busy(trf->dev);
804 pm_runtime_put_autosuspend(trf->dev);
807 static void trf7970a_switch_rf_on(struct trf7970a *trf)
809 dev_dbg(trf->dev, "Switching rf on\n");
811 pm_runtime_get_sync(trf->dev);
813 trf->state = TRF7970A_ST_IDLE;
816 static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
818 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
820 dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
822 mutex_lock(&trf->lock);
825 switch (trf->state) {
826 case TRF7970A_ST_OFF:
827 trf7970a_switch_rf_on(trf);
829 case TRF7970A_ST_IDLE:
830 case TRF7970A_ST_IDLE_RX_BLOCKED:
833 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
834 __func__, trf->state, on);
835 trf7970a_switch_rf_off(trf);
838 switch (trf->state) {
839 case TRF7970A_ST_OFF:
842 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
843 __func__, trf->state, on);
845 case TRF7970A_ST_IDLE:
846 case TRF7970A_ST_IDLE_RX_BLOCKED:
847 trf7970a_switch_rf_off(trf);
851 mutex_unlock(&trf->lock);
855 static int trf7970a_config_rf_tech(struct trf7970a *trf, int tech)
859 dev_dbg(trf->dev, "rf technology: %d\n", tech);
862 case NFC_DIGITAL_RF_TECH_106A:
863 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
864 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
866 case NFC_DIGITAL_RF_TECH_106B:
867 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
868 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
870 case NFC_DIGITAL_RF_TECH_ISO15693:
871 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
872 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
875 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
879 trf->technology = tech;
884 static int trf7970a_config_framing(struct trf7970a *trf, int framing)
886 u8 iso_ctrl = trf->iso_ctrl_tech;
889 dev_dbg(trf->dev, "framing: %d\n", framing);
892 case NFC_DIGITAL_FRAMING_NFCA_SHORT:
893 case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
894 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
895 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
897 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
898 case NFC_DIGITAL_FRAMING_NFCA_T4T:
899 case NFC_DIGITAL_FRAMING_NFCB:
900 case NFC_DIGITAL_FRAMING_NFCB_T4T:
901 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
902 case NFC_DIGITAL_FRAMING_ISO15693_T5T:
903 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
904 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
906 case NFC_DIGITAL_FRAMING_NFCA_T2T:
907 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
908 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
911 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
915 trf->framing = framing;
917 if (iso_ctrl != trf->iso_ctrl) {
918 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
922 trf->iso_ctrl = iso_ctrl;
924 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
925 trf->modulator_sys_clk_ctrl);
930 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
931 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
932 trf->chip_status_ctrl |
933 TRF7970A_CHIP_STATUS_RF_ON);
937 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
939 usleep_range(5000, 6000);
945 static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,
948 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
951 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
953 mutex_lock(&trf->lock);
955 if (trf->state == TRF7970A_ST_OFF)
956 trf7970a_switch_rf_on(trf);
959 case NFC_DIGITAL_CONFIG_RF_TECH:
960 ret = trf7970a_config_rf_tech(trf, param);
962 case NFC_DIGITAL_CONFIG_FRAMING:
963 ret = trf7970a_config_framing(trf, param);
966 dev_dbg(trf->dev, "Unknown type: %d\n", type);
970 mutex_unlock(&trf->lock);
974 static int trf7970a_is_iso15693_write_or_lock(u8 cmd)
977 case ISO15693_CMD_WRITE_SINGLE_BLOCK:
978 case ISO15693_CMD_LOCK_BLOCK:
979 case ISO15693_CMD_WRITE_MULTIPLE_BLOCK:
980 case ISO15693_CMD_WRITE_AFI:
981 case ISO15693_CMD_LOCK_AFI:
982 case ISO15693_CMD_WRITE_DSFID:
983 case ISO15693_CMD_LOCK_DSFID:
991 static int trf7970a_per_cmd_config(struct trf7970a *trf, struct sk_buff *skb)
994 u8 special_fcn_reg1, iso_ctrl;
997 trf->issue_eof = false;
999 /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
1000 * special functions register 1 is cleared; otherwise, its a write or
1001 * sector select command and '4_bit_RX' must be set.
1003 * When issuing an ISO 15693 command, inspect the flags byte to see
1004 * what speed to use. Also, remember if the OPTION flag is set on
1005 * a Type 5 write or lock command so the driver will know that it
1006 * has to send an EOF in order to get a response.
1008 if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
1009 (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
1010 if (req[0] == NFC_T2T_CMD_READ)
1011 special_fcn_reg1 = 0;
1013 special_fcn_reg1 = TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX;
1015 if (special_fcn_reg1 != trf->special_fcn_reg1) {
1016 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
1021 trf->special_fcn_reg1 = special_fcn_reg1;
1023 } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
1024 iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
1026 switch (req[0] & ISO15693_REQ_FLAG_SPEED_MASK) {
1028 iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662;
1030 case ISO15693_REQ_FLAG_SUB_CARRIER:
1031 iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a;
1033 case ISO15693_REQ_FLAG_DATA_RATE:
1034 iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
1036 case (ISO15693_REQ_FLAG_SUB_CARRIER |
1037 ISO15693_REQ_FLAG_DATA_RATE):
1038 iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669;
1042 if (iso_ctrl != trf->iso_ctrl) {
1043 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1047 trf->iso_ctrl = iso_ctrl;
1050 if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&
1051 trf7970a_is_iso15693_write_or_lock(req[1]) &&
1052 (req[0] & ISO15693_REQ_FLAG_OPTION))
1053 trf->issue_eof = true;
1059 static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1060 struct sk_buff *skb, u16 timeout,
1061 nfc_digital_cmd_complete_t cb, void *arg)
1063 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1068 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1069 trf->state, timeout, skb->len);
1071 if (skb->len > TRF7970A_TX_MAX)
1074 mutex_lock(&trf->lock);
1076 if ((trf->state != TRF7970A_ST_IDLE) &&
1077 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1078 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1084 if (trf->aborting) {
1085 dev_dbg(trf->dev, "Abort process complete\n");
1086 trf->aborting = false;
1091 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1094 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1099 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
1100 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1104 trf->state = TRF7970A_ST_IDLE;
1107 ret = trf7970a_per_cmd_config(trf, skb);
1115 trf->timeout = timeout;
1116 trf->ignore_timeout = false;
1119 prefix = skb_push(skb, TRF7970A_TX_SKB_HEADROOM);
1121 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1122 * on what the current framing is, the address of the TX length byte 1
1123 * register (0x1d), and the 2 byte length of the data to be transmitted.
1125 prefix[0] = TRF7970A_CMD_BIT_CTRL |
1126 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET);
1127 prefix[1] = TRF7970A_CMD_BIT_CTRL |
1128 TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
1129 prefix[2] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1;
1131 if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
1133 prefix[4] = 0x0f; /* 7 bits */
1135 prefix[3] = (len & 0xf00) >> 4;
1136 prefix[3] |= ((len & 0xf0) >> 4);
1137 prefix[4] = ((len & 0x0f) << 4);
1140 len = min_t(int, skb->len, TRF7970A_FIFO_SIZE);
1142 usleep_range(1000, 2000);
1144 ret = trf7970a_transmit(trf, skb, len);
1146 kfree_skb(trf->rx_skb);
1151 mutex_unlock(&trf->lock);
1155 static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev,
1156 int type, int param)
1158 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1160 dev_dbg(trf->dev, "Unsupported interface\n");
1165 static int trf7970a_tg_send_cmd(struct nfc_digital_dev *ddev,
1166 struct sk_buff *skb, u16 timeout,
1167 nfc_digital_cmd_complete_t cb, void *arg)
1169 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1171 dev_dbg(trf->dev, "Unsupported interface\n");
1176 static int trf7970a_tg_listen(struct nfc_digital_dev *ddev,
1177 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1179 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1181 dev_dbg(trf->dev, "Unsupported interface\n");
1186 static int trf7970a_tg_listen_mdaa(struct nfc_digital_dev *ddev,
1187 struct digital_tg_mdaa_params *mdaa_params,
1188 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1190 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1192 dev_dbg(trf->dev, "Unsupported interface\n");
1197 static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
1199 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1201 dev_dbg(trf->dev, "Abort process initiated\n");
1203 mutex_lock(&trf->lock);
1205 switch (trf->state) {
1206 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1207 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1208 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1209 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1210 trf->aborting = true;
1216 mutex_unlock(&trf->lock);
1219 static struct nfc_digital_ops trf7970a_nfc_ops = {
1220 .in_configure_hw = trf7970a_in_configure_hw,
1221 .in_send_cmd = trf7970a_in_send_cmd,
1222 .tg_configure_hw = trf7970a_tg_configure_hw,
1223 .tg_send_cmd = trf7970a_tg_send_cmd,
1224 .tg_listen = trf7970a_tg_listen,
1225 .tg_listen_mdaa = trf7970a_tg_listen_mdaa,
1226 .switch_rf = trf7970a_switch_rf,
1227 .abort_cmd = trf7970a_abort_cmd,
1230 static int trf7970a_get_autosuspend_delay(struct device_node *np)
1232 int autosuspend_delay, ret;
1234 ret = of_property_read_u32(np, "autosuspend-delay", &autosuspend_delay);
1236 autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY;
1240 return autosuspend_delay;
1243 static int trf7970a_probe(struct spi_device *spi)
1245 struct device_node *np = spi->dev.of_node;
1246 const struct spi_device_id *id = spi_get_device_id(spi);
1247 struct trf7970a *trf;
1248 int uvolts, autosuspend_delay, ret;
1251 dev_err(&spi->dev, "No Device Tree entry\n");
1255 trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
1259 trf->state = TRF7970A_ST_OFF;
1260 trf->dev = &spi->dev;
1262 trf->quirks = id->driver_data;
1264 spi->mode = SPI_MODE_1;
1265 spi->bits_per_word = 8;
1267 /* There are two enable pins - both must be present */
1268 trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0);
1269 if (!gpio_is_valid(trf->en_gpio)) {
1270 dev_err(trf->dev, "No EN GPIO property\n");
1271 return trf->en_gpio;
1274 ret = devm_gpio_request_one(trf->dev, trf->en_gpio,
1275 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN");
1277 dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret);
1281 trf->en2_gpio = of_get_named_gpio(np, "ti,enable-gpios", 1);
1282 if (!gpio_is_valid(trf->en2_gpio)) {
1283 dev_err(trf->dev, "No EN2 GPIO property\n");
1284 return trf->en2_gpio;
1287 ret = devm_gpio_request_one(trf->dev, trf->en2_gpio,
1288 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN2");
1290 dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret);
1294 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
1295 trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1298 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
1302 mutex_init(&trf->lock);
1303 INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
1305 trf->regulator = devm_regulator_get(&spi->dev, "vin");
1306 if (IS_ERR(trf->regulator)) {
1307 ret = PTR_ERR(trf->regulator);
1308 dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
1309 goto err_destroy_lock;
1312 ret = regulator_enable(trf->regulator);
1314 dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
1315 goto err_destroy_lock;
1318 uvolts = regulator_get_voltage(trf->regulator);
1320 if (uvolts > 4000000)
1321 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
1323 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
1324 TRF7970A_SUPPORTED_PROTOCOLS,
1325 NFC_DIGITAL_DRV_CAPS_IN_CRC, TRF7970A_TX_SKB_HEADROOM,
1328 dev_err(trf->dev, "Can't allocate NFC digital device\n");
1330 goto err_disable_regulator;
1333 nfc_digital_set_parent_dev(trf->ddev, trf->dev);
1334 nfc_digital_set_drvdata(trf->ddev, trf);
1335 spi_set_drvdata(spi, trf);
1337 autosuspend_delay = trf7970a_get_autosuspend_delay(np);
1339 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
1340 pm_runtime_use_autosuspend(trf->dev);
1341 pm_runtime_enable(trf->dev);
1343 ret = nfc_digital_register_device(trf->ddev);
1345 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
1353 pm_runtime_disable(trf->dev);
1354 nfc_digital_free_device(trf->ddev);
1355 err_disable_regulator:
1356 regulator_disable(trf->regulator);
1358 mutex_destroy(&trf->lock);
1362 static int trf7970a_remove(struct spi_device *spi)
1364 struct trf7970a *trf = spi_get_drvdata(spi);
1366 mutex_lock(&trf->lock);
1368 switch (trf->state) {
1369 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1370 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1371 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1372 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1373 trf7970a_send_err_upstream(trf, -ECANCELED);
1375 case TRF7970A_ST_IDLE:
1376 case TRF7970A_ST_IDLE_RX_BLOCKED:
1377 pm_runtime_put_sync(trf->dev);
1383 mutex_unlock(&trf->lock);
1385 pm_runtime_disable(trf->dev);
1387 nfc_digital_unregister_device(trf->ddev);
1388 nfc_digital_free_device(trf->ddev);
1390 regulator_disable(trf->regulator);
1392 mutex_destroy(&trf->lock);
1397 #ifdef CONFIG_PM_RUNTIME
1398 static int trf7970a_pm_runtime_suspend(struct device *dev)
1400 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1401 struct trf7970a *trf = spi_get_drvdata(spi);
1404 dev_dbg(dev, "Runtime suspend\n");
1406 if (trf->state != TRF7970A_ST_OFF) {
1407 dev_dbg(dev, "Can't suspend - not in OFF state (%d)\n",
1412 gpio_set_value(trf->en_gpio, 0);
1413 gpio_set_value(trf->en2_gpio, 0);
1415 ret = regulator_disable(trf->regulator);
1417 dev_err(dev, "%s - Can't disable VIN: %d\n", __func__, ret);
1422 static int trf7970a_pm_runtime_resume(struct device *dev)
1424 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1425 struct trf7970a *trf = spi_get_drvdata(spi);
1428 dev_dbg(dev, "Runtime resume\n");
1430 ret = regulator_enable(trf->regulator);
1432 dev_err(dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1436 usleep_range(5000, 6000);
1438 gpio_set_value(trf->en2_gpio, 1);
1439 usleep_range(1000, 2000);
1440 gpio_set_value(trf->en_gpio, 1);
1442 usleep_range(20000, 21000);
1444 ret = trf7970a_init(trf);
1446 dev_err(dev, "%s - Can't initialize: %d\n", __func__, ret);
1450 pm_runtime_mark_last_busy(dev);
1456 static const struct dev_pm_ops trf7970a_pm_ops = {
1457 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend,
1458 trf7970a_pm_runtime_resume, NULL)
1461 static const struct spi_device_id trf7970a_id_table[] = {
1462 { "trf7970a", TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA },
1465 MODULE_DEVICE_TABLE(spi, trf7970a_id_table);
1467 static struct spi_driver trf7970a_spi_driver = {
1468 .probe = trf7970a_probe,
1469 .remove = trf7970a_remove,
1470 .id_table = trf7970a_id_table,
1473 .owner = THIS_MODULE,
1474 .pm = &trf7970a_pm_ops,
1478 module_spi_driver(trf7970a_spi_driver);
1480 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1481 MODULE_LICENSE("GPL v2");
1482 MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");