wlan: Use request manager for RSSI
propagation from qcacld-2.0 to prima
We are transitioning to the new request manager framework. Change
wlan_hdd_get_rssi() and hdd_get_rssi_cb() to this framework.
Change-Id: Ib0b74e288ad3dc4588440f0de7cfbebc9f88a49a
CRs-Fixed: 2213568
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 1a855aa..6e0a5bb 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -910,68 +910,6 @@
return rsnType;
}
-static void hdd_GetRssiCB( v_S7_t rssi, tANI_U32 staId, void *pContext )
-{
- struct statsContext *pStatsContext;
- hdd_adapter_t *pAdapter;
-
- if (ioctl_debug)
- {
- pr_info("%s: rssi [%d] STA [%d] pContext [%pK]\n",
- __func__, (int)rssi, (int)staId, pContext);
- }
-
- if (NULL == pContext)
- {
- hddLog(VOS_TRACE_LEVEL_ERROR,
- "%s: Bad param, pContext [%pK]",
- __func__, pContext);
- return;
- }
-
- 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) || (RSSI_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 rssi.FW will return RSSI as -100
- * if there are no samples to calculate the average
- * RSSI
- */
- if (rssi != -100)
- pAdapter->rssi = rssi;
- if (pAdapter->rssi > 0)
- pAdapter->rssi = 0;
- /* notify the caller */
- complete(&pStatsContext->completion);
-
- /* serialization is complete */
- spin_unlock(&hdd_context_lock);
-}
struct snr_priv {
int8_t snr;
@@ -1004,13 +942,46 @@
hdd_request_put(request);
}
+struct rssi_priv {
+ v_S7_t rssi;
+};
+
+static void hdd_get_rssi_cb( v_S7_t rssi, tANI_U32 staId, void *context )
+{
+ struct hdd_request *request;
+ struct rssi_priv *priv;
+
+ if (ioctl_debug) {
+ pr_info("%s: rssi [%d] STA [%d] context [%pK]\n",
+ __func__, (int)rssi, (int)staId, context);
+ }
+
+ request = hdd_request_get(context);
+ if (!request) {
+ hddLog(VOS_TRACE_LEVEL_ERROR, FL("Obsolete request"));
+ return;
+ }
+
+ priv = hdd_request_priv(request);
+ priv->rssi = rssi;
+
+ hdd_request_complete(request);
+ hdd_request_put(request);
+}
+
VOS_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, v_S7_t *rssi_value)
{
- struct statsContext context;
hdd_context_t *pHddCtx;
hdd_station_ctx_t *pHddStaCtx;
eHalStatus hstatus;
- long lrc;
+ int ret;
+ void *cookie;
+ struct hdd_request *request;
+ struct rssi_priv *priv;
+ static const struct hdd_request_params params = {
+ .priv_size = sizeof(*priv),
+ .timeout_ms = WLAN_WAIT_TIME_STATS,
+ };
if (NULL == pAdapter)
{
@@ -1045,14 +1016,17 @@
return VOS_STATUS_SUCCESS;
}
- init_completion(&context.completion);
- context.pAdapter = pAdapter;
- context.magic = RSSI_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_GetRssi(pHddCtx->hHal, hdd_GetRssiCB,
+ hstatus = sme_GetRssi(pHddCtx->hHal, hdd_get_rssi_cb,
pHddStaCtx->conn_info.staId[ 0 ],
pHddStaCtx->conn_info.bssId,
- &context, pHddCtx->pvosContext);
+ cookie, pHddCtx->pvosContext);
if (eHAL_STATUS_SUCCESS != hstatus)
{
hddLog(VOS_TRACE_LEVEL_ERROR,"%s: Unable to retrieve RSSI",
@@ -1062,35 +1036,40 @@
else
{
/* request was sent -- wait for the response */
- 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 RSSI",
- __func__, (0 == lrc) ? "timeout" : "interrupt");
+ hddLog(VOS_TRACE_LEVEL_ERROR,
+ FL("SME timeout while retrieving RSSI"));
/* we'll now returned a cached value below */
}
- }
+ else
+ {
+ priv = hdd_request_priv(request);
+ pAdapter->rssi = priv->rssi;
+ /*
+ * copy over the rssi.FW will return RSSI as -100 if
+ * there are no samples to calculate the averag RSSI
+ */
+ if (priv->rssi != -100)
+ pAdapter->rssi = priv->rssi;
- /* 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);
+ if (pAdapter->rssi > 0)
+ pAdapter->rssi = 0;
+ }
+ }
*rssi_value = pAdapter->rssi;
hddLog(VOS_TRACE_LEVEL_INFO,
"%s: RSSI = %d", __func__, *rssi_value);
+ /*
+ * 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;
}
/**---------------------------------------------------------------------------