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