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 if (target->nfcid1_len + size > NFC_NFCID1_MAXSIZE) { 428 PROTOCOL_ERR("4.7.2.1"); 429 rc = -EPROTO; 430 goto exit; 431 } 432 433 memcpy(target->nfcid1 + target->nfcid1_len, sdd_res->nfcid1 + offset, 434 size); 435 target->nfcid1_len += size; 436 437 rc = digital_in_send_sel_req(ddev, target, sdd_res); 438 439 exit: 440 dev_kfree_skb(resp); 441 442 if (rc) { 443 kfree(target); 444 digital_poll_next_tech(ddev); 445 } 446 } 447 448 static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev, 449 struct nfc_target *target) 450 { 451 int rc; 452 struct sk_buff *skb; 453 u8 sel_cmd; 454 455 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 456 NFC_DIGITAL_FRAMING_NFCA_STANDARD); 457 if (rc) 458 return rc; 459 460 skb = digital_skb_alloc(ddev, 2); 461 if (!skb) 462 return -ENOMEM; 463 464 if (target->nfcid1_len == 0) 465 sel_cmd = DIGITAL_CMD_SEL_REQ_CL1; 466 else if (target->nfcid1_len == 3) 467 sel_cmd = DIGITAL_CMD_SEL_REQ_CL2; 468 else 469 sel_cmd = DIGITAL_CMD_SEL_REQ_CL3; 470 471 skb_put_u8(skb, sel_cmd); 472 skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR); 473 474 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res, 475 target); 476 if (rc) 477 kfree_skb(skb); 478 479 return rc; 480 } 481 482 static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg, 483 struct sk_buff *resp) 484 { 485 struct nfc_target *target = NULL; 486 int rc; 487 488 if (IS_ERR(resp)) { 489 rc = PTR_ERR(resp); 490 resp = NULL; 491 goto exit; 492 } 493 494 if (resp->len < sizeof(u16)) { 495 rc = -EIO; 496 goto exit; 497 } 498 499 target = kzalloc_obj(struct nfc_target); 500 if (!target) { 501 rc = -ENOMEM; 502 goto exit; 503 } 504 505 target->sens_res = __le16_to_cpu(*(__le16 *)resp->data); 506 507 if (!DIGITAL_SENS_RES_IS_VALID(target->sens_res)) { 508 PROTOCOL_ERR("4.6.3.3"); 509 rc = -EINVAL; 510 goto exit; 511 } 512 513 if (DIGITAL_SENS_RES_IS_T1T(target->sens_res)) 514 rc = digital_target_found(ddev, target, NFC_PROTO_JEWEL); 515 else 516 rc = digital_in_send_sdd_req(ddev, target); 517 518 exit: 519 dev_kfree_skb(resp); 520 521 if (rc) { 522 kfree(target); 523 digital_poll_next_tech(ddev); 524 } 525 } 526 527 int digital_in_send_sens_req(struct nfc_digital_dev *ddev, u8 rf_tech) 528 { 529 struct sk_buff *skb; 530 int rc; 531 532 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 533 NFC_DIGITAL_RF_TECH_106A); 534 if (rc) 535 return rc; 536 537 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 538 NFC_DIGITAL_FRAMING_NFCA_SHORT); 539 if (rc) 540 return rc; 541 542 skb = digital_skb_alloc(ddev, 1); 543 if (!skb) 544 return -ENOMEM; 545 546 skb_put_u8(skb, DIGITAL_CMD_SENS_REQ); 547 548 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sens_res, NULL); 549 if (rc) 550 kfree_skb(skb); 551 552 return rc; 553 } 554 555 int digital_in_recv_mifare_res(struct sk_buff *resp) 556 { 557 /* Successful READ command response is 16 data bytes + 2 CRC bytes long. 558 * Since the driver can't differentiate a ACK/NACK response from a valid 559 * READ response, the CRC calculation must be handled at digital level 560 * even if the driver supports it for this technology. 561 */ 562 if (resp->len == DIGITAL_MIFARE_READ_RES_LEN + DIGITAL_CRC_LEN) { 563 if (digital_skb_check_crc_a(resp)) { 564 PROTOCOL_ERR("9.4.1.2"); 565 return -EIO; 566 } 567 568 return 0; 569 } 570 571 /* ACK response (i.e. successful WRITE). */ 572 if (resp->len == 1 && resp->data[0] == DIGITAL_MIFARE_ACK_RES) { 573 resp->data[0] = 0; 574 return 0; 575 } 576 577 /* NACK and any other responses are treated as error. */ 578 return -EIO; 579 } 580 581 static void digital_in_recv_attrib_res(struct nfc_digital_dev *ddev, void *arg, 582 struct sk_buff *resp) 583 { 584 struct nfc_target *target = arg; 585 struct digital_attrib_res *attrib_res; 586 int rc; 587 588 if (IS_ERR(resp)) { 589 rc = PTR_ERR(resp); 590 resp = NULL; 591 goto exit; 592 } 593 594 if (resp->len < sizeof(*attrib_res)) { 595 PROTOCOL_ERR("12.6.2"); 596 rc = -EIO; 597 goto exit; 598 } 599 600 attrib_res = (struct digital_attrib_res *)resp->data; 601 602 if (attrib_res->mbli_did & 0x0f) { 603 PROTOCOL_ERR("12.6.2.1"); 604 rc = -EIO; 605 goto exit; 606 } 607 608 rc = digital_target_found(ddev, target, NFC_PROTO_ISO14443_B); 609 610 exit: 611 dev_kfree_skb(resp); 612 kfree(target); 613 614 if (rc) 615 digital_poll_next_tech(ddev); 616 } 617 618 static int digital_in_send_attrib_req(struct nfc_digital_dev *ddev, 619 struct nfc_target *target, 620 struct digital_sensb_res *sensb_res) 621 { 622 struct digital_attrib_req *attrib_req; 623 struct sk_buff *skb; 624 int rc; 625 626 skb = digital_skb_alloc(ddev, sizeof(*attrib_req)); 627 if (!skb) 628 return -ENOMEM; 629 630 attrib_req = skb_put(skb, sizeof(*attrib_req)); 631 632 attrib_req->cmd = DIGITAL_CMD_ATTRIB_REQ; 633 memcpy(attrib_req->nfcid0, sensb_res->nfcid0, 634 sizeof(attrib_req->nfcid0)); 635 attrib_req->param1 = DIGITAL_ATTRIB_P1_TR0_DEFAULT | 636 DIGITAL_ATTRIB_P1_TR1_DEFAULT; 637 attrib_req->param2 = DIGITAL_ATTRIB_P2_LISTEN_POLL_1 | 638 DIGITAL_ATTRIB_P2_POLL_LISTEN_1 | 639 DIGITAL_ATTRIB_P2_MAX_FRAME_256; 640 attrib_req->param3 = sensb_res->proto_info[1] & 0x07; 641 attrib_req->param4 = DIGITAL_ATTRIB_P4_DID(0); 642 643 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_attrib_res, 644 target); 645 if (rc) 646 kfree_skb(skb); 647 648 return rc; 649 } 650 651 static void digital_in_recv_sensb_res(struct nfc_digital_dev *ddev, void *arg, 652 struct sk_buff *resp) 653 { 654 struct nfc_target *target = NULL; 655 struct digital_sensb_res *sensb_res; 656 u8 fsci; 657 int rc; 658 659 if (IS_ERR(resp)) { 660 rc = PTR_ERR(resp); 661 resp = NULL; 662 goto exit; 663 } 664 665 if (resp->len != sizeof(*sensb_res)) { 666 PROTOCOL_ERR("5.6.2.1"); 667 rc = -EIO; 668 goto exit; 669 } 670 671 sensb_res = (struct digital_sensb_res *)resp->data; 672 673 if (sensb_res->cmd != DIGITAL_CMD_SENSB_RES) { 674 PROTOCOL_ERR("5.6.2"); 675 rc = -EIO; 676 goto exit; 677 } 678 679 if (!(sensb_res->proto_info[1] & BIT(0))) { 680 PROTOCOL_ERR("5.6.2.12"); 681 rc = -EIO; 682 goto exit; 683 } 684 685 if (sensb_res->proto_info[1] & BIT(3)) { 686 PROTOCOL_ERR("5.6.2.16"); 687 rc = -EIO; 688 goto exit; 689 } 690 691 fsci = DIGITAL_SENSB_FSCI(sensb_res->proto_info[1]); 692 if (fsci >= 8) 693 ddev->target_fsc = DIGITAL_ATS_MAX_FSC; 694 else 695 ddev->target_fsc = digital_ats_fsc[fsci]; 696 697 target = kzalloc_obj(struct nfc_target); 698 if (!target) { 699 rc = -ENOMEM; 700 goto exit; 701 } 702 703 rc = digital_in_send_attrib_req(ddev, target, sensb_res); 704 705 exit: 706 dev_kfree_skb(resp); 707 708 if (rc) { 709 kfree(target); 710 digital_poll_next_tech(ddev); 711 } 712 } 713 714 int digital_in_send_sensb_req(struct nfc_digital_dev *ddev, u8 rf_tech) 715 { 716 struct digital_sensb_req *sensb_req; 717 struct sk_buff *skb; 718 int rc; 719 720 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 721 NFC_DIGITAL_RF_TECH_106B); 722 if (rc) 723 return rc; 724 725 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 726 NFC_DIGITAL_FRAMING_NFCB); 727 if (rc) 728 return rc; 729 730 skb = digital_skb_alloc(ddev, sizeof(*sensb_req)); 731 if (!skb) 732 return -ENOMEM; 733 734 sensb_req = skb_put(skb, sizeof(*sensb_req)); 735 736 sensb_req->cmd = DIGITAL_CMD_SENSB_REQ; 737 sensb_req->afi = 0x00; /* All families and sub-families */ 738 sensb_req->param = DIGITAL_SENSB_N(0); 739 740 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensb_res, 741 NULL); 742 if (rc) 743 kfree_skb(skb); 744 745 return rc; 746 } 747 748 static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg, 749 struct sk_buff *resp) 750 { 751 int rc; 752 u8 proto; 753 struct nfc_target target; 754 struct digital_sensf_res *sensf_res; 755 756 if (IS_ERR(resp)) { 757 rc = PTR_ERR(resp); 758 resp = NULL; 759 goto exit; 760 } 761 762 if (resp->len < DIGITAL_SENSF_RES_MIN_LENGTH) { 763 rc = -EIO; 764 goto exit; 765 } 766 767 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) { 768 rc = digital_skb_check_crc_f(resp); 769 if (rc) { 770 PROTOCOL_ERR("6.4.1.8"); 771 goto exit; 772 } 773 } 774 775 skb_pull(resp, 1); 776 777 memset(&target, 0, sizeof(struct nfc_target)); 778 779 sensf_res = (struct digital_sensf_res *)resp->data; 780 781 resp->len = min_t(unsigned int, resp->len, NFC_SENSF_RES_MAXSIZE); 782 783 memcpy(target.sensf_res, sensf_res, resp->len); 784 target.sensf_res_len = resp->len; 785 786 memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE); 787 target.nfcid2_len = NFC_NFCID2_MAXSIZE; 788 789 if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 && 790 target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2) 791 proto = NFC_PROTO_NFC_DEP; 792 else 793 proto = NFC_PROTO_FELICA; 794 795 rc = digital_target_found(ddev, &target, proto); 796 797 exit: 798 dev_kfree_skb(resp); 799 800 if (rc) 801 digital_poll_next_tech(ddev); 802 } 803 804 int digital_in_send_sensf_req(struct nfc_digital_dev *ddev, u8 rf_tech) 805 { 806 struct digital_sensf_req *sensf_req; 807 struct sk_buff *skb; 808 int rc; 809 u8 size; 810 811 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech); 812 if (rc) 813 return rc; 814 815 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 816 NFC_DIGITAL_FRAMING_NFCF); 817 if (rc) 818 return rc; 819 820 size = sizeof(struct digital_sensf_req); 821 822 skb = digital_skb_alloc(ddev, size); 823 if (!skb) 824 return -ENOMEM; 825 826 skb_put(skb, size); 827 828 sensf_req = (struct digital_sensf_req *)skb->data; 829 sensf_req->cmd = DIGITAL_CMD_SENSF_REQ; 830 sensf_req->sc1 = 0xFF; 831 sensf_req->sc2 = 0xFF; 832 sensf_req->rc = 0; 833 sensf_req->tsn = 0; 834 835 *(u8 *)skb_push(skb, 1) = size + 1; 836 837 if (!DIGITAL_DRV_CAPS_IN_CRC(ddev)) 838 digital_skb_add_crc_f(skb); 839 840 rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sensf_res, 841 NULL); 842 if (rc) 843 kfree_skb(skb); 844 845 return rc; 846 } 847 848 static void digital_in_recv_iso15693_inv_res(struct nfc_digital_dev *ddev, 849 void *arg, struct sk_buff *resp) 850 { 851 struct digital_iso15693_inv_res *res; 852 struct nfc_target *target = NULL; 853 int rc; 854 855 if (IS_ERR(resp)) { 856 rc = PTR_ERR(resp); 857 resp = NULL; 858 goto out_free_skb; 859 } 860 861 if (resp->len != sizeof(*res)) { 862 rc = -EIO; 863 goto out_free_skb; 864 } 865 866 res = (struct digital_iso15693_inv_res *)resp->data; 867 868 if (!DIGITAL_ISO15693_RES_IS_VALID(res->flags)) { 869 PROTOCOL_ERR("ISO15693 - 10.3.1"); 870 rc = -EINVAL; 871 goto out_free_skb; 872 } 873 874 target = kzalloc_obj(*target); 875 if (!target) { 876 rc = -ENOMEM; 877 goto out_free_skb; 878 } 879 880 target->is_iso15693 = 1; 881 target->iso15693_dsfid = res->dsfid; 882 memcpy(target->iso15693_uid, &res->uid, sizeof(target->iso15693_uid)); 883 884 rc = digital_target_found(ddev, target, NFC_PROTO_ISO15693); 885 886 kfree(target); 887 888 out_free_skb: 889 dev_kfree_skb(resp); 890 891 if (rc) 892 digital_poll_next_tech(ddev); 893 } 894 895 int digital_in_send_iso15693_inv_req(struct nfc_digital_dev *ddev, u8 rf_tech) 896 { 897 struct digital_iso15693_inv_req *req; 898 struct sk_buff *skb; 899 int rc; 900 901 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 902 NFC_DIGITAL_RF_TECH_ISO15693); 903 if (rc) 904 return rc; 905 906 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 907 NFC_DIGITAL_FRAMING_ISO15693_INVENTORY); 908 if (rc) 909 return rc; 910 911 skb = digital_skb_alloc(ddev, sizeof(*req)); 912 if (!skb) 913 return -ENOMEM; 914 915 skb_put(skb, sizeof(*req) - sizeof(req->mask)); /* No mask */ 916 req = (struct digital_iso15693_inv_req *)skb->data; 917 918 /* Single sub-carrier, high data rate, no AFI, single slot 919 * Inventory command 920 */ 921 req->flags = DIGITAL_ISO15693_REQ_FLAG_DATA_RATE | 922 DIGITAL_ISO15693_REQ_FLAG_INVENTORY | 923 DIGITAL_ISO15693_REQ_FLAG_NB_SLOTS; 924 req->cmd = DIGITAL_CMD_ISO15693_INVENTORY_REQ; 925 req->mask_len = 0; 926 927 rc = digital_in_send_cmd(ddev, skb, 30, 928 digital_in_recv_iso15693_inv_res, NULL); 929 if (rc) 930 kfree_skb(skb); 931 932 return rc; 933 } 934 935 static int digital_tg_send_sel_res(struct nfc_digital_dev *ddev) 936 { 937 struct sk_buff *skb; 938 int rc; 939 940 skb = digital_skb_alloc(ddev, 1); 941 if (!skb) 942 return -ENOMEM; 943 944 skb_put_u8(skb, DIGITAL_SEL_RES_NFC_DEP); 945 946 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) 947 digital_skb_add_crc_a(skb); 948 949 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 950 NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE); 951 if (rc) { 952 kfree_skb(skb); 953 return rc; 954 } 955 956 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_atr_req, 957 NULL); 958 if (rc) 959 kfree_skb(skb); 960 961 return rc; 962 } 963 964 static void digital_tg_recv_sel_req(struct nfc_digital_dev *ddev, void *arg, 965 struct sk_buff *resp) 966 { 967 int rc; 968 969 if (IS_ERR(resp)) { 970 rc = PTR_ERR(resp); 971 resp = NULL; 972 goto exit; 973 } 974 975 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) { 976 rc = digital_skb_check_crc_a(resp); 977 if (rc) { 978 PROTOCOL_ERR("4.4.1.3"); 979 goto exit; 980 } 981 } 982 983 /* Silently ignore SEL_REQ content and send a SEL_RES for NFC-DEP */ 984 985 rc = digital_tg_send_sel_res(ddev); 986 987 exit: 988 if (rc) 989 digital_poll_next_tech(ddev); 990 991 dev_kfree_skb(resp); 992 } 993 994 static int digital_tg_send_sdd_res(struct nfc_digital_dev *ddev) 995 { 996 struct sk_buff *skb; 997 struct digital_sdd_res *sdd_res; 998 int rc, i; 999 1000 skb = digital_skb_alloc(ddev, sizeof(struct digital_sdd_res)); 1001 if (!skb) 1002 return -ENOMEM; 1003 1004 skb_put(skb, sizeof(struct digital_sdd_res)); 1005 sdd_res = (struct digital_sdd_res *)skb->data; 1006 1007 sdd_res->nfcid1[0] = 0x08; 1008 get_random_bytes(sdd_res->nfcid1 + 1, 3); 1009 1010 sdd_res->bcc = 0; 1011 for (i = 0; i < 4; i++) 1012 sdd_res->bcc ^= sdd_res->nfcid1[i]; 1013 1014 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1015 NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A); 1016 if (rc) { 1017 kfree_skb(skb); 1018 return rc; 1019 } 1020 1021 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sel_req, 1022 NULL); 1023 if (rc) 1024 kfree_skb(skb); 1025 1026 return rc; 1027 } 1028 1029 static void digital_tg_recv_sdd_req(struct nfc_digital_dev *ddev, void *arg, 1030 struct sk_buff *resp) 1031 { 1032 u8 *sdd_req; 1033 int rc; 1034 1035 if (IS_ERR(resp)) { 1036 rc = PTR_ERR(resp); 1037 resp = NULL; 1038 goto exit; 1039 } 1040 1041 sdd_req = resp->data; 1042 1043 if (resp->len < 2 || sdd_req[0] != DIGITAL_CMD_SEL_REQ_CL1 || 1044 sdd_req[1] != DIGITAL_SDD_REQ_SEL_PAR) { 1045 rc = -EINVAL; 1046 goto exit; 1047 } 1048 1049 rc = digital_tg_send_sdd_res(ddev); 1050 1051 exit: 1052 if (rc) 1053 digital_poll_next_tech(ddev); 1054 1055 dev_kfree_skb(resp); 1056 } 1057 1058 static int digital_tg_send_sens_res(struct nfc_digital_dev *ddev) 1059 { 1060 struct sk_buff *skb; 1061 u8 *sens_res; 1062 int rc; 1063 1064 skb = digital_skb_alloc(ddev, 2); 1065 if (!skb) 1066 return -ENOMEM; 1067 1068 sens_res = skb_put(skb, 2); 1069 1070 sens_res[0] = (DIGITAL_SENS_RES_NFC_DEP >> 8) & 0xFF; 1071 sens_res[1] = DIGITAL_SENS_RES_NFC_DEP & 0xFF; 1072 1073 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1074 NFC_DIGITAL_FRAMING_NFCA_STANDARD); 1075 if (rc) { 1076 kfree_skb(skb); 1077 return rc; 1078 } 1079 1080 rc = digital_tg_send_cmd(ddev, skb, 300, digital_tg_recv_sdd_req, 1081 NULL); 1082 if (rc) 1083 kfree_skb(skb); 1084 1085 return rc; 1086 } 1087 1088 void digital_tg_recv_sens_req(struct nfc_digital_dev *ddev, void *arg, 1089 struct sk_buff *resp) 1090 { 1091 u8 sens_req; 1092 int rc; 1093 1094 if (IS_ERR(resp)) { 1095 rc = PTR_ERR(resp); 1096 resp = NULL; 1097 goto exit; 1098 } 1099 1100 sens_req = resp->data[0]; 1101 1102 if (!resp->len || (sens_req != DIGITAL_CMD_SENS_REQ && 1103 sens_req != DIGITAL_CMD_ALL_REQ)) { 1104 rc = -EINVAL; 1105 goto exit; 1106 } 1107 1108 rc = digital_tg_send_sens_res(ddev); 1109 1110 exit: 1111 if (rc) 1112 digital_poll_next_tech(ddev); 1113 1114 dev_kfree_skb(resp); 1115 } 1116 1117 static void digital_tg_recv_atr_or_sensf_req(struct nfc_digital_dev *ddev, 1118 void *arg, struct sk_buff *resp) 1119 { 1120 if (!IS_ERR(resp) && (resp->len >= 2) && 1121 (resp->data[1] == DIGITAL_CMD_SENSF_REQ)) 1122 digital_tg_recv_sensf_req(ddev, arg, resp); 1123 else 1124 digital_tg_recv_atr_req(ddev, arg, resp); 1125 1126 return; 1127 } 1128 1129 static int digital_tg_send_sensf_res(struct nfc_digital_dev *ddev, 1130 struct digital_sensf_req *sensf_req) 1131 { 1132 struct sk_buff *skb; 1133 u8 size; 1134 int rc; 1135 struct digital_sensf_res *sensf_res; 1136 1137 size = sizeof(struct digital_sensf_res); 1138 1139 if (sensf_req->rc == DIGITAL_SENSF_REQ_RC_NONE) 1140 size -= sizeof(sensf_res->rd); 1141 1142 skb = digital_skb_alloc(ddev, size); 1143 if (!skb) 1144 return -ENOMEM; 1145 1146 skb_put(skb, size); 1147 1148 sensf_res = (struct digital_sensf_res *)skb->data; 1149 1150 memset(sensf_res, 0, size); 1151 1152 sensf_res->cmd = DIGITAL_CMD_SENSF_RES; 1153 sensf_res->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1; 1154 sensf_res->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2; 1155 get_random_bytes(&sensf_res->nfcid2[2], 6); 1156 1157 switch (sensf_req->rc) { 1158 case DIGITAL_SENSF_REQ_RC_SC: 1159 sensf_res->rd[0] = sensf_req->sc1; 1160 sensf_res->rd[1] = sensf_req->sc2; 1161 break; 1162 case DIGITAL_SENSF_REQ_RC_AP: 1163 sensf_res->rd[0] = DIGITAL_SENSF_RES_RD_AP_B1; 1164 sensf_res->rd[1] = DIGITAL_SENSF_RES_RD_AP_B2; 1165 break; 1166 } 1167 1168 *(u8 *)skb_push(skb, sizeof(u8)) = size + 1; 1169 1170 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) 1171 digital_skb_add_crc_f(skb); 1172 1173 rc = digital_tg_send_cmd(ddev, skb, 300, 1174 digital_tg_recv_atr_or_sensf_req, NULL); 1175 if (rc) 1176 kfree_skb(skb); 1177 1178 return rc; 1179 } 1180 1181 void digital_tg_recv_sensf_req(struct nfc_digital_dev *ddev, void *arg, 1182 struct sk_buff *resp) 1183 { 1184 struct digital_sensf_req *sensf_req; 1185 int rc; 1186 1187 if (IS_ERR(resp)) { 1188 rc = PTR_ERR(resp); 1189 resp = NULL; 1190 goto exit; 1191 } 1192 1193 if (!DIGITAL_DRV_CAPS_TG_CRC(ddev)) { 1194 rc = digital_skb_check_crc_f(resp); 1195 if (rc) { 1196 PROTOCOL_ERR("6.4.1.8"); 1197 goto exit; 1198 } 1199 } 1200 1201 if (resp->len != sizeof(struct digital_sensf_req) + 1) { 1202 rc = -EINVAL; 1203 goto exit; 1204 } 1205 1206 skb_pull(resp, 1); 1207 sensf_req = (struct digital_sensf_req *)resp->data; 1208 1209 if (sensf_req->cmd != DIGITAL_CMD_SENSF_REQ) { 1210 rc = -EINVAL; 1211 goto exit; 1212 } 1213 1214 rc = digital_tg_send_sensf_res(ddev, sensf_req); 1215 1216 exit: 1217 if (rc) 1218 digital_poll_next_tech(ddev); 1219 1220 dev_kfree_skb(resp); 1221 } 1222 1223 static int digital_tg_config_nfca(struct nfc_digital_dev *ddev) 1224 { 1225 int rc; 1226 1227 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 1228 NFC_DIGITAL_RF_TECH_106A); 1229 if (rc) 1230 return rc; 1231 1232 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1233 NFC_DIGITAL_FRAMING_NFCA_NFC_DEP); 1234 } 1235 1236 int digital_tg_listen_nfca(struct nfc_digital_dev *ddev, u8 rf_tech) 1237 { 1238 int rc; 1239 1240 rc = digital_tg_config_nfca(ddev); 1241 if (rc) 1242 return rc; 1243 1244 return digital_tg_listen(ddev, 300, digital_tg_recv_sens_req, NULL); 1245 } 1246 1247 static int digital_tg_config_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech) 1248 { 1249 int rc; 1250 1251 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech); 1252 if (rc) 1253 return rc; 1254 1255 return digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1256 NFC_DIGITAL_FRAMING_NFCF_NFC_DEP); 1257 } 1258 1259 int digital_tg_listen_nfcf(struct nfc_digital_dev *ddev, u8 rf_tech) 1260 { 1261 int rc; 1262 1263 rc = digital_tg_config_nfcf(ddev, rf_tech); 1264 if (rc) 1265 return rc; 1266 1267 return digital_tg_listen(ddev, 300, digital_tg_recv_sensf_req, NULL); 1268 } 1269 1270 void digital_tg_recv_md_req(struct nfc_digital_dev *ddev, void *arg, 1271 struct sk_buff *resp) 1272 { 1273 u8 rf_tech; 1274 int rc; 1275 1276 if (IS_ERR(resp)) { 1277 resp = NULL; 1278 goto exit_free_skb; 1279 } 1280 1281 rc = ddev->ops->tg_get_rf_tech(ddev, &rf_tech); 1282 if (rc) 1283 goto exit_free_skb; 1284 1285 switch (rf_tech) { 1286 case NFC_DIGITAL_RF_TECH_106A: 1287 rc = digital_tg_config_nfca(ddev); 1288 if (rc) 1289 goto exit_free_skb; 1290 digital_tg_recv_sens_req(ddev, arg, resp); 1291 break; 1292 case NFC_DIGITAL_RF_TECH_212F: 1293 case NFC_DIGITAL_RF_TECH_424F: 1294 rc = digital_tg_config_nfcf(ddev, rf_tech); 1295 if (rc) 1296 goto exit_free_skb; 1297 digital_tg_recv_sensf_req(ddev, arg, resp); 1298 break; 1299 default: 1300 goto exit_free_skb; 1301 } 1302 1303 return; 1304 1305 exit_free_skb: 1306 digital_poll_next_tech(ddev); 1307 dev_kfree_skb(resp); 1308 } 1309