core.c 24.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright (C) 2011 Instituto Nokia de Tecnologia
 *
 * Authors:
 *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
 *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

24
#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
25

26 27 28 29
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
S
Samuel Ortiz 已提交
30
#include <linux/rfkill.h>
31
#include <linux/nfc.h>
32

33 34
#include <net/genetlink.h>

35 36 37 38
#include "nfc.h"

#define VERSION "0.1"

39 40
#define NFC_CHECK_PRES_FREQ_MS	2000

41 42 43
int nfc_devlist_generation;
DEFINE_MUTEX(nfc_devlist_mutex);

44 45 46
/* NFC device ID bitmap */
static DEFINE_IDA(nfc_index_ida);

47
int nfc_fw_download(struct nfc_dev *dev, const char *firmware_name)
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
{
	int rc = 0;

	pr_debug("%s do firmware %s\n", dev_name(&dev->dev), firmware_name);

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (dev->dev_up) {
		rc = -EBUSY;
		goto error;
	}

65
	if (!dev->ops->fw_download) {
66 67 68 69
		rc = -EOPNOTSUPP;
		goto error;
	}

70 71
	dev->fw_download_in_progress = true;
	rc = dev->ops->fw_download(dev, firmware_name);
72
	if (rc)
73
		dev->fw_download_in_progress = false;
74 75 76 77 78 79

error:
	device_unlock(&dev->dev);
	return rc;
}

80 81 82 83 84 85 86 87 88
/**
 * nfc_fw_download_done - inform that a firmware download was completed
 *
 * @dev: The nfc device to which firmware was downloaded
 * @firmware_name: The firmware filename
 * @result: The positive value of a standard errno value
 */
int nfc_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
			 u32 result)
89
{
90
	dev->fw_download_in_progress = false;
91

92
	return nfc_genl_fw_download_done(dev, firmware_name, result);
93
}
94
EXPORT_SYMBOL(nfc_fw_download_done);
95

96 97 98 99 100 101 102 103 104 105 106
/**
 * nfc_dev_up - turn on the NFC device
 *
 * @dev: The nfc device to be turned on
 *
 * The device remains up until the nfc_dev_down function is called.
 */
int nfc_dev_up(struct nfc_dev *dev)
{
	int rc = 0;

107
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
108 109 110

	device_lock(&dev->dev);

S
Samuel Ortiz 已提交
111 112 113 114 115
	if (dev->rfkill && rfkill_blocked(dev->rfkill)) {
		rc = -ERFKILL;
		goto error;
	}

116 117 118 119 120
	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

121
	if (dev->fw_download_in_progress) {
122 123 124 125
		rc = -EBUSY;
		goto error;
	}

126 127 128 129 130 131 132 133 134 135 136
	if (dev->dev_up) {
		rc = -EALREADY;
		goto error;
	}

	if (dev->ops->dev_up)
		rc = dev->ops->dev_up(dev);

	if (!rc)
		dev->dev_up = true;

137 138 139
	/* We have to enable the device before discovering SEs */
	if (dev->ops->discover_se) {
		rc = dev->ops->discover_se(dev);
140
		if (rc)
141 142 143
			pr_warn("SE discovery failed\n");
	}

144 145 146 147 148 149 150 151 152 153 154 155 156 157
error:
	device_unlock(&dev->dev);
	return rc;
}

/**
 * nfc_dev_down - turn off the NFC device
 *
 * @dev: The nfc device to be turned off
 */
int nfc_dev_down(struct nfc_dev *dev)
{
	int rc = 0;

158
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
159 160 161 162 163 164 165 166 167 168 169 170 171

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (!dev->dev_up) {
		rc = -EALREADY;
		goto error;
	}

172
	if (dev->polling || dev->active_target) {
173 174 175 176 177 178 179 180 181 182 183 184 185 186
		rc = -EBUSY;
		goto error;
	}

	if (dev->ops->dev_down)
		dev->ops->dev_down(dev);

	dev->dev_up = false;

error:
	device_unlock(&dev->dev);
	return rc;
}

S
Samuel Ortiz 已提交
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
static int nfc_rfkill_set_block(void *data, bool blocked)
{
	struct nfc_dev *dev = data;

	pr_debug("%s blocked %d", dev_name(&dev->dev), blocked);

	if (!blocked)
		return 0;

	nfc_dev_down(dev);

	return 0;
}

static const struct rfkill_ops nfc_rfkill_ops = {
	.set_block = nfc_rfkill_set_block,
};

205 206 207 208 209 210 211 212 213
/**
 * nfc_start_poll - start polling for nfc targets
 *
 * @dev: The nfc device that must start polling
 * @protocols: bitset of nfc protocols that must be used for polling
 *
 * The device remains polling for targets until a target is found or
 * the nfc_stop_poll function is called.
 */
214
int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols)
215 216 217
{
	int rc;

218 219
	pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n",
		 dev_name(&dev->dev), im_protocols, tm_protocols);
220

221
	if (!im_protocols && !tm_protocols)
222 223 224 225 226 227 228 229 230
		return -EINVAL;

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

231 232 233 234 235
	if (!dev->dev_up) {
		rc = -ENODEV;
		goto error;
	}

236 237 238 239 240
	if (dev->polling) {
		rc = -EBUSY;
		goto error;
	}

241
	rc = dev->ops->start_poll(dev, im_protocols, tm_protocols);
242
	if (!rc) {
243
		dev->polling = true;
244 245
		dev->rf_mode = NFC_RF_NONE;
	}
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260

error:
	device_unlock(&dev->dev);
	return rc;
}

/**
 * nfc_stop_poll - stop polling for nfc targets
 *
 * @dev: The nfc device that must stop polling
 */
int nfc_stop_poll(struct nfc_dev *dev)
{
	int rc = 0;

261
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (!dev->polling) {
		rc = -EINVAL;
		goto error;
	}

	dev->ops->stop_poll(dev);
	dev->polling = false;
277
	dev->rf_mode = NFC_RF_NONE;
278 279 280 281 282 283

error:
	device_unlock(&dev->dev);
	return rc;
}

284 285 286 287 288 289 290
static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx)
{
	int i;

	if (dev->n_targets == 0)
		return NULL;

291
	for (i = 0; i < dev->n_targets; i++) {
292 293 294 295 296 297 298
		if (dev->targets[i].idx == target_idx)
			return &dev->targets[i];
	}

	return NULL;
}

299
int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
300 301
{
	int rc = 0;
302 303
	u8 *gb;
	size_t gb_len;
304
	struct nfc_target *target;
305

306
	pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

	if (!dev->ops->dep_link_up)
		return -EOPNOTSUPP;

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (dev->dep_link_up == true) {
		rc = -EALREADY;
		goto error;
	}

323 324 325 326 327 328
	gb = nfc_llcp_general_bytes(dev, &gb_len);
	if (gb_len > NFC_MAX_GT_LEN) {
		rc = -EINVAL;
		goto error;
	}

329 330 331 332 333 334 335
	target = nfc_find_target(dev, target_index);
	if (target == NULL) {
		rc = -ENOTCONN;
		goto error;
	}

	rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len);
336
	if (!rc) {
337
		dev->active_target = target;
338 339
		dev->rf_mode = NFC_RF_INITIATOR;
	}
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369

error:
	device_unlock(&dev->dev);
	return rc;
}

int nfc_dep_link_down(struct nfc_dev *dev)
{
	int rc = 0;

	pr_debug("dev_name=%s\n", dev_name(&dev->dev));

	if (!dev->ops->dep_link_down)
		return -EOPNOTSUPP;

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (dev->dep_link_up == false) {
		rc = -EALREADY;
		goto error;
	}

	rc = dev->ops->dep_link_down(dev);
	if (!rc) {
		dev->dep_link_up = false;
370
		dev->active_target = NULL;
371
		dev->rf_mode = NFC_RF_NONE;
S
Samuel Ortiz 已提交
372
		nfc_llcp_mac_is_down(dev);
373 374 375 376 377
		nfc_genl_dep_link_down_event(dev);
	}

error:
	device_unlock(&dev->dev);
378

379 380 381 382
	return rc;
}

int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
383
		       u8 comm_mode, u8 rf_mode)
384 385 386
{
	dev->dep_link_up = true;

S
Samuel Ortiz 已提交
387 388
	nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);

389 390 391 392
	return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);
}
EXPORT_SYMBOL(nfc_dep_link_is_up);

393 394 395 396 397 398 399 400 401 402
/**
 * nfc_activate_target - prepare the target for data exchange
 *
 * @dev: The nfc device that found the target
 * @target_idx: index of the target that must be activated
 * @protocol: nfc protocol that will be used for data exchange
 */
int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
{
	int rc;
403
	struct nfc_target *target;
404

405 406
	pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
		 dev_name(&dev->dev), target_idx, protocol);
407 408 409 410 411 412 413 414

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

415 416 417 418 419 420 421 422 423 424 425 426
	if (dev->active_target) {
		rc = -EBUSY;
		goto error;
	}

	target = nfc_find_target(dev, target_idx);
	if (target == NULL) {
		rc = -ENOTCONN;
		goto error;
	}

	rc = dev->ops->activate_target(dev, target, protocol);
427
	if (!rc) {
428
		dev->active_target = target;
429
		dev->rf_mode = NFC_RF_INITIATOR;
430

431
		if (dev->ops->check_presence && !dev->shutting_down)
432 433 434
			mod_timer(&dev->check_pres_timer, jiffies +
				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
	}
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

error:
	device_unlock(&dev->dev);
	return rc;
}

/**
 * nfc_deactivate_target - deactivate a nfc target
 *
 * @dev: The nfc device that found the target
 * @target_idx: index of the target that must be deactivated
 */
int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
{
	int rc = 0;

451 452
	pr_debug("dev_name=%s target_idx=%u\n",
		 dev_name(&dev->dev), target_idx);
453 454 455 456 457 458 459 460

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

461 462 463 464 465 466 467 468 469 470
	if (dev->active_target == NULL) {
		rc = -ENOTCONN;
		goto error;
	}

	if (dev->active_target->idx != target_idx) {
		rc = -ENOTCONN;
		goto error;
	}

471 472 473
	if (dev->ops->check_presence)
		del_timer_sync(&dev->check_pres_timer);

474 475
	dev->ops->deactivate_target(dev, dev->active_target);
	dev->active_target = NULL;
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492

error:
	device_unlock(&dev->dev);
	return rc;
}

/**
 * nfc_data_exchange - transceive data
 *
 * @dev: The nfc device that found the target
 * @target_idx: index of the target
 * @skb: data to be sent
 * @cb: callback called when the response is received
 * @cb_context: parameter for the callback function
 *
 * The user must wait for the callback before calling this function again.
 */
493 494
int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
		      data_exchange_cb_t cb, void *cb_context)
495 496 497
{
	int rc;

498 499
	pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
		 dev_name(&dev->dev), target_idx, skb->len);
500 501 502 503 504 505 506 507 508

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		kfree_skb(skb);
		goto error;
	}

509 510 511 512 513 514
	if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) {
		if (dev->active_target->idx != target_idx) {
			rc = -EADDRNOTAVAIL;
			kfree_skb(skb);
			goto error;
		}
515

516 517 518 519 520 521
		if (dev->ops->check_presence)
			del_timer_sync(&dev->check_pres_timer);

		rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb,
					     cb_context);

522
		if (!rc && dev->ops->check_presence && !dev->shutting_down)
523 524 525 526 527 528
			mod_timer(&dev->check_pres_timer, jiffies +
				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
	} else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) {
		rc = dev->ops->tm_send(dev, skb);
	} else {
		rc = -ENOTCONN;
529 530 531 532
		kfree_skb(skb);
		goto error;
	}

533

534 535 536 537 538
error:
	device_unlock(&dev->dev);
	return rc;
}

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
static struct nfc_se *find_se(struct nfc_dev *dev, u32 se_idx)
{
	struct nfc_se *se, *n;

	list_for_each_entry_safe(se, n, &dev->secure_elements, list)
		if (se->idx == se_idx)
			return se;

	return NULL;
}

int nfc_enable_se(struct nfc_dev *dev, u32 se_idx)
{

	struct nfc_se *se;
	int rc;

	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (!dev->dev_up) {
		rc = -ENODEV;
		goto error;
	}

	if (dev->polling) {
		rc = -EBUSY;
		goto error;
	}

	if (!dev->ops->enable_se || !dev->ops->disable_se) {
		rc = -EOPNOTSUPP;
		goto error;
	}

	se = find_se(dev, se_idx);
	if (!se) {
		rc = -EINVAL;
		goto error;
	}

586
	if (se->state == NFC_SE_ENABLED) {
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
		rc = -EALREADY;
		goto error;
	}

	rc = dev->ops->enable_se(dev, se_idx);

error:
	device_unlock(&dev->dev);
	return rc;
}

int nfc_disable_se(struct nfc_dev *dev, u32 se_idx)
{

	struct nfc_se *se;
	int rc;

	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);

	device_lock(&dev->dev);

	if (!device_is_registered(&dev->dev)) {
		rc = -ENODEV;
		goto error;
	}

	if (!dev->dev_up) {
		rc = -ENODEV;
		goto error;
	}

	if (!dev->ops->enable_se || !dev->ops->disable_se) {
		rc = -EOPNOTSUPP;
		goto error;
	}

	se = find_se(dev, se_idx);
	if (!se) {
		rc = -EINVAL;
		goto error;
	}

629
	if (se->state == NFC_SE_DISABLED) {
630 631 632 633 634 635 636 637 638 639 640
		rc = -EALREADY;
		goto error;
	}

	rc = dev->ops->disable_se(dev, se_idx);

error:
	device_unlock(&dev->dev);
	return rc;
}

641 642
int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len)
{
643
	pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
644 645 646 647

	if (gb_len > NFC_MAX_GT_LEN)
		return -EINVAL;

S
Samuel Ortiz 已提交
648
	return nfc_llcp_set_remote_gb(dev, gb, gb_len);
649 650 651
}
EXPORT_SYMBOL(nfc_set_remote_general_bytes);

652 653 654 655 656 657 658 659
u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len)
{
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));

	return nfc_llcp_general_bytes(dev, gb_len);
}
EXPORT_SYMBOL(nfc_get_local_general_bytes);

660 661 662 663 664 665 666 667 668 669 670 671
int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb)
{
	/* Only LLCP target mode for now */
	if (dev->dep_link_up == false) {
		kfree_skb(skb);
		return -ENOLINK;
	}

	return nfc_llcp_data_received(dev, skb);
}
EXPORT_SYMBOL(nfc_tm_data_received);

672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode,
		     u8 *gb, size_t gb_len)
{
	int rc;

	device_lock(&dev->dev);

	dev->polling = false;

	if (gb != NULL) {
		rc = nfc_set_remote_general_bytes(dev, gb, gb_len);
		if (rc < 0)
			goto out;
	}

687 688
	dev->rf_mode = NFC_RF_TARGET;

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
	if (protocol == NFC_PROTO_NFC_DEP_MASK)
		nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET);

	rc = nfc_genl_tm_activated(dev, protocol);

out:
	device_unlock(&dev->dev);

	return rc;
}
EXPORT_SYMBOL(nfc_tm_activated);

int nfc_tm_deactivated(struct nfc_dev *dev)
{
	dev->dep_link_up = false;
704
	dev->rf_mode = NFC_RF_NONE;
705 706 707 708 709

	return nfc_genl_tm_deactivated(dev);
}
EXPORT_SYMBOL(nfc_tm_deactivated);

710
/**
711
 * nfc_alloc_send_skb - allocate a skb for data exchange responses
712 713 714 715
 *
 * @size: size to allocate
 * @gfp: gfp flags
 */
716
struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
717 718
				   unsigned int flags, unsigned int size,
				   unsigned int *err)
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
{
	struct sk_buff *skb;
	unsigned int total_size;

	total_size = size +
		dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;

	skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err);
	if (skb)
		skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);

	return skb;
}

/**
 * nfc_alloc_recv_skb - allocate a skb for data exchange responses
 *
 * @size: size to allocate
 * @gfp: gfp flags
 */
struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp)
740 741 742 743 744 745 746 747 748 749 750 751
{
	struct sk_buff *skb;
	unsigned int total_size;

	total_size = size + 1;
	skb = alloc_skb(total_size, gfp);

	if (skb)
		skb_reserve(skb, 1);

	return skb;
}
752
EXPORT_SYMBOL(nfc_alloc_recv_skb);
753

754 755 756 757 758 759 760 761 762 763
/**
 * nfc_targets_found - inform that targets were found
 *
 * @dev: The nfc device that found the targets
 * @targets: array of nfc targets found
 * @ntargets: targets array size
 *
 * The device driver must call this function when one or many nfc targets
 * are found. After calling this function, the device driver must stop
 * polling for targets.
764 765
 * NOTE: This function can be called with targets=NULL and n_targets=0 to
 * notify a driver error, meaning that the polling operation cannot complete.
766 767 768
 * IMPORTANT: this function must not be called from an atomic context.
 * In addition, it must also not be called from a context that would prevent
 * the NFC Core to call other nfc ops entry point concurrently.
769
 */
770 771
int nfc_targets_found(struct nfc_dev *dev,
		      struct nfc_target *targets, int n_targets)
772
{
773 774
	int i;

775
	pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
776

777
	for (i = 0; i < n_targets; i++)
778
		targets[i].idx = dev->target_next_idx++;
779

780
	device_lock(&dev->dev);
781

782 783 784 785 786 787 788
	if (dev->polling == false) {
		device_unlock(&dev->dev);
		return 0;
	}

	dev->polling = false;

789 790 791
	dev->targets_generation++;

	kfree(dev->targets);
792
	dev->targets = NULL;
793

794 795 796 797 798 799 800 801 802 803
	if (targets) {
		dev->targets = kmemdup(targets,
				       n_targets * sizeof(struct nfc_target),
				       GFP_ATOMIC);

		if (!dev->targets) {
			dev->n_targets = 0;
			device_unlock(&dev->dev);
			return -ENOMEM;
		}
804 805 806
	}

	dev->n_targets = n_targets;
807
	device_unlock(&dev->dev);
808 809 810 811 812 813 814

	nfc_genl_targets_found(dev);

	return 0;
}
EXPORT_SYMBOL(nfc_targets_found);

815 816 817 818 819 820 821 822 823 824 825 826
/**
 * nfc_target_lost - inform that an activated target went out of field
 *
 * @dev: The nfc device that had the activated target in field
 * @target_idx: the nfc index of the target
 *
 * The device driver must call this function when the activated target
 * goes out of the field.
 * IMPORTANT: this function must not be called from an atomic context.
 * In addition, it must also not be called from a context that would prevent
 * the NFC Core to call other nfc ops entry point concurrently.
 */
827 828 829 830 831 832 833
int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
{
	struct nfc_target *tg;
	int i;

	pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);

834
	device_lock(&dev->dev);
835 836 837 838 839 840 841 842

	for (i = 0; i < dev->n_targets; i++) {
		tg = &dev->targets[i];
		if (tg->idx == target_idx)
			break;
	}

	if (i == dev->n_targets) {
843
		device_unlock(&dev->dev);
844 845 846 847 848
		return -EINVAL;
	}

	dev->targets_generation++;
	dev->n_targets--;
849
	dev->active_target = NULL;
850 851 852 853 854 855 856 857 858

	if (dev->n_targets) {
		memcpy(&dev->targets[i], &dev->targets[i + 1],
		       (dev->n_targets - i) * sizeof(struct nfc_target));
	} else {
		kfree(dev->targets);
		dev->targets = NULL;
	}

859
	device_unlock(&dev->dev);
860 861 862 863 864 865 866

	nfc_genl_target_lost(dev, target_idx);

	return 0;
}
EXPORT_SYMBOL(nfc_target_lost);

867
inline void nfc_driver_failure(struct nfc_dev *dev, int err)
E
Eric Lapuyade 已提交
868
{
869
	nfc_targets_found(dev, NULL, 0);
E
Eric Lapuyade 已提交
870 871 872
}
EXPORT_SYMBOL(nfc_driver_failure);

873 874
int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type)
{
875
	struct nfc_se *se;
876
	int rc;
877 878 879

	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);

880 881 882
	se = find_se(dev, se_idx);
	if (se)
		return -EALREADY;
883 884 885 886 887 888 889 890 891 892 893 894

	se = kzalloc(sizeof(struct nfc_se), GFP_KERNEL);
	if (!se)
		return -ENOMEM;

	se->idx = se_idx;
	se->type = type;
	se->state = NFC_SE_DISABLED;
	INIT_LIST_HEAD(&se->list);

	list_add(&se->list, &dev->secure_elements);

895 896 897 898 899 900 901 902
	rc = nfc_genl_se_added(dev, se_idx, type);
	if (rc < 0) {
		list_del(&se->list);
		kfree(se);

		return rc;
	}

903 904 905 906 907 908 909
	return 0;
}
EXPORT_SYMBOL(nfc_add_se);

int nfc_remove_se(struct nfc_dev *dev, u32 se_idx)
{
	struct nfc_se *se, *n;
910
	int rc;
911 912 913 914 915

	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);

	list_for_each_entry_safe(se, n, &dev->secure_elements, list)
		if (se->idx == se_idx) {
916 917 918 919
			rc = nfc_genl_se_removed(dev, se_idx);
			if (rc < 0)
				return rc;

920 921 922 923 924 925 926 927 928 929
			list_del(&se->list);
			kfree(se);

			return 0;
		}

	return -EINVAL;
}
EXPORT_SYMBOL(nfc_remove_se);

930 931 932
static void nfc_release(struct device *d)
{
	struct nfc_dev *dev = to_nfc_dev(d);
933
	struct nfc_se *se, *n;
934

935
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
936

937 938
	nfc_genl_data_exit(&dev->genl_data);
	kfree(dev->targets);
939 940 941 942 943 944 945

	list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
			nfc_genl_se_removed(dev, se->idx);
			list_del(&se->list);
			kfree(se);
	}

946 947 948
	kfree(dev);
}

949 950 951 952 953 954 955 956
static void nfc_check_pres_work(struct work_struct *work)
{
	struct nfc_dev *dev = container_of(work, struct nfc_dev,
					   check_pres_work);
	int rc;

	device_lock(&dev->dev);

957 958
	if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) {
		rc = dev->ops->check_presence(dev, dev->active_target);
959 960
		if (rc == -EOPNOTSUPP)
			goto exit;
961
		if (rc) {
962 963 964 965
			u32 active_target_idx = dev->active_target->idx;
			device_unlock(&dev->dev);
			nfc_target_lost(dev, active_target_idx);
			return;
966
		}
967 968 969 970

		if (!dev->shutting_down)
			mod_timer(&dev->check_pres_timer, jiffies +
				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
971 972
	}

973
exit:
974 975 976 977 978 979 980
	device_unlock(&dev->dev);
}

static void nfc_check_pres_timeout(unsigned long data)
{
	struct nfc_dev *dev = (struct nfc_dev *)data;

981
	schedule_work(&dev->check_pres_work);
982 983
}

984 985 986 987 988 989
struct class nfc_class = {
	.name = "nfc",
	.dev_release = nfc_release,
};
EXPORT_SYMBOL(nfc_class);

990
static int match_idx(struct device *d, const void *data)
991 992
{
	struct nfc_dev *dev = to_nfc_dev(d);
993
	const unsigned int *idx = data;
994 995 996 997

	return dev->idx == *idx;
}

998
struct nfc_dev *nfc_get_device(unsigned int idx)
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
{
	struct device *d;

	d = class_find_device(&nfc_class, NULL, &idx, match_idx);
	if (!d)
		return NULL;

	return to_nfc_dev(d);
}

/**
 * nfc_allocate_device - allocate a new nfc device
 *
 * @ops: device operations
 * @supported_protocols: NFC protocols supported by the device
 */
struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
1016 1017
				    u32 supported_protocols,
				    int tx_headroom, int tx_tailroom)
1018 1019 1020 1021
{
	struct nfc_dev *dev;

	if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
1022
	    !ops->deactivate_target || !ops->im_transceive)
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
		return NULL;

	if (!supported_protocols)
		return NULL;

	dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
	if (!dev)
		return NULL;

	dev->ops = ops;
	dev->supported_protocols = supported_protocols;
1034 1035
	dev->tx_headroom = tx_headroom;
	dev->tx_tailroom = tx_tailroom;
1036
	INIT_LIST_HEAD(&dev->secure_elements);
1037

1038 1039
	nfc_genl_data_init(&dev->genl_data);

1040
	dev->rf_mode = NFC_RF_NONE;
1041

1042 1043 1044
	/* first generation must not be 0 */
	dev->targets_generation = 1;

1045 1046 1047 1048 1049 1050 1051 1052
	if (ops->check_presence) {
		init_timer(&dev->check_pres_timer);
		dev->check_pres_timer.data = (unsigned long)dev;
		dev->check_pres_timer.function = nfc_check_pres_timeout;

		INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
	}

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
	return dev;
}
EXPORT_SYMBOL(nfc_allocate_device);

/**
 * nfc_register_device - register a nfc device in the nfc subsystem
 *
 * @dev: The nfc device to register
 */
int nfc_register_device(struct nfc_dev *dev)
{
	int rc;

1066
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1067

1068 1069 1070 1071 1072 1073 1074 1075
	dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL);
	if (dev->idx < 0)
		return dev->idx;

	dev->dev.class = &nfc_class;
	dev_set_name(&dev->dev, "nfc%d", dev->idx);
	device_initialize(&dev->dev);

1076 1077 1078 1079 1080
	mutex_lock(&nfc_devlist_mutex);
	nfc_devlist_generation++;
	rc = device_add(&dev->dev);
	mutex_unlock(&nfc_devlist_mutex);

1081 1082 1083
	if (rc < 0)
		return rc;

S
Samuel Ortiz 已提交
1084 1085 1086 1087
	rc = nfc_llcp_register_device(dev);
	if (rc)
		pr_err("Could not register llcp device\n");

1088 1089
	rc = nfc_genl_device_added(dev);
	if (rc)
1090 1091
		pr_debug("The userspace won't be notified that the device %s was added\n",
			 dev_name(&dev->dev));
1092

S
Samuel Ortiz 已提交
1093 1094 1095 1096 1097 1098 1099 1100 1101
	dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev,
				   RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev);
	if (dev->rfkill) {
		if (rfkill_register(dev->rfkill) < 0) {
			rfkill_destroy(dev->rfkill);
			dev->rfkill = NULL;
		}
	}

1102
	return 0;
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
}
EXPORT_SYMBOL(nfc_register_device);

/**
 * nfc_unregister_device - unregister a nfc device in the nfc subsystem
 *
 * @dev: The nfc device to unregister
 */
void nfc_unregister_device(struct nfc_dev *dev)
{
1113
	int rc, id;
1114

1115
	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1116

1117 1118
	id = dev->idx;

S
Samuel Ortiz 已提交
1119 1120 1121 1122 1123
	if (dev->rfkill) {
		rfkill_unregister(dev->rfkill);
		rfkill_destroy(dev->rfkill);
	}

1124 1125 1126 1127 1128 1129 1130
	if (dev->ops->check_presence) {
		device_lock(&dev->dev);
		dev->shutting_down = true;
		device_unlock(&dev->dev);
		del_timer_sync(&dev->check_pres_timer);
		cancel_work_sync(&dev->check_pres_work);
	}
1131

1132 1133 1134 1135
	rc = nfc_genl_device_removed(dev);
	if (rc)
		pr_debug("The userspace won't be notified that the device %s "
			 "was removed\n", dev_name(&dev->dev));
1136

S
Samuel Ortiz 已提交
1137 1138
	nfc_llcp_unregister_device(dev);

1139 1140 1141 1142
	mutex_lock(&nfc_devlist_mutex);
	nfc_devlist_generation++;
	device_del(&dev->dev);
	mutex_unlock(&nfc_devlist_mutex);
1143

1144
	ida_simple_remove(&nfc_index_ida, id);
1145 1146 1147 1148 1149
}
EXPORT_SYMBOL(nfc_unregister_device);

static int __init nfc_init(void)
{
1150 1151
	int rc;

1152
	pr_info("NFC Core ver %s\n", VERSION);
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
	rc = class_register(&nfc_class);
	if (rc)
		return rc;

	rc = nfc_genl_init();
	if (rc)
		goto err_genl;

	/* the first generation must not be 0 */
	nfc_devlist_generation = 1;

1165 1166 1167 1168
	rc = rawsock_init();
	if (rc)
		goto err_rawsock;

S
Samuel Ortiz 已提交
1169 1170 1171 1172
	rc = nfc_llcp_init();
	if (rc)
		goto err_llcp_sock;

1173 1174 1175 1176
	rc = af_nfc_init();
	if (rc)
		goto err_af_nfc;

1177 1178
	return 0;

1179
err_af_nfc:
S
Samuel Ortiz 已提交
1180 1181
	nfc_llcp_exit();
err_llcp_sock:
1182 1183
	rawsock_exit();
err_rawsock:
1184
	nfc_genl_exit();
1185 1186 1187
err_genl:
	class_unregister(&nfc_class);
	return rc;
1188 1189 1190 1191
}

static void __exit nfc_exit(void)
{
1192
	af_nfc_exit();
S
Samuel Ortiz 已提交
1193
	nfc_llcp_exit();
1194
	rawsock_exit();
1195
	nfc_genl_exit();
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
	class_unregister(&nfc_class);
}

subsys_initcall(nfc_init);
module_exit(nfc_exit);

MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
MODULE_DESCRIPTION("NFC Core ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
1206
MODULE_ALIAS_NETPROTO(PF_NFC);
1207
MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);
新手
引导
客服 返回
顶部