projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NFC: Define secure element IO API and commands
[deliverable/linux.git] / net / nfc / netlink.c
CommitLineData
4d12b8b1
LRV		 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 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the
20 * Free Software Foundation, Inc.,
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23
52858b51 24#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
20c239c1 25
4d12b8b1
LRV		 26#include <net/genetlink.h>
27#include <linux/nfc.h>
28#include <linux/slab.h>
29
30#include "nfc.h"
30cc4587 31#include "llcp.h"
52feb444 32
4d12b8b1
LRV		 33static struct genl_multicast_group nfc_genl_event_mcgrp = {
34 .name = NFC_GENL_MCAST_EVENT_NAME,
35};
36
e5fe4cf8 37static struct genl_family nfc_genl_family = {
4d12b8b1
LRV		 38 .id = GENL_ID_GENERATE,
39 .hdrsize = 0,
40 .name = NFC_GENL_NAME,
41 .version = NFC_GENL_VERSION,
42 .maxattr = NFC_ATTR_MAX,
43};
44
45static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
46 [NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
47 [NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
48 .len = NFC_DEVICE_NAME_MAXSIZE },
49 [NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
1ed28f61
SO		 50 [NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
51 [NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
c970a1ac 52 [NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
fe7c5800
SO		 53 [NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
54 [NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
8af362d1
TE		 55 [NFC_ATTR_LLC_PARAM_LTO] = { .type = NLA_U8 },
56 [NFC_ATTR_LLC_PARAM_RW] = { .type = NLA_U8 },
57 [NFC_ATTR_LLC_PARAM_MIUX] = { .type = NLA_U16 },
d9b8d8e1 58 [NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
9674da87
EL		 59 [NFC_ATTR_FIRMWARE_NAME] = { .type = NLA_STRING,
60 .len = NFC_FIRMWARE_NAME_MAXSIZE },
d9b8d8e1
TE		 61};
62
63static const struct nla_policy nfc_sdp_genl_policy[NFC_SDP_ATTR_MAX + 1] = {
64 [NFC_SDP_ATTR_URI] = { .type = NLA_STRING },
65 [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
4d12b8b1
LRV		 66};
67
68static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
0a40acb2 69 struct netlink_callback *cb, int flags)
4d12b8b1
LRV		 70{
71 void *hdr;
72
15e47304 73 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
0a40acb2 74 &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
4d12b8b1
LRV		 75 if (!hdr)
76 return -EMSGSIZE;
77
78 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
79
1e6428d8
DM		 80 if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
81 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
82 nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
83 nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
84 goto nla_put_failure;
85 if (target->nfcid1_len > 0 &&
86 nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
87 target->nfcid1))
88 goto nla_put_failure;
89 if (target->sensb_res_len > 0 &&
90 nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
91 target->sensb_res))
92 goto nla_put_failure;
93 if (target->sensf_res_len > 0 &&
94 nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
95 target->sensf_res))
96 goto nla_put_failure;
4d12b8b1
LRV		 97
98 return genlmsg_end(msg, hdr);
99
100nla_put_failure:
101 genlmsg_cancel(msg, hdr);
102 return -EMSGSIZE;
103}
104
105static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
106{
107 struct nfc_dev *dev;
108 int rc;
109 u32 idx;
110
111 rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
0a40acb2
SO		 112 nfc_genl_family.attrbuf,
113 nfc_genl_family.maxattr,
114 nfc_genl_policy);
4d12b8b1
LRV		 115 if (rc < 0)
116 return ERR_PTR(rc);
117
118 if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
119 return ERR_PTR(-EINVAL);
120
121 idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
122
123 dev = nfc_get_device(idx);
124 if (!dev)
125 return ERR_PTR(-ENODEV);
126
127 return dev;
128}
129
130static int nfc_genl_dump_targets(struct sk_buff *skb,
0a40acb2 131 struct netlink_callback *cb)
4d12b8b1
LRV		 132{
133 int i = cb->args[0];
134 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
135 int rc;
136
4d12b8b1
LRV		 137 if (!dev) {
138 dev = __get_device_from_cb(cb);
139 if (IS_ERR(dev))
140 return PTR_ERR(dev);
141
142 cb->args[1] = (long) dev;
143 }
144
d4ccb132 145 device_lock(&dev->dev);
4d12b8b1
LRV		 146
147 cb->seq = dev->targets_generation;
148
149 while (i < dev->n_targets) {
150 rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
0a40acb2 151 NLM_F_MULTI);
4d12b8b1
LRV		 152 if (rc < 0)
153 break;
154
155 i++;
156 }
157
d4ccb132 158 device_unlock(&dev->dev);
4d12b8b1
LRV		 159
160 cb->args[0] = i;
161
162 return skb->len;
163}
164
165static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
166{
167 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
168
4d12b8b1
LRV		 169 if (dev)
170 nfc_put_device(dev);
171
172 return 0;
173}
174
175int nfc_genl_targets_found(struct nfc_dev *dev)
176{
177 struct sk_buff *msg;
178 void *hdr;
179
15e47304 180 dev->genl_data.poll_req_portid = 0;
4d12b8b1 181
58050fce 182 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
4d12b8b1
LRV		 183 if (!msg)
184 return -ENOMEM;
185
186 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2 187 NFC_EVENT_TARGETS_FOUND);
4d12b8b1
LRV		 188 if (!hdr)
189 goto free_msg;
190
1e6428d8
DM		 191 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
192 goto nla_put_failure;
4d12b8b1
LRV		 193
194 genlmsg_end(msg, hdr);
195
196 return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
197
198nla_put_failure:
199 genlmsg_cancel(msg, hdr);
200free_msg:
201 nlmsg_free(msg);
202 return -EMSGSIZE;
203}
204
8112a5c9
SO		 205int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
206{
207 struct sk_buff *msg;
208 void *hdr;
209
58050fce 210 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8112a5c9
SO		 211 if (!msg)
212 return -ENOMEM;
213
214 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
215 NFC_EVENT_TARGET_LOST);
216 if (!hdr)
217 goto free_msg;
218
59ef43e6
JL		 219 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
220 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
221 goto nla_put_failure;
8112a5c9
SO		 222
223 genlmsg_end(msg, hdr);
224
225 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
226
227 return 0;
228
fc40a8c1
SO		 229nla_put_failure:
230 genlmsg_cancel(msg, hdr);
231free_msg:
232 nlmsg_free(msg);
233 return -EMSGSIZE;
234}
235
236int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
237{
238 struct sk_buff *msg;
239 void *hdr;
240
58050fce 241 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fc40a8c1
SO		 242 if (!msg)
243 return -ENOMEM;
244
245 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
246 NFC_EVENT_TM_ACTIVATED);
247 if (!hdr)
248 goto free_msg;
249
250 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
251 goto nla_put_failure;
252 if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
253 goto nla_put_failure;
254
255 genlmsg_end(msg, hdr);
256
257 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
258
259 return 0;
260
261nla_put_failure:
262 genlmsg_cancel(msg, hdr);
263free_msg:
264 nlmsg_free(msg);
265 return -EMSGSIZE;
266}
267
268int nfc_genl_tm_deactivated(struct nfc_dev *dev)
269{
270 struct sk_buff *msg;
271 void *hdr;
272
58050fce 273 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fc40a8c1
SO		 274 if (!msg)
275 return -ENOMEM;
276
277 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
278 NFC_EVENT_TM_DEACTIVATED);
279 if (!hdr)
280 goto free_msg;
281
282 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
283 goto nla_put_failure;
284
285 genlmsg_end(msg, hdr);
286
287 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
288
289 return 0;
290
8112a5c9
SO		 291nla_put_failure:
292 genlmsg_cancel(msg, hdr);
293free_msg:
294 nlmsg_free(msg);
295 return -EMSGSIZE;
296}
297
4d12b8b1
LRV		 298int nfc_genl_device_added(struct nfc_dev *dev)
299{
300 struct sk_buff *msg;
301 void *hdr;
302
58050fce 303 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4d12b8b1
LRV		 304 if (!msg)
305 return -ENOMEM;
306
307 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2 308 NFC_EVENT_DEVICE_ADDED);
4d12b8b1
LRV		 309 if (!hdr)
310 goto free_msg;
311
1e6428d8
DM		 312 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
313 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
314 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
315 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
316 goto nla_put_failure;
4d12b8b1
LRV		 317
318 genlmsg_end(msg, hdr);
319
320 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
321
322 return 0;
323
324nla_put_failure:
325 genlmsg_cancel(msg, hdr);
326free_msg:
327 nlmsg_free(msg);
328 return -EMSGSIZE;
329}
330
331int nfc_genl_device_removed(struct nfc_dev *dev)
332{
333 struct sk_buff *msg;
334 void *hdr;
335
58050fce 336 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4d12b8b1
LRV		 337 if (!msg)
338 return -ENOMEM;
339
340 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2 341 NFC_EVENT_DEVICE_REMOVED);
4d12b8b1
LRV		 342 if (!hdr)
343 goto free_msg;
344
1e6428d8
DM		 345 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
346 goto nla_put_failure;
4d12b8b1
LRV		 347
348 genlmsg_end(msg, hdr);
349
350 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
351
352 return 0;
353
354nla_put_failure:
355 genlmsg_cancel(msg, hdr);
356free_msg:
357 nlmsg_free(msg);
358 return -EMSGSIZE;
359}
360
d9b8d8e1
TE		 361int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list)
362{
363 struct sk_buff *msg;
364 struct nlattr *sdp_attr, *uri_attr;
365 struct nfc_llcp_sdp_tlv *sdres;
366 struct hlist_node *n;
367 void *hdr;
368 int rc = -EMSGSIZE;
369 int i;
370
371 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
372 if (!msg)
373 return -ENOMEM;
374
375 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
376 NFC_EVENT_LLC_SDRES);
377 if (!hdr)
378 goto free_msg;
379
380 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
381 goto nla_put_failure;
382
383 sdp_attr = nla_nest_start(msg, NFC_ATTR_LLC_SDP);
384 if (sdp_attr == NULL) {
385 rc = -ENOMEM;
386 goto nla_put_failure;
387 }
388
389 i = 1;
390 hlist_for_each_entry_safe(sdres, n, sdres_list, node) {
391 pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap);
392
393 uri_attr = nla_nest_start(msg, i++);
394 if (uri_attr == NULL) {
395 rc = -ENOMEM;
396 goto nla_put_failure;
397 }
398
399 if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap))
400 goto nla_put_failure;
401
402 if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri))
403 goto nla_put_failure;
404
405 nla_nest_end(msg, uri_attr);
406
407 hlist_del(&sdres->node);
408
409 nfc_llcp_free_sdp_tlv(sdres);
410 }
411
412 nla_nest_end(msg, sdp_attr);
413
414 genlmsg_end(msg, hdr);
415
416 return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
417
418nla_put_failure:
419 genlmsg_cancel(msg, hdr);
420
421free_msg:
422 nlmsg_free(msg);
423
424 nfc_llcp_free_sdp_tlv_list(sdres_list);
425
426 return rc;
427}
428
2757c372
SO		 429int nfc_genl_se_added(struct nfc_dev *dev, u32 se_idx, u16 type)
430{
431 struct sk_buff *msg;
432 void *hdr;
433
434 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
435 if (!msg)
436 return -ENOMEM;
437
438 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
439 NFC_EVENT_SE_ADDED);
440 if (!hdr)
441 goto free_msg;
442
443 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
444 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx) ||
445 nla_put_u8(msg, NFC_ATTR_SE_TYPE, type))
446 goto nla_put_failure;
447
448 genlmsg_end(msg, hdr);
449
450 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
451
452 return 0;
453
454nla_put_failure:
455 genlmsg_cancel(msg, hdr);
456free_msg:
457 nlmsg_free(msg);
458 return -EMSGSIZE;
459}
460
461int nfc_genl_se_removed(struct nfc_dev *dev, u32 se_idx)
462{
463 struct sk_buff *msg;
464 void *hdr;
465
466 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
467 if (!msg)
468 return -ENOMEM;
469
470 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
471 NFC_EVENT_SE_REMOVED);
472 if (!hdr)
473 goto free_msg;
474
475 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
476 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se_idx))
477 goto nla_put_failure;
478
479 genlmsg_end(msg, hdr);
480
481 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
482
483 return 0;
484
485nla_put_failure:
486 genlmsg_cancel(msg, hdr);
487free_msg:
488 nlmsg_free(msg);
489 return -EMSGSIZE;
490}
491
4d12b8b1 492static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
15e47304 493 u32 portid, u32 seq,
0a40acb2
SO		 494 struct netlink_callback *cb,
495 int flags)
4d12b8b1
LRV		 496{
497 void *hdr;
498
15e47304 499 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
0a40acb2 500 NFC_CMD_GET_DEVICE);
4d12b8b1
LRV		 501 if (!hdr)
502 return -EMSGSIZE;
503
504 if (cb)
505 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
506
1e6428d8
DM		 507 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
508 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
509 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
7ad39395
TE		 510 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
511 nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
1e6428d8 512 goto nla_put_failure;
4d12b8b1
LRV		 513
514 return genlmsg_end(msg, hdr);
515
516nla_put_failure:
517 genlmsg_cancel(msg, hdr);
518 return -EMSGSIZE;
519}
520
521static int nfc_genl_dump_devices(struct sk_buff *skb,
0a40acb2 522 struct netlink_callback *cb)
4d12b8b1
LRV		 523{
524 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
525 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
526 bool first_call = false;
527
4d12b8b1
LRV		 528 if (!iter) {
529 first_call = true;
530 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
531 if (!iter)
532 return -ENOMEM;
533 cb->args[0] = (long) iter;
534 }
535
536 mutex_lock(&nfc_devlist_mutex);
537
538 cb->seq = nfc_devlist_generation;
539
540 if (first_call) {
541 nfc_device_iter_init(iter);
542 dev = nfc_device_iter_next(iter);
543 }
544
545 while (dev) {
546 int rc;
547
15e47304 548 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
0a40acb2 549 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
4d12b8b1
LRV		 550 if (rc < 0)
551 break;
552
553 dev = nfc_device_iter_next(iter);
554 }
555
556 mutex_unlock(&nfc_devlist_mutex);
557
558 cb->args[1] = (long) dev;
559
560 return skb->len;
561}
562
563static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
564{
565 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
566
4d12b8b1
LRV		 567 nfc_device_iter_exit(iter);
568 kfree(iter);
569
570 return 0;
571}
572
1ed28f61 573int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
0a40acb2 574 u8 comm_mode, u8 rf_mode)
1ed28f61
SO		 575{
576 struct sk_buff *msg;
577 void *hdr;
578
579 pr_debug("DEP link is up\n");
580
58050fce 581 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1ed28f61
SO		 582 if (!msg)
583 return -ENOMEM;
584
0a40acb2 585 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
1ed28f61
SO		 586 if (!hdr)
587 goto free_msg;
588
1e6428d8
DM		 589 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
590 goto nla_put_failure;
591 if (rf_mode == NFC_RF_INITIATOR &&
592 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
593 goto nla_put_failure;
594 if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
595 nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
596 goto nla_put_failure;
1ed28f61
SO		 597
598 genlmsg_end(msg, hdr);
599
600 dev->dep_link_up = true;
601
602 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
603
604 return 0;
605
606nla_put_failure:
607 genlmsg_cancel(msg, hdr);
608free_msg:
609 nlmsg_free(msg);
610 return -EMSGSIZE;
611}
612
613int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
614{
615 struct sk_buff *msg;
616 void *hdr;
617
618 pr_debug("DEP link is down\n");
619
58050fce 620 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1ed28f61
SO		 621 if (!msg)
622 return -ENOMEM;
623
624 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
0a40acb2 625 NFC_CMD_DEP_LINK_DOWN);
1ed28f61
SO		 626 if (!hdr)
627 goto free_msg;
628
1e6428d8
DM		 629 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
630 goto nla_put_failure;
1ed28f61
SO		 631
632 genlmsg_end(msg, hdr);
633
634 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
635
636 return 0;
637
638nla_put_failure:
639 genlmsg_cancel(msg, hdr);
640free_msg:
641 nlmsg_free(msg);
642 return -EMSGSIZE;
643}
644
4d12b8b1
LRV		 645static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
646{
647 struct sk_buff *msg;
648 struct nfc_dev *dev;
649 u32 idx;
650 int rc = -ENOBUFS;
651
4d12b8b1
LRV		 652 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
653 return -EINVAL;
654
655 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
656
657 dev = nfc_get_device(idx);
658 if (!dev)
659 return -ENODEV;
660
58050fce 661 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4d12b8b1
LRV		 662 if (!msg) {
663 rc = -ENOMEM;
664 goto out_putdev;
665 }
666
15e47304 667 rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
0a40acb2 668 NULL, 0);
4d12b8b1
LRV		 669 if (rc < 0)
670 goto out_free;
671
672 nfc_put_device(dev);
673
674 return genlmsg_reply(msg, info);
675
676out_free:
677 nlmsg_free(msg);
678out_putdev:
679 nfc_put_device(dev);
680 return rc;
681}
682
8b3fe7b5
IE		 683static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
684{
685 struct nfc_dev *dev;
686 int rc;
687 u32 idx;
688
8b3fe7b5
IE		 689 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
690 return -EINVAL;
691
692 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
693
694 dev = nfc_get_device(idx);
695 if (!dev)
696 return -ENODEV;
697
698 rc = nfc_dev_up(dev);
699
700 nfc_put_device(dev);
701 return rc;
702}
703
704static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
705{
706 struct nfc_dev *dev;
707 int rc;
708 u32 idx;
709
8b3fe7b5
IE		 710 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
711 return -EINVAL;
712
713 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
714
715 dev = nfc_get_device(idx);
716 if (!dev)
717 return -ENODEV;
718
719 rc = nfc_dev_down(dev);
720
721 nfc_put_device(dev);
722 return rc;
723}
724
4d12b8b1
LRV		 725static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
726{
727 struct nfc_dev *dev;
728 int rc;
729 u32 idx;
fe7c5800 730 u32 im_protocols = 0, tm_protocols = 0;
4d12b8b1 731
1ed28f61
SO		 732 pr_debug("Poll start\n");
733
4d12b8b1 734 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
fe7c5800
SO		 735 ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
736 !info->attrs[NFC_ATTR_PROTOCOLS]) &&
0f450772 737 !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
4d12b8b1
LRV		 738 return -EINVAL;
739
740 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
fe7c5800
SO		 741
742 if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
743 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
fe7c5800
SO		 744
745 if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
746 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
5e50ee3a
SO		 747 else if (info->attrs[NFC_ATTR_PROTOCOLS])
748 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
4d12b8b1
LRV		 749
750 dev = nfc_get_device(idx);
751 if (!dev)
752 return -ENODEV;
753
754 mutex_lock(&dev->genl_data.genl_data_mutex);
755
fe7c5800 756 rc = nfc_start_poll(dev, im_protocols, tm_protocols);
4d12b8b1 757 if (!rc)
15e47304 758 dev->genl_data.poll_req_portid = info->snd_portid;
4d12b8b1
LRV		 759
760 mutex_unlock(&dev->genl_data.genl_data_mutex);
761
762 nfc_put_device(dev);
763 return rc;
764}
765
766static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
767{
768 struct nfc_dev *dev;
769 int rc;
770 u32 idx;
771
4d12b8b1
LRV		 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
a831b913
SO		 781 device_lock(&dev->dev);
782
783 if (!dev->polling) {
784 device_unlock(&dev->dev);
785 return -EINVAL;
786 }
787
788 device_unlock(&dev->dev);
789
4d12b8b1
LRV		 790 mutex_lock(&dev->genl_data.genl_data_mutex);
791
15e47304 792 if (dev->genl_data.poll_req_portid != info->snd_portid) {
4d12b8b1
LRV		 793 rc = -EBUSY;
794 goto out;
795 }
796
797 rc = nfc_stop_poll(dev);
15e47304 798 dev->genl_data.poll_req_portid = 0;
4d12b8b1
LRV		 799
800out:
801 mutex_unlock(&dev->genl_data.genl_data_mutex);
802 nfc_put_device(dev);
803 return rc;
804}
805
1ed28f61
SO		 806static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
807{
808 struct nfc_dev *dev;
809 int rc, tgt_idx;
810 u32 idx;
47807d3d 811 u8 comm;
1ed28f61
SO		 812
813 pr_debug("DEP link up\n");
814
815 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
47807d3d 816 !info->attrs[NFC_ATTR_COMM_MODE])
1ed28f61
SO		 817 return -EINVAL;
818
819 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
820 if (!info->attrs[NFC_ATTR_TARGET_INDEX])
821 tgt_idx = NFC_TARGET_IDX_ANY;
822 else
823 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
824
825 comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
1ed28f61
SO		 826
827 if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
828 return -EINVAL;
829
1ed28f61
SO		 830 dev = nfc_get_device(idx);
831 if (!dev)
832 return -ENODEV;
833
47807d3d 834 rc = nfc_dep_link_up(dev, tgt_idx, comm);
1ed28f61
SO		 835
836 nfc_put_device(dev);
837
838 return rc;
839}
840
841static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
842{
843 struct nfc_dev *dev;
844 int rc;
845 u32 idx;
846
847 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
848 return -EINVAL;
849
850 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
851
852 dev = nfc_get_device(idx);
853 if (!dev)
854 return -ENODEV;
855
856 rc = nfc_dep_link_down(dev);
857
858 nfc_put_device(dev);
859 return rc;
860}
861
52feb444
TE		 862static int nfc_genl_send_params(struct sk_buff *msg,
863 struct nfc_llcp_local *local,
864 u32 portid, u32 seq)
865{
866 void *hdr;
867
868 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
869 NFC_CMD_LLC_GET_PARAMS);
870 if (!hdr)
871 return -EMSGSIZE;
872
873 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
874 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
875 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
876 nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
877 goto nla_put_failure;
878
879 return genlmsg_end(msg, hdr);
880
881nla_put_failure:
882
883 genlmsg_cancel(msg, hdr);
884 return -EMSGSIZE;
885}
886
887static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
888{
889 struct nfc_dev *dev;
890 struct nfc_llcp_local *local;
891 int rc = 0;
892 struct sk_buff *msg = NULL;
893 u32 idx;
894
895 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
896 return -EINVAL;
897
898 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
899
900 dev = nfc_get_device(idx);
901 if (!dev)
902 return -ENODEV;
903
904 device_lock(&dev->dev);
905
906 local = nfc_llcp_find_local(dev);
907 if (!local) {
908 rc = -ENODEV;
909 goto exit;
910 }
911
912 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
913 if (!msg) {
914 rc = -ENOMEM;
915 goto exit;
916 }
917
918 rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
919
920exit:
921 device_unlock(&dev->dev);
922
923 nfc_put_device(dev);
924
925 if (rc < 0) {
926 if (msg)
927 nlmsg_free(msg);
928
929 return rc;
930 }
931
932 return genlmsg_reply(msg, info);
933}
934
935static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
936{
937 struct nfc_dev *dev;
938 struct nfc_llcp_local *local;
939 u8 rw = 0;
940 u16 miux = 0;
941 u32 idx;
942 int rc = 0;
943
944 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
945 (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
946 !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
947 !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
948 return -EINVAL;
949
950 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
951 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
952
953 if (rw > LLCP_MAX_RW)
954 return -EINVAL;
955 }
956
957 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
958 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
959
960 if (miux > LLCP_MAX_MIUX)
961 return -EINVAL;
962 }
963
964 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
965
966 dev = nfc_get_device(idx);
967 if (!dev)
968 return -ENODEV;
969
970 device_lock(&dev->dev);
971
972 local = nfc_llcp_find_local(dev);
973 if (!local) {
974 nfc_put_device(dev);
975 rc = -ENODEV;
976 goto exit;
977 }
978
979 if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
980 if (dev->dep_link_up) {
981 rc = -EINPROGRESS;
982 goto exit;
983 }
984
985 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
986 }
987
988 if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
989 local->rw = rw;
990
991 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
992 local->miux = cpu_to_be16(miux);
993
994exit:
995 device_unlock(&dev->dev);
996
997 nfc_put_device(dev);
998
999 return rc;
1000}
1001
d9b8d8e1
TE		 1002static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1003{
1004 struct nfc_dev *dev;
1005 struct nfc_llcp_local *local;
1006 struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1007 u32 idx;
1008 u8 tid;
1009 char *uri;
1010 int rc = 0, rem;
1011 size_t uri_len, tlvs_len;
1012 struct hlist_head sdreq_list;
1013 struct nfc_llcp_sdp_tlv *sdreq;
1014
1015 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1016 !info->attrs[NFC_ATTR_LLC_SDP])
1017 return -EINVAL;
1018
1019 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1020
1021 dev = nfc_get_device(idx);
1022 if (!dev) {
1023 rc = -ENODEV;
1024 goto exit;
1025 }
1026
1027 device_lock(&dev->dev);
1028
1029 if (dev->dep_link_up == false) {
1030 rc = -ENOLINK;
1031 goto exit;
1032 }
1033
1034 local = nfc_llcp_find_local(dev);
1035 if (!local) {
1036 nfc_put_device(dev);
1037 rc = -ENODEV;
1038 goto exit;
1039 }
1040
1041 INIT_HLIST_HEAD(&sdreq_list);
1042
1043 tlvs_len = 0;
1044
1045 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1046 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
1047 nfc_sdp_genl_policy);
1048
1049 if (rc != 0) {
1050 rc = -EINVAL;
1051 goto exit;
1052 }
1053
1054 if (!sdp_attrs[NFC_SDP_ATTR_URI])
1055 continue;
1056
1057 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1058 if (uri_len == 0)
1059 continue;
1060
1061 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1062 if (uri == NULL || *uri == 0)
1063 continue;
1064
1065 tid = local->sdreq_next_tid++;
1066
1067 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1068 if (sdreq == NULL) {
1069 rc = -ENOMEM;
1070 goto exit;
1071 }
1072
1073 tlvs_len += sdreq->tlv_len;
1074
1075 hlist_add_head(&sdreq->node, &sdreq_list);
1076 }
1077
1078 if (hlist_empty(&sdreq_list)) {
1079 rc = -EINVAL;
1080 goto exit;
1081 }
1082
1083 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1084exit:
1085 device_unlock(&dev->dev);
1086
1087 nfc_put_device(dev);
1088
1089 return rc;
1090}
1091
9ea7187c 1092static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
9674da87
EL		 1093{
1094 struct nfc_dev *dev;
1095 int rc;
1096 u32 idx;
1097 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1098
1099 if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
1100 return -EINVAL;
1101
1102 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1103
1104 dev = nfc_get_device(idx);
1105 if (!dev)
1106 return -ENODEV;
1107
1108 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1109 sizeof(firmware_name));
1110
9ea7187c 1111 rc = nfc_fw_download(dev, firmware_name);
9674da87
EL		 1112
1113 nfc_put_device(dev);
1114 return rc;
1115}
1116
352a5f5f
EL		 1117int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1118 u32 result)
9674da87
EL		 1119{
1120 struct sk_buff *msg;
1121 void *hdr;
1122
1123 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1124 if (!msg)
1125 return -ENOMEM;
1126
1127 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
9ea7187c 1128 NFC_CMD_FW_DOWNLOAD);
9674da87
EL		 1129 if (!hdr)
1130 goto free_msg;
1131
1132 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
352a5f5f 1133 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
9674da87
EL		 1134 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1135 goto nla_put_failure;
1136
1137 genlmsg_end(msg, hdr);
1138
1139 genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
1140
1141 return 0;
1142
1143nla_put_failure:
1144 genlmsg_cancel(msg, hdr);
1145free_msg:
1146 nlmsg_free(msg);
1147 return -EMSGSIZE;
1148}
1149
be085653
SO		 1150static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1151{
1152 struct nfc_dev *dev;
1153 int rc;
1154 u32 idx, se_idx;
1155
1156 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1157 !info->attrs[NFC_ATTR_SE_INDEX])
1158 return -EINVAL;
1159
1160 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1161 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1162
1163 dev = nfc_get_device(idx);
1164 if (!dev)
1165 return -ENODEV;
1166
1167 rc = nfc_enable_se(dev, se_idx);
1168
1169 nfc_put_device(dev);
1170 return rc;
1171}
1172
1173static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1174{
1175 struct nfc_dev *dev;
1176 int rc;
1177 u32 idx, se_idx;
1178
1179 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1180 !info->attrs[NFC_ATTR_SE_INDEX])
1181 return -EINVAL;
1182
1183 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1184 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1185
1186 dev = nfc_get_device(idx);
1187 if (!dev)
1188 return -ENODEV;
1189
1190 rc = nfc_disable_se(dev, se_idx);
1191
1192 nfc_put_device(dev);
1193 return rc;
1194}
1195
ac22ac46
SO		 1196static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1197 u32 portid, u32 seq,
1198 struct netlink_callback *cb,
1199 int flags)
1200{
1201 void *hdr;
1202 struct nfc_se *se, *n;
1203
1204 list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1205 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1206 NFC_CMD_GET_SE);
1207 if (!hdr)
1208 goto nla_put_failure;
1209
1210 if (cb)
1211 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
1212
1213 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1214 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1215 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1216 goto nla_put_failure;
1217
1218 if (genlmsg_end(msg, hdr) < 0)
1219 goto nla_put_failure;
1220 }
1221
1222 return 0;
1223
1224nla_put_failure:
1225 genlmsg_cancel(msg, hdr);
1226 return -EMSGSIZE;
1227}
1228
1229static int nfc_genl_dump_ses(struct sk_buff *skb,
1230 struct netlink_callback *cb)
1231{
1232 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1233 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1234 bool first_call = false;
1235
1236 if (!iter) {
1237 first_call = true;
1238 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1239 if (!iter)
1240 return -ENOMEM;
1241 cb->args[0] = (long) iter;
1242 }
1243
1244 mutex_lock(&nfc_devlist_mutex);
1245
1246 cb->seq = nfc_devlist_generation;
1247
1248 if (first_call) {
1249 nfc_device_iter_init(iter);
1250 dev = nfc_device_iter_next(iter);
1251 }
1252
1253 while (dev) {
1254 int rc;
1255
1256 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1257 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1258 if (rc < 0)
1259 break;
1260
1261 dev = nfc_device_iter_next(iter);
1262 }
1263
1264 mutex_unlock(&nfc_devlist_mutex);
1265
1266 cb->args[1] = (long) dev;
1267
1268 return skb->len;
1269}
1270
1271static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1272{
1273 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1274
1275 nfc_device_iter_exit(iter);
1276 kfree(iter);
1277
1278 return 0;
1279}
1280
4d12b8b1
LRV		 1281static struct genl_ops nfc_genl_ops[] = {
1282 {
1283 .cmd = NFC_CMD_GET_DEVICE,
1284 .doit = nfc_genl_get_device,
1285 .dumpit = nfc_genl_dump_devices,
1286 .done = nfc_genl_dump_devices_done,
1287 .policy = nfc_genl_policy,
8b3fe7b5
IE		 1288 },
1289 {
1290 .cmd = NFC_CMD_DEV_UP,
1291 .doit = nfc_genl_dev_up,
1292 .policy = nfc_genl_policy,
1293 },
1294 {
1295 .cmd = NFC_CMD_DEV_DOWN,
1296 .doit = nfc_genl_dev_down,
1297 .policy = nfc_genl_policy,
4d12b8b1
LRV		 1298 },
1299 {
1300 .cmd = NFC_CMD_START_POLL,
1301 .doit = nfc_genl_start_poll,
1302 .policy = nfc_genl_policy,
1303 },
1304 {
1305 .cmd = NFC_CMD_STOP_POLL,
1306 .doit = nfc_genl_stop_poll,
1307 .policy = nfc_genl_policy,
1308 },
1ed28f61
SO		 1309 {
1310 .cmd = NFC_CMD_DEP_LINK_UP,
1311 .doit = nfc_genl_dep_link_up,
1312 .policy = nfc_genl_policy,
1313 },
1314 {
1315 .cmd = NFC_CMD_DEP_LINK_DOWN,
1316 .doit = nfc_genl_dep_link_down,
1317 .policy = nfc_genl_policy,
1318 },
4d12b8b1
LRV		 1319 {
1320 .cmd = NFC_CMD_GET_TARGET,
1321 .dumpit = nfc_genl_dump_targets,
1322 .done = nfc_genl_dump_targets_done,
1323 .policy = nfc_genl_policy,
1324 },
52feb444
TE		 1325 {
1326 .cmd = NFC_CMD_LLC_GET_PARAMS,
1327 .doit = nfc_genl_llc_get_params,
1328 .policy = nfc_genl_policy,
1329 },
1330 {
1331 .cmd = NFC_CMD_LLC_SET_PARAMS,
1332 .doit = nfc_genl_llc_set_params,
1333 .policy = nfc_genl_policy,
1334 },
d9b8d8e1
TE		 1335 {
1336 .cmd = NFC_CMD_LLC_SDREQ,
1337 .doit = nfc_genl_llc_sdreq,
1338 .policy = nfc_genl_policy,
1339 },
9674da87 1340 {
9ea7187c
SO		 1341 .cmd = NFC_CMD_FW_DOWNLOAD,
1342 .doit = nfc_genl_fw_download,
9674da87
EL		 1343 .policy = nfc_genl_policy,
1344 },
be085653
SO		 1345 {
1346 .cmd = NFC_CMD_ENABLE_SE,
1347 .doit = nfc_genl_enable_se,
1348 .policy = nfc_genl_policy,
1349 },
1350 {
1351 .cmd = NFC_CMD_DISABLE_SE,
1352 .doit = nfc_genl_disable_se,
1353 .policy = nfc_genl_policy,
1354 },
ac22ac46
SO		 1355 {
1356 .cmd = NFC_CMD_GET_SE,
1357 .dumpit = nfc_genl_dump_ses,
1358 .done = nfc_genl_dump_ses_done,
1359 .policy = nfc_genl_policy,
1360 },
4d12b8b1
LRV		 1361};
1362
3c0cc8aa
SJ		 1363
1364struct urelease_work {
1365 struct work_struct w;
c487606f 1366 int portid;
3c0cc8aa
SJ		 1367};
1368
1369static void nfc_urelease_event_work(struct work_struct *work)
4d12b8b1 1370{
3c0cc8aa 1371 struct urelease_work *w = container_of(work, struct urelease_work, w);
4d12b8b1
LRV		 1372 struct class_dev_iter iter;
1373 struct nfc_dev *dev;
1374
c487606f 1375 pr_debug("portid %d\n", w->portid);
4d12b8b1 1376
3c0cc8aa 1377 mutex_lock(&nfc_devlist_mutex);
4d12b8b1
LRV		 1378
1379 nfc_device_iter_init(&iter);
1380 dev = nfc_device_iter_next(&iter);
1381
1382 while (dev) {
3c0cc8aa
SJ		 1383 mutex_lock(&dev->genl_data.genl_data_mutex);
1384
c487606f 1385 if (dev->genl_data.poll_req_portid == w->portid) {
4d12b8b1 1386 nfc_stop_poll(dev);
15e47304 1387 dev->genl_data.poll_req_portid = 0;
4d12b8b1 1388 }
3c0cc8aa
SJ		 1389
1390 mutex_unlock(&dev->genl_data.genl_data_mutex);
1391
4d12b8b1
LRV		 1392 dev = nfc_device_iter_next(&iter);
1393 }
1394
1395 nfc_device_iter_exit(&iter);
1396
3c0cc8aa
SJ		 1397 mutex_unlock(&nfc_devlist_mutex);
1398
1399 kfree(w);
1400}
1401
1402static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1403 unsigned long event, void *ptr)
1404{
1405 struct netlink_notify *n = ptr;
1406 struct urelease_work *w;
1407
1408 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1409 goto out;
1410
c487606f 1411 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
3c0cc8aa
SJ		 1412
1413 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1414 if (w) {
1415 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
c487606f 1416 w->portid = n->portid;
3c0cc8aa
SJ		 1417 schedule_work((struct work_struct *) w);
1418 }
1419
4d12b8b1
LRV		 1420out:
1421 return NOTIFY_DONE;
1422}
1423
1424void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1425{
15e47304 1426 genl_data->poll_req_portid = 0;
4d12b8b1
LRV		 1427 mutex_init(&genl_data->genl_data_mutex);
1428}
1429
1430void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1431{
1432 mutex_destroy(&genl_data->genl_data_mutex);
1433}
1434
1435static struct notifier_block nl_notifier = {
1436 .notifier_call = nfc_genl_rcv_nl_event,
1437};
1438
1439/**
1440 * nfc_genl_init() - Initialize netlink interface
1441 *
1442 * This initialization function registers the nfc netlink family.
1443 */
1444int __init nfc_genl_init(void)
1445{
1446 int rc;
1447
1448 rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
0a40acb2 1449 ARRAY_SIZE(nfc_genl_ops));
4d12b8b1
LRV		 1450 if (rc)
1451 return rc;
1452
1453 rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);
1454
1455 netlink_register_notifier(&nl_notifier);
1456
1457 return rc;
1458}
1459
1460/**
1461 * nfc_genl_exit() - Deinitialize netlink interface
1462 *
1463 * This exit function unregisters the nfc netlink family.
1464 */
1465void nfc_genl_exit(void)
1466{
1467 netlink_unregister_notifier(&nl_notifier);
1468 genl_unregister_family(&nfc_genl_family);
1469}
Linux kernel - Deliverables
This page took 0.199218 seconds and 5 git commands to generate.