2 * HCI based Driver for STMicroelectronics NFC Chip
4 * Copyright (C) 2014 STMicroelectronics SAS. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 #include <linux/module.h>
20 #include <linux/nfc.h>
21 #include <net/nfc/hci.h>
22 #include <net/nfc/llc.h>
26 #define DRIVER_DESC "HCI NFC driver for ST21NFCA"
28 #define FULL_VERSION_LEN 3
30 /* Proprietary gates, events, commands and registers */
32 /* Commands that apply to all RF readers */
33 #define ST21NFCA_RF_READER_CMD_PRESENCE_CHECK 0x30
35 #define ST21NFCA_RF_READER_ISO15693_GATE 0x12
36 #define ST21NFCA_RF_READER_ISO15693_INVENTORY 0x01
39 * Reader gate for communication with contact-less cards using Type A
40 * protocol ISO14443-3 but not compliant with ISO14443-4
42 #define ST21NFCA_RF_READER_14443_3_A_GATE 0x15
43 #define ST21NFCA_RF_READER_14443_3_A_UID 0x02
44 #define ST21NFCA_RF_READER_14443_3_A_ATQA 0x03
45 #define ST21NFCA_RF_READER_14443_3_A_SAK 0x04
47 #define ST21NFCA_RF_READER_F_DATARATE 0x01
48 #define ST21NFCA_RF_READER_F_DATARATE_106 0x01
49 #define ST21NFCA_RF_READER_F_DATARATE_212 0x02
50 #define ST21NFCA_RF_READER_F_DATARATE_424 0x04
51 #define ST21NFCA_RF_READER_F_POL_REQ 0x02
52 #define ST21NFCA_RF_READER_F_POL_REQ_DEFAULT 0xffff0000
53 #define ST21NFCA_RF_READER_F_NFCID2 0x03
54 #define ST21NFCA_RF_READER_F_NFCID1 0x04
56 #define ST21NFCA_RF_CARD_F_MODE 0x01
57 #define ST21NFCA_RF_CARD_F_NFCID2_LIST 0x04
58 #define ST21NFCA_RF_CARD_F_NFCID1 0x05
59 #define ST21NFCA_RF_CARD_F_SENS_RES 0x06
60 #define ST21NFCA_RF_CARD_F_SEL_RES 0x07
61 #define ST21NFCA_RF_CARD_F_DATARATE 0x08
62 #define ST21NFCA_RF_CARD_F_DATARATE_212_424 0x01
64 #define ST21NFCA_DEVICE_MGNT_PIPE 0x02
66 #define ST21NFCA_DM_GETINFO 0x13
67 #define ST21NFCA_DM_GETINFO_PIPE_LIST 0x02
68 #define ST21NFCA_DM_GETINFO_PIPE_INFO 0x01
69 #define ST21NFCA_DM_PIPE_CREATED 0x02
70 #define ST21NFCA_DM_PIPE_OPEN 0x04
71 #define ST21NFCA_DM_RF_ACTIVE 0x80
72 #define ST21NFCA_DM_DISCONNECT 0x30
74 #define ST21NFCA_DM_IS_PIPE_OPEN(p) \
75 ((p & 0x0f) == (ST21NFCA_DM_PIPE_CREATED | ST21NFCA_DM_PIPE_OPEN))
77 #define ST21NFCA_NFC_MODE 0x03 /* NFC_MODE parameter*/
79 #define ST21NFCA_EVT_HOT_PLUG 0x03
80 #define ST21NFCA_EVT_HOT_PLUG_IS_INHIBITED(x) (x->data[0] & 0x80)
82 #define ST21NFCA_SE_TO_PIPES 2000
84 static DECLARE_BITMAP(dev_mask
, ST21NFCA_NUM_DEVICES
);
86 static struct nfc_hci_gate st21nfca_gates
[] = {
87 {NFC_HCI_ADMIN_GATE
, NFC_HCI_ADMIN_PIPE
},
88 {NFC_HCI_LINK_MGMT_GATE
, NFC_HCI_LINK_MGMT_PIPE
},
89 {ST21NFCA_DEVICE_MGNT_GATE
, ST21NFCA_DEVICE_MGNT_PIPE
},
91 {NFC_HCI_LOOPBACK_GATE
, NFC_HCI_INVALID_PIPE
},
92 {NFC_HCI_ID_MGMT_GATE
, NFC_HCI_INVALID_PIPE
},
93 {NFC_HCI_RF_READER_B_GATE
, NFC_HCI_INVALID_PIPE
},
94 {NFC_HCI_RF_READER_A_GATE
, NFC_HCI_INVALID_PIPE
},
95 {ST21NFCA_RF_READER_F_GATE
, NFC_HCI_INVALID_PIPE
},
96 {ST21NFCA_RF_READER_14443_3_A_GATE
, NFC_HCI_INVALID_PIPE
},
97 {ST21NFCA_RF_READER_ISO15693_GATE
, NFC_HCI_INVALID_PIPE
},
98 {ST21NFCA_RF_CARD_F_GATE
, NFC_HCI_INVALID_PIPE
},
100 /* Secure element pipes are created by secure element host */
101 {ST21NFCA_CONNECTIVITY_GATE
, NFC_HCI_DO_NOT_CREATE_PIPE
},
102 {ST21NFCA_APDU_READER_GATE
, NFC_HCI_DO_NOT_CREATE_PIPE
},
105 struct st21nfca_pipe_info
{
113 /* Largest headroom needed for outgoing custom commands */
114 #define ST21NFCA_CMDS_HEADROOM 7
116 static int st21nfca_hci_load_session(struct nfc_hci_dev
*hdev
)
119 struct sk_buff
*skb_pipe_list
, *skb_pipe_info
;
120 struct st21nfca_pipe_info
*info
;
122 u8 pipe_list
[] = { ST21NFCA_DM_GETINFO_PIPE_LIST
,
123 NFC_HCI_TERMINAL_HOST_ID
125 u8 pipe_info
[] = { ST21NFCA_DM_GETINFO_PIPE_INFO
,
126 NFC_HCI_TERMINAL_HOST_ID
, 0
129 /* On ST21NFCA device pipes number are dynamics
130 * A maximum of 16 pipes can be created at the same time
131 * If pipes are already created, hci_dev_up will fail.
132 * Doing a clear all pipe is a bad idea because:
133 * - It does useless EEPROM cycling
134 * - It might cause issue for secure elements support
135 * (such as removing connectivity or APDU reader pipe)
136 * A better approach on ST21NFCA is to:
137 * - get a pipe list for each host.
138 * (eg: NFC_HCI_HOST_CONTROLLER_ID for now).
139 * (TODO Later on UICC HOST and eSE HOST)
140 * - get pipe information
141 * - match retrieved pipe list in st21nfca_gates
142 * ST21NFCA_DEVICE_MGNT_GATE is a proprietary gate
143 * with ST21NFCA_DEVICE_MGNT_PIPE.
144 * Pipe can be closed and need to be open.
146 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
147 ST21NFCA_DEVICE_MGNT_GATE
,
148 ST21NFCA_DEVICE_MGNT_PIPE
);
153 r
= nfc_hci_send_cmd(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
154 ST21NFCA_DM_GETINFO
, pipe_list
, sizeof(pipe_list
),
159 /* Complete the existing gate_pipe table */
160 for (i
= 0; i
< skb_pipe_list
->len
; i
++) {
161 pipe_info
[2] = skb_pipe_list
->data
[i
];
162 r
= nfc_hci_send_cmd(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
163 ST21NFCA_DM_GETINFO
, pipe_info
,
164 sizeof(pipe_info
), &skb_pipe_info
);
169 * Match pipe ID and gate ID
170 * Output format from ST21NFC_DM_GETINFO is:
171 * - pipe state (1byte)
172 * - source hid (1byte)
173 * - source gid (1byte)
174 * - destination hid (1byte)
175 * - destination gid (1byte)
177 info
= (struct st21nfca_pipe_info
*) skb_pipe_info
->data
;
178 if (info
->dst_gate_id
== ST21NFCA_APDU_READER_GATE
&&
179 info
->src_host_id
== NFC_HCI_UICC_HOST_ID
) {
180 pr_err("Unexpected apdu_reader pipe on host %x\n",
182 kfree_skb(skb_pipe_info
);
186 for (j
= 3; (j
< ARRAY_SIZE(st21nfca_gates
)) &&
187 (st21nfca_gates
[j
].gate
!= info
->dst_gate_id
) ; j
++)
190 if (j
< ARRAY_SIZE(st21nfca_gates
) &&
191 st21nfca_gates
[j
].gate
== info
->dst_gate_id
&&
192 ST21NFCA_DM_IS_PIPE_OPEN(info
->pipe_state
)) {
193 hdev
->init_data
.gates
[j
].pipe
= pipe_info
[2];
195 hdev
->gate2pipe
[st21nfca_gates
[j
].gate
] =
197 hdev
->pipes
[pipe_info
[2]].gate
=
198 st21nfca_gates
[j
].gate
;
199 hdev
->pipes
[pipe_info
[2]].dest_host
=
202 kfree_skb(skb_pipe_info
);
206 * 3 gates have a well known pipe ID. Only NFC_HCI_LINK_MGMT_GATE
207 * is not yet open at this stage.
209 r
= nfc_hci_connect_gate(hdev
, NFC_HCI_HOST_CONTROLLER_ID
,
210 NFC_HCI_LINK_MGMT_GATE
,
211 NFC_HCI_LINK_MGMT_PIPE
);
213 kfree_skb(skb_pipe_list
);
217 static int st21nfca_hci_open(struct nfc_hci_dev
*hdev
)
219 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
222 mutex_lock(&info
->info_lock
);
224 if (info
->state
!= ST21NFCA_ST_COLD
) {
229 r
= info
->phy_ops
->enable(info
->phy_id
);
232 info
->state
= ST21NFCA_ST_READY
;
235 mutex_unlock(&info
->info_lock
);
239 static void st21nfca_hci_close(struct nfc_hci_dev
*hdev
)
241 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
243 mutex_lock(&info
->info_lock
);
245 if (info
->state
== ST21NFCA_ST_COLD
)
248 info
->phy_ops
->disable(info
->phy_id
);
249 info
->state
= ST21NFCA_ST_COLD
;
252 mutex_unlock(&info
->info_lock
);
255 static int st21nfca_hci_ready(struct nfc_hci_dev
*hdev
)
257 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
265 if (info
->se_status
->is_uicc_present
)
266 white_list
[wl_size
++] = NFC_HCI_UICC_HOST_ID
;
267 if (info
->se_status
->is_ese_present
)
268 white_list
[wl_size
++] = ST21NFCA_ESE_HOST_ID
;
271 r
= nfc_hci_set_param(hdev
, NFC_HCI_ADMIN_GATE
,
272 NFC_HCI_ADMIN_WHITELIST
,
273 (u8
*) &white_list
, wl_size
);
278 /* Set NFC_MODE in device management gate to enable */
279 r
= nfc_hci_get_param(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
280 ST21NFCA_NFC_MODE
, &skb
);
284 param
= skb
->data
[0];
289 r
= nfc_hci_set_param(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
290 ST21NFCA_NFC_MODE
, ¶m
, 1);
295 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
296 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
300 r
= nfc_hci_get_param(hdev
, NFC_HCI_ID_MGMT_GATE
,
301 NFC_HCI_ID_MGMT_VERSION_SW
, &skb
);
305 if (skb
->len
!= FULL_VERSION_LEN
) {
310 print_hex_dump(KERN_DEBUG
, "FULL VERSION SOFTWARE INFO: ",
311 DUMP_PREFIX_NONE
, 16, 1,
312 skb
->data
, FULL_VERSION_LEN
, false);
319 static int st21nfca_hci_xmit(struct nfc_hci_dev
*hdev
, struct sk_buff
*skb
)
321 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
323 return info
->phy_ops
->write(info
->phy_id
, skb
);
326 static int st21nfca_hci_start_poll(struct nfc_hci_dev
*hdev
,
327 u32 im_protocols
, u32 tm_protocols
)
332 struct sk_buff
*datarate_skb
;
334 pr_info(DRIVER_DESC
": %s protocols 0x%x 0x%x\n",
335 __func__
, im_protocols
, tm_protocols
);
337 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
338 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
343 * enable polling according to im_protocols & tm_protocols
344 * - CLOSE pipe according to im_protocols & tm_protocols
346 if ((NFC_HCI_RF_READER_B_GATE
& im_protocols
) == 0) {
347 r
= nfc_hci_disconnect_gate(hdev
,
348 NFC_HCI_RF_READER_B_GATE
);
353 if ((NFC_HCI_RF_READER_A_GATE
& im_protocols
) == 0) {
354 r
= nfc_hci_disconnect_gate(hdev
,
355 NFC_HCI_RF_READER_A_GATE
);
360 if ((ST21NFCA_RF_READER_F_GATE
& im_protocols
) == 0) {
361 r
= nfc_hci_disconnect_gate(hdev
,
362 ST21NFCA_RF_READER_F_GATE
);
366 hdev
->gb
= nfc_get_local_general_bytes(hdev
->ndev
,
369 if (hdev
->gb
== NULL
|| hdev
->gb_len
== 0) {
370 im_protocols
&= ~NFC_PROTO_NFC_DEP_MASK
;
371 tm_protocols
&= ~NFC_PROTO_NFC_DEP_MASK
;
374 param
[0] = ST21NFCA_RF_READER_F_DATARATE_106
|
375 ST21NFCA_RF_READER_F_DATARATE_212
|
376 ST21NFCA_RF_READER_F_DATARATE_424
;
377 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_READER_F_GATE
,
378 ST21NFCA_RF_READER_F_DATARATE
,
383 pol_req
= be32_to_cpu((__force __be32
)
384 ST21NFCA_RF_READER_F_POL_REQ_DEFAULT
);
385 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_READER_F_GATE
,
386 ST21NFCA_RF_READER_F_POL_REQ
,
392 if ((ST21NFCA_RF_READER_14443_3_A_GATE
& im_protocols
) == 0) {
393 r
= nfc_hci_disconnect_gate(hdev
,
394 ST21NFCA_RF_READER_14443_3_A_GATE
);
399 if ((ST21NFCA_RF_READER_ISO15693_GATE
& im_protocols
) == 0) {
400 r
= nfc_hci_disconnect_gate(hdev
,
401 ST21NFCA_RF_READER_ISO15693_GATE
);
406 r
= nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
407 NFC_HCI_EVT_READER_REQUESTED
, NULL
, 0);
409 nfc_hci_send_event(hdev
, NFC_HCI_RF_READER_A_GATE
,
410 NFC_HCI_EVT_END_OPERATION
, NULL
, 0);
413 if (tm_protocols
& NFC_PROTO_NFC_DEP_MASK
) {
414 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
415 ST21NFCA_RF_CARD_F_DATARATE
,
420 /* Configure the maximum supported datarate to 424Kbps */
421 if (datarate_skb
->len
> 0 &&
422 datarate_skb
->data
[0] !=
423 ST21NFCA_RF_CARD_F_DATARATE_212_424
) {
424 param
[0] = ST21NFCA_RF_CARD_F_DATARATE_212_424
;
425 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
426 ST21NFCA_RF_CARD_F_DATARATE
,
429 kfree_skb(datarate_skb
);
433 kfree_skb(datarate_skb
);
438 * NFC Forum Digital Spec Table 7:
439 * NFCID1 size: triple (10 bytes)
443 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
444 ST21NFCA_RF_CARD_F_SENS_RES
, param
, 2);
451 * NFC Forum Digistal Spec Table 17:
452 * b3 set to 0b (value b7-b6):
453 * - 10b: Configured for NFC-DEP Protocol
456 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
457 ST21NFCA_RF_CARD_F_SEL_RES
, param
, 1);
461 /* Configure NFCID1 Random uid */
462 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
463 ST21NFCA_RF_CARD_F_NFCID1
, NULL
, 0);
467 /* Configure NFCID2_LIST */
480 /* 8 byte Pad bytes used for polling respone frame */
483 * Configuration byte:
484 * - bit 0: define the default NFCID2 entry used when the
485 * system code is equal to 'FFFF'
486 * - bit 1: use a random value for lowest 6 bytes of
488 * - bit 2: ignore polling request frame if request code
490 * - Other bits are RFU
493 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
494 ST21NFCA_RF_CARD_F_NFCID2_LIST
, param
,
500 r
= nfc_hci_set_param(hdev
, ST21NFCA_RF_CARD_F_GATE
,
501 ST21NFCA_RF_CARD_F_MODE
, param
, 1);
507 static void st21nfca_hci_stop_poll(struct nfc_hci_dev
*hdev
)
509 nfc_hci_send_cmd(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
510 ST21NFCA_DM_DISCONNECT
, NULL
, 0, NULL
);
513 static int st21nfca_get_iso14443_3_atqa(struct nfc_hci_dev
*hdev
, u16
*atqa
)
516 struct sk_buff
*atqa_skb
= NULL
;
518 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_14443_3_A_GATE
,
519 ST21NFCA_RF_READER_14443_3_A_ATQA
, &atqa_skb
);
523 if (atqa_skb
->len
!= 2) {
528 *atqa
= be16_to_cpu(*(__be16
*) atqa_skb
->data
);
535 static int st21nfca_get_iso14443_3_sak(struct nfc_hci_dev
*hdev
, u8
*sak
)
538 struct sk_buff
*sak_skb
= NULL
;
540 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_14443_3_A_GATE
,
541 ST21NFCA_RF_READER_14443_3_A_SAK
, &sak_skb
);
545 if (sak_skb
->len
!= 1) {
550 *sak
= sak_skb
->data
[0];
557 static int st21nfca_get_iso14443_3_uid(struct nfc_hci_dev
*hdev
, u8
*uid
,
561 struct sk_buff
*uid_skb
= NULL
;
563 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_14443_3_A_GATE
,
564 ST21NFCA_RF_READER_14443_3_A_UID
, &uid_skb
);
568 if (uid_skb
->len
== 0 || uid_skb
->len
> NFC_NFCID1_MAXSIZE
) {
573 memcpy(uid
, uid_skb
->data
, uid_skb
->len
);
580 static int st21nfca_get_iso15693_inventory(struct nfc_hci_dev
*hdev
,
581 struct nfc_target
*target
)
584 struct sk_buff
*inventory_skb
= NULL
;
586 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_ISO15693_GATE
,
587 ST21NFCA_RF_READER_ISO15693_INVENTORY
,
592 skb_pull(inventory_skb
, 2);
594 if (inventory_skb
->len
== 0 ||
595 inventory_skb
->len
> NFC_ISO15693_UID_MAXSIZE
) {
600 memcpy(target
->iso15693_uid
, inventory_skb
->data
, inventory_skb
->len
);
601 target
->iso15693_dsfid
= inventory_skb
->data
[1];
602 target
->is_iso15693
= 1;
604 kfree_skb(inventory_skb
);
608 static int st21nfca_hci_dep_link_up(struct nfc_hci_dev
*hdev
,
609 struct nfc_target
*target
, u8 comm_mode
,
610 u8
*gb
, size_t gb_len
)
612 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
614 info
->dep_info
.idx
= target
->idx
;
615 return st21nfca_im_send_atr_req(hdev
, gb
, gb_len
);
618 static int st21nfca_hci_dep_link_down(struct nfc_hci_dev
*hdev
)
620 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
622 info
->state
= ST21NFCA_ST_READY
;
624 return nfc_hci_send_cmd(hdev
, ST21NFCA_DEVICE_MGNT_GATE
,
625 ST21NFCA_DM_DISCONNECT
, NULL
, 0, NULL
);
628 static int st21nfca_hci_target_from_gate(struct nfc_hci_dev
*hdev
, u8 gate
,
629 struct nfc_target
*target
)
634 u8 uid
[NFC_NFCID1_MAXSIZE
];
637 case ST21NFCA_RF_READER_F_GATE
:
638 target
->supported_protocols
= NFC_PROTO_FELICA_MASK
;
640 case ST21NFCA_RF_READER_14443_3_A_GATE
:
641 /* ISO14443-3 type 1 or 2 tags */
642 r
= st21nfca_get_iso14443_3_atqa(hdev
, &atqa
);
645 if (atqa
== 0x000c) {
646 target
->supported_protocols
= NFC_PROTO_JEWEL_MASK
;
647 target
->sens_res
= 0x0c00;
649 r
= st21nfca_get_iso14443_3_sak(hdev
, &sak
);
653 r
= st21nfca_get_iso14443_3_uid(hdev
, uid
, &len
);
657 target
->supported_protocols
=
658 nfc_hci_sak_to_protocol(sak
);
659 if (target
->supported_protocols
== 0xffffffff)
662 target
->sens_res
= atqa
;
663 target
->sel_res
= sak
;
664 memcpy(target
->nfcid1
, uid
, len
);
665 target
->nfcid1_len
= len
;
669 case ST21NFCA_RF_READER_ISO15693_GATE
:
670 target
->supported_protocols
= NFC_PROTO_ISO15693_MASK
;
671 r
= st21nfca_get_iso15693_inventory(hdev
, target
);
682 static int st21nfca_hci_complete_target_discovered(struct nfc_hci_dev
*hdev
,
684 struct nfc_target
*target
)
687 struct sk_buff
*nfcid_skb
= NULL
;
689 if (gate
== ST21NFCA_RF_READER_F_GATE
) {
690 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_F_GATE
,
691 ST21NFCA_RF_READER_F_NFCID2
, &nfcid_skb
);
695 if (nfcid_skb
->len
> NFC_SENSF_RES_MAXSIZE
) {
701 * - After the recepton of polling response for type F frame
702 * at 212 or 424 Kbit/s, NFCID2 registry parameters will be
704 * - After the reception of SEL_RES with NFCIP-1 compliant bit
705 * set for type A frame NFCID1 will be updated
707 if (nfcid_skb
->len
> 0) {
709 memcpy(target
->sensf_res
, nfcid_skb
->data
,
711 target
->sensf_res_len
= nfcid_skb
->len
;
712 /* NFC Forum Digital Protocol Table 44 */
713 if (target
->sensf_res
[0] == 0x01 &&
714 target
->sensf_res
[1] == 0xfe)
715 target
->supported_protocols
=
716 NFC_PROTO_NFC_DEP_MASK
;
718 target
->supported_protocols
=
719 NFC_PROTO_FELICA_MASK
;
721 kfree_skb(nfcid_skb
);
723 r
= nfc_hci_get_param(hdev
, ST21NFCA_RF_READER_F_GATE
,
724 ST21NFCA_RF_READER_F_NFCID1
,
729 if (nfcid_skb
->len
> NFC_NFCID1_MAXSIZE
) {
733 memcpy(target
->sensf_res
, nfcid_skb
->data
,
735 target
->sensf_res_len
= nfcid_skb
->len
;
736 target
->supported_protocols
= NFC_PROTO_NFC_DEP_MASK
;
738 target
->hci_reader_gate
= ST21NFCA_RF_READER_F_GATE
;
742 kfree_skb(nfcid_skb
);
746 #define ST21NFCA_CB_TYPE_READER_ISO15693 1
747 static void st21nfca_hci_data_exchange_cb(void *context
, struct sk_buff
*skb
,
750 struct st21nfca_hci_info
*info
= context
;
752 switch (info
->async_cb_type
) {
753 case ST21NFCA_CB_TYPE_READER_ISO15693
:
755 skb_trim(skb
, skb
->len
- 1);
756 info
->async_cb(info
->async_cb_context
, skb
, err
);
767 * <= 0: driver handled the data exchange
768 * 1: driver doesn't especially handle, please do standard processing
770 static int st21nfca_hci_im_transceive(struct nfc_hci_dev
*hdev
,
771 struct nfc_target
*target
,
773 data_exchange_cb_t cb
, void *cb_context
)
775 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
777 pr_info(DRIVER_DESC
": %s for gate=%d len=%d\n", __func__
,
778 target
->hci_reader_gate
, skb
->len
);
780 switch (target
->hci_reader_gate
) {
781 case ST21NFCA_RF_READER_F_GATE
:
782 if (target
->supported_protocols
== NFC_PROTO_NFC_DEP_MASK
)
783 return st21nfca_im_send_dep_req(hdev
, skb
);
785 *(u8
*)skb_push(skb
, 1) = 0x1a;
786 return nfc_hci_send_cmd_async(hdev
, target
->hci_reader_gate
,
787 ST21NFCA_WR_XCHG_DATA
, skb
->data
,
788 skb
->len
, cb
, cb_context
);
789 case ST21NFCA_RF_READER_14443_3_A_GATE
:
790 *(u8
*)skb_push(skb
, 1) = 0x1a; /* CTR, see spec:10.2.2.1 */
792 return nfc_hci_send_cmd_async(hdev
, target
->hci_reader_gate
,
793 ST21NFCA_WR_XCHG_DATA
, skb
->data
,
794 skb
->len
, cb
, cb_context
);
795 case ST21NFCA_RF_READER_ISO15693_GATE
:
796 info
->async_cb_type
= ST21NFCA_CB_TYPE_READER_ISO15693
;
798 info
->async_cb_context
= cb_context
;
800 *(u8
*)skb_push(skb
, 1) = 0x17;
802 return nfc_hci_send_cmd_async(hdev
, target
->hci_reader_gate
,
803 ST21NFCA_WR_XCHG_DATA
, skb
->data
,
805 st21nfca_hci_data_exchange_cb
,
813 static int st21nfca_hci_tm_send(struct nfc_hci_dev
*hdev
, struct sk_buff
*skb
)
815 return st21nfca_tm_send_dep_res(hdev
, skb
);
818 static int st21nfca_hci_check_presence(struct nfc_hci_dev
*hdev
,
819 struct nfc_target
*target
)
823 switch (target
->hci_reader_gate
) {
824 case NFC_HCI_RF_READER_A_GATE
:
825 case NFC_HCI_RF_READER_B_GATE
:
827 * PRESENCE_CHECK on those gates is available
828 * However, the answer to this command is taking 3 * fwi
829 * if the card is no present.
830 * Instead, we send an empty I-Frame with a very short
831 * configurable fwi ~604µs.
833 return nfc_hci_send_cmd(hdev
, target
->hci_reader_gate
,
834 ST21NFCA_WR_XCHG_DATA
, &fwi
, 1, NULL
);
835 case ST21NFCA_RF_READER_14443_3_A_GATE
:
836 return nfc_hci_send_cmd(hdev
, target
->hci_reader_gate
,
837 ST21NFCA_RF_READER_CMD_PRESENCE_CHECK
,
844 static void st21nfca_hci_cmd_received(struct nfc_hci_dev
*hdev
, u8 pipe
, u8 cmd
,
847 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
848 u8 gate
= hdev
->pipes
[pipe
].gate
;
850 pr_debug("cmd: %x\n", cmd
);
853 case NFC_HCI_ANY_OPEN_PIPE
:
854 if (gate
!= ST21NFCA_APDU_READER_GATE
&&
855 hdev
->pipes
[pipe
].dest_host
!= NFC_HCI_UICC_HOST_ID
)
856 info
->se_info
.count_pipes
++;
858 if (info
->se_info
.count_pipes
== info
->se_info
.expected_pipes
) {
859 del_timer_sync(&info
->se_info
.se_active_timer
);
860 info
->se_info
.se_active
= false;
861 info
->se_info
.count_pipes
= 0;
862 complete(&info
->se_info
.req_completion
);
868 static int st21nfca_admin_event_received(struct nfc_hci_dev
*hdev
, u8 event
,
871 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
873 pr_debug("admin event: %x\n", event
);
876 case ST21NFCA_EVT_HOT_PLUG
:
877 if (info
->se_info
.se_active
) {
878 if (!ST21NFCA_EVT_HOT_PLUG_IS_INHIBITED(skb
)) {
879 del_timer_sync(&info
->se_info
.se_active_timer
);
880 info
->se_info
.se_active
= false;
881 complete(&info
->se_info
.req_completion
);
883 mod_timer(&info
->se_info
.se_active_timer
,
885 msecs_to_jiffies(ST21NFCA_SE_TO_PIPES
));
890 nfc_err(&hdev
->ndev
->dev
, "Unexpected event on admin gate\n");
898 * <= 0: driver handled the event, skb consumed
899 * 1: driver does not handle the event, please do standard processing
901 static int st21nfca_hci_event_received(struct nfc_hci_dev
*hdev
, u8 pipe
,
902 u8 event
, struct sk_buff
*skb
)
904 u8 gate
= hdev
->pipes
[pipe
].gate
;
905 u8 host
= hdev
->pipes
[pipe
].dest_host
;
907 pr_debug("hci event: %d gate: %x\n", event
, gate
);
910 case NFC_HCI_ADMIN_GATE
:
911 return st21nfca_admin_event_received(hdev
, event
, skb
);
912 case ST21NFCA_RF_CARD_F_GATE
:
913 return st21nfca_dep_event_received(hdev
, event
, skb
);
914 case ST21NFCA_CONNECTIVITY_GATE
:
915 return st21nfca_connectivity_event_received(hdev
, host
,
917 case ST21NFCA_APDU_READER_GATE
:
918 return st21nfca_apdu_reader_event_received(hdev
, event
, skb
);
919 case NFC_HCI_LOOPBACK_GATE
:
920 return st21nfca_hci_loopback_event_received(hdev
, event
, skb
);
926 static struct nfc_hci_ops st21nfca_hci_ops
= {
927 .open
= st21nfca_hci_open
,
928 .close
= st21nfca_hci_close
,
929 .load_session
= st21nfca_hci_load_session
,
930 .hci_ready
= st21nfca_hci_ready
,
931 .xmit
= st21nfca_hci_xmit
,
932 .start_poll
= st21nfca_hci_start_poll
,
933 .stop_poll
= st21nfca_hci_stop_poll
,
934 .dep_link_up
= st21nfca_hci_dep_link_up
,
935 .dep_link_down
= st21nfca_hci_dep_link_down
,
936 .target_from_gate
= st21nfca_hci_target_from_gate
,
937 .complete_target_discovered
= st21nfca_hci_complete_target_discovered
,
938 .im_transceive
= st21nfca_hci_im_transceive
,
939 .tm_send
= st21nfca_hci_tm_send
,
940 .check_presence
= st21nfca_hci_check_presence
,
941 .event_received
= st21nfca_hci_event_received
,
942 .cmd_received
= st21nfca_hci_cmd_received
,
943 .discover_se
= st21nfca_hci_discover_se
,
944 .enable_se
= st21nfca_hci_enable_se
,
945 .disable_se
= st21nfca_hci_disable_se
,
946 .se_io
= st21nfca_hci_se_io
,
949 int st21nfca_hci_probe(void *phy_id
, struct nfc_phy_ops
*phy_ops
,
950 char *llc_name
, int phy_headroom
, int phy_tailroom
,
951 int phy_payload
, struct nfc_hci_dev
**hdev
,
952 struct st21nfca_se_status
*se_status
)
954 struct st21nfca_hci_info
*info
;
958 struct nfc_hci_init_data init_data
;
959 unsigned long quirks
= 0;
961 info
= kzalloc(sizeof(struct st21nfca_hci_info
), GFP_KERNEL
);
965 info
->phy_ops
= phy_ops
;
966 info
->phy_id
= phy_id
;
967 info
->state
= ST21NFCA_ST_COLD
;
968 mutex_init(&info
->info_lock
);
970 init_data
.gate_count
= ARRAY_SIZE(st21nfca_gates
);
972 memcpy(init_data
.gates
, st21nfca_gates
, sizeof(st21nfca_gates
));
975 * Session id must include the driver name + i2c bus addr
976 * persistent info to discriminate 2 identical chips
978 dev_num
= find_first_zero_bit(dev_mask
, ST21NFCA_NUM_DEVICES
);
979 if (dev_num
>= ST21NFCA_NUM_DEVICES
) {
984 set_bit(dev_num
, dev_mask
);
986 scnprintf(init_data
.session_id
, sizeof(init_data
.session_id
), "%s%2x",
989 protocols
= NFC_PROTO_JEWEL_MASK
|
990 NFC_PROTO_MIFARE_MASK
|
991 NFC_PROTO_FELICA_MASK
|
992 NFC_PROTO_ISO14443_MASK
|
993 NFC_PROTO_ISO14443_B_MASK
|
994 NFC_PROTO_ISO15693_MASK
|
995 NFC_PROTO_NFC_DEP_MASK
;
997 set_bit(NFC_HCI_QUIRK_SHORT_CLEAR
, &quirks
);
1000 nfc_hci_allocate_device(&st21nfca_hci_ops
, &init_data
, quirks
,
1001 protocols
, llc_name
,
1002 phy_headroom
+ ST21NFCA_CMDS_HEADROOM
,
1003 phy_tailroom
, phy_payload
);
1006 pr_err("Cannot allocate nfc hdev.\n");
1008 goto err_alloc_hdev
;
1011 info
->se_status
= se_status
;
1013 nfc_hci_set_clientdata(info
->hdev
, info
);
1015 r
= nfc_hci_register_device(info
->hdev
);
1020 st21nfca_dep_init(info
->hdev
);
1021 st21nfca_se_init(info
->hdev
);
1022 st21nfca_vendor_cmds_init(info
->hdev
);
1027 nfc_hci_free_device(info
->hdev
);
1034 EXPORT_SYMBOL(st21nfca_hci_probe
);
1036 void st21nfca_hci_remove(struct nfc_hci_dev
*hdev
)
1038 struct st21nfca_hci_info
*info
= nfc_hci_get_clientdata(hdev
);
1040 st21nfca_dep_deinit(hdev
);
1041 st21nfca_se_deinit(hdev
);
1042 nfc_hci_unregister_device(hdev
);
1043 nfc_hci_free_device(hdev
);
1046 EXPORT_SYMBOL(st21nfca_hci_remove
);
1048 MODULE_LICENSE("GPL");
1049 MODULE_DESCRIPTION(DRIVER_DESC
);