blob: 3b78b031e617df51e98101a231519a000cd159ed [file] [log] [blame]
Mark A. Greer165063f2014-03-10 11:56:22 -07001/*
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>
Mark A. Greere6403b72014-03-25 08:54:38 -070019#include <linux/pm_runtime.h>
Mark A. Greer165063f2014-03-10 11:56:22 -070020#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.
40 *
41 * Timeouts are implemented using the delayed workqueue kernel facility.
42 * Timeouts are required so things don't hang when there is no response
43 * from the trf7970a (or tag). Using this mechanism creates a race with
44 * interrupts, however. That is, an interrupt and a timeout could occur
45 * closely enough together that one is blocked by the mutex while the other
46 * executes. When the timeout handler executes first and blocks the
47 * interrupt handler, it will eventually set the state to IDLE so the
48 * interrupt handler will check the state and exit with no harm done.
49 * When the interrupt handler executes first and blocks the timeout handler,
50 * the cancel_delayed_work() call will know that it didn't cancel the
51 * work item (i.e., timeout) and will return zero. That return code is
52 * used by the timer handler to indicate that it should ignore the timeout
53 * once its unblocked.
54 *
55 * Aborting an active command isn't as simple as it seems because the only
56 * way to abort a command that's already been sent to the tag is so turn
57 * off power to the tag. If we do that, though, we'd have to go through
58 * the entire anticollision procedure again but the digital layer doesn't
59 * support that. So, if an abort is received before trf7970a_in_send_cmd()
60 * has sent the command to the tag, it simply returns -ECANCELED. If the
61 * command has already been sent to the tag, then the driver continues
62 * normally and recieves the response data (or error) but just before
63 * sending the data upstream, it frees the rx_skb and sends -ECANCELED
64 * upstream instead. If the command failed, that error will be sent
65 * upstream.
66 *
67 * When recieving data from a tag and the interrupt status register has
68 * only the SRX bit set, it means that all of the data has been received
69 * (once what's in the fifo has been read). However, depending on timing
70 * an interrupt status with only the SRX bit set may not be recived. In
Mark A. Greer5fa3af32014-03-25 08:54:29 -070071 * those cases, the timeout mechanism is used to wait 20 ms in case more
72 * data arrives. After 20 ms, it is assumed that all of the data has been
Mark A. Greer165063f2014-03-10 11:56:22 -070073 * received and the accumulated rx data is sent upstream. The
74 * 'TRF7970A_ST_WAIT_FOR_RX_DATA_CONT' state is used for this purpose
75 * (i.e., it indicates that some data has been received but we're not sure
76 * if there is more coming so a timeout in this state means all data has
Mark A. Greer5fa3af32014-03-25 08:54:29 -070077 * been received and there isn't an error). The delay is 20 ms since delays
78 * of ~16 ms have been observed during testing.
Mark A. Greer165063f2014-03-10 11:56:22 -070079 *
80 * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
81 * Having only 4 bits in the FIFO won't normally generate an interrupt so
82 * driver enables the '4_bit_RX' bit of the Special Functions register 1
83 * to cause an interrupt in that case. Leaving that bit for a read command
84 * messes up the data returned so it is only enabled when the framing is
85 * 'NFC_DIGITAL_FRAMING_NFCA_T2T' and the command is not a read command.
86 * Unfortunately, that means that the driver has to peek into tx frames
87 * when the framing is 'NFC_DIGITAL_FRAMING_NFCA_T2T'. This is done by
88 * the trf7970a_per_cmd_config() routine.
Mark A. Greer9d9304b2014-03-10 11:56:24 -070089 *
90 * ISO/IEC 15693 frames specify whether to use single or double sub-carrier
91 * frequencies and whether to use low or high data rates in the flags byte
92 * of the frame. This means that the driver has to peek at all 15693 frames
93 * to determine what speed to set the communication to. In addition, write
94 * and lock commands use the OPTION flag to indicate that an EOF must be
95 * sent to the tag before it will send its response. So the driver has to
96 * examine all frames for that reason too.
97 *
98 * It is unclear how long to wait before sending the EOF. According to the
99 * Note under Table 1-1 in section 1.6 of
100 * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
101 * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
102 * enough. For this reason, the driver waits 20 ms which seems to work
103 * reliably.
Mark A. Greer165063f2014-03-10 11:56:22 -0700104 */
105
Mark A. Greer80062892014-03-10 11:56:23 -0700106#define TRF7970A_SUPPORTED_PROTOCOLS \
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700107 (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \
Mark A. Greer6857bb92014-04-14 10:04:10 -0700108 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \
109 NFC_PROTO_ISO15693_MASK)
Mark A. Greer165063f2014-03-10 11:56:22 -0700110
Mark A. Greere6403b72014-03-25 08:54:38 -0700111#define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
112
Mark A. Greer165063f2014-03-10 11:56:22 -0700113/* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
114 * on what the current framing is, the address of the TX length byte 1
115 * register (0x1d), and the 2 byte length of the data to be transmitted.
116 * That totals 5 bytes.
117 */
118#define TRF7970A_TX_SKB_HEADROOM 5
119
120#define TRF7970A_RX_SKB_ALLOC_SIZE 256
121
122#define TRF7970A_FIFO_SIZE 128
123
124/* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
125#define TRF7970A_TX_MAX (4096 - 1)
126
Mark A. Greer5fa3af32014-03-25 08:54:29 -0700127#define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
Mark A. Greer165063f2014-03-10 11:56:22 -0700128#define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 3
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700129#define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 20
Mark A. Greer165063f2014-03-10 11:56:22 -0700130
131/* Quirks */
132/* Erratum: When reading IRQ Status register on trf7970a, we must issue a
133 * read continuous command for IRQ Status and Collision Position registers.
134 */
135#define TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA BIT(0)
136
137/* Direct commands */
138#define TRF7970A_CMD_IDLE 0x00
139#define TRF7970A_CMD_SOFT_INIT 0x03
140#define TRF7970A_CMD_RF_COLLISION 0x04
141#define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0x05
142#define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0x06
143#define TRF7970A_CMD_FIFO_RESET 0x0f
144#define TRF7970A_CMD_TRANSMIT_NO_CRC 0x10
145#define TRF7970A_CMD_TRANSMIT 0x11
146#define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0x12
147#define TRF7970A_CMD_DELAY_TRANSMIT 0x13
148#define TRF7970A_CMD_EOF 0x14
149#define TRF7970A_CMD_CLOSE_SLOT 0x15
150#define TRF7970A_CMD_BLOCK_RX 0x16
151#define TRF7970A_CMD_ENABLE_RX 0x17
152#define TRF7970A_CMD_TEST_EXT_RF 0x18
153#define TRF7970A_CMD_TEST_INT_RF 0x19
154#define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
155
156/* Bits determining whether its a direct command or register R/W,
157 * whether to use a continuous SPI transaction or not, and the actual
158 * direct cmd opcode or regster address.
159 */
160#define TRF7970A_CMD_BIT_CTRL BIT(7)
161#define TRF7970A_CMD_BIT_RW BIT(6)
162#define TRF7970A_CMD_BIT_CONTINUOUS BIT(5)
163#define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0x1f)
164
165/* Registers addresses */
166#define TRF7970A_CHIP_STATUS_CTRL 0x00
167#define TRF7970A_ISO_CTRL 0x01
168#define TRF7970A_ISO14443B_TX_OPTIONS 0x02
169#define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
170#define TRF7970A_TX_TIMER_SETTING_H_BYTE 0x04
171#define TRF7970A_TX_TIMER_SETTING_L_BYTE 0x05
172#define TRF7970A_TX_PULSE_LENGTH_CTRL 0x06
173#define TRF7970A_RX_NO_RESPONSE_WAIT 0x07
174#define TRF7970A_RX_WAIT_TIME 0x08
175#define TRF7970A_MODULATOR_SYS_CLK_CTRL 0x09
176#define TRF7970A_RX_SPECIAL_SETTINGS 0x0a
177#define TRF7970A_REG_IO_CTRL 0x0b
178#define TRF7970A_IRQ_STATUS 0x0c
179#define TRF7970A_COLLISION_IRQ_MASK 0x0d
180#define TRF7970A_COLLISION_POSITION 0x0e
181#define TRF7970A_RSSI_OSC_STATUS 0x0f
182#define TRF7970A_SPECIAL_FCN_REG1 0x10
183#define TRF7970A_SPECIAL_FCN_REG2 0x11
184#define TRF7970A_RAM1 0x12
185#define TRF7970A_RAM2 0x13
186#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0x14
187#define TRF7970A_NFC_LOW_FIELD_LEVEL 0x16
188#define TRF7970A_NFCID1 0x17
189#define TRF7970A_NFC_TARGET_LEVEL 0x18
190#define TRF79070A_NFC_TARGET_PROTOCOL 0x19
191#define TRF7970A_TEST_REGISTER1 0x1a
192#define TRF7970A_TEST_REGISTER2 0x1b
193#define TRF7970A_FIFO_STATUS 0x1c
194#define TRF7970A_TX_LENGTH_BYTE1 0x1d
195#define TRF7970A_TX_LENGTH_BYTE2 0x1e
196#define TRF7970A_FIFO_IO_REGISTER 0x1f
197
198/* Chip Status Control Register Bits */
199#define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0)
200#define TRF7970A_CHIP_STATUS_REC_ON BIT(1)
201#define TRF7970A_CHIP_STATUS_AGC_ON BIT(2)
202#define TRF7970A_CHIP_STATUS_PM_ON BIT(3)
203#define TRF7970A_CHIP_STATUS_RF_PWR BIT(4)
204#define TRF7970A_CHIP_STATUS_RF_ON BIT(5)
205#define TRF7970A_CHIP_STATUS_DIRECT BIT(6)
206#define TRF7970A_CHIP_STATUS_STBY BIT(7)
207
208/* ISO Control Register Bits */
209#define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0x00
210#define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0x01
211#define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0x02
212#define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
213#define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0x04
214#define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0x05
215#define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0x06
216#define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
217#define TRF7970A_ISO_CTRL_14443A_106 0x08
218#define TRF7970A_ISO_CTRL_14443A_212 0x09
219#define TRF7970A_ISO_CTRL_14443A_424 0x0a
220#define TRF7970A_ISO_CTRL_14443A_848 0x0b
221#define TRF7970A_ISO_CTRL_14443B_106 0x0c
222#define TRF7970A_ISO_CTRL_14443B_212 0x0d
223#define TRF7970A_ISO_CTRL_14443B_424 0x0e
224#define TRF7970A_ISO_CTRL_14443B_848 0x0f
225#define TRF7970A_ISO_CTRL_FELICA_212 0x1a
226#define TRF7970A_ISO_CTRL_FELICA_424 0x1b
227#define TRF7970A_ISO_CTRL_RFID BIT(5)
228#define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
229#define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
230
231#define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0x1f
232
233/* Modulator and SYS_CLK Control Register Bits */
234#define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0x7)
235#define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0))
236#define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1))
237#define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2))
238#define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3))
239#define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4))
240#define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5))
241#define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6))
242#define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7))
243#define TRF7970A_MODULATOR_EN_ANA BIT(3)
244#define TRF7970A_MODULATOR_CLK(n) (((n) & 0x3) << 4)
245#define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0))
246#define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1))
247#define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2))
248#define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3))
249#define TRF7970A_MODULATOR_EN_OOK BIT(6)
250#define TRF7970A_MODULATOR_27MHZ BIT(7)
251
252/* IRQ Status Register Bits */
253#define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
254#define TRF7970A_IRQ_STATUS_COL BIT(1)
255#define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
256#define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
257#define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
258#define TRF7970A_IRQ_STATUS_FIFO BIT(5)
259#define TRF7970A_IRQ_STATUS_SRX BIT(6)
260#define TRF7970A_IRQ_STATUS_TX BIT(7)
261
262#define TRF7970A_IRQ_STATUS_ERROR \
263 (TRF7970A_IRQ_STATUS_COL | \
264 TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR | \
265 TRF7970A_IRQ_STATUS_PARITY_ERROR | \
266 TRF7970A_IRQ_STATUS_CRC_ERROR)
267
268#define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
269#define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
270#define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
271#define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3)
272#define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4)
273#define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5)
274
275#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0x0 << 2)
276#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0x1 << 2)
277#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0x2 << 2)
278#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0x3 << 2)
279#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0x0
280#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0x1
281#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
282#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
283
284#define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
285
286/* NFC (ISO/IEC 14443A) Type 2 Tag commands */
287#define NFC_T2T_CMD_READ 0x30
288
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700289/* ISO 15693 commands codes */
290#define ISO15693_CMD_INVENTORY 0x01
291#define ISO15693_CMD_READ_SINGLE_BLOCK 0x20
292#define ISO15693_CMD_WRITE_SINGLE_BLOCK 0x21
293#define ISO15693_CMD_LOCK_BLOCK 0x22
294#define ISO15693_CMD_READ_MULTIPLE_BLOCK 0x23
295#define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0x24
296#define ISO15693_CMD_SELECT 0x25
297#define ISO15693_CMD_RESET_TO_READY 0x26
298#define ISO15693_CMD_WRITE_AFI 0x27
299#define ISO15693_CMD_LOCK_AFI 0x28
300#define ISO15693_CMD_WRITE_DSFID 0x29
301#define ISO15693_CMD_LOCK_DSFID 0x2a
302#define ISO15693_CMD_GET_SYSTEM_INFO 0x2b
303#define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
304
305/* ISO 15693 request and response flags */
306#define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0)
307#define ISO15693_REQ_FLAG_DATA_RATE BIT(1)
308#define ISO15693_REQ_FLAG_INVENTORY BIT(2)
309#define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3)
310#define ISO15693_REQ_FLAG_SELECT BIT(4)
311#define ISO15693_REQ_FLAG_AFI BIT(4)
312#define ISO15693_REQ_FLAG_ADDRESS BIT(5)
313#define ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
314#define ISO15693_REQ_FLAG_OPTION BIT(6)
315
316#define ISO15693_REQ_FLAG_SPEED_MASK \
317 (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
318
Mark A. Greer165063f2014-03-10 11:56:22 -0700319enum trf7970a_state {
320 TRF7970A_ST_OFF,
321 TRF7970A_ST_IDLE,
322 TRF7970A_ST_IDLE_RX_BLOCKED,
323 TRF7970A_ST_WAIT_FOR_TX_FIFO,
324 TRF7970A_ST_WAIT_FOR_RX_DATA,
325 TRF7970A_ST_WAIT_FOR_RX_DATA_CONT,
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700326 TRF7970A_ST_WAIT_TO_ISSUE_EOF,
Mark A. Greer165063f2014-03-10 11:56:22 -0700327 TRF7970A_ST_MAX
328};
329
330struct trf7970a {
331 enum trf7970a_state state;
332 struct device *dev;
333 struct spi_device *spi;
334 struct regulator *regulator;
335 struct nfc_digital_dev *ddev;
336 u32 quirks;
Mark A. Greer165063f2014-03-10 11:56:22 -0700337 bool aborting;
338 struct sk_buff *tx_skb;
339 struct sk_buff *rx_skb;
340 nfc_digital_cmd_complete_t cb;
341 void *cb_arg;
Mark A. Greerebcc5a02014-03-25 08:54:36 -0700342 u8 chip_status_ctrl;
Mark A. Greer165063f2014-03-10 11:56:22 -0700343 u8 iso_ctrl;
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700344 u8 iso_ctrl_tech;
Mark A. Greer12e9ade2014-03-25 08:54:35 -0700345 u8 modulator_sys_clk_ctrl;
Mark A. Greer165063f2014-03-10 11:56:22 -0700346 u8 special_fcn_reg1;
347 int technology;
348 int framing;
349 u8 tx_cmd;
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700350 bool issue_eof;
Mark A. Greer165063f2014-03-10 11:56:22 -0700351 int en2_gpio;
352 int en_gpio;
353 struct mutex lock;
354 unsigned int timeout;
355 bool ignore_timeout;
356 struct delayed_work timeout_work;
357};
358
359
360static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)
361{
362 u8 cmd = TRF7970A_CMD_BIT_CTRL | TRF7970A_CMD_BIT_OPCODE(opcode);
363 int ret;
364
365 dev_dbg(trf->dev, "cmd: 0x%x\n", cmd);
366
367 ret = spi_write(trf->spi, &cmd, 1);
368 if (ret)
369 dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd,
370 ret);
371 return ret;
372}
373
374static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
375{
376 u8 addr = TRF7970A_CMD_BIT_RW | reg;
377 int ret;
378
379 ret = spi_write_then_read(trf->spi, &addr, 1, val, 1);
380 if (ret)
381 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
382 ret);
383
384 dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val);
385
386 return ret;
387}
388
389static int trf7970a_read_cont(struct trf7970a *trf, u8 reg,
390 u8 *buf, size_t len)
391{
392 u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS;
393 int ret;
394
395 dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
396
397 ret = spi_write_then_read(trf->spi, &addr, 1, buf, len);
398 if (ret)
399 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
400 ret);
401 return ret;
402}
403
404static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)
405{
406 u8 buf[2] = { reg, val };
407 int ret;
408
409 dev_dbg(trf->dev, "write(0x%x): 0x%x\n", reg, val);
410
411 ret = spi_write(trf->spi, buf, 2);
412 if (ret)
413 dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__,
414 buf[0], buf[1], ret);
415
416 return ret;
417}
418
419static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
420{
421 int ret;
422 u8 buf[2];
423 u8 addr;
424
425 addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW;
426
427 if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA) {
428 addr |= TRF7970A_CMD_BIT_CONTINUOUS;
429 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
430 } else {
431 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 1);
432 }
433
434 if (ret)
435 dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n",
436 __func__, ret);
437 else
438 *status = buf[0];
439
440 return ret;
441}
442
443static void trf7970a_send_upstream(struct trf7970a *trf)
444{
445 u8 rssi;
446
447 dev_kfree_skb_any(trf->tx_skb);
448 trf->tx_skb = NULL;
449
450 if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)
451 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE,
452 16, 1, trf->rx_skb->data, trf->rx_skb->len,
453 false);
454
455 /* According to the manual it is "good form" to reset the fifo and
456 * read the RSSI levels & oscillator status register here. It doesn't
457 * explain why.
458 */
459 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
460 trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
461
462 trf->state = TRF7970A_ST_IDLE;
463
464 if (trf->aborting) {
465 dev_dbg(trf->dev, "Abort process complete\n");
466
467 if (!IS_ERR(trf->rx_skb)) {
468 kfree_skb(trf->rx_skb);
469 trf->rx_skb = ERR_PTR(-ECANCELED);
470 }
471
472 trf->aborting = false;
473 }
474
475 trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb);
476
477 trf->rx_skb = NULL;
478}
479
480static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
481{
482 dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
483
484 kfree_skb(trf->rx_skb);
485 trf->rx_skb = ERR_PTR(errno);
486
487 trf7970a_send_upstream(trf);
488}
489
490static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
491 unsigned int len)
492{
493 unsigned int timeout;
494 int ret;
495
496 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE,
497 16, 1, skb->data, len, false);
498
499 ret = spi_write(trf->spi, skb->data, len);
500 if (ret) {
501 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
502 ret);
503 return ret;
504 }
505
506 skb_pull(skb, len);
507
508 if (skb->len > 0) {
509 trf->state = TRF7970A_ST_WAIT_FOR_TX_FIFO;
510 timeout = TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT;
511 } else {
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700512 if (trf->issue_eof) {
513 trf->state = TRF7970A_ST_WAIT_TO_ISSUE_EOF;
514 timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF;
515 } else {
516 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
517 timeout = trf->timeout;
518 }
Mark A. Greer165063f2014-03-10 11:56:22 -0700519 }
520
521 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout,
522 trf->state);
523
524 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
525
526 return 0;
527}
528
529static void trf7970a_fill_fifo(struct trf7970a *trf)
530{
531 struct sk_buff *skb = trf->tx_skb;
532 unsigned int len;
533 int ret;
534 u8 fifo_bytes;
535
536 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
537 if (ret) {
538 trf7970a_send_err_upstream(trf, ret);
539 return;
540 }
541
542 dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
543
544 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) {
545 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
546 fifo_bytes);
547 trf7970a_send_err_upstream(trf, -EIO);
548 return;
549 }
550
551 /* Calculate how much more data can be written to the fifo */
552 len = TRF7970A_FIFO_SIZE - fifo_bytes;
553 len = min(skb->len, len);
554
555 ret = trf7970a_transmit(trf, skb, len);
556 if (ret)
557 trf7970a_send_err_upstream(trf, ret);
558}
559
560static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
561{
562 struct sk_buff *skb = trf->rx_skb;
563 int ret;
564 u8 fifo_bytes;
565
566 if (status & TRF7970A_IRQ_STATUS_ERROR) {
567 trf7970a_send_err_upstream(trf, -EIO);
568 return;
569 }
570
571 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
572 if (ret) {
573 trf7970a_send_err_upstream(trf, ret);
574 return;
575 }
576
577 dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
578
579 if (!fifo_bytes)
580 goto no_rx_data;
581
582 if (fifo_bytes & TRF7970A_FIFO_STATUS_OVERFLOW) {
583 dev_err(trf->dev, "%s - fifo overflow: 0x%x\n", __func__,
584 fifo_bytes);
585 trf7970a_send_err_upstream(trf, -EIO);
586 return;
587 }
588
589 if (fifo_bytes > skb_tailroom(skb)) {
590 skb = skb_copy_expand(skb, skb_headroom(skb),
591 max_t(int, fifo_bytes,
592 TRF7970A_RX_SKB_ALLOC_SIZE),
593 GFP_KERNEL);
594 if (!skb) {
595 trf7970a_send_err_upstream(trf, -ENOMEM);
596 return;
597 }
598
599 kfree_skb(trf->rx_skb);
600 trf->rx_skb = skb;
601 }
602
603 ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER,
604 skb_put(skb, fifo_bytes), fifo_bytes);
605 if (ret) {
606 trf7970a_send_err_upstream(trf, ret);
607 return;
608 }
609
610 /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
611 if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) &&
612 (trf->special_fcn_reg1 ==
613 TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) {
614 skb->data[0] >>= 4;
615 status = TRF7970A_IRQ_STATUS_SRX;
616 } else {
617 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
618 }
619
620no_rx_data:
621 if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */
622 trf7970a_send_upstream(trf);
623 return;
624 }
625
626 dev_dbg(trf->dev, "Setting timeout for %d ms\n",
627 TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT);
628
629 schedule_delayed_work(&trf->timeout_work,
630 msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT));
631}
632
633static irqreturn_t trf7970a_irq(int irq, void *dev_id)
634{
635 struct trf7970a *trf = dev_id;
636 int ret;
637 u8 status;
638
639 mutex_lock(&trf->lock);
640
641 if (trf->state == TRF7970A_ST_OFF) {
642 mutex_unlock(&trf->lock);
643 return IRQ_NONE;
644 }
645
646 ret = trf7970a_read_irqstatus(trf, &status);
647 if (ret) {
648 mutex_unlock(&trf->lock);
649 return IRQ_NONE;
650 }
651
652 dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state,
653 status);
654
655 if (!status) {
656 mutex_unlock(&trf->lock);
657 return IRQ_NONE;
658 }
659
660 switch (trf->state) {
661 case TRF7970A_ST_IDLE:
662 case TRF7970A_ST_IDLE_RX_BLOCKED:
663 /* If getting interrupts caused by RF noise, turn off the
664 * receiver to avoid unnecessary interrupts. It will be
665 * turned back on in trf7970a_in_send_cmd() when the next
666 * command is issued.
667 */
668 if (status & TRF7970A_IRQ_STATUS_ERROR) {
669 trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
670 trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
671 }
672
673 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
674 break;
675 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
676 if (status & TRF7970A_IRQ_STATUS_TX) {
677 trf->ignore_timeout =
678 !cancel_delayed_work(&trf->timeout_work);
679 trf7970a_fill_fifo(trf);
680 } else {
681 trf7970a_send_err_upstream(trf, -EIO);
682 }
683 break;
684 case TRF7970A_ST_WAIT_FOR_RX_DATA:
685 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
686 if (status & TRF7970A_IRQ_STATUS_SRX) {
687 trf->ignore_timeout =
688 !cancel_delayed_work(&trf->timeout_work);
689 trf7970a_drain_fifo(trf, status);
Mark A. Greer4dd836e2014-03-25 08:54:32 -0700690 } else if (status == TRF7970A_IRQ_STATUS_TX) {
691 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
692 } else {
Mark A. Greer165063f2014-03-10 11:56:22 -0700693 trf7970a_send_err_upstream(trf, -EIO);
694 }
695 break;
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700696 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
697 if (status != TRF7970A_IRQ_STATUS_TX)
698 trf7970a_send_err_upstream(trf, -EIO);
699 break;
Mark A. Greer165063f2014-03-10 11:56:22 -0700700 default:
701 dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
702 __func__, trf->state);
703 }
704
705 mutex_unlock(&trf->lock);
706 return IRQ_HANDLED;
707}
708
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700709static void trf7970a_issue_eof(struct trf7970a *trf)
710{
711 int ret;
712
713 dev_dbg(trf->dev, "Issuing EOF\n");
714
715 ret = trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
716 if (ret)
717 trf7970a_send_err_upstream(trf, ret);
718
719 ret = trf7970a_cmd(trf, TRF7970A_CMD_EOF);
720 if (ret)
721 trf7970a_send_err_upstream(trf, ret);
722
723 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
724
725 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n",
726 trf->timeout, trf->state);
727
728 schedule_delayed_work(&trf->timeout_work,
729 msecs_to_jiffies(trf->timeout));
730}
731
Mark A. Greer165063f2014-03-10 11:56:22 -0700732static void trf7970a_timeout_work_handler(struct work_struct *work)
733{
734 struct trf7970a *trf = container_of(work, struct trf7970a,
735 timeout_work.work);
736
737 dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n",
738 trf->state, trf->ignore_timeout);
739
740 mutex_lock(&trf->lock);
741
742 if (trf->ignore_timeout)
743 trf->ignore_timeout = false;
744 else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
745 trf7970a_send_upstream(trf); /* No more rx data so send up */
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700746 else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
747 trf7970a_issue_eof(trf);
Mark A. Greer165063f2014-03-10 11:56:22 -0700748 else
749 trf7970a_send_err_upstream(trf, -ETIMEDOUT);
750
751 mutex_unlock(&trf->lock);
752}
753
754static int trf7970a_init(struct trf7970a *trf)
755{
756 int ret;
757
758 dev_dbg(trf->dev, "Initializing device - state: %d\n", trf->state);
759
760 ret = trf7970a_cmd(trf, TRF7970A_CMD_SOFT_INIT);
761 if (ret)
762 goto err_out;
763
764 ret = trf7970a_cmd(trf, TRF7970A_CMD_IDLE);
765 if (ret)
766 goto err_out;
767
Mark A. Greerb887eb02014-03-25 08:54:31 -0700768 /* Must clear NFC Target Detection Level reg due to erratum */
769 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
770 if (ret)
771 goto err_out;
772
Mark A. Greer165063f2014-03-10 11:56:22 -0700773 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
774 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 |
775 TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32);
776 if (ret)
777 goto err_out;
778
779 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 0);
780 if (ret)
781 goto err_out;
782
783 trf->special_fcn_reg1 = 0;
784
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700785 trf->iso_ctrl = 0xff;
Mark A. Greer165063f2014-03-10 11:56:22 -0700786 return 0;
787
788err_out:
789 dev_dbg(trf->dev, "Couldn't init device: %d\n", ret);
790 return ret;
791}
792
793static void trf7970a_switch_rf_off(struct trf7970a *trf)
794{
795 dev_dbg(trf->dev, "Switching rf off\n");
796
Mark A. Greera1d2dc52014-03-25 08:54:37 -0700797 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
798
799 trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
800
Mark A. Greer165063f2014-03-10 11:56:22 -0700801 trf->aborting = false;
802 trf->state = TRF7970A_ST_OFF;
Mark A. Greere6403b72014-03-25 08:54:38 -0700803
804 pm_runtime_mark_last_busy(trf->dev);
805 pm_runtime_put_autosuspend(trf->dev);
Mark A. Greer165063f2014-03-10 11:56:22 -0700806}
807
Mark A. Greer18422e62014-03-25 08:54:39 -0700808static void trf7970a_switch_rf_on(struct trf7970a *trf)
Mark A. Greer165063f2014-03-10 11:56:22 -0700809{
Mark A. Greer165063f2014-03-10 11:56:22 -0700810 dev_dbg(trf->dev, "Switching rf on\n");
811
Mark A. Greere6403b72014-03-25 08:54:38 -0700812 pm_runtime_get_sync(trf->dev);
Mark A. Greer165063f2014-03-10 11:56:22 -0700813
Mark A. Greere6403b72014-03-25 08:54:38 -0700814 trf->state = TRF7970A_ST_IDLE;
Mark A. Greer165063f2014-03-10 11:56:22 -0700815}
816
817static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
818{
819 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
Mark A. Greer165063f2014-03-10 11:56:22 -0700820
821 dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
822
823 mutex_lock(&trf->lock);
824
825 if (on) {
826 switch (trf->state) {
827 case TRF7970A_ST_OFF:
Mark A. Greer18422e62014-03-25 08:54:39 -0700828 trf7970a_switch_rf_on(trf);
Mark A. Greer165063f2014-03-10 11:56:22 -0700829 break;
830 case TRF7970A_ST_IDLE:
831 case TRF7970A_ST_IDLE_RX_BLOCKED:
832 break;
833 default:
834 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
835 __func__, trf->state, on);
836 trf7970a_switch_rf_off(trf);
837 }
838 } else {
839 switch (trf->state) {
840 case TRF7970A_ST_OFF:
841 break;
842 default:
843 dev_err(trf->dev, "%s - Invalid request: %d %d\n",
844 __func__, trf->state, on);
845 /* FALLTHROUGH */
846 case TRF7970A_ST_IDLE:
847 case TRF7970A_ST_IDLE_RX_BLOCKED:
848 trf7970a_switch_rf_off(trf);
849 }
850 }
851
852 mutex_unlock(&trf->lock);
Mark A. Greer18422e62014-03-25 08:54:39 -0700853 return 0;
Mark A. Greer165063f2014-03-10 11:56:22 -0700854}
855
856static int trf7970a_config_rf_tech(struct trf7970a *trf, int tech)
857{
858 int ret = 0;
859
860 dev_dbg(trf->dev, "rf technology: %d\n", tech);
861
862 switch (tech) {
863 case NFC_DIGITAL_RF_TECH_106A:
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700864 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
Mark A. Greer12e9ade2014-03-25 08:54:35 -0700865 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
Mark A. Greer165063f2014-03-10 11:56:22 -0700866 break;
Mark A. Greer742b1f92014-03-31 17:52:33 -0700867 case NFC_DIGITAL_RF_TECH_106B:
868 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
869 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
870 break;
Mark A. Greer6857bb92014-04-14 10:04:10 -0700871 case NFC_DIGITAL_RF_TECH_212F:
872 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212;
873 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
874 break;
875 case NFC_DIGITAL_RF_TECH_424F:
876 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424;
877 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_ASK10;
878 break;
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700879 case NFC_DIGITAL_RF_TECH_ISO15693:
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700880 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
Mark A. Greer12e9ade2014-03-25 08:54:35 -0700881 trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_DEPTH_OOK;
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700882 break;
Mark A. Greer165063f2014-03-10 11:56:22 -0700883 default:
884 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
885 return -EINVAL;
886 }
887
888 trf->technology = tech;
889
890 return ret;
891}
892
893static int trf7970a_config_framing(struct trf7970a *trf, int framing)
894{
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700895 u8 iso_ctrl = trf->iso_ctrl_tech;
896 int ret;
897
Mark A. Greer165063f2014-03-10 11:56:22 -0700898 dev_dbg(trf->dev, "framing: %d\n", framing);
899
900 switch (framing) {
901 case NFC_DIGITAL_FRAMING_NFCA_SHORT:
902 case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
903 trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700904 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
Mark A. Greer165063f2014-03-10 11:56:22 -0700905 break;
906 case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
Mark A. Greer80062892014-03-10 11:56:23 -0700907 case NFC_DIGITAL_FRAMING_NFCA_T4T:
Mark A. Greer742b1f92014-03-31 17:52:33 -0700908 case NFC_DIGITAL_FRAMING_NFCB:
909 case NFC_DIGITAL_FRAMING_NFCB_T4T:
Mark A. Greer6857bb92014-04-14 10:04:10 -0700910 case NFC_DIGITAL_FRAMING_NFCF:
911 case NFC_DIGITAL_FRAMING_NFCF_T3T:
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700912 case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
913 case NFC_DIGITAL_FRAMING_ISO15693_T5T:
Mark A. Greer165063f2014-03-10 11:56:22 -0700914 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700915 iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
Mark A. Greer165063f2014-03-10 11:56:22 -0700916 break;
917 case NFC_DIGITAL_FRAMING_NFCA_T2T:
918 trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700919 iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
Mark A. Greer165063f2014-03-10 11:56:22 -0700920 break;
921 default:
922 dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
923 return -EINVAL;
924 }
925
926 trf->framing = framing;
927
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700928 if (iso_ctrl != trf->iso_ctrl) {
929 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
930 if (ret)
931 return ret;
932
933 trf->iso_ctrl = iso_ctrl;
Mark A. Greera0822a72014-03-25 08:54:34 -0700934
935 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
Mark A. Greer12e9ade2014-03-25 08:54:35 -0700936 trf->modulator_sys_clk_ctrl);
Mark A. Greera0822a72014-03-25 08:54:34 -0700937 if (ret)
938 return ret;
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700939 }
940
Mark A. Greera1d2dc52014-03-25 08:54:37 -0700941 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
942 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
943 trf->chip_status_ctrl |
944 TRF7970A_CHIP_STATUS_RF_ON);
945 if (ret)
946 return ret;
947
948 trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
949
950 usleep_range(5000, 6000);
951 }
952
Mark A. Greer49d19cc2014-03-25 08:54:33 -0700953 return 0;
Mark A. Greer165063f2014-03-10 11:56:22 -0700954}
955
956static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,
957 int param)
958{
959 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
Mark A. Greer18422e62014-03-25 08:54:39 -0700960 int ret;
Mark A. Greer165063f2014-03-10 11:56:22 -0700961
962 dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
963
964 mutex_lock(&trf->lock);
965
Mark A. Greer18422e62014-03-25 08:54:39 -0700966 if (trf->state == TRF7970A_ST_OFF)
967 trf7970a_switch_rf_on(trf);
Mark A. Greer165063f2014-03-10 11:56:22 -0700968
969 switch (type) {
970 case NFC_DIGITAL_CONFIG_RF_TECH:
971 ret = trf7970a_config_rf_tech(trf, param);
972 break;
973 case NFC_DIGITAL_CONFIG_FRAMING:
974 ret = trf7970a_config_framing(trf, param);
975 break;
976 default:
977 dev_dbg(trf->dev, "Unknown type: %d\n", type);
978 ret = -EINVAL;
979 }
980
Mark A. Greer165063f2014-03-10 11:56:22 -0700981 mutex_unlock(&trf->lock);
982 return ret;
983}
984
Mark A. Greer9d9304b2014-03-10 11:56:24 -0700985static int trf7970a_is_iso15693_write_or_lock(u8 cmd)
986{
987 switch (cmd) {
988 case ISO15693_CMD_WRITE_SINGLE_BLOCK:
989 case ISO15693_CMD_LOCK_BLOCK:
990 case ISO15693_CMD_WRITE_MULTIPLE_BLOCK:
991 case ISO15693_CMD_WRITE_AFI:
992 case ISO15693_CMD_LOCK_AFI:
993 case ISO15693_CMD_WRITE_DSFID:
994 case ISO15693_CMD_LOCK_DSFID:
995 return 1;
996 break;
997 default:
998 return 0;
999 }
1000}
1001
Mark A. Greer165063f2014-03-10 11:56:22 -07001002static int trf7970a_per_cmd_config(struct trf7970a *trf, struct sk_buff *skb)
1003{
1004 u8 *req = skb->data;
Mark A. Greer9d9304b2014-03-10 11:56:24 -07001005 u8 special_fcn_reg1, iso_ctrl;
Mark A. Greer165063f2014-03-10 11:56:22 -07001006 int ret;
1007
Mark A. Greer9d9304b2014-03-10 11:56:24 -07001008 trf->issue_eof = false;
1009
Mark A. Greer165063f2014-03-10 11:56:22 -07001010 /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
1011 * special functions register 1 is cleared; otherwise, its a write or
1012 * sector select command and '4_bit_RX' must be set.
Mark A. Greer9d9304b2014-03-10 11:56:24 -07001013 *
1014 * When issuing an ISO 15693 command, inspect the flags byte to see
1015 * what speed to use. Also, remember if the OPTION flag is set on
1016 * a Type 5 write or lock command so the driver will know that it
1017 * has to send an EOF in order to get a response.
Mark A. Greer165063f2014-03-10 11:56:22 -07001018 */
1019 if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
1020 (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
1021 if (req[0] == NFC_T2T_CMD_READ)
1022 special_fcn_reg1 = 0;
1023 else
1024 special_fcn_reg1 = TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX;
1025
1026 if (special_fcn_reg1 != trf->special_fcn_reg1) {
1027 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
1028 special_fcn_reg1);
1029 if (ret)
1030 return ret;
1031
1032 trf->special_fcn_reg1 = special_fcn_reg1;
1033 }
Mark A. Greer9d9304b2014-03-10 11:56:24 -07001034 } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
1035 iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
1036
1037 switch (req[0] & ISO15693_REQ_FLAG_SPEED_MASK) {
1038 case 0x00:
1039 iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662;
1040 break;
1041 case ISO15693_REQ_FLAG_SUB_CARRIER:
1042 iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a;
1043 break;
1044 case ISO15693_REQ_FLAG_DATA_RATE:
1045 iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
1046 break;
1047 case (ISO15693_REQ_FLAG_SUB_CARRIER |
1048 ISO15693_REQ_FLAG_DATA_RATE):
1049 iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669;
1050 break;
1051 }
1052
1053 if (iso_ctrl != trf->iso_ctrl) {
1054 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
1055 if (ret)
1056 return ret;
1057
1058 trf->iso_ctrl = iso_ctrl;
1059 }
1060
1061 if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&
1062 trf7970a_is_iso15693_write_or_lock(req[1]) &&
1063 (req[0] & ISO15693_REQ_FLAG_OPTION))
1064 trf->issue_eof = true;
Mark A. Greer165063f2014-03-10 11:56:22 -07001065 }
1066
1067 return 0;
1068}
1069
1070static int trf7970a_in_send_cmd(struct nfc_digital_dev *ddev,
1071 struct sk_buff *skb, u16 timeout,
1072 nfc_digital_cmd_complete_t cb, void *arg)
1073{
1074 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1075 char *prefix;
1076 unsigned int len;
1077 int ret;
1078
1079 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
1080 trf->state, timeout, skb->len);
1081
1082 if (skb->len > TRF7970A_TX_MAX)
1083 return -EINVAL;
1084
1085 mutex_lock(&trf->lock);
1086
1087 if ((trf->state != TRF7970A_ST_IDLE) &&
1088 (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
1089 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
1090 trf->state);
1091 ret = -EIO;
1092 goto out_err;
1093 }
1094
1095 if (trf->aborting) {
1096 dev_dbg(trf->dev, "Abort process complete\n");
1097 trf->aborting = false;
1098 ret = -ECANCELED;
1099 goto out_err;
1100 }
1101
1102 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
1103 GFP_KERNEL);
1104 if (!trf->rx_skb) {
1105 dev_dbg(trf->dev, "Can't alloc rx_skb\n");
1106 ret = -ENOMEM;
1107 goto out_err;
1108 }
1109
1110 if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
1111 ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
1112 if (ret)
1113 goto out_err;
1114
1115 trf->state = TRF7970A_ST_IDLE;
1116 }
1117
1118 ret = trf7970a_per_cmd_config(trf, skb);
1119 if (ret)
1120 goto out_err;
1121
1122 trf->ddev = ddev;
1123 trf->tx_skb = skb;
1124 trf->cb = cb;
1125 trf->cb_arg = arg;
1126 trf->timeout = timeout;
1127 trf->ignore_timeout = false;
1128
1129 len = skb->len;
1130 prefix = skb_push(skb, TRF7970A_TX_SKB_HEADROOM);
1131
1132 /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
1133 * on what the current framing is, the address of the TX length byte 1
1134 * register (0x1d), and the 2 byte length of the data to be transmitted.
1135 */
1136 prefix[0] = TRF7970A_CMD_BIT_CTRL |
1137 TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET);
1138 prefix[1] = TRF7970A_CMD_BIT_CTRL |
1139 TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
1140 prefix[2] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1;
1141
1142 if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
1143 prefix[3] = 0x00;
1144 prefix[4] = 0x0f; /* 7 bits */
1145 } else {
1146 prefix[3] = (len & 0xf00) >> 4;
1147 prefix[3] |= ((len & 0xf0) >> 4);
1148 prefix[4] = ((len & 0x0f) << 4);
1149 }
1150
1151 len = min_t(int, skb->len, TRF7970A_FIFO_SIZE);
1152
1153 usleep_range(1000, 2000);
1154
1155 ret = trf7970a_transmit(trf, skb, len);
1156 if (ret) {
1157 kfree_skb(trf->rx_skb);
1158 trf->rx_skb = NULL;
1159 }
1160
1161out_err:
1162 mutex_unlock(&trf->lock);
1163 return ret;
1164}
1165
1166static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev,
1167 int type, int param)
1168{
1169 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1170
1171 dev_dbg(trf->dev, "Unsupported interface\n");
1172
1173 return -EINVAL;
1174}
1175
1176static int trf7970a_tg_send_cmd(struct nfc_digital_dev *ddev,
1177 struct sk_buff *skb, u16 timeout,
1178 nfc_digital_cmd_complete_t cb, void *arg)
1179{
1180 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1181
1182 dev_dbg(trf->dev, "Unsupported interface\n");
1183
1184 return -EINVAL;
1185}
1186
1187static int trf7970a_tg_listen(struct nfc_digital_dev *ddev,
1188 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1189{
1190 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1191
1192 dev_dbg(trf->dev, "Unsupported interface\n");
1193
1194 return -EINVAL;
1195}
1196
1197static int trf7970a_tg_listen_mdaa(struct nfc_digital_dev *ddev,
1198 struct digital_tg_mdaa_params *mdaa_params,
1199 u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
1200{
1201 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1202
1203 dev_dbg(trf->dev, "Unsupported interface\n");
1204
1205 return -EINVAL;
1206}
1207
1208static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
1209{
1210 struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
1211
1212 dev_dbg(trf->dev, "Abort process initiated\n");
1213
1214 mutex_lock(&trf->lock);
Mark A. Greer5876bc72014-03-25 08:54:30 -07001215
1216 switch (trf->state) {
1217 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1218 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1219 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
1220 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
1221 trf->aborting = true;
1222 break;
1223 default:
1224 break;
1225 }
1226
Mark A. Greer165063f2014-03-10 11:56:22 -07001227 mutex_unlock(&trf->lock);
1228}
1229
1230static struct nfc_digital_ops trf7970a_nfc_ops = {
1231 .in_configure_hw = trf7970a_in_configure_hw,
1232 .in_send_cmd = trf7970a_in_send_cmd,
1233 .tg_configure_hw = trf7970a_tg_configure_hw,
1234 .tg_send_cmd = trf7970a_tg_send_cmd,
1235 .tg_listen = trf7970a_tg_listen,
1236 .tg_listen_mdaa = trf7970a_tg_listen_mdaa,
1237 .switch_rf = trf7970a_switch_rf,
1238 .abort_cmd = trf7970a_abort_cmd,
1239};
1240
Mark A. Greerfd0c8282014-03-25 08:54:40 -07001241static int trf7970a_get_autosuspend_delay(struct device_node *np)
1242{
1243 int autosuspend_delay, ret;
1244
1245 ret = of_property_read_u32(np, "autosuspend-delay", &autosuspend_delay);
1246 if (ret)
1247 autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY;
1248
1249 of_node_put(np);
1250
1251 return autosuspend_delay;
1252}
1253
Mark A. Greer165063f2014-03-10 11:56:22 -07001254static int trf7970a_probe(struct spi_device *spi)
1255{
1256 struct device_node *np = spi->dev.of_node;
1257 const struct spi_device_id *id = spi_get_device_id(spi);
1258 struct trf7970a *trf;
Mark A. Greerfd0c8282014-03-25 08:54:40 -07001259 int uvolts, autosuspend_delay, ret;
Mark A. Greer165063f2014-03-10 11:56:22 -07001260
1261 if (!np) {
1262 dev_err(&spi->dev, "No Device Tree entry\n");
1263 return -EINVAL;
1264 }
1265
1266 trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
1267 if (!trf)
1268 return -ENOMEM;
1269
1270 trf->state = TRF7970A_ST_OFF;
1271 trf->dev = &spi->dev;
1272 trf->spi = spi;
1273 trf->quirks = id->driver_data;
1274
1275 spi->mode = SPI_MODE_1;
1276 spi->bits_per_word = 8;
1277
1278 /* There are two enable pins - both must be present */
1279 trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0);
1280 if (!gpio_is_valid(trf->en_gpio)) {
1281 dev_err(trf->dev, "No EN GPIO property\n");
1282 return trf->en_gpio;
1283 }
1284
1285 ret = devm_gpio_request_one(trf->dev, trf->en_gpio,
1286 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN");
1287 if (ret) {
1288 dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret);
1289 return ret;
1290 }
1291
1292 trf->en2_gpio = of_get_named_gpio(np, "ti,enable-gpios", 1);
1293 if (!gpio_is_valid(trf->en2_gpio)) {
1294 dev_err(trf->dev, "No EN2 GPIO property\n");
1295 return trf->en2_gpio;
1296 }
1297
1298 ret = devm_gpio_request_one(trf->dev, trf->en2_gpio,
1299 GPIOF_DIR_OUT | GPIOF_INIT_LOW, "EN2");
1300 if (ret) {
1301 dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret);
1302 return ret;
1303 }
1304
1305 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
1306 trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1307 "trf7970a", trf);
1308 if (ret) {
1309 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
1310 return ret;
1311 }
1312
1313 mutex_init(&trf->lock);
1314 INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
1315
1316 trf->regulator = devm_regulator_get(&spi->dev, "vin");
1317 if (IS_ERR(trf->regulator)) {
1318 ret = PTR_ERR(trf->regulator);
1319 dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
1320 goto err_destroy_lock;
1321 }
1322
1323 ret = regulator_enable(trf->regulator);
1324 if (ret) {
1325 dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
1326 goto err_destroy_lock;
1327 }
1328
Mark A. Greerebcc5a02014-03-25 08:54:36 -07001329 uvolts = regulator_get_voltage(trf->regulator);
1330
1331 if (uvolts > 4000000)
1332 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
1333
Mark A. Greer165063f2014-03-10 11:56:22 -07001334 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
1335 TRF7970A_SUPPORTED_PROTOCOLS,
1336 NFC_DIGITAL_DRV_CAPS_IN_CRC, TRF7970A_TX_SKB_HEADROOM,
1337 0);
1338 if (!trf->ddev) {
1339 dev_err(trf->dev, "Can't allocate NFC digital device\n");
1340 ret = -ENOMEM;
1341 goto err_disable_regulator;
1342 }
1343
1344 nfc_digital_set_parent_dev(trf->ddev, trf->dev);
1345 nfc_digital_set_drvdata(trf->ddev, trf);
1346 spi_set_drvdata(spi, trf);
1347
Mark A. Greerfd0c8282014-03-25 08:54:40 -07001348 autosuspend_delay = trf7970a_get_autosuspend_delay(np);
1349
1350 pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
Mark A. Greere6403b72014-03-25 08:54:38 -07001351 pm_runtime_use_autosuspend(trf->dev);
1352 pm_runtime_enable(trf->dev);
1353
Mark A. Greer165063f2014-03-10 11:56:22 -07001354 ret = nfc_digital_register_device(trf->ddev);
1355 if (ret) {
1356 dev_err(trf->dev, "Can't register NFC digital device: %d\n",
1357 ret);
1358 goto err_free_ddev;
1359 }
1360
1361 return 0;
1362
1363err_free_ddev:
Mark A. Greere6403b72014-03-25 08:54:38 -07001364 pm_runtime_disable(trf->dev);
Mark A. Greer165063f2014-03-10 11:56:22 -07001365 nfc_digital_free_device(trf->ddev);
1366err_disable_regulator:
1367 regulator_disable(trf->regulator);
1368err_destroy_lock:
1369 mutex_destroy(&trf->lock);
1370 return ret;
1371}
1372
1373static int trf7970a_remove(struct spi_device *spi)
1374{
1375 struct trf7970a *trf = spi_get_drvdata(spi);
1376
1377 mutex_lock(&trf->lock);
1378
Mark A. Greer165063f2014-03-10 11:56:22 -07001379 switch (trf->state) {
1380 case TRF7970A_ST_WAIT_FOR_TX_FIFO:
1381 case TRF7970A_ST_WAIT_FOR_RX_DATA:
1382 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
Mark A. Greer9d9304b2014-03-10 11:56:24 -07001383 case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
Mark A. Greer165063f2014-03-10 11:56:22 -07001384 trf7970a_send_err_upstream(trf, -ECANCELED);
Mark A. Greere6403b72014-03-25 08:54:38 -07001385 /* FALLTHROUGH */
1386 case TRF7970A_ST_IDLE:
1387 case TRF7970A_ST_IDLE_RX_BLOCKED:
1388 pm_runtime_put_sync(trf->dev);
Mark A. Greer165063f2014-03-10 11:56:22 -07001389 break;
1390 default:
1391 break;
1392 }
1393
1394 mutex_unlock(&trf->lock);
1395
Mark A. Greere6403b72014-03-25 08:54:38 -07001396 pm_runtime_disable(trf->dev);
1397
Mark A. Greer165063f2014-03-10 11:56:22 -07001398 nfc_digital_unregister_device(trf->ddev);
1399 nfc_digital_free_device(trf->ddev);
1400
1401 regulator_disable(trf->regulator);
1402
1403 mutex_destroy(&trf->lock);
1404
1405 return 0;
1406}
1407
Mark A. Greere6403b72014-03-25 08:54:38 -07001408#ifdef CONFIG_PM_RUNTIME
1409static int trf7970a_pm_runtime_suspend(struct device *dev)
1410{
1411 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1412 struct trf7970a *trf = spi_get_drvdata(spi);
1413 int ret;
1414
1415 dev_dbg(dev, "Runtime suspend\n");
1416
1417 if (trf->state != TRF7970A_ST_OFF) {
1418 dev_dbg(dev, "Can't suspend - not in OFF state (%d)\n",
1419 trf->state);
1420 return -EBUSY;
1421 }
1422
1423 gpio_set_value(trf->en_gpio, 0);
1424 gpio_set_value(trf->en2_gpio, 0);
1425
1426 ret = regulator_disable(trf->regulator);
1427 if (ret)
1428 dev_err(dev, "%s - Can't disable VIN: %d\n", __func__, ret);
1429
1430 return ret;
1431}
1432
1433static int trf7970a_pm_runtime_resume(struct device *dev)
1434{
1435 struct spi_device *spi = container_of(dev, struct spi_device, dev);
1436 struct trf7970a *trf = spi_get_drvdata(spi);
1437 int ret;
1438
1439 dev_dbg(dev, "Runtime resume\n");
1440
1441 ret = regulator_enable(trf->regulator);
1442 if (ret) {
1443 dev_err(dev, "%s - Can't enable VIN: %d\n", __func__, ret);
1444 return ret;
1445 }
1446
1447 usleep_range(5000, 6000);
1448
1449 gpio_set_value(trf->en2_gpio, 1);
1450 usleep_range(1000, 2000);
1451 gpio_set_value(trf->en_gpio, 1);
1452
1453 usleep_range(20000, 21000);
1454
1455 ret = trf7970a_init(trf);
1456 if (ret) {
1457 dev_err(dev, "%s - Can't initialize: %d\n", __func__, ret);
1458 return ret;
1459 }
1460
1461 pm_runtime_mark_last_busy(dev);
1462
1463 return 0;
1464}
1465#endif
1466
1467static const struct dev_pm_ops trf7970a_pm_ops = {
1468 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend,
1469 trf7970a_pm_runtime_resume, NULL)
1470};
1471
Mark A. Greer165063f2014-03-10 11:56:22 -07001472static const struct spi_device_id trf7970a_id_table[] = {
1473 { "trf7970a", TRF7970A_QUIRK_IRQ_STATUS_READ_ERRATA },
1474 { }
1475};
1476MODULE_DEVICE_TABLE(spi, trf7970a_id_table);
1477
1478static struct spi_driver trf7970a_spi_driver = {
1479 .probe = trf7970a_probe,
1480 .remove = trf7970a_remove,
1481 .id_table = trf7970a_id_table,
1482 .driver = {
1483 .name = "trf7970a",
1484 .owner = THIS_MODULE,
Mark A. Greere6403b72014-03-25 08:54:38 -07001485 .pm = &trf7970a_pm_ops,
Mark A. Greer165063f2014-03-10 11:56:22 -07001486 },
1487};
1488
1489module_spi_driver(trf7970a_spi_driver);
1490
1491MODULE_AUTHOR("Mark A. Greer <mgreer@animalcreek.com>");
1492MODULE_LICENSE("GPL v2");
1493MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");