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