]>
Commit | Line | Data |
---|---|---|
cfad1ba8 EL |
1 | /* |
2 | * HCI based Driver for Inside Secure microread NFC Chip | |
3 | * | |
4 | * Copyright (C) 2013 Intel Corporation. All rights reserved. | |
5 | * | |
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. | |
9 | * | |
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. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the | |
17 | * Free Software Foundation, Inc., | |
18 | * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
19 | */ | |
20 | ||
21 | #include <linux/module.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/slab.h> | |
24 | #include <linux/crc-ccitt.h> | |
25 | ||
26 | #include <linux/nfc.h> | |
27 | #include <net/nfc/nfc.h> | |
28 | #include <net/nfc/hci.h> | |
29 | #include <net/nfc/llc.h> | |
30 | ||
31 | #include "microread.h" | |
32 | ||
33 | /* Proprietary gates, events, commands and registers */ | |
34 | /* Admin */ | |
35 | #define MICROREAD_GATE_ID_ADM NFC_HCI_ADMIN_GATE | |
36 | #define MICROREAD_GATE_ID_MGT 0x01 | |
37 | #define MICROREAD_GATE_ID_OS 0x02 | |
38 | #define MICROREAD_GATE_ID_TESTRF 0x03 | |
39 | #define MICROREAD_GATE_ID_LOOPBACK NFC_HCI_LOOPBACK_GATE | |
40 | #define MICROREAD_GATE_ID_IDT NFC_HCI_ID_MGMT_GATE | |
41 | #define MICROREAD_GATE_ID_LMS NFC_HCI_LINK_MGMT_GATE | |
42 | ||
43 | /* Reader */ | |
44 | #define MICROREAD_GATE_ID_MREAD_GEN 0x10 | |
45 | #define MICROREAD_GATE_ID_MREAD_ISO_B NFC_HCI_RF_READER_B_GATE | |
46 | #define MICROREAD_GATE_ID_MREAD_NFC_T1 0x12 | |
47 | #define MICROREAD_GATE_ID_MREAD_ISO_A NFC_HCI_RF_READER_A_GATE | |
48 | #define MICROREAD_GATE_ID_MREAD_NFC_T3 0x14 | |
49 | #define MICROREAD_GATE_ID_MREAD_ISO_15_3 0x15 | |
50 | #define MICROREAD_GATE_ID_MREAD_ISO_15_2 0x16 | |
51 | #define MICROREAD_GATE_ID_MREAD_ISO_B_3 0x17 | |
52 | #define MICROREAD_GATE_ID_MREAD_BPRIME 0x18 | |
53 | #define MICROREAD_GATE_ID_MREAD_ISO_A_3 0x19 | |
54 | ||
55 | /* Card */ | |
56 | #define MICROREAD_GATE_ID_MCARD_GEN 0x20 | |
57 | #define MICROREAD_GATE_ID_MCARD_ISO_B 0x21 | |
58 | #define MICROREAD_GATE_ID_MCARD_BPRIME 0x22 | |
59 | #define MICROREAD_GATE_ID_MCARD_ISO_A 0x23 | |
60 | #define MICROREAD_GATE_ID_MCARD_NFC_T3 0x24 | |
61 | #define MICROREAD_GATE_ID_MCARD_ISO_15_3 0x25 | |
62 | #define MICROREAD_GATE_ID_MCARD_ISO_15_2 0x26 | |
63 | #define MICROREAD_GATE_ID_MCARD_ISO_B_2 0x27 | |
64 | #define MICROREAD_GATE_ID_MCARD_ISO_CUSTOM 0x28 | |
65 | #define MICROREAD_GATE_ID_SECURE_ELEMENT 0x2F | |
66 | ||
67 | /* P2P */ | |
68 | #define MICROREAD_GATE_ID_P2P_GEN 0x30 | |
69 | #define MICROREAD_GATE_ID_P2P_TARGET 0x31 | |
70 | #define MICROREAD_PAR_P2P_TARGET_MODE 0x01 | |
71 | #define MICROREAD_PAR_P2P_TARGET_GT 0x04 | |
72 | #define MICROREAD_GATE_ID_P2P_INITIATOR 0x32 | |
73 | #define MICROREAD_PAR_P2P_INITIATOR_GI 0x01 | |
74 | #define MICROREAD_PAR_P2P_INITIATOR_GT 0x03 | |
75 | ||
76 | /* Those pipes are created/opened by default in the chip */ | |
77 | #define MICROREAD_PIPE_ID_LMS 0x00 | |
78 | #define MICROREAD_PIPE_ID_ADMIN 0x01 | |
79 | #define MICROREAD_PIPE_ID_MGT 0x02 | |
80 | #define MICROREAD_PIPE_ID_OS 0x03 | |
81 | #define MICROREAD_PIPE_ID_HDS_LOOPBACK 0x04 | |
82 | #define MICROREAD_PIPE_ID_HDS_IDT 0x05 | |
83 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B 0x08 | |
84 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_BPRIME 0x09 | |
85 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_A 0x0A | |
86 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_3 0x0B | |
87 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_2 0x0C | |
88 | #define MICROREAD_PIPE_ID_HDS_MCARD_NFC_T3 0x0D | |
89 | #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B_2 0x0E | |
90 | #define MICROREAD_PIPE_ID_HDS_MCARD_CUSTOM 0x0F | |
91 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B 0x10 | |
92 | #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1 0x11 | |
93 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A 0x12 | |
94 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_3 0x13 | |
95 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_2 0x14 | |
96 | #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3 0x15 | |
97 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B_3 0x16 | |
98 | #define MICROREAD_PIPE_ID_HDS_MREAD_BPRIME 0x17 | |
99 | #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3 0x18 | |
100 | #define MICROREAD_PIPE_ID_HDS_MREAD_GEN 0x1B | |
101 | #define MICROREAD_PIPE_ID_HDS_STACKED_ELEMENT 0x1C | |
102 | #define MICROREAD_PIPE_ID_HDS_INSTANCES 0x1D | |
103 | #define MICROREAD_PIPE_ID_HDS_TESTRF 0x1E | |
104 | #define MICROREAD_PIPE_ID_HDS_P2P_TARGET 0x1F | |
105 | #define MICROREAD_PIPE_ID_HDS_P2P_INITIATOR 0x20 | |
106 | ||
107 | /* Events */ | |
108 | #define MICROREAD_EVT_MREAD_DISCOVERY_OCCURED NFC_HCI_EVT_TARGET_DISCOVERED | |
109 | #define MICROREAD_EVT_MREAD_CARD_FOUND 0x3D | |
110 | #define MICROREAD_EMCF_A_ATQA 0 | |
111 | #define MICROREAD_EMCF_A_SAK 2 | |
112 | #define MICROREAD_EMCF_A_LEN 3 | |
113 | #define MICROREAD_EMCF_A_UID 4 | |
114 | #define MICROREAD_EMCF_A3_ATQA 0 | |
115 | #define MICROREAD_EMCF_A3_SAK 2 | |
116 | #define MICROREAD_EMCF_A3_LEN 3 | |
117 | #define MICROREAD_EMCF_A3_UID 4 | |
118 | #define MICROREAD_EMCF_B_UID 0 | |
119 | #define MICROREAD_EMCF_T1_ATQA 0 | |
120 | #define MICROREAD_EMCF_T1_UID 4 | |
121 | #define MICROREAD_EMCF_T3_UID 0 | |
122 | #define MICROREAD_EVT_MREAD_DISCOVERY_START NFC_HCI_EVT_READER_REQUESTED | |
123 | #define MICROREAD_EVT_MREAD_DISCOVERY_START_SOME 0x3E | |
124 | #define MICROREAD_EVT_MREAD_DISCOVERY_STOP NFC_HCI_EVT_END_OPERATION | |
125 | #define MICROREAD_EVT_MREAD_SIM_REQUESTS 0x3F | |
126 | #define MICROREAD_EVT_MCARD_EXCHANGE NFC_HCI_EVT_TARGET_DISCOVERED | |
127 | #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF 0x20 | |
128 | #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF 0x21 | |
129 | #define MICROREAD_EVT_MCARD_FIELD_ON 0x11 | |
130 | #define MICROREAD_EVT_P2P_TARGET_ACTIVATED 0x13 | |
131 | #define MICROREAD_EVT_P2P_TARGET_DEACTIVATED 0x12 | |
132 | #define MICROREAD_EVT_MCARD_FIELD_OFF 0x14 | |
133 | ||
134 | /* Commands */ | |
135 | #define MICROREAD_CMD_MREAD_EXCHANGE 0x10 | |
136 | #define MICROREAD_CMD_MREAD_SUBSCRIBE 0x3F | |
137 | ||
138 | /* Hosts IDs */ | |
139 | #define MICROREAD_ELT_ID_HDS NFC_HCI_TERMINAL_HOST_ID | |
140 | #define MICROREAD_ELT_ID_SIM NFC_HCI_UICC_HOST_ID | |
141 | #define MICROREAD_ELT_ID_SE1 0x03 | |
142 | #define MICROREAD_ELT_ID_SE2 0x04 | |
143 | #define MICROREAD_ELT_ID_SE3 0x05 | |
144 | ||
145 | static struct nfc_hci_gate microread_gates[] = { | |
146 | {MICROREAD_GATE_ID_ADM, MICROREAD_PIPE_ID_ADMIN}, | |
147 | {MICROREAD_GATE_ID_LOOPBACK, MICROREAD_PIPE_ID_HDS_LOOPBACK}, | |
148 | {MICROREAD_GATE_ID_IDT, MICROREAD_PIPE_ID_HDS_IDT}, | |
149 | {MICROREAD_GATE_ID_LMS, MICROREAD_PIPE_ID_LMS}, | |
150 | {MICROREAD_GATE_ID_MREAD_ISO_B, MICROREAD_PIPE_ID_HDS_MREAD_ISO_B}, | |
151 | {MICROREAD_GATE_ID_MREAD_ISO_A, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A}, | |
152 | {MICROREAD_GATE_ID_MREAD_ISO_A_3, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3}, | |
153 | {MICROREAD_GATE_ID_MGT, MICROREAD_PIPE_ID_MGT}, | |
154 | {MICROREAD_GATE_ID_OS, MICROREAD_PIPE_ID_OS}, | |
155 | {MICROREAD_GATE_ID_MREAD_NFC_T1, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1}, | |
156 | {MICROREAD_GATE_ID_MREAD_NFC_T3, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3}, | |
157 | {MICROREAD_GATE_ID_P2P_TARGET, MICROREAD_PIPE_ID_HDS_P2P_TARGET}, | |
158 | {MICROREAD_GATE_ID_P2P_INITIATOR, MICROREAD_PIPE_ID_HDS_P2P_INITIATOR} | |
159 | }; | |
160 | ||
161 | /* Largest headroom needed for outgoing custom commands */ | |
162 | #define MICROREAD_CMDS_HEADROOM 2 | |
163 | #define MICROREAD_CMD_TAILROOM 2 | |
164 | ||
165 | struct microread_info { | |
166 | struct nfc_phy_ops *phy_ops; | |
167 | void *phy_id; | |
168 | ||
169 | struct nfc_hci_dev *hdev; | |
170 | ||
171 | int async_cb_type; | |
172 | data_exchange_cb_t async_cb; | |
173 | void *async_cb_context; | |
174 | }; | |
175 | ||
176 | static int microread_open(struct nfc_hci_dev *hdev) | |
177 | { | |
178 | struct microread_info *info = nfc_hci_get_clientdata(hdev); | |
179 | ||
180 | return info->phy_ops->enable(info->phy_id); | |
181 | } | |
182 | ||
183 | static void microread_close(struct nfc_hci_dev *hdev) | |
184 | { | |
185 | struct microread_info *info = nfc_hci_get_clientdata(hdev); | |
186 | ||
187 | info->phy_ops->disable(info->phy_id); | |
188 | } | |
189 | ||
190 | static int microread_hci_ready(struct nfc_hci_dev *hdev) | |
191 | { | |
192 | int r; | |
193 | u8 param[4]; | |
194 | ||
195 | param[0] = 0x03; | |
196 | r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A, | |
197 | MICROREAD_CMD_MREAD_SUBSCRIBE, param, 1, NULL); | |
198 | if (r) | |
199 | return r; | |
200 | ||
201 | r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A_3, | |
202 | MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL); | |
203 | if (r) | |
204 | return r; | |
205 | ||
206 | param[0] = 0x00; | |
207 | param[1] = 0x03; | |
208 | param[2] = 0x00; | |
209 | r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_B, | |
210 | MICROREAD_CMD_MREAD_SUBSCRIBE, param, 3, NULL); | |
211 | if (r) | |
212 | return r; | |
213 | ||
214 | r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T1, | |
215 | MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL); | |
216 | if (r) | |
217 | return r; | |
218 | ||
219 | param[0] = 0xFF; | |
220 | param[1] = 0xFF; | |
221 | param[2] = 0x00; | |
222 | param[3] = 0x00; | |
223 | r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T3, | |
224 | MICROREAD_CMD_MREAD_SUBSCRIBE, param, 4, NULL); | |
225 | ||
226 | return r; | |
227 | } | |
228 | ||
229 | static int microread_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb) | |
230 | { | |
231 | struct microread_info *info = nfc_hci_get_clientdata(hdev); | |
232 | ||
233 | return info->phy_ops->write(info->phy_id, skb); | |
234 | } | |
235 | ||
236 | static int microread_start_poll(struct nfc_hci_dev *hdev, | |
237 | u32 im_protocols, u32 tm_protocols) | |
238 | { | |
239 | int r; | |
240 | ||
241 | u8 param[2]; | |
242 | u8 mode; | |
243 | ||
244 | param[0] = 0x00; | |
245 | param[1] = 0x00; | |
246 | ||
247 | if (im_protocols & NFC_PROTO_ISO14443_MASK) | |
248 | param[0] |= (1 << 2); | |
249 | ||
250 | if (im_protocols & NFC_PROTO_ISO14443_B_MASK) | |
251 | param[0] |= 1; | |
252 | ||
253 | if (im_protocols & NFC_PROTO_MIFARE_MASK) | |
254 | param[1] |= 1; | |
255 | ||
256 | if (im_protocols & NFC_PROTO_JEWEL_MASK) | |
257 | param[0] |= (1 << 1); | |
258 | ||
259 | if (im_protocols & NFC_PROTO_FELICA_MASK) | |
260 | param[0] |= (1 << 5); | |
261 | ||
262 | if (im_protocols & NFC_PROTO_NFC_DEP_MASK) | |
263 | param[1] |= (1 << 1); | |
264 | ||
265 | if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) { | |
266 | hdev->gb = nfc_get_local_general_bytes(hdev->ndev, | |
267 | &hdev->gb_len); | |
268 | if (hdev->gb == NULL || hdev->gb_len == 0) { | |
269 | im_protocols &= ~NFC_PROTO_NFC_DEP_MASK; | |
270 | tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK; | |
271 | } | |
272 | } | |
273 | ||
274 | r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A, | |
275 | MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0); | |
276 | if (r) | |
277 | return r; | |
278 | ||
279 | mode = 0xff; | |
280 | r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET, | |
281 | MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1); | |
282 | if (r) | |
283 | return r; | |
284 | ||
285 | if (im_protocols & NFC_PROTO_NFC_DEP_MASK) { | |
286 | r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_INITIATOR, | |
287 | MICROREAD_PAR_P2P_INITIATOR_GI, | |
288 | hdev->gb, hdev->gb_len); | |
289 | if (r) | |
290 | return r; | |
291 | } | |
292 | ||
293 | if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) { | |
294 | r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET, | |
295 | MICROREAD_PAR_P2P_TARGET_GT, | |
296 | hdev->gb, hdev->gb_len); | |
297 | if (r) | |
298 | return r; | |
299 | ||
300 | mode = 0x02; | |
301 | r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET, | |
302 | MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1); | |
303 | if (r) | |
304 | return r; | |
305 | } | |
306 | ||
307 | return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A, | |
308 | MICROREAD_EVT_MREAD_DISCOVERY_START_SOME, | |
309 | param, 2); | |
310 | } | |
311 | ||
312 | static int microread_dep_link_up(struct nfc_hci_dev *hdev, | |
313 | struct nfc_target *target, u8 comm_mode, | |
314 | u8 *gb, size_t gb_len) | |
315 | { | |
316 | struct sk_buff *rgb_skb = NULL; | |
317 | int r; | |
318 | ||
319 | r = nfc_hci_get_param(hdev, target->hci_reader_gate, | |
320 | MICROREAD_PAR_P2P_INITIATOR_GT, &rgb_skb); | |
321 | if (r < 0) | |
322 | return r; | |
323 | ||
324 | if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) { | |
325 | r = -EPROTO; | |
326 | goto exit; | |
327 | } | |
328 | ||
329 | r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data, | |
330 | rgb_skb->len); | |
331 | if (r == 0) | |
332 | r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode, | |
333 | NFC_RF_INITIATOR); | |
334 | exit: | |
335 | kfree_skb(rgb_skb); | |
336 | ||
337 | return r; | |
338 | } | |
339 | ||
340 | static int microread_dep_link_down(struct nfc_hci_dev *hdev) | |
341 | { | |
342 | return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_INITIATOR, | |
343 | MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0); | |
344 | } | |
345 | ||
346 | static int microread_target_from_gate(struct nfc_hci_dev *hdev, u8 gate, | |
347 | struct nfc_target *target) | |
348 | { | |
349 | switch (gate) { | |
350 | case MICROREAD_GATE_ID_P2P_INITIATOR: | |
351 | target->supported_protocols = NFC_PROTO_NFC_DEP_MASK; | |
352 | break; | |
353 | default: | |
354 | return -EPROTO; | |
355 | } | |
356 | ||
357 | return 0; | |
358 | } | |
359 | ||
360 | static int microread_complete_target_discovered(struct nfc_hci_dev *hdev, | |
361 | u8 gate, | |
362 | struct nfc_target *target) | |
363 | { | |
364 | return 0; | |
365 | } | |
366 | ||
367 | #define MICROREAD_CB_TYPE_READER_ALL 1 | |
368 | ||
369 | static void microread_im_transceive_cb(void *context, struct sk_buff *skb, | |
370 | int err) | |
371 | { | |
372 | struct microread_info *info = context; | |
373 | ||
374 | switch (info->async_cb_type) { | |
375 | case MICROREAD_CB_TYPE_READER_ALL: | |
376 | if (err == 0) { | |
377 | if (skb->len == 0) { | |
378 | err = -EPROTO; | |
379 | kfree_skb(skb); | |
380 | info->async_cb(info->async_cb_context, NULL, | |
381 | -EPROTO); | |
382 | return; | |
383 | } | |
384 | ||
385 | if (skb->data[skb->len - 1] != 0) { | |
386 | err = nfc_hci_result_to_errno( | |
387 | skb->data[skb->len - 1]); | |
388 | kfree_skb(skb); | |
389 | info->async_cb(info->async_cb_context, NULL, | |
390 | err); | |
391 | return; | |
392 | } | |
393 | ||
394 | skb_trim(skb, skb->len - 1); /* RF Error ind. */ | |
395 | } | |
396 | info->async_cb(info->async_cb_context, skb, err); | |
397 | break; | |
398 | default: | |
399 | if (err == 0) | |
400 | kfree_skb(skb); | |
401 | break; | |
402 | } | |
403 | } | |
404 | ||
405 | /* | |
406 | * Returns: | |
407 | * <= 0: driver handled the data exchange | |
408 | * 1: driver doesn't especially handle, please do standard processing | |
409 | */ | |
410 | static int microread_im_transceive(struct nfc_hci_dev *hdev, | |
411 | struct nfc_target *target, | |
412 | struct sk_buff *skb, data_exchange_cb_t cb, | |
413 | void *cb_context) | |
414 | { | |
415 | struct microread_info *info = nfc_hci_get_clientdata(hdev); | |
416 | u8 control_bits; | |
417 | u16 crc; | |
418 | ||
419 | pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate); | |
420 | ||
421 | if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) { | |
422 | *skb_push(skb, 1) = 0; | |
423 | ||
424 | return nfc_hci_send_event(hdev, target->hci_reader_gate, | |
425 | MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF, | |
426 | skb->data, skb->len); | |
427 | } | |
428 | ||
429 | switch (target->hci_reader_gate) { | |
430 | case MICROREAD_GATE_ID_MREAD_ISO_A: | |
431 | control_bits = 0xCB; | |
432 | break; | |
433 | case MICROREAD_GATE_ID_MREAD_ISO_A_3: | |
434 | control_bits = 0xCB; | |
435 | break; | |
436 | case MICROREAD_GATE_ID_MREAD_ISO_B: | |
437 | control_bits = 0xCB; | |
438 | break; | |
439 | case MICROREAD_GATE_ID_MREAD_NFC_T1: | |
440 | control_bits = 0x1B; | |
441 | ||
442 | crc = crc_ccitt(0xffff, skb->data, skb->len); | |
443 | crc = ~crc; | |
444 | *skb_put(skb, 1) = crc & 0xff; | |
445 | *skb_put(skb, 1) = crc >> 8; | |
446 | break; | |
447 | case MICROREAD_GATE_ID_MREAD_NFC_T3: | |
448 | control_bits = 0xDB; | |
449 | break; | |
450 | default: | |
451 | pr_info("Abort im_transceive to invalid gate 0x%x\n", | |
452 | target->hci_reader_gate); | |
453 | return 1; | |
454 | } | |
455 | ||
456 | *skb_push(skb, 1) = control_bits; | |
457 | ||
458 | info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL; | |
459 | info->async_cb = cb; | |
460 | info->async_cb_context = cb_context; | |
461 | ||
462 | return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate, | |
463 | MICROREAD_CMD_MREAD_EXCHANGE, | |
464 | skb->data, skb->len, | |
465 | microread_im_transceive_cb, info); | |
466 | } | |
467 | ||
468 | static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb) | |
469 | { | |
470 | int r; | |
471 | ||
472 | r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET, | |
473 | MICROREAD_EVT_MCARD_EXCHANGE, | |
474 | skb->data, skb->len); | |
475 | ||
476 | kfree_skb(skb); | |
477 | ||
478 | return r; | |
479 | } | |
480 | ||
481 | static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate, | |
482 | struct sk_buff *skb) | |
483 | { | |
484 | struct nfc_target *targets; | |
485 | int r = 0; | |
486 | ||
487 | pr_info("target discovered to gate 0x%x\n", gate); | |
488 | ||
489 | targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL); | |
490 | if (targets == NULL) { | |
491 | r = -ENOMEM; | |
492 | goto exit; | |
493 | } | |
494 | ||
495 | targets->hci_reader_gate = gate; | |
496 | ||
497 | switch (gate) { | |
498 | case MICROREAD_GATE_ID_MREAD_ISO_A: | |
499 | targets->supported_protocols = | |
500 | nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]); | |
501 | targets->sens_res = | |
502 | be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]); | |
503 | targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK]; | |
504 | memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID], | |
505 | skb->data[MICROREAD_EMCF_A_LEN]); | |
506 | targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN]; | |
507 | break; | |
508 | case MICROREAD_GATE_ID_MREAD_ISO_A_3: | |
509 | targets->supported_protocols = | |
510 | nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]); | |
511 | targets->sens_res = | |
512 | be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]); | |
513 | targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK]; | |
514 | memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID], | |
515 | skb->data[MICROREAD_EMCF_A3_LEN]); | |
516 | targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN]; | |
517 | break; | |
518 | case MICROREAD_GATE_ID_MREAD_ISO_B: | |
519 | targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK; | |
520 | memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4); | |
521 | targets->nfcid1_len = 4; | |
522 | break; | |
523 | case MICROREAD_GATE_ID_MREAD_NFC_T1: | |
524 | targets->supported_protocols = NFC_PROTO_JEWEL_MASK; | |
525 | targets->sens_res = | |
526 | le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]); | |
527 | memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4); | |
528 | targets->nfcid1_len = 4; | |
529 | break; | |
530 | case MICROREAD_GATE_ID_MREAD_NFC_T3: | |
531 | targets->supported_protocols = NFC_PROTO_FELICA_MASK; | |
532 | memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8); | |
533 | targets->nfcid1_len = 8; | |
534 | break; | |
535 | default: | |
536 | pr_info("discard target discovered to gate 0x%x\n", gate); | |
537 | goto exit_free; | |
538 | } | |
539 | ||
540 | r = nfc_targets_found(hdev->ndev, targets, 1); | |
541 | ||
542 | exit_free: | |
543 | kfree(targets); | |
544 | ||
545 | exit: | |
546 | kfree_skb(skb); | |
547 | ||
548 | if (r) | |
549 | pr_err("Failed to handle discovered target err=%d", r); | |
550 | } | |
551 | ||
552 | static int microread_event_received(struct nfc_hci_dev *hdev, u8 gate, | |
553 | u8 event, struct sk_buff *skb) | |
554 | { | |
555 | int r; | |
556 | u8 mode; | |
557 | ||
558 | pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate); | |
559 | ||
560 | switch (event) { | |
561 | case MICROREAD_EVT_MREAD_CARD_FOUND: | |
562 | microread_target_discovered(hdev, gate, skb); | |
563 | return 0; | |
564 | ||
565 | case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF: | |
566 | if (skb->len < 1) { | |
567 | kfree_skb(skb); | |
568 | return -EPROTO; | |
569 | } | |
570 | ||
571 | if (skb->data[skb->len - 1]) { | |
572 | kfree_skb(skb); | |
573 | return -EIO; | |
574 | } | |
575 | ||
576 | skb_trim(skb, skb->len - 1); | |
577 | ||
578 | r = nfc_tm_data_received(hdev->ndev, skb); | |
579 | break; | |
580 | ||
581 | case MICROREAD_EVT_MCARD_FIELD_ON: | |
582 | case MICROREAD_EVT_MCARD_FIELD_OFF: | |
583 | kfree_skb(skb); | |
584 | return 0; | |
585 | ||
586 | case MICROREAD_EVT_P2P_TARGET_ACTIVATED: | |
587 | r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK, | |
588 | NFC_COMM_PASSIVE, skb->data, | |
589 | skb->len); | |
590 | ||
591 | kfree_skb(skb); | |
592 | break; | |
593 | ||
594 | case MICROREAD_EVT_MCARD_EXCHANGE: | |
595 | if (skb->len < 1) { | |
596 | kfree_skb(skb); | |
597 | return -EPROTO; | |
598 | } | |
599 | ||
600 | if (skb->data[skb->len-1]) { | |
601 | kfree_skb(skb); | |
602 | return -EIO; | |
603 | } | |
604 | ||
605 | skb_trim(skb, skb->len - 1); | |
606 | ||
607 | r = nfc_tm_data_received(hdev->ndev, skb); | |
608 | break; | |
609 | ||
610 | case MICROREAD_EVT_P2P_TARGET_DEACTIVATED: | |
611 | kfree_skb(skb); | |
612 | ||
613 | mode = 0xff; | |
614 | r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET, | |
615 | MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1); | |
616 | if (r) | |
617 | break; | |
618 | ||
619 | r = nfc_hci_send_event(hdev, gate, | |
620 | MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, | |
621 | 0); | |
622 | break; | |
623 | ||
624 | default: | |
625 | return 1; | |
626 | } | |
627 | ||
628 | return r; | |
629 | } | |
630 | ||
631 | static struct nfc_hci_ops microread_hci_ops = { | |
632 | .open = microread_open, | |
633 | .close = microread_close, | |
634 | .hci_ready = microread_hci_ready, | |
635 | .xmit = microread_xmit, | |
636 | .start_poll = microread_start_poll, | |
637 | .dep_link_up = microread_dep_link_up, | |
638 | .dep_link_down = microread_dep_link_down, | |
639 | .target_from_gate = microread_target_from_gate, | |
640 | .complete_target_discovered = microread_complete_target_discovered, | |
641 | .im_transceive = microread_im_transceive, | |
642 | .tm_send = microread_tm_send, | |
643 | .check_presence = NULL, | |
644 | .event_received = microread_event_received, | |
645 | }; | |
646 | ||
647 | int microread_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name, | |
648 | int phy_headroom, int phy_tailroom, int phy_payload, | |
649 | struct nfc_hci_dev **hdev) | |
650 | { | |
651 | struct microread_info *info; | |
652 | unsigned long quirks = 0; | |
0b456c41 | 653 | u32 protocols; |
cfad1ba8 EL |
654 | struct nfc_hci_init_data init_data; |
655 | int r; | |
656 | ||
657 | info = kzalloc(sizeof(struct microread_info), GFP_KERNEL); | |
658 | if (!info) { | |
659 | pr_err("Cannot allocate memory for microread_info.\n"); | |
660 | r = -ENOMEM; | |
661 | goto err_info_alloc; | |
662 | } | |
663 | ||
664 | info->phy_ops = phy_ops; | |
665 | info->phy_id = phy_id; | |
666 | ||
667 | init_data.gate_count = ARRAY_SIZE(microread_gates); | |
668 | memcpy(init_data.gates, microread_gates, sizeof(microread_gates)); | |
669 | ||
670 | strcpy(init_data.session_id, "MICROREA"); | |
671 | ||
672 | set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks); | |
673 | ||
674 | protocols = NFC_PROTO_JEWEL_MASK | | |
675 | NFC_PROTO_MIFARE_MASK | | |
676 | NFC_PROTO_FELICA_MASK | | |
677 | NFC_PROTO_ISO14443_MASK | | |
678 | NFC_PROTO_ISO14443_B_MASK | | |
679 | NFC_PROTO_NFC_DEP_MASK; | |
680 | ||
cfad1ba8 | 681 | info->hdev = nfc_hci_allocate_device(µread_hci_ops, &init_data, |
0b456c41 | 682 | quirks, protocols, llc_name, |
cfad1ba8 EL |
683 | phy_headroom + |
684 | MICROREAD_CMDS_HEADROOM, | |
685 | phy_tailroom + | |
686 | MICROREAD_CMD_TAILROOM, | |
687 | phy_payload); | |
688 | if (!info->hdev) { | |
689 | pr_err("Cannot allocate nfc hdev.\n"); | |
690 | r = -ENOMEM; | |
691 | goto err_alloc_hdev; | |
692 | } | |
693 | ||
694 | nfc_hci_set_clientdata(info->hdev, info); | |
695 | ||
696 | r = nfc_hci_register_device(info->hdev); | |
697 | if (r) | |
698 | goto err_regdev; | |
699 | ||
700 | *hdev = info->hdev; | |
701 | ||
702 | return 0; | |
703 | ||
704 | err_regdev: | |
705 | nfc_hci_free_device(info->hdev); | |
706 | ||
707 | err_alloc_hdev: | |
708 | kfree(info); | |
709 | ||
710 | err_info_alloc: | |
711 | return r; | |
712 | } | |
713 | EXPORT_SYMBOL(microread_probe); | |
714 | ||
715 | void microread_remove(struct nfc_hci_dev *hdev) | |
716 | { | |
717 | struct microread_info *info = nfc_hci_get_clientdata(hdev); | |
718 | ||
719 | nfc_hci_unregister_device(hdev); | |
720 | nfc_hci_free_device(hdev); | |
721 | kfree(info); | |
722 | } | |
723 | EXPORT_SYMBOL(microread_remove); | |
724 | ||
725 | MODULE_LICENSE("GPL"); | |
726 | MODULE_DESCRIPTION(DRIVER_DESC); |