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