Merge tag 'apparmor-pr-2023-07-06' of git://git.kernel.org/pub/scm/linux/kernel/git...
[platform/kernel/linux-rpi.git] / drivers / nfc / nfcsim.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * NFC hardware simulation driver
4  * Copyright (c) 2013, Intel Corporation.
5  */
6
7 #include <linux/device.h>
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/ctype.h>
11 #include <linux/debugfs.h>
12 #include <linux/nfc.h>
13 #include <net/nfc/nfc.h>
14 #include <net/nfc/digital.h>
15
16 #define NFCSIM_ERR(d, fmt, args...) nfc_err(&d->nfc_digital_dev->nfc_dev->dev, \
17                                             "%s: " fmt, __func__, ## args)
18
19 #define NFCSIM_DBG(d, fmt, args...) dev_dbg(&d->nfc_digital_dev->nfc_dev->dev, \
20                                             "%s: " fmt, __func__, ## args)
21
22 #define NFCSIM_VERSION "0.2"
23
24 #define NFCSIM_MODE_NONE        0
25 #define NFCSIM_MODE_INITIATOR   1
26 #define NFCSIM_MODE_TARGET      2
27
28 #define NFCSIM_CAPABILITIES (NFC_DIGITAL_DRV_CAPS_IN_CRC   | \
29                              NFC_DIGITAL_DRV_CAPS_TG_CRC)
30
31 struct nfcsim {
32         struct nfc_digital_dev *nfc_digital_dev;
33
34         struct work_struct recv_work;
35         struct delayed_work send_work;
36
37         struct nfcsim_link *link_in;
38         struct nfcsim_link *link_out;
39
40         bool up;
41         u8 mode;
42         u8 rf_tech;
43
44         u16 recv_timeout;
45
46         nfc_digital_cmd_complete_t cb;
47         void *arg;
48
49         u8 dropframe;
50 };
51
52 struct nfcsim_link {
53         struct mutex lock;
54
55         u8 rf_tech;
56         u8 mode;
57
58         u8 shutdown;
59
60         struct sk_buff *skb;
61         wait_queue_head_t recv_wait;
62         u8 cond;
63 };
64
65 static struct nfcsim_link *nfcsim_link_new(void)
66 {
67         struct nfcsim_link *link;
68
69         link = kzalloc(sizeof(struct nfcsim_link), GFP_KERNEL);
70         if (!link)
71                 return NULL;
72
73         mutex_init(&link->lock);
74         init_waitqueue_head(&link->recv_wait);
75
76         return link;
77 }
78
79 static void nfcsim_link_free(struct nfcsim_link *link)
80 {
81         dev_kfree_skb(link->skb);
82         kfree(link);
83 }
84
85 static void nfcsim_link_recv_wake(struct nfcsim_link *link)
86 {
87         link->cond = 1;
88         wake_up_interruptible(&link->recv_wait);
89 }
90
91 static void nfcsim_link_set_skb(struct nfcsim_link *link, struct sk_buff *skb,
92                                 u8 rf_tech, u8 mode)
93 {
94         mutex_lock(&link->lock);
95
96         dev_kfree_skb(link->skb);
97         link->skb = skb;
98         link->rf_tech = rf_tech;
99         link->mode = mode;
100
101         mutex_unlock(&link->lock);
102 }
103
104 static void nfcsim_link_recv_cancel(struct nfcsim_link *link)
105 {
106         mutex_lock(&link->lock);
107
108         link->mode = NFCSIM_MODE_NONE;
109
110         mutex_unlock(&link->lock);
111
112         nfcsim_link_recv_wake(link);
113 }
114
115 static void nfcsim_link_shutdown(struct nfcsim_link *link)
116 {
117         mutex_lock(&link->lock);
118
119         link->shutdown = 1;
120         link->mode = NFCSIM_MODE_NONE;
121
122         mutex_unlock(&link->lock);
123
124         nfcsim_link_recv_wake(link);
125 }
126
127 static struct sk_buff *nfcsim_link_recv_skb(struct nfcsim_link *link,
128                                             int timeout, u8 rf_tech, u8 mode)
129 {
130         int rc;
131         struct sk_buff *skb;
132
133         rc = wait_event_interruptible_timeout(link->recv_wait,
134                                               link->cond,
135                                               msecs_to_jiffies(timeout));
136
137         mutex_lock(&link->lock);
138
139         skb = link->skb;
140         link->skb = NULL;
141
142         if (!rc) {
143                 rc = -ETIMEDOUT;
144                 goto done;
145         }
146
147         if (!skb || link->rf_tech != rf_tech || link->mode == mode) {
148                 rc = -EINVAL;
149                 goto done;
150         }
151
152         if (link->shutdown) {
153                 rc = -ENODEV;
154                 goto done;
155         }
156
157 done:
158         mutex_unlock(&link->lock);
159
160         if (rc < 0) {
161                 dev_kfree_skb(skb);
162                 skb = ERR_PTR(rc);
163         }
164
165         link->cond = 0;
166
167         return skb;
168 }
169
170 static void nfcsim_send_wq(struct work_struct *work)
171 {
172         struct nfcsim *dev = container_of(work, struct nfcsim, send_work.work);
173
174         /*
175          * To effectively send data, the device just wake up its link_out which
176          * is the link_in of the peer device. The exchanged skb has already been
177          * stored in the dev->link_out through nfcsim_link_set_skb().
178          */
179         nfcsim_link_recv_wake(dev->link_out);
180 }
181
182 static void nfcsim_recv_wq(struct work_struct *work)
183 {
184         struct nfcsim *dev = container_of(work, struct nfcsim, recv_work);
185         struct sk_buff *skb;
186
187         skb = nfcsim_link_recv_skb(dev->link_in, dev->recv_timeout,
188                                    dev->rf_tech, dev->mode);
189
190         if (!dev->up) {
191                 NFCSIM_ERR(dev, "Device is down\n");
192
193                 if (!IS_ERR(skb))
194                         dev_kfree_skb(skb);
195                 return;
196         }
197
198         dev->cb(dev->nfc_digital_dev, dev->arg, skb);
199 }
200
201 static int nfcsim_send(struct nfc_digital_dev *ddev, struct sk_buff *skb,
202                        u16 timeout, nfc_digital_cmd_complete_t cb, void *arg)
203 {
204         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
205         u8 delay;
206
207         if (!dev->up) {
208                 NFCSIM_ERR(dev, "Device is down\n");
209                 return -ENODEV;
210         }
211
212         dev->recv_timeout = timeout;
213         dev->cb = cb;
214         dev->arg = arg;
215
216         schedule_work(&dev->recv_work);
217
218         if (dev->dropframe) {
219                 NFCSIM_DBG(dev, "dropping frame (out of %d)\n", dev->dropframe);
220                 dev_kfree_skb(skb);
221                 dev->dropframe--;
222
223                 return 0;
224         }
225
226         if (skb) {
227                 nfcsim_link_set_skb(dev->link_out, skb, dev->rf_tech,
228                                     dev->mode);
229
230                 /* Add random delay (between 3 and 10 ms) before sending data */
231                 get_random_bytes(&delay, 1);
232                 delay = 3 + (delay & 0x07);
233
234                 schedule_delayed_work(&dev->send_work, msecs_to_jiffies(delay));
235         }
236
237         return 0;
238 }
239
240 static void nfcsim_abort_cmd(struct nfc_digital_dev *ddev)
241 {
242         const struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
243
244         nfcsim_link_recv_cancel(dev->link_in);
245 }
246
247 static int nfcsim_switch_rf(struct nfc_digital_dev *ddev, bool on)
248 {
249         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
250
251         dev->up = on;
252
253         return 0;
254 }
255
256 static int nfcsim_in_configure_hw(struct nfc_digital_dev *ddev,
257                                           int type, int param)
258 {
259         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
260
261         switch (type) {
262         case NFC_DIGITAL_CONFIG_RF_TECH:
263                 dev->up = true;
264                 dev->mode = NFCSIM_MODE_INITIATOR;
265                 dev->rf_tech = param;
266                 break;
267
268         case NFC_DIGITAL_CONFIG_FRAMING:
269                 break;
270
271         default:
272                 NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
273                 return -EINVAL;
274         }
275
276         return 0;
277 }
278
279 static int nfcsim_in_send_cmd(struct nfc_digital_dev *ddev,
280                                struct sk_buff *skb, u16 timeout,
281                                nfc_digital_cmd_complete_t cb, void *arg)
282 {
283         return nfcsim_send(ddev, skb, timeout, cb, arg);
284 }
285
286 static int nfcsim_tg_configure_hw(struct nfc_digital_dev *ddev,
287                                           int type, int param)
288 {
289         struct nfcsim *dev = nfc_digital_get_drvdata(ddev);
290
291         switch (type) {
292         case NFC_DIGITAL_CONFIG_RF_TECH:
293                 dev->up = true;
294                 dev->mode = NFCSIM_MODE_TARGET;
295                 dev->rf_tech = param;
296                 break;
297
298         case NFC_DIGITAL_CONFIG_FRAMING:
299                 break;
300
301         default:
302                 NFCSIM_ERR(dev, "Invalid configuration type: %d\n", type);
303                 return -EINVAL;
304         }
305
306         return 0;
307 }
308
309 static int nfcsim_tg_send_cmd(struct nfc_digital_dev *ddev,
310                                struct sk_buff *skb, u16 timeout,
311                                nfc_digital_cmd_complete_t cb, void *arg)
312 {
313         return nfcsim_send(ddev, skb, timeout, cb, arg);
314 }
315
316 static int nfcsim_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
317                             nfc_digital_cmd_complete_t cb, void *arg)
318 {
319         return nfcsim_send(ddev, NULL, timeout, cb, arg);
320 }
321
322 static const struct nfc_digital_ops nfcsim_digital_ops = {
323         .in_configure_hw = nfcsim_in_configure_hw,
324         .in_send_cmd = nfcsim_in_send_cmd,
325
326         .tg_listen = nfcsim_tg_listen,
327         .tg_configure_hw = nfcsim_tg_configure_hw,
328         .tg_send_cmd = nfcsim_tg_send_cmd,
329
330         .abort_cmd = nfcsim_abort_cmd,
331         .switch_rf = nfcsim_switch_rf,
332 };
333
334 static struct dentry *nfcsim_debugfs_root;
335
336 static void nfcsim_debugfs_init(void)
337 {
338         nfcsim_debugfs_root = debugfs_create_dir("nfcsim", NULL);
339 }
340
341 static void nfcsim_debugfs_remove(void)
342 {
343         debugfs_remove_recursive(nfcsim_debugfs_root);
344 }
345
346 static void nfcsim_debugfs_init_dev(struct nfcsim *dev)
347 {
348         struct dentry *dev_dir;
349         char devname[5]; /* nfcX\0 */
350         u32 idx;
351         int n;
352
353         if (!nfcsim_debugfs_root) {
354                 NFCSIM_ERR(dev, "nfcsim debugfs not initialized\n");
355                 return;
356         }
357
358         idx = dev->nfc_digital_dev->nfc_dev->idx;
359         n = snprintf(devname, sizeof(devname), "nfc%d", idx);
360         if (n >= sizeof(devname)) {
361                 NFCSIM_ERR(dev, "Could not compute dev name for dev %d\n", idx);
362                 return;
363         }
364
365         dev_dir = debugfs_create_dir(devname, nfcsim_debugfs_root);
366
367         debugfs_create_u8("dropframe", 0664, dev_dir, &dev->dropframe);
368 }
369
370 static struct nfcsim *nfcsim_device_new(struct nfcsim_link *link_in,
371                                         struct nfcsim_link *link_out)
372 {
373         struct nfcsim *dev;
374         int rc;
375
376         dev = kzalloc(sizeof(struct nfcsim), GFP_KERNEL);
377         if (!dev)
378                 return ERR_PTR(-ENOMEM);
379
380         INIT_DELAYED_WORK(&dev->send_work, nfcsim_send_wq);
381         INIT_WORK(&dev->recv_work, nfcsim_recv_wq);
382
383         dev->nfc_digital_dev =
384                         nfc_digital_allocate_device(&nfcsim_digital_ops,
385                                                     NFC_PROTO_NFC_DEP_MASK,
386                                                     NFCSIM_CAPABILITIES,
387                                                     0, 0);
388         if (!dev->nfc_digital_dev) {
389                 kfree(dev);
390                 return ERR_PTR(-ENOMEM);
391         }
392
393         nfc_digital_set_drvdata(dev->nfc_digital_dev, dev);
394
395         dev->link_in = link_in;
396         dev->link_out = link_out;
397
398         rc = nfc_digital_register_device(dev->nfc_digital_dev);
399         if (rc) {
400                 pr_err("Could not register digital device (%d)\n", rc);
401                 nfc_digital_free_device(dev->nfc_digital_dev);
402                 kfree(dev);
403
404                 return ERR_PTR(rc);
405         }
406
407         nfcsim_debugfs_init_dev(dev);
408
409         return dev;
410 }
411
412 static void nfcsim_device_free(struct nfcsim *dev)
413 {
414         nfc_digital_unregister_device(dev->nfc_digital_dev);
415
416         dev->up = false;
417
418         nfcsim_link_shutdown(dev->link_in);
419
420         cancel_delayed_work_sync(&dev->send_work);
421         cancel_work_sync(&dev->recv_work);
422
423         nfc_digital_free_device(dev->nfc_digital_dev);
424
425         kfree(dev);
426 }
427
428 static struct nfcsim *dev0;
429 static struct nfcsim *dev1;
430
431 static int __init nfcsim_init(void)
432 {
433         struct nfcsim_link *link0, *link1;
434         int rc;
435
436         link0 = nfcsim_link_new();
437         link1 = nfcsim_link_new();
438         if (!link0 || !link1) {
439                 rc = -ENOMEM;
440                 goto exit_err;
441         }
442
443         nfcsim_debugfs_init();
444
445         dev0 = nfcsim_device_new(link0, link1);
446         if (IS_ERR(dev0)) {
447                 rc = PTR_ERR(dev0);
448                 goto exit_err;
449         }
450
451         dev1 = nfcsim_device_new(link1, link0);
452         if (IS_ERR(dev1)) {
453                 nfcsim_device_free(dev0);
454
455                 rc = PTR_ERR(dev1);
456                 goto exit_err;
457         }
458
459         pr_info("nfcsim " NFCSIM_VERSION " initialized\n");
460
461         return 0;
462
463 exit_err:
464         pr_err("Failed to initialize nfcsim driver (%d)\n", rc);
465
466         if (link0)
467                 nfcsim_link_free(link0);
468         if (link1)
469                 nfcsim_link_free(link1);
470
471         return rc;
472 }
473
474 static void __exit nfcsim_exit(void)
475 {
476         struct nfcsim_link *link0, *link1;
477
478         link0 = dev0->link_in;
479         link1 = dev0->link_out;
480
481         nfcsim_device_free(dev0);
482         nfcsim_device_free(dev1);
483
484         nfcsim_link_free(link0);
485         nfcsim_link_free(link1);
486
487         nfcsim_debugfs_remove();
488 }
489
490 module_init(nfcsim_init);
491 module_exit(nfcsim_exit);
492
493 MODULE_DESCRIPTION("NFCSim driver ver " NFCSIM_VERSION);
494 MODULE_VERSION(NFCSIM_VERSION);
495 MODULE_LICENSE("GPL");