/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "sync.h" #define LOG_TAG "WifiHAL" #include #include #include #include #include "common.h" #include "cpp_bindings.h" #include "gscancommand.h" #include "gscan_event_handler.h" #include "vendor_definitions.h" #define GSCAN_EVENT_WAIT_TIME_SECONDS 4 #define WIFI_SCANNING_MAC_OUI_LENGTH 3 #define EPNO_NO_NETWORKS 0 /* BSSID blacklist */ typedef struct { int num_bssid; // number of blacklisted BSSIDs mac_addr bssids[MAX_BLACKLIST_BSSID]; // blacklisted BSSIDs } wifi_bssid_params; /* Used to handle gscan command events from driver/firmware.*/ typedef struct gscan_event_handlers_s { GScanCommandEventHandler *gscanStartCmdEventHandler; GScanCommandEventHandler *gScanSetBssidHotlistCmdEventHandler; GScanCommandEventHandler *gScanSetSignificantChangeCmdEventHandler; GScanCommandEventHandler *gScanSetSsidHotlistCmdEventHandler; GScanCommandEventHandler *gScanSetPnoListCmdEventHandler; GScanCommandEventHandler *gScanPnoSetPasspointListCmdEventHandler; } gscan_event_handlers; wifi_error initializeGscanHandlers(hal_info *info) { info->gscan_handlers = (gscan_event_handlers *)malloc(sizeof(gscan_event_handlers)); if (info->gscan_handlers) { memset(info->gscan_handlers, 0, sizeof(gscan_event_handlers)); } else { ALOGE("%s: Allocation of gscan event handlers failed", __FUNCTION__); return WIFI_ERROR_OUT_OF_MEMORY; } return WIFI_SUCCESS; } wifi_error cleanupGscanHandlers(hal_info *info) { gscan_event_handlers* event_handlers; if (info && info->gscan_handlers) { event_handlers = (gscan_event_handlers*) info->gscan_handlers; if (event_handlers->gscanStartCmdEventHandler) { delete event_handlers->gscanStartCmdEventHandler; } if (event_handlers->gScanSetBssidHotlistCmdEventHandler) { delete event_handlers->gScanSetBssidHotlistCmdEventHandler; } if (event_handlers->gScanSetSignificantChangeCmdEventHandler) { delete event_handlers->gScanSetSignificantChangeCmdEventHandler; } if (event_handlers->gScanSetSsidHotlistCmdEventHandler) { delete event_handlers->gScanSetSsidHotlistCmdEventHandler; } if (event_handlers->gScanSetPnoListCmdEventHandler) { delete event_handlers->gScanSetPnoListCmdEventHandler; } if (event_handlers->gScanPnoSetPasspointListCmdEventHandler) { delete event_handlers->gScanPnoSetPasspointListCmdEventHandler; } memset(event_handlers, 0, sizeof(gscan_event_handlers)); free(info->gscan_handlers); info->gscan_handlers = NULL; return WIFI_SUCCESS; } ALOGE ("%s: info or info->gscan_handlers NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Implementation of the API functions exposed in gscan.h */ wifi_error wifi_get_valid_channels(wifi_interface_handle handle, int band, int max_channels, wifi_channel *channels, int *num_channels) { int requestId; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(handle); wifi_handle wifiHandle = getWifiHandle(handle); /* No request id from caller, so generate one and pass it on to the driver. * Generate one randomly. */ requestId = get_requestid(); ALOGV("%s: RequestId:%d band:%d max_channels:%d", __FUNCTION__, requestId, band, max_channels); if (channels == NULL) { ALOGE("%s: NULL channels pointer provided. Exit.", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } gScanCommand = new GScanCommand( wifiHandle, requestId, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_GET_VALID_CHANNELS); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, requestId) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND, band) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_MAX_CHANNELS, max_channels) ) { goto cleanup; } gScanCommand->attr_end(nlData); /* Populate the input received from caller/framework. */ gScanCommand->setMaxChannels(max_channels); gScanCommand->setChannels(channels); gScanCommand->setNumChannelsPtr(num_channels); /* Send the msg and wait for a response. */ ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: Error %d happened. ", __FUNCTION__, ret); cleanup: delete gScanCommand; return ret; } wifi_error wifi_get_gscan_capabilities(wifi_interface_handle handle, wifi_gscan_capabilities *capabilities) { wifi_handle wifiHandle = getWifiHandle(handle); hal_info *info = getHalInfo(wifiHandle); if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } if (capabilities == NULL) { ALOGE("%s: NULL capabilities pointer provided. Exit.", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } memcpy(capabilities, &info->capa.gscan_capa, sizeof(wifi_gscan_capabilities)); return WIFI_SUCCESS; } wifi_error wifi_start_gscan(wifi_request_id id, wifi_interface_handle iface, wifi_scan_cmd_params params, wifi_scan_result_handler handler) { wifi_error ret; u32 i, j; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); u32 num_scan_buckets, numChannelSpecs; wifi_scan_bucket_spec bucketSpec; struct nlattr *nlBuckectSpecList; hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanStartCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanStartCmdEventHandler = event_handlers->gscanStartCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } ALOGV("%s: RequestId:%d ", __FUNCTION__, id); /* Wi-Fi HAL doesn't need to check if a similar request to start gscan was * made earlier. If start_gscan() is called while another gscan is already * running, the request will be sent down to driver and firmware. If new * request is successfully honored, then Wi-Fi HAL will use the new request * id for the gScanStartCmdEventHandler object. */ gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_START); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; num_scan_buckets = (unsigned int)params.num_buckets > MAX_BUCKETS ? MAX_BUCKETS : params.num_buckets; ALOGV("%s: Base Period:%d Max_ap_per_scan:%d " "Threshold_percent:%d Threshold_num_scans:%d " "num_buckets:%d", __FUNCTION__, params.base_period, params.max_ap_per_scan, params.report_threshold_percent, params.report_threshold_num_scans, num_scan_buckets); if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SCAN_CMD_PARAMS_BASE_PERIOD, params.base_period) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN, params.max_ap_per_scan) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_PERCENT, params.report_threshold_percent) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_NUM_SCANS, params.report_threshold_num_scans) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS, num_scan_buckets)) { goto cleanup; } nlBuckectSpecList = gScanCommand->attr_start(QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC); /* Add NL attributes for scan bucket specs . */ for (i = 0; i < num_scan_buckets; i++) { bucketSpec = params.buckets[i]; numChannelSpecs = (unsigned int)bucketSpec.num_channels > MAX_CHANNELS ? MAX_CHANNELS : bucketSpec.num_channels; ALOGV("%s: Index: %d Bucket Id:%d Band:%d Period:%d ReportEvent:%d " "numChannelSpecs:%d max_period:%d base:%d step_count:%d", __FUNCTION__, i, bucketSpec.bucket, bucketSpec.band, bucketSpec.period, bucketSpec.report_events, numChannelSpecs, bucketSpec.max_period, bucketSpec.base, bucketSpec.step_count); struct nlattr *nlBucketSpec = gScanCommand->attr_start(i); if (gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_INDEX, bucketSpec.bucket) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_BAND, bucketSpec.band) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_PERIOD, bucketSpec.period) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_REPORT_EVENTS, bucketSpec.report_events) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS, numChannelSpecs) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_MAX_PERIOD, bucketSpec.max_period) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_BASE, bucketSpec.base) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BUCKET_SPEC_STEP_COUNT, bucketSpec.step_count)) { goto cleanup; } struct nlattr *nl_channelSpecList = gScanCommand->attr_start(QCA_WLAN_VENDOR_ATTR_GSCAN_CHANNEL_SPEC); /* Add NL attributes for scan channel specs . */ for (j = 0; j < numChannelSpecs; j++) { struct nlattr *nl_channelSpec = gScanCommand->attr_start(j); wifi_scan_channel_spec channel_spec = bucketSpec.channels[j]; ALOGV("%s: Channel Spec Index:%d Channel:%d Dwell Time:%d " "passive:%d", __FUNCTION__, j, channel_spec.channel, channel_spec.dwellTimeMs, channel_spec.passive); if ( gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_CHANNEL_SPEC_CHANNEL, channel_spec.channel) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_CHANNEL_SPEC_DWELL_TIME, channel_spec.dwellTimeMs) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_CHANNEL_SPEC_PASSIVE, channel_spec.passive) ) { goto cleanup; } gScanCommand->attr_end(nl_channelSpec); } gScanCommand->attr_end(nl_channelSpecList); gScanCommand->attr_end(nlBucketSpec); } gScanCommand->attr_end(nlBuckectSpecList); gScanCommand->attr_end(nlData); /* Set the callback handler functions for related events. */ GScanCallbackHandler callbackHandler; memset(&callbackHandler, 0, sizeof(callbackHandler)); callbackHandler.on_full_scan_result = handler.on_full_scan_result; callbackHandler.on_scan_event = handler.on_scan_event; /* Create an object to handle the related events from firmware/driver. */ if (gScanStartCmdEventHandler == NULL) { gScanStartCmdEventHandler = new GScanCommandEventHandler( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_START, callbackHandler); if (gScanStartCmdEventHandler == NULL) { ALOGE("%s: Error gScanStartCmdEventHandler NULL", __FUNCTION__); ret = WIFI_ERROR_UNKNOWN; goto cleanup; } event_handlers->gscanStartCmdEventHandler = gScanStartCmdEventHandler; } else { gScanStartCmdEventHandler->setCallbackHandler(callbackHandler); } ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s : requestResponse Error:%d", __FUNCTION__, ret); goto cleanup; } if (gScanStartCmdEventHandler != NULL) { gScanStartCmdEventHandler->set_request_id(id); gScanStartCmdEventHandler->enableEventHandling(); } cleanup: delete gScanCommand; /* Disable Event Handling if ret != 0 */ if ((ret != WIFI_SUCCESS) && gScanStartCmdEventHandler) { ALOGI("%s: Error ret:%d, disable event handling", __FUNCTION__, ret); gScanStartCmdEventHandler->disableEventHandling(); } return ret; } wifi_error wifi_stop_gscan(wifi_request_id id, wifi_interface_handle iface) { wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanStartCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanStartCmdEventHandler = event_handlers->gscanStartCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } if (gScanStartCmdEventHandler == NULL || gScanStartCmdEventHandler->isEventHandlingEnabled() == false) { ALOGE("%s: GSCAN isn't running or already stopped. " "Nothing to do. Exit", __FUNCTION__); return WIFI_ERROR_NOT_AVAILABLE; } gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_STOP); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; ret = gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id); if (ret != WIFI_SUCCESS) goto cleanup; gScanCommand->attr_end(nlData); ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); /* Disable Event Handling. */ if (gScanStartCmdEventHandler) { gScanStartCmdEventHandler->disableEventHandling(); } cleanup: delete gScanCommand; return ret; } /* Set the GSCAN BSSID Hotlist. */ wifi_error wifi_set_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface, wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler) { int i, numAp; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData, *nlApThresholdParamList; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanSetBssidHotlistCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanSetBssidHotlistCmdEventHandler = event_handlers->gScanSetBssidHotlistCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } /* Wi-Fi HAL doesn't need to check if a similar request to set bssid * hotlist was made earlier. If set_bssid_hotlist() is called while * another one is running, the request will be sent down to driver and * firmware. If the new request is successfully honored, then Wi-Fi HAL * will use the new request id for the gScanSetBssidHotlistCmdEventHandler * object. */ gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_SET_BSSID_HOTLIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; numAp = (unsigned int)params.num_bssid > MAX_HOTLIST_APS ? MAX_HOTLIST_APS : params.num_bssid; if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BSSID_HOTLIST_PARAMS_LOST_AP_SAMPLE_SIZE, params.lost_ap_sample_size) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_BSSID_HOTLIST_PARAMS_NUM_AP, numAp)) { goto cleanup; } ALOGV("%s: lost_ap_sample_size:%d numAp:%d", __FUNCTION__, params.lost_ap_sample_size, numAp); /* Add the vendor specific attributes for the NL command. */ nlApThresholdParamList = gScanCommand->attr_start( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM); if (!nlApThresholdParamList) goto cleanup; /* Add nested NL attributes for AP Threshold Param. */ for (i = 0; i < numAp; i++) { ap_threshold_param apThreshold = params.ap[i]; struct nlattr *nlApThresholdParam = gScanCommand->attr_start(i); if (!nlApThresholdParam) goto cleanup; if (gScanCommand->put_addr( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_BSSID, apThreshold.bssid) || gScanCommand->put_s32( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_RSSI_LOW, apThreshold.low) || gScanCommand->put_s32( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH, apThreshold.high)) { goto cleanup; } ALOGV("%s: Index:%d BssId: %hhx:%hhx:%hhx:%hhx:%hhx:%hhx " "Threshold low:%d high:%d", __FUNCTION__, i, apThreshold.bssid[0], apThreshold.bssid[1], apThreshold.bssid[2], apThreshold.bssid[3], apThreshold.bssid[4], apThreshold.bssid[5], apThreshold.low, apThreshold.high); gScanCommand->attr_end(nlApThresholdParam); } gScanCommand->attr_end(nlApThresholdParamList); gScanCommand->attr_end(nlData); GScanCallbackHandler callbackHandler; memset(&callbackHandler, 0, sizeof(callbackHandler)); callbackHandler.on_hotlist_ap_found = handler.on_hotlist_ap_found; callbackHandler.on_hotlist_ap_lost = handler.on_hotlist_ap_lost; /* Create an object of the event handler class to take care of the * asychronous events on the north-bound. */ if (gScanSetBssidHotlistCmdEventHandler == NULL) { gScanSetBssidHotlistCmdEventHandler = new GScanCommandEventHandler( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_SET_BSSID_HOTLIST, callbackHandler); if (gScanSetBssidHotlistCmdEventHandler == NULL) { ALOGE("%s: Error instantiating " "gScanSetBssidHotlistCmdEventHandler.", __FUNCTION__); ret = WIFI_ERROR_UNKNOWN; goto cleanup; } event_handlers->gScanSetBssidHotlistCmdEventHandler = gScanSetBssidHotlistCmdEventHandler; } else { gScanSetBssidHotlistCmdEventHandler->setCallbackHandler(callbackHandler); } ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); goto cleanup; } if (gScanSetBssidHotlistCmdEventHandler != NULL) { gScanSetBssidHotlistCmdEventHandler->set_request_id(id); gScanSetBssidHotlistCmdEventHandler->enableEventHandling(); } cleanup: delete gScanCommand; /* Disable Event Handling if ret != 0 */ if ((ret != WIFI_SUCCESS) && gScanSetBssidHotlistCmdEventHandler) { ALOGI("%s: Error ret:%d, disable event handling", __FUNCTION__, ret); gScanSetBssidHotlistCmdEventHandler->disableEventHandling(); } return ret; } wifi_error wifi_reset_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface) { wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanSetBssidHotlistCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanSetBssidHotlistCmdEventHandler = event_handlers->gScanSetBssidHotlistCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } if (gScanSetBssidHotlistCmdEventHandler == NULL || (gScanSetBssidHotlistCmdEventHandler->isEventHandlingEnabled() == false)) { ALOGE("wifi_reset_bssid_hotlist: GSCAN bssid_hotlist isn't set. " "Nothing to do. Exit"); return WIFI_ERROR_NOT_AVAILABLE; } gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_RESET_BSSID_HOTLIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; ret = gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id); if (ret != WIFI_SUCCESS) goto cleanup; gScanCommand->attr_end(nlData); ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); /* Disable Event Handling. */ if (gScanSetBssidHotlistCmdEventHandler) { gScanSetBssidHotlistCmdEventHandler->disableEventHandling(); } cleanup: delete gScanCommand; return ret; } /* Set the GSCAN Significant AP Change list. */ wifi_error wifi_set_significant_change_handler(wifi_request_id id, wifi_interface_handle iface, wifi_significant_change_params params, wifi_significant_change_handler handler) { int i, numAp; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData, *nlApThresholdParamList; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanSetSignificantChangeCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanSetSignificantChangeCmdEventHandler = event_handlers->gScanSetSignificantChangeCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } /* Wi-Fi HAL doesn't need to check if a similar request to set significant * change list was made earlier. If set_significant_change() is called while * another one is running, the request will be sent down to driver and * firmware. If the new request is successfully honored, then Wi-Fi HAL * will use the new request id for the gScanSetSignificantChangeCmdEventHandler * object. */ gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_SET_SIGNIFICANT_CHANGE); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; numAp = (unsigned int)params.num_bssid > MAX_SIGNIFICANT_CHANGE_APS ? MAX_SIGNIFICANT_CHANGE_APS : params.num_bssid; if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SIGNIFICANT_CHANGE_PARAMS_RSSI_SAMPLE_SIZE, params.rssi_sample_size) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SIGNIFICANT_CHANGE_PARAMS_LOST_AP_SAMPLE_SIZE, params.lost_ap_sample_size) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SIGNIFICANT_CHANGE_PARAMS_MIN_BREACHING, params.min_breaching) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SIGNIFICANT_CHANGE_PARAMS_NUM_AP, numAp)) { goto cleanup; } ALOGV("%s: Number of AP params:%d Rssi_sample_size:%d " "lost_ap_sample_size:%d min_breaching:%d", __FUNCTION__, numAp, params.rssi_sample_size, params.lost_ap_sample_size, params.min_breaching); /* Add the vendor specific attributes for the NL command. */ nlApThresholdParamList = gScanCommand->attr_start( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM); if (!nlApThresholdParamList) goto cleanup; /* Add nested NL attributes for AP Threshold Param list. */ for (i = 0; i < numAp; i++) { ap_threshold_param apThreshold = params.ap[i]; struct nlattr *nlApThresholdParam = gScanCommand->attr_start(i); if (!nlApThresholdParam) goto cleanup; if ( gScanCommand->put_addr( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_BSSID, apThreshold.bssid) || gScanCommand->put_s32( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_RSSI_LOW, apThreshold.low) || gScanCommand->put_s32( QCA_WLAN_VENDOR_ATTR_GSCAN_AP_THRESHOLD_PARAM_RSSI_HIGH, apThreshold.high)) { goto cleanup; } ALOGV("%s: ap[%d].bssid:%hhx:%hhx:%hhx:%hhx:%hhx:%hhx " "ap[%d].low:%d ap[%d].high:%d", __FUNCTION__, i, apThreshold.bssid[0], apThreshold.bssid[1], apThreshold.bssid[2], apThreshold.bssid[3], apThreshold.bssid[4], apThreshold.bssid[5], i, apThreshold.low, i, apThreshold.high); gScanCommand->attr_end(nlApThresholdParam); } gScanCommand->attr_end(nlApThresholdParamList); gScanCommand->attr_end(nlData); GScanCallbackHandler callbackHandler; memset(&callbackHandler, 0, sizeof(callbackHandler)); callbackHandler.on_significant_change = handler.on_significant_change; /* Create an object of the event handler class to take care of the * asychronous events on the north-bound. */ if (gScanSetSignificantChangeCmdEventHandler == NULL) { gScanSetSignificantChangeCmdEventHandler = new GScanCommandEventHandler( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_SET_SIGNIFICANT_CHANGE, callbackHandler); if (gScanSetSignificantChangeCmdEventHandler == NULL) { ALOGE("%s: Error in instantiating, " "gScanSetSignificantChangeCmdEventHandler.", __FUNCTION__); ret = WIFI_ERROR_UNKNOWN; goto cleanup; } event_handlers->gScanSetSignificantChangeCmdEventHandler = gScanSetSignificantChangeCmdEventHandler; } else { gScanSetSignificantChangeCmdEventHandler->setCallbackHandler(callbackHandler); } ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); goto cleanup; } if (gScanSetSignificantChangeCmdEventHandler != NULL) { gScanSetSignificantChangeCmdEventHandler->set_request_id(id); gScanSetSignificantChangeCmdEventHandler->enableEventHandling(); } cleanup: /* Disable Event Handling if ret != 0 */ if ((ret != WIFI_SUCCESS) && gScanSetSignificantChangeCmdEventHandler) { ALOGI("%s: Error ret:%d, disable event handling", __FUNCTION__, ret); gScanSetSignificantChangeCmdEventHandler->disableEventHandling(); } delete gScanCommand; return ret; } /* Clear the GSCAN Significant AP change list. */ wifi_error wifi_reset_significant_change_handler(wifi_request_id id, wifi_interface_handle iface) { wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanSetSignificantChangeCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanSetSignificantChangeCmdEventHandler = event_handlers->gScanSetSignificantChangeCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } if (gScanSetSignificantChangeCmdEventHandler == NULL || (gScanSetSignificantChangeCmdEventHandler->isEventHandlingEnabled() == false)) { ALOGE("wifi_reset_significant_change_handler: GSCAN significant_change" " isn't set. Nothing to do. Exit"); return WIFI_ERROR_NOT_AVAILABLE; } gScanCommand = new GScanCommand ( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_RESET_SIGNIFICANT_CHANGE); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; ret = gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id); if (ret != WIFI_SUCCESS) goto cleanup; gScanCommand->attr_end(nlData); ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); /* Disable Event Handling. */ if (gScanSetSignificantChangeCmdEventHandler) { gScanSetSignificantChangeCmdEventHandler->disableEventHandling(); } cleanup: delete gScanCommand; return ret; } /* Get the GSCAN cached scan results. */ wifi_error wifi_get_cached_gscan_results(wifi_interface_handle iface, byte flush, int max, wifi_cached_scan_results *results, int *num) { int requestId, retRequestRsp = 0; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); if (!(info->supported_feature_set & WIFI_FEATURE_GSCAN)) { ALOGE("%s: GSCAN is not supported by driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } /* No request id from caller, so generate one and pass it on to the driver. */ /* Generate it randomly */ requestId = get_requestid(); if (results == NULL || num == NULL) { ALOGE("%s: NULL pointer provided. Exit.", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } gScanCommand = new GScanCommand( wifiHandle, requestId, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_GSCAN_GET_CACHED_RESULTS); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } ret = gScanCommand->allocRspParams(eGScanGetCachedResultsRspParams); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to allocate memory for response struct. Error:%d", __FUNCTION__, ret); goto cleanup; } ret = gScanCommand->allocCachedResultsTemp(max, results); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to allocate memory for temp gscan cached list. " "Error:%d", __FUNCTION__, ret); goto cleanup; } /* Clear the destination cached results list before copying results. */ memset(results, 0, max * sizeof(wifi_cached_scan_results)); /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, requestId) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_GSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_FLUSH, flush) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_GET_CACHED_SCAN_RESULTS_CONFIG_PARAM_MAX, max)) { goto cleanup; } ALOGV("%s: flush:%d max:%d", __FUNCTION__, flush, max); gScanCommand->attr_end(nlData); retRequestRsp = gScanCommand->requestResponse(); if (retRequestRsp != 0) { ALOGE("%s: requestResponse Error:%d", __FUNCTION__, retRequestRsp); /* It's possible to get ETIMEDOUT after receiving few results from * driver. Copy and forward them to framework. */ if (retRequestRsp != -ETIMEDOUT) { /* Proceed to cleanup & return no results */ goto cleanup; } } /* No more data, copy the parsed results into the caller's results array */ ret = gScanCommand->copyCachedScanResults(num, results); ALOGV("%s: max: %d, num:%d", __FUNCTION__, max, *num); if (!ret) { /* If requestResponse returned a TIMEOUT */ if (retRequestRsp == -ETIMEDOUT) { if (*num > 0) { /* Mark scan results as incomplete for the last scan_id */ results[(*num)-1].flags = WIFI_SCAN_FLAG_INTERRUPTED; ALOGV("%s: Timeout happened. Mark scan results as incomplete " "for scan_id:%d", __FUNCTION__, results[(*num)-1].scan_id); ret = WIFI_SUCCESS; } else ret = WIFI_ERROR_TIMED_OUT; } } cleanup: gScanCommand->freeRspParams(eGScanGetCachedResultsRspParams); delete gScanCommand; return ret; } /* Random MAC OUI for PNO */ wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui) { wifi_error ret; struct nlattr *nlData; WifiVendorCommand *vCommand = NULL; interface_info *iinfo = getIfaceInfo(handle); wifi_handle wifiHandle = getWifiHandle(handle); vCommand = new WifiVendorCommand(wifiHandle, 0, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_SCANNING_MAC_OUI); if (vCommand == NULL) { ALOGE("%s: Error vCommand NULL", __FUNCTION__); return WIFI_ERROR_OUT_OF_MEMORY; } /* create the message */ ret = vCommand->create(); if (ret != WIFI_SUCCESS) goto cleanup; ret = vCommand->set_iface_id(iinfo->name); if (ret != WIFI_SUCCESS) goto cleanup; /* Add the vendor specific attributes for the NL command. */ nlData = vCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) goto cleanup; ALOGV("%s: MAC_OUI - %02x:%02x:%02x", __FUNCTION__, scan_oui[0], scan_oui[1], scan_oui[2]); /* Add the fixed part of the mac_oui to the nl command */ ret = vCommand->put_bytes( QCA_WLAN_VENDOR_ATTR_SET_SCANNING_MAC_OUI, (char *)scan_oui, WIFI_SCANNING_MAC_OUI_LENGTH); if (ret != WIFI_SUCCESS) goto cleanup; vCommand->attr_end(nlData); ret = vCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); goto cleanup; } cleanup: delete vCommand; return ret; } GScanCommand::GScanCommand(wifi_handle handle, int id, u32 vendor_id, u32 subcmd) : WifiVendorCommand(handle, id, vendor_id, subcmd) { /* Initialize the member data variables here */ mGetCachedResultsRspParams = NULL; mChannels = NULL; mMaxChannels = 0; mNumChannelsPtr = NULL; mRequestId = id; memset(&mHandler, 0,sizeof(mHandler)); } GScanCommand::~GScanCommand() { unregisterVendorHandler(mVendor_id, mSubcmd); } /* This function implements creation of Vendor command */ wifi_error GScanCommand::create() { wifi_error ret; ret = mMsg.create(NL80211_CMD_VENDOR, 0, 0); if (ret != WIFI_SUCCESS) return ret; /* Insert the oui in the msg */ ret = mMsg.put_u32(NL80211_ATTR_VENDOR_ID, mVendor_id); if (ret != WIFI_SUCCESS) return ret; /* Insert the subcmd in the msg */ ret = mMsg.put_u32(NL80211_ATTR_VENDOR_SUBCMD, mSubcmd); if (ret != WIFI_SUCCESS) return ret; ALOGV("%s: mVendor_id = %d, Subcmd = %d.", __FUNCTION__, mVendor_id, mSubcmd); return ret; } wifi_error GScanCommand::requestResponse() { return WifiCommand::requestResponse(mMsg); } int GScanCommand::handleResponse(WifiEvent &reply) { int i = 0; wifi_error ret = WIFI_SUCCESS; u32 val; WifiVendorCommand::handleResponse(reply); struct nlattr *tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX + 1]; nla_parse(tbVendor, QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX, (struct nlattr *)mVendorData,mDataLen, NULL); switch(mSubcmd) { case QCA_NL80211_VENDOR_SUBCMD_GSCAN_GET_VALID_CHANNELS: { if (!tbVendor[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_CHANNELS]) { ALOGE("%s: QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_CHANNELS" " not found", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } val = nla_get_u32(tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_CHANNELS]); val = val > (unsigned int)mMaxChannels ? (unsigned int)mMaxChannels : val; *mNumChannelsPtr = val; /* Extract the list of channels. */ if (*mNumChannelsPtr > 0 ) { if (!tbVendor[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_CHANNELS]) { ALOGE("%s: QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_CHANNELS" " not found", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } nla_memcpy(mChannels, tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_CHANNELS], sizeof(wifi_channel) * (*mNumChannelsPtr)); } char buf[256]; size_t len = 0; for (i = 0; i < *mNumChannelsPtr && len < sizeof(buf); i++) { len += snprintf(buf + len, sizeof(buf) - len, "%u ", *(mChannels + i)); } ALOGV("%s: Num Channels %d: List of valid channels are: %s", __FUNCTION__, *mNumChannelsPtr, buf); } break; case QCA_NL80211_VENDOR_SUBCMD_GSCAN_GET_CACHED_RESULTS: { wifi_request_id id; u32 numResults = 0; int firstScanIdInPatch = -1; if (!tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_REQUEST_ID]) { ALOGE("%s: GSCAN_RESULTS_REQUEST_ID not" "found", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } id = nla_get_u32( tbVendor[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_REQUEST_ID] ); /* If this is not for us, just ignore it. */ if (id != mRequestId) { ALOGV("%s: Event has Req. ID:%d <> ours:%d", __FUNCTION__, id, mRequestId); break; } if (!tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_RESULTS_AVAILABLE]) { ALOGE("%s: GSCAN_RESULTS_NUM_RESULTS_AVAILABLE not" "found", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } /* Read num of cached scan results in this data chunk. Note that * this value doesn't represent the number of unique gscan scan Ids * since the first scan id in this new chunk could be similar to * the last scan id in the previous chunk. */ numResults = nla_get_u32(tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_RESULTS_AVAILABLE]); ALOGV("%s: num Cached results in this fragment:%d", __FUNCTION__, numResults); if (!mGetCachedResultsRspParams) { ALOGE("%s: mGetCachedResultsRspParams is NULL, exit.", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } /* To support fragmentation from firmware, monitor the * MORE_DATA flag and cache results until MORE_DATA = 0. */ if (!tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_MORE_DATA]) { ALOGE("%s: GSCAN_RESULTS_NUM_RESULTS_MORE_DATA " "not found", __FUNCTION__); ret = WIFI_ERROR_INVALID_ARGS; break; } else { mGetCachedResultsRspParams->more_data = nla_get_u8( tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_MORE_DATA]); } /* No data in this chunk so skip this chunk */ if (numResults == 0) { return NL_SKIP; } if (!tbVendor[QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_SCAN_ID]) { ALOGE("GSCAN_CACHED_RESULTS_SCAN_ID not found"); ret = WIFI_ERROR_INVALID_ARGS; break; } /* Get the first Scan-Id in this chuck of cached results. */ firstScanIdInPatch = nla_get_u32(tbVendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_SCAN_ID]); ALOGV("More data: %d, firstScanIdInPatch: %d, lastProcessedScanId: %d", mGetCachedResultsRspParams->more_data, firstScanIdInPatch, mGetCachedResultsRspParams->lastProcessedScanId); if (numResults) { if (firstScanIdInPatch != mGetCachedResultsRspParams->lastProcessedScanId) { /* New result scan Id block, update the starting index. */ mGetCachedResultsRspParams->cachedResultsStartingIndex++; } ret = gscan_get_cached_results( mGetCachedResultsRspParams->cached_results, tbVendor); /* If a parsing error occurred, exit and proceed for cleanup. */ if (ret) break; } } break; default: /* Error case should not happen print log */ ALOGE("%s: Wrong GScan subcmd response received %d", __FUNCTION__, mSubcmd); } /* A parsing error occurred, do the cleanup of gscan result lists. */ if (ret) { switch(mSubcmd) { case QCA_NL80211_VENDOR_SUBCMD_GSCAN_GET_CACHED_RESULTS: { ALOGE("%s: Parsing error, free CachedResultsRspParams", __FUNCTION__); freeRspParams(eGScanGetCachedResultsRspParams); } break; default: ALOGE("%s: Wrong GScan subcmd received %d", __FUNCTION__, mSubcmd); } } return NL_SKIP; } /* Called to parse and extract cached results. */ wifi_error GScanCommand:: gscan_get_cached_results( wifi_cached_scan_results *cached_results, struct nlattr **tb_vendor) { u32 j = 0; struct nlattr *scanResultsInfo, *wifiScanResultsInfo; int rem = 0, remResults = 0; u32 len = 0, numScanResults = 0; u32 i = mGetCachedResultsRspParams->cachedResultsStartingIndex; ALOGV("%s: starting counter: %d", __FUNCTION__, i); for (scanResultsInfo = (struct nlattr *) nla_data(tb_vendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_LIST]), rem = nla_len(tb_vendor[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_LIST]); nla_ok(scanResultsInfo, rem) && i < mGetCachedResultsRspParams->max; scanResultsInfo = nla_next(scanResultsInfo, &(rem))) { struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX + 1]; nla_parse(tb2, QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX, (struct nlattr *) nla_data(scanResultsInfo), nla_len(scanResultsInfo), NULL); if (! tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_SCAN_ID ]) { ALOGE("%s: GSCAN_CACHED_RESULTS_SCAN_ID" " not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].scan_id = nla_get_u32( tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_SCAN_ID ]); if (! tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_FLAGS ]) { ALOGE("%s: GSCAN_CACHED_RESULTS_FLAGS " "not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].flags = nla_get_u32( tb2[QCA_WLAN_VENDOR_ATTR_GSCAN_CACHED_RESULTS_FLAGS]); if (!tb2[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_BUCKETS_SCANNED]) { ALOGI("%s: GSCAN_RESULTS_BUCKETS_SCANNED" "not found", __FUNCTION__); } else { cached_results[i].buckets_scanned = nla_get_u32( tb2[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_BUCKETS_SCANNED]); } if (! tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_RESULTS_AVAILABLE ]) { ALOGE("%s: RESULTS_NUM_RESULTS_AVAILABLE " "not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } numScanResults = nla_get_u32( tb2[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_NUM_RESULTS_AVAILABLE]); if (mGetCachedResultsRspParams->lastProcessedScanId != cached_results[i].scan_id) { j = 0; /* reset wifi_scan_result counter */ cached_results[i].num_results = 0; ALOGV("parsing: *lastProcessedScanId [%d] !=" " cached_results[%d].scan_id:%d, j:%d " "numScanResults: %d", mGetCachedResultsRspParams->lastProcessedScanId, i, cached_results[i].scan_id, j, numScanResults); mGetCachedResultsRspParams->lastProcessedScanId = cached_results[i].scan_id; mGetCachedResultsRspParams->wifiScanResultsStartingIndex = 0; /* Increment the number of cached scan results received */ mGetCachedResultsRspParams->num_cached_results++; } else { j = mGetCachedResultsRspParams->wifiScanResultsStartingIndex; ALOGV("parsing: *lastProcessedScanId [%d] == " "cached_results[%d].scan_id:%d, j:%d " "numScanResults:%d", mGetCachedResultsRspParams->lastProcessedScanId, i, cached_results[i].scan_id, j, numScanResults); } ALOGV("%s: scan_id %d ", __FUNCTION__, cached_results[i].scan_id); ALOGV("%s: flags %u ", __FUNCTION__, cached_results[i].flags); for (wifiScanResultsInfo = (struct nlattr *) nla_data(tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_LIST]), remResults = nla_len(tb2[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_LIST]); nla_ok(wifiScanResultsInfo, remResults); wifiScanResultsInfo = nla_next(wifiScanResultsInfo, &(remResults))) { struct nlattr *tb3[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX + 1]; nla_parse(tb3, QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_MAX, (struct nlattr *) nla_data(wifiScanResultsInfo), nla_len(wifiScanResultsInfo), NULL); if (j < MAX_AP_CACHE_PER_SCAN) { if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_TIME_STAMP ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_TIME_STAMP not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].results[j].ts = nla_get_u64( tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_TIME_STAMP ]); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_SSID ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_SSID not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } len = nla_len(tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_SSID]); len = sizeof(cached_results[i].results[j].ssid) <= len ? sizeof(cached_results[i].results[j].ssid) : len; memcpy((void *)&cached_results[i].results[j].ssid, nla_data( tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_SSID]), len); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_BSSID ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_BSSID not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } len = nla_len( tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_BSSID]); len = sizeof(cached_results[i].results[j].bssid) <= len ? sizeof(cached_results[i].results[j].bssid) : len; memcpy(&cached_results[i].results[j].bssid, nla_data( tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_BSSID]), len); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_CHANNEL ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_CHANNEL not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].results[j].channel = nla_get_u32( tb3[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_CHANNEL]); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RSSI ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_RSSI not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].results[j].rssi = get_s32( tb3[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RSSI]); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RTT ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_RTT not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].results[j].rtt = nla_get_u32( tb3[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RTT]); if (! tb3[ QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RTT_SD ]) { ALOGE("%s: " "RESULTS_SCAN_RESULT_RTT_SD not found", __FUNCTION__); return WIFI_ERROR_INVALID_ARGS; } cached_results[i].results[j].rtt_sd = nla_get_u32( tb3[QCA_WLAN_VENDOR_ATTR_GSCAN_RESULTS_SCAN_RESULT_RTT_SD]); #ifdef QC_HAL_DEBUG /* Enable these prints for debugging if needed. */ ALOGD("%s: ts %" PRId64, __FUNCTION__, cached_results[i].results[j].ts); ALOGD("%s: SSID %s ", __FUNCTION__, cached_results[i].results[j].ssid); ALOGD("%s: BSSID: %02x:%02x:%02x:%02x:%02x:%02x \n", __FUNCTION__, cached_results[i].results[j].bssid[0], cached_results[i].results[j].bssid[1], cached_results[i].results[j].bssid[2], cached_results[i].results[j].bssid[3], cached_results[i].results[j].bssid[4], cached_results[i].results[j].bssid[5]); ALOGD("%s: channel %d ", __FUNCTION__, cached_results[i].results[j].channel); ALOGD("%s: rssi %d ", __FUNCTION__, cached_results[i].results[j].rssi); ALOGD("%s: rtt %" PRId64, __FUNCTION__, cached_results[i].results[j].rtt); ALOGD("%s: rtt_sd %" PRId64, __FUNCTION__, cached_results[i].results[j].rtt_sd); #endif /* Increment loop index for next record */ j++; /* For this scan id, update the wifiScanResultsStartingIndex * and number of cached results parsed so far. */ mGetCachedResultsRspParams->wifiScanResultsStartingIndex = j; cached_results[i].num_results++; } else { /* We already parsed and stored up to max wifi_scan_results * specified by the caller. Now, continue to loop over NL * entries in order to properly update NL parsing pointer * so it points to the next scan_id results. */ ALOGD("%s: loop index:%d > max num" " of wifi_scan_results:%d for gscan cached results" " bucket:%d. Dummy loop", __FUNCTION__, j, MAX_AP_CACHE_PER_SCAN, i); } } ALOGV("%s: cached_results[%d].num_results: %d ", __FUNCTION__, i, cached_results[i].num_results); /* Increment loop index for next cached scan result record */ i++; } /* Increment starting index of filling cached results received */ if (mGetCachedResultsRspParams->num_cached_results) mGetCachedResultsRspParams->cachedResultsStartingIndex = mGetCachedResultsRspParams->num_cached_results - 1; return WIFI_SUCCESS; } /* Set the GSCAN BSSID Hotlist. */ wifi_error wifi_set_epno_list(wifi_request_id id, wifi_interface_handle iface, const wifi_epno_params *epno_params, wifi_epno_handler handler) { int i, num_networks; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData, *nlPnoParamList; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanSetPnoListCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanSetPnoListCmdEventHandler = event_handlers->gScanSetPnoListCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_HAL_EPNO)) { ALOGE("%s: Enhanced PNO is not supported by the driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } /* Wi-Fi HAL doesn't need to check if a similar request to set ePNO * list was made earlier. If wifi_set_epno_list() is called while * another one is running, the request will be sent down to driver and * firmware. If the new request is successfully honored, then Wi-Fi HAL * will use the new request id for the gScanSetPnoListCmdEventHandler * object. */ gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_SET_LIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to create the NL msg. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to set iface id. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) { ALOGE("%s: Failed to add attribute NL80211_ATTR_VENDOR_DATA. Error:%d", __FUNCTION__, ret); goto cleanup; } num_networks = (unsigned int)epno_params->num_networks > MAX_EPNO_NETWORKS ? MAX_EPNO_NETWORKS : epno_params->num_networks; if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_MIN5GHZ_RSSI, epno_params->min5GHz_rssi) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_MIN24GHZ_RSSI, epno_params->min24GHz_rssi) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_INITIAL_SCORE_MAX, epno_params->initial_score_max) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_CURRENT_CONNECTION_BONUS, epno_params->current_connection_bonus) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_SAME_NETWORK_BONUS, epno_params->same_network_bonus) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_SECURE_BONUS, epno_params->secure_bonus) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_EPNO_BAND5GHZ_BONUS, epno_params->band5GHz_bonus) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_NUM_NETWORKS, num_networks)) { ALOGE("%s: Failed to add vendor atributes. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlPnoParamList = gScanCommand->attr_start( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_EPNO_NETWORKS_LIST); if (!nlPnoParamList) { ALOGE("%s: Failed to add attr. PNO_SET_LIST_PARAM_EPNO_NETWORKS_LIST. " "Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add nested NL attributes for ePno List. */ for (i = 0; i < num_networks; i++) { wifi_epno_network pnoNetwork = epno_params->networks[i]; struct nlattr *nlPnoNetwork = gScanCommand->attr_start(i); if (!nlPnoNetwork) { ALOGE("%s: Failed attr_start for nlPnoNetwork. Error:%d", __FUNCTION__, ret); goto cleanup; } if (gScanCommand->put_string( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_EPNO_NETWORK_SSID, pnoNetwork.ssid) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_EPNO_NETWORK_FLAGS, pnoNetwork.flags) || gScanCommand->put_u8( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_EPNO_NETWORK_AUTH_BIT, pnoNetwork.auth_bit_field)) { ALOGE("%s: Failed to add PNO_SET_LIST_PARAM_EPNO_NETWORK_*. " "Error:%d", __FUNCTION__, ret); goto cleanup; } gScanCommand->attr_end(nlPnoNetwork); } gScanCommand->attr_end(nlPnoParamList); gScanCommand->attr_end(nlData); GScanCallbackHandler callbackHandler; memset(&callbackHandler, 0, sizeof(callbackHandler)); callbackHandler.on_pno_network_found = handler.on_network_found; /* Create an object of the event handler class to take care of the * asychronous events on the north-bound. */ if (gScanSetPnoListCmdEventHandler == NULL) { gScanSetPnoListCmdEventHandler = new GScanCommandEventHandler( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_SET_LIST, callbackHandler); if (gScanSetPnoListCmdEventHandler == NULL) { ALOGE("%s: Error instantiating " "gScanSetPnoListCmdEventHandler.", __FUNCTION__); ret = WIFI_ERROR_UNKNOWN; goto cleanup; } event_handlers->gScanSetPnoListCmdEventHandler = gScanSetPnoListCmdEventHandler; } else { gScanSetPnoListCmdEventHandler->setCallbackHandler(callbackHandler); } ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); goto cleanup; } if (gScanSetPnoListCmdEventHandler != NULL) { gScanSetPnoListCmdEventHandler->set_request_id(id); gScanSetPnoListCmdEventHandler->enableEventHandling(); } cleanup: delete gScanCommand; /* Disable Event Handling if ret != 0 */ if ((ret != WIFI_SUCCESS) && gScanSetPnoListCmdEventHandler) { ALOGI("%s: Error ret:%d, disable event handling", __FUNCTION__, ret); gScanSetPnoListCmdEventHandler->disableEventHandling(); } return ret; } /* Reset the ePNO list - no ePNO networks should be matched after this */ wifi_error wifi_reset_epno_list(wifi_request_id id, wifi_interface_handle iface) { wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); if (!(info->supported_feature_set & WIFI_FEATURE_HAL_EPNO)) { ALOGE("%s: Enhanced PNO is not supported by the driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } gScanCommand = new GScanCommand(wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_SET_LIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to create the NL msg. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to set iface id. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) { ALOGE("%s: Failed to add attribute NL80211_ATTR_VENDOR_DATA. Error:%d", __FUNCTION__, ret); goto cleanup; } if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_PNO_SET_LIST_PARAM_NUM_NETWORKS, EPNO_NO_NETWORKS)) { ALOGE("%s: Failed to add vendor atributes Error:%d", __FUNCTION__, ret); goto cleanup; } gScanCommand->attr_end(nlData); ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); cleanup: delete gScanCommand; return ret; } /* Set the ePNO Passpoint List. */ wifi_error wifi_set_passpoint_list(wifi_request_id id, wifi_interface_handle iface, int num, wifi_passpoint_network *networks, wifi_passpoint_event_handler handler) { int i; wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData, *nlPasspointNetworksParamList; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanPnoSetPasspointListCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanPnoSetPasspointListCmdEventHandler = event_handlers->gScanPnoSetPasspointListCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_HAL_EPNO)) { ALOGE("%s: Enhanced PNO is not supported by the driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } /* Wi-Fi HAL doesn't need to check if a similar request to set ePNO * passpoint list was made earlier. If wifi_set_passpoint_list() is called * while another one is running, the request will be sent down to driver and * firmware. If the new request is successfully honored, then Wi-Fi HAL * will use the new request id for the * gScanPnoSetPasspointListCmdEventHandler object. */ gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_SET_PASSPOINT_LIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to create the NL msg. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to set iface id. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) { ALOGE("%s: Failed to add attribute NL80211_ATTR_VENDOR_DATA. Error:%d", __FUNCTION__, ret); goto cleanup; } if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id) || gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_LIST_PARAM_NUM, num)) { ALOGE("%s: Failed to add vendor atributes. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlPasspointNetworksParamList = gScanCommand->attr_start( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_LIST_PARAM_NETWORK_ARRAY); if (!nlPasspointNetworksParamList) { ALOGE("%s: Failed attr_start for PASSPOINT_LIST_PARAM_NETWORK_ARRAY. " "Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add nested NL attributes for Passpoint List param. */ for (i = 0; i < num; i++) { wifi_passpoint_network passpointNetwork = networks[i]; struct nlattr *nlPasspointNetworkParam = gScanCommand->attr_start(i); if (!nlPasspointNetworkParam) { ALOGE("%s: Failed attr_start for nlPasspointNetworkParam. " "Error:%d", __FUNCTION__, ret); goto cleanup; } if (gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_NETWORK_PARAM_ID, passpointNetwork.id) || gScanCommand->put_string( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_NETWORK_PARAM_REALM, passpointNetwork.realm) || gScanCommand->put_bytes( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_NETWORK_PARAM_ROAM_CNSRTM_ID, (char*)passpointNetwork.roamingConsortiumIds, 16 * sizeof(int64_t)) || gScanCommand->put_bytes( QCA_WLAN_VENDOR_ATTR_PNO_PASSPOINT_NETWORK_PARAM_ROAM_PLMN, (char*)passpointNetwork.plmn, 3 * sizeof(u8))) { ALOGE("%s: Failed to add PNO_PASSPOINT_NETWORK_PARAM_ROAM_* attr. " "Error:%d", __FUNCTION__, ret); goto cleanup; } gScanCommand->attr_end(nlPasspointNetworkParam); } gScanCommand->attr_end(nlPasspointNetworksParamList); gScanCommand->attr_end(nlData); GScanCallbackHandler callbackHandler; memset(&callbackHandler, 0, sizeof(callbackHandler)); callbackHandler.on_passpoint_network_found = handler.on_passpoint_network_found; /* Create an object of the event handler class to take care of the * asychronous events on the north-bound. */ if (gScanPnoSetPasspointListCmdEventHandler == NULL) { gScanPnoSetPasspointListCmdEventHandler = new GScanCommandEventHandler( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_SET_PASSPOINT_LIST, callbackHandler); if (gScanPnoSetPasspointListCmdEventHandler == NULL) { ALOGE("%s: Error instantiating " "gScanPnoSetPasspointListCmdEventHandler.", __FUNCTION__); ret = WIFI_ERROR_UNKNOWN; goto cleanup; } event_handlers->gScanPnoSetPasspointListCmdEventHandler = gScanPnoSetPasspointListCmdEventHandler; } else { gScanPnoSetPasspointListCmdEventHandler->setCallbackHandler(callbackHandler); } ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) { ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); goto cleanup; } if (gScanPnoSetPasspointListCmdEventHandler != NULL) { gScanPnoSetPasspointListCmdEventHandler->set_request_id(id); gScanPnoSetPasspointListCmdEventHandler->enableEventHandling(); } cleanup: delete gScanCommand; /* Disable Event Handling if ret != 0 */ if ((ret != WIFI_SUCCESS) && gScanPnoSetPasspointListCmdEventHandler) { ALOGI("%s: Error ret:%d, disable event handling", __FUNCTION__, ret); gScanPnoSetPasspointListCmdEventHandler->disableEventHandling(); } return ret; } wifi_error wifi_reset_passpoint_list(wifi_request_id id, wifi_interface_handle iface) { wifi_error ret; GScanCommand *gScanCommand; struct nlattr *nlData; interface_info *ifaceInfo = getIfaceInfo(iface); wifi_handle wifiHandle = getWifiHandle(iface); hal_info *info = getHalInfo(wifiHandle); gscan_event_handlers* event_handlers; GScanCommandEventHandler *gScanPnoSetPasspointListCmdEventHandler; event_handlers = (gscan_event_handlers*)info->gscan_handlers; gScanPnoSetPasspointListCmdEventHandler = event_handlers->gScanPnoSetPasspointListCmdEventHandler; if (!(info->supported_feature_set & WIFI_FEATURE_HAL_EPNO)) { ALOGE("%s: Enhanced PNO is not supported by the driver", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } if (gScanPnoSetPasspointListCmdEventHandler == NULL || (gScanPnoSetPasspointListCmdEventHandler->isEventHandlingEnabled() == false)) { ALOGE("wifi_reset_passpoint_list: ePNO passpoint_list isn't set. " "Nothing to do. Exit."); return WIFI_ERROR_NOT_AVAILABLE; } gScanCommand = new GScanCommand( wifiHandle, id, OUI_QCA, QCA_NL80211_VENDOR_SUBCMD_PNO_RESET_PASSPOINT_LIST); if (gScanCommand == NULL) { ALOGE("%s: Error GScanCommand NULL", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } /* Create the NL message. */ ret = gScanCommand->create(); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to create the NL msg. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Set the interface Id of the message. */ ret = gScanCommand->set_iface_id(ifaceInfo->name); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to set iface id. Error:%d", __FUNCTION__, ret); goto cleanup; } /* Add the vendor specific attributes for the NL command. */ nlData = gScanCommand->attr_start(NL80211_ATTR_VENDOR_DATA); if (!nlData) { ALOGE("%s: Failed to add attribute NL80211_ATTR_VENDOR_DATA. Error:%d", __FUNCTION__, ret); goto cleanup; } ret = gScanCommand->put_u32( QCA_WLAN_VENDOR_ATTR_GSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID, id); if (ret != WIFI_SUCCESS) { ALOGE("%s: Failed to add vendor data attributes. Error:%d", __FUNCTION__, ret); goto cleanup; } gScanCommand->attr_end(nlData); ret = gScanCommand->requestResponse(); if (ret != WIFI_SUCCESS) ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); /* Disable Event Handling. */ if (gScanPnoSetPasspointListCmdEventHandler) { gScanPnoSetPasspointListCmdEventHandler->disableEventHandling(); } cleanup: delete gScanCommand; return ret; } wifi_error GScanCommand::allocCachedResultsTemp(int max, wifi_cached_scan_results *cached_results) { /* Alloc memory for "max" number of cached results. */ mGetCachedResultsRspParams->cached_results = (wifi_cached_scan_results*) malloc(max * sizeof(wifi_cached_scan_results)); if (!mGetCachedResultsRspParams->cached_results) { ALOGE("%s: Failed to allocate memory for " "mGetCachedResultsRspParams->cached_results.", __FUNCTION__); return WIFI_ERROR_OUT_OF_MEMORY; } memset(mGetCachedResultsRspParams->cached_results, 0, max * sizeof(wifi_cached_scan_results)); mGetCachedResultsRspParams->max = max; return WIFI_SUCCESS; } /* * Allocates memory for the subCmd response struct and initializes status = -1 */ wifi_error GScanCommand::allocRspParams(eGScanRspRarams cmd) { switch(cmd) { case eGScanGetCachedResultsRspParams: mGetCachedResultsRspParams = (GScanGetCachedResultsRspParams *) malloc(sizeof(GScanGetCachedResultsRspParams)); if (!mGetCachedResultsRspParams) return WIFI_ERROR_OUT_OF_MEMORY; mGetCachedResultsRspParams->num_cached_results = 0; mGetCachedResultsRspParams->more_data = false; mGetCachedResultsRspParams->cachedResultsStartingIndex = -1; mGetCachedResultsRspParams->lastProcessedScanId = -1; mGetCachedResultsRspParams->wifiScanResultsStartingIndex = -1; mGetCachedResultsRspParams->max = 0; mGetCachedResultsRspParams->cached_results = NULL; break; default: ALOGD("%s: Wrong request for alloc.", __FUNCTION__); return WIFI_ERROR_NOT_SUPPORTED; } return WIFI_SUCCESS; } void GScanCommand::freeRspParams(eGScanRspRarams cmd) { switch(cmd) { case eGScanGetCachedResultsRspParams: if (mGetCachedResultsRspParams) { if (mGetCachedResultsRspParams->cached_results) { free(mGetCachedResultsRspParams->cached_results); mGetCachedResultsRspParams->cached_results = NULL; } free(mGetCachedResultsRspParams); mGetCachedResultsRspParams = NULL; } break; default: ALOGD("%s: Wrong request for free.", __FUNCTION__); } } wifi_error GScanCommand::copyCachedScanResults( int *numResults, wifi_cached_scan_results *cached_results) { wifi_error ret = WIFI_SUCCESS; int i; wifi_cached_scan_results *cachedResultRsp; if (mGetCachedResultsRspParams && cached_results) { /* Populate the number of parsed cached results. */ *numResults = mGetCachedResultsRspParams->num_cached_results; for (i = 0; i < *numResults; i++) { cachedResultRsp = &mGetCachedResultsRspParams->cached_results[i]; cached_results[i].scan_id = cachedResultRsp->scan_id; cached_results[i].flags = cachedResultRsp->flags; cached_results[i].num_results = cachedResultRsp->num_results; cached_results[i].buckets_scanned = cachedResultRsp->buckets_scanned; if (!cached_results[i].num_results) { ALOGI("Error: cached_results[%d].num_results=0", i); continue; } ALOGV("copyCachedScanResults: " "cached_results[%d].num_results : %d", i, cached_results[i].num_results); memcpy(cached_results[i].results, cachedResultRsp->results, cached_results[i].num_results * sizeof(wifi_scan_result)); } } else { ALOGE("%s: mGetCachedResultsRspParams is NULL", __FUNCTION__); *numResults = 0; ret = WIFI_ERROR_INVALID_ARGS; } return ret; } void GScanCommand::setMaxChannels(int max_channels) { mMaxChannels = max_channels; } void GScanCommand::setChannels(int *channels) { mChannels = channels; } void GScanCommand::setNumChannelsPtr(int *num_channels) { mNumChannelsPtr = num_channels; }