xref: /openbmc/linux/net/nfc/netlink.c (revision 95e9fd10) 
1 /*
2  * Copyright (C) 2011 Instituto Nokia de Tecnologia
3  *
4  * Authors:
5  *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
6  *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the
20  * Free Software Foundation, Inc.,
21  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22  */
23 
24 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
25 
26 #include <net/genetlink.h>
27 #include <linux/nfc.h>
28 #include <linux/slab.h>
29 
30 #include "nfc.h"
31 
32 static struct genl_multicast_group nfc_genl_event_mcgrp = {
33 	.name = NFC_GENL_MCAST_EVENT_NAME,
34 };
35 
36 static struct genl_family nfc_genl_family = {
37 	.id = GENL_ID_GENERATE,
38 	.hdrsize = 0,
39 	.name = NFC_GENL_NAME,
40 	.version = NFC_GENL_VERSION,
41 	.maxattr = NFC_ATTR_MAX,
42 };
43 
44 static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
45 	[NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
46 	[NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
47 				.len = NFC_DEVICE_NAME_MAXSIZE },
48 	[NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
49 	[NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
50 	[NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
51 	[NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
52 	[NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
53 	[NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
54 };
55 
56 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
57 				struct netlink_callback *cb, int flags)
58 {
59 	void *hdr;
60 
61 	hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
62 			  &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
63 	if (!hdr)
64 		return -EMSGSIZE;
65 
66 	genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
67 
68 	if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
69 	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
70 	    nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
71 	    nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
72 		goto nla_put_failure;
73 	if (target->nfcid1_len > 0 &&
74 	    nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
75 		    target->nfcid1))
76 		goto nla_put_failure;
77 	if (target->sensb_res_len > 0 &&
78 	    nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
79 		    target->sensb_res))
80 		goto nla_put_failure;
81 	if (target->sensf_res_len > 0 &&
82 	    nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
83 		    target->sensf_res))
84 		goto nla_put_failure;
85 
86 	return genlmsg_end(msg, hdr);
87 
88 nla_put_failure:
89 	genlmsg_cancel(msg, hdr);
90 	return -EMSGSIZE;
91 }
92 
93 static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
94 {
95 	struct nfc_dev *dev;
96 	int rc;
97 	u32 idx;
98 
99 	rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
100 			 nfc_genl_family.attrbuf,
101 			 nfc_genl_family.maxattr,
102 			 nfc_genl_policy);
103 	if (rc < 0)
104 		return ERR_PTR(rc);
105 
106 	if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
107 		return ERR_PTR(-EINVAL);
108 
109 	idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
110 
111 	dev = nfc_get_device(idx);
112 	if (!dev)
113 		return ERR_PTR(-ENODEV);
114 
115 	return dev;
116 }
117 
118 static int nfc_genl_dump_targets(struct sk_buff *skb,
119 				 struct netlink_callback *cb)
120 {
121 	int i = cb->args[0];
122 	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
123 	int rc;
124 
125 	if (!dev) {
126 		dev = __get_device_from_cb(cb);
127 		if (IS_ERR(dev))
128 			return PTR_ERR(dev);
129 
130 		cb->args[1] = (long) dev;
131 	}
132 
133 	device_lock(&dev->dev);
134 
135 	cb->seq = dev->targets_generation;
136 
137 	while (i < dev->n_targets) {
138 		rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
139 					  NLM_F_MULTI);
140 		if (rc < 0)
141 			break;
142 
143 		i++;
144 	}
145 
146 	device_unlock(&dev->dev);
147 
148 	cb->args[0] = i;
149 
150 	return skb->len;
151 }
152 
153 static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
154 {
155 	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
156 
157 	if (dev)
158 		nfc_put_device(dev);
159 
160 	return 0;
161 }
162 
163 int nfc_genl_targets_found(struct nfc_dev *dev)
164 {
165 	struct sk_buff *msg;
166 	void *hdr;
167 
168 	dev->genl_data.poll_req_pid = 0;
169 
170 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
171 	if (!msg)
172 		return -ENOMEM;
173 
174 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
175 			  NFC_EVENT_TARGETS_FOUND);
176 	if (!hdr)
177 		goto free_msg;
178 
179 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
180 		goto nla_put_failure;
181 
182 	genlmsg_end(msg, hdr);
183 
184 	return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
185 
186 nla_put_failure:
187 	genlmsg_cancel(msg, hdr);
188 free_msg:
189 	nlmsg_free(msg);
190 	return -EMSGSIZE;
191 }
192 
193 int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
194 {
195 	struct sk_buff *msg;
196 	void *hdr;
197 
198 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
199 	if (!msg)
200 		return -ENOMEM;
201 
202 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
203 			  NFC_EVENT_TARGET_LOST);
204 	if (!hdr)
205 		goto free_msg;
206 
207 	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
208 	    nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
209 		goto nla_put_failure;
210 
211 	genlmsg_end(msg, hdr);
212 
213 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
214 
215 	return 0;
216 
217 nla_put_failure:
218 	genlmsg_cancel(msg, hdr);
219 free_msg:
220 	nlmsg_free(msg);
221 	return -EMSGSIZE;
222 }
223 
224 int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
225 {
226 	struct sk_buff *msg;
227 	void *hdr;
228 
229 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
230 	if (!msg)
231 		return -ENOMEM;
232 
233 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
234 			  NFC_EVENT_TM_ACTIVATED);
235 	if (!hdr)
236 		goto free_msg;
237 
238 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
239 		goto nla_put_failure;
240 	if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
241 		goto nla_put_failure;
242 
243 	genlmsg_end(msg, hdr);
244 
245 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
246 
247 	return 0;
248 
249 nla_put_failure:
250 	genlmsg_cancel(msg, hdr);
251 free_msg:
252 	nlmsg_free(msg);
253 	return -EMSGSIZE;
254 }
255 
256 int nfc_genl_tm_deactivated(struct nfc_dev *dev)
257 {
258 	struct sk_buff *msg;
259 	void *hdr;
260 
261 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
262 	if (!msg)
263 		return -ENOMEM;
264 
265 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
266 			  NFC_EVENT_TM_DEACTIVATED);
267 	if (!hdr)
268 		goto free_msg;
269 
270 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
271 		goto nla_put_failure;
272 
273 	genlmsg_end(msg, hdr);
274 
275 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
276 
277 	return 0;
278 
279 nla_put_failure:
280 	genlmsg_cancel(msg, hdr);
281 free_msg:
282 	nlmsg_free(msg);
283 	return -EMSGSIZE;
284 }
285 
286 int nfc_genl_device_added(struct nfc_dev *dev)
287 {
288 	struct sk_buff *msg;
289 	void *hdr;
290 
291 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
292 	if (!msg)
293 		return -ENOMEM;
294 
295 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
296 			  NFC_EVENT_DEVICE_ADDED);
297 	if (!hdr)
298 		goto free_msg;
299 
300 	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
301 	    nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
302 	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
303 	    nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
304 		goto nla_put_failure;
305 
306 	genlmsg_end(msg, hdr);
307 
308 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
309 
310 	return 0;
311 
312 nla_put_failure:
313 	genlmsg_cancel(msg, hdr);
314 free_msg:
315 	nlmsg_free(msg);
316 	return -EMSGSIZE;
317 }
318 
319 int nfc_genl_device_removed(struct nfc_dev *dev)
320 {
321 	struct sk_buff *msg;
322 	void *hdr;
323 
324 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
325 	if (!msg)
326 		return -ENOMEM;
327 
328 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
329 			  NFC_EVENT_DEVICE_REMOVED);
330 	if (!hdr)
331 		goto free_msg;
332 
333 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
334 		goto nla_put_failure;
335 
336 	genlmsg_end(msg, hdr);
337 
338 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
339 
340 	return 0;
341 
342 nla_put_failure:
343 	genlmsg_cancel(msg, hdr);
344 free_msg:
345 	nlmsg_free(msg);
346 	return -EMSGSIZE;
347 }
348 
349 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
350 				u32 pid, u32 seq,
351 				struct netlink_callback *cb,
352 				int flags)
353 {
354 	void *hdr;
355 
356 	hdr = genlmsg_put(msg, pid, seq, &nfc_genl_family, flags,
357 			  NFC_CMD_GET_DEVICE);
358 	if (!hdr)
359 		return -EMSGSIZE;
360 
361 	if (cb)
362 		genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
363 
364 	if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
365 	    nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
366 	    nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
367 	    nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
368 		goto nla_put_failure;
369 
370 	return genlmsg_end(msg, hdr);
371 
372 nla_put_failure:
373 	genlmsg_cancel(msg, hdr);
374 	return -EMSGSIZE;
375 }
376 
377 static int nfc_genl_dump_devices(struct sk_buff *skb,
378 				 struct netlink_callback *cb)
379 {
380 	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
381 	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
382 	bool first_call = false;
383 
384 	if (!iter) {
385 		first_call = true;
386 		iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
387 		if (!iter)
388 			return -ENOMEM;
389 		cb->args[0] = (long) iter;
390 	}
391 
392 	mutex_lock(&nfc_devlist_mutex);
393 
394 	cb->seq = nfc_devlist_generation;
395 
396 	if (first_call) {
397 		nfc_device_iter_init(iter);
398 		dev = nfc_device_iter_next(iter);
399 	}
400 
401 	while (dev) {
402 		int rc;
403 
404 		rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).pid,
405 					  cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
406 		if (rc < 0)
407 			break;
408 
409 		dev = nfc_device_iter_next(iter);
410 	}
411 
412 	mutex_unlock(&nfc_devlist_mutex);
413 
414 	cb->args[1] = (long) dev;
415 
416 	return skb->len;
417 }
418 
419 static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
420 {
421 	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
422 
423 	nfc_device_iter_exit(iter);
424 	kfree(iter);
425 
426 	return 0;
427 }
428 
429 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
430 			       u8 comm_mode, u8 rf_mode)
431 {
432 	struct sk_buff *msg;
433 	void *hdr;
434 
435 	pr_debug("DEP link is up\n");
436 
437 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
438 	if (!msg)
439 		return -ENOMEM;
440 
441 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
442 	if (!hdr)
443 		goto free_msg;
444 
445 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
446 		goto nla_put_failure;
447 	if (rf_mode == NFC_RF_INITIATOR &&
448 	    nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
449 		goto nla_put_failure;
450 	if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
451 	    nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
452 		goto nla_put_failure;
453 
454 	genlmsg_end(msg, hdr);
455 
456 	dev->dep_link_up = true;
457 
458 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
459 
460 	return 0;
461 
462 nla_put_failure:
463 	genlmsg_cancel(msg, hdr);
464 free_msg:
465 	nlmsg_free(msg);
466 	return -EMSGSIZE;
467 }
468 
469 int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
470 {
471 	struct sk_buff *msg;
472 	void *hdr;
473 
474 	pr_debug("DEP link is down\n");
475 
476 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
477 	if (!msg)
478 		return -ENOMEM;
479 
480 	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
481 			  NFC_CMD_DEP_LINK_DOWN);
482 	if (!hdr)
483 		goto free_msg;
484 
485 	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
486 		goto nla_put_failure;
487 
488 	genlmsg_end(msg, hdr);
489 
490 	genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
491 
492 	return 0;
493 
494 nla_put_failure:
495 	genlmsg_cancel(msg, hdr);
496 free_msg:
497 	nlmsg_free(msg);
498 	return -EMSGSIZE;
499 }
500 
501 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
502 {
503 	struct sk_buff *msg;
504 	struct nfc_dev *dev;
505 	u32 idx;
506 	int rc = -ENOBUFS;
507 
508 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
509 		return -EINVAL;
510 
511 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
512 
513 	dev = nfc_get_device(idx);
514 	if (!dev)
515 		return -ENODEV;
516 
517 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
518 	if (!msg) {
519 		rc = -ENOMEM;
520 		goto out_putdev;
521 	}
522 
523 	rc = nfc_genl_send_device(msg, dev, info->snd_pid, info->snd_seq,
524 				  NULL, 0);
525 	if (rc < 0)
526 		goto out_free;
527 
528 	nfc_put_device(dev);
529 
530 	return genlmsg_reply(msg, info);
531 
532 out_free:
533 	nlmsg_free(msg);
534 out_putdev:
535 	nfc_put_device(dev);
536 	return rc;
537 }
538 
539 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
540 {
541 	struct nfc_dev *dev;
542 	int rc;
543 	u32 idx;
544 
545 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
546 		return -EINVAL;
547 
548 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
549 
550 	dev = nfc_get_device(idx);
551 	if (!dev)
552 		return -ENODEV;
553 
554 	rc = nfc_dev_up(dev);
555 
556 	nfc_put_device(dev);
557 	return rc;
558 }
559 
560 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
561 {
562 	struct nfc_dev *dev;
563 	int rc;
564 	u32 idx;
565 
566 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
567 		return -EINVAL;
568 
569 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
570 
571 	dev = nfc_get_device(idx);
572 	if (!dev)
573 		return -ENODEV;
574 
575 	rc = nfc_dev_down(dev);
576 
577 	nfc_put_device(dev);
578 	return rc;
579 }
580 
581 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
582 {
583 	struct nfc_dev *dev;
584 	int rc;
585 	u32 idx;
586 	u32 im_protocols = 0, tm_protocols = 0;
587 
588 	pr_debug("Poll start\n");
589 
590 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
591 	    ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
592 	      !info->attrs[NFC_ATTR_PROTOCOLS]) &&
593 	     !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
594 		return -EINVAL;
595 
596 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
597 
598 	if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
599 		tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
600 
601 	if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
602 		im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
603 	else if (info->attrs[NFC_ATTR_PROTOCOLS])
604 		im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
605 
606 	dev = nfc_get_device(idx);
607 	if (!dev)
608 		return -ENODEV;
609 
610 	mutex_lock(&dev->genl_data.genl_data_mutex);
611 
612 	rc = nfc_start_poll(dev, im_protocols, tm_protocols);
613 	if (!rc)
614 		dev->genl_data.poll_req_pid = info->snd_pid;
615 
616 	mutex_unlock(&dev->genl_data.genl_data_mutex);
617 
618 	nfc_put_device(dev);
619 	return rc;
620 }
621 
622 static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
623 {
624 	struct nfc_dev *dev;
625 	int rc;
626 	u32 idx;
627 
628 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
629 		return -EINVAL;
630 
631 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
632 
633 	dev = nfc_get_device(idx);
634 	if (!dev)
635 		return -ENODEV;
636 
637 	device_lock(&dev->dev);
638 
639 	if (!dev->polling) {
640 		device_unlock(&dev->dev);
641 		return -EINVAL;
642 	}
643 
644 	device_unlock(&dev->dev);
645 
646 	mutex_lock(&dev->genl_data.genl_data_mutex);
647 
648 	if (dev->genl_data.poll_req_pid != info->snd_pid) {
649 		rc = -EBUSY;
650 		goto out;
651 	}
652 
653 	rc = nfc_stop_poll(dev);
654 	dev->genl_data.poll_req_pid = 0;
655 
656 out:
657 	mutex_unlock(&dev->genl_data.genl_data_mutex);
658 	nfc_put_device(dev);
659 	return rc;
660 }
661 
662 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
663 {
664 	struct nfc_dev *dev;
665 	int rc, tgt_idx;
666 	u32 idx;
667 	u8 comm;
668 
669 	pr_debug("DEP link up\n");
670 
671 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
672 	    !info->attrs[NFC_ATTR_COMM_MODE])
673 		return -EINVAL;
674 
675 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
676 	if (!info->attrs[NFC_ATTR_TARGET_INDEX])
677 		tgt_idx = NFC_TARGET_IDX_ANY;
678 	else
679 		tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
680 
681 	comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
682 
683 	if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
684 		return -EINVAL;
685 
686 	dev = nfc_get_device(idx);
687 	if (!dev)
688 		return -ENODEV;
689 
690 	rc = nfc_dep_link_up(dev, tgt_idx, comm);
691 
692 	nfc_put_device(dev);
693 
694 	return rc;
695 }
696 
697 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
698 {
699 	struct nfc_dev *dev;
700 	int rc;
701 	u32 idx;
702 
703 	if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
704 		return -EINVAL;
705 
706 	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
707 
708 	dev = nfc_get_device(idx);
709 	if (!dev)
710 		return -ENODEV;
711 
712 	rc = nfc_dep_link_down(dev);
713 
714 	nfc_put_device(dev);
715 	return rc;
716 }
717 
718 static struct genl_ops nfc_genl_ops[] = {
719 	{
720 		.cmd = NFC_CMD_GET_DEVICE,
721 		.doit = nfc_genl_get_device,
722 		.dumpit = nfc_genl_dump_devices,
723 		.done = nfc_genl_dump_devices_done,
724 		.policy = nfc_genl_policy,
725 	},
726 	{
727 		.cmd = NFC_CMD_DEV_UP,
728 		.doit = nfc_genl_dev_up,
729 		.policy = nfc_genl_policy,
730 	},
731 	{
732 		.cmd = NFC_CMD_DEV_DOWN,
733 		.doit = nfc_genl_dev_down,
734 		.policy = nfc_genl_policy,
735 	},
736 	{
737 		.cmd = NFC_CMD_START_POLL,
738 		.doit = nfc_genl_start_poll,
739 		.policy = nfc_genl_policy,
740 	},
741 	{
742 		.cmd = NFC_CMD_STOP_POLL,
743 		.doit = nfc_genl_stop_poll,
744 		.policy = nfc_genl_policy,
745 	},
746 	{
747 		.cmd = NFC_CMD_DEP_LINK_UP,
748 		.doit = nfc_genl_dep_link_up,
749 		.policy = nfc_genl_policy,
750 	},
751 	{
752 		.cmd = NFC_CMD_DEP_LINK_DOWN,
753 		.doit = nfc_genl_dep_link_down,
754 		.policy = nfc_genl_policy,
755 	},
756 	{
757 		.cmd = NFC_CMD_GET_TARGET,
758 		.dumpit = nfc_genl_dump_targets,
759 		.done = nfc_genl_dump_targets_done,
760 		.policy = nfc_genl_policy,
761 	},
762 };
763 
764 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
765 				 unsigned long event, void *ptr)
766 {
767 	struct netlink_notify *n = ptr;
768 	struct class_dev_iter iter;
769 	struct nfc_dev *dev;
770 
771 	if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
772 		goto out;
773 
774 	pr_debug("NETLINK_URELEASE event from id %d\n", n->pid);
775 
776 	nfc_device_iter_init(&iter);
777 	dev = nfc_device_iter_next(&iter);
778 
779 	while (dev) {
780 		if (dev->genl_data.poll_req_pid == n->pid) {
781 			nfc_stop_poll(dev);
782 			dev->genl_data.poll_req_pid = 0;
783 		}
784 		dev = nfc_device_iter_next(&iter);
785 	}
786 
787 	nfc_device_iter_exit(&iter);
788 
789 out:
790 	return NOTIFY_DONE;
791 }
792 
793 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
794 {
795 	genl_data->poll_req_pid = 0;
796 	mutex_init(&genl_data->genl_data_mutex);
797 }
798 
799 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
800 {
801 	mutex_destroy(&genl_data->genl_data_mutex);
802 }
803 
804 static struct notifier_block nl_notifier = {
805 	.notifier_call  = nfc_genl_rcv_nl_event,
806 };
807 
808 /**
809  * nfc_genl_init() - Initialize netlink interface
810  *
811  * This initialization function registers the nfc netlink family.
812  */
813 int __init nfc_genl_init(void)
814 {
815 	int rc;
816 
817 	rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
818 					   ARRAY_SIZE(nfc_genl_ops));
819 	if (rc)
820 		return rc;
821 
822 	rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);
823 
824 	netlink_register_notifier(&nl_notifier);
825 
826 	return rc;
827 }
828 
829 /**
830  * nfc_genl_exit() - Deinitialize netlink interface
831  *
832  * This exit function unregisters the nfc netlink family.
833  */
834 void nfc_genl_exit(void)
835 {
836 	netlink_unregister_notifier(&nl_notifier);
837 	genl_unregister_family(&nfc_genl_family);
838 }
839