net/nfc/core.c

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

DEFINITIONS
