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/nfc.h>
  20 #include <net/nfc/nfc.h>
  21
  22 #define DEV_ERR(_dev, fmt, args...) nfc_err(&_dev->nfc_dev->dev, \
  23                                                 "%s: " fmt, __func__, ## args)
  24
  25 #define DEV_DBG(_dev, fmt, args...) dev_dbg(&_dev->nfc_dev->dev, \
  26                                                 "%s: " fmt, __func__, ## args)
  27
  28 #define NFCSIM_VERSION "0.1"
  29
  30 #define NFCSIM_POLL_NONE        0
  31 #define NFCSIM_POLL_INITIATOR   1
  32 #define NFCSIM_POLL_TARGET      2
  33 #define NFCSIM_POLL_DUAL        (NFCSIM_POLL_INITIATOR | NFCSIM_POLL_TARGET)
  34
  35 struct nfcsim {
  36         struct nfc_dev *nfc_dev;
  37
  38         struct mutex lock;
  39
  40         struct delayed_work recv_work;
  41
  42         struct sk_buff *clone_skb;
  43
  44         struct delayed_work poll_work;
  45         u8 polling_mode;
  46         u8 curr_polling_mode;
  47
  48         u8 shutting_down;
  49
  50         u8 up;
  51
  52         u8 initiator;
  53
  54         data_exchange_cb_t cb;
  55         void *cb_context;
  56
  57         struct nfcsim *peer_dev;
  58 };
  59
  60 static struct nfcsim *dev0;
  61 static struct nfcsim *dev1;
  62
  63 static struct workqueue_struct *wq;
  64
  65 static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown)
  66 {
  67         DEV_DBG(dev, "shutdown=%d\n", shutdown);
  68
  69         mutex_lock(&dev->lock);
  70
  71         dev->polling_mode = NFCSIM_POLL_NONE;
  72         dev->shutting_down = shutdown;
  73         dev->cb = NULL;
  74         dev_kfree_skb(dev->clone_skb);
  75         dev->clone_skb = NULL;
  76
  77         mutex_unlock(&dev->lock);
  78
  79         cancel_delayed_work_sync(&dev->poll_work);
  80         cancel_delayed_work_sync(&dev->recv_work);
  81 }
  82
  83 static int nfcsim_target_found(struct nfcsim *dev)
  84 {
  85         struct nfc_target nfc_tgt;
  86
  87         DEV_DBG(dev, "\n");
  88
  89         memset(&nfc_tgt, 0, sizeof(struct nfc_target));
  90
  91         nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  92         nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
  93
  94         return 0;
  95 }
  96
  97 static int nfcsim_dev_up(struct nfc_dev *nfc_dev)
  98 {
  99         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 100
 101         DEV_DBG(dev, "\n");
 102
 103         mutex_lock(&dev->lock);
 104
 105         dev->up = 1;
 106
 107         mutex_unlock(&dev->lock);
 108
 109         return 0;
 110 }
 111
 112 static int nfcsim_dev_down(struct nfc_dev *nfc_dev)
 113 {
 114         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 115
 116         DEV_DBG(dev, "\n");
 117
 118         mutex_lock(&dev->lock);
 119
 120         dev->up = 0;
 121
 122         mutex_unlock(&dev->lock);
 123
 124         return 0;
 125 }
 126
 127 static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev,
 128                               struct nfc_target *target,
 129                               u8 comm_mode, u8 *gb, size_t gb_len)
 130 {
 131         int rc;
 132         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 133         struct nfcsim *peer = dev->peer_dev;
 134         u8 *remote_gb;
 135         size_t remote_gb_len;
 136
 137         DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode);
 138
 139         mutex_lock(&peer->lock);
 140
 141         nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
 142                          NFC_COMM_ACTIVE, gb, gb_len);
 143
 144         remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len);
 145         if (!remote_gb) {
 146                 DEV_ERR(peer, "Can't get remote general bytes\n");
 147
 148                 mutex_unlock(&peer->lock);
 149                 return -EINVAL;
 150         }
 151
 152         mutex_unlock(&peer->lock);
 153
 154         mutex_lock(&dev->lock);
 155
 156         rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len);
 157         if (rc) {
 158                 DEV_ERR(dev, "Can't set remote general bytes\n");
 159                 mutex_unlock(&dev->lock);
 160                 return rc;
 161         }
 162
 163         rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE,
 164                                 NFC_RF_INITIATOR);
 165
 166         mutex_unlock(&dev->lock);
 167
 168         return rc;
 169 }
 170
 171 static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev)
 172 {
 173         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 174
 175         DEV_DBG(dev, "\n");
 176
 177         nfcsim_cleanup_dev(dev, 0);
 178
 179         return 0;
 180 }
 181
 182 static int nfcsim_start_poll(struct nfc_dev *nfc_dev,
 183                              u32 im_protocols, u32 tm_protocols)
 184 {
 185         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 186         int rc;
 187
 188         mutex_lock(&dev->lock);
 189
 190         if (dev->polling_mode != NFCSIM_POLL_NONE) {
 191                 DEV_ERR(dev, "Already in polling mode\n");
 192                 rc = -EBUSY;
 193                 goto exit;
 194         }
 195
 196         if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
 197                 dev->polling_mode |= NFCSIM_POLL_INITIATOR;
 198
 199         if (tm_protocols & NFC_PROTO_NFC_DEP_MASK)
 200                 dev->polling_mode |= NFCSIM_POLL_TARGET;
 201
 202         if (dev->polling_mode == NFCSIM_POLL_NONE) {
 203                 DEV_ERR(dev, "Unsupported polling mode\n");
 204                 rc = -EINVAL;
 205                 goto exit;
 206         }
 207
 208         dev->initiator = 0;
 209         dev->curr_polling_mode = NFCSIM_POLL_NONE;
 210
 211         queue_delayed_work(wq, &dev->poll_work, 0);
 212
 213         DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols,
 214                 tm_protocols);
 215
 216         rc = 0;
 217 exit:
 218         mutex_unlock(&dev->lock);
 219
 220         return rc;
 221 }
 222
 223 static void nfcsim_stop_poll(struct nfc_dev *nfc_dev)
 224 {
 225         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 226
 227         DEV_DBG(dev, "Stop poll\n");
 228
 229         mutex_lock(&dev->lock);
 230
 231         dev->polling_mode = NFCSIM_POLL_NONE;
 232
 233         mutex_unlock(&dev->lock);
 234
 235         cancel_delayed_work_sync(&dev->poll_work);
 236 }
 237
 238 static int nfcsim_activate_target(struct nfc_dev *nfc_dev,
 239                                   struct nfc_target *target, u32 protocol)
 240 {
 241         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 242
 243         DEV_DBG(dev, "\n");
 244
 245         return -ENOTSUPP;
 246 }
 247
 248 static void nfcsim_deactivate_target(struct nfc_dev *nfc_dev,
 249                                      struct nfc_target *target)
 250 {
 251         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 252
 253         DEV_DBG(dev, "\n");
 254 }
 255
 256 static void nfcsim_wq_recv(struct work_struct *work)
 257 {
 258         struct nfcsim *dev = container_of(work, struct nfcsim,
 259                                           recv_work.work);
 260
 261         mutex_lock(&dev->lock);
 262
 263         if (dev->shutting_down || !dev->up || !dev->clone_skb) {
 264                 dev_kfree_skb(dev->clone_skb);
 265                 goto exit;
 266         }
 267
 268         if (dev->initiator) {
 269                 if (!dev->cb) {
 270                         DEV_ERR(dev, "Null recv callback\n");
 271                         dev_kfree_skb(dev->clone_skb);
 272                         goto exit;
 273                 }
 274
 275                 dev->cb(dev->cb_context, dev->clone_skb, 0);
 276                 dev->cb = NULL;
 277         } else {
 278                 nfc_tm_data_received(dev->nfc_dev, dev->clone_skb);
 279         }
 280
 281 exit:
 282         dev->clone_skb = NULL;
 283
 284         mutex_unlock(&dev->lock);
 285 }
 286
 287 static int nfcsim_tx(struct nfc_dev *nfc_dev, struct nfc_target *target,
 288                      struct sk_buff *skb, data_exchange_cb_t cb,
 289                      void *cb_context)
 290 {
 291         struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
 292         struct nfcsim *peer = dev->peer_dev;
 293         int err;
 294
 295         mutex_lock(&dev->lock);
 296
 297         if (dev->shutting_down || !dev->up) {
 298                 mutex_unlock(&dev->lock);
 299                 err = -ENODEV;
 300                 goto exit;
 301         }
 302
 303         dev->cb = cb;
 304         dev->cb_context = cb_context;
 305
 306         mutex_unlock(&dev->lock);
 307
 308         mutex_lock(&peer->lock);
 309
 310         peer->clone_skb = skb_clone(skb, GFP_KERNEL);
 311
 312         if (!peer->clone_skb) {
 313                 DEV_ERR(dev, "skb_clone failed\n");
 314                 mutex_unlock(&peer->lock);
 315                 err = -ENOMEM;
 316                 goto exit;
 317         }
 318
 319         /* This simulates an arbitrary transmission delay between the 2 devices.
 320          * If packet transmission occurs immediately between them, we have a
 321          * non-stop flow of several tens of thousands SYMM packets per second
 322          * and a burning cpu.
 323          *
 324          * TODO: Add support for a sysfs entry to control this delay.
 325          */
 326         queue_delayed_work(wq, &peer->recv_work, msecs_to_jiffies(5));
 327
 328         mutex_unlock(&peer->lock);
 329
 330         err = 0;
 331 exit:
 332         dev_kfree_skb(skb);
 333
 334         return err;
 335 }
 336
 337 static int nfcsim_im_transceive(struct nfc_dev *nfc_dev,
 338                                 struct nfc_target *target, struct sk_buff *skb,
 339                                 data_exchange_cb_t cb, void *cb_context)
 340 {
 341         return nfcsim_tx(nfc_dev, target, skb, cb, cb_context);
 342 }
 343
 344 static int nfcsim_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
 345 {
 346         return nfcsim_tx(nfc_dev, NULL, skb, NULL, NULL);
 347 }
 348
 349 static struct nfc_ops nfcsim_nfc_ops = {
 350         .dev_up = nfcsim_dev_up,
 351         .dev_down = nfcsim_dev_down,
 352         .dep_link_up = nfcsim_dep_link_up,
 353         .dep_link_down = nfcsim_dep_link_down,
 354         .start_poll = nfcsim_start_poll,
 355         .stop_poll = nfcsim_stop_poll,
 356         .activate_target = nfcsim_activate_target,
 357         .deactivate_target = nfcsim_deactivate_target,
 358         .im_transceive = nfcsim_im_transceive,
 359         .tm_send = nfcsim_tm_send,
 360 };
 361
 362 static void nfcsim_set_polling_mode(struct nfcsim *dev)
 363 {
 364         if (dev->polling_mode == NFCSIM_POLL_NONE) {
 365                 dev->curr_polling_mode = NFCSIM_POLL_NONE;
 366                 return;
 367         }
 368
 369         if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
 370                 if (dev->polling_mode & NFCSIM_POLL_INITIATOR)
 371                         dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
 372                 else
 373                         dev->curr_polling_mode = NFCSIM_POLL_TARGET;
 374
 375                 return;
 376         }
 377
 378         if (dev->polling_mode == NFCSIM_POLL_DUAL) {
 379                 if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
 380                         dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
 381                 else
 382                         dev->curr_polling_mode = NFCSIM_POLL_TARGET;
 383         }
 384 }
 385
 386 static void nfcsim_wq_poll(struct work_struct *work)
 387 {
 388         struct nfcsim *dev = container_of(work, struct nfcsim, poll_work.work);
 389         struct nfcsim *peer = dev->peer_dev;
 390
 391         /* These work items run on an ordered workqueue and are therefore
 392          * serialized. So we can take both mutexes without being dead locked.
 393          */
 394         mutex_lock(&dev->lock);
 395         mutex_lock(&peer->lock);
 396
 397         nfcsim_set_polling_mode(dev);
 398
 399         if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
 400                 DEV_DBG(dev, "Not polling\n");
 401                 goto unlock;
 402         }
 403
 404         DEV_DBG(dev, "Polling as %s",
 405                 dev->curr_polling_mode == NFCSIM_POLL_INITIATOR ?
 406                 "initiator\n" : "target\n");
 407
 408         if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
 409                 goto sched_work;
 410
 411         if (peer->curr_polling_mode == NFCSIM_POLL_TARGET) {
 412                 peer->polling_mode = NFCSIM_POLL_NONE;
 413                 dev->polling_mode = NFCSIM_POLL_NONE;
 414
 415                 dev->initiator = 1;
 416
 417                 nfcsim_target_found(dev);
 418
 419                 goto unlock;
 420         }
 421
 422 sched_work:
 423         /* This defines the delay for an initiator to check if the other device
 424          * is polling in target mode.
 425          * If the device starts in dual mode polling, it switches between
 426          * initiator and target at every round.
 427          * Because the wq is ordered and only 1 work item is executed at a time,
 428          * we'll always have one device polling as initiator and the other as
 429          * target at some point, even if both are started in dual mode.
 430          */
 431         queue_delayed_work(wq, &dev->poll_work, msecs_to_jiffies(200));
 432
 433 unlock:
 434         mutex_unlock(&peer->lock);
 435         mutex_unlock(&dev->lock);
 436 }
 437
 438 static struct nfcsim *nfcsim_init_dev(void)
 439 {
 440         struct nfcsim *dev;
 441         int rc = -ENOMEM;
 442
 443         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 444         if (dev == NULL)
 445                 return ERR_PTR(-ENOMEM);
 446
 447         mutex_init(&dev->lock);
 448
 449         INIT_DELAYED_WORK(&dev->recv_work, nfcsim_wq_recv);
 450         INIT_DELAYED_WORK(&dev->poll_work, nfcsim_wq_poll);
 451
 452         dev->nfc_dev = nfc_allocate_device(&nfcsim_nfc_ops,
 453                                            NFC_PROTO_NFC_DEP_MASK,
 454                                            0, 0);
 455         if (!dev->nfc_dev)
 456                 goto error;
 457
 458         nfc_set_drvdata(dev->nfc_dev, dev);
 459
 460         rc = nfc_register_device(dev->nfc_dev);
 461         if (rc)
 462                 goto free_nfc_dev;
 463
 464         return dev;
 465
 466 free_nfc_dev:
 467         nfc_free_device(dev->nfc_dev);
 468
 469 error:
 470         kfree(dev);
 471
 472         return ERR_PTR(rc);
 473 }
 474
 475 static void nfcsim_free_device(struct nfcsim *dev)
 476 {
 477         nfc_unregister_device(dev->nfc_dev);
 478
 479         nfc_free_device(dev->nfc_dev);
 480
 481         kfree(dev);
 482 }
 483
 484 static int __init nfcsim_init(void)
 485 {
 486         int rc;
 487
 488         /* We need an ordered wq to ensure that poll_work items are executed
 489          * one at a time.
 490          */
 491         wq = alloc_ordered_workqueue("nfcsim", 0);
 492         if (!wq) {
 493                 rc = -ENOMEM;
 494                 goto exit;
 495         }
 496
 497         dev0 = nfcsim_init_dev();
 498         if (IS_ERR(dev0)) {
 499                 rc = PTR_ERR(dev0);
 500                 goto exit;
 501         }
 502
 503         dev1 = nfcsim_init_dev();
 504         if (IS_ERR(dev1)) {
 505                 kfree(dev0);
 506
 507                 rc = PTR_ERR(dev1);
 508                 goto exit;
 509         }
 510
 511         dev0->peer_dev = dev1;
 512         dev1->peer_dev = dev0;
 513
 514         pr_debug("NFCsim " NFCSIM_VERSION " initialized\n");
 515
 516         rc = 0;
 517 exit:
 518         if (rc)
 519                 pr_err("Failed to initialize nfcsim driver (%d)\n",
 520                        rc);
 521
 522         return rc;
 523 }
 524
 525 static void __exit nfcsim_exit(void)
 526 {
 527         nfcsim_cleanup_dev(dev0, 1);
 528         nfcsim_cleanup_dev(dev1, 1);
 529
 530         nfcsim_free_device(dev0);
 531         nfcsim_free_device(dev1);
 532
 533         destroy_workqueue(wq);
 534 }
 535
 536 module_init(nfcsim_init);
 537 module_exit(nfcsim_exit);
 538
 539 MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
 540 MODULE_VERSION(NFCSIM_VERSION);
 541 MODULE_LICENSE("GPL");