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