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/consumer.h>
25 #include <linux/spi/spi.h>
26 #include <linux/regulator/consumer.h>
28 #include <net/nfc/nfc.h>
29 #include <net/nfc/digital.h>
31 /* There are 3 ways the host can communicate with the trf7970a:
32 * parallel mode, SPI with Slave Select (SS) mode, and SPI without
33 * SS mode. The driver only supports the two SPI modes.
35 * The trf7970a is very timing sensitive and the VIN, EN2, and EN
36 * pins must asserted in that order and with specific delays in between.
37 * The delays used in the driver were provided by TI and have been
38 * confirmed to work with this driver. There is a bug with the current
39 * version of the trf7970a that requires that EN2 remain low no matter
40 * what. If it goes high, it will generate an RF field even when in
41 * passive target mode. TI has indicated that the chip will work okay
42 * when EN2 is left low. The 'en2-rf-quirk' device tree property
43 * indicates that trf7970a currently being used has the erratum and
44 * that EN2 must be kept low.
46 * Timeouts are implemented using the delayed workqueue kernel facility.
47 * Timeouts are required so things don't hang when there is no response
48 * from the trf7970a (or tag). Using this mechanism creates a race with
49 * interrupts, however. That is, an interrupt and a timeout could occur
50 * closely enough together that one is blocked by the mutex while the other
51 * executes. When the timeout handler executes first and blocks the
52 * interrupt handler, it will eventually set the state to IDLE so the
53 * interrupt handler will check the state and exit with no harm done.
54 * When the interrupt handler executes first and blocks the timeout handler,
55 * the cancel_delayed_work() call will know that it didn't cancel the
56 * work item (i.e., timeout) and will return zero. That return code is
57 * used by the timer handler to indicate that it should ignore the timeout
60 * Aborting an active command isn't as simple as it seems because the only
61 * way to abort a command that's already been sent to the tag is so turn
62 * off power to the tag. If we do that, though, we'd have to go through
63 * the entire anticollision procedure again but the digital layer doesn't
64 * support that. So, if an abort is received before trf7970a_send_cmd()
65 * has sent the command to the tag, it simply returns -ECANCELED. If the
66 * command has already been sent to the tag, then the driver continues
67 * normally and recieves the response data (or error) but just before
68 * sending the data upstream, it frees the rx_skb and sends -ECANCELED
69 * upstream instead. If the command failed, that error will be sent
72 * When recieving data from a tag and the interrupt status register has
73 * only the SRX bit set, it means that all of the data has been received
74 * (once what's in the fifo has been read). However, depending on timing
75 * an interrupt status with only the SRX bit set may not be recived. In
76 * those cases, the timeout mechanism is used to wait 20 ms in case more
77 * data arrives. After 20 ms, it is assumed that all of the data has been
78 * received and the accumulated rx data is sent upstream. The
79 * 'TRF7970A_ST_WAIT_FOR_RX_DATA_CONT' state is used for this purpose
80 * (i.e., it indicates that some data has been received but we're not sure
81 * if there is more coming so a timeout in this state means all data has
82 * been received and there isn't an error). The delay is 20 ms since delays
83 * of ~16 ms have been observed during testing.
85 * When transmitting a frame larger than the FIFO size (127 bytes), the
86 * driver will wait 20 ms for the FIFO to drain past the low-watermark
87 * and generate an interrupt. The low-watermark set to 32 bytes so the
88 * interrupt should fire after 127 - 32 = 95 bytes have been sent. At
89 * the lowest possible bit rate (6.62 kbps for 15693), it will take up
90 * to ~14.35 ms so 20 ms is used for the timeout.
92 * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
93 * Having only 4 bits in the FIFO won't normally generate an interrupt so
94 * driver enables the '4_bit_RX' bit of the Special Functions register 1
95 * to cause an interrupt in that case. Leaving that bit for a read command
96 * messes up the data returned so it is only enabled when the framing is
97 * 'NFC_DIGITAL_FRAMING_NFCA_T2T' and the command is not a read command.
98 * Unfortunately, that means that the driver has to peek into tx frames
99 * when the framing is 'NFC_DIGITAL_FRAMING_NFCA_T2T'. This is done by
100 * the trf7970a_per_cmd_config() routine.
102 * ISO/IEC 15693 frames specify whether to use single or double sub-carrier
103 * frequencies and whether to use low or high data rates in the flags byte
104 * of the frame. This means that the driver has to peek at all 15693 frames
105 * to determine what speed to set the communication to. In addition, write
106 * and lock commands use the OPTION flag to indicate that an EOF must be
107 * sent to the tag before it will send its response. So the driver has to
108 * examine all frames for that reason too.
110 * It is unclear how long to wait before sending the EOF. According to the
111 * Note under Table 1-1 in section 1.6 of
112 * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
113 * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
114 * enough so 20 ms is used. So the timer is set to 40 ms - 20 ms to drain
115 * up to 127 bytes in the FIFO at the lowest bit rate plus another 20 ms to
116 * ensure the wait is long enough before sending the EOF. This seems to work
120 #define TRF7970A_SUPPORTED_PROTOCOLS \
121 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \
122 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \
123 NFC_PROTO_ISO15693_MASK | NFC_PROTO_NFC_DEP_MASK)
125 #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
126 #define TRF7970A_13MHZ_CLOCK_FREQUENCY 13560000
127 #define TRF7970A_27MHZ_CLOCK_FREQUENCY 27120000
129 #define TRF7970A_RX_SKB_ALLOC_SIZE 256
131 #define TRF7970A_FIFO_SIZE 127
133 /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
134 #define TRF7970A_TX_MAX (4096 - 1)
136 #define TRF7970A_WAIT_FOR_TX_IRQ 20
137 #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
138 #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 20
139 #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 40
141 /* Guard times for various RF technologies (in us) */
142 #define TRF7970A_GUARD_TIME_NFCA 5000
143 #define TRF7970A_GUARD_TIME_NFCB 5000
144 #define TRF7970A_GUARD_TIME_NFCF 20000
145 #define TRF7970A_GUARD_TIME_15693 1000
148 /* Erratum: When reading IRQ Status register on trf7970a, we must issue a
149 * read continuous command for IRQ Status and Collision Position registers.
151 #define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0)
152 #define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1)
153 #define TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE BIT(2)
155 /* Direct commands */
156 #define TRF7970A_CMD_IDLE 0x00
157 #define TRF7970A_CMD_SOFT_INIT 0x03
158 #define TRF7970A_CMD_RF_COLLISION 0x04
159 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0x05
160 #define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0x06
161 #define TRF7970A_CMD_FIFO_RESET 0x0f
162 #define TRF7970A_CMD_TRANSMIT_NO_CRC 0x10
163 #define TRF7970A_CMD_TRANSMIT 0x11
164 #define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0x12
165 #define TRF7970A_CMD_DELAY_TRANSMIT 0x13
166 #define TRF7970A_CMD_EOF 0x14
167 #define TRF7970A_CMD_CLOSE_SLOT 0x15
168 #define TRF7970A_CMD_BLOCK_RX 0x16
169 #define TRF7970A_CMD_ENABLE_RX 0x17
170 #define TRF7970A_CMD_TEST_INT_RF 0x18
171 #define TRF7970A_CMD_TEST_EXT_RF 0x19
172 #define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
174 /* Bits determining whether its a direct command or register R/W,
175 * whether to use a continuous SPI transaction or not, and the actual
176 * direct cmd opcode or regster address.
178 #define TRF7970A_CMD_BIT_CTRL BIT(7)
179 #define TRF7970A_CMD_BIT_RW BIT(6)
180 #define TRF7970A_CMD_BIT_CONTINUOUS BIT(5)
181 #define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0x1f)
183 /* Registers addresses */
184 #define TRF7970A_CHIP_STATUS_CTRL 0x00
185 #define TRF7970A_ISO_CTRL 0x01
186 #define TRF7970A_ISO14443B_TX_OPTIONS 0x02
187 #define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
188 #define TRF7970A_TX_TIMER_SETTING_H_BYTE 0x04
189 #define TRF7970A_TX_TIMER_SETTING_L_BYTE 0x05
190 #define TRF7970A_TX_PULSE_LENGTH_CTRL 0x06
191 #define TRF7970A_RX_NO_RESPONSE_WAIT 0x07
192 #define TRF7970A_RX_WAIT_TIME 0x08
193 #define TRF7970A_MODULATOR_SYS_CLK_CTRL 0x09
194 #define TRF7970A_RX_SPECIAL_SETTINGS 0x0a
195 #define TRF7970A_REG_IO_CTRL 0x0b
196 #define TRF7970A_IRQ_STATUS 0x0c
197 #define TRF7970A_COLLISION_IRQ_MASK 0x0d
198 #define TRF7970A_COLLISION_POSITION 0x0e
199 #define TRF7970A_RSSI_OSC_STATUS 0x0f
200 #define TRF7970A_SPECIAL_FCN_REG1 0x10
201 #define TRF7970A_SPECIAL_FCN_REG2 0x11
202 #define TRF7970A_RAM1 0x12
203 #define TRF7970A_RAM2 0x13
204 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0x14
205 #define TRF7970A_NFC_LOW_FIELD_LEVEL 0x16
206 #define TRF7970A_NFCID1 0x17
207 #define TRF7970A_NFC_TARGET_LEVEL 0x18
208 #define TRF79070A_NFC_TARGET_PROTOCOL 0x19
209 #define TRF7970A_TEST_REGISTER1 0x1a
210 #define TRF7970A_TEST_REGISTER2 0x1b
211 #define TRF7970A_FIFO_STATUS 0x1c
212 #define TRF7970A_TX_LENGTH_BYTE1 0x1d
213 #define TRF7970A_TX_LENGTH_BYTE2 0x1e
214 #define TRF7970A_FIFO_IO_REGISTER 0x1f
216 /* Chip Status Control Register Bits */
217 #define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0)
218 #define TRF7970A_CHIP_STATUS_REC_ON BIT(1)
219 #define TRF7970A_CHIP_STATUS_AGC_ON BIT(2)
220 #define TRF7970A_CHIP_STATUS_PM_ON BIT(3)
221 #define TRF7970A_CHIP_STATUS_RF_PWR BIT(4)
222 #define TRF7970A_CHIP_STATUS_RF_ON BIT(5)
223 #define TRF7970A_CHIP_STATUS_DIRECT BIT(6)
224 #define TRF7970A_CHIP_STATUS_STBY BIT(7)
226 /* ISO Control Register Bits */
227 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0x00
228 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0x01
229 #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0x02
230 #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
231 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0x04
232 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0x05
233 #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0x06
234 #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
235 #define TRF7970A_ISO_CTRL_14443A_106 0x08
236 #define TRF7970A_ISO_CTRL_14443A_212 0x09
237 #define TRF7970A_ISO_CTRL_14443A_424 0x0a
238 #define TRF7970A_ISO_CTRL_14443A_848 0x0b
239 #define TRF7970A_ISO_CTRL_14443B_106 0x0c
240 #define TRF7970A_ISO_CTRL_14443B_212 0x0d
241 #define TRF7970A_ISO_CTRL_14443B_424 0x0e
242 #define TRF7970A_ISO_CTRL_14443B_848 0x0f
243 #define TRF7970A_ISO_CTRL_FELICA_212 0x1a
244 #define TRF7970A_ISO_CTRL_FELICA_424 0x1b
245 #define TRF7970A_ISO_CTRL_NFC_NFCA_106 0x01
246 #define TRF7970A_ISO_CTRL_NFC_NFCF_212 0x02
247 #define TRF7970A_ISO_CTRL_NFC_NFCF_424 0x03
248 #define TRF7970A_ISO_CTRL_NFC_CE_14443A 0x00
249 #define TRF7970A_ISO_CTRL_NFC_CE_14443B 0x01
250 #define TRF7970A_ISO_CTRL_NFC_CE BIT(2)
251 #define TRF7970A_ISO_CTRL_NFC_ACTIVE BIT(3)
252 #define TRF7970A_ISO_CTRL_NFC_INITIATOR BIT(4)
253 #define TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE BIT(5)
254 #define TRF7970A_ISO_CTRL_RFID BIT(5)
255 #define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
256 #define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
258 #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0x1f
260 /* Modulator and SYS_CLK Control Register Bits */
261 #define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0x7)
262 #define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0))
263 #define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1))
264 #define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2))
265 #define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3))
266 #define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4))
267 #define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5))
268 #define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6))
269 #define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7))
270 #define TRF7970A_MODULATOR_EN_ANA BIT(3)
271 #define TRF7970A_MODULATOR_CLK(n) (((n) & 0x3) << 4)
272 #define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0))
273 #define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1))
274 #define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2))
275 #define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3))
276 #define TRF7970A_MODULATOR_EN_OOK BIT(6)
277 #define TRF7970A_MODULATOR_27MHZ BIT(7)
279 #define TRF7970A_RX_SPECIAL_SETTINGS_NO_LIM BIT(0)
280 #define TRF7970A_RX_SPECIAL_SETTINGS_AGCR BIT(1)
281 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_0DB (0x0 << 2)
282 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_5DB (0x1 << 2)
283 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_10DB (0x2 << 2)
284 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_15DB (0x3 << 2)
285 #define TRF7970A_RX_SPECIAL_SETTINGS_HBT BIT(4)
286 #define TRF7970A_RX_SPECIAL_SETTINGS_M848 BIT(5)
287 #define TRF7970A_RX_SPECIAL_SETTINGS_C424 BIT(6)
288 #define TRF7970A_RX_SPECIAL_SETTINGS_C212 BIT(7)
290 #define TRF7970A_REG_IO_CTRL_VRS(v) ((v) & 0x07)
291 #define TRF7970A_REG_IO_CTRL_IO_LOW BIT(5)
292 #define TRF7970A_REG_IO_CTRL_EN_EXT_PA BIT(6)
293 #define TRF7970A_REG_IO_CTRL_AUTO_REG BIT(7)
295 /* IRQ Status Register Bits */
296 #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
297 #define TRF7970A_IRQ_STATUS_NFC_COL_ERROR BIT(0)
298 #define TRF7970A_IRQ_STATUS_COL BIT(1)
299 #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
300 #define TRF7970A_IRQ_STATUS_NFC_RF BIT(2)
301 #define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
302 #define TRF7970A_IRQ_STATUS_NFC_SDD BIT(3)
303 #define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
304 #define TRF7970A_IRQ_STATUS_NFC_PROTO_ERROR BIT(4)
305 #define TRF7970A_IRQ_STATUS_FIFO BIT(5)
306 #define TRF7970A_IRQ_STATUS_SRX BIT(6)
307 #define TRF7970A_IRQ_STATUS_TX BIT(7)
309 #define TRF7970A_IRQ_STATUS_ERROR \
310 (TRF7970A_IRQ_STATUS_COL | \
311 TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR | \
312 TRF7970A_IRQ_STATUS_PARITY_ERROR | \
313 TRF7970A_IRQ_STATUS_CRC_ERROR)
315 #define TRF7970A_RSSI_OSC_STATUS_RSSI_MASK (BIT(2) | BIT(1) | BIT(0))
316 #define TRF7970A_RSSI_OSC_STATUS_RSSI_X_MASK (BIT(5) | BIT(4) | BIT(3))
317 #define TRF7970A_RSSI_OSC_STATUS_RSSI_OSC_OK BIT(6)
319 #define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
320 #define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
321 #define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
322 #define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3)
323 #define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4)
324 #define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5)
326 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0x0 << 2)
327 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0x1 << 2)
328 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0x2 << 2)
329 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0x3 << 2)
330 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0x0
331 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0x1
332 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
333 #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
335 #define TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(v) ((v) & 0x07)
336 #define TRF7970A_NFC_LOW_FIELD_LEVEL_CLEX_DIS BIT(7)
338 #define TRF7970A_NFC_TARGET_LEVEL_RFDET(v) ((v) & 0x07)
339 #define TRF7970A_NFC_TARGET_LEVEL_HI_RF BIT(3)
340 #define TRF7970A_NFC_TARGET_LEVEL_SDD_EN BIT(5)
341 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_4BYTES (0x0 << 6)
342 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_7BYTES (0x1 << 6)
343 #define TRF7970A_NFC_TARGET_LEVEL_LD_S_10BYTES (0x2 << 6)
345 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106 BIT(0)
346 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212 BIT(1)
347 #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424 (BIT(0) | BIT(1))
348 #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B BIT(2)
349 #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 BIT(3)
350 #define TRF79070A_NFC_TARGET_PROTOCOL_FELICA BIT(4)
351 #define TRF79070A_NFC_TARGET_PROTOCOL_RF_L BIT(6)
352 #define TRF79070A_NFC_TARGET_PROTOCOL_RF_H BIT(7)
354 #define TRF79070A_NFC_TARGET_PROTOCOL_106A \
355 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
356 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
357 TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 | \
358 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
360 #define TRF79070A_NFC_TARGET_PROTOCOL_106B \
361 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
362 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
363 TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B | \
364 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
366 #define TRF79070A_NFC_TARGET_PROTOCOL_212F \
367 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
368 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
369 TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
370 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212)
372 #define TRF79070A_NFC_TARGET_PROTOCOL_424F \
373 (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
374 TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
375 TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
376 TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424)
378 #define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
380 /* NFC (ISO/IEC 14443A) Type 2 Tag commands */
381 #define NFC_T2T_CMD_READ 0x30
383 /* ISO 15693 commands codes */
384 #define ISO15693_CMD_INVENTORY 0x01
385 #define ISO15693_CMD_READ_SINGLE_BLOCK 0x20
386 #define ISO15693_CMD_WRITE_SINGLE_BLOCK 0x21
387 #define ISO15693_CMD_LOCK_BLOCK 0x22
388 #define ISO15693_CMD_READ_MULTIPLE_BLOCK 0x23
389 #define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0x24
390 #define ISO15693_CMD_SELECT 0x25
391 #define ISO15693_CMD_RESET_TO_READY 0x26
392 #define ISO15693_CMD_WRITE_AFI 0x27
393 #define ISO15693_CMD_LOCK_AFI 0x28
394 #define ISO15693_CMD_WRITE_DSFID 0x29
395 #define ISO15693_CMD_LOCK_DSFID 0x2a
396 #define ISO15693_CMD_GET_SYSTEM_INFO 0x2b
397 #define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
399 /* ISO 15693 request and response flags */
400 #define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0)
401 #define ISO15693_REQ_FLAG_DATA_RATE BIT(1)
402 #define ISO15693_REQ_FLAG_INVENTORY BIT(2)
403 #define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3)
404 #define ISO15693_REQ_FLAG_SELECT BIT(4)
405 #define ISO15693_REQ_FLAG_AFI BIT(4)
406 #define ISO15693_REQ_FLAG_ADDRESS BIT(5)
407 #define ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
408 #define ISO15693_REQ_FLAG_OPTION BIT(6)
410 #define ISO15693_REQ_FLAG_SPEED_MASK \
411 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
413 enum trf7970a_state
{
417 TRF7970A_ST_IDLE_RX_BLOCKED
,
418 TRF7970A_ST_WAIT_FOR_TX_FIFO
,
419 TRF7970A_ST_WAIT_FOR_RX_DATA
,
420 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
,
421 TRF7970A_ST_WAIT_TO_ISSUE_EOF
,
422 TRF7970A_ST_LISTENING
,
423 TRF7970A_ST_LISTENING_MD
,
428 enum trf7970a_state state
;
430 struct spi_device
*spi
;
431 struct regulator
*regulator
;
432 struct nfc_digital_dev
*ddev
;
436 struct sk_buff
*tx_skb
;
437 struct sk_buff
*rx_skb
;
438 nfc_digital_cmd_complete_t cb
;
443 u8 modulator_sys_clk_ctrl
;
446 unsigned int guard_time
;
452 bool adjust_resp_len
;
453 struct gpio_desc
*en_gpiod
;
454 struct gpio_desc
*en2_gpiod
;
456 unsigned int timeout
;
458 struct delayed_work timeout_work
;
461 static int trf7970a_cmd(struct trf7970a
*trf
, u8 opcode
)
463 u8 cmd
= TRF7970A_CMD_BIT_CTRL
| TRF7970A_CMD_BIT_OPCODE(opcode
);
466 dev_dbg(trf
->dev
, "cmd: 0x%x\n", cmd
);
468 ret
= spi_write(trf
->spi
, &cmd
, 1);
470 dev_err(trf
->dev
, "%s - cmd: 0x%x, ret: %d\n", __func__
, cmd
,
475 static int trf7970a_read(struct trf7970a
*trf
, u8 reg
, u8
*val
)
477 u8 addr
= TRF7970A_CMD_BIT_RW
| reg
;
480 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, val
, 1);
482 dev_err(trf
->dev
, "%s - addr: 0x%x, ret: %d\n", __func__
, addr
,
485 dev_dbg(trf
->dev
, "read(0x%x): 0x%x\n", addr
, *val
);
490 static int trf7970a_read_cont(struct trf7970a
*trf
, u8 reg
, u8
*buf
,
493 u8 addr
= reg
| TRF7970A_CMD_BIT_RW
| TRF7970A_CMD_BIT_CONTINUOUS
;
494 struct spi_transfer t
[2];
495 struct spi_message m
;
498 dev_dbg(trf
->dev
, "read_cont(0x%x, %zd)\n", addr
, len
);
500 spi_message_init(&m
);
502 memset(&t
, 0, sizeof(t
));
505 t
[0].len
= sizeof(addr
);
506 spi_message_add_tail(&t
[0], &m
);
510 spi_message_add_tail(&t
[1], &m
);
512 ret
= spi_sync(trf
->spi
, &m
);
514 dev_err(trf
->dev
, "%s - addr: 0x%x, ret: %d\n", __func__
, addr
,
519 static int trf7970a_write(struct trf7970a
*trf
, u8 reg
, u8 val
)
521 u8 buf
[2] = { reg
, val
};
524 dev_dbg(trf
->dev
, "write(0x%x): 0x%x\n", reg
, val
);
526 ret
= spi_write(trf
->spi
, buf
, 2);
528 dev_err(trf
->dev
, "%s - write: 0x%x 0x%x, ret: %d\n", __func__
,
529 buf
[0], buf
[1], ret
);
534 static int trf7970a_read_irqstatus(struct trf7970a
*trf
, u8
*status
)
540 addr
= TRF7970A_IRQ_STATUS
| TRF7970A_CMD_BIT_RW
;
542 if (trf
->quirks
& TRF7970A_QUIRK_IRQ_STATUS_READ
) {
543 addr
|= TRF7970A_CMD_BIT_CONTINUOUS
;
544 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, buf
, 2);
546 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, buf
, 1);
550 dev_err(trf
->dev
, "%s - irqstatus: Status read failed: %d\n",
558 static int trf7970a_read_target_proto(struct trf7970a
*trf
, u8
*target_proto
)
564 addr
= TRF79070A_NFC_TARGET_PROTOCOL
| TRF7970A_CMD_BIT_RW
|
565 TRF7970A_CMD_BIT_CONTINUOUS
;
567 ret
= spi_write_then_read(trf
->spi
, &addr
, 1, buf
, 2);
569 dev_err(trf
->dev
, "%s - target_proto: Read failed: %d\n",
572 *target_proto
= buf
[0];
577 static int trf7970a_mode_detect(struct trf7970a
*trf
, u8
*rf_tech
)
580 u8 target_proto
, tech
;
582 ret
= trf7970a_read_target_proto(trf
, &target_proto
);
586 switch (target_proto
) {
587 case TRF79070A_NFC_TARGET_PROTOCOL_106A
:
588 tech
= NFC_DIGITAL_RF_TECH_106A
;
590 case TRF79070A_NFC_TARGET_PROTOCOL_106B
:
591 tech
= NFC_DIGITAL_RF_TECH_106B
;
593 case TRF79070A_NFC_TARGET_PROTOCOL_212F
:
594 tech
= NFC_DIGITAL_RF_TECH_212F
;
596 case TRF79070A_NFC_TARGET_PROTOCOL_424F
:
597 tech
= NFC_DIGITAL_RF_TECH_424F
;
600 dev_dbg(trf
->dev
, "%s - mode_detect: target_proto: 0x%x\n",
601 __func__
, target_proto
);
610 static void trf7970a_send_upstream(struct trf7970a
*trf
)
612 dev_kfree_skb_any(trf
->tx_skb
);
615 if (trf
->rx_skb
&& !IS_ERR(trf
->rx_skb
) && !trf
->aborting
)
616 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE
,
617 16, 1, trf
->rx_skb
->data
, trf
->rx_skb
->len
,
620 trf
->state
= TRF7970A_ST_IDLE
;
623 dev_dbg(trf
->dev
, "Abort process complete\n");
625 if (!IS_ERR(trf
->rx_skb
)) {
626 kfree_skb(trf
->rx_skb
);
627 trf
->rx_skb
= ERR_PTR(-ECANCELED
);
630 trf
->aborting
= false;
633 if (trf
->adjust_resp_len
) {
635 skb_trim(trf
->rx_skb
, trf
->rx_skb
->len
- 1);
637 trf
->adjust_resp_len
= false;
640 trf
->cb(trf
->ddev
, trf
->cb_arg
, trf
->rx_skb
);
645 static void trf7970a_send_err_upstream(struct trf7970a
*trf
, int errno
)
647 dev_dbg(trf
->dev
, "Error - state: %d, errno: %d\n", trf
->state
, errno
);
649 cancel_delayed_work(&trf
->timeout_work
);
651 kfree_skb(trf
->rx_skb
);
652 trf
->rx_skb
= ERR_PTR(errno
);
654 trf7970a_send_upstream(trf
);
657 static int trf7970a_transmit(struct trf7970a
*trf
, struct sk_buff
*skb
,
658 unsigned int len
, u8
*prefix
,
659 unsigned int prefix_len
)
661 struct spi_transfer t
[2];
662 struct spi_message m
;
663 unsigned int timeout
;
666 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE
,
667 16, 1, skb
->data
, len
, false);
669 spi_message_init(&m
);
671 memset(&t
, 0, sizeof(t
));
673 t
[0].tx_buf
= prefix
;
674 t
[0].len
= prefix_len
;
675 spi_message_add_tail(&t
[0], &m
);
677 t
[1].tx_buf
= skb
->data
;
679 spi_message_add_tail(&t
[1], &m
);
681 ret
= spi_sync(trf
->spi
, &m
);
683 dev_err(trf
->dev
, "%s - Can't send tx data: %d\n", __func__
,
691 trf
->state
= TRF7970A_ST_WAIT_FOR_TX_FIFO
;
692 timeout
= TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT
;
694 if (trf
->issue_eof
) {
695 trf
->state
= TRF7970A_ST_WAIT_TO_ISSUE_EOF
;
696 timeout
= TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF
;
698 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA
;
701 timeout
= TRF7970A_WAIT_FOR_TX_IRQ
;
703 timeout
= trf
->timeout
;
707 dev_dbg(trf
->dev
, "Setting timeout for %d ms, state: %d\n", timeout
,
710 schedule_delayed_work(&trf
->timeout_work
, msecs_to_jiffies(timeout
));
715 static void trf7970a_fill_fifo(struct trf7970a
*trf
)
717 struct sk_buff
*skb
= trf
->tx_skb
;
723 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
, &fifo_bytes
);
725 trf7970a_send_err_upstream(trf
, ret
);
729 dev_dbg(trf
->dev
, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes
);
731 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
733 /* Calculate how much more data can be written to the fifo */
734 len
= TRF7970A_FIFO_SIZE
- fifo_bytes
;
736 schedule_delayed_work(&trf
->timeout_work
,
737 msecs_to_jiffies(TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT
));
741 len
= min(skb
->len
, len
);
743 prefix
= TRF7970A_CMD_BIT_CONTINUOUS
| TRF7970A_FIFO_IO_REGISTER
;
745 ret
= trf7970a_transmit(trf
, skb
, len
, &prefix
, sizeof(prefix
));
747 trf7970a_send_err_upstream(trf
, ret
);
750 static void trf7970a_drain_fifo(struct trf7970a
*trf
, u8 status
)
752 struct sk_buff
*skb
= trf
->rx_skb
;
756 if (status
& TRF7970A_IRQ_STATUS_ERROR
) {
757 trf7970a_send_err_upstream(trf
, -EIO
);
761 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
, &fifo_bytes
);
763 trf7970a_send_err_upstream(trf
, ret
);
767 dev_dbg(trf
->dev
, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes
);
769 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
774 if (fifo_bytes
> skb_tailroom(skb
)) {
775 skb
= skb_copy_expand(skb
, skb_headroom(skb
),
776 max_t(int, fifo_bytes
,
777 TRF7970A_RX_SKB_ALLOC_SIZE
),
780 trf7970a_send_err_upstream(trf
, -ENOMEM
);
784 kfree_skb(trf
->rx_skb
);
788 ret
= trf7970a_read_cont(trf
, TRF7970A_FIFO_IO_REGISTER
,
789 skb_put(skb
, fifo_bytes
), fifo_bytes
);
791 trf7970a_send_err_upstream(trf
, ret
);
795 /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
796 if ((trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_T2T
) && (skb
->len
== 1) &&
797 (trf
->special_fcn_reg1
== TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX
)) {
799 status
= TRF7970A_IRQ_STATUS_SRX
;
801 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
;
803 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
, &fifo_bytes
);
805 trf7970a_send_err_upstream(trf
, ret
);
809 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
811 /* If there are bytes in the FIFO, set status to '0' so
812 * the if stmt below doesn't fire and the driver will wait
813 * for the trf7970a to generate another RX interrupt.
820 if (status
== TRF7970A_IRQ_STATUS_SRX
) { /* Receive complete */
821 trf7970a_send_upstream(trf
);
825 dev_dbg(trf
->dev
, "Setting timeout for %d ms\n",
826 TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT
);
828 schedule_delayed_work(&trf
->timeout_work
,
829 msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT
));
832 static irqreturn_t
trf7970a_irq(int irq
, void *dev_id
)
834 struct trf7970a
*trf
= dev_id
;
836 u8 status
, fifo_bytes
, iso_ctrl
;
838 mutex_lock(&trf
->lock
);
840 if (trf
->state
== TRF7970A_ST_RF_OFF
) {
841 mutex_unlock(&trf
->lock
);
845 ret
= trf7970a_read_irqstatus(trf
, &status
);
847 mutex_unlock(&trf
->lock
);
851 dev_dbg(trf
->dev
, "IRQ - state: %d, status: 0x%x\n", trf
->state
,
855 mutex_unlock(&trf
->lock
);
859 switch (trf
->state
) {
860 case TRF7970A_ST_IDLE
:
861 case TRF7970A_ST_IDLE_RX_BLOCKED
:
862 /* If initiator and getting interrupts caused by RF noise,
863 * turn off the receiver to avoid unnecessary interrupts.
864 * It will be turned back on in trf7970a_send_cmd() when
865 * the next command is issued.
867 if (trf
->is_initiator
&& (status
& TRF7970A_IRQ_STATUS_ERROR
)) {
868 trf7970a_cmd(trf
, TRF7970A_CMD_BLOCK_RX
);
869 trf
->state
= TRF7970A_ST_IDLE_RX_BLOCKED
;
872 trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
874 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
875 if (status
& TRF7970A_IRQ_STATUS_TX
) {
876 trf
->ignore_timeout
=
877 !cancel_delayed_work(&trf
->timeout_work
);
878 trf7970a_fill_fifo(trf
);
880 trf7970a_send_err_upstream(trf
, -EIO
);
883 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
884 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
885 if (status
& TRF7970A_IRQ_STATUS_SRX
) {
886 trf
->ignore_timeout
=
887 !cancel_delayed_work(&trf
->timeout_work
);
888 trf7970a_drain_fifo(trf
, status
);
889 } else if (status
& TRF7970A_IRQ_STATUS_FIFO
) {
890 ret
= trf7970a_read(trf
, TRF7970A_FIFO_STATUS
,
893 fifo_bytes
&= ~TRF7970A_FIFO_STATUS_OVERFLOW
;
896 trf7970a_send_err_upstream(trf
, ret
);
897 else if (!fifo_bytes
)
898 trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
899 } else if ((status
== TRF7970A_IRQ_STATUS_TX
) ||
900 (!trf
->is_initiator
&&
901 (status
== (TRF7970A_IRQ_STATUS_TX
|
902 TRF7970A_IRQ_STATUS_NFC_RF
)))) {
903 trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
906 trf
->ignore_timeout
=
907 !cancel_delayed_work(&trf
->timeout_work
);
908 trf
->rx_skb
= ERR_PTR(0);
909 trf7970a_send_upstream(trf
);
913 if (trf
->is_initiator
)
916 iso_ctrl
= trf
->iso_ctrl
;
918 switch (trf
->framing
) {
919 case NFC_DIGITAL_FRAMING_NFCA_STANDARD
:
920 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT_NO_CRC
;
921 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
922 trf
->iso_ctrl
= 0xff; /* Force ISO_CTRL write */
924 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A
:
925 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
926 iso_ctrl
&= ~TRF7970A_ISO_CTRL_RX_CRC_N
;
927 trf
->iso_ctrl
= 0xff; /* Force ISO_CTRL write */
929 case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE
:
930 ret
= trf7970a_write(trf
,
931 TRF7970A_SPECIAL_FCN_REG1
,
932 TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL
);
934 goto err_unlock_exit
;
936 trf
->special_fcn_reg1
=
937 TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL
;
943 if (iso_ctrl
!= trf
->iso_ctrl
) {
944 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
,
947 goto err_unlock_exit
;
949 trf
->iso_ctrl
= iso_ctrl
;
952 trf7970a_send_err_upstream(trf
, -EIO
);
955 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
956 if (status
!= TRF7970A_IRQ_STATUS_TX
)
957 trf7970a_send_err_upstream(trf
, -EIO
);
959 case TRF7970A_ST_LISTENING
:
960 if (status
& TRF7970A_IRQ_STATUS_SRX
) {
961 trf
->ignore_timeout
=
962 !cancel_delayed_work(&trf
->timeout_work
);
963 trf7970a_drain_fifo(trf
, status
);
964 } else if (!(status
& TRF7970A_IRQ_STATUS_NFC_RF
)) {
965 trf7970a_send_err_upstream(trf
, -EIO
);
968 case TRF7970A_ST_LISTENING_MD
:
969 if (status
& TRF7970A_IRQ_STATUS_SRX
) {
970 trf
->ignore_timeout
=
971 !cancel_delayed_work(&trf
->timeout_work
);
973 ret
= trf7970a_mode_detect(trf
, &trf
->md_rf_tech
);
975 trf7970a_send_err_upstream(trf
, ret
);
977 trf
->state
= TRF7970A_ST_LISTENING
;
978 trf7970a_drain_fifo(trf
, status
);
980 } else if (!(status
& TRF7970A_IRQ_STATUS_NFC_RF
)) {
981 trf7970a_send_err_upstream(trf
, -EIO
);
985 dev_err(trf
->dev
, "%s - Driver in invalid state: %d\n",
986 __func__
, trf
->state
);
990 mutex_unlock(&trf
->lock
);
994 static void trf7970a_issue_eof(struct trf7970a
*trf
)
998 dev_dbg(trf
->dev
, "Issuing EOF\n");
1000 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_FIFO_RESET
);
1002 trf7970a_send_err_upstream(trf
, ret
);
1004 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_EOF
);
1006 trf7970a_send_err_upstream(trf
, ret
);
1008 trf
->state
= TRF7970A_ST_WAIT_FOR_RX_DATA
;
1010 dev_dbg(trf
->dev
, "Setting timeout for %d ms, state: %d\n",
1011 trf
->timeout
, trf
->state
);
1013 schedule_delayed_work(&trf
->timeout_work
,
1014 msecs_to_jiffies(trf
->timeout
));
1017 static void trf7970a_timeout_work_handler(struct work_struct
*work
)
1019 struct trf7970a
*trf
= container_of(work
, struct trf7970a
,
1022 dev_dbg(trf
->dev
, "Timeout - state: %d, ignore_timeout: %d\n",
1023 trf
->state
, trf
->ignore_timeout
);
1025 mutex_lock(&trf
->lock
);
1027 if (trf
->ignore_timeout
)
1028 trf
->ignore_timeout
= false;
1029 else if (trf
->state
== TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
)
1030 trf7970a_drain_fifo(trf
, TRF7970A_IRQ_STATUS_SRX
);
1031 else if (trf
->state
== TRF7970A_ST_WAIT_TO_ISSUE_EOF
)
1032 trf7970a_issue_eof(trf
);
1034 trf7970a_send_err_upstream(trf
, -ETIMEDOUT
);
1036 mutex_unlock(&trf
->lock
);
1039 static int trf7970a_init(struct trf7970a
*trf
)
1043 dev_dbg(trf
->dev
, "Initializing device - state: %d\n", trf
->state
);
1045 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_SOFT_INIT
);
1049 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_IDLE
);
1053 ret
= trf7970a_write(trf
, TRF7970A_REG_IO_CTRL
,
1054 trf
->io_ctrl
| TRF7970A_REG_IO_CTRL_VRS(0x1));
1058 ret
= trf7970a_write(trf
, TRF7970A_NFC_TARGET_LEVEL
, 0);
1062 usleep_range(1000, 2000);
1064 trf
->chip_status_ctrl
&= ~TRF7970A_CHIP_STATUS_RF_ON
;
1066 ret
= trf7970a_write(trf
, TRF7970A_MODULATOR_SYS_CLK_CTRL
,
1067 trf
->modulator_sys_clk_ctrl
);
1071 ret
= trf7970a_write(trf
, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS
,
1072 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96
|
1073 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32
);
1077 ret
= trf7970a_write(trf
, TRF7970A_SPECIAL_FCN_REG1
, 0);
1081 trf
->special_fcn_reg1
= 0;
1083 trf
->iso_ctrl
= 0xff;
1087 dev_dbg(trf
->dev
, "Couldn't init device: %d\n", ret
);
1091 static void trf7970a_switch_rf_off(struct trf7970a
*trf
)
1093 if ((trf
->state
== TRF7970A_ST_PWR_OFF
) ||
1094 (trf
->state
== TRF7970A_ST_RF_OFF
))
1097 dev_dbg(trf
->dev
, "Switching rf off\n");
1099 trf
->chip_status_ctrl
&= ~TRF7970A_CHIP_STATUS_RF_ON
;
1101 trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
, trf
->chip_status_ctrl
);
1103 trf
->aborting
= false;
1104 trf
->state
= TRF7970A_ST_RF_OFF
;
1106 pm_runtime_mark_last_busy(trf
->dev
);
1107 pm_runtime_put_autosuspend(trf
->dev
);
1110 static int trf7970a_switch_rf_on(struct trf7970a
*trf
)
1114 dev_dbg(trf
->dev
, "Switching rf on\n");
1116 pm_runtime_get_sync(trf
->dev
);
1118 if (trf
->state
!= TRF7970A_ST_RF_OFF
) { /* Power on, RF off */
1119 dev_err(trf
->dev
, "%s - Incorrect state: %d\n", __func__
,
1124 ret
= trf7970a_init(trf
);
1126 dev_err(trf
->dev
, "%s - Can't initialize: %d\n", __func__
, ret
);
1130 trf
->state
= TRF7970A_ST_IDLE
;
1135 static int trf7970a_switch_rf(struct nfc_digital_dev
*ddev
, bool on
)
1137 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1140 dev_dbg(trf
->dev
, "Switching RF - state: %d, on: %d\n", trf
->state
, on
);
1142 mutex_lock(&trf
->lock
);
1145 switch (trf
->state
) {
1146 case TRF7970A_ST_PWR_OFF
:
1147 case TRF7970A_ST_RF_OFF
:
1148 ret
= trf7970a_switch_rf_on(trf
);
1150 case TRF7970A_ST_IDLE
:
1151 case TRF7970A_ST_IDLE_RX_BLOCKED
:
1154 dev_err(trf
->dev
, "%s - Invalid request: %d %d\n",
1155 __func__
, trf
->state
, on
);
1156 trf7970a_switch_rf_off(trf
);
1160 switch (trf
->state
) {
1161 case TRF7970A_ST_PWR_OFF
:
1162 case TRF7970A_ST_RF_OFF
:
1165 dev_err(trf
->dev
, "%s - Invalid request: %d %d\n",
1166 __func__
, trf
->state
, on
);
1169 case TRF7970A_ST_IDLE
:
1170 case TRF7970A_ST_IDLE_RX_BLOCKED
:
1171 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
1172 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
1173 trf7970a_switch_rf_off(trf
);
1177 mutex_unlock(&trf
->lock
);
1181 static int trf7970a_in_config_rf_tech(struct trf7970a
*trf
, int tech
)
1185 dev_dbg(trf
->dev
, "rf technology: %d\n", tech
);
1188 case NFC_DIGITAL_RF_TECH_106A
:
1189 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_14443A_106
;
1190 trf
->modulator_sys_clk_ctrl
=
1191 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1192 TRF7970A_MODULATOR_DEPTH_OOK
;
1193 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCA
;
1195 case NFC_DIGITAL_RF_TECH_106B
:
1196 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_14443B_106
;
1197 trf
->modulator_sys_clk_ctrl
=
1198 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1199 TRF7970A_MODULATOR_DEPTH_ASK10
;
1200 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCB
;
1202 case NFC_DIGITAL_RF_TECH_212F
:
1203 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_FELICA_212
;
1204 trf
->modulator_sys_clk_ctrl
=
1205 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1206 TRF7970A_MODULATOR_DEPTH_ASK10
;
1207 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCF
;
1209 case NFC_DIGITAL_RF_TECH_424F
:
1210 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_FELICA_424
;
1211 trf
->modulator_sys_clk_ctrl
=
1212 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1213 TRF7970A_MODULATOR_DEPTH_ASK10
;
1214 trf
->guard_time
= TRF7970A_GUARD_TIME_NFCF
;
1216 case NFC_DIGITAL_RF_TECH_ISO15693
:
1217 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648
;
1218 trf
->modulator_sys_clk_ctrl
=
1219 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1220 TRF7970A_MODULATOR_DEPTH_OOK
;
1221 trf
->guard_time
= TRF7970A_GUARD_TIME_15693
;
1224 dev_dbg(trf
->dev
, "Unsupported rf technology: %d\n", tech
);
1228 trf
->technology
= tech
;
1230 /* If in initiator mode and not changing the RF tech due to a
1231 * PSL sequence (indicated by 'trf->iso_ctrl == 0xff' from
1232 * trf7970a_init()), clear the NFC Target Detection Level register
1235 if (trf
->iso_ctrl
== 0xff)
1236 ret
= trf7970a_write(trf
, TRF7970A_NFC_TARGET_LEVEL
, 0);
1241 static int trf7970a_is_rf_field(struct trf7970a
*trf
, bool *is_rf_field
)
1246 ret
= trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
,
1247 trf
->chip_status_ctrl
|
1248 TRF7970A_CHIP_STATUS_REC_ON
);
1252 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_TEST_EXT_RF
);
1256 usleep_range(50, 60);
1258 ret
= trf7970a_read(trf
, TRF7970A_RSSI_OSC_STATUS
, &rssi
);
1262 ret
= trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
,
1263 trf
->chip_status_ctrl
);
1267 if (rssi
& TRF7970A_RSSI_OSC_STATUS_RSSI_MASK
)
1268 *is_rf_field
= true;
1270 *is_rf_field
= false;
1275 static int trf7970a_in_config_framing(struct trf7970a
*trf
, int framing
)
1277 u8 iso_ctrl
= trf
->iso_ctrl_tech
;
1278 bool is_rf_field
= false;
1281 dev_dbg(trf
->dev
, "framing: %d\n", framing
);
1284 case NFC_DIGITAL_FRAMING_NFCA_SHORT
:
1285 case NFC_DIGITAL_FRAMING_NFCA_STANDARD
:
1286 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT_NO_CRC
;
1287 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
1289 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A
:
1290 case NFC_DIGITAL_FRAMING_NFCA_T4T
:
1291 case NFC_DIGITAL_FRAMING_NFCB
:
1292 case NFC_DIGITAL_FRAMING_NFCB_T4T
:
1293 case NFC_DIGITAL_FRAMING_NFCF
:
1294 case NFC_DIGITAL_FRAMING_NFCF_T3T
:
1295 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY
:
1296 case NFC_DIGITAL_FRAMING_ISO15693_T5T
:
1297 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP
:
1298 case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP
:
1299 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
1300 iso_ctrl
&= ~TRF7970A_ISO_CTRL_RX_CRC_N
;
1302 case NFC_DIGITAL_FRAMING_NFCA_T2T
:
1303 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
1304 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
1307 dev_dbg(trf
->dev
, "Unsupported Framing: %d\n", framing
);
1311 trf
->framing
= framing
;
1313 if (!(trf
->chip_status_ctrl
& TRF7970A_CHIP_STATUS_RF_ON
)) {
1314 ret
= trf7970a_is_rf_field(trf
, &is_rf_field
);
1322 if (iso_ctrl
!= trf
->iso_ctrl
) {
1323 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
, iso_ctrl
);
1327 trf
->iso_ctrl
= iso_ctrl
;
1329 ret
= trf7970a_write(trf
, TRF7970A_MODULATOR_SYS_CLK_CTRL
,
1330 trf
->modulator_sys_clk_ctrl
);
1335 if (!(trf
->chip_status_ctrl
& TRF7970A_CHIP_STATUS_RF_ON
)) {
1336 ret
= trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
,
1337 trf
->chip_status_ctrl
|
1338 TRF7970A_CHIP_STATUS_RF_ON
);
1342 trf
->chip_status_ctrl
|= TRF7970A_CHIP_STATUS_RF_ON
;
1344 usleep_range(trf
->guard_time
, trf
->guard_time
+ 1000);
1350 static int trf7970a_in_configure_hw(struct nfc_digital_dev
*ddev
, int type
,
1353 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1356 dev_dbg(trf
->dev
, "Configure hw - type: %d, param: %d\n", type
, param
);
1358 mutex_lock(&trf
->lock
);
1360 trf
->is_initiator
= true;
1362 if ((trf
->state
== TRF7970A_ST_PWR_OFF
) ||
1363 (trf
->state
== TRF7970A_ST_RF_OFF
)) {
1364 ret
= trf7970a_switch_rf_on(trf
);
1370 case NFC_DIGITAL_CONFIG_RF_TECH
:
1371 ret
= trf7970a_in_config_rf_tech(trf
, param
);
1373 case NFC_DIGITAL_CONFIG_FRAMING
:
1374 ret
= trf7970a_in_config_framing(trf
, param
);
1377 dev_dbg(trf
->dev
, "Unknown type: %d\n", type
);
1382 mutex_unlock(&trf
->lock
);
1386 static int trf7970a_is_iso15693_write_or_lock(u8 cmd
)
1389 case ISO15693_CMD_WRITE_SINGLE_BLOCK
:
1390 case ISO15693_CMD_LOCK_BLOCK
:
1391 case ISO15693_CMD_WRITE_MULTIPLE_BLOCK
:
1392 case ISO15693_CMD_WRITE_AFI
:
1393 case ISO15693_CMD_LOCK_AFI
:
1394 case ISO15693_CMD_WRITE_DSFID
:
1395 case ISO15693_CMD_LOCK_DSFID
:
1403 static int trf7970a_per_cmd_config(struct trf7970a
*trf
, struct sk_buff
*skb
)
1405 u8
*req
= skb
->data
;
1406 u8 special_fcn_reg1
, iso_ctrl
;
1409 trf
->issue_eof
= false;
1411 /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
1412 * special functions register 1 is cleared; otherwise, its a write or
1413 * sector select command and '4_bit_RX' must be set.
1415 * When issuing an ISO 15693 command, inspect the flags byte to see
1416 * what speed to use. Also, remember if the OPTION flag is set on
1417 * a Type 5 write or lock command so the driver will know that it
1418 * has to send an EOF in order to get a response.
1420 if ((trf
->technology
== NFC_DIGITAL_RF_TECH_106A
) &&
1421 (trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_T2T
)) {
1422 if (req
[0] == NFC_T2T_CMD_READ
)
1423 special_fcn_reg1
= 0;
1425 special_fcn_reg1
= TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX
;
1427 if (special_fcn_reg1
!= trf
->special_fcn_reg1
) {
1428 ret
= trf7970a_write(trf
, TRF7970A_SPECIAL_FCN_REG1
,
1433 trf
->special_fcn_reg1
= special_fcn_reg1
;
1435 } else if (trf
->technology
== NFC_DIGITAL_RF_TECH_ISO15693
) {
1436 iso_ctrl
= trf
->iso_ctrl
& ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK
;
1438 switch (req
[0] & ISO15693_REQ_FLAG_SPEED_MASK
) {
1440 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662
;
1442 case ISO15693_REQ_FLAG_SUB_CARRIER
:
1443 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a
;
1445 case ISO15693_REQ_FLAG_DATA_RATE
:
1446 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648
;
1448 case (ISO15693_REQ_FLAG_SUB_CARRIER
|
1449 ISO15693_REQ_FLAG_DATA_RATE
):
1450 iso_ctrl
|= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669
;
1454 if (iso_ctrl
!= trf
->iso_ctrl
) {
1455 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
, iso_ctrl
);
1459 trf
->iso_ctrl
= iso_ctrl
;
1462 if (trf
->framing
== NFC_DIGITAL_FRAMING_ISO15693_T5T
) {
1463 if (trf7970a_is_iso15693_write_or_lock(req
[1]) &&
1464 (req
[0] & ISO15693_REQ_FLAG_OPTION
))
1465 trf
->issue_eof
= true;
1466 else if ((trf
->quirks
&
1467 TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE
) &&
1468 (req
[1] == ISO15693_CMD_READ_MULTIPLE_BLOCK
))
1469 trf
->adjust_resp_len
= true;
1476 static int trf7970a_send_cmd(struct nfc_digital_dev
*ddev
,
1477 struct sk_buff
*skb
, u16 timeout
,
1478 nfc_digital_cmd_complete_t cb
, void *arg
)
1480 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1486 dev_dbg(trf
->dev
, "New request - state: %d, timeout: %d ms, len: %d\n",
1487 trf
->state
, timeout
, skb
->len
);
1489 if (skb
->len
> TRF7970A_TX_MAX
)
1492 mutex_lock(&trf
->lock
);
1494 if ((trf
->state
!= TRF7970A_ST_IDLE
) &&
1495 (trf
->state
!= TRF7970A_ST_IDLE_RX_BLOCKED
)) {
1496 dev_err(trf
->dev
, "%s - Bogus state: %d\n", __func__
,
1502 if (trf
->aborting
) {
1503 dev_dbg(trf
->dev
, "Abort process complete\n");
1504 trf
->aborting
= false;
1510 trf
->rx_skb
= nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE
,
1513 dev_dbg(trf
->dev
, "Can't alloc rx_skb\n");
1519 if (trf
->state
== TRF7970A_ST_IDLE_RX_BLOCKED
) {
1520 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_ENABLE_RX
);
1524 trf
->state
= TRF7970A_ST_IDLE
;
1527 if (trf
->is_initiator
) {
1528 ret
= trf7970a_per_cmd_config(trf
, skb
);
1537 trf
->timeout
= timeout
;
1538 trf
->ignore_timeout
= false;
1542 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1543 * on what the current framing is, the address of the TX length byte 1
1544 * register (0x1d), and the 2 byte length of the data to be transmitted.
1545 * That totals 5 bytes.
1547 prefix
[0] = TRF7970A_CMD_BIT_CTRL
|
1548 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET
);
1549 prefix
[1] = TRF7970A_CMD_BIT_CTRL
|
1550 TRF7970A_CMD_BIT_OPCODE(trf
->tx_cmd
);
1551 prefix
[2] = TRF7970A_CMD_BIT_CONTINUOUS
| TRF7970A_TX_LENGTH_BYTE1
;
1553 if (trf
->framing
== NFC_DIGITAL_FRAMING_NFCA_SHORT
) {
1555 prefix
[4] = 0x0f; /* 7 bits */
1557 prefix
[3] = (len
& 0xf00) >> 4;
1558 prefix
[3] |= ((len
& 0xf0) >> 4);
1559 prefix
[4] = ((len
& 0x0f) << 4);
1562 len
= min_t(int, skb
->len
, TRF7970A_FIFO_SIZE
);
1564 /* Clear possible spurious interrupt */
1565 ret
= trf7970a_read_irqstatus(trf
, &status
);
1569 ret
= trf7970a_transmit(trf
, skb
, len
, prefix
, sizeof(prefix
));
1571 kfree_skb(trf
->rx_skb
);
1576 mutex_unlock(&trf
->lock
);
1580 static int trf7970a_tg_config_rf_tech(struct trf7970a
*trf
, int tech
)
1584 dev_dbg(trf
->dev
, "rf technology: %d\n", tech
);
1587 case NFC_DIGITAL_RF_TECH_106A
:
1588 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE
|
1589 TRF7970A_ISO_CTRL_NFC_CE
| TRF7970A_ISO_CTRL_NFC_CE_14443A
;
1590 trf
->modulator_sys_clk_ctrl
=
1591 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1592 TRF7970A_MODULATOR_DEPTH_OOK
;
1594 case NFC_DIGITAL_RF_TECH_212F
:
1595 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE
|
1596 TRF7970A_ISO_CTRL_NFC_NFCF_212
;
1597 trf
->modulator_sys_clk_ctrl
=
1598 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1599 TRF7970A_MODULATOR_DEPTH_ASK10
;
1601 case NFC_DIGITAL_RF_TECH_424F
:
1602 trf
->iso_ctrl_tech
= TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE
|
1603 TRF7970A_ISO_CTRL_NFC_NFCF_424
;
1604 trf
->modulator_sys_clk_ctrl
=
1605 (trf
->modulator_sys_clk_ctrl
& 0xf8) |
1606 TRF7970A_MODULATOR_DEPTH_ASK10
;
1609 dev_dbg(trf
->dev
, "Unsupported rf technology: %d\n", tech
);
1613 trf
->technology
= tech
;
1615 /* Normally we write the ISO_CTRL register in
1616 * trf7970a_tg_config_framing() because the framing can change
1617 * the value written. However, when sending a PSL RES,
1618 * digital_tg_send_psl_res_complete() doesn't call
1619 * trf7970a_tg_config_framing() so we must write the register
1622 if ((trf
->framing
== NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED
) &&
1623 (trf
->iso_ctrl_tech
!= trf
->iso_ctrl
)) {
1624 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
,
1625 trf
->iso_ctrl_tech
);
1627 trf
->iso_ctrl
= trf
->iso_ctrl_tech
;
1633 /* Since this is a target routine, several of the framing calls are
1634 * made between receiving the request and sending the response so they
1635 * should take effect until after the response is sent. This is accomplished
1636 * by skipping the ISO_CTRL register write here and doing it in the interrupt
1639 static int trf7970a_tg_config_framing(struct trf7970a
*trf
, int framing
)
1641 u8 iso_ctrl
= trf
->iso_ctrl_tech
;
1644 dev_dbg(trf
->dev
, "framing: %d\n", framing
);
1647 case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP
:
1648 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT_NO_CRC
;
1649 iso_ctrl
|= TRF7970A_ISO_CTRL_RX_CRC_N
;
1651 case NFC_DIGITAL_FRAMING_NFCA_STANDARD
:
1652 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A
:
1653 case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE
:
1654 /* These ones are applied in the interrupt handler */
1655 iso_ctrl
= trf
->iso_ctrl
; /* Don't write to ISO_CTRL yet */
1657 case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP
:
1658 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
1659 iso_ctrl
&= ~TRF7970A_ISO_CTRL_RX_CRC_N
;
1661 case NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED
:
1662 trf
->tx_cmd
= TRF7970A_CMD_TRANSMIT
;
1663 iso_ctrl
&= ~TRF7970A_ISO_CTRL_RX_CRC_N
;
1666 dev_dbg(trf
->dev
, "Unsupported Framing: %d\n", framing
);
1670 trf
->framing
= framing
;
1672 if (iso_ctrl
!= trf
->iso_ctrl
) {
1673 ret
= trf7970a_write(trf
, TRF7970A_ISO_CTRL
, iso_ctrl
);
1677 trf
->iso_ctrl
= iso_ctrl
;
1679 ret
= trf7970a_write(trf
, TRF7970A_MODULATOR_SYS_CLK_CTRL
,
1680 trf
->modulator_sys_clk_ctrl
);
1685 if (!(trf
->chip_status_ctrl
& TRF7970A_CHIP_STATUS_RF_ON
)) {
1686 ret
= trf7970a_write(trf
, TRF7970A_CHIP_STATUS_CTRL
,
1687 trf
->chip_status_ctrl
|
1688 TRF7970A_CHIP_STATUS_RF_ON
);
1692 trf
->chip_status_ctrl
|= TRF7970A_CHIP_STATUS_RF_ON
;
1698 static int trf7970a_tg_configure_hw(struct nfc_digital_dev
*ddev
, int type
,
1701 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1704 dev_dbg(trf
->dev
, "Configure hw - type: %d, param: %d\n", type
, param
);
1706 mutex_lock(&trf
->lock
);
1708 trf
->is_initiator
= false;
1710 if ((trf
->state
== TRF7970A_ST_PWR_OFF
) ||
1711 (trf
->state
== TRF7970A_ST_RF_OFF
)) {
1712 ret
= trf7970a_switch_rf_on(trf
);
1718 case NFC_DIGITAL_CONFIG_RF_TECH
:
1719 ret
= trf7970a_tg_config_rf_tech(trf
, param
);
1721 case NFC_DIGITAL_CONFIG_FRAMING
:
1722 ret
= trf7970a_tg_config_framing(trf
, param
);
1725 dev_dbg(trf
->dev
, "Unknown type: %d\n", type
);
1730 mutex_unlock(&trf
->lock
);
1734 static int _trf7970a_tg_listen(struct nfc_digital_dev
*ddev
, u16 timeout
,
1735 nfc_digital_cmd_complete_t cb
, void *arg
,
1738 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1741 mutex_lock(&trf
->lock
);
1743 if ((trf
->state
!= TRF7970A_ST_IDLE
) &&
1744 (trf
->state
!= TRF7970A_ST_IDLE_RX_BLOCKED
)) {
1745 dev_err(trf
->dev
, "%s - Bogus state: %d\n", __func__
,
1751 if (trf
->aborting
) {
1752 dev_dbg(trf
->dev
, "Abort process complete\n");
1753 trf
->aborting
= false;
1758 trf
->rx_skb
= nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE
,
1761 dev_dbg(trf
->dev
, "Can't alloc rx_skb\n");
1766 ret
= trf7970a_write(trf
, TRF7970A_RX_SPECIAL_SETTINGS
,
1767 TRF7970A_RX_SPECIAL_SETTINGS_HBT
|
1768 TRF7970A_RX_SPECIAL_SETTINGS_M848
|
1769 TRF7970A_RX_SPECIAL_SETTINGS_C424
|
1770 TRF7970A_RX_SPECIAL_SETTINGS_C212
);
1774 ret
= trf7970a_write(trf
, TRF7970A_REG_IO_CTRL
,
1775 trf
->io_ctrl
| TRF7970A_REG_IO_CTRL_VRS(0x1));
1779 ret
= trf7970a_write(trf
, TRF7970A_NFC_LOW_FIELD_LEVEL
,
1780 TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3));
1784 ret
= trf7970a_write(trf
, TRF7970A_NFC_TARGET_LEVEL
,
1785 TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7));
1792 trf
->timeout
= timeout
;
1793 trf
->ignore_timeout
= false;
1795 ret
= trf7970a_cmd(trf
, TRF7970A_CMD_ENABLE_RX
);
1799 trf
->state
= mode_detect
? TRF7970A_ST_LISTENING_MD
:
1800 TRF7970A_ST_LISTENING
;
1802 schedule_delayed_work(&trf
->timeout_work
, msecs_to_jiffies(timeout
));
1805 mutex_unlock(&trf
->lock
);
1809 static int trf7970a_tg_listen(struct nfc_digital_dev
*ddev
, u16 timeout
,
1810 nfc_digital_cmd_complete_t cb
, void *arg
)
1812 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1814 dev_dbg(trf
->dev
, "Listen - state: %d, timeout: %d ms\n",
1815 trf
->state
, timeout
);
1817 return _trf7970a_tg_listen(ddev
, timeout
, cb
, arg
, false);
1820 static int trf7970a_tg_listen_md(struct nfc_digital_dev
*ddev
,
1821 u16 timeout
, nfc_digital_cmd_complete_t cb
,
1824 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1827 dev_dbg(trf
->dev
, "Listen MD - state: %d, timeout: %d ms\n",
1828 trf
->state
, timeout
);
1830 ret
= trf7970a_tg_configure_hw(ddev
, NFC_DIGITAL_CONFIG_RF_TECH
,
1831 NFC_DIGITAL_RF_TECH_106A
);
1835 ret
= trf7970a_tg_configure_hw(ddev
, NFC_DIGITAL_CONFIG_FRAMING
,
1836 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP
);
1840 return _trf7970a_tg_listen(ddev
, timeout
, cb
, arg
, true);
1843 static int trf7970a_tg_get_rf_tech(struct nfc_digital_dev
*ddev
, u8
*rf_tech
)
1845 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1847 dev_dbg(trf
->dev
, "Get RF Tech - state: %d, rf_tech: %d\n",
1848 trf
->state
, trf
->md_rf_tech
);
1850 *rf_tech
= trf
->md_rf_tech
;
1855 static void trf7970a_abort_cmd(struct nfc_digital_dev
*ddev
)
1857 struct trf7970a
*trf
= nfc_digital_get_drvdata(ddev
);
1859 dev_dbg(trf
->dev
, "Abort process initiated\n");
1861 mutex_lock(&trf
->lock
);
1863 switch (trf
->state
) {
1864 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
1865 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
1866 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
1867 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
1868 trf
->aborting
= true;
1870 case TRF7970A_ST_LISTENING
:
1871 trf
->ignore_timeout
= !cancel_delayed_work(&trf
->timeout_work
);
1872 trf7970a_send_err_upstream(trf
, -ECANCELED
);
1873 dev_dbg(trf
->dev
, "Abort process complete\n");
1879 mutex_unlock(&trf
->lock
);
1882 static struct nfc_digital_ops trf7970a_nfc_ops
= {
1883 .in_configure_hw
= trf7970a_in_configure_hw
,
1884 .in_send_cmd
= trf7970a_send_cmd
,
1885 .tg_configure_hw
= trf7970a_tg_configure_hw
,
1886 .tg_send_cmd
= trf7970a_send_cmd
,
1887 .tg_listen
= trf7970a_tg_listen
,
1888 .tg_listen_md
= trf7970a_tg_listen_md
,
1889 .tg_get_rf_tech
= trf7970a_tg_get_rf_tech
,
1890 .switch_rf
= trf7970a_switch_rf
,
1891 .abort_cmd
= trf7970a_abort_cmd
,
1894 static int trf7970a_power_up(struct trf7970a
*trf
)
1898 dev_dbg(trf
->dev
, "Powering up - state: %d\n", trf
->state
);
1900 if (trf
->state
!= TRF7970A_ST_PWR_OFF
)
1903 ret
= regulator_enable(trf
->regulator
);
1905 dev_err(trf
->dev
, "%s - Can't enable VIN: %d\n", __func__
, ret
);
1909 usleep_range(5000, 6000);
1911 if (trf
->en2_gpiod
&&
1912 !(trf
->quirks
& TRF7970A_QUIRK_EN2_MUST_STAY_LOW
)) {
1913 gpiod_set_value_cansleep(trf
->en2_gpiod
, 1);
1914 usleep_range(1000, 2000);
1917 gpiod_set_value_cansleep(trf
->en_gpiod
, 1);
1919 usleep_range(20000, 21000);
1921 trf
->state
= TRF7970A_ST_RF_OFF
;
1926 static int trf7970a_power_down(struct trf7970a
*trf
)
1930 dev_dbg(trf
->dev
, "Powering down - state: %d\n", trf
->state
);
1932 if (trf
->state
== TRF7970A_ST_PWR_OFF
)
1935 if (trf
->state
!= TRF7970A_ST_RF_OFF
) {
1936 dev_dbg(trf
->dev
, "Can't power down - not RF_OFF state (%d)\n",
1941 gpiod_set_value_cansleep(trf
->en_gpiod
, 0);
1943 if (trf
->en2_gpiod
&& !(trf
->quirks
& TRF7970A_QUIRK_EN2_MUST_STAY_LOW
))
1944 gpiod_set_value_cansleep(trf
->en2_gpiod
, 0);
1946 ret
= regulator_disable(trf
->regulator
);
1948 dev_err(trf
->dev
, "%s - Can't disable VIN: %d\n", __func__
,
1951 trf
->state
= TRF7970A_ST_PWR_OFF
;
1956 static int trf7970a_startup(struct trf7970a
*trf
)
1960 ret
= trf7970a_power_up(trf
);
1964 pm_runtime_set_active(trf
->dev
);
1965 pm_runtime_enable(trf
->dev
);
1966 pm_runtime_mark_last_busy(trf
->dev
);
1971 static void trf7970a_shutdown(struct trf7970a
*trf
)
1973 switch (trf
->state
) {
1974 case TRF7970A_ST_WAIT_FOR_TX_FIFO
:
1975 case TRF7970A_ST_WAIT_FOR_RX_DATA
:
1976 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT
:
1977 case TRF7970A_ST_WAIT_TO_ISSUE_EOF
:
1978 case TRF7970A_ST_LISTENING
:
1979 trf7970a_send_err_upstream(trf
, -ECANCELED
);
1981 case TRF7970A_ST_IDLE
:
1982 case TRF7970A_ST_IDLE_RX_BLOCKED
:
1983 trf7970a_switch_rf_off(trf
);
1989 pm_runtime_disable(trf
->dev
);
1990 pm_runtime_set_suspended(trf
->dev
);
1992 trf7970a_power_down(trf
);
1995 static int trf7970a_get_autosuspend_delay(struct device_node
*np
)
1997 int autosuspend_delay
, ret
;
1999 ret
= of_property_read_u32(np
, "autosuspend-delay", &autosuspend_delay
);
2001 autosuspend_delay
= TRF7970A_AUTOSUSPEND_DELAY
;
2003 return autosuspend_delay
;
2006 static int trf7970a_probe(struct spi_device
*spi
)
2008 struct device_node
*np
= spi
->dev
.of_node
;
2009 struct trf7970a
*trf
;
2010 int uvolts
, autosuspend_delay
, ret
;
2011 u32 clk_freq
= TRF7970A_13MHZ_CLOCK_FREQUENCY
;
2014 dev_err(&spi
->dev
, "No Device Tree entry\n");
2018 trf
= devm_kzalloc(&spi
->dev
, sizeof(*trf
), GFP_KERNEL
);
2022 trf
->state
= TRF7970A_ST_PWR_OFF
;
2023 trf
->dev
= &spi
->dev
;
2026 spi
->mode
= SPI_MODE_1
;
2027 spi
->bits_per_word
= 8;
2029 ret
= spi_setup(spi
);
2031 dev_err(trf
->dev
, "Can't set up SPI Communication\n");
2035 if (of_property_read_bool(np
, "t5t-rmb-extra-byte-quirk"))
2036 trf
->quirks
|= TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE
;
2038 if (of_property_read_bool(np
, "irq-status-read-quirk"))
2039 trf
->quirks
|= TRF7970A_QUIRK_IRQ_STATUS_READ
;
2041 /* There are two enable pins - only EN must be present in the DT */
2042 trf
->en_gpiod
= devm_gpiod_get_index(trf
->dev
, "ti,enable", 0,
2044 if (IS_ERR(trf
->en_gpiod
)) {
2045 dev_err(trf
->dev
, "No EN GPIO property\n");
2046 return PTR_ERR(trf
->en_gpiod
);
2049 trf
->en2_gpiod
= devm_gpiod_get_index_optional(trf
->dev
, "ti,enable", 1,
2051 if (!trf
->en2_gpiod
) {
2052 dev_info(trf
->dev
, "No EN2 GPIO property\n");
2053 } else if (IS_ERR(trf
->en2_gpiod
)) {
2054 dev_err(trf
->dev
, "Error getting EN2 GPIO property: %ld\n",
2055 PTR_ERR(trf
->en2_gpiod
));
2056 return PTR_ERR(trf
->en2_gpiod
);
2057 } else if (of_property_read_bool(np
, "en2-rf-quirk")) {
2058 trf
->quirks
|= TRF7970A_QUIRK_EN2_MUST_STAY_LOW
;
2061 of_property_read_u32(np
, "clock-frequency", &clk_freq
);
2062 if ((clk_freq
!= TRF7970A_27MHZ_CLOCK_FREQUENCY
) &&
2063 (clk_freq
!= TRF7970A_13MHZ_CLOCK_FREQUENCY
)) {
2065 "clock-frequency (%u Hz) unsupported\n", clk_freq
);
2069 ret
= devm_request_threaded_irq(trf
->dev
, spi
->irq
, NULL
,
2071 IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
2074 dev_err(trf
->dev
, "Can't request IRQ#%d: %d\n", spi
->irq
, ret
);
2078 mutex_init(&trf
->lock
);
2079 INIT_DELAYED_WORK(&trf
->timeout_work
, trf7970a_timeout_work_handler
);
2081 trf
->regulator
= devm_regulator_get(&spi
->dev
, "vin");
2082 if (IS_ERR(trf
->regulator
)) {
2083 ret
= PTR_ERR(trf
->regulator
);
2084 dev_err(trf
->dev
, "Can't get VIN regulator: %d\n", ret
);
2085 goto err_destroy_lock
;
2088 ret
= regulator_enable(trf
->regulator
);
2090 dev_err(trf
->dev
, "Can't enable VIN: %d\n", ret
);
2091 goto err_destroy_lock
;
2094 uvolts
= regulator_get_voltage(trf
->regulator
);
2095 if (uvolts
> 4000000)
2096 trf
->chip_status_ctrl
= TRF7970A_CHIP_STATUS_VRS5_3
;
2098 trf
->regulator
= devm_regulator_get(&spi
->dev
, "vdd-io");
2099 if (IS_ERR(trf
->regulator
)) {
2100 ret
= PTR_ERR(trf
->regulator
);
2101 dev_err(trf
->dev
, "Can't get VDD_IO regulator: %d\n", ret
);
2102 goto err_destroy_lock
;
2105 ret
= regulator_enable(trf
->regulator
);
2107 dev_err(trf
->dev
, "Can't enable VDD_IO: %d\n", ret
);
2108 goto err_destroy_lock
;
2111 if (regulator_get_voltage(trf
->regulator
) == 1800000) {
2112 trf
->io_ctrl
= TRF7970A_REG_IO_CTRL_IO_LOW
;
2113 dev_dbg(trf
->dev
, "trf7970a config vdd_io to 1.8V\n");
2116 trf
->ddev
= nfc_digital_allocate_device(&trf7970a_nfc_ops
,
2117 TRF7970A_SUPPORTED_PROTOCOLS
,
2118 NFC_DIGITAL_DRV_CAPS_IN_CRC
|
2119 NFC_DIGITAL_DRV_CAPS_TG_CRC
, 0,
2122 dev_err(trf
->dev
, "Can't allocate NFC digital device\n");
2124 goto err_disable_regulator
;
2127 nfc_digital_set_parent_dev(trf
->ddev
, trf
->dev
);
2128 nfc_digital_set_drvdata(trf
->ddev
, trf
);
2129 spi_set_drvdata(spi
, trf
);
2131 autosuspend_delay
= trf7970a_get_autosuspend_delay(np
);
2133 pm_runtime_set_autosuspend_delay(trf
->dev
, autosuspend_delay
);
2134 pm_runtime_use_autosuspend(trf
->dev
);
2136 ret
= trf7970a_startup(trf
);
2140 ret
= nfc_digital_register_device(trf
->ddev
);
2142 dev_err(trf
->dev
, "Can't register NFC digital device: %d\n",
2150 trf7970a_shutdown(trf
);
2152 nfc_digital_free_device(trf
->ddev
);
2153 err_disable_regulator
:
2154 regulator_disable(trf
->regulator
);
2156 mutex_destroy(&trf
->lock
);
2160 static int trf7970a_remove(struct spi_device
*spi
)
2162 struct trf7970a
*trf
= spi_get_drvdata(spi
);
2164 mutex_lock(&trf
->lock
);
2166 trf7970a_shutdown(trf
);
2168 mutex_unlock(&trf
->lock
);
2170 nfc_digital_unregister_device(trf
->ddev
);
2171 nfc_digital_free_device(trf
->ddev
);
2173 regulator_disable(trf
->regulator
);
2175 mutex_destroy(&trf
->lock
);
2180 #ifdef CONFIG_PM_SLEEP
2181 static int trf7970a_suspend(struct device
*dev
)
2183 struct spi_device
*spi
= to_spi_device(dev
);
2184 struct trf7970a
*trf
= spi_get_drvdata(spi
);
2186 dev_dbg(dev
, "Suspend\n");
2188 mutex_lock(&trf
->lock
);
2190 trf7970a_shutdown(trf
);
2192 mutex_unlock(&trf
->lock
);
2197 static int trf7970a_resume(struct device
*dev
)
2199 struct spi_device
*spi
= to_spi_device(dev
);
2200 struct trf7970a
*trf
= spi_get_drvdata(spi
);
2203 dev_dbg(dev
, "Resume\n");
2205 mutex_lock(&trf
->lock
);
2207 ret
= trf7970a_startup(trf
);
2209 mutex_unlock(&trf
->lock
);
2216 static int trf7970a_pm_runtime_suspend(struct device
*dev
)
2218 struct spi_device
*spi
= to_spi_device(dev
);
2219 struct trf7970a
*trf
= spi_get_drvdata(spi
);
2222 dev_dbg(dev
, "Runtime suspend\n");
2224 mutex_lock(&trf
->lock
);
2226 ret
= trf7970a_power_down(trf
);
2228 mutex_unlock(&trf
->lock
);
2233 static int trf7970a_pm_runtime_resume(struct device
*dev
)
2235 struct spi_device
*spi
= to_spi_device(dev
);
2236 struct trf7970a
*trf
= spi_get_drvdata(spi
);
2239 dev_dbg(dev
, "Runtime resume\n");
2241 ret
= trf7970a_power_up(trf
);
2243 pm_runtime_mark_last_busy(dev
);
2249 static const struct dev_pm_ops trf7970a_pm_ops
= {
2250 SET_SYSTEM_SLEEP_PM_OPS(trf7970a_suspend
, trf7970a_resume
)
2251 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend
,
2252 trf7970a_pm_runtime_resume
, NULL
)
2255 static const struct of_device_id trf7970a_of_match
[] = {
2256 {.compatible
= "ti,trf7970a",},
2260 MODULE_DEVICE_TABLE(of
, trf7970a_of_match
);
2262 static const struct spi_device_id trf7970a_id_table
[] = {
2267 MODULE_DEVICE_TABLE(spi
, trf7970a_id_table
);
2269 static struct spi_driver trf7970a_spi_driver
= {
2270 .probe
= trf7970a_probe
,
2271 .remove
= trf7970a_remove
,
2272 .id_table
= trf7970a_id_table
,
2275 .of_match_table
= of_match_ptr(trf7970a_of_match
),
2276 .pm
= &trf7970a_pm_ops
,
2280 module_spi_driver(trf7970a_spi_driver
);
2282 MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
2283 MODULE_LICENSE("GPL v2");
2284 MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");