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