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         device_unlock(&dev->dev);
1464         return rc;
1465
1466 error:
1467         device_unlock(&dev->dev);
1468         kfree(cb_context);
1469         return rc;
1470 }
1471
1472 struct se_io_ctx {
1473         u32 dev_idx;
1474         u32 se_idx;
1475 };
1476
1477 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1478 {
1479         struct se_io_ctx *ctx = context;
1480         struct sk_buff *msg;
1481         void *hdr;
1482
1483         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1484         if (!msg) {
1485                 kfree(ctx);
1486                 return;
1487         }
1488
1489         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1490                           NFC_CMD_SE_IO);
1491         if (!hdr)
1492                 goto free_msg;
1493
1494         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1495             nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1496             nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1497                 goto nla_put_failure;
1498
1499         genlmsg_end(msg, hdr);
1500
1501         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1502
1503         kfree(ctx);
1504
1505         return;
1506
1507 nla_put_failure:
1508 free_msg:
1509         nlmsg_free(msg);
1510         kfree(ctx);
1511
1512         return;
1513 }
1514
1515 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1516 {
1517         struct nfc_dev *dev;
1518         struct se_io_ctx *ctx;
1519         u32 dev_idx, se_idx;
1520         u8 *apdu;
1521         size_t apdu_len;
1522         int rc;
1523
1524         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1525             !info->attrs[NFC_ATTR_SE_INDEX] ||
1526             !info->attrs[NFC_ATTR_SE_APDU])
1527                 return -EINVAL;
1528
1529         dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1530         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1531
1532         dev = nfc_get_device(dev_idx);
1533         if (!dev)
1534                 return -ENODEV;
1535
1536         if (!dev->ops || !dev->ops->se_io) {
1537                 rc = -EOPNOTSUPP;
1538                 goto put_dev;
1539         }
1540
1541         apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1542         if (apdu_len == 0) {
1543                 rc = -EINVAL;
1544                 goto put_dev;
1545         }
1546
1547         apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1548         if (!apdu) {
1549                 rc = -EINVAL;
1550                 goto put_dev;
1551         }
1552
1553         ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1554         if (!ctx) {
1555                 rc = -ENOMEM;
1556                 goto put_dev;
1557         }
1558
1559         ctx->dev_idx = dev_idx;
1560         ctx->se_idx = se_idx;
1561
1562         rc = nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1563
1564 put_dev:
1565         nfc_put_device(dev);
1566         return rc;
1567 }
1568
1569 static int nfc_genl_vendor_cmd(struct sk_buff *skb,
1570                                struct genl_info *info)
1571 {
1572         struct nfc_dev *dev;
1573         struct nfc_vendor_cmd *cmd;
1574         u32 dev_idx, vid, subcmd;
1575         u8 *data;
1576         size_t data_len;
1577         int i, err;
1578
1579         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1580             !info->attrs[NFC_ATTR_VENDOR_ID] ||
1581             !info->attrs[NFC_ATTR_VENDOR_SUBCMD])
1582                 return -EINVAL;
1583
1584         dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1585         vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]);
1586         subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]);
1587
1588         dev = nfc_get_device(dev_idx);
1589         if (!dev)
1590                 return -ENODEV;
1591
1592         if (!dev->vendor_cmds || !dev->n_vendor_cmds) {
1593                 err = -ENODEV;
1594                 goto put_dev;
1595         }
1596
1597         if (info->attrs[NFC_ATTR_VENDOR_DATA]) {
1598                 data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]);
1599                 data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]);
1600                 if (data_len == 0) {
1601                         err = -EINVAL;
1602                         goto put_dev;
1603                 }
1604         } else {
1605                 data = NULL;
1606                 data_len = 0;
1607         }
1608
1609         for (i = 0; i < dev->n_vendor_cmds; i++) {
1610                 cmd = &dev->vendor_cmds[i];
1611
1612                 if (cmd->vendor_id != vid || cmd->subcmd != subcmd)
1613                         continue;
1614
1615                 dev->cur_cmd_info = info;
1616                 err = cmd->doit(dev, data, data_len);
1617                 dev->cur_cmd_info = NULL;
1618                 goto put_dev;
1619         }
1620
1621         err = -EOPNOTSUPP;
1622
1623 put_dev:
1624         nfc_put_device(dev);
1625         return err;
1626 }
1627
1628 /* message building helper */
1629 static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
1630                                 int flags, u8 cmd)
1631 {
1632         /* since there is no private header just add the generic one */
1633         return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd);
1634 }
1635
1636 static struct sk_buff *
1637 __nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen,
1638                            u32 portid, u32 seq,
1639                            enum nfc_attrs attr,
1640                            u32 oui, u32 subcmd, gfp_t gfp)
1641 {
1642         struct sk_buff *skb;
1643         void *hdr;
1644
1645         skb = nlmsg_new(approxlen + 100, gfp);
1646         if (!skb)
1647                 return NULL;
1648
1649         hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR);
1650         if (!hdr) {
1651                 kfree_skb(skb);
1652                 return NULL;
1653         }
1654
1655         if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx))
1656                 goto nla_put_failure;
1657         if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui))
1658                 goto nla_put_failure;
1659         if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd))
1660                 goto nla_put_failure;
1661
1662         ((void **)skb->cb)[0] = dev;
1663         ((void **)skb->cb)[1] = hdr;
1664
1665         return skb;
1666
1667 nla_put_failure:
1668         kfree_skb(skb);
1669         return NULL;
1670 }
1671
1672 struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev,
1673                                                  enum nfc_attrs attr,
1674                                                  u32 oui, u32 subcmd,
1675                                                  int approxlen)
1676 {
1677         if (WARN_ON(!dev->cur_cmd_info))
1678                 return NULL;
1679
1680         return __nfc_alloc_vendor_cmd_skb(dev, approxlen,
1681                                           dev->cur_cmd_info->snd_portid,
1682                                           dev->cur_cmd_info->snd_seq, attr,
1683                                           oui, subcmd, GFP_KERNEL);
1684 }
1685 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb);
1686
1687 int nfc_vendor_cmd_reply(struct sk_buff *skb)
1688 {
1689         struct nfc_dev *dev = ((void **)skb->cb)[0];
1690         void *hdr = ((void **)skb->cb)[1];
1691
1692         /* clear CB data for netlink core to own from now on */
1693         memset(skb->cb, 0, sizeof(skb->cb));
1694
1695         if (WARN_ON(!dev->cur_cmd_info)) {
1696                 kfree_skb(skb);
1697                 return -EINVAL;
1698         }
1699
1700         genlmsg_end(skb, hdr);
1701         return genlmsg_reply(skb, dev->cur_cmd_info);
1702 }
1703 EXPORT_SYMBOL(nfc_vendor_cmd_reply);
1704
1705 static const struct genl_ops nfc_genl_ops[] = {
1706         {
1707                 .cmd = NFC_CMD_GET_DEVICE,
1708                 .doit = nfc_genl_get_device,
1709                 .dumpit = nfc_genl_dump_devices,
1710                 .done = nfc_genl_dump_devices_done,
1711                 .policy = nfc_genl_policy,
1712         },
1713         {
1714                 .cmd = NFC_CMD_DEV_UP,
1715                 .doit = nfc_genl_dev_up,
1716                 .policy = nfc_genl_policy,
1717         },
1718         {
1719                 .cmd = NFC_CMD_DEV_DOWN,
1720                 .doit = nfc_genl_dev_down,
1721                 .policy = nfc_genl_policy,
1722         },
1723         {
1724                 .cmd = NFC_CMD_START_POLL,
1725                 .doit = nfc_genl_start_poll,
1726                 .policy = nfc_genl_policy,
1727         },
1728         {
1729                 .cmd = NFC_CMD_STOP_POLL,
1730                 .doit = nfc_genl_stop_poll,
1731                 .policy = nfc_genl_policy,
1732         },
1733         {
1734                 .cmd = NFC_CMD_DEP_LINK_UP,
1735                 .doit = nfc_genl_dep_link_up,
1736                 .policy = nfc_genl_policy,
1737         },
1738         {
1739                 .cmd = NFC_CMD_DEP_LINK_DOWN,
1740                 .doit = nfc_genl_dep_link_down,
1741                 .policy = nfc_genl_policy,
1742         },
1743         {
1744                 .cmd = NFC_CMD_GET_TARGET,
1745                 .dumpit = nfc_genl_dump_targets,
1746                 .done = nfc_genl_dump_targets_done,
1747                 .policy = nfc_genl_policy,
1748         },
1749         {
1750                 .cmd = NFC_CMD_LLC_GET_PARAMS,
1751                 .doit = nfc_genl_llc_get_params,
1752                 .policy = nfc_genl_policy,
1753         },
1754         {
1755                 .cmd = NFC_CMD_LLC_SET_PARAMS,
1756                 .doit = nfc_genl_llc_set_params,
1757                 .policy = nfc_genl_policy,
1758         },
1759         {
1760                 .cmd = NFC_CMD_LLC_SDREQ,
1761                 .doit = nfc_genl_llc_sdreq,
1762                 .policy = nfc_genl_policy,
1763         },
1764         {
1765                 .cmd = NFC_CMD_FW_DOWNLOAD,
1766                 .doit = nfc_genl_fw_download,
1767                 .policy = nfc_genl_policy,
1768         },
1769         {
1770                 .cmd = NFC_CMD_ENABLE_SE,
1771                 .doit = nfc_genl_enable_se,
1772                 .policy = nfc_genl_policy,
1773         },
1774         {
1775                 .cmd = NFC_CMD_DISABLE_SE,
1776                 .doit = nfc_genl_disable_se,
1777                 .policy = nfc_genl_policy,
1778         },
1779         {
1780                 .cmd = NFC_CMD_GET_SE,
1781                 .dumpit = nfc_genl_dump_ses,
1782                 .done = nfc_genl_dump_ses_done,
1783                 .policy = nfc_genl_policy,
1784         },
1785         {
1786                 .cmd = NFC_CMD_SE_IO,
1787                 .doit = nfc_genl_se_io,
1788                 .policy = nfc_genl_policy,
1789         },
1790         {
1791                 .cmd = NFC_CMD_ACTIVATE_TARGET,
1792                 .doit = nfc_genl_activate_target,
1793                 .policy = nfc_genl_policy,
1794         },
1795         {
1796                 .cmd = NFC_CMD_VENDOR,
1797                 .doit = nfc_genl_vendor_cmd,
1798                 .policy = nfc_genl_policy,
1799         },
1800         {
1801                 .cmd = NFC_CMD_DEACTIVATE_TARGET,
1802                 .doit = nfc_genl_deactivate_target,
1803                 .policy = nfc_genl_policy,
1804         },
1805 };
1806
1807 static struct genl_family nfc_genl_family __ro_after_init = {
1808         .hdrsize = 0,
1809         .name = NFC_GENL_NAME,
1810         .version = NFC_GENL_VERSION,
1811         .maxattr = NFC_ATTR_MAX,
1812         .module = THIS_MODULE,
1813         .ops = nfc_genl_ops,
1814         .n_ops = ARRAY_SIZE(nfc_genl_ops),
1815         .mcgrps = nfc_genl_mcgrps,
1816         .n_mcgrps = ARRAY_SIZE(nfc_genl_mcgrps),
1817 };
1818
1819
1820 struct urelease_work {
1821         struct  work_struct w;
1822         u32     portid;
1823 };
1824
1825 static void nfc_urelease_event_work(struct work_struct *work)
1826 {
1827         struct urelease_work *w = container_of(work, struct urelease_work, w);
1828         struct class_dev_iter iter;
1829         struct nfc_dev *dev;
1830
1831         pr_debug("portid %d\n", w->portid);
1832
1833         mutex_lock(&nfc_devlist_mutex);
1834
1835         nfc_device_iter_init(&iter);
1836         dev = nfc_device_iter_next(&iter);
1837
1838         while (dev) {
1839                 mutex_lock(&dev->genl_data.genl_data_mutex);
1840
1841                 if (dev->genl_data.poll_req_portid == w->portid) {
1842                         nfc_stop_poll(dev);
1843                         dev->genl_data.poll_req_portid = 0;
1844                 }
1845
1846                 mutex_unlock(&dev->genl_data.genl_data_mutex);
1847
1848                 dev = nfc_device_iter_next(&iter);
1849         }
1850
1851         nfc_device_iter_exit(&iter);
1852
1853         mutex_unlock(&nfc_devlist_mutex);
1854
1855         kfree(w);
1856 }
1857
1858 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1859                                  unsigned long event, void *ptr)
1860 {
1861         struct netlink_notify *n = ptr;
1862         struct urelease_work *w;
1863
1864         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1865                 goto out;
1866
1867         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1868
1869         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1870         if (w) {
1871                 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1872                 w->portid = n->portid;
1873                 schedule_work((struct work_struct *) w);
1874         }
1875
1876 out:
1877         return NOTIFY_DONE;
1878 }
1879
1880 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1881 {
1882         genl_data->poll_req_portid = 0;
1883         mutex_init(&genl_data->genl_data_mutex);
1884 }
1885
1886 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1887 {
1888         mutex_destroy(&genl_data->genl_data_mutex);
1889 }
1890
1891 static struct notifier_block nl_notifier = {
1892         .notifier_call  = nfc_genl_rcv_nl_event,
1893 };
1894
1895 /**
1896  * nfc_genl_init() - Initialize netlink interface
1897  *
1898  * This initialization function registers the nfc netlink family.
1899  */
1900 int __init nfc_genl_init(void)
1901 {
1902         int rc;
1903
1904         rc = genl_register_family(&nfc_genl_family);
1905         if (rc)
1906                 return rc;
1907
1908         netlink_register_notifier(&nl_notifier);
1909
1910         return 0;
1911 }
1912
1913 /**
1914  * nfc_genl_exit() - Deinitialize netlink interface
1915  *
1916  * This exit function unregisters the nfc netlink family.
1917  */
1918 void nfc_genl_exit(void)
1919 {
1920         netlink_unregister_notifier(&nl_notifier);
1921         genl_unregister_family(&nfc_genl_family);
1922 }