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, write to the
  20  * Free Software Foundation, Inc.,
  21  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <linux/init.h>
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/slab.h>
  28
  29 #include "nfc.h"
  30
  31 #define VERSION "0.1"
  32
  33 int nfc_devlist_generation;
  34 DEFINE_MUTEX(nfc_devlist_mutex);
  35
  36 int nfc_printk(const char *level, const char *format, ...)
  37 {
  38         struct va_format vaf;
  39         va_list args;
  40         int r;
  41
  42         va_start(args, format);
  43
  44         vaf.fmt = format;
  45         vaf.va = &args;
  46
  47         r = printk("%sNFC: %pV\n", level, &vaf);
  48
  49         va_end(args);
  50
  51         return r;
  52 }
  53 EXPORT_SYMBOL(nfc_printk);
  54
  55 /**
  56  * nfc_dev_up - turn on the NFC device
  57  *
  58  * @dev: The nfc device to be turned on
  59  *
  60  * The device remains up until the nfc_dev_down function is called.
  61  */
  62 int nfc_dev_up(struct nfc_dev *dev)
  63 {
  64         int rc = 0;
  65
  66         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
  67
  68         device_lock(&dev->dev);
  69
  70         if (!device_is_registered(&dev->dev)) {
  71                 rc = -ENODEV;
  72                 goto error;
  73         }
  74
  75         if (dev->dev_up) {
  76                 rc = -EALREADY;
  77                 goto error;
  78         }
  79
  80         if (dev->ops->dev_up)
  81                 rc = dev->ops->dev_up(dev);
  82
  83         if (!rc)
  84                 dev->dev_up = true;
  85
  86 error:
  87         device_unlock(&dev->dev);
  88         return rc;
  89 }
  90
  91 /**
  92  * nfc_dev_down - turn off the NFC device
  93  *
  94  * @dev: The nfc device to be turned off
  95  */
  96 int nfc_dev_down(struct nfc_dev *dev)
  97 {
  98         int rc = 0;
  99
 100         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 101
 102         device_lock(&dev->dev);
 103
 104         if (!device_is_registered(&dev->dev)) {
 105                 rc = -ENODEV;
 106                 goto error;
 107         }
 108
 109         if (!dev->dev_up) {
 110                 rc = -EALREADY;
 111                 goto error;
 112         }
 113
 114         if (dev->polling || dev->remote_activated) {
 115                 rc = -EBUSY;
 116                 goto error;
 117         }
 118
 119         if (dev->ops->dev_down)
 120                 dev->ops->dev_down(dev);
 121
 122         dev->dev_up = false;
 123
 124 error:
 125         device_unlock(&dev->dev);
 126         return rc;
 127 }
 128
 129 /**
 130  * nfc_start_poll - start polling for nfc targets
 131  *
 132  * @dev: The nfc device that must start polling
 133  * @protocols: bitset of nfc protocols that must be used for polling
 134  *
 135  * The device remains polling for targets until a target is found or
 136  * the nfc_stop_poll function is called.
 137  */
 138 int nfc_start_poll(struct nfc_dev *dev, u32 protocols)
 139 {
 140         int rc;
 141
 142         nfc_dbg("dev_name=%s protocols=0x%x", dev_name(&dev->dev), protocols);
 143
 144         if (!protocols)
 145                 return -EINVAL;
 146
 147         device_lock(&dev->dev);
 148
 149         if (!device_is_registered(&dev->dev)) {
 150                 rc = -ENODEV;
 151                 goto error;
 152         }
 153
 154         if (dev->polling) {
 155                 rc = -EBUSY;
 156                 goto error;
 157         }
 158
 159         rc = dev->ops->start_poll(dev, protocols);
 160         if (!rc)
 161                 dev->polling = true;
 162
 163 error:
 164         device_unlock(&dev->dev);
 165         return rc;
 166 }
 167
 168 /**
 169  * nfc_stop_poll - stop polling for nfc targets
 170  *
 171  * @dev: The nfc device that must stop polling
 172  */
 173 int nfc_stop_poll(struct nfc_dev *dev)
 174 {
 175         int rc = 0;
 176
 177         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 178
 179         device_lock(&dev->dev);
 180
 181         if (!device_is_registered(&dev->dev)) {
 182                 rc = -ENODEV;
 183                 goto error;
 184         }
 185
 186         if (!dev->polling) {
 187                 rc = -EINVAL;
 188                 goto error;
 189         }
 190
 191         dev->ops->stop_poll(dev);
 192         dev->polling = false;
 193
 194 error:
 195         device_unlock(&dev->dev);
 196         return rc;
 197 }
 198
 199 /**
 200  * nfc_activate_target - prepare the target for data exchange
 201  *
 202  * @dev: The nfc device that found the target
 203  * @target_idx: index of the target that must be activated
 204  * @protocol: nfc protocol that will be used for data exchange
 205  */
 206 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
 207 {
 208         int rc;
 209
 210         nfc_dbg("dev_name=%s target_idx=%u protocol=%u", dev_name(&dev->dev),
 211                                                         target_idx, protocol);
 212
 213         device_lock(&dev->dev);
 214
 215         if (!device_is_registered(&dev->dev)) {
 216                 rc = -ENODEV;
 217                 goto error;
 218         }
 219
 220         rc = dev->ops->activate_target(dev, target_idx, protocol);
 221         if (!rc)
 222                 dev->remote_activated = true;
 223
 224 error:
 225         device_unlock(&dev->dev);
 226         return rc;
 227 }
 228
 229 /**
 230  * nfc_deactivate_target - deactivate a nfc target
 231  *
 232  * @dev: The nfc device that found the target
 233  * @target_idx: index of the target that must be deactivated
 234  */
 235 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 236 {
 237         int rc = 0;
 238
 239         nfc_dbg("dev_name=%s target_idx=%u", dev_name(&dev->dev), target_idx);
 240
 241         device_lock(&dev->dev);
 242
 243         if (!device_is_registered(&dev->dev)) {
 244                 rc = -ENODEV;
 245                 goto error;
 246         }
 247
 248         dev->ops->deactivate_target(dev, target_idx);
 249         dev->remote_activated = false;
 250
 251 error:
 252         device_unlock(&dev->dev);
 253         return rc;
 254 }
 255
 256 /**
 257  * nfc_data_exchange - transceive data
 258  *
 259  * @dev: The nfc device that found the target
 260  * @target_idx: index of the target
 261  * @skb: data to be sent
 262  * @cb: callback called when the response is received
 263  * @cb_context: parameter for the callback function
 264  *
 265  * The user must wait for the callback before calling this function again.
 266  */
 267 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx,
 268                                         struct sk_buff *skb,
 269                                         data_exchange_cb_t cb,
 270                                         void *cb_context)
 271 {
 272         int rc;
 273
 274         nfc_dbg("dev_name=%s target_idx=%u skb->len=%u", dev_name(&dev->dev),
 275                                                         target_idx, skb->len);
 276
 277         device_lock(&dev->dev);
 278
 279         if (!device_is_registered(&dev->dev)) {
 280                 rc = -ENODEV;
 281                 kfree_skb(skb);
 282                 goto error;
 283         }
 284
 285         rc = dev->ops->data_exchange(dev, target_idx, skb, cb, cb_context);
 286
 287 error:
 288         device_unlock(&dev->dev);
 289         return rc;
 290 }
 291
 292 /**
 293  * nfc_alloc_skb - allocate a skb for data exchange responses
 294  *
 295  * @size: size to allocate
 296  * @gfp: gfp flags
 297  */
 298 struct sk_buff *nfc_alloc_skb(unsigned int size, gfp_t gfp)
 299 {
 300         struct sk_buff *skb;
 301         unsigned int total_size;
 302
 303         total_size = size + 1;
 304         skb = alloc_skb(total_size, gfp);
 305
 306         if (skb)
 307                 skb_reserve(skb, 1);
 308
 309         return skb;
 310 }
 311 EXPORT_SYMBOL(nfc_alloc_skb);
 312
 313 /**
 314  * nfc_targets_found - inform that targets were found
 315  *
 316  * @dev: The nfc device that found the targets
 317  * @targets: array of nfc targets found
 318  * @ntargets: targets array size
 319  *
 320  * The device driver must call this function when one or many nfc targets
 321  * are found. After calling this function, the device driver must stop
 322  * polling for targets.
 323  */
 324 int nfc_targets_found(struct nfc_dev *dev, struct nfc_target *targets,
 325                                                         int n_targets)
 326 {
 327         int i;
 328
 329         nfc_dbg("dev_name=%s n_targets=%d", dev_name(&dev->dev), n_targets);
 330
 331         dev->polling = false;
 332
 333         for (i = 0; i < n_targets; i++)
 334                 targets[i].idx = dev->target_idx++;
 335
 336         spin_lock_bh(&dev->targets_lock);
 337
 338         dev->targets_generation++;
 339
 340         kfree(dev->targets);
 341         dev->targets = kmemdup(targets, n_targets * sizeof(struct nfc_target),
 342                                                                 GFP_ATOMIC);
 343
 344         if (!dev->targets) {
 345                 dev->n_targets = 0;
 346                 spin_unlock_bh(&dev->targets_lock);
 347                 return -ENOMEM;
 348         }
 349
 350         dev->n_targets = n_targets;
 351         spin_unlock_bh(&dev->targets_lock);
 352
 353         nfc_genl_targets_found(dev);
 354
 355         return 0;
 356 }
 357 EXPORT_SYMBOL(nfc_targets_found);
 358
 359 static void nfc_release(struct device *d)
 360 {
 361         struct nfc_dev *dev = to_nfc_dev(d);
 362
 363         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 364
 365         nfc_genl_data_exit(&dev->genl_data);
 366         kfree(dev->targets);
 367         kfree(dev);
 368 }
 369
 370 struct class nfc_class = {
 371         .name = "nfc",
 372         .dev_release = nfc_release,
 373 };
 374 EXPORT_SYMBOL(nfc_class);
 375
 376 static int match_idx(struct device *d, void *data)
 377 {
 378         struct nfc_dev *dev = to_nfc_dev(d);
 379         unsigned *idx = data;
 380
 381         return dev->idx == *idx;
 382 }
 383
 384 struct nfc_dev *nfc_get_device(unsigned idx)
 385 {
 386         struct device *d;
 387
 388         d = class_find_device(&nfc_class, NULL, &idx, match_idx);
 389         if (!d)
 390                 return NULL;
 391
 392         return to_nfc_dev(d);
 393 }
 394
 395 /**
 396  * nfc_allocate_device - allocate a new nfc device
 397  *
 398  * @ops: device operations
 399  * @supported_protocols: NFC protocols supported by the device
 400  */
 401 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
 402                                         u32 supported_protocols,
 403                                         int tx_headroom,
 404                                         int tx_tailroom)
 405 {
 406         static atomic_t dev_no = ATOMIC_INIT(0);
 407         struct nfc_dev *dev;
 408
 409         if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
 410                 !ops->deactivate_target || !ops->data_exchange)
 411                 return NULL;
 412
 413         if (!supported_protocols)
 414                 return NULL;
 415
 416         dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
 417         if (!dev)
 418                 return NULL;
 419
 420         dev->dev.class = &nfc_class;
 421         dev->idx = atomic_inc_return(&dev_no) - 1;
 422         dev_set_name(&dev->dev, "nfc%d", dev->idx);
 423         device_initialize(&dev->dev);
 424
 425         dev->ops = ops;
 426         dev->supported_protocols = supported_protocols;
 427         dev->tx_headroom = tx_headroom;
 428         dev->tx_tailroom = tx_tailroom;
 429
 430         spin_lock_init(&dev->targets_lock);
 431         nfc_genl_data_init(&dev->genl_data);
 432
 433         /* first generation must not be 0 */
 434         dev->targets_generation = 1;
 435
 436         return dev;
 437 }
 438 EXPORT_SYMBOL(nfc_allocate_device);
 439
 440 /**
 441  * nfc_register_device - register a nfc device in the nfc subsystem
 442  *
 443  * @dev: The nfc device to register
 444  */
 445 int nfc_register_device(struct nfc_dev *dev)
 446 {
 447         int rc;
 448
 449         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 450
 451         mutex_lock(&nfc_devlist_mutex);
 452         nfc_devlist_generation++;
 453         rc = device_add(&dev->dev);
 454         mutex_unlock(&nfc_devlist_mutex);
 455
 456         if (rc < 0)
 457                 return rc;
 458
 459         rc = nfc_genl_device_added(dev);
 460         if (rc)
 461                 nfc_dbg("The userspace won't be notified that the device %s was"
 462                                                 " added", dev_name(&dev->dev));
 463
 464
 465         return 0;
 466 }
 467 EXPORT_SYMBOL(nfc_register_device);
 468
 469 /**
 470  * nfc_unregister_device - unregister a nfc device in the nfc subsystem
 471  *
 472  * @dev: The nfc device to unregister
 473  */
 474 void nfc_unregister_device(struct nfc_dev *dev)
 475 {
 476         int rc;
 477
 478         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 479
 480         mutex_lock(&nfc_devlist_mutex);
 481         nfc_devlist_generation++;
 482
 483         /* lock to avoid unregistering a device while an operation
 484            is in progress */
 485         device_lock(&dev->dev);
 486         device_del(&dev->dev);
 487         device_unlock(&dev->dev);
 488
 489         mutex_unlock(&nfc_devlist_mutex);
 490
 491         rc = nfc_genl_device_removed(dev);
 492         if (rc)
 493                 nfc_dbg("The userspace won't be notified that the device %s"
 494                                         " was removed", dev_name(&dev->dev));
 495
 496 }
 497 EXPORT_SYMBOL(nfc_unregister_device);
 498
 499 static int __init nfc_init(void)
 500 {
 501         int rc;
 502
 503         nfc_info("NFC Core ver %s", VERSION);
 504
 505         rc = class_register(&nfc_class);
 506         if (rc)
 507                 return rc;
 508
 509         rc = nfc_genl_init();
 510         if (rc)
 511                 goto err_genl;
 512
 513         /* the first generation must not be 0 */
 514         nfc_devlist_generation = 1;
 515
 516         rc = rawsock_init();
 517         if (rc)
 518                 goto err_rawsock;
 519
 520         rc = af_nfc_init();
 521         if (rc)
 522                 goto err_af_nfc;
 523
 524         return 0;
 525
 526 err_af_nfc:
 527         rawsock_exit();
 528 err_rawsock:
 529         nfc_genl_exit();
 530 err_genl:
 531         class_unregister(&nfc_class);
 532         return rc;
 533 }
 534
 535 static void __exit nfc_exit(void)
 536 {
 537         af_nfc_exit();
 538         rawsock_exit();
 539         nfc_genl_exit();
 540         class_unregister(&nfc_class);
 541 }
 542
 543 subsys_initcall(nfc_init);
 544 module_exit(nfc_exit);
 545
 546 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
 547 MODULE_DESCRIPTION("NFC Core ver " VERSION);
 548 MODULE_VERSION(VERSION);
 549 MODULE_LICENSE("GPL");