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