1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2011 Instituto Nokia de Tecnologia 4 * 5 * Authors: 6 * Lauro Ramos Venancio <lauro.venancio@openbossa.org> 7 * Aloisio Almeida Jr <aloisio.almeida@openbossa.org> 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ 11 12 #include <linux/init.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <linux/rfkill.h> 17 #include <linux/nfc.h> 18 19 #include <net/genetlink.h> 20 21 #include "nfc.h" 22 23 #define VERSION "0.1" 24 25 #define NFC_CHECK_PRES_FREQ_MS 2000 26 27 int nfc_devlist_generation; 28 DEFINE_MUTEX(nfc_devlist_mutex); 29 30 /* NFC device ID bitmap */ 31 static DEFINE_IDA(nfc_index_ida); 32 33 int nfc_fw_download(struct nfc_dev *dev, const char *firmware_name) 34 { 35 int rc = 0; 36 37 pr_debug("%s do firmware %s\n", dev_name(&dev->dev), firmware_name); 38 39 device_lock(&dev->dev); 40 41 if (!device_is_registered(&dev->dev)) { 42 rc = -ENODEV; 43 goto error; 44 } 45 46 if (dev->dev_up) { 47 rc = -EBUSY; 48 goto error; 49 } 50 51 if (!dev->ops->fw_download) { 52 rc = -EOPNOTSUPP; 53 goto error; 54 } 55 56 dev->fw_download_in_progress = true; 57 rc = dev->ops->fw_download(dev, firmware_name); 58 if (rc) 59 dev->fw_download_in_progress = false; 60 61 error: 62 device_unlock(&dev->dev); 63 return rc; 64 } 65 66 /** 67 * nfc_fw_download_done - inform that a firmware download was completed 68 * 69 * @dev: The nfc device to which firmware was downloaded 70 * @firmware_name: The firmware filename 71 * @result: The positive value of a standard errno value 72 */ 73 int nfc_fw_download_done(struct nfc_dev *dev, const char *firmware_name, 74 u32 result) 75 { 76 dev->fw_download_in_progress = false; 77 78 return nfc_genl_fw_download_done(dev, firmware_name, result); 79 } 80 EXPORT_SYMBOL(nfc_fw_download_done); 81 82 /** 83 * nfc_dev_up - turn on the NFC device 84 * 85 * @dev: The nfc device to be turned on 86 * 87 * The device remains up until the nfc_dev_down function is called. 88 */ 89 int nfc_dev_up(struct nfc_dev *dev) 90 { 91 int rc = 0; 92 93 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 94 95 device_lock(&dev->dev); 96 97 if (dev->rfkill && rfkill_blocked(dev->rfkill)) { 98 rc = -ERFKILL; 99 goto error; 100 } 101 102 if (!device_is_registered(&dev->dev)) { 103 rc = -ENODEV; 104 goto error; 105 } 106 107 if (dev->fw_download_in_progress) { 108 rc = -EBUSY; 109 goto error; 110 } 111 112 if (dev->dev_up) { 113 rc = -EALREADY; 114 goto error; 115 } 116 117 if (dev->ops->dev_up) 118 rc = dev->ops->dev_up(dev); 119 120 if (!rc) 121 dev->dev_up = true; 122 123 /* We have to enable the device before discovering SEs */ 124 if (dev->ops->discover_se && dev->ops->discover_se(dev)) 125 pr_err("SE discovery failed\n"); 126 127 error: 128 device_unlock(&dev->dev); 129 return rc; 130 } 131 132 /** 133 * nfc_dev_down - turn off the NFC device 134 * 135 * @dev: The nfc device to be turned off 136 */ 137 int nfc_dev_down(struct nfc_dev *dev) 138 { 139 int rc = 0; 140 141 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 142 143 device_lock(&dev->dev); 144 145 if (!device_is_registered(&dev->dev)) { 146 rc = -ENODEV; 147 goto error; 148 } 149 150 if (!dev->dev_up) { 151 rc = -EALREADY; 152 goto error; 153 } 154 155 if (dev->polling || dev->active_target) { 156 rc = -EBUSY; 157 goto error; 158 } 159 160 if (dev->ops->dev_down) 161 dev->ops->dev_down(dev); 162 163 dev->dev_up = false; 164 165 error: 166 device_unlock(&dev->dev); 167 return rc; 168 } 169 170 static int nfc_rfkill_set_block(void *data, bool blocked) 171 { 172 struct nfc_dev *dev = data; 173 174 pr_debug("%s blocked %d", dev_name(&dev->dev), blocked); 175 176 if (!blocked) 177 return 0; 178 179 nfc_dev_down(dev); 180 181 return 0; 182 } 183 184 static const struct rfkill_ops nfc_rfkill_ops = { 185 .set_block = nfc_rfkill_set_block, 186 }; 187 188 /** 189 * nfc_start_poll - start polling for nfc targets 190 * 191 * @dev: The nfc device that must start polling 192 * @protocols: bitset of nfc protocols that must be used for polling 193 * 194 * The device remains polling for targets until a target is found or 195 * the nfc_stop_poll function is called. 196 */ 197 int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols) 198 { 199 int rc; 200 201 pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n", 202 dev_name(&dev->dev), im_protocols, tm_protocols); 203 204 if (!im_protocols && !tm_protocols) 205 return -EINVAL; 206 207 device_lock(&dev->dev); 208 209 if (!device_is_registered(&dev->dev)) { 210 rc = -ENODEV; 211 goto error; 212 } 213 214 if (!dev->dev_up) { 215 rc = -ENODEV; 216 goto error; 217 } 218 219 if (dev->polling) { 220 rc = -EBUSY; 221 goto error; 222 } 223 224 rc = dev->ops->start_poll(dev, im_protocols, tm_protocols); 225 if (!rc) { 226 dev->polling = true; 227 dev->rf_mode = NFC_RF_NONE; 228 } 229 230 error: 231 device_unlock(&dev->dev); 232 return rc; 233 } 234 235 /** 236 * nfc_stop_poll - stop polling for nfc targets 237 * 238 * @dev: The nfc device that must stop polling 239 */ 240 int nfc_stop_poll(struct nfc_dev *dev) 241 { 242 int rc = 0; 243 244 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 245 246 device_lock(&dev->dev); 247 248 if (!device_is_registered(&dev->dev)) { 249 rc = -ENODEV; 250 goto error; 251 } 252 253 if (!dev->polling) { 254 rc = -EINVAL; 255 goto error; 256 } 257 258 dev->ops->stop_poll(dev); 259 dev->polling = false; 260 dev->rf_mode = NFC_RF_NONE; 261 262 error: 263 device_unlock(&dev->dev); 264 return rc; 265 } 266 267 static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx) 268 { 269 int i; 270 271 for (i = 0; i < dev->n_targets; i++) { 272 if (dev->targets[i].idx == target_idx) 273 return &dev->targets[i]; 274 } 275 276 return NULL; 277 } 278 279 int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode) 280 { 281 int rc = 0; 282 u8 *gb; 283 size_t gb_len; 284 struct nfc_target *target; 285 286 pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode); 287 288 if (!dev->ops->dep_link_up) 289 return -EOPNOTSUPP; 290 291 device_lock(&dev->dev); 292 293 if (!device_is_registered(&dev->dev)) { 294 rc = -ENODEV; 295 goto error; 296 } 297 298 if (dev->dep_link_up == true) { 299 rc = -EALREADY; 300 goto error; 301 } 302 303 gb = nfc_llcp_general_bytes(dev, &gb_len); 304 if (gb_len > NFC_MAX_GT_LEN) { 305 rc = -EINVAL; 306 goto error; 307 } 308 309 target = nfc_find_target(dev, target_index); 310 if (target == NULL) { 311 rc = -ENOTCONN; 312 goto error; 313 } 314 315 rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len); 316 if (!rc) { 317 dev->active_target = target; 318 dev->rf_mode = NFC_RF_INITIATOR; 319 } 320 321 error: 322 device_unlock(&dev->dev); 323 return rc; 324 } 325 326 int nfc_dep_link_down(struct nfc_dev *dev) 327 { 328 int rc = 0; 329 330 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 331 332 if (!dev->ops->dep_link_down) 333 return -EOPNOTSUPP; 334 335 device_lock(&dev->dev); 336 337 if (!device_is_registered(&dev->dev)) { 338 rc = -ENODEV; 339 goto error; 340 } 341 342 if (dev->dep_link_up == false) { 343 rc = -EALREADY; 344 goto error; 345 } 346 347 rc = dev->ops->dep_link_down(dev); 348 if (!rc) { 349 dev->dep_link_up = false; 350 dev->active_target = NULL; 351 dev->rf_mode = NFC_RF_NONE; 352 nfc_llcp_mac_is_down(dev); 353 nfc_genl_dep_link_down_event(dev); 354 } 355 356 error: 357 device_unlock(&dev->dev); 358 359 return rc; 360 } 361 362 int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx, 363 u8 comm_mode, u8 rf_mode) 364 { 365 dev->dep_link_up = true; 366 367 if (!dev->active_target && rf_mode == NFC_RF_INITIATOR) { 368 struct nfc_target *target; 369 370 target = nfc_find_target(dev, target_idx); 371 if (target == NULL) 372 return -ENOTCONN; 373 374 dev->active_target = target; 375 } 376 377 dev->polling = false; 378 dev->rf_mode = rf_mode; 379 380 nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode); 381 382 return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode); 383 } 384 EXPORT_SYMBOL(nfc_dep_link_is_up); 385 386 /** 387 * nfc_activate_target - prepare the target for data exchange 388 * 389 * @dev: The nfc device that found the target 390 * @target_idx: index of the target that must be activated 391 * @protocol: nfc protocol that will be used for data exchange 392 */ 393 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol) 394 { 395 int rc; 396 struct nfc_target *target; 397 398 pr_debug("dev_name=%s target_idx=%u protocol=%u\n", 399 dev_name(&dev->dev), target_idx, protocol); 400 401 device_lock(&dev->dev); 402 403 if (!device_is_registered(&dev->dev)) { 404 rc = -ENODEV; 405 goto error; 406 } 407 408 if (dev->active_target) { 409 rc = -EBUSY; 410 goto error; 411 } 412 413 target = nfc_find_target(dev, target_idx); 414 if (target == NULL) { 415 rc = -ENOTCONN; 416 goto error; 417 } 418 419 rc = dev->ops->activate_target(dev, target, protocol); 420 if (!rc) { 421 dev->active_target = target; 422 dev->rf_mode = NFC_RF_INITIATOR; 423 424 if (dev->ops->check_presence && !dev->shutting_down) 425 mod_timer(&dev->check_pres_timer, jiffies + 426 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 427 } 428 429 error: 430 device_unlock(&dev->dev); 431 return rc; 432 } 433 434 /** 435 * nfc_deactivate_target - deactivate a nfc target 436 * 437 * @dev: The nfc device that found the target 438 * @target_idx: index of the target that must be deactivated 439 */ 440 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx, u8 mode) 441 { 442 int rc = 0; 443 444 pr_debug("dev_name=%s target_idx=%u\n", 445 dev_name(&dev->dev), target_idx); 446 447 device_lock(&dev->dev); 448 449 if (!device_is_registered(&dev->dev)) { 450 rc = -ENODEV; 451 goto error; 452 } 453 454 if (dev->active_target == NULL) { 455 rc = -ENOTCONN; 456 goto error; 457 } 458 459 if (dev->active_target->idx != target_idx) { 460 rc = -ENOTCONN; 461 goto error; 462 } 463 464 if (dev->ops->check_presence) 465 del_timer_sync(&dev->check_pres_timer); 466 467 dev->ops->deactivate_target(dev, dev->active_target, mode); 468 dev->active_target = NULL; 469 470 error: 471 device_unlock(&dev->dev); 472 return rc; 473 } 474 475 /** 476 * nfc_data_exchange - transceive data 477 * 478 * @dev: The nfc device that found the target 479 * @target_idx: index of the target 480 * @skb: data to be sent 481 * @cb: callback called when the response is received 482 * @cb_context: parameter for the callback function 483 * 484 * The user must wait for the callback before calling this function again. 485 */ 486 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb, 487 data_exchange_cb_t cb, void *cb_context) 488 { 489 int rc; 490 491 pr_debug("dev_name=%s target_idx=%u skb->len=%u\n", 492 dev_name(&dev->dev), target_idx, skb->len); 493 494 device_lock(&dev->dev); 495 496 if (!device_is_registered(&dev->dev)) { 497 rc = -ENODEV; 498 kfree_skb(skb); 499 goto error; 500 } 501 502 if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) { 503 if (dev->active_target->idx != target_idx) { 504 rc = -EADDRNOTAVAIL; 505 kfree_skb(skb); 506 goto error; 507 } 508 509 if (dev->ops->check_presence) 510 del_timer_sync(&dev->check_pres_timer); 511 512 rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb, 513 cb_context); 514 515 if (!rc && dev->ops->check_presence && !dev->shutting_down) 516 mod_timer(&dev->check_pres_timer, jiffies + 517 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 518 } else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) { 519 rc = dev->ops->tm_send(dev, skb); 520 } else { 521 rc = -ENOTCONN; 522 kfree_skb(skb); 523 goto error; 524 } 525 526 527 error: 528 device_unlock(&dev->dev); 529 return rc; 530 } 531 532 struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx) 533 { 534 struct nfc_se *se; 535 536 list_for_each_entry(se, &dev->secure_elements, list) 537 if (se->idx == se_idx) 538 return se; 539 540 return NULL; 541 } 542 EXPORT_SYMBOL(nfc_find_se); 543 544 int nfc_enable_se(struct nfc_dev *dev, u32 se_idx) 545 { 546 struct nfc_se *se; 547 int rc; 548 549 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 550 551 device_lock(&dev->dev); 552 553 if (!device_is_registered(&dev->dev)) { 554 rc = -ENODEV; 555 goto error; 556 } 557 558 if (!dev->dev_up) { 559 rc = -ENODEV; 560 goto error; 561 } 562 563 if (dev->polling) { 564 rc = -EBUSY; 565 goto error; 566 } 567 568 if (!dev->ops->enable_se || !dev->ops->disable_se) { 569 rc = -EOPNOTSUPP; 570 goto error; 571 } 572 573 se = nfc_find_se(dev, se_idx); 574 if (!se) { 575 rc = -EINVAL; 576 goto error; 577 } 578 579 if (se->state == NFC_SE_ENABLED) { 580 rc = -EALREADY; 581 goto error; 582 } 583 584 rc = dev->ops->enable_se(dev, se_idx); 585 if (rc >= 0) 586 se->state = NFC_SE_ENABLED; 587 588 error: 589 device_unlock(&dev->dev); 590 return rc; 591 } 592 593 int nfc_disable_se(struct nfc_dev *dev, u32 se_idx) 594 { 595 struct nfc_se *se; 596 int rc; 597 598 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 599 600 device_lock(&dev->dev); 601 602 if (!device_is_registered(&dev->dev)) { 603 rc = -ENODEV; 604 goto error; 605 } 606 607 if (!dev->dev_up) { 608 rc = -ENODEV; 609 goto error; 610 } 611 612 if (!dev->ops->enable_se || !dev->ops->disable_se) { 613 rc = -EOPNOTSUPP; 614 goto error; 615 } 616 617 se = nfc_find_se(dev, se_idx); 618 if (!se) { 619 rc = -EINVAL; 620 goto error; 621 } 622 623 if (se->state == NFC_SE_DISABLED) { 624 rc = -EALREADY; 625 goto error; 626 } 627 628 rc = dev->ops->disable_se(dev, se_idx); 629 if (rc >= 0) 630 se->state = NFC_SE_DISABLED; 631 632 error: 633 device_unlock(&dev->dev); 634 return rc; 635 } 636 637 int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len) 638 { 639 pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len); 640 641 return nfc_llcp_set_remote_gb(dev, gb, gb_len); 642 } 643 EXPORT_SYMBOL(nfc_set_remote_general_bytes); 644 645 u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len) 646 { 647 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 648 649 return nfc_llcp_general_bytes(dev, gb_len); 650 } 651 EXPORT_SYMBOL(nfc_get_local_general_bytes); 652 653 int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb) 654 { 655 /* Only LLCP target mode for now */ 656 if (dev->dep_link_up == false) { 657 kfree_skb(skb); 658 return -ENOLINK; 659 } 660 661 return nfc_llcp_data_received(dev, skb); 662 } 663 EXPORT_SYMBOL(nfc_tm_data_received); 664 665 int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode, 666 u8 *gb, size_t gb_len) 667 { 668 int rc; 669 670 device_lock(&dev->dev); 671 672 dev->polling = false; 673 674 if (gb != NULL) { 675 rc = nfc_set_remote_general_bytes(dev, gb, gb_len); 676 if (rc < 0) 677 goto out; 678 } 679 680 dev->rf_mode = NFC_RF_TARGET; 681 682 if (protocol == NFC_PROTO_NFC_DEP_MASK) 683 nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET); 684 685 rc = nfc_genl_tm_activated(dev, protocol); 686 687 out: 688 device_unlock(&dev->dev); 689 690 return rc; 691 } 692 EXPORT_SYMBOL(nfc_tm_activated); 693 694 int nfc_tm_deactivated(struct nfc_dev *dev) 695 { 696 dev->dep_link_up = false; 697 dev->rf_mode = NFC_RF_NONE; 698 699 return nfc_genl_tm_deactivated(dev); 700 } 701 EXPORT_SYMBOL(nfc_tm_deactivated); 702 703 /** 704 * nfc_alloc_send_skb - allocate a skb for data exchange responses 705 * 706 * @size: size to allocate 707 */ 708 struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk, 709 unsigned int flags, unsigned int size, 710 unsigned int *err) 711 { 712 struct sk_buff *skb; 713 unsigned int total_size; 714 715 total_size = size + 716 dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE; 717 718 skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err); 719 if (skb) 720 skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE); 721 722 return skb; 723 } 724 725 /** 726 * nfc_alloc_recv_skb - allocate a skb for data exchange responses 727 * 728 * @size: size to allocate 729 * @gfp: gfp flags 730 */ 731 struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp) 732 { 733 struct sk_buff *skb; 734 unsigned int total_size; 735 736 total_size = size + 1; 737 skb = alloc_skb(total_size, gfp); 738 739 if (skb) 740 skb_reserve(skb, 1); 741 742 return skb; 743 } 744 EXPORT_SYMBOL(nfc_alloc_recv_skb); 745 746 /** 747 * nfc_targets_found - inform that targets were found 748 * 749 * @dev: The nfc device that found the targets 750 * @targets: array of nfc targets found 751 * @n_targets: targets array size 752 * 753 * The device driver must call this function when one or many nfc targets 754 * are found. After calling this function, the device driver must stop 755 * polling for targets. 756 * NOTE: This function can be called with targets=NULL and n_targets=0 to 757 * notify a driver error, meaning that the polling operation cannot complete. 758 * IMPORTANT: this function must not be called from an atomic context. 759 * In addition, it must also not be called from a context that would prevent 760 * the NFC Core to call other nfc ops entry point concurrently. 761 */ 762 int nfc_targets_found(struct nfc_dev *dev, 763 struct nfc_target *targets, int n_targets) 764 { 765 int i; 766 767 pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets); 768 769 for (i = 0; i < n_targets; i++) 770 targets[i].idx = dev->target_next_idx++; 771 772 device_lock(&dev->dev); 773 774 if (dev->polling == false) { 775 device_unlock(&dev->dev); 776 return 0; 777 } 778 779 dev->polling = false; 780 781 dev->targets_generation++; 782 783 kfree(dev->targets); 784 dev->targets = NULL; 785 786 if (targets) { 787 dev->targets = kmemdup(targets, 788 n_targets * sizeof(struct nfc_target), 789 GFP_ATOMIC); 790 791 if (!dev->targets) { 792 dev->n_targets = 0; 793 device_unlock(&dev->dev); 794 return -ENOMEM; 795 } 796 } 797 798 dev->n_targets = n_targets; 799 device_unlock(&dev->dev); 800 801 nfc_genl_targets_found(dev); 802 803 return 0; 804 } 805 EXPORT_SYMBOL(nfc_targets_found); 806 807 /** 808 * nfc_target_lost - inform that an activated target went out of field 809 * 810 * @dev: The nfc device that had the activated target in field 811 * @target_idx: the nfc index of the target 812 * 813 * The device driver must call this function when the activated target 814 * goes out of the field. 815 * IMPORTANT: this function must not be called from an atomic context. 816 * In addition, it must also not be called from a context that would prevent 817 * the NFC Core to call other nfc ops entry point concurrently. 818 */ 819 int nfc_target_lost(struct nfc_dev *dev, u32 target_idx) 820 { 821 struct nfc_target *tg; 822 int i; 823 824 pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx); 825 826 device_lock(&dev->dev); 827 828 for (i = 0; i < dev->n_targets; i++) { 829 tg = &dev->targets[i]; 830 if (tg->idx == target_idx) 831 break; 832 } 833 834 if (i == dev->n_targets) { 835 device_unlock(&dev->dev); 836 return -EINVAL; 837 } 838 839 dev->targets_generation++; 840 dev->n_targets--; 841 dev->active_target = NULL; 842 843 if (dev->n_targets) { 844 memcpy(&dev->targets[i], &dev->targets[i + 1], 845 (dev->n_targets - i) * sizeof(struct nfc_target)); 846 } else { 847 kfree(dev->targets); 848 dev->targets = NULL; 849 } 850 851 device_unlock(&dev->dev); 852 853 nfc_genl_target_lost(dev, target_idx); 854 855 return 0; 856 } 857 EXPORT_SYMBOL(nfc_target_lost); 858 859 inline void nfc_driver_failure(struct nfc_dev *dev, int err) 860 { 861 nfc_targets_found(dev, NULL, 0); 862 } 863 EXPORT_SYMBOL(nfc_driver_failure); 864 865 int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type) 866 { 867 struct nfc_se *se; 868 int rc; 869 870 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 871 872 se = nfc_find_se(dev, se_idx); 873 if (se) 874 return -EALREADY; 875 876 se = kzalloc(sizeof(struct nfc_se), GFP_KERNEL); 877 if (!se) 878 return -ENOMEM; 879 880 se->idx = se_idx; 881 se->type = type; 882 se->state = NFC_SE_DISABLED; 883 INIT_LIST_HEAD(&se->list); 884 885 list_add(&se->list, &dev->secure_elements); 886 887 rc = nfc_genl_se_added(dev, se_idx, type); 888 if (rc < 0) { 889 list_del(&se->list); 890 kfree(se); 891 892 return rc; 893 } 894 895 return 0; 896 } 897 EXPORT_SYMBOL(nfc_add_se); 898 899 int nfc_remove_se(struct nfc_dev *dev, u32 se_idx) 900 { 901 struct nfc_se *se, *n; 902 int rc; 903 904 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 905 906 list_for_each_entry_safe(se, n, &dev->secure_elements, list) 907 if (se->idx == se_idx) { 908 rc = nfc_genl_se_removed(dev, se_idx); 909 if (rc < 0) 910 return rc; 911 912 list_del(&se->list); 913 kfree(se); 914 915 return 0; 916 } 917 918 return -EINVAL; 919 } 920 EXPORT_SYMBOL(nfc_remove_se); 921 922 int nfc_se_transaction(struct nfc_dev *dev, u8 se_idx, 923 struct nfc_evt_transaction *evt_transaction) 924 { 925 int rc; 926 927 pr_debug("transaction: %x\n", se_idx); 928 929 device_lock(&dev->dev); 930 931 if (!evt_transaction) { 932 rc = -EPROTO; 933 goto out; 934 } 935 936 rc = nfc_genl_se_transaction(dev, se_idx, evt_transaction); 937 out: 938 device_unlock(&dev->dev); 939 return rc; 940 } 941 EXPORT_SYMBOL(nfc_se_transaction); 942 943 int nfc_se_connectivity(struct nfc_dev *dev, u8 se_idx) 944 { 945 int rc; 946 947 pr_debug("connectivity: %x\n", se_idx); 948 949 device_lock(&dev->dev); 950 rc = nfc_genl_se_connectivity(dev, se_idx); 951 device_unlock(&dev->dev); 952 return rc; 953 } 954 EXPORT_SYMBOL(nfc_se_connectivity); 955 956 static void nfc_release(struct device *d) 957 { 958 struct nfc_dev *dev = to_nfc_dev(d); 959 struct nfc_se *se, *n; 960 961 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 962 963 nfc_genl_data_exit(&dev->genl_data); 964 kfree(dev->targets); 965 966 list_for_each_entry_safe(se, n, &dev->secure_elements, list) { 967 nfc_genl_se_removed(dev, se->idx); 968 list_del(&se->list); 969 kfree(se); 970 } 971 972 ida_simple_remove(&nfc_index_ida, dev->idx); 973 974 kfree(dev); 975 } 976 977 static void nfc_check_pres_work(struct work_struct *work) 978 { 979 struct nfc_dev *dev = container_of(work, struct nfc_dev, 980 check_pres_work); 981 int rc; 982 983 device_lock(&dev->dev); 984 985 if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) { 986 rc = dev->ops->check_presence(dev, dev->active_target); 987 if (rc == -EOPNOTSUPP) 988 goto exit; 989 if (rc) { 990 u32 active_target_idx = dev->active_target->idx; 991 device_unlock(&dev->dev); 992 nfc_target_lost(dev, active_target_idx); 993 return; 994 } 995 996 if (!dev->shutting_down) 997 mod_timer(&dev->check_pres_timer, jiffies + 998 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 999 } 1000 1001 exit: 1002 device_unlock(&dev->dev); 1003 } 1004 1005 static void nfc_check_pres_timeout(struct timer_list *t) 1006 { 1007 struct nfc_dev *dev = from_timer(dev, t, check_pres_timer); 1008 1009 schedule_work(&dev->check_pres_work); 1010 } 1011 1012 struct class nfc_class = { 1013 .name = "nfc", 1014 .dev_release = nfc_release, 1015 }; 1016 EXPORT_SYMBOL(nfc_class); 1017 1018 static int match_idx(struct device *d, const void *data) 1019 { 1020 struct nfc_dev *dev = to_nfc_dev(d); 1021 const unsigned int *idx = data; 1022 1023 return dev->idx == *idx; 1024 } 1025 1026 struct nfc_dev *nfc_get_device(unsigned int idx) 1027 { 1028 struct device *d; 1029 1030 d = class_find_device(&nfc_class, NULL, &idx, match_idx); 1031 if (!d) 1032 return NULL; 1033 1034 return to_nfc_dev(d); 1035 } 1036 1037 /** 1038 * nfc_allocate_device - allocate a new nfc device 1039 * 1040 * @ops: device operations 1041 * @supported_protocols: NFC protocols supported by the device 1042 */ 1043 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops, 1044 u32 supported_protocols, 1045 int tx_headroom, int tx_tailroom) 1046 { 1047 struct nfc_dev *dev; 1048 int rc; 1049 1050 if (!ops->start_poll || !ops->stop_poll || !ops->activate_target || 1051 !ops->deactivate_target || !ops->im_transceive) 1052 return NULL; 1053 1054 if (!supported_protocols) 1055 return NULL; 1056 1057 dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL); 1058 if (!dev) 1059 return NULL; 1060 1061 rc = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL); 1062 if (rc < 0) 1063 goto err_free_dev; 1064 dev->idx = rc; 1065 1066 dev->dev.class = &nfc_class; 1067 dev_set_name(&dev->dev, "nfc%d", dev->idx); 1068 device_initialize(&dev->dev); 1069 1070 dev->ops = ops; 1071 dev->supported_protocols = supported_protocols; 1072 dev->tx_headroom = tx_headroom; 1073 dev->tx_tailroom = tx_tailroom; 1074 INIT_LIST_HEAD(&dev->secure_elements); 1075 1076 nfc_genl_data_init(&dev->genl_data); 1077 1078 dev->rf_mode = NFC_RF_NONE; 1079 1080 /* first generation must not be 0 */ 1081 dev->targets_generation = 1; 1082 1083 if (ops->check_presence) { 1084 timer_setup(&dev->check_pres_timer, nfc_check_pres_timeout, 0); 1085 INIT_WORK(&dev->check_pres_work, nfc_check_pres_work); 1086 } 1087 1088 return dev; 1089 1090 err_free_dev: 1091 kfree(dev); 1092 1093 return NULL; 1094 } 1095 EXPORT_SYMBOL(nfc_allocate_device); 1096 1097 /** 1098 * nfc_register_device - register a nfc device in the nfc subsystem 1099 * 1100 * @dev: The nfc device to register 1101 */ 1102 int nfc_register_device(struct nfc_dev *dev) 1103 { 1104 int rc; 1105 1106 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1107 1108 mutex_lock(&nfc_devlist_mutex); 1109 nfc_devlist_generation++; 1110 rc = device_add(&dev->dev); 1111 mutex_unlock(&nfc_devlist_mutex); 1112 1113 if (rc < 0) 1114 return rc; 1115 1116 rc = nfc_llcp_register_device(dev); 1117 if (rc) 1118 pr_err("Could not register llcp device\n"); 1119 1120 rc = nfc_genl_device_added(dev); 1121 if (rc) 1122 pr_debug("The userspace won't be notified that the device %s was added\n", 1123 dev_name(&dev->dev)); 1124 1125 dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev, 1126 RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev); 1127 if (dev->rfkill) { 1128 if (rfkill_register(dev->rfkill) < 0) { 1129 rfkill_destroy(dev->rfkill); 1130 dev->rfkill = NULL; 1131 } 1132 } 1133 1134 return 0; 1135 } 1136 EXPORT_SYMBOL(nfc_register_device); 1137 1138 /** 1139 * nfc_unregister_device - unregister a nfc device in the nfc subsystem 1140 * 1141 * @dev: The nfc device to unregister 1142 */ 1143 void nfc_unregister_device(struct nfc_dev *dev) 1144 { 1145 int rc; 1146 1147 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1148 1149 if (dev->rfkill) { 1150 rfkill_unregister(dev->rfkill); 1151 rfkill_destroy(dev->rfkill); 1152 } 1153 1154 if (dev->ops->check_presence) { 1155 device_lock(&dev->dev); 1156 dev->shutting_down = true; 1157 device_unlock(&dev->dev); 1158 del_timer_sync(&dev->check_pres_timer); 1159 cancel_work_sync(&dev->check_pres_work); 1160 } 1161 1162 rc = nfc_genl_device_removed(dev); 1163 if (rc) 1164 pr_debug("The userspace won't be notified that the device %s " 1165 "was removed\n", dev_name(&dev->dev)); 1166 1167 nfc_llcp_unregister_device(dev); 1168 1169 mutex_lock(&nfc_devlist_mutex); 1170 nfc_devlist_generation++; 1171 device_del(&dev->dev); 1172 mutex_unlock(&nfc_devlist_mutex); 1173 } 1174 EXPORT_SYMBOL(nfc_unregister_device); 1175 1176 static int __init nfc_init(void) 1177 { 1178 int rc; 1179 1180 pr_info("NFC Core ver %s\n", VERSION); 1181 1182 rc = class_register(&nfc_class); 1183 if (rc) 1184 return rc; 1185 1186 rc = nfc_genl_init(); 1187 if (rc) 1188 goto err_genl; 1189 1190 /* the first generation must not be 0 */ 1191 nfc_devlist_generation = 1; 1192 1193 rc = rawsock_init(); 1194 if (rc) 1195 goto err_rawsock; 1196 1197 rc = nfc_llcp_init(); 1198 if (rc) 1199 goto err_llcp_sock; 1200 1201 rc = af_nfc_init(); 1202 if (rc) 1203 goto err_af_nfc; 1204 1205 return 0; 1206 1207 err_af_nfc: 1208 nfc_llcp_exit(); 1209 err_llcp_sock: 1210 rawsock_exit(); 1211 err_rawsock: 1212 nfc_genl_exit(); 1213 err_genl: 1214 class_unregister(&nfc_class); 1215 return rc; 1216 } 1217 1218 static void __exit nfc_exit(void) 1219 { 1220 af_nfc_exit(); 1221 nfc_llcp_exit(); 1222 rawsock_exit(); 1223 nfc_genl_exit(); 1224 class_unregister(&nfc_class); 1225 } 1226 1227 subsys_initcall(nfc_init); 1228 module_exit(nfc_exit); 1229 1230 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>"); 1231 MODULE_DESCRIPTION("NFC Core ver " VERSION); 1232 MODULE_VERSION(VERSION); 1233 MODULE_LICENSE("GPL"); 1234 MODULE_ALIAS_NETPROTO(PF_NFC); 1235 MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME); 1236