Linux Audio

Check our new training course

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