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_FRAME_DIR_OUT 0xD4 21 #define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5 22 23 #define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0 24 25 #define DIGITAL_CMD_ATR_REQ 0x00 26 #define DIGITAL_CMD_ATR_RES 0x01 27 #define DIGITAL_CMD_PSL_REQ 0x04 28 #define DIGITAL_CMD_PSL_RES 0x05 29 #define DIGITAL_CMD_DEP_REQ 0x06 30 #define DIGITAL_CMD_DEP_RES 0x07 31 32 #define DIGITAL_ATR_REQ_MIN_SIZE 16 33 #define DIGITAL_ATR_REQ_MAX_SIZE 64 34 35 #define DIGITAL_NFCID3_LEN ((u8)8) 36 #define DIGITAL_LR_BITS_PAYLOAD_SIZE_254B 0x30 37 #define DIGITAL_GB_BIT 0x02 38 39 #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0) 40 41 #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10 42 43 #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \ 44 ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT) 45 #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & 0x10) 46 #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08) 47 #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04) 48 #define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03) 49 50 #define DIGITAL_NFC_DEP_PFB_I_PDU 0x00 51 #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40 52 #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80 53 54 struct digital_atr_req { 55 u8 dir; 56 u8 cmd; 57 u8 nfcid3[10]; 58 u8 did; 59 u8 bs; 60 u8 br; 61 u8 pp; 62 u8 gb[0]; 63 } __packed; 64 65 struct digital_atr_res { 66 u8 dir; 67 u8 cmd; 68 u8 nfcid3[10]; 69 u8 did; 70 u8 bs; 71 u8 br; 72 u8 to; 73 u8 pp; 74 u8 gb[0]; 75 } __packed; 76 77 struct digital_psl_req { 78 u8 dir; 79 u8 cmd; 80 u8 did; 81 u8 brs; 82 u8 fsl; 83 } __packed; 84 85 struct digital_psl_res { 86 u8 dir; 87 u8 cmd; 88 u8 did; 89 } __packed; 90 91 struct digital_dep_req_res { 92 u8 dir; 93 u8 cmd; 94 u8 pfb; 95 } __packed; 96 97 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, 98 struct sk_buff *resp); 99 100 static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev, 101 struct sk_buff *skb) 102 { 103 skb_push(skb, sizeof(u8)); 104 105 skb->data[0] = skb->len; 106 107 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) 108 *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB; 109 } 110 111 static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev, 112 struct sk_buff *skb) 113 { 114 u8 size; 115 116 if (skb->len < 2) 117 return -EIO; 118 119 if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) 120 skb_pull(skb, sizeof(u8)); 121 122 size = skb->data[0]; 123 if (size != skb->len) 124 return -EIO; 125 126 skb_pull(skb, sizeof(u8)); 127 128 return 0; 129 } 130 131 static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg, 132 struct sk_buff *resp) 133 { 134 struct nfc_target *target = arg; 135 struct digital_atr_res *atr_res; 136 u8 gb_len; 137 int rc; 138 139 if (IS_ERR(resp)) { 140 rc = PTR_ERR(resp); 141 resp = NULL; 142 goto exit; 143 } 144 145 rc = ddev->skb_check_crc(resp); 146 if (rc) { 147 PROTOCOL_ERR("14.4.1.6"); 148 goto exit; 149 } 150 151 rc = digital_skb_pull_dep_sod(ddev, resp); 152 if (rc) { 153 PROTOCOL_ERR("14.4.1.2"); 154 goto exit; 155 } 156 157 if (resp->len < sizeof(struct digital_atr_res)) { 158 rc = -EIO; 159 goto exit; 160 } 161 162 gb_len = resp->len - sizeof(struct digital_atr_res); 163 164 atr_res = (struct digital_atr_res *)resp->data; 165 166 rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len); 167 if (rc) 168 goto exit; 169 170 rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE, 171 NFC_RF_INITIATOR); 172 173 ddev->curr_nfc_dep_pni = 0; 174 175 exit: 176 dev_kfree_skb(resp); 177 178 if (rc) 179 ddev->curr_protocol = 0; 180 } 181 182 int digital_in_send_atr_req(struct nfc_digital_dev *ddev, 183 struct nfc_target *target, __u8 comm_mode, __u8 *gb, 184 size_t gb_len) 185 { 186 struct sk_buff *skb; 187 struct digital_atr_req *atr_req; 188 uint size; 189 190 size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len; 191 192 if (size > DIGITAL_ATR_REQ_MAX_SIZE) { 193 PROTOCOL_ERR("14.6.1.1"); 194 return -EINVAL; 195 } 196 197 skb = digital_skb_alloc(ddev, size); 198 if (!skb) 199 return -ENOMEM; 200 201 skb_put(skb, sizeof(struct digital_atr_req)); 202 203 atr_req = (struct digital_atr_req *)skb->data; 204 memset(atr_req, 0, sizeof(struct digital_atr_req)); 205 206 atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 207 atr_req->cmd = DIGITAL_CMD_ATR_REQ; 208 if (target->nfcid2_len) 209 memcpy(atr_req->nfcid3, target->nfcid2, 210 max(target->nfcid2_len, DIGITAL_NFCID3_LEN)); 211 else 212 get_random_bytes(atr_req->nfcid3, DIGITAL_NFCID3_LEN); 213 214 atr_req->did = 0; 215 atr_req->bs = 0; 216 atr_req->br = 0; 217 218 atr_req->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B; 219 220 if (gb_len) { 221 atr_req->pp |= DIGITAL_GB_BIT; 222 memcpy(skb_put(skb, gb_len), gb, gb_len); 223 } 224 225 digital_skb_push_dep_sod(ddev, skb); 226 227 ddev->skb_add_crc(skb); 228 229 digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res, target); 230 231 return 0; 232 } 233 234 static int digital_in_send_rtox(struct nfc_digital_dev *ddev, 235 struct digital_data_exch *data_exch, u8 rtox) 236 { 237 struct digital_dep_req_res *dep_req; 238 struct sk_buff *skb; 239 int rc; 240 241 skb = digital_skb_alloc(ddev, 1); 242 if (!skb) 243 return -ENOMEM; 244 245 *skb_put(skb, 1) = rtox; 246 247 skb_push(skb, sizeof(struct digital_dep_req_res)); 248 249 dep_req = (struct digital_dep_req_res *)skb->data; 250 251 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 252 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 253 dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU | 254 DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT; 255 256 digital_skb_push_dep_sod(ddev, skb); 257 258 ddev->skb_add_crc(skb); 259 260 rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res, 261 data_exch); 262 263 return rc; 264 } 265 266 static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, 267 struct sk_buff *resp) 268 { 269 struct digital_data_exch *data_exch = arg; 270 struct digital_dep_req_res *dep_res; 271 u8 pfb; 272 uint size; 273 int rc; 274 275 if (IS_ERR(resp)) { 276 rc = PTR_ERR(resp); 277 resp = NULL; 278 goto exit; 279 } 280 281 rc = ddev->skb_check_crc(resp); 282 if (rc) { 283 PROTOCOL_ERR("14.4.1.6"); 284 goto error; 285 } 286 287 rc = digital_skb_pull_dep_sod(ddev, resp); 288 if (rc) { 289 PROTOCOL_ERR("14.4.1.2"); 290 goto exit; 291 } 292 293 dep_res = (struct digital_dep_req_res *)resp->data; 294 295 if (resp->len < sizeof(struct digital_dep_req_res) || 296 dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN || 297 dep_res->cmd != DIGITAL_CMD_DEP_RES) { 298 rc = -EIO; 299 goto error; 300 } 301 302 pfb = dep_res->pfb; 303 304 switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) { 305 case DIGITAL_NFC_DEP_PFB_I_PDU: 306 if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { 307 PROTOCOL_ERR("14.12.3.3"); 308 rc = -EIO; 309 goto error; 310 } 311 312 ddev->curr_nfc_dep_pni = 313 DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); 314 rc = 0; 315 break; 316 317 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: 318 pr_err("Received a ACK/NACK PDU\n"); 319 rc = -EIO; 320 goto error; 321 322 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: 323 if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { 324 rc = -EINVAL; 325 goto error; 326 } 327 328 rc = digital_in_send_rtox(ddev, data_exch, resp->data[3]); 329 if (rc) 330 goto error; 331 332 kfree_skb(resp); 333 return; 334 } 335 336 if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) { 337 pr_err("MI bit set. Chained PDU not supported\n"); 338 rc = -EIO; 339 goto error; 340 } 341 342 size = sizeof(struct digital_dep_req_res); 343 344 if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) 345 size++; 346 347 if (size > resp->len) { 348 rc = -EIO; 349 goto error; 350 } 351 352 skb_pull(resp, size); 353 354 exit: 355 data_exch->cb(data_exch->cb_context, resp, rc); 356 357 error: 358 kfree(data_exch); 359 360 if (rc) 361 kfree_skb(resp); 362 } 363 364 int digital_in_send_dep_req(struct nfc_digital_dev *ddev, 365 struct nfc_target *target, struct sk_buff *skb, 366 struct digital_data_exch *data_exch) 367 { 368 struct digital_dep_req_res *dep_req; 369 370 skb_push(skb, sizeof(struct digital_dep_req_res)); 371 372 dep_req = (struct digital_dep_req_res *)skb->data; 373 dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; 374 dep_req->cmd = DIGITAL_CMD_DEP_REQ; 375 dep_req->pfb = ddev->curr_nfc_dep_pni; 376 377 digital_skb_push_dep_sod(ddev, skb); 378 379 ddev->skb_add_crc(skb); 380 381 return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res, 382 data_exch); 383 } 384 385 static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg, 386 struct sk_buff *resp) 387 { 388 int rc; 389 struct digital_dep_req_res *dep_req; 390 size_t size; 391 392 if (IS_ERR(resp)) { 393 rc = PTR_ERR(resp); 394 resp = NULL; 395 goto exit; 396 } 397 398 rc = ddev->skb_check_crc(resp); 399 if (rc) { 400 PROTOCOL_ERR("14.4.1.6"); 401 goto exit; 402 } 403 404 rc = digital_skb_pull_dep_sod(ddev, resp); 405 if (rc) { 406 PROTOCOL_ERR("14.4.1.2"); 407 goto exit; 408 } 409 410 size = sizeof(struct digital_dep_req_res); 411 dep_req = (struct digital_dep_req_res *)resp->data; 412 413 if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 414 dep_req->cmd != DIGITAL_CMD_DEP_REQ) { 415 rc = -EIO; 416 goto exit; 417 } 418 419 if (DIGITAL_NFC_DEP_DID_BIT_SET(dep_req->pfb)) 420 size++; 421 422 if (resp->len < size) { 423 rc = -EIO; 424 goto exit; 425 } 426 427 switch (DIGITAL_NFC_DEP_PFB_TYPE(dep_req->pfb)) { 428 case DIGITAL_NFC_DEP_PFB_I_PDU: 429 pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n"); 430 ddev->curr_nfc_dep_pni = DIGITAL_NFC_DEP_PFB_PNI(dep_req->pfb); 431 break; 432 case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: 433 pr_err("Received a ACK/NACK PDU\n"); 434 rc = -EINVAL; 435 goto exit; 436 break; 437 case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: 438 pr_err("Received a SUPERVISOR PDU\n"); 439 rc = -EINVAL; 440 goto exit; 441 break; 442 } 443 444 skb_pull(resp, size); 445 446 rc = nfc_tm_data_received(ddev->nfc_dev, resp); 447 448 exit: 449 if (rc) 450 kfree_skb(resp); 451 } 452 453 int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb) 454 { 455 struct digital_dep_req_res *dep_res; 456 457 skb_push(skb, sizeof(struct digital_dep_req_res)); 458 dep_res = (struct digital_dep_req_res *)skb->data; 459 460 dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 461 dep_res->cmd = DIGITAL_CMD_DEP_RES; 462 dep_res->pfb = ddev->curr_nfc_dep_pni; 463 464 digital_skb_push_dep_sod(ddev, skb); 465 466 ddev->skb_add_crc(skb); 467 468 return digital_tg_send_cmd(ddev, skb, 1500, digital_tg_recv_dep_req, 469 NULL); 470 } 471 472 static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev, 473 void *arg, struct sk_buff *resp) 474 { 475 u8 rf_tech = PTR_ERR(arg); 476 477 if (IS_ERR(resp)) 478 return; 479 480 digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, rf_tech); 481 482 digital_tg_listen(ddev, 1500, digital_tg_recv_dep_req, NULL); 483 484 dev_kfree_skb(resp); 485 } 486 487 static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did, 488 u8 rf_tech) 489 { 490 struct digital_psl_res *psl_res; 491 struct sk_buff *skb; 492 int rc; 493 494 skb = digital_skb_alloc(ddev, sizeof(struct digital_psl_res)); 495 if (!skb) 496 return -ENOMEM; 497 498 skb_put(skb, sizeof(struct digital_psl_res)); 499 500 psl_res = (struct digital_psl_res *)skb->data; 501 502 psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 503 psl_res->cmd = DIGITAL_CMD_PSL_RES; 504 psl_res->did = did; 505 506 digital_skb_push_dep_sod(ddev, skb); 507 508 ddev->skb_add_crc(skb); 509 510 rc = digital_tg_send_cmd(ddev, skb, 0, digital_tg_send_psl_res_complete, 511 ERR_PTR(rf_tech)); 512 513 if (rc) 514 kfree_skb(skb); 515 516 return rc; 517 } 518 519 static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg, 520 struct sk_buff *resp) 521 { 522 int rc; 523 struct digital_psl_req *psl_req; 524 u8 rf_tech; 525 u8 dsi; 526 527 if (IS_ERR(resp)) { 528 rc = PTR_ERR(resp); 529 resp = NULL; 530 goto exit; 531 } 532 533 rc = ddev->skb_check_crc(resp); 534 if (rc) { 535 PROTOCOL_ERR("14.4.1.6"); 536 goto exit; 537 } 538 539 rc = digital_skb_pull_dep_sod(ddev, resp); 540 if (rc) { 541 PROTOCOL_ERR("14.4.1.2"); 542 goto exit; 543 } 544 545 psl_req = (struct digital_psl_req *)resp->data; 546 547 if (resp->len != sizeof(struct digital_psl_req) || 548 psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 549 psl_req->cmd != DIGITAL_CMD_PSL_REQ) { 550 rc = -EIO; 551 goto exit; 552 } 553 554 dsi = (psl_req->brs >> 3) & 0x07; 555 switch (dsi) { 556 case 0: 557 rf_tech = NFC_DIGITAL_RF_TECH_106A; 558 break; 559 case 1: 560 rf_tech = NFC_DIGITAL_RF_TECH_212F; 561 break; 562 case 2: 563 rf_tech = NFC_DIGITAL_RF_TECH_424F; 564 break; 565 default: 566 pr_err("Unsuported dsi value %d\n", dsi); 567 goto exit; 568 } 569 570 rc = digital_tg_send_psl_res(ddev, psl_req->did, rf_tech); 571 572 exit: 573 kfree_skb(resp); 574 } 575 576 static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev, 577 void *arg, struct sk_buff *resp) 578 { 579 int offset; 580 581 if (IS_ERR(resp)) { 582 digital_poll_next_tech(ddev); 583 return; 584 } 585 586 offset = 2; 587 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) 588 offset++; 589 590 if (resp->data[offset] == DIGITAL_CMD_PSL_REQ) 591 digital_tg_recv_psl_req(ddev, arg, resp); 592 else 593 digital_tg_recv_dep_req(ddev, arg, resp); 594 } 595 596 static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev, 597 struct digital_atr_req *atr_req) 598 { 599 struct digital_atr_res *atr_res; 600 struct sk_buff *skb; 601 u8 *gb; 602 size_t gb_len; 603 int rc; 604 605 gb = nfc_get_local_general_bytes(ddev->nfc_dev, &gb_len); 606 if (!gb) 607 gb_len = 0; 608 609 skb = digital_skb_alloc(ddev, sizeof(struct digital_atr_res) + gb_len); 610 if (!skb) 611 return -ENOMEM; 612 613 skb_put(skb, sizeof(struct digital_atr_res)); 614 atr_res = (struct digital_atr_res *)skb->data; 615 616 memset(atr_res, 0, sizeof(struct digital_atr_res)); 617 618 atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; 619 atr_res->cmd = DIGITAL_CMD_ATR_RES; 620 memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3)); 621 atr_res->to = 8; 622 atr_res->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B; 623 if (gb_len) { 624 skb_put(skb, gb_len); 625 626 atr_res->pp |= DIGITAL_GB_BIT; 627 memcpy(atr_res->gb, gb, gb_len); 628 } 629 630 digital_skb_push_dep_sod(ddev, skb); 631 632 ddev->skb_add_crc(skb); 633 634 rc = digital_tg_send_cmd(ddev, skb, 999, 635 digital_tg_send_atr_res_complete, NULL); 636 if (rc) { 637 kfree_skb(skb); 638 return rc; 639 } 640 641 return rc; 642 } 643 644 void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg, 645 struct sk_buff *resp) 646 { 647 int rc; 648 struct digital_atr_req *atr_req; 649 size_t gb_len, min_size; 650 651 if (IS_ERR(resp)) { 652 rc = PTR_ERR(resp); 653 resp = NULL; 654 goto exit; 655 } 656 657 if (!resp->len) { 658 rc = -EIO; 659 goto exit; 660 } 661 662 if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) { 663 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2; 664 665 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_106A; 666 ddev->skb_add_crc = digital_skb_add_crc_a; 667 ddev->skb_check_crc = digital_skb_check_crc_a; 668 } else { 669 min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1; 670 671 ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_212F; 672 ddev->skb_add_crc = digital_skb_add_crc_f; 673 ddev->skb_check_crc = digital_skb_check_crc_f; 674 } 675 676 if (resp->len < min_size) { 677 rc = -EIO; 678 goto exit; 679 } 680 681 if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) { 682 ddev->skb_add_crc = digital_skb_add_crc_none; 683 ddev->skb_check_crc = digital_skb_check_crc_none; 684 } 685 686 rc = ddev->skb_check_crc(resp); 687 if (rc) { 688 PROTOCOL_ERR("14.4.1.6"); 689 goto exit; 690 } 691 692 rc = digital_skb_pull_dep_sod(ddev, resp); 693 if (rc) { 694 PROTOCOL_ERR("14.4.1.2"); 695 goto exit; 696 } 697 698 atr_req = (struct digital_atr_req *)resp->data; 699 700 if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || 701 atr_req->cmd != DIGITAL_CMD_ATR_REQ) { 702 rc = -EINVAL; 703 goto exit; 704 } 705 706 rc = digital_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 707 NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED); 708 if (rc) 709 goto exit; 710 711 rc = digital_tg_send_atr_res(ddev, atr_req); 712 if (rc) 713 goto exit; 714 715 gb_len = resp->len - sizeof(struct digital_atr_req); 716 rc = nfc_tm_activated(ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK, 717 NFC_COMM_PASSIVE, atr_req->gb, gb_len); 718 if (rc) 719 goto exit; 720 721 ddev->poll_tech_count = 0; 722 723 rc = 0; 724 exit: 725 if (rc) 726 digital_poll_next_tech(ddev); 727 728 dev_kfree_skb(resp); 729 } 730