android/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Transition HDD to OSIF Request Manager

Browse Source 
The HDD Request Manager was replicated in the converged project as the
OSIF Request Manager so that the infrastructure could be used by the
converged code. Transition HDD to the OSIF Request Manager and remove
the now duplicated HDD Request Manager.

Change-Id: I2dfdd2da4f98e95a74ba13d04bb42d25a90c9ec8
CRs-Fixed: 2269909
This commit is contained in:
Jeff Johnson 2018-06-28 13:27:01 -07:00 committed by nshrivas
parent ceb4e9b46e
commit f1a99eae5a
13 changed files with 292 additions and 712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Kbuild
View File

@ -53,7 +53,6 @@ HDD_OBJS := $(HDD_SRC_DIR)/wlan_hdd_assoc.o \
$(HDD_SRC_DIR)/wlan_hdd_p2p.o \
$(HDD_SRC_DIR)/wlan_hdd_power.o \
$(HDD_SRC_DIR)/wlan_hdd_regulatory.o \
$(HDD_SRC_DIR)/wlan_hdd_request_manager.o \
$(HDD_SRC_DIR)/wlan_hdd_scan.o \
$(HDD_SRC_DIR)/wlan_hdd_softap_tx_rx.o \
$(HDD_SRC_DIR)/wlan_hdd_stats.o \

26
core/hdd/src/wlan_hdd_apf.c
View File

@ -24,7 +24,7 @@
#include "wlan_hdd_apf.h"
#include "qca_vendor.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
struct hdd_apf_context apf_context;
@ -84,21 +84,21 @@ struct apf_offload_priv {
void hdd_get_apf_capabilities_cb(void *context,
struct sir_apf_get_offload *data)
{
struct hdd_request *request;
struct osif_request *request;
struct apf_offload_priv *priv;
hdd_enter();
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->apf_get_offload = *data;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -159,21 +159,21 @@ static int hdd_get_apf_capabilities(struct hdd_context *hdd_ctx)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct apf_offload_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_APF,
};
hdd_enter();
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Unable to allocate request");
return -EINVAL;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_apf_capabilities(hdd_ctx->mac_handle,
hdd_get_apf_capabilities_cb,
@ -183,12 +183,12 @@ static int hdd_get_apf_capabilities(struct hdd_context *hdd_ctx)
ret = qdf_status_to_os_return(status);
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("Target response timed out");
goto cleanup;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
ret = hdd_post_get_apf_capabilities_rsp(hdd_ctx,
&priv->apf_get_offload);
if (ret)
@ -201,7 +201,7 @@ cleanup:
* response from SME, and posted the response to userspace.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
hdd_exit();
return ret;

62
core/hdd/src/wlan_hdd_cfg80211.c
View File

@ -88,7 +88,7 @@
#include "wlan_hdd_lpass.h"
#include "wlan_hdd_nan_datapath.h"
#include "wlan_hdd_disa.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "wlan_hdd_he.h"
#ifdef FEATURE_WLAN_APF
#include "wlan_hdd_apf.h"
@ -11611,7 +11611,7 @@ struct hdd_sar_context {
static void hdd_sar_cb(void *cookie,
struct sar_limit_event *event)
{
struct hdd_request *request;
struct osif_request *request;
struct hdd_sar_context *context;
hdd_enter();
@ -11621,16 +11621,16 @@ static void hdd_sar_cb(void *cookie,
return;
}
request = hdd_request_get(cookie);
request = osif_request_get(cookie);
if (!request) {
hdd_debug("Obsolete request");
return;
}
context = hdd_request_priv(request);
context = osif_request_priv(request);
context->event = *event;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -11768,13 +11768,13 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
const void *data, int data_len)
{
struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
struct hdd_request *request;
struct osif_request *request;
struct hdd_sar_context *context;
mac_handle_t mac_handle;
void *cookie;
QDF_STATUS status;
int ret;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*context),
.timeout_ms = WLAN_WAIT_TIME_SAR,
};
@ -11789,13 +11789,13 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
if (wlan_hdd_validate_context(hdd_ctx))
return -EINVAL;
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
mac_handle = hdd_ctx->mac_handle;
status = sme_get_sar_power_limits(mac_handle, hdd_sar_cb, cookie);
@ -11805,17 +11805,17 @@ static int __wlan_hdd_get_sar_power_limits(struct wiphy *wiphy,
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("Target response timed out");
goto cleanup;
}
context = hdd_request_priv(request);
context = osif_request_priv(request);
ret = hdd_sar_send_response(wiphy, &context->event);
cleanup:
hdd_request_put(request);
osif_request_put(request);
return ret;
}
@ -13114,8 +13114,8 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
uint32_t pkt_type_bitmap;
struct sk_buff *skb;
struct hdd_request *request = NULL;
static const struct hdd_request_params params = {
struct osif_request *request = NULL;
static const struct osif_request_params params = {
.priv_size = 0,
.timeout_ms = WLAN_WAIT_TIME_NUD_STATS,
};
@ -13141,13 +13141,13 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
return -EINVAL;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
arp_stats_params.pkt_type = WLAN_NUD_STATS_ARP_PKT_TYPE;
arp_stats_params.vdev_id = adapter->session_id;
@ -13178,7 +13178,7 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
goto exit;
}
err = hdd_request_wait_for_response(request);
err = osif_request_wait_for_response(request);
if (err) {
hdd_err("SME timedout while retrieving NUD stats");
err = -ETIMEDOUT;
@ -13233,7 +13233,7 @@ static int __wlan_hdd_cfg80211_get_nud_stats(struct wiphy *wiphy,
cfg80211_vendor_cmd_reply(skb);
exit:
hdd_request_put(request);
osif_request_put(request);
return err;
}
@ -13333,21 +13333,21 @@ struct chain_rssi_priv {
static void hdd_get_chain_rssi_cb(void *context,
struct chain_rssi_result *data)
{
struct hdd_request *request;
struct osif_request *request;
struct chain_rssi_priv *priv;
hdd_enter();
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->chain_rssi = *data;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -13416,9 +13416,9 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
QDF_STATUS status;
int retval;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct chain_rssi_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -13449,12 +13449,12 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
QDF_MAC_ADDR_SIZE);
req_msg.session_id = adapter->session_id;
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
mac_handle = hdd_ctx->mac_handle;
status = sme_get_chain_rssi(mac_handle,
@ -13465,18 +13465,18 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
hdd_err("Unable to get chain rssi");
retval = qdf_status_to_os_return(status);
} else {
retval = hdd_request_wait_for_response(request);
retval = osif_request_wait_for_response(request);
if (retval) {
hdd_err("Target response timed out");
} else {
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
retval = hdd_post_get_chain_rssi_rsp(hdd_ctx,
&priv->chain_rssi);
if (retval)
hdd_err("Failed to post chain rssi");
}
}
hdd_request_put(request);
osif_request_put(request);
hdd_exit();
return retval;

26
core/hdd/src/wlan_hdd_debugfs.c
View File

@ -28,7 +28,7 @@
#ifdef WLAN_OPEN_SOURCE
#include <wlan_hdd_includes.h>
#include <wlan_hdd_debugfs.h>
#include <wlan_hdd_request_manager.h>
#include <wlan_osif_request_manager.h>
#include <wlan_hdd_wowl.h>
#include <cds_sched.h>
#include <wlan_hdd_debugfs_llstat.h>
@ -394,20 +394,20 @@ static void hdd_power_debugstats_dealloc(void *priv)
static void hdd_power_debugstats_cb(struct power_stats_response *response,
void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct power_stats_priv *priv;
uint32_t *debug_registers;
uint32_t debug_registers_len;
hdd_enter();
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
/* copy fixed-sized data */
priv->power_stats = *response;
@ -427,8 +427,8 @@ static void hdd_power_debugstats_cb(struct power_stats_response *response,
priv->power_stats.num_debug_register = 0;
}
}
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -454,9 +454,9 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
unsigned int len = 0;
char *power_debugfs_buf = NULL;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct power_stats_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
.dealloc = hdd_power_debugstats_dealloc,
@ -477,12 +477,12 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
if (!wlan_hdd_validate_modules_state(hdd_ctx))
return -EINVAL;
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_power_debug_stats_req(hdd_ctx->mac_handle,
hdd_power_debugstats_cb,
@ -493,14 +493,14 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
goto cleanup;
}
ret_cnt = hdd_request_wait_for_response(request);
ret_cnt = osif_request_wait_for_response(request);
if (ret_cnt) {
hdd_err("Target response timed out Power stats");
ret_cnt = -ETIMEDOUT;
goto cleanup;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
chip_power_stats = &priv->power_stats;
power_debugfs_buf = qdf_mem_malloc(POWER_DEBUGFS_BUFFER_MAX_LEN);
@ -540,7 +540,7 @@ static ssize_t __wlan_hdd_read_power_debugfs(struct file *file,
cleanup:
qdf_mem_free(power_debugfs_buf);
hdd_request_put(request);
osif_request_put(request);
return ret_cnt;
}

26
core/hdd/src/wlan_hdd_disa.c
View File

@ -25,7 +25,7 @@
#include "wlan_hdd_disa.h"
#include "wlan_disa_ucfg_api.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "sme_api.h"
#include <qca_vendor.h>
@ -55,7 +55,7 @@ struct hdd_encrypt_decrypt_msg_context {
static void hdd_encrypt_decrypt_msg_cb(void *cookie,
struct disa_encrypt_decrypt_resp_params *resp)
{
struct hdd_request *request;
struct osif_request *request;
struct hdd_encrypt_decrypt_msg_context *context;
hdd_enter();
@ -65,7 +65,7 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
return;
}
request = hdd_request_get(cookie);
request = osif_request_get(cookie);
if (!request) {
hdd_err("Obsolete request");
return;
@ -81,7 +81,7 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
resp->status,
resp->data_len);
context = hdd_request_priv(request);
context = osif_request_priv(request);
context->response = *resp;
context->status = 0;
if (resp->data_len) {
@ -101,8 +101,8 @@ static void hdd_encrypt_decrypt_msg_cb(void *cookie,
context->response.data = NULL;
}
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -361,27 +361,27 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
QDF_STATUS qdf_status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct hdd_encrypt_decrypt_msg_context *context;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*context),
.timeout_ms = WLAN_WAIT_TIME_ENCRYPT_DECRYPT,
.dealloc = hdd_encrypt_decrypt_context_dealloc,
};
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
context = hdd_request_priv(request);
context = osif_request_priv(request);
ret = hdd_fill_encrypt_decrypt_params(&context->request, adapter,
data, data_len);
if (ret)
goto cleanup;
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
qdf_status = ucfg_disa_encrypt_decrypt_req(hdd_ctx->hdd_psoc,
&context->request,
@ -394,7 +394,7 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("Target response timed out");
goto cleanup;
@ -411,7 +411,7 @@ static int hdd_encrypt_decrypt_msg(struct hdd_adapter *adapter,
hdd_err("Failed to post encrypt/decrypt message response");
cleanup:
hdd_request_put(request);
osif_request_put(request);
hdd_exit();
return ret;

26
core/hdd/src/wlan_hdd_fips.c
View File

@ -24,7 +24,7 @@
#include "wlan_hdd_main.h"
#include "wlan_hdd_fips.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "qdf_mem.h"
#include "sme_api.h"
@ -81,7 +81,7 @@ static int hdd_fips_event_dup(struct wmi_host_fips_event_param *dest,
static void hdd_fips_cb(void *cookie,
struct wmi_host_fips_event_param *response)
{
struct hdd_request *request;
struct osif_request *request;
struct hdd_fips_context *context;
hdd_enter();
@ -91,7 +91,7 @@ static void hdd_fips_cb(void *cookie,
return;
}
request = hdd_request_get(cookie);
request = osif_request_get(cookie);
if (!request) {
hdd_debug("Obsolete request");
return;
@ -104,7 +104,7 @@ static void hdd_fips_cb(void *cookie,
qdf_trace_hex_dump(QDF_MODULE_ID_HDD, QDF_TRACE_LEVEL_DEBUG,
response->data, response->data_len);
context = hdd_request_priv(request);
context = osif_request_priv(request);
if (response->error_status) {
context->status = -ETIMEDOUT;
} else {
@ -112,8 +112,8 @@ static void hdd_fips_cb(void *cookie,
response);
}
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -175,11 +175,11 @@ static int __hdd_fips_test(struct net_device *dev,
int ret;
QDF_STATUS qdf_status;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct hdd_fips_context *context;
struct fips_params *fips_request;
struct wmi_host_fips_event_param *fips_response;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*context),
.timeout_ms = WLAN_WAIT_TIME_FIPS,
.dealloc = hdd_fips_context_dealloc,
@ -199,12 +199,12 @@ static int __hdd_fips_test(struct net_device *dev,
if (ret)
return ret;
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
context = hdd_request_priv(request);
context = osif_request_priv(request);
fips_request = &context->request;
fips_request->key = &user_request->key[0];
fips_request->key_len = user_request->key_len;
@ -214,7 +214,7 @@ static int __hdd_fips_test(struct net_device *dev,
fips_request->op = user_request->operation;
fips_request->pdev_id = WMI_PDEV_ID_1ST;
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
qdf_status = sme_fips_request(hdd_ctx->mac_handle, &context->request,
hdd_fips_cb, cookie);
@ -224,7 +224,7 @@ static int __hdd_fips_test(struct net_device *dev,
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("Target response timed out");
goto cleanup;
@ -269,7 +269,7 @@ static int __hdd_fips_test(struct net_device *dev,
ret = -EFAULT;
cleanup:
hdd_request_put(request);
osif_request_put(request);
hdd_exit();
return ret;

50
core/hdd/src/wlan_hdd_ioctl.c
View File

@ -25,7 +25,7 @@
#include "wlan_hdd_ioctl.h"
#include "wlan_hdd_power.h"
#include "wlan_hdd_regulatory.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "wlan_hdd_driver_ops.h"
#include "wlan_policy_mgr_api.h"
#include "wlan_hdd_hostapd.h"
@ -155,18 +155,18 @@ struct tsm_priv {
static void hdd_get_tsm_stats_cb(tAniTrafStrmMetrics tsm_metrics,
const uint32_t staId, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct tsm_priv *priv;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->tsm_metrics = tsm_metrics;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -180,9 +180,9 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct tsm_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -195,12 +195,12 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
hdd_ctx = WLAN_HDD_GET_CTX(adapter);
hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_tsm_stats(hdd_ctx->mac_handle, hdd_get_tsm_stats_cb,
hdd_sta_ctx->conn_info.staId[0],
@ -212,17 +212,17 @@ static int hdd_get_tsm_stats(struct hdd_adapter *adapter,
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving tsm statistics");
goto cleanup;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
*tsm_metrics = priv->tsm_metrics;
cleanup:
hdd_request_put(request);
osif_request_put(request);
return ret;
}
@ -2482,19 +2482,19 @@ sme_config_free:
static void hdd_get_link_status_cb(uint8_t status, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct link_status_priv *priv;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->link_status = status;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -2515,9 +2515,9 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct link_status_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_LINK_STATUS,
};
@ -2545,12 +2545,12 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
return 0;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return 0;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_link_status(adapter->hdd_ctx->mac_handle,
hdd_get_link_status_cb,
@ -2560,13 +2560,13 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
/* return a cached value */
} else {
/* request is sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving link status");
/* return a cached value */
} else {
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->link_status = priv->link_status;
}
}
@ -2576,7 +2576,7 @@ static int wlan_hdd_get_link_status(struct hdd_adapter *adapter)
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
/* either callback updated adapter stats or it has cached data */
return adapter->link_status;

14
core/hdd/src/wlan_hdd_main.c
View File

@ -45,7 +45,6 @@
#include "wlan_hdd_power.h"
#include "wlan_hdd_stats.h"
#include "wlan_hdd_scan.h"
#include "wlan_hdd_request_manager.h"
#include <wlan_osif_request_manager.h>
#ifdef CONFIG_LEAK_DETECTION
#include "qdf_debug_domain.h"
@ -6905,7 +6904,6 @@ static void hdd_wlan_exit(struct hdd_context *hdd_ctx)
qdf_spinlock_destroy(&hdd_ctx->sta_update_info_lock);
qdf_spinlock_destroy(&hdd_ctx->connection_status_lock);
hdd_request_manager_deinit();
osif_request_manager_deinit();
hdd_close_all_adapters(hdd_ctx, false);
@ -10912,7 +10910,6 @@ int hdd_wlan_startup(struct device *dev)
#endif
osif_request_manager_init();
hdd_request_manager_init();
qdf_atomic_init(&hdd_ctx->con_mode_flag);
hdd_driver_memdump_init();
@ -11029,7 +11026,6 @@ err_stop_modules:
err_memdump_deinit:
hdd_driver_memdump_deinit();
hdd_request_manager_deinit();
osif_request_manager_deinit();
hdd_exit_netlink_services(hdd_ctx);
@ -11076,7 +11072,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
struct hdd_context *hdd_ctx = (struct hdd_context *)data;
int status;
struct hdd_adapter *adapter = NULL;
struct hdd_request *request = NULL;
struct osif_request *request = NULL;
hdd_enter();
@ -11089,7 +11085,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
if (status != 0)
return;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("obselete request");
return;
@ -11098,7 +11094,7 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
adapter = hdd_get_adapter_by_vdev(hdd_ctx, rsp->vdev_id);
if ((NULL == adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic)) {
hdd_err("Invalid adapter or adapter has invalid magic");
hdd_request_put(request);
osif_request_put(request);
return;
}
@ -11126,8 +11122,8 @@ void hdd_get_nud_stats_cb(void *data, struct rsp_stats *rsp, void *context)
rsp->icmpv4_rsp_recvd;
}
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}

114
core/hdd/src/wlan_hdd_ocb.c
View File

@ -27,7 +27,7 @@
#include "wlan_hdd_main.h"
#include "wlan_hdd_ocb.h"
#include "wlan_hdd_trace.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "wlan_tgt_def_config.h"
#include "sch_api.h"
#include "wma_api.h"
@ -352,16 +352,16 @@ struct hdd_ocb_set_config_priv {
*/
static void hdd_ocb_set_config_callback(void *context_ptr, void *response_ptr)
{
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_ocb_set_config_priv *priv;
struct ocb_set_config_response *response = response_ptr;
hdd_request = hdd_request_get(context_ptr);
if (!hdd_request) {
request = osif_request_get(context_ptr);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
if (response && response->status)
hdd_warn("Operation failed: %d", response->status);
@ -371,8 +371,8 @@ static void hdd_ocb_set_config_callback(void *context_ptr, void *response_ptr)
else
priv->status = -EINVAL;
hdd_request_complete(hdd_request);
hdd_request_put(hdd_request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -388,9 +388,9 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
int rc;
QDF_STATUS status;
void *cookie;
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_ocb_set_config_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
};
@ -400,12 +400,12 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
return -EINVAL;
}
hdd_request = hdd_request_alloc(&params);
if (!hdd_request) {
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(hdd_request);
cookie = osif_request_cookie(request);
hdd_debug("Disabling queues");
wlan_hdd_netif_queue_control(adapter,
@ -422,13 +422,13 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
}
/* Wait for the function to complete. */
rc = hdd_request_wait_for_response(hdd_request);
rc = osif_request_wait_for_response(request);
if (rc) {
hdd_err("Operation timed out");
goto end;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
rc = priv->status;
if (rc) {
hdd_err("Operation failed: %d", rc);
@ -446,7 +446,7 @@ static int hdd_ocb_set_config_req(struct hdd_adapter *adapter,
/* fall through */
end:
hdd_request_put(hdd_request);
osif_request_put(request);
return rc;
}
@ -1298,25 +1298,25 @@ struct hdd_ocb_get_tsf_timer_priv {
static void hdd_ocb_get_tsf_timer_callback(void *context_ptr,
void *response_ptr)
{
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_ocb_get_tsf_timer_priv *priv;
struct ocb_get_tsf_timer_response *response = response_ptr;
hdd_request = hdd_request_get(context_ptr);
if (!hdd_request) {
request = osif_request_get(context_ptr);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
if (response) {
priv->response = *response;
priv->status = 0;
} else {
priv->status = -EINVAL;
}
hdd_request_complete(hdd_request);
hdd_request_put(hdd_request);
osif_request_complete(request);
osif_request_put(request);
}
static int
@ -1384,9 +1384,9 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
struct ocb_get_tsf_timer_param request = {0};
QDF_STATUS status;
void *cookie;
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_ocb_get_tsf_timer_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
};
@ -1407,12 +1407,12 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
return -EINVAL;
}
hdd_request = hdd_request_alloc(&params);
if (!hdd_request) {
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(hdd_request);
cookie = osif_request_cookie(request);
request.vdev_id = adapter->session_id;
status = ucfg_ocb_get_tsf_timer(adapter->hdd_vdev, &request,
@ -1424,13 +1424,13 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
goto end;
}
rc = hdd_request_wait_for_response(hdd_request);
rc = osif_request_wait_for_response(request);
if (rc) {
hdd_err("Operation timed out");
goto end;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
rc = priv->status;
if (rc) {
hdd_err("Operation failed: %d", rc);
@ -1450,7 +1450,7 @@ __wlan_hdd_cfg80211_ocb_get_tsf_timer(struct wiphy *wiphy,
/* fall through */
end:
hdd_request_put(hdd_request);
osif_request_put(request);
return rc;
}
@ -1499,18 +1499,18 @@ static void hdd_dcc_get_stats_dealloc(void *context_ptr)
*/
static void hdd_dcc_get_stats_callback(void *context_ptr, void *response_ptr)
{
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_dcc_stats_priv *priv;
struct ocb_dcc_get_stats_response *response = response_ptr;
struct ocb_dcc_get_stats_response *hdd_resp;
hdd_request = hdd_request_get(context_ptr);
if (!hdd_request) {
request = osif_request_get(context_ptr);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
if (!response) {
priv->status = -EINVAL;
goto end;
@ -1532,8 +1532,8 @@ static void hdd_dcc_get_stats_callback(void *context_ptr, void *response_ptr)
priv->status = 0;
end:
hdd_request_complete(hdd_request);
hdd_request_put(hdd_request);
osif_request_complete(request);
osif_request_put(request);
}
static int
@ -1606,9 +1606,9 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
struct ocb_dcc_get_stats_param request = {0};
QDF_STATUS status;
void *cookie;
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_dcc_stats_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
.dealloc = hdd_dcc_get_stats_dealloc,
@ -1652,12 +1652,12 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
request_array = nla_data(
tb[QCA_WLAN_VENDOR_ATTR_DCC_GET_STATS_REQUEST_ARRAY]);
hdd_request = hdd_request_alloc(&params);
if (!hdd_request) {
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(hdd_request);
cookie = osif_request_cookie(request);
request.vdev_id = adapter->session_id;
request.channel_count = channel_count;
@ -1674,13 +1674,13 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
}
/* Wait for the function to complete. */
rc = hdd_request_wait_for_response(hdd_request);
rc = osif_request_wait_for_response(request);
if (rc) {
hdd_err("Operation timed out");
goto end;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
rc = priv->status;
if (rc) {
hdd_err("Operation failed: %d", rc);
@ -1696,7 +1696,7 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
/* fall through */
end:
hdd_request_put(hdd_request);
osif_request_put(request);
return rc;
}
@ -1820,23 +1820,23 @@ struct hdd_dcc_update_ndl_priv {
*/
static void hdd_dcc_update_ndl_callback(void *context_ptr, void *response_ptr)
{
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_dcc_update_ndl_priv *priv;
struct ocb_dcc_update_ndl_response *response = response_ptr;
hdd_request = hdd_request_get(context_ptr);
if (!hdd_request) {
request = osif_request_get(context_ptr);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
if (response && (0 == response->status)) {
priv->status = 0;
} else {
priv->status = -EINVAL;
}
hdd_request_complete(hdd_request);
hdd_request_put(hdd_request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -1866,9 +1866,9 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
int rc;
QDF_STATUS status;
void *cookie;
struct hdd_request *hdd_request;
struct osif_request *request;
struct hdd_dcc_update_ndl_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_OCB_CMD,
};
@ -1916,12 +1916,12 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
ndl_active_state_array = nla_data(
tb[QCA_WLAN_VENDOR_ATTR_DCC_UPDATE_NDL_ACTIVE_STATE_ARRAY]);
hdd_request = hdd_request_alloc(&params);
if (!hdd_request) {
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(hdd_request);
cookie = osif_request_cookie(request);
/* Copy the parameters to the request structure. */
request.vdev_id = adapter->session_id;
@ -1941,13 +1941,13 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
}
/* Wait for the function to complete. */
rc = hdd_request_wait_for_response(hdd_request);
rc = osif_request_wait_for_response(request);
if (rc) {
hdd_err("Operation timed out");
goto end;
}
priv = hdd_request_priv(hdd_request);
priv = osif_request_priv(request);
rc = priv->status;
if (rc) {
hdd_err("Operation failed: %d", rc);
@ -1956,7 +1956,7 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
/* fall through */
end:
hdd_request_put(hdd_request);
osif_request_put(request);
return rc;
}

195
core/hdd/src/wlan_hdd_request_manager.c
View File

@ -1,195 +0,0 @@
/*
* Copyright (c) 2017 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 copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <linux/kernel.h>
#include "wlan_hdd_request_manager.h"
#include "wlan_hdd_main.h"
#include "qdf_list.h"
#include "qdf_event.h"
#include "qdf_mem.h"
/* arbitrary value */
#define MAX_NUM_REQUESTS 20
static bool is_initialized;
static qdf_list_t requests;
static qdf_spinlock_t spinlock;
static void *cookie;
struct hdd_request {
qdf_list_node_t node;
void *cookie;
uint32_t reference_count;
struct hdd_request_params params;
qdf_event_t completed;
};
/* must be called with spinlock held */
static void hdd_request_unlink(struct hdd_request *request)
{
qdf_list_remove_node(&requests, &request->node);
}
static void hdd_request_destroy(struct hdd_request *request)
{
struct hdd_request_params *params;
params = &request->params;
if (params->dealloc) {
void *priv = hdd_request_priv(request);
params->dealloc(priv);
}
qdf_event_destroy(&request->completed);
qdf_mem_free(request);
}
/* must be called with spinlock held */
static struct hdd_request *hdd_request_find(void *cookie)
{
QDF_STATUS status;
struct hdd_request *request;
qdf_list_node_t *node;
status = qdf_list_peek_front(&requests, &node);
while (QDF_IS_STATUS_SUCCESS(status)) {
request = qdf_container_of(node, struct hdd_request, node);
if (request->cookie == cookie)
return request;
status = qdf_list_peek_next(&requests, node, &node);
}
return NULL;
}
struct hdd_request *hdd_request_alloc(const struct hdd_request_params *params)
{
size_t length;
struct hdd_request *request;
if (!is_initialized) {
hdd_err("invoked when not initialized from %pS",
(void *)_RET_IP_);
return NULL;
}
length = sizeof(*request) + params->priv_size;
request = qdf_mem_malloc(length);
if (!request) {
hdd_err("allocation failed for %pS", (void *)_RET_IP_);
return NULL;
}
request->reference_count = 1;
request->params = *params;
qdf_event_create(&request->completed);
qdf_spin_lock_bh(&spinlock);
request->cookie = cookie++;
qdf_list_insert_back(&requests, &request->node);
qdf_spin_unlock_bh(&spinlock);
hdd_debug("request %pK, cookie %pK, caller %pS",
request, request->cookie, (void *)_RET_IP_);
return request;
}
void *hdd_request_priv(struct hdd_request *request)
{
/* private data area immediately follows the struct hdd_request */
return request + 1;
}
void *hdd_request_cookie(struct hdd_request *request)
{
return request->cookie;
}
struct hdd_request *hdd_request_get(void *cookie)
{
struct hdd_request *request;
if (!is_initialized) {
hdd_err("invoked when not initialized from %pS",
(void *)_RET_IP_);
return NULL;
}
qdf_spin_lock_bh(&spinlock);
request = hdd_request_find(cookie);
if (request)
request->reference_count++;
qdf_spin_unlock_bh(&spinlock);
hdd_debug("cookie %pK, request %pK, caller %pS",
cookie, request, (void *)_RET_IP_);
return request;
}
void hdd_request_put(struct hdd_request *request)
{
bool unlinked = false;
hdd_debug("request %pK, cookie %pK, caller %pS",
request, request->cookie, (void *)_RET_IP_);
qdf_spin_lock_bh(&spinlock);
request->reference_count--;
if (0 == request->reference_count) {
hdd_request_unlink(request);
unlinked = true;
}
qdf_spin_unlock_bh(&spinlock);
if (unlinked)
hdd_request_destroy(request);
}
int hdd_request_wait_for_response(struct hdd_request *request)
{
QDF_STATUS status;
status = qdf_wait_for_event_completion(&request->completed,
request->params.timeout_ms);
return qdf_status_to_os_return(status);
}
void hdd_request_complete(struct hdd_request *request)
{
(void) qdf_event_set(&request->completed);
}
void hdd_request_manager_init(void)
{
hdd_debug("%pS", (void *)_RET_IP_);
if (is_initialized)
return;
qdf_list_create(&requests, MAX_NUM_REQUESTS);
qdf_spinlock_create(&spinlock);
is_initialized = true;
}
/*
* hdd_request_manager_deinit implementation note:
* It is intentional that we do not destroy the list or the spinlock.
* This allows threads to still access the infrastructure even when it
* has been deinitialized. Since neither lists nor spinlocks consume
* resources this does not result in a resource leak.
*/
void hdd_request_manager_deinit(void)
{
hdd_debug("%pS", (void *)_RET_IP_);
is_initialized = false;
}

220
core/hdd/src/wlan_hdd_request_manager.h
View File

@ -1,220 +0,0 @@
/*
* Copyright (c) 2017 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 copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef __WLAN_HDD_REQUEST_MANAGER_H__
#define __WLAN_HDD_REQUEST_MANAGER_H__
/**
* DOC: WLAN HDD REQUEST MANAGER
*
* Many operations within the wlan driver occur in an asynchronous
* manner. Requests are received by HDD via one of the kernel
* interfaces (ioctl, nl80211, virtual file system, etc.). The
* requests are translated to an internal format and are then passed
* to lower layers, usually via SME, for processing. For requests
* which require a response, that response comes up from the lower
* layers in a separate thread of execution, ultimately resulting in a
* call to a callback function that was provided by HDD as part of the
* initial request. So a mechanism is needed to synchronize the
* request and response. This framework provides that mechanism.
*
* Once the framework has been initialized, the typical sequence of
* events is as follows:
*
* Request Thread:
* 1. Create a &struct hdd_request_params which describes the request.
* 2. Call hdd_request_alloc() to allocate a &struct hdd_request.
* 3. Call hdd_request_priv() to get a pointer to the private data.
* 4. Place any information which must be shared with the Response
* Callback in the private data area.
* 5. Call hdd_request_cookie() to get the unique cookie assigned
* to the request.
* 6. Call the underlying request handling API, passing the cookie
* as the callback's private context.
* 7. Call hdd_request_wait_for_response() to wait for the response
* (or for the request to time out).
* 8. Use the return status to see if the request was successful. If
* it was, retrieve any response information from the private
* structure and prepare a response for userspace.
* 9. Call hdd_request_put() to relinquish access to the request.
* 10. Return status to the caller.
*
* Response Callback:
* 1. Call hdd_request_get() with the provided cookie to see if the
* request structure is still valid. If it returns %NULL then
* return since this means the request thread has already timed
* out.
* 2. Call hdd_request_priv() to get access to the private data area.
* 3. Write response data into the private data area.
* 4. Call hdd_request_complete() to indicate that the response is
* ready to be processed by the request thread.
* 5. Call hdd_request_put() to relinquish the callback function's
* reference to the request.
*/
/* this is opaque to clients */
struct hdd_request;
/**
* typedef hdd_request_dealloc - Private data deallocation function
*/
typedef void (*hdd_request_dealloc)(void *priv);
/**
* struct hdd_request_params - HDD request parameters
* @priv_size: Size of the private data area required to pass
* information between the request thread and the response callback.
* @timeout_ms: The amount of time to wait for a response in milliseconds.
* @dealloc: Function to be called when the request is destroyed to
* deallocate any allocations made in the private area of the
* request struct. Can be %NULL if no private allocations are
* made.
*/
struct hdd_request_params {
uint32_t priv_size;
uint32_t timeout_ms;
hdd_request_dealloc dealloc;
};
/**
* hdd_request_alloc() - Allocate a request struct
* @params: parameter block that specifies the attributes of the
* request
*
* This function will attempt to allocate a &struct hdd_request with
* the specified @params. If successful, the caller can then use
* request struct to make an asynchronous request. Once the request is
* no longer needed, the reference should be relinquished via a call
* to hdd_request_put().
*
* Return: A pointer to an allocated &struct hdd_request (which also
* contains room for the private buffer) if the allocation is
* successful, %NULL if the allocation fails.
*/
struct hdd_request *hdd_request_alloc(const struct hdd_request_params *params);
/**
* hdd_request_priv() - Get pointer to request private data
* @request: The request struct that contains the private data
*
* This function will return a pointer to the private data area that
* is part of the request struct. The caller must already have a valid
* reference to @request from either hdd_request_alloc() or
* hdd_request_get().
*
* Returns: pointer to the private data area. Note that this pointer
* will always be an offset from the input @request pointer and hence
* this function will never return %NULL.
*/
void *hdd_request_priv(struct hdd_request *request);
/**
* hdd_request_cookie() - Get cookie of a request
* @request: The request struct associated with the request
*
* This function will return the unique cookie that has been assigned
* to the request. This cookie can subsequently be passed to
* hdd_request_get() to retrieve the request.
*
* Note that the cookie is defined as a void pointer as it is intended
* to be passed as an opaque context pointer from HDD to underlying
* layers when making a request, and subsequently passed back to HDD
* as an opaque pointer in an asynchronous callback.
*
* Returns: The cookie assigned to the request.
*/
void *hdd_request_cookie(struct hdd_request *request);
/**
* hdd_request_get() - Get a reference to a request struct
* @cookie: The cookie of the request struct that needs to be
* referenced
*
* This function will use the cookie to determine if the associated
* request struct is valid, and if so, will increment the reference
* count of the struct. This means the caller is guaranteed that the
* request struct is valid and the underlying private data can be
* dereferenced.
*
* Returns: The pointer to the request struct associated with @cookie
* if the request is still valid, %NULL if the underlying request
* struct is no longer valid.
*/
struct hdd_request *hdd_request_get(void *cookie);
/**
* hdd_request_put() - Release a reference to a request struct
* @request: The request struct that no longer needs to be referenced
*
* This function will decrement the reference count of the struct, and
* will clean up the request if this is the last reference. The caller
* must already have a valid reference to @request, either from
* hdd_request_alloc() or hdd_request_get().
*
* Returns: Nothing
*/
void hdd_request_put(struct hdd_request *request);
/**
* hdd_request_wait_for_response() - Wait for a response
* @request: The request struct associated with the request
*
* This function will wait until either a response is received and
* communicated via hdd_request_complete(), or until the request
* timeout period expires.
*
* Returns: 0 if a response was received, -ETIMEDOUT if the response
* timed out.
*/
int hdd_request_wait_for_response(struct hdd_request *request);
/**
* hdd_request_complete() - Complete a request
* @request: The request struct associated with the request
*
* This function is used to indicate that a response has been received
* and that any information required by the request thread has been
* copied into the private data area of the request struct. This will
* unblock any hdd_request_wait_for_response() that is pending on this
* @request.
*
* Returns: Nothing
*/
void hdd_request_complete(struct hdd_request *request);
/**
* hdd_request_manager_init() - Initialize the HDD Request Manager
*
* This function must be called during system initialization to
* initialize the HDD Request Manager.
*
* Returns: Nothing
*/
void hdd_request_manager_init(void);
/**
* hdd_request_manager_deinit() - Deinitialize the HDD Request Manager
*
* This function must be called during system shutdown to deinitialize
* the HDD Request Manager.
*
* Returns: Nothing
*/
void hdd_request_manager_deinit(void);
#endif /* __WLAN_HDD_REQUEST_MANAGER_H__ */

218
core/hdd/src/wlan_hdd_stats.c
View File

@ -32,7 +32,7 @@
#include <qca_vendor.h>
#include "wma_api.h"
#include "wlan_hdd_hostapd.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "wlan_hdd_debugfs_llstat.h"
#include "wlan_reg_services_api.h"
#include <wlan_cfg80211_mc_cp_stats.h>
@ -4851,7 +4851,7 @@ static bool hdd_is_rcpi_applicable(struct hdd_adapter *adapter,
static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
int32_t rcpi, QDF_STATUS status)
{
struct hdd_request *request;
struct osif_request *request;
struct rcpi_info *priv;
if (!context) {
@ -4859,13 +4859,13 @@ static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
return;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete RCPI request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->mac_addr = mac_addr;
if (!QDF_IS_STATUS_SUCCESS(status)) {
@ -4875,8 +4875,8 @@ static void wlan_hdd_get_rcpi_cb(void *context, struct qdf_mac_addr mac_addr,
priv->rcpi = rcpi;
}
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
/**
@ -4900,8 +4900,8 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
struct sme_rcpi_req *rcpi_req;
void *cookie;
struct rcpi_info *priv;
struct hdd_request *request;
static const struct hdd_request_params params = {
struct osif_request *request;
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_RCPI,
};
@ -4950,13 +4950,13 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
return -EINVAL;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
qdf_mem_free(rcpi_req);
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
rcpi_req->mac_addr = mac_addr;
rcpi_req->session_id = adapter->session_id;
@ -4972,7 +4972,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
}
/* request was sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving RCPI");
status = -EINVAL;
@ -4980,7 +4980,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
}
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->rcpi.mac_addr = priv->mac_addr;
adapter->rcpi.rcpi = priv->rcpi;
if (qdf_mem_cmp(&mac_addr, &priv->mac_addr, sizeof(mac_addr))) {
@ -4993,7 +4993,7 @@ static int __wlan_hdd_get_rcpi(struct hdd_adapter *adapter,
hdd_debug("RCPI = %d", *rcpi_value);
out:
qdf_mem_free(rcpi_req);
hdd_request_put(request);
osif_request_put(request);
hdd_exit();
return status;
@ -5086,19 +5086,19 @@ struct rssi_priv {
*/
static void hdd_get_rssi_cb(int8_t rssi, uint32_t sta_id, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct rssi_priv *priv;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->rssi = rssi;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
@ -5108,9 +5108,9 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct rssi_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5143,13 +5143,13 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
return QDF_STATUS_SUCCESS;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure, return cached RSSI");
*rssi_value = adapter->rssi;
return QDF_STATUS_SUCCESS;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_rssi(hdd_ctx->mac_handle, hdd_get_rssi_cb,
sta_ctx->conn_info.staId[0],
@ -5160,13 +5160,13 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
/* we'll returned a cached value below */
} else {
/* request was sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_warn("SME timed out while retrieving RSSI");
/* we'll returned a cached value below */
} else {
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->rssi = priv->rssi;
@ -5187,7 +5187,7 @@ QDF_STATUS wlan_hdd_get_rssi(struct hdd_adapter *adapter, int8_t *rssi_value)
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
*rssi_value = adapter->rssi;
hdd_debug("RSSI = %d", *rssi_value);
@ -5211,20 +5211,20 @@ struct snr_priv {
*/
static void hdd_get_snr_cb(int8_t snr, uint32_t sta_id, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct snr_priv *priv;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
/* propagate response back to requesting thread */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->snr = snr;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
@ -5234,9 +5234,9 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct snr_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5256,12 +5256,12 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_FAULT;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_snr(hdd_ctx->mac_handle, hdd_get_snr_cb,
sta_ctx->conn_info.staId[0],
@ -5271,13 +5271,13 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
/* we'll returned a cached value below */
} else {
/* request was sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving SNR");
/* we'll now returned a cached value below */
} else {
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->snr = priv->snr;
}
}
@ -5287,7 +5287,7 @@ QDF_STATUS wlan_hdd_get_snr(struct hdd_adapter *adapter, int8_t *snr)
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
*snr = adapter->snr;
hdd_exit();
@ -5301,7 +5301,7 @@ struct linkspeed_priv {
static void
hdd_get_link_speed_cb(tSirLinkSpeedInfo *linkspeed_info, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct linkspeed_priv *priv;
if (!linkspeed_info) {
@ -5309,16 +5309,16 @@ hdd_get_link_speed_cb(tSirLinkSpeedInfo *linkspeed_info, void *context)
return;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->linkspeed_info = *linkspeed_info;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
@ -5329,9 +5329,9 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
QDF_STATUS status;
void *cookie;
tSirLinkSpeedInfo *linkspeed_info;
struct hdd_request *request;
struct osif_request *request;
struct linkspeed_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5341,15 +5341,15 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
return -EINVAL;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
ret = -ENOMEM;
goto return_cached_value;
}
cookie = hdd_request_cookie(request);
priv = hdd_request_priv(request);
cookie = osif_request_cookie(request);
priv = osif_request_priv(request);
linkspeed_info = &priv->linkspeed_info;
qdf_copy_macaddr(&linkspeed_info->peer_macaddr, mac_address);
@ -5361,7 +5361,7 @@ int wlan_hdd_get_linkspeed_for_peermac(struct hdd_adapter *adapter,
ret = qdf_status_to_os_return(status);
goto cleanup;
}
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving link speed");
goto cleanup;
@ -5374,7 +5374,7 @@ cleanup:
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
return_cached_value:
*linkspeed = adapter->estimated_linkspeed;
@ -5437,7 +5437,7 @@ struct peer_rssi_priv {
static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct peer_rssi_priv *priv;
struct sir_peer_info *rssi_info;
uint8_t peer_num;
@ -5447,13 +5447,13 @@ static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
return;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
peer_num = sta_rssi->count;
rssi_info = sta_rssi->info;
@ -5469,8 +5469,8 @@ static void hdd_get_peer_rssi_cb(struct sir_peer_info_resp *sta_rssi,
peer_num * sizeof(*rssi_info));
priv->peer_sta_info.sta_num = peer_num;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
@ -5482,9 +5482,9 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
void *cookie;
int ret;
struct sir_peer_info_req rssi_req;
struct hdd_request *request;
struct osif_request *request;
struct peer_rssi_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5495,14 +5495,14 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
return -EFAULT;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
priv = hdd_request_priv(request);
cookie = osif_request_cookie(request);
priv = osif_request_priv(request);
qdf_mem_copy(&rssi_req.peer_macaddr, macaddress,
QDF_MAC_ADDR_SIZE);
@ -5515,7 +5515,7 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
hdd_err("Unable to retrieve statistics for rssi");
ret = -EFAULT;
} else {
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving rssi");
ret = -EFAULT;
@ -5525,7 +5525,7 @@ int wlan_hdd_get_peer_rssi(struct hdd_adapter *adapter,
}
}
hdd_request_put(request);
osif_request_put(request);
return ret;
}
@ -5545,7 +5545,7 @@ struct peer_info_priv {
static void wlan_hdd_get_peer_info_cb(struct sir_peer_info_ext_resp *sta_info,
void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct peer_info_priv *priv;
uint8_t sta_num;
@ -5567,21 +5567,21 @@ static void wlan_hdd_get_peer_info_cb(struct sir_peer_info_ext_resp *sta_info,
sta_num = sta_info->count;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->peer_sta_ext_info.sta_num = sta_num;
qdf_mem_copy(&priv->peer_sta_ext_info.info,
sta_info->info,
sta_num * sizeof(sta_info->info[0]));
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
@ -5592,9 +5592,9 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
void *cookie;
int ret;
struct sir_peer_info_ext_req peer_info_req;
struct hdd_request *request;
struct osif_request *request;
struct peer_info_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5604,14 +5604,14 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
return -EFAULT;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
priv = hdd_request_priv(request);
cookie = osif_request_cookie(request);
priv = osif_request_priv(request);
qdf_mem_copy(&peer_info_req.peer_macaddr, &macaddress,
QDF_MAC_ADDR_SIZE);
@ -5625,7 +5625,7 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
hdd_err("Unable to retrieve statistics for peer info");
ret = -EFAULT;
} else {
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving peer info");
ret = -EFAULT;
@ -5636,7 +5636,7 @@ int wlan_hdd_get_peer_info(struct hdd_adapter *adapter,
}
}
hdd_request_put(request);
osif_request_put(request);
return ret;
}
@ -5656,7 +5656,7 @@ struct class_a_stats {
*/
static void hdd_get_class_a_statistics_cb(void *stats, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct class_a_stats *priv;
tCsrGlobalClassAStatsInfo *returned_stats;
@ -5666,17 +5666,17 @@ static void hdd_get_class_a_statistics_cb(void *stats, void *context)
return;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
returned_stats = stats;
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->class_a_stats = *returned_stats;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -5686,9 +5686,9 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct class_a_stats *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5703,12 +5703,12 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
return QDF_STATUS_SUCCESS;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return QDF_STATUS_E_NOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
/* query only for Class A statistics (which include link speed) */
status = sme_get_statistics(adapter->hdd_ctx->mac_handle,
@ -5722,14 +5722,14 @@ QDF_STATUS wlan_hdd_get_class_astats(struct hdd_adapter *adapter)
}
/* request was sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_warn("SME timed out while retrieving Class A statistics");
goto return_cached_results;
}
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->hdd_stats.class_a_stat = priv->class_a_stats;
return_cached_results:
@ -5738,7 +5738,7 @@ return_cached_results:
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
return QDF_STATUS_SUCCESS;
}
@ -5827,7 +5827,7 @@ struct station_stats {
*/
static void hdd_get_station_statistics_cb(void *stats, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct station_stats *priv;
tCsrSummaryStatsInfo *summary_stats;
tCsrGlobalClassAStatsInfo *class_a_stats;
@ -5839,7 +5839,7 @@ static void hdd_get_station_statistics_cb(void *stats, void *context)
return;
}
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
@ -5849,15 +5849,15 @@ static void hdd_get_station_statistics_cb(void *stats, void *context)
class_a_stats = (tCsrGlobalClassAStatsInfo *) (summary_stats + 1);
per_chain_rssi_stats = (struct csr_per_chain_rssi_stats_info *)
(class_a_stats + 1);
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
/* copy over the stats. do so as a struct copy */
priv->summary_stats = *summary_stats;
priv->class_a_stats = *class_a_stats;
priv->per_chain_rssi_stats = *per_chain_rssi_stats;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
@ -5866,9 +5866,9 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
QDF_STATUS status;
int errno;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct station_stats *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5878,12 +5878,12 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
return 0;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
/* query only for Summary & Class A statistics */
status = sme_get_statistics(adapter->hdd_ctx->mac_handle,
@ -5901,14 +5901,14 @@ int wlan_hdd_get_station_stats(struct hdd_adapter *adapter)
}
/* request was sent -- wait for the response */
errno = hdd_request_wait_for_response(request);
errno = osif_request_wait_for_response(request);
if (errno) {
hdd_err("Failed to wait for statistics, errno %d", errno);
goto put_request;
}
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->hdd_stats.summary_stat = priv->summary_stats;
adapter->hdd_stats.class_a_stat = priv->class_a_stats;
adapter->hdd_stats.per_chain_rssi_stats = priv->per_chain_rssi_stats;
@ -5919,7 +5919,7 @@ put_request:
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
/* either callback updated adapter stats or it has cached data */
return 0;
@ -5943,21 +5943,21 @@ struct temperature_priv {
*/
static void hdd_get_temperature_cb(int temperature, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct temperature_priv *priv;
hdd_enter();
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
priv->temperature = temperature;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
hdd_exit();
}
@ -5966,9 +5966,9 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
QDF_STATUS status;
int ret;
void *cookie;
struct hdd_request *request;
struct osif_request *request;
struct temperature_priv *priv;
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
@ -5979,23 +5979,23 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
return -EPERM;
}
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_err("Request allocation failure");
return -ENOMEM;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_temperature(adapter->hdd_ctx->mac_handle, cookie,
hdd_get_temperature_cb);
if (QDF_STATUS_SUCCESS != status) {
hdd_err("Unable to retrieve temperature");
} else {
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("SME timed out while retrieving temperature");
} else {
/* update the adapter with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
if (priv->temperature)
adapter->temperature = priv->temperature;
}
@ -6006,7 +6006,7 @@ int wlan_hdd_get_temperature(struct hdd_adapter *adapter, int *temperature)
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
*temperature = adapter->temperature;
hdd_exit();

26
core/hdd/src/wlan_hdd_wext.c
View File

@ -87,7 +87,7 @@
#endif
#include "wlan_hdd_lro.h"
#include "cds_utils.h"
#include "wlan_hdd_request_manager.h"
#include "wlan_osif_request_manager.h"
#include "os_if_wifi_pos.h"
#include <cdp_txrx_stats.h>
#include <cds_api.h>
@ -8213,19 +8213,19 @@ struct hdd_statistics_priv {
*/
static void hdd_statistics_cb(void *stats, void *context)
{
struct hdd_request *request;
struct osif_request *request;
struct hdd_statistics_priv *priv;
tCsrSummaryStatsInfo *summary_stats;
tCsrGlobalClassAStatsInfo *class_a_stats;
tCsrGlobalClassDStatsInfo *class_d_stats;
request = hdd_request_get(context);
request = osif_request_get(context);
if (!request) {
hdd_err("Obsolete request");
return;
}
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
summary_stats = (tCsrSummaryStatsInfo *)stats;
priv->summary_stats = *summary_stats;
@ -8236,8 +8236,8 @@ static void hdd_statistics_cb(void *stats, void *context)
class_d_stats = (tCsrGlobalClassDStatsInfo *)(class_a_stats + 1);
priv->class_d_stats = *class_d_stats;
hdd_request_complete(request);
hdd_request_put(request);
osif_request_complete(request);
osif_request_put(request);
}
static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
@ -8245,23 +8245,23 @@ static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
int ret = 0;
void *cookie;
QDF_STATUS status;
struct hdd_request *request;
struct osif_request *request;
struct hdd_station_ctx *sta_ctx;
struct hdd_statistics_priv *priv;
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
static const struct hdd_request_params params = {
static const struct osif_request_params params = {
.priv_size = sizeof(*priv),
.timeout_ms = WLAN_WAIT_TIME_STATS,
};
sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
request = hdd_request_alloc(&params);
request = osif_request_alloc(&params);
if (!request) {
hdd_warn("request allocation failed");
return -EINVAL;
}
cookie = hdd_request_cookie(request);
cookie = osif_request_cookie(request);
status = sme_get_statistics(hdd_ctx->mac_handle, eCSR_HDD,
SME_SUMMARY_STATS |
SME_GLOBAL_CLASSA_STATS |
@ -8276,14 +8276,14 @@ static int hdd_get_wlan_stats(struct hdd_adapter *adapter)
}
/* request was sent -- wait for the response */
ret = hdd_request_wait_for_response(request);
ret = osif_request_wait_for_response(request);
if (ret) {
hdd_err("Failed to wait for statistics, errno %d", ret);
goto put_request;
}
/* update the adapter cache with the fresh results */
priv = hdd_request_priv(request);
priv = osif_request_priv(request);
adapter->hdd_stats.summary_stat = priv->summary_stats;
adapter->hdd_stats.class_a_stat = priv->class_a_stats;
adapter->hdd_stats.class_d_stat = priv->class_d_stats;
@ -8294,7 +8294,7 @@ put_request:
* received a response or we sent a request and timed out.
* regardless we are done with the request.
*/
hdd_request_put(request);
osif_request_put(request);
return ret;
}
#endif /* QCA_SUPPORT_CP_STATS */