text: /*
   * HCI based Driver for Inside Secure microread NFC Chip
   *
   * Copyright (C) 2013  Intel Corporation. All rights reserved.
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms and conditions of the GNU General Public License,
   * version 2, as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the
   * Free Software Foundation, Inc.,
   * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   */
  
  #include <linux/module.h>
  #include <linux/delay.h>
  #include <linux/slab.h>
  #include <linux/crc-ccitt.h>
  
  #include <linux/nfc.h>
  #include <net/nfc/nfc.h>
  #include <net/nfc/hci.h>
  #include <net/nfc/llc.h>
  
  #include "microread.h"
  
  /* Proprietary gates, events, commands and registers */
  /* Admin */
  #define MICROREAD_GATE_ID_ADM NFC_HCI_ADMIN_GATE
  #define MICROREAD_GATE_ID_MGT 0x01
  #define MICROREAD_GATE_ID_OS 0x02
  #define MICROREAD_GATE_ID_TESTRF 0x03
  #define MICROREAD_GATE_ID_LOOPBACK NFC_HCI_LOOPBACK_GATE
  #define MICROREAD_GATE_ID_IDT NFC_HCI_ID_MGMT_GATE
  #define MICROREAD_GATE_ID_LMS NFC_HCI_LINK_MGMT_GATE
  
  /* Reader */
  #define MICROREAD_GATE_ID_MREAD_GEN 0x10
  #define MICROREAD_GATE_ID_MREAD_ISO_B NFC_HCI_RF_READER_B_GATE
  #define MICROREAD_GATE_ID_MREAD_NFC_T1 0x12
  #define MICROREAD_GATE_ID_MREAD_ISO_A NFC_HCI_RF_READER_A_GATE
  #define MICROREAD_GATE_ID_MREAD_NFC_T3 0x14
  #define MICROREAD_GATE_ID_MREAD_ISO_15_3 0x15
  #define MICROREAD_GATE_ID_MREAD_ISO_15_2 0x16
  #define MICROREAD_GATE_ID_MREAD_ISO_B_3 0x17
  #define MICROREAD_GATE_ID_MREAD_BPRIME 0x18
  #define MICROREAD_GATE_ID_MREAD_ISO_A_3 0x19
  
  /* Card */
  #define MICROREAD_GATE_ID_MCARD_GEN 0x20
  #define MICROREAD_GATE_ID_MCARD_ISO_B 0x21
  #define MICROREAD_GATE_ID_MCARD_BPRIME 0x22
  #define MICROREAD_GATE_ID_MCARD_ISO_A 0x23
  #define MICROREAD_GATE_ID_MCARD_NFC_T3 0x24
  #define MICROREAD_GATE_ID_MCARD_ISO_15_3 0x25
  #define MICROREAD_GATE_ID_MCARD_ISO_15_2 0x26
  #define MICROREAD_GATE_ID_MCARD_ISO_B_2 0x27
  #define MICROREAD_GATE_ID_MCARD_ISO_CUSTOM 0x28
  #define MICROREAD_GATE_ID_SECURE_ELEMENT 0x2F
  
  /* P2P */
  #define MICROREAD_GATE_ID_P2P_GEN 0x30
  #define MICROREAD_GATE_ID_P2P_TARGET 0x31
  #define MICROREAD_PAR_P2P_TARGET_MODE 0x01
  #define MICROREAD_PAR_P2P_TARGET_GT 0x04
  #define MICROREAD_GATE_ID_P2P_INITIATOR 0x32
  #define MICROREAD_PAR_P2P_INITIATOR_GI 0x01
  #define MICROREAD_PAR_P2P_INITIATOR_GT 0x03
  
  /* Those pipes are created/opened by default in the chip */
  #define MICROREAD_PIPE_ID_LMS 0x00
  #define MICROREAD_PIPE_ID_ADMIN 0x01
  #define MICROREAD_PIPE_ID_MGT 0x02
  #define MICROREAD_PIPE_ID_OS 0x03
  #define MICROREAD_PIPE_ID_HDS_LOOPBACK 0x04
  #define MICROREAD_PIPE_ID_HDS_IDT 0x05
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B 0x08
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_BPRIME 0x09
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_A 0x0A
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_3 0x0B
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_15_2 0x0C
  #define MICROREAD_PIPE_ID_HDS_MCARD_NFC_T3 0x0D
  #define MICROREAD_PIPE_ID_HDS_MCARD_ISO_B_2 0x0E
  #define MICROREAD_PIPE_ID_HDS_MCARD_CUSTOM 0x0F
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B 0x10
  #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1 0x11
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A 0x12
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_3 0x13
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_15_2 0x14
  #define MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3 0x15
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_B_3 0x16
  #define MICROREAD_PIPE_ID_HDS_MREAD_BPRIME 0x17
  #define MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3 0x18
  #define MICROREAD_PIPE_ID_HDS_MREAD_GEN 0x1B
  #define MICROREAD_PIPE_ID_HDS_STACKED_ELEMENT 0x1C
  #define MICROREAD_PIPE_ID_HDS_INSTANCES 0x1D
  #define MICROREAD_PIPE_ID_HDS_TESTRF 0x1E
  #define MICROREAD_PIPE_ID_HDS_P2P_TARGET 0x1F
  #define MICROREAD_PIPE_ID_HDS_P2P_INITIATOR 0x20
  
  /* Events */
  #define MICROREAD_EVT_MREAD_DISCOVERY_OCCURED NFC_HCI_EVT_TARGET_DISCOVERED
  #define MICROREAD_EVT_MREAD_CARD_FOUND 0x3D
  #define MICROREAD_EMCF_A_ATQA 0
  #define MICROREAD_EMCF_A_SAK 2
  #define MICROREAD_EMCF_A_LEN 3
  #define MICROREAD_EMCF_A_UID 4
  #define MICROREAD_EMCF_A3_ATQA 0
  #define MICROREAD_EMCF_A3_SAK 2
  #define MICROREAD_EMCF_A3_LEN 3
  #define MICROREAD_EMCF_A3_UID 4
  #define MICROREAD_EMCF_B_UID 0
  #define MICROREAD_EMCF_T1_ATQA 0
  #define MICROREAD_EMCF_T1_UID 4
  #define MICROREAD_EMCF_T3_UID 0
  #define MICROREAD_EVT_MREAD_DISCOVERY_START NFC_HCI_EVT_READER_REQUESTED
  #define MICROREAD_EVT_MREAD_DISCOVERY_START_SOME 0x3E
  #define MICROREAD_EVT_MREAD_DISCOVERY_STOP NFC_HCI_EVT_END_OPERATION
  #define MICROREAD_EVT_MREAD_SIM_REQUESTS 0x3F
  #define MICROREAD_EVT_MCARD_EXCHANGE NFC_HCI_EVT_TARGET_DISCOVERED
  #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF 0x20
  #define MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF 0x21
  #define MICROREAD_EVT_MCARD_FIELD_ON 0x11
  #define MICROREAD_EVT_P2P_TARGET_ACTIVATED 0x13
  #define MICROREAD_EVT_P2P_TARGET_DEACTIVATED 0x12
  #define MICROREAD_EVT_MCARD_FIELD_OFF 0x14
  
  /* Commands */
  #define MICROREAD_CMD_MREAD_EXCHANGE 0x10
  #define MICROREAD_CMD_MREAD_SUBSCRIBE 0x3F
  
  /* Hosts IDs */
  #define MICROREAD_ELT_ID_HDS NFC_HCI_TERMINAL_HOST_ID
  #define MICROREAD_ELT_ID_SIM NFC_HCI_UICC_HOST_ID
  #define MICROREAD_ELT_ID_SE1 0x03
  #define MICROREAD_ELT_ID_SE2 0x04
  #define MICROREAD_ELT_ID_SE3 0x05
  
  static struct nfc_hci_gate microread_gates[] = {
  	{MICROREAD_GATE_ID_ADM, MICROREAD_PIPE_ID_ADMIN},
  	{MICROREAD_GATE_ID_LOOPBACK, MICROREAD_PIPE_ID_HDS_LOOPBACK},
  	{MICROREAD_GATE_ID_IDT, MICROREAD_PIPE_ID_HDS_IDT},
  	{MICROREAD_GATE_ID_LMS, MICROREAD_PIPE_ID_LMS},
  	{MICROREAD_GATE_ID_MREAD_ISO_B, MICROREAD_PIPE_ID_HDS_MREAD_ISO_B},
  	{MICROREAD_GATE_ID_MREAD_ISO_A, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A},
  	{MICROREAD_GATE_ID_MREAD_ISO_A_3, MICROREAD_PIPE_ID_HDS_MREAD_ISO_A_3},
  	{MICROREAD_GATE_ID_MGT, MICROREAD_PIPE_ID_MGT},
  	{MICROREAD_GATE_ID_OS, MICROREAD_PIPE_ID_OS},
  	{MICROREAD_GATE_ID_MREAD_NFC_T1, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T1},
  	{MICROREAD_GATE_ID_MREAD_NFC_T3, MICROREAD_PIPE_ID_HDS_MREAD_NFC_T3},
  	{MICROREAD_GATE_ID_P2P_TARGET, MICROREAD_PIPE_ID_HDS_P2P_TARGET},
  	{MICROREAD_GATE_ID_P2P_INITIATOR, MICROREAD_PIPE_ID_HDS_P2P_INITIATOR}
  };
  
  /* Largest headroom needed for outgoing custom commands */
  #define MICROREAD_CMDS_HEADROOM	2
  #define MICROREAD_CMD_TAILROOM	2
  
  struct microread_info {
  	struct nfc_phy_ops *phy_ops;
  	void *phy_id;
  
  	struct nfc_hci_dev *hdev;
  
  	int async_cb_type;
  	data_exchange_cb_t async_cb;
  	void *async_cb_context;
  };
  
  static int microread_open(struct nfc_hci_dev *hdev)
  {
  	struct microread_info *info = nfc_hci_get_clientdata(hdev);
  
  	return info->phy_ops->enable(info->phy_id);
  }
  
  static void microread_close(struct nfc_hci_dev *hdev)
  {
  	struct microread_info *info = nfc_hci_get_clientdata(hdev);
  
  	info->phy_ops->disable(info->phy_id);
  }
  
  static int microread_hci_ready(struct nfc_hci_dev *hdev)
  {
  	int r;
  	u8 param[4];
  
  	param[0] = 0x03;
  	r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  			     MICROREAD_CMD_MREAD_SUBSCRIBE, param, 1, NULL);
  	if (r)
  		return r;
  
  	r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_A_3,
  			     MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
  	if (r)
  		return r;
  
  	param[0] = 0x00;
  	param[1] = 0x03;
  	param[2] = 0x00;
  	r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_ISO_B,
  			     MICROREAD_CMD_MREAD_SUBSCRIBE, param, 3, NULL);
  	if (r)
  		return r;
  
  	r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T1,
  			     MICROREAD_CMD_MREAD_SUBSCRIBE, NULL, 0, NULL);
  	if (r)
  		return r;
  
  	param[0] = 0xFF;
  	param[1] = 0xFF;
  	param[2] = 0x00;
  	param[3] = 0x00;
  	r = nfc_hci_send_cmd(hdev, MICROREAD_GATE_ID_MREAD_NFC_T3,
  			     MICROREAD_CMD_MREAD_SUBSCRIBE, param, 4, NULL);
  
  	return r;
  }
  
  static int microread_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
  {
  	struct microread_info *info = nfc_hci_get_clientdata(hdev);
  
  	return info->phy_ops->write(info->phy_id, skb);
  }
  
  static int microread_start_poll(struct nfc_hci_dev *hdev,
  				u32 im_protocols, u32 tm_protocols)
  {
  	int r;
  
  	u8 param[2];
  	u8 mode;
  
  	param[0] = 0x00;
  	param[1] = 0x00;
  
  	if (im_protocols & NFC_PROTO_ISO14443_MASK)
  		param[0] |= (1 << 2);
  
  	if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
  		param[0] |= 1;
  
  	if (im_protocols & NFC_PROTO_MIFARE_MASK)
  		param[1] |= 1;
  
  	if (im_protocols & NFC_PROTO_JEWEL_MASK)
  		param[0] |= (1 << 1);
  
  	if (im_protocols & NFC_PROTO_FELICA_MASK)
  		param[0] |= (1 << 5);
  
  	if (im_protocols & NFC_PROTO_NFC_DEP_MASK)
  		param[1] |= (1 << 1);
  
  	if ((im_protocols | tm_protocols) & NFC_PROTO_NFC_DEP_MASK) {
  		hdev->gb = nfc_get_local_general_bytes(hdev->ndev,
  						       &hdev->gb_len);
  		if (hdev->gb == NULL || hdev->gb_len == 0) {
  			im_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
  			tm_protocols &= ~NFC_PROTO_NFC_DEP_MASK;
  		}
  	}
  
  	r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  			       MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
  	if (r)
  		return r;
  
  	mode = 0xff;
  	r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  			      MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  	if (r)
  		return r;
  
  	if (im_protocols & NFC_PROTO_NFC_DEP_MASK) {
  		r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
  				      MICROREAD_PAR_P2P_INITIATOR_GI,
  				      hdev->gb, hdev->gb_len);
  		if (r)
  			return r;
  	}
  
  	if (tm_protocols & NFC_PROTO_NFC_DEP_MASK) {
  		r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  				      MICROREAD_PAR_P2P_TARGET_GT,
  				      hdev->gb, hdev->gb_len);
  		if (r)
  			return r;
  
  		mode = 0x02;
  		r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  				      MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  		if (r)
  			return r;
  	}
  
  	return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_MREAD_ISO_A,
  				  MICROREAD_EVT_MREAD_DISCOVERY_START_SOME,
  				  param, 2);
  }
  
  static int microread_dep_link_up(struct nfc_hci_dev *hdev,
  				struct nfc_target *target, u8 comm_mode,
  				u8 *gb, size_t gb_len)
  {
  	struct sk_buff *rgb_skb = NULL;
  	int r;
  
  	r = nfc_hci_get_param(hdev, target->hci_reader_gate,
  			      MICROREAD_PAR_P2P_INITIATOR_GT, &rgb_skb);
  	if (r < 0)
  		return r;
  
  	if (rgb_skb->len == 0 || rgb_skb->len > NFC_GB_MAXSIZE) {
  		r = -EPROTO;
  		goto exit;
  	}
  
  	r = nfc_set_remote_general_bytes(hdev->ndev, rgb_skb->data,
  					 rgb_skb->len);
  	if (r == 0)
  		r = nfc_dep_link_is_up(hdev->ndev, target->idx, comm_mode,
  				       NFC_RF_INITIATOR);
  exit:
  	kfree_skb(rgb_skb);
  
  	return r;
  }
  
  static int microread_dep_link_down(struct nfc_hci_dev *hdev)
  {
  	return nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_INITIATOR,
  				  MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL, 0);
  }
  
  static int microread_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
  				      struct nfc_target *target)
  {
  	switch (gate) {
  	case MICROREAD_GATE_ID_P2P_INITIATOR:
  		target->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  		break;
  	default:
  		return -EPROTO;
  	}
  
  	return 0;
  }
  
  static int microread_complete_target_discovered(struct nfc_hci_dev *hdev,
  						u8 gate,
  						struct nfc_target *target)
  {
  	return 0;
  }
  
  #define MICROREAD_CB_TYPE_READER_ALL 1
  
  static void microread_im_transceive_cb(void *context, struct sk_buff *skb,
  				       int err)
  {
  	struct microread_info *info = context;
  
  	switch (info->async_cb_type) {
  	case MICROREAD_CB_TYPE_READER_ALL:
  		if (err == 0) {
  			if (skb->len == 0) {
  				err = -EPROTO;
  				kfree_skb(skb);
  				info->async_cb(info->async_cb_context, NULL,
  					       -EPROTO);
  				return;
  			}
  
  			if (skb->data[skb->len - 1] != 0) {
  				err = nfc_hci_result_to_errno(
  						       skb->data[skb->len - 1]);
  				kfree_skb(skb);
  				info->async_cb(info->async_cb_context, NULL,
  					       err);
  				return;
  			}
  
  			skb_trim(skb, skb->len - 1);	/* RF Error ind. */
  		}
  		info->async_cb(info->async_cb_context, skb, err);
  		break;
  	default:
  		if (err == 0)
  			kfree_skb(skb);
  		break;
  	}
  }
  
  /*
   * Returns:
   * <= 0: driver handled the data exchange
   *    1: driver doesn't especially handle, please do standard processing
   */
  static int microread_im_transceive(struct nfc_hci_dev *hdev,
  				   struct nfc_target *target,
  				   struct sk_buff *skb, data_exchange_cb_t cb,
  				   void *cb_context)
  {
  	struct microread_info *info = nfc_hci_get_clientdata(hdev);
  	u8 control_bits;
  	u16 crc;
  
  	pr_info("data exchange to gate 0x%x\n", target->hci_reader_gate);
  
  	if (target->hci_reader_gate == MICROREAD_GATE_ID_P2P_INITIATOR) {
  		*skb_push(skb, 1) = 0;
  
  		return nfc_hci_send_event(hdev, target->hci_reader_gate,
  				     MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_TO_RF,
  				     skb->data, skb->len);
  	}
  
  	switch (target->hci_reader_gate) {
  	case MICROREAD_GATE_ID_MREAD_ISO_A:
  		control_bits = 0xCB;
  		break;
  	case MICROREAD_GATE_ID_MREAD_ISO_A_3:
  		control_bits = 0xCB;
  		break;
  	case MICROREAD_GATE_ID_MREAD_ISO_B:
  		control_bits = 0xCB;
  		break;
  	case MICROREAD_GATE_ID_MREAD_NFC_T1:
  		control_bits = 0x1B;
  
  		crc = crc_ccitt(0xffff, skb->data, skb->len);
  		crc = ~crc;
  		*skb_put(skb, 1) = crc & 0xff;
  		*skb_put(skb, 1) = crc >> 8;
  		break;
  	case MICROREAD_GATE_ID_MREAD_NFC_T3:
  		control_bits = 0xDB;
  		break;
  	default:
  		pr_info("Abort im_transceive to invalid gate 0x%x\n",
  			target->hci_reader_gate);
  		return 1;
  	}
  
  	*skb_push(skb, 1) = control_bits;
  
  	info->async_cb_type = MICROREAD_CB_TYPE_READER_ALL;
  	info->async_cb = cb;
  	info->async_cb_context = cb_context;
  
  	return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
  				      MICROREAD_CMD_MREAD_EXCHANGE,
  				      skb->data, skb->len,
  				      microread_im_transceive_cb, info);
  }
  
  static int microread_tm_send(struct nfc_hci_dev *hdev, struct sk_buff *skb)
  {
  	int r;
  
  	r = nfc_hci_send_event(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  			       MICROREAD_EVT_MCARD_EXCHANGE,
  			       skb->data, skb->len);
  
  	kfree_skb(skb);
  
  	return r;
  }
  
  static void microread_target_discovered(struct nfc_hci_dev *hdev, u8 gate,
  					struct sk_buff *skb)
  {
  	struct nfc_target *targets;
  	int r = 0;
  
  	pr_info("target discovered to gate 0x%x\n", gate);
  
  	targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
  	if (targets == NULL) {
  		r = -ENOMEM;
  		goto exit;
  	}
  
  	targets->hci_reader_gate = gate;
  
  	switch (gate) {
  	case MICROREAD_GATE_ID_MREAD_ISO_A:
  		targets->supported_protocols =
  		      nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A_SAK]);
  		targets->sens_res =
  			 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A_ATQA]);
  		targets->sel_res = skb->data[MICROREAD_EMCF_A_SAK];
  		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A_UID],
  		       skb->data[MICROREAD_EMCF_A_LEN]);
  		targets->nfcid1_len = skb->data[MICROREAD_EMCF_A_LEN];
  		break;
  	case MICROREAD_GATE_ID_MREAD_ISO_A_3:
  		targets->supported_protocols =
  		      nfc_hci_sak_to_protocol(skb->data[MICROREAD_EMCF_A3_SAK]);
  		targets->sens_res =
  			 be16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_A3_ATQA]);
  		targets->sel_res = skb->data[MICROREAD_EMCF_A3_SAK];
  		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_A3_UID],
  		       skb->data[MICROREAD_EMCF_A3_LEN]);
  		targets->nfcid1_len = skb->data[MICROREAD_EMCF_A3_LEN];
  		break;
  	case MICROREAD_GATE_ID_MREAD_ISO_B:
  		targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
  		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_B_UID], 4);
  		targets->nfcid1_len = 4;
  		break;
  	case MICROREAD_GATE_ID_MREAD_NFC_T1:
  		targets->supported_protocols = NFC_PROTO_JEWEL_MASK;
  		targets->sens_res =
  			le16_to_cpu(*(u16 *)&skb->data[MICROREAD_EMCF_T1_ATQA]);
  		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T1_UID], 4);
  		targets->nfcid1_len = 4;
  		break;
  	case MICROREAD_GATE_ID_MREAD_NFC_T3:
  		targets->supported_protocols = NFC_PROTO_FELICA_MASK;
  		memcpy(targets->nfcid1, &skb->data[MICROREAD_EMCF_T3_UID], 8);
  		targets->nfcid1_len = 8;
  		break;
  	default:
  		pr_info("discard target discovered to gate 0x%x\n", gate);
  		goto exit_free;
  	}
  
  	r = nfc_targets_found(hdev->ndev, targets, 1);
  
  exit_free:
  	kfree(targets);
  
  exit:
  	kfree_skb(skb);
  
  	if (r)
  		pr_err("Failed to handle discovered target err=%d", r);
  }
  
  static int microread_event_received(struct nfc_hci_dev *hdev, u8 gate,
  				     u8 event, struct sk_buff *skb)
  {
  	int r;
  	u8 mode;
  
  	pr_info("Microread received event 0x%x to gate 0x%x\n", event, gate);
  
  	switch (event) {
  	case MICROREAD_EVT_MREAD_CARD_FOUND:
  		microread_target_discovered(hdev, gate, skb);
  		return 0;
  
  	case MICROREAD_EVT_P2P_INITIATOR_EXCHANGE_FROM_RF:
  		if (skb->len < 1) {
  			kfree_skb(skb);
  			return -EPROTO;
  		}
  
  		if (skb->data[skb->len - 1]) {
  			kfree_skb(skb);
  			return -EIO;
  		}
  
  		skb_trim(skb, skb->len - 1);
  
  		r = nfc_tm_data_received(hdev->ndev, skb);
  		break;
  
  	case MICROREAD_EVT_MCARD_FIELD_ON:
  	case MICROREAD_EVT_MCARD_FIELD_OFF:
  		kfree_skb(skb);
  		return 0;
  
  	case MICROREAD_EVT_P2P_TARGET_ACTIVATED:
  		r = nfc_tm_activated(hdev->ndev, NFC_PROTO_NFC_DEP_MASK,
  				     NFC_COMM_PASSIVE, skb->data,
  				     skb->len);
  
  		kfree_skb(skb);
  		break;
  
  	case MICROREAD_EVT_MCARD_EXCHANGE:
  		if (skb->len < 1) {
  			kfree_skb(skb);
  			return -EPROTO;
  		}
  
  		if (skb->data[skb->len-1]) {
  			kfree_skb(skb);
  			return -EIO;
  		}
  
  		skb_trim(skb, skb->len - 1);
  
  		r = nfc_tm_data_received(hdev->ndev, skb);
  		break;
  
  	case MICROREAD_EVT_P2P_TARGET_DEACTIVATED:
  		kfree_skb(skb);
  
  		mode = 0xff;
  		r = nfc_hci_set_param(hdev, MICROREAD_GATE_ID_P2P_TARGET,
  				      MICROREAD_PAR_P2P_TARGET_MODE, &mode, 1);
  		if (r)
  			break;
  
  		r = nfc_hci_send_event(hdev, gate,
  				       MICROREAD_EVT_MREAD_DISCOVERY_STOP, NULL,
  				       0);
  		break;
  
  	default:
  		return 1;
  	}
  
  	return r;
  }
  
  static struct nfc_hci_ops microread_hci_ops = {
  	.open = microread_open,
  	.close = microread_close,
  	.hci_ready = microread_hci_ready,
  	.xmit = microread_xmit,
  	.start_poll = microread_start_poll,
  	.dep_link_up = microread_dep_link_up,
  	.dep_link_down = microread_dep_link_down,
  	.target_from_gate = microread_target_from_gate,
  	.complete_target_discovered = microread_complete_target_discovered,
  	.im_transceive = microread_im_transceive,
  	.tm_send = microread_tm_send,
  	.check_presence = NULL,
  	.event_received = microread_event_received,
  };
  
  int microread_probe(void *phy_id, struct nfc_phy_ops *phy_ops, char *llc_name,
  		    int phy_headroom, int phy_tailroom, int phy_payload,
  		    struct nfc_hci_dev **hdev)
  {
  	struct microread_info *info;
  	unsigned long quirks = 0;
  	u32 protocols;
  	struct nfc_hci_init_data init_data;
  	int r;
  
  	info = kzalloc(sizeof(struct microread_info), GFP_KERNEL);
  	if (!info) {
  		pr_err("Cannot allocate memory for microread_info.\n");
  		r = -ENOMEM;
  		goto err_info_alloc;
  	}
  
  	info->phy_ops = phy_ops;
  	info->phy_id = phy_id;
  
  	init_data.gate_count = ARRAY_SIZE(microread_gates);
  	memcpy(init_data.gates, microread_gates, sizeof(microread_gates));
  
  	strcpy(init_data.session_id, "MICROREA");
  
  	set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
  
  	protocols = NFC_PROTO_JEWEL_MASK |
  		    NFC_PROTO_MIFARE_MASK |
  		    NFC_PROTO_FELICA_MASK |
  		    NFC_PROTO_ISO14443_MASK |
  		    NFC_PROTO_ISO14443_B_MASK |
  		    NFC_PROTO_NFC_DEP_MASK;
  
  	info->hdev = nfc_hci_allocate_device(&microread_hci_ops, &init_data,
  					     quirks, protocols, llc_name,
  					     phy_headroom +
  					     MICROREAD_CMDS_HEADROOM,
  					     phy_tailroom +
  					     MICROREAD_CMD_TAILROOM,
  					     phy_payload);
  	if (!info->hdev) {
  		pr_err("Cannot allocate nfc hdev.\n");
  		r = -ENOMEM;
  		goto err_alloc_hdev;
  	}
  
  	nfc_hci_set_clientdata(info->hdev, info);
  
  	r = nfc_hci_register_device(info->hdev);
  	if (r)
  		goto err_regdev;
  
  	*hdev = info->hdev;
  
  	return 0;
  
  err_regdev:
  	nfc_hci_free_device(info->hdev);
  
  err_alloc_hdev:
  	kfree(info);
  
  err_info_alloc:
  	return r;
  }
  EXPORT_SYMBOL(microread_probe);
  
  void microread_remove(struct nfc_hci_dev *hdev)
  {
  	struct microread_info *info = nfc_hci_get_clientdata(hdev);
  
  	nfc_hci_unregister_device(hdev);
  	nfc_hci_free_device(hdev);
  	kfree(info);
  }
  EXPORT_SYMBOL(microread_remove);
  
  MODULE_LICENSE("GPL");
  MODULE_DESCRIPTION(DRIVER_DESC);
  