netlink.c

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