Snap for 9428991 from 72b872097da907a1c30debf5c2770ad035d59889 to udc-release

Change-Id: I33c61b6fafed0fa1a0f04e1992312fa4bd42aaab

1 files changed, 130 insertions, 40 deletions

diff --git a/bcmdhd/wifi_hal/rtt.cpp b/bcmdhd/wifi_hal/rtt.cpp
index 603caf3..202fb33 100644
--- a/bcmdhd/wifi_hal/rtt.cpp
+++ b/bcmdhd/wifi_hal/rtt.cpp
@@ -48,7 +48,8 @@
 #include "cpp_bindings.h"
 
 using namespace android;
-#define RTT_RESULT_SIZE (sizeof(wifi_rtt_result));
+#define RTT_RESULT_V2_SIZE (sizeof(wifi_rtt_result_v2))
+#define RTT_RESULT_V1_SIZE (sizeof(wifi_rtt_result))
 typedef enum {
 
     RTT_SUBCMD_SET_CONFIG = ANDROID_NL80211_SUBCMD_RTT_RANGE_START,
@@ -82,6 +83,8 @@ typedef enum {
     RTT_ATTRIBUTE_RESULT_CNT                = 32,
     RTT_ATTRIBUTE_RESULT                    = 33,
     RTT_ATTRIBUTE_RESUTL_DETAIL             = 34,
+    RTT_ATTRIBUTE_RESULT_FREQ               = 35,
+    RTT_ATTRIBUTE_RESULT_BW                 = 36,
     /* Add any new RTT_ATTRIBUTE prior to RTT_ATTRIBUTE_MAX */
     RTT_ATTRIBUTE_MAX
 } RTT_ATTRIBUTE;
@@ -321,9 +324,15 @@ class RttCommand : public WifiCommand
     int currDtlIdx;
     int totalCnt;
     static const int MAX_RESULTS = 1024;
-    wifi_rtt_result *rttResults[MAX_RESULTS];
+    wifi_rtt_result_v2 *rttResults[MAX_RESULTS];
     wifi_rtt_config *rttParams;
     wifi_rtt_event_handler rttHandler;
+    int nextidx = 0;
+    wifi_rtt_result *rttResultsV1[MAX_RESULTS];
+    wifi_channel channel;
+    wifi_rtt_bw bw = WIFI_RTT_BW_UNSPECIFIED;
+    int result_size;
+    int opt_result_size;
 public:
     RttCommand(wifi_interface_handle iface, int id, unsigned num_rtt_config,
             wifi_rtt_config rtt_config[], wifi_rtt_event_handler handler)
@@ -331,6 +340,7 @@ public:
         rttHandler(handler)
     {
         memset(rttResults, 0, sizeof(rttResults));
+        memset(rttResultsV1, 0, sizeof(rttResultsV1));
         currentIdx = 0;
         mCompleted = 0;
         totalCnt = 0;
@@ -345,9 +355,10 @@ public:
         totalCnt = 0;
         currDtlIdx = 0;
         numRttParams = 0;
-	memset(rttResults, 0, sizeof(rttResults));
-	rttParams = NULL;
-	rttHandler.on_rtt_results = NULL;
+        memset(rttResults, 0, sizeof(rttResults));
+        memset(rttResultsV1, 0, sizeof(rttResultsV1));
+        rttParams = NULL;
+        rttHandler.on_rtt_results_v2 = NULL;
     }
 
     int createSetupRequest(WifiRequest& request) {
@@ -563,79 +574,158 @@ public:
                                 bssid[3],
                                 bssid[4],
                                 bssid[5]);
+                    } else if (it2.get_type() == RTT_ATTRIBUTE_RESULT_FREQ) {
+                        channel = it2.get_u32();
+                        if (rttResults[currentIdx] == NULL) {
+                            ALOGE("Not allocated\n");
+                            break;
+                        }
+                        if (!channel) {
+                            rttResults[currentIdx]->frequency = UNSPECIFIED;
+                        } else {
+                            rttResults[currentIdx]->frequency = channel;
+                        }
+                        ALOGI("retrieved rtt_result : \n\tchannel :%d",
+                            rttResults[currentIdx]->frequency);
+                    } else if (it2.get_type() == RTT_ATTRIBUTE_RESULT_BW) {
+                        bw = (wifi_rtt_bw)it2.get_u32();
+                        if (rttResults[currentIdx] == NULL) {
+                            ALOGE("Not allocated\n");
+                            break;
+                        }
+                        rttResults[currentIdx]->packet_bw = bw;
+                        ALOGI("retrieved rtt_result : \n\tpacket_bw :%d",
+                            rttResults[currentIdx]->packet_bw);
                     } else if (it2.get_type() == RTT_ATTRIBUTE_RESULT_CNT) {
                         result_cnt = it2.get_u32();
                         ALOGI("retrieved result_cnt : %d\n", result_cnt);
                     } else if (it2.get_type() == RTT_ATTRIBUTE_RESULT) {
+                        currentIdx = nextidx;
                         int result_len = it2.get_len();
-                        rttResults[currentIdx] =  (wifi_rtt_result *)malloc(it2.get_len());
-                        wifi_rtt_result *rtt_result = rttResults[currentIdx];
-                        if (rtt_result == NULL) {
+                        rttResultsV1[currentIdx] =
+                            (wifi_rtt_result *)malloc(it2.get_len());
+                        wifi_rtt_result *rtt_results_v1 = rttResultsV1[currentIdx];
+                        if (rtt_results_v1 == NULL) {
                             mCompleted = 1;
-                            ALOGE("failed to allocate the wifi_rtt_result\n");
+                            ALOGE("failed to allocate the wifi_result_v1\n");
                             break;
                         }
-                        memcpy(rtt_result, it2.get_data(), it2.get_len());
-                        result_len -= sizeof(wifi_rtt_result);
+
+                        /* Populate to the rtt_results_v1 struct */
+                        memcpy(rtt_results_v1, it2.get_data(), it2.get_len());
+
+                        /* handle the optional data */
+                        result_len -= RTT_RESULT_V1_SIZE;
                         if (result_len > 0) {
                             dot11_rm_ie_t *ele_1;
                             dot11_rm_ie_t *ele_2;
                             /* The result has LCI or LCR element */
-                            ele_1 = (dot11_rm_ie_t *)(rtt_result + 1);
+                            ele_1 = (dot11_rm_ie_t *)(rtt_results_v1 + 1);
                             if (ele_1->id == DOT11_MNG_MEASURE_REPORT_ID) {
                                 if (ele_1->type == DOT11_MEASURE_TYPE_LCI) {
-                                    rtt_result->LCI = (wifi_information_element *)ele_1;
+                                    rtt_results_v1->LCI = (wifi_information_element *)ele_1;
                                     result_len -= (ele_1->len + DOT11_HDR_LEN);
+                                    opt_result_size += (ele_1->len + DOT11_HDR_LEN);
                                     /* get a next rm ie */
                                     if (result_len > 0) {
-                                        ele_2 = (dot11_rm_ie_t *)((char *)ele_1 + (ele_1->len + DOT11_HDR_LEN));
+                                        ele_2 = (dot11_rm_ie_t *)((char *)ele_1 +
+                                            (ele_1->len + DOT11_HDR_LEN));
                                         if ((ele_2->id == DOT11_MNG_MEASURE_REPORT_ID) &&
                                                 (ele_2->type == DOT11_MEASURE_TYPE_CIVICLOC)) {
-                                            rtt_result->LCR = (wifi_information_element *)ele_2;
+                                            rtt_results_v1->LCR = (wifi_information_element *)ele_2;
                                         }
                                     }
                                 } else if (ele_1->type == DOT11_MEASURE_TYPE_CIVICLOC){
-                                    rtt_result->LCR = (wifi_information_element *)ele_1;
+                                    rtt_results_v1->LCR = (wifi_information_element *)ele_1;
                                     result_len -= (ele_1->len + DOT11_HDR_LEN);
+                                    opt_result_size += (ele_1->len + DOT11_HDR_LEN);
                                     /* get a next rm ie */
                                     if (result_len > 0) {
-                                        ele_2 = (dot11_rm_ie_t *)((char *)ele_1 + (ele_1->len + DOT11_HDR_LEN));
+                                        ele_2 = (dot11_rm_ie_t *)((char *)ele_1 +
+                                                (ele_1->len + DOT11_HDR_LEN));
                                         if ((ele_2->id == DOT11_MNG_MEASURE_REPORT_ID) &&
                                                 (ele_2->type == DOT11_MEASURE_TYPE_LCI)) {
-                                            rtt_result->LCI = (wifi_information_element *)ele_2;
+                                            rtt_results_v1->LCI = (wifi_information_element *)ele_2;
                                         }
                                     }
                                 }
                             }
                         }
+
+                        /* Alloc new struct including new elements, reserve for new elements */
+                        rttResults[currentIdx] =
+                            (wifi_rtt_result_v2 *)malloc(RTT_RESULT_V2_SIZE + opt_result_size);
+                        wifi_rtt_result_v2 *rtt_result_v2 = rttResults[currentIdx];
+                        if (rtt_result_v2 == NULL) {
+                            ALOGE("failed to allocate the rtt_result\n");
+                            break;
+                        }
+
+                        /* Populate the new struct as per the legacy struct elements */
+                        memcpy(&rtt_result_v2->rtt_result,
+                            (wifi_rtt_result *)rtt_results_v1, RTT_RESULT_V1_SIZE);
+                        if (!channel) {
+                            rtt_result_v2->frequency = WIFI_CHAN_WIDTH_INVALID;
+                        }
+
+                        /* Copy the optional data to new struct */
+                        if (opt_result_size &&
+                            (opt_result_size == (it2.get_len() - RTT_RESULT_V1_SIZE))) {
+
+                            wifi_rtt_result_v2 *opt_rtt_result = NULL;
+                            /* Intersect the optional data from legacy rtt result struct */
+                            wifi_rtt_result *opt_legacy_rtt_result =
+                                (wifi_rtt_result *)(rtt_results_v1 + RTT_RESULT_V1_SIZE);
+
+                            /* shift dest buf by size of new rtt result struct */
+                            opt_rtt_result =
+                                (wifi_rtt_result_v2 *)rtt_result_v2 + RTT_RESULT_V2_SIZE;
+
+                            /* Append optional rtt_result_v1 data to rtt_result_v2 */
+                            memcpy(opt_rtt_result, opt_legacy_rtt_result,
+                                (it2.get_len() - RTT_RESULT_V1_SIZE));
+                        } else {
+                           ALOGI("Optional rtt result elements missing, skip processing\n");
+                        }
+
                         totalCnt++;
-                        ALOGI("retrived rtt_result : \n\tburst_num :%d, measurement_number : %d, success_number : %d\n"
-                                "\tnumber_per_burst_peer : %d, status : %s, retry_after_duration : %d s\n"
-				"\trssi : %d dbm, rx_rate : %d Kbps, rtt : %lu ns, rtt_sd : %lu\n"
-				"\tdistance : %d cm, burst_duration : %d ms, negotiated_burst_num : %d\n",
-                                rtt_result->burst_num, rtt_result->measurement_number,
-                                rtt_result->success_number, rtt_result->number_per_burst_peer,
-                                get_err_info(rtt_result->status), rtt_result->retry_after_duration,
-                                rtt_result->rssi, rtt_result->rx_rate.bitrate * 100,
-				(unsigned long)rtt_result->rtt/1000, (unsigned long)rtt_result->rtt_sd,
-			       	rtt_result->distance_mm / 10,
-                                rtt_result->burst_duration, rtt_result->negotiated_burst_num);
-                        currentIdx++;
+                        ALOGI("retrieved rtt_result : \n\tburst_num :%d, measurement_number : %d"
+                                ", success_number : %d \tnumber_per_burst_peer : %d, status : %s,"
+                                " retry_after_duration : %d s\n \trssi : %d dbm,"
+                                " rx_rate : %d Kbps, rtt : %lu ns, rtt_sd : %lu\n"
+                                "\tdistance : %d cm, burst_duration : %d ms,"
+                                " negotiated_burst_num : %d\n",
+                                rtt_results_v1->burst_num, rtt_results_v1->measurement_number,
+                                rtt_results_v1->success_number,
+                                rtt_results_v1->number_per_burst_peer,
+                                get_err_info(rtt_results_v1->status),
+                                rtt_results_v1->retry_after_duration,
+                                rtt_results_v1->rssi, rtt_results_v1->rx_rate.bitrate * 100,
+                                (unsigned long)rtt_results_v1->rtt/1000,
+                                (unsigned long)rtt_results_v1->rtt_sd,
+                                rtt_results_v1->distance_mm / 10,
+                                rtt_results_v1->burst_duration,
+                                rtt_results_v1->negotiated_burst_num);
+                        nextidx = currentIdx++;
                     }
                 }
             }
-
         }
         if (mCompleted) {
             unregisterVendorHandler(GOOGLE_OUI, RTT_EVENT_COMPLETE);
-	    if (*rttHandler.on_rtt_results) {
-                (*rttHandler.on_rtt_results)(id(), totalCnt, rttResults);
+            {
+                if (*rttHandler.on_rtt_results_v2) {
+                    (*rttHandler.on_rtt_results_v2)(id(), totalCnt, rttResults);
+                }
             }
             for (int i = 0; i < currentIdx; i++) {
                 free(rttResults[i]);
                 rttResults[i] = NULL;
+
+                free(rttResultsV1[i]);
+                rttResultsV1[i] = NULL;
             }
-            totalCnt = currentIdx = 0;
+            totalCnt = currentIdx = nextidx = 0;
             WifiCommand *cmd = wifi_unregister_cmd(wifiHandle(), id());
             if (cmd)
                 cmd->releaseRef();
@@ -650,16 +740,16 @@ wifi_error wifi_rtt_range_request(wifi_request_id id, wifi_interface_handle ifac
         unsigned num_rtt_config, wifi_rtt_config rtt_config[], wifi_rtt_event_handler handler)
 {
     if (iface == NULL) {
-	ALOGE("wifi_rtt_range_request: NULL iface pointer provided."
-		" Exit.");
-	return WIFI_ERROR_INVALID_ARGS;
+        ALOGE("wifi_rtt_range_request: NULL iface pointer provided."
+            " Exit.");
+        return WIFI_ERROR_INVALID_ARGS;
     }
 
     wifi_handle handle = getWifiHandle(iface);
     if (handle == NULL) {
-	ALOGE("wifi_rtt_range_request: NULL handle pointer provided."
-	" Exit.");
-	return WIFI_ERROR_INVALID_ARGS;
+        ALOGE("wifi_rtt_range_request: NULL handle pointer provided."
+            " Exit.");
+        return WIFI_ERROR_INVALID_ARGS;
     }
 
     ALOGI("Rtt range_request; id = %d", id);