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 
133 static 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 
153 struct 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 
164 static 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 
171 static 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 
178 static 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 
217 static 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 
224 static 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 		hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
255 						       &hdev->gb_len);
256 		if (hdev->gb == NULL || 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 
300 static 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);
322 exit:
323 	kfree_skb(rgb_skb);
324 
325 	return r;
326 }
327 
328 static 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 
334 static 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 
348 static 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 
357 static 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  */
397 static 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 
455 static 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 
468 static 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(sizeof(struct nfc_target), GFP_KERNEL);
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 		targets->supported_protocols =
487 		      nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]);
488 		targets->sens_res =
489 			 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]);
490 		targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK];
491 		targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN];
492 		if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
493 			r = -EINVAL;
494 			goto exit_free;
495 		}
496 		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID],
497 		       targets->nfcid1_len);
498 		break;
499 	case MICROREAD_GATE_ID_MREAD_ISO_A_3:
500 		targets->supported_protocols =
501 		      nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]);
502 		targets->sens_res =
503 			 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]);
504 		targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK];
505 		targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN];
506 		if (targets->nfcid1_len > sizeof(targets->nfcid1)) {
507 			r = -EINVAL;
508 			goto exit_free;
509 		}
510 		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID],
511 		       targets->nfcid1_len);
512 		break;
513 	case MICROREAD_GATE_ID_MREAD_ISO_B:
514 		targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
515 		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4);
516 		targets->nfcid1_len = 4;
517 		break;
518 	case MICROREAD_GATE_ID_MREAD_NFC_T1:
519 		targets->supported_protocols = NFC_PROTO_JEWEL_MASK;
520 		targets->sens_res =
521 			le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]);
522 		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4);
523 		targets->nfcid1_len = 4;
524 		break;
525 	case MICROREAD_GATE_ID_MREAD_NFC_T3:
526 		targets->supported_protocols = NFC_PROTO_FELICA_MASK;
527 		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8);
528 		targets->nfcid1_len = 8;
529 		break;
530 	default:
531 		pr_info("discard target discovered to gate 0x%x\n", gate);
532 		goto exit_free;
533 	}
534 
535 	r = nfc_targets_found(hdev->ndev, targets, 1);
536 
537 exit_free:
538 	kfree(targets);
539 
540 exit:
541 	kfree_skb(skb);
542 
543 	if (r)
544 		pr_err("Failed to handle discovered target err=%d\n", r);
545 }
546 
547 static int microread_event_received(struct nfc_hci_dev *hdev, u8 pipe,
548 				     u8 event, struct sk_buff *skb)
549 {
550 	int r;
551 	u8 gate = hdev->pipes[pipe].gate;
552 	u8 mode;
553 
554 	pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate);
555 
556 	switch (event) {
557 	case MICROREAD_EVT_MREAD_CARD_FOUND:
558 		microread_target_discovered(hdev, gate, skb);
559 		return 0;
560 
561 	case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF:
562 		if (skb->len < 1) {
563 			kfree_skb(skb);
564 			return -EPROTO;
565 		}
566 
567 		if (skb->data[skb->len - 1]) {
568 			kfree_skb(skb);
569 			return -EIO;
570 		}
571 
572 		skb_trim(skb, skb->len - 1);
573 
574 		r = nfc_tm_data_received(hdev->ndev, skb);
575 		break;
576 
577 	case MICROREAD_EVT_MCARD_FIELD_ON:
578 	case MICROREAD_EVT_MCARD_FIELD_OFF:
579 		kfree_skb(skb);
580 		return 0;
581 
582 	case MICROREAD_EVT_P2P_TARGET_ACTIVATED:
583 		r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
584 				     NFC_COMM_PASSIVE, skb->data,
585 				     skb->len);
586 
587 		kfree_skb(skb);
588 		break;
589 
590 	case MICROREAD_EVT_MCARD_EXCHANGE:
591 		if (skb->len < 1) {
592 			kfree_skb(skb);
593 			return -EPROTO;
594 		}
595 
596 		if (skb->data[skb->len-1]) {
597 			kfree_skb(skb);
598 			return -EIO;
599 		}
600 
601 		skb_trim(skb, skb->len - 1);
602 
603 		r = nfc_tm_data_received(hdev->ndev, skb);
604 		break;
605 
606 	case MICROREAD_EVT_P2P_TARGET_DEACTIVATED:
607 		kfree_skb(skb);
608 
609 		mode = 0xff;
610 		r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
611 				      MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
612 		if (r)
613 			break;
614 
615 		r = nfc_hci_send_event(hdev, gate,
616 				       MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL,
617 				       0);
618 		break;
619 
620 	default:
621 		return 1;
622 	}
623 
624 	return r;
625 }
626 
627 static const struct nfc_hci_ops microread_hci_ops = {
628 	.open = microread_open,
629 	.close = microread_close,
630 	.hci_ready = microread_hci_ready,
631 	.xmit = microread_xmit,
632 	.start_poll = microread_start_poll,
633 	.dep_link_up = microread_dep_link_up,
634 	.dep_link_down = microread_dep_link_down,
635 	.target_from_gate = microread_target_from_gate,
636 	.complete_target_discovered = microread_complete_target_discovered,
637 	.im_transceive = microread_im_transceive,
638 	.tm_send = microread_tm_send,
639 	.check_presence = NULL,
640 	.event_received = microread_event_received,
641 };
642 
643 int microread_probe(void *phy_id, const struct nfc_phy_ops *phy_ops,
644 		    const char *llc_name, int phy_headroom, int phy_tailroom,
645 		    int phy_payload, struct nfc_hci_dev **hdev)
646 {
647 	struct microread_info *info;
648 	unsigned long quirks = 0;
649 	u32 protocols;
650 	struct nfc_hci_init_data init_data;
651 	int r;
652 
653 	info = kzalloc(sizeof(struct microread_info), GFP_KERNEL);
654 	if (!info) {
655 		r = -ENOMEM;
656 		goto err_info_alloc;
657 	}
658 
659 	info->phy_ops = phy_ops;
660 	info->phy_id = phy_id;
661 
662 	init_data.gate_count = ARRAY_SIZE(microread_gates);
663 	memcpy(init_data.gates, microread_gates, sizeof(microread_gates));
664 
665 	strcpy(init_data.session_id, "MICROREA");
666 
667 	set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
668 
669 	protocols = NFC_PROTO_JEWEL_MASK |
670 		    NFC_PROTO_MIFARE_MASK |
671 		    NFC_PROTO_FELICA_MASK |
672 		    NFC_PROTO_ISO14443_MASK |
673 		    NFC_PROTO_ISO14443_B_MASK |
674 		    NFC_PROTO_NFC_DEP_MASK;
675 
676 	info->hdev = nfc_hci_allocate_device(&microread_hci_ops, &init_data,
677 					     quirks, protocols, llc_name,
678 					     phy_headroom +
679 					     MICROREAD_CMDS_HEADROOM,
680 					     phy_tailroom +
681 					     MICROREAD_CMD_TAILROOM,
682 					     phy_payload);
683 	if (!info->hdev) {
684 		pr_err("Cannot allocate nfc hdev\n");
685 		r = -ENOMEM;
686 		goto err_alloc_hdev;
687 	}
688 
689 	nfc_hci_set_clientdata(info->hdev, info);
690 
691 	r = nfc_hci_register_device(info->hdev);
692 	if (r)
693 		goto err_regdev;
694 
695 	*hdev = info->hdev;
696 
697 	return 0;
698 
699 err_regdev:
700 	nfc_hci_free_device(info->hdev);
701 
702 err_alloc_hdev:
703 	kfree(info);
704 
705 err_info_alloc:
706 	return r;
707 }
708 EXPORT_SYMBOL(microread_probe);
709 
710 void microread_remove(struct nfc_hci_dev *hdev)
711 {
712 	struct microread_info *info = nfc_hci_get_clientdata(hdev);
713 
714 	nfc_hci_unregister_device(hdev);
715 	nfc_hci_free_device(hdev);
716 	kfree(info);
717 }
718 EXPORT_SYMBOL(microread_remove);
719 
720 MODULE_LICENSE("GPL");
721 MODULE_DESCRIPTION(DRIVER_DESC);
722