Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Sony NFC Port-100 Series driver
0004  * Copyright (c) 2013, Intel Corporation.
0005  *
0006  * Partly based/Inspired by Stephen Tiedemann's nfcpy
0007  */
0008 
0009 #include <linux/module.h>
0010 #include <linux/usb.h>
0011 #include <net/nfc/digital.h>
0012 
0013 #define VERSION "0.1"
0014 
0015 #define SONY_VENDOR_ID      0x054c
0016 #define RCS380S_PRODUCT_ID  0x06c1
0017 #define RCS380P_PRODUCT_ID  0x06c3
0018 
0019 #define PORT100_PROTOCOLS (NFC_PROTO_JEWEL_MASK    | \
0020                NFC_PROTO_MIFARE_MASK   | \
0021                NFC_PROTO_FELICA_MASK   | \
0022                NFC_PROTO_NFC_DEP_MASK  | \
0023                NFC_PROTO_ISO14443_MASK | \
0024                NFC_PROTO_ISO14443_B_MASK)
0025 
0026 #define PORT100_CAPABILITIES (NFC_DIGITAL_DRV_CAPS_IN_CRC | \
0027                   NFC_DIGITAL_DRV_CAPS_TG_CRC)
0028 
0029 /* Standard port100 frame definitions */
0030 #define PORT100_FRAME_HEADER_LEN (sizeof(struct port100_frame) \
0031                   + 2) /* data[0] CC, data[1] SCC */
0032 #define PORT100_FRAME_TAIL_LEN 2 /* data[len] DCS, data[len + 1] postamble*/
0033 
0034 #define PORT100_COMM_RF_HEAD_MAX_LEN (sizeof(struct port100_tg_comm_rf_cmd))
0035 
0036 /*
0037  * Max extended frame payload len, excluding CC and SCC
0038  * which are already in PORT100_FRAME_HEADER_LEN.
0039  */
0040 #define PORT100_FRAME_MAX_PAYLOAD_LEN 1001
0041 
0042 #define PORT100_FRAME_ACK_SIZE 6 /* Preamble (1), SoPC (2), ACK Code (2),
0043                     Postamble (1) */
0044 static u8 ack_frame[PORT100_FRAME_ACK_SIZE] = {
0045     0x00, 0x00, 0xff, 0x00, 0xff, 0x00
0046 };
0047 
0048 #define PORT100_FRAME_CHECKSUM(f) (f->data[le16_to_cpu(f->datalen)])
0049 #define PORT100_FRAME_POSTAMBLE(f) (f->data[le16_to_cpu(f->datalen) + 1])
0050 
0051 /* start of frame */
0052 #define PORT100_FRAME_SOF   0x00FF
0053 #define PORT100_FRAME_EXT   0xFFFF
0054 #define PORT100_FRAME_ACK   0x00FF
0055 
0056 /* Port-100 command: in or out */
0057 #define PORT100_FRAME_DIRECTION(f) (f->data[0]) /* CC */
0058 #define PORT100_FRAME_DIR_OUT 0xD6
0059 #define PORT100_FRAME_DIR_IN  0xD7
0060 
0061 /* Port-100 sub-command */
0062 #define PORT100_FRAME_CMD(f) (f->data[1]) /* SCC */
0063 
0064 #define PORT100_CMD_GET_FIRMWARE_VERSION 0x20
0065 #define PORT100_CMD_GET_COMMAND_TYPE     0x28
0066 #define PORT100_CMD_SET_COMMAND_TYPE     0x2A
0067 
0068 #define PORT100_CMD_IN_SET_RF       0x00
0069 #define PORT100_CMD_IN_SET_PROTOCOL 0x02
0070 #define PORT100_CMD_IN_COMM_RF      0x04
0071 
0072 #define PORT100_CMD_TG_SET_RF       0x40
0073 #define PORT100_CMD_TG_SET_PROTOCOL 0x42
0074 #define PORT100_CMD_TG_SET_RF_OFF   0x46
0075 #define PORT100_CMD_TG_COMM_RF      0x48
0076 
0077 #define PORT100_CMD_SWITCH_RF       0x06
0078 
0079 #define PORT100_CMD_RESPONSE(cmd) (cmd + 1)
0080 
0081 #define PORT100_CMD_TYPE_IS_SUPPORTED(mask, cmd_type) \
0082     ((mask) & (0x01 << (cmd_type)))
0083 #define PORT100_CMD_TYPE_0  0
0084 #define PORT100_CMD_TYPE_1  1
0085 
0086 #define PORT100_CMD_STATUS_OK      0x00
0087 #define PORT100_CMD_STATUS_TIMEOUT 0x80
0088 
0089 #define PORT100_MDAA_TGT_HAS_BEEN_ACTIVATED_MASK 0x01
0090 #define PORT100_MDAA_TGT_WAS_ACTIVATED_MASK      0x02
0091 
0092 struct port100;
0093 
0094 typedef void (*port100_send_async_complete_t)(struct port100 *dev, void *arg,
0095                           struct sk_buff *resp);
0096 
0097 /*
0098  * Setting sets structure for in_set_rf command
0099  *
0100  * @in_*_set_number: Represent the entry indexes in the port-100 RF Base Table.
0101  *              This table contains multiple RF setting sets required for RF
0102  *              communication.
0103  *
0104  * @in_*_comm_type: Theses fields set the communication type to be used.
0105  */
0106 struct port100_in_rf_setting {
0107     u8 in_send_set_number;
0108     u8 in_send_comm_type;
0109     u8 in_recv_set_number;
0110     u8 in_recv_comm_type;
0111 } __packed;
0112 
0113 #define PORT100_COMM_TYPE_IN_212F 0x01
0114 #define PORT100_COMM_TYPE_IN_424F 0x02
0115 #define PORT100_COMM_TYPE_IN_106A 0x03
0116 #define PORT100_COMM_TYPE_IN_106B 0x07
0117 
0118 static const struct port100_in_rf_setting in_rf_settings[] = {
0119     [NFC_DIGITAL_RF_TECH_212F] = {
0120         .in_send_set_number = 1,
0121         .in_send_comm_type  = PORT100_COMM_TYPE_IN_212F,
0122         .in_recv_set_number = 15,
0123         .in_recv_comm_type  = PORT100_COMM_TYPE_IN_212F,
0124     },
0125     [NFC_DIGITAL_RF_TECH_424F] = {
0126         .in_send_set_number = 1,
0127         .in_send_comm_type  = PORT100_COMM_TYPE_IN_424F,
0128         .in_recv_set_number = 15,
0129         .in_recv_comm_type  = PORT100_COMM_TYPE_IN_424F,
0130     },
0131     [NFC_DIGITAL_RF_TECH_106A] = {
0132         .in_send_set_number = 2,
0133         .in_send_comm_type  = PORT100_COMM_TYPE_IN_106A,
0134         .in_recv_set_number = 15,
0135         .in_recv_comm_type  = PORT100_COMM_TYPE_IN_106A,
0136     },
0137     [NFC_DIGITAL_RF_TECH_106B] = {
0138         .in_send_set_number = 3,
0139         .in_send_comm_type  = PORT100_COMM_TYPE_IN_106B,
0140         .in_recv_set_number = 15,
0141         .in_recv_comm_type  = PORT100_COMM_TYPE_IN_106B,
0142     },
0143     /* Ensures the array has NFC_DIGITAL_RF_TECH_LAST elements */
0144     [NFC_DIGITAL_RF_TECH_LAST] = { 0 },
0145 };
0146 
0147 /**
0148  * struct port100_tg_rf_setting - Setting sets structure for tg_set_rf command
0149  *
0150  * @tg_set_number: Represents the entry index in the port-100 RF Base Table.
0151  *                 This table contains multiple RF setting sets required for RF
0152  *                 communication. this field is used for both send and receive
0153  *                 settings.
0154  *
0155  * @tg_comm_type: Sets the communication type to be used to send and receive
0156  *                data.
0157  */
0158 struct port100_tg_rf_setting {
0159     u8 tg_set_number;
0160     u8 tg_comm_type;
0161 } __packed;
0162 
0163 #define PORT100_COMM_TYPE_TG_106A 0x0B
0164 #define PORT100_COMM_TYPE_TG_212F 0x0C
0165 #define PORT100_COMM_TYPE_TG_424F 0x0D
0166 
0167 static const struct port100_tg_rf_setting tg_rf_settings[] = {
0168     [NFC_DIGITAL_RF_TECH_106A] = {
0169         .tg_set_number = 8,
0170         .tg_comm_type = PORT100_COMM_TYPE_TG_106A,
0171     },
0172     [NFC_DIGITAL_RF_TECH_212F] = {
0173         .tg_set_number = 8,
0174         .tg_comm_type = PORT100_COMM_TYPE_TG_212F,
0175     },
0176     [NFC_DIGITAL_RF_TECH_424F] = {
0177         .tg_set_number = 8,
0178         .tg_comm_type = PORT100_COMM_TYPE_TG_424F,
0179     },
0180     /* Ensures the array has NFC_DIGITAL_RF_TECH_LAST elements */
0181     [NFC_DIGITAL_RF_TECH_LAST] = { 0 },
0182 
0183 };
0184 
0185 #define PORT100_IN_PROT_INITIAL_GUARD_TIME      0x00
0186 #define PORT100_IN_PROT_ADD_CRC                 0x01
0187 #define PORT100_IN_PROT_CHECK_CRC               0x02
0188 #define PORT100_IN_PROT_MULTI_CARD              0x03
0189 #define PORT100_IN_PROT_ADD_PARITY              0x04
0190 #define PORT100_IN_PROT_CHECK_PARITY            0x05
0191 #define PORT100_IN_PROT_BITWISE_AC_RECV_MODE    0x06
0192 #define PORT100_IN_PROT_VALID_BIT_NUMBER        0x07
0193 #define PORT100_IN_PROT_CRYPTO1                 0x08
0194 #define PORT100_IN_PROT_ADD_SOF                 0x09
0195 #define PORT100_IN_PROT_CHECK_SOF               0x0A
0196 #define PORT100_IN_PROT_ADD_EOF                 0x0B
0197 #define PORT100_IN_PROT_CHECK_EOF               0x0C
0198 #define PORT100_IN_PROT_DEAF_TIME               0x0E
0199 #define PORT100_IN_PROT_CRM                     0x0F
0200 #define PORT100_IN_PROT_CRM_MIN_LEN             0x10
0201 #define PORT100_IN_PROT_T1_TAG_FRAME            0x11
0202 #define PORT100_IN_PROT_RFCA                    0x12
0203 #define PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR 0x13
0204 #define PORT100_IN_PROT_END                     0x14
0205 
0206 #define PORT100_IN_MAX_NUM_PROTOCOLS            19
0207 
0208 #define PORT100_TG_PROT_TU           0x00
0209 #define PORT100_TG_PROT_RF_OFF       0x01
0210 #define PORT100_TG_PROT_CRM          0x02
0211 #define PORT100_TG_PROT_END          0x03
0212 
0213 #define PORT100_TG_MAX_NUM_PROTOCOLS 3
0214 
0215 struct port100_protocol {
0216     u8 number;
0217     u8 value;
0218 } __packed;
0219 
0220 static const struct port100_protocol
0221 in_protocols[][PORT100_IN_MAX_NUM_PROTOCOLS + 1] = {
0222     [NFC_DIGITAL_FRAMING_NFCA_SHORT] = {
0223         { PORT100_IN_PROT_INITIAL_GUARD_TIME,      6 },
0224         { PORT100_IN_PROT_ADD_CRC,                 0 },
0225         { PORT100_IN_PROT_CHECK_CRC,               0 },
0226         { PORT100_IN_PROT_MULTI_CARD,              0 },
0227         { PORT100_IN_PROT_ADD_PARITY,              0 },
0228         { PORT100_IN_PROT_CHECK_PARITY,            1 },
0229         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0230         { PORT100_IN_PROT_VALID_BIT_NUMBER,        7 },
0231         { PORT100_IN_PROT_CRYPTO1,                 0 },
0232         { PORT100_IN_PROT_ADD_SOF,                 0 },
0233         { PORT100_IN_PROT_CHECK_SOF,               0 },
0234         { PORT100_IN_PROT_ADD_EOF,                 0 },
0235         { PORT100_IN_PROT_CHECK_EOF,               0 },
0236         { PORT100_IN_PROT_DEAF_TIME,               4 },
0237         { PORT100_IN_PROT_CRM,                     0 },
0238         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0239         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0240         { PORT100_IN_PROT_RFCA,                    0 },
0241         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0242         { PORT100_IN_PROT_END,                     0 },
0243     },
0244     [NFC_DIGITAL_FRAMING_NFCA_STANDARD] = {
0245         { PORT100_IN_PROT_INITIAL_GUARD_TIME,      6 },
0246         { PORT100_IN_PROT_ADD_CRC,                 0 },
0247         { PORT100_IN_PROT_CHECK_CRC,               0 },
0248         { PORT100_IN_PROT_MULTI_CARD,              0 },
0249         { PORT100_IN_PROT_ADD_PARITY,              1 },
0250         { PORT100_IN_PROT_CHECK_PARITY,            1 },
0251         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0252         { PORT100_IN_PROT_VALID_BIT_NUMBER,        8 },
0253         { PORT100_IN_PROT_CRYPTO1,                 0 },
0254         { PORT100_IN_PROT_ADD_SOF,                 0 },
0255         { PORT100_IN_PROT_CHECK_SOF,               0 },
0256         { PORT100_IN_PROT_ADD_EOF,                 0 },
0257         { PORT100_IN_PROT_CHECK_EOF,               0 },
0258         { PORT100_IN_PROT_DEAF_TIME,               4 },
0259         { PORT100_IN_PROT_CRM,                     0 },
0260         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0261         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0262         { PORT100_IN_PROT_RFCA,                    0 },
0263         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0264         { PORT100_IN_PROT_END,                     0 },
0265     },
0266     [NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A] = {
0267         { PORT100_IN_PROT_INITIAL_GUARD_TIME,      6 },
0268         { PORT100_IN_PROT_ADD_CRC,                 1 },
0269         { PORT100_IN_PROT_CHECK_CRC,               1 },
0270         { PORT100_IN_PROT_MULTI_CARD,              0 },
0271         { PORT100_IN_PROT_ADD_PARITY,              1 },
0272         { PORT100_IN_PROT_CHECK_PARITY,            1 },
0273         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0274         { PORT100_IN_PROT_VALID_BIT_NUMBER,        8 },
0275         { PORT100_IN_PROT_CRYPTO1,                 0 },
0276         { PORT100_IN_PROT_ADD_SOF,                 0 },
0277         { PORT100_IN_PROT_CHECK_SOF,               0 },
0278         { PORT100_IN_PROT_ADD_EOF,                 0 },
0279         { PORT100_IN_PROT_CHECK_EOF,               0 },
0280         { PORT100_IN_PROT_DEAF_TIME,               4 },
0281         { PORT100_IN_PROT_CRM,                     0 },
0282         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0283         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0284         { PORT100_IN_PROT_RFCA,                    0 },
0285         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0286         { PORT100_IN_PROT_END,                     0 },
0287     },
0288     [NFC_DIGITAL_FRAMING_NFCA_T1T] = {
0289         /* nfc_digital_framing_nfca_short */
0290         { PORT100_IN_PROT_ADD_CRC,          2 },
0291         { PORT100_IN_PROT_CHECK_CRC,        2 },
0292         { PORT100_IN_PROT_VALID_BIT_NUMBER, 8 },
0293         { PORT100_IN_PROT_T1_TAG_FRAME,     2 },
0294         { PORT100_IN_PROT_END,              0 },
0295     },
0296     [NFC_DIGITAL_FRAMING_NFCA_T2T] = {
0297         /* nfc_digital_framing_nfca_standard */
0298         { PORT100_IN_PROT_ADD_CRC,   1 },
0299         { PORT100_IN_PROT_CHECK_CRC, 0 },
0300         { PORT100_IN_PROT_END,       0 },
0301     },
0302     [NFC_DIGITAL_FRAMING_NFCA_T4T] = {
0303         /* nfc_digital_framing_nfca_standard_with_crc_a */
0304         { PORT100_IN_PROT_END,       0 },
0305     },
0306     [NFC_DIGITAL_FRAMING_NFCA_NFC_DEP] = {
0307         /* nfc_digital_framing_nfca_standard */
0308         { PORT100_IN_PROT_END, 0 },
0309     },
0310     [NFC_DIGITAL_FRAMING_NFCF] = {
0311         { PORT100_IN_PROT_INITIAL_GUARD_TIME,     18 },
0312         { PORT100_IN_PROT_ADD_CRC,                 1 },
0313         { PORT100_IN_PROT_CHECK_CRC,               1 },
0314         { PORT100_IN_PROT_MULTI_CARD,              0 },
0315         { PORT100_IN_PROT_ADD_PARITY,              0 },
0316         { PORT100_IN_PROT_CHECK_PARITY,            0 },
0317         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0318         { PORT100_IN_PROT_VALID_BIT_NUMBER,        8 },
0319         { PORT100_IN_PROT_CRYPTO1,                 0 },
0320         { PORT100_IN_PROT_ADD_SOF,                 0 },
0321         { PORT100_IN_PROT_CHECK_SOF,               0 },
0322         { PORT100_IN_PROT_ADD_EOF,                 0 },
0323         { PORT100_IN_PROT_CHECK_EOF,               0 },
0324         { PORT100_IN_PROT_DEAF_TIME,               4 },
0325         { PORT100_IN_PROT_CRM,                     0 },
0326         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0327         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0328         { PORT100_IN_PROT_RFCA,                    0 },
0329         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0330         { PORT100_IN_PROT_END,                     0 },
0331     },
0332     [NFC_DIGITAL_FRAMING_NFCF_T3T] = {
0333         /* nfc_digital_framing_nfcf */
0334         { PORT100_IN_PROT_END, 0 },
0335     },
0336     [NFC_DIGITAL_FRAMING_NFCF_NFC_DEP] = {
0337         /* nfc_digital_framing_nfcf */
0338         { PORT100_IN_PROT_INITIAL_GUARD_TIME,     18 },
0339         { PORT100_IN_PROT_ADD_CRC,                 1 },
0340         { PORT100_IN_PROT_CHECK_CRC,               1 },
0341         { PORT100_IN_PROT_MULTI_CARD,              0 },
0342         { PORT100_IN_PROT_ADD_PARITY,              0 },
0343         { PORT100_IN_PROT_CHECK_PARITY,            0 },
0344         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0345         { PORT100_IN_PROT_VALID_BIT_NUMBER,        8 },
0346         { PORT100_IN_PROT_CRYPTO1,                 0 },
0347         { PORT100_IN_PROT_ADD_SOF,                 0 },
0348         { PORT100_IN_PROT_CHECK_SOF,               0 },
0349         { PORT100_IN_PROT_ADD_EOF,                 0 },
0350         { PORT100_IN_PROT_CHECK_EOF,               0 },
0351         { PORT100_IN_PROT_DEAF_TIME,               4 },
0352         { PORT100_IN_PROT_CRM,                     0 },
0353         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0354         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0355         { PORT100_IN_PROT_RFCA,                    0 },
0356         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0357         { PORT100_IN_PROT_END,                     0 },
0358     },
0359     [NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED] = {
0360         { PORT100_IN_PROT_END, 0 },
0361     },
0362     [NFC_DIGITAL_FRAMING_NFCB] = {
0363         { PORT100_IN_PROT_INITIAL_GUARD_TIME,     20 },
0364         { PORT100_IN_PROT_ADD_CRC,                 1 },
0365         { PORT100_IN_PROT_CHECK_CRC,               1 },
0366         { PORT100_IN_PROT_MULTI_CARD,              0 },
0367         { PORT100_IN_PROT_ADD_PARITY,              0 },
0368         { PORT100_IN_PROT_CHECK_PARITY,            0 },
0369         { PORT100_IN_PROT_BITWISE_AC_RECV_MODE,    0 },
0370         { PORT100_IN_PROT_VALID_BIT_NUMBER,        8 },
0371         { PORT100_IN_PROT_CRYPTO1,                 0 },
0372         { PORT100_IN_PROT_ADD_SOF,                 1 },
0373         { PORT100_IN_PROT_CHECK_SOF,               1 },
0374         { PORT100_IN_PROT_ADD_EOF,                 1 },
0375         { PORT100_IN_PROT_CHECK_EOF,               1 },
0376         { PORT100_IN_PROT_DEAF_TIME,               4 },
0377         { PORT100_IN_PROT_CRM,                     0 },
0378         { PORT100_IN_PROT_CRM_MIN_LEN,             0 },
0379         { PORT100_IN_PROT_T1_TAG_FRAME,            0 },
0380         { PORT100_IN_PROT_RFCA,                    0 },
0381         { PORT100_IN_PROT_GUARD_TIME_AT_INITIATOR, 6 },
0382         { PORT100_IN_PROT_END,                     0 },
0383     },
0384     [NFC_DIGITAL_FRAMING_NFCB_T4T] = {
0385         /* nfc_digital_framing_nfcb */
0386         { PORT100_IN_PROT_END,                     0 },
0387     },
0388     /* Ensures the array has NFC_DIGITAL_FRAMING_LAST elements */
0389     [NFC_DIGITAL_FRAMING_LAST] = {
0390         { PORT100_IN_PROT_END, 0 },
0391     },
0392 };
0393 
0394 static const struct port100_protocol
0395 tg_protocols[][PORT100_TG_MAX_NUM_PROTOCOLS + 1] = {
0396     [NFC_DIGITAL_FRAMING_NFCA_SHORT] = {
0397         { PORT100_TG_PROT_END, 0 },
0398     },
0399     [NFC_DIGITAL_FRAMING_NFCA_STANDARD] = {
0400         { PORT100_TG_PROT_END, 0 },
0401     },
0402     [NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A] = {
0403         { PORT100_TG_PROT_END, 0 },
0404     },
0405     [NFC_DIGITAL_FRAMING_NFCA_T1T] = {
0406         { PORT100_TG_PROT_END, 0 },
0407     },
0408     [NFC_DIGITAL_FRAMING_NFCA_T2T] = {
0409         { PORT100_TG_PROT_END, 0 },
0410     },
0411     [NFC_DIGITAL_FRAMING_NFCA_NFC_DEP] = {
0412         { PORT100_TG_PROT_TU,     1 },
0413         { PORT100_TG_PROT_RF_OFF, 0 },
0414         { PORT100_TG_PROT_CRM,    7 },
0415         { PORT100_TG_PROT_END,    0 },
0416     },
0417     [NFC_DIGITAL_FRAMING_NFCF] = {
0418         { PORT100_TG_PROT_END, 0 },
0419     },
0420     [NFC_DIGITAL_FRAMING_NFCF_T3T] = {
0421         { PORT100_TG_PROT_END, 0 },
0422     },
0423     [NFC_DIGITAL_FRAMING_NFCF_NFC_DEP] = {
0424         { PORT100_TG_PROT_TU,     1 },
0425         { PORT100_TG_PROT_RF_OFF, 0 },
0426         { PORT100_TG_PROT_CRM,    7 },
0427         { PORT100_TG_PROT_END,    0 },
0428     },
0429     [NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED] = {
0430         { PORT100_TG_PROT_RF_OFF, 1 },
0431         { PORT100_TG_PROT_END,    0 },
0432     },
0433     /* Ensures the array has NFC_DIGITAL_FRAMING_LAST elements */
0434     [NFC_DIGITAL_FRAMING_LAST] = {
0435         { PORT100_TG_PROT_END,    0 },
0436     },
0437 };
0438 
0439 struct port100 {
0440     struct nfc_digital_dev *nfc_digital_dev;
0441 
0442     int skb_headroom;
0443     int skb_tailroom;
0444 
0445     struct usb_device *udev;
0446     struct usb_interface *interface;
0447 
0448     struct urb *out_urb;
0449     struct urb *in_urb;
0450 
0451     /* This mutex protects the out_urb and avoids to submit a new command
0452      * through port100_send_frame_async() while the previous one is being
0453      * canceled through port100_abort_cmd().
0454      */
0455     struct mutex out_urb_lock;
0456 
0457     struct work_struct cmd_complete_work;
0458 
0459     u8 cmd_type;
0460 
0461     /* The digital stack serializes commands to be sent. There is no need
0462      * for any queuing/locking mechanism at driver level.
0463      */
0464     struct port100_cmd *cmd;
0465 
0466     bool cmd_cancel;
0467     struct completion cmd_cancel_done;
0468 };
0469 
0470 struct port100_cmd {
0471     u8 code;
0472     int status;
0473     struct sk_buff *req;
0474     struct sk_buff *resp;
0475     int resp_len;
0476     port100_send_async_complete_t  complete_cb;
0477     void *complete_cb_context;
0478 };
0479 
0480 struct port100_frame {
0481     u8 preamble;
0482     __be16 start_frame;
0483     __be16 extended_frame;
0484     __le16 datalen;
0485     u8 datalen_checksum;
0486     u8 data[];
0487 } __packed;
0488 
0489 struct port100_ack_frame {
0490     u8 preamble;
0491     __be16 start_frame;
0492     __be16 ack_frame;
0493     u8 postambule;
0494 } __packed;
0495 
0496 struct port100_cb_arg {
0497     nfc_digital_cmd_complete_t complete_cb;
0498     void *complete_arg;
0499     u8 mdaa;
0500 };
0501 
0502 struct port100_tg_comm_rf_cmd {
0503     __le16 guard_time;
0504     __le16 send_timeout;
0505     u8 mdaa;
0506     u8 nfca_param[6];
0507     u8 nfcf_param[18];
0508     u8 mf_halted;
0509     u8 arae_flag;
0510     __le16 recv_timeout;
0511     u8 data[];
0512 } __packed;
0513 
0514 struct port100_tg_comm_rf_res {
0515     u8 comm_type;
0516     u8 ar_status;
0517     u8 target_activated;
0518     __le32 status;
0519     u8 data[];
0520 } __packed;
0521 
0522 /* The rule: value + checksum = 0 */
0523 static inline u8 port100_checksum(u16 value)
0524 {
0525     return ~(((u8 *)&value)[0] + ((u8 *)&value)[1]) + 1;
0526 }
0527 
0528 /* The rule: sum(data elements) + checksum = 0 */
0529 static u8 port100_data_checksum(const u8 *data, int datalen)
0530 {
0531     u8 sum = 0;
0532     int i;
0533 
0534     for (i = 0; i < datalen; i++)
0535         sum += data[i];
0536 
0537     return port100_checksum(sum);
0538 }
0539 
0540 static void port100_tx_frame_init(void *_frame, u8 cmd_code)
0541 {
0542     struct port100_frame *frame = _frame;
0543 
0544     frame->preamble = 0;
0545     frame->start_frame = cpu_to_be16(PORT100_FRAME_SOF);
0546     frame->extended_frame = cpu_to_be16(PORT100_FRAME_EXT);
0547     PORT100_FRAME_DIRECTION(frame) = PORT100_FRAME_DIR_OUT;
0548     PORT100_FRAME_CMD(frame) = cmd_code;
0549     frame->datalen = cpu_to_le16(2);
0550 }
0551 
0552 static void port100_tx_frame_finish(void *_frame)
0553 {
0554     struct port100_frame *frame = _frame;
0555 
0556     frame->datalen_checksum = port100_checksum(le16_to_cpu(frame->datalen));
0557 
0558     PORT100_FRAME_CHECKSUM(frame) =
0559         port100_data_checksum(frame->data, le16_to_cpu(frame->datalen));
0560 
0561     PORT100_FRAME_POSTAMBLE(frame) = 0;
0562 }
0563 
0564 static void port100_tx_update_payload_len(void *_frame, int len)
0565 {
0566     struct port100_frame *frame = _frame;
0567 
0568     le16_add_cpu(&frame->datalen, len);
0569 }
0570 
0571 static bool port100_rx_frame_is_valid(const void *_frame)
0572 {
0573     u8 checksum;
0574     const struct port100_frame *frame = _frame;
0575 
0576     if (frame->start_frame != cpu_to_be16(PORT100_FRAME_SOF) ||
0577         frame->extended_frame != cpu_to_be16(PORT100_FRAME_EXT))
0578         return false;
0579 
0580     checksum = port100_checksum(le16_to_cpu(frame->datalen));
0581     if (checksum != frame->datalen_checksum)
0582         return false;
0583 
0584     checksum = port100_data_checksum(frame->data,
0585                      le16_to_cpu(frame->datalen));
0586     if (checksum != PORT100_FRAME_CHECKSUM(frame))
0587         return false;
0588 
0589     return true;
0590 }
0591 
0592 static bool port100_rx_frame_is_ack(const struct port100_ack_frame *frame)
0593 {
0594     return (frame->start_frame == cpu_to_be16(PORT100_FRAME_SOF) &&
0595         frame->ack_frame == cpu_to_be16(PORT100_FRAME_ACK));
0596 }
0597 
0598 static inline int port100_rx_frame_size(const void *frame)
0599 {
0600     const struct port100_frame *f = frame;
0601 
0602     return sizeof(struct port100_frame) + le16_to_cpu(f->datalen) +
0603            PORT100_FRAME_TAIL_LEN;
0604 }
0605 
0606 static bool port100_rx_frame_is_cmd_response(const struct port100 *dev,
0607                          const void *frame)
0608 {
0609     const struct port100_frame *f = frame;
0610 
0611     return (PORT100_FRAME_CMD(f) == PORT100_CMD_RESPONSE(dev->cmd->code));
0612 }
0613 
0614 static void port100_recv_response(struct urb *urb)
0615 {
0616     struct port100 *dev = urb->context;
0617     struct port100_cmd *cmd = dev->cmd;
0618     u8 *in_frame;
0619 
0620     cmd->status = urb->status;
0621 
0622     switch (urb->status) {
0623     case 0:
0624         break; /* success */
0625     case -ECONNRESET:
0626     case -ENOENT:
0627         nfc_dbg(&dev->interface->dev,
0628             "The urb has been canceled (status %d)\n", urb->status);
0629         goto sched_wq;
0630     case -ESHUTDOWN:
0631     default:
0632         nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
0633             urb->status);
0634         goto sched_wq;
0635     }
0636 
0637     in_frame = dev->in_urb->transfer_buffer;
0638 
0639     if (!port100_rx_frame_is_valid(in_frame)) {
0640         nfc_err(&dev->interface->dev, "Received an invalid frame\n");
0641         cmd->status = -EIO;
0642         goto sched_wq;
0643     }
0644 
0645     print_hex_dump_debug("PORT100 RX: ", DUMP_PREFIX_NONE, 16, 1, in_frame,
0646                  port100_rx_frame_size(in_frame), false);
0647 
0648     if (!port100_rx_frame_is_cmd_response(dev, in_frame)) {
0649         nfc_err(&dev->interface->dev,
0650             "It's not the response to the last command\n");
0651         cmd->status = -EIO;
0652         goto sched_wq;
0653     }
0654 
0655 sched_wq:
0656     schedule_work(&dev->cmd_complete_work);
0657 }
0658 
0659 static int port100_submit_urb_for_response(const struct port100 *dev,
0660                        gfp_t flags)
0661 {
0662     dev->in_urb->complete = port100_recv_response;
0663 
0664     return usb_submit_urb(dev->in_urb, flags);
0665 }
0666 
0667 static void port100_recv_ack(struct urb *urb)
0668 {
0669     struct port100 *dev = urb->context;
0670     struct port100_cmd *cmd = dev->cmd;
0671     const struct port100_ack_frame *in_frame;
0672     int rc;
0673 
0674     cmd->status = urb->status;
0675 
0676     switch (urb->status) {
0677     case 0:
0678         break; /* success */
0679     case -ECONNRESET:
0680     case -ENOENT:
0681         nfc_dbg(&dev->interface->dev,
0682             "The urb has been stopped (status %d)\n", urb->status);
0683         goto sched_wq;
0684     case -ESHUTDOWN:
0685     default:
0686         nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
0687             urb->status);
0688         goto sched_wq;
0689     }
0690 
0691     in_frame = dev->in_urb->transfer_buffer;
0692 
0693     if (!port100_rx_frame_is_ack(in_frame)) {
0694         nfc_err(&dev->interface->dev, "Received an invalid ack\n");
0695         cmd->status = -EIO;
0696         goto sched_wq;
0697     }
0698 
0699     rc = port100_submit_urb_for_response(dev, GFP_ATOMIC);
0700     if (rc) {
0701         nfc_err(&dev->interface->dev,
0702             "usb_submit_urb failed with result %d\n", rc);
0703         cmd->status = rc;
0704         goto sched_wq;
0705     }
0706 
0707     return;
0708 
0709 sched_wq:
0710     schedule_work(&dev->cmd_complete_work);
0711 }
0712 
0713 static int port100_submit_urb_for_ack(const struct port100 *dev, gfp_t flags)
0714 {
0715     dev->in_urb->complete = port100_recv_ack;
0716 
0717     return usb_submit_urb(dev->in_urb, flags);
0718 }
0719 
0720 static int port100_send_ack(struct port100 *dev)
0721 {
0722     int rc = 0;
0723 
0724     mutex_lock(&dev->out_urb_lock);
0725 
0726     /*
0727      * If prior cancel is in-flight (dev->cmd_cancel == true), we
0728      * can skip to send cancel. Then this will wait the prior
0729      * cancel, or merged into the next cancel rarely if next
0730      * cancel was started before waiting done. In any case, this
0731      * will be waked up soon or later.
0732      */
0733     if (!dev->cmd_cancel) {
0734         reinit_completion(&dev->cmd_cancel_done);
0735 
0736         usb_kill_urb(dev->out_urb);
0737 
0738         dev->out_urb->transfer_buffer = ack_frame;
0739         dev->out_urb->transfer_buffer_length = sizeof(ack_frame);
0740         rc = usb_submit_urb(dev->out_urb, GFP_KERNEL);
0741 
0742         /*
0743          * Set the cmd_cancel flag only if the URB has been
0744          * successfully submitted. It will be reset by the out
0745          * URB completion callback port100_send_complete().
0746          */
0747         dev->cmd_cancel = !rc;
0748     }
0749 
0750     mutex_unlock(&dev->out_urb_lock);
0751 
0752     if (!rc)
0753         wait_for_completion(&dev->cmd_cancel_done);
0754 
0755     return rc;
0756 }
0757 
0758 static int port100_send_frame_async(struct port100 *dev,
0759                     const struct sk_buff *out,
0760                     const struct sk_buff *in, int in_len)
0761 {
0762     int rc;
0763 
0764     mutex_lock(&dev->out_urb_lock);
0765 
0766     /* A command cancel frame as been sent through dev->out_urb. Don't try
0767      * to submit a new one.
0768      */
0769     if (dev->cmd_cancel) {
0770         rc = -EAGAIN;
0771         goto exit;
0772     }
0773 
0774     dev->out_urb->transfer_buffer = out->data;
0775     dev->out_urb->transfer_buffer_length = out->len;
0776 
0777     dev->in_urb->transfer_buffer = in->data;
0778     dev->in_urb->transfer_buffer_length = in_len;
0779 
0780     print_hex_dump_debug("PORT100 TX: ", DUMP_PREFIX_NONE, 16, 1,
0781                  out->data, out->len, false);
0782 
0783     rc = usb_submit_urb(dev->out_urb, GFP_KERNEL);
0784     if (rc)
0785         goto exit;
0786 
0787     rc = port100_submit_urb_for_ack(dev, GFP_KERNEL);
0788     if (rc)
0789         usb_kill_urb(dev->out_urb);
0790 
0791 exit:
0792     mutex_unlock(&dev->out_urb_lock);
0793 
0794     return rc;
0795 }
0796 
0797 static void port100_build_cmd_frame(struct port100 *dev, u8 cmd_code,
0798                     struct sk_buff *skb)
0799 {
0800     /* payload is already there, just update datalen */
0801     int payload_len = skb->len;
0802 
0803     skb_push(skb, PORT100_FRAME_HEADER_LEN);
0804     skb_put(skb, PORT100_FRAME_TAIL_LEN);
0805 
0806     port100_tx_frame_init(skb->data, cmd_code);
0807     port100_tx_update_payload_len(skb->data, payload_len);
0808     port100_tx_frame_finish(skb->data);
0809 }
0810 
0811 static void port100_send_async_complete(struct port100 *dev)
0812 {
0813     struct port100_cmd *cmd = dev->cmd;
0814     int status = cmd->status;
0815 
0816     struct sk_buff *req = cmd->req;
0817     struct sk_buff *resp = cmd->resp;
0818 
0819     dev_kfree_skb(req);
0820 
0821     dev->cmd = NULL;
0822 
0823     if (status < 0) {
0824         cmd->complete_cb(dev, cmd->complete_cb_context,
0825                  ERR_PTR(status));
0826         dev_kfree_skb(resp);
0827         goto done;
0828     }
0829 
0830     skb_put(resp, port100_rx_frame_size(resp->data));
0831     skb_pull(resp, PORT100_FRAME_HEADER_LEN);
0832     skb_trim(resp, resp->len - PORT100_FRAME_TAIL_LEN);
0833 
0834     cmd->complete_cb(dev, cmd->complete_cb_context, resp);
0835 
0836 done:
0837     kfree(cmd);
0838 }
0839 
0840 static int port100_send_cmd_async(struct port100 *dev, u8 cmd_code,
0841                 struct sk_buff *req,
0842                 port100_send_async_complete_t complete_cb,
0843                 void *complete_cb_context)
0844 {
0845     struct port100_cmd *cmd;
0846     struct sk_buff *resp;
0847     int rc;
0848     int  resp_len = PORT100_FRAME_HEADER_LEN +
0849             PORT100_FRAME_MAX_PAYLOAD_LEN +
0850             PORT100_FRAME_TAIL_LEN;
0851 
0852     if (dev->cmd) {
0853         nfc_err(&dev->interface->dev,
0854             "A command is still in process\n");
0855         return -EBUSY;
0856     }
0857 
0858     resp = alloc_skb(resp_len, GFP_KERNEL);
0859     if (!resp)
0860         return -ENOMEM;
0861 
0862     cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
0863     if (!cmd) {
0864         dev_kfree_skb(resp);
0865         return -ENOMEM;
0866     }
0867 
0868     cmd->code = cmd_code;
0869     cmd->req = req;
0870     cmd->resp = resp;
0871     cmd->resp_len = resp_len;
0872     cmd->complete_cb = complete_cb;
0873     cmd->complete_cb_context = complete_cb_context;
0874 
0875     port100_build_cmd_frame(dev, cmd_code, req);
0876 
0877     dev->cmd = cmd;
0878 
0879     rc = port100_send_frame_async(dev, req, resp, resp_len);
0880     if (rc) {
0881         kfree(cmd);
0882         dev_kfree_skb(resp);
0883         dev->cmd = NULL;
0884     }
0885 
0886     return rc;
0887 }
0888 
0889 struct port100_sync_cmd_response {
0890     struct sk_buff *resp;
0891     struct completion done;
0892 };
0893 
0894 static void port100_wq_cmd_complete(struct work_struct *work)
0895 {
0896     struct port100 *dev = container_of(work, struct port100,
0897                        cmd_complete_work);
0898 
0899     port100_send_async_complete(dev);
0900 }
0901 
0902 static void port100_send_sync_complete(struct port100 *dev, void *_arg,
0903                       struct sk_buff *resp)
0904 {
0905     struct port100_sync_cmd_response *arg = _arg;
0906 
0907     arg->resp = resp;
0908     complete(&arg->done);
0909 }
0910 
0911 static struct sk_buff *port100_send_cmd_sync(struct port100 *dev, u8 cmd_code,
0912                          struct sk_buff *req)
0913 {
0914     int rc;
0915     struct port100_sync_cmd_response arg;
0916 
0917     init_completion(&arg.done);
0918 
0919     rc = port100_send_cmd_async(dev, cmd_code, req,
0920                     port100_send_sync_complete, &arg);
0921     if (rc) {
0922         dev_kfree_skb(req);
0923         return ERR_PTR(rc);
0924     }
0925 
0926     wait_for_completion(&arg.done);
0927 
0928     return arg.resp;
0929 }
0930 
0931 static void port100_send_complete(struct urb *urb)
0932 {
0933     struct port100 *dev = urb->context;
0934 
0935     if (dev->cmd_cancel) {
0936         complete_all(&dev->cmd_cancel_done);
0937         dev->cmd_cancel = false;
0938     }
0939 
0940     switch (urb->status) {
0941     case 0:
0942         break; /* success */
0943     case -ECONNRESET:
0944     case -ENOENT:
0945         nfc_dbg(&dev->interface->dev,
0946             "The urb has been stopped (status %d)\n", urb->status);
0947         break;
0948     case -ESHUTDOWN:
0949     default:
0950         nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
0951             urb->status);
0952     }
0953 }
0954 
0955 static void port100_abort_cmd(struct nfc_digital_dev *ddev)
0956 {
0957     struct port100 *dev = nfc_digital_get_drvdata(ddev);
0958 
0959     /* An ack will cancel the last issued command */
0960     port100_send_ack(dev);
0961 
0962     /* cancel the urb request */
0963     usb_kill_urb(dev->in_urb);
0964 }
0965 
0966 static struct sk_buff *port100_alloc_skb(const struct port100 *dev, unsigned int size)
0967 {
0968     struct sk_buff *skb;
0969 
0970     skb = alloc_skb(dev->skb_headroom + dev->skb_tailroom + size,
0971             GFP_KERNEL);
0972     if (skb)
0973         skb_reserve(skb, dev->skb_headroom);
0974 
0975     return skb;
0976 }
0977 
0978 static int port100_set_command_type(struct port100 *dev, u8 command_type)
0979 {
0980     struct sk_buff *skb;
0981     struct sk_buff *resp;
0982     int rc;
0983 
0984     skb = port100_alloc_skb(dev, 1);
0985     if (!skb)
0986         return -ENOMEM;
0987 
0988     skb_put_u8(skb, command_type);
0989 
0990     resp = port100_send_cmd_sync(dev, PORT100_CMD_SET_COMMAND_TYPE, skb);
0991     if (IS_ERR(resp))
0992         return PTR_ERR(resp);
0993 
0994     rc = resp->data[0];
0995 
0996     dev_kfree_skb(resp);
0997 
0998     return rc;
0999 }
1000 
1001 static u64 port100_get_command_type_mask(struct port100 *dev)
1002 {
1003     struct sk_buff *skb;
1004     struct sk_buff *resp;
1005     u64 mask;
1006 
1007     skb = port100_alloc_skb(dev, 0);
1008     if (!skb)
1009         return 0;
1010 
1011     resp = port100_send_cmd_sync(dev, PORT100_CMD_GET_COMMAND_TYPE, skb);
1012     if (IS_ERR(resp))
1013         return 0;
1014 
1015     if (resp->len < 8)
1016         mask = 0;
1017     else
1018         mask = be64_to_cpu(*(__be64 *)resp->data);
1019 
1020     dev_kfree_skb(resp);
1021 
1022     return mask;
1023 }
1024 
1025 static u16 port100_get_firmware_version(struct port100 *dev)
1026 {
1027     struct sk_buff *skb;
1028     struct sk_buff *resp;
1029     u16 fw_ver;
1030 
1031     skb = port100_alloc_skb(dev, 0);
1032     if (!skb)
1033         return 0;
1034 
1035     resp = port100_send_cmd_sync(dev, PORT100_CMD_GET_FIRMWARE_VERSION,
1036                      skb);
1037     if (IS_ERR(resp))
1038         return 0;
1039 
1040     fw_ver = le16_to_cpu(*(__le16 *)resp->data);
1041 
1042     dev_kfree_skb(resp);
1043 
1044     return fw_ver;
1045 }
1046 
1047 static int port100_switch_rf(struct nfc_digital_dev *ddev, bool on)
1048 {
1049     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1050     struct sk_buff *skb, *resp;
1051 
1052     skb = port100_alloc_skb(dev, 1);
1053     if (!skb)
1054         return -ENOMEM;
1055 
1056     skb_put_u8(skb, on ? 1 : 0);
1057 
1058     /* Cancel the last command if the device is being switched off */
1059     if (!on)
1060         port100_abort_cmd(ddev);
1061 
1062     resp = port100_send_cmd_sync(dev, PORT100_CMD_SWITCH_RF, skb);
1063 
1064     if (IS_ERR(resp))
1065         return PTR_ERR(resp);
1066 
1067     dev_kfree_skb(resp);
1068 
1069     return 0;
1070 }
1071 
1072 static int port100_in_set_rf(struct nfc_digital_dev *ddev, u8 rf)
1073 {
1074     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1075     struct sk_buff *skb;
1076     struct sk_buff *resp;
1077     int rc;
1078 
1079     if (rf >= NFC_DIGITAL_RF_TECH_LAST)
1080         return -EINVAL;
1081 
1082     skb = port100_alloc_skb(dev, sizeof(struct port100_in_rf_setting));
1083     if (!skb)
1084         return -ENOMEM;
1085 
1086     skb_put_data(skb, &in_rf_settings[rf],
1087              sizeof(struct port100_in_rf_setting));
1088 
1089     resp = port100_send_cmd_sync(dev, PORT100_CMD_IN_SET_RF, skb);
1090 
1091     if (IS_ERR(resp))
1092         return PTR_ERR(resp);
1093 
1094     rc = resp->data[0];
1095 
1096     dev_kfree_skb(resp);
1097 
1098     return rc;
1099 }
1100 
1101 static int port100_in_set_framing(struct nfc_digital_dev *ddev, int param)
1102 {
1103     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1104     const struct port100_protocol *protocols;
1105     struct sk_buff *skb;
1106     struct sk_buff *resp;
1107     int num_protocols;
1108     size_t size;
1109     int rc;
1110 
1111     if (param >= NFC_DIGITAL_FRAMING_LAST)
1112         return -EINVAL;
1113 
1114     protocols = in_protocols[param];
1115 
1116     num_protocols = 0;
1117     while (protocols[num_protocols].number != PORT100_IN_PROT_END)
1118         num_protocols++;
1119 
1120     if (!num_protocols)
1121         return 0;
1122 
1123     size = sizeof(struct port100_protocol) * num_protocols;
1124 
1125     skb = port100_alloc_skb(dev, size);
1126     if (!skb)
1127         return -ENOMEM;
1128 
1129     skb_put_data(skb, protocols, size);
1130 
1131     resp = port100_send_cmd_sync(dev, PORT100_CMD_IN_SET_PROTOCOL, skb);
1132 
1133     if (IS_ERR(resp))
1134         return PTR_ERR(resp);
1135 
1136     rc = resp->data[0];
1137 
1138     dev_kfree_skb(resp);
1139 
1140     return rc;
1141 }
1142 
1143 static int port100_in_configure_hw(struct nfc_digital_dev *ddev, int type,
1144                    int param)
1145 {
1146     if (type == NFC_DIGITAL_CONFIG_RF_TECH)
1147         return port100_in_set_rf(ddev, param);
1148 
1149     if (type == NFC_DIGITAL_CONFIG_FRAMING)
1150         return port100_in_set_framing(ddev, param);
1151 
1152     return -EINVAL;
1153 }
1154 
1155 static void port100_in_comm_rf_complete(struct port100 *dev, void *arg,
1156                        struct sk_buff *resp)
1157 {
1158     const struct port100_cb_arg *cb_arg = arg;
1159     nfc_digital_cmd_complete_t cb = cb_arg->complete_cb;
1160     u32 status;
1161     int rc;
1162 
1163     if (IS_ERR(resp)) {
1164         rc =  PTR_ERR(resp);
1165         goto exit;
1166     }
1167 
1168     if (resp->len < 4) {
1169         nfc_err(&dev->interface->dev,
1170             "Invalid packet length received\n");
1171         rc = -EIO;
1172         goto error;
1173     }
1174 
1175     status = le32_to_cpu(*(__le32 *)resp->data);
1176 
1177     skb_pull(resp, sizeof(u32));
1178 
1179     if (status == PORT100_CMD_STATUS_TIMEOUT) {
1180         rc = -ETIMEDOUT;
1181         goto error;
1182     }
1183 
1184     if (status != PORT100_CMD_STATUS_OK) {
1185         nfc_err(&dev->interface->dev,
1186             "in_comm_rf failed with status 0x%08x\n", status);
1187         rc = -EIO;
1188         goto error;
1189     }
1190 
1191     /* Remove collision bits byte */
1192     skb_pull(resp, 1);
1193 
1194     goto exit;
1195 
1196 error:
1197     kfree_skb(resp);
1198     resp = ERR_PTR(rc);
1199 
1200 exit:
1201     cb(dev->nfc_digital_dev, cb_arg->complete_arg, resp);
1202 
1203     kfree(cb_arg);
1204 }
1205 
1206 static int port100_in_send_cmd(struct nfc_digital_dev *ddev,
1207                    struct sk_buff *skb, u16 _timeout,
1208                    nfc_digital_cmd_complete_t cb, void *arg)
1209 {
1210     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1211     struct port100_cb_arg *cb_arg;
1212     __le16 timeout;
1213 
1214     cb_arg = kzalloc(sizeof(struct port100_cb_arg), GFP_KERNEL);
1215     if (!cb_arg)
1216         return -ENOMEM;
1217 
1218     cb_arg->complete_cb = cb;
1219     cb_arg->complete_arg = arg;
1220 
1221     timeout = cpu_to_le16(_timeout * 10);
1222 
1223     memcpy(skb_push(skb, sizeof(__le16)), &timeout, sizeof(__le16));
1224 
1225     return port100_send_cmd_async(dev, PORT100_CMD_IN_COMM_RF, skb,
1226                       port100_in_comm_rf_complete, cb_arg);
1227 }
1228 
1229 static int port100_tg_set_rf(struct nfc_digital_dev *ddev, u8 rf)
1230 {
1231     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1232     struct sk_buff *skb;
1233     struct sk_buff *resp;
1234     int rc;
1235 
1236     if (rf >= NFC_DIGITAL_RF_TECH_LAST)
1237         return -EINVAL;
1238 
1239     skb = port100_alloc_skb(dev, sizeof(struct port100_tg_rf_setting));
1240     if (!skb)
1241         return -ENOMEM;
1242 
1243     skb_put_data(skb, &tg_rf_settings[rf],
1244              sizeof(struct port100_tg_rf_setting));
1245 
1246     resp = port100_send_cmd_sync(dev, PORT100_CMD_TG_SET_RF, skb);
1247 
1248     if (IS_ERR(resp))
1249         return PTR_ERR(resp);
1250 
1251     rc = resp->data[0];
1252 
1253     dev_kfree_skb(resp);
1254 
1255     return rc;
1256 }
1257 
1258 static int port100_tg_set_framing(struct nfc_digital_dev *ddev, int param)
1259 {
1260     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1261     const struct port100_protocol *protocols;
1262     struct sk_buff *skb;
1263     struct sk_buff *resp;
1264     int rc;
1265     int num_protocols;
1266     size_t size;
1267 
1268     if (param >= NFC_DIGITAL_FRAMING_LAST)
1269         return -EINVAL;
1270 
1271     protocols = tg_protocols[param];
1272 
1273     num_protocols = 0;
1274     while (protocols[num_protocols].number != PORT100_TG_PROT_END)
1275         num_protocols++;
1276 
1277     if (!num_protocols)
1278         return 0;
1279 
1280     size = sizeof(struct port100_protocol) * num_protocols;
1281 
1282     skb = port100_alloc_skb(dev, size);
1283     if (!skb)
1284         return -ENOMEM;
1285 
1286     skb_put_data(skb, protocols, size);
1287 
1288     resp = port100_send_cmd_sync(dev, PORT100_CMD_TG_SET_PROTOCOL, skb);
1289 
1290     if (IS_ERR(resp))
1291         return PTR_ERR(resp);
1292 
1293     rc = resp->data[0];
1294 
1295     dev_kfree_skb(resp);
1296 
1297     return rc;
1298 }
1299 
1300 static int port100_tg_configure_hw(struct nfc_digital_dev *ddev, int type,
1301                    int param)
1302 {
1303     if (type == NFC_DIGITAL_CONFIG_RF_TECH)
1304         return port100_tg_set_rf(ddev, param);
1305 
1306     if (type == NFC_DIGITAL_CONFIG_FRAMING)
1307         return port100_tg_set_framing(ddev, param);
1308 
1309     return -EINVAL;
1310 }
1311 
1312 static bool port100_tg_target_activated(struct port100 *dev, u8 tgt_activated)
1313 {
1314     u8 mask;
1315 
1316     switch (dev->cmd_type) {
1317     case PORT100_CMD_TYPE_0:
1318         mask = PORT100_MDAA_TGT_HAS_BEEN_ACTIVATED_MASK;
1319         break;
1320     case PORT100_CMD_TYPE_1:
1321         mask = PORT100_MDAA_TGT_HAS_BEEN_ACTIVATED_MASK |
1322                PORT100_MDAA_TGT_WAS_ACTIVATED_MASK;
1323         break;
1324     default:
1325         nfc_err(&dev->interface->dev, "Unknown command type\n");
1326         return false;
1327     }
1328 
1329     return ((tgt_activated & mask) == mask);
1330 }
1331 
1332 static void port100_tg_comm_rf_complete(struct port100 *dev, void *arg,
1333                     struct sk_buff *resp)
1334 {
1335     u32 status;
1336     const struct port100_cb_arg *cb_arg = arg;
1337     nfc_digital_cmd_complete_t cb = cb_arg->complete_cb;
1338     struct port100_tg_comm_rf_res *hdr;
1339 
1340     if (IS_ERR(resp))
1341         goto exit;
1342 
1343     hdr = (struct port100_tg_comm_rf_res *)resp->data;
1344 
1345     status = le32_to_cpu(hdr->status);
1346 
1347     if (cb_arg->mdaa &&
1348         !port100_tg_target_activated(dev, hdr->target_activated)) {
1349         kfree_skb(resp);
1350         resp = ERR_PTR(-ETIMEDOUT);
1351 
1352         goto exit;
1353     }
1354 
1355     skb_pull(resp, sizeof(struct port100_tg_comm_rf_res));
1356 
1357     if (status != PORT100_CMD_STATUS_OK) {
1358         kfree_skb(resp);
1359 
1360         if (status == PORT100_CMD_STATUS_TIMEOUT)
1361             resp = ERR_PTR(-ETIMEDOUT);
1362         else
1363             resp = ERR_PTR(-EIO);
1364     }
1365 
1366 exit:
1367     cb(dev->nfc_digital_dev, cb_arg->complete_arg, resp);
1368 
1369     kfree(cb_arg);
1370 }
1371 
1372 static int port100_tg_send_cmd(struct nfc_digital_dev *ddev,
1373                    struct sk_buff *skb, u16 timeout,
1374                    nfc_digital_cmd_complete_t cb, void *arg)
1375 {
1376     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1377     struct port100_tg_comm_rf_cmd *hdr;
1378     struct port100_cb_arg *cb_arg;
1379 
1380     cb_arg = kzalloc(sizeof(struct port100_cb_arg), GFP_KERNEL);
1381     if (!cb_arg)
1382         return -ENOMEM;
1383 
1384     cb_arg->complete_cb = cb;
1385     cb_arg->complete_arg = arg;
1386 
1387     skb_push(skb, sizeof(struct port100_tg_comm_rf_cmd));
1388 
1389     hdr = (struct port100_tg_comm_rf_cmd *)skb->data;
1390 
1391     memset(hdr, 0, sizeof(struct port100_tg_comm_rf_cmd));
1392     hdr->guard_time = cpu_to_le16(500);
1393     hdr->send_timeout = cpu_to_le16(0xFFFF);
1394     hdr->recv_timeout = cpu_to_le16(timeout);
1395 
1396     return port100_send_cmd_async(dev, PORT100_CMD_TG_COMM_RF, skb,
1397                       port100_tg_comm_rf_complete, cb_arg);
1398 }
1399 
1400 static int port100_listen_mdaa(struct nfc_digital_dev *ddev,
1401                    struct digital_tg_mdaa_params *params,
1402                    u16 timeout,
1403                    nfc_digital_cmd_complete_t cb, void *arg)
1404 {
1405     struct port100 *dev = nfc_digital_get_drvdata(ddev);
1406     struct port100_tg_comm_rf_cmd *hdr;
1407     struct port100_cb_arg *cb_arg;
1408     struct sk_buff *skb;
1409     int rc;
1410 
1411     rc = port100_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1412                      NFC_DIGITAL_RF_TECH_106A);
1413     if (rc)
1414         return rc;
1415 
1416     rc = port100_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1417                      NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1418     if (rc)
1419         return rc;
1420 
1421     cb_arg = kzalloc(sizeof(struct port100_cb_arg), GFP_KERNEL);
1422     if (!cb_arg)
1423         return -ENOMEM;
1424 
1425     cb_arg->complete_cb = cb;
1426     cb_arg->complete_arg = arg;
1427     cb_arg->mdaa = 1;
1428 
1429     skb = port100_alloc_skb(dev, 0);
1430     if (!skb) {
1431         kfree(cb_arg);
1432         return -ENOMEM;
1433     }
1434 
1435     skb_push(skb, sizeof(struct port100_tg_comm_rf_cmd));
1436     hdr = (struct port100_tg_comm_rf_cmd *)skb->data;
1437 
1438     memset(hdr, 0, sizeof(struct port100_tg_comm_rf_cmd));
1439 
1440     hdr->guard_time = 0;
1441     hdr->send_timeout = cpu_to_le16(0xFFFF);
1442     hdr->mdaa = 1;
1443     hdr->nfca_param[0] = (params->sens_res >> 8) & 0xFF;
1444     hdr->nfca_param[1] = params->sens_res & 0xFF;
1445     memcpy(hdr->nfca_param + 2, params->nfcid1, 3);
1446     hdr->nfca_param[5] = params->sel_res;
1447     memcpy(hdr->nfcf_param, params->nfcid2, 8);
1448     hdr->nfcf_param[16] = (params->sc >> 8) & 0xFF;
1449     hdr->nfcf_param[17] = params->sc & 0xFF;
1450     hdr->recv_timeout = cpu_to_le16(timeout);
1451 
1452     return port100_send_cmd_async(dev, PORT100_CMD_TG_COMM_RF, skb,
1453                       port100_tg_comm_rf_complete, cb_arg);
1454 }
1455 
1456 static int port100_listen(struct nfc_digital_dev *ddev, u16 timeout,
1457               nfc_digital_cmd_complete_t cb, void *arg)
1458 {
1459     const struct port100 *dev = nfc_digital_get_drvdata(ddev);
1460     struct sk_buff *skb;
1461 
1462     skb = port100_alloc_skb(dev, 0);
1463     if (!skb)
1464         return -ENOMEM;
1465 
1466     return port100_tg_send_cmd(ddev, skb, timeout, cb, arg);
1467 }
1468 
1469 static const struct nfc_digital_ops port100_digital_ops = {
1470     .in_configure_hw = port100_in_configure_hw,
1471     .in_send_cmd = port100_in_send_cmd,
1472 
1473     .tg_listen_mdaa = port100_listen_mdaa,
1474     .tg_listen = port100_listen,
1475     .tg_configure_hw = port100_tg_configure_hw,
1476     .tg_send_cmd = port100_tg_send_cmd,
1477 
1478     .switch_rf = port100_switch_rf,
1479     .abort_cmd = port100_abort_cmd,
1480 };
1481 
1482 static const struct usb_device_id port100_table[] = {
1483     { USB_DEVICE(SONY_VENDOR_ID, RCS380S_PRODUCT_ID), },
1484     { USB_DEVICE(SONY_VENDOR_ID, RCS380P_PRODUCT_ID), },
1485     { }
1486 };
1487 MODULE_DEVICE_TABLE(usb, port100_table);
1488 
1489 static int port100_probe(struct usb_interface *interface,
1490              const struct usb_device_id *id)
1491 {
1492     struct port100 *dev;
1493     int rc;
1494     struct usb_host_interface *iface_desc;
1495     struct usb_endpoint_descriptor *endpoint;
1496     int in_endpoint;
1497     int out_endpoint;
1498     u16 fw_version;
1499     u64 cmd_type_mask;
1500     int i;
1501 
1502     dev = devm_kzalloc(&interface->dev, sizeof(struct port100), GFP_KERNEL);
1503     if (!dev)
1504         return -ENOMEM;
1505 
1506     mutex_init(&dev->out_urb_lock);
1507     dev->udev = usb_get_dev(interface_to_usbdev(interface));
1508     dev->interface = interface;
1509     usb_set_intfdata(interface, dev);
1510 
1511     in_endpoint = out_endpoint = 0;
1512     iface_desc = interface->cur_altsetting;
1513     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1514         endpoint = &iface_desc->endpoint[i].desc;
1515 
1516         if (!in_endpoint && usb_endpoint_is_bulk_in(endpoint))
1517             in_endpoint = endpoint->bEndpointAddress;
1518 
1519         if (!out_endpoint && usb_endpoint_is_bulk_out(endpoint))
1520             out_endpoint = endpoint->bEndpointAddress;
1521     }
1522 
1523     if (!in_endpoint || !out_endpoint) {
1524         nfc_err(&interface->dev,
1525             "Could not find bulk-in or bulk-out endpoint\n");
1526         rc = -ENODEV;
1527         goto error;
1528     }
1529 
1530     dev->in_urb = usb_alloc_urb(0, GFP_KERNEL);
1531     dev->out_urb = usb_alloc_urb(0, GFP_KERNEL);
1532 
1533     if (!dev->in_urb || !dev->out_urb) {
1534         nfc_err(&interface->dev, "Could not allocate USB URBs\n");
1535         rc = -ENOMEM;
1536         goto error;
1537     }
1538 
1539     usb_fill_bulk_urb(dev->in_urb, dev->udev,
1540               usb_rcvbulkpipe(dev->udev, in_endpoint),
1541               NULL, 0, NULL, dev);
1542     usb_fill_bulk_urb(dev->out_urb, dev->udev,
1543               usb_sndbulkpipe(dev->udev, out_endpoint),
1544               NULL, 0, port100_send_complete, dev);
1545     dev->out_urb->transfer_flags = URB_ZERO_PACKET;
1546 
1547     dev->skb_headroom = PORT100_FRAME_HEADER_LEN +
1548                 PORT100_COMM_RF_HEAD_MAX_LEN;
1549     dev->skb_tailroom = PORT100_FRAME_TAIL_LEN;
1550 
1551     init_completion(&dev->cmd_cancel_done);
1552     INIT_WORK(&dev->cmd_complete_work, port100_wq_cmd_complete);
1553 
1554     /* The first thing to do with the Port-100 is to set the command type
1555      * to be used. If supported we use command type 1. 0 otherwise.
1556      */
1557     cmd_type_mask = port100_get_command_type_mask(dev);
1558     if (!cmd_type_mask) {
1559         nfc_err(&interface->dev,
1560             "Could not get supported command types\n");
1561         rc = -ENODEV;
1562         goto error;
1563     }
1564 
1565     if (PORT100_CMD_TYPE_IS_SUPPORTED(cmd_type_mask, PORT100_CMD_TYPE_1))
1566         dev->cmd_type = PORT100_CMD_TYPE_1;
1567     else
1568         dev->cmd_type = PORT100_CMD_TYPE_0;
1569 
1570     rc = port100_set_command_type(dev, dev->cmd_type);
1571     if (rc) {
1572         nfc_err(&interface->dev,
1573             "The device does not support command type %u\n",
1574             dev->cmd_type);
1575         goto error;
1576     }
1577 
1578     fw_version = port100_get_firmware_version(dev);
1579     if (!fw_version)
1580         nfc_err(&interface->dev,
1581             "Could not get device firmware version\n");
1582 
1583     nfc_info(&interface->dev,
1584          "Sony NFC Port-100 Series attached (firmware v%x.%02x)\n",
1585          (fw_version & 0xFF00) >> 8, fw_version & 0xFF);
1586 
1587     dev->nfc_digital_dev = nfc_digital_allocate_device(&port100_digital_ops,
1588                                PORT100_PROTOCOLS,
1589                                PORT100_CAPABILITIES,
1590                                dev->skb_headroom,
1591                                dev->skb_tailroom);
1592     if (!dev->nfc_digital_dev) {
1593         nfc_err(&interface->dev,
1594             "Could not allocate nfc_digital_dev\n");
1595         rc = -ENOMEM;
1596         goto error;
1597     }
1598 
1599     nfc_digital_set_parent_dev(dev->nfc_digital_dev, &interface->dev);
1600     nfc_digital_set_drvdata(dev->nfc_digital_dev, dev);
1601 
1602     rc = nfc_digital_register_device(dev->nfc_digital_dev);
1603     if (rc) {
1604         nfc_err(&interface->dev,
1605             "Could not register digital device\n");
1606         goto free_nfc_dev;
1607     }
1608 
1609     return 0;
1610 
1611 free_nfc_dev:
1612     nfc_digital_free_device(dev->nfc_digital_dev);
1613 
1614 error:
1615     usb_kill_urb(dev->in_urb);
1616     usb_free_urb(dev->in_urb);
1617     usb_kill_urb(dev->out_urb);
1618     usb_free_urb(dev->out_urb);
1619     usb_put_dev(dev->udev);
1620 
1621     return rc;
1622 }
1623 
1624 static void port100_disconnect(struct usb_interface *interface)
1625 {
1626     struct port100 *dev;
1627 
1628     dev = usb_get_intfdata(interface);
1629     usb_set_intfdata(interface, NULL);
1630 
1631     nfc_digital_unregister_device(dev->nfc_digital_dev);
1632     nfc_digital_free_device(dev->nfc_digital_dev);
1633 
1634     usb_kill_urb(dev->in_urb);
1635     usb_kill_urb(dev->out_urb);
1636 
1637     usb_free_urb(dev->in_urb);
1638     usb_free_urb(dev->out_urb);
1639     usb_put_dev(dev->udev);
1640 
1641     kfree(dev->cmd);
1642 
1643     nfc_info(&interface->dev, "Sony Port-100 NFC device disconnected\n");
1644 }
1645 
1646 static struct usb_driver port100_driver = {
1647     .name =     "port100",
1648     .probe =    port100_probe,
1649     .disconnect =   port100_disconnect,
1650     .id_table = port100_table,
1651 };
1652 
1653 module_usb_driver(port100_driver);
1654 
1655 MODULE_DESCRIPTION("NFC Port-100 series usb driver ver " VERSION);
1656 MODULE_VERSION(VERSION);
1657 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!