248 lines
8.6 KiB
C++
248 lines
8.6 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Portions copyright (C) 2017 Broadcom Limited
|
|
*
|
|
* 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 <stdint.h>
|
|
#include <fcntl.h>
|
|
#include <sys/socket.h>
|
|
#include <netlink/genl/genl.h>
|
|
#include <netlink/genl/family.h>
|
|
#include <netlink/genl/ctrl.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <netpacket/packet.h>
|
|
#include <linux/filter.h>
|
|
#include <linux/errqueue.h>
|
|
|
|
#include <linux/pkt_sched.h>
|
|
#include <netlink/object-api.h>
|
|
#include <netlink/netlink.h>
|
|
#include <netlink/socket.h>
|
|
#include <netlink/handlers.h>
|
|
|
|
#include "sync.h"
|
|
|
|
#define LOG_TAG "WifiHAL"
|
|
|
|
#include <utils/Log.h>
|
|
|
|
#include "wifi_hal.h"
|
|
#include "common.h"
|
|
#include "cpp_bindings.h"
|
|
|
|
typedef enum {
|
|
ANDR_WIFI_ATTRIBUTE_INVALID = 0,
|
|
ANDR_WIFI_ATTRIBUTE_NUM_RADIO = 1,
|
|
ANDR_WIFI_ATTRIBUTE_STATS_INFO = 2,
|
|
ANDR_WIFI_ATTRIBUTE_STATS_MAX = 3
|
|
} LINK_STAT_ATTRIBUTE;
|
|
|
|
/* Internal radio statistics structure in the driver */
|
|
typedef struct {
|
|
wifi_radio radio;
|
|
uint32_t on_time;
|
|
uint32_t tx_time;
|
|
uint32_t rx_time;
|
|
uint32_t on_time_scan;
|
|
uint32_t on_time_nbd;
|
|
uint32_t on_time_gscan;
|
|
uint32_t on_time_roam_scan;
|
|
uint32_t on_time_pno_scan;
|
|
uint32_t on_time_hs20;
|
|
uint32_t num_channels;
|
|
wifi_channel_stat channels[];
|
|
} wifi_radio_stat_internal;
|
|
|
|
enum {
|
|
LSTATS_SUBCMD_GET_INFO = ANDROID_NL80211_SUBCMD_LSTATS_RANGE_START,
|
|
};
|
|
|
|
class GetLinkStatsCommand : public WifiCommand
|
|
{
|
|
wifi_stats_result_handler mHandler;
|
|
public:
|
|
GetLinkStatsCommand(wifi_interface_handle iface, wifi_stats_result_handler handler)
|
|
: WifiCommand("GetLinkStatsCommand", iface, 0), mHandler(handler)
|
|
{ }
|
|
|
|
virtual int create() {
|
|
ALOGI("Creating message to get link statistics; iface = %d", mIfaceInfo->id);
|
|
|
|
int ret = mMsg.create(GOOGLE_OUI, LSTATS_SUBCMD_GET_INFO);
|
|
if (ret < 0) {
|
|
ALOGE("Failed to create %x - %d", LSTATS_SUBCMD_GET_INFO, ret);
|
|
return ret;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
protected:
|
|
virtual int handleResponse(WifiEvent& reply) {
|
|
void *data = NULL;
|
|
wifi_radio_stat *radio_stat_ptr = NULL;
|
|
u8 *iface_stat = NULL;
|
|
u8 *radioStatsBuf = NULL, *output = NULL, *data_ptr = NULL;
|
|
uint32_t total_size = 0, per_radio_size = 0, data_len = 0, rem_len = 0;
|
|
int num_radios = 0, id = 0, subcmd = 0, len = 0;
|
|
|
|
ALOGI("In GetLinkStatsCommand::handleResponse");
|
|
|
|
if (reply.get_cmd() != NL80211_CMD_VENDOR) {
|
|
ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
|
|
return NL_SKIP;
|
|
}
|
|
|
|
id = reply.get_vendor_id();
|
|
subcmd = reply.get_vendor_subcmd();
|
|
nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
|
|
len = reply.get_vendor_data_len();
|
|
|
|
ALOGV("Id = %0x, subcmd = %d, len = %d\n", id, subcmd, len);
|
|
if (vendor_data == NULL || len == 0) {
|
|
ALOGE("no vendor data in GetLinkStatCommand response; ignoring it");
|
|
return NL_SKIP;
|
|
}
|
|
|
|
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
|
|
if (it.get_type() == ANDR_WIFI_ATTRIBUTE_NUM_RADIO) {
|
|
num_radios = it.get_u32();
|
|
} else if (it.get_type() == ANDR_WIFI_ATTRIBUTE_STATS_INFO) {
|
|
data = it.get_data();
|
|
data_len = it.get_len();
|
|
} else {
|
|
ALOGW("Ignoring invalid attribute type = %d, size = %d\n",
|
|
it.get_type(), it.get_len());
|
|
return NL_SKIP;
|
|
}
|
|
}
|
|
|
|
if (num_radios) {
|
|
rem_len = MAX_CMD_RESP_BUF_LEN;
|
|
radioStatsBuf = (u8 *)malloc(MAX_CMD_RESP_BUF_LEN);
|
|
if (!radioStatsBuf) {
|
|
ALOGE("No memory\n");
|
|
return NL_SKIP;
|
|
}
|
|
memset(radioStatsBuf, 0, MAX_CMD_RESP_BUF_LEN);
|
|
output = radioStatsBuf;
|
|
|
|
if (!data || !data_len) {
|
|
ALOGE("%s: null data\n", __func__);
|
|
return NL_SKIP;
|
|
}
|
|
|
|
data_ptr = (u8*)data;
|
|
for (int i = 0; i < num_radios; i++) {
|
|
rem_len -= per_radio_size;
|
|
if (rem_len < per_radio_size) {
|
|
ALOGE("No data left for radio %d\n", i);
|
|
goto exit;
|
|
}
|
|
data_ptr = (u8*)data + total_size;
|
|
if (!data_ptr) {
|
|
ALOGE("Invalid data for radio index = %d\n", i);
|
|
goto exit;
|
|
}
|
|
radio_stat_ptr =
|
|
convertToExternalRadioStatStructure((wifi_radio_stat*)data_ptr,
|
|
&per_radio_size);
|
|
if (!radio_stat_ptr || !per_radio_size) {
|
|
ALOGE("No data for radio %d\n", i);
|
|
continue;
|
|
}
|
|
memcpy(output, radio_stat_ptr, per_radio_size);
|
|
output += per_radio_size;
|
|
total_size += per_radio_size;
|
|
}
|
|
|
|
iface_stat = ((u8*)data + total_size);
|
|
if (!iface_stat || data_len < total_size) {
|
|
ALOGE("No data for iface stats!!, data_len = %d, total_size = %d\n",
|
|
data_len, total_size);
|
|
goto exit;
|
|
}
|
|
(*mHandler.on_link_stats_results)(id, (wifi_iface_stat *)iface_stat,
|
|
num_radios, (wifi_radio_stat *)radioStatsBuf);
|
|
}
|
|
exit:
|
|
if (radio_stat_ptr) {
|
|
free(radio_stat_ptr);
|
|
radio_stat_ptr = NULL;
|
|
}
|
|
if (radioStatsBuf) {
|
|
free(radioStatsBuf);
|
|
radioStatsBuf = NULL;
|
|
}
|
|
return NL_OK;
|
|
}
|
|
|
|
private:
|
|
wifi_radio_stat *convertToExternalRadioStatStructure(wifi_radio_stat *internal_stat_ptr,
|
|
uint32_t *per_radio_size) {
|
|
wifi_radio_stat *external_stat_ptr = NULL;
|
|
if (!internal_stat_ptr) {
|
|
ALOGE("Incoming data is null\n");
|
|
} else {
|
|
uint32_t channel_size = internal_stat_ptr->num_channels * sizeof(wifi_channel_stat);
|
|
*per_radio_size = offsetof(wifi_radio_stat, channels) + channel_size;
|
|
external_stat_ptr = (wifi_radio_stat *)malloc(*per_radio_size);
|
|
if (external_stat_ptr) {
|
|
external_stat_ptr->radio = internal_stat_ptr->radio;
|
|
external_stat_ptr->on_time = internal_stat_ptr->on_time;
|
|
external_stat_ptr->tx_time = internal_stat_ptr->tx_time;
|
|
external_stat_ptr->num_tx_levels = internal_stat_ptr->num_tx_levels;
|
|
external_stat_ptr->tx_time_per_levels = NULL;
|
|
external_stat_ptr->rx_time = internal_stat_ptr->rx_time;
|
|
external_stat_ptr->on_time_scan = internal_stat_ptr->on_time_scan;
|
|
external_stat_ptr->on_time_nbd = internal_stat_ptr->on_time_nbd;
|
|
external_stat_ptr->on_time_gscan = internal_stat_ptr->on_time_gscan;
|
|
external_stat_ptr->on_time_roam_scan = internal_stat_ptr->on_time_roam_scan;
|
|
external_stat_ptr->on_time_pno_scan = internal_stat_ptr->on_time_pno_scan;
|
|
external_stat_ptr->on_time_hs20 = internal_stat_ptr->on_time_hs20;
|
|
external_stat_ptr->num_channels = internal_stat_ptr->num_channels;
|
|
if (internal_stat_ptr->num_channels) {
|
|
memcpy(&(external_stat_ptr->channels), &(internal_stat_ptr->channels),
|
|
channel_size);
|
|
}
|
|
}
|
|
}
|
|
return external_stat_ptr;
|
|
}
|
|
};
|
|
|
|
wifi_error wifi_get_link_stats(wifi_request_id id,
|
|
wifi_interface_handle iface, wifi_stats_result_handler handler)
|
|
{
|
|
GetLinkStatsCommand command(iface, handler);
|
|
return (wifi_error) command.requestResponse();
|
|
}
|
|
|
|
wifi_error wifi_set_link_stats(
|
|
wifi_interface_handle /* iface */, wifi_link_layer_params /* params */)
|
|
{
|
|
/* Return success here since bcom HAL does not need set link stats. */
|
|
return WIFI_SUCCESS;
|
|
}
|
|
|
|
wifi_error wifi_clear_link_stats(
|
|
wifi_interface_handle /* iface */, u32 /* stats_clear_req_mask */,
|
|
u32 * /* stats_clear_rsp_mask */, u8 /* stop_req */, u8 * /* stop_rsp */)
|
|
{
|
|
/* Return success here since bcom HAL does not support clear link stats. */
|
|
return WIFI_SUCCESS;
|
|
}
|