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