1 /* 2 * Copyright (C) 2012 Intel Corporation. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 16 */ 17 18 #define pr_fmt(fmt) "hci: %s: " fmt, __func__ 19 20 #include <linux/init.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/nfc.h> 24 25 #include <net/nfc/nfc.h> 26 #include <net/nfc/hci.h> 27 #include <net/nfc/llc.h> 28 29 #include "hci.h" 30 31 /* Largest headroom needed for outgoing HCI commands */ 32 #define HCI_CMDS_HEADROOM 1 33 34 int nfc_hci_result_to_errno(u8 result) 35 { 36 switch (result) { 37 case NFC_HCI_ANY_OK: 38 return 0; 39 case NFC_HCI_ANY_E_REG_PAR_UNKNOWN: 40 return -EOPNOTSUPP; 41 case NFC_HCI_ANY_E_TIMEOUT: 42 return -ETIME; 43 default: 44 return -1; 45 } 46 } 47 EXPORT_SYMBOL(nfc_hci_result_to_errno); 48 49 void nfc_hci_reset_pipes(struct nfc_hci_dev *hdev) 50 { 51 int i = 0; 52 53 for (i = 0; i < NFC_HCI_MAX_PIPES; i++) { 54 hdev->pipes[i].gate = NFC_HCI_INVALID_GATE; 55 hdev->pipes[i].dest_host = NFC_HCI_INVALID_HOST; 56 } 57 memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe)); 58 } 59 EXPORT_SYMBOL(nfc_hci_reset_pipes); 60 61 void nfc_hci_reset_pipes_per_host(struct nfc_hci_dev *hdev, u8 host) 62 { 63 int i = 0; 64 65 for (i = 0; i < NFC_HCI_MAX_PIPES; i++) { 66 if (hdev->pipes[i].dest_host != host) 67 continue; 68 69 hdev->pipes[i].gate = NFC_HCI_INVALID_GATE; 70 hdev->pipes[i].dest_host = NFC_HCI_INVALID_HOST; 71 } 72 } 73 EXPORT_SYMBOL(nfc_hci_reset_pipes_per_host); 74 75 static void nfc_hci_msg_tx_work(struct work_struct *work) 76 { 77 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev, 78 msg_tx_work); 79 struct hci_msg *msg; 80 struct sk_buff *skb; 81 int r = 0; 82 83 mutex_lock(&hdev->msg_tx_mutex); 84 if (hdev->shutting_down) 85 goto exit; 86 87 if (hdev->cmd_pending_msg) { 88 if (timer_pending(&hdev->cmd_timer) == 0) { 89 if (hdev->cmd_pending_msg->cb) 90 hdev->cmd_pending_msg->cb(hdev-> 91 cmd_pending_msg-> 92 cb_context, 93 NULL, 94 -ETIME); 95 kfree(hdev->cmd_pending_msg); 96 hdev->cmd_pending_msg = NULL; 97 } else { 98 goto exit; 99 } 100 } 101 102 next_msg: 103 if (list_empty(&hdev->msg_tx_queue)) 104 goto exit; 105 106 msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l); 107 list_del(&msg->msg_l); 108 109 pr_debug("msg_tx_queue has a cmd to send\n"); 110 while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) { 111 r = nfc_llc_xmit_from_hci(hdev->llc, skb); 112 if (r < 0) { 113 kfree_skb(skb); 114 skb_queue_purge(&msg->msg_frags); 115 if (msg->cb) 116 msg->cb(msg->cb_context, NULL, r); 117 kfree(msg); 118 break; 119 } 120 } 121 122 if (r) 123 goto next_msg; 124 125 if (msg->wait_response == false) { 126 kfree(msg); 127 goto next_msg; 128 } 129 130 hdev->cmd_pending_msg = msg; 131 mod_timer(&hdev->cmd_timer, jiffies + 132 msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay)); 133 134 exit: 135 mutex_unlock(&hdev->msg_tx_mutex); 136 } 137 138 static void nfc_hci_msg_rx_work(struct work_struct *work) 139 { 140 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev, 141 msg_rx_work); 142 struct sk_buff *skb; 143 struct hcp_message *message; 144 u8 pipe; 145 u8 type; 146 u8 instruction; 147 148 while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) { 149 pipe = skb->data[0]; 150 skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN); 151 message = (struct hcp_message *)skb->data; 152 type = HCP_MSG_GET_TYPE(message->header); 153 instruction = HCP_MSG_GET_CMD(message->header); 154 skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN); 155 156 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb); 157 } 158 } 159 160 static void __nfc_hci_cmd_completion(struct nfc_hci_dev *hdev, int err, 161 struct sk_buff *skb) 162 { 163 del_timer_sync(&hdev->cmd_timer); 164 165 if (hdev->cmd_pending_msg->cb) 166 hdev->cmd_pending_msg->cb(hdev->cmd_pending_msg->cb_context, 167 skb, err); 168 else 169 kfree_skb(skb); 170 171 kfree(hdev->cmd_pending_msg); 172 hdev->cmd_pending_msg = NULL; 173 174 schedule_work(&hdev->msg_tx_work); 175 } 176 177 void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result, 178 struct sk_buff *skb) 179 { 180 mutex_lock(&hdev->msg_tx_mutex); 181 182 if (hdev->cmd_pending_msg == NULL) { 183 kfree_skb(skb); 184 goto exit; 185 } 186 187 __nfc_hci_cmd_completion(hdev, nfc_hci_result_to_errno(result), skb); 188 189 exit: 190 mutex_unlock(&hdev->msg_tx_mutex); 191 } 192 193 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd, 194 struct sk_buff *skb) 195 { 196 u8 gate = hdev->pipes[pipe].gate; 197 u8 status = NFC_HCI_ANY_OK; 198 struct hci_create_pipe_resp *create_info; 199 struct hci_delete_pipe_noti *delete_info; 200 struct hci_all_pipe_cleared_noti *cleared_info; 201 202 pr_debug("from gate %x pipe %x cmd %x\n", gate, pipe, cmd); 203 204 switch (cmd) { 205 case NFC_HCI_ADM_NOTIFY_PIPE_CREATED: 206 if (skb->len != 5) { 207 status = NFC_HCI_ANY_E_NOK; 208 goto exit; 209 } 210 create_info = (struct hci_create_pipe_resp *)skb->data; 211 212 /* Save the new created pipe and bind with local gate, 213 * the description for skb->data[3] is destination gate id 214 * but since we received this cmd from host controller, we 215 * are the destination and it is our local gate 216 */ 217 hdev->gate2pipe[create_info->dest_gate] = create_info->pipe; 218 hdev->pipes[create_info->pipe].gate = create_info->dest_gate; 219 hdev->pipes[create_info->pipe].dest_host = 220 create_info->src_host; 221 break; 222 case NFC_HCI_ANY_OPEN_PIPE: 223 if (gate == NFC_HCI_INVALID_GATE) { 224 status = NFC_HCI_ANY_E_NOK; 225 goto exit; 226 } 227 break; 228 case NFC_HCI_ADM_NOTIFY_PIPE_DELETED: 229 if (skb->len != 1) { 230 status = NFC_HCI_ANY_E_NOK; 231 goto exit; 232 } 233 delete_info = (struct hci_delete_pipe_noti *)skb->data; 234 235 hdev->pipes[delete_info->pipe].gate = NFC_HCI_INVALID_GATE; 236 hdev->pipes[delete_info->pipe].dest_host = NFC_HCI_INVALID_HOST; 237 break; 238 case NFC_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED: 239 if (skb->len != 1) { 240 status = NFC_HCI_ANY_E_NOK; 241 goto exit; 242 } 243 cleared_info = (struct hci_all_pipe_cleared_noti *)skb->data; 244 245 nfc_hci_reset_pipes_per_host(hdev, cleared_info->host); 246 break; 247 default: 248 pr_info("Discarded unknown cmd %x to gate %x\n", cmd, gate); 249 break; 250 } 251 252 if (hdev->ops->cmd_received) 253 hdev->ops->cmd_received(hdev, pipe, cmd, skb); 254 255 exit: 256 nfc_hci_hcp_message_tx(hdev, pipe, NFC_HCI_HCP_RESPONSE, 257 status, NULL, 0, NULL, NULL, 0); 258 259 kfree_skb(skb); 260 } 261 262 u32 nfc_hci_sak_to_protocol(u8 sak) 263 { 264 switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) { 265 case NFC_HCI_TYPE_A_SEL_PROT_MIFARE: 266 return NFC_PROTO_MIFARE_MASK; 267 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443: 268 return NFC_PROTO_ISO14443_MASK; 269 case NFC_HCI_TYPE_A_SEL_PROT_DEP: 270 return NFC_PROTO_NFC_DEP_MASK; 271 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP: 272 return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK; 273 default: 274 return 0xffffffff; 275 } 276 } 277 EXPORT_SYMBOL(nfc_hci_sak_to_protocol); 278 279 int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate) 280 { 281 struct nfc_target *targets; 282 struct sk_buff *atqa_skb = NULL; 283 struct sk_buff *sak_skb = NULL; 284 struct sk_buff *uid_skb = NULL; 285 int r; 286 287 pr_debug("from gate %d\n", gate); 288 289 targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL); 290 if (targets == NULL) 291 return -ENOMEM; 292 293 switch (gate) { 294 case NFC_HCI_RF_READER_A_GATE: 295 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE, 296 NFC_HCI_RF_READER_A_ATQA, &atqa_skb); 297 if (r < 0) 298 goto exit; 299 300 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE, 301 NFC_HCI_RF_READER_A_SAK, &sak_skb); 302 if (r < 0) 303 goto exit; 304 305 if (atqa_skb->len != 2 || sak_skb->len != 1) { 306 r = -EPROTO; 307 goto exit; 308 } 309 310 targets->supported_protocols = 311 nfc_hci_sak_to_protocol(sak_skb->data[0]); 312 if (targets->supported_protocols == 0xffffffff) { 313 r = -EPROTO; 314 goto exit; 315 } 316 317 targets->sens_res = be16_to_cpu(*(__be16 *)atqa_skb->data); 318 targets->sel_res = sak_skb->data[0]; 319 320 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE, 321 NFC_HCI_RF_READER_A_UID, &uid_skb); 322 if (r < 0) 323 goto exit; 324 325 if (uid_skb->len == 0 || uid_skb->len > NFC_NFCID1_MAXSIZE) { 326 r = -EPROTO; 327 goto exit; 328 } 329 330 memcpy(targets->nfcid1, uid_skb->data, uid_skb->len); 331 targets->nfcid1_len = uid_skb->len; 332 333 if (hdev->ops->complete_target_discovered) { 334 r = hdev->ops->complete_target_discovered(hdev, gate, 335 targets); 336 if (r < 0) 337 goto exit; 338 } 339 break; 340 case NFC_HCI_RF_READER_B_GATE: 341 targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK; 342 break; 343 default: 344 if (hdev->ops->target_from_gate) 345 r = hdev->ops->target_from_gate(hdev, gate, targets); 346 else 347 r = -EPROTO; 348 if (r < 0) 349 goto exit; 350 351 if (hdev->ops->complete_target_discovered) { 352 r = hdev->ops->complete_target_discovered(hdev, gate, 353 targets); 354 if (r < 0) 355 goto exit; 356 } 357 break; 358 } 359 360 /* if driver set the new gate, we will skip the old one */ 361 if (targets->hci_reader_gate == 0x00) 362 targets->hci_reader_gate = gate; 363 364 r = nfc_targets_found(hdev->ndev, targets, 1); 365 366 exit: 367 kfree(targets); 368 kfree_skb(atqa_skb); 369 kfree_skb(sak_skb); 370 kfree_skb(uid_skb); 371 372 return r; 373 } 374 EXPORT_SYMBOL(nfc_hci_target_discovered); 375 376 void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event, 377 struct sk_buff *skb) 378 { 379 int r = 0; 380 u8 gate = hdev->pipes[pipe].gate; 381 382 if (gate == NFC_HCI_INVALID_GATE) { 383 pr_err("Discarded event %x to unopened pipe %x\n", event, pipe); 384 goto exit; 385 } 386 387 if (hdev->ops->event_received) { 388 r = hdev->ops->event_received(hdev, pipe, event, skb); 389 if (r <= 0) 390 goto exit_noskb; 391 } 392 393 switch (event) { 394 case NFC_HCI_EVT_TARGET_DISCOVERED: 395 if (skb->len < 1) { /* no status data? */ 396 r = -EPROTO; 397 goto exit; 398 } 399 400 if (skb->data[0] == 3) { 401 /* TODO: Multiple targets in field, none activated 402 * poll is supposedly stopped, but there is no 403 * single target to activate, so nothing to report 404 * up. 405 * if we need to restart poll, we must save the 406 * protocols from the initial poll and reuse here. 407 */ 408 } 409 410 if (skb->data[0] != 0) { 411 r = -EPROTO; 412 goto exit; 413 } 414 415 r = nfc_hci_target_discovered(hdev, gate); 416 break; 417 default: 418 pr_info("Discarded unknown event %x to gate %x\n", event, gate); 419 r = -EINVAL; 420 break; 421 } 422 423 exit: 424 kfree_skb(skb); 425 426 exit_noskb: 427 if (r) 428 nfc_hci_driver_failure(hdev, r); 429 } 430 431 static void nfc_hci_cmd_timeout(unsigned long data) 432 { 433 struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data; 434 435 schedule_work(&hdev->msg_tx_work); 436 } 437 438 static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count, 439 struct nfc_hci_gate *gates) 440 { 441 int r; 442 while (gate_count--) { 443 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, 444 gates->gate, gates->pipe); 445 if (r < 0) 446 return r; 447 gates++; 448 } 449 450 return 0; 451 } 452 453 static int hci_dev_session_init(struct nfc_hci_dev *hdev) 454 { 455 struct sk_buff *skb = NULL; 456 int r; 457 458 if (hdev->init_data.gates[0].gate != NFC_HCI_ADMIN_GATE) 459 return -EPROTO; 460 461 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, 462 hdev->init_data.gates[0].gate, 463 hdev->init_data.gates[0].pipe); 464 if (r < 0) 465 goto exit; 466 467 r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE, 468 NFC_HCI_ADMIN_SESSION_IDENTITY, &skb); 469 if (r < 0) 470 goto disconnect_all; 471 472 if (skb->len && skb->len == strlen(hdev->init_data.session_id) && 473 (memcmp(hdev->init_data.session_id, skb->data, 474 skb->len) == 0) && hdev->ops->load_session) { 475 /* Restore gate<->pipe table from some proprietary location. */ 476 477 r = hdev->ops->load_session(hdev); 478 479 if (r < 0) 480 goto disconnect_all; 481 } else { 482 483 r = nfc_hci_disconnect_all_gates(hdev); 484 if (r < 0) 485 goto exit; 486 487 r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count, 488 hdev->init_data.gates); 489 if (r < 0) 490 goto disconnect_all; 491 492 r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE, 493 NFC_HCI_ADMIN_SESSION_IDENTITY, 494 hdev->init_data.session_id, 495 strlen(hdev->init_data.session_id)); 496 } 497 if (r == 0) 498 goto exit; 499 500 disconnect_all: 501 nfc_hci_disconnect_all_gates(hdev); 502 503 exit: 504 kfree_skb(skb); 505 506 return r; 507 } 508 509 static int hci_dev_version(struct nfc_hci_dev *hdev) 510 { 511 int r; 512 struct sk_buff *skb; 513 514 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE, 515 NFC_HCI_ID_MGMT_VERSION_SW, &skb); 516 if (r == -EOPNOTSUPP) { 517 pr_info("Software/Hardware info not available\n"); 518 return 0; 519 } 520 if (r < 0) 521 return r; 522 523 if (skb->len != 3) { 524 kfree_skb(skb); 525 return -EINVAL; 526 } 527 528 hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4; 529 hdev->sw_patch = skb->data[0] & 0x0f; 530 hdev->sw_flashlib_major = skb->data[1]; 531 hdev->sw_flashlib_minor = skb->data[2]; 532 533 kfree_skb(skb); 534 535 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE, 536 NFC_HCI_ID_MGMT_VERSION_HW, &skb); 537 if (r < 0) 538 return r; 539 540 if (skb->len != 3) { 541 kfree_skb(skb); 542 return -EINVAL; 543 } 544 545 hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5; 546 hdev->hw_version = skb->data[0] & 0x1f; 547 hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6; 548 hdev->hw_software = skb->data[1] & 0x3f; 549 hdev->hw_bsid = skb->data[2]; 550 551 kfree_skb(skb); 552 553 pr_info("SOFTWARE INFO:\n"); 554 pr_info("RomLib : %d\n", hdev->sw_romlib); 555 pr_info("Patch : %d\n", hdev->sw_patch); 556 pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major); 557 pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor); 558 pr_info("HARDWARE INFO:\n"); 559 pr_info("Derivative : %d\n", hdev->hw_derivative); 560 pr_info("HW Version : %d\n", hdev->hw_version); 561 pr_info("#MPW : %d\n", hdev->hw_mpw); 562 pr_info("Software : %d\n", hdev->hw_software); 563 pr_info("BSID Version : %d\n", hdev->hw_bsid); 564 565 return 0; 566 } 567 568 static int hci_dev_up(struct nfc_dev *nfc_dev) 569 { 570 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 571 int r = 0; 572 573 if (hdev->ops->open) { 574 r = hdev->ops->open(hdev); 575 if (r < 0) 576 return r; 577 } 578 579 r = nfc_llc_start(hdev->llc); 580 if (r < 0) 581 goto exit_close; 582 583 r = hci_dev_session_init(hdev); 584 if (r < 0) 585 goto exit_llc; 586 587 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 588 NFC_HCI_EVT_END_OPERATION, NULL, 0); 589 if (r < 0) 590 goto exit_llc; 591 592 if (hdev->ops->hci_ready) { 593 r = hdev->ops->hci_ready(hdev); 594 if (r < 0) 595 goto exit_llc; 596 } 597 598 r = hci_dev_version(hdev); 599 if (r < 0) 600 goto exit_llc; 601 602 return 0; 603 604 exit_llc: 605 nfc_llc_stop(hdev->llc); 606 607 exit_close: 608 if (hdev->ops->close) 609 hdev->ops->close(hdev); 610 611 return r; 612 } 613 614 static int hci_dev_down(struct nfc_dev *nfc_dev) 615 { 616 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 617 618 nfc_llc_stop(hdev->llc); 619 620 if (hdev->ops->close) 621 hdev->ops->close(hdev); 622 623 nfc_hci_reset_pipes(hdev); 624 625 return 0; 626 } 627 628 static int hci_start_poll(struct nfc_dev *nfc_dev, 629 u32 im_protocols, u32 tm_protocols) 630 { 631 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 632 633 if (hdev->ops->start_poll) 634 return hdev->ops->start_poll(hdev, im_protocols, tm_protocols); 635 else 636 return nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 637 NFC_HCI_EVT_READER_REQUESTED, 638 NULL, 0); 639 } 640 641 static void hci_stop_poll(struct nfc_dev *nfc_dev) 642 { 643 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 644 645 if (hdev->ops->stop_poll) 646 hdev->ops->stop_poll(hdev); 647 else 648 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 649 NFC_HCI_EVT_END_OPERATION, NULL, 0); 650 } 651 652 static int hci_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target, 653 __u8 comm_mode, __u8 *gb, size_t gb_len) 654 { 655 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 656 657 if (!hdev->ops->dep_link_up) 658 return 0; 659 660 return hdev->ops->dep_link_up(hdev, target, comm_mode, 661 gb, gb_len); 662 } 663 664 static int hci_dep_link_down(struct nfc_dev *nfc_dev) 665 { 666 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 667 668 if (!hdev->ops->dep_link_down) 669 return 0; 670 671 return hdev->ops->dep_link_down(hdev); 672 } 673 674 static int hci_activate_target(struct nfc_dev *nfc_dev, 675 struct nfc_target *target, u32 protocol) 676 { 677 return 0; 678 } 679 680 static void hci_deactivate_target(struct nfc_dev *nfc_dev, 681 struct nfc_target *target) 682 { 683 } 684 685 #define HCI_CB_TYPE_TRANSCEIVE 1 686 687 static void hci_transceive_cb(void *context, struct sk_buff *skb, int err) 688 { 689 struct nfc_hci_dev *hdev = context; 690 691 switch (hdev->async_cb_type) { 692 case HCI_CB_TYPE_TRANSCEIVE: 693 /* 694 * TODO: Check RF Error indicator to make sure data is valid. 695 * It seems that HCI cmd can complete without error, but data 696 * can be invalid if an RF error occured? Ignore for now. 697 */ 698 if (err == 0) 699 skb_trim(skb, skb->len - 1); /* RF Err ind */ 700 701 hdev->async_cb(hdev->async_cb_context, skb, err); 702 break; 703 default: 704 if (err == 0) 705 kfree_skb(skb); 706 break; 707 } 708 } 709 710 static int hci_transceive(struct nfc_dev *nfc_dev, struct nfc_target *target, 711 struct sk_buff *skb, data_exchange_cb_t cb, 712 void *cb_context) 713 { 714 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 715 int r; 716 717 pr_debug("target_idx=%d\n", target->idx); 718 719 switch (target->hci_reader_gate) { 720 case NFC_HCI_RF_READER_A_GATE: 721 case NFC_HCI_RF_READER_B_GATE: 722 if (hdev->ops->im_transceive) { 723 r = hdev->ops->im_transceive(hdev, target, skb, cb, 724 cb_context); 725 if (r <= 0) /* handled */ 726 break; 727 } 728 729 *skb_push(skb, 1) = 0; /* CTR, see spec:10.2.2.1 */ 730 731 hdev->async_cb_type = HCI_CB_TYPE_TRANSCEIVE; 732 hdev->async_cb = cb; 733 hdev->async_cb_context = cb_context; 734 735 r = nfc_hci_send_cmd_async(hdev, target->hci_reader_gate, 736 NFC_HCI_WR_XCHG_DATA, skb->data, 737 skb->len, hci_transceive_cb, hdev); 738 break; 739 default: 740 if (hdev->ops->im_transceive) { 741 r = hdev->ops->im_transceive(hdev, target, skb, cb, 742 cb_context); 743 if (r == 1) 744 r = -ENOTSUPP; 745 } else { 746 r = -ENOTSUPP; 747 } 748 break; 749 } 750 751 kfree_skb(skb); 752 753 return r; 754 } 755 756 static int hci_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb) 757 { 758 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 759 760 if (!hdev->ops->tm_send) { 761 kfree_skb(skb); 762 return -ENOTSUPP; 763 } 764 765 return hdev->ops->tm_send(hdev, skb); 766 } 767 768 static int hci_check_presence(struct nfc_dev *nfc_dev, 769 struct nfc_target *target) 770 { 771 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 772 773 if (!hdev->ops->check_presence) 774 return 0; 775 776 return hdev->ops->check_presence(hdev, target); 777 } 778 779 static int hci_discover_se(struct nfc_dev *nfc_dev) 780 { 781 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 782 783 if (hdev->ops->discover_se) 784 return hdev->ops->discover_se(hdev); 785 786 return 0; 787 } 788 789 static int hci_enable_se(struct nfc_dev *nfc_dev, u32 se_idx) 790 { 791 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 792 793 if (hdev->ops->enable_se) 794 return hdev->ops->enable_se(hdev, se_idx); 795 796 return 0; 797 } 798 799 static int hci_disable_se(struct nfc_dev *nfc_dev, u32 se_idx) 800 { 801 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 802 803 if (hdev->ops->disable_se) 804 return hdev->ops->disable_se(hdev, se_idx); 805 806 return 0; 807 } 808 809 static int hci_se_io(struct nfc_dev *nfc_dev, u32 se_idx, 810 u8 *apdu, size_t apdu_length, 811 se_io_cb_t cb, void *cb_context) 812 { 813 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 814 815 if (hdev->ops->se_io) 816 return hdev->ops->se_io(hdev, se_idx, apdu, 817 apdu_length, cb, cb_context); 818 819 return 0; 820 } 821 822 static void nfc_hci_failure(struct nfc_hci_dev *hdev, int err) 823 { 824 mutex_lock(&hdev->msg_tx_mutex); 825 826 if (hdev->cmd_pending_msg == NULL) { 827 nfc_driver_failure(hdev->ndev, err); 828 goto exit; 829 } 830 831 __nfc_hci_cmd_completion(hdev, err, NULL); 832 833 exit: 834 mutex_unlock(&hdev->msg_tx_mutex); 835 } 836 837 static void nfc_hci_llc_failure(struct nfc_hci_dev *hdev, int err) 838 { 839 nfc_hci_failure(hdev, err); 840 } 841 842 static void nfc_hci_recv_from_llc(struct nfc_hci_dev *hdev, struct sk_buff *skb) 843 { 844 struct hcp_packet *packet; 845 u8 type; 846 u8 instruction; 847 struct sk_buff *hcp_skb; 848 u8 pipe; 849 struct sk_buff *frag_skb; 850 int msg_len; 851 852 packet = (struct hcp_packet *)skb->data; 853 if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) { 854 skb_queue_tail(&hdev->rx_hcp_frags, skb); 855 return; 856 } 857 858 /* it's the last fragment. Does it need re-aggregation? */ 859 if (skb_queue_len(&hdev->rx_hcp_frags)) { 860 pipe = packet->header & NFC_HCI_FRAGMENT; 861 skb_queue_tail(&hdev->rx_hcp_frags, skb); 862 863 msg_len = 0; 864 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) { 865 msg_len += (frag_skb->len - 866 NFC_HCI_HCP_PACKET_HEADER_LEN); 867 } 868 869 hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN + 870 msg_len, GFP_KERNEL); 871 if (hcp_skb == NULL) { 872 nfc_hci_failure(hdev, -ENOMEM); 873 return; 874 } 875 876 *skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe; 877 878 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) { 879 msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN; 880 memcpy(skb_put(hcp_skb, msg_len), 881 frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN, 882 msg_len); 883 } 884 885 skb_queue_purge(&hdev->rx_hcp_frags); 886 } else { 887 packet->header &= NFC_HCI_FRAGMENT; 888 hcp_skb = skb; 889 } 890 891 /* if this is a response, dispatch immediately to 892 * unblock waiting cmd context. Otherwise, enqueue to dispatch 893 * in separate context where handler can also execute command. 894 */ 895 packet = (struct hcp_packet *)hcp_skb->data; 896 type = HCP_MSG_GET_TYPE(packet->message.header); 897 if (type == NFC_HCI_HCP_RESPONSE) { 898 pipe = packet->header; 899 instruction = HCP_MSG_GET_CMD(packet->message.header); 900 skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN + 901 NFC_HCI_HCP_MESSAGE_HEADER_LEN); 902 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb); 903 } else { 904 skb_queue_tail(&hdev->msg_rx_queue, hcp_skb); 905 schedule_work(&hdev->msg_rx_work); 906 } 907 } 908 909 static int hci_fw_download(struct nfc_dev *nfc_dev, const char *firmware_name) 910 { 911 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 912 913 if (!hdev->ops->fw_download) 914 return -ENOTSUPP; 915 916 return hdev->ops->fw_download(hdev, firmware_name); 917 } 918 919 static struct nfc_ops hci_nfc_ops = { 920 .dev_up = hci_dev_up, 921 .dev_down = hci_dev_down, 922 .start_poll = hci_start_poll, 923 .stop_poll = hci_stop_poll, 924 .dep_link_up = hci_dep_link_up, 925 .dep_link_down = hci_dep_link_down, 926 .activate_target = hci_activate_target, 927 .deactivate_target = hci_deactivate_target, 928 .im_transceive = hci_transceive, 929 .tm_send = hci_tm_send, 930 .check_presence = hci_check_presence, 931 .fw_download = hci_fw_download, 932 .discover_se = hci_discover_se, 933 .enable_se = hci_enable_se, 934 .disable_se = hci_disable_se, 935 .se_io = hci_se_io, 936 }; 937 938 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops, 939 struct nfc_hci_init_data *init_data, 940 unsigned long quirks, 941 u32 protocols, 942 const char *llc_name, 943 int tx_headroom, 944 int tx_tailroom, 945 int max_link_payload) 946 { 947 struct nfc_hci_dev *hdev; 948 949 if (ops->xmit == NULL) 950 return NULL; 951 952 if (protocols == 0) 953 return NULL; 954 955 hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL); 956 if (hdev == NULL) 957 return NULL; 958 959 hdev->llc = nfc_llc_allocate(llc_name, hdev, ops->xmit, 960 nfc_hci_recv_from_llc, tx_headroom, 961 tx_tailroom, nfc_hci_llc_failure); 962 if (hdev->llc == NULL) { 963 kfree(hdev); 964 return NULL; 965 } 966 967 hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols, 968 tx_headroom + HCI_CMDS_HEADROOM, 969 tx_tailroom); 970 if (!hdev->ndev) { 971 nfc_llc_free(hdev->llc); 972 kfree(hdev); 973 return NULL; 974 } 975 976 hdev->ops = ops; 977 hdev->max_data_link_payload = max_link_payload; 978 hdev->init_data = *init_data; 979 980 nfc_set_drvdata(hdev->ndev, hdev); 981 982 nfc_hci_reset_pipes(hdev); 983 984 hdev->quirks = quirks; 985 986 return hdev; 987 } 988 EXPORT_SYMBOL(nfc_hci_allocate_device); 989 990 void nfc_hci_free_device(struct nfc_hci_dev *hdev) 991 { 992 nfc_free_device(hdev->ndev); 993 nfc_llc_free(hdev->llc); 994 kfree(hdev); 995 } 996 EXPORT_SYMBOL(nfc_hci_free_device); 997 998 int nfc_hci_register_device(struct nfc_hci_dev *hdev) 999 { 1000 mutex_init(&hdev->msg_tx_mutex); 1001 1002 INIT_LIST_HEAD(&hdev->msg_tx_queue); 1003 1004 INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work); 1005 1006 init_timer(&hdev->cmd_timer); 1007 hdev->cmd_timer.data = (unsigned long)hdev; 1008 hdev->cmd_timer.function = nfc_hci_cmd_timeout; 1009 1010 skb_queue_head_init(&hdev->rx_hcp_frags); 1011 1012 INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work); 1013 1014 skb_queue_head_init(&hdev->msg_rx_queue); 1015 1016 return nfc_register_device(hdev->ndev); 1017 } 1018 EXPORT_SYMBOL(nfc_hci_register_device); 1019 1020 void nfc_hci_unregister_device(struct nfc_hci_dev *hdev) 1021 { 1022 struct hci_msg *msg, *n; 1023 1024 mutex_lock(&hdev->msg_tx_mutex); 1025 1026 if (hdev->cmd_pending_msg) { 1027 if (hdev->cmd_pending_msg->cb) 1028 hdev->cmd_pending_msg->cb( 1029 hdev->cmd_pending_msg->cb_context, 1030 NULL, -ESHUTDOWN); 1031 kfree(hdev->cmd_pending_msg); 1032 hdev->cmd_pending_msg = NULL; 1033 } 1034 1035 hdev->shutting_down = true; 1036 1037 mutex_unlock(&hdev->msg_tx_mutex); 1038 1039 del_timer_sync(&hdev->cmd_timer); 1040 cancel_work_sync(&hdev->msg_tx_work); 1041 1042 cancel_work_sync(&hdev->msg_rx_work); 1043 1044 nfc_unregister_device(hdev->ndev); 1045 1046 skb_queue_purge(&hdev->rx_hcp_frags); 1047 skb_queue_purge(&hdev->msg_rx_queue); 1048 1049 list_for_each_entry_safe(msg, n, &hdev->msg_tx_queue, msg_l) { 1050 list_del(&msg->msg_l); 1051 skb_queue_purge(&msg->msg_frags); 1052 kfree(msg); 1053 } 1054 } 1055 EXPORT_SYMBOL(nfc_hci_unregister_device); 1056 1057 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata) 1058 { 1059 hdev->clientdata = clientdata; 1060 } 1061 EXPORT_SYMBOL(nfc_hci_set_clientdata); 1062 1063 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev) 1064 { 1065 return hdev->clientdata; 1066 } 1067 EXPORT_SYMBOL(nfc_hci_get_clientdata); 1068 1069 void nfc_hci_driver_failure(struct nfc_hci_dev *hdev, int err) 1070 { 1071 nfc_hci_failure(hdev, err); 1072 } 1073 EXPORT_SYMBOL(nfc_hci_driver_failure); 1074 1075 void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb) 1076 { 1077 nfc_llc_rcv_from_drv(hdev->llc, skb); 1078 } 1079 EXPORT_SYMBOL(nfc_hci_recv_frame); 1080 1081 static int __init nfc_hci_init(void) 1082 { 1083 return nfc_llc_init(); 1084 } 1085 1086 static void __exit nfc_hci_exit(void) 1087 { 1088 nfc_llc_exit(); 1089 } 1090 1091 subsys_initcall(nfc_hci_init); 1092 module_exit(nfc_hci_exit); 1093 1094 MODULE_LICENSE("GPL"); 1095 MODULE_DESCRIPTION("NFC HCI Core"); 1096