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