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. 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.
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
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_in_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
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.
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.
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.
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.
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
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)
126 #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
128 #define TRF7970A_RX_SKB_ALLOC_SIZE 256
130 #define TRF7970A_FIFO_SIZE 127
132 /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
133 #define TRF7970A_TX_MAX (4096 - 1)
135 #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
136 #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 20
137 #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 40
139 /* Guard times for various RF technologies (in us) */
140 #define TRF7970A_GUARD_TIME_NFCA 5000
141 #define TRF7970A_GUARD_TIME_NFCB 5000
142 #define TRF7970A_GUARD_TIME_NFCF 20000
143 #define TRF7970A_GUARD_TIME_15693 1000
146 /* Erratum: When reading IRQ Status register on trf7970a, we must issue a
147 * read continuous command for IRQ Status and Collision Position registers.
149 #define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0)
150 #define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1)
152 /* Direct commands */
153 #define TRF7970A_CMD_IDLE 0x00
154 #define TRF7970A_CMD_SOFT_INIT 0x03
155 #define TRF7970A_CMD_RF_COLLISION 0x04
156 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0x05
157 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0x06
158 #define TRF7970A_CMD_FIFO_RESET 0x0f
159 #define TRF7970A_CMD_TRANSMIT_NO_CRC 0x10
160 #define TRF7970A_CMD_TRANSMIT 0x11
161 #define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0x12
162 #define TRF7970A_CMD_DELAY_TRANSMIT 0x13
163 #define TRF7970A_CMD_EOF 0x14
164 #define TRF7970A_CMD_CLOSE_SLOT 0x15
165 #define TRF7970A_CMD_BLOCK_RX 0x16
166 #define TRF7970A_CMD_ENABLE_RX 0x17
167 #define TRF7970A_CMD_TEST_EXT_RF 0x18
168 #define TRF7970A_CMD_TEST_INT_RF 0x19
169 #define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
171 /* Bits determining whether its a direct command or register R/W,
172 * whether to use a continuous SPI transaction or not, and the actual
173 * direct cmd opcode or regster address.
175 #define TRF7970A_CMD_BIT_CTRL BIT(7)
176 #define TRF7970A_CMD_BIT_RW BIT(6)
177 #define TRF7970A_CMD_BIT_CONTINUOUS BIT(5)
178 #define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0x1f)
180 /* Registers addresses */
181 #define TRF7970A_CHIP_STATUS_CTRL 0x00
182 #define TRF7970A_ISO_CTRL 0x01
183 #define TRF7970A_ISO14443B_TX_OPTIONS 0x02
184 #define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
185 #define TRF7970A_TX_TIMER_SETTING_H_BYTE 0x04
186 #define TRF7970A_TX_TIMER_SETTING_L_BYTE 0x05
187 #define TRF7970A_TX_PULSE_LENGTH_CTRL 0x06
188 #define TRF7970A_RX_NO_RESPONSE_WAIT 0x07
189 #define TRF7970A_RX_WAIT_TIME 0x08
190 #define TRF7970A_MODULATOR_SYS_CLK_CTRL 0x09
191 #define TRF7970A_RX_SPECIAL_SETTINGS 0x0a
192 #define TRF7970A_REG_IO_CTRL 0x0b
193 #define TRF7970A_IRQ_STATUS 0x0c
194 #define TRF7970A_COLLISION_IRQ_MASK 0x0d
195 #define TRF7970A_COLLISION_POSITION 0x0e
196 #define TRF7970A_RSSI_OSC_STATUS 0x0f
197 #define TRF7970A_SPECIAL_FCN_REG1 0x10
198 #define TRF7970A_SPECIAL_FCN_REG2 0x11
199 #define TRF7970A_RAM1 0x12
200 #define TRF7970A_RAM2 0x13
201 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0x14
202 #define TRF7970A_NFC_LOW_FIELD_LEVEL 0x16
203 #define TRF7970A_NFCID1 0x17
204 #define TRF7970A_NFC_TARGET_LEVEL 0x18
205 #define TRF79070A_NFC_TARGET_PROTOCOL 0x19
206 #define TRF7970A_TEST_REGISTER1 0x1a
207 #define TRF7970A_TEST_REGISTER2 0x1b
208 #define TRF7970A_FIFO_STATUS 0x1c
209 #define TRF7970A_TX_LENGTH_BYTE1 0x1d
210 #define TRF7970A_TX_LENGTH_BYTE2 0x1e
211 #define TRF7970A_FIFO_IO_REGISTER 0x1f
213 /* Chip Status Control Register Bits */
214 #define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0)
215 #define TRF7970A_CHIP_STATUS_REC_ON BIT(1)
216 #define TRF7970A_CHIP_STATUS_AGC_ON BIT(2)
217 #define TRF7970A_CHIP_STATUS_PM_ON BIT(3)
218 #define TRF7970A_CHIP_STATUS_RF_PWR BIT(4)
219 #define TRF7970A_CHIP_STATUS_RF_ON BIT(5)
220 #define TRF7970A_CHIP_STATUS_DIRECT BIT(6)
221 #define TRF7970A_CHIP_STATUS_STBY BIT(7)
223 /* ISO Control Register Bits */
224 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0x00
225 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0x01
226 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0x02
227 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
228 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0x04
229 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0x05
230 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0x06
231 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
232 #define TRF7970A_ISO_CTRL_14443A_106 0x08
233 #define TRF7970A_ISO_CTRL_14443A_212 0x09
234 #define TRF7970A_ISO_CTRL_14443A_424 0x0a
235 #define TRF7970A_ISO_CTRL_14443A_848 0x0b
236 #define TRF7970A_ISO_CTRL_14443B_106 0x0c
237 #define TRF7970A_ISO_CTRL_14443B_212 0x0d
238 #define TRF7970A_ISO_CTRL_14443B_424 0x0e
239 #define TRF7970A_ISO_CTRL_14443B_848 0x0f
240 #define TRF7970A_ISO_CTRL_FELICA_212 0x1a
241 #define TRF7970A_ISO_CTRL_FELICA_424 0x1b
242 #define TRF7970A_ISO_CTRL_RFID BIT(5)
243 #define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
244 #define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
246 #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0x1f
248 /* Modulator and SYS_CLK Control Register Bits */
249 #define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0x7)
250 #define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0))
251 #define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1))
252 #define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2))
253 #define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3))
254 #define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4))
255 #define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5))
256 #define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6))
257 #define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7))
258 #define TRF7970A_MODULATOR_EN_ANA BIT(3)
259 #define TRF7970A_MODULATOR_CLK(n) (((n) & 0x3) << 4)
260 #define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0))
261 #define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1))
262 #define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2))
263 #define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3))
264 #define TRF7970A_MODULATOR_EN_OOK BIT(6)
265 #define TRF7970A_MODULATOR_27MHZ BIT(7)
267 /* IRQ Status Register Bits */
268 #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
269 #define TRF7970A_IRQ_STATUS_COL BIT(1)
270 #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
271 #define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
272 #define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
273 #define TRF7970A_IRQ_STATUS_FIFO BIT(5)
274 #define TRF7970A_IRQ_STATUS_SRX BIT(6)
275 #define TRF7970A_IRQ_STATUS_TX BIT(7)
277 #define TRF7970A_IRQ_STATUS_ERROR \
278 (TRF7970A_IRQ_STATUS_COL | \
279 TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR | \
280 TRF7970A_IRQ_STATUS_PARITY_ERROR | \
281 TRF7970A_IRQ_STATUS_CRC_ERROR)
283 #define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
284 #define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
285 #define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
286 #define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3)
287 #define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4)
288 #define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5)
290 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0x0 << 2)
291 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0x1 << 2)
292 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0x2 << 2)
293 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0x3 << 2)
294 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0x0
295 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0x1
296 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
297 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
299 #define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
301 /* NFC (ISO/IEC 14443A) Type 2 Tag commands */
302 #define NFC_T2T_CMD_READ 0x30
304 /* ISO 15693 commands codes */
305 #define ISO15693_CMD_INVENTORY 0x01
306 #define ISO15693_CMD_READ_SINGLE_BLOCK 0x20
307 #define ISO15693_CMD_WRITE_SINGLE_BLOCK 0x21
308 #define ISO15693_CMD_LOCK_BLOCK 0x22
309 #define ISO15693_CMD_READ_MULTIPLE_BLOCK 0x23
310 #define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0x24
311 #define ISO15693_CMD_SELECT 0x25
312 #define ISO15693_CMD_RESET_TO_READY 0x26
313 #define ISO15693_CMD_WRITE_AFI 0x27
314 #define ISO15693_CMD_LOCK_AFI 0x28
315 #define ISO15693_CMD_WRITE_DSFID 0x29
316 #define ISO15693_CMD_LOCK_DSFID 0x2a
317 #define ISO15693_CMD_GET_SYSTEM_INFO 0x2b
318 #define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
320 /* ISO 15693 request and response flags */
321 #define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0)
322 #define ISO15693_REQ_FLAG_DATA_RATE BIT(1)
323 #define ISO15693_REQ_FLAG_INVENTORY BIT(2)
324 #define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3)
325 #define ISO15693_REQ_FLAG_SELECT BIT(4)
326 #define ISO15693_REQ_FLAG_AFI BIT(4)
327 #define ISO15693_REQ_FLAG_ADDRESS BIT(5)
328 #define ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
329 #define ISO15693_REQ_FLAG_OPTION BIT(6)
331 #define ISO15693_REQ_FLAG_SPEED_MASK \
332 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
334 enum trf7970a_state
{
337 TRF7970A_ST_IDLE_RX_BLOCKED
,
338 TRF7970A_ST_WAIT_FOR_TX_FIFO
,
339 TRF7970A_ST_WAIT_FOR_RX_DATA
,
340 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
,
341 TRF7970A_ST_WAIT_TO_ISSUE_EOF
,
346 enum trf7970a_state state
;
348 struct spi_device
*spi
;
349 struct regulator
*regulator
;
350 struct nfc_digital_dev
*ddev
;
353 struct sk_buff
*tx_skb
;
354 struct sk_buff
*rx_skb
;
355 nfc_digital_cmd_complete_t cb
;
360 u8 modulator_sys_clk_ctrl
;
362 unsigned int guard_time
;
370 unsigned int timeout
;
372 struct delayed_work timeout_work
;
376 static int trf7970a_cmd(struct trf7970a
*trf
, u8 opcode
)
378 u8 cmd
= TRF7970A_CMD_BIT_CTRL
| TRF7970A_CMD_BIT_OPCODE(opcode
);
381 dev_dbg(trf
->dev
, "cmd: 0x%x\n", cmd
);
383 ret
= spi_write(trf
->spi
, &cmd
, 1);
385 dev_err(trf
->dev
, "%s - cmd: 0x%x, ret: %d\n", __func__
, cmd
,
390 static int trf7970a_read(struct trf7970a
*trf
, u8 reg
, u8
*val
)
392 u8 addr
= TRF7970A_CMD_BIT_RW
| reg
;
395 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, val
, 1);
397 dev_err(trf
->dev
, "%s - addr: 0x%x, ret: %d\n", __func__
, addr
,
400 dev_dbg(trf
->dev
, "read(0x%x): 0x%x\n", addr
, *val
);
405 static int trf7970a_read_cont(struct trf7970a
*trf
, u8 reg
, u8
*buf
, size_t len
)
407 u8 addr
= reg
| TRF7970A_CMD_BIT_RW
| TRF7970A_CMD_BIT_CONTINUOUS
;
408 struct spi_transfer t
[2];
409 struct spi_message m
;
412 dev_dbg(trf
->dev
, "read_cont(0x%x, %zd)\n", addr
, len
);
414 spi_message_init(&m
);
416 memset(&t
, 0, sizeof(t
));
419 t
[0].len
= sizeof(addr
);
420 spi_message_add_tail(&t
[0], &m
);
424 spi_message_add_tail(&t
[1], &m
);
426 ret
= spi_sync(trf
->spi
, &m
);
428 dev_err(trf
->dev
, "%s - addr: 0x%x, ret: %d\n", __func__
, addr
,
433 static int trf7970a_write(struct trf7970a
*trf
, u8 reg
, u8 val
)
435 u8 buf
[2] = { reg
, val
};
438 dev_dbg(trf
->dev
, "write(0x%x): 0x%x\n", reg
, val
);
440 ret
= spi_write(trf
->spi
, buf
, 2);
442 dev_err(trf
->dev
, "%s - write: 0x%x 0x%x, ret: %d\n", __func__
,
443 buf
[0], buf
[1], ret
);
448 static int trf7970a_read_irqstatus(struct trf7970a
*trf
, u8
*status
)
454 addr
= TRF7970A_IRQ_STATUS
| TRF7970A_CMD_BIT_RW
;
456 if (trf
->quirks
& TRF7970A_QUIRK_IRQ_STATUS_READ
) {
457 addr
|= TRF7970A_CMD_BIT_CONTINUOUS
;
458 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, buf
, 2);
460 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, buf
, 1);
464 dev_err(trf
->dev
, "%s - irqstatus: Status read failed: %d\n",
472 static void trf7970a_send_upstream(struct trf7970a
*trf
)
474 dev_kfree_skb_any(trf
->tx_skb
);
477 if (trf
->rx_skb
&& !IS_ERR(trf
->rx_skb
) && !trf
->aborting
)
478 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE
,
479 16, 1, trf
->rx_skb
->data
, trf
->rx_skb
->len
,
482 trf
->state
= TRF7970A_ST_IDLE
;
485 dev_dbg(trf
->dev
, "Abort process complete\n");
487 if (!IS_ERR(trf
->rx_skb
)) {
488 kfree_skb(trf
->rx_skb
);
489 trf
->rx_skb
= ERR_PTR(-ECANCELED
);
492 trf
->aborting
= false;
495 trf
->cb(trf
->ddev
, trf
->cb_arg
, trf
->rx_skb
);
500 static void trf7970a_send_err_upstream(struct trf7970a
*trf
, int errno
)
502 dev_dbg(trf
->dev
, "Error - state: %d, errno: %d\n", trf
->state
, errno
);
504 kfree_skb(trf
->rx_skb
);
505 trf
->rx_skb
= ERR_PTR(errno
);
507 trf7970a_send_upstream(trf
);
510 static int trf7970a_transmit(struct trf7970a
*trf
, struct sk_buff
*skb
,
511 unsigned int len
, u8
*prefix
, unsigned int prefix_len
)
513 struct spi_transfer t
[2];
514 struct spi_message m
;
515 unsigned int timeout
;
518 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE
,
519 16, 1, skb
->data
, len
, false);
521 spi_message_init(&m
);
523 memset(&t
, 0, sizeof(t
));
525 t
[0].tx_buf
= prefix
;
526 t
[0].len
= prefix_len
;
527 spi_message_add_tail(&t
[0], &m
);
529 t
[1].tx_buf
= skb
->data
;
531 spi_message_add_tail(&t
[1], &m
);
533 ret
= spi_sync(trf
->spi
, &m
);
535 dev_err(trf
->dev
, "%s - Can't send tx data: %d\n", __func__
,
543 trf
->state
= TRF7970A_ST_WAIT_FOR_TX_FIFO
;
544 timeout
= TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT
;
546 if (trf
->issue_eof
) {
547 trf
->state
= TRF7970A_ST_WAIT_TO_ISSUE_EOF
;
548 timeout
= TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF
;
550 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA
;
551 timeout
= trf
->timeout
;
555 dev_dbg(trf
->dev
, "Setting timeout for %d ms, state: %d\n", timeout
,
558 schedule_delayed_work(&trf
->timeout_work
, msecs_to_jiffies(timeout
));
563 static void trf7970a_fill_fifo(struct trf7970a
*trf
)
565 struct sk_buff
*skb
= trf
->tx_skb
;
571 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
, &fifo_bytes
);
573 trf7970a_send_err_upstream(trf
, ret
);
577 dev_dbg(trf
->dev
, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes
);
579 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
581 /* Calculate how much more data can be written to the fifo */
582 len
= TRF7970A_FIFO_SIZE
- fifo_bytes
;
583 len
= min(skb
->len
, len
);
585 prefix
= TRF7970A_CMD_BIT_CONTINUOUS
| TRF7970A_FIFO_IO_REGISTER
;
587 ret
= trf7970a_transmit(trf
, skb
, len
, &prefix
, sizeof(prefix
));
589 trf7970a_send_err_upstream(trf
, ret
);
592 static void trf7970a_drain_fifo(struct trf7970a
*trf
, u8 status
)
594 struct sk_buff
*skb
= trf
->rx_skb
;
598 if (status
& TRF7970A_IRQ_STATUS_ERROR
) {
599 trf7970a_send_err_upstream(trf
, -EIO
);
603 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
, &fifo_bytes
);
605 trf7970a_send_err_upstream(trf
, ret
);
609 dev_dbg(trf
->dev
, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes
);
611 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
616 if (fifo_bytes
> skb_tailroom(skb
)) {
617 skb
= skb_copy_expand(skb
, skb_headroom(skb
),
618 max_t(int, fifo_bytes
,
619 TRF7970A_RX_SKB_ALLOC_SIZE
),
622 trf7970a_send_err_upstream(trf
, -ENOMEM
);
626 kfree_skb(trf
->rx_skb
);
630 ret
= trf7970a_read_cont(trf
, TRF7970A_FIFO_IO_REGISTER
,
631 skb_put(skb
, fifo_bytes
), fifo_bytes
);
633 trf7970a_send_err_upstream(trf
, ret
);
637 /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
638 if ((trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_T2T
) && (skb
->len
== 1) &&
639 (trf
->special_fcn_reg1
==
640 TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX
)) {
642 status
= TRF7970A_IRQ_STATUS_SRX
;
644 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
;
648 if (status
== TRF7970A_IRQ_STATUS_SRX
) { /* Receive complete */
649 trf7970a_send_upstream(trf
);
653 dev_dbg(trf
->dev
, "Setting timeout for %d ms\n",
654 TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT
);
656 schedule_delayed_work(&trf
->timeout_work
,
657 msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT
));
660 static irqreturn_t
trf7970a_irq(int irq
, void *dev_id
)
662 struct trf7970a
*trf
= dev_id
;
666 mutex_lock(&trf
->lock
);
668 if (trf
->state
== TRF7970A_ST_OFF
) {
669 mutex_unlock(&trf
->lock
);
673 ret
= trf7970a_read_irqstatus(trf
, &status
);
675 mutex_unlock(&trf
->lock
);
679 dev_dbg(trf
->dev
, "IRQ - state: %d, status: 0x%x\n", trf
->state
,
683 mutex_unlock(&trf
->lock
);
687 switch (trf
->state
) {
688 case TRF7970A_ST_IDLE
:
689 case TRF7970A_ST_IDLE_RX_BLOCKED
:
690 /* If getting interrupts caused by RF noise, turn off the
691 * receiver to avoid unnecessary interrupts. It will be
692 * turned back on in trf7970a_in_send_cmd() when the next
695 if (status
& TRF7970A_IRQ_STATUS_ERROR
) {
696 trf7970a_cmd(trf
, TRF7970A_CMD_BLOCK_RX
);
697 trf
->state
= TRF7970A_ST_IDLE_RX_BLOCKED
;
700 trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
702 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
703 if (status
& TRF7970A_IRQ_STATUS_TX
) {
704 trf
->ignore_timeout
=
705 !cancel_delayed_work(&trf
->timeout_work
);
706 trf7970a_fill_fifo(trf
);
708 trf7970a_send_err_upstream(trf
, -EIO
);
711 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
712 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
713 if (status
& TRF7970A_IRQ_STATUS_SRX
) {
714 trf
->ignore_timeout
=
715 !cancel_delayed_work(&trf
->timeout_work
);
716 trf7970a_drain_fifo(trf
, status
);
717 } else if (status
== TRF7970A_IRQ_STATUS_TX
) {
718 trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
720 trf7970a_send_err_upstream(trf
, -EIO
);
723 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
724 if (status
!= TRF7970A_IRQ_STATUS_TX
)
725 trf7970a_send_err_upstream(trf
, -EIO
);
728 dev_err(trf
->dev
, "%s - Driver in invalid state: %d\n",
729 __func__
, trf
->state
);
732 mutex_unlock(&trf
->lock
);
736 static void trf7970a_issue_eof(struct trf7970a
*trf
)
740 dev_dbg(trf
->dev
, "Issuing EOF\n");
742 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
744 trf7970a_send_err_upstream(trf
, ret
);
746 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_EOF
);
748 trf7970a_send_err_upstream(trf
, ret
);
750 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA
;
752 dev_dbg(trf
->dev
, "Setting timeout for %d ms, state: %d\n",
753 trf
->timeout
, trf
->state
);
755 schedule_delayed_work(&trf
->timeout_work
,
756 msecs_to_jiffies(trf
->timeout
));
759 static void trf7970a_timeout_work_handler(struct work_struct
*work
)
761 struct trf7970a
*trf
= container_of(work
, struct trf7970a
,
764 dev_dbg(trf
->dev
, "Timeout - state: %d, ignore_timeout: %d\n",
765 trf
->state
, trf
->ignore_timeout
);
767 mutex_lock(&trf
->lock
);
769 if (trf
->ignore_timeout
)
770 trf
->ignore_timeout
= false;
771 else if (trf
->state
== TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
)
772 trf7970a_send_upstream(trf
); /* No more rx data so send up */
773 else if (trf
->state
== TRF7970A_ST_WAIT_TO_ISSUE_EOF
)
774 trf7970a_issue_eof(trf
);
776 trf7970a_send_err_upstream(trf
, -ETIMEDOUT
);
778 mutex_unlock(&trf
->lock
);
781 static int trf7970a_init(struct trf7970a
*trf
)
785 dev_dbg(trf
->dev
, "Initializing device - state: %d\n", trf
->state
);
787 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_SOFT_INIT
);
791 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_IDLE
);
795 ret
= trf7970a_write(trf
, TRF7970A_MODULATOR_SYS_CLK_CTRL
, 0);
799 trf
->modulator_sys_clk_ctrl
= 0;
801 /* Must clear NFC Target Detection Level reg due to erratum */
802 ret
= trf7970a_write(trf
, TRF7970A_NFC_TARGET_LEVEL
, 0);
806 ret
= trf7970a_write(trf
, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS
,
807 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96
|
808 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32
);
812 ret
= trf7970a_write(trf
, TRF7970A_SPECIAL_FCN_REG1
, 0);
816 trf
->special_fcn_reg1
= 0;
818 trf
->iso_ctrl
= 0xff;
822 dev_dbg(trf
->dev
, "Couldn't init device: %d\n", ret
);
826 static void trf7970a_switch_rf_off(struct trf7970a
*trf
)
828 dev_dbg(trf
->dev
, "Switching rf off\n");
830 trf
->chip_status_ctrl
&= ~TRF7970A_CHIP_STATUS_RF_ON
;
832 trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
, trf
->chip_status_ctrl
);
834 trf
->aborting
= false;
835 trf
->state
= TRF7970A_ST_OFF
;
837 pm_runtime_mark_last_busy(trf
->dev
);
838 pm_runtime_put_autosuspend(trf
->dev
);
841 static void trf7970a_switch_rf_on(struct trf7970a
*trf
)
845 dev_dbg(trf
->dev
, "Switching rf on\n");
847 pm_runtime_get_sync(trf
->dev
);
849 ret
= trf7970a_init(trf
);
851 dev_err(trf
->dev
, "%s - Can't initialize: %d\n", __func__
, ret
);
855 trf
->state
= TRF7970A_ST_IDLE
;
858 static int trf7970a_switch_rf(struct nfc_digital_dev
*ddev
, bool on
)
860 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
862 dev_dbg(trf
->dev
, "Switching RF - state: %d, on: %d\n", trf
->state
, on
);
864 mutex_lock(&trf
->lock
);
867 switch (trf
->state
) {
868 case TRF7970A_ST_OFF
:
869 trf7970a_switch_rf_on(trf
);
871 case TRF7970A_ST_IDLE
:
872 case TRF7970A_ST_IDLE_RX_BLOCKED
:
875 dev_err(trf
->dev
, "%s - Invalid request: %d %d\n",
876 __func__
, trf
->state
, on
);
877 trf7970a_switch_rf_off(trf
);
880 switch (trf
->state
) {
881 case TRF7970A_ST_OFF
:
884 dev_err(trf
->dev
, "%s - Invalid request: %d %d\n",
885 __func__
, trf
->state
, on
);
887 case TRF7970A_ST_IDLE
:
888 case TRF7970A_ST_IDLE_RX_BLOCKED
:
889 trf7970a_switch_rf_off(trf
);
893 mutex_unlock(&trf
->lock
);
897 static int trf7970a_config_rf_tech(struct trf7970a
*trf
, int tech
)
901 dev_dbg(trf
->dev
, "rf technology: %d\n", tech
);
904 case NFC_DIGITAL_RF_TECH_106A
:
905 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_14443A_106
;
906 trf
->modulator_sys_clk_ctrl
= TRF7970A_MODULATOR_DEPTH_OOK
;
907 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCA
;
909 case NFC_DIGITAL_RF_TECH_106B
:
910 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_14443B_106
;
911 trf
->modulator_sys_clk_ctrl
= TRF7970A_MODULATOR_DEPTH_ASK10
;
912 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCB
;
914 case NFC_DIGITAL_RF_TECH_212F
:
915 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_FELICA_212
;
916 trf
->modulator_sys_clk_ctrl
= TRF7970A_MODULATOR_DEPTH_ASK10
;
917 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCF
;
919 case NFC_DIGITAL_RF_TECH_424F
:
920 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_FELICA_424
;
921 trf
->modulator_sys_clk_ctrl
= TRF7970A_MODULATOR_DEPTH_ASK10
;
922 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCF
;
924 case NFC_DIGITAL_RF_TECH_ISO15693
:
925 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648
;
926 trf
->modulator_sys_clk_ctrl
= TRF7970A_MODULATOR_DEPTH_OOK
;
927 trf
->guard_time
= TRF7970A_GUARD_TIME_15693
;
930 dev_dbg(trf
->dev
, "Unsupported rf technology: %d\n", tech
);
934 trf
->technology
= tech
;
939 static int trf7970a_config_framing(struct trf7970a
*trf
, int framing
)
941 u8 iso_ctrl
= trf
->iso_ctrl_tech
;
944 dev_dbg(trf
->dev
, "framing: %d\n", framing
);
947 case NFC_DIGITAL_FRAMING_NFCA_SHORT
:
948 case NFC_DIGITAL_FRAMING_NFCA_STANDARD
:
949 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT_NO_CRC
;
950 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
952 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A
:
953 case NFC_DIGITAL_FRAMING_NFCA_T4T
:
954 case NFC_DIGITAL_FRAMING_NFCB
:
955 case NFC_DIGITAL_FRAMING_NFCB_T4T
:
956 case NFC_DIGITAL_FRAMING_NFCF
:
957 case NFC_DIGITAL_FRAMING_NFCF_T3T
:
958 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY
:
959 case NFC_DIGITAL_FRAMING_ISO15693_T5T
:
960 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
961 iso_ctrl
&= ~TRF7970A_ISO_CTRL_RX_CRC_N
;
963 case NFC_DIGITAL_FRAMING_NFCA_T2T
:
964 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
965 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
968 dev_dbg(trf
->dev
, "Unsupported Framing: %d\n", framing
);
972 trf
->framing
= framing
;
974 if (iso_ctrl
!= trf
->iso_ctrl
) {
975 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
, iso_ctrl
);
979 trf
->iso_ctrl
= iso_ctrl
;
981 ret
= trf7970a_write(trf
, TRF7970A_MODULATOR_SYS_CLK_CTRL
,
982 trf
->modulator_sys_clk_ctrl
);
987 if (!(trf
->chip_status_ctrl
& TRF7970A_CHIP_STATUS_RF_ON
)) {
988 ret
= trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
,
989 trf
->chip_status_ctrl
|
990 TRF7970A_CHIP_STATUS_RF_ON
);
994 trf
->chip_status_ctrl
|= TRF7970A_CHIP_STATUS_RF_ON
;
996 usleep_range(trf
->guard_time
, trf
->guard_time
+ 1000);
1002 static int trf7970a_in_configure_hw(struct nfc_digital_dev
*ddev
, int type
,
1005 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1008 dev_dbg(trf
->dev
, "Configure hw - type: %d, param: %d\n", type
, param
);
1010 mutex_lock(&trf
->lock
);
1012 if (trf
->state
== TRF7970A_ST_OFF
)
1013 trf7970a_switch_rf_on(trf
);
1016 case NFC_DIGITAL_CONFIG_RF_TECH
:
1017 ret
= trf7970a_config_rf_tech(trf
, param
);
1019 case NFC_DIGITAL_CONFIG_FRAMING
:
1020 ret
= trf7970a_config_framing(trf
, param
);
1023 dev_dbg(trf
->dev
, "Unknown type: %d\n", type
);
1027 mutex_unlock(&trf
->lock
);
1031 static int trf7970a_is_iso15693_write_or_lock(u8 cmd
)
1034 case ISO15693_CMD_WRITE_SINGLE_BLOCK
:
1035 case ISO15693_CMD_LOCK_BLOCK
:
1036 case ISO15693_CMD_WRITE_MULTIPLE_BLOCK
:
1037 case ISO15693_CMD_WRITE_AFI
:
1038 case ISO15693_CMD_LOCK_AFI
:
1039 case ISO15693_CMD_WRITE_DSFID
:
1040 case ISO15693_CMD_LOCK_DSFID
:
1048 static int trf7970a_per_cmd_config(struct trf7970a
*trf
, struct sk_buff
*skb
)
1050 u8
*req
= skb
->data
;
1051 u8 special_fcn_reg1
, iso_ctrl
;
1054 trf
->issue_eof
= false;
1056 /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
1057 * special functions register 1 is cleared; otherwise, its a write or
1058 * sector select command and '4_bit_RX' must be set.
1060 * When issuing an ISO 15693 command, inspect the flags byte to see
1061 * what speed to use. Also, remember if the OPTION flag is set on
1062 * a Type 5 write or lock command so the driver will know that it
1063 * has to send an EOF in order to get a response.
1065 if ((trf
->technology
== NFC_DIGITAL_RF_TECH_106A
) &&
1066 (trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_T2T
)) {
1067 if (req
[0] == NFC_T2T_CMD_READ
)
1068 special_fcn_reg1
= 0;
1070 special_fcn_reg1
= TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX
;
1072 if (special_fcn_reg1
!= trf
->special_fcn_reg1
) {
1073 ret
= trf7970a_write(trf
, TRF7970A_SPECIAL_FCN_REG1
,
1078 trf
->special_fcn_reg1
= special_fcn_reg1
;
1080 } else if (trf
->technology
== NFC_DIGITAL_RF_TECH_ISO15693
) {
1081 iso_ctrl
= trf
->iso_ctrl
& ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK
;
1083 switch (req
[0] & ISO15693_REQ_FLAG_SPEED_MASK
) {
1085 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662
;
1087 case ISO15693_REQ_FLAG_SUB_CARRIER
:
1088 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a
;
1090 case ISO15693_REQ_FLAG_DATA_RATE
:
1091 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648
;
1093 case (ISO15693_REQ_FLAG_SUB_CARRIER
|
1094 ISO15693_REQ_FLAG_DATA_RATE
):
1095 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669
;
1099 if (iso_ctrl
!= trf
->iso_ctrl
) {
1100 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
, iso_ctrl
);
1104 trf
->iso_ctrl
= iso_ctrl
;
1107 if ((trf
->framing
== NFC_DIGITAL_FRAMING_ISO15693_T5T
) &&
1108 trf7970a_is_iso15693_write_or_lock(req
[1]) &&
1109 (req
[0] & ISO15693_REQ_FLAG_OPTION
))
1110 trf
->issue_eof
= true;
1116 static int trf7970a_in_send_cmd(struct nfc_digital_dev
*ddev
,
1117 struct sk_buff
*skb
, u16 timeout
,
1118 nfc_digital_cmd_complete_t cb
, void *arg
)
1120 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1126 dev_dbg(trf
->dev
, "New request - state: %d, timeout: %d ms, len: %d\n",
1127 trf
->state
, timeout
, skb
->len
);
1129 if (skb
->len
> TRF7970A_TX_MAX
)
1132 mutex_lock(&trf
->lock
);
1134 if ((trf
->state
!= TRF7970A_ST_IDLE
) &&
1135 (trf
->state
!= TRF7970A_ST_IDLE_RX_BLOCKED
)) {
1136 dev_err(trf
->dev
, "%s - Bogus state: %d\n", __func__
,
1142 if (trf
->aborting
) {
1143 dev_dbg(trf
->dev
, "Abort process complete\n");
1144 trf
->aborting
= false;
1149 trf
->rx_skb
= nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE
,
1152 dev_dbg(trf
->dev
, "Can't alloc rx_skb\n");
1157 if (trf
->state
== TRF7970A_ST_IDLE_RX_BLOCKED
) {
1158 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_ENABLE_RX
);
1162 trf
->state
= TRF7970A_ST_IDLE
;
1165 ret
= trf7970a_per_cmd_config(trf
, skb
);
1173 trf
->timeout
= timeout
;
1174 trf
->ignore_timeout
= false;
1178 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1179 * on what the current framing is, the address of the TX length byte 1
1180 * register (0x1d), and the 2 byte length of the data to be transmitted.
1181 * That totals 5 bytes.
1183 prefix
[0] = TRF7970A_CMD_BIT_CTRL
|
1184 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET
);
1185 prefix
[1] = TRF7970A_CMD_BIT_CTRL
|
1186 TRF7970A_CMD_BIT_OPCODE(trf
->tx_cmd
);
1187 prefix
[2] = TRF7970A_CMD_BIT_CONTINUOUS
| TRF7970A_TX_LENGTH_BYTE1
;
1189 if (trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_SHORT
) {
1191 prefix
[4] = 0x0f; /* 7 bits */
1193 prefix
[3] = (len
& 0xf00) >> 4;
1194 prefix
[3] |= ((len
& 0xf0) >> 4);
1195 prefix
[4] = ((len
& 0x0f) << 4);
1198 len
= min_t(int, skb
->len
, TRF7970A_FIFO_SIZE
);
1200 /* Clear possible spurious interrupt */
1201 ret
= trf7970a_read_irqstatus(trf
, &status
);
1205 ret
= trf7970a_transmit(trf
, skb
, len
, prefix
, sizeof(prefix
));
1207 kfree_skb(trf
->rx_skb
);
1212 mutex_unlock(&trf
->lock
);
1216 static int trf7970a_tg_configure_hw(struct nfc_digital_dev
*ddev
,
1217 int type
, int param
)
1219 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1221 dev_dbg(trf
->dev
, "Unsupported interface\n");
1226 static int trf7970a_tg_send_cmd(struct nfc_digital_dev
*ddev
,
1227 struct sk_buff
*skb
, u16 timeout
,
1228 nfc_digital_cmd_complete_t cb
, void *arg
)
1230 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1232 dev_dbg(trf
->dev
, "Unsupported interface\n");
1237 static int trf7970a_tg_listen(struct nfc_digital_dev
*ddev
,
1238 u16 timeout
, nfc_digital_cmd_complete_t cb
, void *arg
)
1240 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1242 dev_dbg(trf
->dev
, "Unsupported interface\n");
1247 static void trf7970a_abort_cmd(struct nfc_digital_dev
*ddev
)
1249 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1251 dev_dbg(trf
->dev
, "Abort process initiated\n");
1253 mutex_lock(&trf
->lock
);
1255 switch (trf
->state
) {
1256 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
1257 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
1258 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
1259 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
1260 trf
->aborting
= true;
1266 mutex_unlock(&trf
->lock
);
1269 static struct nfc_digital_ops trf7970a_nfc_ops
= {
1270 .in_configure_hw
= trf7970a_in_configure_hw
,
1271 .in_send_cmd
= trf7970a_in_send_cmd
,
1272 .tg_configure_hw
= trf7970a_tg_configure_hw
,
1273 .tg_send_cmd
= trf7970a_tg_send_cmd
,
1274 .tg_listen
= trf7970a_tg_listen
,
1275 .switch_rf
= trf7970a_switch_rf
,
1276 .abort_cmd
= trf7970a_abort_cmd
,
1279 static int trf7970a_get_autosuspend_delay(struct device_node
*np
)
1281 int autosuspend_delay
, ret
;
1283 ret
= of_property_read_u32(np
, "autosuspend-delay", &autosuspend_delay
);
1285 autosuspend_delay
= TRF7970A_AUTOSUSPEND_DELAY
;
1287 return autosuspend_delay
;
1290 static int trf7970a_get_vin_voltage_override(struct device_node
*np
,
1293 return of_property_read_u32(np
, "vin-voltage-override", vin_uvolts
);
1296 static int trf7970a_probe(struct spi_device
*spi
)
1298 struct device_node
*np
= spi
->dev
.of_node
;
1299 struct trf7970a
*trf
;
1300 int uvolts
, autosuspend_delay
, ret
;
1303 dev_err(&spi
->dev
, "No Device Tree entry\n");
1307 trf
= devm_kzalloc(&spi
->dev
, sizeof(*trf
), GFP_KERNEL
);
1311 trf
->state
= TRF7970A_ST_OFF
;
1312 trf
->dev
= &spi
->dev
;
1315 spi
->mode
= SPI_MODE_1
;
1316 spi
->bits_per_word
= 8;
1318 ret
= spi_setup(spi
);
1320 dev_err(trf
->dev
, "Can't set up SPI Communication\n");
1324 if (of_property_read_bool(np
, "irq-status-read-quirk"))
1325 trf
->quirks
|= TRF7970A_QUIRK_IRQ_STATUS_READ
;
1327 /* There are two enable pins - both must be present */
1328 trf
->en_gpio
= of_get_named_gpio(np
, "ti,enable-gpios", 0);
1329 if (!gpio_is_valid(trf
->en_gpio
)) {
1330 dev_err(trf
->dev
, "No EN GPIO property\n");
1331 return trf
->en_gpio
;
1334 ret
= devm_gpio_request_one(trf
->dev
, trf
->en_gpio
,
1335 GPIOF_DIR_OUT
| GPIOF_INIT_LOW
, "trf7970a EN");
1337 dev_err(trf
->dev
, "Can't request EN GPIO: %d\n", ret
);
1341 trf
->en2_gpio
= of_get_named_gpio(np
, "ti,enable-gpios", 1);
1342 if (!gpio_is_valid(trf
->en2_gpio
)) {
1343 dev_err(trf
->dev
, "No EN2 GPIO property\n");
1344 return trf
->en2_gpio
;
1347 ret
= devm_gpio_request_one(trf
->dev
, trf
->en2_gpio
,
1348 GPIOF_DIR_OUT
| GPIOF_INIT_LOW
, "trf7970a EN2");
1350 dev_err(trf
->dev
, "Can't request EN2 GPIO: %d\n", ret
);
1354 if (of_property_read_bool(np
, "en2-rf-quirk"))
1355 trf
->quirks
|= TRF7970A_QUIRK_EN2_MUST_STAY_LOW
;
1357 ret
= devm_request_threaded_irq(trf
->dev
, spi
->irq
, NULL
,
1358 trf7970a_irq
, IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
1361 dev_err(trf
->dev
, "Can't request IRQ#%d: %d\n", spi
->irq
, ret
);
1365 mutex_init(&trf
->lock
);
1366 INIT_DELAYED_WORK(&trf
->timeout_work
, trf7970a_timeout_work_handler
);
1368 trf
->regulator
= devm_regulator_get(&spi
->dev
, "vin");
1369 if (IS_ERR(trf
->regulator
)) {
1370 ret
= PTR_ERR(trf
->regulator
);
1371 dev_err(trf
->dev
, "Can't get VIN regulator: %d\n", ret
);
1372 goto err_destroy_lock
;
1375 ret
= regulator_enable(trf
->regulator
);
1377 dev_err(trf
->dev
, "Can't enable VIN: %d\n", ret
);
1378 goto err_destroy_lock
;
1381 ret
= trf7970a_get_vin_voltage_override(np
, &uvolts
);
1383 uvolts
= regulator_get_voltage(trf
->regulator
);
1385 if (uvolts
> 4000000)
1386 trf
->chip_status_ctrl
= TRF7970A_CHIP_STATUS_VRS5_3
;
1388 trf
->ddev
= nfc_digital_allocate_device(&trf7970a_nfc_ops
,
1389 TRF7970A_SUPPORTED_PROTOCOLS
,
1390 NFC_DIGITAL_DRV_CAPS_IN_CRC
, 0, 0);
1392 dev_err(trf
->dev
, "Can't allocate NFC digital device\n");
1394 goto err_disable_regulator
;
1397 nfc_digital_set_parent_dev(trf
->ddev
, trf
->dev
);
1398 nfc_digital_set_drvdata(trf
->ddev
, trf
);
1399 spi_set_drvdata(spi
, trf
);
1401 autosuspend_delay
= trf7970a_get_autosuspend_delay(np
);
1403 pm_runtime_set_autosuspend_delay(trf
->dev
, autosuspend_delay
);
1404 pm_runtime_use_autosuspend(trf
->dev
);
1405 pm_runtime_enable(trf
->dev
);
1407 ret
= nfc_digital_register_device(trf
->ddev
);
1409 dev_err(trf
->dev
, "Can't register NFC digital device: %d\n",
1417 pm_runtime_disable(trf
->dev
);
1418 nfc_digital_free_device(trf
->ddev
);
1419 err_disable_regulator
:
1420 regulator_disable(trf
->regulator
);
1422 mutex_destroy(&trf
->lock
);
1426 static int trf7970a_remove(struct spi_device
*spi
)
1428 struct trf7970a
*trf
= spi_get_drvdata(spi
);
1430 mutex_lock(&trf
->lock
);
1432 switch (trf
->state
) {
1433 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
1434 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
1435 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
1436 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
1437 trf7970a_send_err_upstream(trf
, -ECANCELED
);
1439 case TRF7970A_ST_IDLE
:
1440 case TRF7970A_ST_IDLE_RX_BLOCKED
:
1441 pm_runtime_put_sync(trf
->dev
);
1447 mutex_unlock(&trf
->lock
);
1449 pm_runtime_disable(trf
->dev
);
1451 nfc_digital_unregister_device(trf
->ddev
);
1452 nfc_digital_free_device(trf
->ddev
);
1454 regulator_disable(trf
->regulator
);
1456 mutex_destroy(&trf
->lock
);
1461 #ifdef CONFIG_PM_RUNTIME
1462 static int trf7970a_pm_runtime_suspend(struct device
*dev
)
1464 struct spi_device
*spi
= container_of(dev
, struct spi_device
, dev
);
1465 struct trf7970a
*trf
= spi_get_drvdata(spi
);
1468 dev_dbg(dev
, "Runtime suspend\n");
1470 if (trf
->state
!= TRF7970A_ST_OFF
) {
1471 dev_dbg(dev
, "Can't suspend - not in OFF state (%d)\n",
1476 gpio_set_value(trf
->en_gpio
, 0);
1477 gpio_set_value(trf
->en2_gpio
, 0);
1479 ret
= regulator_disable(trf
->regulator
);
1481 dev_err(dev
, "%s - Can't disable VIN: %d\n", __func__
, ret
);
1486 static int trf7970a_pm_runtime_resume(struct device
*dev
)
1488 struct spi_device
*spi
= container_of(dev
, struct spi_device
, dev
);
1489 struct trf7970a
*trf
= spi_get_drvdata(spi
);
1492 dev_dbg(dev
, "Runtime resume\n");
1494 ret
= regulator_enable(trf
->regulator
);
1496 dev_err(dev
, "%s - Can't enable VIN: %d\n", __func__
, ret
);
1500 usleep_range(5000, 6000);
1502 if (!(trf
->quirks
& TRF7970A_QUIRK_EN2_MUST_STAY_LOW
)) {
1503 gpio_set_value(trf
->en2_gpio
, 1);
1504 usleep_range(1000, 2000);
1507 gpio_set_value(trf
->en_gpio
, 1);
1509 usleep_range(20000, 21000);
1511 pm_runtime_mark_last_busy(dev
);
1517 static const struct dev_pm_ops trf7970a_pm_ops
= {
1518 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend
,
1519 trf7970a_pm_runtime_resume
, NULL
)
1522 static const struct spi_device_id trf7970a_id_table
[] = {
1526 MODULE_DEVICE_TABLE(spi
, trf7970a_id_table
);
1528 static struct spi_driver trf7970a_spi_driver
= {
1529 .probe
= trf7970a_probe
,
1530 .remove
= trf7970a_remove
,
1531 .id_table
= trf7970a_id_table
,
1534 .owner
= THIS_MODULE
,
1535 .pm
= &trf7970a_pm_ops
,
1539 module_spi_driver(trf7970a_spi_driver
);
1541 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1542 MODULE_LICENSE("GPL v2");
1543 MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");