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_dep_link_up(struct sk_buff *skb, struct genl_info *info) 814 { 815 struct nfc_dev *dev; 816 int rc, tgt_idx; 817 u32 idx; 818 u8 comm; 819 820 pr_debug("DEP link up\n"); 821 822 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 823 !info->attrs[NFC_ATTR_COMM_MODE]) 824 return -EINVAL; 825 826 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 827 if (!info->attrs[NFC_ATTR_TARGET_INDEX]) 828 tgt_idx = NFC_TARGET_IDX_ANY; 829 else 830 tgt_idx = nla_get_u32(info->attrs[NFC_ATTR_TARGET_INDEX]); 831 832 comm = nla_get_u8(info->attrs[NFC_ATTR_COMM_MODE]); 833 834 if (comm != NFC_COMM_ACTIVE && comm != NFC_COMM_PASSIVE) 835 return -EINVAL; 836 837 dev = nfc_get_device(idx); 838 if (!dev) 839 return -ENODEV; 840 841 rc = nfc_dep_link_up(dev, tgt_idx, comm); 842 843 nfc_put_device(dev); 844 845 return rc; 846 } 847 848 static int nfc_genl_dep_link_down(struct sk_buff *skb, struct genl_info *info) 849 { 850 struct nfc_dev *dev; 851 int rc; 852 u32 idx; 853 854 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 855 return -EINVAL; 856 857 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 858 859 dev = nfc_get_device(idx); 860 if (!dev) 861 return -ENODEV; 862 863 rc = nfc_dep_link_down(dev); 864 865 nfc_put_device(dev); 866 return rc; 867 } 868 869 static int nfc_genl_send_params(struct sk_buff *msg, 870 struct nfc_llcp_local *local, 871 u32 portid, u32 seq) 872 { 873 void *hdr; 874 875 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, 0, 876 NFC_CMD_LLC_GET_PARAMS); 877 if (!hdr) 878 return -EMSGSIZE; 879 880 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, local->dev->idx) || 881 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_LTO, local->lto) || 882 nla_put_u8(msg, NFC_ATTR_LLC_PARAM_RW, local->rw) || 883 nla_put_u16(msg, NFC_ATTR_LLC_PARAM_MIUX, be16_to_cpu(local->miux))) 884 goto nla_put_failure; 885 886 return genlmsg_end(msg, hdr); 887 888 nla_put_failure: 889 890 genlmsg_cancel(msg, hdr); 891 return -EMSGSIZE; 892 } 893 894 static int nfc_genl_llc_get_params(struct sk_buff *skb, struct genl_info *info) 895 { 896 struct nfc_dev *dev; 897 struct nfc_llcp_local *local; 898 int rc = 0; 899 struct sk_buff *msg = NULL; 900 u32 idx; 901 902 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 903 return -EINVAL; 904 905 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 906 907 dev = nfc_get_device(idx); 908 if (!dev) 909 return -ENODEV; 910 911 device_lock(&dev->dev); 912 913 local = nfc_llcp_find_local(dev); 914 if (!local) { 915 rc = -ENODEV; 916 goto exit; 917 } 918 919 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 920 if (!msg) { 921 rc = -ENOMEM; 922 goto exit; 923 } 924 925 rc = nfc_genl_send_params(msg, local, info->snd_portid, info->snd_seq); 926 927 exit: 928 device_unlock(&dev->dev); 929 930 nfc_put_device(dev); 931 932 if (rc < 0) { 933 if (msg) 934 nlmsg_free(msg); 935 936 return rc; 937 } 938 939 return genlmsg_reply(msg, info); 940 } 941 942 static int nfc_genl_llc_set_params(struct sk_buff *skb, struct genl_info *info) 943 { 944 struct nfc_dev *dev; 945 struct nfc_llcp_local *local; 946 u8 rw = 0; 947 u16 miux = 0; 948 u32 idx; 949 int rc = 0; 950 951 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 952 (!info->attrs[NFC_ATTR_LLC_PARAM_LTO] && 953 !info->attrs[NFC_ATTR_LLC_PARAM_RW] && 954 !info->attrs[NFC_ATTR_LLC_PARAM_MIUX])) 955 return -EINVAL; 956 957 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) { 958 rw = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_RW]); 959 960 if (rw > LLCP_MAX_RW) 961 return -EINVAL; 962 } 963 964 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) { 965 miux = nla_get_u16(info->attrs[NFC_ATTR_LLC_PARAM_MIUX]); 966 967 if (miux > LLCP_MAX_MIUX) 968 return -EINVAL; 969 } 970 971 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 972 973 dev = nfc_get_device(idx); 974 if (!dev) 975 return -ENODEV; 976 977 device_lock(&dev->dev); 978 979 local = nfc_llcp_find_local(dev); 980 if (!local) { 981 nfc_put_device(dev); 982 rc = -ENODEV; 983 goto exit; 984 } 985 986 if (info->attrs[NFC_ATTR_LLC_PARAM_LTO]) { 987 if (dev->dep_link_up) { 988 rc = -EINPROGRESS; 989 goto exit; 990 } 991 992 local->lto = nla_get_u8(info->attrs[NFC_ATTR_LLC_PARAM_LTO]); 993 } 994 995 if (info->attrs[NFC_ATTR_LLC_PARAM_RW]) 996 local->rw = rw; 997 998 if (info->attrs[NFC_ATTR_LLC_PARAM_MIUX]) 999 local->miux = cpu_to_be16(miux); 1000 1001 exit: 1002 device_unlock(&dev->dev); 1003 1004 nfc_put_device(dev); 1005 1006 return rc; 1007 } 1008 1009 static int nfc_genl_llc_sdreq(struct sk_buff *skb, struct genl_info *info) 1010 { 1011 struct nfc_dev *dev; 1012 struct nfc_llcp_local *local; 1013 struct nlattr *attr, *sdp_attrs[NFC_SDP_ATTR_MAX+1]; 1014 u32 idx; 1015 u8 tid; 1016 char *uri; 1017 int rc = 0, rem; 1018 size_t uri_len, tlvs_len; 1019 struct hlist_head sdreq_list; 1020 struct nfc_llcp_sdp_tlv *sdreq; 1021 1022 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1023 !info->attrs[NFC_ATTR_LLC_SDP]) 1024 return -EINVAL; 1025 1026 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1027 1028 dev = nfc_get_device(idx); 1029 if (!dev) { 1030 rc = -ENODEV; 1031 goto exit; 1032 } 1033 1034 device_lock(&dev->dev); 1035 1036 if (dev->dep_link_up == false) { 1037 rc = -ENOLINK; 1038 goto exit; 1039 } 1040 1041 local = nfc_llcp_find_local(dev); 1042 if (!local) { 1043 nfc_put_device(dev); 1044 rc = -ENODEV; 1045 goto exit; 1046 } 1047 1048 INIT_HLIST_HEAD(&sdreq_list); 1049 1050 tlvs_len = 0; 1051 1052 nla_for_each_nested(attr, info->attrs[NFC_ATTR_LLC_SDP], rem) { 1053 rc = nla_parse_nested(sdp_attrs, NFC_SDP_ATTR_MAX, attr, 1054 nfc_sdp_genl_policy); 1055 1056 if (rc != 0) { 1057 rc = -EINVAL; 1058 goto exit; 1059 } 1060 1061 if (!sdp_attrs[NFC_SDP_ATTR_URI]) 1062 continue; 1063 1064 uri_len = nla_len(sdp_attrs[NFC_SDP_ATTR_URI]); 1065 if (uri_len == 0) 1066 continue; 1067 1068 uri = nla_data(sdp_attrs[NFC_SDP_ATTR_URI]); 1069 if (uri == NULL || *uri == 0) 1070 continue; 1071 1072 tid = local->sdreq_next_tid++; 1073 1074 sdreq = nfc_llcp_build_sdreq_tlv(tid, uri, uri_len); 1075 if (sdreq == NULL) { 1076 rc = -ENOMEM; 1077 goto exit; 1078 } 1079 1080 tlvs_len += sdreq->tlv_len; 1081 1082 hlist_add_head(&sdreq->node, &sdreq_list); 1083 } 1084 1085 if (hlist_empty(&sdreq_list)) { 1086 rc = -EINVAL; 1087 goto exit; 1088 } 1089 1090 rc = nfc_llcp_send_snl_sdreq(local, &sdreq_list, tlvs_len); 1091 exit: 1092 device_unlock(&dev->dev); 1093 1094 nfc_put_device(dev); 1095 1096 return rc; 1097 } 1098 1099 static int nfc_genl_fw_download(struct sk_buff *skb, struct genl_info *info) 1100 { 1101 struct nfc_dev *dev; 1102 int rc; 1103 u32 idx; 1104 char firmware_name[NFC_FIRMWARE_NAME_MAXSIZE + 1]; 1105 1106 if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 1107 return -EINVAL; 1108 1109 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1110 1111 dev = nfc_get_device(idx); 1112 if (!dev) 1113 return -ENODEV; 1114 1115 nla_strlcpy(firmware_name, info->attrs[NFC_ATTR_FIRMWARE_NAME], 1116 sizeof(firmware_name)); 1117 1118 rc = nfc_fw_download(dev, firmware_name); 1119 1120 nfc_put_device(dev); 1121 return rc; 1122 } 1123 1124 int nfc_genl_fw_download_done(struct nfc_dev *dev, const char *firmware_name, 1125 u32 result) 1126 { 1127 struct sk_buff *msg; 1128 void *hdr; 1129 1130 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1131 if (!msg) 1132 return -ENOMEM; 1133 1134 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1135 NFC_CMD_FW_DOWNLOAD); 1136 if (!hdr) 1137 goto free_msg; 1138 1139 if (nla_put_string(msg, NFC_ATTR_FIRMWARE_NAME, firmware_name) || 1140 nla_put_u32(msg, NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS, result) || 1141 nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx)) 1142 goto nla_put_failure; 1143 1144 genlmsg_end(msg, hdr); 1145 1146 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1147 1148 return 0; 1149 1150 nla_put_failure: 1151 genlmsg_cancel(msg, hdr); 1152 free_msg: 1153 nlmsg_free(msg); 1154 return -EMSGSIZE; 1155 } 1156 1157 static int nfc_genl_enable_se(struct sk_buff *skb, struct genl_info *info) 1158 { 1159 struct nfc_dev *dev; 1160 int rc; 1161 u32 idx, se_idx; 1162 1163 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1164 !info->attrs[NFC_ATTR_SE_INDEX]) 1165 return -EINVAL; 1166 1167 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1168 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1169 1170 dev = nfc_get_device(idx); 1171 if (!dev) 1172 return -ENODEV; 1173 1174 rc = nfc_enable_se(dev, se_idx); 1175 1176 nfc_put_device(dev); 1177 return rc; 1178 } 1179 1180 static int nfc_genl_disable_se(struct sk_buff *skb, struct genl_info *info) 1181 { 1182 struct nfc_dev *dev; 1183 int rc; 1184 u32 idx, se_idx; 1185 1186 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1187 !info->attrs[NFC_ATTR_SE_INDEX]) 1188 return -EINVAL; 1189 1190 idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1191 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1192 1193 dev = nfc_get_device(idx); 1194 if (!dev) 1195 return -ENODEV; 1196 1197 rc = nfc_disable_se(dev, se_idx); 1198 1199 nfc_put_device(dev); 1200 return rc; 1201 } 1202 1203 static int nfc_genl_send_se(struct sk_buff *msg, struct nfc_dev *dev, 1204 u32 portid, u32 seq, 1205 struct netlink_callback *cb, 1206 int flags) 1207 { 1208 void *hdr; 1209 struct nfc_se *se, *n; 1210 1211 list_for_each_entry_safe(se, n, &dev->secure_elements, list) { 1212 hdr = genlmsg_put(msg, portid, seq, &nfc_genl_family, flags, 1213 NFC_CMD_GET_SE); 1214 if (!hdr) 1215 goto nla_put_failure; 1216 1217 if (cb) 1218 genl_dump_check_consistent(cb, hdr, &nfc_genl_family); 1219 1220 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, dev->idx) || 1221 nla_put_u32(msg, NFC_ATTR_SE_INDEX, se->idx) || 1222 nla_put_u8(msg, NFC_ATTR_SE_TYPE, se->type)) 1223 goto nla_put_failure; 1224 1225 if (genlmsg_end(msg, hdr) < 0) 1226 goto nla_put_failure; 1227 } 1228 1229 return 0; 1230 1231 nla_put_failure: 1232 genlmsg_cancel(msg, hdr); 1233 return -EMSGSIZE; 1234 } 1235 1236 static int nfc_genl_dump_ses(struct sk_buff *skb, 1237 struct netlink_callback *cb) 1238 { 1239 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1240 struct nfc_dev *dev = (struct nfc_dev *) cb->args[1]; 1241 bool first_call = false; 1242 1243 if (!iter) { 1244 first_call = true; 1245 iter = kmalloc(sizeof(struct class_dev_iter), GFP_KERNEL); 1246 if (!iter) 1247 return -ENOMEM; 1248 cb->args[0] = (long) iter; 1249 } 1250 1251 mutex_lock(&nfc_devlist_mutex); 1252 1253 cb->seq = nfc_devlist_generation; 1254 1255 if (first_call) { 1256 nfc_device_iter_init(iter); 1257 dev = nfc_device_iter_next(iter); 1258 } 1259 1260 while (dev) { 1261 int rc; 1262 1263 rc = nfc_genl_send_se(skb, dev, NETLINK_CB(cb->skb).portid, 1264 cb->nlh->nlmsg_seq, cb, NLM_F_MULTI); 1265 if (rc < 0) 1266 break; 1267 1268 dev = nfc_device_iter_next(iter); 1269 } 1270 1271 mutex_unlock(&nfc_devlist_mutex); 1272 1273 cb->args[1] = (long) dev; 1274 1275 return skb->len; 1276 } 1277 1278 static int nfc_genl_dump_ses_done(struct netlink_callback *cb) 1279 { 1280 struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0]; 1281 1282 nfc_device_iter_exit(iter); 1283 kfree(iter); 1284 1285 return 0; 1286 } 1287 1288 struct se_io_ctx { 1289 u32 dev_idx; 1290 u32 se_idx; 1291 }; 1292 1293 static void se_io_cb(void *context, u8 *apdu, size_t apdu_len, int err) 1294 { 1295 struct se_io_ctx *ctx = context; 1296 struct sk_buff *msg; 1297 void *hdr; 1298 1299 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1300 if (!msg) { 1301 kfree(ctx); 1302 return; 1303 } 1304 1305 hdr = genlmsg_put(msg, 0, 0, &nfc_genl_family, 0, 1306 NFC_CMD_SE_IO); 1307 if (!hdr) 1308 goto free_msg; 1309 1310 if (nla_put_u32(msg, NFC_ATTR_DEVICE_INDEX, ctx->dev_idx) || 1311 nla_put_u32(msg, NFC_ATTR_SE_INDEX, ctx->se_idx) || 1312 nla_put(msg, NFC_ATTR_SE_APDU, apdu_len, apdu)) 1313 goto nla_put_failure; 1314 1315 genlmsg_end(msg, hdr); 1316 1317 genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_KERNEL); 1318 1319 kfree(ctx); 1320 1321 return; 1322 1323 nla_put_failure: 1324 genlmsg_cancel(msg, hdr); 1325 free_msg: 1326 nlmsg_free(msg); 1327 kfree(ctx); 1328 1329 return; 1330 } 1331 1332 static int nfc_genl_se_io(struct sk_buff *skb, struct genl_info *info) 1333 { 1334 struct nfc_dev *dev; 1335 struct se_io_ctx *ctx; 1336 u32 dev_idx, se_idx; 1337 u8 *apdu; 1338 size_t apdu_len; 1339 1340 if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 1341 !info->attrs[NFC_ATTR_SE_INDEX] || 1342 !info->attrs[NFC_ATTR_SE_APDU]) 1343 return -EINVAL; 1344 1345 dev_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]); 1346 se_idx = nla_get_u32(info->attrs[NFC_ATTR_SE_INDEX]); 1347 1348 dev = nfc_get_device(dev_idx); 1349 if (!dev) 1350 return -ENODEV; 1351 1352 if (!dev->ops || !dev->ops->se_io) 1353 return -ENOTSUPP; 1354 1355 apdu_len = nla_len(info->attrs[NFC_ATTR_SE_APDU]); 1356 if (apdu_len == 0) 1357 return -EINVAL; 1358 1359 apdu = nla_data(info->attrs[NFC_ATTR_SE_APDU]); 1360 if (!apdu) 1361 return -EINVAL; 1362 1363 ctx = kzalloc(sizeof(struct se_io_ctx), GFP_KERNEL); 1364 if (!ctx) 1365 return -ENOMEM; 1366 1367 ctx->dev_idx = dev_idx; 1368 ctx->se_idx = se_idx; 1369 1370 return dev->ops->se_io(dev, se_idx, apdu, apdu_len, se_io_cb, ctx); 1371 } 1372 1373 static const struct genl_ops nfc_genl_ops[] = { 1374 { 1375 .cmd = NFC_CMD_GET_DEVICE, 1376 .doit = nfc_genl_get_device, 1377 .dumpit = nfc_genl_dump_devices, 1378 .done = nfc_genl_dump_devices_done, 1379 .policy = nfc_genl_policy, 1380 }, 1381 { 1382 .cmd = NFC_CMD_DEV_UP, 1383 .doit = nfc_genl_dev_up, 1384 .policy = nfc_genl_policy, 1385 }, 1386 { 1387 .cmd = NFC_CMD_DEV_DOWN, 1388 .doit = nfc_genl_dev_down, 1389 .policy = nfc_genl_policy, 1390 }, 1391 { 1392 .cmd = NFC_CMD_START_POLL, 1393 .doit = nfc_genl_start_poll, 1394 .policy = nfc_genl_policy, 1395 }, 1396 { 1397 .cmd = NFC_CMD_STOP_POLL, 1398 .doit = nfc_genl_stop_poll, 1399 .policy = nfc_genl_policy, 1400 }, 1401 { 1402 .cmd = NFC_CMD_DEP_LINK_UP, 1403 .doit = nfc_genl_dep_link_up, 1404 .policy = nfc_genl_policy, 1405 }, 1406 { 1407 .cmd = NFC_CMD_DEP_LINK_DOWN, 1408 .doit = nfc_genl_dep_link_down, 1409 .policy = nfc_genl_policy, 1410 }, 1411 { 1412 .cmd = NFC_CMD_GET_TARGET, 1413 .dumpit = nfc_genl_dump_targets, 1414 .done = nfc_genl_dump_targets_done, 1415 .policy = nfc_genl_policy, 1416 }, 1417 { 1418 .cmd = NFC_CMD_LLC_GET_PARAMS, 1419 .doit = nfc_genl_llc_get_params, 1420 .policy = nfc_genl_policy, 1421 }, 1422 { 1423 .cmd = NFC_CMD_LLC_SET_PARAMS, 1424 .doit = nfc_genl_llc_set_params, 1425 .policy = nfc_genl_policy, 1426 }, 1427 { 1428 .cmd = NFC_CMD_LLC_SDREQ, 1429 .doit = nfc_genl_llc_sdreq, 1430 .policy = nfc_genl_policy, 1431 }, 1432 { 1433 .cmd = NFC_CMD_FW_DOWNLOAD, 1434 .doit = nfc_genl_fw_download, 1435 .policy = nfc_genl_policy, 1436 }, 1437 { 1438 .cmd = NFC_CMD_ENABLE_SE, 1439 .doit = nfc_genl_enable_se, 1440 .policy = nfc_genl_policy, 1441 }, 1442 { 1443 .cmd = NFC_CMD_DISABLE_SE, 1444 .doit = nfc_genl_disable_se, 1445 .policy = nfc_genl_policy, 1446 }, 1447 { 1448 .cmd = NFC_CMD_GET_SE, 1449 .dumpit = nfc_genl_dump_ses, 1450 .done = nfc_genl_dump_ses_done, 1451 .policy = nfc_genl_policy, 1452 }, 1453 { 1454 .cmd = NFC_CMD_SE_IO, 1455 .doit = nfc_genl_se_io, 1456 .policy = nfc_genl_policy, 1457 }, 1458 }; 1459 1460 1461 struct urelease_work { 1462 struct work_struct w; 1463 int portid; 1464 }; 1465 1466 static void nfc_urelease_event_work(struct work_struct *work) 1467 { 1468 struct urelease_work *w = container_of(work, struct urelease_work, w); 1469 struct class_dev_iter iter; 1470 struct nfc_dev *dev; 1471 1472 pr_debug("portid %d\n", w->portid); 1473 1474 mutex_lock(&nfc_devlist_mutex); 1475 1476 nfc_device_iter_init(&iter); 1477 dev = nfc_device_iter_next(&iter); 1478 1479 while (dev) { 1480 mutex_lock(&dev->genl_data.genl_data_mutex); 1481 1482 if (dev->genl_data.poll_req_portid == w->portid) { 1483 nfc_stop_poll(dev); 1484 dev->genl_data.poll_req_portid = 0; 1485 } 1486 1487 mutex_unlock(&dev->genl_data.genl_data_mutex); 1488 1489 dev = nfc_device_iter_next(&iter); 1490 } 1491 1492 nfc_device_iter_exit(&iter); 1493 1494 mutex_unlock(&nfc_devlist_mutex); 1495 1496 kfree(w); 1497 } 1498 1499 static int nfc_genl_rcv_nl_event(struct notifier_block *this, 1500 unsigned long event, void *ptr) 1501 { 1502 struct netlink_notify *n = ptr; 1503 struct urelease_work *w; 1504 1505 if (event != NETLINK_URELEASE || n->protocol != NETLINK_GENERIC) 1506 goto out; 1507 1508 pr_debug("NETLINK_URELEASE event from id %d\n", n->portid); 1509 1510 w = kmalloc(sizeof(*w), GFP_ATOMIC); 1511 if (w) { 1512 INIT_WORK((struct work_struct *) w, nfc_urelease_event_work); 1513 w->portid = n->portid; 1514 schedule_work((struct work_struct *) w); 1515 } 1516 1517 out: 1518 return NOTIFY_DONE; 1519 } 1520 1521 void nfc_genl_data_init(struct nfc_genl_data *genl_data) 1522 { 1523 genl_data->poll_req_portid = 0; 1524 mutex_init(&genl_data->genl_data_mutex); 1525 } 1526 1527 void nfc_genl_data_exit(struct nfc_genl_data *genl_data) 1528 { 1529 mutex_destroy(&genl_data->genl_data_mutex); 1530 } 1531 1532 static struct notifier_block nl_notifier = { 1533 .notifier_call = nfc_genl_rcv_nl_event, 1534 }; 1535 1536 /** 1537 * nfc_genl_init() - Initialize netlink interface 1538 * 1539 * This initialization function registers the nfc netlink family. 1540 */ 1541 int __init nfc_genl_init(void) 1542 { 1543 int rc; 1544 1545 rc = genl_register_family_with_ops_groups(&nfc_genl_family, 1546 nfc_genl_ops, 1547 nfc_genl_mcgrps); 1548 if (rc) 1549 return rc; 1550 1551 netlink_register_notifier(&nl_notifier); 1552 1553 return 0; 1554 } 1555 1556 /** 1557 * nfc_genl_exit() - Deinitialize netlink interface 1558 * 1559 * This exit function unregisters the nfc netlink family. 1560 */ 1561 void nfc_genl_exit(void) 1562 { 1563 netlink_unregister_notifier(&nl_notifier); 1564 genl_unregister_family(&nfc_genl_family); 1565 } 1566