| /* Copyright (c) 2015, 2018 The Linux Foundation. All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions | |
| * are met: | |
| * * Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * * Redistributions in binary form must reproduce the above | |
| * copyright notice, this list of conditions and the following | |
| * disclaimer in the documentation and/or other materials provided | |
| * with the distribution. | |
| * * Neither the name of The Linux Foundation nor the names of its | |
| * contributors may be used to endorse or promote products derived | |
| * from this software without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED | |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT | |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS | |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR | |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE | |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN | |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| #include "sync.h" | |
| #define LOG_TAG "WifiHAL" | |
| #include <utils/Log.h> | |
| #include <time.h> | |
| #include <errno.h> | |
| #include <stdlib.h> | |
| #include <unistd.h> | |
| #include <string> | |
| #include <net/if.h> | |
| #include <vector> | |
| #include "wificonfigcommand.h" | |
| /* Implementation of the API functions exposed in wifi_config.h */ | |
| wifi_error wifi_extended_dtim_config_set(wifi_request_id id, | |
| wifi_interface_handle iface, | |
| int extended_dtim) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| interface_info *ifaceInfo = getIfaceInfo(iface); | |
| wifi_handle wifiHandle = getWifiHandle(iface); | |
| ALOGV("%s: extended_dtim:%d", __FUNCTION__, extended_dtim); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| id, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_extended_dtim_config_set: failed to create NL msg. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_extended_dtim_config_set: failed to set iface id. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("wifi_extended_dtim_config_set: failed attr_start for " | |
| "VENDOR_DATA. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| ret = wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_CONFIG_DYNAMIC_DTIM, extended_dtim); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_extended_dtim_config_set(): failed to put vendor data. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_extended_dtim_config_set(): requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| int check_feature(enum qca_wlan_vendor_features feature, features_info *info) | |
| { | |
| size_t idx = feature / 8; | |
| return (idx < info->flags_len) && | |
| (info->flags[idx] & BIT(feature % 8)); | |
| } | |
| /* Set the country code to driver. */ | |
| wifi_error wifi_set_country_code(wifi_interface_handle iface, | |
| const char* country_code) | |
| { | |
| int requestId; | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| wifi_handle wifiHandle = getWifiHandle(iface); | |
| hal_info *info = getHalInfo(wifiHandle); | |
| ALOGV("%s: %s", __FUNCTION__, country_code); | |
| /* No request id from caller, so generate one and pass it on to the driver. | |
| * Generate it randomly. | |
| */ | |
| requestId = get_requestid(); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| requestId, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message with NL80211_CMD_REQ_SET_REG NL cmd. */ | |
| ret = wifiConfigCommand->create_generic(NL80211_CMD_REQ_SET_REG); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_country_code: failed to create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| ret = wifiConfigCommand->put_string(NL80211_ATTR_REG_ALPHA2, country_code); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_country_code: put country code failed. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| if (check_feature(QCA_WLAN_VENDOR_FEATURE_SELF_MANAGED_REGULATORY, | |
| &info->driver_supported_features)) { | |
| ret = wifiConfigCommand->put_u32(NL80211_ATTR_USER_REG_HINT_TYPE, | |
| NL80211_USER_REG_HINT_CELL_BASE); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_country_code: put reg hint type failed. Error:%d", | |
| ret); | |
| goto cleanup; | |
| } | |
| } | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_country_code(): requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| usleep(WAIT_TIME_FOR_SET_REG_DOMAIN); | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_set_beacon_wifi_iface_stats_averaging_factor( | |
| wifi_request_id id, | |
| wifi_interface_handle iface, | |
| u16 factor) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| interface_info *ifaceInfo = getIfaceInfo(iface); | |
| wifi_handle wifiHandle = getWifiHandle(iface); | |
| ALOGV("%s factor:%u", __FUNCTION__, factor); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| id, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_beacon_wifi_iface_stats_averaging_factor: failed to " | |
| "create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_beacon_wifi_iface_stats_averaging_factor: failed to " | |
| "set iface id. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("wifi_set_beacon_wifi_iface_stats_averaging_factor: failed " | |
| "attr_start for VENDOR_DATA. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_CONFIG_STATS_AVG_FACTOR, factor)) { | |
| ALOGE("wifi_set_beacon_wifi_iface_stats_averaging_factor(): failed to " | |
| "put vendor data. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_beacon_wifi_iface_stats_averaging_factor(): " | |
| "requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_set_guard_time(wifi_request_id id, | |
| wifi_interface_handle iface, | |
| u32 guard_time) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| interface_info *ifaceInfo = getIfaceInfo(iface); | |
| wifi_handle wifiHandle = getWifiHandle(iface); | |
| ALOGV("%s : guard_time:%u", __FUNCTION__, guard_time); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| id, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_guard_time: failed to create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_guard_time: failed to set iface id. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("wifi_set_guard_time: failed attr_start for VENDOR_DATA. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_CONFIG_GUARD_TIME, guard_time)) { | |
| ALOGE("wifi_set_guard_time: failed to add vendor data."); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_guard_time(): requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_select_tx_power_scenario(wifi_interface_handle handle, | |
| wifi_power_scenario scenario) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| interface_info *ifaceInfo = getIfaceInfo(handle); | |
| wifi_handle wifiHandle = getWifiHandle(handle); | |
| u32 bdf_file = 0; | |
| ALOGV("%s : power scenario:%d", __FUNCTION__, scenario); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| 1, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_SAR_LIMITS); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_select_tx_power_scenario: failed to create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_select_tx_power_scenario: failed to set iface id. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("wifi_select_tx_power_scenario: failed attr_start for VENDOR_DATA. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| switch (scenario) { | |
| case WIFI_POWER_SCENARIO_VOICE_CALL: | |
| case WIFI_POWER_SCENARIO_ON_BODY_BT: | |
| bdf_file = QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SELECT_BDF0; | |
| break; | |
| case WIFI_POWER_SCENARIO_ON_HEAD_CELL_OFF: | |
| case WIFI_POWER_SCENARIO_ON_HEAD_CELL_ON: | |
| case WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT: | |
| case WIFI_POWER_SCENARIO_ON_HEAD_HOTSPOT_MMW: | |
| bdf_file = QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SELECT_BDF1; | |
| break; | |
| case WIFI_POWER_SCENARIO_ON_BODY_CELL_OFF: | |
| bdf_file = QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SELECT_BDF2; | |
| break; | |
| case WIFI_POWER_SCENARIO_ON_BODY_CELL_ON: | |
| case WIFI_POWER_SCENARIO_ON_BODY_CELL_ON_BT: | |
| case WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT: | |
| case WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT: | |
| case WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_MMW: | |
| case WIFI_POWER_SCENARIO_ON_BODY_HOTSPOT_BT_MMW: | |
| bdf_file = QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SELECT_BDF3; | |
| break; | |
| default: | |
| ALOGE("wifi_select_tx_power_scenario: invalid scenario %d", scenario); | |
| ret = WIFI_ERROR_INVALID_ARGS; | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SAR_ENABLE, | |
| bdf_file)) { | |
| ALOGE("failed to put SAR_ENABLE"); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_select_tx_power_scenario(): requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_reset_tx_power_scenario(wifi_interface_handle handle) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| interface_info *ifaceInfo = getIfaceInfo(handle); | |
| wifi_handle wifiHandle = getWifiHandle(handle); | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| 1, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_SAR_LIMITS); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_reset_tx_power_scenario: failed to create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_reset_tx_power_scenario: failed to set iface id. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("wifi_reset_tx_power_scenario: failed attr_start for VENDOR_DATA. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32(QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SAR_ENABLE, | |
| QCA_WLAN_VENDOR_ATTR_SAR_LIMITS_SELECT_NONE)) { | |
| ALOGE("failed to put SAR_ENABLE or NUM_SPECS"); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_reset_tx_power_scenario(): requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_set_latency_mode(wifi_interface_handle handle, | |
| wifi_latency_mode mode) { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| u32 latency_mode; | |
| interface_info *ifaceInfo = getIfaceInfo(handle); | |
| wifi_handle wifiHandle = getWifiHandle(handle); | |
| hal_info *info = getHalInfo(wifiHandle); | |
| ALOGV("%s : latency mode:%d", __FUNCTION__, mode); | |
| /* Check Supported low-latency capability */ | |
| if (!(info->supported_feature_set & WIFI_FEATURE_SET_LATENCY_MODE)) { | |
| ALOGE("%s: Set latency mode feature not supported 0x%" PRIx64, __FUNCTION__, | |
| info->supported_feature_set); | |
| return WIFI_ERROR_NOT_SUPPORTED; | |
| } | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| wifiHandle, | |
| 1, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_SET_WIFI_CONFIGURATION); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_latency_mode: failed to create NL msg. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| ret = wifiConfigCommand->set_iface_id(ifaceInfo->name); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_latency_mode: failed to set iface id. Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Add the vendor specific attributes for the NL command. */ | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ret = WIFI_ERROR_UNKNOWN; | |
| ALOGE("wifi_set_latency_mode: failed attr_start for VENDOR_DATA. " | |
| "Error:%d", ret); | |
| goto cleanup; | |
| } | |
| switch(mode) { | |
| case WIFI_LATENCY_MODE_NORMAL: | |
| latency_mode = QCA_WLAN_VENDOR_ATTR_CONFIG_LATENCY_LEVEL_NORMAL; | |
| break; | |
| case WIFI_LATENCY_MODE_LOW: | |
| latency_mode = QCA_WLAN_VENDOR_ATTR_CONFIG_LATENCY_LEVEL_LOW; | |
| break; | |
| default: | |
| ALOGE("wifi_set_latency_mode: Invalid mode: %d", mode); | |
| ret = WIFI_ERROR_UNKNOWN; | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u16( | |
| QCA_WLAN_VENDOR_ATTR_CONFIG_LATENCY_LEVEL, | |
| latency_mode)) { | |
| ALOGE("wifi_set_latency_mode: failed to put latency mode"); | |
| ret = WIFI_ERROR_UNKNOWN; | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("wifi_set_latency_mode: requestEvent Error:%d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_set_thermal_mitigation_mode(wifi_handle handle, | |
| wifi_thermal_mode mode, | |
| u32 completion_window) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| struct nlattr *nlData; | |
| u32 qca_vendor_thermal_level; | |
| hal_info *info = getHalInfo(handle); | |
| if (!info || info->num_interfaces < 1) { | |
| ALOGE("%s: Error wifi_handle NULL or base wlan interface not present", | |
| __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| wifiConfigCommand = new WiFiConfigCommand( | |
| handle, | |
| 1, | |
| OUI_QCA, | |
| QCA_NL80211_VENDOR_SUBCMD_THERMAL_CMD); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error, Failed to create wifiConfigCommand", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| /* Create the NL message. */ | |
| ret = wifiConfigCommand->create(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("Failed to create thermal vendor command, Error:%d", ret); | |
| goto cleanup; | |
| } | |
| /* Set the interface Id of the message. */ | |
| if (wifiConfigCommand->put_u32(NL80211_ATTR_IFINDEX, | |
| info->interfaces[0]->id)) { | |
| ALOGE("%s: Failed to put iface id", __FUNCTION__); | |
| goto cleanup; | |
| } | |
| nlData = wifiConfigCommand->attr_start(NL80211_ATTR_VENDOR_DATA); | |
| if (!nlData) { | |
| ALOGE("%s: Failed in attr_start for VENDOR_DATA, Error:%d", | |
| __FUNCTION__, ret); | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32(QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_VALUE, | |
| QCA_WLAN_VENDOR_ATTR_THERMAL_CMD_TYPE_SET_LEVEL)) { | |
| ALOGE("Failed to put THERMAL_LEVEL command type"); | |
| goto cleanup; | |
| } | |
| switch(mode) { | |
| case WIFI_MITIGATION_NONE: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_NONE; | |
| break; | |
| case WIFI_MITIGATION_LIGHT: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_LIGHT; | |
| break; | |
| case WIFI_MITIGATION_MODERATE: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_MODERATE; | |
| break; | |
| case WIFI_MITIGATION_SEVERE: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_SEVERE; | |
| break; | |
| case WIFI_MITIGATION_CRITICAL: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_CRITICAL; | |
| break; | |
| case WIFI_MITIGATION_EMERGENCY: | |
| qca_vendor_thermal_level = QCA_WLAN_VENDOR_THERMAL_LEVEL_EMERGENCY; | |
| break; | |
| default: | |
| ALOGE("Unknown thermal mitigation level %d", mode); | |
| ret = WIFI_ERROR_UNKNOWN; | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_THERMAL_LEVEL, | |
| qca_vendor_thermal_level)) { | |
| ALOGE("Failed to put thermal level"); | |
| goto cleanup; | |
| } | |
| if (wifiConfigCommand->put_u32( | |
| QCA_WLAN_VENDOR_ATTR_THERMAL_COMPLETION_WINDOW, | |
| completion_window)) { | |
| ALOGE("Failed to put thermal completion window"); | |
| goto cleanup; | |
| } | |
| wifiConfigCommand->attr_end(nlData); | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("Failed to set thermal level with Error: %d", ret); | |
| goto cleanup; | |
| } | |
| cleanup: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| WiFiConfigCommand::WiFiConfigCommand(wifi_handle handle, | |
| int id, u32 vendor_id, | |
| u32 subcmd) | |
| : WifiVendorCommand(handle, id, vendor_id, subcmd) | |
| { | |
| /* Initialize the member data variables here */ | |
| mWaitforRsp = false; | |
| mRequestId = id; | |
| } | |
| WiFiConfigCommand::~WiFiConfigCommand() | |
| { | |
| unregisterVendorHandler(mVendor_id, mSubcmd); | |
| } | |
| /* This function implements creation of Vendor command */ | |
| wifi_error WiFiConfigCommand::create() | |
| { | |
| wifi_error 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); | |
| return ret; | |
| } | |
| /* This function implements creation of generic NL command */ | |
| wifi_error WiFiConfigCommand::create_generic(u8 cmdId) | |
| { | |
| wifi_error ret = mMsg.create(cmdId, 0, 0); | |
| return ret; | |
| } | |
| void WiFiConfigCommand::waitForRsp(bool wait) | |
| { | |
| mWaitforRsp = wait; | |
| } | |
| /* Callback handlers registered for nl message send */ | |
| static int error_handler_wifi_config(struct sockaddr_nl *nla, | |
| struct nlmsgerr *err, | |
| void *arg) | |
| { | |
| struct sockaddr_nl *tmp; | |
| int *ret = (int *)arg; | |
| tmp = nla; | |
| *ret = err->error; | |
| ALOGE("%s: Error code:%d (%s)", __FUNCTION__, *ret, strerror(-(*ret))); | |
| return NL_STOP; | |
| } | |
| /* Callback handlers registered for nl message send */ | |
| static int ack_handler_wifi_config(struct nl_msg *msg, void *arg) | |
| { | |
| int *ret = (int *)arg; | |
| struct nl_msg * a; | |
| a = msg; | |
| *ret = 0; | |
| return NL_STOP; | |
| } | |
| /* Callback handlers registered for nl message send */ | |
| static int finish_handler_wifi_config(struct nl_msg *msg, void *arg) | |
| { | |
| int *ret = (int *)arg; | |
| struct nl_msg * a; | |
| a = msg; | |
| *ret = 0; | |
| return NL_SKIP; | |
| } | |
| /* | |
| * Override base class requestEvent and implement little differently here. | |
| * This will send the request message. | |
| * We don't wait for any response back in case of wificonfig, | |
| * thus no wait for condition. | |
| */ | |
| wifi_error WiFiConfigCommand::requestEvent() | |
| { | |
| int status; | |
| wifi_error res = WIFI_SUCCESS; | |
| struct nl_cb *cb; | |
| cb = nl_cb_alloc(NL_CB_DEFAULT); | |
| if (!cb) { | |
| ALOGE("%s: Callback allocation failed",__FUNCTION__); | |
| res = WIFI_ERROR_OUT_OF_MEMORY; | |
| goto out; | |
| } | |
| status = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); | |
| if (status < 0) { | |
| res = mapKernelErrortoWifiHalError(status); | |
| goto out; | |
| } | |
| status = 1; | |
| nl_cb_err(cb, NL_CB_CUSTOM, error_handler_wifi_config, &status); | |
| nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler_wifi_config, | |
| &status); | |
| nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler_wifi_config, &status); | |
| /* Err is populated as part of finish_handler. */ | |
| while (status > 0) { | |
| nl_recvmsgs(mInfo->cmd_sock, cb); | |
| } | |
| if (status < 0) { | |
| res = mapKernelErrortoWifiHalError(status); | |
| goto out; | |
| } | |
| if (mWaitforRsp == true) { | |
| struct timespec abstime; | |
| abstime.tv_sec = 4; | |
| abstime.tv_nsec = 0; | |
| res = mCondition.wait(abstime); | |
| if (res == WIFI_ERROR_TIMED_OUT) | |
| ALOGE("%s: Time out happened.", __FUNCTION__); | |
| ALOGV("%s: Command invoked return value:%d, mWaitForRsp=%d", | |
| __FUNCTION__, res, mWaitforRsp); | |
| } | |
| out: | |
| /* Cleanup the mMsg */ | |
| mMsg.destroy(); | |
| return res; | |
| } | |
| static std::vector<std::string> added_ifaces; | |
| static bool is_dynamic_interface(const char * ifname) | |
| { | |
| for (const auto& iface : added_ifaces) { | |
| if (iface == std::string(ifname)) | |
| return true; | |
| } | |
| return false; | |
| } | |
| void wifi_cleanup_dynamic_ifaces(wifi_handle handle) | |
| { | |
| int len = added_ifaces.size(); | |
| while (len--) { | |
| wifi_virtual_interface_delete(handle, added_ifaces.front().c_str()); | |
| } | |
| added_ifaces.clear(); // could be redundent. But to be on safe side. | |
| } | |
| wifi_error wifi_virtual_interface_create(wifi_handle handle, | |
| const char* ifname, | |
| wifi_interface_type iface_type) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| u32 wlan0_id = if_nametoindex("wlan0"); | |
| if (!handle || !wlan0_id) { | |
| ALOGE("%s: Error wifi_handle NULL or wlan0 not present", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| ALOGD("%s: ifname=%s create", __FUNCTION__, ifname); | |
| // Do not create interface if already exist. | |
| if (if_nametoindex(ifname)) | |
| return WIFI_SUCCESS; | |
| wifiConfigCommand = new WiFiConfigCommand(handle, get_requestid(), 0, 0); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| nl80211_iftype type; | |
| switch(iface_type) { | |
| case WIFI_INTERFACE_TYPE_STA: /* IfaceType:STA */ | |
| type = NL80211_IFTYPE_STATION; | |
| break; | |
| case WIFI_INTERFACE_TYPE_AP: /* IfaceType:AP */ | |
| type = NL80211_IFTYPE_AP; | |
| break; | |
| case WIFI_INTERFACE_TYPE_P2P: /* IfaceType:P2P */ | |
| type = NL80211_IFTYPE_P2P_DEVICE; | |
| break; | |
| case WIFI_INTERFACE_TYPE_NAN: /* IfaceType:NAN */ | |
| type = NL80211_IFTYPE_NAN; | |
| break; | |
| default: | |
| ALOGE("%s: Wrong interface type %u", __FUNCTION__, iface_type); | |
| ret = WIFI_ERROR_UNKNOWN; | |
| goto done; | |
| break; | |
| } | |
| wifiConfigCommand->create_generic(NL80211_CMD_NEW_INTERFACE); | |
| wifiConfigCommand->put_u32(NL80211_ATTR_IFINDEX, wlan0_id); | |
| wifiConfigCommand->put_string(NL80211_ATTR_IFNAME, ifname); | |
| wifiConfigCommand->put_u32(NL80211_ATTR_IFTYPE, type); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("%s: requestEvent Error:%d", __FUNCTION__,ret); | |
| } | |
| // Update dynamic interface list | |
| added_ifaces.push_back(std::string(ifname)); | |
| done: | |
| delete wifiConfigCommand; | |
| return ret; | |
| } | |
| wifi_error wifi_virtual_interface_delete(wifi_handle handle, | |
| const char* ifname) | |
| { | |
| wifi_error ret; | |
| WiFiConfigCommand *wifiConfigCommand; | |
| u32 wlan0_id = if_nametoindex("wlan0"); | |
| if (!handle || !wlan0_id) { | |
| ALOGE("%s: Error wifi_handle NULL or wlan0 not present", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| ALOGD("%s: ifname=%s delete", __FUNCTION__, ifname); | |
| if (if_nametoindex(ifname) && !is_dynamic_interface(ifname)) { | |
| // Do not remove interface if it was not added dynamically. | |
| return WIFI_SUCCESS; | |
| } | |
| wifiConfigCommand = new WiFiConfigCommand(handle, get_requestid(), 0, 0); | |
| if (wifiConfigCommand == NULL) { | |
| ALOGE("%s: Error wifiConfigCommand NULL", __FUNCTION__); | |
| return WIFI_ERROR_UNKNOWN; | |
| } | |
| wifiConfigCommand->create_generic(NL80211_CMD_DEL_INTERFACE); | |
| wifiConfigCommand->put_u32(NL80211_ATTR_IFINDEX, if_nametoindex(ifname)); | |
| /* Send the NL msg. */ | |
| wifiConfigCommand->waitForRsp(false); | |
| ret = wifiConfigCommand->requestEvent(); | |
| if (ret != WIFI_SUCCESS) { | |
| ALOGE("%s: requestEvent Error:%d", __FUNCTION__,ret); | |
| } | |
| // Update dynamic interface list | |
| added_ifaces.erase(std::remove(added_ifaces.begin(), added_ifaces.end(), std::string(ifname)), | |
| added_ifaces.end()); | |
| delete wifiConfigCommand; | |
| return ret; | |
| } |