net/nfc/core.c

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