Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * HCI based Driver for Inside Secure microread NFC Chip
0004  *
0005  * Copyright (C) 2013  Intel Corporation. All rights reserved.
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/module.h>
0011 #include <linux/delay.h>
0012 #include <linux/slab.h>
0013 #include <linux/crc-ccitt.h>
0014 
0015 #include <linux/nfc.h>
0016 #include <net/nfc/nfc.h>
0017 #include <net/nfc/hci.h>
0018 
0019 #include "microread.h"
0020 
0021 /* Proprietary gates, events, commands and registers */
0022 /* Admin */
0023 #define MICROREAD_GATE_ID_ADM NFC_HCI_ADMIN_GATE
0024 #define MICROREAD_GATE_ID_MGT 0x01
0025 #define MICROREAD_GATE_ID_OS 0x02
0026 #define MICROREAD_GATE_ID_TESTRF 0x03
0027 #define MICROREAD_GATE_ID_LOOPBACK NFC_HCI_LOOPBACK_GATE
0028 #define MICROREAD_GATE_ID_IDT NFC_HCI_ID_MGMT_GATE
0029 #define MICROREAD_GATE_ID_LMS NFC_HCI_LINK_MGMT_GATE
0030 
0031 /* Reader */
0032 #define MICROREAD_GATE_ID_MREAD_GEN 0x10
0033 #define MICROREAD_GATE_ID_MREAD_ISO_B NFC_HCI_RF_READER_B_GATE
0034 #define MICROREAD_GATE_ID_MREAD_NFC_T1 0x12
0035 #define MICROREAD_GATE_ID_MREAD_ISO_A NFC_HCI_RF_READER_A_GATE
0036 #define MICROREAD_GATE_ID_MREAD_NFC_T3 0x14
0037 #define MICROREAD_GATE_ID_MREAD_ISO_15_3 0x15
0038 #define MICROREAD_GATE_ID_MREAD_ISO_15_2 0x16
0039 #define MICROREAD_GATE_ID_MREAD_ISO_B_3 0x17
0040 #define MICROREAD_GATE_ID_MREAD_BPRIME 0x18
0041 #define MICROREAD_GATE_ID_MREAD_ISO_A_3 0x19
0042 
0043 /* Card */
0044 #define MICROREAD_GATE_ID_MCARD_GEN 0x20
0045 #define MICROREAD_GATE_ID_MCARD_ISO_B 0x21
0046 #define MICROREAD_GATE_ID_MCARD_BPRIME 0x22
0047 #define MICROREAD_GATE_ID_MCARD_ISO_A 0x23
0048 #define MICROREAD_GATE_ID_MCARD_NFC_T3 0x24
0049 #define MICROREAD_GATE_ID_MCARD_ISO_15_3 0x25
0050 #define MICROREAD_GATE_ID_MCARD_ISO_15_2 0x26
0051 #define MICROREAD_GATE_ID_MCARD_ISO_B_2 0x27
0052 #define MICROREAD_GATE_ID_MCARD_ISO_CUSTOM 0x28
0053 #define MICROREAD_GATE_ID_SECURE_ELEMENT 0x2F
0054 
0055 /* P2P */
0056 #define MICROREAD_GATE_ID_P2P_GEN 0x30
0057 #define MICROREAD_GATE_ID_P2P_TARGET 0x31
0058 #define MICROREAD_PAR_P2P_TARGET_MODE 0x01
0059 #define MICROREAD_PAR_P2P_TARGET_GT 0x04
0060 #define MICROREAD_GATE_ID_P2P_INITIATOR 0x32
0061 #define MICROREAD_PAR_P2P_INITIATOR_GI 0x01
0062 #define MICROREAD_PAR_P2P_INITIATOR_GT 0x03
0063 
0064 /* Those pipes are created/opened by default in the chip */
0065 #define MICROREAD_PIPE_ID_LMS 0x00
0066 #define MICROREAD_PIPE_ID_ADMIN 0x01
0067 #define MICROREAD_PIPE_ID_MGT 0x02
0068 #define MICROREAD_PIPE_ID_OS 0x03
0069 #define MICROREAD_PIPE_ID_HDS_LOOPBACK 0x04
0070 #define MICROREAD_PIPE_ID_HDS_IDT 0x05
0071 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B 0x08
0072 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_BPRIME 0x09
0073 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_A 0x0A
0074 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_3 0x0B
0075 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_2 0x0C
0076 #define MICROREAD_PIPE_ID_HDS_MCARD_NFC_T3 0x0D
0077 #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B_2 0x0E
0078 #define MICROREAD_PIPE_ID_HDS_MCARD_CUSTOM 0x0F
0079 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B 0x10
0080 #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1 0x11
0081 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A 0x12
0082 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_3 0x13
0083 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_2 0x14
0084 #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3 0x15
0085 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B_3 0x16
0086 #define MICROREAD_PIPE_ID_HDS_MREAD_BPRIME 0x17
0087 #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3 0x18
0088 #define MICROREAD_PIPE_ID_HDS_MREAD_GEN 0x1B
0089 #define MICROREAD_PIPE_ID_HDS_STACKED_ELEMENT 0x1C
0090 #define MICROREAD_PIPE_ID_HDS_INSTANCES 0x1D
0091 #define MICROREAD_PIPE_ID_HDS_TESTRF 0x1E
0092 #define MICROREAD_PIPE_ID_HDS_P2P_TARGET 0x1F
0093 #define MICROREAD_PIPE_ID_HDS_P2P_INITIATOR 0x20
0094 
0095 /* Events */
0096 #define MICROREAD_EVT_MREAD_DISCOVERY_OCCURED NFC_HCI_EVT_TARGET_DISCOVERED
0097 #define MICROREAD_EVT_MREAD_CARD_FOUND 0x3D
0098 #define MICROREAD_EMCF_A_ATQA 0
0099 #define MICROREAD_EMCF_A_SAK 2
0100 #define MICROREAD_EMCF_A_LEN 3
0101 #define MICROREAD_EMCF_A_UID 4
0102 #define MICROREAD_EMCF_A3_ATQA 0
0103 #define MICROREAD_EMCF_A3_SAK 2
0104 #define MICROREAD_EMCF_A3_LEN 3
0105 #define MICROREAD_EMCF_A3_UID 4
0106 #define MICROREAD_EMCF_B_UID 0
0107 #define MICROREAD_EMCF_T1_ATQA 0
0108 #define MICROREAD_EMCF_T1_UID 4
0109 #define MICROREAD_EMCF_T3_UID 0
0110 #define MICROREAD_EVT_MREAD_DISCOVERY_START NFC_HCI_EVT_READER_REQUESTED
0111 #define MICROREAD_EVT_MREAD_DISCOVERY_START_SOME 0x3E
0112 #define MICROREAD_EVT_MREAD_DISCOVERY_STOP NFC_HCI_EVT_END_OPERATION
0113 #define MICROREAD_EVT_MREAD_SIM_REQUESTS 0x3F
0114 #define MICROREAD_EVT_MCARD_EXCHANGE NFC_HCI_EVT_TARGET_DISCOVERED
0115 #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF 0x20
0116 #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF 0x21
0117 #define MICROREAD_EVT_MCARD_FIELD_ON 0x11
0118 #define MICROREAD_EVT_P2P_TARGET_ACTIVATED 0x13
0119 #define MICROREAD_EVT_P2P_TARGET_DEACTIVATED 0x12
0120 #define MICROREAD_EVT_MCARD_FIELD_OFF 0x14
0121 
0122 /* Commands */
0123 #define MICROREAD_CMD_MREAD_EXCHANGE 0x10
0124 #define MICROREAD_CMD_MREAD_SUBSCRIBE 0x3F
0125 
0126 /* Hosts IDs */
0127 #define MICROREAD_ELT_ID_HDS NFC_HCI_TERMINAL_HOST_ID
0128 #define MICROREAD_ELT_ID_SIM NFC_HCI_UICC_HOST_ID
0129 #define MICROREAD_ELT_ID_SE1 0x03
0130 #define MICROREAD_ELT_ID_SE2 0x04
0131 #define MICROREAD_ELT_ID_SE3 0x05
0132 
0133 static const struct nfc_hci_gate microread_gates[] = {
0134     {MICROREAD_GATE_ID_ADM, MICROREAD_PIPE_ID_ADMIN},
0135     {MICROREAD_GATE_ID_LOOPBACK, MICROREAD_PIPE_ID_HDS_LOOPBACK},
0136     {MICROREAD_GATE_ID_IDT, MICROREAD_PIPE_ID_HDS_IDT},
0137     {MICROREAD_GATE_ID_LMS, MICROREAD_PIPE_ID_LMS},
0138     {MICROREAD_GATE_ID_MREAD_ISO_B, MICROREAD_PIPE_ID_HDS_MREAD_ISO_B},
0139     {MICROREAD_GATE_ID_MREAD_ISO_A, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A},
0140     {MICROREAD_GATE_ID_MREAD_ISO_A_3, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3},
0141     {MICROREAD_GATE_ID_MGT, MICROREAD_PIPE_ID_MGT},
0142     {MICROREAD_GATE_ID_OS, MICROREAD_PIPE_ID_OS},
0143     {MICROREAD_GATE_ID_MREAD_NFC_T1, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1},
0144     {MICROREAD_GATE_ID_MREAD_NFC_T3, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3},
0145     {MICROREAD_GATE_ID_P2P_TARGET, MICROREAD_PIPE_ID_HDS_P2P_TARGET},
0146     {MICROREAD_GATE_ID_P2P_INITIATOR, MICROREAD_PIPE_ID_HDS_P2P_INITIATOR}
0147 };
0148 
0149 /* Largest headroom needed for outgoing custom commands */
0150 #define MICROREAD_CMDS_HEADROOM 2
0151 #define MICROREAD_CMD_TAILROOM  2
0152 
0153 struct microread_info {
0154     const struct nfc_phy_ops *phy_ops;
0155     void *phy_id;
0156 
0157     struct nfc_hci_dev *hdev;
0158 
0159     int async_cb_type;
0160     data_exchange_cb_t async_cb;
0161     void *async_cb_context;
0162 };
0163 
0164 static int microread_open(struct nfc_hci_dev *hdev)
0165 {
0166     struct microread_info *info = nfc_hci_get_clientdata(hdev);
0167 
0168     return info->phy_ops->enable(info->phy_id);
0169 }
0170 
0171 static void microread_close(struct nfc_hci_dev *hdev)
0172 {
0173     struct microread_info *info = nfc_hci_get_clientdata(hdev);
0174 
0175     info->phy_ops->disable(info->phy_id);
0176 }
0177 
0178 static int microread_hci_ready(struct nfc_hci_dev *hdev)
0179 {
0180     int r;
0181     u8 param[4];
0182 
0183     param[0] = 0x03;
0184     r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
0185                  MICROREAD_CMD_MREAD_SUBSCRIBE, param, 1, NULL);
0186     if (r)
0187         return r;
0188 
0189     r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A_3,
0190                  MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
0191     if (r)
0192         return r;
0193 
0194     param[0] = 0x00;
0195     param[1] = 0x03;
0196     param[2] = 0x00;
0197     r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_B,
0198                  MICROREAD_CMD_MREAD_SUBSCRIBE, param, 3, NULL);
0199     if (r)
0200         return r;
0201 
0202     r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T1,
0203                  MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
0204     if (r)
0205         return r;
0206 
0207     param[0] = 0xFF;
0208     param[1] = 0xFF;
0209     param[2] = 0x00;
0210     param[3] = 0x00;
0211     r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T3,
0212                  MICROREAD_CMD_MREAD_SUBSCRIBE, param, 4, NULL);
0213 
0214     return r;
0215 }
0216 
0217 static int microread_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
0218 {
0219     struct microread_info *info = nfc_hci_get_clientdata(hdev);
0220 
0221     return info->phy_ops->write(info->phy_id, skb);
0222 }
0223 
0224 static int microread_start_poll(struct nfc_hci_dev *hdev,
0225                 u32 im_protocols, u32 tm_protocols)
0226 {
0227     int r;
0228 
0229     u8 param[2];
0230     u8 mode;
0231 
0232     param[0] = 0x00;
0233     param[1] = 0x00;
0234 
0235     if (im_protocols & NFC_PROTO_ISO14443_MASK)
0236         param[0] |= (1 << 2);
0237 
0238     if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
0239         param[0] |= 1;
0240 
0241     if (im_protocols & NFC_PROTO_MIFARE_MASK)
0242         param[1] |= 1;
0243 
0244     if (im_protocols & NFC_PROTO_JEWEL_MASK)
0245         param[0] |= (1 << 1);
0246 
0247     if (im_protocols & NFC_PROTO_FELICA_MASK)
0248         param[0] |= (1 << 5);
0249 
0250     if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
0251         param[1] |= (1 << 1);
0252 
0253     if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
0254         hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
0255                                &hdev->gb_len);
0256         if (hdev->gb == NULL || hdev->gb_len == 0) {
0257             im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
0258             tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
0259         }
0260     }
0261 
0262     r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
0263                    MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
0264     if (r)
0265         return r;
0266 
0267     mode = 0xff;
0268     r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
0269                   MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
0270     if (r)
0271         return r;
0272 
0273     if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
0274         r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
0275                       MICROREAD_PAR_P2P_INITIATOR_GI,
0276                       hdev->gb, hdev->gb_len);
0277         if (r)
0278             return r;
0279     }
0280 
0281     if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
0282         r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
0283                       MICROREAD_PAR_P2P_TARGET_GT,
0284                       hdev->gb, hdev->gb_len);
0285         if (r)
0286             return r;
0287 
0288         mode = 0x02;
0289         r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
0290                       MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
0291         if (r)
0292             return r;
0293     }
0294 
0295     return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
0296                   MICROREAD_EVT_MREAD_DISCOVERY_START_SOME,
0297                   param, 2);
0298 }
0299 
0300 static int microread_dep_link_up(struct nfc_hci_dev *hdev,
0301                 struct nfc_target *target, u8 comm_mode,
0302                 u8 *gb, size_t gb_len)
0303 {
0304     struct sk_buff *rgb_skb = NULL;
0305     int r;
0306 
0307     r = nfc_hci_get_param(hdev, target->hci_reader_gate,
0308                   MICROREAD_PAR_P2P_INITIATOR_GT, &rgb_skb);
0309     if (r < 0)
0310         return r;
0311 
0312     if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
0313         r = -EPROTO;
0314         goto exit;
0315     }
0316 
0317     r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
0318                      rgb_skb->len);
0319     if (r == 0)
0320         r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
0321                        NFC_RF_INITIATOR);
0322 exit:
0323     kfree_skb(rgb_skb);
0324 
0325     return r;
0326 }
0327 
0328 static int microread_dep_link_down(struct nfc_hci_dev *hdev)
0329 {
0330     return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
0331                   MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
0332 }
0333 
0334 static int microread_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
0335                       struct nfc_target *target)
0336 {
0337     switch (gate) {
0338     case MICROREAD_GATE_ID_P2P_INITIATOR:
0339         target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
0340         break;
0341     default:
0342         return -EPROTO;
0343     }
0344 
0345     return 0;
0346 }
0347 
0348 static int microread_complete_target_discovered(struct nfc_hci_dev *hdev,
0349                         u8 gate,
0350                         struct nfc_target *target)
0351 {
0352     return 0;
0353 }
0354 
0355 #define MICROREAD_CB_TYPE_READER_ALL 1
0356 
0357 static void microread_im_transceive_cb(void *context, struct sk_buff *skb,
0358                        int err)
0359 {
0360     const struct microread_info *info = context;
0361 
0362     switch (info->async_cb_type) {
0363     case MICROREAD_CB_TYPE_READER_ALL:
0364         if (err == 0) {
0365             if (skb->len == 0) {
0366                 kfree_skb(skb);
0367                 info->async_cb(info->async_cb_context, NULL,
0368                            -EPROTO);
0369                 return;
0370             }
0371 
0372             if (skb->data[skb->len - 1] != 0) {
0373                 err = nfc_hci_result_to_errno(
0374                                skb->data[skb->len - 1]);
0375                 kfree_skb(skb);
0376                 info->async_cb(info->async_cb_context, NULL,
0377                            err);
0378                 return;
0379             }
0380 
0381             skb_trim(skb, skb->len - 1);    /* RF Error ind. */
0382         }
0383         info->async_cb(info->async_cb_context, skb, err);
0384         break;
0385     default:
0386         if (err == 0)
0387             kfree_skb(skb);
0388         break;
0389     }
0390 }
0391 
0392 /*
0393  * Returns:
0394  * <= 0: driver handled the data exchange
0395  *    1: driver doesn't especially handle, please do standard processing
0396  */
0397 static int microread_im_transceive(struct nfc_hci_dev *hdev,
0398                    struct nfc_target *target,
0399                    struct sk_buff *skb, data_exchange_cb_t cb,
0400                    void *cb_context)
0401 {
0402     struct microread_info *info = nfc_hci_get_clientdata(hdev);
0403     u8 control_bits;
0404     u16 crc;
0405 
0406     pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate);
0407 
0408     if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) {
0409         *(u8 *)skb_push(skb, 1) = 0;
0410 
0411         return nfc_hci_send_event(hdev, target->hci_reader_gate,
0412                      MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF,
0413                      skb->data, skb->len);
0414     }
0415 
0416     switch (target->hci_reader_gate) {
0417     case MICROREAD_GATE_ID_MREAD_ISO_A:
0418         control_bits = 0xCB;
0419         break;
0420     case MICROREAD_GATE_ID_MREAD_ISO_A_3:
0421         control_bits = 0xCB;
0422         break;
0423     case MICROREAD_GATE_ID_MREAD_ISO_B:
0424         control_bits = 0xCB;
0425         break;
0426     case MICROREAD_GATE_ID_MREAD_NFC_T1:
0427         control_bits = 0x1B;
0428 
0429         crc = crc_ccitt(0xffff, skb->data, skb->len);
0430         crc = ~crc;
0431         skb_put_u8(skb, crc & 0xff);
0432         skb_put_u8(skb, crc >> 8);
0433         break;
0434     case MICROREAD_GATE_ID_MREAD_NFC_T3:
0435         control_bits = 0xDB;
0436         break;
0437     default:
0438         pr_info("Abort im_transceive to invalid gate 0x%x\n",
0439             target->hci_reader_gate);
0440         return 1;
0441     }
0442 
0443     *(u8 *)skb_push(skb, 1) = control_bits;
0444 
0445     info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL;
0446     info->async_cb = cb;
0447     info->async_cb_context = cb_context;
0448 
0449     return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
0450                       MICROREAD_CMD_MREAD_EXCHANGE,
0451                       skb->data, skb->len,
0452                       microread_im_transceive_cb, info);
0453 }
0454 
0455 static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
0456 {
0457     int r;
0458 
0459     r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET,
0460                    MICROREAD_EVT_MCARD_EXCHANGE,
0461                    skb->data, skb->len);
0462 
0463     kfree_skb(skb);
0464 
0465     return r;
0466 }
0467 
0468 static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate,
0469                     struct sk_buff *skb)
0470 {
0471     struct nfc_target *targets;
0472     int r = 0;
0473 
0474     pr_info("target discovered to gate 0x%x\n", gate);
0475 
0476     targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
0477     if (targets == NULL) {
0478         r = -ENOMEM;
0479         goto exit;
0480     }
0481 
0482     targets->hci_reader_gate = gate;
0483 
0484     switch (gate) {
0485     case MICROREAD_GATE_ID_MREAD_ISO_A:
0486         targets->supported_protocols =
0487               nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]);
0488         targets->sens_res =
0489              be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]);
0490         targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK];
0491         targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN];
0492         if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
0493             r = -EINVAL;
0494             goto exit_free;
0495         }
0496         memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID],
0497                targets->nfcid1_len);
0498         break;
0499     case MICROREAD_GATE_ID_MREAD_ISO_A_3:
0500         targets->supported_protocols =
0501               nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]);
0502         targets->sens_res =
0503              be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]);
0504         targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK];
0505         targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN];
0506         if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
0507             r = -EINVAL;
0508             goto exit_free;
0509         }
0510         memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID],
0511                targets->nfcid1_len);
0512         break;
0513     case MICROREAD_GATE_ID_MREAD_ISO_B:
0514         targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
0515         memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4);
0516         targets->nfcid1_len = 4;
0517         break;
0518     case MICROREAD_GATE_ID_MREAD_NFC_T1:
0519         targets->supported_protocols = NFC_PROTO_JEWEL_MASK;
0520         targets->sens_res =
0521             le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]);
0522         memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4);
0523         targets->nfcid1_len = 4;
0524         break;
0525     case MICROREAD_GATE_ID_MREAD_NFC_T3:
0526         targets->supported_protocols = NFC_PROTO_FELICA_MASK;
0527         memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8);
0528         targets->nfcid1_len = 8;
0529         break;
0530     default:
0531         pr_info("discard target discovered to gate 0x%x\n", gate);
0532         goto exit_free;
0533     }
0534 
0535     r = nfc_targets_found(hdev->ndev, targets, 1);
0536 
0537 exit_free:
0538     kfree(targets);
0539 
0540 exit:
0541     kfree_skb(skb);
0542 
0543     if (r)
0544         pr_err("Failed to handle discovered target err=%d\n", r);
0545 }
0546 
0547 static int microread_event_received(struct nfc_hci_dev *hdev, u8 pipe,
0548                      u8 event, struct sk_buff *skb)
0549 {
0550     int r;
0551     u8 gate = hdev->pipes[pipe].gate;
0552     u8 mode;
0553 
0554     pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate);
0555 
0556     switch (event) {
0557     case MICROREAD_EVT_MREAD_CARD_FOUND:
0558         microread_target_discovered(hdev, gate, skb);
0559         return 0;
0560 
0561     case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF:
0562         if (skb->len < 1) {
0563             kfree_skb(skb);
0564             return -EPROTO;
0565         }
0566 
0567         if (skb->data[skb->len - 1]) {
0568             kfree_skb(skb);
0569             return -EIO;
0570         }
0571 
0572         skb_trim(skb, skb->len - 1);
0573 
0574         r = nfc_tm_data_received(hdev->ndev, skb);
0575         break;
0576 
0577     case MICROREAD_EVT_MCARD_FIELD_ON:
0578     case MICROREAD_EVT_MCARD_FIELD_OFF:
0579         kfree_skb(skb);
0580         return 0;
0581 
0582     case MICROREAD_EVT_P2P_TARGET_ACTIVATED:
0583         r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
0584                      NFC_COMM_PASSIVE, skb->data,
0585                      skb->len);
0586 
0587         kfree_skb(skb);
0588         break;
0589 
0590     case MICROREAD_EVT_MCARD_EXCHANGE:
0591         if (skb->len < 1) {
0592             kfree_skb(skb);
0593             return -EPROTO;
0594         }
0595 
0596         if (skb->data[skb->len-1]) {
0597             kfree_skb(skb);
0598             return -EIO;
0599         }
0600 
0601         skb_trim(skb, skb->len - 1);
0602 
0603         r = nfc_tm_data_received(hdev->ndev, skb);
0604         break;
0605 
0606     case MICROREAD_EVT_P2P_TARGET_DEACTIVATED:
0607         kfree_skb(skb);
0608 
0609         mode = 0xff;
0610         r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
0611                       MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
0612         if (r)
0613             break;
0614 
0615         r = nfc_hci_send_event(hdev, gate,
0616                        MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL,
0617                        0);
0618         break;
0619 
0620     default:
0621         return 1;
0622     }
0623 
0624     return r;
0625 }
0626 
0627 static const struct nfc_hci_ops microread_hci_ops = {
0628     .open = microread_open,
0629     .close = microread_close,
0630     .hci_ready = microread_hci_ready,
0631     .xmit = microread_xmit,
0632     .start_poll = microread_start_poll,
0633     .dep_link_up = microread_dep_link_up,
0634     .dep_link_down = microread_dep_link_down,
0635     .target_from_gate = microread_target_from_gate,
0636     .complete_target_discovered = microread_complete_target_discovered,
0637     .im_transceive = microread_im_transceive,
0638     .tm_send = microread_tm_send,
0639     .check_presence = NULL,
0640     .event_received = microread_event_received,
0641 };
0642 
0643 int microread_probe(void *phy_id, const struct nfc_phy_ops *phy_ops,
0644             const char *llc_name, int phy_headroom, int phy_tailroom,
0645             int phy_payload, struct nfc_hci_dev **hdev)
0646 {
0647     struct microread_info *info;
0648     unsigned long quirks = 0;
0649     u32 protocols;
0650     struct nfc_hci_init_data init_data;
0651     int r;
0652 
0653     info = kzalloc(sizeof(struct microread_info), GFP_KERNEL);
0654     if (!info) {
0655         r = -ENOMEM;
0656         goto err_info_alloc;
0657     }
0658 
0659     info->phy_ops = phy_ops;
0660     info->phy_id = phy_id;
0661 
0662     init_data.gate_count = ARRAY_SIZE(microread_gates);
0663     memcpy(init_data.gates, microread_gates, sizeof(microread_gates));
0664 
0665     strcpy(init_data.session_id, "MICROREA");
0666 
0667     set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
0668 
0669     protocols = NFC_PROTO_JEWEL_MASK |
0670             NFC_PROTO_MIFARE_MASK |
0671             NFC_PROTO_FELICA_MASK |
0672             NFC_PROTO_ISO14443_MASK |
0673             NFC_PROTO_ISO14443_B_MASK |
0674             NFC_PROTO_NFC_DEP_MASK;
0675 
0676     info->hdev = nfc_hci_allocate_device(&microread_hci_ops, &init_data,
0677                          quirks, protocols, llc_name,
0678                          phy_headroom +
0679                          MICROREAD_CMDS_HEADROOM,
0680                          phy_tailroom +
0681                          MICROREAD_CMD_TAILROOM,
0682                          phy_payload);
0683     if (!info->hdev) {
0684         pr_err("Cannot allocate nfc hdev\n");
0685         r = -ENOMEM;
0686         goto err_alloc_hdev;
0687     }
0688 
0689     nfc_hci_set_clientdata(info->hdev, info);
0690 
0691     r = nfc_hci_register_device(info->hdev);
0692     if (r)
0693         goto err_regdev;
0694 
0695     *hdev = info->hdev;
0696 
0697     return 0;
0698 
0699 err_regdev:
0700     nfc_hci_free_device(info->hdev);
0701 
0702 err_alloc_hdev:
0703     kfree(info);
0704 
0705 err_info_alloc:
0706     return r;
0707 }
0708 EXPORT_SYMBOL(microread_probe);
0709 
0710 void microread_remove(struct nfc_hci_dev *hdev)
0711 {
0712     struct microread_info *info = nfc_hci_get_clientdata(hdev);
0713 
0714     nfc_hci_unregister_device(hdev);
0715     nfc_hci_free_device(hdev);
0716     kfree(info);
0717 }
0718 EXPORT_SYMBOL(microread_remove);
0719 
0720 MODULE_LICENSE("GPL");
0721 MODULE_DESCRIPTION(DRIVER_DESC);
[ 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!