qcacld-3.0: Refactor formation of wmi feature commands
Move tlv formation of wmi feature based commands to common wmi
layer from wma layer.
Change-Id: I2cda92c377faf16b09412f0dc746e537343242ff
CRs-Fixed: 976998
diff --git a/core/wma/src/wma_features.c b/core/wma/src/wma_features.c
index 8ec2c2c..8fe0266 100644
--- a/core/wma/src/wma_features.c
+++ b/core/wma/src/wma_features.c
@@ -148,9 +148,6 @@
QDF_STATUS wma_send_snr_request(tp_wma_handle wma_handle,
void *pGetRssiReq)
{
- wmi_buf_t buf;
- wmi_request_stats_cmd_fixed_param *cmd;
- uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
tAniGetRssiReq *pRssiBkUp = NULL;
/* command is in progess */
@@ -177,24 +174,8 @@
wma_handle->pGetRssiReq = (void *)pRssiBkUp;
}
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- qdf_mem_free(pRssiBkUp);
- wma_handle->pGetRssiReq = NULL;
- return QDF_STATUS_E_FAILURE;
- }
-
- cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_request_stats_cmd_fixed_param));
- cmd->stats_id = WMI_REQUEST_VDEV_STAT;
- if (wmi_unified_cmd_send
- (wma_handle->wmi_handle, buf, len, WMI_REQUEST_STATS_CMDID)) {
+ if (wmi_unified_snr_request_cmd(wma_handle->wmi_handle)) {
WMA_LOGE("Failed to send host stats request to fw");
- wmi_buf_free(buf);
qdf_mem_free(pRssiBkUp);
wma_handle->pGetRssiReq = NULL;
return QDF_STATUS_E_FAILURE;
@@ -210,10 +191,7 @@
*/
QDF_STATUS wma_get_snr(tAniGetSnrReq *psnr_req)
{
- wmi_buf_t buf;
- wmi_request_stats_cmd_fixed_param *cmd;
tAniGetSnrReq *psnr_req_bkp;
- uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
tp_wma_handle wma_handle = NULL;
struct wma_txrx_node *intr;
@@ -241,26 +219,11 @@
psnr_req_bkp->staId = psnr_req->staId;
psnr_req_bkp->pDevContext = psnr_req->pDevContext;
psnr_req_bkp->snrCallback = psnr_req->snrCallback;
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- qdf_mem_free(psnr_req_bkp);
- return QDF_STATUS_E_FAILURE;
- }
-
- cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
- cmd->vdev_id = psnr_req->sessionId;
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_request_stats_cmd_fixed_param));
- cmd->stats_id = WMI_REQUEST_VDEV_STAT;
intr->psnr_req = (void *)psnr_req_bkp;
- if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_REQUEST_STATS_CMDID)) {
+
+ if (wmi_unified_snr_cmd(wma_handle->wmi_handle,
+ psnr_req->sessionId)) {
WMA_LOGE("Failed to send host stats request to fw");
- wmi_buf_free(buf);
qdf_mem_free(psnr_req_bkp);
intr->psnr_req = NULL;
return QDF_STATUS_E_FAILURE;
@@ -279,9 +242,7 @@
void wma_process_link_status_req(tp_wma_handle wma,
tAniGetLinkStatus *pGetLinkStatus)
{
- wmi_buf_t buf;
- wmi_request_stats_cmd_fixed_param *cmd;
- uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
+ struct link_status_params cmd = {0};
struct wma_txrx_node *iface =
&wma->interfaces[pGetLinkStatus->sessionId];
@@ -292,24 +253,10 @@
return;
}
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- goto end;
- }
-
iface->plink_status_req = pGetLinkStatus;
- cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_request_stats_cmd_fixed_param));
- cmd->stats_id = WMI_REQUEST_VDEV_RATE_STAT;
- cmd->vdev_id = pGetLinkStatus->sessionId;
- if (wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_REQUEST_STATS_CMDID)) {
+ cmd.session_id = pGetLinkStatus->sessionId;
+ if (wmi_unified_link_status_req_cmd(wma->wmi_handle, &cmd)) {
WMA_LOGE("Failed to send WMI link status request to fw");
- wmi_buf_free(buf);
iface->plink_status_req = NULL;
goto end;
}
@@ -335,10 +282,7 @@
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
tSirLPHBEnableStruct *ts_lphb_enable;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_hb_set_enable_cmd_fixed_param *hb_enable_fp;
- int len = sizeof(wmi_hb_set_enable_cmd_fixed_param);
+ wmi_hb_set_enable_cmd_fixed_param hb_enable_fp;
int i;
if (lphb_conf_req == NULL) {
@@ -358,30 +302,16 @@
return QDF_STATUS_E_FAILURE;
}
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- hb_enable_fp = (wmi_hb_set_enable_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&hb_enable_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_hb_set_enable_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_hb_set_enable_cmd_fixed_param));
/* fill in values */
- hb_enable_fp->vdev_id = ts_lphb_enable->session;
- hb_enable_fp->enable = ts_lphb_enable->enable;
- hb_enable_fp->item = ts_lphb_enable->item;
- hb_enable_fp->session = ts_lphb_enable->session;
+ hb_enable_fp.vdev_id = ts_lphb_enable->session;
+ hb_enable_fp.enable = ts_lphb_enable->enable;
+ hb_enable_fp.item = ts_lphb_enable->item;
+ hb_enable_fp.session = ts_lphb_enable->session;
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_HB_SET_ENABLE_CMDID);
+ status = wmi_unified_lphb_config_hbenable_cmd(wma_handle->wmi_handle,
+ &hb_enable_fp);
if (status != EOK) {
- WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_ENABLE returned Error %d",
- status);
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
@@ -427,10 +357,8 @@
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
tSirLPHBTcpParamStruct *ts_lphb_tcp_param;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_hb_set_tcp_params_cmd_fixed_param *hb_tcp_params_fp;
- int len = sizeof(wmi_hb_set_tcp_params_cmd_fixed_param);
+ wmi_hb_set_tcp_params_cmd_fixed_param hb_tcp_params_fp = {0};
+
if (lphb_conf_req == NULL) {
WMA_LOGE("%s : LPHB configuration is NULL", __func__);
@@ -448,37 +376,22 @@
MAC_ADDR_ARRAY(ts_lphb_tcp_param->gateway_mac.bytes),
ts_lphb_tcp_param->timePeriodSec, ts_lphb_tcp_param->tcpSn);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- hb_tcp_params_fp = (wmi_hb_set_tcp_params_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&hb_tcp_params_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_hb_set_tcp_params_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_hb_set_tcp_params_cmd_fixed_param));
-
/* fill in values */
- hb_tcp_params_fp->vdev_id = ts_lphb_tcp_param->session;
- hb_tcp_params_fp->srv_ip = ts_lphb_tcp_param->srv_ip;
- hb_tcp_params_fp->dev_ip = ts_lphb_tcp_param->dev_ip;
- hb_tcp_params_fp->seq = ts_lphb_tcp_param->tcpSn;
- hb_tcp_params_fp->src_port = ts_lphb_tcp_param->src_port;
- hb_tcp_params_fp->dst_port = ts_lphb_tcp_param->dst_port;
- hb_tcp_params_fp->interval = ts_lphb_tcp_param->timePeriodSec;
- hb_tcp_params_fp->timeout = ts_lphb_tcp_param->timeout;
- hb_tcp_params_fp->session = ts_lphb_tcp_param->session;
+ hb_tcp_params_fp.vdev_id = ts_lphb_tcp_param->session;
+ hb_tcp_params_fp.srv_ip = ts_lphb_tcp_param->srv_ip;
+ hb_tcp_params_fp.dev_ip = ts_lphb_tcp_param->dev_ip;
+ hb_tcp_params_fp.seq = ts_lphb_tcp_param->tcpSn;
+ hb_tcp_params_fp.src_port = ts_lphb_tcp_param->src_port;
+ hb_tcp_params_fp.dst_port = ts_lphb_tcp_param->dst_port;
+ hb_tcp_params_fp.interval = ts_lphb_tcp_param->timePeriodSec;
+ hb_tcp_params_fp.timeout = ts_lphb_tcp_param->timeout;
+ hb_tcp_params_fp.session = ts_lphb_tcp_param->session;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ts_lphb_tcp_param->gateway_mac.bytes,
- &hb_tcp_params_fp->gateway_mac);
+ &hb_tcp_params_fp.gateway_mac);
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_HB_SET_TCP_PARAMS_CMDID);
+ status = wmi_unified_lphb_config_tcp_params_cmd(wma_handle->wmi_handle,
+ &hb_tcp_params_fp);
if (status != EOK) {
- WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
- status);
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
@@ -501,10 +414,7 @@
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
tSirLPHBTcpFilterStruct *ts_lphb_tcp_filter;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *hb_tcp_filter_fp;
- int len = sizeof(wmi_hb_set_tcp_pkt_filter_cmd_fixed_param);
+ wmi_hb_set_tcp_pkt_filter_cmd_fixed_param hb_tcp_filter_fp = {0};
if (lphb_conf_req == NULL) {
WMA_LOGE("%s : LPHB configuration is NULL", __func__);
@@ -520,34 +430,18 @@
ts_lphb_tcp_filter->filter[3], ts_lphb_tcp_filter->filter[4],
ts_lphb_tcp_filter->filter[5]);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- hb_tcp_filter_fp =
- (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&hb_tcp_filter_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_hb_set_tcp_pkt_filter_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param));
-
/* fill in values */
- hb_tcp_filter_fp->vdev_id = ts_lphb_tcp_filter->session;
- hb_tcp_filter_fp->length = ts_lphb_tcp_filter->length;
- hb_tcp_filter_fp->offset = ts_lphb_tcp_filter->offset;
- hb_tcp_filter_fp->session = ts_lphb_tcp_filter->session;
- memcpy((void *)&hb_tcp_filter_fp->filter,
+ hb_tcp_filter_fp.vdev_id = ts_lphb_tcp_filter->session;
+ hb_tcp_filter_fp.length = ts_lphb_tcp_filter->length;
+ hb_tcp_filter_fp.offset = ts_lphb_tcp_filter->offset;
+ hb_tcp_filter_fp.session = ts_lphb_tcp_filter->session;
+ memcpy((void *)&hb_tcp_filter_fp.filter,
(void *)&ts_lphb_tcp_filter->filter,
WMI_WLAN_HB_MAX_FILTER_SIZE);
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_HB_SET_TCP_PKT_FILTER_CMDID);
+ status = wmi_unified_lphb_config_tcp_pkt_filter_cmd(wma_handle->wmi_handle,
+ &hb_tcp_filter_fp);
if (status != EOK) {
- WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
- status);
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
@@ -570,10 +464,8 @@
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
tSirLPHBUdpParamStruct *ts_lphb_udp_param;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_hb_set_udp_params_cmd_fixed_param *hb_udp_params_fp;
- int len = sizeof(wmi_hb_set_udp_params_cmd_fixed_param);
+ wmi_hb_set_udp_params_cmd_fixed_param hb_udp_params_fp = {0};
+
if (lphb_conf_req == NULL) {
WMA_LOGE("%s : LPHB configuration is NULL", __func__);
@@ -590,36 +482,22 @@
ts_lphb_udp_param->session,
MAC_ADDR_ARRAY(ts_lphb_udp_param->gateway_mac.bytes));
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- hb_udp_params_fp = (wmi_hb_set_udp_params_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&hb_udp_params_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_hb_set_udp_params_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_hb_set_udp_params_cmd_fixed_param));
/* fill in values */
- hb_udp_params_fp->vdev_id = ts_lphb_udp_param->session;
- hb_udp_params_fp->srv_ip = ts_lphb_udp_param->srv_ip;
- hb_udp_params_fp->dev_ip = ts_lphb_udp_param->dev_ip;
- hb_udp_params_fp->src_port = ts_lphb_udp_param->src_port;
- hb_udp_params_fp->dst_port = ts_lphb_udp_param->dst_port;
- hb_udp_params_fp->interval = ts_lphb_udp_param->interval;
- hb_udp_params_fp->timeout = ts_lphb_udp_param->timeout;
- hb_udp_params_fp->session = ts_lphb_udp_param->session;
+ hb_udp_params_fp.vdev_id = ts_lphb_udp_param->session;
+ hb_udp_params_fp.srv_ip = ts_lphb_udp_param->srv_ip;
+ hb_udp_params_fp.dev_ip = ts_lphb_udp_param->dev_ip;
+ hb_udp_params_fp.src_port = ts_lphb_udp_param->src_port;
+ hb_udp_params_fp.dst_port = ts_lphb_udp_param->dst_port;
+ hb_udp_params_fp.interval = ts_lphb_udp_param->interval;
+ hb_udp_params_fp.timeout = ts_lphb_udp_param->timeout;
+ hb_udp_params_fp.session = ts_lphb_udp_param->session;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ts_lphb_udp_param->gateway_mac.bytes,
- &hb_udp_params_fp->gateway_mac);
+ &hb_udp_params_fp.gateway_mac);
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_HB_SET_UDP_PARAMS_CMDID);
+ status = wmi_unified_lphb_config_udp_params_cmd(wma_handle->wmi_handle,
+ &hb_udp_params_fp);
if (status != EOK) {
- WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
- status);
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
@@ -642,10 +520,7 @@
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
int status = 0;
tSirLPHBUdpFilterStruct *ts_lphb_udp_filter;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_hb_set_udp_pkt_filter_cmd_fixed_param *hb_udp_filter_fp;
- int len = sizeof(wmi_hb_set_udp_pkt_filter_cmd_fixed_param);
+ wmi_hb_set_udp_pkt_filter_cmd_fixed_param hb_udp_filter_fp = {0};
if (lphb_conf_req == NULL) {
WMA_LOGE("%s : LPHB configuration is NULL", __func__);
@@ -661,34 +536,19 @@
ts_lphb_udp_filter->filter[3], ts_lphb_udp_filter->filter[4],
ts_lphb_udp_filter->filter[5]);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- hb_udp_filter_fp =
- (wmi_hb_set_udp_pkt_filter_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&hb_udp_filter_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_hb_set_udp_pkt_filter_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_hb_set_udp_pkt_filter_cmd_fixed_param));
/* fill in values */
- hb_udp_filter_fp->vdev_id = ts_lphb_udp_filter->session;
- hb_udp_filter_fp->length = ts_lphb_udp_filter->length;
- hb_udp_filter_fp->offset = ts_lphb_udp_filter->offset;
- hb_udp_filter_fp->session = ts_lphb_udp_filter->session;
- memcpy((void *)&hb_udp_filter_fp->filter,
+ hb_udp_filter_fp.vdev_id = ts_lphb_udp_filter->session;
+ hb_udp_filter_fp.length = ts_lphb_udp_filter->length;
+ hb_udp_filter_fp.offset = ts_lphb_udp_filter->offset;
+ hb_udp_filter_fp.session = ts_lphb_udp_filter->session;
+ memcpy((void *)&hb_udp_filter_fp.filter,
(void *)&ts_lphb_udp_filter->filter,
WMI_WLAN_HB_MAX_FILTER_SIZE);
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_HB_SET_UDP_PKT_FILTER_CMDID);
+ status = wmi_unified_lphb_config_udp_pkt_filter_cmd(wma_handle->wmi_handle,
+ &hb_udp_filter_fp);
if (status != EOK) {
- WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
- status);
qdf_status = QDF_STATUS_E_FAILURE;
goto error;
}
@@ -765,10 +625,7 @@
{
uint8_t vdev_id;
int status = 0;
- wmi_buf_t buf = NULL;
- uint8_t *buf_ptr;
- wmi_peer_set_param_cmd_fixed_param *peer_set_param_fp;
- int len = sizeof(wmi_peer_set_param_cmd_fixed_param);
+ wmi_peer_set_param_cmd_fixed_param peer_set_param_fp = {0};
if (!ta_dhcp_ind) {
WMA_LOGE("%s : DHCP indication is NULL", __func__);
@@ -792,34 +649,19 @@
ta_dhcp_ind->device_mode,
MAC_ADDR_ARRAY(ta_dhcp_ind->peerMacAddr.bytes));
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- peer_set_param_fp = (wmi_peer_set_param_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&peer_set_param_fp->tlv_header,
- WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_peer_set_param_cmd_fixed_param));
-
/* fill in values */
- peer_set_param_fp->vdev_id = vdev_id;
- peer_set_param_fp->param_id = WMI_PEER_CRIT_PROTO_HINT_ENABLED;
+ peer_set_param_fp.vdev_id = vdev_id;
+ peer_set_param_fp.param_id = WMI_PEER_CRIT_PROTO_HINT_ENABLED;
if (WMA_DHCP_START_IND == ta_dhcp_ind->msgType)
- peer_set_param_fp->param_value = 1;
+ peer_set_param_fp.param_value = 1;
else
- peer_set_param_fp->param_value = 0;
+ peer_set_param_fp.param_value = 0;
WMI_CHAR_ARRAY_TO_MAC_ADDR(ta_dhcp_ind->peerMacAddr.bytes,
- &peer_set_param_fp->peer_macaddr);
+ &peer_set_param_fp.peer_macaddr);
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- len, WMI_PEER_SET_PARAM_CMDID);
+ status = wmi_unified_process_dhcp_ind(wma_handle->wmi_handle,
+ &peer_set_param_fp);
if (status != EOK) {
- WMA_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
- " returned Error %d", __func__, status);
return QDF_STATUS_E_FAILURE;
}
@@ -927,10 +769,7 @@
QDF_STATUS wma_get_link_speed(WMA_HANDLE handle, tSirLinkSpeedInfo *pLinkSpeed)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
- wmi_peer_get_estimated_linkspeed_cmd_fixed_param *cmd;
- wmi_buf_t wmi_buf;
- uint32_t len;
- uint8_t *buf_ptr;
+ wmi_mac_addr peer_macaddr;
if (!wma_handle || !wma_handle->wmi_handle) {
WMA_LOGE("%s: WMA is closed, can not issue get link speed cmd",
@@ -944,36 +783,22 @@
wma_send_link_speed(0);
return QDF_STATUS_E_FAILURE;
}
- len = sizeof(wmi_peer_get_estimated_linkspeed_cmd_fixed_param);
- wmi_buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!wmi_buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
- buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
-
- cmd = (wmi_peer_get_estimated_linkspeed_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_peer_get_estimated_linkspeed_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_peer_get_estimated_linkspeed_cmd_fixed_param));
/* Copy the peer macaddress to the wma buffer */
WMI_CHAR_ARRAY_TO_MAC_ADDR(pLinkSpeed->peer_macaddr.bytes,
- &cmd->peer_macaddr);
+ &peer_macaddr);
WMA_LOGD("%s: pLinkSpeed->peerMacAddr: %pM, "
"peer_macaddr.mac_addr31to0: 0x%x, peer_macaddr.mac_addr47to32: 0x%x",
__func__, pLinkSpeed->peer_macaddr.bytes,
- cmd->peer_macaddr.mac_addr31to0,
- cmd->peer_macaddr.mac_addr47to32);
+ peer_macaddr.mac_addr31to0,
+ peer_macaddr.mac_addr47to32);
- if (wmi_unified_cmd_send(wma_handle->wmi_handle, wmi_buf, len,
- WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) {
- WMA_LOGE("%s: failed to send link speed command", __func__);
- qdf_nbuf_free(wmi_buf);
+ if (wmi_unified_get_link_speed_cmd(wma_handle->wmi_handle,
+ peer_macaddr)) {
return QDF_STATUS_E_FAILURE;
}
+
return QDF_STATUS_SUCCESS;
}
@@ -1026,32 +851,18 @@
struct egap_conf_params *egap_params)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
- wmi_ap_ps_egap_param_cmd_fixed_param *cmd;
- wmi_buf_t buf;
+ wmi_ap_ps_egap_param_cmd_fixed_param cmd = {0};
int32_t err;
- buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
- if (!buf) {
- WMA_LOGE("Failed to allocate buffer to send ap_ps_egap cmd");
- return QDF_STATUS_E_NOMEM;
- }
- cmd = (wmi_ap_ps_egap_param_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_ap_ps_egap_param_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN(
- wmi_ap_ps_egap_param_cmd_fixed_param));
-
- cmd->enable = egap_params->enable;
- cmd->inactivity_time = egap_params->inactivity_time;
- cmd->wait_time = egap_params->wait_time;
- cmd->flags = egap_params->flags;
- err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- sizeof(*cmd), WMI_AP_PS_EGAP_PARAM_CMDID);
+ cmd.enable = egap_params->enable;
+ cmd.inactivity_time = egap_params->inactivity_time;
+ cmd.wait_time = egap_params->wait_time;
+ cmd.flags = egap_params->flags;
+ err = wmi_unified_egap_conf_params_cmd(wma_handle->wmi_handle, &cmd);
if (err) {
- WMA_LOGE("Failed to send ap_ps_egap cmd");
- wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
+
return QDF_STATUS_SUCCESS;
}
@@ -1101,7 +912,7 @@
#endif /* FEATURE_GREEN_AP */
/**
- * wmi_unified_fw_profiling_cmd() - send FW profiling cmd to WLAN FW
+ * wma_unified_fw_profiling_cmd() - send FW profiling cmd to WLAN FW
* @wma: wma handle
* @cmd: Profiling command index
* @value1: parameter1 value
@@ -1109,126 +920,20 @@
*
* Return: 0 for success else error code
*/
-int32_t wmi_unified_fw_profiling_cmd(wmi_unified_t wmi_handle,
+QDF_STATUS wma_unified_fw_profiling_cmd(wmi_unified_t wmi_handle,
uint32_t cmd, uint32_t value1, uint32_t value2)
{
- wmi_buf_t buf;
- int32_t len = 0;
int ret;
- wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd;
- wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd;
- wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd;
- wmi_wlan_profile_get_prof_data_cmd_fixed_param *profile_getdata_cmd;
- switch (cmd) {
- case WMI_WLAN_PROFILE_TRIGGER_CMDID:
- len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param);
- buf = wmi_buf_alloc(wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
- return -ENOMEM;
- }
- prof_trig_cmd =
- (wmi_wlan_profile_trigger_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&prof_trig_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_wlan_profile_trigger_cmd_fixed_param));
- prof_trig_cmd->enable = value1;
- ret = wmi_unified_cmd_send(wmi_handle, buf, len,
- WMI_WLAN_PROFILE_TRIGGER_CMDID);
- if (ret) {
- WMA_LOGE("PROFILE_TRIGGER cmd Failed with value %d",
- value1);
- qdf_nbuf_free(buf);
- return ret;
- }
- break;
-
- case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID:
- len = sizeof(wmi_wlan_profile_get_prof_data_cmd_fixed_param);
- buf = wmi_buf_alloc(wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
- return -ENOMEM;
- }
- profile_getdata_cmd =
- (wmi_wlan_profile_get_prof_data_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&profile_getdata_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_wlan_profile_get_prof_data_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_wlan_profile_get_prof_data_cmd_fixed_param));
- ret = wmi_unified_cmd_send(wmi_handle, buf, len,
- WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID);
- if (ret) {
- WMA_LOGE("PROFILE_DATA cmd Failed for id %d value %d",
- value1, value2);
- qdf_nbuf_free(buf);
- return ret;
- }
- break;
-
- case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID:
- len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param);
- buf = wmi_buf_alloc(wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
- return -ENOMEM;
- }
- hist_intvl_cmd =
- (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param));
- hist_intvl_cmd->profile_id = value1;
- hist_intvl_cmd->value = value2;
- ret = wmi_unified_cmd_send(wmi_handle, buf, len,
- WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID);
- if (ret) {
- WMA_LOGE("HIST_INTVL cmd Failed for id %d value %d",
- value1, value2);
- qdf_nbuf_free(buf);
- return ret;
- }
- break;
-
- case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID:
- len =
- sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param);
- buf = wmi_buf_alloc(wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
- return -ENOMEM;
- }
- profile_enable_cmd =
- (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&profile_enable_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_wlan_profile_enable_profile_id_cmd_fixed_param));
- profile_enable_cmd->profile_id = value1;
- profile_enable_cmd->enable = value2;
- ret = wmi_unified_cmd_send(wmi_handle, buf, len,
- WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
- if (ret) {
- WMA_LOGE("enable cmd Failed for id %d value %d",
- value1, value2);
- qdf_nbuf_free(buf);
- return ret;
- }
- break;
-
- default:
- WMA_LOGD("%s: invalid profiling command", __func__);
- break;
+ ret = wmi_unified_fw_profiling_data_cmd(wmi_handle, cmd,
+ value1, value2);
+ if (ret) {
+ WMA_LOGE("enable cmd Failed for id %d value %d",
+ value1, value2);
+ return ret;
}
- return 0;
+ return QDF_STATUS_SUCCESS;
}
#ifdef FEATURE_WLAN_LPHB
@@ -1292,79 +997,21 @@
static QDF_STATUS wma_wow_sta_ra_filter(tp_wma_handle wma, uint8_t vdev_id)
{
- WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
struct wma_txrx_node *iface;
- wmi_buf_t buf;
- uint8_t *buf_ptr;
- int32_t len;
int ret;
+ uint8_t default_pattern;
iface = &wma->interfaces[vdev_id];
- len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_BITMAP_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
- buf_ptr = (uint8_t *) cmd;
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
- cmd->vdev_id = vdev_id;
- cmd->pattern_id = iface->num_wow_default_patterns++,
- cmd->pattern_type = WOW_IPV6_RA_PATTERN;
- buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for pattern_info_timeout but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for ra_ratelimit_interval. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- *((A_UINT32 *) buf_ptr) = wma->RArateLimitInterval;
+ default_pattern = iface->num_wow_default_patterns++;
WMA_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
wma->RArateLimitInterval, vdev_id);
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_WOW_ADD_WAKE_PATTERN_CMDID);
+ ret = wmi_unified_wow_sta_ra_filter_cmd(wma->wmi_handle, vdev_id,
+ default_pattern, wma->RArateLimitInterval);
if (ret) {
WMA_LOGE("%s: Failed to send RA rate limit to fw", __func__);
- wmi_buf_free(buf);
iface->num_wow_default_patterns--;
return QDF_STATUS_E_FAILURE;
}
@@ -1383,32 +1030,11 @@
*/
int wmi_unified_nat_keepalive_enable(tp_wma_handle wma, uint8_t vdev_id)
{
- WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len = sizeof(*cmd);
- WMA_LOGD("%s: vdev_id %d", __func__, vdev_id);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
- return -ENOMEM;
- }
- cmd = (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param));
- cmd->vdev_id = vdev_id;
- cmd->action = IPSEC_NATKEEPALIVE_FILTER_ENABLE;
- if (wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID)) {
- WMA_LOGP("%s: Failed to send NAT keepalive enable command",
- __func__);
- wmi_buf_free(buf);
- return -EIO;
- }
- return 0;
+ if (wmi_unified_nat_keepalive_en_cmd(wma->wmi_handle, vdev_id))
+ return QDF_STATUS_E_FAILURE;
+
+ return QDF_STATUS_SUCCESS;
}
/**
@@ -1420,30 +1046,13 @@
*/
int wma_unified_csa_offload_enable(tp_wma_handle wma, uint8_t vdev_id)
{
- wmi_csa_offload_enable_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len = sizeof(*cmd);
-
- WMA_LOGD("%s: vdev_id %d", __func__, vdev_id);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
- return -ENOMEM;
- }
- cmd = (wmi_csa_offload_enable_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_csa_offload_enable_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_csa_offload_enable_cmd_fixed_param));
- cmd->vdev_id = vdev_id;
- cmd->csa_offload_enable = WMI_CSA_OFFLOAD_ENABLE;
- if (wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_CSA_OFFLOAD_ENABLE_CMDID)) {
+ if (wmi_unified_csa_offload_enable(wma->wmi_handle,
+ vdev_id)) {
WMA_LOGP("%s: Failed to send CSA offload enable command",
__func__);
- wmi_buf_free(buf);
return -EIO;
}
+
return 0;
}
@@ -1859,8 +1468,6 @@
void wma_start_oem_data_req(tp_wma_handle wma_handle,
tStartOemDataReq *startOemDataReq)
{
- wmi_buf_t buf;
- uint8_t *cmd;
int ret = 0;
tStartOemDataRsp *pStartOemDataRsp;
@@ -1876,30 +1483,12 @@
return;
}
- buf = wmi_buf_alloc(wma_handle->wmi_handle,
- (startOemDataReq->data_len + WMI_TLV_HDR_SIZE));
- if (!buf) {
- WMA_LOGE(FL("wmi_buf_alloc failed"));
- goto out;
- }
-
- cmd = (uint8_t *) wmi_buf_data(buf);
-
- WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE, startOemDataReq->data_len);
- cmd += WMI_TLV_HDR_SIZE;
- qdf_mem_copy(cmd, startOemDataReq->data,
- startOemDataReq->data_len);
-
- WMA_LOGI(FL("Sending OEM Data Request to target, data len %d"),
- startOemDataReq->data_len);
-
- ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf,
- (startOemDataReq->data_len +
- WMI_TLV_HDR_SIZE), WMI_OEM_REQ_CMDID);
+ ret = wmi_unified_start_oem_data_cmd(wma_handle->wmi_handle,
+ startOemDataReq->data_len,
+ startOemDataReq->data);
if (ret != EOK) {
WMA_LOGE(FL(":wmi cmd send failed"));
- qdf_nbuf_free(buf);
}
out:
@@ -2371,10 +1960,6 @@
int
wma_unified_dfs_phyerr_filter_offload_enable(tp_wma_handle wma_handle)
{
- wmi_dfs_phyerr_filter_ena_cmd_fixed_param *enable_phyerr_offload_cmd;
- wmi_dfs_phyerr_filter_dis_cmd_fixed_param *disable_phyerr_offload_cmd;
- wmi_buf_t buf;
- uint16_t len;
int ret;
if (NULL == wma_handle) {
@@ -2382,78 +1967,13 @@
return 0;
}
- if (false == wma_handle->dfs_phyerr_filter_offload) {
- WMA_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
- __func__);
- len = sizeof(*disable_phyerr_offload_cmd);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
- return 0;
- }
- disable_phyerr_offload_cmd =
- (wmi_dfs_phyerr_filter_dis_cmd_fixed_param *)
- wmi_buf_data(buf);
+ ret = wmi_unified_dfs_phyerr_filter_offload_en_cmd(wma_handle->wmi_handle,
+ wma_handle->dfs_phyerr_filter_offload);
+ if (ret)
+ return QDF_STATUS_E_FAILURE;
- WMITLV_SET_HDR(&disable_phyerr_offload_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_dis_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_dfs_phyerr_filter_dis_cmd_fixed_param));
- /*
- * Send WMI_DFS_PHYERR_FILTER_DIS_CMDID
- * to the firmware to disable the phyerror
- * filtering offload.
- */
- ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_DFS_PHYERR_FILTER_DIS_CMDID);
- if (ret < 0) {
- WMA_LOGE("%s: Failed to send WMI_DFS_PHYERR_FILTER_DIS_CMDID ret=%d",
- __func__, ret);
- wmi_buf_free(buf);
- return 0;
- }
- WMA_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success",
- __func__);
- } else {
- WMA_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
- __func__);
-
- len = sizeof(*enable_phyerr_offload_cmd);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
- return 0;
- }
-
- enable_phyerr_offload_cmd =
- (wmi_dfs_phyerr_filter_ena_cmd_fixed_param *)
- wmi_buf_data(buf);
-
- WMITLV_SET_HDR(&enable_phyerr_offload_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_ena_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_dfs_phyerr_filter_ena_cmd_fixed_param));
-
- /*
- * Send a WMI_DFS_PHYERR_FILTER_ENA_CMDID
- * to the firmware to enable the phyerror
- * filtering offload.
- */
- ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_DFS_PHYERR_FILTER_ENA_CMDID);
-
- if (ret < 0) {
- WMA_LOGE("%s: Failed to send WMI_DFS_PHYERR_FILTER_ENA_CMDID ret=%d",
- __func__, ret);
- wmi_buf_free(buf);
- return 0;
- }
- WMA_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success",
- __func__);
- }
-
- return 1;
+ return QDF_STATUS_SUCCESS;
}
#if !defined(REMOVE_PKT_LOG)
@@ -2468,12 +1988,7 @@
struct ath_pktlog_wmi_params *params)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
- WMI_PKTLOG_EVENT PKTLOG_EVENT;
- WMI_CMD_ID CMD_ID;
- wmi_pdev_pktlog_enable_cmd_fixed_param *cmd;
- wmi_pdev_pktlog_disable_cmd_fixed_param *disable_cmd;
- int len = 0;
- wmi_buf_t buf;
+ int ret;
/*Check if packet log is enabled in cfg.ini */
if (!cds_is_packet_log_enabled()) {
@@ -2481,60 +1996,14 @@
return QDF_STATUS_E_FAILURE;
}
- PKTLOG_EVENT = params->pktlog_event;
- CMD_ID = params->cmd_id;
+ ret = wmi_unified_pktlog_wmi_send_cmd(wma_handle->wmi_handle,
+ params->pktlog_event,
+ params->cmd_id);
+ if (ret)
+ return QDF_STATUS_E_FAILURE;
- switch (CMD_ID) {
- case WMI_PDEV_PKTLOG_ENABLE_CMDID:
- len = sizeof(*cmd);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
- cmd = (wmi_pdev_pktlog_enable_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_pdev_pktlog_enable_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_pdev_pktlog_enable_cmd_fixed_param));
- cmd->evlist = PKTLOG_EVENT;
- if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_PDEV_PKTLOG_ENABLE_CMDID)) {
- WMA_LOGE("failed to send pktlog enable cmdid");
- goto wmi_send_failed;
- }
- break;
- case WMI_PDEV_PKTLOG_DISABLE_CMDID:
- len = sizeof(*disable_cmd);
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
- return QDF_STATUS_E_NOMEM;
- }
- disable_cmd = (wmi_pdev_pktlog_disable_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&disable_cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_pdev_pktlog_disable_cmd_fixed_param));
- disable_cmd->pdev_id = 0;
- if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_PDEV_PKTLOG_DISABLE_CMDID)) {
- WMA_LOGE("failed to send pktlog disable cmdid");
- goto wmi_send_failed;
- }
- break;
- default:
- WMA_LOGD("%s: invalid PKTLOG command", __func__);
- break;
- }
return QDF_STATUS_SUCCESS;
-
-wmi_send_failed:
- wmi_buf_free(buf);
- return QDF_STATUS_E_FAILURE;
}
#endif /* REMOVE_PKT_LOG */
@@ -3085,37 +2554,15 @@
uint32_t bitmap,
bool enable)
{
- WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *cmd;
- uint16_t len;
- wmi_buf_t buf;
int ret;
- len = sizeof(WMI_WOW_ADD_DEL_EVT_CMD_fixed_param);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
- cmd = (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_WOW_ADD_DEL_EVT_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param));
- cmd->vdev_id = vdev_id;
- cmd->is_add = enable;
- cmd->event_bitmap = bitmap;
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
+ ret = wmi_unified_add_wow_wakeup_event_cmd(wma->wmi_handle, vdev_id,
+ enable, bitmap);
if (ret) {
WMA_LOGE("Failed to config wow wakeup event");
- wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
- WMA_LOGD("Wakeup pattern 0x%x %s in fw", bitmap,
- enable ? "enabled" : "disabled");
-
return QDF_STATUS_SUCCESS;
}
@@ -3139,118 +2586,17 @@
uint8_t ptrn_offset, const uint8_t *mask,
uint8_t mask_len, bool user)
{
- WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
- WOW_BITMAP_PATTERN_T *bitmap_pattern;
struct wma_txrx_node *iface;
- wmi_buf_t buf;
- uint8_t *buf_ptr;
- int32_t len;
int ret;
+ uint8_t default_patterns;
iface = &wma->interfaces[vdev_id];
-
- len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
- WMI_TLV_HDR_SIZE +
- 1 * sizeof(WOW_BITMAP_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
- WMI_TLV_HDR_SIZE +
- 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
- buf_ptr = (uint8_t *) cmd;
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
- cmd->vdev_id = vdev_id;
- /*
- * For user configured wow pattern use pattern id sent by HDD
- * and for default wow patterns generate pattern id internally
- */
- if (user)
- cmd->pattern_id = ptrn_id;
- else
- cmd->pattern_id = iface->num_wow_default_patterns++;
-
- cmd->pattern_type = WOW_BITMAP_PATTERN;
- buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
-
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
- sizeof(WOW_BITMAP_PATTERN_T));
- buf_ptr += WMI_TLV_HDR_SIZE;
- bitmap_pattern = (WOW_BITMAP_PATTERN_T *) buf_ptr;
-
- WMITLV_SET_HDR(&bitmap_pattern->tlv_header,
- WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T,
- WMITLV_GET_STRUCT_TLVLEN(WOW_BITMAP_PATTERN_T));
-
- qdf_mem_copy(&bitmap_pattern->patternbuf[0], ptrn, ptrn_len);
- qdf_mem_copy(&bitmap_pattern->bitmaskbuf[0], mask, mask_len);
-
- bitmap_pattern->pattern_offset = ptrn_offset;
- bitmap_pattern->pattern_len = ptrn_len;
-
- if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMAP_PATTERN_SIZE)
- bitmap_pattern->pattern_len = WOW_DEFAULT_BITMAP_PATTERN_SIZE;
-
- if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMASK_SIZE)
- bitmap_pattern->pattern_len = WOW_DEFAULT_BITMASK_SIZE;
-
- bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
- bitmap_pattern->pattern_id = ptrn_id;
-
- WMA_LOGI("vdev id : %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
- cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
- bitmap_pattern->pattern_offset, user);
-
- WMA_LOGI("Pattern : ");
- QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_INFO,
- &bitmap_pattern->patternbuf[0], bitmap_pattern->pattern_len);
-
- WMA_LOGI("Mask : ");
- QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_INFO,
- &bitmap_pattern->bitmaskbuf[0], bitmap_pattern->pattern_len);
-
- buf_ptr += sizeof(WOW_BITMAP_PATTERN_T);
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for pattern_info_timeout but no data. */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- /* Fill TLV for ra_ratelimit_interval with dummy data as this fix elem */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(A_UINT32));
- buf_ptr += WMI_TLV_HDR_SIZE;
- *(A_UINT32 *) buf_ptr = 0;
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_WOW_ADD_WAKE_PATTERN_CMDID);
+ default_patterns = iface->num_wow_default_patterns++;
+ ret = wmi_unified_wow_patterns_to_fw_cmd(wma->wmi_handle,
+ vdev_id, ptrn_id, ptrn,
+ ptrn_len, ptrn_offset, mask,
+ mask_len, user, default_patterns);
if (ret) {
- WMA_LOGE("%s: Failed to send wow ptrn to fw", __func__);
- wmi_buf_free(buf);
if (!user)
iface->num_wow_default_patterns--;
return QDF_STATUS_E_FAILURE;
@@ -3652,40 +2998,14 @@
static QDF_STATUS wma_wow_delete_pattern(tp_wma_handle wma, uint8_t ptrn_id,
uint8_t vdev_id, bool user)
{
- WMI_WOW_DEL_PATTERN_CMD_fixed_param *cmd;
+
struct wma_txrx_node *iface;
- wmi_buf_t buf;
- int32_t len;
int ret;
- len = sizeof(WMI_WOW_DEL_PATTERN_CMD_fixed_param);
-
iface = &wma->interfaces[vdev_id];
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- cmd = (WMI_WOW_DEL_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_WOW_DEL_PATTERN_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN(
- WMI_WOW_DEL_PATTERN_CMD_fixed_param));
- cmd->vdev_id = vdev_id;
- cmd->pattern_id = ptrn_id;
- cmd->pattern_type = WOW_BITMAP_PATTERN;
-
- WMA_LOGI("Deleting pattern id: %d vdev id %d in fw",
- cmd->pattern_id, vdev_id);
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_WOW_DEL_WAKE_PATTERN_CMDID);
+ ret = wmi_unified_wow_delete_pattern_cmd(wma->wmi_handle, ptrn_id,
+ vdev_id);
if (ret) {
- WMA_LOGE("%s: Failed to delete wow ptrn from fw", __func__);
- wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
@@ -4192,10 +3512,7 @@
*/
static QDF_STATUS wma_send_host_wakeup_ind_to_fw(tp_wma_handle wma)
{
- wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *cmd;
- wmi_buf_t buf;
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
- int32_t len;
int ret;
#ifdef CONFIG_CNSS
tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
@@ -4205,28 +3522,10 @@
}
#endif /* CONFIG_CNSS */
- len = sizeof(wmi_wow_hostwakeup_from_sleep_cmd_fixed_param);
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- cmd = (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_wow_hostwakeup_from_sleep_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param));
-
qdf_event_reset(&wma->wma_resume_event);
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
+ ret = wmi_unified_host_wakeup_ind_to_fw_cmd(wma->wmi_handle);
if (ret) {
- WMA_LOGE("Failed to send host wakeup indication to fw");
- wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
@@ -4377,36 +3676,17 @@
*/
void wma_del_ts_req(tp_wma_handle wma, tDelTsParams *msg)
{
- wmi_vdev_wmm_delts_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len = sizeof(*cmd);
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
- goto err;
- }
- cmd = (wmi_vdev_wmm_delts_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_vdev_wmm_delts_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_vdev_wmm_delts_cmd_fixed_param));
- cmd->vdev_id = msg->sessionId;
- cmd->ac = TID_TO_WME_AC(msg->userPrio);
-
- WMA_LOGD("Delts vdev:%d, ac:%d, %s:%d",
- cmd->vdev_id, cmd->ac, __FUNCTION__, __LINE__);
- if (wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_VDEV_WMM_DELTS_CMDID)) {
+ if (wmi_unified_del_ts_cmd(wma->wmi_handle,
+ msg->sessionId,
+ TID_TO_WME_AC(msg->userPrio))) {
WMA_LOGP("%s: Failed to send vdev DELTS command", __func__);
- qdf_nbuf_free(buf);
}
+
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (msg->setRICparams == true)
wma_set_ric_req(wma, msg, false);
#endif /* WLAN_FEATURE_ROAM_OFFLOAD */
-err:
qdf_mem_free(msg);
}
@@ -4424,56 +3704,8 @@
void wma_aggr_qos_req(tp_wma_handle wma,
tAggrAddTsParams *pAggrQosRspMsg)
{
- int i = 0;
- wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len = sizeof(*cmd);
-
- for (i = 0; i < HAL_QOS_NUM_AC_MAX; i++) {
- /* if flow in this AC is active */
- if (((1 << i) & pAggrQosRspMsg->tspecIdx)) {
- /*
- * as per implementation of wma_add_ts_req() we
- * are not waiting any response from firmware so
- * apart from sending ADDTS to firmware just send
- * success to upper layers
- */
- pAggrQosRspMsg->status[i] = QDF_STATUS_SUCCESS;
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
- goto aggr_qos_exit;
- }
- cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *)
- wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_vdev_wmm_addts_cmd_fixed_param));
- cmd->vdev_id = pAggrQosRspMsg->sessionId;
- cmd->ac =
- TID_TO_WME_AC(pAggrQosRspMsg->tspec[i].tsinfo.
- traffic.userPrio);
- cmd->medium_time_us =
- pAggrQosRspMsg->tspec[i].mediumTime * 32;
- cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
- WMA_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
- __func__, __LINE__, cmd->vdev_id, cmd->ac,
- cmd->medium_time_us, cmd->downgrade_type);
- if (wmi_unified_cmd_send
- (wma->wmi_handle, buf, len,
- WMI_VDEV_WMM_ADDTS_CMDID)) {
- WMA_LOGP("%s: Failed to send vdev ADDTS command",
- __func__);
- pAggrQosRspMsg->status[i] =
- QDF_STATUS_E_FAILURE;
- qdf_nbuf_free(buf);
- }
- }
- }
-
-aggr_qos_exit:
+ wmi_unified_aggr_qos_cmd(wma->wmi_handle,
+ (struct aggr_add_ts_param *)pAggrQosRspMsg);
/* send reponse to upper layers from here only. */
wma_send_msg(wma, WMA_AGGR_QOS_RSP, pAggrQosRspMsg, 0);
}
@@ -4487,9 +3719,7 @@
*/
void wma_add_ts_req(tp_wma_handle wma, tAddTsParams *msg)
{
- wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len = sizeof(*cmd);
+ struct add_ts_param cmd = {0};
#ifdef FEATURE_WLAN_ESE
/*
@@ -4510,29 +3740,14 @@
#endif /* FEATURE_WLAN_ESE */
msg->status = QDF_STATUS_SUCCESS;
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
- goto err;
- }
- cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_vdev_wmm_addts_cmd_fixed_param));
- cmd->vdev_id = msg->sme_session_id;
- cmd->ac = TID_TO_WME_AC(msg->tspec.tsinfo.traffic.userPrio);
- cmd->medium_time_us = msg->tspec.mediumTime * 32;
- cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
- WMA_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
- cmd->vdev_id, cmd->ac, cmd->medium_time_us,
- cmd->downgrade_type, __func__, __LINE__);
- if (wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_VDEV_WMM_ADDTS_CMDID)) {
- WMA_LOGP("%s: Failed to send vdev ADDTS command", __func__);
+
+ cmd.sme_session_id = msg->sme_session_id;
+ cmd.tspec.tsinfo.traffic.userPrio =
+ TID_TO_WME_AC(msg->tspec.tsinfo.traffic.userPrio);
+ cmd.tspec.mediumTime = msg->tspec.mediumTime;
+ if (wmi_unified_add_ts_cmd(wma->wmi_handle, &cmd))
msg->status = QDF_STATUS_E_FAILURE;
- qdf_nbuf_free(buf);
- }
+
#ifdef WLAN_FEATURE_ROAM_OFFLOAD
if (msg->setRICparams == true)
wma_set_ric_req(wma, msg, true);
@@ -4553,36 +3768,10 @@
static int wma_enable_disable_packet_filter(tp_wma_handle wma,
uint8_t vdev_id, bool enable)
{
- int32_t len;
- int ret = 0;
- wmi_buf_t buf;
- WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *cmd;
+ int ret;
- len = sizeof(WMI_PACKET_FILTER_ENABLE_CMD_fixed_param);
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return -ENOMEM;
- }
-
- cmd = (WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *) wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_packet_filter_enable_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN(
- WMI_PACKET_FILTER_ENABLE_CMD_fixed_param));
-
- cmd->vdev_id = vdev_id;
- if (enable)
- cmd->enable = PACKET_FILTER_SET_ENABLE;
- else
- cmd->enable = PACKET_FILTER_SET_DISABLE;
-
- WMA_LOGE("%s: Packet filter enable %d for vdev_id %d",
- __func__, cmd->enable, vdev_id);
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_PACKET_FILTER_ENABLE_CMDID);
+ ret = wmi_unified_enable_disable_packet_filter_cmd(wma->wmi_handle,
+ vdev_id, enable);
if (ret)
WMA_LOGE("Failed to send packet filter wmi cmd to fw");
@@ -4603,66 +3792,14 @@
uint8_t vdev_id, tSirRcvPktFilterCfgType *rcv_filter_param,
uint8_t filter_id, bool enable)
{
- int len, i;
- int err = 0;
- wmi_buf_t buf;
- WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *cmd;
+ int err;
-
- /* allocate the memory */
- len = sizeof(*cmd);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("Failed to allocate buffer to send set_param cmd");
- return -ENOMEM;
- }
-
- cmd = (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *)wmi_buf_data(buf);
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_packet_filter_config_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param));
-
- cmd->vdev_id = vdev_id;
- cmd->filter_id = filter_id;
- if (enable)
- cmd->filter_action = PACKET_FILTER_SET_ACTIVE;
- else
- cmd->filter_action = PACKET_FILTER_SET_INACTIVE;
-
- if (enable) {
- cmd->num_params = QDF_MIN(
- WMI_PACKET_FILTER_MAX_CMP_PER_PACKET_FILTER,
- rcv_filter_param->numFieldParams);
- cmd->filter_type = rcv_filter_param->filterType;
- cmd->coalesce_time = rcv_filter_param->coalesceTime;
-
- for (i = 0; i < cmd->num_params; i++) {
- cmd->paramsData[i].proto_type =
- rcv_filter_param->paramsData[i].protocolLayer;
- cmd->paramsData[i].cmp_type =
- rcv_filter_param->paramsData[i].cmpFlag;
- cmd->paramsData[i].data_length =
- rcv_filter_param->paramsData[i].dataLength;
- cmd->paramsData[i].data_offset =
- rcv_filter_param->paramsData[i].dataOffset;
- memcpy(&cmd->paramsData[i].compareData,
- rcv_filter_param->paramsData[i].compareData,
- sizeof(cmd->paramsData[i].compareData));
- memcpy(&cmd->paramsData[i].dataMask,
- rcv_filter_param->paramsData[i].dataMask,
- sizeof(cmd->paramsData[i].dataMask));
- }
- }
-
- WMA_LOGE("Packet filter action %d filter with id: %d, num_params=%d",
- cmd->filter_action, cmd->filter_id, cmd->num_params);
/* send the command along with data */
- err = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_PACKET_FILTER_CONFIG_CMDID);
+ err = wmi_unified_config_packet_filter_cmd(wma->wmi_handle,
+ vdev_id, (struct rcv_pkt_filter_config *)rcv_filter_param,
+ filter_id, enable);
if (err) {
WMA_LOGE("Failed to send pkt_filter cmd");
- wmi_buf_free(buf);
return -EIO;
}
@@ -5172,7 +4309,7 @@
* wma_enable_arp_ns_offload() - enable ARP NS offload
* @wma: wma handle
* @tpSirHostOffloadReq: offload request
- * @bArpOnly: flag
+ * @arp_only: flag
*
* To configure ARP NS off load data to firmware
* when target goes to wow mode.
@@ -5181,18 +4318,10 @@
*/
QDF_STATUS wma_enable_arp_ns_offload(tp_wma_handle wma,
tpSirHostOffloadReq
- pHostOffloadParams, bool bArpOnly)
+ pHostOffloadParams, bool arp_only)
{
- int32_t i;
int32_t res;
- WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *cmd;
- WMI_NS_OFFLOAD_TUPLE *ns_tuple;
- WMI_ARP_OFFLOAD_TUPLE *arp_tuple;
- A_UINT8 *buf_ptr;
- wmi_buf_t buf;
- int32_t len;
uint8_t vdev_id;
- uint32_t count = 0, num_ns_ext_tuples = 0;
/* Get the vdev id */
if (!wma_find_vdev_by_bssid(wma, pHostOffloadParams->bssid.bytes,
@@ -5209,174 +4338,13 @@
return QDF_STATUS_E_FAILURE;
}
- if (!bArpOnly)
- count = pHostOffloadParams->num_ns_offload_count;
- len = sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param) + WMI_TLV_HDR_SIZE + /* TLV place holder size for array of NS tuples */
- WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE) + WMI_TLV_HDR_SIZE + /* TLV place holder size for array of ARP tuples */
- WMI_MAX_ARP_OFFLOADS * sizeof(WMI_ARP_OFFLOAD_TUPLE);
-
- /*
- * If there are more than WMI_MAX_NS_OFFLOADS addresses then allocate
- * extra length for extended NS offload tuples which follows ARP offload
- * tuples. Host needs to fill this structure in following format:
- * 2 NS ofload tuples
- * 2 ARP offload tuples
- * N numbers of extended NS offload tuples if HDD has given more than
- * 2 NS offload addresses
- */
- if (!bArpOnly && count > WMI_MAX_NS_OFFLOADS) {
- num_ns_ext_tuples = count - WMI_MAX_NS_OFFLOADS;
- len += WMI_TLV_HDR_SIZE + num_ns_ext_tuples *
- sizeof(WMI_NS_OFFLOAD_TUPLE);
- }
-
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- qdf_mem_free(pHostOffloadParams);
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (A_UINT8 *) wmi_buf_data(buf);
- cmd = (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param));
- cmd->flags = 0;
- cmd->vdev_id = vdev_id;
- if (!bArpOnly)
- cmd->num_ns_ext_tuples = num_ns_ext_tuples;
-
- WMA_LOGD("ARP NS Offload vdev_id: %d", cmd->vdev_id);
-
- /* Have copy of arp info to send along with NS, Since FW expects
- * both ARP and NS info in single cmd */
- if (bArpOnly)
- qdf_mem_copy(&wma->mArpInfo, pHostOffloadParams,
- sizeof(tSirHostOffloadReq));
-
- buf_ptr += sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param);
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
- (WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE)));
- buf_ptr += WMI_TLV_HDR_SIZE;
- for (i = 0; i < WMI_MAX_NS_OFFLOADS; i++) {
- ns_tuple = (WMI_NS_OFFLOAD_TUPLE *) buf_ptr;
- WMITLV_SET_HDR(&ns_tuple->tlv_header,
- WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
- (sizeof(WMI_NS_OFFLOAD_TUPLE) -
- WMI_TLV_HDR_SIZE));
-
- /* Fill data only for NS offload in the first ARP tuple for LA */
- if (!bArpOnly &&
- ((pHostOffloadParams->enableOrDisable & SIR_OFFLOAD_ENABLE))) {
- ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
-
-#ifdef WLAN_NS_OFFLOAD
- /*Copy the target/solicitation/remote ip addr */
- if (pHostOffloadParams->nsOffloadInfo.
- targetIPv6AddrValid[i])
- A_MEMCPY(&ns_tuple->target_ipaddr[0],
- &pHostOffloadParams->nsOffloadInfo.
- targetIPv6Addr[i],
- sizeof(WMI_IPV6_ADDR));
- A_MEMCPY(&ns_tuple->solicitation_ipaddr,
- &pHostOffloadParams->nsOffloadInfo.
- selfIPv6Addr[i], sizeof(WMI_IPV6_ADDR));
- WMA_LOGD("NS solicitedIp: %pI6, targetIp: %pI6",
- &pHostOffloadParams->nsOffloadInfo.selfIPv6Addr[i],
- &pHostOffloadParams->nsOffloadInfo.
- targetIPv6Addr[i]);
-
- /* target MAC is optional, check if it is valid,
- * if this is not valid, the target will use the known
- * local MAC address rather than the tuple
- */
- WMI_CHAR_ARRAY_TO_MAC_ADDR(pHostOffloadParams->
- nsOffloadInfo.self_macaddr.bytes,
- &ns_tuple->target_mac);
-#endif /* WLAN_NS_OFFLOAD */
- if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
- (ns_tuple->target_mac.mac_addr47to32 != 0)) {
- ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
- }
- }
- buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
- }
-
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
- (WMI_MAX_ARP_OFFLOADS * sizeof(WMI_ARP_OFFLOAD_TUPLE)));
- buf_ptr += WMI_TLV_HDR_SIZE;
- for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
- arp_tuple = (WMI_ARP_OFFLOAD_TUPLE *) buf_ptr;
- WMITLV_SET_HDR(&arp_tuple->tlv_header,
- WMITLV_TAG_STRUC_WMI_ARP_OFFLOAD_TUPLE,
- WMITLV_GET_STRUCT_TLVLEN(WMI_ARP_OFFLOAD_TUPLE));
-
- /* Fill data for ARP and NS in the first tupple for LA */
- if ((wma->mArpInfo.enableOrDisable & SIR_OFFLOAD_ENABLE)
- && (i == 0)) {
- /*Copy the target ip addr and flags */
- arp_tuple->flags = WMI_ARPOFF_FLAGS_VALID;
- A_MEMCPY(&arp_tuple->target_ipaddr,
- wma->mArpInfo.params.hostIpv4Addr,
- SIR_IPV4_ADDR_LEN);
- WMA_LOGD("ARPOffload IP4 address: %pI4",
- wma->mArpInfo.params.hostIpv4Addr);
- }
- buf_ptr += sizeof(WMI_ARP_OFFLOAD_TUPLE);
- }
-
- /* Populate extended NS offload tuples */
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
- (num_ns_ext_tuples*sizeof(WMI_NS_OFFLOAD_TUPLE)));
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- if (num_ns_ext_tuples) {
- for (i = WMI_MAX_NS_OFFLOADS; i < count; i++) {
- ns_tuple = (WMI_NS_OFFLOAD_TUPLE *)buf_ptr;
- WMITLV_SET_HDR(&ns_tuple->tlv_header,
- WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
- (sizeof(WMI_NS_OFFLOAD_TUPLE)-WMI_TLV_HDR_SIZE));
-
- /* Fill data only for NS offload in the first ARP tuple for LA */
- if (!bArpOnly &&
- ((pHostOffloadParams->enableOrDisable & SIR_OFFLOAD_ENABLE))) {
- ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
-#ifdef WLAN_NS_OFFLOAD
- /*Copy the target/solicitation/remote ip addr */
- if (pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[i])
- A_MEMCPY(&ns_tuple->target_ipaddr[0],
- &pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[i],
- sizeof(WMI_IPV6_ADDR));
- A_MEMCPY(&ns_tuple->solicitation_ipaddr,
- &pHostOffloadParams->nsOffloadInfo.selfIPv6Addr[i],
- sizeof(WMI_IPV6_ADDR));
- WMA_LOGD("Index %d NS solicitedIp: %pI6, targetIp: %pI6", i,
- &pHostOffloadParams->nsOffloadInfo.selfIPv6Addr[i],
- &pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[i]);
-
- /* target MAC is optional, check if it is valid, if this is not valid,
- * the target will use the known local MAC address rather than the tuple */
- WMI_CHAR_ARRAY_TO_MAC_ADDR(
- pHostOffloadParams->nsOffloadInfo.self_macaddr.bytes,
- &ns_tuple->target_mac);
-#endif
- if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
- (ns_tuple->target_mac.mac_addr47to32 != 0)) {
- ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
- }
- }
- buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
- }
- }
-
- res = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_SET_ARP_NS_OFFLOAD_CMDID);
+ res = wmi_unified_enable_arp_ns_offload_cmd(wma->wmi_handle,
+ (struct host_offload_req_param *)pHostOffloadParams,
+ arp_only,
+ vdev_id);
if (res) {
WMA_LOGE("Failed to enable ARP NDP/NSffload");
- wmi_buf_free(buf);
qdf_mem_free(pHostOffloadParams);
return QDF_STATUS_E_FAILURE;
}
@@ -5677,45 +4645,12 @@
int wma_set_app_type1_params_in_fw(tp_wma_handle wma,
tpSirAppType1Params appType1Params)
{
- wmi_extwow_set_app_type1_params_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- int32_t len;
int ret;
- len = sizeof(wmi_extwow_set_app_type1_params_cmd_fixed_param);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
- return QDF_STATUS_E_NOMEM;
- }
-
- cmd = (wmi_extwow_set_app_type1_params_cmd_fixed_param *)
- wmi_buf_data(buf);
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_extwow_set_app_type1_params_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_extwow_set_app_type1_params_cmd_fixed_param));
-
- cmd->vdev_id = appType1Params->vdev_id;
- WMI_CHAR_ARRAY_TO_MAC_ADDR(appType1Params->wakee_mac_addr.bytes,
- &cmd->wakee_mac);
- qdf_mem_copy(cmd->ident, appType1Params->identification_id, 8);
- cmd->ident_len = appType1Params->id_length;
- qdf_mem_copy(cmd->passwd, appType1Params->password, 16);
- cmd->passwd_len = appType1Params->pass_length;
-
- WMA_LOGD("%s: vdev_id %d wakee_mac_addr %pM "
- "identification_id %.8s id_length %u "
- "password %.16s pass_length %u",
- __func__, cmd->vdev_id, appType1Params->wakee_mac_addr.bytes,
- cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
+ ret = wmi_unified_app_type1_params_in_fw_cmd(wma->wmi_handle,
+ (struct app_type1_params *)appType1Params);
if (ret) {
WMA_LOGE("%s: Failed to set APP TYPE1 PARAMS", __func__);
- wmi_buf_free(buf);
return QDF_STATUS_E_FAILURE;
}
@@ -6016,11 +4951,7 @@
QDF_STATUS wma_set_led_flashing(tp_wma_handle wma_handle,
tSirLedFlashingReq *flashing)
{
- wmi_set_led_flashing_cmd_fixed_param *cmd;
- int status = 0;
- wmi_buf_t buf;
- uint8_t *buf_ptr;
- int32_t len = sizeof(wmi_set_led_flashing_cmd_fixed_param);
+ struct flashing_req_params cmd = {0};
if (!wma_handle || !wma_handle->wmi_handle) {
WMA_LOGE(FL("WMA is closed, can not issue cmd"));
@@ -6030,27 +4961,13 @@
WMA_LOGE(FL("invalid parameter: flashing"));
return QDF_STATUS_E_INVAL;
}
-
- buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!buf) {
- WMA_LOGP(FL("wmi_buf_alloc failed"));
- return -ENOMEM;
- }
- buf_ptr = (uint8_t *) wmi_buf_data(buf);
- cmd = (wmi_set_led_flashing_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_set_led_flashing_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_set_led_flashing_cmd_fixed_param));
- cmd->pattern_id = flashing->pattern_id;
- cmd->led_x0 = flashing->led_x0;
- cmd->led_x1 = flashing->led_x1;
-
- status = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
- WMI_PDEV_SET_LED_FLASHING_CMDID);
+ cmd.req_id = flashing->reqId;
+ cmd.pattern_id = flashing->pattern_id;
+ cmd.led_x0 = flashing->led_x0;
+ cmd.led_x1 = flashing->led_x1;
+ status = wmi_unified_set_led_flashing_cmd(wma_handle->wmi_handle,
+ &cmd);
if (status != EOK) {
- WMA_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
- " returned Error %d", __func__, status);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
@@ -6950,18 +5867,12 @@
tTdlsPeerStateParams *peerStateParams)
{
tp_wma_handle wma_handle = (tp_wma_handle) handle;
- wmi_tdls_peer_update_cmd_fixed_param *cmd;
- wmi_tdls_peer_capabilities *peer_cap;
- wmi_channel *chan_info;
- wmi_buf_t wmi_buf;
- uint8_t *buf_ptr;
uint32_t i;
ol_txrx_pdev_handle pdev;
uint8_t peer_id;
struct ol_txrx_peer_t *peer;
- int32_t len = sizeof(wmi_tdls_peer_update_cmd_fixed_param) +
- sizeof(wmi_tdls_peer_capabilities);
int ret = 0;
+ uint32_t *ch_mhz;
if (!wma_handle || !wma_handle->wmi_handle) {
WMA_LOGE("%s: WMA is closed, can not issue cmd", __func__);
@@ -6975,165 +5886,25 @@
sizeof(tTdlsPeerCapParams));
}
- len += WMI_TLV_HDR_SIZE +
- sizeof(wmi_channel) * peerStateParams->peerCap.peerChanLen;
-
- wmi_buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
- if (!wmi_buf) {
- WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
- ret = ENOMEM;
- goto end_tdls_peer_state;
- }
-
- buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
- cmd = (wmi_tdls_peer_update_cmd_fixed_param *) buf_ptr;
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_tdls_peer_update_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN
- (wmi_tdls_peer_update_cmd_fixed_param));
-
- cmd->vdev_id = peerStateParams->vdevId;
- WMI_CHAR_ARRAY_TO_MAC_ADDR(peerStateParams->peerMacAddr,
- &cmd->peer_macaddr);
-
- switch (peerStateParams->peerState) {
- case WMA_TDLS_PEER_STATE_PEERING:
- cmd->peer_state = WMI_TDLS_PEER_STATE_PEERING;
- break;
- case WMA_TDLS_PEER_STATE_CONNECTED:
- cmd->peer_state = WMI_TDLS_PEER_STATE_CONNECTED;
- break;
- case WMA_TDLS_PEER_STATE_TEARDOWN:
- cmd->peer_state = WMI_TDLS_PEER_STATE_TEARDOWN;
- break;
- case WMA_TDLS_PEER_ADD_MAC_ADDR:
- cmd->peer_state = WMI_TDLS_PEER_ADD_MAC_ADDR;
- break;
- case WMA_TDLS_PEER_REMOVE_MAC_ADDR:
- cmd->peer_state = WMI_TDLS_PEER_REMOVE_MAC_ADDR;
- break;
- }
-
- WMA_LOGD("%s: vdev_id: %d, peerStateParams->peerMacAddr: %pM, "
- "peer_macaddr.mac_addr31to0: 0x%x, "
- "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
- __func__, cmd->vdev_id, peerStateParams->peerMacAddr,
- cmd->peer_macaddr.mac_addr31to0,
- cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
-
- buf_ptr += sizeof(wmi_tdls_peer_update_cmd_fixed_param);
- peer_cap = (wmi_tdls_peer_capabilities *) buf_ptr;
- WMITLV_SET_HDR(&peer_cap->tlv_header,
- WMITLV_TAG_STRUC_wmi_tdls_peer_capabilities,
- WMITLV_GET_STRUCT_TLVLEN(wmi_tdls_peer_capabilities));
-
- if ((peerStateParams->peerCap.peerUapsdQueue & 0x08) >> 3)
- WMI_SET_TDLS_PEER_VO_UAPSD(peer_cap);
- if ((peerStateParams->peerCap.peerUapsdQueue & 0x04) >> 2)
- WMI_SET_TDLS_PEER_VI_UAPSD(peer_cap);
- if ((peerStateParams->peerCap.peerUapsdQueue & 0x02) >> 1)
- WMI_SET_TDLS_PEER_BK_UAPSD(peer_cap);
- if (peerStateParams->peerCap.peerUapsdQueue & 0x01)
- WMI_SET_TDLS_PEER_BE_UAPSD(peer_cap);
-
- /* Ack and More Data Ack are sent as 0, so no need to set
- * but fill SP
- */
- WMI_SET_TDLS_PEER_SP_UAPSD(peer_cap,
- peerStateParams->peerCap.peerMaxSp);
-
- peer_cap->buff_sta_support =
- peerStateParams->peerCap.peerBuffStaSupport;
- peer_cap->off_chan_support =
- peerStateParams->peerCap.peerOffChanSupport;
- peer_cap->peer_curr_operclass =
- peerStateParams->peerCap.peerCurrOperClass;
- /* self curr operclass is not being used and so pass op class for
- * preferred off chan in it.
- */
- peer_cap->self_curr_operclass =
- peerStateParams->peerCap.opClassForPrefOffChan;
- peer_cap->peer_chan_len = peerStateParams->peerCap.peerChanLen;
- peer_cap->peer_operclass_len =
- peerStateParams->peerCap.peerOperClassLen;
-
- WMA_LOGD("%s: peer_operclass_len: %d",
- __func__, peer_cap->peer_operclass_len);
- for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
- peer_cap->peer_operclass[i] =
- peerStateParams->peerCap.peerOperClass[i];
- WMA_LOGD("%s: peer_operclass[%d]: %d",
- __func__, i, peer_cap->peer_operclass[i]);
- }
-
- peer_cap->is_peer_responder = peerStateParams->peerCap.isPeerResponder;
- peer_cap->pref_offchan_num = peerStateParams->peerCap.prefOffChanNum;
- peer_cap->pref_offchan_bw =
- peerStateParams->peerCap.prefOffChanBandwidth;
-
- WMA_LOGD
- ("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: %d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num: %d, pref_offchan_bw: %d",
- __func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
- peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
- peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
- peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
- peer_cap->pref_offchan_num, peer_cap->pref_offchan_bw);
-
- /* next fill variable size array of peer chan info */
- buf_ptr += sizeof(wmi_tdls_peer_capabilities);
- WMITLV_SET_HDR(buf_ptr,
- WMITLV_TAG_ARRAY_STRUC,
- sizeof(wmi_channel) *
- peerStateParams->peerCap.peerChanLen);
- chan_info = (wmi_channel *) (buf_ptr + WMI_TLV_HDR_SIZE);
-
+ ch_mhz = qdf_mem_malloc(sizeof(uint32_t) *
+ peerStateParams->peerCap.peerChanLen);
for (i = 0; i < peerStateParams->peerCap.peerChanLen; ++i) {
- WMITLV_SET_HDR(&chan_info->tlv_header,
- WMITLV_TAG_STRUC_wmi_channel,
- WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
- chan_info->mhz =
+ ch_mhz[i] =
cds_chan_to_freq(peerStateParams->peerCap.peerChan[i].
chanId);
- chan_info->band_center_freq1 = chan_info->mhz;
- chan_info->band_center_freq2 = 0;
-
- WMA_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
-
- if (peerStateParams->peerCap.peerChan[i].dfsSet) {
- WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
- WMA_LOGI("chan[%d] DFS[%d]\n",
- peerStateParams->peerCap.peerChan[i].chanId,
- peerStateParams->peerCap.peerChan[i].dfsSet);
- }
-
- if (chan_info->mhz < WMA_2_4_GHZ_MAX_FREQ) {
- WMI_SET_CHANNEL_MODE(chan_info, MODE_11G);
- } else {
- WMI_SET_CHANNEL_MODE(chan_info, MODE_11A);
- }
-
- WMI_SET_CHANNEL_MAX_TX_POWER(chan_info,
- peerStateParams->peerCap.
- peerChan[i].pwr);
-
- WMI_SET_CHANNEL_REG_POWER(chan_info,
- peerStateParams->peerCap.peerChan[i].
- pwr);
- WMA_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
- peerStateParams->peerCap.peerChan[i].pwr);
-
- chan_info++;
}
- if (wmi_unified_cmd_send(wma_handle->wmi_handle, wmi_buf, len,
- WMI_TDLS_PEER_UPDATE_CMDID)) {
+ if (wmi_unified_update_tdls_peer_state_cmd(wma_handle->wmi_handle,
+ (struct tdls_peer_state_params *)peerStateParams,
+ ch_mhz)) {
WMA_LOGE("%s: failed to send tdls peer update state command",
__func__);
- qdf_nbuf_free(wmi_buf);
+ qdf_mem_free(ch_mhz);
ret = -EIO;
goto end_tdls_peer_state;
}
+ qdf_mem_free(ch_mhz);
/* in case of teardown, remove peer from fw */
if (WMA_TDLS_PEER_STATE_TEARDOWN == peerStateParams->peerState) {
pdev = cds_get_context(QDF_MODULE_ID_TXRX);
@@ -7596,87 +6367,18 @@
QDF_STATUS wma_process_fw_mem_dump_req(tp_wma_handle wma,
struct fw_dump_req *mem_dump_req)
{
- wmi_get_fw_mem_dump_fixed_param *cmd;
- wmi_fw_mem_dump *dump_params;
- struct fw_dump_seg_req *seg_req;
- int32_t len;
- wmi_buf_t buf;
- u_int8_t *buf_ptr;
- int ret, loop;
+ int ret;
if (!mem_dump_req || !wma) {
WMA_LOGE(FL("input pointer is NULL"));
return QDF_STATUS_E_FAILURE;
}
- /*
- * len = sizeof(fixed param) that includes tlv header +
- * tlv header for array of struc +
- * sizeof (each struct)
- */
- len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
- len += mem_dump_req->num_seg * sizeof(wmi_fw_mem_dump);
- buf = wmi_buf_alloc(wma->wmi_handle, len);
-
- if (!buf) {
- WMA_LOGE(FL("Failed allocate wmi buffer"));
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = (u_int8_t *) wmi_buf_data(buf);
- qdf_mem_zero(buf_ptr, len);
- cmd = (wmi_get_fw_mem_dump_fixed_param *) buf_ptr;
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_get_fw_mem_dump_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN(wmi_get_fw_mem_dump_fixed_param));
-
- cmd->request_id = mem_dump_req->request_id;
- cmd->num_fw_mem_dump_segs = mem_dump_req->num_seg;
-
- /* TLV indicating array of structures to follow */
- buf_ptr += sizeof(wmi_get_fw_mem_dump_fixed_param);
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
- sizeof(wmi_fw_mem_dump) *
- cmd->num_fw_mem_dump_segs);
-
- buf_ptr += WMI_TLV_HDR_SIZE;
- dump_params = (wmi_fw_mem_dump *) buf_ptr;
-
- WMA_LOGI(FL("request_id:%d num_seg:%d"),
- mem_dump_req->request_id, mem_dump_req->num_seg);
- for (loop = 0; loop < cmd->num_fw_mem_dump_segs; loop++) {
- seg_req = (struct fw_dump_seg_req *)
- ((uint8_t *)(mem_dump_req->segment) +
- loop * sizeof(*seg_req));
- WMITLV_SET_HDR(&dump_params->tlv_header,
- WMITLV_TAG_STRUC_wmi_fw_mem_dump_params,
- WMITLV_GET_STRUCT_TLVLEN(wmi_fw_mem_dump));
- dump_params->seg_id = seg_req->seg_id;
- dump_params->seg_start_addr_lo = seg_req->seg_start_addr_lo;
- dump_params->seg_start_addr_hi = seg_req->seg_start_addr_hi;
- dump_params->seg_length = seg_req->seg_length;
- dump_params->dest_addr_lo = seg_req->dst_addr_lo;
- dump_params->dest_addr_hi = seg_req->dst_addr_hi;
- WMA_LOGI(FL("seg_number:%d"), loop);
- WMA_LOGI(FL("seg_id:%d start_addr_lo:0x%x start_addr_hi:0x%x"),
- dump_params->seg_id, dump_params->seg_start_addr_lo,
- dump_params->seg_start_addr_hi);
- WMA_LOGI(FL("seg_length:%d dst_addr_lo:0x%x dst_addr_hi:0x%x"),
- dump_params->seg_length, dump_params->dest_addr_lo,
- dump_params->dest_addr_hi);
- dump_params++;
- }
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_GET_FW_MEM_DUMP_CMDID);
- if (ret) {
- WMA_LOGE(FL("Failed to send get firmware mem dump request"));
- wmi_buf_free(buf);
+ ret = wmi_unified_process_fw_mem_dump_cmd(wma->wmi_handle,
+ (struct fw_dump_req_param *) mem_dump_req);
+ if (ret)
return QDF_STATUS_E_FAILURE;
- }
- WMA_LOGI(FL("Get firmware mem dump request sent successfully"));
return QDF_STATUS_SUCCESS;
}
@@ -7776,10 +6478,7 @@
QDF_STATUS wma_process_set_ie_info(tp_wma_handle wma,
struct vdev_ie_info *ie_info)
{
- wmi_vdev_set_ie_cmd_fixed_param *cmd;
- wmi_buf_t buf;
- uint8_t *buf_ptr;
- uint32_t len, ie_len_aligned;
+ struct vdev_ie_info_param cmd = {0};
int ret;
if (!ie_info || !wma) {
@@ -7793,45 +6492,13 @@
return QDF_STATUS_E_INVAL;
}
- ie_len_aligned = roundup(ie_info->length, sizeof(uint32_t));
- /* Allocate memory for the WMI command */
- len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + ie_len_aligned;
+ cmd.vdev_id = ie_info->vdev_id;
+ cmd.ie_id = ie_info->ie_id;
+ cmd.length = ie_info->length;
+ cmd.data = ie_info->data;
- buf = wmi_buf_alloc(wma->wmi_handle, len);
- if (!buf) {
- WMA_LOGE(FL("wmi_buf_alloc failed"));
- return QDF_STATUS_E_NOMEM;
- }
-
- buf_ptr = wmi_buf_data(buf);
- qdf_mem_zero(buf_ptr, len);
-
- /* Populate the WMI command */
- cmd = (wmi_vdev_set_ie_cmd_fixed_param *)buf_ptr;
-
- WMITLV_SET_HDR(&cmd->tlv_header,
- WMITLV_TAG_STRUC_wmi_vdev_set_ie_cmd_fixed_param,
- WMITLV_GET_STRUCT_TLVLEN(
- wmi_vdev_set_ie_cmd_fixed_param));
- cmd->vdev_id = ie_info->vdev_id;
- cmd->ie_id = ie_info->ie_id;
- cmd->ie_len = ie_info->length;
-
- WMA_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
- ie_info->length, ie_info->vdev_id);
-
- buf_ptr += sizeof(*cmd);
- WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
- buf_ptr += WMI_TLV_HDR_SIZE;
-
- qdf_mem_copy(buf_ptr, ie_info->data, cmd->ie_len);
-
- ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
- WMI_VDEV_SET_IE_CMDID);
- if (ret != EOK) {
- WMA_LOGE(FL("Failed to send set IE command ret = %d"), ret);
- wmi_buf_free(buf);
- }
+ ret = wmi_unified_process_set_ie_info_cmd(wma->wmi_handle,
+ &cmd);
return ret;
}