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