net/nfc/netlink.c

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