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