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 <linux/module.h> 10 11#include "digital.h" 12 13#define DIGITAL_PROTO_NFCA_RF_TECH \ 14 (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | \ 15 NFC_PROTO_NFC_DEP_MASK | NFC_PROTO_ISO14443_MASK) 16 17#define DIGITAL_PROTO_NFCB_RF_TECH NFC_PROTO_ISO14443_B_MASK 18 19#define DIGITAL_PROTO_NFCF_RF_TECH \ 20 (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK) 21 22#define DIGITAL_PROTO_ISO15693_RF_TECH NFC_PROTO_ISO15693_MASK 23 24/* Delay between each poll frame (ms) */ 25#define DIGITAL_POLL_INTERVAL 10 26 27struct digital_cmd { 28 struct list_head queue; 29 30 u8 type; 31 u8 pending; 32 33 u16 timeout; 34 struct sk_buff *req; 35 struct sk_buff *resp; 36 struct digital_tg_mdaa_params *mdaa_params; 37 38 nfc_digital_cmd_complete_t cmd_cb; 39 void *cb_context; 40}; 41 42struct sk_buff *digital_skb_alloc(struct nfc_digital_dev *ddev, 43 unsigned int len) 44{ 45 struct sk_buff *skb; 46 47 skb = alloc_skb(len + ddev->tx_headroom + ddev->tx_tailroom, 48 GFP_KERNEL); 49 if (skb) 50 skb_reserve(skb, ddev->tx_headroom); 51 52 return skb; 53} 54 55void digital_skb_add_crc(struct sk_buff *skb, crc_func_t crc_func, u16 init, 56 u8 bitwise_inv, u8 msb_first) 57{ 58 u16 crc; 59 60 crc = crc_func(init, skb->data, skb->len); 61 62 if (bitwise_inv) 63 crc = ~crc; 64 65 if (msb_first) 66 crc = __fswab16(crc); 67 68 skb_put_u8(skb, crc & 0xFF); 69 skb_put_u8(skb, (crc >> 8) & 0xFF); 70} 71 72int digital_skb_check_crc(struct sk_buff *skb, crc_func_t crc_func, 73 u16 crc_init, u8 bitwise_inv, u8 msb_first) 74{ 75 int rc; 76 u16 crc; 77 78 if (skb->len <= 2) 79 return -EIO; 80 81 crc = crc_func(crc_init, skb->data, skb->len - 2); 82 83 if (bitwise_inv) 84 crc = ~crc; 85 86 if (msb_first) 87 crc = __swab16(crc); 88 89 rc = (skb->data[skb->len - 2] - (crc & 0xFF)) + 90 (skb->data[skb->len - 1] - ((crc >> 8) & 0xFF)); 91 92 if (rc) 93 return -EIO; 94 95 skb_trim(skb, skb->len - 2); 96 97 return 0; 98} 99 100static inline void digital_switch_rf(struct nfc_digital_dev *ddev, bool on) 101{ 102 ddev->ops->switch_rf(ddev, on); 103} 104 105static inline void digital_abort_cmd(struct nfc_digital_dev *ddev) 106{ 107 ddev->ops->abort_cmd(ddev); 108} 109 110static void digital_wq_cmd_complete(struct work_struct *work) 111{ 112 struct digital_cmd *cmd; 113 struct nfc_digital_dev *ddev = container_of(work, 114 struct nfc_digital_dev, 115 cmd_complete_work); 116 117 mutex_lock(&ddev->cmd_lock); 118 119 cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd, 120 queue); 121 if (!cmd) { 122 mutex_unlock(&ddev->cmd_lock); 123 return; 124 } 125 126 list_del(&cmd->queue); 127 128 mutex_unlock(&ddev->cmd_lock); 129 130 if (!IS_ERR(cmd->resp)) 131 print_hex_dump_debug("DIGITAL RX: ", DUMP_PREFIX_NONE, 16, 1, 132 cmd->resp->data, cmd->resp->len, false); 133 134 cmd->cmd_cb(ddev, cmd->cb_context, cmd->resp); 135 136 kfree(cmd->mdaa_params); 137 kfree(cmd); 138 139 schedule_work(&ddev->cmd_work); 140} 141 142static void digital_send_cmd_complete(struct nfc_digital_dev *ddev, 143 void *arg, struct sk_buff *resp) 144{ 145 struct digital_cmd *cmd = arg; 146 147 cmd->resp = resp; 148 149 schedule_work(&ddev->cmd_complete_work); 150} 151 152static void digital_wq_cmd(struct work_struct *work) 153{ 154 int rc; 155 struct digital_cmd *cmd; 156 struct digital_tg_mdaa_params *params; 157 struct nfc_digital_dev *ddev = container_of(work, 158 struct nfc_digital_dev, 159 cmd_work); 160 161 mutex_lock(&ddev->cmd_lock); 162 163 cmd = list_first_entry_or_null(&ddev->cmd_queue, struct digital_cmd, 164 queue); 165 if (!cmd || cmd->pending) { 166 mutex_unlock(&ddev->cmd_lock); 167 return; 168 } 169 170 cmd->pending = 1; 171 172 mutex_unlock(&ddev->cmd_lock); 173 174 if (cmd->req) 175 print_hex_dump_debug("DIGITAL TX: ", DUMP_PREFIX_NONE, 16, 1, 176 cmd->req->data, cmd->req->len, false); 177 178 switch (cmd->type) { 179 case DIGITAL_CMD_IN_SEND: 180 rc = ddev->ops->in_send_cmd(ddev, cmd->req, cmd->timeout, 181 digital_send_cmd_complete, cmd); 182 break; 183 184 case DIGITAL_CMD_TG_SEND: 185 rc = ddev->ops->tg_send_cmd(ddev, cmd->req, cmd->timeout, 186 digital_send_cmd_complete, cmd); 187 break; 188 189 case DIGITAL_CMD_TG_LISTEN: 190 rc = ddev->ops->tg_listen(ddev, cmd->timeout, 191 digital_send_cmd_complete, cmd); 192 break; 193 194 case DIGITAL_CMD_TG_LISTEN_MDAA: 195 params = cmd->mdaa_params; 196 197 rc = ddev->ops->tg_listen_mdaa(ddev, params, cmd->timeout, 198 digital_send_cmd_complete, cmd); 199 break; 200 201 case DIGITAL_CMD_TG_LISTEN_MD: 202 rc = ddev->ops->tg_listen_md(ddev, cmd->timeout, 203 digital_send_cmd_complete, cmd); 204 break; 205 206 default: 207 pr_err("Unknown cmd type %d\n", cmd->type); 208 return; 209 } 210 211 if (!rc) 212 return; 213 214 pr_err("in_send_command returned err %d\n", rc); 215 216 mutex_lock(&ddev->cmd_lock); 217 list_del(&cmd->queue); 218 mutex_unlock(&ddev->cmd_lock); 219 220 kfree_skb(cmd->req); 221 kfree(cmd->mdaa_params); 222 kfree(cmd); 223 224 schedule_work(&ddev->cmd_work); 225} 226 227int digital_send_cmd(struct nfc_digital_dev *ddev, u8 cmd_type, 228 struct sk_buff *skb, struct digital_tg_mdaa_params *params, 229 u16 timeout, nfc_digital_cmd_complete_t cmd_cb, 230 void *cb_context) 231{ 232 struct digital_cmd *cmd; 233 234 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 235 if (!cmd) 236 return -ENOMEM; 237 238 cmd->type = cmd_type; 239 cmd->timeout = timeout; 240 cmd->req = skb; 241 cmd->mdaa_params = params; 242 cmd->cmd_cb = cmd_cb; 243 cmd->cb_context = cb_context; 244 INIT_LIST_HEAD(&cmd->queue); 245 246 mutex_lock(&ddev->cmd_lock); 247 list_add_tail(&cmd->queue, &ddev->cmd_queue); 248 mutex_unlock(&ddev->cmd_lock); 249 250 schedule_work(&ddev->cmd_work); 251 252 return 0; 253} 254 255int digital_in_configure_hw(struct nfc_digital_dev *ddev, int type, int param) 256{ 257 int rc; 258 259 rc = ddev->ops->in_configure_hw(ddev, type, param); 260 if (rc) 261 pr_err("in_configure_hw failed: %d\n", rc); 262 263 return rc; 264} 265 266int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param) 267{ 268 int rc; 269 270 rc = ddev->ops->tg_configure_hw(ddev, type, param); 271 if (rc) 272 pr_err("tg_configure_hw failed: %d\n", rc); 273 274 return rc; 275} 276 277static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech) 278{ 279 struct digital_tg_mdaa_params *params; 280 int rc; 281 282 params = kzalloc(sizeof(*params), GFP_KERNEL); 283 if (!params) 284 return -ENOMEM; 285 286 params->sens_res = DIGITAL_SENS_RES_NFC_DEP; 287 get_random_bytes(params->nfcid1, sizeof(params->nfcid1)); 288 params->sel_res = DIGITAL_SEL_RES_NFC_DEP; 289 290 params->nfcid2[0] = DIGITAL_SENSF_NFCID2_NFC_DEP_B1; 291 params->nfcid2[1] = DIGITAL_SENSF_NFCID2_NFC_DEP_B2; 292 get_random_bytes(params->nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2); 293 params->sc = DIGITAL_SENSF_FELICA_SC; 294 295 rc = digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params, 296 500, digital_tg_recv_atr_req, NULL); 297 if (rc) 298 kfree(params); 299 300 return rc; 301} 302 303static int digital_tg_listen_md(struct nfc_digital_dev *ddev, u8 rf_tech) 304{ 305 return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MD, NULL, NULL, 500, 306 digital_tg_recv_md_req, NULL); 307} 308 309int digital_target_found(struct nfc_digital_dev *ddev, 310 struct nfc_target *target, u8 protocol) 311{ 312 int rc; 313 u8 framing; 314 u8 rf_tech; 315 u8 poll_tech_count; 316 int (*check_crc)(struct sk_buff *skb); 317 void (*add_crc)(struct sk_buff *skb); 318 319 rf_tech = ddev->poll_techs[ddev->poll_tech_index].rf_tech; 320 321 switch (protocol) { 322 case NFC_PROTO_JEWEL: 323 framing = NFC_DIGITAL_FRAMING_NFCA_T1T; 324 check_crc = digital_skb_check_crc_b; 325 add_crc = digital_skb_add_crc_b; 326 break; 327 328 case NFC_PROTO_MIFARE: 329 framing = NFC_DIGITAL_FRAMING_NFCA_T2T; 330 check_crc = digital_skb_check_crc_a; 331 add_crc = digital_skb_add_crc_a; 332 break; 333 334 case NFC_PROTO_FELICA: 335 framing = NFC_DIGITAL_FRAMING_NFCF_T3T; 336 check_crc = digital_skb_check_crc_f; 337 add_crc = digital_skb_add_crc_f; 338 break; 339 340 case NFC_PROTO_NFC_DEP: 341 if (rf_tech == NFC_DIGITAL_RF_TECH_106A) { 342 framing = NFC_DIGITAL_FRAMING_NFCA_NFC_DEP; 343 check_crc = digital_skb_check_crc_a; 344 add_crc = digital_skb_add_crc_a; 345 } else { 346 framing = NFC_DIGITAL_FRAMING_NFCF_NFC_DEP; 347 check_crc = digital_skb_check_crc_f; 348 add_crc = digital_skb_add_crc_f; 349 } 350 break; 351 352 case NFC_PROTO_ISO15693: 353 framing = NFC_DIGITAL_FRAMING_ISO15693_T5T; 354 check_crc = digital_skb_check_crc_b; 355 add_crc = digital_skb_add_crc_b; 356 break; 357 358 case NFC_PROTO_ISO14443: 359 framing = NFC_DIGITAL_FRAMING_NFCA_T4T; 360 check_crc = digital_skb_check_crc_a; 361 add_crc = digital_skb_add_crc_a; 362 break; 363 364 case NFC_PROTO_ISO14443_B: 365 framing = NFC_DIGITAL_FRAMING_NFCB_T4T; 366 check_crc = digital_skb_check_crc_b; 367 add_crc = digital_skb_add_crc_b; 368 break; 369 370 default: 371 pr_err("Invalid protocol %d\n", protocol); 372 return -EINVAL; 373 } 374 375 pr_debug("rf_tech=%d, protocol=%d\n", rf_tech, protocol); 376 377 ddev->curr_rf_tech = rf_tech; 378 379 if (DIGITAL_DRV_CAPS_IN_CRC(ddev)) { 380 ddev->skb_add_crc = digital_skb_add_crc_none; 381 ddev->skb_check_crc = digital_skb_check_crc_none; 382 } else { 383 ddev->skb_add_crc = add_crc; 384 ddev->skb_check_crc = check_crc; 385 } 386 387 rc = digital_in_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, framing); 388 if (rc) 389 return rc; 390 391 target->supported_protocols = (1 << protocol); 392 393 poll_tech_count = ddev->poll_tech_count; 394 ddev->poll_tech_count = 0; 395 396 rc = nfc_targets_found(ddev->nfc_dev, target, 1); 397 if (rc) { 398 ddev->poll_tech_count = poll_tech_count; 399 return rc; 400 } 401 402 return 0; 403} 404 405void digital_poll_next_tech(struct nfc_digital_dev *ddev) 406{ 407 u8 rand_mod; 408 409 digital_switch_rf(ddev, 0); 410 411 mutex_lock(&ddev->poll_lock); 412 413 if (!ddev->poll_tech_count) { 414 mutex_unlock(&ddev->poll_lock); 415 return; 416 } 417 418 get_random_bytes(&rand_mod, sizeof(rand_mod)); 419 ddev->poll_tech_index = rand_mod % ddev->poll_tech_count; 420 421 mutex_unlock(&ddev->poll_lock); 422 423 schedule_delayed_work(&ddev->poll_work, 424 msecs_to_jiffies(DIGITAL_POLL_INTERVAL)); 425} 426 427static void digital_wq_poll(struct work_struct *work) 428{ 429 int rc; 430 struct digital_poll_tech *poll_tech; 431 struct nfc_digital_dev *ddev = container_of(work, 432 struct nfc_digital_dev, 433 poll_work.work); 434 mutex_lock(&ddev->poll_lock); 435 436 if (!ddev->poll_tech_count) { 437 mutex_unlock(&ddev->poll_lock); 438 return; 439 } 440 441 poll_tech = &ddev->poll_techs[ddev->poll_tech_index]; 442 443 mutex_unlock(&ddev->poll_lock); 444 445 rc = poll_tech->poll_func(ddev, poll_tech->rf_tech); 446 if (rc) 447 digital_poll_next_tech(ddev); 448} 449 450static void digital_add_poll_tech(struct nfc_digital_dev *ddev, u8 rf_tech, 451 digital_poll_t poll_func) 452{ 453 struct digital_poll_tech *poll_tech; 454 455 if (ddev->poll_tech_count >= NFC_DIGITAL_POLL_MODE_COUNT_MAX) 456 return; 457 458 poll_tech = &ddev->poll_techs[ddev->poll_tech_count++]; 459 460 poll_tech->rf_tech = rf_tech; 461 poll_tech->poll_func = poll_func; 462} 463 464/** 465 * start_poll operation 466 * 467 * For every supported protocol, the corresponding polling function is added 468 * to the table of polling technologies (ddev->poll_techs[]) using 469 * digital_add_poll_tech(). 470 * When a polling function fails (by timeout or protocol error) the next one is 471 * schedule by digital_poll_next_tech() on the poll workqueue (ddev->poll_work). 472 */ 473static int digital_start_poll(struct nfc_dev *nfc_dev, __u32 im_protocols, 474 __u32 tm_protocols) 475{ 476 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 477 u32 matching_im_protocols, matching_tm_protocols; 478 479 pr_debug("protocols: im 0x%x, tm 0x%x, supported 0x%x\n", im_protocols, 480 tm_protocols, ddev->protocols); 481 482 matching_im_protocols = ddev->protocols & im_protocols; 483 matching_tm_protocols = ddev->protocols & tm_protocols; 484 485 if (!matching_im_protocols && !matching_tm_protocols) { 486 pr_err("Unknown protocol\n"); 487 return -EINVAL; 488 } 489 490 if (ddev->poll_tech_count) { 491 pr_err("Already polling\n"); 492 return -EBUSY; 493 } 494 495 if (ddev->curr_protocol) { 496 pr_err("A target is already active\n"); 497 return -EBUSY; 498 } 499 500 ddev->poll_tech_count = 0; 501 ddev->poll_tech_index = 0; 502 503 if (matching_im_protocols & DIGITAL_PROTO_NFCA_RF_TECH) 504 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A, 505 digital_in_send_sens_req); 506 507 if (matching_im_protocols & DIGITAL_PROTO_NFCB_RF_TECH) 508 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106B, 509 digital_in_send_sensb_req); 510 511 if (matching_im_protocols & DIGITAL_PROTO_NFCF_RF_TECH) { 512 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F, 513 digital_in_send_sensf_req); 514 515 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F, 516 digital_in_send_sensf_req); 517 } 518 519 if (matching_im_protocols & DIGITAL_PROTO_ISO15693_RF_TECH) 520 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_ISO15693, 521 digital_in_send_iso15693_inv_req); 522 523 if (matching_tm_protocols & NFC_PROTO_NFC_DEP_MASK) { 524 if (ddev->ops->tg_listen_mdaa) { 525 digital_add_poll_tech(ddev, 0, 526 digital_tg_listen_mdaa); 527 } else if (ddev->ops->tg_listen_md) { 528 digital_add_poll_tech(ddev, 0, 529 digital_tg_listen_md); 530 } else { 531 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_106A, 532 digital_tg_listen_nfca); 533 534 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_212F, 535 digital_tg_listen_nfcf); 536 537 digital_add_poll_tech(ddev, NFC_DIGITAL_RF_TECH_424F, 538 digital_tg_listen_nfcf); 539 } 540 } 541 542 if (!ddev->poll_tech_count) { 543 pr_err("Unsupported protocols: im=0x%x, tm=0x%x\n", 544 matching_im_protocols, matching_tm_protocols); 545 return -EINVAL; 546 } 547 548 schedule_delayed_work(&ddev->poll_work, 0); 549 550 return 0; 551} 552 553static void digital_stop_poll(struct nfc_dev *nfc_dev) 554{ 555 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 556 557 mutex_lock(&ddev->poll_lock); 558 559 if (!ddev->poll_tech_count) { 560 pr_err("Polling operation was not running\n"); 561 mutex_unlock(&ddev->poll_lock); 562 return; 563 } 564 565 ddev->poll_tech_count = 0; 566 567 mutex_unlock(&ddev->poll_lock); 568 569 cancel_delayed_work_sync(&ddev->poll_work); 570 571 digital_abort_cmd(ddev); 572} 573 574static int digital_dev_up(struct nfc_dev *nfc_dev) 575{ 576 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 577 578 digital_switch_rf(ddev, 1); 579 580 return 0; 581} 582 583static int digital_dev_down(struct nfc_dev *nfc_dev) 584{ 585 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 586 587 digital_switch_rf(ddev, 0); 588 589 return 0; 590} 591 592static int digital_dep_link_up(struct nfc_dev *nfc_dev, 593 struct nfc_target *target, 594 __u8 comm_mode, __u8 *gb, size_t gb_len) 595{ 596 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 597 int rc; 598 599 rc = digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len); 600 601 if (!rc) 602 ddev->curr_protocol = NFC_PROTO_NFC_DEP; 603 604 return rc; 605} 606 607static int digital_dep_link_down(struct nfc_dev *nfc_dev) 608{ 609 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 610 611 digital_abort_cmd(ddev); 612 613 ddev->curr_protocol = 0; 614 615 return 0; 616} 617 618static int digital_activate_target(struct nfc_dev *nfc_dev, 619 struct nfc_target *target, __u32 protocol) 620{ 621 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 622 623 if (ddev->poll_tech_count) { 624 pr_err("Can't activate a target while polling\n"); 625 return -EBUSY; 626 } 627 628 if (ddev->curr_protocol) { 629 pr_err("A target is already active\n"); 630 return -EBUSY; 631 } 632 633 ddev->curr_protocol = protocol; 634 635 return 0; 636} 637 638static void digital_deactivate_target(struct nfc_dev *nfc_dev, 639 struct nfc_target *target, 640 u8 mode) 641{ 642 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 643 644 if (!ddev->curr_protocol) { 645 pr_err("No active target\n"); 646 return; 647 } 648 649 digital_abort_cmd(ddev); 650 ddev->curr_protocol = 0; 651} 652 653static int digital_tg_send(struct nfc_dev *dev, struct sk_buff *skb) 654{ 655 struct nfc_digital_dev *ddev = nfc_get_drvdata(dev); 656 657 return digital_tg_send_dep_res(ddev, skb); 658} 659 660static void digital_in_send_complete(struct nfc_digital_dev *ddev, void *arg, 661 struct sk_buff *resp) 662{ 663 struct digital_data_exch *data_exch = arg; 664 int rc; 665 666 if (IS_ERR(resp)) { 667 rc = PTR_ERR(resp); 668 resp = NULL; 669 goto done; 670 } 671 672 if (ddev->curr_protocol == NFC_PROTO_MIFARE) { 673 rc = digital_in_recv_mifare_res(resp); 674 /* crc check is done in digital_in_recv_mifare_res() */ 675 goto done; 676 } 677 678 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) || 679 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) { 680 rc = digital_in_iso_dep_pull_sod(ddev, resp); 681 if (rc) 682 goto done; 683 } 684 685 rc = ddev->skb_check_crc(resp); 686 687done: 688 if (rc) { 689 kfree_skb(resp); 690 resp = NULL; 691 } 692 693 data_exch->cb(data_exch->cb_context, resp, rc); 694 695 kfree(data_exch); 696} 697 698static int digital_in_send(struct nfc_dev *nfc_dev, struct nfc_target *target, 699 struct sk_buff *skb, data_exchange_cb_t cb, 700 void *cb_context) 701{ 702 struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev); 703 struct digital_data_exch *data_exch; 704 int rc; 705 706 data_exch = kzalloc(sizeof(*data_exch), GFP_KERNEL); 707 if (!data_exch) 708 return -ENOMEM; 709 710 data_exch->cb = cb; 711 data_exch->cb_context = cb_context; 712 713 if (ddev->curr_protocol == NFC_PROTO_NFC_DEP) { 714 rc = digital_in_send_dep_req(ddev, target, skb, data_exch); 715 goto exit; 716 } 717 718 if ((ddev->curr_protocol == NFC_PROTO_ISO14443) || 719 (ddev->curr_protocol == NFC_PROTO_ISO14443_B)) { 720 rc = digital_in_iso_dep_push_sod(ddev, skb); 721 if (rc) 722 goto exit; 723 } 724 725 ddev->skb_add_crc(skb); 726 727 rc = digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete, 728 data_exch); 729 730exit: 731 if (rc) 732 kfree(data_exch); 733 734 return rc; 735} 736 737static struct nfc_ops digital_nfc_ops = { 738 .dev_up = digital_dev_up, 739 .dev_down = digital_dev_down, 740 .start_poll = digital_start_poll, 741 .stop_poll = digital_stop_poll, 742 .dep_link_up = digital_dep_link_up, 743 .dep_link_down = digital_dep_link_down, 744 .activate_target = digital_activate_target, 745 .deactivate_target = digital_deactivate_target, 746 .tm_send = digital_tg_send, 747 .im_transceive = digital_in_send, 748}; 749 750struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops, 751 __u32 supported_protocols, 752 __u32 driver_capabilities, 753 int tx_headroom, int tx_tailroom) 754{ 755 struct nfc_digital_dev *ddev; 756 757 if (!ops->in_configure_hw || !ops->in_send_cmd || !ops->tg_listen || 758 !ops->tg_configure_hw || !ops->tg_send_cmd || !ops->abort_cmd || 759 !ops->switch_rf || (ops->tg_listen_md && !ops->tg_get_rf_tech)) 760 return NULL; 761 762 ddev = kzalloc(sizeof(*ddev), GFP_KERNEL); 763 if (!ddev) 764 return NULL; 765 766 ddev->driver_capabilities = driver_capabilities; 767 ddev->ops = ops; 768 769 mutex_init(&ddev->cmd_lock); 770 INIT_LIST_HEAD(&ddev->cmd_queue); 771 772 INIT_WORK(&ddev->cmd_work, digital_wq_cmd); 773 INIT_WORK(&ddev->cmd_complete_work, digital_wq_cmd_complete); 774 775 mutex_init(&ddev->poll_lock); 776 INIT_DELAYED_WORK(&ddev->poll_work, digital_wq_poll); 777 778 if (supported_protocols & NFC_PROTO_JEWEL_MASK) 779 ddev->protocols |= NFC_PROTO_JEWEL_MASK; 780 if (supported_protocols & NFC_PROTO_MIFARE_MASK) 781 ddev->protocols |= NFC_PROTO_MIFARE_MASK; 782 if (supported_protocols & NFC_PROTO_FELICA_MASK) 783 ddev->protocols |= NFC_PROTO_FELICA_MASK; 784 if (supported_protocols & NFC_PROTO_NFC_DEP_MASK) 785 ddev->protocols |= NFC_PROTO_NFC_DEP_MASK; 786 if (supported_protocols & NFC_PROTO_ISO15693_MASK) 787 ddev->protocols |= NFC_PROTO_ISO15693_MASK; 788 if (supported_protocols & NFC_PROTO_ISO14443_MASK) 789 ddev->protocols |= NFC_PROTO_ISO14443_MASK; 790 if (supported_protocols & NFC_PROTO_ISO14443_B_MASK) 791 ddev->protocols |= NFC_PROTO_ISO14443_B_MASK; 792 793 ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN; 794 ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN; 795 796 ddev->nfc_dev = nfc_allocate_device(&digital_nfc_ops, ddev->protocols, 797 ddev->tx_headroom, 798 ddev->tx_tailroom); 799 if (!ddev->nfc_dev) { 800 pr_err("nfc_allocate_device failed\n"); 801 goto free_dev; 802 } 803 804 nfc_set_drvdata(ddev->nfc_dev, ddev); 805 806 return ddev; 807 808free_dev: 809 kfree(ddev); 810 811 return NULL; 812} 813EXPORT_SYMBOL(nfc_digital_allocate_device); 814 815void nfc_digital_free_device(struct nfc_digital_dev *ddev) 816{ 817 nfc_free_device(ddev->nfc_dev); 818 kfree(ddev); 819} 820EXPORT_SYMBOL(nfc_digital_free_device); 821 822int nfc_digital_register_device(struct nfc_digital_dev *ddev) 823{ 824 return nfc_register_device(ddev->nfc_dev); 825} 826EXPORT_SYMBOL(nfc_digital_register_device); 827 828void nfc_digital_unregister_device(struct nfc_digital_dev *ddev) 829{ 830 struct digital_cmd *cmd, *n; 831 832 nfc_unregister_device(ddev->nfc_dev); 833 834 mutex_lock(&ddev->poll_lock); 835 ddev->poll_tech_count = 0; 836 mutex_unlock(&ddev->poll_lock); 837 838 cancel_delayed_work_sync(&ddev->poll_work); 839 cancel_work_sync(&ddev->cmd_work); 840 cancel_work_sync(&ddev->cmd_complete_work); 841 842 list_for_each_entry_safe(cmd, n, &ddev->cmd_queue, queue) { 843 list_del(&cmd->queue); 844 845 /* Call the command callback if any and pass it a ENODEV error. 846 * This gives a chance to the command issuer to free any 847 * allocated buffer. 848 */ 849 if (cmd->cmd_cb) 850 cmd->cmd_cb(ddev, cmd->cb_context, ERR_PTR(-ENODEV)); 851 852 kfree(cmd->mdaa_params); 853 kfree(cmd); 854 } 855} 856EXPORT_SYMBOL(nfc_digital_unregister_device); 857 858MODULE_LICENSE("GPL"); 859