367 lines
12 KiB
C++
367 lines
12 KiB
C++
/* Copyright (c) 2014, 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 "ifaceeventhandler.h"
|
|
|
|
/* Used to handle NL command events from driver/firmware. */
|
|
IfaceEventHandlerCommand *mwifiEventHandler = NULL;
|
|
|
|
/* Set the interface event monitor handler*/
|
|
wifi_error wifi_set_iface_event_handler(wifi_request_id id,
|
|
wifi_interface_handle iface,
|
|
wifi_event_handler eh)
|
|
{
|
|
int ret = 0;
|
|
wifi_handle wifiHandle = getWifiHandle(iface);
|
|
|
|
/* Check if a similar request to set iface event handler was made earlier.
|
|
* Right now we don't differentiate between the case where (i) the new
|
|
* Request Id is different from the current one vs (ii) both new and
|
|
* Request Ids are the same.
|
|
*/
|
|
if (mwifiEventHandler)
|
|
{
|
|
if (id == mwifiEventHandler->get_request_id()) {
|
|
ALOGE("%s: Iface Event Handler Set for request Id %d is still"
|
|
"running. Exit", __func__, id);
|
|
return WIFI_ERROR_TOO_MANY_REQUESTS;
|
|
} else {
|
|
ALOGE("%s: Iface Event Handler Set for a different Request "
|
|
"Id:%d is requested. Not supported. Exit", __func__, id);
|
|
return WIFI_ERROR_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
|
|
mwifiEventHandler = new IfaceEventHandlerCommand(
|
|
wifiHandle,
|
|
id,
|
|
NL80211_CMD_REG_CHANGE);
|
|
if (mwifiEventHandler == NULL) {
|
|
ALOGE("%s: Error mwifiEventHandler NULL", __func__);
|
|
return WIFI_ERROR_UNKNOWN;
|
|
}
|
|
mwifiEventHandler->setCallbackHandler(eh);
|
|
|
|
return (wifi_error)ret;
|
|
}
|
|
|
|
/* Reset monitoring for the NL event*/
|
|
wifi_error wifi_reset_iface_event_handler(wifi_request_id id,
|
|
wifi_interface_handle iface)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (mwifiEventHandler)
|
|
{
|
|
if (id == mwifiEventHandler->get_request_id()) {
|
|
ALOGV("Delete Object mwifiEventHandler for id = %d", id);
|
|
delete mwifiEventHandler;
|
|
mwifiEventHandler = NULL;
|
|
} else {
|
|
ALOGE("%s: Iface Event Handler Set for a different Request "
|
|
"Id:%d is requested. Not supported. Exit", __func__, id);
|
|
return WIFI_ERROR_NOT_SUPPORTED;
|
|
}
|
|
} else {
|
|
ALOGV("Object mwifiEventHandler for id = %d already Deleted", id);
|
|
}
|
|
|
|
return (wifi_error)ret;
|
|
}
|
|
|
|
/* This function will be the main handler for the registered incoming
|
|
* (from driver) Commads. Calls the appropriate callback handler after
|
|
* parsing the vendor data.
|
|
*/
|
|
int IfaceEventHandlerCommand::handleEvent(WifiEvent &event)
|
|
{
|
|
wifiEventHandler::handleEvent(event);
|
|
|
|
switch(mSubcmd)
|
|
{
|
|
case NL80211_CMD_REG_CHANGE:
|
|
{
|
|
char code[2];
|
|
memset(&code[0], 0, 2);
|
|
if(tb[NL80211_ATTR_REG_ALPHA2])
|
|
{
|
|
memcpy(&code[0], (char *) nla_data(tb[NL80211_ATTR_REG_ALPHA2]), 2);
|
|
} else {
|
|
ALOGE("%s: NL80211_ATTR_REG_ALPHA2 not found", __func__);
|
|
}
|
|
ALOGV("Country : %c%c", code[0], code[1]);
|
|
if(mHandler.on_country_code_changed)
|
|
{
|
|
mHandler.on_country_code_changed(code);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
ALOGV("NL Event : %d Not supported", mSubcmd);
|
|
}
|
|
|
|
return NL_SKIP;
|
|
}
|
|
|
|
IfaceEventHandlerCommand::IfaceEventHandlerCommand(wifi_handle handle, int id, u32 subcmd)
|
|
: wifiEventHandler(handle, id, subcmd)
|
|
{
|
|
ALOGV("wifiEventHandler %p constructed", this);
|
|
registerHandler(mSubcmd);
|
|
memset(&mHandler, 0, sizeof(wifi_event_handler));
|
|
mEventData = NULL;
|
|
mDataLen = 0;
|
|
}
|
|
|
|
IfaceEventHandlerCommand::~IfaceEventHandlerCommand()
|
|
{
|
|
ALOGV("IfaceEventHandlerCommand %p destructor", this);
|
|
unregisterHandler(mSubcmd);
|
|
}
|
|
|
|
void IfaceEventHandlerCommand::setCallbackHandler(wifi_event_handler nHandler)
|
|
{
|
|
mHandler = nHandler;
|
|
}
|
|
|
|
int wifiEventHandler::get_request_id()
|
|
{
|
|
return mRequestId;
|
|
}
|
|
|
|
int IfaceEventHandlerCommand::get_request_id()
|
|
{
|
|
return wifiEventHandler::get_request_id();
|
|
}
|
|
|
|
wifiEventHandler::wifiEventHandler(wifi_handle handle, int id, u32 subcmd)
|
|
: WifiCommand(handle, id)
|
|
{
|
|
mRequestId = id;
|
|
mSubcmd = subcmd;
|
|
registerHandler(mSubcmd);
|
|
ALOGV("wifiEventHandler %p constructed", this);
|
|
}
|
|
|
|
wifiEventHandler::~wifiEventHandler()
|
|
{
|
|
ALOGV("wifiEventHandler %p destructor", this);
|
|
unregisterHandler(mSubcmd);
|
|
}
|
|
|
|
int wifiEventHandler::handleEvent(WifiEvent &event)
|
|
{
|
|
struct genlmsghdr *gnlh = event.header();
|
|
mSubcmd = gnlh->cmd;
|
|
nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
|
|
genlmsg_attrlen(gnlh, 0), NULL);
|
|
ALOGV("Got NL Event : %d from the Driver.", gnlh->cmd);
|
|
|
|
return NL_SKIP;
|
|
}
|
|
|
|
WifihalGeneric::WifihalGeneric(wifi_handle handle, int id, u32 vendor_id,
|
|
u32 subcmd)
|
|
: WifiVendorCommand(handle, id, vendor_id, subcmd)
|
|
{
|
|
/* Initialize the member data variables here */
|
|
mSet = 0;
|
|
mSetSizeMax = 0;
|
|
mSetSizePtr = NULL;
|
|
mConcurrencySet = 0;
|
|
filterVersion = 0;
|
|
filterLength = 0;
|
|
firmware_bus_max_size = 0;
|
|
}
|
|
|
|
WifihalGeneric::~WifihalGeneric()
|
|
{
|
|
}
|
|
|
|
int WifihalGeneric::requestResponse()
|
|
{
|
|
return WifiCommand::requestResponse(mMsg);
|
|
}
|
|
|
|
int WifihalGeneric::handleResponse(WifiEvent &reply)
|
|
{
|
|
ALOGV("Got a Wi-Fi HAL module message from Driver");
|
|
int i = 0;
|
|
WifiVendorCommand::handleResponse(reply);
|
|
|
|
// Parse the vendordata and get the attribute
|
|
switch(mSubcmd)
|
|
{
|
|
case QCA_NL80211_VENDOR_SUBCMD_GET_SUPPORTED_FEATURES:
|
|
{
|
|
struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_SET_MAX + 1];
|
|
nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_FEATURE_SET_MAX,
|
|
(struct nlattr *)mVendorData,
|
|
mDataLen, NULL);
|
|
|
|
if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_SET])
|
|
{
|
|
ALOGE("%s: QCA_WLAN_VENDOR_ATTR_FEATURE_SET not found", __func__);
|
|
return WIFI_ERROR_INVALID_ARGS;
|
|
}
|
|
mSet = nla_get_u32(tb_vendor[QCA_WLAN_VENDOR_ATTR_FEATURE_SET]);
|
|
ALOGV("Supported feature set : %x", mSet);
|
|
|
|
break;
|
|
}
|
|
case QCA_NL80211_VENDOR_SUBCMD_GET_CONCURRENCY_MATRIX:
|
|
{
|
|
struct nlattr *tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_MAX + 1];
|
|
nla_parse(tb_vendor,
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_MAX,
|
|
(struct nlattr *)mVendorData,mDataLen, NULL);
|
|
|
|
if (tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_RESULTS_SET_SIZE]) {
|
|
u32 val;
|
|
val = nla_get_u32(
|
|
tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_RESULTS_SET_SIZE]);
|
|
|
|
ALOGV("%s: Num of concurrency combinations: %d",
|
|
__func__, val);
|
|
val = val > (unsigned int)mSetSizeMax ?
|
|
(unsigned int)mSetSizeMax : val;
|
|
*mSetSizePtr = val;
|
|
|
|
/* Extract the list of channels. */
|
|
if (*mSetSizePtr > 0 &&
|
|
tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_RESULTS_SET]) {
|
|
nla_memcpy(mConcurrencySet,
|
|
tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_GET_CONCURRENCY_MATRIX_RESULTS_SET],
|
|
sizeof(feature_set) * (*mSetSizePtr));
|
|
}
|
|
|
|
ALOGV("%s: Get concurrency matrix response received.",
|
|
__func__);
|
|
ALOGV("%s: Num of concurrency combinations : %d",
|
|
__func__, *mSetSizePtr);
|
|
ALOGV("%s: List of valid concurrency combinations is: ",
|
|
__func__);
|
|
for(i = 0; i < *mSetSizePtr; i++)
|
|
{
|
|
ALOGV("%x", *(mConcurrencySet + i));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case QCA_NL80211_VENDOR_SUBCMD_PACKET_FILTER:
|
|
{
|
|
struct nlattr *tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_MAX + 1];
|
|
nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_MAX,
|
|
(struct nlattr *)mVendorData,
|
|
mDataLen, NULL);
|
|
|
|
if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_VERSION])
|
|
{
|
|
ALOGE("%s: QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_VERSION"
|
|
" not found", __FUNCTION__);
|
|
return WIFI_ERROR_INVALID_ARGS;
|
|
}
|
|
filterVersion = nla_get_u32(
|
|
tb_vendor[QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_VERSION]);
|
|
ALOGV("Current version : %u", filterVersion);
|
|
|
|
if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_TOTAL_LENGTH])
|
|
{
|
|
ALOGE("%s: QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_TOTAL_LENGTH"
|
|
" not found", __FUNCTION__);
|
|
return WIFI_ERROR_INVALID_ARGS;
|
|
}
|
|
filterLength = nla_get_u32(
|
|
tb_vendor[QCA_WLAN_VENDOR_ATTR_PACKET_FILTER_TOTAL_LENGTH]);
|
|
ALOGV("Max filter length Supported : %u", filterLength);
|
|
|
|
}
|
|
break;
|
|
case QCA_NL80211_VENDOR_SUBCMD_GET_BUS_SIZE:
|
|
{
|
|
struct nlattr *tb_vendor[
|
|
QCA_WLAN_VENDOR_ATTR_DRV_INFO_MAX + 1];
|
|
nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_DRV_INFO_MAX,
|
|
(struct nlattr *)mVendorData, mDataLen, NULL);
|
|
|
|
if (!tb_vendor[QCA_WLAN_VENDOR_ATTR_DRV_INFO_BUS_SIZE])
|
|
{
|
|
ALOGE("%s: QCA_WLAN_VENDOR_ATTR_DRV_INFO_BUS_SIZE"
|
|
" not found", __FUNCTION__);
|
|
return WIFI_ERROR_INVALID_ARGS;
|
|
}
|
|
firmware_bus_max_size = nla_get_u32(
|
|
tb_vendor[QCA_WLAN_VENDOR_ATTR_DRV_INFO_BUS_SIZE]);
|
|
ALOGV("Max BUS size Supported: %d", firmware_bus_max_size);
|
|
}
|
|
break;
|
|
default :
|
|
ALOGE("%s: Wrong Wi-Fi HAL event received %d", __func__, mSubcmd);
|
|
}
|
|
return NL_SKIP;
|
|
}
|
|
|
|
void WifihalGeneric::getResponseparams(feature_set *pset)
|
|
{
|
|
*pset = mSet;
|
|
}
|
|
|
|
void WifihalGeneric::setMaxSetSize(int set_size_max) {
|
|
mSetSizeMax = set_size_max;
|
|
}
|
|
|
|
void WifihalGeneric::setConcurrencySet(feature_set set[]) {
|
|
mConcurrencySet = set;
|
|
}
|
|
|
|
void WifihalGeneric::setSizePtr(int *set_size) {
|
|
mSetSizePtr = set_size;
|
|
}
|
|
|
|
int WifihalGeneric::getFilterVersion() {
|
|
return filterVersion;
|
|
}
|
|
|
|
int WifihalGeneric::getFilterLength() {
|
|
return filterLength;
|
|
}
|
|
|
|
int WifihalGeneric::getBusSize() {
|
|
return firmware_bus_max_size;
|
|
}
|