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); 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 rc = -ENODEV; 1114 goto exit; 1115 } 1116 1117 device_lock(&dev->dev); 1118 1119 if (dev->dep_link_up == false) { 1120 rc = -ENOLINK; 1121 goto exit; 1122 } 1123 1124 local = nfc_llcp_find_local(dev); 1125 if (!local) { 1126 nfc_put_device(dev); 1127 rc = -ENODEV; 1128 goto exit; 1129 } 1130 1131 INIT_HLIST_HEAD(&sdreq_list); 1132 1133 tlvs_len = 0; 1134 1135 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) { 1136 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr, 1137 nfc_sdp_genl_policy); 1138 1139 if (rc != 0) { 1140 rc = -EINVAL; 1141 goto exit; 1142 } 1143 1144 if (!sdp_attrs[NFC_SDP_ATTR_URI]) 1145 continue; 1146 1147 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]); 1148 if (uri_len == 0) 1149 continue; 1150 1151 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]); 1152 if (uri == NULL || *uri == 0) 1153 continue; 1154 1155 tid = local->sdreq_next_tid++; 1156 1157 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len); 1158 if (sdreq == NULL) { 1159 rc = -ENOMEM; 1160 goto exit; 1161 } 1162 1163 tlvs_len += sdreq->tlv_len; 1164 1165 hlist_add_head(&sdreq->node, &sdreq_list); 1166 } 1167 1168 if (hlist_empty(&sdreq_list)) { 1169 rc = -EINVAL; 1170 goto exit; 1171 } 1172 1173 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len); 1174 exit: 1175 device_unlock(&dev->dev); 1176 1177 nfc_put_device(dev); 1178 1179 return rc; 1180 } 1181 1182 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info) 1183 { 1184 struct nfc_dev *dev; 1185 int rc; 1186 u32 idx; 1187 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1]; 1188 1189 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 1190 return -EINVAL; 1191 1192 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1193 1194 dev = nfc_get_device(idx); 1195 if (!dev) 1196 return -ENODEV; 1197 1198 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME], 1199 sizeof(firmware_name)); 1200 1201 rc = nfc_fw_download(dev, firmware_name); 1202 1203 nfc_put_device(dev); 1204 return rc; 1205 } 1206 1207 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name, 1208 u32 result) 1209 { 1210 struct sk_buff *msg; 1211 void *hdr; 1212 1213 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1214 if (!msg) 1215 return -ENOMEM; 1216 1217 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1218 NFC_CMD_FW_DOWNLOAD); 1219 if (!hdr) 1220 goto free_msg; 1221 1222 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) || 1223 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) || 1224 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) 1225 goto nla_put_failure; 1226 1227 genlmsg_end(msg, hdr); 1228 1229 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1230 1231 return 0; 1232 1233 nla_put_failure: 1234 genlmsg_cancel(msg, hdr); 1235 free_msg: 1236 nlmsg_free(msg); 1237 return -EMSGSIZE; 1238 } 1239 1240 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info) 1241 { 1242 struct nfc_dev *dev; 1243 int rc; 1244 u32 idx, se_idx; 1245 1246 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1247 !info->attrs[NFC_ATTR_SE_INDEX]) 1248 return -EINVAL; 1249 1250 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1251 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1252 1253 dev = nfc_get_device(idx); 1254 if (!dev) 1255 return -ENODEV; 1256 1257 rc = nfc_enable_se(dev, se_idx); 1258 1259 nfc_put_device(dev); 1260 return rc; 1261 } 1262 1263 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info) 1264 { 1265 struct nfc_dev *dev; 1266 int rc; 1267 u32 idx, se_idx; 1268 1269 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1270 !info->attrs[NFC_ATTR_SE_INDEX]) 1271 return -EINVAL; 1272 1273 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1274 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1275 1276 dev = nfc_get_device(idx); 1277 if (!dev) 1278 return -ENODEV; 1279 1280 rc = nfc_disable_se(dev, se_idx); 1281 1282 nfc_put_device(dev); 1283 return rc; 1284 } 1285 1286 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev, 1287 u32 portid, u32 seq, 1288 struct netlink_callback *cb, 1289 int flags) 1290 { 1291 void *hdr; 1292 struct nfc_se *se, *n; 1293 1294 list_for_each_entry_safe(se, n, &dev->secure_elements, list) { 1295 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags, 1296 NFC_CMD_GET_SE); 1297 if (!hdr) 1298 goto nla_put_failure; 1299 1300 if (cb) 1301 genl_dump_check_consistent(cb, hdr, &nfc_genl_family); 1302 1303 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) || 1304 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) || 1305 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type)) 1306 goto nla_put_failure; 1307 1308 genlmsg_end(msg, hdr); 1309 } 1310 1311 return 0; 1312 1313 nla_put_failure: 1314 genlmsg_cancel(msg, hdr); 1315 return -EMSGSIZE; 1316 } 1317 1318 static int nfc_genl_dump_ses(struct sk_buff *skb, 1319 struct netlink_callback *cb) 1320 { 1321 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1322 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1]; 1323 bool first_call = false; 1324 1325 if (!iter) { 1326 first_call = true; 1327 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL); 1328 if (!iter) 1329 return -ENOMEM; 1330 cb->args[0] = (long) iter; 1331 } 1332 1333 mutex_lock(&nfc_devlist_mutex); 1334 1335 cb->seq = nfc_devlist_generation; 1336 1337 if (first_call) { 1338 nfc_device_iter_init(iter); 1339 dev = nfc_device_iter_next(iter); 1340 } 1341 1342 while (dev) { 1343 int rc; 1344 1345 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid, 1346 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI); 1347 if (rc < 0) 1348 break; 1349 1350 dev = nfc_device_iter_next(iter); 1351 } 1352 1353 mutex_unlock(&nfc_devlist_mutex); 1354 1355 cb->args[1] = (long) dev; 1356 1357 return skb->len; 1358 } 1359 1360 static int nfc_genl_dump_ses_done(struct netlink_callback *cb) 1361 { 1362 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1363 1364 nfc_device_iter_exit(iter); 1365 kfree(iter); 1366 1367 return 0; 1368 } 1369 1370 static int nfc_se_io(struct nfc_dev *dev, u32 se_idx, 1371 u8 *apdu, size_t apdu_length, 1372 se_io_cb_t cb, void *cb_context) 1373 { 1374 struct nfc_se *se; 1375 int rc; 1376 1377 pr_debug("%s se index %d\n", dev_name(&dev->dev), se_idx); 1378 1379 device_lock(&dev->dev); 1380 1381 if (!device_is_registered(&dev->dev)) { 1382 rc = -ENODEV; 1383 goto error; 1384 } 1385 1386 if (!dev->dev_up) { 1387 rc = -ENODEV; 1388 goto error; 1389 } 1390 1391 if (!dev->ops->se_io) { 1392 rc = -EOPNOTSUPP; 1393 goto error; 1394 } 1395 1396 se = nfc_find_se(dev, se_idx); 1397 if (!se) { 1398 rc = -EINVAL; 1399 goto error; 1400 } 1401 1402 if (se->state != NFC_SE_ENABLED) { 1403 rc = -ENODEV; 1404 goto error; 1405 } 1406 1407 rc = dev->ops->se_io(dev, se_idx, apdu, 1408 apdu_length, cb, cb_context); 1409 1410 error: 1411 device_unlock(&dev->dev); 1412 return rc; 1413 } 1414 1415 struct se_io_ctx { 1416 u32 dev_idx; 1417 u32 se_idx; 1418 }; 1419 1420 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err) 1421 { 1422 struct se_io_ctx *ctx = context; 1423 struct sk_buff *msg; 1424 void *hdr; 1425 1426 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1427 if (!msg) { 1428 kfree(ctx); 1429 return; 1430 } 1431 1432 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1433 NFC_CMD_SE_IO); 1434 if (!hdr) 1435 goto free_msg; 1436 1437 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) || 1438 nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) || 1439 nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu)) 1440 goto nla_put_failure; 1441 1442 genlmsg_end(msg, hdr); 1443 1444 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1445 1446 kfree(ctx); 1447 1448 return; 1449 1450 nla_put_failure: 1451 genlmsg_cancel(msg, hdr); 1452 free_msg: 1453 nlmsg_free(msg); 1454 kfree(ctx); 1455 1456 return; 1457 } 1458 1459 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info) 1460 { 1461 struct nfc_dev *dev; 1462 struct se_io_ctx *ctx; 1463 u32 dev_idx, se_idx; 1464 u8 *apdu; 1465 size_t apdu_len; 1466 1467 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1468 !info->attrs[NFC_ATTR_SE_INDEX] || 1469 !info->attrs[NFC_ATTR_SE_APDU]) 1470 return -EINVAL; 1471 1472 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1473 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1474 1475 dev = nfc_get_device(dev_idx); 1476 if (!dev) 1477 return -ENODEV; 1478 1479 if (!dev->ops || !dev->ops->se_io) 1480 return -ENOTSUPP; 1481 1482 apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]); 1483 if (apdu_len == 0) 1484 return -EINVAL; 1485 1486 apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]); 1487 if (!apdu) 1488 return -EINVAL; 1489 1490 ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL); 1491 if (!ctx) 1492 return -ENOMEM; 1493 1494 ctx->dev_idx = dev_idx; 1495 ctx->se_idx = se_idx; 1496 1497 return nfc_se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx); 1498 } 1499 1500 static int nfc_genl_vendor_cmd(struct sk_buff *skb, 1501 struct genl_info *info) 1502 { 1503 struct nfc_dev *dev; 1504 struct nfc_vendor_cmd *cmd; 1505 u32 dev_idx, vid, subcmd; 1506 u8 *data; 1507 size_t data_len; 1508 int i, err; 1509 1510 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1511 !info->attrs[NFC_ATTR_VENDOR_ID] || 1512 !info->attrs[NFC_ATTR_VENDOR_SUBCMD]) 1513 return -EINVAL; 1514 1515 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1516 vid = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_ID]); 1517 subcmd = nla_get_u32(info->attrs[NFC_ATTR_VENDOR_SUBCMD]); 1518 1519 dev = nfc_get_device(dev_idx); 1520 if (!dev || !dev->vendor_cmds || !dev->n_vendor_cmds) 1521 return -ENODEV; 1522 1523 if (info->attrs[NFC_ATTR_VENDOR_DATA]) { 1524 data = nla_data(info->attrs[NFC_ATTR_VENDOR_DATA]); 1525 data_len = nla_len(info->attrs[NFC_ATTR_VENDOR_DATA]); 1526 if (data_len == 0) 1527 return -EINVAL; 1528 } else { 1529 data = NULL; 1530 data_len = 0; 1531 } 1532 1533 for (i = 0; i < dev->n_vendor_cmds; i++) { 1534 cmd = &dev->vendor_cmds[i]; 1535 1536 if (cmd->vendor_id != vid || cmd->subcmd != subcmd) 1537 continue; 1538 1539 dev->cur_cmd_info = info; 1540 err = cmd->doit(dev, data, data_len); 1541 dev->cur_cmd_info = NULL; 1542 return err; 1543 } 1544 1545 return -EOPNOTSUPP; 1546 } 1547 1548 /* message building helper */ 1549 static inline void *nfc_hdr_put(struct sk_buff *skb, u32 portid, u32 seq, 1550 int flags, u8 cmd) 1551 { 1552 /* since there is no private header just add the generic one */ 1553 return genlmsg_put(skb, portid, seq, &nfc_genl_family, flags, cmd); 1554 } 1555 1556 static struct sk_buff * 1557 __nfc_alloc_vendor_cmd_skb(struct nfc_dev *dev, int approxlen, 1558 u32 portid, u32 seq, 1559 enum nfc_attrs attr, 1560 u32 oui, u32 subcmd, gfp_t gfp) 1561 { 1562 struct sk_buff *skb; 1563 void *hdr; 1564 1565 skb = nlmsg_new(approxlen + 100, gfp); 1566 if (!skb) 1567 return NULL; 1568 1569 hdr = nfc_hdr_put(skb, portid, seq, 0, NFC_CMD_VENDOR); 1570 if (!hdr) { 1571 kfree_skb(skb); 1572 return NULL; 1573 } 1574 1575 if (nla_put_u32(skb, NFC_ATTR_DEVICE_INDEX, dev->idx)) 1576 goto nla_put_failure; 1577 if (nla_put_u32(skb, NFC_ATTR_VENDOR_ID, oui)) 1578 goto nla_put_failure; 1579 if (nla_put_u32(skb, NFC_ATTR_VENDOR_SUBCMD, subcmd)) 1580 goto nla_put_failure; 1581 1582 ((void **)skb->cb)[0] = dev; 1583 ((void **)skb->cb)[1] = hdr; 1584 1585 return skb; 1586 1587 nla_put_failure: 1588 kfree_skb(skb); 1589 return NULL; 1590 } 1591 1592 struct sk_buff *__nfc_alloc_vendor_cmd_reply_skb(struct nfc_dev *dev, 1593 enum nfc_attrs attr, 1594 u32 oui, u32 subcmd, 1595 int approxlen) 1596 { 1597 if (WARN_ON(!dev->cur_cmd_info)) 1598 return NULL; 1599 1600 return __nfc_alloc_vendor_cmd_skb(dev, approxlen, 1601 dev->cur_cmd_info->snd_portid, 1602 dev->cur_cmd_info->snd_seq, attr, 1603 oui, subcmd, GFP_KERNEL); 1604 } 1605 EXPORT_SYMBOL(__nfc_alloc_vendor_cmd_reply_skb); 1606 1607 int nfc_vendor_cmd_reply(struct sk_buff *skb) 1608 { 1609 struct nfc_dev *dev = ((void **)skb->cb)[0]; 1610 void *hdr = ((void **)skb->cb)[1]; 1611 1612 /* clear CB data for netlink core to own from now on */ 1613 memset(skb->cb, 0, sizeof(skb->cb)); 1614 1615 if (WARN_ON(!dev->cur_cmd_info)) { 1616 kfree_skb(skb); 1617 return -EINVAL; 1618 } 1619 1620 genlmsg_end(skb, hdr); 1621 return genlmsg_reply(skb, dev->cur_cmd_info); 1622 } 1623 EXPORT_SYMBOL(nfc_vendor_cmd_reply); 1624 1625 static const struct genl_ops nfc_genl_ops[] = { 1626 { 1627 .cmd = NFC_CMD_GET_DEVICE, 1628 .doit = nfc_genl_get_device, 1629 .dumpit = nfc_genl_dump_devices, 1630 .done = nfc_genl_dump_devices_done, 1631 .policy = nfc_genl_policy, 1632 }, 1633 { 1634 .cmd = NFC_CMD_DEV_UP, 1635 .doit = nfc_genl_dev_up, 1636 .policy = nfc_genl_policy, 1637 }, 1638 { 1639 .cmd = NFC_CMD_DEV_DOWN, 1640 .doit = nfc_genl_dev_down, 1641 .policy = nfc_genl_policy, 1642 }, 1643 { 1644 .cmd = NFC_CMD_START_POLL, 1645 .doit = nfc_genl_start_poll, 1646 .policy = nfc_genl_policy, 1647 }, 1648 { 1649 .cmd = NFC_CMD_STOP_POLL, 1650 .doit = nfc_genl_stop_poll, 1651 .policy = nfc_genl_policy, 1652 }, 1653 { 1654 .cmd = NFC_CMD_DEP_LINK_UP, 1655 .doit = nfc_genl_dep_link_up, 1656 .policy = nfc_genl_policy, 1657 }, 1658 { 1659 .cmd = NFC_CMD_DEP_LINK_DOWN, 1660 .doit = nfc_genl_dep_link_down, 1661 .policy = nfc_genl_policy, 1662 }, 1663 { 1664 .cmd = NFC_CMD_GET_TARGET, 1665 .dumpit = nfc_genl_dump_targets, 1666 .done = nfc_genl_dump_targets_done, 1667 .policy = nfc_genl_policy, 1668 }, 1669 { 1670 .cmd = NFC_CMD_LLC_GET_PARAMS, 1671 .doit = nfc_genl_llc_get_params, 1672 .policy = nfc_genl_policy, 1673 }, 1674 { 1675 .cmd = NFC_CMD_LLC_SET_PARAMS, 1676 .doit = nfc_genl_llc_set_params, 1677 .policy = nfc_genl_policy, 1678 }, 1679 { 1680 .cmd = NFC_CMD_LLC_SDREQ, 1681 .doit = nfc_genl_llc_sdreq, 1682 .policy = nfc_genl_policy, 1683 }, 1684 { 1685 .cmd = NFC_CMD_FW_DOWNLOAD, 1686 .doit = nfc_genl_fw_download, 1687 .policy = nfc_genl_policy, 1688 }, 1689 { 1690 .cmd = NFC_CMD_ENABLE_SE, 1691 .doit = nfc_genl_enable_se, 1692 .policy = nfc_genl_policy, 1693 }, 1694 { 1695 .cmd = NFC_CMD_DISABLE_SE, 1696 .doit = nfc_genl_disable_se, 1697 .policy = nfc_genl_policy, 1698 }, 1699 { 1700 .cmd = NFC_CMD_GET_SE, 1701 .dumpit = nfc_genl_dump_ses, 1702 .done = nfc_genl_dump_ses_done, 1703 .policy = nfc_genl_policy, 1704 }, 1705 { 1706 .cmd = NFC_CMD_SE_IO, 1707 .doit = nfc_genl_se_io, 1708 .policy = nfc_genl_policy, 1709 }, 1710 { 1711 .cmd = NFC_CMD_ACTIVATE_TARGET, 1712 .doit = nfc_genl_activate_target, 1713 .policy = nfc_genl_policy, 1714 }, 1715 { 1716 .cmd = NFC_CMD_VENDOR, 1717 .doit = nfc_genl_vendor_cmd, 1718 .policy = nfc_genl_policy, 1719 }, 1720 }; 1721 1722 1723 struct urelease_work { 1724 struct work_struct w; 1725 u32 portid; 1726 }; 1727 1728 static void nfc_urelease_event_work(struct work_struct *work) 1729 { 1730 struct urelease_work *w = container_of(work, struct urelease_work, w); 1731 struct class_dev_iter iter; 1732 struct nfc_dev *dev; 1733 1734 pr_debug("portid %d\n", w->portid); 1735 1736 mutex_lock(&nfc_devlist_mutex); 1737 1738 nfc_device_iter_init(&iter); 1739 dev = nfc_device_iter_next(&iter); 1740 1741 while (dev) { 1742 mutex_lock(&dev->genl_data.genl_data_mutex); 1743 1744 if (dev->genl_data.poll_req_portid == w->portid) { 1745 nfc_stop_poll(dev); 1746 dev->genl_data.poll_req_portid = 0; 1747 } 1748 1749 mutex_unlock(&dev->genl_data.genl_data_mutex); 1750 1751 dev = nfc_device_iter_next(&iter); 1752 } 1753 1754 nfc_device_iter_exit(&iter); 1755 1756 mutex_unlock(&nfc_devlist_mutex); 1757 1758 kfree(w); 1759 } 1760 1761 static int nfc_genl_rcv_nl_event(struct notifier_block *this, 1762 unsigned long event, void *ptr) 1763 { 1764 struct netlink_notify *n = ptr; 1765 struct urelease_work *w; 1766 1767 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC) 1768 goto out; 1769 1770 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid); 1771 1772 w = kmalloc(sizeof(*w), GFP_ATOMIC); 1773 if (w) { 1774 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work); 1775 w->portid = n->portid; 1776 schedule_work((struct work_struct *) w); 1777 } 1778 1779 out: 1780 return NOTIFY_DONE; 1781 } 1782 1783 void nfc_genl_data_init(struct nfc_genl_data *genl_data) 1784 { 1785 genl_data->poll_req_portid = 0; 1786 mutex_init(&genl_data->genl_data_mutex); 1787 } 1788 1789 void nfc_genl_data_exit(struct nfc_genl_data *genl_data) 1790 { 1791 mutex_destroy(&genl_data->genl_data_mutex); 1792 } 1793 1794 static struct notifier_block nl_notifier = { 1795 .notifier_call = nfc_genl_rcv_nl_event, 1796 }; 1797 1798 /** 1799 * nfc_genl_init() - Initialize netlink interface 1800 * 1801 * This initialization function registers the nfc netlink family. 1802 */ 1803 int __init nfc_genl_init(void) 1804 { 1805 int rc; 1806 1807 rc = genl_register_family_with_ops_groups(&nfc_genl_family, 1808 nfc_genl_ops, 1809 nfc_genl_mcgrps); 1810 if (rc) 1811 return rc; 1812 1813 netlink_register_notifier(&nl_notifier); 1814 1815 return 0; 1816 } 1817 1818 /** 1819 * nfc_genl_exit() - Deinitialize netlink interface 1820 * 1821 * This exit function unregisters the nfc netlink family. 1822 */ 1823 void nfc_genl_exit(void) 1824 { 1825 netlink_unregister_notifier(&nl_notifier); 1826 genl_unregister_family(&nfc_genl_family); 1827 } 1828