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  * 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                                .len = U8_MAX - 4 },
  65         [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
  66 };
  67
  68 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
  69                                 struct netlink_callback *cb, int flags)
  70 {
  71         void *hdr;
  72
  73         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  74                           &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
  75         if (!hdr)
  76                 return -EMSGSIZE;
  77
  78         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
  79
  80         if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
  81             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
  82             nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
  83             nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
  84                 goto nla_put_failure;
  85         if (target->nfcid1_len > 0 &&
  86             nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
  87                     target->nfcid1))
  88                 goto nla_put_failure;
  89         if (target->sensb_res_len > 0 &&
  90             nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
  91                     target->sensb_res))
  92                 goto nla_put_failure;
  93         if (target->sensf_res_len > 0 &&
  94             nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
  95                     target->sensf_res))
  96                 goto nla_put_failure;
  97
  98         if (target->is_iso15693) {
  99                 if (nla_put_u8(msg, NFC_ATTR_TARGET_ISO15693_DSFID,
 100                                target->iso15693_dsfid) ||
 101                     nla_put(msg, NFC_ATTR_TARGET_ISO15693_UID,
 102                             sizeof(target->iso15693_uid), target->iso15693_uid))
 103                         goto nla_put_failure;
 104         }
 105
 106         return genlmsg_end(msg, hdr);
 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 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
 501                                 u32 portid, u32 seq,
 502                                 struct netlink_callback *cb,
 503                                 int flags)
 504 {
 505         void *hdr;
 506
 507         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
 508                           NFC_CMD_GET_DEVICE);
 509         if (!hdr)
 510                 return -EMSGSIZE;
 511
 512         if (cb)
 513                 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
 514
 515         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 516             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
 517             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
 518             nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
 519             nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
 520                 goto nla_put_failure;
 521
 522         return genlmsg_end(msg, hdr);
 523
 524 nla_put_failure:
 525         genlmsg_cancel(msg, hdr);
 526         return -EMSGSIZE;
 527 }
 528
 529 static int nfc_genl_dump_devices(struct sk_buff *skb,
 530                                  struct netlink_callback *cb)
 531 {
 532         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 533         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 534         bool first_call = false;
 535
 536         if (!iter) {
 537                 first_call = true;
 538                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
 539                 if (!iter)
 540                         return -ENOMEM;
 541                 cb->args[0] = (long) iter;
 542         }
 543
 544         mutex_lock(&nfc_devlist_mutex);
 545
 546         cb->seq = nfc_devlist_generation;
 547
 548         if (first_call) {
 549                 nfc_device_iter_init(iter);
 550                 dev = nfc_device_iter_next(iter);
 551         }
 552
 553         while (dev) {
 554                 int rc;
 555
 556                 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
 557                                           cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
 558                 if (rc < 0)
 559                         break;
 560
 561                 dev = nfc_device_iter_next(iter);
 562         }
 563
 564         mutex_unlock(&nfc_devlist_mutex);
 565
 566         cb->args[1] = (long) dev;
 567
 568         return skb->len;
 569 }
 570
 571 static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
 572 {
 573         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 574
 575         nfc_device_iter_exit(iter);
 576         kfree(iter);
 577
 578         return 0;
 579 }
 580
 581 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
 582                                u8 comm_mode, u8 rf_mode)
 583 {
 584         struct sk_buff *msg;
 585         void *hdr;
 586
 587         pr_debug("DEP link is up\n");
 588
 589         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 590         if (!msg)
 591                 return -ENOMEM;
 592
 593         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
 594         if (!hdr)
 595                 goto free_msg;
 596
 597         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 598                 goto nla_put_failure;
 599         if (rf_mode == NFC_RF_INITIATOR &&
 600             nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
 601                 goto nla_put_failure;
 602         if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
 603             nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
 604                 goto nla_put_failure;
 605
 606         genlmsg_end(msg, hdr);
 607
 608         dev->dep_link_up = true;
 609
 610         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
 611
 612         return 0;
 613
 614 nla_put_failure:
 615         genlmsg_cancel(msg, hdr);
 616 free_msg:
 617         nlmsg_free(msg);
 618         return -EMSGSIZE;
 619 }
 620
 621 int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
 622 {
 623         struct sk_buff *msg;
 624         void *hdr;
 625
 626         pr_debug("DEP link is down\n");
 627
 628         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 629         if (!msg)
 630                 return -ENOMEM;
 631
 632         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 633                           NFC_CMD_DEP_LINK_DOWN);
 634         if (!hdr)
 635                 goto free_msg;
 636
 637         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 638                 goto nla_put_failure;
 639
 640         genlmsg_end(msg, hdr);
 641
 642         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
 643
 644         return 0;
 645
 646 nla_put_failure:
 647         genlmsg_cancel(msg, hdr);
 648 free_msg:
 649         nlmsg_free(msg);
 650         return -EMSGSIZE;
 651 }
 652
 653 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
 654 {
 655         struct sk_buff *msg;
 656         struct nfc_dev *dev;
 657         u32 idx;
 658         int rc = -ENOBUFS;
 659
 660         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 661                 return -EINVAL;
 662
 663         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 664
 665         dev = nfc_get_device(idx);
 666         if (!dev)
 667                 return -ENODEV;
 668
 669         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 670         if (!msg) {
 671                 rc = -ENOMEM;
 672                 goto out_putdev;
 673         }
 674
 675         rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
 676                                   NULL, 0);
 677         if (rc < 0)
 678                 goto out_free;
 679
 680         nfc_put_device(dev);
 681
 682         return genlmsg_reply(msg, info);
 683
 684 out_free:
 685         nlmsg_free(msg);
 686 out_putdev:
 687         nfc_put_device(dev);
 688         return rc;
 689 }
 690
 691 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
 692 {
 693         struct nfc_dev *dev;
 694         int rc;
 695         u32 idx;
 696
 697         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 698                 return -EINVAL;
 699
 700         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 701
 702         dev = nfc_get_device(idx);
 703         if (!dev)
 704                 return -ENODEV;
 705
 706         rc = nfc_dev_up(dev);
 707
 708         nfc_put_device(dev);
 709         return rc;
 710 }
 711
 712 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
 713 {
 714         struct nfc_dev *dev;
 715         int rc;
 716         u32 idx;
 717
 718         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 719                 return -EINVAL;
 720
 721         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 722
 723         dev = nfc_get_device(idx);
 724         if (!dev)
 725                 return -ENODEV;
 726
 727         rc = nfc_dev_down(dev);
 728
 729         nfc_put_device(dev);
 730         return rc;
 731 }
 732
 733 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
 734 {
 735         struct nfc_dev *dev;
 736         int rc;
 737         u32 idx;
 738         u32 im_protocols = 0, tm_protocols = 0;
 739
 740         pr_debug("Poll start\n");
 741
 742         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 743             ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
 744               !info->attrs[NFC_ATTR_PROTOCOLS]) &&
 745               !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
 746                 return -EINVAL;
 747
 748         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 749
 750         if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
 751                 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
 752
 753         if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
 754                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
 755         else if (info->attrs[NFC_ATTR_PROTOCOLS])
 756                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
 757
 758         dev = nfc_get_device(idx);
 759         if (!dev)
 760                 return -ENODEV;
 761
 762         mutex_lock(&dev->genl_data.genl_data_mutex);
 763
 764         rc = nfc_start_poll(dev, im_protocols, tm_protocols);
 765         if (!rc)
 766                 dev->genl_data.poll_req_portid = info->snd_portid;
 767
 768         mutex_unlock(&dev->genl_data.genl_data_mutex);
 769
 770         nfc_put_device(dev);
 771         return rc;
 772 }
 773
 774 static int nfc_genl_stop_poll(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         device_lock(&dev->dev);
 790
 791         if (!dev->polling) {
 792                 device_unlock(&dev->dev);
 793                 return -EINVAL;
 794         }
 795
 796         device_unlock(&dev->dev);
 797
 798         mutex_lock(&dev->genl_data.genl_data_mutex);
 799
 800         if (dev->genl_data.poll_req_portid != info->snd_portid) {
 801                 rc = -EBUSY;
 802                 goto out;
 803         }
 804
 805         rc = nfc_stop_poll(dev);
 806         dev->genl_data.poll_req_portid = 0;
 807
 808 out:
 809         mutex_unlock(&dev->genl_data.genl_data_mutex);
 810         nfc_put_device(dev);
 811         return rc;
 812 }
 813
 814 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
 815 {
 816         struct nfc_dev *dev;
 817         int rc, tgt_idx;
 818         u32 idx;
 819         u8 comm;
 820
 821         pr_debug("DEP link up\n");
 822
 823         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 824             !info->attrs[NFC_ATTR_COMM_MODE])
 825                 return -EINVAL;
 826
 827         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 828         if (!info->attrs[NFC_ATTR_TARGET_INDEX])
 829                 tgt_idx = NFC_TARGET_IDX_ANY;
 830         else
 831                 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
 832
 833         comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
 834
 835         if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
 836                 return -EINVAL;
 837
 838         dev = nfc_get_device(idx);
 839         if (!dev)
 840                 return -ENODEV;
 841
 842         rc = nfc_dep_link_up(dev, tgt_idx, comm);
 843
 844         nfc_put_device(dev);
 845
 846         return rc;
 847 }
 848
 849 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
 850 {
 851         struct nfc_dev *dev;
 852         int rc;
 853         u32 idx;
 854
 855         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 856                 return -EINVAL;
 857
 858         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 859
 860         dev = nfc_get_device(idx);
 861         if (!dev)
 862                 return -ENODEV;
 863
 864         rc = nfc_dep_link_down(dev);
 865
 866         nfc_put_device(dev);
 867         return rc;
 868 }
 869
 870 static int nfc_genl_send_params(struct sk_buff *msg,
 871                                 struct nfc_llcp_local *local,
 872                                 u32 portid, u32 seq)
 873 {
 874         void *hdr;
 875
 876         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
 877                           NFC_CMD_LLC_GET_PARAMS);
 878         if (!hdr)
 879                 return -EMSGSIZE;
 880
 881         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
 882             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
 883             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
 884             nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
 885                 goto nla_put_failure;
 886
 887         return genlmsg_end(msg, hdr);
 888
 889 nla_put_failure:
 890
 891         genlmsg_cancel(msg, hdr);
 892         return -EMSGSIZE;
 893 }
 894
 895 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
 896 {
 897         struct nfc_dev *dev;
 898         struct nfc_llcp_local *local;
 899         int rc = 0;
 900         struct sk_buff *msg = NULL;
 901         u32 idx;
 902
 903         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 904                 return -EINVAL;
 905
 906         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 907
 908         dev = nfc_get_device(idx);
 909         if (!dev)
 910                 return -ENODEV;
 911
 912         device_lock(&dev->dev);
 913
 914         local = nfc_llcp_find_local(dev);
 915         if (!local) {
 916                 rc = -ENODEV;
 917                 goto exit;
 918         }
 919
 920         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 921         if (!msg) {
 922                 rc = -ENOMEM;
 923                 goto exit;
 924         }
 925
 926         rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
 927
 928 exit:
 929         device_unlock(&dev->dev);
 930
 931         nfc_put_device(dev);
 932
 933         if (rc < 0) {
 934                 if (msg)
 935                         nlmsg_free(msg);
 936
 937                 return rc;
 938         }
 939
 940         return genlmsg_reply(msg, info);
 941 }
 942
 943 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
 944 {
 945         struct nfc_dev *dev;
 946         struct nfc_llcp_local *local;
 947         u8 rw = 0;
 948         u16 miux = 0;
 949         u32 idx;
 950         int rc = 0;
 951
 952         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 953             (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
 954              !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
 955              !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
 956                 return -EINVAL;
 957
 958         if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
 959                 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
 960
 961                 if (rw > LLCP_MAX_RW)
 962                         return -EINVAL;
 963         }
 964
 965         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
 966                 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
 967
 968                 if (miux > LLCP_MAX_MIUX)
 969                         return -EINVAL;
 970         }
 971
 972         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 973
 974         dev = nfc_get_device(idx);
 975         if (!dev)
 976                 return -ENODEV;
 977
 978         device_lock(&dev->dev);
 979
 980         local = nfc_llcp_find_local(dev);
 981         if (!local) {
 982                 nfc_put_device(dev);
 983                 rc = -ENODEV;
 984                 goto exit;
 985         }
 986
 987         if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
 988                 if (dev->dep_link_up) {
 989                         rc = -EINPROGRESS;
 990                         goto exit;
 991                 }
 992
 993                 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
 994         }
 995
 996         if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
 997                 local->rw = rw;
 998
 999         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
1000                 local->miux = cpu_to_be16(miux);
1001
1002 exit:
1003         device_unlock(&dev->dev);
1004
1005         nfc_put_device(dev);
1006
1007         return rc;
1008 }
1009
1010 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1011 {
1012         struct nfc_dev *dev;
1013         struct nfc_llcp_local *local;
1014         struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1015         u32 idx;
1016         u8 tid;
1017         char *uri;
1018         int rc = 0, rem;
1019         size_t uri_len, tlvs_len;
1020         struct hlist_head sdreq_list;
1021         struct nfc_llcp_sdp_tlv *sdreq;
1022
1023         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1024             !info->attrs[NFC_ATTR_LLC_SDP])
1025                 return -EINVAL;
1026
1027         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1028
1029         dev = nfc_get_device(idx);
1030         if (!dev) {
1031                 rc = -ENODEV;
1032                 goto exit;
1033         }
1034
1035         device_lock(&dev->dev);
1036
1037         if (dev->dep_link_up == false) {
1038                 rc = -ENOLINK;
1039                 goto exit;
1040         }
1041
1042         local = nfc_llcp_find_local(dev);
1043         if (!local) {
1044                 nfc_put_device(dev);
1045                 rc = -ENODEV;
1046                 goto exit;
1047         }
1048
1049         INIT_HLIST_HEAD(&sdreq_list);
1050
1051         tlvs_len = 0;
1052
1053         nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1054                 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
1055                                       nfc_sdp_genl_policy);
1056
1057                 if (rc != 0) {
1058                         rc = -EINVAL;
1059                         goto exit;
1060                 }
1061
1062                 if (!sdp_attrs[NFC_SDP_ATTR_URI])
1063                         continue;
1064
1065                 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1066                 if (uri_len == 0)
1067                         continue;
1068
1069                 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1070                 if (uri == NULL || *uri == 0)
1071                         continue;
1072
1073                 tid = local->sdreq_next_tid++;
1074
1075                 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1076                 if (sdreq == NULL) {
1077                         rc = -ENOMEM;
1078                         goto exit;
1079                 }
1080
1081                 tlvs_len += sdreq->tlv_len;
1082
1083                 hlist_add_head(&sdreq->node, &sdreq_list);
1084         }
1085
1086         if (hlist_empty(&sdreq_list)) {
1087                 rc = -EINVAL;
1088                 goto exit;
1089         }
1090
1091         rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1092 exit:
1093         device_unlock(&dev->dev);
1094
1095         nfc_put_device(dev);
1096
1097         return rc;
1098 }
1099
1100 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
1101 {
1102         struct nfc_dev *dev;
1103         int rc;
1104         u32 idx;
1105         char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1106
1107         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
1108                 return -EINVAL;
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         nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1117                     sizeof(firmware_name));
1118
1119         rc = nfc_fw_download(dev, firmware_name);
1120
1121         nfc_put_device(dev);
1122         return rc;
1123 }
1124
1125 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1126                               u32 result)
1127 {
1128         struct sk_buff *msg;
1129         void *hdr;
1130
1131         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1132         if (!msg)
1133                 return -ENOMEM;
1134
1135         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1136                           NFC_CMD_FW_DOWNLOAD);
1137         if (!hdr)
1138                 goto free_msg;
1139
1140         if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
1141             nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
1142             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1143                 goto nla_put_failure;
1144
1145         genlmsg_end(msg, hdr);
1146
1147         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1148
1149         return 0;
1150
1151 nla_put_failure:
1152         genlmsg_cancel(msg, hdr);
1153 free_msg:
1154         nlmsg_free(msg);
1155         return -EMSGSIZE;
1156 }
1157
1158 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1159 {
1160         struct nfc_dev *dev;
1161         int rc;
1162         u32 idx, se_idx;
1163
1164         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1165             !info->attrs[NFC_ATTR_SE_INDEX])
1166                 return -EINVAL;
1167
1168         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1169         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1170
1171         dev = nfc_get_device(idx);
1172         if (!dev)
1173                 return -ENODEV;
1174
1175         rc = nfc_enable_se(dev, se_idx);
1176
1177         nfc_put_device(dev);
1178         return rc;
1179 }
1180
1181 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1182 {
1183         struct nfc_dev *dev;
1184         int rc;
1185         u32 idx, se_idx;
1186
1187         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1188             !info->attrs[NFC_ATTR_SE_INDEX])
1189                 return -EINVAL;
1190
1191         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1192         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1193
1194         dev = nfc_get_device(idx);
1195         if (!dev)
1196                 return -ENODEV;
1197
1198         rc = nfc_disable_se(dev, se_idx);
1199
1200         nfc_put_device(dev);
1201         return rc;
1202 }
1203
1204 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1205                                 u32 portid, u32 seq,
1206                                 struct netlink_callback *cb,
1207                                 int flags)
1208 {
1209         void *hdr;
1210         struct nfc_se *se, *n;
1211
1212         list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1213                 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1214                                   NFC_CMD_GET_SE);
1215                 if (!hdr)
1216                         goto nla_put_failure;
1217
1218                 if (cb)
1219                         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
1220
1221                 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1222                     nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1223                     nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1224                         goto nla_put_failure;
1225
1226                 if (genlmsg_end(msg, hdr) < 0)
1227                         goto nla_put_failure;
1228         }
1229
1230         return 0;
1231
1232 nla_put_failure:
1233         genlmsg_cancel(msg, hdr);
1234         return -EMSGSIZE;
1235 }
1236
1237 static int nfc_genl_dump_ses(struct sk_buff *skb,
1238                                  struct netlink_callback *cb)
1239 {
1240         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1241         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1242         bool first_call = false;
1243
1244         if (!iter) {
1245                 first_call = true;
1246                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1247                 if (!iter)
1248                         return -ENOMEM;
1249                 cb->args[0] = (long) iter;
1250         }
1251
1252         mutex_lock(&nfc_devlist_mutex);
1253
1254         cb->seq = nfc_devlist_generation;
1255
1256         if (first_call) {
1257                 nfc_device_iter_init(iter);
1258                 dev = nfc_device_iter_next(iter);
1259         }
1260
1261         while (dev) {
1262                 int rc;
1263
1264                 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1265                                           cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1266                 if (rc < 0)
1267                         break;
1268
1269                 dev = nfc_device_iter_next(iter);
1270         }
1271
1272         mutex_unlock(&nfc_devlist_mutex);
1273
1274         cb->args[1] = (long) dev;
1275
1276         return skb->len;
1277 }
1278
1279 static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1280 {
1281         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1282
1283         nfc_device_iter_exit(iter);
1284         kfree(iter);
1285
1286         return 0;
1287 }
1288
1289 struct se_io_ctx {
1290         u32 dev_idx;
1291         u32 se_idx;
1292 };
1293
1294 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1295 {
1296         struct se_io_ctx *ctx = context;
1297         struct sk_buff *msg;
1298         void *hdr;
1299
1300         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1301         if (!msg) {
1302                 kfree(ctx);
1303                 return;
1304         }
1305
1306         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1307                           NFC_CMD_SE_IO);
1308         if (!hdr)
1309                 goto free_msg;
1310
1311         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1312             nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1313             nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1314                 goto nla_put_failure;
1315
1316         genlmsg_end(msg, hdr);
1317
1318         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1319
1320         kfree(ctx);
1321
1322         return;
1323
1324 nla_put_failure:
1325         genlmsg_cancel(msg, hdr);
1326 free_msg:
1327         nlmsg_free(msg);
1328         kfree(ctx);
1329
1330         return;
1331 }
1332
1333 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1334 {
1335         struct nfc_dev *dev;
1336         struct se_io_ctx *ctx;
1337         u32 dev_idx, se_idx;
1338         u8 *apdu;
1339         size_t apdu_len;
1340
1341         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1342             !info->attrs[NFC_ATTR_SE_INDEX] ||
1343             !info->attrs[NFC_ATTR_SE_APDU])
1344                 return -EINVAL;
1345
1346         dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1347         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1348
1349         dev = nfc_get_device(dev_idx);
1350         if (!dev)
1351                 return -ENODEV;
1352
1353         if (!dev->ops || !dev->ops->se_io)
1354                 return -ENOTSUPP;
1355
1356         apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1357         if (apdu_len == 0)
1358                 return -EINVAL;
1359
1360         apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1361         if (!apdu)
1362                 return -EINVAL;
1363
1364         ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1365         if (!ctx)
1366                 return -ENOMEM;
1367
1368         ctx->dev_idx = dev_idx;
1369         ctx->se_idx = se_idx;
1370
1371         return dev->ops->se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1372 }
1373
1374 static const struct genl_ops nfc_genl_ops[] = {
1375         {
1376                 .cmd = NFC_CMD_GET_DEVICE,
1377                 .doit = nfc_genl_get_device,
1378                 .dumpit = nfc_genl_dump_devices,
1379                 .done = nfc_genl_dump_devices_done,
1380                 .policy = nfc_genl_policy,
1381         },
1382         {
1383                 .cmd = NFC_CMD_DEV_UP,
1384                 .doit = nfc_genl_dev_up,
1385                 .policy = nfc_genl_policy,
1386         },
1387         {
1388                 .cmd = NFC_CMD_DEV_DOWN,
1389                 .doit = nfc_genl_dev_down,
1390                 .policy = nfc_genl_policy,
1391         },
1392         {
1393                 .cmd = NFC_CMD_START_POLL,
1394                 .doit = nfc_genl_start_poll,
1395                 .policy = nfc_genl_policy,
1396         },
1397         {
1398                 .cmd = NFC_CMD_STOP_POLL,
1399                 .doit = nfc_genl_stop_poll,
1400                 .policy = nfc_genl_policy,
1401         },
1402         {
1403                 .cmd = NFC_CMD_DEP_LINK_UP,
1404                 .doit = nfc_genl_dep_link_up,
1405                 .policy = nfc_genl_policy,
1406         },
1407         {
1408                 .cmd = NFC_CMD_DEP_LINK_DOWN,
1409                 .doit = nfc_genl_dep_link_down,
1410                 .policy = nfc_genl_policy,
1411         },
1412         {
1413                 .cmd = NFC_CMD_GET_TARGET,
1414                 .dumpit = nfc_genl_dump_targets,
1415                 .done = nfc_genl_dump_targets_done,
1416                 .policy = nfc_genl_policy,
1417         },
1418         {
1419                 .cmd = NFC_CMD_LLC_GET_PARAMS,
1420                 .doit = nfc_genl_llc_get_params,
1421                 .policy = nfc_genl_policy,
1422         },
1423         {
1424                 .cmd = NFC_CMD_LLC_SET_PARAMS,
1425                 .doit = nfc_genl_llc_set_params,
1426                 .policy = nfc_genl_policy,
1427         },
1428         {
1429                 .cmd = NFC_CMD_LLC_SDREQ,
1430                 .doit = nfc_genl_llc_sdreq,
1431                 .policy = nfc_genl_policy,
1432         },
1433         {
1434                 .cmd = NFC_CMD_FW_DOWNLOAD,
1435                 .doit = nfc_genl_fw_download,
1436                 .policy = nfc_genl_policy,
1437         },
1438         {
1439                 .cmd = NFC_CMD_ENABLE_SE,
1440                 .doit = nfc_genl_enable_se,
1441                 .policy = nfc_genl_policy,
1442         },
1443         {
1444                 .cmd = NFC_CMD_DISABLE_SE,
1445                 .doit = nfc_genl_disable_se,
1446                 .policy = nfc_genl_policy,
1447         },
1448         {
1449                 .cmd = NFC_CMD_GET_SE,
1450                 .dumpit = nfc_genl_dump_ses,
1451                 .done = nfc_genl_dump_ses_done,
1452                 .policy = nfc_genl_policy,
1453         },
1454         {
1455                 .cmd = NFC_CMD_SE_IO,
1456                 .doit = nfc_genl_se_io,
1457                 .policy = nfc_genl_policy,
1458         },
1459 };
1460
1461
1462 struct urelease_work {
1463         struct  work_struct w;
1464         int     portid;
1465 };
1466
1467 static void nfc_urelease_event_work(struct work_struct *work)
1468 {
1469         struct urelease_work *w = container_of(work, struct urelease_work, w);
1470         struct class_dev_iter iter;
1471         struct nfc_dev *dev;
1472
1473         pr_debug("portid %d\n", w->portid);
1474
1475         mutex_lock(&nfc_devlist_mutex);
1476
1477         nfc_device_iter_init(&iter);
1478         dev = nfc_device_iter_next(&iter);
1479
1480         while (dev) {
1481                 mutex_lock(&dev->genl_data.genl_data_mutex);
1482
1483                 if (dev->genl_data.poll_req_portid == w->portid) {
1484                         nfc_stop_poll(dev);
1485                         dev->genl_data.poll_req_portid = 0;
1486                 }
1487
1488                 mutex_unlock(&dev->genl_data.genl_data_mutex);
1489
1490                 dev = nfc_device_iter_next(&iter);
1491         }
1492
1493         nfc_device_iter_exit(&iter);
1494
1495         mutex_unlock(&nfc_devlist_mutex);
1496
1497         kfree(w);
1498 }
1499
1500 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1501                                  unsigned long event, void *ptr)
1502 {
1503         struct netlink_notify *n = ptr;
1504         struct urelease_work *w;
1505
1506         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1507                 goto out;
1508
1509         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1510
1511         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1512         if (w) {
1513                 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1514                 w->portid = n->portid;
1515                 schedule_work((struct work_struct *) w);
1516         }
1517
1518 out:
1519         return NOTIFY_DONE;
1520 }
1521
1522 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1523 {
1524         genl_data->poll_req_portid = 0;
1525         mutex_init(&genl_data->genl_data_mutex);
1526 }
1527
1528 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1529 {
1530         mutex_destroy(&genl_data->genl_data_mutex);
1531 }
1532
1533 static struct notifier_block nl_notifier = {
1534         .notifier_call  = nfc_genl_rcv_nl_event,
1535 };
1536
1537 /**
1538  * nfc_genl_init() - Initialize netlink interface
1539  *
1540  * This initialization function registers the nfc netlink family.
1541  */
1542 int __init nfc_genl_init(void)
1543 {
1544         int rc;
1545
1546         rc = genl_register_family_with_ops_groups(&nfc_genl_family,
1547                                                   nfc_genl_ops,
1548                                                   nfc_genl_mcgrps);
1549         if (rc)
1550                 return rc;
1551
1552         netlink_register_notifier(&nl_notifier);
1553
1554         return 0;
1555 }
1556
1557 /**
1558  * nfc_genl_exit() - Deinitialize netlink interface
1559  *
1560  * This exit function unregisters the nfc netlink family.
1561  */
1562 void nfc_genl_exit(void)
1563 {
1564         netlink_unregister_notifier(&nl_notifier);
1565         genl_unregister_family(&nfc_genl_family);
1566 }