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