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