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