Quelle trf7970a.c
Sprache: C
// SPDX-License-Identifier: GPL-2.0-only /* * TI TRF7970a RFID / NFC Transceiver Driver * * Copyright ( C ) 2013 Texas Instruments Incorporated - http : //www.ti.com * * Author : Erick Macias < emacias @ ti . com > * Author : Felipe Balbi < balbi @ ti . com > * Author : Mark A . Greer < mgreer @ animalcreek . com > #include <linux/module.h>#include <linux/device.h>#include <linux/netdevice.h>#include <linux/interrupt.h>#include <linux/pm_runtime.h>#include <linux/nfc.h>#include <linux/skbuff.h>#include <linux/delay.h>#include <linux/gpio/consumer.h>#include <linux/of.h>#include <linux/spi/spi.h>#include <linux/regulator/consumer.h>#include <net/nfc/nfc.h>#include <net/nfc/digital.h>/* There are 3 ways the host can communicate with the trf7970a: * parallel mode , SPI with Slave Select ( SS ) mode , and SPI without * SS mode . The driver only supports the two SPI modes . * * The trf7970a is very timing sensitive and the VIN , EN2 , and EN * pins must asserted in that order and with specific delays in between . * The delays used in the driver were provided by TI and have been * confirmed to work with this driver . There is a bug with the current * version of the trf7970a that requires that EN2 remain low no matter * what . If it goes high , it will generate an RF field even when in * passive target mode . TI has indicated that the chip will work okay * when EN2 is left low . The ' en2 - rf - quirk ' device tree property * indicates that trf7970a currently being used has the erratum and * that EN2 must be kept low . * * Timeouts are implemented using the delayed workqueue kernel facility . * Timeouts are required so things don ' t hang when there is no response * from the trf7970a ( or tag ) . Using this mechanism creates a race with * interrupts , however . That is , an interrupt and a timeout could occur * closely enough together that one is blocked by the mutex while the other * executes . When the timeout handler executes first and blocks the * interrupt handler , it will eventually set the state to IDLE so the * interrupt handler will check the state and exit with no harm done . * When the interrupt handler executes first and blocks the timeout handler , * the cancel_delayed_work ( ) call will know that it didn ' t cancel the * work item ( i . e . , timeout ) and will return zero . That return code is * used by the timer handler to indicate that it should ignore the timeout * once its unblocked . * * Aborting an active command isn ' t as simple as it seems because the only * way to abort a command that ' s already been sent to the tag is so turn * off power to the tag . If we do that , though , we ' d have to go through * the entire anticollision procedure again but the digital layer doesn ' t * support that . So , if an abort is received before trf7970a_send_cmd ( ) * has sent the command to the tag , it simply returns - ECANCELED . If the * command has already been sent to the tag , then the driver continues * normally and recieves the response data ( or error ) but just before * sending the data upstream , it frees the rx_skb and sends - ECANCELED * upstream instead . If the command failed , that error will be sent * upstream . * * When recieving data from a tag and the interrupt status register has * only the SRX bit set , it means that all of the data has been received * ( once what ' s in the fifo has been read ) . However , depending on timing * an interrupt status with only the SRX bit set may not be recived . In * those cases , the timeout mechanism is used to wait 20 ms in case more * data arrives . After 20 ms , it is assumed that all of the data has been * received and the accumulated rx data is sent upstream . The * ' TRF7970A_ST_WAIT_FOR_RX_DATA_CONT ' state is used for this purpose * ( i . e . , it indicates that some data has been received but we ' re not sure * if there is more coming so a timeout in this state means all data has * been received and there isn ' t an error ) . The delay is 20 ms since delays * of ~ 16 ms have been observed during testing . * * When transmitting a frame larger than the FIFO size ( 127 bytes ) , the * driver will wait 20 ms for the FIFO to drain past the low - watermark * and generate an interrupt . The low - watermark set to 32 bytes so the * interrupt should fire after 127 - 32 = 95 bytes have been sent . At * the lowest possible bit rate ( 6 . 62 kbps for 15693 ) , it will take up * to ~ 14 . 35 ms so 20 ms is used for the timeout . * * Type 2 write and sector select commands respond with a 4 - bit ACK or NACK . * Having only 4 bits in the FIFO won ' t normally generate an interrupt so * driver enables the ' 4 _ bit_RX ' bit of the Special Functions register 1 * to cause an interrupt in that case . Leaving that bit for a read command * messes up the data returned so it is only enabled when the framing is * ' NFC_DIGITAL_FRAMING_NFCA_T2T ' and the command is not a read command . * Unfortunately , that means that the driver has to peek into tx frames * when the framing is ' NFC_DIGITAL_FRAMING_NFCA_T2T ' . This is done by * the trf7970a_per_cmd_config ( ) routine . * * ISO / IEC 15693 frames specify whether to use single or double sub - carrier * frequencies and whether to use low or high data rates in the flags byte * of the frame . This means that the driver has to peek at all 15693 frames * to determine what speed to set the communication to . In addition , write * and lock commands use the OPTION flag to indicate that an EOF must be * sent to the tag before it will send its response . So the driver has to * examine all frames for that reason too . * * It is unclear how long to wait before sending the EOF . According to the * Note under Table 1 - 1 in section 1 . 6 of * http : //www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least * 10 ms for TI Tag - it HF - I tags ; however testing has shown that is not long * enough so 20 ms is used . So the timer is set to 40 ms - 20 ms to drain * up to 127 bytes in the FIFO at the lowest bit rate plus another 20 ms to * ensure the wait is long enough before sending the EOF . This seems to work * reliably . #define TRF7970A_SUPPORTED_PROTOCOLS \#define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */ #define TRF7970A_13MHZ_CLOCK_FREQUENCY 13560000 #define TRF7970A_27MHZ_CLOCK_FREQUENCY 27120000 #define TRF7970A_RX_SKB_ALLOC_SIZE 256 #define TRF7970A_FIFO_SIZE 127 /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */ #define TRF7970A_TX_MAX (4096 - 1 )#define TRF7970A_WAIT_FOR_TX_IRQ 20 #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20 #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 20 #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 40 /* Guard times for various RF technologies (in us) */ #define TRF7970A_GUARD_TIME_NFCA 5000 #define TRF7970A_GUARD_TIME_NFCB 5000 #define TRF7970A_GUARD_TIME_NFCF 20000 #define TRF7970A_GUARD_TIME_15693 1000 /* Quirks */ /* Erratum: When reading IRQ Status register on trf7970a, we must issue a * read continuous command for IRQ Status and Collision Position registers . #define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0 )#define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1 )/* Direct commands */ #define TRF7970A_CMD_IDLE 0 x00#define TRF7970A_CMD_SOFT_INIT 0 x03#define TRF7970A_CMD_RF_COLLISION 0 x04#define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0 x05#define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0 x06#define TRF7970A_CMD_FIFO_RESET 0 x0f#define TRF7970A_CMD_TRANSMIT_NO_CRC 0 x10#define TRF7970A_CMD_TRANSMIT 0 x11#define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0 x12#define TRF7970A_CMD_DELAY_TRANSMIT 0 x13#define TRF7970A_CMD_EOF 0 x14#define TRF7970A_CMD_CLOSE_SLOT 0 x15#define TRF7970A_CMD_BLOCK_RX 0 x16#define TRF7970A_CMD_ENABLE_RX 0 x17#define TRF7970A_CMD_TEST_INT_RF 0 x18#define TRF7970A_CMD_TEST_EXT_RF 0 x19#define TRF7970A_CMD_RX_GAIN_ADJUST 0 x1a/* Bits determining whether its a direct command or register R/W, * whether to use a continuous SPI transaction or not , and the actual * direct cmd opcode or register address . #define TRF7970A_CMD_BIT_CTRL BIT(7 )#define TRF7970A_CMD_BIT_RW BIT(6 )#define TRF7970A_CMD_BIT_CONTINUOUS BIT(5 )#define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0 x1f)/* Registers addresses */ #define TRF7970A_CHIP_STATUS_CTRL 0 x00#define TRF7970A_ISO_CTRL 0 x01#define TRF7970A_ISO14443B_TX_OPTIONS 0 x02#define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0 x03#define TRF7970A_TX_TIMER_SETTING_H_BYTE 0 x04#define TRF7970A_TX_TIMER_SETTING_L_BYTE 0 x05#define TRF7970A_TX_PULSE_LENGTH_CTRL 0 x06#define TRF7970A_RX_NO_RESPONSE_WAIT 0 x07#define TRF7970A_RX_WAIT_TIME 0 x08#define TRF7970A_MODULATOR_SYS_CLK_CTRL 0 x09#define TRF7970A_RX_SPECIAL_SETTINGS 0 x0a#define TRF7970A_REG_IO_CTRL 0 x0b#define TRF7970A_IRQ_STATUS 0 x0c#define TRF7970A_COLLISION_IRQ_MASK 0 x0d#define TRF7970A_COLLISION_POSITION 0 x0e#define TRF7970A_RSSI_OSC_STATUS 0 x0f#define TRF7970A_SPECIAL_FCN_REG1 0 x10#define TRF7970A_SPECIAL_FCN_REG2 0 x11#define TRF7970A_RAM1 0 x12#define TRF7970A_RAM2 0 x13#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0 x14#define TRF7970A_NFC_LOW_FIELD_LEVEL 0 x16#define TRF7970A_NFCID1 0 x17#define TRF7970A_NFC_TARGET_LEVEL 0 x18#define TRF79070A_NFC_TARGET_PROTOCOL 0 x19#define TRF7970A_TEST_REGISTER1 0 x1a#define TRF7970A_TEST_REGISTER2 0 x1b#define TRF7970A_FIFO_STATUS 0 x1c#define TRF7970A_TX_LENGTH_BYTE1 0 x1d#define TRF7970A_TX_LENGTH_BYTE2 0 x1e#define TRF7970A_FIFO_IO_REGISTER 0 x1f/* Chip Status Control Register Bits */ #define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0 )#define TRF7970A_CHIP_STATUS_REC_ON BIT(1 )#define TRF7970A_CHIP_STATUS_AGC_ON BIT(2 )#define TRF7970A_CHIP_STATUS_PM_ON BIT(3 )#define TRF7970A_CHIP_STATUS_RF_PWR BIT(4 )#define TRF7970A_CHIP_STATUS_RF_ON BIT(5 )#define TRF7970A_CHIP_STATUS_DIRECT BIT(6 )#define TRF7970A_CHIP_STATUS_STBY BIT(7 )/* ISO Control Register Bits */ #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0 x00#define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0 x01#define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0 x02#define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0 x03#define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0 x04#define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0 x05#define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0 x06#define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0 x07#define TRF7970A_ISO_CTRL_14443A_106 0 x08#define TRF7970A_ISO_CTRL_14443A_212 0 x09#define TRF7970A_ISO_CTRL_14443A_424 0 x0a#define TRF7970A_ISO_CTRL_14443A_848 0 x0b#define TRF7970A_ISO_CTRL_14443B_106 0 x0c#define TRF7970A_ISO_CTRL_14443B_212 0 x0d#define TRF7970A_ISO_CTRL_14443B_424 0 x0e#define TRF7970A_ISO_CTRL_14443B_848 0 x0f#define TRF7970A_ISO_CTRL_FELICA_212 0 x1a#define TRF7970A_ISO_CTRL_FELICA_424 0 x1b#define TRF7970A_ISO_CTRL_NFC_NFCA_106 0 x01#define TRF7970A_ISO_CTRL_NFC_NFCF_212 0 x02#define TRF7970A_ISO_CTRL_NFC_NFCF_424 0 x03#define TRF7970A_ISO_CTRL_NFC_CE_14443A 0 x00#define TRF7970A_ISO_CTRL_NFC_CE_14443B 0 x01#define TRF7970A_ISO_CTRL_NFC_CE BIT(2 )#define TRF7970A_ISO_CTRL_NFC_ACTIVE BIT(3 )#define TRF7970A_ISO_CTRL_NFC_INITIATOR BIT(4 )#define TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE BIT(5 )#define TRF7970A_ISO_CTRL_RFID BIT(5 )#define TRF7970A_ISO_CTRL_DIR_MODE BIT(6 )#define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7 ) /* true == No CRC */ #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0 x1f/* Modulator and SYS_CLK Control Register Bits */ #define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0 x7)#define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0 ))#define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1 ))#define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2 ))#define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3 ))#define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4 ))#define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5 ))#define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6 ))#define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7 ))#define TRF7970A_MODULATOR_EN_ANA BIT(3 )#define TRF7970A_MODULATOR_CLK(n) (((n) & 0 x3) << 4 )#define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0 ))#define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1 ))#define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2 ))#define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3 ))#define TRF7970A_MODULATOR_EN_OOK BIT(6 )#define TRF7970A_MODULATOR_27MHZ BIT(7 )#define TRF7970A_RX_GAIN_REDUCTION_MAX_DB 15 #define TRF7970A_RX_GAIN_REDUCTION_DB_PER_LSB 5 #define TRF7970A_RX_SPECIAL_SETTINGS_NO_LIM BIT(0 )#define TRF7970A_RX_SPECIAL_SETTINGS_AGCR BIT(1 )#define TRF7970A_RX_SPECIAL_SETTINGS_GD_SHIFT 2 #define TRF7970A_RX_SPECIAL_SETTINGS_GD_MAX (0 x3)#define TRF7970A_RX_SPECIAL_SETTINGS_GD_MASK (TRF7970A_RX_SPECIAL_SETTINGS_GD_MAX << \#define TRF7970A_RX_SPECIAL_SETTINGS_GD_0DB (0 x0 << TRF7970A_RX_SPECIAL_SETTINGS_GD_SHIFT)#define TRF7970A_RX_SPECIAL_SETTINGS_GD_5DB (0 x1 << TRF7970A_RX_SPECIAL_SETTINGS_GD_SHIFT)#define TRF7970A_RX_SPECIAL_SETTINGS_GD_10DB (0 x2 << TRF7970A_RX_SPECIAL_SETTINGS_GD_SHIFT)#define TRF7970A_RX_SPECIAL_SETTINGS_GD_15DB (0 x3 << TRF7970A_RX_SPECIAL_SETTINGS_GD_SHIFT)#define TRF7970A_RX_SPECIAL_SETTINGS_HBT BIT(4 )#define TRF7970A_RX_SPECIAL_SETTINGS_M848 BIT(5 )#define TRF7970A_RX_SPECIAL_SETTINGS_C424 BIT(6 )#define TRF7970A_RX_SPECIAL_SETTINGS_C212 BIT(7 )#define TRF7970A_REG_IO_CTRL_VRS(v) ((v) & 0 x07)#define TRF7970A_REG_IO_CTRL_IO_LOW BIT(5 )#define TRF7970A_REG_IO_CTRL_EN_EXT_PA BIT(6 )#define TRF7970A_REG_IO_CTRL_AUTO_REG BIT(7 )/* IRQ Status Register Bits */ #define TRF7970A_IRQ_STATUS_NORESP BIT(0 ) /* ISO15693 only */ #define TRF7970A_IRQ_STATUS_NFC_COL_ERROR BIT(0 )#define TRF7970A_IRQ_STATUS_COL BIT(1 )#define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2 )#define TRF7970A_IRQ_STATUS_NFC_RF BIT(2 )#define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3 )#define TRF7970A_IRQ_STATUS_NFC_SDD BIT(3 )#define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4 )#define TRF7970A_IRQ_STATUS_NFC_PROTO_ERROR BIT(4 )#define TRF7970A_IRQ_STATUS_FIFO BIT(5 )#define TRF7970A_IRQ_STATUS_SRX BIT(6 )#define TRF7970A_IRQ_STATUS_TX BIT(7 )#define TRF7970A_IRQ_STATUS_ERROR \#define TRF7970A_RSSI_OSC_STATUS_RSSI_MASK (BIT(2 ) | BIT(1 ) | BIT(0 ))#define TRF7970A_RSSI_OSC_STATUS_RSSI_X_MASK (BIT(5 ) | BIT(4 ) | BIT(3 ))#define TRF7970A_RSSI_OSC_STATUS_RSSI_OSC_OK BIT(6 )#define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0 )#define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1 )#define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2 )#define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3 )#define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4 )#define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5 )#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0 x0 << 2 )#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0 x1 << 2 )#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0 x2 << 2 )#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0 x3 << 2 )#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0 x0#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0 x1#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0 x2#define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0 x3#define TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(v) ((v) & 0 x07)#define TRF7970A_NFC_LOW_FIELD_LEVEL_CLEX_DIS BIT(7 )#define TRF7970A_NFC_TARGET_LEVEL_RFDET(v) ((v) & 0 x07)#define TRF7970A_NFC_TARGET_LEVEL_HI_RF BIT(3 )#define TRF7970A_NFC_TARGET_LEVEL_SDD_EN BIT(5 )#define TRF7970A_NFC_TARGET_LEVEL_LD_S_4BYTES (0 x0 << 6 )#define TRF7970A_NFC_TARGET_LEVEL_LD_S_7BYTES (0 x1 << 6 )#define TRF7970A_NFC_TARGET_LEVEL_LD_S_10BYTES (0 x2 << 6 )#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106 BIT(0 )#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212 BIT(1 )#define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424 (BIT(0 ) | BIT(1 ))#define TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B BIT(2 )#define TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 BIT(3 )#define TRF79070A_NFC_TARGET_PROTOCOL_FELICA BIT(4 )#define TRF79070A_NFC_TARGET_PROTOCOL_RF_L BIT(6 )#define TRF79070A_NFC_TARGET_PROTOCOL_RF_H BIT(7 )#define TRF79070A_NFC_TARGET_PROTOCOL_106A \#define TRF79070A_NFC_TARGET_PROTOCOL_106B \#define TRF79070A_NFC_TARGET_PROTOCOL_212F \#define TRF79070A_NFC_TARGET_PROTOCOL_424F \#define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7 )/* NFC (ISO/IEC 14443A) Type 2 Tag commands */ #define NFC_T2T_CMD_READ 0 x30/* ISO 15693 commands codes */ #define ISO15693_CMD_INVENTORY 0 x01#define ISO15693_CMD_READ_SINGLE_BLOCK 0 x20#define ISO15693_CMD_WRITE_SINGLE_BLOCK 0 x21#define ISO15693_CMD_LOCK_BLOCK 0 x22#define ISO15693_CMD_READ_MULTIPLE_BLOCK 0 x23#define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0 x24#define ISO15693_CMD_SELECT 0 x25#define ISO15693_CMD_RESET_TO_READY 0 x26#define ISO15693_CMD_WRITE_AFI 0 x27#define ISO15693_CMD_LOCK_AFI 0 x28#define ISO15693_CMD_WRITE_DSFID 0 x29#define ISO15693_CMD_LOCK_DSFID 0 x2a#define ISO15693_CMD_GET_SYSTEM_INFO 0 x2b#define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0 x2c/* ISO 15693 request and response flags */ #define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0 )#define ISO15693_REQ_FLAG_DATA_RATE BIT(1 )#define ISO15693_REQ_FLAG_INVENTORY BIT(2 )#define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3 )#define ISO15693_REQ_FLAG_SELECT BIT(4 )#define ISO15693_REQ_FLAG_AFI BIT(4 )#define ISO15693_REQ_FLAG_ADDRESS BIT(5 )#define ISO15693_REQ_FLAG_NB_SLOTS BIT(5 )#define ISO15693_REQ_FLAG_OPTION BIT(6 )#define ISO15693_REQ_FLAG_SPEED_MASK \enum trf7970a_state {struct trf7970a {enum trf7970a_state state;struct device *dev;struct spi_device *spi;struct regulator *vin_regulator;struct regulator *vddio_regulator;struct nfc_digital_dev *ddev;bool is_initiator;bool aborting;struct sk_buff *tx_skb;struct sk_buff *rx_skb;void *cb_arg;unsigned int guard_time;int technology;int framing;bool issue_eof;struct gpio_desc *en_gpiod;struct gpio_desc *en2_gpiod;struct mutex lock;unsigned int timeout;bool ignore_timeout;struct delayed_work timeout_work;bool custom_rx_gain_reduction;static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)int ret;"cmd: 0x%x\n" , cmd);1 );if (ret)"%s - cmd: 0x%x, ret: %d\n" , __func__, cmd,return ret;static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)int ret;1 , val, 1 );if (ret)"%s - addr: 0x%x, ret: %d\n" , __func__, addr,"read(0x%x): 0x%x\n" , addr, *val);return ret;static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf,struct spi_transfer t[2 ];struct spi_message m;int ret;"read_cont(0x%x, %zd)\n" , addr, len);0 , sizeof (t));0 ].tx_buf = &addr;0 ].len = sizeof (addr);0 ], &m);1 ].rx_buf = buf;1 ].len = len;1 ], &m);if (ret)"%s - addr: 0x%x, ret: %d\n" , __func__, addr,return ret;static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)2 ] = { reg, val };int ret;"write(0x%x): 0x%x\n" , reg, val);2 );if (ret)"%s - write: 0x%x 0x%x, ret: %d\n" , __func__,0 ], buf[1 ], ret);return ret;static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)int ret;2 ];if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ) {1 , buf, 2 );else {1 , buf, 1 );if (ret)"%s - irqstatus: Status read failed: %d\n" ,else 0 ];return ret;static int trf7970a_update_rx_gain_reduction(struct trf7970a *trf)int ret = 0 ;if (!trf->custom_rx_gain_reduction)return 0 ;if (ret)return ret;return ret;static int trf7970a_update_iso_ctrl_register(struct trf7970a *trf, u8 iso_ctrl)int ret;if (ret)return ret;/* * Every time the ISO_CTRL register is written , the RX special setting register is reset by * the chip . When a custom gain reguduction is required , it should be rewritten now . return ret;static int trf7970a_read_target_proto(struct trf7970a *trf, u8 *target_proto)int ret;2 ];1 , buf, 2 );if (ret)"%s - target_proto: Read failed: %d\n" ,else 0 ];return ret;static int trf7970a_mode_detect(struct trf7970a *trf, u8 *rf_tech)int ret;if (ret)return ret;switch (target_proto) {case TRF79070A_NFC_TARGET_PROTOCOL_106A:break ;case TRF79070A_NFC_TARGET_PROTOCOL_106B:break ;case TRF79070A_NFC_TARGET_PROTOCOL_212F:break ;case TRF79070A_NFC_TARGET_PROTOCOL_424F:break ;default :"%s - mode_detect: target_proto: 0x%x\n" ,return -EIO;return ret;static void trf7970a_send_upstream(struct trf7970a *trf)if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)"trf7970a rx data: " , DUMP_PREFIX_NONE,16 , 1 , trf->rx_skb->data, trf->rx_skb->len,false );if (trf->aborting) {"Abort process complete\n" );if (!IS_ERR(trf->rx_skb)) {false ;static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)"Error - state: %d, errno: %d\n" , trf->state, errno);static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,unsigned int len, const u8 *prefix,unsigned int prefix_len)struct spi_transfer t[2 ];struct spi_message m;unsigned int timeout;int ret;"trf7970a tx data: " , DUMP_PREFIX_NONE,16 , 1 , skb->data, len, false );0 , sizeof (t));0 ].tx_buf = prefix;0 ].len = prefix_len;0 ], &m);1 ].tx_buf = skb->data;1 ].len = len;1 ], &m);if (ret) {"%s - Can't send tx data: %d\n" , __func__,return ret;if (skb->len > 0 ) {else {if (trf->issue_eof) {else {if (!trf->timeout)else "Setting timeout for %d ms, state: %d\n" , timeout,return 0 ;static void trf7970a_fill_fifo(struct trf7970a *trf)struct sk_buff *skb = trf->tx_skb;unsigned int len;int ret;if (ret) {return ;"Filling FIFO - fifo_bytes: 0x%x\n" , fifo_bytes);/* Calculate how much more data can be written to the fifo */ if (!len) {return ;sizeof (prefix));if (ret)static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)struct sk_buff *skb = trf->rx_skb;int ret;if (status & TRF7970A_IRQ_STATUS_ERROR) {return ;if (ret) {return ;"Draining FIFO - fifo_bytes: 0x%x\n" , fifo_bytes);if (!fifo_bytes)goto no_rx_data;if (fifo_bytes > skb_tailroom(skb)) {int , fifo_bytes,if (!skb) {return ;if (ret) {return ;/* If received Type 2 ACK/NACK, shift right 4 bits and pass up */ if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1 ) &&0 ] >>= 4 ;else {if (ret) {return ;/* If there are bytes in the FIFO, set status to '0' so * the if stmt below doesn ' t fire and the driver will wait * for the trf7970a to generate another RX interrupt . if (fifo_bytes)0 ;if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */ return ;"Setting timeout for %d ms\n" ,static irqreturn_t trf7970a_irq(int irq, void *dev_id)struct trf7970a *trf = dev_id;int ret;if (trf->state == TRF7970A_ST_RF_OFF) {return IRQ_NONE;if (ret) {return IRQ_NONE;"IRQ - state: %d, status: 0x%x\n" , trf->state,if (!status) {return IRQ_NONE;switch (trf->state) {case TRF7970A_ST_IDLE:case TRF7970A_ST_IDLE_RX_BLOCKED:/* If initiator and getting interrupts caused by RF noise, * turn off the receiver to avoid unnecessary interrupts . * It will be turned back on in trf7970a_send_cmd ( ) when * the next command is issued . if (trf->is_initiator && (status & TRF7970A_IRQ_STATUS_ERROR)) {break ;case TRF7970A_ST_WAIT_FOR_TX_FIFO:if (status & TRF7970A_IRQ_STATUS_TX) {else {break ;case TRF7970A_ST_WAIT_FOR_RX_DATA:case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:if (status & TRF7970A_IRQ_STATUS_SRX) {else if (status & TRF7970A_IRQ_STATUS_FIFO) {if (ret)else if (!fifo_bytes)else if ((status == TRF7970A_IRQ_STATUS_TX) ||if (!trf->timeout) {0 );break ;if (trf->is_initiator)break ;switch (trf->framing) {case NFC_DIGITAL_FRAMING_NFCA_STANDARD:0 xff; /* Force ISO_CTRL write */ break ;case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:0 xff; /* Force ISO_CTRL write */ break ;case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:if (ret)goto err_unlock_exit;break ;default :break ;if (iso_ctrl != trf->iso_ctrl) {if (ret)goto err_unlock_exit;else {break ;case TRF7970A_ST_WAIT_TO_ISSUE_EOF:if (status != TRF7970A_IRQ_STATUS_TX)break ;case TRF7970A_ST_LISTENING:if (status & TRF7970A_IRQ_STATUS_SRX) {else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {break ;case TRF7970A_ST_LISTENING_MD:if (status & TRF7970A_IRQ_STATUS_SRX) {if (ret) {else {else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {break ;default :"%s - Driver in invalid state: %d\n" ,return IRQ_HANDLED;static void trf7970a_issue_eof(struct trf7970a *trf)int ret;"Issuing EOF\n" );if (ret)if (ret)"Setting timeout for %d ms, state: %d\n" ,static void trf7970a_timeout_work_handler(struct work_struct *work)struct trf7970a *trf = container_of(work, struct trf7970a,"Timeout - state: %d, ignore_timeout: %d\n" ,if (trf->ignore_timeout)false ;else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)else static int trf7970a_init(struct trf7970a *trf)int ret;"Initializing device - state: %d\n" , trf->state);if (ret)goto err_out;/* Set the gain reduction after soft init */ if (ret)goto err_out;if (ret)goto err_out;0 x1));if (ret)goto err_out;0 );if (ret)goto err_out;1000 , 2000 );if (ret)goto err_out;if (ret)goto err_out;0 );if (ret)goto err_out;0 ;0 xff;return 0 ;"Couldn't init device: %d\n" , ret);return ret;static void trf7970a_switch_rf_off(struct trf7970a *trf)if ((trf->state == TRF7970A_ST_PWR_OFF) ||return ;"Switching rf off\n" );false ;static int trf7970a_switch_rf_on(struct trf7970a *trf)int ret;"Switching rf on\n" );if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */ "%s - Incorrect state: %d\n" , __func__,return -EINVAL;if (ret) {"%s - Can't initialize: %d\n" , __func__, ret);return ret;return 0 ;static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);int ret = 0 ;"Switching RF - state: %d, on: %d\n" , trf->state, on);if (on) {switch (trf->state) {case TRF7970A_ST_PWR_OFF:case TRF7970A_ST_RF_OFF:break ;case TRF7970A_ST_IDLE:case TRF7970A_ST_IDLE_RX_BLOCKED:break ;default :"%s - Invalid request: %d %d\n" ,else {switch (trf->state) {case TRF7970A_ST_PWR_OFF:case TRF7970A_ST_RF_OFF:break ;default :"%s - Invalid request: %d %d\n" ,case TRF7970A_ST_IDLE:case TRF7970A_ST_IDLE_RX_BLOCKED:case TRF7970A_ST_WAIT_FOR_RX_DATA:case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:return ret;static int trf7970a_in_config_rf_tech(struct trf7970a *trf, int tech)int ret = 0 ;"rf technology: %d\n" , tech);switch (tech) {case NFC_DIGITAL_RF_TECH_106A:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_106B:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_212F:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_424F:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_ISO15693:0 xf8) |break ;default :"Unsupported rf technology: %d\n" , tech);return -EINVAL;/* If in initiator mode and not changing the RF tech due to a * PSL sequence ( indicated by ' trf - > iso_ctrl = = 0 xff ' from * trf7970a_init ( ) ) , clear the NFC Target Detection Level register * due to erratum . if (trf->iso_ctrl == 0 xff)0 );return ret;static int trf7970a_is_rf_field(struct trf7970a *trf, bool *is_rf_field)int ret;if (ret)return ret;if (ret)return ret;50 , 60 );if (ret)return ret;if (ret)return ret;if (rssi & TRF7970A_RSSI_OSC_STATUS_RSSI_MASK)true ;else false ;return 0 ;static int trf7970a_in_config_framing(struct trf7970a *trf, int framing)bool is_rf_field = false ;int ret;"framing: %d\n" , framing);switch (framing) {case NFC_DIGITAL_FRAMING_NFCA_SHORT:case NFC_DIGITAL_FRAMING_NFCA_STANDARD:break ;case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:case NFC_DIGITAL_FRAMING_NFCA_T4T:case NFC_DIGITAL_FRAMING_NFCB:case NFC_DIGITAL_FRAMING_NFCB_T4T:case NFC_DIGITAL_FRAMING_NFCF:case NFC_DIGITAL_FRAMING_NFCF_T3T:case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:case NFC_DIGITAL_FRAMING_ISO15693_T5T:case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:break ;case NFC_DIGITAL_FRAMING_NFCA_T2T:break ;default :"Unsupported Framing: %d\n" , framing);return -EINVAL;if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {if (ret)return ret;if (is_rf_field)return -EBUSY;if (iso_ctrl != trf->iso_ctrl) {if (ret)return ret;if (ret)return ret;if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {if (ret)return ret;1000 );return 0 ;static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,int param)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);int ret;"Configure hw - type: %d, param: %d\n" , type, param);true ;if ((trf->state == TRF7970A_ST_PWR_OFF) ||if (ret)goto err_unlock;switch (type) {case NFC_DIGITAL_CONFIG_RF_TECH:break ;case NFC_DIGITAL_CONFIG_FRAMING:break ;default :"Unknown type: %d\n" , type);return ret;static int trf7970a_is_iso15693_write_or_lock(u8 cmd)switch (cmd) {case ISO15693_CMD_WRITE_SINGLE_BLOCK:case ISO15693_CMD_LOCK_BLOCK:case ISO15693_CMD_WRITE_MULTIPLE_BLOCK:case ISO15693_CMD_WRITE_AFI:case ISO15693_CMD_LOCK_AFI:case ISO15693_CMD_WRITE_DSFID:case ISO15693_CMD_LOCK_DSFID:return 1 ;default :return 0 ;static int trf7970a_per_cmd_config(struct trf7970a *trf,const struct sk_buff *skb)const u8 *req = skb->data;int ret;false ;/* When issuing Type 2 read command, make sure the '4_bit_RX' bit in * special functions register 1 is cleared ; otherwise , its a write or * sector select command and ' 4 _ bit_RX ' must be set . * * When issuing an ISO 15693 command , inspect the flags byte to see * what speed to use . Also , remember if the OPTION flag is set on * a Type 5 write or lock command so the driver will know that it * has to send an EOF in order to get a response . if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&if (req[0 ] == NFC_T2T_CMD_READ)0 ;else if (special_fcn_reg1 != trf->special_fcn_reg1) {if (ret)return ret;else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {switch (req[0 ] & ISO15693_REQ_FLAG_SPEED_MASK) {case 0 x00:break ;case ISO15693_REQ_FLAG_SUB_CARRIER:break ;case ISO15693_REQ_FLAG_DATA_RATE:break ;case (ISO15693_REQ_FLAG_SUB_CARRIER |break ;if (iso_ctrl != trf->iso_ctrl) {if (ret)return ret;if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&1 ]) &&0 ] & ISO15693_REQ_FLAG_OPTION))true ;return 0 ;static int trf7970a_send_cmd(struct nfc_digital_dev *ddev,struct sk_buff *skb, u16 timeout,void *arg)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);5 ];unsigned int len;int ret;"New request - state: %d, timeout: %d ms, len: %d\n" ,if (skb->len > TRF7970A_TX_MAX)return -EINVAL;if ((trf->state != TRF7970A_ST_IDLE) &&"%s - Bogus state: %d\n" , __func__,goto out_err;if (trf->aborting) {"Abort process complete\n" );false ;goto out_err;if (timeout) {if (!trf->rx_skb) {"Can't alloc rx_skb\n" );goto out_err;if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {if (ret)goto out_err;if (trf->is_initiator) {if (ret)goto out_err;false ;/* TX data must be prefixed with a FIFO reset cmd, a cmd that depends * on what the current framing is , the address of the TX length byte 1 * register ( 0 x1d ) , and the 2 byte length of the data to be transmitted . * That totals 5 bytes . 0 ] = TRF7970A_CMD_BIT_CTRL |1 ] = TRF7970A_CMD_BIT_CTRL |2 ] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1;if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {3 ] = 0 x00;4 ] = 0 x0f; /* 7 bits */ else {3 ] = (len & 0 xf00) >> 4 ;3 ] |= ((len & 0 xf0) >> 4 );4 ] = ((len & 0 x0f) << 4 );int , skb->len, TRF7970A_FIFO_SIZE);/* Clear possible spurious interrupt */ if (ret)goto out_err;sizeof (prefix));if (ret) {return ret;static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)int ret = 0 ;"rf technology: %d\n" , tech);switch (tech) {case NFC_DIGITAL_RF_TECH_106A:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_212F:0 xf8) |break ;case NFC_DIGITAL_RF_TECH_424F:0 xf8) |break ;default :"Unsupported rf technology: %d\n" , tech);return -EINVAL;/* Normally we write the ISO_CTRL register in * trf7970a_tg_config_framing ( ) because the framing can change * the value written . However , when sending a PSL RES , * digital_tg_send_psl_res_complete ( ) doesn ' t call * trf7970a_tg_config_framing ( ) so we must write the register * here . if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&return ret;/* Since this is a target routine, several of the framing calls are * made between receiving the request and sending the response so they * should take effect until after the response is sent . This is accomplished * by skipping the ISO_CTRL register write here and doing it in the interrupt * handler . static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)int ret;"framing: %d\n" , framing);switch (framing) {case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:break ;case NFC_DIGITAL_FRAMING_NFCA_STANDARD:case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:/* These ones are applied in the interrupt handler */ /* Don't write to ISO_CTRL yet */ break ;case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:break ;case NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED:break ;default :"Unsupported Framing: %d\n" , framing);return -EINVAL;if (iso_ctrl != trf->iso_ctrl) {if (ret)return ret;if (ret)return ret;if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {if (ret)return ret;return 0 ;static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, int type,int param)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);int ret;"Configure hw - type: %d, param: %d\n" , type, param);false ;if ((trf->state == TRF7970A_ST_PWR_OFF) ||if (ret)goto err_unlock;switch (type) {case NFC_DIGITAL_CONFIG_RF_TECH:break ;case NFC_DIGITAL_CONFIG_FRAMING:break ;default :"Unknown type: %d\n" , type);return ret;static int _trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,void *arg,bool mode_detect)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);int ret;if ((trf->state != TRF7970A_ST_IDLE) &&"%s - Bogus state: %d\n" , __func__,goto out_err;if (trf->aborting) {"Abort process complete\n" );false ;goto out_err;if (!trf->rx_skb) {"Can't alloc rx_skb\n" );goto out_err;if (ret)goto out_err;if (ret)goto out_err;0 x1));if (ret)goto out_err;0 x3));if (ret)goto out_err;0 x7));if (ret)goto out_err;false ;if (ret)goto out_err;return ret;static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,void *arg)const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);"Listen - state: %d, timeout: %d ms\n" ,return _trf7970a_tg_listen(ddev, timeout, cb, arg, false );static int trf7970a_tg_listen_md(struct nfc_digital_dev *ddev,void *arg)const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);int ret;"Listen MD - state: %d, timeout: %d ms\n" ,if (ret)return ret;if (ret)return ret;return _trf7970a_tg_listen(ddev, timeout, cb, arg, true );static int trf7970a_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);"Get RF Tech - state: %d, rf_tech: %d\n" ,return 0 ;static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)struct trf7970a *trf = nfc_digital_get_drvdata(ddev);"Abort process initiated\n" );switch (trf->state) {case TRF7970A_ST_WAIT_FOR_TX_FIFO:case TRF7970A_ST_WAIT_FOR_RX_DATA:case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:case TRF7970A_ST_WAIT_TO_ISSUE_EOF:true ;break ;case TRF7970A_ST_LISTENING:"Abort process complete\n" );break ;default :break ;static const struct nfc_digital_ops trf7970a_nfc_ops = {static int trf7970a_power_up(struct trf7970a *trf)int ret;"Powering up - state: %d\n" , trf->state);if (trf->state != TRF7970A_ST_PWR_OFF)return 0 ;if (ret) {"%s - Can't enable VIN: %d\n" , __func__, ret);return ret;5000 , 6000 );if (trf->en2_gpiod &&1 );1000 , 2000 );1 );20000 , 21000 );return 0 ;static int trf7970a_power_down(struct trf7970a *trf)int ret;"Powering down - state: %d\n" , trf->state);if (trf->state == TRF7970A_ST_PWR_OFF)return 0 ;if (trf->state != TRF7970A_ST_RF_OFF) {"Can't power down - not RF_OFF state (%d)\n" ,return -EBUSY;0 );if (trf->en2_gpiod && !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW))0 );if (ret)"%s - Can't disable VIN: %d\n" , __func__,return ret;static int trf7970a_startup(struct trf7970a *trf)int ret;if (ret)return ret;if (ret)return ret;return 0 ;static void trf7970a_shutdown(struct trf7970a *trf)switch (trf->state) {case TRF7970A_ST_WAIT_FOR_TX_FIFO:case TRF7970A_ST_WAIT_FOR_RX_DATA:case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:case TRF7970A_ST_WAIT_TO_ISSUE_EOF:case TRF7970A_ST_LISTENING:case TRF7970A_ST_IDLE:case TRF7970A_ST_IDLE_RX_BLOCKED:break ;default :break ;static int trf7970a_get_autosuspend_delay(const struct device_node *np)int autosuspend_delay, ret;"autosuspend-delay" , &autosuspend_delay);if (ret)return autosuspend_delay;static int trf7970a_probe(struct spi_device *spi)const struct device_node *np = spi->dev.of_node;struct trf7970a *trf;int uvolts, autosuspend_delay, ret;if (!np) {"No Device Tree entry\n" );return -EINVAL;sizeof (*trf), GFP_KERNEL);if (!trf)return -ENOMEM;8 ;if (ret < 0 ) {"Can't set up SPI Communication\n" );return ret;if (of_property_read_bool(np, "irq-status-read-quirk" ))/* There are two enable pins - only EN must be present in the DT */ "ti,enable" , 0 ,if (IS_ERR(trf->en_gpiod)) {"No EN GPIO property\n" );return PTR_ERR(trf->en_gpiod);"ti,enable" , 1 ,if (!trf->en2_gpiod) {"No EN2 GPIO property\n" );else if (IS_ERR(trf->en2_gpiod)) {"Error getting EN2 GPIO property: %ld\n" ,return PTR_ERR(trf->en2_gpiod);else if (of_property_read_bool(np, "en2-rf-quirk" )) {"clock-frequency" , &clk_freq);if ((clk_freq != TRF7970A_27MHZ_CLOCK_FREQUENCY) &&"clock-frequency (%u Hz) unsupported\n" , clk_freq);return -EINVAL;if (clk_freq == TRF7970A_27MHZ_CLOCK_FREQUENCY) {"trf7970a configured for 27MHz crystal\n" );else {0 ;if (of_property_read_u32(np, "ti,rx-gain-reduction-db" , &rx_gain_reduction_db) == 0 ) {if (rx_gain_reduction_db > TRF7970A_RX_GAIN_REDUCTION_MAX_DB) {"RX Gain reduction too high. Ignored\n" );else if ((rx_gain_reduction_db % TRF7970A_RX_GAIN_REDUCTION_DB_PER_LSB)) {"RX Gain must be set in 5 dB increments. Ignored\n" );else {"RX gain set to -%udB\n" , rx_gain_reduction_db);true ;"trf7970a" , trf);if (ret) {"Can't request IRQ#%d: %d\n" , spi->irq, ret);return ret;"vin" );if (IS_ERR(trf->vin_regulator)) {"Can't get VIN regulator: %d\n" , ret);goto err_destroy_lock;if (ret) {"Can't enable VIN: %d\n" , ret);goto err_destroy_lock;if (uvolts > 4000000 )"vdd-io" );if (IS_ERR(trf->vddio_regulator)) {"Can't get VDD_IO regulator: %d\n" , ret);goto err_disable_vin_regulator;if (ret) {"Can't enable VDD_IO: %d\n" , ret);goto err_disable_vin_regulator;if (regulator_get_voltage(trf->vddio_regulator) == 1800000 ) {"trf7970a config vdd_io to 1.8V\n" );0 ,0 );if (!trf->ddev) {"Can't allocate NFC digital device\n" );goto err_disable_vddio_regulator;if (ret)goto err_free_ddev;if (ret) {"Can't register NFC digital device: %d\n" ,goto err_shutdown;return 0 ;return ret;static void trf7970a_remove(struct spi_device *spi)struct trf7970a *trf = spi_get_drvdata(spi);#ifdef CONFIG_PM_SLEEPstatic int trf7970a_suspend(struct device *dev)struct spi_device *spi = to_spi_device(dev);struct trf7970a *trf = spi_get_drvdata(spi);return 0 ;static int trf7970a_resume(struct device *dev)struct spi_device *spi = to_spi_device(dev);struct trf7970a *trf = spi_get_drvdata(spi);int ret;return ret;#endif #ifdef CONFIG_PMstatic int trf7970a_pm_runtime_suspend(struct device *dev)struct spi_device *spi = to_spi_device(dev);struct trf7970a *trf = spi_get_drvdata(spi);int ret;return ret;static int trf7970a_pm_runtime_resume(struct device *dev)struct spi_device *spi = to_spi_device(dev);struct trf7970a *trf = spi_get_drvdata(spi);int ret;if (!ret)return ret;#endif static const struct dev_pm_ops trf7970a_pm_ops = {static const struct of_device_id trf7970a_of_match[] __maybe_unused = {"ti,trf7970a" ,},static const struct spi_device_id trf7970a_id_table[] = {"trf7970a" , 0 },static struct spi_driver trf7970a_spi_driver = {"trf7970a" ,"Mark A. Greer <mgreer@animalcreek.com>" );"GPL v2" );"TI trf7970a RFID/NFC Transceiver Driver" );
Messung V0.5 in Prozent C=99 H=92 G=95
¤ Dauer der Verarbeitung: 0.36 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
2026-10-10
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=1126864 #Domains=1897691
