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);
247 void nfc_hci_event_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 event
,
253 case NFC_HCI_EVT_TARGET_DISCOVERED
:
254 if (skb
->len
< 1) { /* no status data? */
259 if (skb
->data
[0] == 3) {
260 /* TODO: Multiple targets in field, none activated
261 * poll is supposedly stopped, but there is no
262 * single target to activate, so nothing to report
264 * if we need to restart poll, we must save the
265 * protocols from the initial poll and reuse here.
269 if (skb
->data
[0] != 0) {
274 r
= nfc_hci_target_discovered(hdev
,
275 nfc_hci_pipe2gate(hdev
, pipe
));
278 /* TODO: Unknown events are hardware specific
279 * pass them to the driver (needs a new hci_ops) */
287 /* TODO: There was an error dispatching the event,
288 * how to propagate up to nfc core?
293 static void nfc_hci_cmd_timeout(unsigned long data
)
295 struct nfc_hci_dev
*hdev
= (struct nfc_hci_dev
*)data
;
297 queue_work(hdev
->msg_tx_wq
, &hdev
->msg_tx_work
);
300 static int hci_dev_connect_gates(struct nfc_hci_dev
*hdev
, u8 gate_count
,
305 while (gate_count
--) {
306 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
, *p
);
315 static int hci_dev_session_init(struct nfc_hci_dev
*hdev
)
317 struct sk_buff
*skb
= NULL
;
319 u8 hci_gates
[] = { /* NFC_HCI_ADMIN_GATE MUST be first */
320 NFC_HCI_ADMIN_GATE
, NFC_HCI_LOOPBACK_GATE
,
321 NFC_HCI_ID_MGMT_GATE
, NFC_HCI_LINK_MGMT_GATE
,
322 NFC_HCI_RF_READER_B_GATE
, NFC_HCI_RF_READER_A_GATE
325 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
330 r
= nfc_hci_get_param(hdev
, NFC_HCI_ADMIN_GATE
,
331 NFC_HCI_ADMIN_SESSION_IDENTITY
, &skb
);
335 if (skb
->len
&& skb
->len
== strlen(hdev
->init_data
.session_id
))
336 if (memcmp(hdev
->init_data
.session_id
, skb
->data
,
338 /* TODO ELa: restore gate<->pipe table from
340 * note: it doesn't seem possible to get the chip
341 * currently open gate/pipe table.
342 * It is only possible to obtain the supported
347 * For now, always do a full initialization */
350 r
= nfc_hci_disconnect_all_gates(hdev
);
354 r
= hci_dev_connect_gates(hdev
, sizeof(hci_gates
), hci_gates
);
358 r
= hci_dev_connect_gates(hdev
, hdev
->init_data
.gate_count
,
359 hdev
->init_data
.gates
);
363 r
= nfc_hci_set_param(hdev
, NFC_HCI_ADMIN_GATE
,
364 NFC_HCI_ADMIN_SESSION_IDENTITY
,
365 hdev
->init_data
.session_id
,
366 strlen(hdev
->init_data
.session_id
));
371 nfc_hci_disconnect_all_gates(hdev
);
380 static int hci_dev_version(struct nfc_hci_dev
*hdev
)
385 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
386 NFC_HCI_ID_MGMT_VERSION_SW
, &skb
);
395 hdev
->sw_romlib
= (skb
->data
[0] & 0xf0) >> 4;
396 hdev
->sw_patch
= skb
->data
[0] & 0x0f;
397 hdev
->sw_flashlib_major
= skb
->data
[1];
398 hdev
->sw_flashlib_minor
= skb
->data
[2];
402 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
403 NFC_HCI_ID_MGMT_VERSION_HW
, &skb
);
412 hdev
->hw_derivative
= (skb
->data
[0] & 0xe0) >> 5;
413 hdev
->hw_version
= skb
->data
[0] & 0x1f;
414 hdev
->hw_mpw
= (skb
->data
[1] & 0xc0) >> 6;
415 hdev
->hw_software
= skb
->data
[1] & 0x3f;
416 hdev
->hw_bsid
= skb
->data
[2];
420 pr_info("SOFTWARE INFO:\n");
421 pr_info("RomLib : %d\n", hdev
->sw_romlib
);
422 pr_info("Patch : %d\n", hdev
->sw_patch
);
423 pr_info("FlashLib Major : %d\n", hdev
->sw_flashlib_major
);
424 pr_info("FlashLib Minor : %d\n", hdev
->sw_flashlib_minor
);
425 pr_info("HARDWARE INFO:\n");
426 pr_info("Derivative : %d\n", hdev
->hw_derivative
);
427 pr_info("HW Version : %d\n", hdev
->hw_version
);
428 pr_info("#MPW : %d\n", hdev
->hw_mpw
);
429 pr_info("Software : %d\n", hdev
->hw_software
);
430 pr_info("BSID Version : %d\n", hdev
->hw_bsid
);
435 static int hci_dev_up(struct nfc_dev
*nfc_dev
)
437 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
440 if (hdev
->ops
->open
) {
441 r
= hdev
->ops
->open(hdev
);
446 r
= hci_dev_session_init(hdev
);
450 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
451 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
455 if (hdev
->ops
->hci_ready
) {
456 r
= hdev
->ops
->hci_ready(hdev
);
461 r
= hci_dev_version(hdev
);
467 if (hdev
->ops
->close
)
468 hdev
->ops
->close(hdev
);
472 static int hci_dev_down(struct nfc_dev
*nfc_dev
)
474 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
476 if (hdev
->ops
->close
)
477 hdev
->ops
->close(hdev
);
479 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
484 static int hci_start_poll(struct nfc_dev
*nfc_dev
, u32 protocols
)
486 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
488 if (hdev
->ops
->start_poll
)
489 return hdev
->ops
->start_poll(hdev
, protocols
);
491 return nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
492 NFC_HCI_EVT_READER_REQUESTED
, NULL
, 0);
495 static void hci_stop_poll(struct nfc_dev
*nfc_dev
)
497 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
499 nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
500 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
503 static int hci_activate_target(struct nfc_dev
*nfc_dev
,
504 struct nfc_target
*target
, u32 protocol
)
509 static void hci_deactivate_target(struct nfc_dev
*nfc_dev
,
510 struct nfc_target
*target
)
514 static int hci_data_exchange(struct nfc_dev
*nfc_dev
, struct nfc_target
*target
,
515 struct sk_buff
*skb
, data_exchange_cb_t cb
,
518 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
520 struct sk_buff
*res_skb
= NULL
;
522 pr_debug("target_idx=%d\n", target
->idx
);
524 switch (target
->hci_reader_gate
) {
525 case NFC_HCI_RF_READER_A_GATE
:
526 case NFC_HCI_RF_READER_B_GATE
:
527 if (hdev
->ops
->data_exchange
) {
528 r
= hdev
->ops
->data_exchange(hdev
, target
, skb
,
530 if (r
<= 0) /* handled */
534 *skb_push(skb
, 1) = 0; /* CTR, see spec:10.2.2.1 */
535 r
= nfc_hci_send_cmd(hdev
, target
->hci_reader_gate
,
536 NFC_HCI_WR_XCHG_DATA
,
537 skb
->data
, skb
->len
, &res_skb
);
539 * TODO: Check RF Error indicator to make sure data is valid.
540 * It seems that HCI cmd can complete without error, but data
541 * can be invalid if an RF error occured? Ignore for now.
544 skb_trim(res_skb
, res_skb
->len
- 1); /* RF Err ind */
547 if (hdev
->ops
->data_exchange
) {
548 r
= hdev
->ops
->data_exchange(hdev
, target
, skb
,
559 cb(cb_context
, res_skb
, r
);
564 static int hci_check_presence(struct nfc_dev
*nfc_dev
,
565 struct nfc_target
*target
)
567 struct nfc_hci_dev
*hdev
= nfc_get_drvdata(nfc_dev
);
569 if (hdev
->ops
->check_presence
)
570 return hdev
->ops
->check_presence(hdev
, target
);
575 static struct nfc_ops hci_nfc_ops
= {
576 .dev_up
= hci_dev_up
,
577 .dev_down
= hci_dev_down
,
578 .start_poll
= hci_start_poll
,
579 .stop_poll
= hci_stop_poll
,
580 .activate_target
= hci_activate_target
,
581 .deactivate_target
= hci_deactivate_target
,
582 .data_exchange
= hci_data_exchange
,
583 .check_presence
= hci_check_presence
,
586 struct nfc_hci_dev
*nfc_hci_allocate_device(struct nfc_hci_ops
*ops
,
587 struct nfc_hci_init_data
*init_data
,
591 int max_link_payload
)
593 struct nfc_hci_dev
*hdev
;
595 if (ops
->xmit
== NULL
)
601 hdev
= kzalloc(sizeof(struct nfc_hci_dev
), GFP_KERNEL
);
605 hdev
->ndev
= nfc_allocate_device(&hci_nfc_ops
, protocols
,
606 tx_headroom
+ HCI_CMDS_HEADROOM
,
614 hdev
->max_data_link_payload
= max_link_payload
;
615 hdev
->init_data
= *init_data
;
617 nfc_set_drvdata(hdev
->ndev
, hdev
);
619 memset(hdev
->gate2pipe
, NFC_HCI_INVALID_PIPE
, sizeof(hdev
->gate2pipe
));
623 EXPORT_SYMBOL(nfc_hci_allocate_device
);
625 void nfc_hci_free_device(struct nfc_hci_dev
*hdev
)
627 nfc_free_device(hdev
->ndev
);
630 EXPORT_SYMBOL(nfc_hci_free_device
);
632 int nfc_hci_register_device(struct nfc_hci_dev
*hdev
)
634 struct device
*dev
= &hdev
->ndev
->dev
;
635 const char *devname
= dev_name(dev
);
639 mutex_init(&hdev
->msg_tx_mutex
);
641 INIT_LIST_HEAD(&hdev
->msg_tx_queue
);
643 INIT_WORK(&hdev
->msg_tx_work
, nfc_hci_msg_tx_work
);
644 snprintf(name
, sizeof(name
), "%s_hci_msg_tx_wq", devname
);
645 hdev
->msg_tx_wq
= alloc_workqueue(name
, WQ_NON_REENTRANT
| WQ_UNBOUND
|
647 if (hdev
->msg_tx_wq
== NULL
) {
652 init_timer(&hdev
->cmd_timer
);
653 hdev
->cmd_timer
.data
= (unsigned long)hdev
;
654 hdev
->cmd_timer
.function
= nfc_hci_cmd_timeout
;
656 skb_queue_head_init(&hdev
->rx_hcp_frags
);
658 INIT_WORK(&hdev
->msg_rx_work
, nfc_hci_msg_rx_work
);
659 snprintf(name
, sizeof(name
), "%s_hci_msg_rx_wq", devname
);
660 hdev
->msg_rx_wq
= alloc_workqueue(name
, WQ_NON_REENTRANT
| WQ_UNBOUND
|
662 if (hdev
->msg_rx_wq
== NULL
) {
667 skb_queue_head_init(&hdev
->msg_rx_queue
);
669 r
= nfc_register_device(hdev
->ndev
);
674 destroy_workqueue(hdev
->msg_tx_wq
);
676 destroy_workqueue(hdev
->msg_rx_wq
);
681 EXPORT_SYMBOL(nfc_hci_register_device
);
683 void nfc_hci_unregister_device(struct nfc_hci_dev
*hdev
)
687 skb_queue_purge(&hdev
->rx_hcp_frags
);
688 skb_queue_purge(&hdev
->msg_rx_queue
);
690 while ((msg
= list_first_entry(&hdev
->msg_tx_queue
, struct hci_msg
,
692 list_del(&msg
->msg_l
);
693 skb_queue_purge(&msg
->msg_frags
);
697 del_timer_sync(&hdev
->cmd_timer
);
699 nfc_unregister_device(hdev
->ndev
);
701 destroy_workqueue(hdev
->msg_tx_wq
);
703 destroy_workqueue(hdev
->msg_rx_wq
);
705 EXPORT_SYMBOL(nfc_hci_unregister_device
);
707 void nfc_hci_set_clientdata(struct nfc_hci_dev
*hdev
, void *clientdata
)
709 hdev
->clientdata
= clientdata
;
711 EXPORT_SYMBOL(nfc_hci_set_clientdata
);
713 void *nfc_hci_get_clientdata(struct nfc_hci_dev
*hdev
)
715 return hdev
->clientdata
;
717 EXPORT_SYMBOL(nfc_hci_get_clientdata
);
719 void nfc_hci_recv_frame(struct nfc_hci_dev
*hdev
, struct sk_buff
*skb
)
721 struct hcp_packet
*packet
;
724 struct sk_buff
*hcp_skb
;
726 struct sk_buff
*frag_skb
;
730 /* TODO ELa: lower layer had permanent failure, need to
734 skb_queue_purge(&hdev
->rx_hcp_frags
);
739 packet
= (struct hcp_packet
*)skb
->data
;
740 if ((packet
->header
& ~NFC_HCI_FRAGMENT
) == 0) {
741 skb_queue_tail(&hdev
->rx_hcp_frags
, skb
);
745 /* it's the last fragment. Does it need re-aggregation? */
746 if (skb_queue_len(&hdev
->rx_hcp_frags
)) {
747 pipe
= packet
->header
& NFC_HCI_FRAGMENT
;
748 skb_queue_tail(&hdev
->rx_hcp_frags
, skb
);
751 skb_queue_walk(&hdev
->rx_hcp_frags
, frag_skb
) {
752 msg_len
+= (frag_skb
->len
-
753 NFC_HCI_HCP_PACKET_HEADER_LEN
);
756 hcp_skb
= nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN
+
757 msg_len
, GFP_KERNEL
);
758 if (hcp_skb
== NULL
) {
759 /* TODO ELa: cannot deliver HCP message. How to
760 * propagate error up?
764 *skb_put(hcp_skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
) = pipe
;
766 skb_queue_walk(&hdev
->rx_hcp_frags
, frag_skb
) {
767 msg_len
= frag_skb
->len
- NFC_HCI_HCP_PACKET_HEADER_LEN
;
768 memcpy(skb_put(hcp_skb
, msg_len
),
769 frag_skb
->data
+ NFC_HCI_HCP_PACKET_HEADER_LEN
,
773 skb_queue_purge(&hdev
->rx_hcp_frags
);
775 packet
->header
&= NFC_HCI_FRAGMENT
;
779 /* if this is a response, dispatch immediately to
780 * unblock waiting cmd context. Otherwise, enqueue to dispatch
781 * in separate context where handler can also execute command.
783 packet
= (struct hcp_packet
*)hcp_skb
->data
;
784 type
= HCP_MSG_GET_TYPE(packet
->message
.header
);
785 if (type
== NFC_HCI_HCP_RESPONSE
) {
786 pipe
= packet
->header
;
787 instruction
= HCP_MSG_GET_CMD(packet
->message
.header
);
788 skb_pull(hcp_skb
, NFC_HCI_HCP_PACKET_HEADER_LEN
+
789 NFC_HCI_HCP_MESSAGE_HEADER_LEN
);
790 nfc_hci_hcp_message_rx(hdev
, pipe
, type
, instruction
, hcp_skb
);
792 skb_queue_tail(&hdev
->msg_rx_queue
, hcp_skb
);
793 queue_work(hdev
->msg_rx_wq
, &hdev
->msg_rx_work
);
796 EXPORT_SYMBOL(nfc_hci_recv_frame
);
798 MODULE_LICENSE("GPL");