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 void nfc_hci_msg_tx_work(struct work_struct
*work
)
37 struct nfc_hci_dev
*hdev
= container_of(work
, struct nfc_hci_dev
,
43 mutex_lock(&hdev
->msg_tx_mutex
);
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
,
54 kfree(hdev
->cmd_pending_msg
);
55 hdev
->cmd_pending_msg
= NULL
;
61 if (list_empty(&hdev
->msg_tx_queue
))
64 msg
= list_first_entry(&hdev
->msg_tx_queue
, struct hci_msg
, msg_l
);
65 list_del(&msg
->msg_l
);
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
);
72 skb_queue_purge(&msg
->msg_frags
);
74 msg
->cb(hdev
, NFC_HCI_ANY_E_NOK
, NULL
,
84 if (msg
->wait_response
== false) {
89 hdev
->cmd_pending_msg
= msg
;
90 mod_timer(&hdev
->cmd_timer
, jiffies
+
91 msecs_to_jiffies(hdev
->cmd_pending_msg
->completion_delay
));
94 mutex_unlock(&hdev
->msg_tx_mutex
);
97 static void nfc_hci_msg_rx_work(struct work_struct
*work
)
99 struct nfc_hci_dev
*hdev
= container_of(work
, struct nfc_hci_dev
,
102 struct hcp_message
*message
;
107 while ((skb
= skb_dequeue(&hdev
->msg_rx_queue
)) != NULL
) {
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
);
115 nfc_hci_hcp_message_rx(hdev
, pipe
, type
, instruction
, skb
);
119 void nfc_hci_resp_received(struct nfc_hci_dev
*hdev
, u8 result
,
122 mutex_lock(&hdev
->msg_tx_mutex
);
124 if (hdev
->cmd_pending_msg
== NULL
) {
129 del_timer_sync(&hdev
->cmd_timer
);
131 if (hdev
->cmd_pending_msg
->cb
)
132 hdev
->cmd_pending_msg
->cb(hdev
, result
, skb
,
133 hdev
->cmd_pending_msg
->cb_context
);
137 kfree(hdev
->cmd_pending_msg
);
138 hdev
->cmd_pending_msg
= NULL
;
140 queue_work(hdev
->msg_tx_wq
, &hdev
->msg_tx_work
);
143 mutex_unlock(&hdev
->msg_tx_mutex
);
146 void nfc_hci_cmd_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 cmd
,
152 static u32
nfc_hci_sak_to_protocol(u8 sak
)
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
;
168 static int nfc_hci_target_discovered(struct nfc_hci_dev
*hdev
, u8 gate
)
170 struct nfc_target
*targets
;
171 struct sk_buff
*atqa_skb
= NULL
;
172 struct sk_buff
*sak_skb
= NULL
;
175 pr_debug("from gate %d\n", gate
);
177 targets
= kzalloc(sizeof(struct nfc_target
), GFP_KERNEL
);
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
);
188 r
= nfc_hci_get_param(hdev
, NFC_HCI_RF_READER_A_GATE
,
189 NFC_HCI_RF_READER_A_SAK
, &sak_skb
);
193 if (atqa_skb
->len
!= 2 || sak_skb
->len
!= 1) {
198 targets
->supported_protocols
=
199 nfc_hci_sak_to_protocol(sak_skb
->data
[0]);
200 if (targets
->supported_protocols
== 0xffffffff) {
205 targets
->sens_res
= be16_to_cpu(*(u16
*)atqa_skb
->data
);
206 targets
->sel_res
= sak_skb
->data
[0];
208 if (hdev
->ops
->complete_target_discovered
) {
209 r
= hdev
->ops
->complete_target_discovered(hdev
, gate
,
215 case NFC_HCI_RF_READER_B_GATE
:
216 targets
->supported_protocols
= NFC_PROTO_ISO14443_MASK
;
219 if (hdev
->ops
->target_from_gate
)
220 r
= hdev
->ops
->target_from_gate(hdev
, gate
, targets
);
226 if (hdev
->ops
->complete_target_discovered
) {
227 r
= hdev
->ops
->complete_target_discovered(hdev
, gate
,
235 targets
->hci_reader_gate
= gate
;
237 r
= nfc_targets_found(hdev
->ndev
, targets
, 1);
241 kfree(hdev
->targets
);
242 hdev
->targets
= targets
;
244 hdev
->target_count
= 1;
254 void nfc_hci_event_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 event
,
260 case NFC_HCI_EVT_TARGET_DISCOVERED
:
261 if (hdev
->poll_started
== false) {
266 if (skb
->len
< 1) { /* no status data? */
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
276 * if we need to restart poll, we must save the
277 * protocols from the initial poll and reuse here.
281 if (skb
->data
[0] != 0) {
286 r
= nfc_hci_target_discovered(hdev
,
287 nfc_hci_pipe2gate(hdev
, pipe
));
290 /* TODO: Unknown events are hardware specific
291 * pass them to the driver (needs a new hci_ops) */
299 /* TODO: There was an error dispatching the event,
300 * how to propagate up to nfc core?
305 static void nfc_hci_cmd_timeout(unsigned long data
)
307 struct nfc_hci_dev
*hdev
= (struct nfc_hci_dev
*)data
;
309 queue_work(hdev
->msg_tx_wq
, &hdev
->msg_tx_work
);
312 static int hci_dev_connect_gates(struct nfc_hci_dev
*hdev
, u8 gate_count
,
317 while (gate_count
--) {
318 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
, *p
);
327 static int hci_dev_session_init(struct nfc_hci_dev
*hdev
)
329 struct sk_buff
*skb
= NULL
;
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
337 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
342 r
= nfc_hci_get_param(hdev
, NFC_HCI_ADMIN_GATE
,
343 NFC_HCI_ADMIN_SESSION_IDENTITY
, &skb
);
347 if (skb
->len
&& skb
->len
== strlen(hdev
->init_data
.session_id
))
348 if (memcmp(hdev
->init_data
.session_id
, skb
->data
,
350 /* TODO ELa: restore gate<->pipe table from
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
359 * For now, always do a full initialization */
362 r
= nfc_hci_disconnect_all_gates(hdev
);
366 r
= hci_dev_connect_gates(hdev
, sizeof(hci_gates
), hci_gates
);
370 r
= hci_dev_connect_gates(hdev
, hdev
->init_data
.gate_count
,
371 hdev
->init_data
.gates
);
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
));
383 nfc_hci_disconnect_all_gates(hdev
);
392 static int hci_dev_version(struct nfc_hci_dev
*hdev
)
397 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
398 NFC_HCI_ID_MGMT_VERSION_SW
, &skb
);
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];
414 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
415 NFC_HCI_ID_MGMT_VERSION_HW
, &skb
);
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];
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
);
447 static int hci_dev_up(struct nfc_dev
*nfc_dev
)
449 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
452 if (hdev
->ops
->open
) {
453 r
= hdev
->ops
->open(hdev
);
458 r
= hci_dev_session_init(hdev
);
462 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
463 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
467 if (hdev
->ops
->hci_ready
) {
468 r
= hdev
->ops
->hci_ready(hdev
);
473 r
= hci_dev_version(hdev
);
479 if (hdev
->ops
->close
)
480 hdev
->ops
->close(hdev
);
484 static int hci_dev_down(struct nfc_dev
*nfc_dev
)
486 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
488 if (hdev
->ops
->close
)
489 hdev
->ops
->close(hdev
);
491 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
496 static int hci_start_poll(struct nfc_dev
*nfc_dev
, u32 protocols
)
498 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
501 if (hdev
->ops
->start_poll
)
502 r
= hdev
->ops
->start_poll(hdev
, protocols
);
504 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
505 NFC_HCI_EVT_READER_REQUESTED
, NULL
, 0);
507 hdev
->poll_started
= true;
512 static void hci_stop_poll(struct nfc_dev
*nfc_dev
)
514 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
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;
523 static struct nfc_target
*hci_find_target(struct nfc_hci_dev
*hdev
,
527 if (hdev
->poll_started
== false || hdev
->targets
== NULL
)
530 for (i
= 0; i
< hdev
->target_count
; i
++) {
531 if (hdev
->targets
[i
].idx
== target_idx
)
532 return &hdev
->targets
[i
];
538 static int hci_activate_target(struct nfc_dev
*nfc_dev
, u32 target_idx
,
541 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
543 if (hci_find_target(hdev
, target_idx
) == NULL
)
549 static void hci_deactivate_target(struct nfc_dev
*nfc_dev
, u32 target_idx
)
553 static int hci_data_exchange(struct nfc_dev
*nfc_dev
, u32 target_idx
,
554 struct sk_buff
*skb
, data_exchange_cb_t cb
,
557 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
559 struct nfc_target
*target
;
560 struct sk_buff
*res_skb
= NULL
;
562 pr_debug("target_idx=%d\n", target_idx
);
564 target
= hci_find_target(hdev
, target_idx
);
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
,
574 if (r
<= 0) /* handled */
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
);
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.
588 skb_trim(res_skb
, res_skb
->len
- 1); /* RF Err ind */
591 if (hdev
->ops
->data_exchange
) {
592 r
= hdev
->ops
->data_exchange(hdev
, target
, skb
,
603 cb(cb_context
, res_skb
, r
);
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
,
618 struct nfc_hci_dev
*nfc_hci_allocate_device(struct nfc_hci_ops
*ops
,
619 struct nfc_hci_init_data
*init_data
,
623 int max_link_payload
)
625 struct nfc_hci_dev
*hdev
;
627 if (ops
->xmit
== NULL
)
633 hdev
= kzalloc(sizeof(struct nfc_hci_dev
), GFP_KERNEL
);
637 hdev
->ndev
= nfc_allocate_device(&hci_nfc_ops
, protocols
,
638 tx_headroom
+ HCI_CMDS_HEADROOM
,
646 hdev
->max_data_link_payload
= max_link_payload
;
647 hdev
->init_data
= *init_data
;
649 nfc_set_drvdata(hdev
->ndev
, hdev
);
651 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
655 EXPORT_SYMBOL(nfc_hci_allocate_device
);
657 void nfc_hci_free_device(struct nfc_hci_dev
*hdev
)
659 nfc_free_device(hdev
->ndev
);
662 EXPORT_SYMBOL(nfc_hci_free_device
);
664 int nfc_hci_register_device(struct nfc_hci_dev
*hdev
)
666 struct device
*dev
= &hdev
->ndev
->dev
;
667 const char *devname
= dev_name(dev
);
671 mutex_init(&hdev
->msg_tx_mutex
);
673 INIT_LIST_HEAD(&hdev
->msg_tx_queue
);
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
|
679 if (hdev
->msg_tx_wq
== NULL
) {
684 init_timer(&hdev
->cmd_timer
);
685 hdev
->cmd_timer
.data
= (unsigned long)hdev
;
686 hdev
->cmd_timer
.function
= nfc_hci_cmd_timeout
;
688 skb_queue_head_init(&hdev
->rx_hcp_frags
);
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
|
694 if (hdev
->msg_rx_wq
== NULL
) {
699 skb_queue_head_init(&hdev
->msg_rx_queue
);
701 r
= nfc_register_device(hdev
->ndev
);
706 destroy_workqueue(hdev
->msg_tx_wq
);
708 destroy_workqueue(hdev
->msg_rx_wq
);
713 EXPORT_SYMBOL(nfc_hci_register_device
);
715 void nfc_hci_unregister_device(struct nfc_hci_dev
*hdev
)
719 skb_queue_purge(&hdev
->rx_hcp_frags
);
720 skb_queue_purge(&hdev
->msg_rx_queue
);
722 while ((msg
= list_first_entry(&hdev
->msg_tx_queue
, struct hci_msg
,
724 list_del(&msg
->msg_l
);
725 skb_queue_purge(&msg
->msg_frags
);
729 del_timer_sync(&hdev
->cmd_timer
);
731 nfc_unregister_device(hdev
->ndev
);
733 destroy_workqueue(hdev
->msg_tx_wq
);
735 destroy_workqueue(hdev
->msg_rx_wq
);
737 EXPORT_SYMBOL(nfc_hci_unregister_device
);
739 void nfc_hci_set_clientdata(struct nfc_hci_dev
*hdev
, void *clientdata
)
741 hdev
->clientdata
= clientdata
;
743 EXPORT_SYMBOL(nfc_hci_set_clientdata
);
745 void *nfc_hci_get_clientdata(struct nfc_hci_dev
*hdev
)
747 return hdev
->clientdata
;
749 EXPORT_SYMBOL(nfc_hci_get_clientdata
);
751 void nfc_hci_recv_frame(struct nfc_hci_dev
*hdev
, struct sk_buff
*skb
)
753 struct hcp_packet
*packet
;
756 struct sk_buff
*hcp_skb
;
758 struct sk_buff
*frag_skb
;
762 /* TODO ELa: lower layer had permanent failure, need to
766 skb_queue_purge(&hdev
->rx_hcp_frags
);
771 packet
= (struct hcp_packet
*)skb
->data
;
772 if ((packet
->header
& ~NFC_HCI_FRAGMENT
) == 0) {
773 skb_queue_tail(&hdev
->rx_hcp_frags
, skb
);
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
);
783 skb_queue_walk(&hdev
->rx_hcp_frags
, frag_skb
) {
784 msg_len
+= (frag_skb
->len
-
785 NFC_HCI_HCP_PACKET_HEADER_LEN
);
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?
796 *skb_put(hcp_skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
) = pipe
;
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
,
805 skb_queue_purge(&hdev
->rx_hcp_frags
);
807 packet
->header
&= NFC_HCI_FRAGMENT
;
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.
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
);
824 skb_queue_tail(&hdev
->msg_rx_queue
, hcp_skb
);
825 queue_work(hdev
->msg_rx_wq
, &hdev
->msg_rx_work
);
828 EXPORT_SYMBOL(nfc_hci_recv_frame
);
830 MODULE_LICENSE("GPL");