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