net/nfc/digital_technology.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * NFC Digital Protocol stack
   4  * Copyright (c) 2013, Intel Corporation.
   5  */
   6
   7 #define pr_fmt(fmt) "digital: %s: " fmt, __func__
   8
   9 #include "digital.h"
  10
  11 #define DIGITAL_CMD_SENS_REQ    0x26
  12 #define DIGITAL_CMD_ALL_REQ     0x52
  13 #define DIGITAL_CMD_SEL_REQ_CL1 0x93
  14 #define DIGITAL_CMD_SEL_REQ_CL2 0x95
  15 #define DIGITAL_CMD_SEL_REQ_CL3 0x97
  16
  17 #define DIGITAL_SDD_REQ_SEL_PAR 0x20
  18
  19 #define DIGITAL_SDD_RES_CT  0x88
  20 #define DIGITAL_SDD_RES_LEN 5
  21 #define DIGITAL_SEL_RES_LEN 1
  22
  23 #define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
  24 #define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
  25 #define DIGITAL_SEL_RES_IS_T4T(sel_res) ((sel_res) & 0x20)
  26 #define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
  27
  28 #define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x0C00) == 0x0C00)
  29 #define DIGITAL_SENS_RES_IS_VALID(sens_res) \
  30         ((!((sens_res) & 0x001F) && (((sens_res) & 0x0C00) == 0x0C00)) || \
  31         (((sens_res) & 0x001F) && ((sens_res) & 0x0C00) != 0x0C00))
  32
  33 #define DIGITAL_MIFARE_READ_RES_LEN 16
  34 #define DIGITAL_MIFARE_ACK_RES  0x0A
  35
  36 #define DIGITAL_CMD_SENSB_REQ                   0x05
  37 #define DIGITAL_SENSB_ADVANCED                  BIT(5)
  38 #define DIGITAL_SENSB_EXTENDED                  BIT(4)
  39 #define DIGITAL_SENSB_ALLB_REQ                  BIT(3)
  40 #define DIGITAL_SENSB_N(n)                      ((n) & 0x7)
  41
  42 #define DIGITAL_CMD_SENSB_RES                   0x50
  43
  44 #define DIGITAL_CMD_ATTRIB_REQ                  0x1D
  45 #define DIGITAL_ATTRIB_P1_TR0_DEFAULT           (0x0 << 6)
  46 #define DIGITAL_ATTRIB_P1_TR1_DEFAULT           (0x0 << 4)
  47 #define DIGITAL_ATTRIB_P1_SUPRESS_EOS           BIT(3)
  48 #define DIGITAL_ATTRIB_P1_SUPRESS_SOS           BIT(2)
  49 #define DIGITAL_ATTRIB_P2_LISTEN_POLL_1         (0x0 << 6)
  50 #define DIGITAL_ATTRIB_P2_POLL_LISTEN_1         (0x0 << 4)
  51 #define DIGITAL_ATTRIB_P2_MAX_FRAME_256         0x8
  52 #define DIGITAL_ATTRIB_P4_DID(n)                ((n) & 0xf)
  53
  54 #define DIGITAL_CMD_SENSF_REQ   0x00
  55 #define DIGITAL_CMD_SENSF_RES   0x01
  56
  57 #define DIGITAL_SENSF_RES_MIN_LENGTH 17
  58 #define DIGITAL_SENSF_RES_RD_AP_B1   0x00
  59 #define DIGITAL_SENSF_RES_RD_AP_B2   0x8F
  60
  61 #define DIGITAL_SENSF_REQ_RC_NONE 0
  62 #define DIGITAL_SENSF_REQ_RC_SC   1
  63 #define DIGITAL_SENSF_REQ_RC_AP   2
  64
  65 #define DIGITAL_CMD_ISO15693_INVENTORY_REQ      0x01
  66
  67 #define DIGITAL_ISO15693_REQ_FLAG_DATA_RATE     BIT(1)
  68 #define DIGITAL_ISO15693_REQ_FLAG_INVENTORY     BIT(2)
  69 #define DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS      BIT(5)
  70 #define DIGITAL_ISO15693_RES_FLAG_ERROR         BIT(0)
  71 #define DIGITAL_ISO15693_RES_IS_VALID(flags) \
  72         (!((flags) & DIGITAL_ISO15693_RES_FLAG_ERROR))
  73
  74 #define DIGITAL_ISO_DEP_I_PCB    0x02
  75 #define DIGITAL_ISO_DEP_PNI(pni) ((pni) & 0x01)
  76
  77 #define DIGITAL_ISO_DEP_PCB_TYPE(pcb) ((pcb) & 0xC0)
  78
  79 #define DIGITAL_ISO_DEP_I_BLOCK 0x00
  80
  81 #define DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb) ((pcb) & 0x08)
  82
  83 static const u8 digital_ats_fsc[] = {
  84          16,  24,  32,  40,  48,  64,  96, 128,
  85 };
  86
  87 #define DIGITAL_ATS_FSCI(t0) ((t0) & 0x0F)
  88 #define DIGITAL_SENSB_FSCI(pi2) (((pi2) & 0xF0) >> 4)
  89 #define DIGITAL_ATS_MAX_FSC  256
  90
  91 #define DIGITAL_RATS_BYTE1 0xE0
  92 #define DIGITAL_RATS_PARAM 0x80
  93
  94 struct digital_sdd_res {
  95         u8 nfcid1[4];
  96         u8 bcc;
  97 } __packed;
  98
  99 struct digital_sel_req {
 100         u8 sel_cmd;
 101         u8 b2;
 102         u8 nfcid1[4];
 103         u8 bcc;
 104 } __packed;
 105
 106 struct digital_sensb_req {
 107         u8 cmd;
 108         u8 afi;
 109         u8 param;
 110 } __packed;
 111
 112 struct digital_sensb_res {
 113         u8 cmd;
 114         u8 nfcid0[4];
 115         u8 app_data[4];
 116         u8 proto_info[3];
 117 } __packed;
 118
 119 struct digital_attrib_req {
 120         u8 cmd;
 121         u8 nfcid0[4];
 122         u8 param1;
 123         u8 param2;
 124         u8 param3;
 125         u8 param4;
 126 } __packed;
 127
 128 struct digital_attrib_res {
 129         u8 mbli_did;
 130 } __packed;
 131
 132 struct digital_sensf_req {
 133         u8 cmd;
 134         u8 sc1;
 135         u8 sc2;
 136         u8 rc;
 137         u8 tsn;
 138 } __packed;
 139
 140 struct digital_sensf_res {
 141         u8 cmd;
 142         u8 nfcid2[8];
 143         u8 pad0[2];
 144         u8 pad1[3];
 145         u8 mrti_check;
 146         u8 mrti_update;
 147         u8 pad2;
 148         u8 rd[2];
 149 } __packed;
 150
 151 struct digital_iso15693_inv_req {
 152         u8 flags;
 153         u8 cmd;
 154         u8 mask_len;
 155         u64 mask;
 156 } __packed;
 157
 158 struct digital_iso15693_inv_res {
 159         u8 flags;
 160         u8 dsfid;
 161         u64 uid;
 162 } __packed;
 163
 164 static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
 165                                    struct nfc_target *target);
 166
 167 int digital_in_iso_dep_pull_sod(struct nfc_digital_dev *ddev,
 168                                 struct sk_buff *skb)
 169 {
 170         u8 pcb;
 171         u8 block_type;
 172
 173         if (skb->len < 1)
 174                 return -EIO;
 175
 176         pcb = *skb->data;
 177         block_type = DIGITAL_ISO_DEP_PCB_TYPE(pcb);
 178
 179         /* No support fo R-block nor S-block */
 180         if (block_type != DIGITAL_ISO_DEP_I_BLOCK) {
 181                 pr_err("ISO_DEP R-block and S-block not supported\n");
 182                 return -EIO;
 183         }
 184
 185         if (DIGITAL_ISO_DEP_BLOCK_HAS_DID(pcb)) {
 186                 pr_err("DID field in ISO_DEP PCB not supported\n");
 187                 return -EIO;
 188         }
 189
 190         skb_pull(skb, 1);
 191
 192         return 0;
 193 }
 194
 195 int digital_in_iso_dep_push_sod(struct nfc_digital_dev *ddev,
 196                                 struct sk_buff *skb)
 197 {
 198         /*
 199          * Chaining not supported so skb->len + 1 PCB byte + 2 CRC bytes must
 200          * not be greater than remote FSC
 201          */
 202         if (skb->len + 3 > ddev->target_fsc)
 203                 return -EIO;
 204
 205         skb_push(skb, 1);
 206
 207         *skb->data = DIGITAL_ISO_DEP_I_PCB | ddev->curr_nfc_dep_pni;
 208
 209         ddev->curr_nfc_dep_pni =
 210                 DIGITAL_ISO_DEP_PNI(ddev->curr_nfc_dep_pni + 1);
 211
 212         return 0;
 213 }
 214
 215 static void digital_in_recv_ats(struct nfc_digital_dev *ddev, void *arg,
 216                                 struct sk_buff *resp)
 217 {
 218         struct nfc_target *target = arg;
 219         u8 fsdi;
 220         int rc;
 221
 222         if (IS_ERR(resp)) {
 223                 rc = PTR_ERR(resp);
 224                 resp = NULL;
 225                 goto exit;
 226         }
 227
 228         if (resp->len < 2) {
 229                 rc = -EIO;
 230                 goto exit;
 231         }
 232
 233         fsdi = DIGITAL_ATS_FSCI(resp->data[1]);
 234         if (fsdi >= 8)
 235                 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
 236         else
 237                 ddev->target_fsc = digital_ats_fsc[fsdi];
 238
 239         ddev->curr_nfc_dep_pni = 0;
 240
 241         rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443);
 242
 243 exit:
 244         dev_kfree_skb(resp);
 245         kfree(target);
 246
 247         if (rc)
 248                 digital_poll_next_tech(ddev);
 249 }
 250
 251 static int digital_in_send_rats(struct nfc_digital_dev *ddev,
 252                                 struct nfc_target *target)
 253 {
 254         int rc;
 255         struct sk_buff *skb;
 256
 257         skb = digital_skb_alloc(ddev, 2);
 258         if (!skb)
 259                 return -ENOMEM;
 260
 261         skb_put_u8(skb, DIGITAL_RATS_BYTE1);
 262         skb_put_u8(skb, DIGITAL_RATS_PARAM);
 263
 264         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_ats,
 265                                  target);
 266         if (rc)
 267                 kfree_skb(skb);
 268
 269         return rc;
 270 }
 271
 272 static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
 273                                     struct sk_buff *resp)
 274 {
 275         struct nfc_target *target = arg;
 276         int rc;
 277         u8 sel_res;
 278         u8 nfc_proto;
 279
 280         if (IS_ERR(resp)) {
 281                 rc = PTR_ERR(resp);
 282                 resp = NULL;
 283                 goto exit;
 284         }
 285
 286         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
 287                 rc = digital_skb_check_crc_a(resp);
 288                 if (rc) {
 289                         PROTOCOL_ERR("4.4.1.3");
 290                         goto exit;
 291                 }
 292         }
 293
 294         if (resp->len != DIGITAL_SEL_RES_LEN) {
 295                 rc = -EIO;
 296                 goto exit;
 297         }
 298
 299         sel_res = resp->data[0];
 300
 301         if (!DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res)) {
 302                 rc = digital_in_send_sdd_req(ddev, target);
 303                 if (rc)
 304                         goto exit;
 305
 306                 goto exit_free_skb;
 307         }
 308
 309         target->sel_res = sel_res;
 310
 311         if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
 312                 nfc_proto = NFC_PROTO_MIFARE;
 313         } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
 314                 nfc_proto = NFC_PROTO_NFC_DEP;
 315         } else if (DIGITAL_SEL_RES_IS_T4T(sel_res)) {
 316                 rc = digital_in_send_rats(ddev, target);
 317                 if (rc)
 318                         goto exit;
 319                 /*
 320                  * Skip target_found and don't free it for now. This will be
 321                  * done when receiving the ATS
 322                  */
 323                 goto exit_free_skb;
 324         } else {
 325                 rc = -EOPNOTSUPP;
 326                 goto exit;
 327         }
 328
 329         rc = digital_target_found(ddev, target, nfc_proto);
 330
 331 exit:
 332         kfree(target);
 333
 334 exit_free_skb:
 335         dev_kfree_skb(resp);
 336
 337         if (rc)
 338                 digital_poll_next_tech(ddev);
 339 }
 340
 341 static int digital_in_send_sel_req(struct nfc_digital_dev *ddev,
 342                                    struct nfc_target *target,
 343                                    struct digital_sdd_res *sdd_res)
 344 {
 345         struct sk_buff *skb;
 346         struct digital_sel_req *sel_req;
 347         u8 sel_cmd;
 348         int rc;
 349
 350         skb = digital_skb_alloc(ddev, sizeof(struct digital_sel_req));
 351         if (!skb)
 352                 return -ENOMEM;
 353
 354         skb_put(skb, sizeof(struct digital_sel_req));
 355         sel_req = (struct digital_sel_req *)skb->data;
 356
 357         if (target->nfcid1_len <= 4)
 358                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
 359         else if (target->nfcid1_len < 10)
 360                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
 361         else
 362                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
 363
 364         sel_req->sel_cmd = sel_cmd;
 365         sel_req->b2 = 0x70;
 366         memcpy(sel_req->nfcid1, sdd_res->nfcid1, 4);
 367         sel_req->bcc = sdd_res->bcc;
 368
 369         if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
 370                 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 371                                 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
 372                 if (rc)
 373                         goto exit;
 374         } else {
 375                 digital_skb_add_crc_a(skb);
 376         }
 377
 378         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sel_res,
 379                                  target);
 380 exit:
 381         if (rc)
 382                 kfree_skb(skb);
 383
 384         return rc;
 385 }
 386
 387 static void digital_in_recv_sdd_res(struct nfc_digital_dev *ddev, void *arg,
 388                                     struct sk_buff *resp)
 389 {
 390         struct nfc_target *target = arg;
 391         struct digital_sdd_res *sdd_res;
 392         int rc;
 393         u8 offset, size;
 394         u8 i, bcc;
 395
 396         if (IS_ERR(resp)) {
 397                 rc = PTR_ERR(resp);
 398                 resp = NULL;
 399                 goto exit;
 400         }
 401
 402         if (resp->len < DIGITAL_SDD_RES_LEN) {
 403                 PROTOCOL_ERR("4.7.2.8");
 404                 rc = -EINVAL;
 405                 goto exit;
 406         }
 407
 408         sdd_res = (struct digital_sdd_res *)resp->data;
 409
 410         for (i = 0, bcc = 0; i < 4; i++)
 411                 bcc ^= sdd_res->nfcid1[i];
 412
 413         if (bcc != sdd_res->bcc) {
 414                 PROTOCOL_ERR("4.7.2.6");
 415                 rc = -EINVAL;
 416                 goto exit;
 417         }
 418
 419         if (sdd_res->nfcid1[0] == DIGITAL_SDD_RES_CT) {
 420                 offset = 1;
 421                 size = 3;
 422         } else {
 423                 offset = 0;
 424                 size = 4;
 425         }
 426
 427         memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset,
 428                size);
 429         target->nfcid1_len += size;
 430
 431         rc = digital_in_send_sel_req(ddev, target, sdd_res);
 432
 433 exit:
 434         dev_kfree_skb(resp);
 435
 436         if (rc) {
 437                 kfree(target);
 438                 digital_poll_next_tech(ddev);
 439         }
 440 }
 441
 442 static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev,
 443                                    struct nfc_target *target)
 444 {
 445         int rc;
 446         struct sk_buff *skb;
 447         u8 sel_cmd;
 448
 449         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 450                                      NFC_DIGITAL_FRAMING_NFCA_STANDARD);
 451         if (rc)
 452                 return rc;
 453
 454         skb = digital_skb_alloc(ddev, 2);
 455         if (!skb)
 456                 return -ENOMEM;
 457
 458         if (target->nfcid1_len == 0)
 459                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1;
 460         else if (target->nfcid1_len == 3)
 461                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2;
 462         else
 463                 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3;
 464
 465         skb_put_u8(skb, sel_cmd);
 466         skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR);
 467
 468         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res,
 469                                  target);
 470         if (rc)
 471                 kfree_skb(skb);
 472
 473         return rc;
 474 }
 475
 476 static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg,
 477                                      struct sk_buff *resp)
 478 {
 479         struct nfc_target *target = NULL;
 480         int rc;
 481
 482         if (IS_ERR(resp)) {
 483                 rc = PTR_ERR(resp);
 484                 resp = NULL;
 485                 goto exit;
 486         }
 487
 488         if (resp->len < sizeof(u16)) {
 489                 rc = -EIO;
 490                 goto exit;
 491         }
 492
 493         target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
 494         if (!target) {
 495                 rc = -ENOMEM;
 496                 goto exit;
 497         }
 498
 499         target->sens_res = __le16_to_cpu(*(__le16 *)resp->data);
 500
 501         if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) {
 502                 PROTOCOL_ERR("4.6.3.3");
 503                 rc = -EINVAL;
 504                 goto exit;
 505         }
 506
 507         if (DIGITAL_SENS_RES_IS_T1T(target->sens_res))
 508                 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL);
 509         else
 510                 rc = digital_in_send_sdd_req(ddev, target);
 511
 512 exit:
 513         dev_kfree_skb(resp);
 514
 515         if (rc) {
 516                 kfree(target);
 517                 digital_poll_next_tech(ddev);
 518         }
 519 }
 520
 521 int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech)
 522 {
 523         struct sk_buff *skb;
 524         int rc;
 525
 526         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
 527                                      NFC_DIGITAL_RF_TECH_106A);
 528         if (rc)
 529                 return rc;
 530
 531         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 532                                      NFC_DIGITAL_FRAMING_NFCA_SHORT);
 533         if (rc)
 534                 return rc;
 535
 536         skb = digital_skb_alloc(ddev, 1);
 537         if (!skb)
 538                 return -ENOMEM;
 539
 540         skb_put_u8(skb, DIGITAL_CMD_SENS_REQ);
 541
 542         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL);
 543         if (rc)
 544                 kfree_skb(skb);
 545
 546         return rc;
 547 }
 548
 549 int digital_in_recv_mifare_res(struct sk_buff *resp)
 550 {
 551         /* Successful READ command response is 16 data bytes + 2 CRC bytes long.
 552          * Since the driver can't differentiate a ACK/NACK response from a valid
 553          * READ response, the CRC calculation must be handled at digital level
 554          * even if the driver supports it for this technology.
 555          */
 556         if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) {
 557                 if (digital_skb_check_crc_a(resp)) {
 558                         PROTOCOL_ERR("9.4.1.2");
 559                         return -EIO;
 560                 }
 561
 562                 return 0;
 563         }
 564
 565         /* ACK response (i.e. successful WRITE). */
 566         if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) {
 567                 resp->data[0] = 0;
 568                 return 0;
 569         }
 570
 571         /* NACK and any other responses are treated as error. */
 572         return -EIO;
 573 }
 574
 575 static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg,
 576                                        struct sk_buff *resp)
 577 {
 578         struct nfc_target *target = arg;
 579         struct digital_attrib_res *attrib_res;
 580         int rc;
 581
 582         if (IS_ERR(resp)) {
 583                 rc = PTR_ERR(resp);
 584                 resp = NULL;
 585                 goto exit;
 586         }
 587
 588         if (resp->len < sizeof(*attrib_res)) {
 589                 PROTOCOL_ERR("12.6.2");
 590                 rc = -EIO;
 591                 goto exit;
 592         }
 593
 594         attrib_res = (struct digital_attrib_res *)resp->data;
 595
 596         if (attrib_res->mbli_did & 0x0f) {
 597                 PROTOCOL_ERR("12.6.2.1");
 598                 rc = -EIO;
 599                 goto exit;
 600         }
 601
 602         rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B);
 603
 604 exit:
 605         dev_kfree_skb(resp);
 606         kfree(target);
 607
 608         if (rc)
 609                 digital_poll_next_tech(ddev);
 610 }
 611
 612 static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev,
 613                                struct nfc_target *target,
 614                                struct digital_sensb_res *sensb_res)
 615 {
 616         struct digital_attrib_req *attrib_req;
 617         struct sk_buff *skb;
 618         int rc;
 619
 620         skb = digital_skb_alloc(ddev, sizeof(*attrib_req));
 621         if (!skb)
 622                 return -ENOMEM;
 623
 624         attrib_req = skb_put(skb, sizeof(*attrib_req));
 625
 626         attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ;
 627         memcpy(attrib_req->nfcid0, sensb_res->nfcid0,
 628                sizeof(attrib_req->nfcid0));
 629         attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT |
 630                              DIGITAL_ATTRIB_P1_TR1_DEFAULT;
 631         attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 |
 632                              DIGITAL_ATTRIB_P2_POLL_LISTEN_1 |
 633                              DIGITAL_ATTRIB_P2_MAX_FRAME_256;
 634         attrib_req->param3 = sensb_res->proto_info[1] & 0x07;
 635         attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0);
 636
 637         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res,
 638                                  target);
 639         if (rc)
 640                 kfree_skb(skb);
 641
 642         return rc;
 643 }
 644
 645 static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg,
 646                                       struct sk_buff *resp)
 647 {
 648         struct nfc_target *target = NULL;
 649         struct digital_sensb_res *sensb_res;
 650         u8 fsci;
 651         int rc;
 652
 653         if (IS_ERR(resp)) {
 654                 rc = PTR_ERR(resp);
 655                 resp = NULL;
 656                 goto exit;
 657         }
 658
 659         if (resp->len != sizeof(*sensb_res)) {
 660                 PROTOCOL_ERR("5.6.2.1");
 661                 rc = -EIO;
 662                 goto exit;
 663         }
 664
 665         sensb_res = (struct digital_sensb_res *)resp->data;
 666
 667         if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) {
 668                 PROTOCOL_ERR("5.6.2");
 669                 rc = -EIO;
 670                 goto exit;
 671         }
 672
 673         if (!(sensb_res->proto_info[1] & BIT(0))) {
 674                 PROTOCOL_ERR("5.6.2.12");
 675                 rc = -EIO;
 676                 goto exit;
 677         }
 678
 679         if (sensb_res->proto_info[1] & BIT(3)) {
 680                 PROTOCOL_ERR("5.6.2.16");
 681                 rc = -EIO;
 682                 goto exit;
 683         }
 684
 685         fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]);
 686         if (fsci >= 8)
 687                 ddev->target_fsc = DIGITAL_ATS_MAX_FSC;
 688         else
 689                 ddev->target_fsc = digital_ats_fsc[fsci];
 690
 691         target = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
 692         if (!target) {
 693                 rc = -ENOMEM;
 694                 goto exit;
 695         }
 696
 697         rc = digital_in_send_attrib_req(ddev, target, sensb_res);
 698
 699 exit:
 700         dev_kfree_skb(resp);
 701
 702         if (rc) {
 703                 kfree(target);
 704                 digital_poll_next_tech(ddev);
 705         }
 706 }
 707
 708 int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech)
 709 {
 710         struct digital_sensb_req *sensb_req;
 711         struct sk_buff *skb;
 712         int rc;
 713
 714         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
 715                                      NFC_DIGITAL_RF_TECH_106B);
 716         if (rc)
 717                 return rc;
 718
 719         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 720                                      NFC_DIGITAL_FRAMING_NFCB);
 721         if (rc)
 722                 return rc;
 723
 724         skb = digital_skb_alloc(ddev, sizeof(*sensb_req));
 725         if (!skb)
 726                 return -ENOMEM;
 727
 728         sensb_req = skb_put(skb, sizeof(*sensb_req));
 729
 730         sensb_req->cmd = DIGITAL_CMD_SENSB_REQ;
 731         sensb_req->afi = 0x00; /* All families and sub-families */
 732         sensb_req->param = DIGITAL_SENSB_N(0);
 733
 734         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res,
 735                                  NULL);
 736         if (rc)
 737                 kfree_skb(skb);
 738
 739         return rc;
 740 }
 741
 742 static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
 743                                    struct sk_buff *resp)
 744 {
 745         int rc;
 746         u8 proto;
 747         struct nfc_target target;
 748         struct digital_sensf_res *sensf_res;
 749
 750         if (IS_ERR(resp)) {
 751                 rc = PTR_ERR(resp);
 752                 resp = NULL;
 753                 goto exit;
 754         }
 755
 756         if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) {
 757                 rc = -EIO;
 758                 goto exit;
 759         }
 760
 761         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) {
 762                 rc = digital_skb_check_crc_f(resp);
 763                 if (rc) {
 764                         PROTOCOL_ERR("6.4.1.8");
 765                         goto exit;
 766                 }
 767         }
 768
 769         skb_pull(resp, 1);
 770
 771         memset(&target, 0, sizeof(struct nfc_target));
 772
 773         sensf_res = (struct digital_sensf_res *)resp->data;
 774
 775         memcpy(target.sensf_res, sensf_res, resp->len);
 776         target.sensf_res_len = resp->len;
 777
 778         memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
 779         target.nfcid2_len = NFC_NFCID2_MAXSIZE;
 780
 781         if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
 782             target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
 783                 proto = NFC_PROTO_NFC_DEP;
 784         else
 785                 proto = NFC_PROTO_FELICA;
 786
 787         rc = digital_target_found(ddev, &target, proto);
 788
 789 exit:
 790         dev_kfree_skb(resp);
 791
 792         if (rc)
 793                 digital_poll_next_tech(ddev);
 794 }
 795
 796 int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech)
 797 {
 798         struct digital_sensf_req *sensf_req;
 799         struct sk_buff *skb;
 800         int rc;
 801         u8 size;
 802
 803         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
 804         if (rc)
 805                 return rc;
 806
 807         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 808                                      NFC_DIGITAL_FRAMING_NFCF);
 809         if (rc)
 810                 return rc;
 811
 812         size = sizeof(struct digital_sensf_req);
 813
 814         skb = digital_skb_alloc(ddev, size);
 815         if (!skb)
 816                 return -ENOMEM;
 817
 818         skb_put(skb, size);
 819
 820         sensf_req = (struct digital_sensf_req *)skb->data;
 821         sensf_req->cmd = DIGITAL_CMD_SENSF_REQ;
 822         sensf_req->sc1 = 0xFF;
 823         sensf_req->sc2 = 0xFF;
 824         sensf_req->rc = 0;
 825         sensf_req->tsn = 0;
 826
 827         *(u8 *)skb_push(skb, 1) = size + 1;
 828
 829         if (!DIGITAL_DRV_CAPS_IN_CRC(ddev))
 830                 digital_skb_add_crc_f(skb);
 831
 832         rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res,
 833                                  NULL);
 834         if (rc)
 835                 kfree_skb(skb);
 836
 837         return rc;
 838 }
 839
 840 static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev,
 841                 void *arg, struct sk_buff *resp)
 842 {
 843         struct digital_iso15693_inv_res *res;
 844         struct nfc_target *target = NULL;
 845         int rc;
 846
 847         if (IS_ERR(resp)) {
 848                 rc = PTR_ERR(resp);
 849                 resp = NULL;
 850                 goto out_free_skb;
 851         }
 852
 853         if (resp->len != sizeof(*res)) {
 854                 rc = -EIO;
 855                 goto out_free_skb;
 856         }
 857
 858         res = (struct digital_iso15693_inv_res *)resp->data;
 859
 860         if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) {
 861                 PROTOCOL_ERR("ISO15693 - 10.3.1");
 862                 rc = -EINVAL;
 863                 goto out_free_skb;
 864         }
 865
 866         target = kzalloc(sizeof(*target), GFP_KERNEL);
 867         if (!target) {
 868                 rc = -ENOMEM;
 869                 goto out_free_skb;
 870         }
 871
 872         target->is_iso15693 = 1;
 873         target->iso15693_dsfid = res->dsfid;
 874         memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid));
 875
 876         rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693);
 877
 878         kfree(target);
 879
 880 out_free_skb:
 881         dev_kfree_skb(resp);
 882
 883         if (rc)
 884                 digital_poll_next_tech(ddev);
 885 }
 886
 887 int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech)
 888 {
 889         struct digital_iso15693_inv_req *req;
 890         struct sk_buff *skb;
 891         int rc;
 892
 893         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
 894                                      NFC_DIGITAL_RF_TECH_ISO15693);
 895         if (rc)
 896                 return rc;
 897
 898         rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 899                                      NFC_DIGITAL_FRAMING_ISO15693_INVENTORY);
 900         if (rc)
 901                 return rc;
 902
 903         skb = digital_skb_alloc(ddev, sizeof(*req));
 904         if (!skb)
 905                 return -ENOMEM;
 906
 907         skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */
 908         req = (struct digital_iso15693_inv_req *)skb->data;
 909
 910         /* Single sub-carrier, high data rate, no AFI, single slot
 911          * Inventory command
 912          */
 913         req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE |
 914                      DIGITAL_ISO15693_REQ_FLAG_INVENTORY |
 915                      DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS;
 916         req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ;
 917         req->mask_len = 0;
 918
 919         rc = digital_in_send_cmd(ddev, skb, 30,
 920                                  digital_in_recv_iso15693_inv_res, NULL);
 921         if (rc)
 922                 kfree_skb(skb);
 923
 924         return rc;
 925 }
 926
 927 static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev)
 928 {
 929         struct sk_buff *skb;
 930         int rc;
 931
 932         skb = digital_skb_alloc(ddev, 1);
 933         if (!skb)
 934                 return -ENOMEM;
 935
 936         skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP);
 937
 938         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
 939                 digital_skb_add_crc_a(skb);
 940
 941         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
 942                                      NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE);
 943         if (rc) {
 944                 kfree_skb(skb);
 945                 return rc;
 946         }
 947
 948         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req,
 949                                  NULL);
 950         if (rc)
 951                 kfree_skb(skb);
 952
 953         return rc;
 954 }
 955
 956 static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg,
 957                                     struct sk_buff *resp)
 958 {
 959         int rc;
 960
 961         if (IS_ERR(resp)) {
 962                 rc = PTR_ERR(resp);
 963                 resp = NULL;
 964                 goto exit;
 965         }
 966
 967         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
 968                 rc = digital_skb_check_crc_a(resp);
 969                 if (rc) {
 970                         PROTOCOL_ERR("4.4.1.3");
 971                         goto exit;
 972                 }
 973         }
 974
 975         /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */
 976
 977         rc = digital_tg_send_sel_res(ddev);
 978
 979 exit:
 980         if (rc)
 981                 digital_poll_next_tech(ddev);
 982
 983         dev_kfree_skb(resp);
 984 }
 985
 986 static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev)
 987 {
 988         struct sk_buff *skb;
 989         struct digital_sdd_res *sdd_res;
 990         int rc, i;
 991
 992         skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res));
 993         if (!skb)
 994                 return -ENOMEM;
 995
 996         skb_put(skb, sizeof(struct digital_sdd_res));
 997         sdd_res = (struct digital_sdd_res *)skb->data;
 998
 999         sdd_res->nfcid1[0] = 0x08;
1000         get_random_bytes(sdd_res->nfcid1 + 1, 3);
1001
1002         sdd_res->bcc = 0;
1003         for (i = 0; i < 4; i++)
1004                 sdd_res->bcc ^= sdd_res->nfcid1[i];
1005
1006         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1007                                 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A);
1008         if (rc) {
1009                 kfree_skb(skb);
1010                 return rc;
1011         }
1012
1013         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req,
1014                                  NULL);
1015         if (rc)
1016                 kfree_skb(skb);
1017
1018         return rc;
1019 }
1020
1021 static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg,
1022                                     struct sk_buff *resp)
1023 {
1024         u8 *sdd_req;
1025         int rc;
1026
1027         if (IS_ERR(resp)) {
1028                 rc = PTR_ERR(resp);
1029                 resp = NULL;
1030                 goto exit;
1031         }
1032
1033         sdd_req = resp->data;
1034
1035         if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 ||
1036             sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) {
1037                 rc = -EINVAL;
1038                 goto exit;
1039         }
1040
1041         rc = digital_tg_send_sdd_res(ddev);
1042
1043 exit:
1044         if (rc)
1045                 digital_poll_next_tech(ddev);
1046
1047         dev_kfree_skb(resp);
1048 }
1049
1050 static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev)
1051 {
1052         struct sk_buff *skb;
1053         u8 *sens_res;
1054         int rc;
1055
1056         skb = digital_skb_alloc(ddev, 2);
1057         if (!skb)
1058                 return -ENOMEM;
1059
1060         sens_res = skb_put(skb, 2);
1061
1062         sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF;
1063         sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF;
1064
1065         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1066                                      NFC_DIGITAL_FRAMING_NFCA_STANDARD);
1067         if (rc) {
1068                 kfree_skb(skb);
1069                 return rc;
1070         }
1071
1072         rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req,
1073                                  NULL);
1074         if (rc)
1075                 kfree_skb(skb);
1076
1077         return rc;
1078 }
1079
1080 void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg,
1081                               struct sk_buff *resp)
1082 {
1083         u8 sens_req;
1084         int rc;
1085
1086         if (IS_ERR(resp)) {
1087                 rc = PTR_ERR(resp);
1088                 resp = NULL;
1089                 goto exit;
1090         }
1091
1092         sens_req = resp->data[0];
1093
1094         if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ &&
1095             sens_req != DIGITAL_CMD_ALL_REQ)) {
1096                 rc = -EINVAL;
1097                 goto exit;
1098         }
1099
1100         rc = digital_tg_send_sens_res(ddev);
1101
1102 exit:
1103         if (rc)
1104                 digital_poll_next_tech(ddev);
1105
1106         dev_kfree_skb(resp);
1107 }
1108
1109 static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev,
1110                 void *arg, struct sk_buff *resp)
1111 {
1112         if (!IS_ERR(resp) && (resp->len >= 2) &&
1113                         (resp->data[1] == DIGITAL_CMD_SENSF_REQ))
1114                 digital_tg_recv_sensf_req(ddev, arg, resp);
1115         else
1116                 digital_tg_recv_atr_req(ddev, arg, resp);
1117
1118         return;
1119 }
1120
1121 static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev,
1122                               struct digital_sensf_req *sensf_req)
1123 {
1124         struct sk_buff *skb;
1125         u8 size;
1126         int rc;
1127         struct digital_sensf_res *sensf_res;
1128
1129         size = sizeof(struct digital_sensf_res);
1130
1131         if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE)
1132                 size -= sizeof(sensf_res->rd);
1133
1134         skb = digital_skb_alloc(ddev, size);
1135         if (!skb)
1136                 return -ENOMEM;
1137
1138         skb_put(skb, size);
1139
1140         sensf_res = (struct digital_sensf_res *)skb->data;
1141
1142         memset(sensf_res, 0, size);
1143
1144         sensf_res->cmd = DIGITAL_CMD_SENSF_RES;
1145         sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1;
1146         sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2;
1147         get_random_bytes(&sensf_res->nfcid2[2], 6);
1148
1149         switch (sensf_req->rc) {
1150         case DIGITAL_SENSF_REQ_RC_SC:
1151                 sensf_res->rd[0] = sensf_req->sc1;
1152                 sensf_res->rd[1] = sensf_req->sc2;
1153                 break;
1154         case DIGITAL_SENSF_REQ_RC_AP:
1155                 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1;
1156                 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2;
1157                 break;
1158         }
1159
1160         *(u8 *)skb_push(skb, sizeof(u8)) = size + 1;
1161
1162         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev))
1163                 digital_skb_add_crc_f(skb);
1164
1165         rc = digital_tg_send_cmd(ddev, skb, 300,
1166                                  digital_tg_recv_atr_or_sensf_req, NULL);
1167         if (rc)
1168                 kfree_skb(skb);
1169
1170         return rc;
1171 }
1172
1173 void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg,
1174                                struct sk_buff *resp)
1175 {
1176         struct digital_sensf_req *sensf_req;
1177         int rc;
1178
1179         if (IS_ERR(resp)) {
1180                 rc = PTR_ERR(resp);
1181                 resp = NULL;
1182                 goto exit;
1183         }
1184
1185         if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) {
1186                 rc = digital_skb_check_crc_f(resp);
1187                 if (rc) {
1188                         PROTOCOL_ERR("6.4.1.8");
1189                         goto exit;
1190                 }
1191         }
1192
1193         if (resp->len != sizeof(struct digital_sensf_req) + 1) {
1194                 rc = -EINVAL;
1195                 goto exit;
1196         }
1197
1198         skb_pull(resp, 1);
1199         sensf_req = (struct digital_sensf_req *)resp->data;
1200
1201         if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) {
1202                 rc = -EINVAL;
1203                 goto exit;
1204         }
1205
1206         rc = digital_tg_send_sensf_res(ddev, sensf_req);
1207
1208 exit:
1209         if (rc)
1210                 digital_poll_next_tech(ddev);
1211
1212         dev_kfree_skb(resp);
1213 }
1214
1215 static int digital_tg_config_nfca(struct nfc_digital_dev *ddev)
1216 {
1217         int rc;
1218
1219         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
1220                                      NFC_DIGITAL_RF_TECH_106A);
1221         if (rc)
1222                 return rc;
1223
1224         return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1225                                        NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
1226 }
1227
1228 int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech)
1229 {
1230         int rc;
1231
1232         rc = digital_tg_config_nfca(ddev);
1233         if (rc)
1234                 return rc;
1235
1236         return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL);
1237 }
1238
1239 static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1240 {
1241         int rc;
1242
1243         rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech);
1244         if (rc)
1245                 return rc;
1246
1247         return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
1248                                        NFC_DIGITAL_FRAMING_NFCF_NFC_DEP);
1249 }
1250
1251 int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech)
1252 {
1253         int rc;
1254
1255         rc = digital_tg_config_nfcf(ddev, rf_tech);
1256         if (rc)
1257                 return rc;
1258
1259         return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL);
1260 }
1261
1262 void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg,
1263                             struct sk_buff *resp)
1264 {
1265         u8 rf_tech;
1266         int rc;
1267
1268         if (IS_ERR(resp)) {
1269                 resp = NULL;
1270                 goto exit_free_skb;
1271         }
1272
1273         rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech);
1274         if (rc)
1275                 goto exit_free_skb;
1276
1277         switch (rf_tech) {
1278         case NFC_DIGITAL_RF_TECH_106A:
1279                 rc = digital_tg_config_nfca(ddev);
1280                 if (rc)
1281                         goto exit_free_skb;
1282                 digital_tg_recv_sens_req(ddev, arg, resp);
1283                 break;
1284         case NFC_DIGITAL_RF_TECH_212F:
1285         case NFC_DIGITAL_RF_TECH_424F:
1286                 rc = digital_tg_config_nfcf(ddev, rf_tech);
1287                 if (rc)
1288                         goto exit_free_skb;
1289                 digital_tg_recv_sensf_req(ddev, arg, resp);
1290                 break;
1291         default:
1292                 goto exit_free_skb;
1293         }
1294
1295         return;
1296
1297 exit_free_skb:
1298         digital_poll_next_tech(ddev);
1299         dev_kfree_skb(resp);
1300 }