1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
17
18#include <net/genetlink.h>
19#include <linux/nfc.h>
20#include <linux/slab.h>
21
22#include "nfc.h"
23#include "llcp.h"
24
25static const struct genl_multicast_group nfc_genl_mcgrps[] = {
26 { .name = NFC_GENL_MCAST_EVENT_NAME, },
27};
28
29static struct genl_family nfc_genl_family;
30static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
31 [NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
32 [NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
33 .len = NFC_DEVICE_NAME_MAXSIZE },
34 [NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
35 [NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
36 [NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
37 [NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
38 [NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
39 [NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
40 [NFC_ATTR_LLC_PARAM_LTO] = { .type = NLA_U8 },
41 [NFC_ATTR_LLC_PARAM_RW] = { .type = NLA_U8 },
42 [NFC_ATTR_LLC_PARAM_MIUX] = { .type = NLA_U16 },
43 [NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
44 [NFC_ATTR_FIRMWARE_NAME] = { .type = NLA_STRING,
45 .len = NFC_FIRMWARE_NAME_MAXSIZE },
46 [NFC_ATTR_SE_APDU] = { .type = NLA_BINARY },
47 [NFC_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
48
49};
50
51static const struct nla_policy nfc_sdp_genl_policy[NFC_SDP_ATTR_MAX + 1] = {
52 [NFC_SDP_ATTR_URI] = { .type = NLA_STRING,
53 .len = U8_MAX - 4 },
54 [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
55};
56
57static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
58 struct netlink_callback *cb, int flags)
59{
60 void *hdr;
61
62 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
63 &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
64 if (!hdr)
65 return -EMSGSIZE;
66
67 genl_dump_check_consistent(cb, hdr);
68
69 if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
70 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
71 nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
72 nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
73 goto nla_put_failure;
74 if (target->nfcid1_len > 0 &&
75 nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
76 target->nfcid1))
77 goto nla_put_failure;
78 if (target->sensb_res_len > 0 &&
79 nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
80 target->sensb_res))
81 goto nla_put_failure;
82 if (target->sensf_res_len > 0 &&
83 nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
84 target->sensf_res))
85 goto nla_put_failure;
86
87 if (target->is_iso15693) {
88 if (nla_put_u8(msg, NFC_ATTR_TARGET_ISO15693_DSFID,
89 target->iso15693_dsfid) ||
90 nla_put(msg, NFC_ATTR_TARGET_ISO15693_UID,
91 sizeof(target->iso15693_uid), target->iso15693_uid))
92 goto nla_put_failure;
93 }
94
95 genlmsg_end(msg, hdr);
96 return 0;
97
98nla_put_failure:
99 genlmsg_cancel(msg, hdr);
100 return -EMSGSIZE;
101}
102
103static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
104{
105 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
106 struct nfc_dev *dev;
107 u32 idx;
108
109 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
110 return ERR_PTR(-EINVAL);
111
112 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
113
114 dev = nfc_get_device(idx);
115 if (!dev)
116 return ERR_PTR(-ENODEV);
117
118 return dev;
119}
120
121static int nfc_genl_dump_targets(struct sk_buff *skb,
122 struct netlink_callback *cb)
123{
124 int i = cb->args[0];
125 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
126 int rc;
127
128 if (!dev) {
129 dev = __get_device_from_cb(cb);
130 if (IS_ERR(dev))
131 return PTR_ERR(dev);
132
133 cb->args[1] = (long) dev;
134 }
135
136 device_lock(&dev->dev);
137
138 cb->seq = dev->targets_generation;
139
140 while (i < dev->n_targets) {
141 rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
142 NLM_F_MULTI);
143 if (rc < 0)
144 break;
145
146 i++;
147 }
148
149 device_unlock(&dev->dev);
150
151 cb->args[0] = i;
152
153 return skb->len;
154}
155
156static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
157{
158 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
159
160 if (dev)
161 nfc_put_device(dev);
162
163 return 0;
164}
165
166int nfc_genl_targets_found(struct nfc_dev *dev)
167{
168 struct sk_buff *msg;
169 void *hdr;
170
171 dev->genl_data.poll_req_portid = 0;
172
173 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
174 if (!msg)
175 return -ENOMEM;
176
177 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
178 NFC_EVENT_TARGETS_FOUND);
179 if (!hdr)
180 goto free_msg;
181
182 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
183 goto nla_put_failure;
184
185 genlmsg_end(msg, hdr);
186
187 return genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
188
189nla_put_failure:
190free_msg:
191 nlmsg_free(msg);
192 return -EMSGSIZE;
193}
194
195int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
196{
197 struct sk_buff *msg;
198 void *hdr;
199
200 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
201 if (!msg)
202 return -ENOMEM;
203
204 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
205 NFC_EVENT_TARGET_LOST);
206 if (!hdr)
207 goto free_msg;
208
209 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
210 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
211 goto nla_put_failure;
212
213 genlmsg_end(msg, hdr);
214
215 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
216
217 return 0;
218
219nla_put_failure:
220free_msg:
221 nlmsg_free(msg);
222 return -EMSGSIZE;
223}
224
225int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
226{
227 struct sk_buff *msg;
228 void *hdr;
229
230 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
231 if (!msg)
232 return -ENOMEM;
233
234 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
235 NFC_EVENT_TM_ACTIVATED);
236 if (!hdr)
237 goto free_msg;
238
239 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
240 goto nla_put_failure;
241 if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
242 goto nla_put_failure;
243
244 genlmsg_end(msg, hdr);
245
246 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
247
248 return 0;
249
250nla_put_failure:
251free_msg:
252 nlmsg_free(msg);
253 return -EMSGSIZE;
254}
255
256int nfc_genl_tm_deactivated(struct nfc_dev *dev)
257{
258 struct sk_buff *msg;
259 void *hdr;
260
261 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
262 if (!msg)
263 return -ENOMEM;
264
265 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
266 NFC_EVENT_TM_DEACTIVATED);
267 if (!hdr)
268 goto free_msg;
269
270 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
271 goto nla_put_failure;
272
273 genlmsg_end(msg, hdr);
274
275 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
276
277 return 0;
278
279nla_put_failure:
280free_msg:
281 nlmsg_free(msg);
282 return -EMSGSIZE;
283}
284
285static int nfc_genl_setup_device_added(struct nfc_dev *dev, struct sk_buff *msg)
286{
287 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
288 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
289 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
290 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
291 nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
292 return -1;
293 return 0;
294}
295
296int nfc_genl_device_added(struct nfc_dev *dev)
297{
298 struct sk_buff *msg;
299 void *hdr;
300
301 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
302 if (!msg)
303 return -ENOMEM;
304
305 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
306 NFC_EVENT_DEVICE_ADDED);
307 if (!hdr)
308 goto free_msg;
309
310 if (nfc_genl_setup_device_added(dev, msg))
311 goto nla_put_failure;
312
313 genlmsg_end(msg, hdr);
314
315 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
316
317 return 0;
318
319nla_put_failure:
320free_msg:
321 nlmsg_free(msg);
322 return -EMSGSIZE;
323}
324
325int nfc_genl_device_removed(struct nfc_dev *dev)
326{
327 struct sk_buff *msg;
328 void *hdr;
329
330 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
331 if (!msg)
332 return -ENOMEM;
333
334 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
335 NFC_EVENT_DEVICE_REMOVED);
336 if (!hdr)
337 goto free_msg;
338
339 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
340 goto nla_put_failure;
341
342 genlmsg_end(msg, hdr);
343
344 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
345
346 return 0;
347
348nla_put_failure:
349free_msg:
350 nlmsg_free(msg);
351 return -EMSGSIZE;
352}
353
354int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list)
355{
356 struct sk_buff *msg;
357 struct nlattr *sdp_attr, *uri_attr;
358 struct nfc_llcp_sdp_tlv *sdres;
359 struct hlist_node *n;
360 void *hdr;
361 int rc = -EMSGSIZE;
362 int i;
363
364 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
365 if (!msg)
366 return -ENOMEM;
367
368 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
369 NFC_EVENT_LLC_SDRES);
370 if (!hdr)
371 goto free_msg;
372
373 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
374 goto nla_put_failure;
375
376 sdp_attr = nla_nest_start_noflag(msg, NFC_ATTR_LLC_SDP);
377 if (sdp_attr == NULL) {
378 rc = -ENOMEM;
379 goto nla_put_failure;
380 }
381
382 i = 1;
383 hlist_for_each_entry_safe(sdres, n, sdres_list, node) {
384 pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap);
385
386 uri_attr = nla_nest_start_noflag(msg, i++);
387 if (uri_attr == NULL) {
388 rc = -ENOMEM;
389 goto nla_put_failure;
390 }
391
392 if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap))
393 goto nla_put_failure;
394
395 if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri))
396 goto nla_put_failure;
397
398 nla_nest_end(msg, uri_attr);
399
400 hlist_del(&sdres->node);
401
402 nfc_llcp_free_sdp_tlv(sdres);
403 }
404
405 nla_nest_end(msg, sdp_attr);
406
407 genlmsg_end(msg, hdr);
408
409 return genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
410
411nla_put_failure:
412free_msg:
413 nlmsg_free(msg);
414
415 nfc_llcp_free_sdp_tlv_list(sdres_list);
416
417 return rc;
418}
419
420int nfc_genl_se_added(struct nfc_dev *dev, u32 se_idx, u16 type)
421{
422 struct sk_buff *msg;
423 void *hdr;
424
425 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
426 if (!msg)
427 return -ENOMEM;
428
429 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
430 NFC_EVENT_SE_ADDED);
431 if (!hdr)
432 goto free_msg;
433
434 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
435 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx) ||
436 nla_put_u8(msg, NFC_ATTR_SE_TYPE, type))
437 goto nla_put_failure;
438
439 genlmsg_end(msg, hdr);
440
441 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
442
443 return 0;
444
445nla_put_failure:
446free_msg:
447 nlmsg_free(msg);
448 return -EMSGSIZE;
449}
450
451int nfc_genl_se_removed(struct nfc_dev *dev, u32 se_idx)
452{
453 struct sk_buff *msg;
454 void *hdr;
455
456 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
457 if (!msg)
458 return -ENOMEM;
459
460 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
461 NFC_EVENT_SE_REMOVED);
462 if (!hdr)
463 goto free_msg;
464
465 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
466 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx))
467 goto nla_put_failure;
468
469 genlmsg_end(msg, hdr);
470
471 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
472
473 return 0;
474
475nla_put_failure:
476free_msg:
477 nlmsg_free(msg);
478 return -EMSGSIZE;
479}
480
481int nfc_genl_se_transaction(struct nfc_dev *dev, u8 se_idx,
482 struct nfc_evt_transaction *evt_transaction)
483{
484 struct nfc_se *se;
485 struct sk_buff *msg;
486 void *hdr;
487
488 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
489 if (!msg)
490 return -ENOMEM;
491
492 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
493 NFC_EVENT_SE_TRANSACTION);
494 if (!hdr)
495 goto free_msg;
496
497 se = nfc_find_se(dev, se_idx);
498 if (!se)
499 goto free_msg;
500
501 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
502 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx) ||
503 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type) ||
504 nla_put(msg, NFC_ATTR_SE_AID, evt_transaction->aid_len,
505 evt_transaction->aid) ||
506 nla_put(msg, NFC_ATTR_SE_PARAMS, evt_transaction->params_len,
507 evt_transaction->params))
508 goto nla_put_failure;
509
510
511 devm_kfree(&dev->dev, evt_transaction);
512
513 genlmsg_end(msg, hdr);
514
515 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
516
517 return 0;
518
519nla_put_failure:
520free_msg:
521
522 devm_kfree(&dev->dev, evt_transaction);
523 nlmsg_free(msg);
524 return -EMSGSIZE;
525}
526
527int nfc_genl_se_connectivity(struct nfc_dev *dev, u8 se_idx)
528{
529 struct nfc_se *se;
530 struct sk_buff *msg;
531 void *hdr;
532
533 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
534 if (!msg)
535 return -ENOMEM;
536
537 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
538 NFC_EVENT_SE_CONNECTIVITY);
539 if (!hdr)
540 goto free_msg;
541
542 se = nfc_find_se(dev, se_idx);
543 if (!se)
544 goto free_msg;
545
546 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
547 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx) ||
548 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
549 goto nla_put_failure;
550
551 genlmsg_end(msg, hdr);
552
553 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
554
555 return 0;
556
557nla_put_failure:
558free_msg:
559 nlmsg_free(msg);
560 return -EMSGSIZE;
561}
562
563static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
564 u32 portid, u32 seq,
565 struct netlink_callback *cb,
566 int flags)
567{
568 void *hdr;
569
570 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
571 NFC_CMD_GET_DEVICE);
572 if (!hdr)
573 return -EMSGSIZE;
574
575 if (cb)
576 genl_dump_check_consistent(cb, hdr);
577
578 if (nfc_genl_setup_device_added(dev, msg))
579 goto nla_put_failure;
580
581 genlmsg_end(msg, hdr);
582 return 0;
583
584nla_put_failure:
585 genlmsg_cancel(msg, hdr);
586 return -EMSGSIZE;
587}
588
589static int nfc_genl_dump_devices(struct sk_buff *skb,
590 struct netlink_callback *cb)
591{
592 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
593 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
594 bool first_call = false;
595
596 if (!iter) {
597 first_call = true;
598 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
599 if (!iter)
600 return -ENOMEM;
601 cb->args[0] = (long) iter;
602 }
603
604 mutex_lock(&nfc_devlist_mutex);
605
606 cb->seq = nfc_devlist_generation;
607
608 if (first_call) {
609 nfc_device_iter_init(iter);
610 dev = nfc_device_iter_next(iter);
611 }
612
613 while (dev) {
614 int rc;
615
616 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
617 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
618 if (rc < 0)
619 break;
620
621 dev = nfc_device_iter_next(iter);
622 }
623
624 mutex_unlock(&nfc_devlist_mutex);
625
626 cb->args[1] = (long) dev;
627
628 return skb->len;
629}
630
631static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
632{
633 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
634
635 nfc_device_iter_exit(iter);
636 kfree(iter);
637
638 return 0;
639}
640
641int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
642 u8 comm_mode, u8 rf_mode)
643{
644 struct sk_buff *msg;
645 void *hdr;
646
647 pr_debug("DEP link is up\n");
648
649 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
650 if (!msg)
651 return -ENOMEM;
652
653 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
654 if (!hdr)
655 goto free_msg;
656
657 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
658 goto nla_put_failure;
659 if (rf_mode == NFC_RF_INITIATOR &&
660 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
661 goto nla_put_failure;
662 if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
663 nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
664 goto nla_put_failure;
665
666 genlmsg_end(msg, hdr);
667
668 dev->dep_link_up = true;
669
670 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
671
672 return 0;
673
674nla_put_failure:
675free_msg:
676 nlmsg_free(msg);
677 return -EMSGSIZE;
678}
679
680int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
681{
682 struct sk_buff *msg;
683 void *hdr;
684
685 pr_debug("DEP link is down\n");
686
687 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
688 if (!msg)
689 return -ENOMEM;
690
691 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
692 NFC_CMD_DEP_LINK_DOWN);
693 if (!hdr)
694 goto free_msg;
695
696 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
697 goto nla_put_failure;
698
699 genlmsg_end(msg, hdr);
700
701 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
702
703 return 0;
704
705nla_put_failure:
706free_msg:
707 nlmsg_free(msg);
708 return -EMSGSIZE;
709}
710
711static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
712{
713 struct sk_buff *msg;
714 struct nfc_dev *dev;
715 u32 idx;
716 int rc = -ENOBUFS;
717
718 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
719 return -EINVAL;
720
721 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
722
723 dev = nfc_get_device(idx);
724 if (!dev)
725 return -ENODEV;
726
727 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
728 if (!msg) {
729 rc = -ENOMEM;
730 goto out_putdev;
731 }
732
733 rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
734 NULL, 0);
735 if (rc < 0)
736 goto out_free;
737
738 nfc_put_device(dev);
739
740 return genlmsg_reply(msg, info);
741
742out_free:
743 nlmsg_free(msg);
744out_putdev:
745 nfc_put_device(dev);
746 return rc;
747}
748
749static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
750{
751 struct nfc_dev *dev;
752 int rc;
753 u32 idx;
754
755 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
756 return -EINVAL;
757
758 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
759
760 dev = nfc_get_device(idx);
761 if (!dev)
762 return -ENODEV;
763
764 rc = nfc_dev_up(dev);
765
766 nfc_put_device(dev);
767 return rc;
768}
769
770static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
771{
772 struct nfc_dev *dev;
773 int rc;
774 u32 idx;
775
776 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
777 return -EINVAL;
778
779 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
780
781 dev = nfc_get_device(idx);
782 if (!dev)
783 return -ENODEV;
784
785 rc = nfc_dev_down(dev);
786
787 nfc_put_device(dev);
788 return rc;
789}
790
791static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
792{
793 struct nfc_dev *dev;
794 int rc;
795 u32 idx;
796 u32 im_protocols = 0, tm_protocols = 0;
797
798 pr_debug("Poll start\n");
799
800 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
801 ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
802 !info->attrs[NFC_ATTR_PROTOCOLS]) &&
803 !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
804 return -EINVAL;
805
806 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
807
808 if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
809 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
810
811 if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
812 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
813 else if (info->attrs[NFC_ATTR_PROTOCOLS])
814 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
815
816 dev = nfc_get_device(idx);
817 if (!dev)
818 return -ENODEV;
819
820 mutex_lock(&dev->genl_data.genl_data_mutex);
821
822 rc = nfc_start_poll(dev, im_protocols, tm_protocols);
823 if (!rc)
824 dev->genl_data.poll_req_portid = info->snd_portid;
825
826 mutex_unlock(&dev->genl_data.genl_data_mutex);
827
828 nfc_put_device(dev);
829 return rc;
830}
831
832static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
833{
834 struct nfc_dev *dev;
835 int rc;
836 u32 idx;
837
838 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
839 return -EINVAL;
840
841 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
842
843 dev = nfc_get_device(idx);
844 if (!dev)
845 return -ENODEV;
846
847 device_lock(&dev->dev);
848
849 if (!dev->polling) {
850 device_unlock(&dev->dev);
851 return -EINVAL;
852 }
853
854 device_unlock(&dev->dev);
855
856 mutex_lock(&dev->genl_data.genl_data_mutex);
857
858 if (dev->genl_data.poll_req_portid != info->snd_portid) {
859 rc = -EBUSY;
860 goto out;
861 }
862
863 rc = nfc_stop_poll(dev);
864 dev->genl_data.poll_req_portid = 0;
865
866out:
867 mutex_unlock(&dev->genl_data.genl_data_mutex);
868 nfc_put_device(dev);
869 return rc;
870}
871
872static int nfc_genl_activate_target(struct sk_buff *skb, struct genl_info *info)
873{
874 struct nfc_dev *dev;
875 u32 device_idx, target_idx, protocol;
876 int rc;
877
878 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
879 !info->attrs[NFC_ATTR_TARGET_INDEX] ||
880 !info->attrs[NFC_ATTR_PROTOCOLS])
881 return -EINVAL;
882
883 device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
884
885 dev = nfc_get_device(device_idx);
886 if (!dev)
887 return -ENODEV;
888
889 target_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
890 protocol = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
891
892 nfc_deactivate_target(dev, target_idx, NFC_TARGET_MODE_SLEEP);
893 rc = nfc_activate_target(dev, target_idx, protocol);
894
895 nfc_put_device(dev);
896 return rc;
897}
898
899static int nfc_genl_deactivate_target(struct sk_buff *skb,
900 struct genl_info *info)
901{
902 struct nfc_dev *dev;
903 u32 device_idx, target_idx;
904 int rc;
905
906 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
907 !info->attrs[NFC_ATTR_TARGET_INDEX])
908 return -EINVAL;
909
910 device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
911
912 dev = nfc_get_device(device_idx);
913 if (!dev)
914 return -ENODEV;
915
916 target_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
917
918 rc = nfc_deactivate_target(dev, target_idx, NFC_TARGET_MODE_SLEEP);
919
920 nfc_put_device(dev);
921 return rc;
922}
923
924static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
925{
926 struct nfc_dev *dev;
927 int rc, tgt_idx;
928 u32 idx;
929 u8 comm;
930
931 pr_debug("DEP link up\n");
932
933 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
934 !info->attrs[NFC_ATTR_COMM_MODE])
935 return -EINVAL;
936
937 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
938 if (!info->attrs[NFC_ATTR_TARGET_INDEX])
939 tgt_idx = NFC_TARGET_IDX_ANY;
940 else
941 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
942
943 comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
944
945 if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
946 return -EINVAL;
947
948 dev = nfc_get_device(idx);
949 if (!dev)
950 return -ENODEV;
951
952 rc = nfc_dep_link_up(dev, tgt_idx, comm);
953
954 nfc_put_device(dev);
955
956 return rc;
957}
958
959static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
960{
961 struct nfc_dev *dev;
962 int rc;
963 u32 idx;
964
965 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
966 !info->attrs[NFC_ATTR_TARGET_INDEX])
967 return -EINVAL;
968
969 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
970
971 dev = nfc_get_device(idx);
972 if (!dev)
973 return -ENODEV;
974
975 rc = nfc_dep_link_down(dev);
976
977 nfc_put_device(dev);
978 return rc;
979}
980
981static int nfc_genl_send_params(struct sk_buff *msg,
982 struct nfc_llcp_local *local,
983 u32 portid, u32 seq)
984{
985 void *hdr;
986
987 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
988 NFC_CMD_LLC_GET_PARAMS);
989 if (!hdr)
990 return -EMSGSIZE;
991
992 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
993 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
994 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
995 nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
996 goto nla_put_failure;
997
998 genlmsg_end(msg, hdr);
999 return 0;
1000
1001nla_put_failure:
1002 genlmsg_cancel(msg, hdr);
1003 return -EMSGSIZE;
1004}
1005
1006static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
1007{
1008 struct nfc_dev *dev;
1009 struct nfc_llcp_local *local;
1010 int rc = 0;
1011 struct sk_buff *msg = NULL;
1012 u32 idx;
1013
1014 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1015 !info->attrs[NFC_ATTR_FIRMWARE_NAME])
1016 return -EINVAL;
1017
1018 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1019
1020 dev = nfc_get_device(idx);
1021 if (!dev)
1022 return -ENODEV;
1023
1024 device_lock(&dev->dev);
1025
1026 local = nfc_llcp_find_local(dev);
1027 if (!local) {
1028 rc = -ENODEV;
1029 goto exit;
1030 }
1031
1032 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1033 if (!msg) {
1034 rc = -ENOMEM;
1035 goto exit;
1036 }
1037
1038 rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
1039
1040exit:
1041 device_unlock(&dev->dev);
1042
1043 nfc_put_device(dev);
1044
1045 if (rc < 0) {
1046 if (msg)
1047 nlmsg_free(msg);
1048
1049 return rc;
1050 }
1051
1052 return genlmsg_reply(msg, info);
1053}
1054
1055static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
1056{
1057 struct nfc_dev *dev;
1058 struct nfc_llcp_local *local;
1059 u8 rw = 0;
1060 u16 miux = 0;
1061 u32 idx;
1062 int rc = 0;
1063
1064 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1065 (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
1066 !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
1067 !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
1068 return -EINVAL;
1069
1070 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
1071 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
1072
1073 if (rw > LLCP_MAX_RW)
1074 return -EINVAL;
1075 }
1076
1077 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
1078 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
1079
1080 if (miux > LLCP_MAX_MIUX)
1081 return -EINVAL;
1082 }
1083
1084 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1085
1086 dev = nfc_get_device(idx);
1087 if (!dev)
1088 return -ENODEV;
1089
1090 device_lock(&dev->dev);
1091
1092 local = nfc_llcp_find_local(dev);
1093 if (!local) {
1094 rc = -ENODEV;
1095 goto exit;
1096 }
1097
1098 if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
1099 if (dev->dep_link_up) {
1100 rc = -EINPROGRESS;
1101 goto exit;
1102 }
1103
1104 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
1105 }
1106
1107 if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
1108 local->rw = rw;
1109
1110 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
1111 local->miux = cpu_to_be16(miux);
1112
1113exit:
1114 device_unlock(&dev->dev);
1115
1116 nfc_put_device(dev);
1117
1118 return rc;
1119}
1120
1121static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1122{
1123 struct nfc_dev *dev;
1124 struct nfc_llcp_local *local;
1125 struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1126 u32 idx;
1127 u8 tid;
1128 char *uri;
1129 int rc = 0, rem;
1130 size_t uri_len, tlvs_len;
1131 struct hlist_head sdreq_list;
1132 struct nfc_llcp_sdp_tlv *sdreq;
1133
1134 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1135 !info->attrs[NFC_ATTR_LLC_SDP])
1136 return -EINVAL;
1137
1138 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1139
1140 dev = nfc_get_device(idx);
1141 if (!dev)
1142 return -ENODEV;
1143
1144 device_lock(&dev->dev);
1145
1146 if (dev->dep_link_up == false) {
1147 rc = -ENOLINK;
1148 goto exit;
1149 }
1150
1151 local = nfc_llcp_find_local(dev);
1152 if (!local) {
1153 rc = -ENODEV;
1154 goto exit;
1155 }
1156
1157 INIT_HLIST_HEAD(&sdreq_list);
1158
1159 tlvs_len = 0;
1160
1161 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1162 rc = nla_parse_nested_deprecated(sdp_attrs, NFC_SDP_ATTR_MAX,
1163 attr, nfc_sdp_genl_policy,
1164 info->extack);
1165
1166 if (rc != 0) {
1167 rc = -EINVAL;
1168 goto exit;
1169 }
1170
1171 if (!sdp_attrs[NFC_SDP_ATTR_URI])
1172 continue;
1173
1174 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1175 if (uri_len == 0)
1176 continue;
1177
1178 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1179 if (uri == NULL || *uri == 0)
1180 continue;
1181
1182 tid = local->sdreq_next_tid++;
1183
1184 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1185 if (sdreq == NULL) {
1186 rc = -ENOMEM;
1187 goto exit;
1188 }
1189
1190 tlvs_len += sdreq->tlv_len;
1191
1192 hlist_add_head(&sdreq->node, &sdreq_list);
1193 }
1194
1195 if (hlist_empty(&sdreq_list)) {
1196 rc = -EINVAL;
1197 goto exit;
1198 }
1199
1200 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1201exit:
1202 device_unlock(&dev->dev);
1203
1204 nfc_put_device(dev);
1205
1206 return rc;
1207}
1208
1209static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
1210{
1211 struct nfc_dev *dev;
1212 int rc;
1213 u32 idx;
1214 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1215
1216 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
1217 return -EINVAL;
1218
1219 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1220
1221 dev = nfc_get_device(idx);
1222 if (!dev)
1223 return -ENODEV;
1224
1225 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1226 sizeof(firmware_name));
1227
1228 rc = nfc_fw_download(dev, firmware_name);
1229
1230 nfc_put_device(dev);
1231 return rc;
1232}
1233
1234int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1235 u32 result)
1236{
1237 struct sk_buff *msg;
1238 void *hdr;
1239
1240 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1241 if (!msg)
1242 return -ENOMEM;
1243
1244 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1245 NFC_CMD_FW_DOWNLOAD);
1246 if (!hdr)
1247 goto free_msg;
1248
1249 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
1250 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
1251 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1252 goto nla_put_failure;
1253
1254 genlmsg_end(msg, hdr);
1255
1256 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1257
1258 return 0;
1259
1260nla_put_failure:
1261free_msg:
1262 nlmsg_free(msg);
1263 return -EMSGSIZE;
1264}
1265
1266static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1267{
1268 struct nfc_dev *dev;
1269 int rc;
1270 u32 idx, se_idx;
1271
1272 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1273 !info->attrs[NFC_ATTR_SE_INDEX])
1274 return -EINVAL;
1275
1276 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1277 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1278
1279 dev = nfc_get_device(idx);
1280 if (!dev)
1281 return -ENODEV;
1282
1283 rc = nfc_enable_se(dev, se_idx);
1284
1285 nfc_put_device(dev);
1286 return rc;
1287}
1288
1289static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1290{
1291 struct nfc_dev *dev;
1292 int rc;
1293 u32 idx, se_idx;
1294
1295 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1296 !info->attrs[NFC_ATTR_SE_INDEX])
1297 return -EINVAL;
1298
1299 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1300 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1301
1302 dev = nfc_get_device(idx);
1303 if (!dev)
1304 return -ENODEV;
1305
1306 rc = nfc_disable_se(dev, se_idx);
1307
1308 nfc_put_device(dev);
1309 return rc;
1310}
1311
1312static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1313 u32 portid, u32 seq,
1314 struct netlink_callback *cb,
1315 int flags)
1316{
1317 void *hdr;
1318 struct nfc_se *se, *n;
1319
1320 list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1321 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1322 NFC_CMD_GET_SE);
1323 if (!hdr)
1324 goto nla_put_failure;
1325
1326 if (cb)
1327 genl_dump_check_consistent(cb, hdr);
1328
1329 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1330 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1331 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1332 goto nla_put_failure;
1333
1334 genlmsg_end(msg, hdr);
1335 }
1336
1337 return 0;
1338
1339nla_put_failure:
1340 genlmsg_cancel(msg, hdr);
1341 return -EMSGSIZE;
1342}
1343
1344static int nfc_genl_dump_ses(struct sk_buff *skb,
1345 struct netlink_callback *cb)
1346{
1347 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1348 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1349 bool first_call = false;
1350
1351 if (!iter) {
1352 first_call = true;
1353 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1354 if (!iter)
1355 return -ENOMEM;
1356 cb->args[0] = (long) iter;
1357 }
1358
1359 mutex_lock(&nfc_devlist_mutex);
1360
1361 cb->seq = nfc_devlist_generation;
1362
1363 if (first_call) {
1364 nfc_device_iter_init(iter);
1365 dev = nfc_device_iter_next(iter);
1366 }
1367
1368 while (dev) {
1369 int rc;
1370
1371 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1372 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1373 if (rc < 0)
1374 break;
1375
1376 dev = nfc_device_iter_next(iter);
1377 }
1378
1379 mutex_unlock(&nfc_devlist_mutex);
1380
1381 cb->args[1] = (long) dev;
1382
1383 return skb->len;
1384}
1385
1386static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1387{
1388 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1389
1390 nfc_device_iter_exit(iter);
1391 kfree(iter);
1392
1393 return 0;
1394}
1395
1396static int nfc_se_io(struct nfc_dev *dev, u32 se_idx,
1397 u8 *apdu, size_t apdu_length,
1398 se_io_cb_t cb, void *cb_context)
1399{
1400 struct nfc_se *se;
1401 int rc;
1402
1403 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
1404
1405 device_lock(&dev->dev);
1406
1407 if (!device_is_registered(&dev->dev)) {
1408 rc = -ENODEV;
1409 goto error;
1410 }
1411
1412 if (!dev->dev_up) {
1413 rc = -ENODEV;
1414 goto error;
1415 }
1416
1417 if (!dev->ops->se_io) {
1418 rc = -EOPNOTSUPP;
1419 goto error;
1420 }
1421
1422 se = nfc_find_se(dev, se_idx);
1423 if (!se) {
1424 rc = -EINVAL;
1425 goto error;
1426 }
1427
1428 if (se->state != NFC_SE_ENABLED) {
1429 rc = -ENODEV;
1430 goto error;
1431 }
1432
1433 rc = dev->ops->se_io(dev, se_idx, apdu,
1434 apdu_length, cb, cb_context);
1435
1436error:
1437 device_unlock(&dev->dev);
1438 return rc;
1439}
1440
1441struct se_io_ctx {
1442 u32 dev_idx;
1443 u32 se_idx;
1444};
1445
1446static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1447{
1448 struct se_io_ctx *ctx = context;
1449 struct sk_buff *msg;
1450 void *hdr;
1451
1452 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1453 if (!msg) {
1454 kfree(ctx);
1455 return;
1456 }
1457
1458 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1459 NFC_CMD_SE_IO);
1460 if (!hdr)
1461 goto free_msg;
1462
1463 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1464 nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1465 nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1466 goto nla_put_failure;
1467
1468 genlmsg_end(msg, hdr);
1469
1470 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1471
1472 kfree(ctx);
1473
1474 return;
1475
1476nla_put_failure:
1477free_msg:
1478 nlmsg_free(msg);
1479 kfree(ctx);
1480
1481 return;
1482}
1483
1484static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1485{
1486 struct nfc_dev *dev;
1487 struct se_io_ctx *ctx;
1488 u32 dev_idx, se_idx;
1489 u8 *apdu;
1490 size_t apdu_len;
1491
1492 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1493 !info->attrs[NFC_ATTR_SE_INDEX] ||
1494 !info->attrs[NFC_ATTR_SE_APDU])
1495 return -EINVAL;
1496
1497 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1498 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1499
1500 dev = nfc_get_device(dev_idx);
1501 if (!dev)
1502 return -ENODEV;
1503
1504 if (!dev->ops || !dev->ops->se_io)
1505 return -ENOTSUPP;
1506
1507 apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1508 if (apdu_len == 0)
1509 return -EINVAL;
1510
1511 apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1512 if (!apdu)
1513 return -EINVAL;
1514
1515 ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1516 if (!ctx)
1517 return -ENOMEM;
1518
1519 ctx->dev_idx = dev_idx;
1520 ctx->se_idx = se_idx;
1521
1522 return nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1523}
1524
1525static int nfc_genl_vendor_cmd(struct sk_buff *skb,
1526 struct genl_info *info)
1527{
1528 struct nfc_dev *dev;
1529 struct nfc_vendor_cmd *cmd;
1530 u32 dev_idx, vid, subcmd;
1531 u8 *data;
1532 size_t data_len;
1533 int i, err;
1534
1535 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1536 !info->attrs[NFC_ATTR_VENDOR_ID] ||
1537 !info->attrs[NFC_ATTR_VENDOR_SUBCMD])
1538 return -EINVAL;
1539
1540 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1541 vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]);
1542 subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]);
1543
1544 dev = nfc_get_device(dev_idx);
1545 if (!dev || !dev->vendor_cmds || !dev->n_vendor_cmds)
1546 return -ENODEV;
1547
1548 if (info->attrs[NFC_ATTR_VENDOR_DATA]) {
1549 data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]);
1550 data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]);
1551 if (data_len == 0)
1552 return -EINVAL;
1553 } else {
1554 data = NULL;
1555 data_len = 0;
1556 }
1557
1558 for (i = 0; i < dev->n_vendor_cmds; i++) {
1559 cmd = &dev->vendor_cmds[i];
1560
1561 if (cmd->vendor_id != vid || cmd->subcmd != subcmd)
1562 continue;
1563
1564 dev->cur_cmd_info = info;
1565 err = cmd->doit(dev, data, data_len);
1566 dev->cur_cmd_info = NULL;
1567 return err;
1568 }
1569
1570 return -EOPNOTSUPP;
1571}
1572
1573
1574static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
1575 int flags, u8 cmd)
1576{
1577
1578 return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd);
1579}
1580
1581static struct sk_buff *
1582__nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen,
1583 u32 portid, u32 seq,
1584 enum nfc_attrs attr,
1585 u32 oui, u32 subcmd, gfp_t gfp)
1586{
1587 struct sk_buff *skb;
1588 void *hdr;
1589
1590 skb = nlmsg_new(approxlen + 100, gfp);
1591 if (!skb)
1592 return NULL;
1593
1594 hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR);
1595 if (!hdr) {
1596 kfree_skb(skb);
1597 return NULL;
1598 }
1599
1600 if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx))
1601 goto nla_put_failure;
1602 if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui))
1603 goto nla_put_failure;
1604 if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd))
1605 goto nla_put_failure;
1606
1607 ((void **)skb->cb)[0] = dev;
1608 ((void **)skb->cb)[1] = hdr;
1609
1610 return skb;
1611
1612nla_put_failure:
1613 kfree_skb(skb);
1614 return NULL;
1615}
1616
1617struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev,
1618 enum nfc_attrs attr,
1619 u32 oui, u32 subcmd,
1620 int approxlen)
1621{
1622 if (WARN_ON(!dev->cur_cmd_info))
1623 return NULL;
1624
1625 return __nfc_alloc_vendor_cmd_skb(dev, approxlen,
1626 dev->cur_cmd_info->snd_portid,
1627 dev->cur_cmd_info->snd_seq, attr,
1628 oui, subcmd, GFP_KERNEL);
1629}
1630EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb);
1631
1632int nfc_vendor_cmd_reply(struct sk_buff *skb)
1633{
1634 struct nfc_dev *dev = ((void **)skb->cb)[0];
1635 void *hdr = ((void **)skb->cb)[1];
1636
1637
1638 memset(skb->cb, 0, sizeof(skb->cb));
1639
1640 if (WARN_ON(!dev->cur_cmd_info)) {
1641 kfree_skb(skb);
1642 return -EINVAL;
1643 }
1644
1645 genlmsg_end(skb, hdr);
1646 return genlmsg_reply(skb, dev->cur_cmd_info);
1647}
1648EXPORT_SYMBOL(nfc_vendor_cmd_reply);
1649
1650static const struct genl_ops nfc_genl_ops[] = {
1651 {
1652 .cmd = NFC_CMD_GET_DEVICE,
1653 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1654 .doit = nfc_genl_get_device,
1655 .dumpit = nfc_genl_dump_devices,
1656 .done = nfc_genl_dump_devices_done,
1657 },
1658 {
1659 .cmd = NFC_CMD_DEV_UP,
1660 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1661 .doit = nfc_genl_dev_up,
1662 },
1663 {
1664 .cmd = NFC_CMD_DEV_DOWN,
1665 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1666 .doit = nfc_genl_dev_down,
1667 },
1668 {
1669 .cmd = NFC_CMD_START_POLL,
1670 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1671 .doit = nfc_genl_start_poll,
1672 },
1673 {
1674 .cmd = NFC_CMD_STOP_POLL,
1675 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1676 .doit = nfc_genl_stop_poll,
1677 },
1678 {
1679 .cmd = NFC_CMD_DEP_LINK_UP,
1680 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1681 .doit = nfc_genl_dep_link_up,
1682 },
1683 {
1684 .cmd = NFC_CMD_DEP_LINK_DOWN,
1685 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1686 .doit = nfc_genl_dep_link_down,
1687 },
1688 {
1689 .cmd = NFC_CMD_GET_TARGET,
1690 .validate = GENL_DONT_VALIDATE_STRICT |
1691 GENL_DONT_VALIDATE_DUMP_STRICT,
1692 .dumpit = nfc_genl_dump_targets,
1693 .done = nfc_genl_dump_targets_done,
1694 },
1695 {
1696 .cmd = NFC_CMD_LLC_GET_PARAMS,
1697 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1698 .doit = nfc_genl_llc_get_params,
1699 },
1700 {
1701 .cmd = NFC_CMD_LLC_SET_PARAMS,
1702 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1703 .doit = nfc_genl_llc_set_params,
1704 },
1705 {
1706 .cmd = NFC_CMD_LLC_SDREQ,
1707 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1708 .doit = nfc_genl_llc_sdreq,
1709 },
1710 {
1711 .cmd = NFC_CMD_FW_DOWNLOAD,
1712 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1713 .doit = nfc_genl_fw_download,
1714 },
1715 {
1716 .cmd = NFC_CMD_ENABLE_SE,
1717 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1718 .doit = nfc_genl_enable_se,
1719 },
1720 {
1721 .cmd = NFC_CMD_DISABLE_SE,
1722 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1723 .doit = nfc_genl_disable_se,
1724 },
1725 {
1726 .cmd = NFC_CMD_GET_SE,
1727 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1728 .dumpit = nfc_genl_dump_ses,
1729 .done = nfc_genl_dump_ses_done,
1730 },
1731 {
1732 .cmd = NFC_CMD_SE_IO,
1733 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1734 .doit = nfc_genl_se_io,
1735 },
1736 {
1737 .cmd = NFC_CMD_ACTIVATE_TARGET,
1738 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1739 .doit = nfc_genl_activate_target,
1740 },
1741 {
1742 .cmd = NFC_CMD_VENDOR,
1743 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1744 .doit = nfc_genl_vendor_cmd,
1745 },
1746 {
1747 .cmd = NFC_CMD_DEACTIVATE_TARGET,
1748 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1749 .doit = nfc_genl_deactivate_target,
1750 },
1751};
1752
1753static struct genl_family nfc_genl_family __ro_after_init = {
1754 .hdrsize = 0,
1755 .name = NFC_GENL_NAME,
1756 .version = NFC_GENL_VERSION,
1757 .maxattr = NFC_ATTR_MAX,
1758 .policy = nfc_genl_policy,
1759 .module = THIS_MODULE,
1760 .ops = nfc_genl_ops,
1761 .n_ops = ARRAY_SIZE(nfc_genl_ops),
1762 .mcgrps = nfc_genl_mcgrps,
1763 .n_mcgrps = ARRAY_SIZE(nfc_genl_mcgrps),
1764};
1765
1766
1767struct urelease_work {
1768 struct work_struct w;
1769 u32 portid;
1770};
1771
1772static void nfc_urelease_event_work(struct work_struct *work)
1773{
1774 struct urelease_work *w = container_of(work, struct urelease_work, w);
1775 struct class_dev_iter iter;
1776 struct nfc_dev *dev;
1777
1778 pr_debug("portid %d\n", w->portid);
1779
1780 mutex_lock(&nfc_devlist_mutex);
1781
1782 nfc_device_iter_init(&iter);
1783 dev = nfc_device_iter_next(&iter);
1784
1785 while (dev) {
1786 mutex_lock(&dev->genl_data.genl_data_mutex);
1787
1788 if (dev->genl_data.poll_req_portid == w->portid) {
1789 nfc_stop_poll(dev);
1790 dev->genl_data.poll_req_portid = 0;
1791 }
1792
1793 mutex_unlock(&dev->genl_data.genl_data_mutex);
1794
1795 dev = nfc_device_iter_next(&iter);
1796 }
1797
1798 nfc_device_iter_exit(&iter);
1799
1800 mutex_unlock(&nfc_devlist_mutex);
1801
1802 kfree(w);
1803}
1804
1805static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1806 unsigned long event, void *ptr)
1807{
1808 struct netlink_notify *n = ptr;
1809 struct urelease_work *w;
1810
1811 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1812 goto out;
1813
1814 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1815
1816 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1817 if (w) {
1818 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1819 w->portid = n->portid;
1820 schedule_work((struct work_struct *) w);
1821 }
1822
1823out:
1824 return NOTIFY_DONE;
1825}
1826
1827void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1828{
1829 genl_data->poll_req_portid = 0;
1830 mutex_init(&genl_data->genl_data_mutex);
1831}
1832
1833void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1834{
1835 mutex_destroy(&genl_data->genl_data_mutex);
1836}
1837
1838static struct notifier_block nl_notifier = {
1839 .notifier_call = nfc_genl_rcv_nl_event,
1840};
1841
1842
1843
1844
1845
1846
1847int __init nfc_genl_init(void)
1848{
1849 int rc;
1850
1851 rc = genl_register_family(&nfc_genl_family);
1852 if (rc)
1853 return rc;
1854
1855 netlink_register_notifier(&nl_notifier);
1856
1857 return 0;
1858}
1859
1860
1861
1862
1863
1864
1865void nfc_genl_exit(void)
1866{
1867 netlink_unregister_notifier(&nl_notifier);
1868 genl_unregister_family(&nfc_genl_family);
1869}
1870
