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