net/nfc/core.c

   1 /*
   2  * Copyright (C) 2011 Instituto Nokia de Tecnologia
   3  *
   4  * Authors:
   5  *    Lauro Ramos Venancio <[email protected]>
   6  *    Aloisio Almeida Jr <[email protected]>
   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_start_poll - start polling for nfc targets
  57  *
  58  * @dev: The nfc device that must start polling
  59  * @protocols: bitset of nfc protocols that must be used for polling
  60  *
  61  * The device remains polling for targets until a target is found or
  62  * the nfc_stop_poll function is called.
  63  */
  64 int nfc_start_poll(struct nfc_dev *dev, u32 protocols)
  65 {
  66         int rc;
  67
  68         nfc_dbg("dev_name=%s protocols=0x%x", dev_name(&dev->dev), protocols);
  69
  70         if (!protocols)
  71                 return -EINVAL;
  72
  73         device_lock(&dev->dev);
  74
  75         if (!device_is_registered(&dev->dev)) {
  76                 rc = -ENODEV;
  77                 goto error;
  78         }
  79
  80         if (dev->polling) {
  81                 rc = -EBUSY;
  82                 goto error;
  83         }
  84
  85         rc = dev->ops->start_poll(dev, protocols);
  86         if (!rc)
  87                 dev->polling = true;
  88
  89 error:
  90         device_unlock(&dev->dev);
  91         return rc;
  92 }
  93
  94 /**
  95  * nfc_stop_poll - stop polling for nfc targets
  96  *
  97  * @dev: The nfc device that must stop polling
  98  */
  99 int nfc_stop_poll(struct nfc_dev *dev)
 100 {
 101         int rc = 0;
 102
 103         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 104
 105         device_lock(&dev->dev);
 106
 107         if (!device_is_registered(&dev->dev)) {
 108                 rc = -ENODEV;
 109                 goto error;
 110         }
 111
 112         if (!dev->polling) {
 113                 rc = -EINVAL;
 114                 goto error;
 115         }
 116
 117         dev->ops->stop_poll(dev);
 118         dev->polling = false;
 119
 120 error:
 121         device_unlock(&dev->dev);
 122         return rc;
 123 }
 124
 125 /**
 126  * nfc_activate_target - prepare the target for data exchange
 127  *
 128  * @dev: The nfc device that found the target
 129  * @target_idx: index of the target that must be activated
 130  * @protocol: nfc protocol that will be used for data exchange
 131  */
 132 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
 133 {
 134         int rc;
 135
 136         nfc_dbg("dev_name=%s target_idx=%u protocol=%u", dev_name(&dev->dev),
 137                                                         target_idx, protocol);
 138
 139         device_lock(&dev->dev);
 140
 141         if (!device_is_registered(&dev->dev)) {
 142                 rc = -ENODEV;
 143                 goto error;
 144         }
 145
 146         rc = dev->ops->activate_target(dev, target_idx, protocol);
 147
 148 error:
 149         device_unlock(&dev->dev);
 150         return rc;
 151 }
 152
 153 /**
 154  * nfc_deactivate_target - deactivate a nfc target
 155  *
 156  * @dev: The nfc device that found the target
 157  * @target_idx: index of the target that must be deactivated
 158  */
 159 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 160 {
 161         int rc = 0;
 162
 163         nfc_dbg("dev_name=%s target_idx=%u", dev_name(&dev->dev), target_idx);
 164
 165         device_lock(&dev->dev);
 166
 167         if (!device_is_registered(&dev->dev)) {
 168                 rc = -ENODEV;
 169                 goto error;
 170         }
 171
 172         dev->ops->deactivate_target(dev, target_idx);
 173
 174 error:
 175         device_unlock(&dev->dev);
 176         return rc;
 177 }
 178
 179 /**
 180  * nfc_data_exchange - transceive data
 181  *
 182  * @dev: The nfc device that found the target
 183  * @target_idx: index of the target
 184  * @skb: data to be sent
 185  * @cb: callback called when the response is received
 186  * @cb_context: parameter for the callback function
 187  *
 188  * The user must wait for the callback before calling this function again.
 189  */
 190 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx,
 191                                         struct sk_buff *skb,
 192                                         data_exchange_cb_t cb,
 193                                         void *cb_context)
 194 {
 195         int rc;
 196
 197         nfc_dbg("dev_name=%s target_idx=%u skb->len=%u", dev_name(&dev->dev),
 198                                                         target_idx, skb->len);
 199
 200         device_lock(&dev->dev);
 201
 202         if (!device_is_registered(&dev->dev)) {
 203                 rc = -ENODEV;
 204                 kfree_skb(skb);
 205                 goto error;
 206         }
 207
 208         rc = dev->ops->data_exchange(dev, target_idx, skb, cb, cb_context);
 209
 210 error:
 211         device_unlock(&dev->dev);
 212         return rc;
 213 }
 214
 215 /**
 216  * nfc_alloc_skb - allocate a skb for data exchange responses
 217  *
 218  * @size: size to allocate
 219  * @gfp: gfp flags
 220  */
 221 struct sk_buff *nfc_alloc_skb(unsigned int size, gfp_t gfp)
 222 {
 223         struct sk_buff *skb;
 224         unsigned int total_size;
 225
 226         total_size = size + 1;
 227         skb = alloc_skb(total_size, gfp);
 228
 229         if (skb)
 230                 skb_reserve(skb, 1);
 231
 232         return skb;
 233 }
 234 EXPORT_SYMBOL(nfc_alloc_skb);
 235
 236 /**
 237  * nfc_targets_found - inform that targets were found
 238  *
 239  * @dev: The nfc device that found the targets
 240  * @targets: array of nfc targets found
 241  * @ntargets: targets array size
 242  *
 243  * The device driver must call this function when one or many nfc targets
 244  * are found. After calling this function, the device driver must stop
 245  * polling for targets.
 246  */
 247 int nfc_targets_found(struct nfc_dev *dev, struct nfc_target *targets,
 248                                                         int n_targets)
 249 {
 250         int i;
 251
 252         nfc_dbg("dev_name=%s n_targets=%d", dev_name(&dev->dev), n_targets);
 253
 254         dev->polling = false;
 255
 256         for (i = 0; i < n_targets; i++)
 257                 targets[i].idx = dev->target_idx++;
 258
 259         spin_lock_bh(&dev->targets_lock);
 260
 261         dev->targets_generation++;
 262
 263         kfree(dev->targets);
 264         dev->targets = kmemdup(targets, n_targets * sizeof(struct nfc_target),
 265                                                                 GFP_ATOMIC);
 266
 267         if (!dev->targets) {
 268                 dev->n_targets = 0;
 269                 spin_unlock_bh(&dev->targets_lock);
 270                 return -ENOMEM;
 271         }
 272
 273         dev->n_targets = n_targets;
 274         spin_unlock_bh(&dev->targets_lock);
 275
 276         nfc_genl_targets_found(dev);
 277
 278         return 0;
 279 }
 280 EXPORT_SYMBOL(nfc_targets_found);
 281
 282 static void nfc_release(struct device *d)
 283 {
 284         struct nfc_dev *dev = to_nfc_dev(d);
 285
 286         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 287
 288         nfc_genl_data_exit(&dev->genl_data);
 289         kfree(dev->targets);
 290         kfree(dev);
 291 }
 292
 293 struct class nfc_class = {
 294         .name = "nfc",
 295         .dev_release = nfc_release,
 296 };
 297 EXPORT_SYMBOL(nfc_class);
 298
 299 static int match_idx(struct device *d, void *data)
 300 {
 301         struct nfc_dev *dev = to_nfc_dev(d);
 302         unsigned *idx = data;
 303
 304         return dev->idx == *idx;
 305 }
 306
 307 struct nfc_dev *nfc_get_device(unsigned idx)
 308 {
 309         struct device *d;
 310
 311         d = class_find_device(&nfc_class, NULL, &idx, match_idx);
 312         if (!d)
 313                 return NULL;
 314
 315         return to_nfc_dev(d);
 316 }
 317
 318 /**
 319  * nfc_allocate_device - allocate a new nfc device
 320  *
 321  * @ops: device operations
 322  * @supported_protocols: NFC protocols supported by the device
 323  */
 324 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
 325                                         u32 supported_protocols)
 326 {
 327         static atomic_t dev_no = ATOMIC_INIT(0);
 328         struct nfc_dev *dev;
 329
 330         if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
 331                 !ops->deactivate_target || !ops->data_exchange)
 332                 return NULL;
 333
 334         if (!supported_protocols)
 335                 return NULL;
 336
 337         dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
 338         if (!dev)
 339                 return NULL;
 340
 341         dev->dev.class = &nfc_class;
 342         dev->idx = atomic_inc_return(&dev_no) - 1;
 343         dev_set_name(&dev->dev, "nfc%d", dev->idx);
 344         device_initialize(&dev->dev);
 345
 346         dev->ops = ops;
 347         dev->supported_protocols = supported_protocols;
 348
 349         spin_lock_init(&dev->targets_lock);
 350         nfc_genl_data_init(&dev->genl_data);
 351
 352         /* first generation must not be 0 */
 353         dev->targets_generation = 1;
 354
 355         return dev;
 356 }
 357 EXPORT_SYMBOL(nfc_allocate_device);
 358
 359 /**
 360  * nfc_register_device - register a nfc device in the nfc subsystem
 361  *
 362  * @dev: The nfc device to register
 363  */
 364 int nfc_register_device(struct nfc_dev *dev)
 365 {
 366         int rc;
 367
 368         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 369
 370         mutex_lock(&nfc_devlist_mutex);
 371         nfc_devlist_generation++;
 372         rc = device_add(&dev->dev);
 373         mutex_unlock(&nfc_devlist_mutex);
 374
 375         if (rc < 0)
 376                 return rc;
 377
 378         rc = nfc_genl_device_added(dev);
 379         if (rc)
 380                 nfc_dbg("The userspace won't be notified that the device %s was"
 381                                                 " added", dev_name(&dev->dev));
 382
 383
 384         return 0;
 385 }
 386 EXPORT_SYMBOL(nfc_register_device);
 387
 388 /**
 389  * nfc_unregister_device - unregister a nfc device in the nfc subsystem
 390  *
 391  * @dev: The nfc device to unregister
 392  */
 393 void nfc_unregister_device(struct nfc_dev *dev)
 394 {
 395         int rc;
 396
 397         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
 398
 399         mutex_lock(&nfc_devlist_mutex);
 400         nfc_devlist_generation++;
 401
 402         /* lock to avoid unregistering a device while an operation
 403            is in progress */
 404         device_lock(&dev->dev);
 405         device_del(&dev->dev);
 406         device_unlock(&dev->dev);
 407
 408         mutex_unlock(&nfc_devlist_mutex);
 409
 410         rc = nfc_genl_device_removed(dev);
 411         if (rc)
 412                 nfc_dbg("The userspace won't be notified that the device %s"
 413                                         " was removed", dev_name(&dev->dev));
 414
 415 }
 416 EXPORT_SYMBOL(nfc_unregister_device);
 417
 418 static int __init nfc_init(void)
 419 {
 420         int rc;
 421
 422         nfc_info("NFC Core ver %s", VERSION);
 423
 424         rc = class_register(&nfc_class);
 425         if (rc)
 426                 return rc;
 427
 428         rc = nfc_genl_init();
 429         if (rc)
 430                 goto err_genl;
 431
 432         /* the first generation must not be 0 */
 433         nfc_devlist_generation = 1;
 434
 435         rc = rawsock_init();
 436         if (rc)
 437                 goto err_rawsock;
 438
 439         rc = af_nfc_init();
 440         if (rc)
 441                 goto err_af_nfc;
 442
 443         return 0;
 444
 445 err_af_nfc:
 446         rawsock_exit();
 447 err_rawsock:
 448         nfc_genl_exit();
 449 err_genl:
 450         class_unregister(&nfc_class);
 451         return rc;
 452 }
 453
 454 static void __exit nfc_exit(void)
 455 {
 456         af_nfc_exit();
 457         rawsock_exit();
 458         nfc_genl_exit();
 459         class_unregister(&nfc_class);
 460 }
 461
 462 subsys_initcall(nfc_init);
 463 module_exit(nfc_exit);
 464
 465 MODULE_AUTHOR("Lauro Ramos Venancio <[email protected]>");
 466 MODULE_DESCRIPTION("NFC Core ver " VERSION);
 467 MODULE_VERSION(VERSION);
 468 MODULE_LICENSE("GPL");