blob: 0490e9208e00c61c9797af56a5bde9f1cbe9f1e2 [file] [log] [blame]
Govind Singh5eb51532016-03-09 11:34:12 +05301/*
Paul Zhangd19abd82017-01-04 16:45:42 +08002 * Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
Govind Singh5eb51532016-03-09 11:34:12 +05303 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
26 */
Govind Singh5eb51532016-03-09 11:34:12 +053027#include "wmi_unified_priv.h"
Govind Singh5eb51532016-03-09 11:34:12 +053028#include "wmi_unified_param.h"
29
30/**
31 * wmi_unified_vdev_create_send() - send VDEV create command to fw
32 * @wmi_handle: wmi handle
33 * @param: pointer to hold vdev create parameter
34 * @macaddr: vdev mac address
35 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +053036 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +053037 */
Govind Singhb53420c2016-03-09 14:32:57 +053038QDF_STATUS wmi_unified_vdev_create_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +053039 uint8_t macaddr[IEEE80211_ADDR_LEN],
40 struct vdev_create_params *param)
41{
42 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
43
44 if (wmi_handle->ops->send_vdev_create_cmd)
45 return wmi_handle->ops->send_vdev_create_cmd(wmi_handle,
46 macaddr, param);
47
Govind Singhb53420c2016-03-09 14:32:57 +053048 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +053049}
50
51/**
52 * wmi_unified_vdev_delete_send() - send VDEV delete command to fw
53 * @wmi_handle: wmi handle
54 * @if_id: vdev id
55 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +053056 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +053057 */
Govind Singhb53420c2016-03-09 14:32:57 +053058QDF_STATUS wmi_unified_vdev_delete_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +053059 uint8_t if_id)
60{
61 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
62
63 if (wmi_handle->ops->send_vdev_delete_cmd)
64 return wmi_handle->ops->send_vdev_delete_cmd(wmi_handle,
65 if_id);
66
Govind Singhb53420c2016-03-09 14:32:57 +053067 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +053068}
69
70/**
71 * wmi_unified_vdev_stop_send() - send vdev stop command to fw
72 * @wmi: wmi handle
73 * @vdev_id: vdev id
74 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +053075 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +053076 */
Govind Singhb53420c2016-03-09 14:32:57 +053077QDF_STATUS wmi_unified_vdev_stop_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +053078 uint8_t vdev_id)
79{
80 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
81
82 if (wmi_handle->ops->send_vdev_stop_cmd)
83 return wmi_handle->ops->send_vdev_stop_cmd(wmi_handle,
84 vdev_id);
85
Govind Singhb53420c2016-03-09 14:32:57 +053086 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +053087}
88
89/**
90 * wmi_unified_vdev_down_send() - send vdev down command to fw
91 * @wmi: wmi handle
92 * @vdev_id: vdev id
93 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +053094 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +053095 */
Govind Singhb53420c2016-03-09 14:32:57 +053096QDF_STATUS wmi_unified_vdev_down_send(void *wmi_hdl, uint8_t vdev_id)
Govind Singh5eb51532016-03-09 11:34:12 +053097{
98 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
99
100 if (wmi_handle->ops->send_vdev_down_cmd)
101 return wmi_handle->ops->send_vdev_down_cmd(wmi_handle, vdev_id);
102
Govind Singhb53420c2016-03-09 14:32:57 +0530103 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530104}
105
106/**
Himanshu Agarwal0007b762016-03-09 16:49:38 +0530107 * wmi_unified_vdev_start_send() - send vdev start command to fw
108 * @wmi: wmi handle
109 * @vdev_id: vdev id
110 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530111 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwal0007b762016-03-09 16:49:38 +0530112 */
113QDF_STATUS wmi_unified_vdev_start_send(void *wmi_hdl,
114 struct vdev_start_params *req)
115{
116 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
117
118 if (wmi_handle->ops->send_vdev_start_cmd)
119 return wmi_handle->ops->send_vdev_start_cmd(wmi_handle, req);
120
121 return QDF_STATUS_E_FAILURE;
122}
123
124/**
125 * wmi_unified_hidden_ssid_vdev_restart_send() - restart vdev to set hidden ssid
126 * @wmi: wmi handle
127 * @restart_params: vdev restart params
128 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530129 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwal0007b762016-03-09 16:49:38 +0530130 */
131QDF_STATUS wmi_unified_hidden_ssid_vdev_restart_send(void *wmi_hdl,
132 struct hidden_ssid_vdev_restart_params *restart_params)
133{
134 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
135
136 if (wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd)
137 return wmi_handle->ops->send_hidden_ssid_vdev_restart_cmd(
138 wmi_handle, restart_params);
139
140 return QDF_STATUS_E_FAILURE;
141}
142
143/**
Govind Singh5eb51532016-03-09 11:34:12 +0530144 * wmi_unified_peer_flush_tids_send() - flush peer tids packets in fw
145 * @wmi: wmi handle
146 * @peer_addr: peer mac address
147 * @param: pointer to hold peer flush tid parameter
148 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530149 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530150 */
Govind Singhb53420c2016-03-09 14:32:57 +0530151QDF_STATUS wmi_unified_peer_flush_tids_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530152 uint8_t peer_addr[IEEE80211_ADDR_LEN],
153 struct peer_flush_params *param)
154{
155 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
156
157 if (wmi_handle->ops->send_peer_flush_tids_cmd)
158 return wmi_handle->ops->send_peer_flush_tids_cmd(wmi_handle,
159 peer_addr, param);
160
Govind Singhb53420c2016-03-09 14:32:57 +0530161 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530162}
163
164/**
165 * wmi_unified_peer_delete_send() - send PEER delete command to fw
166 * @wmi: wmi handle
167 * @peer_addr: peer mac addr
168 * @vdev_id: vdev id
169 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530170 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530171 */
Govind Singhb53420c2016-03-09 14:32:57 +0530172QDF_STATUS wmi_unified_peer_delete_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530173 uint8_t
174 peer_addr[IEEE80211_ADDR_LEN],
175 uint8_t vdev_id)
176{
177 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
178
179 if (wmi_handle->ops->send_peer_delete_cmd)
180 return wmi_handle->ops->send_peer_delete_cmd(wmi_handle,
181 peer_addr, vdev_id);
182
Govind Singhb53420c2016-03-09 14:32:57 +0530183 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530184}
185
186/**
187 * wmi_set_peer_param() - set peer parameter in fw
188 * @wmi_ctx: wmi handle
189 * @peer_addr: peer mac address
190 * @param : pointer to hold peer set parameter
191 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530192 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530193 */
Govind Singhb53420c2016-03-09 14:32:57 +0530194QDF_STATUS wmi_set_peer_param_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530195 uint8_t peer_addr[IEEE80211_ADDR_LEN],
196 struct peer_set_params *param)
197{
198 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
199
200 if (wmi_handle->ops->send_peer_param_cmd)
201 return wmi_handle->ops->send_peer_param_cmd(wmi_handle,
202 peer_addr, param);
203
Govind Singhb53420c2016-03-09 14:32:57 +0530204 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530205}
206
207/**
208 * wmi_unified_vdev_up_send() - send vdev up command in fw
209 * @wmi: wmi handle
210 * @bssid: bssid
211 * @vdev_up_params: pointer to hold vdev up parameter
212 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530213 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530214 */
Govind Singhb53420c2016-03-09 14:32:57 +0530215QDF_STATUS wmi_unified_vdev_up_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530216 uint8_t bssid[IEEE80211_ADDR_LEN],
217 struct vdev_up_params *params)
218{
219 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
220
221 if (wmi_handle->ops->send_vdev_up_cmd)
222 return wmi_handle->ops->send_vdev_up_cmd(wmi_handle, bssid,
223 params);
224
Govind Singhb53420c2016-03-09 14:32:57 +0530225 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530226}
227
228/**
229 * wmi_unified_peer_create_send() - send peer create command to fw
230 * @wmi: wmi handle
231 * @peer_addr: peer mac address
232 * @peer_type: peer type
233 * @vdev_id: vdev id
234 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530235 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530236 */
Govind Singhb53420c2016-03-09 14:32:57 +0530237QDF_STATUS wmi_unified_peer_create_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530238 struct peer_create_params *param)
239{
240 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
241
242 if (wmi_handle->ops->send_peer_create_cmd)
243 return wmi_handle->ops->send_peer_create_cmd(wmi_handle, param);
244
Govind Singhb53420c2016-03-09 14:32:57 +0530245 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530246}
247
Leo Changeee40872016-09-28 13:43:36 -0700248/**
249 * wmi_unified_peer_rx_reorder_queue_setup_send() - send rx reorder queue
250 * setup command to fw
251 * @wmi: wmi handle
252 * @rx_reorder_queue_setup_params: Rx reorder queue setup parameters
253 *
254 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure
255 */
256QDF_STATUS wmi_unified_peer_rx_reorder_queue_setup_send(void *wmi_hdl,
257 struct rx_reorder_queue_setup_params *param)
258{
259 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
260
261 if (wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd)
262 return wmi_handle->ops->send_peer_rx_reorder_queue_setup_cmd(
263 wmi_handle, param);
264
265 return QDF_STATUS_E_FAILURE;
266}
267
268/**
269 * wmi_unified_peer_rx_reorder_queue_remove_send() - send rx reorder queue
270 * remove command to fw
271 * @wmi: wmi handle
272 * @rx_reorder_queue_remove_params: Rx reorder queue remove parameters
273 *
274 * Return: QDF_STATUS for success and QDF_STATUS_E_FAILURE for failure
275 */
276QDF_STATUS wmi_unified_peer_rx_reorder_queue_remove_send(void *wmi_hdl,
277 struct rx_reorder_queue_remove_params *param)
278{
279 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
280
281 if (wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd)
282 return wmi_handle->ops->send_peer_rx_reorder_queue_remove_cmd(
283 wmi_handle, param);
284
285 return QDF_STATUS_E_FAILURE;
286}
287
Sathish Kumar01b7ac02016-10-04 14:28:00 +0530288#if defined(FEATURE_GREEN_AP) || defined(ATH_SUPPORT_GREEN_AP)
Govind Singh5eb51532016-03-09 11:34:12 +0530289/**
290 * wmi_unified_green_ap_ps_send() - enable green ap powersave command
291 * @wmi_handle: wmi handle
292 * @value: value
293 * @mac_id: mac id to have radio context
294 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530295 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530296 */
Govind Singhb53420c2016-03-09 14:32:57 +0530297QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530298 uint32_t value, uint8_t mac_id)
299{
300 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
301
302 if (wmi_handle->ops->send_green_ap_ps_cmd)
303 return wmi_handle->ops->send_green_ap_ps_cmd(wmi_handle, value,
304 mac_id);
305
Govind Singhb53420c2016-03-09 14:32:57 +0530306 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530307}
308#else
Govind Singhb53420c2016-03-09 14:32:57 +0530309QDF_STATUS wmi_unified_green_ap_ps_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530310 uint32_t value, uint8_t mac_id)
311{
312 return 0;
313}
Sathish Kumar01b7ac02016-10-04 14:28:00 +0530314#endif /* FEATURE_GREEN_AP or ATH_SUPPORT_GREEN_AP*/
Govind Singh5eb51532016-03-09 11:34:12 +0530315
316/**
317 * wmi_unified_pdev_utf_cmd() - send utf command to fw
318 * @wmi_handle: wmi handle
319 * @param: pointer to pdev_utf_params
320 * @mac_id: mac id to have radio context
321 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530322 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530323 */
Govind Singhb53420c2016-03-09 14:32:57 +0530324QDF_STATUS
Govind Singh5eb51532016-03-09 11:34:12 +0530325wmi_unified_pdev_utf_cmd_send(void *wmi_hdl,
326 struct pdev_utf_params *param,
327 uint8_t mac_id)
328{
329 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
330
331 if (wmi_handle->ops->send_pdev_utf_cmd)
332 return wmi_handle->ops->send_pdev_utf_cmd(wmi_handle, param,
333 mac_id);
334
Govind Singhb53420c2016-03-09 14:32:57 +0530335 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530336}
337
338/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530339 * wmi_unified_pdev_param_send() - set pdev parameters
Govind Singh5eb51532016-03-09 11:34:12 +0530340 * @wmi_handle: wmi handle
341 * @param: pointer to pdev parameter
342 * @mac_id: radio context
343 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530344 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
345 * errno on failure
Govind Singh5eb51532016-03-09 11:34:12 +0530346 */
Govind Singhb53420c2016-03-09 14:32:57 +0530347QDF_STATUS
Govind Singh5eb51532016-03-09 11:34:12 +0530348wmi_unified_pdev_param_send(void *wmi_hdl,
349 struct pdev_params *param,
350 uint8_t mac_id)
351{
352 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
353
354 if (wmi_handle->ops->send_pdev_param_cmd)
355 return wmi_handle->ops->send_pdev_param_cmd(wmi_handle, param,
356 mac_id);
357
Govind Singhb53420c2016-03-09 14:32:57 +0530358 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530359}
360
361/**
362 * wmi_unified_suspend_send() - WMI suspend function
363 * @param wmi_handle : handle to WMI.
364 * @param param : pointer to hold suspend parameter
365 * @mac_id: radio context
366 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530367 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530368 */
Govind Singhb53420c2016-03-09 14:32:57 +0530369QDF_STATUS wmi_unified_suspend_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530370 struct suspend_params *param,
371 uint8_t mac_id)
372{
373 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
374
375 if (wmi_handle->ops->send_suspend_cmd)
376 return wmi_handle->ops->send_suspend_cmd(wmi_handle, param,
377 mac_id);
378
Govind Singhb53420c2016-03-09 14:32:57 +0530379 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530380}
381
382/**
383 * wmi_unified_resume_send - WMI resume function
384 * @param wmi_handle : handle to WMI.
385 * @mac_id: radio context
386 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530387 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530388 */
Govind Singhb53420c2016-03-09 14:32:57 +0530389QDF_STATUS wmi_unified_resume_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530390 uint8_t mac_id)
391{
392 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
393
394 if (wmi_handle->ops->send_resume_cmd)
395 return wmi_handle->ops->send_resume_cmd(wmi_handle,
396 mac_id);
397
Govind Singhb53420c2016-03-09 14:32:57 +0530398 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530399}
400
401/**
402 * wmi_unified_wow_enable_send() - WMI wow enable function
403 * @param wmi_handle : handle to WMI.
404 * @param param : pointer to hold wow enable parameter
405 * @mac_id: radio context
406 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530407 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530408 */
Govind Singhb53420c2016-03-09 14:32:57 +0530409QDF_STATUS wmi_unified_wow_enable_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530410 struct wow_cmd_params *param,
411 uint8_t mac_id)
412{
413 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
414
415 if (wmi_handle->ops->send_wow_enable_cmd)
416 return wmi_handle->ops->send_wow_enable_cmd(wmi_handle, param,
417 mac_id);
418
Govind Singhb53420c2016-03-09 14:32:57 +0530419 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530420}
421
422/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530423 * wmi_unified_wow_wakeup_send() - WMI wow wakeup function
424 * @param wmi_hdl : handle to WMI.
425 *
426 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
427 */
428QDF_STATUS wmi_unified_wow_wakeup_send(void *wmi_hdl)
429{
430 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
431
432 if (wmi_handle->ops->send_wow_wakeup_cmd)
433 return wmi_handle->ops->send_wow_wakeup_cmd(wmi_handle);
434
435 return QDF_STATUS_E_FAILURE;
436}
437
438/**
439 * wmi_unified_wow_add_wakeup_event_send() - WMI wow wakeup function
440 * @param wmi_handle : handle to WMI.
441 * @param: pointer to wow wakeup event parameter structure
442 *
443 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
444 */
445QDF_STATUS wmi_unified_wow_add_wakeup_event_send(void *wmi_hdl,
446 struct wow_add_wakeup_params *param)
447{
448 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
449
450 if (wmi->ops->send_wow_add_wakeup_event_cmd)
451 return wmi->ops->send_wow_add_wakeup_event_cmd(wmi,
452 param);
453
454 return QDF_STATUS_E_FAILURE;
455}
456
457/**
458 * wmi_unified_wow_add_wakeup_pattern_send() - WMI wow wakeup pattern function
459 * @param wmi_handle : handle to WMI.
460 * @param: pointer to wow wakeup pattern parameter structure
461 *
462 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
463 */
464QDF_STATUS wmi_unified_wow_add_wakeup_pattern_send(void *wmi_hdl,
465 struct wow_add_wakeup_pattern_params *param)
466{
467 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
468
469 if (wmi->ops->send_wow_add_wakeup_pattern_cmd)
470 return wmi->ops->send_wow_add_wakeup_pattern_cmd(wmi, param);
471
472 return QDF_STATUS_E_FAILURE;
473}
474
475/**
476 * wmi_unified_wow_remove_wakeup_pattern_send() - WMI wow wakeup pattern function
477 * @param wmi_handle : handle to WMI.
478 * @param: pointer to wow wakeup pattern parameter structure
479 *
480 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
481 */
482QDF_STATUS wmi_unified_wow_remove_wakeup_pattern_send(void *wmi_hdl,
483 struct wow_remove_wakeup_pattern_params *param)
484{
485 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
486
487 if (wmi->ops->send_wow_remove_wakeup_pattern_cmd)
488 return wmi->ops->send_wow_remove_wakeup_pattern_cmd(wmi, param);
489
490 return QDF_STATUS_E_FAILURE;
491}
492
493/**
Govind Singh5eb51532016-03-09 11:34:12 +0530494 * wmi_unified_ap_ps_cmd_send() - set ap powersave parameters
495 * @wma_ctx: wma context
496 * @peer_addr: peer mac address
497 * @param: pointer to ap_ps parameter structure
498 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530499 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530500 */
Govind Singhb53420c2016-03-09 14:32:57 +0530501QDF_STATUS wmi_unified_ap_ps_cmd_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530502 uint8_t *peer_addr,
503 struct ap_ps_params *param)
504{
505 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
506
507 if (wmi_handle->ops->send_set_ap_ps_param_cmd)
508 return wmi_handle->ops->send_set_ap_ps_param_cmd(wmi_handle,
509 peer_addr,
510 param);
511
Govind Singhb53420c2016-03-09 14:32:57 +0530512 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530513}
514
515/**
516 * wmi_unified_sta_ps_cmd_send() - set sta powersave parameters
517 * @wma_ctx: wma context
518 * @peer_addr: peer mac address
519 * @param: pointer to sta_ps parameter structure
520 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530521 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530522 */
Govind Singhb53420c2016-03-09 14:32:57 +0530523QDF_STATUS wmi_unified_sta_ps_cmd_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530524 struct sta_ps_params *param)
525{
526 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
527
528 if (wmi_handle->ops->send_set_sta_ps_param_cmd)
529 return wmi_handle->ops->send_set_sta_ps_param_cmd(wmi_handle,
530 param);
531
Govind Singhb53420c2016-03-09 14:32:57 +0530532 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530533}
534
535/**
536 * wmi_crash_inject() - inject fw crash
537 * @wma_handle: wma handle
538 * @param: ponirt to crash inject paramter structure
539 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530540 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530541 */
Govind Singhb53420c2016-03-09 14:32:57 +0530542QDF_STATUS wmi_crash_inject(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530543 struct crash_inject *param)
544{
545 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
546
547 if (wmi_handle->ops->send_crash_inject_cmd)
548 return wmi_handle->ops->send_crash_inject_cmd(wmi_handle,
549 param);
550
Govind Singhb53420c2016-03-09 14:32:57 +0530551 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530552}
553
554/**
555 * wmi_unified_dbglog_cmd_send() - set debug log level
556 * @param wmi_handle : handle to WMI.
557 * @param param : pointer to hold dbglog level parameter
558 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530559 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530560 */
Govind Singhb53420c2016-03-09 14:32:57 +0530561QDF_STATUS
Govind Singh5eb51532016-03-09 11:34:12 +0530562wmi_unified_dbglog_cmd_send(void *wmi_hdl,
563 struct dbglog_params *dbglog_param)
564{
565 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
566
567 if (wmi_handle->ops->send_dbglog_cmd)
568 return wmi_handle->ops->send_dbglog_cmd(wmi_handle,
569 dbglog_param);
570
Govind Singhb53420c2016-03-09 14:32:57 +0530571 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530572}
573
574/**
575 * wmi_unified_vdev_set_param_send() - WMI vdev set parameter function
576 * @param wmi_handle : handle to WMI.
577 * @param macaddr : MAC address
578 * @param param : pointer to hold vdev set parameter
579 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530580 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530581 */
Govind Singhb53420c2016-03-09 14:32:57 +0530582QDF_STATUS wmi_unified_vdev_set_param_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530583 struct vdev_set_params *param)
584{
585 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
586
587 if (wmi_handle->ops->send_vdev_set_param_cmd)
588 return wmi_handle->ops->send_vdev_set_param_cmd(wmi_handle,
589 param);
590
Govind Singhb53420c2016-03-09 14:32:57 +0530591 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530592}
593
594/**
595 * wmi_unified_stats_request_send() - WMI request stats function
596 * @param wmi_handle : handle to WMI.
597 * @param macaddr : MAC address
598 * @param param : pointer to hold stats request parameter
599 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530600 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530601 */
Govind Singhb53420c2016-03-09 14:32:57 +0530602QDF_STATUS wmi_unified_stats_request_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530603 uint8_t macaddr[IEEE80211_ADDR_LEN],
604 struct stats_request_params *param)
605{
606 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
607
608 if (wmi_handle->ops->send_stats_request_cmd)
609 return wmi_handle->ops->send_stats_request_cmd(wmi_handle,
610 macaddr, param);
611
Govind Singhb53420c2016-03-09 14:32:57 +0530612 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530613}
614
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +0530615#ifdef CONFIG_MCL
Govind Singh5eb51532016-03-09 11:34:12 +0530616/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530617 * wmi_unified_packet_log_enable_send() - WMI request stats function
Govind Singh5eb51532016-03-09 11:34:12 +0530618 * @param wmi_handle : handle to WMI.
619 * @param macaddr : MAC address
620 * @param param : pointer to hold stats request parameter
621 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530622 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530623 */
Govind Singhb53420c2016-03-09 14:32:57 +0530624QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530625 uint8_t macaddr[IEEE80211_ADDR_LEN],
626 struct packet_enable_params *param)
627{
628 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
629
630 if (wmi_handle->ops->send_packet_log_enable_cmd)
631 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle,
632 macaddr, param);
633
Govind Singhb53420c2016-03-09 14:32:57 +0530634 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530635}
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530636#else
637/**
638 * wmi_unified_packet_log_enable_send() - WMI request stats function
639 * @param wmi_handle : handle to WMI.
640 * @param macaddr : MAC address
641 * @param param : pointer to hold stats request parameter
642 *
643 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
644 */
645QDF_STATUS wmi_unified_packet_log_enable_send(void *wmi_hdl,
Keyur Parekh7df8ca12017-05-07 08:54:47 -0700646 WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id)
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530647{
648 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
649
650 if (wmi_handle->ops->send_packet_log_enable_cmd)
651 return wmi_handle->ops->send_packet_log_enable_cmd(wmi_handle,
Keyur Parekh7df8ca12017-05-07 08:54:47 -0700652 PKTLOG_EVENT, mac_id);
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530653
654 return QDF_STATUS_E_FAILURE;
655}
656
657#endif
658/**
659 * wmi_unified_packet_log_disable__send() - WMI pktlog disable function
660 * @param wmi_handle : handle to WMI.
661 * @param PKTLOG_EVENT : packet log event
662 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
663 */
Keyur Parekh7df8ca12017-05-07 08:54:47 -0700664QDF_STATUS wmi_unified_packet_log_disable_send(void *wmi_hdl, uint8_t mac_id)
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530665{
666 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
667
668 if (wmi_handle->ops->send_packet_log_disable_cmd)
Keyur Parekh7df8ca12017-05-07 08:54:47 -0700669 return wmi_handle->ops->send_packet_log_disable_cmd(wmi_handle,
670 mac_id);
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530671
672 return QDF_STATUS_E_FAILURE;
673}
Govind Singh5eb51532016-03-09 11:34:12 +0530674
675/**
676 * wmi_unified_beacon_send_cmd() - WMI beacon send function
677 * @param wmi_handle : handle to WMI.
678 * @param macaddr : MAC address
679 * @param param : pointer to hold beacon send cmd parameter
680 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530681 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530682 */
Govind Singhb53420c2016-03-09 14:32:57 +0530683QDF_STATUS wmi_unified_beacon_send_cmd(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530684 struct beacon_params *param)
685{
686 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
687
688 if (wmi_handle->ops->send_beacon_send_cmd)
689 return wmi_handle->ops->send_beacon_send_cmd(wmi_handle,
Govind Singhd3156eb2016-02-26 17:50:39 +0530690 param);
Govind Singh5eb51532016-03-09 11:34:12 +0530691
Govind Singhb53420c2016-03-09 14:32:57 +0530692 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530693}
694
695/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530696 * wmi_unified_beacon_tmpl_send_cmd() - WMI beacon send function
697 * @param wmi_handle : handle to WMI.
698 * @param macaddr : MAC address
699 * @param param : pointer to hold beacon send cmd parameter
700 *
701 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
702 */
703QDF_STATUS wmi_unified_beacon_tmpl_send_cmd(void *wmi_hdl,
704 struct beacon_tmpl_params *param)
705{
706 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
707
708 if (wmi_handle->ops->send_beacon_tmpl_send_cmd)
709 return wmi_handle->ops->send_beacon_tmpl_send_cmd(wmi_handle,
710 param);
711
712 return QDF_STATUS_E_FAILURE;
713}
714/**
Govind Singh5eb51532016-03-09 11:34:12 +0530715 * wmi_unified_peer_assoc_send() - WMI peer assoc function
716 * @param wmi_handle : handle to WMI.
717 * @param macaddr : MAC address
718 * @param param : pointer to peer assoc parameter
719 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530720 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530721 */
Govind Singhb53420c2016-03-09 14:32:57 +0530722QDF_STATUS wmi_unified_peer_assoc_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530723 struct peer_assoc_params *param)
724{
725 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
726
727 if (wmi_handle->ops->send_peer_assoc_cmd)
728 return wmi_handle->ops->send_peer_assoc_cmd(wmi_handle,
Govind Singhd3156eb2016-02-26 17:50:39 +0530729 param);
Govind Singh5eb51532016-03-09 11:34:12 +0530730
Govind Singhb53420c2016-03-09 14:32:57 +0530731 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530732}
733
734/**
735 * wmi_unified_scan_start_cmd_send() - WMI scan start function
736 * @param wmi_handle : handle to WMI.
737 * @param macaddr : MAC address
738 * @param param : pointer to hold scan start cmd parameter
739 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530740 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530741 */
Govind Singhb53420c2016-03-09 14:32:57 +0530742QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl,
Om Prakash Tripathi1d83e352017-02-25 15:53:30 +0530743 struct scan_req_params *param)
Govind Singh5eb51532016-03-09 11:34:12 +0530744{
745 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
746
747 if (wmi_handle->ops->send_scan_start_cmd)
748 return wmi_handle->ops->send_scan_start_cmd(wmi_handle,
Govind Singhd3156eb2016-02-26 17:50:39 +0530749 param);
Govind Singh5eb51532016-03-09 11:34:12 +0530750
Govind Singhb53420c2016-03-09 14:32:57 +0530751 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530752}
753
754/**
755 * wmi_unified_scan_stop_cmd_send() - WMI scan start function
756 * @param wmi_handle : handle to WMI.
757 * @param macaddr : MAC address
758 * @param param : pointer to hold scan start cmd parameter
759 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530760 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530761 */
Govind Singhb53420c2016-03-09 14:32:57 +0530762QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl,
Om Prakash Tripathi1d83e352017-02-25 15:53:30 +0530763 struct scan_cancel_param *param)
Govind Singh5eb51532016-03-09 11:34:12 +0530764{
765 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
766
767 if (wmi_handle->ops->send_scan_stop_cmd)
768 return wmi_handle->ops->send_scan_stop_cmd(wmi_handle,
Govind Singhd3156eb2016-02-26 17:50:39 +0530769 param);
Govind Singh5eb51532016-03-09 11:34:12 +0530770
Govind Singhb53420c2016-03-09 14:32:57 +0530771 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530772}
773
774/**
775 * wmi_unified_scan_chan_list_cmd_send() - WMI scan channel list function
776 * @param wmi_handle : handle to WMI.
777 * @param macaddr : MAC address
778 * @param param : pointer to hold scan channel list parameter
779 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530780 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh5eb51532016-03-09 11:34:12 +0530781 */
Govind Singhb53420c2016-03-09 14:32:57 +0530782QDF_STATUS wmi_unified_scan_chan_list_cmd_send(void *wmi_hdl,
Govind Singh5eb51532016-03-09 11:34:12 +0530783 struct scan_chan_list_params *param)
784{
785 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
786
787 if (wmi_handle->ops->send_scan_chan_list_cmd)
788 return wmi_handle->ops->send_scan_chan_list_cmd(wmi_handle,
Govind Singhd3156eb2016-02-26 17:50:39 +0530789 param);
Govind Singh5eb51532016-03-09 11:34:12 +0530790
Govind Singhb53420c2016-03-09 14:32:57 +0530791 return QDF_STATUS_E_FAILURE;
Govind Singh5eb51532016-03-09 11:34:12 +0530792}
Govind Singh427ee5a2016-02-26 18:09:36 +0530793
794/**
795 * wmi_mgmt_unified_cmd_send() - management cmd over wmi layer
796 * @wmi_hdl : handle to WMI.
797 * @param : pointer to hold mgmt cmd parameter
798 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530799 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh427ee5a2016-02-26 18:09:36 +0530800 */
Govind Singhb53420c2016-03-09 14:32:57 +0530801QDF_STATUS wmi_mgmt_unified_cmd_send(void *wmi_hdl,
Govind Singh427ee5a2016-02-26 18:09:36 +0530802 struct wmi_mgmt_params *param)
803{
804 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
805
806 if (wmi_handle->ops->send_mgmt_cmd)
807 return wmi_handle->ops->send_mgmt_cmd(wmi_handle,
808 param);
809
Govind Singhb53420c2016-03-09 14:32:57 +0530810 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530811}
812
813/**
Kiran Venkatappac13fc7b2017-03-19 22:58:09 +0530814 * wmi_offchan_data_tx_cmd_send() - Send offchan data tx cmd over wmi layer
815 * @wmi_hdl : handle to WMI.
816 * @param : pointer to hold offchan data cmd parameter
817 *
818 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
819 */
820QDF_STATUS wmi_offchan_data_tx_cmd_send(void *wmi_hdl,
821 struct wmi_offchan_data_tx_params *param)
822{
823 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
824
825 if (wmi_handle->ops->send_offchan_data_tx_cmd)
826 return wmi_handle->ops->send_offchan_data_tx_cmd(wmi_handle,
827 param);
828
829 return QDF_STATUS_E_FAILURE;
830}
831
832/**
Govind Singh427ee5a2016-02-26 18:09:36 +0530833 * wmi_unified_modem_power_state() - set modem power state to fw
834 * @wmi_hdl: wmi handle
835 * @param_value: parameter value
836 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530837 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh427ee5a2016-02-26 18:09:36 +0530838 */
Govind Singhb53420c2016-03-09 14:32:57 +0530839QDF_STATUS wmi_unified_modem_power_state(void *wmi_hdl,
Govind Singh427ee5a2016-02-26 18:09:36 +0530840 uint32_t param_value)
841{
842 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
843
844 if (wmi_handle->ops->send_modem_power_state_cmd)
845 return wmi_handle->ops->send_modem_power_state_cmd(wmi_handle,
846 param_value);
847
Govind Singhb53420c2016-03-09 14:32:57 +0530848 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530849}
850
851/**
852 * wmi_unified_set_sta_ps_mode() - set sta powersave params in fw
853 * @wmi_hdl: wmi handle
854 * @vdev_id: vdev id
855 * @val: value
856 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530857 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh427ee5a2016-02-26 18:09:36 +0530858 */
Govind Singhb53420c2016-03-09 14:32:57 +0530859QDF_STATUS wmi_unified_set_sta_ps_mode(void *wmi_hdl,
Govind Singh427ee5a2016-02-26 18:09:36 +0530860 uint32_t vdev_id, uint8_t val)
861{
862 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
863
864 if (wmi_handle->ops->send_set_sta_ps_mode_cmd)
865 return wmi_handle->ops->send_set_sta_ps_mode_cmd(wmi_handle,
866 vdev_id, val);
867
Govind Singhb53420c2016-03-09 14:32:57 +0530868 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530869}
870
871/**
872 * wmi_set_mimops() - set MIMO powersave
873 * @wmi_hdl: wmi handle
874 * @vdev_id: vdev id
875 * @value: value
876 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530877 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh427ee5a2016-02-26 18:09:36 +0530878 */
Govind Singhb53420c2016-03-09 14:32:57 +0530879QDF_STATUS wmi_unified_set_mimops(void *wmi_hdl, uint8_t vdev_id, int value)
Govind Singh427ee5a2016-02-26 18:09:36 +0530880{
881 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
882
883 if (wmi_handle->ops->send_set_mimops_cmd)
884 return wmi_handle->ops->send_set_mimops_cmd(wmi_handle,
885 vdev_id, value);
886
Govind Singhb53420c2016-03-09 14:32:57 +0530887 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530888}
889
890/**
891 * wmi_set_smps_params() - set smps params
892 * @wmi_hdl: wmi handle
893 * @vdev_id: vdev id
894 * @value: value
895 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530896 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh427ee5a2016-02-26 18:09:36 +0530897 */
Govind Singhb53420c2016-03-09 14:32:57 +0530898QDF_STATUS wmi_unified_set_smps_params(void *wmi_hdl, uint8_t vdev_id,
Govind Singh427ee5a2016-02-26 18:09:36 +0530899 int value)
900{
901 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
902
903 if (wmi_handle->ops->send_set_smps_params_cmd)
904 return wmi_handle->ops->send_set_smps_params_cmd(wmi_handle,
905 vdev_id, value);
906
Govind Singhb53420c2016-03-09 14:32:57 +0530907 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530908}
909
910
911/**
912 * wmi_set_p2pgo_oppps_req() - send p2p go opp power save request to fw
913 * @wmi_hdl: wmi handle
914 * @opps: p2p opp power save parameters
915 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530916 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh427ee5a2016-02-26 18:09:36 +0530917 */
Govind Singhb53420c2016-03-09 14:32:57 +0530918QDF_STATUS wmi_unified_set_p2pgo_oppps_req(void *wmi_hdl,
Govind Singh427ee5a2016-02-26 18:09:36 +0530919 struct p2p_ps_params *oppps)
920{
921 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
922
923 if (wmi_handle->ops->send_set_p2pgo_oppps_req_cmd)
924 return wmi_handle->ops->send_set_p2pgo_oppps_req_cmd(wmi_handle,
925 oppps);
926
Govind Singhb53420c2016-03-09 14:32:57 +0530927 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530928}
929
930/**
931 * wmi_unified_set_p2pgo_noa_req_cmd() - send p2p go noa request to fw
932 * @wmi_hdl: wmi handle
933 * @noa: p2p power save parameters
934 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +0530935 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh427ee5a2016-02-26 18:09:36 +0530936 */
Govind Singhb53420c2016-03-09 14:32:57 +0530937QDF_STATUS wmi_unified_set_p2pgo_noa_req_cmd(void *wmi_hdl,
Govind Singh427ee5a2016-02-26 18:09:36 +0530938 struct p2p_ps_params *noa)
939{
940 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
941
942 if (wmi_handle->ops->send_set_p2pgo_noa_req_cmd)
943 return wmi_handle->ops->send_set_p2pgo_noa_req_cmd(wmi_handle,
944 noa);
945
Govind Singhb53420c2016-03-09 14:32:57 +0530946 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +0530947}
948
Wu Gaocd3a8512017-03-13 20:17:34 +0800949#ifdef CONVERGED_P2P_ENABLE
950/**
951 * wmi_unified_p2p_lo_start_cmd() - send p2p lo start request to fw
952 * @wmi_hdl: wmi handle
953 * @param: p2p listen offload start parameters
954 *
955 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
956 */
957QDF_STATUS wmi_unified_p2p_lo_start_cmd(void *wmi_hdl,
958 struct p2p_lo_start *param)
959{
960 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
961
962 if (!wmi_handle) {
963 WMI_LOGE("wmi handle is null");
964 return QDF_STATUS_E_INVAL;
965 }
966
967 if (wmi_handle->ops->send_p2p_lo_start_cmd)
968 return wmi_handle->ops->send_p2p_lo_start_cmd(wmi_handle,
969 param);
970
971 return QDF_STATUS_E_FAILURE;
972}
973
974/**
975 * wmi_unified_p2p_lo_stop_cmd() - send p2p lo stop request to fw
976 * @wmi_hdl: wmi handle
977 * @vdev_id: vdev id
978 *
979 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
980 */
981QDF_STATUS wmi_unified_p2p_lo_stop_cmd(void *wmi_hdl, uint8_t vdev_id)
982{
983 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
984
985 if (!wmi_handle) {
986 WMI_LOGE("wmi handle is null");
987 return QDF_STATUS_E_INVAL;
988 }
989
990 if (wmi_handle->ops->send_p2p_lo_start_cmd)
991 return wmi_handle->ops->send_p2p_lo_stop_cmd(wmi_handle,
992 vdev_id);
993
994 return QDF_STATUS_E_FAILURE;
995}
996#endif /* End of CONVERGED_P2P_ENABLE */
997
Govind Singh427ee5a2016-02-26 18:09:36 +0530998/**
999 * wmi_get_temperature() - get pdev temperature req
1000 * @wmi_hdl: wmi handle
1001 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301002 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh427ee5a2016-02-26 18:09:36 +05301003 */
Govind Singhb53420c2016-03-09 14:32:57 +05301004QDF_STATUS wmi_unified_get_temperature(void *wmi_hdl)
Govind Singh427ee5a2016-02-26 18:09:36 +05301005{
1006 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1007
1008 if (wmi_handle->ops->send_get_temperature_cmd)
1009 return wmi_handle->ops->send_get_temperature_cmd(wmi_handle);
1010
Govind Singhb53420c2016-03-09 14:32:57 +05301011 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +05301012}
1013
1014/**
1015 * wmi_unified_set_sta_uapsd_auto_trig_cmd() - set uapsd auto trigger command
1016 * @wmi_hdl: wmi handle
1017 * @end_set_sta_ps_mode_cmd: cmd paramter strcture
1018 *
1019 * This function sets the trigger
1020 * uapsd params such as service interval, delay interval
1021 * and suspend interval which will be used by the firmware
1022 * to send trigger frames periodically when there is no
1023 * traffic on the transmit side.
1024 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301025 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh427ee5a2016-02-26 18:09:36 +05301026 */
Govind Singhb53420c2016-03-09 14:32:57 +05301027QDF_STATUS
Govind Singh427ee5a2016-02-26 18:09:36 +05301028wmi_unified_set_sta_uapsd_auto_trig_cmd(void *wmi_hdl,
1029 struct sta_uapsd_trig_params *param)
1030{
1031 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1032
1033 if (wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd)
1034 return wmi_handle->ops->send_set_sta_uapsd_auto_trig_cmd(wmi_handle,
1035 param);
1036
Govind Singhb53420c2016-03-09 14:32:57 +05301037 return QDF_STATUS_E_FAILURE;
Govind Singh427ee5a2016-02-26 18:09:36 +05301038}
Govind Singh2edc80f2016-03-01 15:30:53 +05301039
1040/**
1041 * wmi_unified_ocb_start_timing_advert() - start sending the timing advertisement
1042 * frames on a channel
1043 * @wmi_handle: pointer to the wmi handle
1044 * @timing_advert: pointer to the timing advertisement struct
1045 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301046 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301047 */
Govind Singhb53420c2016-03-09 14:32:57 +05301048QDF_STATUS wmi_unified_ocb_start_timing_advert(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301049 struct ocb_timing_advert_param *timing_advert)
1050{
1051 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1052
1053 if (wmi_handle->ops->send_ocb_start_timing_advert_cmd)
1054 return wmi_handle->ops->send_ocb_start_timing_advert_cmd(wmi_handle,
1055 timing_advert);
1056
Govind Singhb53420c2016-03-09 14:32:57 +05301057 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301058}
1059
1060/**
1061 * wmi_unified_ocb_stop_timing_advert() - stop sending the timing advertisement
1062 * frames on a channel
1063 * @wmi_handle: pointer to the wmi handle
1064 * @timing_advert: pointer to the timing advertisement struct
1065 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301066 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301067 */
Govind Singhb53420c2016-03-09 14:32:57 +05301068QDF_STATUS wmi_unified_ocb_stop_timing_advert(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301069 struct ocb_timing_advert_param *timing_advert)
1070{
1071 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1072
1073 if (wmi_handle->ops->send_ocb_stop_timing_advert_cmd)
1074 return wmi_handle->ops->send_ocb_stop_timing_advert_cmd(wmi_handle,
1075 timing_advert);
1076
Govind Singhb53420c2016-03-09 14:32:57 +05301077 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301078}
1079
1080/**
1081 * wmi_unified_ocb_set_utc_time_cmd() - get ocb tsf timer val
1082 * @wmi_handle: pointer to the wmi handle
1083 * @vdev_id: vdev id
1084 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301085 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301086 */
Govind Singhb53420c2016-03-09 14:32:57 +05301087QDF_STATUS wmi_unified_ocb_set_utc_time_cmd(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301088 struct ocb_utc_param *utc)
1089{
1090 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1091
1092 if (wmi_handle->ops->send_ocb_set_utc_time_cmd)
1093 return wmi_handle->ops->send_ocb_set_utc_time_cmd(wmi_handle,
1094 utc);
1095
Govind Singhb53420c2016-03-09 14:32:57 +05301096 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301097}
1098
1099/**
1100 * wmi_unified_ocb_get_tsf_timer() - get ocb tsf timer val
1101 * @wmi_handle: pointer to the wmi handle
1102 * @vdev_id: vdev id
1103 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301104 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301105 */
Govind Singhb53420c2016-03-09 14:32:57 +05301106QDF_STATUS wmi_unified_ocb_get_tsf_timer(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301107 uint8_t vdev_id)
1108{
1109 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1110
1111 if (wmi_handle->ops->send_ocb_get_tsf_timer_cmd)
1112 return wmi_handle->ops->send_ocb_get_tsf_timer_cmd(wmi_handle,
1113 vdev_id);
1114
Govind Singhb53420c2016-03-09 14:32:57 +05301115 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301116}
1117
1118/**
1119 * wmi_unified_dcc_get_stats_cmd() - get the DCC channel stats
1120 * @wmi_handle: pointer to the wmi handle
1121 * @get_stats_param: pointer to the dcc stats
1122 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301123 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301124 */
Govind Singhb53420c2016-03-09 14:32:57 +05301125QDF_STATUS wmi_unified_dcc_get_stats_cmd(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301126 struct dcc_get_stats_param *get_stats_param)
1127{
1128 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1129
1130 if (wmi_handle->ops->send_dcc_get_stats_cmd)
1131 return wmi_handle->ops->send_dcc_get_stats_cmd(wmi_handle,
1132 get_stats_param);
1133
Govind Singhb53420c2016-03-09 14:32:57 +05301134 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301135}
1136
1137/**
1138 * wmi_unified_dcc_clear_stats() - command to clear the DCC stats
1139 * @wmi_handle: pointer to the wmi handle
1140 * @clear_stats_param: parameters to the command
1141 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301142 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh2edc80f2016-03-01 15:30:53 +05301143 */
Govind Singhb53420c2016-03-09 14:32:57 +05301144QDF_STATUS wmi_unified_dcc_clear_stats(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301145 uint32_t vdev_id, uint32_t dcc_stats_bitmap)
1146{
1147 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1148
1149 if (wmi_handle->ops->send_dcc_clear_stats_cmd)
1150 return wmi_handle->ops->send_dcc_clear_stats_cmd(wmi_handle,
1151 vdev_id, dcc_stats_bitmap);
1152
Govind Singhb53420c2016-03-09 14:32:57 +05301153 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301154}
1155
1156/**
1157 * wmi_unified_dcc_update_ndl() - command to update the NDL data
1158 * @wmi_handle: pointer to the wmi handle
1159 * @update_ndl_param: pointer to the request parameters
1160 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301161 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
Govind Singh2edc80f2016-03-01 15:30:53 +05301162 */
Govind Singhb53420c2016-03-09 14:32:57 +05301163QDF_STATUS wmi_unified_dcc_update_ndl(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301164 struct dcc_update_ndl_param *update_ndl_param)
1165{
1166 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1167
1168 if (wmi_handle->ops->send_dcc_update_ndl_cmd)
1169 return wmi_handle->ops->send_dcc_update_ndl_cmd(wmi_handle,
1170 update_ndl_param);
1171
Govind Singhb53420c2016-03-09 14:32:57 +05301172 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301173}
1174
1175/**
1176 * wmi_unified_ocb_set_config() - send the OCB config to the FW
1177 * @wmi_handle: pointer to the wmi handle
1178 * @config: the OCB configuration
1179 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301180 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
Govind Singh2edc80f2016-03-01 15:30:53 +05301181 */
Govind Singhb53420c2016-03-09 14:32:57 +05301182QDF_STATUS wmi_unified_ocb_set_config(void *wmi_hdl,
Govind Singh2edc80f2016-03-01 15:30:53 +05301183 struct ocb_config_param *config, uint32_t *ch_mhz)
1184{
1185 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1186
1187 if (wmi_handle->ops->send_ocb_set_config_cmd)
1188 return wmi_handle->ops->send_ocb_set_config_cmd(wmi_handle,
1189 config, ch_mhz);
1190
Govind Singhb53420c2016-03-09 14:32:57 +05301191 return QDF_STATUS_E_FAILURE;
Govind Singh2edc80f2016-03-01 15:30:53 +05301192}
Govind Singh17a9cfa2016-03-01 15:54:59 +05301193
1194/**
1195 * wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd() - control mcc scheduler
1196 * @wmi_handle: wmi handle
1197 * @mcc_adaptive_scheduler: enable/disable
1198 *
1199 * This function enable/disable mcc adaptive scheduler in fw.
1200 *
Govind Singhb53420c2016-03-09 14:32:57 +05301201 * Return: QDF_STATUS_SUCCESS for sucess or error code
Govind Singh17a9cfa2016-03-01 15:54:59 +05301202 */
Govind Singhb53420c2016-03-09 14:32:57 +05301203QDF_STATUS wmi_unified_set_enable_disable_mcc_adaptive_scheduler_cmd(
Govind Singh4df47142016-04-16 19:24:23 -07001204 void *wmi_hdl, uint32_t mcc_adaptive_scheduler,
1205 uint32_t pdev_id)
Govind Singh17a9cfa2016-03-01 15:54:59 +05301206{
1207 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1208
1209 if (wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd)
1210 return wmi_handle->ops->send_set_enable_disable_mcc_adaptive_scheduler_cmd(wmi_handle,
Govind Singh4df47142016-04-16 19:24:23 -07001211 mcc_adaptive_scheduler, pdev_id);
Govind Singh17a9cfa2016-03-01 15:54:59 +05301212
Govind Singhb53420c2016-03-09 14:32:57 +05301213 return QDF_STATUS_E_FAILURE;
Govind Singh17a9cfa2016-03-01 15:54:59 +05301214}
1215
1216/**
1217 * wmi_unified_set_mcc_channel_time_latency_cmd() - set MCC channel time latency
1218 * @wmi: wmi handle
1219 * @mcc_channel: mcc channel
1220 * @mcc_channel_time_latency: MCC channel time latency.
1221 *
1222 * Currently used to set time latency for an MCC vdev/adapter using operating
1223 * channel of it and channel number. The info is provided run time using
1224 * iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>.
1225 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301226 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh17a9cfa2016-03-01 15:54:59 +05301227 */
Govind Singhb53420c2016-03-09 14:32:57 +05301228QDF_STATUS wmi_unified_set_mcc_channel_time_latency_cmd(void *wmi_hdl,
Govind Singh17a9cfa2016-03-01 15:54:59 +05301229 uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency)
1230{
1231 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1232
1233 if (wmi_handle->ops->send_set_mcc_channel_time_latency_cmd)
1234 return wmi_handle->ops->send_set_mcc_channel_time_latency_cmd(wmi_handle,
1235 mcc_channel_freq,
1236 mcc_channel_time_latency);
1237
Govind Singhb53420c2016-03-09 14:32:57 +05301238 return QDF_STATUS_E_FAILURE;
Govind Singh17a9cfa2016-03-01 15:54:59 +05301239}
1240
1241/**
1242 * wmi_unified_set_mcc_channel_time_quota_cmd() - set MCC channel time quota
1243 * @wmi: wmi handle
1244 * @adapter_1_chan_number: adapter 1 channel number
1245 * @adapter_1_quota: adapter 1 quota
1246 * @adapter_2_chan_number: adapter 2 channel number
1247 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301248 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh17a9cfa2016-03-01 15:54:59 +05301249 */
Govind Singhb53420c2016-03-09 14:32:57 +05301250QDF_STATUS wmi_unified_set_mcc_channel_time_quota_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301251 uint32_t adapter_1_chan_freq,
1252 uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq)
Govind Singh17a9cfa2016-03-01 15:54:59 +05301253{
1254 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1255
1256 if (wmi_handle->ops->send_set_mcc_channel_time_quota_cmd)
1257 return wmi_handle->ops->send_set_mcc_channel_time_quota_cmd(wmi_handle,
1258 adapter_1_chan_freq,
1259 adapter_1_quota,
1260 adapter_2_chan_freq);
1261
Govind Singhb53420c2016-03-09 14:32:57 +05301262 return QDF_STATUS_E_FAILURE;
Govind Singh17a9cfa2016-03-01 15:54:59 +05301263}
1264
1265/**
1266 * wmi_unified_set_thermal_mgmt_cmd() - set thermal mgmt command to fw
1267 * @wmi_handle: Pointer to wmi handle
1268 * @thermal_info: Thermal command information
1269 *
1270 * This function sends the thermal management command
1271 * to the firmware
1272 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301273 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh17a9cfa2016-03-01 15:54:59 +05301274 */
Govind Singhb53420c2016-03-09 14:32:57 +05301275QDF_STATUS wmi_unified_set_thermal_mgmt_cmd(void *wmi_hdl,
Govind Singh17a9cfa2016-03-01 15:54:59 +05301276 struct thermal_cmd_params *thermal_info)
1277{
1278 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1279
1280 if (wmi_handle->ops->send_set_thermal_mgmt_cmd)
1281 return wmi_handle->ops->send_set_thermal_mgmt_cmd(wmi_handle,
1282 thermal_info);
1283
Govind Singhb53420c2016-03-09 14:32:57 +05301284 return QDF_STATUS_E_FAILURE;
Govind Singh17a9cfa2016-03-01 15:54:59 +05301285}
1286
1287
1288/**
1289 * wmi_unified_lro_config_cmd() - process the LRO config command
1290 * @wmi: Pointer to wmi handle
1291 * @wmi_lro_cmd: Pointer to LRO configuration parameters
1292 *
1293 * This function sends down the LRO configuration parameters to
1294 * the firmware to enable LRO, sets the TCP flags and sets the
1295 * seed values for the toeplitz hash generation
1296 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301297 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh17a9cfa2016-03-01 15:54:59 +05301298 */
Govind Singhb53420c2016-03-09 14:32:57 +05301299QDF_STATUS wmi_unified_lro_config_cmd(void *wmi_hdl,
Govind Singh17a9cfa2016-03-01 15:54:59 +05301300 struct wmi_lro_config_cmd_t *wmi_lro_cmd)
1301{
1302 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1303
1304 if (wmi_handle->ops->send_lro_config_cmd)
1305 return wmi_handle->ops->send_lro_config_cmd(wmi_handle,
1306 wmi_lro_cmd);
1307
Govind Singhb53420c2016-03-09 14:32:57 +05301308 return QDF_STATUS_E_FAILURE;
Govind Singh17a9cfa2016-03-01 15:54:59 +05301309}
Govind Singh4eacd2b2016-03-07 14:24:22 +05301310
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05301311#ifdef CONFIG_MCL
Govind Singh4eacd2b2016-03-07 14:24:22 +05301312/**
Poddar, Siddarth98281c42016-04-28 15:49:11 +05301313 * wmi_unified_peer_rate_report_cmd() - process the peer rate report command
1314 * @wmi_hdl: Pointer to wmi handle
1315 * @rate_report_params: Pointer to peer rate report parameters
1316 *
1317 *
1318 * Return: QDF_STATUS_SUCCESS for success otherwise failure
1319 */
1320QDF_STATUS wmi_unified_peer_rate_report_cmd(void *wmi_hdl,
1321 struct wmi_peer_rate_report_params *rate_report_params)
1322{
1323 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1324
1325 if (wmi_handle->ops->send_peer_rate_report_cmd)
1326 return wmi_handle->ops->send_peer_rate_report_cmd(wmi_handle,
1327 rate_report_params);
1328
1329 return QDF_STATUS_E_FAILURE;
1330}
1331
1332/**
Govind Singh4eacd2b2016-03-07 14:24:22 +05301333 * wmi_unified_bcn_buf_ll_cmd() - prepare and send beacon buffer to fw for LL
1334 * @wmi_hdl: wmi handle
1335 * @param: bcn ll cmd parameter
1336 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301337 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301338 */
Govind Singhb53420c2016-03-09 14:32:57 +05301339QDF_STATUS wmi_unified_bcn_buf_ll_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301340 wmi_bcn_send_from_host_cmd_fixed_param *param)
1341{
1342 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1343
1344 if (wmi_handle->ops->send_bcn_buf_ll_cmd)
1345 return wmi_handle->ops->send_bcn_buf_ll_cmd(wmi_handle,
1346 param);
1347
Govind Singhb53420c2016-03-09 14:32:57 +05301348 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301349}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301350#endif
Govind Singh4eacd2b2016-03-07 14:24:22 +05301351
1352/**
1353 * wmi_unified_set_sta_sa_query_param_cmd() - set sta sa query parameters
1354 * @wmi_hdl: wmi handle
1355 * @vdev_id: vdev id
1356 * @max_retries: max retries
1357 * @retry_interval: retry interval
1358 * This function sets sta query related parameters in fw.
1359 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301360 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301361 */
1362
Govind Singhb53420c2016-03-09 14:32:57 +05301363QDF_STATUS wmi_unified_set_sta_sa_query_param_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301364 uint8_t vdev_id, uint32_t max_retries,
1365 uint32_t retry_interval)
1366{
1367 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1368
1369 if (wmi_handle->ops->send_set_sta_sa_query_param_cmd)
1370 return wmi_handle->ops->send_set_sta_sa_query_param_cmd(wmi_handle,
1371 vdev_id, max_retries,
1372 retry_interval);
1373
Govind Singhb53420c2016-03-09 14:32:57 +05301374 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301375}
1376
1377/**
1378 * wmi_unified_set_sta_keep_alive_cmd() - set sta keep alive parameters
1379 * @wmi_hdl: wmi handle
1380 * @params: sta keep alive parameter
1381 *
1382 * This function sets keep alive related parameters in fw.
1383 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301384 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301385 */
Govind Singhb53420c2016-03-09 14:32:57 +05301386QDF_STATUS wmi_unified_set_sta_keep_alive_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301387 struct sta_params *params)
1388{
1389 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1390
1391 if (wmi_handle->ops->send_set_sta_keep_alive_cmd)
1392 return wmi_handle->ops->send_set_sta_keep_alive_cmd(wmi_handle,
1393 params);
1394
Govind Singhb53420c2016-03-09 14:32:57 +05301395 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301396}
1397
1398/**
1399 * wmi_unified_vdev_set_gtx_cfg_cmd() - set GTX params
1400 * @wmi_hdl: wmi handle
1401 * @if_id: vdev id
1402 * @gtx_info: GTX config params
1403 *
1404 * This function set GTX related params in firmware.
1405 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301406 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301407 */
Govind Singhb53420c2016-03-09 14:32:57 +05301408QDF_STATUS wmi_unified_vdev_set_gtx_cfg_cmd(void *wmi_hdl, uint32_t if_id,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301409 struct wmi_gtx_config *gtx_info)
1410{
1411 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1412
1413 if (wmi_handle->ops->send_vdev_set_gtx_cfg_cmd)
1414 return wmi_handle->ops->send_vdev_set_gtx_cfg_cmd(wmi_handle,
1415 if_id, gtx_info);
1416
Govind Singhb53420c2016-03-09 14:32:57 +05301417 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301418}
1419
1420/**
1421 * wmi_unified_process_update_edca_param() - update EDCA params
1422 * @wmi_hdl: wmi handle
Vikram Kandukuri3bb482b2017-06-01 16:47:51 +05301423 * @vdev_id: vdev id.
1424 * @wmm_vparams: edca parameters
Govind Singh4eacd2b2016-03-07 14:24:22 +05301425 *
1426 * This function updates EDCA parameters to the target
1427 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301428 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301429 */
Govind Singhb53420c2016-03-09 14:32:57 +05301430QDF_STATUS wmi_unified_process_update_edca_param(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301431 uint8_t vdev_id,
Vikram Kandukuri3bb482b2017-06-01 16:47:51 +05301432 struct wmi_host_wme_vparams wmm_vparams[WMI_MAX_NUM_AC])
Govind Singh4eacd2b2016-03-07 14:24:22 +05301433{
1434 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1435
1436 if (wmi_handle->ops->send_process_update_edca_param_cmd)
1437 return wmi_handle->ops->send_process_update_edca_param_cmd(wmi_handle,
Vikram Kandukuri3bb482b2017-06-01 16:47:51 +05301438 vdev_id, wmm_vparams);
Govind Singh4eacd2b2016-03-07 14:24:22 +05301439
Govind Singhb53420c2016-03-09 14:32:57 +05301440 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301441}
1442
1443/**
1444 * wmi_unified_probe_rsp_tmpl_send_cmd() - send probe response template to fw
1445 * @wmi_hdl: wmi handle
1446 * @vdev_id: vdev id
1447 * @probe_rsp_info: probe response info
1448 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301449 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301450 */
Govind Singhb53420c2016-03-09 14:32:57 +05301451QDF_STATUS wmi_unified_probe_rsp_tmpl_send_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301452 uint8_t vdev_id,
1453 struct wmi_probe_resp_params *probe_rsp_info,
1454 uint8_t *frm)
1455{
1456 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1457
1458 if (wmi_handle->ops->send_probe_rsp_tmpl_send_cmd)
1459 return wmi_handle->ops->send_probe_rsp_tmpl_send_cmd(wmi_handle,
1460 vdev_id, probe_rsp_info,
1461 frm);
1462
Govind Singhb53420c2016-03-09 14:32:57 +05301463 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301464}
1465
1466/**
Himanshu Agarwal712622f2016-03-09 18:49:18 +05301467 * wmi_unified_setup_install_key_cmd - send key to install to fw
1468 * @wmi_hdl: wmi handle
1469 * @key_params: key parameters
1470 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301471 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwal712622f2016-03-09 18:49:18 +05301472 */
1473QDF_STATUS wmi_unified_setup_install_key_cmd(void *wmi_hdl,
1474 struct set_key_params *key_params)
1475{
1476 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1477
1478 if (wmi_handle->ops->send_setup_install_key_cmd)
1479 return wmi_handle->ops->send_setup_install_key_cmd(wmi_handle,
1480 key_params);
1481
1482 return QDF_STATUS_E_FAILURE;
1483}
1484
1485/**
Govind Singh4eacd2b2016-03-07 14:24:22 +05301486 * wmi_unified_p2p_go_set_beacon_ie_cmd() - set beacon IE for p2p go
1487 * @wma_handle: wma handle
1488 * @vdev_id: vdev id
1489 * @p2p_ie: p2p IE
1490 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301491 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301492 */
Govind Singhb53420c2016-03-09 14:32:57 +05301493QDF_STATUS wmi_unified_p2p_go_set_beacon_ie_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301494 A_UINT32 vdev_id, uint8_t *p2p_ie)
1495{
1496 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1497
1498 if (wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd)
1499 return wmi_handle->ops->send_p2p_go_set_beacon_ie_cmd(wmi_handle,
1500 vdev_id, p2p_ie);
1501
Govind Singhb53420c2016-03-09 14:32:57 +05301502 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301503}
1504
1505/**
1506 * wmi_unified_set_gateway_params_cmd() - set gateway parameters
1507 * @wmi_hdl: wmi handle
1508 * @req: gateway parameter update request structure
1509 *
1510 * This function reads the incoming @req and fill in the destination
1511 * WMI structure and sends down the gateway configs down to the firmware
1512 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301513 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures;
1514 * error number otherwise
Govind Singh4eacd2b2016-03-07 14:24:22 +05301515 */
Govind Singhb53420c2016-03-09 14:32:57 +05301516QDF_STATUS wmi_unified_set_gateway_params_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301517 struct gateway_update_req_param *req)
1518{
1519 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1520
1521 if (wmi_handle->ops->send_set_gateway_params_cmd)
1522 return wmi_handle->ops->send_set_gateway_params_cmd(wmi_handle,
1523 req);
1524
Govind Singhb53420c2016-03-09 14:32:57 +05301525 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301526}
1527
1528/**
1529 * wmi_unified_set_rssi_monitoring_cmd() - set rssi monitoring
1530 * @wmi_hdl: wmi handle
1531 * @req: rssi monitoring request structure
1532 *
1533 * This function reads the incoming @req and fill in the destination
1534 * WMI structure and send down the rssi monitoring configs down to the firmware
1535 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301536 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures;
1537 * error number otherwise
Govind Singh4eacd2b2016-03-07 14:24:22 +05301538 */
Govind Singhb53420c2016-03-09 14:32:57 +05301539QDF_STATUS wmi_unified_set_rssi_monitoring_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301540 struct rssi_monitor_param *req)
1541{
1542 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1543
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301544 if (wmi_handle->ops->send_set_rssi_monitoring_cmd)
Govind Singh4eacd2b2016-03-07 14:24:22 +05301545 return wmi_handle->ops->send_set_rssi_monitoring_cmd(wmi_handle,
1546 req);
1547
Govind Singhb53420c2016-03-09 14:32:57 +05301548 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301549}
1550
1551/**
1552 * wmi_unified_scan_probe_setoui_cmd() - set scan probe OUI
1553 * @wmi_hdl: wmi handle
1554 * @psetoui: OUI parameters
1555 *
1556 * set scan probe OUI parameters in firmware
1557 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301558 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301559 */
Govind Singhb53420c2016-03-09 14:32:57 +05301560QDF_STATUS wmi_unified_scan_probe_setoui_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301561 struct scan_mac_oui *psetoui)
1562{
1563 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1564
1565 if (wmi_handle->ops->send_scan_probe_setoui_cmd)
1566 return wmi_handle->ops->send_scan_probe_setoui_cmd(wmi_handle,
1567 psetoui);
1568
Govind Singhb53420c2016-03-09 14:32:57 +05301569 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301570}
1571
1572/**
1573 * wmi_unified_reset_passpoint_network_list_cmd() - reset passpoint network list
1574 * @wmi_hdl: wmi handle
1575 * @req: passpoint network request structure
1576 *
1577 * This function sends down WMI command with network id set to wildcard id.
1578 * firmware shall clear all the config entries
1579 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301580 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301581 */
Govind Singhb53420c2016-03-09 14:32:57 +05301582QDF_STATUS wmi_unified_reset_passpoint_network_list_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301583 struct wifi_passpoint_req_param *req)
1584{
1585 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1586
1587 if (wmi_handle->ops->send_reset_passpoint_network_list_cmd)
1588 return wmi_handle->ops->send_reset_passpoint_network_list_cmd(wmi_handle,
1589 req);
1590
Govind Singhb53420c2016-03-09 14:32:57 +05301591 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301592}
1593
1594/**
1595 * wmi_unified_set_passpoint_network_list_cmd() - set passpoint network list
1596 * @wmi_hdl: wmi handle
1597 * @req: passpoint network request structure
1598 *
1599 * This function reads the incoming @req and fill in the destination
1600 * WMI structure and send down the passpoint configs down to the firmware
1601 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301602 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301603 */
Govind Singhb53420c2016-03-09 14:32:57 +05301604QDF_STATUS wmi_unified_set_passpoint_network_list_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301605 struct wifi_passpoint_req_param *req)
1606{
1607 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1608
1609 if (wmi_handle->ops->send_set_passpoint_network_list_cmd)
1610 return wmi_handle->ops->send_set_passpoint_network_list_cmd(wmi_handle,
1611 req);
1612
Govind Singhb53420c2016-03-09 14:32:57 +05301613 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301614}
1615
1616/** wmi_unified_set_epno_network_list_cmd() - set epno network list
1617 * @wmi_hdl: wmi handle
1618 * @req: epno config params request structure
1619 *
1620 * This function reads the incoming epno config request structure
1621 * and constructs the WMI message to the firmware.
1622 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301623 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
1624 * error number otherwise
Govind Singh4eacd2b2016-03-07 14:24:22 +05301625 */
Govind Singhb53420c2016-03-09 14:32:57 +05301626QDF_STATUS wmi_unified_set_epno_network_list_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301627 struct wifi_enhanched_pno_params *req)
1628{
1629 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1630
1631 if (wmi_handle->ops->send_set_epno_network_list_cmd)
1632 return wmi_handle->ops->send_set_epno_network_list_cmd(wmi_handle,
1633 req);
1634
Govind Singhb53420c2016-03-09 14:32:57 +05301635 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301636}
1637
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05301638#ifdef CONFIG_MCL
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301639/**
1640 * wmi_unified_roam_scan_offload_mode_cmd() - set roam scan parameters
1641 * @wmi_hdl: wmi handle
1642 * @scan_cmd_fp: scan related parameters
1643 * @roam_req: roam related parameters
1644 *
1645 * This function reads the incoming @roam_req and fill in the destination
1646 * WMI structure and send down the roam scan configs down to the firmware
1647 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301648 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301649 */
1650QDF_STATUS wmi_unified_roam_scan_offload_mode_cmd(void *wmi_hdl,
1651 wmi_start_scan_cmd_fixed_param *scan_cmd_fp,
1652 struct roam_offload_scan_params *roam_req)
1653{
1654 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1655
1656 if (wmi_handle->ops->send_roam_scan_offload_mode_cmd)
1657 return wmi_handle->ops->send_roam_scan_offload_mode_cmd(
1658 wmi_handle, scan_cmd_fp, roam_req);
1659
1660 return QDF_STATUS_E_FAILURE;
1661}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301662#endif
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301663
1664/**
1665 * wmi_unified_roam_scan_offload_rssi_thresh_cmd() - set roam scan rssi
1666 * parameters
1667 * @wmi_hdl: wmi handle
1668 * @roam_req: roam rssi related parameters
1669 *
1670 * This function reads the incoming @roam_req and fill in the destination
1671 * WMI structure and send down the roam scan rssi configs down to the firmware
1672 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301673 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301674 */
1675QDF_STATUS wmi_unified_roam_scan_offload_rssi_thresh_cmd(void *wmi_hdl,
1676 struct roam_offload_scan_rssi_params
1677 *roam_req)
1678{
1679 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1680
1681 if (wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd)
1682 return wmi_handle->ops->send_roam_scan_offload_rssi_thresh_cmd(
1683 wmi_handle, roam_req);
1684
1685 return QDF_STATUS_E_FAILURE;
1686}
1687
Varun Reddy Yeturu412601c2017-07-20 09:45:01 -07001688QDF_STATUS wmi_unified_roam_mawc_params_cmd(
1689 void *wmi_hdl, struct wmi_mawc_roam_params *params)
1690{
1691 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1692
1693 if (wmi_handle->ops->send_roam_mawc_params_cmd)
1694 return wmi_handle->ops->send_roam_mawc_params_cmd(
1695 wmi_handle, params);
1696
1697 return QDF_STATUS_E_FAILURE;
1698}
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301699/**
1700 * wmi_unified_roam_scan_filter_cmd() - send roam scan whitelist,
1701 * blacklist and preferred list
1702 * @wmi_hdl: wmi handle
1703 * @roam_req: roam scan lists related parameters
1704 *
1705 * This function reads the incoming @roam_req and fill in the destination
1706 * WMI structure and send down the different roam scan lists down to the fw
1707 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301708 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Himanshu Agarwalc5e4d892016-03-09 15:25:44 +05301709 */
1710QDF_STATUS wmi_unified_roam_scan_filter_cmd(void *wmi_hdl,
1711 struct roam_scan_filter_params *roam_req)
1712{
1713 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1714
1715 if (wmi_handle->ops->send_roam_scan_filter_cmd)
1716 return wmi_handle->ops->send_roam_scan_filter_cmd(
1717 wmi_handle, roam_req);
1718
1719 return QDF_STATUS_E_FAILURE;
1720}
1721
Govind Singh4eacd2b2016-03-07 14:24:22 +05301722/** wmi_unified_ipa_offload_control_cmd() - ipa offload control parameter
1723 * @wmi_hdl: wmi handle
1724 * @ipa_offload: ipa offload control parameter
1725 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301726 * Returns: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures,
1727 * error number otherwise
Govind Singh4eacd2b2016-03-07 14:24:22 +05301728 */
Govind Singhb53420c2016-03-09 14:32:57 +05301729QDF_STATUS wmi_unified_ipa_offload_control_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301730 struct ipa_offload_control_params *ipa_offload)
1731{
1732 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1733
1734 if (wmi_handle->ops->send_ipa_offload_control_cmd)
1735 return wmi_handle->ops->send_ipa_offload_control_cmd(wmi_handle,
1736 ipa_offload);
1737
Govind Singhb53420c2016-03-09 14:32:57 +05301738 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301739}
1740
1741/**
1742 * wmi_unified_extscan_get_capabilities_cmd() - extscan get capabilities
1743 * @wmi_hdl: wmi handle
1744 * @pgetcapab: get capabilities params
1745 *
1746 * This function send request to fw to get extscan capabilities.
1747 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301748 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301749 */
Govind Singhb53420c2016-03-09 14:32:57 +05301750QDF_STATUS wmi_unified_extscan_get_capabilities_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301751 struct extscan_capabilities_params *pgetcapab)
1752{
1753 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1754
1755 if (wmi_handle->ops->send_extscan_get_capabilities_cmd)
1756 return wmi_handle->ops->send_extscan_get_capabilities_cmd(wmi_handle,
1757 pgetcapab);
1758
Govind Singhb53420c2016-03-09 14:32:57 +05301759 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301760}
1761
1762/**
1763 * wmi_unified_extscan_get_cached_results_cmd() - extscan get cached results
1764 * @wmi_hdl: wmi handle
1765 * @pcached_results: cached results parameters
1766 *
1767 * This function send request to fw to get cached results.
1768 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301769 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301770 */
Govind Singhb53420c2016-03-09 14:32:57 +05301771QDF_STATUS wmi_unified_extscan_get_cached_results_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301772 struct extscan_cached_result_params *pcached_results)
1773{
1774 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1775
1776 if (wmi_handle->ops->send_extscan_get_cached_results_cmd)
1777 return wmi_handle->ops->send_extscan_get_cached_results_cmd(wmi_handle,
1778 pcached_results);
1779
Govind Singhb53420c2016-03-09 14:32:57 +05301780 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301781}
1782
1783/**
1784 * wmi_unified_extscan_stop_change_monitor_cmd() - send stop change monitor cmd
1785 * @wmi_hdl: wmi handle
1786 * @reset_req: Reset change request params
1787 *
1788 * This function sends stop change monitor request to fw.
1789 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301790 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301791 */
Govind Singhb53420c2016-03-09 14:32:57 +05301792QDF_STATUS wmi_unified_extscan_stop_change_monitor_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301793 struct extscan_capabilities_reset_params *reset_req)
1794{
1795 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1796
1797 if (wmi_handle->ops->send_extscan_stop_change_monitor_cmd)
1798 return wmi_handle->ops->send_extscan_stop_change_monitor_cmd(wmi_handle,
1799 reset_req);
1800
Govind Singhb53420c2016-03-09 14:32:57 +05301801 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301802}
1803
1804
1805
1806/**
1807 * wmi_unified_extscan_start_change_monitor_cmd() - start change monitor cmd
1808 * @wmi_hdl: wmi handle
1809 * @psigchange: change monitor request params
1810 *
1811 * This function sends start change monitor request to fw.
1812 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301813 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301814 */
Govind Singhb53420c2016-03-09 14:32:57 +05301815QDF_STATUS wmi_unified_extscan_start_change_monitor_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301816 struct extscan_set_sig_changereq_params *
1817 psigchange)
1818{
1819 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1820
1821 if (wmi_handle->ops->send_extscan_start_change_monitor_cmd)
1822 return wmi_handle->ops->send_extscan_start_change_monitor_cmd(wmi_handle,
1823 psigchange);
1824
Govind Singhb53420c2016-03-09 14:32:57 +05301825 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301826}
1827
1828/**
1829 * wmi_unified_extscan_stop_hotlist_monitor_cmd() - stop hotlist monitor
1830 * @wmi_hdl: wmi handle
1831 * @photlist_reset: hotlist reset params
1832 *
1833 * This function configures hotlist monitor to stop in fw.
1834 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301835 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301836 */
Govind Singhb53420c2016-03-09 14:32:57 +05301837QDF_STATUS wmi_unified_extscan_stop_hotlist_monitor_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301838 struct extscan_bssid_hotlist_reset_params *photlist_reset)
1839{
1840 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1841
1842 if (wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd)
1843 return wmi_handle->ops->send_extscan_stop_hotlist_monitor_cmd(wmi_handle,
1844 photlist_reset);
1845
Govind Singhb53420c2016-03-09 14:32:57 +05301846 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301847}
1848
1849/**
1850 * wmi_unified_stop_extscan_cmd() - stop extscan command to fw.
1851 * @wmi_hdl: wmi handle
1852 * @pstopcmd: stop scan command request params
1853 *
1854 * This function sends stop extscan request to fw.
1855 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301856 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh4eacd2b2016-03-07 14:24:22 +05301857 */
Govind Singhb53420c2016-03-09 14:32:57 +05301858QDF_STATUS wmi_unified_stop_extscan_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301859 struct extscan_stop_req_params *pstopcmd)
1860{
1861 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1862
1863 if (wmi_handle->ops->send_stop_extscan_cmd)
1864 return wmi_handle->ops->send_stop_extscan_cmd(wmi_handle,
1865 pstopcmd);
1866
Govind Singhb53420c2016-03-09 14:32:57 +05301867 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301868}
1869
1870/**
1871 * wmi_unified_start_extscan_cmd() - start extscan command to fw.
1872 * @wmi_hdl: wmi handle
1873 * @pstart: scan command request params
1874 *
1875 * This function sends start extscan request to fw.
1876 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301877 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singh4eacd2b2016-03-07 14:24:22 +05301878 */
Govind Singhb53420c2016-03-09 14:32:57 +05301879QDF_STATUS wmi_unified_start_extscan_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301880 struct wifi_scan_cmd_req_params *pstart)
1881{
1882 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1883
1884 if (wmi_handle->ops->send_start_extscan_cmd)
1885 return wmi_handle->ops->send_start_extscan_cmd(wmi_handle,
1886 pstart);
1887
Govind Singhb53420c2016-03-09 14:32:57 +05301888 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301889}
1890
1891/**
1892 * wmi_unified_plm_stop_cmd() - plm stop request
1893 * @wmi_hdl: wmi handle
1894 * @plm: plm request parameters
1895 *
1896 * This function request FW to stop PLM.
1897 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301898 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301899 */
Govind Singhb53420c2016-03-09 14:32:57 +05301900QDF_STATUS wmi_unified_plm_stop_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301901 const struct plm_req_params *plm)
1902{
1903 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1904
1905 if (wmi_handle->ops->send_plm_stop_cmd)
1906 return wmi_handle->ops->send_plm_stop_cmd(wmi_handle,
1907 plm);
1908
Govind Singhb53420c2016-03-09 14:32:57 +05301909 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301910}
1911
1912/**
1913 * wmi_unified_plm_start_cmd() - plm start request
1914 * @wmi_hdl: wmi handle
1915 * @plm: plm request parameters
1916 *
1917 * This function request FW to start PLM.
1918 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301919 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301920 */
Govind Singhb53420c2016-03-09 14:32:57 +05301921QDF_STATUS wmi_unified_plm_start_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05301922 const struct plm_req_params *plm,
1923 uint32_t *gchannel_list)
1924{
1925 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1926
1927 if (wmi_handle->ops->send_plm_start_cmd)
1928 return wmi_handle->ops->send_plm_start_cmd(wmi_handle,
1929 plm, gchannel_list);
1930
Govind Singhb53420c2016-03-09 14:32:57 +05301931 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301932}
1933
1934/**
1935 * send_pno_stop_cmd() - PNO stop request
1936 * @wmi_hdl: wmi handle
1937 * @vdev_id: vdev id
1938 *
1939 * This function request FW to stop ongoing PNO operation.
1940 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301941 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301942 */
Govind Singhb53420c2016-03-09 14:32:57 +05301943QDF_STATUS wmi_unified_pno_stop_cmd(void *wmi_hdl, uint8_t vdev_id)
Govind Singh4eacd2b2016-03-07 14:24:22 +05301944{
1945 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1946
1947 if (wmi_handle->ops->send_pno_stop_cmd)
1948 return wmi_handle->ops->send_pno_stop_cmd(wmi_handle,
1949 vdev_id);
1950
Govind Singhb53420c2016-03-09 14:32:57 +05301951 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301952}
1953
1954/**
1955 * wmi_unified_pno_start_cmd() - PNO start request
1956 * @wmi_hdl: wmi handle
1957 * @pno: PNO request
Govind Singh4eacd2b2016-03-07 14:24:22 +05301958 *
1959 * This function request FW to start PNO request.
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301960 * Request: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05301961 */
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301962#ifdef FEATURE_WLAN_SCAN_PNO
Govind Singhb53420c2016-03-09 14:32:57 +05301963QDF_STATUS wmi_unified_pno_start_cmd(void *wmi_hdl,
Abhishek Singh5987b632017-03-03 22:09:07 +05301964 struct pno_scan_req_params *pno)
Govind Singh4eacd2b2016-03-07 14:24:22 +05301965{
1966 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1967
1968 if (wmi_handle->ops->send_pno_start_cmd)
1969 return wmi_handle->ops->send_pno_start_cmd(wmi_handle,
Abhishek Singh5987b632017-03-03 22:09:07 +05301970 pno);
Govind Singh4eacd2b2016-03-07 14:24:22 +05301971
Govind Singhb53420c2016-03-09 14:32:57 +05301972 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05301973}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05301974#endif
Govind Singh4eacd2b2016-03-07 14:24:22 +05301975
Varun Reddy Yeturueac038b2017-07-24 16:11:22 -07001976/**
1977 * wmi_unified_nlo_mawc_cmd() - NLO MAWC cmd configuration
1978 * @wmi_hdl: wmi handle
1979 * @params: Configuration parameters
1980 *
1981 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
1982 */
1983QDF_STATUS wmi_unified_nlo_mawc_cmd(void *wmi_hdl,
1984 struct nlo_mawc_params *params)
1985{
1986 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
1987
1988 if (wmi_handle->ops->send_nlo_mawc_cmd)
1989 return wmi_handle->ops->send_nlo_mawc_cmd(wmi_handle, params);
1990
1991 return QDF_STATUS_E_FAILURE;
1992}
1993
Govind Singh4eacd2b2016-03-07 14:24:22 +05301994/* wmi_unified_set_ric_req_cmd() - set ric request element
1995 * @wmi_hdl: wmi handle
1996 * @msg: message
1997 * @is_add_ts: is addts required
1998 *
1999 * This function sets ric request element for 11r roaming.
2000 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302001 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05302002 */
Govind Singhb53420c2016-03-09 14:32:57 +05302003QDF_STATUS wmi_unified_set_ric_req_cmd(void *wmi_hdl, void *msg,
Govind Singh4eacd2b2016-03-07 14:24:22 +05302004 uint8_t is_add_ts)
2005{
2006 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2007
2008 if (wmi_handle->ops->send_set_ric_req_cmd)
2009 return wmi_handle->ops->send_set_ric_req_cmd(wmi_handle, msg,
2010 is_add_ts);
2011
Govind Singhb53420c2016-03-09 14:32:57 +05302012 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05302013}
2014
2015/**
2016 * wmi_unified_process_ll_stats_clear_cmd() - clear link layer stats
2017 * @wmi_hdl: wmi handle
2018 * @clear_req: ll stats clear request command params
2019 * @addr: mac address
2020 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302021 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05302022 */
Govind Singhb53420c2016-03-09 14:32:57 +05302023QDF_STATUS wmi_unified_process_ll_stats_clear_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05302024 const struct ll_stats_clear_params *clear_req,
2025 uint8_t addr[IEEE80211_ADDR_LEN])
2026{
2027 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2028
2029 if (wmi_handle->ops->send_process_ll_stats_clear_cmd)
2030 return wmi_handle->ops->send_process_ll_stats_clear_cmd(wmi_handle,
2031 clear_req, addr);
2032
Govind Singhb53420c2016-03-09 14:32:57 +05302033 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05302034}
2035
2036/**
2037 * wmi_unified_process_ll_stats_get_cmd() - link layer stats get request
2038 * @wmi_hdl:wmi handle
2039 * @get_req:ll stats get request command params
2040 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302041 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05302042 */
Govind Singhb53420c2016-03-09 14:32:57 +05302043QDF_STATUS wmi_unified_process_ll_stats_get_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05302044 const struct ll_stats_get_params *get_req,
2045 uint8_t addr[IEEE80211_ADDR_LEN])
2046{
2047 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2048
2049 if (wmi_handle->ops->send_process_ll_stats_get_cmd)
2050 return wmi_handle->ops->send_process_ll_stats_get_cmd(wmi_handle,
2051 get_req, addr);
2052
Govind Singhb53420c2016-03-09 14:32:57 +05302053 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05302054}
2055
2056/**
Padma, Santhosh Kumarcb1ee462017-03-21 19:09:35 +05302057 * wmi_unified_congestion_request_cmd() - send request to fw to get CCA
2058 * @wmi_hdl: wma handle
2059 * @vdev_id: vdev id
2060 *
2061 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
2062 */
2063QDF_STATUS wmi_unified_congestion_request_cmd(void *wmi_hdl,
2064 uint8_t vdev_id)
2065{
2066 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2067
2068 if (wmi_handle->ops->send_congestion_cmd)
2069 return wmi_handle->ops->send_congestion_cmd(wmi_handle,
2070 vdev_id);
2071
2072 return QDF_STATUS_E_FAILURE;
2073}
2074
2075/**
Govind Singh4eacd2b2016-03-07 14:24:22 +05302076 * wmi_unified_process_ll_stats_set_cmd() - link layer stats set request
2077 * @wmi_handle: wmi handle
2078 * @set_req: ll stats set request command params
2079 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302080 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh4eacd2b2016-03-07 14:24:22 +05302081 */
Govind Singhb53420c2016-03-09 14:32:57 +05302082QDF_STATUS wmi_unified_process_ll_stats_set_cmd(void *wmi_hdl,
Govind Singh4eacd2b2016-03-07 14:24:22 +05302083 const struct ll_stats_set_params *set_req)
2084{
2085 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2086
2087 if (wmi_handle->ops->send_process_ll_stats_set_cmd)
2088 return wmi_handle->ops->send_process_ll_stats_set_cmd(wmi_handle,
2089 set_req);
2090
Govind Singhb53420c2016-03-09 14:32:57 +05302091 return QDF_STATUS_E_FAILURE;
Govind Singh4eacd2b2016-03-07 14:24:22 +05302092}
Govind Singh20c5dac2016-03-07 15:33:31 +05302093
2094/**
2095 * wmi_unified_snr_request_cmd() - send request to fw to get RSSI stats
2096 * @wmi_handle: wmi handle
2097 * @rssi_req: get RSSI request
2098 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302099 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302100 */
Govind Singhb53420c2016-03-09 14:32:57 +05302101QDF_STATUS wmi_unified_snr_request_cmd(void *wmi_hdl)
Govind Singh20c5dac2016-03-07 15:33:31 +05302102{
2103 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2104
2105 if (wmi_handle->ops->send_snr_request_cmd)
2106 return wmi_handle->ops->send_snr_request_cmd(wmi_handle);
2107
Govind Singhb53420c2016-03-09 14:32:57 +05302108 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302109}
2110
2111/**
2112 * wmi_unified_snr_cmd() - get RSSI from fw
2113 * @wmi_handle: wmi handle
2114 * @vdev_id: vdev id
2115 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302116 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302117 */
Govind Singhb53420c2016-03-09 14:32:57 +05302118QDF_STATUS wmi_unified_snr_cmd(void *wmi_hdl, uint8_t vdev_id)
Govind Singh20c5dac2016-03-07 15:33:31 +05302119{
2120 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2121
2122 if (wmi_handle->ops->send_snr_cmd)
2123 return wmi_handle->ops->send_snr_cmd(wmi_handle,
2124 vdev_id);
2125
Govind Singhb53420c2016-03-09 14:32:57 +05302126 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302127}
2128
2129/**
2130 * wmi_unified_link_status_req_cmd() - process link status request from UMAC
2131 * @wmi_handle: wmi handle
2132 * @link_status: get link params
2133 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302134 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302135 */
Govind Singhb53420c2016-03-09 14:32:57 +05302136QDF_STATUS wmi_unified_link_status_req_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302137 struct link_status_params *link_status)
2138{
2139 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2140
2141 if (wmi_handle->ops->send_link_status_req_cmd)
2142 return wmi_handle->ops->send_link_status_req_cmd(wmi_handle,
2143 link_status);
2144
Govind Singhb53420c2016-03-09 14:32:57 +05302145 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302146}
2147
Govind Singh20c5dac2016-03-07 15:33:31 +05302148/**
2149 * wmi_unified_process_dhcp_ind() - process dhcp indication from SME
2150 * @wmi_handle: wmi handle
2151 * @ta_dhcp_ind: DHCP indication parameter
2152 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302153 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302154 */
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05302155#ifdef CONFIG_MCL
Govind Singhb53420c2016-03-09 14:32:57 +05302156QDF_STATUS wmi_unified_process_dhcp_ind(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302157 wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
2158{
2159 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2160
2161 if (wmi_handle->ops->send_process_dhcp_ind_cmd)
2162 return wmi_handle->ops->send_process_dhcp_ind_cmd(wmi_handle,
2163 ta_dhcp_ind);
2164
Govind Singhb53420c2016-03-09 14:32:57 +05302165 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302166}
2167
2168/**
2169 * wmi_unified_get_link_speed_cmd() -send command to get linkspeed
2170 * @wmi_handle: wmi handle
2171 * @pLinkSpeed: link speed info
2172 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302173 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302174 */
Govind Singhb53420c2016-03-09 14:32:57 +05302175QDF_STATUS wmi_unified_get_link_speed_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302176 wmi_mac_addr peer_macaddr)
2177{
2178 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2179
2180 if (wmi_handle->ops->send_get_link_speed_cmd)
2181 return wmi_handle->ops->send_get_link_speed_cmd(wmi_handle,
2182 peer_macaddr);
2183
Govind Singhb53420c2016-03-09 14:32:57 +05302184 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302185}
2186
2187/**
2188 * wmi_unified_egap_conf_params_cmd() - send wmi cmd of egap configuration params
2189 * @wmi_handle: wmi handler
2190 * @egap_params: pointer to egap_params
2191 *
2192 * Return: 0 for success, otherwise appropriate error code
2193 */
Govind Singhb53420c2016-03-09 14:32:57 +05302194QDF_STATUS wmi_unified_egap_conf_params_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302195 wmi_ap_ps_egap_param_cmd_fixed_param *egap_params)
2196{
2197 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2198
2199 if (wmi_handle->ops->send_egap_conf_params_cmd)
2200 return wmi_handle->ops->send_egap_conf_params_cmd(wmi_handle,
2201 egap_params);
2202
Govind Singhb53420c2016-03-09 14:32:57 +05302203 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302204}
Paul Zhangd19abd82017-01-04 16:45:42 +08002205
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302206#endif
Govind Singh20c5dac2016-03-07 15:33:31 +05302207
2208/**
2209 * wmi_unified_fw_profiling_data_cmd() - send FW profiling cmd to WLAN FW
2210 * @wmi_handl: wmi handle
2211 * @cmd: Profiling command index
2212 * @value1: parameter1 value
2213 * @value2: parameter2 value
2214 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302215 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302216 */
Govind Singhb53420c2016-03-09 14:32:57 +05302217QDF_STATUS wmi_unified_fw_profiling_data_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302218 uint32_t cmd, uint32_t value1, uint32_t value2)
2219{
2220 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2221
2222 if (wmi_handle->ops->send_fw_profiling_cmd)
2223 return wmi_handle->ops->send_fw_profiling_cmd(wmi_handle,
2224 cmd, value1, value2);
2225
Govind Singhb53420c2016-03-09 14:32:57 +05302226 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302227}
2228
Govind Singh20c5dac2016-03-07 15:33:31 +05302229/**
2230 * wmi_unified_nat_keepalive_en_cmd() - enable NAT keepalive filter
2231 * @wmi_handle: wmi handle
2232 * @vdev_id: vdev id
2233 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302234 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302235 */
Govind Singhb53420c2016-03-09 14:32:57 +05302236QDF_STATUS wmi_unified_nat_keepalive_en_cmd(void *wmi_hdl, uint8_t vdev_id)
Govind Singh20c5dac2016-03-07 15:33:31 +05302237{
2238 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2239
2240 if (wmi_handle->ops->send_nat_keepalive_en_cmd)
2241 return wmi_handle->ops->send_nat_keepalive_en_cmd(wmi_handle,
2242 vdev_id);
2243
Govind Singhb53420c2016-03-09 14:32:57 +05302244 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302245}
2246
2247/**
2248 * wmi_unified_csa_offload_enable() - send CSA offload enable command
2249 * @wmi_hdl: wmi handle
2250 * @vdev_id: vdev id
2251 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302252 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302253 */
Govind Singhb53420c2016-03-09 14:32:57 +05302254QDF_STATUS wmi_unified_csa_offload_enable(void *wmi_hdl, uint8_t vdev_id)
Govind Singh20c5dac2016-03-07 15:33:31 +05302255{
2256 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2257
2258 if (wmi_handle->ops->send_csa_offload_enable_cmd)
2259 return wmi_handle->ops->send_csa_offload_enable_cmd(wmi_handle,
2260 vdev_id);
2261
Govind Singhb53420c2016-03-09 14:32:57 +05302262 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302263}
Naveen Rawat42cd1e62017-05-13 15:56:57 -07002264
2265#ifdef WLAN_FEATURE_CIF_CFR
2266QDF_STATUS wmi_unified_oem_dma_ring_cfg(void *wmi_hdl,
2267 wmi_oem_dma_ring_cfg_req_fixed_param *cfg)
2268{
2269 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2270
2271 if (wmi_handle->ops->send_start_oem_data_cmd)
2272 return wmi_handle->ops->send_oem_dma_cfg_cmd(wmi_handle, cfg);
2273
2274 return QDF_STATUS_E_FAILURE;
2275}
2276#endif
2277
Govind Singh20c5dac2016-03-07 15:33:31 +05302278/**
2279 * wmi_unified_start_oem_data_cmd() - start OEM data request to target
2280 * @wmi_handle: wmi handle
2281 * @startOemDataReq: start request params
2282 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302283 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302284 */
Govind Singhb53420c2016-03-09 14:32:57 +05302285QDF_STATUS wmi_unified_start_oem_data_cmd(void *wmi_hdl,
Krishna Kumaar Natarajanb16bb272016-07-21 15:02:44 -07002286 uint32_t data_len,
Govind Singh20c5dac2016-03-07 15:33:31 +05302287 uint8_t *data)
2288{
2289 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2290
2291 if (wmi_handle->ops->send_start_oem_data_cmd)
2292 return wmi_handle->ops->send_start_oem_data_cmd(wmi_handle,
2293 data_len, data);
2294
Govind Singhb53420c2016-03-09 14:32:57 +05302295 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302296}
2297
2298/**
2299 * wmi_unified_dfs_phyerr_filter_offload_en_cmd() - enable dfs phyerr filter
2300 * @wmi_handle: wmi handle
2301 * @dfs_phyerr_filter_offload: is dfs phyerr filter offload
2302 *
2303 * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or
2304 * WMI_DFS_PHYERR_FILTER_DIS_CMDID command
2305 * to firmware based on phyerr filtering
2306 * offload status.
2307 *
2308 * Return: 1 success, 0 failure
2309 */
Govind Singhb53420c2016-03-09 14:32:57 +05302310QDF_STATUS
Govind Singh20c5dac2016-03-07 15:33:31 +05302311wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl,
2312 bool dfs_phyerr_filter_offload)
2313{
2314 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2315
2316 if (wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd)
2317 return wmi_handle->ops->send_dfs_phyerr_filter_offload_en_cmd(wmi_handle,
2318 dfs_phyerr_filter_offload);
2319
Govind Singhb53420c2016-03-09 14:32:57 +05302320 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302321}
2322
2323#if !defined(REMOVE_PKT_LOG)
2324/**
2325 * wmi_unified_pktlog_wmi_send_cmd() - send pktlog enable/disable command to target
2326 * @wmi_handle: wmi handle
2327 * @pktlog_event: pktlog event
2328 * @cmd_id: pktlog cmd id
2329 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302330 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302331 */
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05302332#ifdef CONFIG_MCL
Govind Singhb53420c2016-03-09 14:32:57 +05302333QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302334 WMI_PKTLOG_EVENT pktlog_event,
Nirav Shah47ec2482016-07-27 19:06:13 +05302335 uint32_t cmd_id,
2336 uint8_t user_triggered)
Govind Singh20c5dac2016-03-07 15:33:31 +05302337{
2338 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2339
2340 if (wmi_handle->ops->send_pktlog_wmi_send_cmd)
2341 return wmi_handle->ops->send_pktlog_wmi_send_cmd(wmi_handle,
Nirav Shah47ec2482016-07-27 19:06:13 +05302342 pktlog_event, cmd_id, user_triggered);
Govind Singh20c5dac2016-03-07 15:33:31 +05302343
Govind Singhb53420c2016-03-09 14:32:57 +05302344 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302345}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302346#endif
Govind Singh20c5dac2016-03-07 15:33:31 +05302347#endif /* REMOVE_PKT_LOG */
2348
2349/**
Govind Singh20c5dac2016-03-07 15:33:31 +05302350 * wmi_unified_wow_delete_pattern_cmd() - delete wow pattern in target
2351 * @wmi_handle: wmi handle
2352 * @ptrn_id: pattern id
2353 * @vdev_id: vdev id
2354 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302355 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302356 */
Govind Singhb53420c2016-03-09 14:32:57 +05302357QDF_STATUS wmi_unified_wow_delete_pattern_cmd(void *wmi_hdl, uint8_t ptrn_id,
Govind Singh20c5dac2016-03-07 15:33:31 +05302358 uint8_t vdev_id)
2359{
2360 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2361
2362 if (wmi_handle->ops->send_wow_delete_pattern_cmd)
2363 return wmi_handle->ops->send_wow_delete_pattern_cmd(wmi_handle,
2364 ptrn_id, vdev_id);
2365
Govind Singhb53420c2016-03-09 14:32:57 +05302366 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302367}
2368
2369/**
2370 * wmi_unified_host_wakeup_ind_to_fw_cmd() - send wakeup ind to fw
2371 * @wmi_handle: wmi handle
2372 *
2373 * Sends host wakeup indication to FW. On receiving this indication,
2374 * FW will come out of WOW.
2375 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302376 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302377 */
Govind Singhb53420c2016-03-09 14:32:57 +05302378QDF_STATUS wmi_unified_host_wakeup_ind_to_fw_cmd(void *wmi_hdl)
Govind Singh20c5dac2016-03-07 15:33:31 +05302379{
2380 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2381
2382 if (wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd)
2383 return wmi_handle->ops->send_host_wakeup_ind_to_fw_cmd(wmi_handle);
2384
Govind Singhb53420c2016-03-09 14:32:57 +05302385 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302386}
2387
2388/**
2389 * wmi_unified_del_ts_cmd() - send DELTS request to fw
2390 * @wmi_handle: wmi handle
2391 * @msg: delts params
2392 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302393 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302394 */
Govind Singhb53420c2016-03-09 14:32:57 +05302395QDF_STATUS wmi_unified_del_ts_cmd(void *wmi_hdl, uint8_t vdev_id,
Govind Singh20c5dac2016-03-07 15:33:31 +05302396 uint8_t ac)
2397{
2398 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2399
2400 if (wmi_handle->ops->send_del_ts_cmd)
2401 return wmi_handle->ops->send_del_ts_cmd(wmi_handle,
2402 vdev_id, ac);
2403
Govind Singhb53420c2016-03-09 14:32:57 +05302404 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302405}
2406
2407/**
2408 * wmi_unified_aggr_qos_cmd() - send aggr qos request to fw
2409 * @wmi_handle: handle to wmi
2410 * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests.
2411 *
Govind Singhb53420c2016-03-09 14:32:57 +05302412 * A function to handle WMI_AGGR_QOS_REQ. This will send out
Govind Singh20c5dac2016-03-07 15:33:31 +05302413 * ADD_TS requestes to firmware in loop for all the ACs with
2414 * active flow.
2415 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302416 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302417 */
Govind Singhb53420c2016-03-09 14:32:57 +05302418QDF_STATUS wmi_unified_aggr_qos_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302419 struct aggr_add_ts_param *aggr_qos_rsp_msg)
2420{
2421 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2422
2423 if (wmi_handle->ops->send_aggr_qos_cmd)
2424 return wmi_handle->ops->send_aggr_qos_cmd(wmi_handle,
2425 aggr_qos_rsp_msg);
2426
Govind Singhb53420c2016-03-09 14:32:57 +05302427 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302428}
2429
2430/**
2431 * wmi_unified_add_ts_cmd() - send ADDTS request to fw
2432 * @wmi_handle: wmi handle
2433 * @msg: ADDTS params
2434 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302435 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302436 */
Govind Singhb53420c2016-03-09 14:32:57 +05302437QDF_STATUS wmi_unified_add_ts_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302438 struct add_ts_param *msg)
2439{
2440 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2441
2442 if (wmi_handle->ops->send_add_ts_cmd)
2443 return wmi_handle->ops->send_add_ts_cmd(wmi_handle,
2444 msg);
2445
Govind Singhb53420c2016-03-09 14:32:57 +05302446 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302447}
2448
2449/**
Govind Singh20c5dac2016-03-07 15:33:31 +05302450 * wmi_unified_process_add_periodic_tx_ptrn_cmd - add periodic tx ptrn
2451 * @wmi_handle: wmi handle
2452 * @pAddPeriodicTxPtrnParams: tx ptrn params
2453 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302454 * Retrun: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302455 */
Govind Singhb53420c2016-03-09 14:32:57 +05302456QDF_STATUS wmi_unified_process_add_periodic_tx_ptrn_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302457 struct periodic_tx_pattern *
2458 pAddPeriodicTxPtrnParams,
2459 uint8_t vdev_id)
2460{
2461 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2462
2463 if (wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd)
2464 return wmi_handle->ops->send_process_add_periodic_tx_ptrn_cmd(wmi_handle,
2465 pAddPeriodicTxPtrnParams,
2466 vdev_id);
2467
Govind Singhb53420c2016-03-09 14:32:57 +05302468 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302469}
2470
2471/**
2472 * wmi_unified_process_del_periodic_tx_ptrn_cmd - del periodic tx ptrn
2473 * @wmi_handle: wmi handle
2474 * @vdev_id: vdev id
2475 * @pattern_id: pattern id
2476 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302477 * Retrun: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302478 */
Govind Singhb53420c2016-03-09 14:32:57 +05302479QDF_STATUS wmi_unified_process_del_periodic_tx_ptrn_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302480 uint8_t vdev_id,
2481 uint8_t pattern_id)
2482{
2483 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2484
2485 if (wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd)
2486 return wmi_handle->ops->send_process_del_periodic_tx_ptrn_cmd(wmi_handle,
2487 vdev_id,
2488 pattern_id);
2489
Govind Singhb53420c2016-03-09 14:32:57 +05302490 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302491}
2492
2493/**
2494 * wmi_unified_stats_ext_req_cmd() - request ext stats from fw
2495 * @wmi_handle: wmi handle
2496 * @preq: stats ext params
2497 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302498 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302499 */
Govind Singhb53420c2016-03-09 14:32:57 +05302500QDF_STATUS wmi_unified_stats_ext_req_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302501 struct stats_ext_params *preq)
2502{
2503 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2504
2505 if (wmi_handle->ops->send_stats_ext_req_cmd)
2506 return wmi_handle->ops->send_stats_ext_req_cmd(wmi_handle,
2507 preq);
2508
Govind Singhb53420c2016-03-09 14:32:57 +05302509 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302510}
2511
2512/**
2513 * wmi_unified_enable_ext_wow_cmd() - enable ext wow in fw
2514 * @wmi_handle: wmi handle
2515 * @params: ext wow params
2516 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302517 * Return:QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302518 */
Govind Singhb53420c2016-03-09 14:32:57 +05302519QDF_STATUS wmi_unified_enable_ext_wow_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302520 struct ext_wow_params *params)
2521{
2522 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2523
2524 if (wmi_handle->ops->send_enable_ext_wow_cmd)
2525 return wmi_handle->ops->send_enable_ext_wow_cmd(wmi_handle,
2526 params);
2527
Govind Singhb53420c2016-03-09 14:32:57 +05302528 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302529}
2530
2531/**
2532 * wmi_unified_set_app_type2_params_in_fw_cmd() - set app type2 params in fw
2533 * @wmi_handle: wmi handle
2534 * @appType2Params: app type2 params
2535 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302536 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302537 */
Govind Singhb53420c2016-03-09 14:32:57 +05302538QDF_STATUS wmi_unified_set_app_type2_params_in_fw_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302539 struct app_type2_params *appType2Params)
2540{
2541 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2542
2543 if (wmi_handle->ops->send_set_app_type2_params_in_fw_cmd)
2544 return wmi_handle->ops->send_set_app_type2_params_in_fw_cmd(wmi_handle,
2545 appType2Params);
2546
Govind Singhb53420c2016-03-09 14:32:57 +05302547 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302548
2549}
2550
2551/**
2552 * wmi_unified_set_auto_shutdown_timer_cmd() - sets auto shutdown timer in firmware
2553 * @wmi_handle: wmi handle
2554 * @timer_val: auto shutdown timer value
2555 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302556 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302557 */
Govind Singhb53420c2016-03-09 14:32:57 +05302558QDF_STATUS wmi_unified_set_auto_shutdown_timer_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302559 uint32_t timer_val)
2560{
2561 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2562
2563 if (wmi_handle->ops->send_set_auto_shutdown_timer_cmd)
2564 return wmi_handle->ops->send_set_auto_shutdown_timer_cmd(wmi_handle,
2565 timer_val);
2566
Govind Singhb53420c2016-03-09 14:32:57 +05302567 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302568}
2569
2570/**
2571 * wmi_unified_nan_req_cmd() - to send nan request to target
2572 * @wmi_handle: wmi handle
2573 * @nan_req: request data which will be non-null
2574 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302575 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302576 */
Govind Singhb53420c2016-03-09 14:32:57 +05302577QDF_STATUS wmi_unified_nan_req_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302578 struct nan_req_params *nan_req)
2579{
2580 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2581
2582 if (wmi_handle->ops->send_nan_req_cmd)
2583 return wmi_handle->ops->send_nan_req_cmd(wmi_handle,
2584 nan_req);
2585
Govind Singhb53420c2016-03-09 14:32:57 +05302586 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302587}
2588
2589/**
2590 * wmi_unified_process_dhcpserver_offload_cmd() - enable DHCP server offload
2591 * @wmi_handle: wmi handle
2592 * @pDhcpSrvOffloadInfo: DHCP server offload info
2593 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302594 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302595 */
Govind Singhb53420c2016-03-09 14:32:57 +05302596QDF_STATUS wmi_unified_process_dhcpserver_offload_cmd(void *wmi_hdl,
Jeff Johnsona87370f2017-10-04 19:19:20 -07002597 struct dhcp_offload_info_params *params)
Govind Singh20c5dac2016-03-07 15:33:31 +05302598{
2599 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2600
2601 if (wmi_handle->ops->send_process_dhcpserver_offload_cmd)
2602 return wmi_handle->ops->send_process_dhcpserver_offload_cmd(wmi_handle,
Jeff Johnsona87370f2017-10-04 19:19:20 -07002603 params);
Govind Singh20c5dac2016-03-07 15:33:31 +05302604
Govind Singhb53420c2016-03-09 14:32:57 +05302605 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302606}
2607
2608/**
2609 * wmi_unified_process_ch_avoid_update_cmd() - handles channel avoid update request
2610 * @wmi_handle: wmi handle
2611 * @ch_avoid_update_req: channel avoid update params
2612 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302613 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302614 */
Govind Singhb53420c2016-03-09 14:32:57 +05302615QDF_STATUS wmi_unified_process_ch_avoid_update_cmd(void *wmi_hdl)
Govind Singh20c5dac2016-03-07 15:33:31 +05302616{
2617 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2618
2619 if (wmi_handle->ops->send_process_ch_avoid_update_cmd)
2620 return wmi_handle->ops->send_process_ch_avoid_update_cmd(wmi_handle);
2621
Govind Singhb53420c2016-03-09 14:32:57 +05302622 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302623}
2624
2625/**
2626 * wmi_unified_send_regdomain_info_to_fw_cmd() - send regdomain info to fw
2627 * @wmi_handle: wmi handle
2628 * @reg_dmn: reg domain
2629 * @regdmn2G: 2G reg domain
2630 * @regdmn5G: 5G reg domain
2631 * @ctl2G: 2G test limit
2632 * @ctl5G: 5G test limit
2633 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302634 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302635 */
Govind Singhb53420c2016-03-09 14:32:57 +05302636QDF_STATUS wmi_unified_send_regdomain_info_to_fw_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302637 uint32_t reg_dmn, uint16_t regdmn2G,
Rajeev Kumar Sirasanagandla4c1fecd2017-06-06 13:27:56 +05302638 uint16_t regdmn5G, uint8_t ctl2G,
2639 uint8_t ctl5G)
Govind Singh20c5dac2016-03-07 15:33:31 +05302640{
2641 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2642
2643 if (wmi_handle->ops->send_regdomain_info_to_fw_cmd)
2644 return wmi_handle->ops->send_regdomain_info_to_fw_cmd(wmi_handle,
2645 reg_dmn, regdmn2G,
2646 regdmn5G, ctl2G,
2647 ctl5G);
2648
Govind Singhb53420c2016-03-09 14:32:57 +05302649 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302650}
2651
2652
2653/**
2654 * wmi_unified_set_tdls_offchan_mode_cmd() - set tdls off channel mode
2655 * @wmi_handle: wmi handle
2656 * @chan_switch_params: Pointer to tdls channel switch parameter structure
2657 *
2658 * This function sets tdls off channel mode
2659 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302660 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures;
2661 * Negative errno otherwise
Govind Singh20c5dac2016-03-07 15:33:31 +05302662 */
Govind Singhb53420c2016-03-09 14:32:57 +05302663QDF_STATUS wmi_unified_set_tdls_offchan_mode_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302664 struct tdls_channel_switch_params *chan_switch_params)
2665{
2666 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2667
2668 if (wmi_handle->ops->send_set_tdls_offchan_mode_cmd)
2669 return wmi_handle->ops->send_set_tdls_offchan_mode_cmd(wmi_handle,
2670 chan_switch_params);
2671
Govind Singhb53420c2016-03-09 14:32:57 +05302672 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302673}
2674
2675/**
2676 * wmi_unified_update_fw_tdls_state_cmd() - send enable/disable tdls for a vdev
2677 * @wmi_handle: wmi handle
2678 * @pwmaTdlsparams: TDLS params
2679 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302680 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302681 */
Govind Singhb53420c2016-03-09 14:32:57 +05302682QDF_STATUS wmi_unified_update_fw_tdls_state_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302683 void *tdls_param, uint8_t tdls_state)
2684{
2685 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2686
2687 if (wmi_handle->ops->send_update_fw_tdls_state_cmd)
2688 return wmi_handle->ops->send_update_fw_tdls_state_cmd(wmi_handle,
2689 tdls_param, tdls_state);
2690
Govind Singhb53420c2016-03-09 14:32:57 +05302691 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302692}
2693
2694/**
2695 * wmi_unified_update_tdls_peer_state_cmd() - update TDLS peer state
2696 * @wmi_handle: wmi handle
2697 * @peerStateParams: TDLS peer state params
2698 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302699 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302700 */
Govind Singhb53420c2016-03-09 14:32:57 +05302701QDF_STATUS wmi_unified_update_tdls_peer_state_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302702 struct tdls_peer_state_params *peerStateParams,
2703 uint32_t *ch_mhz)
2704{
2705 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2706
2707 if (wmi_handle->ops->send_update_tdls_peer_state_cmd)
2708 return wmi_handle->ops->send_update_tdls_peer_state_cmd(wmi_handle,
2709 peerStateParams, ch_mhz);
2710
Govind Singhb53420c2016-03-09 14:32:57 +05302711 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302712}
2713
2714/**
2715 * wmi_unified_process_fw_mem_dump_cmd() - Function to request fw memory dump from
2716 * firmware
2717 * @wmi_handle: Pointer to wmi handle
2718 * @mem_dump_req: Pointer for mem_dump_req
2719 *
2720 * This function sends memory dump request to firmware
2721 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302722 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302723 *
2724 */
Govind Singhb53420c2016-03-09 14:32:57 +05302725QDF_STATUS wmi_unified_process_fw_mem_dump_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302726 struct fw_dump_req_param *mem_dump_req)
2727{
2728 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2729
2730 if (wmi_handle->ops->send_process_fw_mem_dump_cmd)
2731 return wmi_handle->ops->send_process_fw_mem_dump_cmd(wmi_handle,
2732 mem_dump_req);
2733
Govind Singhb53420c2016-03-09 14:32:57 +05302734 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302735}
2736
2737/**
2738 * wmi_unified_process_set_ie_info_cmd() - Function to send IE info to firmware
2739 * @wmi_handle: Pointer to WMi handle
2740 * @ie_data: Pointer for ie data
2741 *
2742 * This function sends IE information to firmware
2743 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302744 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh20c5dac2016-03-07 15:33:31 +05302745 *
2746 */
Govind Singhb53420c2016-03-09 14:32:57 +05302747QDF_STATUS wmi_unified_process_set_ie_info_cmd(void *wmi_hdl,
Govind Singh20c5dac2016-03-07 15:33:31 +05302748 struct vdev_ie_info_param *ie_info)
2749{
2750 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2751
2752 if (wmi_handle->ops->send_process_set_ie_info_cmd)
2753 return wmi_handle->ops->send_process_set_ie_info_cmd(wmi_handle,
2754 ie_info);
2755
Govind Singhb53420c2016-03-09 14:32:57 +05302756 return QDF_STATUS_E_FAILURE;
Govind Singh20c5dac2016-03-07 15:33:31 +05302757}
Himanshu Agarwal7c83dcd2016-07-19 15:41:51 +05302758#ifdef CONFIG_MCL
Govind Singh9ddd5162016-03-07 16:30:32 +05302759/**
2760 * wmi_unified_send_init_cmd() - wmi init command
2761 * @wmi_handle: pointer to wmi handle
2762 * @res_cfg: resource config
2763 * @num_mem_chunks: no of mem chunck
2764 * @mem_chunk: pointer to mem chunck structure
2765 *
2766 * This function sends IE information to firmware
2767 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302768 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh9ddd5162016-03-07 16:30:32 +05302769 *
2770 */
Govind Singhb53420c2016-03-09 14:32:57 +05302771QDF_STATUS wmi_unified_send_init_cmd(void *wmi_hdl,
Govind Singh9ddd5162016-03-07 16:30:32 +05302772 wmi_resource_config *res_cfg,
2773 uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunk,
2774 bool action)
2775{
2776 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2777
2778 if (wmi_handle->ops->send_init_cmd)
2779 return wmi_handle->ops->send_init_cmd(wmi_handle,
2780 res_cfg, num_mem_chunks, mem_chunk, action);
2781
Govind Singhb53420c2016-03-09 14:32:57 +05302782 return QDF_STATUS_E_FAILURE;
Govind Singh9ddd5162016-03-07 16:30:32 +05302783}
Himanshu Agarwal7c83dcd2016-07-19 15:41:51 +05302784#endif
Govind Singh9ddd5162016-03-07 16:30:32 +05302785/**
2786 * wmi_unified_send_saved_init_cmd() - wmi init command
2787 * @wmi_handle: pointer to wmi handle
2788 *
2789 * This function sends IE information to firmware
2790 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302791 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh9ddd5162016-03-07 16:30:32 +05302792 *
2793 */
Govind Singhb53420c2016-03-09 14:32:57 +05302794QDF_STATUS wmi_unified_send_saved_init_cmd(void *wmi_hdl)
Govind Singh9ddd5162016-03-07 16:30:32 +05302795{
2796 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2797
2798 if (wmi_handle->ops->send_saved_init_cmd)
2799 return wmi_handle->ops->send_saved_init_cmd(wmi_handle);
2800
Govind Singhb53420c2016-03-09 14:32:57 +05302801 return QDF_STATUS_E_FAILURE;
Govind Singh9ddd5162016-03-07 16:30:32 +05302802}
2803
2804/**
2805 * wmi_unified_save_fw_version_cmd() - save fw version
2806 * @wmi_handle: pointer to wmi handle
2807 * @res_cfg: resource config
2808 * @num_mem_chunks: no of mem chunck
2809 * @mem_chunk: pointer to mem chunck structure
2810 *
2811 * This function sends IE information to firmware
2812 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302813 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singh9ddd5162016-03-07 16:30:32 +05302814 *
2815 */
Govind Singhb53420c2016-03-09 14:32:57 +05302816QDF_STATUS wmi_unified_save_fw_version_cmd(void *wmi_hdl,
Govind Singh9ddd5162016-03-07 16:30:32 +05302817 void *evt_buf)
2818{
2819 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2820
2821 if (wmi_handle->ops->save_fw_version_cmd)
2822 return wmi_handle->ops->save_fw_version_cmd(wmi_handle,
2823 evt_buf);
2824
Govind Singhb53420c2016-03-09 14:32:57 +05302825 return QDF_STATUS_E_FAILURE;
Govind Singh9ddd5162016-03-07 16:30:32 +05302826}
Govind Singha4836fd2016-03-07 16:45:38 +05302827
2828/**
2829 * send_set_base_macaddr_indicate_cmd() - set base mac address in fw
2830 * @wmi_hdl: wmi handle
2831 * @custom_addr: base mac address
2832 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302833 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302834 */
Govind Singhb53420c2016-03-09 14:32:57 +05302835QDF_STATUS wmi_unified_set_base_macaddr_indicate_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302836 uint8_t *custom_addr)
2837{
2838 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2839
2840 if (wmi_handle->ops->send_set_base_macaddr_indicate_cmd)
2841 return wmi_handle->ops->send_set_base_macaddr_indicate_cmd(wmi_handle,
2842 custom_addr);
2843
Govind Singhb53420c2016-03-09 14:32:57 +05302844 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302845}
2846
2847/**
2848 * wmi_unified_log_supported_evt_cmd() - Enable/Disable FW diag/log events
2849 * @wmi_hdl: wmi handle
2850 * @event: Event received from FW
2851 * @len: Length of the event
2852 *
2853 * Enables the low frequency events and disables the high frequency
2854 * events. Bit 17 indicates if the event if low/high frequency.
2855 * 1 - high frequency, 0 - low frequency
2856 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302857 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures
Govind Singha4836fd2016-03-07 16:45:38 +05302858 */
Govind Singhb53420c2016-03-09 14:32:57 +05302859QDF_STATUS wmi_unified_log_supported_evt_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302860 uint8_t *event,
2861 uint32_t len)
2862{
2863 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2864
2865 if (wmi_handle->ops->send_log_supported_evt_cmd)
2866 return wmi_handle->ops->send_log_supported_evt_cmd(wmi_handle,
2867 event, len);
2868
Govind Singhb53420c2016-03-09 14:32:57 +05302869 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302870}
2871
2872/**
2873 * wmi_unified_enable_specific_fw_logs_cmd() - Start/Stop logging of diag log id
2874 * @wmi_hdl: wmi handle
2875 * @start_log: Start logging related parameters
2876 *
2877 * Send the command to the FW based on which specific logging of diag
2878 * event/log id can be started/stopped
2879 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302880 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302881 */
Govind Singhb53420c2016-03-09 14:32:57 +05302882QDF_STATUS wmi_unified_enable_specific_fw_logs_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302883 struct wmi_wifi_start_log *start_log)
2884{
2885 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2886
2887 if (wmi_handle->ops->send_enable_specific_fw_logs_cmd)
2888 return wmi_handle->ops->send_enable_specific_fw_logs_cmd(wmi_handle,
2889 start_log);
2890
Govind Singhb53420c2016-03-09 14:32:57 +05302891 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302892}
2893
2894/**
2895 * wmi_unified_flush_logs_to_fw_cmd() - Send log flush command to FW
2896 * @wmi_hdl: WMI handle
2897 *
2898 * This function is used to send the flush command to the FW,
2899 * that will flush the fw logs that are residue in the FW
2900 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302901 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302902 */
Govind Singhb53420c2016-03-09 14:32:57 +05302903QDF_STATUS wmi_unified_flush_logs_to_fw_cmd(void *wmi_hdl)
Govind Singha4836fd2016-03-07 16:45:38 +05302904{
2905 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2906
2907 if (wmi_handle->ops->send_flush_logs_to_fw_cmd)
2908 return wmi_handle->ops->send_flush_logs_to_fw_cmd(wmi_handle);
2909
Govind Singhb53420c2016-03-09 14:32:57 +05302910 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302911}
2912
2913/**
Manishekar Chandrasekaran86508512016-04-21 19:16:32 +05302914 * wmi_unified_pdev_set_pcl_cmd() - Send WMI_SOC_SET_PCL_CMDID to FW
Govind Singha4836fd2016-03-07 16:45:38 +05302915 * @wmi_hdl: wmi handle
2916 * @msg: PCL structure containing the PCL and the number of channels
2917 *
2918 * WMI_SOC_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN
2919 * firmware. The DBS Manager is the consumer of this information in the WLAN
2920 * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs
2921 * to migrate to a new channel without host driver involvement. An example of
2922 * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will
2923 * manage the channel selection without firmware involvement.
2924 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302925 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302926 */
Manishekar Chandrasekaran86508512016-04-21 19:16:32 +05302927QDF_STATUS wmi_unified_pdev_set_pcl_cmd(void *wmi_hdl,
2928 struct wmi_pcl_chan_weights *msg)
Govind Singha4836fd2016-03-07 16:45:38 +05302929{
2930 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2931
Manishekar Chandrasekaran86508512016-04-21 19:16:32 +05302932 if (wmi_handle->ops->send_pdev_set_pcl_cmd)
2933 return wmi_handle->ops->send_pdev_set_pcl_cmd(wmi_handle, msg);
Govind Singha4836fd2016-03-07 16:45:38 +05302934
Govind Singhb53420c2016-03-09 14:32:57 +05302935 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302936}
2937
2938/**
2939 * wmi_unified_soc_set_hw_mode_cmd() - Send WMI_SOC_SET_HW_MODE_CMDID to FW
2940 * @wmi_hdl: wmi handle
2941 * @msg: Structure containing the following parameters
2942 *
2943 * - hw_mode_index: The HW_Mode field is a enumerated type that is selected
2944 * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID.
2945 *
2946 * Provides notification to the WLAN firmware that host driver is requesting a
2947 * HardWare (HW) Mode change. This command is needed to support iHelium in the
2948 * configurations that include the Dual Band Simultaneous (DBS) feature.
2949 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302950 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302951 */
Govind Singhb53420c2016-03-09 14:32:57 +05302952QDF_STATUS wmi_unified_soc_set_hw_mode_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302953 uint32_t hw_mode_index)
2954{
2955 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2956
Manishekar Chandrasekaran17183782016-04-27 12:29:16 +05302957 if (wmi_handle->ops->send_pdev_set_hw_mode_cmd)
2958 return wmi_handle->ops->send_pdev_set_hw_mode_cmd(wmi_handle,
Govind Singha4836fd2016-03-07 16:45:38 +05302959 hw_mode_index);
2960
Govind Singhb53420c2016-03-09 14:32:57 +05302961 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302962}
2963
2964/**
Manishekar Chandrasekaran157a4de2016-04-27 12:52:51 +05302965 * wmi_unified_pdev_set_dual_mac_config_cmd() - Set dual mac config to FW
Govind Singha4836fd2016-03-07 16:45:38 +05302966 * @wmi_hdl: wmi handle
2967 * @msg: Dual MAC config parameters
2968 *
2969 * Configures WLAN firmware with the dual MAC features
2970 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302971 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failures.
Govind Singha4836fd2016-03-07 16:45:38 +05302972 */
Manishekar Chandrasekaran157a4de2016-04-27 12:52:51 +05302973QDF_STATUS wmi_unified_pdev_set_dual_mac_config_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302974 struct wmi_dual_mac_config *msg)
2975{
2976 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2977
Manishekar Chandrasekaran157a4de2016-04-27 12:52:51 +05302978 if (wmi_handle->ops->send_pdev_set_dual_mac_config_cmd)
2979 return wmi_handle->ops->send_pdev_set_dual_mac_config_cmd(wmi_handle,
Govind Singha4836fd2016-03-07 16:45:38 +05302980 msg);
2981
Govind Singhb53420c2016-03-09 14:32:57 +05302982 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05302983}
2984
Govind Singha4836fd2016-03-07 16:45:38 +05302985/**
2986 * wmi_unified_set_led_flashing_cmd() - set led flashing in fw
2987 * @wmi_hdl: wmi handle
2988 * @flashing: flashing request
2989 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05302990 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05302991 */
Govind Singhb53420c2016-03-09 14:32:57 +05302992QDF_STATUS wmi_unified_set_led_flashing_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05302993 struct flashing_req_params *flashing)
2994{
2995 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
2996
2997 if (wmi_handle->ops->send_set_led_flashing_cmd)
2998 return wmi_handle->ops->send_set_led_flashing_cmd(wmi_handle,
2999 flashing);
3000
Govind Singhb53420c2016-03-09 14:32:57 +05303001 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303002}
3003
3004/**
3005 * wmi_unified_app_type1_params_in_fw_cmd() - set app type1 params in fw
3006 * @wmi_hdl: wmi handle
3007 * @appType1Params: app type1 params
3008 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303009 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303010 */
Govind Singhb53420c2016-03-09 14:32:57 +05303011QDF_STATUS wmi_unified_app_type1_params_in_fw_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303012 struct app_type1_params *app_type1_params)
3013{
3014 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3015
3016 if (wmi_handle->ops->send_app_type1_params_in_fw_cmd)
3017 return wmi_handle->ops->send_app_type1_params_in_fw_cmd(wmi_handle,
3018 app_type1_params);
3019
Govind Singhb53420c2016-03-09 14:32:57 +05303020 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303021}
3022
3023/**
3024 * wmi_unified_set_ssid_hotlist_cmd() - Handle an SSID hotlist set request
3025 * @wmi_hdl: wmi handle
3026 * @request: SSID hotlist set request
3027 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303028 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303029 */
Govind Singhb53420c2016-03-09 14:32:57 +05303030QDF_STATUS
Govind Singha4836fd2016-03-07 16:45:38 +05303031wmi_unified_set_ssid_hotlist_cmd(void *wmi_hdl,
3032 struct ssid_hotlist_request_params *request)
3033{
3034 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3035
3036 if (wmi_handle->ops->send_set_ssid_hotlist_cmd)
3037 return wmi_handle->ops->send_set_ssid_hotlist_cmd(wmi_handle,
3038 request);
3039
Govind Singhb53420c2016-03-09 14:32:57 +05303040 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303041}
3042
3043/**
3044 * wmi_unified_roam_synch_complete_cmd() - roam synch complete command to fw.
3045 * @wmi_hdl: wmi handle
3046 * @vdev_id: vdev id
3047 *
3048 * This function sends roam synch complete event to fw.
3049 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303050 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303051 */
Govind Singhb53420c2016-03-09 14:32:57 +05303052QDF_STATUS wmi_unified_roam_synch_complete_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303053 uint8_t vdev_id)
3054{
3055 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3056
3057 if (wmi_handle->ops->send_process_roam_synch_complete_cmd)
3058 return wmi_handle->ops->send_process_roam_synch_complete_cmd(wmi_handle,
3059 vdev_id);
3060
Govind Singhb53420c2016-03-09 14:32:57 +05303061 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303062}
3063
3064/**
Anurag Chouhan459e0152016-07-22 20:19:54 +05303065 * wmi_unified_fw_test_cmd() - send fw test command to fw.
3066 * @wmi_hdl: wmi handle
3067 * @wmi_fwtest: fw test command
3068 *
3069 * This function sends fw test command to fw.
3070 *
3071 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3072 */
3073QDF_STATUS wmi_unified_fw_test_cmd(void *wmi_hdl,
3074 struct set_fwtest_params *wmi_fwtest)
3075{
3076 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3077
3078 if (wmi_handle->ops->send_fw_test_cmd)
3079 return wmi_handle->ops->send_fw_test_cmd(wmi_handle,
3080 wmi_fwtest);
3081
3082 return QDF_STATUS_E_FAILURE;
3083
3084}
3085
3086/**
Govind Singha4836fd2016-03-07 16:45:38 +05303087 * wmi_unified_unit_test_cmd() - send unit test command to fw.
3088 * @wmi_hdl: wmi handle
3089 * @wmi_utest: unit test command
3090 *
3091 * This function send unit test command to fw.
3092 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303093 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303094 */
Govind Singhb53420c2016-03-09 14:32:57 +05303095QDF_STATUS wmi_unified_unit_test_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303096 struct wmi_unit_test_cmd *wmi_utest)
3097{
3098 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3099
3100 if (wmi_handle->ops->send_unit_test_cmd)
3101 return wmi_handle->ops->send_unit_test_cmd(wmi_handle,
3102 wmi_utest);
3103
Govind Singhb53420c2016-03-09 14:32:57 +05303104 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303105}
3106
3107/**
3108 * wmi_unified__roam_invoke_cmd() - send roam invoke command to fw.
3109 * @wmi_hdl: wmi handle
3110 * @roaminvoke: roam invoke command
3111 *
3112 * Send roam invoke command to fw for fastreassoc.
3113 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303114 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303115 */
Govind Singhb53420c2016-03-09 14:32:57 +05303116QDF_STATUS wmi_unified_roam_invoke_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303117 struct wmi_roam_invoke_cmd *roaminvoke,
3118 uint32_t ch_hz)
3119{
3120 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3121
3122 if (wmi_handle->ops->send_roam_invoke_cmd)
3123 return wmi_handle->ops->send_roam_invoke_cmd(wmi_handle,
3124 roaminvoke, ch_hz);
3125
Govind Singhb53420c2016-03-09 14:32:57 +05303126 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303127}
3128
3129/**
3130 * wmi_unified_roam_scan_offload_cmd() - set roam offload command
3131 * @wmi_hdl: wmi handle
3132 * @command: command
3133 * @vdev_id: vdev id
3134 *
3135 * This function set roam offload command to fw.
3136 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303137 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303138 */
Govind Singhb53420c2016-03-09 14:32:57 +05303139QDF_STATUS wmi_unified_roam_scan_offload_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303140 uint32_t command, uint32_t vdev_id)
3141{
3142 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3143
3144 if (wmi_handle->ops->send_roam_scan_offload_cmd)
3145 return wmi_handle->ops->send_roam_scan_offload_cmd(wmi_handle,
3146 command, vdev_id);
3147
Govind Singhb53420c2016-03-09 14:32:57 +05303148 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303149}
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05303150#ifdef CONFIG_MCL
Govind Singha4836fd2016-03-07 16:45:38 +05303151/**
3152 * wmi_unified_send_roam_scan_offload_ap_cmd() - set roam ap profile in fw
3153 * @wmi_hdl: wmi handle
Himanshu Agarwaleaf7d732017-09-28 11:51:35 +05303154 * @ap_profile: ap profile params
Govind Singha4836fd2016-03-07 16:45:38 +05303155 *
3156 * Send WMI_ROAM_AP_PROFILE to firmware
3157 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303158 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303159 */
Govind Singhb53420c2016-03-09 14:32:57 +05303160QDF_STATUS wmi_unified_send_roam_scan_offload_ap_cmd(void *wmi_hdl,
Himanshu Agarwaleaf7d732017-09-28 11:51:35 +05303161 struct ap_profile_params *ap_profile)
Govind Singha4836fd2016-03-07 16:45:38 +05303162{
3163 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3164
3165 if (wmi_handle->ops->send_roam_scan_offload_ap_profile_cmd)
Himanshu Agarwaleaf7d732017-09-28 11:51:35 +05303166 return wmi_handle->ops->send_roam_scan_offload_ap_profile_cmd(
3167 wmi_handle, ap_profile);
Govind Singha4836fd2016-03-07 16:45:38 +05303168
Govind Singhb53420c2016-03-09 14:32:57 +05303169 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303170}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303171#endif
Govind Singha4836fd2016-03-07 16:45:38 +05303172/**
3173 * wmi_unified_roam_scan_offload_scan_period() - set roam offload scan period
3174 * @wmi_handle: wmi handle
3175 * @scan_period: scan period
3176 * @scan_age: scan age
3177 * @vdev_id: vdev id
3178 *
3179 * Send WMI_ROAM_SCAN_PERIOD parameters to fw.
3180 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303181 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303182 */
Govind Singhb53420c2016-03-09 14:32:57 +05303183QDF_STATUS wmi_unified_roam_scan_offload_scan_period(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303184 uint32_t scan_period,
3185 uint32_t scan_age,
3186 uint32_t vdev_id)
3187{
3188 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3189
3190 if (wmi_handle->ops->send_roam_scan_offload_scan_period_cmd)
3191 return wmi_handle->ops->send_roam_scan_offload_scan_period_cmd(wmi_handle,
3192 scan_period, scan_age, vdev_id);
3193
Govind Singhb53420c2016-03-09 14:32:57 +05303194 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303195}
3196
3197/**
3198 * wmi_unified_roam_scan_offload_chan_list_cmd() - set roam offload channel list
3199 * @wmi_handle: wmi handle
3200 * @chan_count: channel count
3201 * @chan_list: channel list
3202 * @list_type: list type
3203 * @vdev_id: vdev id
3204 *
3205 * Set roam offload channel list.
3206 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303207 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303208 */
Govind Singhb53420c2016-03-09 14:32:57 +05303209QDF_STATUS wmi_unified_roam_scan_offload_chan_list_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303210 uint8_t chan_count,
Varun Reddy Yeturu5a552cf2016-07-07 17:42:49 -07003211 uint32_t *chan_list,
Govind Singha4836fd2016-03-07 16:45:38 +05303212 uint8_t list_type, uint32_t vdev_id)
3213{
3214 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3215
3216 if (wmi_handle->ops->send_roam_scan_offload_chan_list_cmd)
3217 return wmi_handle->ops->send_roam_scan_offload_chan_list_cmd(wmi_handle,
3218 chan_count, chan_list,
3219 list_type, vdev_id);
3220
Govind Singhb53420c2016-03-09 14:32:57 +05303221 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303222}
3223
3224/**
3225 * wmi_unified_roam_scan_offload_rssi_change_cmd() - set roam offload RSSI th
3226 * @wmi_hdl: wmi handle
3227 * @rssi_change_thresh: RSSI Change threshold
3228 * @bcn_rssi_weight: beacon RSSI weight
3229 * @vdev_id: vdev id
3230 *
3231 * Send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD parameters to fw.
3232 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303233 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
Govind Singha4836fd2016-03-07 16:45:38 +05303234 */
Govind Singhb53420c2016-03-09 14:32:57 +05303235QDF_STATUS wmi_unified_roam_scan_offload_rssi_change_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303236 uint32_t vdev_id,
3237 int32_t rssi_change_thresh,
3238 uint32_t bcn_rssi_weight,
3239 uint32_t hirssi_delay_btw_scans)
3240{
3241 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3242
3243 if (wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd)
3244 return wmi_handle->ops->send_roam_scan_offload_rssi_change_cmd(wmi_handle,
3245 vdev_id, rssi_change_thresh,
3246 bcn_rssi_weight, hirssi_delay_btw_scans);
3247
Govind Singhb53420c2016-03-09 14:32:57 +05303248 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303249}
3250
Kapil Gupta54ea36e2017-02-24 15:50:03 +05303251QDF_STATUS wmi_unified_set_per_roam_config(void *wmi_hdl,
3252 struct wmi_per_roam_config_req *req_buf)
3253{
3254 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3255
3256 if (wmi_handle->ops->send_per_roam_config_cmd)
3257 return wmi_handle->ops->send_per_roam_config_cmd(wmi_handle,
3258 req_buf);
3259
3260 return QDF_STATUS_E_FAILURE;
3261}
3262
Govind Singha4836fd2016-03-07 16:45:38 +05303263/**
Anurag Chouhan97f00422017-09-11 14:56:30 +05303264 * wmi_unified_set_arp_stats_req() - set arp stats request
3265 * @wmi_hdl: wmi handle
3266 * @req_buf: pointer to set_arp_stats
3267 *
3268 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3269 */
3270QDF_STATUS wmi_unified_set_arp_stats_req(void *wmi_hdl,
3271 struct set_arp_stats *req_buf)
3272{
3273 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3274
3275 if (wmi_handle->ops->send_set_arp_stats_req_cmd)
3276 return wmi_handle->ops->send_set_arp_stats_req_cmd(wmi_handle,
3277 req_buf);
3278
3279 return QDF_STATUS_E_FAILURE;
3280}
3281
3282/**
3283 * wmi_unified_get_arp_stats_req() - get arp stats request
3284 * @wmi_hdl: wmi handle
3285 * @req_buf: pointer to get_arp_stats
3286 *
3287 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3288 */
3289QDF_STATUS wmi_unified_get_arp_stats_req(void *wmi_hdl,
3290 struct get_arp_stats *req_buf)
3291{
3292 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3293
3294 if (wmi_handle->ops->send_get_arp_stats_req_cmd)
3295 return wmi_handle->ops->send_get_arp_stats_req_cmd(wmi_handle,
3296 req_buf);
3297
3298 return QDF_STATUS_E_FAILURE;
3299}
3300
Vignesh Viswanathan81bde492017-09-25 14:36:38 +05303301QDF_STATUS wmi_unified_set_del_pmkid_cache(void *wmi_hdl,
3302 struct wmi_unified_pmk_cache *req_buf)
3303{
3304 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3305
3306 if (wmi_handle->ops->send_set_del_pmkid_cache_cmd)
3307 return wmi_handle->ops->send_set_del_pmkid_cache_cmd(wmi_handle,
3308 req_buf);
3309
3310 return QDF_STATUS_E_FAILURE;
3311}
3312
3313#if defined(WLAN_FEATURE_FILS_SK)
3314QDF_STATUS wmi_unified_roam_send_hlp_cmd(void *wmi_hdl,
3315 struct hlp_params *req_buf)
3316{
3317 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3318
3319 if (wmi_handle->ops->send_roam_scan_hlp_cmd)
3320 return wmi_handle->ops->send_roam_scan_hlp_cmd(wmi_handle,
3321 req_buf);
3322
3323 return QDF_STATUS_E_FAILURE;
3324}
3325#endif
3326
Anurag Chouhan97f00422017-09-11 14:56:30 +05303327/**
Govind Singha4836fd2016-03-07 16:45:38 +05303328 * wmi_unified_get_buf_extscan_hotlist_cmd() - prepare hotlist command
3329 * @wmi_hdl: wmi handle
3330 * @photlist: hotlist command params
3331 * @buf_len: buffer length
3332 *
3333 * This function fills individual elements for hotlist request and
3334 * TLV for bssid entries
3335 *
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303336 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure.
Govind Singha4836fd2016-03-07 16:45:38 +05303337 */
Govind Singhb53420c2016-03-09 14:32:57 +05303338QDF_STATUS wmi_unified_get_buf_extscan_hotlist_cmd(void *wmi_hdl,
Govind Singha4836fd2016-03-07 16:45:38 +05303339 struct ext_scan_setbssi_hotlist_params *
3340 photlist, int *buf_len)
3341{
3342 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3343
3344 if (wmi_handle->ops->send_get_buf_extscan_hotlist_cmd)
3345 return wmi_handle->ops->send_get_buf_extscan_hotlist_cmd(wmi_handle,
3346 photlist, buf_len);
3347
Govind Singhb53420c2016-03-09 14:32:57 +05303348 return QDF_STATUS_E_FAILURE;
Govind Singha4836fd2016-03-07 16:45:38 +05303349}
3350
Dustin Brown4423f632017-01-13 15:24:07 -08003351QDF_STATUS wmi_unified_set_active_bpf_mode_cmd(void *wmi_hdl,
3352 uint8_t vdev_id,
3353 enum wmi_host_active_bpf_mode ucast_mode,
3354 enum wmi_host_active_bpf_mode mcast_bcast_mode)
3355{
3356 wmi_unified_t wmi = (wmi_unified_t)wmi_hdl;
3357
3358 if (!wmi->ops->send_set_active_bpf_mode_cmd) {
Srinivas Girigowda61e086f2017-06-19 17:20:20 -07003359 WMI_LOGD("send_set_active_bpf_mode_cmd op is NULL");
Dustin Brown4423f632017-01-13 15:24:07 -08003360 return QDF_STATUS_E_FAILURE;
3361 }
3362
3363 return wmi->ops->send_set_active_bpf_mode_cmd(wmi, vdev_id,
3364 ucast_mode,
3365 mcast_bcast_mode);
3366}
3367
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303368/**
3369 * wmi_unified_pdev_get_tpc_config_cmd_send() - WMI get tpc config function
3370 * @param wmi_handle : handle to WMI.
3371 * @param param : tpc config param
3372 *
3373 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3374 */
3375QDF_STATUS wmi_unified_pdev_get_tpc_config_cmd_send(void *wmi_hdl,
3376 uint32_t param)
3377{
3378 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3379
3380 if (wmi_handle->ops->send_pdev_get_tpc_config_cmd)
3381 return wmi_handle->ops->send_pdev_get_tpc_config_cmd(wmi_handle,
3382 param);
3383
3384 return QDF_STATUS_E_FAILURE;
3385}
3386
3387/**
Sathish Kumar58f12552016-08-09 16:50:46 +05303388 * wmi_unified_set_bwf_cmd_send() - WMI set bwf function
3389 * @param wmi_handle : handle to WMI.
3390 * @param param : pointer to set bwf param
3391 *
3392 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3393 */
3394QDF_STATUS wmi_unified_set_bwf_cmd_send(void *wmi_hdl,
3395 struct set_bwf_params *param)
3396{
3397 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3398
3399 if (wmi_handle->ops->send_set_bwf_cmd)
3400 return wmi_handle->ops->send_set_bwf_cmd(wmi_handle, param);
3401
3402 return QDF_STATUS_E_FAILURE;
3403}
3404
3405/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303406 * wmi_unified_set_atf_cmd_send() - WMI set atf function
3407 * @param wmi_handle : handle to WMI.
3408 * @param param : pointer to set atf param
3409 *
3410 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3411 */
3412QDF_STATUS wmi_unified_set_atf_cmd_send(void *wmi_hdl,
3413 struct set_atf_params *param)
3414{
3415 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3416
3417 if (wmi_handle->ops->send_set_atf_cmd)
3418 return wmi_handle->ops->send_set_atf_cmd(wmi_handle, param);
3419
3420 return QDF_STATUS_E_FAILURE;
3421}
3422
3423/**
3424 * wmi_unified_pdev_fips_cmd_send() - WMI pdev fips cmd function
3425 * @param wmi_handle : handle to WMI.
3426 * @param param : pointer to hold pdev fips param
3427 *
3428 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3429 */
3430QDF_STATUS wmi_unified_pdev_fips_cmd_send(void *wmi_hdl,
3431 struct fips_params *param)
3432{
3433 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3434
3435 if (wmi_handle->ops->send_pdev_fips_cmd)
3436 return wmi_handle->ops->send_pdev_fips_cmd(wmi_handle, param);
3437
3438 return QDF_STATUS_E_FAILURE;
3439}
3440
3441/**
3442 * wmi_unified_wlan_profile_enable_cmd_send() - WMI wlan profile enable cmd function
3443 * @param wmi_handle : handle to WMI.
3444 * @param param : pointer to hold wlan profile param
3445 *
3446 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3447 */
3448QDF_STATUS wmi_unified_wlan_profile_enable_cmd_send(void *wmi_hdl,
3449 struct wlan_profile_params *param)
3450{
3451 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3452
3453 if (wmi_handle->ops->send_wlan_profile_enable_cmd)
3454 return wmi_handle->ops->send_wlan_profile_enable_cmd(wmi_handle,
3455 param);
3456
3457 return QDF_STATUS_E_FAILURE;
3458}
3459
3460/**
3461 * wmi_unified_wlan_profile_trigger_cmd_send() - WMI wlan profile trigger cmd function
3462 * @param wmi_handle : handle to WMI.
3463 * @param param : pointer to hold wlan profile param
3464 *
3465 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3466 */
3467QDF_STATUS wmi_unified_wlan_profile_trigger_cmd_send(void *wmi_hdl,
3468 struct wlan_profile_params *param)
3469{
3470 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3471
3472 if (wmi->ops->send_wlan_profile_trigger_cmd)
3473 return wmi->ops->send_wlan_profile_trigger_cmd(wmi,
3474 param);
3475
3476 return QDF_STATUS_E_FAILURE;
3477}
3478
3479/**
3480 * wmi_unified_set_chan_cmd_send() - WMI set channel cmd function
3481 * @param wmi_handle : handle to WMI.
3482 * @param param : pointer to hold channel param
3483 *
3484 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3485 */
3486QDF_STATUS wmi_unified_set_chan_cmd_send(void *wmi_hdl,
3487 struct channel_param *param)
3488{
3489 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3490
3491 if (wmi_handle->ops->send_pdev_set_chan_cmd)
3492 return wmi_handle->ops->send_pdev_set_chan_cmd(wmi_handle,
3493 param);
3494
3495 return QDF_STATUS_E_FAILURE;
3496}
3497
3498/**
3499 * wmi_unified_set_ht_ie_cmd_send() - WMI set channel cmd function
3500 * @param wmi_handle : handle to WMI.
3501 * @param param : pointer to hold channel param
3502 *
3503 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3504 */
3505QDF_STATUS wmi_unified_set_ht_ie_cmd_send(void *wmi_hdl,
3506 struct ht_ie_params *param)
3507{
3508 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3509
3510 if (wmi_handle->ops->send_set_ht_ie_cmd)
3511 return wmi_handle->ops->send_set_ht_ie_cmd(wmi_handle, param);
3512
3513 return QDF_STATUS_E_FAILURE;
3514}
3515
3516/**
3517 * wmi_unified_set_vht_ie_cmd_send() - WMI set channel cmd function
3518 * @param wmi_handle : handle to WMI.
3519 * @param param : pointer to hold channel param
3520 *
3521 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3522 */
3523QDF_STATUS wmi_unified_set_vht_ie_cmd_send(void *wmi_hdl,
3524 struct vht_ie_params *param)
3525{
3526 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3527
3528 if (wmi_handle->ops->send_set_vht_ie_cmd)
3529 return wmi_handle->ops->send_set_vht_ie_cmd(wmi_handle, param);
3530
3531 return QDF_STATUS_E_FAILURE;
3532}
3533
3534/**
3535 * wmi_unified_wmm_update_cmd_send() - WMI wmm update cmd function
3536 * @param wmi_handle : handle to WMI.
3537 * @param param : pointer to hold wmm param
3538 *
3539 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3540 */
3541QDF_STATUS wmi_unified_wmm_update_cmd_send(void *wmi_hdl,
3542 struct wmm_update_params *param)
3543{
3544 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3545
3546 if (wmi_handle->ops->send_wmm_update_cmd)
3547 return wmi_handle->ops->send_wmm_update_cmd(wmi_handle, param);
3548
3549 return QDF_STATUS_E_FAILURE;
3550}
3551
3552/**
3553 * wmi_unified_set_ant_switch_tbl_cmd_send() - WMI ant switch tbl cmd function
3554 * @param wmi_handle : handle to WMI.
3555 * @param param : pointer to hold ant switch tbl param
3556 *
3557 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3558 */
3559QDF_STATUS wmi_unified_set_ant_switch_tbl_cmd_send(void *wmi_hdl,
3560 struct ant_switch_tbl_params *param)
3561{
3562 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3563
3564 if (wmi_handle->ops->send_set_ant_switch_tbl_cmd)
3565 return wmi_handle->ops->send_set_ant_switch_tbl_cmd(wmi_handle,
3566 param);
3567
3568 return QDF_STATUS_E_FAILURE;
3569}
3570
3571/**
3572 * wmi_unified_set_ratepwr_table_cmd_send() - WMI ratepwr table cmd function
3573 * @param wmi_handle : handle to WMI.
3574 * @param param : pointer to hold ratepwr table param
3575 *
3576 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3577 */
3578QDF_STATUS wmi_unified_set_ratepwr_table_cmd_send(void *wmi_hdl,
3579 struct ratepwr_table_params *param)
3580{
3581 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3582
3583 if (wmi_handle->ops->send_set_ratepwr_table_cmd)
3584 return wmi_handle->ops->send_set_ratepwr_table_cmd(wmi_handle,
3585 param);
3586
3587 return QDF_STATUS_E_FAILURE;
3588}
3589
3590/**
3591 * wmi_unified_get_ratepwr_table_cmd_send() - WMI ratepwr table cmd function
3592 * @param wmi_handle : handle to WMI.
3593 *
3594 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3595 */
3596QDF_STATUS wmi_unified_get_ratepwr_table_cmd_send(void *wmi_hdl)
3597{
3598 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3599
3600 if (wmi_handle->ops->send_get_ratepwr_table_cmd)
3601 return wmi_handle->ops->send_get_ratepwr_table_cmd(wmi_handle);
3602
3603 return QDF_STATUS_E_FAILURE;
3604}
3605
3606/**
3607 * wmi_unified_set_ctl_table_cmd_send() - WMI ctl table cmd function
3608 * @param wmi_handle : handle to WMI.
3609 * @param param : pointer to hold ctl table param
3610 *
3611 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3612 */
3613QDF_STATUS wmi_unified_set_ctl_table_cmd_send(void *wmi_hdl,
3614 struct ctl_table_params *param)
3615{
3616 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3617
3618 if (wmi_handle->ops->send_set_ctl_table_cmd)
3619 return wmi_handle->ops->send_set_ctl_table_cmd(wmi_handle,
3620 param);
3621
3622 return QDF_STATUS_E_FAILURE;
3623}
3624
3625/**
3626 * wmi_unified_set_mimogain_table_cmd_send() - WMI set mimogain cmd function
3627 * @param wmi_handle : handle to WMI.
3628 * @param param : pointer to hold mimogain param
3629 *
3630 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3631 */
3632QDF_STATUS wmi_unified_set_mimogain_table_cmd_send(void *wmi_hdl,
3633 struct mimogain_table_params *param)
3634{
3635 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3636
3637 if (wmi_handle->ops->send_set_mimogain_table_cmd)
3638 return wmi_handle->ops->send_set_mimogain_table_cmd(wmi_handle,
3639 param);
3640
3641 return QDF_STATUS_E_FAILURE;
3642}
3643
3644/**
3645 * wmi_unified_set_ratepwr_chainmsk_cmd_send() - WMI ratepwr
3646 * chainmsk cmd function
3647 * @param wmi_handle : handle to WMI.
3648 * @param param : pointer to hold ratepwr chainmsk param
3649 *
3650 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3651 */
3652QDF_STATUS wmi_unified_set_ratepwr_chainmsk_cmd_send(void *wmi_hdl,
3653 struct ratepwr_chainmsk_params *param)
3654{
3655 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3656
3657 if (wmi->ops->send_set_ratepwr_chainmsk_cmd)
3658 return wmi->ops->send_set_ratepwr_chainmsk_cmd(wmi, param);
3659
3660 return QDF_STATUS_E_FAILURE;
3661}
3662
3663/**
3664 * wmi_unified_set_macaddr_cmd_send() - WMI set macaddr cmd function
3665 * @param wmi_handle : handle to WMI.
3666 * @param param : pointer to hold macaddr param
3667 *
3668 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3669 */
3670QDF_STATUS wmi_unified_set_macaddr_cmd_send(void *wmi_hdl,
3671 struct macaddr_params *param)
3672{
3673 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3674
3675 if (wmi_handle->ops->send_set_macaddr_cmd)
3676 return wmi_handle->ops->send_set_macaddr_cmd(wmi_handle, param);
3677
3678 return QDF_STATUS_E_FAILURE;
3679}
3680
3681/**
3682 * wmi_unified_pdev_scan_start_cmd_send() - WMI pdev scan start cmd function
3683 * @param wmi_handle : handle to WMI.
3684 *
3685 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3686 */
3687QDF_STATUS wmi_unified_pdev_scan_start_cmd_send(void *wmi_hdl)
3688{
3689 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3690
3691 if (wmi_handle->ops->send_pdev_scan_start_cmd)
3692 return wmi_handle->ops->send_pdev_scan_start_cmd(wmi_handle);
3693
3694 return QDF_STATUS_E_FAILURE;
3695}
3696
3697/**
3698 * wmi_unified_pdev_scan_end_cmd_send() - WMI pdev scan end cmd function
3699 * @param wmi_handle : handle to WMI.
3700 *
3701 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3702 */
3703QDF_STATUS wmi_unified_pdev_scan_end_cmd_send(void *wmi_hdl)
3704{
3705 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3706
3707 if (wmi_handle->ops->send_pdev_scan_end_cmd)
3708 return wmi_handle->ops->send_pdev_scan_end_cmd(wmi_handle);
3709
3710 return QDF_STATUS_E_FAILURE;
3711}
3712
3713/**
3714 * wmi_unified_set_acparams_cmd_send() - WMI set acparams cmd function
3715 * @param wmi_handle : handle to WMI.
3716 * @param param : pointer to hold acparams param
3717 *
3718 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3719 */
3720QDF_STATUS wmi_unified_set_acparams_cmd_send(void *wmi_hdl,
3721 struct acparams_params *param)
3722{
3723 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3724
3725 if (wmi_handle->ops->send_set_acparams_cmd)
3726 return wmi_handle->ops->send_set_acparams_cmd(wmi_handle,
3727 param);
3728
3729 return QDF_STATUS_E_FAILURE;
3730}
3731
3732/**
3733 * wmi_unified_set_vap_dscp_tid_map_cmd_send() - WMI set vap dscp
3734 * tid map cmd function
3735 * @param wmi_handle : handle to WMI.
3736 * @param param : pointer to hold dscp param
3737 *
3738 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3739 */
3740QDF_STATUS wmi_unified_set_vap_dscp_tid_map_cmd_send(void *wmi_hdl,
3741 struct vap_dscp_tid_map_params *param)
3742{
3743 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3744
3745 if (wmi->ops->send_set_vap_dscp_tid_map_cmd)
3746 return wmi->ops->send_set_vap_dscp_tid_map_cmd(wmi, param);
3747
3748 return QDF_STATUS_E_FAILURE;
3749}
3750
3751/**
3752 * wmi_unified_proxy_ast_reserve_cmd_send() - WMI proxy ast
3753 * reserve cmd function
3754 * @param wmi_handle : handle to WMI.
3755 * @param param : pointer to hold ast param
3756 *
3757 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3758 */
3759QDF_STATUS wmi_unified_proxy_ast_reserve_cmd_send(void *wmi_hdl,
3760 struct proxy_ast_reserve_params *param)
3761{
3762 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3763
3764 if (wmi_handle->ops->send_proxy_ast_reserve_cmd)
3765 return wmi_handle->ops->send_proxy_ast_reserve_cmd(wmi_handle,
3766 param);
3767
3768 return QDF_STATUS_E_FAILURE;
3769}
3770
3771/**
3772 * wmi_unified_pdev_qvit_cmd_send() - WMI pdev qvit cmd function
3773 * @param wmi_handle : handle to WMI.
3774 * @param param : pointer to hold qvit param
3775 *
3776 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3777 */
3778QDF_STATUS wmi_unified_pdev_qvit_cmd_send(void *wmi_hdl,
3779 struct pdev_qvit_params *param)
3780{
3781 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3782
3783 if (wmi_handle->ops->send_pdev_qvit_cmd)
3784 return wmi_handle->ops->send_pdev_qvit_cmd(wmi_handle, param);
3785
3786 return QDF_STATUS_E_FAILURE;
3787}
3788
3789/**
3790 * wmi_unified_mcast_group_update_cmd_send() - WMI mcast grp update cmd function
3791 * @param wmi_handle : handle to WMI.
3792 * @param param : pointer to hold mcast grp param
3793 *
3794 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3795 */
3796QDF_STATUS wmi_unified_mcast_group_update_cmd_send(void *wmi_hdl,
3797 struct mcast_group_update_params *param)
3798{
3799 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3800
3801 if (wmi_handle->ops->send_mcast_group_update_cmd)
3802 return wmi_handle->ops->send_mcast_group_update_cmd(wmi_handle,
3803 param);
3804
3805 return QDF_STATUS_E_FAILURE;
3806}
3807
3808/**
3809 * wmi_unified_peer_add_wds_entry_cmd_send() - WMI add wds entry cmd function
3810 * @param wmi_handle : handle to WMI.
3811 * @param param : pointer to hold wds entry param
3812 *
3813 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3814 */
3815QDF_STATUS wmi_unified_peer_add_wds_entry_cmd_send(void *wmi_hdl,
3816 struct peer_add_wds_entry_params *param)
3817{
3818 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3819
3820 if (wmi_handle->ops->send_peer_add_wds_entry_cmd)
3821 return wmi_handle->ops->send_peer_add_wds_entry_cmd(wmi_handle,
3822 param);
3823
3824 return QDF_STATUS_E_FAILURE;
3825}
3826
3827/**
3828 * wmi_unified_peer_del_wds_entry_cmd_send() - WMI del wds entry cmd function
3829 * @param wmi_handle : handle to WMI.
3830 * @param param : pointer to hold wds entry param
3831 *
3832 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3833 */
3834QDF_STATUS wmi_unified_peer_del_wds_entry_cmd_send(void *wmi_hdl,
3835 struct peer_del_wds_entry_params *param)
3836{
3837 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3838
3839 if (wmi_handle->ops->send_peer_del_wds_entry_cmd)
3840 return wmi_handle->ops->send_peer_del_wds_entry_cmd(wmi_handle,
3841 param);
3842
3843 return QDF_STATUS_E_FAILURE;
3844}
3845
3846/**
Jeevan Kukkalli0aeff782017-06-16 18:07:28 +05303847 * wmi_unified_set_bridge_mac_addr_cmd_send() - WMI set bridge mac addr cmd function
3848 * @param wmi_hdl : handle to WMI.
3849 * @param param : pointer to hold bridge mac addr param
3850 *
3851 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3852 */
3853QDF_STATUS wmi_unified_set_bridge_mac_addr_cmd_send(void *wmi_hdl,
3854 struct set_bridge_mac_addr_params *param)
3855{
3856 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3857
3858 if (wmi_handle->ops->send_set_bridge_mac_addr_cmd)
3859 return wmi_handle->ops->send_set_bridge_mac_addr_cmd(wmi_handle,
3860 param);
3861
3862 return QDF_STATUS_E_FAILURE;
3863}
3864
3865/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05303866 * wmi_unified_peer_update_wds_entry_cmd_send() - WMI update wds entry cmd function
3867 * @param wmi_handle : handle to WMI.
3868 * @param param : pointer to hold wds entry param
3869 *
3870 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3871 */
3872QDF_STATUS wmi_unified_peer_update_wds_entry_cmd_send(void *wmi_hdl,
3873 struct peer_update_wds_entry_params *param)
3874{
3875 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3876
3877 if (wmi->ops->send_peer_update_wds_entry_cmd)
3878 return wmi->ops->send_peer_update_wds_entry_cmd(wmi, param);
3879
3880 return QDF_STATUS_E_FAILURE;
3881}
3882
3883/**
3884 * wmi_unified_phyerr_enable_cmd_send() - WMI phyerr enable cmd function
3885 * @param wmi_handle : handle to WMI.
3886 * @param param : pointer to hold phyerr enable param
3887 *
3888 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3889 */
3890QDF_STATUS wmi_unified_phyerr_enable_cmd_send(void *wmi_hdl)
3891{
3892 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3893
3894 if (wmi_handle->ops->send_phyerr_enable_cmd)
3895 return wmi_handle->ops->send_phyerr_enable_cmd(wmi_handle);
3896
3897 return QDF_STATUS_E_FAILURE;
3898}
3899
3900/**
3901 * wmi_unified_phyerr_disable_cmd_send() - WMI phyerr disable cmd function
3902 * @param wmi_handle : handle to WMI.
3903 * @param param : pointer to hold phyerr disable param
3904 *
3905 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3906 */
3907QDF_STATUS wmi_unified_phyerr_disable_cmd_send(void *wmi_hdl)
3908{
3909 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3910
3911 if (wmi_handle->ops->send_phyerr_disable_cmd)
3912 return wmi_handle->ops->send_phyerr_disable_cmd(wmi_handle);
3913
3914 return QDF_STATUS_E_FAILURE;
3915}
3916
3917/**
3918 * wmi_unified_smart_ant_enable_cmd_send() - WMI smart ant enable function
3919 * @param wmi_handle : handle to WMI.
3920 * @param param : pointer to hold antenna param
3921 *
3922 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3923 */
3924QDF_STATUS wmi_unified_smart_ant_enable_cmd_send(void *wmi_hdl,
3925 struct smart_ant_enable_params *param)
3926{
3927 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
3928
3929 if (wmi_handle->ops->send_smart_ant_enable_cmd)
3930 return wmi_handle->ops->send_smart_ant_enable_cmd(wmi_handle,
3931 param);
3932
3933 return QDF_STATUS_E_FAILURE;
3934}
3935
3936/**
3937 * wmi_unified_smart_ant_set_rx_ant_cmd_send() - WMI set rx antenna function
3938 * @param wmi_handle : handle to WMI.
3939 * @param param : pointer to hold antenna param
3940 *
3941 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3942 */
3943QDF_STATUS wmi_unified_smart_ant_set_rx_ant_cmd_send(void *wmi_hdl,
3944 struct smart_ant_rx_ant_params *param)
3945{
3946 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3947
3948 if (wmi->ops->send_smart_ant_set_rx_ant_cmd)
3949 return wmi->ops->send_smart_ant_set_rx_ant_cmd(wmi, param);
3950
3951 return QDF_STATUS_E_FAILURE;
3952}
3953
3954/**
3955 * wmi_unified_smart_ant_set_tx_ant_cmd_send() - WMI set tx antenna function
3956 * @param wmi_handle : handle to WMI.
3957 * @param param : pointer to hold antenna param
3958 *
3959 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3960 */
3961QDF_STATUS wmi_unified_smart_ant_set_tx_ant_cmd_send(void *wmi_hdl,
3962 uint8_t macaddr[IEEE80211_ADDR_LEN],
3963 struct smart_ant_tx_ant_params *param)
3964{
3965 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3966
3967 if (wmi->ops->send_smart_ant_set_tx_ant_cmd)
3968 return wmi->ops->send_smart_ant_set_tx_ant_cmd(wmi, macaddr,
3969 param);
3970
3971 return QDF_STATUS_E_FAILURE;
3972}
3973
3974/**
3975 * wmi_unified_smart_ant_set_training_info_cmd_send() - WMI set tx antenna function
3976 * @param wmi_handle : handle to WMI.
3977 * @param param : pointer to hold antenna param
3978 *
3979 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
3980 */
3981QDF_STATUS wmi_unified_smart_ant_set_training_info_cmd_send(void *wmi_hdl,
3982 uint8_t macaddr[IEEE80211_ADDR_LEN],
3983 struct smart_ant_training_info_params *param)
3984{
3985 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
3986
3987 if (wmi->ops->send_smart_ant_set_training_info_cmd)
3988 return wmi->ops->send_smart_ant_set_training_info_cmd(wmi,
3989 macaddr, param);
3990
3991 return QDF_STATUS_E_FAILURE;
3992}
3993
3994/**
3995 * wmi_unified_smart_ant_node_config_cmd_send() - WMI set node config function
3996 * @param wmi_handle : handle to WMI.
3997 * @param macaddr : MAC address
3998 * @param param : pointer to hold node parameter
3999 *
4000 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4001 */
4002QDF_STATUS wmi_unified_smart_ant_node_config_cmd_send(void *wmi_hdl,
4003 uint8_t macaddr[IEEE80211_ADDR_LEN],
4004 struct smart_ant_node_config_params *param)
4005{
4006 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4007
4008 if (wmi->ops->send_smart_ant_set_node_config_cmd)
4009 return wmi->ops->send_smart_ant_set_node_config_cmd(wmi,
4010 macaddr, param);
4011
4012 return QDF_STATUS_E_FAILURE;
4013}
4014
4015/**
4016 * wmi_unified_smart_ant_enable_tx_feedback_cmd_send() - WMI set tx antenna function
4017 * @param wmi_handle : handle to WMI.
4018 * @param param : pointer to hold antenna param
4019 *
4020 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4021 */
4022QDF_STATUS wmi_unified_smart_ant_enable_tx_feedback_cmd_send(void *wmi_hdl,
4023 struct smart_ant_enable_tx_feedback_params *param)
4024{
4025 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4026
4027 if (wmi->ops->send_smart_ant_enable_tx_feedback_cmd)
4028 return wmi->ops->send_smart_ant_enable_tx_feedback_cmd(wmi,
4029 param);
4030
4031 return QDF_STATUS_E_FAILURE;
4032}
4033
4034/**
4035 * wmi_unified_vdev_spectral_configure_cmd_send() - WMI set spectral config function
4036 * @param wmi_handle : handle to WMI.
4037 * @param param : pointer to hold spectral config param
4038 *
4039 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4040 */
4041QDF_STATUS wmi_unified_vdev_spectral_configure_cmd_send(void *wmi_hdl,
4042 struct vdev_spectral_configure_params *param)
4043{
4044 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4045
4046 if (wmi->ops->send_vdev_spectral_configure_cmd)
4047 return wmi->ops->send_vdev_spectral_configure_cmd(wmi, param);
4048
4049 return QDF_STATUS_E_FAILURE;
4050}
4051
4052/**
4053 * wmi_unified_vdev_spectral_enable_cmd_send() - WMI enable spectral function
4054 * @param wmi_handle : handle to WMI.
4055 * @param param : pointer to hold enable spectral param
4056 *
4057 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4058 */
4059QDF_STATUS wmi_unified_vdev_spectral_enable_cmd_send(void *wmi_hdl,
4060 struct vdev_spectral_enable_params *param)
4061{
4062 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4063
4064 if (wmi->ops->send_vdev_spectral_enable_cmd)
4065 return wmi->ops->send_vdev_spectral_enable_cmd(wmi, param);
4066
4067 return QDF_STATUS_E_FAILURE;
4068}
4069
4070/**
4071 * wmi_unified_bss_chan_info_request_cmd_send() - WMI bss chan info request function
4072 * @param wmi_handle : handle to WMI.
4073 * @param param : pointer to hold chan info param
4074 *
4075 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4076 */
4077QDF_STATUS wmi_unified_bss_chan_info_request_cmd_send(void *wmi_hdl,
4078 struct bss_chan_info_request_params *param)
4079{
4080 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4081
4082 if (wmi->ops->send_bss_chan_info_request_cmd)
4083 return wmi->ops->send_bss_chan_info_request_cmd(wmi, param);
4084
4085 return QDF_STATUS_E_FAILURE;
4086}
4087
4088/**
4089 * wmi_unified_thermal_mitigation_param_cmd_send() - WMI thermal mitigation function
4090 * @param wmi_handle : handle to WMI.
4091 * @param param : pointer to hold thermal mitigation param
4092 *
4093 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4094 */
4095QDF_STATUS wmi_unified_thermal_mitigation_param_cmd_send(void *wmi_hdl,
4096 struct thermal_mitigation_params *param)
4097{
4098 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4099
4100 if (wmi->ops->send_thermal_mitigation_param_cmd)
4101 return wmi->ops->send_thermal_mitigation_param_cmd(wmi, param);
4102
4103 return QDF_STATUS_E_FAILURE;
4104}
4105
4106/**
4107 * wmi_unified_vdev_set_neighbour_rx_cmd_send() - WMI set neighbour rx function
4108 * @param wmi_handle : handle to WMI.
4109 * @param macaddr : MAC address
4110 * @param param : pointer to hold neighbour rx parameter
4111 *
4112 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4113 */
4114QDF_STATUS wmi_unified_vdev_set_neighbour_rx_cmd_send(void *wmi_hdl,
4115 uint8_t macaddr[IEEE80211_ADDR_LEN],
4116 struct set_neighbour_rx_params *param)
4117{
4118 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4119
4120 if (wmi->ops->send_vdev_set_neighbour_rx_cmd)
4121 return wmi->ops->send_vdev_set_neighbour_rx_cmd(wmi,
4122 macaddr, param);
4123
4124 return QDF_STATUS_E_FAILURE;
4125}
4126
4127/**
4128 * wmi_unified_vdev_set_fwtest_param_cmd_send() - WMI set fwtest function
4129 * @param wmi_handle : handle to WMI.
4130 * @param param : pointer to hold fwtest param
4131 *
4132 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4133 */
4134QDF_STATUS wmi_unified_vdev_set_fwtest_param_cmd_send(void *wmi_hdl,
4135 struct set_fwtest_params *param)
4136{
4137 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4138
4139 if (wmi->ops->send_vdev_set_fwtest_param_cmd)
4140 return wmi->ops->send_vdev_set_fwtest_param_cmd(wmi, param);
4141
4142 return QDF_STATUS_E_FAILURE;
4143}
4144
4145/**
4146 * wmi_unified_vdev_config_ratemask_cmd_send() - WMI config ratemask function
4147 * @param wmi_handle : handle to WMI.
4148 * @param param : pointer to hold config ratemask param
4149 *
4150 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4151 */
4152QDF_STATUS wmi_unified_vdev_config_ratemask_cmd_send(void *wmi_hdl,
4153 struct config_ratemask_params *param)
4154{
4155 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4156
4157 if (wmi->ops->send_vdev_config_ratemask_cmd)
4158 return wmi->ops->send_vdev_config_ratemask_cmd(wmi, param);
4159
4160 return QDF_STATUS_E_FAILURE;
4161}
4162
4163/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304164 * wmi_unified_pdev_set_regdomain_params_cmd_send() - WMI set regdomain function
4165 * @param wmi_handle : handle to WMI.
4166 * @param param : pointer to hold regdomain param
4167 *
4168 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4169 */
4170QDF_STATUS wmi_unified_pdev_set_regdomain_cmd_send(void *wmi_hdl,
4171 struct pdev_set_regdomain_params *param)
4172{
4173 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4174
4175 if (wmi_handle->ops->send_pdev_set_regdomain_cmd)
4176 return wmi_handle->ops->send_pdev_set_regdomain_cmd(wmi_handle,
4177 param);
4178
4179 return QDF_STATUS_E_FAILURE;
4180}
4181
4182/**
4183 * wmi_unified_set_quiet_mode_cmd_send() - WMI set quiet mode function
4184 * @param wmi_handle : handle to WMI.
4185 * @param param : pointer to hold quiet mode param
4186 *
4187 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4188 */
4189QDF_STATUS wmi_unified_set_quiet_mode_cmd_send(void *wmi_hdl,
4190 struct set_quiet_mode_params *param)
4191{
4192 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4193
4194 if (wmi_handle->ops->send_set_quiet_mode_cmd)
4195 return wmi_handle->ops->send_set_quiet_mode_cmd(wmi_handle,
4196 param);
4197
4198 return QDF_STATUS_E_FAILURE;
4199}
4200
4201/**
4202 * wmi_unified_set_beacon_filter_cmd_send() - WMI set beacon filter function
4203 * @param wmi_handle : handle to WMI.
4204 * @param param : pointer to hold beacon filter param
4205 *
4206 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4207 */
4208QDF_STATUS wmi_unified_set_beacon_filter_cmd_send(void *wmi_hdl,
4209 struct set_beacon_filter_params *param)
4210{
4211 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4212
4213 if (wmi_handle->ops->send_set_beacon_filter_cmd)
4214 return wmi_handle->ops->send_set_beacon_filter_cmd(wmi_handle,
4215 param);
4216
4217 return QDF_STATUS_E_FAILURE;
4218}
4219
4220/**
4221 * wmi_unified_remove_beacon_filter_cmd_send() - WMI set beacon filter function
4222 * @param wmi_handle : handle to WMI.
4223 * @param param : pointer to hold beacon filter param
4224 *
4225 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4226 */
4227QDF_STATUS wmi_unified_remove_beacon_filter_cmd_send(void *wmi_hdl,
4228 struct remove_beacon_filter_params *param)
4229{
4230 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4231
4232 if (wmi->ops->send_remove_beacon_filter_cmd)
4233 return wmi->ops->send_remove_beacon_filter_cmd(wmi, param);
4234
4235 return QDF_STATUS_E_FAILURE;
4236}
4237
4238/**
4239 * wmi_unified_mgmt_cmd_send() - WMI mgmt cmd function
4240 * @param wmi_handle : handle to WMI.
4241 * @param macaddr : MAC address
4242 * @param param : pointer to hold mgmt parameter
4243 *
4244 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4245 */
4246#if 0
4247QDF_STATUS wmi_unified_mgmt_cmd_send(void *wmi_hdl,
4248 uint8_t macaddr[IEEE80211_ADDR_LEN],
4249 struct mgmt_params *param)
4250{
4251 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4252
4253 if (wmi_handle->ops->send_mgmt_cmd)
4254 return wmi_handle->ops->send_mgmt_cmd(wmi_handle,
4255 macaddr, param);
4256
4257 return QDF_STATUS_E_FAILURE;
4258}
4259#endif
4260
4261/**
4262 * wmi_unified_addba_clearresponse_cmd_send() - WMI addba resp cmd function
4263 * @param wmi_handle : handle to WMI.
4264 * @param macaddr : MAC address
4265 * @param param : pointer to hold addba resp parameter
4266 *
4267 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4268 */
4269QDF_STATUS wmi_unified_addba_clearresponse_cmd_send(void *wmi_hdl,
4270 uint8_t macaddr[IEEE80211_ADDR_LEN],
4271 struct addba_clearresponse_params *param)
4272{
4273 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4274
4275 if (wmi_handle->ops->send_addba_clearresponse_cmd)
4276 return wmi_handle->ops->send_addba_clearresponse_cmd(wmi_handle,
4277 macaddr, param);
4278
4279 return QDF_STATUS_E_FAILURE;
4280}
4281
4282/**
4283 * wmi_unified_addba_send_cmd_send() - WMI addba send function
4284 * @param wmi_handle : handle to WMI.
4285 * @param macaddr : MAC address
4286 * @param param : pointer to hold addba parameter
4287 *
4288 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4289 */
4290QDF_STATUS wmi_unified_addba_send_cmd_send(void *wmi_hdl,
4291 uint8_t macaddr[IEEE80211_ADDR_LEN],
4292 struct addba_send_params *param)
4293{
4294 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4295
4296 if (wmi_handle->ops->send_addba_send_cmd)
4297 return wmi_handle->ops->send_addba_send_cmd(wmi_handle,
4298 macaddr, param);
4299
4300 return QDF_STATUS_E_FAILURE;
4301}
4302
4303/**
4304 * wmi_unified_delba_send_cmd_send() - WMI delba cmd function
4305 * @param wmi_handle : handle to WMI.
4306 * @param macaddr : MAC address
4307 * @param param : pointer to hold delba parameter
4308 *
4309 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4310 */
4311QDF_STATUS wmi_unified_delba_send_cmd_send(void *wmi_hdl,
4312 uint8_t macaddr[IEEE80211_ADDR_LEN],
4313 struct delba_send_params *param)
4314{
4315 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4316
4317 if (wmi_handle->ops->send_delba_send_cmd)
4318 return wmi_handle->ops->send_delba_send_cmd(wmi_handle,
4319 macaddr, param);
4320
4321 return QDF_STATUS_E_FAILURE;
4322}
4323
4324/**
4325 * wmi_unified_addba_setresponse_cmd_send() - WMI addba set resp cmd function
4326 * @param wmi_handle : handle to WMI.
4327 * @param macaddr : MAC address
4328 * @param param : pointer to hold addba set resp parameter
4329 *
4330 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4331 */
4332QDF_STATUS wmi_unified_addba_setresponse_cmd_send(void *wmi_hdl,
4333 uint8_t macaddr[IEEE80211_ADDR_LEN],
4334 struct addba_setresponse_params *param)
4335{
4336 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4337
4338 if (wmi_handle->ops->send_addba_setresponse_cmd)
4339 return wmi_handle->ops->send_addba_setresponse_cmd(wmi_handle,
4340 macaddr, param);
4341
4342 return QDF_STATUS_E_FAILURE;
4343}
4344
4345/**
4346 * wmi_unified_singleamsdu_cmd_send() - WMI singleamsdu function
4347 * @param wmi_handle : handle to WMI.
4348 * @param macaddr : MAC address
4349 * @param param : pointer to hold singleamsdu parameter
4350 *
4351 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4352 */
4353QDF_STATUS wmi_unified_singleamsdu_cmd_send(void *wmi_hdl,
4354 uint8_t macaddr[IEEE80211_ADDR_LEN],
4355 struct singleamsdu_params *param)
4356{
4357 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4358
4359 if (wmi_handle->ops->send_singleamsdu_cmd)
4360 return wmi_handle->ops->send_singleamsdu_cmd(wmi_handle,
4361 macaddr, param);
4362
4363 return QDF_STATUS_E_FAILURE;
4364}
4365
4366/**
4367 * wmi_unified_set_qboost_param_cmd_send() - WMI set_qboost function
4368 * @param wmi_handle : handle to WMI.
4369 * @param macaddr : MAC address
4370 * @param param : pointer to hold set_qboost parameter
4371 *
4372 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4373 */
4374QDF_STATUS wmi_unified_set_qboost_param_cmd_send(void *wmi_hdl,
4375 uint8_t macaddr[IEEE80211_ADDR_LEN],
4376 struct set_qboost_params *param)
4377{
4378 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4379
4380 if (wmi_handle->ops->send_set_qboost_param_cmd)
4381 return wmi_handle->ops->send_set_qboost_param_cmd(wmi_handle,
4382 macaddr, param);
4383
4384 return QDF_STATUS_E_FAILURE;
4385}
4386
4387/**
4388 * wmi_unified_mu_scan_cmd_send() - WMI set mu scan function
4389 * @param wmi_handle : handle to WMI.
4390 * @param param : pointer to hold mu scan param
4391 *
4392 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4393 */
4394QDF_STATUS wmi_unified_mu_scan_cmd_send(void *wmi_hdl,
4395 struct mu_scan_params *param)
4396{
4397 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4398
4399 if (wmi_handle->ops->send_mu_scan_cmd)
4400 return wmi_handle->ops->send_mu_scan_cmd(wmi_handle, param);
4401
4402 return QDF_STATUS_E_FAILURE;
4403}
4404
4405/**
4406 * wmi_unified_lteu_config_cmd_send() - WMI set mu scan function
4407 * @param wmi_handle : handle to WMI.
4408 * @param param : pointer to hold mu scan param
4409 *
4410 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4411 */
4412QDF_STATUS wmi_unified_lteu_config_cmd_send(void *wmi_hdl,
4413 struct lteu_config_params *param)
4414{
4415 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4416
4417 if (wmi_handle->ops->send_lteu_config_cmd)
4418 return wmi_handle->ops->send_lteu_config_cmd(wmi_handle, param);
4419
4420 return QDF_STATUS_E_FAILURE;
4421}
4422
4423/**
4424 * wmi_unified_set_psmode_cmd_send() - WMI set mu scan function
4425 * @param wmi_handle : handle to WMI.
4426 * @param param : pointer to hold mu scan param
4427 *
4428 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4429 */
4430QDF_STATUS wmi_unified_set_psmode_cmd_send(void *wmi_hdl,
4431 struct set_ps_mode_params *param)
4432{
4433 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4434
4435 if (wmi_handle->ops->send_set_ps_mode_cmd)
4436 return wmi_handle->ops->send_set_ps_mode_cmd(wmi_handle, param);
4437
4438 return QDF_STATUS_E_FAILURE;
4439}
4440
4441/**
4442 * wmi_unified_init_cmd_send() - send initialization cmd to fw
4443 * @wmi_handle: wmi handle
Kiran Venkatappa26117052016-12-23 19:58:54 +05304444 * @param param: pointer to wmi init param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304445 *
4446 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4447 */
4448QDF_STATUS wmi_unified_init_cmd_send(void *wmi_hdl,
Kiran Venkatappa26117052016-12-23 19:58:54 +05304449 struct wmi_init_cmd_param *param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304450{
4451 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4452
4453 if (wmi_handle->ops->init_cmd_send)
Kiran Venkatappa26117052016-12-23 19:58:54 +05304454 return wmi_handle->ops->init_cmd_send(wmi_handle, param);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304455
4456 return QDF_STATUS_E_FAILURE;
4457}
4458
4459/**
4460 * wmi_save_service_bitmap() - save service bitmap
4461 * @wmi_handle: wmi handle
4462 * @param evt_buf: pointer to event buffer
4463 *
4464 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4465 */
Rajeev Kumar77901472017-02-12 02:12:17 -08004466QDF_STATUS wmi_save_service_bitmap(void *wmi_hdl, void *evt_buf,
4467 void *bitmap_buf)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304468{
4469 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl;
4470
4471 if (wmi_handle->ops->save_service_bitmap) {
Kiran Venkatappa7d739142017-09-01 17:02:34 +05304472 return wmi_handle->ops->save_service_bitmap(wmi_handle, evt_buf,
Rajeev Kumar77901472017-02-12 02:12:17 -08004473 bitmap_buf);
Kiran Venkatappa7d739142017-09-01 17:02:34 +05304474 }
4475 return QDF_STATUS_E_FAILURE;
4476}
4477
4478/**
4479 * wmi_save_ext_service_bitmap() - save extended service bitmap
4480 * @wmi_handle: wmi handle
4481 * @param evt_buf: pointer to event buffer
4482 *
4483 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4484 */
4485QDF_STATUS wmi_save_ext_service_bitmap(void *wmi_hdl, void *evt_buf,
4486 void *bitmap_buf)
4487{
4488 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl;
4489
4490 if (wmi_handle->ops->save_ext_service_bitmap) {
4491 return wmi_handle->ops->save_ext_service_bitmap(wmi_handle,
4492 evt_buf, bitmap_buf);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304493 }
4494 return QDF_STATUS_E_FAILURE;
4495}
4496
4497/**
4498 * wmi_save_fw_version() - Save fw version
4499 * @wmi_handle: wmi handle
4500 * @param evt_buf: pointer to event buffer
4501 *
4502 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4503 */
4504QDF_STATUS wmi_save_fw_version(void *wmi_hdl, void *evt_buf)
4505{
4506 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl;
4507
4508 if (wmi_handle->ops->save_fw_version) {
4509 wmi_handle->ops->save_fw_version(wmi_handle, evt_buf);
4510 return 0;
4511 }
4512 return QDF_STATUS_E_FAILURE;
4513
4514}
4515
4516/**
4517 * wmi_check_and_update_fw_version() - Ready and fw version check
4518 * @wmi_handle: wmi handle
4519 * @param evt_buf: pointer to event buffer
4520 *
4521 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4522 */
4523QDF_STATUS wmi_check_and_update_fw_version(void *wmi_hdl, void *evt_buf)
4524{
4525 struct wmi_unified *wmi_handle = (struct wmi_unified *) wmi_hdl;
4526
4527 if (wmi_handle->ops->check_and_update_fw_version)
4528 return wmi_handle->ops->check_and_update_fw_version(wmi_handle,
4529 evt_buf);
4530
4531 return QDF_STATUS_E_FAILURE;
4532
4533}
4534
4535/**
4536 * wmi_service_enabled() - Check if service enabled
4537 * @param wmi_handle: wmi handle
4538 * @param service_id: service identifier
4539 *
4540 * Return: 1 enabled, 0 disabled
4541 */
Kiran Venkatappa1d5f5ab2016-08-09 22:52:35 +05304542#ifndef CONFIG_MCL
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304543bool wmi_service_enabled(void *wmi_hdl, uint32_t service_id)
4544{
4545 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4546
4547 if ((service_id < wmi_services_max) &&
4548 (wmi_handle->services[service_id] != WMI_SERVICE_UNAVAILABLE)) {
4549 if (wmi_handle->ops->is_service_enabled) {
4550 return wmi_handle->ops->is_service_enabled(wmi_handle,
4551 wmi_handle->services[service_id]);
4552 }
4553 } else {
4554 qdf_print("Support not added yet for Service %d\n", service_id);
4555 }
4556 return false;
4557}
4558#endif
4559
4560/**
4561 * wmi_get_target_cap_from_service_ready() - extract service ready event
4562 * @wmi_handle: wmi handle
4563 * @param evt_buf: pointer to received event buffer
4564 * @param ev: pointer to hold target capability information extracted from even
4565 *
4566 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4567 */
4568QDF_STATUS wmi_get_target_cap_from_service_ready(void *wmi_hdl,
Rajeev Kumar037799b2017-02-03 00:39:49 -08004569 void *evt_buf, struct wlan_psoc_target_capability_info *ev)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304570{
4571 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4572
4573 if (wmi->ops->get_target_cap_from_service_ready)
4574 return wmi->ops->get_target_cap_from_service_ready(wmi,
4575 evt_buf, ev);
4576
4577 return QDF_STATUS_E_FAILURE;
4578}
4579
4580/**
4581 * wmi_extract_fw_version() - extract fw version
4582 * @wmi_handle: wmi handle
4583 * @param evt_buf: pointer to event buffer
4584 * @param fw_ver: Pointer to hold fw version
4585 *
4586 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4587 */
4588QDF_STATUS wmi_extract_fw_version(void *wmi_hdl,
4589 void *evt_buf, struct wmi_host_fw_ver *fw_ver)
4590{
4591 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4592
4593 if (wmi_handle->ops->extract_fw_version)
4594 return wmi_handle->ops->extract_fw_version(wmi_handle,
4595 evt_buf, fw_ver);
4596
4597 return QDF_STATUS_E_FAILURE;
4598}
4599
4600/**
4601 * wmi_extract_fw_abi_version() - extract fw abi version
4602 * @wmi_handle: wmi handle
4603 * @param evt_buf: Pointer to event buffer
4604 * @param fw_ver: Pointer to hold fw abi version
4605 *
4606 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4607 */
4608QDF_STATUS wmi_extract_fw_abi_version(void *wmi_hdl,
4609 void *evt_buf, struct wmi_host_fw_abi_ver *fw_ver)
4610{
4611 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4612
4613 if (wmi_handle->ops->extract_fw_abi_version)
4614 return wmi_handle->ops->extract_fw_abi_version(wmi_handle,
4615 evt_buf, fw_ver);
4616
4617 return QDF_STATUS_E_FAILURE;
4618}
4619
4620/**
4621 * wmi_extract_hal_reg_cap() - extract HAL registered capabilities
4622 * @wmi_handle: wmi handle
4623 * @param evt_buf: Pointer to event buffer
4624 * @param hal_reg_cap: pointer to hold HAL reg capabilities
4625 *
4626 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4627 */
4628QDF_STATUS wmi_extract_hal_reg_cap(void *wmi_hdl, void *evt_buf,
Rajeev Kumar037799b2017-02-03 00:39:49 -08004629 struct wlan_psoc_hal_reg_capability *hal_reg_cap)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304630{
4631 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4632
4633 if (wmi_handle->ops->extract_hal_reg_cap)
4634 return wmi_handle->ops->extract_hal_reg_cap(wmi_handle,
4635 evt_buf, hal_reg_cap);
4636
4637 return QDF_STATUS_E_FAILURE;
4638}
4639
4640/**
4641 * wmi_extract_host_mem_req_from_service_ready() - Extract host memory
4642 * request event
4643 * @wmi_handle: wmi handle
4644 * @param evt_buf: pointer to event buffer
4645 * @param num_entries: pointer to hold number of entries requested
4646 *
4647 * Return: Number of entries requested
4648 */
4649host_mem_req *wmi_extract_host_mem_req_from_service_ready(void *wmi_hdl,
4650 void *evt_buf, uint8_t *num_entries)
4651{
4652 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4653
4654 if (wmi_handle->ops->extract_host_mem_req)
4655 return wmi_handle->ops->extract_host_mem_req(wmi_handle,
4656 evt_buf, num_entries);
4657
4658 *num_entries = 0;
4659 return NULL;
4660}
4661
4662/**
4663 * wmi_ready_extract_init_status() - Extract init status from ready event
4664 * @wmi_handle: wmi handle
4665 * @param ev: Pointer to event buffer
4666 *
4667 * Return: ready status
4668 */
4669uint32_t wmi_ready_extract_init_status(void *wmi_hdl, void *ev)
4670{
4671 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4672
4673 if (wmi_handle->ops->ready_extract_init_status)
4674 return wmi_handle->ops->ready_extract_init_status(wmi_handle,
4675 ev);
4676
4677
4678 return 1;
4679
4680}
4681
4682/**
4683 * wmi_ready_extract_mac_addr() - extract mac address from ready event
4684 * @wmi_handle: wmi handle
4685 * @param ev: pointer to event buffer
4686 * @param macaddr: Pointer to hold MAC address
4687 *
4688 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4689 */
4690QDF_STATUS wmi_ready_extract_mac_addr(void *wmi_hdl, void *ev, uint8_t *macaddr)
4691{
4692 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4693
4694 if (wmi_handle->ops->ready_extract_mac_addr)
4695 return wmi_handle->ops->ready_extract_mac_addr(wmi_handle,
4696 ev, macaddr);
4697
4698
4699 return QDF_STATUS_E_FAILURE;
4700}
4701
4702/**
Manoj Ekbotedd273902017-07-09 23:28:56 -07004703 * wmi_ready_extract_mac_addr() - extract MAC address list from ready event
4704 * @wmi_handle: wmi handle
4705 * @param ev: pointer to event buffer
4706 * @param num_mac_addr: Pointer to number of entries
4707 *
4708 * Return: address to start of mac addr list
4709 */
4710wmi_host_mac_addr *wmi_ready_extract_mac_addr_list(void *wmi_hdl, void *ev,
4711 uint8_t *num_mac_addr)
4712{
4713 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4714
4715 if (wmi_handle->ops->ready_extract_mac_addr_list)
4716 return wmi_handle->ops->ready_extract_mac_addr_list(wmi_handle,
4717 ev, num_mac_addr);
4718
4719 *num_mac_addr = 0;
4720
4721 return NULL;
4722}
4723
4724/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304725 * wmi_extract_dbglog_data_len() - extract debuglog data length
4726 * @wmi_handle: wmi handle
4727 * @param evt_buf: pointer to event buffer
4728 * @param len: length of buffer
4729 *
4730 * Return: length
4731 */
4732uint8_t *wmi_extract_dbglog_data_len(void *wmi_hdl, void *evt_buf,
Rajeev Kumar029b9ea2017-01-25 12:46:21 -08004733 uint32_t *len)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05304734{
4735 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4736
4737 if (wmi_handle->ops->extract_dbglog_data_len)
4738 return wmi_handle->ops->extract_dbglog_data_len(wmi_handle,
4739 evt_buf, len);
4740
4741
4742 return NULL;
4743}
4744
4745/**
4746 * wmi_send_ext_resource_config() - send extended resource configuration
4747 * @wmi_handle: wmi handle
4748 * @param ext_cfg: pointer to extended resource configuration
4749 *
4750 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4751 */
4752QDF_STATUS wmi_send_ext_resource_config(void *wmi_hdl,
4753 wmi_host_ext_resource_config *ext_cfg)
4754{
4755 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4756
4757 if (wmi_handle->ops->send_ext_resource_config)
4758 return wmi_handle->ops->send_ext_resource_config(wmi_handle,
4759 ext_cfg);
4760
4761 return QDF_STATUS_E_FAILURE;
4762}
4763
4764/**
4765 * wmi_unified_nf_dbr_dbm_info_get_cmd_send() - WMI request nf info function
4766 * @param wmi_handle : handle to WMI.
4767 *
4768 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4769 */
4770QDF_STATUS wmi_unified_nf_dbr_dbm_info_get_cmd_send(void *wmi_hdl)
4771{
4772 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4773
4774 if (wmi->ops->send_nf_dbr_dbm_info_get_cmd)
4775 return wmi->ops->send_nf_dbr_dbm_info_get_cmd(wmi);
4776
4777 return QDF_STATUS_E_FAILURE;
4778}
4779
4780/**
4781 * wmi_unified_packet_power_info_get_cmd_send() - WMI get packet power info function
4782 * @param wmi_handle : handle to WMI.
4783 * @param param : pointer to hold packet power info param
4784 *
4785 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4786 */
4787QDF_STATUS wmi_unified_packet_power_info_get_cmd_send(void *wmi_hdl,
4788 struct packet_power_info_params *param)
4789{
4790 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4791
4792 if (wmi->ops->send_packet_power_info_get_cmd)
4793 return wmi->ops->send_packet_power_info_get_cmd(wmi, param);
4794
4795 return QDF_STATUS_E_FAILURE;
4796}
4797
4798/**
4799 * wmi_unified_gpio_config_cmd_send() - WMI gpio config function
4800 * @param wmi_handle : handle to WMI.
4801 * @param param : pointer to hold gpio config param
4802 *
4803 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4804 */
4805QDF_STATUS wmi_unified_gpio_config_cmd_send(void *wmi_hdl,
4806 struct gpio_config_params *param)
4807{
4808 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4809
4810 if (wmi_handle->ops->send_gpio_config_cmd)
4811 return wmi_handle->ops->send_gpio_config_cmd(wmi_handle, param);
4812
4813 return QDF_STATUS_E_FAILURE;
4814}
4815
4816/**
4817 * wmi_unified_gpio_output_cmd_send() - WMI gpio config function
4818 * @param wmi_handle : handle to WMI.
4819 * @param param : pointer to hold gpio config param
4820 *
4821 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4822 */
4823QDF_STATUS wmi_unified_gpio_output_cmd_send(void *wmi_hdl,
4824 struct gpio_output_params *param)
4825{
4826 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4827
4828 if (wmi_handle->ops->send_gpio_output_cmd)
4829 return wmi_handle->ops->send_gpio_output_cmd(wmi_handle, param);
4830
4831 return QDF_STATUS_E_FAILURE;
4832}
4833
4834/**
4835 * wmi_unified_rtt_meas_req_test_cmd_send() - WMI rtt meas req test function
4836 * @param wmi_handle : handle to WMI.
4837 * @param param : pointer to hold rtt meas req test param
4838 *
4839 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4840 */
4841QDF_STATUS wmi_unified_rtt_meas_req_test_cmd_send(void *wmi_hdl,
4842 struct rtt_meas_req_test_params *param)
4843{
4844 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4845
4846 if (wmi_handle->ops->send_rtt_meas_req_test_cmd)
4847 return wmi_handle->ops->send_rtt_meas_req_test_cmd(wmi_handle,
4848 param);
4849
4850 return QDF_STATUS_E_FAILURE;
4851}
4852
4853/**
4854 * wmi_unified_rtt_meas_req_cmd_send() - WMI rtt meas req function
4855 * @param wmi_handle : handle to WMI.
4856 * @param param : pointer to hold rtt meas req param
4857 *
4858 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4859 */
4860QDF_STATUS wmi_unified_rtt_meas_req_cmd_send(void *wmi_hdl,
4861 struct rtt_meas_req_params *param)
4862{
4863 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4864
4865 if (wmi_handle->ops->send_rtt_meas_req_cmd)
4866 return wmi_handle->ops->send_rtt_meas_req_cmd(wmi_handle,
4867 param);
4868
4869 return QDF_STATUS_E_FAILURE;
4870}
4871
4872/**
4873 * wmi_unified_lci_set_cmd_send() - WMI lci set function
4874 * @param wmi_handle : handle to WMI.
4875 * @param param : pointer to hold lci param
4876 *
4877 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4878 */
4879QDF_STATUS wmi_unified_lci_set_cmd_send(void *wmi_hdl,
4880 struct lci_set_params *param)
4881{
4882 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4883
4884 if (wmi_handle->ops->send_lci_set_cmd)
4885 return wmi_handle->ops->send_lci_set_cmd(wmi_handle, param);
4886
4887 return QDF_STATUS_E_FAILURE;
4888}
4889
4890/**
4891 * wmi_unified_lcr_set_cmd_send() - WMI lcr set function
4892 * @param wmi_handle : handle to WMI.
4893 * @param param : pointer to hold lcr param
4894 *
4895 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4896 */
4897QDF_STATUS wmi_unified_lcr_set_cmd_send(void *wmi_hdl,
4898 struct lcr_set_params *param)
4899{
4900 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4901
4902 if (wmi_handle->ops->send_lcr_set_cmd)
4903 return wmi_handle->ops->send_lcr_set_cmd(wmi_handle, param);
4904
4905 return QDF_STATUS_E_FAILURE;
4906}
4907
4908/**
4909 * wmi_unified_rtt_keepalive_req_cmd_send() - WMI rtt meas req test function
4910 * @param wmi_handle : handle to WMI.
4911 * @param param : pointer to hold rtt meas req test param
4912 *
4913 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4914 */
4915QDF_STATUS wmi_unified_rtt_keepalive_req_cmd_send(void *wmi_hdl,
4916 struct rtt_keepalive_req_params *param)
4917{
4918 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4919
4920 if (wmi_handle->ops->send_rtt_keepalive_req_cmd)
4921 return wmi_handle->ops->send_rtt_keepalive_req_cmd(wmi_handle,
4922 param);
4923
4924 return QDF_STATUS_E_FAILURE;
4925}
4926
4927/**
4928 * wmi_unified_send_periodic_chan_stats_config_cmd() - send periodic chan stats cmd
4929 * to fw
4930 * @wmi_handle: wmi handle
4931 * @param: pointer to hold periodic chan stats param
4932 *
4933 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4934 */
4935QDF_STATUS wmi_unified_send_periodic_chan_stats_config_cmd(void *wmi_hdl,
4936 struct periodic_chan_stats_params *param)
4937{
4938 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
4939
4940 if (wmi->ops->send_periodic_chan_stats_config_cmd)
4941 return wmi->ops->send_periodic_chan_stats_config_cmd(wmi,
4942 param);
4943
4944 return QDF_STATUS_E_FAILURE;
4945}
4946
4947/**
4948 * wmi_send_atf_peer_request_cmd() - send atf peer request command to fw
4949 * @wmi_handle: wmi handle
4950 * @param: pointer to atf peer request param
4951 *
4952 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4953 */
4954QDF_STATUS
4955wmi_send_atf_peer_request_cmd(void *wmi_hdl,
4956 struct atf_peer_request_params *param)
4957{
4958 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4959
4960 if (wmi_handle->ops->send_atf_peer_request_cmd)
4961 return wmi_handle->ops->send_atf_peer_request_cmd(wmi_handle,
4962 param);
4963
4964 return QDF_STATUS_E_FAILURE;
4965}
4966
4967/**
4968 * wmi_send_set_atf_grouping_cmd() - send set atf grouping command to fw
4969 * @wmi_handle: wmi handle
4970 * @param: pointer to set atf grouping param
4971 *
4972 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4973 */
4974QDF_STATUS
4975wmi_send_set_atf_grouping_cmd(void *wmi_hdl,
4976 struct atf_grouping_params *param)
4977{
4978 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4979
4980 if (wmi_handle->ops->send_set_atf_grouping_cmd)
4981 return wmi_handle->ops->send_set_atf_grouping_cmd(wmi_handle,
4982 param);
4983
4984 return QDF_STATUS_E_FAILURE;
4985
4986}
4987
Sathish Kumar68789382016-11-14 17:44:29 +05304988/**
4989 * wmi_send_get_user_position_cmd() - send get user position command to fw
4990 * @wmi_handle: wmi handle
4991 *
4992 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
4993 */
4994QDF_STATUS
4995wmi_send_get_user_position_cmd(void *wmi_hdl, uint32_t value)
4996{
4997 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
4998
4999 if (wmi_handle->ops->send_get_user_position_cmd)
5000 return wmi_handle->ops->send_get_user_position_cmd(wmi_handle,
5001 value);
5002
5003 return QDF_STATUS_E_FAILURE;
5004}
5005
5006/**
5007 * wmi_send_get_peer_mumimo_tx_count_cmd() - send get mumio tx count
5008 * command to fw
5009 * @wmi_handle: wmi handle
5010 * @value: user pos value
5011 *
5012 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5013 */
5014QDF_STATUS
5015wmi_send_get_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
5016{
5017 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5018
5019 if (wmi->ops->send_get_peer_mumimo_tx_count_cmd)
5020 return wmi->ops->send_get_peer_mumimo_tx_count_cmd(wmi, value);
5021
5022 return QDF_STATUS_E_FAILURE;
5023}
5024
5025/**
5026 * wmi_send_reset_peer_mumimo_tx_count_cmd() - send reset peer mumimo
5027 * tx count to fw
5028 * @wmi_handle: wmi handle
5029 * @value: reset tx count value
5030 *
5031 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5032 */
5033QDF_STATUS
5034wmi_send_reset_peer_mumimo_tx_count_cmd(void *wmi_hdl, uint32_t value)
5035{
5036 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5037
5038 if (wmi->ops->send_reset_peer_mumimo_tx_count_cmd)
5039 return wmi->ops->send_reset_peer_mumimo_tx_count_cmd(wmi,
5040 value);
5041
5042 return QDF_STATUS_E_FAILURE;
5043}
5044
5045/**
5046 * wmi_send_pdev_caldata_version_check_cmd() - send reset peer mumimo
5047 * tx count to fw
5048 * @wmi_handle: wmi handle
5049 * @value: value
5050 *
5051 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5052 */
5053QDF_STATUS
5054wmi_send_pdev_caldata_version_check_cmd(void *wmi_hdl, uint32_t value)
5055{
5056 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5057
5058 if (wmi->ops->send_pdev_caldata_version_check_cmd)
5059 return wmi->ops->send_pdev_caldata_version_check_cmd(wmi,
5060 value);
5061
5062 return QDF_STATUS_E_FAILURE;
5063}
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305064
5065/* Extract - APIs */
5066/**
5067 * wmi_extract_wds_addr_event - Extract WDS addr WMI event
5068 *
5069 * @param wmi_handle : handle to WMI.
5070 * @param evt_buf : pointer to event buffer
5071 * @param len : length of the event buffer
5072 * @param wds_ev: pointer to strct to extract
5073 * @return QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5074 */
5075QDF_STATUS wmi_extract_wds_addr_event(void *wmi_hdl, void *evt_buf,
5076 uint16_t len, wds_addr_event_t *wds_ev)
5077{
5078 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5079
5080 if (wmi_handle->ops->extract_wds_addr_event) {
5081 return wmi_handle->ops->extract_wds_addr_event(wmi_handle,
5082 evt_buf, len, wds_ev);
5083 }
5084 return QDF_STATUS_E_FAILURE;
5085}
5086
5087/**
5088 * wmi_extract_dcs_interference_type() - extract dcs interference type
5089 * @wmi_handle: wmi handle
5090 * @param evt_buf: pointer to event buffer
Kiran Venkatappafea8a802016-12-29 18:09:32 +05305091 * @param param: Pointer to hold dcs interference param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305092 *
5093 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5094 */
5095QDF_STATUS wmi_extract_dcs_interference_type(void *wmi_hdl,
Kiran Venkatappafea8a802016-12-29 18:09:32 +05305096 void *evt_buf, struct wmi_host_dcs_interference_param *param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305097{
5098 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5099
5100 if (wmi->ops->extract_dcs_interference_type) {
5101 return wmi->ops->extract_dcs_interference_type(wmi,
Kiran Venkatappafea8a802016-12-29 18:09:32 +05305102 evt_buf, param);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305103 }
5104 return QDF_STATUS_E_FAILURE;
5105}
5106
5107/*
5108 * wmi_extract_dcs_cw_int() - extract dcs cw interference from event
5109 * @wmi_handle: wmi handle
5110 * @param evt_buf: pointer to event buffer
5111 * @param cw_int: Pointer to hold cw interference
5112 *
5113 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5114 */
5115QDF_STATUS wmi_extract_dcs_cw_int(void *wmi_hdl, void *evt_buf,
5116 wmi_host_ath_dcs_cw_int *cw_int)
5117{
5118 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5119
5120 if (wmi_handle->ops->extract_dcs_cw_int) {
5121 return wmi_handle->ops->extract_dcs_cw_int(wmi_handle,
5122 evt_buf, cw_int);
5123 }
5124 return QDF_STATUS_E_FAILURE;
5125}
5126
5127/**
5128 * wmi_extract_dcs_im_tgt_stats() - extract dcs im target stats from event
5129 * @wmi_handle: wmi handle
5130 * @param evt_buf: pointer to event buffer
5131 * @param wlan_stat: Pointer to hold wlan stats
5132 *
5133 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5134 */
5135QDF_STATUS wmi_extract_dcs_im_tgt_stats(void *wmi_hdl, void *evt_buf,
5136 wmi_host_dcs_im_tgt_stats_t *wlan_stat)
5137{
5138 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5139
5140 if (wmi_handle->ops->extract_dcs_im_tgt_stats) {
5141 return wmi_handle->ops->extract_dcs_im_tgt_stats(wmi_handle,
5142 evt_buf, wlan_stat);
5143 }
5144 return QDF_STATUS_E_FAILURE;
5145}
5146
5147/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305148 * wmi_extract_fips_event_data() - extract fips event data
5149 * @wmi_handle: wmi handle
5150 * @param evt_buf: pointer to event buffer
Kiran Venkatappac813ec92016-12-29 22:07:14 +05305151 * @param param: pointer to FIPS event param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305152 *
5153 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5154 */
5155QDF_STATUS wmi_extract_fips_event_data(void *wmi_hdl, void *evt_buf,
Kiran Venkatappac813ec92016-12-29 22:07:14 +05305156 struct wmi_host_fips_event_param *param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305157{
5158 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5159
5160 if (wmi_handle->ops->extract_fips_event_data) {
5161 return wmi_handle->ops->extract_fips_event_data(wmi_handle,
Kiran Venkatappac813ec92016-12-29 22:07:14 +05305162 evt_buf, param);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305163 }
5164 return QDF_STATUS_E_FAILURE;
5165}
5166
5167/**
5168 * wmi_extract_vdev_start_resp() - extract vdev start response
5169 * @wmi_handle: wmi handle
5170 * @param evt_buf: pointer to event buffer
5171 * @param vdev_rsp: Pointer to hold vdev response
5172 *
5173 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5174 */
5175QDF_STATUS wmi_extract_vdev_start_resp(void *wmi_hdl, void *evt_buf,
5176 wmi_host_vdev_start_resp *vdev_rsp)
5177{
5178 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5179
5180 if (wmi_handle->ops->extract_vdev_start_resp)
5181 return wmi_handle->ops->extract_vdev_start_resp(wmi_handle,
5182 evt_buf, vdev_rsp);
5183
5184 return QDF_STATUS_E_FAILURE;
5185}
5186
5187/**
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305188 * wmi_extract_tbttoffset_num_vdevs() - extract tbtt offset num vdev
5189 * @wmi_handle: wmi handle
5190 * @param evt_buf: pointer to event buffer
5191 * @param vdev_map: Pointer to hold num vdev
5192 *
5193 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5194 */
5195QDF_STATUS wmi_extract_tbttoffset_num_vdevs(void *wmi_hdl, void *evt_buf,
5196 uint32_t *num_vdevs)
5197{
5198 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5199
5200 if (wmi->ops->extract_tbttoffset_num_vdevs)
5201 return wmi->ops->extract_tbttoffset_num_vdevs(wmi,
5202 evt_buf, num_vdevs);
5203
5204 return QDF_STATUS_E_FAILURE;
5205}
5206
5207/**
5208 * wmi_extract_ext_tbttoffset_num_vdevs() - extract ext tbtt offset num vdev
5209 * @wmi_handle: wmi handle
5210 * @param evt_buf: pointer to event buffer
5211 * @param vdev_map: Pointer to hold num vdev
5212 *
5213 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5214 */
5215QDF_STATUS wmi_extract_ext_tbttoffset_num_vdevs(void *wmi_hdl, void *evt_buf,
5216 uint32_t *num_vdevs)
5217{
5218 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5219
5220 if (wmi->ops->extract_ext_tbttoffset_num_vdevs)
5221 return wmi->ops->extract_ext_tbttoffset_num_vdevs(wmi,
5222 evt_buf, num_vdevs);
5223
5224 return QDF_STATUS_E_FAILURE;
5225}
5226
5227/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305228 * wmi_extract_tbttoffset_update_params() - extract tbtt offset update param
5229 * @wmi_handle: wmi handle
5230 * @param evt_buf: pointer to event buffer
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305231 * @param idx: Index refering to a vdev
5232 * @param tbtt_param: Pointer to tbttoffset event param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305233 *
5234 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5235 */
5236QDF_STATUS wmi_extract_tbttoffset_update_params(void *wmi_hdl, void *evt_buf,
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305237 uint8_t idx, struct tbttoffset_params *tbtt_param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305238{
5239 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5240
5241 if (wmi->ops->extract_tbttoffset_update_params)
5242 return wmi->ops->extract_tbttoffset_update_params(wmi,
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305243 evt_buf, idx, tbtt_param);
5244
5245 return QDF_STATUS_E_FAILURE;
5246}
5247
5248/**
5249 * wmi_extract_ext_tbttoffset_update_params() - extract tbtt offset update param
5250 * @wmi_handle: wmi handle
5251 * @param evt_buf: pointer to event buffer
5252 * @param idx: Index refering to a vdev
5253 * @param tbtt_param: Pointer to tbttoffset event param
5254 *
5255 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5256 */
5257QDF_STATUS wmi_extract_ext_tbttoffset_update_params(void *wmi_hdl,
5258 void *evt_buf, uint8_t idx, struct tbttoffset_params *tbtt_param)
5259{
5260 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5261
5262 if (wmi->ops->extract_ext_tbttoffset_update_params)
5263 return wmi->ops->extract_ext_tbttoffset_update_params(wmi,
5264 evt_buf, idx, tbtt_param);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305265
5266 return QDF_STATUS_E_FAILURE;
5267}
5268
5269/**
5270 * wmi_extract_mgmt_rx_params() - extract management rx params from event
5271 * @wmi_handle: wmi handle
5272 * @param evt_buf: pointer to event buffer
5273 * @param hdr: Pointer to hold header
5274 * @param bufp: Pointer to hold pointer to rx param buffer
5275 *
5276 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5277 */
5278QDF_STATUS wmi_extract_mgmt_rx_params(void *wmi_hdl, void *evt_buf,
Himanshu Agarwalb4992a42017-01-05 14:23:18 +05305279 struct mgmt_rx_event_params *hdr, uint8_t **bufp)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305280{
5281 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5282
5283 if (wmi_handle->ops->extract_mgmt_rx_params)
5284 return wmi_handle->ops->extract_mgmt_rx_params(wmi_handle,
5285 evt_buf, hdr, bufp);
5286
5287 return QDF_STATUS_E_FAILURE;
5288}
5289
5290/**
5291 * wmi_extract_vdev_stopped_param() - extract vdev stop param from event
5292 * @wmi_handle: wmi handle
5293 * @param evt_buf: pointer to event buffer
5294 * @param vdev_id: Pointer to hold vdev identifier
5295 *
5296 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5297 */
5298QDF_STATUS wmi_extract_vdev_stopped_param(void *wmi_hdl, void *evt_buf,
5299 uint32_t *vdev_id)
5300{
5301 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5302
5303 if (wmi_handle->ops->extract_vdev_stopped_param)
5304 return wmi_handle->ops->extract_vdev_stopped_param(wmi_handle,
5305 evt_buf, vdev_id);
5306
5307 return QDF_STATUS_E_FAILURE;
5308}
5309
5310/**
5311 * wmi_extract_vdev_roam_param() - extract vdev roam param from event
5312 * @wmi_handle: wmi handle
5313 * @param evt_buf: pointer to event buffer
5314 * @param param: Pointer to hold roam param
5315 *
5316 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5317 */
5318QDF_STATUS wmi_extract_vdev_roam_param(void *wmi_hdl, void *evt_buf,
5319 wmi_host_roam_event *param)
5320{
5321 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5322
5323 if (wmi_handle->ops->extract_vdev_roam_param)
5324 return wmi_handle->ops->extract_vdev_roam_param(wmi_handle,
5325 evt_buf, param);
5326
5327 return QDF_STATUS_E_FAILURE;
5328}
5329
5330/**
5331 * wmi_extract_vdev_scan_ev_param() - extract vdev scan param from event
5332 * @wmi_handle: wmi handle
5333 * @param evt_buf: pointer to event buffer
5334 * @param param: Pointer to hold vdev scan param
5335 *
5336 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5337 */
5338QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf,
Om Prakash Tripathi1d83e352017-02-25 15:53:30 +05305339 struct scan_event *param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305340{
5341 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5342
5343 if (wmi_handle->ops->extract_vdev_scan_ev_param)
5344 return wmi_handle->ops->extract_vdev_scan_ev_param(wmi_handle,
5345 evt_buf, param);
5346
5347 return QDF_STATUS_E_FAILURE;
5348}
5349
Frank Liu3d5e9992017-03-15 17:51:43 +08005350#ifdef CONVERGED_TDLS_ENABLE
5351QDF_STATUS wmi_extract_vdev_tdls_ev_param(void *wmi_hdl, void *evt_buf,
5352 struct tdls_event_info *param)
5353{
5354 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl;
5355
5356 if (wmi_handle->ops->extract_vdev_tdls_ev_param)
5357 return wmi_handle->ops->extract_vdev_tdls_ev_param(wmi_handle,
5358 evt_buf, param);
5359
5360 return QDF_STATUS_E_FAILURE;
5361}
5362#endif
5363
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305364/**
5365 * wmi_extract_mu_ev_param() - extract mu param from event
5366 * @wmi_handle: wmi handle
5367 * @param evt_buf: pointer to event buffer
5368 * @param param: Pointer to hold mu report
5369 *
5370 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5371 */
5372QDF_STATUS wmi_extract_mu_ev_param(void *wmi_hdl, void *evt_buf,
5373 wmi_host_mu_report_event *param)
5374{
5375 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5376
5377 if (wmi_handle->ops->extract_mu_ev_param)
5378 return wmi_handle->ops->extract_mu_ev_param(wmi_handle, evt_buf,
5379 param);
5380
5381 return QDF_STATUS_E_FAILURE;
5382}
5383
5384/**
Sathish Kumar68789382016-11-14 17:44:29 +05305385 * wmi_extract_mu_db_entry() - extract mu db entry from event
5386 * @wmi_handle: wmi handle
5387 * @param evt_buf: pointer to event buffer
5388 * @param param: Pointer to hold mu db entry
5389 *
5390 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5391 */
5392QDF_STATUS wmi_extract_mu_db_entry(void *wmi_hdl, void *evt_buf,
5393 uint8_t idx, wmi_host_mu_db_entry *param)
5394{
5395 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5396
5397 if (wmi_handle->ops->extract_mu_db_entry)
5398 return wmi_handle->ops->extract_mu_db_entry(wmi_handle, evt_buf,
5399 idx, param);
5400
5401 return QDF_STATUS_E_FAILURE;
5402}
5403
5404/**
5405 * wmi_extract_mumimo_tx_count_ev_param() - extract mumimo tx count from event
5406 * @wmi_handle: wmi handle
5407 * @param evt_buf: pointer to event buffer
5408 * @param param: Pointer to hold mumimo tx count
5409 *
5410 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5411 */
5412QDF_STATUS wmi_extract_mumimo_tx_count_ev_param(void *wmi_hdl, void *evt_buf,
5413 wmi_host_peer_txmu_cnt_event *param)
5414{
5415 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5416
5417 if (wmi->ops->extract_mumimo_tx_count_ev_param)
5418 return wmi->ops->extract_mumimo_tx_count_ev_param(wmi,
5419 evt_buf, param);
5420
5421 return QDF_STATUS_E_FAILURE;
5422}
5423
5424/**
5425 * wmi_extract_peer_gid_userpos_list_ev_param() - extract peer userpos list
5426 * from event
5427 * @wmi_handle: wmi handle
5428 * @param evt_buf: pointer to event buffer
5429 * @param param: Pointer to hold peer gid userposition list
5430 *
5431 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5432 */
5433QDF_STATUS wmi_extract_peer_gid_userpos_list_ev_param(void *wmi_hdl,
5434 void *evt_buf,
5435 wmi_host_peer_gid_userpos_list_event *param)
5436{
5437 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5438
5439 if (wmi->ops->extract_peer_gid_userpos_list_ev_param)
5440 return wmi->ops->extract_peer_gid_userpos_list_ev_param(wmi,
5441 evt_buf, param);
5442
5443 return QDF_STATUS_E_FAILURE;
5444}
5445
5446/**
5447 * wmi_extract_pdev_caldata_version_check_ev_param() - extract caldata
5448 * from event
5449 * @wmi_handle: wmi handle
5450 * @param evt_buf: pointer to event buffer
5451 * @param param: Pointer to hold caldata version data
5452 *
5453 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5454 */
5455QDF_STATUS wmi_extract_pdev_caldata_version_check_ev_param(void *wmi_hdl,
5456 void *evt_buf,
5457 wmi_host_pdev_check_cal_version_event *param)
5458{
5459 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5460
5461 if (wmi->ops->extract_pdev_caldata_version_check_ev_param)
5462 return wmi->ops->extract_pdev_caldata_version_check_ev_param(
5463 wmi, evt_buf, param);
5464
5465 return QDF_STATUS_E_FAILURE;
5466}
5467
5468/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305469 * wmi_extract_pdev_tpc_config_ev_param() - extract pdev tpc configuration
5470 * param from event
5471 * @wmi_handle: wmi handle
5472 * @param evt_buf: pointer to event buffer
5473 * @param param: Pointer to hold tpc configuration
5474 *
5475 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5476 */
5477QDF_STATUS wmi_extract_pdev_tpc_config_ev_param(void *wmi_hdl, void *evt_buf,
5478 wmi_host_pdev_tpc_config_event *param)
5479{
5480 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5481
5482 if (wmi->ops->extract_pdev_tpc_config_ev_param)
5483 return wmi->ops->extract_pdev_tpc_config_ev_param(wmi,
5484 evt_buf, param);
5485
5486 return QDF_STATUS_E_FAILURE;
5487
5488}
5489
5490/**
5491 * wmi_extract_gpio_input_ev_param() - extract gpio input param from event
5492 * @wmi_handle: wmi handle
5493 * @param evt_buf: pointer to event buffer
5494 * @param gpio_num: Pointer to hold gpio number
5495 *
5496 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5497 */
5498QDF_STATUS wmi_extract_gpio_input_ev_param(void *wmi_hdl,
5499 void *evt_buf, uint32_t *gpio_num)
5500{
5501 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5502
5503 if (wmi_handle->ops->extract_gpio_input_ev_param)
5504 return wmi_handle->ops->extract_gpio_input_ev_param(wmi_handle,
5505 evt_buf, gpio_num);
5506
5507 return QDF_STATUS_E_FAILURE;
5508}
5509
5510/**
5511 * wmi_extract_pdev_reserve_ast_ev_param() - extract reserve ast entry
5512 * param from event
5513 * @wmi_handle: wmi handle
5514 * @param evt_buf: pointer to event buffer
Kiran Venkatappa5050aa82017-02-08 14:57:16 +05305515 * @param param: Pointer to hold reserve ast entry param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305516 *
5517 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5518 */
5519QDF_STATUS wmi_extract_pdev_reserve_ast_ev_param(void *wmi_hdl,
Kiran Venkatappa5050aa82017-02-08 14:57:16 +05305520 void *evt_buf, struct wmi_host_proxy_ast_reserve_param *param)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305521{
5522 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5523
5524 if (wmi->ops->extract_pdev_reserve_ast_ev_param)
5525 return wmi->ops->extract_pdev_reserve_ast_ev_param(wmi,
Kiran Venkatappa5050aa82017-02-08 14:57:16 +05305526 evt_buf, param);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305527
5528 return QDF_STATUS_E_FAILURE;
5529}
5530
5531/**
5532 * wmi_extract_nfcal_power_ev_param() - extract noise floor calibration
5533 * power param from event
5534 * @wmi_handle: wmi handle
5535 * @param evt_buf: pointer to event buffer
5536 * @param param: Pointer to hold nf cal power param
5537 *
5538 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5539 */
5540QDF_STATUS wmi_extract_nfcal_power_ev_param(void *wmi_hdl, void *evt_buf,
5541 wmi_host_pdev_nfcal_power_all_channels_event *param)
5542{
5543 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5544
5545 if (wmi_handle->ops->extract_nfcal_power_ev_param)
5546 return wmi_handle->ops->extract_nfcal_power_ev_param(wmi_handle,
5547 evt_buf, param);
5548
5549 return QDF_STATUS_E_FAILURE;
5550
5551}
5552
5553/**
5554 * wmi_extract_pdev_tpc_ev_param() - extract tpc param from event
5555 * @wmi_handle: wmi handle
5556 * @param evt_buf: pointer to event buffer
5557 * @param param: Pointer to hold tpc param
5558 *
5559 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5560 */
5561QDF_STATUS wmi_extract_pdev_tpc_ev_param(void *wmi_hdl, void *evt_buf,
5562 wmi_host_pdev_tpc_event *param)
5563{
5564 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5565
5566 if (wmi_handle->ops->extract_pdev_tpc_ev_param)
5567 return wmi_handle->ops->extract_pdev_tpc_ev_param(wmi_handle,
5568 evt_buf, param);
5569
5570 return QDF_STATUS_E_FAILURE;
5571
5572}
5573
5574/**
5575 * wmi_extract_pdev_generic_buffer_ev_param() - extract pdev generic buffer
5576 * from event
5577 * @wmi_handle: wmi handle
5578 * @param evt_buf: pointer to event buffer
5579 * @param param: Pointer to generic buffer param
5580 *
5581 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5582 */
5583QDF_STATUS wmi_extract_pdev_generic_buffer_ev_param(void *wmi_hdl,
5584 void *evt_buf, wmi_host_pdev_generic_buffer_event *param)
5585{
5586 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5587
5588 if (wmi->ops->extract_pdev_generic_buffer_ev_param)
5589 return wmi->ops->extract_pdev_generic_buffer_ev_param(wmi,
5590 evt_buf, param);
5591
5592 return QDF_STATUS_E_FAILURE;
5593
5594}
5595
5596/**
5597 * wmi_extract_mgmt_tx_compl_param() - extract mgmt tx completion param
5598 * from event
Kiran Venkatappac13fc7b2017-03-19 22:58:09 +05305599 * @wmi_hdl: wmi handle
5600 * @evt_buf: pointer to event buffer
5601 * @param: Pointer to mgmt tx completion param
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305602 *
5603 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5604 */
5605QDF_STATUS wmi_extract_mgmt_tx_compl_param(void *wmi_hdl, void *evt_buf,
5606 wmi_host_mgmt_tx_compl_event *param)
5607{
5608 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5609
5610 if (wmi_handle->ops->extract_mgmt_tx_compl_param)
5611 return wmi_handle->ops->extract_mgmt_tx_compl_param(wmi_handle,
5612 evt_buf, param);
5613
5614
5615 return QDF_STATUS_E_FAILURE;
5616}
5617
5618/**
Kiran Venkatappac13fc7b2017-03-19 22:58:09 +05305619 * wmi_extract_offchan_data_tx_compl_param() -
5620 * extract offchan data tx completion param from event
5621 * @wmi_hdl: wmi handle
5622 * @evt_buf: pointer to event buffer
5623 * @param: Pointer to offchan data tx completion param
5624 *
5625 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5626 */
5627QDF_STATUS wmi_extract_offchan_data_tx_compl_param(void *wmi_hdl, void *evt_buf,
5628 struct wmi_host_offchan_data_tx_compl_event *param)
5629{
5630 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5631
5632 if (wmi_handle->ops->extract_offchan_data_tx_compl_param)
5633 return wmi_handle->ops->extract_offchan_data_tx_compl_param(
5634 wmi_handle, evt_buf, param);
5635
5636
5637 return QDF_STATUS_E_FAILURE;
5638}
5639
5640/**
Sathish Kumar45e991b2017-02-27 10:35:40 +05305641 * wmi_extract_pdev_csa_switch_count_status() - extract CSA switch count status
5642 * from event
5643 * @wmi_handle: wmi handle
5644 * @param evt_buf: pointer to event buffer
5645 * @param param: Pointer to CSA switch count status param
5646 *
5647 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5648 */
5649QDF_STATUS wmi_extract_pdev_csa_switch_count_status(void *wmi_hdl,
5650 void *evt_buf,
5651 struct pdev_csa_switch_count_status *param)
5652{
5653 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5654
5655 if (wmi_handle->ops->extract_pdev_csa_switch_count_status)
5656 return wmi_handle->ops->extract_pdev_csa_switch_count_status(
5657 wmi_handle,
5658 evt_buf,
5659 param);
5660
5661 return QDF_STATUS_E_FAILURE;
5662}
5663
5664
5665/**
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305666 * wmi_extract_swba_num_vdevs() - extract swba num vdevs from event
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305667 * @wmi_handle: wmi handle
5668 * @param evt_buf: pointer to event buffer
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305669 * @param num_vdevs: Pointer to hold num vdevs
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305670 *
5671 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5672 */
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305673QDF_STATUS wmi_extract_swba_num_vdevs(void *wmi_hdl, void *evt_buf,
5674 uint32_t *num_vdevs)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305675{
5676 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5677
Sathish Kumare5f0e0e2017-05-17 18:05:15 +05305678 if (wmi_handle->ops->extract_swba_num_vdevs)
5679 return wmi_handle->ops->extract_swba_num_vdevs(wmi_handle,
5680 evt_buf, num_vdevs);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305681
5682 return QDF_STATUS_E_FAILURE;
5683}
5684
5685/**
5686 * wmi_extract_swba_tim_info() - extract swba tim info from event
5687 * @wmi_handle: wmi handle
5688 * @param evt_buf: pointer to event buffer
5689 * @param idx: Index to bcn info
5690 * @param tim_info: Pointer to hold tim info
5691 *
5692 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5693 */
5694QDF_STATUS wmi_extract_swba_tim_info(void *wmi_hdl, void *evt_buf,
5695 uint32_t idx, wmi_host_tim_info *tim_info)
5696{
5697 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5698
5699 if (wmi_handle->ops->extract_swba_tim_info)
5700 return wmi_handle->ops->extract_swba_tim_info(wmi_handle,
5701 evt_buf, idx, tim_info);
5702
5703 return QDF_STATUS_E_FAILURE;
5704}
5705
5706/**
5707 * wmi_extract_swba_noa_info() - extract swba NoA information from event
5708 * @wmi_handle: wmi handle
5709 * @param evt_buf: pointer to event buffer
5710 * @param idx: Index to bcn info
5711 * @param p2p_desc: Pointer to hold p2p NoA info
5712 *
5713 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5714 */
5715QDF_STATUS wmi_extract_swba_noa_info(void *wmi_hdl, void *evt_buf,
5716 uint32_t idx, wmi_host_p2p_noa_info *p2p_desc)
5717{
5718 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5719
5720 if (wmi_handle->ops->extract_swba_noa_info)
5721 return wmi_handle->ops->extract_swba_noa_info(wmi_handle,
5722 evt_buf, idx, p2p_desc);
5723
5724 return QDF_STATUS_E_FAILURE;
5725}
5726
Wu Gaocd3a8512017-03-13 20:17:34 +08005727#ifdef CONVERGED_P2P_ENABLE
5728/**
5729 * wmi_extract_p2p_lo_stop_ev_param() - extract p2p lo stop param from event
5730 * @wmi_handle: wmi handle
5731 * @evt_buf: pointer to event buffer
5732 * @param: Pointer to hold listen offload stop param
5733 *
5734 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5735 */
5736QDF_STATUS wmi_extract_p2p_lo_stop_ev_param(void *wmi_hdl, void *evt_buf,
5737 struct p2p_lo_event *param)
5738{
5739 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5740
5741 if (!wmi_handle) {
5742 WMI_LOGE("wmi handle is null");
5743 return QDF_STATUS_E_INVAL;
5744 }
5745
5746 if (wmi_handle->ops->extract_p2p_lo_stop_ev_param)
5747 return wmi_handle->ops->extract_p2p_lo_stop_ev_param(
5748 wmi_handle, evt_buf, param);
5749
5750 return QDF_STATUS_E_FAILURE;
5751}
5752
5753/**
5754 * wmi_extract_p2p_noa_ev_param() - extract p2p noa param from event
5755 * @wmi_handle: wmi handle
5756 * @evt_buf: pointer to event buffer
5757 * @param: Pointer to hold p2p noa param
5758 *
5759 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5760 */
5761QDF_STATUS wmi_extract_p2p_noa_ev_param(void *wmi_hdl, void *evt_buf,
5762 struct p2p_noa_info *param)
5763{
5764 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5765
5766 if (!wmi_handle) {
5767 WMI_LOGE("wmi handle is null");
5768 return QDF_STATUS_E_INVAL;
5769 }
5770
5771 if (wmi_handle->ops->extract_p2p_noa_ev_param)
5772 return wmi_handle->ops->extract_p2p_noa_ev_param(
5773 wmi_handle, evt_buf, param);
5774
5775 return QDF_STATUS_E_FAILURE;
5776}
5777#endif
5778
Govind Singhe7d9f3e2016-04-15 13:58:27 +05305779/**
5780 * wmi_extract_peer_sta_ps_statechange_ev() - extract peer sta ps state
5781 * from event
5782 * @wmi_handle: wmi handle
5783 * @param evt_buf: pointer to event buffer
5784 * @param ev: Pointer to hold peer param and ps state
5785 *
5786 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5787 */
5788QDF_STATUS wmi_extract_peer_sta_ps_statechange_ev(void *wmi_hdl, void *evt_buf,
5789 wmi_host_peer_sta_ps_statechange_event *ev)
5790{
5791 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5792
5793 if (wmi->ops->extract_peer_sta_ps_statechange_ev)
5794 return wmi->ops->extract_peer_sta_ps_statechange_ev(wmi,
5795 evt_buf, ev);
5796
5797 return QDF_STATUS_E_FAILURE;
5798}
5799
5800/**
5801 * wmi_extract_peer_sta_kickout_ev() - extract peer sta kickout event
5802 * @wmi_handle: wmi handle
5803 * @param evt_buf: pointer to event buffer
5804 * @param ev: Pointer to hold peer param
5805 *
5806 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5807 */
5808QDF_STATUS wmi_extract_peer_sta_kickout_ev(void *wmi_hdl, void *evt_buf,
5809 wmi_host_peer_sta_kickout_event *ev)
5810{
5811 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5812
5813 if (wmi_handle->ops->extract_peer_sta_kickout_ev)
5814 return wmi_handle->ops->extract_peer_sta_kickout_ev(wmi_handle,
5815 evt_buf, ev);
5816
5817 return QDF_STATUS_E_FAILURE;
5818}
5819
5820/**
5821 * wmi_extract_peer_ratecode_list_ev() - extract peer ratecode from event
5822 * @wmi_handle: wmi handle
5823 * @param evt_buf: pointer to event buffer
5824 * @param peer_mac: Pointer to hold peer mac address
5825 * @param rate_cap: Pointer to hold ratecode
5826 *
5827 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5828 */
5829QDF_STATUS wmi_extract_peer_ratecode_list_ev(void *wmi_hdl, void *evt_buf,
5830 uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap)
5831{
5832 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
5833
5834 if (wmi->ops->extract_peer_ratecode_list_ev)
5835 return wmi->ops->extract_peer_ratecode_list_ev(wmi,
5836 evt_buf, peer_mac, rate_cap);
5837
5838 return QDF_STATUS_E_FAILURE;
5839
5840}
5841
5842/**
5843 * wmi_extract_comb_phyerr() - extract comb phy error from event
5844 * @wmi_handle: wmi handle
5845 * @param evt_buf: pointer to event buffer
5846 * @param datalen: data length of event buffer
5847 * @param buf_offset: Pointer to hold value of current event buffer offset
5848 * post extraction
5849 * @param phyer: Pointer to hold phyerr
5850 *
5851 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5852 */
5853QDF_STATUS wmi_extract_comb_phyerr(void *wmi_hdl, void *evt_buf,
5854 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr)
5855{
5856 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5857
5858 if (wmi_handle->ops->extract_comb_phyerr)
5859 return wmi_handle->ops->extract_comb_phyerr(wmi_handle,
5860 evt_buf, datalen, buf_offset, phyerr);
5861
5862 return QDF_STATUS_E_FAILURE;
5863
5864}
5865
5866/**
5867 * wmi_extract_single_phyerr() - extract single phy error from event
5868 * @wmi_handle: wmi handle
5869 * @param evt_buf: pointer to event buffer
5870 * @param datalen: data length of event buffer
5871 * @param buf_offset: Pointer to hold value of current event buffer offset
5872 * post extraction
5873 * @param phyerr: Pointer to hold phyerr
5874 *
5875 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5876 */
5877QDF_STATUS wmi_extract_single_phyerr(void *wmi_hdl, void *evt_buf,
5878 uint16_t datalen, uint16_t *buf_offset, wmi_host_phyerr_t *phyerr)
5879{
5880 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5881
5882 if (wmi_handle->ops->extract_single_phyerr)
5883 return wmi_handle->ops->extract_single_phyerr(wmi_handle,
5884 evt_buf, datalen, buf_offset, phyerr);
5885
5886 return QDF_STATUS_E_FAILURE;
5887
5888}
5889
5890/**
5891 * wmi_extract_composite_phyerr() - extract composite phy error from event
5892 * @wmi_handle: wmi handle
5893 * @param evt_buf: pointer to event buffer
5894 * @param datalen: Length of event buffer
5895 * @param phyerr: Pointer to hold phy error
5896 *
5897 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5898 */
5899QDF_STATUS wmi_extract_composite_phyerr(void *wmi_hdl, void *evt_buf,
5900 uint16_t datalen, wmi_host_phyerr_t *phyerr)
5901{
5902 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5903
5904 if (wmi_handle->ops->extract_composite_phyerr)
5905 return wmi_handle->ops->extract_composite_phyerr(wmi_handle,
5906 evt_buf, datalen, phyerr);
5907
5908 return QDF_STATUS_E_FAILURE;
5909
5910}
5911
5912/**
5913 * wmi_extract_stats_param() - extract all stats count from event
5914 * @wmi_handle: wmi handle
5915 * @param evt_buf: pointer to event buffer
5916 * @param stats_param: Pointer to hold stats count
5917 *
5918 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5919 */
5920QDF_STATUS wmi_extract_stats_param(void *wmi_hdl, void *evt_buf,
5921 wmi_host_stats_event *stats_param)
5922{
5923 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5924
5925 if (wmi_handle->ops->extract_all_stats_count)
5926 return wmi_handle->ops->extract_all_stats_count(wmi_handle,
5927 evt_buf, stats_param);
5928
5929 return QDF_STATUS_E_FAILURE;
5930}
5931
5932/**
5933 * wmi_extract_pdev_stats() - extract pdev stats from event
5934 * @wmi_handle: wmi handle
5935 * @param evt_buf: pointer to event buffer
5936 * @param index: Index into pdev stats
5937 * @param pdev_stats: Pointer to hold pdev stats
5938 *
5939 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5940 */
5941QDF_STATUS wmi_extract_pdev_stats(void *wmi_hdl, void *evt_buf,
5942 uint32_t index, wmi_host_pdev_stats *pdev_stats)
5943{
5944 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5945
5946 if (wmi_handle->ops->extract_pdev_stats)
5947 return wmi_handle->ops->extract_pdev_stats(wmi_handle,
5948 evt_buf, index, pdev_stats);
5949
5950 return QDF_STATUS_E_FAILURE;
5951}
5952
5953/**
5954 * wmi_extract_pdev_ext_stats() - extract extended pdev stats from event
5955 * @wmi_handle: wmi handle
5956 * @param evt_buf: pointer to event buffer
5957 * @param index: Index into extended pdev stats
5958 * @param pdev_ext_stats: Pointer to hold extended pdev stats
5959 *
5960 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5961 */
5962QDF_STATUS wmi_extract_pdev_ext_stats(void *wmi_hdl, void *evt_buf,
5963 uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats)
5964{
5965 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5966
5967 if (wmi_handle->ops->extract_pdev_ext_stats)
5968 return wmi_handle->ops->extract_pdev_ext_stats(wmi_handle,
5969 evt_buf, index, pdev_ext_stats);
5970
5971 return QDF_STATUS_E_FAILURE;
5972}
5973
5974/**
5975 * wmi_extract_peer_stats() - extract peer stats from event
5976 * @wmi_handle: wmi handle
5977 * @param evt_buf: pointer to event buffer
5978 * @param index: Index into peer stats
5979 * @param peer_stats: Pointer to hold peer stats
5980 *
5981 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
5982 */
5983QDF_STATUS wmi_extract_peer_stats(void *wmi_hdl, void *evt_buf,
5984 uint32_t index, wmi_host_peer_stats *peer_stats)
5985{
5986 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
5987
5988 if (wmi_handle->ops->extract_peer_stats)
5989 return wmi_handle->ops->extract_peer_stats(wmi_handle,
5990 evt_buf, index, peer_stats);
5991
5992 return QDF_STATUS_E_FAILURE;
5993}
5994
5995/**
5996 * wmi_extract_vdev_stats() - extract vdev stats from event
5997 * @wmi_handle: wmi handle
5998 * @param evt_buf: pointer to event buffer
5999 * @param index: Index into vdev stats
6000 * @param vdev_stats: Pointer to hold vdev stats
6001 *
6002 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6003 */
6004QDF_STATUS wmi_extract_vdev_stats(void *wmi_hdl, void *evt_buf,
6005 uint32_t index, wmi_host_vdev_stats *vdev_stats)
6006{
6007 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6008
6009 if (wmi_handle->ops->extract_vdev_stats)
6010 return wmi_handle->ops->extract_vdev_stats(wmi_handle,
6011 evt_buf, index, vdev_stats);
6012
6013 return QDF_STATUS_E_FAILURE;
6014}
6015
6016/**
6017 * wmi_extract_rtt_hdr() - extract rtt header from event
6018 * @wmi_handle: wmi handle
6019 * @param evt_buf: pointer to event buffer
6020 * @param ev: Pointer to hold rtt header
6021 *
6022 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6023 */
6024QDF_STATUS wmi_extract_rtt_hdr(void *wmi_hdl, void *evt_buf,
6025 wmi_host_rtt_event_hdr *ev)
6026{
6027 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6028
6029 if (wmi_handle->ops->extract_rtt_hdr)
6030 return wmi_handle->ops->extract_rtt_hdr(wmi_handle,
6031 evt_buf, ev);
6032
6033 return QDF_STATUS_E_FAILURE;
6034}
6035
6036/**
6037 * wmi_extract_bcnflt_stats() - extract bcn fault stats from event
6038 * @wmi_handle: wmi handle
6039 * @param evt_buf: pointer to event buffer
6040 * @param index: Index into bcn fault stats
6041 * @param bcnflt_stats: Pointer to hold bcn fault stats
6042 *
6043 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6044 */
6045QDF_STATUS wmi_extract_bcnflt_stats(void *wmi_hdl, void *evt_buf,
6046 uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats)
6047{
6048 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6049
6050 if (wmi_handle->ops->extract_bcnflt_stats)
6051 return wmi_handle->ops->extract_bcnflt_stats(wmi_handle,
6052 evt_buf, index, bcnflt_stats);
6053
6054 return QDF_STATUS_E_FAILURE;
6055}
6056
6057/**
6058 * wmi_extract_rtt_ev() - extract rtt event
6059 * @wmi_handle: wmi handle
6060 * @param evt_buf: Pointer to event buffer
6061 * @param ev: Pointer to hold rtt event
6062 * @param hdump: Pointer to hold hex dump
6063 * @param hdump_len: hex dump length
6064 *
6065 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6066 */
6067QDF_STATUS wmi_extract_rtt_ev(void *wmi_hdl, void *evt_buf,
6068 wmi_host_rtt_meas_event *ev, uint8_t *hdump, uint16_t hdump_len)
6069{
6070 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6071
6072 if (wmi_handle->ops->extract_rtt_ev)
6073 return wmi_handle->ops->extract_rtt_ev(wmi_handle,
6074 evt_buf, ev, hdump, hdump_len);
6075
6076 return QDF_STATUS_E_FAILURE;
6077}
6078
6079/**
6080 * wmi_extract_peer_extd_stats() - extract extended peer stats from event
6081 * @wmi_handle: wmi handle
6082 * @param evt_buf: pointer to event buffer
6083 * @param index: Index into extended peer stats
6084 * @param peer_extd_stats: Pointer to hold extended peer stats
6085 *
6086 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6087 */
6088QDF_STATUS wmi_extract_peer_extd_stats(void *wmi_hdl, void *evt_buf,
6089 uint32_t index, wmi_host_peer_extd_stats *peer_extd_stats)
6090{
6091 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6092
6093 if (wmi_handle->ops->extract_peer_extd_stats)
6094 return wmi_handle->ops->extract_peer_extd_stats(wmi_handle,
6095 evt_buf, index, peer_extd_stats);
6096
6097 return QDF_STATUS_E_FAILURE;
6098}
6099
6100/**
6101 * wmi_extract_rtt_error_report_ev() - extract rtt error report from event
6102 * @wmi_handle: wmi handle
6103 * @param evt_buf: pointer to event buffer
6104 * @param wds_ev: Pointer to hold rtt error report
6105 *
6106 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6107 */
6108QDF_STATUS wmi_extract_rtt_error_report_ev(void *wmi_hdl, void *evt_buf,
6109 wmi_host_rtt_error_report_event *ev)
6110{
6111 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6112
6113 if (wmi_handle->ops->extract_rtt_error_report_ev)
6114 return wmi_handle->ops->extract_rtt_error_report_ev(wmi_handle,
6115 evt_buf, ev);
6116
6117 return QDF_STATUS_E_FAILURE;
6118}
6119
6120/**
6121 * wmi_extract_chan_stats() - extract chan stats from event
6122 * @wmi_handle: wmi handle
6123 * @param evt_buf: pointer to event buffer
6124 * @param index: Index into chan stats
6125 * @param chanstats: Pointer to hold chan stats
6126 *
6127 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6128 */
6129QDF_STATUS wmi_extract_chan_stats(void *wmi_hdl, void *evt_buf,
6130 uint32_t index, wmi_host_chan_stats *chan_stats)
6131{
6132 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6133
6134 if (wmi_handle->ops->extract_chan_stats)
6135 return wmi_handle->ops->extract_chan_stats(wmi_handle,
6136 evt_buf, index, chan_stats);
6137
6138 return QDF_STATUS_E_FAILURE;
6139}
6140
6141/**
6142 * wmi_extract_thermal_stats() - extract thermal stats from event
6143 * @wmi_handle: wmi handle
6144 * @param evt_buf: Pointer to event buffer
6145 * @param temp: Pointer to hold extracted temperature
6146 * @param level: Pointer to hold extracted level
Om Prakash Tripathic569cdb2017-04-19 16:57:31 +05306147 * @param pdev_id: Pointer to hold extracted pdev_id
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306148 *
6149 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6150 */
6151QDF_STATUS wmi_extract_thermal_stats(void *wmi_hdl, void *evt_buf,
Om Prakash Tripathic569cdb2017-04-19 16:57:31 +05306152 uint32_t *temp, uint32_t *level, uint32_t *pdev_id)
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306153{
6154 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6155
6156 if (wmi_handle->ops->extract_thermal_stats)
6157 return wmi_handle->ops->extract_thermal_stats(wmi_handle,
Om Prakash Tripathic569cdb2017-04-19 16:57:31 +05306158 evt_buf, temp, level, pdev_id);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306159
6160 return QDF_STATUS_E_FAILURE;
6161}
6162
6163/**
6164 * wmi_extract_profile_ctx() - extract profile context from event
6165 * @wmi_handle: wmi handle
6166 * @param evt_buf: pointer to event buffer
6167 * @param profile_ctx: Pointer to hold profile context
6168 *
6169 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6170 */
6171QDF_STATUS wmi_extract_profile_ctx(void *wmi_hdl, void *evt_buf,
6172 wmi_host_wlan_profile_ctx_t *profile_ctx)
6173{
6174 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6175
6176 if (wmi_handle->ops->extract_profile_ctx)
6177 return wmi_handle->ops->extract_profile_ctx(wmi_handle,
6178 evt_buf, profile_ctx);
6179
6180 return QDF_STATUS_E_FAILURE;
6181}
6182
6183/**
6184 * wmi_extract_thermal_level_stats() - extract thermal level stats from
6185 * event
6186 * @wmi_handle: wmi handle
6187 * @param evt_buf: pointer to event buffer
6188 * @param idx: Index to level stats
6189 * @param levelcount: Pointer to hold levelcount
6190 * @param dccount: Pointer to hold dccount
6191 *
6192 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6193 */
6194QDF_STATUS wmi_extract_thermal_level_stats(void *wmi_hdl, void *evt_buf,
6195 uint8_t idx, uint32_t *levelcount, uint32_t *dccount)
6196{
6197 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6198
6199 if (wmi_handle->ops->extract_thermal_level_stats)
6200 return wmi_handle->ops->extract_thermal_level_stats(wmi_handle,
6201 evt_buf, idx, levelcount, dccount);
6202
6203 return QDF_STATUS_E_FAILURE;
6204}
6205
6206/**
6207 * wmi_extract_profile_data() - extract profile data from event
6208 * @wmi_handle: wmi handle
6209 * @param evt_buf: pointer to event buffer
Govind Singhfdb1bb32016-05-06 20:20:25 +05306210 * @idx index: index of profile data
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306211 * @param profile_data: Pointer to hold profile data
6212 *
6213 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6214 */
Govind Singhfdb1bb32016-05-06 20:20:25 +05306215QDF_STATUS wmi_extract_profile_data(void *wmi_hdl, void *evt_buf, uint8_t idx,
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306216 wmi_host_wlan_profile_t *profile_data)
6217{
6218 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6219
6220 if (wmi_handle->ops->extract_profile_data)
6221 return wmi_handle->ops->extract_profile_data(wmi_handle,
Govind Singhfdb1bb32016-05-06 20:20:25 +05306222 evt_buf, idx, profile_data);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306223
6224 return QDF_STATUS_E_FAILURE;
6225}
6226
6227/**
6228 * wmi_extract_chan_info_event() - extract chan information from event
6229 * @wmi_handle: wmi handle
6230 * @param evt_buf: pointer to event buffer
6231 * @param chan_info: Pointer to hold chan information
6232 *
6233 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6234 */
6235QDF_STATUS wmi_extract_chan_info_event(void *wmi_hdl, void *evt_buf,
6236 wmi_host_chan_info_event *chan_info)
6237{
6238 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6239
6240 if (wmi_handle->ops->extract_chan_info_event)
6241 return wmi_handle->ops->extract_chan_info_event(wmi_handle,
6242 evt_buf, chan_info);
6243
6244 return QDF_STATUS_E_FAILURE;
6245}
6246
6247/**
6248 * wmi_extract_channel_hopping_event() - extract channel hopping param
6249 * from event
6250 * @wmi_handle: wmi handle
6251 * @param evt_buf: pointer to event buffer
6252 * @param ch_hopping: Pointer to hold channel hopping param
6253 *
6254 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6255 */
6256QDF_STATUS wmi_extract_channel_hopping_event(void *wmi_hdl, void *evt_buf,
6257 wmi_host_pdev_channel_hopping_event *ch_hopping)
6258{
6259 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6260
6261 if (wmi->ops->extract_channel_hopping_event)
6262 return wmi->ops->extract_channel_hopping_event(wmi,
6263 evt_buf, ch_hopping);
6264
6265 return QDF_STATUS_E_FAILURE;
6266}
6267
6268/**
6269 * wmi_extract_bss_chan_info_event() - extract bss channel information
6270 * from event
6271 * @wmi_handle: wmi handle
6272 * @param evt_buf: pointer to event buffer
6273 * @param bss_chan_info: Pointer to hold bss channel information
6274 *
6275 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6276 */
6277QDF_STATUS wmi_extract_bss_chan_info_event(void *wmi_hdl, void *evt_buf,
6278 wmi_host_pdev_bss_chan_info_event *bss_chan_info)
6279{
6280 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6281
6282 if (wmi_handle->ops->extract_bss_chan_info_event)
6283 return wmi_handle->ops->extract_bss_chan_info_event(wmi_handle,
6284 evt_buf, bss_chan_info);
6285
6286 return QDF_STATUS_E_FAILURE;
6287}
6288
6289/**
6290 * wmi_extract_inst_rssi_stats_event() - extract inst rssi stats from event
6291 * @wmi_handle: wmi handle
6292 * @param evt_buf: pointer to event buffer
6293 * @param inst_rssi_resp: Pointer to hold inst rssi response
6294 *
6295 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6296 */
6297QDF_STATUS wmi_extract_inst_rssi_stats_event(void *wmi_hdl, void *evt_buf,
6298 wmi_host_inst_stats_resp *inst_rssi_resp)
6299{
6300 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6301
6302 if (wmi->ops->extract_inst_rssi_stats_event)
6303 return wmi->ops->extract_inst_rssi_stats_event(wmi,
6304 evt_buf, inst_rssi_resp);
6305
6306 return QDF_STATUS_E_FAILURE;
6307}
6308
6309/**
6310 * wmi_extract_tx_data_traffic_ctrl_ev() - extract tx data traffic control
6311 * from event
6312 * @wmi_handle: wmi handle
6313 * @param evt_buf: pointer to event buffer
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306314 * @param ev: Pointer to hold data traffic control
6315 *
6316 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6317 */
6318QDF_STATUS wmi_extract_tx_data_traffic_ctrl_ev(void *wmi_hdl, void *evt_buf,
6319 wmi_host_tx_data_traffic_ctrl_event *ev)
6320{
6321 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6322
6323 if (wmi->ops->extract_tx_data_traffic_ctrl_ev)
6324 return wmi->ops->extract_tx_data_traffic_ctrl_ev(wmi,
6325 evt_buf, ev);
6326
6327 return QDF_STATUS_E_FAILURE;
6328}
6329
6330/**
Sathish Kumar68789382016-11-14 17:44:29 +05306331 * wmi_extract_atf_peer_stats_ev() - extract atf peer stats
6332 * from event
6333 * @wmi_handle: wmi handle
6334 * @param evt_buf: pointer to event buffer
6335 * @param ev: Pointer to hold atf peer stats
6336 *
6337 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6338 */
6339QDF_STATUS wmi_extract_atf_peer_stats_ev(void *wmi_hdl, void *evt_buf,
6340 wmi_host_atf_peer_stats_event *ev)
6341{
6342 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6343
6344 if (wmi->ops->extract_atf_peer_stats_ev)
6345 return wmi->ops->extract_atf_peer_stats_ev(wmi,
6346 evt_buf, ev);
6347
6348 return QDF_STATUS_E_FAILURE;
6349}
6350
6351/**
6352 * wmi_extract_atf_token_info_ev() - extract atf token info
6353 * from event
6354 * @wmi_handle: wmi handle
6355 * @param evt_buf: pointer to event buffer
6356 * @param idx: Index indicating the peer number
6357 * @param ev: Pointer to hold atf token info
6358 *
6359 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6360 */
6361QDF_STATUS wmi_extract_atf_token_info_ev(void *wmi_hdl, void *evt_buf,
6362 uint8_t idx, wmi_host_atf_peer_stats_info *ev)
6363{
6364 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6365
6366 if (wmi->ops->extract_atf_token_info_ev)
6367 return wmi->ops->extract_atf_token_info_ev(wmi,
6368 evt_buf, idx, ev);
6369
6370 return QDF_STATUS_E_FAILURE;
6371}
6372
6373/**
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306374 * wmi_extract_vdev_extd_stats() - extract extended vdev stats from event
6375 * @wmi_handle: wmi handle
6376 * @param evt_buf: pointer to event buffer
6377 * @param index: Index into extended vdev stats
6378 * @param vdev_extd_stats: Pointer to hold extended vdev stats
6379 *
6380 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6381 */
6382QDF_STATUS wmi_extract_vdev_extd_stats(void *wmi_hdl, void *evt_buf,
6383 uint32_t index, wmi_host_vdev_extd_stats *vdev_extd_stats)
6384{
6385 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6386
6387 if (wmi_handle->ops->extract_vdev_extd_stats)
6388 return wmi_handle->ops->extract_vdev_extd_stats(wmi_handle,
6389 evt_buf, index, vdev_extd_stats);
Gupta, Kapil2e685982016-04-25 19:14:19 +05306390 return QDF_STATUS_E_FAILURE;
6391}
6392
6393/**
6394 * wmi_unified_send_adapt_dwelltime_params_cmd() - send wmi cmd of
6395 * adaptive dwelltime configuration params
6396 * @wma_handle: wma handler
6397 * @dwelltime_params: pointer to dwelltime_params
6398 *
6399 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
6400 */
6401QDF_STATUS wmi_unified_send_adapt_dwelltime_params_cmd(void *wmi_hdl,
6402 struct wmi_adaptive_dwelltime_params *dwelltime_params)
6403{
6404 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6405
6406 if (wmi_handle->ops->send_adapt_dwelltime_params_cmd)
6407 return wmi_handle->ops->
6408 send_adapt_dwelltime_params_cmd(wmi_handle,
6409 dwelltime_params);
Govind Singhe7d9f3e2016-04-15 13:58:27 +05306410
6411 return QDF_STATUS_E_FAILURE;
6412}
Govind Singhbca3b1b2016-05-02 17:59:24 +05306413
6414/**
6415 * wmi_unified_send_power_dbg_cmd() - send power debug commands
6416 * @wmi_handle: wmi handle
6417 * @param: wmi power debug parameter
6418 *
6419 * Send WMI_POWER_DEBUG_CMDID parameters to fw.
6420 *
6421 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6422 */
6423QDF_STATUS wmi_unified_send_power_dbg_cmd(void *wmi_hdl,
6424 struct wmi_power_dbg_params *param)
6425{
6426 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6427
6428 if (wmi_handle->ops->send_power_dbg_cmd)
6429 return wmi_handle->ops->send_power_dbg_cmd(wmi_handle,
6430 param);
6431
6432 return QDF_STATUS_E_FAILURE;
6433}
Padma, Santhosh Kumar8394bae2016-09-11 18:24:59 +05306434
6435/**
Sathish Kumar45e991b2017-02-27 10:35:40 +05306436 * wmi_unified_send_multiple_vdev_restart_req_cmd() - send multiple vdev restart
6437 * @wmi_handle: wmi handle
6438 * @param: multiple vdev restart parameter
6439 *
6440 * Send WMI_PDEV_MULTIPLE_VDEV_RESTART_REQUEST_CMDID parameters to fw.
6441 *
6442 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6443 */
6444QDF_STATUS wmi_unified_send_multiple_vdev_restart_req_cmd(void *wmi_hdl,
6445 struct multiple_vdev_restart_params *param)
6446{
6447 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6448
6449 if (wmi_handle->ops->send_multiple_vdev_restart_req_cmd)
6450 return wmi_handle->ops->send_multiple_vdev_restart_req_cmd(
6451 wmi_handle,
6452 param);
6453
6454 return QDF_STATUS_E_FAILURE;
6455}
6456
6457/**
Manikandan Mohan31a13e22016-12-13 13:14:06 -08006458 * wmi_unified_send_sar_limit_cmd() - send sar limit cmd to fw
6459 * @wmi_hdl: wmi handle
6460 * @params: sar limit command params
6461 *
6462 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6463 */
6464QDF_STATUS wmi_unified_send_sar_limit_cmd(void *wmi_hdl,
6465 struct sar_limit_cmd_params *params)
6466{
6467 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6468
6469 if (wmi_handle->ops->send_sar_limit_cmd)
6470 return wmi_handle->ops->send_sar_limit_cmd(
6471 wmi_handle,
6472 params);
6473 return QDF_STATUS_E_FAILURE;
6474}
6475
6476/**
Padma, Santhosh Kumar8394bae2016-09-11 18:24:59 +05306477 * wmi_unified_encrypt_decrypt_send_cmd() - send encryptdecrypt cmd to fw
6478 * @wmi_hdl: wmi handle
6479 * @params: encrypt/decrypt params
6480 *
6481 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6482 */
6483QDF_STATUS wmi_unified_encrypt_decrypt_send_cmd(void *wmi_hdl,
6484 struct encrypt_decrypt_req_params *params)
6485{
6486 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6487
6488 if (wmi_handle->ops->send_encrypt_decrypt_send_cmd)
6489 return wmi_handle->ops->send_encrypt_decrypt_send_cmd(
6490 wmi_handle,
6491 params);
Sathish Kumar68789382016-11-14 17:44:29 +05306492 return QDF_STATUS_E_FAILURE;
6493}
6494
6495/*
6496 * wmi_unified_send_btcoex_wlan_priority_cmd() - send btcoex priority commands
6497 * @wmi_handle: wmi handle
Sathish Kumar699f6b52016-11-10 15:30:22 +05306498 * @param : wmi btcoex cfg params
Sathish Kumar68789382016-11-14 17:44:29 +05306499 *
6500 * Send WMI_BTCOEX_CFG_CMDID parameters to fw.
6501 *
6502 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6503 */
6504QDF_STATUS wmi_unified_send_btcoex_wlan_priority_cmd(void *wmi_hdl,
Sathish Kumar699f6b52016-11-10 15:30:22 +05306505 struct btcoex_cfg_params *param)
Sathish Kumar68789382016-11-14 17:44:29 +05306506{
6507 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6508
6509 if (wmi->ops->send_btcoex_wlan_priority_cmd)
6510 return wmi->ops->send_btcoex_wlan_priority_cmd(wmi,
Sathish Kumar699f6b52016-11-10 15:30:22 +05306511 param);
6512
6513 return QDF_STATUS_E_FAILURE;
6514}
6515/**
6516 * wmi_unified_send_btcoex_duty_cycle_cmd() - send btcoex duty cycle commands
6517 * @wmi_handle: wmi handle
6518 * @param: wmi btcoex cfg params
6519 *
6520 * Send WMI_BTCOEX_CFG_CMDID parameters to fw.
6521 *
6522 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6523 */
6524QDF_STATUS wmi_unified_send_btcoex_duty_cycle_cmd(void *wmi_hdl,
6525 struct btcoex_cfg_params *param)
6526{
6527 wmi_unified_t wmi = (wmi_unified_t) wmi_hdl;
6528
6529 if (wmi->ops->send_btcoex_duty_cycle_cmd)
6530 return wmi->ops->send_btcoex_duty_cycle_cmd(wmi,
6531 param);
Padma, Santhosh Kumar8394bae2016-09-11 18:24:59 +05306532
6533 return QDF_STATUS_E_FAILURE;
6534}
Kiran Venkatappa06520822016-08-10 23:55:40 +05306535
6536/*
6537 * wmi_extract_service_ready_ext() - extract extended service ready
6538 * @wmi_handle: wmi handle
6539 * @param: wmi power debug parameter
6540 *
6541 *
6542 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6543 */
6544QDF_STATUS wmi_extract_service_ready_ext(void *wmi_hdl, uint8_t *evt_buf,
Rajeev Kumar037799b2017-02-03 00:39:49 -08006545 struct wlan_psoc_host_service_ext_param *param)
Kiran Venkatappa06520822016-08-10 23:55:40 +05306546{
6547 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6548
6549 if (wmi_handle->ops->extract_service_ready_ext)
6550 return wmi_handle->ops->extract_service_ready_ext(wmi_handle,
6551 evt_buf, param);
6552
6553 return QDF_STATUS_E_FAILURE;
6554}
6555
6556/**
6557 * wmi_extract_hw_mode_cap_service_ready_ext() -
6558 * extract HW mode cap from service ready event
6559 * @wmi_handle: wmi handle
6560 * @param evt_buf: pointer to event buffer
6561 * @param param: Pointer to hold evt buf
6562 * @param hw_mode_idx: hw mode idx should be less than num_mode
6563 *
6564 * Return: QDF_STATUS_SUCCESS for success or error code
6565 */
6566QDF_STATUS wmi_extract_hw_mode_cap_service_ready_ext(
6567 void *wmi_hdl,
6568 uint8_t *evt_buf, uint8_t hw_mode_idx,
Rajeev Kumar037799b2017-02-03 00:39:49 -08006569 struct wlan_psoc_host_hw_mode_caps *param)
Kiran Venkatappa06520822016-08-10 23:55:40 +05306570{
6571 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6572
6573 if (wmi_handle->ops->extract_hw_mode_cap_service_ready_ext)
6574 return wmi_handle->ops->extract_hw_mode_cap_service_ready_ext(
6575 wmi_handle,
6576 evt_buf, hw_mode_idx, param);
6577
6578 return QDF_STATUS_E_FAILURE;
6579}
6580/**
6581 * wmi_extract_mac_phy_cap_service_ready_ext() -
6582 * extract MAC phy cap from service ready event
6583 * @wmi_handle: wmi handle
6584 * @param evt_buf: pointer to event buffer
Kiran Venkatappa2b1b0d22016-12-26 15:38:06 +05306585 * @param hw_mode_id: hw mode id of hw_mode_caps
6586 * @param phy_id: phy_id within hw_mode_cap
6587 * @param param: pointer to mac phy caps structure to hold the values from event
Kiran Venkatappa06520822016-08-10 23:55:40 +05306588 *
6589 * Return: QDF_STATUS_SUCCESS for success or error code
6590 */
6591QDF_STATUS wmi_extract_mac_phy_cap_service_ready_ext(
6592 void *wmi_hdl,
Kiran Venkatappa2b1b0d22016-12-26 15:38:06 +05306593 uint8_t *evt_buf,
6594 uint8_t hw_mode_id,
6595 uint8_t phy_id,
Rajeev Kumar037799b2017-02-03 00:39:49 -08006596 struct wlan_psoc_host_mac_phy_caps *param)
Kiran Venkatappa06520822016-08-10 23:55:40 +05306597{
6598 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6599
6600 if (wmi_handle->ops->extract_mac_phy_cap_service_ready_ext)
6601 return wmi_handle->ops->extract_mac_phy_cap_service_ready_ext(
6602 wmi_handle,
Kiran Venkatappa2b1b0d22016-12-26 15:38:06 +05306603 evt_buf, hw_mode_id, phy_id, param);
Kiran Venkatappa06520822016-08-10 23:55:40 +05306604
6605 return QDF_STATUS_E_FAILURE;
6606}
Vijay Pamidipatid814b8d2017-01-17 12:53:05 +05306607
Kiran Venkatappa06520822016-08-10 23:55:40 +05306608/**
6609 * wmi_extract_reg_cap_service_ready_ext() -
6610 * extract REG cap from service ready event
6611 * @wmi_handle: wmi handle
6612 * @param evt_buf: pointer to event buffer
6613 * @param param: Pointer to hold evt buf
6614 * @param phy_idx: phy idx should be less than num_mode
6615 *
6616 * Return: QDF_STATUS_SUCCESS for success or error code
6617 */
6618QDF_STATUS wmi_extract_reg_cap_service_ready_ext(
6619 void *wmi_hdl,
6620 uint8_t *evt_buf, uint8_t phy_idx,
Rajeev Kumar037799b2017-02-03 00:39:49 -08006621 struct wlan_psoc_host_hal_reg_capabilities_ext *param)
Kiran Venkatappa06520822016-08-10 23:55:40 +05306622{
6623 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6624
6625 if (wmi_handle->ops->extract_reg_cap_service_ready_ext)
6626 return wmi_handle->ops->extract_reg_cap_service_ready_ext(
6627 wmi_handle,
6628 evt_buf, phy_idx, param);
6629
6630 return QDF_STATUS_E_FAILURE;
6631}
Sathish Kumar27ee0a32017-01-24 17:51:26 +05306632
6633/**
6634 * wmi_extract_pdev_utf_event() -
6635 * extract UTF data from pdev utf event
6636 * @wmi_handle: wmi handle
6637 * @param evt_buf: pointer to event buffer
6638 * @param param: Pointer to hold evt buf
6639 *
6640 * Return: QDF_STATUS_SUCCESS for success or error code
6641 */
6642QDF_STATUS wmi_extract_pdev_utf_event(void *wmi_hdl,
6643 uint8_t *evt_buf,
6644 struct wmi_host_pdev_utf_event *param)
6645{
6646 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6647
6648 if (wmi_handle->ops->extract_pdev_utf_event)
6649 return wmi_handle->ops->extract_pdev_utf_event(
6650 wmi_handle,
6651 evt_buf, param);
6652
6653 return QDF_STATUS_E_FAILURE;
6654}
Vijay Pamidipatid814b8d2017-01-17 12:53:05 +05306655
6656/**
Kiran Venkatappa316357d2017-02-28 14:19:17 +05306657 * wmi_extract_pdev_qvit_event() -
6658 * extract UTF data from pdev qvit event
6659 * @wmi_handle: wmi handle
6660 * @param evt_buf: pointer to event buffer
6661 * @param param: Pointer to hold evt buf
6662 *
6663 * Return: QDF_STATUS_SUCCESS for success or error code
6664 */
6665QDF_STATUS wmi_extract_pdev_qvit_event(void *wmi_hdl,
6666 uint8_t *evt_buf,
6667 struct wmi_host_pdev_qvit_event *param)
6668{
6669 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6670
6671 if (wmi_handle->ops->extract_pdev_qvit_event)
6672 return wmi_handle->ops->extract_pdev_qvit_event(
6673 wmi_handle,
6674 evt_buf, param);
6675
6676 return QDF_STATUS_E_FAILURE;
6677}
6678
6679/**
Sathish Kumar58a9fb92017-01-19 14:57:37 +05306680 * wmi_unified_send_coex_ver_cfg_cmd() - send coex ver cfg command
6681 * @wmi_handle: wmi handle
6682 * @param: wmi coex ver cfg params
6683 *
6684 * Send WMI_COEX_VERSION_CFG_CMID parameters to fw.
6685 *
6686 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6687 */
6688QDF_STATUS wmi_unified_send_coex_ver_cfg_cmd(void *wmi_hdl,
6689 coex_ver_cfg_t *param)
6690{
6691 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6692
6693 if (wmi_handle->ops->send_coex_ver_cfg_cmd)
6694 return wmi_handle->ops->send_coex_ver_cfg_cmd(wmi_handle,
6695 param);
6696
6697 return QDF_STATUS_E_FAILURE;
6698}
6699
6700/**
Sathish Kumar80f4f382017-04-24 11:36:00 +05306701 * wmi_unified_send_coex_config_cmd() - send coex ver cfg command
6702 * @wmi_handle: wmi handle
6703 * @param: wmi coex cfg cmd params
6704 *
6705 * Send WMI_COEX_CFG_CMD parameters to fw.
6706 *
6707 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6708 */
6709QDF_STATUS wmi_unified_send_coex_config_cmd(void *wmi_hdl,
6710 struct coex_config_params *param)
6711{
6712 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6713
6714 if (wmi_handle->ops->send_coex_config_cmd)
6715 return wmi_handle->ops->send_coex_config_cmd(wmi_handle,
6716 param);
6717
6718 return QDF_STATUS_E_FAILURE;
6719}
6720
Rajeev Kumar Sirasanagandlaab4275d2016-11-22 21:28:54 +05306721QDF_STATUS wmi_unified_send_request_get_rcpi_cmd(void *wmi_hdl,
6722 struct rcpi_req *get_rcpi_param)
6723{
6724 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6725
6726 if (wmi_handle->ops->send_get_rcpi_cmd)
6727 return wmi_handle->ops->send_get_rcpi_cmd(wmi_handle,
6728 get_rcpi_param);
6729
6730 return QDF_STATUS_E_FAILURE;
6731}
6732
6733QDF_STATUS wmi_extract_rcpi_response_event(void *wmi_hdl, void *evt_buf,
6734 struct rcpi_res *res)
6735{
6736 wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl;
6737 struct wmi_ops *ops = wmi_handle->ops;
6738
6739 if (ops->extract_rcpi_response_event)
6740 return ops->extract_rcpi_response_event(wmi_handle, evt_buf,
6741 res);
6742
6743 return QDF_STATUS_E_FAILURE;
6744}
6745
Sathish Kumar80f4f382017-04-24 11:36:00 +05306746/**
Vijay Pamidipatid814b8d2017-01-17 12:53:05 +05306747 * wmi_extract_peer_delete_response_event() -
6748 * extract vdev id and peer mac addresse from peer delete response event
6749 * @wmi_handle: wmi handle
6750 * @param evt_buf: pointer to event buffer
6751 * @param param: Pointer to hold evt buf
6752 *
6753 * Return: QDF_STATUS_SUCCESS for success or error code
6754 */
6755QDF_STATUS wmi_extract_peer_delete_response_event(
6756 void *wmi_hdl,
6757 uint8_t *evt_buf,
6758 struct wmi_host_peer_delete_response_event *param)
6759{
6760 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6761
6762 if (wmi_handle->ops->extract_peer_delete_response_event)
6763 return wmi_handle->ops->extract_peer_delete_response_event(
6764 wmi_handle,
6765 evt_buf, param);
6766
6767 return QDF_STATUS_E_FAILURE;
6768}
Arif Hussainf00be1d2017-01-07 18:21:55 -08006769
6770QDF_STATUS
6771wmi_unified_dfs_phyerr_offload_en_cmd(void *wmi_hdl,
6772 uint32_t pdev_id)
6773{
6774 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6775
6776 if (wmi_handle->ops->send_dfs_phyerr_offload_en_cmd)
6777 return wmi_handle->ops->send_dfs_phyerr_offload_en_cmd(
6778 wmi_handle, pdev_id);
6779
6780 return QDF_STATUS_E_FAILURE;
6781}
6782
6783QDF_STATUS
6784wmi_unified_dfs_phyerr_offload_dis_cmd(void *wmi_hdl,
6785 uint32_t pdev_id)
6786{
6787 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6788
6789 if (wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd)
6790 return wmi_handle->ops->send_dfs_phyerr_offload_dis_cmd(
6791 wmi_handle, pdev_id);
6792
6793 return QDF_STATUS_E_FAILURE;
6794}
Vikram Kandukuri45fc8582017-03-07 18:40:13 +05306795
6796/*
6797 * wmi_extract_chainmask_tables_tlv() - extract chain mask tables
6798 * @wmi_handle: wmi handle
6799 * @evt_buf: pointer to event buffer.
6800 * @chainmask_table: pointer to struct wlan_psoc_host_chainmask_table
6801 *
6802 *
6803 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
6804 */
6805QDF_STATUS wmi_extract_chainmask_tables(void *wmi_hdl, uint8_t *evt_buf,
6806 struct wlan_psoc_host_chainmask_table *chainmask_table)
6807{
6808 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6809
6810 if (wmi_handle->ops->extract_chainmask_tables)
6811 return wmi_handle->ops->extract_chainmask_tables(wmi_handle,
6812 evt_buf, chainmask_table);
6813
6814 return QDF_STATUS_E_FAILURE;
6815}
Kiran Kumar Lokeredaf91e32017-04-24 00:56:03 -07006816/**
6817 * wmi_unified_set_country_cmd_send() - WMI set country function
6818 * @param wmi_handle : handle to WMI.
6819 * @param param : pointer to hold set country cmd parameter
6820 *
6821 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
6822 */
6823QDF_STATUS wmi_unified_set_country_cmd_send(void *wmi_hdl,
6824 struct set_country *param)
6825{
6826 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6827
6828 if (wmi_handle->ops->send_set_country_cmd)
6829 return wmi_handle->ops->send_set_country_cmd(wmi_handle,
6830 param);
6831
6832 return QDF_STATUS_E_FAILURE;
6833}
6834
Nitesh Shah52323d02017-05-22 15:49:00 +05306835/**
6836 * wmi_unified_send_dbs_scan_sel_params_cmd() - send wmi cmd of
6837 * DBS scan selection configuration params
6838 * @wma_handle: wma handler
6839 * @dbs_scan_params: pointer to wmi_dbs_scan_sel_params
6840 *
6841 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code for failure
6842 */
6843QDF_STATUS wmi_unified_send_dbs_scan_sel_params_cmd(void *wmi_hdl,
6844 struct wmi_dbs_scan_sel_params *dbs_scan_params)
6845{
6846 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6847
6848 if (wmi_handle->ops->send_dbs_scan_sel_params_cmd)
6849 return wmi_handle->ops->
6850 send_dbs_scan_sel_params_cmd(wmi_handle,
6851 dbs_scan_params);
6852
6853 return QDF_STATUS_E_FAILURE;
6854}
Ganesh Kondabattini40252f52017-07-10 11:54:11 +05306855
6856/**
6857 * wmi_unified_send_limit_off_chan_cmd() - send wmi cmd of limit off channel
6858 * configuration params
6859 * @wmi_hdl: wmi handler
6860 * @limit_off_chan_param: pointer to wmi_limit_off_chan_param
6861 *
6862 * Return: QDF_STATUS_SUCCESS on success and QDF failure reason code on failure
6863 */
6864QDF_STATUS wmi_unified_send_limit_off_chan_cmd(void *wmi_hdl,
6865 struct wmi_limit_off_chan_param *limit_off_chan_param)
6866{
6867 wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
6868
6869 if (wmi_handle->ops->send_limit_off_chan_cmd)
6870 return wmi_handle->ops->send_limit_off_chan_cmd(wmi_handle,
6871 limit_off_chan_param);
6872
6873 return QDF_STATUS_E_FAILURE;
6874}