Merge "wlan: Add support to build wearable targets for msm-4.9 kernel" into wlan-driver.lnx.1.0
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 2e3b606..eca0d14 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -1483,13 +1483,13 @@
* callback type to check fw mem dump request.Called from SVC
* context and update status in HDD.
*/
-typedef void (*hdd_fw_mem_dump_req_cb)(struct hdd_fw_mem_dump_req_ctx *);
+typedef void (*hdd_fw_mem_dump_req_cb)(void *context);
int memdump_init(void);
int memdump_deinit(void);
void wlan_hdd_fw_mem_dump_cb(void *,tAniFwrDumpRsp *);
int wlan_hdd_fw_mem_dump_req(hdd_context_t * pHddCtx);
-void wlan_hdd_fw_mem_dump_req_cb(struct hdd_fw_mem_dump_req_ctx*);
+void wlan_hdd_fw_mem_dump_req_cb(void *context);
#ifdef WLAN_FEATURE_LINK_LAYER_STATS
/**
* struct hdd_ll_stats_context - hdd link layer stats context
diff --git a/CORE/HDD/inc/wlan_hdd_wext.h b/CORE/HDD/inc/wlan_hdd_wext.h
index 1a58dc0..ec12057 100644
--- a/CORE/HDD/inc/wlan_hdd_wext.h
+++ b/CORE/HDD/inc/wlan_hdd_wext.h
@@ -343,6 +343,11 @@
v_U32_t chan;
}hdd_freq_chan_map_t;
+struct stats_class_a_ctx {
+ tCsrGlobalClassAStatsInfo class_a_stats;
+};
+
+
#define wlan_hdd_get_wps_ie_ptr(ie, ie_len) \
wlan_hdd_get_vendor_oui_ie_ptr(WPS_OUI_TYPE, WPS_OUI_TYPE_SIZE, ie, ie_len)
@@ -421,7 +426,7 @@
extern void *mem_alloc_copy_from_user_helper(const void *wrqu_data, size_t len);
void hdd_clearRoamProfileIe( hdd_adapter_t *pAdapter);
-void hdd_GetClassA_statisticsCB(void *pStats, void *pContext);
+void hdd_get_class_a_statistics_cb(void *stats, void *context);
VOS_STATUS wlan_hdd_check_ula_done(hdd_adapter_t *pAdapter);
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index 9856f96..463919a 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -81,6 +81,7 @@
#include "wniCfg.h"
#include <wlan_hdd_wowl.h>
#include "wlan_hdd_hostapd.h"
+#include "wlan_hdd_request_manager.h"
#ifdef FEATURE_WLAN_CH_AVOID
#include "wcnss_wlan.h"
@@ -4882,8 +4883,15 @@
static VOS_STATUS wlan_hdd_get_classAstats_for_station(hdd_adapter_t *pAdapter, u8 staid)
{
eHalStatus hstatus;
- long lrc;
- struct statsContext context;
+ int ret;
+ void *cookie;
+ struct hdd_request *request;
+ struct stats_class_a_ctx *priv;
+ static const struct hdd_request_params params = {
+ .priv_size = sizeof(*priv),
+ .timeout_ms = WLAN_WAIT_TIME_STATS,
+ };
+
if (NULL == pAdapter)
{
@@ -4891,17 +4899,21 @@
return VOS_STATUS_E_FAULT;
}
- init_completion(&context.completion);
- context.pAdapter = pAdapter;
- context.magic = STATS_CONTEXT_MAGIC;
+ request = hdd_request_alloc(¶ms);
+ if (!request) {
+ hddLog(VOS_TRACE_LEVEL_ERROR, FL("Request allocation failure"));
+ return VOS_STATUS_E_NOMEM;
+ }
+ cookie = hdd_request_cookie(request);
+
hstatus = sme_GetStatistics( WLAN_HDD_GET_HAL_CTX(pAdapter),
eCSR_HDD,
SME_GLOBAL_CLASSA_STATS,
- hdd_GetClassA_statisticsCB,
+ hdd_get_class_a_statistics_cb,
0, // not periodic
FALSE, //non-cached results
staid,
- &context);
+ cookie);
if (eHAL_STATUS_SUCCESS != hstatus)
{
hddLog(VOS_TRACE_LEVEL_ERROR,
@@ -4910,30 +4922,25 @@
}
else
{
- lrc = wait_for_completion_interruptible_timeout(&context.completion,
- msecs_to_jiffies(WLAN_WAIT_TIME_STATS));
- if (lrc <= 0)
+ ret = hdd_request_wait_for_response(request);
+ if (ret)
{
hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: SME %s while retrieving link speed",
- __func__, (0 == lrc) ? "timeout" : "interrupt");
+ FL("SME timeout while retrieving link speed"));
+ }
+ else
+ {
+ priv = hdd_request_priv(request);
+ pAdapter->hdd_stats.ClassA_stat = priv->class_a_stats;
}
}
- /* either we never sent a request, we sent a request and received a
- response or we sent a request and timed out. if we never sent a
- request or if we sent a request and got a response, we want to
- clear the magic out of paranoia. if we timed out there is a
- race condition such that the callback function could be
- executing at the same time we are. of primary concern is if the
- callback function had already verified the "magic" but had not
- yet set the completion variable when a timeout occurred. we
- serialize these activities by invalidating the magic while
- holding a shared spinlock which will cause us to block if the
- callback is currently executing */
- spin_lock(&hdd_context_lock);
- context.magic = 0;
- spin_unlock(&hdd_context_lock);
+ /*
+ * either we never sent a request, we sent a request and received a
+ * response or we sent a request and timed out. Regardless we are
+ * done with the request.
+ */
+ hdd_request_put(request);
return VOS_STATUS_SUCCESS;
}
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index b3afa6f..62c5f4c 100644
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -15772,6 +15772,10 @@
read: memdump_read
};
+struct fw_mem_dump_priv {
+ uint32_t status;
+};
+
/*
* wlan_hdd_fw_mem_dump_cb : callback for Fw mem dump request
* To be passed by HDD to WDA and called upon receiving of response
@@ -15780,34 +15784,42 @@
* @dump_rsp : dump response from HAL
* Returns none
*/
-void wlan_hdd_fw_mem_dump_cb(void *fwMemDumpReqContext,
+void wlan_hdd_fw_mem_dump_cb(void *context,
tAniFwrDumpRsp *dump_rsp)
{
- struct hdd_fw_mem_dump_req_ctx *pHddFwMemDumpCtx = (struct hdd_fw_mem_dump_req_ctx *)fwMemDumpReqContext;
+ struct hdd_request *request;
+ struct fw_mem_dump_priv *priv;
- ENTER();
- spin_lock(&hdd_context_lock);
- if(!pHddFwMemDumpCtx || (FW_MEM_DUMP_MAGIC != pHddFwMemDumpCtx->magic)) {
- spin_unlock(&hdd_context_lock);
- return;
- }
- /* report the status to requesting function and free mem.*/
- if (dump_rsp->dump_status != eHAL_STATUS_SUCCESS) {
- hddLog(LOGE, FL("fw dump request declined by fwr"));
- //set the request completion variable
- complete(&(pHddFwMemDumpCtx->req_completion));
- //Free the allocated fwr dump
- wlan_free_fwr_mem_dump_buffer();
- wlan_set_fwr_mem_dump_state(FW_MEM_DUMP_IDLE);
- }
- else {
- hddLog(LOG1, FL("fw dump request accepted by fwr"));
- /* register the HDD callback which will be called by SVC */
- wlan_set_svc_fw_mem_dump_req_cb((void*)wlan_hdd_fw_mem_dump_req_cb,(void*)pHddFwMemDumpCtx);
- }
- spin_unlock(&hdd_context_lock);
- EXIT();
+ request = hdd_request_get(context);
+ if (!request) {
+ hddLog(VOS_TRACE_LEVEL_ERROR, FL("Obsolete request"));
+ return;
+ }
+ ENTER();
+
+ priv = hdd_request_priv(request);
+ priv->status = dump_rsp->dump_status;
+
+ /* report the status to requesting function and free mem.*/
+ if (dump_rsp->dump_status != eHAL_STATUS_SUCCESS) {
+ hddLog(LOGE, FL("fw dump request declined by fwr"));
+ //set the request completion variable
+ hdd_request_complete(request);
+ //Free the allocated fwr dump
+ wlan_free_fwr_mem_dump_buffer();
+ wlan_set_fwr_mem_dump_state(FW_MEM_DUMP_IDLE);
+ } else {
+ hddLog(LOG1, FL("fw dump request accepted by fwr"));
+ /* register the HDD callback which will be called by SVC */
+ wlan_set_svc_fw_mem_dump_req_cb(
+ (void*)wlan_hdd_fw_mem_dump_req_cb,
+ context);
+ }
+
+ hdd_request_put(request);
+
+ EXIT();
}
/**
@@ -15942,9 +15954,16 @@
int wlan_hdd_fw_mem_dump_req(hdd_context_t * pHddCtx)
{
tAniFwrDumpReq fw_mem_dump_req={0};
- struct hdd_fw_mem_dump_req_ctx fw_mem_dump_ctx;
eHalStatus status = eHAL_STATUS_FAILURE;
- int ret=0, result;
+ int ret=0, dump_status;
+ void *cookie;
+ struct hdd_request *request;
+ struct fw_mem_dump_priv *priv;
+ static const struct hdd_request_params params = {
+ .priv_size = sizeof(*priv),
+ .timeout_ms = FW_MEM_DUMP_TIMEOUT_MS,
+ };
+
ENTER();
/*Check whether a dump request is already going on
@@ -15964,12 +15983,16 @@
hddLog(LOGE, FL("Fwr mem Allocation failed"));
return -ENOMEM;
}
- init_completion(&fw_mem_dump_ctx.req_completion);
- fw_mem_dump_ctx.magic = FW_MEM_DUMP_MAGIC;
- fw_mem_dump_ctx.status = false;
+
+ request = hdd_request_alloc(¶ms);
+ if (!request) {
+ hddLog(VOS_TRACE_LEVEL_ERROR, FL("Request allocation failure"));
+ return VOS_STATUS_E_NOMEM;
+ }
+ cookie = hdd_request_cookie(request);
fw_mem_dump_req.fwMemDumpReqCallback = wlan_hdd_fw_mem_dump_cb;
- fw_mem_dump_req.fwMemDumpReqContext = &fw_mem_dump_ctx;
+ fw_mem_dump_req.fwMemDumpReqContext = cookie;
status = sme_FwMemDumpReq(pHddCtx->hHal, &fw_mem_dump_req);
if(eHAL_STATUS_SUCCESS != status)
{
@@ -15980,21 +16003,20 @@
goto cleanup;
}
/*wait for fw mem dump completion to send event to userspace*/
- result =
- wait_for_completion_timeout(&fw_mem_dump_ctx.req_completion,
- msecs_to_jiffies(FW_MEM_DUMP_TIMEOUT_MS));
- if (0 >= result )
+ ret = hdd_request_wait_for_response(request);
+ if (ret)
{
hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: fw_mem_dump_req timeout %d ", __func__,result);
+ "%s: fw_mem_dump_req timeout %d ", __func__,ret);
ret = -ETIMEDOUT;
+ }else {
+ priv = hdd_request_priv(request);
+ dump_status = priv->status;
}
cleanup:
- spin_lock(&hdd_context_lock);
- fw_mem_dump_ctx.magic = 0;
- if(!ret && !fw_mem_dump_ctx.status)
+ hdd_request_put(request);
+ if(!ret && !dump_status)
ret = -EFAULT;
- spin_unlock(&hdd_context_lock);
EXIT();
return ret;
@@ -16003,27 +16025,22 @@
/**
* HDD callback which will be called by SVC to indicate mem dump completion.
*/
-void wlan_hdd_fw_mem_dump_req_cb(struct hdd_fw_mem_dump_req_ctx* pHddFwMemDumpCtx)
+void wlan_hdd_fw_mem_dump_req_cb(void *context)
{
- if (!pHddFwMemDumpCtx) {
- hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: HDD context not valid ", __func__);
- return;
- }
- spin_lock(&hdd_context_lock);
- /* check the req magic and set status */
- if (pHddFwMemDumpCtx->magic == FW_MEM_DUMP_MAGIC)
- {
- pHddFwMemDumpCtx->status = true;
- //signal the completion
- complete(&(pHddFwMemDumpCtx->req_completion));
- }
- else
- {
- hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: fw mem dump request possible timeout ", __func__);
- }
- spin_unlock(&hdd_context_lock);
+ struct hdd_request *request;
+ struct fw_mem_dump_priv *priv;
+
+ request = hdd_request_get(context);
+ if (!request) {
+ hddLog(VOS_TRACE_LEVEL_ERROR, FL("Obsolete request"));
+ return;
+ }
+
+ priv = hdd_request_priv(request);
+ priv->status = true;
+
+ hdd_request_complete(request);
+ hdd_request_put(request);
}
void hdd_initialize_adapter_common(hdd_adapter_t *pAdapter)
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 5c5e7d8..2fd9c3b 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -3244,71 +3244,6 @@
wireless_send_event(pAdapter->dev, IWEVCUSTOM, &wrqu, tx_fail);
}
-void hdd_GetClassA_statisticsCB(void *pStats, void *pContext)
-{
- struct statsContext *pStatsContext;
- tCsrGlobalClassAStatsInfo *pClassAStats;
- hdd_adapter_t *pAdapter;
-
- if (ioctl_debug)
- {
- pr_info("%s: pStats [%pK] pContext [%pK]\n",
- __func__, pStats, pContext);
- }
-
- if ((NULL == pStats) || (NULL == pContext))
- {
- hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: Bad param, pStats [%pK] pContext [%pK]",
- __func__, pStats, pContext);
- return;
- }
-
- pClassAStats = pStats;
- pStatsContext = pContext;
- pAdapter = pStatsContext->pAdapter;
-
- /* there is a race condition that exists between this callback
- function and the caller since the caller could time out either
- before or while this code is executing. we use a spinlock to
- serialize these actions */
- spin_lock(&hdd_context_lock);
-
- if ((NULL == pAdapter) || (STATS_CONTEXT_MAGIC != pStatsContext->magic))
- {
- /* the caller presumably timed out so there is nothing we can do */
- spin_unlock(&hdd_context_lock);
- hddLog(VOS_TRACE_LEVEL_WARN,
- "%s: Invalid context, pAdapter [%pK] magic [%08x]",
- __func__, pAdapter, pStatsContext->magic);
- if (ioctl_debug)
- {
- pr_info("%s: Invalid context, pAdapter [%pK] magic [%08x]\n",
- __func__, pAdapter, pStatsContext->magic);
- }
- return;
- }
-
- /* context is valid so caller is still waiting */
-
- /* paranoia: invalidate the magic */
- pStatsContext->magic = 0;
-
- /* copy over the stats. do so as a struct copy */
- pAdapter->hdd_stats.ClassA_stat = *pClassAStats;
-
- /* notify the caller */
- complete(&pStatsContext->completion);
-
- /* serialization is complete */
- spin_unlock(&hdd_context_lock);
-
-}
-
-struct stats_class_a_ctx {
- tCsrGlobalClassAStatsInfo class_a_stats;
-};
-
void hdd_get_class_a_statistics_cb(void *stats, void *context)
{
struct hdd_request *request;
diff --git a/CORE/SVC/src/logging/wlan_logging_sock_svc.c b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
index ed5f632..246a847 100644
--- a/CORE/SVC/src/logging/wlan_logging_sock_svc.c
+++ b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
@@ -1311,17 +1311,14 @@
* memdump complete. If it's null,then something is
* not right.
*/
- if (gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb &&
- gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb_arg) {
+ if (gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb) {
((hdd_fw_mem_dump_req_cb)
gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb)(
- (struct hdd_fw_mem_dump_req_ctx*)
gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb_arg);
/*invalidate the callback pointers*/
spin_lock_irqsave(&gwlan_logging.fw_mem_dump_ctx.fw_mem_dump_lock,flags);
gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb = NULL;
- gwlan_logging.fw_mem_dump_ctx.svc_fw_mem_dump_req_cb_arg = NULL;
spin_unlock_irqrestore(&gwlan_logging.fw_mem_dump_ctx.fw_mem_dump_lock,flags);
}
}