Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * NFC Digital Protocol stack
0004  * Copyright (c) 2013, Intel Corporation.
0005  */
0006 
0007 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
0008 
0009 #include "digital.h"
0010 
0011 #define DIGITAL_NFC_DEP_N_RETRY_NACK    2
0012 #define DIGITAL_NFC_DEP_N_RETRY_ATN 2
0013 
0014 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
0015 #define DIGITAL_NFC_DEP_FRAME_DIR_IN  0xD5
0016 
0017 #define DIGITAL_NFC_DEP_NFCA_SOD_SB   0xF0
0018 
0019 #define DIGITAL_CMD_ATR_REQ 0x00
0020 #define DIGITAL_CMD_ATR_RES 0x01
0021 #define DIGITAL_CMD_PSL_REQ 0x04
0022 #define DIGITAL_CMD_PSL_RES 0x05
0023 #define DIGITAL_CMD_DEP_REQ 0x06
0024 #define DIGITAL_CMD_DEP_RES 0x07
0025 
0026 #define DIGITAL_ATR_REQ_MIN_SIZE 16
0027 #define DIGITAL_ATR_REQ_MAX_SIZE 64
0028 
0029 #define DIGITAL_ATR_RES_TO_WT(s)    ((s) & 0xF)
0030 
0031 #define DIGITAL_DID_MAX 14
0032 
0033 #define DIGITAL_PAYLOAD_SIZE_MAX    254
0034 #define DIGITAL_PAYLOAD_BITS_TO_PP(s)   (((s) & 0x3) << 4)
0035 #define DIGITAL_PAYLOAD_PP_TO_BITS(s)   (((s) >> 4) & 0x3)
0036 #define DIGITAL_PAYLOAD_BITS_TO_FSL(s)  ((s) & 0x3)
0037 #define DIGITAL_PAYLOAD_FSL_TO_BITS(s)  ((s) & 0x3)
0038 
0039 #define DIGITAL_GB_BIT  0x02
0040 
0041 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
0042 
0043 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
0044 #define DIGITAL_NFC_DEP_PFB_MI_BIT  0x10
0045 #define DIGITAL_NFC_DEP_PFB_NACK_BIT    0x10
0046 #define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04
0047 
0048 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
0049                 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
0050 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb)  ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT)
0051 #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT)
0052 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
0053 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
0054 #define DIGITAL_NFC_DEP_PFB_PNI(pfb)     ((pfb) & 0x03)
0055 
0056 #define DIGITAL_NFC_DEP_RTOX_VALUE(data) ((data) & 0x3F)
0057 #define DIGITAL_NFC_DEP_RTOX_MAX     59
0058 
0059 #define DIGITAL_NFC_DEP_PFB_I_PDU          0x00
0060 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU   0x40
0061 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
0062 
0063 struct digital_atr_req {
0064     u8 dir;
0065     u8 cmd;
0066     u8 nfcid3[10];
0067     u8 did;
0068     u8 bs;
0069     u8 br;
0070     u8 pp;
0071     u8 gb[];
0072 } __packed;
0073 
0074 struct digital_atr_res {
0075     u8 dir;
0076     u8 cmd;
0077     u8 nfcid3[10];
0078     u8 did;
0079     u8 bs;
0080     u8 br;
0081     u8 to;
0082     u8 pp;
0083     u8 gb[];
0084 } __packed;
0085 
0086 struct digital_psl_req {
0087     u8 dir;
0088     u8 cmd;
0089     u8 did;
0090     u8 brs;
0091     u8 fsl;
0092 } __packed;
0093 
0094 struct digital_psl_res {
0095     u8 dir;
0096     u8 cmd;
0097     u8 did;
0098 } __packed;
0099 
0100 struct digital_dep_req_res {
0101     u8 dir;
0102     u8 cmd;
0103     u8 pfb;
0104 } __packed;
0105 
0106 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
0107                     struct sk_buff *resp);
0108 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
0109                     struct sk_buff *resp);
0110 
0111 static const u8 digital_payload_bits_map[4] = {
0112     [0] = 64,
0113     [1] = 128,
0114     [2] = 192,
0115     [3] = 254
0116 };
0117 
0118 /* Response Waiting Time for ATR_RES PDU in ms
0119  *
0120  * RWT(ATR_RES) = RWT(nfcdep,activation) + dRWT(nfcdep) + dT(nfcdep,initiator)
0121  *
0122  * with:
0123  *  RWT(nfcdep,activation) = 4096 * 2^12 / f(c) s
0124  *  dRWT(nfcdep) = 16 / f(c) s
0125  *  dT(nfcdep,initiator) = 100 ms
0126  *  f(c) = 13560000 Hz
0127  */
0128 #define DIGITAL_ATR_RES_RWT 1337
0129 
0130 /* Response Waiting Time for other DEP PDUs in ms
0131  *
0132  * max_rwt = rwt + dRWT(nfcdep) + dT(nfcdep,initiator)
0133  *
0134  * with:
0135  *  rwt = (256 * 16 / f(c)) * 2^wt s
0136  *  dRWT(nfcdep) = 16 / f(c) s
0137  *  dT(nfcdep,initiator) = 100 ms
0138  *  f(c) = 13560000 Hz
0139  *  0 <= wt <= 14 (given by the target by the TO field of ATR_RES response)
0140  */
0141 #define DIGITAL_NFC_DEP_IN_MAX_WT 14
0142 #define DIGITAL_NFC_DEP_TG_MAX_WT 14
0143 static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = {
0144     100,  101,  101,  102,  105,
0145     110,  119,  139,  177,  255,
0146     409,  719, 1337, 2575, 5049,
0147 };
0148 
0149 static u8 digital_payload_bits_to_size(u8 payload_bits)
0150 {
0151     if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
0152         return 0;
0153 
0154     return digital_payload_bits_map[payload_bits];
0155 }
0156 
0157 static u8 digital_payload_size_to_bits(u8 payload_size)
0158 {
0159     int i;
0160 
0161     for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
0162         if (digital_payload_bits_map[i] == payload_size)
0163             return i;
0164 
0165     return 0xff;
0166 }
0167 
0168 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
0169                      struct sk_buff *skb)
0170 {
0171     skb_push(skb, sizeof(u8));
0172 
0173     skb->data[0] = skb->len;
0174 
0175     if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
0176         *(u8 *)skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
0177 }
0178 
0179 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
0180                     struct sk_buff *skb)
0181 {
0182     u8 size;
0183 
0184     if (skb->len < 2)
0185         return -EIO;
0186 
0187     if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
0188         skb_pull(skb, sizeof(u8));
0189 
0190     size = skb->data[0];
0191     if (size != skb->len)
0192         return -EIO;
0193 
0194     skb_pull(skb, sizeof(u8));
0195 
0196     return 0;
0197 }
0198 
0199 static struct sk_buff *
0200 digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb,
0201                struct digital_dep_req_res *dep_req_res,
0202                struct digital_data_exch *data_exch)
0203 {
0204     struct sk_buff *new_skb;
0205 
0206     if (skb->len > ddev->remote_payload_max) {
0207         dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
0208 
0209         new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
0210         if (!new_skb) {
0211             kfree_skb(ddev->chaining_skb);
0212             ddev->chaining_skb = NULL;
0213 
0214             return ERR_PTR(-ENOMEM);
0215         }
0216 
0217         skb_put_data(new_skb, skb->data, ddev->remote_payload_max);
0218         skb_pull(skb, ddev->remote_payload_max);
0219 
0220         ddev->chaining_skb = skb;
0221         ddev->data_exch = data_exch;
0222     } else {
0223         ddev->chaining_skb = NULL;
0224         new_skb = skb;
0225     }
0226 
0227     return new_skb;
0228 }
0229 
0230 static struct sk_buff *
0231 digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb,
0232                  struct sk_buff *resp,
0233                  int (*send_ack)(struct nfc_digital_dev *ddev,
0234                          struct digital_data_exch
0235                                  *data_exch),
0236                  struct digital_data_exch *data_exch)
0237 {
0238     struct sk_buff *new_skb;
0239     int rc;
0240 
0241     if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
0242         ddev->chaining_skb =
0243             nfc_alloc_recv_skb(8 * ddev->local_payload_max,
0244                        GFP_KERNEL);
0245         if (!ddev->chaining_skb) {
0246             rc = -ENOMEM;
0247             goto error;
0248         }
0249     }
0250 
0251     if (ddev->chaining_skb) {
0252         if (resp->len > skb_tailroom(ddev->chaining_skb)) {
0253             new_skb = skb_copy_expand(ddev->chaining_skb,
0254                           skb_headroom(
0255                               ddev->chaining_skb),
0256                           8 * ddev->local_payload_max,
0257                           GFP_KERNEL);
0258             if (!new_skb) {
0259                 rc = -ENOMEM;
0260                 goto error;
0261             }
0262 
0263             kfree_skb(ddev->chaining_skb);
0264             ddev->chaining_skb = new_skb;
0265         }
0266 
0267         skb_put_data(ddev->chaining_skb, resp->data, resp->len);
0268 
0269         kfree_skb(resp);
0270         resp = NULL;
0271 
0272         if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
0273             rc = send_ack(ddev, data_exch);
0274             if (rc)
0275                 goto error;
0276 
0277             return NULL;
0278         }
0279 
0280         resp = ddev->chaining_skb;
0281         ddev->chaining_skb = NULL;
0282     }
0283 
0284     return resp;
0285 
0286 error:
0287     kfree_skb(resp);
0288 
0289     kfree_skb(ddev->chaining_skb);
0290     ddev->chaining_skb = NULL;
0291 
0292     return ERR_PTR(rc);
0293 }
0294 
0295 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
0296                     struct sk_buff *resp)
0297 {
0298     struct nfc_target *target = arg;
0299     struct digital_psl_res *psl_res;
0300     int rc;
0301 
0302     if (IS_ERR(resp)) {
0303         rc = PTR_ERR(resp);
0304         resp = NULL;
0305         goto exit;
0306     }
0307 
0308     rc = ddev->skb_check_crc(resp);
0309     if (rc) {
0310         PROTOCOL_ERR("14.4.1.6");
0311         goto exit;
0312     }
0313 
0314     rc = digital_skb_pull_dep_sod(ddev, resp);
0315     if (rc) {
0316         PROTOCOL_ERR("14.4.1.2");
0317         goto exit;
0318     }
0319 
0320     psl_res = (struct digital_psl_res *)resp->data;
0321 
0322     if ((resp->len != sizeof(*psl_res)) ||
0323         (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
0324         (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
0325         rc = -EIO;
0326         goto exit;
0327     }
0328 
0329     rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
0330                      NFC_DIGITAL_RF_TECH_424F);
0331     if (rc)
0332         goto exit;
0333 
0334     rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
0335                      NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
0336     if (rc)
0337         goto exit;
0338 
0339     if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
0340         (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
0341         ddev->skb_add_crc = digital_skb_add_crc_f;
0342         ddev->skb_check_crc = digital_skb_check_crc_f;
0343     }
0344 
0345     ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
0346 
0347     nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
0348                NFC_RF_INITIATOR);
0349 
0350     ddev->curr_nfc_dep_pni = 0;
0351 
0352 exit:
0353     dev_kfree_skb(resp);
0354 
0355     if (rc)
0356         ddev->curr_protocol = 0;
0357 }
0358 
0359 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
0360                    struct nfc_target *target)
0361 {
0362     struct sk_buff *skb;
0363     struct digital_psl_req *psl_req;
0364     int rc;
0365     u8 payload_size, payload_bits;
0366 
0367     skb = digital_skb_alloc(ddev, sizeof(*psl_req));
0368     if (!skb)
0369         return -ENOMEM;
0370 
0371     skb_put(skb, sizeof(*psl_req));
0372 
0373     psl_req = (struct digital_psl_req *)skb->data;
0374 
0375     psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0376     psl_req->cmd = DIGITAL_CMD_PSL_REQ;
0377     psl_req->did = 0;
0378     psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
0379 
0380     payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
0381     payload_bits = digital_payload_size_to_bits(payload_size);
0382     psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
0383 
0384     ddev->local_payload_max = payload_size;
0385     ddev->remote_payload_max = payload_size;
0386 
0387     digital_skb_push_dep_sod(ddev, skb);
0388 
0389     ddev->skb_add_crc(skb);
0390 
0391     rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
0392                  digital_in_recv_psl_res, target);
0393     if (rc)
0394         kfree_skb(skb);
0395 
0396     return rc;
0397 }
0398 
0399 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
0400                  struct sk_buff *resp)
0401 {
0402     struct nfc_target *target = arg;
0403     struct digital_atr_res *atr_res;
0404     u8 gb_len, payload_bits;
0405     u8 wt;
0406     int rc;
0407 
0408     if (IS_ERR(resp)) {
0409         rc = PTR_ERR(resp);
0410         resp = NULL;
0411         goto exit;
0412     }
0413 
0414     rc = ddev->skb_check_crc(resp);
0415     if (rc) {
0416         PROTOCOL_ERR("14.4.1.6");
0417         goto exit;
0418     }
0419 
0420     rc = digital_skb_pull_dep_sod(ddev, resp);
0421     if (rc) {
0422         PROTOCOL_ERR("14.4.1.2");
0423         goto exit;
0424     }
0425 
0426     if (resp->len < sizeof(struct digital_atr_res)) {
0427         rc = -EIO;
0428         goto exit;
0429     }
0430 
0431     gb_len = resp->len - sizeof(struct digital_atr_res);
0432 
0433     atr_res = (struct digital_atr_res *)resp->data;
0434 
0435     wt = DIGITAL_ATR_RES_TO_WT(atr_res->to);
0436     if (wt > DIGITAL_NFC_DEP_IN_MAX_WT)
0437         wt = DIGITAL_NFC_DEP_IN_MAX_WT;
0438     ddev->dep_rwt = digital_rwt_map[wt];
0439 
0440     payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
0441     ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
0442 
0443     if (!ddev->remote_payload_max) {
0444         rc = -EINVAL;
0445         goto exit;
0446     }
0447 
0448     rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
0449     if (rc)
0450         goto exit;
0451 
0452     if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
0453         (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
0454         rc = digital_in_send_psl_req(ddev, target);
0455         if (!rc)
0456             goto exit;
0457     }
0458 
0459     rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
0460                 NFC_RF_INITIATOR);
0461 
0462     ddev->curr_nfc_dep_pni = 0;
0463 
0464 exit:
0465     dev_kfree_skb(resp);
0466 
0467     if (rc)
0468         ddev->curr_protocol = 0;
0469 }
0470 
0471 int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
0472                 struct nfc_target *target, __u8 comm_mode, __u8 *gb,
0473                 size_t gb_len)
0474 {
0475     struct sk_buff *skb;
0476     struct digital_atr_req *atr_req;
0477     uint size;
0478     int rc;
0479     u8 payload_bits;
0480 
0481     size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
0482 
0483     if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
0484         PROTOCOL_ERR("14.6.1.1");
0485         return -EINVAL;
0486     }
0487 
0488     skb = digital_skb_alloc(ddev, size);
0489     if (!skb)
0490         return -ENOMEM;
0491 
0492     skb_put(skb, sizeof(struct digital_atr_req));
0493 
0494     atr_req = (struct digital_atr_req *)skb->data;
0495     memset(atr_req, 0, sizeof(struct digital_atr_req));
0496 
0497     atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0498     atr_req->cmd = DIGITAL_CMD_ATR_REQ;
0499     if (target->nfcid2_len)
0500         memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
0501     else
0502         get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
0503 
0504     atr_req->did = 0;
0505     atr_req->bs = 0;
0506     atr_req->br = 0;
0507 
0508     ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
0509     payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
0510     atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
0511 
0512     if (gb_len) {
0513         atr_req->pp |= DIGITAL_GB_BIT;
0514         skb_put_data(skb, gb, gb_len);
0515     }
0516 
0517     digital_skb_push_dep_sod(ddev, skb);
0518 
0519     ddev->skb_add_crc(skb);
0520 
0521     rc = digital_in_send_cmd(ddev, skb, DIGITAL_ATR_RES_RWT,
0522                  digital_in_recv_atr_res, target);
0523     if (rc)
0524         kfree_skb(skb);
0525 
0526     return rc;
0527 }
0528 
0529 static int digital_in_send_ack(struct nfc_digital_dev *ddev,
0530                    struct digital_data_exch *data_exch)
0531 {
0532     struct digital_dep_req_res *dep_req;
0533     struct sk_buff *skb;
0534     int rc;
0535 
0536     skb = digital_skb_alloc(ddev, 1);
0537     if (!skb)
0538         return -ENOMEM;
0539 
0540     skb_push(skb, sizeof(struct digital_dep_req_res));
0541 
0542     dep_req = (struct digital_dep_req_res *)skb->data;
0543 
0544     dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0545     dep_req->cmd = DIGITAL_CMD_DEP_REQ;
0546     dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
0547                ddev->curr_nfc_dep_pni;
0548 
0549     digital_skb_push_dep_sod(ddev, skb);
0550 
0551     ddev->skb_add_crc(skb);
0552 
0553     ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
0554 
0555     rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
0556                  digital_in_recv_dep_res, data_exch);
0557     if (rc) {
0558         kfree_skb(skb);
0559         kfree_skb(ddev->saved_skb);
0560         ddev->saved_skb = NULL;
0561     }
0562 
0563     return rc;
0564 }
0565 
0566 static int digital_in_send_nack(struct nfc_digital_dev *ddev,
0567                 struct digital_data_exch *data_exch)
0568 {
0569     struct digital_dep_req_res *dep_req;
0570     struct sk_buff *skb;
0571     int rc;
0572 
0573     skb = digital_skb_alloc(ddev, 1);
0574     if (!skb)
0575         return -ENOMEM;
0576 
0577     skb_push(skb, sizeof(struct digital_dep_req_res));
0578 
0579     dep_req = (struct digital_dep_req_res *)skb->data;
0580 
0581     dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0582     dep_req->cmd = DIGITAL_CMD_DEP_REQ;
0583     dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
0584                DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni;
0585 
0586     digital_skb_push_dep_sod(ddev, skb);
0587 
0588     ddev->skb_add_crc(skb);
0589 
0590     rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
0591                  digital_in_recv_dep_res, data_exch);
0592     if (rc)
0593         kfree_skb(skb);
0594 
0595     return rc;
0596 }
0597 
0598 static int digital_in_send_atn(struct nfc_digital_dev *ddev,
0599                    struct digital_data_exch *data_exch)
0600 {
0601     struct digital_dep_req_res *dep_req;
0602     struct sk_buff *skb;
0603     int rc;
0604 
0605     skb = digital_skb_alloc(ddev, 1);
0606     if (!skb)
0607         return -ENOMEM;
0608 
0609     skb_push(skb, sizeof(struct digital_dep_req_res));
0610 
0611     dep_req = (struct digital_dep_req_res *)skb->data;
0612 
0613     dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0614     dep_req->cmd = DIGITAL_CMD_DEP_REQ;
0615     dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
0616 
0617     digital_skb_push_dep_sod(ddev, skb);
0618 
0619     ddev->skb_add_crc(skb);
0620 
0621     rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
0622                  digital_in_recv_dep_res, data_exch);
0623     if (rc)
0624         kfree_skb(skb);
0625 
0626     return rc;
0627 }
0628 
0629 static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
0630                 struct digital_data_exch *data_exch, u8 rtox)
0631 {
0632     struct digital_dep_req_res *dep_req;
0633     struct sk_buff *skb;
0634     int rc;
0635     u16 rwt_int;
0636 
0637     rwt_int = ddev->dep_rwt * rtox;
0638     if (rwt_int > digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT])
0639         rwt_int = digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT];
0640 
0641     skb = digital_skb_alloc(ddev, 1);
0642     if (!skb)
0643         return -ENOMEM;
0644 
0645     skb_put_u8(skb, rtox);
0646 
0647     skb_push(skb, sizeof(struct digital_dep_req_res));
0648 
0649     dep_req = (struct digital_dep_req_res *)skb->data;
0650 
0651     dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0652     dep_req->cmd = DIGITAL_CMD_DEP_REQ;
0653     dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
0654                DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
0655 
0656     digital_skb_push_dep_sod(ddev, skb);
0657 
0658     ddev->skb_add_crc(skb);
0659 
0660     rc = digital_in_send_cmd(ddev, skb, rwt_int,
0661                  digital_in_recv_dep_res, data_exch);
0662     if (rc)
0663         kfree_skb(skb);
0664 
0665     return rc;
0666 }
0667 
0668 static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev,
0669                      struct digital_data_exch *data_exch)
0670 {
0671     int rc;
0672 
0673     if (!ddev->saved_skb)
0674         return -EINVAL;
0675 
0676     skb_get(ddev->saved_skb);
0677 
0678     rc = digital_in_send_cmd(ddev, ddev->saved_skb, ddev->dep_rwt,
0679                  digital_in_recv_dep_res, data_exch);
0680     if (rc)
0681         kfree_skb(ddev->saved_skb);
0682 
0683     return rc;
0684 }
0685 
0686 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
0687                     struct sk_buff *resp)
0688 {
0689     struct digital_data_exch *data_exch = arg;
0690     struct digital_dep_req_res *dep_res;
0691     u8 pfb;
0692     uint size;
0693     int rc;
0694     u8 rtox;
0695 
0696     if (IS_ERR(resp)) {
0697         rc = PTR_ERR(resp);
0698         resp = NULL;
0699 
0700         if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) &&
0701             (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
0702             ddev->atn_count = 0;
0703 
0704             rc = digital_in_send_nack(ddev, data_exch);
0705             if (rc)
0706                 goto error;
0707 
0708             return;
0709         } else if ((rc == -ETIMEDOUT) &&
0710                (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) {
0711             ddev->nack_count = 0;
0712 
0713             rc = digital_in_send_atn(ddev, data_exch);
0714             if (rc)
0715                 goto error;
0716 
0717             return;
0718         }
0719 
0720         goto exit;
0721     }
0722 
0723     rc = digital_skb_pull_dep_sod(ddev, resp);
0724     if (rc) {
0725         PROTOCOL_ERR("14.4.1.2");
0726         goto exit;
0727     }
0728 
0729     rc = ddev->skb_check_crc(resp);
0730     if (rc) {
0731         if ((resp->len >= 4) &&
0732             (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
0733             ddev->atn_count = 0;
0734 
0735             rc = digital_in_send_nack(ddev, data_exch);
0736             if (rc)
0737                 goto error;
0738 
0739             kfree_skb(resp);
0740 
0741             return;
0742         }
0743 
0744         PROTOCOL_ERR("14.4.1.6");
0745         goto error;
0746     }
0747 
0748     ddev->atn_count = 0;
0749     ddev->nack_count = 0;
0750 
0751     if (resp->len > ddev->local_payload_max) {
0752         rc = -EMSGSIZE;
0753         goto exit;
0754     }
0755 
0756     size = sizeof(struct digital_dep_req_res);
0757     dep_res = (struct digital_dep_req_res *)resp->data;
0758 
0759     if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
0760         dep_res->cmd != DIGITAL_CMD_DEP_RES) {
0761         rc = -EIO;
0762         goto error;
0763     }
0764 
0765     pfb = dep_res->pfb;
0766 
0767     if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
0768         PROTOCOL_ERR("14.8.2.1");
0769         rc = -EIO;
0770         goto error;
0771     }
0772 
0773     if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
0774         rc = -EIO;
0775         goto exit;
0776     }
0777 
0778     if (size > resp->len) {
0779         rc = -EIO;
0780         goto error;
0781     }
0782 
0783     skb_pull(resp, size);
0784 
0785     switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
0786     case DIGITAL_NFC_DEP_PFB_I_PDU:
0787         if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
0788             PROTOCOL_ERR("14.12.3.3");
0789             rc = -EIO;
0790             goto error;
0791         }
0792 
0793         ddev->curr_nfc_dep_pni =
0794             DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
0795 
0796         kfree_skb(ddev->saved_skb);
0797         ddev->saved_skb = NULL;
0798 
0799         resp = digital_recv_dep_data_gather(ddev, pfb, resp,
0800                             digital_in_send_ack,
0801                             data_exch);
0802         if (IS_ERR(resp)) {
0803             rc = PTR_ERR(resp);
0804             resp = NULL;
0805             goto error;
0806         }
0807 
0808         /* If resp is NULL then we're still chaining so return and
0809          * wait for the next part of the PDU.  Else, the PDU is
0810          * complete so pass it up.
0811          */
0812         if (!resp)
0813             return;
0814 
0815         rc = 0;
0816         break;
0817 
0818     case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
0819         if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
0820             PROTOCOL_ERR("14.12.4.5");
0821             rc = -EIO;
0822             goto exit;
0823         }
0824 
0825         if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
0826             PROTOCOL_ERR("14.12.3.3");
0827             rc = -EIO;
0828             goto exit;
0829         }
0830 
0831         ddev->curr_nfc_dep_pni =
0832             DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
0833 
0834         if (!ddev->chaining_skb) {
0835             PROTOCOL_ERR("14.12.4.3");
0836             rc = -EIO;
0837             goto exit;
0838         }
0839 
0840         /* The initiator has received a valid ACK. Free the last sent
0841          * PDU and keep on sending chained skb.
0842          */
0843         kfree_skb(ddev->saved_skb);
0844         ddev->saved_skb = NULL;
0845 
0846         rc = digital_in_send_dep_req(ddev, NULL,
0847                          ddev->chaining_skb,
0848                          ddev->data_exch);
0849         if (rc)
0850             goto error;
0851 
0852         goto free_resp;
0853 
0854     case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
0855         if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */
0856             rc = digital_in_send_saved_skb(ddev, data_exch);
0857             if (rc)
0858                 goto error;
0859 
0860             goto free_resp;
0861         }
0862 
0863         if (ddev->atn_count || ddev->nack_count) {
0864             PROTOCOL_ERR("14.12.4.4");
0865             rc = -EIO;
0866             goto error;
0867         }
0868 
0869         rtox = DIGITAL_NFC_DEP_RTOX_VALUE(resp->data[0]);
0870         if (!rtox || rtox > DIGITAL_NFC_DEP_RTOX_MAX) {
0871             PROTOCOL_ERR("14.8.4.1");
0872             rc = -EIO;
0873             goto error;
0874         }
0875 
0876         rc = digital_in_send_rtox(ddev, data_exch, rtox);
0877         if (rc)
0878             goto error;
0879 
0880         goto free_resp;
0881     }
0882 
0883 exit:
0884     data_exch->cb(data_exch->cb_context, resp, rc);
0885 
0886 error:
0887     kfree(data_exch);
0888 
0889     kfree_skb(ddev->chaining_skb);
0890     ddev->chaining_skb = NULL;
0891 
0892     kfree_skb(ddev->saved_skb);
0893     ddev->saved_skb = NULL;
0894 
0895     if (rc)
0896         kfree_skb(resp);
0897 
0898     return;
0899 
0900 free_resp:
0901     dev_kfree_skb(resp);
0902 }
0903 
0904 int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
0905                 struct nfc_target *target, struct sk_buff *skb,
0906                 struct digital_data_exch *data_exch)
0907 {
0908     struct digital_dep_req_res *dep_req;
0909     struct sk_buff *chaining_skb, *tmp_skb;
0910     int rc;
0911 
0912     skb_push(skb, sizeof(struct digital_dep_req_res));
0913 
0914     dep_req = (struct digital_dep_req_res *)skb->data;
0915 
0916     dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
0917     dep_req->cmd = DIGITAL_CMD_DEP_REQ;
0918     dep_req->pfb = ddev->curr_nfc_dep_pni;
0919 
0920     ddev->atn_count = 0;
0921     ddev->nack_count = 0;
0922 
0923     chaining_skb = ddev->chaining_skb;
0924 
0925     tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
0926     if (IS_ERR(tmp_skb))
0927         return PTR_ERR(tmp_skb);
0928 
0929     digital_skb_push_dep_sod(ddev, tmp_skb);
0930 
0931     ddev->skb_add_crc(tmp_skb);
0932 
0933     ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
0934 
0935     rc = digital_in_send_cmd(ddev, tmp_skb, ddev->dep_rwt,
0936                  digital_in_recv_dep_res, data_exch);
0937     if (rc) {
0938         if (tmp_skb != skb)
0939             kfree_skb(tmp_skb);
0940 
0941         kfree_skb(chaining_skb);
0942         ddev->chaining_skb = NULL;
0943 
0944         kfree_skb(ddev->saved_skb);
0945         ddev->saved_skb = NULL;
0946     }
0947 
0948     return rc;
0949 }
0950 
0951 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
0952 {
0953     ddev->curr_rf_tech = rf_tech;
0954 
0955     ddev->skb_add_crc = digital_skb_add_crc_none;
0956     ddev->skb_check_crc = digital_skb_check_crc_none;
0957 
0958     if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
0959         return;
0960 
0961     switch (ddev->curr_rf_tech) {
0962     case NFC_DIGITAL_RF_TECH_106A:
0963         ddev->skb_add_crc = digital_skb_add_crc_a;
0964         ddev->skb_check_crc = digital_skb_check_crc_a;
0965         break;
0966 
0967     case NFC_DIGITAL_RF_TECH_212F:
0968     case NFC_DIGITAL_RF_TECH_424F:
0969         ddev->skb_add_crc = digital_skb_add_crc_f;
0970         ddev->skb_check_crc = digital_skb_check_crc_f;
0971         break;
0972 
0973     default:
0974         break;
0975     }
0976 }
0977 
0978 static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
0979                    struct digital_data_exch *data_exch)
0980 {
0981     struct digital_dep_req_res *dep_res;
0982     struct sk_buff *skb;
0983     int rc;
0984 
0985     skb = digital_skb_alloc(ddev, 1);
0986     if (!skb)
0987         return -ENOMEM;
0988 
0989     skb_push(skb, sizeof(struct digital_dep_req_res));
0990 
0991     dep_res = (struct digital_dep_req_res *)skb->data;
0992 
0993     dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
0994     dep_res->cmd = DIGITAL_CMD_DEP_RES;
0995     dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
0996                ddev->curr_nfc_dep_pni;
0997 
0998     if (ddev->did) {
0999         dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1000 
1001         skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1002     }
1003 
1004     ddev->curr_nfc_dep_pni =
1005         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1006 
1007     digital_skb_push_dep_sod(ddev, skb);
1008 
1009     ddev->skb_add_crc(skb);
1010 
1011     ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
1012 
1013     rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1014                  data_exch);
1015     if (rc) {
1016         kfree_skb(skb);
1017         kfree_skb(ddev->saved_skb);
1018         ddev->saved_skb = NULL;
1019     }
1020 
1021     return rc;
1022 }
1023 
1024 static int digital_tg_send_atn(struct nfc_digital_dev *ddev)
1025 {
1026     struct digital_dep_req_res *dep_res;
1027     struct sk_buff *skb;
1028     int rc;
1029 
1030     skb = digital_skb_alloc(ddev, 1);
1031     if (!skb)
1032         return -ENOMEM;
1033 
1034     skb_push(skb, sizeof(struct digital_dep_req_res));
1035 
1036     dep_res = (struct digital_dep_req_res *)skb->data;
1037 
1038     dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1039     dep_res->cmd = DIGITAL_CMD_DEP_RES;
1040     dep_res->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
1041 
1042     if (ddev->did) {
1043         dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1044 
1045         skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1046     }
1047 
1048     digital_skb_push_dep_sod(ddev, skb);
1049 
1050     ddev->skb_add_crc(skb);
1051 
1052     rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1053                  NULL);
1054     if (rc)
1055         kfree_skb(skb);
1056 
1057     return rc;
1058 }
1059 
1060 static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev)
1061 {
1062     int rc;
1063 
1064     if (!ddev->saved_skb)
1065         return -EINVAL;
1066 
1067     skb_get(ddev->saved_skb);
1068 
1069     rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500,
1070                  digital_tg_recv_dep_req, NULL);
1071     if (rc)
1072         kfree_skb(ddev->saved_skb);
1073 
1074     return rc;
1075 }
1076 
1077 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
1078                     struct sk_buff *resp)
1079 {
1080     int rc;
1081     struct digital_dep_req_res *dep_req;
1082     u8 pfb;
1083     size_t size;
1084 
1085     if (IS_ERR(resp)) {
1086         rc = PTR_ERR(resp);
1087         resp = NULL;
1088         goto exit;
1089     }
1090 
1091     rc = ddev->skb_check_crc(resp);
1092     if (rc) {
1093         PROTOCOL_ERR("14.4.1.6");
1094         goto exit;
1095     }
1096 
1097     rc = digital_skb_pull_dep_sod(ddev, resp);
1098     if (rc) {
1099         PROTOCOL_ERR("14.4.1.2");
1100         goto exit;
1101     }
1102 
1103     if (resp->len > ddev->local_payload_max) {
1104         rc = -EMSGSIZE;
1105         goto exit;
1106     }
1107 
1108     size = sizeof(struct digital_dep_req_res);
1109     dep_req = (struct digital_dep_req_res *)resp->data;
1110 
1111     if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1112         dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
1113         rc = -EIO;
1114         goto exit;
1115     }
1116 
1117     pfb = dep_req->pfb;
1118 
1119     if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
1120         if (ddev->did && (ddev->did == resp->data[3])) {
1121             size++;
1122         } else {
1123             rc = -EIO;
1124             goto exit;
1125         }
1126     } else if (ddev->did) {
1127         rc = -EIO;
1128         goto exit;
1129     }
1130 
1131     if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
1132         rc = -EIO;
1133         goto exit;
1134     }
1135 
1136     if (size > resp->len) {
1137         rc = -EIO;
1138         goto exit;
1139     }
1140 
1141     skb_pull(resp, size);
1142 
1143     switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1144     case DIGITAL_NFC_DEP_PFB_I_PDU:
1145         pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
1146 
1147         if (ddev->atn_count) {
1148             /* The target has received (and replied to) at least one
1149              * ATN DEP_REQ.
1150              */
1151             ddev->atn_count = 0;
1152 
1153             /* pni of resp PDU equal to the target current pni - 1
1154              * means resp is the previous DEP_REQ PDU received from
1155              * the initiator so the target replies with saved_skb
1156              * which is the previous DEP_RES saved in
1157              * digital_tg_send_dep_res().
1158              */
1159             if (DIGITAL_NFC_DEP_PFB_PNI(pfb) ==
1160               DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) {
1161                 rc = digital_tg_send_saved_skb(ddev);
1162                 if (rc)
1163                     goto exit;
1164 
1165                 goto free_resp;
1166             }
1167 
1168             /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1
1169              * means the target probably did not received the last
1170              * DEP_REQ PDU sent by the initiator. The target
1171              * fallbacks to normal processing then.
1172              */
1173         }
1174 
1175         if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
1176             PROTOCOL_ERR("14.12.3.4");
1177             rc = -EIO;
1178             goto exit;
1179         }
1180 
1181         kfree_skb(ddev->saved_skb);
1182         ddev->saved_skb = NULL;
1183 
1184         resp = digital_recv_dep_data_gather(ddev, pfb, resp,
1185                             digital_tg_send_ack, NULL);
1186         if (IS_ERR(resp)) {
1187             rc = PTR_ERR(resp);
1188             resp = NULL;
1189             goto exit;
1190         }
1191 
1192         /* If resp is NULL then we're still chaining so return and
1193          * wait for the next part of the PDU.  Else, the PDU is
1194          * complete so pass it up.
1195          */
1196         if (!resp)
1197             return;
1198 
1199         rc = 0;
1200         break;
1201     case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
1202         if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */
1203             if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) !=
1204                         ddev->curr_nfc_dep_pni) {
1205                 rc = -EIO;
1206                 goto exit;
1207             }
1208 
1209             ddev->atn_count = 0;
1210 
1211             rc = digital_tg_send_saved_skb(ddev);
1212             if (rc)
1213                 goto exit;
1214 
1215             goto free_resp;
1216         }
1217 
1218         /* ACK */
1219         if (ddev->atn_count) {
1220             /* The target has previously received one or more ATN
1221              * PDUs.
1222              */
1223             ddev->atn_count = 0;
1224 
1225             /* If the ACK PNI is equal to the target PNI - 1 means
1226              * that the initiator did not receive the previous PDU
1227              * sent by the target so re-send it.
1228              */
1229             if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) ==
1230                         ddev->curr_nfc_dep_pni) {
1231                 rc = digital_tg_send_saved_skb(ddev);
1232                 if (rc)
1233                     goto exit;
1234 
1235                 goto free_resp;
1236             }
1237 
1238             /* Otherwise, the target did not receive the previous
1239              * ACK PDU from the initiator. Fallback to normal
1240              * processing of chained PDU then.
1241              */
1242         }
1243 
1244         /* Keep on sending chained PDU */
1245         if (!ddev->chaining_skb ||
1246             DIGITAL_NFC_DEP_PFB_PNI(pfb) !=
1247                     ddev->curr_nfc_dep_pni) {
1248             rc = -EIO;
1249             goto exit;
1250         }
1251 
1252         kfree_skb(ddev->saved_skb);
1253         ddev->saved_skb = NULL;
1254 
1255         rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
1256         if (rc)
1257             goto exit;
1258 
1259         goto free_resp;
1260     case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
1261         if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
1262             rc = -EINVAL;
1263             goto exit;
1264         }
1265 
1266         rc = digital_tg_send_atn(ddev);
1267         if (rc)
1268             goto exit;
1269 
1270         ddev->atn_count++;
1271 
1272         goto free_resp;
1273     }
1274 
1275     rc = nfc_tm_data_received(ddev->nfc_dev, resp);
1276     if (rc)
1277         resp = NULL;
1278 
1279 exit:
1280     kfree_skb(ddev->chaining_skb);
1281     ddev->chaining_skb = NULL;
1282 
1283     ddev->atn_count = 0;
1284 
1285     kfree_skb(ddev->saved_skb);
1286     ddev->saved_skb = NULL;
1287 
1288     if (rc)
1289         kfree_skb(resp);
1290 
1291     return;
1292 
1293 free_resp:
1294     dev_kfree_skb(resp);
1295 }
1296 
1297 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1298 {
1299     struct digital_dep_req_res *dep_res;
1300     struct sk_buff *chaining_skb, *tmp_skb;
1301     int rc;
1302 
1303     skb_push(skb, sizeof(struct digital_dep_req_res));
1304 
1305     dep_res = (struct digital_dep_req_res *)skb->data;
1306 
1307     dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1308     dep_res->cmd = DIGITAL_CMD_DEP_RES;
1309     dep_res->pfb = ddev->curr_nfc_dep_pni;
1310 
1311     if (ddev->did) {
1312         dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1313 
1314         skb_put_data(skb, &ddev->did, sizeof(ddev->did));
1315     }
1316 
1317     ddev->curr_nfc_dep_pni =
1318         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1319 
1320     chaining_skb = ddev->chaining_skb;
1321 
1322     tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1323     if (IS_ERR(tmp_skb))
1324         return PTR_ERR(tmp_skb);
1325 
1326     digital_skb_push_dep_sod(ddev, tmp_skb);
1327 
1328     ddev->skb_add_crc(tmp_skb);
1329 
1330     ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
1331 
1332     rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1333                  NULL);
1334     if (rc) {
1335         if (tmp_skb != skb)
1336             kfree_skb(tmp_skb);
1337 
1338         kfree_skb(chaining_skb);
1339         ddev->chaining_skb = NULL;
1340 
1341         kfree_skb(ddev->saved_skb);
1342         ddev->saved_skb = NULL;
1343     }
1344 
1345     return rc;
1346 }
1347 
1348 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1349                          void *arg, struct sk_buff *resp)
1350 {
1351     u8 rf_tech = (unsigned long)arg;
1352 
1353     if (IS_ERR(resp))
1354         return;
1355 
1356     digital_tg_set_rf_tech(ddev, rf_tech);
1357 
1358     digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1359 
1360     digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1361 
1362     dev_kfree_skb(resp);
1363 }
1364 
1365 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1366                    u8 rf_tech)
1367 {
1368     struct digital_psl_res *psl_res;
1369     struct sk_buff *skb;
1370     int rc;
1371 
1372     skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1373     if (!skb)
1374         return -ENOMEM;
1375 
1376     skb_put(skb, sizeof(struct digital_psl_res));
1377 
1378     psl_res = (struct digital_psl_res *)skb->data;
1379 
1380     psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1381     psl_res->cmd = DIGITAL_CMD_PSL_RES;
1382     psl_res->did = did;
1383 
1384     digital_skb_push_dep_sod(ddev, skb);
1385 
1386     ddev->skb_add_crc(skb);
1387 
1388     ddev->curr_nfc_dep_pni = 0;
1389 
1390     rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
1391                  (void *)(unsigned long)rf_tech);
1392     if (rc)
1393         kfree_skb(skb);
1394 
1395     return rc;
1396 }
1397 
1398 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1399                     struct sk_buff *resp)
1400 {
1401     int rc;
1402     struct digital_psl_req *psl_req;
1403     u8 rf_tech;
1404     u8 dsi, payload_size, payload_bits;
1405 
1406     if (IS_ERR(resp)) {
1407         rc = PTR_ERR(resp);
1408         resp = NULL;
1409         goto exit;
1410     }
1411 
1412     rc = ddev->skb_check_crc(resp);
1413     if (rc) {
1414         PROTOCOL_ERR("14.4.1.6");
1415         goto exit;
1416     }
1417 
1418     rc = digital_skb_pull_dep_sod(ddev, resp);
1419     if (rc) {
1420         PROTOCOL_ERR("14.4.1.2");
1421         goto exit;
1422     }
1423 
1424     psl_req = (struct digital_psl_req *)resp->data;
1425 
1426     if (resp->len != sizeof(struct digital_psl_req) ||
1427         psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1428         psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1429         rc = -EIO;
1430         goto exit;
1431     }
1432 
1433     dsi = (psl_req->brs >> 3) & 0x07;
1434     switch (dsi) {
1435     case 0:
1436         rf_tech = NFC_DIGITAL_RF_TECH_106A;
1437         break;
1438     case 1:
1439         rf_tech = NFC_DIGITAL_RF_TECH_212F;
1440         break;
1441     case 2:
1442         rf_tech = NFC_DIGITAL_RF_TECH_424F;
1443         break;
1444     default:
1445         pr_err("Unsupported dsi value %d\n", dsi);
1446         goto exit;
1447     }
1448 
1449     payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1450     payload_size = digital_payload_bits_to_size(payload_bits);
1451 
1452     if (!payload_size || (payload_size > min(ddev->local_payload_max,
1453                          ddev->remote_payload_max))) {
1454         rc = -EINVAL;
1455         goto exit;
1456     }
1457 
1458     ddev->local_payload_max = payload_size;
1459     ddev->remote_payload_max = payload_size;
1460 
1461     rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1462 
1463 exit:
1464     kfree_skb(resp);
1465 }
1466 
1467 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1468                          void *arg, struct sk_buff *resp)
1469 {
1470     int offset;
1471 
1472     if (IS_ERR(resp)) {
1473         digital_poll_next_tech(ddev);
1474         return;
1475     }
1476 
1477     offset = 2;
1478     if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1479         offset++;
1480 
1481     ddev->atn_count = 0;
1482 
1483     if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1484         digital_tg_recv_psl_req(ddev, arg, resp);
1485     else
1486         digital_tg_recv_dep_req(ddev, arg, resp);
1487 }
1488 
1489 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1490                    struct digital_atr_req *atr_req)
1491 {
1492     struct digital_atr_res *atr_res;
1493     struct sk_buff *skb;
1494     u8 *gb, payload_bits;
1495     size_t gb_len;
1496     int rc;
1497 
1498     gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1499     if (!gb)
1500         gb_len = 0;
1501 
1502     skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1503     if (!skb)
1504         return -ENOMEM;
1505 
1506     skb_put(skb, sizeof(struct digital_atr_res));
1507     atr_res = (struct digital_atr_res *)skb->data;
1508 
1509     memset(atr_res, 0, sizeof(struct digital_atr_res));
1510 
1511     atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1512     atr_res->cmd = DIGITAL_CMD_ATR_RES;
1513     memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1514     atr_res->to = DIGITAL_NFC_DEP_TG_MAX_WT;
1515 
1516     ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1517     payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1518     atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1519 
1520     if (gb_len) {
1521         skb_put(skb, gb_len);
1522 
1523         atr_res->pp |= DIGITAL_GB_BIT;
1524         memcpy(atr_res->gb, gb, gb_len);
1525     }
1526 
1527     digital_skb_push_dep_sod(ddev, skb);
1528 
1529     ddev->skb_add_crc(skb);
1530 
1531     ddev->curr_nfc_dep_pni = 0;
1532 
1533     rc = digital_tg_send_cmd(ddev, skb, 999,
1534                  digital_tg_send_atr_res_complete, NULL);
1535     if (rc)
1536         kfree_skb(skb);
1537 
1538     return rc;
1539 }
1540 
1541 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1542                  struct sk_buff *resp)
1543 {
1544     int rc;
1545     struct digital_atr_req *atr_req;
1546     size_t gb_len, min_size;
1547     u8 poll_tech_count, payload_bits;
1548 
1549     if (IS_ERR(resp)) {
1550         rc = PTR_ERR(resp);
1551         resp = NULL;
1552         goto exit;
1553     }
1554 
1555     if (!resp->len) {
1556         rc = -EIO;
1557         goto exit;
1558     }
1559 
1560     if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1561         min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
1562         digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1563     } else {
1564         min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
1565         digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1566     }
1567 
1568     if (resp->len < min_size) {
1569         rc = -EIO;
1570         goto exit;
1571     }
1572 
1573     ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1574 
1575     rc = ddev->skb_check_crc(resp);
1576     if (rc) {
1577         PROTOCOL_ERR("14.4.1.6");
1578         goto exit;
1579     }
1580 
1581     rc = digital_skb_pull_dep_sod(ddev, resp);
1582     if (rc) {
1583         PROTOCOL_ERR("14.4.1.2");
1584         goto exit;
1585     }
1586 
1587     atr_req = (struct digital_atr_req *)resp->data;
1588 
1589     if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1590         atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1591         atr_req->did > DIGITAL_DID_MAX) {
1592         rc = -EINVAL;
1593         goto exit;
1594     }
1595 
1596     payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1597     ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1598 
1599     if (!ddev->remote_payload_max) {
1600         rc = -EINVAL;
1601         goto exit;
1602     }
1603 
1604     ddev->did = atr_req->did;
1605 
1606     rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1607                      NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1608     if (rc)
1609         goto exit;
1610 
1611     rc = digital_tg_send_atr_res(ddev, atr_req);
1612     if (rc)
1613         goto exit;
1614 
1615     gb_len = resp->len - sizeof(struct digital_atr_req);
1616 
1617     poll_tech_count = ddev->poll_tech_count;
1618     ddev->poll_tech_count = 0;
1619 
1620     rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1621                   NFC_COMM_PASSIVE, atr_req->gb, gb_len);
1622     if (rc) {
1623         ddev->poll_tech_count = poll_tech_count;
1624         goto exit;
1625     }
1626 
1627     rc = 0;
1628 exit:
1629     if (rc)
1630         digital_poll_next_tech(ddev);
1631 
1632     dev_kfree_skb(resp);
1633 }
[ 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!