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