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, u8 mode) 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, mode); 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 struct nfc_se *se; 559 int rc; 560 561 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 562 563 device_lock(&dev->dev); 564 565 if (!device_is_registered(&dev->dev)) { 566 rc = -ENODEV; 567 goto error; 568 } 569 570 if (!dev->dev_up) { 571 rc = -ENODEV; 572 goto error; 573 } 574 575 if (dev->polling) { 576 rc = -EBUSY; 577 goto error; 578 } 579 580 if (!dev->ops->enable_se || !dev->ops->disable_se) { 581 rc = -EOPNOTSUPP; 582 goto error; 583 } 584 585 se = nfc_find_se(dev, se_idx); 586 if (!se) { 587 rc = -EINVAL; 588 goto error; 589 } 590 591 if (se->state == NFC_SE_ENABLED) { 592 rc = -EALREADY; 593 goto error; 594 } 595 596 rc = dev->ops->enable_se(dev, se_idx); 597 if (rc >= 0) 598 se->state = NFC_SE_ENABLED; 599 600error: 601 device_unlock(&dev->dev); 602 return rc; 603} 604 605int nfc_disable_se(struct nfc_dev *dev, u32 se_idx) 606{ 607 struct nfc_se *se; 608 int rc; 609 610 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 611 612 device_lock(&dev->dev); 613 614 if (!device_is_registered(&dev->dev)) { 615 rc = -ENODEV; 616 goto error; 617 } 618 619 if (!dev->dev_up) { 620 rc = -ENODEV; 621 goto error; 622 } 623 624 if (!dev->ops->enable_se || !dev->ops->disable_se) { 625 rc = -EOPNOTSUPP; 626 goto error; 627 } 628 629 se = nfc_find_se(dev, se_idx); 630 if (!se) { 631 rc = -EINVAL; 632 goto error; 633 } 634 635 if (se->state == NFC_SE_DISABLED) { 636 rc = -EALREADY; 637 goto error; 638 } 639 640 rc = dev->ops->disable_se(dev, se_idx); 641 if (rc >= 0) 642 se->state = NFC_SE_DISABLED; 643 644error: 645 device_unlock(&dev->dev); 646 return rc; 647} 648 649int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len) 650{ 651 pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len); 652 653 return nfc_llcp_set_remote_gb(dev, gb, gb_len); 654} 655EXPORT_SYMBOL(nfc_set_remote_general_bytes); 656 657u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len) 658{ 659 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 660 661 return nfc_llcp_general_bytes(dev, gb_len); 662} 663EXPORT_SYMBOL(nfc_get_local_general_bytes); 664 665int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb) 666{ 667 /* Only LLCP target mode for now */ 668 if (dev->dep_link_up == false) { 669 kfree_skb(skb); 670 return -ENOLINK; 671 } 672 673 return nfc_llcp_data_received(dev, skb); 674} 675EXPORT_SYMBOL(nfc_tm_data_received); 676 677int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode, 678 u8 *gb, size_t gb_len) 679{ 680 int rc; 681 682 device_lock(&dev->dev); 683 684 dev->polling = false; 685 686 if (gb != NULL) { 687 rc = nfc_set_remote_general_bytes(dev, gb, gb_len); 688 if (rc < 0) 689 goto out; 690 } 691 692 dev->rf_mode = NFC_RF_TARGET; 693 694 if (protocol == NFC_PROTO_NFC_DEP_MASK) 695 nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET); 696 697 rc = nfc_genl_tm_activated(dev, protocol); 698 699out: 700 device_unlock(&dev->dev); 701 702 return rc; 703} 704EXPORT_SYMBOL(nfc_tm_activated); 705 706int nfc_tm_deactivated(struct nfc_dev *dev) 707{ 708 dev->dep_link_up = false; 709 dev->rf_mode = NFC_RF_NONE; 710 711 return nfc_genl_tm_deactivated(dev); 712} 713EXPORT_SYMBOL(nfc_tm_deactivated); 714 715/** 716 * nfc_alloc_send_skb - allocate a skb for data exchange responses 717 * 718 * @size: size to allocate 719 * @gfp: gfp flags 720 */ 721struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk, 722 unsigned int flags, unsigned int size, 723 unsigned int *err) 724{ 725 struct sk_buff *skb; 726 unsigned int total_size; 727 728 total_size = size + 729 dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE; 730 731 skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err); 732 if (skb) 733 skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE); 734 735 return skb; 736} 737 738/** 739 * nfc_alloc_recv_skb - allocate a skb for data exchange responses 740 * 741 * @size: size to allocate 742 * @gfp: gfp flags 743 */ 744struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp) 745{ 746 struct sk_buff *skb; 747 unsigned int total_size; 748 749 total_size = size + 1; 750 skb = alloc_skb(total_size, gfp); 751 752 if (skb) 753 skb_reserve(skb, 1); 754 755 return skb; 756} 757EXPORT_SYMBOL(nfc_alloc_recv_skb); 758 759/** 760 * nfc_targets_found - inform that targets were found 761 * 762 * @dev: The nfc device that found the targets 763 * @targets: array of nfc targets found 764 * @ntargets: targets array size 765 * 766 * The device driver must call this function when one or many nfc targets 767 * are found. After calling this function, the device driver must stop 768 * polling for targets. 769 * NOTE: This function can be called with targets=NULL and n_targets=0 to 770 * notify a driver error, meaning that the polling operation cannot complete. 771 * IMPORTANT: this function must not be called from an atomic context. 772 * In addition, it must also not be called from a context that would prevent 773 * the NFC Core to call other nfc ops entry point concurrently. 774 */ 775int nfc_targets_found(struct nfc_dev *dev, 776 struct nfc_target *targets, int n_targets) 777{ 778 int i; 779 780 pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets); 781 782 for (i = 0; i < n_targets; i++) 783 targets[i].idx = dev->target_next_idx++; 784 785 device_lock(&dev->dev); 786 787 if (dev->polling == false) { 788 device_unlock(&dev->dev); 789 return 0; 790 } 791 792 dev->polling = false; 793 794 dev->targets_generation++; 795 796 kfree(dev->targets); 797 dev->targets = NULL; 798 799 if (targets) { 800 dev->targets = kmemdup(targets, 801 n_targets * sizeof(struct nfc_target), 802 GFP_ATOMIC); 803 804 if (!dev->targets) { 805 dev->n_targets = 0; 806 device_unlock(&dev->dev); 807 return -ENOMEM; 808 } 809 } 810 811 dev->n_targets = n_targets; 812 device_unlock(&dev->dev); 813 814 nfc_genl_targets_found(dev); 815 816 return 0; 817} 818EXPORT_SYMBOL(nfc_targets_found); 819 820/** 821 * nfc_target_lost - inform that an activated target went out of field 822 * 823 * @dev: The nfc device that had the activated target in field 824 * @target_idx: the nfc index of the target 825 * 826 * The device driver must call this function when the activated target 827 * goes out of the field. 828 * IMPORTANT: this function must not be called from an atomic context. 829 * In addition, it must also not be called from a context that would prevent 830 * the NFC Core to call other nfc ops entry point concurrently. 831 */ 832int nfc_target_lost(struct nfc_dev *dev, u32 target_idx) 833{ 834 struct nfc_target *tg; 835 int i; 836 837 pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx); 838 839 device_lock(&dev->dev); 840 841 for (i = 0; i < dev->n_targets; i++) { 842 tg = &dev->targets[i]; 843 if (tg->idx == target_idx) 844 break; 845 } 846 847 if (i == dev->n_targets) { 848 device_unlock(&dev->dev); 849 return -EINVAL; 850 } 851 852 dev->targets_generation++; 853 dev->n_targets--; 854 dev->active_target = NULL; 855 856 if (dev->n_targets) { 857 memcpy(&dev->targets[i], &dev->targets[i + 1], 858 (dev->n_targets - i) * sizeof(struct nfc_target)); 859 } else { 860 kfree(dev->targets); 861 dev->targets = NULL; 862 } 863 864 device_unlock(&dev->dev); 865 866 nfc_genl_target_lost(dev, target_idx); 867 868 return 0; 869} 870EXPORT_SYMBOL(nfc_target_lost); 871 872inline void nfc_driver_failure(struct nfc_dev *dev, int err) 873{ 874 nfc_targets_found(dev, NULL, 0); 875} 876EXPORT_SYMBOL(nfc_driver_failure); 877 878int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type) 879{ 880 struct nfc_se *se; 881 int rc; 882 883 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 884 885 se = nfc_find_se(dev, se_idx); 886 if (se) 887 return -EALREADY; 888 889 se = kzalloc(sizeof(struct nfc_se), GFP_KERNEL); 890 if (!se) 891 return -ENOMEM; 892 893 se->idx = se_idx; 894 se->type = type; 895 se->state = NFC_SE_DISABLED; 896 INIT_LIST_HEAD(&se->list); 897 898 list_add(&se->list, &dev->secure_elements); 899 900 rc = nfc_genl_se_added(dev, se_idx, type); 901 if (rc < 0) { 902 list_del(&se->list); 903 kfree(se); 904 905 return rc; 906 } 907 908 return 0; 909} 910EXPORT_SYMBOL(nfc_add_se); 911 912int nfc_remove_se(struct nfc_dev *dev, u32 se_idx) 913{ 914 struct nfc_se *se, *n; 915 int rc; 916 917 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 918 919 list_for_each_entry_safe(se, n, &dev->secure_elements, list) 920 if (se->idx == se_idx) { 921 rc = nfc_genl_se_removed(dev, se_idx); 922 if (rc < 0) 923 return rc; 924 925 list_del(&se->list); 926 kfree(se); 927 928 return 0; 929 } 930 931 return -EINVAL; 932} 933EXPORT_SYMBOL(nfc_remove_se); 934 935int nfc_se_transaction(struct nfc_dev *dev, u8 se_idx, 936 struct nfc_evt_transaction *evt_transaction) 937{ 938 int rc; 939 940 pr_debug("transaction: %x\n", se_idx); 941 942 device_lock(&dev->dev); 943 944 if (!evt_transaction) { 945 rc = -EPROTO; 946 goto out; 947 } 948 949 rc = nfc_genl_se_transaction(dev, se_idx, evt_transaction); 950out: 951 device_unlock(&dev->dev); 952 return rc; 953} 954EXPORT_SYMBOL(nfc_se_transaction); 955 956static void nfc_release(struct device *d) 957{ 958 struct nfc_dev *dev = to_nfc_dev(d); 959 struct nfc_se *se, *n; 960 961 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 962 963 nfc_genl_data_exit(&dev->genl_data); 964 kfree(dev->targets); 965 966 list_for_each_entry_safe(se, n, &dev->secure_elements, list) { 967 nfc_genl_se_removed(dev, se->idx); 968 list_del(&se->list); 969 kfree(se); 970 } 971 972 kfree(dev); 973} 974 975static void nfc_check_pres_work(struct work_struct *work) 976{ 977 struct nfc_dev *dev = container_of(work, struct nfc_dev, 978 check_pres_work); 979 int rc; 980 981 device_lock(&dev->dev); 982 983 if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) { 984 rc = dev->ops->check_presence(dev, dev->active_target); 985 if (rc == -EOPNOTSUPP) 986 goto exit; 987 if (rc) { 988 u32 active_target_idx = dev->active_target->idx; 989 device_unlock(&dev->dev); 990 nfc_target_lost(dev, active_target_idx); 991 return; 992 } 993 994 if (!dev->shutting_down) 995 mod_timer(&dev->check_pres_timer, jiffies + 996 msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS)); 997 } 998 999exit: 1000 device_unlock(&dev->dev); 1001} 1002 1003static void nfc_check_pres_timeout(unsigned long data) 1004{ 1005 struct nfc_dev *dev = (struct nfc_dev *)data; 1006 1007 schedule_work(&dev->check_pres_work); 1008} 1009 1010struct class nfc_class = { 1011 .name = "nfc", 1012 .dev_release = nfc_release, 1013}; 1014EXPORT_SYMBOL(nfc_class); 1015 1016static int match_idx(struct device *d, const void *data) 1017{ 1018 struct nfc_dev *dev = to_nfc_dev(d); 1019 const unsigned int *idx = data; 1020 1021 return dev->idx == *idx; 1022} 1023 1024struct nfc_dev *nfc_get_device(unsigned int idx) 1025{ 1026 struct device *d; 1027 1028 d = class_find_device(&nfc_class, NULL, &idx, match_idx); 1029 if (!d) 1030 return NULL; 1031 1032 return to_nfc_dev(d); 1033} 1034 1035/** 1036 * nfc_allocate_device - allocate a new nfc device 1037 * 1038 * @ops: device operations 1039 * @supported_protocols: NFC protocols supported by the device 1040 */ 1041struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops, 1042 u32 supported_protocols, 1043 int tx_headroom, int tx_tailroom) 1044{ 1045 struct nfc_dev *dev; 1046 1047 if (!ops->start_poll || !ops->stop_poll || !ops->activate_target || 1048 !ops->deactivate_target || !ops->im_transceive) 1049 return NULL; 1050 1051 if (!supported_protocols) 1052 return NULL; 1053 1054 dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL); 1055 if (!dev) 1056 return NULL; 1057 1058 dev->ops = ops; 1059 dev->supported_protocols = supported_protocols; 1060 dev->tx_headroom = tx_headroom; 1061 dev->tx_tailroom = tx_tailroom; 1062 INIT_LIST_HEAD(&dev->secure_elements); 1063 1064 nfc_genl_data_init(&dev->genl_data); 1065 1066 dev->rf_mode = NFC_RF_NONE; 1067 1068 /* first generation must not be 0 */ 1069 dev->targets_generation = 1; 1070 1071 if (ops->check_presence) { 1072 init_timer(&dev->check_pres_timer); 1073 dev->check_pres_timer.data = (unsigned long)dev; 1074 dev->check_pres_timer.function = nfc_check_pres_timeout; 1075 1076 INIT_WORK(&dev->check_pres_work, nfc_check_pres_work); 1077 } 1078 1079 return dev; 1080} 1081EXPORT_SYMBOL(nfc_allocate_device); 1082 1083/** 1084 * nfc_register_device - register a nfc device in the nfc subsystem 1085 * 1086 * @dev: The nfc device to register 1087 */ 1088int nfc_register_device(struct nfc_dev *dev) 1089{ 1090 int rc; 1091 1092 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1093 1094 dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL); 1095 if (dev->idx < 0) 1096 return dev->idx; 1097 1098 dev->dev.class = &nfc_class; 1099 dev_set_name(&dev->dev, "nfc%d", dev->idx); 1100 device_initialize(&dev->dev); 1101 1102 mutex_lock(&nfc_devlist_mutex); 1103 nfc_devlist_generation++; 1104 rc = device_add(&dev->dev); 1105 mutex_unlock(&nfc_devlist_mutex); 1106 1107 if (rc < 0) 1108 return rc; 1109 1110 rc = nfc_llcp_register_device(dev); 1111 if (rc) 1112 pr_err("Could not register llcp device\n"); 1113 1114 rc = nfc_genl_device_added(dev); 1115 if (rc) 1116 pr_debug("The userspace won't be notified that the device %s was added\n", 1117 dev_name(&dev->dev)); 1118 1119 dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev, 1120 RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev); 1121 if (dev->rfkill) { 1122 if (rfkill_register(dev->rfkill) < 0) { 1123 rfkill_destroy(dev->rfkill); 1124 dev->rfkill = NULL; 1125 } 1126 } 1127 1128 return 0; 1129} 1130EXPORT_SYMBOL(nfc_register_device); 1131 1132/** 1133 * nfc_unregister_device - unregister a nfc device in the nfc subsystem 1134 * 1135 * @dev: The nfc device to unregister 1136 */ 1137void nfc_unregister_device(struct nfc_dev *dev) 1138{ 1139 int rc, id; 1140 1141 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1142 1143 id = dev->idx; 1144 1145 if (dev->rfkill) { 1146 rfkill_unregister(dev->rfkill); 1147 rfkill_destroy(dev->rfkill); 1148 } 1149 1150 if (dev->ops->check_presence) { 1151 device_lock(&dev->dev); 1152 dev->shutting_down = true; 1153 device_unlock(&dev->dev); 1154 del_timer_sync(&dev->check_pres_timer); 1155 cancel_work_sync(&dev->check_pres_work); 1156 } 1157 1158 rc = nfc_genl_device_removed(dev); 1159 if (rc) 1160 pr_debug("The userspace won't be notified that the device %s " 1161 "was removed\n", dev_name(&dev->dev)); 1162 1163 nfc_llcp_unregister_device(dev); 1164 1165 mutex_lock(&nfc_devlist_mutex); 1166 nfc_devlist_generation++; 1167 device_del(&dev->dev); 1168 mutex_unlock(&nfc_devlist_mutex); 1169 1170 ida_simple_remove(&nfc_index_ida, id); 1171} 1172EXPORT_SYMBOL(nfc_unregister_device); 1173 1174static int __init nfc_init(void) 1175{ 1176 int rc; 1177 1178 pr_info("NFC Core ver %s\n", VERSION); 1179 1180 rc = class_register(&nfc_class); 1181 if (rc) 1182 return rc; 1183 1184 rc = nfc_genl_init(); 1185 if (rc) 1186 goto err_genl; 1187 1188 /* the first generation must not be 0 */ 1189 nfc_devlist_generation = 1; 1190 1191 rc = rawsock_init(); 1192 if (rc) 1193 goto err_rawsock; 1194 1195 rc = nfc_llcp_init(); 1196 if (rc) 1197 goto err_llcp_sock; 1198 1199 rc = af_nfc_init(); 1200 if (rc) 1201 goto err_af_nfc; 1202 1203 return 0; 1204 1205err_af_nfc: 1206 nfc_llcp_exit(); 1207err_llcp_sock: 1208 rawsock_exit(); 1209err_rawsock: 1210 nfc_genl_exit(); 1211err_genl: 1212 class_unregister(&nfc_class); 1213 return rc; 1214} 1215 1216static void __exit nfc_exit(void) 1217{ 1218 af_nfc_exit(); 1219 nfc_llcp_exit(); 1220 rawsock_exit(); 1221 nfc_genl_exit(); 1222 class_unregister(&nfc_class); 1223} 1224 1225subsys_initcall(nfc_init); 1226module_exit(nfc_exit); 1227 1228MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>"); 1229MODULE_DESCRIPTION("NFC Core ver " VERSION); 1230MODULE_VERSION(VERSION); 1231MODULE_LICENSE("GPL"); 1232MODULE_ALIAS_NETPROTO(PF_NFC); 1233MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME); 1234