linux/net/nfc/core.c
<<
>>
Prefs
   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, write to the
  20 * Free Software Foundation, Inc.,
  21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22 */
  23
  24#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
  25
  26#include <linux/init.h>
  27#include <linux/kernel.h>
  28#include <linux/module.h>
  29#include <linux/slab.h>
  30#include <linux/rfkill.h>
  31#include <linux/nfc.h>
  32
  33#include <net/genetlink.h>
  34
  35#include "nfc.h"
  36
  37#define VERSION "0.1"
  38
  39#define NFC_CHECK_PRES_FREQ_MS  2000
  40
  41int nfc_devlist_generation;
  42DEFINE_MUTEX(nfc_devlist_mutex);
  43
  44/* NFC device ID bitmap */
  45static DEFINE_IDA(nfc_index_ida);
  46
  47/**
  48 * nfc_dev_up - turn on the NFC device
  49 *
  50 * @dev: The nfc device to be turned on
  51 *
  52 * The device remains up until the nfc_dev_down function is called.
  53 */
  54int nfc_dev_up(struct nfc_dev *dev)
  55{
  56        int rc = 0;
  57
  58        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
  59
  60        device_lock(&dev->dev);
  61
  62        if (dev->rfkill && rfkill_blocked(dev->rfkill)) {
  63                rc = -ERFKILL;
  64                goto error;
  65        }
  66
  67        if (!device_is_registered(&dev->dev)) {
  68                rc = -ENODEV;
  69                goto error;
  70        }
  71
  72        if (dev->dev_up) {
  73                rc = -EALREADY;
  74                goto error;
  75        }
  76
  77        if (dev->ops->dev_up)
  78                rc = dev->ops->dev_up(dev);
  79
  80        if (!rc)
  81                dev->dev_up = true;
  82
  83error:
  84        device_unlock(&dev->dev);
  85        return rc;
  86}
  87
  88/**
  89 * nfc_dev_down - turn off the NFC device
  90 *
  91 * @dev: The nfc device to be turned off
  92 */
  93int nfc_dev_down(struct nfc_dev *dev)
  94{
  95        int rc = 0;
  96
  97        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
  98
  99        device_lock(&dev->dev);
 100
 101        if (!device_is_registered(&dev->dev)) {
 102                rc = -ENODEV;
 103                goto error;
 104        }
 105
 106        if (!dev->dev_up) {
 107                rc = -EALREADY;
 108                goto error;
 109        }
 110
 111        if (dev->polling || dev->active_target) {
 112                rc = -EBUSY;
 113                goto error;
 114        }
 115
 116        if (dev->ops->dev_down)
 117                dev->ops->dev_down(dev);
 118
 119        dev->dev_up = false;
 120
 121error:
 122        device_unlock(&dev->dev);
 123        return rc;
 124}
 125
 126static int nfc_rfkill_set_block(void *data, bool blocked)
 127{
 128        struct nfc_dev *dev = data;
 129
 130        pr_debug("%s blocked %d", dev_name(&dev->dev), blocked);
 131
 132        if (!blocked)
 133                return 0;
 134
 135        nfc_dev_down(dev);
 136
 137        return 0;
 138}
 139
 140static const struct rfkill_ops nfc_rfkill_ops = {
 141        .set_block = nfc_rfkill_set_block,
 142};
 143
 144/**
 145 * nfc_start_poll - start polling for nfc targets
 146 *
 147 * @dev: The nfc device that must start polling
 148 * @protocols: bitset of nfc protocols that must be used for polling
 149 *
 150 * The device remains polling for targets until a target is found or
 151 * the nfc_stop_poll function is called.
 152 */
 153int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols)
 154{
 155        int rc;
 156
 157        pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n",
 158                 dev_name(&dev->dev), im_protocols, tm_protocols);
 159
 160        if (!im_protocols && !tm_protocols)
 161                return -EINVAL;
 162
 163        device_lock(&dev->dev);
 164
 165        if (!device_is_registered(&dev->dev)) {
 166                rc = -ENODEV;
 167                goto error;
 168        }
 169
 170        if (!dev->dev_up) {
 171                rc = -ENODEV;
 172                goto error;
 173        }
 174
 175        if (dev->polling) {
 176                rc = -EBUSY;
 177                goto error;
 178        }
 179
 180        rc = dev->ops->start_poll(dev, im_protocols, tm_protocols);
 181        if (!rc) {
 182                dev->polling = true;
 183                dev->rf_mode = NFC_RF_NONE;
 184        }
 185
 186error:
 187        device_unlock(&dev->dev);
 188        return rc;
 189}
 190
 191/**
 192 * nfc_stop_poll - stop polling for nfc targets
 193 *
 194 * @dev: The nfc device that must stop polling
 195 */
 196int nfc_stop_poll(struct nfc_dev *dev)
 197{
 198        int rc = 0;
 199
 200        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 201
 202        device_lock(&dev->dev);
 203
 204        if (!device_is_registered(&dev->dev)) {
 205                rc = -ENODEV;
 206                goto error;
 207        }
 208
 209        if (!dev->polling) {
 210                rc = -EINVAL;
 211                goto error;
 212        }
 213
 214        dev->ops->stop_poll(dev);
 215        dev->polling = false;
 216        dev->rf_mode = NFC_RF_NONE;
 217
 218error:
 219        device_unlock(&dev->dev);
 220        return rc;
 221}
 222
 223static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx)
 224{
 225        int i;
 226
 227        if (dev->n_targets == 0)
 228                return NULL;
 229
 230        for (i = 0; i < dev->n_targets; i++) {
 231                if (dev->targets[i].idx == target_idx)
 232                        return &dev->targets[i];
 233        }
 234
 235        return NULL;
 236}
 237
 238int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
 239{
 240        int rc = 0;
 241        u8 *gb;
 242        size_t gb_len;
 243        struct nfc_target *target;
 244
 245        pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
 246
 247        if (!dev->ops->dep_link_up)
 248                return -EOPNOTSUPP;
 249
 250        device_lock(&dev->dev);
 251
 252        if (!device_is_registered(&dev->dev)) {
 253                rc = -ENODEV;
 254                goto error;
 255        }
 256
 257        if (dev->dep_link_up == true) {
 258                rc = -EALREADY;
 259                goto error;
 260        }
 261
 262        gb = nfc_llcp_general_bytes(dev, &gb_len);
 263        if (gb_len > NFC_MAX_GT_LEN) {
 264                rc = -EINVAL;
 265                goto error;
 266        }
 267
 268        target = nfc_find_target(dev, target_index);
 269        if (target == NULL) {
 270                rc = -ENOTCONN;
 271                goto error;
 272        }
 273
 274        rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len);
 275        if (!rc) {
 276                dev->active_target = target;
 277                dev->rf_mode = NFC_RF_INITIATOR;
 278        }
 279
 280error:
 281        device_unlock(&dev->dev);
 282        return rc;
 283}
 284
 285int nfc_dep_link_down(struct nfc_dev *dev)
 286{
 287        int rc = 0;
 288
 289        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 290
 291        if (!dev->ops->dep_link_down)
 292                return -EOPNOTSUPP;
 293
 294        device_lock(&dev->dev);
 295
 296        if (!device_is_registered(&dev->dev)) {
 297                rc = -ENODEV;
 298                goto error;
 299        }
 300
 301        if (dev->dep_link_up == false) {
 302                rc = -EALREADY;
 303                goto error;
 304        }
 305
 306        rc = dev->ops->dep_link_down(dev);
 307        if (!rc) {
 308                dev->dep_link_up = false;
 309                dev->active_target = NULL;
 310                dev->rf_mode = NFC_RF_NONE;
 311                nfc_llcp_mac_is_down(dev);
 312                nfc_genl_dep_link_down_event(dev);
 313        }
 314
 315error:
 316        device_unlock(&dev->dev);
 317
 318        return rc;
 319}
 320
 321int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
 322                       u8 comm_mode, u8 rf_mode)
 323{
 324        dev->dep_link_up = true;
 325
 326        nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);
 327
 328        return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);
 329}
 330EXPORT_SYMBOL(nfc_dep_link_is_up);
 331
 332/**
 333 * nfc_activate_target - prepare the target for data exchange
 334 *
 335 * @dev: The nfc device that found the target
 336 * @target_idx: index of the target that must be activated
 337 * @protocol: nfc protocol that will be used for data exchange
 338 */
 339int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
 340{
 341        int rc;
 342        struct nfc_target *target;
 343
 344        pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
 345                 dev_name(&dev->dev), target_idx, protocol);
 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->active_target) {
 355                rc = -EBUSY;
 356                goto error;
 357        }
 358
 359        target = nfc_find_target(dev, target_idx);
 360        if (target == NULL) {
 361                rc = -ENOTCONN;
 362                goto error;
 363        }
 364
 365        rc = dev->ops->activate_target(dev, target, protocol);
 366        if (!rc) {
 367                dev->active_target = target;
 368                dev->rf_mode = NFC_RF_INITIATOR;
 369
 370                if (dev->ops->check_presence && !dev->shutting_down)
 371                        mod_timer(&dev->check_pres_timer, jiffies +
 372                                  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 373        }
 374
 375error:
 376        device_unlock(&dev->dev);
 377        return rc;
 378}
 379
 380/**
 381 * nfc_deactivate_target - deactivate a nfc target
 382 *
 383 * @dev: The nfc device that found the target
 384 * @target_idx: index of the target that must be deactivated
 385 */
 386int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 387{
 388        int rc = 0;
 389
 390        pr_debug("dev_name=%s target_idx=%u\n",
 391                 dev_name(&dev->dev), target_idx);
 392
 393        device_lock(&dev->dev);
 394
 395        if (!device_is_registered(&dev->dev)) {
 396                rc = -ENODEV;
 397                goto error;
 398        }
 399
 400        if (dev->active_target == NULL) {
 401                rc = -ENOTCONN;
 402                goto error;
 403        }
 404
 405        if (dev->active_target->idx != target_idx) {
 406                rc = -ENOTCONN;
 407                goto error;
 408        }
 409
 410        if (dev->ops->check_presence)
 411                del_timer_sync(&dev->check_pres_timer);
 412
 413        dev->ops->deactivate_target(dev, dev->active_target);
 414        dev->active_target = NULL;
 415
 416error:
 417        device_unlock(&dev->dev);
 418        return rc;
 419}
 420
 421/**
 422 * nfc_data_exchange - transceive data
 423 *
 424 * @dev: The nfc device that found the target
 425 * @target_idx: index of the target
 426 * @skb: data to be sent
 427 * @cb: callback called when the response is received
 428 * @cb_context: parameter for the callback function
 429 *
 430 * The user must wait for the callback before calling this function again.
 431 */
 432int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
 433                      data_exchange_cb_t cb, void *cb_context)
 434{
 435        int rc;
 436
 437        pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
 438                 dev_name(&dev->dev), target_idx, skb->len);
 439
 440        device_lock(&dev->dev);
 441
 442        if (!device_is_registered(&dev->dev)) {
 443                rc = -ENODEV;
 444                kfree_skb(skb);
 445                goto error;
 446        }
 447
 448        if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) {
 449                if (dev->active_target->idx != target_idx) {
 450                        rc = -EADDRNOTAVAIL;
 451                        kfree_skb(skb);
 452                        goto error;
 453                }
 454
 455                if (dev->ops->check_presence)
 456                        del_timer_sync(&dev->check_pres_timer);
 457
 458                rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb,
 459                                             cb_context);
 460
 461                if (!rc && dev->ops->check_presence && !dev->shutting_down)
 462                        mod_timer(&dev->check_pres_timer, jiffies +
 463                                  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 464        } else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) {
 465                rc = dev->ops->tm_send(dev, skb);
 466        } else {
 467                rc = -ENOTCONN;
 468                kfree_skb(skb);
 469                goto error;
 470        }
 471
 472
 473error:
 474        device_unlock(&dev->dev);
 475        return rc;
 476}
 477
 478int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len)
 479{
 480        pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
 481
 482        if (gb_len > NFC_MAX_GT_LEN)
 483                return -EINVAL;
 484
 485        return nfc_llcp_set_remote_gb(dev, gb, gb_len);
 486}
 487EXPORT_SYMBOL(nfc_set_remote_general_bytes);
 488
 489u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len)
 490{
 491        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 492
 493        return nfc_llcp_general_bytes(dev, gb_len);
 494}
 495EXPORT_SYMBOL(nfc_get_local_general_bytes);
 496
 497int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb)
 498{
 499        /* Only LLCP target mode for now */
 500        if (dev->dep_link_up == false) {
 501                kfree_skb(skb);
 502                return -ENOLINK;
 503        }
 504
 505        return nfc_llcp_data_received(dev, skb);
 506}
 507EXPORT_SYMBOL(nfc_tm_data_received);
 508
 509int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode,
 510                     u8 *gb, size_t gb_len)
 511{
 512        int rc;
 513
 514        device_lock(&dev->dev);
 515
 516        dev->polling = false;
 517
 518        if (gb != NULL) {
 519                rc = nfc_set_remote_general_bytes(dev, gb, gb_len);
 520                if (rc < 0)
 521                        goto out;
 522        }
 523
 524        dev->rf_mode = NFC_RF_TARGET;
 525
 526        if (protocol == NFC_PROTO_NFC_DEP_MASK)
 527                nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET);
 528
 529        rc = nfc_genl_tm_activated(dev, protocol);
 530
 531out:
 532        device_unlock(&dev->dev);
 533
 534        return rc;
 535}
 536EXPORT_SYMBOL(nfc_tm_activated);
 537
 538int nfc_tm_deactivated(struct nfc_dev *dev)
 539{
 540        dev->dep_link_up = false;
 541        dev->rf_mode = NFC_RF_NONE;
 542
 543        return nfc_genl_tm_deactivated(dev);
 544}
 545EXPORT_SYMBOL(nfc_tm_deactivated);
 546
 547/**
 548 * nfc_alloc_send_skb - allocate a skb for data exchange responses
 549 *
 550 * @size: size to allocate
 551 * @gfp: gfp flags
 552 */
 553struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
 554                                   unsigned int flags, unsigned int size,
 555                                   unsigned int *err)
 556{
 557        struct sk_buff *skb;
 558        unsigned int total_size;
 559
 560        total_size = size +
 561                dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;
 562
 563        skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err);
 564        if (skb)
 565                skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
 566
 567        return skb;
 568}
 569
 570/**
 571 * nfc_alloc_recv_skb - allocate a skb for data exchange responses
 572 *
 573 * @size: size to allocate
 574 * @gfp: gfp flags
 575 */
 576struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp)
 577{
 578        struct sk_buff *skb;
 579        unsigned int total_size;
 580
 581        total_size = size + 1;
 582        skb = alloc_skb(total_size, gfp);
 583
 584        if (skb)
 585                skb_reserve(skb, 1);
 586
 587        return skb;
 588}
 589EXPORT_SYMBOL(nfc_alloc_recv_skb);
 590
 591/**
 592 * nfc_targets_found - inform that targets were found
 593 *
 594 * @dev: The nfc device that found the targets
 595 * @targets: array of nfc targets found
 596 * @ntargets: targets array size
 597 *
 598 * The device driver must call this function when one or many nfc targets
 599 * are found. After calling this function, the device driver must stop
 600 * polling for targets.
 601 * NOTE: This function can be called with targets=NULL and n_targets=0 to
 602 * notify a driver error, meaning that the polling operation cannot complete.
 603 * IMPORTANT: this function must not be called from an atomic context.
 604 * In addition, it must also not be called from a context that would prevent
 605 * the NFC Core to call other nfc ops entry point concurrently.
 606 */
 607int nfc_targets_found(struct nfc_dev *dev,
 608                      struct nfc_target *targets, int n_targets)
 609{
 610        int i;
 611
 612        pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
 613
 614        for (i = 0; i < n_targets; i++)
 615                targets[i].idx = dev->target_next_idx++;
 616
 617        device_lock(&dev->dev);
 618
 619        if (dev->polling == false) {
 620                device_unlock(&dev->dev);
 621                return 0;
 622        }
 623
 624        dev->polling = false;
 625
 626        dev->targets_generation++;
 627
 628        kfree(dev->targets);
 629        dev->targets = NULL;
 630
 631        if (targets) {
 632                dev->targets = kmemdup(targets,
 633                                       n_targets * sizeof(struct nfc_target),
 634                                       GFP_ATOMIC);
 635
 636                if (!dev->targets) {
 637                        dev->n_targets = 0;
 638                        device_unlock(&dev->dev);
 639                        return -ENOMEM;
 640                }
 641        }
 642
 643        dev->n_targets = n_targets;
 644        device_unlock(&dev->dev);
 645
 646        nfc_genl_targets_found(dev);
 647
 648        return 0;
 649}
 650EXPORT_SYMBOL(nfc_targets_found);
 651
 652/**
 653 * nfc_target_lost - inform that an activated target went out of field
 654 *
 655 * @dev: The nfc device that had the activated target in field
 656 * @target_idx: the nfc index of the target
 657 *
 658 * The device driver must call this function when the activated target
 659 * goes out of the field.
 660 * IMPORTANT: this function must not be called from an atomic context.
 661 * In addition, it must also not be called from a context that would prevent
 662 * the NFC Core to call other nfc ops entry point concurrently.
 663 */
 664int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
 665{
 666        struct nfc_target *tg;
 667        int i;
 668
 669        pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
 670
 671        device_lock(&dev->dev);
 672
 673        for (i = 0; i < dev->n_targets; i++) {
 674                tg = &dev->targets[i];
 675                if (tg->idx == target_idx)
 676                        break;
 677        }
 678
 679        if (i == dev->n_targets) {
 680                device_unlock(&dev->dev);
 681                return -EINVAL;
 682        }
 683
 684        dev->targets_generation++;
 685        dev->n_targets--;
 686        dev->active_target = NULL;
 687
 688        if (dev->n_targets) {
 689                memcpy(&dev->targets[i], &dev->targets[i + 1],
 690                       (dev->n_targets - i) * sizeof(struct nfc_target));
 691        } else {
 692                kfree(dev->targets);
 693                dev->targets = NULL;
 694        }
 695
 696        device_unlock(&dev->dev);
 697
 698        nfc_genl_target_lost(dev, target_idx);
 699
 700        return 0;
 701}
 702EXPORT_SYMBOL(nfc_target_lost);
 703
 704inline void nfc_driver_failure(struct nfc_dev *dev, int err)
 705{
 706        nfc_targets_found(dev, NULL, 0);
 707}
 708EXPORT_SYMBOL(nfc_driver_failure);
 709
 710static void nfc_release(struct device *d)
 711{
 712        struct nfc_dev *dev = to_nfc_dev(d);
 713
 714        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 715
 716        nfc_genl_data_exit(&dev->genl_data);
 717        kfree(dev->targets);
 718        kfree(dev);
 719}
 720
 721static void nfc_check_pres_work(struct work_struct *work)
 722{
 723        struct nfc_dev *dev = container_of(work, struct nfc_dev,
 724                                           check_pres_work);
 725        int rc;
 726
 727        device_lock(&dev->dev);
 728
 729        if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) {
 730                rc = dev->ops->check_presence(dev, dev->active_target);
 731                if (rc == -EOPNOTSUPP)
 732                        goto exit;
 733                if (rc) {
 734                        u32 active_target_idx = dev->active_target->idx;
 735                        device_unlock(&dev->dev);
 736                        nfc_target_lost(dev, active_target_idx);
 737                        return;
 738                }
 739
 740                if (!dev->shutting_down)
 741                        mod_timer(&dev->check_pres_timer, jiffies +
 742                                  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 743        }
 744
 745exit:
 746        device_unlock(&dev->dev);
 747}
 748
 749static void nfc_check_pres_timeout(unsigned long data)
 750{
 751        struct nfc_dev *dev = (struct nfc_dev *)data;
 752
 753        schedule_work(&dev->check_pres_work);
 754}
 755
 756struct class nfc_class = {
 757        .name = "nfc",
 758        .dev_release = nfc_release,
 759};
 760EXPORT_SYMBOL(nfc_class);
 761
 762static int match_idx(struct device *d, const void *data)
 763{
 764        struct nfc_dev *dev = to_nfc_dev(d);
 765        const unsigned int *idx = data;
 766
 767        return dev->idx == *idx;
 768}
 769
 770struct nfc_dev *nfc_get_device(unsigned int idx)
 771{
 772        struct device *d;
 773
 774        d = class_find_device(&nfc_class, NULL, &idx, match_idx);
 775        if (!d)
 776                return NULL;
 777
 778        return to_nfc_dev(d);
 779}
 780
 781/**
 782 * nfc_allocate_device - allocate a new nfc device
 783 *
 784 * @ops: device operations
 785 * @supported_protocols: NFC protocols supported by the device
 786 */
 787struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
 788                                    u32 supported_protocols,
 789                                    u32 supported_se,
 790                                    int tx_headroom, int tx_tailroom)
 791{
 792        struct nfc_dev *dev;
 793
 794        if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
 795            !ops->deactivate_target || !ops->im_transceive)
 796                return NULL;
 797
 798        if (!supported_protocols)
 799                return NULL;
 800
 801        dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
 802        if (!dev)
 803                return NULL;
 804
 805        dev->ops = ops;
 806        dev->supported_protocols = supported_protocols;
 807        dev->supported_se = supported_se;
 808        dev->active_se = NFC_SE_NONE;
 809        dev->tx_headroom = tx_headroom;
 810        dev->tx_tailroom = tx_tailroom;
 811
 812        nfc_genl_data_init(&dev->genl_data);
 813
 814        dev->rf_mode = NFC_RF_NONE;
 815
 816        /* first generation must not be 0 */
 817        dev->targets_generation = 1;
 818
 819        if (ops->check_presence) {
 820                init_timer(&dev->check_pres_timer);
 821                dev->check_pres_timer.data = (unsigned long)dev;
 822                dev->check_pres_timer.function = nfc_check_pres_timeout;
 823
 824                INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
 825        }
 826
 827        return dev;
 828}
 829EXPORT_SYMBOL(nfc_allocate_device);
 830
 831/**
 832 * nfc_register_device - register a nfc device in the nfc subsystem
 833 *
 834 * @dev: The nfc device to register
 835 */
 836int nfc_register_device(struct nfc_dev *dev)
 837{
 838        int rc;
 839
 840        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 841
 842        dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL);
 843        if (dev->idx < 0)
 844                return dev->idx;
 845
 846        dev->dev.class = &nfc_class;
 847        dev_set_name(&dev->dev, "nfc%d", dev->idx);
 848        device_initialize(&dev->dev);
 849
 850        mutex_lock(&nfc_devlist_mutex);
 851        nfc_devlist_generation++;
 852        rc = device_add(&dev->dev);
 853        mutex_unlock(&nfc_devlist_mutex);
 854
 855        if (rc < 0)
 856                return rc;
 857
 858        rc = nfc_llcp_register_device(dev);
 859        if (rc)
 860                pr_err("Could not register llcp device\n");
 861
 862        rc = nfc_genl_device_added(dev);
 863        if (rc)
 864                pr_debug("The userspace won't be notified that the device %s was added\n",
 865                         dev_name(&dev->dev));
 866
 867        dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev,
 868                                   RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev);
 869        if (dev->rfkill) {
 870                if (rfkill_register(dev->rfkill) < 0) {
 871                        rfkill_destroy(dev->rfkill);
 872                        dev->rfkill = NULL;
 873                }
 874        }
 875
 876        return 0;
 877}
 878EXPORT_SYMBOL(nfc_register_device);
 879
 880/**
 881 * nfc_unregister_device - unregister a nfc device in the nfc subsystem
 882 *
 883 * @dev: The nfc device to unregister
 884 */
 885void nfc_unregister_device(struct nfc_dev *dev)
 886{
 887        int rc, id;
 888
 889        pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 890
 891        id = dev->idx;
 892
 893        if (dev->rfkill) {
 894                rfkill_unregister(dev->rfkill);
 895                rfkill_destroy(dev->rfkill);
 896        }
 897
 898        if (dev->ops->check_presence) {
 899                device_lock(&dev->dev);
 900                dev->shutting_down = true;
 901                device_unlock(&dev->dev);
 902                del_timer_sync(&dev->check_pres_timer);
 903                cancel_work_sync(&dev->check_pres_work);
 904        }
 905
 906        rc = nfc_genl_device_removed(dev);
 907        if (rc)
 908                pr_debug("The userspace won't be notified that the device %s "
 909                         "was removed\n", dev_name(&dev->dev));
 910
 911        nfc_llcp_unregister_device(dev);
 912
 913        mutex_lock(&nfc_devlist_mutex);
 914        nfc_devlist_generation++;
 915        device_del(&dev->dev);
 916        mutex_unlock(&nfc_devlist_mutex);
 917
 918        ida_simple_remove(&nfc_index_ida, id);
 919}
 920EXPORT_SYMBOL(nfc_unregister_device);
 921
 922static int __init nfc_init(void)
 923{
 924        int rc;
 925
 926        pr_info("NFC Core ver %s\n", VERSION);
 927
 928        rc = class_register(&nfc_class);
 929        if (rc)
 930                return rc;
 931
 932        rc = nfc_genl_init();
 933        if (rc)
 934                goto err_genl;
 935
 936        /* the first generation must not be 0 */
 937        nfc_devlist_generation = 1;
 938
 939        rc = rawsock_init();
 940        if (rc)
 941                goto err_rawsock;
 942
 943        rc = nfc_llcp_init();
 944        if (rc)
 945                goto err_llcp_sock;
 946
 947        rc = af_nfc_init();
 948        if (rc)
 949                goto err_af_nfc;
 950
 951        return 0;
 952
 953err_af_nfc:
 954        nfc_llcp_exit();
 955err_llcp_sock:
 956        rawsock_exit();
 957err_rawsock:
 958        nfc_genl_exit();
 959err_genl:
 960        class_unregister(&nfc_class);
 961        return rc;
 962}
 963
 964static void __exit nfc_exit(void)
 965{
 966        af_nfc_exit();
 967        nfc_llcp_exit();
 968        rawsock_exit();
 969        nfc_genl_exit();
 970        class_unregister(&nfc_class);
 971}
 972
 973subsys_initcall(nfc_init);
 974module_exit(nfc_exit);
 975
 976MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
 977MODULE_DESCRIPTION("NFC Core ver " VERSION);
 978MODULE_VERSION(VERSION);
 979MODULE_LICENSE("GPL");
 980MODULE_ALIAS_NETPROTO(PF_NFC);
 981MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);
 982
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.