1 files changed, 136 insertions, 73 deletions

diff --git a/net/nfc/nci/ntf.c b/net/nfc/nci/ntf.c
index 96633f5cda4f..b16a8dc2afbe 100644
--- a/net/nfc/nci/ntf.c
+++ b/net/nfc/nci/ntf.c
@@ -25,6 +25,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
+
 #include <linux/types.h>
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
@@ -43,18 +45,21 @@ static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
         struct nci_core_conn_credit_ntf *ntf = (void *) skb->data;
         int i;
 
-        nfc_dbg("entry, num_entries %d", ntf->num_entries);
+        pr_debug("num_entries %d\n", 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);
+                ntf->conn_entries[i].conn_id =
+                        nci_conn_id(&ntf->conn_entries[i].conn_id);
+
+                pr_debug("entry[%d]: conn_id %d, credits %d\n",
+                         i, ntf->conn_entries[i].conn_id,
+                         ntf->conn_entries[i].credits);
 
-                if (ntf->conn_entries[i].conn_id == ndev->conn_id) {
+                if (ntf->conn_entries[i].conn_id == NCI_STATIC_RF_CONN_ID) {
                         /* found static rf connection */
                         atomic_add(ntf->conn_entries[i].credits,
                                 &ndev->credits_cnt);
@@ -66,31 +71,34 @@ static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
                 queue_work(ndev->tx_wq, &ndev->tx_work);
 }
 
-static void nci_rf_field_info_ntf_packet(struct nci_dev *ndev,
-                                        struct sk_buff *skb)
+static void nci_core_conn_intf_error_ntf_packet(struct nci_dev *ndev,
+                                                struct sk_buff *skb)
 {
-        struct nci_rf_field_info_ntf *ntf = (void *) skb->data;
+        struct nci_core_intf_error_ntf *ntf = (void *) skb->data;
 
-        nfc_dbg("entry, rf_field_status %d", ntf->rf_field_status);
+        ntf->conn_id = nci_conn_id(&ntf->conn_id);
+
+        pr_debug("status 0x%x, conn_id %d\n", ntf->status, ntf->conn_id);
+
+        /* complete the data exchange transaction, if exists */
+        if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
+                nci_data_exchange_complete(ndev, NULL, -EIO);
 }
 
-static int nci_rf_activate_nfca_passive_poll(struct nci_dev *ndev,
-                        struct nci_rf_activate_ntf *ntf, __u8 *data)
+static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev,
+                        struct nci_rf_intf_activated_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);
+        pr_debug("sens_res 0x%x, nfcid1_len %d\n",
+                 nfca_poll->sens_res, nfca_poll->nfcid1_len);
 
         memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len);
         data += nfca_poll->nfcid1_len;
@@ -100,32 +108,32 @@ static int nci_rf_activate_nfca_passive_poll(struct nci_dev *ndev,
         if (nfca_poll->sel_res_len != 0)
                 nfca_poll->sel_res = *data++;
 
-        ntf->rf_interface_type = *data++;
-        ntf->activation_params_len = *data++;
+        pr_debug("sel_res_len %d, sel_res 0x%x\n",
+                 nfca_poll->sel_res_len,
+                 nfca_poll->sel_res);
 
-        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);
+        return data;
+}
 
-        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,
+static int nci_extract_activation_params_iso_dep(struct nci_dev *ndev,
+                        struct nci_rf_intf_activated_ntf *ntf, __u8 *data)
+{
+        struct activation_params_nfca_poll_iso_dep *nfca_poll;
+
+        switch (ntf->activation_rf_tech_and_mode) {
+        case NCI_NFC_A_PASSIVE_POLL_MODE:
+                nfca_poll = &ntf->activation_params.nfca_poll_iso_dep;
+                nfca_poll->rats_res_len = *data++;
+                if (nfca_poll->rats_res_len > 0) {
+                        memcpy(nfca_poll->rats_res,
                                 data,
-                                nfca_poll_iso_dep->rats_res_len);
+                                nfca_poll->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);
+                pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
+                       ntf->activation_rf_tech_and_mode);
                 return -EPROTO;
         }
 
@@ -133,7 +141,7 @@ static int nci_rf_activate_nfca_passive_poll(struct nci_dev *ndev,
 }
 
 static void nci_target_found(struct nci_dev *ndev,
-                                struct nci_rf_activate_ntf *ntf)
+                                struct nci_rf_intf_activated_ntf *ntf)
 {
         struct nfc_target nfc_tgt;
 
@@ -141,66 +149,121 @@ static void nci_target_found(struct nci_dev *ndev,
                 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;
+        else
+                nfc_tgt.supported_protocols = 0;
 
         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;
+        nfc_tgt.nfcid1_len = ntf->rf_tech_specific_params.nfca_poll.nfcid1_len;
+        if (nfc_tgt.nfcid1_len > 0) {
+                memcpy(nfc_tgt.nfcid1,
+                        ntf->rf_tech_specific_params.nfca_poll.nfcid1,
+                        nfc_tgt.nfcid1_len);
+        }
 
         if (!(nfc_tgt.supported_protocols & ndev->poll_prots)) {
-                nfc_dbg("the target found does not have the desired protocol");
+                pr_debug("the target found does not have the desired protocol\n");
                 return;
         }
 
-        nfc_dbg("new target found,  supported_protocols 0x%x",
-                nfc_tgt.supported_protocols);
+        pr_debug("new target found,  supported_protocols 0x%x\n",
+                 nfc_tgt.supported_protocols);
 
         ndev->target_available_prots = nfc_tgt.supported_protocols;
+        ndev->max_data_pkt_payload_size = ntf->max_data_pkt_payload_size;
+        ndev->initial_num_credits = ntf->initial_num_credits;
+
+        /* set the available credits to initial value */
+        atomic_set(&ndev->credits_cnt, ndev->initial_num_credits);
 
         nfc_targets_found(ndev->nfc_dev, &nfc_tgt, 1);
 }
 
-static void nci_rf_activate_ntf_packet(struct nci_dev *ndev,
-                                        struct sk_buff *skb)
+static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
+                                                struct sk_buff *skb)
 {
-        struct nci_rf_activate_ntf ntf;
+        struct nci_rf_intf_activated_ntf ntf;
         __u8 *data = skb->data;
-        int rc = -1;
+        int err = 0;
 
         clear_bit(NCI_DISCOVERY, &ndev->flags);
         set_bit(NCI_POLL_ACTIVE, &ndev->flags);
 
-        ntf.target_handle = *data++;
+        ntf.rf_discovery_id = *data++;
+        ntf.rf_interface = *data++;
         ntf.rf_protocol = *data++;
-        ntf.rf_tech_and_mode = *data++;
+        ntf.activation_rf_tech_and_mode = *data++;
+        ntf.max_data_pkt_payload_size = *data++;
+        ntf.initial_num_credits = *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;
+        pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id);
+        pr_debug("rf_interface 0x%x\n", ntf.rf_interface);
+        pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol);
+        pr_debug("activation_rf_tech_and_mode 0x%x\n",
+                 ntf.activation_rf_tech_and_mode);
+        pr_debug("max_data_pkt_payload_size 0x%x\n",
+                 ntf.max_data_pkt_payload_size);
+        pr_debug("initial_num_credits 0x%x\n", ntf.initial_num_credits);
+        pr_debug("rf_tech_specific_params_len %d\n",
+                 ntf.rf_tech_specific_params_len);
+
+        if (ntf.rf_tech_specific_params_len > 0) {
+                switch (ntf.activation_rf_tech_and_mode) {
+                case NCI_NFC_A_PASSIVE_POLL_MODE:
+                        data = nci_extract_rf_params_nfca_passive_poll(ndev,
+                                &ntf, data);
+                        break;
+
+                default:
+                        pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
+                               ntf.activation_rf_tech_and_mode);
+                        return;
+                }
+        }
 
-        default:
-                nfc_err("unsupported rf_tech_and_mode 0x%x",
-                        ntf.rf_tech_and_mode);
-                return;
+        ntf.data_exch_rf_tech_and_mode = *data++;
+        ntf.data_exch_tx_bit_rate = *data++;
+        ntf.data_exch_rx_bit_rate = *data++;
+        ntf.activation_params_len = *data++;
+
+        pr_debug("data_exch_rf_tech_and_mode 0x%x\n",
+                 ntf.data_exch_rf_tech_and_mode);
+        pr_debug("data_exch_tx_bit_rate 0x%x\n",
+                 ntf.data_exch_tx_bit_rate);
+        pr_debug("data_exch_rx_bit_rate 0x%x\n",
+                 ntf.data_exch_rx_bit_rate);
+        pr_debug("activation_params_len %d\n",
+                 ntf.activation_params_len);
+
+        if (ntf.activation_params_len > 0) {
+                switch (ntf.rf_interface) {
+                case NCI_RF_INTERFACE_ISO_DEP:
+                        err = nci_extract_activation_params_iso_dep(ndev,
+                                &ntf, data);
+                        break;
+
+                case NCI_RF_INTERFACE_FRAME:
+                        /* no activation params */
+                        break;
+
+                default:
+                        pr_err("unsupported rf_interface 0x%x\n",
+                               ntf.rf_interface);
+                        return;
+                }
         }
 
-        if (!rc)
+        if (!err)
                 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];
+        struct nci_rf_deactivate_ntf *ntf = (void *) skb->data;
 
-        nfc_dbg("entry, type 0x%x", type);
+        pr_debug("entry, type 0x%x, reason 0x%x\n", ntf->type, ntf->reason);
 
         clear_bit(NCI_POLL_ACTIVE, &ndev->flags);
         ndev->target_active_prot = 0;
@@ -223,11 +286,11 @@ 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));
+        pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
+                 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);
@@ -237,12 +300,12 @@ void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
                 nci_core_conn_credits_ntf_packet(ndev, skb);
                 break;
 
-        case NCI_OP_RF_FIELD_INFO_NTF:
-                nci_rf_field_info_ntf_packet(ndev, skb);
+        case NCI_OP_CORE_INTF_ERROR_NTF:
+                nci_core_conn_intf_error_ntf_packet(ndev, skb);
                 break;
 
-        case NCI_OP_RF_ACTIVATE_NTF:
-                nci_rf_activate_ntf_packet(ndev, skb);
+        case NCI_OP_RF_INTF_ACTIVATED_NTF:
+                nci_rf_intf_activated_ntf_packet(ndev, skb);
                 break;
 
         case NCI_OP_RF_DEACTIVATE_NTF:
@@ -250,7 +313,7 @@ void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
                 break;
 
         default:
-                nfc_err("unknown ntf opcode 0x%x", ntf_opcode);
+                pr_err("unknown ntf opcode 0x%x\n", ntf_opcode);
                 break;
         }