NFC Digital: Add initiator NFC-DEP support

This adds support for NFC-DEP protocol in initiator mode for NFC-A and
NFC-F technologies.

When a target is detected, the process flow is as follow:

For NFC-A technology:
1 - The digital stack receives a SEL_RES as the reply of the SEL_REQ
    command.
2   - If b7 of SEL_RES is set, the peer device is configure for NFC-DEP
      protocol. NFC core is notified through nfc_targets_found().
      Execution continues at step 4.
3   - Otherwise, it's a tag and the NFC core is notified. Detection
      ends.
4 - The digital stacks sends an ATR_REQ command containing a randomly
    generated NFCID3 and the general bytes obtained from the LLCP layer
    of NFC core.

For NFC-F technology:
1 - The digital stack receives a SENSF_RES as the reply of the
    SENSF_REQ command.
2   - If B1 and B2 of NFCID2 are 0x01 and 0xFE respectively, the peer
      device is configured for NFC-DEP protocol. NFC core is notified
      through nfc_targets_found(). Execution continues at step 4.
3   - Otherwise it's a type 3 tag. NFC core is notified. Detection
      ends.
4 - The digital stacks sends an ATR_REQ command containing the NFC-F
    NFCID2 as NFCID3 and the general bytes obtained from the LLCP layer
    of NFC core.

For both technologies:
5 - The digital stacks receives the ATR_RES response containing the
    NFCID3 and the general bytes of the peer device.
6 - The digital stack notifies NFC core that the DEP link is up through
    nfc_dep_link_up().
7 - The NFC core performs data exchange through tm_transceive().
8 - The digital stack sends a DEP_REQ command containing an I PDU with
    the data from NFC core.
9 - The digital stack receives a DEP_RES command
10  - If the DEP_RES response contains a supervisor PDU with timeout
      extension request (RTOX) the digital stack sends a DEP_REQ
      command containing a supervisor PDU acknowledging the RTOX
      request. The execution continues at step 9.
11  - If the DEP_RES response contains an I PDU, the response data is
      passed back to NFC core through the response callback. The
      execution continues at step 8.

Signed-off-by: Thierry Escande <thierry.escande@linux.intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

5 files changed, 435 insertions, 6 deletions

diff --git a/net/nfc/Makefile b/net/nfc/Makefile
index 2db39713a907..2555ff8e7219 100644
--- a/net/nfc/Makefile
+++ b/net/nfc/Makefile
@@ -10,4 +10,4 @@ obj-$(CONFIG_NFC_DIGITAL) += nfc_digital.o
 nfc-objs := core.o netlink.o af_nfc.o rawsock.o llcp_core.o llcp_commands.o \
                 llcp_sock.o
 
-nfc_digital-objs := digital_core.o digital_technology.o
+nfc_digital-objs := digital_core.o digital_technology.o digital_dep.o
diff --git a/net/nfc/digital.h b/net/nfc/digital.h
index 85bc74c988f8..5254a872522b 100644
--- a/net/nfc/digital.h
+++ b/net/nfc/digital.h
@@ -35,6 +35,13 @@
 #define DIGITAL_MAX_HEADER_LEN 7
 #define DIGITAL_CRC_LEN        2
 
+#define DIGITAL_SENSF_NFCID2_NFC_DEP_B1 0x01
+#define DIGITAL_SENSF_NFCID2_NFC_DEP_B2 0xFE
+
+#define DIGITAL_SENS_RES_NFC_DEP 0x0100
+#define DIGITAL_SEL_RES_NFC_DEP  0x40
+#define DIGITAL_SENSF_FELICA_SC  0xFFFF
+
 #define DIGITAL_DRV_CAPS_IN_CRC(ddev) \
         ((ddev)->driver_capabilities & NFC_DIGITAL_DRV_CAPS_IN_CRC)
 #define DIGITAL_DRV_CAPS_TG_CRC(ddev) \
@@ -72,6 +79,13 @@ int digital_target_found(struct nfc_digital_dev *ddev,
 
 int digital_in_recv_mifare_res(struct sk_buff *resp);
 
+int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
+                            struct nfc_target *target, __u8 comm_mode, __u8 *gb,
+                            size_t gb_len);
+int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
+                            struct nfc_target *target, struct sk_buff *skb,
+                            struct digital_data_exch *data_exch);
+
 typedef u16 (*crc_func_t)(u16, const u8 *, size_t);
 
 #define CRC_A_INIT 0x6363
diff --git a/net/nfc/digital_core.c b/net/nfc/digital_core.c
index 25e5bcb946e0..dccfcccf6998 100644
--- a/net/nfc/digital_core.c
+++ b/net/nfc/digital_core.c
@@ -18,9 +18,10 @@
 #include "digital.h"
 
 #define DIGITAL_PROTO_NFCA_RF_TECH \
-        (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK)
+        (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK | NFC_PROTO_NFC_DEP_MASK)
 
-#define DIGITAL_PROTO_NFCF_RF_TECH (NFC_PROTO_FELICA_MASK)
+#define DIGITAL_PROTO_NFCF_RF_TECH \
+        (NFC_PROTO_FELICA_MASK | NFC_PROTO_NFC_DEP_MASK)
 
 struct digital_cmd {
         struct list_head queue;
@@ -260,6 +261,18 @@ int digital_target_found(struct nfc_digital_dev *ddev,
                 add_crc = digital_skb_add_crc_f;
                 break;
 
+        case NFC_PROTO_NFC_DEP:
+                if (rf_tech == NFC_DIGITAL_RF_TECH_106A) {
+                        framing = NFC_DIGITAL_FRAMING_NFCA_NFC_DEP;
+                        check_crc = digital_skb_check_crc_a;
+                        add_crc = digital_skb_add_crc_a;
+                } else {
+                        framing = NFC_DIGITAL_FRAMING_NFCF_NFC_DEP;
+                        check_crc = digital_skb_check_crc_f;
+                        add_crc = digital_skb_add_crc_f;
+                }
+                break;
+
         default:
                 PR_ERR("Invalid protocol %d", protocol);
                 return -EINVAL;
@@ -453,12 +466,18 @@ static int digital_dep_link_up(struct nfc_dev *nfc_dev,
                                struct nfc_target *target,
                                __u8 comm_mode, __u8 *gb, size_t gb_len)
 {
-        return -EOPNOTSUPP;
+        struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
+
+        return digital_in_send_atr_req(ddev, target, comm_mode, gb, gb_len);
 }
 
 static int digital_dep_link_down(struct nfc_dev *nfc_dev)
 {
-        return -EOPNOTSUPP;
+        struct nfc_digital_dev *ddev = nfc_get_drvdata(nfc_dev);
+
+        ddev->curr_protocol = 0;
+
+        return 0;
 }
 
 static int digital_activate_target(struct nfc_dev *nfc_dev,
@@ -523,6 +542,9 @@ static int digital_in_send(struct nfc_dev *nfc_dev, struct nfc_target *target,
         data_exch->cb = cb;
         data_exch->cb_context = cb_context;
 
+        if (ddev->curr_protocol == NFC_PROTO_NFC_DEP)
+                return digital_in_send_dep_req(ddev, target, skb, data_exch);
+
         ddev->skb_add_crc(skb);
 
         return digital_in_send_cmd(ddev, skb, 500, digital_in_send_complete,
@@ -578,6 +600,8 @@ struct nfc_digital_dev *nfc_digital_allocate_device(struct nfc_digital_ops *ops,
                 ddev->protocols |= NFC_PROTO_MIFARE_MASK;
         if (supported_protocols & NFC_PROTO_FELICA_MASK)
                 ddev->protocols |= NFC_PROTO_FELICA_MASK;
+        if (supported_protocols & NFC_PROTO_NFC_DEP_MASK)
+                ddev->protocols |= NFC_PROTO_NFC_DEP_MASK;
 
         ddev->tx_headroom = tx_headroom + DIGITAL_MAX_HEADER_LEN;
         ddev->tx_tailroom = tx_tailroom + DIGITAL_CRC_LEN;
diff --git a/net/nfc/digital_dep.c b/net/nfc/digital_dep.c
new file mode 100644
index 000000000000..be984c4204d2
--- /dev/null
+++ b/net/nfc/digital_dep.c
@@ -0,0 +1,381 @@
+/*
+ * NFC Digital Protocol stack
+ * Copyright (c) 2013, Intel Corporation.
+ *
+ * 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 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.
+ *
+ */
+
+#include "digital.h"
+
+#define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4
+#define DIGITAL_NFC_DEP_FRAME_DIR_IN  0xD5
+
+#define DIGITAL_NFC_DEP_NFCA_SOD_SB   0xF0
+
+#define DIGITAL_CMD_ATR_REQ 0x00
+#define DIGITAL_CMD_ATR_RES 0x01
+#define DIGITAL_CMD_PSL_REQ 0x04
+#define DIGITAL_CMD_PSL_RES 0x05
+#define DIGITAL_CMD_DEP_REQ 0x06
+#define DIGITAL_CMD_DEP_RES 0x07
+
+#define DIGITAL_ATR_REQ_MIN_SIZE 16
+#define DIGITAL_ATR_REQ_MAX_SIZE 64
+
+#define DIGITAL_NFCID3_LEN ((u8)8)
+#define DIGITAL_LR_BITS_PAYLOAD_SIZE_254B 0x30
+#define DIGITAL_GB_BIT  0x02
+
+#define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0)
+
+#define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10
+
+#define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \
+                                ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT)
+#define DIGITAL_NFC_DEP_MI_BIT_SET(pfb)  ((pfb) & 0x10)
+#define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08)
+#define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & 0x04)
+#define DIGITAL_NFC_DEP_PFB_PNI(pfb)     ((pfb) & 0x03)
+
+#define DIGITAL_NFC_DEP_PFB_I_PDU          0x00
+#define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU   0x40
+#define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80
+
+struct digital_atr_req {
+        u8 dir;
+        u8 cmd;
+        u8 nfcid3[10];
+        u8 did;
+        u8 bs;
+        u8 br;
+        u8 pp;
+        u8 gb[0];
+} __packed;
+
+struct digital_atr_res {
+        u8 dir;
+        u8 cmd;
+        u8 nfcid3[10];
+        u8 did;
+        u8 bs;
+        u8 br;
+        u8 to;
+        u8 pp;
+        u8 gb[0];
+} __packed;
+
+struct digital_psl_req {
+        u8 dir;
+        u8 cmd;
+        u8 did;
+        u8 brs;
+        u8 fsl;
+} __packed;
+
+struct digital_psl_res {
+        u8 dir;
+        u8 cmd;
+        u8 did;
+} __packed;
+
+struct digital_dep_req_res {
+        u8 dir;
+        u8 cmd;
+        u8 pfb;
+} __packed;
+
+static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
+                                    struct sk_buff *resp);
+
+static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev,
+                                     struct sk_buff *skb)
+{
+        skb_push(skb, sizeof(u8));
+
+        skb->data[0] = skb->len;
+
+        if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
+                *skb_push(skb, sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB;
+}
+
+static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev,
+                                    struct sk_buff *skb)
+{
+        u8 size;
+
+        if (skb->len < 2)
+                return -EIO;
+
+        if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)
+                skb_pull(skb, sizeof(u8));
+
+        size = skb->data[0];
+        if (size != skb->len)
+                return -EIO;
+
+        skb_pull(skb, sizeof(u8));
+
+        return 0;
+}
+
+static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg,
+                                 struct sk_buff *resp)
+{
+        struct nfc_target *target = arg;
+        struct digital_atr_res *atr_res;
+        u8 gb_len;
+        int rc;
+
+        if (IS_ERR(resp)) {
+                rc = PTR_ERR(resp);
+                resp = NULL;
+                goto exit;
+        }
+
+        rc = ddev->skb_check_crc(resp);
+        if (rc) {
+                PROTOCOL_ERR("14.4.1.6");
+                goto exit;
+        }
+
+        rc = digital_skb_pull_dep_sod(ddev, resp);
+        if (rc) {
+                PROTOCOL_ERR("14.4.1.2");
+                goto exit;
+        }
+
+        if (resp->len < sizeof(struct digital_atr_res)) {
+                rc = -EIO;
+                goto exit;
+        }
+
+        gb_len = resp->len - sizeof(struct digital_atr_res);
+
+        atr_res = (struct digital_atr_res *)resp->data;
+
+        rc = nfc_set_remote_general_bytes(ddev->nfc_dev, atr_res->gb, gb_len);
+        if (rc)
+                goto exit;
+
+        rc = nfc_dep_link_is_up(ddev->nfc_dev, target->idx, NFC_COMM_ACTIVE,
+                                NFC_RF_INITIATOR);
+
+        ddev->curr_nfc_dep_pni = 0;
+
+exit:
+        dev_kfree_skb(resp);
+
+        if (rc)
+                ddev->curr_protocol = 0;
+}
+
+int digital_in_send_atr_req(struct nfc_digital_dev *ddev,
+                            struct nfc_target *target, __u8 comm_mode, __u8 *gb,
+                            size_t gb_len)
+{
+        struct sk_buff *skb;
+        struct digital_atr_req *atr_req;
+        uint size;
+
+        size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len;
+
+        if (size > DIGITAL_ATR_REQ_MAX_SIZE) {
+                PROTOCOL_ERR("14.6.1.1");
+                return -EINVAL;
+        }
+
+        skb = digital_skb_alloc(ddev, size);
+        if (!skb)
+                return -ENOMEM;
+
+        skb_put(skb, sizeof(struct digital_atr_req));
+
+        atr_req = (struct digital_atr_req *)skb->data;
+        memset(atr_req, 0, sizeof(struct digital_atr_req));
+
+        atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
+        atr_req->cmd = DIGITAL_CMD_ATR_REQ;
+        if (target->nfcid2_len)
+                memcpy(atr_req->nfcid3, target->nfcid2,
+                       max(target->nfcid2_len, DIGITAL_NFCID3_LEN));
+        else
+                get_random_bytes(atr_req->nfcid3, DIGITAL_NFCID3_LEN);
+
+        atr_req->did = 0;
+        atr_req->bs = 0;
+        atr_req->br = 0;
+
+        atr_req->pp = DIGITAL_LR_BITS_PAYLOAD_SIZE_254B;
+
+        if (gb_len) {
+                atr_req->pp |= DIGITAL_GB_BIT;
+                memcpy(skb_put(skb, gb_len), gb, gb_len);
+        }
+
+        digital_skb_push_dep_sod(ddev, skb);
+
+        ddev->skb_add_crc(skb);
+
+        digital_in_send_cmd(ddev, skb, 500, digital_in_recv_atr_res, target);
+
+        return 0;
+}
+
+static int digital_in_send_rtox(struct nfc_digital_dev *ddev,
+                                struct digital_data_exch *data_exch, u8 rtox)
+{
+        struct digital_dep_req_res *dep_req;
+        struct sk_buff *skb;
+        int rc;
+
+        skb = digital_skb_alloc(ddev, 1);
+        if (!skb)
+                return -ENOMEM;
+
+        *skb_put(skb, 1) = rtox;
+
+        skb_push(skb, sizeof(struct digital_dep_req_res));
+
+        dep_req = (struct digital_dep_req_res *)skb->data;
+
+        dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
+        dep_req->cmd = DIGITAL_CMD_DEP_REQ;
+        dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU |
+                       DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT;
+
+        digital_skb_push_dep_sod(ddev, skb);
+
+        ddev->skb_add_crc(skb);
+
+        rc = digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
+                                 data_exch);
+
+        return rc;
+}
+
+static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg,
+                                    struct sk_buff *resp)
+{
+        struct digital_data_exch *data_exch = arg;
+        struct digital_dep_req_res *dep_res;
+        u8 pfb;
+        uint size;
+        int rc;
+
+        if (IS_ERR(resp)) {
+                rc = PTR_ERR(resp);
+                resp = NULL;
+                goto exit;
+        }
+
+        rc = ddev->skb_check_crc(resp);
+        if (rc) {
+                PROTOCOL_ERR("14.4.1.6");
+                goto error;
+        }
+
+        rc = digital_skb_pull_dep_sod(ddev, resp);
+        if (rc) {
+                PROTOCOL_ERR("14.4.1.2");
+                goto exit;
+        }
+
+        dep_res = (struct digital_dep_req_res *)resp->data;
+
+        if (resp->len < sizeof(struct digital_dep_req_res) ||
+            dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN ||
+            dep_res->cmd != DIGITAL_CMD_DEP_RES) {
+                rc = -EIO;
+                goto error;
+        }
+
+        pfb = dep_res->pfb;
+
+        switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) {
+        case DIGITAL_NFC_DEP_PFB_I_PDU:
+                if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) {
+                        PROTOCOL_ERR("14.12.3.3");
+                        rc = -EIO;
+                        goto error;
+                }
+
+                ddev->curr_nfc_dep_pni =
+                        DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1);
+                rc = 0;
+                break;
+
+        case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU:
+                PR_ERR("Received a ACK/NACK PDU");
+                rc = -EIO;
+                goto error;
+
+        case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU:
+                if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) {
+                        rc = -EINVAL;
+                        goto error;
+                }
+
+                rc = digital_in_send_rtox(ddev, data_exch, resp->data[3]);
+                if (rc)
+                        goto error;
+
+                kfree_skb(resp);
+                return;
+        }
+
+        if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) {
+                PR_ERR("MI bit set. Chained PDU not supported.");
+                rc = -EIO;
+                goto error;
+        }
+
+        size = sizeof(struct digital_dep_req_res);
+
+        if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb))
+                size++;
+
+        if (size > resp->len) {
+                rc = -EIO;
+                goto error;
+        }
+
+        skb_pull(resp, size);
+
+exit:
+        data_exch->cb(data_exch->cb_context, resp, rc);
+
+error:
+        kfree(data_exch);
+
+        if (rc)
+                kfree_skb(resp);
+}
+
+int digital_in_send_dep_req(struct nfc_digital_dev *ddev,
+                            struct nfc_target *target, struct sk_buff *skb,
+                            struct digital_data_exch *data_exch)
+{
+        struct digital_dep_req_res *dep_req;
+
+        skb_push(skb, sizeof(struct digital_dep_req_res));
+
+        dep_req = (struct digital_dep_req_res *)skb->data;
+        dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT;
+        dep_req->cmd = DIGITAL_CMD_DEP_REQ;
+        dep_req->pfb = ddev->curr_nfc_dep_pni;
+
+        digital_skb_push_dep_sod(ddev, skb);
+
+        ddev->skb_add_crc(skb);
+
+        return digital_in_send_cmd(ddev, skb, 1500, digital_in_recv_dep_res,
+                                   data_exch);
+}
diff --git a/net/nfc/digital_technology.c b/net/nfc/digital_technology.c
index bfe5ae17909e..0c28f600fd1c 100644
--- a/net/nfc/digital_technology.c
+++ b/net/nfc/digital_technology.c
@@ -28,6 +28,7 @@
 
 #define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04))
 #define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60))
+#define DIGITAL_SEL_RES_IS_NFC_DEP(sel_res) ((sel_res) & 0x40)
 
 #define DIGITAL_SENS_RES_IS_T1T(sens_res) (((sens_res) & 0x000C) == 0x000C)
 #define DIGITAL_SENS_RES_IS_VALID(sens_res) \
@@ -121,6 +122,8 @@ static void digital_in_recv_sel_res(struct nfc_digital_dev *ddev, void *arg,
 
         if (DIGITAL_SEL_RES_IS_T2T(sel_res)) {
                 nfc_proto = NFC_PROTO_MIFARE;
+        } else if (DIGITAL_SEL_RES_IS_NFC_DEP(sel_res)) {
+                nfc_proto = NFC_PROTO_NFC_DEP;
         } else {
                 rc = -EOPNOTSUPP;
                 goto exit;
@@ -379,6 +382,7 @@ static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
                                    struct sk_buff *resp)
 {
         int rc;
+        u8 proto;
         struct nfc_target target;
         struct digital_sensf_res *sensf_res;
 
@@ -413,7 +417,13 @@ static void digital_in_recv_sensf_res(struct nfc_digital_dev *ddev, void *arg,
         memcpy(target.nfcid2, sensf_res->nfcid2, NFC_NFCID2_MAXSIZE);
         target.nfcid2_len = NFC_NFCID2_MAXSIZE;
 
-        rc = digital_target_found(ddev, &target, NFC_PROTO_FELICA);
+        if (target.nfcid2[0] == DIGITAL_SENSF_NFCID2_NFC_DEP_B1 &&
+            target.nfcid2[1] == DIGITAL_SENSF_NFCID2_NFC_DEP_B2)
+                proto = NFC_PROTO_NFC_DEP;
+        else
+                proto = NFC_PROTO_FELICA;
+
+        rc = digital_target_found(ddev, &target, proto);
 
 exit:
         dev_kfree_skb(resp);