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