/* * 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 <stdlib.h> #include <linux/pkt_sched.h> #include <netlink/object-api.h> #include <netlink-types.h> #include <dlfcn.h> #include "wifi_hal.h" #include "common.h" #include <netlink-types.h> interface_info *getIfaceInfo(wifi_interface_handle handle) { return (interface_info *)handle; } wifi_handle getWifiHandle(wifi_interface_handle handle) { return getIfaceInfo(handle)->handle; } hal_info *getHalInfo(wifi_handle handle) { return (hal_info *)handle; } hal_info *getHalInfo(wifi_interface_handle handle) { return getHalInfo(getWifiHandle(handle)); } wifi_handle getWifiHandle(hal_info *info) { return (wifi_handle)info; } wifi_interface_handle getIfaceHandle(interface_info *info) { return (wifi_interface_handle)info; } wifi_error wifi_register_handler(wifi_handle handle, int cmd, nl_recvmsg_msg_cb_t func, void *arg) { hal_info *info = (hal_info *)handle; pthread_mutex_lock(&info->cb_lock); wifi_error result = WIFI_ERROR_OUT_OF_MEMORY; for (int i = 0; i < info->num_event_cb; i++) { if(info->event_cb[i].nl_cmd == cmd && info->event_cb[i].cb_arg == arg) { info->event_cb[i].cb_func = func; ALOGI("Updated event handler %p for nl_cmd 0x%0x" " and arg %p", func, cmd, arg); pthread_mutex_unlock(&info->cb_lock); return WIFI_SUCCESS; } } if (info->num_event_cb < info->alloc_event_cb) { info->event_cb[info->num_event_cb].nl_cmd = cmd; info->event_cb[info->num_event_cb].vendor_id = 0; info->event_cb[info->num_event_cb].vendor_subcmd = 0; info->event_cb[info->num_event_cb].cb_func = func; info->event_cb[info->num_event_cb].cb_arg = arg; info->num_event_cb++; ALOGI("Successfully added event handler %p for command %d", func, cmd); result = WIFI_SUCCESS; } else { result = WIFI_ERROR_OUT_OF_MEMORY; } pthread_mutex_unlock(&info->cb_lock); return result; } wifi_error wifi_register_vendor_handler(wifi_handle handle, uint32_t id, int subcmd, nl_recvmsg_msg_cb_t func, void *arg) { hal_info *info = (hal_info *)handle; pthread_mutex_lock(&info->cb_lock); wifi_error result = WIFI_ERROR_OUT_OF_MEMORY; for (int i = 0; i < info->num_event_cb; i++) { if(info->event_cb[i].vendor_id == id && info->event_cb[i].vendor_subcmd == subcmd) { info->event_cb[i].cb_func = func; info->event_cb[i].cb_arg = arg; ALOGI("Updated event handler %p for vendor 0x%0x, subcmd 0x%0x" " and arg %p", func, id, subcmd, arg); pthread_mutex_unlock(&info->cb_lock); return WIFI_SUCCESS; } } if (info->num_event_cb < info->alloc_event_cb) { info->event_cb[info->num_event_cb].nl_cmd = NL80211_CMD_VENDOR; info->event_cb[info->num_event_cb].vendor_id = id; info->event_cb[info->num_event_cb].vendor_subcmd = subcmd; info->event_cb[info->num_event_cb].cb_func = func; info->event_cb[info->num_event_cb].cb_arg = arg; info->num_event_cb++; ALOGI("Added event handler %p for vendor 0x%0x, subcmd 0x%0x and arg" " %p", func, id, subcmd, arg); result = WIFI_SUCCESS; } else { result = WIFI_ERROR_OUT_OF_MEMORY; } pthread_mutex_unlock(&info->cb_lock); return result; } void wifi_unregister_handler(wifi_handle handle, int cmd) { hal_info *info = (hal_info *)handle; if (cmd == NL80211_CMD_VENDOR) { ALOGE("Must use wifi_unregister_vendor_handler to remove vendor handlers"); return; } pthread_mutex_lock(&info->cb_lock); for (int i = 0; i < info->num_event_cb; i++) { if (info->event_cb[i].nl_cmd == cmd) { if(i < info->num_event_cb-1) { /* No need to memmove if only one entry exist and deleting * the same, as the num_event_cb will become 0 in this case. */ memmove(&info->event_cb[i], &info->event_cb[i+1], (info->num_event_cb - i) * sizeof(cb_info)); } info->num_event_cb--; ALOGI("Successfully removed event handler for command %d", cmd); break; } } pthread_mutex_unlock(&info->cb_lock); } void wifi_unregister_vendor_handler(wifi_handle handle, uint32_t id, int subcmd) { hal_info *info = (hal_info *)handle; pthread_mutex_lock(&info->cb_lock); for (int i = 0; i < info->num_event_cb; i++) { if (info->event_cb[i].nl_cmd == NL80211_CMD_VENDOR && info->event_cb[i].vendor_id == id && info->event_cb[i].vendor_subcmd == subcmd) { if(i < info->num_event_cb-1) { /* No need to memmove if only one entry exist and deleting * the same, as the num_event_cb will become 0 in this case. */ memmove(&info->event_cb[i], &info->event_cb[i+1], (info->num_event_cb - i) * sizeof(cb_info)); } info->num_event_cb--; ALOGI("Successfully removed event handler for vendor 0x%0x", id); break; } } pthread_mutex_unlock(&info->cb_lock); } wifi_error wifi_register_cmd(wifi_handle handle, int id, WifiCommand *cmd) { hal_info *info = (hal_info *)handle; ALOGD("registering command %d", id); if (info->num_cmd < info->alloc_cmd) { info->cmd[info->num_cmd].id = id; info->cmd[info->num_cmd].cmd = cmd; info->num_cmd++; ALOGI("Successfully added command %d: %p", id, cmd); return WIFI_SUCCESS; } else { return WIFI_ERROR_OUT_OF_MEMORY; } } WifiCommand *wifi_unregister_cmd(wifi_handle handle, int id) { hal_info *info = (hal_info *)handle; ALOGD("un-registering command %d", id); for (int i = 0; i < info->num_cmd; i++) { if (info->cmd[i].id == id) { WifiCommand *cmd = info->cmd[i].cmd; memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info)); info->num_cmd--; ALOGI("Successfully removed command %d: %p", id, cmd); return cmd; } } return NULL; } void wifi_unregister_cmd(wifi_handle handle, WifiCommand *cmd) { hal_info *info = (hal_info *)handle; for (int i = 0; i < info->num_cmd; i++) { if (info->cmd[i].cmd == cmd) { int id = info->cmd[i].id; memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info)); info->num_cmd--; ALOGI("Successfully removed command %d: %p", id, cmd); return; } } } #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ void hexdump(void *buf, u16 len) { int i=0; char *bytes = (char *)buf; ALOGI("******HexDump len:%d*********", len); for (i = 0; ((i + 7) < len); i+=8) { ALOGI("%02x %02x %02x %02x %02x %02x %02x %02x", bytes[i], bytes[i+1], bytes[i+2], bytes[i+3], bytes[i+4], bytes[i+5], bytes[i+6], bytes[i+7]); } if ((len - i) >= 4) { ALOGI("%02x %02x %02x %02x", bytes[i], bytes[i+1], bytes[i+2], bytes[i+3]); i+=4; } for (;i < len;i++) { ALOGI("%02x", bytes[i]); } ALOGI("******HexDump End***********"); } #ifdef __cplusplus } #endif /* __cplusplus */ /* Pointer to the table of LOWI callback funcs */ lowi_cb_table_t *LowiWifiHalApi = NULL; /* LowiSupportedCapabilities read */ u32 lowiSupportedCapabilities = 0; int compareLowiVersion(u16 major, u16 minor, u16 micro) { u32 currVersion = 0x10000*(WIFIHAL_LOWI_MAJOR_VERSION) + \ 0x100*(WIFIHAL_LOWI_MINOR_VERSION) + \ WIFIHAL_LOWI_MICRO_VERSION; u32 lowiVersion = 0x10000*(major) + \ 0x100*(minor) + \ micro; return (memcmp(&currVersion, &lowiVersion, sizeof(u32))); } /* * This function will open the lowi shared library and obtain the * Lowi Callback table and the capabilities supported. * A version check is also performed in this function and if the version * check fails then the callback table returned will be NULL. */ wifi_error fetchLowiCbTableAndCapabilities(lowi_cb_table_t **lowi_wifihal_api, bool *lowi_get_capa_supported) { getCbTable_t* lowiCbTable = NULL; int ret = 0; wifi_error retVal = WIFI_SUCCESS; *lowi_wifihal_api = NULL; *lowi_get_capa_supported = false; #if __WORDSIZE == 64 void* lowi_handle = dlopen("/vendor/lib64/liblowi_wifihal.so", RTLD_NOW); #else void* lowi_handle = dlopen("/vendor/lib/liblowi_wifihal.so", RTLD_NOW); #endif if (!lowi_handle) { ALOGE("%s: NULL lowi_handle, err: %s", __FUNCTION__, dlerror()); return WIFI_ERROR_UNKNOWN; } lowiCbTable = (getCbTable_t*)dlsym(lowi_handle, "lowi_wifihal_get_cb_table"); if (!lowiCbTable) { ALOGE("%s: NULL lowi callback table", __FUNCTION__); return WIFI_ERROR_UNKNOWN; } *lowi_wifihal_api = lowiCbTable(); /* First check whether lowi module implements the get_lowi_version * function. All the functions in lowi module starts with * "lowi_wifihal_" prefix thus the below function name. */ if ((dlsym(lowi_handle, "lowi_wifihal_get_lowi_version") != NULL) && ((*lowi_wifihal_api)->get_lowi_version != NULL)) { u16 lowiMajorVersion = WIFIHAL_LOWI_MAJOR_VERSION; u16 lowiMinorVersion = WIFIHAL_LOWI_MINOR_VERSION; u16 lowiMicroVersion = WIFIHAL_LOWI_MICRO_VERSION; int versionCheck = -1; ret = (*lowi_wifihal_api)->get_lowi_version(&lowiMajorVersion, &lowiMinorVersion, &lowiMicroVersion); if (ret) { ALOGI("%s: get_lowi_version returned error:%d", __FUNCTION__, ret); retVal = WIFI_ERROR_NOT_SUPPORTED; goto cleanup; } ALOGI("%s: Lowi version:%d.%d.%d", __FUNCTION__, lowiMajorVersion, lowiMinorVersion, lowiMicroVersion); /* Compare the version with version in wifihal_internal.h */ versionCheck = compareLowiVersion(lowiMajorVersion, lowiMinorVersion, lowiMicroVersion); if (versionCheck < 0) { ALOGI("%s: Version Check failed:%d", __FUNCTION__, versionCheck); retVal = WIFI_ERROR_NOT_SUPPORTED; goto cleanup; } else { ALOGI("%s: Version Check passed:%d", __FUNCTION__, versionCheck); } } else { ALOGI("%s: lowi_wifihal_get_lowi_version not present", __FUNCTION__); } /* Check if get_lowi_capabilities func pointer exists in * the lowi lib and populate lowi_get_capa_supported * All the functions in lowi modules starts with * "lowi_wifihal_ prefix" thus the below function name. */ if (dlsym(lowi_handle, "lowi_wifihal_get_lowi_capabilities") != NULL) { *lowi_get_capa_supported = true; } else { ALOGI("lowi_wifihal_get_lowi_capabilities() is not supported."); *lowi_get_capa_supported = false; } cleanup: if (retVal) { *lowi_wifihal_api = NULL; } return retVal; } lowi_cb_table_t *getLowiCallbackTable(u32 requested_lowi_capabilities) { int ret = WIFI_SUCCESS; bool lowi_get_capabilities_support = false; if (requested_lowi_capabilities == GSCAN_SUPPORTED) { ALOGV("%s: Returning Null, GSCAN not supported by lowi", __FUNCTION__); return NULL; } ALOGI("%s: Entry", __FUNCTION__); if (LowiWifiHalApi == NULL) { ALOGI("%s: LowiWifiHalApi Null, Initialize Lowi", __FUNCTION__); ret = fetchLowiCbTableAndCapabilities(&LowiWifiHalApi, &lowi_get_capabilities_support); if (ret != WIFI_SUCCESS || LowiWifiHalApi == NULL || LowiWifiHalApi->init == NULL) { ALOGI("%s: LOWI is not supported.", __FUNCTION__); goto cleanup; } /* Initialize LOWI if it isn't up already. */ ret = LowiWifiHalApi->init(); if (ret) { ALOGE("%s: failed lowi initialization. " "Returned error:%d. Exit.", __FUNCTION__, ret); goto cleanup; } if (!lowi_get_capabilities_support || LowiWifiHalApi->get_lowi_capabilities == NULL) { ALOGI("%s: Allow rtt APIs thru LOWI to proceed even though " "get_lowi_capabilities() is not supported. Returning", __FUNCTION__); lowiSupportedCapabilities |= (ONE_SIDED_RANGING_SUPPORTED|DUAL_SIDED_RANGING_SUPPORED); return LowiWifiHalApi; } ret = LowiWifiHalApi->get_lowi_capabilities(&lowiSupportedCapabilities); if (ret) { ALOGI("%s: failed to get lowi supported capabilities." "Returned error:%d. Exit.", __FUNCTION__, ret); goto cleanup; } } if ((lowiSupportedCapabilities & requested_lowi_capabilities) == 0) { ALOGE("%s: requested lowi capabilities: 0x%08x is not " " in supported capabilities: 0x%08x. Return NULL.", __FUNCTION__, requested_lowi_capabilities, lowiSupportedCapabilities); return NULL; } ALOGI("%s: Returning valid LowiWifiHalApi instance:%p", __FUNCTION__, LowiWifiHalApi); return LowiWifiHalApi; cleanup: ALOGI("%s: Cleaning up Lowi due to failure. Return NULL", __FUNCTION__); if (LowiWifiHalApi && LowiWifiHalApi->destroy) { ret = LowiWifiHalApi->destroy(); } LowiWifiHalApi = NULL; lowiSupportedCapabilities = 0; return LowiWifiHalApi; }