1 /*
2 * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved.
3 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for
6 * any purpose with or without fee is hereby granted, provided that the
7 * above copyright notice and this permission notice appear in all
8 * copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17 * PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 /**
21 * DOC: wma_main.c
22 *
23 * This file contains wma initialization and FW exchange
24 * related functions.
25 */
26
27 /* Header files */
28
29 #include "wma.h"
30 #include "wma_api.h"
31 #include "cds_api.h"
32 #include "wmi_unified_api.h"
33 #include "wlan_qct_sys.h"
34 #include "wni_api.h"
35 #include "ani_global.h"
36 #include "wmi_unified.h"
37 #include "wni_cfg.h"
38 #if defined(CONFIG_HL_SUPPORT)
39 #include "wlan_tgt_def_config_hl.h"
40 #else
41 #include "wlan_tgt_def_config.h"
42 #endif
43 #include "qdf_nbuf.h"
44 #include "qdf_types.h"
45 #include "qdf_mem.h"
46 #include "wma_types.h"
47 #include "lim_api.h"
48 #include "lim_session_utils.h"
49 #include "wlan_cm_tgt_if_tx_api.h"
50 #include "wlan_cm_roam_api.h"
51
52 #include "cds_utils.h"
53
54 #if !defined(REMOVE_PKT_LOG)
55 #include "pktlog_ac.h"
56 #endif /* REMOVE_PKT_LOG */
57
58 #include "dbglog_host.h"
59 #include "csr_api.h"
60 #include "ol_fw.h"
61
62 #include "wma_internal.h"
63
64 #include "wma_ocb.h"
65 #include "wlan_policy_mgr_api.h"
66 #include "cdp_txrx_cfg.h"
67 #include "cdp_txrx_flow_ctrl_legacy.h"
68 #include "cdp_txrx_flow_ctrl_v2.h"
69 #include "cdp_txrx_ipa.h"
70 #include "cdp_txrx_misc.h"
71 #include "wma_fips_api.h"
72 #include "wma_nan_datapath.h"
73 #include "wma_fw_state.h"
74 #include "wlan_lmac_if_def.h"
75 #include "wlan_lmac_if_api.h"
76 #include "target_if.h"
77 #include "target_if_scan.h"
78 #include "wlan_global_lmac_if_api.h"
79 #include "target_if_pmo.h"
80 #include "wma_he.h"
81 #include "wlan_pmo_obj_mgmt_api.h"
82
83 #include "wlan_reg_tgt_api.h"
84 #include "wlan_reg_services_api.h"
85 #include <cdp_txrx_handle.h>
86 #include <wlan_pmo_ucfg_api.h>
87 #include "wifi_pos_api.h"
88 #include "hif_main.h"
89 #ifdef WLAN_CONV_SPECTRAL_ENABLE
90 #include <target_if_spectral.h>
91 #include <wlan_spectral_utils_api.h>
92 #endif
93 #include "init_event_handler.h"
94 #include "init_deinit_lmac.h"
95 #include "target_if_green_ap.h"
96 #include "service_ready_param.h"
97 #include "wlan_cp_stats_mc_ucfg_api.h"
98 #include "cfg_nan_api.h"
99 #include "wlan_mlme_api.h"
100 #include "wlan_mlme_ucfg_api.h"
101 #include "cfg_ucfg_api.h"
102 #include "init_cmd_api.h"
103 #include "nan_ucfg_api.h"
104 #include "wma_coex.h"
105 #include "wma_twt.h"
106 #include "target_if_vdev_mgr_rx_ops.h"
107 #include "wlan_tdls_cfg_api.h"
108 #include "wlan_policy_mgr_i.h"
109 #include "target_if_psoc_timer_tx_ops.h"
110 #include <ftm_time_sync_ucfg_api.h>
111 #include "wlan_ipa_ucfg_api.h"
112 #include "wma_eht.h"
113
114 #ifdef DIRECT_BUF_RX_ENABLE
115 #include <target_if_direct_buf_rx_api.h>
116 #endif
117
118 #include "wlan_pkt_capture_ucfg_api.h"
119 #include "target_if_cm_roam_event.h"
120 #include "wlan_fwol_ucfg_api.h"
121 #include "wlan_tdls_api.h"
122 #include "wlan_twt_cfg_ext_api.h"
123 #include "wlan_mlo_mgr_sta.h"
124 #include "wlan_dp_api.h"
125 #include "wlan_dp_ucfg_api.h"
126
127 #define WMA_LOG_COMPLETION_TIMER 500 /* 500 msecs */
128 #define WMI_TLV_HEADROOM 128
129
130 static uint32_t g_fw_wlan_feat_caps;
131 /**
132 * wma_get_fw_wlan_feat_caps() - get fw feature capability
133 * @feature: feature enum value
134 *
135 * Return: true/false
136 */
wma_get_fw_wlan_feat_caps(enum cap_bitmap feature)137 bool wma_get_fw_wlan_feat_caps(enum cap_bitmap feature)
138 {
139 return (g_fw_wlan_feat_caps & (1 << feature)) ? true : false;
140 }
141
142 /**
143 * wma_set_fw_wlan_feat_caps() - set fw feature capability
144 * @feature: feature enum value
145 *
146 * Return: None
147 */
wma_set_fw_wlan_feat_caps(enum cap_bitmap feature)148 void wma_set_fw_wlan_feat_caps(enum cap_bitmap feature)
149 {
150 g_fw_wlan_feat_caps |= (1 << feature);
151 }
152
153 /**
154 * wma_service_ready_ext_evt_timeout() - Service ready extended event timeout
155 * @data: Timeout handler data
156 *
157 * This function is called when the FW fails to send WMI_SERVICE_READY_EXT_EVENT
158 * message
159 *
160 * Return: None
161 */
wma_service_ready_ext_evt_timeout(void * data)162 static void wma_service_ready_ext_evt_timeout(void *data)
163 {
164 wma_alert("Timeout waiting for WMI_SERVICE_READY_EXT_EVENT");
165
166 /* Assert here. Panic is being called in insmod thread */
167 QDF_ASSERT(0);
168 }
169
170 /**
171 * wma_get_ini_handle() - API to get WMA ini info handle
172 * @wma: WMA Handle
173 *
174 * Returns the pointer to WMA ini structure.
175 * Return: struct wma_ini_config
176 */
wma_get_ini_handle(tp_wma_handle wma)177 struct wma_ini_config *wma_get_ini_handle(tp_wma_handle wma)
178 {
179 if (wma_validate_handle(wma))
180 return NULL;
181
182 return &wma->ini_config;
183 }
184
__wma_validate_handle(tp_wma_handle wma_handle,const char * func)185 int __wma_validate_handle(tp_wma_handle wma_handle, const char *func)
186 {
187 if (!wma_handle) {
188 wma_err("Invalid WMA handle (via %s)", func);
189 return -EINVAL;
190 }
191
192 return 0;
193 }
194
195 #define MAX_SUPPORTED_PEERS_REV1_1 14
196 #define MAX_SUPPORTED_PEERS_REV1_3 32
197 #ifdef WLAN_MAX_CLIENTS_ALLOWED
198 #define MAX_SUPPORTED_PEERS WLAN_MAX_CLIENTS_ALLOWED
199 #else
200 #define MAX_SUPPORTED_PEERS 32
201 #endif
202 #define MIN_NO_OF_PEERS 1
203
204 /**
205 * wma_get_number_of_peers_supported - API to query for number of peers
206 * supported
207 * @wma: WMA Handle
208 *
209 * Return: Max Number of Peers Supported
210 */
wma_get_number_of_peers_supported(tp_wma_handle wma)211 static uint8_t wma_get_number_of_peers_supported(tp_wma_handle wma)
212 {
213 struct wma_ini_config *cfg = wma_get_ini_handle(wma);
214 uint8_t max_no_of_peers = cfg ? cfg->max_no_of_peers : MIN_NO_OF_PEERS;
215
216 return max_no_of_peers;
217 }
218
219 /**
220 * wma_get_number_of_tids_supported - API to query for number of tids supported
221 * @no_of_peers_supported: Number of peer supported
222 * @no_vdevs: Number of vdevs
223 *
224 * Return: Max number of tids supported
225 */
226 #if defined(CONFIG_HL_SUPPORT)
wma_get_number_of_tids_supported(uint8_t no_of_peers_supported,uint8_t num_vdevs)227 static uint32_t wma_get_number_of_tids_supported(uint8_t no_of_peers_supported,
228 uint8_t num_vdevs)
229 {
230 return 4 * no_of_peers_supported;
231 }
232 #else
wma_get_number_of_tids_supported(uint8_t no_of_peers_supported,uint8_t num_vdevs)233 static uint32_t wma_get_number_of_tids_supported(uint8_t no_of_peers_supported,
234 uint8_t num_vdevs)
235 {
236 return 2 * (no_of_peers_supported + num_vdevs + 2);
237 }
238 #endif
239
240 #if (defined(IPA_DISABLE_OVERRIDE)) && (!defined(IPA_OFFLOAD))
wma_set_ipa_disable_config(target_resource_config * tgt_cfg)241 static void wma_set_ipa_disable_config(
242 target_resource_config *tgt_cfg)
243 {
244 tgt_cfg->ipa_disable = true;
245 }
246 #else
wma_set_ipa_disable_config(target_resource_config * tgt_cfg)247 static void wma_set_ipa_disable_config(
248 target_resource_config *tgt_cfg)
249 {
250 tgt_cfg->ipa_disable = ucfg_ipa_is_enabled() ? false : true;
251 }
252 #endif
253
254 #ifndef NUM_OF_ADDITIONAL_FW_PEERS
255 #define NUM_OF_ADDITIONAL_FW_PEERS 2
256 #endif
257
258 /**
259 * wma_update_num_peers_tids() - Update num_peers and tids based on num_vdevs
260 * @wma_handle: wma handle
261 * @tgt_cfg: Resource config given to target
262 *
263 * Get num_vdevs from tgt_cfg and update num_peers and tids based on it.
264 *
265 * Return: none
266 */
wma_update_num_peers_tids(t_wma_handle * wma_handle,target_resource_config * tgt_cfg)267 static void wma_update_num_peers_tids(t_wma_handle *wma_handle,
268 target_resource_config *tgt_cfg)
269
270 {
271 uint8_t no_of_peers_supported;
272
273 no_of_peers_supported = wma_get_number_of_peers_supported(wma_handle);
274
275 tgt_cfg->num_peers = no_of_peers_supported + tgt_cfg->num_vdevs +
276 NUM_OF_ADDITIONAL_FW_PEERS;
277 /* The current firmware implementation requires the number of
278 * offload peers should be (number of vdevs + 1).
279 */
280 tgt_cfg->num_tids =
281 wma_get_number_of_tids_supported(no_of_peers_supported,
282 tgt_cfg->num_vdevs);
283 }
284
285 #ifdef FEATURE_WDS
286 /**
287 * wma_set_peer_map_unmap_v2_config() - Update peer_map_unmap_v2
288 * @psoc: Object manager psoc
289 * @tgt_cfg: Resource config given to target
290 *
291 * This function enables Peer map/unmap v2 feature.
292 *
293 * Return: none
294 */
wma_set_peer_map_unmap_v2_config(struct wlan_objmgr_psoc * psoc,target_resource_config * tgt_cfg)295 static void wma_set_peer_map_unmap_v2_config(struct wlan_objmgr_psoc *psoc,
296 target_resource_config *tgt_cfg)
297 {
298 tgt_cfg->peer_map_unmap_v2 =
299 wlan_mlme_get_wds_mode(psoc) ? true : false;
300 }
301 #else
wma_set_peer_map_unmap_v2_config(struct wlan_objmgr_psoc * psoc,target_resource_config * tgt_cfg)302 static void wma_set_peer_map_unmap_v2_config(struct wlan_objmgr_psoc *psoc,
303 target_resource_config *tgt_cfg)
304 {
305 tgt_cfg->peer_map_unmap_v2 = false;
306 }
307 #endif
308
309 #ifdef FEATURE_SET
310 /**
311 * wma_get_concurrency_support() - Get concurrency support
312 * @psoc: Object manager psoc
313 *
314 * Return: WMI_HOST_BAND_CONCURRENCY
315 */
316 static WMI_HOST_BAND_CONCURRENCY
wma_get_concurrency_support(struct wlan_objmgr_psoc * psoc)317 wma_get_concurrency_support(struct wlan_objmgr_psoc *psoc)
318 {
319 bool is_sbs_enabled = false;
320
321 if (policy_mgr_is_dual_mac_disabled_in_ini(psoc))
322 return WMI_HOST_BAND_CONCURRENCY_NONE;
323
324 policy_mgr_get_sbs_cfg(psoc, &is_sbs_enabled);
325
326 if (is_sbs_enabled)
327 return WMI_HOST_BAND_CONCURRENCY_DBS_SBS;
328 else
329 return WMI_HOST_BAND_CONCURRENCY_DBS;
330 }
331
332 /**
333 * wma_update_set_feature_version() - Update the set feature version
334 *
335 * @fs: Feature set structure in which version needs to be updated.
336 *
337 * Version 1 - Base feature version
338 * Version 2 - WMI_HOST_VENDOR1_REQ1_VERSION_3_30 updated.
339 * Version 3 - min sleep period for TWT and Scheduled PM in FW updated
340 * Version 4 - WMI_HOST_VENDOR1_REQ1_VERSION_3_40 updated.
341 * Version 5 - INI based 11BE support updated
342 * Version 6 - sta dump info updated
343 *
344 * Return: None
345 */
wma_update_set_feature_version(struct target_feature_set * fs)346 static void wma_update_set_feature_version(struct target_feature_set *fs)
347 {
348 fs->feature_set_version = 6;
349 }
350
351 /**
352 * wma_set_feature_set_info() - Set feature set info
353 * @wma_handle: WMA handle
354 * @feature_set: Feature set structure which needs to be filled
355 *
356 * Return: WMI_HOST_BAND_CONCURRENCY
357 */
wma_set_feature_set_info(tp_wma_handle wma_handle,struct target_feature_set * feature_set)358 static void wma_set_feature_set_info(tp_wma_handle wma_handle,
359 struct target_feature_set *feature_set)
360 {
361 struct cds_context *cds_ctx =
362 (struct cds_context *)(wma_handle->cds_context);
363 struct wlan_objmgr_psoc *psoc;
364 struct wlan_scan_features scan_feature_set = {0};
365 struct wlan_twt_features twt_feature_set = {0};
366 struct wlan_mlme_features mlme_feature_set = {0};
367 struct wlan_tdls_features tdls_feature_set = {0};
368
369 psoc = wma_handle->psoc;
370 if (!psoc) {
371 wma_err("Invalid psoc");
372 return;
373 }
374
375 if (!cds_ctx) {
376 wma_err("Invalid cds context");
377 return;
378 }
379
380 if (!cds_ctx->cds_cfg) {
381 wma_err("Invalid cds config");
382 return;
383 }
384
385 feature_set->wifi_standard =
386 cds_ctx->cds_cfg->cds_feature_set.wifi_standard;
387 feature_set->sap_5g_supported =
388 cds_ctx->cds_cfg->cds_feature_set.sap_5g_supported;
389 feature_set->sap_6g_supported =
390 cds_ctx->cds_cfg->cds_feature_set.sap_6g_supported;
391 feature_set->band_capability =
392 cds_ctx->cds_cfg->cds_feature_set.band_capability;
393
394 feature_set->concurrency_support = wma_get_concurrency_support(psoc);
395
396 wlan_scan_get_feature_info(psoc, &scan_feature_set);
397 feature_set->pno_in_unassoc_state =
398 scan_feature_set.pno_in_unassoc_state;
399 if (feature_set->pno_in_unassoc_state)
400 feature_set->pno_in_assoc_state =
401 scan_feature_set.pno_in_assoc_state;
402
403 wlan_twt_get_feature_info(psoc, &twt_feature_set);
404 feature_set->enable_twt = twt_feature_set.enable_twt;
405 if (feature_set->enable_twt) {
406 feature_set->enable_twt_requester =
407 twt_feature_set.enable_twt_requester;
408 feature_set->enable_twt_broadcast =
409 twt_feature_set.enable_twt_broadcast;
410 feature_set->enable_twt_flexible =
411 twt_feature_set.enable_twt_flexible;
412 }
413
414 feature_set->enable_rfc835 = true;
415
416 wlan_mlme_get_feature_info(psoc, &mlme_feature_set);
417
418 feature_set->enable_wifi_optimizer =
419 mlme_feature_set.enable_wifi_optimizer;
420 feature_set->sap_max_num_clients =
421 mlme_feature_set.sap_max_num_clients;
422
423 feature_set->vendor_req_1_version =
424 mlme_feature_set.vendor_req_1_version;
425 feature_set->roaming_high_cu_roam_trigger =
426 mlme_feature_set.roaming_high_cu_roam_trigger;
427 feature_set->roaming_emergency_trigger =
428 mlme_feature_set.roaming_emergency_trigger;
429 feature_set->roaming_btm_trihgger =
430 mlme_feature_set.roaming_btm_trihgger;
431 feature_set->roaming_idle_trigger =
432 mlme_feature_set.roaming_idle_trigger;
433 feature_set->roaming_wtc_trigger =
434 mlme_feature_set.roaming_wtc_trigger;
435 feature_set->roaming_btcoex_trigger =
436 mlme_feature_set.roaming_btcoex_trigger;
437 feature_set->roaming_btw_wpa_wpa2 =
438 mlme_feature_set.roaming_btw_wpa_wpa2;
439 feature_set->roaming_manage_chan_list_api =
440 mlme_feature_set.roaming_manage_chan_list_api;
441
442 feature_set->roaming_adaptive_11r =
443 mlme_feature_set.roaming_adaptive_11r;
444 feature_set->roaming_ctrl_api_get_set =
445 mlme_feature_set.roaming_ctrl_api_get_set;
446 feature_set->roaming_ctrl_api_reassoc =
447 mlme_feature_set.roaming_ctrl_api_reassoc;
448 feature_set->roaming_ctrl_get_cu =
449 mlme_feature_set.roaming_ctrl_get_cu;
450 feature_set->vendor_req_2_version =
451 mlme_feature_set.vendor_req_2_version;
452 feature_set->iface_combinations = mlme_feature_set.iface_combinations;
453
454 if (mlme_feature_set.enable2x2)
455 feature_set->num_antennas = WMI_HOST_MIMO_2X2;
456 else
457 feature_set->num_antennas = WMI_HOST_SISO;
458
459 feature_set->set_country_code_hal_supported = true;
460 feature_set->get_valid_channel_supported = true;
461 feature_set->supported_dot11mode = feature_set->wifi_standard;
462 feature_set->sap_wpa3_support = true;
463 feature_set->assurance_disconnect_reason_api = true;
464 feature_set->frame_pcap_log_mgmt =
465 ucfg_dp_is_local_pkt_capture_enabled(psoc);
466 feature_set->frame_pcap_log_ctrl = feature_set->frame_pcap_log_mgmt;
467 feature_set->frame_pcap_log_data = feature_set->frame_pcap_log_mgmt;
468
469 /*
470 * This information is hardcoded based on hdd_sta_akm_suites,
471 *wlan_crypto_key_mgmt and wlan_crypto_rsnx_cap
472 */
473
474 /* WLAN_CRYPTO_RSNX_CAP_SAE_H2E support*/
475 feature_set->security_wpa3_sae_h2e = true;
476 feature_set->security_wpa3_sae_ft = true;
477 feature_set->security_wpa3_enterp_suitb = true;
478 feature_set->security_wpa3_enterp_suitb_192bit = true;
479 feature_set->security_fills_sha_256 = true;
480 feature_set->security_fills_sha_384 = true;
481 feature_set->security_fills_sha_256_FT = true;
482 feature_set->security_fills_sha_384_FT = true;
483 /* This is OWE security support */
484 feature_set->security_enhanced_open = true;
485
486 feature_set->enable_nan = cfg_nan_get_enable(psoc);
487
488 wlan_tdls_get_features_info(psoc, &tdls_feature_set);
489 feature_set->enable_tdls = tdls_feature_set.enable_tdls;
490 if (feature_set->enable_tdls) {
491 feature_set->enable_tdls_offchannel =
492 tdls_feature_set.enable_tdls_offchannel;
493 feature_set->max_tdls_peers = tdls_feature_set.max_tdls_peers;
494 feature_set->enable_tdls_capability_enhance =
495 tdls_feature_set.enable_tdls_capability_enhance;
496 }
497
498 if (feature_set->sap_6g_supported)
499 feature_set->enable_p2p_6e =
500 policy_mgr_is_6ghz_conc_mode_supported(
501 psoc,
502 PM_P2P_CLIENT_MODE);
503
504 feature_set->peer_bigdata_getbssinfo_support = true;
505 feature_set->peer_bigdata_assocreject_info_support = true;
506 feature_set->peer_getstainfo_support = true;
507 feature_set->sta_dump_support = true;
508 wma_update_set_feature_version(feature_set);
509 }
510
511 /**
512 * wma_send_feature_set_cmd() - Send feature set command to FW
513 * @wma_handle: WMA handle
514 *
515 * Return: None
516 */
wma_send_feature_set_cmd(tp_wma_handle wma_handle)517 static void wma_send_feature_set_cmd(tp_wma_handle wma_handle)
518 {
519 struct target_feature_set feature_set;
520
521 if (!wma_handle) {
522 wma_err("Invalid wma_handle");
523 return;
524 }
525
526 wma_set_feature_set_info(wma_handle, &feature_set);
527
528 wmi_feature_set_cmd_send(wma_handle->wmi_handle,
529 &feature_set);
530 }
531
532 /**
533 * wma_is_feature_set_supported() - Check if feaure set is supported or not
534 * @wma_handle: WMA handle
535 *
536 * Return: True, if feature set is supported else return false
537 */
wma_is_feature_set_supported(tp_wma_handle wma_handle)538 static bool wma_is_feature_set_supported(tp_wma_handle wma_handle)
539 {
540 struct cds_context *cds_ctx =
541 (struct cds_context *)(wma_handle->cds_context);
542 bool is_feature_enabled_from_fw;
543
544 if (!cds_ctx) {
545 wma_err("Invalid cds context");
546 return false;
547 }
548
549 if (!cds_ctx->cds_cfg) {
550 wma_err("Invalid cds config");
551 return false;
552 }
553
554 is_feature_enabled_from_fw =
555 wmi_service_enabled(wma_handle->wmi_handle,
556 wmi_service_feature_set_event_support);
557
558 if (!is_feature_enabled_from_fw)
559 wma_debug("Get wifi feature is disabled from fw");
560
561 return (is_feature_enabled_from_fw &&
562 cds_ctx->cds_cfg->get_wifi_features);
563 }
564 #else
wma_send_feature_set_cmd(tp_wma_handle wma_handle)565 static inline void wma_send_feature_set_cmd(tp_wma_handle wma_handle)
566 {
567 }
568
wma_is_feature_set_supported(tp_wma_handle wma_handle)569 static bool wma_is_feature_set_supported(tp_wma_handle wma_handle)
570 {
571 return false;
572 }
573
574 #endif
575
576 /**
577 * wma_set_default_tgt_config() - set default tgt config
578 * @wma_handle: wma handle
579 * @tgt_cfg: Resource config given to target
580 * @cds_cfg: cds configuration
581 *
582 * Return: none
583 */
wma_set_default_tgt_config(tp_wma_handle wma_handle,target_resource_config * tgt_cfg,struct cds_config_info * cds_cfg)584 static void wma_set_default_tgt_config(tp_wma_handle wma_handle,
585 target_resource_config *tgt_cfg,
586 struct cds_config_info *cds_cfg)
587 {
588 enum QDF_GLOBAL_MODE con_mode;
589
590 qdf_mem_zero(tgt_cfg, sizeof(target_resource_config));
591
592 tgt_cfg->num_vdevs = cds_cfg->num_vdevs;
593 wma_update_num_peers_tids(wma_handle, tgt_cfg);
594
595 /* The current firmware implementation requires the number of
596 * offload peers should be (number of vdevs + 1).
597 */
598 tgt_cfg->num_offload_peers = cds_cfg->ap_maxoffload_peers + 1;
599 tgt_cfg->num_offload_reorder_buffs =
600 cds_cfg->ap_maxoffload_reorderbuffs + 1;
601 tgt_cfg->num_peer_keys = CFG_TGT_NUM_PEER_KEYS;
602 tgt_cfg->ast_skid_limit = CFG_TGT_AST_SKID_LIMIT;
603 tgt_cfg->tx_chain_mask = CFG_TGT_DEFAULT_TX_CHAIN_MASK;
604 tgt_cfg->rx_chain_mask = CFG_TGT_DEFAULT_RX_CHAIN_MASK;
605 tgt_cfg->rx_timeout_pri[0] = CFG_TGT_RX_TIMEOUT_LO_PRI;
606 tgt_cfg->rx_timeout_pri[1] = CFG_TGT_RX_TIMEOUT_LO_PRI;
607 tgt_cfg->rx_timeout_pri[2] = CFG_TGT_RX_TIMEOUT_LO_PRI;
608 tgt_cfg->rx_timeout_pri[3] = CFG_TGT_RX_TIMEOUT_HI_PRI;
609 tgt_cfg->rx_decap_mode = CFG_TGT_RX_DECAP_MODE;
610 tgt_cfg->scan_max_pending_req = WLAN_MAX_ACTIVE_SCANS_ALLOWED;
611 tgt_cfg->bmiss_offload_max_vdev =
612 CFG_TGT_DEFAULT_BMISS_OFFLOAD_MAX_VDEV;
613 tgt_cfg->roam_offload_max_vdev = CFG_TGT_DEFAULT_ROAM_OFFLOAD_MAX_VDEV;
614 tgt_cfg->roam_offload_max_ap_profiles =
615 CFG_TGT_DEFAULT_ROAM_OFFLOAD_MAX_PROFILES;
616 tgt_cfg->num_mcast_groups = CFG_TGT_DEFAULT_NUM_MCAST_GROUPS;
617 tgt_cfg->num_mcast_table_elems = CFG_TGT_DEFAULT_NUM_MCAST_TABLE_ELEMS;
618 tgt_cfg->mcast2ucast_mode = CFG_TGT_DEFAULT_MCAST2UCAST_MODE;
619 tgt_cfg->tx_dbg_log_size = CFG_TGT_DEFAULT_TX_DBG_LOG_SIZE;
620 tgt_cfg->num_wds_entries = CFG_TGT_WDS_ENTRIES;
621 tgt_cfg->dma_burst_size = CFG_TGT_DEFAULT_DMA_BURST_SIZE;
622 tgt_cfg->mac_aggr_delim = CFG_TGT_DEFAULT_MAC_AGGR_DELIM;
623 tgt_cfg->rx_skip_defrag_timeout_dup_detection_check =
624 CFG_TGT_DEFAULT_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK,
625 tgt_cfg->vow_config = CFG_TGT_DEFAULT_VOW_CONFIG;
626 tgt_cfg->gtk_offload_max_vdev = CFG_TGT_DEFAULT_GTK_OFFLOAD_MAX_VDEV;
627 tgt_cfg->num_msdu_desc = CFG_TGT_NUM_MSDU_DESC;
628 tgt_cfg->max_frag_entries = CFG_TGT_MAX_FRAG_TABLE_ENTRIES;
629 tgt_cfg->num_tdls_vdevs = CFG_TGT_NUM_TDLS_VDEVS;
630 tgt_cfg->num_tdls_conn_table_entries =
631 QDF_MIN(CFG_TGT_NUM_TDLS_CONN_TABLE_ENTRIES,
632 cfg_tdls_get_max_peer_count(wma_handle->psoc));
633 tgt_cfg->beacon_tx_offload_max_vdev =
634 CFG_TGT_DEFAULT_BEACON_TX_OFFLOAD_MAX_VDEV;
635 tgt_cfg->num_multicast_filter_entries =
636 CFG_TGT_MAX_MULTICAST_FILTER_ENTRIES;
637 tgt_cfg->num_wow_filters = 0;
638 tgt_cfg->num_keep_alive_pattern = MAXNUM_PERIODIC_TX_PTRNS;
639 tgt_cfg->num_max_sta_vdevs = CFG_TGT_DEFAULT_MAX_STA_VDEVS;
640 tgt_cfg->keep_alive_pattern_size = 0;
641 tgt_cfg->max_tdls_concurrent_sleep_sta =
642 CFG_TGT_NUM_TDLS_CONC_SLEEP_STAS;
643 tgt_cfg->max_tdls_concurrent_buffer_sta =
644 CFG_TGT_NUM_TDLS_CONC_BUFFER_STAS;
645 tgt_cfg->wmi_send_separate = 0;
646 tgt_cfg->num_ocb_vdevs = CFG_TGT_NUM_OCB_VDEVS;
647 tgt_cfg->num_ocb_channels = CFG_TGT_NUM_OCB_CHANNELS;
648 tgt_cfg->num_ocb_schedules = CFG_TGT_NUM_OCB_SCHEDULES;
649 tgt_cfg->twt_ap_sta_count = CFG_TGT_DEFAULT_TWT_AP_STA_COUNT;
650 tgt_cfg->enable_pci_gen = cfg_get(wma_handle->psoc, CFG_ENABLE_PCI_GEN);
651
652 tgt_cfg->mgmt_comp_evt_bundle_support = true;
653 tgt_cfg->tx_msdu_new_partition_id_support = true;
654 tgt_cfg->is_sap_connected_d3wow_enabled =
655 ucfg_pmo_get_sap_mode_bus_suspend(wma_handle->psoc);
656 tgt_cfg->is_go_connected_d3wow_enabled =
657 ucfg_pmo_get_go_mode_bus_suspend(wma_handle->psoc);
658 tgt_cfg->num_max_active_vdevs =
659 policy_mgr_get_max_conc_cxns(wma_handle->psoc);
660 tgt_cfg->num_max_mlo_link_per_ml_bss =
661 wlan_mlme_get_sta_mlo_conn_max_num(wma_handle->psoc);
662 cfg_nan_get_max_ndi(wma_handle->psoc,
663 &tgt_cfg->max_ndi);
664
665 con_mode = cds_get_conparam();
666 if (con_mode == QDF_GLOBAL_MONITOR_MODE)
667 tgt_cfg->rx_decap_mode = CFG_TGT_RX_DECAP_MODE_RAW;
668
669 if (con_mode == QDF_GLOBAL_FTM_MODE) {
670 tgt_cfg->num_offload_peers = 0;
671 tgt_cfg->num_offload_reorder_buffs = 0;
672 tgt_cfg->bmiss_offload_max_vdev = 0;
673 tgt_cfg->roam_offload_max_vdev = 0;
674 tgt_cfg->roam_offload_max_ap_profiles = 0;
675 tgt_cfg->beacon_tx_offload_max_vdev = 1;
676 tgt_cfg->num_multicast_filter_entries = 0;
677 tgt_cfg->gtk_offload_max_vdev = 0;
678 }
679 cfg_nan_get_ndp_max_sessions(wma_handle->psoc,
680 &tgt_cfg->max_ndp_sessions);
681
682 wma_set_ipa_disable_config(tgt_cfg);
683 wma_set_peer_map_unmap_v2_config(wma_handle->psoc, tgt_cfg);
684
685 tgt_cfg->notify_frame_support = DP_MARK_NOTIFY_FRAME_SUPPORT;
686 }
687
688 /**
689 * wma_cli_get_command() - WMA "get" command processor
690 * @vdev_id: virtual device for the command
691 * @param_id: parameter id
692 * @vpdev: parameter category
693 *
694 * Return: parameter value on success, -EINVAL on failure
695 */
wma_cli_get_command(int vdev_id,int param_id,int vpdev)696 int wma_cli_get_command(int vdev_id, int param_id, int vpdev)
697 {
698 int ret = 0;
699 tp_wma_handle wma;
700 struct wma_txrx_node *intr = NULL;
701
702 wma = cds_get_context(QDF_MODULE_ID_WMA);
703 if (!wma)
704 return -EINVAL;
705
706 intr = wma->interfaces;
707
708 if (VDEV_CMD == vpdev) {
709 switch (param_id) {
710 case wmi_vdev_param_nss:
711 ret = intr[vdev_id].config.nss;
712 break;
713 #ifdef QCA_SUPPORT_GTX
714 case wmi_vdev_param_gtx_ht_mcs:
715 ret = intr[vdev_id].config.gtx_info.gtxRTMask[0];
716 break;
717 case wmi_vdev_param_gtx_vht_mcs:
718 ret = intr[vdev_id].config.gtx_info.gtxRTMask[1];
719 break;
720 case wmi_vdev_param_gtx_usr_cfg:
721 ret = intr[vdev_id].config.gtx_info.gtxUsrcfg;
722 break;
723 case wmi_vdev_param_gtx_thre:
724 ret = intr[vdev_id].config.gtx_info.gtxPERThreshold;
725 break;
726 case wmi_vdev_param_gtx_margin:
727 ret = intr[vdev_id].config.gtx_info.gtxPERMargin;
728 break;
729 case wmi_vdev_param_gtx_step:
730 ret = intr[vdev_id].config.gtx_info.gtxTPCstep;
731 break;
732 case wmi_vdev_param_gtx_mintpc:
733 ret = intr[vdev_id].config.gtx_info.gtxTPCMin;
734 break;
735 case wmi_vdev_param_gtx_bw_mask:
736 ret = intr[vdev_id].config.gtx_info.gtxBWMask;
737 break;
738 #endif /* QCA_SUPPORT_GTX */
739 case wmi_vdev_param_ldpc:
740 ret = intr[vdev_id].config.ldpc;
741 break;
742 case wmi_vdev_param_tx_stbc:
743 ret = intr[vdev_id].config.tx_stbc;
744 break;
745 case wmi_vdev_param_rx_stbc:
746 ret = intr[vdev_id].config.rx_stbc;
747 break;
748 case wmi_vdev_param_sgi:
749 ret = intr[vdev_id].config.shortgi;
750 break;
751 case wmi_vdev_param_enable_rtscts:
752 ret = intr[vdev_id].config.rtscts_en;
753 break;
754 case wmi_vdev_param_chwidth:
755 ret = intr[vdev_id].config.chwidth;
756 break;
757 case wmi_vdev_param_fixed_rate:
758 ret = intr[vdev_id].config.tx_rate;
759 break;
760 case wmi_vdev_param_he_dcm_enable:
761 case wmi_vdev_param_he_range_ext:
762 ret = wma_get_he_vdev_param(&intr[vdev_id], param_id);
763 break;
764 default:
765 wma_err("Invalid cli_get vdev command/Not yet implemented 0x%x",
766 param_id);
767 return -EINVAL;
768 }
769 } else if (PDEV_CMD == vpdev) {
770 switch (param_id) {
771 case wmi_pdev_param_ani_enable:
772 ret = wma->pdevconfig.ani_enable;
773 break;
774 case wmi_pdev_param_ani_poll_period:
775 ret = wma->pdevconfig.ani_poll_len;
776 break;
777 case wmi_pdev_param_ani_listen_period:
778 ret = wma->pdevconfig.ani_listen_len;
779 break;
780 case wmi_pdev_param_ani_ofdm_level:
781 ret = wma->pdevconfig.ani_ofdm_level;
782 break;
783 case wmi_pdev_param_ani_cck_level:
784 ret = wma->pdevconfig.ani_cck_level;
785 break;
786 case wmi_pdev_param_dynamic_bw:
787 ret = wma->pdevconfig.cwmenable;
788 break;
789 case wmi_pdev_param_cts_cbw:
790 ret = wma->pdevconfig.cts_cbw;
791 break;
792 case wmi_pdev_param_tx_chain_mask:
793 ret = wma->pdevconfig.txchainmask;
794 break;
795 case wmi_pdev_param_rx_chain_mask:
796 ret = wma->pdevconfig.rxchainmask;
797 break;
798 case wmi_pdev_param_txpower_limit2g:
799 ret = wma->pdevconfig.txpow2g;
800 break;
801 case wmi_pdev_param_txpower_limit5g:
802 ret = wma->pdevconfig.txpow5g;
803 break;
804 default:
805 wma_err("Invalid cli_get pdev command/Not yet implemented 0x%x",
806 param_id);
807 return -EINVAL;
808 }
809 } else if (GEN_CMD == vpdev) {
810 switch (param_id) {
811 case GEN_VDEV_PARAM_AMPDU:
812 ret = intr[vdev_id].config.ampdu;
813 break;
814 case GEN_VDEV_PARAM_AMSDU:
815 ret = intr[vdev_id].config.amsdu;
816 break;
817 case GEN_VDEV_ROAM_SYNCH_DELAY:
818 ret = intr[vdev_id].roam_synch_delay;
819 break;
820 case GEN_VDEV_PARAM_TX_AMPDU:
821 ret = intr[vdev_id].config.tx_ampdu;
822 break;
823 case GEN_VDEV_PARAM_RX_AMPDU:
824 ret = intr[vdev_id].config.rx_ampdu;
825 break;
826 case GEN_VDEV_PARAM_TX_AMSDU:
827 ret = intr[vdev_id].config.tx_amsdu;
828 break;
829 case GEN_VDEV_PARAM_RX_AMSDU:
830 ret = intr[vdev_id].config.rx_amsdu;
831 break;
832 default:
833 wma_warn("Invalid generic vdev command/Not yet implemented 0x%x",
834 param_id);
835 return -EINVAL;
836 }
837 } else if (PPS_CMD == vpdev) {
838 switch (param_id) {
839 case WMI_VDEV_PPS_PAID_MATCH:
840 ret = intr[vdev_id].config.pps_params.paid_match_enable;
841 break;
842 case WMI_VDEV_PPS_GID_MATCH:
843 ret = intr[vdev_id].config.pps_params.gid_match_enable;
844 break;
845 case WMI_VDEV_PPS_EARLY_TIM_CLEAR:
846 ret = intr[vdev_id].config.pps_params.tim_clear;
847 break;
848 case WMI_VDEV_PPS_EARLY_DTIM_CLEAR:
849 ret = intr[vdev_id].config.pps_params.dtim_clear;
850 break;
851 case WMI_VDEV_PPS_EOF_PAD_DELIM:
852 ret = intr[vdev_id].config.pps_params.eof_delim;
853 break;
854 case WMI_VDEV_PPS_MACADDR_MISMATCH:
855 ret = intr[vdev_id].config.pps_params.mac_match;
856 break;
857 case WMI_VDEV_PPS_DELIM_CRC_FAIL:
858 ret = intr[vdev_id].config.pps_params.delim_fail;
859 break;
860 case WMI_VDEV_PPS_GID_NSTS_ZERO:
861 ret = intr[vdev_id].config.pps_params.nsts_zero;
862 break;
863 case WMI_VDEV_PPS_RSSI_CHECK:
864 ret = intr[vdev_id].config.pps_params.rssi_chk;
865 break;
866 default:
867 wma_err("Invalid pps vdev command/Not yet implemented 0x%x",
868 param_id);
869 return -EINVAL;
870 }
871 } else if (QPOWER_CMD == vpdev) {
872 switch (param_id) {
873 case WMI_STA_PS_PARAM_QPOWER_PSPOLL_COUNT:
874 ret = intr[vdev_id].config.qpower_params.
875 max_ps_poll_cnt;
876 break;
877 case WMI_STA_PS_PARAM_QPOWER_MAX_TX_BEFORE_WAKE:
878 ret = intr[vdev_id].config.qpower_params.
879 max_tx_before_wake;
880 break;
881 case WMI_STA_PS_PARAM_QPOWER_SPEC_PSPOLL_WAKE_INTERVAL:
882 ret = intr[vdev_id].config.qpower_params.
883 spec_ps_poll_wake_interval;
884 break;
885 case WMI_STA_PS_PARAM_QPOWER_SPEC_MAX_SPEC_NODATA_PSPOLL:
886 ret = intr[vdev_id].config.qpower_params.
887 max_spec_nodata_ps_poll;
888 break;
889 default:
890 wma_warn("Invalid generic vdev command/Not yet implemented 0x%x",
891 param_id);
892 return -EINVAL;
893 }
894 } else if (GTX_CMD == vpdev) {
895 switch (param_id) {
896 case wmi_vdev_param_gtx_ht_mcs:
897 ret = intr[vdev_id].config.gtx_info.gtxRTMask[0];
898 break;
899 case wmi_vdev_param_gtx_vht_mcs:
900 ret = intr[vdev_id].config.gtx_info.gtxRTMask[1];
901 break;
902 case wmi_vdev_param_gtx_usr_cfg:
903 ret = intr[vdev_id].config.gtx_info.gtxUsrcfg;
904 break;
905 case wmi_vdev_param_gtx_thre:
906 ret = intr[vdev_id].config.gtx_info.gtxPERThreshold;
907 break;
908 case wmi_vdev_param_gtx_margin:
909 ret = intr[vdev_id].config.gtx_info.gtxPERMargin;
910 break;
911 case wmi_vdev_param_gtx_step:
912 ret = intr[vdev_id].config.gtx_info.gtxTPCstep;
913 break;
914 case wmi_vdev_param_gtx_mintpc:
915 ret = intr[vdev_id].config.gtx_info.gtxTPCMin;
916 break;
917 case wmi_vdev_param_gtx_bw_mask:
918 ret = intr[vdev_id].config.gtx_info.gtxBWMask;
919 break;
920 default:
921 wma_warn("Invalid generic vdev command/Not yet implemented 0x%x",
922 param_id);
923 return -EINVAL;
924 }
925 }
926 return ret;
927 }
928
929 /**
930 * wma_cli_set2_command() - WMA "set 2 params" command processor
931 * @vdev_id: virtual device for the command
932 * @param_id: parameter id
933 * @sval1: first parameter value
934 * @sval2: second parameter value
935 * @vpdev: parameter category
936 *
937 * Command handler for set operations which require 2 parameters
938 *
939 * Return: 0 on success, errno on failure
940 */
wma_cli_set2_command(int vdev_id,int param_id,int sval1,int sval2,int vpdev)941 int wma_cli_set2_command(int vdev_id, int param_id, int sval1,
942 int sval2, int vpdev)
943 {
944 struct scheduler_msg msg = { 0 };
945 wma_cli_set_cmd_t *iwcmd;
946
947 iwcmd = qdf_mem_malloc(sizeof(*iwcmd));
948 if (!iwcmd)
949 return -ENOMEM;
950
951 qdf_mem_zero(iwcmd, sizeof(*iwcmd));
952 iwcmd->param_value = sval1;
953 iwcmd->param_sec_value = sval2;
954 iwcmd->param_vdev_id = vdev_id;
955 iwcmd->param_id = param_id;
956 iwcmd->param_vp_dev = vpdev;
957 msg.type = WMA_CLI_SET_CMD;
958 msg.reserved = 0;
959 msg.bodyptr = iwcmd;
960
961 if (QDF_STATUS_SUCCESS !=
962 scheduler_post_message(QDF_MODULE_ID_WMA,
963 QDF_MODULE_ID_WMA,
964 QDF_MODULE_ID_WMA, &msg)) {
965 qdf_mem_free(iwcmd);
966 return -EIO;
967 }
968 return 0;
969 }
970
971 /**
972 * wma_cli_set_command() - WMA "set" command processor
973 * @vdev_id: virtual device for the command
974 * @param_id: parameter id
975 * @sval: parameter value
976 * @vpdev: parameter category
977 *
978 * Command handler for set operations
979 *
980 * Return: 0 on success, errno on failure
981 */
wma_cli_set_command(int vdev_id,int param_id,int sval,int vpdev)982 int wma_cli_set_command(int vdev_id, int param_id, int sval, int vpdev)
983 {
984 return wma_cli_set2_command(vdev_id, param_id, sval, 0, vpdev);
985
986 }
987
wma_form_unit_test_cmd_and_send(uint32_t vdev_id,uint32_t module_id,uint32_t arg_count,uint32_t * arg)988 QDF_STATUS wma_form_unit_test_cmd_and_send(uint32_t vdev_id,
989 uint32_t module_id, uint32_t arg_count, uint32_t *arg)
990 {
991 struct wmi_unit_test_cmd *unit_test_args;
992 tp_wma_handle wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
993 uint32_t i;
994 QDF_STATUS status;
995 struct wmi_unified *wmi_handle;
996
997 wma_debug("enter");
998
999 if (QDF_GLOBAL_FTM_MODE != cds_get_conparam()) {
1000 if (!wma_is_vdev_valid(vdev_id))
1001 return QDF_STATUS_E_FAILURE;
1002 }
1003
1004 if (arg_count > WMI_UNIT_TEST_MAX_NUM_ARGS) {
1005 wma_err("arg_count is crossed the boundary");
1006 return QDF_STATUS_E_FAILURE;
1007 }
1008
1009 if (wma_validate_handle(wma_handle))
1010 return QDF_STATUS_E_FAILURE;
1011
1012 wmi_handle = wma_handle->wmi_handle;
1013 if (wmi_validate_handle(wmi_handle))
1014 return QDF_STATUS_E_FAILURE;
1015
1016 unit_test_args = qdf_mem_malloc(sizeof(*unit_test_args));
1017 if (!unit_test_args)
1018 return QDF_STATUS_E_NOMEM;
1019
1020 unit_test_args->vdev_id = vdev_id;
1021 unit_test_args->module_id = module_id;
1022 unit_test_args->num_args = arg_count;
1023 for (i = 0; i < arg_count; i++)
1024 unit_test_args->args[i] = arg[i];
1025
1026 status = wmi_unified_unit_test_cmd(wmi_handle,
1027 unit_test_args);
1028 qdf_mem_free(unit_test_args);
1029 wma_debug("exit");
1030
1031 return status;
1032 }
1033
wma_process_send_addba_req(tp_wma_handle wma_handle,struct send_add_ba_req * send_addba)1034 static void wma_process_send_addba_req(tp_wma_handle wma_handle,
1035 struct send_add_ba_req *send_addba)
1036 {
1037 QDF_STATUS status;
1038 struct wmi_unified *wmi_handle;
1039
1040 if (wma_validate_handle(wma_handle)) {
1041 qdf_mem_free(send_addba);
1042 return;
1043 }
1044
1045 wmi_handle = wma_handle->wmi_handle;
1046 if (wmi_validate_handle(wmi_handle)) {
1047 qdf_mem_free(send_addba);
1048 return;
1049 }
1050
1051 status = wmi_unified_addba_send_cmd_send(wmi_handle,
1052 send_addba->mac_addr,
1053 &send_addba->param);
1054 if (QDF_STATUS_SUCCESS != status) {
1055 wma_err("Failed to process WMA_SEND_ADDBA_REQ");
1056 }
1057 wma_debug("sent ADDBA req to" QDF_MAC_ADDR_FMT "tid %d buff_size %d",
1058 QDF_MAC_ADDR_REF(send_addba->mac_addr),
1059 send_addba->param.tidno,
1060 send_addba->param.buffersize);
1061
1062 qdf_mem_free(send_addba);
1063 }
1064
1065 /**
1066 * wma_set_priv_cfg() - set private config parameters
1067 * @wma_handle: wma handle
1068 * @privcmd: private command
1069 *
1070 * Return: 0 for success or error code
1071 */
wma_set_priv_cfg(tp_wma_handle wma_handle,wma_cli_set_cmd_t * privcmd)1072 static int32_t wma_set_priv_cfg(tp_wma_handle wma_handle,
1073 wma_cli_set_cmd_t *privcmd)
1074 {
1075 int32_t ret = 0;
1076
1077 switch (privcmd->param_id) {
1078 case WMA_VDEV_TXRX_FWSTATS_ENABLE_CMDID:
1079 ret = wma_set_txrx_fw_stats_level(wma_handle,
1080 privcmd->param_vdev_id,
1081 privcmd->param_value);
1082 break;
1083 case WMA_VDEV_TXRX_FWSTATS_RESET_CMDID:
1084 ret = wma_txrx_fw_stats_reset(wma_handle,
1085 privcmd->param_vdev_id,
1086 privcmd->param_value);
1087 break;
1088 case WMI_STA_SMPS_FORCE_MODE_CMDID:
1089 ret = wma_set_mimops(wma_handle,
1090 privcmd->param_vdev_id,
1091 privcmd->param_value);
1092 break;
1093 case WMI_STA_SMPS_PARAM_CMDID:
1094 wma_set_smps_params(wma_handle, privcmd->param_vdev_id,
1095 privcmd->param_value);
1096 break;
1097 case WMA_VDEV_MCC_SET_TIME_LATENCY:
1098 {
1099 /* Extract first MCC adapter/vdev channel number and latency */
1100 uint8_t mcc_channel = privcmd->param_value & 0x000000FF;
1101 uint8_t mcc_channel_latency =
1102 (privcmd->param_value & 0x0000FF00) >> 8;
1103 int ret = -1;
1104
1105 wma_debug("Parsed input: Channel #1:%d, latency:%dms",
1106 mcc_channel, mcc_channel_latency);
1107 ret = wma_set_mcc_channel_time_latency(wma_handle,
1108 mcc_channel,
1109 mcc_channel_latency);
1110 }
1111 break;
1112 case WMA_VDEV_MCC_SET_TIME_QUOTA:
1113 {
1114 /* Extract the MCC 2 adapters/vdevs channel numbers and time
1115 * quota value for the first adapter only (which is specified
1116 * in iwpriv command.
1117 */
1118 uint8_t adapter_2_chan_number =
1119 privcmd->param_value & 0x000000FF;
1120 uint8_t adapter_1_chan_number =
1121 (privcmd->param_value & 0x0000FF00) >> 8;
1122 uint8_t adapter_1_quota =
1123 (privcmd->param_value & 0x00FF0000) >> 16;
1124 int ret = -1;
1125
1126 wma_debug("Parsed input: Channel #1:%d, Channel #2:%d, quota 1:%dms",
1127 adapter_1_chan_number,
1128 adapter_2_chan_number, adapter_1_quota);
1129
1130 ret = wma_set_mcc_channel_time_quota(wma_handle,
1131 adapter_1_chan_number,
1132 adapter_1_quota,
1133 adapter_2_chan_number);
1134 }
1135 break;
1136 default:
1137 wma_err("Invalid wma config command id:%d", privcmd->param_id);
1138 ret = -EINVAL;
1139 }
1140 return ret;
1141 }
1142
1143 /**
1144 * wma_set_dtim_period() - set dtim period to FW
1145 * @wma: wma handle
1146 * @dtim_params: dtim params
1147 *
1148 * Return: none
1149 */
wma_set_dtim_period(tp_wma_handle wma,struct set_dtim_params * dtim_params)1150 static void wma_set_dtim_period(tp_wma_handle wma,
1151 struct set_dtim_params *dtim_params)
1152 {
1153 struct wma_txrx_node *iface =
1154 &wma->interfaces[dtim_params->session_id];
1155 if (!wma_is_vdev_valid(dtim_params->session_id)) {
1156 wma_err("invalid VDEV");
1157 return;
1158 }
1159 wma_debug("set dtim_period %d", dtim_params->dtim_period);
1160 iface->dtimPeriod = dtim_params->dtim_period;
1161
1162 }
1163
wma_is_tx_chainmask_valid(int value,struct target_psoc_info * tgt_hdl)1164 static inline bool wma_is_tx_chainmask_valid(int value,
1165 struct target_psoc_info *tgt_hdl)
1166 {
1167 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap;
1168 uint8_t total_mac_phy_cnt, i;
1169
1170 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
1171 if (!mac_phy_cap) {
1172 wma_err("Invalid MAC PHY capabilities handle");
1173 return false;
1174 }
1175
1176 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
1177 for (i = 0; i < total_mac_phy_cnt; i++) {
1178 if (((mac_phy_cap[i].tx_chain_mask_5G) & (value))) {
1179 return true;
1180 }
1181 }
1182
1183 return false;
1184 }
1185
1186 /**
1187 * wma_convert_ac_value() - map ac setting to the value to be used in FW.
1188 * @ac_value: ac value to be mapped.
1189 *
1190 * Return: enum wmi_traffic_ac
1191 */
wma_convert_ac_value(uint32_t ac_value)1192 static inline wmi_traffic_ac wma_convert_ac_value(uint32_t ac_value)
1193 {
1194 switch (ac_value) {
1195 case QCA_WLAN_AC_BE:
1196 return WMI_AC_BE;
1197 case QCA_WLAN_AC_BK:
1198 return WMI_AC_BK;
1199 case QCA_WLAN_AC_VI:
1200 return WMI_AC_VI;
1201 case QCA_WLAN_AC_VO:
1202 return WMI_AC_VO;
1203 case QCA_WLAN_AC_ALL:
1204 return WMI_AC_MAX;
1205 }
1206 wma_err("invalid enum: %u", ac_value);
1207 return WMI_AC_MAX;
1208 }
1209
1210 #ifdef WLAN_FEATURE_11BE
1211 /**
1212 * wma_set_per_link_amsdu_cap() - Set AMSDU/AMPDU capability per link to FW.
1213 * @wma: wma handle
1214 * @privcmd: pointer to set command parameters
1215 * @aggr_type: aggregration type
1216 *
1217 * Return: QDF_STATUS_SUCCESS if set command is sent successfully, else
1218 * QDF_STATUS_E_FAILURE
1219 */
1220 static QDF_STATUS
wma_set_per_link_amsdu_cap(tp_wma_handle wma,wma_cli_set_cmd_t * privcmd,wmi_vdev_custom_aggr_type_t aggr_type)1221 wma_set_per_link_amsdu_cap(tp_wma_handle wma, wma_cli_set_cmd_t *privcmd,
1222 wmi_vdev_custom_aggr_type_t aggr_type)
1223 {
1224 uint8_t vdev_id;
1225 uint8_t op_mode;
1226 QDF_STATUS ret = QDF_STATUS_E_FAILURE;
1227
1228 for (vdev_id = 0; vdev_id < WLAN_MAX_VDEVS; vdev_id++) {
1229 op_mode = wlan_get_opmode_from_vdev_id(wma->pdev, vdev_id);
1230 if (op_mode == QDF_STA_MODE) {
1231 ret = wma_set_tx_rx_aggr_size(vdev_id,
1232 privcmd->param_value,
1233 privcmd->param_value,
1234 aggr_type);
1235 if (QDF_IS_STATUS_ERROR(ret)) {
1236 wma_err("set_aggr_size failed for vdev: %d, ret %d",
1237 vdev_id, ret);
1238 return ret;
1239 }
1240 }
1241 }
1242
1243 return ret;
1244 }
1245 #else
1246 static inline QDF_STATUS
wma_set_per_link_amsdu_cap(tp_wma_handle wma,wma_cli_set_cmd_t * privcmd,wmi_vdev_custom_aggr_type_t aggr_type)1247 wma_set_per_link_amsdu_cap(tp_wma_handle wma, wma_cli_set_cmd_t *privcmd,
1248 wmi_vdev_custom_aggr_type_t aggr_type)
1249 {
1250 return QDF_STATUS_SUCCESS;
1251 }
1252 #endif
1253
1254 /**
1255 * wma_process_cli_set_cmd() - set parameters to fw
1256 * @wma: wma handle
1257 * @privcmd: command
1258 *
1259 * Return: none
1260 */
wma_process_cli_set_cmd(tp_wma_handle wma,wma_cli_set_cmd_t * privcmd)1261 static void wma_process_cli_set_cmd(tp_wma_handle wma,
1262 wma_cli_set_cmd_t *privcmd)
1263 {
1264 int vid = privcmd->param_vdev_id, pps_val = 0;
1265 QDF_STATUS ret;
1266 struct wma_txrx_node *intr = wma->interfaces;
1267 struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
1268 struct qpower_params *qparams = &intr[vid].config.qpower_params;
1269 struct pdev_params pdev_param = {0};
1270 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
1271 struct target_psoc_info *tgt_hdl;
1272 enum wlan_eht_mode eht_mode;
1273
1274 if (!mac) {
1275 wma_err("Failed to get mac");
1276 return;
1277 }
1278
1279 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma->psoc);
1280 if (!tgt_hdl) {
1281 wma_err("target psoc info is NULL");
1282 return;
1283 }
1284
1285 if (privcmd->param_id >= WMI_CMDID_MAX) {
1286 /*
1287 * This configuration setting is not done using any wmi
1288 * command, call appropriate handler.
1289 */
1290 if (wma_set_priv_cfg(wma, privcmd))
1291 wma_err("Failed to set wma priv configuration");
1292 return;
1293 }
1294
1295 switch (privcmd->param_vp_dev) {
1296 case VDEV_CMD:
1297 if (!wma_is_vdev_valid(privcmd->param_vdev_id)) {
1298 wma_err("Vdev id is not valid");
1299 return;
1300 }
1301
1302 wma_debug("vdev id %d pid %d pval %d", privcmd->param_vdev_id,
1303 privcmd->param_id, privcmd->param_value);
1304 ret = wma_vdev_set_param(wma->wmi_handle,
1305 privcmd->param_vdev_id,
1306 privcmd->param_id,
1307 privcmd->param_value);
1308 if (QDF_IS_STATUS_ERROR(ret)) {
1309 wma_err("wma_vdev_set_param failed ret %d", ret);
1310 return;
1311 }
1312 break;
1313 case PDEV_CMD:
1314 wma_debug("pdev pid %d pval %d", privcmd->param_id,
1315 privcmd->param_value);
1316 if ((privcmd->param_id == wmi_pdev_param_rx_chain_mask) ||
1317 (privcmd->param_id == wmi_pdev_param_tx_chain_mask)) {
1318 if (QDF_STATUS_SUCCESS !=
1319 wma_check_txrx_chainmask(
1320 target_if_get_num_rf_chains(tgt_hdl),
1321 privcmd->param_value)) {
1322 wma_debug("Chainmask value is invalid");
1323 return;
1324 }
1325 }
1326
1327 if (privcmd->param_id == wmi_pdev_param_tx_chain_mask) {
1328 if (!wma_is_tx_chainmask_valid(privcmd->param_value,
1329 tgt_hdl)) {
1330 wma_debug("Chainmask value is invalid");
1331 return;
1332 }
1333 }
1334 pdev_param.param_id = privcmd->param_id;
1335 pdev_param.param_value = privcmd->param_value;
1336 if (privcmd->param_id == wmi_pdev_param_twt_ac_config)
1337 pdev_param.param_value =
1338 wma_convert_ac_value(pdev_param.param_value);
1339 ret = wmi_unified_pdev_param_send(wma->wmi_handle,
1340 &pdev_param,
1341 privcmd->param_sec_value);
1342 if (QDF_IS_STATUS_ERROR(ret)) {
1343 wma_err("wma_vdev_set_param failed ret %d", ret);
1344 return;
1345 }
1346 break;
1347 case GEN_CMD:
1348 {
1349 struct wma_txrx_node *intr = wma->interfaces;
1350 wmi_vdev_custom_aggr_type_t aggr_type =
1351 WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU;
1352
1353 wma_debug("gen pid %d pval %d", privcmd->param_id,
1354 privcmd->param_value);
1355
1356 switch (privcmd->param_id) {
1357 case GEN_VDEV_PARAM_AMSDU:
1358 case GEN_VDEV_PARAM_AMPDU:
1359 if (!soc) {
1360 wma_err("SOC context is NULL");
1361 return;
1362 }
1363
1364 if (privcmd->param_id == GEN_VDEV_PARAM_AMPDU) {
1365 ret = cdp_aggr_cfg(soc, privcmd->param_vdev_id,
1366 privcmd->param_value, 0);
1367 if (ret)
1368 wma_err("cdp_aggr_cfg set ampdu failed ret %d",
1369 ret);
1370 else
1371 intr[privcmd->param_vdev_id].config.
1372 ampdu = privcmd->param_value;
1373
1374 aggr_type =
1375 WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU;
1376 }
1377
1378 wlan_mlme_get_eht_mode(wma->psoc, &eht_mode);
1379 if (eht_mode == WLAN_EHT_MODE_MLSR ||
1380 eht_mode == WLAN_EHT_MODE_MLMR) {
1381 ret = wma_set_per_link_amsdu_cap(wma, privcmd,
1382 aggr_type);
1383 if (QDF_IS_STATUS_ERROR(ret))
1384 return;
1385 } else {
1386 ret = wma_set_tx_rx_aggr_size(
1387 vid,
1388 privcmd->param_value,
1389 privcmd->param_value,
1390 aggr_type);
1391 if (QDF_IS_STATUS_ERROR(ret)) {
1392 wma_err("set_aggr_size failed ret %d",
1393 ret);
1394 return;
1395 }
1396 }
1397 break;
1398 case GEN_PARAM_CRASH_INJECT:
1399 if (QDF_GLOBAL_FTM_MODE == cds_get_conparam())
1400 wma_err("Crash inject not allowed in FTM mode");
1401 else
1402 ret = wma_crash_inject(wma,
1403 privcmd->param_value,
1404 privcmd->param_sec_value);
1405 break;
1406 case GEN_PARAM_CAPTURE_TSF:
1407 ret = wma_capture_tsf(wma, privcmd->param_value);
1408 break;
1409 case GEN_PARAM_RESET_TSF_GPIO:
1410 ret = wma_reset_tsf_gpio(wma, privcmd->param_value);
1411 break;
1412 default:
1413 ret = wma_set_tsf_auto_report(wma,
1414 privcmd->param_vdev_id,
1415 privcmd->param_id,
1416 privcmd->param_value);
1417 if (ret == QDF_STATUS_E_FAILURE)
1418 wma_err("Invalid param id 0x%x",
1419 privcmd->param_id);
1420 break;
1421 }
1422 break;
1423 }
1424 case DBG_CMD:
1425 wma_debug("dbg pid %d pval %d", privcmd->param_id,
1426 privcmd->param_value);
1427 switch (privcmd->param_id) {
1428 case WMI_DBGLOG_LOG_LEVEL:
1429 ret = dbglog_set_log_lvl(wma->wmi_handle,
1430 privcmd->param_value);
1431 if (ret)
1432 wma_err("dbglog_set_log_lvl failed ret %d",
1433 ret);
1434 break;
1435 case WMI_DBGLOG_VAP_ENABLE:
1436 ret = dbglog_vap_log_enable(wma->wmi_handle,
1437 privcmd->param_value, true);
1438 if (ret)
1439 wma_err("dbglog_vap_log_enable failed ret %d",
1440 ret);
1441 break;
1442 case WMI_DBGLOG_VAP_DISABLE:
1443 ret = dbglog_vap_log_enable(wma->wmi_handle,
1444 privcmd->param_value, false);
1445 if (ret)
1446 wma_err("dbglog_vap_log_enable failed ret %d",
1447 ret);
1448 break;
1449 case WMI_DBGLOG_MODULE_ENABLE:
1450 ret = dbglog_module_log_enable(wma->wmi_handle,
1451 privcmd->param_value, true);
1452 if (ret)
1453 wma_err("dbglog_module_log_enable failed ret %d",
1454 ret);
1455 break;
1456 case WMI_DBGLOG_MODULE_DISABLE:
1457 ret = dbglog_module_log_enable(wma->wmi_handle,
1458 privcmd->param_value, false);
1459 if (ret)
1460 wma_err("dbglog_module_log_enable failed ret %d",
1461 ret);
1462 break;
1463 case WMI_DBGLOG_MOD_LOG_LEVEL:
1464 ret = dbglog_set_mod_log_lvl(wma->wmi_handle,
1465 privcmd->param_value);
1466 if (ret)
1467 wma_err("dbglog_module_log_enable failed ret %d",
1468 ret);
1469 break;
1470 case WMI_DBGLOG_MOD_WOW_LOG_LEVEL:
1471 ret = dbglog_set_mod_wow_log_lvl(wma->wmi_handle,
1472 privcmd->param_value);
1473 if (ret)
1474 wma_err("WMI_DBGLOG_MOD_WOW_LOG_LEVEL failed ret %d",
1475 ret);
1476 break;
1477 case WMI_DBGLOG_TYPE:
1478 ret = dbglog_parser_type_init(wma->wmi_handle,
1479 privcmd->param_value);
1480 if (ret)
1481 wma_err("dbglog_parser_type_init failed ret %d",
1482 ret);
1483 break;
1484 case WMI_DBGLOG_REPORT_ENABLE:
1485 ret = dbglog_report_enable(wma->wmi_handle,
1486 privcmd->param_value);
1487 if (ret)
1488 wma_err("dbglog_report_enable failed ret %d",
1489 ret);
1490 break;
1491 case WMI_WLAN_PROFILE_TRIGGER_CMDID:
1492 ret = wma_unified_fw_profiling_cmd(wma->wmi_handle,
1493 WMI_WLAN_PROFILE_TRIGGER_CMDID,
1494 privcmd->param_value, 0);
1495 if (ret)
1496 wma_err("Profile cmd failed for %d ret %d",
1497 WMI_WLAN_PROFILE_TRIGGER_CMDID, ret);
1498 break;
1499 case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID:
1500 ret = wma_unified_fw_profiling_cmd(wma->wmi_handle,
1501 WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
1502 privcmd->param_value,
1503 privcmd->param_sec_value);
1504 if (ret)
1505 wma_err("Profile cmd failed for %d ret %d",
1506 WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID,
1507 ret);
1508 break;
1509 case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID:
1510 ret = wma_unified_fw_profiling_cmd(wma->wmi_handle,
1511 WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
1512 privcmd->param_value,
1513 privcmd->param_sec_value);
1514 if (ret)
1515 wma_err("Profile cmd failed for %d ret %d",
1516 WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID,
1517 ret);
1518 break;
1519 case WMI_WLAN_PROFILE_LIST_PROFILE_ID_CMDID:
1520 ret = wma_unified_fw_profiling_cmd(wma->wmi_handle,
1521 WMI_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
1522 0, 0);
1523 if (ret)
1524 wma_err("Profile cmd failed for %d ret %d",
1525 WMI_WLAN_PROFILE_LIST_PROFILE_ID_CMDID,
1526 ret);
1527 break;
1528 case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID:
1529 ret = wma_unified_fw_profiling_cmd(wma->wmi_handle,
1530 WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
1531 0, 0);
1532 if (ret)
1533 wma_err("Profile cmd failed for %d ret %d",
1534 WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID,
1535 ret);
1536 break;
1537 case WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID:
1538 /* Set the Green AP */
1539 ret = wmi_unified_green_ap_ps_send
1540 (wma->wmi_handle, privcmd->param_value,
1541 WMA_WILDCARD_PDEV_ID);
1542 if (ret) {
1543 wma_err("Set GreenAP Failed val %d",
1544 privcmd->param_value);
1545 }
1546 break;
1547
1548 default:
1549 wma_err("Invalid param id 0x%x", privcmd->param_id);
1550 break;
1551 }
1552 break;
1553 case PPS_CMD:
1554 wma_debug("dbg pid %d pval %d", privcmd->param_id,
1555 privcmd->param_value);
1556 switch (privcmd->param_id) {
1557
1558 case WMI_VDEV_PPS_PAID_MATCH:
1559 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1560 (PKT_PWR_SAVE_PAID_MATCH & 0xffff);
1561 intr[vid].config.pps_params.paid_match_enable =
1562 privcmd->param_value;
1563 break;
1564 case WMI_VDEV_PPS_GID_MATCH:
1565 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1566 (PKT_PWR_SAVE_GID_MATCH & 0xffff);
1567 intr[vid].config.pps_params.gid_match_enable =
1568 privcmd->param_value;
1569 break;
1570 case WMI_VDEV_PPS_EARLY_TIM_CLEAR:
1571 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1572 (PKT_PWR_SAVE_EARLY_TIM_CLEAR & 0xffff);
1573 intr[vid].config.pps_params.tim_clear =
1574 privcmd->param_value;
1575 break;
1576 case WMI_VDEV_PPS_EARLY_DTIM_CLEAR:
1577 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1578 (PKT_PWR_SAVE_EARLY_DTIM_CLEAR & 0xffff);
1579 intr[vid].config.pps_params.dtim_clear =
1580 privcmd->param_value;
1581 break;
1582 case WMI_VDEV_PPS_EOF_PAD_DELIM:
1583 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1584 (PKT_PWR_SAVE_EOF_PAD_DELIM & 0xffff);
1585 intr[vid].config.pps_params.eof_delim =
1586 privcmd->param_value;
1587 break;
1588 case WMI_VDEV_PPS_MACADDR_MISMATCH:
1589 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1590 (PKT_PWR_SAVE_MACADDR_MISMATCH & 0xffff);
1591 intr[vid].config.pps_params.mac_match =
1592 privcmd->param_value;
1593 break;
1594 case WMI_VDEV_PPS_DELIM_CRC_FAIL:
1595 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1596 (PKT_PWR_SAVE_DELIM_CRC_FAIL & 0xffff);
1597 intr[vid].config.pps_params.delim_fail =
1598 privcmd->param_value;
1599 break;
1600 case WMI_VDEV_PPS_GID_NSTS_ZERO:
1601 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1602 (PKT_PWR_SAVE_GID_NSTS_ZERO & 0xffff);
1603 intr[vid].config.pps_params.nsts_zero =
1604 privcmd->param_value;
1605 break;
1606 case WMI_VDEV_PPS_RSSI_CHECK:
1607 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1608 (PKT_PWR_SAVE_RSSI_CHECK & 0xffff);
1609 intr[vid].config.pps_params.rssi_chk =
1610 privcmd->param_value;
1611 break;
1612 case WMI_VDEV_PPS_5G_EBT:
1613 pps_val = ((privcmd->param_value << 31) & 0xffff0000) |
1614 (PKT_PWR_SAVE_5G_EBT & 0xffff);
1615 intr[vid].config.pps_params.ebt_5g =
1616 privcmd->param_value;
1617 break;
1618 default:
1619 wma_err("Invalid param id 0x%x", privcmd->param_id);
1620 break;
1621 }
1622 break;
1623
1624 case QPOWER_CMD:
1625 wma_debug("QPOWER CLI CMD pid %d pval %d", privcmd->param_id,
1626 privcmd->param_value);
1627 switch (privcmd->param_id) {
1628 case WMI_STA_PS_PARAM_QPOWER_PSPOLL_COUNT:
1629 wma_debug("QPOWER CLI CMD:Ps Poll Cnt val %d",
1630 privcmd->param_value);
1631 /* Set the QPower Ps Poll Count */
1632 ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
1633 vid, WMI_STA_PS_PARAM_QPOWER_PSPOLL_COUNT,
1634 privcmd->param_value);
1635 if (ret) {
1636 wma_err("Set Q-PsPollCnt Failed vdevId %d val %d",
1637 vid, privcmd->param_value);
1638 } else {
1639 qparams->max_ps_poll_cnt = privcmd->param_value;
1640 }
1641 break;
1642 case WMI_STA_PS_PARAM_QPOWER_MAX_TX_BEFORE_WAKE:
1643 wma_debug("QPOWER CLI CMD:Max Tx Before wake val %d",
1644 privcmd->param_value);
1645 /* Set the QPower Max Tx Before Wake */
1646 ret = wma_unified_set_sta_ps_param(wma->wmi_handle,
1647 vid, WMI_STA_PS_PARAM_QPOWER_MAX_TX_BEFORE_WAKE,
1648 privcmd->param_value);
1649 if (ret) {
1650 wma_err("Set Q-MaxTxBefWake Failed vId %d val %d",
1651 vid, privcmd->param_value);
1652 } else {
1653 qparams->max_tx_before_wake =
1654 privcmd->param_value;
1655 }
1656 break;
1657 case WMI_STA_PS_PARAM_QPOWER_SPEC_PSPOLL_WAKE_INTERVAL:
1658 wma_debug("QPOWER CLI CMD:Ps Poll Wake Inv val %d",
1659 privcmd->param_value);
1660 /* Set the QPower Spec Ps Poll Wake Inv */
1661 ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vid,
1662 WMI_STA_PS_PARAM_QPOWER_SPEC_PSPOLL_WAKE_INTERVAL,
1663 privcmd->param_value);
1664 if (ret) {
1665 wma_err("Set Q-PsPoll WakeIntv Failed vId %d val %d",
1666 vid, privcmd->param_value);
1667 } else {
1668 qparams->spec_ps_poll_wake_interval =
1669 privcmd->param_value;
1670 }
1671 break;
1672 case WMI_STA_PS_PARAM_QPOWER_SPEC_MAX_SPEC_NODATA_PSPOLL:
1673 wma_debug("QPOWER CLI CMD:Spec NoData Ps Poll val %d",
1674 privcmd->param_value);
1675 /* Set the QPower Spec NoData PsPoll */
1676 ret = wma_unified_set_sta_ps_param(wma->wmi_handle, vid,
1677 WMI_STA_PS_PARAM_QPOWER_SPEC_MAX_SPEC_NODATA_PSPOLL,
1678 privcmd->param_value);
1679 if (ret) {
1680 wma_err("Set Q-SpecNoDataPsPoll Failed vId %d val %d",
1681 vid, privcmd->param_value);
1682 } else {
1683 qparams->max_spec_nodata_ps_poll =
1684 privcmd->param_value;
1685 }
1686 break;
1687
1688 default:
1689 wma_err("Invalid param id 0x%x", privcmd->param_id);
1690 break;
1691 }
1692 break;
1693 case GTX_CMD:
1694 wma_debug("vdev id %d pid %d pval %d", privcmd->param_vdev_id,
1695 privcmd->param_id, privcmd->param_value);
1696 switch (privcmd->param_id) {
1697 case wmi_vdev_param_gtx_ht_mcs:
1698 intr[vid].config.gtx_info.gtxRTMask[0] =
1699 privcmd->param_value;
1700 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1701 privcmd->param_vdev_id,
1702 &intr[vid].config.gtx_info);
1703 break;
1704 case wmi_vdev_param_gtx_vht_mcs:
1705 intr[vid].config.gtx_info.gtxRTMask[1] =
1706 privcmd->param_value;
1707 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1708 privcmd->param_vdev_id,
1709 &intr[vid].config.gtx_info);
1710 break;
1711
1712 case wmi_vdev_param_gtx_usr_cfg:
1713 intr[vid].config.gtx_info.gtxUsrcfg =
1714 privcmd->param_value;
1715 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1716 privcmd->param_vdev_id,
1717 &intr[vid].config.gtx_info);
1718 break;
1719
1720 case wmi_vdev_param_gtx_thre:
1721 intr[vid].config.gtx_info.gtxPERThreshold =
1722 privcmd->param_value;
1723 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1724 privcmd->param_vdev_id,
1725 &intr[vid].config.gtx_info);
1726 break;
1727
1728 case wmi_vdev_param_gtx_margin:
1729 intr[vid].config.gtx_info.gtxPERMargin =
1730 privcmd->param_value;
1731 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1732 privcmd->param_vdev_id,
1733 &intr[vid].config.gtx_info);
1734 break;
1735
1736 case wmi_vdev_param_gtx_step:
1737 intr[vid].config.gtx_info.gtxTPCstep =
1738 privcmd->param_value;
1739 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1740 privcmd->param_vdev_id,
1741 &intr[vid].config.gtx_info);
1742 break;
1743
1744 case wmi_vdev_param_gtx_mintpc:
1745 intr[vid].config.gtx_info.gtxTPCMin =
1746 privcmd->param_value;
1747 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1748 privcmd->param_vdev_id,
1749 &intr[vid].config.gtx_info);
1750 break;
1751
1752 case wmi_vdev_param_gtx_bw_mask:
1753 intr[vid].config.gtx_info.gtxBWMask =
1754 privcmd->param_value;
1755 ret = wmi_unified_vdev_set_gtx_cfg_send(wma->wmi_handle,
1756 privcmd->param_vdev_id,
1757 &intr[vid].config.gtx_info);
1758 if (ret) {
1759 wma_err("wma_vdev_set_param failed ret %d",
1760 ret);
1761 return;
1762 }
1763 break;
1764 default:
1765 break;
1766 }
1767 break;
1768
1769 default:
1770 wma_err("Invalid vpdev command id");
1771 }
1772 if (1 == privcmd->param_vp_dev) {
1773 switch (privcmd->param_id) {
1774 case wmi_vdev_param_nss:
1775 intr[vid].config.nss = privcmd->param_value;
1776 break;
1777 case wmi_vdev_param_ldpc:
1778 intr[vid].config.ldpc = privcmd->param_value;
1779 break;
1780 case wmi_vdev_param_tx_stbc:
1781 intr[vid].config.tx_stbc = privcmd->param_value;
1782 break;
1783 case wmi_vdev_param_rx_stbc:
1784 intr[vid].config.rx_stbc = privcmd->param_value;
1785 break;
1786 case wmi_vdev_param_sgi:
1787 intr[vid].config.shortgi = privcmd->param_value;
1788 break;
1789 case wmi_vdev_param_enable_rtscts:
1790 intr[vid].config.rtscts_en = privcmd->param_value;
1791 break;
1792 case wmi_vdev_param_chwidth:
1793 intr[vid].config.chwidth = privcmd->param_value;
1794 break;
1795 case wmi_vdev_param_fixed_rate:
1796 intr[vid].config.tx_rate = privcmd->param_value;
1797 break;
1798 case wmi_vdev_param_early_rx_adjust_enable:
1799 intr[vid].config.erx_adjust = privcmd->param_value;
1800 break;
1801 case wmi_vdev_param_early_rx_tgt_bmiss_num:
1802 intr[vid].config.erx_bmiss_num = privcmd->param_value;
1803 break;
1804 case wmi_vdev_param_early_rx_bmiss_sample_cycle:
1805 intr[vid].config.erx_bmiss_cycle = privcmd->param_value;
1806 break;
1807 case wmi_vdev_param_early_rx_slop_step:
1808 intr[vid].config.erx_slop_step = privcmd->param_value;
1809 break;
1810 case wmi_vdev_param_early_rx_init_slop:
1811 intr[vid].config.erx_init_slop = privcmd->param_value;
1812 break;
1813 case wmi_vdev_param_early_rx_adjust_pause:
1814 intr[vid].config.erx_adj_pause = privcmd->param_value;
1815 break;
1816 case wmi_vdev_param_early_rx_drift_sample:
1817 intr[vid].config.erx_dri_sample = privcmd->param_value;
1818 break;
1819 case wmi_vdev_param_he_dcm_enable:
1820 case wmi_vdev_param_he_range_ext:
1821 wma_set_he_vdev_param(&intr[vid], privcmd->param_id,
1822 privcmd->param_value);
1823 break;
1824 default:
1825 wma_debug("vdev cmd is not part vdev_cli_config 0x%x",
1826 privcmd->param_id);
1827 break;
1828 }
1829 } else if (2 == privcmd->param_vp_dev) {
1830 switch (privcmd->param_id) {
1831 case wmi_pdev_param_ani_enable:
1832 wma->pdevconfig.ani_enable = privcmd->param_value;
1833 break;
1834 case wmi_pdev_param_ani_poll_period:
1835 wma->pdevconfig.ani_poll_len = privcmd->param_value;
1836 break;
1837 case wmi_pdev_param_ani_listen_period:
1838 wma->pdevconfig.ani_listen_len = privcmd->param_value;
1839 break;
1840 case wmi_pdev_param_ani_ofdm_level:
1841 wma->pdevconfig.ani_ofdm_level = privcmd->param_value;
1842 break;
1843 case wmi_pdev_param_ani_cck_level:
1844 wma->pdevconfig.ani_cck_level = privcmd->param_value;
1845 break;
1846 case wmi_pdev_param_dynamic_bw:
1847 wma->pdevconfig.cwmenable = privcmd->param_value;
1848 break;
1849 case wmi_pdev_param_cts_cbw:
1850 wma->pdevconfig.cts_cbw = privcmd->param_value;
1851 break;
1852 case wmi_pdev_param_tx_chain_mask:
1853 wma->pdevconfig.txchainmask = privcmd->param_value;
1854 break;
1855 case wmi_pdev_param_rx_chain_mask:
1856 wma->pdevconfig.rxchainmask = privcmd->param_value;
1857 break;
1858 case wmi_pdev_param_txpower_limit2g:
1859 wma->pdevconfig.txpow2g = privcmd->param_value;
1860 if (mac->mlme_cfg->gen.band_capability & BIT(REG_BAND_2G))
1861 mac->mlme_cfg->power.current_tx_power_level =
1862 (uint8_t)privcmd->param_value;
1863 else
1864 wma_err("Current band is not 2G");
1865 break;
1866 case wmi_pdev_param_txpower_limit5g:
1867 wma->pdevconfig.txpow5g = privcmd->param_value;
1868 if (mac->mlme_cfg->gen.band_capability & BIT(REG_BAND_5G))
1869 mac->mlme_cfg->power.current_tx_power_level =
1870 (uint8_t)privcmd->param_value;
1871 else
1872 wma_err("Current band is not 5G");
1873 break;
1874 default:
1875 wma_debug("Invalid wma_cli_set pdev command/Not yet implemented 0x%x",
1876 privcmd->param_id);
1877 break;
1878 }
1879 } else if (5 == privcmd->param_vp_dev) {
1880 ret = wma_vdev_set_param(wma->wmi_handle,
1881 privcmd->param_vdev_id,
1882 wmi_vdev_param_packet_powersave,
1883 pps_val);
1884 if (ret)
1885 wma_err("Failed to send wmi packet power save cmd");
1886 else
1887 wma_debug("Sent packet power save cmd %d value %x to target",
1888 privcmd->param_id, pps_val);
1889 }
1890 }
1891
wma_critical_events_in_flight(void)1892 uint32_t wma_critical_events_in_flight(void)
1893 {
1894 t_wma_handle *wma;
1895
1896 wma = cds_get_context(QDF_MODULE_ID_WMA);
1897 if (!wma)
1898 return 0;
1899
1900 if (wmi_validate_handle(wma->wmi_handle))
1901 return 0;
1902
1903 return wmi_critical_events_in_flight(wma->wmi_handle);
1904 }
1905
1906 /**
1907 * wma_process_hal_pwr_dbg_cmd() - send hal pwr dbg cmd to fw.
1908 * @handle: wma handle
1909 * @sir_pwr_dbg_params: unit test command
1910 *
1911 * This function send unit test command to fw.
1912 *
1913 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
1914 */
wma_process_hal_pwr_dbg_cmd(WMA_HANDLE handle,struct sir_mac_pwr_dbg_cmd * sir_pwr_dbg_params)1915 QDF_STATUS wma_process_hal_pwr_dbg_cmd(WMA_HANDLE handle,
1916 struct sir_mac_pwr_dbg_cmd *
1917 sir_pwr_dbg_params)
1918 {
1919 tp_wma_handle wma_handle = (tp_wma_handle)handle;
1920 int i;
1921 struct wmi_power_dbg_params wmi_pwr_dbg_params;
1922 QDF_STATUS status;
1923
1924 if (!sir_pwr_dbg_params) {
1925 wma_err("sir_pwr_dbg_params is null");
1926 return QDF_STATUS_E_INVAL;
1927 }
1928 wmi_pwr_dbg_params.module_id = sir_pwr_dbg_params->module_id;
1929 wmi_pwr_dbg_params.pdev_id = sir_pwr_dbg_params->pdev_id;
1930 wmi_pwr_dbg_params.num_args = sir_pwr_dbg_params->num_args;
1931
1932 for (i = 0; i < wmi_pwr_dbg_params.num_args; i++)
1933 wmi_pwr_dbg_params.args[i] = sir_pwr_dbg_params->args[i];
1934
1935 status = wmi_unified_send_power_dbg_cmd(wma_handle->wmi_handle,
1936 &wmi_pwr_dbg_params);
1937
1938 return status;
1939 }
1940
wma_discard_fw_event(struct scheduler_msg * msg)1941 static QDF_STATUS wma_discard_fw_event(struct scheduler_msg *msg)
1942 {
1943 if (!msg->bodyptr)
1944 return QDF_STATUS_E_INVAL;
1945
1946 qdf_mem_free(msg->bodyptr);
1947 msg->bodyptr = NULL;
1948 msg->bodyval = 0;
1949 msg->type = 0;
1950
1951 return QDF_STATUS_SUCCESS;
1952 }
1953
1954 QDF_STATUS
wma_vdev_nss_chain_params_send(uint8_t vdev_id,struct wlan_mlme_nss_chains * user_cfg)1955 wma_vdev_nss_chain_params_send(uint8_t vdev_id,
1956 struct wlan_mlme_nss_chains *user_cfg)
1957 {
1958 tp_wma_handle wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
1959 struct vdev_nss_chains vdev_user_cfg;
1960 if (!wma_handle)
1961 return QDF_STATUS_E_FAILURE;
1962
1963 vdev_user_cfg.disable_rx_mrc[NSS_CHAINS_BAND_2GHZ] =
1964 user_cfg->disable_rx_mrc[NSS_CHAINS_BAND_2GHZ];
1965 vdev_user_cfg.disable_tx_mrc[NSS_CHAINS_BAND_2GHZ] =
1966 user_cfg->disable_tx_mrc[NSS_CHAINS_BAND_2GHZ];
1967 vdev_user_cfg.disable_rx_mrc[NSS_CHAINS_BAND_5GHZ] =
1968 user_cfg->disable_rx_mrc[NSS_CHAINS_BAND_5GHZ];
1969 vdev_user_cfg.disable_tx_mrc[NSS_CHAINS_BAND_5GHZ] =
1970 user_cfg->disable_tx_mrc[NSS_CHAINS_BAND_5GHZ];
1971
1972 vdev_user_cfg.num_rx_chains[NSS_CHAINS_BAND_2GHZ]
1973 = user_cfg->num_rx_chains[NSS_CHAINS_BAND_2GHZ];
1974 vdev_user_cfg.num_tx_chains[NSS_CHAINS_BAND_2GHZ]
1975 = user_cfg->num_tx_chains[NSS_CHAINS_BAND_2GHZ];
1976 vdev_user_cfg.num_rx_chains[NSS_CHAINS_BAND_5GHZ] =
1977 user_cfg->num_rx_chains[NSS_CHAINS_BAND_5GHZ];
1978 vdev_user_cfg.num_tx_chains[NSS_CHAINS_BAND_5GHZ] =
1979 user_cfg->num_tx_chains[NSS_CHAINS_BAND_5GHZ];
1980
1981 vdev_user_cfg.rx_nss[NSS_CHAINS_BAND_2GHZ] =
1982 user_cfg->rx_nss[NSS_CHAINS_BAND_2GHZ];
1983 vdev_user_cfg.tx_nss[NSS_CHAINS_BAND_2GHZ] =
1984 user_cfg->tx_nss[NSS_CHAINS_BAND_2GHZ];
1985 vdev_user_cfg.rx_nss[NSS_CHAINS_BAND_5GHZ] =
1986 user_cfg->rx_nss[NSS_CHAINS_BAND_5GHZ];
1987 vdev_user_cfg.tx_nss[NSS_CHAINS_BAND_5GHZ] =
1988 user_cfg->tx_nss[NSS_CHAINS_BAND_5GHZ];
1989
1990 vdev_user_cfg.num_tx_chains_11a = user_cfg->num_tx_chains_11a;
1991 vdev_user_cfg.num_tx_chains_11b = user_cfg->num_tx_chains_11b;
1992 vdev_user_cfg.num_tx_chains_11g = user_cfg->num_tx_chains_11g;
1993
1994 return wmi_unified_vdev_nss_chain_params_send(wma_handle->wmi_handle,
1995 vdev_id,
1996 &vdev_user_cfg);
1997 }
1998
1999 /**
2000 * wma_antenna_isolation_event_handler() - antenna isolation event handler
2001 * @handle: wma handle
2002 * @param: event data
2003 * @len: length
2004 *
2005 * Return: 0 for success or error code
2006 */
wma_antenna_isolation_event_handler(void * handle,u8 * param,u32 len)2007 static int wma_antenna_isolation_event_handler(void *handle,
2008 u8 *param,
2009 u32 len)
2010 {
2011 struct scheduler_msg cds_msg = {0};
2012 wmi_coex_report_isolation_event_fixed_param *event;
2013 WMI_COEX_REPORT_ANTENNA_ISOLATION_EVENTID_param_tlvs *param_buf;
2014 struct sir_isolation_resp *pisolation;
2015 struct mac_context *mac = NULL;
2016
2017 wma_debug("handle %pK param %pK len %d", handle, param, len);
2018
2019 mac = (struct mac_context *)cds_get_context(QDF_MODULE_ID_PE);
2020 if (!mac) {
2021 wma_err("Invalid mac context");
2022 return -EINVAL;
2023 }
2024
2025 pisolation = qdf_mem_malloc(sizeof(*pisolation));
2026 if (!pisolation)
2027 return 0;
2028
2029 param_buf =
2030 (WMI_COEX_REPORT_ANTENNA_ISOLATION_EVENTID_param_tlvs *)param;
2031 if (!param_buf) {
2032 wma_err("Invalid isolation event");
2033 return -EINVAL;
2034 }
2035 event = param_buf->fixed_param;
2036 pisolation->isolation_chain0 = event->isolation_chain0;
2037 pisolation->isolation_chain1 = event->isolation_chain1;
2038 pisolation->isolation_chain2 = event->isolation_chain2;
2039 pisolation->isolation_chain3 = event->isolation_chain3;
2040
2041 wma_debug("chain1 %d chain2 %d chain3 %d chain4 %d",
2042 pisolation->isolation_chain0, pisolation->isolation_chain1,
2043 pisolation->isolation_chain2, pisolation->isolation_chain3);
2044
2045 cds_msg.type = eWNI_SME_ANTENNA_ISOLATION_RSP;
2046 cds_msg.bodyptr = pisolation;
2047 cds_msg.bodyval = 0;
2048 if (QDF_STATUS_SUCCESS !=
2049 scheduler_post_message(QDF_MODULE_ID_WMA,
2050 QDF_MODULE_ID_SME,
2051 QDF_MODULE_ID_SME, &cds_msg)) {
2052 wma_err("could not post peer info rsp msg to SME");
2053 /* free the mem and return */
2054 qdf_mem_free(pisolation);
2055 }
2056
2057 return 0;
2058 }
2059
2060 /**
2061 * wma_init_max_no_of_peers - API to initialize wma configuration params
2062 * @wma_handle: WMA Handle
2063 * @max_peers: Max Peers supported
2064 *
2065 * Return: void
2066 */
wma_init_max_no_of_peers(tp_wma_handle wma_handle,uint16_t max_peers)2067 static uint8_t wma_init_max_no_of_peers(tp_wma_handle wma_handle,
2068 uint16_t max_peers)
2069 {
2070 struct wma_ini_config *cfg = wma_get_ini_handle(wma_handle);
2071 struct hif_opaque_softc *scn = cds_get_context(QDF_MODULE_ID_HIF);
2072 uint32_t tgt_version = hif_get_target_info_handle(scn)->target_version;
2073 uint8_t max_no_of_peers;
2074 uint8_t max_supported_peers;
2075
2076 if (!cfg) {
2077 wma_err("NULL WMA ini handle");
2078 return 0;
2079 }
2080
2081 switch (tgt_version) {
2082 case AR6320_REV1_1_VERSION:
2083 max_supported_peers = MAX_SUPPORTED_PEERS_REV1_1;
2084 break;
2085 case AR6320_REV1_3_VERSION:
2086 max_supported_peers = MAX_SUPPORTED_PEERS_REV1_3;
2087 break;
2088 default:
2089 max_supported_peers = MAX_SUPPORTED_PEERS;
2090 break;
2091 }
2092 max_no_of_peers = (max_peers > max_supported_peers) ?
2093 max_supported_peers : max_peers;
2094 cfg->max_no_of_peers = max_no_of_peers;
2095
2096 return max_no_of_peers;
2097 }
2098
2099 /**
2100 * wma_cleanup_hold_req() - cleanup hold request queue
2101 * @wma: wma handle
2102 *
2103 * Return: none
2104 */
wma_cleanup_hold_req(tp_wma_handle wma)2105 static void wma_cleanup_hold_req(tp_wma_handle wma)
2106 {
2107 struct wma_target_req *req_msg = NULL;
2108 qdf_list_node_t *node1 = NULL;
2109
2110 qdf_spin_lock_bh(&wma->wma_hold_req_q_lock);
2111 if (!qdf_list_size(&wma->wma_hold_req_queue)) {
2112 qdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
2113 wma_debug("request queue is empty");
2114 return;
2115 }
2116
2117 /* peek front, and then cleanup it in wma_hold_req_timer */
2118 while (QDF_STATUS_SUCCESS ==
2119 qdf_list_peek_front(&wma->wma_hold_req_queue, &node1)) {
2120 req_msg = qdf_container_of(node1, struct wma_target_req, node);
2121 qdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
2122 /* Cleanup timeout handler */
2123 qdf_mc_timer_stop(&req_msg->event_timeout);
2124 wma_hold_req_timer(req_msg);
2125 qdf_spin_lock_bh(&wma->wma_hold_req_q_lock);
2126 }
2127 qdf_spin_unlock_bh(&wma->wma_hold_req_q_lock);
2128 }
2129
2130 /**
2131 * wma_cleanup_vdev_resp_and_hold_req() - cleaunup the vdev resp and hold req
2132 * queue
2133 * @msg :scheduler msg
2134 *
2135 * Return: QDF_STATUS
2136 */
2137 static QDF_STATUS
wma_cleanup_vdev_resp_and_hold_req(struct scheduler_msg * msg)2138 wma_cleanup_vdev_resp_and_hold_req(struct scheduler_msg *msg)
2139 {
2140 tp_wma_handle wma;
2141
2142 if (!msg || !msg->bodyptr) {
2143 wma_err("msg or body pointer is NULL");
2144 return QDF_STATUS_E_INVAL;
2145 }
2146
2147 wma = msg->bodyptr;
2148 target_if_flush_psoc_vdev_timers(wma->psoc);
2149 wma_cleanup_hold_req(wma);
2150
2151 return QDF_STATUS_SUCCESS;
2152 }
2153
2154 /**
2155 * wma_cleanup_vdev_resp_and_hold_req_flush_cb() - flush cb for the msg to clean
2156 * up vdev resp and hold req
2157 * @msg :scheduler msg
2158 *
2159 * As passed msg->bodyptr is wma in this case this is dummy flush cb so that
2160 * driver doesn't try to free msg->bodyptr when this msg is flushed.
2161 *
2162 * Return: QDF_STATUS
2163 */
2164 static inline QDF_STATUS
wma_cleanup_vdev_resp_and_hold_req_flush_cb(struct scheduler_msg * msg)2165 wma_cleanup_vdev_resp_and_hold_req_flush_cb(struct scheduler_msg *msg)
2166 {
2167 return QDF_STATUS_SUCCESS;
2168 }
2169
2170 /**
2171 * wma_shutdown_notifier_cb - Shutdown notifier call back
2172 * @priv : WMA handle
2173 *
2174 * During recovery, WMA may wait for resume to complete if the crash happens
2175 * while in suspend. This may cause delays in completing the recovery. This call
2176 * back would be called during recovery and the event is completed so that if
2177 * the resume is waiting on FW to respond then it can get out of the wait so
2178 * that recovery thread can start bringing down all the modules.
2179 *
2180 * Return: None
2181 */
wma_shutdown_notifier_cb(void * priv)2182 static void wma_shutdown_notifier_cb(void *priv)
2183 {
2184 tp_wma_handle wma_handle = priv;
2185 struct scheduler_msg msg = { 0 };
2186 QDF_STATUS status;
2187
2188 ucfg_pmo_psoc_wakeup_host_event_received(wma_handle->psoc);
2189 wmi_stop(wma_handle->wmi_handle);
2190
2191 msg.bodyptr = wma_handle;
2192 msg.callback = wma_cleanup_vdev_resp_and_hold_req;
2193 msg.flush_callback = wma_cleanup_vdev_resp_and_hold_req_flush_cb;
2194 status = scheduler_post_message(QDF_MODULE_ID_WMA,
2195 QDF_MODULE_ID_WMA,
2196 QDF_MODULE_ID_TARGET_IF, &msg);
2197 }
2198
2199 struct wma_version_info g_wmi_version_info;
2200
2201 #ifdef WLAN_FEATURE_MEMDUMP_ENABLE
2202 /**
2203 * wma_state_info_dump() - prints state information of wma layer
2204 * @buf_ptr: buffer pointer
2205 * @size: size of buffer to be filled
2206 *
2207 * This function is used to dump state information of wma layer
2208 *
2209 * Return: None
2210 */
wma_state_info_dump(char ** buf_ptr,uint16_t * size)2211 static void wma_state_info_dump(char **buf_ptr, uint16_t *size)
2212 {
2213 uint8_t vdev_id;
2214 uint16_t len = 0;
2215 t_wma_handle *wma;
2216 char *buf = *buf_ptr;
2217 struct wma_txrx_node *iface;
2218 struct wake_lock_stats stats;
2219 struct wlan_objmgr_vdev *vdev;
2220 uint32_t rate_flag;
2221 QDF_STATUS status;
2222
2223 wma = cds_get_context(QDF_MODULE_ID_WMA);
2224 if (!wma)
2225 return;
2226
2227 wma_debug("size of buffer: %d", *size);
2228
2229 for (vdev_id = 0; vdev_id < wma->max_bssid; vdev_id++) {
2230 iface = &wma->interfaces[vdev_id];
2231 vdev = iface->vdev;
2232 if (!vdev)
2233 continue;
2234
2235 status = wma_get_vdev_rate_flag(iface->vdev, &rate_flag);
2236 if (QDF_IS_STATUS_ERROR(status))
2237 continue;
2238
2239 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(wma->psoc,
2240 vdev_id, WLAN_LEGACY_WMA_ID);
2241 if (!vdev)
2242 continue;
2243 ucfg_mc_cp_stats_get_vdev_wake_lock_stats(vdev, &stats);
2244 len += qdf_scnprintf(buf + len, *size - len,
2245 "\n"
2246 "vdev_id %d\n"
2247 "WoW Stats\n"
2248 "\tpno_match %u\n"
2249 "\tpno_complete %u\n"
2250 "\tgscan %u\n"
2251 "\tlow_rssi %u\n"
2252 "\trssi_breach %u\n"
2253 "\tucast %u\n"
2254 "\tbcast %u\n"
2255 "\ticmpv4 %u\n"
2256 "\ticmpv6 %u\n"
2257 "\tipv4_mcast %u\n"
2258 "\tipv6_mcast %u\n"
2259 "\tipv6_mcast_ra %u\n"
2260 "\tipv6_mcast_ns %u\n"
2261 "\tipv6_mcast_na %u\n"
2262 "\toem_response %u\n"
2263 "\tuc_drop %u\n"
2264 "\tfatal_event %u\n"
2265 "dtimPeriod %d\n"
2266 "chan_width %d\n"
2267 "vdev_active %d\n"
2268 "vdev_up %d\n"
2269 "aid %d\n"
2270 "rate_flags %d\n"
2271 "nss %d\n"
2272 "nwType %d\n"
2273 "tx_streams %d",
2274 vdev_id,
2275 stats.pno_match_wake_up_count,
2276 stats.pno_complete_wake_up_count,
2277 stats.gscan_wake_up_count,
2278 stats.low_rssi_wake_up_count,
2279 stats.rssi_breach_wake_up_count,
2280 stats.ucast_wake_up_count,
2281 stats.bcast_wake_up_count,
2282 stats.icmpv4_count,
2283 stats.icmpv6_count,
2284 stats.ipv4_mcast_wake_up_count,
2285 stats.ipv6_mcast_wake_up_count,
2286 stats.ipv6_mcast_ra_stats,
2287 stats.ipv6_mcast_ns_stats,
2288 stats.ipv6_mcast_na_stats,
2289 stats.oem_response_wake_up_count,
2290 stats.uc_drop_wake_up_count,
2291 stats.fatal_event_wake_up_count,
2292 iface->dtimPeriod,
2293 iface->chan_width,
2294 iface->vdev_active,
2295 wma_is_vdev_up(vdev_id),
2296 iface->aid,
2297 rate_flag,
2298 iface->nss,
2299 iface->nwType,
2300 iface->tx_streams);
2301 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
2302 }
2303
2304 *size -= len;
2305 *buf_ptr += len;
2306 }
2307
2308 /**
2309 * wma_register_debug_callback() - registration function for wma layer
2310 * to print wma state information
2311 */
wma_register_debug_callback(void)2312 static void wma_register_debug_callback(void)
2313 {
2314 qdf_register_debug_callback(QDF_MODULE_ID_WMA, &wma_state_info_dump);
2315 }
2316 #else /* WLAN_FEATURE_MEMDUMP_ENABLE */
wma_register_debug_callback(void)2317 static void wma_register_debug_callback(void)
2318 {
2319 }
2320 #endif /* WLAN_FEATURE_MEMDUMP_ENABLE */
2321 /**
2322 * wma_register_tx_ops_handler() - register tx_ops of southbound
2323 * @tx_ops: tx_ops pointer in southbound
2324 *
2325 * Return: 0 on success, errno on failure
2326 */
2327 static QDF_STATUS
wma_register_tx_ops_handler(struct wlan_lmac_if_tx_ops * tx_ops)2328 wma_register_tx_ops_handler(struct wlan_lmac_if_tx_ops *tx_ops)
2329 {
2330 /*
2331 * Assign tx_ops, it's up to UMAC modules to declare and define these
2332 * functions which are used to send wmi command to target.
2333 */
2334
2335 if (!tx_ops) {
2336 wma_err("pointer to lmac if tx ops is NULL");
2337 return QDF_STATUS_E_INVAL;
2338 }
2339
2340 /* mgmt_txrx component's tx ops */
2341 tx_ops->mgmt_txrx_tx_ops.mgmt_tx_send = wma_mgmt_unified_cmd_send;
2342
2343 /* mgmt txrx component nbuf op for nbuf dma unmap */
2344 tx_ops->mgmt_txrx_tx_ops.tx_drain_nbuf_op = wma_mgmt_nbuf_unmap_cb;
2345
2346 return QDF_STATUS_SUCCESS;
2347 }
2348
2349 /**
2350 * wma_target_if_open() - Attach UMAC modules' interface with wmi layer
2351 * @wma_handle: wma handle
2352 *
2353 * Separate module defines below functions:
2354 * 1. tgt_wmi_<module>_<action> api sends wmi command, assigned to south bound
2355 * tx_ops function pointers;
2356 * 2. module's south dispatcher handles information from lower layer, assigned
2357 * to south bound rx_ops function pointers;
2358 * 3. wmi event handler deals with wmi event, extracts umac needed information,
2359 * and call rx_ops(module's dispatcher). It executes in tasklet context and
2360 * is up to dispatcher to decide the context to reside in tasklet or in
2361 * thread context.
2362 *
2363 * Return: None
2364 */
wma_target_if_open(tp_wma_handle wma_handle)2365 static void wma_target_if_open(tp_wma_handle wma_handle)
2366 {
2367 struct wlan_objmgr_psoc *psoc = wma_handle->psoc;
2368
2369 if (!psoc)
2370 return;
2371
2372 wlan_global_lmac_if_set_txops_registration_cb(WLAN_DEV_OL,
2373 target_if_register_tx_ops);
2374 wlan_lmac_if_set_umac_txops_registration_cb(
2375 wma_register_tx_ops_handler);
2376 wlan_global_lmac_if_open(psoc);
2377
2378 }
2379
2380 /**
2381 * wma_legacy_service_ready_event_handler() - legacy (ext)service ready handler
2382 * @event_id: event_id
2383 * @handle: wma handle
2384 * @event_data: event data
2385 * @length: event length
2386 *
2387 * Return: 0 for success, negative error code for failure
2388 */
wma_legacy_service_ready_event_handler(uint32_t event_id,void * handle,uint8_t * event_data,uint32_t length)2389 static int wma_legacy_service_ready_event_handler(uint32_t event_id,
2390 void *handle,
2391 uint8_t *event_data,
2392 uint32_t length)
2393 {
2394 switch (event_id) {
2395 case wmi_service_ready_event_id:
2396 return wma_rx_service_ready_event(handle, event_data, length);
2397 case wmi_service_ready_ext_event_id:
2398 return wma_rx_service_ready_ext_event(handle, event_data,
2399 length);
2400 case wmi_ready_event_id:
2401 return wma_rx_ready_event(handle, event_data, length);
2402 case wmi_service_ready_ext2_event_id:
2403 return wma_rx_service_ready_ext2_event(handle, event_data,
2404 length);
2405 default:
2406 wma_err("Legacy callback invoked with invalid event_id:%d",
2407 event_id);
2408 QDF_BUG(0);
2409 }
2410
2411 return 0;
2412 }
2413
2414 #ifdef WLAN_FEATURE_CAL_FAILURE_TRIGGER
2415 /**
2416 * wma_process_cal_fail_info() - Process cal failure event and
2417 * send it to userspace
2418 * @wmi_event: Cal failure event data
2419 */
wma_process_cal_fail_info(uint8_t * wmi_event)2420 static void wma_process_cal_fail_info(uint8_t *wmi_event)
2421 {
2422 struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
2423 uint8_t *buf_ptr;
2424 wmi_debug_mesg_fw_cal_failure_param *cal_failure_event;
2425
2426 if (!mac) {
2427 wma_err("Invalid mac context");
2428 return;
2429 }
2430
2431 if (!mac->cal_failure_event_cb) {
2432 wma_err("Callback not registered for cal failure event");
2433 return;
2434 }
2435
2436 buf_ptr = wmi_event;
2437 buf_ptr = buf_ptr + sizeof(wmi_debug_mesg_flush_complete_fixed_param) +
2438 WMI_TLV_HDR_SIZE +
2439 sizeof(wmi_debug_mesg_fw_data_stall_param) + WMI_TLV_HDR_SIZE;
2440
2441 cal_failure_event = (wmi_debug_mesg_fw_cal_failure_param *)buf_ptr;
2442
2443 if (((cal_failure_event->tlv_header & 0xFFFF0000) >> 16 ==
2444 WMITLV_TAG_STRUC_wmi_debug_mesg_fw_cal_failure_param)) {
2445 /**
2446 * Log calibration failure information received from FW
2447 */
2448 wma_debug("Calibration failure event:");
2449 wma_debug("calType: %x calFailureReasonCode: %x",
2450 cal_failure_event->cal_type,
2451 cal_failure_event->cal_failure_reason_code);
2452 mac->cal_failure_event_cb(
2453 cal_failure_event->cal_type,
2454 cal_failure_event->cal_failure_reason_code);
2455 } else {
2456 wma_err("Invalid TLV header in cal failure event");
2457 }
2458 }
2459 #else
wma_process_cal_fail_info(uint8_t * wmi_event)2460 static inline void wma_process_cal_fail_info(uint8_t *wmi_event)
2461 {
2462 }
2463 #endif
2464
2465 /**
2466 * wma_flush_complete_evt_handler() - FW log flush complete event handler
2467 * @handle: WMI handle
2468 * @event: Event received from FW
2469 * @len: Length of the event
2470 *
2471 */
wma_flush_complete_evt_handler(void * handle,u_int8_t * event,u_int32_t len)2472 static int wma_flush_complete_evt_handler(void *handle,
2473 u_int8_t *event,
2474 u_int32_t len)
2475 {
2476 QDF_STATUS status;
2477 tp_wma_handle wma = (tp_wma_handle) handle;
2478
2479 WMI_DEBUG_MESG_FLUSH_COMPLETE_EVENTID_param_tlvs *param_buf;
2480 wmi_debug_mesg_flush_complete_fixed_param *wmi_event;
2481 wmi_debug_mesg_fw_data_stall_param *data_stall_event;
2482 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
2483 uint8_t *buf_ptr;
2484 uint32_t reason_code;
2485
2486 param_buf = (WMI_DEBUG_MESG_FLUSH_COMPLETE_EVENTID_param_tlvs *) event;
2487 if (!param_buf) {
2488 wma_err("Invalid log flush complete event buffer");
2489 return QDF_STATUS_E_FAILURE;
2490 }
2491
2492 wmi_event = param_buf->fixed_param;
2493 reason_code = wmi_event->reserved0;
2494 wma_debug("Received reason code %d from FW", reason_code);
2495
2496 if (reason_code == WMI_DIAG_TRIGGER_DATA_STALL) {
2497 buf_ptr = (uint8_t *)wmi_event;
2498 buf_ptr = buf_ptr +
2499 sizeof(wmi_debug_mesg_flush_complete_fixed_param) +
2500 WMI_TLV_HDR_SIZE;
2501 data_stall_event =
2502 (wmi_debug_mesg_fw_data_stall_param *)buf_ptr;
2503 }
2504
2505 if (reason_code == WMI_DIAG_TRIGGER_DATA_STALL &&
2506 ((data_stall_event->tlv_header & 0xFFFF0000) >> 16 ==
2507 WMITLV_TAG_STRUC_wmi_debug_mesg_fw_data_stall_param)) {
2508 /**
2509 * Log data stall info received from FW:
2510 *
2511 * Possible data stall recovery types:
2512 * WLAN_DBG_DATA_STALL_RECOVERY_CONNECT_DISCONNECT
2513 * WLAN_DBG_DATA_STALL_RECOVERY_CONNECT_MAC_PHY_RESET
2514 * WLAN_DBG_DATA_STALL_RECOVERY_CONNECT_PDR
2515 *
2516 * Possible data stall event types:
2517 * WLAN_DBG_DATA_STALL_VDEV_PAUSE
2518 * WLAN_DBG_DATA_STALL_HWSCHED_CMD_FILTER
2519 * WLAN_DBG_DATA_STALL_HWSCHED_CMD_FLUSH
2520 * WLAN_DBG_DATA_STALL_RX_REFILL_FAILED
2521 * WLAN_DBG_DATA_STALL_RX_FCS_LEN_ERROR
2522 *
2523 * reason_code1:
2524 * The information stored in reason_code1 varies based on the
2525 * data stall type values:
2526 *
2527 * data_stall_type | reason_code1
2528 * -----------------------------------------------------
2529 * HWSCHED_CMD_FLUSH | flush req reason (0-40)
2530 * RX_REFILL_FAILED | ring_id (0-7)
2531 * RX_FCS_LEN_ERROR | exact error type
2532 *
2533 * reasone_code2:
2534 * on which tid/hwq stall happened
2535 *
2536 */
2537 QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
2538 "Data Stall event:");
2539 QDF_TRACE(QDF_MODULE_ID_WMA, QDF_TRACE_LEVEL_DEBUG,
2540 "data_stall_type: %x vdev_id_bitmap: %x reason_code1: %x reason_code2: %x recovery_type: %x ",
2541 data_stall_event->data_stall_type,
2542 data_stall_event->vdev_id_bitmap,
2543 data_stall_event->reason_code1,
2544 data_stall_event->reason_code2,
2545 data_stall_event->recovery_type);
2546
2547 cdp_post_data_stall_event(soc,
2548 DATA_STALL_LOG_INDICATOR_FIRMWARE,
2549 data_stall_event->data_stall_type,
2550 OL_TXRX_PDEV_ID,
2551 data_stall_event->vdev_id_bitmap,
2552 data_stall_event->recovery_type);
2553 }
2554
2555 if (reason_code == WMI_DIAG_TRIGGER_CAL_FAILURE) {
2556 wma_process_cal_fail_info((uint8_t *)wmi_event);
2557 return QDF_STATUS_SUCCESS;
2558 }
2559
2560 /*
2561 * reason_code = 0; Flush event in response to flush command
2562 * reason_code = other value; Asynchronous flush event for fatal events
2563 */
2564 if (!reason_code && (cds_is_log_report_in_progress() == false)) {
2565 wma_debug("Received WMI flush event without sending CMD");
2566 return -EINVAL;
2567 } else if (!reason_code && cds_is_log_report_in_progress() == true) {
2568 /* Flush event in response to flush command */
2569 wma_debug("Received WMI flush event in response to flush CMD");
2570 status = qdf_mc_timer_stop(&wma->log_completion_timer);
2571 if (status != QDF_STATUS_SUCCESS)
2572 wma_err("Failed to stop the log completion timeout");
2573 cds_logging_set_fw_flush_complete();
2574 return QDF_STATUS_SUCCESS;
2575 } else if (reason_code && cds_is_log_report_in_progress() == false) {
2576 /* Asynchronous flush event for fatal events */
2577 status = cds_set_log_completion(WLAN_LOG_TYPE_FATAL,
2578 WLAN_LOG_INDICATOR_FIRMWARE,
2579 reason_code, false);
2580 if (QDF_STATUS_SUCCESS != status) {
2581 wma_err("Failed to set log trigger params");
2582 return QDF_STATUS_E_FAILURE;
2583 }
2584 cds_logging_set_fw_flush_complete();
2585 return status;
2586 } else {
2587 /* Asynchronous flush event for fatal event,
2588 * but, report in progress already
2589 */
2590 wma_debug("Bug report already in progress - dropping! type:%d, indicator=%d reason_code=%d",
2591 WLAN_LOG_TYPE_FATAL,
2592 WLAN_LOG_INDICATOR_FIRMWARE, reason_code);
2593 return QDF_STATUS_E_FAILURE;
2594 }
2595 /* Asynchronous flush event for fatal event,
2596 * but, report in progress already
2597 */
2598 wma_warn("Bug report already in progress - dropping! type:%d, indicator=%d reason_code=%d",
2599 WLAN_LOG_TYPE_FATAL,
2600 WLAN_LOG_INDICATOR_FIRMWARE, reason_code);
2601 return QDF_STATUS_E_FAILURE;
2602 }
2603
2604 #ifdef WLAN_CONV_SPECTRAL_ENABLE
2605 /**
2606 * wma_extract_single_phyerr_spectral() - extract single phy error from event
2607 * @handle: wma handle
2608 * @evt_buf: pointer to event buffer
2609 * @datalen: data length of event buffer
2610 * @buf_offset: Pointer to hold value of current event buffer offset
2611 * post extraction
2612 * @phyerr: Pointer to hold phyerr
2613 *
2614 * Return: QDF_STATUS
2615 */
wma_extract_single_phyerr_spectral(void * handle,void * evt_buf,uint16_t datalen,uint16_t * buf_offset,wmi_host_phyerr_t * phyerr)2616 static QDF_STATUS wma_extract_single_phyerr_spectral(void *handle,
2617 void *evt_buf,
2618 uint16_t datalen, uint16_t *buf_offset,
2619 wmi_host_phyerr_t *phyerr)
2620 {
2621 wmi_single_phyerr_rx_event *ev;
2622 int n = *buf_offset;
2623
2624 ev = (wmi_single_phyerr_rx_event *)((uint8_t *)evt_buf + n);
2625
2626 if (n < datalen) {
2627 /* ensure there's at least space for the header */
2628 if ((datalen - n) < sizeof(ev->hdr)) {
2629 wma_err("not enough space? (datalen=%d, n=%d, hdr=%zu bytes",
2630 datalen, n, sizeof(ev->hdr));
2631 return QDF_STATUS_E_FAILURE;
2632 }
2633
2634 phyerr->bufp = ev->bufp;
2635 phyerr->buf_len = ev->hdr.buf_len;
2636
2637 /*
2638 * Sanity check the buffer length of the event against
2639 * what we currently have.
2640 *
2641 * Since buf_len is 32 bits, we check if it overflows
2642 * a large 32 bit value. It's not 0x7fffffff because
2643 * we increase n by (buf_len + sizeof(hdr)), which would
2644 * in itself cause n to overflow.
2645 *
2646 * If "int" is 64 bits then this becomes a moot point.
2647 */
2648 if (ev->hdr.buf_len > 0x7f000000) {
2649 wma_err("buf_len is garbage? (0x%x)", ev->hdr.buf_len);
2650 return QDF_STATUS_E_FAILURE;
2651 }
2652 if (n + ev->hdr.buf_len > datalen) {
2653 wma_err("buf_len exceeds available space n=%d, buf_len=%d, datalen=%d",
2654 n, ev->hdr.buf_len, datalen);
2655 return QDF_STATUS_E_FAILURE;
2656 }
2657
2658 phyerr->phy_err_code = WMI_UNIFIED_PHYERRCODE_GET(&ev->hdr);
2659 phyerr->tsf_timestamp = ev->hdr.tsf_timestamp;
2660
2661 #ifdef DEBUG_SPECTRAL_SCAN
2662 wma_debug("len=%d, tsf=0x%08x, rssi = 0x%x/0x%x/0x%x/0x%x, comb rssi = 0x%x, phycode=%d",
2663 ev->hdr.buf_len,
2664 ev->hdr.tsf_timestamp,
2665 ev->hdr.rssi_chain0,
2666 ev->hdr.rssi_chain1,
2667 ev->hdr.rssi_chain2,
2668 ev->hdr.rssi_chain3,
2669 WMI_UNIFIED_RSSI_COMB_GET(&ev->hdr),
2670 phyerr->phy_err_code);
2671
2672 /*
2673 * For now, unroll this loop - the chain 'value' field isn't
2674 * a variable but glued together into a macro field definition.
2675 * Grr. :-)
2676 */
2677 wma_debug("chain 0: raw=0x%08x; pri20=%d sec20=%d sec40=%d sec80=%d",
2678 ev->hdr.rssi_chain0,
2679 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, PRI20),
2680 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC20),
2681 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC40),
2682 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC80));
2683
2684 wma_debug("chain 1: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d",
2685 ev->hdr.rssi_chain1,
2686 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, PRI20),
2687 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC20),
2688 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC40),
2689 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC80));
2690
2691 wma_debug("chain 2: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d",
2692 ev->hdr.rssi_chain2,
2693 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, PRI20),
2694 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC20),
2695 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC40),
2696 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC80));
2697
2698 wma_debug("chain 3: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d",
2699 ev->hdr.rssi_chain3,
2700 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, PRI20),
2701 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC20),
2702 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC40),
2703 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC80));
2704
2705
2706 wma_debug("freq_info_1=0x%08x, freq_info_2=0x%08x",
2707 ev->hdr.freq_info_1, ev->hdr.freq_info_2);
2708
2709 /*
2710 * The NF chain values are signed and are negative - hence
2711 * the cast evilness.
2712 */
2713 wma_debug("nfval[1]=0x%08x, nfval[2]=0x%08x, nf=%d/%d/%d/%d, freq1=%d, freq2=%d, cw=%d",
2714 ev->hdr.nf_list_1,
2715 ev->hdr.nf_list_2,
2716 (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 0),
2717 (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 1),
2718 (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 2),
2719 (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 3),
2720 WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 1),
2721 WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 2),
2722 WMI_UNIFIED_CHWIDTH_GET(&ev->hdr));
2723 #endif
2724
2725 /*
2726 * If required, pass spectral events to the spectral module
2727 */
2728 if (ev->hdr.buf_len > 0) {
2729
2730 /* Initialize the NF values to Zero. */
2731 phyerr->rf_info.noise_floor[0] =
2732 WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 0);
2733 phyerr->rf_info.noise_floor[1] =
2734 WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 1);
2735 phyerr->rf_info.noise_floor[2] =
2736 WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 2);
2737 phyerr->rf_info.noise_floor[3] =
2738 WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 3);
2739
2740 /* populate the rf info */
2741 phyerr->rf_info.rssi_comb =
2742 WMI_UNIFIED_RSSI_COMB_GET(&ev->hdr);
2743
2744 /* Need to unroll loop due to macro
2745 * constraints chain 0
2746 */
2747 phyerr->rf_info.pc_rssi_info[0].rssi_pri20 =
2748 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, PRI20);
2749 phyerr->rf_info.pc_rssi_info[0].rssi_sec20 =
2750 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC20);
2751 phyerr->rf_info.pc_rssi_info[0].rssi_sec40 =
2752 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC40);
2753 phyerr->rf_info.pc_rssi_info[0].rssi_sec80 =
2754 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC80);
2755
2756 /* chain 1 */
2757 phyerr->rf_info.pc_rssi_info[1].rssi_pri20 =
2758 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, PRI20);
2759 phyerr->rf_info.pc_rssi_info[1].rssi_sec20 =
2760 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC20);
2761 phyerr->rf_info.pc_rssi_info[1].rssi_sec40 =
2762 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC40);
2763 phyerr->rf_info.pc_rssi_info[1].rssi_sec80 =
2764 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC80);
2765
2766 /* chain 2 */
2767 phyerr->rf_info.pc_rssi_info[2].rssi_pri20 =
2768 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, PRI20);
2769 phyerr->rf_info.pc_rssi_info[2].rssi_sec20 =
2770 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC20);
2771 phyerr->rf_info.pc_rssi_info[2].rssi_sec40 =
2772 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC40);
2773 phyerr->rf_info.pc_rssi_info[2].rssi_sec80 =
2774 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC80);
2775
2776 /* chain 3 */
2777 phyerr->rf_info.pc_rssi_info[3].rssi_pri20 =
2778 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, PRI20);
2779 phyerr->rf_info.pc_rssi_info[3].rssi_sec20 =
2780 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC20);
2781 phyerr->rf_info.pc_rssi_info[3].rssi_sec40 =
2782 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC40);
2783 phyerr->rf_info.pc_rssi_info[3].rssi_sec80 =
2784 WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC80);
2785
2786 phyerr->chan_info.center_freq1 =
2787 WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 1);
2788 phyerr->chan_info.center_freq2 =
2789 WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 2);
2790
2791 }
2792
2793 /*
2794 * Advance the buffer pointer to the next PHY error.
2795 * buflen is the length of this payload, so we need to
2796 * advance past the current header _AND_ the payload.
2797 */
2798 n += sizeof(*ev) + ev->hdr.buf_len;
2799 }
2800 *buf_offset += n;
2801
2802 return QDF_STATUS_SUCCESS;
2803 }
2804
2805 /**
2806 * spectral_phyerr_event_handler() - spectral phyerr event handler
2807 * @handle: wma handle
2808 * @data: data buffer
2809 * @datalen: buffer length
2810 *
2811 * Return: QDF_STATUS
2812 */
spectral_phyerr_event_handler(void * handle,uint8_t * data,uint32_t datalen)2813 static QDF_STATUS spectral_phyerr_event_handler(void *handle,
2814 uint8_t *data,
2815 uint32_t datalen)
2816 {
2817 tp_wma_handle wma = (tp_wma_handle) handle;
2818 QDF_STATUS status = QDF_STATUS_SUCCESS;
2819 uint16_t buf_offset, event_buf_len = 0;
2820 wmi_single_phyerr_rx_event *ev;
2821 wmi_host_phyerr_t phyerr;
2822 struct target_if_spectral_rfqual_info rfqual_info;
2823 struct target_if_spectral_chan_info chan_info;
2824 struct target_if_spectral_acs_stats acs_stats;
2825
2826 if (wma_validate_handle(wma))
2827 return QDF_STATUS_E_FAILURE;
2828
2829 memset(&phyerr, 0, sizeof(wmi_host_phyerr_t));
2830 status = wmi_extract_comb_phyerr(wma->wmi_handle, data, datalen,
2831 &buf_offset, &phyerr);
2832 if (QDF_IS_STATUS_ERROR(status)) {
2833 wma_err("extract comb phyerr failed");
2834 return QDF_STATUS_E_FAILURE;
2835 }
2836
2837 ev = (wmi_single_phyerr_rx_event *)phyerr.bufp;
2838 event_buf_len = phyerr.buf_len;
2839 /* Loop over the bufp, extracting out phyerrors */
2840 buf_offset = 0;
2841 while (buf_offset < event_buf_len) {
2842 if (wma_extract_single_phyerr_spectral(handle, ev,
2843 event_buf_len, &buf_offset, &phyerr)) {
2844 wma_err("extract single phy err failed");
2845 return QDF_STATUS_E_FAILURE;
2846 }
2847
2848 if (phyerr.buf_len > 0) {
2849 if (sizeof(phyerr.rf_info) > sizeof(rfqual_info))
2850 qdf_mem_copy(&rfqual_info, &phyerr.rf_info,
2851 sizeof(rfqual_info));
2852 else
2853 qdf_mem_copy(&rfqual_info, &phyerr.rf_info,
2854 sizeof(phyerr.rf_info));
2855
2856 if (sizeof(phyerr.chan_info) > sizeof(chan_info))
2857 qdf_mem_copy(&chan_info, &phyerr.chan_info,
2858 sizeof(chan_info));
2859 else
2860 qdf_mem_copy(&chan_info, &phyerr.chan_info,
2861 sizeof(phyerr.chan_info));
2862
2863 target_if_spectral_process_phyerr(wma->pdev, phyerr.bufp,
2864 phyerr.buf_len,
2865 &rfqual_info,
2866 &chan_info,
2867 phyerr.tsf64,
2868 &acs_stats);
2869 }
2870 }
2871
2872 return status;
2873 }
2874 #else
2875 static QDF_STATUS
wma_extract_single_phyerr_spectral(void * handle,void * evt_buf,uint16_t datalen,uint16_t * buf_offset,wmi_host_phyerr_t * phyerr)2876 wma_extract_single_phyerr_spectral(void *handle, void *evt_buf,
2877 uint16_t datalen,
2878 uint16_t *buf_offset,
2879 wmi_host_phyerr_t *phyerr)
2880 {
2881 return QDF_STATUS_SUCCESS;
2882 }
2883
spectral_phyerr_event_handler(void * handle,uint8_t * data,uint32_t datalen)2884 static QDF_STATUS spectral_phyerr_event_handler(void *handle,
2885 uint8_t *data, uint32_t datalen)
2886 {
2887 return QDF_STATUS_SUCCESS;
2888 }
2889 #endif
2890
2891 /**
2892 * dfs_phyerr_event_handler() - dfs phyerr event handler
2893 * @handle: wma handle
2894 * @data: data buffer
2895 * @datalen: buffer length
2896 * @fulltsf: 64 bit event TSF
2897 *
2898 * Function to process DFS phy errors.
2899 *
2900 * Return: QDF_STATUS
2901 */
dfs_phyerr_event_handler(tp_wma_handle handle,uint8_t * data,uint32_t datalen,uint64_t fulltsf)2902 static QDF_STATUS dfs_phyerr_event_handler(tp_wma_handle handle,
2903 uint8_t *data,
2904 uint32_t datalen,
2905 uint64_t fulltsf)
2906 {
2907 QDF_STATUS status = QDF_STATUS_SUCCESS;
2908 struct wlan_lmac_if_dfs_rx_ops *dfs_rx_ops;
2909 wmi_host_phyerr_t phyerr;
2910 int8_t rssi_comb;
2911 uint16_t buf_offset;
2912
2913 if (!handle->psoc) {
2914 wma_err("psoc is null");
2915 return QDF_STATUS_E_INVAL;
2916 }
2917
2918 dfs_rx_ops = wlan_lmac_if_get_dfs_rx_ops(handle->psoc);
2919 if (!dfs_rx_ops) {
2920 wma_err("dfs_rx_ops is null");
2921 return QDF_STATUS_E_INVAL;
2922 }
2923
2924 if (!dfs_rx_ops->dfs_process_phyerr) {
2925 wma_err("dfs_process_phyerr handler is null");
2926 return QDF_STATUS_E_INVAL;
2927 }
2928
2929 if (!handle->pdev) {
2930 wma_err("pdev is null");
2931 return -EINVAL;
2932 }
2933
2934 buf_offset = 0;
2935 while (buf_offset < datalen) {
2936 status = wmi_extract_single_phyerr(handle->wmi_handle, data, datalen,
2937 &buf_offset, &phyerr);
2938 if (QDF_IS_STATUS_ERROR(status)) {
2939 /* wmi_extract_single_phyerr has logs */
2940 return status;
2941 }
2942
2943 rssi_comb = phyerr.rf_info.rssi_comb & 0xFF;
2944 if (phyerr.buf_len > 0)
2945 dfs_rx_ops->dfs_process_phyerr(handle->pdev,
2946 &phyerr.bufp[0],
2947 phyerr.buf_len,
2948 rssi_comb,
2949 rssi_comb,
2950 phyerr.tsf_timestamp,
2951 fulltsf);
2952 }
2953
2954 return QDF_STATUS_SUCCESS;
2955 }
2956
2957 /**
2958 * wma_unified_phyerr_rx_event_handler() - phyerr event handler
2959 * @handle: wma handle
2960 * @data: data buffer
2961 * @datalen: buffer length
2962 *
2963 * WMI Handler for WMI_PHYERR_EVENTID event from firmware.
2964 * This handler is currently handling DFS and spectral scan
2965 * phy errors.
2966 *
2967 * Return: 0 for success, other value for failure
2968 */
wma_unified_phyerr_rx_event_handler(void * handle,uint8_t * data,uint32_t datalen)2969 static int wma_unified_phyerr_rx_event_handler(void *handle,
2970 uint8_t *data,
2971 uint32_t datalen)
2972 {
2973 /* phyerr handling is moved to cmn project
2974 * As WIN still uses handler registration in non-cmn code.
2975 * need complete testing of non offloaded DFS code before we enable
2976 * it in cmn code.
2977 **/
2978 tp_wma_handle wma = (tp_wma_handle) handle;
2979 QDF_STATUS status = QDF_STATUS_SUCCESS;
2980 wmi_host_phyerr_t phyerr;
2981 uint16_t buf_offset = 0;
2982 wmi_single_phyerr_rx_event *ev;
2983 uint16_t event_buf_len = 0;
2984 wmi_host_phyerr_t phyerr2;
2985 bool spectralscan = false;
2986
2987 if (wma_validate_handle(wma))
2988 return -EINVAL;
2989
2990 /* sanity check on data length */
2991 status = wmi_extract_comb_phyerr(wma->wmi_handle, data, datalen,
2992 &buf_offset, &phyerr);
2993 if (QDF_IS_STATUS_ERROR(status)) {
2994 wma_err("extract phyerr failed: %d", status);
2995 return qdf_status_to_os_return(status);
2996 }
2997 ev = (wmi_single_phyerr_rx_event *)phyerr.bufp;
2998 event_buf_len = phyerr.buf_len;
2999 /* Loop over the bufp, extracting out phyerrors */
3000 buf_offset = 0;
3001 while (ev && (buf_offset < event_buf_len)) {
3002 if (wma_extract_single_phyerr_spectral(handle, ev,
3003 event_buf_len,
3004 &buf_offset,
3005 &phyerr2)) {
3006 wma_err("extract single phy err failed");
3007 return qdf_status_to_os_return(QDF_STATUS_E_FAILURE);
3008 }
3009 if ((buf_offset != 0) && (phyerr2.phy_err_code == 0x26 ||
3010 phyerr2.phy_err_code == 0x24)) {
3011 spectralscan = true;
3012 } else {
3013 break;
3014 }
3015 }
3016 if (spectralscan) {
3017 status = spectral_phyerr_event_handler(wma, data, datalen);
3018 return qdf_status_to_os_return(status);
3019 }
3020 /* handle different PHY Error conditions */
3021 if (((phyerr.phy_err_mask0 & (WMI_PHY_ERROR_MASK0_RADAR |
3022 WMI_PHY_ERROR_MASK0_FALSE_RADAR_EXT |
3023 WMI_PHY_ERROR_MASK0_SPECTRAL_SCAN)) == 0)) {
3024 wma_debug("Unknown phy error event");
3025 return -EINVAL;
3026 }
3027
3028 /* Handle Spectral or DFS PHY Error */
3029 if (phyerr.phy_err_mask0 & (WMI_PHY_ERROR_MASK0_RADAR |
3030 WMI_PHY_ERROR_MASK0_FALSE_RADAR_EXT)) {
3031 if (wma->is_dfs_offloaded) {
3032 wma_debug("Unexpected phy error, dfs offloaded");
3033 return -EINVAL;
3034 }
3035 status = dfs_phyerr_event_handler(wma,
3036 phyerr.bufp,
3037 phyerr.buf_len,
3038 phyerr.tsf64);
3039 } else if (phyerr.phy_err_mask0 & (WMI_PHY_ERROR_MASK0_SPECTRAL_SCAN |
3040 WMI_PHY_ERROR_MASK0_FALSE_RADAR_EXT)) {
3041 status = spectral_phyerr_event_handler(wma, data, datalen);
3042 }
3043
3044 return qdf_status_to_os_return(status);
3045 }
3046
wma_vdev_init(struct wma_txrx_node * vdev)3047 void wma_vdev_init(struct wma_txrx_node *vdev)
3048 {
3049 vdev->is_waiting_for_key = false;
3050 }
3051
wma_vdev_deinit(struct wma_txrx_node * vdev)3052 void wma_vdev_deinit(struct wma_txrx_node *vdev)
3053 {
3054 struct beacon_info *bcn;
3055 tp_wma_handle wma_handle;
3056
3057 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
3058 if (!wma_handle)
3059 return;
3060
3061 bcn = vdev->beacon;
3062 if (bcn) {
3063 if (bcn->dma_mapped)
3064 qdf_nbuf_unmap_single(wma_handle->qdf_dev,
3065 bcn->buf, QDF_DMA_TO_DEVICE);
3066 qdf_nbuf_free(bcn->buf);
3067 qdf_mem_free(bcn);
3068 vdev->beacon = NULL;
3069 }
3070
3071 if (vdev->vdev_active == true)
3072 vdev->vdev_active = false;
3073
3074 if (vdev->addBssStaContext) {
3075 qdf_mem_free(vdev->addBssStaContext);
3076 vdev->addBssStaContext = NULL;
3077 }
3078
3079 if (vdev->psnr_req) {
3080 qdf_mem_free(vdev->psnr_req);
3081 vdev->psnr_req = NULL;
3082 }
3083
3084 if (vdev->rcpi_req) {
3085 qdf_mem_free(vdev->rcpi_req);
3086 vdev->rcpi_req = NULL;
3087 }
3088
3089 if (vdev->roam_scan_stats_req) {
3090 struct sir_roam_scan_stats *req;
3091
3092 req = vdev->roam_scan_stats_req;
3093 vdev->roam_scan_stats_req = NULL;
3094 qdf_mem_free(req);
3095 }
3096
3097 if (vdev->roam_synch_frame_ind.bcn_probe_rsp) {
3098 qdf_mem_free(vdev->roam_synch_frame_ind.bcn_probe_rsp);
3099 vdev->roam_synch_frame_ind.bcn_probe_rsp = NULL;
3100 }
3101
3102 if (vdev->roam_synch_frame_ind.reassoc_req) {
3103 qdf_mem_free(vdev->roam_synch_frame_ind.reassoc_req);
3104 vdev->roam_synch_frame_ind.reassoc_req = NULL;
3105 }
3106
3107 if (vdev->roam_synch_frame_ind.reassoc_rsp) {
3108 qdf_mem_free(vdev->roam_synch_frame_ind.reassoc_rsp);
3109 vdev->roam_synch_frame_ind.reassoc_rsp = NULL;
3110 }
3111
3112 if (vdev->plink_status_req) {
3113 qdf_mem_free(vdev->plink_status_req);
3114 vdev->plink_status_req = NULL;
3115 }
3116
3117 vdev->is_waiting_for_key = false;
3118 }
3119
3120 /**
3121 * wma_wmi_stop() - generic function to block WMI commands
3122 * @return: None
3123 */
wma_wmi_stop(void)3124 void wma_wmi_stop(void)
3125 {
3126 tp_wma_handle wma_handle;
3127
3128 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
3129 if (!wma_handle)
3130 return;
3131
3132 if (wmi_validate_handle(wma_handle->wmi_handle))
3133 return;
3134
3135 wmi_stop(wma_handle->wmi_handle);
3136 }
3137
3138 #ifdef WLAN_WMI_BCN
3139 static QDF_STATUS
wma_register_swba_events(wmi_unified_t wmi_handle)3140 wma_register_swba_events(wmi_unified_t wmi_handle)
3141 {
3142 QDF_STATUS status;
3143
3144 status = wmi_unified_register_event_handler(wmi_handle,
3145 wmi_host_swba_event_id,
3146 wma_beacon_swba_handler,
3147 WMA_RX_SERIALIZER_CTX);
3148
3149 return status;
3150 }
3151 #else
wma_register_swba_events(wmi_unified_t wmi_handle)3152 static QDF_STATUS wma_register_swba_events(wmi_unified_t wmi_handle)
3153 {
3154 return QDF_STATUS_SUCCESS;
3155 }
3156 #endif
3157
3158 #ifdef FEATURE_WLAN_APF
wma_register_apf_events(tp_wma_handle wma_handle)3159 static void wma_register_apf_events(tp_wma_handle wma_handle)
3160 {
3161 if (wma_validate_handle(wma_handle))
3162 return;
3163
3164 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3165 wmi_apf_capability_info_event_id,
3166 wma_get_apf_caps_event_handler,
3167 WMA_RX_SERIALIZER_CTX);
3168 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3169 wmi_apf_get_vdev_work_memory_resp_event_id,
3170 wma_apf_read_work_memory_event_handler,
3171 WMA_RX_SERIALIZER_CTX);
3172 }
3173 #else /* FEATURE_WLAN_APF */
wma_register_apf_events(tp_wma_handle wma_handle)3174 static void wma_register_apf_events(tp_wma_handle wma_handle)
3175 {
3176 }
3177 #endif /* FEATURE_WLAN_APF */
3178
3179 #ifdef WLAN_FEATURE_MOTION_DETECTION
3180 /**
3181 * wma_register_md_events - Register motion detection event handlers
3182 * @wma_handle: wma handle
3183 * Return: None
3184 */
wma_register_md_events(tp_wma_handle wma_handle)3185 static void wma_register_md_events(tp_wma_handle wma_handle)
3186 {
3187 if (wma_validate_handle(wma_handle))
3188 return;
3189
3190 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3191 wmi_motion_det_host_eventid,
3192 wma_motion_det_host_event_handler,
3193 WMA_RX_SERIALIZER_CTX);
3194
3195 wmi_unified_register_event_handler(
3196 wma_handle->wmi_handle,
3197 wmi_motion_det_base_line_host_eventid,
3198 wma_motion_det_base_line_host_event_handler,
3199 WMA_RX_SERIALIZER_CTX);
3200 }
3201 #else /* WLAN_FEATURE_MOTION_DETECTION */
3202 /**
3203 * wma_register_md_events - Register motion detection event handlers
3204 * @wma_handle: wma handle
3205 * Return: None
3206 */
wma_register_md_events(tp_wma_handle wma_handle)3207 static void wma_register_md_events(tp_wma_handle wma_handle)
3208 {
3209 }
3210 #endif /* WLAN_FEATURE_MOTION_DETECTION */
3211
3212 #ifdef FEATURE_WLM_STATS
wma_register_wlm_stats_events(tp_wma_handle wma_handle)3213 static void wma_register_wlm_stats_events(tp_wma_handle wma_handle)
3214 {
3215 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3216 wmi_wlm_stats_event_id,
3217 wma_wlm_stats_rsp,
3218 WMA_RX_SERIALIZER_CTX);
3219 }
3220 #else /* FEATURE_WLM_STATS */
wma_register_wlm_stats_events(tp_wma_handle wma_handle)3221 static void wma_register_wlm_stats_events(tp_wma_handle wma_handle)
3222 {
3223 }
3224 #endif /* FEATURE_WLM_STATS */
3225
3226 #ifdef MULTI_CLIENT_LL_SUPPORT
wma_register_wlm_latency_level_event(tp_wma_handle wma_handle)3227 static void wma_register_wlm_latency_level_event(tp_wma_handle wma_handle)
3228 {
3229 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3230 wmi_vdev_latency_event_id,
3231 wma_latency_level_event_handler,
3232 WMA_RX_WORK_CTX);
3233 }
3234 #else
wma_register_wlm_latency_level_event(tp_wma_handle wma_handle)3235 static void wma_register_wlm_latency_level_event(tp_wma_handle wma_handle)
3236 {
3237 }
3238 #endif
3239
wma_get_psoc_from_scn_handle(void * scn_handle)3240 struct wlan_objmgr_psoc *wma_get_psoc_from_scn_handle(void *scn_handle)
3241 {
3242 tp_wma_handle wma_handle;
3243
3244 if (!scn_handle) {
3245 wma_err("invalid scn handle");
3246 return NULL;
3247 }
3248 wma_handle = (tp_wma_handle)scn_handle;
3249
3250 return wma_handle->psoc;
3251 }
3252
wma_get_fw_phy_mode_for_freq_cb(uint32_t freq,uint32_t chan_width,uint32_t * phy_mode)3253 void wma_get_fw_phy_mode_for_freq_cb(uint32_t freq, uint32_t chan_width,
3254 uint32_t *phy_mode)
3255 {
3256 uint32_t dot11_mode;
3257 enum wlan_phymode host_phy_mode;
3258 struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
3259
3260 if (!mac) {
3261 wma_err("MAC context is NULL");
3262 *phy_mode = WLAN_PHYMODE_AUTO;
3263 return;
3264 }
3265
3266 dot11_mode = mac->mlme_cfg->dot11_mode.dot11_mode;
3267
3268 /* Update invalid dot11 modes to valid dot11 modes */
3269 if (WLAN_REG_IS_24GHZ_CH_FREQ(freq) &&
3270 dot11_mode == MLME_DOT11_MODE_11A)
3271 dot11_mode = MLME_DOT11_MODE_11G;
3272
3273 if (WLAN_REG_IS_5GHZ_CH_FREQ(freq) &&
3274 (dot11_mode == MLME_DOT11_MODE_11B ||
3275 dot11_mode == MLME_DOT11_MODE_11G ||
3276 dot11_mode == MLME_DOT11_MODE_11G_ONLY))
3277 dot11_mode = MLME_DOT11_MODE_11A;
3278
3279 host_phy_mode = wma_chan_phy_mode(freq, chan_width, dot11_mode);
3280 *phy_mode = wmi_host_to_fw_phymode(host_phy_mode);
3281 }
3282
wma_get_phy_mode_cb(qdf_freq_t freq,uint32_t chan_width,enum wlan_phymode * phy_mode)3283 void wma_get_phy_mode_cb(qdf_freq_t freq, uint32_t chan_width,
3284 enum wlan_phymode *phy_mode)
3285 {
3286 uint32_t dot11_mode;
3287 struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
3288
3289 if (!mac) {
3290 wma_err("MAC context is NULL");
3291 *phy_mode = WLAN_PHYMODE_AUTO;
3292 return;
3293 }
3294
3295 dot11_mode = mac->mlme_cfg->dot11_mode.dot11_mode;
3296 *phy_mode = wma_chan_phy_mode(freq, chan_width, dot11_mode);
3297 }
3298
3299 #ifdef WLAN_FEATURE_NAN
3300 static void
wma_register_nan_callbacks(tp_wma_handle wma_handle)3301 wma_register_nan_callbacks(tp_wma_handle wma_handle)
3302 {
3303 struct nan_callbacks cb_obj = {0};
3304
3305 cb_obj.update_ndi_conn = wma_ndi_update_connection_info;
3306
3307 ucfg_nan_register_wma_callbacks(wma_handle->psoc, &cb_obj);
3308 }
3309 #else
wma_register_nan_callbacks(tp_wma_handle wma_handle)3310 static void wma_register_nan_callbacks(tp_wma_handle wma_handle)
3311 {
3312 }
3313 #endif
3314
3315 #ifdef WLAN_FEATURE_PKT_CAPTURE
3316 static void
wma_register_pkt_capture_callbacks(tp_wma_handle wma_handle)3317 wma_register_pkt_capture_callbacks(tp_wma_handle wma_handle)
3318 {
3319 struct pkt_capture_callbacks cb_obj = {0};
3320
3321 cb_obj.get_rmf_status = wma_get_rmf_status;
3322
3323 ucfg_pkt_capture_register_wma_callbacks(wma_handle->psoc, &cb_obj);
3324 }
3325 #else
3326 static inline void
wma_register_pkt_capture_callbacks(tp_wma_handle wma_handle)3327 wma_register_pkt_capture_callbacks(tp_wma_handle wma_handle)
3328 {
3329 }
3330 #endif
3331
3332 #ifdef TRACE_RECORD
wma_trace_dump(void * mac_ctx,tp_qdf_trace_record record,uint16_t rec_index)3333 static void wma_trace_dump(void *mac_ctx, tp_qdf_trace_record record,
3334 uint16_t rec_index)
3335 {
3336 /*
3337 * This is dummy handler registered to qdf_trace as wma module wants to
3338 * insert trace records in qdf trace global record table but qdf_trace
3339 * does not allow to insert the trace records in the global record
3340 * table if a module is not registered with the qdf trace.
3341 */
3342 }
3343
wma_trace_init(void)3344 static void wma_trace_init(void)
3345 {
3346 qdf_trace_register(QDF_MODULE_ID_WMA, &wma_trace_dump);
3347 }
3348 #else
wma_trace_init(void)3349 static inline void wma_trace_init(void)
3350 {
3351 }
3352 #endif
3353
3354 #ifdef FEATURE_CLUB_LL_STATS_AND_GET_STATION
wma_get_service_cap_club_get_sta_in_ll_stats_req(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)3355 static void wma_get_service_cap_club_get_sta_in_ll_stats_req(
3356 struct wmi_unified *wmi_handle,
3357 struct wma_tgt_services *cfg)
3358 {
3359 cfg->is_get_station_clubbed_in_ll_stats_req =
3360 wmi_service_enabled(wmi_handle,
3361 wmi_service_get_station_in_ll_stats_req);
3362 }
3363 #else
wma_get_service_cap_club_get_sta_in_ll_stats_req(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)3364 static void wma_get_service_cap_club_get_sta_in_ll_stats_req(
3365 struct wmi_unified *wmi_handle,
3366 struct wma_tgt_services *cfg)
3367 {
3368 }
3369 #endif /* FEATURE_CLUB_LL_STATS_AND_GET_STATION */
3370
3371 #ifdef WLAN_FEATURE_11BE_MLO
3372 static void
wma_update_num_tdls_vdevs_if_11be_mlo(struct wlan_objmgr_psoc * psoc,target_resource_config * wlan_res_cfg)3373 wma_update_num_tdls_vdevs_if_11be_mlo(struct wlan_objmgr_psoc *psoc,
3374 target_resource_config *wlan_res_cfg)
3375 {
3376 if (!wlan_tdls_is_fw_11be_mlo_capable(psoc))
3377 return;
3378
3379 wlan_res_cfg->num_tdls_vdevs = WLAN_UMAC_MLO_MAX_VDEVS;
3380 wma_debug("update tdls num vdevs %d", wlan_res_cfg->num_tdls_vdevs);
3381 }
3382
3383 static void
wma_get_service_cap_per_link_mlo_stats(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)3384 wma_get_service_cap_per_link_mlo_stats(struct wmi_unified *wmi_handle,
3385 struct wma_tgt_services *cfg)
3386 {
3387 cfg->is_mlo_per_link_stats_supported =
3388 wmi_service_enabled(wmi_handle,
3389 wmi_service_per_link_stats_support);
3390 wma_debug("mlo_per_link stats is %s supported by FW",
3391 cfg->is_mlo_per_link_stats_supported ? "" : "NOT");
3392 }
3393 #else
3394 static void
wma_update_num_tdls_vdevs_if_11be_mlo(struct wlan_objmgr_psoc * psoc,target_resource_config * wlan_res_cfg)3395 wma_update_num_tdls_vdevs_if_11be_mlo(struct wlan_objmgr_psoc *psoc,
3396 target_resource_config *wlan_res_cfg)
3397 {
3398 }
3399
3400 static void
wma_get_service_cap_per_link_mlo_stats(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)3401 wma_get_service_cap_per_link_mlo_stats(struct wmi_unified *wmi_handle,
3402 struct wma_tgt_services *cfg)
3403 {
3404 }
3405 #endif
3406
3407 /**
3408 * wma_set_exclude_selftx_from_cca_busy_time() - Set exclude self tx time from
3409 * cca busy time bool
3410 * @exclude_selftx_from_cca_busy: Bool to update in in wma ini config
3411 * @wma_handle: WMA handle
3412 *
3413 * Return: None
3414 */
3415 static void
wma_set_exclude_selftx_from_cca_busy_time(bool exclude_selftx_from_cca_busy,tp_wma_handle wma_handle)3416 wma_set_exclude_selftx_from_cca_busy_time(bool exclude_selftx_from_cca_busy,
3417 tp_wma_handle wma_handle)
3418 {
3419 struct wma_ini_config *cfg = wma_get_ini_handle(wma_handle);
3420
3421 if (!cfg) {
3422 wma_err("NULL WMA ini handle");
3423 return;
3424 }
3425
3426 cfg->exclude_selftx_from_cca_busy = exclude_selftx_from_cca_busy;
3427 }
3428
wma_deinit_pagefault_wakeup_history(tp_wma_handle wma)3429 static void wma_deinit_pagefault_wakeup_history(tp_wma_handle wma)
3430 {
3431 struct wma_pf_sym *pf_sym_entry;
3432 int8_t idx, max_sym_count = WLAN_WMA_MAX_PF_SYM;
3433 bool is_ssr = false;
3434
3435 if (wlan_pmo_enable_ssr_on_page_fault(wma->psoc)) {
3436 is_ssr = true;
3437 max_sym_count = 0x1;
3438 }
3439
3440 for (idx = 0; idx < max_sym_count; idx++) {
3441 pf_sym_entry = &wma->wma_pf_hist.wma_pf_sym[idx];
3442 pf_sym_entry->pf_sym.symbol = 0x0;
3443 pf_sym_entry->pf_sym.count = 0x0;
3444 qdf_mem_free(pf_sym_entry->pf_ev_ts);
3445 pf_sym_entry->pf_ev_ts = NULL;
3446 }
3447
3448 if (!is_ssr) {
3449 qdf_mem_free(wma->wma_pf_hist.pf_notify_buf_ptr);
3450 wma->wma_pf_hist.pf_notify_buf_ptr = NULL;
3451 wma->wma_pf_hist.pf_notify_buf_len = 0x0;
3452 }
3453 qdf_spinlock_destroy(&wma->wma_pf_hist.lock);
3454 }
3455
wma_init_pagefault_wakeup_history(tp_wma_handle wma)3456 static QDF_STATUS wma_init_pagefault_wakeup_history(tp_wma_handle wma)
3457 {
3458 struct wma_pf_sym *pf_sym_entry;
3459 int8_t idx, idx2, max_sym_count = WLAN_WMA_MAX_PF_SYM;
3460 uint8_t max_pf_count;
3461 bool is_ssr = false;
3462
3463 if (wlan_pmo_enable_ssr_on_page_fault(wma->psoc)) {
3464 is_ssr = true;
3465 max_sym_count = 0x1;
3466 }
3467
3468 max_pf_count = wlan_pmo_get_min_pagefault_wakeups_for_action(wma->psoc);
3469 for (idx = 0; idx < max_sym_count; idx++) {
3470 pf_sym_entry = &wma->wma_pf_hist.wma_pf_sym[idx];
3471 pf_sym_entry->pf_sym.symbol = 0x0;
3472 pf_sym_entry->pf_sym.count = 0x0;
3473 pf_sym_entry->pf_ev_ts = qdf_mem_malloc(max_pf_count *
3474 sizeof(qdf_time_t));
3475 if (!pf_sym_entry->pf_ev_ts)
3476 goto mem_err;
3477 }
3478
3479 if (!is_ssr) {
3480 wma->wma_pf_hist.pf_notify_buf_len = 0x0;
3481 wma->wma_pf_hist.pf_notify_buf_ptr =
3482 qdf_mem_malloc(WLAN_WMA_PF_APPS_NOTIFY_BUF_LEN);
3483 if (!wma->wma_pf_hist.pf_notify_buf_ptr)
3484 goto mem_err;
3485 }
3486
3487 qdf_spinlock_create(&wma->wma_pf_hist.lock);
3488
3489 return QDF_STATUS_SUCCESS;
3490
3491 mem_err:
3492 for (idx2 = --idx; idx2 >= 0; idx2--) {
3493 pf_sym_entry = &wma->wma_pf_hist.wma_pf_sym[idx2];
3494 qdf_mem_free(pf_sym_entry->pf_ev_ts);
3495 pf_sym_entry->pf_ev_ts = NULL;
3496 }
3497
3498 return QDF_STATUS_E_NOMEM;
3499 }
3500
3501 /**
3502 * wma_open() - Allocate wma context and initialize it.
3503 * @psoc: psoc object
3504 * @tgt_cfg_cb: tgt config callback fun
3505 * @cds_cfg: mac parameters
3506 * @target_type: target type
3507 *
3508 * Return: 0 on success, errno on failure
3509 */
wma_open(struct wlan_objmgr_psoc * psoc,wma_tgt_cfg_cb tgt_cfg_cb,struct cds_config_info * cds_cfg,uint32_t target_type)3510 QDF_STATUS wma_open(struct wlan_objmgr_psoc *psoc,
3511 wma_tgt_cfg_cb tgt_cfg_cb,
3512 struct cds_config_info *cds_cfg,
3513 uint32_t target_type)
3514 {
3515 tp_wma_handle wma_handle;
3516 HTC_HANDLE htc_handle;
3517 qdf_device_t qdf_dev;
3518 void *wmi_handle;
3519 QDF_STATUS qdf_status;
3520 struct wmi_unified_attach_params *params;
3521 struct policy_mgr_wma_cbacks wma_cbacks;
3522 struct target_psoc_info *tgt_psoc_info;
3523 int i;
3524 bool val = 0;
3525 void *cds_context;
3526 target_resource_config *wlan_res_cfg;
3527 uint32_t self_gen_frm_pwr = 0;
3528 uint32_t device_mode = cds_get_conparam();
3529
3530 wma_debug("Enter");
3531
3532 cds_context = cds_get_global_context();
3533 if (!cds_context) {
3534 wma_err("Invalid CDS context");
3535 return QDF_STATUS_E_INVAL;
3536 }
3537
3538 g_wmi_version_info.major = __WMI_VER_MAJOR_;
3539 g_wmi_version_info.minor = __WMI_VER_MINOR_;
3540 g_wmi_version_info.revision = __WMI_REVISION_;
3541
3542 qdf_dev = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
3543 htc_handle = cds_get_context(QDF_MODULE_ID_HTC);
3544
3545 if (!htc_handle) {
3546 wma_err("Invalid HTC handle");
3547 return QDF_STATUS_E_INVAL;
3548 }
3549
3550 /* Alloc memory for WMA Context */
3551 qdf_status = cds_alloc_context(QDF_MODULE_ID_WMA,
3552 (void **)&wma_handle,
3553 sizeof(*wma_handle));
3554
3555 if (qdf_status != QDF_STATUS_SUCCESS) {
3556 wma_err("Memory allocation failed for wma_handle");
3557 return qdf_status;
3558 }
3559
3560 qdf_mem_zero(wma_handle, sizeof(t_wma_handle));
3561
3562 if (target_if_alloc_psoc_tgt_info(psoc)) {
3563 wma_err("target psoc info allocation failed");
3564 qdf_status = QDF_STATUS_E_NOMEM;
3565 goto err_free_wma_handle;
3566 }
3567
3568 if (device_mode != QDF_GLOBAL_FTM_MODE) {
3569 #ifdef FEATURE_WLAN_EXTSCAN
3570 qdf_wake_lock_create(&wma_handle->extscan_wake_lock,
3571 "wlan_extscan_wl");
3572 #endif /* FEATURE_WLAN_EXTSCAN */
3573 qdf_wake_lock_create(&wma_handle->wow_wake_lock,
3574 "wlan_wow_wl");
3575 qdf_wake_lock_create(&wma_handle->wow_auth_req_wl,
3576 "wlan_auth_req_wl");
3577 qdf_wake_lock_create(&wma_handle->wow_assoc_req_wl,
3578 "wlan_assoc_req_wl");
3579 qdf_wake_lock_create(&wma_handle->wow_deauth_rec_wl,
3580 "wlan_deauth_rec_wl");
3581 qdf_wake_lock_create(&wma_handle->wow_disassoc_rec_wl,
3582 "wlan_disassoc_rec_wl");
3583 qdf_wake_lock_create(&wma_handle->wow_ap_assoc_lost_wl,
3584 "wlan_ap_assoc_lost_wl");
3585 qdf_wake_lock_create(&wma_handle->wow_auto_shutdown_wl,
3586 "wlan_auto_shutdown_wl");
3587 qdf_wake_lock_create(&wma_handle->roam_ho_wl,
3588 "wlan_roam_ho_wl");
3589 qdf_wake_lock_create(&wma_handle->roam_preauth_wl,
3590 "wlan_roam_preauth_wl");
3591 qdf_wake_lock_create(&wma_handle->probe_req_wps_wl,
3592 "wlan_probe_req_wps_wl");
3593 qdf_wake_lock_create(&wma_handle->sap_d3_wow_wake_lock,
3594 "wlan_sap_d3_wow_wake_lock");
3595 qdf_wake_lock_create(&wma_handle->go_d3_wow_wake_lock,
3596 "wlan_go_d3_wow_wake_lock");
3597 }
3598
3599 qdf_status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_LEGACY_WMA_ID);
3600 if (QDF_IS_STATUS_ERROR(qdf_status)) {
3601 wma_err("PSOC get_ref fails");
3602 goto err_get_psoc_ref;
3603 }
3604 wma_handle->psoc = psoc;
3605
3606 if (!wlan_pmo_no_op_on_page_fault(psoc)) {
3607 qdf_status = wma_init_pagefault_wakeup_history(wma_handle);
3608 if (QDF_IS_STATUS_ERROR(qdf_status))
3609 goto err_wma_handle;
3610 }
3611
3612 wma_target_if_open(wma_handle);
3613
3614 /*
3615 * Allocate locally used params with its rx_ops member,
3616 * and free it immediately after used.
3617 */
3618 params = qdf_mem_malloc(sizeof(*params));
3619 if (!params) {
3620 qdf_status = QDF_STATUS_E_NOMEM;
3621 goto err_wma_handle;
3622 }
3623
3624 params->osdev = NULL;
3625 params->target_type = WMI_TLV_TARGET;
3626 params->use_cookie = false;
3627 params->psoc = psoc;
3628 params->max_commands = WMI_MAX_CMDS;
3629
3630 /* initialize tlv attach */
3631 wmi_tlv_init();
3632
3633 /* attach the wmi */
3634 wmi_handle = wmi_unified_attach(wma_handle, params);
3635 qdf_mem_free(params);
3636 if (!wmi_handle) {
3637 wma_err("failed to attach WMI");
3638 qdf_status = QDF_STATUS_E_NOMEM;
3639 goto err_wma_handle;
3640 }
3641
3642 target_if_register_legacy_service_ready_cb(
3643 wma_legacy_service_ready_event_handler);
3644
3645 wma_info("WMA --> wmi_unified_attach - success");
3646
3647 /* store the wmi handle in tgt_if_handle */
3648 tgt_psoc_info = wlan_psoc_get_tgt_if_handle(psoc);
3649
3650 target_psoc_set_target_type(tgt_psoc_info, target_type);
3651 target_psoc_set_device_mode(tgt_psoc_info, device_mode);
3652 /* Save the WMI & HTC handle */
3653 target_psoc_set_wmi_hdl(tgt_psoc_info, wmi_handle);
3654 wma_handle->wmi_handle = wmi_handle;
3655 target_psoc_set_htc_hdl(tgt_psoc_info, htc_handle);
3656 wma_handle->cds_context = cds_context;
3657 wma_handle->qdf_dev = qdf_dev;
3658 wma_handle->enable_tx_compl_tsf64 =
3659 cds_cfg->enable_tx_compl_tsf64;
3660
3661 /* Register Converged Event handlers */
3662 init_deinit_register_tgt_psoc_ev_handlers(psoc);
3663
3664 /* Register LFR2/3 common Roam Event handler */
3665 target_if_roam_register_common_events(psoc);
3666
3667 /* Register Roam offload Event handlers */
3668 target_if_roam_offload_register_events(psoc);
3669
3670 /* Initialize max_no_of_peers for wma_get_number_of_peers_supported() */
3671 cds_cfg->max_station = wma_init_max_no_of_peers(wma_handle,
3672 cds_cfg->max_station);
3673
3674 wlan_mlme_set_assoc_sta_limit(psoc, cds_cfg->max_station);
3675
3676 wlan_mlme_register_common_events(psoc);
3677
3678 /* initialize default target config */
3679 wlan_res_cfg = target_psoc_get_wlan_res_cfg(tgt_psoc_info);
3680 if (!wlan_res_cfg) {
3681 wma_err("wlan_res_cfg is null");
3682 qdf_status = QDF_STATUS_E_NOMEM;
3683 goto err_wma_handle;
3684 }
3685
3686 wma_set_default_tgt_config(wma_handle, wlan_res_cfg, cds_cfg);
3687 wma_update_num_tdls_vdevs_if_11be_mlo(psoc, wlan_res_cfg);
3688
3689 qdf_status = wlan_mlme_get_tx_chainmask_cck(psoc, &val);
3690 if (qdf_status != QDF_STATUS_SUCCESS) {
3691 wma_err("Failed to get tx_chainmask_cck");
3692 qdf_status = QDF_STATUS_E_FAILURE;
3693 goto err_wma_handle;
3694 }
3695 wma_handle->tx_chain_mask_cck = val;
3696
3697 qdf_status = wlan_mlme_get_self_gen_frm_pwr(psoc, &self_gen_frm_pwr);
3698 if (qdf_status != QDF_STATUS_SUCCESS)
3699 wma_err("Failed to get self_gen_frm_pwr");
3700 wma_handle->self_gen_frm_pwr = self_gen_frm_pwr;
3701
3702 cds_cfg->max_bssid = WLAN_MAX_VDEVS;
3703
3704 wma_handle->max_station = cds_cfg->max_station;
3705 wma_handle->max_bssid = cds_cfg->max_bssid;
3706 wma_handle->enable_mc_list =
3707 ucfg_pmo_is_mc_addr_list_enabled(wma_handle->psoc);
3708 wma_handle->active_uc_apf_mode =
3709 ucfg_pmo_get_active_uc_apf_mode(wma_handle->psoc);
3710 wma_handle->active_mc_bc_apf_mode =
3711 ucfg_pmo_get_active_mc_bc_apf_mode(wma_handle->psoc);
3712 wma_handle->link_stats_results = NULL;
3713 #ifdef WLAN_FEATURE_LPSS
3714 wma_handle->is_lpass_enabled = cds_cfg->is_lpass_enabled;
3715 #endif
3716 wma_handle->interfaces = qdf_mem_malloc(sizeof(struct wma_txrx_node) *
3717 wma_handle->max_bssid);
3718 if (!wma_handle->interfaces) {
3719 qdf_status = QDF_STATUS_E_NOMEM;
3720 goto err_scn_context;
3721 }
3722
3723 for (i = 0; i < wma_handle->max_bssid; ++i)
3724 wma_vdev_init(&wma_handle->interfaces[i]);
3725
3726 /* Register the debug print event handler */
3727 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3728 wmi_debug_print_event_id,
3729 wma_unified_debug_print_event_handler,
3730 WMA_RX_SERIALIZER_CTX);
3731 /* Register profiling event Handler */
3732 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3733 wmi_wlan_profile_data_event_id,
3734 wma_profile_data_report_event_handler,
3735 WMA_RX_SERIALIZER_CTX);
3736
3737 wma_handle->tgt_cfg_update_cb = tgt_cfg_cb;
3738 wma_handle->old_hw_mode_index = WMA_DEFAULT_HW_MODE_INDEX;
3739 wma_handle->new_hw_mode_index = WMA_DEFAULT_HW_MODE_INDEX;
3740 wma_handle->saved_chan.num_channels = 0;
3741 wma_handle->fw_timeout_crash = cds_cfg->fw_timeout_crash;
3742
3743 qdf_status = qdf_mc_timer_init(&wma_handle->service_ready_ext_timer,
3744 QDF_TIMER_TYPE_SW,
3745 wma_service_ready_ext_evt_timeout,
3746 wma_handle);
3747 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
3748 wma_err("Failed to initialize service ready ext timeout");
3749 goto err_event_init;
3750 }
3751
3752 qdf_status = qdf_event_create(&wma_handle->target_suspend);
3753 if (qdf_status != QDF_STATUS_SUCCESS) {
3754 wma_err("target suspend event initialization failed");
3755 goto err_event_init;
3756 }
3757
3758 /* Init Tx Frame Complete event */
3759 qdf_status = qdf_event_create(&wma_handle->tx_frm_download_comp_event);
3760 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
3761 wma_err("failed to init tx_frm_download_comp_event");
3762 goto err_event_init;
3763 }
3764
3765 /* Init tx queue empty check event */
3766 qdf_status = qdf_event_create(&wma_handle->tx_queue_empty_event);
3767 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
3768 wma_err("failed to init tx_queue_empty_event");
3769 goto err_event_init;
3770 }
3771
3772 qdf_status = cds_shutdown_notifier_register(wma_shutdown_notifier_cb,
3773 wma_handle);
3774 if (qdf_status != QDF_STATUS_SUCCESS) {
3775 wma_err("Shutdown notifier register failed: %d", qdf_status);
3776 goto err_event_init;
3777 }
3778
3779 qdf_status = qdf_event_create(&wma_handle->runtime_suspend);
3780 if (qdf_status != QDF_STATUS_SUCCESS) {
3781 wma_err("runtime_suspend event initialization failed");
3782 goto err_event_init;
3783 }
3784
3785 qdf_status = qdf_event_create(&wma_handle->recovery_event);
3786 if (qdf_status != QDF_STATUS_SUCCESS) {
3787 wma_err("recovery event initialization failed");
3788 goto err_event_init;
3789 }
3790
3791 qdf_status = qdf_mutex_create(&wma_handle->radio_stats_lock);
3792 if (QDF_IS_STATUS_ERROR(qdf_status)) {
3793 wma_err("Failed to create radio stats mutex");
3794 goto err_event_init;
3795 }
3796
3797 qdf_list_create(&wma_handle->wma_hold_req_queue,
3798 MAX_ENTRY_HOLD_REQ_QUEUE);
3799 qdf_spinlock_create(&wma_handle->wma_hold_req_q_lock);
3800 qdf_atomic_init(&wma_handle->is_wow_bus_suspended);
3801 qdf_atomic_init(&wma_handle->sap_num_clients_connected);
3802 qdf_atomic_init(&wma_handle->go_num_clients_connected);
3803
3804 /* register for STA kickout function */
3805 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3806 wmi_peer_sta_kickout_event_id,
3807 wma_peer_sta_kickout_event_handler,
3808 WMA_RX_SERIALIZER_CTX);
3809 /* register for fw state response event */
3810 wma_register_fw_state_events(wma_handle->wmi_handle);
3811
3812 #ifdef WLAN_POWER_DEBUG
3813 /* register for Chip Power stats event */
3814 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3815 wmi_pdev_chip_power_stats_event_id,
3816 wma_unified_power_debug_stats_event_handler,
3817 WMA_RX_SERIALIZER_CTX);
3818 #endif
3819 #ifdef WLAN_FEATURE_BEACON_RECEPTION_STATS
3820 /* register for beacon stats event */
3821 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3822 wmi_vdev_bcn_reception_stats_event_id,
3823 wma_unified_beacon_debug_stats_event_handler,
3824 WMA_RX_SERIALIZER_CTX);
3825 #endif
3826
3827 #if defined(CLD_PM_QOS) && defined(WLAN_FEATURE_LL_MODE)
3828 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3829 wmi_vdev_bcn_latency_event_id,
3830 wma_vdev_bcn_latency_event_handler,
3831 WMA_RX_SERIALIZER_CTX);
3832 #endif
3833 /* register for linkspeed response event */
3834 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3835 wmi_peer_estimated_linkspeed_event_id,
3836 wma_link_speed_event_handler,
3837 WMA_RX_SERIALIZER_CTX);
3838
3839 #ifdef FEATURE_OEM_DATA_SUPPORT
3840 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3841 wmi_oem_response_event_id,
3842 wma_oem_data_response_handler,
3843 WMA_RX_SERIALIZER_CTX);
3844 #endif /* FEATURE_OEM_DATA_SUPPORT */
3845
3846 /* Register beacon tx complete event id. The event is required
3847 * for sending channel switch announcement frames
3848 */
3849 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3850 wmi_offload_bcn_tx_status_event_id,
3851 wma_unified_bcntx_status_event_handler,
3852 WMA_RX_SERIALIZER_CTX);
3853
3854 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3855 wmi_update_vdev_rate_stats_event_id,
3856 wma_link_status_event_handler,
3857 WMA_RX_SERIALIZER_CTX);
3858
3859 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3860 wmi_roam_scan_stats_event_id,
3861 wma_roam_scan_stats_event_handler,
3862 WMA_RX_SERIALIZER_CTX);
3863
3864 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3865 wmi_pdev_cold_boot_cal_event_id,
3866 wma_cold_boot_cal_event_handler,
3867 WMA_RX_WORK_CTX);
3868
3869 #ifdef FEATURE_OEM_DATA
3870 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3871 wmi_oem_data_event_id,
3872 wma_oem_event_handler,
3873 WMA_RX_WORK_CTX);
3874 #endif
3875
3876 #ifdef WLAN_FEATURE_LINK_LAYER_STATS
3877 /* Register event handler for processing Link Layer Stats
3878 * response from the FW
3879 */
3880 wma_register_ll_stats_event_handler(wma_handle);
3881
3882 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */
3883
3884 wmi_set_tgt_assert(wma_handle->wmi_handle,
3885 cds_cfg->force_target_assert_enabled);
3886 /* Firmware debug log */
3887 qdf_status = dbglog_init(wma_handle->wmi_handle);
3888 if (qdf_status != QDF_STATUS_SUCCESS) {
3889 wma_err("Firmware Dbglog initialization failed");
3890 goto err_dbglog_init;
3891 }
3892
3893 wma_handle->staMaxLIModDtim = cds_cfg->sta_maxlimod_dtim;
3894 wma_handle->sta_max_li_mod_dtim_ms = cds_cfg->sta_maxlimod_dtim_ms;
3895 wma_handle->staModDtim = ucfg_pmo_get_sta_mod_dtim(wma_handle->psoc);
3896 wma_handle->staDynamicDtim =
3897 ucfg_pmo_get_sta_dynamic_dtim(wma_handle->psoc);
3898
3899 #ifdef WLAN_FEATURE_STATS_EXT
3900 /* register for extended stats event */
3901 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3902 wmi_stats_ext_event_id,
3903 wma_stats_ext_event_handler,
3904 WMA_RX_SERIALIZER_CTX);
3905 #endif /* WLAN_FEATURE_STATS_EXT */
3906 #ifdef FEATURE_WLAN_EXTSCAN
3907 wma_register_extscan_event_handler(wma_handle);
3908 #endif /* WLAN_FEATURE_STATS_EXT */
3909
3910 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3911 wmi_rssi_breach_event_id,
3912 wma_rssi_breached_event_handler,
3913 WMA_RX_SERIALIZER_CTX);
3914
3915 qdf_wake_lock_create(&wma_handle->wmi_cmd_rsp_wake_lock,
3916 "wlan_fw_rsp_wakelock");
3917 qdf_runtime_lock_init(&wma_handle->wmi_cmd_rsp_runtime_lock);
3918 qdf_runtime_lock_init(&wma_handle->sap_prevent_runtime_pm_lock);
3919 qdf_runtime_lock_init(&wma_handle->ndp_prevent_runtime_pm_lock);
3920
3921 /* Register peer assoc conf event handler */
3922 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3923 wmi_peer_assoc_conf_event_id,
3924 wma_peer_assoc_conf_handler,
3925 WMA_RX_SERIALIZER_CTX);
3926 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3927 wmi_peer_create_conf_event_id,
3928 wma_peer_create_confirm_handler,
3929 WMA_RX_SERIALIZER_CTX);
3930 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3931 wmi_peer_delete_response_event_id,
3932 wma_peer_delete_handler,
3933 WMA_RX_SERIALIZER_CTX);
3934 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3935 wmi_chan_info_event_id,
3936 wma_chan_info_event_handler,
3937 WMA_RX_SERIALIZER_CTX);
3938 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3939 wmi_dbg_mesg_flush_complete_event_id,
3940 wma_flush_complete_evt_handler,
3941 WMA_RX_WORK_CTX);
3942 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3943 wmi_report_rx_aggr_failure_event_id,
3944 wma_rx_aggr_failure_event_handler,
3945 WMA_RX_SERIALIZER_CTX);
3946
3947 wmi_unified_register_event_handler(
3948 wma_handle->wmi_handle,
3949 wmi_coex_report_antenna_isolation_event_id,
3950 wma_antenna_isolation_event_handler,
3951 WMA_RX_SERIALIZER_CTX);
3952
3953 wma_handle->ito_repeat_count = cds_cfg->ito_repeat_count;
3954 wma_handle->bandcapability = cds_cfg->bandcapability;
3955
3956 /* Register PWR_SAVE_FAIL event only in case of recovery(1) */
3957 if (ucfg_pmo_get_auto_power_fail_mode(wma_handle->psoc) ==
3958 PMO_FW_TO_SEND_WOW_IND_ON_PWR_FAILURE) {
3959 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3960 wmi_pdev_chip_pwr_save_failure_detect_event_id,
3961 wma_chip_power_save_failure_detected_handler,
3962 WMA_RX_WORK_CTX);
3963 }
3964
3965 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3966 wmi_pdev_div_rssi_antid_event_id,
3967 wma_pdev_div_info_evt_handler,
3968 WMA_RX_WORK_CTX);
3969
3970 wmi_unified_register_event_handler(wma_handle->wmi_handle,
3971 wmi_get_ani_level_event_id,
3972 wma_get_ani_level_evt_handler,
3973 WMA_RX_WORK_CTX);
3974
3975 wma_register_debug_callback();
3976 wifi_pos_register_get_phy_mode_cb(wma_handle->psoc,
3977 wma_get_phy_mode_cb);
3978 wifi_pos_register_get_fw_phy_mode_for_freq_cb(
3979 wma_handle->psoc,
3980 wma_get_fw_phy_mode_for_freq_cb);
3981
3982 /* Register callback with PMO so PMO can update the vdev pause bitmap*/
3983 pmo_register_pause_bitmap_notifier(wma_handle->psoc,
3984 wma_vdev_update_pause_bitmap);
3985 pmo_register_get_pause_bitmap(wma_handle->psoc,
3986 wma_vdev_get_pause_bitmap);
3987 pmo_register_is_device_in_low_pwr_mode(wma_handle->psoc,
3988 wma_vdev_is_device_in_low_pwr_mode);
3989 pmo_register_get_dtim_period_callback(wma_handle->psoc,
3990 wma_vdev_get_dtim_period);
3991 pmo_register_get_beacon_interval_callback(wma_handle->psoc,
3992 wma_vdev_get_beacon_interval);
3993 wma_cbacks.wma_get_connection_info = wma_get_connection_info;
3994 wma_register_nan_callbacks(wma_handle);
3995 wma_register_pkt_capture_callbacks(wma_handle);
3996 qdf_status = policy_mgr_register_wma_cb(wma_handle->psoc, &wma_cbacks);
3997 if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
3998 wma_err("Failed to register wma cb with Policy Manager");
3999 }
4000
4001 wmi_unified_register_event_handler(wma_handle->wmi_handle,
4002 wmi_phyerr_event_id,
4003 wma_unified_phyerr_rx_event_handler,
4004 WMA_RX_WORK_CTX);
4005
4006 wmi_unified_register_event_handler(wma_handle->wmi_handle,
4007 wmi_sap_obss_detection_report_event_id,
4008 wma_vdev_obss_detection_info_handler,
4009 WMA_RX_SERIALIZER_CTX);
4010
4011 wmi_unified_register_event_handler(wma_handle->wmi_handle,
4012 wmi_obss_color_collision_report_event_id,
4013 wma_vdev_bss_color_collision_info_handler,
4014 WMA_RX_WORK_CTX);
4015
4016 wma_register_twt_events(wma_handle);
4017
4018 wma_register_apf_events(wma_handle);
4019 wma_register_md_events(wma_handle);
4020 wma_register_wlm_stats_events(wma_handle);
4021 wma_register_wlm_latency_level_event(wma_handle);
4022 wma_register_mws_coex_events(wma_handle);
4023 wma_trace_init();
4024 wma_set_exclude_selftx_from_cca_busy_time(
4025 cds_cfg->exclude_selftx_from_cca_busy,
4026 wma_handle);
4027 return QDF_STATUS_SUCCESS;
4028
4029 err_dbglog_init:
4030 qdf_status = qdf_mutex_destroy(&wma_handle->radio_stats_lock);
4031 if (QDF_IS_STATUS_ERROR(qdf_status))
4032 wma_err("Failed to destroy radio stats mutex");
4033
4034 qdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
4035 qdf_runtime_lock_deinit(&wma_handle->ndp_prevent_runtime_pm_lock);
4036 qdf_runtime_lock_deinit(&wma_handle->sap_prevent_runtime_pm_lock);
4037 qdf_runtime_lock_deinit(&wma_handle->wmi_cmd_rsp_runtime_lock);
4038 qdf_spinlock_destroy(&wma_handle->wma_hold_req_q_lock);
4039 err_event_init:
4040 wmi_unified_unregister_event_handler(wma_handle->wmi_handle,
4041 wmi_debug_print_event_id);
4042
4043 for (i = 0; i < wma_handle->max_bssid; ++i)
4044 wma_vdev_deinit(&wma_handle->interfaces[i]);
4045
4046 qdf_mem_free(wma_handle->interfaces);
4047
4048 err_scn_context:
4049 qdf_mem_free(((struct cds_context *) cds_context)->cfg_ctx);
4050 ((struct cds_context *)cds_context)->cfg_ctx = NULL;
4051 qdf_mem_free(wmi_handle);
4052
4053 err_wma_handle:
4054 wlan_objmgr_psoc_release_ref(psoc, WLAN_LEGACY_WMA_ID);
4055 err_get_psoc_ref:
4056 target_if_free_psoc_tgt_info(psoc);
4057 if (cds_get_conparam() != QDF_GLOBAL_FTM_MODE) {
4058 qdf_wake_lock_destroy(&wma_handle->go_d3_wow_wake_lock);
4059 qdf_wake_lock_destroy(&wma_handle->sap_d3_wow_wake_lock);
4060 #ifdef FEATURE_WLAN_EXTSCAN
4061 qdf_wake_lock_destroy(&wma_handle->extscan_wake_lock);
4062 #endif /* FEATURE_WLAN_EXTSCAN */
4063 qdf_wake_lock_destroy(&wma_handle->wow_wake_lock);
4064 qdf_wake_lock_destroy(&wma_handle->wow_auth_req_wl);
4065 qdf_wake_lock_destroy(&wma_handle->wow_assoc_req_wl);
4066 qdf_wake_lock_destroy(&wma_handle->wow_deauth_rec_wl);
4067 qdf_wake_lock_destroy(&wma_handle->wow_disassoc_rec_wl);
4068 qdf_wake_lock_destroy(&wma_handle->wow_ap_assoc_lost_wl);
4069 qdf_wake_lock_destroy(&wma_handle->wow_auto_shutdown_wl);
4070 qdf_wake_lock_destroy(&wma_handle->roam_ho_wl);
4071 qdf_wake_lock_destroy(&wma_handle->roam_preauth_wl);
4072 qdf_wake_lock_destroy(&wma_handle->probe_req_wps_wl);
4073 }
4074 err_free_wma_handle:
4075 cds_free_context(QDF_MODULE_ID_WMA, wma_handle);
4076
4077 wma_debug("Exit");
4078
4079 return qdf_status;
4080 }
4081
4082 /**
4083 * wma_pre_start() - wma pre start
4084 *
4085 * Return: 0 on success, errno on failure
4086 */
wma_pre_start(void)4087 QDF_STATUS wma_pre_start(void)
4088 {
4089 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
4090 tp_wma_handle wma_handle;
4091 void *htc_handle;
4092
4093 wma_debug("Enter");
4094
4095 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
4096
4097 /* Validate the wma_handle */
4098 if (!wma_handle) {
4099 qdf_status = QDF_STATUS_E_INVAL;
4100 goto end;
4101 }
4102
4103 htc_handle = lmac_get_htc_hdl(wma_handle->psoc);
4104 if (!htc_handle) {
4105 wma_err("invalid htc handle");
4106 qdf_status = QDF_STATUS_E_INVAL;
4107 goto end;
4108 }
4109
4110 /* Open endpoint for ctrl path - WMI <--> HTC */
4111 qdf_status = wmi_unified_connect_htc_service(wma_handle->wmi_handle,
4112 htc_handle);
4113 if (qdf_status != QDF_STATUS_SUCCESS) {
4114 wma_err("wmi_unified_connect_htc_service");
4115 if (!cds_is_fw_down())
4116 QDF_BUG(0);
4117
4118 qdf_status = QDF_STATUS_E_FAULT;
4119 goto end;
4120 }
4121
4122 /* Open endpoint for wmi diag path */
4123 qdf_status = wmi_diag_connect_pdev_htc_service(wma_handle->wmi_handle,
4124 htc_handle);
4125 if (qdf_status != QDF_STATUS_SUCCESS) {
4126 wma_err("wmi_diag_connect_pdev_htc_service");
4127 if (!cds_is_fw_down())
4128 QDF_BUG(0);
4129
4130 qdf_status = QDF_STATUS_E_FAULT;
4131 goto end;
4132 }
4133
4134 wma_debug("WMA --> wmi_unified_connect_htc_service - success");
4135
4136 end:
4137 wma_debug("Exit");
4138 return qdf_status;
4139 }
4140
wma_send_msg_by_priority(tp_wma_handle wma_handle,uint16_t msg_type,void * body_ptr,uint32_t body_val,bool is_high_priority)4141 void wma_send_msg_by_priority(tp_wma_handle wma_handle, uint16_t msg_type,
4142 void *body_ptr, uint32_t body_val, bool is_high_priority)
4143 {
4144 struct scheduler_msg msg = {0};
4145 QDF_STATUS status;
4146
4147 msg.type = msg_type;
4148 msg.bodyval = body_val;
4149 msg.bodyptr = body_ptr;
4150 msg.flush_callback = wma_discard_fw_event;
4151
4152 status = scheduler_post_msg_by_priority(QDF_MODULE_ID_PE,
4153 &msg, is_high_priority);
4154 if (!QDF_IS_STATUS_SUCCESS(status)) {
4155 if (body_ptr)
4156 qdf_mem_free(body_ptr);
4157 }
4158 }
4159
4160
wma_send_msg(tp_wma_handle wma_handle,uint16_t msg_type,void * body_ptr,uint32_t body_val)4161 void wma_send_msg(tp_wma_handle wma_handle, uint16_t msg_type,
4162 void *body_ptr, uint32_t body_val)
4163 {
4164 wma_send_msg_by_priority(wma_handle, msg_type,
4165 body_ptr, body_val, false);
4166 }
4167
wma_send_msg_high_priority(tp_wma_handle wma_handle,uint16_t msg_type,void * body_ptr,uint32_t body_val)4168 void wma_send_msg_high_priority(tp_wma_handle wma_handle, uint16_t msg_type,
4169 void *body_ptr, uint32_t body_val)
4170 {
4171 wma_send_msg_by_priority(wma_handle, msg_type,
4172 body_ptr, body_val, true);
4173 }
4174
4175 /**
4176 * wma_set_base_macaddr_indicate() - set base mac address in fw
4177 * @wma_handle: wma handle
4178 * @customAddr: base mac address
4179 *
4180 * Return: 0 for success or error code
4181 */
wma_set_base_macaddr_indicate(tp_wma_handle wma_handle,tSirMacAddr * customAddr)4182 static int wma_set_base_macaddr_indicate(tp_wma_handle wma_handle,
4183 tSirMacAddr *customAddr)
4184 {
4185 int err;
4186
4187 err = wmi_unified_set_base_macaddr_indicate_cmd(wma_handle->wmi_handle,
4188 (uint8_t *)customAddr);
4189 if (err)
4190 return -EIO;
4191 wma_debug("Base MAC Addr: " QDF_MAC_ADDR_FMT,
4192 QDF_MAC_ADDR_REF((*customAddr)));
4193
4194 return 0;
4195 }
4196
4197 /**
4198 * wma_log_supported_evt_handler() - Enable/Disable FW diag/log events
4199 * @handle: WMA handle
4200 * @event: Event received from FW
4201 * @len: Length of the event
4202 *
4203 * Enables the low frequency events and disables the high frequency
4204 * events. Bit 17 indicates if the event if low/high frequency.
4205 * 1 - high frequency, 0 - low frequency
4206 *
4207 * Return: 0 on successfully enabling/disabling the events
4208 */
wma_log_supported_evt_handler(void * handle,uint8_t * event,uint32_t len)4209 static int wma_log_supported_evt_handler(void *handle,
4210 uint8_t *event,
4211 uint32_t len)
4212 {
4213 tp_wma_handle wma = (tp_wma_handle) handle;
4214
4215 if (wmi_unified_log_supported_evt_cmd(wma->wmi_handle,
4216 event, len))
4217 return -EINVAL;
4218
4219 return 0;
4220 }
4221
4222 /**
4223 * wma_pdev_set_hw_mode_resp_evt_handler() - Set HW mode resp evt handler
4224 * @handle: WMI handle
4225 * @event: Event received from FW
4226 * @len: Length of the event
4227 *
4228 * Event handler for WMI_PDEV_SET_HW_MODE_RESP_EVENTID that is sent to host
4229 * driver in response to a WMI_PDEV_SET_HW_MODE_CMDID being sent to WLAN
4230 * firmware
4231 *
4232 * Return: QDF_STATUS
4233 */
wma_pdev_set_hw_mode_resp_evt_handler(void * handle,uint8_t * event,uint32_t len)4234 static int wma_pdev_set_hw_mode_resp_evt_handler(void *handle,
4235 uint8_t *event,
4236 uint32_t len)
4237 {
4238 WMI_PDEV_SET_HW_MODE_RESP_EVENTID_param_tlvs *param_buf;
4239 wmi_pdev_set_hw_mode_response_event_fixed_param *wmi_event;
4240 wmi_pdev_set_hw_mode_response_vdev_mac_entry *vdev_mac_entry;
4241 uint32_t i;
4242 struct sir_set_hw_mode_resp *hw_mode_resp;
4243 tp_wma_handle wma = (tp_wma_handle) handle;
4244
4245 if (wma_validate_handle(wma)) {
4246 /* Since WMA handle itself is NULL, we cannot send fail
4247 * response back to LIM here
4248 */
4249 return QDF_STATUS_E_NULL_VALUE;
4250 }
4251
4252 wma_release_wakelock(&wma->wmi_cmd_rsp_wake_lock);
4253 wma_remove_req(wma, 0, WMA_PDEV_SET_HW_MODE_RESP);
4254
4255 hw_mode_resp = qdf_mem_malloc(sizeof(*hw_mode_resp));
4256 if (!hw_mode_resp) {
4257 /* Since this memory allocation itself failed, we cannot
4258 * send fail response back to LIM here
4259 */
4260 return QDF_STATUS_E_NULL_VALUE;
4261 }
4262
4263 param_buf = (WMI_PDEV_SET_HW_MODE_RESP_EVENTID_param_tlvs *) event;
4264 if (!param_buf) {
4265 wma_err("Invalid WMI_PDEV_SET_HW_MODE_RESP_EVENTID event");
4266 /* Need to send response back to upper layer to free
4267 * active command list
4268 */
4269 goto fail;
4270 }
4271 if (param_buf->fixed_param->num_vdev_mac_entries >=
4272 MAX_VDEV_SUPPORTED) {
4273 wma_err("num_vdev_mac_entries crossed max value");
4274 goto fail;
4275 }
4276
4277 wmi_event = param_buf->fixed_param;
4278 if (wmi_event->num_vdev_mac_entries >
4279 param_buf->num_wmi_pdev_set_hw_mode_response_vdev_mac_mapping) {
4280 wma_err("Invalid num_vdev_mac_entries: %d",
4281 wmi_event->num_vdev_mac_entries);
4282 goto fail;
4283 }
4284 hw_mode_resp->status = wmi_event->status;
4285 hw_mode_resp->cfgd_hw_mode_index = wmi_event->cfgd_hw_mode_index;
4286 hw_mode_resp->num_vdev_mac_entries = wmi_event->num_vdev_mac_entries;
4287
4288 wma->set_hw_mode_resp_status = wmi_event->status;
4289 wma_debug("status:%d cfgd_hw_mode_index:%d num_vdev_mac_entries:%d",
4290 wmi_event->status,
4291 wmi_event->cfgd_hw_mode_index,
4292 wmi_event->num_vdev_mac_entries);
4293 vdev_mac_entry =
4294 param_buf->wmi_pdev_set_hw_mode_response_vdev_mac_mapping;
4295
4296 /* Store the vdev-mac map in WMA and prepare to send to PE */
4297 for (i = 0; i < wmi_event->num_vdev_mac_entries; i++) {
4298 uint32_t vdev_id, mac_id, pdev_id;
4299
4300 vdev_id = vdev_mac_entry[i].vdev_id;
4301 pdev_id = vdev_mac_entry[i].pdev_id;
4302 if (pdev_id == OL_TXRX_PDEV_ID) {
4303 wma_err("soc level id received for mac id");
4304 goto fail;
4305 }
4306 if (vdev_id >= wma->max_bssid) {
4307 wma_err("vdev_id: %d is invalid, max_bssid: %d",
4308 vdev_id, wma->max_bssid);
4309 goto fail;
4310 }
4311
4312 mac_id = WMA_PDEV_TO_MAC_MAP(vdev_mac_entry[i].pdev_id);
4313
4314 wma_debug("vdev_id:%d mac_id:%d", vdev_id, mac_id);
4315
4316 hw_mode_resp->vdev_mac_map[i].vdev_id = vdev_id;
4317 hw_mode_resp->vdev_mac_map[i].mac_id = mac_id;
4318 wma_update_intf_hw_mode_params(vdev_id, mac_id,
4319 wmi_event->cfgd_hw_mode_index);
4320 }
4321
4322 if (hw_mode_resp->status == SET_HW_MODE_STATUS_OK) {
4323 if (WMA_DEFAULT_HW_MODE_INDEX == wma->new_hw_mode_index) {
4324 wma->new_hw_mode_index = wmi_event->cfgd_hw_mode_index;
4325 } else {
4326 wma->old_hw_mode_index = wma->new_hw_mode_index;
4327 wma->new_hw_mode_index = wmi_event->cfgd_hw_mode_index;
4328 }
4329 policy_mgr_update_hw_mode_index(wma->psoc,
4330 wmi_event->cfgd_hw_mode_index);
4331 }
4332
4333 wma_debug("Updated: old_hw_mode_index:%d new_hw_mode_index:%d",
4334 wma->old_hw_mode_index, wma->new_hw_mode_index);
4335
4336 wma_send_msg(wma, SIR_HAL_PDEV_SET_HW_MODE_RESP,
4337 (void *) hw_mode_resp, 0);
4338
4339 return QDF_STATUS_SUCCESS;
4340
4341 fail:
4342 wma_err("Sending fail response to LIM");
4343 hw_mode_resp->status = SET_HW_MODE_STATUS_ECANCELED;
4344 hw_mode_resp->cfgd_hw_mode_index = 0;
4345 hw_mode_resp->num_vdev_mac_entries = 0;
4346 wma_send_msg(wma, SIR_HAL_PDEV_SET_HW_MODE_RESP,
4347 (void *) hw_mode_resp, 0);
4348
4349 return QDF_STATUS_E_FAILURE;
4350 }
4351
4352 /**
4353 * wma_process_pdev_hw_mode_trans_ind() - Process HW mode transition info
4354 *
4355 * @handle: WMA handle
4356 * @fixed_param: Event fixed parameters
4357 * @vdev_mac_entry: vdev mac entry
4358 * @hw_mode_trans_ind: Buffer to store parsed information
4359 *
4360 * Parses fixed_param, vdev_mac_entry and fills in the information into
4361 * hw_mode_trans_ind and wma
4362 *
4363 * Return: None
4364 */
wma_process_pdev_hw_mode_trans_ind(void * handle,wmi_pdev_hw_mode_transition_event_fixed_param * fixed_param,wmi_pdev_set_hw_mode_response_vdev_mac_entry * vdev_mac_entry,struct cm_hw_mode_trans_ind * hw_mode_trans_ind)4365 void wma_process_pdev_hw_mode_trans_ind(void *handle,
4366 wmi_pdev_hw_mode_transition_event_fixed_param *fixed_param,
4367 wmi_pdev_set_hw_mode_response_vdev_mac_entry *vdev_mac_entry,
4368 struct cm_hw_mode_trans_ind *hw_mode_trans_ind)
4369 {
4370 uint32_t i;
4371 tp_wma_handle wma = (tp_wma_handle) handle;
4372
4373 if (fixed_param->num_vdev_mac_entries > MAX_VDEV_SUPPORTED) {
4374 wma_err("Number of Vdev mac entries %d exceeded max vdev supported %d",
4375 fixed_param->num_vdev_mac_entries,
4376 MAX_VDEV_SUPPORTED);
4377 return;
4378 }
4379 hw_mode_trans_ind->old_hw_mode_index = fixed_param->old_hw_mode_index;
4380 hw_mode_trans_ind->new_hw_mode_index = fixed_param->new_hw_mode_index;
4381 hw_mode_trans_ind->num_vdev_mac_entries =
4382 fixed_param->num_vdev_mac_entries;
4383
4384 if (!vdev_mac_entry) {
4385 wma_debug("null vdev_mac_entry");
4386 goto update_hw_mode;
4387 }
4388
4389 /* Store the vdev-mac map in WMA and send to policy manager */
4390 for (i = 0; i < fixed_param->num_vdev_mac_entries; i++) {
4391 uint32_t vdev_id, mac_id, pdev_id;
4392
4393 vdev_id = vdev_mac_entry[i].vdev_id;
4394 pdev_id = vdev_mac_entry[i].pdev_id;
4395
4396 if (pdev_id == OL_TXRX_PDEV_ID) {
4397 wma_err("soc level id received for mac id");
4398 return;
4399 }
4400 if (vdev_id >= wma->max_bssid) {
4401 wma_err("vdev_id: %d is invalid, max_bssid: %d",
4402 vdev_id, wma->max_bssid);
4403 return;
4404 }
4405
4406 mac_id = WMA_PDEV_TO_MAC_MAP(vdev_mac_entry[i].pdev_id);
4407 hw_mode_trans_ind->vdev_mac_map[i].vdev_id = vdev_id;
4408 hw_mode_trans_ind->vdev_mac_map[i].mac_id = mac_id;
4409 wma_update_intf_hw_mode_params(vdev_id, mac_id,
4410 fixed_param->new_hw_mode_index);
4411 }
4412 update_hw_mode:
4413 wma->old_hw_mode_index = fixed_param->old_hw_mode_index;
4414 wma->new_hw_mode_index = fixed_param->new_hw_mode_index;
4415 policy_mgr_update_new_hw_mode_index(wma->psoc,
4416 fixed_param->new_hw_mode_index);
4417 policy_mgr_update_old_hw_mode_index(wma->psoc,
4418 fixed_param->old_hw_mode_index);
4419 }
4420
4421 static void
wma_process_mac_freq_mapping(struct cm_hw_mode_trans_ind * hw_mode_trans_ind,WMI_PDEV_HW_MODE_TRANSITION_EVENTID_param_tlvs * param_buf)4422 wma_process_mac_freq_mapping(struct cm_hw_mode_trans_ind *hw_mode_trans_ind,
4423 WMI_PDEV_HW_MODE_TRANSITION_EVENTID_param_tlvs *param_buf)
4424 {
4425 uint32_t i, num_mac_freq;
4426 wmi_pdev_band_to_mac *mac_freq;
4427
4428 mac_freq = param_buf->mac_freq_mapping;
4429 num_mac_freq = param_buf->num_mac_freq_mapping;
4430
4431 if (!mac_freq) {
4432 wma_debug("mac_freq Null");
4433 return;
4434 }
4435
4436 if (!num_mac_freq || num_mac_freq > MAX_FREQ_RANGE_NUM) {
4437 wma_debug("num mac freq invalid %d", num_mac_freq);
4438 return;
4439 }
4440
4441 hw_mode_trans_ind->num_freq_map = num_mac_freq;
4442 for (i = 0; i < num_mac_freq; i++) {
4443 hw_mode_trans_ind->mac_freq_map[i].mac_id =
4444 WMA_PDEV_TO_MAC_MAP(mac_freq[i].pdev_id);
4445 hw_mode_trans_ind->mac_freq_map[i].start_freq =
4446 mac_freq[i].start_freq;
4447 hw_mode_trans_ind->mac_freq_map[i].end_freq =
4448 mac_freq[i].end_freq;
4449 }
4450 }
4451
4452 /**
4453 * wma_pdev_hw_mode_transition_evt_handler() - HW mode transition evt handler
4454 * @handle: WMI handle
4455 * @event: Event received from FW
4456 * @len: Length of the event
4457 *
4458 * Event handler for WMI_PDEV_HW_MODE_TRANSITION_EVENTID that indicates an
4459 * asynchronous hardware mode transition. This event notifies the host driver
4460 * that firmware independently changed the hardware mode for some reason, such
4461 * as Coex, LFR 3.0, etc
4462 *
4463 * Return: Success on receiving valid params from FW
4464 */
wma_pdev_hw_mode_transition_evt_handler(void * handle,uint8_t * event,uint32_t len)4465 static int wma_pdev_hw_mode_transition_evt_handler(void *handle,
4466 uint8_t *event,
4467 uint32_t len)
4468 {
4469 WMI_PDEV_HW_MODE_TRANSITION_EVENTID_param_tlvs *param_buf;
4470 wmi_pdev_hw_mode_transition_event_fixed_param *wmi_event;
4471 wmi_pdev_set_hw_mode_response_vdev_mac_entry *vdev_mac_entry;
4472 struct cm_hw_mode_trans_ind *hw_mode_trans_ind;
4473 tp_wma_handle wma = (tp_wma_handle) handle;
4474
4475 if (wma_validate_handle(wma)) {
4476 /* This is an async event. So, not sending any event to LIM */
4477 return QDF_STATUS_E_NULL_VALUE;
4478 }
4479
4480 param_buf = (WMI_PDEV_HW_MODE_TRANSITION_EVENTID_param_tlvs *) event;
4481 if (!param_buf) {
4482 /* This is an async event. So, not sending any event to LIM */
4483 wma_err("Invalid WMI_PDEV_HW_MODE_TRANSITION_EVENTID event");
4484 return QDF_STATUS_E_FAILURE;
4485 }
4486
4487 if (param_buf->fixed_param->num_vdev_mac_entries > MAX_VDEV_SUPPORTED) {
4488 wma_err("num_vdev_mac_entries: %d crossed max value: %d",
4489 param_buf->fixed_param->num_vdev_mac_entries,
4490 MAX_VDEV_SUPPORTED);
4491 return QDF_STATUS_E_FAILURE;
4492 }
4493
4494 hw_mode_trans_ind = qdf_mem_malloc(sizeof(*hw_mode_trans_ind));
4495 if (!hw_mode_trans_ind)
4496 return QDF_STATUS_E_NOMEM;
4497
4498 wmi_event = param_buf->fixed_param;
4499 vdev_mac_entry =
4500 param_buf->wmi_pdev_set_hw_mode_response_vdev_mac_mapping;
4501 if (wmi_event->num_vdev_mac_entries >
4502 param_buf->num_wmi_pdev_set_hw_mode_response_vdev_mac_mapping) {
4503 wma_err("Invalid num_vdev_mac_entries: %d",
4504 wmi_event->num_vdev_mac_entries);
4505 qdf_mem_free(hw_mode_trans_ind);
4506 return -EINVAL;
4507 }
4508
4509 wma_process_pdev_hw_mode_trans_ind(wma, wmi_event, vdev_mac_entry,
4510 hw_mode_trans_ind);
4511 wma_process_mac_freq_mapping(hw_mode_trans_ind, param_buf);
4512
4513 if (policy_mgr_is_hwmode_offload_enabled(wma->psoc)) {
4514 policy_mgr_hw_mode_transition_cb(
4515 hw_mode_trans_ind->old_hw_mode_index,
4516 hw_mode_trans_ind->new_hw_mode_index,
4517 hw_mode_trans_ind->num_vdev_mac_entries,
4518 hw_mode_trans_ind->vdev_mac_map,
4519 hw_mode_trans_ind->num_freq_map,
4520 hw_mode_trans_ind->mac_freq_map,
4521 wma->psoc);
4522 qdf_mem_free(hw_mode_trans_ind);
4523 } else {
4524 struct scheduler_msg sme_msg = {0};
4525 QDF_STATUS status;
4526
4527 wma_debug("post eWNI_SME_HW_MODE_TRANS_IND");
4528 sme_msg.type = eWNI_SME_HW_MODE_TRANS_IND;
4529 sme_msg.bodyptr = hw_mode_trans_ind;
4530 sme_msg.flush_callback = wma_discard_fw_event;
4531
4532 status = scheduler_post_message(QDF_MODULE_ID_WMA,
4533 QDF_MODULE_ID_SME,
4534 QDF_MODULE_ID_SME, &sme_msg);
4535 if (QDF_IS_STATUS_ERROR(status))
4536 qdf_mem_free(hw_mode_trans_ind);
4537 }
4538
4539 return QDF_STATUS_SUCCESS;
4540 }
4541
4542 /**
4543 * wma_pdev_set_dual_mode_config_resp_evt_handler() - Dual mode evt handler
4544 * @handle: WMI handle
4545 * @event: Event received from FW
4546 * @len: Length of the event
4547 *
4548 * Notifies the host driver of the completion or failure of a
4549 * WMI_PDEV_SET_MAC_CONFIG_CMDID command. This event would be returned to
4550 * the host driver once the firmware has completed a reconfiguration of the Scan
4551 * and FW mode configuration. This changes could include entering or leaving a
4552 * dual mac configuration for either scan and/or more permanent firmware mode.
4553 *
4554 * Return: Success on receiving valid params from FW
4555 */
wma_pdev_set_dual_mode_config_resp_evt_handler(void * handle,uint8_t * event,uint32_t len)4556 static int wma_pdev_set_dual_mode_config_resp_evt_handler(void *handle,
4557 uint8_t *event,
4558 uint32_t len)
4559 {
4560 WMI_PDEV_SET_MAC_CONFIG_RESP_EVENTID_param_tlvs *param_buf;
4561 wmi_pdev_set_mac_config_response_event_fixed_param *wmi_event;
4562 tp_wma_handle wma = (tp_wma_handle) handle;
4563 struct sir_dual_mac_config_resp *dual_mac_cfg_resp;
4564
4565 if (wma_validate_handle(wma)) {
4566 /* Since the WMA handle is NULL, we cannot send resp to LIM.
4567 * So, returning from here.
4568 */
4569 return QDF_STATUS_E_NULL_VALUE;
4570 }
4571 wma_release_wakelock(&wma->wmi_cmd_rsp_wake_lock);
4572 wma_remove_req(wma, 0, WMA_PDEV_MAC_CFG_RESP);
4573
4574 dual_mac_cfg_resp = qdf_mem_malloc(sizeof(*dual_mac_cfg_resp));
4575 if (!dual_mac_cfg_resp)
4576 /* Since the mem alloc failed, we cannot send resp to LIM.
4577 * So, returning from here.
4578 */
4579 return QDF_STATUS_E_NULL_VALUE;
4580
4581 param_buf = (WMI_PDEV_SET_MAC_CONFIG_RESP_EVENTID_param_tlvs *)
4582 event;
4583 if (!param_buf) {
4584 wma_err("Invalid event");
4585 goto fail;
4586 }
4587
4588 wmi_event = param_buf->fixed_param;
4589 wma_debug("status: %d", wmi_event->status);
4590 dual_mac_cfg_resp->status = wmi_event->status;
4591
4592 if (SET_HW_MODE_STATUS_OK == dual_mac_cfg_resp->status) {
4593 policy_mgr_update_dbs_scan_config(wma->psoc);
4594 policy_mgr_update_dbs_fw_config(wma->psoc);
4595 }
4596
4597 /* Pass the message to PE */
4598 wma_send_msg(wma, SIR_HAL_PDEV_MAC_CFG_RESP,
4599 (void *) dual_mac_cfg_resp, 0);
4600
4601 return QDF_STATUS_SUCCESS;
4602
4603 fail:
4604 wma_err("Sending fail response to LIM");
4605 dual_mac_cfg_resp->status = SET_HW_MODE_STATUS_ECANCELED;
4606 wma_send_msg(wma, SIR_HAL_PDEV_MAC_CFG_RESP,
4607 (void *) dual_mac_cfg_resp, 0);
4608
4609 return QDF_STATUS_E_FAILURE;
4610
4611 }
4612
4613 #ifdef WLAN_CONV_SPECTRAL_ENABLE
wma_register_spectral_cmds(tp_wma_handle wma_handle)4614 static void wma_register_spectral_cmds(tp_wma_handle wma_handle)
4615 {
4616 struct spectral_wmi_ops cmd_ops;
4617
4618 cmd_ops.wmi_spectral_configure_cmd_send =
4619 wmi_unified_vdev_spectral_configure_cmd_send;
4620 cmd_ops.wmi_spectral_enable_cmd_send =
4621 wmi_unified_vdev_spectral_enable_cmd_send;
4622 wlan_register_spectral_wmi_ops(wma_handle->psoc, &cmd_ops);
4623 }
4624 #else
wma_register_spectral_cmds(tp_wma_handle wma_handle)4625 static void wma_register_spectral_cmds(tp_wma_handle wma_handle)
4626 {
4627 }
4628 #endif
4629 /**
4630 * wma_start() - wma start function.
4631 * Initialize event handlers and timers.
4632 *
4633 * Return: 0 on success, QDF Error on failure
4634 */
wma_start(void)4635 QDF_STATUS wma_start(void)
4636 {
4637 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
4638 tp_wma_handle wma_handle;
4639 struct wmi_unified *wmi_handle;
4640 struct mac_context *mac = NULL;
4641
4642 wma_debug("Enter");
4643
4644 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
4645 if (!wma_handle) {
4646 qdf_status = QDF_STATUS_E_INVAL;
4647 goto end;
4648 }
4649
4650 wmi_handle = get_wmi_unified_hdl_from_psoc(wma_handle->psoc);
4651 if (wmi_validate_handle(wmi_handle)) {
4652 qdf_status = QDF_STATUS_E_INVAL;
4653 goto end;
4654 }
4655
4656 mac = cds_get_context(QDF_MODULE_ID_PE);
4657 if (!mac) {
4658 qdf_status = QDF_STATUS_E_INVAL;
4659 goto end;
4660 }
4661
4662 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4663 wmi_wow_wakeup_host_event_id,
4664 wma_wow_wakeup_host_event,
4665 WMA_RX_TASKLET_CTX);
4666 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4667 wma_err("Failed to register wow wakeup host event handler");
4668 qdf_status = QDF_STATUS_E_FAILURE;
4669 goto end;
4670 }
4671
4672 if (wma_d0_wow_is_supported()) {
4673 qdf_status = wmi_unified_register_event_handler(
4674 wmi_handle,
4675 wmi_d0_wow_disable_ack_event_id,
4676 wma_d0_wow_disable_ack_event,
4677 WMA_RX_TASKLET_CTX);
4678 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4679 wma_err("Failed to register d0wow disable ack event handler");
4680 qdf_status = QDF_STATUS_E_FAILURE;
4681 goto end;
4682 }
4683 }
4684
4685 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4686 wmi_pdev_resume_event_id,
4687 wma_pdev_resume_event_handler,
4688 WMA_RX_TASKLET_CTX);
4689 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4690 wma_err("Failed to register PDEV resume event handler");
4691 qdf_status = QDF_STATUS_E_FAILURE;
4692 goto end;
4693 }
4694 #if defined(QCA_LL_LEGACY_TX_FLOW_CONTROL) || \
4695 defined(QCA_LL_TX_FLOW_CONTROL_V2) || defined(CONFIG_HL_SUPPORT)
4696 wma_debug("MCC TX Pause Event Handler register");
4697 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4698 wmi_tx_pause_event_id,
4699 wma_mcc_vdev_tx_pause_evt_handler,
4700 WMA_RX_TASKLET_CTX);
4701 #endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
4702
4703 wma_debug("Registering SAR2 response handler");
4704 qdf_status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
4705 wmi_wlan_sar2_result_event_id,
4706 wma_sar_rsp_evt_handler,
4707 WMA_RX_SERIALIZER_CTX);
4708 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4709 wma_err("Failed to register sar response event cb");
4710 qdf_status = QDF_STATUS_E_FAILURE;
4711 goto end;
4712 }
4713
4714 #ifdef FEATURE_WLAN_AUTO_SHUTDOWN
4715 wma_debug("Registering auto shutdown handler");
4716 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4717 wmi_host_auto_shutdown_event_id,
4718 wma_auto_shutdown_event_handler,
4719 WMA_RX_SERIALIZER_CTX);
4720 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4721 wma_err("Failed to register WMI Auto shutdown event handler");
4722 qdf_status = QDF_STATUS_E_FAILURE;
4723 goto end;
4724 }
4725 #endif /* FEATURE_WLAN_AUTO_SHUTDOWN */
4726 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4727 wmi_thermal_mgmt_event_id,
4728 wma_thermal_mgmt_evt_handler,
4729 WMA_RX_SERIALIZER_CTX);
4730 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4731 wma_err("Failed to register thermal mitigation event cb");
4732 qdf_status = QDF_STATUS_E_FAILURE;
4733 goto end;
4734 }
4735
4736 qdf_status = wma_ocb_register_callbacks(wma_handle);
4737 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4738 wma_err("Failed to register OCB callbacks");
4739 qdf_status = QDF_STATUS_E_FAILURE;
4740 goto end;
4741 }
4742
4743 qdf_status = QDF_STATUS_SUCCESS;
4744
4745 #ifdef QCA_WIFI_FTM
4746 /*
4747 * Tx mgmt attach requires TXRX context which is not created
4748 * in FTM mode. So skip the TX mgmt attach.
4749 */
4750 if (cds_get_conparam() == QDF_GLOBAL_FTM_MODE)
4751 goto end;
4752 #endif /* QCA_WIFI_FTM */
4753
4754 qdf_status = wma_tx_attach(wma_handle);
4755 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4756 wma_err("Failed to register tx management");
4757 goto end;
4758 }
4759
4760 /* Initialize log completion timeout */
4761 qdf_status = qdf_mc_timer_init(&wma_handle->log_completion_timer,
4762 QDF_TIMER_TYPE_SW,
4763 wma_log_completion_timeout,
4764 wma_handle);
4765 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4766 wma_err("Failed to initialize log completion timeout");
4767 goto end;
4768 }
4769
4770 qdf_status = wma_fips_register_event_handlers(wma_handle);
4771 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4772 wma_err("Failed to register FIPS event handler");
4773 qdf_status = QDF_STATUS_E_FAILURE;
4774 goto end;
4775 }
4776
4777 qdf_status = wma_sar_register_event_handlers(wma_handle);
4778 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4779 wma_err("Failed to register SAR event handlers");
4780 qdf_status = QDF_STATUS_E_FAILURE;
4781 goto end;
4782 }
4783
4784 /* Initialize the get temperature event handler */
4785 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4786 wmi_pdev_temperature_event_id,
4787 wma_pdev_temperature_evt_handler,
4788 WMA_RX_SERIALIZER_CTX);
4789 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4790 wma_err("Failed to register get_temperature event cb");
4791 qdf_status = QDF_STATUS_E_FAILURE;
4792 goto end;
4793 }
4794
4795 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4796 wmi_vdev_tsf_report_event_id,
4797 wma_vdev_tsf_handler,
4798 WMA_RX_SERIALIZER_CTX);
4799 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4800 wma_err("Failed to register tsf callback");
4801 qdf_status = QDF_STATUS_E_FAILURE;
4802 goto end;
4803 }
4804
4805 /* Initialize the wma_pdev_set_hw_mode_resp_evt_handler event handler */
4806 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4807 wmi_pdev_set_hw_mode_rsp_event_id,
4808 wma_pdev_set_hw_mode_resp_evt_handler,
4809 WMA_RX_SERIALIZER_CTX);
4810 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4811 wma_err("Failed to register set hw mode resp event cb");
4812 qdf_status = QDF_STATUS_E_FAILURE;
4813 goto end;
4814 }
4815
4816 /* Initialize the WMI_SOC_HW_MODE_TRANSITION_EVENTID event handler */
4817 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4818 wmi_pdev_hw_mode_transition_event_id,
4819 wma_pdev_hw_mode_transition_evt_handler,
4820 WMA_RX_SERIALIZER_CTX);
4821 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4822 wma_err("Failed to register hw mode transition event cb");
4823 qdf_status = QDF_STATUS_E_FAILURE;
4824 goto end;
4825 }
4826
4827 /* Initialize the set dual mac configuration event handler */
4828 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4829 wmi_pdev_set_mac_config_resp_event_id,
4830 wma_pdev_set_dual_mode_config_resp_evt_handler,
4831 WMA_RX_SERIALIZER_CTX);
4832 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4833 wma_err("Failed to register hw mode transition event cb");
4834 qdf_status = QDF_STATUS_E_FAILURE;
4835 goto end;
4836 }
4837
4838 qdf_status = wmi_unified_register_event_handler(wmi_handle,
4839 wmi_coex_bt_activity_event_id,
4840 wma_wlan_bt_activity_evt_handler,
4841 WMA_RX_SERIALIZER_CTX);
4842 if (QDF_IS_STATUS_ERROR(qdf_status)) {
4843 wma_err("Failed to register coex bt activity event handler");
4844 qdf_status = QDF_STATUS_E_FAILURE;
4845 goto end;
4846 }
4847 wma_register_spectral_cmds(wma_handle);
4848
4849 end:
4850 wma_debug("Exit");
4851 return qdf_status;
4852 }
4853
wma_stop(void)4854 QDF_STATUS wma_stop(void)
4855 {
4856 tp_wma_handle wma_handle;
4857 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
4858 int i;
4859 struct mac_context *mac = NULL;
4860 struct wlan_objmgr_vdev *vdev;
4861
4862 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
4863 wma_debug("Enter");
4864 if (!wma_handle) {
4865 qdf_status = QDF_STATUS_E_INVAL;
4866 goto end;
4867 }
4868 mac = cds_get_context(QDF_MODULE_ID_PE);
4869 if (!mac) {
4870 goto end;
4871 }
4872 #ifdef QCA_WIFI_FTM
4873 /*
4874 * Tx mgmt detach requires TXRX context which is not created
4875 * in FTM mode. So skip the TX mgmt detach.
4876 */
4877 if (cds_get_conparam() == QDF_GLOBAL_FTM_MODE) {
4878 qdf_status = QDF_STATUS_SUCCESS;
4879 goto end;
4880 }
4881 #endif /* QCA_WIFI_FTM */
4882
4883 if (wma_handle->ack_work_ctx) {
4884 cds_flush_work(&wma_handle->ack_work_ctx->ack_cmp_work);
4885 if (wma_handle->ack_work_ctx->frame)
4886 qdf_nbuf_free(wma_handle->ack_work_ctx->frame);
4887
4888 qdf_mem_free(wma_handle->ack_work_ctx);
4889 wma_handle->ack_work_ctx = NULL;
4890 }
4891
4892 /* Destroy the timer for log completion */
4893 qdf_status = qdf_mc_timer_destroy(&wma_handle->log_completion_timer);
4894 if (qdf_status != QDF_STATUS_SUCCESS)
4895 wma_err("Failed to destroy the log completion timer");
4896 /* clean up ll-queue for all vdev */
4897 for (i = 0; i < wma_handle->max_bssid; i++) {
4898 vdev = wma_handle->interfaces[i].vdev;
4899 if (!vdev)
4900 continue;
4901
4902 if (wma_is_vdev_up(i))
4903 cdp_fc_vdev_flush(cds_get_context(QDF_MODULE_ID_SOC),
4904 i);
4905 }
4906
4907 qdf_status = wma_tx_detach(wma_handle);
4908 if (qdf_status != QDF_STATUS_SUCCESS) {
4909 wma_err("Failed to deregister tx management");
4910 goto end;
4911 }
4912
4913 end:
4914 wma_debug("Exit");
4915 return qdf_status;
4916 }
4917
4918 /**
4919 * wma_wmi_service_close() - close wma wmi service interface.
4920 *
4921 * Return: 0 on success, QDF Error on failure
4922 */
wma_wmi_service_close(void)4923 QDF_STATUS wma_wmi_service_close(void)
4924 {
4925 void *cds_ctx;
4926 tp_wma_handle wma_handle;
4927 uint8_t i;
4928 struct wmi_unified *wmi_handle;
4929
4930 wma_debug("Enter");
4931
4932 cds_ctx = cds_get_global_context();
4933 if (!cds_ctx) {
4934 wma_err("Invalid CDS context");
4935 return QDF_STATUS_E_INVAL;
4936 }
4937
4938 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
4939 if (!wma_handle)
4940 return QDF_STATUS_E_INVAL;
4941
4942 wmi_handle = wma_handle->wmi_handle;
4943 if (wmi_validate_handle(wmi_handle))
4944 return QDF_STATUS_E_INVAL;
4945
4946 /* detach the wmi service */
4947 wma_debug("calling wmi_unified_detach");
4948 wmi_unified_detach(wmi_handle);
4949 wma_handle->wmi_handle = NULL;
4950
4951 for (i = 0; i < wma_handle->max_bssid; i++)
4952 wma_vdev_deinit(&wma_handle->interfaces[i]);
4953
4954 qdf_mem_free(wma_handle->interfaces);
4955
4956 /* free the wma_handle */
4957 cds_free_context(QDF_MODULE_ID_WMA, wma_handle);
4958
4959 if (((struct cds_context *)cds_ctx)->cfg_ctx)
4960 qdf_mem_free(((struct cds_context *)cds_ctx)->cfg_ctx);
4961 ((struct cds_context *)cds_ctx)->cfg_ctx = NULL;
4962 wma_debug("Exit");
4963 return QDF_STATUS_SUCCESS;
4964 }
4965
4966 /**
4967 * wma_wmi_work_close() - close the work queue items associated with WMI
4968 *
4969 * This function closes work queue items associated with WMI, but not fully
4970 * closes WMI service.
4971 *
4972 * Return: QDF_STATUS_SUCCESS if work close is successful. Otherwise
4973 * proper error codes.
4974 */
wma_wmi_work_close(void)4975 QDF_STATUS wma_wmi_work_close(void)
4976 {
4977 tp_wma_handle wma_handle;
4978 struct wmi_unified *wmi_handle;
4979
4980 wma_debug("Enter");
4981
4982 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
4983 if (!wma_handle)
4984 return QDF_STATUS_E_INVAL;
4985
4986 wmi_handle = wma_handle->wmi_handle;
4987 if (wmi_validate_handle(wmi_handle))
4988 return QDF_STATUS_E_INVAL;
4989
4990 /* remove the wmi work */
4991 wma_debug("calling wmi_unified_remove_work");
4992 wmi_unified_remove_work(wmi_handle);
4993
4994 wma_debug("Exit");
4995 return QDF_STATUS_SUCCESS;
4996 }
4997
4998 /**
4999 * wma_close() - wma close function.
5000 * cleanup resources attached with wma.
5001 *
5002 * Return: 0 on success, QDF Error on failure
5003 */
wma_close(void)5004 QDF_STATUS wma_close(void)
5005 {
5006 tp_wma_handle wma_handle;
5007 struct target_psoc_info *tgt_psoc_info;
5008 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
5009 struct wmi_unified *wmi_handle;
5010
5011 wma_debug("Enter");
5012
5013 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
5014 if (!wma_handle)
5015 return QDF_STATUS_E_INVAL;
5016
5017 wmi_handle = wma_handle->wmi_handle;
5018 if (wmi_validate_handle(wmi_handle))
5019 return QDF_STATUS_E_INVAL;
5020
5021 if (!wlan_pmo_no_op_on_page_fault(wma_handle->psoc))
5022 wma_deinit_pagefault_wakeup_history(wma_handle);
5023
5024 qdf_atomic_set(&wma_handle->sap_num_clients_connected, 0);
5025 qdf_atomic_set(&wma_handle->go_num_clients_connected, 0);
5026
5027 if (cds_get_conparam() != QDF_GLOBAL_FTM_MODE) {
5028 qdf_wake_lock_destroy(&wma_handle->go_d3_wow_wake_lock);
5029 qdf_wake_lock_destroy(&wma_handle->sap_d3_wow_wake_lock);
5030 #ifdef FEATURE_WLAN_EXTSCAN
5031 qdf_wake_lock_destroy(&wma_handle->extscan_wake_lock);
5032 #endif /* FEATURE_WLAN_EXTSCAN */
5033 qdf_wake_lock_destroy(&wma_handle->wow_wake_lock);
5034 qdf_wake_lock_destroy(&wma_handle->wow_auth_req_wl);
5035 qdf_wake_lock_destroy(&wma_handle->wow_assoc_req_wl);
5036 qdf_wake_lock_destroy(&wma_handle->wow_deauth_rec_wl);
5037 qdf_wake_lock_destroy(&wma_handle->wow_disassoc_rec_wl);
5038 qdf_wake_lock_destroy(&wma_handle->wow_ap_assoc_lost_wl);
5039 qdf_wake_lock_destroy(&wma_handle->wow_auto_shutdown_wl);
5040 qdf_wake_lock_destroy(&wma_handle->roam_ho_wl);
5041 qdf_wake_lock_destroy(&wma_handle->roam_preauth_wl);
5042 qdf_wake_lock_destroy(&wma_handle->probe_req_wps_wl);
5043 }
5044
5045 /* unregister Firmware debug log */
5046 qdf_status = dbglog_deinit(wmi_handle);
5047 if (qdf_status != QDF_STATUS_SUCCESS)
5048 wma_err("dbglog_deinit failed");
5049
5050 qdf_status = qdf_mc_timer_destroy(&wma_handle->service_ready_ext_timer);
5051 if (!QDF_IS_STATUS_SUCCESS(qdf_status))
5052 wma_err("Failed to destroy service ready ext event timer");
5053
5054 qdf_event_destroy(&wma_handle->target_suspend);
5055 qdf_event_destroy(&wma_handle->runtime_suspend);
5056 qdf_event_destroy(&wma_handle->recovery_event);
5057 qdf_event_destroy(&wma_handle->tx_frm_download_comp_event);
5058 qdf_event_destroy(&wma_handle->tx_queue_empty_event);
5059 wma_cleanup_hold_req(wma_handle);
5060 qdf_wake_lock_destroy(&wma_handle->wmi_cmd_rsp_wake_lock);
5061 qdf_runtime_lock_deinit(&wma_handle->ndp_prevent_runtime_pm_lock);
5062 qdf_runtime_lock_deinit(&wma_handle->sap_prevent_runtime_pm_lock);
5063 qdf_runtime_lock_deinit(&wma_handle->wmi_cmd_rsp_runtime_lock);
5064 qdf_spinlock_destroy(&wma_handle->wma_hold_req_q_lock);
5065
5066 if (wma_handle->pGetRssiReq) {
5067 qdf_mem_free(wma_handle->pGetRssiReq);
5068 wma_handle->pGetRssiReq = NULL;
5069 }
5070
5071 wma_unified_radio_tx_mem_free(wma_handle);
5072
5073 qdf_status = qdf_mutex_destroy(&wma_handle->radio_stats_lock);
5074 if (QDF_IS_STATUS_ERROR(qdf_status))
5075 wma_err("Failed to destroy radio stats mutex");
5076
5077 if (wma_handle->pdev) {
5078 wlan_objmgr_pdev_release_ref(wma_handle->pdev,
5079 WLAN_LEGACY_WMA_ID);
5080 wma_handle->pdev = NULL;
5081 }
5082
5083 pmo_unregister_get_beacon_interval_callback(wma_handle->psoc);
5084 pmo_unregister_get_dtim_period_callback(wma_handle->psoc);
5085 pmo_unregister_is_device_in_low_pwr_mode(wma_handle->psoc);
5086 pmo_unregister_get_pause_bitmap(wma_handle->psoc);
5087 pmo_unregister_pause_bitmap_notifier(wma_handle->psoc);
5088
5089 tgt_psoc_info = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
5090 init_deinit_free_num_units(wma_handle->psoc, tgt_psoc_info);
5091 target_if_free_psoc_tgt_info(wma_handle->psoc);
5092
5093 wlan_objmgr_psoc_release_ref(wma_handle->psoc, WLAN_LEGACY_WMA_ID);
5094 wma_handle->psoc = NULL;
5095
5096 wma_debug("Exit");
5097 return QDF_STATUS_SUCCESS;
5098 }
5099
5100 /**
5101 * wma_update_fw_config() - update fw configuration
5102 * @psoc: psoc to query configuration from
5103 * @tgt_hdl: target capability info
5104 *
5105 * Return: none
5106 */
wma_update_fw_config(struct wlan_objmgr_psoc * psoc,struct target_psoc_info * tgt_hdl)5107 static void wma_update_fw_config(struct wlan_objmgr_psoc *psoc,
5108 struct target_psoc_info *tgt_hdl)
5109 {
5110 target_resource_config *cfg = &tgt_hdl->info.wlan_res_cfg;
5111
5112 /* Override the no. of max fragments as per platform configuration */
5113 cfg->max_frag_entries = QDF_MIN(QCA_OL_11AC_TX_MAX_FRAGS,
5114 target_if_get_max_frag_entry(tgt_hdl));
5115 target_if_set_max_frag_entry(tgt_hdl, cfg->max_frag_entries);
5116
5117 if (cds_get_conparam() == QDF_GLOBAL_FTM_MODE)
5118 cfg->num_wow_filters = 0;
5119 else
5120 cfg->num_wow_filters = ucfg_pmo_get_num_wow_filters(psoc);
5121
5122 cfg->apf_instruction_size = ucfg_pmo_get_apf_instruction_size(psoc);
5123 cfg->num_packet_filters = ucfg_pmo_get_num_packet_filters(psoc);
5124 }
5125
5126 /**
5127 * wma_set_tx_partition_base() - set TX MSDU ID partition base for IPA
5128 * @value: TX MSDU ID partition base
5129 *
5130 * Return: none
5131 */
5132 #ifdef IPA_OFFLOAD
wma_set_tx_partition_base(uint32_t value)5133 static void wma_set_tx_partition_base(uint32_t value)
5134 {
5135 cdp_ipa_set_uc_tx_partition_base(
5136 cds_get_context(QDF_MODULE_ID_SOC),
5137 (struct cdp_cfg *)cds_get_context(QDF_MODULE_ID_CFG),
5138 value);
5139 wma_debug("TX_MSDU_ID_PARTITION=%d", value);
5140 }
5141 #else
wma_set_tx_partition_base(uint32_t value)5142 static void wma_set_tx_partition_base(uint32_t value)
5143 {
5144 }
5145 #endif
5146
5147 #ifdef WLAN_FEATURE_IGMP_OFFLOAD
5148 /**
5149 * wma_get_igmp_offload_enable() - update tgt service with igmp offload support
5150 * @wmi_handle: Unified wmi handle
5151 * @cfg: target services
5152 *
5153 * Return: none
5154 */
5155 static inline void
wma_get_igmp_offload_enable(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5156 wma_get_igmp_offload_enable(struct wmi_unified *wmi_handle,
5157 struct wma_tgt_services *cfg)
5158 {
5159 cfg->igmp_offload_enable = wmi_service_enabled(
5160 wmi_handle,
5161 wmi_service_igmp_offload_support);
5162 }
5163 #else
5164 static inline void
wma_get_igmp_offload_enable(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5165 wma_get_igmp_offload_enable(struct wmi_unified *wmi_handle,
5166 struct wma_tgt_services *cfg)
5167 {}
5168 #endif
5169
5170 #ifdef FEATURE_WLAN_TDLS
5171 /**
5172 * wma_get_tdls_wideband_support() - update tgt service with service tdls
5173 * wideband support
5174 * @wmi_handle: Unified wmi handle
5175 * @cfg: target services
5176 *
5177 * Return: none
5178 */
5179 static inline void
wma_get_tdls_wideband_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5180 wma_get_tdls_wideband_support(struct wmi_unified *wmi_handle,
5181 struct wma_tgt_services *cfg)
5182 {
5183 cfg->en_tdls_wideband_support = wmi_service_enabled(
5184 wmi_handle,
5185 wmi_service_tdls_wideband_support);
5186 }
5187
5188 #ifdef WLAN_FEATURE_11BE
5189 /**
5190 * wma_get_tdls_mlo_support() - update tgt service with service tdls
5191 * be support
5192 * @wmi_handle: Unified wmi handle
5193 * @cfg: target services
5194 *
5195 * Return: none
5196 */
5197 static inline void
wma_get_tdls_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5198 wma_get_tdls_mlo_support(struct wmi_unified *wmi_handle,
5199 struct wma_tgt_services *cfg)
5200 {
5201 cfg->en_tdls_mlo_support =
5202 wmi_service_enabled(wmi_handle,
5203 wmi_service_tdls_mlo_support);
5204 }
5205
5206 static inline void
wma_get_n_link_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5207 wma_get_n_link_mlo_support(struct wmi_unified *wmi_handle,
5208 struct wma_tgt_services *cfg)
5209 {
5210 cfg->en_n_link_mlo_support =
5211 wmi_service_enabled(wmi_handle,
5212 wmi_service_n_link_mlo_support);
5213 }
5214
5215 #else
5216 static inline void
wma_get_tdls_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5217 wma_get_tdls_mlo_support(struct wmi_unified *wmi_handle,
5218 struct wma_tgt_services *cfg)
5219 {
5220 }
5221
5222 static inline void
wma_get_n_link_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5223 wma_get_n_link_mlo_support(struct wmi_unified *wmi_handle,
5224 struct wma_tgt_services *cfg)
5225 {
5226 }
5227 #endif /* WLAN_FEATURE_11BE */
5228
5229 #ifdef WLAN_FEATURE_11AX
5230 /**
5231 * wma_get_tdls_ax_support() - update tgt service with service tdls ax support
5232 * @wmi_handle: Unified wmi handle
5233 * @cfg: target services
5234 *
5235 * Return: none
5236 */
5237 static inline void
wma_get_tdls_ax_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5238 wma_get_tdls_ax_support(struct wmi_unified *wmi_handle,
5239 struct wma_tgt_services *cfg)
5240 {
5241 cfg->en_tdls_11ax_support = wmi_service_enabled(
5242 wmi_handle,
5243 wmi_service_tdls_ax_support);
5244 }
5245
5246 static inline void
wma_get_tdls_6g_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5247 wma_get_tdls_6g_support(struct wmi_unified *wmi_handle,
5248 struct wma_tgt_services *cfg)
5249 {
5250 cfg->en_tdls_6g_support = wmi_service_enabled(
5251 wmi_handle,
5252 wmi_service_tdls_6g_support);
5253 }
5254
5255 #else
5256 static inline void
wma_get_tdls_ax_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5257 wma_get_tdls_ax_support(struct wmi_unified *wmi_handle,
5258 struct wma_tgt_services *cfg)
5259 {}
5260
5261 static inline void
wma_get_tdls_6g_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5262 wma_get_tdls_6g_support(struct wmi_unified *wmi_handle,
5263 struct wma_tgt_services *cfg)
5264 {}
5265
5266 #endif
5267 #else
5268 static inline void
wma_get_tdls_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5269 wma_get_tdls_mlo_support(struct wmi_unified *wmi_handle,
5270 struct wma_tgt_services *cfg)
5271 {
5272 }
5273
5274 static inline void
wma_get_n_link_mlo_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5275 wma_get_n_link_mlo_support(struct wmi_unified *wmi_handle,
5276 struct wma_tgt_services *cfg)
5277 {}
5278
5279 static inline void
wma_get_tdls_ax_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5280 wma_get_tdls_ax_support(struct wmi_unified *wmi_handle,
5281 struct wma_tgt_services *cfg)
5282 {}
5283
5284 static inline void
wma_get_tdls_6g_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5285 wma_get_tdls_6g_support(struct wmi_unified *wmi_handle,
5286 struct wma_tgt_services *cfg)
5287 {}
5288
5289 static inline void
wma_get_tdls_wideband_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5290 wma_get_tdls_wideband_support(struct wmi_unified *wmi_handle,
5291 struct wma_tgt_services *cfg)
5292 {}
5293 #endif
5294
5295 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE
wma_get_dynamic_vdev_macaddr_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5296 static inline void wma_get_dynamic_vdev_macaddr_support(
5297 struct wmi_unified *wmi_handle, struct wma_tgt_services *cfg)
5298 {
5299 cfg->dynamic_vdev_macaddr_support =
5300 wmi_service_enabled(
5301 wmi_handle,
5302 wmi_service_dynamic_update_vdev_macaddr_support);
5303 }
5304 #else
wma_get_dynamic_vdev_macaddr_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5305 static inline void wma_get_dynamic_vdev_macaddr_support(
5306 struct wmi_unified *wmi_handle, struct wma_tgt_services *cfg)
5307 {
5308 }
5309 #endif
5310
5311 #ifdef WLAN_FEATURE_11BE
5312 /**
5313 * wma_get_mlo_tid_to_link_mapping_support() - update tgt service with
5314 * service tid to link mapping support
5315 * @wmi_handle: Unified wmi handle
5316 * @cfg: target services
5317 *
5318 * Return: none
5319 */
5320 static inline void
wma_get_mlo_tid_to_link_mapping_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5321 wma_get_mlo_tid_to_link_mapping_support(struct wmi_unified *wmi_handle,
5322 struct wma_tgt_services *cfg)
5323 {
5324 cfg->en_mlo_tid_to_link_support =
5325 wmi_service_enabled(wmi_handle,
5326 wmi_service_mlo_tid_to_link_mapping_support);
5327 }
5328
5329 #else
5330 static inline void
wma_get_mlo_tid_to_link_mapping_support(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5331 wma_get_mlo_tid_to_link_mapping_support(struct wmi_unified *wmi_handle,
5332 struct wma_tgt_services *cfg)
5333 {
5334 }
5335 #endif
5336
5337 #ifdef WLAN_FEATURE_NAN
5338 /**
5339 * wma_nan_set_pairing_feature() - set feature bit for Secure NAN if max
5340 * pairing session has non-zero value.
5341 *
5342 * Return: none
5343 */
wma_nan_set_pairing_feature(void)5344 static void wma_nan_set_pairing_feature(void)
5345 {
5346 tp_wma_handle wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
5347 struct target_psoc_info *tgt_hdl;
5348 struct wlan_objmgr_psoc *psoc;
5349
5350 if (!wma_handle) {
5351 wma_err("wma handle is null");
5352 return;
5353 }
5354
5355 psoc = wma_handle->psoc;
5356 tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc);
5357 if (!tgt_hdl) {
5358 wma_err("tgt_hdl is null");
5359 return;
5360 }
5361
5362 if (tgt_hdl->info.service_ext2_param.max_nan_pairing_sessions) {
5363 wma_set_fw_wlan_feat_caps(SECURE_NAN);
5364 wma_debug("Secure NAN is enabled");
5365 }
5366 }
5367 #endif /* WLAN_FEATURE_NAN */
5368
5369 /**
5370 * wma_update_target_services() - update target services from wma handle
5371 * @wmi_handle: Unified wmi handle
5372 * @cfg: target services
5373 *
5374 * Return: none
5375 */
wma_update_target_services(struct wmi_unified * wmi_handle,struct wma_tgt_services * cfg)5376 static inline void wma_update_target_services(struct wmi_unified *wmi_handle,
5377 struct wma_tgt_services *cfg)
5378 {
5379 /* STA power save */
5380 cfg->sta_power_save = wmi_service_enabled(wmi_handle,
5381 wmi_service_sta_pwrsave);
5382
5383 /* Enable UAPSD */
5384 cfg->uapsd = wmi_service_enabled(wmi_handle,
5385 wmi_service_ap_uapsd);
5386
5387 /* Update AP DFS service */
5388 cfg->ap_dfs = wmi_service_enabled(wmi_handle,
5389 wmi_service_ap_dfs);
5390
5391 /* Enable 11AC */
5392 cfg->en_11ac = wmi_service_enabled(wmi_handle,
5393 wmi_service_11ac);
5394 if (cfg->en_11ac)
5395 g_fw_wlan_feat_caps |= (1 << DOT11AC);
5396
5397 /* Proactive ARP response */
5398 g_fw_wlan_feat_caps |= (1 << WLAN_PERIODIC_TX_PTRN);
5399
5400 /* Enable WOW */
5401 g_fw_wlan_feat_caps |= (1 << WOW);
5402
5403 /* ARP offload */
5404 cfg->arp_offload = wmi_service_enabled(wmi_handle,
5405 wmi_service_arpns_offload);
5406
5407 /* Adaptive early-rx */
5408 cfg->early_rx = wmi_service_enabled(wmi_handle,
5409 wmi_service_early_rx);
5410
5411 cfg->is_fw_therm_throt_supp = wmi_service_enabled(wmi_handle,
5412 wmi_service_tt);
5413
5414 #ifdef FEATURE_WLAN_SCAN_PNO
5415 /* PNO offload */
5416 if (wmi_service_enabled(wmi_handle, wmi_service_nlo)) {
5417 cfg->pno_offload = true;
5418 g_fw_wlan_feat_caps |= (1 << PNO);
5419 }
5420 #endif /* FEATURE_WLAN_SCAN_PNO */
5421
5422 #ifdef FEATURE_WLAN_EXTSCAN
5423 if (wmi_service_enabled(wmi_handle, wmi_service_extscan))
5424 g_fw_wlan_feat_caps |= (1 << EXTENDED_SCAN);
5425 #endif /* FEATURE_WLAN_EXTSCAN */
5426 cfg->lte_coex_ant_share = wmi_service_enabled(wmi_handle,
5427 wmi_service_lte_ant_share_support);
5428 #ifdef FEATURE_WLAN_TDLS
5429 /* Enable TDLS */
5430 if (wmi_service_enabled(wmi_handle, wmi_service_tdls)) {
5431 cfg->en_tdls = 1;
5432 g_fw_wlan_feat_caps |= (1 << TDLS);
5433 }
5434 /* Enable advanced TDLS features */
5435 if (wmi_service_enabled(wmi_handle, wmi_service_tdls_offchan)) {
5436 cfg->en_tdls_offchan = 1;
5437 g_fw_wlan_feat_caps |= (1 << TDLS_OFF_CHANNEL);
5438 }
5439
5440 cfg->en_tdls_uapsd_buf_sta =
5441 wmi_service_enabled(wmi_handle,
5442 wmi_service_tdls_uapsd_buffer_sta);
5443 cfg->en_tdls_uapsd_sleep_sta =
5444 wmi_service_enabled(wmi_handle,
5445 wmi_service_tdls_uapsd_sleep_sta);
5446 #endif /* FEATURE_WLAN_TDLS */
5447 if (wmi_service_enabled
5448 (wmi_handle, wmi_service_beacon_offload))
5449 cfg->beacon_offload = true;
5450 if (wmi_service_enabled
5451 (wmi_handle, wmi_service_sta_pmf_offload))
5452 cfg->pmf_offload = true;
5453 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
5454 /* Enable Roam Offload */
5455 cfg->en_roam_offload = wmi_service_enabled(wmi_handle,
5456 wmi_service_roam_ho_offload);
5457 #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
5458 #ifdef WLAN_FEATURE_NAN
5459 if (wmi_service_enabled(wmi_handle, wmi_service_nan))
5460 g_fw_wlan_feat_caps |= (1 << NAN);
5461 wma_nan_set_pairing_feature();
5462 #endif /* WLAN_FEATURE_NAN */
5463
5464 if (wmi_service_enabled(wmi_handle, wmi_service_rtt))
5465 g_fw_wlan_feat_caps |= (1 << RTT);
5466
5467 if (wmi_service_enabled(wmi_handle,
5468 wmi_service_tx_msdu_id_new_partition_support)) {
5469 wma_set_tx_partition_base(HTT_TX_IPA_NEW_MSDU_ID_SPACE_BEGIN);
5470 } else {
5471 wma_set_tx_partition_base(HTT_TX_IPA_MSDU_ID_SPACE_BEGIN);
5472 }
5473
5474 wma_he_update_tgt_services(wmi_handle, cfg);
5475 wma_eht_update_tgt_services(wmi_handle, cfg);
5476
5477 cfg->get_peer_info_enabled =
5478 wmi_service_enabled(wmi_handle,
5479 wmi_service_peer_stats_info);
5480 if (wmi_service_enabled(wmi_handle, wmi_service_fils_support))
5481 cfg->is_fils_roaming_supported = true;
5482
5483 if (wmi_service_enabled(wmi_handle, wmi_service_mawc_support))
5484 cfg->is_fw_mawc_capable = true;
5485
5486 if (wmi_service_enabled(wmi_handle,
5487 wmi_service_11k_neighbour_report_support))
5488 cfg->is_11k_offload_supported = true;
5489
5490 if (wmi_service_enabled(wmi_handle, wmi_service_twt_requestor))
5491 cfg->twt_requestor = true;
5492 if (wmi_service_enabled(wmi_handle, wmi_service_twt_responder))
5493 cfg->twt_responder = true;
5494 if (wmi_service_enabled(wmi_handle, wmi_service_obss_scan))
5495 cfg->obss_scan_offload = true;
5496 if (wmi_service_enabled(wmi_handle, wmi_service_beacon_reception_stats))
5497 cfg->bcn_reception_stats = true;
5498
5499 if (wmi_service_enabled(wmi_handle, wmi_service_vdev_latency_config))
5500 g_fw_wlan_feat_caps |= (1 << VDEV_LATENCY_CONFIG);
5501 if (wmi_service_enabled(wmi_handle,
5502 wmi_roam_scan_chan_list_to_host_support))
5503 cfg->is_roam_scan_ch_to_host = true;
5504
5505 cfg->ll_stats_per_chan_rx_tx_time =
5506 wmi_service_enabled(wmi_handle,
5507 wmi_service_ll_stats_per_chan_rx_tx_time);
5508
5509 wma_get_service_cap_club_get_sta_in_ll_stats_req(wmi_handle, cfg);
5510
5511 wma_get_igmp_offload_enable(wmi_handle, cfg);
5512 wma_get_tdls_ax_support(wmi_handle, cfg);
5513 wma_get_tdls_mlo_support(wmi_handle, cfg);
5514 wma_get_tdls_6g_support(wmi_handle, cfg);
5515 wma_get_tdls_wideband_support(wmi_handle, cfg);
5516 wma_get_dynamic_vdev_macaddr_support(wmi_handle, cfg);
5517 wma_get_service_cap_per_link_mlo_stats(wmi_handle, cfg);
5518 wma_get_n_link_mlo_support(wmi_handle, cfg);
5519 wma_get_mlo_tid_to_link_mapping_support(wmi_handle, cfg);
5520 }
5521
5522 /**
5523 * wma_update_target_ht_cap() - update ht capabality from wma handle
5524 * @tgt_hdl: pointer to structure target_psoc_info
5525 * @cfg: ht capability
5526 *
5527 * Return: none
5528 */
5529 static inline void
wma_update_target_ht_cap(struct target_psoc_info * tgt_hdl,struct wma_tgt_ht_cap * cfg)5530 wma_update_target_ht_cap(struct target_psoc_info *tgt_hdl,
5531 struct wma_tgt_ht_cap *cfg)
5532 {
5533 int ht_cap_info;
5534
5535 ht_cap_info = target_if_get_ht_cap_info(tgt_hdl);
5536 /* RX STBC */
5537 cfg->ht_rx_stbc = !!(ht_cap_info & WMI_HT_CAP_RX_STBC);
5538
5539 /* TX STBC */
5540 cfg->ht_tx_stbc = !!(ht_cap_info & WMI_HT_CAP_TX_STBC);
5541
5542 /* MPDU density */
5543 cfg->mpdu_density = ht_cap_info & WMI_HT_CAP_MPDU_DENSITY;
5544
5545 /* HT RX LDPC */
5546 cfg->ht_rx_ldpc = !!(ht_cap_info & WMI_HT_CAP_LDPC);
5547
5548 /* HT SGI */
5549 cfg->ht_sgi_20 = !!(ht_cap_info & WMI_HT_CAP_HT20_SGI);
5550
5551 cfg->ht_sgi_40 = !!(ht_cap_info & WMI_HT_CAP_HT40_SGI);
5552
5553 cfg->dynamic_smps = !!(ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS);
5554
5555 /* RF chains */
5556 cfg->num_rf_chains = target_if_get_num_rf_chains(tgt_hdl);
5557
5558 wma_nofl_debug("ht_cap_info - %x ht_rx_stbc - %d, ht_tx_stbc - %d\n"
5559 "mpdu_density - %d ht_rx_ldpc - %d ht_sgi_20 - %d\n"
5560 "ht_sgi_40 - %d num_rf_chains - %d dynamic_smps - %d",
5561 ht_cap_info,
5562 cfg->ht_rx_stbc, cfg->ht_tx_stbc, cfg->mpdu_density,
5563 cfg->ht_rx_ldpc, cfg->ht_sgi_20, cfg->ht_sgi_40,
5564 cfg->num_rf_chains, cfg->dynamic_smps);
5565
5566 }
5567
5568 /**
5569 * wma_update_target_vht_cap() - update vht capabality from wma handle
5570 * @tgt_hdl: pointer to structure target_psoc_info
5571 * @cfg: vht capabality
5572 *
5573 * Return: none
5574 */
5575 static inline void
wma_update_target_vht_cap(struct target_psoc_info * tgt_hdl,struct wma_tgt_vht_cap * cfg)5576 wma_update_target_vht_cap(struct target_psoc_info *tgt_hdl,
5577 struct wma_tgt_vht_cap *cfg)
5578 {
5579 int vht_cap_info = target_if_get_vht_cap_info(tgt_hdl);
5580
5581 if (vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_11454)
5582 cfg->vht_max_mpdu = WMI_VHT_CAP_MAX_MPDU_LEN_11454;
5583 else if (vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_7935)
5584 cfg->vht_max_mpdu = WMI_VHT_CAP_MAX_MPDU_LEN_7935;
5585 else
5586 cfg->vht_max_mpdu = 0;
5587
5588
5589 if (vht_cap_info & WMI_VHT_CAP_CH_WIDTH_80P80_160MHZ) {
5590 cfg->supp_chan_width = 1 << eHT_CHANNEL_WIDTH_80P80MHZ;
5591 cfg->supp_chan_width |= 1 << eHT_CHANNEL_WIDTH_160MHZ;
5592 } else if (vht_cap_info & WMI_VHT_CAP_CH_WIDTH_160MHZ) {
5593 cfg->supp_chan_width = 1 << eHT_CHANNEL_WIDTH_160MHZ;
5594 } else {
5595 cfg->supp_chan_width = 1 << eHT_CHANNEL_WIDTH_80MHZ;
5596 }
5597
5598 cfg->vht_rx_ldpc = vht_cap_info & WMI_VHT_CAP_RX_LDPC;
5599
5600 cfg->vht_short_gi_80 = vht_cap_info & WMI_VHT_CAP_SGI_80MHZ;
5601 cfg->vht_short_gi_160 = vht_cap_info & WMI_VHT_CAP_SGI_160MHZ;
5602
5603 cfg->vht_tx_stbc = vht_cap_info & WMI_VHT_CAP_TX_STBC;
5604
5605 cfg->vht_rx_stbc =
5606 (vht_cap_info & WMI_VHT_CAP_RX_STBC_1SS) |
5607 (vht_cap_info & WMI_VHT_CAP_RX_STBC_2SS) |
5608 (vht_cap_info & WMI_VHT_CAP_RX_STBC_3SS);
5609
5610 cfg->vht_max_ampdu_len_exp = (vht_cap_info &
5611 WMI_VHT_CAP_MAX_AMPDU_LEN_EXP)
5612 >> WMI_VHT_CAP_MAX_AMPDU_LEN_EXP_SHIFT;
5613
5614 cfg->vht_su_bformer = vht_cap_info & WMI_VHT_CAP_SU_BFORMER;
5615
5616 cfg->vht_su_bformee = vht_cap_info & WMI_VHT_CAP_SU_BFORMEE;
5617
5618 cfg->vht_mu_bformer = vht_cap_info & WMI_VHT_CAP_MU_BFORMER;
5619
5620 cfg->vht_mu_bformee = vht_cap_info & WMI_VHT_CAP_MU_BFORMEE;
5621
5622 cfg->vht_txop_ps = vht_cap_info & WMI_VHT_CAP_TXOP_PS;
5623
5624 wma_nofl_debug("max_mpdu %d supp_chan_width %x rx_ldpc %x\n"
5625 "short_gi_80 %x tx_stbc %x rx_stbc %x txop_ps %x\n"
5626 "su_bformee %x mu_bformee %x max_ampdu_len_exp %d",
5627 cfg->vht_max_mpdu, cfg->supp_chan_width, cfg->vht_rx_ldpc,
5628 cfg->vht_short_gi_80, cfg->vht_tx_stbc, cfg->vht_rx_stbc,
5629 cfg->vht_txop_ps, cfg->vht_su_bformee, cfg->vht_mu_bformee,
5630 cfg->vht_max_ampdu_len_exp);
5631 }
5632
5633 /**
5634 * wma_update_supported_bands() - update supported bands from service ready ext
5635 * @supported_bands: Supported band given by FW through service ready ext params
5636 * @new_supported_bands: New supported band which needs to be updated by
5637 * this API which WMA layer understands
5638 *
5639 * This API will convert FW given supported band to enum which WMA layer
5640 * understands
5641 *
5642 * Return: QDF_STATUS
5643 */
wma_update_supported_bands(WLAN_BAND_CAPABILITY supported_bands,WMI_PHY_CAPABILITY * new_supported_bands)5644 static QDF_STATUS wma_update_supported_bands(
5645 WLAN_BAND_CAPABILITY supported_bands,
5646 WMI_PHY_CAPABILITY *new_supported_bands)
5647 {
5648 QDF_STATUS status = QDF_STATUS_SUCCESS;
5649
5650 if (!new_supported_bands) {
5651 wma_err("NULL new supported band variable");
5652 return QDF_STATUS_E_FAILURE;
5653 }
5654 switch (supported_bands) {
5655 case WLAN_2G_CAPABILITY:
5656 *new_supported_bands |= WMI_11G_CAPABILITY;
5657 break;
5658 case WLAN_5G_CAPABILITY:
5659 *new_supported_bands |= WMI_11A_CAPABILITY;
5660 break;
5661 default:
5662 wma_err("wrong supported band");
5663 status = QDF_STATUS_E_FAILURE;
5664 break;
5665 }
5666 return status;
5667 }
5668
5669 /**
5670 * wma_derive_ext_ht_cap() - Derive HT caps based on given value
5671 * @ht_cap: given pointer to HT caps which needs to be updated
5672 * @value: new HT cap info provided in form of bitmask
5673 * @tx_chain: given tx chainmask value
5674 * @rx_chain: given rx chainmask value
5675 *
5676 * This function takes the value provided in form of bitmask and decodes
5677 * it. After decoding, what ever value it gets, it takes the union(max) or
5678 * intersection(min) with previously derived values.
5679 *
5680 * Return: none
5681 *
5682 */
wma_derive_ext_ht_cap(struct wma_tgt_ht_cap * ht_cap,uint32_t value,uint32_t tx_chain,uint32_t rx_chain)5683 static void wma_derive_ext_ht_cap(
5684 struct wma_tgt_ht_cap *ht_cap, uint32_t value,
5685 uint32_t tx_chain, uint32_t rx_chain)
5686 {
5687 struct wma_tgt_ht_cap tmp = {0};
5688
5689 if (!ht_cap)
5690 return;
5691
5692 if (!qdf_mem_cmp(ht_cap, &tmp, sizeof(struct wma_tgt_ht_cap))) {
5693 ht_cap->ht_rx_stbc = (!!(value & WMI_HT_CAP_RX_STBC));
5694 ht_cap->ht_tx_stbc = (!!(value & WMI_HT_CAP_TX_STBC));
5695 ht_cap->mpdu_density = (!!(value & WMI_HT_CAP_MPDU_DENSITY));
5696 ht_cap->ht_rx_ldpc = (!!(value & WMI_HT_CAP_RX_LDPC));
5697 ht_cap->ht_sgi_20 = (!!(value & WMI_HT_CAP_HT20_SGI));
5698 ht_cap->ht_sgi_40 = (!!(value & WMI_HT_CAP_HT40_SGI));
5699 ht_cap->dynamic_smps = (!!(value & WMI_HT_CAP_DYNAMIC_SMPS));
5700 ht_cap->num_rf_chains =
5701 QDF_MAX(wma_get_num_of_setbits_from_bitmask(tx_chain),
5702 wma_get_num_of_setbits_from_bitmask(rx_chain));
5703 } else {
5704 ht_cap->ht_rx_stbc = QDF_MIN(ht_cap->ht_rx_stbc,
5705 (!!(value & WMI_HT_CAP_RX_STBC)));
5706 ht_cap->ht_tx_stbc = QDF_MAX(ht_cap->ht_tx_stbc,
5707 (!!(value & WMI_HT_CAP_TX_STBC)));
5708 ht_cap->mpdu_density = QDF_MIN(ht_cap->mpdu_density,
5709 (!!(value & WMI_HT_CAP_MPDU_DENSITY)));
5710 ht_cap->ht_rx_ldpc = QDF_MIN(ht_cap->ht_rx_ldpc,
5711 (!!(value & WMI_HT_CAP_RX_LDPC)));
5712 ht_cap->ht_sgi_20 = QDF_MIN(ht_cap->ht_sgi_20,
5713 (!!(value & WMI_HT_CAP_HT20_SGI)));
5714 ht_cap->ht_sgi_40 = QDF_MIN(ht_cap->ht_sgi_40,
5715 (!!(value & WMI_HT_CAP_HT40_SGI)));
5716 ht_cap->dynamic_smps = QDF_MIN(ht_cap->dynamic_smps,
5717 (!!(value & WMI_HT_CAP_DYNAMIC_SMPS)));
5718
5719 ht_cap->num_rf_chains =
5720 QDF_MAX(ht_cap->num_rf_chains,
5721 QDF_MAX(wma_get_num_of_setbits_from_bitmask(
5722 tx_chain),
5723 wma_get_num_of_setbits_from_bitmask(
5724 rx_chain)));
5725 }
5726 }
5727
5728 /**
5729 * wma_update_target_ext_ht_cap() - Update HT caps with given extended cap
5730 * @tgt_hdl: target psoc information
5731 * @ht_cap: HT cap structure to be filled
5732 *
5733 * This function loop through each hardware mode and for each hardware mode
5734 * again it loop through each MAC/PHY and pull the caps 2G and 5G specific
5735 * HT caps and derives the final cap.
5736 *
5737 * Return: none
5738 *
5739 */
wma_update_target_ext_ht_cap(struct target_psoc_info * tgt_hdl,struct wma_tgt_ht_cap * ht_cap)5740 static void wma_update_target_ext_ht_cap(struct target_psoc_info *tgt_hdl,
5741 struct wma_tgt_ht_cap *ht_cap)
5742 {
5743 int i, total_mac_phy_cnt;
5744 uint32_t ht_2g, ht_5g;
5745 struct wma_tgt_ht_cap tmp_ht_cap = {0}, tmp_cap = {0};
5746 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap;
5747 int num_hw_modes;
5748
5749 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
5750 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
5751 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
5752
5753 if (!mac_phy_cap) {
5754 wma_err("Invalid MAC PHY capabilities handle");
5755 return;
5756 }
5757
5758 /*
5759 * for legacy device extended cap might not even come, so in that case
5760 * don't overwrite legacy values
5761 */
5762 if (!num_hw_modes) {
5763 wma_debug("No extended HT cap for current SOC");
5764 return;
5765 }
5766
5767 for (i = 0; i < total_mac_phy_cnt; i++) {
5768 ht_2g = mac_phy_cap[i].ht_cap_info_2G;
5769 ht_5g = mac_phy_cap[i].ht_cap_info_5G;
5770 if (ht_2g)
5771 wma_derive_ext_ht_cap(&tmp_ht_cap,
5772 ht_2g,
5773 mac_phy_cap[i].tx_chain_mask_2G,
5774 mac_phy_cap[i].rx_chain_mask_2G);
5775 if (ht_5g)
5776 wma_derive_ext_ht_cap(&tmp_ht_cap,
5777 ht_5g,
5778 mac_phy_cap[i].tx_chain_mask_5G,
5779 mac_phy_cap[i].rx_chain_mask_5G);
5780 }
5781
5782 if (qdf_mem_cmp(&tmp_cap, &tmp_ht_cap,
5783 sizeof(struct wma_tgt_ht_cap))) {
5784 qdf_mem_copy(ht_cap, &tmp_ht_cap,
5785 sizeof(struct wma_tgt_ht_cap));
5786 }
5787
5788 wma_nofl_debug("[ext ht cap] ht_rx_stbc - %d, ht_tx_stbc - %d\n"
5789 "mpdu_density - %d ht_rx_ldpc - %d ht_sgi_20 - %d\n"
5790 "ht_sgi_40 - %d num_rf_chains - %d dynamic_smps - %d",
5791 ht_cap->ht_rx_stbc, ht_cap->ht_tx_stbc,
5792 ht_cap->mpdu_density, ht_cap->ht_rx_ldpc,
5793 ht_cap->ht_sgi_20, ht_cap->ht_sgi_40,
5794 ht_cap->num_rf_chains, ht_cap->dynamic_smps);
5795 }
5796
5797 /**
5798 * wma_derive_ext_vht_cap() - Derive VHT caps based on given value
5799 * @vht_cap: pointer to given VHT caps to be filled
5800 * @value: new VHT cap info provided in form of bitmask
5801 *
5802 * This function takes the value provided in form of bitmask and decodes
5803 * it. After decoding, what ever value it gets, it takes the union(max) or
5804 * intersection(min) with previously derived values.
5805 *
5806 * Return: none
5807 *
5808 */
wma_derive_ext_vht_cap(struct wma_tgt_vht_cap * vht_cap,uint32_t value)5809 static void wma_derive_ext_vht_cap(
5810 struct wma_tgt_vht_cap *vht_cap, uint32_t value)
5811 {
5812 struct wma_tgt_vht_cap tmp_cap = {0};
5813 uint32_t tmp = 0;
5814
5815 if (!vht_cap)
5816 return;
5817
5818 if (!qdf_mem_cmp(vht_cap, &tmp_cap,
5819 sizeof(struct wma_tgt_vht_cap))) {
5820 if (value & WMI_VHT_CAP_MAX_MPDU_LEN_11454)
5821 vht_cap->vht_max_mpdu = WMI_VHT_CAP_MAX_MPDU_LEN_11454;
5822 else if (value & WMI_VHT_CAP_MAX_MPDU_LEN_7935)
5823 vht_cap->vht_max_mpdu = WMI_VHT_CAP_MAX_MPDU_LEN_7935;
5824 else
5825 vht_cap->vht_max_mpdu = 0;
5826
5827 if (value & WMI_VHT_CAP_CH_WIDTH_80P80_160MHZ) {
5828 vht_cap->supp_chan_width =
5829 1 << eHT_CHANNEL_WIDTH_80P80MHZ;
5830 vht_cap->supp_chan_width |=
5831 1 << eHT_CHANNEL_WIDTH_160MHZ;
5832 } else if (value & WMI_VHT_CAP_CH_WIDTH_160MHZ) {
5833 vht_cap->supp_chan_width =
5834 1 << eHT_CHANNEL_WIDTH_160MHZ;
5835 } else {
5836 vht_cap->supp_chan_width = 1 << eHT_CHANNEL_WIDTH_80MHZ;
5837 }
5838 vht_cap->vht_rx_ldpc = value & WMI_VHT_CAP_RX_LDPC;
5839 vht_cap->vht_short_gi_80 = value & WMI_VHT_CAP_SGI_80MHZ;
5840 vht_cap->vht_short_gi_160 = value & WMI_VHT_CAP_SGI_160MHZ;
5841 vht_cap->vht_tx_stbc = value & WMI_VHT_CAP_TX_STBC;
5842 vht_cap->vht_rx_stbc =
5843 (value & WMI_VHT_CAP_RX_STBC_1SS) |
5844 (value & WMI_VHT_CAP_RX_STBC_2SS) |
5845 (value & WMI_VHT_CAP_RX_STBC_3SS);
5846 vht_cap->vht_max_ampdu_len_exp =
5847 (value & WMI_VHT_CAP_MAX_AMPDU_LEN_EXP) >>
5848 WMI_VHT_CAP_MAX_AMPDU_LEN_EXP_SHIFT;
5849 vht_cap->vht_su_bformer = value & WMI_VHT_CAP_SU_BFORMER;
5850 vht_cap->vht_su_bformee = value & WMI_VHT_CAP_SU_BFORMEE;
5851 vht_cap->vht_mu_bformer = value & WMI_VHT_CAP_MU_BFORMER;
5852 vht_cap->vht_mu_bformee = value & WMI_VHT_CAP_MU_BFORMEE;
5853 vht_cap->vht_txop_ps = value & WMI_VHT_CAP_TXOP_PS;
5854 } else {
5855 if (value & WMI_VHT_CAP_MAX_MPDU_LEN_11454)
5856 tmp = WMI_VHT_CAP_MAX_MPDU_LEN_11454;
5857 else if (value & WMI_VHT_CAP_MAX_MPDU_LEN_7935)
5858 tmp = WMI_VHT_CAP_MAX_MPDU_LEN_7935;
5859 else
5860 tmp = 0;
5861 vht_cap->vht_max_mpdu = QDF_MIN(vht_cap->vht_max_mpdu, tmp);
5862
5863 if ((value & WMI_VHT_CAP_CH_WIDTH_80P80_160MHZ)) {
5864 tmp = (1 << eHT_CHANNEL_WIDTH_80P80MHZ) |
5865 (1 << eHT_CHANNEL_WIDTH_160MHZ);
5866 } else if (value & WMI_VHT_CAP_CH_WIDTH_160MHZ) {
5867 tmp = 1 << eHT_CHANNEL_WIDTH_160MHZ;
5868 } else {
5869 tmp = 1 << eHT_CHANNEL_WIDTH_80MHZ;
5870 }
5871 vht_cap->supp_chan_width =
5872 QDF_MAX(vht_cap->supp_chan_width, tmp);
5873 vht_cap->vht_rx_ldpc = QDF_MIN(vht_cap->vht_rx_ldpc,
5874 value & WMI_VHT_CAP_RX_LDPC);
5875 vht_cap->vht_short_gi_80 = QDF_MAX(vht_cap->vht_short_gi_80,
5876 value & WMI_VHT_CAP_SGI_80MHZ);
5877 vht_cap->vht_short_gi_160 = QDF_MAX(vht_cap->vht_short_gi_160,
5878 value & WMI_VHT_CAP_SGI_160MHZ);
5879 vht_cap->vht_tx_stbc = QDF_MAX(vht_cap->vht_tx_stbc,
5880 value & WMI_VHT_CAP_TX_STBC);
5881 vht_cap->vht_rx_stbc = QDF_MIN(vht_cap->vht_rx_stbc,
5882 (value & WMI_VHT_CAP_RX_STBC_1SS) |
5883 (value & WMI_VHT_CAP_RX_STBC_2SS) |
5884 (value & WMI_VHT_CAP_RX_STBC_3SS));
5885 vht_cap->vht_max_ampdu_len_exp =
5886 QDF_MIN(vht_cap->vht_max_ampdu_len_exp,
5887 (value & WMI_VHT_CAP_MAX_AMPDU_LEN_EXP) >>
5888 WMI_VHT_CAP_MAX_AMPDU_LEN_EXP_SHIFT);
5889 vht_cap->vht_su_bformer = QDF_MAX(vht_cap->vht_su_bformer,
5890 value & WMI_VHT_CAP_SU_BFORMER);
5891 vht_cap->vht_su_bformee = QDF_MAX(vht_cap->vht_su_bformee,
5892 value & WMI_VHT_CAP_SU_BFORMEE);
5893 vht_cap->vht_mu_bformer = QDF_MAX(vht_cap->vht_mu_bformer,
5894 value & WMI_VHT_CAP_MU_BFORMER);
5895 vht_cap->vht_mu_bformee = QDF_MAX(vht_cap->vht_mu_bformee,
5896 value & WMI_VHT_CAP_MU_BFORMEE);
5897 vht_cap->vht_txop_ps = QDF_MIN(vht_cap->vht_txop_ps,
5898 value & WMI_VHT_CAP_TXOP_PS);
5899 }
5900 }
5901
5902 /**
5903 * wma_update_target_ext_vht_cap() - Update VHT caps with given extended cap
5904 * @tgt_hdl: target psoc information
5905 * @vht_cap: VHT cap structure to be filled
5906 *
5907 * This function loop through each hardware mode and for each hardware mode
5908 * again it loop through each MAC/PHY and pull the caps 2G and 5G specific
5909 * VHT caps and derives the final cap.
5910 *
5911 * Return: none
5912 *
5913 */
wma_update_target_ext_vht_cap(struct target_psoc_info * tgt_hdl,struct wma_tgt_vht_cap * vht_cap)5914 static void wma_update_target_ext_vht_cap(struct target_psoc_info *tgt_hdl,
5915 struct wma_tgt_vht_cap *vht_cap)
5916 {
5917 int i, num_hw_modes, total_mac_phy_cnt;
5918 uint32_t vht_cap_info_2g, vht_cap_info_5g;
5919 struct wma_tgt_vht_cap tmp_vht_cap = {0}, tmp_cap = {0};
5920 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap;
5921 uint32_t vht_mcs_10_11_supp = 0;
5922
5923 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
5924 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
5925
5926 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
5927 if (!mac_phy_cap) {
5928 wma_err("Invalid MAC PHY capabilities handle");
5929 return;
5930 }
5931
5932 /*
5933 * for legacy device extended cap might not even come, so in that case
5934 * don't overwrite legacy values
5935 */
5936 if (!num_hw_modes) {
5937 wma_debug("No extended VHT cap for current SOC");
5938 return;
5939 }
5940
5941 for (i = 0; i < total_mac_phy_cnt; i++) {
5942 vht_cap_info_2g = mac_phy_cap[i].vht_cap_info_2G;
5943 vht_cap_info_5g = mac_phy_cap[i].vht_cap_info_5G;
5944 if (vht_cap_info_2g)
5945 wma_derive_ext_vht_cap(&tmp_vht_cap,
5946 vht_cap_info_2g);
5947 if (vht_cap_info_5g)
5948 wma_derive_ext_vht_cap(&tmp_vht_cap,
5949 vht_cap_info_5g);
5950 if (WMI_GET_BITS(mac_phy_cap[i].vht_supp_mcs_5G, 16, 2) &&
5951 WMI_VHT_MCS_NOTIFY_EXT_SS_GET(mac_phy_cap[i].
5952 vht_supp_mcs_5G))
5953 vht_mcs_10_11_supp = 1;
5954 if (WMI_GET_BITS(mac_phy_cap[i].vht_supp_mcs_2G, 16, 2) &&
5955 WMI_VHT_MCS_NOTIFY_EXT_SS_GET(mac_phy_cap[i].
5956 vht_supp_mcs_2G))
5957 vht_mcs_10_11_supp = 1;
5958 }
5959
5960 if (qdf_mem_cmp(&tmp_cap, &tmp_vht_cap,
5961 sizeof(struct wma_tgt_vht_cap))) {
5962 qdf_mem_copy(vht_cap, &tmp_vht_cap,
5963 sizeof(struct wma_tgt_vht_cap));
5964 }
5965 vht_cap->vht_mcs_10_11_supp = vht_mcs_10_11_supp;
5966 wma_nofl_debug("[ext vhtcap] max_mpdu %d supp_chan_width %x rx_ldpc %x\n"
5967 "short_gi_80 %x tx_stbc %x rx_stbc %x txop_ps %x\n"
5968 "su_bformee %x mu_bformee %x max_ampdu_len_exp %d\n"
5969 "vht_mcs_10_11_supp %d",
5970 vht_cap->vht_max_mpdu, vht_cap->supp_chan_width,
5971 vht_cap->vht_rx_ldpc, vht_cap->vht_short_gi_80,
5972 vht_cap->vht_tx_stbc, vht_cap->vht_rx_stbc,
5973 vht_cap->vht_txop_ps, vht_cap->vht_su_bformee,
5974 vht_cap->vht_mu_bformee, vht_cap->vht_max_ampdu_len_exp,
5975 vht_cap->vht_mcs_10_11_supp);
5976 }
5977
5978 static void
wma_update_sar_version(struct wlan_psoc_host_service_ext_param * param,struct wma_tgt_cfg * cfg)5979 wma_update_sar_version(struct wlan_psoc_host_service_ext_param *param,
5980 struct wma_tgt_cfg *cfg)
5981 {
5982 cfg->sar_version = param ? param->sar_version : SAR_VERSION_1;
5983 }
5984
5985 /**
5986 * wma_update_hdd_band_cap() - update band cap which hdd understands
5987 * @supported_band: supported band which has been given by FW
5988 * @tgt_cfg: target configuration to be updated
5989 * @psoc: psoc ptr
5990 *
5991 * Convert WMA given supported band to enum which HDD understands
5992 *
5993 * Return: None
5994 */
wma_update_hdd_band_cap(WMI_PHY_CAPABILITY supported_band,struct wma_tgt_cfg * tgt_cfg,struct wlan_objmgr_psoc * psoc)5995 static void wma_update_hdd_band_cap(WMI_PHY_CAPABILITY supported_band,
5996 struct wma_tgt_cfg *tgt_cfg,
5997 struct wlan_objmgr_psoc *psoc)
5998 {
5999 switch (supported_band) {
6000 case WMI_11G_CAPABILITY:
6001 case WMI_11NG_CAPABILITY:
6002 tgt_cfg->band_cap = BIT(REG_BAND_2G);
6003 break;
6004 case WMI_11A_CAPABILITY:
6005 case WMI_11NA_CAPABILITY:
6006 case WMI_11AC_CAPABILITY:
6007 tgt_cfg->band_cap = BIT(REG_BAND_5G);
6008 break;
6009 case WMI_11AG_CAPABILITY:
6010 case WMI_11NAG_CAPABILITY:
6011 case WMI_11AX_CAPABILITY:
6012 tgt_cfg->band_cap = (BIT(REG_BAND_2G) | BIT(REG_BAND_5G));
6013 if (wlan_reg_is_6ghz_supported(psoc))
6014 tgt_cfg->band_cap |= BIT(REG_BAND_6G);
6015 break;
6016 default:
6017 tgt_cfg->band_cap = (BIT(REG_BAND_2G) |
6018 BIT(REG_BAND_5G) |
6019 BIT(REG_BAND_6G));
6020 }
6021 }
6022
6023 /**
6024 * wma_update_obss_detection_support() - update obss detection offload support
6025 * @wh: wma handle
6026 * @tgt_cfg: target configuration to be updated
6027 *
6028 * Update obss detection offload support based on service bit.
6029 *
6030 * Return: None
6031 */
wma_update_obss_detection_support(tp_wma_handle wh,struct wma_tgt_cfg * tgt_cfg)6032 static void wma_update_obss_detection_support(tp_wma_handle wh,
6033 struct wma_tgt_cfg *tgt_cfg)
6034 {
6035 if (wmi_service_enabled(wh->wmi_handle,
6036 wmi_service_ap_obss_detection_offload))
6037 tgt_cfg->obss_detection_offloaded = true;
6038 else
6039 tgt_cfg->obss_detection_offloaded = false;
6040 }
6041
6042 /**
6043 * wma_update_obss_color_collision_support() - update obss color collision
6044 * offload support
6045 * @wh: wma handle
6046 * @tgt_cfg: target configuration to be updated
6047 *
6048 * Update obss color collision offload support based on service bit.
6049 *
6050 * Return: None
6051 */
wma_update_obss_color_collision_support(tp_wma_handle wh,struct wma_tgt_cfg * tgt_cfg)6052 static void wma_update_obss_color_collision_support(tp_wma_handle wh,
6053 struct wma_tgt_cfg *tgt_cfg)
6054 {
6055 if (wmi_service_enabled(wh->wmi_handle, wmi_service_bss_color_offload))
6056 tgt_cfg->obss_color_collision_offloaded = true;
6057 else
6058 tgt_cfg->obss_color_collision_offloaded = false;
6059 }
6060
6061 /**
6062 * wma_update_restricted_80p80_bw_support() - update restricted 80+80 support
6063 * @wh: wma handle
6064 * @tgt_cfg: target configuration to be updated
6065 *
6066 * Update restricted 80+80MHz (165MHz) BW support based on service bit.
6067 *
6068 * Return: None
6069 */
wma_update_restricted_80p80_bw_support(tp_wma_handle wh,struct wma_tgt_cfg * tgt_cfg)6070 static void wma_update_restricted_80p80_bw_support(tp_wma_handle wh,
6071 struct wma_tgt_cfg *tgt_cfg)
6072 {
6073 if (wmi_service_enabled(wh->wmi_handle,
6074 wmi_service_bw_165mhz_support))
6075 tgt_cfg->restricted_80p80_bw_supp = true;
6076 else
6077 tgt_cfg->restricted_80p80_bw_supp = false;
6078 }
6079
6080 /**
6081 * wma_update_aux_dev_caps() - update aux device capability
6082 * @tgt_hdl: target psoc information
6083 * @tgt_cfg: target configuration to be updated
6084 *
6085 * Update aux device capability to wma_tgt_cfg.
6086 *
6087 * Return: None
6088 */
wma_update_aux_dev_caps(struct target_psoc_info * tgt_hdl,struct wma_tgt_cfg * tgt_cfg)6089 static void wma_update_aux_dev_caps(struct target_psoc_info *tgt_hdl,
6090 struct wma_tgt_cfg *tgt_cfg)
6091 {
6092 uint8_t cap_idx;
6093 uint32_t num_aux_dev_caps;
6094 struct wlan_psoc_host_aux_dev_caps *aux_dev_caps;
6095 enum wmi_host_hw_mode_config_type hw_mode_id;
6096
6097 num_aux_dev_caps = tgt_hdl->info.service_ext2_param.num_aux_dev_caps;
6098 aux_dev_caps = tgt_hdl->info.aux_dev_caps;
6099
6100 for (cap_idx = 0; cap_idx < num_aux_dev_caps; cap_idx++) {
6101 /*current only support AUX0*/
6102 if (aux_dev_caps[cap_idx].aux_index != 0)
6103 continue;
6104
6105 hw_mode_id = aux_dev_caps[cap_idx].hw_mode_id;
6106 if (hw_mode_id >= WMI_HOST_HW_MODE_MAX) {
6107 wma_err("invalid hw mode id %d.", hw_mode_id);
6108 continue;
6109 }
6110 tgt_cfg->wma_aux0_dev_caps[hw_mode_id].supported_modes_bitmap =
6111 aux_dev_caps[cap_idx].supported_modes_bitmap;
6112 tgt_cfg->wma_aux0_dev_caps[hw_mode_id].listen_pdev_id_map =
6113 aux_dev_caps[cap_idx].listen_pdev_id_map;
6114 tgt_cfg->wma_aux0_dev_caps[hw_mode_id].emlsr_pdev_id_map =
6115 aux_dev_caps[cap_idx].emlsr_pdev_id_map;
6116 }
6117 }
6118
6119 #ifdef WLAN_SUPPORT_GREEN_AP
wma_green_ap_register_handlers(tp_wma_handle wma_handle)6120 static void wma_green_ap_register_handlers(tp_wma_handle wma_handle)
6121 {
6122 if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
6123 WMI_SERVICE_EGAP))
6124 target_if_green_ap_register_egap_event_handler(
6125 wma_handle->pdev);
6126
6127 target_if_green_ap_register_ll_ps_event_handler(wma_handle->pdev);
6128
6129 }
6130 #else
wma_green_ap_register_handlers(tp_wma_handle wma_handle)6131 static inline void wma_green_ap_register_handlers(tp_wma_handle wma_handle)
6132 {
6133 }
6134 #endif
6135
6136 #ifdef WLAN_FEATURE_NAN
6137 #ifdef WLAN_FEATURE_11BE_MLO
wma_update_mlo_sta_nan_ndi_target_caps(tp_wma_handle wma_handle,struct wma_tgt_cfg * tgt_cfg)6138 static void wma_update_mlo_sta_nan_ndi_target_caps(tp_wma_handle wma_handle,
6139 struct wma_tgt_cfg *tgt_cfg)
6140 {
6141 if (wmi_service_enabled(wma_handle->wmi_handle,
6142 wmi_service_mlo_sta_nan_ndi_support))
6143 tgt_cfg->nan_caps.mlo_sta_nan_ndi_allowed = 1;
6144 }
6145 #else
wma_update_mlo_sta_nan_ndi_target_caps(tp_wma_handle wma_handle,struct wma_tgt_cfg * tgt_cfg)6146 static void wma_update_mlo_sta_nan_ndi_target_caps(tp_wma_handle wma_handle,
6147 struct wma_tgt_cfg *tgt_cfg)
6148 {
6149 }
6150 #endif /* WLAN_FEATURE_11BE_MLO */
6151
wma_update_nan_target_caps(tp_wma_handle wma_handle,struct wma_tgt_cfg * tgt_cfg)6152 static void wma_update_nan_target_caps(tp_wma_handle wma_handle,
6153 struct wma_tgt_cfg *tgt_cfg)
6154 {
6155 if (wmi_service_enabled(wma_handle->wmi_handle,
6156 wmi_service_nan_disable_support))
6157 tgt_cfg->nan_caps.nan_conc_control = 1;
6158
6159 if (wmi_service_enabled(wma_handle->wmi_handle,
6160 wmi_service_nan_dbs_support))
6161 tgt_cfg->nan_caps.nan_dbs_supported = 1;
6162
6163 if (wmi_service_enabled(wma_handle->wmi_handle,
6164 wmi_service_ndi_dbs_support))
6165 tgt_cfg->nan_caps.ndi_dbs_supported = 1;
6166
6167 if (wmi_service_enabled(wma_handle->wmi_handle,
6168 wmi_service_nan_sap_support))
6169 tgt_cfg->nan_caps.nan_sap_supported = 1;
6170
6171 if (wmi_service_enabled(wma_handle->wmi_handle,
6172 wmi_service_ndi_sap_support))
6173 tgt_cfg->nan_caps.ndi_sap_supported = 1;
6174
6175 if (wmi_service_enabled(wma_handle->wmi_handle, wmi_service_nan_vdev))
6176 tgt_cfg->nan_caps.nan_vdev_allowed = 1;
6177
6178 if (wmi_service_enabled(wma_handle->wmi_handle,
6179 wmi_service_sta_nan_ndi_four_port))
6180 tgt_cfg->nan_caps.sta_nan_ndi_ndi_allowed = 1;
6181
6182 if (wmi_service_enabled(wma_handle->wmi_handle,
6183 wmi_service_ndi_txbf_support))
6184 tgt_cfg->nan_caps.ndi_txbf_supported = 1;
6185
6186 wma_update_mlo_sta_nan_ndi_target_caps(wma_handle, tgt_cfg);
6187 }
6188 #else
wma_update_nan_target_caps(tp_wma_handle wma_handle,struct wma_tgt_cfg * tgt_cfg)6189 static void wma_update_nan_target_caps(tp_wma_handle wma_handle,
6190 struct wma_tgt_cfg *tgt_cfg)
6191 {
6192 }
6193 #endif
6194
6195 static uint8_t
wma_convert_chainmask_to_chain(uint8_t chainmask)6196 wma_convert_chainmask_to_chain(uint8_t chainmask)
6197 {
6198 uint8_t num_chains = 0;
6199
6200 while (chainmask) {
6201 chainmask &= (chainmask - 1);
6202 num_chains++;
6203 }
6204
6205 return num_chains;
6206 }
6207
6208 static void
wma_fill_chain_cfg(struct target_psoc_info * tgt_hdl,uint8_t phy)6209 wma_fill_chain_cfg(struct target_psoc_info *tgt_hdl,
6210 uint8_t phy)
6211 {
6212 struct mac_context *mac_ctx;
6213 uint8_t num_chain;
6214 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap =
6215 tgt_hdl->info.mac_phy_cap;
6216
6217 mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
6218 if (!mac_ctx) {
6219 wma_err("fill chain cfg failed as mac_ctx is NULL");
6220 return;
6221 }
6222
6223 num_chain = wma_convert_chainmask_to_chain(mac_phy_cap[phy].
6224 tx_chain_mask_2G);
6225
6226 if (num_chain > mac_ctx->fw_chain_cfg.max_tx_chains_2g)
6227 mac_ctx->fw_chain_cfg.max_tx_chains_2g = num_chain;
6228
6229 num_chain = wma_convert_chainmask_to_chain(mac_phy_cap[phy].
6230 tx_chain_mask_5G);
6231
6232 if (num_chain > mac_ctx->fw_chain_cfg.max_tx_chains_5g)
6233 mac_ctx->fw_chain_cfg.max_tx_chains_5g = num_chain;
6234
6235 num_chain = wma_convert_chainmask_to_chain(mac_phy_cap[phy].
6236 rx_chain_mask_2G);
6237
6238 if (num_chain > mac_ctx->fw_chain_cfg.max_rx_chains_2g)
6239 mac_ctx->fw_chain_cfg.max_rx_chains_2g = num_chain;
6240
6241 num_chain = wma_convert_chainmask_to_chain(mac_phy_cap[phy].
6242 rx_chain_mask_5G);
6243
6244 if (num_chain > mac_ctx->fw_chain_cfg.max_rx_chains_5g)
6245 mac_ctx->fw_chain_cfg.max_rx_chains_5g = num_chain;
6246 }
6247
wma_update_mlme_related_tgt_caps(struct wlan_objmgr_psoc * psoc,struct wmi_unified * wmi_handle)6248 static void wma_update_mlme_related_tgt_caps(struct wlan_objmgr_psoc *psoc,
6249 struct wmi_unified *wmi_handle)
6250 {
6251 struct mlme_tgt_caps mlme_tgt_cfg;
6252
6253 mlme_tgt_cfg.data_stall_recovery_fw_support =
6254 wmi_service_enabled(wmi_handle,
6255 wmi_service_data_stall_recovery_support);
6256
6257 mlme_tgt_cfg.bigtk_support =
6258 wmi_service_enabled(wmi_handle, wmi_beacon_protection_support);
6259
6260 mlme_tgt_cfg.stop_all_host_scan_support =
6261 wmi_service_enabled(wmi_handle,
6262 wmi_service_host_scan_stop_vdev_all);
6263 mlme_tgt_cfg.dual_sta_roam_fw_support =
6264 wmi_service_enabled(wmi_handle,
6265 wmi_service_dual_sta_roam_support);
6266
6267 mlme_tgt_cfg.ocv_support =
6268 wmi_service_enabled(wmi_handle,
6269 wmi_service_ocv_support);
6270
6271 wma_debug("beacon protection support %d, ocv support %d",
6272 mlme_tgt_cfg.bigtk_support, mlme_tgt_cfg.ocv_support);
6273
6274 /* Call this at last only after filling all the tgt caps */
6275 wlan_mlme_update_cfg_with_tgt_caps(psoc, &mlme_tgt_cfg);
6276 }
6277
6278 /**
6279 * wma_update_mlme_aux_dev_caps() - update aux device capability to mlme
6280 * @psoc: psoc handle
6281 * @tgt_hdl: target psoc information
6282 *
6283 * Update aux device capability to mlme.
6284 *
6285 * Return: None
6286 */
wma_update_mlme_aux_dev_caps(struct wlan_objmgr_psoc * psoc,struct target_psoc_info * tgt_hdl)6287 static void wma_update_mlme_aux_dev_caps(struct wlan_objmgr_psoc *psoc,
6288 struct target_psoc_info *tgt_hdl)
6289 {
6290 uint8_t cap_idx;
6291 uint32_t num_aux_dev_caps;
6292 struct wlan_psoc_host_aux_dev_caps *aux_dev_caps;
6293 enum wmi_host_hw_mode_config_type hw_mode_id;
6294 struct wlan_mlme_aux_dev_caps
6295 wlan_mlme_aux0_dev_caps[WLAN_MLME_HW_MODE_MAX] = {0};
6296
6297 if (WMI_HOST_HW_MODE_MAX != WLAN_MLME_HW_MODE_MAX)
6298 wma_err("struct define mismatch, pls fix it.");
6299
6300 num_aux_dev_caps =
6301 tgt_hdl->info.service_ext2_param.num_aux_dev_caps;
6302 aux_dev_caps = tgt_hdl->info.aux_dev_caps;
6303
6304 for (cap_idx = 0; cap_idx < num_aux_dev_caps; cap_idx++) {
6305 /*current only support AUX0*/
6306 if (aux_dev_caps[cap_idx].aux_index != 0)
6307 continue;
6308
6309 hw_mode_id = aux_dev_caps[cap_idx].hw_mode_id;
6310 if (hw_mode_id >= WMI_HOST_HW_MODE_MAX) {
6311 wma_err("invalid hw mode id %d.", hw_mode_id);
6312 continue;
6313 }
6314 wlan_mlme_aux0_dev_caps[hw_mode_id].supported_modes_bitmap =
6315 aux_dev_caps[cap_idx].supported_modes_bitmap;
6316 wlan_mlme_aux0_dev_caps[hw_mode_id].listen_pdev_id_map =
6317 aux_dev_caps[cap_idx].listen_pdev_id_map;
6318 wlan_mlme_aux0_dev_caps[hw_mode_id].emlsr_pdev_id_map =
6319 aux_dev_caps[cap_idx].emlsr_pdev_id_map;
6320 }
6321
6322 wlan_mlme_update_aux_dev_caps(psoc, wlan_mlme_aux0_dev_caps);
6323 }
6324
6325 static bool
wma_is_dbs_mandatory(struct wlan_objmgr_psoc * psoc,struct target_psoc_info * tgt_hdl)6326 wma_is_dbs_mandatory(struct wlan_objmgr_psoc *psoc,
6327 struct target_psoc_info *tgt_hdl)
6328 {
6329 uint8_t i, total_mac_phy_cnt;
6330 struct wlan_psoc_host_mac_phy_caps *mac_cap, *mac_phy_cap;
6331 uint8_t supported_band = 0;
6332
6333 if (!policy_mgr_find_if_fw_supports_dbs(psoc) ||
6334 !policy_mgr_find_if_hwlist_has_dbs(psoc)) {
6335 wma_debug("DBS is not mandatory");
6336 return false;
6337 }
6338
6339 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
6340 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
6341 if (!mac_phy_cap) {
6342 wma_err("Invalid MAC PHY capabilities handle");
6343 return false;
6344 }
6345
6346
6347 for (i = 0; i < total_mac_phy_cnt; i++) {
6348 mac_cap = &mac_phy_cap[i];
6349 if (mac_cap && (mac_cap->phy_id == 0))
6350 supported_band |= mac_cap->supported_bands;
6351 }
6352
6353 /* If Mac0 supports both the bands then DBS is not mandatory */
6354 if (supported_band & WLAN_2G_CAPABILITY &&
6355 supported_band & WLAN_5G_CAPABILITY) {
6356 wma_debug("Mac0 supports both bands DBS is optional");
6357 return false;
6358 }
6359
6360 wma_info("MAC0 does not support both bands %d DBS is mandatory",
6361 supported_band);
6362
6363 return true;
6364 }
6365
6366 /**
6367 * wma_update_hdd_cfg() - update HDD config
6368 * @wma_handle: wma handle
6369 *
6370 * Return: Zero on success err number on failure
6371 */
wma_update_hdd_cfg(tp_wma_handle wma_handle)6372 static int wma_update_hdd_cfg(tp_wma_handle wma_handle)
6373 {
6374 struct wma_tgt_cfg tgt_cfg;
6375 void *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
6376 target_resource_config *wlan_res_cfg;
6377 struct wlan_psoc_host_service_ext_param *service_ext_param;
6378 struct target_psoc_info *tgt_hdl;
6379 struct wmi_unified *wmi_handle;
6380 uint8_t i;
6381 int ret;
6382
6383 wma_debug("Enter");
6384
6385 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
6386 if (!tgt_hdl) {
6387 wma_err("target psoc info is NULL");
6388 return -EINVAL;
6389 }
6390
6391 wlan_res_cfg = target_psoc_get_wlan_res_cfg(tgt_hdl);
6392 if (!wlan_res_cfg) {
6393 wma_err("wlan_res_cfg is null");
6394 return -EINVAL;
6395 }
6396
6397 service_ext_param =
6398 target_psoc_get_service_ext_param(tgt_hdl);
6399 wmi_handle = get_wmi_unified_hdl_from_psoc(wma_handle->psoc);
6400 if (wmi_validate_handle(wmi_handle))
6401 return -EINVAL;
6402
6403 wma_update_mlme_related_tgt_caps(wma_handle->psoc, wmi_handle);
6404 wma_update_mlme_aux_dev_caps(wma_handle->psoc, tgt_hdl);
6405
6406 if (wmi_service_enabled(wmi_handle, wmi_service_peer_create_conf))
6407 wlan_psoc_nif_fw_ext_cap_set(wma_handle->psoc,
6408 WLAN_SOC_F_PEER_CREATE_RESP);
6409
6410 qdf_mem_zero(&tgt_cfg, sizeof(struct wma_tgt_cfg));
6411
6412 tgt_cfg.sub_20_support = wma_handle->sub_20_support;
6413 tgt_cfg.reg_domain = wma_handle->reg_cap.eeprom_rd;
6414 tgt_cfg.eeprom_rd_ext = wma_handle->reg_cap.eeprom_rd_ext;
6415
6416 tgt_cfg.max_intf_count = wlan_res_cfg->num_vdevs;
6417 policy_mgr_set_max_conc_cxns(wma_handle->psoc,
6418 wlan_res_cfg->num_max_active_vdevs);
6419
6420 qdf_mem_copy(tgt_cfg.hw_macaddr.bytes, wma_handle->hwaddr,
6421 ATH_MAC_LEN);
6422
6423 wma_update_target_services(wmi_handle, &tgt_cfg.services);
6424 wma_update_target_ht_cap(tgt_hdl, &tgt_cfg.ht_cap);
6425 wma_update_target_vht_cap(tgt_hdl, &tgt_cfg.vht_cap);
6426 /*
6427 * This will overwrite the structure filled by wma_update_target_ht_cap
6428 * and wma_update_target_vht_cap APIs.
6429 */
6430 wma_update_target_ext_ht_cap(tgt_hdl, &tgt_cfg.ht_cap);
6431 wma_update_target_ext_vht_cap(tgt_hdl, &tgt_cfg.vht_cap);
6432
6433 wma_update_target_ext_he_cap(tgt_hdl, &tgt_cfg);
6434 wma_update_target_ext_eht_cap(tgt_hdl, &tgt_cfg);
6435
6436 tgt_cfg.target_fw_version = target_if_get_fw_version(tgt_hdl);
6437 if (service_ext_param)
6438 tgt_cfg.target_fw_vers_ext =
6439 service_ext_param->fw_build_vers_ext;
6440
6441 tgt_cfg.hw_bd_id = wma_handle->hw_bd_id;
6442 tgt_cfg.hw_bd_info.bdf_version = wma_handle->hw_bd_info[BDF_VERSION];
6443 tgt_cfg.hw_bd_info.ref_design_id =
6444 wma_handle->hw_bd_info[REF_DESIGN_ID];
6445 tgt_cfg.hw_bd_info.customer_id = wma_handle->hw_bd_info[CUSTOMER_ID];
6446 tgt_cfg.hw_bd_info.project_id = wma_handle->hw_bd_info[PROJECT_ID];
6447 tgt_cfg.hw_bd_info.board_data_rev =
6448 wma_handle->hw_bd_info[BOARD_DATA_REV];
6449
6450 #ifdef WLAN_FEATURE_LPSS
6451 tgt_cfg.lpss_support = wma_handle->lpss_support;
6452 #endif /* WLAN_FEATURE_LPSS */
6453 tgt_cfg.ap_arpns_support = wma_handle->ap_arpns_support;
6454 tgt_cfg.dfs_cac_offload = wma_handle->is_dfs_offloaded;
6455 tgt_cfg.rcpi_enabled = wma_handle->rcpi_enabled;
6456 wma_update_hdd_band_cap(target_if_get_phy_capability(tgt_hdl),
6457 &tgt_cfg, wma_handle->psoc);
6458 wma_update_sar_version(service_ext_param, &tgt_cfg);
6459 tgt_cfg.fine_time_measurement_cap =
6460 target_if_get_wmi_fw_sub_feat_caps(tgt_hdl);
6461 tgt_cfg.wmi_max_len = wmi_get_max_msg_len(wma_handle->wmi_handle)
6462 - WMI_TLV_HEADROOM;
6463 tgt_cfg.tx_bfee_8ss_enabled = wma_handle->tx_bfee_8ss_enabled;
6464 tgt_cfg.dynamic_nss_chains_support =
6465 wma_handle->dynamic_nss_chains_support;
6466 wma_update_obss_detection_support(wma_handle, &tgt_cfg);
6467 wma_update_obss_color_collision_support(wma_handle, &tgt_cfg);
6468 wma_update_hdd_cfg_ndp(wma_handle, &tgt_cfg);
6469 wma_update_nan_target_caps(wma_handle, &tgt_cfg);
6470 wma_update_bcast_twt_support(wma_handle, &tgt_cfg);
6471 wma_update_twt_tgt_cap(wma_handle, &tgt_cfg);
6472 wma_update_restricted_80p80_bw_support(wma_handle, &tgt_cfg);
6473 wma_update_aux_dev_caps(tgt_hdl, &tgt_cfg);
6474 /* Take the max of chains supported by FW, which will limit nss */
6475 for (i = 0; i < tgt_hdl->info.total_mac_phy_cnt; i++)
6476 wma_fill_chain_cfg(tgt_hdl, i);
6477
6478 ret = wma_handle->tgt_cfg_update_cb(hdd_ctx, &tgt_cfg);
6479 if (ret)
6480 return -EINVAL;
6481
6482 wma_green_ap_register_handlers(wma_handle);
6483
6484 return ret;
6485 }
6486
6487 /**
6488 * wma_init_scan_fw_mode_config() - Initialize scan/fw mode config
6489 * @psoc: Object manager psoc
6490 * @scan_config: Scam mode configuration
6491 * @fw_config: FW mode configuration
6492 *
6493 * Enables all the valid bits of concurrent_scan_config_bits and
6494 * fw_mode_config_bits.
6495 *
6496 * Return: None
6497 */
wma_init_scan_fw_mode_config(struct wlan_objmgr_psoc * psoc,uint32_t scan_config,uint32_t fw_config)6498 static void wma_init_scan_fw_mode_config(struct wlan_objmgr_psoc *psoc,
6499 uint32_t scan_config,
6500 uint32_t fw_config)
6501 {
6502 wma_debug("Enter");
6503
6504 if (!psoc) {
6505 wma_err("obj psoc is NULL");
6506 return;
6507 }
6508
6509 policy_mgr_init_dbs_config(psoc, scan_config, fw_config);
6510 policy_mgr_init_sbs_fw_config(psoc, fw_config);
6511
6512 wma_debug("Exit");
6513 }
6514
wma_set_pmo_caps(struct wlan_objmgr_psoc * psoc)6515 static void wma_set_pmo_caps(struct wlan_objmgr_psoc *psoc)
6516 {
6517 QDF_STATUS status;
6518 tp_wma_handle wma;
6519 struct pmo_device_caps caps;
6520
6521 wma = cds_get_context(QDF_MODULE_ID_WMA);
6522 if (!wma)
6523 return;
6524
6525 caps.arp_ns_offload =
6526 wmi_service_enabled(wma->wmi_handle, wmi_service_arpns_offload);
6527 caps.apf =
6528 wmi_service_enabled(wma->wmi_handle, wmi_service_apf_offload);
6529 caps.packet_filter =
6530 wmi_service_enabled(wma->wmi_handle,
6531 wmi_service_packet_filter_offload);
6532 caps.unified_wow =
6533 wmi_service_enabled(wma->wmi_handle,
6534 wmi_service_unified_wow_capability);
6535 caps.li_offload =
6536 wmi_service_enabled(wma->wmi_handle,
6537 wmi_service_listen_interval_offload_support
6538 );
6539
6540 status = ucfg_pmo_psoc_set_caps(psoc, &caps);
6541 if (QDF_IS_STATUS_ERROR(status))
6542 wma_err("Failed to set PMO capabilities; status:%d", status);
6543 }
6544
6545 /**
6546 * wma_set_mlme_caps() - Populate the MLME related target capabilities to the
6547 * mlme component
6548 * @psoc: Pointer to psoc object
6549 *
6550 * Return: None
6551 */
wma_set_mlme_caps(struct wlan_objmgr_psoc * psoc)6552 static void wma_set_mlme_caps(struct wlan_objmgr_psoc *psoc)
6553 {
6554 tp_wma_handle wma;
6555 bool tgt_cap;
6556 uint32_t akm_bitmap = 0;
6557 QDF_STATUS status;
6558
6559 wma = cds_get_context(QDF_MODULE_ID_WMA);
6560 if (!wma)
6561 return;
6562
6563 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6564 wmi_service_adaptive_11r_support);
6565
6566 status = ucfg_mlme_set_tgt_adaptive_11r_cap(psoc, tgt_cap);
6567 if (QDF_IS_STATUS_ERROR(status))
6568 wma_err("Failed to set adaptive 11r cap");
6569
6570 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6571 wmi_service_wpa3_ft_sae_support);
6572 if (tgt_cap)
6573 akm_bitmap |= (1 << AKM_FT_SAE);
6574
6575 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6576 wmi_service_wpa3_ft_suite_b_support);
6577 if (tgt_cap)
6578 akm_bitmap |= (1 << AKM_FT_SUITEB_SHA384);
6579
6580 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6581 wmi_service_ft_fils);
6582 if (tgt_cap)
6583 akm_bitmap |= (1 << AKM_FT_FILS);
6584
6585 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6586 wmi_service_owe_roam_support);
6587 if (tgt_cap)
6588 akm_bitmap |= (1 << AKM_OWE);
6589
6590 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6591 wmi_service_sae_roam_support);
6592 if (tgt_cap)
6593 akm_bitmap |= (1 << AKM_SAE);
6594
6595 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6596 wmi_service_suiteb_roam_support);
6597 if (tgt_cap)
6598 akm_bitmap |= (1 << AKM_SUITEB);
6599
6600 tgt_cap = wmi_service_enabled(wma->wmi_handle,
6601 wmi_service_wpa3_sha384_roam_support);
6602 if (tgt_cap)
6603 akm_bitmap |= (1 << AKM_SAE_EXT);
6604
6605 status = mlme_set_tgt_wpa3_roam_cap(psoc, akm_bitmap);
6606 if (QDF_IS_STATUS_ERROR(status))
6607 wma_err("Failed to set sae roam support");
6608 }
6609
6610 #ifdef WLAN_FEATURE_BIG_DATA_STATS
wma_is_big_data_support_enable(struct wmi_unified * wmi_handle)6611 static bool wma_is_big_data_support_enable(struct wmi_unified *wmi_handle)
6612 {
6613 return wmi_service_enabled(wmi_handle, wmi_service_big_data_support);
6614 }
6615 #else
wma_is_big_data_support_enable(struct wmi_unified * wmi_handle)6616 static bool wma_is_big_data_support_enable(struct wmi_unified *wmi_handle)
6617 {
6618 return false;
6619 }
6620 #endif
6621
6622 /**
6623 * wma_set_mc_cp_caps() - Populate mc cp component related capabilities
6624 * to the mc cp component
6625 *
6626 * @psoc: Pointer to psoc object
6627 *
6628 * Return: None
6629 */
wma_set_mc_cp_caps(struct wlan_objmgr_psoc * psoc)6630 static void wma_set_mc_cp_caps(struct wlan_objmgr_psoc *psoc)
6631 {
6632 tp_wma_handle wma;
6633
6634 wma = cds_get_context(QDF_MODULE_ID_WMA);
6635 if (!wma)
6636 return;
6637
6638 if (wma_is_big_data_support_enable(wma->wmi_handle))
6639 ucfg_mc_cp_set_big_data_fw_support(psoc, true);
6640 else
6641 ucfg_mc_cp_set_big_data_fw_support(psoc, false);
6642 }
6643
6644 #ifdef THERMAL_STATS_SUPPORT
wma_set_thermal_stats_fw_cap(tp_wma_handle wma,struct wlan_fwol_capability_info * cap)6645 static void wma_set_thermal_stats_fw_cap(tp_wma_handle wma,
6646 struct wlan_fwol_capability_info *cap)
6647 {
6648 cap->fw_thermal_stats_cap = wmi_service_enabled(wma->wmi_handle,
6649 wmi_service_thermal_stats_temp_range_supported);
6650 }
6651 #else
wma_set_thermal_stats_fw_cap(tp_wma_handle wma,struct wlan_fwol_capability_info * cap)6652 static void wma_set_thermal_stats_fw_cap(tp_wma_handle wma,
6653 struct wlan_fwol_capability_info *cap)
6654 {
6655 }
6656 #endif
6657
6658 /**
6659 * wma_set_fwol_caps() - Populate fwol component related capabilities
6660 * to the fwol component
6661 *
6662 * @psoc: Pointer to psoc object
6663 *
6664 * Return: None
6665 */
wma_set_fwol_caps(struct wlan_objmgr_psoc * psoc)6666 static void wma_set_fwol_caps(struct wlan_objmgr_psoc *psoc)
6667 {
6668 tp_wma_handle wma;
6669 struct wlan_fwol_capability_info cap_info;
6670 wma = cds_get_context(QDF_MODULE_ID_WMA);
6671
6672 if (!wma) {
6673 wma_err_rl("wma Null");
6674 return;
6675 }
6676 if (!psoc) {
6677 wma_err_rl("psoc Null");
6678 return;
6679 }
6680
6681 wma_set_thermal_stats_fw_cap(wma, &cap_info);
6682 ucfg_fwol_update_fw_cap_info(psoc, &cap_info);
6683 }
wma_set_component_caps(struct wlan_objmgr_psoc * psoc)6684 static void wma_set_component_caps(struct wlan_objmgr_psoc *psoc)
6685 {
6686 wma_set_pmo_caps(psoc);
6687 wma_set_mlme_caps(psoc);
6688 wma_set_mc_cp_caps(psoc);
6689 wma_set_fwol_caps(psoc);
6690 }
6691
6692 #if defined(WLAN_FEATURE_GTK_OFFLOAD) && defined(WLAN_POWER_MANAGEMENT_OFFLOAD)
wma_register_gtk_offload_event(tp_wma_handle wma_handle)6693 static QDF_STATUS wma_register_gtk_offload_event(tp_wma_handle wma_handle)
6694 {
6695 QDF_STATUS status = QDF_STATUS_E_FAILURE;
6696
6697 if (wma_validate_handle(wma_handle))
6698 return QDF_STATUS_E_FAILURE;
6699
6700 if (wmi_service_enabled(wma_handle->wmi_handle,
6701 wmi_service_gtk_offload)) {
6702 status = wmi_unified_register_event_handler(
6703 wma_handle->wmi_handle,
6704 wmi_gtk_offload_status_event_id,
6705 target_if_pmo_gtk_offload_status_event,
6706 WMA_RX_WORK_CTX);
6707 }
6708 return status;
6709 }
6710 #else
wma_register_gtk_offload_event(tp_wma_handle wma_handle)6711 static QDF_STATUS wma_register_gtk_offload_event(tp_wma_handle wma_handle)
6712 {
6713 return QDF_STATUS_SUCCESS;
6714 }
6715 #endif /* WLAN_FEATURE_GTK_OFFLOAD && WLAN_POWER_MANAGEMENT_OFFLOAD */
6716
6717 /**
6718 * wma_rx_service_ready_event() - event handler to process
6719 * wmi rx service ready event.
6720 * @handle: wma handle
6721 * @cmd_param_info: command params info
6722 * @length: param length
6723 *
6724 * Return: none
6725 */
wma_rx_service_ready_event(void * handle,uint8_t * cmd_param_info,uint32_t length)6726 int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
6727 uint32_t length)
6728 {
6729 tp_wma_handle wma_handle = (tp_wma_handle) handle;
6730 WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf;
6731 wmi_service_ready_event_fixed_param *ev;
6732 QDF_STATUS status;
6733 uint32_t *ev_wlan_dbs_hw_mode_list;
6734 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
6735 struct target_psoc_info *tgt_hdl;
6736 struct wlan_psoc_target_capability_info *tgt_cap_info;
6737 target_resource_config *wlan_res_cfg;
6738 struct wmi_unified *wmi_handle;
6739 uint32_t *service_bitmap;
6740
6741 wma_debug("Enter");
6742
6743 if (wma_validate_handle(wma_handle))
6744 return -EINVAL;
6745
6746 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
6747 if (!tgt_hdl) {
6748 wma_err("target psoc info is NULL");
6749 return -EINVAL;
6750 }
6751
6752 wlan_res_cfg = target_psoc_get_wlan_res_cfg(tgt_hdl);
6753 tgt_cap_info = target_psoc_get_target_caps(tgt_hdl);
6754 service_bitmap = target_psoc_get_service_bitmap(tgt_hdl);
6755
6756 param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) cmd_param_info;
6757 if (!param_buf) {
6758 wma_err("Invalid arguments");
6759 return -EINVAL;
6760 }
6761
6762 ev = param_buf->fixed_param;
6763 if (!ev) {
6764 wma_err("Invalid buffer");
6765 return -EINVAL;
6766 }
6767
6768 wmi_handle = get_wmi_unified_hdl_from_psoc(wma_handle->psoc);
6769 if (wmi_validate_handle(wmi_handle))
6770 return -EINVAL;
6771
6772 wma_debug("WMA <-- WMI_SERVICE_READY_EVENTID");
6773
6774 if (ev->num_dbs_hw_modes > param_buf->num_wlan_dbs_hw_mode_list) {
6775 wma_err("FW dbs_hw_mode entry %d more than value %d in TLV hdr",
6776 ev->num_dbs_hw_modes,
6777 param_buf->num_wlan_dbs_hw_mode_list);
6778 return -EINVAL;
6779 }
6780
6781 ev_wlan_dbs_hw_mode_list = param_buf->wlan_dbs_hw_mode_list;
6782
6783 /* Continuing with the rest of the processing,
6784 * even if memory allocation fails
6785 */
6786 policy_mgr_init_dbs_hw_mode(wma_handle->psoc, ev->num_dbs_hw_modes,
6787 ev_wlan_dbs_hw_mode_list);
6788
6789 /* Initializes the fw_mode and scan_config to zero.
6790 * If ext service ready event is present it will set
6791 * the actual values of these two params.
6792 * This is to ensure that no garbage values would be
6793 * present in the absence of ext service ready event.
6794 */
6795 wma_init_scan_fw_mode_config(wma_handle->psoc, 0, 0);
6796
6797 qdf_mem_copy(&wma_handle->reg_cap, param_buf->hal_reg_capabilities,
6798 sizeof(HAL_REG_CAPABILITIES));
6799
6800 wma_handle->vht_supp_mcs = ev->vht_supp_mcs;
6801
6802 wma_handle->new_hw_mode_index = tgt_cap_info->default_dbs_hw_mode_index;
6803 policy_mgr_update_new_hw_mode_index(wma_handle->psoc,
6804 tgt_cap_info->default_dbs_hw_mode_index);
6805
6806 wma_debug("Firmware default hw mode index : %d",
6807 tgt_cap_info->default_dbs_hw_mode_index);
6808 wma_info("Firmware build version : %08x",
6809 ev->fw_build_vers);
6810 wma_debug("FW fine time meas cap: 0x%x",
6811 tgt_cap_info->wmi_fw_sub_feat_caps);
6812
6813 wma_handle->hw_bd_id = ev->hw_bd_id;
6814
6815 wma_handle->hw_bd_info[BDF_VERSION] =
6816 WMI_GET_BDF_VERSION(ev->hw_bd_info);
6817 wma_handle->hw_bd_info[REF_DESIGN_ID] =
6818 WMI_GET_REF_DESIGN(ev->hw_bd_info);
6819 wma_handle->hw_bd_info[CUSTOMER_ID] =
6820 WMI_GET_CUSTOMER_ID(ev->hw_bd_info);
6821 wma_handle->hw_bd_info[PROJECT_ID] =
6822 WMI_GET_PROJECT_ID(ev->hw_bd_info);
6823 wma_handle->hw_bd_info[BOARD_DATA_REV] =
6824 WMI_GET_BOARD_DATA_REV(ev->hw_bd_info);
6825
6826 wma_info("Board id: %x, Board version: %x %x %x %x %x",
6827 wma_handle->hw_bd_id,
6828 wma_handle->hw_bd_info[BDF_VERSION],
6829 wma_handle->hw_bd_info[REF_DESIGN_ID],
6830 wma_handle->hw_bd_info[CUSTOMER_ID],
6831 wma_handle->hw_bd_info[PROJECT_ID],
6832 wma_handle->hw_bd_info[BOARD_DATA_REV]);
6833
6834 /* wmi service is ready */
6835 qdf_mem_copy(wma_handle->wmi_service_bitmap,
6836 service_bitmap,
6837 sizeof(wma_handle->wmi_service_bitmap));
6838
6839 cdp_cfg_tx_set_is_mgmt_over_wmi_enabled(soc,
6840 wmi_service_enabled(wmi_handle, wmi_service_mgmt_tx_wmi));
6841 cdp_set_desc_global_pool_size(soc, ev->num_msdu_desc);
6842 /* SWBA event handler for beacon transmission */
6843 status = wma_register_swba_events(wma_handle->wmi_handle);
6844
6845 if (QDF_IS_STATUS_ERROR(status)) {
6846 wma_err("Failed to register swba beacon event cb");
6847 goto failure;
6848 }
6849 #ifdef WLAN_FEATURE_LPSS
6850 wma_handle->lpss_support =
6851 wmi_service_enabled(wmi_handle, wmi_service_lpass);
6852 #endif /* WLAN_FEATURE_LPSS */
6853
6854 if (wmi_service_enabled(wmi_handle, wmi_service_fse_cmem_alloc_support))
6855 wlan_dp_set_fst_in_cmem(true);
6856
6857 if (wmi_service_enabled(wmi_handle,
6858 wmi_service_fisa_dynamic_msdu_aggr_size_support))
6859 wlan_dp_set_fisa_dynamic_aggr_size_support(true);
6860 /*
6861 * This Service bit is added to check for ARP/NS Offload
6862 * support for LL/HL targets
6863 */
6864 wma_handle->ap_arpns_support =
6865 wmi_service_enabled(wmi_handle, wmi_service_ap_arpns_offload);
6866
6867 if (wmi_service_enabled(wmi_handle, wmi_service_csa_offload)) {
6868 wma_debug("FW support CSA offload capability");
6869 status = wmi_unified_register_event_handler(
6870 wmi_handle,
6871 wmi_csa_handling_event_id,
6872 wma_csa_offload_handler,
6873 WMA_RX_SERIALIZER_CTX);
6874 if (QDF_IS_STATUS_ERROR(status)) {
6875 wma_err("Failed to register CSA offload event cb");
6876 goto failure;
6877 }
6878 }
6879
6880 if (wmi_service_enabled(wmi_handle, wmi_service_mgmt_tx_wmi)) {
6881 wma_debug("Firmware supports management TX over WMI,use WMI interface instead of HTT for management Tx");
6882 /*
6883 * Register Tx completion event handler for MGMT Tx over WMI
6884 * case
6885 */
6886 status = wmi_unified_register_event_handler(
6887 wmi_handle,
6888 wmi_mgmt_tx_completion_event_id,
6889 wma_mgmt_tx_completion_handler,
6890 WMA_RX_SERIALIZER_CTX);
6891 if (QDF_IS_STATUS_ERROR(status)) {
6892 wma_err("Failed to register MGMT over WMI completion handler");
6893 goto failure;
6894 }
6895
6896 status = wmi_unified_register_event_handler(
6897 wmi_handle,
6898 wmi_mgmt_tx_bundle_completion_event_id,
6899 wma_mgmt_tx_bundle_completion_handler,
6900 WMA_RX_SERIALIZER_CTX);
6901 if (QDF_IS_STATUS_ERROR(status)) {
6902 wma_err("Failed to register MGMT over WMI completion handler");
6903 goto failure;
6904 }
6905
6906 } else {
6907 wma_err("FW does not support WMI_SERVICE_MGMT_TX_WMI, Use HTT interface for Management Tx");
6908 }
6909
6910 status = wma_register_gtk_offload_event(wma_handle);
6911 if (QDF_IS_STATUS_ERROR(status)) {
6912 wma_err("Failed to register GTK offload event cb");
6913 goto failure;
6914 }
6915
6916 status = wmi_unified_register_event_handler(wmi_handle,
6917 wmi_tbttoffset_update_event_id,
6918 wma_tbttoffset_update_event_handler,
6919 WMA_RX_SERIALIZER_CTX);
6920 if (QDF_IS_STATUS_ERROR(status)) {
6921 wma_err("Failed to register WMI_TBTTOFFSET_UPDATE_EVENTID callback");
6922 goto failure;
6923 }
6924
6925 if (wmi_service_enabled(wma_handle->wmi_handle,
6926 wmi_service_rcpi_support)) {
6927 /* register for rcpi response event */
6928 status = wmi_unified_register_event_handler(
6929 wmi_handle,
6930 wmi_update_rcpi_event_id,
6931 wma_rcpi_event_handler,
6932 WMA_RX_SERIALIZER_CTX);
6933 if (QDF_IS_STATUS_ERROR(status)) {
6934 wma_err("Failed to register RCPI event handler");
6935 goto failure;
6936 }
6937 wma_handle->rcpi_enabled = true;
6938 }
6939
6940 /* mac_id is replaced with pdev_id in converged firmware to have
6941 * multi-radio support. In order to maintain backward compatibility
6942 * with old fw, host needs to check WMI_SERVICE_DEPRECATED_REPLACE
6943 * in service bitmap from FW and host needs to set use_pdev_id in
6944 * wmi_resource_config to true. If WMI_SERVICE_DEPRECATED_REPLACE
6945 * service is not set, then host shall not expect MAC ID from FW in
6946 * VDEV START RESPONSE event and host shall use PDEV ID.
6947 */
6948 if (wmi_service_enabled(wmi_handle, wmi_service_deprecated_replace))
6949 wlan_res_cfg->use_pdev_id = true;
6950 else
6951 wlan_res_cfg->use_pdev_id = false;
6952
6953 wlan_res_cfg->max_num_dbs_scan_duty_cycle = CDS_DBS_SCAN_CLIENTS_MAX;
6954
6955 /* Initialize the log supported event handler */
6956 status = wmi_unified_register_event_handler(wmi_handle,
6957 wmi_diag_event_id_log_supported_event_id,
6958 wma_log_supported_evt_handler,
6959 WMA_RX_SERIALIZER_CTX);
6960 if (QDF_IS_STATUS_ERROR(status)) {
6961 wma_err("Failed to register log supported event cb");
6962 goto failure;
6963 }
6964
6965 cdp_mark_first_wakeup_packet(
6966 soc, OL_TXRX_PDEV_ID,
6967 wmi_service_enabled(wmi_handle,
6968 wmi_service_mark_first_wakeup_packet));
6969 wma_handle->is_dfs_offloaded =
6970 wmi_service_enabled(wmi_handle,
6971 wmi_service_dfs_phyerr_offload);
6972
6973 wma_handle->nan_datapath_enabled =
6974 wmi_service_enabled(wma_handle->wmi_handle,
6975 wmi_service_nan_data);
6976
6977 wma_handle->fw_therm_throt_support =
6978 wmi_service_enabled(wma_handle->wmi_handle,
6979 wmi_service_tt);
6980
6981 wma_set_component_caps(wma_handle->psoc);
6982
6983 wma_update_fw_config(wma_handle->psoc, tgt_hdl);
6984
6985 status = wmi_unified_save_fw_version_cmd(wmi_handle, param_buf);
6986 if (QDF_IS_STATUS_ERROR(status)) {
6987 wma_err("Failed to send WMI_INIT_CMDID command");
6988 goto failure;
6989 }
6990
6991 if (wmi_service_enabled(wmi_handle, wmi_service_ext_msg)) {
6992 status = qdf_mc_timer_start(
6993 &wma_handle->service_ready_ext_timer,
6994 WMA_SERVICE_READY_EXT_TIMEOUT);
6995 if (QDF_IS_STATUS_ERROR(status))
6996 wma_err("Failed to start the service ready ext timer");
6997 }
6998 wma_handle->tx_bfee_8ss_enabled =
6999 wmi_service_enabled(wmi_handle, wmi_service_8ss_tx_bfee);
7000
7001 wma_handle->dynamic_nss_chains_support = wmi_service_enabled(wmi_handle,
7002 wmi_service_per_vdev_chain_support);
7003 target_psoc_set_num_radios(tgt_hdl, 1);
7004
7005 return 0;
7006
7007 failure:
7008 return -EINVAL;
7009
7010 }
7011
7012 /**
7013 * wma_get_caps_for_phyidx_hwmode() - to fetch caps for given hw mode and band
7014 * @caps_per_phy: Pointer to capabilities structure which needs to be filled
7015 * @hw_mode: Provided hardware mode
7016 * @band: Provide band i.e. 2G or 5G
7017 *
7018 * This API finds cap which suitable for provided hw mode and band. If user
7019 * is provides some invalid hw mode then it will automatically falls back to
7020 * default hw mode
7021 *
7022 * Return: QDF_STATUS
7023 */
wma_get_caps_for_phyidx_hwmode(struct wma_caps_per_phy * caps_per_phy,enum hw_mode_dbs_capab hw_mode,enum cds_band_type band)7024 QDF_STATUS wma_get_caps_for_phyidx_hwmode(struct wma_caps_per_phy *caps_per_phy,
7025 enum hw_mode_dbs_capab hw_mode, enum cds_band_type band)
7026 {
7027 t_wma_handle *wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
7028 struct target_psoc_info *tgt_hdl;
7029 int ht_cap_info, vht_cap_info;
7030 uint8_t our_hw_mode = hw_mode, num_hw_modes, hw_mode_config_type;
7031 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap;
7032 struct wlan_psoc_target_capability_info *tgt_cap_info;
7033 uint8_t total_mac_phy_cnt, i;
7034
7035 if (!wma_handle)
7036 return QDF_STATUS_E_FAILURE;
7037
7038 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
7039 if (!tgt_hdl) {
7040 wma_err("target psoc info is NULL");
7041 return -EINVAL;
7042 }
7043 if (!caps_per_phy) {
7044 wma_err("Invalid caps pointer");
7045 return QDF_STATUS_E_FAILURE;
7046 }
7047
7048 ht_cap_info = target_if_get_ht_cap_info(tgt_hdl);
7049 vht_cap_info = target_if_get_vht_cap_info(tgt_hdl);
7050 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
7051 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
7052 tgt_cap_info = target_psoc_get_target_caps(tgt_hdl);
7053
7054 if (!mac_phy_cap) {
7055 wma_err("Invalid MAC PHY capabilities handle");
7056 return QDF_STATUS_E_FAILURE;
7057 }
7058
7059 if (!tgt_cap_info) {
7060 wma_err("Invalid target capabilities handle");
7061 return QDF_STATUS_E_FAILURE;
7062 }
7063
7064 if (!num_hw_modes) {
7065 wma_debug("Invalid number of hw modes, use legacy HT/VHT caps");
7066 caps_per_phy->ht_2g = ht_cap_info;
7067 caps_per_phy->ht_5g = ht_cap_info;
7068 caps_per_phy->vht_2g = vht_cap_info;
7069 caps_per_phy->vht_5g = vht_cap_info;
7070 /* legacy platform doesn't support HE IE */
7071 caps_per_phy->he_2g[0] = 0;
7072 caps_per_phy->he_2g[1] = 0;
7073 caps_per_phy->he_5g[0] = 0;
7074 caps_per_phy->he_5g[1] = 0;
7075 caps_per_phy->tx_chain_mask_2G =
7076 EXTRACT_TX_CHAIN_MASK_2G(tgt_cap_info->txrx_chainmask);
7077 caps_per_phy->rx_chain_mask_2G =
7078 EXTRACT_RX_CHAIN_MASK_2G(tgt_cap_info->txrx_chainmask);
7079 caps_per_phy->tx_chain_mask_5G =
7080 EXTRACT_TX_CHAIN_MASK_5G(tgt_cap_info->txrx_chainmask);
7081 caps_per_phy->rx_chain_mask_5G =
7082 EXTRACT_RX_CHAIN_MASK_5G(tgt_cap_info->txrx_chainmask);
7083
7084 return QDF_STATUS_SUCCESS;
7085 }
7086
7087 if (!policy_mgr_is_dbs_enable(wma_handle->psoc))
7088 our_hw_mode = HW_MODE_DBS_NONE;
7089
7090 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
7091 for (i = 0; i < total_mac_phy_cnt; i++) {
7092 hw_mode_config_type = mac_phy_cap[i].hw_mode_config_type;
7093 if (our_hw_mode == HW_MODE_DBS &&
7094 !(hw_mode_config_type == WMI_HW_MODE_DBS ||
7095 hw_mode_config_type == WMI_HW_MODE_DBS_OR_SBS))
7096 continue;
7097
7098 if ((band == CDS_BAND_2GHZ || band == CDS_BAND_ALL) &&
7099 (WLAN_2G_CAPABILITY & mac_phy_cap[i].supported_bands) &&
7100 !caps_per_phy->tx_chain_mask_2G) {
7101 caps_per_phy->ht_2g = mac_phy_cap[i].ht_cap_info_2G;
7102 caps_per_phy->vht_2g = mac_phy_cap[i].vht_cap_info_2G;
7103 qdf_mem_copy(caps_per_phy->he_2g,
7104 mac_phy_cap[i].he_cap_info_2G,
7105 sizeof(caps_per_phy->he_2g));
7106
7107 caps_per_phy->tx_chain_mask_2G =
7108 mac_phy_cap[i].tx_chain_mask_2G;
7109 caps_per_phy->rx_chain_mask_2G =
7110 mac_phy_cap[i].rx_chain_mask_2G;
7111
7112 wma_debug("Select 2G capable phyid[%d] chain %d %d ht 0x%x vht 0x%x",
7113 i,
7114 caps_per_phy->tx_chain_mask_2G,
7115 caps_per_phy->rx_chain_mask_2G,
7116 caps_per_phy->ht_2g,
7117 caps_per_phy->vht_2g);
7118 }
7119 if ((band == CDS_BAND_5GHZ || band == CDS_BAND_ALL) &&
7120 (WLAN_5G_CAPABILITY & mac_phy_cap[i].supported_bands) &&
7121 !caps_per_phy->tx_chain_mask_5G) {
7122 caps_per_phy->ht_5g = mac_phy_cap[i].ht_cap_info_5G;
7123 caps_per_phy->vht_5g = mac_phy_cap[i].vht_cap_info_5G;
7124 qdf_mem_copy(caps_per_phy->he_5g,
7125 mac_phy_cap[i].he_cap_info_5G,
7126 sizeof(caps_per_phy->he_5g));
7127
7128 caps_per_phy->tx_chain_mask_5G =
7129 mac_phy_cap[i].tx_chain_mask_5G;
7130 caps_per_phy->rx_chain_mask_5G =
7131 mac_phy_cap[i].rx_chain_mask_5G;
7132
7133 wma_debug("Select 5G capable phyid[%d] chain %d %d ht 0x%x vht 0x%x",
7134 i,
7135 caps_per_phy->tx_chain_mask_5G,
7136 caps_per_phy->rx_chain_mask_5G,
7137 caps_per_phy->ht_5g,
7138 caps_per_phy->vht_5g);
7139 }
7140 }
7141
7142 return QDF_STATUS_SUCCESS;
7143 }
7144
7145 /**
7146 * wma_is_rx_ldpc_supported_for_channel() - to find out if ldpc is supported
7147 *
7148 * @ch_freq: Channel freq for which it needs to check if rx ldpc is enabled
7149 *
7150 * This API takes channel number as argument and takes default hw mode as DBS
7151 * to check if rx LDPC support is enabled for that channel or no
7152 */
wma_is_rx_ldpc_supported_for_channel(uint32_t ch_freq)7153 bool wma_is_rx_ldpc_supported_for_channel(uint32_t ch_freq)
7154 {
7155 t_wma_handle *wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
7156 struct target_psoc_info *tgt_hdl;
7157 struct wma_caps_per_phy caps_per_phy = {0};
7158 enum cds_band_type band;
7159 bool status;
7160 uint8_t num_hw_modes;
7161
7162 if (!wma_handle)
7163 return false;
7164
7165 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
7166 if (!tgt_hdl) {
7167 wma_err("Target handle is NULL");
7168 return QDF_STATUS_E_FAILURE;
7169 }
7170
7171 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
7172
7173 if (!WLAN_REG_IS_24GHZ_CH_FREQ(ch_freq))
7174 band = CDS_BAND_5GHZ;
7175 else
7176 band = CDS_BAND_2GHZ;
7177
7178 if (QDF_STATUS_SUCCESS != wma_get_caps_for_phyidx_hwmode(
7179 &caps_per_phy,
7180 HW_MODE_DBS, band)) {
7181 return false;
7182 }
7183
7184 /*
7185 * Legacy platforms like Rome set WMI_HT_CAP_LDPC to specify RX LDPC
7186 * capability. But new platforms like Helium set WMI_HT_CAP_RX_LDPC
7187 * instead.
7188 */
7189 if (0 == num_hw_modes) {
7190 status = (!!(caps_per_phy.ht_2g & WMI_HT_CAP_LDPC));
7191 } else {
7192 if (WLAN_REG_IS_24GHZ_CH_FREQ(ch_freq))
7193 status = (!!(caps_per_phy.ht_2g & WMI_HT_CAP_RX_LDPC));
7194 else
7195 status = (!!(caps_per_phy.ht_5g & WMI_HT_CAP_RX_LDPC));
7196 }
7197
7198 return status;
7199 }
7200
7201 /**
7202 * wma_print_mac_phy_capabilities() - Prints MAC PHY capabilities
7203 * @cap: pointer to WMI_MAC_PHY_CAPABILITIES
7204 * @index: MAC_PHY index
7205 *
7206 * Return: none
7207 */
wma_print_mac_phy_capabilities(struct wlan_psoc_host_mac_phy_caps * cap,int index)7208 static void wma_print_mac_phy_capabilities(struct wlan_psoc_host_mac_phy_caps
7209 *cap, int index)
7210 {
7211 uint32_t mac_2G[PSOC_HOST_MAX_MAC_SIZE];
7212 uint32_t mac_5G[PSOC_HOST_MAX_MAC_SIZE];
7213 uint32_t phy_2G[WMI_MAX_HECAP_PHY_SIZE];
7214 uint32_t phy_5G[WMI_MAX_HECAP_PHY_SIZE];
7215 struct wlan_psoc_host_ppe_threshold ppet_2G, ppet_5G;
7216
7217 wma_nofl_debug("\t: index [%d]", index);
7218 wma_nofl_debug("\t: cap for hw_mode_id[%d]", cap->hw_mode_id);
7219 wma_nofl_debug("\t: pdev_id[%d]", cap->pdev_id);
7220 wma_nofl_debug("\t: phy_id[%d]", cap->phy_id);
7221 wma_nofl_debug("\t: hw_mode_config_type[%d]", cap->hw_mode_config_type);
7222 wma_nofl_debug("\t: supports_11b[%d]", cap->supports_11b);
7223 wma_nofl_debug("\t: supports_11g[%d]", cap->supports_11g);
7224 wma_nofl_debug("\t: supports_11a[%d]", cap->supports_11a);
7225 wma_nofl_debug("\t: supports_11n[%d]", cap->supports_11n);
7226 wma_nofl_debug("\t: supports_11ac[%d]", cap->supports_11ac);
7227 wma_nofl_debug("\t: supports_11ax[%d]", cap->supports_11ax);
7228 wma_nofl_debug("\t: supported_bands[%d]", cap->supported_bands);
7229 wma_nofl_debug("\t: ampdu_density[%d]", cap->ampdu_density);
7230 wma_nofl_debug("\t: max_bw_supported_2G[%d]", cap->max_bw_supported_2G);
7231 wma_nofl_debug("\t: ht_cap_info_2G[%d]", cap->ht_cap_info_2G);
7232 wma_nofl_debug("\t: vht_cap_info_2G[0x%0X]", cap->vht_cap_info_2G);
7233 wma_nofl_debug("\t: vht_supp_mcs_2G[0x%0X]", cap->vht_supp_mcs_2G);
7234 wma_nofl_debug("\t: tx_chain_mask_2G[%d]", cap->tx_chain_mask_2G);
7235 wma_nofl_debug("\t: rx_chain_mask_2G[%d]", cap->rx_chain_mask_2G);
7236 wma_nofl_debug("\t: max_bw_supported_5G[%d]", cap->max_bw_supported_5G);
7237 wma_nofl_debug("\t: ht_cap_info_5G[%d]", cap->ht_cap_info_5G);
7238 wma_nofl_debug("\t: vht_cap_info_5G[0x%0X]", cap->vht_cap_info_5G);
7239 wma_nofl_debug("\t: vht_supp_mcs_5G[0x%0X]", cap->vht_supp_mcs_5G);
7240 wma_nofl_debug("\t: tx_chain_mask_5G[%d]", cap->tx_chain_mask_5G);
7241 wma_nofl_debug("\t: rx_chain_mask_5G[%d]", cap->rx_chain_mask_5G);
7242 wma_nofl_debug("\t: he_cap_info_2G[0][%08x]", cap->he_cap_info_2G[0]);
7243 wma_nofl_debug("\t: he_cap_info_2G[1][%08x]", cap->he_cap_info_2G[1]);
7244 wma_nofl_debug("\t: he_supp_mcs_2G[%08x]", cap->he_supp_mcs_2G);
7245 wma_nofl_debug("\t: he_cap_info_5G[0][%08x]", cap->he_cap_info_5G[0]);
7246 wma_nofl_debug("\t: he_cap_info_5G[1][%08x]", cap->he_cap_info_5G[1]);
7247 wma_nofl_debug("\t: he_supp_mcs_5G[%08x]", cap->he_supp_mcs_5G);
7248 qdf_mem_copy(mac_2G, cap->he_cap_info_2G, sizeof(mac_2G));
7249 qdf_mem_copy(mac_5G, cap->he_cap_info_5G, sizeof(mac_5G));
7250 qdf_mem_copy(phy_2G, cap->he_cap_phy_info_2G,
7251 WMI_MAX_HECAP_PHY_SIZE * 4);
7252 qdf_mem_copy(phy_5G, cap->he_cap_phy_info_5G,
7253 WMI_MAX_HECAP_PHY_SIZE * 4);
7254 ppet_2G = cap->he_ppet2G;
7255 ppet_5G = cap->he_ppet5G;
7256
7257 wma_print_he_mac_cap_w1(mac_2G[0]);
7258 wma_print_he_mac_cap_w2(mac_2G[1]);
7259 wma_print_he_phy_cap(phy_2G);
7260 wma_print_he_ppet(&ppet_2G);
7261 wma_print_he_mac_cap_w1(mac_5G[0]);
7262 wma_print_he_mac_cap_w1(mac_5G[1]);
7263 wma_print_he_phy_cap(phy_5G);
7264 wma_print_he_ppet(&ppet_5G);
7265 }
7266
7267 /**
7268 * wma_print_populate_soc_caps() - Prints all the caps populated per hw mode
7269 * @tgt_hdl: target related info
7270 *
7271 * This function prints all the caps populater per hw mode and per PHY
7272 *
7273 * Return: none
7274 */
wma_print_populate_soc_caps(struct target_psoc_info * tgt_hdl)7275 static void wma_print_populate_soc_caps(struct target_psoc_info *tgt_hdl)
7276 {
7277 int i, num_hw_modes, total_mac_phy_cnt;
7278 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap, *tmp;
7279
7280 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
7281 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
7282
7283 /* print number of hw modes */
7284 wma_debug("num of hw modes [%d]", num_hw_modes);
7285 wma_debug("num mac_phy_cnt [%d]", total_mac_phy_cnt);
7286
7287 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
7288 if (!mac_phy_cap) {
7289 wma_err("Invalid MAC PHY capabilities handle");
7290 return;
7291 }
7292
7293 wma_debug("<====== HW mode cap printing starts ======>");
7294 /* print cap of each hw mode */
7295 for (i = 0; i < total_mac_phy_cnt; i++) {
7296 if (&mac_phy_cap[i]) {
7297 wma_nofl_debug("====>: hw mode id[%d], phy id[%d]",
7298 mac_phy_cap[i].hw_mode_id,
7299 mac_phy_cap[i].phy_id);
7300 tmp = &mac_phy_cap[i];
7301 wma_print_mac_phy_capabilities(tmp, i);
7302 }
7303 }
7304 wma_debug("<====== HW mode cap printing ends ======>\n");
7305 }
7306
7307 /**
7308 * wma_update_hw_mode_list() - updates hw_mode_list
7309 * @wma_handle: pointer to wma global structure
7310 * @tgt_hdl: target psoc information
7311 *
7312 * This function updates hw_mode_list with tx_streams, rx_streams,
7313 * bandwidth, dbs and agile dfs for each hw_mode.
7314 *
7315 * Returns: 0 for success else failure.
7316 */
wma_update_hw_mode_list(t_wma_handle * wma_handle,struct target_psoc_info * tgt_hdl)7317 static QDF_STATUS wma_update_hw_mode_list(t_wma_handle *wma_handle,
7318 struct target_psoc_info *tgt_hdl)
7319 {
7320 struct wlan_psoc_host_mac_phy_caps *tmp, *mac_phy_cap;
7321 uint32_t i, hw_config_type, j = 0;
7322 WMI_PHY_CAPABILITY new_supported_band = 0;
7323 bool supported_band_update_failure = false;
7324 struct wlan_psoc_target_capability_info *tgt_cap_info;
7325 int num_hw_modes;
7326
7327 if (wma_validate_handle(wma_handle))
7328 return QDF_STATUS_E_FAILURE;
7329
7330 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
7331 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
7332 tgt_cap_info = target_psoc_get_target_caps(tgt_hdl);
7333
7334 if (!mac_phy_cap) {
7335 wma_err("mac_phy_cap Null");
7336 return QDF_STATUS_E_FAILURE;
7337 }
7338
7339 wma_debug("Num modes:%d", num_hw_modes);
7340 for (i = 0; i < num_hw_modes; i++) {
7341 /* Update for MAC0 */
7342 tmp = &mac_phy_cap[j++];
7343 hw_config_type = tmp->hw_mode_config_type;
7344 if (wma_update_supported_bands(tmp->supported_bands,
7345 &new_supported_band)
7346 != QDF_STATUS_SUCCESS)
7347 supported_band_update_failure = true;
7348
7349 /* SBS and DBS have dual MAC. Upto 2 MACs are considered. */
7350 if ((hw_config_type == WMI_HW_MODE_DBS) ||
7351 (hw_config_type == WMI_HW_MODE_SBS_PASSIVE) ||
7352 (hw_config_type == WMI_HW_MODE_SBS) ||
7353 (hw_config_type == WMI_HW_MODE_DBS_OR_SBS)) {
7354 /* Update for MAC1 */
7355 tmp = &mac_phy_cap[j++];
7356 if (QDF_STATUS_SUCCESS !=
7357 wma_update_supported_bands(tmp->supported_bands,
7358 &new_supported_band))
7359 supported_band_update_failure = true;
7360 }
7361 }
7362
7363 /* overwrite phy_capability which we got from service ready event */
7364 if (!supported_band_update_failure) {
7365 wma_debug("updating supported band from old[%d] to new[%d]",
7366 target_if_get_phy_capability(tgt_hdl),
7367 new_supported_band);
7368 target_if_set_phy_capability(tgt_hdl, new_supported_band);
7369 }
7370
7371 if (QDF_STATUS_SUCCESS !=
7372 policy_mgr_update_hw_mode_list(wma_handle->psoc,
7373 tgt_hdl))
7374 wma_err("failed to update policy manager");
7375
7376 return QDF_STATUS_SUCCESS;
7377 }
7378
wma_init_wifi_pos_dma_rings(t_wma_handle * wma_handle,uint8_t num_mac,void * buf)7379 static void wma_init_wifi_pos_dma_rings(t_wma_handle *wma_handle,
7380 uint8_t num_mac, void *buf)
7381 {
7382 struct hif_opaque_softc *hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
7383 void *hal_soc;
7384
7385 if (!hif_ctx) {
7386 wma_err("invalid hif context");
7387 return;
7388 }
7389
7390 hal_soc = hif_get_hal_handle(hif_ctx);
7391
7392 wifi_pos_init_cir_cfr_rings(wma_handle->psoc, hal_soc, num_mac, buf);
7393 }
7394
7395 /**
7396 * wma_populate_soc_caps() - populate entire SOC's capabilities
7397 * @wma_handle: pointer to wma global structure
7398 * @tgt_hdl: target psoc information
7399 * @param_buf: pointer to param of service ready extension event from fw
7400 *
7401 * This API populates all capabilities of entire SOC. For example,
7402 * how many number of hw modes are supported by this SOC, what are the
7403 * capabilities of each phy per hw mode, what are HAL reg capabilities per
7404 * phy.
7405 *
7406 * Return: none
7407 */
wma_populate_soc_caps(t_wma_handle * wma_handle,struct target_psoc_info * tgt_hdl,WMI_SERVICE_READY_EXT_EVENTID_param_tlvs * param_buf)7408 static void wma_populate_soc_caps(t_wma_handle *wma_handle,
7409 struct target_psoc_info *tgt_hdl,
7410 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf)
7411 {
7412
7413 wma_debug("Enter");
7414
7415 wma_init_wifi_pos_dma_rings(wma_handle,
7416 param_buf->num_oem_dma_ring_caps,
7417 param_buf->oem_dma_ring_caps);
7418
7419 wma_print_populate_soc_caps(tgt_hdl);
7420 wma_debug("Exit");
7421 }
7422
7423 /**
7424 * wma_init_dbr_params() - init dbr params
7425 * @wma_handle: pointer to wma global structure
7426 *
7427 * This API initializes params of direct buffer rx component.
7428 *
7429 * Return: none
7430 */
7431 #ifdef DIRECT_BUF_RX_ENABLE
wma_init_dbr_params(t_wma_handle * wma_handle)7432 static void wma_init_dbr_params(t_wma_handle *wma_handle)
7433 {
7434 struct hif_opaque_softc *hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
7435 void *hal_soc;
7436
7437 if (!hif_ctx) {
7438 wma_err("invalid hif context");
7439 return;
7440 }
7441
7442 hal_soc = hif_get_hal_handle(hif_ctx);
7443 direct_buf_rx_target_attach(wma_handle->psoc, hal_soc,
7444 wma_handle->qdf_dev);
7445 }
7446 #else
wma_init_dbr_params(t_wma_handle * wma_handle)7447 static inline void wma_init_dbr_params(t_wma_handle *wma_handle)
7448 {
7449 }
7450 #endif
7451
7452 /**
7453 * wma_set_coex_res_cfg() - Set target COEX resource configuration.
7454 * @wma_handle: pointer to wma global structure
7455 * @wmi_handle: pointer to wmi handle
7456 * @wlan_res_cfg: Pointer to target resource configuration
7457 *
7458 * Return: none
7459 */
7460 #ifdef FEATURE_COEX_CONFIG
wma_set_coex_res_cfg(t_wma_handle * wma_handle,struct wmi_unified * wmi_handle,target_resource_config * wlan_res_cfg)7461 static void wma_set_coex_res_cfg(t_wma_handle *wma_handle,
7462 struct wmi_unified *wmi_handle,
7463 target_resource_config *wlan_res_cfg)
7464 {
7465 if (cfg_get(wma_handle->psoc, CFG_THREE_WAY_COEX_CONFIG_LEGACY) &&
7466 wmi_service_enabled(wmi_handle,
7467 wmi_service_three_way_coex_config_legacy)) {
7468 wlan_res_cfg->three_way_coex_config_legacy_en = true;
7469 } else {
7470 wlan_res_cfg->three_way_coex_config_legacy_en = false;
7471 }
7472 }
7473 #else
wma_set_coex_res_cfg(t_wma_handle * wma_handle,struct wmi_unified * wmi_handle,target_resource_config * wlan_res_cfg)7474 static void wma_set_coex_res_cfg(t_wma_handle *wma_handle,
7475 struct wmi_unified *wmi_handle,
7476 target_resource_config *wlan_res_cfg)
7477 {
7478 }
7479 #endif
7480
wma_update_hw_mode_config(tp_wma_handle wma_handle,struct target_psoc_info * tgt_hdl)7481 static void wma_update_hw_mode_config(tp_wma_handle wma_handle,
7482 struct target_psoc_info *tgt_hdl)
7483 {
7484 uint32_t conc_scan_config_bits, fw_config_bits;
7485
7486 fw_config_bits = target_if_get_fw_config_bits(tgt_hdl);
7487 conc_scan_config_bits = target_if_get_conc_scan_config_bits(tgt_hdl);
7488
7489 wma_debug("Defaults: scan config:%x FW mode config:%x",
7490 conc_scan_config_bits, fw_config_bits);
7491
7492 if (wma_is_dbs_mandatory(wma_handle->psoc, tgt_hdl) &&
7493 (policy_mgr_is_dual_mac_disabled_in_ini(wma_handle->psoc))) {
7494 policy_mgr_set_dual_mac_feature(wma_handle->psoc,
7495 ENABLE_DBS_CXN_AND_DISABLE_SIMULTANEOUS_SCAN);
7496 policy_mgr_set_ch_select_plcy(wma_handle->psoc,
7497 POLICY_MGR_CH_SELECT_POLICY_DEF);
7498 }
7499 wma_init_scan_fw_mode_config(wma_handle->psoc, conc_scan_config_bits,
7500 fw_config_bits);
7501 }
7502
7503 #define MAX_GRP_KEY 16
7504
wma_rx_service_ready_ext2_event(void * handle,uint8_t * ev,uint32_t len)7505 int wma_rx_service_ready_ext2_event(void *handle, uint8_t *ev, uint32_t len)
7506 {
7507 tp_wma_handle wma_handle = (tp_wma_handle)handle;
7508 struct target_psoc_info *tgt_hdl;
7509 target_resource_config *wlan_res_cfg;
7510 QDF_STATUS status;
7511
7512 wma_debug("Enter");
7513
7514 if (wma_validate_handle(wma_handle))
7515 return -EINVAL;
7516
7517 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
7518 if (!tgt_hdl) {
7519 wma_err("target psoc info is NULL");
7520 return -EINVAL;
7521 }
7522
7523 wlan_res_cfg = target_psoc_get_wlan_res_cfg(tgt_hdl);
7524
7525 if (wlan_mlme_is_multipass_sap(wma_handle->psoc))
7526 wlan_res_cfg->max_num_group_keys = MAX_GRP_KEY;
7527
7528 status = policy_mgr_update_sbs_freq(wma_handle->psoc, tgt_hdl);
7529 if (QDF_IS_STATUS_ERROR(status))
7530 return -EINVAL;
7531
7532 wma_update_hw_mode_config(wma_handle, tgt_hdl);
7533
7534 return 0;
7535 }
7536
7537 /**
7538 * wma_rx_service_ready_ext_event() - evt handler for service ready ext event.
7539 * @handle: wma handle
7540 * @event: params of the service ready extended event
7541 * @length: param length
7542 *
7543 * Return: none
7544 */
wma_rx_service_ready_ext_event(void * handle,uint8_t * event,uint32_t length)7545 int wma_rx_service_ready_ext_event(void *handle, uint8_t *event,
7546 uint32_t length)
7547 {
7548 tp_wma_handle wma_handle = (tp_wma_handle) handle;
7549 WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *param_buf;
7550 wmi_service_ready_ext_event_fixed_param *ev;
7551 QDF_STATUS ret;
7552 struct target_psoc_info *tgt_hdl;
7553 struct wlan_psoc_target_capability_info *tgt_cap_info;
7554 struct wmi_unified *wmi_handle;
7555 void *soc = cds_get_context(QDF_MODULE_ID_SOC);
7556 target_resource_config *wlan_res_cfg;
7557
7558 wma_debug("Enter");
7559
7560 if (wma_validate_handle(wma_handle))
7561 return -EINVAL;
7562
7563 wmi_handle = get_wmi_unified_hdl_from_psoc(wma_handle->psoc);
7564 if (wmi_validate_handle(wmi_handle))
7565 return -EINVAL;
7566
7567 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
7568 if (!tgt_hdl) {
7569 wma_err("target psoc info is NULL");
7570 return -EINVAL;
7571 }
7572
7573 wlan_res_cfg = target_psoc_get_wlan_res_cfg(tgt_hdl);
7574 param_buf = (WMI_SERVICE_READY_EXT_EVENTID_param_tlvs *) event;
7575 if (!param_buf) {
7576 wma_err("Invalid event");
7577 return -EINVAL;
7578 }
7579
7580 ev = param_buf->fixed_param;
7581 if (!ev) {
7582 wma_err("Invalid buffer");
7583 return -EINVAL;
7584 }
7585
7586 wma_debug("WMA <-- WMI_SERVICE_READY_EXT_EVENTID");
7587
7588 tgt_cap_info = target_psoc_get_target_caps(tgt_hdl);
7589 ret = qdf_mc_timer_stop(&wma_handle->service_ready_ext_timer);
7590 if (!QDF_IS_STATUS_SUCCESS(ret)) {
7591 wma_err("Failed to stop the service ready ext timer");
7592 return -EINVAL;
7593 }
7594 wma_populate_soc_caps(wma_handle, tgt_hdl, param_buf);
7595
7596 ret = wma_update_hw_mode_list(wma_handle, tgt_hdl);
7597 if (QDF_IS_STATUS_ERROR(ret)) {
7598 wma_err("Failed to update hw mode list");
7599 return -EINVAL;
7600 }
7601
7602 wma_debug("WMA --> WMI_INIT_CMDID");
7603
7604 wma_update_hw_mode_config(wma_handle, tgt_hdl);
7605
7606 target_psoc_set_num_radios(tgt_hdl, 1);
7607
7608 wlan_dp_update_peer_map_unmap_version(&wlan_res_cfg->peer_map_unmap_version);
7609
7610 if (wmi_service_enabled(wmi_handle,
7611 wmi_service_new_htt_msg_format)) {
7612 cdp_cfg_set_new_htt_msg_format(soc, 1);
7613 wlan_res_cfg->new_htt_msg_format = true;
7614 } else {
7615 cdp_cfg_set_new_htt_msg_format(soc, 0);
7616 wlan_res_cfg->new_htt_msg_format = false;
7617 }
7618
7619 if (QDF_GLOBAL_FTM_MODE != cds_get_conparam() &&
7620 ucfg_mlme_get_peer_unmap_conf(wma_handle->psoc) &&
7621 wmi_service_enabled(wmi_handle,
7622 wmi_service_peer_unmap_cnf_support)) {
7623 wlan_res_cfg->peer_unmap_conf_support = true;
7624 cdp_cfg_set_peer_unmap_conf_support(soc, true);
7625 } else {
7626 wlan_res_cfg->peer_unmap_conf_support = false;
7627 cdp_cfg_set_peer_unmap_conf_support(soc, false);
7628 }
7629
7630 if (wma_handle->enable_tx_compl_tsf64 &&
7631 wmi_service_enabled(wmi_handle,
7632 wmi_service_tx_compl_tsf64)) {
7633 wlan_res_cfg->tstamp64_en = true;
7634 cdp_cfg_set_tx_compl_tsf64(soc, true);
7635 } else {
7636 wlan_res_cfg->tstamp64_en = false;
7637 cdp_cfg_set_tx_compl_tsf64(soc, false);
7638 }
7639
7640 if (ucfg_is_ftm_time_sync_enable(wma_handle->psoc) &&
7641 wmi_service_enabled(wmi_handle, wmi_service_time_sync_ftm)) {
7642 wlan_res_cfg->time_sync_ftm = true;
7643 ucfg_ftm_time_sync_set_enable(wma_handle->psoc, true);
7644 } else {
7645 wlan_res_cfg->time_sync_ftm = false;
7646 ucfg_ftm_time_sync_set_enable(wma_handle->psoc, false);
7647 }
7648
7649 if (wmi_service_enabled(wma_handle->wmi_handle, wmi_service_nan_vdev))
7650 ucfg_nan_set_vdev_creation_supp_by_fw(wma_handle->psoc, true);
7651
7652 /* Change default hw mode as below kind of target will only be
7653 * sending single HW mode
7654 */
7655 if (!wmi_service_enabled(wmi_handle,
7656 wmi_service_dual_band_simultaneous_support))
7657 wma_handle->new_hw_mode_index =
7658 tgt_cap_info->default_dbs_hw_mode_index;
7659
7660 /*
7661 * Firmware can accommodate maximum 4 vdevs and the ini gNumVdevs
7662 * indicates the same.
7663 * If host driver is going to create vdev for NAN, it indicates
7664 * the total no.of vdevs supported to firmware which includes the
7665 * NAN vdev.
7666 * If firmware is going to create NAN discovery vdev, host should
7667 * indicate 3 vdevs and firmware shall add 1 vdev for NAN. So decrement
7668 * the num_vdevs by 1.
7669 * If NAN is not supported on some target(disabled through ini
7670 * param gEnableNanSupport), there is no use of reserving one vdev for
7671 * it in firmware though firmware advertises wmi_service_nan. Indicate
7672 * firmware that host is going to take care of the NAN vdev. Host can
7673 * use the vdev either for NAN or other operations on need basis.
7674 */
7675
7676 if (wmi_service_enabled(wma_handle->wmi_handle, wmi_service_nan)) {
7677 if (ucfg_nan_is_vdev_creation_allowed(wma_handle->psoc) ||
7678 QDF_GLOBAL_FTM_MODE == cds_get_conparam() ||
7679 !cfg_nan_get_enable(wma_handle->psoc)) {
7680 wlan_res_cfg->nan_separate_iface_support = true;
7681 } else {
7682 wlan_res_cfg->num_vdevs--;
7683 wma_update_num_peers_tids(wma_handle, wlan_res_cfg);
7684 }
7685 }
7686
7687 if ((ucfg_pkt_capture_get_mode(wma_handle->psoc) !=
7688 PACKET_CAPTURE_MODE_DISABLE) &&
7689 wmi_service_enabled(wmi_handle,
7690 wmi_service_packet_capture_support))
7691 wlan_res_cfg->pktcapture_support = true;
7692 else
7693 wlan_res_cfg->pktcapture_support = false;
7694 wlan_res_cfg->max_peer_ext_stats = WMA_SON_MAX_PEER_EXT_STATS;
7695
7696 if (wmi_service_enabled(wmi_handle,
7697 wmi_service_sae_eapol_offload_support))
7698 wlan_res_cfg->sae_eapol_offload = true;
7699 else
7700 wlan_res_cfg->sae_eapol_offload = false;
7701
7702 wma_debug("num_vdevs: %u", wlan_res_cfg->num_vdevs);
7703
7704 wma_init_dbr_params(wma_handle);
7705
7706 wma_set_coex_res_cfg(wma_handle, wmi_handle, wlan_res_cfg);
7707
7708 return 0;
7709 }
7710
7711 /**
7712 * wma_rx_ready_event() - event handler to process
7713 * wmi rx ready event.
7714 * @handle: wma handle
7715 * @cmd_param_info: command params info
7716 * @length: param length
7717 *
7718 * Return: none
7719 */
wma_rx_ready_event(void * handle,uint8_t * cmd_param_info,uint32_t length)7720 int wma_rx_ready_event(void *handle, uint8_t *cmd_param_info,
7721 uint32_t length)
7722 {
7723 tp_wma_handle wma_handle = (tp_wma_handle) handle;
7724 WMI_READY_EVENTID_param_tlvs *param_buf = NULL;
7725 wmi_ready_event_fixed_param *ev = NULL;
7726 int ret;
7727
7728 wma_debug("Enter");
7729
7730 param_buf = (WMI_READY_EVENTID_param_tlvs *) cmd_param_info;
7731 if (!(wma_handle && param_buf)) {
7732 wma_err("Invalid arguments");
7733 QDF_ASSERT(0);
7734 return -EINVAL;
7735 }
7736
7737 wma_debug("WMA <-- WMI_READY_EVENTID");
7738
7739 if (wma_is_feature_set_supported(wma_handle))
7740 wma_send_feature_set_cmd(wma_handle);
7741
7742 ev = param_buf->fixed_param;
7743 /* Indicate to the waiting thread that the ready
7744 * event was received
7745 */
7746 wma_handle->sub_20_support =
7747 wmi_service_enabled(wma_handle->wmi_handle,
7748 wmi_service_half_rate_quarter_rate_support);
7749 wma_handle->wmi_ready = true;
7750 wma_handle->wlan_init_status = ev->status;
7751
7752 if (wma_handle->is_dfs_offloaded)
7753 wmi_unified_dfs_phyerr_offload_en_cmd(
7754 wma_handle->wmi_handle, 0);
7755 /* copy the mac addr */
7756 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->mac_addr, wma_handle->myaddr);
7757 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->mac_addr, wma_handle->hwaddr);
7758 ret = wma_update_hdd_cfg(wma_handle);
7759 if (ret)
7760 return ret;
7761
7762 wma_debug("Exit");
7763
7764 return 0;
7765 }
7766
7767 /**
7768 * wma_wait_for_ready_event() - wait for wma ready event
7769 * @handle: wma handle
7770 *
7771 * Return: 0 for success or QDF error
7772 */
wma_wait_for_ready_event(WMA_HANDLE handle)7773 QDF_STATUS wma_wait_for_ready_event(WMA_HANDLE handle)
7774 {
7775 tp_wma_handle wma_handle = (tp_wma_handle)handle;
7776 QDF_STATUS status;
7777 struct target_psoc_info *tgt_hdl;
7778
7779 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
7780 if (!tgt_hdl) {
7781 wma_err("target psoc info is NULL");
7782 return QDF_STATUS_E_INVAL;
7783 }
7784
7785 status = qdf_wait_for_event_completion(&tgt_hdl->info.event,
7786 WMA_READY_EVENTID_TIMEOUT);
7787 if (!tgt_hdl->info.wmi_ready) {
7788 wma_err("Error in pdev creation");
7789 if (!cds_is_driver_recovering() || !cds_is_fw_down())
7790 QDF_DEBUG_PANIC("FW ready event timed out");
7791 return QDF_STATUS_E_INVAL;
7792 }
7793
7794 if (status == QDF_STATUS_E_TIMEOUT)
7795 wma_err("Timeout waiting for FW ready event");
7796 else if (QDF_IS_STATUS_ERROR(status))
7797 wma_err("Failed to wait for FW ready event; status:%u", status);
7798 else
7799 wma_info("FW ready event received");
7800
7801 return status;
7802 }
7803
7804 /**
7805 * wma_set_ppsconfig() - set pps config in fw
7806 * @vdev_id: vdev id
7807 * @pps_param: pps params
7808 * @val : param value
7809 *
7810 * Return: 0 for success or QDF error
7811 */
wma_set_ppsconfig(uint8_t vdev_id,uint16_t pps_param,int val)7812 QDF_STATUS wma_set_ppsconfig(uint8_t vdev_id, uint16_t pps_param,
7813 int val)
7814 {
7815 tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
7816 int ret = -EIO;
7817 uint32_t pps_val;
7818
7819 if (!wma)
7820 return QDF_STATUS_E_INVAL;
7821
7822 switch (pps_param) {
7823 case WMA_VHT_PPS_PAID_MATCH:
7824 pps_val = ((val << 31) & 0xffff0000) |
7825 (PKT_PWR_SAVE_PAID_MATCH & 0xffff);
7826 goto pkt_pwr_save_config;
7827 case WMA_VHT_PPS_GID_MATCH:
7828 pps_val = ((val << 31) & 0xffff0000) |
7829 (PKT_PWR_SAVE_GID_MATCH & 0xffff);
7830 goto pkt_pwr_save_config;
7831 case WMA_VHT_PPS_DELIM_CRC_FAIL:
7832 pps_val = ((val << 31) & 0xffff0000) |
7833 (PKT_PWR_SAVE_DELIM_CRC_FAIL & 0xffff);
7834 goto pkt_pwr_save_config;
7835
7836 /* Enable the code below as and when the functionality
7837 * is supported/added in host.
7838 */
7839 #ifdef NOT_YET
7840 case WMA_VHT_PPS_EARLY_TIM_CLEAR:
7841 pps_val = ((val << 31) & 0xffff0000) |
7842 (PKT_PWR_SAVE_EARLY_TIM_CLEAR & 0xffff);
7843 goto pkt_pwr_save_config;
7844 case WMA_VHT_PPS_EARLY_DTIM_CLEAR:
7845 pps_val = ((val << 31) & 0xffff0000) |
7846 (PKT_PWR_SAVE_EARLY_DTIM_CLEAR & 0xffff);
7847 goto pkt_pwr_save_config;
7848 case WMA_VHT_PPS_EOF_PAD_DELIM:
7849 pps_val = ((val << 31) & 0xffff0000) |
7850 (PKT_PWR_SAVE_EOF_PAD_DELIM & 0xffff);
7851 goto pkt_pwr_save_config;
7852 case WMA_VHT_PPS_MACADDR_MISMATCH:
7853 pps_val = ((val << 31) & 0xffff0000) |
7854 (PKT_PWR_SAVE_MACADDR_MISMATCH & 0xffff);
7855 goto pkt_pwr_save_config;
7856 case WMA_VHT_PPS_GID_NSTS_ZERO:
7857 pps_val = ((val << 31) & 0xffff0000) |
7858 (PKT_PWR_SAVE_GID_NSTS_ZERO & 0xffff);
7859 goto pkt_pwr_save_config;
7860 case WMA_VHT_PPS_RSSI_CHECK:
7861 pps_val = ((val << 31) & 0xffff0000) |
7862 (PKT_PWR_SAVE_RSSI_CHECK & 0xffff);
7863 goto pkt_pwr_save_config;
7864 #endif /* NOT_YET */
7865 pkt_pwr_save_config:
7866 wma_debug("vdev_id:%d val:0x%x pps_val:0x%x", vdev_id,
7867 val, pps_val);
7868 ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
7869 wmi_vdev_param_packet_powersave,
7870 pps_val);
7871 break;
7872 default:
7873 wma_err("INVALID PPS CONFIG");
7874 }
7875
7876 return (ret) ? QDF_STATUS_E_FAILURE : QDF_STATUS_SUCCESS;
7877 }
7878
7879 /**
7880 * wma_process_set_mas() - Function to enable/disable MAS
7881 * @wma: Pointer to WMA handle
7882 * @mas_val: 1-Enable MAS, 0-Disable MAS
7883 *
7884 * This function enables/disables the MAS value
7885 *
7886 * Return: QDF_SUCCESS for success otherwise failure
7887 */
wma_process_set_mas(tp_wma_handle wma,uint32_t * mas_val)7888 static QDF_STATUS wma_process_set_mas(tp_wma_handle wma,
7889 uint32_t *mas_val)
7890 {
7891 uint32_t val;
7892
7893 if (!wma || !mas_val) {
7894 wma_err("Invalid input to enable/disable MAS");
7895 return QDF_STATUS_E_FAILURE;
7896 }
7897
7898 val = (*mas_val);
7899
7900 if (QDF_STATUS_SUCCESS !=
7901 wma_set_enable_disable_mcc_adaptive_scheduler(val)) {
7902 wma_err("Unable to enable/disable MAS");
7903 return QDF_STATUS_E_FAILURE;
7904 }
7905 wma_debug("Value is %d", val);
7906 return QDF_STATUS_SUCCESS;
7907 }
7908
7909 /**
7910 * wma_process_set_miracast() - Function to set miracast value in WMA
7911 * @wma: Pointer to WMA handle
7912 * @miracast_val: 0-Disabled,1-Source,2-Sink
7913 *
7914 * This function stores the miracast value in WMA
7915 *
7916 * Return: QDF_SUCCESS for success otherwise failure
7917 *
7918 */
wma_process_set_miracast(tp_wma_handle wma,uint32_t * miracast_val)7919 static QDF_STATUS wma_process_set_miracast(tp_wma_handle wma,
7920 uint32_t *miracast_val)
7921 {
7922 if (!wma || !miracast_val) {
7923 wma_err("Invalid input to store miracast value");
7924 return QDF_STATUS_E_FAILURE;
7925 }
7926
7927 wma->miracast_value = *miracast_val;
7928 wma_debug("Miracast value is %d", wma->miracast_value);
7929
7930 return QDF_STATUS_SUCCESS;
7931 }
7932
7933 /**
7934 * wma_config_stats_factor() - Function to configure stats avg. factor
7935 * @wma: pointer to WMA handle
7936 * @avg_factor: stats. avg. factor passed down by userspace
7937 *
7938 * This function configures the avg. stats value in firmware
7939 *
7940 * Return: QDF_STATUS_SUCCESS for success otherwise failure
7941 *
7942 */
wma_config_stats_factor(tp_wma_handle wma,struct sir_stats_avg_factor * avg_factor)7943 static QDF_STATUS wma_config_stats_factor(tp_wma_handle wma,
7944 struct sir_stats_avg_factor *avg_factor)
7945 {
7946 QDF_STATUS ret;
7947
7948 if (!wma || !avg_factor) {
7949 wma_err("Invalid input of stats avg factor");
7950 return QDF_STATUS_E_FAILURE;
7951 }
7952
7953 ret = wma_vdev_set_param(wma->wmi_handle,
7954 avg_factor->vdev_id,
7955 wmi_vdev_param_stats_avg_factor,
7956 avg_factor->stats_avg_factor);
7957 if (QDF_IS_STATUS_ERROR(ret)) {
7958 wma_err("failed to set avg_factor for vdev_id %d",
7959 avg_factor->vdev_id);
7960 }
7961
7962 wma_debug("Set stats_avg_factor %d for vdev_id %d",
7963 avg_factor->stats_avg_factor, avg_factor->vdev_id);
7964
7965 return ret;
7966 }
7967
7968 /**
7969 * wma_config_guard_time() - Function to set guard time in firmware
7970 * @wma: pointer to WMA handle
7971 * @guard_time: guard time passed down by userspace
7972 *
7973 * This function configures the guard time in firmware
7974 *
7975 * Return: QDF_STATUS_SUCCESS for success otherwise failure
7976 *
7977 */
wma_config_guard_time(tp_wma_handle wma,struct sir_guard_time_request * guard_time)7978 static QDF_STATUS wma_config_guard_time(tp_wma_handle wma,
7979 struct sir_guard_time_request *guard_time)
7980 {
7981 QDF_STATUS ret;
7982
7983 if (!wma || !guard_time) {
7984 wma_err("Invalid input of guard time");
7985 return QDF_STATUS_E_FAILURE;
7986 }
7987
7988 ret = wma_vdev_set_param(wma->wmi_handle,
7989 guard_time->vdev_id,
7990 wmi_vdev_param_rx_leak_window,
7991 guard_time->guard_time);
7992 if (QDF_IS_STATUS_ERROR(ret)) {
7993 wma_err("failed to set guard time for vdev_id %d",
7994 guard_time->vdev_id);
7995 }
7996
7997 wma_debug("Set guard time %d for vdev_id %d",
7998 guard_time->guard_time, guard_time->vdev_id);
7999
8000 return ret;
8001 }
8002
8003 /**
8004 * wma_enable_specific_fw_logs() - Start/Stop logging of diag event/log id
8005 * @wma_handle: WMA handle
8006 * @start_log: Start logging related parameters
8007 *
8008 * Send the command to the FW based on which specific logging of diag
8009 * event/log id can be started/stopped
8010 *
8011 * Return: None
8012 */
wma_enable_specific_fw_logs(tp_wma_handle wma_handle,struct sir_wifi_start_log * start_log)8013 static void wma_enable_specific_fw_logs(tp_wma_handle wma_handle,
8014 struct sir_wifi_start_log *start_log)
8015 {
8016
8017 if (!start_log) {
8018 wma_err("start_log pointer is NULL");
8019 return;
8020 }
8021 if (wma_validate_handle(wma_handle))
8022 return;
8023
8024 if (!((start_log->ring_id == RING_ID_CONNECTIVITY) ||
8025 (start_log->ring_id == RING_ID_FIRMWARE_DEBUG))) {
8026 wma_debug("Not connectivity or fw debug ring: %d",
8027 start_log->ring_id);
8028 return;
8029 }
8030
8031 wmi_unified_enable_specific_fw_logs_cmd(wma_handle->wmi_handle,
8032 (struct wmi_wifi_start_log *)start_log);
8033 }
8034
8035 #define MEGABYTE (1024 * 1024)
8036 /**
8037 * wma_set_wifi_start_packet_stats() - Start/stop packet stats
8038 * @wma_handle: WMA handle
8039 * @start_log: Structure containing the start wifi logger params
8040 *
8041 * This function is used to send the WMA commands to start/stop logging
8042 * of per packet statistics
8043 *
8044 * Return: None
8045 *
8046 */
8047 #if !defined(FEATURE_PKTLOG) || defined(REMOVE_PKT_LOG)
wma_set_wifi_start_packet_stats(void * wma_handle,struct sir_wifi_start_log * start_log)8048 static void wma_set_wifi_start_packet_stats(void *wma_handle,
8049 struct sir_wifi_start_log *start_log)
8050 {
8051 }
8052
8053 #else
wma_set_wifi_start_packet_stats(void * wma_handle,struct sir_wifi_start_log * start_log)8054 static void wma_set_wifi_start_packet_stats(void *wma_handle,
8055 struct sir_wifi_start_log *start_log)
8056 {
8057 struct hif_opaque_softc *scn;
8058 uint32_t log_state;
8059
8060 if (!start_log) {
8061 wma_err("start_log pointer is NULL");
8062 return;
8063 }
8064 if (wma_validate_handle(wma_handle))
8065 return;
8066
8067 /* No need to register for ring IDs other than packet stats */
8068 if (start_log->ring_id != RING_ID_PER_PACKET_STATS) {
8069 wma_debug("Ring id is not for per packet stats: %d",
8070 start_log->ring_id);
8071 return;
8072 }
8073
8074 scn = cds_get_context(QDF_MODULE_ID_HIF);
8075 if (!scn) {
8076 wma_err("Invalid HIF handle");
8077 return;
8078 }
8079
8080 #ifdef PKTLOG_LEGACY
8081 log_state = ATH_PKTLOG_ANI | ATH_PKTLOG_RCUPDATE | ATH_PKTLOG_RCFIND |
8082 ATH_PKTLOG_RX | ATH_PKTLOG_TX |
8083 ATH_PKTLOG_TEXT | ATH_PKTLOG_SW_EVENT;
8084 #elif defined(QCA_WIFI_QCA6390) || defined(QCA_WIFI_QCA6490) || \
8085 defined(QCA_WIFI_QCA6750) || defined(QCA_WIFI_KIWI) || \
8086 defined(QCA_WIFI_WCN6450)
8087 log_state = ATH_PKTLOG_RCFIND | ATH_PKTLOG_RCUPDATE |
8088 ATH_PKTLOG_TX | ATH_PKTLOG_LITE_T2H |
8089 ATH_PKTLOG_SW_EVENT | ATH_PKTLOG_RX;
8090 #elif defined(QCA_WIFI_QCA6290)
8091 log_state = ATH_PKTLOG_LITE_RX | ATH_PKTLOG_LITE_T2H;
8092 #else
8093 wma_debug("Packet log Not supported");
8094 log_state = 0;
8095 #endif
8096 if (start_log->size != 0) {
8097 pktlog_setsize(scn, start_log->size * MEGABYTE);
8098 return;
8099 } else if (start_log->is_pktlog_buff_clear == true) {
8100 pktlog_clearbuff(scn, start_log->is_pktlog_buff_clear);
8101 return;
8102 }
8103
8104 if (start_log->verbose_level == WLAN_LOG_LEVEL_ACTIVE) {
8105 pktlog_enable(scn, log_state, start_log->ini_triggered,
8106 start_log->user_triggered,
8107 start_log->is_iwpriv_command);
8108 wma_debug("Enabling per packet stats");
8109 } else {
8110 pktlog_enable(scn, 0, start_log->ini_triggered,
8111 start_log->user_triggered,
8112 start_log->is_iwpriv_command);
8113 wma_debug("Disabling per packet stats");
8114 }
8115 }
8116 #endif
8117
8118 /**
8119 * wma_send_flush_logs_to_fw() - Send log flush command to FW
8120 * @wma_handle: WMI handle
8121 *
8122 * This function is used to send the flush command to the FW,
8123 * that will flush the fw logs that are residue in the FW
8124 *
8125 * Return: None
8126 */
wma_send_flush_logs_to_fw(tp_wma_handle wma_handle)8127 void wma_send_flush_logs_to_fw(tp_wma_handle wma_handle)
8128 {
8129 QDF_STATUS status;
8130
8131 status = wmi_unified_flush_logs_to_fw_cmd(wma_handle->wmi_handle);
8132 if (QDF_IS_STATUS_ERROR(status))
8133 return;
8134
8135 status = qdf_mc_timer_start(&wma_handle->log_completion_timer,
8136 WMA_LOG_COMPLETION_TIMER);
8137 if (QDF_IS_STATUS_ERROR(status))
8138 wma_err("Failed to start the log completion timer");
8139 }
8140
8141 /**
8142 * wma_update_tx_fail_cnt_th() - Set threshold for TX pkt fail
8143 * @wma: WMA handle
8144 * @tx_fail_cnt_th: sme_tx_fail_cnt_threshold parameter
8145 *
8146 * This function is used to set Tx pkt fail count threshold,
8147 * FW will do disconnect with station once this threshold is reached.
8148 *
8149 * Return: QDF_STATUS
8150 */
wma_update_tx_fail_cnt_th(tp_wma_handle wma,struct sme_tx_fail_cnt_threshold * tx_fail_cnt_th)8151 static QDF_STATUS wma_update_tx_fail_cnt_th(tp_wma_handle wma,
8152 struct sme_tx_fail_cnt_threshold *tx_fail_cnt_th)
8153 {
8154 u_int8_t vdev_id;
8155 u_int32_t tx_fail_disconn_th;
8156 int ret = -EIO;
8157 struct wmi_unified *wmi_handle;
8158
8159 if (wma_validate_handle(wma))
8160 return QDF_STATUS_E_INVAL;
8161
8162 wmi_handle = wma->wmi_handle;
8163 if (wmi_validate_handle(wmi_handle))
8164 return QDF_STATUS_E_INVAL;
8165
8166 vdev_id = tx_fail_cnt_th->session_id;
8167 tx_fail_disconn_th = tx_fail_cnt_th->tx_fail_cnt_threshold;
8168 wma_debug("Set TX pkt fail count threshold vdevId %d count %d",
8169 vdev_id, tx_fail_disconn_th);
8170
8171 ret = wma_vdev_set_param(wmi_handle, vdev_id,
8172 wmi_vdev_param_disconnect_th,
8173 tx_fail_disconn_th);
8174
8175 if (ret) {
8176 wma_err("Failed to send TX pkt fail count threshold command");
8177 return QDF_STATUS_E_FAILURE;
8178 }
8179
8180 return QDF_STATUS_SUCCESS;
8181 }
8182
8183 /**
8184 * wma_update_short_retry_limit() - Set retry limit for short frames
8185 * @wma: WMA handle
8186 * @short_retry_limit_th: retry limir count for Short frames.
8187 *
8188 * This function is used to configure the transmission retry limit at which
8189 * short frames needs to be retry.
8190 *
8191 * Return: QDF_STATUS
8192 */
wma_update_short_retry_limit(tp_wma_handle wma,struct sme_short_retry_limit * short_retry_limit_th)8193 static QDF_STATUS wma_update_short_retry_limit(tp_wma_handle wma,
8194 struct sme_short_retry_limit *short_retry_limit_th)
8195 {
8196 uint8_t vdev_id;
8197 uint32_t short_retry_limit;
8198 int ret;
8199 struct wmi_unified *wmi_handle;
8200
8201 if (wma_validate_handle(wma))
8202 return QDF_STATUS_E_INVAL;
8203
8204 wmi_handle = wma->wmi_handle;
8205 if (wmi_validate_handle(wmi_handle))
8206 return QDF_STATUS_E_INVAL;
8207
8208 vdev_id = short_retry_limit_th->session_id;
8209 short_retry_limit = short_retry_limit_th->short_retry_limit;
8210 wma_debug("Set short retry limit threshold vdevId %d count %d",
8211 vdev_id, short_retry_limit);
8212
8213 ret = wma_vdev_set_param(wmi_handle, vdev_id,
8214 wmi_vdev_param_non_agg_sw_retry_th,
8215 short_retry_limit);
8216
8217 if (ret) {
8218 wma_err("Failed to send short limit threshold command");
8219 return QDF_STATUS_E_FAILURE;
8220 }
8221 return QDF_STATUS_SUCCESS;
8222 }
8223
8224 /**
8225 * wma_update_long_retry_limit() - Set retry limit for long frames
8226 * @wma: WMA handle
8227 * @long_retry_limit_th: retry limir count for long frames
8228 *
8229 * This function is used to configure the transmission retry limit at which
8230 * long frames needs to be retry
8231 *
8232 * Return: QDF_STATUS
8233 */
wma_update_long_retry_limit(tp_wma_handle wma,struct sme_long_retry_limit * long_retry_limit_th)8234 static QDF_STATUS wma_update_long_retry_limit(tp_wma_handle wma,
8235 struct sme_long_retry_limit *long_retry_limit_th)
8236 {
8237 uint8_t vdev_id;
8238 uint32_t long_retry_limit;
8239 int ret;
8240 struct wmi_unified *wmi_handle;
8241
8242 if (wma_validate_handle(wma))
8243 return QDF_STATUS_E_INVAL;
8244
8245 wmi_handle = wma->wmi_handle;
8246 if (wmi_validate_handle(wmi_handle))
8247 return QDF_STATUS_E_INVAL;
8248
8249 vdev_id = long_retry_limit_th->session_id;
8250 long_retry_limit = long_retry_limit_th->long_retry_limit;
8251 wma_debug("Set TX pkt fail count threshold vdevId %d count %d",
8252 vdev_id, long_retry_limit);
8253
8254 ret = wma_vdev_set_param(wmi_handle, vdev_id,
8255 wmi_vdev_param_agg_sw_retry_th,
8256 long_retry_limit);
8257
8258 if (ret) {
8259 wma_err("Failed to send long limit threshold command");
8260 return QDF_STATUS_E_FAILURE;
8261 }
8262
8263 return QDF_STATUS_SUCCESS;
8264 }
8265
8266 #define MAX_VDEV_AP_ALIVE_PARAMS 4
8267 /* params being sent:
8268 * wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs
8269 * wmi_vdev_param_ap_keepalive_max_idle_inactive_secs
8270 * wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs
8271 * wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs
8272 */
8273
8274 /*
8275 * wma_update_sta_inactivity_timeout() - Set sta_inactivity_timeout to fw
8276 * @wma_handle: WMA handle
8277 * @sta_inactivity_timer: sme_sta_inactivity_timeout
8278 *
8279 * This function is used to set sta_inactivity_timeout.
8280 * If a station does not send anything in sta_inactivity_timeout seconds, an
8281 * empty data frame is sent to it in order to verify whether it is
8282 * still in range. If this frame is not ACKed, the station will be
8283 * disassociated and then deauthenticated.
8284 *
8285 * Return: None
8286 */
wma_update_sta_inactivity_timeout(tp_wma_handle wma,struct sme_sta_inactivity_timeout * sta_inactivity_timer)8287 void wma_update_sta_inactivity_timeout(tp_wma_handle wma,
8288 struct sme_sta_inactivity_timeout *sta_inactivity_timer)
8289 {
8290 uint8_t vdev_id;
8291 uint32_t max_unresponsive_time;
8292 uint32_t min_inactive_time, max_inactive_time;
8293 struct wmi_unified *wmi_handle;
8294 struct dev_set_param setparam[MAX_VDEV_AP_ALIVE_PARAMS] = {};
8295 uint8_t index = 0;
8296 QDF_STATUS status = QDF_STATUS_E_FAILURE;
8297
8298 if (wma_validate_handle(wma))
8299 return;
8300
8301 wmi_handle = wma->wmi_handle;
8302 if (wmi_validate_handle(wmi_handle))
8303 return;
8304
8305 vdev_id = sta_inactivity_timer->session_id;
8306 max_unresponsive_time = sta_inactivity_timer->sta_inactivity_timeout;
8307 max_inactive_time = max_unresponsive_time * TWO_THIRD;
8308 min_inactive_time = max_unresponsive_time - max_inactive_time;
8309 status = mlme_check_index_setparam(
8310 setparam,
8311 wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs,
8312 min_inactive_time, index++,
8313 MAX_VDEV_AP_ALIVE_PARAMS);
8314 if (QDF_IS_STATUS_ERROR(status)) {
8315 wma_err("failed to set wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs");
8316 goto error;
8317 }
8318 status = mlme_check_index_setparam(
8319 setparam,
8320 wmi_vdev_param_ap_keepalive_max_idle_inactive_secs,
8321 min_inactive_time, index++, MAX_VDEV_AP_ALIVE_PARAMS);
8322 if (QDF_IS_STATUS_ERROR(status)) {
8323 wma_err("failed to set wmi_vdev_param_ap_keepalive_max_idle_inactive_secs");
8324 goto error;
8325 }
8326 status = mlme_check_index_setparam(
8327 setparam,
8328 wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs,
8329 max_inactive_time, index++, MAX_VDEV_AP_ALIVE_PARAMS);
8330 if (QDF_IS_STATUS_ERROR(status)) {
8331 wma_err("failed to set wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs");
8332 goto error;
8333 }
8334 status = mlme_check_index_setparam(
8335 setparam,
8336 wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs,
8337 max_unresponsive_time, index++,
8338 MAX_VDEV_AP_ALIVE_PARAMS);
8339 if (QDF_IS_STATUS_ERROR(status)) {
8340 wma_err("failed to set wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs");
8341 goto error;
8342 }
8343
8344 status = wma_send_multi_pdev_vdev_set_params(MLME_VDEV_SETPARAM,
8345 vdev_id, setparam, index);
8346 if (QDF_IS_STATUS_ERROR(status))
8347 wma_err("Failed to send idle_inactive,unresponsive time vdev set params");
8348
8349 error:
8350 return;
8351 }
8352
8353 #ifdef WLAN_FEATURE_WOW_PULSE
8354
8355
8356 #define WMI_WOW_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM \
8357 WMI_WOW_HOSTWAKEUP_GPIO_PIN_PATTERN_CONFIG_CMD_fixed_param
8358
8359
8360 #define WMITLV_TAG_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM \
8361 WMITLV_TAG_STRUC_wmi_wow_hostwakeup_gpio_pin_pattern_config_cmd_fixed_param
8362
8363 /**
8364 * wma_send_wow_pulse_cmd() - send wmi cmd of wow pulse cmd
8365 * information to fw.
8366 * @wma_handle: wma handler
8367 * @wow_pulse_cmd: wow_pulse_mode pointer
8368 *
8369 * Return: Return QDF_STATUS
8370 */
wma_send_wow_pulse_cmd(tp_wma_handle wma_handle,struct wow_pulse_mode * wow_pulse_cmd)8371 static QDF_STATUS wma_send_wow_pulse_cmd(tp_wma_handle wma_handle,
8372 struct wow_pulse_mode *wow_pulse_cmd)
8373 {
8374 QDF_STATUS status = QDF_STATUS_SUCCESS;
8375 wmi_buf_t buf;
8376 WMI_WOW_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM *cmd;
8377 u_int16_t len;
8378
8379 len = sizeof(*cmd);
8380 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8381 if (!buf)
8382 return QDF_STATUS_E_NOMEM;
8383
8384 cmd = (WMI_WOW_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM *)wmi_buf_data(buf);
8385 qdf_mem_zero(cmd, len);
8386
8387 WMITLV_SET_HDR(&cmd->tlv_header,
8388 WMITLV_TAG_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM,
8389 WMITLV_GET_STRUCT_TLVLEN(
8390 WMI_WOW_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM));
8391
8392 cmd->enable = wow_pulse_cmd->wow_pulse_enable;
8393 cmd->pin = wow_pulse_cmd->wow_pulse_pin;
8394 cmd->interval_low = wow_pulse_cmd->wow_pulse_interval_low;
8395 cmd->interval_high = wow_pulse_cmd->wow_pulse_interval_high;
8396 cmd->repeat_cnt = wow_pulse_cmd->wow_pulse_repeat_count;
8397 cmd->init_state = wow_pulse_cmd->wow_pulse_init_state;
8398
8399 if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
8400 WMI_WOW_HOSTWAKEUP_GPIO_PIN_PATTERN_CONFIG_CMDID)) {
8401 wmi_buf_free(buf);
8402 status = QDF_STATUS_E_FAILURE;
8403 }
8404
8405 wma_debug("Exit");
8406 return status;
8407 }
8408
8409 #undef WMI_WOW_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM
8410 #undef WMITLV_TAG_HOSTWAKEUP_GPIO_CMD_FIXED_PARAM
8411 #undef WMI_WOW_PULSE_REPEAT_CNT
8412
8413 #else
wma_send_wow_pulse_cmd(tp_wma_handle wma_handle,struct wow_pulse_mode * wow_pulse_cmd)8414 static inline QDF_STATUS wma_send_wow_pulse_cmd(tp_wma_handle wma_handle,
8415 struct wow_pulse_mode *wow_pulse_cmd)
8416 {
8417 return QDF_STATUS_E_FAILURE;
8418 }
8419 #endif
8420
8421
8422 /**
8423 * wma_process_power_debug_stats_req() - Process the Chip Power stats collect
8424 * request and pass the Power stats request to Fw
8425 * @wma_handle: WMA handle
8426 *
8427 * Return: QDF_STATUS
8428 */
8429 #ifdef WLAN_POWER_DEBUG
wma_process_power_debug_stats_req(tp_wma_handle wma_handle)8430 static QDF_STATUS wma_process_power_debug_stats_req(tp_wma_handle wma_handle)
8431 {
8432 wmi_pdev_get_chip_power_stats_cmd_fixed_param *cmd;
8433 int32_t len;
8434 wmi_buf_t buf;
8435 uint8_t *buf_ptr;
8436 int ret;
8437
8438 if (wma_validate_handle(wma_handle))
8439 return QDF_STATUS_E_FAILURE;
8440
8441 len = sizeof(*cmd);
8442 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8443 if (!buf)
8444 return QDF_STATUS_E_NOMEM;
8445
8446 buf_ptr = (u_int8_t *) wmi_buf_data(buf);
8447 cmd = (wmi_pdev_get_chip_power_stats_cmd_fixed_param *) buf_ptr;
8448
8449 WMITLV_SET_HDR(&cmd->tlv_header,
8450 WMITLV_TAG_STRUC_wmi_get_chip_power_stats_cmd_fixed_param,
8451 WMITLV_GET_STRUCT_TLVLEN(
8452 wmi_pdev_get_chip_power_stats_cmd_fixed_param));
8453 cmd->pdev_id = 0;
8454
8455 wma_debug("POWER_DEBUG_STATS - Get Request Params; Pdev id - %d",
8456 cmd->pdev_id);
8457 ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
8458 WMI_PDEV_GET_CHIP_POWER_STATS_CMDID);
8459 if (ret) {
8460 wmi_buf_free(buf);
8461 return QDF_STATUS_E_FAILURE;
8462 }
8463 return QDF_STATUS_SUCCESS;
8464 }
8465 #else
wma_process_power_debug_stats_req(tp_wma_handle wma_handle)8466 static QDF_STATUS wma_process_power_debug_stats_req(tp_wma_handle wma_handle)
8467 {
8468 return QDF_STATUS_SUCCESS;
8469 }
8470 #endif
8471 #ifdef WLAN_FEATURE_BEACON_RECEPTION_STATS
wma_process_beacon_debug_stats_req(tp_wma_handle wma_handle,uint32_t * vdev_id)8472 static QDF_STATUS wma_process_beacon_debug_stats_req(tp_wma_handle wma_handle,
8473 uint32_t *vdev_id)
8474 {
8475 wmi_vdev_get_bcn_recv_stats_cmd_fixed_param *cmd;
8476 int32_t len;
8477 wmi_buf_t buf;
8478 uint8_t *buf_ptr;
8479 int ret;
8480
8481 wma_debug("Enter");
8482 if (wma_validate_handle(wma_handle))
8483 return QDF_STATUS_E_FAILURE;
8484
8485 len = sizeof(*cmd);
8486 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8487 if (!buf)
8488 return QDF_STATUS_E_NOMEM;
8489
8490 buf_ptr = (u_int8_t *)wmi_buf_data(buf);
8491 cmd = (wmi_vdev_get_bcn_recv_stats_cmd_fixed_param *)buf_ptr;
8492
8493 WMITLV_SET_HDR(&cmd->tlv_header,
8494 WMITLV_TAG_STRUC_wmi_get_bcn_recv_stats_fixed_param,
8495 WMITLV_GET_STRUCT_TLVLEN(
8496 wmi_vdev_get_bcn_recv_stats_cmd_fixed_param));
8497 cmd->vdev_id = *vdev_id;
8498
8499 wma_debug("BEACON_DEBUG_STATS - Get Request Params; vdev id - %d",
8500 cmd->vdev_id);
8501 ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
8502 WMI_VDEV_GET_BCN_RECEPTION_STATS_CMDID);
8503 if (ret) {
8504 wmi_buf_free(buf);
8505 return QDF_STATUS_E_FAILURE;
8506 }
8507
8508 wma_debug("Exit");
8509 return QDF_STATUS_SUCCESS;
8510 }
8511 #else
wma_process_beacon_debug_stats_req(tp_wma_handle wma_handle,uint32_t * vdev_id)8512 static QDF_STATUS wma_process_beacon_debug_stats_req(tp_wma_handle wma_handle,
8513 uint32_t *vdev_id)
8514 {
8515 return QDF_STATUS_SUCCESS;
8516 }
8517 #endif
8518
8519 /**
8520 * wma_set_arp_req_stats() - process set arp stats request command to fw
8521 * @handle: WMA handle
8522 * @req_buf: set srp stats request buffer
8523 *
8524 * Return: None
8525 */
wma_set_arp_req_stats(WMA_HANDLE handle,struct set_arp_stats_params * req_buf)8526 static void wma_set_arp_req_stats(WMA_HANDLE handle,
8527 struct set_arp_stats_params *req_buf)
8528 {
8529 QDF_STATUS status;
8530 struct set_arp_stats *arp_stats;
8531 tp_wma_handle wma_handle = (tp_wma_handle) handle;
8532 struct wlan_objmgr_vdev *vdev;
8533 struct wmi_unified *wmi_handle;
8534
8535 if (wma_validate_handle(wma_handle))
8536 return;
8537
8538 wmi_handle = wma_handle->wmi_handle;
8539 if (wmi_validate_handle(wmi_handle))
8540 return;
8541
8542 if (!wma_is_vdev_valid(req_buf->vdev_id)) {
8543 wma_err("vdev id:%d is not active", req_buf->vdev_id);
8544 return;
8545 }
8546
8547 vdev = wlan_objmgr_get_vdev_by_id_from_psoc(wma_handle->psoc,
8548 req_buf->vdev_id,
8549 WLAN_LEGACY_WMA_ID);
8550 if (!vdev) {
8551 wma_err("Can't get vdev by vdev_id:%d", req_buf->vdev_id);
8552 return;
8553 }
8554
8555 if (!wma_is_vdev_up(req_buf->vdev_id)) {
8556 wma_debug("vdev id:%d is not started", req_buf->vdev_id);
8557 goto release_ref;
8558 }
8559
8560 arp_stats = (struct set_arp_stats *)req_buf;
8561 status = wmi_unified_set_arp_stats_req(wmi_handle, arp_stats);
8562 if (QDF_IS_STATUS_ERROR(status))
8563 wma_err("failed to set arp stats to FW");
8564
8565 release_ref:
8566 wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
8567 }
8568
8569 /**
8570 * wma_get_arp_req_stats() - process get arp stats request command to fw
8571 * @wma_handle: WMA handle
8572 * @req_buf: get srp stats request buffer
8573 *
8574 * Return: None
8575 */
wma_get_arp_req_stats(WMA_HANDLE handle,struct get_arp_stats_params * req_buf)8576 static void wma_get_arp_req_stats(WMA_HANDLE handle,
8577 struct get_arp_stats_params *req_buf)
8578 {
8579 QDF_STATUS status;
8580 struct get_arp_stats *arp_stats;
8581 tp_wma_handle wma_handle = (tp_wma_handle) handle;
8582 struct wmi_unified *wmi_handle;
8583
8584 if (wma_validate_handle(wma_handle))
8585 return;
8586
8587 wmi_handle = wma_handle->wmi_handle;
8588 if (wmi_validate_handle(wmi_handle))
8589 return;
8590
8591 if (!wma_is_vdev_valid(req_buf->vdev_id)) {
8592 wma_err("vdev id:%d is not active", req_buf->vdev_id);
8593 return;
8594 }
8595
8596 arp_stats = (struct get_arp_stats *)req_buf;
8597 status = wmi_unified_get_arp_stats_req(wmi_handle, arp_stats);
8598 if (QDF_IS_STATUS_ERROR(status))
8599 wma_err("failed to send get arp stats to FW");
8600 }
8601
8602 /**
8603 * wma_set_del_pmkid_cache() - API to set/delete PMKID cache entry in fw
8604 * @handle: WMA handle
8605 * @pmk_cache: PMK cache entry
8606 *
8607 * Return: None
8608 */
wma_set_del_pmkid_cache(WMA_HANDLE handle,struct wmi_unified_pmk_cache * pmk_cache)8609 static void wma_set_del_pmkid_cache(WMA_HANDLE handle,
8610 struct wmi_unified_pmk_cache *pmk_cache)
8611 {
8612 QDF_STATUS status;
8613 tp_wma_handle wma_handle = (tp_wma_handle) handle;
8614 struct wmi_unified *wmi_handle;
8615
8616 if (wma_validate_handle(wma_handle))
8617 return;
8618
8619 wmi_handle = wma_handle->wmi_handle;
8620 if (wmi_validate_handle(wmi_handle))
8621 return;
8622
8623 status = wmi_unified_set_del_pmkid_cache(wmi_handle, pmk_cache);
8624 if (QDF_IS_STATUS_ERROR(status))
8625 wma_err("failed to send set/del pmkid cmd to fw");
8626 }
8627
8628 /**
8629 * wma_send_invoke_neighbor_report() - API to send invoke neighbor report
8630 * command to fw
8631 *
8632 * @handle: WMA handle
8633 * @params: Pointer to invoke neighbor report params
8634 *
8635 * Return: None
8636 */
8637 static
wma_send_invoke_neighbor_report(WMA_HANDLE handle,struct wmi_invoke_neighbor_report_params * params)8638 void wma_send_invoke_neighbor_report(WMA_HANDLE handle,
8639 struct wmi_invoke_neighbor_report_params *params)
8640 {
8641 QDF_STATUS status;
8642 tp_wma_handle wma_handle = (tp_wma_handle) handle;
8643 struct wmi_unified *wmi_handle;
8644
8645 if (wma_validate_handle(wma_handle))
8646 return;
8647
8648 wmi_handle = wma_handle->wmi_handle;
8649 if (wmi_validate_handle(wmi_handle))
8650 return;
8651
8652 status = wmi_unified_invoke_neighbor_report_cmd(wmi_handle, params);
8653
8654 if (status != QDF_STATUS_SUCCESS)
8655 wma_err("failed to send invoke neighbor report command");
8656 }
8657
wma_set_rx_reorder_timeout_val(tp_wma_handle wma_handle,struct sir_set_rx_reorder_timeout_val * reorder_timeout)8658 QDF_STATUS wma_set_rx_reorder_timeout_val(tp_wma_handle wma_handle,
8659 struct sir_set_rx_reorder_timeout_val *reorder_timeout)
8660 {
8661 wmi_pdev_set_reorder_timeout_val_cmd_fixed_param *cmd;
8662 uint32_t len;
8663 wmi_buf_t buf;
8664 int ret;
8665
8666 if (!reorder_timeout) {
8667 wma_err("invalid pointer");
8668 return QDF_STATUS_E_INVAL;
8669 }
8670
8671 if (wma_validate_handle(wma_handle))
8672 return QDF_STATUS_E_INVAL;
8673
8674 len = sizeof(*cmd);
8675 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8676 if (!buf)
8677 return QDF_STATUS_E_NOMEM;
8678
8679 cmd = (wmi_pdev_set_reorder_timeout_val_cmd_fixed_param *)
8680 wmi_buf_data(buf);
8681
8682 WMITLV_SET_HDR(&cmd->tlv_header,
8683 WMITLV_TAG_STRUC_wmi_pdev_set_reorder_timeout_val_cmd_fixed_param,
8684 WMITLV_GET_STRUCT_TLVLEN(wmi_pdev_set_reorder_timeout_val_cmd_fixed_param));
8685
8686 memcpy(cmd->rx_timeout_pri, reorder_timeout->rx_timeout_pri,
8687 sizeof(reorder_timeout->rx_timeout_pri));
8688
8689 wma_debug("rx aggr record timeout: VO: %d, VI: %d, BE: %d, BK: %d",
8690 cmd->rx_timeout_pri[0], cmd->rx_timeout_pri[1],
8691 cmd->rx_timeout_pri[2], cmd->rx_timeout_pri[3]);
8692
8693 ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
8694 WMI_PDEV_SET_REORDER_TIMEOUT_VAL_CMDID);
8695 if (ret) {
8696 wmi_buf_free(buf);
8697 return QDF_STATUS_E_FAILURE;
8698 }
8699
8700 return QDF_STATUS_SUCCESS;
8701 }
8702
wma_set_rx_blocksize(tp_wma_handle wma_handle,struct sir_peer_set_rx_blocksize * peer_rx_blocksize)8703 QDF_STATUS wma_set_rx_blocksize(tp_wma_handle wma_handle,
8704 struct sir_peer_set_rx_blocksize *peer_rx_blocksize)
8705 {
8706 wmi_peer_set_rx_blocksize_cmd_fixed_param *cmd;
8707 int32_t len;
8708 wmi_buf_t buf;
8709 u_int8_t *buf_ptr;
8710 int ret;
8711
8712 if (!peer_rx_blocksize) {
8713 wma_err("invalid pointer");
8714 return QDF_STATUS_E_INVAL;
8715 }
8716
8717 if (wma_validate_handle(wma_handle))
8718 return QDF_STATUS_E_INVAL;
8719
8720 len = sizeof(*cmd);
8721 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8722 if (!buf)
8723 return QDF_STATUS_E_NOMEM;
8724
8725 buf_ptr = (u_int8_t *) wmi_buf_data(buf);
8726 cmd = (wmi_peer_set_rx_blocksize_cmd_fixed_param *) buf_ptr;
8727
8728 WMITLV_SET_HDR(&cmd->tlv_header,
8729 WMITLV_TAG_STRUC_wmi_peer_set_rx_blocksize_cmd_fixed_param,
8730 WMITLV_GET_STRUCT_TLVLEN(wmi_peer_set_rx_blocksize_cmd_fixed_param));
8731
8732 cmd->vdev_id = peer_rx_blocksize->vdev_id;
8733 cmd->rx_block_ack_win_limit =
8734 peer_rx_blocksize->rx_block_ack_win_limit;
8735 WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_rx_blocksize->peer_macaddr.bytes,
8736 &cmd->peer_macaddr);
8737
8738 wma_debug("rx aggr blocksize: %d", cmd->rx_block_ack_win_limit);
8739
8740 ret = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
8741 WMI_PEER_SET_RX_BLOCKSIZE_CMDID);
8742 if (ret) {
8743 wmi_buf_free(buf);
8744 return QDF_STATUS_E_FAILURE;
8745 }
8746
8747 return QDF_STATUS_SUCCESS;
8748 }
8749
wma_get_chain_rssi(tp_wma_handle wma_handle,struct get_chain_rssi_req_params * req_params)8750 QDF_STATUS wma_get_chain_rssi(tp_wma_handle wma_handle,
8751 struct get_chain_rssi_req_params *req_params)
8752 {
8753 wmi_pdev_div_get_rssi_antid_fixed_param *cmd;
8754 wmi_buf_t wmi_buf;
8755 uint32_t len = sizeof(wmi_pdev_div_get_rssi_antid_fixed_param);
8756 u_int8_t *buf_ptr;
8757
8758 if (wma_validate_handle(wma_handle))
8759 return QDF_STATUS_E_INVAL;
8760
8761 wmi_buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
8762 if (!wmi_buf)
8763 return QDF_STATUS_E_NOMEM;
8764
8765 buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf);
8766
8767 cmd = (wmi_pdev_div_get_rssi_antid_fixed_param *)buf_ptr;
8768 WMITLV_SET_HDR(&cmd->tlv_header,
8769 WMITLV_TAG_STRUC_wmi_pdev_div_get_rssi_antid_fixed_param,
8770 WMITLV_GET_STRUCT_TLVLEN(
8771 wmi_pdev_div_get_rssi_antid_fixed_param));
8772 cmd->pdev_id = 0;
8773 WMI_CHAR_ARRAY_TO_MAC_ADDR(req_params->peer_macaddr.bytes,
8774 &cmd->macaddr);
8775
8776 if (wmi_unified_cmd_send(wma_handle->wmi_handle, wmi_buf, len,
8777 WMI_PDEV_DIV_GET_RSSI_ANTID_CMDID)) {
8778 wmi_buf_free(wmi_buf);
8779 return QDF_STATUS_E_FAILURE;
8780 }
8781
8782 return QDF_STATUS_SUCCESS;
8783 }
8784
8785 #if defined(WLAN_FEATURE_FILS_SK)
8786 /**
8787 * wma_roam_scan_send_hlp() - API to send HLP IE info to fw
8788 * @wma_handle: WMA handle
8789 * @req: HLP params
8790 *
8791 * Return: QDF_STATUS
8792 */
wma_roam_scan_send_hlp(tp_wma_handle wma_handle,struct hlp_params * req)8793 static QDF_STATUS wma_roam_scan_send_hlp(tp_wma_handle wma_handle,
8794 struct hlp_params *req)
8795 {
8796 struct hlp_params *params;
8797 QDF_STATUS status;
8798
8799 params = qdf_mem_malloc(sizeof(*params));
8800 if (!params)
8801 return QDF_STATUS_E_NOMEM;
8802
8803 params->vdev_id = req->vdev_id;
8804 params->hlp_ie_len = req->hlp_ie_len;
8805 qdf_mem_copy(params->hlp_ie, req->hlp_ie, req->hlp_ie_len);
8806 status = wmi_unified_roam_send_hlp_cmd(wma_handle->wmi_handle, params);
8807
8808 wma_debug("Send HLP status %d vdev id %d", status, params->vdev_id);
8809 qdf_trace_hex_dump(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_DEBUG,
8810 params->hlp_ie, 10);
8811
8812 qdf_mem_free(params);
8813 return status;
8814 }
8815 #else
wma_roam_scan_send_hlp(tp_wma_handle wma_handle,struct hlp_params * req)8816 static QDF_STATUS wma_roam_scan_send_hlp(tp_wma_handle wma_handle,
8817 struct hlp_params *req)
8818 {
8819 return QDF_STATUS_SUCCESS;
8820 }
8821 #endif
8822
8823 /**
8824 * wma_process_limit_off_chan() - set limit off channel parameters
8825 * @wma_handle: pointer to wma handle
8826 * @param: pointer to sir_limit_off_chan
8827 *
8828 * Return: QDF_STATUS_SUCCESS for success or error code.
8829 */
wma_process_limit_off_chan(tp_wma_handle wma_handle,struct sir_limit_off_chan * param)8830 static QDF_STATUS wma_process_limit_off_chan(tp_wma_handle wma_handle,
8831 struct sir_limit_off_chan *param)
8832 {
8833 int32_t err;
8834 struct wmi_limit_off_chan_param limit_off_chan_param;
8835
8836 if (param->vdev_id >= wma_handle->max_bssid) {
8837 wma_err("Invalid vdev_id: %d", param->vdev_id);
8838 return QDF_STATUS_E_INVAL;
8839 }
8840 if (!wma_is_vdev_up(param->vdev_id)) {
8841 wma_debug("vdev %d is not up skipping limit_off_chan_param",
8842 param->vdev_id);
8843 return QDF_STATUS_E_INVAL;
8844 }
8845
8846 limit_off_chan_param.vdev_id = param->vdev_id;
8847 limit_off_chan_param.status = param->is_tos_active;
8848 limit_off_chan_param.max_offchan_time = param->max_off_chan_time;
8849 limit_off_chan_param.rest_time = param->rest_time;
8850 limit_off_chan_param.skip_dfs_chans = param->skip_dfs_chans;
8851
8852 err = wmi_unified_send_limit_off_chan_cmd(wma_handle->wmi_handle,
8853 &limit_off_chan_param);
8854 if (err) {
8855 wma_err("failed to set limit off chan cmd");
8856 return QDF_STATUS_E_FAILURE;
8857 }
8858
8859 return QDF_STATUS_SUCCESS;
8860 }
8861
wma_process_obss_color_collision_req(tp_wma_handle wma_handle,struct wmi_obss_color_collision_cfg_param * cfg)8862 static QDF_STATUS wma_process_obss_color_collision_req(tp_wma_handle wma_handle,
8863 struct wmi_obss_color_collision_cfg_param *cfg)
8864 {
8865 QDF_STATUS status;
8866
8867 if (cfg->vdev_id >= wma_handle->max_bssid) {
8868 wma_err("Invalid vdev_id: %d", cfg->vdev_id);
8869 return QDF_STATUS_E_INVAL;
8870 }
8871 if (!wma_is_vdev_up(cfg->vdev_id)) {
8872 wma_err("vdev %d is not up skipping obss color collision req",
8873 cfg->vdev_id);
8874 return QDF_STATUS_E_INVAL;
8875 }
8876
8877 status = wmi_unified_send_obss_color_collision_cfg_cmd(wma_handle->
8878 wmi_handle, cfg);
8879 if (QDF_IS_STATUS_ERROR(status))
8880 wma_err("Failed to send obss color collision cfg");
8881
8882 return status;
8883 }
8884
8885 /**
8886 * wma_send_obss_detection_cfg() - send obss detection cfg to firmware
8887 * @wma_handle: pointer to wma handle
8888 * @cfg: obss detection configuration
8889 *
8890 * Send obss detection configuration to firmware.
8891 *
8892 * Return: None
8893 */
wma_send_obss_detection_cfg(tp_wma_handle wma_handle,struct wmi_obss_detection_cfg_param * cfg)8894 static void wma_send_obss_detection_cfg(tp_wma_handle wma_handle,
8895 struct wmi_obss_detection_cfg_param
8896 *cfg)
8897 {
8898 QDF_STATUS status;
8899
8900 if (cfg->vdev_id >= wma_handle->max_bssid) {
8901 wma_err("Invalid vdev_id: %d", cfg->vdev_id);
8902 return;
8903 }
8904 if (!wma_is_vdev_up(cfg->vdev_id)) {
8905 wma_err("vdev %d is not up skipping obss detection req",
8906 cfg->vdev_id);
8907 return;
8908 }
8909
8910 status = wmi_unified_send_obss_detection_cfg_cmd(wma_handle->wmi_handle,
8911 cfg);
8912 if (QDF_IS_STATUS_ERROR(status))
8913 wma_err("Failed to send obss detection cfg");
8914
8915 return;
8916 }
8917
8918 #ifdef WLAN_FEATURE_MOTION_DETECTION
8919 /**
8920 * wma_motion_det_host_event_handler - motion detection event handler
8921 * @handle: WMA global handle
8922 * @event: motion detection event
8923 * @len: Length of cmd
8924 *
8925 * Call motion detection event callback handler
8926 *
8927 * Return: 0 on success, else error on failure
8928 */
wma_motion_det_host_event_handler(void * handle,uint8_t * event,uint32_t len)8929 int wma_motion_det_host_event_handler(void *handle, uint8_t *event,
8930 uint32_t len)
8931 {
8932 wmi_motion_det_event *motion_det_event_hdr;
8933 WMI_MOTION_DET_HOST_EVENTID_param_tlvs *param_buf =
8934 (WMI_MOTION_DET_HOST_EVENTID_param_tlvs *)event;
8935 struct sir_md_evt *md_event;
8936 struct mac_context *pmac = (struct mac_context *)cds_get_context(
8937 QDF_MODULE_ID_PE);
8938
8939 if (!param_buf) {
8940 wma_err("Invalid motion det host event buffer");
8941 return -EINVAL;
8942 }
8943
8944 if (!pmac || !pmac->sme.md_host_evt_cb) {
8945 wma_err("Invalid motion detect callback");
8946 return -EINVAL;
8947 }
8948
8949 motion_det_event_hdr = param_buf->fixed_param;
8950 wma_alert("motion detect host event received, vdev_id=%d, status=%d",
8951 motion_det_event_hdr->vdev_id, motion_det_event_hdr->status);
8952
8953 md_event = qdf_mem_malloc(sizeof(*md_event));
8954 if (!md_event)
8955 return -ENOMEM;
8956
8957 md_event->vdev_id = motion_det_event_hdr->vdev_id;
8958 md_event->status = motion_det_event_hdr->status;
8959
8960 pmac->sme.md_host_evt_cb(pmac->sme.md_ctx, md_event);
8961
8962 qdf_mem_free(md_event);
8963 return 0;
8964 }
8965
8966 /**
8967 * wma_motion_det_base_line_host_event_handler - md baselining event handler
8968 * @handle: WMA global handle
8969 * @event: motion detection baselining event
8970 * @len: Length of cmd
8971 *
8972 * Return: 0 on success, else error on failure
8973 */
wma_motion_det_base_line_host_event_handler(void * handle,uint8_t * event,uint32_t len)8974 int wma_motion_det_base_line_host_event_handler(void *handle,
8975 uint8_t *event, uint32_t len)
8976 {
8977 wmi_motion_det_base_line_event *motion_det_base_line_event_hdr;
8978 WMI_MOTION_DET_BASE_LINE_HOST_EVENTID_param_tlvs *param_buf =
8979 (WMI_MOTION_DET_BASE_LINE_HOST_EVENTID_param_tlvs *)event;
8980 struct sir_md_bl_evt *md_bl_event;
8981 struct mac_context *pmac = (struct mac_context *)cds_get_context(
8982 QDF_MODULE_ID_PE);
8983
8984 if (!param_buf) {
8985 wma_err("Invalid motion detection base line event buffer");
8986 return -EINVAL;
8987 }
8988
8989 if (!pmac || !pmac->sme.md_bl_evt_cb) {
8990 wma_err("Invalid motion detection base line callback");
8991 return -EINVAL;
8992 }
8993
8994 motion_det_base_line_event_hdr = param_buf->fixed_param;
8995 wma_alert("motion detection base line event received, vdev_id=%d",
8996 motion_det_base_line_event_hdr->vdev_id);
8997 wma_alert("baseline_value=%d bl_max_corr_resv=%d bl_min_corr_resv=%d",
8998 motion_det_base_line_event_hdr->bl_baseline_value,
8999 motion_det_base_line_event_hdr->bl_max_corr_reserved,
9000 motion_det_base_line_event_hdr->bl_min_corr_reserved);
9001
9002 md_bl_event = qdf_mem_malloc(sizeof(*md_bl_event));
9003 if (!md_bl_event)
9004 return -ENOMEM;
9005
9006 md_bl_event->vdev_id = motion_det_base_line_event_hdr->vdev_id;
9007 md_bl_event->bl_baseline_value =
9008 motion_det_base_line_event_hdr->bl_baseline_value;
9009 md_bl_event->bl_max_corr_reserved =
9010 motion_det_base_line_event_hdr->bl_max_corr_reserved;
9011 md_bl_event->bl_min_corr_reserved =
9012 motion_det_base_line_event_hdr->bl_min_corr_reserved;
9013
9014 pmac->sme.md_bl_evt_cb(pmac->sme.md_ctx, md_bl_event);
9015
9016 qdf_mem_free(md_bl_event);
9017 return 0;
9018 }
9019
9020 /**
9021 * wma_set_motion_det_config - Sends motion detection configuration wmi cmd
9022 * @wma_handle: WMA global handle
9023 * @motion_det_cfg: motion detection configuration
9024 *
9025 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_ERROR on error
9026 */
wma_set_motion_det_config(tp_wma_handle wma_handle,struct sme_motion_det_cfg * motion_det_cfg)9027 static QDF_STATUS wma_set_motion_det_config(
9028 tp_wma_handle wma_handle,
9029 struct sme_motion_det_cfg *motion_det_cfg)
9030 {
9031 wmi_motion_det_config_params_cmd_fixed_param *cmd;
9032 wmi_buf_t buf;
9033 int err;
9034
9035 buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
9036 if (!buf)
9037 return QDF_STATUS_E_NOMEM;
9038
9039 cmd = (wmi_motion_det_config_params_cmd_fixed_param *)wmi_buf_data(buf);
9040 qdf_mem_zero(cmd, sizeof(*cmd));
9041
9042 WMITLV_SET_HDR(
9043 &cmd->tlv_header,
9044 WMITLV_TAG_STRUC_wmi_motion_det_config_params_cmd_fixed_param,
9045 WMITLV_GET_STRUCT_TLVLEN(
9046 wmi_motion_det_config_params_cmd_fixed_param));
9047 cmd->vdev_id = motion_det_cfg->vdev_id;
9048 cmd->time_t1 = motion_det_cfg->time_t1;
9049 cmd->time_t2 = motion_det_cfg->time_t2;
9050 cmd->n1 = motion_det_cfg->n1;
9051 cmd->n2 = motion_det_cfg->n2;
9052 cmd->time_t1_gap = motion_det_cfg->time_t1_gap;
9053 cmd->time_t2_gap = motion_det_cfg->time_t2_gap;
9054 cmd->coarse_K = motion_det_cfg->coarse_K;
9055 cmd->fine_K = motion_det_cfg->fine_K;
9056 cmd->coarse_Q = motion_det_cfg->coarse_Q;
9057 cmd->fine_Q = motion_det_cfg->fine_Q;
9058 cmd->md_coarse_thr_high = motion_det_cfg->md_coarse_thr_high;
9059 cmd->md_fine_thr_high = motion_det_cfg->md_fine_thr_high;
9060 cmd->md_coarse_thr_low = motion_det_cfg->md_coarse_thr_low;
9061 cmd->md_fine_thr_low = motion_det_cfg->md_fine_thr_low;
9062
9063 err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, sizeof(*cmd),
9064 WMI_MOTION_DET_CONFIG_PARAM_CMDID);
9065 if (err) {
9066 wmi_buf_free(buf);
9067 return QDF_STATUS_E_FAILURE;
9068 }
9069 wma_nofl_alert("Set motion_det_config to vdevId %d\n"
9070 "time_t1 %d\n"
9071 "time_t2 %d\n"
9072 "n1 %d\n"
9073 "n2 %d\n"
9074 "time_t1_gap %d\n"
9075 "time_t2_gap %d\n"
9076 "coarse_K %d\n"
9077 "fine_K %d\n"
9078 "coarse_Q %d\n"
9079 "fine_Q %d\n"
9080 "md_coarse_thr_high %d\n"
9081 "md_fine_thr_high %d\n"
9082 "md_coarse_thr_low %d\n"
9083 "md_fine_thr_low %d\n",
9084 motion_det_cfg->vdev_id,
9085 motion_det_cfg->time_t1,
9086 motion_det_cfg->time_t2,
9087 motion_det_cfg->n1,
9088 motion_det_cfg->n2,
9089 motion_det_cfg->time_t1_gap,
9090 motion_det_cfg->time_t2_gap,
9091 motion_det_cfg->coarse_K,
9092 motion_det_cfg->fine_K,
9093 motion_det_cfg->coarse_Q,
9094 motion_det_cfg->fine_Q,
9095 motion_det_cfg->md_coarse_thr_high,
9096 motion_det_cfg->md_fine_thr_high,
9097 motion_det_cfg->md_coarse_thr_low,
9098 motion_det_cfg->md_fine_thr_low);
9099 return QDF_STATUS_SUCCESS;
9100 }
9101
9102 /**
9103 * wma_set_motion_det_enable - Sends motion detection start/stop wmi cmd
9104 * @wma_handle: WMA global handle
9105 * @md_en: motion detection start/stop
9106 *
9107 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_ERROR on error
9108 */
wma_set_motion_det_enable(tp_wma_handle wma_handle,struct sme_motion_det_en * md_en)9109 static QDF_STATUS wma_set_motion_det_enable(tp_wma_handle wma_handle,
9110 struct sme_motion_det_en *md_en)
9111 {
9112 wmi_motion_det_start_stop_cmd_fixed_param *cmd;
9113 wmi_buf_t buf;
9114 int err;
9115
9116 buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
9117 if (!buf)
9118 return QDF_STATUS_E_NOMEM;
9119
9120 cmd = (wmi_motion_det_start_stop_cmd_fixed_param *)wmi_buf_data(buf);
9121 qdf_mem_zero(cmd, sizeof(*cmd));
9122
9123 WMITLV_SET_HDR(
9124 &cmd->tlv_header,
9125 WMITLV_TAG_STRUC_wmi_motion_det_start_stop_cmd_fixed_param,
9126 WMITLV_GET_STRUCT_TLVLEN(
9127 wmi_motion_det_start_stop_cmd_fixed_param));
9128 cmd->vdev_id = md_en->vdev_id;
9129 cmd->enable = md_en->enable;
9130
9131 err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, sizeof(*cmd),
9132 WMI_MOTION_DET_START_STOP_CMDID);
9133 if (err) {
9134 wmi_buf_free(buf);
9135 return QDF_STATUS_E_FAILURE;
9136 }
9137 wma_alert("Set motion_det_enable to vdevId %d %d", md_en->vdev_id,
9138 md_en->enable);
9139 return QDF_STATUS_SUCCESS;
9140 }
9141
9142 /**
9143 * wma_set_motion_det_base_line_config - Sends md baselining cfg wmi cmd
9144 * @wma_handle: WMA global handle
9145 * @md_base_line_cfg: md baselining configuration
9146 *
9147 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_ERROR on error
9148 */
wma_set_motion_det_base_line_config(tp_wma_handle wma_handle,struct sme_motion_det_base_line_cfg * md_base_line_cfg)9149 static QDF_STATUS wma_set_motion_det_base_line_config(
9150 tp_wma_handle wma_handle,
9151 struct sme_motion_det_base_line_cfg *md_base_line_cfg)
9152 {
9153 wmi_motion_det_base_line_config_params_cmd_fixed_param *cmd;
9154 wmi_buf_t buf;
9155 int err;
9156
9157 buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
9158 if (!buf)
9159 return QDF_STATUS_E_NOMEM;
9160
9161 cmd = (wmi_motion_det_base_line_config_params_cmd_fixed_param *)
9162 wmi_buf_data(buf);
9163 qdf_mem_zero(cmd, sizeof(*cmd));
9164
9165 WMITLV_SET_HDR(
9166 &cmd->tlv_header,
9167 WMITLV_TAG_STRUC_wmi_motion_det_base_line_config_params_cmd_fixed_param,
9168 WMITLV_GET_STRUCT_TLVLEN(
9169 wmi_motion_det_base_line_config_params_cmd_fixed_param));
9170
9171 cmd->vdev_id = md_base_line_cfg->vdev_id;
9172 cmd->bl_time_t = md_base_line_cfg->bl_time_t;
9173 cmd->bl_packet_gap = md_base_line_cfg->bl_packet_gap;
9174 cmd->bl_n = md_base_line_cfg->bl_n;
9175 cmd->bl_num_meas = md_base_line_cfg->bl_num_meas;
9176
9177 err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, sizeof(*cmd),
9178 WMI_MOTION_DET_BASE_LINE_CONFIG_PARAM_CMDID);
9179 if (err) {
9180 wmi_buf_free(buf);
9181 return QDF_STATUS_E_FAILURE;
9182 }
9183 wma_nofl_alert("Set motion_det_baseline_config to vdevId %d\n"
9184 "bl_time_t %d\n"
9185 "bl_packet_gap %d\n"
9186 "bl_n %d\n"
9187 "bl_num_meas %d\n",
9188 md_base_line_cfg->vdev_id,
9189 md_base_line_cfg->bl_time_t,
9190 md_base_line_cfg->bl_packet_gap,
9191 md_base_line_cfg->bl_n,
9192 md_base_line_cfg->bl_num_meas);
9193 return QDF_STATUS_SUCCESS;
9194 }
9195
9196 /**
9197 * wma_set_motion_det_base_line_enable - Sends md baselining start/stop wmi cmd
9198 * @wma_handle: WMA global handle
9199 * @md_base_line_en: motion detection baselining start/stop
9200 *
9201 * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_ERROR on error
9202 */
wma_set_motion_det_base_line_enable(tp_wma_handle wma_handle,struct sme_motion_det_base_line_en * md_base_line_en)9203 static QDF_STATUS wma_set_motion_det_base_line_enable(
9204 tp_wma_handle wma_handle,
9205 struct sme_motion_det_base_line_en *md_base_line_en)
9206 {
9207 wmi_motion_det_base_line_start_stop_cmd_fixed_param *cmd;
9208 wmi_buf_t buf;
9209 int err;
9210
9211 buf = wmi_buf_alloc(wma_handle->wmi_handle, sizeof(*cmd));
9212 if (!buf)
9213 return QDF_STATUS_E_NOMEM;
9214
9215 cmd = (wmi_motion_det_base_line_start_stop_cmd_fixed_param *)
9216 wmi_buf_data(buf);
9217 qdf_mem_zero(cmd, sizeof(*cmd));
9218
9219 WMITLV_SET_HDR(
9220 &cmd->tlv_header,
9221 WMITLV_TAG_STRUC_wmi_motion_det_base_line_start_stop_cmd_fixed_param,
9222 WMITLV_GET_STRUCT_TLVLEN(
9223 wmi_motion_det_base_line_start_stop_cmd_fixed_param));
9224
9225 cmd->vdev_id = md_base_line_en->vdev_id;
9226 cmd->enable = md_base_line_en->enable;
9227
9228 err = wmi_unified_cmd_send(wma_handle->wmi_handle, buf, sizeof(*cmd),
9229 WMI_MOTION_DET_BASE_LINE_START_STOP_CMDID);
9230 if (err) {
9231 wmi_buf_free(buf);
9232 return QDF_STATUS_E_FAILURE;
9233 }
9234 wma_alert("Set motion_det_base_line_enable to vdevId %d enable %d",
9235 md_base_line_en->vdev_id, md_base_line_en->enable);
9236 return QDF_STATUS_SUCCESS;
9237 }
9238 #endif /* WLAN_FEATURE_MOTION_DETECTION */
9239
9240 /**
9241 * wma_mc_process_msg() - process wma messages and call appropriate function.
9242 * @msg: message
9243 *
9244 * Return: QDF_SUCCESS for success otherwise failure
9245 */
wma_mc_process_msg(struct scheduler_msg * msg)9246 static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
9247 {
9248 QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
9249 tp_wma_handle wma_handle;
9250
9251 if (!msg) {
9252 wma_err("msg is NULL");
9253 QDF_ASSERT(0);
9254 qdf_status = QDF_STATUS_E_INVAL;
9255 goto end;
9256 }
9257
9258 wma_nofl_debug("Handle msg %s(0x%x)",
9259 mac_trace_get_wma_msg_string(msg->type), msg->type);
9260
9261 wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
9262 if (!wma_handle) {
9263 QDF_ASSERT(0);
9264 qdf_mem_free(msg->bodyptr);
9265 qdf_status = QDF_STATUS_E_INVAL;
9266 goto end;
9267 }
9268
9269 switch (msg->type) {
9270 #ifdef FEATURE_WLAN_ESE
9271 case WMA_TSM_STATS_REQ:
9272 wma_debug("McThread: WMA_TSM_STATS_REQ");
9273 wma_process_tsm_stats_req(wma_handle, (void *)msg->bodyptr);
9274 break;
9275 #endif /* FEATURE_WLAN_ESE */
9276 case WMA_UPDATE_CHAN_LIST_REQ:
9277 wma_update_channel_list(wma_handle,
9278 (tSirUpdateChanList *) msg->bodyptr);
9279 qdf_mem_free(msg->bodyptr);
9280 break;
9281 case WMA_ADD_STA_REQ:
9282 wma_add_sta(wma_handle, (tpAddStaParams) msg->bodyptr);
9283 break;
9284 case WMA_SEND_PEER_UNMAP_CONF:
9285 wma_peer_unmap_conf_send(
9286 wma_handle,
9287 (struct send_peer_unmap_conf_params *)msg->bodyptr);
9288 qdf_mem_free(msg->bodyptr);
9289 break;
9290 case WMA_DELETE_STA_REQ:
9291 wma_delete_sta(wma_handle, (tpDeleteStaParams) msg->bodyptr);
9292 break;
9293 case WMA_DELETE_BSS_HO_FAIL_REQ:
9294 wma_delete_bss_ho_fail(wma_handle, msg->bodyval);
9295 break;
9296 case WMA_DELETE_BSS_REQ:
9297 wma_delete_bss(wma_handle, msg->bodyval);
9298 break;
9299 case WMA_UPDATE_EDCA_PROFILE_IND:
9300 wma_process_update_edca_param_req(wma_handle,
9301 (tEdcaParams *) msg->bodyptr);
9302 qdf_mem_free(msg->bodyptr);
9303 break;
9304 case WMA_SEND_BEACON_REQ:
9305 wma_send_beacon(wma_handle, (tpSendbeaconParams) msg->bodyptr);
9306 break;
9307 case WMA_SEND_AP_VDEV_UP:
9308 wma_set_ap_vdev_up(wma_handle, msg->bodyval);
9309 break;
9310 case WMA_SEND_PROBE_RSP_TMPL:
9311 wma_send_probe_rsp_tmpl(wma_handle,
9312 (tpSendProbeRespParams) msg->bodyptr);
9313 qdf_mem_free(msg->bodyptr);
9314 break;
9315 case WMA_CLI_SET_CMD:
9316 wma_process_cli_set_cmd(wma_handle,
9317 (wma_cli_set_cmd_t *) msg->bodyptr);
9318 qdf_mem_free(msg->bodyptr);
9319 break;
9320 case WMA_SET_PDEV_IE_REQ:
9321 wma_process_set_pdev_ie_req(wma_handle,
9322 (struct set_ie_param *)msg->bodyptr);
9323 qdf_mem_free(msg->bodyptr);
9324 break;
9325 #if !defined(REMOVE_PKT_LOG) && defined(FEATURE_PKTLOG)
9326 case WMA_PKTLOG_ENABLE_REQ:
9327 wma_pktlog_wmi_send_cmd(wma_handle,
9328 (struct ath_pktlog_wmi_params *)msg->bodyptr);
9329 qdf_mem_free(msg->bodyptr);
9330 break;
9331 #endif /* REMOVE_PKT_LOG */
9332 case WMA_ENABLE_UAPSD_REQ:
9333 wma_enable_uapsd_mode(wma_handle,
9334 (tpEnableUapsdParams) msg->bodyptr);
9335 qdf_mem_free(msg->bodyptr);
9336 break;
9337 case WMA_DISABLE_UAPSD_REQ:
9338 wma_disable_uapsd_mode(wma_handle,
9339 (tpDisableUapsdParams) msg->bodyptr);
9340 qdf_mem_free(msg->bodyptr);
9341 break;
9342 case WMA_SET_DTIM_PERIOD:
9343 wma_set_dtim_period(wma_handle,
9344 (struct set_dtim_params *)msg->bodyptr);
9345 qdf_mem_free(msg->bodyptr);
9346 break;
9347 case WMA_SET_TX_POWER_REQ:
9348 wma_set_tx_power(wma_handle, (tpMaxTxPowerParams) msg->bodyptr);
9349 break;
9350 case WMA_SET_MAX_TX_POWER_REQ:
9351 wma_set_max_tx_power(wma_handle,
9352 (tpMaxTxPowerParams) msg->bodyptr);
9353 break;
9354 case WMA_SET_KEEP_ALIVE:
9355 wma_set_keepalive_req(wma_handle, msg->bodyptr);
9356 break;
9357 #ifdef FEATURE_WLAN_ESE
9358 case WMA_SET_PLM_REQ:
9359 wma_config_plm(wma_handle, msg->bodyptr);
9360 qdf_mem_free(msg->bodyptr);
9361 break;
9362 #endif
9363
9364 case WMA_UPDATE_OP_MODE:
9365 wma_process_update_opmode(wma_handle,
9366 (tUpdateVHTOpMode *) msg->bodyptr);
9367 qdf_mem_free(msg->bodyptr);
9368 break;
9369 case WMA_UPDATE_RX_NSS:
9370 wma_process_update_rx_nss(wma_handle,
9371 (tUpdateRxNss *) msg->bodyptr);
9372 qdf_mem_free(msg->bodyptr);
9373 break;
9374 case WMA_UPDATE_MEMBERSHIP:
9375 wma_process_update_membership(wma_handle,
9376 (tUpdateMembership *) msg->bodyptr);
9377 break;
9378 case WMA_UPDATE_USERPOS:
9379 wma_process_update_userpos(wma_handle,
9380 (tUpdateUserPos *) msg->bodyptr);
9381 break;
9382 case WMA_UPDATE_BEACON_IND:
9383 wma_process_update_beacon_params(wma_handle,
9384 (tUpdateBeaconParams *) msg->bodyptr);
9385 qdf_mem_free(msg->bodyptr);
9386 break;
9387
9388 case WMA_ADD_TS_REQ:
9389 wma_add_ts_req(wma_handle, msg->bodyptr);
9390 break;
9391
9392 case WMA_DEL_TS_REQ:
9393 wma_del_ts_req(wma_handle, msg->bodyptr);
9394 break;
9395
9396 case WMA_AGGR_QOS_REQ:
9397 wma_aggr_qos_req(wma_handle, msg->bodyptr);
9398 break;
9399
9400 case WMA_8023_MULTICAST_LIST_REQ:
9401 wma_process_mcbc_set_filter_req(wma_handle,
9402 (tpSirRcvFltMcAddrList) msg->bodyptr);
9403 qdf_mem_free(msg->bodyptr);
9404 break;
9405
9406 case WMA_ROAM_PRE_AUTH_STATUS:
9407 wma_send_roam_preauth_status(wma_handle, msg->bodyptr);
9408 qdf_mem_free(msg->bodyptr);
9409 break;
9410
9411 case WMA_ROAM_SYNC_TIMEOUT:
9412 wma_handle_roam_sync_timeout(wma_handle, msg->bodyptr);
9413 qdf_mem_free(msg->bodyptr);
9414 break;
9415 case WMA_RATE_UPDATE_IND:
9416 wma_process_rate_update_indicate(wma_handle,
9417 (tSirRateUpdateInd *) msg->bodyptr);
9418 break;
9419
9420 #ifdef FEATURE_WLAN_TDLS
9421 case WMA_UPDATE_TDLS_PEER_STATE:
9422 wma_update_tdls_peer_state(wma_handle, msg->bodyptr);
9423 break;
9424 #endif /* FEATURE_WLAN_TDLS */
9425 case WMA_ADD_PERIODIC_TX_PTRN_IND:
9426 wma_process_add_periodic_tx_ptrn_ind(wma_handle,
9427 (tSirAddPeriodicTxPtrn *) msg->bodyptr);
9428 qdf_mem_free(msg->bodyptr);
9429 break;
9430 case WMA_DEL_PERIODIC_TX_PTRN_IND:
9431 wma_process_del_periodic_tx_ptrn_ind(wma_handle,
9432 (tSirDelPeriodicTxPtrn *) msg->bodyptr);
9433 qdf_mem_free(msg->bodyptr);
9434 break;
9435 case WMA_TX_POWER_LIMIT:
9436 wma_process_tx_power_limits(wma_handle, msg->bodyptr);
9437 qdf_mem_free(msg->bodyptr);
9438 break;
9439 case WMA_SEND_ADDBA_REQ:
9440 wma_process_send_addba_req(wma_handle,
9441 (struct send_add_ba_req *)msg->bodyptr);
9442 break;
9443
9444 #ifdef FEATURE_WLAN_CH_AVOID
9445 case WMA_CH_AVOID_UPDATE_REQ:
9446 wma_process_ch_avoid_update_req(wma_handle,
9447 (tSirChAvoidUpdateReq *) msg->bodyptr);
9448 qdf_mem_free(msg->bodyptr);
9449 break;
9450 #endif /* FEATURE_WLAN_CH_AVOID */
9451 #ifdef FEATURE_WLAN_AUTO_SHUTDOWN
9452 case WMA_SET_AUTO_SHUTDOWN_TIMER_REQ:
9453 wma_set_auto_shutdown_timer_req(wma_handle, msg->bodyptr);
9454 qdf_mem_free(msg->bodyptr);
9455 break;
9456 #endif /* FEATURE_WLAN_AUTO_SHUTDOWN */
9457 case WMA_DHCP_START_IND:
9458 case WMA_DHCP_STOP_IND:
9459 wma_process_dhcp_ind(wma_handle, (tAniDHCPInd *) msg->bodyptr);
9460 qdf_mem_free(msg->bodyptr);
9461 break;
9462 case WMA_INIT_THERMAL_INFO_CMD:
9463 wma_process_init_thermal_info(wma_handle,
9464 (t_thermal_mgmt *) msg->bodyptr);
9465 qdf_mem_free(msg->bodyptr);
9466 break;
9467
9468 case WMA_SET_THERMAL_LEVEL:
9469 wma_process_set_thermal_level(wma_handle, msg->bodyval);
9470 break;
9471 #ifdef CONFIG_HL_SUPPORT
9472 case WMA_INIT_BAD_PEER_TX_CTL_INFO_CMD:
9473 wma_process_init_bad_peer_tx_ctl_info(
9474 wma_handle,
9475 (struct t_bad_peer_txtcl_config *)msg->bodyptr);
9476 qdf_mem_free(msg->bodyptr);
9477 break;
9478 #endif
9479 case WMA_SET_MIMOPS_REQ:
9480 wma_process_set_mimops_req(wma_handle,
9481 (tSetMIMOPS *) msg->bodyptr);
9482 qdf_mem_free(msg->bodyptr);
9483 break;
9484 case WMA_SET_SAP_INTRABSS_DIS:
9485 wma_set_vdev_intrabss_fwd(wma_handle,
9486 (tDisableIntraBssFwd *) msg->bodyptr);
9487 qdf_mem_free(msg->bodyptr);
9488 break;
9489 case WMA_GET_ISOLATION:
9490 wma_get_isolation(wma_handle);
9491 break;
9492 case WMA_MODEM_POWER_STATE_IND:
9493 wma_notify_modem_power_state(wma_handle,
9494 (tSirModemPowerStateInd *) msg->bodyptr);
9495 qdf_mem_free(msg->bodyptr);
9496 break;
9497 #ifdef WLAN_FEATURE_STATS_EXT
9498 case WMA_STATS_EXT_REQUEST:
9499 wma_stats_ext_req(wma_handle,
9500 (tpStatsExtRequest) (msg->bodyptr));
9501 qdf_mem_free(msg->bodyptr);
9502 break;
9503 #endif /* WLAN_FEATURE_STATS_EXT */
9504 #ifdef WLAN_FEATURE_EXTWOW_SUPPORT
9505 case WMA_WLAN_EXT_WOW:
9506 wma_enable_ext_wow(wma_handle,
9507 (tSirExtWoWParams *) msg->bodyptr);
9508 qdf_mem_free(msg->bodyptr);
9509 break;
9510 case WMA_WLAN_SET_APP_TYPE1_PARAMS:
9511 wma_set_app_type1_params_in_fw(wma_handle,
9512 (tSirAppType1Params *) msg->bodyptr);
9513 qdf_mem_free(msg->bodyptr);
9514 break;
9515 case WMA_WLAN_SET_APP_TYPE2_PARAMS:
9516 wma_set_app_type2_params_in_fw(wma_handle,
9517 (tSirAppType2Params *) msg->bodyptr);
9518 qdf_mem_free(msg->bodyptr);
9519 break;
9520 #endif /* WLAN_FEATURE_EXTWOW_SUPPORT */
9521 #ifdef FEATURE_WLAN_EXTSCAN
9522 case WMA_EXTSCAN_START_REQ:
9523 wma_start_extscan(wma_handle, msg->bodyptr);
9524 qdf_mem_free(msg->bodyptr);
9525 break;
9526 case WMA_EXTSCAN_STOP_REQ:
9527 wma_stop_extscan(wma_handle, msg->bodyptr);
9528 qdf_mem_free(msg->bodyptr);
9529 break;
9530 case WMA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
9531 wma_extscan_start_hotlist_monitor(wma_handle, msg->bodyptr);
9532 qdf_mem_free(msg->bodyptr);
9533 break;
9534 case WMA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
9535 wma_extscan_stop_hotlist_monitor(wma_handle, msg->bodyptr);
9536 qdf_mem_free(msg->bodyptr);
9537 break;
9538 case WMA_EXTSCAN_SET_SIGNF_CHANGE_REQ:
9539 wma_extscan_start_change_monitor(wma_handle, msg->bodyptr);
9540 qdf_mem_free(msg->bodyptr);
9541 break;
9542 case WMA_EXTSCAN_RESET_SIGNF_CHANGE_REQ:
9543 wma_extscan_stop_change_monitor(wma_handle, msg->bodyptr);
9544 qdf_mem_free(msg->bodyptr);
9545 break;
9546 case WMA_EXTSCAN_GET_CACHED_RESULTS_REQ:
9547 wma_extscan_get_cached_results(wma_handle, msg->bodyptr);
9548 qdf_mem_free(msg->bodyptr);
9549 break;
9550 case WMA_EXTSCAN_GET_CAPABILITIES_REQ:
9551 wma_extscan_get_capabilities(wma_handle, msg->bodyptr);
9552 qdf_mem_free(msg->bodyptr);
9553 break;
9554 case WMA_SET_EPNO_LIST_REQ:
9555 wma_set_epno_network_list(wma_handle, msg->bodyptr);
9556 qdf_mem_free(msg->bodyptr);
9557 break;
9558 case WMA_SET_PASSPOINT_LIST_REQ:
9559 /* Issue reset passpoint network list first and clear
9560 * the entries
9561 */
9562 wma_reset_passpoint_network_list(wma_handle, msg->bodyptr);
9563
9564 wma_set_passpoint_network_list(wma_handle, msg->bodyptr);
9565 qdf_mem_free(msg->bodyptr);
9566 break;
9567 case WMA_RESET_PASSPOINT_LIST_REQ:
9568 wma_reset_passpoint_network_list(wma_handle, msg->bodyptr);
9569 qdf_mem_free(msg->bodyptr);
9570 break;
9571 #endif /* FEATURE_WLAN_EXTSCAN */
9572 case WMA_SET_SCAN_MAC_OUI_REQ:
9573 wma_scan_probe_setoui(wma_handle, msg->bodyptr);
9574 qdf_mem_free(msg->bodyptr);
9575 break;
9576 #ifdef WLAN_FEATURE_LINK_LAYER_STATS
9577 case WMA_LINK_LAYER_STATS_CLEAR_REQ:
9578 wma_process_ll_stats_clear_req(wma_handle,
9579 (tpSirLLStatsClearReq) msg->bodyptr);
9580 qdf_mem_free(msg->bodyptr);
9581 break;
9582 case WMA_LINK_LAYER_STATS_SET_REQ:
9583 wma_process_ll_stats_set_req(wma_handle,
9584 (tpSirLLStatsSetReq) msg->bodyptr);
9585 qdf_mem_free(msg->bodyptr);
9586 break;
9587 case WMA_LINK_LAYER_STATS_GET_REQ:
9588 wma_process_ll_stats_get_req(wma_handle,
9589 (tpSirLLStatsGetReq) msg->bodyptr);
9590 qdf_mem_free(msg->bodyptr);
9591 break;
9592 case WDA_LINK_LAYER_STATS_SET_THRESHOLD:
9593 wma_config_stats_ext_threshold(wma_handle,
9594 (struct sir_ll_ext_stats_threshold *)msg->bodyptr);
9595 qdf_mem_free(msg->bodyptr);
9596 break;
9597 #endif /* WLAN_FEATURE_LINK_LAYER_STATS */
9598 case SIR_HAL_SET_BASE_MACADDR_IND:
9599 wma_set_base_macaddr_indicate(wma_handle,
9600 (tSirMacAddr *) msg->bodyptr);
9601 qdf_mem_free(msg->bodyptr);
9602 break;
9603 case WMA_LINK_STATUS_GET_REQ:
9604 wma_process_link_status_req(wma_handle,
9605 (tAniGetLinkStatus *) msg->bodyptr);
9606 break;
9607 case WMA_GET_TEMPERATURE_REQ:
9608 wma_get_temperature(wma_handle);
9609 qdf_mem_free(msg->bodyptr);
9610 break;
9611 case WMA_TSF_GPIO_PIN:
9612 wma_set_tsf_gpio_pin(wma_handle, msg->bodyval);
9613 break;
9614
9615 #ifdef DHCP_SERVER_OFFLOAD
9616 case WMA_SET_DHCP_SERVER_OFFLOAD_CMD:
9617 wma_process_dhcpserver_offload(wma_handle, msg->bodyptr);
9618 qdf_mem_free(msg->bodyptr);
9619 break;
9620 #endif /* DHCP_SERVER_OFFLOAD */
9621 #ifdef WLAN_FEATURE_GPIO_LED_FLASHING
9622 case WMA_LED_FLASHING_REQ:
9623 wma_set_led_flashing(wma_handle, msg->bodyptr);
9624 qdf_mem_free(msg->bodyptr);
9625 break;
9626 #endif /* WLAN_FEATURE_GPIO_LED_FLASHING */
9627 case SIR_HAL_SET_MAS:
9628 wma_process_set_mas(wma_handle,
9629 (uint32_t *)msg->bodyptr);
9630 qdf_mem_free(msg->bodyptr);
9631 break;
9632 case SIR_HAL_SET_MIRACAST:
9633 wma_process_set_miracast(wma_handle,
9634 (uint32_t *)msg->bodyptr);
9635 qdf_mem_free(msg->bodyptr);
9636 break;
9637 case SIR_HAL_CONFIG_STATS_FACTOR:
9638 wma_config_stats_factor(wma_handle,
9639 (struct sir_stats_avg_factor *)
9640 msg->bodyptr);
9641 qdf_mem_free(msg->bodyptr);
9642 break;
9643 case SIR_HAL_CONFIG_GUARD_TIME:
9644 wma_config_guard_time(wma_handle,
9645 (struct sir_guard_time_request *)
9646 msg->bodyptr);
9647 qdf_mem_free(msg->bodyptr);
9648 break;
9649 case SIR_HAL_START_STOP_LOGGING:
9650 wma_set_wifi_start_packet_stats(wma_handle,
9651 (struct sir_wifi_start_log *)msg->bodyptr);
9652 wma_enable_specific_fw_logs(wma_handle,
9653 (struct sir_wifi_start_log *)msg->bodyptr);
9654 qdf_mem_free(msg->bodyptr);
9655 break;
9656 case SIR_HAL_FLUSH_LOG_TO_FW:
9657 wma_send_flush_logs_to_fw(wma_handle);
9658 /* Body ptr is NULL here */
9659 break;
9660 case WMA_SET_RSSI_MONITOR_REQ:
9661 wma_set_rssi_monitoring(wma_handle, msg->bodyptr);
9662 qdf_mem_free(msg->bodyptr);
9663 break;
9664 case SIR_HAL_SET_PCL_TO_FW:
9665 wma_send_set_pcl_cmd(wma_handle,
9666 (struct set_pcl_req *)msg->bodyptr);
9667 qdf_mem_free(msg->bodyptr);
9668 break;
9669 case SIR_HAL_PDEV_SET_HW_MODE:
9670 wma_send_pdev_set_hw_mode_cmd(wma_handle,
9671 (struct policy_mgr_hw_mode *)msg->bodyptr);
9672 qdf_mem_free(msg->bodyptr);
9673 break;
9674 case WMA_SET_WISA_PARAMS:
9675 wma_set_wisa_params(wma_handle,
9676 (struct sir_wisa_params *)msg->bodyptr);
9677 qdf_mem_free(msg->bodyptr);
9678 break;
9679 case SIR_HAL_PDEV_DUAL_MAC_CFG_REQ:
9680 wma_send_pdev_set_dual_mac_config(wma_handle,
9681 (struct policy_mgr_dual_mac_config *)msg->bodyptr);
9682 qdf_mem_free(msg->bodyptr);
9683 break;
9684 case WMA_SET_IE_INFO:
9685 wma_process_set_ie_info(wma_handle,
9686 (struct vdev_ie_info *)msg->bodyptr);
9687 qdf_mem_free(msg->bodyptr);
9688 break;
9689 case WMA_CFG_VENDOR_ACTION_TB_PPDU:
9690 wma_process_cfg_action_frm_tb_ppdu(wma_handle, msg->bodyptr);
9691 qdf_mem_free(msg->bodyptr);
9692 break;
9693 case SIR_HAL_SOC_ANTENNA_MODE_REQ:
9694 wma_send_pdev_set_antenna_mode(wma_handle,
9695 (struct sir_antenna_mode_param *)msg->bodyptr);
9696 qdf_mem_free(msg->bodyptr);
9697 break;
9698 case WMA_GW_PARAM_UPDATE_REQ:
9699 wma_set_gateway_params(wma_handle, msg->bodyptr);
9700 qdf_mem_free(msg->bodyptr);
9701 break;
9702 case WMA_SET_ADAPT_DWELLTIME_CONF_PARAMS:
9703 wma_send_adapt_dwelltime_params(wma_handle,
9704 (struct adaptive_dwelltime_params *)msg->bodyptr);
9705 qdf_mem_free(msg->bodyptr);
9706 break;
9707 case WMA_HT40_OBSS_SCAN_IND:
9708 wma_send_ht40_obss_scanind(wma_handle,
9709 (struct obss_ht40_scanind *)msg->bodyptr);
9710 qdf_mem_free(msg->bodyptr);
9711 break;
9712 case WMA_ADD_BCN_FILTER_CMDID:
9713 wma_add_beacon_filter(wma_handle, msg->bodyptr);
9714 qdf_mem_free(msg->bodyptr);
9715 break;
9716 case WMA_REMOVE_BCN_FILTER_CMDID:
9717 wma_remove_beacon_filter(wma_handle, msg->bodyptr);
9718 qdf_mem_free(msg->bodyptr);
9719 break;
9720 case WDA_APF_GET_CAPABILITIES_REQ:
9721 wma_get_apf_capabilities(wma_handle);
9722 break;
9723 case SIR_HAL_POWER_DBG_CMD:
9724 wma_process_hal_pwr_dbg_cmd(wma_handle,
9725 msg->bodyptr);
9726 qdf_mem_free(msg->bodyptr);
9727 break;
9728 case WMA_SEND_FREQ_RANGE_CONTROL_IND:
9729 wma_enable_disable_caevent_ind(wma_handle, msg->bodyval);
9730 break;
9731 case SIR_HAL_UPDATE_TX_FAIL_CNT_TH:
9732 wma_update_tx_fail_cnt_th(wma_handle, msg->bodyptr);
9733 qdf_mem_free(msg->bodyptr);
9734 break;
9735 case SIR_HAL_LONG_RETRY_LIMIT_CNT:
9736 wma_update_long_retry_limit(wma_handle, msg->bodyptr);
9737 qdf_mem_free(msg->bodyptr);
9738 break;
9739 case SIR_HAL_SHORT_RETRY_LIMIT_CNT:
9740 wma_update_short_retry_limit(wma_handle, msg->bodyptr);
9741 qdf_mem_free(msg->bodyptr);
9742 break;
9743 case SIR_HAL_POWER_DEBUG_STATS_REQ:
9744 wma_process_power_debug_stats_req(wma_handle);
9745 break;
9746 case WMA_BEACON_DEBUG_STATS_REQ:
9747 wma_process_beacon_debug_stats_req(wma_handle, msg->bodyptr);
9748 qdf_mem_free(msg->bodyptr);
9749 break;
9750 case WMA_GET_RCPI_REQ:
9751 wma_get_rcpi_req(wma_handle,
9752 (struct sme_rcpi_req *)msg->bodyptr);
9753 qdf_mem_free(msg->bodyptr);
9754 break;
9755 case WMA_SET_WOW_PULSE_CMD:
9756 wma_send_wow_pulse_cmd(wma_handle,
9757 (struct wow_pulse_mode *)msg->bodyptr);
9758 qdf_mem_free(msg->bodyptr);
9759 break;
9760 case WMA_SET_DBS_SCAN_SEL_CONF_PARAMS:
9761 wma_send_dbs_scan_selection_params(wma_handle,
9762 (struct wmi_dbs_scan_sel_params *)msg->bodyptr);
9763 qdf_mem_free(msg->bodyptr);
9764 break;
9765 case WMA_SET_ARP_STATS_REQ:
9766 wma_set_arp_req_stats(wma_handle,
9767 (struct set_arp_stats_params *)msg->bodyptr);
9768 qdf_mem_free(msg->bodyptr);
9769 break;
9770 case WMA_GET_ARP_STATS_REQ:
9771 wma_get_arp_req_stats(wma_handle,
9772 (struct get_arp_stats_params *)msg->bodyptr);
9773 qdf_mem_free(msg->bodyptr);
9774 break;
9775 case SIR_HAL_SET_DEL_PMKID_CACHE:
9776 wma_set_del_pmkid_cache(wma_handle, msg->bodyptr);
9777 if (msg->bodyptr) {
9778 qdf_mem_zero(msg->bodyptr,
9779 sizeof(struct wmi_unified_pmk_cache));
9780 qdf_mem_free(msg->bodyptr);
9781 }
9782 break;
9783 case SIR_HAL_HLP_IE_INFO:
9784 wma_roam_scan_send_hlp(wma_handle,
9785 (struct hlp_params *)msg->bodyptr);
9786 qdf_mem_free(msg->bodyptr);
9787 break;
9788 case WMA_SET_LIMIT_OFF_CHAN:
9789 wma_process_limit_off_chan(wma_handle, msg->bodyptr);
9790 qdf_mem_free(msg->bodyptr);
9791 break;
9792 case WMA_OBSS_DETECTION_REQ:
9793 wma_send_obss_detection_cfg(wma_handle, msg->bodyptr);
9794 qdf_mem_free(msg->bodyptr);
9795 break;
9796 case WMA_INVOKE_NEIGHBOR_REPORT:
9797 wma_send_invoke_neighbor_report(wma_handle, msg->bodyptr);
9798 qdf_mem_free(msg->bodyptr);
9799 break;
9800 case WMA_OBSS_COLOR_COLLISION_REQ:
9801 wma_process_obss_color_collision_req(wma_handle, msg->bodyptr);
9802 qdf_mem_free(msg->bodyptr);
9803 break;
9804 case WMA_GET_ROAM_SCAN_STATS:
9805 wma_get_roam_scan_stats(wma_handle, msg->bodyptr);
9806 qdf_mem_free(msg->bodyptr);
9807 break;
9808 #ifdef WLAN_FEATURE_MOTION_DETECTION
9809 case WMA_SET_MOTION_DET_CONFIG:
9810 wma_set_motion_det_config(
9811 wma_handle,
9812 (struct sme_motion_det_cfg *)msg->bodyptr);
9813 qdf_mem_free(msg->bodyptr);
9814 break;
9815 case WMA_SET_MOTION_DET_ENABLE:
9816 wma_set_motion_det_enable(
9817 wma_handle,
9818 (struct sme_motion_det_en *)msg->bodyptr);
9819 qdf_mem_free(msg->bodyptr);
9820 break;
9821 case WMA_SET_MOTION_DET_BASE_LINE_CONFIG:
9822 wma_set_motion_det_base_line_config(
9823 wma_handle,
9824 (struct sme_motion_det_base_line_cfg *)msg->bodyptr);
9825 qdf_mem_free(msg->bodyptr);
9826 break;
9827 case WMA_SET_MOTION_DET_BASE_LINE_ENABLE:
9828 wma_set_motion_det_base_line_enable(
9829 wma_handle,
9830 (struct sme_motion_det_base_line_en *)msg->bodyptr);
9831 qdf_mem_free(msg->bodyptr);
9832 break;
9833 #endif /* WLAN_FEATURE_MOTION_DETECTION */
9834 #ifdef FW_THERMAL_THROTTLE_SUPPORT
9835 case WMA_SET_THERMAL_THROTTLE_CFG:
9836 if (!wma_handle->thermal_mgmt_info.thermalMgmtEnabled)
9837 wmi_unified_thermal_mitigation_param_cmd_send(
9838 wma_handle->wmi_handle, msg->bodyptr);
9839 else
9840 qdf_status = QDF_STATUS_E_INVAL;
9841 qdf_mem_free(msg->bodyptr);
9842 break;
9843 case WMA_SET_THERMAL_MGMT:
9844 if (!wma_handle->thermal_mgmt_info.thermalMgmtEnabled)
9845 wma_set_thermal_mgmt(
9846 wma_handle,
9847 *((t_thermal_cmd_params *)msg->bodyptr));
9848 else
9849 qdf_status = QDF_STATUS_E_INVAL;
9850 qdf_mem_free(msg->bodyptr);
9851 break;
9852 #endif /* FW_THERMAL_THROTTLE_SUPPORT */
9853 #ifdef WLAN_MWS_INFO_DEBUGFS
9854 case WMA_GET_MWS_COEX_INFO_REQ:
9855 wma_get_mws_coex_info_req(wma_handle, msg->bodyptr);
9856 qdf_mem_free(msg->bodyptr);
9857 break;
9858 #endif
9859 case WMA_ROAM_SCAN_CH_REQ:
9860 wma_get_roam_scan_ch(wma_handle->wmi_handle, msg->bodyval);
9861 break;
9862 case WMA_TWT_ADD_DIALOG_REQUEST:
9863 wma_twt_process_add_dialog(wma_handle, msg->bodyptr);
9864 qdf_mem_free(msg->bodyptr);
9865 break;
9866 case WMA_TWT_DEL_DIALOG_REQUEST:
9867 wma_twt_process_del_dialog(wma_handle, msg->bodyptr);
9868 qdf_mem_free(msg->bodyptr);
9869 break;
9870 case WMA_TWT_PAUSE_DIALOG_REQUEST:
9871 wma_twt_process_pause_dialog(wma_handle, msg->bodyptr);
9872 qdf_mem_free(msg->bodyptr);
9873 break;
9874 case WMA_TWT_RESUME_DIALOG_REQUEST:
9875 wma_twt_process_resume_dialog(wma_handle, msg->bodyptr);
9876 qdf_mem_free(msg->bodyptr);
9877 break;
9878 case WMA_TWT_NUDGE_DIALOG_REQUEST:
9879 wma_twt_process_nudge_dialog(wma_handle, msg->bodyptr);
9880 qdf_mem_free(msg->bodyptr);
9881 break;
9882 case WMA_UPDATE_EDCA_PIFS_PARAM_IND:
9883 wma_update_edca_pifs_param(
9884 wma_handle,
9885 (struct edca_pifs_vparam *)msg->bodyptr);
9886 qdf_mem_free(msg->bodyptr);
9887 break;
9888 default:
9889 wma_debug("Unhandled WMA message of type %d", msg->type);
9890 if (msg->bodyptr)
9891 qdf_mem_free(msg->bodyptr);
9892 }
9893 end:
9894 return qdf_status;
9895 }
9896
wma_mc_process_handler(struct scheduler_msg * msg)9897 QDF_STATUS wma_mc_process_handler(struct scheduler_msg *msg)
9898 {
9899 return wma_mc_process_msg(msg);
9900 }
9901
9902 /**
9903 * wma_log_completion_timeout() - Log completion timeout
9904 * @data: Timeout handler data
9905 *
9906 * This function is called when log completion timer expires
9907 *
9908 * Return: None
9909 */
wma_log_completion_timeout(void * data)9910 void wma_log_completion_timeout(void *data)
9911 {
9912 wma_debug("Timeout occurred for log completion command");
9913
9914 /* Though we did not receive any event from FW,
9915 * we can flush whatever logs we have with us
9916 */
9917 cds_logging_set_fw_flush_complete();
9918 }
9919
9920 /**
9921 * wma_map_pcl_weights() - Map PCL weights
9922 * @pcl_weight: Internal PCL weights
9923 *
9924 * Maps the internal weights of PCL to the weights needed by FW
9925 *
9926 * Return: Mapped channel weight of type wmi_pcl_chan_weight
9927 */
wma_map_pcl_weights(uint32_t pcl_weight)9928 wmi_pcl_chan_weight wma_map_pcl_weights(uint32_t pcl_weight)
9929 {
9930 switch (pcl_weight) {
9931 case WEIGHT_OF_GROUP1_PCL_CHANNELS:
9932 return WMI_PCL_WEIGHT_VERY_HIGH;
9933 case WEIGHT_OF_GROUP2_PCL_CHANNELS:
9934 return WMI_PCL_WEIGHT_HIGH;
9935 case WEIGHT_OF_GROUP3_PCL_CHANNELS:
9936 return WMI_PCL_WEIGHT_MEDIUM;
9937 case WEIGHT_OF_GROUP4_PCL_CHANNELS:
9938 return WMI_PCL_WEIGHT_MEDIUM;
9939 case WEIGHT_OF_NON_PCL_CHANNELS:
9940 return WMI_PCL_WEIGHT_LOW;
9941 default:
9942 return WMI_PCL_WEIGHT_DISALLOW;
9943 }
9944 }
9945
9946 /**
9947 * wma_send_set_pcl_cmd() - Send WMI_SOC_SET_PCL_CMDID to FW
9948 * @wma_handle: WMA handle
9949 * @msg: PCL structure containing the PCL and the number of channels
9950 *
9951 * WMI_PDEV_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN
9952 * firmware. The DBS Manager is the consumer of this information in the WLAN
9953 * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs
9954 * to migrate to a new channel without host driver involvement. An example of
9955 * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will
9956 * manage the channel selection without firmware involvement.
9957 *
9958 * WMI_PDEV_SET_PCL_CMDID will carry only the weight list and not the actual
9959 * channel list. The weights corresponds to the channels sent in
9960 * WMI_SCAN_CHAN_LIST_CMDID. The channels from PCL would be having a higher
9961 * weightage compared to the non PCL channels.
9962 *
9963 * Return: Success if the cmd is sent successfully to the firmware
9964 */
wma_send_set_pcl_cmd(tp_wma_handle wma_handle,struct set_pcl_req * msg)9965 QDF_STATUS wma_send_set_pcl_cmd(tp_wma_handle wma_handle,
9966 struct set_pcl_req *msg)
9967 {
9968 uint32_t i;
9969 QDF_STATUS status;
9970 bool is_channel_allowed;
9971
9972 if (wma_validate_handle(wma_handle))
9973 return QDF_STATUS_E_NULL_VALUE;
9974
9975 /*
9976 * if vdev_id is WLAN_UMAC_VDEV_ID_MAX, then roaming is enabled on
9977 * only one sta, so PDEV PCL command needs to be sent.
9978 * If a valid vdev id is present, then vdev pcl command needs to be
9979 * sent.
9980 */
9981 if (msg->vdev_id != WLAN_UMAC_VDEV_ID_MAX)
9982 return wlan_cm_roam_send_set_vdev_pcl(wma_handle->psoc, msg);
9983
9984
9985 wma_debug("RSO_CFG: BandCapability:%d, band_mask:%d",
9986 wma_handle->bandcapability, msg->band_mask);
9987 for (i = 0; i < wma_handle->saved_chan.num_channels; i++) {
9988 msg->chan_weights.saved_chan_list[i] =
9989 wma_handle->saved_chan.ch_freq_list[i];
9990 }
9991
9992 msg->chan_weights.saved_num_chan = wma_handle->saved_chan.num_channels;
9993
9994 status = policy_mgr_get_valid_chan_weights(wma_handle->psoc,
9995 (struct policy_mgr_pcl_chan_weights *)&msg->chan_weights,
9996 PM_STA_MODE, NULL);
9997 if (QDF_IS_STATUS_ERROR(status)) {
9998 wma_err("Error in creating weighed pcl");
9999 return status;
10000 }
10001
10002 for (i = 0; i < msg->chan_weights.saved_num_chan; i++) {
10003 msg->chan_weights.weighed_valid_list[i] =
10004 wma_map_pcl_weights(
10005 msg->chan_weights.weighed_valid_list[i]);
10006
10007 is_channel_allowed =
10008 policy_mgr_is_sta_chan_valid_for_connect_and_roam(
10009 wma_handle->pdev,
10010 msg->chan_weights.saved_chan_list[i]);
10011 if (!is_channel_allowed) {
10012 msg->chan_weights.weighed_valid_list[i] =
10013 WEIGHT_OF_DISALLOWED_CHANNELS;
10014 continue;
10015 }
10016
10017 if (msg->band_mask ==
10018 (BIT(REG_BAND_2G) | BIT(REG_BAND_5G) | BIT(REG_BAND_6G)))
10019 continue;
10020
10021 /*
10022 * Dont allow roaming on 5G/6G band if only 2G band configured
10023 * as supported roam band mask
10024 */
10025 if (((wma_handle->bandcapability == BAND_2G) ||
10026 (msg->band_mask == BIT(REG_BAND_2G))) &&
10027 !WLAN_REG_IS_24GHZ_CH_FREQ(
10028 msg->chan_weights.saved_chan_list[i])) {
10029 msg->chan_weights.weighed_valid_list[i] =
10030 WEIGHT_OF_DISALLOWED_CHANNELS;
10031 continue;
10032 }
10033
10034 /*
10035 * Dont allow roaming on 2G/6G band if only 5G band configured
10036 * as supported roam band mask
10037 */
10038 if (((wma_handle->bandcapability == BAND_5G) ||
10039 (msg->band_mask == BIT(REG_BAND_5G))) &&
10040 !WLAN_REG_IS_5GHZ_CH_FREQ(
10041 msg->chan_weights.saved_chan_list[i])) {
10042 msg->chan_weights.weighed_valid_list[i] =
10043 WEIGHT_OF_DISALLOWED_CHANNELS;
10044 continue;
10045 }
10046
10047 /*
10048 * Dont allow roaming on 2G/5G band if only 6G band configured
10049 * as supported roam band mask
10050 */
10051 if (msg->band_mask == BIT(REG_BAND_6G) &&
10052 !WLAN_REG_IS_6GHZ_CHAN_FREQ(
10053 msg->chan_weights.saved_chan_list[i])) {
10054 msg->chan_weights.weighed_valid_list[i] =
10055 WEIGHT_OF_DISALLOWED_CHANNELS;
10056 continue;
10057 }
10058
10059 /*
10060 * Dont allow roaming on 6G band if only 2G + 5G band configured
10061 * as supported roam band mask.
10062 */
10063 if (msg->band_mask == (BIT(REG_BAND_2G) | BIT(REG_BAND_5G)) &&
10064 (WLAN_REG_IS_6GHZ_CHAN_FREQ(
10065 msg->chan_weights.saved_chan_list[i]))) {
10066 msg->chan_weights.weighed_valid_list[i] =
10067 WEIGHT_OF_DISALLOWED_CHANNELS;
10068 continue;
10069 }
10070
10071 /*
10072 * Dont allow roaming on 2G band if only 5G + 6G band configured
10073 * as supported roam band mask.
10074 */
10075 if (msg->band_mask == (BIT(REG_BAND_5G) | BIT(REG_BAND_6G)) &&
10076 (WLAN_REG_IS_24GHZ_CH_FREQ(
10077 msg->chan_weights.saved_chan_list[i]))) {
10078 msg->chan_weights.weighed_valid_list[i] =
10079 WEIGHT_OF_DISALLOWED_CHANNELS;
10080 continue;
10081 }
10082
10083 /*
10084 * Dont allow roaming on 5G band if only 2G + 6G band configured
10085 * as supported roam band mask.
10086 */
10087 if (msg->band_mask == (BIT(REG_BAND_2G) | BIT(REG_BAND_6G)) &&
10088 (WLAN_REG_IS_5GHZ_CH_FREQ(
10089 msg->chan_weights.saved_chan_list[i]))) {
10090 msg->chan_weights.weighed_valid_list[i] =
10091 WEIGHT_OF_DISALLOWED_CHANNELS;
10092 continue;
10093 }
10094 }
10095
10096 wma_debug("RSO_CFG: Dump PDEV PCL weights for vdev[%d]", msg->vdev_id);
10097 policy_mgr_dump_channel_list(msg->chan_weights.saved_num_chan,
10098 msg->chan_weights.saved_chan_list,
10099 msg->chan_weights.weighed_valid_list);
10100
10101 if (wmi_unified_pdev_set_pcl_cmd(wma_handle->wmi_handle,
10102 &msg->chan_weights))
10103 return QDF_STATUS_E_FAILURE;
10104
10105 return QDF_STATUS_SUCCESS;
10106 }
10107
10108 /**
10109 * wma_send_pdev_set_hw_mode_cmd() - Send WMI_PDEV_SET_HW_MODE_CMDID to FW
10110 * @wma_handle: WMA handle
10111 * @msg: Structure containing the following parameters
10112 *
10113 * - hw_mode_index: The HW_Mode field is a enumerated type that is selected
10114 * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID.
10115 *
10116 * Provides notification to the WLAN firmware that host driver is requesting a
10117 * HardWare (HW) Mode change. This command is needed to support iHelium in the
10118 * configurations that include the Dual Band Simultaneous (DBS) feature.
10119 *
10120 * Return: Success if the cmd is sent successfully to the firmware
10121 */
wma_send_pdev_set_hw_mode_cmd(tp_wma_handle wma_handle,struct policy_mgr_hw_mode * msg)10122 QDF_STATUS wma_send_pdev_set_hw_mode_cmd(tp_wma_handle wma_handle,
10123 struct policy_mgr_hw_mode *msg)
10124 {
10125 struct sir_set_hw_mode_resp *param;
10126 struct wma_target_req *timeout_msg;
10127
10128 if (wma_validate_handle(wma_handle)) {
10129 /* Handle is NULL. Will not be able to send failure
10130 * response as well
10131 */
10132 return QDF_STATUS_E_NULL_VALUE;
10133 }
10134
10135 if (!msg) {
10136 wma_err("Set HW mode param is NULL");
10137 /* Lets try to free the active command list */
10138 goto fail;
10139 }
10140
10141 wma_acquire_wakelock(&wma_handle->wmi_cmd_rsp_wake_lock,
10142 WMA_VDEV_HW_MODE_REQUEST_TIMEOUT);
10143 if (wmi_unified_soc_set_hw_mode_cmd(wma_handle->wmi_handle,
10144 msg->hw_mode_index)) {
10145 wma_release_wakelock(&wma_handle->wmi_cmd_rsp_wake_lock);
10146 goto fail;
10147 }
10148 timeout_msg = wma_fill_hold_req(wma_handle, 0,
10149 SIR_HAL_PDEV_SET_HW_MODE,
10150 WMA_PDEV_SET_HW_MODE_RESP, NULL,
10151 WMA_VDEV_HW_MODE_REQUEST_TIMEOUT - 1);
10152 if (!timeout_msg) {
10153 wma_err("Failed to allocate request for SIR_HAL_PDEV_SET_HW_MODE");
10154 wma_remove_req(wma_handle, 0, WMA_PDEV_SET_HW_MODE_RESP);
10155 }
10156
10157 return QDF_STATUS_SUCCESS;
10158 fail:
10159 param = qdf_mem_malloc(sizeof(*param));
10160 if (!param)
10161 return QDF_STATUS_E_NULL_VALUE;
10162
10163 param->status = SET_HW_MODE_STATUS_ECANCELED;
10164 param->cfgd_hw_mode_index = 0;
10165 param->num_vdev_mac_entries = 0;
10166 wma_debug("Sending HW mode fail response to LIM");
10167 wma_send_msg(wma_handle, SIR_HAL_PDEV_SET_HW_MODE_RESP,
10168 (void *) param, 0);
10169 return QDF_STATUS_E_FAILURE;
10170 }
10171
10172 /**
10173 * wma_send_pdev_set_dual_mac_config() - Set dual mac config to FW
10174 * @wma_handle: WMA handle
10175 * @msg: Dual MAC config parameters
10176 *
10177 * Configures WLAN firmware with the dual MAC features
10178 *
10179 * Return: QDF_STATUS. 0 on success.
10180 */
wma_send_pdev_set_dual_mac_config(tp_wma_handle wma_handle,struct policy_mgr_dual_mac_config * msg)10181 QDF_STATUS wma_send_pdev_set_dual_mac_config(tp_wma_handle wma_handle,
10182 struct policy_mgr_dual_mac_config *msg)
10183 {
10184 QDF_STATUS status;
10185 struct wma_target_req *req_msg;
10186 struct sir_dual_mac_config_resp *resp;
10187
10188 if (wma_validate_handle(wma_handle))
10189 return QDF_STATUS_E_NULL_VALUE;
10190
10191 if (!msg) {
10192 wma_err("Set dual mode config is NULL");
10193 return QDF_STATUS_E_NULL_VALUE;
10194 }
10195
10196 req_msg = wma_fill_hold_req(wma_handle, 0,
10197 SIR_HAL_PDEV_DUAL_MAC_CFG_REQ,
10198 WMA_PDEV_MAC_CFG_RESP, NULL,
10199 WMA_VDEV_DUAL_MAC_CFG_TIMEOUT);
10200 if (!req_msg) {
10201 wma_err("Failed to allocate request for SIR_HAL_PDEV_DUAL_MAC_CFG_REQ");
10202 return QDF_STATUS_E_FAILURE;
10203 }
10204
10205 /*
10206 * acquire the wake lock here and release it in response handler function
10207 * In error condition, release the wake lock right away
10208 */
10209 wma_acquire_wakelock(&wma_handle->wmi_cmd_rsp_wake_lock,
10210 WMA_VDEV_PLCY_MGR_WAKE_LOCK_TIMEOUT);
10211 status = wmi_unified_pdev_set_dual_mac_config_cmd(
10212 wma_handle->wmi_handle,
10213 (struct policy_mgr_dual_mac_config *)msg);
10214 if (QDF_IS_STATUS_ERROR(status)) {
10215 wma_err("Failed to send WMI_PDEV_SET_DUAL_MAC_CONFIG_CMDID: %d",
10216 status);
10217 wma_release_wakelock(&wma_handle->wmi_cmd_rsp_wake_lock);
10218 wma_remove_req(wma_handle, 0, WMA_PDEV_MAC_CFG_RESP);
10219 goto fail;
10220 }
10221 policy_mgr_update_dbs_req_config(wma_handle->psoc,
10222 msg->scan_config, msg->fw_mode_config);
10223
10224 return QDF_STATUS_SUCCESS;
10225
10226 fail:
10227 resp = qdf_mem_malloc(sizeof(*resp));
10228 if (!resp)
10229 return QDF_STATUS_E_NULL_VALUE;
10230
10231 resp->status = SET_HW_MODE_STATUS_ECANCELED;
10232 wma_debug("Sending failure response to LIM");
10233 wma_send_msg(wma_handle, SIR_HAL_PDEV_MAC_CFG_RESP, (void *) resp, 0);
10234
10235 return QDF_STATUS_E_FAILURE;
10236 }
10237
10238 /**
10239 * wma_send_pdev_set_antenna_mode() - Set antenna mode to FW
10240 * @wma_handle: WMA handle
10241 * @msg: Antenna mode parameters
10242 *
10243 * Send WMI_PDEV_SET_ANTENNA_MODE_CMDID to FW requesting to
10244 * modify the number of TX/RX chains from host
10245 *
10246 * Return: QDF_STATUS. 0 on success.
10247 */
wma_send_pdev_set_antenna_mode(tp_wma_handle wma_handle,struct sir_antenna_mode_param * msg)10248 QDF_STATUS wma_send_pdev_set_antenna_mode(tp_wma_handle wma_handle,
10249 struct sir_antenna_mode_param *msg)
10250 {
10251 wmi_pdev_set_antenna_mode_cmd_fixed_param *cmd;
10252 wmi_buf_t buf;
10253 uint32_t len;
10254 QDF_STATUS status = QDF_STATUS_SUCCESS;
10255 struct sir_antenna_mode_resp *param;
10256
10257 if (wma_validate_handle(wma_handle))
10258 return QDF_STATUS_E_NULL_VALUE;
10259
10260 if (!msg) {
10261 wma_err("Set antenna mode param is NULL");
10262 return QDF_STATUS_E_NULL_VALUE;
10263 }
10264
10265 len = sizeof(*cmd);
10266
10267 buf = wmi_buf_alloc(wma_handle->wmi_handle, len);
10268 if (!buf) {
10269 status = QDF_STATUS_E_NOMEM;
10270 goto resp;
10271 }
10272
10273 cmd = (wmi_pdev_set_antenna_mode_cmd_fixed_param *) wmi_buf_data(buf);
10274 WMITLV_SET_HDR(&cmd->tlv_header,
10275 WMITLV_TAG_STRUC_wmi_pdev_set_antenna_mode_cmd_fixed_param,
10276 WMITLV_GET_STRUCT_TLVLEN(
10277 wmi_pdev_set_antenna_mode_cmd_fixed_param));
10278
10279 cmd->pdev_id = OL_TXRX_PDEV_ID;
10280 /* Bits 0-15 is num of RX chains 16-31 is num of TX chains */
10281 cmd->num_txrx_chains = msg->num_rx_chains;
10282 cmd->num_txrx_chains |= (msg->num_tx_chains << 16);
10283
10284 wma_debug("Num of chains TX: %d RX: %d txrx_chains: 0x%x",
10285 msg->num_tx_chains,
10286 msg->num_rx_chains, cmd->num_txrx_chains);
10287
10288 if (wmi_unified_cmd_send(wma_handle->wmi_handle, buf, len,
10289 WMI_PDEV_SET_ANTENNA_MODE_CMDID)) {
10290 wmi_buf_free(buf);
10291 status = QDF_STATUS_E_FAILURE;
10292 goto resp;
10293 }
10294 status = QDF_STATUS_SUCCESS;
10295
10296 resp:
10297 param = qdf_mem_malloc(sizeof(*param));
10298 if (!param)
10299 return QDF_STATUS_E_NOMEM;
10300
10301 param->status = (status) ?
10302 SET_ANTENNA_MODE_STATUS_ECANCELED :
10303 SET_ANTENNA_MODE_STATUS_OK;
10304 wma_debug("Send antenna mode resp to LIM status: %d",
10305 param->status);
10306 wma_send_msg(wma_handle, SIR_HAL_SOC_ANTENNA_MODE_RESP,
10307 (void *) param, 0);
10308 return status;
10309 }
10310
10311 /**
10312 * wma_crash_inject() - sends command to FW to simulate crash
10313 * @wma_handle: pointer of WMA context
10314 * @type: subtype of the command
10315 * @delay_time_ms: time in milliseconds for FW to delay the crash
10316 *
10317 * This function will send a command to FW in order to simulate different
10318 * kinds of FW crashes.
10319 *
10320 * Return: QDF_STATUS_SUCCESS for success or error code
10321 */
wma_crash_inject(WMA_HANDLE wma_handle,uint32_t type,uint32_t delay_time_ms)10322 QDF_STATUS wma_crash_inject(WMA_HANDLE wma_handle, uint32_t type,
10323 uint32_t delay_time_ms)
10324 {
10325 struct crash_inject param;
10326 tp_wma_handle wma = (tp_wma_handle)wma_handle;
10327
10328 param.type = type;
10329 param.delay_time_ms = delay_time_ms;
10330 return wmi_crash_inject(wma->wmi_handle, ¶m);
10331 }
10332
wma_configure_smps_params(uint32_t vdev_id,uint32_t param_id,uint32_t param_val)10333 QDF_STATUS wma_configure_smps_params(uint32_t vdev_id, uint32_t param_id,
10334 uint32_t param_val)
10335 {
10336 tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
10337 int smps_cmd_value;
10338 int status = QDF_STATUS_E_INVAL;
10339
10340 if (!wma)
10341 return status;
10342
10343 smps_cmd_value = param_id << WMI_SMPS_PARAM_VALUE_S;
10344 smps_cmd_value = smps_cmd_value | param_val;
10345
10346 status = wma_set_smps_params(wma, vdev_id, smps_cmd_value);
10347 if (status)
10348 wma_err("Failed to set SMPS Param");
10349
10350 return status;
10351 }
10352
10353
10354 /**
10355 * wma_config_bmiss_bcnt_params() - set bmiss config parameters
10356 * @vdev_id: virtual device for the command
10357 * @first_cnt: bmiss first value
10358 * @final_cnt: bmiss final value
10359 *
10360 * Return: QDF_STATUS_SUCCESS or non-zero on failure
10361 */
wma_config_bmiss_bcnt_params(uint32_t vdev_id,uint32_t first_cnt,uint32_t final_cnt)10362 QDF_STATUS wma_config_bmiss_bcnt_params(uint32_t vdev_id, uint32_t first_cnt,
10363 uint32_t final_cnt)
10364 {
10365 tp_wma_handle wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
10366 int status = QDF_STATUS_E_INVAL;
10367
10368 if (!wma_handle)
10369 return status;
10370
10371 status = wma_roam_scan_bmiss_cnt(wma_handle, first_cnt, final_cnt,
10372 vdev_id);
10373
10374 if (status)
10375 wma_err("Failed to set Bmiss Param");
10376
10377 return status;
10378 }
10379
wma_get_rx_chainmask(uint8_t pdev_id,uint32_t * chainmask_2g,uint32_t * chainmask_5g)10380 QDF_STATUS wma_get_rx_chainmask(uint8_t pdev_id, uint32_t *chainmask_2g,
10381 uint32_t *chainmask_5g)
10382 {
10383 struct wlan_psoc_host_mac_phy_caps *mac_phy_cap;
10384 uint8_t total_mac_phy_cnt, idx;
10385 struct target_psoc_info *tgt_hdl;
10386 uint32_t hw_mode_idx = 0, num_hw_modes = 0;
10387
10388 tp_wma_handle wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
10389 if (!wma_handle)
10390 return QDF_STATUS_E_INVAL;
10391
10392 tgt_hdl = wlan_psoc_get_tgt_if_handle(wma_handle->psoc);
10393 if (!tgt_hdl) {
10394 wma_err("target psoc info is NULL");
10395 return QDF_STATUS_E_INVAL;
10396 }
10397
10398 total_mac_phy_cnt = target_psoc_get_total_mac_phy_cnt(tgt_hdl);
10399 num_hw_modes = target_psoc_get_num_hw_modes(tgt_hdl);
10400 if (total_mac_phy_cnt <= pdev_id) {
10401 wma_err("mac phy cnt %d, pdev id %d",
10402 total_mac_phy_cnt, pdev_id);
10403 return QDF_STATUS_E_FAILURE;
10404 }
10405
10406 if ((wma_handle->new_hw_mode_index != WMA_DEFAULT_HW_MODE_INDEX) &&
10407 (wma_handle->new_hw_mode_index <= num_hw_modes))
10408 hw_mode_idx = wma_handle->new_hw_mode_index;
10409 mac_phy_cap = target_psoc_get_mac_phy_cap(tgt_hdl);
10410 if (!mac_phy_cap) {
10411 wma_err("Invalid MAC PHY capabilities handle");
10412 return QDF_STATUS_E_FAILURE;
10413 }
10414 for (idx = 0; idx < total_mac_phy_cnt; idx++) {
10415 if (mac_phy_cap[idx].hw_mode_id != hw_mode_idx)
10416 continue;
10417 if (mac_phy_cap[idx].supported_bands & WLAN_2G_CAPABILITY)
10418 *chainmask_2g = mac_phy_cap[idx].rx_chain_mask_2G;
10419 if (mac_phy_cap[idx].supported_bands & WLAN_5G_CAPABILITY)
10420 *chainmask_5g = mac_phy_cap[idx].rx_chain_mask_5G;
10421 }
10422 wma_debug("pdev id: %d, hw_mode_idx: %d, rx chainmask 2g:%d, 5g:%d",
10423 pdev_id, hw_mode_idx, *chainmask_2g, *chainmask_5g);
10424
10425 return QDF_STATUS_SUCCESS;
10426 }
10427
10428 #ifdef FEATURE_ANI_LEVEL_REQUEST
wma_send_ani_level_request(tp_wma_handle wma_handle,uint32_t * freqs,uint8_t num_freqs)10429 QDF_STATUS wma_send_ani_level_request(tp_wma_handle wma_handle,
10430 uint32_t *freqs, uint8_t num_freqs)
10431 {
10432 return wmi_unified_ani_level_cmd_send(wma_handle->wmi_handle, freqs,
10433 num_freqs);
10434 }
10435 #endif
10436