284e2f6a14ff490f287354bdd60058b87123d475
[linux-2.6.git] / net / nfc / core.c
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 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28
29 #include "nfc.h"
30
31 #define VERSION "0.1"
32
33 int nfc_devlist_generation;
34 DEFINE_MUTEX(nfc_devlist_mutex);
35
36 int nfc_printk(const char *level, const char *format, ...)
37 {
38         struct va_format vaf;
39         va_list args;
40         int r;
41
42         va_start(args, format);
43
44         vaf.fmt = format;
45         vaf.va = &args;
46
47         r = printk("%sNFC: %pV\n", level, &vaf);
48
49         va_end(args);
50
51         return r;
52 }
53 EXPORT_SYMBOL(nfc_printk);
54
55 /**
56  * nfc_start_poll - start polling for nfc targets
57  *
58  * @dev: The nfc device that must start polling
59  * @protocols: bitset of nfc protocols that must be used for polling
60  *
61  * The device remains polling for targets until a target is found or
62  * the nfc_stop_poll function is called.
63  */
64 int nfc_start_poll(struct nfc_dev *dev, u32 protocols)
65 {
66         int rc;
67
68         nfc_dbg("dev_name=%s protocols=0x%x", dev_name(&dev->dev), protocols);
69
70         if (!protocols)
71                 return -EINVAL;
72
73         device_lock(&dev->dev);
74
75         if (!device_is_registered(&dev->dev)) {
76                 rc = -ENODEV;
77                 goto error;
78         }
79
80         if (dev->polling) {
81                 rc = -EBUSY;
82                 goto error;
83         }
84
85         rc = dev->ops->start_poll(dev, protocols);
86         if (!rc)
87                 dev->polling = true;
88
89 error:
90         device_unlock(&dev->dev);
91         return rc;
92 }
93
94 /**
95  * nfc_stop_poll - stop polling for nfc targets
96  *
97  * @dev: The nfc device that must stop polling
98  */
99 int nfc_stop_poll(struct nfc_dev *dev)
100 {
101         int rc = 0;
102
103         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
104
105         device_lock(&dev->dev);
106
107         if (!device_is_registered(&dev->dev)) {
108                 rc = -ENODEV;
109                 goto error;
110         }
111
112         if (!dev->polling) {
113                 rc = -EINVAL;
114                 goto error;
115         }
116
117         dev->ops->stop_poll(dev);
118         dev->polling = false;
119
120 error:
121         device_unlock(&dev->dev);
122         return rc;
123 }
124
125 /**
126  * nfc_activate_target - prepare the target for data exchange
127  *
128  * @dev: The nfc device that found the target
129  * @target_idx: index of the target that must be activated
130  * @protocol: nfc protocol that will be used for data exchange
131  */
132 int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
133 {
134         int rc;
135
136         nfc_dbg("dev_name=%s target_idx=%u protocol=%u", dev_name(&dev->dev),
137                                                         target_idx, protocol);
138
139         device_lock(&dev->dev);
140
141         if (!device_is_registered(&dev->dev)) {
142                 rc = -ENODEV;
143                 goto error;
144         }
145
146         rc = dev->ops->activate_target(dev, target_idx, protocol);
147
148 error:
149         device_unlock(&dev->dev);
150         return rc;
151 }
152
153 /**
154  * nfc_deactivate_target - deactivate a nfc target
155  *
156  * @dev: The nfc device that found the target
157  * @target_idx: index of the target that must be deactivated
158  */
159 int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
160 {
161         int rc = 0;
162
163         nfc_dbg("dev_name=%s target_idx=%u", dev_name(&dev->dev), target_idx);
164
165         device_lock(&dev->dev);
166
167         if (!device_is_registered(&dev->dev)) {
168                 rc = -ENODEV;
169                 goto error;
170         }
171
172         dev->ops->deactivate_target(dev, target_idx);
173
174 error:
175         device_unlock(&dev->dev);
176         return rc;
177 }
178
179 /**
180  * nfc_data_exchange - transceive data
181  *
182  * @dev: The nfc device that found the target
183  * @target_idx: index of the target
184  * @skb: data to be sent
185  * @cb: callback called when the response is received
186  * @cb_context: parameter for the callback function
187  *
188  * The user must wait for the callback before calling this function again.
189  */
190 int nfc_data_exchange(struct nfc_dev *dev, u32 target_idx,
191                                         struct sk_buff *skb,
192                                         data_exchange_cb_t cb,
193                                         void *cb_context)
194 {
195         int rc;
196
197         nfc_dbg("dev_name=%s target_idx=%u skb->len=%u", dev_name(&dev->dev),
198                                                         target_idx, skb->len);
199
200         device_lock(&dev->dev);
201
202         if (!device_is_registered(&dev->dev)) {
203                 rc = -ENODEV;
204                 kfree_skb(skb);
205                 goto error;
206         }
207
208         rc = dev->ops->data_exchange(dev, target_idx, skb, cb, cb_context);
209
210 error:
211         device_unlock(&dev->dev);
212         return rc;
213 }
214
215 /**
216  * nfc_alloc_skb - allocate a skb for data exchange responses
217  *
218  * @size: size to allocate
219  * @gfp: gfp flags
220  */
221 struct sk_buff *nfc_alloc_skb(unsigned int size, gfp_t gfp)
222 {
223         struct sk_buff *skb;
224         unsigned int total_size;
225
226         total_size = size + 1;
227         skb = alloc_skb(total_size, gfp);
228
229         if (skb)
230                 skb_reserve(skb, 1);
231
232         return skb;
233 }
234 EXPORT_SYMBOL(nfc_alloc_skb);
235
236 /**
237  * nfc_targets_found - inform that targets were found
238  *
239  * @dev: The nfc device that found the targets
240  * @targets: array of nfc targets found
241  * @ntargets: targets array size
242  *
243  * The device driver must call this function when one or many nfc targets
244  * are found. After calling this function, the device driver must stop
245  * polling for targets.
246  */
247 int nfc_targets_found(struct nfc_dev *dev, struct nfc_target *targets,
248                                                         int n_targets)
249 {
250         int i;
251
252         nfc_dbg("dev_name=%s n_targets=%d", dev_name(&dev->dev), n_targets);
253
254         dev->polling = false;
255
256         for (i = 0; i < n_targets; i++)
257                 targets[i].idx = dev->target_idx++;
258
259         spin_lock_bh(&dev->targets_lock);
260
261         dev->targets_generation++;
262
263         kfree(dev->targets);
264         dev->targets = kmemdup(targets, n_targets * sizeof(struct nfc_target),
265                                                                 GFP_ATOMIC);
266
267         if (!dev->targets) {
268                 dev->n_targets = 0;
269                 spin_unlock_bh(&dev->targets_lock);
270                 return -ENOMEM;
271         }
272
273         dev->n_targets = n_targets;
274         spin_unlock_bh(&dev->targets_lock);
275
276         nfc_genl_targets_found(dev);
277
278         return 0;
279 }
280 EXPORT_SYMBOL(nfc_targets_found);
281
282 static void nfc_release(struct device *d)
283 {
284         struct nfc_dev *dev = to_nfc_dev(d);
285
286         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
287
288         nfc_genl_data_exit(&dev->genl_data);
289         kfree(dev->targets);
290         kfree(dev);
291 }
292
293 struct class nfc_class = {
294         .name = "nfc",
295         .dev_release = nfc_release,
296 };
297 EXPORT_SYMBOL(nfc_class);
298
299 static int match_idx(struct device *d, void *data)
300 {
301         struct nfc_dev *dev = to_nfc_dev(d);
302         unsigned *idx = data;
303
304         return dev->idx == *idx;
305 }
306
307 struct nfc_dev *nfc_get_device(unsigned idx)
308 {
309         struct device *d;
310
311         d = class_find_device(&nfc_class, NULL, &idx, match_idx);
312         if (!d)
313                 return NULL;
314
315         return to_nfc_dev(d);
316 }
317
318 /**
319  * nfc_allocate_device - allocate a new nfc device
320  *
321  * @ops: device operations
322  * @supported_protocols: NFC protocols supported by the device
323  */
324 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
325                                         u32 supported_protocols,
326                                         int tx_headroom,
327                                         int tx_tailroom)
328 {
329         static atomic_t dev_no = ATOMIC_INIT(0);
330         struct nfc_dev *dev;
331
332         if (!ops->start_poll || !ops->stop_poll || !ops->activate_target ||
333                 !ops->deactivate_target || !ops->data_exchange)
334                 return NULL;
335
336         if (!supported_protocols)
337                 return NULL;
338
339         dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL);
340         if (!dev)
341                 return NULL;
342
343         dev->dev.class = &nfc_class;
344         dev->idx = atomic_inc_return(&dev_no) - 1;
345         dev_set_name(&dev->dev, "nfc%d", dev->idx);
346         device_initialize(&dev->dev);
347
348         dev->ops = ops;
349         dev->supported_protocols = supported_protocols;
350         dev->tx_headroom = tx_headroom;
351         dev->tx_tailroom = tx_tailroom;
352
353         spin_lock_init(&dev->targets_lock);
354         nfc_genl_data_init(&dev->genl_data);
355
356         /* first generation must not be 0 */
357         dev->targets_generation = 1;
358
359         return dev;
360 }
361 EXPORT_SYMBOL(nfc_allocate_device);
362
363 /**
364  * nfc_register_device - register a nfc device in the nfc subsystem
365  *
366  * @dev: The nfc device to register
367  */
368 int nfc_register_device(struct nfc_dev *dev)
369 {
370         int rc;
371
372         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
373
374         mutex_lock(&nfc_devlist_mutex);
375         nfc_devlist_generation++;
376         rc = device_add(&dev->dev);
377         mutex_unlock(&nfc_devlist_mutex);
378
379         if (rc < 0)
380                 return rc;
381
382         rc = nfc_genl_device_added(dev);
383         if (rc)
384                 nfc_dbg("The userspace won't be notified that the device %s was"
385                                                 " added", dev_name(&dev->dev));
386
387
388         return 0;
389 }
390 EXPORT_SYMBOL(nfc_register_device);
391
392 /**
393  * nfc_unregister_device - unregister a nfc device in the nfc subsystem
394  *
395  * @dev: The nfc device to unregister
396  */
397 void nfc_unregister_device(struct nfc_dev *dev)
398 {
399         int rc;
400
401         nfc_dbg("dev_name=%s", dev_name(&dev->dev));
402
403         mutex_lock(&nfc_devlist_mutex);
404         nfc_devlist_generation++;
405
406         /* lock to avoid unregistering a device while an operation
407            is in progress */
408         device_lock(&dev->dev);
409         device_del(&dev->dev);
410         device_unlock(&dev->dev);
411
412         mutex_unlock(&nfc_devlist_mutex);
413
414         rc = nfc_genl_device_removed(dev);
415         if (rc)
416                 nfc_dbg("The userspace won't be notified that the device %s"
417                                         " was removed", dev_name(&dev->dev));
418
419 }
420 EXPORT_SYMBOL(nfc_unregister_device);
421
422 static int __init nfc_init(void)
423 {
424         int rc;
425
426         nfc_info("NFC Core ver %s", VERSION);
427
428         rc = class_register(&nfc_class);
429         if (rc)
430                 return rc;
431
432         rc = nfc_genl_init();
433         if (rc)
434                 goto err_genl;
435
436         /* the first generation must not be 0 */
437         nfc_devlist_generation = 1;
438
439         rc = rawsock_init();
440         if (rc)
441                 goto err_rawsock;
442
443         rc = af_nfc_init();
444         if (rc)
445                 goto err_af_nfc;
446
447         return 0;
448
449 err_af_nfc:
450         rawsock_exit();
451 err_rawsock:
452         nfc_genl_exit();
453 err_genl:
454         class_unregister(&nfc_class);
455         return rc;
456 }
457
458 static void __exit nfc_exit(void)
459 {
460         af_nfc_exit();
461         rawsock_exit();
462         nfc_genl_exit();
463         class_unregister(&nfc_class);
464 }
465
466 subsys_initcall(nfc_init);
467 module_exit(nfc_exit);
468
469 MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
470 MODULE_DESCRIPTION("NFC Core ver " VERSION);
471 MODULE_VERSION(VERSION);
472 MODULE_LICENSE("GPL");