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