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