Linux Audio

Check our new training course

Loading...
v3.5.6
  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
 36#define NFC_CHECK_PRES_FREQ_MS	2000
 37
 38int nfc_devlist_generation;
 39DEFINE_MUTEX(nfc_devlist_mutex);
 40
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 41/**
 42 * nfc_dev_up - turn on the NFC device
 43 *
 44 * @dev: The nfc device to be turned on
 45 *
 46 * The device remains up until the nfc_dev_down function is called.
 47 */
 48int nfc_dev_up(struct nfc_dev *dev)
 49{
 50	int rc = 0;
 51
 52	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 53
 54	device_lock(&dev->dev);
 55
 
 
 
 
 
 56	if (!device_is_registered(&dev->dev)) {
 57		rc = -ENODEV;
 58		goto error;
 59	}
 60
 
 
 
 
 
 61	if (dev->dev_up) {
 62		rc = -EALREADY;
 63		goto error;
 64	}
 65
 66	if (dev->ops->dev_up)
 67		rc = dev->ops->dev_up(dev);
 68
 69	if (!rc)
 70		dev->dev_up = true;
 71
 
 
 
 
 72error:
 73	device_unlock(&dev->dev);
 74	return rc;
 75}
 76
 77/**
 78 * nfc_dev_down - turn off the NFC device
 79 *
 80 * @dev: The nfc device to be turned off
 81 */
 82int nfc_dev_down(struct nfc_dev *dev)
 83{
 84	int rc = 0;
 85
 86	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 87
 88	device_lock(&dev->dev);
 89
 90	if (!device_is_registered(&dev->dev)) {
 91		rc = -ENODEV;
 92		goto error;
 93	}
 94
 95	if (!dev->dev_up) {
 96		rc = -EALREADY;
 97		goto error;
 98	}
 99
100	if (dev->polling || dev->active_target) {
101		rc = -EBUSY;
102		goto error;
103	}
104
105	if (dev->ops->dev_down)
106		dev->ops->dev_down(dev);
107
108	dev->dev_up = false;
109
110error:
111	device_unlock(&dev->dev);
112	return rc;
113}
114
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
115/**
116 * nfc_start_poll - start polling for nfc targets
117 *
118 * @dev: The nfc device that must start polling
119 * @protocols: bitset of nfc protocols that must be used for polling
120 *
121 * The device remains polling for targets until a target is found or
122 * the nfc_stop_poll function is called.
123 */
124int nfc_start_poll(struct nfc_dev *dev, u32 protocols)
125{
126	int rc;
127
128	pr_debug("dev_name=%s protocols=0x%x\n",
129		 dev_name(&dev->dev), protocols);
130
131	if (!protocols)
132		return -EINVAL;
133
134	device_lock(&dev->dev);
135
136	if (!device_is_registered(&dev->dev)) {
137		rc = -ENODEV;
138		goto error;
139	}
140
 
 
 
 
 
141	if (dev->polling) {
142		rc = -EBUSY;
143		goto error;
144	}
145
146	rc = dev->ops->start_poll(dev, protocols);
147	if (!rc)
148		dev->polling = true;
 
 
149
150error:
151	device_unlock(&dev->dev);
152	return rc;
153}
154
155/**
156 * nfc_stop_poll - stop polling for nfc targets
157 *
158 * @dev: The nfc device that must stop polling
159 */
160int nfc_stop_poll(struct nfc_dev *dev)
161{
162	int rc = 0;
163
164	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
165
166	device_lock(&dev->dev);
167
168	if (!device_is_registered(&dev->dev)) {
169		rc = -ENODEV;
170		goto error;
171	}
172
173	if (!dev->polling) {
174		rc = -EINVAL;
175		goto error;
176	}
177
178	dev->ops->stop_poll(dev);
179	dev->polling = false;
 
180
181error:
182	device_unlock(&dev->dev);
183	return rc;
184}
185
186static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx)
187{
188	int i;
189
190	if (dev->n_targets == 0)
191		return NULL;
192
193	for (i = 0; i < dev->n_targets ; i++) {
194		if (dev->targets[i].idx == target_idx)
195			return &dev->targets[i];
196	}
197
198	return NULL;
199}
200
201int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
202{
203	int rc = 0;
204	u8 *gb;
205	size_t gb_len;
206	struct nfc_target *target;
207
208	pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
209
210	if (!dev->ops->dep_link_up)
211		return -EOPNOTSUPP;
212
213	device_lock(&dev->dev);
214
215	if (!device_is_registered(&dev->dev)) {
216		rc = -ENODEV;
217		goto error;
218	}
219
220	if (dev->dep_link_up == true) {
221		rc = -EALREADY;
222		goto error;
223	}
224
225	gb = nfc_llcp_general_bytes(dev, &gb_len);
226	if (gb_len > NFC_MAX_GT_LEN) {
227		rc = -EINVAL;
228		goto error;
229	}
230
231	target = nfc_find_target(dev, target_index);
232	if (target == NULL) {
233		rc = -ENOTCONN;
234		goto error;
235	}
236
237	rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len);
238	if (!rc)
239		dev->active_target = target;
 
 
240
241error:
242	device_unlock(&dev->dev);
243	return rc;
244}
245
246int nfc_dep_link_down(struct nfc_dev *dev)
247{
248	int rc = 0;
249
250	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
251
252	if (!dev->ops->dep_link_down)
253		return -EOPNOTSUPP;
254
255	device_lock(&dev->dev);
256
257	if (!device_is_registered(&dev->dev)) {
258		rc = -ENODEV;
259		goto error;
260	}
261
262	if (dev->dep_link_up == false) {
263		rc = -EALREADY;
264		goto error;
265	}
266
267	if (dev->dep_rf_mode == NFC_RF_TARGET) {
268		rc = -EOPNOTSUPP;
269		goto error;
270	}
271
272	rc = dev->ops->dep_link_down(dev);
273	if (!rc) {
274		dev->dep_link_up = false;
275		dev->active_target = NULL;
 
276		nfc_llcp_mac_is_down(dev);
277		nfc_genl_dep_link_down_event(dev);
278	}
279
280error:
281	device_unlock(&dev->dev);
 
282	return rc;
283}
284
285int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
286		       u8 comm_mode, u8 rf_mode)
287{
288	dev->dep_link_up = true;
289	dev->dep_rf_mode = rf_mode;
 
 
 
 
 
 
 
 
 
 
 
 
290
291	nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);
292
293	return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);
294}
295EXPORT_SYMBOL(nfc_dep_link_is_up);
296
297/**
298 * nfc_activate_target - prepare the target for data exchange
299 *
300 * @dev: The nfc device that found the target
301 * @target_idx: index of the target that must be activated
302 * @protocol: nfc protocol that will be used for data exchange
303 */
304int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
305{
306	int rc;
307	struct nfc_target *target;
308
309	pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
310		 dev_name(&dev->dev), target_idx, protocol);
311
312	device_lock(&dev->dev);
313
314	if (!device_is_registered(&dev->dev)) {
315		rc = -ENODEV;
316		goto error;
317	}
318
319	if (dev->active_target) {
320		rc = -EBUSY;
321		goto error;
322	}
323
324	target = nfc_find_target(dev, target_idx);
325	if (target == NULL) {
326		rc = -ENOTCONN;
327		goto error;
328	}
329
330	rc = dev->ops->activate_target(dev, target, protocol);
331	if (!rc) {
332		dev->active_target = target;
 
333
334		if (dev->ops->check_presence)
335			mod_timer(&dev->check_pres_timer, jiffies +
336				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
337	}
338
339error:
340	device_unlock(&dev->dev);
341	return rc;
342}
343
344/**
345 * nfc_deactivate_target - deactivate a nfc target
346 *
347 * @dev: The nfc device that found the target
348 * @target_idx: index of the target that must be deactivated
349 */
350int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
351{
352	int rc = 0;
353
354	pr_debug("dev_name=%s target_idx=%u\n",
355		 dev_name(&dev->dev), target_idx);
356
357	device_lock(&dev->dev);
358
359	if (!device_is_registered(&dev->dev)) {
360		rc = -ENODEV;
361		goto error;
362	}
363
364	if (dev->active_target == NULL) {
365		rc = -ENOTCONN;
366		goto error;
367	}
368
369	if (dev->active_target->idx != target_idx) {
370		rc = -ENOTCONN;
371		goto error;
372	}
373
374	if (dev->ops->check_presence)
375		del_timer_sync(&dev->check_pres_timer);
376
377	dev->ops->deactivate_target(dev, dev->active_target);
378	dev->active_target = NULL;
379
380error:
381	device_unlock(&dev->dev);
382	return rc;
383}
384
385/**
386 * nfc_data_exchange - transceive data
387 *
388 * @dev: The nfc device that found the target
389 * @target_idx: index of the target
390 * @skb: data to be sent
391 * @cb: callback called when the response is received
392 * @cb_context: parameter for the callback function
393 *
394 * The user must wait for the callback before calling this function again.
395 */
396int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
397		      data_exchange_cb_t cb, void *cb_context)
398{
399	int rc;
400
401	pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
402		 dev_name(&dev->dev), target_idx, skb->len);
403
404	device_lock(&dev->dev);
405
406	if (!device_is_registered(&dev->dev)) {
407		rc = -ENODEV;
408		kfree_skb(skb);
409		goto error;
410	}
411
412	if (dev->active_target == NULL) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
413		rc = -ENOTCONN;
414		kfree_skb(skb);
415		goto error;
416	}
417
418	if (dev->active_target->idx != target_idx) {
419		rc = -EADDRNOTAVAIL;
420		kfree_skb(skb);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
421		goto error;
422	}
423
424	if (dev->ops->check_presence)
425		del_timer_sync(&dev->check_pres_timer);
 
 
 
 
 
 
 
 
 
 
 
 
426
427	rc = dev->ops->data_exchange(dev, dev->active_target, skb, cb,
428				     cb_context);
 
 
 
429
430	if (!rc && dev->ops->check_presence)
431		mod_timer(&dev->check_pres_timer, jiffies +
432			  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
433
434error:
435	device_unlock(&dev->dev);
436	return rc;
437}
438
439int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len)
440{
441	pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
442
443	if (gb_len > NFC_MAX_GT_LEN)
444		return -EINVAL;
445
446	return nfc_llcp_set_remote_gb(dev, gb, gb_len);
447}
448EXPORT_SYMBOL(nfc_set_remote_general_bytes);
449
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
450/**
451 * nfc_alloc_send_skb - allocate a skb for data exchange responses
452 *
453 * @size: size to allocate
454 * @gfp: gfp flags
455 */
456struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
457				   unsigned int flags, unsigned int size,
458				   unsigned int *err)
459{
460	struct sk_buff *skb;
461	unsigned int total_size;
462
463	total_size = size +
464		dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;
465
466	skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err);
467	if (skb)
468		skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
469
470	return skb;
471}
472
473/**
474 * nfc_alloc_recv_skb - allocate a skb for data exchange responses
475 *
476 * @size: size to allocate
477 * @gfp: gfp flags
478 */
479struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp)
480{
481	struct sk_buff *skb;
482	unsigned int total_size;
483
484	total_size = size + 1;
485	skb = alloc_skb(total_size, gfp);
486
487	if (skb)
488		skb_reserve(skb, 1);
489
490	return skb;
491}
492EXPORT_SYMBOL(nfc_alloc_recv_skb);
493
494/**
495 * nfc_targets_found - inform that targets were found
496 *
497 * @dev: The nfc device that found the targets
498 * @targets: array of nfc targets found
499 * @ntargets: targets array size
500 *
501 * The device driver must call this function when one or many nfc targets
502 * are found. After calling this function, the device driver must stop
503 * polling for targets.
 
 
504 * IMPORTANT: this function must not be called from an atomic context.
505 * In addition, it must also not be called from a context that would prevent
506 * the NFC Core to call other nfc ops entry point concurrently.
507 */
508int nfc_targets_found(struct nfc_dev *dev,
509		      struct nfc_target *targets, int n_targets)
510{
511	int i;
512
513	pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
514
515	dev->polling = false;
516
517	for (i = 0; i < n_targets; i++)
518		targets[i].idx = dev->target_next_idx++;
519
520	device_lock(&dev->dev);
521
 
 
 
 
 
 
 
522	dev->targets_generation++;
523
524	kfree(dev->targets);
525	dev->targets = kmemdup(targets, n_targets * sizeof(struct nfc_target),
526			       GFP_ATOMIC);
527
528	if (!dev->targets) {
529		dev->n_targets = 0;
530		device_unlock(&dev->dev);
531		return -ENOMEM;
 
 
 
 
 
 
532	}
533
534	dev->n_targets = n_targets;
535	device_unlock(&dev->dev);
536
537	nfc_genl_targets_found(dev);
538
539	return 0;
540}
541EXPORT_SYMBOL(nfc_targets_found);
542
543/**
544 * nfc_target_lost - inform that an activated target went out of field
545 *
546 * @dev: The nfc device that had the activated target in field
547 * @target_idx: the nfc index of the target
548 *
549 * The device driver must call this function when the activated target
550 * goes out of the field.
551 * IMPORTANT: this function must not be called from an atomic context.
552 * In addition, it must also not be called from a context that would prevent
553 * the NFC Core to call other nfc ops entry point concurrently.
554 */
555int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
556{
557	struct nfc_target *tg;
558	int i;
559
560	pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
561
562	device_lock(&dev->dev);
563
564	for (i = 0; i < dev->n_targets; i++) {
565		tg = &dev->targets[i];
566		if (tg->idx == target_idx)
567			break;
568	}
569
570	if (i == dev->n_targets) {
571		device_unlock(&dev->dev);
572		return -EINVAL;
573	}
574
575	dev->targets_generation++;
576	dev->n_targets--;
577	dev->active_target = NULL;
578
579	if (dev->n_targets) {
580		memcpy(&dev->targets[i], &dev->targets[i + 1],
581		       (dev->n_targets - i) * sizeof(struct nfc_target));
582	} else {
583		kfree(dev->targets);
584		dev->targets = NULL;
585	}
586
587	device_unlock(&dev->dev);
588
589	nfc_genl_target_lost(dev, target_idx);
590
591	return 0;
592}
593EXPORT_SYMBOL(nfc_target_lost);
594
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
595static void nfc_release(struct device *d)
596{
597	struct nfc_dev *dev = to_nfc_dev(d);
 
598
599	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
600
601	if (dev->ops->check_presence) {
602		del_timer_sync(&dev->check_pres_timer);
603		destroy_workqueue(dev->check_pres_wq);
604	}
605
606	nfc_genl_data_exit(&dev->genl_data);
607	kfree(dev->targets);
 
 
 
 
 
 
 
608	kfree(dev);
609}
610
611static void nfc_check_pres_work(struct work_struct *work)
612{
613	struct nfc_dev *dev = container_of(work, struct nfc_dev,
614					   check_pres_work);
615	int rc;
616
617	device_lock(&dev->dev);
618
619	if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) {
620		rc = dev->ops->check_presence(dev, dev->active_target);
621		if (!rc) {
622			mod_timer(&dev->check_pres_timer, jiffies +
623				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
624		} else {
625			u32 active_target_idx = dev->active_target->idx;
626			device_unlock(&dev->dev);
627			nfc_target_lost(dev, active_target_idx);
628			return;
629		}
 
 
 
 
630	}
631
 
632	device_unlock(&dev->dev);
633}
634
635static void nfc_check_pres_timeout(unsigned long data)
636{
637	struct nfc_dev *dev = (struct nfc_dev *)data;
638
639	queue_work(dev->check_pres_wq, &dev->check_pres_work);
640}
641
642struct class nfc_class = {
643	.name = "nfc",
644	.dev_release = nfc_release,
645};
646EXPORT_SYMBOL(nfc_class);
647
648static int match_idx(struct device *d, void *data)
649{
650	struct nfc_dev *dev = to_nfc_dev(d);
651	unsigned int *idx = data;
652
653	return dev->idx == *idx;
654}
655
656struct nfc_dev *nfc_get_device(unsigned int idx)
657{
658	struct device *d;
659
660	d = class_find_device(&nfc_class, NULL, &idx, match_idx);
661	if (!d)
662		return NULL;
663
664	return to_nfc_dev(d);
665}
666
667/**
668 * nfc_allocate_device - allocate a new nfc device
669 *
670 * @ops: device operations
671 * @supported_protocols: NFC protocols supported by the device
672 */
673struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
674				    u32 supported_protocols,
675				    int tx_headroom, int tx_tailroom)
676{
677	static atomic_t dev_no = ATOMIC_INIT(0);
678	struct nfc_dev *dev;
679
680	if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
681	    !ops->deactivate_target || !ops->data_exchange)
682		return NULL;
683
684	if (!supported_protocols)
685		return NULL;
686
687	dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
688	if (!dev)
689		return NULL;
690
691	dev->dev.class = &nfc_class;
692	dev->idx = atomic_inc_return(&dev_no) - 1;
693	dev_set_name(&dev->dev, "nfc%d", dev->idx);
694	device_initialize(&dev->dev);
695
696	dev->ops = ops;
697	dev->supported_protocols = supported_protocols;
698	dev->tx_headroom = tx_headroom;
699	dev->tx_tailroom = tx_tailroom;
 
700
701	nfc_genl_data_init(&dev->genl_data);
702
 
703
704	/* first generation must not be 0 */
705	dev->targets_generation = 1;
706
707	if (ops->check_presence) {
708		char name[32];
709		init_timer(&dev->check_pres_timer);
710		dev->check_pres_timer.data = (unsigned long)dev;
711		dev->check_pres_timer.function = nfc_check_pres_timeout;
712
713		INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
714		snprintf(name, sizeof(name), "nfc%d_check_pres_wq", dev->idx);
715		dev->check_pres_wq = alloc_workqueue(name, WQ_NON_REENTRANT |
716						     WQ_UNBOUND |
717						     WQ_MEM_RECLAIM, 1);
718		if (dev->check_pres_wq == NULL) {
719			kfree(dev);
720			return NULL;
721		}
722	}
723
724	return dev;
725}
726EXPORT_SYMBOL(nfc_allocate_device);
727
728/**
729 * nfc_register_device - register a nfc device in the nfc subsystem
730 *
731 * @dev: The nfc device to register
732 */
733int nfc_register_device(struct nfc_dev *dev)
734{
735	int rc;
736
737	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
738
 
 
 
 
 
 
 
 
739	mutex_lock(&nfc_devlist_mutex);
740	nfc_devlist_generation++;
741	rc = device_add(&dev->dev);
742	mutex_unlock(&nfc_devlist_mutex);
743
744	if (rc < 0)
745		return rc;
746
747	rc = nfc_llcp_register_device(dev);
748	if (rc)
749		pr_err("Could not register llcp device\n");
750
751	rc = nfc_genl_device_added(dev);
752	if (rc)
753		pr_debug("The userspace won't be notified that the device %s was added\n",
754			 dev_name(&dev->dev));
755
 
 
 
 
 
 
 
 
 
756	return 0;
757}
758EXPORT_SYMBOL(nfc_register_device);
759
760/**
761 * nfc_unregister_device - unregister a nfc device in the nfc subsystem
762 *
763 * @dev: The nfc device to unregister
764 */
765void nfc_unregister_device(struct nfc_dev *dev)
766{
767	int rc;
768
769	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
770
771	mutex_lock(&nfc_devlist_mutex);
772	nfc_devlist_generation++;
773
774	/* lock to avoid unregistering a device while an operation
775	   is in progress */
776	device_lock(&dev->dev);
777	device_del(&dev->dev);
778	device_unlock(&dev->dev);
779
780	mutex_unlock(&nfc_devlist_mutex);
 
 
 
781
782	nfc_llcp_unregister_device(dev);
 
 
 
 
 
 
783
784	rc = nfc_genl_device_removed(dev);
785	if (rc)
786		pr_debug("The userspace won't be notified that the device %s was removed\n",
787			 dev_name(&dev->dev));
 
 
 
 
 
 
 
788
 
789}
790EXPORT_SYMBOL(nfc_unregister_device);
791
792static int __init nfc_init(void)
793{
794	int rc;
795
796	pr_info("NFC Core ver %s\n", VERSION);
797
798	rc = class_register(&nfc_class);
799	if (rc)
800		return rc;
801
802	rc = nfc_genl_init();
803	if (rc)
804		goto err_genl;
805
806	/* the first generation must not be 0 */
807	nfc_devlist_generation = 1;
808
809	rc = rawsock_init();
810	if (rc)
811		goto err_rawsock;
812
813	rc = nfc_llcp_init();
814	if (rc)
815		goto err_llcp_sock;
816
817	rc = af_nfc_init();
818	if (rc)
819		goto err_af_nfc;
820
821	return 0;
822
823err_af_nfc:
824	nfc_llcp_exit();
825err_llcp_sock:
826	rawsock_exit();
827err_rawsock:
828	nfc_genl_exit();
829err_genl:
830	class_unregister(&nfc_class);
831	return rc;
832}
833
834static void __exit nfc_exit(void)
835{
836	af_nfc_exit();
837	nfc_llcp_exit();
838	rawsock_exit();
839	nfc_genl_exit();
840	class_unregister(&nfc_class);
841}
842
843subsys_initcall(nfc_init);
844module_exit(nfc_exit);
845
846MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
847MODULE_DESCRIPTION("NFC Core ver " VERSION);
848MODULE_VERSION(VERSION);
849MODULE_LICENSE("GPL");
v3.15
   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, see <http://www.gnu.org/licenses/>.
 
 
  20 */
  21
  22#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
  23
  24#include <linux/init.h>
  25#include <linux/kernel.h>
  26#include <linux/module.h>
  27#include <linux/slab.h>
  28#include <linux/rfkill.h>
  29#include <linux/nfc.h>
  30
  31#include <net/genetlink.h>
  32
  33#include "nfc.h"
  34
  35#define VERSION "0.1"
  36
  37#define NFC_CHECK_PRES_FREQ_MS	2000
  38
  39int nfc_devlist_generation;
  40DEFINE_MUTEX(nfc_devlist_mutex);
  41
  42/* NFC device ID bitmap */
  43static DEFINE_IDA(nfc_index_ida);
  44
  45int nfc_fw_download(struct nfc_dev *dev, const char *firmware_name)
  46{
  47	int rc = 0;
  48
  49	pr_debug("%s do firmware %s\n", dev_name(&dev->dev), firmware_name);
  50
  51	device_lock(&dev->dev);
  52
  53	if (!device_is_registered(&dev->dev)) {
  54		rc = -ENODEV;
  55		goto error;
  56	}
  57
  58	if (dev->dev_up) {
  59		rc = -EBUSY;
  60		goto error;
  61	}
  62
  63	if (!dev->ops->fw_download) {
  64		rc = -EOPNOTSUPP;
  65		goto error;
  66	}
  67
  68	dev->fw_download_in_progress = true;
  69	rc = dev->ops->fw_download(dev, firmware_name);
  70	if (rc)
  71		dev->fw_download_in_progress = false;
  72
  73error:
  74	device_unlock(&dev->dev);
  75	return rc;
  76}
  77
  78/**
  79 * nfc_fw_download_done - inform that a firmware download was completed
  80 *
  81 * @dev: The nfc device to which firmware was downloaded
  82 * @firmware_name: The firmware filename
  83 * @result: The positive value of a standard errno value
  84 */
  85int nfc_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
  86			 u32 result)
  87{
  88	dev->fw_download_in_progress = false;
  89
  90	return nfc_genl_fw_download_done(dev, firmware_name, result);
  91}
  92EXPORT_SYMBOL(nfc_fw_download_done);
  93
  94/**
  95 * nfc_dev_up - turn on the NFC device
  96 *
  97 * @dev: The nfc device to be turned on
  98 *
  99 * The device remains up until the nfc_dev_down function is called.
 100 */
 101int nfc_dev_up(struct nfc_dev *dev)
 102{
 103	int rc = 0;
 104
 105	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 106
 107	device_lock(&dev->dev);
 108
 109	if (dev->rfkill && rfkill_blocked(dev->rfkill)) {
 110		rc = -ERFKILL;
 111		goto error;
 112	}
 113
 114	if (!device_is_registered(&dev->dev)) {
 115		rc = -ENODEV;
 116		goto error;
 117	}
 118
 119	if (dev->fw_download_in_progress) {
 120		rc = -EBUSY;
 121		goto error;
 122	}
 123
 124	if (dev->dev_up) {
 125		rc = -EALREADY;
 126		goto error;
 127	}
 128
 129	if (dev->ops->dev_up)
 130		rc = dev->ops->dev_up(dev);
 131
 132	if (!rc)
 133		dev->dev_up = true;
 134
 135	/* We have to enable the device before discovering SEs */
 136	if (dev->ops->discover_se && dev->ops->discover_se(dev))
 137		pr_err("SE discovery failed\n");
 138
 139error:
 140	device_unlock(&dev->dev);
 141	return rc;
 142}
 143
 144/**
 145 * nfc_dev_down - turn off the NFC device
 146 *
 147 * @dev: The nfc device to be turned off
 148 */
 149int nfc_dev_down(struct nfc_dev *dev)
 150{
 151	int rc = 0;
 152
 153	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 154
 155	device_lock(&dev->dev);
 156
 157	if (!device_is_registered(&dev->dev)) {
 158		rc = -ENODEV;
 159		goto error;
 160	}
 161
 162	if (!dev->dev_up) {
 163		rc = -EALREADY;
 164		goto error;
 165	}
 166
 167	if (dev->polling || dev->active_target) {
 168		rc = -EBUSY;
 169		goto error;
 170	}
 171
 172	if (dev->ops->dev_down)
 173		dev->ops->dev_down(dev);
 174
 175	dev->dev_up = false;
 176
 177error:
 178	device_unlock(&dev->dev);
 179	return rc;
 180}
 181
 182static int nfc_rfkill_set_block(void *data, bool blocked)
 183{
 184	struct nfc_dev *dev = data;
 185
 186	pr_debug("%s blocked %d", dev_name(&dev->dev), blocked);
 187
 188	if (!blocked)
 189		return 0;
 190
 191	nfc_dev_down(dev);
 192
 193	return 0;
 194}
 195
 196static const struct rfkill_ops nfc_rfkill_ops = {
 197	.set_block = nfc_rfkill_set_block,
 198};
 199
 200/**
 201 * nfc_start_poll - start polling for nfc targets
 202 *
 203 * @dev: The nfc device that must start polling
 204 * @protocols: bitset of nfc protocols that must be used for polling
 205 *
 206 * The device remains polling for targets until a target is found or
 207 * the nfc_stop_poll function is called.
 208 */
 209int nfc_start_poll(struct nfc_dev *dev, u32 im_protocols, u32 tm_protocols)
 210{
 211	int rc;
 212
 213	pr_debug("dev_name %s initiator protocols 0x%x target protocols 0x%x\n",
 214		 dev_name(&dev->dev), im_protocols, tm_protocols);
 215
 216	if (!im_protocols && !tm_protocols)
 217		return -EINVAL;
 218
 219	device_lock(&dev->dev);
 220
 221	if (!device_is_registered(&dev->dev)) {
 222		rc = -ENODEV;
 223		goto error;
 224	}
 225
 226	if (!dev->dev_up) {
 227		rc = -ENODEV;
 228		goto error;
 229	}
 230
 231	if (dev->polling) {
 232		rc = -EBUSY;
 233		goto error;
 234	}
 235
 236	rc = dev->ops->start_poll(dev, im_protocols, tm_protocols);
 237	if (!rc) {
 238		dev->polling = true;
 239		dev->rf_mode = NFC_RF_NONE;
 240	}
 241
 242error:
 243	device_unlock(&dev->dev);
 244	return rc;
 245}
 246
 247/**
 248 * nfc_stop_poll - stop polling for nfc targets
 249 *
 250 * @dev: The nfc device that must stop polling
 251 */
 252int nfc_stop_poll(struct nfc_dev *dev)
 253{
 254	int rc = 0;
 255
 256	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 257
 258	device_lock(&dev->dev);
 259
 260	if (!device_is_registered(&dev->dev)) {
 261		rc = -ENODEV;
 262		goto error;
 263	}
 264
 265	if (!dev->polling) {
 266		rc = -EINVAL;
 267		goto error;
 268	}
 269
 270	dev->ops->stop_poll(dev);
 271	dev->polling = false;
 272	dev->rf_mode = NFC_RF_NONE;
 273
 274error:
 275	device_unlock(&dev->dev);
 276	return rc;
 277}
 278
 279static struct nfc_target *nfc_find_target(struct nfc_dev *dev, u32 target_idx)
 280{
 281	int i;
 282
 283	for (i = 0; i < dev->n_targets; i++) {
 
 
 
 284		if (dev->targets[i].idx == target_idx)
 285			return &dev->targets[i];
 286	}
 287
 288	return NULL;
 289}
 290
 291int nfc_dep_link_up(struct nfc_dev *dev, int target_index, u8 comm_mode)
 292{
 293	int rc = 0;
 294	u8 *gb;
 295	size_t gb_len;
 296	struct nfc_target *target;
 297
 298	pr_debug("dev_name=%s comm %d\n", dev_name(&dev->dev), comm_mode);
 299
 300	if (!dev->ops->dep_link_up)
 301		return -EOPNOTSUPP;
 302
 303	device_lock(&dev->dev);
 304
 305	if (!device_is_registered(&dev->dev)) {
 306		rc = -ENODEV;
 307		goto error;
 308	}
 309
 310	if (dev->dep_link_up == true) {
 311		rc = -EALREADY;
 312		goto error;
 313	}
 314
 315	gb = nfc_llcp_general_bytes(dev, &gb_len);
 316	if (gb_len > NFC_MAX_GT_LEN) {
 317		rc = -EINVAL;
 318		goto error;
 319	}
 320
 321	target = nfc_find_target(dev, target_index);
 322	if (target == NULL) {
 323		rc = -ENOTCONN;
 324		goto error;
 325	}
 326
 327	rc = dev->ops->dep_link_up(dev, target, comm_mode, gb, gb_len);
 328	if (!rc) {
 329		dev->active_target = target;
 330		dev->rf_mode = NFC_RF_INITIATOR;
 331	}
 332
 333error:
 334	device_unlock(&dev->dev);
 335	return rc;
 336}
 337
 338int nfc_dep_link_down(struct nfc_dev *dev)
 339{
 340	int rc = 0;
 341
 342	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 343
 344	if (!dev->ops->dep_link_down)
 345		return -EOPNOTSUPP;
 346
 347	device_lock(&dev->dev);
 348
 349	if (!device_is_registered(&dev->dev)) {
 350		rc = -ENODEV;
 351		goto error;
 352	}
 353
 354	if (dev->dep_link_up == false) {
 355		rc = -EALREADY;
 356		goto error;
 357	}
 358
 
 
 
 
 
 359	rc = dev->ops->dep_link_down(dev);
 360	if (!rc) {
 361		dev->dep_link_up = false;
 362		dev->active_target = NULL;
 363		dev->rf_mode = NFC_RF_NONE;
 364		nfc_llcp_mac_is_down(dev);
 365		nfc_genl_dep_link_down_event(dev);
 366	}
 367
 368error:
 369	device_unlock(&dev->dev);
 370
 371	return rc;
 372}
 373
 374int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
 375		       u8 comm_mode, u8 rf_mode)
 376{
 377	dev->dep_link_up = true;
 378
 379	if (!dev->active_target && rf_mode == NFC_RF_INITIATOR) {
 380		struct nfc_target *target;
 381
 382		target = nfc_find_target(dev, target_idx);
 383		if (target == NULL)
 384			return -ENOTCONN;
 385
 386		dev->active_target = target;
 387	}
 388
 389	dev->polling = false;
 390	dev->rf_mode = rf_mode;
 391
 392	nfc_llcp_mac_is_up(dev, target_idx, comm_mode, rf_mode);
 393
 394	return nfc_genl_dep_link_up_event(dev, target_idx, comm_mode, rf_mode);
 395}
 396EXPORT_SYMBOL(nfc_dep_link_is_up);
 397
 398/**
 399 * nfc_activate_target - prepare the target for data exchange
 400 *
 401 * @dev: The nfc device that found the target
 402 * @target_idx: index of the target that must be activated
 403 * @protocol: nfc protocol that will be used for data exchange
 404 */
 405int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
 406{
 407	int rc;
 408	struct nfc_target *target;
 409
 410	pr_debug("dev_name=%s target_idx=%u protocol=%u\n",
 411		 dev_name(&dev->dev), target_idx, protocol);
 412
 413	device_lock(&dev->dev);
 414
 415	if (!device_is_registered(&dev->dev)) {
 416		rc = -ENODEV;
 417		goto error;
 418	}
 419
 420	if (dev->active_target) {
 421		rc = -EBUSY;
 422		goto error;
 423	}
 424
 425	target = nfc_find_target(dev, target_idx);
 426	if (target == NULL) {
 427		rc = -ENOTCONN;
 428		goto error;
 429	}
 430
 431	rc = dev->ops->activate_target(dev, target, protocol);
 432	if (!rc) {
 433		dev->active_target = target;
 434		dev->rf_mode = NFC_RF_INITIATOR;
 435
 436		if (dev->ops->check_presence && !dev->shutting_down)
 437			mod_timer(&dev->check_pres_timer, jiffies +
 438				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 439	}
 440
 441error:
 442	device_unlock(&dev->dev);
 443	return rc;
 444}
 445
 446/**
 447 * nfc_deactivate_target - deactivate a nfc target
 448 *
 449 * @dev: The nfc device that found the target
 450 * @target_idx: index of the target that must be deactivated
 451 */
 452int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
 453{
 454	int rc = 0;
 455
 456	pr_debug("dev_name=%s target_idx=%u\n",
 457		 dev_name(&dev->dev), target_idx);
 458
 459	device_lock(&dev->dev);
 460
 461	if (!device_is_registered(&dev->dev)) {
 462		rc = -ENODEV;
 463		goto error;
 464	}
 465
 466	if (dev->active_target == NULL) {
 467		rc = -ENOTCONN;
 468		goto error;
 469	}
 470
 471	if (dev->active_target->idx != target_idx) {
 472		rc = -ENOTCONN;
 473		goto error;
 474	}
 475
 476	if (dev->ops->check_presence)
 477		del_timer_sync(&dev->check_pres_timer);
 478
 479	dev->ops->deactivate_target(dev, dev->active_target);
 480	dev->active_target = NULL;
 481
 482error:
 483	device_unlock(&dev->dev);
 484	return rc;
 485}
 486
 487/**
 488 * nfc_data_exchange - transceive data
 489 *
 490 * @dev: The nfc device that found the target
 491 * @target_idx: index of the target
 492 * @skb: data to be sent
 493 * @cb: callback called when the response is received
 494 * @cb_context: parameter for the callback function
 495 *
 496 * The user must wait for the callback before calling this function again.
 497 */
 498int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx, struct sk_buff *skb,
 499		      data_exchange_cb_t cb, void *cb_context)
 500{
 501	int rc;
 502
 503	pr_debug("dev_name=%s target_idx=%u skb->len=%u\n",
 504		 dev_name(&dev->dev), target_idx, skb->len);
 505
 506	device_lock(&dev->dev);
 507
 508	if (!device_is_registered(&dev->dev)) {
 509		rc = -ENODEV;
 510		kfree_skb(skb);
 511		goto error;
 512	}
 513
 514	if (dev->rf_mode == NFC_RF_INITIATOR && dev->active_target != NULL) {
 515		if (dev->active_target->idx != target_idx) {
 516			rc = -EADDRNOTAVAIL;
 517			kfree_skb(skb);
 518			goto error;
 519		}
 520
 521		if (dev->ops->check_presence)
 522			del_timer_sync(&dev->check_pres_timer);
 523
 524		rc = dev->ops->im_transceive(dev, dev->active_target, skb, cb,
 525					     cb_context);
 526
 527		if (!rc && dev->ops->check_presence && !dev->shutting_down)
 528			mod_timer(&dev->check_pres_timer, jiffies +
 529				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 530	} else if (dev->rf_mode == NFC_RF_TARGET && dev->ops->tm_send != NULL) {
 531		rc = dev->ops->tm_send(dev, skb);
 532	} else {
 533		rc = -ENOTCONN;
 534		kfree_skb(skb);
 535		goto error;
 536	}
 537
 538
 539error:
 540	device_unlock(&dev->dev);
 541	return rc;
 542}
 543
 544struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx)
 545{
 546	struct nfc_se *se;
 547
 548	list_for_each_entry(se, &dev->secure_elements, list)
 549		if (se->idx == se_idx)
 550			return se;
 551
 552	return NULL;
 553}
 554EXPORT_SYMBOL(nfc_find_se);
 555
 556int nfc_enable_se(struct nfc_dev *dev, u32 se_idx)
 557{
 558
 559	struct nfc_se *se;
 560	int rc;
 561
 562	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
 563
 564	device_lock(&dev->dev);
 565
 566	if (!device_is_registered(&dev->dev)) {
 567		rc = -ENODEV;
 568		goto error;
 569	}
 570
 571	if (!dev->dev_up) {
 572		rc = -ENODEV;
 573		goto error;
 574	}
 575
 576	if (dev->polling) {
 577		rc = -EBUSY;
 578		goto error;
 579	}
 580
 581	if (!dev->ops->enable_se || !dev->ops->disable_se) {
 582		rc = -EOPNOTSUPP;
 583		goto error;
 584	}
 585
 586	se = nfc_find_se(dev, se_idx);
 587	if (!se) {
 588		rc = -EINVAL;
 589		goto error;
 590	}
 591
 592	if (se->state == NFC_SE_ENABLED) {
 593		rc = -EALREADY;
 594		goto error;
 595	}
 596
 597	rc = dev->ops->enable_se(dev, se_idx);
 598	if (rc >= 0)
 599		se->state = NFC_SE_ENABLED;
 600
 601error:
 602	device_unlock(&dev->dev);
 603	return rc;
 604}
 605
 606int nfc_disable_se(struct nfc_dev *dev, u32 se_idx)
 607{
 608
 609	struct nfc_se *se;
 610	int rc;
 611
 612	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
 613
 614	device_lock(&dev->dev);
 615
 616	if (!device_is_registered(&dev->dev)) {
 617		rc = -ENODEV;
 618		goto error;
 619	}
 620
 621	if (!dev->dev_up) {
 622		rc = -ENODEV;
 623		goto error;
 624	}
 625
 626	if (!dev->ops->enable_se || !dev->ops->disable_se) {
 627		rc = -EOPNOTSUPP;
 628		goto error;
 629	}
 630
 631	se = nfc_find_se(dev, se_idx);
 632	if (!se) {
 633		rc = -EINVAL;
 634		goto error;
 635	}
 636
 637	if (se->state == NFC_SE_DISABLED) {
 638		rc = -EALREADY;
 639		goto error;
 640	}
 641
 642	rc = dev->ops->disable_se(dev, se_idx);
 643	if (rc >= 0)
 644		se->state = NFC_SE_DISABLED;
 645
 646error:
 647	device_unlock(&dev->dev);
 648	return rc;
 649}
 650
 651int nfc_set_remote_general_bytes(struct nfc_dev *dev, u8 *gb, u8 gb_len)
 652{
 653	pr_debug("dev_name=%s gb_len=%d\n", dev_name(&dev->dev), gb_len);
 654
 
 
 
 655	return nfc_llcp_set_remote_gb(dev, gb, gb_len);
 656}
 657EXPORT_SYMBOL(nfc_set_remote_general_bytes);
 658
 659u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, size_t *gb_len)
 660{
 661	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 662
 663	return nfc_llcp_general_bytes(dev, gb_len);
 664}
 665EXPORT_SYMBOL(nfc_get_local_general_bytes);
 666
 667int nfc_tm_data_received(struct nfc_dev *dev, struct sk_buff *skb)
 668{
 669	/* Only LLCP target mode for now */
 670	if (dev->dep_link_up == false) {
 671		kfree_skb(skb);
 672		return -ENOLINK;
 673	}
 674
 675	return nfc_llcp_data_received(dev, skb);
 676}
 677EXPORT_SYMBOL(nfc_tm_data_received);
 678
 679int nfc_tm_activated(struct nfc_dev *dev, u32 protocol, u8 comm_mode,
 680		     u8 *gb, size_t gb_len)
 681{
 682	int rc;
 683
 684	device_lock(&dev->dev);
 685
 686	dev->polling = false;
 687
 688	if (gb != NULL) {
 689		rc = nfc_set_remote_general_bytes(dev, gb, gb_len);
 690		if (rc < 0)
 691			goto out;
 692	}
 693
 694	dev->rf_mode = NFC_RF_TARGET;
 695
 696	if (protocol == NFC_PROTO_NFC_DEP_MASK)
 697		nfc_dep_link_is_up(dev, 0, comm_mode, NFC_RF_TARGET);
 698
 699	rc = nfc_genl_tm_activated(dev, protocol);
 700
 701out:
 702	device_unlock(&dev->dev);
 703
 704	return rc;
 705}
 706EXPORT_SYMBOL(nfc_tm_activated);
 707
 708int nfc_tm_deactivated(struct nfc_dev *dev)
 709{
 710	dev->dep_link_up = false;
 711	dev->rf_mode = NFC_RF_NONE;
 712
 713	return nfc_genl_tm_deactivated(dev);
 714}
 715EXPORT_SYMBOL(nfc_tm_deactivated);
 716
 717/**
 718 * nfc_alloc_send_skb - allocate a skb for data exchange responses
 719 *
 720 * @size: size to allocate
 721 * @gfp: gfp flags
 722 */
 723struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
 724				   unsigned int flags, unsigned int size,
 725				   unsigned int *err)
 726{
 727	struct sk_buff *skb;
 728	unsigned int total_size;
 729
 730	total_size = size +
 731		dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE;
 732
 733	skb = sock_alloc_send_skb(sk, total_size, flags & MSG_DONTWAIT, err);
 734	if (skb)
 735		skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
 736
 737	return skb;
 738}
 739
 740/**
 741 * nfc_alloc_recv_skb - allocate a skb for data exchange responses
 742 *
 743 * @size: size to allocate
 744 * @gfp: gfp flags
 745 */
 746struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp)
 747{
 748	struct sk_buff *skb;
 749	unsigned int total_size;
 750
 751	total_size = size + 1;
 752	skb = alloc_skb(total_size, gfp);
 753
 754	if (skb)
 755		skb_reserve(skb, 1);
 756
 757	return skb;
 758}
 759EXPORT_SYMBOL(nfc_alloc_recv_skb);
 760
 761/**
 762 * nfc_targets_found - inform that targets were found
 763 *
 764 * @dev: The nfc device that found the targets
 765 * @targets: array of nfc targets found
 766 * @ntargets: targets array size
 767 *
 768 * The device driver must call this function when one or many nfc targets
 769 * are found. After calling this function, the device driver must stop
 770 * polling for targets.
 771 * NOTE: This function can be called with targets=NULL and n_targets=0 to
 772 * notify a driver error, meaning that the polling operation cannot complete.
 773 * IMPORTANT: this function must not be called from an atomic context.
 774 * In addition, it must also not be called from a context that would prevent
 775 * the NFC Core to call other nfc ops entry point concurrently.
 776 */
 777int nfc_targets_found(struct nfc_dev *dev,
 778		      struct nfc_target *targets, int n_targets)
 779{
 780	int i;
 781
 782	pr_debug("dev_name=%s n_targets=%d\n", dev_name(&dev->dev), n_targets);
 783
 
 
 784	for (i = 0; i < n_targets; i++)
 785		targets[i].idx = dev->target_next_idx++;
 786
 787	device_lock(&dev->dev);
 788
 789	if (dev->polling == false) {
 790		device_unlock(&dev->dev);
 791		return 0;
 792	}
 793
 794	dev->polling = false;
 795
 796	dev->targets_generation++;
 797
 798	kfree(dev->targets);
 799	dev->targets = NULL;
 
 800
 801	if (targets) {
 802		dev->targets = kmemdup(targets,
 803				       n_targets * sizeof(struct nfc_target),
 804				       GFP_ATOMIC);
 805
 806		if (!dev->targets) {
 807			dev->n_targets = 0;
 808			device_unlock(&dev->dev);
 809			return -ENOMEM;
 810		}
 811	}
 812
 813	dev->n_targets = n_targets;
 814	device_unlock(&dev->dev);
 815
 816	nfc_genl_targets_found(dev);
 817
 818	return 0;
 819}
 820EXPORT_SYMBOL(nfc_targets_found);
 821
 822/**
 823 * nfc_target_lost - inform that an activated target went out of field
 824 *
 825 * @dev: The nfc device that had the activated target in field
 826 * @target_idx: the nfc index of the target
 827 *
 828 * The device driver must call this function when the activated target
 829 * goes out of the field.
 830 * IMPORTANT: this function must not be called from an atomic context.
 831 * In addition, it must also not be called from a context that would prevent
 832 * the NFC Core to call other nfc ops entry point concurrently.
 833 */
 834int nfc_target_lost(struct nfc_dev *dev, u32 target_idx)
 835{
 836	struct nfc_target *tg;
 837	int i;
 838
 839	pr_debug("dev_name %s n_target %d\n", dev_name(&dev->dev), target_idx);
 840
 841	device_lock(&dev->dev);
 842
 843	for (i = 0; i < dev->n_targets; i++) {
 844		tg = &dev->targets[i];
 845		if (tg->idx == target_idx)
 846			break;
 847	}
 848
 849	if (i == dev->n_targets) {
 850		device_unlock(&dev->dev);
 851		return -EINVAL;
 852	}
 853
 854	dev->targets_generation++;
 855	dev->n_targets--;
 856	dev->active_target = NULL;
 857
 858	if (dev->n_targets) {
 859		memcpy(&dev->targets[i], &dev->targets[i + 1],
 860		       (dev->n_targets - i) * sizeof(struct nfc_target));
 861	} else {
 862		kfree(dev->targets);
 863		dev->targets = NULL;
 864	}
 865
 866	device_unlock(&dev->dev);
 867
 868	nfc_genl_target_lost(dev, target_idx);
 869
 870	return 0;
 871}
 872EXPORT_SYMBOL(nfc_target_lost);
 873
 874inline void nfc_driver_failure(struct nfc_dev *dev, int err)
 875{
 876	nfc_targets_found(dev, NULL, 0);
 877}
 878EXPORT_SYMBOL(nfc_driver_failure);
 879
 880int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type)
 881{
 882	struct nfc_se *se;
 883	int rc;
 884
 885	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
 886
 887	se = nfc_find_se(dev, se_idx);
 888	if (se)
 889		return -EALREADY;
 890
 891	se = kzalloc(sizeof(struct nfc_se), GFP_KERNEL);
 892	if (!se)
 893		return -ENOMEM;
 894
 895	se->idx = se_idx;
 896	se->type = type;
 897	se->state = NFC_SE_DISABLED;
 898	INIT_LIST_HEAD(&se->list);
 899
 900	list_add(&se->list, &dev->secure_elements);
 901
 902	rc = nfc_genl_se_added(dev, se_idx, type);
 903	if (rc < 0) {
 904		list_del(&se->list);
 905		kfree(se);
 906
 907		return rc;
 908	}
 909
 910	return 0;
 911}
 912EXPORT_SYMBOL(nfc_add_se);
 913
 914int nfc_remove_se(struct nfc_dev *dev, u32 se_idx)
 915{
 916	struct nfc_se *se, *n;
 917	int rc;
 918
 919	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
 920
 921	list_for_each_entry_safe(se, n, &dev->secure_elements, list)
 922		if (se->idx == se_idx) {
 923			rc = nfc_genl_se_removed(dev, se_idx);
 924			if (rc < 0)
 925				return rc;
 926
 927			list_del(&se->list);
 928			kfree(se);
 929
 930			return 0;
 931		}
 932
 933	return -EINVAL;
 934}
 935EXPORT_SYMBOL(nfc_remove_se);
 936
 937static void nfc_release(struct device *d)
 938{
 939	struct nfc_dev *dev = to_nfc_dev(d);
 940	struct nfc_se *se, *n;
 941
 942	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
 943
 
 
 
 
 
 944	nfc_genl_data_exit(&dev->genl_data);
 945	kfree(dev->targets);
 946
 947	list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
 948			nfc_genl_se_removed(dev, se->idx);
 949			list_del(&se->list);
 950			kfree(se);
 951	}
 952
 953	kfree(dev);
 954}
 955
 956static void nfc_check_pres_work(struct work_struct *work)
 957{
 958	struct nfc_dev *dev = container_of(work, struct nfc_dev,
 959					   check_pres_work);
 960	int rc;
 961
 962	device_lock(&dev->dev);
 963
 964	if (dev->active_target && timer_pending(&dev->check_pres_timer) == 0) {
 965		rc = dev->ops->check_presence(dev, dev->active_target);
 966		if (rc == -EOPNOTSUPP)
 967			goto exit;
 968		if (rc) {
 
 969			u32 active_target_idx = dev->active_target->idx;
 970			device_unlock(&dev->dev);
 971			nfc_target_lost(dev, active_target_idx);
 972			return;
 973		}
 974
 975		if (!dev->shutting_down)
 976			mod_timer(&dev->check_pres_timer, jiffies +
 977				  msecs_to_jiffies(NFC_CHECK_PRES_FREQ_MS));
 978	}
 979
 980exit:
 981	device_unlock(&dev->dev);
 982}
 983
 984static void nfc_check_pres_timeout(unsigned long data)
 985{
 986	struct nfc_dev *dev = (struct nfc_dev *)data;
 987
 988	schedule_work(&dev->check_pres_work);
 989}
 990
 991struct class nfc_class = {
 992	.name = "nfc",
 993	.dev_release = nfc_release,
 994};
 995EXPORT_SYMBOL(nfc_class);
 996
 997static int match_idx(struct device *d, const void *data)
 998{
 999	struct nfc_dev *dev = to_nfc_dev(d);
1000	const unsigned int *idx = data;
1001
1002	return dev->idx == *idx;
1003}
1004
1005struct nfc_dev *nfc_get_device(unsigned int idx)
1006{
1007	struct device *d;
1008
1009	d = class_find_device(&nfc_class, NULL, &idx, match_idx);
1010	if (!d)
1011		return NULL;
1012
1013	return to_nfc_dev(d);
1014}
1015
1016/**
1017 * nfc_allocate_device - allocate a new nfc device
1018 *
1019 * @ops: device operations
1020 * @supported_protocols: NFC protocols supported by the device
1021 */
1022struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
1023				    u32 supported_protocols,
1024				    int tx_headroom, int tx_tailroom)
1025{
 
1026	struct nfc_dev *dev;
1027
1028	if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
1029	    !ops->deactivate_target || !ops->im_transceive)
1030		return NULL;
1031
1032	if (!supported_protocols)
1033		return NULL;
1034
1035	dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
1036	if (!dev)
1037		return NULL;
1038
 
 
 
 
 
1039	dev->ops = ops;
1040	dev->supported_protocols = supported_protocols;
1041	dev->tx_headroom = tx_headroom;
1042	dev->tx_tailroom = tx_tailroom;
1043	INIT_LIST_HEAD(&dev->secure_elements);
1044
1045	nfc_genl_data_init(&dev->genl_data);
1046
1047	dev->rf_mode = NFC_RF_NONE;
1048
1049	/* first generation must not be 0 */
1050	dev->targets_generation = 1;
1051
1052	if (ops->check_presence) {
 
1053		init_timer(&dev->check_pres_timer);
1054		dev->check_pres_timer.data = (unsigned long)dev;
1055		dev->check_pres_timer.function = nfc_check_pres_timeout;
1056
1057		INIT_WORK(&dev->check_pres_work, nfc_check_pres_work);
 
 
 
 
 
 
 
 
1058	}
1059
1060	return dev;
1061}
1062EXPORT_SYMBOL(nfc_allocate_device);
1063
1064/**
1065 * nfc_register_device - register a nfc device in the nfc subsystem
1066 *
1067 * @dev: The nfc device to register
1068 */
1069int nfc_register_device(struct nfc_dev *dev)
1070{
1071	int rc;
1072
1073	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1074
1075	dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL);
1076	if (dev->idx < 0)
1077		return dev->idx;
1078
1079	dev->dev.class = &nfc_class;
1080	dev_set_name(&dev->dev, "nfc%d", dev->idx);
1081	device_initialize(&dev->dev);
1082
1083	mutex_lock(&nfc_devlist_mutex);
1084	nfc_devlist_generation++;
1085	rc = device_add(&dev->dev);
1086	mutex_unlock(&nfc_devlist_mutex);
1087
1088	if (rc < 0)
1089		return rc;
1090
1091	rc = nfc_llcp_register_device(dev);
1092	if (rc)
1093		pr_err("Could not register llcp device\n");
1094
1095	rc = nfc_genl_device_added(dev);
1096	if (rc)
1097		pr_debug("The userspace won't be notified that the device %s was added\n",
1098			 dev_name(&dev->dev));
1099
1100	dev->rfkill = rfkill_alloc(dev_name(&dev->dev), &dev->dev,
1101				   RFKILL_TYPE_NFC, &nfc_rfkill_ops, dev);
1102	if (dev->rfkill) {
1103		if (rfkill_register(dev->rfkill) < 0) {
1104			rfkill_destroy(dev->rfkill);
1105			dev->rfkill = NULL;
1106		}
1107	}
1108
1109	return 0;
1110}
1111EXPORT_SYMBOL(nfc_register_device);
1112
1113/**
1114 * nfc_unregister_device - unregister a nfc device in the nfc subsystem
1115 *
1116 * @dev: The nfc device to unregister
1117 */
1118void nfc_unregister_device(struct nfc_dev *dev)
1119{
1120	int rc, id;
1121
1122	pr_debug("dev_name=%s\n", dev_name(&dev->dev));
1123
1124	id = dev->idx;
 
 
 
 
 
 
 
1125
1126	if (dev->rfkill) {
1127		rfkill_unregister(dev->rfkill);
1128		rfkill_destroy(dev->rfkill);
1129	}
1130
1131	if (dev->ops->check_presence) {
1132		device_lock(&dev->dev);
1133		dev->shutting_down = true;
1134		device_unlock(&dev->dev);
1135		del_timer_sync(&dev->check_pres_timer);
1136		cancel_work_sync(&dev->check_pres_work);
1137	}
1138
1139	rc = nfc_genl_device_removed(dev);
1140	if (rc)
1141		pr_debug("The userspace won't be notified that the device %s "
1142			 "was removed\n", dev_name(&dev->dev));
1143
1144	nfc_llcp_unregister_device(dev);
1145
1146	mutex_lock(&nfc_devlist_mutex);
1147	nfc_devlist_generation++;
1148	device_del(&dev->dev);
1149	mutex_unlock(&nfc_devlist_mutex);
1150
1151	ida_simple_remove(&nfc_index_ida, id);
1152}
1153EXPORT_SYMBOL(nfc_unregister_device);
1154
1155static int __init nfc_init(void)
1156{
1157	int rc;
1158
1159	pr_info("NFC Core ver %s\n", VERSION);
1160
1161	rc = class_register(&nfc_class);
1162	if (rc)
1163		return rc;
1164
1165	rc = nfc_genl_init();
1166	if (rc)
1167		goto err_genl;
1168
1169	/* the first generation must not be 0 */
1170	nfc_devlist_generation = 1;
1171
1172	rc = rawsock_init();
1173	if (rc)
1174		goto err_rawsock;
1175
1176	rc = nfc_llcp_init();
1177	if (rc)
1178		goto err_llcp_sock;
1179
1180	rc = af_nfc_init();
1181	if (rc)
1182		goto err_af_nfc;
1183
1184	return 0;
1185
1186err_af_nfc:
1187	nfc_llcp_exit();
1188err_llcp_sock:
1189	rawsock_exit();
1190err_rawsock:
1191	nfc_genl_exit();
1192err_genl:
1193	class_unregister(&nfc_class);
1194	return rc;
1195}
1196
1197static void __exit nfc_exit(void)
1198{
1199	af_nfc_exit();
1200	nfc_llcp_exit();
1201	rawsock_exit();
1202	nfc_genl_exit();
1203	class_unregister(&nfc_class);
1204}
1205
1206subsys_initcall(nfc_init);
1207module_exit(nfc_exit);
1208
1209MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
1210MODULE_DESCRIPTION("NFC Core ver " VERSION);
1211MODULE_VERSION(VERSION);
1212MODULE_LICENSE("GPL");
1213MODULE_ALIAS_NETPROTO(PF_NFC);
1214MODULE_ALIAS_GENL_FAMILY(NFC_GENL_NAME);