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