net/nfc/netlink.c

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