projects/linux·blob master · refs

748 lines · 19.6 KiB

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