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 };
  57
  58 static int nfc_genl_send_target(struct sk_buff *msg, struct nfc_target *target,
  59                                 struct netlink_callback *cb, int flags)
  60 {
  61         void *hdr;
  62
  63         hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  64                           &nfc_genl_family, flags, NFC_CMD_GET_TARGET);
  65         if (!hdr)
  66                 return -EMSGSIZE;
  67
  68         genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
  69
  70         if (nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target->idx) ||
  71             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, target->supported_protocols) ||
  72             nla_put_u16(msg, NFC_ATTR_TARGET_SENS_RES, target->sens_res) ||
  73             nla_put_u8(msg, NFC_ATTR_TARGET_SEL_RES, target->sel_res))
  74                 goto nla_put_failure;
  75         if (target->nfcid1_len > 0 &&
  76             nla_put(msg, NFC_ATTR_TARGET_NFCID1, target->nfcid1_len,
  77                     target->nfcid1))
  78                 goto nla_put_failure;
  79         if (target->sensb_res_len > 0 &&
  80             nla_put(msg, NFC_ATTR_TARGET_SENSB_RES, target->sensb_res_len,
  81                     target->sensb_res))
  82                 goto nla_put_failure;
  83         if (target->sensf_res_len > 0 &&
  84             nla_put(msg, NFC_ATTR_TARGET_SENSF_RES, target->sensf_res_len,
  85                     target->sensf_res))
  86                 goto nla_put_failure;
  87
  88         return genlmsg_end(msg, hdr);
  89
  90 nla_put_failure:
  91         genlmsg_cancel(msg, hdr);
  92         return -EMSGSIZE;
  93 }
  94
  95 static struct nfc_dev *__get_device_from_cb(struct netlink_callback *cb)
  96 {
  97         struct nfc_dev *dev;
  98         int rc;
  99         u32 idx;
 100
 101         rc = nlmsg_parse(cb->nlh, GENL_HDRLEN + nfc_genl_family.hdrsize,
 102                          nfc_genl_family.attrbuf,
 103                          nfc_genl_family.maxattr,
 104                          nfc_genl_policy);
 105         if (rc < 0)
 106                 return ERR_PTR(rc);
 107
 108         if (!nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX])
 109                 return ERR_PTR(-EINVAL);
 110
 111         idx = nla_get_u32(nfc_genl_family.attrbuf[NFC_ATTR_DEVICE_INDEX]);
 112
 113         dev = nfc_get_device(idx);
 114         if (!dev)
 115                 return ERR_PTR(-ENODEV);
 116
 117         return dev;
 118 }
 119
 120 static int nfc_genl_dump_targets(struct sk_buff *skb,
 121                                  struct netlink_callback *cb)
 122 {
 123         int i = cb->args[0];
 124         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 125         int rc;
 126
 127         if (!dev) {
 128                 dev = __get_device_from_cb(cb);
 129                 if (IS_ERR(dev))
 130                         return PTR_ERR(dev);
 131
 132                 cb->args[1] = (long) dev;
 133         }
 134
 135         device_lock(&dev->dev);
 136
 137         cb->seq = dev->targets_generation;
 138
 139         while (i < dev->n_targets) {
 140                 rc = nfc_genl_send_target(skb, &dev->targets[i], cb,
 141                                           NLM_F_MULTI);
 142                 if (rc < 0)
 143                         break;
 144
 145                 i++;
 146         }
 147
 148         device_unlock(&dev->dev);
 149
 150         cb->args[0] = i;
 151
 152         return skb->len;
 153 }
 154
 155 static int nfc_genl_dump_targets_done(struct netlink_callback *cb)
 156 {
 157         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 158
 159         if (dev)
 160                 nfc_put_device(dev);
 161
 162         return 0;
 163 }
 164
 165 int nfc_genl_targets_found(struct nfc_dev *dev)
 166 {
 167         struct sk_buff *msg;
 168         void *hdr;
 169
 170         dev->genl_data.poll_req_portid = 0;
 171
 172         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 173         if (!msg)
 174                 return -ENOMEM;
 175
 176         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 177                           NFC_EVENT_TARGETS_FOUND);
 178         if (!hdr)
 179                 goto free_msg;
 180
 181         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 182                 goto nla_put_failure;
 183
 184         genlmsg_end(msg, hdr);
 185
 186         return genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 187
 188 nla_put_failure:
 189         genlmsg_cancel(msg, hdr);
 190 free_msg:
 191         nlmsg_free(msg);
 192         return -EMSGSIZE;
 193 }
 194
 195 int nfc_genl_target_lost(struct nfc_dev *dev, u32 target_idx)
 196 {
 197         struct sk_buff *msg;
 198         void *hdr;
 199
 200         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 201         if (!msg)
 202                 return -ENOMEM;
 203
 204         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 205                           NFC_EVENT_TARGET_LOST);
 206         if (!hdr)
 207                 goto free_msg;
 208
 209         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 210             nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
 211                 goto nla_put_failure;
 212
 213         genlmsg_end(msg, hdr);
 214
 215         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 216
 217         return 0;
 218
 219 nla_put_failure:
 220         genlmsg_cancel(msg, hdr);
 221 free_msg:
 222         nlmsg_free(msg);
 223         return -EMSGSIZE;
 224 }
 225
 226 int nfc_genl_tm_activated(struct nfc_dev *dev, u32 protocol)
 227 {
 228         struct sk_buff *msg;
 229         void *hdr;
 230
 231         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 232         if (!msg)
 233                 return -ENOMEM;
 234
 235         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 236                           NFC_EVENT_TM_ACTIVATED);
 237         if (!hdr)
 238                 goto free_msg;
 239
 240         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 241                 goto nla_put_failure;
 242         if (nla_put_u32(msg, NFC_ATTR_TM_PROTOCOLS, protocol))
 243                 goto nla_put_failure;
 244
 245         genlmsg_end(msg, hdr);
 246
 247         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 248
 249         return 0;
 250
 251 nla_put_failure:
 252         genlmsg_cancel(msg, hdr);
 253 free_msg:
 254         nlmsg_free(msg);
 255         return -EMSGSIZE;
 256 }
 257
 258 int nfc_genl_tm_deactivated(struct nfc_dev *dev)
 259 {
 260         struct sk_buff *msg;
 261         void *hdr;
 262
 263         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 264         if (!msg)
 265                 return -ENOMEM;
 266
 267         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 268                           NFC_EVENT_TM_DEACTIVATED);
 269         if (!hdr)
 270                 goto free_msg;
 271
 272         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 273                 goto nla_put_failure;
 274
 275         genlmsg_end(msg, hdr);
 276
 277         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 278
 279         return 0;
 280
 281 nla_put_failure:
 282         genlmsg_cancel(msg, hdr);
 283 free_msg:
 284         nlmsg_free(msg);
 285         return -EMSGSIZE;
 286 }
 287
 288 int nfc_genl_device_added(struct nfc_dev *dev)
 289 {
 290         struct sk_buff *msg;
 291         void *hdr;
 292
 293         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 294         if (!msg)
 295                 return -ENOMEM;
 296
 297         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 298                           NFC_EVENT_DEVICE_ADDED);
 299         if (!hdr)
 300                 goto free_msg;
 301
 302         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 303             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
 304             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
 305             nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up))
 306                 goto nla_put_failure;
 307
 308         genlmsg_end(msg, hdr);
 309
 310         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 311
 312         return 0;
 313
 314 nla_put_failure:
 315         genlmsg_cancel(msg, hdr);
 316 free_msg:
 317         nlmsg_free(msg);
 318         return -EMSGSIZE;
 319 }
 320
 321 int nfc_genl_device_removed(struct nfc_dev *dev)
 322 {
 323         struct sk_buff *msg;
 324         void *hdr;
 325
 326         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 327         if (!msg)
 328                 return -ENOMEM;
 329
 330         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 331                           NFC_EVENT_DEVICE_REMOVED);
 332         if (!hdr)
 333                 goto free_msg;
 334
 335         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 336                 goto nla_put_failure;
 337
 338         genlmsg_end(msg, hdr);
 339
 340         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_KERNEL);
 341
 342         return 0;
 343
 344 nla_put_failure:
 345         genlmsg_cancel(msg, hdr);
 346 free_msg:
 347         nlmsg_free(msg);
 348         return -EMSGSIZE;
 349 }
 350
 351 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev,
 352                                 u32 portid, u32 seq,
 353                                 struct netlink_callback *cb,
 354                                 int flags)
 355 {
 356         void *hdr;
 357
 358         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags,
 359                           NFC_CMD_GET_DEVICE);
 360         if (!hdr)
 361                 return -EMSGSIZE;
 362
 363         if (cb)
 364                 genl_dump_check_consistent(cb, hdr, &nfc_genl_family);
 365
 366         if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) ||
 367             nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) ||
 368             nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) ||
 369             nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) ||
 370             nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode))
 371                 goto nla_put_failure;
 372
 373         return genlmsg_end(msg, hdr);
 374
 375 nla_put_failure:
 376         genlmsg_cancel(msg, hdr);
 377         return -EMSGSIZE;
 378 }
 379
 380 static int nfc_genl_dump_devices(struct sk_buff *skb,
 381                                  struct netlink_callback *cb)
 382 {
 383         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 384         struct nfc_dev *dev = (struct nfc_dev *) cb->args[1];
 385         bool first_call = false;
 386
 387         if (!iter) {
 388                 first_call = true;
 389                 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL);
 390                 if (!iter)
 391                         return -ENOMEM;
 392                 cb->args[0] = (long) iter;
 393         }
 394
 395         mutex_lock(&nfc_devlist_mutex);
 396
 397         cb->seq = nfc_devlist_generation;
 398
 399         if (first_call) {
 400                 nfc_device_iter_init(iter);
 401                 dev = nfc_device_iter_next(iter);
 402         }
 403
 404         while (dev) {
 405                 int rc;
 406
 407                 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid,
 408                                           cb->nlh->nlmsg_seq, cb, NLM_F_MULTI);
 409                 if (rc < 0)
 410                         break;
 411
 412                 dev = nfc_device_iter_next(iter);
 413         }
 414
 415         mutex_unlock(&nfc_devlist_mutex);
 416
 417         cb->args[1] = (long) dev;
 418
 419         return skb->len;
 420 }
 421
 422 static int nfc_genl_dump_devices_done(struct netlink_callback *cb)
 423 {
 424         struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
 425
 426         nfc_device_iter_exit(iter);
 427         kfree(iter);
 428
 429         return 0;
 430 }
 431
 432 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx,
 433                                u8 comm_mode, u8 rf_mode)
 434 {
 435         struct sk_buff *msg;
 436         void *hdr;
 437
 438         pr_debug("DEP link is up\n");
 439
 440         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 441         if (!msg)
 442                 return -ENOMEM;
 443
 444         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP);
 445         if (!hdr)
 446                 goto free_msg;
 447
 448         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 449                 goto nla_put_failure;
 450         if (rf_mode == NFC_RF_INITIATOR &&
 451             nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx))
 452                 goto nla_put_failure;
 453         if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) ||
 454             nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode))
 455                 goto nla_put_failure;
 456
 457         genlmsg_end(msg, hdr);
 458
 459         dev->dep_link_up = true;
 460
 461         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 462
 463         return 0;
 464
 465 nla_put_failure:
 466         genlmsg_cancel(msg, hdr);
 467 free_msg:
 468         nlmsg_free(msg);
 469         return -EMSGSIZE;
 470 }
 471
 472 int nfc_genl_dep_link_down_event(struct nfc_dev *dev)
 473 {
 474         struct sk_buff *msg;
 475         void *hdr;
 476
 477         pr_debug("DEP link is down\n");
 478
 479         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
 480         if (!msg)
 481                 return -ENOMEM;
 482
 483         hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0,
 484                           NFC_CMD_DEP_LINK_DOWN);
 485         if (!hdr)
 486                 goto free_msg;
 487
 488         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx))
 489                 goto nla_put_failure;
 490
 491         genlmsg_end(msg, hdr);
 492
 493         genlmsg_multicast(msg, 0, nfc_genl_event_mcgrp.id, GFP_ATOMIC);
 494
 495         return 0;
 496
 497 nla_put_failure:
 498         genlmsg_cancel(msg, hdr);
 499 free_msg:
 500         nlmsg_free(msg);
 501         return -EMSGSIZE;
 502 }
 503
 504 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info)
 505 {
 506         struct sk_buff *msg;
 507         struct nfc_dev *dev;
 508         u32 idx;
 509         int rc = -ENOBUFS;
 510
 511         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 512                 return -EINVAL;
 513
 514         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 515
 516         dev = nfc_get_device(idx);
 517         if (!dev)
 518                 return -ENODEV;
 519
 520         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 521         if (!msg) {
 522                 rc = -ENOMEM;
 523                 goto out_putdev;
 524         }
 525
 526         rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq,
 527                                   NULL, 0);
 528         if (rc < 0)
 529                 goto out_free;
 530
 531         nfc_put_device(dev);
 532
 533         return genlmsg_reply(msg, info);
 534
 535 out_free:
 536         nlmsg_free(msg);
 537 out_putdev:
 538         nfc_put_device(dev);
 539         return rc;
 540 }
 541
 542 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
 543 {
 544         struct nfc_dev *dev;
 545         int rc;
 546         u32 idx;
 547
 548         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 549                 return -EINVAL;
 550
 551         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 552
 553         dev = nfc_get_device(idx);
 554         if (!dev)
 555                 return -ENODEV;
 556
 557         rc = nfc_dev_up(dev);
 558
 559         nfc_put_device(dev);
 560         return rc;
 561 }
 562
 563 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
 564 {
 565         struct nfc_dev *dev;
 566         int rc;
 567         u32 idx;
 568
 569         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 570                 return -EINVAL;
 571
 572         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 573
 574         dev = nfc_get_device(idx);
 575         if (!dev)
 576                 return -ENODEV;
 577
 578         rc = nfc_dev_down(dev);
 579
 580         nfc_put_device(dev);
 581         return rc;
 582 }
 583
 584 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
 585 {
 586         struct nfc_dev *dev;
 587         int rc;
 588         u32 idx;
 589         u32 im_protocols = 0, tm_protocols = 0;
 590
 591         pr_debug("Poll start\n");
 592
 593         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 594             ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] &&
 595               !info->attrs[NFC_ATTR_PROTOCOLS]) &&
 596               !info->attrs[NFC_ATTR_TM_PROTOCOLS]))
 597                 return -EINVAL;
 598
 599         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 600
 601         if (info->attrs[NFC_ATTR_TM_PROTOCOLS])
 602                 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]);
 603
 604         if (info->attrs[NFC_ATTR_IM_PROTOCOLS])
 605                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]);
 606         else if (info->attrs[NFC_ATTR_PROTOCOLS])
 607                 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]);
 608
 609         dev = nfc_get_device(idx);
 610         if (!dev)
 611                 return -ENODEV;
 612
 613         mutex_lock(&dev->genl_data.genl_data_mutex);
 614
 615         rc = nfc_start_poll(dev, im_protocols, tm_protocols);
 616         if (!rc)
 617                 dev->genl_data.poll_req_portid = info->snd_portid;
 618
 619         mutex_unlock(&dev->genl_data.genl_data_mutex);
 620
 621         nfc_put_device(dev);
 622         return rc;
 623 }
 624
 625 static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info)
 626 {
 627         struct nfc_dev *dev;
 628         int rc;
 629         u32 idx;
 630
 631         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 632                 return -EINVAL;
 633
 634         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 635
 636         dev = nfc_get_device(idx);
 637         if (!dev)
 638                 return -ENODEV;
 639
 640         device_lock(&dev->dev);
 641
 642         if (!dev->polling) {
 643                 device_unlock(&dev->dev);
 644                 return -EINVAL;
 645         }
 646
 647         device_unlock(&dev->dev);
 648
 649         mutex_lock(&dev->genl_data.genl_data_mutex);
 650
 651         if (dev->genl_data.poll_req_portid != info->snd_portid) {
 652                 rc = -EBUSY;
 653                 goto out;
 654         }
 655
 656         rc = nfc_stop_poll(dev);
 657         dev->genl_data.poll_req_portid = 0;
 658
 659 out:
 660         mutex_unlock(&dev->genl_data.genl_data_mutex);
 661         nfc_put_device(dev);
 662         return rc;
 663 }
 664
 665 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info)
 666 {
 667         struct nfc_dev *dev;
 668         int rc, tgt_idx;
 669         u32 idx;
 670         u8 comm;
 671
 672         pr_debug("DEP link up\n");
 673
 674         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 675             !info->attrs[NFC_ATTR_COMM_MODE])
 676                 return -EINVAL;
 677
 678         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 679         if (!info->attrs[NFC_ATTR_TARGET_INDEX])
 680                 tgt_idx = NFC_TARGET_IDX_ANY;
 681         else
 682                 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]);
 683
 684         comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]);
 685
 686         if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE)
 687                 return -EINVAL;
 688
 689         dev = nfc_get_device(idx);
 690         if (!dev)
 691                 return -ENODEV;
 692
 693         rc = nfc_dep_link_up(dev, tgt_idx, comm);
 694
 695         nfc_put_device(dev);
 696
 697         return rc;
 698 }
 699
 700 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info)
 701 {
 702         struct nfc_dev *dev;
 703         int rc;
 704         u32 idx;
 705
 706         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 707                 return -EINVAL;
 708
 709         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 710
 711         dev = nfc_get_device(idx);
 712         if (!dev)
 713                 return -ENODEV;
 714
 715         rc = nfc_dep_link_down(dev);
 716
 717         nfc_put_device(dev);
 718         return rc;
 719 }
 720
 721 static int nfc_genl_send_params(struct sk_buff *msg,
 722                                 struct nfc_llcp_local *local,
 723                                 u32 portid, u32 seq)
 724 {
 725         void *hdr;
 726
 727         hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0,
 728                           NFC_CMD_LLC_GET_PARAMS);
 729         if (!hdr)
 730                 return -EMSGSIZE;
 731
 732         if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) ||
 733             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) ||
 734             nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) ||
 735             nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux)))
 736                 goto nla_put_failure;
 737
 738         return genlmsg_end(msg, hdr);
 739
 740 nla_put_failure:
 741
 742         genlmsg_cancel(msg, hdr);
 743         return -EMSGSIZE;
 744 }
 745
 746 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info)
 747 {
 748         struct nfc_dev *dev;
 749         struct nfc_llcp_local *local;
 750         int rc = 0;
 751         struct sk_buff *msg = NULL;
 752         u32 idx;
 753
 754         if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
 755                 return -EINVAL;
 756
 757         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 758
 759         dev = nfc_get_device(idx);
 760         if (!dev)
 761                 return -ENODEV;
 762
 763         device_lock(&dev->dev);
 764
 765         local = nfc_llcp_find_local(dev);
 766         if (!local) {
 767                 rc = -ENODEV;
 768                 goto exit;
 769         }
 770
 771         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 772         if (!msg) {
 773                 rc = -ENOMEM;
 774                 goto exit;
 775         }
 776
 777         rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq);
 778
 779 exit:
 780         device_unlock(&dev->dev);
 781
 782         nfc_put_device(dev);
 783
 784         if (rc < 0) {
 785                 if (msg)
 786                         nlmsg_free(msg);
 787
 788                 return rc;
 789         }
 790
 791         return genlmsg_reply(msg, info);
 792 }
 793
 794 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info)
 795 {
 796         struct nfc_dev *dev;
 797         struct nfc_llcp_local *local;
 798         u8 rw = 0;
 799         u16 miux = 0;
 800         u32 idx;
 801         int rc = 0;
 802
 803         if (!info->attrs[NFC_ATTR_DEVICE_INDEX] ||
 804             (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] &&
 805              !info->attrs[NFC_ATTR_LLC_PARAM_RW] &&
 806              !info->attrs[NFC_ATTR_LLC_PARAM_MIUX]))
 807                 return -EINVAL;
 808
 809         if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) {
 810                 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]);
 811
 812                 if (rw > LLCP_MAX_RW)
 813                         return -EINVAL;
 814         }
 815
 816         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) {
 817                 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]);
 818
 819                 if (miux > LLCP_MAX_MIUX)
 820                         return -EINVAL;
 821         }
 822
 823         idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
 824
 825         dev = nfc_get_device(idx);
 826         if (!dev)
 827                 return -ENODEV;
 828
 829         device_lock(&dev->dev);
 830
 831         local = nfc_llcp_find_local(dev);
 832         if (!local) {
 833                 nfc_put_device(dev);
 834                 rc = -ENODEV;
 835                 goto exit;
 836         }
 837
 838         if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) {
 839                 if (dev->dep_link_up) {
 840                         rc = -EINPROGRESS;
 841                         goto exit;
 842                 }
 843
 844                 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]);
 845         }
 846
 847         if (info->attrs[NFC_ATTR_LLC_PARAM_RW])
 848                 local->rw = rw;
 849
 850         if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX])
 851                 local->miux = cpu_to_be16(miux);
 852
 853 exit:
 854         device_unlock(&dev->dev);
 855
 856         nfc_put_device(dev);
 857
 858         return rc;
 859 }
 860
 861 static struct genl_ops nfc_genl_ops[] = {
 862         {
 863                 .cmd = NFC_CMD_GET_DEVICE,
 864                 .doit = nfc_genl_get_device,
 865                 .dumpit = nfc_genl_dump_devices,
 866                 .done = nfc_genl_dump_devices_done,
 867                 .policy = nfc_genl_policy,
 868         },
 869         {
 870                 .cmd = NFC_CMD_DEV_UP,
 871                 .doit = nfc_genl_dev_up,
 872                 .policy = nfc_genl_policy,
 873         },
 874         {
 875                 .cmd = NFC_CMD_DEV_DOWN,
 876                 .doit = nfc_genl_dev_down,
 877                 .policy = nfc_genl_policy,
 878         },
 879         {
 880                 .cmd = NFC_CMD_START_POLL,
 881                 .doit = nfc_genl_start_poll,
 882                 .policy = nfc_genl_policy,
 883         },
 884         {
 885                 .cmd = NFC_CMD_STOP_POLL,
 886                 .doit = nfc_genl_stop_poll,
 887                 .policy = nfc_genl_policy,
 888         },
 889         {
 890                 .cmd = NFC_CMD_DEP_LINK_UP,
 891                 .doit = nfc_genl_dep_link_up,
 892                 .policy = nfc_genl_policy,
 893         },
 894         {
 895                 .cmd = NFC_CMD_DEP_LINK_DOWN,
 896                 .doit = nfc_genl_dep_link_down,
 897                 .policy = nfc_genl_policy,
 898         },
 899         {
 900                 .cmd = NFC_CMD_GET_TARGET,
 901                 .dumpit = nfc_genl_dump_targets,
 902                 .done = nfc_genl_dump_targets_done,
 903                 .policy = nfc_genl_policy,
 904         },
 905         {
 906                 .cmd = NFC_CMD_LLC_GET_PARAMS,
 907                 .doit = nfc_genl_llc_get_params,
 908                 .policy = nfc_genl_policy,
 909         },
 910         {
 911                 .cmd = NFC_CMD_LLC_SET_PARAMS,
 912                 .doit = nfc_genl_llc_set_params,
 913                 .policy = nfc_genl_policy,
 914         },
 915 };
 916
 917
 918 struct urelease_work {
 919         struct  work_struct w;
 920         int     portid;
 921 };
 922
 923 static void nfc_urelease_event_work(struct work_struct *work)
 924 {
 925         struct urelease_work *w = container_of(work, struct urelease_work, w);
 926         struct class_dev_iter iter;
 927         struct nfc_dev *dev;
 928
 929         pr_debug("portid %d\n", w->portid);
 930
 931         mutex_lock(&nfc_devlist_mutex);
 932
 933         nfc_device_iter_init(&iter);
 934         dev = nfc_device_iter_next(&iter);
 935
 936         while (dev) {
 937                 mutex_lock(&dev->genl_data.genl_data_mutex);
 938
 939                 if (dev->genl_data.poll_req_portid == w->portid) {
 940                         nfc_stop_poll(dev);
 941                         dev->genl_data.poll_req_portid = 0;
 942                 }
 943
 944                 mutex_unlock(&dev->genl_data.genl_data_mutex);
 945
 946                 dev = nfc_device_iter_next(&iter);
 947         }
 948
 949         nfc_device_iter_exit(&iter);
 950
 951         mutex_unlock(&nfc_devlist_mutex);
 952
 953         kfree(w);
 954 }
 955
 956 static int nfc_genl_rcv_nl_event(struct notifier_block *this,
 957                                  unsigned long event, void *ptr)
 958 {
 959         struct netlink_notify *n = ptr;
 960         struct urelease_work *w;
 961
 962         if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC)
 963                 goto out;
 964
 965         pr_debug("NETLINK_URELEASE event from id %d\n", n->portid);
 966
 967         w = kmalloc(sizeof(*w), GFP_ATOMIC);
 968         if (w) {
 969                 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work);
 970                 w->portid = n->portid;
 971                 schedule_work((struct work_struct *) w);
 972         }
 973
 974 out:
 975         return NOTIFY_DONE;
 976 }
 977
 978 void nfc_genl_data_init(struct nfc_genl_data *genl_data)
 979 {
 980         genl_data->poll_req_portid = 0;
 981         mutex_init(&genl_data->genl_data_mutex);
 982 }
 983
 984 void nfc_genl_data_exit(struct nfc_genl_data *genl_data)
 985 {
 986         mutex_destroy(&genl_data->genl_data_mutex);
 987 }
 988
 989 static struct notifier_block nl_notifier = {
 990         .notifier_call  = nfc_genl_rcv_nl_event,
 991 };
 992
 993 /**
 994  * nfc_genl_init() - Initialize netlink interface
 995  *
 996  * This initialization function registers the nfc netlink family.
 997  */
 998 int __init nfc_genl_init(void)
 999 {
1000         int rc;
1001
1002         rc = genl_register_family_with_ops(&nfc_genl_family, nfc_genl_ops,
1003                                            ARRAY_SIZE(nfc_genl_ops));
1004         if (rc)
1005                 return rc;
1006
1007         rc = genl_register_mc_group(&nfc_genl_family, &nfc_genl_event_mcgrp);
1008
1009         netlink_register_notifier(&nl_notifier);
1010
1011         return rc;
1012 }
1013
1014 /**
1015  * nfc_genl_exit() - Deinitialize netlink interface
1016  *
1017  * This exit function unregisters the nfc netlink family.
1018  */
1019 void nfc_genl_exit(void)
1020 {
1021         netlink_unregister_notifier(&nl_notifier);
1022         genl_unregister_family(&nfc_genl_family);
1023 }