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