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