net/nfc/netlink.c

   1 /*
   2  * Copyright (C) 2011 Instituto Nokia de Tecnologia
   3  *
   4  * Authors:
   5  *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
   6  *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the
  20  * Free Software Foundation, Inc.,
  21  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22  */
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
  25
  26 #include <net/genetlink.h>
  27 #include <linux/nfc.h>
  28 #include <linux/slab.h>
  29
  30 #include "nfc.h"
  31
  32 #include "llcp/llcp.h"
  33
  34 static struct genl_multicast_group nfc_genl_event_mcgrp = {
  35         .name = NFC_GENL_MCAST_EVENT_NAME,
  36 };
  37
  38 static struct genl_family nfc_genl_family = {
  39         .id = GENL_ID_GENERATE,
  40         .hdrsize = 0,
  41         .name = NFC_GENL_NAME,
  42         .version = NFC_GENL_VERSION,
  43         .maxattr = NFC_ATTR_MAX,
  44 };
  45
  46 static const struct nla_policy nfc_genl_policy[NFC_ATTR_MAX + 1] = {
  47         [NFC_ATTR_DEVICE_INDEX] = { .type = NLA_U32 },
  48         [NFC_ATTR_DEVICE_NAME] = { .type = NLA_STRING,
  49                                 .len = NFC_DEVICE_NAME_MAXSIZE },
  50         [NFC_ATTR_PROTOCOLS] = { .type = NLA_U32 },
  51         [NFC_ATTR_COMM_MODE] = { .type = NLA_U8 },
  52         [NFC_ATTR_RF_MODE] = { .type = NLA_U8 },
  53         [NFC_ATTR_DEVICE_POWERED] = { .type = NLA_U8 },
  54         [NFC_ATTR_IM_PROTOCOLS] = { .type = NLA_U32 },
  55         [NFC_ATTR_TM_PROTOCOLS] = { .type = NLA_U32 },
  56         [NFC_ATTR_LLC_PARAM_LTO] = { .type = NLA_U8 },
  57         [NFC_ATTR_LLC_PARAM_RW] = { .type = NLA_U8 },
  58         [NFC_ATTR_LLC_PARAM_MIUX] = { .type = NLA_U16 },
  59         [NFC_ATTR_LLC_SDP] = { .type = NLA_NESTED },
  60 };
  61
  62 static const struct nla_policy nfc_sdp_genl_policy[NFC_SDP_ATTR_MAX + 1] = {
  63         [NFC_SDP_ATTR_URI] = { .type = NLA_STRING },
  64         [NFC_SDP_ATTR_SAP] = { .type = NLA_U8 },
  65 };
  66
  67 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
  68                                 struct netlink_callback *cb, int flags)
  69 {
  70         void *hdr;
  71
  72         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  73                           &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
  74         if (!hdr)
  75                 return -EMSGSIZE;
  76
  77         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
  78
  79         if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
  80             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
  81             nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
  82             nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
  83                 goto nla_put_failure;
  84         if (target->nfcid1_len > 0 &&
  85             nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
  86                     target->nfcid1))
  87                 goto nla_put_failure;
  88         if (target->sensb_res_len > 0 &&
  89             nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
  90                     target->sensb_res))
  91                 goto nla_put_failure;
  92         if (target->sensf_res_len > 0 &&
  93             nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
  94                     target->sensf_res))
  95                 goto nla_put_failure;
  96
  97         return genlmsg_end(msg, hdr);
  98
  99 nla_put_failure:
 100         genlmsg_cancel(msg, hdr);
 101         return -EMSGSIZE;
 102 }
 103
 104 static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
 105 {
 106         struct nfc_dev *dev;
 107         int rc;
 108         u32 idx;
 109
 110         rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
 111                          nfc_genl_family.attrbuf,
 112                          nfc_genl_family.maxattr,
 113                          nfc_genl_policy);
 114         if (rc < 0)
 115                 return ERR_PTR(rc);
 116
 117         if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
 118                 return ERR_PTR(-EINVAL);
 119
 120         idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
 121
 122         dev = nfc_get_device(idx);
 123         if (!dev)
 124                 return ERR_PTR(-ENODEV);
 125
 126         return dev;
 127 }
 128
 129 static int nfc_genl_dump_targets(struct sk_buff *skb,
 130                                  struct netlink_callback *cb)
 131 {
 132         int i = cb->args[0];
 133         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 134         int rc;
 135
 136         if (!dev) {
 137                 dev = __get_device_from_cb(cb);
 138                 if (IS_ERR(dev))
 139                         return PTR_ERR(dev);
 140
 141                 cb->args[1] = (long) dev;
 142         }
 143
 144         device_lock(&dev->dev);
 145
 146         cb->seq = dev->targets_generation;
 147
 148         while (i < dev->n_targets) {
 149                 rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
 150                                           NLM_F_MULTI);
 151                 if (rc < 0)
 152                         break;
 153
 154                 i++;
 155         }
 156
 157         device_unlock(&dev->dev);
 158
 159         cb->args[0] = i;
 160
 161         return skb->len;
 162 }
 163
 164 static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
 165 {
 166         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 167
 168         if (dev)
 169                 nfc_put_device(dev);
 170
 171         return 0;
 172 }
 173
 174 int nfc_genl_targets_found(struct nfc_dev *dev)
 175 {
 176         struct sk_buff *msg;
 177         void *hdr;
 178
 179         dev->genl_data.poll_req_portid = 0;
 180
 181         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 182         if (!msg)
 183                 return -ENOMEM;
 184
 185         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 186                           NFC_EVENT_TARGETS_FOUND);
 187         if (!hdr)
 188                 goto free_msg;
 189
 190         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 191                 goto nla_put_failure;
 192
 193         genlmsg_end(msg, hdr);
 194
 195         return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 196
 197 nla_put_failure:
 198         genlmsg_cancel(msg, hdr);
 199 free_msg:
 200         nlmsg_free(msg);
 201         return -EMSGSIZE;
 202 }
 203
 204 int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
 205 {
 206         struct sk_buff *msg;
 207         void *hdr;
 208
 209         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 210         if (!msg)
 211                 return -ENOMEM;
 212
 213         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 214                           NFC_EVENT_TARGET_LOST);
 215         if (!hdr)
 216                 goto free_msg;
 217
 218         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 219             nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
 220                 goto nla_put_failure;
 221
 222         genlmsg_end(msg, hdr);
 223
 224         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 225
 226         return 0;
 227
 228 nla_put_failure:
 229         genlmsg_cancel(msg, hdr);
 230 free_msg:
 231         nlmsg_free(msg);
 232         return -EMSGSIZE;
 233 }
 234
 235 int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
 236 {
 237         struct sk_buff *msg;
 238         void *hdr;
 239
 240         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 241         if (!msg)
 242                 return -ENOMEM;
 243
 244         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 245                           NFC_EVENT_TM_ACTIVATED);
 246         if (!hdr)
 247                 goto free_msg;
 248
 249         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 250                 goto nla_put_failure;
 251         if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
 252                 goto nla_put_failure;
 253
 254         genlmsg_end(msg, hdr);
 255
 256         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 257
 258         return 0;
 259
 260 nla_put_failure:
 261         genlmsg_cancel(msg, hdr);
 262 free_msg:
 263         nlmsg_free(msg);
 264         return -EMSGSIZE;
 265 }
 266
 267 int nfc_genl_tm_deactivated(struct nfc_dev *dev)
 268 {
 269         struct sk_buff *msg;
 270         void *hdr;
 271
 272         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 273         if (!msg)
 274                 return -ENOMEM;
 275
 276         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 277                           NFC_EVENT_TM_DEACTIVATED);
 278         if (!hdr)
 279                 goto free_msg;
 280
 281         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 282                 goto nla_put_failure;
 283
 284         genlmsg_end(msg, hdr);
 285
 286         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 287
 288         return 0;
 289
 290 nla_put_failure:
 291         genlmsg_cancel(msg, hdr);
 292 free_msg:
 293         nlmsg_free(msg);
 294         return -EMSGSIZE;
 295 }
 296
 297 int nfc_genl_device_added(struct nfc_dev *dev)
 298 {
 299         struct sk_buff *msg;
 300         void *hdr;
 301
 302         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 303         if (!msg)
 304                 return -ENOMEM;
 305
 306         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 307                           NFC_EVENT_DEVICE_ADDED);
 308         if (!hdr)
 309                 goto free_msg;
 310
 311         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 312             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
 313             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
 314             nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
 315                 goto nla_put_failure;
 316
 317         genlmsg_end(msg, hdr);
 318
 319         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 320
 321         return 0;
 322
 323 nla_put_failure:
 324         genlmsg_cancel(msg, hdr);
 325 free_msg:
 326         nlmsg_free(msg);
 327         return -EMSGSIZE;
 328 }
 329
 330 int nfc_genl_device_removed(struct nfc_dev *dev)
 331 {
 332         struct sk_buff *msg;
 333         void *hdr;
 334
 335         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 336         if (!msg)
 337                 return -ENOMEM;
 338
 339         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 340                           NFC_EVENT_DEVICE_REMOVED);
 341         if (!hdr)
 342                 goto free_msg;
 343
 344         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 345                 goto nla_put_failure;
 346
 347         genlmsg_end(msg, hdr);
 348
 349         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 350
 351         return 0;
 352
 353 nla_put_failure:
 354         genlmsg_cancel(msg, hdr);
 355 free_msg:
 356         nlmsg_free(msg);
 357         return -EMSGSIZE;
 358 }
 359
 360 int nfc_genl_llc_send_sdres(struct nfc_dev *dev, struct hlist_head *sdres_list)
 361 {
 362         struct sk_buff *msg;
 363         struct nlattr *sdp_attr, *uri_attr;
 364         struct nfc_llcp_sdp_tlv *sdres;
 365         struct hlist_node *n;
 366         void *hdr;
 367         int rc = -EMSGSIZE;
 368         int i;
 369
 370         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 371         if (!msg)
 372                 return -ENOMEM;
 373
 374         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 375                           NFC_EVENT_LLC_SDRES);
 376         if (!hdr)
 377                 goto free_msg;
 378
 379         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 380                 goto nla_put_failure;
 381
 382         sdp_attr = nla_nest_start(msg, NFC_ATTR_LLC_SDP);
 383         if (sdp_attr == NULL) {
 384                 rc = -ENOMEM;
 385                 goto nla_put_failure;
 386         }
 387
 388         i = 1;
 389         hlist_for_each_entry_safe(sdres, n, sdres_list, node) {
 390                 pr_debug("uri: %s, sap: %d\n", sdres->uri, sdres->sap);
 391
 392                 uri_attr = nla_nest_start(msg, i++);
 393                 if (uri_attr == NULL) {
 394                         rc = -ENOMEM;
 395                         goto nla_put_failure;
 396                 }
 397
 398                 if (nla_put_u8(msg, NFC_SDP_ATTR_SAP, sdres->sap))
 399                         goto nla_put_failure;
 400
 401                 if (nla_put_string(msg, NFC_SDP_ATTR_URI, sdres->uri))
 402                         goto nla_put_failure;
 403
 404                 nla_nest_end(msg, uri_attr);
 405
 406                 hlist_del(&sdres->node);
 407
 408                 nfc_llcp_free_sdp_tlv(sdres);
 409         }
 410
 411         nla_nest_end(msg, sdp_attr);
 412
 413         genlmsg_end(msg, hdr);
 414
 415         return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 416
 417 nla_put_failure:
 418         genlmsg_cancel(msg, hdr);
 419
 420 free_msg:
 421         nlmsg_free(msg);
 422
 423         nfc_llcp_free_sdp_tlv_list(sdres_list);
 424
 425         return rc;
 426 }
 427
 428 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
 429                                 u32 portid, u32 seq,
 430                                 struct netlink_callback *cb,
 431                                 int flags)
 432 {
 433         void *hdr;
 434
 435         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
 436                           NFC_CMD_GET_DEVICE);
 437         if (!hdr)
 438                 return -EMSGSIZE;
 439
 440         if (cb)
 441                 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
 442
 443         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 444             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
 445             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
 446             nla_put_u32(msg, NFC_ATTR_SE, dev->supported_se) ||
 447             nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
 448             nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
 449                 goto nla_put_failure;
 450
 451         return genlmsg_end(msg, hdr);
 452
 453 nla_put_failure:
 454         genlmsg_cancel(msg, hdr);
 455         return -EMSGSIZE;
 456 }
 457
 458 static int nfc_genl_dump_devices(struct sk_buff *skb,
 459                                  struct netlink_callback *cb)
 460 {
 461         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 462         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 463         bool first_call = false;
 464
 465         if (!iter) {
 466                 first_call = true;
 467                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
 468                 if (!iter)
 469                         return -ENOMEM;
 470                 cb->args[0] = (long) iter;
 471         }
 472
 473         mutex_lock(&nfc_devlist_mutex);
 474
 475         cb->seq = nfc_devlist_generation;
 476
 477         if (first_call) {
 478                 nfc_device_iter_init(iter);
 479                 dev = nfc_device_iter_next(iter);
 480         }
 481
 482         while (dev) {
 483                 int rc;
 484
 485                 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
 486                                           cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
 487                 if (rc < 0)
 488                         break;
 489
 490                 dev = nfc_device_iter_next(iter);
 491         }
 492
 493         mutex_unlock(&nfc_devlist_mutex);
 494
 495         cb->args[1] = (long) dev;
 496
 497         return skb->len;
 498 }
 499
 500 static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
 501 {
 502         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 503
 504         nfc_device_iter_exit(iter);
 505         kfree(iter);
 506
 507         return 0;
 508 }
 509
 510 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
 511                                u8 comm_mode, u8 rf_mode)
 512 {
 513         struct sk_buff *msg;
 514         void *hdr;
 515
 516         pr_debug("DEP link is up\n");
 517
 518         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 519         if (!msg)
 520                 return -ENOMEM;
 521
 522         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
 523         if (!hdr)
 524                 goto free_msg;
 525
 526         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 527                 goto nla_put_failure;
 528         if (rf_mode == NFC_RF_INITIATOR &&
 529             nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
 530                 goto nla_put_failure;
 531         if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
 532             nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
 533                 goto nla_put_failure;
 534
 535         genlmsg_end(msg, hdr);
 536
 537         dev->dep_link_up = true;
 538
 539         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 540
 541         return 0;
 542
 543 nla_put_failure:
 544         genlmsg_cancel(msg, hdr);
 545 free_msg:
 546         nlmsg_free(msg);
 547         return -EMSGSIZE;
 548 }
 549
 550 int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
 551 {
 552         struct sk_buff *msg;
 553         void *hdr;
 554
 555         pr_debug("DEP link is down\n");
 556
 557         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 558         if (!msg)
 559                 return -ENOMEM;
 560
 561         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 562                           NFC_CMD_DEP_LINK_DOWN);
 563         if (!hdr)
 564                 goto free_msg;
 565
 566         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 567                 goto nla_put_failure;
 568
 569         genlmsg_end(msg, hdr);
 570
 571         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 572
 573         return 0;
 574
 575 nla_put_failure:
 576         genlmsg_cancel(msg, hdr);
 577 free_msg:
 578         nlmsg_free(msg);
 579         return -EMSGSIZE;
 580 }
 581
 582 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
 583 {
 584         struct sk_buff *msg;
 585         struct nfc_dev *dev;
 586         u32 idx;
 587         int rc = -ENOBUFS;
 588
 589         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 590                 return -EINVAL;
 591
 592         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 593
 594         dev = nfc_get_device(idx);
 595         if (!dev)
 596                 return -ENODEV;
 597
 598         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 599         if (!msg) {
 600                 rc = -ENOMEM;
 601                 goto out_putdev;
 602         }
 603
 604         rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
 605                                   NULL, 0);
 606         if (rc < 0)
 607                 goto out_free;
 608
 609         nfc_put_device(dev);
 610
 611         return genlmsg_reply(msg, info);
 612
 613 out_free:
 614         nlmsg_free(msg);
 615 out_putdev:
 616         nfc_put_device(dev);
 617         return rc;
 618 }
 619
 620 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
 621 {
 622         struct nfc_dev *dev;
 623         int rc;
 624         u32 idx;
 625
 626         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 627                 return -EINVAL;
 628
 629         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 630
 631         dev = nfc_get_device(idx);
 632         if (!dev)
 633                 return -ENODEV;
 634
 635         rc = nfc_dev_up(dev);
 636
 637         nfc_put_device(dev);
 638         return rc;
 639 }
 640
 641 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
 642 {
 643         struct nfc_dev *dev;
 644         int rc;
 645         u32 idx;
 646
 647         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 648                 return -EINVAL;
 649
 650         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 651
 652         dev = nfc_get_device(idx);
 653         if (!dev)
 654                 return -ENODEV;
 655
 656         rc = nfc_dev_down(dev);
 657
 658         nfc_put_device(dev);
 659         return rc;
 660 }
 661
 662 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
 663 {
 664         struct nfc_dev *dev;
 665         int rc;
 666         u32 idx;
 667         u32 im_protocols = 0, tm_protocols = 0;
 668
 669         pr_debug("Poll start\n");
 670
 671         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 672             ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
 673               !info->attrs[NFC_ATTR_PROTOCOLS]) &&
 674               !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
 675                 return -EINVAL;
 676
 677         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 678
 679         if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
 680                 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
 681
 682         if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
 683                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
 684         else if (info->attrs[NFC_ATTR_PROTOCOLS])
 685                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
 686
 687         dev = nfc_get_device(idx);
 688         if (!dev)
 689                 return -ENODEV;
 690
 691         mutex_lock(&dev->genl_data.genl_data_mutex);
 692
 693         rc = nfc_start_poll(dev, im_protocols, tm_protocols);
 694         if (!rc)
 695                 dev->genl_data.poll_req_portid = info->snd_portid;
 696
 697         mutex_unlock(&dev->genl_data.genl_data_mutex);
 698
 699         nfc_put_device(dev);
 700         return rc;
 701 }
 702
 703 static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
 704 {
 705         struct nfc_dev *dev;
 706         int rc;
 707         u32 idx;
 708
 709         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 710                 return -EINVAL;
 711
 712         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 713
 714         dev = nfc_get_device(idx);
 715         if (!dev)
 716                 return -ENODEV;
 717
 718         device_lock(&dev->dev);
 719
 720         if (!dev->polling) {
 721                 device_unlock(&dev->dev);
 722                 return -EINVAL;
 723         }
 724
 725         device_unlock(&dev->dev);
 726
 727         mutex_lock(&dev->genl_data.genl_data_mutex);
 728
 729         if (dev->genl_data.poll_req_portid != info->snd_portid) {
 730                 rc = -EBUSY;
 731                 goto out;
 732         }
 733
 734         rc = nfc_stop_poll(dev);
 735         dev->genl_data.poll_req_portid = 0;
 736
 737 out:
 738         mutex_unlock(&dev->genl_data.genl_data_mutex);
 739         nfc_put_device(dev);
 740         return rc;
 741 }
 742
 743 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
 744 {
 745         struct nfc_dev *dev;
 746         int rc, tgt_idx;
 747         u32 idx;
 748         u8 comm;
 749
 750         pr_debug("DEP link up\n");
 751
 752         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 753             !info->attrs[NFC_ATTR_COMM_MODE])
 754                 return -EINVAL;
 755
 756         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 757         if (!info->attrs[NFC_ATTR_TARGET_INDEX])
 758                 tgt_idx = NFC_TARGET_IDX_ANY;
 759         else
 760                 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
 761
 762         comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
 763
 764         if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
 765                 return -EINVAL;
 766
 767         dev = nfc_get_device(idx);
 768         if (!dev)
 769                 return -ENODEV;
 770
 771         rc = nfc_dep_link_up(dev, tgt_idx, comm);
 772
 773         nfc_put_device(dev);
 774
 775         return rc;
 776 }
 777
 778 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
 779 {
 780         struct nfc_dev *dev;
 781         int rc;
 782         u32 idx;
 783
 784         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 785                 return -EINVAL;
 786
 787         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 788
 789         dev = nfc_get_device(idx);
 790         if (!dev)
 791                 return -ENODEV;
 792
 793         rc = nfc_dep_link_down(dev);
 794
 795         nfc_put_device(dev);
 796         return rc;
 797 }
 798
 799 static int nfc_genl_send_params(struct sk_buff *msg,
 800                                 struct nfc_llcp_local *local,
 801                                 u32 portid, u32 seq)
 802 {
 803         void *hdr;
 804
 805         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
 806                           NFC_CMD_LLC_GET_PARAMS);
 807         if (!hdr)
 808                 return -EMSGSIZE;
 809
 810         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
 811             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
 812             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
 813             nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
 814                 goto nla_put_failure;
 815
 816         return genlmsg_end(msg, hdr);
 817
 818 nla_put_failure:
 819
 820         genlmsg_cancel(msg, hdr);
 821         return -EMSGSIZE;
 822 }
 823
 824 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
 825 {
 826         struct nfc_dev *dev;
 827         struct nfc_llcp_local *local;
 828         int rc = 0;
 829         struct sk_buff *msg = NULL;
 830         u32 idx;
 831
 832         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 833                 return -EINVAL;
 834
 835         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 836
 837         dev = nfc_get_device(idx);
 838         if (!dev)
 839                 return -ENODEV;
 840
 841         device_lock(&dev->dev);
 842
 843         local = nfc_llcp_find_local(dev);
 844         if (!local) {
 845                 rc = -ENODEV;
 846                 goto exit;
 847         }
 848
 849         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 850         if (!msg) {
 851                 rc = -ENOMEM;
 852                 goto exit;
 853         }
 854
 855         rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
 856
 857 exit:
 858         device_unlock(&dev->dev);
 859
 860         nfc_put_device(dev);
 861
 862         if (rc < 0) {
 863                 if (msg)
 864                         nlmsg_free(msg);
 865
 866                 return rc;
 867         }
 868
 869         return genlmsg_reply(msg, info);
 870 }
 871
 872 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
 873 {
 874         struct nfc_dev *dev;
 875         struct nfc_llcp_local *local;
 876         u8 rw = 0;
 877         u16 miux = 0;
 878         u32 idx;
 879         int rc = 0;
 880
 881         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 882             (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
 883              !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
 884              !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
 885                 return -EINVAL;
 886
 887         if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
 888                 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
 889
 890                 if (rw > LLCP_MAX_RW)
 891                         return -EINVAL;
 892         }
 893
 894         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
 895                 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
 896
 897                 if (miux > LLCP_MAX_MIUX)
 898                         return -EINVAL;
 899         }
 900
 901         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 902
 903         dev = nfc_get_device(idx);
 904         if (!dev)
 905                 return -ENODEV;
 906
 907         device_lock(&dev->dev);
 908
 909         local = nfc_llcp_find_local(dev);
 910         if (!local) {
 911                 nfc_put_device(dev);
 912                 rc = -ENODEV;
 913                 goto exit;
 914         }
 915
 916         if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
 917                 if (dev->dep_link_up) {
 918                         rc = -EINPROGRESS;
 919                         goto exit;
 920                 }
 921
 922                 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
 923         }
 924
 925         if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
 926                 local->rw = rw;
 927
 928         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
 929                 local->miux = cpu_to_be16(miux);
 930
 931 exit:
 932         device_unlock(&dev->dev);
 933
 934         nfc_put_device(dev);
 935
 936         return rc;
 937 }
 938
 939 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info)
 940 {
 941         struct nfc_dev *dev;
 942         struct nfc_llcp_local *local;
 943         struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1];
 944         u32 idx;
 945         u8 tid;
 946         char *uri;
 947         int rc = 0, rem;
 948         size_t uri_len, tlvs_len;
 949         struct hlist_head sdreq_list;
 950         struct nfc_llcp_sdp_tlv *sdreq;
 951
 952         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 953             !info->attrs[NFC_ATTR_LLC_SDP])
 954                 return -EINVAL;
 955
 956         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 957
 958         dev = nfc_get_device(idx);
 959         if (!dev) {
 960                 rc = -ENODEV;
 961                 goto exit;
 962         }
 963
 964         device_lock(&dev->dev);
 965
 966         if (dev->dep_link_up == false) {
 967                 rc = -ENOLINK;
 968                 goto exit;
 969         }
 970
 971         local = nfc_llcp_find_local(dev);
 972         if (!local) {
 973                 nfc_put_device(dev);
 974                 rc = -ENODEV;
 975                 goto exit;
 976         }
 977
 978         INIT_HLIST_HEAD(&sdreq_list);
 979
 980         tlvs_len = 0;
 981
 982         nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) {
 983                 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr,
 984                                       nfc_sdp_genl_policy);
 985
 986                 if (rc != 0) {
 987                         rc = -EINVAL;
 988                         goto exit;
 989                 }
 990
 991                 if (!sdp_attrs[NFC_SDP_ATTR_URI])
 992                         continue;
 993
 994                 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]);
 995                 if (uri_len == 0)
 996                         continue;
 997
 998                 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]);
 999                 if (uri == NULL || *uri == 0)
1000                         continue;
1001
1002                 tid = local->sdreq_next_tid++;
1003
1004                 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len);
1005                 if (sdreq == NULL) {
1006                         rc = -ENOMEM;
1007                         goto exit;
1008                 }
1009
1010                 tlvs_len += sdreq->tlv_len;
1011
1012                 hlist_add_head(&sdreq->node, &sdreq_list);
1013         }
1014
1015         if (hlist_empty(&sdreq_list)) {
1016                 rc = -EINVAL;
1017                 goto exit;
1018         }
1019
1020         rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len);
1021 exit:
1022         device_unlock(&dev->dev);
1023
1024         nfc_put_device(dev);
1025
1026         return rc;
1027 }
1028
1029 static struct genl_ops nfc_genl_ops[] = {
1030         {
1031                 .cmd = NFC_CMD_GET_DEVICE,
1032                 .doit = nfc_genl_get_device,
1033                 .dumpit = nfc_genl_dump_devices,
1034                 .done = nfc_genl_dump_devices_done,
1035                 .policy = nfc_genl_policy,
1036         },
1037         {
1038                 .cmd = NFC_CMD_DEV_UP,
1039                 .doit = nfc_genl_dev_up,
1040                 .policy = nfc_genl_policy,
1041         },
1042         {
1043                 .cmd = NFC_CMD_DEV_DOWN,
1044                 .doit = nfc_genl_dev_down,
1045                 .policy = nfc_genl_policy,
1046         },
1047         {
1048                 .cmd = NFC_CMD_START_POLL,
1049                 .doit = nfc_genl_start_poll,
1050                 .policy = nfc_genl_policy,
1051         },
1052         {
1053                 .cmd = NFC_CMD_STOP_POLL,
1054                 .doit = nfc_genl_stop_poll,
1055                 .policy = nfc_genl_policy,
1056         },
1057         {
1058                 .cmd = NFC_CMD_DEP_LINK_UP,
1059                 .doit = nfc_genl_dep_link_up,
1060                 .policy = nfc_genl_policy,
1061         },
1062         {
1063                 .cmd = NFC_CMD_DEP_LINK_DOWN,
1064                 .doit = nfc_genl_dep_link_down,
1065                 .policy = nfc_genl_policy,
1066         },
1067         {
1068                 .cmd = NFC_CMD_GET_TARGET,
1069                 .dumpit = nfc_genl_dump_targets,
1070                 .done = nfc_genl_dump_targets_done,
1071                 .policy = nfc_genl_policy,
1072         },
1073         {
1074                 .cmd = NFC_CMD_LLC_GET_PARAMS,
1075                 .doit = nfc_genl_llc_get_params,
1076                 .policy = nfc_genl_policy,
1077         },
1078         {
1079                 .cmd = NFC_CMD_LLC_SET_PARAMS,
1080                 .doit = nfc_genl_llc_set_params,
1081                 .policy = nfc_genl_policy,
1082         },
1083         {
1084                 .cmd = NFC_CMD_LLC_SDREQ,
1085                 .doit = nfc_genl_llc_sdreq,
1086                 .policy = nfc_genl_policy,
1087         },
1088 };
1089
1090
1091 struct urelease_work {
1092         struct  work_struct w;
1093         int     portid;
1094 };
1095
1096 static void nfc_urelease_event_work(struct work_struct *work)
1097 {
1098         struct urelease_work *w = container_of(work, struct urelease_work, w);
1099         struct class_dev_iter iter;
1100         struct nfc_dev *dev;
1101
1102         pr_debug("portid %d\n", w->portid);
1103
1104         mutex_lock(&nfc_devlist_mutex);
1105
1106         nfc_device_iter_init(&iter);
1107         dev = nfc_device_iter_next(&iter);
1108
1109         while (dev) {
1110                 mutex_lock(&dev->genl_data.genl_data_mutex);
1111
1112                 if (dev->genl_data.poll_req_portid == w->portid) {
1113                         nfc_stop_poll(dev);
1114                         dev->genl_data.poll_req_portid = 0;
1115                 }
1116
1117                 mutex_unlock(&dev->genl_data.genl_data_mutex);
1118
1119                 dev = nfc_device_iter_next(&iter);
1120         }
1121
1122         nfc_device_iter_exit(&iter);
1123
1124         mutex_unlock(&nfc_devlist_mutex);
1125
1126         kfree(w);
1127 }
1128
1129 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
1130                                  unsigned long event, void *ptr)
1131 {
1132         struct netlink_notify *n = ptr;
1133         struct urelease_work *w;
1134
1135         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
1136                 goto out;
1137
1138         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
1139
1140         w = kmalloc(sizeof(*w), GFP_ATOMIC);
1141         if (w) {
1142                 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
1143                 w->portid = n->portid;
1144                 schedule_work((struct work_struct *) w);
1145         }
1146
1147 out:
1148         return NOTIFY_DONE;
1149 }
1150
1151 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
1152 {
1153         genl_data->poll_req_portid = 0;
1154         mutex_init(&genl_data->genl_data_mutex);
1155 }
1156
1157 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
1158 {
1159         mutex_destroy(&genl_data->genl_data_mutex);
1160 }
1161
1162 static struct notifier_block nl_notifier = {
1163         .notifier_call  = nfc_genl_rcv_nl_event,
1164 };
1165
1166 /**
1167  * nfc_genl_init() - Initialize netlink interface
1168  *
1169  * This initialization function registers the nfc netlink family.
1170  */
1171 int __init nfc_genl_init(void)
1172 {
1173         int rc;
1174
1175         rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
1176                                            ARRAY_SIZE(nfc_genl_ops));
1177         if (rc)
1178                 return rc;
1179
1180         rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);
1181
1182         netlink_register_notifier(&nl_notifier);
1183
1184         return rc;
1185 }
1186
1187 /**
1188  * nfc_genl_exit() - Deinitialize netlink interface
1189  *
1190  * This exit function unregisters the nfc netlink family.
1191  */
1192 void nfc_genl_exit(void)
1193 {
1194         netlink_unregister_notifier(&nl_notifier);
1195         genl_unregister_family(&nfc_genl_family);
1196 }