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         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
 291 int 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
 333 error:
 334         device_unlock(&dev->dev);
 335         return rc;
 336 }
 337
 338 int 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
 368 error:
 369         device_unlock(&dev->dev);
 370
 371         return rc;
 372 }
 373
 374 int 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 }
 396 EXPORT_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  */
 405 int 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
 441 error:
 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  */
 452 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 453 {
 454         int rc = 0;
 455
 456         pr_debug("dev_name=%s target_idx=%u\n",
 457                  dev_name(&dev->dev), target_idx);
 458
 459         device_lock(&dev->dev);
 460
 461         if (!device_is_registered(&dev->dev)) {
 462                 rc = -ENODEV;
 463                 goto error;
 464         }
 465
 466         if (dev->active_target == NULL) {
 467                 rc = -ENOTCONN;
 468                 goto error;
 469         }
 470
 471         if (dev->active_target->idx != target_idx) {
 472                 rc = -ENOTCONN;
 473                 goto error;
 474         }
 475
 476         if (dev->ops->check_presence)
 477                 del_timer_sync(&dev->check_pres_timer);
 478
 479         dev->ops->deactivate_target(dev, dev->active_target);
 480         dev->active_target = NULL;
 481
 482 error:
 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  */
 498 int 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
 539 error:
 540         device_unlock(&dev->dev);
 541         return rc;
 542 }
 543
 544 struct 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 }
 554 EXPORT_SYMBOL(nfc_find_se);
 555
 556 int 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
 600 error:
 601         device_unlock(&dev->dev);
 602         return rc;
 603 }
 604
 605 int 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
 644 error:
 645         device_unlock(&dev->dev);
 646         return rc;
 647 }
 648
 649 int 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 }
 655 EXPORT_SYMBOL(nfc_set_remote_general_bytes);
 656
 657 u8 *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 }
 663 EXPORT_SYMBOL(nfc_get_local_general_bytes);
 664
 665 int 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 }
 675 EXPORT_SYMBOL(nfc_tm_data_received);
 676
 677 int 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
 699 out:
 700         device_unlock(&dev->dev);
 701
 702         return rc;
 703 }
 704 EXPORT_SYMBOL(nfc_tm_activated);
 705
 706 int 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 }
 713 EXPORT_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  */
 721 struct 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  */
 744 struct 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 }
 757 EXPORT_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  */
 775 int 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 }
 818 EXPORT_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  */
 832 int 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 }
 870 EXPORT_SYMBOL(nfc_target_lost);
 871
 872 inline void nfc_driver_failure(struct nfc_dev *dev, int err)
 873 {
 874         nfc_targets_found(dev, NULL, 0);
 875 }
 876 EXPORT_SYMBOL(nfc_driver_failure);
 877
 878 int 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 }
 910 EXPORT_SYMBOL(nfc_add_se);
 911
 912 int 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 }
 933 EXPORT_SYMBOL(nfc_remove_se);
 934
 935 int 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);
 950 out:
 951         device_unlock(&dev->dev);
 952         return rc;
 953 }
 954 EXPORT_SYMBOL(nfc_se_transaction);
 955
 956 static 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
 975 static 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
 999 exit:
1000         device_unlock(&dev->dev);
1001 }
1002
1003 static 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
1010 struct class nfc_class = {
1011         .name = "nfc",
1012         .dev_release = nfc_release,
1013 };
1014 EXPORT_SYMBOL(nfc_class);
1015
1016 static 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
1024 struct 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  */
1041 struct 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 }
1081 EXPORT_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  */
1088 int 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 }
1130 EXPORT_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  */
1137 void 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 }
1172 EXPORT_SYMBOL(nfc_unregister_device);
1173
1174 static 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
1205 err_af_nfc:
1206         nfc_llcp_exit();
1207 err_llcp_sock:
1208         rawsock_exit();
1209 err_rawsock:
1210         nfc_genl_exit();
1211 err_genl:
1212         class_unregister(&nfc_class);
1213         return rc;
1214 }
1215
1216 static 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
1225 subsys_initcall(nfc_init);
1226 module_exit(nfc_exit);
1227
1228 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
1229 MODULE_DESCRIPTION("NFC Core ver " VERSION);
1230 MODULE_VERSION(VERSION);
1231 MODULE_LICENSE("GPL");
1232 MODULE_ALIAS_NETPROTO(PF_NFC);
1233 MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);