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