Further Availability Map Structure change

Multiple channels were not supported as part of further
availability map. This change is to add the support for the same.

Change-Id: Id2221e207b0dd2f566fefafe84caf18fe4ea0c54
CRs-Fixed: 780180

5 files changed, 119 insertions, 61 deletions

diff --git a/qcwcn/wifi_hal/nan.h b/qcwcn/wifi_hal/nan.h
index 688a8b5..02a5551 100644
--- a/qcwcn/wifi_hal/nan.h
+++ b/qcwcn/wifi_hal/nan.h
@@ -44,8 +44,6 @@ typedef int NanVersion;
 #define NAN_MAJOR_VERSION               2
 #define NAN_MINOR_VERSION               0
 #define NAN_MICRO_VERSION               0
-#define NAN_TRANSMIT_POST_CONNECTIVITY_CAPABILITY_SIZE 4
-#define NAN_FURTHER_AVAILABILITY_MAP_SIZE 8
 #define NAN_MAX_SOCIAL_CHANNEL 3
 
 /* NAN Maximum Lengths */
@@ -56,6 +54,7 @@ typedef int NanVersion;
 #define NAN_MAX_MESH_DATA_LEN                   32
 #define NAN_MAX_CLUSTER_ATTRIBUTE_LEN           255
 #define NAN_MAX_SUBSCRIBE_MAX_ADDRESS           42
+#define NAN_MAX_FAM_CHANNELS                    32
 
 /*
   Definition of various NanRequestType
@@ -488,16 +487,9 @@ typedef enum {
     NAN_DURATION_32MS = 1,
     NAN_DURATION_64MS = 2
 } NanAvailDuration;
-/*
-  Further availability map which can sent and received from
-  Discovery engine
-*/
+
+/* Further availability per channel information */
 typedef struct {
-    /*
-       Number of channels indicates the number of entries
-       in vector which is part of fam
-    */
-    u8 numchans;
     /* Defined above */
     NanAvailDuration entry_control;
     /*
@@ -541,9 +533,19 @@ typedef struct {
        - Duration field is equal to 2, AIB [0], AIB [1], AIB [2] and AIB [3] are valid
     */
     u32 avail_interval_bitmap;
-    /* Additional Vendor elements if numchans > 1*/
-    u32 vendor_elements_len;
-    u8 vendor_elements[NAN_MAX_VSA_DATA_LEN];
+} NanFurtherAvailabilityChannel;
+
+/*
+  Further availability map which can be sent and received from
+  Discovery engine
+*/
+typedef struct {
+    /*
+       Number of channels indicates the number of channel
+       entries which is part of fam
+    */
+    u8 numchans;
+    NanFurtherAvailabilityChannel famchan[NAN_MAX_FAM_CHANNELS];
 } NanFurtherAvailabilityMap;
 
 /*
diff --git a/qcwcn/wifi_hal/nan_i.h b/qcwcn/wifi_hal/nan_i.h
index e269250..3bb531a 100644
--- a/qcwcn/wifi_hal/nan_i.h
+++ b/qcwcn/wifi_hal/nan_i.h
@@ -865,6 +865,32 @@ typedef enum
     /* Reserved 20480 - 65535*/
     NAN_TLV_TYPE_FW_LAST = 65535
 } NanFwTlvType;
+
+typedef struct PACKED
+{
+    u8 availIntDuration:2;
+    u8 mapId:4;
+    u8 reserved:2;
+} NanApiEntryCtrl;
+
+/*
+ * Valid Operating Classes were derived from IEEE Std. 802.11-2012 Annex E
+ * Table E-4 Global Operating Classe and, filtered by channel, are: 81, 83,
+ * 84, 103, 114, 115, 116, 124, 125.
+ */
+typedef struct PACKED
+{
+    NanApiEntryCtrl entryCtrl;
+    u8 opClass;
+    u8 channel;
+    u8 availIntBitmap[4];
+} NanFurtherAvailabilityChan, *pNanFurtherAvailabilityChan;
+
+typedef struct PACKED
+{
+    u8 numChan;
+    u8 pFaChan[];
+} NanFurtherAvailabilityMapAttrTlv, *pNanFurtherAvailabilityMapAttrTlv;
 #endif /* NAN_2_0 */
 
 #ifdef __cplusplus
diff --git a/qcwcn/wifi_hal/nan_ind.cpp b/qcwcn/wifi_hal/nan_ind.cpp
index 41fb0f0..cdf61d3 100644
--- a/qcwcn/wifi_hal/nan_ind.cpp
+++ b/qcwcn/wifi_hal/nan_ind.cpp
@@ -264,8 +264,8 @@ int NanCommand::getNanPublishReplied(NanPublishRepliedInd *event)
             /* Populate further availability bitmap from
                received TLV */
             ret = getNanFurtherAvailabilityMap(outputTlv.value,
-                                                   outputTlv.length,
-                                                   &event->fam);
+                                               outputTlv.length,
+                                               &event->fam);
             if (ret == 0) {
                 event->is_fam_valid = 1;
             }
@@ -411,8 +411,8 @@ int NanCommand::getNanMatch(NanMatchInd *event)
             /* Populate further availability bitmap from
                received TLV */
             ret = getNanFurtherAvailabilityMap(outputTlv.value,
-                                                   outputTlv.length,
-                                                   &event->fam);
+                                               outputTlv.length,
+                                               &event->fam);
             if (ret == 0) {
                 event->is_fam_valid = 1;
             }
@@ -882,34 +882,34 @@ int NanCommand::getNanFurtherAvailabilityMap(const u8 *pInValue,
                                              NanFurtherAvailabilityMap *pFam)
 {
 #ifdef NAN_2_0
-    if ((length <= NAN_FURTHER_AVAILABILITY_MAP_SIZE) ||
-        pInValue == NULL) {
-        ALOGE("%s: Invalid Arg TLV Len %d < %d", __func__,
-              length, NAN_FURTHER_AVAILABILITY_MAP_SIZE);
+    int idx = 0;
+
+    if ((length == 0) || pInValue == NULL) {
+        ALOGE("%s: Invalid Arg TLV Len %d or pInValue NULL",
+              __func__, length);
         return -1;
     }
 
     pFam->numchans = pInValue[0];
-    pFam->entry_control = (NanAvailDuration)(pInValue[1] & 0x03);
-    pFam->class_val = pInValue[2];
-    pFam->channel = pInValue[3];
-    pFam->mapid = (pInValue[1] >> 2) & 0x0F;
-    memcpy(&pFam->avail_interval_bitmap,
-           &pInValue[4],
-           sizeof(pFam->avail_interval_bitmap));
-    pFam->vendor_elements_len = 0;
-    if (pFam->numchans > 1) {
-        pFam->vendor_elements_len = length - \
-            NAN_FURTHER_AVAILABILITY_MAP_SIZE;
-        if (pFam->vendor_elements_len > NAN_MAX_VSA_DATA_LEN) {
-            pFam->vendor_elements_len = NAN_MAX_VSA_DATA_LEN;
-        }
-        memcpy(pFam->vendor_elements, &pInValue[8],
-               pFam->vendor_elements_len);
+    if (pFam->numchans > NAN_MAX_FAM_CHANNELS) {
+        ALOGE("%s: Unable to accommodate numchans %d",
+              __func__, pFam->numchans);
+        return -1;
     }
-    else {
-        memset(pFam->vendor_elements, 0,
-               sizeof(pFam->vendor_elements));
+    for (idx = 0; idx < pFam->numchans; idx++) {
+        pNanFurtherAvailabilityChan pRsp = \
+              (pNanFurtherAvailabilityChan)((u8*)pInValue[1] + \
+              (idx * sizeof(NanFurtherAvailabilityChan)));
+        NanFurtherAvailabilityChannel *pFamChan = &pFam->famchan[idx];
+
+        pFamChan->entry_control = \
+            (NanAvailDuration)(pRsp->entryCtrl.availIntDuration);
+        pFamChan->mapid = pRsp->entryCtrl.mapId;
+        pFamChan->class_val = pRsp->opClass;
+        pFamChan->channel = pRsp->channel;
+        memcpy(&pFamChan->avail_interval_bitmap,
+               &pRsp->availIntBitmap,
+               sizeof(pFamChan->avail_interval_bitmap));
     }
 #endif /* NAN_2_0*/
     return 0;
diff --git a/qcwcn/wifi_hal/nan_req.cpp b/qcwcn/wifi_hal/nan_req.cpp
index 250a5bd..4179398 100644
--- a/qcwcn/wifi_hal/nan_req.cpp
+++ b/qcwcn/wifi_hal/nan_req.cpp
@@ -324,12 +324,13 @@ int NanCommand::putNanConfig(const NanConfigRequest *pReq)
          (
            pReq->config_discovery_attr ? (SIZEOF_TLV_HDR + \
            calcNanTransmitPostDiscoverySize(&pReq->discovery_attr_val)) : 0 \
-         ) + \
-         (
-           pReq->config_fam ? (SIZEOF_TLV_HDR + \
-           NAN_FURTHER_AVAILABILITY_MAP_SIZE + \
-           pReq->fam_val.vendor_elements_len) : 0 \
          );
+
+    if (pReq->config_fam && \
+        calcNanFurtherAvailabilityMapSize(&pReq->fam_val)) {
+        message_len += (SIZEOF_TLV_HDR + \
+           calcNanFurtherAvailabilityMapSize(&pReq->fam_val));
+    }
 #endif /* NAN_2_0 */
 
     pNanConfigurationReqMsg pFwReq = (pNanConfigurationReqMsg)malloc(message_len);
@@ -428,12 +429,12 @@ int NanCommand::putNanConfig(const NanConfigRequest *pReq)
                       calcNanTransmitPostDiscoverySize(&pReq->discovery_attr_val),
                       (const u8*)(tlvs + SIZEOF_TLV_HDR), tlvs);
     }
-    if (pReq->config_fam) {
+    if (pReq->config_fam && \
+        calcNanFurtherAvailabilityMapSize(&pReq->fam_val)) {
         fillNanFurtherAvailabilityMapVal(&pReq->fam_val,
                                         (u8*)(tlvs + SIZEOF_TLV_HDR));
         tlvs = addTlv(NAN_TLV_TYPE_FURTHER_AVAILABILITY_MAP,
-                      (NAN_FURTHER_AVAILABILITY_MAP_SIZE + \
-                       pReq->fam_val.vendor_elements_len),
+                      calcNanFurtherAvailabilityMapSize(&pReq->fam_val),
                       (const u8*)(tlvs + SIZEOF_TLV_HDR), tlvs);
     }
 #endif /* NAN_2_0 */
@@ -1049,23 +1050,50 @@ void NanCommand::fillNanFurtherAvailabilityMapVal(
     const NanFurtherAvailabilityMap *pFam,
     u8 *pOutValue)
 {
+    int idx = 0;
+
     if (pFam && pOutValue) {
-        u32 famsize = NAN_FURTHER_AVAILABILITY_MAP_SIZE + \
-            pFam->vendor_elements_len;
+        u32 famsize = calcNanFurtherAvailabilityMapSize(pFam);
+        pNanFurtherAvailabilityMapAttrTlv pFwReq = \
+            (pNanFurtherAvailabilityMapAttrTlv)pOutValue;
+
         memset(pOutValue, 0, famsize);
-        pOutValue[0] = pFam->numchans;
-        pOutValue[1] = (pFam->mapid & 0x0F) << 2;
-        pOutValue[1] |= (pFam->entry_control & 0x03);
-        pOutValue[2] = pFam->class_val;
-        pOutValue[3] = pFam->channel;
-        memcpy(&pOutValue[4], &pFam->avail_interval_bitmap,
-               sizeof(pFam->avail_interval_bitmap));
-        memcpy(&pOutValue[NAN_FURTHER_AVAILABILITY_MAP_SIZE],
-               pFam->vendor_elements,
-               pFam->vendor_elements_len);
+        pFwReq->numChan = pFam->numchans;
+        for (idx = 0; idx < pFam->numchans; idx++) {
+            const NanFurtherAvailabilityChannel *pFamChan =  \
+                &pFam->famchan[idx];
+            pNanFurtherAvailabilityChan pFwFamChan = \
+                (pNanFurtherAvailabilityChan)((u8*)&pFwReq->pFaChan[0] + \
+                (idx * sizeof(NanFurtherAvailabilityChan)));
+
+            pFwFamChan->entryCtrl.availIntDuration = \
+                pFamChan->entry_control;
+            pFwFamChan->entryCtrl.mapId = \
+                pFamChan->mapid;
+            pFwFamChan->opClass =  pFamChan->class_val;
+            pFwFamChan->channel = pFamChan->channel;
+            memcpy(&pFwFamChan->availIntBitmap,
+                   &pFamChan->avail_interval_bitmap,
+                   sizeof(pFwFamChan->availIntBitmap));
+        }
         ALOGI("%s: Filled FurtherAvailabilityMapVal", __func__);
         hexdump((char*)pOutValue, famsize);
     }
     return;
 }
 
+int NanCommand::calcNanFurtherAvailabilityMapSize(
+    const NanFurtherAvailabilityMap *pFam)
+{
+    int ret = 0;
+    if (pFam && pFam->numchans &&
+        pFam->numchans <= NAN_MAX_FAM_CHANNELS) {
+        /* Fixed size of u8 for numchans*/
+        ret = sizeof(u8);
+        /* numchans * sizeof(FamChannels) */
+        ret += (pFam->numchans * sizeof(NanFurtherAvailabilityChan));
+    }
+    ALOGI("%s:size:%d", __func__, ret);
+    return ret;
+}
+
diff --git a/qcwcn/wifi_hal/nancommand.h b/qcwcn/wifi_hal/nancommand.h
index dabc115..096fc71 100644
--- a/qcwcn/wifi_hal/nancommand.h
+++ b/qcwcn/wifi_hal/nancommand.h
@@ -73,6 +73,8 @@ private:
     void fillNanTransmitPostDiscoveryVal(
         const NanTransmitPostDiscovery *pTxDisc,
         u8 *pOutValue);
+    int calcNanFurtherAvailabilityMapSize(
+        const NanFurtherAvailabilityMap *pFam);
     void fillNanFurtherAvailabilityMapVal(
         const NanFurtherAvailabilityMap *pFam,
         u8 *pOutValue);