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