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
  25static const struct genl_multicast_group nfc_genl_mcgrps[] = {
  26	{ .name = NFC_GENL_MCAST_EVENT_NAME, },
  27};
  28
  29static struct genl_family nfc_genl_family;
  30static 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
  55static 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
  61static 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
 102nla_put_failure:
 103	genlmsg_cancel(msg, hdr);
 104	return -EMSGSIZE;
 105}
 106
 107static 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->attrs[NFC_ATTR_DEVICE_INDEX])
 114		return ERR_PTR(-EINVAL);
 115
 116	idx = nla_get_u32(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
 125static 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
 160static 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
 170int 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
 193nla_put_failure:
 194free_msg:
 195	nlmsg_free(msg);
 196	return -EMSGSIZE;
 197}
 198
 199int 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
 223nla_put_failure:
 224free_msg:
 225	nlmsg_free(msg);
 226	return -EMSGSIZE;
 227}
 228
 229int 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
 254nla_put_failure:
 255free_msg:
 256	nlmsg_free(msg);
 257	return -EMSGSIZE;
 258}
 259
 260int 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
 283nla_put_failure:
 284free_msg:
 285	nlmsg_free(msg);
 286	return -EMSGSIZE;
 287}
 288
 289static 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
 300int 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
 323nla_put_failure:
 324free_msg:
 325	nlmsg_free(msg);
 326	return -EMSGSIZE;
 327}
 328
 329int 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
 352nla_put_failure:
 353free_msg:
 354	nlmsg_free(msg);
 355	return -EMSGSIZE;
 356}
 357
 358int 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
 415nla_put_failure:
 416free_msg:
 417	nlmsg_free(msg);
 418
 419	nfc_llcp_free_sdp_tlv_list(sdres_list);
 420
 421	return rc;
 422}
 423
 424int 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
 449nla_put_failure:
 450free_msg:
 451	nlmsg_free(msg);
 452	return -EMSGSIZE;
 453}
 454
 455int 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
 479nla_put_failure:
 480free_msg:
 481	nlmsg_free(msg);
 482	return -EMSGSIZE;
 483}
 484
 485int 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
 523nla_put_failure:
 524free_msg:
 525	/* evt_transaction is no more used */
 526	devm_kfree(&dev->dev, evt_transaction);
 527	nlmsg_free(msg);
 528	return -EMSGSIZE;
 529}
 530
 531int 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
 561nla_put_failure:
 562free_msg:
 563	nlmsg_free(msg);
 564	return -EMSGSIZE;
 565}
 566
 567static 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
 588nla_put_failure:
 589	genlmsg_cancel(msg, hdr);
 590	return -EMSGSIZE;
 591}
 592
 593static 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
 635static 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
 647int 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
 680nla_put_failure:
 681free_msg:
 682	nlmsg_free(msg);
 683	return -EMSGSIZE;
 684}
 685
 686int 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
 711nla_put_failure:
 712free_msg:
 713	nlmsg_free(msg);
 714	return -EMSGSIZE;
 715}
 716
 717static 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
 748out_free:
 749	nlmsg_free(msg);
 750out_putdev:
 751	nfc_put_device(dev);
 752	return rc;
 753}
 754
 755static 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
 776static 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
 797static 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
 838static 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
 873out:
 874	mutex_unlock(&dev->genl_data.genl_data_mutex);
 875	nfc_put_device(dev);
 876	return rc;
 877}
 878
 879static 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
 906static 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
 931static 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
 966static 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
 988static 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
1008nla_put_failure:
1009	genlmsg_cancel(msg, hdr);
1010	return -EMSGSIZE;
1011}
1012
1013static 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 exit;
1043	}
1044
1045	rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
1046
1047exit:
1048	device_unlock(&dev->dev);
1049
1050	nfc_put_device(dev);
1051
1052	if (rc < 0) {
1053		if (msg)
1054			nlmsg_free(msg);
1055
1056		return rc;
1057	}
1058
1059	return genlmsg_reply(msg, info);
1060}
1061
1062static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
1063{
1064	struct nfc_dev *dev;
1065	struct nfc_llcp_local *local;
1066	u8 rw = 0;
1067	u16 miux = 0;
1068	u32 idx;
1069	int rc = 0;
1070
1071	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1072	    (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
1073	     !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
1074	     !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
1075		return -EINVAL;
1076
1077	if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
1078		rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
1079
1080		if (rw > LLCP_MAX_RW)
1081			return -EINVAL;
1082	}
1083
1084	if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
1085		miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
1086
1087		if (miux > LLCP_MAX_MIUX)
1088			return -EINVAL;
1089	}
1090
1091	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1092
1093	dev = nfc_get_device(idx);
1094	if (!dev)
1095		return -ENODEV;
1096
1097	device_lock(&dev->dev);
1098
1099	local = nfc_llcp_find_local(dev);
1100	if (!local) {
1101		rc = -ENODEV;
1102		goto exit;
1103	}
1104
1105	if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
1106		if (dev->dep_link_up) {
1107			rc = -EINPROGRESS;
1108			goto exit;
1109		}
1110
1111		local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
1112	}
1113
1114	if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
1115		local->rw = rw;
1116
1117	if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
1118		local->miux = cpu_to_be16(miux);
1119
1120exit:
1121	device_unlock(&dev->dev);
1122
1123	nfc_put_device(dev);
1124
1125	return rc;
1126}
1127
1128static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1129{
1130	struct nfc_dev *dev;
1131	struct nfc_llcp_local *local;
1132	struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1133	u32 idx;
1134	u8 tid;
1135	char *uri;
1136	int rc = 0, rem;
1137	size_t uri_len, tlvs_len;
1138	struct hlist_head sdreq_list;
1139	struct nfc_llcp_sdp_tlv *sdreq;
1140
1141	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1142	    !info->attrs[NFC_ATTR_LLC_SDP])
1143		return -EINVAL;
1144
1145	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1146
1147	dev = nfc_get_device(idx);
1148	if (!dev)
1149		return -ENODEV;
1150
1151	device_lock(&dev->dev);
1152
1153	if (dev->dep_link_up == false) {
1154		rc = -ENOLINK;
1155		goto exit;
1156	}
1157
1158	local = nfc_llcp_find_local(dev);
1159	if (!local) {
1160		rc = -ENODEV;
1161		goto exit;
1162	}
1163
1164	INIT_HLIST_HEAD(&sdreq_list);
1165
1166	tlvs_len = 0;
1167
1168	nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1169		rc = nla_parse_nested_deprecated(sdp_attrs, NFC_SDP_ATTR_MAX,
1170						 attr, nfc_sdp_genl_policy,
1171						 info->extack);
1172
1173		if (rc != 0) {
1174			rc = -EINVAL;
1175			goto exit;
1176		}
1177
1178		if (!sdp_attrs[NFC_SDP_ATTR_URI])
1179			continue;
1180
1181		uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1182		if (uri_len == 0)
1183			continue;
1184
1185		uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1186		if (uri == NULL || *uri == 0)
1187			continue;
1188
1189		tid = local->sdreq_next_tid++;
1190
1191		sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1192		if (sdreq == NULL) {
1193			rc = -ENOMEM;
1194			goto exit;
1195		}
1196
1197		tlvs_len += sdreq->tlv_len;
1198
1199		hlist_add_head(&sdreq->node, &sdreq_list);
1200	}
1201
1202	if (hlist_empty(&sdreq_list)) {
1203		rc = -EINVAL;
1204		goto exit;
1205	}
1206
1207	rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1208exit:
1209	device_unlock(&dev->dev);
1210
1211	nfc_put_device(dev);
1212
1213	return rc;
1214}
1215
1216static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
1217{
1218	struct nfc_dev *dev;
1219	int rc;
1220	u32 idx;
1221	char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1222
1223	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || !info->attrs[NFC_ATTR_FIRMWARE_NAME])
1224		return -EINVAL;
1225
1226	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1227
1228	dev = nfc_get_device(idx);
1229	if (!dev)
1230		return -ENODEV;
1231
1232	nla_strscpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1233		    sizeof(firmware_name));
1234
1235	rc = nfc_fw_download(dev, firmware_name);
1236
1237	nfc_put_device(dev);
1238	return rc;
1239}
1240
1241int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1242			      u32 result)
1243{
1244	struct sk_buff *msg;
1245	void *hdr;
1246
1247	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1248	if (!msg)
1249		return -ENOMEM;
1250
1251	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1252			  NFC_CMD_FW_DOWNLOAD);
1253	if (!hdr)
1254		goto free_msg;
1255
1256	if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
1257	    nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
1258	    nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1259		goto nla_put_failure;
1260
1261	genlmsg_end(msg, hdr);
1262
1263	genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
1264
1265	return 0;
1266
1267nla_put_failure:
1268free_msg:
1269	nlmsg_free(msg);
1270	return -EMSGSIZE;
1271}
1272
1273static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1274{
1275	struct nfc_dev *dev;
1276	int rc;
1277	u32 idx, se_idx;
1278
1279	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1280	    !info->attrs[NFC_ATTR_SE_INDEX])
1281		return -EINVAL;
1282
1283	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1284	se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1285
1286	dev = nfc_get_device(idx);
1287	if (!dev)
1288		return -ENODEV;
1289
1290	rc = nfc_enable_se(dev, se_idx);
1291
1292	nfc_put_device(dev);
1293	return rc;
1294}
1295
1296static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1297{
1298	struct nfc_dev *dev;
1299	int rc;
1300	u32 idx, se_idx;
1301
1302	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1303	    !info->attrs[NFC_ATTR_SE_INDEX])
1304		return -EINVAL;
1305
1306	idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1307	se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1308
1309	dev = nfc_get_device(idx);
1310	if (!dev)
1311		return -ENODEV;
1312
1313	rc = nfc_disable_se(dev, se_idx);
1314
1315	nfc_put_device(dev);
1316	return rc;
1317}
1318
1319static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1320				u32 portid, u32 seq,
1321				struct netlink_callback *cb,
1322				int flags)
1323{
1324	void *hdr;
1325	struct nfc_se *se, *n;
1326
1327	list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1328		hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1329				  NFC_CMD_GET_SE);
1330		if (!hdr)
1331			goto nla_put_failure;
1332
1333		if (cb)
1334			genl_dump_check_consistent(cb, hdr);
1335
1336		if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1337		    nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1338		    nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1339			goto nla_put_failure;
1340
1341		genlmsg_end(msg, hdr);
1342	}
1343
1344	return 0;
1345
1346nla_put_failure:
1347	genlmsg_cancel(msg, hdr);
1348	return -EMSGSIZE;
1349}
1350
1351static int nfc_genl_dump_ses(struct sk_buff *skb,
1352				 struct netlink_callback *cb)
1353{
1354	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1355	struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1356	bool first_call = false;
1357
1358	if (!iter) {
1359		first_call = true;
1360		iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1361		if (!iter)
1362			return -ENOMEM;
1363		cb->args[0] = (long) iter;
1364	}
1365
1366	mutex_lock(&nfc_devlist_mutex);
1367
1368	cb->seq = nfc_devlist_generation;
1369
1370	if (first_call) {
1371		nfc_device_iter_init(iter);
1372		dev = nfc_device_iter_next(iter);
1373	}
1374
1375	while (dev) {
1376		int rc;
1377
1378		rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1379					  cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1380		if (rc < 0)
1381			break;
1382
1383		dev = nfc_device_iter_next(iter);
1384	}
1385
1386	mutex_unlock(&nfc_devlist_mutex);
1387
1388	cb->args[1] = (long) dev;
1389
1390	return skb->len;
1391}
1392
1393static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1394{
1395	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1396
1397	if (iter) {
1398		nfc_device_iter_exit(iter);
1399		kfree(iter);
1400	}
1401
1402	return 0;
1403}
1404
1405static int nfc_se_io(struct nfc_dev *dev, u32 se_idx,
1406		     u8 *apdu, size_t apdu_length,
1407		     se_io_cb_t cb, void *cb_context)
1408{
1409	struct nfc_se *se;
1410	int rc;
1411
1412	pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
1413
1414	device_lock(&dev->dev);
1415
1416	if (!device_is_registered(&dev->dev)) {
1417		rc = -ENODEV;
1418		goto error;
1419	}
1420
1421	if (!dev->dev_up) {
1422		rc = -ENODEV;
1423		goto error;
1424	}
1425
1426	if (!dev->ops->se_io) {
1427		rc = -EOPNOTSUPP;
1428		goto error;
1429	}
1430
1431	se = nfc_find_se(dev, se_idx);
1432	if (!se) {
1433		rc = -EINVAL;
1434		goto error;
1435	}
1436
1437	if (se->state != NFC_SE_ENABLED) {
1438		rc = -ENODEV;
1439		goto error;
1440	}
1441
1442	rc = dev->ops->se_io(dev, se_idx, apdu,
1443			apdu_length, cb, cb_context);
1444
1445error:
1446	device_unlock(&dev->dev);
1447	return rc;
1448}
1449
1450struct se_io_ctx {
1451	u32 dev_idx;
1452	u32 se_idx;
1453};
1454
1455static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1456{
1457	struct se_io_ctx *ctx = context;
1458	struct sk_buff *msg;
1459	void *hdr;
1460
1461	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1462	if (!msg) {
1463		kfree(ctx);
1464		return;
1465	}
1466
1467	hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1468			  NFC_CMD_SE_IO);
1469	if (!hdr)
1470		goto free_msg;
1471
1472	if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1473	    nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1474	    nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1475		goto nla_put_failure;
1476
1477	genlmsg_end(msg, hdr);
1478
1479	genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1480
1481	kfree(ctx);
1482
1483	return;
1484
1485nla_put_failure:
1486free_msg:
1487	nlmsg_free(msg);
1488	kfree(ctx);
1489
1490	return;
1491}
1492
1493static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1494{
1495	struct nfc_dev *dev;
1496	struct se_io_ctx *ctx;
1497	u32 dev_idx, se_idx;
1498	u8 *apdu;
1499	size_t apdu_len;
1500	int rc;
1501
1502	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1503	    !info->attrs[NFC_ATTR_SE_INDEX] ||
1504	    !info->attrs[NFC_ATTR_SE_APDU])
1505		return -EINVAL;
1506
1507	dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1508	se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1509
1510	dev = nfc_get_device(dev_idx);
1511	if (!dev)
1512		return -ENODEV;
1513
1514	if (!dev->ops || !dev->ops->se_io) {
1515		rc = -EOPNOTSUPP;
1516		goto put_dev;
1517	}
1518
1519	apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1520	if (apdu_len == 0) {
1521		rc = -EINVAL;
1522		goto put_dev;
1523	}
1524
1525	apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1526	if (!apdu) {
1527		rc = -EINVAL;
1528		goto put_dev;
1529	}
1530
1531	ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1532	if (!ctx) {
1533		rc = -ENOMEM;
1534		goto put_dev;
1535	}
1536
1537	ctx->dev_idx = dev_idx;
1538	ctx->se_idx = se_idx;
1539
1540	rc = nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1541
1542put_dev:
1543	nfc_put_device(dev);
1544	return rc;
1545}
1546
1547static int nfc_genl_vendor_cmd(struct sk_buff *skb,
1548			       struct genl_info *info)
1549{
1550	struct nfc_dev *dev;
1551	const struct nfc_vendor_cmd *cmd;
1552	u32 dev_idx, vid, subcmd;
1553	u8 *data;
1554	size_t data_len;
1555	int i, err;
1556
1557	if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1558	    !info->attrs[NFC_ATTR_VENDOR_ID] ||
1559	    !info->attrs[NFC_ATTR_VENDOR_SUBCMD])
1560		return -EINVAL;
1561
1562	dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1563	vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]);
1564	subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]);
1565
1566	dev = nfc_get_device(dev_idx);
1567	if (!dev)
1568		return -ENODEV;
1569
1570	if (!dev->vendor_cmds || !dev->n_vendor_cmds) {
1571		err = -ENODEV;
1572		goto put_dev;
1573	}
1574
1575	if (info->attrs[NFC_ATTR_VENDOR_DATA]) {
1576		data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]);
1577		data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]);
1578		if (data_len == 0) {
1579			err = -EINVAL;
1580			goto put_dev;
1581		}
1582	} else {
1583		data = NULL;
1584		data_len = 0;
1585	}
1586
1587	for (i = 0; i < dev->n_vendor_cmds; i++) {
1588		cmd = &dev->vendor_cmds[i];
1589
1590		if (cmd->vendor_id != vid || cmd->subcmd != subcmd)
1591			continue;
1592
1593		dev->cur_cmd_info = info;
1594		err = cmd->doit(dev, data, data_len);
1595		dev->cur_cmd_info = NULL;
1596		goto put_dev;
1597	}
1598
1599	err = -EOPNOTSUPP;
1600
1601put_dev:
1602	nfc_put_device(dev);
1603	return err;
1604}
1605
1606/* message building helper */
1607static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
1608				int flags, u8 cmd)
1609{
1610	/* since there is no private header just add the generic one */
1611	return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd);
1612}
1613
1614static struct sk_buff *
1615__nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen,
1616			   u32 portid, u32 seq,
1617			   enum nfc_attrs attr,
1618			   u32 oui, u32 subcmd, gfp_t gfp)
1619{
1620	struct sk_buff *skb;
1621	void *hdr;
1622
1623	skb = nlmsg_new(approxlen + 100, gfp);
1624	if (!skb)
1625		return NULL;
1626
1627	hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR);
1628	if (!hdr) {
1629		kfree_skb(skb);
1630		return NULL;
1631	}
1632
1633	if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx))
1634		goto nla_put_failure;
1635	if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui))
1636		goto nla_put_failure;
1637	if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd))
1638		goto nla_put_failure;
1639
1640	((void **)skb->cb)[0] = dev;
1641	((void **)skb->cb)[1] = hdr;
1642
1643	return skb;
1644
1645nla_put_failure:
1646	kfree_skb(skb);
1647	return NULL;
1648}
1649
1650struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev,
1651						 enum nfc_attrs attr,
1652						 u32 oui, u32 subcmd,
1653						 int approxlen)
1654{
1655	if (WARN_ON(!dev->cur_cmd_info))
1656		return NULL;
1657
1658	return __nfc_alloc_vendor_cmd_skb(dev, approxlen,
1659					  dev->cur_cmd_info->snd_portid,
1660					  dev->cur_cmd_info->snd_seq, attr,
1661					  oui, subcmd, GFP_KERNEL);
1662}
1663EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb);
1664
1665int nfc_vendor_cmd_reply(struct sk_buff *skb)
1666{
1667	struct nfc_dev *dev = ((void **)skb->cb)[0];
1668	void *hdr = ((void **)skb->cb)[1];
1669
1670	/* clear CB data for netlink core to own from now on */
1671	memset(skb->cb, 0, sizeof(skb->cb));
1672
1673	if (WARN_ON(!dev->cur_cmd_info)) {
1674		kfree_skb(skb);
1675		return -EINVAL;
1676	}
1677
1678	genlmsg_end(skb, hdr);
1679	return genlmsg_reply(skb, dev->cur_cmd_info);
1680}
1681EXPORT_SYMBOL(nfc_vendor_cmd_reply);
1682
1683static const struct genl_ops nfc_genl_ops[] = {
1684	{
1685		.cmd = NFC_CMD_GET_DEVICE,
1686		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1687		.doit = nfc_genl_get_device,
1688		.dumpit = nfc_genl_dump_devices,
1689		.done = nfc_genl_dump_devices_done,
1690	},
1691	{
1692		.cmd = NFC_CMD_DEV_UP,
1693		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1694		.doit = nfc_genl_dev_up,
1695		.flags = GENL_ADMIN_PERM,
1696	},
1697	{
1698		.cmd = NFC_CMD_DEV_DOWN,
1699		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1700		.doit = nfc_genl_dev_down,
1701		.flags = GENL_ADMIN_PERM,
1702	},
1703	{
1704		.cmd = NFC_CMD_START_POLL,
1705		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1706		.doit = nfc_genl_start_poll,
1707		.flags = GENL_ADMIN_PERM,
1708	},
1709	{
1710		.cmd = NFC_CMD_STOP_POLL,
1711		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1712		.doit = nfc_genl_stop_poll,
1713		.flags = GENL_ADMIN_PERM,
1714	},
1715	{
1716		.cmd = NFC_CMD_DEP_LINK_UP,
1717		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1718		.doit = nfc_genl_dep_link_up,
1719		.flags = GENL_ADMIN_PERM,
1720	},
1721	{
1722		.cmd = NFC_CMD_DEP_LINK_DOWN,
1723		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1724		.doit = nfc_genl_dep_link_down,
1725		.flags = GENL_ADMIN_PERM,
1726	},
1727	{
1728		.cmd = NFC_CMD_GET_TARGET,
1729		.validate = GENL_DONT_VALIDATE_STRICT |
1730			    GENL_DONT_VALIDATE_DUMP_STRICT,
1731		.dumpit = nfc_genl_dump_targets,
1732		.done = nfc_genl_dump_targets_done,
1733	},
1734	{
1735		.cmd = NFC_CMD_LLC_GET_PARAMS,
1736		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1737		.doit = nfc_genl_llc_get_params,
1738	},
1739	{
1740		.cmd = NFC_CMD_LLC_SET_PARAMS,
1741		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1742		.doit = nfc_genl_llc_set_params,
1743		.flags = GENL_ADMIN_PERM,
1744	},
1745	{
1746		.cmd = NFC_CMD_LLC_SDREQ,
1747		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1748		.doit = nfc_genl_llc_sdreq,
1749		.flags = GENL_ADMIN_PERM,
1750	},
1751	{
1752		.cmd = NFC_CMD_FW_DOWNLOAD,
1753		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1754		.doit = nfc_genl_fw_download,
1755		.flags = GENL_ADMIN_PERM,
1756	},
1757	{
1758		.cmd = NFC_CMD_ENABLE_SE,
1759		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1760		.doit = nfc_genl_enable_se,
1761		.flags = GENL_ADMIN_PERM,
1762	},
1763	{
1764		.cmd = NFC_CMD_DISABLE_SE,
1765		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1766		.doit = nfc_genl_disable_se,
1767		.flags = GENL_ADMIN_PERM,
1768	},
1769	{
1770		.cmd = NFC_CMD_GET_SE,
1771		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1772		.dumpit = nfc_genl_dump_ses,
1773		.done = nfc_genl_dump_ses_done,
1774	},
1775	{
1776		.cmd = NFC_CMD_SE_IO,
1777		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1778		.doit = nfc_genl_se_io,
1779		.flags = GENL_ADMIN_PERM,
1780	},
1781	{
1782		.cmd = NFC_CMD_ACTIVATE_TARGET,
1783		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1784		.doit = nfc_genl_activate_target,
1785		.flags = GENL_ADMIN_PERM,
1786	},
1787	{
1788		.cmd = NFC_CMD_VENDOR,
1789		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1790		.doit = nfc_genl_vendor_cmd,
1791		.flags = GENL_ADMIN_PERM,
1792	},
1793	{
1794		.cmd = NFC_CMD_DEACTIVATE_TARGET,
1795		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1796		.doit = nfc_genl_deactivate_target,
1797		.flags = GENL_ADMIN_PERM,
1798	},
1799};
1800
1801static struct genl_family nfc_genl_family __ro_after_init = {
1802	.hdrsize = 0,
1803	.name = NFC_GENL_NAME,
1804	.version = NFC_GENL_VERSION,
1805	.maxattr = NFC_ATTR_MAX,
1806	.policy = nfc_genl_policy,
1807	.module = THIS_MODULE,
1808	.ops = nfc_genl_ops,
1809	.n_ops = ARRAY_SIZE(nfc_genl_ops),
1810	.resv_start_op = NFC_CMD_DEACTIVATE_TARGET + 1,
1811	.mcgrps = nfc_genl_mcgrps,
1812	.n_mcgrps = ARRAY_SIZE(nfc_genl_mcgrps),
1813};
1814
1815
1816struct urelease_work {
1817	struct	work_struct w;
1818	u32	portid;
1819};
1820
1821static void nfc_urelease_event_work(struct work_struct *work)
1822{
1823	struct urelease_work *w = container_of(work, struct urelease_work, w);
1824	struct class_dev_iter iter;
1825	struct nfc_dev *dev;
1826
1827	pr_debug("portid %d\n", w->portid);
1828
1829	mutex_lock(&nfc_devlist_mutex);
1830
1831	nfc_device_iter_init(&iter);
1832	dev = nfc_device_iter_next(&iter);
1833
1834	while (dev) {
1835		mutex_lock(&dev->genl_data.genl_data_mutex);
1836
1837		if (dev->genl_data.poll_req_portid == w->portid) {
1838			nfc_stop_poll(dev);
1839			dev->genl_data.poll_req_portid = 0;
1840		}
1841
1842		mutex_unlock(&dev->genl_data.genl_data_mutex);
1843
1844		dev = nfc_device_iter_next(&iter);
1845	}
1846
1847	nfc_device_iter_exit(&iter);
1848
1849	mutex_unlock(&nfc_devlist_mutex);
1850
1851	kfree(w);
1852}
1853
1854static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1855				 unsigned long event, void *ptr)
1856{
1857	struct netlink_notify *n = ptr;
1858	struct urelease_work *w;
1859
1860	if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1861		goto out;
1862
1863	pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1864
1865	w = kmalloc(sizeof(*w), GFP_ATOMIC);
1866	if (w) {
1867		INIT_WORK(&w->w, nfc_urelease_event_work);
1868		w->portid = n->portid;
1869		schedule_work(&w->w);
1870	}
1871
1872out:
1873	return NOTIFY_DONE;
1874}
1875
1876void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1877{
1878	genl_data->poll_req_portid = 0;
1879	mutex_init(&genl_data->genl_data_mutex);
1880}
1881
1882void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1883{
1884	mutex_destroy(&genl_data->genl_data_mutex);
1885}
1886
1887static struct notifier_block nl_notifier = {
1888	.notifier_call  = nfc_genl_rcv_nl_event,
1889};
1890
1891/**
1892 * nfc_genl_init() - Initialize netlink interface
1893 *
1894 * This initialization function registers the nfc netlink family.
1895 */
1896int __init nfc_genl_init(void)
1897{
1898	int rc;
1899
1900	rc = genl_register_family(&nfc_genl_family);
1901	if (rc)
1902		return rc;
1903
1904	netlink_register_notifier(&nl_notifier);
1905
1906	return 0;
1907}
1908
1909/**
1910 * nfc_genl_exit() - Deinitialize netlink interface
1911 *
1912 * This exit function unregisters the nfc netlink family.
1913 */
1914void nfc_genl_exit(void)
1915{
1916	netlink_unregister_notifier(&nl_notifier);
1917	genl_unregister_family(&nfc_genl_family);
1918}