2 * Copyright (C) 2012 Intel Corporation. All rights reserved.
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.
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.
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.
20 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/nfc.h>
27 #include <net/nfc/nfc.h>
28 #include <net/nfc/hci.h>
32 /* Largest headroom needed for outgoing HCI commands */
33 #define HCI_CMDS_HEADROOM 1
35 static int nfc_hci_result_to_errno(u8 result
)
40 case NFC_HCI_ANY_E_TIMEOUT
:
47 static void nfc_hci_msg_tx_work(struct work_struct
*work
)
49 struct nfc_hci_dev
*hdev
= container_of(work
, struct nfc_hci_dev
,
55 mutex_lock(&hdev
->msg_tx_mutex
);
57 if (hdev
->cmd_pending_msg
) {
58 if (timer_pending(&hdev
->cmd_timer
) == 0) {
59 if (hdev
->cmd_pending_msg
->cb
)
60 hdev
->cmd_pending_msg
->cb(hdev
,
66 kfree(hdev
->cmd_pending_msg
);
67 hdev
->cmd_pending_msg
= NULL
;
73 if (list_empty(&hdev
->msg_tx_queue
))
76 msg
= list_first_entry(&hdev
->msg_tx_queue
, struct hci_msg
, msg_l
);
77 list_del(&msg
->msg_l
);
79 pr_debug("msg_tx_queue has a cmd to send\n");
80 while ((skb
= skb_dequeue(&msg
->msg_frags
)) != NULL
) {
81 r
= hdev
->ops
->xmit(hdev
, skb
);
84 skb_queue_purge(&msg
->msg_frags
);
86 msg
->cb(hdev
, r
, NULL
, msg
->cb_context
);
95 if (msg
->wait_response
== false) {
100 hdev
->cmd_pending_msg
= msg
;
101 mod_timer(&hdev
->cmd_timer
, jiffies
+
102 msecs_to_jiffies(hdev
->cmd_pending_msg
->completion_delay
));
105 mutex_unlock(&hdev
->msg_tx_mutex
);
108 static void nfc_hci_msg_rx_work(struct work_struct
*work
)
110 struct nfc_hci_dev
*hdev
= container_of(work
, struct nfc_hci_dev
,
113 struct hcp_message
*message
;
118 while ((skb
= skb_dequeue(&hdev
->msg_rx_queue
)) != NULL
) {
120 skb_pull(skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
);
121 message
= (struct hcp_message
*)skb
->data
;
122 type
= HCP_MSG_GET_TYPE(message
->header
);
123 instruction
= HCP_MSG_GET_CMD(message
->header
);
124 skb_pull(skb
, NFC_HCI_HCP_MESSAGE_HEADER_LEN
);
126 nfc_hci_hcp_message_rx(hdev
, pipe
, type
, instruction
, skb
);
130 static void __nfc_hci_cmd_completion(struct nfc_hci_dev
*hdev
, int err
,
133 del_timer_sync(&hdev
->cmd_timer
);
135 if (hdev
->cmd_pending_msg
->cb
)
136 hdev
->cmd_pending_msg
->cb(hdev
, err
, skb
,
137 hdev
->cmd_pending_msg
->cb_context
);
141 kfree(hdev
->cmd_pending_msg
);
142 hdev
->cmd_pending_msg
= NULL
;
144 queue_work(hdev
->msg_tx_wq
, &hdev
->msg_tx_work
);
147 void nfc_hci_resp_received(struct nfc_hci_dev
*hdev
, u8 result
,
150 mutex_lock(&hdev
->msg_tx_mutex
);
152 if (hdev
->cmd_pending_msg
== NULL
) {
157 __nfc_hci_cmd_completion(hdev
, nfc_hci_result_to_errno(result
), skb
);
160 mutex_unlock(&hdev
->msg_tx_mutex
);
163 void nfc_hci_cmd_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 cmd
,
169 static u32
nfc_hci_sak_to_protocol(u8 sak
)
171 switch (NFC_HCI_TYPE_A_SEL_PROT(sak
)) {
172 case NFC_HCI_TYPE_A_SEL_PROT_MIFARE
:
173 return NFC_PROTO_MIFARE_MASK
;
174 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443
:
175 return NFC_PROTO_ISO14443_MASK
;
176 case NFC_HCI_TYPE_A_SEL_PROT_DEP
:
177 return NFC_PROTO_NFC_DEP_MASK
;
178 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP
:
179 return NFC_PROTO_ISO14443_MASK
| NFC_PROTO_NFC_DEP_MASK
;
185 static int nfc_hci_target_discovered(struct nfc_hci_dev
*hdev
, u8 gate
)
187 struct nfc_target
*targets
;
188 struct sk_buff
*atqa_skb
= NULL
;
189 struct sk_buff
*sak_skb
= NULL
;
190 struct sk_buff
*uid_skb
= NULL
;
193 pr_debug("from gate %d\n", gate
);
195 targets
= kzalloc(sizeof(struct nfc_target
), GFP_KERNEL
);
200 case NFC_HCI_RF_READER_A_GATE
:
201 r
= nfc_hci_get_param(hdev
, NFC_HCI_RF_READER_A_GATE
,
202 NFC_HCI_RF_READER_A_ATQA
, &atqa_skb
);
206 r
= nfc_hci_get_param(hdev
, NFC_HCI_RF_READER_A_GATE
,
207 NFC_HCI_RF_READER_A_SAK
, &sak_skb
);
211 if (atqa_skb
->len
!= 2 || sak_skb
->len
!= 1) {
216 targets
->supported_protocols
=
217 nfc_hci_sak_to_protocol(sak_skb
->data
[0]);
218 if (targets
->supported_protocols
== 0xffffffff) {
223 targets
->sens_res
= be16_to_cpu(*(u16
*)atqa_skb
->data
);
224 targets
->sel_res
= sak_skb
->data
[0];
226 r
= nfc_hci_get_param(hdev
, NFC_HCI_RF_READER_A_GATE
,
227 NFC_HCI_RF_READER_A_UID
, &uid_skb
);
231 if (uid_skb
->len
== 0 || uid_skb
->len
> NFC_NFCID1_MAXSIZE
) {
236 memcpy(targets
->nfcid1
, uid_skb
->data
, uid_skb
->len
);
237 targets
->nfcid1_len
= uid_skb
->len
;
239 if (hdev
->ops
->complete_target_discovered
) {
240 r
= hdev
->ops
->complete_target_discovered(hdev
, gate
,
246 case NFC_HCI_RF_READER_B_GATE
:
247 targets
->supported_protocols
= NFC_PROTO_ISO14443_B_MASK
;
250 if (hdev
->ops
->target_from_gate
)
251 r
= hdev
->ops
->target_from_gate(hdev
, gate
, targets
);
257 if (hdev
->ops
->complete_target_discovered
) {
258 r
= hdev
->ops
->complete_target_discovered(hdev
, gate
,
266 targets
->hci_reader_gate
= gate
;
268 r
= nfc_targets_found(hdev
->ndev
, targets
, 1);
279 void nfc_hci_event_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 event
,
285 case NFC_HCI_EVT_TARGET_DISCOVERED
:
286 if (skb
->len
< 1) { /* no status data? */
291 if (skb
->data
[0] == 3) {
292 /* TODO: Multiple targets in field, none activated
293 * poll is supposedly stopped, but there is no
294 * single target to activate, so nothing to report
296 * if we need to restart poll, we must save the
297 * protocols from the initial poll and reuse here.
301 if (skb
->data
[0] != 0) {
306 r
= nfc_hci_target_discovered(hdev
,
307 nfc_hci_pipe2gate(hdev
, pipe
));
310 /* TODO: Unknown events are hardware specific
311 * pass them to the driver (needs a new hci_ops) */
319 /* TODO: There was an error dispatching the event,
320 * how to propagate up to nfc core?
325 static void nfc_hci_cmd_timeout(unsigned long data
)
327 struct nfc_hci_dev
*hdev
= (struct nfc_hci_dev
*)data
;
329 queue_work(hdev
->msg_tx_wq
, &hdev
->msg_tx_work
);
332 static int hci_dev_connect_gates(struct nfc_hci_dev
*hdev
, u8 gate_count
,
333 struct nfc_hci_gate
*gates
)
336 while (gate_count
--) {
337 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
338 gates
->gate
, gates
->pipe
);
347 static int hci_dev_session_init(struct nfc_hci_dev
*hdev
)
349 struct sk_buff
*skb
= NULL
;
352 if (hdev
->init_data
.gates
[0].gate
!= NFC_HCI_ADMIN_GATE
)
355 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
356 hdev
->init_data
.gates
[0].gate
,
357 hdev
->init_data
.gates
[0].pipe
);
361 r
= nfc_hci_get_param(hdev
, NFC_HCI_ADMIN_GATE
,
362 NFC_HCI_ADMIN_SESSION_IDENTITY
, &skb
);
366 if (skb
->len
&& skb
->len
== strlen(hdev
->init_data
.session_id
))
367 if (memcmp(hdev
->init_data
.session_id
, skb
->data
,
369 /* TODO ELa: restore gate<->pipe table from
371 * note: it doesn't seem possible to get the chip
372 * currently open gate/pipe table.
373 * It is only possible to obtain the supported
378 * For now, always do a full initialization */
381 r
= nfc_hci_disconnect_all_gates(hdev
);
385 r
= hci_dev_connect_gates(hdev
, hdev
->init_data
.gate_count
,
386 hdev
->init_data
.gates
);
390 r
= nfc_hci_set_param(hdev
, NFC_HCI_ADMIN_GATE
,
391 NFC_HCI_ADMIN_SESSION_IDENTITY
,
392 hdev
->init_data
.session_id
,
393 strlen(hdev
->init_data
.session_id
));
398 nfc_hci_disconnect_all_gates(hdev
);
407 static int hci_dev_version(struct nfc_hci_dev
*hdev
)
412 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
413 NFC_HCI_ID_MGMT_VERSION_SW
, &skb
);
422 hdev
->sw_romlib
= (skb
->data
[0] & 0xf0) >> 4;
423 hdev
->sw_patch
= skb
->data
[0] & 0x0f;
424 hdev
->sw_flashlib_major
= skb
->data
[1];
425 hdev
->sw_flashlib_minor
= skb
->data
[2];
429 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
430 NFC_HCI_ID_MGMT_VERSION_HW
, &skb
);
439 hdev
->hw_derivative
= (skb
->data
[0] & 0xe0) >> 5;
440 hdev
->hw_version
= skb
->data
[0] & 0x1f;
441 hdev
->hw_mpw
= (skb
->data
[1] & 0xc0) >> 6;
442 hdev
->hw_software
= skb
->data
[1] & 0x3f;
443 hdev
->hw_bsid
= skb
->data
[2];
447 pr_info("SOFTWARE INFO:\n");
448 pr_info("RomLib : %d\n", hdev
->sw_romlib
);
449 pr_info("Patch : %d\n", hdev
->sw_patch
);
450 pr_info("FlashLib Major : %d\n", hdev
->sw_flashlib_major
);
451 pr_info("FlashLib Minor : %d\n", hdev
->sw_flashlib_minor
);
452 pr_info("HARDWARE INFO:\n");
453 pr_info("Derivative : %d\n", hdev
->hw_derivative
);
454 pr_info("HW Version : %d\n", hdev
->hw_version
);
455 pr_info("#MPW : %d\n", hdev
->hw_mpw
);
456 pr_info("Software : %d\n", hdev
->hw_software
);
457 pr_info("BSID Version : %d\n", hdev
->hw_bsid
);
462 static int hci_dev_up(struct nfc_dev
*nfc_dev
)
464 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
467 if (hdev
->ops
->open
) {
468 r
= hdev
->ops
->open(hdev
);
473 r
= hci_dev_session_init(hdev
);
477 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
478 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
482 if (hdev
->ops
->hci_ready
) {
483 r
= hdev
->ops
->hci_ready(hdev
);
488 r
= hci_dev_version(hdev
);
494 if (hdev
->ops
->close
)
495 hdev
->ops
->close(hdev
);
499 static int hci_dev_down(struct nfc_dev
*nfc_dev
)
501 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
503 if (hdev
->ops
->close
)
504 hdev
->ops
->close(hdev
);
506 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
511 static int hci_start_poll(struct nfc_dev
*nfc_dev
,
512 u32 im_protocols
, u32 tm_protocols
)
514 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
516 if (hdev
->ops
->start_poll
)
517 return hdev
->ops
->start_poll(hdev
, im_protocols
, tm_protocols
);
519 return nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
520 NFC_HCI_EVT_READER_REQUESTED
, NULL
, 0);
523 static void hci_stop_poll(struct nfc_dev
*nfc_dev
)
525 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
527 nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
528 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
531 static int hci_activate_target(struct nfc_dev
*nfc_dev
,
532 struct nfc_target
*target
, u32 protocol
)
537 static void hci_deactivate_target(struct nfc_dev
*nfc_dev
,
538 struct nfc_target
*target
)
542 static int hci_transceive(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
543 struct sk_buff
*skb
, data_exchange_cb_t cb
,
546 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
548 struct sk_buff
*res_skb
= NULL
;
550 pr_debug("target_idx=%d\n", target
->idx
);
552 switch (target
->hci_reader_gate
) {
553 case NFC_HCI_RF_READER_A_GATE
:
554 case NFC_HCI_RF_READER_B_GATE
:
555 if (hdev
->ops
->data_exchange
) {
556 r
= hdev
->ops
->data_exchange(hdev
, target
, skb
,
558 if (r
<= 0) /* handled */
562 *skb_push(skb
, 1) = 0; /* CTR, see spec:10.2.2.1 */
563 r
= nfc_hci_send_cmd(hdev
, target
->hci_reader_gate
,
564 NFC_HCI_WR_XCHG_DATA
,
565 skb
->data
, skb
->len
, &res_skb
);
567 * TODO: Check RF Error indicator to make sure data is valid.
568 * It seems that HCI cmd can complete without error, but data
569 * can be invalid if an RF error occured? Ignore for now.
572 skb_trim(res_skb
, res_skb
->len
- 1); /* RF Err ind */
575 if (hdev
->ops
->data_exchange
) {
576 r
= hdev
->ops
->data_exchange(hdev
, target
, skb
,
587 cb(cb_context
, res_skb
, r
);
592 static int hci_check_presence(struct nfc_dev
*nfc_dev
,
593 struct nfc_target
*target
)
595 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
597 if (hdev
->ops
->check_presence
)
598 return hdev
->ops
->check_presence(hdev
, target
);
603 static struct nfc_ops hci_nfc_ops
= {
604 .dev_up
= hci_dev_up
,
605 .dev_down
= hci_dev_down
,
606 .start_poll
= hci_start_poll
,
607 .stop_poll
= hci_stop_poll
,
608 .activate_target
= hci_activate_target
,
609 .deactivate_target
= hci_deactivate_target
,
610 .im_transceive
= hci_transceive
,
611 .check_presence
= hci_check_presence
,
614 struct nfc_hci_dev
*nfc_hci_allocate_device(struct nfc_hci_ops
*ops
,
615 struct nfc_hci_init_data
*init_data
,
619 int max_link_payload
)
621 struct nfc_hci_dev
*hdev
;
623 if (ops
->xmit
== NULL
)
629 hdev
= kzalloc(sizeof(struct nfc_hci_dev
), GFP_KERNEL
);
633 hdev
->ndev
= nfc_allocate_device(&hci_nfc_ops
, protocols
,
634 tx_headroom
+ HCI_CMDS_HEADROOM
,
642 hdev
->max_data_link_payload
= max_link_payload
;
643 hdev
->init_data
= *init_data
;
645 nfc_set_drvdata(hdev
->ndev
, hdev
);
647 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
651 EXPORT_SYMBOL(nfc_hci_allocate_device
);
653 void nfc_hci_free_device(struct nfc_hci_dev
*hdev
)
655 nfc_free_device(hdev
->ndev
);
658 EXPORT_SYMBOL(nfc_hci_free_device
);
660 int nfc_hci_register_device(struct nfc_hci_dev
*hdev
)
662 struct device
*dev
= &hdev
->ndev
->dev
;
663 const char *devname
= dev_name(dev
);
667 mutex_init(&hdev
->msg_tx_mutex
);
669 INIT_LIST_HEAD(&hdev
->msg_tx_queue
);
671 INIT_WORK(&hdev
->msg_tx_work
, nfc_hci_msg_tx_work
);
672 snprintf(name
, sizeof(name
), "%s_hci_msg_tx_wq", devname
);
673 hdev
->msg_tx_wq
= alloc_workqueue(name
, WQ_NON_REENTRANT
| WQ_UNBOUND
|
675 if (hdev
->msg_tx_wq
== NULL
) {
680 init_timer(&hdev
->cmd_timer
);
681 hdev
->cmd_timer
.data
= (unsigned long)hdev
;
682 hdev
->cmd_timer
.function
= nfc_hci_cmd_timeout
;
684 skb_queue_head_init(&hdev
->rx_hcp_frags
);
686 INIT_WORK(&hdev
->msg_rx_work
, nfc_hci_msg_rx_work
);
687 snprintf(name
, sizeof(name
), "%s_hci_msg_rx_wq", devname
);
688 hdev
->msg_rx_wq
= alloc_workqueue(name
, WQ_NON_REENTRANT
| WQ_UNBOUND
|
690 if (hdev
->msg_rx_wq
== NULL
) {
695 skb_queue_head_init(&hdev
->msg_rx_queue
);
697 r
= nfc_register_device(hdev
->ndev
);
702 destroy_workqueue(hdev
->msg_tx_wq
);
704 destroy_workqueue(hdev
->msg_rx_wq
);
709 EXPORT_SYMBOL(nfc_hci_register_device
);
711 void nfc_hci_unregister_device(struct nfc_hci_dev
*hdev
)
713 struct hci_msg
*msg
, *n
;
715 skb_queue_purge(&hdev
->rx_hcp_frags
);
716 skb_queue_purge(&hdev
->msg_rx_queue
);
718 list_for_each_entry_safe(msg
, n
, &hdev
->msg_tx_queue
, msg_l
) {
719 list_del(&msg
->msg_l
);
720 skb_queue_purge(&msg
->msg_frags
);
724 del_timer_sync(&hdev
->cmd_timer
);
726 nfc_unregister_device(hdev
->ndev
);
728 destroy_workqueue(hdev
->msg_tx_wq
);
730 destroy_workqueue(hdev
->msg_rx_wq
);
732 EXPORT_SYMBOL(nfc_hci_unregister_device
);
734 void nfc_hci_set_clientdata(struct nfc_hci_dev
*hdev
, void *clientdata
)
736 hdev
->clientdata
= clientdata
;
738 EXPORT_SYMBOL(nfc_hci_set_clientdata
);
740 void *nfc_hci_get_clientdata(struct nfc_hci_dev
*hdev
)
742 return hdev
->clientdata
;
744 EXPORT_SYMBOL(nfc_hci_get_clientdata
);
746 static void nfc_hci_failure(struct nfc_hci_dev
*hdev
, int err
)
748 mutex_lock(&hdev
->msg_tx_mutex
);
750 if (hdev
->cmd_pending_msg
== NULL
) {
751 nfc_driver_failure(hdev
->ndev
, err
);
755 __nfc_hci_cmd_completion(hdev
, err
, NULL
);
758 mutex_unlock(&hdev
->msg_tx_mutex
);
761 void nfc_hci_driver_failure(struct nfc_hci_dev
*hdev
, int err
)
763 nfc_hci_failure(hdev
, err
);
765 EXPORT_SYMBOL(nfc_hci_driver_failure
);
767 void nfc_hci_recv_frame(struct nfc_hci_dev
*hdev
, struct sk_buff
*skb
)
769 struct hcp_packet
*packet
;
772 struct sk_buff
*hcp_skb
;
774 struct sk_buff
*frag_skb
;
777 packet
= (struct hcp_packet
*)skb
->data
;
778 if ((packet
->header
& ~NFC_HCI_FRAGMENT
) == 0) {
779 skb_queue_tail(&hdev
->rx_hcp_frags
, skb
);
783 /* it's the last fragment. Does it need re-aggregation? */
784 if (skb_queue_len(&hdev
->rx_hcp_frags
)) {
785 pipe
= packet
->header
& NFC_HCI_FRAGMENT
;
786 skb_queue_tail(&hdev
->rx_hcp_frags
, skb
);
789 skb_queue_walk(&hdev
->rx_hcp_frags
, frag_skb
) {
790 msg_len
+= (frag_skb
->len
-
791 NFC_HCI_HCP_PACKET_HEADER_LEN
);
794 hcp_skb
= nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN
+
795 msg_len
, GFP_KERNEL
);
796 if (hcp_skb
== NULL
) {
797 nfc_hci_failure(hdev
, -ENOMEM
);
801 *skb_put(hcp_skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
) = pipe
;
803 skb_queue_walk(&hdev
->rx_hcp_frags
, frag_skb
) {
804 msg_len
= frag_skb
->len
- NFC_HCI_HCP_PACKET_HEADER_LEN
;
805 memcpy(skb_put(hcp_skb
, msg_len
),
806 frag_skb
->data
+ NFC_HCI_HCP_PACKET_HEADER_LEN
,
810 skb_queue_purge(&hdev
->rx_hcp_frags
);
812 packet
->header
&= NFC_HCI_FRAGMENT
;
816 /* if this is a response, dispatch immediately to
817 * unblock waiting cmd context. Otherwise, enqueue to dispatch
818 * in separate context where handler can also execute command.
820 packet
= (struct hcp_packet
*)hcp_skb
->data
;
821 type
= HCP_MSG_GET_TYPE(packet
->message
.header
);
822 if (type
== NFC_HCI_HCP_RESPONSE
) {
823 pipe
= packet
->header
;
824 instruction
= HCP_MSG_GET_CMD(packet
->message
.header
);
825 skb_pull(hcp_skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
+
826 NFC_HCI_HCP_MESSAGE_HEADER_LEN
);
827 nfc_hci_hcp_message_rx(hdev
, pipe
, type
, instruction
, hcp_skb
);
829 skb_queue_tail(&hdev
->msg_rx_queue
, hcp_skb
);
830 queue_work(hdev
->msg_rx_wq
, &hdev
->msg_rx_work
);
833 EXPORT_SYMBOL(nfc_hci_recv_frame
);
835 MODULE_LICENSE("GPL");