net/nfc/core.c

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