net/nfc/digital_dep.c

   1 /*
   2  * NFC Digital Protocol stack
   3  * Copyright (c) 2013, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
  17
  18 #include "digital.h"
  19
  20 #define DIGITAL_NFC_DEP_N_RETRY_NACK    2
  21 #define DIGITAL_NFC_DEP_N_RETRY_ATN     2
  22
  23 #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
  24 #define DIGITAL_NFC_DEP_FRAME_DIR_IN  0xD5
  25
  26 #define DIGITAL_NFC_DEP_NFCA_SOD_SB   0xF0
  27
  28 #define DIGITAL_CMD_ATR_REQ 0x00
  29 #define DIGITAL_CMD_ATR_RES 0x01
  30 #define DIGITAL_CMD_PSL_REQ 0x04
  31 #define DIGITAL_CMD_PSL_RES 0x05
  32 #define DIGITAL_CMD_DEP_REQ 0x06
  33 #define DIGITAL_CMD_DEP_RES 0x07
  34
  35 #define DIGITAL_ATR_REQ_MIN_SIZE 16
  36 #define DIGITAL_ATR_REQ_MAX_SIZE 64
  37
  38 #define DIGITAL_ATR_RES_TO_WT(s)        ((s) & 0xF)
  39
  40 #define DIGITAL_DID_MAX 14
  41
  42 #define DIGITAL_PAYLOAD_SIZE_MAX        254
  43 #define DIGITAL_PAYLOAD_BITS_TO_PP(s)   (((s) & 0x3) << 4)
  44 #define DIGITAL_PAYLOAD_PP_TO_BITS(s)   (((s) >> 4) & 0x3)
  45 #define DIGITAL_PAYLOAD_BITS_TO_FSL(s)  ((s) & 0x3)
  46 #define DIGITAL_PAYLOAD_FSL_TO_BITS(s)  ((s) & 0x3)
  47
  48 #define DIGITAL_GB_BIT  0x02
  49
  50 #define DIGITAL_NFC_DEP_REQ_RES_HEADROOM        2 /* SoD: [SB (NFC-A)] + LEN */
  51 #define DIGITAL_NFC_DEP_REQ_RES_TAILROOM        2 /* EoD: 2-byte CRC */
  52
  53 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
  54
  55 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
  56 #define DIGITAL_NFC_DEP_PFB_MI_BIT      0x10
  57 #define DIGITAL_NFC_DEP_PFB_NACK_BIT    0x10
  58 #define DIGITAL_NFC_DEP_PFB_DID_BIT     0x04
  59
  60 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
  61                                 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
  62 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb)  ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT)
  63 #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT)
  64 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
  65 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT)
  66 #define DIGITAL_NFC_DEP_PFB_PNI(pfb)     ((pfb) & 0x03)
  67
  68 #define DIGITAL_NFC_DEP_RTOX_VALUE(data) ((data) & 0x3F)
  69 #define DIGITAL_NFC_DEP_RTOX_MAX         59
  70
  71 #define DIGITAL_NFC_DEP_PFB_I_PDU          0x00
  72 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU   0x40
  73 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
  74
  75 struct digital_atr_req {
  76         u8 dir;
  77         u8 cmd;
  78         u8 nfcid3[10];
  79         u8 did;
  80         u8 bs;
  81         u8 br;
  82         u8 pp;
  83         u8 gb[0];
  84 } __packed;
  85
  86 struct digital_atr_res {
  87         u8 dir;
  88         u8 cmd;
  89         u8 nfcid3[10];
  90         u8 did;
  91         u8 bs;
  92         u8 br;
  93         u8 to;
  94         u8 pp;
  95         u8 gb[0];
  96 } __packed;
  97
  98 struct digital_psl_req {
  99         u8 dir;
 100         u8 cmd;
 101         u8 did;
 102         u8 brs;
 103         u8 fsl;
 104 } __packed;
 105
 106 struct digital_psl_res {
 107         u8 dir;
 108         u8 cmd;
 109         u8 did;
 110 } __packed;
 111
 112 struct digital_dep_req_res {
 113         u8 dir;
 114         u8 cmd;
 115         u8 pfb;
 116 } __packed;
 117
 118 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
 119                                     struct sk_buff *resp);
 120 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
 121                                     struct sk_buff *resp);
 122
 123 static const u8 digital_payload_bits_map[4] = {
 124         [0] = 64,
 125         [1] = 128,
 126         [2] = 192,
 127         [3] = 254
 128 };
 129
 130 /* Response Waiting Time for ATR_RES PDU in ms
 131  *
 132  * RWT(ATR_RES) = RWT(nfcdep,activation) + dRWT(nfcdep) + dT(nfcdep,initiator)
 133  *
 134  * with:
 135  *  RWT(nfcdep,activation) = 4096 * 2^12 / f(c) s
 136  *  dRWT(nfcdep) = 16 / f(c) s
 137  *  dT(nfcdep,initiator) = 100 ms
 138  *  f(c) = 13560000 Hz
 139  */
 140 #define DIGITAL_ATR_RES_RWT 1337
 141
 142 /* Response Waiting Time for other DEP PDUs in ms
 143  *
 144  * max_rwt = rwt + dRWT(nfcdep) + dT(nfcdep,initiator)
 145  *
 146  * with:
 147  *  rwt = (256 * 16 / f(c)) * 2^wt s
 148  *  dRWT(nfcdep) = 16 / f(c) s
 149  *  dT(nfcdep,initiator) = 100 ms
 150  *  f(c) = 13560000 Hz
 151  *  0 <= wt <= 14 (given by the target by the TO field of ATR_RES response)
 152  */
 153 #define DIGITAL_NFC_DEP_IN_MAX_WT 14
 154 #define DIGITAL_NFC_DEP_TG_MAX_WT 8
 155 static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = {
 156         100,  101,  101,  102,  105,
 157         110,  119,  139,  177,  255,
 158         409,  719, 1337, 2575, 5049,
 159 };
 160
 161 static u8 digital_payload_bits_to_size(u8 payload_bits)
 162 {
 163         if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map))
 164                 return 0;
 165
 166         return digital_payload_bits_map[payload_bits];
 167 }
 168
 169 static u8 digital_payload_size_to_bits(u8 payload_size)
 170 {
 171         int i;
 172
 173         for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++)
 174                 if (digital_payload_bits_map[i] == payload_size)
 175                         return i;
 176
 177         return 0xff;
 178 }
 179
 180 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
 181                                      struct sk_buff *skb)
 182 {
 183         skb_push(skb, sizeof(u8));
 184
 185         skb->data[0] = skb->len;
 186
 187         if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
 188                 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
 189 }
 190
 191 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
 192                                     struct sk_buff *skb)
 193 {
 194         u8 size;
 195
 196         if (skb->len < 2)
 197                 return -EIO;
 198
 199         if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
 200                 skb_pull(skb, sizeof(u8));
 201
 202         size = skb->data[0];
 203         if (size != skb->len)
 204                 return -EIO;
 205
 206         skb_pull(skb, sizeof(u8));
 207
 208         return 0;
 209 }
 210
 211 static struct sk_buff *
 212 digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb,
 213                            struct digital_dep_req_res *dep_req_res,
 214                            struct digital_data_exch *data_exch)
 215 {
 216         struct sk_buff *new_skb;
 217
 218         if (skb->len > ddev->remote_payload_max) {
 219                 dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT;
 220
 221                 new_skb = digital_skb_alloc(ddev, ddev->remote_payload_max);
 222                 if (!new_skb) {
 223                         kfree_skb(ddev->chaining_skb);
 224                         ddev->chaining_skb = NULL;
 225
 226                         return ERR_PTR(-ENOMEM);
 227                 }
 228
 229                 memcpy(skb_put(new_skb, ddev->remote_payload_max), skb->data,
 230                        ddev->remote_payload_max);
 231                 skb_pull(skb, ddev->remote_payload_max);
 232
 233                 ddev->chaining_skb = skb;
 234                 ddev->data_exch = data_exch;
 235         } else {
 236                 ddev->chaining_skb = NULL;
 237                 new_skb = skb;
 238         }
 239
 240         return new_skb;
 241 }
 242
 243 static struct sk_buff *
 244 digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb,
 245                              struct sk_buff *resp,
 246                              int (*send_ack)(struct nfc_digital_dev *ddev,
 247                                              struct digital_data_exch
 248                                                              *data_exch),
 249                              struct digital_data_exch *data_exch)
 250 {
 251         struct sk_buff *new_skb;
 252         int rc;
 253
 254         if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) {
 255                 ddev->chaining_skb =
 256                         nfc_alloc_recv_skb(8 * ddev->local_payload_max,
 257                                            GFP_KERNEL);
 258                 if (!ddev->chaining_skb) {
 259                         rc = -ENOMEM;
 260                         goto error;
 261                 }
 262         }
 263
 264         if (ddev->chaining_skb) {
 265                 if (resp->len > skb_tailroom(ddev->chaining_skb)) {
 266                         new_skb = skb_copy_expand(ddev->chaining_skb,
 267                                                   skb_headroom(
 268                                                           ddev->chaining_skb),
 269                                                   8 * ddev->local_payload_max,
 270                                                   GFP_KERNEL);
 271                         if (!new_skb) {
 272                                 rc = -ENOMEM;
 273                                 goto error;
 274                         }
 275
 276                         kfree_skb(ddev->chaining_skb);
 277                         ddev->chaining_skb = new_skb;
 278                 }
 279
 280                 memcpy(skb_put(ddev->chaining_skb, resp->len), resp->data,
 281                        resp->len);
 282
 283                 kfree_skb(resp);
 284                 resp = NULL;
 285
 286                 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
 287                         rc = send_ack(ddev, data_exch);
 288                         if (rc)
 289                                 goto error;
 290
 291                         return NULL;
 292                 }
 293
 294                 resp = ddev->chaining_skb;
 295                 ddev->chaining_skb = NULL;
 296         }
 297
 298         return resp;
 299
 300 error:
 301         kfree_skb(resp);
 302
 303         kfree_skb(ddev->chaining_skb);
 304         ddev->chaining_skb = NULL;
 305
 306         return ERR_PTR(rc);
 307 }
 308
 309 static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg,
 310                                     struct sk_buff *resp)
 311 {
 312         struct nfc_target *target = arg;
 313         struct digital_psl_res *psl_res;
 314         int rc;
 315
 316         if (IS_ERR(resp)) {
 317                 rc = PTR_ERR(resp);
 318                 resp = NULL;
 319                 goto exit;
 320         }
 321
 322         rc = ddev->skb_check_crc(resp);
 323         if (rc) {
 324                 PROTOCOL_ERR("14.4.1.6");
 325                 goto exit;
 326         }
 327
 328         rc = digital_skb_pull_dep_sod(ddev, resp);
 329         if (rc) {
 330                 PROTOCOL_ERR("14.4.1.2");
 331                 goto exit;
 332         }
 333
 334         psl_res = (struct digital_psl_res *)resp->data;
 335
 336         if ((resp->len != sizeof(*psl_res)) ||
 337             (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) ||
 338             (psl_res->cmd != DIGITAL_CMD_PSL_RES)) {
 339                 rc = -EIO;
 340                 goto exit;
 341         }
 342
 343         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
 344                                      NFC_DIGITAL_RF_TECH_424F);
 345         if (rc)
 346                 goto exit;
 347
 348         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 349                                      NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
 350         if (rc)
 351                 goto exit;
 352
 353         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) &&
 354             (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) {
 355                 ddev->skb_add_crc = digital_skb_add_crc_f;
 356                 ddev->skb_check_crc = digital_skb_check_crc_f;
 357         }
 358
 359         ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F;
 360
 361         nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
 362                            NFC_RF_INITIATOR);
 363
 364         ddev->curr_nfc_dep_pni = 0;
 365
 366 exit:
 367         dev_kfree_skb(resp);
 368
 369         if (rc)
 370                 ddev->curr_protocol = 0;
 371 }
 372
 373 static int digital_in_send_psl_req(struct nfc_digital_dev *ddev,
 374                                    struct nfc_target *target)
 375 {
 376         struct sk_buff *skb;
 377         struct digital_psl_req *psl_req;
 378         int rc;
 379         u8 payload_size, payload_bits;
 380
 381         skb = digital_skb_alloc(ddev, sizeof(*psl_req));
 382         if (!skb)
 383                 return -ENOMEM;
 384
 385         skb_put(skb, sizeof(*psl_req));
 386
 387         psl_req = (struct digital_psl_req *)skb->data;
 388
 389         psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 390         psl_req->cmd = DIGITAL_CMD_PSL_REQ;
 391         psl_req->did = 0;
 392         psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */
 393
 394         payload_size = min(ddev->local_payload_max, ddev->remote_payload_max);
 395         payload_bits = digital_payload_size_to_bits(payload_size);
 396         psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits);
 397
 398         ddev->local_payload_max = payload_size;
 399         ddev->remote_payload_max = payload_size;
 400
 401         digital_skb_push_dep_sod(ddev, skb);
 402
 403         ddev->skb_add_crc(skb);
 404
 405         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
 406                                  digital_in_recv_psl_res, target);
 407         if (rc)
 408                 kfree_skb(skb);
 409
 410         return rc;
 411 }
 412
 413 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
 414                                  struct sk_buff *resp)
 415 {
 416         struct nfc_target *target = arg;
 417         struct digital_atr_res *atr_res;
 418         u8 gb_len, payload_bits;
 419         u8 wt;
 420         int rc;
 421
 422         if (IS_ERR(resp)) {
 423                 rc = PTR_ERR(resp);
 424                 resp = NULL;
 425                 goto exit;
 426         }
 427
 428         rc = ddev->skb_check_crc(resp);
 429         if (rc) {
 430                 PROTOCOL_ERR("14.4.1.6");
 431                 goto exit;
 432         }
 433
 434         rc = digital_skb_pull_dep_sod(ddev, resp);
 435         if (rc) {
 436                 PROTOCOL_ERR("14.4.1.2");
 437                 goto exit;
 438         }
 439
 440         if (resp->len < sizeof(struct digital_atr_res)) {
 441                 rc = -EIO;
 442                 goto exit;
 443         }
 444
 445         gb_len = resp->len - sizeof(struct digital_atr_res);
 446
 447         atr_res = (struct digital_atr_res *)resp->data;
 448
 449         wt = DIGITAL_ATR_RES_TO_WT(atr_res->to);
 450         if (wt > DIGITAL_NFC_DEP_IN_MAX_WT)
 451                 wt = DIGITAL_NFC_DEP_IN_MAX_WT;
 452         ddev->dep_rwt = digital_rwt_map[wt];
 453
 454         payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp);
 455         ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
 456
 457         if (!ddev->remote_payload_max) {
 458                 rc = -EINVAL;
 459                 goto exit;
 460         }
 461
 462         rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
 463         if (rc)
 464                 goto exit;
 465
 466         if ((ddev->protocols & NFC_PROTO_FELICA_MASK) &&
 467             (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) {
 468                 rc = digital_in_send_psl_req(ddev, target);
 469                 if (!rc)
 470                         goto exit;
 471         }
 472
 473         rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
 474                                 NFC_RF_INITIATOR);
 475
 476         ddev->curr_nfc_dep_pni = 0;
 477
 478 exit:
 479         dev_kfree_skb(resp);
 480
 481         if (rc)
 482                 ddev->curr_protocol = 0;
 483 }
 484
 485 int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
 486                             struct nfc_target *target, __u8 comm_mode, __u8 *gb,
 487                             size_t gb_len)
 488 {
 489         struct sk_buff *skb;
 490         struct digital_atr_req *atr_req;
 491         uint size;
 492         int rc;
 493         u8 payload_bits;
 494
 495         size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
 496
 497         if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
 498                 PROTOCOL_ERR("14.6.1.1");
 499                 return -EINVAL;
 500         }
 501
 502         skb = digital_skb_alloc(ddev, size);
 503         if (!skb)
 504                 return -ENOMEM;
 505
 506         skb_put(skb, sizeof(struct digital_atr_req));
 507
 508         atr_req = (struct digital_atr_req *)skb->data;
 509         memset(atr_req, 0, sizeof(struct digital_atr_req));
 510
 511         atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 512         atr_req->cmd = DIGITAL_CMD_ATR_REQ;
 513         if (target->nfcid2_len)
 514                 memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE);
 515         else
 516                 get_random_bytes(atr_req->nfcid3, NFC_NFCID3_MAXSIZE);
 517
 518         atr_req->did = 0;
 519         atr_req->bs = 0;
 520         atr_req->br = 0;
 521
 522         ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
 523         payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
 524         atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
 525
 526         if (gb_len) {
 527                 atr_req->pp |= DIGITAL_GB_BIT;
 528                 memcpy(skb_put(skb, gb_len), gb, gb_len);
 529         }
 530
 531         digital_skb_push_dep_sod(ddev, skb);
 532
 533         ddev->skb_add_crc(skb);
 534
 535         rc = digital_in_send_cmd(ddev, skb, DIGITAL_ATR_RES_RWT,
 536                                  digital_in_recv_atr_res, target);
 537         if (rc)
 538                 kfree_skb(skb);
 539
 540         return rc;
 541 }
 542
 543 static int digital_in_send_ack(struct nfc_digital_dev *ddev,
 544                                struct digital_data_exch *data_exch)
 545 {
 546         struct digital_dep_req_res *dep_req;
 547         struct sk_buff *skb;
 548         int rc;
 549
 550         skb = digital_skb_alloc(ddev, 1);
 551         if (!skb)
 552                 return -ENOMEM;
 553
 554         skb_push(skb, sizeof(struct digital_dep_req_res));
 555
 556         dep_req = (struct digital_dep_req_res *)skb->data;
 557
 558         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 559         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
 560         dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
 561                        ddev->curr_nfc_dep_pni;
 562
 563         digital_skb_push_dep_sod(ddev, skb);
 564
 565         ddev->skb_add_crc(skb);
 566
 567         ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
 568
 569         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
 570                                  digital_in_recv_dep_res, data_exch);
 571         if (rc) {
 572                 kfree_skb(skb);
 573                 kfree_skb(ddev->saved_skb);
 574                 ddev->saved_skb = NULL;
 575         }
 576
 577         return rc;
 578 }
 579
 580 static int digital_in_send_nack(struct nfc_digital_dev *ddev,
 581                                 struct digital_data_exch *data_exch)
 582 {
 583         struct digital_dep_req_res *dep_req;
 584         struct sk_buff *skb;
 585         int rc;
 586
 587         skb = digital_skb_alloc(ddev, 1);
 588         if (!skb)
 589                 return -ENOMEM;
 590
 591         skb_push(skb, sizeof(struct digital_dep_req_res));
 592
 593         dep_req = (struct digital_dep_req_res *)skb->data;
 594
 595         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 596         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
 597         dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
 598                        DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni;
 599
 600         digital_skb_push_dep_sod(ddev, skb);
 601
 602         ddev->skb_add_crc(skb);
 603
 604         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
 605                                  digital_in_recv_dep_res, data_exch);
 606         if (rc)
 607                 kfree_skb(skb);
 608
 609         return rc;
 610 }
 611
 612 static int digital_in_send_atn(struct nfc_digital_dev *ddev,
 613                                struct digital_data_exch *data_exch)
 614 {
 615         struct digital_dep_req_res *dep_req;
 616         struct sk_buff *skb;
 617         int rc;
 618
 619         skb = digital_skb_alloc(ddev, 1);
 620         if (!skb)
 621                 return -ENOMEM;
 622
 623         skb_push(skb, sizeof(struct digital_dep_req_res));
 624
 625         dep_req = (struct digital_dep_req_res *)skb->data;
 626
 627         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 628         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
 629         dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
 630
 631         digital_skb_push_dep_sod(ddev, skb);
 632
 633         ddev->skb_add_crc(skb);
 634
 635         rc = digital_in_send_cmd(ddev, skb, ddev->dep_rwt,
 636                                  digital_in_recv_dep_res, data_exch);
 637         if (rc)
 638                 kfree_skb(skb);
 639
 640         return rc;
 641 }
 642
 643 static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
 644                                 struct digital_data_exch *data_exch, u8 rtox)
 645 {
 646         struct digital_dep_req_res *dep_req;
 647         struct sk_buff *skb;
 648         int rc;
 649         u16 rwt_int;
 650
 651         rwt_int = ddev->dep_rwt * rtox;
 652         if (rwt_int > digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT])
 653                 rwt_int = digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT];
 654
 655         skb = digital_skb_alloc(ddev, 1);
 656         if (!skb)
 657                 return -ENOMEM;
 658
 659         *skb_put(skb, 1) = rtox;
 660
 661         skb_push(skb, sizeof(struct digital_dep_req_res));
 662
 663         dep_req = (struct digital_dep_req_res *)skb->data;
 664
 665         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 666         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
 667         dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
 668                        DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
 669
 670         digital_skb_push_dep_sod(ddev, skb);
 671
 672         ddev->skb_add_crc(skb);
 673
 674         rc = digital_in_send_cmd(ddev, skb, rwt_int,
 675                                  digital_in_recv_dep_res, data_exch);
 676         if (rc)
 677                 kfree_skb(skb);
 678
 679         return rc;
 680 }
 681
 682 static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev,
 683                                      struct digital_data_exch *data_exch)
 684 {
 685         int rc;
 686
 687         if (!ddev->saved_skb)
 688                 return -EINVAL;
 689
 690         skb_get(ddev->saved_skb);
 691
 692         rc = digital_in_send_cmd(ddev, ddev->saved_skb, ddev->dep_rwt,
 693                                  digital_in_recv_dep_res, data_exch);
 694         if (rc)
 695                 kfree_skb(ddev->saved_skb);
 696
 697         return rc;
 698 }
 699
 700 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
 701                                     struct sk_buff *resp)
 702 {
 703         struct digital_data_exch *data_exch = arg;
 704         struct digital_dep_req_res *dep_res;
 705         u8 pfb;
 706         uint size;
 707         int rc;
 708         u8 rtox;
 709
 710         if (IS_ERR(resp)) {
 711                 rc = PTR_ERR(resp);
 712                 resp = NULL;
 713
 714                 if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) &&
 715                     (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
 716                         ddev->atn_count = 0;
 717
 718                         rc = digital_in_send_nack(ddev, data_exch);
 719                         if (rc)
 720                                 goto error;
 721
 722                         return;
 723                 } else if ((rc == -ETIMEDOUT) &&
 724                            (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) {
 725                         ddev->nack_count = 0;
 726
 727                         rc = digital_in_send_atn(ddev, data_exch);
 728                         if (rc)
 729                                 goto error;
 730
 731                         return;
 732                 }
 733
 734                 goto exit;
 735         }
 736
 737         rc = digital_skb_pull_dep_sod(ddev, resp);
 738         if (rc) {
 739                 PROTOCOL_ERR("14.4.1.2");
 740                 goto exit;
 741         }
 742
 743         rc = ddev->skb_check_crc(resp);
 744         if (rc) {
 745                 if ((resp->len >= 4) &&
 746                     (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) {
 747                         ddev->atn_count = 0;
 748
 749                         rc = digital_in_send_nack(ddev, data_exch);
 750                         if (rc)
 751                                 goto error;
 752
 753                         kfree_skb(resp);
 754
 755                         return;
 756                 }
 757
 758                 PROTOCOL_ERR("14.4.1.6");
 759                 goto error;
 760         }
 761
 762         ddev->atn_count = 0;
 763         ddev->nack_count = 0;
 764
 765         if (resp->len > ddev->local_payload_max) {
 766                 rc = -EMSGSIZE;
 767                 goto exit;
 768         }
 769
 770         size = sizeof(struct digital_dep_req_res);
 771         dep_res = (struct digital_dep_req_res *)resp->data;
 772
 773         if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
 774             dep_res->cmd != DIGITAL_CMD_DEP_RES) {
 775                 rc = -EIO;
 776                 goto error;
 777         }
 778
 779         pfb = dep_res->pfb;
 780
 781         if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
 782                 PROTOCOL_ERR("14.8.2.1");
 783                 rc = -EIO;
 784                 goto error;
 785         }
 786
 787         if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
 788                 rc = -EIO;
 789                 goto exit;
 790         }
 791
 792         if (size > resp->len) {
 793                 rc = -EIO;
 794                 goto error;
 795         }
 796
 797         skb_pull(resp, size);
 798
 799         switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
 800         case DIGITAL_NFC_DEP_PFB_I_PDU:
 801                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
 802                         PROTOCOL_ERR("14.12.3.3");
 803                         rc = -EIO;
 804                         goto error;
 805                 }
 806
 807                 ddev->curr_nfc_dep_pni =
 808                         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
 809
 810                 kfree_skb(ddev->saved_skb);
 811                 ddev->saved_skb = NULL;
 812
 813                 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
 814                                                     digital_in_send_ack,
 815                                                     data_exch);
 816                 if (IS_ERR(resp)) {
 817                         rc = PTR_ERR(resp);
 818                         resp = NULL;
 819                         goto error;
 820                 }
 821
 822                 /* If resp is NULL then we're still chaining so return and
 823                  * wait for the next part of the PDU.  Else, the PDU is
 824                  * complete so pass it up.
 825                  */
 826                 if (!resp)
 827                         return;
 828
 829                 rc = 0;
 830                 break;
 831
 832         case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
 833                 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) {
 834                         PROTOCOL_ERR("14.12.4.5");
 835                         rc = -EIO;
 836                         goto exit;
 837                 }
 838
 839                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
 840                         PROTOCOL_ERR("14.12.3.3");
 841                         rc = -EIO;
 842                         goto exit;
 843                 }
 844
 845                 ddev->curr_nfc_dep_pni =
 846                         DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
 847
 848                 if (!ddev->chaining_skb) {
 849                         PROTOCOL_ERR("14.12.4.3");
 850                         rc = -EIO;
 851                         goto exit;
 852                 }
 853
 854                 /* The initiator has received a valid ACK. Free the last sent
 855                  * PDU and keep on sending chained skb.
 856                  */
 857                 kfree_skb(ddev->saved_skb);
 858                 ddev->saved_skb = NULL;
 859
 860                 rc = digital_in_send_dep_req(ddev, NULL,
 861                                              ddev->chaining_skb,
 862                                              ddev->data_exch);
 863                 if (rc)
 864                         goto error;
 865
 866                 goto free_resp;
 867
 868         case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
 869                 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */
 870                         rc = digital_in_send_saved_skb(ddev, data_exch);
 871                         if (rc)
 872                                 goto error;
 873
 874                         goto free_resp;
 875                 }
 876
 877                 if (ddev->atn_count || ddev->nack_count) {
 878                         PROTOCOL_ERR("14.12.4.4");
 879                         rc = -EIO;
 880                         goto error;
 881                 }
 882
 883                 rtox = DIGITAL_NFC_DEP_RTOX_VALUE(resp->data[0]);
 884                 if (!rtox || rtox > DIGITAL_NFC_DEP_RTOX_MAX) {
 885                         PROTOCOL_ERR("14.8.4.1");
 886                         rc = -EIO;
 887                         goto error;
 888                 }
 889
 890                 rc = digital_in_send_rtox(ddev, data_exch, rtox);
 891                 if (rc)
 892                         goto error;
 893
 894                 goto free_resp;
 895         }
 896
 897 exit:
 898         data_exch->cb(data_exch->cb_context, resp, rc);
 899
 900 error:
 901         kfree(data_exch);
 902
 903         kfree_skb(ddev->chaining_skb);
 904         ddev->chaining_skb = NULL;
 905
 906         kfree_skb(ddev->saved_skb);
 907         ddev->saved_skb = NULL;
 908
 909         if (rc)
 910                 kfree_skb(resp);
 911
 912         return;
 913
 914 free_resp:
 915         dev_kfree_skb(resp);
 916 }
 917
 918 int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
 919                             struct nfc_target *target, struct sk_buff *skb,
 920                             struct digital_data_exch *data_exch)
 921 {
 922         struct digital_dep_req_res *dep_req;
 923         struct sk_buff *chaining_skb, *tmp_skb;
 924         int rc;
 925
 926         skb_push(skb, sizeof(struct digital_dep_req_res));
 927
 928         dep_req = (struct digital_dep_req_res *)skb->data;
 929
 930         dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
 931         dep_req->cmd = DIGITAL_CMD_DEP_REQ;
 932         dep_req->pfb = ddev->curr_nfc_dep_pni;
 933
 934         ddev->atn_count = 0;
 935         ddev->nack_count = 0;
 936
 937         chaining_skb = ddev->chaining_skb;
 938
 939         tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req, data_exch);
 940         if (IS_ERR(tmp_skb))
 941                 return PTR_ERR(tmp_skb);
 942
 943         digital_skb_push_dep_sod(ddev, tmp_skb);
 944
 945         ddev->skb_add_crc(tmp_skb);
 946
 947         ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
 948
 949         rc = digital_in_send_cmd(ddev, tmp_skb, ddev->dep_rwt,
 950                                  digital_in_recv_dep_res, data_exch);
 951         if (rc) {
 952                 if (tmp_skb != skb)
 953                         kfree_skb(tmp_skb);
 954
 955                 kfree_skb(chaining_skb);
 956                 ddev->chaining_skb = NULL;
 957
 958                 kfree_skb(ddev->saved_skb);
 959                 ddev->saved_skb = NULL;
 960         }
 961
 962         return rc;
 963 }
 964
 965 static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech)
 966 {
 967         ddev->curr_rf_tech = rf_tech;
 968
 969         ddev->skb_add_crc = digital_skb_add_crc_none;
 970         ddev->skb_check_crc = digital_skb_check_crc_none;
 971
 972         if (DIGITAL_DRV_CAPS_TG_CRC(ddev))
 973                 return;
 974
 975         switch (ddev->curr_rf_tech) {
 976         case NFC_DIGITAL_RF_TECH_106A:
 977                 ddev->skb_add_crc = digital_skb_add_crc_a;
 978                 ddev->skb_check_crc = digital_skb_check_crc_a;
 979                 break;
 980
 981         case NFC_DIGITAL_RF_TECH_212F:
 982         case NFC_DIGITAL_RF_TECH_424F:
 983                 ddev->skb_add_crc = digital_skb_add_crc_f;
 984                 ddev->skb_check_crc = digital_skb_check_crc_f;
 985                 break;
 986
 987         default:
 988                 break;
 989         }
 990 }
 991
 992 static int digital_tg_send_ack(struct nfc_digital_dev *ddev,
 993                                struct digital_data_exch *data_exch)
 994 {
 995         struct digital_dep_req_res *dep_res;
 996         struct sk_buff *skb;
 997         int rc;
 998
 999         skb = digital_skb_alloc(ddev, 1);
1000         if (!skb)
1001                 return -ENOMEM;
1002
1003         skb_push(skb, sizeof(struct digital_dep_req_res));
1004
1005         dep_res = (struct digital_dep_req_res *)skb->data;
1006
1007         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1008         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1009         dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU |
1010                        ddev->curr_nfc_dep_pni;
1011
1012         if (ddev->did) {
1013                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1014
1015                 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1016                        sizeof(ddev->did));
1017         }
1018
1019         ddev->curr_nfc_dep_pni =
1020                 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1021
1022         digital_skb_push_dep_sod(ddev, skb);
1023
1024         ddev->skb_add_crc(skb);
1025
1026         ddev->saved_skb = pskb_copy(skb, GFP_KERNEL);
1027
1028         rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1029                                  data_exch);
1030         if (rc) {
1031                 kfree_skb(skb);
1032                 kfree_skb(ddev->saved_skb);
1033                 ddev->saved_skb = NULL;
1034         }
1035
1036         return rc;
1037 }
1038
1039 static int digital_tg_send_atn(struct nfc_digital_dev *ddev)
1040 {
1041         struct digital_dep_req_res *dep_res;
1042         struct sk_buff *skb;
1043         int rc;
1044
1045         skb = digital_skb_alloc(ddev, 1);
1046         if (!skb)
1047                 return -ENOMEM;
1048
1049         skb_push(skb, sizeof(struct digital_dep_req_res));
1050
1051         dep_res = (struct digital_dep_req_res *)skb->data;
1052
1053         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1054         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1055         dep_res->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU;
1056
1057         if (ddev->did) {
1058                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1059
1060                 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1061                        sizeof(ddev->did));
1062         }
1063
1064         digital_skb_push_dep_sod(ddev, skb);
1065
1066         ddev->skb_add_crc(skb);
1067
1068         rc = digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req,
1069                                  NULL);
1070         if (rc)
1071                 kfree_skb(skb);
1072
1073         return rc;
1074 }
1075
1076 static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev)
1077 {
1078         int rc;
1079
1080         if (!ddev->saved_skb)
1081                 return -EINVAL;
1082
1083         skb_get(ddev->saved_skb);
1084
1085         rc = digital_tg_send_cmd(ddev, ddev->saved_skb, 1500,
1086                                  digital_tg_recv_dep_req, NULL);
1087         if (rc)
1088                 kfree_skb(ddev->saved_skb);
1089
1090         return rc;
1091 }
1092
1093 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg,
1094                                     struct sk_buff *resp)
1095 {
1096         int rc;
1097         struct digital_dep_req_res *dep_req;
1098         u8 pfb;
1099         size_t size;
1100
1101         if (IS_ERR(resp)) {
1102                 rc = PTR_ERR(resp);
1103                 resp = NULL;
1104                 goto exit;
1105         }
1106
1107         rc = ddev->skb_check_crc(resp);
1108         if (rc) {
1109                 PROTOCOL_ERR("14.4.1.6");
1110                 goto exit;
1111         }
1112
1113         rc = digital_skb_pull_dep_sod(ddev, resp);
1114         if (rc) {
1115                 PROTOCOL_ERR("14.4.1.2");
1116                 goto exit;
1117         }
1118
1119         if (resp->len > ddev->local_payload_max) {
1120                 rc = -EMSGSIZE;
1121                 goto exit;
1122         }
1123
1124         size = sizeof(struct digital_dep_req_res);
1125         dep_req = (struct digital_dep_req_res *)resp->data;
1126
1127         if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1128             dep_req->cmd != DIGITAL_CMD_DEP_REQ) {
1129                 rc = -EIO;
1130                 goto exit;
1131         }
1132
1133         pfb = dep_req->pfb;
1134
1135         if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) {
1136                 if (ddev->did && (ddev->did == resp->data[3])) {
1137                         size++;
1138                 } else {
1139                         rc = -EIO;
1140                         goto exit;
1141                 }
1142         } else if (ddev->did) {
1143                 rc = -EIO;
1144                 goto exit;
1145         }
1146
1147         if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) {
1148                 rc = -EIO;
1149                 goto exit;
1150         }
1151
1152         if (size > resp->len) {
1153                 rc = -EIO;
1154                 goto exit;
1155         }
1156
1157         skb_pull(resp, size);
1158
1159         switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
1160         case DIGITAL_NFC_DEP_PFB_I_PDU:
1161                 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n");
1162
1163                 if (ddev->atn_count) {
1164                         /* The target has received (and replied to) at least one
1165                          * ATN DEP_REQ.
1166                          */
1167                         ddev->atn_count = 0;
1168
1169                         /* pni of resp PDU equal to the target current pni - 1
1170                          * means resp is the previous DEP_REQ PDU received from
1171                          * the initiator so the target replies with saved_skb
1172                          * which is the previous DEP_RES saved in
1173                          * digital_tg_send_dep_res().
1174                          */
1175                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb) ==
1176                           DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) {
1177                                 rc = digital_tg_send_saved_skb(ddev);
1178                                 if (rc)
1179                                         goto exit;
1180
1181                                 goto free_resp;
1182                         }
1183
1184                         /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1
1185                          * means the target probably did not received the last
1186                          * DEP_REQ PDU sent by the initiator. The target
1187                          * fallbacks to normal processing then.
1188                          */
1189                 }
1190
1191                 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
1192                         PROTOCOL_ERR("14.12.3.4");
1193                         rc = -EIO;
1194                         goto exit;
1195                 }
1196
1197                 kfree_skb(ddev->saved_skb);
1198                 ddev->saved_skb = NULL;
1199
1200                 resp = digital_recv_dep_data_gather(ddev, pfb, resp,
1201                                                     digital_tg_send_ack, NULL);
1202                 if (IS_ERR(resp)) {
1203                         rc = PTR_ERR(resp);
1204                         resp = NULL;
1205                         goto exit;
1206                 }
1207
1208                 /* If resp is NULL then we're still chaining so return and
1209                  * wait for the next part of the PDU.  Else, the PDU is
1210                  * complete so pass it up.
1211                  */
1212                 if (!resp)
1213                         return;
1214
1215                 rc = 0;
1216                 break;
1217         case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
1218                 if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */
1219                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) !=
1220                                                 ddev->curr_nfc_dep_pni) {
1221                                 rc = -EIO;
1222                                 goto exit;
1223                         }
1224
1225                         ddev->atn_count = 0;
1226
1227                         rc = digital_tg_send_saved_skb(ddev);
1228                         if (rc)
1229                                 goto exit;
1230
1231                         goto free_resp;
1232                 }
1233
1234                 /* ACK */
1235                 if (ddev->atn_count) {
1236                         /* The target has previously recevied one or more ATN
1237                          * PDUs.
1238                          */
1239                         ddev->atn_count = 0;
1240
1241                         /* If the ACK PNI is equal to the target PNI - 1 means
1242                          * that the initiator did not receive the previous PDU
1243                          * sent by the target so re-send it.
1244                          */
1245                         if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) ==
1246                                                 ddev->curr_nfc_dep_pni) {
1247                                 rc = digital_tg_send_saved_skb(ddev);
1248                                 if (rc)
1249                                         goto exit;
1250
1251                                 goto free_resp;
1252                         }
1253
1254                         /* Otherwise, the target did not receive the previous
1255                          * ACK PDU from the initiator. Fallback to normal
1256                          * processing of chained PDU then.
1257                          */
1258                 }
1259
1260                 /* Keep on sending chained PDU */
1261                 if (!ddev->chaining_skb ||
1262                     DIGITAL_NFC_DEP_PFB_PNI(pfb) !=
1263                                         ddev->curr_nfc_dep_pni) {
1264                         rc = -EIO;
1265                         goto exit;
1266                 }
1267
1268                 kfree_skb(ddev->saved_skb);
1269                 ddev->saved_skb = NULL;
1270
1271                 rc = digital_tg_send_dep_res(ddev, ddev->chaining_skb);
1272                 if (rc)
1273                         goto exit;
1274
1275                 goto free_resp;
1276         case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
1277                 if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
1278                         rc = -EINVAL;
1279                         goto exit;
1280                 }
1281
1282                 rc = digital_tg_send_atn(ddev);
1283                 if (rc)
1284                         goto exit;
1285
1286                 ddev->atn_count++;
1287
1288                 goto free_resp;
1289         }
1290
1291         rc = nfc_tm_data_received(ddev->nfc_dev, resp);
1292
1293 exit:
1294         kfree_skb(ddev->chaining_skb);
1295         ddev->chaining_skb = NULL;
1296
1297         ddev->atn_count = 0;
1298
1299         kfree_skb(ddev->saved_skb);
1300         ddev->saved_skb = NULL;
1301
1302         if (rc)
1303                 kfree_skb(resp);
1304
1305         return;
1306
1307 free_resp:
1308         dev_kfree_skb(resp);
1309 }
1310
1311 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb)
1312 {
1313         struct digital_dep_req_res *dep_res;
1314         struct sk_buff *chaining_skb, *tmp_skb;
1315         int rc;
1316
1317         skb_push(skb, sizeof(struct digital_dep_req_res));
1318
1319         dep_res = (struct digital_dep_req_res *)skb->data;
1320
1321         dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1322         dep_res->cmd = DIGITAL_CMD_DEP_RES;
1323         dep_res->pfb = ddev->curr_nfc_dep_pni;
1324
1325         if (ddev->did) {
1326                 dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT;
1327
1328                 memcpy(skb_put(skb, sizeof(ddev->did)), &ddev->did,
1329                        sizeof(ddev->did));
1330         }
1331
1332         ddev->curr_nfc_dep_pni =
1333                 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
1334
1335         chaining_skb = ddev->chaining_skb;
1336
1337         tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_res, NULL);
1338         if (IS_ERR(tmp_skb))
1339                 return PTR_ERR(tmp_skb);
1340
1341         digital_skb_push_dep_sod(ddev, tmp_skb);
1342
1343         ddev->skb_add_crc(tmp_skb);
1344
1345         ddev->saved_skb = pskb_copy(tmp_skb, GFP_KERNEL);
1346
1347         rc = digital_tg_send_cmd(ddev, tmp_skb, 1500, digital_tg_recv_dep_req,
1348                                  NULL);
1349         if (rc) {
1350                 if (tmp_skb != skb)
1351                         kfree_skb(tmp_skb);
1352
1353                 kfree_skb(chaining_skb);
1354                 ddev->chaining_skb = NULL;
1355
1356                 kfree_skb(ddev->saved_skb);
1357                 ddev->saved_skb = NULL;
1358         }
1359
1360         return rc;
1361 }
1362
1363 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev,
1364                                              void *arg, struct sk_buff *resp)
1365 {
1366         u8 rf_tech = (unsigned long)arg;
1367
1368         if (IS_ERR(resp))
1369                 return;
1370
1371         digital_tg_set_rf_tech(ddev, rf_tech);
1372
1373         digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1374
1375         digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL);
1376
1377         dev_kfree_skb(resp);
1378 }
1379
1380 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did,
1381                                    u8 rf_tech)
1382 {
1383         struct digital_psl_res *psl_res;
1384         struct sk_buff *skb;
1385         int rc;
1386
1387         skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res));
1388         if (!skb)
1389                 return -ENOMEM;
1390
1391         skb_put(skb, sizeof(struct digital_psl_res));
1392
1393         psl_res = (struct digital_psl_res *)skb->data;
1394
1395         psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1396         psl_res->cmd = DIGITAL_CMD_PSL_RES;
1397         psl_res->did = did;
1398
1399         digital_skb_push_dep_sod(ddev, skb);
1400
1401         ddev->skb_add_crc(skb);
1402
1403         ddev->curr_nfc_dep_pni = 0;
1404
1405         rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete,
1406                                  (void *)(unsigned long)rf_tech);
1407         if (rc)
1408                 kfree_skb(skb);
1409
1410         return rc;
1411 }
1412
1413 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg,
1414                                     struct sk_buff *resp)
1415 {
1416         int rc;
1417         struct digital_psl_req *psl_req;
1418         u8 rf_tech;
1419         u8 dsi, payload_size, payload_bits;
1420
1421         if (IS_ERR(resp)) {
1422                 rc = PTR_ERR(resp);
1423                 resp = NULL;
1424                 goto exit;
1425         }
1426
1427         rc = ddev->skb_check_crc(resp);
1428         if (rc) {
1429                 PROTOCOL_ERR("14.4.1.6");
1430                 goto exit;
1431         }
1432
1433         rc = digital_skb_pull_dep_sod(ddev, resp);
1434         if (rc) {
1435                 PROTOCOL_ERR("14.4.1.2");
1436                 goto exit;
1437         }
1438
1439         psl_req = (struct digital_psl_req *)resp->data;
1440
1441         if (resp->len != sizeof(struct digital_psl_req) ||
1442             psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1443             psl_req->cmd != DIGITAL_CMD_PSL_REQ) {
1444                 rc = -EIO;
1445                 goto exit;
1446         }
1447
1448         dsi = (psl_req->brs >> 3) & 0x07;
1449         switch (dsi) {
1450         case 0:
1451                 rf_tech = NFC_DIGITAL_RF_TECH_106A;
1452                 break;
1453         case 1:
1454                 rf_tech = NFC_DIGITAL_RF_TECH_212F;
1455                 break;
1456         case 2:
1457                 rf_tech = NFC_DIGITAL_RF_TECH_424F;
1458                 break;
1459         default:
1460                 pr_err("Unsupported dsi value %d\n", dsi);
1461                 goto exit;
1462         }
1463
1464         payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl);
1465         payload_size = digital_payload_bits_to_size(payload_bits);
1466
1467         if (!payload_size || (payload_size > min(ddev->local_payload_max,
1468                                                  ddev->remote_payload_max))) {
1469                 rc = -EINVAL;
1470                 goto exit;
1471         }
1472
1473         ddev->local_payload_max = payload_size;
1474         ddev->remote_payload_max = payload_size;
1475
1476         rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech);
1477
1478 exit:
1479         kfree_skb(resp);
1480 }
1481
1482 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev,
1483                                              void *arg, struct sk_buff *resp)
1484 {
1485         int offset;
1486
1487         if (IS_ERR(resp)) {
1488                 digital_poll_next_tech(ddev);
1489                 return;
1490         }
1491
1492         offset = 2;
1493         if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB)
1494                 offset++;
1495
1496         ddev->atn_count = 0;
1497
1498         if (resp->data[offset] == DIGITAL_CMD_PSL_REQ)
1499                 digital_tg_recv_psl_req(ddev, arg, resp);
1500         else
1501                 digital_tg_recv_dep_req(ddev, arg, resp);
1502 }
1503
1504 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev,
1505                                    struct digital_atr_req *atr_req)
1506 {
1507         struct digital_atr_res *atr_res;
1508         struct sk_buff *skb;
1509         u8 *gb, payload_bits;
1510         size_t gb_len;
1511         int rc;
1512
1513         gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len);
1514         if (!gb)
1515                 gb_len = 0;
1516
1517         skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len);
1518         if (!skb)
1519                 return -ENOMEM;
1520
1521         skb_put(skb, sizeof(struct digital_atr_res));
1522         atr_res = (struct digital_atr_res *)skb->data;
1523
1524         memset(atr_res, 0, sizeof(struct digital_atr_res));
1525
1526         atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN;
1527         atr_res->cmd = DIGITAL_CMD_ATR_RES;
1528         memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3));
1529         atr_res->to = DIGITAL_NFC_DEP_TG_MAX_WT;
1530
1531         ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX;
1532         payload_bits = digital_payload_size_to_bits(ddev->local_payload_max);
1533         atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits);
1534
1535         if (gb_len) {
1536                 skb_put(skb, gb_len);
1537
1538                 atr_res->pp |= DIGITAL_GB_BIT;
1539                 memcpy(atr_res->gb, gb, gb_len);
1540         }
1541
1542         digital_skb_push_dep_sod(ddev, skb);
1543
1544         ddev->skb_add_crc(skb);
1545
1546         ddev->curr_nfc_dep_pni = 0;
1547
1548         rc = digital_tg_send_cmd(ddev, skb, 999,
1549                                  digital_tg_send_atr_res_complete, NULL);
1550         if (rc)
1551                 kfree_skb(skb);
1552
1553         return rc;
1554 }
1555
1556 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg,
1557                              struct sk_buff *resp)
1558 {
1559         int rc;
1560         struct digital_atr_req *atr_req;
1561         size_t gb_len, min_size;
1562         u8 poll_tech_count, payload_bits;
1563
1564         if (IS_ERR(resp)) {
1565                 rc = PTR_ERR(resp);
1566                 resp = NULL;
1567                 goto exit;
1568         }
1569
1570         if (!resp->len) {
1571                 rc = -EIO;
1572                 goto exit;
1573         }
1574
1575         if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) {
1576                 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2;
1577                 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_106A);
1578         } else {
1579                 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1;
1580                 digital_tg_set_rf_tech(ddev, NFC_DIGITAL_RF_TECH_212F);
1581         }
1582
1583         if (resp->len < min_size) {
1584                 rc = -EIO;
1585                 goto exit;
1586         }
1587
1588         ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK;
1589
1590         rc = ddev->skb_check_crc(resp);
1591         if (rc) {
1592                 PROTOCOL_ERR("14.4.1.6");
1593                 goto exit;
1594         }
1595
1596         rc = digital_skb_pull_dep_sod(ddev, resp);
1597         if (rc) {
1598                 PROTOCOL_ERR("14.4.1.2");
1599                 goto exit;
1600         }
1601
1602         atr_req = (struct digital_atr_req *)resp->data;
1603
1604         if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT ||
1605             atr_req->cmd != DIGITAL_CMD_ATR_REQ ||
1606             atr_req->did > DIGITAL_DID_MAX) {
1607                 rc = -EINVAL;
1608                 goto exit;
1609         }
1610
1611         payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp);
1612         ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits);
1613
1614         if (!ddev->remote_payload_max) {
1615                 rc = -EINVAL;
1616                 goto exit;
1617         }
1618
1619         ddev->did = atr_req->did;
1620
1621         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1622                                      NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED);
1623         if (rc)
1624                 goto exit;
1625
1626         rc = digital_tg_send_atr_res(ddev, atr_req);
1627         if (rc)
1628                 goto exit;
1629
1630         gb_len = resp->len - sizeof(struct digital_atr_req);
1631
1632         poll_tech_count = ddev->poll_tech_count;
1633         ddev->poll_tech_count = 0;
1634
1635         rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
1636                               NFC_COMM_PASSIVE, atr_req->gb, gb_len);
1637         if (rc) {
1638                 ddev->poll_tech_count = poll_tech_count;
1639                 goto exit;
1640         }
1641
1642         rc = 0;
1643 exit:
1644         if (rc)
1645                 digital_poll_next_tech(ddev);
1646
1647         dev_kfree_skb(resp);
1648 }