net/nfc/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 <[email protected]>
   7  *    Aloisio Almeida Jr <[email protected]>
   8  *
   9  * Vendor commands implementation based on net/wireless/nl80211.c
  10  * which is:
  11  *
  12  * Copyright 2006-2010  Johannes Berg <[email protected]>
  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
  25 static const struct genl_multicast_group nfc_genl_mcgrps[] = {
  26         { .name = NFC_GENL_MCAST_EVENT_NAME, },
  27 };
  28
  29 static struct genl_family nfc_genl_family;
  30 static 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
  55 static 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
  61 static 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
 107 nla_put_failure:
 108         genlmsg_cancel(msg, hdr);
 109         return -EMSGSIZE;
 110 }
 111
 112 static 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
 130 static 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
 165 static 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
 175 int 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
 198 nla_put_failure:
 199 free_msg:
 200         nlmsg_free(msg);
 201         return -EMSGSIZE;
 202 }
 203
 204 int 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
 228 nla_put_failure:
 229 free_msg:
 230         nlmsg_free(msg);
 231         return -EMSGSIZE;
 232 }
 233
 234 int 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
 259 nla_put_failure:
 260 free_msg:
 261         nlmsg_free(msg);
 262         return -EMSGSIZE;
 263 }
 264
 265 int 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
 288 nla_put_failure:
 289 free_msg:
 290         nlmsg_free(msg);
 291         return -EMSGSIZE;
 292 }
 293
 294 static 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
 305 int 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
 328 nla_put_failure:
 329 free_msg:
 330         nlmsg_free(msg);
 331         return -EMSGSIZE;
 332 }
 333
 334 int 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
 357 nla_put_failure:
 358 free_msg:
 359         nlmsg_free(msg);
 360         return -EMSGSIZE;
 361 }
 362
 363 int 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
 420 nla_put_failure:
 421 free_msg:
 422         nlmsg_free(msg);
 423
 424         nfc_llcp_free_sdp_tlv_list(sdres_list);
 425
 426         return rc;
 427 }
 428
 429 int 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
 454 nla_put_failure:
 455 free_msg:
 456         nlmsg_free(msg);
 457         return -EMSGSIZE;
 458 }
 459
 460 int 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
 484 nla_put_failure:
 485 free_msg:
 486         nlmsg_free(msg);
 487         return -EMSGSIZE;
 488 }
 489
 490 int 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
 528 nla_put_failure:
 529 free_msg:
 530         /* evt_transaction is no more used */
 531         devm_kfree(&dev->dev, evt_transaction);
 532         nlmsg_free(msg);
 533         return -EMSGSIZE;
 534 }
 535
 536 int 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
 566 nla_put_failure:
 567 free_msg:
 568         nlmsg_free(msg);
 569         return -EMSGSIZE;
 570 }
 571
 572 static 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
 593 nla_put_failure:
 594         genlmsg_cancel(msg, hdr);
 595         return -EMSGSIZE;
 596 }
 597
 598 static 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
 640 static 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
 652 int 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
 685 nla_put_failure:
 686 free_msg:
 687         nlmsg_free(msg);
 688         return -EMSGSIZE;
 689 }
 690
 691 int 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
 716 nla_put_failure:
 717 free_msg:
 718         nlmsg_free(msg);
 719         return -EMSGSIZE;
 720 }
 721
 722 static 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
 753 out_free:
 754         nlmsg_free(msg);
 755 out_putdev:
 756         nfc_put_device(dev);
 757         return rc;
 758 }
 759
 760 static 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
 781 static 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
 802 static 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
 843 static 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
 878 out:
 879         mutex_unlock(&dev->genl_data.genl_data_mutex);
 880         nfc_put_device(dev);
 881         return rc;
 882 }
 883
 884 static 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
 911 static 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
 936 static 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
 971 static 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
 992 static 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
1012 nla_put_failure:
1013         genlmsg_cancel(msg, hdr);
1014         return -EMSGSIZE;
1015 }
1016
1017 static 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
1050 put_local:
1051         nfc_llcp_local_put(local);
1052
1053 exit:
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
1068 static 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
1126 put_local:
1127         nfc_llcp_local_put(local);
1128
1129 exit:
1130         device_unlock(&dev->dev);
1131
1132         nfc_put_device(dev);
1133
1134         return rc;
1135 }
1136
1137 static 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 == NULL || *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
1218 put_local:
1219         nfc_llcp_local_put(local);
1220
1221 exit:
1222         device_unlock(&dev->dev);
1223
1224         nfc_put_device(dev);
1225
1226         return rc;
1227 }
1228
1229 static 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
1254 int 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
1280 nla_put_failure:
1281 free_msg:
1282         nlmsg_free(msg);
1283         return -EMSGSIZE;
1284 }
1285
1286 static 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
1309 static 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
1332 static 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
1359 nla_put_failure:
1360         genlmsg_cancel(msg, hdr);
1361         return -EMSGSIZE;
1362 }
1363
1364 static 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
1406 static 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
1418 static 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
1461 error:
1462         device_unlock(&dev->dev);
1463         kfree(cb_context);
1464         return rc;
1465 }
1466
1467 struct se_io_ctx {
1468         u32 dev_idx;
1469         u32 se_idx;
1470 };
1471
1472 static 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
1502 nla_put_failure:
1503 free_msg:
1504         nlmsg_free(msg);
1505         kfree(ctx);
1506
1507         return;
1508 }
1509
1510 static 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         if (!apdu) {
1544                 rc = -EINVAL;
1545                 goto put_dev;
1546         }
1547
1548         ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1549         if (!ctx) {
1550                 rc = -ENOMEM;
1551                 goto put_dev;
1552         }
1553
1554         ctx->dev_idx = dev_idx;
1555         ctx->se_idx = se_idx;
1556
1557         rc = nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1558
1559 put_dev:
1560         nfc_put_device(dev);
1561         return rc;
1562 }
1563
1564 static int nfc_genl_vendor_cmd(struct sk_buff *skb,
1565                                struct genl_info *info)
1566 {
1567         struct nfc_dev *dev;
1568         const struct nfc_vendor_cmd *cmd;
1569         u32 dev_idx, vid, subcmd;
1570         u8 *data;
1571         size_t data_len;
1572         int i, err;
1573
1574         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1575             !info->attrs[NFC_ATTR_VENDOR_ID] ||
1576             !info->attrs[NFC_ATTR_VENDOR_SUBCMD])
1577                 return -EINVAL;
1578
1579         dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1580         vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]);
1581         subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]);
1582
1583         dev = nfc_get_device(dev_idx);
1584         if (!dev)
1585                 return -ENODEV;
1586
1587         if (!dev->vendor_cmds || !dev->n_vendor_cmds) {
1588                 err = -ENODEV;
1589                 goto put_dev;
1590         }
1591
1592         if (info->attrs[NFC_ATTR_VENDOR_DATA]) {
1593                 data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]);
1594                 data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]);
1595                 if (data_len == 0) {
1596                         err = -EINVAL;
1597                         goto put_dev;
1598                 }
1599         } else {
1600                 data = NULL;
1601                 data_len = 0;
1602         }
1603
1604         for (i = 0; i < dev->n_vendor_cmds; i++) {
1605                 cmd = &dev->vendor_cmds[i];
1606
1607                 if (cmd->vendor_id != vid || cmd->subcmd != subcmd)
1608                         continue;
1609
1610                 dev->cur_cmd_info = info;
1611                 err = cmd->doit(dev, data, data_len);
1612                 dev->cur_cmd_info = NULL;
1613                 goto put_dev;
1614         }
1615
1616         err = -EOPNOTSUPP;
1617
1618 put_dev:
1619         nfc_put_device(dev);
1620         return err;
1621 }
1622
1623 /* message building helper */
1624 static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
1625                                 int flags, u8 cmd)
1626 {
1627         /* since there is no private header just add the generic one */
1628         return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd);
1629 }
1630
1631 static struct sk_buff *
1632 __nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen,
1633                            u32 portid, u32 seq,
1634                            enum nfc_attrs attr,
1635                            u32 oui, u32 subcmd, gfp_t gfp)
1636 {
1637         struct sk_buff *skb;
1638         void *hdr;
1639
1640         skb = nlmsg_new(approxlen + 100, gfp);
1641         if (!skb)
1642                 return NULL;
1643
1644         hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR);
1645         if (!hdr) {
1646                 kfree_skb(skb);
1647                 return NULL;
1648         }
1649
1650         if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx))
1651                 goto nla_put_failure;
1652         if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui))
1653                 goto nla_put_failure;
1654         if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd))
1655                 goto nla_put_failure;
1656
1657         ((void **)skb->cb)[0] = dev;
1658         ((void **)skb->cb)[1] = hdr;
1659
1660         return skb;
1661
1662 nla_put_failure:
1663         kfree_skb(skb);
1664         return NULL;
1665 }
1666
1667 struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev,
1668                                                  enum nfc_attrs attr,
1669                                                  u32 oui, u32 subcmd,
1670                                                  int approxlen)
1671 {
1672         if (WARN_ON(!dev->cur_cmd_info))
1673                 return NULL;
1674
1675         return __nfc_alloc_vendor_cmd_skb(dev, approxlen,
1676                                           dev->cur_cmd_info->snd_portid,
1677                                           dev->cur_cmd_info->snd_seq, attr,
1678                                           oui, subcmd, GFP_KERNEL);
1679 }
1680 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb);
1681
1682 int nfc_vendor_cmd_reply(struct sk_buff *skb)
1683 {
1684         struct nfc_dev *dev = ((void **)skb->cb)[0];
1685         void *hdr = ((void **)skb->cb)[1];
1686
1687         /* clear CB data for netlink core to own from now on */
1688         memset(skb->cb, 0, sizeof(skb->cb));
1689
1690         if (WARN_ON(!dev->cur_cmd_info)) {
1691                 kfree_skb(skb);
1692                 return -EINVAL;
1693         }
1694
1695         genlmsg_end(skb, hdr);
1696         return genlmsg_reply(skb, dev->cur_cmd_info);
1697 }
1698 EXPORT_SYMBOL(nfc_vendor_cmd_reply);
1699
1700 static const struct genl_ops nfc_genl_ops[] = {
1701         {
1702                 .cmd = NFC_CMD_GET_DEVICE,
1703                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1704                 .doit = nfc_genl_get_device,
1705                 .dumpit = nfc_genl_dump_devices,
1706                 .done = nfc_genl_dump_devices_done,
1707         },
1708         {
1709                 .cmd = NFC_CMD_DEV_UP,
1710                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1711                 .doit = nfc_genl_dev_up,
1712                 .flags = GENL_ADMIN_PERM,
1713         },
1714         {
1715                 .cmd = NFC_CMD_DEV_DOWN,
1716                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1717                 .doit = nfc_genl_dev_down,
1718                 .flags = GENL_ADMIN_PERM,
1719         },
1720         {
1721                 .cmd = NFC_CMD_START_POLL,
1722                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1723                 .doit = nfc_genl_start_poll,
1724                 .flags = GENL_ADMIN_PERM,
1725         },
1726         {
1727                 .cmd = NFC_CMD_STOP_POLL,
1728                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1729                 .doit = nfc_genl_stop_poll,
1730                 .flags = GENL_ADMIN_PERM,
1731         },
1732         {
1733                 .cmd = NFC_CMD_DEP_LINK_UP,
1734                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1735                 .doit = nfc_genl_dep_link_up,
1736                 .flags = GENL_ADMIN_PERM,
1737         },
1738         {
1739                 .cmd = NFC_CMD_DEP_LINK_DOWN,
1740                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1741                 .doit = nfc_genl_dep_link_down,
1742                 .flags = GENL_ADMIN_PERM,
1743         },
1744         {
1745                 .cmd = NFC_CMD_GET_TARGET,
1746                 .validate = GENL_DONT_VALIDATE_STRICT |
1747                             GENL_DONT_VALIDATE_DUMP_STRICT,
1748                 .dumpit = nfc_genl_dump_targets,
1749                 .done = nfc_genl_dump_targets_done,
1750         },
1751         {
1752                 .cmd = NFC_CMD_LLC_GET_PARAMS,
1753                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1754                 .doit = nfc_genl_llc_get_params,
1755         },
1756         {
1757                 .cmd = NFC_CMD_LLC_SET_PARAMS,
1758                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1759                 .doit = nfc_genl_llc_set_params,
1760                 .flags = GENL_ADMIN_PERM,
1761         },
1762         {
1763                 .cmd = NFC_CMD_LLC_SDREQ,
1764                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1765                 .doit = nfc_genl_llc_sdreq,
1766                 .flags = GENL_ADMIN_PERM,
1767         },
1768         {
1769                 .cmd = NFC_CMD_FW_DOWNLOAD,
1770                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1771                 .doit = nfc_genl_fw_download,
1772                 .flags = GENL_ADMIN_PERM,
1773         },
1774         {
1775                 .cmd = NFC_CMD_ENABLE_SE,
1776                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1777                 .doit = nfc_genl_enable_se,
1778                 .flags = GENL_ADMIN_PERM,
1779         },
1780         {
1781                 .cmd = NFC_CMD_DISABLE_SE,
1782                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1783                 .doit = nfc_genl_disable_se,
1784                 .flags = GENL_ADMIN_PERM,
1785         },
1786         {
1787                 .cmd = NFC_CMD_GET_SE,
1788                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1789                 .dumpit = nfc_genl_dump_ses,
1790                 .done = nfc_genl_dump_ses_done,
1791         },
1792         {
1793                 .cmd = NFC_CMD_SE_IO,
1794                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1795                 .doit = nfc_genl_se_io,
1796                 .flags = GENL_ADMIN_PERM,
1797         },
1798         {
1799                 .cmd = NFC_CMD_ACTIVATE_TARGET,
1800                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1801                 .doit = nfc_genl_activate_target,
1802                 .flags = GENL_ADMIN_PERM,
1803         },
1804         {
1805                 .cmd = NFC_CMD_VENDOR,
1806                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1807                 .doit = nfc_genl_vendor_cmd,
1808                 .flags = GENL_ADMIN_PERM,
1809         },
1810         {
1811                 .cmd = NFC_CMD_DEACTIVATE_TARGET,
1812                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1813                 .doit = nfc_genl_deactivate_target,
1814                 .flags = GENL_ADMIN_PERM,
1815         },
1816 };
1817
1818 static struct genl_family nfc_genl_family __ro_after_init = {
1819         .hdrsize = 0,
1820         .name = NFC_GENL_NAME,
1821         .version = NFC_GENL_VERSION,
1822         .maxattr = NFC_ATTR_MAX,
1823         .policy = nfc_genl_policy,
1824         .module = THIS_MODULE,
1825         .ops = nfc_genl_ops,
1826         .n_ops = ARRAY_SIZE(nfc_genl_ops),
1827         .resv_start_op = NFC_CMD_DEACTIVATE_TARGET + 1,
1828         .mcgrps = nfc_genl_mcgrps,
1829         .n_mcgrps = ARRAY_SIZE(nfc_genl_mcgrps),
1830 };
1831
1832
1833 struct urelease_work {
1834         struct  work_struct w;
1835         u32     portid;
1836 };
1837
1838 static void nfc_urelease_event_work(struct work_struct *work)
1839 {
1840         struct urelease_work *w = container_of(work, struct urelease_work, w);
1841         struct class_dev_iter iter;
1842         struct nfc_dev *dev;
1843
1844         pr_debug("portid %d\n", w->portid);
1845
1846         mutex_lock(&nfc_devlist_mutex);
1847
1848         nfc_device_iter_init(&iter);
1849         dev = nfc_device_iter_next(&iter);
1850
1851         while (dev) {
1852                 mutex_lock(&dev->genl_data.genl_data_mutex);
1853
1854                 if (dev->genl_data.poll_req_portid == w->portid) {
1855                         nfc_stop_poll(dev);
1856                         dev->genl_data.poll_req_portid = 0;
1857                 }
1858
1859                 mutex_unlock(&dev->genl_data.genl_data_mutex);
1860
1861                 dev = nfc_device_iter_next(&iter);
1862         }
1863
1864         nfc_device_iter_exit(&iter);
1865
1866         mutex_unlock(&nfc_devlist_mutex);
1867
1868         kfree(w);
1869 }
1870
1871 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1872                                  unsigned long event, void *ptr)
1873 {
1874         struct netlink_notify *n = ptr;
1875         struct urelease_work *w;
1876
1877         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1878                 goto out;
1879
1880         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1881
1882         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1883         if (w) {
1884                 INIT_WORK(&w->w, nfc_urelease_event_work);
1885                 w->portid = n->portid;
1886                 schedule_work(&w->w);
1887         }
1888
1889 out:
1890         return NOTIFY_DONE;
1891 }
1892
1893 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1894 {
1895         genl_data->poll_req_portid = 0;
1896         mutex_init(&genl_data->genl_data_mutex);
1897 }
1898
1899 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1900 {
1901         mutex_destroy(&genl_data->genl_data_mutex);
1902 }
1903
1904 static struct notifier_block nl_notifier = {
1905         .notifier_call  = nfc_genl_rcv_nl_event,
1906 };
1907
1908 /**
1909  * nfc_genl_init() - Initialize netlink interface
1910  *
1911  * This initialization function registers the nfc netlink family.
1912  */
1913 int __init nfc_genl_init(void)
1914 {
1915         int rc;
1916
1917         rc = genl_register_family(&nfc_genl_family);
1918         if (rc)
1919                 return rc;
1920
1921         netlink_register_notifier(&nl_notifier);
1922
1923         return 0;
1924 }
1925
1926 /**
1927  * nfc_genl_exit() - Deinitialize netlink interface
1928  *
1929  * This exit function unregisters the nfc netlink family.
1930  */
1931 void nfc_genl_exit(void)
1932 {
1933         netlink_unregister_notifier(&nl_notifier);
1934         genl_unregister_family(&nfc_genl_family);
1935 }