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, write to the 16 * Free Software Foundation, Inc., 17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 */ 19 20 #define pr_fmt(fmt) "hci: %s: " fmt, __func__ 21 22 #include <linux/init.h> 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/nfc.h> 26 27 #include <net/nfc/nfc.h> 28 #include <net/nfc/hci.h> 29 30 #include "hci.h" 31 32 /* Largest headroom needed for outgoing HCI commands */ 33 #define HCI_CMDS_HEADROOM 1 34 35 static void nfc_hci_msg_tx_work(struct work_struct *work) 36 { 37 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev, 38 msg_tx_work); 39 struct hci_msg *msg; 40 struct sk_buff *skb; 41 int r = 0; 42 43 mutex_lock(&hdev->msg_tx_mutex); 44 45 if (hdev->cmd_pending_msg) { 46 if (timer_pending(&hdev->cmd_timer) == 0) { 47 if (hdev->cmd_pending_msg->cb) 48 hdev->cmd_pending_msg->cb(hdev, 49 NFC_HCI_ANY_E_TIMEOUT, 50 NULL, 51 hdev-> 52 cmd_pending_msg-> 53 cb_context); 54 kfree(hdev->cmd_pending_msg); 55 hdev->cmd_pending_msg = NULL; 56 } else 57 goto exit; 58 } 59 60 next_msg: 61 if (list_empty(&hdev->msg_tx_queue)) 62 goto exit; 63 64 msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l); 65 list_del(&msg->msg_l); 66 67 pr_debug("msg_tx_queue has a cmd to send\n"); 68 while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) { 69 r = hdev->ops->xmit(hdev, skb); 70 if (r < 0) { 71 kfree_skb(skb); 72 skb_queue_purge(&msg->msg_frags); 73 if (msg->cb) 74 msg->cb(hdev, NFC_HCI_ANY_E_NOK, NULL, 75 msg->cb_context); 76 kfree(msg); 77 break; 78 } 79 } 80 81 if (r) 82 goto next_msg; 83 84 if (msg->wait_response == false) { 85 kfree(msg); 86 goto next_msg; 87 } 88 89 hdev->cmd_pending_msg = msg; 90 mod_timer(&hdev->cmd_timer, jiffies + 91 msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay)); 92 93 exit: 94 mutex_unlock(&hdev->msg_tx_mutex); 95 } 96 97 static void nfc_hci_msg_rx_work(struct work_struct *work) 98 { 99 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev, 100 msg_rx_work); 101 struct sk_buff *skb; 102 struct hcp_message *message; 103 u8 pipe; 104 u8 type; 105 u8 instruction; 106 107 while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) { 108 pipe = skb->data[0]; 109 skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN); 110 message = (struct hcp_message *)skb->data; 111 type = HCP_MSG_GET_TYPE(message->header); 112 instruction = HCP_MSG_GET_CMD(message->header); 113 skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN); 114 115 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb); 116 } 117 } 118 119 void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result, 120 struct sk_buff *skb) 121 { 122 mutex_lock(&hdev->msg_tx_mutex); 123 124 if (hdev->cmd_pending_msg == NULL) { 125 kfree_skb(skb); 126 goto exit; 127 } 128 129 del_timer_sync(&hdev->cmd_timer); 130 131 if (hdev->cmd_pending_msg->cb) 132 hdev->cmd_pending_msg->cb(hdev, result, skb, 133 hdev->cmd_pending_msg->cb_context); 134 else 135 kfree_skb(skb); 136 137 kfree(hdev->cmd_pending_msg); 138 hdev->cmd_pending_msg = NULL; 139 140 queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work); 141 142 exit: 143 mutex_unlock(&hdev->msg_tx_mutex); 144 } 145 146 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd, 147 struct sk_buff *skb) 148 { 149 kfree_skb(skb); 150 } 151 152 static u32 nfc_hci_sak_to_protocol(u8 sak) 153 { 154 switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) { 155 case NFC_HCI_TYPE_A_SEL_PROT_MIFARE: 156 return NFC_PROTO_MIFARE_MASK; 157 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443: 158 return NFC_PROTO_ISO14443_MASK; 159 case NFC_HCI_TYPE_A_SEL_PROT_DEP: 160 return NFC_PROTO_NFC_DEP_MASK; 161 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP: 162 return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK; 163 default: 164 return 0xffffffff; 165 } 166 } 167 168 static int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate) 169 { 170 struct nfc_target *targets; 171 struct sk_buff *atqa_skb = NULL; 172 struct sk_buff *sak_skb = NULL; 173 int r; 174 175 pr_debug("from gate %d\n", gate); 176 177 targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL); 178 if (targets == NULL) 179 return -ENOMEM; 180 181 switch (gate) { 182 case NFC_HCI_RF_READER_A_GATE: 183 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE, 184 NFC_HCI_RF_READER_A_ATQA, &atqa_skb); 185 if (r < 0) 186 goto exit; 187 188 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE, 189 NFC_HCI_RF_READER_A_SAK, &sak_skb); 190 if (r < 0) 191 goto exit; 192 193 if (atqa_skb->len != 2 || sak_skb->len != 1) { 194 r = -EPROTO; 195 goto exit; 196 } 197 198 targets->supported_protocols = 199 nfc_hci_sak_to_protocol(sak_skb->data[0]); 200 if (targets->supported_protocols == 0xffffffff) { 201 r = -EPROTO; 202 goto exit; 203 } 204 205 targets->sens_res = be16_to_cpu(*(u16 *)atqa_skb->data); 206 targets->sel_res = sak_skb->data[0]; 207 208 if (hdev->ops->complete_target_discovered) { 209 r = hdev->ops->complete_target_discovered(hdev, gate, 210 targets); 211 if (r < 0) 212 goto exit; 213 } 214 break; 215 case NFC_HCI_RF_READER_B_GATE: 216 targets->supported_protocols = NFC_PROTO_ISO14443_MASK; 217 break; 218 default: 219 if (hdev->ops->target_from_gate) 220 r = hdev->ops->target_from_gate(hdev, gate, targets); 221 else 222 r = -EPROTO; 223 if (r < 0) 224 goto exit; 225 226 if (hdev->ops->complete_target_discovered) { 227 r = hdev->ops->complete_target_discovered(hdev, gate, 228 targets); 229 if (r < 0) 230 goto exit; 231 } 232 break; 233 } 234 235 targets->hci_reader_gate = gate; 236 237 r = nfc_targets_found(hdev->ndev, targets, 1); 238 if (r < 0) 239 goto exit; 240 241 kfree(hdev->targets); 242 hdev->targets = targets; 243 targets = NULL; 244 hdev->target_count = 1; 245 246 exit: 247 kfree(targets); 248 kfree_skb(atqa_skb); 249 kfree_skb(sak_skb); 250 251 return r; 252 } 253 254 void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event, 255 struct sk_buff *skb) 256 { 257 int r = 0; 258 259 switch (event) { 260 case NFC_HCI_EVT_TARGET_DISCOVERED: 261 if (hdev->poll_started == false) { 262 r = -EPROTO; 263 goto exit; 264 } 265 266 if (skb->len < 1) { /* no status data? */ 267 r = -EPROTO; 268 goto exit; 269 } 270 271 if (skb->data[0] == 3) { 272 /* TODO: Multiple targets in field, none activated 273 * poll is supposedly stopped, but there is no 274 * single target to activate, so nothing to report 275 * up. 276 * if we need to restart poll, we must save the 277 * protocols from the initial poll and reuse here. 278 */ 279 } 280 281 if (skb->data[0] != 0) { 282 r = -EPROTO; 283 goto exit; 284 } 285 286 r = nfc_hci_target_discovered(hdev, 287 nfc_hci_pipe2gate(hdev, pipe)); 288 break; 289 default: 290 /* TODO: Unknown events are hardware specific 291 * pass them to the driver (needs a new hci_ops) */ 292 break; 293 } 294 295 exit: 296 kfree_skb(skb); 297 298 if (r) { 299 /* TODO: There was an error dispatching the event, 300 * how to propagate up to nfc core? 301 */ 302 } 303 } 304 305 static void nfc_hci_cmd_timeout(unsigned long data) 306 { 307 struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data; 308 309 queue_work(hdev->msg_tx_wq, &hdev->msg_tx_work); 310 } 311 312 static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count, 313 u8 gates[]) 314 { 315 int r; 316 u8 *p = gates; 317 while (gate_count--) { 318 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, *p); 319 if (r < 0) 320 return r; 321 p++; 322 } 323 324 return 0; 325 } 326 327 static int hci_dev_session_init(struct nfc_hci_dev *hdev) 328 { 329 struct sk_buff *skb = NULL; 330 int r; 331 u8 hci_gates[] = { /* NFC_HCI_ADMIN_GATE MUST be first */ 332 NFC_HCI_ADMIN_GATE, NFC_HCI_LOOPBACK_GATE, 333 NFC_HCI_ID_MGMT_GATE, NFC_HCI_LINK_MGMT_GATE, 334 NFC_HCI_RF_READER_B_GATE, NFC_HCI_RF_READER_A_GATE 335 }; 336 337 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID, 338 NFC_HCI_ADMIN_GATE); 339 if (r < 0) 340 goto exit; 341 342 r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE, 343 NFC_HCI_ADMIN_SESSION_IDENTITY, &skb); 344 if (r < 0) 345 goto disconnect_all; 346 347 if (skb->len && skb->len == strlen(hdev->init_data.session_id)) 348 if (memcmp(hdev->init_data.session_id, skb->data, 349 skb->len) == 0) { 350 /* TODO ELa: restore gate<->pipe table from 351 * some TBD location. 352 * note: it doesn't seem possible to get the chip 353 * currently open gate/pipe table. 354 * It is only possible to obtain the supported 355 * gate list. 356 */ 357 358 /* goto exit 359 * For now, always do a full initialization */ 360 } 361 362 r = nfc_hci_disconnect_all_gates(hdev); 363 if (r < 0) 364 goto exit; 365 366 r = hci_dev_connect_gates(hdev, sizeof(hci_gates), hci_gates); 367 if (r < 0) 368 goto disconnect_all; 369 370 r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count, 371 hdev->init_data.gates); 372 if (r < 0) 373 goto disconnect_all; 374 375 r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE, 376 NFC_HCI_ADMIN_SESSION_IDENTITY, 377 hdev->init_data.session_id, 378 strlen(hdev->init_data.session_id)); 379 if (r == 0) 380 goto exit; 381 382 disconnect_all: 383 nfc_hci_disconnect_all_gates(hdev); 384 385 exit: 386 if (skb) 387 kfree_skb(skb); 388 389 return r; 390 } 391 392 static int hci_dev_version(struct nfc_hci_dev *hdev) 393 { 394 int r; 395 struct sk_buff *skb; 396 397 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE, 398 NFC_HCI_ID_MGMT_VERSION_SW, &skb); 399 if (r < 0) 400 return r; 401 402 if (skb->len != 3) { 403 kfree_skb(skb); 404 return -EINVAL; 405 } 406 407 hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4; 408 hdev->sw_patch = skb->data[0] & 0x0f; 409 hdev->sw_flashlib_major = skb->data[1]; 410 hdev->sw_flashlib_minor = skb->data[2]; 411 412 kfree_skb(skb); 413 414 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE, 415 NFC_HCI_ID_MGMT_VERSION_HW, &skb); 416 if (r < 0) 417 return r; 418 419 if (skb->len != 3) { 420 kfree_skb(skb); 421 return -EINVAL; 422 } 423 424 hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5; 425 hdev->hw_version = skb->data[0] & 0x1f; 426 hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6; 427 hdev->hw_software = skb->data[1] & 0x3f; 428 hdev->hw_bsid = skb->data[2]; 429 430 kfree_skb(skb); 431 432 pr_info("SOFTWARE INFO:\n"); 433 pr_info("RomLib : %d\n", hdev->sw_romlib); 434 pr_info("Patch : %d\n", hdev->sw_patch); 435 pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major); 436 pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor); 437 pr_info("HARDWARE INFO:\n"); 438 pr_info("Derivative : %d\n", hdev->hw_derivative); 439 pr_info("HW Version : %d\n", hdev->hw_version); 440 pr_info("#MPW : %d\n", hdev->hw_mpw); 441 pr_info("Software : %d\n", hdev->hw_software); 442 pr_info("BSID Version : %d\n", hdev->hw_bsid); 443 444 return 0; 445 } 446 447 static int hci_dev_up(struct nfc_dev *nfc_dev) 448 { 449 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 450 int r = 0; 451 452 if (hdev->ops->open) { 453 r = hdev->ops->open(hdev); 454 if (r < 0) 455 return r; 456 } 457 458 r = hci_dev_session_init(hdev); 459 if (r < 0) 460 goto exit; 461 462 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 463 NFC_HCI_EVT_END_OPERATION, NULL, 0); 464 if (r < 0) 465 goto exit; 466 467 if (hdev->ops->hci_ready) { 468 r = hdev->ops->hci_ready(hdev); 469 if (r < 0) 470 goto exit; 471 } 472 473 r = hci_dev_version(hdev); 474 if (r < 0) 475 goto exit; 476 477 exit: 478 if (r < 0) 479 if (hdev->ops->close) 480 hdev->ops->close(hdev); 481 return r; 482 } 483 484 static int hci_dev_down(struct nfc_dev *nfc_dev) 485 { 486 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 487 488 if (hdev->ops->close) 489 hdev->ops->close(hdev); 490 491 memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe)); 492 493 return 0; 494 } 495 496 static int hci_start_poll(struct nfc_dev *nfc_dev, u32 protocols) 497 { 498 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 499 int r; 500 501 if (hdev->ops->start_poll) 502 r = hdev->ops->start_poll(hdev, protocols); 503 else 504 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 505 NFC_HCI_EVT_READER_REQUESTED, NULL, 0); 506 if (r == 0) 507 hdev->poll_started = true; 508 509 return r; 510 } 511 512 static void hci_stop_poll(struct nfc_dev *nfc_dev) 513 { 514 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 515 516 if (hdev->poll_started) { 517 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE, 518 NFC_HCI_EVT_END_OPERATION, NULL, 0); 519 hdev->poll_started = false; 520 } 521 } 522 523 static struct nfc_target *hci_find_target(struct nfc_hci_dev *hdev, 524 u32 target_idx) 525 { 526 int i; 527 if (hdev->poll_started == false || hdev->targets == NULL) 528 return NULL; 529 530 for (i = 0; i < hdev->target_count; i++) { 531 if (hdev->targets[i].idx == target_idx) 532 return &hdev->targets[i]; 533 } 534 535 return NULL; 536 } 537 538 static int hci_activate_target(struct nfc_dev *nfc_dev, u32 target_idx, 539 u32 protocol) 540 { 541 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 542 543 if (hci_find_target(hdev, target_idx) == NULL) 544 return -ENOMEDIUM; 545 546 return 0; 547 } 548 549 static void hci_deactivate_target(struct nfc_dev *nfc_dev, u32 target_idx) 550 { 551 } 552 553 static int hci_data_exchange(struct nfc_dev *nfc_dev, u32 target_idx, 554 struct sk_buff *skb, data_exchange_cb_t cb, 555 void *cb_context) 556 { 557 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev); 558 int r; 559 struct nfc_target *target; 560 struct sk_buff *res_skb = NULL; 561 562 pr_debug("target_idx=%d\n", target_idx); 563 564 target = hci_find_target(hdev, target_idx); 565 if (target == NULL) 566 return -ENOMEDIUM; 567 568 switch (target->hci_reader_gate) { 569 case NFC_HCI_RF_READER_A_GATE: 570 case NFC_HCI_RF_READER_B_GATE: 571 if (hdev->ops->data_exchange) { 572 r = hdev->ops->data_exchange(hdev, target, skb, 573 &res_skb); 574 if (r <= 0) /* handled */ 575 break; 576 } 577 578 *skb_push(skb, 1) = 0; /* CTR, see spec:10.2.2.1 */ 579 r = nfc_hci_send_cmd(hdev, target->hci_reader_gate, 580 NFC_HCI_WR_XCHG_DATA, 581 skb->data, skb->len, &res_skb); 582 /* 583 * TODO: Check RF Error indicator to make sure data is valid. 584 * It seems that HCI cmd can complete without error, but data 585 * can be invalid if an RF error occured? Ignore for now. 586 */ 587 if (r == 0) 588 skb_trim(res_skb, res_skb->len - 1); /* RF Err ind */ 589 break; 590 default: 591 if (hdev->ops->data_exchange) { 592 r = hdev->ops->data_exchange(hdev, target, skb, 593 &res_skb); 594 if (r == 1) 595 r = -ENOTSUPP; 596 } 597 else 598 r = -ENOTSUPP; 599 } 600 601 kfree_skb(skb); 602 603 cb(cb_context, res_skb, r); 604 605 return 0; 606 } 607 608 struct nfc_ops hci_nfc_ops = { 609 .dev_up = hci_dev_up, 610 .dev_down = hci_dev_down, 611 .start_poll = hci_start_poll, 612 .stop_poll = hci_stop_poll, 613 .activate_target = hci_activate_target, 614 .deactivate_target = hci_deactivate_target, 615 .data_exchange = hci_data_exchange, 616 }; 617 618 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops, 619 struct nfc_hci_init_data *init_data, 620 u32 protocols, 621 int tx_headroom, 622 int tx_tailroom, 623 int max_link_payload) 624 { 625 struct nfc_hci_dev *hdev; 626 627 if (ops->xmit == NULL) 628 return NULL; 629 630 if (protocols == 0) 631 return NULL; 632 633 hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL); 634 if (hdev == NULL) 635 return NULL; 636 637 hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols, 638 tx_headroom + HCI_CMDS_HEADROOM, 639 tx_tailroom); 640 if (!hdev->ndev) { 641 kfree(hdev); 642 return NULL; 643 } 644 645 hdev->ops = ops; 646 hdev->max_data_link_payload = max_link_payload; 647 hdev->init_data = *init_data; 648 649 nfc_set_drvdata(hdev->ndev, hdev); 650 651 memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe)); 652 653 return hdev; 654 } 655 EXPORT_SYMBOL(nfc_hci_allocate_device); 656 657 void nfc_hci_free_device(struct nfc_hci_dev *hdev) 658 { 659 nfc_free_device(hdev->ndev); 660 kfree(hdev); 661 } 662 EXPORT_SYMBOL(nfc_hci_free_device); 663 664 int nfc_hci_register_device(struct nfc_hci_dev *hdev) 665 { 666 struct device *dev = &hdev->ndev->dev; 667 const char *devname = dev_name(dev); 668 char name[32]; 669 int r = 0; 670 671 mutex_init(&hdev->msg_tx_mutex); 672 673 INIT_LIST_HEAD(&hdev->msg_tx_queue); 674 675 INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work); 676 snprintf(name, sizeof(name), "%s_hci_msg_tx_wq", devname); 677 hdev->msg_tx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND | 678 WQ_MEM_RECLAIM, 1); 679 if (hdev->msg_tx_wq == NULL) { 680 r = -ENOMEM; 681 goto exit; 682 } 683 684 init_timer(&hdev->cmd_timer); 685 hdev->cmd_timer.data = (unsigned long)hdev; 686 hdev->cmd_timer.function = nfc_hci_cmd_timeout; 687 688 skb_queue_head_init(&hdev->rx_hcp_frags); 689 690 INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work); 691 snprintf(name, sizeof(name), "%s_hci_msg_rx_wq", devname); 692 hdev->msg_rx_wq = alloc_workqueue(name, WQ_NON_REENTRANT | WQ_UNBOUND | 693 WQ_MEM_RECLAIM, 1); 694 if (hdev->msg_rx_wq == NULL) { 695 r = -ENOMEM; 696 goto exit; 697 } 698 699 skb_queue_head_init(&hdev->msg_rx_queue); 700 701 r = nfc_register_device(hdev->ndev); 702 703 exit: 704 if (r < 0) { 705 if (hdev->msg_tx_wq) 706 destroy_workqueue(hdev->msg_tx_wq); 707 if (hdev->msg_rx_wq) 708 destroy_workqueue(hdev->msg_rx_wq); 709 } 710 711 return r; 712 } 713 EXPORT_SYMBOL(nfc_hci_register_device); 714 715 void nfc_hci_unregister_device(struct nfc_hci_dev *hdev) 716 { 717 struct hci_msg *msg; 718 719 skb_queue_purge(&hdev->rx_hcp_frags); 720 skb_queue_purge(&hdev->msg_rx_queue); 721 722 while ((msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, 723 msg_l)) != NULL) { 724 list_del(&msg->msg_l); 725 skb_queue_purge(&msg->msg_frags); 726 kfree(msg); 727 } 728 729 del_timer_sync(&hdev->cmd_timer); 730 731 nfc_unregister_device(hdev->ndev); 732 733 destroy_workqueue(hdev->msg_tx_wq); 734 735 destroy_workqueue(hdev->msg_rx_wq); 736 } 737 EXPORT_SYMBOL(nfc_hci_unregister_device); 738 739 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata) 740 { 741 hdev->clientdata = clientdata; 742 } 743 EXPORT_SYMBOL(nfc_hci_set_clientdata); 744 745 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev) 746 { 747 return hdev->clientdata; 748 } 749 EXPORT_SYMBOL(nfc_hci_get_clientdata); 750 751 void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb) 752 { 753 struct hcp_packet *packet; 754 u8 type; 755 u8 instruction; 756 struct sk_buff *hcp_skb; 757 u8 pipe; 758 struct sk_buff *frag_skb; 759 int msg_len; 760 761 if (skb == NULL) { 762 /* TODO ELa: lower layer had permanent failure, need to 763 * propagate that up 764 */ 765 766 skb_queue_purge(&hdev->rx_hcp_frags); 767 768 return; 769 } 770 771 packet = (struct hcp_packet *)skb->data; 772 if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) { 773 skb_queue_tail(&hdev->rx_hcp_frags, skb); 774 return; 775 } 776 777 /* it's the last fragment. Does it need re-aggregation? */ 778 if (skb_queue_len(&hdev->rx_hcp_frags)) { 779 pipe = packet->header & NFC_HCI_FRAGMENT; 780 skb_queue_tail(&hdev->rx_hcp_frags, skb); 781 782 msg_len = 0; 783 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) { 784 msg_len += (frag_skb->len - 785 NFC_HCI_HCP_PACKET_HEADER_LEN); 786 } 787 788 hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN + 789 msg_len, GFP_KERNEL); 790 if (hcp_skb == NULL) { 791 /* TODO ELa: cannot deliver HCP message. How to 792 * propagate error up? 793 */ 794 } 795 796 *skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe; 797 798 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) { 799 msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN; 800 memcpy(skb_put(hcp_skb, msg_len), 801 frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN, 802 msg_len); 803 } 804 805 skb_queue_purge(&hdev->rx_hcp_frags); 806 } else { 807 packet->header &= NFC_HCI_FRAGMENT; 808 hcp_skb = skb; 809 } 810 811 /* if this is a response, dispatch immediately to 812 * unblock waiting cmd context. Otherwise, enqueue to dispatch 813 * in separate context where handler can also execute command. 814 */ 815 packet = (struct hcp_packet *)hcp_skb->data; 816 type = HCP_MSG_GET_TYPE(packet->message.header); 817 if (type == NFC_HCI_HCP_RESPONSE) { 818 pipe = packet->header; 819 instruction = HCP_MSG_GET_CMD(packet->message.header); 820 skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN + 821 NFC_HCI_HCP_MESSAGE_HEADER_LEN); 822 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb); 823 } else { 824 skb_queue_tail(&hdev->msg_rx_queue, hcp_skb); 825 queue_work(hdev->msg_rx_wq, &hdev->msg_rx_work); 826 } 827 } 828 EXPORT_SYMBOL(nfc_hci_recv_frame); 829 830 MODULE_LICENSE("GPL"); 831