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