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