Loading...
1/*
2 * NFC hardware simulation driver
3 * Copyright (c) 2013, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 */
15
16#include <linux/device.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/nfc.h>
20#include <net/nfc/nfc.h>
21
22#define DEV_ERR(_dev, fmt, args...) nfc_err(&_dev->nfc_dev->dev, \
23 "%s: " fmt, __func__, ## args)
24
25#define DEV_DBG(_dev, fmt, args...) dev_dbg(&_dev->nfc_dev->dev, \
26 "%s: " fmt, __func__, ## args)
27
28#define NFCSIM_VERSION "0.1"
29
30#define NFCSIM_POLL_NONE 0
31#define NFCSIM_POLL_INITIATOR 1
32#define NFCSIM_POLL_TARGET 2
33#define NFCSIM_POLL_DUAL (NFCSIM_POLL_INITIATOR | NFCSIM_POLL_TARGET)
34
35#define RX_DEFAULT_DELAY 5
36
37struct nfcsim {
38 struct nfc_dev *nfc_dev;
39
40 struct mutex lock;
41
42 struct delayed_work recv_work;
43
44 struct sk_buff *clone_skb;
45
46 struct delayed_work poll_work;
47 u8 polling_mode;
48 u8 curr_polling_mode;
49
50 u8 shutting_down;
51
52 u8 up;
53
54 u8 initiator;
55
56 u32 rx_delay;
57
58 data_exchange_cb_t cb;
59 void *cb_context;
60
61 struct nfcsim *peer_dev;
62};
63
64static struct nfcsim *dev0;
65static struct nfcsim *dev1;
66
67static struct workqueue_struct *wq;
68
69static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown)
70{
71 DEV_DBG(dev, "shutdown=%d\n", shutdown);
72
73 mutex_lock(&dev->lock);
74
75 dev->polling_mode = NFCSIM_POLL_NONE;
76 dev->shutting_down = shutdown;
77 dev->cb = NULL;
78 dev_kfree_skb(dev->clone_skb);
79 dev->clone_skb = NULL;
80
81 mutex_unlock(&dev->lock);
82
83 cancel_delayed_work_sync(&dev->poll_work);
84 cancel_delayed_work_sync(&dev->recv_work);
85}
86
87static int nfcsim_target_found(struct nfcsim *dev)
88{
89 struct nfc_target nfc_tgt;
90
91 DEV_DBG(dev, "\n");
92
93 memset(&nfc_tgt, 0, sizeof(struct nfc_target));
94
95 nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
96 nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
97
98 return 0;
99}
100
101static int nfcsim_dev_up(struct nfc_dev *nfc_dev)
102{
103 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
104
105 DEV_DBG(dev, "\n");
106
107 mutex_lock(&dev->lock);
108
109 dev->up = 1;
110
111 mutex_unlock(&dev->lock);
112
113 return 0;
114}
115
116static int nfcsim_dev_down(struct nfc_dev *nfc_dev)
117{
118 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
119
120 DEV_DBG(dev, "\n");
121
122 mutex_lock(&dev->lock);
123
124 dev->up = 0;
125
126 mutex_unlock(&dev->lock);
127
128 return 0;
129}
130
131static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev,
132 struct nfc_target *target,
133 u8 comm_mode, u8 *gb, size_t gb_len)
134{
135 int rc;
136 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
137 struct nfcsim *peer = dev->peer_dev;
138 u8 *remote_gb;
139 size_t remote_gb_len;
140
141 DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode);
142
143 mutex_lock(&peer->lock);
144
145 nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
146 NFC_COMM_ACTIVE, gb, gb_len);
147
148 remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len);
149 if (!remote_gb) {
150 DEV_ERR(peer, "Can't get remote general bytes\n");
151
152 mutex_unlock(&peer->lock);
153 return -EINVAL;
154 }
155
156 mutex_unlock(&peer->lock);
157
158 mutex_lock(&dev->lock);
159
160 rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len);
161 if (rc) {
162 DEV_ERR(dev, "Can't set remote general bytes\n");
163 mutex_unlock(&dev->lock);
164 return rc;
165 }
166
167 rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE,
168 NFC_RF_INITIATOR);
169
170 mutex_unlock(&dev->lock);
171
172 return rc;
173}
174
175static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev)
176{
177 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
178
179 DEV_DBG(dev, "\n");
180
181 nfcsim_cleanup_dev(dev, 0);
182
183 return 0;
184}
185
186static int nfcsim_start_poll(struct nfc_dev *nfc_dev,
187 u32 im_protocols, u32 tm_protocols)
188{
189 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
190 int rc;
191
192 mutex_lock(&dev->lock);
193
194 if (dev->polling_mode != NFCSIM_POLL_NONE) {
195 DEV_ERR(dev, "Already in polling mode\n");
196 rc = -EBUSY;
197 goto exit;
198 }
199
200 if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
201 dev->polling_mode |= NFCSIM_POLL_INITIATOR;
202
203 if (tm_protocols & NFC_PROTO_NFC_DEP_MASK)
204 dev->polling_mode |= NFCSIM_POLL_TARGET;
205
206 if (dev->polling_mode == NFCSIM_POLL_NONE) {
207 DEV_ERR(dev, "Unsupported polling mode\n");
208 rc = -EINVAL;
209 goto exit;
210 }
211
212 dev->initiator = 0;
213 dev->curr_polling_mode = NFCSIM_POLL_NONE;
214
215 queue_delayed_work(wq, &dev->poll_work, 0);
216
217 DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols,
218 tm_protocols);
219
220 rc = 0;
221exit:
222 mutex_unlock(&dev->lock);
223
224 return rc;
225}
226
227static void nfcsim_stop_poll(struct nfc_dev *nfc_dev)
228{
229 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
230
231 DEV_DBG(dev, "Stop poll\n");
232
233 mutex_lock(&dev->lock);
234
235 dev->polling_mode = NFCSIM_POLL_NONE;
236
237 mutex_unlock(&dev->lock);
238
239 cancel_delayed_work_sync(&dev->poll_work);
240}
241
242static int nfcsim_activate_target(struct nfc_dev *nfc_dev,
243 struct nfc_target *target, u32 protocol)
244{
245 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
246
247 DEV_DBG(dev, "\n");
248
249 return -ENOTSUPP;
250}
251
252static void nfcsim_deactivate_target(struct nfc_dev *nfc_dev,
253 struct nfc_target *target, u8 mode)
254{
255 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
256
257 DEV_DBG(dev, "\n");
258}
259
260static void nfcsim_wq_recv(struct work_struct *work)
261{
262 struct nfcsim *dev = container_of(work, struct nfcsim,
263 recv_work.work);
264
265 mutex_lock(&dev->lock);
266
267 if (dev->shutting_down || !dev->up || !dev->clone_skb) {
268 dev_kfree_skb(dev->clone_skb);
269 goto exit;
270 }
271
272 if (dev->initiator) {
273 if (!dev->cb) {
274 DEV_ERR(dev, "Null recv callback\n");
275 dev_kfree_skb(dev->clone_skb);
276 goto exit;
277 }
278
279 dev->cb(dev->cb_context, dev->clone_skb, 0);
280 dev->cb = NULL;
281 } else {
282 nfc_tm_data_received(dev->nfc_dev, dev->clone_skb);
283 }
284
285exit:
286 dev->clone_skb = NULL;
287
288 mutex_unlock(&dev->lock);
289}
290
291static int nfcsim_tx(struct nfc_dev *nfc_dev, struct nfc_target *target,
292 struct sk_buff *skb, data_exchange_cb_t cb,
293 void *cb_context)
294{
295 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
296 struct nfcsim *peer = dev->peer_dev;
297 int err;
298
299 mutex_lock(&dev->lock);
300
301 if (dev->shutting_down || !dev->up) {
302 mutex_unlock(&dev->lock);
303 err = -ENODEV;
304 goto exit;
305 }
306
307 dev->cb = cb;
308 dev->cb_context = cb_context;
309
310 mutex_unlock(&dev->lock);
311
312 mutex_lock(&peer->lock);
313
314 peer->clone_skb = skb_clone(skb, GFP_KERNEL);
315
316 if (!peer->clone_skb) {
317 DEV_ERR(dev, "skb_clone failed\n");
318 mutex_unlock(&peer->lock);
319 err = -ENOMEM;
320 goto exit;
321 }
322
323 /* This simulates an arbitrary transmission delay between the 2 devices.
324 * If packet transmission occurs immediately between them, we have a
325 * non-stop flow of several tens of thousands SYMM packets per second
326 * and a burning cpu.
327 */
328 queue_delayed_work(wq, &peer->recv_work,
329 msecs_to_jiffies(dev->rx_delay));
330
331 mutex_unlock(&peer->lock);
332
333 err = 0;
334exit:
335 dev_kfree_skb(skb);
336
337 return err;
338}
339
340static int nfcsim_im_transceive(struct nfc_dev *nfc_dev,
341 struct nfc_target *target, struct sk_buff *skb,
342 data_exchange_cb_t cb, void *cb_context)
343{
344 return nfcsim_tx(nfc_dev, target, skb, cb, cb_context);
345}
346
347static int nfcsim_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
348{
349 return nfcsim_tx(nfc_dev, NULL, skb, NULL, NULL);
350}
351
352static struct nfc_ops nfcsim_nfc_ops = {
353 .dev_up = nfcsim_dev_up,
354 .dev_down = nfcsim_dev_down,
355 .dep_link_up = nfcsim_dep_link_up,
356 .dep_link_down = nfcsim_dep_link_down,
357 .start_poll = nfcsim_start_poll,
358 .stop_poll = nfcsim_stop_poll,
359 .activate_target = nfcsim_activate_target,
360 .deactivate_target = nfcsim_deactivate_target,
361 .im_transceive = nfcsim_im_transceive,
362 .tm_send = nfcsim_tm_send,
363};
364
365static void nfcsim_set_polling_mode(struct nfcsim *dev)
366{
367 if (dev->polling_mode == NFCSIM_POLL_NONE) {
368 dev->curr_polling_mode = NFCSIM_POLL_NONE;
369 return;
370 }
371
372 if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
373 if (dev->polling_mode & NFCSIM_POLL_INITIATOR)
374 dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
375 else
376 dev->curr_polling_mode = NFCSIM_POLL_TARGET;
377
378 return;
379 }
380
381 if (dev->polling_mode == NFCSIM_POLL_DUAL) {
382 if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
383 dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
384 else
385 dev->curr_polling_mode = NFCSIM_POLL_TARGET;
386 }
387}
388
389static void nfcsim_wq_poll(struct work_struct *work)
390{
391 struct nfcsim *dev = container_of(work, struct nfcsim, poll_work.work);
392 struct nfcsim *peer = dev->peer_dev;
393
394 /* These work items run on an ordered workqueue and are therefore
395 * serialized. So we can take both mutexes without being dead locked.
396 */
397 mutex_lock(&dev->lock);
398 mutex_lock(&peer->lock);
399
400 nfcsim_set_polling_mode(dev);
401
402 if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
403 DEV_DBG(dev, "Not polling\n");
404 goto unlock;
405 }
406
407 DEV_DBG(dev, "Polling as %s",
408 dev->curr_polling_mode == NFCSIM_POLL_INITIATOR ?
409 "initiator\n" : "target\n");
410
411 if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
412 goto sched_work;
413
414 if (peer->curr_polling_mode == NFCSIM_POLL_TARGET) {
415 peer->polling_mode = NFCSIM_POLL_NONE;
416 dev->polling_mode = NFCSIM_POLL_NONE;
417
418 dev->initiator = 1;
419
420 nfcsim_target_found(dev);
421
422 goto unlock;
423 }
424
425sched_work:
426 /* This defines the delay for an initiator to check if the other device
427 * is polling in target mode.
428 * If the device starts in dual mode polling, it switches between
429 * initiator and target at every round.
430 * Because the wq is ordered and only 1 work item is executed at a time,
431 * we'll always have one device polling as initiator and the other as
432 * target at some point, even if both are started in dual mode.
433 */
434 queue_delayed_work(wq, &dev->poll_work, msecs_to_jiffies(200));
435
436unlock:
437 mutex_unlock(&peer->lock);
438 mutex_unlock(&dev->lock);
439}
440
441static struct nfcsim *nfcsim_init_dev(void)
442{
443 struct nfcsim *dev;
444 int rc = -ENOMEM;
445
446 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
447 if (dev == NULL)
448 return ERR_PTR(-ENOMEM);
449
450 mutex_init(&dev->lock);
451
452 INIT_DELAYED_WORK(&dev->recv_work, nfcsim_wq_recv);
453 INIT_DELAYED_WORK(&dev->poll_work, nfcsim_wq_poll);
454
455 dev->nfc_dev = nfc_allocate_device(&nfcsim_nfc_ops,
456 NFC_PROTO_NFC_DEP_MASK,
457 0, 0);
458 if (!dev->nfc_dev)
459 goto error;
460
461 nfc_set_drvdata(dev->nfc_dev, dev);
462
463 rc = nfc_register_device(dev->nfc_dev);
464 if (rc)
465 goto free_nfc_dev;
466
467 dev->rx_delay = RX_DEFAULT_DELAY;
468 return dev;
469
470free_nfc_dev:
471 nfc_free_device(dev->nfc_dev);
472
473error:
474 kfree(dev);
475
476 return ERR_PTR(rc);
477}
478
479static void nfcsim_free_device(struct nfcsim *dev)
480{
481 nfc_unregister_device(dev->nfc_dev);
482
483 nfc_free_device(dev->nfc_dev);
484
485 kfree(dev);
486}
487
488static int __init nfcsim_init(void)
489{
490 int rc;
491
492 /* We need an ordered wq to ensure that poll_work items are executed
493 * one at a time.
494 */
495 wq = alloc_ordered_workqueue("nfcsim", 0);
496 if (!wq) {
497 rc = -ENOMEM;
498 goto exit;
499 }
500
501 dev0 = nfcsim_init_dev();
502 if (IS_ERR(dev0)) {
503 rc = PTR_ERR(dev0);
504 goto exit;
505 }
506
507 dev1 = nfcsim_init_dev();
508 if (IS_ERR(dev1)) {
509 kfree(dev0);
510
511 rc = PTR_ERR(dev1);
512 goto exit;
513 }
514
515 dev0->peer_dev = dev1;
516 dev1->peer_dev = dev0;
517
518 pr_debug("NFCsim " NFCSIM_VERSION " initialized\n");
519
520 rc = 0;
521exit:
522 if (rc)
523 pr_err("Failed to initialize nfcsim driver (%d)\n",
524 rc);
525
526 return rc;
527}
528
529static void __exit nfcsim_exit(void)
530{
531 nfcsim_cleanup_dev(dev0, 1);
532 nfcsim_cleanup_dev(dev1, 1);
533
534 nfcsim_free_device(dev0);
535 nfcsim_free_device(dev1);
536
537 destroy_workqueue(wq);
538}
539
540module_init(nfcsim_init);
541module_exit(nfcsim_exit);
542
543MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
544MODULE_VERSION(NFCSIM_VERSION);
545MODULE_LICENSE("GPL");
1/*
2 * NFC hardware simulation driver
3 * Copyright (c) 2013, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 */
15
16#include <linux/device.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/nfc.h>
20#include <net/nfc/nfc.h>
21
22#define DEV_ERR(_dev, fmt, args...) nfc_err(&_dev->nfc_dev->dev, \
23 "%s: " fmt, __func__, ## args)
24
25#define DEV_DBG(_dev, fmt, args...) dev_dbg(&_dev->nfc_dev->dev, \
26 "%s: " fmt, __func__, ## args)
27
28#define NFCSIM_VERSION "0.1"
29
30#define NFCSIM_POLL_NONE 0
31#define NFCSIM_POLL_INITIATOR 1
32#define NFCSIM_POLL_TARGET 2
33#define NFCSIM_POLL_DUAL (NFCSIM_POLL_INITIATOR | NFCSIM_POLL_TARGET)
34
35struct nfcsim {
36 struct nfc_dev *nfc_dev;
37
38 struct mutex lock;
39
40 struct delayed_work recv_work;
41
42 struct sk_buff *clone_skb;
43
44 struct delayed_work poll_work;
45 u8 polling_mode;
46 u8 curr_polling_mode;
47
48 u8 shutting_down;
49
50 u8 up;
51
52 u8 initiator;
53
54 data_exchange_cb_t cb;
55 void *cb_context;
56
57 struct nfcsim *peer_dev;
58};
59
60static struct nfcsim *dev0;
61static struct nfcsim *dev1;
62
63static struct workqueue_struct *wq;
64
65static void nfcsim_cleanup_dev(struct nfcsim *dev, u8 shutdown)
66{
67 DEV_DBG(dev, "shutdown=%d\n", shutdown);
68
69 mutex_lock(&dev->lock);
70
71 dev->polling_mode = NFCSIM_POLL_NONE;
72 dev->shutting_down = shutdown;
73 dev->cb = NULL;
74 dev_kfree_skb(dev->clone_skb);
75 dev->clone_skb = NULL;
76
77 mutex_unlock(&dev->lock);
78
79 cancel_delayed_work_sync(&dev->poll_work);
80 cancel_delayed_work_sync(&dev->recv_work);
81}
82
83static int nfcsim_target_found(struct nfcsim *dev)
84{
85 struct nfc_target nfc_tgt;
86
87 DEV_DBG(dev, "\n");
88
89 memset(&nfc_tgt, 0, sizeof(struct nfc_target));
90
91 nfc_tgt.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
92 nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
93
94 return 0;
95}
96
97static int nfcsim_dev_up(struct nfc_dev *nfc_dev)
98{
99 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
100
101 DEV_DBG(dev, "\n");
102
103 mutex_lock(&dev->lock);
104
105 dev->up = 1;
106
107 mutex_unlock(&dev->lock);
108
109 return 0;
110}
111
112static int nfcsim_dev_down(struct nfc_dev *nfc_dev)
113{
114 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
115
116 DEV_DBG(dev, "\n");
117
118 mutex_lock(&dev->lock);
119
120 dev->up = 0;
121
122 mutex_unlock(&dev->lock);
123
124 return 0;
125}
126
127static int nfcsim_dep_link_up(struct nfc_dev *nfc_dev,
128 struct nfc_target *target,
129 u8 comm_mode, u8 *gb, size_t gb_len)
130{
131 int rc;
132 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
133 struct nfcsim *peer = dev->peer_dev;
134 u8 *remote_gb;
135 size_t remote_gb_len;
136
137 DEV_DBG(dev, "target_idx: %d, comm_mode: %d\n", target->idx, comm_mode);
138
139 mutex_lock(&peer->lock);
140
141 nfc_tm_activated(peer->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
142 NFC_COMM_ACTIVE, gb, gb_len);
143
144 remote_gb = nfc_get_local_general_bytes(peer->nfc_dev, &remote_gb_len);
145 if (!remote_gb) {
146 DEV_ERR(peer, "Can't get remote general bytes\n");
147
148 mutex_unlock(&peer->lock);
149 return -EINVAL;
150 }
151
152 mutex_unlock(&peer->lock);
153
154 mutex_lock(&dev->lock);
155
156 rc = nfc_set_remote_general_bytes(nfc_dev, remote_gb, remote_gb_len);
157 if (rc) {
158 DEV_ERR(dev, "Can't set remote general bytes\n");
159 mutex_unlock(&dev->lock);
160 return rc;
161 }
162
163 rc = nfc_dep_link_is_up(nfc_dev, target->idx, NFC_COMM_ACTIVE,
164 NFC_RF_INITIATOR);
165
166 mutex_unlock(&dev->lock);
167
168 return rc;
169}
170
171static int nfcsim_dep_link_down(struct nfc_dev *nfc_dev)
172{
173 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
174
175 DEV_DBG(dev, "\n");
176
177 nfcsim_cleanup_dev(dev, 0);
178
179 return 0;
180}
181
182static int nfcsim_start_poll(struct nfc_dev *nfc_dev,
183 u32 im_protocols, u32 tm_protocols)
184{
185 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
186 int rc;
187
188 mutex_lock(&dev->lock);
189
190 if (dev->polling_mode != NFCSIM_POLL_NONE) {
191 DEV_ERR(dev, "Already in polling mode\n");
192 rc = -EBUSY;
193 goto exit;
194 }
195
196 if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
197 dev->polling_mode |= NFCSIM_POLL_INITIATOR;
198
199 if (tm_protocols & NFC_PROTO_NFC_DEP_MASK)
200 dev->polling_mode |= NFCSIM_POLL_TARGET;
201
202 if (dev->polling_mode == NFCSIM_POLL_NONE) {
203 DEV_ERR(dev, "Unsupported polling mode\n");
204 rc = -EINVAL;
205 goto exit;
206 }
207
208 dev->initiator = 0;
209 dev->curr_polling_mode = NFCSIM_POLL_NONE;
210
211 queue_delayed_work(wq, &dev->poll_work, 0);
212
213 DEV_DBG(dev, "Start polling: im: 0x%X, tm: 0x%X\n", im_protocols,
214 tm_protocols);
215
216 rc = 0;
217exit:
218 mutex_unlock(&dev->lock);
219
220 return rc;
221}
222
223static void nfcsim_stop_poll(struct nfc_dev *nfc_dev)
224{
225 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
226
227 DEV_DBG(dev, "Stop poll\n");
228
229 mutex_lock(&dev->lock);
230
231 dev->polling_mode = NFCSIM_POLL_NONE;
232
233 mutex_unlock(&dev->lock);
234
235 cancel_delayed_work_sync(&dev->poll_work);
236}
237
238static int nfcsim_activate_target(struct nfc_dev *nfc_dev,
239 struct nfc_target *target, u32 protocol)
240{
241 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
242
243 DEV_DBG(dev, "\n");
244
245 return -ENOTSUPP;
246}
247
248static void nfcsim_deactivate_target(struct nfc_dev *nfc_dev,
249 struct nfc_target *target)
250{
251 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
252
253 DEV_DBG(dev, "\n");
254}
255
256static void nfcsim_wq_recv(struct work_struct *work)
257{
258 struct nfcsim *dev = container_of(work, struct nfcsim,
259 recv_work.work);
260
261 mutex_lock(&dev->lock);
262
263 if (dev->shutting_down || !dev->up || !dev->clone_skb) {
264 dev_kfree_skb(dev->clone_skb);
265 goto exit;
266 }
267
268 if (dev->initiator) {
269 if (!dev->cb) {
270 DEV_ERR(dev, "Null recv callback\n");
271 dev_kfree_skb(dev->clone_skb);
272 goto exit;
273 }
274
275 dev->cb(dev->cb_context, dev->clone_skb, 0);
276 dev->cb = NULL;
277 } else {
278 nfc_tm_data_received(dev->nfc_dev, dev->clone_skb);
279 }
280
281exit:
282 dev->clone_skb = NULL;
283
284 mutex_unlock(&dev->lock);
285}
286
287static int nfcsim_tx(struct nfc_dev *nfc_dev, struct nfc_target *target,
288 struct sk_buff *skb, data_exchange_cb_t cb,
289 void *cb_context)
290{
291 struct nfcsim *dev = nfc_get_drvdata(nfc_dev);
292 struct nfcsim *peer = dev->peer_dev;
293 int err;
294
295 mutex_lock(&dev->lock);
296
297 if (dev->shutting_down || !dev->up) {
298 mutex_unlock(&dev->lock);
299 err = -ENODEV;
300 goto exit;
301 }
302
303 dev->cb = cb;
304 dev->cb_context = cb_context;
305
306 mutex_unlock(&dev->lock);
307
308 mutex_lock(&peer->lock);
309
310 peer->clone_skb = skb_clone(skb, GFP_KERNEL);
311
312 if (!peer->clone_skb) {
313 DEV_ERR(dev, "skb_clone failed\n");
314 mutex_unlock(&peer->lock);
315 err = -ENOMEM;
316 goto exit;
317 }
318
319 /* This simulates an arbitrary transmission delay between the 2 devices.
320 * If packet transmission occurs immediately between them, we have a
321 * non-stop flow of several tens of thousands SYMM packets per second
322 * and a burning cpu.
323 *
324 * TODO: Add support for a sysfs entry to control this delay.
325 */
326 queue_delayed_work(wq, &peer->recv_work, msecs_to_jiffies(5));
327
328 mutex_unlock(&peer->lock);
329
330 err = 0;
331exit:
332 dev_kfree_skb(skb);
333
334 return err;
335}
336
337static int nfcsim_im_transceive(struct nfc_dev *nfc_dev,
338 struct nfc_target *target, struct sk_buff *skb,
339 data_exchange_cb_t cb, void *cb_context)
340{
341 return nfcsim_tx(nfc_dev, target, skb, cb, cb_context);
342}
343
344static int nfcsim_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
345{
346 return nfcsim_tx(nfc_dev, NULL, skb, NULL, NULL);
347}
348
349static struct nfc_ops nfcsim_nfc_ops = {
350 .dev_up = nfcsim_dev_up,
351 .dev_down = nfcsim_dev_down,
352 .dep_link_up = nfcsim_dep_link_up,
353 .dep_link_down = nfcsim_dep_link_down,
354 .start_poll = nfcsim_start_poll,
355 .stop_poll = nfcsim_stop_poll,
356 .activate_target = nfcsim_activate_target,
357 .deactivate_target = nfcsim_deactivate_target,
358 .im_transceive = nfcsim_im_transceive,
359 .tm_send = nfcsim_tm_send,
360};
361
362static void nfcsim_set_polling_mode(struct nfcsim *dev)
363{
364 if (dev->polling_mode == NFCSIM_POLL_NONE) {
365 dev->curr_polling_mode = NFCSIM_POLL_NONE;
366 return;
367 }
368
369 if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
370 if (dev->polling_mode & NFCSIM_POLL_INITIATOR)
371 dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
372 else
373 dev->curr_polling_mode = NFCSIM_POLL_TARGET;
374
375 return;
376 }
377
378 if (dev->polling_mode == NFCSIM_POLL_DUAL) {
379 if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
380 dev->curr_polling_mode = NFCSIM_POLL_INITIATOR;
381 else
382 dev->curr_polling_mode = NFCSIM_POLL_TARGET;
383 }
384}
385
386static void nfcsim_wq_poll(struct work_struct *work)
387{
388 struct nfcsim *dev = container_of(work, struct nfcsim, poll_work.work);
389 struct nfcsim *peer = dev->peer_dev;
390
391 /* These work items run on an ordered workqueue and are therefore
392 * serialized. So we can take both mutexes without being dead locked.
393 */
394 mutex_lock(&dev->lock);
395 mutex_lock(&peer->lock);
396
397 nfcsim_set_polling_mode(dev);
398
399 if (dev->curr_polling_mode == NFCSIM_POLL_NONE) {
400 DEV_DBG(dev, "Not polling\n");
401 goto unlock;
402 }
403
404 DEV_DBG(dev, "Polling as %s",
405 dev->curr_polling_mode == NFCSIM_POLL_INITIATOR ?
406 "initiator\n" : "target\n");
407
408 if (dev->curr_polling_mode == NFCSIM_POLL_TARGET)
409 goto sched_work;
410
411 if (peer->curr_polling_mode == NFCSIM_POLL_TARGET) {
412 peer->polling_mode = NFCSIM_POLL_NONE;
413 dev->polling_mode = NFCSIM_POLL_NONE;
414
415 dev->initiator = 1;
416
417 nfcsim_target_found(dev);
418
419 goto unlock;
420 }
421
422sched_work:
423 /* This defines the delay for an initiator to check if the other device
424 * is polling in target mode.
425 * If the device starts in dual mode polling, it switches between
426 * initiator and target at every round.
427 * Because the wq is ordered and only 1 work item is executed at a time,
428 * we'll always have one device polling as initiator and the other as
429 * target at some point, even if both are started in dual mode.
430 */
431 queue_delayed_work(wq, &dev->poll_work, msecs_to_jiffies(200));
432
433unlock:
434 mutex_unlock(&peer->lock);
435 mutex_unlock(&dev->lock);
436}
437
438static struct nfcsim *nfcsim_init_dev(void)
439{
440 struct nfcsim *dev;
441 int rc = -ENOMEM;
442
443 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
444 if (dev == NULL)
445 return ERR_PTR(-ENOMEM);
446
447 mutex_init(&dev->lock);
448
449 INIT_DELAYED_WORK(&dev->recv_work, nfcsim_wq_recv);
450 INIT_DELAYED_WORK(&dev->poll_work, nfcsim_wq_poll);
451
452 dev->nfc_dev = nfc_allocate_device(&nfcsim_nfc_ops,
453 NFC_PROTO_NFC_DEP_MASK,
454 0, 0);
455 if (!dev->nfc_dev)
456 goto error;
457
458 nfc_set_drvdata(dev->nfc_dev, dev);
459
460 rc = nfc_register_device(dev->nfc_dev);
461 if (rc)
462 goto free_nfc_dev;
463
464 return dev;
465
466free_nfc_dev:
467 nfc_free_device(dev->nfc_dev);
468
469error:
470 kfree(dev);
471
472 return ERR_PTR(rc);
473}
474
475static void nfcsim_free_device(struct nfcsim *dev)
476{
477 nfc_unregister_device(dev->nfc_dev);
478
479 nfc_free_device(dev->nfc_dev);
480
481 kfree(dev);
482}
483
484static int __init nfcsim_init(void)
485{
486 int rc;
487
488 /* We need an ordered wq to ensure that poll_work items are executed
489 * one at a time.
490 */
491 wq = alloc_ordered_workqueue("nfcsim", 0);
492 if (!wq) {
493 rc = -ENOMEM;
494 goto exit;
495 }
496
497 dev0 = nfcsim_init_dev();
498 if (IS_ERR(dev0)) {
499 rc = PTR_ERR(dev0);
500 goto exit;
501 }
502
503 dev1 = nfcsim_init_dev();
504 if (IS_ERR(dev1)) {
505 kfree(dev0);
506
507 rc = PTR_ERR(dev1);
508 goto exit;
509 }
510
511 dev0->peer_dev = dev1;
512 dev1->peer_dev = dev0;
513
514 pr_debug("NFCsim " NFCSIM_VERSION " initialized\n");
515
516 rc = 0;
517exit:
518 if (rc)
519 pr_err("Failed to initialize nfcsim driver (%d)\n",
520 rc);
521
522 return rc;
523}
524
525static void __exit nfcsim_exit(void)
526{
527 nfcsim_cleanup_dev(dev0, 1);
528 nfcsim_cleanup_dev(dev1, 1);
529
530 nfcsim_free_device(dev0);
531 nfcsim_free_device(dev1);
532
533 destroy_workqueue(wq);
534}
535
536module_init(nfcsim_init);
537module_exit(nfcsim_exit);
538
539MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
540MODULE_VERSION(NFCSIM_VERSION);
541MODULE_LICENSE("GPL");