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