drivers/nfc/nfcsim.c

   1 /*
   2  * NFC hardware simulation driver
   3  * Copyright (c) 2013, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #include <linux/device.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/ctype.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/nfc.h>
  22 #include <net/nfc/nfc.h>
  23 #include <net/nfc/digital.h>
  24
  25 #define NFCSIM_ERR(d, fmt, args...) nfc_err(&d->nfc_digital_dev->nfc_dev->dev, \
  26                                             "%s: " fmt, __func__, ## args)
  27
  28 #define NFCSIM_DBG(d, fmt, args...) dev_dbg(&d->nfc_digital_dev->nfc_dev->dev, \
  29                                             "%s: " fmt, __func__, ## args)
  30
  31 #define NFCSIM_VERSION "0.2"
  32
  33 #define NFCSIM_MODE_NONE        0
  34 #define NFCSIM_MODE_INITIATOR   1
  35 #define NFCSIM_MODE_TARGET      2
  36
  37 #define NFCSIM_CAPABILITIES (NFC_DIGITAL_DRV_CAPS_IN_CRC   | \
  38                              NFC_DIGITAL_DRV_CAPS_TG_CRC)
  39
  40 struct nfcsim {
  41         struct nfc_digital_dev *nfc_digital_dev;
  42
  43         struct work_struct recv_work;
  44         struct delayed_work send_work;
  45
  46         struct nfcsim_link *link_in;
  47         struct nfcsim_link *link_out;
  48
  49         bool up;
  50         u8 mode;
  51         u8 rf_tech;
  52
  53         u16 recv_timeout;
  54
  55         nfc_digital_cmd_complete_t cb;
  56         void *arg;
  57
  58         u8 dropframe;
  59 };
  60
  61 struct nfcsim_link {
  62         struct mutex lock;
  63
  64         u8 rf_tech;
  65         u8 mode;
  66
  67         u8 shutdown;
  68
  69         struct sk_buff *skb;
  70         wait_queue_head_t recv_wait;
  71         u8 cond;
  72 };
  73
  74 static struct nfcsim_link *nfcsim_link_new(void)
  75 {
  76         struct nfcsim_link *link;
  77
  78         link = kzalloc(sizeof(struct nfcsim_link), GFP_KERNEL);
  79         if (!link)
  80                 return NULL;
  81
  82         mutex_init(&link->lock);
  83         init_waitqueue_head(&link->recv_wait);
  84
  85         return link;
  86 }
  87
  88 static void nfcsim_link_free(struct nfcsim_link *link)
  89 {
  90         dev_kfree_skb(link->skb);
  91         kfree(link);
  92 }
  93
  94 static void nfcsim_link_recv_wake(struct nfcsim_link *link)
  95 {
  96         link->cond = 1;
  97         wake_up_interruptible(&link->recv_wait);
  98 }
  99
 100 static void nfcsim_link_set_skb(struct nfcsim_link *link, struct sk_buff *skb,
 101                                 u8 rf_tech, u8 mode)
 102 {
 103         mutex_lock(&link->lock);
 104
 105         dev_kfree_skb(link->skb);
 106         link->skb = skb;
 107         link->rf_tech = rf_tech;
 108         link->mode = mode;
 109
 110         mutex_unlock(&link->lock);
 111 }
 112
 113 static void nfcsim_link_recv_cancel(struct nfcsim_link *link)
 114 {
 115         mutex_lock(&link->lock);
 116
 117         link->mode = NFCSIM_MODE_NONE;
 118
 119         mutex_unlock(&link->lock);
 120
 121         nfcsim_link_recv_wake(link);
 122 }
 123
 124 static void nfcsim_link_shutdown(struct nfcsim_link *link)
 125 {
 126         mutex_lock(&link->lock);
 127
 128         link->shutdown = 1;
 129         link->mode = NFCSIM_MODE_NONE;
 130
 131         mutex_unlock(&link->lock);
 132
 133         nfcsim_link_recv_wake(link);
 134 }
 135
 136 static struct sk_buff *nfcsim_link_recv_skb(struct nfcsim_link *link,
 137                                             int timeout, u8 rf_tech, u8 mode)
 138 {
 139         int rc;
 140         struct sk_buff *skb;
 141
 142         rc = wait_event_interruptible_timeout(link->recv_wait,
 143                                               link->cond,
 144                                               msecs_to_jiffies(timeout));
 145
 146         mutex_lock(&link->lock);
 147
 148         skb = link->skb;
 149         link->skb = NULL;
 150
 151         if (!rc) {
 152                 rc = -ETIMEDOUT;
 153                 goto done;
 154         }
 155
 156         if (!skb || link->rf_tech != rf_tech || link->mode == mode) {
 157                 rc = -EINVAL;
 158                 goto done;
 159         }
 160
 161         if (link->shutdown) {
 162                 rc = -ENODEV;
 163                 goto done;
 164         }
 165
 166 done:
 167         mutex_unlock(&link->lock);
 168
 169         if (rc < 0) {
 170                 dev_kfree_skb(skb);
 171                 skb = ERR_PTR(rc);
 172         }
 173
 174         link->cond = 0;
 175
 176         return skb;
 177 }
 178
 179 static void nfcsim_send_wq(struct work_struct *work)
 180 {
 181         struct nfcsim *dev = container_of(work, struct nfcsim, send_work.work);
 182
 183         /*
 184          * To effectively send data, the device just wake up its link_out which
 185          * is the link_in of the peer device. The exchanged skb has already been
 186          * stored in the dev->link_out through nfcsim_link_set_skb().
 187          */
 188         nfcsim_link_recv_wake(dev->link_out);
 189 }
 190
 191 static void nfcsim_recv_wq(struct work_struct *work)
 192 {
 193         struct nfcsim *dev = container_of(work, struct nfcsim, recv_work);
 194         struct sk_buff *skb;
 195
 196         skb = nfcsim_link_recv_skb(dev->link_in, dev->recv_timeout,
 197                                    dev->rf_tech, dev->mode);
 198
 199         if (!dev->up) {
 200                 NFCSIM_ERR(dev, "Device is down\n");
 201
 202                 if (!IS_ERR(skb))
 203                         dev_kfree_skb(skb);
 204
 205                 skb = ERR_PTR(-ENODEV);
 206         }
 207
 208         dev->cb(dev->nfc_digital_dev, dev->arg, skb);
 209 }
 210
 211 static int nfcsim_send(struct nfc_digital_dev *ddev, struct sk_buff *skb,
 212                        u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
 213 {
 214         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
 215         u8 delay;
 216
 217         if (!dev->up) {
 218                 NFCSIM_ERR(dev, "Device is down\n");
 219                 return -ENODEV;
 220         }
 221
 222         dev->recv_timeout = timeout;
 223         dev->cb = cb;
 224         dev->arg = arg;
 225
 226         schedule_work(&dev->recv_work);
 227
 228         if (dev->dropframe) {
 229                 NFCSIM_DBG(dev, "dropping frame (out of %d)\n", dev->dropframe);
 230                 dev_kfree_skb(skb);
 231                 dev->dropframe--;
 232
 233                 return 0;
 234         }
 235
 236         if (skb) {
 237                 nfcsim_link_set_skb(dev->link_out, skb, dev->rf_tech,
 238                                     dev->mode);
 239
 240                 /* Add random delay (between 3 and 10 ms) before sending data */
 241                 get_random_bytes(&delay, 1);
 242                 delay = 3 + (delay & 0x07);
 243
 244                 schedule_delayed_work(&dev->send_work, msecs_to_jiffies(delay));
 245         }
 246
 247         return 0;
 248 }
 249
 250 static void nfcsim_abort_cmd(struct nfc_digital_dev *ddev)
 251 {
 252         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
 253
 254         nfcsim_link_recv_cancel(dev->link_in);
 255 }
 256
 257 static int nfcsim_switch_rf(struct nfc_digital_dev *ddev, bool on)
 258 {
 259         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
 260
 261         dev->up = on;
 262
 263         return 0;
 264 }
 265
 266 static int nfcsim_in_configure_hw(struct nfc_digital_dev *ddev,
 267                                           int type, int param)
 268 {
 269         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
 270
 271         switch (type) {
 272         case NFC_DIGITAL_CONFIG_RF_TECH:
 273                 dev->up = true;
 274                 dev->mode = NFCSIM_MODE_INITIATOR;
 275                 dev->rf_tech = param;
 276                 break;
 277
 278         case NFC_DIGITAL_CONFIG_FRAMING:
 279                 break;
 280
 281         default:
 282                 NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
 283                 return -EINVAL;
 284         }
 285
 286         return 0;
 287 }
 288
 289 static int nfcsim_in_send_cmd(struct nfc_digital_dev *ddev,
 290                                struct sk_buff *skb, u16 timeout,
 291                                nfc_digital_cmd_complete_t cb, void *arg)
 292 {
 293         return nfcsim_send(ddev, skb, timeout, cb, arg);
 294 }
 295
 296 static int nfcsim_tg_configure_hw(struct nfc_digital_dev *ddev,
 297                                           int type, int param)
 298 {
 299         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
 300
 301         switch (type) {
 302         case NFC_DIGITAL_CONFIG_RF_TECH:
 303                 dev->up = true;
 304                 dev->mode = NFCSIM_MODE_TARGET;
 305                 dev->rf_tech = param;
 306                 break;
 307
 308         case NFC_DIGITAL_CONFIG_FRAMING:
 309                 break;
 310
 311         default:
 312                 NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
 313                 return -EINVAL;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static int nfcsim_tg_send_cmd(struct nfc_digital_dev *ddev,
 320                                struct sk_buff *skb, u16 timeout,
 321                                nfc_digital_cmd_complete_t cb, void *arg)
 322 {
 323         return nfcsim_send(ddev, skb, timeout, cb, arg);
 324 }
 325
 326 static int nfcsim_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
 327                             nfc_digital_cmd_complete_t cb, void *arg)
 328 {
 329         return nfcsim_send(ddev, NULL, timeout, cb, arg);
 330 }
 331
 332 static struct nfc_digital_ops nfcsim_digital_ops = {
 333         .in_configure_hw = nfcsim_in_configure_hw,
 334         .in_send_cmd = nfcsim_in_send_cmd,
 335
 336         .tg_listen = nfcsim_tg_listen,
 337         .tg_configure_hw = nfcsim_tg_configure_hw,
 338         .tg_send_cmd = nfcsim_tg_send_cmd,
 339
 340         .abort_cmd = nfcsim_abort_cmd,
 341         .switch_rf = nfcsim_switch_rf,
 342 };
 343
 344 static struct dentry *nfcsim_debugfs_root;
 345
 346 static void nfcsim_debugfs_init(void)
 347 {
 348         nfcsim_debugfs_root = debugfs_create_dir("nfcsim", NULL);
 349
 350         if (!nfcsim_debugfs_root)
 351                 pr_err("Could not create debugfs entry\n");
 352
 353 }
 354
 355 static void nfcsim_debugfs_remove(void)
 356 {
 357         debugfs_remove_recursive(nfcsim_debugfs_root);
 358 }
 359
 360 static void nfcsim_debugfs_init_dev(struct nfcsim *dev)
 361 {
 362         struct dentry *dev_dir;
 363         char devname[5]; /* nfcX\0 */
 364         u32 idx;
 365         int n;
 366
 367         if (!nfcsim_debugfs_root) {
 368                 NFCSIM_ERR(dev, "nfcsim debugfs not initialized\n");
 369                 return;
 370         }
 371
 372         idx = dev->nfc_digital_dev->nfc_dev->idx;
 373         n = snprintf(devname, sizeof(devname), "nfc%d", idx);
 374         if (n >= sizeof(devname)) {
 375                 NFCSIM_ERR(dev, "Could not compute dev name for dev %d\n", idx);
 376                 return;
 377         }
 378
 379         dev_dir = debugfs_create_dir(devname, nfcsim_debugfs_root);
 380         if (!dev_dir) {
 381                 NFCSIM_ERR(dev, "Could not create debugfs entries for nfc%d\n",
 382                            idx);
 383                 return;
 384         }
 385
 386         debugfs_create_u8("dropframe", 0664, dev_dir, &dev->dropframe);
 387 }
 388
 389 static struct nfcsim *nfcsim_device_new(struct nfcsim_link *link_in,
 390                                         struct nfcsim_link *link_out)
 391 {
 392         struct nfcsim *dev;
 393         int rc;
 394
 395         dev = kzalloc(sizeof(struct nfcsim), GFP_KERNEL);
 396         if (!dev)
 397                 return ERR_PTR(-ENOMEM);
 398
 399         INIT_DELAYED_WORK(&dev->send_work, nfcsim_send_wq);
 400         INIT_WORK(&dev->recv_work, nfcsim_recv_wq);
 401
 402         dev->nfc_digital_dev =
 403                         nfc_digital_allocate_device(&nfcsim_digital_ops,
 404                                                     NFC_PROTO_NFC_DEP_MASK,
 405                                                     NFCSIM_CAPABILITIES,
 406                                                     0, 0);
 407         if (!dev->nfc_digital_dev) {
 408                 kfree(dev);
 409                 return ERR_PTR(-ENOMEM);
 410         }
 411
 412         nfc_digital_set_drvdata(dev->nfc_digital_dev, dev);
 413
 414         dev->link_in = link_in;
 415         dev->link_out = link_out;
 416
 417         rc = nfc_digital_register_device(dev->nfc_digital_dev);
 418         if (rc) {
 419                 pr_err("Could not register digital device (%d)\n", rc);
 420                 nfc_digital_free_device(dev->nfc_digital_dev);
 421                 kfree(dev);
 422
 423                 return ERR_PTR(rc);
 424         }
 425
 426         nfcsim_debugfs_init_dev(dev);
 427
 428         return dev;
 429 }
 430
 431 static void nfcsim_device_free(struct nfcsim *dev)
 432 {
 433         nfc_digital_unregister_device(dev->nfc_digital_dev);
 434
 435         dev->up = false;
 436
 437         nfcsim_link_shutdown(dev->link_in);
 438
 439         cancel_delayed_work_sync(&dev->send_work);
 440         cancel_work_sync(&dev->recv_work);
 441
 442         nfc_digital_free_device(dev->nfc_digital_dev);
 443
 444         kfree(dev);
 445 }
 446
 447 static struct nfcsim *dev0;
 448 static struct nfcsim *dev1;
 449
 450 static int __init nfcsim_init(void)
 451 {
 452         struct nfcsim_link *link0, *link1;
 453         int rc;
 454
 455         link0 = nfcsim_link_new();
 456         link1 = nfcsim_link_new();
 457         if (!link0 || !link1) {
 458                 rc = -ENOMEM;
 459                 goto exit_err;
 460         }
 461
 462         nfcsim_debugfs_init();
 463
 464         dev0 = nfcsim_device_new(link0, link1);
 465         if (IS_ERR(dev0)) {
 466                 rc = PTR_ERR(dev0);
 467                 goto exit_err;
 468         }
 469
 470         dev1 = nfcsim_device_new(link1, link0);
 471         if (IS_ERR(dev1)) {
 472                 nfcsim_device_free(dev0);
 473
 474                 rc = PTR_ERR(dev1);
 475                 goto exit_err;
 476         }
 477
 478         pr_info("nfcsim " NFCSIM_VERSION " initialized\n");
 479
 480         return 0;
 481
 482 exit_err:
 483         pr_err("Failed to initialize nfcsim driver (%d)\n", rc);
 484
 485         if (link0)
 486                 nfcsim_link_free(link0);
 487         if (link1)
 488                 nfcsim_link_free(link1);
 489
 490         return rc;
 491 }
 492
 493 static void __exit nfcsim_exit(void)
 494 {
 495         struct nfcsim_link *link0, *link1;
 496
 497         link0 = dev0->link_in;
 498         link1 = dev0->link_out;
 499
 500         nfcsim_device_free(dev0);
 501         nfcsim_device_free(dev1);
 502
 503         nfcsim_link_free(link0);
 504         nfcsim_link_free(link1);
 505
 506         nfcsim_debugfs_remove();
 507 }
 508
 509 module_init(nfcsim_init);
 510 module_exit(nfcsim_exit);
 511
 512 MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
 513 MODULE_VERSION(NFCSIM_VERSION);
 514 MODULE_LICENSE("GPL");