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