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

qcacld-3.0: Converge on struct plm_req_params

Browse Source 
The driver currently defines two different data structures to hold
PLM Request parameters:
- legacy struct plm_req
- unified WMI struct plm_req_params

To align with the converged software architecture remove the legacy
definition and exclusively use the unified WMI definition.

Change-Id: I7675686aba9590a4507a8f9ebffcbf181ee00a21
CRs-Fixed: 2411817
This commit is contained in:
Jeff Johnson
2019-02-26 08:02:11 -08:00
committed by nshrivas
parent a40d629fbd
commit 36583f0647
6 changed files with 104 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1504,7 +1504,7 @@ hdd_parse_set_roam_scan_channels(struct hdd_adapter *adapter, const char *comman
* Return: 0 for success non-zero for failure * Return: 0 for success non-zero for failure
*/ */
static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command, static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
struct plm_req *req) struct plm_req_params *req)
{ {
uint8_t *in_ptr = NULL; uint8_t *in_ptr = NULL;
int count, content = 0, ret = 0; int count, content = 0, ret = 0;
@@ -1598,8 +1598,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
if (content < 0) if (content < 0)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->numBursts = content; req->num_bursts = content;
hdd_debug("num burst %d", req->numBursts); hdd_debug("num bursts %d", req->num_bursts);
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
if (NULL == in_ptr) if (NULL == in_ptr)
@@ -1621,8 +1621,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
if (content <= 0) if (content <= 0)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->burstInt = content; req->burst_int = content;
hdd_debug("burst Int %d", req->burstInt); hdd_debug("burst int %d", req->burst_int);
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
if (NULL == in_ptr) if (NULL == in_ptr)
@@ -1644,8 +1644,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
if (content <= 0) if (content <= 0)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->measDuration = content; req->meas_duration = content;
hdd_debug("measDur %d", req->measDuration); hdd_debug("meas duration %d", req->meas_duration);
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
if (NULL == in_ptr) if (NULL == in_ptr)
@@ -1667,8 +1667,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
if (content <= 0) if (content <= 0)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->burstLen = content; req->burst_len = content;
hdd_debug("burstLen %d", req->burstLen); hdd_debug("burst len %d", req->burst_len);
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
if (NULL == in_ptr) if (NULL == in_ptr)
@@ -1690,9 +1690,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
if (content <= 0) if (content <= 0)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->desiredTxPwr = content; req->desired_tx_pwr = content;
hdd_debug("desiredTxPwr %d", hdd_debug("desired tx pwr %d", req->desired_tx_pwr);
req->desiredTxPwr);
for (count = 0; count < QDF_MAC_ADDR_SIZE; count++) { for (count = 0; count < QDF_MAC_ADDR_SIZE; count++) {
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
@@ -1716,8 +1715,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
req->mac_addr.bytes[count] = content; req->mac_addr.bytes[count] = content;
} }
hdd_debug("MC addr " MAC_ADDRESS_STR, hdd_debug("MAC addr " MAC_ADDRESS_STR,
MAC_ADDR_ARRAY(req->mac_addr.bytes)); MAC_ADDR_ARRAY(req->mac_addr.bytes));
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
@@ -1741,11 +1740,11 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
content = QDF_MIN(content, CFG_VALID_CHANNEL_LIST_LEN); content = QDF_MIN(content, CFG_VALID_CHANNEL_LIST_LEN);
req->plmNumCh = content; req->plm_num_ch = content;
hdd_debug("numch: %d", req->plmNumCh); hdd_debug("num ch: %d", req->plm_num_ch);
/* Channel numbers */ /* Channel numbers */
for (count = 0; count < req->plmNumCh; count++) { for (count = 0; count < req->plm_num_ch; count++) {
in_ptr = strpbrk(in_ptr, " "); in_ptr = strpbrk(in_ptr, " ");
if (NULL == in_ptr) if (NULL == in_ptr)
@@ -1765,8 +1764,8 @@ static QDF_STATUS hdd_parse_plm_cmd(uint8_t *command,
content > WNI_CFG_CURRENT_CHANNEL_STAMAX) content > WNI_CFG_CURRENT_CHANNEL_STAMAX)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
req->plmChList[count] = content; req->plm_ch_list[count] = content;
hdd_debug(" ch- %d", req->plmChList[count]); hdd_debug(" ch- %d", req->plm_ch_list[count]);
} }
} }
/* If PLM START */ /* If PLM START */
@@ -5579,11 +5578,11 @@ exit:
/** /**
* drv_cmd_ccx_plm_req() - Set ESE PLM request * drv_cmd_ccx_plm_req() - Set ESE PLM request
* @adapter: Pointer to the HDD adapter * @adapter: Pointer to the HDD adapter
* @hdd_ctx: Pointer to the HDD context * @hdd_ctx: Pointer to the HDD context
* @command: Driver command string * @command: Driver command string
* @command_len: Driver command string length * @command_len: Driver command string length
* @priv_data: Private data coming with the driver command. Unused here * @priv_data: Private data coming with the driver command. Unused here
* *
* This function handles driver command that sets the ESE PLM request * This function handles driver command that sets the ESE PLM request
* *
@@ -5595,36 +5594,21 @@ static int drv_cmd_ccx_plm_req(struct hdd_adapter *adapter,
uint8_t command_len, uint8_t command_len,
struct hdd_priv_data *priv_data) struct hdd_priv_data *priv_data)
{ {
int ret = 0; QDF_STATUS status;
uint8_t *value = command; struct plm_req_params *req;
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct plm_req *req = NULL;
req = qdf_mem_malloc(sizeof(struct plm_req)); req = qdf_mem_malloc(sizeof(*req));
if (NULL == req) { if (!req)
ret = -ENOMEM; return -ENOMEM;
goto exit;
status = hdd_parse_plm_cmd(command, req);
if (QDF_IS_STATUS_SUCCESS(status)) {
req->vdev_id = adapter->vdev_id;
status = sme_set_plm_request(hdd_ctx->mac_handle, req);
} }
qdf_mem_free(req);
status = hdd_parse_plm_cmd(value, req); return qdf_status_to_os_return(status);
if (QDF_STATUS_SUCCESS != status) {
qdf_mem_free(req);
req = NULL;
ret = -EINVAL;
goto exit;
}
req->sessionId = adapter->vdev_id;
status = sme_set_plm_request(hdd_ctx->mac_handle, req);
if (QDF_STATUS_SUCCESS != status) {
qdf_mem_free(req);
req = NULL;
ret = -EINVAL;
goto exit;
}
exit:
return ret;
} }
/** /**

18
core/mac/inc/sir_api.h
View File

@@ -869,24 +869,6 @@ typedef struct sEsePEContext {
tEseTSMContext tsm; tEseTSMContext tsm;
} tEsePEContext, *tpEsePEContext; } tEsePEContext, *tpEsePEContext;
struct plm_req {
uint16_t diag_token; /* Dialog token */
uint16_t meas_token; /* measurement token */
uint16_t numBursts; /* total number of bursts */
uint16_t burstInt; /* burst interval in seconds */
uint16_t measDuration; /* in TU's,STA goes off-ch */
/* no of times the STA should cycle through PLM ch list */
uint8_t burstLen;
int8_t desiredTxPwr; /* desired tx power */
struct qdf_mac_addr mac_addr; /* MC dest addr */
/* no of channels */
uint8_t plmNumCh;
/* channel numbers */
uint8_t plmChList[CFG_VALID_CHANNEL_LIST_LEN];
uint8_t sessionId;
bool enable;
};
#endif /* FEATURE_WLAN_ESE */ #endif /* FEATURE_WLAN_ESE */
/* / Definition for join request */ /* / Definition for join request */

4
core/sme/inc/sme_api.h
View File

@@ -627,8 +627,10 @@ QDF_STATUS sme_set_ese_beacon_request(mac_handle_t mac_handle,
* *
* Return: QDF_STATUS enumeration * Return: QDF_STATUS enumeration
*/ */
QDF_STATUS sme_set_plm_request(mac_handle_t mac_handle, struct plm_req *req); QDF_STATUS sme_set_plm_request(mac_handle_t mac_handle,
struct plm_req_params *req);
#endif /*FEATURE_WLAN_ESE */ #endif /*FEATURE_WLAN_ESE */
QDF_STATUS sme_get_modify_profile_fields(mac_handle_t mac_handle, QDF_STATUS sme_get_modify_profile_fields(mac_handle_t mac_handle,
uint8_t sessionId, uint8_t sessionId,
tCsrRoamModifyProfileFields * tCsrRoamModifyProfileFields *

69
core/sme/src/common/sme_api.c
View File

@@ -1450,7 +1450,8 @@ QDF_STATUS sme_update_is_ese_feature_enabled(mac_handle_t mac_handle,
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
QDF_STATUS sme_set_plm_request(mac_handle_t mac_handle, struct plm_req *req) QDF_STATUS sme_set_plm_request(mac_handle_t mac_handle,
struct plm_req_params *req)
{ {
QDF_STATUS status; QDF_STATUS status;
bool ret = false; bool ret = false;
@@ -1458,71 +1459,80 @@ QDF_STATUS sme_set_plm_request(mac_handle_t mac_handle, struct plm_req *req)
uint8_t ch_list[CFG_VALID_CHANNEL_LIST_LEN] = { 0 }; uint8_t ch_list[CFG_VALID_CHANNEL_LIST_LEN] = { 0 };
uint8_t count, valid_count = 0; uint8_t count, valid_count = 0;
struct scheduler_msg msg = {0}; struct scheduler_msg msg = {0};
struct csr_roam_session *pSession = CSR_GET_SESSION(mac, struct csr_roam_session *session;
req->sessionId); struct plm_req_params *body;
status = sme_acquire_global_lock(&mac->sme); status = sme_acquire_global_lock(&mac->sme);
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
return status; return status;
if (!pSession) { session = CSR_GET_SESSION(mac, req->vdev_id);
sme_err("session %d not found", req->sessionId); if (!session) {
sme_err("session %d not found", req->vdev_id);
sme_release_global_lock(&mac->sme); sme_release_global_lock(&mac->sme);
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
if (!pSession->sessionActive) { if (!session->sessionActive) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR, QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("Invalid Sessionid")); FL("Invalid Sessionid"));
sme_release_global_lock(&mac->sme); sme_release_global_lock(&mac->sme);
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
if (!req->enable) /* per contract must make a copy of the params when messaging */
body = qdf_mem_malloc(sizeof(*body));
if (!req)
return QDF_STATUS_E_NOMEM;
*body = *req;
if (!body->enable)
goto send_plm_start; goto send_plm_start;
/* validating channel numbers */ /* validating channel numbers */
for (count = 0; count < req->plmNumCh; count++) { for (count = 0; count < body->plm_num_ch; count++) {
ret = csr_is_supported_channel(mac, req->plmChList[count]); uint8_t ch = body->plm_ch_list[count];
if (ret && req->plmChList[count] > 14) {
if (CHANNEL_STATE_DFS == wlan_reg_get_channel_state( ret = csr_is_supported_channel(mac, ch);
mac->pdev, if (!ret) {
req->plmChList[count])) { /* Not supported, ignore the channel */
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
FL("Unsupported channel %d ignored for PLM"),
ch);
continue;
}
if (ch > 14) {
enum channel_state state =
wlan_reg_get_channel_state(mac->pdev, ch);
if (state == CHANNEL_STATE_DFS) {
/* DFS channel is provided, no PLM bursts can be /* DFS channel is provided, no PLM bursts can be
* transmitted. Ignoring these channels. * transmitted. Ignoring these channels.
*/ */
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE(QDF_MODULE_ID_SME,
QDF_TRACE_LEVEL_DEBUG, QDF_TRACE_LEVEL_DEBUG,
FL("DFS channel %d ignored for PLM"), FL("DFS channel %d ignored for PLM"),
req->plmChList[count]); ch);
continue; continue;
} }
} else if (!ret) {
/* Not supported, ignore the channel */
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
FL("Unsupported channel %d ignored for PLM"),
req->plmChList[count]);
continue;
} }
ch_list[valid_count] = req->plmChList[count]; ch_list[valid_count++] = ch;
valid_count++;
} /* End of for () */ } /* End of for () */
/* Copying back the valid channel list to plm struct */ /* Copying back the valid channel list to plm struct */
qdf_mem_zero((void *)req->plmChList, qdf_mem_zero(body->plm_ch_list, body->plm_num_ch);
req->plmNumCh);
if (valid_count) if (valid_count)
qdf_mem_copy(req->plmChList, ch_list, qdf_mem_copy(body->plm_ch_list, ch_list, valid_count);
valid_count);
/* All are invalid channels, FW need to send the PLM /* All are invalid channels, FW need to send the PLM
* report with "incapable" bit set. * report with "incapable" bit set.
*/ */
req->plmNumCh = valid_count; body->plm_num_ch = valid_count;
send_plm_start: send_plm_start:
/* PLM START */ /* PLM START */
msg.type = WMA_SET_PLM_REQ; msg.type = WMA_SET_PLM_REQ;
msg.reserved = 0; msg.reserved = 0;
msg.bodyptr = req; msg.bodyptr = body;
if (!QDF_IS_STATUS_SUCCESS(scheduler_post_message(QDF_MODULE_ID_SME, if (!QDF_IS_STATUS_SUCCESS(scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA, QDF_MODULE_ID_WMA,
@@ -1531,11 +1541,12 @@ send_plm_start:
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR, QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("Not able to post WMA_SET_PLM_REQ to WMA")); FL("Not able to post WMA_SET_PLM_REQ to WMA"));
sme_release_global_lock(&mac->sme); sme_release_global_lock(&mac->sme);
qdf_mem_free(body);
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
sme_release_global_lock(&mac->sme); sme_release_global_lock(&mac->sme);
return status; return QDF_STATUS_SUCCESS;
} }
/** /**

4
core/wma/inc/wma_internal.h
View File

@@ -1117,9 +1117,7 @@ void wma_add_ts_req(tp_wma_handle wma, struct add_ts_param *msg);
#ifdef FEATURE_WLAN_ESE #ifdef FEATURE_WLAN_ESE
QDF_STATUS wma_process_tsm_stats_req(tp_wma_handle wma_handler, QDF_STATUS wma_process_tsm_stats_req(tp_wma_handle wma_handler,
void *pTsmStatsMsg); void *pTsmStatsMsg);
QDF_STATUS wma_plm_start(tp_wma_handle wma, const struct plm_req *plm); void wma_config_plm(tp_wma_handle wma, struct plm_req_params *plm);
QDF_STATUS wma_plm_stop(tp_wma_handle wma, const struct plm_req *plm);
void wma_config_plm(tp_wma_handle wma, struct plm_req *plm);
#endif #endif
QDF_STATUS wma_process_mcbc_set_filter_req(tp_wma_handle wma_handle, QDF_STATUS wma_process_mcbc_set_filter_req(tp_wma_handle wma_handle,

95
core/wma/src/wma_scan_roam.c
View File

@@ -3276,27 +3276,23 @@ send_resp:
/** /**
* wma_plm_start() - plm start request * wma_plm_start() - plm start request
* @wma: wma handle * @wma: wma handle
* @plm: plm request parameters * @params: plm request parameters
* *
* This function request FW to start PLM. * This function request FW to start PLM.
* *
* Return: QDF status * Return: QDF status
*/ */
QDF_STATUS wma_plm_start(tp_wma_handle wma, const struct plm_req *plm) static QDF_STATUS wma_plm_start(tp_wma_handle wma,
struct plm_req_params *params)
{ {
struct plm_req_params params = {0};
uint32_t num_channels; uint32_t num_channels;
uint32_t *channel_list = NULL; uint32_t *channel_list = NULL;
uint32_t i; uint32_t i;
QDF_STATUS status; QDF_STATUS status;
if (NULL == plm || NULL == wma) {
WMA_LOGE("%s: input pointer is NULL ", __func__);
return QDF_STATUS_E_FAILURE;
}
WMA_LOGD("PLM Start"); WMA_LOGD("PLM Start");
num_channels = plm->plmNumCh; num_channels = params->plm_num_ch;
if (num_channels) { if (num_channels) {
channel_list = qdf_mem_malloc(sizeof(uint32_t) * num_channels); channel_list = qdf_mem_malloc(sizeof(uint32_t) * num_channels);
@@ -3304,41 +3300,23 @@ QDF_STATUS wma_plm_start(tp_wma_handle wma, const struct plm_req *plm)
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
for (i = 0; i < num_channels; i++) { for (i = 0; i < num_channels; i++) {
channel_list[i] = plm->plmChList[i]; channel_list[i] = params->plm_ch_list[i];
if (channel_list[i] < WMA_NLO_FREQ_THRESH) if (channel_list[i] < WMA_NLO_FREQ_THRESH)
channel_list[i] = channel_list[i] =
cds_chan_to_freq(channel_list[i]); cds_chan_to_freq(channel_list[i]);
} }
} }
status = wmi_unified_plm_start_cmd(wma->wmi_handle, params,
params.diag_token = plm->diag_token; channel_list);
params.meas_token = plm->meas_token;
params.num_bursts = plm->numBursts;
params.burst_int = plm->burstInt;
params.meas_duration = plm->measDuration;
params.burst_len = plm->burstLen;
params.desired_tx_pwr = plm->desiredTxPwr;
params.plm_num_ch = plm->plmNumCh;
params.vdev_id = plm->sessionId;
params.enable = plm->enable;
qdf_mem_copy(&params.mac_addr, &plm->mac_addr,
sizeof(struct qdf_mac_addr));
qdf_mem_copy(params.plm_ch_list, plm->plmChList,
WMI_CFG_VALID_CHANNEL_LIST_LEN);
status = wmi_unified_plm_start_cmd(wma->wmi_handle,
&params, channel_list);
if (QDF_IS_STATUS_ERROR(status)) {
qdf_mem_free(channel_list);
return status;
}
qdf_mem_free(channel_list); qdf_mem_free(channel_list);
wma->interfaces[plm->sessionId].plm_in_progress = true; if (QDF_IS_STATUS_ERROR(status))
return status;
wma->interfaces[params->vdev_id].plm_in_progress = true;
WMA_LOGD("Plm start request sent successfully for vdev %d", WMA_LOGD("Plm start request sent successfully for vdev %d",
plm->sessionId); params->vdev_id);
return status; return status;
} }
@@ -3346,53 +3324,32 @@ QDF_STATUS wma_plm_start(tp_wma_handle wma, const struct plm_req *plm)
/** /**
* wma_plm_stop() - plm stop request * wma_plm_stop() - plm stop request
* @wma: wma handle * @wma: wma handle
* @plm: plm request parameters * @params: plm request parameters
* *
* This function request FW to stop PLM. * This function request FW to stop PLM.
* *
* Return: QDF status * Return: QDF status
*/ */
QDF_STATUS wma_plm_stop(tp_wma_handle wma, const struct plm_req *plm) static QDF_STATUS wma_plm_stop(tp_wma_handle wma,
struct plm_req_params *params)
{ {
struct plm_req_params params = {0};
QDF_STATUS status; QDF_STATUS status;
if (NULL == plm || NULL == wma) { if (!wma->interfaces[params->vdev_id].plm_in_progress) {
WMA_LOGE("%s: input pointer is NULL ", __func__);
return QDF_STATUS_E_FAILURE;
}
if (false == wma->interfaces[plm->sessionId].plm_in_progress) {
WMA_LOGE("No active plm req found, skip plm stop req"); WMA_LOGE("No active plm req found, skip plm stop req");
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
WMA_LOGD("PLM Stop"); WMA_LOGD("PLM Stop");
params.diag_token = plm->diag_token; status = wmi_unified_plm_stop_cmd(wma->wmi_handle, params);
params.meas_token = plm->meas_token;
params.num_bursts = plm->numBursts;
params.burst_int = plm->burstInt;
params.meas_duration = plm->measDuration;
params.burst_len = plm->burstLen;
params.desired_tx_pwr = plm->desiredTxPwr;
params.plm_num_ch = plm->plmNumCh;
params.vdev_id = plm->sessionId;
params.enable = plm->enable;
qdf_mem_copy(&params.mac_addr, &plm->mac_addr,
sizeof(struct qdf_mac_addr));
qdf_mem_copy(params.plm_ch_list, plm->plmChList,
WMI_CFG_VALID_CHANNEL_LIST_LEN);
status = wmi_unified_plm_stop_cmd(wma->wmi_handle,
&params);
if (QDF_IS_STATUS_ERROR(status)) if (QDF_IS_STATUS_ERROR(status))
return status; return status;
wma->interfaces[plm->sessionId].plm_in_progress = false; wma->interfaces[params->vdev_id].plm_in_progress = false;
WMA_LOGD("Plm stop request sent successfully for vdev %d", WMA_LOGD("Plm stop request sent successfully for vdev %d",
plm->sessionId); params->vdev_id);
return status; return status;
} }
@@ -3400,25 +3357,25 @@ QDF_STATUS wma_plm_stop(tp_wma_handle wma, const struct plm_req *plm)
/** /**
* wma_config_plm() - config PLM * wma_config_plm() - config PLM
* @wma: wma handle * @wma: wma handle
* @plm: plm request parameters * @params: plm request parameters
* *
* Return: none * Return: none
*/ */
void wma_config_plm(tp_wma_handle wma, struct plm_req *plm) void wma_config_plm(tp_wma_handle wma, struct plm_req_params *params)
{ {
QDF_STATUS ret; QDF_STATUS ret;
if (NULL == plm || NULL == wma) if (!params || !wma)
return; return;
if (plm->enable) if (params->enable)
ret = wma_plm_start(wma, plm); ret = wma_plm_start(wma, params);
else else
ret = wma_plm_stop(wma, plm); ret = wma_plm_stop(wma, params);
if (ret) if (ret)
WMA_LOGE("%s: PLM %s failed %d", __func__, WMA_LOGE("%s: PLM %s failed %d", __func__,
plm->enable ? "start" : "stop", ret); params->enable ? "start" : "stop", ret);
} }
#endif #endif