|
|
@@ -1,5 +1,5 @@
|
|
|
/*
|
|
|
- * Copyright (c) 2020 The Linux Foundation. All rights reserved.
|
|
|
+ * Copyright (c) 2020-2021 The Linux Foundation. All rights reserved.
|
|
|
*
|
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
@@ -29,6 +29,7 @@
|
|
|
#include <wlan_cp_stats_mc_ucfg_api.h>
|
|
|
#include <sme_api.h>
|
|
|
#include <wma_api.h>
|
|
|
+#include "wlan_cmn.h"
|
|
|
|
|
|
/* define short names for get station info attributes */
|
|
|
#define MEDIUM_ASSESS_TYPE \
|
|
|
@@ -66,6 +67,12 @@
|
|
|
|
|
|
#define MAX_CONGESTION_THRESHOLD 100
|
|
|
|
|
|
+#define MEDIUM_ASSESS_TIMER_INTERVAL 1000 /* 1000ms */
|
|
|
+static qdf_mc_timer_t hdd_medium_assess_timer;
|
|
|
+static uint8_t timer_enable, ssr_flag;
|
|
|
+struct hdd_medium_assess_info medium_assess_info[WLAN_UMAC_MAX_RP_PID];
|
|
|
+unsigned long stime;
|
|
|
+
|
|
|
const struct nla_policy
|
|
|
hdd_medium_assess_policy[MEDIUM_ASSESS_MAX + 1] = {
|
|
|
[MEDIUM_ASSESS_TYPE] = {.type = NLA_U8},
|
|
|
@@ -249,7 +256,48 @@ static int get_congestion_report_len(void)
|
|
|
*
|
|
|
* Return: None
|
|
|
*/
|
|
|
-static void hdd_congestion_notification_cb(uint8_t vdev_id, uint8_t congestion)
|
|
|
+static void hdd_congestion_notification_cb(uint8_t vdev_id,
|
|
|
+ struct medium_assess_data *data)
|
|
|
+{
|
|
|
+ struct hdd_medium_assess_info *mdata;
|
|
|
+ uint8_t i;
|
|
|
+
|
|
|
+ /* the cb should not be delay more than 40 ms or drop it */
|
|
|
+ if (qdf_system_time_after(jiffies, stime)) {
|
|
|
+ hdd_debug("medium assess interference data drop");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i = 0; i < WLAN_UMAC_MAX_RP_PID; i++) {
|
|
|
+ mdata = &medium_assess_info[i];
|
|
|
+ if (data[i].part1_valid) {
|
|
|
+ mdata->data[mdata->index].part1_valid = 1;
|
|
|
+ mdata->data[mdata->index].cycle_count =
|
|
|
+ data[i].cycle_count;
|
|
|
+ mdata->data[mdata->index].rx_clear_count =
|
|
|
+ data[i].rx_clear_count;
|
|
|
+ mdata->data[mdata->index].tx_frame_count =
|
|
|
+ data[i].tx_frame_count;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mdata->data[mdata->index].part1_valid) {
|
|
|
+ mdata->index++;
|
|
|
+ if (mdata->index >= MEDIUM_ASSESS_NUM)
|
|
|
+ mdata->index = 0;
|
|
|
+ mdata->data[mdata->index].part1_valid = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * hdd_congestion_notification_report() - congestion report function
|
|
|
+ * @vdev_id: vdev id
|
|
|
+ * @congestion: congestion percentage
|
|
|
+ *
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+static void hdd_congestion_notification_report(uint8_t vdev_id,
|
|
|
+ uint8_t congestion)
|
|
|
{
|
|
|
struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
|
|
|
struct hdd_adapter *adapter;
|
|
|
@@ -284,6 +332,37 @@ static void hdd_congestion_notification_cb(uint8_t vdev_id, uint8_t congestion)
|
|
|
cfg80211_vendor_event(event, GFP_KERNEL);
|
|
|
}
|
|
|
|
|
|
+void hdd_medium_assess_ssr_enable_flag(void)
|
|
|
+{
|
|
|
+ ssr_flag = 1;
|
|
|
+}
|
|
|
+
|
|
|
+void hdd_medium_assess_stop_timer(uint8_t pdev_id, struct hdd_context *hdd_ctx)
|
|
|
+{
|
|
|
+ struct request_info info = {0};
|
|
|
+ bool pending = false;
|
|
|
+ uint8_t i, interval = 0;
|
|
|
+
|
|
|
+ if (ssr_flag)
|
|
|
+ return;
|
|
|
+
|
|
|
+ medium_assess_info[pdev_id].config.threshold = MAX_CONGESTION_THRESHOLD;
|
|
|
+ medium_assess_info[pdev_id].config.interval = 0;
|
|
|
+ medium_assess_info[pdev_id].index = 0;
|
|
|
+ medium_assess_info[pdev_id].count = 0;
|
|
|
+
|
|
|
+ for (i = 0; i < WLAN_UMAC_MAX_RP_PID; i++)
|
|
|
+ interval += medium_assess_info[i].config.interval;
|
|
|
+
|
|
|
+ if (!interval) {
|
|
|
+ ucfg_mc_cp_stats_reset_pending_req(hdd_ctx->psoc,
|
|
|
+ TYPE_CONGESTION_STATS,
|
|
|
+ &info, &pending);
|
|
|
+ qdf_mc_timer_stop(&hdd_medium_assess_timer);
|
|
|
+ hdd_debug("medium assess atimer stop");
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
/**
|
|
|
* hdd_medium_assess_congestion_report() - congestion report
|
|
|
* @hdd_ctx: pointer to HDD context
|
|
|
@@ -296,32 +375,38 @@ static int hdd_medium_assess_congestion_report(struct hdd_context *hdd_ctx,
|
|
|
struct hdd_adapter *adapter,
|
|
|
struct nlattr **tb)
|
|
|
{
|
|
|
- struct wlan_objmgr_vdev *vdev;
|
|
|
- uint8_t enable, threshold, interval = 1;
|
|
|
- struct request_info info = {0};
|
|
|
- bool pending = false;
|
|
|
QDF_STATUS status;
|
|
|
+ struct wlan_objmgr_vdev *vdev;
|
|
|
+ uint8_t enable, threshold, interval = 0;
|
|
|
+ uint8_t pdev_id, vdev_id;
|
|
|
int errno = 0;
|
|
|
|
|
|
+ if (!tb[CONGESTION_REPORT_ENABLE]) {
|
|
|
+ hdd_err_rl("Congestion report enable is not present");
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+
|
|
|
vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_CP_STATS_ID);
|
|
|
if (!vdev)
|
|
|
return -EINVAL;
|
|
|
|
|
|
- if (!tb[CONGESTION_REPORT_ENABLE]) {
|
|
|
- hdd_err_rl("Congestion report enable is not present");
|
|
|
- errno = -EINVAL;
|
|
|
+ vdev_id = adapter->vdev_id;
|
|
|
+ status = policy_mgr_get_mac_id_by_session_id(hdd_ctx->psoc, vdev_id,
|
|
|
+ &pdev_id);
|
|
|
+ if (QDF_IS_STATUS_ERROR(status)) {
|
|
|
+ hdd_err("get mac id failed");
|
|
|
goto out;
|
|
|
}
|
|
|
- enable = nla_get_u8(tb[CONGESTION_REPORT_ENABLE]);
|
|
|
|
|
|
+ medium_assess_info[pdev_id].vdev_id = vdev_id;
|
|
|
+ medium_assess_info[pdev_id].pdev_id = pdev_id;
|
|
|
+
|
|
|
+ enable = nla_get_u8(tb[CONGESTION_REPORT_ENABLE]);
|
|
|
switch (enable) {
|
|
|
case REPORT_DISABLE:
|
|
|
- ucfg_mc_cp_stats_reset_pending_req(hdd_ctx->psoc,
|
|
|
- TYPE_CONGESTION_STATS,
|
|
|
- &info,
|
|
|
- &pending);
|
|
|
- threshold = MAX_CONGESTION_THRESHOLD;
|
|
|
- interval = 0;
|
|
|
+ hdd_debug("medium assess disable: pdev_id %d, vdev_id: %d",
|
|
|
+ pdev_id, vdev_id);
|
|
|
+ hdd_medium_assess_stop_timer(pdev_id, hdd_ctx);
|
|
|
break;
|
|
|
case REPORT_ENABLE:
|
|
|
if (!tb[CONGESTION_REPORT_THRESHOLD]) {
|
|
|
@@ -335,44 +420,32 @@ static int hdd_medium_assess_congestion_report(struct hdd_context *hdd_ctx,
|
|
|
errno = -EINVAL;
|
|
|
goto out;
|
|
|
}
|
|
|
- if (tb[CONGESTION_REPORT_INTERVAL])
|
|
|
+ if (tb[CONGESTION_REPORT_INTERVAL]) {
|
|
|
interval = nla_get_u8(tb[CONGESTION_REPORT_INTERVAL]);
|
|
|
- status = ucfg_mc_cp_stats_reset_congestion_counter(vdev);
|
|
|
- if (QDF_IS_STATUS_ERROR(status)) {
|
|
|
- hdd_err("Failed to set threshold");
|
|
|
- errno = qdf_status_to_os_return(status);
|
|
|
- goto out;
|
|
|
+ if (interval >= MEDIUM_ASSESS_NUM)
|
|
|
+ interval = MEDIUM_ASSESS_NUM - 1;
|
|
|
+ } else {
|
|
|
+ interval = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ medium_assess_info[pdev_id].config.threshold = threshold;
|
|
|
+ medium_assess_info[pdev_id].config.interval = interval;
|
|
|
+ medium_assess_info[pdev_id].index = 0;
|
|
|
+ medium_assess_info[pdev_id].count = 0;
|
|
|
+ hdd_debug("medium assess enable: pdev_id %d, vdev_id: %d",
|
|
|
+ pdev_id, vdev_id);
|
|
|
+
|
|
|
+ if (qdf_mc_timer_get_current_state(&hdd_medium_assess_timer) ==
|
|
|
+ QDF_TIMER_STATE_STOPPED) {
|
|
|
+ hdd_debug("medium assess atimer start");
|
|
|
+ qdf_mc_timer_start(&hdd_medium_assess_timer,
|
|
|
+ MEDIUM_ASSESS_TIMER_INTERVAL);
|
|
|
}
|
|
|
break;
|
|
|
default:
|
|
|
hdd_err_rl("Invalid enable: %d", enable);
|
|
|
errno = -EINVAL;
|
|
|
- goto out;
|
|
|
- }
|
|
|
-
|
|
|
- status = ucfg_mc_cp_stats_set_congestion_threshold(vdev, threshold);
|
|
|
- if (QDF_IS_STATUS_ERROR(status)) {
|
|
|
- hdd_err("Failed to set threshold");
|
|
|
- errno = qdf_status_to_os_return(status);
|
|
|
- goto out;
|
|
|
- }
|
|
|
-
|
|
|
- errno = sme_cli_set_command(adapter->vdev_id,
|
|
|
- WMI_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD,
|
|
|
- interval * 1000, PDEV_CMD);
|
|
|
- if (errno) {
|
|
|
- hdd_err("Failed to set interval");
|
|
|
- goto out;
|
|
|
- }
|
|
|
-
|
|
|
- if (interval) {
|
|
|
- info.vdev_id = adapter->vdev_id;
|
|
|
- info.pdev_id =
|
|
|
- wlan_objmgr_pdev_get_pdev_id(wlan_vdev_get_pdev(vdev));
|
|
|
- info.u.congestion_notif_cb = hdd_congestion_notification_cb;
|
|
|
- errno = ucfg_mc_cp_stats_send_stats_request(vdev,
|
|
|
- TYPE_CONGESTION_STATS,
|
|
|
- &info);
|
|
|
+ break;
|
|
|
}
|
|
|
|
|
|
out:
|
|
|
@@ -463,3 +536,186 @@ int hdd_cfg80211_medium_assess(struct wiphy *wiphy,
|
|
|
|
|
|
return errno;
|
|
|
}
|
|
|
+
|
|
|
+/**
|
|
|
+ * hdd_congestion_notification_calculation() - medium assess congestion
|
|
|
+ * calculation.
|
|
|
+ * @info: structure hdd_medium_assess_info
|
|
|
+ *
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+static void
|
|
|
+hdd_congestion_notification_calculation(struct hdd_medium_assess_info *info)
|
|
|
+{
|
|
|
+ struct medium_assess_data *h_data, *t_data;
|
|
|
+ int32_t h_index, t_index;
|
|
|
+ uint32_t rx_clear_count_delta, tx_frame_count_delta;
|
|
|
+ uint32_t cycle_count_delta;
|
|
|
+ uint32_t congestion = 0;
|
|
|
+
|
|
|
+ h_index = info->index - 1;
|
|
|
+ if (h_index < 0)
|
|
|
+ h_index = MEDIUM_ASSESS_NUM - 1;
|
|
|
+
|
|
|
+ if (h_index >= info->config.interval)
|
|
|
+ t_index = h_index - info->config.interval;
|
|
|
+ else
|
|
|
+ t_index = MEDIUM_ASSESS_NUM - info->config.interval - h_index;
|
|
|
+
|
|
|
+ if (h_index < 0 || h_index >= MEDIUM_ASSESS_NUM ||
|
|
|
+ t_index < 0 || t_index >= MEDIUM_ASSESS_NUM) {
|
|
|
+ hdd_err("medium assess index is not valid.");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ h_data = &info->data[h_index];
|
|
|
+ t_data = &info->data[t_index];
|
|
|
+
|
|
|
+ if (!(h_data->part1_valid || t_data->part1_valid)) {
|
|
|
+ hdd_err("medium assess data is not valid.");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (h_data->rx_clear_count >= t_data->rx_clear_count) {
|
|
|
+ rx_clear_count_delta = h_data->rx_clear_count -
|
|
|
+ t_data->rx_clear_count;
|
|
|
+ } else {
|
|
|
+ rx_clear_count_delta = U32_MAX - t_data->rx_clear_count;
|
|
|
+ rx_clear_count_delta += h_data->rx_clear_count;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (h_data->tx_frame_count >= t_data->tx_frame_count) {
|
|
|
+ tx_frame_count_delta = h_data->tx_frame_count -
|
|
|
+ t_data->tx_frame_count;
|
|
|
+ } else {
|
|
|
+ tx_frame_count_delta = U32_MAX - t_data->tx_frame_count;
|
|
|
+ tx_frame_count_delta += h_data->tx_frame_count;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (h_data->cycle_count >= t_data->cycle_count) {
|
|
|
+ cycle_count_delta = h_data->cycle_count - t_data->cycle_count;
|
|
|
+ } else {
|
|
|
+ cycle_count_delta = U32_MAX - t_data->cycle_count;
|
|
|
+ cycle_count_delta += h_data->cycle_count;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (cycle_count_delta)
|
|
|
+ congestion = (rx_clear_count_delta - tx_frame_count_delta)
|
|
|
+ * 100 / cycle_count_delta;
|
|
|
+ if (congestion > 100)
|
|
|
+ congestion = 100;
|
|
|
+
|
|
|
+ hdd_debug("pdev: %d, rx_clear %u, tx_frame %u cycle %u congestion: %u",
|
|
|
+ info->pdev_id, rx_clear_count_delta, tx_frame_count_delta,
|
|
|
+ cycle_count_delta, congestion);
|
|
|
+ if (congestion >= info->config.threshold)
|
|
|
+ hdd_congestion_notification_report(info->vdev_id, congestion);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * hdd_congestion_notification_report_multi() - medium assess report
|
|
|
+ * multi interface.
|
|
|
+ * @pdev_id: pdev id
|
|
|
+ *
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+static void hdd_congestion_notification_report_multi(uint8_t pdev_id)
|
|
|
+{
|
|
|
+ struct hdd_medium_assess_info *info;
|
|
|
+
|
|
|
+ info = &medium_assess_info[pdev_id];
|
|
|
+ info->count++;
|
|
|
+ if (info->count % info->config.interval == 0)
|
|
|
+ hdd_congestion_notification_calculation(info);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * hdd_medium_assess_expire_handler() - timer callback
|
|
|
+ * @arg: argument
|
|
|
+ *
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+static void hdd_medium_assess_expire_handler(void *arg)
|
|
|
+{
|
|
|
+ struct wlan_objmgr_vdev *vdev;
|
|
|
+ struct request_info info = {0};
|
|
|
+ struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
|
|
|
+ struct hdd_adapter *adapter;
|
|
|
+ uint8_t vdev_id = INVALID_VDEV_ID, pdev_id;
|
|
|
+ uint8_t index, i;
|
|
|
+
|
|
|
+ if (wlan_hdd_validate_context(hdd_ctx))
|
|
|
+ return;
|
|
|
+
|
|
|
+ for (i = 0; i < WLAN_UMAC_MAX_RP_PID; i++)
|
|
|
+ if (medium_assess_info[i].config.interval != 0) {
|
|
|
+ vdev_id = medium_assess_info[i].vdev_id;
|
|
|
+ pdev_id = medium_assess_info[i].pdev_id;
|
|
|
+ hdd_congestion_notification_report_multi(pdev_id);
|
|
|
+
|
|
|
+ /* ensure events are reveived at the 'same' time */
|
|
|
+ index = medium_assess_info[i].index;
|
|
|
+ medium_assess_info[i].data[index].part1_valid = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (vdev_id == INVALID_VDEV_ID)
|
|
|
+ return;
|
|
|
+
|
|
|
+ adapter = hdd_get_adapter_by_vdev(hdd_ctx, vdev_id);
|
|
|
+ if (!adapter) {
|
|
|
+ hdd_err("Failed to find adapter of vdev %d", vdev_id);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_CP_STATS_ID);
|
|
|
+ if (!vdev)
|
|
|
+ return;
|
|
|
+
|
|
|
+ info.vdev_id = vdev_id;
|
|
|
+ info.pdev_id = 0;
|
|
|
+ info.u.congestion_notif_cb = hdd_congestion_notification_cb;
|
|
|
+ stime = jiffies + msecs_to_jiffies(40);
|
|
|
+ ucfg_mc_cp_stats_send_stats_request(vdev,
|
|
|
+ TYPE_CONGESTION_STATS,
|
|
|
+ &info);
|
|
|
+ hdd_objmgr_put_vdev_by_user(vdev, WLAN_CP_STATS_ID);
|
|
|
+ qdf_mc_timer_start(&hdd_medium_assess_timer,
|
|
|
+ MEDIUM_ASSESS_TIMER_INTERVAL);
|
|
|
+}
|
|
|
+
|
|
|
+void hdd_medium_assess_init(void)
|
|
|
+{
|
|
|
+ QDF_STATUS status;
|
|
|
+
|
|
|
+ if (!timer_enable) {
|
|
|
+ hdd_debug("medium assess init timer");
|
|
|
+ status = qdf_mc_timer_init(&hdd_medium_assess_timer,
|
|
|
+ QDF_TIMER_TYPE_SW,
|
|
|
+ hdd_medium_assess_expire_handler,
|
|
|
+ NULL);
|
|
|
+ if (QDF_IS_STATUS_ERROR(status)) {
|
|
|
+ hdd_debug("medium assess init timer failed");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ssr_flag) {
|
|
|
+ ssr_flag = 0;
|
|
|
+ qdf_mc_timer_start(&hdd_medium_assess_timer,
|
|
|
+ MEDIUM_ASSESS_TIMER_INTERVAL);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ timer_enable += 1;
|
|
|
+}
|
|
|
+
|
|
|
+void hdd_medium_assess_deinit(void)
|
|
|
+{
|
|
|
+ timer_enable -= 1;
|
|
|
+ if (!timer_enable) {
|
|
|
+ hdd_debug("medium assess deinit timer");
|
|
|
+ if (qdf_mc_timer_get_current_state(&hdd_medium_assess_timer) ==
|
|
|
+ QDF_TIMER_STATE_RUNNING)
|
|
|
+ qdf_mc_timer_stop(&hdd_medium_assess_timer);
|
|
|
+
|
|
|
+ qdf_mc_timer_destroy(&hdd_medium_assess_timer);
|
|
|
+ }
|
|
|
+}
|
Paul Zhang