NFC: ST21NFCA: Add driver for STMicroelectronics ST21NFCA NFC Chip

Add driver for STMicroelectronics ST21NFCA NFC controller.
ST21NFCA is using HCI protocol, shdlc as LLC layer & I2C as
communication protocol.

Adding support for Reader/Writer mode with Tag type 1/2/3/4 A & B.
It is using proprietary gate 15 for ISO14443-3 such as type 1 &
type 2 tags. It is using proprietary gate 14 for type F tags.
ST21NFCA_DEVICE_MGNT_GATE gives access to proprietary CLF configuration.
Standard gate for ISO14443-4 A (13) & B (11) are also used.

ST21NFCA specific mecanism:

One particular point to notice for the data handling is that frame
does not contain any length value. Therefore the i2c part of this driver
is managing the reception with a read length sequence until the end of
frame (0x7e) is reached.

In order to avoid conflict between sof & eof a mecanism
called byte stuffing concist of an escape byte (0x7d) insertion before
special byte (0x7e, 0x7d). The special byte is then xored with 0x20.

In this driver, When data are available in the CLF, the interrupt
gpio is driven to active state and triggered an interrupt.
Once the i2c_master_recv start, the interrupt gpio is driven to idle
state until its complete. If the frame is incomplete or data are still
available, interrupts will be triggered again.

Signed-off-by: Christophe Ricard <christophe-h.ricard@st.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

7 files changed, 1221 insertions, 0 deletions

diff --git a/drivers/nfc/Kconfig b/drivers/nfc/Kconfig
index 65d4ca19d132..26c66a126551 100644
--- a/drivers/nfc/Kconfig
+++ b/drivers/nfc/Kconfig
@@ -71,5 +71,6 @@ config NFC_PORT100
 source "drivers/nfc/pn544/Kconfig"
 source "drivers/nfc/microread/Kconfig"
 source "drivers/nfc/nfcmrvl/Kconfig"
+source "drivers/nfc/st21nfca/Kconfig"
 
 endmenu
diff --git a/drivers/nfc/Makefile b/drivers/nfc/Makefile
index ae42a3fa60c9..23225b0287fd 100644
--- a/drivers/nfc/Makefile
+++ b/drivers/nfc/Makefile
@@ -11,5 +11,6 @@ obj-$(CONFIG_NFC_SIM)		+= nfcsim.o
 obj-$(CONFIG_NFC_PORT100)       += port100.o
 obj-$(CONFIG_NFC_MRVL)          += nfcmrvl/
 obj-$(CONFIG_NFC_TRF7970A)      += trf7970a.o
+obj-$(CONFIG_NFC_ST21NFCA)  += st21nfca/
 
 ccflags-$(CONFIG_NFC_DEBUG) := -DDEBUG
diff --git a/drivers/nfc/st21nfca/Kconfig b/drivers/nfc/st21nfca/Kconfig
new file mode 100644
index 000000000000..ee459f066ade
--- /dev/null
+++ b/drivers/nfc/st21nfca/Kconfig
@@ -0,0 +1,23 @@
+config NFC_ST21NFCA
+        tristate "STMicroelectronics ST21NFCA NFC driver"
+        depends on NFC_HCI
+        select CRC_CCITT
+        default n
+        ---help---
+          STMicroelectronics ST21NFCA core driver. It implements the chipset
+          HCI logic and hooks into the NFC kernel APIs. Physical layers will
+          register against it.
+
+          To compile this driver as a module, choose m here. The module will
+          be called st21nfca.
+          Say N if unsure.
+
+config NFC_ST21NFCA_I2C
+        tristate "NFC ST21NFCA i2c support"
+        depends on NFC_ST21NFCA && I2C && NFC_SHDLC
+        ---help---
+          This module adds support for the STMicroelectronics st21nfca i2c interface.
+          Select this if your platform is using the i2c bus.
+
+          If you choose to build a module, it'll be called st21nfca_i2c.
+          Say N if unsure.
diff --git a/drivers/nfc/st21nfca/Makefile b/drivers/nfc/st21nfca/Makefile
new file mode 100644
index 000000000000..038ed093a119
--- /dev/null
+++ b/drivers/nfc/st21nfca/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for ST21NFCA HCI based NFC driver
+#
+
+st21nfca_i2c-objs  = i2c.o
+
+obj-$(CONFIG_NFC_ST21NFCA)     += st21nfca.o
+obj-$(CONFIG_NFC_ST21NFCA_I2C) += st21nfca_i2c.o
diff --git a/drivers/nfc/st21nfca/i2c.c b/drivers/nfc/st21nfca/i2c.c
new file mode 100644
index 000000000000..3b0fd0f76d1c
--- /dev/null
+++ b/drivers/nfc/st21nfca/i2c.c
@@ -0,0 +1,595 @@
+/*
+ * I2C Link Layer for ST21NFCA HCI based Driver
+ * Copyright (C) 2014  STMicroelectronics SAS. 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/crc-ccitt.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/miscdevice.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/nfc.h>
+#include <linux/firmware.h>
+#include <linux/unaligned/access_ok.h>
+#include <linux/platform_data/st21nfca.h>
+
+#include <net/nfc/hci.h>
+#include <net/nfc/llc.h>
+#include <net/nfc/nfc.h>
+
+#include "st21nfca.h"
+
+/*
+ * Every frame starts with ST21NFCA_SOF_EOF and ends with ST21NFCA_SOF_EOF.
+ * Because ST21NFCA_SOF_EOF is a possible data value, there is a mecanism
+ * called byte stuffing has been introduced.
+ *
+ * if byte == ST21NFCA_SOF_EOF or ST21NFCA_ESCAPE_BYTE_STUFFING
+ * - insert ST21NFCA_ESCAPE_BYTE_STUFFING (escape byte)
+ * - xor byte with ST21NFCA_BYTE_STUFFING_MASK
+ */
+#define ST21NFCA_SOF_EOF                0x7e
+#define ST21NFCA_BYTE_STUFFING_MASK     0x20
+#define ST21NFCA_ESCAPE_BYTE_STUFFING   0x7d
+
+/* SOF + 00 fill size */
+#define ST21NFCA_FRAME_HEADROOM                 2
+
+/* 4 bytes crc (worst case byte stuffing) + EOF */
+#define ST21NFCA_FRAME_TAILROOM 5
+
+#define ST21NFCA_HCI_I2C_DRIVER_NAME "st21nfca_hci_i2c"
+
+static struct i2c_device_id st21nfca_hci_i2c_id_table[] = {
+        {ST21NFCA_HCI_DRIVER_NAME, 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(i2c, st21nfca_hci_i2c_id_table);
+
+struct st21nfca_i2c_phy {
+        struct i2c_client *i2c_dev;
+        struct nfc_hci_dev *hdev;
+
+        unsigned int gpio_ena;
+        unsigned int gpio_irq;
+        unsigned int irq_polarity;
+
+        struct sk_buff *pending_skb;
+        int current_read_len;
+        /*
+         * crc might have fail because i2c macro
+         * is disable due to other interface activity
+         */
+        int crc_trials;
+
+        int powered;
+        int run_mode;
+
+        /*
+         * < 0 if hardware error occured (e.g. i2c err)
+         * and prevents normal operation.
+         */
+        int hard_fault;
+};
+static u8 len_seq[] = { 13, 24, 15, 29 };
+static u16 wait_tab[] = { 2, 3, 5, 15, 20, 40};
+
+#define I2C_DUMP_SKB(info, skb)                                 \
+do {                                                            \
+        pr_debug("%s:\n", info);                                \
+        print_hex_dump(KERN_DEBUG, "i2c: ", DUMP_PREFIX_OFFSET, \
+                       16, 1, (skb)->data, (skb)->len, 0);      \
+} while (0)
+
+static void st21nfca_hci_platform_init(struct st21nfca_i2c_phy *phy)
+{
+        u16 wait_tab[] = { 50, 300, 1000 };
+        char reboot_cmd[] = { 0x7E, 0x66, 0x48, 0xF6, 0x7E };
+        u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE];
+        int i, r = -1;
+
+        for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++)
+                r = i2c_master_recv(phy->i2c_dev, tmp,
+                                    ST21NFCA_HCI_LLC_MAX_SIZE);
+
+        r = -1;
+        for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++)
+                r = i2c_master_send(phy->i2c_dev, reboot_cmd,
+                                    sizeof(reboot_cmd));
+        usleep_range(1000, 1500);
+
+}
+
+static int st21nfca_hci_i2c_enable(void *phy_id)
+{
+        struct st21nfca_i2c_phy *phy = phy_id;
+
+        gpio_set_value(phy->gpio_ena, 1);
+        phy->powered = 1;
+        phy->run_mode = ST21NFCA_HCI_MODE;
+
+        usleep_range(10000, 15000);
+
+        return 0;
+}
+
+static void st21nfca_hci_i2c_disable(void *phy_id)
+{
+        struct st21nfca_i2c_phy *phy = phy_id;
+
+        pr_info("\n");
+        gpio_set_value(phy->gpio_ena, 0);
+
+        phy->powered = 0;
+}
+
+static int st21nfca_hci_add_len_crc(struct sk_buff *skb)
+{
+        int ret = 2;
+        u16 crc;
+        u8 tmp;
+
+        *skb_push(skb, 1) = 0;
+
+        crc = crc_ccitt(0xffff, skb->data, skb->len);
+        crc = ~crc;
+
+        tmp = crc & 0x00ff;
+        *skb_put(skb, 1) = tmp;
+
+        tmp = (crc >> 8) & 0x00ff;
+        *skb_put(skb, 1) = tmp;
+
+        return ret;
+}
+
+static void st21nfca_hci_remove_len_crc(struct sk_buff *skb, int crc_len)
+{
+        skb_pull(skb, ST21NFCA_FRAME_HEADROOM);
+        skb_trim(skb, crc_len);
+}
+
+/*
+ * Writing a frame must not return the number of written bytes.
+ * It must return either zero for success, or <0 for error.
+ * In addition, it must not alter the skb
+ */
+static int st21nfca_hci_i2c_write(void *phy_id, struct sk_buff *skb)
+{
+        int r = -1, i, j, len;
+        struct st21nfca_i2c_phy *phy = phy_id;
+        struct i2c_client *client = phy->i2c_dev;
+        u16 wait_tab[] = { 2, 3, 5, 15, 20, 40};
+        u8 tmp[ST21NFCA_HCI_LLC_MAX_SIZE * 2];
+
+        I2C_DUMP_SKB("st21nfca_hci_i2c_write", skb);
+
+
+        if (phy->hard_fault != 0)
+                return phy->hard_fault;
+
+        /*
+         * Compute CRC before byte stuffing computation on frame
+         * Note st21nfca_hci_add_len_crc is doing a byte stuffing
+         * on its own value
+         */
+        len = st21nfca_hci_add_len_crc(skb);
+
+        /* add ST21NFCA_SOF_EOF on tail */
+        *skb_put(skb, 1) = ST21NFCA_SOF_EOF;
+        /* add ST21NFCA_SOF_EOF on head */
+        *skb_push(skb, 1) = ST21NFCA_SOF_EOF;
+
+        /*
+         * Compute byte stuffing
+         * if byte == ST21NFCA_SOF_EOF or ST21NFCA_ESCAPE_BYTE_STUFFING
+         * insert ST21NFCA_ESCAPE_BYTE_STUFFING (escape byte)
+         * xor byte with ST21NFCA_BYTE_STUFFING_MASK
+         */
+        tmp[0] = skb->data[0];
+        for (i = 1, j = 1; i < skb->len - 1; i++, j++) {
+                if (skb->data[i] == ST21NFCA_SOF_EOF
+                    || skb->data[i] == ST21NFCA_ESCAPE_BYTE_STUFFING) {
+                        tmp[j] = ST21NFCA_ESCAPE_BYTE_STUFFING;
+                        j++;
+                        tmp[j] = skb->data[i] ^ ST21NFCA_BYTE_STUFFING_MASK;
+                } else {
+                        tmp[j] = skb->data[i];
+                }
+        }
+        tmp[j] = skb->data[i];
+        j++;
+
+        /*
+         * Manage sleep mode
+         * Try 3 times to send data with delay between each
+         */
+        for (i = 0; i < ARRAY_SIZE(wait_tab) && r < 0; i++) {
+                r = i2c_master_send(client, tmp, j);
+                if (r < 0)
+                        msleep(wait_tab[i]);
+        }
+
+        if (r >= 0) {
+                if (r != j)
+                        r = -EREMOTEIO;
+                else
+                        r = 0;
+        }
+
+        st21nfca_hci_remove_len_crc(skb, len);
+
+        return r;
+}
+
+static int get_frame_size(u8 *buf, int buflen)
+{
+        int len = 0;
+        if (buf[len + 1] == ST21NFCA_SOF_EOF)
+                return 0;
+
+        for (len = 1; len < buflen && buf[len] != ST21NFCA_SOF_EOF; len++)
+                ;
+
+        return len;
+}
+
+static int check_crc(u8 *buf, int buflen)
+{
+        u16 crc;
+
+        crc = crc_ccitt(0xffff, buf, buflen - 2);
+        crc = ~crc;
+
+        if (buf[buflen - 2] != (crc & 0xff) || buf[buflen - 1] != (crc >> 8)) {
+                pr_err(ST21NFCA_HCI_DRIVER_NAME
+                       ": CRC error 0x%x != 0x%x 0x%x\n", crc, buf[buflen - 1],
+                       buf[buflen - 2]);
+
+                pr_info(DRIVER_DESC ": %s : BAD CRC\n", __func__);
+                print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,
+                               16, 2, buf, buflen, false);
+                return -EPERM;
+        }
+        return 0;
+}
+
+/*
+ * Prepare received data for upper layer.
+ * Received data include byte stuffing, crc and sof/eof
+ * which is not usable by hci part.
+ * returns:
+ * frame size without sof/eof, header and byte stuffing
+ * -EBADMSG : frame was incorrect and discarded
+ */
+static int st21nfca_hci_i2c_repack(struct sk_buff *skb)
+{
+        int i, j, r, size;
+        if (skb->len < 1 || (skb->len > 1 && skb->data[1] != 0))
+                return -EBADMSG;
+
+        size = get_frame_size(skb->data, skb->len);
+        if (size > 0) {
+                skb_trim(skb, size);
+                /* remove ST21NFCA byte stuffing for upper layer */
+                for (i = 1, j = 0; i < skb->len; i++) {
+                        if (skb->data[i] ==
+                                        (u8) ST21NFCA_ESCAPE_BYTE_STUFFING) {
+                                skb->data[i] =
+                                    skb->data[i +
+                                              1] | ST21NFCA_BYTE_STUFFING_MASK;
+                                i++;
+                                j++;
+                        }
+                        skb->data[i] = skb->data[i + j];
+                }
+                /* remove byte stuffing useless byte */
+                skb_trim(skb, i - j);
+                /* remove ST21NFCA_SOF_EOF from head */
+                skb_pull(skb, 1);
+
+                r = check_crc(skb->data, skb->len);
+                if (r != 0) {
+                        i = 0;
+                        return -EBADMSG;
+                }
+
+                /* remove headbyte */
+                skb_pull(skb, 1);
+                /* remove crc. Byte Stuffing is already removed here */
+                skb_trim(skb, skb->len - 2);
+                return skb->len;
+        }
+        return 0;
+}
+
+/*
+ * Reads an shdlc frame and returns it in a newly allocated sk_buff. Guarantees
+ * that i2c bus will be flushed and that next read will start on a new frame.
+ * returned skb contains only LLC header and payload.
+ * returns:
+ * frame size : if received frame is complete (find ST21NFCA_SOF_EOF at
+ * end of read)
+ * -EAGAIN : if received frame is incomplete (not find ST21NFCA_SOF_EOF
+ * at end of read)
+ * -EREMOTEIO : i2c read error (fatal)
+ * -EBADMSG : frame was incorrect and discarded
+ * (value returned from st21nfca_hci_i2c_repack)
+ * -EIO : if no ST21NFCA_SOF_EOF is found after reaching
+ * the read length end sequence
+ */
+static int st21nfca_hci_i2c_read(struct st21nfca_i2c_phy *phy,
+                                 struct sk_buff *skb)
+{
+        int r, i;
+        u8 len;
+        struct i2c_client *client = phy->i2c_dev;
+
+        if (phy->current_read_len < ARRAY_SIZE(len_seq)) {
+                len = len_seq[phy->current_read_len];
+
+                /*
+                 * Add retry mecanism
+                 * Operation on I2C interface may fail in case of operation on
+                 * RF or SWP interface
+                 */
+                r = 0;
+                for (i = 0; i < ARRAY_SIZE(wait_tab) && r <= 0; i++) {
+                        r = i2c_master_recv(client, skb_put(skb, len), len);
+                        if (r < 0)
+                                msleep(wait_tab[i]);
+                }
+
+                if (r != len) {
+                        phy->current_read_len = 0;
+                        return -EREMOTEIO;
+                }
+
+                if (memchr(skb->data + 2, ST21NFCA_SOF_EOF,
+                                skb->len - 2) != NULL) {
+                        phy->current_read_len = 0;
+                        return st21nfca_hci_i2c_repack(skb);
+                }
+                phy->current_read_len++;
+                return -EAGAIN;
+        }
+        return -EIO;
+}
+
+/*
+ * Reads an shdlc frame from the chip. This is not as straightforward as it
+ * seems. The frame format is data-crc, and corruption can occur anywhere
+ * while transiting on i2c bus, such that we could read an invalid data.
+ * The tricky case is when we read a corrupted data or crc. We must detect
+ * this here in order to determine that data can be transmitted to the hci
+ * core. This is the reason why we check the crc here.
+ * The CLF will repeat a frame until we send a RR on that frame.
+ *
+ * On ST21NFCA, IRQ goes in idle when read starts. As no size information are
+ * available in the incoming data, other IRQ might come. Every IRQ will trigger
+ * a read sequence with different length and will fill the current frame.
+ * The reception is complete once we reach a ST21NFCA_SOF_EOF.
+ */
+static irqreturn_t st21nfca_hci_irq_thread_fn(int irq, void *phy_id)
+{
+        struct st21nfca_i2c_phy *phy = phy_id;
+        struct i2c_client *client;
+
+        int r;
+
+        if (!phy || irq != phy->i2c_dev->irq) {
+                WARN_ON_ONCE(1);
+                return IRQ_NONE;
+        }
+
+        client = phy->i2c_dev;
+        dev_dbg(&client->dev, "IRQ\n");
+
+        if (phy->hard_fault != 0)
+                return IRQ_HANDLED;
+
+        r = st21nfca_hci_i2c_read(phy, phy->pending_skb);
+        if (r == -EREMOTEIO) {
+                phy->hard_fault = r;
+
+                nfc_hci_recv_frame(phy->hdev, NULL);
+
+                return IRQ_HANDLED;
+        } else if (r == -EAGAIN || r == -EIO) {
+                return IRQ_HANDLED;
+        } else if (r == -EBADMSG && phy->crc_trials < ARRAY_SIZE(wait_tab)) {
+                /*
+                 * With ST21NFCA, only one interface (I2C, RF or SWP)
+                 * may be active at a time.
+                 * Having incorrect crc is usually due to i2c macrocell
+                 * deactivation in the middle of a transmission.
+                 * It may generate corrupted data on i2c.
+                 * We give sometime to get i2c back.
+                 * The complete frame will be repeated.
+                 */
+                msleep(wait_tab[phy->crc_trials]);
+                phy->crc_trials++;
+                phy->current_read_len = 0;
+        } else if (r > 0) {
+                /*
+                 * We succeeded to read data from the CLF and
+                 * data is valid.
+                 * Reset counter.
+                 */
+                nfc_hci_recv_frame(phy->hdev, phy->pending_skb);
+                phy->crc_trials = 0;
+        }
+
+        phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
+        if (phy->pending_skb == NULL) {
+                phy->hard_fault = -ENOMEM;
+                nfc_hci_recv_frame(phy->hdev, NULL);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static struct nfc_phy_ops i2c_phy_ops = {
+        .write = st21nfca_hci_i2c_write,
+        .enable = st21nfca_hci_i2c_enable,
+        .disable = st21nfca_hci_i2c_disable,
+};
+
+static int st21nfca_request_resources(struct st21nfca_i2c_phy *phy,
+                                      struct i2c_client *client)
+{
+        struct st21nfca_nfc_platform_data *pdata;
+        int r;
+
+        pdata = client->dev.platform_data;
+        if (pdata == NULL) {
+                nfc_err(&client->dev, "No platform data\n");
+                return -EINVAL;
+        }
+
+        /* store for later use */
+        phy->gpio_irq = pdata->gpio_irq;
+        phy->gpio_ena = pdata->gpio_ena;
+        phy->irq_polarity = pdata->irq_polarity;
+        phy->i2c_dev = client;
+
+        r = devm_gpio_request(&client->dev, phy->gpio_irq, "wake_up");
+        if (r) {
+                pr_err("%s : gpio_request failed\n", __FILE__);
+                return -ENODEV;
+        }
+
+        r = gpio_direction_input(phy->gpio_irq);
+        if (r) {
+                pr_err("%s : gpio_direction_input failed\n", __FILE__);
+                return -ENODEV;
+        }
+
+        if (phy->gpio_ena != 0) {
+                r = devm_gpio_request(&client->dev,
+                                        phy->gpio_ena, "clf_enable");
+                if (r) {
+                        pr_err("%s : ena gpio_request failed\n", __FILE__);
+                        return -ENODEV;
+                }
+                r = gpio_direction_output(phy->gpio_ena, 1);
+
+                if (r) {
+                        pr_err("%s : ena gpio_direction_output failed\n",
+                               __FILE__);
+                        return -ENODEV;
+                }
+        }
+
+        phy->pending_skb = alloc_skb(ST21NFCA_HCI_LLC_MAX_SIZE * 2, GFP_KERNEL);
+        if (phy->pending_skb == NULL)
+                return -ENOMEM;
+
+        phy->current_read_len = 0;
+        phy->crc_trials = 0;
+        return r;
+}
+
+static int st21nfca_hci_i2c_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct st21nfca_i2c_phy *phy;
+        struct st21nfca_nfc_platform_data *pdata;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s\n", __func__);
+        dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                nfc_err(&client->dev, "Need I2C_FUNC_I2C\n");
+                return -ENODEV;
+        }
+
+        phy = devm_kzalloc(&client->dev, sizeof(struct st21nfca_i2c_phy),
+                           GFP_KERNEL);
+        if (!phy) {
+                nfc_err(&client->dev,
+                        "Cannot allocate memory for st21nfca i2c phy.\n");
+                return -ENOMEM;
+        }
+
+        phy->i2c_dev = client;
+
+        i2c_set_clientdata(client, phy);
+
+        pdata = client->dev.platform_data;
+        if (pdata == NULL) {
+                nfc_err(&client->dev, "No platform data\n");
+                return -EINVAL;
+        }
+
+        r = st21nfca_request_resources(phy, client);
+        if (r) {
+                nfc_err(&client->dev, "Cannot get platform resources\n");
+                return r;
+        }
+
+        st21nfca_hci_platform_init(phy);
+        r = devm_request_threaded_irq(&client->dev, client->irq, NULL,
+                                st21nfca_hci_irq_thread_fn,
+                                phy->irq_polarity | IRQF_ONESHOT,
+                                ST21NFCA_HCI_DRIVER_NAME, phy);
+        if (r < 0) {
+                nfc_err(&client->dev, "Unable to register IRQ handler\n");
+                return r;
+        }
+
+        r = st21nfca_hci_probe(phy, &i2c_phy_ops, LLC_SHDLC_NAME,
+                               ST21NFCA_FRAME_HEADROOM, ST21NFCA_FRAME_TAILROOM,
+                               ST21NFCA_HCI_LLC_MAX_PAYLOAD, &phy->hdev);
+
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+static int st21nfca_hci_i2c_remove(struct i2c_client *client)
+{
+        struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __func__);
+
+        st21nfca_hci_remove(phy->hdev);
+
+        if (phy->powered)
+                st21nfca_hci_i2c_disable(phy);
+
+        return 0;
+}
+
+static struct i2c_driver st21nfca_hci_i2c_driver = {
+        .driver = {
+                   .name = ST21NFCA_HCI_I2C_DRIVER_NAME,
+                   },
+        .probe = st21nfca_hci_i2c_probe,
+        .id_table = st21nfca_hci_i2c_id_table,
+        .remove = st21nfca_hci_i2c_remove,
+};
+
+module_i2c_driver(st21nfca_hci_i2c_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/nfc/st21nfca/st21nfca.c b/drivers/nfc/st21nfca/st21nfca.c
new file mode 100644
index 000000000000..69213f37b7ba
--- /dev/null
+++ b/drivers/nfc/st21nfca/st21nfca.c
@@ -0,0 +1,506 @@
+/*
+ * HCI based Driver for STMicroelectronics NFC Chip
+ *
+ * Copyright (C) 2014  STMicroelectronics SAS. 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/crc-ccitt.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/miscdevice.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+
+#include <linux/nfc.h>
+#include <net/nfc/hci.h>
+#include <net/nfc/llc.h>
+
+#include <uapi/linux/nfc.h>
+
+#include "st21nfca.h"
+#include <linux/platform_data/st21nfca.h>
+
+#define DRIVER_DESC "HCI NFC driver for ST21NFCA"
+
+#define FULL_VERSION_LEN 3
+
+/* Proprietary gates, events, commands and registers */
+
+/* Commands that apply to all RF readers */
+#define ST21NFCA_RF_READER_CMD_PRESENCE_CHECK   0x30
+
+#define ST21NFCA_RF_READER_ISO15693_GATE        0x12
+
+/*
+ * Reader gate for communication with contact-less cards using Type A
+ * protocol ISO14443-3 but not compliant with ISO14443-4
+ */
+#define ST21NFCA_RF_READER_14443_3_A_GATE       0x15
+#define ST21NFCA_RF_READER_14443_3_A_UID        0x02
+#define ST21NFCA_RF_READER_14443_3_A_ATQA       0x03
+#define ST21NFCA_RF_READER_14443_3_A_SAK        0x04
+
+#define ST21NFCA_DEVICE_MGNT_GATE               0x01
+#define ST21NFCA_DEVICE_MGNT_PIPE               0x02
+#define ST21NFCA_NFC_MODE       0x03    /* NFC_MODE parameter*/
+
+
+static DECLARE_BITMAP(dev_mask, ST21NFCA_NUM_DEVICES);
+
+static struct nfc_hci_gate st21nfca_gates[] = {
+        {NFC_HCI_ADMIN_GATE, NFC_HCI_INVALID_PIPE},
+        {NFC_HCI_LOOPBACK_GATE, NFC_HCI_INVALID_PIPE},
+        {NFC_HCI_ID_MGMT_GATE, NFC_HCI_INVALID_PIPE},
+        {NFC_HCI_LINK_MGMT_GATE, NFC_HCI_INVALID_PIPE},
+        {NFC_HCI_RF_READER_B_GATE, NFC_HCI_INVALID_PIPE},
+        {NFC_HCI_RF_READER_A_GATE, NFC_HCI_INVALID_PIPE},
+        {ST21NFCA_DEVICE_MGNT_GATE, ST21NFCA_DEVICE_MGNT_PIPE},
+        {ST21NFCA_RF_READER_F_GATE, NFC_HCI_INVALID_PIPE},
+        {ST21NFCA_RF_READER_14443_3_A_GATE, NFC_HCI_INVALID_PIPE},
+};
+/* Largest headroom needed for outgoing custom commands */
+#define ST21NFCA_CMDS_HEADROOM  7
+
+static int st21nfca_hci_open(struct nfc_hci_dev *hdev)
+{
+        struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
+        int r;
+
+        mutex_lock(&info->info_lock);
+
+        if (info->state != ST21NFCA_ST_COLD) {
+                r = -EBUSY;
+                goto out;
+        }
+
+        r = info->phy_ops->enable(info->phy_id);
+
+        if (r == 0)
+                info->state = ST21NFCA_ST_READY;
+
+out:
+        mutex_unlock(&info->info_lock);
+        return r;
+}
+
+static void st21nfca_hci_close(struct nfc_hci_dev *hdev)
+{
+        struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
+
+        mutex_lock(&info->info_lock);
+
+        if (info->state == ST21NFCA_ST_COLD)
+                goto out;
+
+        info->phy_ops->disable(info->phy_id);
+        info->state = ST21NFCA_ST_COLD;
+
+out:
+        mutex_unlock(&info->info_lock);
+}
+
+static int st21nfca_hci_ready(struct nfc_hci_dev *hdev)
+{
+        struct sk_buff *skb;
+
+        u8 param;
+        int r;
+
+        param = NFC_HCI_UICC_HOST_ID;
+        r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
+                              NFC_HCI_ADMIN_WHITELIST, &param, 1);
+        if (r < 0)
+                return r;
+
+        /* Set NFC_MODE in device management gate to enable */
+        r = nfc_hci_get_param(hdev, ST21NFCA_DEVICE_MGNT_GATE,
+                              ST21NFCA_NFC_MODE, &skb);
+        if (r < 0)
+                return r;
+
+        if (skb->data[0] == 0) {
+                kfree_skb(skb);
+                param = 1;
+
+                r = nfc_hci_set_param(hdev, ST21NFCA_DEVICE_MGNT_GATE,
+                                        ST21NFCA_NFC_MODE, &param, 1);
+                if (r < 0)
+                        return r;
+        }
+
+        r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
+                               NFC_HCI_EVT_END_OPERATION, NULL, 0);
+        if (r < 0)
+                return r;
+
+        r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
+                              NFC_HCI_ID_MGMT_VERSION_SW, &skb);
+        if (r < 0)
+                return r;
+
+        if (skb->len != FULL_VERSION_LEN) {
+                kfree_skb(skb);
+                return -EINVAL;
+        }
+
+        print_hex_dump(KERN_DEBUG, "FULL VERSION SOFTWARE INFO: ",
+                       DUMP_PREFIX_NONE, 16, 1,
+                       skb->data, FULL_VERSION_LEN, false);
+
+        kfree_skb(skb);
+
+        return 0;
+}
+
+static int st21nfca_hci_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
+{
+        struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
+
+        return info->phy_ops->write(info->phy_id, skb);
+}
+
+static int st21nfca_hci_start_poll(struct nfc_hci_dev *hdev,
+                                   u32 im_protocols, u32 tm_protocols)
+{
+        int r;
+
+        pr_info(DRIVER_DESC ": %s protocols 0x%x 0x%x\n",
+                __func__, im_protocols, tm_protocols);
+
+        r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
+                               NFC_HCI_EVT_END_OPERATION, NULL, 0);
+        if (r < 0)
+                return r;
+        if (im_protocols) {
+                /*
+                 * enable polling according to im_protocols & tm_protocols
+                 * - CLOSE pipe according to im_protocols & tm_protocols
+                 */
+                if ((NFC_HCI_RF_READER_B_GATE & im_protocols) == 0) {
+                        r = nfc_hci_disconnect_gate(hdev,
+                                        NFC_HCI_RF_READER_B_GATE);
+                        if (r < 0)
+                                return r;
+                }
+
+                if ((NFC_HCI_RF_READER_A_GATE & im_protocols) == 0) {
+                        r = nfc_hci_disconnect_gate(hdev,
+                                        NFC_HCI_RF_READER_A_GATE);
+                        if (r < 0)
+                                return r;
+                }
+
+                if ((ST21NFCA_RF_READER_F_GATE & im_protocols) == 0) {
+                        r = nfc_hci_disconnect_gate(hdev,
+                                        ST21NFCA_RF_READER_F_GATE);
+                        if (r < 0)
+                                return r;
+                }
+
+                if ((ST21NFCA_RF_READER_14443_3_A_GATE & im_protocols) == 0) {
+                        r = nfc_hci_disconnect_gate(hdev,
+                                        ST21NFCA_RF_READER_14443_3_A_GATE);
+                        if (r < 0)
+                                return r;
+                }
+
+                if ((ST21NFCA_RF_READER_ISO15693_GATE & im_protocols) == 0) {
+                        r = nfc_hci_disconnect_gate(hdev,
+                                        ST21NFCA_RF_READER_ISO15693_GATE);
+                        if (r < 0)
+                                return r;
+                }
+
+                r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
+                                       NFC_HCI_EVT_READER_REQUESTED, NULL, 0);
+                if (r < 0)
+                        nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
+                                           NFC_HCI_EVT_END_OPERATION, NULL, 0);
+        }
+        return r;
+}
+
+static int st21nfca_get_iso14443_3_atqa(struct nfc_hci_dev *hdev, u16 *atqa)
+{
+        int r;
+        struct sk_buff *atqa_skb = NULL;
+
+        r = nfc_hci_get_param(hdev, ST21NFCA_RF_READER_14443_3_A_GATE,
+                              ST21NFCA_RF_READER_14443_3_A_ATQA, &atqa_skb);
+        if (r < 0)
+                goto exit;
+
+        if (atqa_skb->len != 2) {
+                r = -EPROTO;
+                goto exit;
+        }
+
+        *atqa = be16_to_cpu(*(u16 *) atqa_skb->data);
+
+exit:
+        kfree_skb(atqa_skb);
+        return r;
+}
+
+static int st21nfca_get_iso14443_3_sak(struct nfc_hci_dev *hdev, u8 *sak)
+{
+        int r;
+        struct sk_buff *sak_skb = NULL;
+
+        r = nfc_hci_get_param(hdev, ST21NFCA_RF_READER_14443_3_A_GATE,
+                              ST21NFCA_RF_READER_14443_3_A_SAK, &sak_skb);
+        if (r < 0)
+                goto exit;
+
+        if (sak_skb->len != 1) {
+                r = -EPROTO;
+                goto exit;
+        }
+
+        *sak = sak_skb->data[0];
+
+exit:
+        kfree_skb(sak_skb);
+        return r;
+}
+
+static int st21nfca_get_iso14443_3_uid(struct nfc_hci_dev *hdev, u8 *gate,
+                                       int *len)
+{
+        int r;
+        struct sk_buff *uid_skb = NULL;
+
+        r = nfc_hci_get_param(hdev, ST21NFCA_RF_READER_14443_3_A_GATE,
+                              ST21NFCA_RF_READER_14443_3_A_UID, &uid_skb);
+        if (r < 0)
+                goto exit;
+
+        if (uid_skb->len == 0 || uid_skb->len > NFC_NFCID1_MAXSIZE) {
+                r = -EPROTO;
+                goto exit;
+        }
+
+        gate = uid_skb->data;
+        *len = uid_skb->len;
+exit:
+        kfree_skb(uid_skb);
+        return r;
+}
+
+static int st21nfca_hci_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
+                                         struct nfc_target *target)
+{
+        int r, len;
+        u16 atqa;
+        u8 sak;
+        u8 uid[NFC_NFCID1_MAXSIZE];
+
+        switch (gate) {
+        case ST21NFCA_RF_READER_F_GATE:
+                target->supported_protocols = NFC_PROTO_FELICA_MASK;
+                break;
+        case ST21NFCA_RF_READER_14443_3_A_GATE:
+                /* ISO14443-3 type 1 or 2 tags */
+                r = st21nfca_get_iso14443_3_atqa(hdev, &atqa);
+                if (r < 0)
+                        return r;
+                if (atqa == 0x000c) {
+                        target->supported_protocols = NFC_PROTO_JEWEL_MASK;
+                        target->sens_res = 0x0c00;
+                } else {
+                        r = st21nfca_get_iso14443_3_sak(hdev, &sak);
+                        if (r < 0)
+                                return r;
+
+                        r = st21nfca_get_iso14443_3_uid(hdev, uid, &len);
+                        if (r < 0)
+                                return r;
+
+                        target->supported_protocols =
+                            nfc_hci_sak_to_protocol(sak);
+                        if (target->supported_protocols == 0xffffffff)
+                                return -EPROTO;
+
+                        target->sens_res = atqa;
+                        target->sel_res = sak;
+                        memcpy(target->nfcid1, uid, len);
+                        target->nfcid1_len = len;
+                }
+
+                break;
+        default:
+                return -EPROTO;
+        }
+
+        return 0;
+}
+
+/*
+ * Returns:
+ * <= 0: driver handled the data exchange
+ *    1: driver doesn't especially handle, please do standard processing
+ */
+static int st21nfca_hci_im_transceive(struct nfc_hci_dev *hdev,
+                                      struct nfc_target *target,
+                                      struct sk_buff *skb,
+                                      data_exchange_cb_t cb, void *cb_context)
+{
+        pr_info(DRIVER_DESC ": %s for gate=%d len=%d\n", __func__,
+                target->hci_reader_gate, skb->len);
+
+        switch (target->hci_reader_gate) {
+        case ST21NFCA_RF_READER_F_GATE:
+                *skb_push(skb, 1) = 0x1a;
+                return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
+                                              ST21NFCA_WR_XCHG_DATA, skb->data,
+                                              skb->len, cb, cb_context);
+        case ST21NFCA_RF_READER_14443_3_A_GATE:
+                *skb_push(skb, 1) = 0x1a;       /* CTR, see spec:10.2.2.1 */
+
+                return nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
+                                              ST21NFCA_WR_XCHG_DATA, skb->data,
+                                              skb->len, cb, cb_context);
+        default:
+                return 1;
+        }
+}
+
+static int st21nfca_hci_check_presence(struct nfc_hci_dev *hdev,
+                                       struct nfc_target *target)
+{
+        u8 fwi = 0x11;
+        switch (target->hci_reader_gate) {
+        case NFC_HCI_RF_READER_A_GATE:
+        case NFC_HCI_RF_READER_B_GATE:
+                /*
+                 * PRESENCE_CHECK on those gates is available
+                 * However, the answer to this command is taking 3 * fwi
+                 * if the card is no present.
+                 * Instead, we send an empty I-Frame with a very short
+                 * configurable fwi ~604µs.
+                 */
+                return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
+                                        ST21NFCA_WR_XCHG_DATA, &fwi, 1, NULL);
+        case ST21NFCA_RF_READER_14443_3_A_GATE:
+                return nfc_hci_send_cmd(hdev, target->hci_reader_gate,
+                                        ST21NFCA_RF_READER_CMD_PRESENCE_CHECK,
+                                        NULL, 0, NULL);
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+static struct nfc_hci_ops st21nfca_hci_ops = {
+        .open = st21nfca_hci_open,
+        .close = st21nfca_hci_close,
+        .hci_ready = st21nfca_hci_ready,
+        .xmit = st21nfca_hci_xmit,
+        .start_poll = st21nfca_hci_start_poll,
+        .target_from_gate = st21nfca_hci_target_from_gate,
+        .im_transceive = st21nfca_hci_im_transceive,
+        .check_presence = st21nfca_hci_check_presence,
+};
+
+int st21nfca_hci_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 st21nfca_hci_info *info;
+        int r = 0;
+        int dev_num;
+        u32 protocols;
+        struct nfc_hci_init_data init_data;
+        unsigned long quirks = 0;
+
+        info = kzalloc(sizeof(struct st21nfca_hci_info), GFP_KERNEL);
+        if (!info) {
+                r = -ENOMEM;
+                goto err_alloc_hdev;
+        }
+
+        info->phy_ops = phy_ops;
+        info->phy_id = phy_id;
+        info->state = ST21NFCA_ST_COLD;
+        mutex_init(&info->info_lock);
+
+        init_data.gate_count = ARRAY_SIZE(st21nfca_gates);
+
+        memcpy(init_data.gates, st21nfca_gates, sizeof(st21nfca_gates));
+
+        /*
+         * Session id must include the driver name + i2c bus addr
+         * persistent info to discriminate 2 identical chips
+         */
+        dev_num = find_first_zero_bit(dev_mask, ST21NFCA_NUM_DEVICES);
+        if (dev_num >= ST21NFCA_NUM_DEVICES)
+                goto err_alloc_hdev;
+
+        scnprintf(init_data.session_id, sizeof(init_data.session_id), "%s%2x",
+                  "ST21AH", dev_num);
+
+        protocols = NFC_PROTO_JEWEL_MASK |
+            NFC_PROTO_MIFARE_MASK |
+            NFC_PROTO_FELICA_MASK |
+            NFC_PROTO_ISO14443_MASK |
+            NFC_PROTO_ISO14443_B_MASK;
+
+        set_bit(NFC_HCI_QUIRK_SHORT_CLEAR, &quirks);
+
+        info->hdev =
+            nfc_hci_allocate_device(&st21nfca_hci_ops, &init_data, quirks,
+                                    protocols, llc_name,
+                                    phy_headroom + ST21NFCA_CMDS_HEADROOM,
+                                    phy_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);
+
+        return r;
+}
+EXPORT_SYMBOL(st21nfca_hci_probe);
+
+void st21nfca_hci_remove(struct nfc_hci_dev *hdev)
+{
+        struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
+
+        nfc_hci_unregister_device(hdev);
+        nfc_hci_free_device(hdev);
+        kfree(info);
+}
+EXPORT_SYMBOL(st21nfca_hci_remove);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/nfc/st21nfca/st21nfca.h b/drivers/nfc/st21nfca/st21nfca.h
new file mode 100644
index 000000000000..334cd90bcc8c
--- /dev/null
+++ b/drivers/nfc/st21nfca/st21nfca.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2014  STMicroelectronics SAS. 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __LOCAL_ST21NFCA_H_
+#define __LOCAL_ST21NFCA_H_
+
+#include <net/nfc/hci.h>
+
+#define HCI_MODE 0
+
+/* framing in HCI mode */
+#define ST21NFCA_SOF_EOF_LEN    2
+
+/* Almost every time value is 0 */
+#define ST21NFCA_HCI_LLC_LEN    1
+
+/* Size in worst case :
+ * In normal case CRC len = 2 but byte stuffing
+ * may appear in case one CRC byte = ST21NFCA_SOF_EOF
+ */
+#define ST21NFCA_HCI_LLC_CRC    4
+
+#define ST21NFCA_HCI_LLC_LEN_CRC        (ST21NFCA_SOF_EOF_LEN + \
+                                                ST21NFCA_HCI_LLC_LEN + \
+                                                ST21NFCA_HCI_LLC_CRC)
+#define ST21NFCA_HCI_LLC_MIN_SIZE       (1 + ST21NFCA_HCI_LLC_LEN_CRC)
+
+/* Worst case when adding byte stuffing between each byte */
+#define ST21NFCA_HCI_LLC_MAX_PAYLOAD    29
+#define ST21NFCA_HCI_LLC_MAX_SIZE       (ST21NFCA_HCI_LLC_LEN_CRC + 1 + \
+                                        ST21NFCA_HCI_LLC_MAX_PAYLOAD)
+
+#define DRIVER_DESC "HCI NFC driver for ST21NFCA"
+
+#define ST21NFCA_HCI_MODE 0
+
+#define ST21NFCA_NUM_DEVICES 256
+
+int st21nfca_hci_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);
+void st21nfca_hci_remove(struct nfc_hci_dev *hdev);
+
+enum st21nfca_state {
+        ST21NFCA_ST_COLD,
+        ST21NFCA_ST_READY,
+};
+
+struct st21nfca_hci_info {
+        struct nfc_phy_ops *phy_ops;
+        void *phy_id;
+
+        struct nfc_hci_dev *hdev;
+
+        enum st21nfca_state state;
+
+        struct mutex info_lock;
+
+        int async_cb_type;
+        data_exchange_cb_t async_cb;
+        void *async_cb_context;
+
+} __packed;
+
+/* Reader RF commands */
+#define ST21NFCA_WR_XCHG_DATA            0x10
+
+#define ST21NFCA_RF_READER_F_GATE               0x14
+#define ST21NFCA_RF_READER_F_DATARATE 0x01
+#define ST21NFCA_RF_READER_F_DATARATE_106 0x01
+#define ST21NFCA_RF_READER_F_DATARATE_212 0x02
+#define ST21NFCA_RF_READER_F_DATARATE_424 0x04
+
+#endif /* __LOCAL_ST21NFCA_H_ */