1 /* 2 * Copyright (C) 2011 Instituto Nokia de Tecnologia 3 * 4 * Authors: 5 * Lauro Ramos Venancio <lauro.venancio@openbossa.org> 6 * Aloisio Almeida Jr <aloisio.almeida@openbossa.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the 20 * Free Software Foundation, Inc., 21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 22 */ 23 24 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ 25 26 #include <linux/init.h> 27 #include <linux/kernel.h> 28 #include <linux/module.h> 29 #include <linux/slab.h> 30 #include <linux/nfc.h> 31 32 #include <net/genetlink.h> 33 34 #include "nfc.h" 35 36 #define VERSION "0.1" 37 38 #define NFC_CHECK_PRES_FREQ_MS 2000 39 40 int nfc_devlist_generation; 41 DEFINE_MUTEX(nfc_devlist_mutex); 42 43 /* NFC device ID bitmap */ 44 static DEFINE_IDA(nfc_index_ida); 45 46 /** 47 * nfc_dev_up - turn on the NFC device 48 * 49 * @dev: The nfc device to be turned on 50 * 51 * The device remains up until the nfc_dev_down function is called. 52 */ 53 int nfc_dev_up(struct nfc_dev *dev) 54 { 55 int rc = 0; 56 57 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 58 59 device_lock(&dev->dev); 60 61 if (!device_is_registered(&dev->dev)) { 62 rc = -ENODEV; 63 goto error; 64 } 65 66 if (dev->dev_up) { 67 rc = -EALREADY; 68 goto error; 69 } 70 71 if (dev->ops->dev_up) 72 rc = dev->ops->dev_up(dev); 73 74 if (!rc) 75 dev->dev_up = true; 76 77 error: 78 device_unlock(&dev->dev); 79 return rc; 80 } 81 82 /** 83 * nfc_dev_down - turn off the NFC device 84 * 85 * @dev: The nfc device to be turned off 86 */ 87 int nfc_dev_down(struct nfc_dev *dev) 88 { 89 int rc = 0; 90 91 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 92 93 device_lock(&dev->dev); 94 95 if (!device_is_registered(&dev->dev)) { 96 rc = -ENODEV; 97 goto error; 98 } 99 100 if (!dev->dev_up) { 101 rc = -EALREADY; 102 goto error; 103 } 104 105 if (dev->polling || dev->active_target) { 106 rc = -EBUSY; 107 goto error; 108 } 109 110 if (dev->ops->dev_down) 111 dev->ops->dev_down(dev); 112 113 dev->dev_up = false; 114 115 error: 116 device_unlock(&dev->dev); 117 return rc; 118 } 119 120 /** 121 * nfc_start_poll - start polling for nfc targets 122 * 123 * @dev: The nfc device that must start polling 124 * @protocols: bitset of nfc protocols that must be used for polling 125 * 126 * The device remains polling for targets until a target is found or 127 * the nfc_stop_poll function is called. 128 */ 129 int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols) 130 { 131 int rc; 132 133 pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n", 134 dev_name(&dev->dev), im_protocols, tm_protocols); 135 136 if (!im_protocols && !tm_protocols) 137 return -EINVAL; 138 139 device_lock(&dev->dev); 140 141 if (!device_is_registered(&dev->dev)) { 142 rc = -ENODEV; 143 goto error; 144 } 145 146 if (dev->polling) { 147 rc = -EBUSY; 148 goto error; 149 } 150 151 rc = dev->ops->start_poll(dev, im_protocols, tm_protocols); 152 if (!rc) { 153 dev->polling = true; 154 dev->rf_mode = NFC_RF_NONE; 155 } 156 157 error: 158 device_unlock(&dev->dev); 159 return rc; 160 } 161 162 /** 163 * nfc_stop_poll - stop polling for nfc targets 164 * 165 * @dev: The nfc device that must stop polling 166 */ 167 int nfc_stop_poll(struct nfc_dev *dev) 168 { 169 int rc = 0; 170 171 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 172 173 device_lock(&dev->dev); 174 175 if (!device_is_registered(&dev->dev)) { 176 rc = -ENODEV; 177 goto error; 178 } 179 180 if (!dev->polling) { 181 rc = -EINVAL; 182 goto error; 183 } 184 185 dev->ops->stop_poll(dev); 186 dev->polling = false; 187 dev->rf_mode = NFC_RF_NONE; 188 189 error: 190 device_unlock(&dev->dev); 191 return rc; 192 } 193 194 static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx) 195 { 196 int i; 197 198 if (dev->n_targets == 0) 199 return NULL; 200 201 for (i = 0; i < dev->n_targets; i++) { 202 if (dev->targets[i].idx == target_idx) 203 return &dev->targets[i]; 204 } 205 206 return NULL; 207 } 208 209 int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode) 210 { 211 int rc = 0; 212 u8 *gb; 213 size_t gb_len; 214 struct nfc_target *target; 215 216 pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode); 217 218 if (!dev->ops->dep_link_up) 219 return -EOPNOTSUPP; 220 221 device_lock(&dev->dev); 222 223 if (!device_is_registered(&dev->dev)) { 224 rc = -ENODEV; 225 goto error; 226 } 227 228 if (dev->dep_link_up == true) { 229 rc = -EALREADY; 230 goto error; 231 } 232 233 gb = nfc_llcp_general_bytes(dev, &gb_len); 234 if (gb_len > NFC_MAX_GT_LEN) { 235 rc = -EINVAL; 236 goto error; 237 } 238 239 target = nfc_find_target(dev, target_index); 240 if (target == NULL) { 241 rc = -ENOTCONN; 242 goto error; 243 } 244 245 rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len); 246 if (!rc) { 247 dev->active_target = target; 248 dev->rf_mode = NFC_RF_INITIATOR; 249 } 250 251 error: 252 device_unlock(&dev->dev); 253 return rc; 254 } 255 256 int nfc_dep_link_down(struct nfc_dev *dev) 257 { 258 int rc = 0; 259 260 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 261 262 if (!dev->ops->dep_link_down) 263 return -EOPNOTSUPP; 264 265 device_lock(&dev->dev); 266 267 if (!device_is_registered(&dev->dev)) { 268 rc = -ENODEV; 269 goto error; 270 } 271 272 if (dev->dep_link_up == false) { 273 rc = -EALREADY; 274 goto error; 275 } 276 277 rc = dev->ops->dep_link_down(dev); 278 if (!rc) { 279 dev->dep_link_up = false; 280 dev->active_target = NULL; 281 dev->rf_mode = NFC_RF_NONE; 282 nfc_llcp_mac_is_down(dev); 283 nfc_genl_dep_link_down_event(dev); 284 } 285 286 error: 287 device_unlock(&dev->dev); 288 289 return rc; 290 } 291 292 int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx, 293 u8 comm_mode, u8 rf_mode) 294 { 295 dev->dep_link_up = true; 296 297 nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode); 298 299 return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode); 300 } 301 EXPORT_SYMBOL(nfc_dep_link_is_up); 302 303 /** 304 * nfc_activate_target - prepare the target for data exchange 305 * 306 * @dev: The nfc device that found the target 307 * @target_idx: index of the target that must be activated 308 * @protocol: nfc protocol that will be used for data exchange 309 */ 310 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol) 311 { 312 int rc; 313 struct nfc_target *target; 314 315 pr_debug("dev_name=%s target_idx=%u protocol=%u\n", 316 dev_name(&dev->dev), target_idx, protocol); 317 318 device_lock(&dev->dev); 319 320 if (!device_is_registered(&dev->dev)) { 321 rc = -ENODEV; 322 goto error; 323 } 324 325 if (dev->active_target) { 326 rc = -EBUSY; 327 goto error; 328 } 329 330 target = nfc_find_target(dev, target_idx); 331 if (target == NULL) { 332 rc = -ENOTCONN; 333 goto error; 334 } 335 336 rc = dev->ops->activate_target(dev, target, protocol); 337 if (!rc) { 338 dev->active_target = target; 339 dev->rf_mode = NFC_RF_INITIATOR; 340 341 if (dev->ops->check_presence) 342 mod_timer(&dev->check_pres_timer, jiffies + 343 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 344 } 345 346 error: 347 device_unlock(&dev->dev); 348 return rc; 349 } 350 351 /** 352 * nfc_deactivate_target - deactivate a nfc target 353 * 354 * @dev: The nfc device that found the target 355 * @target_idx: index of the target that must be deactivated 356 */ 357 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx) 358 { 359 int rc = 0; 360 361 pr_debug("dev_name=%s target_idx=%u\n", 362 dev_name(&dev->dev), target_idx); 363 364 device_lock(&dev->dev); 365 366 if (!device_is_registered(&dev->dev)) { 367 rc = -ENODEV; 368 goto error; 369 } 370 371 if (dev->active_target == NULL) { 372 rc = -ENOTCONN; 373 goto error; 374 } 375 376 if (dev->active_target->idx != target_idx) { 377 rc = -ENOTCONN; 378 goto error; 379 } 380 381 if (dev->ops->check_presence) 382 del_timer_sync(&dev->check_pres_timer); 383 384 dev->ops->deactivate_target(dev, dev->active_target); 385 dev->active_target = NULL; 386 387 error: 388 device_unlock(&dev->dev); 389 return rc; 390 } 391 392 /** 393 * nfc_data_exchange - transceive data 394 * 395 * @dev: The nfc device that found the target 396 * @target_idx: index of the target 397 * @skb: data to be sent 398 * @cb: callback called when the response is received 399 * @cb_context: parameter for the callback function 400 * 401 * The user must wait for the callback before calling this function again. 402 */ 403 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb, 404 data_exchange_cb_t cb, void *cb_context) 405 { 406 int rc; 407 408 pr_debug("dev_name=%s target_idx=%u skb->len=%u\n", 409 dev_name(&dev->dev), target_idx, skb->len); 410 411 device_lock(&dev->dev); 412 413 if (!device_is_registered(&dev->dev)) { 414 rc = -ENODEV; 415 kfree_skb(skb); 416 goto error; 417 } 418 419 if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) { 420 if (dev->active_target->idx != target_idx) { 421 rc = -EADDRNOTAVAIL; 422 kfree_skb(skb); 423 goto error; 424 } 425 426 if (dev->ops->check_presence) 427 del_timer_sync(&dev->check_pres_timer); 428 429 rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb, 430 cb_context); 431 432 if (!rc && dev->ops->check_presence) 433 mod_timer(&dev->check_pres_timer, jiffies + 434 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 435 } else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) { 436 rc = dev->ops->tm_send(dev, skb); 437 } else { 438 rc = -ENOTCONN; 439 kfree_skb(skb); 440 goto error; 441 } 442 443 444 error: 445 device_unlock(&dev->dev); 446 return rc; 447 } 448 449 int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len) 450 { 451 pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len); 452 453 if (gb_len > NFC_MAX_GT_LEN) 454 return -EINVAL; 455 456 return nfc_llcp_set_remote_gb(dev, gb, gb_len); 457 } 458 EXPORT_SYMBOL(nfc_set_remote_general_bytes); 459 460 u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len) 461 { 462 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 463 464 return nfc_llcp_general_bytes(dev, gb_len); 465 } 466 EXPORT_SYMBOL(nfc_get_local_general_bytes); 467 468 int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb) 469 { 470 /* Only LLCP target mode for now */ 471 if (dev->dep_link_up == false) { 472 kfree_skb(skb); 473 return -ENOLINK; 474 } 475 476 return nfc_llcp_data_received(dev, skb); 477 } 478 EXPORT_SYMBOL(nfc_tm_data_received); 479 480 int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode, 481 u8 *gb, size_t gb_len) 482 { 483 int rc; 484 485 device_lock(&dev->dev); 486 487 dev->polling = false; 488 489 if (gb != NULL) { 490 rc = nfc_set_remote_general_bytes(dev, gb, gb_len); 491 if (rc < 0) 492 goto out; 493 } 494 495 dev->rf_mode = NFC_RF_TARGET; 496 497 if (protocol == NFC_PROTO_NFC_DEP_MASK) 498 nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET); 499 500 rc = nfc_genl_tm_activated(dev, protocol); 501 502 out: 503 device_unlock(&dev->dev); 504 505 return rc; 506 } 507 EXPORT_SYMBOL(nfc_tm_activated); 508 509 int nfc_tm_deactivated(struct nfc_dev *dev) 510 { 511 dev->dep_link_up = false; 512 dev->rf_mode = NFC_RF_NONE; 513 514 return nfc_genl_tm_deactivated(dev); 515 } 516 EXPORT_SYMBOL(nfc_tm_deactivated); 517 518 /** 519 * nfc_alloc_send_skb - allocate a skb for data exchange responses 520 * 521 * @size: size to allocate 522 * @gfp: gfp flags 523 */ 524 struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk, 525 unsigned int flags, unsigned int size, 526 unsigned int *err) 527 { 528 struct sk_buff *skb; 529 unsigned int total_size; 530 531 total_size = size + 532 dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE; 533 534 skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err); 535 if (skb) 536 skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE); 537 538 return skb; 539 } 540 541 /** 542 * nfc_alloc_recv_skb - allocate a skb for data exchange responses 543 * 544 * @size: size to allocate 545 * @gfp: gfp flags 546 */ 547 struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp) 548 { 549 struct sk_buff *skb; 550 unsigned int total_size; 551 552 total_size = size + 1; 553 skb = alloc_skb(total_size, gfp); 554 555 if (skb) 556 skb_reserve(skb, 1); 557 558 return skb; 559 } 560 EXPORT_SYMBOL(nfc_alloc_recv_skb); 561 562 /** 563 * nfc_targets_found - inform that targets were found 564 * 565 * @dev: The nfc device that found the targets 566 * @targets: array of nfc targets found 567 * @ntargets: targets array size 568 * 569 * The device driver must call this function when one or many nfc targets 570 * are found. After calling this function, the device driver must stop 571 * polling for targets. 572 * NOTE: This function can be called with targets=NULL and n_targets=0 to 573 * notify a driver error, meaning that the polling operation cannot complete. 574 * IMPORTANT: this function must not be called from an atomic context. 575 * In addition, it must also not be called from a context that would prevent 576 * the NFC Core to call other nfc ops entry point concurrently. 577 */ 578 int nfc_targets_found(struct nfc_dev *dev, 579 struct nfc_target *targets, int n_targets) 580 { 581 int i; 582 583 pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets); 584 585 for (i = 0; i < n_targets; i++) 586 targets[i].idx = dev->target_next_idx++; 587 588 device_lock(&dev->dev); 589 590 if (dev->polling == false) { 591 device_unlock(&dev->dev); 592 return 0; 593 } 594 595 dev->polling = false; 596 597 dev->targets_generation++; 598 599 kfree(dev->targets); 600 dev->targets = NULL; 601 602 if (targets) { 603 dev->targets = kmemdup(targets, 604 n_targets * sizeof(struct nfc_target), 605 GFP_ATOMIC); 606 607 if (!dev->targets) { 608 dev->n_targets = 0; 609 device_unlock(&dev->dev); 610 return -ENOMEM; 611 } 612 } 613 614 dev->n_targets = n_targets; 615 device_unlock(&dev->dev); 616 617 nfc_genl_targets_found(dev); 618 619 return 0; 620 } 621 EXPORT_SYMBOL(nfc_targets_found); 622 623 /** 624 * nfc_target_lost - inform that an activated target went out of field 625 * 626 * @dev: The nfc device that had the activated target in field 627 * @target_idx: the nfc index of the target 628 * 629 * The device driver must call this function when the activated target 630 * goes out of the field. 631 * IMPORTANT: this function must not be called from an atomic context. 632 * In addition, it must also not be called from a context that would prevent 633 * the NFC Core to call other nfc ops entry point concurrently. 634 */ 635 int nfc_target_lost(struct nfc_dev *dev, u32 target_idx) 636 { 637 struct nfc_target *tg; 638 int i; 639 640 pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx); 641 642 device_lock(&dev->dev); 643 644 for (i = 0; i < dev->n_targets; i++) { 645 tg = &dev->targets[i]; 646 if (tg->idx == target_idx) 647 break; 648 } 649 650 if (i == dev->n_targets) { 651 device_unlock(&dev->dev); 652 return -EINVAL; 653 } 654 655 dev->targets_generation++; 656 dev->n_targets--; 657 dev->active_target = NULL; 658 659 if (dev->n_targets) { 660 memcpy(&dev->targets[i], &dev->targets[i + 1], 661 (dev->n_targets - i) * sizeof(struct nfc_target)); 662 } else { 663 kfree(dev->targets); 664 dev->targets = NULL; 665 } 666 667 device_unlock(&dev->dev); 668 669 nfc_genl_target_lost(dev, target_idx); 670 671 return 0; 672 } 673 EXPORT_SYMBOL(nfc_target_lost); 674 675 inline void nfc_driver_failure(struct nfc_dev *dev, int err) 676 { 677 nfc_targets_found(dev, NULL, 0); 678 } 679 EXPORT_SYMBOL(nfc_driver_failure); 680 681 static void nfc_release(struct device *d) 682 { 683 struct nfc_dev *dev = to_nfc_dev(d); 684 685 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 686 687 if (dev->ops->check_presence) { 688 del_timer_sync(&dev->check_pres_timer); 689 cancel_work_sync(&dev->check_pres_work); 690 } 691 692 nfc_genl_data_exit(&dev->genl_data); 693 kfree(dev->targets); 694 kfree(dev); 695 } 696 697 static void nfc_check_pres_work(struct work_struct *work) 698 { 699 struct nfc_dev *dev = container_of(work, struct nfc_dev, 700 check_pres_work); 701 int rc; 702 703 device_lock(&dev->dev); 704 705 if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) { 706 rc = dev->ops->check_presence(dev, dev->active_target); 707 if (rc == -EOPNOTSUPP) 708 goto exit; 709 if (!rc) { 710 mod_timer(&dev->check_pres_timer, jiffies + 711 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 712 } else { 713 u32 active_target_idx = dev->active_target->idx; 714 device_unlock(&dev->dev); 715 nfc_target_lost(dev, active_target_idx); 716 return; 717 } 718 } 719 720 exit: 721 device_unlock(&dev->dev); 722 } 723 724 static void nfc_check_pres_timeout(unsigned long data) 725 { 726 struct nfc_dev *dev = (struct nfc_dev *)data; 727 728 schedule_work(&dev->check_pres_work); 729 } 730 731 struct class nfc_class = { 732 .name = "nfc", 733 .dev_release = nfc_release, 734 }; 735 EXPORT_SYMBOL(nfc_class); 736 737 static int match_idx(struct device *d, void *data) 738 { 739 struct nfc_dev *dev = to_nfc_dev(d); 740 unsigned int *idx = data; 741 742 return dev->idx == *idx; 743 } 744 745 struct nfc_dev *nfc_get_device(unsigned int idx) 746 { 747 struct device *d; 748 749 d = class_find_device(&nfc_class, NULL, &idx, match_idx); 750 if (!d) 751 return NULL; 752 753 return to_nfc_dev(d); 754 } 755 756 /** 757 * nfc_allocate_device - allocate a new nfc device 758 * 759 * @ops: device operations 760 * @supported_protocols: NFC protocols supported by the device 761 */ 762 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops, 763 u32 supported_protocols, 764 int tx_headroom, int tx_tailroom) 765 { 766 struct nfc_dev *dev; 767 768 if (!ops->start_poll || !ops->stop_poll || !ops->activate_target || 769 !ops->deactivate_target || !ops->im_transceive) 770 return NULL; 771 772 if (!supported_protocols) 773 return NULL; 774 775 dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL); 776 if (!dev) 777 return NULL; 778 779 dev->ops = ops; 780 dev->supported_protocols = supported_protocols; 781 dev->tx_headroom = tx_headroom; 782 dev->tx_tailroom = tx_tailroom; 783 784 nfc_genl_data_init(&dev->genl_data); 785 786 dev->rf_mode = NFC_RF_NONE; 787 788 /* first generation must not be 0 */ 789 dev->targets_generation = 1; 790 791 if (ops->check_presence) { 792 init_timer(&dev->check_pres_timer); 793 dev->check_pres_timer.data = (unsigned long)dev; 794 dev->check_pres_timer.function = nfc_check_pres_timeout; 795 796 INIT_WORK(&dev->check_pres_work, nfc_check_pres_work); 797 } 798 799 return dev; 800 } 801 EXPORT_SYMBOL(nfc_allocate_device); 802 803 /** 804 * nfc_register_device - register a nfc device in the nfc subsystem 805 * 806 * @dev: The nfc device to register 807 */ 808 int nfc_register_device(struct nfc_dev *dev) 809 { 810 int rc; 811 812 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 813 814 dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL); 815 if (dev->idx < 0) 816 return dev->idx; 817 818 dev->dev.class = &nfc_class; 819 dev_set_name(&dev->dev, "nfc%d", dev->idx); 820 device_initialize(&dev->dev); 821 822 mutex_lock(&nfc_devlist_mutex); 823 nfc_devlist_generation++; 824 rc = device_add(&dev->dev); 825 mutex_unlock(&nfc_devlist_mutex); 826 827 if (rc < 0) 828 return rc; 829 830 rc = nfc_llcp_register_device(dev); 831 if (rc) 832 pr_err("Could not register llcp device\n"); 833 834 rc = nfc_genl_device_added(dev); 835 if (rc) 836 pr_debug("The userspace won't be notified that the device %s was added\n", 837 dev_name(&dev->dev)); 838 839 return 0; 840 } 841 EXPORT_SYMBOL(nfc_register_device); 842 843 /** 844 * nfc_unregister_device - unregister a nfc device in the nfc subsystem 845 * 846 * @dev: The nfc device to unregister 847 */ 848 void nfc_unregister_device(struct nfc_dev *dev) 849 { 850 int rc, id; 851 852 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 853 854 id = dev->idx; 855 856 mutex_lock(&nfc_devlist_mutex); 857 nfc_devlist_generation++; 858 859 /* lock to avoid unregistering a device while an operation 860 is in progress */ 861 device_lock(&dev->dev); 862 device_del(&dev->dev); 863 device_unlock(&dev->dev); 864 865 mutex_unlock(&nfc_devlist_mutex); 866 867 nfc_llcp_unregister_device(dev); 868 869 rc = nfc_genl_device_removed(dev); 870 if (rc) 871 pr_debug("The userspace won't be notified that the device %s was removed\n", 872 dev_name(&dev->dev)); 873 874 ida_simple_remove(&nfc_index_ida, id); 875 876 } 877 EXPORT_SYMBOL(nfc_unregister_device); 878 879 static int __init nfc_init(void) 880 { 881 int rc; 882 883 pr_info("NFC Core ver %s\n", VERSION); 884 885 rc = class_register(&nfc_class); 886 if (rc) 887 return rc; 888 889 rc = nfc_genl_init(); 890 if (rc) 891 goto err_genl; 892 893 /* the first generation must not be 0 */ 894 nfc_devlist_generation = 1; 895 896 rc = rawsock_init(); 897 if (rc) 898 goto err_rawsock; 899 900 rc = nfc_llcp_init(); 901 if (rc) 902 goto err_llcp_sock; 903 904 rc = af_nfc_init(); 905 if (rc) 906 goto err_af_nfc; 907 908 return 0; 909 910 err_af_nfc: 911 nfc_llcp_exit(); 912 err_llcp_sock: 913 rawsock_exit(); 914 err_rawsock: 915 nfc_genl_exit(); 916 err_genl: 917 class_unregister(&nfc_class); 918 return rc; 919 } 920 921 static void __exit nfc_exit(void) 922 { 923 af_nfc_exit(); 924 nfc_llcp_exit(); 925 rawsock_exit(); 926 nfc_genl_exit(); 927 class_unregister(&nfc_class); 928 } 929 930 subsys_initcall(nfc_init); 931 module_exit(nfc_exit); 932 933 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>"); 934 MODULE_DESCRIPTION("NFC Core ver " VERSION); 935 MODULE_VERSION(VERSION); 936 MODULE_LICENSE("GPL"); 937 MODULE_ALIAS_NETPROTO(PF_NFC); 938 MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME); 939