| /* Copyright (c) 2017, 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" |
| |
| #include <utils/Log.h> |
| |
| #include "wifi_hal.h" |
| #include "common.h" |
| #include "cpp_bindings.h" |
| #include "radio_mode.h" |
| #include "vendor_definitions.h" |
| #include <netlink/genl/genl.h> |
| #include <string.h> |
| #include <net/if.h> |
| |
| /* Used to handle radio mode command events from driver/firmware.*/ |
| void RADIOModeCommand::setCallbackHandler(wifi_radio_mode_change_handler handler) |
| { |
| mHandler = handler; |
| } |
| |
| void RADIOModeCommand::setReqId(wifi_request_id id) |
| { |
| mreqId = id; |
| } |
| |
| RADIOModeCommand::RADIOModeCommand(wifi_handle handle, int id, |
| u32 vendor_id, u32 subcmd) |
| : WifiVendorCommand(handle, id, vendor_id, subcmd) |
| { |
| memset(&mHandler, 0, sizeof(mHandler)); |
| if (registerVendorHandler(vendor_id, subcmd)) { |
| /* Error case should not happen print log */ |
| ALOGE("%s: Unable to register Vendor Handler Vendor Id=0x%x subcmd=%u", |
| __FUNCTION__, vendor_id, subcmd); |
| } |
| } |
| |
| RADIOModeCommand::~RADIOModeCommand() |
| { |
| unregisterVendorHandler(mVendor_id, mSubcmd); |
| } |
| |
| |
| RADIOModeCommand* RADIOModeCommand::instance(wifi_handle handle, |
| wifi_request_id id) |
| { |
| RADIOModeCommand* mRADIOModeCommandInstance; |
| |
| if (handle == NULL) { |
| ALOGE("Interface Handle is invalid"); |
| return NULL; |
| } |
| hal_info *info = getHalInfo(handle); |
| if (!info) { |
| ALOGE("hal_info is invalid"); |
| return NULL; |
| } |
| mRADIOModeCommandInstance = new RADIOModeCommand(handle, id, |
| OUI_QCA, |
| QCA_NL80211_VENDOR_SUBCMD_WLAN_MAC_INFO); |
| return mRADIOModeCommandInstance; |
| } |
| |
| /* This function will be the main handler for incoming event. |
| * Call the appropriate callback handler after parsing the vendor data. |
| */ |
| int RADIOModeCommand::handleEvent(WifiEvent &event) |
| { |
| wifi_error ret = WIFI_SUCCESS; |
| int num_of_mac = 0; |
| wifi_mac_info mode_info; |
| |
| memset(&mode_info, 0, sizeof(mode_info)); |
| WifiVendorCommand::handleEvent(event); |
| |
| /* Parse the vendordata and get the attribute */ |
| switch(mSubcmd) |
| { |
| case QCA_NL80211_VENDOR_SUBCMD_WLAN_MAC_INFO: |
| { |
| struct nlattr *mtb_vendor[QCA_WLAN_VENDOR_ATTR_MAC_MAX + 1]; |
| struct nlattr *modeInfo; |
| int rem; |
| |
| nla_parse(mtb_vendor, QCA_WLAN_VENDOR_ATTR_MAC_MAX, |
| (struct nlattr *)mVendorData, |
| mDataLen, NULL); |
| |
| if (mtb_vendor[QCA_WLAN_VENDOR_ATTR_MAC_INFO]) |
| { |
| for (modeInfo = (struct nlattr *) nla_data(mtb_vendor[QCA_WLAN_VENDOR_ATTR_MAC_INFO]), |
| rem = nla_len(mtb_vendor[QCA_WLAN_VENDOR_ATTR_MAC_INFO]); |
| nla_ok(modeInfo, rem);modeInfo = nla_next(modeInfo, &(rem))) { |
| |
| struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_MAC_INFO_MAX+ 1]; |
| nla_parse(tb2, QCA_WLAN_VENDOR_ATTR_MAC_INFO_MAX, |
| (struct nlattr *) nla_data(modeInfo), nla_len(modeInfo), NULL); |
| if (!tb2[QCA_WLAN_VENDOR_ATTR_MAC_INFO_MAC_ID]) |
| { |
| ALOGE("%s: QCA_WLAN_VENDOR_ATTR_MAC_INFO_MAC_ID" |
| " not found", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| mode_info.wlan_mac_id = nla_get_u32(tb2[QCA_WLAN_VENDOR_ATTR_MAC_INFO_MAC_ID]); |
| ALOGV("mac_id[%d]: %d ", num_of_mac, mode_info.wlan_mac_id); |
| |
| if (!tb2[QCA_WLAN_VENDOR_ATTR_MAC_INFO_BAND]) |
| { |
| ALOGE("%s: QCA_WLAN_VENDOR_ATTR_MAC_INFO_BAND" |
| " NOT FOUND", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| mode_info.mac_band = (wlan_mac_band) nla_get_u32(tb2[QCA_WLAN_VENDOR_ATTR_MAC_INFO_BAND]); |
| ALOGV("mac_band[%d]: %d ", num_of_mac, mode_info.mac_band); |
| |
| if (tb2[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO]) |
| { |
| int num_of_iface = 0; |
| struct nlattr *tb_iface; |
| int rem_info; |
| |
| for (tb_iface = (struct nlattr *) nla_data(tb2[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO]), |
| rem_info = nla_len(tb2[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO]); |
| nla_ok(tb_iface, rem_info);tb_iface = nla_next(tb_iface, &(rem_info))) { |
| |
| struct nlattr *tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_MAX+ 1]; |
| wifi_iface_info miface_info; |
| |
| nla_parse(tb3, QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_MAX, |
| (struct nlattr *) nla_data(tb_iface), nla_len(tb_iface), NULL); |
| |
| if (!tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_IFINDEX]) |
| { |
| ALOGE("%s: QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_IFINDEX" |
| " NOT FOUND", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| if (if_indextoname(nla_get_u32(tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_IFINDEX]), |
| miface_info.iface_name) == NULL) |
| { |
| ALOGE("%s: Failed to convert %d IFINDEX to IFNAME", __FUNCTION__, |
| nla_get_u32(tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_IFINDEX])); |
| } |
| ALOGV("ifname[%d]: %s ", num_of_iface, miface_info.iface_name); |
| |
| if (!tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_FREQ]) |
| { |
| ALOGE("%s: QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_FREQ" |
| " NOT FOUND", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| miface_info.channel = nla_get_u32(tb3[QCA_WLAN_VENDOR_ATTR_MAC_IFACE_INFO_FREQ]); |
| ALOGV("channel[%d]: %d ", num_of_iface, miface_info.channel); |
| |
| if (!num_of_iface) |
| mode_info.iface_info = (wifi_iface_info *) |
| malloc(sizeof(wifi_iface_info)); |
| else |
| mode_info.iface_info = (wifi_iface_info *) |
| realloc(mode_info.iface_info, (num_of_iface + 1) * sizeof(wifi_iface_info)); |
| |
| memcpy(&mode_info.iface_info[num_of_iface], &miface_info, sizeof(wifi_iface_info)); |
| num_of_iface++; |
| mode_info.num_iface = num_of_iface; |
| } |
| } |
| if (!num_of_mac) |
| mwifi_iface_mac_info = (wifi_mac_info *) |
| malloc(sizeof(wifi_mac_info)); |
| else |
| mwifi_iface_mac_info = (wifi_mac_info *) |
| realloc(mwifi_iface_mac_info, (num_of_mac + 1) * (sizeof(wifi_mac_info))); |
| |
| memcpy(&mwifi_iface_mac_info[num_of_mac], &mode_info, sizeof(wifi_mac_info)); |
| num_of_mac++; |
| } |
| } |
| |
| if (mHandler.on_radio_mode_change && num_of_mac) { |
| (*mHandler.on_radio_mode_change)(mreqId, num_of_mac, mwifi_iface_mac_info); |
| free(mwifi_iface_mac_info); |
| mwifi_iface_mac_info = NULL; |
| } |
| else { |
| ALOGE("No Callback registered: on radio mode change"); |
| free(mwifi_iface_mac_info); |
| mwifi_iface_mac_info = NULL; |
| } |
| } |
| break; |
| |
| default: |
| /* Error case should not happen print log */ |
| ALOGE("%s: Wrong subcmd received %d", __FUNCTION__, mSubcmd); |
| } |
| |
| return ret; |
| } |
| |
| wifi_error wifi_set_radio_mode_change_handler(wifi_request_id id, |
| wifi_interface_handle iface, |
| wifi_radio_mode_change_handler eh) |
| { |
| wifi_error ret; |
| WifiVendorCommand *vCommand = NULL; |
| wifi_handle wifiHandle = getWifiHandle(iface); |
| RADIOModeCommand *radiomodeCommand; |
| |
| ret = initialize_vendor_cmd(iface, id, |
| QCA_NL80211_VENDOR_SUBCMD_WLAN_MAC_INFO, |
| &vCommand); |
| if (ret != WIFI_SUCCESS) { |
| ALOGE("%s: Initialization failed", __FUNCTION__); |
| return ret; |
| } |
| |
| radiomodeCommand = RADIOModeCommand::instance(wifiHandle, id); |
| if (radiomodeCommand == NULL) { |
| ALOGE("%s: Error RadioModeCommand NULL", __FUNCTION__); |
| ret = WIFI_ERROR_OUT_OF_MEMORY; |
| goto cleanup; |
| } |
| radiomodeCommand->setCallbackHandler(eh); |
| radiomodeCommand->setReqId(id); |
| |
| cleanup: |
| delete vCommand; |
| return mapKernelErrortoWifiHalError(ret); |
| } |
