net/nfc/netlink.c

   1 /*
   2  * Copyright (C) 2011 Instituto Nokia de Tecnologia
   3  *
   4  * Authors:
   5  *    Lauro Ramos Venancio <[email protected]>
   6  *    Aloisio Almeida Jr <[email protected]>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
  23
  24 #include <net/genetlink.h>
  25 #include <linux/nfc.h>
  26 #include <linux/slab.h>
  27
  28 #include "nfc.h"
  29 #include "llcp.h"
  30
  31 static const struct genl_multicast_group nfc_genl_mcgrps[] = {
  32         { .name = NFC_GENL_MCAST_EVENT_NAME, },
  33 };
  34
  35 static struct genl_family nfc_genl_family = {
  36         .id = GENL_ID_GENERATE,
  37         .hdrsize = 0,
  38         .name = NFC_GENL_NAME,
  39         .version = NFC_GENL_VERSION,
  40         .maxattr = NFC_ATTR_MAX,
  41 };
  42
  43 static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
  44         [NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
  45         [NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
  46                                 .len = NFC_DEVICE_NAME_MAXSIZE },
  47         [NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
  48         [NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
  49         [NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
  50         [NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
  51         [NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
  52         [NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
  53         [NFC_ATTR_LLC_PARAM_LTO] = { .type = NLA_U8 },
  54         [NFC_ATTR_LLC_PARAM_RW] = { .type = NLA_U8 },
  55         [NFC_ATTR_LLC_PARAM_MIUX] = { .type = NLA_U16 },
  56         [NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
  57         [NFC_ATTR_FIRMWARE_NAME] = { .type = NLA_STRING,
  58                                      .len = NFC_FIRMWARE_NAME_MAXSIZE },
  59         [NFC_ATTR_SE_APDU] = { .type = NLA_BINARY },
  60 };
  61
  62 static const struct nla_policy nfc_sdp_genl_policy[NFC_SDP_ATTR_MAX + 1] = {
  63         [NFC_SDP_ATTR_URI] = { .type = NLA_STRING },
  64         [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
  65 };
  66
  67 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
  68                                 struct netlink_callback *cb, int flags)
  69 {
  70         void *hdr;
  71
  72         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  73                           &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
  74         if (!hdr)
  75                 return -EMSGSIZE;
  76
  77         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
  78
  79         if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
  80             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
  81             nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
  82             nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
  83                 goto nla_put_failure;
  84         if (target->nfcid1_len > 0 &&
  85             nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
  86                     target->nfcid1))
  87                 goto nla_put_failure;
  88         if (target->sensb_res_len > 0 &&
  89             nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
  90                     target->sensb_res))
  91                 goto nla_put_failure;
  92         if (target->sensf_res_len > 0 &&
  93             nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
  94                     target->sensf_res))
  95                 goto nla_put_failure;
  96
  97         if (target->is_iso15693) {
  98                 if (nla_put_u8(msg, NFC_ATTR_TARGET_ISO15693_DSFID,
  99                                target->iso15693_dsfid) ||
 100                     nla_put(msg, NFC_ATTR_TARGET_ISO15693_UID,
 101                             sizeof(target->iso15693_uid), target->iso15693_uid))
 102                         goto nla_put_failure;
 103         }
 104
 105         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_activate_target(struct sk_buff *skb, struct genl_info *info)
 814 {
 815         struct nfc_dev *dev;
 816         u32 device_idx, target_idx, protocol;
 817         int rc;
 818
 819         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 820                 return -EINVAL;
 821
 822         device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 823
 824         dev = nfc_get_device(device_idx);
 825         if (!dev)
 826                 return -ENODEV;
 827
 828         target_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
 829         protocol = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
 830
 831         nfc_deactivate_target(dev, target_idx);
 832         rc = nfc_activate_target(dev, target_idx, protocol);
 833
 834         nfc_put_device(dev);
 835         return 0;
 836 }
 837
 838 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
 839 {
 840         struct nfc_dev *dev;
 841         int rc, tgt_idx;
 842         u32 idx;
 843         u8 comm;
 844
 845         pr_debug("DEP link up\n");
 846
 847         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 848             !info->attrs[NFC_ATTR_COMM_MODE])
 849                 return -EINVAL;
 850
 851         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 852         if (!info->attrs[NFC_ATTR_TARGET_INDEX])
 853                 tgt_idx = NFC_TARGET_IDX_ANY;
 854         else
 855                 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
 856
 857         comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
 858
 859         if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
 860                 return -EINVAL;
 861
 862         dev = nfc_get_device(idx);
 863         if (!dev)
 864                 return -ENODEV;
 865
 866         rc = nfc_dep_link_up(dev, tgt_idx, comm);
 867
 868         nfc_put_device(dev);
 869
 870         return rc;
 871 }
 872
 873 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
 874 {
 875         struct nfc_dev *dev;
 876         int rc;
 877         u32 idx;
 878
 879         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 880                 return -EINVAL;
 881
 882         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 883
 884         dev = nfc_get_device(idx);
 885         if (!dev)
 886                 return -ENODEV;
 887
 888         rc = nfc_dep_link_down(dev);
 889
 890         nfc_put_device(dev);
 891         return rc;
 892 }
 893
 894 static int nfc_genl_send_params(struct sk_buff *msg,
 895                                 struct nfc_llcp_local *local,
 896                                 u32 portid, u32 seq)
 897 {
 898         void *hdr;
 899
 900         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
 901                           NFC_CMD_LLC_GET_PARAMS);
 902         if (!hdr)
 903                 return -EMSGSIZE;
 904
 905         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
 906             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
 907             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
 908             nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
 909                 goto nla_put_failure;
 910
 911         return genlmsg_end(msg, hdr);
 912
 913 nla_put_failure:
 914
 915         genlmsg_cancel(msg, hdr);
 916         return -EMSGSIZE;
 917 }
 918
 919 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
 920 {
 921         struct nfc_dev *dev;
 922         struct nfc_llcp_local *local;
 923         int rc = 0;
 924         struct sk_buff *msg = NULL;
 925         u32 idx;
 926
 927         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 928                 return -EINVAL;
 929
 930         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 931
 932         dev = nfc_get_device(idx);
 933         if (!dev)
 934                 return -ENODEV;
 935
 936         device_lock(&dev->dev);
 937
 938         local = nfc_llcp_find_local(dev);
 939         if (!local) {
 940                 rc = -ENODEV;
 941                 goto exit;
 942         }
 943
 944         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 945         if (!msg) {
 946                 rc = -ENOMEM;
 947                 goto exit;
 948         }
 949
 950         rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
 951
 952 exit:
 953         device_unlock(&dev->dev);
 954
 955         nfc_put_device(dev);
 956
 957         if (rc < 0) {
 958                 if (msg)
 959                         nlmsg_free(msg);
 960
 961                 return rc;
 962         }
 963
 964         return genlmsg_reply(msg, info);
 965 }
 966
 967 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
 968 {
 969         struct nfc_dev *dev;
 970         struct nfc_llcp_local *local;
 971         u8 rw = 0;
 972         u16 miux = 0;
 973         u32 idx;
 974         int rc = 0;
 975
 976         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 977             (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
 978              !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
 979              !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
 980                 return -EINVAL;
 981
 982         if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
 983                 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
 984
 985                 if (rw > LLCP_MAX_RW)
 986                         return -EINVAL;
 987         }
 988
 989         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
 990                 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
 991
 992                 if (miux > LLCP_MAX_MIUX)
 993                         return -EINVAL;
 994         }
 995
 996         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 997
 998         dev = nfc_get_device(idx);
 999         if (!dev)
1000                 return -ENODEV;
1001
1002         device_lock(&dev->dev);
1003
1004         local = nfc_llcp_find_local(dev);
1005         if (!local) {
1006                 nfc_put_device(dev);
1007                 rc = -ENODEV;
1008                 goto exit;
1009         }
1010
1011         if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
1012                 if (dev->dep_link_up) {
1013                         rc = -EINPROGRESS;
1014                         goto exit;
1015                 }
1016
1017                 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
1018         }
1019
1020         if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
1021                 local->rw = rw;
1022
1023         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
1024                 local->miux = cpu_to_be16(miux);
1025
1026 exit:
1027         device_unlock(&dev->dev);
1028
1029         nfc_put_device(dev);
1030
1031         return rc;
1032 }
1033
1034 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
1035 {
1036         struct nfc_dev *dev;
1037         struct nfc_llcp_local *local;
1038         struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
1039         u32 idx;
1040         u8 tid;
1041         char *uri;
1042         int rc = 0, rem;
1043         size_t uri_len, tlvs_len;
1044         struct hlist_head sdreq_list;
1045         struct nfc_llcp_sdp_tlv *sdreq;
1046
1047         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1048             !info->attrs[NFC_ATTR_LLC_SDP])
1049                 return -EINVAL;
1050
1051         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1052
1053         dev = nfc_get_device(idx);
1054         if (!dev) {
1055                 rc = -ENODEV;
1056                 goto exit;
1057         }
1058
1059         device_lock(&dev->dev);
1060
1061         if (dev->dep_link_up == false) {
1062                 rc = -ENOLINK;
1063                 goto exit;
1064         }
1065
1066         local = nfc_llcp_find_local(dev);
1067         if (!local) {
1068                 nfc_put_device(dev);
1069                 rc = -ENODEV;
1070                 goto exit;
1071         }
1072
1073         INIT_HLIST_HEAD(&sdreq_list);
1074
1075         tlvs_len = 0;
1076
1077         nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
1078                 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
1079                                       nfc_sdp_genl_policy);
1080
1081                 if (rc != 0) {
1082                         rc = -EINVAL;
1083                         goto exit;
1084                 }
1085
1086                 if (!sdp_attrs[NFC_SDP_ATTR_URI])
1087                         continue;
1088
1089                 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
1090                 if (uri_len == 0)
1091                         continue;
1092
1093                 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
1094                 if (uri == NULL || *uri == 0)
1095                         continue;
1096
1097                 tid = local->sdreq_next_tid++;
1098
1099                 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1100                 if (sdreq == NULL) {
1101                         rc = -ENOMEM;
1102                         goto exit;
1103                 }
1104
1105                 tlvs_len += sdreq->tlv_len;
1106
1107                 hlist_add_head(&sdreq->node, &sdreq_list);
1108         }
1109
1110         if (hlist_empty(&sdreq_list)) {
1111                 rc = -EINVAL;
1112                 goto exit;
1113         }
1114
1115         rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1116 exit:
1117         device_unlock(&dev->dev);
1118
1119         nfc_put_device(dev);
1120
1121         return rc;
1122 }
1123
1124 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info)
1125 {
1126         struct nfc_dev *dev;
1127         int rc;
1128         u32 idx;
1129         char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1];
1130
1131         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
1132                 return -EINVAL;
1133
1134         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1135
1136         dev = nfc_get_device(idx);
1137         if (!dev)
1138                 return -ENODEV;
1139
1140         nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME],
1141                     sizeof(firmware_name));
1142
1143         rc = nfc_fw_download(dev, firmware_name);
1144
1145         nfc_put_device(dev);
1146         return rc;
1147 }
1148
1149 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name,
1150                               u32 result)
1151 {
1152         struct sk_buff *msg;
1153         void *hdr;
1154
1155         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1156         if (!msg)
1157                 return -ENOMEM;
1158
1159         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1160                           NFC_CMD_FW_DOWNLOAD);
1161         if (!hdr)
1162                 goto free_msg;
1163
1164         if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) ||
1165             nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) ||
1166             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
1167                 goto nla_put_failure;
1168
1169         genlmsg_end(msg, hdr);
1170
1171         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1172
1173         return 0;
1174
1175 nla_put_failure:
1176         genlmsg_cancel(msg, hdr);
1177 free_msg:
1178         nlmsg_free(msg);
1179         return -EMSGSIZE;
1180 }
1181
1182 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info)
1183 {
1184         struct nfc_dev *dev;
1185         int rc;
1186         u32 idx, se_idx;
1187
1188         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1189             !info->attrs[NFC_ATTR_SE_INDEX])
1190                 return -EINVAL;
1191
1192         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1193         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1194
1195         dev = nfc_get_device(idx);
1196         if (!dev)
1197                 return -ENODEV;
1198
1199         rc = nfc_enable_se(dev, se_idx);
1200
1201         nfc_put_device(dev);
1202         return rc;
1203 }
1204
1205 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info)
1206 {
1207         struct nfc_dev *dev;
1208         int rc;
1209         u32 idx, se_idx;
1210
1211         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1212             !info->attrs[NFC_ATTR_SE_INDEX])
1213                 return -EINVAL;
1214
1215         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1216         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1217
1218         dev = nfc_get_device(idx);
1219         if (!dev)
1220                 return -ENODEV;
1221
1222         rc = nfc_disable_se(dev, se_idx);
1223
1224         nfc_put_device(dev);
1225         return rc;
1226 }
1227
1228 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev,
1229                                 u32 portid, u32 seq,
1230                                 struct netlink_callback *cb,
1231                                 int flags)
1232 {
1233         void *hdr;
1234         struct nfc_se *se, *n;
1235
1236         list_for_each_entry_safe(se, n, &dev->secure_elements, list) {
1237                 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
1238                                   NFC_CMD_GET_SE);
1239                 if (!hdr)
1240                         goto nla_put_failure;
1241
1242                 if (cb)
1243                         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
1244
1245                 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
1246                     nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) ||
1247                     nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type))
1248                         goto nla_put_failure;
1249
1250                 if (genlmsg_end(msg, hdr) < 0)
1251                         goto nla_put_failure;
1252         }
1253
1254         return 0;
1255
1256 nla_put_failure:
1257         genlmsg_cancel(msg, hdr);
1258         return -EMSGSIZE;
1259 }
1260
1261 static int nfc_genl_dump_ses(struct sk_buff *skb,
1262                                  struct netlink_callback *cb)
1263 {
1264         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1265         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
1266         bool first_call = false;
1267
1268         if (!iter) {
1269                 first_call = true;
1270                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
1271                 if (!iter)
1272                         return -ENOMEM;
1273                 cb->args[0] = (long) iter;
1274         }
1275
1276         mutex_lock(&nfc_devlist_mutex);
1277
1278         cb->seq = nfc_devlist_generation;
1279
1280         if (first_call) {
1281                 nfc_device_iter_init(iter);
1282                 dev = nfc_device_iter_next(iter);
1283         }
1284
1285         while (dev) {
1286                 int rc;
1287
1288                 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid,
1289                                           cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
1290                 if (rc < 0)
1291                         break;
1292
1293                 dev = nfc_device_iter_next(iter);
1294         }
1295
1296         mutex_unlock(&nfc_devlist_mutex);
1297
1298         cb->args[1] = (long) dev;
1299
1300         return skb->len;
1301 }
1302
1303 static int nfc_genl_dump_ses_done(struct netlink_callback *cb)
1304 {
1305         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
1306
1307         nfc_device_iter_exit(iter);
1308         kfree(iter);
1309
1310         return 0;
1311 }
1312
1313 static int nfc_se_io(struct nfc_dev *dev, u32 se_idx,
1314                      u8 *apdu, size_t apdu_length,
1315                      se_io_cb_t cb, void *cb_context)
1316 {
1317         struct nfc_se *se;
1318         int rc;
1319
1320         pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx);
1321
1322         device_lock(&dev->dev);
1323
1324         if (!device_is_registered(&dev->dev)) {
1325                 rc = -ENODEV;
1326                 goto error;
1327         }
1328
1329         if (!dev->dev_up) {
1330                 rc = -ENODEV;
1331                 goto error;
1332         }
1333
1334         if (!dev->ops->se_io) {
1335                 rc = -EOPNOTSUPP;
1336                 goto error;
1337         }
1338
1339         se = nfc_find_se(dev, se_idx);
1340         if (!se) {
1341                 rc = -EINVAL;
1342                 goto error;
1343         }
1344
1345         if (se->state != NFC_SE_ENABLED) {
1346                 rc = -ENODEV;
1347                 goto error;
1348         }
1349
1350         rc = dev->ops->se_io(dev, se_idx, apdu,
1351                         apdu_length, cb, cb_context);
1352
1353 error:
1354         device_unlock(&dev->dev);
1355         return rc;
1356 }
1357
1358 struct se_io_ctx {
1359         u32 dev_idx;
1360         u32 se_idx;
1361 };
1362
1363 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err)
1364 {
1365         struct se_io_ctx *ctx = context;
1366         struct sk_buff *msg;
1367         void *hdr;
1368
1369         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1370         if (!msg) {
1371                 kfree(ctx);
1372                 return;
1373         }
1374
1375         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
1376                           NFC_CMD_SE_IO);
1377         if (!hdr)
1378                 goto free_msg;
1379
1380         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) ||
1381             nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) ||
1382             nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu))
1383                 goto nla_put_failure;
1384
1385         genlmsg_end(msg, hdr);
1386
1387         genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL);
1388
1389         kfree(ctx);
1390
1391         return;
1392
1393 nla_put_failure:
1394         genlmsg_cancel(msg, hdr);
1395 free_msg:
1396         nlmsg_free(msg);
1397         kfree(ctx);
1398
1399         return;
1400 }
1401
1402 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info)
1403 {
1404         struct nfc_dev *dev;
1405         struct se_io_ctx *ctx;
1406         u32 dev_idx, se_idx;
1407         u8 *apdu;
1408         size_t apdu_len;
1409
1410         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
1411             !info->attrs[NFC_ATTR_SE_INDEX] ||
1412             !info->attrs[NFC_ATTR_SE_APDU])
1413                 return -EINVAL;
1414
1415         dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
1416         se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]);
1417
1418         dev = nfc_get_device(dev_idx);
1419         if (!dev)
1420                 return -ENODEV;
1421
1422         if (!dev->ops || !dev->ops->se_io)
1423                 return -ENOTSUPP;
1424
1425         apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]);
1426         if (apdu_len == 0)
1427                 return -EINVAL;
1428
1429         apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]);
1430         if (!apdu)
1431                 return -EINVAL;
1432
1433         ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL);
1434         if (!ctx)
1435                 return -ENOMEM;
1436
1437         ctx->dev_idx = dev_idx;
1438         ctx->se_idx = se_idx;
1439
1440         return nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx);
1441 }
1442
1443 static const struct genl_ops nfc_genl_ops[] = {
1444         {
1445                 .cmd = NFC_CMD_GET_DEVICE,
1446                 .doit = nfc_genl_get_device,
1447                 .dumpit = nfc_genl_dump_devices,
1448                 .done = nfc_genl_dump_devices_done,
1449                 .policy = nfc_genl_policy,
1450         },
1451         {
1452                 .cmd = NFC_CMD_DEV_UP,
1453                 .doit = nfc_genl_dev_up,
1454                 .policy = nfc_genl_policy,
1455         },
1456         {
1457                 .cmd = NFC_CMD_DEV_DOWN,
1458                 .doit = nfc_genl_dev_down,
1459                 .policy = nfc_genl_policy,
1460         },
1461         {
1462                 .cmd = NFC_CMD_START_POLL,
1463                 .doit = nfc_genl_start_poll,
1464                 .policy = nfc_genl_policy,
1465         },
1466         {
1467                 .cmd = NFC_CMD_STOP_POLL,
1468                 .doit = nfc_genl_stop_poll,
1469                 .policy = nfc_genl_policy,
1470         },
1471         {
1472                 .cmd = NFC_CMD_DEP_LINK_UP,
1473                 .doit = nfc_genl_dep_link_up,
1474                 .policy = nfc_genl_policy,
1475         },
1476         {
1477                 .cmd = NFC_CMD_DEP_LINK_DOWN,
1478                 .doit = nfc_genl_dep_link_down,
1479                 .policy = nfc_genl_policy,
1480         },
1481         {
1482                 .cmd = NFC_CMD_GET_TARGET,
1483                 .dumpit = nfc_genl_dump_targets,
1484                 .done = nfc_genl_dump_targets_done,
1485                 .policy = nfc_genl_policy,
1486         },
1487         {
1488                 .cmd = NFC_CMD_LLC_GET_PARAMS,
1489                 .doit = nfc_genl_llc_get_params,
1490                 .policy = nfc_genl_policy,
1491         },
1492         {
1493                 .cmd = NFC_CMD_LLC_SET_PARAMS,
1494                 .doit = nfc_genl_llc_set_params,
1495                 .policy = nfc_genl_policy,
1496         },
1497         {
1498                 .cmd = NFC_CMD_LLC_SDREQ,
1499                 .doit = nfc_genl_llc_sdreq,
1500                 .policy = nfc_genl_policy,
1501         },
1502         {
1503                 .cmd = NFC_CMD_FW_DOWNLOAD,
1504                 .doit = nfc_genl_fw_download,
1505                 .policy = nfc_genl_policy,
1506         },
1507         {
1508                 .cmd = NFC_CMD_ENABLE_SE,
1509                 .doit = nfc_genl_enable_se,
1510                 .policy = nfc_genl_policy,
1511         },
1512         {
1513                 .cmd = NFC_CMD_DISABLE_SE,
1514                 .doit = nfc_genl_disable_se,
1515                 .policy = nfc_genl_policy,
1516         },
1517         {
1518                 .cmd = NFC_CMD_GET_SE,
1519                 .dumpit = nfc_genl_dump_ses,
1520                 .done = nfc_genl_dump_ses_done,
1521                 .policy = nfc_genl_policy,
1522         },
1523         {
1524                 .cmd = NFC_CMD_SE_IO,
1525                 .doit = nfc_genl_se_io,
1526                 .policy = nfc_genl_policy,
1527         },
1528         {
1529                 .cmd = NFC_CMD_ACTIVATE_TARGET,
1530                 .doit = nfc_genl_activate_target,
1531                 .policy = nfc_genl_policy,
1532         },
1533 };
1534
1535
1536 struct urelease_work {
1537         struct  work_struct w;
1538         int     portid;
1539 };
1540
1541 static void nfc_urelease_event_work(struct work_struct *work)
1542 {
1543         struct urelease_work *w = container_of(work, struct urelease_work, w);
1544         struct class_dev_iter iter;
1545         struct nfc_dev *dev;
1546
1547         pr_debug("portid %d\n", w->portid);
1548
1549         mutex_lock(&nfc_devlist_mutex);
1550
1551         nfc_device_iter_init(&iter);
1552         dev = nfc_device_iter_next(&iter);
1553
1554         while (dev) {
1555                 mutex_lock(&dev->genl_data.genl_data_mutex);
1556
1557                 if (dev->genl_data.poll_req_portid == w->portid) {
1558                         nfc_stop_poll(dev);
1559                         dev->genl_data.poll_req_portid = 0;
1560                 }
1561
1562                 mutex_unlock(&dev->genl_data.genl_data_mutex);
1563
1564                 dev = nfc_device_iter_next(&iter);
1565         }
1566
1567         nfc_device_iter_exit(&iter);
1568
1569         mutex_unlock(&nfc_devlist_mutex);
1570
1571         kfree(w);
1572 }
1573
1574 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1575                                  unsigned long event, void *ptr)
1576 {
1577         struct netlink_notify *n = ptr;
1578         struct urelease_work *w;
1579
1580         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1581                 goto out;
1582
1583         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1584
1585         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1586         if (w) {
1587                 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1588                 w->portid = n->portid;
1589                 schedule_work((struct work_struct *) w);
1590         }
1591
1592 out:
1593         return NOTIFY_DONE;
1594 }
1595
1596 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1597 {
1598         genl_data->poll_req_portid = 0;
1599         mutex_init(&genl_data->genl_data_mutex);
1600 }
1601
1602 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1603 {
1604         mutex_destroy(&genl_data->genl_data_mutex);
1605 }
1606
1607 static struct notifier_block nl_notifier = {
1608         .notifier_call  = nfc_genl_rcv_nl_event,
1609 };
1610
1611 /**
1612  * nfc_genl_init() - Initialize netlink interface
1613  *
1614  * This initialization function registers the nfc netlink family.
1615  */
1616 int __init nfc_genl_init(void)
1617 {
1618         int rc;
1619
1620         rc = genl_register_family_with_ops_groups(&nfc_genl_family,
1621                                                   nfc_genl_ops,
1622                                                   nfc_genl_mcgrps);
1623         if (rc)
1624                 return rc;
1625
1626         netlink_register_notifier(&nl_notifier);
1627
1628         return 0;
1629 }
1630
1631 /**
1632  * nfc_genl_exit() - Deinitialize netlink interface
1633  *
1634  * This exit function unregisters the nfc netlink family.
1635  */
1636 void nfc_genl_exit(void)
1637 {
1638         netlink_unregister_notifier(&nl_notifier);
1639         genl_unregister_family(&nfc_genl_family);
1640 }