Merge branch 'osd-devel' into nfs-for-next

13 files changed, 1792 insertions, 10 deletions

diff --git a/net/nfc/Kconfig b/net/nfc/Kconfig
index 33e095b124b3..58cddadf8e8e 100644
--- a/net/nfc/Kconfig
+++ b/net/nfc/Kconfig
@@ -13,4 +13,6 @@ menuconfig NFC
           To compile this support as a module, choose M here: the module will
           be called nfc.
 
+source "net/nfc/nci/Kconfig"
+
 source "drivers/nfc/Kconfig"
diff --git a/net/nfc/Makefile b/net/nfc/Makefile
index 16250c353851..fbb550f2377b 100644
--- a/net/nfc/Makefile
+++ b/net/nfc/Makefile
@@ -3,5 +3,6 @@
 #
 
 obj-$(CONFIG_NFC) += nfc.o
+obj-$(CONFIG_NFC_NCI) += nci/
 
 nfc-objs := core.o netlink.o af_nfc.o rawsock.o
diff --git a/net/nfc/core.c b/net/nfc/core.c
index b6fd4e1f2057..47e02c1b8c02 100644
--- a/net/nfc/core.c
+++ b/net/nfc/core.c
@@ -53,6 +53,80 @@ int nfc_printk(const char *level, const char *format, ...)
 EXPORT_SYMBOL(nfc_printk);
 
 /**
+ * nfc_dev_up - turn on the NFC device
+ *
+ * @dev: The nfc device to be turned on
+ *
+ * The device remains up until the nfc_dev_down function is called.
+ */
+int nfc_dev_up(struct nfc_dev *dev)
+{
+        int rc = 0;
+
+        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+
+        device_lock(&dev->dev);
+
+        if (!device_is_registered(&dev->dev)) {
+                rc = -ENODEV;
+                goto error;
+        }
+
+        if (dev->dev_up) {
+                rc = -EALREADY;
+                goto error;
+        }
+
+        if (dev->ops->dev_up)
+                rc = dev->ops->dev_up(dev);
+
+        if (!rc)
+                dev->dev_up = true;
+
+error:
+        device_unlock(&dev->dev);
+        return rc;
+}
+
+/**
+ * nfc_dev_down - turn off the NFC device
+ *
+ * @dev: The nfc device to be turned off
+ */
+int nfc_dev_down(struct nfc_dev *dev)
+{
+        int rc = 0;
+
+        nfc_dbg("dev_name=%s", dev_name(&dev->dev));
+
+        device_lock(&dev->dev);
+
+        if (!device_is_registered(&dev->dev)) {
+                rc = -ENODEV;
+                goto error;
+        }
+
+        if (!dev->dev_up) {
+                rc = -EALREADY;
+                goto error;
+        }
+
+        if (dev->polling || dev->remote_activated) {
+                rc = -EBUSY;
+                goto error;
+        }
+
+        if (dev->ops->dev_down)
+                dev->ops->dev_down(dev);
+
+        dev->dev_up = false;
+
+error:
+        device_unlock(&dev->dev);
+        return rc;
+}
+
+/**
  * nfc_start_poll - start polling for nfc targets
  *
  * @dev: The nfc device that must start polling
@@ -144,6 +218,8 @@ int nfc_activate_target(struct nfc_dev *dev, u32 target_idx, u32 protocol)
         }
 
         rc = dev->ops->activate_target(dev, target_idx, protocol);
+        if (!rc)
+                dev->remote_activated = true;
 
 error:
         device_unlock(&dev->dev);
@@ -170,6 +246,7 @@ int nfc_deactivate_target(struct nfc_dev *dev, u32 target_idx)
         }
 
         dev->ops->deactivate_target(dev, target_idx);
+        dev->remote_activated = false;
 
 error:
         device_unlock(&dev->dev);
@@ -322,7 +399,9 @@ struct nfc_dev *nfc_get_device(unsigned idx)
  * @supported_protocols: NFC protocols supported by the device
  */
 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
-                                        u32 supported_protocols)
+                                        u32 supported_protocols,
+                                        int tx_headroom,
+                                        int tx_tailroom)
 {
         static atomic_t dev_no = ATOMIC_INIT(0);
         struct nfc_dev *dev;
@@ -345,6 +424,8 @@ struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
 
         dev->ops = ops;
         dev->supported_protocols = supported_protocols;
+        dev->tx_headroom = tx_headroom;
+        dev->tx_tailroom = tx_tailroom;
 
         spin_lock_init(&dev->targets_lock);
         nfc_genl_data_init(&dev->genl_data);
diff --git a/net/nfc/nci/Kconfig b/net/nfc/nci/Kconfig
new file mode 100644
index 000000000000..decdc49b26d8
--- /dev/null
+++ b/net/nfc/nci/Kconfig
@@ -0,0 +1,10 @@
+config NFC_NCI
+        depends on NFC && EXPERIMENTAL
+        tristate "NCI protocol support (EXPERIMENTAL)"
+        default n
+        help
+          NCI (NFC Controller Interface) is a communication protocol between
+          an NFC Controller (NFCC) and a Device Host (DH).
+
+          Say Y here to compile NCI support into the kernel or say M to
+          compile it as module (nci).
diff --git a/net/nfc/nci/Makefile b/net/nfc/nci/Makefile
new file mode 100644
index 000000000000..cdb3a2e44471
--- /dev/null
+++ b/net/nfc/nci/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the Linux NFC NCI layer.
+#
+
+obj-$(CONFIG_NFC_NCI) += nci.o
+
+nci-objs := core.o data.o lib.o ntf.o rsp.o
\ No newline at end of file
diff --git a/net/nfc/nci/core.c b/net/nfc/nci/core.c
new file mode 100644
index 000000000000..4047e29acb3b
--- /dev/null
+++ b/net/nfc/nci/core.c
@@ -0,0 +1,797 @@
+/*
+ *  The NFC Controller Interface is the communication protocol between an
+ *  NFC Controller (NFCC) and a Device Host (DH).
+ *
+ *  Copyright (C) 2011 Texas Instruments, Inc.
+ *
+ *  Written by Ilan Elias <ilane@ti.com>
+ *
+ *  Acknowledgements:
+ *  This file is based on hci_core.c, which was written
+ *  by Maxim Krasnyansky.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms 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/types.h>
+#include <linux/workqueue.h>
+#include <linux/completion.h>
+#include <linux/sched.h>
+#include <linux/bitops.h>
+#include <linux/skbuff.h>
+
+#include "../nfc.h"
+#include <net/nfc/nci.h>
+#include <net/nfc/nci_core.h>
+#include <linux/nfc.h>
+
+static void nci_cmd_work(struct work_struct *work);
+static void nci_rx_work(struct work_struct *work);
+static void nci_tx_work(struct work_struct *work);
+
+/* ---- NCI requests ---- */
+
+void nci_req_complete(struct nci_dev *ndev, int result)
+{
+        if (ndev->req_status == NCI_REQ_PEND) {
+                ndev->req_result = result;
+                ndev->req_status = NCI_REQ_DONE;
+                complete(&ndev->req_completion);
+        }
+}
+
+static void nci_req_cancel(struct nci_dev *ndev, int err)
+{
+        if (ndev->req_status == NCI_REQ_PEND) {
+                ndev->req_result = err;
+                ndev->req_status = NCI_REQ_CANCELED;
+                complete(&ndev->req_completion);
+        }
+}
+
+/* Execute request and wait for completion. */
+static int __nci_request(struct nci_dev *ndev,
+        void (*req)(struct nci_dev *ndev, unsigned long opt),
+        unsigned long opt,
+        __u32 timeout)
+{
+        int rc = 0;
+        unsigned long completion_rc;
+
+        ndev->req_status = NCI_REQ_PEND;
+
+        init_completion(&ndev->req_completion);
+        req(ndev, opt);
+        completion_rc = wait_for_completion_interruptible_timeout(
+                                                        &ndev->req_completion,
+                                                        timeout);
+
+        nfc_dbg("wait_for_completion return %ld", completion_rc);
+
+        if (completion_rc > 0) {
+                switch (ndev->req_status) {
+                case NCI_REQ_DONE:
+                        rc = nci_to_errno(ndev->req_result);
+                        break;
+
+                case NCI_REQ_CANCELED:
+                        rc = -ndev->req_result;
+                        break;
+
+                default:
+                        rc = -ETIMEDOUT;
+                        break;
+                }
+        } else {
+                nfc_err("wait_for_completion_interruptible_timeout failed %ld",
+                        completion_rc);
+
+                rc = ((completion_rc == 0) ? (-ETIMEDOUT) : (completion_rc));
+        }
+
+        ndev->req_status = ndev->req_result = 0;
+
+        return rc;
+}
+
+static inline int nci_request(struct nci_dev *ndev,
+                void (*req)(struct nci_dev *ndev, unsigned long opt),
+                unsigned long opt, __u32 timeout)
+{
+        int rc;
+
+        if (!test_bit(NCI_UP, &ndev->flags))
+                return -ENETDOWN;
+
+        /* Serialize all requests */
+        mutex_lock(&ndev->req_lock);
+        rc = __nci_request(ndev, req, opt, timeout);
+        mutex_unlock(&ndev->req_lock);
+
+        return rc;
+}
+
+static void nci_reset_req(struct nci_dev *ndev, unsigned long opt)
+{
+        nci_send_cmd(ndev, NCI_OP_CORE_RESET_CMD, 0, NULL);
+}
+
+static void nci_init_req(struct nci_dev *ndev, unsigned long opt)
+{
+        nci_send_cmd(ndev, NCI_OP_CORE_INIT_CMD, 0, NULL);
+}
+
+static void nci_init_complete_req(struct nci_dev *ndev, unsigned long opt)
+{
+        struct nci_core_conn_create_cmd conn_cmd;
+        struct nci_rf_disc_map_cmd cmd;
+        struct disc_map_config *cfg = cmd.mapping_configs;
+        __u8 *num = &cmd.num_mapping_configs;
+        int i;
+
+        /* create static rf connection */
+        conn_cmd.target_handle = 0;
+        conn_cmd.num_target_specific_params = 0;
+        nci_send_cmd(ndev, NCI_OP_CORE_CONN_CREATE_CMD, 2, &conn_cmd);
+
+        /* set rf mapping configurations */
+        *num = 0;
+
+        /* by default mapping is set to NCI_RF_INTERFACE_FRAME */
+        for (i = 0; i < ndev->num_supported_rf_interfaces; i++) {
+                if (ndev->supported_rf_interfaces[i] ==
+                        NCI_RF_INTERFACE_ISO_DEP) {
+                        cfg[*num].rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
+                        cfg[*num].mode = NCI_DISC_MAP_MODE_BOTH;
+                        cfg[*num].rf_interface_type = NCI_RF_INTERFACE_ISO_DEP;
+                        (*num)++;
+                } else if (ndev->supported_rf_interfaces[i] ==
+                        NCI_RF_INTERFACE_NFC_DEP) {
+                        cfg[*num].rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
+                        cfg[*num].mode = NCI_DISC_MAP_MODE_BOTH;
+                        cfg[*num].rf_interface_type = NCI_RF_INTERFACE_NFC_DEP;
+                        (*num)++;
+                }
+
+                if (*num == NCI_MAX_NUM_MAPPING_CONFIGS)
+                        break;
+        }
+
+        nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_MAP_CMD,
+                (1 + ((*num)*sizeof(struct disc_map_config))),
+                &cmd);
+}
+
+static void nci_rf_discover_req(struct nci_dev *ndev, unsigned long opt)
+{
+        struct nci_rf_disc_cmd cmd;
+        __u32 protocols = opt;
+
+        cmd.num_disc_configs = 0;
+
+        if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
+                (protocols & NFC_PROTO_JEWEL_MASK
+                || protocols & NFC_PROTO_MIFARE_MASK
+                || protocols & NFC_PROTO_ISO14443_MASK
+                || protocols & NFC_PROTO_NFC_DEP_MASK)) {
+                cmd.disc_configs[cmd.num_disc_configs].type =
+                NCI_DISCOVERY_TYPE_POLL_A_PASSIVE;
+                cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
+                cmd.num_disc_configs++;
+        }
+
+        if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
+                (protocols & NFC_PROTO_ISO14443_MASK)) {
+                cmd.disc_configs[cmd.num_disc_configs].type =
+                NCI_DISCOVERY_TYPE_POLL_B_PASSIVE;
+                cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
+                cmd.num_disc_configs++;
+        }
+
+        if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
+                (protocols & NFC_PROTO_FELICA_MASK
+                || protocols & NFC_PROTO_NFC_DEP_MASK)) {
+                cmd.disc_configs[cmd.num_disc_configs].type =
+                NCI_DISCOVERY_TYPE_POLL_F_PASSIVE;
+                cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
+                cmd.num_disc_configs++;
+        }
+
+        nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_CMD,
+                (1 + (cmd.num_disc_configs*sizeof(struct disc_config))),
+                &cmd);
+}
+
+static void nci_rf_deactivate_req(struct nci_dev *ndev, unsigned long opt)
+{
+        struct nci_rf_deactivate_cmd cmd;
+
+        cmd.type = NCI_DEACTIVATE_TYPE_IDLE_MODE;
+
+        nci_send_cmd(ndev, NCI_OP_RF_DEACTIVATE_CMD,
+                        sizeof(struct nci_rf_deactivate_cmd),
+                        &cmd);
+}
+
+static int nci_open_device(struct nci_dev *ndev)
+{
+        int rc = 0;
+
+        mutex_lock(&ndev->req_lock);
+
+        if (test_bit(NCI_UP, &ndev->flags)) {
+                rc = -EALREADY;
+                goto done;
+        }
+
+        if (ndev->ops->open(ndev)) {
+                rc = -EIO;
+                goto done;
+        }
+
+        atomic_set(&ndev->cmd_cnt, 1);
+
+        set_bit(NCI_INIT, &ndev->flags);
+
+        rc = __nci_request(ndev, nci_reset_req, 0,
+                                msecs_to_jiffies(NCI_RESET_TIMEOUT));
+
+        if (!rc) {
+                rc = __nci_request(ndev, nci_init_req, 0,
+                                msecs_to_jiffies(NCI_INIT_TIMEOUT));
+        }
+
+        if (!rc) {
+                rc = __nci_request(ndev, nci_init_complete_req, 0,
+                                msecs_to_jiffies(NCI_INIT_TIMEOUT));
+        }
+
+        clear_bit(NCI_INIT, &ndev->flags);
+
+        if (!rc) {
+                set_bit(NCI_UP, &ndev->flags);
+        } else {
+                /* Init failed, cleanup */
+                skb_queue_purge(&ndev->cmd_q);
+                skb_queue_purge(&ndev->rx_q);
+                skb_queue_purge(&ndev->tx_q);
+
+                ndev->ops->close(ndev);
+                ndev->flags = 0;
+        }
+
+done:
+        mutex_unlock(&ndev->req_lock);
+        return rc;
+}
+
+static int nci_close_device(struct nci_dev *ndev)
+{
+        nci_req_cancel(ndev, ENODEV);
+        mutex_lock(&ndev->req_lock);
+
+        if (!test_and_clear_bit(NCI_UP, &ndev->flags)) {
+                del_timer_sync(&ndev->cmd_timer);
+                mutex_unlock(&ndev->req_lock);
+                return 0;
+        }
+
+        /* Drop RX and TX queues */
+        skb_queue_purge(&ndev->rx_q);
+        skb_queue_purge(&ndev->tx_q);
+
+        /* Flush RX and TX wq */
+        flush_workqueue(ndev->rx_wq);
+        flush_workqueue(ndev->tx_wq);
+
+        /* Reset device */
+        skb_queue_purge(&ndev->cmd_q);
+        atomic_set(&ndev->cmd_cnt, 1);
+
+        set_bit(NCI_INIT, &ndev->flags);
+        __nci_request(ndev, nci_reset_req, 0,
+                                msecs_to_jiffies(NCI_RESET_TIMEOUT));
+        clear_bit(NCI_INIT, &ndev->flags);
+
+        /* Flush cmd wq */
+        flush_workqueue(ndev->cmd_wq);
+
+        /* After this point our queues are empty
+         * and no works are scheduled. */
+        ndev->ops->close(ndev);
+
+        /* Clear flags */
+        ndev->flags = 0;
+
+        mutex_unlock(&ndev->req_lock);
+
+        return 0;
+}
+
+/* NCI command timer function */
+static void nci_cmd_timer(unsigned long arg)
+{
+        struct nci_dev *ndev = (void *) arg;
+
+        nfc_dbg("entry");
+
+        atomic_set(&ndev->cmd_cnt, 1);
+        queue_work(ndev->cmd_wq, &ndev->cmd_work);
+}
+
+static int nci_dev_up(struct nfc_dev *nfc_dev)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+
+        nfc_dbg("entry");
+
+        return nci_open_device(ndev);
+}
+
+static int nci_dev_down(struct nfc_dev *nfc_dev)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+
+        nfc_dbg("entry");
+
+        return nci_close_device(ndev);
+}
+
+static int nci_start_poll(struct nfc_dev *nfc_dev, __u32 protocols)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+        int rc;
+
+        nfc_dbg("entry");
+
+        if (test_bit(NCI_DISCOVERY, &ndev->flags)) {
+                nfc_err("unable to start poll, since poll is already active");
+                return -EBUSY;
+        }
+
+        if (ndev->target_active_prot) {
+                nfc_err("there is an active target");
+                return -EBUSY;
+        }
+
+        if (test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
+                nfc_dbg("target is active, implicitly deactivate...");
+
+                rc = nci_request(ndev, nci_rf_deactivate_req, 0,
+                        msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
+                if (rc)
+                        return -EBUSY;
+        }
+
+        rc = nci_request(ndev, nci_rf_discover_req, protocols,
+                msecs_to_jiffies(NCI_RF_DISC_TIMEOUT));
+
+        if (!rc)
+                ndev->poll_prots = protocols;
+
+        return rc;
+}
+
+static void nci_stop_poll(struct nfc_dev *nfc_dev)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+
+        nfc_dbg("entry");
+
+        if (!test_bit(NCI_DISCOVERY, &ndev->flags)) {
+                nfc_err("unable to stop poll, since poll is not active");
+                return;
+        }
+
+        nci_request(ndev, nci_rf_deactivate_req, 0,
+                msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
+}
+
+static int nci_activate_target(struct nfc_dev *nfc_dev, __u32 target_idx,
+                                __u32 protocol)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+
+        nfc_dbg("entry, target_idx %d, protocol 0x%x", target_idx, protocol);
+
+        if (!test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
+                nfc_err("there is no available target to activate");
+                return -EINVAL;
+        }
+
+        if (ndev->target_active_prot) {
+                nfc_err("there is already an active target");
+                return -EBUSY;
+        }
+
+        if (!(ndev->target_available_prots & (1 << protocol))) {
+                nfc_err("target does not support the requested protocol 0x%x",
+                        protocol);
+                return -EINVAL;
+        }
+
+        ndev->target_active_prot = protocol;
+        ndev->target_available_prots = 0;
+
+        return 0;
+}
+
+static void nci_deactivate_target(struct nfc_dev *nfc_dev, __u32 target_idx)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+
+        nfc_dbg("entry, target_idx %d", target_idx);
+
+        if (!ndev->target_active_prot) {
+                nfc_err("unable to deactivate target, no active target");
+                return;
+        }
+
+        ndev->target_active_prot = 0;
+
+        if (test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
+                nci_request(ndev, nci_rf_deactivate_req, 0,
+                        msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
+        }
+}
+
+static int nci_data_exchange(struct nfc_dev *nfc_dev, __u32 target_idx,
+                                                struct sk_buff *skb,
+                                                data_exchange_cb_t cb,
+                                                void *cb_context)
+{
+        struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
+        int rc;
+
+        nfc_dbg("entry, target_idx %d, len %d", target_idx, skb->len);
+
+        if (!ndev->target_active_prot) {
+                nfc_err("unable to exchange data, no active target");
+                return -EINVAL;
+        }
+
+        if (test_and_set_bit(NCI_DATA_EXCHANGE, &ndev->flags))
+                return -EBUSY;
+
+        /* store cb and context to be used on receiving data */
+        ndev->data_exchange_cb = cb;
+        ndev->data_exchange_cb_context = cb_context;
+
+        rc = nci_send_data(ndev, ndev->conn_id, skb);
+        if (rc)
+                clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
+
+        return rc;
+}
+
+static struct nfc_ops nci_nfc_ops = {
+        .dev_up = nci_dev_up,
+        .dev_down = nci_dev_down,
+        .start_poll = nci_start_poll,
+        .stop_poll = nci_stop_poll,
+        .activate_target = nci_activate_target,
+        .deactivate_target = nci_deactivate_target,
+        .data_exchange = nci_data_exchange,
+};
+
+/* ---- Interface to NCI drivers ---- */
+
+/**
+ * nci_allocate_device - allocate a new nci device
+ *
+ * @ops: device operations
+ * @supported_protocols: NFC protocols supported by the device
+ */
+struct nci_dev *nci_allocate_device(struct nci_ops *ops,
+                                        __u32 supported_protocols,
+                                        int tx_headroom,
+                                        int tx_tailroom)
+{
+        struct nci_dev *ndev;
+
+        nfc_dbg("entry, supported_protocols 0x%x", supported_protocols);
+
+        if (!ops->open || !ops->close || !ops->send)
+                return NULL;
+
+        if (!supported_protocols)
+                return NULL;
+
+        ndev = kzalloc(sizeof(struct nci_dev), GFP_KERNEL);
+        if (!ndev)
+                return NULL;
+
+        ndev->ops = ops;
+        ndev->tx_headroom = tx_headroom;
+        ndev->tx_tailroom = tx_tailroom;
+
+        ndev->nfc_dev = nfc_allocate_device(&nci_nfc_ops,
+                                                supported_protocols,
+                                                tx_headroom + NCI_DATA_HDR_SIZE,
+                                                tx_tailroom);
+        if (!ndev->nfc_dev)
+                goto free_exit;
+
+        nfc_set_drvdata(ndev->nfc_dev, ndev);
+
+        return ndev;
+
+free_exit:
+        kfree(ndev);
+        return NULL;
+}
+EXPORT_SYMBOL(nci_allocate_device);
+
+/**
+ * nci_free_device - deallocate nci device
+ *
+ * @ndev: The nci device to deallocate
+ */
+void nci_free_device(struct nci_dev *ndev)
+{
+        nfc_dbg("entry");
+
+        nfc_free_device(ndev->nfc_dev);
+        kfree(ndev);
+}
+EXPORT_SYMBOL(nci_free_device);
+
+/**
+ * nci_register_device - register a nci device in the nfc subsystem
+ *
+ * @dev: The nci device to register
+ */
+int nci_register_device(struct nci_dev *ndev)
+{
+        int rc;
+        struct device *dev = &ndev->nfc_dev->dev;
+        char name[32];
+
+        nfc_dbg("entry");
+
+        rc = nfc_register_device(ndev->nfc_dev);
+        if (rc)
+                goto exit;
+
+        ndev->flags = 0;
+
+        INIT_WORK(&ndev->cmd_work, nci_cmd_work);
+        snprintf(name, sizeof(name), "%s_nci_cmd_wq", dev_name(dev));
+        ndev->cmd_wq = create_singlethread_workqueue(name);
+        if (!ndev->cmd_wq) {
+                rc = -ENOMEM;
+                goto unreg_exit;
+        }
+
+        INIT_WORK(&ndev->rx_work, nci_rx_work);
+        snprintf(name, sizeof(name), "%s_nci_rx_wq", dev_name(dev));
+        ndev->rx_wq = create_singlethread_workqueue(name);
+        if (!ndev->rx_wq) {
+                rc = -ENOMEM;
+                goto destroy_cmd_wq_exit;
+        }
+
+        INIT_WORK(&ndev->tx_work, nci_tx_work);
+        snprintf(name, sizeof(name), "%s_nci_tx_wq", dev_name(dev));
+        ndev->tx_wq = create_singlethread_workqueue(name);
+        if (!ndev->tx_wq) {
+                rc = -ENOMEM;
+                goto destroy_rx_wq_exit;
+        }
+
+        skb_queue_head_init(&ndev->cmd_q);
+        skb_queue_head_init(&ndev->rx_q);
+        skb_queue_head_init(&ndev->tx_q);
+
+        setup_timer(&ndev->cmd_timer, nci_cmd_timer,
+                        (unsigned long) ndev);
+
+        mutex_init(&ndev->req_lock);
+
+        goto exit;
+
+destroy_rx_wq_exit:
+        destroy_workqueue(ndev->rx_wq);
+
+destroy_cmd_wq_exit:
+        destroy_workqueue(ndev->cmd_wq);
+
+unreg_exit:
+        nfc_unregister_device(ndev->nfc_dev);
+
+exit:
+        return rc;
+}
+EXPORT_SYMBOL(nci_register_device);
+
+/**
+ * nci_unregister_device - unregister a nci device in the nfc subsystem
+ *
+ * @dev: The nci device to unregister
+ */
+void nci_unregister_device(struct nci_dev *ndev)
+{
+        nfc_dbg("entry");
+
+        nci_close_device(ndev);
+
+        destroy_workqueue(ndev->cmd_wq);
+        destroy_workqueue(ndev->rx_wq);
+        destroy_workqueue(ndev->tx_wq);
+
+        nfc_unregister_device(ndev->nfc_dev);
+}
+EXPORT_SYMBOL(nci_unregister_device);
+
+/**
+ * nci_recv_frame - receive frame from NCI drivers
+ *
+ * @skb: The sk_buff to receive
+ */
+int nci_recv_frame(struct sk_buff *skb)
+{
+        struct nci_dev *ndev = (struct nci_dev *) skb->dev;
+
+        nfc_dbg("entry, len %d", skb->len);
+
+        if (!ndev || (!test_bit(NCI_UP, &ndev->flags)
+                && !test_bit(NCI_INIT, &ndev->flags))) {
+                kfree_skb(skb);
+                return -ENXIO;
+        }
+
+        /* Queue frame for rx worker thread */
+        skb_queue_tail(&ndev->rx_q, skb);
+        queue_work(ndev->rx_wq, &ndev->rx_work);
+
+        return 0;
+}
+EXPORT_SYMBOL(nci_recv_frame);
+
+static int nci_send_frame(struct sk_buff *skb)
+{
+        struct nci_dev *ndev = (struct nci_dev *) skb->dev;
+
+        nfc_dbg("entry, len %d", skb->len);
+
+        if (!ndev) {
+                kfree_skb(skb);
+                return -ENODEV;
+        }
+
+        /* Get rid of skb owner, prior to sending to the driver. */
+        skb_orphan(skb);
+
+        return ndev->ops->send(skb);
+}
+
+/* Send NCI command */
+int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload)
+{
+        struct nci_ctrl_hdr *hdr;
+        struct sk_buff *skb;
+
+        nfc_dbg("entry, opcode 0x%x, plen %d", opcode, plen);
+
+        skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + plen), GFP_KERNEL);
+        if (!skb) {
+                nfc_err("no memory for command");
+                return -ENOMEM;
+        }
+
+        hdr = (struct nci_ctrl_hdr *) skb_put(skb, NCI_CTRL_HDR_SIZE);
+        hdr->gid = nci_opcode_gid(opcode);
+        hdr->oid = nci_opcode_oid(opcode);
+        hdr->plen = plen;
+
+        nci_mt_set((__u8 *)hdr, NCI_MT_CMD_PKT);
+        nci_pbf_set((__u8 *)hdr, NCI_PBF_LAST);
+
+        if (plen)
+                memcpy(skb_put(skb, plen), payload, plen);
+
+        skb->dev = (void *) ndev;
+
+        skb_queue_tail(&ndev->cmd_q, skb);
+        queue_work(ndev->cmd_wq, &ndev->cmd_work);
+
+        return 0;
+}
+
+/* ---- NCI TX Data worker thread ---- */
+
+static void nci_tx_work(struct work_struct *work)
+{
+        struct nci_dev *ndev = container_of(work, struct nci_dev, tx_work);
+        struct sk_buff *skb;
+
+        nfc_dbg("entry, credits_cnt %d", atomic_read(&ndev->credits_cnt));
+
+        /* Send queued tx data */
+        while (atomic_read(&ndev->credits_cnt)) {
+                skb = skb_dequeue(&ndev->tx_q);
+                if (!skb)
+                        return;
+
+                atomic_dec(&ndev->credits_cnt);
+
+                nfc_dbg("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d",
+                                nci_pbf(skb->data),
+                                nci_conn_id(skb->data),
+                                nci_plen(skb->data));
+
+                nci_send_frame(skb);
+        }
+}
+
+/* ----- NCI RX worker thread (data & control) ----- */
+
+static void nci_rx_work(struct work_struct *work)
+{
+        struct nci_dev *ndev = container_of(work, struct nci_dev, rx_work);
+        struct sk_buff *skb;
+
+        while ((skb = skb_dequeue(&ndev->rx_q))) {
+                /* Process frame */
+                switch (nci_mt(skb->data)) {
+                case NCI_MT_RSP_PKT:
+                        nci_rsp_packet(ndev, skb);
+                        break;
+
+                case NCI_MT_NTF_PKT:
+                        nci_ntf_packet(ndev, skb);
+                        break;
+
+                case NCI_MT_DATA_PKT:
+                        nci_rx_data_packet(ndev, skb);
+                        break;
+
+                default:
+                        nfc_err("unknown MT 0x%x", nci_mt(skb->data));
+                        kfree_skb(skb);
+                        break;
+                }
+        }
+}
+
+/* ----- NCI TX CMD worker thread ----- */
+
+static void nci_cmd_work(struct work_struct *work)
+{
+        struct nci_dev *ndev = container_of(work, struct nci_dev, cmd_work);
+        struct sk_buff *skb;
+
+        nfc_dbg("entry, cmd_cnt %d", atomic_read(&ndev->cmd_cnt));
+
+        /* Send queued command */
+        if (atomic_read(&ndev->cmd_cnt)) {
+                skb = skb_dequeue(&ndev->cmd_q);
+                if (!skb)
+                        return;
+
+                atomic_dec(&ndev->cmd_cnt);
+
+                nfc_dbg("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
+                                nci_pbf(skb->data),
+                                nci_opcode_gid(nci_opcode(skb->data)),
+                                nci_opcode_oid(nci_opcode(skb->data)),
+                                nci_plen(skb->data));
+
+                nci_send_frame(skb);
+
+                mod_timer(&ndev->cmd_timer,
+                        jiffies + msecs_to_jiffies(NCI_CMD_TIMEOUT));
+        }
+}
diff --git a/net/nfc/nci/data.c b/net/nfc/nci/data.c
new file mode 100644
index 000000000000..e5ed90fc1a9c
--- /dev/null
+++ b/net/nfc/nci/data.c
@@ -0,0 +1,247 @@
+/*
+ *  The NFC Controller Interface is the communication protocol between an
+ *  NFC Controller (NFCC) and a Device Host (DH).
+ *
+ *  Copyright (C) 2011 Texas Instruments, Inc.
+ *
+ *  Written by Ilan Elias <ilane@ti.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms 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/types.h>
+#include <linux/interrupt.h>
+#include <linux/wait.h>
+#include <linux/bitops.h>
+#include <linux/skbuff.h>
+
+#include "../nfc.h"
+#include <net/nfc/nci.h>
+#include <net/nfc/nci_core.h>
+#include <linux/nfc.h>
+
+/* Complete data exchange transaction and forward skb to nfc core */
+void nci_data_exchange_complete(struct nci_dev *ndev,
+                                struct sk_buff *skb,
+                                int err)
+{
+        data_exchange_cb_t cb = ndev->data_exchange_cb;
+        void *cb_context = ndev->data_exchange_cb_context;
+
+        nfc_dbg("entry, len %d, err %d", ((skb) ? (skb->len) : (0)), err);
+
+        if (cb) {
+                ndev->data_exchange_cb = NULL;
+                ndev->data_exchange_cb_context = 0;
+
+                /* forward skb to nfc core */
+                cb(cb_context, skb, err);
+        } else if (skb) {
+                nfc_err("no rx callback, dropping rx data...");
+
+                /* no waiting callback, free skb */
+                kfree_skb(skb);
+        }
+
+        clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
+}
+
+/* ----------------- NCI TX Data ----------------- */
+
+static inline void nci_push_data_hdr(struct nci_dev *ndev,
+                                        __u8 conn_id,
+                                        struct sk_buff *skb,
+                                        __u8 pbf)
+{
+        struct nci_data_hdr *hdr;
+        int plen = skb->len;
+
+        hdr = (struct nci_data_hdr *) skb_push(skb, NCI_DATA_HDR_SIZE);
+        hdr->conn_id = conn_id;
+        hdr->rfu = 0;
+        hdr->plen = plen;
+
+        nci_mt_set((__u8 *)hdr, NCI_MT_DATA_PKT);
+        nci_pbf_set((__u8 *)hdr, pbf);
+
+        skb->dev = (void *) ndev;
+}
+
+static int nci_queue_tx_data_frags(struct nci_dev *ndev,
+                                        __u8 conn_id,
+                                        struct sk_buff *skb) {
+        int total_len = skb->len;
+        unsigned char *data = skb->data;
+        unsigned long flags;
+        struct sk_buff_head frags_q;
+        struct sk_buff *skb_frag;
+        int frag_len;
+        int rc = 0;
+
+        nfc_dbg("entry, conn_id 0x%x, total_len %d", conn_id, total_len);
+
+        __skb_queue_head_init(&frags_q);
+
+        while (total_len) {
+                frag_len = min_t(int, total_len, ndev->max_pkt_payload_size);
+
+                skb_frag = nci_skb_alloc(ndev,
+                                        (NCI_DATA_HDR_SIZE + frag_len),
+                                        GFP_KERNEL);
+                if (skb_frag == NULL) {
+                        rc = -ENOMEM;
+                        goto free_exit;
+                }
+                skb_reserve(skb_frag, NCI_DATA_HDR_SIZE);
+
+                /* first, copy the data */
+                memcpy(skb_put(skb_frag, frag_len), data, frag_len);
+
+                /* second, set the header */
+                nci_push_data_hdr(ndev, conn_id, skb_frag,
+                ((total_len == frag_len) ? (NCI_PBF_LAST) : (NCI_PBF_CONT)));
+
+                __skb_queue_tail(&frags_q, skb_frag);
+
+                data += frag_len;
+                total_len -= frag_len;
+
+                nfc_dbg("frag_len %d, remaining total_len %d",
+                        frag_len, total_len);
+        }
+
+        /* queue all fragments atomically */
+        spin_lock_irqsave(&ndev->tx_q.lock, flags);
+
+        while ((skb_frag = __skb_dequeue(&frags_q)) != NULL)
+                __skb_queue_tail(&ndev->tx_q, skb_frag);
+
+        spin_unlock_irqrestore(&ndev->tx_q.lock, flags);
+
+        /* free the original skb */
+        kfree_skb(skb);
+
+        goto exit;
+
+free_exit:
+        while ((skb_frag = __skb_dequeue(&frags_q)) != NULL)
+                kfree_skb(skb_frag);
+
+exit:
+        return rc;
+}
+
+/* Send NCI data */
+int nci_send_data(struct nci_dev *ndev, __u8 conn_id, struct sk_buff *skb)
+{
+        int rc = 0;
+
+        nfc_dbg("entry, conn_id 0x%x, plen %d", conn_id, skb->len);
+
+        /* check if the packet need to be fragmented */
+        if (skb->len <= ndev->max_pkt_payload_size) {
+                /* no need to fragment packet */
+                nci_push_data_hdr(ndev, conn_id, skb, NCI_PBF_LAST);
+
+                skb_queue_tail(&ndev->tx_q, skb);
+        } else {
+                /* fragment packet and queue the fragments */
+                rc = nci_queue_tx_data_frags(ndev, conn_id, skb);
+                if (rc) {
+                        nfc_err("failed to fragment tx data packet");
+                        goto free_exit;
+                }
+        }
+
+        queue_work(ndev->tx_wq, &ndev->tx_work);
+
+        goto exit;
+
+free_exit:
+        kfree_skb(skb);
+
+exit:
+        return rc;
+}
+
+/* ----------------- NCI RX Data ----------------- */
+
+static void nci_add_rx_data_frag(struct nci_dev *ndev,
+                                struct sk_buff *skb,
+                                __u8 pbf)
+{
+        int reassembly_len;
+        int err = 0;
+
+        if (ndev->rx_data_reassembly) {
+                reassembly_len = ndev->rx_data_reassembly->len;
+
+                /* first, make enough room for the already accumulated data */
+                if (skb_cow_head(skb, reassembly_len)) {
+                        nfc_err("error adding room for accumulated rx data");
+
+                        kfree_skb(skb);
+                        skb = 0;
+
+                        kfree_skb(ndev->rx_data_reassembly);
+                        ndev->rx_data_reassembly = 0;
+
+                        err = -ENOMEM;
+                        goto exit;
+                }
+
+                /* second, combine the two fragments */
+                memcpy(skb_push(skb, reassembly_len),
+                                ndev->rx_data_reassembly->data,
+                                reassembly_len);
+
+                /* third, free old reassembly */
+                kfree_skb(ndev->rx_data_reassembly);
+                ndev->rx_data_reassembly = 0;
+        }
+
+        if (pbf == NCI_PBF_CONT) {
+                /* need to wait for next fragment, store skb and exit */
+                ndev->rx_data_reassembly = skb;
+                return;
+        }
+
+exit:
+        nci_data_exchange_complete(ndev, skb, err);
+}
+
+/* Rx Data packet */
+void nci_rx_data_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        __u8 pbf = nci_pbf(skb->data);
+
+        nfc_dbg("entry, len %d", skb->len);
+
+        nfc_dbg("NCI RX: MT=data, PBF=%d, conn_id=%d, plen=%d",
+                        nci_pbf(skb->data),
+                        nci_conn_id(skb->data),
+                        nci_plen(skb->data));
+
+        /* strip the nci data header */
+        skb_pull(skb, NCI_DATA_HDR_SIZE);
+
+        if (ndev->target_active_prot == NFC_PROTO_MIFARE) {
+                /* frame I/F => remove the status byte */
+                nfc_dbg("NFC_PROTO_MIFARE => remove the status byte");
+                skb_trim(skb, (skb->len - 1));
+        }
+
+        nci_add_rx_data_frag(ndev, skb, pbf);
+}
diff --git a/net/nfc/nci/lib.c b/net/nfc/nci/lib.c
new file mode 100644
index 000000000000..b19dc2fa90e1
--- /dev/null
+++ b/net/nfc/nci/lib.c
@@ -0,0 +1,94 @@
+/*
+ *  The NFC Controller Interface is the communication protocol between an
+ *  NFC Controller (NFCC) and a Device Host (DH).
+ *
+ *  Copyright (C) 2011 Texas Instruments, Inc.
+ *
+ *  Written by Ilan Elias <ilane@ti.com>
+ *
+ *  Acknowledgements:
+ *  This file is based on lib.c, which was written
+ *  by Maxim Krasnyansky.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms 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/kernel.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+
+#include <net/nfc/nci.h>
+
+/* NCI status codes to Unix errno mapping */
+int nci_to_errno(__u8 code)
+{
+        switch (code) {
+        case NCI_STATUS_OK:
+                return 0;
+
+        case NCI_STATUS_REJECTED:
+                return -EBUSY;
+
+        case NCI_STATUS_MESSAGE_CORRUPTED:
+                return -EBADMSG;
+
+        case NCI_STATUS_BUFFER_FULL:
+                return -ENOBUFS;
+
+        case NCI_STATUS_NOT_INITIALIZED:
+                return -EHOSTDOWN;
+
+        case NCI_STATUS_SYNTAX_ERROR:
+        case NCI_STATUS_SEMANTIC_ERROR:
+        case NCI_STATUS_INVALID_PARAM:
+        case NCI_STATUS_RF_PROTOCOL_ERROR:
+        case NCI_STATUS_NFCEE_PROTOCOL_ERROR:
+                return -EPROTO;
+
+        case NCI_STATUS_UNKNOWN_GID:
+        case NCI_STATUS_UNKNOWN_OID:
+                return -EBADRQC;
+
+        case NCI_STATUS_MESSAGE_SIZE_EXCEEDED:
+                return -EMSGSIZE;
+
+        case NCI_STATUS_DISCOVERY_ALREADY_STARTED:
+                return -EALREADY;
+
+        case NCI_STATUS_DISCOVERY_TARGET_ACTIVATION_FAILED:
+        case NCI_STATUS_NFCEE_INTERFACE_ACTIVATION_FAILED:
+                return -ECONNREFUSED;
+
+        case NCI_STATUS_RF_TRANSMISSION_ERROR:
+        case NCI_STATUS_NFCEE_TRANSMISSION_ERROR:
+                return -ECOMM;
+
+        case NCI_STATUS_RF_TIMEOUT_ERROR:
+        case NCI_STATUS_NFCEE_TIMEOUT_ERROR:
+                return -ETIMEDOUT;
+
+        case NCI_STATUS_RF_LINK_LOSS_ERROR:
+                return -ENOLINK;
+
+        case NCI_STATUS_MAX_ACTIVE_NFCEE_INTERFACES_REACHED:
+                return -EDQUOT;
+
+        case NCI_STATUS_FAILED:
+        default:
+                return -ENOSYS;
+        }
+}
+EXPORT_SYMBOL(nci_to_errno);
diff --git a/net/nfc/nci/ntf.c b/net/nfc/nci/ntf.c
new file mode 100644
index 000000000000..96633f5cda4f
--- /dev/null
+++ b/net/nfc/nci/ntf.c
@@ -0,0 +1,258 @@
+/*
+ *  The NFC Controller Interface is the communication protocol between an
+ *  NFC Controller (NFCC) and a Device Host (DH).
+ *
+ *  Copyright (C) 2011 Texas Instruments, Inc.
+ *
+ *  Written by Ilan Elias <ilane@ti.com>
+ *
+ *  Acknowledgements:
+ *  This file is based on hci_event.c, which was written
+ *  by Maxim Krasnyansky.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms 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/types.h>
+#include <linux/interrupt.h>
+#include <linux/bitops.h>
+#include <linux/skbuff.h>
+
+#include "../nfc.h"
+#include <net/nfc/nci.h>
+#include <net/nfc/nci_core.h>
+#include <linux/nfc.h>
+
+/* Handle NCI Notification packets */
+
+static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
+                                                struct sk_buff *skb)
+{
+        struct nci_core_conn_credit_ntf *ntf = (void *) skb->data;
+        int i;
+
+        nfc_dbg("entry, num_entries %d", ntf->num_entries);
+
+        if (ntf->num_entries > NCI_MAX_NUM_CONN)
+                ntf->num_entries = NCI_MAX_NUM_CONN;
+
+        /* update the credits */
+        for (i = 0; i < ntf->num_entries; i++) {
+                nfc_dbg("entry[%d]: conn_id %d, credits %d", i,
+                        ntf->conn_entries[i].conn_id,
+                        ntf->conn_entries[i].credits);
+
+                if (ntf->conn_entries[i].conn_id == ndev->conn_id) {
+                        /* found static rf connection */
+                        atomic_add(ntf->conn_entries[i].credits,
+                                &ndev->credits_cnt);
+                }
+        }
+
+        /* trigger the next tx */
+        if (!skb_queue_empty(&ndev->tx_q))
+                queue_work(ndev->tx_wq, &ndev->tx_work);
+}
+
+static void nci_rf_field_info_ntf_packet(struct nci_dev *ndev,
+                                        struct sk_buff *skb)
+{
+        struct nci_rf_field_info_ntf *ntf = (void *) skb->data;
+
+        nfc_dbg("entry, rf_field_status %d", ntf->rf_field_status);
+}
+
+static int nci_rf_activate_nfca_passive_poll(struct nci_dev *ndev,
+                        struct nci_rf_activate_ntf *ntf, __u8 *data)
+{
+        struct rf_tech_specific_params_nfca_poll *nfca_poll;
+        struct activation_params_nfca_poll_iso_dep *nfca_poll_iso_dep;
+
+        nfca_poll = &ntf->rf_tech_specific_params.nfca_poll;
+        nfca_poll_iso_dep = &ntf->activation_params.nfca_poll_iso_dep;
+
+        nfca_poll->sens_res = __le16_to_cpu(*((__u16 *)data));
+        data += 2;
+
+        nfca_poll->nfcid1_len = *data++;
+
+        nfc_dbg("sens_res 0x%x, nfcid1_len %d",
+                nfca_poll->sens_res,
+                nfca_poll->nfcid1_len);
+
+        memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len);
+        data += nfca_poll->nfcid1_len;
+
+        nfca_poll->sel_res_len = *data++;
+
+        if (nfca_poll->sel_res_len != 0)
+                nfca_poll->sel_res = *data++;
+
+        ntf->rf_interface_type = *data++;
+        ntf->activation_params_len = *data++;
+
+        nfc_dbg("sel_res_len %d, sel_res 0x%x, rf_interface_type %d, activation_params_len %d",
+                nfca_poll->sel_res_len,
+                nfca_poll->sel_res,
+                ntf->rf_interface_type,
+                ntf->activation_params_len);
+
+        switch (ntf->rf_interface_type) {
+        case NCI_RF_INTERFACE_ISO_DEP:
+                nfca_poll_iso_dep->rats_res_len = *data++;
+                if (nfca_poll_iso_dep->rats_res_len > 0) {
+                        memcpy(nfca_poll_iso_dep->rats_res,
+                                data,
+                                nfca_poll_iso_dep->rats_res_len);
+                }
+                break;
+
+        case NCI_RF_INTERFACE_FRAME:
+                /* no activation params */
+                break;
+
+        default:
+                nfc_err("unsupported rf_interface_type 0x%x",
+                        ntf->rf_interface_type);
+                return -EPROTO;
+        }
+
+        return 0;
+}
+
+static void nci_target_found(struct nci_dev *ndev,
+                                struct nci_rf_activate_ntf *ntf)
+{
+        struct nfc_target nfc_tgt;
+
+        if (ntf->rf_protocol == NCI_RF_PROTOCOL_T2T)    /* T2T MifareUL */
+                nfc_tgt.supported_protocols = NFC_PROTO_MIFARE_MASK;
+        else if (ntf->rf_protocol == NCI_RF_PROTOCOL_ISO_DEP)   /* 4A */
+                nfc_tgt.supported_protocols = NFC_PROTO_ISO14443_MASK;
+
+        nfc_tgt.sens_res = ntf->rf_tech_specific_params.nfca_poll.sens_res;
+        nfc_tgt.sel_res = ntf->rf_tech_specific_params.nfca_poll.sel_res;
+
+        if (!(nfc_tgt.supported_protocols & ndev->poll_prots)) {
+                nfc_dbg("the target found does not have the desired protocol");
+                return;
+        }
+
+        nfc_dbg("new target found,  supported_protocols 0x%x",
+                nfc_tgt.supported_protocols);
+
+        ndev->target_available_prots = nfc_tgt.supported_protocols;
+
+        nfc_targets_found(ndev->nfc_dev, &nfc_tgt, 1);
+}
+
+static void nci_rf_activate_ntf_packet(struct nci_dev *ndev,
+                                        struct sk_buff *skb)
+{
+        struct nci_rf_activate_ntf ntf;
+        __u8 *data = skb->data;
+        int rc = -1;
+
+        clear_bit(NCI_DISCOVERY, &ndev->flags);
+        set_bit(NCI_POLL_ACTIVE, &ndev->flags);
+
+        ntf.target_handle = *data++;
+        ntf.rf_protocol = *data++;
+        ntf.rf_tech_and_mode = *data++;
+        ntf.rf_tech_specific_params_len = *data++;
+
+        nfc_dbg("target_handle %d, rf_protocol 0x%x, rf_tech_and_mode 0x%x, rf_tech_specific_params_len %d",
+                ntf.target_handle,
+                ntf.rf_protocol,
+                ntf.rf_tech_and_mode,
+                ntf.rf_tech_specific_params_len);
+
+        switch (ntf.rf_tech_and_mode) {
+        case NCI_NFC_A_PASSIVE_POLL_MODE:
+                rc = nci_rf_activate_nfca_passive_poll(ndev, &ntf,
+                        data);
+                break;
+
+        default:
+                nfc_err("unsupported rf_tech_and_mode 0x%x",
+                        ntf.rf_tech_and_mode);
+                return;
+        }
+
+        if (!rc)
+                nci_target_found(ndev, &ntf);
+}
+
+static void nci_rf_deactivate_ntf_packet(struct nci_dev *ndev,
+                                        struct sk_buff *skb)
+{
+        __u8 type = skb->data[0];
+
+        nfc_dbg("entry, type 0x%x", type);
+
+        clear_bit(NCI_POLL_ACTIVE, &ndev->flags);
+        ndev->target_active_prot = 0;
+
+        /* drop tx data queue */
+        skb_queue_purge(&ndev->tx_q);
+
+        /* drop partial rx data packet */
+        if (ndev->rx_data_reassembly) {
+                kfree_skb(ndev->rx_data_reassembly);
+                ndev->rx_data_reassembly = 0;
+        }
+
+        /* complete the data exchange transaction, if exists */
+        if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
+                nci_data_exchange_complete(ndev, NULL, -EIO);
+}
+
+void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        __u16 ntf_opcode = nci_opcode(skb->data);
+
+        nfc_dbg("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
+                        nci_pbf(skb->data),
+                        nci_opcode_gid(ntf_opcode),
+                        nci_opcode_oid(ntf_opcode),
+                        nci_plen(skb->data));
+
+        /* strip the nci control header */
+        skb_pull(skb, NCI_CTRL_HDR_SIZE);
+
+        switch (ntf_opcode) {
+        case NCI_OP_CORE_CONN_CREDITS_NTF:
+                nci_core_conn_credits_ntf_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_FIELD_INFO_NTF:
+                nci_rf_field_info_ntf_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_ACTIVATE_NTF:
+                nci_rf_activate_ntf_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_DEACTIVATE_NTF:
+                nci_rf_deactivate_ntf_packet(ndev, skb);
+                break;
+
+        default:
+                nfc_err("unknown ntf opcode 0x%x", ntf_opcode);
+                break;
+        }
+
+        kfree_skb(skb);
+}
diff --git a/net/nfc/nci/rsp.c b/net/nfc/nci/rsp.c
new file mode 100644
index 000000000000..0403d4cd0917
--- /dev/null
+++ b/net/nfc/nci/rsp.c
@@ -0,0 +1,226 @@
+/*
+ *  The NFC Controller Interface is the communication protocol between an
+ *  NFC Controller (NFCC) and a Device Host (DH).
+ *
+ *  Copyright (C) 2011 Texas Instruments, Inc.
+ *
+ *  Written by Ilan Elias <ilane@ti.com>
+ *
+ *  Acknowledgements:
+ *  This file is based on hci_event.c, which was written
+ *  by Maxim Krasnyansky.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms 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/types.h>
+#include <linux/interrupt.h>
+#include <linux/bitops.h>
+#include <linux/skbuff.h>
+
+#include "../nfc.h"
+#include <net/nfc/nci.h>
+#include <net/nfc/nci_core.h>
+
+/* Handle NCI Response packets */
+
+static void nci_core_reset_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        struct nci_core_reset_rsp *rsp = (void *) skb->data;
+
+        nfc_dbg("entry, status 0x%x", rsp->status);
+
+        if (rsp->status == NCI_STATUS_OK)
+                ndev->nci_ver = rsp->nci_ver;
+
+        nfc_dbg("nci_ver 0x%x", ndev->nci_ver);
+
+        nci_req_complete(ndev, rsp->status);
+}
+
+static void nci_core_init_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        struct nci_core_init_rsp_1 *rsp_1 = (void *) skb->data;
+        struct nci_core_init_rsp_2 *rsp_2;
+
+        nfc_dbg("entry, status 0x%x", rsp_1->status);
+
+        if (rsp_1->status != NCI_STATUS_OK)
+                return;
+
+        ndev->nfcc_features = __le32_to_cpu(rsp_1->nfcc_features);
+        ndev->num_supported_rf_interfaces = rsp_1->num_supported_rf_interfaces;
+
+        if (ndev->num_supported_rf_interfaces >
+                NCI_MAX_SUPPORTED_RF_INTERFACES) {
+                ndev->num_supported_rf_interfaces =
+                        NCI_MAX_SUPPORTED_RF_INTERFACES;
+        }
+
+        memcpy(ndev->supported_rf_interfaces,
+                rsp_1->supported_rf_interfaces,
+                ndev->num_supported_rf_interfaces);
+
+        rsp_2 = (void *) (skb->data + 6 + ndev->num_supported_rf_interfaces);
+
+        ndev->max_logical_connections =
+                rsp_2->max_logical_connections;
+        ndev->max_routing_table_size =
+                __le16_to_cpu(rsp_2->max_routing_table_size);
+        ndev->max_control_packet_payload_length =
+                rsp_2->max_control_packet_payload_length;
+        ndev->rf_sending_buffer_size =
+                __le16_to_cpu(rsp_2->rf_sending_buffer_size);
+        ndev->rf_receiving_buffer_size =
+                __le16_to_cpu(rsp_2->rf_receiving_buffer_size);
+        ndev->manufacturer_id =
+                __le16_to_cpu(rsp_2->manufacturer_id);
+
+        nfc_dbg("nfcc_features 0x%x",
+                ndev->nfcc_features);
+        nfc_dbg("num_supported_rf_interfaces %d",
+                ndev->num_supported_rf_interfaces);
+        nfc_dbg("supported_rf_interfaces[0] 0x%x",
+                ndev->supported_rf_interfaces[0]);
+        nfc_dbg("supported_rf_interfaces[1] 0x%x",
+                ndev->supported_rf_interfaces[1]);
+        nfc_dbg("supported_rf_interfaces[2] 0x%x",
+                ndev->supported_rf_interfaces[2]);
+        nfc_dbg("supported_rf_interfaces[3] 0x%x",
+                ndev->supported_rf_interfaces[3]);
+        nfc_dbg("max_logical_connections %d",
+                ndev->max_logical_connections);
+        nfc_dbg("max_routing_table_size %d",
+                ndev->max_routing_table_size);
+        nfc_dbg("max_control_packet_payload_length %d",
+                ndev->max_control_packet_payload_length);
+        nfc_dbg("rf_sending_buffer_size %d",
+                ndev->rf_sending_buffer_size);
+        nfc_dbg("rf_receiving_buffer_size %d",
+                ndev->rf_receiving_buffer_size);
+        nfc_dbg("manufacturer_id 0x%x",
+                ndev->manufacturer_id);
+
+        nci_req_complete(ndev, rsp_1->status);
+}
+
+static void nci_core_conn_create_rsp_packet(struct nci_dev *ndev,
+                                                struct sk_buff *skb)
+{
+        struct nci_core_conn_create_rsp *rsp = (void *) skb->data;
+
+        nfc_dbg("entry, status 0x%x", rsp->status);
+
+        if (rsp->status != NCI_STATUS_OK)
+                return;
+
+        ndev->max_pkt_payload_size = rsp->max_pkt_payload_size;
+        ndev->initial_num_credits = rsp->initial_num_credits;
+        ndev->conn_id = rsp->conn_id;
+
+        atomic_set(&ndev->credits_cnt, ndev->initial_num_credits);
+
+        nfc_dbg("max_pkt_payload_size %d", ndev->max_pkt_payload_size);
+        nfc_dbg("initial_num_credits %d", ndev->initial_num_credits);
+        nfc_dbg("conn_id %d", ndev->conn_id);
+}
+
+static void nci_rf_disc_map_rsp_packet(struct nci_dev *ndev,
+                                        struct sk_buff *skb)
+{
+        __u8 status = skb->data[0];
+
+        nfc_dbg("entry, status 0x%x", status);
+
+        nci_req_complete(ndev, status);
+}
+
+static void nci_rf_disc_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        __u8 status = skb->data[0];
+
+        nfc_dbg("entry, status 0x%x", status);
+
+        if (status == NCI_STATUS_OK)
+                set_bit(NCI_DISCOVERY, &ndev->flags);
+
+        nci_req_complete(ndev, status);
+}
+
+static void nci_rf_deactivate_rsp_packet(struct nci_dev *ndev,
+                                        struct sk_buff *skb)
+{
+        __u8 status = skb->data[0];
+
+        nfc_dbg("entry, status 0x%x", status);
+
+        clear_bit(NCI_DISCOVERY, &ndev->flags);
+
+        nci_req_complete(ndev, status);
+}
+
+void nci_rsp_packet(struct nci_dev *ndev, struct sk_buff *skb)
+{
+        __u16 rsp_opcode = nci_opcode(skb->data);
+
+        /* we got a rsp, stop the cmd timer */
+        del_timer(&ndev->cmd_timer);
+
+        nfc_dbg("NCI RX: MT=rsp, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
+                        nci_pbf(skb->data),
+                        nci_opcode_gid(rsp_opcode),
+                        nci_opcode_oid(rsp_opcode),
+                        nci_plen(skb->data));
+
+        /* strip the nci control header */
+        skb_pull(skb, NCI_CTRL_HDR_SIZE);
+
+        switch (rsp_opcode) {
+        case NCI_OP_CORE_RESET_RSP:
+                nci_core_reset_rsp_packet(ndev, skb);
+                break;
+
+        case NCI_OP_CORE_INIT_RSP:
+                nci_core_init_rsp_packet(ndev, skb);
+                break;
+
+        case NCI_OP_CORE_CONN_CREATE_RSP:
+                nci_core_conn_create_rsp_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_DISCOVER_MAP_RSP:
+                nci_rf_disc_map_rsp_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_DISCOVER_RSP:
+                nci_rf_disc_rsp_packet(ndev, skb);
+                break;
+
+        case NCI_OP_RF_DEACTIVATE_RSP:
+                nci_rf_deactivate_rsp_packet(ndev, skb);
+                break;
+
+        default:
+                nfc_err("unknown rsp opcode 0x%x", rsp_opcode);
+                break;
+        }
+
+        kfree_skb(skb);
+
+        /* trigger the next cmd */
+        atomic_set(&ndev->cmd_cnt, 1);
+        if (!skb_queue_empty(&ndev->cmd_q))
+                queue_work(ndev->cmd_wq, &ndev->cmd_work);
+}
diff --git a/net/nfc/netlink.c b/net/nfc/netlink.c
index ccdff7953f7d..03f8818e1f16 100644
--- a/net/nfc/netlink.c
+++ b/net/nfc/netlink.c
@@ -367,6 +367,52 @@ out_putdev:
         return rc;
 }
 
+static int nfc_genl_dev_up(struct sk_buff *skb, struct genl_info *info)
+{
+        struct nfc_dev *dev;
+        int rc;
+        u32 idx;
+
+        nfc_dbg("entry");
+
+        if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
+                return -EINVAL;
+
+        idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
+
+        dev = nfc_get_device(idx);
+        if (!dev)
+                return -ENODEV;
+
+        rc = nfc_dev_up(dev);
+
+        nfc_put_device(dev);
+        return rc;
+}
+
+static int nfc_genl_dev_down(struct sk_buff *skb, struct genl_info *info)
+{
+        struct nfc_dev *dev;
+        int rc;
+        u32 idx;
+
+        nfc_dbg("entry");
+
+        if (!info->attrs[NFC_ATTR_DEVICE_INDEX])
+                return -EINVAL;
+
+        idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);
+
+        dev = nfc_get_device(idx);
+        if (!dev)
+                return -ENODEV;
+
+        rc = nfc_dev_down(dev);
+
+        nfc_put_device(dev);
+        return rc;
+}
+
 static int nfc_genl_start_poll(struct sk_buff *skb, struct genl_info *info)
 {
         struct nfc_dev *dev;
@@ -441,6 +487,16 @@ static struct genl_ops nfc_genl_ops[] = {
                 .policy = nfc_genl_policy,
         },
         {
+                .cmd = NFC_CMD_DEV_UP,
+                .doit = nfc_genl_dev_up,
+                .policy = nfc_genl_policy,
+        },
+        {
+                .cmd = NFC_CMD_DEV_DOWN,
+                .doit = nfc_genl_dev_down,
+                .policy = nfc_genl_policy,
+        },
+        {
                 .cmd = NFC_CMD_START_POLL,
                 .doit = nfc_genl_start_poll,
                 .policy = nfc_genl_policy,
diff --git a/net/nfc/nfc.h b/net/nfc/nfc.h
index aaf9832298f3..d86583f4831d 100644
--- a/net/nfc/nfc.h
+++ b/net/nfc/nfc.h
@@ -24,10 +24,10 @@
 #ifndef __LOCAL_NFC_H
 #define __LOCAL_NFC_H
 
-#include <net/nfc.h>
+#include <net/nfc/nfc.h>
 #include <net/sock.h>
 
-__attribute__((format (printf, 2, 3)))
+__printf(2, 3)
 int nfc_printk(const char *level, const char *fmt, ...);
 
 #define nfc_info(fmt, arg...) nfc_printk(KERN_INFO, fmt, ##arg)
@@ -101,6 +101,10 @@ static inline void nfc_device_iter_exit(struct class_dev_iter *iter)
         class_dev_iter_exit(iter);
 }
 
+int nfc_dev_up(struct nfc_dev *dev);
+
+int nfc_dev_down(struct nfc_dev *dev);
+
 int nfc_start_poll(struct nfc_dev *dev, u32 protocols);
 
 int nfc_stop_poll(struct nfc_dev *dev);
diff --git a/net/nfc/rawsock.c b/net/nfc/rawsock.c
index 52de84a55115..9fd652a51424 100644
--- a/net/nfc/rawsock.c
+++ b/net/nfc/rawsock.c
@@ -123,11 +123,7 @@ error:
 
 static int rawsock_add_header(struct sk_buff *skb)
 {
-
-        if (skb_cow_head(skb, 1))
-                return -ENOMEM;
-
-        *skb_push(skb, 1) = 0;
+        *skb_push(skb, NFC_HEADER_SIZE) = 0;
 
         return 0;
 }
@@ -197,6 +193,7 @@ static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
                                         struct msghdr *msg, size_t len)
 {
         struct sock *sk = sock->sk;
+        struct nfc_dev *dev = nfc_rawsock(sk)->dev;
         struct sk_buff *skb;
         int rc;
 
@@ -208,11 +205,13 @@ static int rawsock_sendmsg(struct kiocb *iocb, struct socket *sock,
         if (sock->state != SS_CONNECTED)
                 return -ENOTCONN;
 
-        skb = sock_alloc_send_skb(sk, len, msg->msg_flags & MSG_DONTWAIT,
-                                                                        &rc);
+        skb = sock_alloc_send_skb(sk, len + dev->tx_headroom + dev->tx_tailroom + NFC_HEADER_SIZE,
+                                        msg->msg_flags & MSG_DONTWAIT, &rc);
         if (!skb)
                 return rc;
 
+        skb_reserve(skb, dev->tx_headroom + NFC_HEADER_SIZE);
+
         rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
         if (rc < 0) {
                 kfree_skb(skb);