blob: 284e2f6a14ff490f287354bdd60058b87123d475 [file] [log] [blame]
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -03001/*
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
33int nfc_devlist_generation;
34DEFINE_MUTEX(nfc_devlist_mutex);
35
36int 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}
53EXPORT_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 */
64int 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
89error:
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 */
99int 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
120error:
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 */
132int 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
148error:
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 */
159int 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
174error:
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 */
190int 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
210error:
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 */
221struct 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}
234EXPORT_SYMBOL(nfc_alloc_skb);
235
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300236/**
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 */
247int 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}
280EXPORT_SYMBOL(nfc_targets_found);
281
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300282static 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
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300288 nfc_genl_data_exit(&dev->genl_data);
289 kfree(dev->targets);
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300290 kfree(dev);
291}
292
293struct class nfc_class = {
294 .name = "nfc",
295 .dev_release = nfc_release,
296};
297EXPORT_SYMBOL(nfc_class);
298
299static 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
307struct 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 */
324struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
Samuel Ortize8753042011-08-19 15:47:11 +0200325 u32 supported_protocols,
326 int tx_headroom,
327 int tx_tailroom)
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300328{
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;
Samuel Ortize8753042011-08-19 15:47:11 +0200350 dev->tx_headroom = tx_headroom;
351 dev->tx_tailroom = tx_tailroom;
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300352
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300353 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
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300359 return dev;
360}
361EXPORT_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 */
368int 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
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300379 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;
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300389}
390EXPORT_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 */
397void nfc_unregister_device(struct nfc_dev *dev)
398{
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300399 int rc;
400
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300401 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);
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300413
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
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300419}
420EXPORT_SYMBOL(nfc_unregister_device);
421
422static int __init nfc_init(void)
423{
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300424 int rc;
425
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300426 nfc_info("NFC Core ver %s", VERSION);
427
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300428 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
Lauro Ramos Venancio23b78692011-07-01 19:31:36 -0300439 rc = rawsock_init();
440 if (rc)
441 goto err_rawsock;
442
Aloisio Almeida Jrc7fe3b52011-07-01 19:31:35 -0300443 rc = af_nfc_init();
444 if (rc)
445 goto err_af_nfc;
446
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300447 return 0;
448
Aloisio Almeida Jrc7fe3b52011-07-01 19:31:35 -0300449err_af_nfc:
Lauro Ramos Venancio23b78692011-07-01 19:31:36 -0300450 rawsock_exit();
451err_rawsock:
Aloisio Almeida Jrc7fe3b52011-07-01 19:31:35 -0300452 nfc_genl_exit();
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300453err_genl:
454 class_unregister(&nfc_class);
455 return rc;
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300456}
457
458static void __exit nfc_exit(void)
459{
Aloisio Almeida Jrc7fe3b52011-07-01 19:31:35 -0300460 af_nfc_exit();
Lauro Ramos Venancio23b78692011-07-01 19:31:36 -0300461 rawsock_exit();
Lauro Ramos Venancio4d12b8b2011-07-01 19:31:34 -0300462 nfc_genl_exit();
Lauro Ramos Venancio3e256b82011-07-01 19:31:33 -0300463 class_unregister(&nfc_class);
464}
465
466subsys_initcall(nfc_init);
467module_exit(nfc_exit);
468
469MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
470MODULE_DESCRIPTION("NFC Core ver " VERSION);
471MODULE_VERSION(VERSION);
472MODULE_LICENSE("GPL");