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