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 static int nfc_genl_send_device(struct sk_buff *msg, struct nfc_dev *dev, 556 u32 portid, u32 seq, 557 struct netlink_callback *cb, 558 int flags) 559 { 560 void *hdr; 561 562 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags, 563 NFC_CMD_GET_DEVICE); 564 if (!hdr) 565 return -EMSGSIZE; 566 567 if (cb) 568 genl_dump_check_consistent(cb, hdr, &nfc_genl_family); 569 570 if (nla_put_string(msg, NFC_ATTR_DEVICE_NAME, nfc_device_name(dev)) || 571 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) || 572 nla_put_u32(msg, NFC_ATTR_PROTOCOLS, dev->supported_protocols) || 573 nla_put_u8(msg, NFC_ATTR_DEVICE_POWERED, dev->dev_up) || 574 nla_put_u8(msg, NFC_ATTR_RF_MODE, dev->rf_mode)) 575 goto nla_put_failure; 576 577 genlmsg_end(msg, hdr); 578 return 0; 579 580 nla_put_failure: 581 genlmsg_cancel(msg, hdr); 582 return -EMSGSIZE; 583 } 584 585 static int nfc_genl_dump_devices(struct sk_buff *skb, 586 struct netlink_callback *cb) 587 { 588 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 589 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1]; 590 bool first_call = false; 591 592 if (!iter) { 593 first_call = true; 594 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL); 595 if (!iter) 596 return -ENOMEM; 597 cb->args[0] = (long) iter; 598 } 599 600 mutex_lock(&nfc_devlist_mutex); 601 602 cb->seq = nfc_devlist_generation; 603 604 if (first_call) { 605 nfc_device_iter_init(iter); 606 dev = nfc_device_iter_next(iter); 607 } 608 609 while (dev) { 610 int rc; 611 612 rc = nfc_genl_send_device(skb, dev, NETLINK_CB(cb->skb).portid, 613 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI); 614 if (rc < 0) 615 break; 616 617 dev = nfc_device_iter_next(iter); 618 } 619 620 mutex_unlock(&nfc_devlist_mutex); 621 622 cb->args[1] = (long) dev; 623 624 return skb->len; 625 } 626 627 static int nfc_genl_dump_devices_done(struct netlink_callback *cb) 628 { 629 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 630 631 nfc_device_iter_exit(iter); 632 kfree(iter); 633 634 return 0; 635 } 636 637 int nfc_genl_dep_link_up_event(struct nfc_dev *dev, u32 target_idx, 638 u8 comm_mode, u8 rf_mode) 639 { 640 struct sk_buff *msg; 641 void *hdr; 642 643 pr_debug("DEP link is up\n"); 644 645 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 646 if (!msg) 647 return -ENOMEM; 648 649 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, NFC_CMD_DEP_LINK_UP); 650 if (!hdr) 651 goto free_msg; 652 653 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) 654 goto nla_put_failure; 655 if (rf_mode == NFC_RF_INITIATOR && 656 nla_put_u32(msg, NFC_ATTR_TARGET_INDEX, target_idx)) 657 goto nla_put_failure; 658 if (nla_put_u8(msg, NFC_ATTR_COMM_MODE, comm_mode) || 659 nla_put_u8(msg, NFC_ATTR_RF_MODE, rf_mode)) 660 goto nla_put_failure; 661 662 genlmsg_end(msg, hdr); 663 664 dev->dep_link_up = true; 665 666 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC); 667 668 return 0; 669 670 nla_put_failure: 671 genlmsg_cancel(msg, hdr); 672 free_msg: 673 nlmsg_free(msg); 674 return -EMSGSIZE; 675 } 676 677 int nfc_genl_dep_link_down_event(struct nfc_dev *dev) 678 { 679 struct sk_buff *msg; 680 void *hdr; 681 682 pr_debug("DEP link is down\n"); 683 684 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 685 if (!msg) 686 return -ENOMEM; 687 688 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 689 NFC_CMD_DEP_LINK_DOWN); 690 if (!hdr) 691 goto free_msg; 692 693 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) 694 goto nla_put_failure; 695 696 genlmsg_end(msg, hdr); 697 698 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC); 699 700 return 0; 701 702 nla_put_failure: 703 genlmsg_cancel(msg, hdr); 704 free_msg: 705 nlmsg_free(msg); 706 return -EMSGSIZE; 707 } 708 709 static int nfc_genl_get_device(struct sk_buff *skb, struct genl_info *info) 710 { 711 struct sk_buff *msg; 712 struct nfc_dev *dev; 713 u32 idx; 714 int rc = -ENOBUFS; 715 716 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 717 return -EINVAL; 718 719 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 720 721 dev = nfc_get_device(idx); 722 if (!dev) 723 return -ENODEV; 724 725 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 726 if (!msg) { 727 rc = -ENOMEM; 728 goto out_putdev; 729 } 730 731 rc = nfc_genl_send_device(msg, dev, info->snd_portid, info->snd_seq, 732 NULL, 0); 733 if (rc < 0) 734 goto out_free; 735 736 nfc_put_device(dev); 737 738 return genlmsg_reply(msg, info); 739 740 out_free: 741 nlmsg_free(msg); 742 out_putdev: 743 nfc_put_device(dev); 744 return rc; 745 } 746 747 static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info) 748 { 749 struct nfc_dev *dev; 750 int rc; 751 u32 idx; 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 rc = nfc_dev_up(dev); 763 764 nfc_put_device(dev); 765 return rc; 766 } 767 768 static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info) 769 { 770 struct nfc_dev *dev; 771 int rc; 772 u32 idx; 773 774 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 775 return -EINVAL; 776 777 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 778 779 dev = nfc_get_device(idx); 780 if (!dev) 781 return -ENODEV; 782 783 rc = nfc_dev_down(dev); 784 785 nfc_put_device(dev); 786 return rc; 787 } 788 789 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info) 790 { 791 struct nfc_dev *dev; 792 int rc; 793 u32 idx; 794 u32 im_protocols = 0, tm_protocols = 0; 795 796 pr_debug("Poll start\n"); 797 798 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 799 ((!info->attrs[NFC_ATTR_IM_PROTOCOLS] && 800 !info->attrs[NFC_ATTR_PROTOCOLS]) && 801 !info->attrs[NFC_ATTR_TM_PROTOCOLS])) 802 return -EINVAL; 803 804 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 805 806 if (info->attrs[NFC_ATTR_TM_PROTOCOLS]) 807 tm_protocols = nla_get_u32(info->attrs[NFC_ATTR_TM_PROTOCOLS]); 808 809 if (info->attrs[NFC_ATTR_IM_PROTOCOLS]) 810 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_IM_PROTOCOLS]); 811 else if (info->attrs[NFC_ATTR_PROTOCOLS]) 812 im_protocols = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]); 813 814 dev = nfc_get_device(idx); 815 if (!dev) 816 return -ENODEV; 817 818 mutex_lock(&dev->genl_data.genl_data_mutex); 819 820 rc = nfc_start_poll(dev, im_protocols, tm_protocols); 821 if (!rc) 822 dev->genl_data.poll_req_portid = info->snd_portid; 823 824 mutex_unlock(&dev->genl_data.genl_data_mutex); 825 826 nfc_put_device(dev); 827 return rc; 828 } 829 830 static int nfc_genl_stop_poll(struct sk_buff *skb, struct genl_info *info) 831 { 832 struct nfc_dev *dev; 833 int rc; 834 u32 idx; 835 836 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 837 return -EINVAL; 838 839 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 840 841 dev = nfc_get_device(idx); 842 if (!dev) 843 return -ENODEV; 844 845 device_lock(&dev->dev); 846 847 if (!dev->polling) { 848 device_unlock(&dev->dev); 849 return -EINVAL; 850 } 851 852 device_unlock(&dev->dev); 853 854 mutex_lock(&dev->genl_data.genl_data_mutex); 855 856 if (dev->genl_data.poll_req_portid != info->snd_portid) { 857 rc = -EBUSY; 858 goto out; 859 } 860 861 rc = nfc_stop_poll(dev); 862 dev->genl_data.poll_req_portid = 0; 863 864 out: 865 mutex_unlock(&dev->genl_data.genl_data_mutex); 866 nfc_put_device(dev); 867 return rc; 868 } 869 870 static int nfc_genl_activate_target(struct sk_buff *skb, struct genl_info *info) 871 { 872 struct nfc_dev *dev; 873 u32 device_idx, target_idx, protocol; 874 int rc; 875 876 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 877 return -EINVAL; 878 879 device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 880 881 dev = nfc_get_device(device_idx); 882 if (!dev) 883 return -ENODEV; 884 885 target_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]); 886 protocol = nla_get_u32(info->attrs[NFC_ATTR_PROTOCOLS]); 887 888 nfc_deactivate_target(dev, target_idx, NFC_TARGET_MODE_SLEEP); 889 rc = nfc_activate_target(dev, target_idx, protocol); 890 891 nfc_put_device(dev); 892 return 0; 893 } 894 895 static int nfc_genl_dep_link_up(struct sk_buff *skb, struct genl_info *info) 896 { 897 struct nfc_dev *dev; 898 int rc, tgt_idx; 899 u32 idx; 900 u8 comm; 901 902 pr_debug("DEP link up\n"); 903 904 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 905 !info->attrs[NFC_ATTR_COMM_MODE]) 906 return -EINVAL; 907 908 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 909 if (!info->attrs[NFC_ATTR_TARGET_INDEX]) 910 tgt_idx = NFC_TARGET_IDX_ANY; 911 else 912 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]); 913 914 comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]); 915 916 if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE) 917 return -EINVAL; 918 919 dev = nfc_get_device(idx); 920 if (!dev) 921 return -ENODEV; 922 923 rc = nfc_dep_link_up(dev, tgt_idx, comm); 924 925 nfc_put_device(dev); 926 927 return rc; 928 } 929 930 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info) 931 { 932 struct nfc_dev *dev; 933 int rc; 934 u32 idx; 935 936 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 937 return -EINVAL; 938 939 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 940 941 dev = nfc_get_device(idx); 942 if (!dev) 943 return -ENODEV; 944 945 rc = nfc_dep_link_down(dev); 946 947 nfc_put_device(dev); 948 return rc; 949 } 950 951 static int nfc_genl_send_params(struct sk_buff *msg, 952 struct nfc_llcp_local *local, 953 u32 portid, u32 seq) 954 { 955 void *hdr; 956 957 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0, 958 NFC_CMD_LLC_GET_PARAMS); 959 if (!hdr) 960 return -EMSGSIZE; 961 962 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) || 963 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) || 964 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) || 965 nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux))) 966 goto nla_put_failure; 967 968 genlmsg_end(msg, hdr); 969 return 0; 970 971 nla_put_failure: 972 973 genlmsg_cancel(msg, hdr); 974 return -EMSGSIZE; 975 } 976 977 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info) 978 { 979 struct nfc_dev *dev; 980 struct nfc_llcp_local *local; 981 int rc = 0; 982 struct sk_buff *msg = NULL; 983 u32 idx; 984 985 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 986 return -EINVAL; 987 988 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 989 990 dev = nfc_get_device(idx); 991 if (!dev) 992 return -ENODEV; 993 994 device_lock(&dev->dev); 995 996 local = nfc_llcp_find_local(dev); 997 if (!local) { 998 rc = -ENODEV; 999 goto exit; 1000 } 1001 1002 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1003 if (!msg) { 1004 rc = -ENOMEM; 1005 goto exit; 1006 } 1007 1008 rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq); 1009 1010 exit: 1011 device_unlock(&dev->dev); 1012 1013 nfc_put_device(dev); 1014 1015 if (rc < 0) { 1016 if (msg) 1017 nlmsg_free(msg); 1018 1019 return rc; 1020 } 1021 1022 return genlmsg_reply(msg, info); 1023 } 1024 1025 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info) 1026 { 1027 struct nfc_dev *dev; 1028 struct nfc_llcp_local *local; 1029 u8 rw = 0; 1030 u16 miux = 0; 1031 u32 idx; 1032 int rc = 0; 1033 1034 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1035 (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] && 1036 !info->attrs[NFC_ATTR_LLC_PARAM_RW] && 1037 !info->attrs[NFC_ATTR_LLC_PARAM_MIUX])) 1038 return -EINVAL; 1039 1040 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) { 1041 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]); 1042 1043 if (rw > LLCP_MAX_RW) 1044 return -EINVAL; 1045 } 1046 1047 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) { 1048 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]); 1049 1050 if (miux > LLCP_MAX_MIUX) 1051 return -EINVAL; 1052 } 1053 1054 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1055 1056 dev = nfc_get_device(idx); 1057 if (!dev) 1058 return -ENODEV; 1059 1060 device_lock(&dev->dev); 1061 1062 local = nfc_llcp_find_local(dev); 1063 if (!local) { 1064 nfc_put_device(dev); 1065 rc = -ENODEV; 1066 goto exit; 1067 } 1068 1069 if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) { 1070 if (dev->dep_link_up) { 1071 rc = -EINPROGRESS; 1072 goto exit; 1073 } 1074 1075 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]); 1076 } 1077 1078 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) 1079 local->rw = rw; 1080 1081 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) 1082 local->miux = cpu_to_be16(miux); 1083 1084 exit: 1085 device_unlock(&dev->dev); 1086 1087 nfc_put_device(dev); 1088 1089 return rc; 1090 } 1091 1092 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info) 1093 { 1094 struct nfc_dev *dev; 1095 struct nfc_llcp_local *local; 1096 struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1]; 1097 u32 idx; 1098 u8 tid; 1099 char *uri; 1100 int rc = 0, rem; 1101 size_t uri_len, tlvs_len; 1102 struct hlist_head sdreq_list; 1103 struct nfc_llcp_sdp_tlv *sdreq; 1104 1105 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1106 !info->attrs[NFC_ATTR_LLC_SDP]) 1107 return -EINVAL; 1108 1109 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1110 1111 dev = nfc_get_device(idx); 1112 if (!dev) 1113 return -ENODEV; 1114 1115 device_lock(&dev->dev); 1116 1117 if (dev->dep_link_up == false) { 1118 rc = -ENOLINK; 1119 goto exit; 1120 } 1121 1122 local = nfc_llcp_find_local(dev); 1123 if (!local) { 1124 nfc_put_device(dev); 1125 rc = -ENODEV; 1126 goto exit; 1127 } 1128 1129 INIT_HLIST_HEAD(&sdreq_list); 1130 1131 tlvs_len = 0; 1132 1133 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) { 1134 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr, 1135 nfc_sdp_genl_policy); 1136 1137 if (rc != 0) { 1138 rc = -EINVAL; 1139 goto exit; 1140 } 1141 1142 if (!sdp_attrs[NFC_SDP_ATTR_URI]) 1143 continue; 1144 1145 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]); 1146 if (uri_len == 0) 1147 continue; 1148 1149 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]); 1150 if (uri == NULL || *uri == 0) 1151 continue; 1152 1153 tid = local->sdreq_next_tid++; 1154 1155 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len); 1156 if (sdreq == NULL) { 1157 rc = -ENOMEM; 1158 goto exit; 1159 } 1160 1161 tlvs_len += sdreq->tlv_len; 1162 1163 hlist_add_head(&sdreq->node, &sdreq_list); 1164 } 1165 1166 if (hlist_empty(&sdreq_list)) { 1167 rc = -EINVAL; 1168 goto exit; 1169 } 1170 1171 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len); 1172 exit: 1173 device_unlock(&dev->dev); 1174 1175 nfc_put_device(dev); 1176 1177 return rc; 1178 } 1179 1180 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info) 1181 { 1182 struct nfc_dev *dev; 1183 int rc; 1184 u32 idx; 1185 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1]; 1186 1187 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 1188 return -EINVAL; 1189 1190 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1191 1192 dev = nfc_get_device(idx); 1193 if (!dev) 1194 return -ENODEV; 1195 1196 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME], 1197 sizeof(firmware_name)); 1198 1199 rc = nfc_fw_download(dev, firmware_name); 1200 1201 nfc_put_device(dev); 1202 return rc; 1203 } 1204 1205 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name, 1206 u32 result) 1207 { 1208 struct sk_buff *msg; 1209 void *hdr; 1210 1211 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1212 if (!msg) 1213 return -ENOMEM; 1214 1215 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1216 NFC_CMD_FW_DOWNLOAD); 1217 if (!hdr) 1218 goto free_msg; 1219 1220 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) || 1221 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) || 1222 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) 1223 goto nla_put_failure; 1224 1225 genlmsg_end(msg, hdr); 1226 1227 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1228 1229 return 0; 1230 1231 nla_put_failure: 1232 genlmsg_cancel(msg, hdr); 1233 free_msg: 1234 nlmsg_free(msg); 1235 return -EMSGSIZE; 1236 } 1237 1238 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info) 1239 { 1240 struct nfc_dev *dev; 1241 int rc; 1242 u32 idx, se_idx; 1243 1244 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1245 !info->attrs[NFC_ATTR_SE_INDEX]) 1246 return -EINVAL; 1247 1248 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1249 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1250 1251 dev = nfc_get_device(idx); 1252 if (!dev) 1253 return -ENODEV; 1254 1255 rc = nfc_enable_se(dev, se_idx); 1256 1257 nfc_put_device(dev); 1258 return rc; 1259 } 1260 1261 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info) 1262 { 1263 struct nfc_dev *dev; 1264 int rc; 1265 u32 idx, se_idx; 1266 1267 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1268 !info->attrs[NFC_ATTR_SE_INDEX]) 1269 return -EINVAL; 1270 1271 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1272 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1273 1274 dev = nfc_get_device(idx); 1275 if (!dev) 1276 return -ENODEV; 1277 1278 rc = nfc_disable_se(dev, se_idx); 1279 1280 nfc_put_device(dev); 1281 return rc; 1282 } 1283 1284 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev, 1285 u32 portid, u32 seq, 1286 struct netlink_callback *cb, 1287 int flags) 1288 { 1289 void *hdr; 1290 struct nfc_se *se, *n; 1291 1292 list_for_each_entry_safe(se, n, &dev->secure_elements, list) { 1293 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags, 1294 NFC_CMD_GET_SE); 1295 if (!hdr) 1296 goto nla_put_failure; 1297 1298 if (cb) 1299 genl_dump_check_consistent(cb, hdr, &nfc_genl_family); 1300 1301 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) || 1302 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) || 1303 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type)) 1304 goto nla_put_failure; 1305 1306 genlmsg_end(msg, hdr); 1307 } 1308 1309 return 0; 1310 1311 nla_put_failure: 1312 genlmsg_cancel(msg, hdr); 1313 return -EMSGSIZE; 1314 } 1315 1316 static int nfc_genl_dump_ses(struct sk_buff *skb, 1317 struct netlink_callback *cb) 1318 { 1319 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1320 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1]; 1321 bool first_call = false; 1322 1323 if (!iter) { 1324 first_call = true; 1325 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL); 1326 if (!iter) 1327 return -ENOMEM; 1328 cb->args[0] = (long) iter; 1329 } 1330 1331 mutex_lock(&nfc_devlist_mutex); 1332 1333 cb->seq = nfc_devlist_generation; 1334 1335 if (first_call) { 1336 nfc_device_iter_init(iter); 1337 dev = nfc_device_iter_next(iter); 1338 } 1339 1340 while (dev) { 1341 int rc; 1342 1343 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid, 1344 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI); 1345 if (rc < 0) 1346 break; 1347 1348 dev = nfc_device_iter_next(iter); 1349 } 1350 1351 mutex_unlock(&nfc_devlist_mutex); 1352 1353 cb->args[1] = (long) dev; 1354 1355 return skb->len; 1356 } 1357 1358 static int nfc_genl_dump_ses_done(struct netlink_callback *cb) 1359 { 1360 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1361 1362 nfc_device_iter_exit(iter); 1363 kfree(iter); 1364 1365 return 0; 1366 } 1367 1368 static int nfc_se_io(struct nfc_dev *dev, u32 se_idx, 1369 u8 *apdu, size_t apdu_length, 1370 se_io_cb_t cb, void *cb_context) 1371 { 1372 struct nfc_se *se; 1373 int rc; 1374 1375 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 1376 1377 device_lock(&dev->dev); 1378 1379 if (!device_is_registered(&dev->dev)) { 1380 rc = -ENODEV; 1381 goto error; 1382 } 1383 1384 if (!dev->dev_up) { 1385 rc = -ENODEV; 1386 goto error; 1387 } 1388 1389 if (!dev->ops->se_io) { 1390 rc = -EOPNOTSUPP; 1391 goto error; 1392 } 1393 1394 se = nfc_find_se(dev, se_idx); 1395 if (!se) { 1396 rc = -EINVAL; 1397 goto error; 1398 } 1399 1400 if (se->state != NFC_SE_ENABLED) { 1401 rc = -ENODEV; 1402 goto error; 1403 } 1404 1405 rc = dev->ops->se_io(dev, se_idx, apdu, 1406 apdu_length, cb, cb_context); 1407 1408 error: 1409 device_unlock(&dev->dev); 1410 return rc; 1411 } 1412 1413 struct se_io_ctx { 1414 u32 dev_idx; 1415 u32 se_idx; 1416 }; 1417 1418 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err) 1419 { 1420 struct se_io_ctx *ctx = context; 1421 struct sk_buff *msg; 1422 void *hdr; 1423 1424 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1425 if (!msg) { 1426 kfree(ctx); 1427 return; 1428 } 1429 1430 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1431 NFC_CMD_SE_IO); 1432 if (!hdr) 1433 goto free_msg; 1434 1435 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) || 1436 nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) || 1437 nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu)) 1438 goto nla_put_failure; 1439 1440 genlmsg_end(msg, hdr); 1441 1442 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1443 1444 kfree(ctx); 1445 1446 return; 1447 1448 nla_put_failure: 1449 genlmsg_cancel(msg, hdr); 1450 free_msg: 1451 nlmsg_free(msg); 1452 kfree(ctx); 1453 1454 return; 1455 } 1456 1457 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info) 1458 { 1459 struct nfc_dev *dev; 1460 struct se_io_ctx *ctx; 1461 u32 dev_idx, se_idx; 1462 u8 *apdu; 1463 size_t apdu_len; 1464 1465 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1466 !info->attrs[NFC_ATTR_SE_INDEX] || 1467 !info->attrs[NFC_ATTR_SE_APDU]) 1468 return -EINVAL; 1469 1470 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1471 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1472 1473 dev = nfc_get_device(dev_idx); 1474 if (!dev) 1475 return -ENODEV; 1476 1477 if (!dev->ops || !dev->ops->se_io) 1478 return -ENOTSUPP; 1479 1480 apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]); 1481 if (apdu_len == 0) 1482 return -EINVAL; 1483 1484 apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]); 1485 if (!apdu) 1486 return -EINVAL; 1487 1488 ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL); 1489 if (!ctx) 1490 return -ENOMEM; 1491 1492 ctx->dev_idx = dev_idx; 1493 ctx->se_idx = se_idx; 1494 1495 return nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx); 1496 } 1497 1498 static int nfc_genl_vendor_cmd(struct sk_buff *skb, 1499 struct genl_info *info) 1500 { 1501 struct nfc_dev *dev; 1502 struct nfc_vendor_cmd *cmd; 1503 u32 dev_idx, vid, subcmd; 1504 u8 *data; 1505 size_t data_len; 1506 int i, err; 1507 1508 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1509 !info->attrs[NFC_ATTR_VENDOR_ID] || 1510 !info->attrs[NFC_ATTR_VENDOR_SUBCMD]) 1511 return -EINVAL; 1512 1513 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1514 vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]); 1515 subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]); 1516 1517 dev = nfc_get_device(dev_idx); 1518 if (!dev || !dev->vendor_cmds || !dev->n_vendor_cmds) 1519 return -ENODEV; 1520 1521 if (info->attrs[NFC_ATTR_VENDOR_DATA]) { 1522 data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]); 1523 data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]); 1524 if (data_len == 0) 1525 return -EINVAL; 1526 } else { 1527 data = NULL; 1528 data_len = 0; 1529 } 1530 1531 for (i = 0; i < dev->n_vendor_cmds; i++) { 1532 cmd = &dev->vendor_cmds[i]; 1533 1534 if (cmd->vendor_id != vid || cmd->subcmd != subcmd) 1535 continue; 1536 1537 dev->cur_cmd_info = info; 1538 err = cmd->doit(dev, data, data_len); 1539 dev->cur_cmd_info = NULL; 1540 return err; 1541 } 1542 1543 return -EOPNOTSUPP; 1544 } 1545 1546 /* message building helper */ 1547 static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq, 1548 int flags, u8 cmd) 1549 { 1550 /* since there is no private header just add the generic one */ 1551 return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd); 1552 } 1553 1554 static struct sk_buff * 1555 __nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen, 1556 u32 portid, u32 seq, 1557 enum nfc_attrs attr, 1558 u32 oui, u32 subcmd, gfp_t gfp) 1559 { 1560 struct sk_buff *skb; 1561 void *hdr; 1562 1563 skb = nlmsg_new(approxlen + 100, gfp); 1564 if (!skb) 1565 return NULL; 1566 1567 hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR); 1568 if (!hdr) { 1569 kfree_skb(skb); 1570 return NULL; 1571 } 1572 1573 if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx)) 1574 goto nla_put_failure; 1575 if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui)) 1576 goto nla_put_failure; 1577 if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd)) 1578 goto nla_put_failure; 1579 1580 ((void **)skb->cb)[0] = dev; 1581 ((void **)skb->cb)[1] = hdr; 1582 1583 return skb; 1584 1585 nla_put_failure: 1586 kfree_skb(skb); 1587 return NULL; 1588 } 1589 1590 struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev, 1591 enum nfc_attrs attr, 1592 u32 oui, u32 subcmd, 1593 int approxlen) 1594 { 1595 if (WARN_ON(!dev->cur_cmd_info)) 1596 return NULL; 1597 1598 return __nfc_alloc_vendor_cmd_skb(dev, approxlen, 1599 dev->cur_cmd_info->snd_portid, 1600 dev->cur_cmd_info->snd_seq, attr, 1601 oui, subcmd, GFP_KERNEL); 1602 } 1603 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb); 1604 1605 int nfc_vendor_cmd_reply(struct sk_buff *skb) 1606 { 1607 struct nfc_dev *dev = ((void **)skb->cb)[0]; 1608 void *hdr = ((void **)skb->cb)[1]; 1609 1610 /* clear CB data for netlink core to own from now on */ 1611 memset(skb->cb, 0, sizeof(skb->cb)); 1612 1613 if (WARN_ON(!dev->cur_cmd_info)) { 1614 kfree_skb(skb); 1615 return -EINVAL; 1616 } 1617 1618 genlmsg_end(skb, hdr); 1619 return genlmsg_reply(skb, dev->cur_cmd_info); 1620 } 1621 EXPORT_SYMBOL(nfc_vendor_cmd_reply); 1622 1623 static const struct genl_ops nfc_genl_ops[] = { 1624 { 1625 .cmd = NFC_CMD_GET_DEVICE, 1626 .doit = nfc_genl_get_device, 1627 .dumpit = nfc_genl_dump_devices, 1628 .done = nfc_genl_dump_devices_done, 1629 .policy = nfc_genl_policy, 1630 }, 1631 { 1632 .cmd = NFC_CMD_DEV_UP, 1633 .doit = nfc_genl_dev_up, 1634 .policy = nfc_genl_policy, 1635 }, 1636 { 1637 .cmd = NFC_CMD_DEV_DOWN, 1638 .doit = nfc_genl_dev_down, 1639 .policy = nfc_genl_policy, 1640 }, 1641 { 1642 .cmd = NFC_CMD_START_POLL, 1643 .doit = nfc_genl_start_poll, 1644 .policy = nfc_genl_policy, 1645 }, 1646 { 1647 .cmd = NFC_CMD_STOP_POLL, 1648 .doit = nfc_genl_stop_poll, 1649 .policy = nfc_genl_policy, 1650 }, 1651 { 1652 .cmd = NFC_CMD_DEP_LINK_UP, 1653 .doit = nfc_genl_dep_link_up, 1654 .policy = nfc_genl_policy, 1655 }, 1656 { 1657 .cmd = NFC_CMD_DEP_LINK_DOWN, 1658 .doit = nfc_genl_dep_link_down, 1659 .policy = nfc_genl_policy, 1660 }, 1661 { 1662 .cmd = NFC_CMD_GET_TARGET, 1663 .dumpit = nfc_genl_dump_targets, 1664 .done = nfc_genl_dump_targets_done, 1665 .policy = nfc_genl_policy, 1666 }, 1667 { 1668 .cmd = NFC_CMD_LLC_GET_PARAMS, 1669 .doit = nfc_genl_llc_get_params, 1670 .policy = nfc_genl_policy, 1671 }, 1672 { 1673 .cmd = NFC_CMD_LLC_SET_PARAMS, 1674 .doit = nfc_genl_llc_set_params, 1675 .policy = nfc_genl_policy, 1676 }, 1677 { 1678 .cmd = NFC_CMD_LLC_SDREQ, 1679 .doit = nfc_genl_llc_sdreq, 1680 .policy = nfc_genl_policy, 1681 }, 1682 { 1683 .cmd = NFC_CMD_FW_DOWNLOAD, 1684 .doit = nfc_genl_fw_download, 1685 .policy = nfc_genl_policy, 1686 }, 1687 { 1688 .cmd = NFC_CMD_ENABLE_SE, 1689 .doit = nfc_genl_enable_se, 1690 .policy = nfc_genl_policy, 1691 }, 1692 { 1693 .cmd = NFC_CMD_DISABLE_SE, 1694 .doit = nfc_genl_disable_se, 1695 .policy = nfc_genl_policy, 1696 }, 1697 { 1698 .cmd = NFC_CMD_GET_SE, 1699 .dumpit = nfc_genl_dump_ses, 1700 .done = nfc_genl_dump_ses_done, 1701 .policy = nfc_genl_policy, 1702 }, 1703 { 1704 .cmd = NFC_CMD_SE_IO, 1705 .doit = nfc_genl_se_io, 1706 .policy = nfc_genl_policy, 1707 }, 1708 { 1709 .cmd = NFC_CMD_ACTIVATE_TARGET, 1710 .doit = nfc_genl_activate_target, 1711 .policy = nfc_genl_policy, 1712 }, 1713 { 1714 .cmd = NFC_CMD_VENDOR, 1715 .doit = nfc_genl_vendor_cmd, 1716 .policy = nfc_genl_policy, 1717 }, 1718 }; 1719 1720 1721 struct urelease_work { 1722 struct work_struct w; 1723 u32 portid; 1724 }; 1725 1726 static void nfc_urelease_event_work(struct work_struct *work) 1727 { 1728 struct urelease_work *w = container_of(work, struct urelease_work, w); 1729 struct class_dev_iter iter; 1730 struct nfc_dev *dev; 1731 1732 pr_debug("portid %d\n", w->portid); 1733 1734 mutex_lock(&nfc_devlist_mutex); 1735 1736 nfc_device_iter_init(&iter); 1737 dev = nfc_device_iter_next(&iter); 1738 1739 while (dev) { 1740 mutex_lock(&dev->genl_data.genl_data_mutex); 1741 1742 if (dev->genl_data.poll_req_portid == w->portid) { 1743 nfc_stop_poll(dev); 1744 dev->genl_data.poll_req_portid = 0; 1745 } 1746 1747 mutex_unlock(&dev->genl_data.genl_data_mutex); 1748 1749 dev = nfc_device_iter_next(&iter); 1750 } 1751 1752 nfc_device_iter_exit(&iter); 1753 1754 mutex_unlock(&nfc_devlist_mutex); 1755 1756 kfree(w); 1757 } 1758 1759 static int nfc_genl_rcv_nl_event(struct notifier_block *this, 1760 unsigned long event, void *ptr) 1761 { 1762 struct netlink_notify *n = ptr; 1763 struct urelease_work *w; 1764 1765 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC) 1766 goto out; 1767 1768 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid); 1769 1770 w = kmalloc(sizeof(*w), GFP_ATOMIC); 1771 if (w) { 1772 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work); 1773 w->portid = n->portid; 1774 schedule_work((struct work_struct *) w); 1775 } 1776 1777 out: 1778 return NOTIFY_DONE; 1779 } 1780 1781 void nfc_genl_data_init(struct nfc_genl_data *genl_data) 1782 { 1783 genl_data->poll_req_portid = 0; 1784 mutex_init(&genl_data->genl_data_mutex); 1785 } 1786 1787 void nfc_genl_data_exit(struct nfc_genl_data *genl_data) 1788 { 1789 mutex_destroy(&genl_data->genl_data_mutex); 1790 } 1791 1792 static struct notifier_block nl_notifier = { 1793 .notifier_call = nfc_genl_rcv_nl_event, 1794 }; 1795 1796 /** 1797 * nfc_genl_init() - Initialize netlink interface 1798 * 1799 * This initialization function registers the nfc netlink family. 1800 */ 1801 int __init nfc_genl_init(void) 1802 { 1803 int rc; 1804 1805 rc = genl_register_family_with_ops_groups(&nfc_genl_family, 1806 nfc_genl_ops, 1807 nfc_genl_mcgrps); 1808 if (rc) 1809 return rc; 1810 1811 netlink_register_notifier(&nl_notifier); 1812 1813 return 0; 1814 } 1815 1816 /** 1817 * nfc_genl_exit() - Deinitialize netlink interface 1818 * 1819 * This exit function unregisters the nfc netlink family. 1820 */ 1821 void nfc_genl_exit(void) 1822 { 1823 netlink_unregister_notifier(&nl_notifier); 1824 genl_unregister_family(&nfc_genl_family); 1825 } 1826