1 /** @file mlan_api.c
2 *
3 * @brief This file provides more APIs for mlan.
4 *
5 * Copyright 2008-2024 NXP
6 *
7 * SPDX-License-Identifier: BSD-3-Clause
8 *
9 */
10
11 #include <stdio.h>
12 #include <mlan_api.h>
13 #if CONFIG_COMBO_SCAN
14 #include <string.h>
15 #endif
16 /* Additional WMSDK header files */
17 #include <wmerrno.h>
18 #include <osa.h>
19
20 #include <wifi.h>
21
22 #if defined(RW610)
23 #include "wifi-imu.h"
24 #else
25 #include "wifi-sdio.h"
26 #endif
27 #include "wifi-internal.h"
28
29 #if CONFIG_DRIVER_MBO
30 #include "mlan_mbo.h"
31 #endif
32
33 /* Always keep this include at the end of all include files */
34 #include <mlan_remap_mem_operations.h>
35
36 #if (CONFIG_11MC) || (CONFIG_11AZ)
37 #if CONFIG_WLS_CSI_PROC
38 #include <wls_param_defines.h>
39 #include <wls_api.h>
40 #include <wls_structure_defs.h>
41 #include <range_kalman.h>
42 #endif
43 #endif
44
45 static const char driver_version_format[] = "SD878x-%s-%s-WM";
46 static const char driver_version[] = "702.1.0";
47
48 static unsigned int mgmt_ie_index_bitmap = 0x0000000F;
49
50 #if (CONFIG_11MC) || (CONFIG_11AZ)
51 ftm_start_param ftm_param;
52 #if CONFIG_WLS_CSI_PROC
53 #define NL_MAX_PAYLOAD (3 * 1024)
54 unsigned int csi_res_array[8];
55 uint32_t wls_data[WLS_CSI_DATA_LEN_DW];
56 range_kalman_state range_input_str = {0};
57 #define RANGE_DRIVE_VAR 1e-5f // in meter/(s^2)
58 #define RANGE_MEASUREMENT_VAR 4e-2f // in meter^2
59 #define RANGE_RATE_INIT 1e-3f // in (meter/s)^2
60 #define CSI_TSF_LEN 6 * sizeof(uint32_t)
61 #define FFT_INBUFFER_LEN_DW (MAX_RX * MAX_TX + NUM_PROC_BUF) * (MAX_IFFT_SIZE_CSI)
62 uint32_t fftInBuffer_t[FFT_INBUFFER_LEN_DW];
63 #endif
64 #endif
65
66 /* This were static functions in mlan file */
67 mlan_status wlan_cmd_802_11_deauthenticate(IN pmlan_private pmpriv, IN HostCmd_DS_COMMAND *cmd, IN t_void *pdata_buf);
68 mlan_status wlan_cmd_reg_access(IN HostCmd_DS_COMMAND *cmd, IN t_u16 cmd_action, IN t_void *pdata_buf);
69 mlan_status wlan_cmd_mem_access(IN HostCmd_DS_COMMAND *cmd, IN t_u16 cmd_action, IN t_void *pdata_buf);
70 #if CONFIG_WLAN_BRIDGE
71 mlan_status wlan_cmd_bridge_mode(IN HostCmd_DS_COMMAND *cmd, IN t_u16 cmd_action, IN t_void *pdata_buf);
72 #endif
73 mlan_status wlan_cmd_auto_reconnect(IN HostCmd_DS_COMMAND *cmd, IN t_u16 cmd_action, IN t_void *pdata_buf);
74 mlan_status wlan_misc_ioctl_region(IN pmlan_adapter pmadapter, IN pmlan_ioctl_req pioctl_req);
75 #if CONFIG_11K_OFFLOAD
76 mlan_status wlan_cmd_11k_neighbor_req(mlan_private *pmpriv, HostCmd_DS_COMMAND *pcmd);
77 #endif
78
79 int wifi_set_mac_multicast_addr(const char *mlist, t_u32 num_of_addr);
80 int wifi_send_disable_supplicant(int mode);
81 int wifi_send_rf_channel_cmd(wifi_rf_channel_t *rf_channel);
82 int wifi_get_set_rf_tx_power(t_u16 cmd_action, wifi_tx_power_t *tx_power);
83
84 #ifdef RW610
wifi_send_shutdown_cmd()85 int wifi_send_shutdown_cmd()
86 {
87 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
88
89 wifi_get_command_lock();
90
91 cmd->command = HostCmd_CMD_FUNC_SHUTDOWN;
92 cmd->size = S_DS_GEN;
93 cmd->seq_num = 0x0;
94 cmd->result = 0x0;
95
96 wifi_wait_for_cmdresp(NULL);
97 return WM_SUCCESS;
98 }
99 #endif
wifi_deauthenticate(uint8_t * bssid)100 int wifi_deauthenticate(uint8_t *bssid)
101 {
102 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
103
104 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
105
106 if (pmpriv->media_connected == MFALSE)
107 {
108 return WM_SUCCESS;
109 }
110
111 (void)wifi_get_command_lock();
112
113 /* fixme: check if this static selection is ok */
114 #if CONFIG_P2P
115 cmd->seq_num = (0x01) << 13;
116 #else
117 cmd->seq_num = 0x0;
118 #endif
119 cmd->result = 0x0;
120
121 (void)wlan_cmd_802_11_deauthenticate((mlan_private *)mlan_adap->priv[0], cmd, bssid);
122 (void)wifi_wait_for_cmdresp(NULL);
123
124 return WM_SUCCESS;
125 }
126
127 #if CONFIG_WPA_SUPP
128 #define REASON_CODE_PEER_STA_LEAVING 36
wifi_nxp_deauthenticate(unsigned int bss_type,const uint8_t * bssid,uint16_t reason_code)129 int wifi_nxp_deauthenticate(unsigned int bss_type, const uint8_t *bssid, uint16_t reason_code)
130 {
131 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[bss_type];
132 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
133 HostCmd_DS_802_11_DEAUTHENTICATE *pdeauth = &cmd->params.deauth;
134
135 pmpriv->curr_bss_params.host_mlme = 0;
136 pmpriv->auth_flag = 0;
137 pmpriv->auth_alg = 0xFFFF;
138
139 if (pmpriv->media_connected == MFALSE)
140 {
141 return WM_SUCCESS;
142 }
143
144 (void)wifi_get_command_lock();
145
146 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_802_11_DEAUTHENTICATE);
147 cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_802_11_DEAUTHENTICATE) + S_DS_GEN);
148 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
149 cmd->result = 0x0;
150
151 /* Set AP MAC address */ (void)memcpy((void *)pdeauth->mac_addr, (const void *)bssid, (size_t)MLAN_MAC_ADDR_LENGTH);
152
153 wifi_d("Deauth: %02x:%02x:%02x:%02x:%02x:%02x", pdeauth->mac_addr[0], pdeauth->mac_addr[1], pdeauth->mac_addr[2],
154 pdeauth->mac_addr[3], pdeauth->mac_addr[4], pdeauth->mac_addr[5]);
155
156 if (pmpriv->adapter->state_11h.recvd_chanswann_event)
157 { /** Reason code 36 = Requested from peer station as it is leaving the BSS */
158 pdeauth->reason_code = wlan_cpu_to_le16(REASON_CODE_PEER_STA_LEAVING);
159 }
160 else
161 {
162 pdeauth->reason_code = wlan_cpu_to_le16(reason_code);
163 }
164 (void)wifi_wait_for_cmdresp(NULL);
165
166 return WM_SUCCESS;
167 }
168 #endif
169
wifi_get_eeprom_data(uint32_t offset,uint32_t byte_count,uint8_t * buf)170 int wifi_get_eeprom_data(uint32_t offset, uint32_t byte_count, uint8_t *buf)
171 {
172 mlan_ds_read_eeprom eeprom_rd;
173 eeprom_rd.offset = offset;
174 eeprom_rd.byte_count = byte_count;
175
176 (void)wifi_get_command_lock();
177 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
178
179 cmd->command = HostCmd_CMD_802_11_EEPROM_ACCESS;
180 cmd->seq_num = 0x0;
181 cmd->result = 0x0;
182
183 (void)wlan_cmd_reg_access(cmd, HostCmd_ACT_GEN_GET, &eeprom_rd);
184 (void)wifi_wait_for_cmdresp(buf);
185 return wm_wifi.cmd_resp_status;
186 }
187
wifi_reg_access(wifi_reg_t reg_type,uint16_t action,uint32_t offset,uint32_t * value)188 int wifi_reg_access(wifi_reg_t reg_type, uint16_t action, uint32_t offset, uint32_t *value)
189 {
190 mlan_ds_reg_rw reg_rw;
191 reg_rw.offset = offset;
192 reg_rw.value = *value;
193 uint16_t hostcmd;
194 int ret = WM_SUCCESS;
195 switch (reg_type)
196 {
197 case REG_MAC:
198 hostcmd = HostCmd_CMD_MAC_REG_ACCESS;
199 break;
200 case REG_BBP:
201 hostcmd = HostCmd_CMD_BBP_REG_ACCESS;
202 break;
203 case REG_RF:
204 hostcmd = HostCmd_CMD_RF_REG_ACCESS;
205 break;
206 case REG_CAU:
207 hostcmd = HostCmd_CMD_CAU_REG_ACCESS;
208 break;
209 default:
210 wifi_e("Incorrect register type");
211 ret = -WM_FAIL;
212 break;
213 }
214
215 if (ret != WM_SUCCESS)
216 {
217 return ret;
218 }
219
220 (void)wifi_get_command_lock();
221 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
222
223 cmd->command = hostcmd;
224 cmd->seq_num = 0x0;
225 cmd->result = 0x0;
226
227 (void)wlan_cmd_reg_access(cmd, action, ®_rw);
228 (void)wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? value : NULL);
229 return wm_wifi.cmd_resp_status;
230 }
231
wifi_mem_access(uint16_t action,uint32_t addr,uint32_t * value)232 int wifi_mem_access(uint16_t action, uint32_t addr, uint32_t *value)
233 {
234 mlan_ds_mem_rw mem_rw;
235 mem_rw.addr = addr;
236 mem_rw.value = *value;
237
238 (void)wifi_get_command_lock();
239 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
240
241 cmd->command = HostCmd_CMD_MEM_ACCESS;
242 cmd->seq_num = 0x0;
243 cmd->result = 0x0;
244
245 (void)wlan_cmd_mem_access(cmd, action, &mem_rw);
246
247 (void)wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? value : NULL);
248 return wm_wifi.cmd_resp_status;
249 }
250
251 #if CONFIG_WIFI_BOOT_SLEEP
wifi_boot_sleep(uint16_t action,uint16_t * enable)252 int wifi_boot_sleep(uint16_t action, uint16_t *enable)
253 {
254 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
255
256 (void)wifi_get_command_lock();
257 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
258
259 cmd->command = HostCmd_CMD_BOOT_SLEEP;
260 cmd->seq_num = 0x0;
261 cmd->result = 0x0;
262
263 (void)wlan_cmd_boot_sleep(pmpriv, cmd, action, enable);
264
265 (void)wifi_wait_for_cmdresp(enable);
266 return wm_wifi.cmd_resp_status;
267 }
268 #endif
269
270 #if CONFIG_AUTO_RECONNECT
wifi_auto_reconnect(uint16_t action,wifi_auto_reconnect_config_t * auto_reconnect_config)271 static int wifi_auto_reconnect(uint16_t action, wifi_auto_reconnect_config_t *auto_reconnect_config)
272 {
273 mlan_ds_auto_reconnect auto_reconnect;
274
275 (void)memset(&auto_reconnect, 0x00, sizeof(mlan_ds_auto_reconnect));
276
277 if (auto_reconnect_config)
278 {
279 auto_reconnect.reconnect_counter = auto_reconnect_config->reconnect_counter;
280 auto_reconnect.reconnect_interval = auto_reconnect_config->reconnect_interval;
281 auto_reconnect.flags = auto_reconnect_config->flags;
282 }
283
284 wifi_get_command_lock();
285 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
286
287 cmd->command = HostCmd_CMD_AUTO_RECONNECT;
288 cmd->seq_num = 0x0;
289 cmd->result = 0x0;
290
291 wlan_cmd_auto_reconnect(cmd, action, &auto_reconnect);
292
293 wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? auto_reconnect_config : NULL);
294
295 return wm_wifi.cmd_resp_status;
296 }
297
wifi_auto_reconnect_enable(wifi_auto_reconnect_config_t auto_reconnect_config)298 int wifi_auto_reconnect_enable(wifi_auto_reconnect_config_t auto_reconnect_config)
299 {
300 return wifi_auto_reconnect(HostCmd_ACT_GEN_SET, &auto_reconnect_config);
301 }
302
wifi_auto_reconnect_disable(void)303 int wifi_auto_reconnect_disable(void)
304 {
305 return wifi_auto_reconnect(HostCmd_ACT_GEN_SET, NULL);
306 }
307
wifi_get_auto_reconnect_config(wifi_auto_reconnect_config_t * auto_reconnect_config)308 int wifi_get_auto_reconnect_config(wifi_auto_reconnect_config_t *auto_reconnect_config)
309 {
310 return wifi_auto_reconnect(HostCmd_ACT_GEN_GET, auto_reconnect_config);
311 }
312 #endif
313
wifi_get_tsf(uint32_t * tsf_high,uint32_t * tsf_low)314 int wifi_get_tsf(uint32_t *tsf_high, uint32_t *tsf_low)
315 {
316 t_u64 tsf = 0x00;
317
318 (void)wifi_get_command_lock();
319 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
320
321 (void)memset(cmd, 0, sizeof(HostCmd_DS_COMMAND));
322
323 cmd->seq_num = 0x0;
324 cmd->result = 0x0;
325
326 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_GET_TSF,
327 HostCmd_ACT_GEN_GET, 0, NULL, NULL, cmd);
328 if (rv != MLAN_STATUS_SUCCESS)
329 {
330 return -WM_FAIL;
331 }
332
333 (void)wifi_wait_for_cmdresp(&tsf);
334
335 *tsf_high = tsf >> 32;
336 *tsf_low = (t_u32)tsf;
337
338 return wm_wifi.cmd_resp_status;
339 }
340
341 #if CONFIG_WLAN_BRIDGE
wifi_bridge_mode(uint16_t action,uint8_t * enable,wifi_bridge_cfg_t * bridgecfg)342 static int wifi_bridge_mode(uint16_t action, uint8_t *enable, wifi_bridge_cfg_t *bridgecfg)
343 {
344 mlan_bridge_mode bridge_mode;
345 bridge_mode.enable = *enable;
346
347 t_u8 *tlv = NULL;
348 MrvlIEtypes_BridgeParamSet_t *bridge_params = NULL;
349 MrvlIEtypes_AutoLinkParamSet_t *autolink_params = NULL;
350 MrvlIEtypes_SsIdParamSet_t *ssid = NULL;
351 MrvlIEtypes_Passphrase_t *pass = NULL;
352
353 wifi_get_command_lock();
354 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
355
356 cmd->command = HostCmd_CMD_BRIDGE_MODE;
357 cmd->seq_num = 0x0;
358 cmd->result = 0x0;
359
360 wlan_cmd_bridge_mode(cmd, action, &bridge_mode);
361
362 if (action == HostCmd_ACT_GEN_GET)
363 goto done;
364
365 if (bridgecfg == NULL)
366 goto done;
367
368 tlv = (t_u8 *)cmd + sizeof(HostCmd_BRIDGE_MODE) + S_DS_GEN;
369
370 bridge_params = (MrvlIEtypes_BridgeParamSet_t *)tlv;
371
372 bridge_params->header.type = wlan_cpu_to_le16(TLV_TYPE_BRIDGE_PARAM);
373 bridge_params->header.len = 4 * sizeof(MrvlIEtypesHeader_t) + bridgecfg->ex_ap_ssid_len +
374 bridgecfg->ex_ap_pass_len + bridgecfg->bridge_ssid_len + bridgecfg->bridge_pass_len;
375 tlv = (t_u8 *)bridge_params;
376
377 ssid = (MrvlIEtypes_SsIdParamSet_t *)(tlv + sizeof(MrvlIEtypesHeader_t));
378 ssid->header.type = wlan_cpu_to_le16(TLV_TYPE_SSID);
379 ssid->header.len = bridgecfg->ex_ap_ssid_len;
380 (void)memcpy((void *)ssid->ssid, (const void *)bridgecfg->ex_ap_ssid, bridgecfg->ex_ap_ssid_len);
381 tlv = (t_u8 *)ssid;
382
383 pass = (MrvlIEtypes_Passphrase_t *)(tlv + sizeof(MrvlIEtypesHeader_t) + ssid->header.len);
384 pass->header.type = wlan_cpu_to_le16(TLV_TYPE_PASSPHRASE);
385 pass->header.len = bridgecfg->ex_ap_pass_len;
386 (void)memcpy((void *)pass->passphrase, (const void *)bridgecfg->ex_ap_pass, bridgecfg->ex_ap_pass_len);
387
388 tlv = (t_u8 *)pass;
389
390 ssid = (MrvlIEtypes_SsIdParamSet_t *)(tlv + sizeof(MrvlIEtypesHeader_t) + pass->header.len);
391 ssid->header.type = wlan_cpu_to_le16(TLV_TYPE_SSID);
392 ssid->header.len = bridgecfg->bridge_ssid_len;
393 (void)memcpy((void *)ssid->ssid, (const void *)bridgecfg->bridge_ssid, bridgecfg->bridge_ssid_len);
394
395 tlv = (t_u8 *)ssid;
396
397 pass = (MrvlIEtypes_Passphrase_t *)(tlv + sizeof(MrvlIEtypesHeader_t) + ssid->header.len);
398 pass->header.type = wlan_cpu_to_le16(TLV_TYPE_PASSPHRASE);
399 pass->header.len = bridgecfg->bridge_pass_len;
400 (void)memcpy((void *)pass->passphrase, (const void *)bridgecfg->bridge_pass, bridgecfg->bridge_pass_len);
401
402 cmd->size += bridge_params->header.len + sizeof(MrvlIEtypesHeader_t);
403
404 /*prepare autolink info*/
405 tlv = (t_u8 *)pass;
406 autolink_params = (MrvlIEtypes_AutoLinkParamSet_t *)(tlv + sizeof(MrvlIEtypesHeader_t) + pass->header.len);
407 autolink_params->header.type = wlan_cpu_to_le16(TLV_TYPE_AUTOLINK_PARAM);
408 autolink_params->header.len = sizeof(MrvlIEtypes_AutoLinkParamSet_t) - sizeof(MrvlIEtypesHeader_t);
409 autolink_params->scan_timer_interval = wlan_cpu_to_le32(bridgecfg->autolink.scan_timer_interval);
410 autolink_params->scan_timer_condition = bridgecfg->autolink.scan_timer_condition;
411 autolink_params->scan_channel_list = bridgecfg->autolink.scan_channel_list;
412 cmd->size += autolink_params->header.len + sizeof(MrvlIEtypesHeader_t);
413
414 done:
415
416 wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? bridgecfg : NULL);
417
418 return wm_wifi.cmd_resp_status;
419 }
420
wifi_enable_bridge_mode(wifi_bridge_cfg_t * cfg)421 int wifi_enable_bridge_mode(wifi_bridge_cfg_t *cfg)
422 {
423 uint8_t enable = 0x01;
424
425 if (cfg->auto_link)
426 {
427 enable |= 1 << ENABLE_AUTOLINK_BIT;
428 }
429 if (cfg->hidden_ssid)
430 {
431 enable |= 1 << HIDDEN_SSID_BIT;
432 }
433
434 return wifi_bridge_mode(HostCmd_ACT_GEN_SET, &enable, cfg);
435 }
436
wifi_disable_bridge_mode()437 int wifi_disable_bridge_mode()
438 {
439 uint8_t disable = 0x00;
440 return wifi_bridge_mode(HostCmd_ACT_GEN_SET, &disable, NULL);
441 }
442
wifi_get_bridge_mode_config(wifi_bridge_cfg_t * cfg)443 int wifi_get_bridge_mode_config(wifi_bridge_cfg_t *cfg)
444 {
445 uint8_t config = 0x00;
446 return wifi_bridge_mode(HostCmd_ACT_GEN_GET, &config, cfg);
447 }
448
wifi_config_bridge_tx_buf(uint16_t buf_size)449 int wifi_config_bridge_tx_buf(uint16_t buf_size)
450 {
451 wifi_get_command_lock();
452 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
453
454 cmd->command = HostCmd_CMD_RECONFIGURE_TX_BUFF;
455 cmd->seq_num = 0x0;
456 cmd->result = 0x0;
457
458 wlan_cmd_recfg_tx_buf((mlan_private *)mlan_adap->priv[0], cmd, HostCmd_ACT_GEN_SET, &buf_size);
459
460 wifi_wait_for_cmdresp(NULL);
461 return wm_wifi.cmd_resp_status;
462 }
463 #endif
464
wifi_send_rssi_info_cmd(wifi_rssi_info_t * rssi_info)465 int wifi_send_rssi_info_cmd(wifi_rssi_info_t *rssi_info)
466 {
467 (void)wifi_get_command_lock();
468 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
469
470 cmd->seq_num = 0x0;
471 cmd->result = 0x0;
472
473 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_RSSI_INFO,
474 HostCmd_ACT_GEN_GET, 0, NULL, NULL, cmd);
475 if (rv != MLAN_STATUS_SUCCESS)
476 {
477 return -WM_FAIL;
478 }
479
480 (void)wifi_wait_for_cmdresp(rssi_info);
481 return wm_wifi.cmd_resp_status;
482 }
483
wifi_send_rf_channel_cmd(wifi_rf_channel_t * rf_channel)484 int wifi_send_rf_channel_cmd(wifi_rf_channel_t *rf_channel)
485 {
486 (void)wifi_get_command_lock();
487 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
488
489 cmd->seq_num = 0x0;
490 cmd->result = 0x0;
491
492 /*
493 SET operation is not supported according to spec. So we are
494 sending NULL as one param below.
495 */
496 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_RF_CHANNEL,
497 HostCmd_ACT_GEN_GET, 0, NULL, NULL, cmd);
498 if (rv != MLAN_STATUS_SUCCESS)
499 {
500 return -WM_FAIL;
501 }
502
503 (void)wifi_wait_for_cmdresp(rf_channel);
504 return wm_wifi.cmd_resp_status;
505 }
506
wifi_send_remain_on_channel_cmd(unsigned int bss_type,wifi_remain_on_channel_t * remain_on_channel)507 int wifi_send_remain_on_channel_cmd(unsigned int bss_type, wifi_remain_on_channel_t *remain_on_channel)
508 {
509 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
510 (void)wifi_get_command_lock();
511 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
512
513 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0U /* seq_num */, 0U /* bss_num */, bss_type);
514 cmd->result = 0x0;
515 /*save remain on channel bss index*/
516 mlan_adap->remain_bss_index = mlan_adap->priv[bss_type]->bss_index;
517 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[bss_type], HostCmd_CMD_802_11_REMAIN_ON_CHANNEL,
518 HostCmd_ACT_GEN_SET, 0, NULL, remain_on_channel, cmd);
519 if (rv != MLAN_STATUS_SUCCESS)
520 {
521 return -WM_FAIL;
522 }
523
524 (void)wifi_wait_for_cmdresp(NULL);
525 return wm_wifi.cmd_resp_status;
526 }
527
528 /* power_level is not used when cmd_action is GET */
wifi_get_set_rf_tx_power(t_u16 cmd_action,wifi_tx_power_t * tx_power)529 int wifi_get_set_rf_tx_power(t_u16 cmd_action, wifi_tx_power_t *tx_power)
530 {
531 (void)wifi_get_command_lock();
532 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
533
534 cmd->seq_num = 0x0;
535 cmd->result = 0x0;
536 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_RF_TX_POWER,
537 cmd_action, 0, NULL, &tx_power->current_level, cmd);
538 if (rv != MLAN_STATUS_SUCCESS)
539 {
540 return -WM_FAIL;
541 }
542
543 (void)wifi_wait_for_cmdresp(cmd_action == HostCmd_ACT_GEN_GET ? tx_power : NULL);
544 return wm_wifi.cmd_resp_status;
545 }
546
wifi_get_data_rate(wifi_ds_rate * ds_rate,mlan_bss_type bss_type)547 int wifi_get_data_rate(wifi_ds_rate *ds_rate, mlan_bss_type bss_type)
548 {
549 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
550 (void)wifi_get_command_lock();
551 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
552
553 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
554 cmd->result = 0x0;
555
556 mlan_status rv = MLAN_STATUS_SUCCESS;
557 if (bss_type == MLAN_BSS_TYPE_UAP)
558 {
559 if (is_uap_started())
560 rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[1], HostCmd_CMD_802_11_TX_RATE_QUERY, 0, 0,
561 NULL, NULL, cmd);
562 else
563 wifi_e("uap isn't up\n\r");
564 }
565 else if (bss_type == MLAN_BSS_TYPE_STA)
566 {
567 if (is_sta_connected())
568 rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_TX_RATE_QUERY, 0, 0,
569 NULL, NULL, cmd);
570 else
571 wifi_e("sta connection required before setting tx rate\n\r");
572 }
573
574 if (rv != MLAN_STATUS_SUCCESS)
575 {
576 wifi_put_command_lock();
577 return -WM_FAIL;
578 }
579
580 (void)wifi_wait_for_cmdresp(ds_rate);
581 return wm_wifi.cmd_resp_status;
582 }
583
wifi_set_pmfcfg(t_u8 mfpc,t_u8 mfpr)584 int wifi_set_pmfcfg(t_u8 mfpc, t_u8 mfpr)
585 {
586 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
587
588 pmpriv->pmfcfg.mfpc = mfpc;
589 pmpriv->pmfcfg.mfpr = mfpr;
590
591 return WM_SUCCESS;
592 }
593
wifi_get_pmfcfg(t_u8 * mfpc,t_u8 * mfpr)594 int wifi_get_pmfcfg(t_u8 *mfpc, t_u8 *mfpr)
595 {
596 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
597
598 *mfpc = pmpriv->pmfcfg.mfpc;
599 *mfpr = pmpriv->pmfcfg.mfpr;
600
601 return WM_SUCCESS;
602 }
603
wifi_set_packet_filters(wifi_flt_cfg_t * flt_cfg)604 int wifi_set_packet_filters(wifi_flt_cfg_t *flt_cfg)
605 {
606 (void)wifi_get_command_lock();
607 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
608 HostCmd_DS_MEF_CFG *mef_hdr;
609 mef_entry_header *entry_hdr;
610 t_u8 *buf = (t_u8 *)cmd, *filter_buf = NULL;
611 t_u32 buf_len;
612 int i, j;
613 mef_op op;
614 t_u32 dnum;
615
616 (void)memset(cmd, 0, sizeof(HostCmd_DS_COMMAND));
617
618 cmd->seq_num = 0x0;
619 cmd->result = 0x0;
620
621 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_MEF_CFG);
622 buf_len = S_DS_GEN;
623
624 /** Fill HostCmd_DS_MEF_CFG */
625 mef_hdr = (HostCmd_DS_MEF_CFG *)(void *)(buf + buf_len);
626 mef_hdr->criteria = wlan_cpu_to_le32(flt_cfg->criteria);
627 mef_hdr->nentries = wlan_cpu_to_le16(flt_cfg->nentries);
628 buf_len += sizeof(HostCmd_DS_MEF_CFG);
629
630 for (i = 0; i < flt_cfg->nentries; i++)
631 {
632 /** Fill entry header data */
633 entry_hdr = (mef_entry_header *)(buf + buf_len);
634 entry_hdr->mode = flt_cfg->mef_entry[i].mode;
635 entry_hdr->action = flt_cfg->mef_entry[i].action;
636 buf_len += sizeof(mef_entry_header);
637 for (j = 0; j < flt_cfg->mef_entry[i].filter_num; j++)
638 {
639 if (flt_cfg->mef_entry[i].filter_item[j].type == TYPE_DNUM_EQ)
640 {
641 /* Format of decimal num:
642 * | 5 bytes | 5 bytes | 5 bytes | 1 byte |
643 * | pattern | offset | num of bytes | type (TYPE_DNUM_EQ) |
644 */
645 filter_buf = (t_u8 *)(buf + buf_len);
646
647 /* push pattern */
648 op.operand_type = OPERAND_DNUM;
649 dnum = flt_cfg->mef_entry[i].filter_item[j].pattern;
650 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
651 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
652 buf_len += sizeof(dnum) + 1;
653 filter_buf = (t_u8 *)(buf + buf_len);
654
655 /* push offset */
656 op.operand_type = OPERAND_DNUM;
657 dnum = flt_cfg->mef_entry[i].filter_item[j].offset;
658 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
659 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
660 buf_len += sizeof(dnum) + 1;
661 filter_buf = (t_u8 *)(buf + buf_len);
662
663 /* push num of bytes */
664 op.operand_type = OPERAND_DNUM;
665 dnum = flt_cfg->mef_entry[i].filter_item[j].num_bytes;
666 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
667 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
668 buf_len += sizeof(dnum) + 1;
669 filter_buf = (t_u8 *)(buf + buf_len);
670
671 /* push type */
672 op.operand_type = TYPE_DNUM_EQ;
673 (void)memcpy(filter_buf, &(op.operand_type), 1);
674 buf_len += 1;
675 filter_buf = (t_u8 *)(buf + buf_len);
676 }
677 else if (flt_cfg->mef_entry[i].filter_item[j].type == TYPE_BYTE_EQ)
678 {
679 /* Format of byte seq:
680 * | 5 bytes | val | 5 bytes | 1 byte |
681 * | repeat | bytes seq | offset | type (TYPE_BYTE_EQ) |
682 */
683 filter_buf = (t_u8 *)(buf + buf_len);
684
685 /* push repeat */
686 op.operand_type = OPERAND_DNUM;
687 dnum = flt_cfg->mef_entry[i].filter_item[j].repeat;
688 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
689 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
690 buf_len += sizeof(dnum) + 1;
691 filter_buf = (t_u8 *)(buf + buf_len);
692
693 /* push bytes seq */
694 op.operand_type = OPERAND_BYTE_SEQ;
695 (void)memcpy(filter_buf, flt_cfg->mef_entry[i].filter_item[j].byte_seq,
696 flt_cfg->mef_entry[i].filter_item[j].num_byte_seq);
697 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_byte_seq,
698 &(flt_cfg->mef_entry[i].filter_item[j].num_byte_seq), 1);
699 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_byte_seq + 1, &(op.operand_type), 1);
700 buf_len += flt_cfg->mef_entry[i].filter_item[j].num_byte_seq + 2;
701 filter_buf = (t_u8 *)(buf + buf_len);
702
703 /* push offset */
704 op.operand_type = OPERAND_DNUM;
705 dnum = flt_cfg->mef_entry[i].filter_item[j].offset;
706 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
707 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
708 buf_len += sizeof(dnum) + 1;
709 filter_buf = (t_u8 *)(buf + buf_len);
710
711 /* push type */
712 op.operand_type = TYPE_BYTE_EQ;
713 (void)memcpy(filter_buf, &(op.operand_type), 1);
714 buf_len += 1;
715 filter_buf = (t_u8 *)(buf + buf_len);
716 }
717 else if (flt_cfg->mef_entry[i].filter_item[j].type == TYPE_BIT_EQ)
718 {
719 /* Format of bit seq:
720 * | val | 5 bytes | val | 1 byte |
721 * | bytes seq | offset | mask seq | type (TYPE_BIT_EQ) |
722 */
723 filter_buf = (t_u8 *)(buf + buf_len);
724
725 /* push bytes seq */
726 op.operand_type = OPERAND_BYTE_SEQ;
727 (void)memcpy(filter_buf, flt_cfg->mef_entry[i].filter_item[j].byte_seq,
728 flt_cfg->mef_entry[i].filter_item[j].num_byte_seq);
729 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_byte_seq,
730 &(flt_cfg->mef_entry[i].filter_item[j].num_byte_seq), 1);
731 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_byte_seq + 1, &(op.operand_type), 1);
732 buf_len += flt_cfg->mef_entry[i].filter_item[j].num_byte_seq + 2;
733 filter_buf = (t_u8 *)(buf + buf_len);
734
735 /* push offset */
736 op.operand_type = OPERAND_DNUM;
737 dnum = flt_cfg->mef_entry[i].filter_item[j].offset;
738 (void)memcpy(filter_buf, &dnum, sizeof(dnum));
739 (void)memcpy(filter_buf + sizeof(dnum), &(op.operand_type), 1);
740 buf_len += sizeof(dnum) + 1;
741 filter_buf = (t_u8 *)(buf + buf_len);
742
743 /* push mask seq */
744 op.operand_type = OPERAND_BYTE_SEQ;
745 (void)memcpy(filter_buf, flt_cfg->mef_entry[i].filter_item[j].mask_seq,
746 flt_cfg->mef_entry[i].filter_item[j].num_mask_seq);
747 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_mask_seq,
748 &(flt_cfg->mef_entry[i].filter_item[j].num_mask_seq), 1);
749 (void)memcpy(filter_buf + flt_cfg->mef_entry[i].filter_item[j].num_mask_seq + 1, &(op.operand_type), 1);
750 buf_len += flt_cfg->mef_entry[i].filter_item[j].num_mask_seq + 2;
751 filter_buf = (t_u8 *)(buf + buf_len);
752
753 /* push type */
754 op.operand_type = TYPE_BIT_EQ;
755 (void)memcpy(filter_buf, &(op.operand_type), 1);
756 buf_len += 1;
757 filter_buf = (t_u8 *)(buf + buf_len);
758 }
759 else
760 goto done;
761 if (j != 0)
762 {
763 filter_buf = (t_u8 *)(buf + buf_len);
764 op.operand_type = flt_cfg->mef_entry[i].rpn[j];
765 (void)memcpy(filter_buf, &(op.operand_type), 1);
766 buf_len += 1;
767 filter_buf = (t_u8 *)(buf + buf_len);
768 }
769 }
770 if (filter_buf != NULL)
771 entry_hdr->len = (t_u32)filter_buf - (t_u32)entry_hdr - sizeof(mef_entry_header);
772 }
773
774 cmd->size = wlan_cpu_to_le16(buf_len);
775 done:
776 (void)wifi_wait_for_cmdresp(NULL);
777
778 return wm_wifi.cmd_resp_status;
779 }
780
781 #define FLTR_BUF_IP_OFFSET 24
782
wifi_set_auto_arp(t_u32 * ipv4_addr)783 int wifi_set_auto_arp(t_u32 *ipv4_addr)
784 {
785 wifi_get_command_lock();
786 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
787 HostCmd_DS_MEF_CFG *mef_hdr;
788 t_u8 *buf = (t_u8 *)cmd, *filter = NULL;
789 t_u32 buf_len;
790 t_u8 fltr_buf[] = {0x01, 0x10, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x02, 0x02,
791 0x14, 0x00, 0x00, 0x00, 0x01, 0x41, 0x01, 0x00, 0x00, 0x00, 0x01, 0xc0, 0xa8,
792 0x01, 0x6d, 0x04, 0x02, 0x2e, 0x00, 0x00, 0x00, 0x01, 0x41, 0x44};
793
794 (void)memset(cmd, 0, sizeof(HostCmd_DS_COMMAND));
795
796 cmd->seq_num = 0x0;
797 cmd->result = 0x0;
798
799 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_MEF_CFG);
800 buf_len = S_DS_GEN;
801
802 /** Fill HostCmd_DS_MEF_CFG*/
803 mef_hdr = (HostCmd_DS_MEF_CFG *)(buf + buf_len);
804 mef_hdr->criteria = wlan_cpu_to_le32(MBIT(0) | MBIT(1) | MBIT(3));
805 mef_hdr->nentries = wlan_cpu_to_le16(1);
806 buf_len += sizeof(HostCmd_DS_MEF_CFG);
807
808 filter = buf + buf_len;
809 (void)memcpy((void *)filter, (const void *)fltr_buf, sizeof(fltr_buf));
810 (void)memcpy((void *)&filter[FLTR_BUF_IP_OFFSET], (const void *)ipv4_addr, sizeof(t_u32));
811 buf_len += sizeof(fltr_buf);
812
813 cmd->size = wlan_cpu_to_le16(buf_len);
814 wifi_wait_for_cmdresp(NULL);
815
816 return wm_wifi.cmd_resp_status;
817 }
818
wifi_tcp_keep_alive(wifi_tcp_keep_alive_t * keep_alive,t_u8 * src_mac,t_u32 src_ip)819 int wifi_tcp_keep_alive(wifi_tcp_keep_alive_t *keep_alive, t_u8 *src_mac, t_u32 src_ip)
820 {
821 wifi_get_command_lock();
822 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
823 t_u16 cmd_action = HostCmd_ACT_GEN_SET;
824
825 HostCmd_DS_AUTO_TX *auto_tx_cmd = (HostCmd_DS_AUTO_TX *)((t_u8 *)cmd + S_DS_GEN);
826 t_u8 *pos = (t_u8 *)auto_tx_cmd + sizeof(auto_tx_cmd->action);
827 t_u16 len = 0;
828
829 MrvlIEtypes_Cloud_Keep_Alive_t *keep_alive_tlv = MNULL;
830 MrvlIEtypes_Keep_Alive_Ctrl_t *ctrl_tlv = MNULL;
831 MrvlIEtypes_Keep_Alive_Pkt_t *pkt_tlv = MNULL;
832 t_u8 eth_ip[] = {0x08, 0x00};
833 t_u8 ip_packet[67] = {0x45, 0x00, 0x00, 0x43, 0x8c, 0x9e, 0x00, 0x00, 0xff, 0x06, 0xac, 0xbf, 0xc0, 0xa8,
834 0x00, 0x7c, 0xc0, 0xa8, 0x00, 0x8a, 0xc0, 0x03, 0x22, 0xb7, 0xb0, 0xb6, 0x60, 0x9f,
835 0x42, 0xdd, 0x9e, 0x1e, 0x50, 0x18, 0x80, 0x00, 0xd0, 0x88, 0x00, 0x00, 0x74, 0x68,
836 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6b, 0x65, 0x65, 0x70, 0x20, 0x61,
837 0x6c, 0x69, 0x76, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74};
838 #if 0
839 t_u8 ip_packet2[41] = {0x45, 0x00, 0x00, 0x29, 0x76, 0x51, 0x40, 0x00, 0x80, 0x06, 0xf2, 0x4c, 0xc0, 0xa8, 0x01, 0x0a, 0xc0, 0xa8, 0x01, 0x0c, 0xfb, 0xd8, 0x01, 0xbd, 0x76, 0xe3, 0x34, 0x62, 0x06, 0x80, 0x8b, 0x62, 0x50, 0x10, 0x01, 0x00, 0xe1, 0xe4, 0x00, 0x00, 0x00};
840 #endif
841 t_u16 pkt_len = 67;
842
843 if (keep_alive->reset)
844 cmd_action = HostCmd_ACT_GEN_RESET;
845
846 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_AUTO_TX);
847 cmd->size = S_DS_GEN + sizeof(HostCmd_DS_AUTO_TX);
848 auto_tx_cmd->action = wlan_cpu_to_le16(cmd_action);
849
850 keep_alive_tlv = (MrvlIEtypes_Cloud_Keep_Alive_t *)pos;
851
852 keep_alive_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_CLOUD_KEEP_ALIVE);
853 keep_alive_tlv->keep_alive_id = 1; // keep_alive->mkeep_alive_id;
854 keep_alive_tlv->enable = keep_alive->enable;
855 len = len + sizeof(keep_alive_tlv->keep_alive_id) + sizeof(keep_alive_tlv->enable);
856 pos = pos + len + sizeof(MrvlIEtypesHeader_t);
857 if (cmd_action == HostCmd_ACT_GEN_SET)
858 {
859 if (keep_alive->enable)
860 {
861 ctrl_tlv = (MrvlIEtypes_Keep_Alive_Ctrl_t *)pos;
862 ctrl_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_CTRL);
863 ctrl_tlv->header.len =
864 wlan_cpu_to_le16(sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t) - sizeof(MrvlIEtypesHeader_t));
865 ctrl_tlv->snd_interval = wlan_cpu_to_le32(keep_alive->timeout);
866 ctrl_tlv->retry_interval = wlan_cpu_to_le16(keep_alive->interval);
867 ctrl_tlv->retry_count = wlan_cpu_to_le16(keep_alive->max_keep_alives);
868 len = len + sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t);
869
870 pos = pos + sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t);
871 pkt_tlv = (MrvlIEtypes_Keep_Alive_Pkt_t *)pos;
872 pkt_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_PKT);
873 (void)memcpy((void *)pkt_tlv->eth_header.dest_addr, (const void *)keep_alive->dst_mac,
874 MLAN_MAC_ADDR_LENGTH);
875 (void)memcpy((void *)pkt_tlv->eth_header.src_addr, (const void *)src_mac, MLAN_MAC_ADDR_LENGTH);
876 (void)memcpy((void *)((t_u8 *)&pkt_tlv->eth_header.h803_len), (const void *)eth_ip, sizeof(t_u16));
877 (void)memcpy((void *)(ip_packet + 12), (const void *)&src_ip, sizeof(t_u32));
878 (void)memcpy((void *)(ip_packet + 16), (const void *)&keep_alive->dst_ip, sizeof(t_u32));
879 (void)memcpy((void *)pkt_tlv->ip_packet, (const void *)ip_packet, pkt_len);
880 pkt_tlv->header.len = wlan_cpu_to_le16(sizeof(Eth803Hdr_t) + pkt_len);
881 len = len + sizeof(MrvlIEtypesHeader_t) + sizeof(Eth803Hdr_t) + pkt_len;
882 }
883 else
884 {
885 pkt_tlv = (MrvlIEtypes_Keep_Alive_Pkt_t *)pos;
886 pkt_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_PKT);
887 pkt_tlv->header.len = 0;
888 len = len + sizeof(MrvlIEtypesHeader_t);
889 }
890 }
891 if (cmd_action == HostCmd_ACT_GEN_RESET)
892 {
893 pkt_tlv = (MrvlIEtypes_Keep_Alive_Pkt_t *)pos;
894 pkt_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_PKT);
895 pkt_tlv->header.len = 0;
896 len = len + sizeof(MrvlIEtypesHeader_t);
897 }
898 keep_alive_tlv->header.len = wlan_cpu_to_le16(len);
899
900 cmd->size = cmd->size + len + sizeof(MrvlIEtypesHeader_t);
901 cmd->size = wlan_cpu_to_le16(cmd->size);
902
903 cmd->seq_num = 0x00;
904 cmd->result = 0x00;
905
906 wifi_wait_for_cmdresp(NULL);
907
908 return wm_wifi.cmd_resp_status;
909 }
910
911 #if CONFIG_CLOUD_KEEP_ALIVE
wifi_cloud_keep_alive(wifi_cloud_keep_alive_t * keep_alive,t_u16 action,t_u8 * enable)912 int wifi_cloud_keep_alive(wifi_cloud_keep_alive_t *keep_alive, t_u16 action, t_u8 *enable)
913 {
914 wifi_get_command_lock();
915 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
916 t_u16 cmd_action;
917 HostCmd_DS_AUTO_TX *auto_tx_cmd = (HostCmd_DS_AUTO_TX *)((t_u8 *)cmd + S_DS_GEN);
918 t_u8 *pos = (t_u8 *)auto_tx_cmd + sizeof(auto_tx_cmd->action);
919 t_u16 len = 0;
920 MrvlIEtypes_Cloud_Keep_Alive_t *keep_alive_tlv = MNULL;
921
922 if (keep_alive == NULL)
923 return -WM_E_INVAL;
924
925 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
926 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, BSS_TYPE_STA);
927 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_AUTO_TX);
928 cmd->size = S_DS_GEN + sizeof(HostCmd_DS_AUTO_TX);
929
930 if ((action == MLAN_ACT_GET) && (enable != NULL))
931 {
932 cmd_action = HostCmd_ACT_GEN_GET;
933 }
934 else if ((action == MLAN_ACT_SET) && !keep_alive->reset)
935 {
936 cmd_action = HostCmd_ACT_GEN_SET;
937 }
938 else if ((action == MLAN_ACT_SET) && keep_alive->reset)
939 {
940 cmd_action = HostCmd_ACT_GEN_RESET;
941 }
942 else
943 {
944 return -WM_E_INVAL;
945 }
946 auto_tx_cmd->action = wlan_cpu_to_le16(cmd_action);
947
948 keep_alive_tlv = (MrvlIEtypes_Cloud_Keep_Alive_t *)pos;
949
950 keep_alive_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_CLOUD_KEEP_ALIVE);
951 keep_alive_tlv->keep_alive_id = keep_alive->mkeep_alive_id;
952 if (cmd_action == HostCmd_ACT_GEN_GET)
953 {
954 keep_alive_tlv->enable = MFALSE;
955 len = len + sizeof(keep_alive_tlv->keep_alive_id) + sizeof(keep_alive_tlv->enable);
956 keep_alive_tlv->header.len = wlan_cpu_to_le16(len);
957
958 cmd->size = cmd->size + len + sizeof(MrvlIEtypesHeader_t);
959 cmd->size = wlan_cpu_to_le16(cmd->size);
960 }
961 else if (cmd_action == HostCmd_ACT_GEN_SET)
962 {
963 if (keep_alive->enable)
964 {
965 MrvlIEtypes_Keep_Alive_Ctrl_t *ctrl_tlv = MNULL;
966 MrvlIEtypes_Keep_Alive_Pkt_t *pkt_tlv = MNULL;
967 t_u8 eth_ip[] = {0x08, 0x00};
968
969 keep_alive_tlv->enable = keep_alive->enable;
970 len = len + sizeof(keep_alive_tlv->keep_alive_id) + sizeof(keep_alive_tlv->enable);
971 pos = pos + len + sizeof(MrvlIEtypesHeader_t);
972 ctrl_tlv = (MrvlIEtypes_Keep_Alive_Ctrl_t *)pos;
973 ctrl_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_CTRL);
974 ctrl_tlv->header.len =
975 wlan_cpu_to_le16(sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t) - sizeof(MrvlIEtypesHeader_t));
976 ctrl_tlv->snd_interval = wlan_cpu_to_le32(keep_alive->send_interval);
977 ctrl_tlv->retry_interval = wlan_cpu_to_le16(keep_alive->retry_interval);
978 ctrl_tlv->retry_count = wlan_cpu_to_le16(keep_alive->retry_count);
979 len = len + sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t);
980
981 pos = pos + sizeof(MrvlIEtypes_Keep_Alive_Ctrl_t);
982 pkt_tlv = (MrvlIEtypes_Keep_Alive_Pkt_t *)pos;
983 pkt_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_KEEP_ALIVE_PKT);
984 (void)memcpy(pkt_tlv->eth_header.dest_addr, keep_alive->dst_mac, MLAN_MAC_ADDR_LENGTH);
985 (void)memcpy(pkt_tlv->eth_header.src_addr, keep_alive->src_mac, MLAN_MAC_ADDR_LENGTH);
986 (void)memcpy((t_u8 *)&pkt_tlv->eth_header.h803_len, eth_ip, sizeof(t_u16));
987 (void)memcpy(pkt_tlv->ip_packet, keep_alive->packet, keep_alive->pkt_len);
988 pkt_tlv->header.len = wlan_cpu_to_le16(sizeof(Eth803Hdr_t) + keep_alive->pkt_len);
989 len = len + sizeof(MrvlIEtypesHeader_t) + sizeof(Eth803Hdr_t) + keep_alive->pkt_len;
990 keep_alive_tlv->header.len = wlan_cpu_to_le16(len);
991
992 cmd->size = cmd->size + len + sizeof(MrvlIEtypesHeader_t);
993 cmd->size = wlan_cpu_to_le16(cmd->size);
994 }
995 else
996 {
997 keep_alive_tlv->enable = MFALSE;
998 len = len + sizeof(keep_alive_tlv->keep_alive_id) + sizeof(keep_alive_tlv->enable);
999 keep_alive_tlv->header.len = wlan_cpu_to_le16(len);
1000
1001 cmd->size = cmd->size + len + sizeof(MrvlIEtypesHeader_t);
1002 cmd->size = wlan_cpu_to_le16(cmd->size);
1003 }
1004 }
1005 else if (cmd_action == HostCmd_ACT_GEN_RESET)
1006 {
1007 keep_alive_tlv->enable = MFALSE;
1008 len = len + sizeof(keep_alive_tlv->keep_alive_id) + sizeof(keep_alive_tlv->enable);
1009 keep_alive_tlv->header.len = wlan_cpu_to_le16(len);
1010
1011 cmd->size = cmd->size + len + sizeof(MrvlIEtypesHeader_t);
1012 cmd->size = wlan_cpu_to_le16(cmd->size);
1013 }
1014
1015 cmd->result = 0x00;
1016 if (cmd_action == HostCmd_ACT_GEN_GET)
1017 {
1018 wifi_wait_for_cmdresp((void *)enable);
1019 }
1020 else
1021 {
1022 wifi_wait_for_cmdresp(NULL);
1023 }
1024
1025 return wm_wifi.cmd_resp_status;
1026 }
1027 #endif
1028
1029 #if CONFIG_RF_TEST_MODE
1030 #ifdef RW610
1031 /* 802.11n/a/g/b data rate IDs */
1032 #define DATARATE_1M 0x0001
1033 #define DATARATE_2M 0x0002
1034 #define DATARATE5_5M 0x0003
1035 #define DATARATE_11M 0x0004
1036 #define RESERVED_1 0x0005
1037
1038 #define DATARATE_6M 0x0006
1039 #define DATARATE_9M 0x0007
1040 #define DATARATE_12M 0x0008
1041 #define DATARATE_18M 0x0009
1042 #define DATARATE_24M 0x000A
1043 #define DATARATE_36M 0x000B
1044 #define DATARATE_48M 0x000C
1045 #define DATARATE_54M 0x000D
1046 #define RESERVED_2 0x000E
1047
1048 #define HT_MCS0 0x000F
1049 #define HT_MCS1 0x0010
1050 #define HT_MCS2 0x0011
1051 #define HT_MCS3 0x0012
1052 #define HT_MCS4 0x0013
1053 #define HT_MCS5 0x0014
1054 #define HT_MCS6 0x0015
1055 #define HT_MCS7 0x0016
1056
1057 /* 802.11ac VHT MCS rates ID */
1058 #define VHT_SS1_MCS0 0x1100
1059 #define VHT_SS1_MCS1 0x1101
1060 #define VHT_SS1_MCS2 0x1102
1061 #define VHT_SS1_MCS3 0x1103
1062 #define VHT_SS1_MCS4 0x1104
1063 #define VHT_SS1_MCS5 0x1105
1064 #define VHT_SS1_MCS6 0x1106
1065 #define VHT_SS1_MCS7 0x1107
1066 #define VHT_SS1_MCS8 0x1108
1067
1068 /* 802.11ax HE MCS rates ID */
1069 #define HE_SS1_MCS0 0x2100
1070 #define HE_SS1_MCS1 0x2101
1071 #define HE_SS1_MCS2 0x2102
1072 #define HE_SS1_MCS3 0x2103
1073 #define HE_SS1_MCS4 0x2104
1074 #define HE_SS1_MCS5 0x2105
1075 #define HE_SS1_MCS6 0x2106
1076 #define HE_SS1_MCS7 0x2107
1077 #define HE_SS1_MCS8 0x2108
1078 #define HE_SS1_MCS9 0x2109
1079
1080 static uint32_t tx_data_rate_ids[] = {
1081 /* 802.11n/a/g/b data rate IDs */
1082 DATARATE_1M, DATARATE_2M, DATARATE5_5M, DATARATE_11M, RESERVED_1, DATARATE_6M, DATARATE_9M, DATARATE_12M,
1083 DATARATE_18M, DATARATE_24M, DATARATE_36M, DATARATE_48M, DATARATE_54M, RESERVED_2, HT_MCS0, HT_MCS1, HT_MCS2,
1084 HT_MCS3, HT_MCS4, HT_MCS5, HT_MCS6, HT_MCS7,
1085 /* 802.11ac VHT MCS rates id */
1086 VHT_SS1_MCS0, VHT_SS1_MCS1, VHT_SS1_MCS2, VHT_SS1_MCS3, VHT_SS1_MCS4, VHT_SS1_MCS5, VHT_SS1_MCS6, VHT_SS1_MCS7,
1087 VHT_SS1_MCS8,
1088 /* 802.11ax HE MCS rates ID */
1089 HE_SS1_MCS0, HE_SS1_MCS1, HE_SS1_MCS2, HE_SS1_MCS3, HE_SS1_MCS4, HE_SS1_MCS5, HE_SS1_MCS6, HE_SS1_MCS7, HE_SS1_MCS8,
1090 HE_SS1_MCS9};
1091 #endif
1092
1093 static uint8_t band_set = 0;
1094 static uint8_t bandwidth_set = 0;
1095 static uint8_t tx_antenna_set = 0;
1096 static uint8_t rx_antenna_set = 0;
1097
wifi_get_set_rf_test_generic(t_u16 cmd_action,wifi_mfg_cmd_generic_cfg_t * wifi_mfg_cmd_generic_cfg)1098 int wifi_get_set_rf_test_generic(t_u16 cmd_action, wifi_mfg_cmd_generic_cfg_t *wifi_mfg_cmd_generic_cfg)
1099 {
1100 wifi_get_command_lock();
1101 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1102 mlan_ds_misc_cfg misc;
1103 cmd->seq_num = 0x0;
1104 cmd->result = 0x0;
1105
1106 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1107 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1108 0, NULL, wifi_mfg_cmd_generic_cfg, cmd);
1109 if (rv != MLAN_STATUS_SUCCESS)
1110 return -WM_FAIL;
1111
1112 wifi_wait_for_cmdresp(&misc);
1113 memcpy(wifi_mfg_cmd_generic_cfg, (wifi_mfg_cmd_generic_cfg_t *)&misc.param.mfg_generic_cfg,
1114 sizeof(wifi_mfg_cmd_generic_cfg_t));
1115 return wm_wifi.cmd_resp_status;
1116 }
1117
wifi_get_set_rf_test_tx_frame(t_u16 cmd_action,wifi_mfg_cmd_tx_frame_t * wifi_mfg_cmd_tx_frame,wifi_mfg_cmd_generic_cfg_t * wifi_mfg_cmd_generic_cfg)1118 int wifi_get_set_rf_test_tx_frame(t_u16 cmd_action,
1119 wifi_mfg_cmd_tx_frame_t *wifi_mfg_cmd_tx_frame,
1120 wifi_mfg_cmd_generic_cfg_t *wifi_mfg_cmd_generic_cfg)
1121 {
1122 wifi_get_command_lock();
1123 mlan_ds_misc_cfg misc;
1124 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1125
1126 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1127 cmd->seq_num = 0x0;
1128 cmd->result = 0x0;
1129 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1130 0, NULL, wifi_mfg_cmd_tx_frame, cmd);
1131 if (rv != MLAN_STATUS_SUCCESS)
1132 return -WM_FAIL;
1133
1134 wifi_wait_for_cmdresp(&misc);
1135 memcpy(wifi_mfg_cmd_generic_cfg, (wifi_mfg_cmd_generic_cfg_t *)&misc.param.mfg_generic_cfg,
1136 sizeof(wifi_mfg_cmd_generic_cfg_t));
1137 return wm_wifi.cmd_resp_status;
1138 }
1139
wifi_get_set_rf_trigger_frame_cfg(t_u16 cmd_action,wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr_t * wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr,wifi_mfg_cmd_generic_cfg_t * wifi_mfg_cmd_generic_cfg)1140 int wifi_get_set_rf_trigger_frame_cfg(t_u16 cmd_action,
1141 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr_t *wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr,
1142 wifi_mfg_cmd_generic_cfg_t *wifi_mfg_cmd_generic_cfg)
1143 {
1144 wifi_get_command_lock();
1145 mlan_ds_misc_cfg misc;
1146 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1147
1148 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1149 cmd->seq_num = 0x0;
1150 cmd->result = 0x0;
1151 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1152 0, NULL, wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr, cmd);
1153 if (rv != MLAN_STATUS_SUCCESS)
1154 return -WM_FAIL;
1155
1156 wifi_wait_for_cmdresp(&misc);
1157 memcpy(wifi_mfg_cmd_generic_cfg, (wifi_mfg_cmd_generic_cfg_t *)&misc.param.mfg_generic_cfg,
1158 sizeof(wifi_mfg_cmd_generic_cfg_t));
1159 return wm_wifi.cmd_resp_status;
1160 }
1161
wifi_get_set_rf_he_tb_tx(t_u16 cmd_action,wifi_mfg_cmd_he_tb_tx_t * wifi_mfg_cmd_he_tb_tx,wifi_mfg_cmd_generic_cfg_t * wifi_mfg_cmd_generic_cfg)1162 int wifi_get_set_rf_he_tb_tx(t_u16 cmd_action,
1163 wifi_mfg_cmd_he_tb_tx_t *wifi_mfg_cmd_he_tb_tx,
1164 wifi_mfg_cmd_generic_cfg_t *wifi_mfg_cmd_generic_cfg)
1165 {
1166 wifi_get_command_lock();
1167 mlan_ds_misc_cfg misc;
1168 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1169
1170 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1171 cmd->seq_num = 0x0;
1172 cmd->result = 0x0;
1173 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1174 0, NULL, wifi_mfg_cmd_he_tb_tx, cmd);
1175 if (rv != MLAN_STATUS_SUCCESS)
1176 return -WM_FAIL;
1177
1178 wifi_wait_for_cmdresp(&misc);
1179 memcpy(wifi_mfg_cmd_generic_cfg, (wifi_mfg_cmd_generic_cfg_t *)&misc.param.mfg_generic_cfg,
1180 sizeof(wifi_mfg_cmd_generic_cfg_t));
1181 return wm_wifi.cmd_resp_status;
1182 }
1183
wifi_get_set_rf_otp_mac_addr(t_u16 cmd_action,wifi_mfg_cmd_otp_mac_addr_rd_wr_t * wifi_mfg_cmd_otp_mac_addr_rd_wr)1184 int wifi_get_set_rf_otp_mac_addr(t_u16 cmd_action, wifi_mfg_cmd_otp_mac_addr_rd_wr_t *wifi_mfg_cmd_otp_mac_addr_rd_wr)
1185 {
1186 wifi_get_command_lock();
1187 mlan_ds_misc_cfg misc;
1188 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1189
1190 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1191 cmd->seq_num = 0x0;
1192 cmd->result = 0x0;
1193 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1194 0, NULL, wifi_mfg_cmd_otp_mac_addr_rd_wr, cmd);
1195 if (rv != MLAN_STATUS_SUCCESS)
1196 return -WM_FAIL;
1197
1198 wifi_wait_for_cmdresp(&misc);
1199 memcpy(wifi_mfg_cmd_otp_mac_addr_rd_wr, (wifi_mfg_cmd_otp_mac_addr_rd_wr_t *)&misc.param.mfg_otp_mac_addr_rd_wr,
1200 sizeof(wifi_mfg_cmd_otp_mac_addr_rd_wr_t));
1201 return wm_wifi.cmd_resp_status;
1202 }
1203
wifi_get_set_rf_otp_cal_data(t_u16 cmd_action,wifi_mfg_cmd_otp_cal_data_rd_wr_t * wifi_mfg_cmd_otp_cal_data_rd_wr)1204 int wifi_get_set_rf_otp_cal_data(t_u16 cmd_action, wifi_mfg_cmd_otp_cal_data_rd_wr_t *wifi_mfg_cmd_otp_cal_data_rd_wr)
1205 {
1206 wifi_get_command_lock();
1207 mlan_ds_misc_cfg *misc = NULL;
1208 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1209
1210 misc = (mlan_ds_misc_cfg *)OSA_MemoryAllocate(sizeof(mlan_ds_misc_cfg));
1211 (void)memset(misc, 0x00, sizeof(mlan_ds_misc_cfg));
1212 cmd->seq_num = 0x0;
1213 cmd->result = 0x0;
1214 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1215 0, NULL, wifi_mfg_cmd_otp_cal_data_rd_wr, cmd);
1216 if (rv != MLAN_STATUS_SUCCESS)
1217 {
1218 (void)OSA_MemoryFree(misc);
1219 return -WM_FAIL;
1220 }
1221
1222 wifi_wait_for_cmdresp(misc);
1223 memcpy(wifi_mfg_cmd_otp_cal_data_rd_wr, (wifi_mfg_cmd_otp_cal_data_rd_wr_t *)&(misc->param.mfg_otp_cal_data_rd_wr),
1224 sizeof(wifi_mfg_cmd_otp_cal_data_rd_wr_t));
1225 (void)OSA_MemoryFree(misc);
1226 return wm_wifi.cmd_resp_status;
1227 }
1228
wifi_get_set_rf_test_tx_cont(t_u16 cmd_action,wifi_mfg_cmd_tx_cont_t * wifi_mfg_cmd_tx_cont,wifi_mfg_cmd_generic_cfg_t * wifi_mfg_cmd_generic_cfg)1229 int wifi_get_set_rf_test_tx_cont(t_u16 cmd_action,
1230 wifi_mfg_cmd_tx_cont_t *wifi_mfg_cmd_tx_cont,
1231 wifi_mfg_cmd_generic_cfg_t *wifi_mfg_cmd_generic_cfg)
1232 {
1233 wifi_get_command_lock();
1234 mlan_ds_misc_cfg misc;
1235 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
1236
1237 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
1238 cmd->seq_num = 0x0;
1239 cmd->result = 0x0;
1240 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MFG_COMMAND, cmd_action,
1241 0, NULL, wifi_mfg_cmd_tx_cont, cmd);
1242 if (rv != MLAN_STATUS_SUCCESS)
1243 return -WM_FAIL;
1244
1245 wifi_wait_for_cmdresp(&misc);
1246 memcpy(wifi_mfg_cmd_generic_cfg, (wifi_mfg_cmd_generic_cfg_t *)&misc.param.mfg_generic_cfg,
1247 sizeof(wifi_mfg_cmd_generic_cfg_t));
1248 return wm_wifi.cmd_resp_status;
1249 }
1250
wifi_set_rf_test_mode(void)1251 int wifi_set_rf_test_mode(void)
1252 {
1253 int ret;
1254 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1255
1256 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1257
1258 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_SET_TEST_MODE;
1259 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1260
1261 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1262 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1263 {
1264 return WM_SUCCESS;
1265 }
1266
1267 wifi_e("wifi set rf test mode fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1268 return -WM_FAIL;
1269 }
1270
wifi_unset_rf_test_mode(void)1271 int wifi_unset_rf_test_mode(void)
1272 {
1273 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1274
1275 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1276
1277 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_UNSET_TEST_MODE;
1278 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1279
1280 (void)wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1281
1282 return WM_SUCCESS;
1283 }
1284
wifi_set_rf_channel(const uint8_t channel)1285 int wifi_set_rf_channel(const uint8_t channel)
1286 {
1287 int ret;
1288
1289 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1290
1291 /* To align with mxdriver, skip channel valid check for rf test mode */
1292 #if 0
1293 /* Check if Channel is allowed as per WWSM */
1294 if (!wlan_is_channel_valid(channel))
1295 return -WM_FAIL;
1296 #endif
1297
1298 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1299
1300 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_CHAN;
1301 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1302
1303 wifi_mfg_cmd_generic_cfg.data1 = channel;
1304
1305 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1306
1307 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1308 {
1309 return WM_SUCCESS;
1310 }
1311
1312 wifi_e("wifi set rf channel fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1313 return -WM_FAIL;
1314 }
1315
wifi_set_rf_radio_mode(const uint8_t mode)1316 int wifi_set_rf_radio_mode(const uint8_t mode)
1317 {
1318 int ret;
1319
1320 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1321
1322 /* Check if radio mode is valid */
1323 if (!wlan_is_radio_mode_valid(mode))
1324 {
1325 return -WM_FAIL;
1326 }
1327
1328 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1329
1330 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RADIO_MODE_CFG;
1331 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1332 wifi_mfg_cmd_generic_cfg.data1 = mode;
1333
1334 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1335 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1336 {
1337 return WM_SUCCESS;
1338 }
1339
1340 wifi_e("wifi set radio mode fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1341 return -WM_FAIL;
1342 }
1343
wifi_get_rf_channel(uint8_t * channel)1344 int wifi_get_rf_channel(uint8_t *channel)
1345 {
1346 int ret;
1347
1348 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1349
1350 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1351
1352 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_CHAN;
1353 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1354
1355 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1356
1357 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1358 {
1359 *channel = wifi_mfg_cmd_generic_cfg.data1;
1360 return WM_SUCCESS;
1361 }
1362
1363 wifi_e("wifi get rf channel fail, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1364 return -WM_FAIL;
1365 }
1366
wifi_get_rf_radio_mode(uint8_t * mode)1367 int wifi_get_rf_radio_mode(uint8_t *mode)
1368 {
1369 int ret;
1370
1371 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1372
1373 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1374
1375 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RADIO_MODE_CFG;
1376 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1377
1378 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1379
1380 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1381 {
1382 *mode = wifi_mfg_cmd_generic_cfg.data1;
1383 return WM_SUCCESS;
1384 }
1385
1386 wifi_e("wifi get rf radio fail, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1387 return -WM_FAIL;
1388 }
1389
wifi_set_rf_band(const uint8_t band)1390 int wifi_set_rf_band(const uint8_t band)
1391 {
1392 int ret;
1393
1394 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1395
1396 if (band != 0U
1397 #if CONFIG_5GHz_SUPPORT
1398 && band != 1U
1399 #endif
1400 )
1401 return -WM_FAIL;
1402
1403 #if CONFIG_5GHz_SUPPORT
1404 if ((band == 1) && ISSUPP_NO5G(mlan_adap->fw_cap_ext))
1405 {
1406 wifi_e("Not support 5G, please set 2G band");
1407 return -WM_FAIL;
1408 }
1409 #endif
1410
1411 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1412
1413 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_BAND_AG;
1414 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1415
1416 wifi_mfg_cmd_generic_cfg.data1 = band;
1417
1418 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1419
1420 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1421 {
1422 band_set = 1;
1423 return WM_SUCCESS;
1424 }
1425
1426 wifi_e("Wifi set rf band fails, error code: 0x%x", wifi_mfg_cmd_generic_cfg.error);
1427 return -WM_FAIL;
1428 }
1429
wifi_get_rf_band(uint8_t * band)1430 int wifi_get_rf_band(uint8_t *band)
1431 {
1432 int ret;
1433
1434 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1435
1436 if (!band_set)
1437 {
1438 wifi_e("RF Band not set");
1439 return -WM_FAIL;
1440 }
1441
1442 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1443
1444 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_BAND_AG;
1445 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1446
1447 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1448 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1449 {
1450 *band = wifi_mfg_cmd_generic_cfg.data1;
1451 return WM_SUCCESS;
1452 }
1453
1454 wifi_e("Wifi get rf band fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1455 return -WM_FAIL;
1456 }
1457
wifi_set_rf_bandwidth(const uint8_t bandwidth)1458 int wifi_set_rf_bandwidth(const uint8_t bandwidth)
1459 {
1460 int ret;
1461
1462 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1463
1464 if ((bandwidth != 0U)
1465 #if CONFIG_5GHz_SUPPORT
1466 && (bandwidth != 1U)
1467 #endif
1468 #if CONFIG_11AC
1469 && (bandwidth != 4U)
1470 #endif
1471 )
1472 {
1473 return -WM_FAIL;
1474 }
1475
1476 if ((bandwidth != 0) && ISSUPP_NO5G(mlan_adap->fw_cap_ext))
1477 {
1478 wifi_e("Not support 5G, please set 2G bandwidth");
1479 return -WM_FAIL;
1480 }
1481
1482 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1483
1484 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_CHANNELBW;
1485 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1486
1487 wifi_mfg_cmd_generic_cfg.data1 = bandwidth;
1488
1489 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1490 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1491 {
1492 bandwidth_set = 1;
1493 return WM_SUCCESS;
1494 }
1495
1496 wifi_e("Wifi set rf bandwidth fails, error code: 0x%x", wifi_mfg_cmd_generic_cfg.error);
1497 return -WM_FAIL;
1498 }
1499
wifi_get_rf_bandwidth(uint8_t * bandwidth)1500 int wifi_get_rf_bandwidth(uint8_t *bandwidth)
1501 {
1502 int ret;
1503
1504 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1505
1506 if (!bandwidth_set)
1507 {
1508 wifi_e("Bandwidth not set");
1509 return -WM_FAIL;
1510 }
1511
1512 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1513
1514 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RF_CHANNELBW;
1515 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1516
1517 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1518 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1519 {
1520 *bandwidth = wifi_mfg_cmd_generic_cfg.data1;
1521 return WM_SUCCESS;
1522 }
1523
1524 wifi_e("Wifi get rf bandwidth fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1525 return -WM_FAIL;
1526 }
1527
wifi_get_rf_per(uint32_t * rx_tot_pkt_count,uint32_t * rx_mcast_bcast_count,uint32_t * rx_pkt_fcs_error)1528 int wifi_get_rf_per(uint32_t *rx_tot_pkt_count, uint32_t *rx_mcast_bcast_count, uint32_t *rx_pkt_fcs_error)
1529 {
1530 int ret;
1531
1532 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1533
1534 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1535
1536 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_CLR_RX_ERR;
1537 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1538
1539 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1540 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1541 {
1542 *rx_tot_pkt_count = wifi_mfg_cmd_generic_cfg.data1;
1543 *rx_mcast_bcast_count = wifi_mfg_cmd_generic_cfg.data2;
1544 *rx_pkt_fcs_error = wifi_mfg_cmd_generic_cfg.data3;
1545 return WM_SUCCESS;
1546 }
1547
1548 wifi_e("Wifi get rf per fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1549 return -WM_FAIL;
1550 }
1551
wifi_set_rf_tx_cont_mode(const uint32_t enable_tx,const uint32_t cw_mode,const uint32_t payload_pattern,const uint32_t cs_mode,const uint32_t act_sub_ch,const uint32_t tx_rate)1552 int wifi_set_rf_tx_cont_mode(const uint32_t enable_tx,
1553 const uint32_t cw_mode,
1554 const uint32_t payload_pattern,
1555 const uint32_t cs_mode,
1556 const uint32_t act_sub_ch,
1557 const uint32_t tx_rate)
1558 {
1559 wifi_mfg_cmd_tx_cont_t wifi_mfg_cmd_tx_cont;
1560 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1561 int ret;
1562
1563 if ((enable_tx > 1U) || (cw_mode > 1U) || (cs_mode > 1U) || (act_sub_ch == 2U || act_sub_ch > 3U))
1564 return -WM_FAIL;
1565
1566 (void)memset(&wifi_mfg_cmd_tx_cont, 0x00, sizeof(wifi_mfg_cmd_tx_cont_t));
1567 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1568
1569 wifi_mfg_cmd_tx_cont.mfg_cmd = MFG_CMD_TX_CONT;
1570 wifi_mfg_cmd_tx_cont.action = HostCmd_ACT_GEN_SET;
1571
1572 wifi_mfg_cmd_tx_cont.enable_tx = enable_tx;
1573 wifi_mfg_cmd_tx_cont.cw_mode = cw_mode;
1574 wifi_mfg_cmd_tx_cont.payload_pattern = payload_pattern;
1575 wifi_mfg_cmd_tx_cont.cs_mode = cs_mode;
1576 wifi_mfg_cmd_tx_cont.act_sub_ch = act_sub_ch;
1577 wifi_mfg_cmd_tx_cont.tx_rate = tx_rate;
1578
1579 ret = wifi_get_set_rf_test_tx_cont(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_tx_cont, &wifi_mfg_cmd_generic_cfg);
1580 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1581 {
1582 return WM_SUCCESS;
1583 }
1584
1585 wifi_e("Wifi set rf tx cont mode fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1586 return -WM_FAIL;
1587 }
1588
wifi_set_rf_tx_antenna(const uint8_t antenna)1589 int wifi_set_rf_tx_antenna(const uint8_t antenna)
1590 {
1591 int ret;
1592
1593 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1594
1595 if (antenna != 1U && antenna != 2U)
1596 return -WM_FAIL;
1597
1598 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1599
1600 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_TX_ANT;
1601 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1602
1603 wifi_mfg_cmd_generic_cfg.data1 = antenna;
1604
1605 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1606 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1607 {
1608 tx_antenna_set = 1;
1609 return WM_SUCCESS;
1610 }
1611
1612 wifi_e("Wifi set rf tx antenna fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1613 return -WM_FAIL;
1614 }
1615
wifi_get_rf_tx_antenna(uint8_t * antenna)1616 int wifi_get_rf_tx_antenna(uint8_t *antenna)
1617 {
1618 int ret;
1619
1620 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1621
1622 if (!tx_antenna_set)
1623 {
1624 wifi_e("Tx Antenna not set");
1625 return -WM_FAIL;
1626 }
1627
1628 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1629
1630 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_TX_ANT;
1631 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1632
1633 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1634 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1635 {
1636 *antenna = wifi_mfg_cmd_generic_cfg.data1;
1637 return WM_SUCCESS;
1638 }
1639
1640 wifi_e("Wifi get rf tx antenna fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1641 return -WM_FAIL;
1642 ;
1643 }
1644
wifi_set_rf_rx_antenna(const uint8_t antenna)1645 int wifi_set_rf_rx_antenna(const uint8_t antenna)
1646 {
1647 int ret;
1648
1649 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1650
1651 if (antenna != 1U && antenna != 2U)
1652 return -WM_FAIL;
1653
1654 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1655
1656 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RX_ANT;
1657 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1658
1659 wifi_mfg_cmd_generic_cfg.data1 = antenna;
1660
1661 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1662 if (ret == WM_SUCCESS && wifi_mfg_cmd_generic_cfg.error == 0)
1663 {
1664 rx_antenna_set = 1;
1665 return WM_SUCCESS;
1666 }
1667
1668 wifi_e("Wifi get rf tx antenna fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1669 return -WM_FAIL;
1670 }
1671
wifi_get_rf_rx_antenna(uint8_t * antenna)1672 int wifi_get_rf_rx_antenna(uint8_t *antenna)
1673 {
1674 int ret;
1675
1676 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1677
1678 if (!rx_antenna_set)
1679 {
1680 wifi_e("Rx antenna not set");
1681 return -WM_FAIL;
1682 }
1683
1684 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1685
1686 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RX_ANT;
1687 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_GET;
1688
1689 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_generic_cfg);
1690
1691 if (ret == WM_SUCCESS)
1692 *antenna = wifi_mfg_cmd_generic_cfg.data1;
1693
1694 return ret;
1695 }
1696
wifi_set_rf_tx_power(const uint32_t power,const uint8_t mod,const uint8_t path_id)1697 int wifi_set_rf_tx_power(const uint32_t power, const uint8_t mod, const uint8_t path_id)
1698 {
1699 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1700 int ret;
1701
1702 if (mod != 0U && mod != 1U && mod != 2U)
1703 return -WM_FAIL;
1704
1705 if (path_id != 0U && path_id != 1U && path_id != 2U)
1706 return -WM_FAIL;
1707
1708 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1709
1710 wifi_mfg_cmd_generic_cfg.mfg_cmd = MFG_CMD_RFPWR;
1711 wifi_mfg_cmd_generic_cfg.action = HostCmd_ACT_GEN_SET;
1712 #ifdef SD9177
1713 /* Firecrest firmware expects value * 16 */
1714 wifi_mfg_cmd_generic_cfg.data1 = power * 16;
1715 #else
1716 wifi_mfg_cmd_generic_cfg.data1 = power;
1717 #endif
1718 wifi_mfg_cmd_generic_cfg.data2 = mod;
1719 wifi_mfg_cmd_generic_cfg.data3 = path_id;
1720
1721 ret = wifi_get_set_rf_test_generic(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_generic_cfg);
1722 if (ret == WM_SUCCESS)
1723 {
1724 return WM_SUCCESS;
1725 }
1726
1727 wifi_e("Wifi set rf tx power fails, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1728 return -WM_FAIL;
1729 }
1730
1731 #ifdef RW610
wifi_check_data_rate_id(const uint32_t data_rate)1732 static int wifi_check_data_rate_id(const uint32_t data_rate)
1733 {
1734 uint8_t i;
1735 for (i = 0; i < sizeof(tx_data_rate_ids) / sizeof(tx_data_rate_ids[0]); i++)
1736 {
1737 if (data_rate == tx_data_rate_ids[i])
1738 {
1739 return WM_SUCCESS;
1740 }
1741 }
1742 return -WM_FAIL;
1743 }
1744 #endif
1745
wifi_set_rf_tx_frame(const uint32_t enable,const uint32_t data_rate,const uint32_t frame_pattern,const uint32_t frame_length,const uint16_t adjust_burst_sifs,const uint32_t burst_sifs_in_us,const uint32_t short_preamble,const uint32_t act_sub_ch,const uint32_t short_gi,const uint32_t adv_coding,const uint32_t tx_bf,const uint32_t gf_mode,const uint32_t stbc,const uint8_t * bssid)1746 int wifi_set_rf_tx_frame(const uint32_t enable,
1747 const uint32_t data_rate,
1748 const uint32_t frame_pattern,
1749 const uint32_t frame_length,
1750 const uint16_t adjust_burst_sifs,
1751 const uint32_t burst_sifs_in_us,
1752 const uint32_t short_preamble,
1753 const uint32_t act_sub_ch,
1754 const uint32_t short_gi,
1755 const uint32_t adv_coding,
1756 const uint32_t tx_bf,
1757 const uint32_t gf_mode,
1758 const uint32_t stbc,
1759 const uint8_t *bssid)
1760 {
1761 wifi_mfg_cmd_tx_frame_t wifi_mfg_cmd_tx_frame;
1762 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1763 int ret;
1764
1765 if (enable > 1U || frame_length < 1U || frame_length > 0x400U || burst_sifs_in_us > 255U || short_preamble > 1U ||
1766 act_sub_ch == 2U || act_sub_ch > 3U || short_gi > 1U || adv_coding > 1U || tx_bf > 1U || gf_mode > 1U ||
1767 stbc > 1U)
1768 return -WM_FAIL;
1769
1770 (void)memset(&wifi_mfg_cmd_tx_frame, 0x00, sizeof(wifi_mfg_cmd_tx_frame_t));
1771 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1772 #ifdef RW610
1773 ret = wifi_check_data_rate_id(data_rate);
1774 if ((enable == 1U) && (ret != WM_SUCCESS))
1775 {
1776 wifi_e("The configured data rate ID is illegal. data_rate_id: 0x%x\r\n", data_rate);
1777 return ret;
1778 }
1779 #endif
1780
1781 wifi_mfg_cmd_tx_frame.mfg_cmd = MFG_CMD_TX_FRAME;
1782 wifi_mfg_cmd_tx_frame.action = HostCmd_ACT_GEN_SET;
1783
1784 wifi_mfg_cmd_tx_frame.enable = enable;
1785 wifi_mfg_cmd_tx_frame.data_rate = data_rate;
1786 #ifdef RW610
1787 /* on fw side, data rate id of 802.11n/a/g/b start from 0, the data rate id need reduce 1 */
1788 if (data_rate <= HT_MCS7)
1789 {
1790 wifi_mfg_cmd_tx_frame.data_rate--;
1791 }
1792 #endif
1793
1794 wifi_mfg_cmd_tx_frame.frame_pattern = frame_pattern;
1795 wifi_mfg_cmd_tx_frame.frame_length = frame_length;
1796 (void)memcpy((void *)wifi_mfg_cmd_tx_frame.bssid, (const void *)bssid, MLAN_MAC_ADDR_LENGTH);
1797 wifi_mfg_cmd_tx_frame.adjust_burst_sifs = adjust_burst_sifs;
1798 wifi_mfg_cmd_tx_frame.burst_sifs_in_us = burst_sifs_in_us;
1799 wifi_mfg_cmd_tx_frame.short_preamble = short_preamble;
1800 wifi_mfg_cmd_tx_frame.act_sub_ch = act_sub_ch;
1801 wifi_mfg_cmd_tx_frame.short_gi = short_gi;
1802 wifi_mfg_cmd_tx_frame.adv_coding = adv_coding;
1803 wifi_mfg_cmd_tx_frame.tx_bf = tx_bf;
1804 wifi_mfg_cmd_tx_frame.gf_mode = gf_mode;
1805 wifi_mfg_cmd_tx_frame.stbc = stbc;
1806
1807 ret = wifi_get_set_rf_test_tx_frame(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_tx_frame, &wifi_mfg_cmd_generic_cfg);
1808 if (WM_SUCCESS == ret && wifi_mfg_cmd_generic_cfg.error == 0)
1809 {
1810 return WM_SUCCESS;
1811 }
1812
1813 wifi_e("wifi set rf tx frame fail, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1814 return -WM_FAIL;
1815 }
1816
wifi_rf_trigger_frame_cfg(uint32_t Enable_tx,uint32_t Standalone_hetb,uint8_t FRAME_CTRL_TYPE,uint8_t FRAME_CTRL_SUBTYPE,uint16_t FRAME_DURATION,uint64_t TriggerType,uint64_t UlLen,uint64_t MoreTF,uint64_t CSRequired,uint64_t UlBw,uint64_t LTFType,uint64_t LTFMode,uint64_t LTFSymbol,uint64_t UlSTBC,uint64_t LdpcESS,uint64_t ApTxPwr,uint64_t PreFecPadFct,uint64_t PeDisambig,uint64_t SpatialReuse,uint64_t Doppler,uint64_t HeSig2,uint32_t AID12,uint32_t RUAllocReg,uint32_t RUAlloc,uint32_t UlCodingType,uint32_t UlMCS,uint32_t UlDCM,uint32_t SSAlloc,uint8_t UlTargetRSSI,uint8_t MPDU_MU_SF,uint8_t TID_AL,uint8_t AC_PL,uint8_t Pref_AC)1817 int wifi_rf_trigger_frame_cfg(uint32_t Enable_tx,
1818 uint32_t Standalone_hetb,
1819 uint8_t FRAME_CTRL_TYPE,
1820 uint8_t FRAME_CTRL_SUBTYPE,
1821 uint16_t FRAME_DURATION,
1822 uint64_t TriggerType,
1823 uint64_t UlLen,
1824 uint64_t MoreTF,
1825 uint64_t CSRequired,
1826 uint64_t UlBw,
1827 uint64_t LTFType,
1828 uint64_t LTFMode,
1829 uint64_t LTFSymbol,
1830 uint64_t UlSTBC,
1831 uint64_t LdpcESS,
1832 uint64_t ApTxPwr,
1833 uint64_t PreFecPadFct,
1834 uint64_t PeDisambig,
1835 uint64_t SpatialReuse,
1836 uint64_t Doppler,
1837 uint64_t HeSig2,
1838 uint32_t AID12,
1839 uint32_t RUAllocReg,
1840 uint32_t RUAlloc,
1841 uint32_t UlCodingType,
1842 uint32_t UlMCS,
1843 uint32_t UlDCM,
1844 uint32_t SSAlloc,
1845 uint8_t UlTargetRSSI,
1846 uint8_t MPDU_MU_SF,
1847 uint8_t TID_AL,
1848 uint8_t AC_PL,
1849 uint8_t Pref_AC)
1850 {
1851 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr_t wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr;
1852 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1853 int ret;
1854
1855 (void)memset(&wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr, 0x00, sizeof(wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr_t));
1856 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1857 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.mfg_cmd = MFG_CMD_CONFIG_TRIGGER_FRAME;
1858 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.action = HostCmd_ACT_GEN_SET;
1859
1860 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.enable_tx = Enable_tx;
1861 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.standalone_hetb = Standalone_hetb;
1862 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.frmCtl.type = FRAME_CTRL_TYPE;
1863 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.frmCtl.sub_type = FRAME_CTRL_SUBTYPE;
1864 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.duration = FRAME_DURATION;
1865
1866 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.trigger_type = TriggerType;
1867 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ul_len = UlLen;
1868 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.more_tf = MoreTF;
1869 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.cs_required = CSRequired;
1870 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ul_bw = UlBw;
1871 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ltf_type = LTFType;
1872 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ltf_mode = LTFMode;
1873 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ltf_symbol = LTFSymbol;
1874 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ul_stbc = UlSTBC;
1875 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ldpc_ess = LdpcESS;
1876 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.ap_tx_pwr = ApTxPwr;
1877 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.pre_fec_pad_fct = PreFecPadFct;
1878 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.pe_disambig = PeDisambig;
1879 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.spatial_reuse = SpatialReuse;
1880 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.doppler = Doppler;
1881 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_common_field.he_sig2 = HeSig2;
1882
1883 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.aid12 = AID12;
1884 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ru_alloc_reg = RUAllocReg;
1885 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ru_alloc = RUAlloc;
1886 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ul_coding_type = UlCodingType;
1887 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ul_mcs = UlMCS;
1888 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ul_dcm = UlDCM;
1889 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ss_alloc = SSAlloc;
1890 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.trig_user_info_field.ul_target_rssi = UlTargetRSSI;
1891
1892 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.basic_trig_user_info.mpdu_mu_sf = MPDU_MU_SF;
1893 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.basic_trig_user_info.tid_al = TID_AL;
1894 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.basic_trig_user_info.ac_pl = AC_PL;
1895 wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr.basic_trig_user_info.pref_ac = Pref_AC;
1896
1897 ret = wifi_get_set_rf_trigger_frame_cfg(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_IEEEtypes_CtlBasicTrigHdr,
1898 &wifi_mfg_cmd_generic_cfg);
1899 if (WM_SUCCESS == ret && wifi_mfg_cmd_generic_cfg.error == 0)
1900 {
1901 return WM_SUCCESS;
1902 }
1903
1904 wifi_e("wifi set rf tx frame fail, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1905 return -WM_FAIL;
1906 }
1907
wifi_cfg_rf_he_tb_tx(uint16_t enable,uint16_t qnum,uint16_t aid,uint16_t axq_mu_timer,int16_t tx_power)1908 int wifi_cfg_rf_he_tb_tx(uint16_t enable, uint16_t qnum, uint16_t aid, uint16_t axq_mu_timer, int16_t tx_power)
1909 {
1910 wifi_mfg_cmd_he_tb_tx_t wifi_mfg_cmd_he_tb_tx;
1911
1912 wifi_mfg_cmd_generic_cfg_t wifi_mfg_cmd_generic_cfg;
1913 int ret;
1914
1915 (void)memset(&wifi_mfg_cmd_he_tb_tx, 0x00, sizeof(wifi_mfg_cmd_he_tb_tx_t));
1916 (void)memset(&wifi_mfg_cmd_generic_cfg, 0x00, sizeof(wifi_mfg_cmd_generic_cfg_t));
1917 wifi_mfg_cmd_he_tb_tx.mfg_cmd = MFG_CMD_CONFIG_MAC_HE_TB_TX;
1918 wifi_mfg_cmd_he_tb_tx.action = HostCmd_ACT_GEN_SET;
1919
1920 wifi_mfg_cmd_he_tb_tx.enable = enable;
1921 wifi_mfg_cmd_he_tb_tx.qnum = qnum;
1922 wifi_mfg_cmd_he_tb_tx.aid = aid;
1923 wifi_mfg_cmd_he_tb_tx.axq_mu_timer = axq_mu_timer;
1924 wifi_mfg_cmd_he_tb_tx.tx_power = tx_power;
1925
1926 ret = wifi_get_set_rf_he_tb_tx(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_he_tb_tx, &wifi_mfg_cmd_generic_cfg);
1927 if (WM_SUCCESS == ret && wifi_mfg_cmd_generic_cfg.error == 0)
1928 {
1929 return WM_SUCCESS;
1930 }
1931
1932 wifi_e("wifi set rf tx frame fail, error code: 0x%x\r\n", wifi_mfg_cmd_generic_cfg.error);
1933 return -WM_FAIL;
1934 }
1935
wifi_set_rf_otp_mac_addr(uint8_t * mac)1936 int wifi_set_rf_otp_mac_addr(uint8_t *mac)
1937 {
1938 int ret;
1939
1940 wifi_mfg_cmd_otp_mac_addr_rd_wr_t wifi_mfg_cmd_otp_mac_addr_rd_wr;
1941
1942 (void)memset(&wifi_mfg_cmd_otp_mac_addr_rd_wr, 0x00, sizeof(wifi_mfg_cmd_otp_mac_addr_rd_wr_t));
1943
1944 wifi_mfg_cmd_otp_mac_addr_rd_wr.mfg_cmd = MFG_CMD_OTP_MAC_ADD;
1945 wifi_mfg_cmd_otp_mac_addr_rd_wr.action = HostCmd_ACT_GEN_SET;
1946 (void)memcpy((void *)wifi_mfg_cmd_otp_mac_addr_rd_wr.mac_addr, (const void *)mac, MLAN_MAC_ADDR_LENGTH);
1947
1948 ret = wifi_get_set_rf_otp_mac_addr(HostCmd_ACT_GEN_SET, &wifi_mfg_cmd_otp_mac_addr_rd_wr);
1949 if (ret == WM_SUCCESS && wifi_mfg_cmd_otp_mac_addr_rd_wr.error == 0)
1950 {
1951 return WM_SUCCESS;
1952 }
1953
1954 wifi_e("wifi set otp mac address fails, error code: 0x%x\r\n", wifi_mfg_cmd_otp_mac_addr_rd_wr.error);
1955 return -WM_FAIL;
1956 }
1957
wifi_get_rf_otp_mac_addr(uint8_t * mac)1958 int wifi_get_rf_otp_mac_addr(uint8_t *mac)
1959 {
1960 int ret;
1961
1962 wifi_mfg_cmd_otp_mac_addr_rd_wr_t wifi_mfg_cmd_otp_mac_addr_rd_wr;
1963
1964 (void)memset(&wifi_mfg_cmd_otp_mac_addr_rd_wr, 0x00, sizeof(wifi_mfg_cmd_otp_mac_addr_rd_wr_t));
1965
1966 wifi_mfg_cmd_otp_mac_addr_rd_wr.mfg_cmd = MFG_CMD_OTP_MAC_ADD;
1967 wifi_mfg_cmd_otp_mac_addr_rd_wr.action = HostCmd_ACT_GEN_GET;
1968
1969 ret = wifi_get_set_rf_otp_mac_addr(HostCmd_ACT_GEN_GET, &wifi_mfg_cmd_otp_mac_addr_rd_wr);
1970 if (ret == WM_SUCCESS && wifi_mfg_cmd_otp_mac_addr_rd_wr.error == 0)
1971 {
1972 (void)memcpy((void *)mac, (const void *)wifi_mfg_cmd_otp_mac_addr_rd_wr.mac_addr, MLAN_MAC_ADDR_LENGTH);
1973 return WM_SUCCESS;
1974 }
1975
1976 wifi_e("wifi get otp mac address fails, error code: 0x%x\r\n", wifi_mfg_cmd_otp_mac_addr_rd_wr.error);
1977 return -WM_FAIL;
1978 }
1979
wifi_set_rf_otp_cal_data(const uint8_t * cal_data,uint32_t cal_data_len)1980 int wifi_set_rf_otp_cal_data(const uint8_t *cal_data, uint32_t cal_data_len)
1981 {
1982 int ret;
1983
1984 wifi_mfg_cmd_otp_cal_data_rd_wr_t *wifi_mfg_cmd_otp_cal_data_rd_wr = NULL;
1985
1986 wifi_mfg_cmd_otp_cal_data_rd_wr =
1987 (wifi_mfg_cmd_otp_cal_data_rd_wr_t *)OSA_MemoryAllocate(sizeof(wifi_mfg_cmd_otp_cal_data_rd_wr_t));
1988 (void)memset(wifi_mfg_cmd_otp_cal_data_rd_wr, 0x00, sizeof(wifi_mfg_cmd_otp_cal_data_rd_wr_t));
1989
1990 wifi_mfg_cmd_otp_cal_data_rd_wr->mfg_cmd = MFG_CMD_OTP_CAL_DATA;
1991 wifi_mfg_cmd_otp_cal_data_rd_wr->action = HostCmd_ACT_GEN_SET;
1992 wifi_mfg_cmd_otp_cal_data_rd_wr->cal_data_len = cal_data_len;
1993 (void)memcpy((void *)wifi_mfg_cmd_otp_cal_data_rd_wr->cal_data, (const void *)cal_data, cal_data_len);
1994
1995 ret = wifi_get_set_rf_otp_cal_data(HostCmd_ACT_GEN_SET, wifi_mfg_cmd_otp_cal_data_rd_wr);
1996 if (ret == WM_SUCCESS && wifi_mfg_cmd_otp_cal_data_rd_wr->error == 0)
1997 {
1998 ret = WM_SUCCESS;
1999 }
2000 else
2001 {
2002 wifi_e("wifi set cal data fails, error code: 0x%x\r\n", wifi_mfg_cmd_otp_cal_data_rd_wr->error);
2003 ret = -WM_FAIL;
2004 }
2005
2006 (void)OSA_MemoryFree(wifi_mfg_cmd_otp_cal_data_rd_wr);
2007 return ret;
2008 }
2009
wifi_get_rf_otp_cal_data(uint8_t * cal_data)2010 int wifi_get_rf_otp_cal_data(uint8_t *cal_data)
2011 {
2012 int ret;
2013 uint32_t cal_data_status = 0;
2014
2015 wifi_mfg_cmd_otp_cal_data_rd_wr_t *wifi_mfg_cmd_otp_cal_data_rd_wr = NULL;
2016
2017 wifi_mfg_cmd_otp_cal_data_rd_wr =
2018 (wifi_mfg_cmd_otp_cal_data_rd_wr_t *)OSA_MemoryAllocate(sizeof(wifi_mfg_cmd_otp_cal_data_rd_wr_t));
2019 (void)memset(wifi_mfg_cmd_otp_cal_data_rd_wr, 0x00, sizeof(wifi_mfg_cmd_otp_cal_data_rd_wr_t));
2020
2021 wifi_mfg_cmd_otp_cal_data_rd_wr->mfg_cmd = MFG_CMD_OTP_CAL_DATA;
2022 wifi_mfg_cmd_otp_cal_data_rd_wr->action = HostCmd_ACT_GEN_GET;
2023
2024 ret = wifi_get_set_rf_otp_cal_data(HostCmd_ACT_GEN_GET, wifi_mfg_cmd_otp_cal_data_rd_wr);
2025 if (ret == WM_SUCCESS && wifi_mfg_cmd_otp_cal_data_rd_wr->error == 0)
2026 {
2027 cal_data_status = wifi_mfg_cmd_otp_cal_data_rd_wr->cal_data_status;
2028 if (cal_data_status == 1)
2029 {
2030 (void)memcpy((void *)cal_data, (const void *)wifi_mfg_cmd_otp_cal_data_rd_wr->cal_data,
2031 wifi_mfg_cmd_otp_cal_data_rd_wr->cal_data_len);
2032 ret = WM_SUCCESS;
2033 }
2034 else
2035 {
2036 ret = -WM_FAIL;
2037 }
2038 }
2039 else
2040 {
2041 wifi_e("wifi get otp cal data fails, error code: 0x%x\r\n", wifi_mfg_cmd_otp_cal_data_rd_wr->error);
2042 ret = -WM_FAIL;
2043 }
2044
2045 (void)OSA_MemoryFree(wifi_mfg_cmd_otp_cal_data_rd_wr);
2046
2047 return ret;
2048 }
2049 #endif
2050
2051 /*
2052 * fixme: Currently, we support only single SSID based scan. We can extend
2053 * this to a list of multiple SSIDs. The mlan API supports this.
2054 */
wifi_send_scan_cmd(t_u8 bss_mode,const t_u8 * specific_bssid,const char * ssid,uint8_t ssid_num,const t_u8 num_channels,const wifi_scan_channel_list_t * chan_list,const t_u8 num_probes,const t_s16 rssi_threshold,const t_u16 scan_chan_gap,const bool keep_previous_scan,const bool active_scan_triggered)2055 int wifi_send_scan_cmd(t_u8 bss_mode,
2056 const t_u8 *specific_bssid,
2057 const char *ssid,
2058 uint8_t ssid_num,
2059 const t_u8 num_channels,
2060 const wifi_scan_channel_list_t *chan_list,
2061 const t_u8 num_probes,
2062 #if CONFIG_SCAN_WITH_RSSIFILTER
2063 const t_s16 rssi_threshold,
2064 #endif
2065 #if CONFIG_SCAN_CHANNEL_GAP
2066 const t_u16 scan_chan_gap,
2067 #endif
2068 const bool keep_previous_scan,
2069 const bool active_scan_triggered)
2070 {
2071 int ssid_len = 0;
2072 char const *tmp_ssid = ssid;
2073 t_u8 i;
2074 #if CONFIG_COMBO_SCAN
2075 const char wildcard_ssid[] = "*";
2076 #endif
2077 mlan_adap->active_scan_triggered = MFALSE;
2078
2079 #if CONFIG_WPA_SUPP
2080 if (mlan_adap->wpa_supp_scan_triggered == MTRUE)
2081 {
2082 return -WM_E_BUSY;
2083 }
2084
2085 mlan_adap->wpa_supp_scan_triggered = wm_wifi.wpa_supp_scan;
2086 wm_wifi.wpa_supp_scan = MFALSE;
2087 #endif
2088 if (ssid_num > MRVDRV_MAX_SSID_LIST_LENGTH)
2089 return -WM_E_INVAL;
2090 tmp_ssid = ssid;
2091 for (i = 0; i < ssid_num; i++)
2092 {
2093 ssid_len = strlen(tmp_ssid);
2094 tmp_ssid += ssid_len;
2095 tmp_ssid++;
2096 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2097 {
2098 #if CONFIG_WPA_SUPP
2099 mlan_adap->wpa_supp_scan_triggered = MFALSE;
2100 #endif
2101 return -WM_E_INVAL;
2102 }
2103 }
2104
2105 #if !CONFIG_MEM_POOLS
2106 wlan_user_scan_cfg *user_scan_cfg = (wlan_user_scan_cfg *)OSA_MemoryAllocate(sizeof(wlan_user_scan_cfg));
2107 #else
2108 wlan_user_scan_cfg *user_scan_cfg = (wlan_user_scan_cfg *)OSA_MemoryPoolAllocate(buf_512_MemoryPool);
2109 #endif
2110 if (user_scan_cfg == MNULL)
2111 {
2112 #if CONFIG_WPA_SUPP
2113 mlan_adap->wpa_supp_scan_triggered = MFALSE;
2114 #endif
2115 return -WM_E_NOMEM;
2116 }
2117
2118 (void)memset(user_scan_cfg, 0x00, sizeof(wlan_user_scan_cfg));
2119
2120 user_scan_cfg->bss_mode = bss_mode;
2121 user_scan_cfg->keep_previous_scan = keep_previous_scan;
2122
2123 #if CONFIG_SCAN_WITH_RSSIFILTER
2124 user_scan_cfg->rssi_threshold = rssi_threshold;
2125 #endif
2126
2127 if (num_probes > 0U && num_probes <= MAX_PROBES)
2128 {
2129 user_scan_cfg->num_probes = num_probes;
2130 }
2131
2132 if (specific_bssid != NULL)
2133 {
2134 (void)memcpy((void *)user_scan_cfg->specific_bssid, (const void *)specific_bssid, MLAN_MAC_ADDR_LENGTH);
2135 }
2136
2137 tmp_ssid = ssid;
2138 for (i = 0; i < ssid_num; i++)
2139 {
2140 ssid_len = strlen(tmp_ssid);
2141 (void)memcpy((void *)user_scan_cfg->ssid_list[i].ssid, (const void *)tmp_ssid, ssid_len);
2142 tmp_ssid += ssid_len;
2143 tmp_ssid++;
2144 }
2145
2146 #if CONFIG_COMBO_SCAN
2147 for (i = 0; (i < MRVDRV_MAX_SSID_LIST_LENGTH) && (*user_scan_cfg->ssid_list[i].ssid); i++)
2148 {
2149 if (!strncmp(wildcard_ssid, (char *)(user_scan_cfg->ssid_list[i].ssid), strlen(wildcard_ssid)))
2150 {
2151 (void)memset(user_scan_cfg->ssid_list[i].ssid, 0x00, sizeof(user_scan_cfg->ssid_list[i].ssid));
2152 user_scan_cfg->ssid_list[i].max_len = 40;
2153 }
2154 }
2155 #endif
2156
2157 if ((chan_list != MNULL) && (chan_list[0].radio_type & BAND_SPECIFIED))
2158 {
2159 user_scan_cfg->chan_list[0].radio_type = chan_list[0].radio_type;
2160 }
2161 else if (num_channels > 0U && num_channels <= WLAN_USER_SCAN_CHAN_MAX && chan_list != MNULL)
2162 {
2163 for (i = 0; i < num_channels; i++)
2164 {
2165 /** Channel Number to scan */
2166 user_scan_cfg->chan_list[i].chan_number = chan_list[i].chan_number;
2167 /** Radio type: 'B/G' Band = 0, 'A' Band = 1 */
2168 /* fixme: B/G is hardcoded here. Ask the caller first to
2169 send the radio type and then change here */
2170 if (chan_list[i].chan_number > 14U)
2171 {
2172 user_scan_cfg->chan_list[i].radio_type = 1;
2173 }
2174 /** Scan type: Active = 1, Passive = 2 */
2175 /* fixme: Active is hardcoded here. Ask the caller first to
2176 send the type and then change here */
2177 user_scan_cfg->chan_list[i].scan_type = chan_list[i].scan_type;
2178 /** Scan duration in milliseconds; if 0 default used */
2179 user_scan_cfg->chan_list[i].scan_time = chan_list[i].scan_time;
2180 }
2181 }
2182
2183 if (active_scan_triggered)
2184 {
2185 mlan_adap->active_scan_triggered = MTRUE;
2186 }
2187 #if CONFIG_SCAN_CHANNEL_GAP
2188 user_scan_cfg->scan_chan_gap = scan_chan_gap;
2189 #endif
2190 if (wm_wifi.g_user_scan_cfg != NULL)
2191 {
2192 #if !CONFIG_MEM_POOLS
2193 OSA_MemoryFree((void *)user_scan_cfg);
2194 #else
2195 OSA_MemoryPoolFree(buf_512_MemoryPool, user_scan_cfg);
2196 #endif
2197
2198 #if CONFIG_WPA_SUPP
2199 mlan_adap->wpa_supp_scan_triggered = MFALSE;
2200 return -WM_E_BUSY;
2201 #else
2202 return -WM_E_BUSY;
2203 #endif
2204 }
2205
2206 wm_wifi.g_user_scan_cfg = user_scan_cfg;
2207 (void)OSA_TaskNotifyPost(wm_wifi.wifi_scan_task_Handle);
2208
2209 return WM_SUCCESS;
2210 }
2211
2212 #if CONFIG_WPA_SUPP
wifi_send_sched_scan_cmd(nxp_wifi_trigger_sched_scan_t * params)2213 int wifi_send_sched_scan_cmd(nxp_wifi_trigger_sched_scan_t *params)
2214 {
2215 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2216 int ret, i;
2217
2218 memset(&pmpriv->scan_cfg, 0, sizeof(pmpriv->scan_cfg));
2219
2220 if (params->num_ssids != 0U)
2221 {
2222 for (i = 0; i < params->num_ssids; i++)
2223 {
2224 memcpy((void *)pmpriv->scan_cfg.ssid_list[i].ssid, (const void *)params->scan_ssids[i].ssid,
2225 (size_t)params->scan_ssids[i].ssid_len);
2226 pmpriv->scan_cfg.ssid_list[i].max_len = 0;
2227 }
2228 }
2229 else
2230 {
2231 pmpriv->scan_cfg.ssid_list[0].max_len = 0xff;
2232 }
2233
2234 for (i = 0; params->num_chans; i++)
2235 {
2236 pmpriv->scan_cfg.chan_list[i].chan_number = params->chan_list[i];
2237
2238 pmpriv->scan_cfg.chan_list[i].scan_type = MLAN_SCAN_TYPE_ACTIVE;
2239
2240 if (pmpriv->scan_cfg.chan_list[i].chan_number > 14)
2241 {
2242 pmpriv->scan_cfg.chan_list[i].radio_type = HostCmd_SCAN_RADIO_TYPE_A;
2243 }
2244 else
2245 {
2246 pmpriv->scan_cfg.chan_list[i].radio_type = HostCmd_SCAN_RADIO_TYPE_BG;
2247 }
2248 }
2249
2250 if (pmpriv->probe_req_index != -1)
2251 {
2252 ret = wifi_clear_mgmt_ie2(MLAN_BSS_TYPE_STA, pmpriv->probe_req_index);
2253
2254 if (ret != WM_SUCCESS)
2255 {
2256 wifi_e("Clear probe req IE failed");
2257 return -WM_FAIL;
2258 }
2259 pmpriv->probe_req_index = -1;
2260 }
2261
2262 if (params->extra_ies.ie_len)
2263 {
2264 pmpriv->probe_req_index = wifi_set_mgmt_ie2(MLAN_BSS_TYPE_STA, MGMT_MASK_PROBE_REQ,
2265 (void *)params->extra_ies.ie, params->extra_ies.ie_len);
2266
2267 if (pmpriv->probe_req_index == -1)
2268 {
2269 wifi_e("Set probe req IE failed");
2270 return -WM_FAIL;
2271 }
2272 }
2273
2274 pmpriv->scan_cfg.report_condition = params->report_condition;
2275 pmpriv->scan_cfg.rssi_threshold = params->filter_rssi;
2276 pmpriv->scan_cfg.repeat_count = params->repeat_count;
2277 pmpriv->scan_cfg.scan_interval = params->scan_interval;
2278 pmpriv->scan_cfg.chan_per_scan = params->chan_per_scan;
2279 pmpriv->scan_cfg.num_probes = 2;
2280
2281 pmpriv->scan_cfg.bss_type = MLAN_BSS_MODE_INFRA;
2282 pmpriv->scan_cfg.action = BG_SCAN_ACT_SET;
2283 pmpriv->scan_cfg.enable = MTRUE;
2284
2285 ret = wifi_request_bgscan(pmpriv);
2286 if (ret)
2287 {
2288 wifi_d("Failed to request bgscan");
2289 return -WM_FAIL;
2290 }
2291
2292 pmpriv->sched_scanning = MTRUE;
2293 pmpriv->bg_scan_start = MTRUE;
2294 pmpriv->bg_scan_reported = MFALSE;
2295
2296 return ret;
2297 }
2298
wifi_send_stop_sched_scan_cmd(void)2299 int wifi_send_stop_sched_scan_cmd(void)
2300 {
2301 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2302
2303 pmpriv->sched_scanning = MFALSE;
2304 pmpriv->bg_scan_start = MFALSE;
2305 pmpriv->bg_scan_reported = MFALSE;
2306
2307 memset(&pmpriv->scan_cfg, 0, sizeof(pmpriv->scan_cfg));
2308
2309 pmpriv->scan_cfg.action = BG_SCAN_ACT_SET;
2310 pmpriv->scan_cfg.enable = MFALSE;
2311 int ret = wifi_request_bgscan(pmpriv);
2312 if (ret)
2313 {
2314 wifi_d("Failed to request bgscan");
2315 }
2316
2317 return ret;
2318 }
2319 #endif
2320
wifi_send_key_material_cmd(int bss_index,mlan_ds_sec_cfg * sec)2321 static int wifi_send_key_material_cmd(int bss_index, mlan_ds_sec_cfg *sec)
2322 {
2323 /* fixme: check if this needs to go on heap */
2324 mlan_ioctl_req req;
2325 mlan_status rv = MLAN_STATUS_SUCCESS;
2326
2327 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
2328 req.pbuf = (t_u8 *)sec;
2329 req.buf_len = sizeof(mlan_ds_sec_cfg);
2330 req.bss_index = bss_index;
2331 req.req_id = MLAN_IOCTL_SEC_CFG;
2332 req.action = MLAN_ACT_SET;
2333
2334 if (bss_index != 0)
2335 {
2336 rv = wlan_ops_uap_ioctl(mlan_adap, &req);
2337 }
2338 else
2339 {
2340 rv = wlan_ops_sta_ioctl(mlan_adap, &req);
2341 }
2342
2343 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
2344 {
2345 return -WM_FAIL;
2346 }
2347
2348 return WM_SUCCESS;
2349 }
2350
wifi_set_key(int bss_index,bool is_pairwise,const uint8_t key_index,const uint8_t * key,unsigned key_len,const uint8_t * seq,unsigned seq_len,const uint8_t * mac_addr,unsigned int flags)2351 int wifi_set_key(int bss_index,
2352 bool is_pairwise,
2353 const uint8_t key_index,
2354 const uint8_t *key,
2355 unsigned key_len,
2356 const uint8_t *seq,
2357 unsigned seq_len,
2358 const uint8_t *mac_addr,
2359 unsigned int flags)
2360 {
2361 /* fixme: check if this needs to go on heap */
2362 mlan_ds_sec_cfg sec;
2363 int ret = WM_SUCCESS;
2364 t_u8 bcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2365 #if CONFIG_GTK_REKEY_OFFLOAD
2366 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[bss_index];
2367 t_u8 zero_kek[MLAN_KEK_LEN] = {0};
2368 #endif
2369
2370 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2371 sec.sub_command = MLAN_OID_SEC_CFG_ENCRYPT_KEY;
2372
2373 if (key_len > MAX_WEP_KEY_SIZE)
2374 {
2375 if (seq && seq_len)
2376 {
2377 memcpy(sec.param.encrypt_key.pn, seq, seq_len);
2378 sec.param.encrypt_key.key_flags |= KEY_FLAG_RX_SEQ_VALID;
2379 }
2380
2381 if (mac_addr)
2382 {
2383 if (is_pairwise)
2384 {
2385 sec.param.encrypt_key.key_flags |= KEY_FLAG_SET_TX_KEY;
2386 }
2387 else
2388 {
2389 sec.param.encrypt_key.key_flags |= KEY_FLAG_GROUP_KEY;
2390 }
2391 (void)memcpy((void *)sec.param.encrypt_key.mac_addr, (const void *)mac_addr, MLAN_MAC_ADDR_LENGTH);
2392 }
2393 else
2394 {
2395 memcpy(sec.param.encrypt_key.mac_addr, bcast_addr, MLAN_MAC_ADDR_LENGTH);
2396 sec.param.encrypt_key.key_flags |= KEY_FLAG_GROUP_KEY;
2397 }
2398 sec.param.encrypt_key.key_index = key_index;
2399
2400 if (flags)
2401 {
2402 sec.param.encrypt_key.key_flags |= flags;
2403 }
2404 }
2405 else
2406 {
2407 sec.param.encrypt_key.key_index = MLAN_KEY_INDEX_DEFAULT;
2408 sec.param.encrypt_key.is_current_wep_key = MTRUE;
2409 }
2410
2411 sec.param.encrypt_key.key_len = key_len;
2412 (void)memcpy((void *)sec.param.encrypt_key.key_material, (const void *)key, key_len);
2413
2414 ret = wifi_send_key_material_cmd(bss_index, &sec);
2415
2416 #if CONFIG_GTK_REKEY_OFFLOAD
2417
2418 if ((ret == WM_SUCCESS) && (is_pairwise == false))
2419 {
2420 if (memcmp(pmpriv->gtk_rekey.kek, zero_kek, sizeof(zero_kek)) != 0)
2421 {
2422 mlan_status status = MLAN_STATUS_SUCCESS;
2423 ret = wlan_prepare_cmd(pmpriv, HostCmd_CMD_CONFIG_GTK_REKEY_OFFLOAD_CFG, HostCmd_ACT_GEN_SET, 0, MNULL,
2424 &pmpriv->gtk_rekey);
2425 if (status)
2426 {
2427 PRINTM(MINFO, "Error sending message to FW\n");
2428 ret = -WM_FAIL;
2429 }
2430 (void)__memset(pmpriv->adapter, &pmpriv->gtk_rekey, 0, sizeof(mlan_ds_misc_gtk_rekey_data));
2431 }
2432 }
2433 #endif
2434
2435 return ret;
2436 }
2437
wifi_set_rekey_info(int bss_index,const t_u8 * kek,size_t kek_len,const t_u8 * kck,size_t kck_len,const t_u8 * replay_ctr)2438 int wifi_set_rekey_info(
2439 int bss_index, const t_u8 *kek, size_t kek_len, const t_u8 *kck, size_t kck_len, const t_u8 *replay_ctr)
2440 {
2441 #if CONFIG_GTK_REKEY_OFFLOAD
2442 mlan_ds_misc_cfg misc;
2443 mlan_ioctl_req req;
2444 mlan_status rv = MLAN_STATUS_SUCCESS;
2445
2446 (void)memset(&misc, 0x00, sizeof(mlan_ds_misc_cfg));
2447
2448 misc.sub_command = MLAN_OID_MISC_CONFIG_GTK_REKEY_OFFLOAD;
2449
2450 (void)memcpy(misc.param.gtk_rekey.kek, kek, MLAN_KEK_LEN);
2451 (void)memcpy(misc.param.gtk_rekey.kck, kck, MLAN_KCK_LEN);
2452 (void)memcpy(misc.param.gtk_rekey.replay_ctr, replay_ctr, MLAN_REPLAY_CTR_LEN);
2453
2454 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
2455 req.pbuf = (t_u8 *)&misc;
2456 req.buf_len = sizeof(mlan_ds_misc_cfg);
2457 req.bss_index = bss_index;
2458 req.req_id = MLAN_IOCTL_MISC_CFG;
2459 req.action = MLAN_ACT_SET;
2460
2461 if (bss_index != 0)
2462 {
2463 rv = wlan_ops_uap_ioctl(mlan_adap, &req);
2464 }
2465 else
2466 {
2467 rv = wlan_ops_sta_ioctl(mlan_adap, &req);
2468 }
2469
2470 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
2471 {
2472 return -WM_FAIL;
2473 }
2474
2475 return WM_SUCCESS;
2476 #else
2477 return WM_SUCCESS;
2478 #endif
2479 }
2480
wifi_set_igtk_key(int bss_index,const uint8_t * pn,const uint16_t key_index,const uint8_t * key,unsigned key_len)2481 int wifi_set_igtk_key(int bss_index, const uint8_t *pn, const uint16_t key_index, const uint8_t *key, unsigned key_len)
2482 {
2483 /* fixme: check if this needs to go on heap */
2484 mlan_ds_sec_cfg sec;
2485
2486 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2487 sec.sub_command = MLAN_OID_SEC_CFG_ENCRYPT_KEY;
2488
2489 sec.param.encrypt_key.key_flags = KEY_FLAG_AES_MCAST_IGTK;
2490 sec.param.encrypt_key.key_index = key_index;
2491
2492 (void)memcpy((void *)sec.param.encrypt_key.pn, (const void *)pn, SEQ_MAX_SIZE);
2493 sec.param.encrypt_key.key_len = key_len;
2494 (void)memcpy((void *)sec.param.encrypt_key.key_material, (const void *)key, key_len);
2495
2496 return wifi_send_key_material_cmd(bss_index, &sec);
2497 }
2498
wifi_remove_key(int bss_index,bool is_pairwise,const uint8_t key_index,const uint8_t * mac_addr)2499 int wifi_remove_key(int bss_index, bool is_pairwise, const uint8_t key_index, const uint8_t *mac_addr)
2500 {
2501 /* fixme: check if this needs to go on heap */
2502 mlan_ds_sec_cfg sec;
2503
2504 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2505 sec.sub_command = MLAN_OID_SEC_CFG_ENCRYPT_KEY;
2506
2507 if (key_index == KEY_INDEX_CLEAR_ALL)
2508 {
2509 sec.param.encrypt_key.key_disable = MTRUE;
2510 }
2511 else
2512 {
2513 sec.param.encrypt_key.key_remove = MTRUE;
2514 sec.param.encrypt_key.key_index = key_index;
2515 }
2516
2517 sec.param.encrypt_key.key_len = MLAN_MAX_KEY_LENGTH;
2518 sec.param.encrypt_key.key_flags = KEY_FLAG_REMOVE_KEY;
2519
2520 if (mac_addr)
2521 {
2522 (void)memcpy((void *)sec.param.encrypt_key.mac_addr, (const void *)mac_addr, MLAN_MAC_ADDR_LENGTH);
2523 }
2524
2525 return wifi_send_key_material_cmd(bss_index, &sec);
2526 }
2527
2528 #ifdef STREAM_2X2
wifi_send_11n_cfg_cmd(t_u16 action,uint16_t httxcfg)2529 static int wifi_send_11n_cfg_cmd(t_u16 action, uint16_t httxcfg)
2530 {
2531 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2532 mlan_ds_11n_tx_cfg dot11n_tx_cfg;
2533
2534 (void)memset(&dot11n_tx_cfg, 0x00, sizeof(mlan_ds_11n_tx_cfg));
2535
2536 dot11n_tx_cfg.httxcap = httxcfg;
2537
2538 if (action != HostCmd_ACT_GEN_GET && action != HostCmd_ACT_GEN_SET)
2539 return -WM_FAIL;
2540
2541 wifi_get_command_lock();
2542 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
2543
2544 cmd->seq_num = 0x0;
2545 cmd->result = 0x0;
2546
2547 mlan_status rv = wlan_ops_sta_prepare_cmd(pmpriv, HostCmd_CMD_11N_CFG, action, 0, NULL, &dot11n_tx_cfg, cmd);
2548 if (rv != MLAN_STATUS_SUCCESS)
2549 return -WM_FAIL;
2550
2551 return wifi_wait_for_cmdresp(NULL);
2552 }
2553
wifi_send_11ac_cfg_cmd(t_u16 action,uint32_t vhtcap,uint16_t tx_mcs_map,uint16_t rx_mcs_map)2554 static int wifi_send_11ac_cfg_cmd(t_u16 action, uint32_t vhtcap, uint16_t tx_mcs_map, uint16_t rx_mcs_map)
2555 {
2556 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2557 mlan_ds_11ac_vht_cfg dot11ac_cfg;
2558
2559 (void)memset(&dot11ac_cfg, 0x00, sizeof(mlan_ds_11ac_vht_cfg));
2560
2561 dot11ac_cfg.band = 2;
2562 dot11ac_cfg.txrx = 1;
2563 dot11ac_cfg.vht_cap_info = vhtcap;
2564 dot11ac_cfg.vht_tx_mcs = tx_mcs_map;
2565 dot11ac_cfg.vht_rx_mcs = rx_mcs_map;
2566
2567 if (action != HostCmd_ACT_GEN_GET && action != HostCmd_ACT_GEN_SET)
2568 return -WM_FAIL;
2569
2570 wifi_get_command_lock();
2571 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
2572
2573 cmd->seq_num = 0x0;
2574 cmd->result = 0x0;
2575
2576 mlan_status rv = wlan_ops_sta_prepare_cmd(pmpriv, HostCmd_CMD_11AC_CFG, action, 0, NULL, &dot11ac_cfg, cmd);
2577 if (rv != MLAN_STATUS_SUCCESS)
2578 return -WM_FAIL;
2579
2580 return wifi_wait_for_cmdresp(NULL);
2581 }
2582
2583 #endif
2584
2585 #ifdef STREAM_2X2
wifi_send_rf_antenna_cmd(t_u16 action,uint8_t tx_antenna,uint8_t rx_antenna)2586 static int wifi_send_rf_antenna_cmd(t_u16 action, uint8_t tx_antenna, uint8_t rx_antenna)
2587 {
2588 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2589 mlan_ds_ant_cfg ant_cfg;
2590
2591 (void)memset(&ant_cfg, 0x00, sizeof(mlan_ds_ant_cfg));
2592
2593 ant_cfg.tx_antenna = tx_antenna;
2594 ant_cfg.rx_antenna = rx_antenna;
2595
2596 if (action != HostCmd_ACT_GEN_GET && action != HostCmd_ACT_GEN_SET)
2597 return -WM_FAIL;
2598
2599 wifi_get_command_lock();
2600 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
2601
2602 cmd->seq_num = 0x0;
2603 cmd->result = 0x0;
2604
2605 mlan_status rv = wlan_ops_sta_prepare_cmd(pmpriv, HostCmd_CMD_802_11_RF_ANTENNA, action, 0, NULL, &ant_cfg, cmd);
2606 if (rv != MLAN_STATUS_SUCCESS)
2607 return -WM_FAIL;
2608
2609 return wifi_wait_for_cmdresp(/*action == HostCmd_ACT_GEN_GET ? ant_mode : */ NULL);
2610 }
2611
2612 #else
2613
wifi_send_rf_antenna_cmd(t_u16 action,wifi_antcfg_t * wifi_antcfg)2614 static int wifi_send_rf_antenna_cmd(t_u16 action, wifi_antcfg_t *wifi_antcfg)
2615 {
2616 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2617 mlan_ds_ant_cfg_1x1 ant_cfg_1x1;
2618
2619 (void)memset(&ant_cfg_1x1, 0x00, sizeof(mlan_ds_ant_cfg_1x1));
2620
2621 ant_cfg_1x1.antenna = (t_u32) * (wifi_antcfg->ant_mode);
2622 ant_cfg_1x1.evaluate_time = (t_u16) * (wifi_antcfg->evaluate_time);
2623 #ifdef RW610
2624 ant_cfg_1x1.evaluate_mode = (t_u8) * (wifi_antcfg->evaluate_mode);
2625 #endif
2626
2627 if (action != HostCmd_ACT_GEN_GET && action != HostCmd_ACT_GEN_SET)
2628 {
2629 return -WM_FAIL;
2630 }
2631
2632 (void)wifi_get_command_lock();
2633 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
2634
2635 (void)memset(cmd, 0x00, S_DS_GEN + sizeof(HostCmd_DS_802_11_RF_ANTENNA));
2636
2637 cmd->seq_num = 0x0;
2638 cmd->result = 0x0;
2639
2640 mlan_status rv =
2641 wlan_ops_sta_prepare_cmd(pmpriv, HostCmd_CMD_802_11_RF_ANTENNA, action, 0, NULL, &ant_cfg_1x1, cmd);
2642 if (rv != MLAN_STATUS_SUCCESS)
2643 {
2644 (void)wifi_put_command_lock();
2645 return -WM_FAIL;
2646 }
2647
2648 (void)wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? wifi_antcfg : NULL);
2649
2650 return wm_wifi.cmd_resp_status;
2651 }
2652
2653 #ifndef RW610
wifi_get_antenna(t_u32 * ant_mode,t_u16 * evaluate_time,t_u16 * current_antenna)2654 int wifi_get_antenna(t_u32 *ant_mode, t_u16 *evaluate_time, t_u16 *current_antenna)
2655 #else
2656 int wifi_get_antenna(t_u32 *ant_mode, t_u16 *evaluate_time, t_u8 *evaluate_mode, t_u16 *current_antenna)
2657 #endif
2658 {
2659 if (ant_mode == MNULL)
2660 {
2661 return -WM_E_INVAL;
2662 }
2663
2664 wifi_antcfg_t antenna_cfg;
2665 antenna_cfg.ant_mode = ant_mode;
2666 antenna_cfg.evaluate_time = evaluate_time;
2667 #ifdef RW610
2668 antenna_cfg.evaluate_mode = evaluate_mode;
2669 #endif
2670 antenna_cfg.current_antenna = current_antenna;
2671
2672 int rv = wifi_send_rf_antenna_cmd(HostCmd_ACT_GEN_GET, &antenna_cfg);
2673 if (rv != WM_SUCCESS || wm_wifi.cmd_resp_status != WM_SUCCESS)
2674 {
2675 return -WM_FAIL;
2676 }
2677
2678 return WM_SUCCESS;
2679 }
2680 #endif
2681
2682 #ifdef STREAM_2X2
wifi_set_11n_cfg(uint16_t httxcfg)2683 int wifi_set_11n_cfg(uint16_t httxcfg)
2684 {
2685 return wifi_send_11n_cfg_cmd(HostCmd_ACT_GEN_SET, httxcfg);
2686 }
2687
wifi_set_11ac_cfg(uint32_t vhtcap,uint16_t tx_mcs_map,uint16_t rx_mcs_map)2688 int wifi_set_11ac_cfg(uint32_t vhtcap, uint16_t tx_mcs_map, uint16_t rx_mcs_map)
2689 {
2690 return wifi_send_11ac_cfg_cmd(HostCmd_ACT_GEN_SET, vhtcap, tx_mcs_map, rx_mcs_map);
2691 }
2692
2693 #endif
2694
2695 #ifdef STREAM_2X2
wifi_set_antenna(t_u8 tx_antenna,t_u8 rx_antenna)2696 int wifi_set_antenna(t_u8 tx_antenna, t_u8 rx_antenna)
2697 {
2698 return wifi_send_rf_antenna_cmd(HostCmd_ACT_GEN_SET, tx_antenna, rx_antenna);
2699 }
2700 #else
2701 #ifndef RW610
wifi_set_antenna(t_u32 ant_mode,t_u16 evaluate_time)2702 int wifi_set_antenna(t_u32 ant_mode, t_u16 evaluate_time)
2703 {
2704 wifi_antcfg_t antenna_cfg;
2705 antenna_cfg.ant_mode = &ant_mode;
2706 antenna_cfg.evaluate_time = &evaluate_time;
2707
2708 return wifi_send_rf_antenna_cmd(HostCmd_ACT_GEN_SET, &antenna_cfg);
2709 }
2710 #else
wifi_set_antenna(t_u32 ant_mode,t_u16 evaluate_time,t_u8 evaluate_mode)2711 int wifi_set_antenna(t_u32 ant_mode, t_u16 evaluate_time, t_u8 evaluate_mode)
2712 {
2713 wifi_antcfg_t antenna_cfg;
2714 antenna_cfg.ant_mode = &ant_mode;
2715 antenna_cfg.evaluate_time = &evaluate_time;
2716 antenna_cfg.evaluate_mode = &evaluate_mode;
2717
2718 return wifi_send_rf_antenna_cmd(HostCmd_ACT_GEN_SET, &antenna_cfg);
2719 }
2720 #endif /*RW610*/
2721 #endif
2722
2723 #if CONFIG_WIFI_GET_LOG
wifi_send_get_log_cmd(wlan_pkt_stats_t * stats,mlan_bss_type bss_type)2724 static int wifi_send_get_log_cmd(wlan_pkt_stats_t *stats, mlan_bss_type bss_type)
2725 {
2726 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
2727
2728 wifi_get_command_lock();
2729 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
2730
2731 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
2732 cmd->result = 0x0;
2733
2734 mlan_status rv =
2735 wlan_ops_sta_prepare_cmd(pmpriv, HostCmd_CMD_802_11_GET_LOG, HostCmd_ACT_GEN_GET, 0, NULL, NULL, cmd);
2736 if (rv != MLAN_STATUS_SUCCESS)
2737 return -WM_FAIL;
2738
2739 return wifi_wait_for_cmdresp(stats);
2740 }
2741
wifi_get_log(wlan_pkt_stats_t * stats,mlan_bss_type bss_type)2742 int wifi_get_log(wlan_pkt_stats_t *stats, mlan_bss_type bss_type)
2743
2744 {
2745 int rv;
2746
2747 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
2748 rv = wifi_send_get_log_cmd(stats, bss_type);
2749 if (rv != WM_SUCCESS || wm_wifi.cmd_resp_status != WM_SUCCESS)
2750 return -WM_FAIL;
2751
2752 return WM_SUCCESS;
2753 }
2754 #endif
2755
wifi_send_cmd_802_11_supplicant_pmk(int mode,mlan_ds_sec_cfg * sec,mlan_act_ioctl action)2756 static int wifi_send_cmd_802_11_supplicant_pmk(int mode, mlan_ds_sec_cfg *sec, mlan_act_ioctl action)
2757 {
2758 /* fixme: check if this needs to go on heap */
2759 mlan_ioctl_req req;
2760
2761 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
2762 req.pbuf = (t_u8 *)sec;
2763 req.buf_len = sizeof(mlan_ds_sec_cfg);
2764 req.bss_index = 0;
2765 req.req_id = MLAN_IOCTL_SEC_CFG;
2766 req.action = action;
2767
2768 mlan_status rv = wlan_ops_sta_ioctl(mlan_adap, &req);
2769 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
2770 {
2771 return -WM_FAIL;
2772 }
2773
2774 return WM_SUCCESS;
2775 }
2776
wifi_send_add_wpa_pmk(int mode,char * ssid,char * bssid,char * pmk,unsigned int len)2777 int wifi_send_add_wpa_pmk(int mode, char *ssid, char *bssid, char *pmk, unsigned int len)
2778 {
2779 if (ssid == MNULL || (len != MLAN_MAX_KEY_LENGTH))
2780 {
2781 return -WM_E_INVAL;
2782 }
2783
2784 mlan_ds_sec_cfg sec;
2785
2786 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2787 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2788
2789 /* SSID */
2790 int ssid_len = strlen(ssid);
2791 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2792 {
2793 return -WM_E_INVAL;
2794 }
2795
2796 mlan_ds_passphrase *pp = &sec.param.passphrase;
2797 pp->ssid.ssid_len = ssid_len;
2798 (void)memcpy((void *)pp->ssid.ssid, (const void *)ssid, ssid_len);
2799
2800 /* MAC */
2801 if (bssid != NULL)
2802 {
2803 (void)memcpy((void *)pp->bssid, (const void *)bssid, MLAN_MAC_ADDR_LENGTH);
2804 }
2805
2806 /* PMK */
2807 pp->psk_type = MLAN_PSK_PMK;
2808 (void)memcpy((void *)pp->psk.pmk.pmk, (const void *)pmk, len);
2809
2810 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2811 }
2812
2813 /* fixme: This function has not been tested because of known issue in
2814 calling function. The calling function has been disabled for that */
wifi_send_get_wpa_pmk(int mode,char * ssid)2815 int wifi_send_get_wpa_pmk(int mode, char *ssid)
2816 {
2817 if (ssid == MNULL)
2818 {
2819 return -WM_E_INVAL;
2820 }
2821
2822 mlan_ds_sec_cfg sec;
2823
2824 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2825 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2826
2827 /* SSID */
2828 int ssid_len = strlen(ssid);
2829 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2830 {
2831 return -WM_E_INVAL;
2832 }
2833
2834 mlan_ds_passphrase *pp = &sec.param.passphrase;
2835 pp->ssid.ssid_len = ssid_len;
2836 (void)memcpy((void *)pp->ssid.ssid, (const void *)ssid, ssid_len);
2837
2838 /* Zero MAC */
2839
2840 pp->psk_type = MLAN_PSK_QUERY;
2841
2842 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_GET);
2843 }
2844
2845 /*
2846 Note:
2847 Passphrase can be between 8 to 63 if it is ASCII and 64 if its PSK
2848 hexstring
2849 */
wifi_send_add_wpa_psk(int mode,char * ssid,char * passphrase,unsigned int len)2850 int wifi_send_add_wpa_psk(int mode, char *ssid, char *passphrase, unsigned int len)
2851 {
2852 if (ssid == MNULL || ((len < MLAN_MIN_PASSPHRASE_LENGTH) || (len > MLAN_MAX_PASSPHRASE_LENGTH)))
2853 {
2854 return -WM_E_INVAL;
2855 }
2856
2857 mlan_ds_sec_cfg sec;
2858
2859 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2860 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2861
2862 /* SSID */
2863 int ssid_len = strlen(ssid);
2864 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2865 {
2866 return -WM_E_INVAL;
2867 }
2868
2869 mlan_ds_passphrase *pp = &sec.param.passphrase;
2870 pp->ssid.ssid_len = ssid_len;
2871 (void)memcpy((void *)pp->ssid.ssid, (const void *)ssid, ssid_len);
2872
2873 /* Zero MAC */
2874
2875 /* Passphrase */
2876 pp->psk_type = MLAN_PSK_PASSPHRASE;
2877 pp->psk.passphrase.passphrase_len = len;
2878 (void)memcpy((void *)pp->psk.passphrase.passphrase, (const void *)passphrase, len);
2879
2880 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2881 }
2882
2883 /*
2884 Note:
2885 Password can be between 1 to 255 if it is ASCII
2886 */
wifi_send_add_wpa3_password(int mode,char * ssid,char * password,unsigned int len)2887 int wifi_send_add_wpa3_password(int mode, char *ssid, char *password, unsigned int len)
2888 {
2889 if (ssid == MNULL || ((len < MLAN_MIN_PASSWORD_LENGTH) || (len > MLAN_MAX_PASSWORD_LENGTH)))
2890 {
2891 return -WM_E_INVAL;
2892 }
2893
2894 mlan_ds_sec_cfg sec;
2895
2896 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2897 sec.sub_command = MLAN_OID_SEC_CFG_PASSWORD;
2898
2899 /* SSID */
2900 int ssid_len = strlen(ssid);
2901 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2902 {
2903 return -WM_E_INVAL;
2904 }
2905
2906 mlan_ds_passphrase *pp = &sec.param.passphrase;
2907 pp->ssid.ssid_len = ssid_len;
2908 (void)memcpy((void *)pp->ssid.ssid, (const void *)ssid, ssid_len);
2909
2910 /* Zero MAC */
2911
2912 /* Passphrase */
2913 pp->psk_type = MLAN_PSK_PASSWORD;
2914 pp->password.password_len = len;
2915 (void)memcpy((void *)pp->password.password, (const void *)password, len);
2916
2917 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2918 }
2919
wifi_send_clear_wpa_psk(int mode,const char * ssid)2920 int wifi_send_clear_wpa_psk(int mode, const char *ssid)
2921 {
2922 if (ssid == MNULL)
2923 {
2924 return -WM_E_INVAL;
2925 }
2926
2927 mlan_ds_sec_cfg sec;
2928
2929 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2930 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2931
2932 /* SSID */
2933 int ssid_len = strlen(ssid);
2934 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2935 {
2936 return -WM_E_INVAL;
2937 }
2938
2939 sec.param.passphrase.ssid.ssid_len = ssid_len;
2940 (void)strcpy((char *)sec.param.passphrase.ssid.ssid, ssid);
2941
2942 /* Zero MAC */
2943
2944 sec.param.passphrase.psk_type = MLAN_PSK_CLEAR;
2945 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2946 }
2947
wifi_send_enable_supplicant(int mode,const char * ssid)2948 int wifi_send_enable_supplicant(int mode, const char *ssid)
2949 {
2950 if (ssid == MNULL)
2951 {
2952 return -WM_E_INVAL;
2953 }
2954
2955 mlan_ds_sec_cfg sec;
2956
2957 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2958 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2959
2960 /* SSID */
2961 int ssid_len = strlen(ssid);
2962 if (ssid_len > MLAN_MAX_SSID_LENGTH)
2963 {
2964 return -WM_E_INVAL;
2965 }
2966
2967 sec.param.passphrase.ssid.ssid_len = ssid_len;
2968 (void)strcpy((char *)sec.param.passphrase.ssid.ssid, ssid);
2969
2970 /* Zero MAC */
2971
2972 sec.param.passphrase.psk_type = MLAN_PSK_PASSPHRASE;
2973 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2974 }
2975
wifi_send_disable_supplicant(int mode)2976 int wifi_send_disable_supplicant(int mode)
2977 {
2978 mlan_ds_sec_cfg sec;
2979
2980 (void)memset(&sec, 0x00, sizeof(mlan_ds_sec_cfg));
2981 sec.sub_command = MLAN_OID_SEC_CFG_PASSPHRASE;
2982
2983 sec.param.passphrase.psk_type = MLAN_PSK_CLEAR;
2984
2985 return wifi_send_cmd_802_11_supplicant_pmk(mode, &sec, MLAN_ACT_SET);
2986 }
2987
wifi_set_mac_multicast_addr(const char * mlist,t_u32 num_of_addr)2988 int wifi_set_mac_multicast_addr(const char *mlist, t_u32 num_of_addr)
2989 {
2990 if (mlist == MNULL)
2991 {
2992 return -WM_E_INVAL;
2993 }
2994 if (num_of_addr > MLAN_MAX_MULTICAST_LIST_SIZE)
2995 {
2996 return -WM_E_INVAL;
2997 }
2998
2999 mlan_multicast_list *mcast_list = (mlan_multicast_list *)OSA_MemoryAllocate(sizeof(mlan_multicast_list));
3000 if(mcast_list == NULL)
3001 {
3002 return -WM_FAIL;
3003 }
3004
3005 (void)memset(mcast_list, 0x0, sizeof(mlan_multicast_list));
3006 (void)memcpy(mcast_list->mac_list, (const void *)mlist, num_of_addr * MLAN_MAC_ADDR_LENGTH);
3007 mcast_list->num_multicast_addr = num_of_addr;
3008 (void)wifi_get_command_lock();
3009 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
3010
3011 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_MAC_MULTICAST_ADR,
3012 HostCmd_ACT_GEN_SET, 0, NULL, mcast_list, cmd);
3013
3014 if (rv != MLAN_STATUS_SUCCESS)
3015 {
3016 OSA_MemoryFree(mcast_list);
3017 return -WM_FAIL;
3018 }
3019 (void)wifi_wait_for_cmdresp(NULL);
3020 OSA_MemoryFree(mcast_list);
3021
3022 return WM_SUCCESS;
3023 }
3024
wifi_get_otp_user_data(uint8_t * buf,uint16_t len)3025 int wifi_get_otp_user_data(uint8_t *buf, uint16_t len)
3026 {
3027 (void)wifi_get_command_lock();
3028 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
3029 mlan_ds_misc_otp_user_data pdata;
3030
3031 if (buf == MNULL)
3032 {
3033 return -WM_E_INVAL;
3034 }
3035
3036 cmd->seq_num = 0x0;
3037 cmd->result = 0x0;
3038 pdata.user_data_length = len > MAX_OTP_USER_DATA_LEN ? MAX_OTP_USER_DATA_LEN : len;
3039
3040 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_OTP_READ_USER_DATA,
3041 HostCmd_ACT_GEN_GET, 0, NULL, &pdata, cmd);
3042 if (rv != MLAN_STATUS_SUCCESS)
3043 {
3044 return -WM_FAIL;
3045 }
3046
3047 (void)wifi_wait_for_cmdresp(buf);
3048 return wm_wifi.cmd_resp_status;
3049 }
3050
wifi_get_cal_data(wifi_cal_data_t * cal_data)3051 int wifi_get_cal_data(wifi_cal_data_t *cal_data)
3052 {
3053 uint32_t size = S_DS_GEN + sizeof(HostCmd_DS_802_11_CFG_DATA) - 1U;
3054
3055 (void)wifi_get_command_lock();
3056 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
3057
3058 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_CFG_DATA);
3059
3060 HostCmd_DS_802_11_CFG_DATA *cfg_data_cmd = (HostCmd_DS_802_11_CFG_DATA *)((uint32_t)cmd + S_DS_GEN);
3061
3062 cfg_data_cmd->action = HostCmd_ACT_GEN_GET;
3063 cfg_data_cmd->type = 0x02;
3064 cfg_data_cmd->data_len = 0x00;
3065
3066 cmd->size = size;
3067 cmd->seq_num = 0x00;
3068 cmd->result = 0x00;
3069
3070 (void)wifi_wait_for_cmdresp(cal_data);
3071
3072 return wm_wifi.cmd_resp_status;
3073 }
3074
3075 #if CONFIG_11AX
wifi_request_get_fw_info(mlan_private * priv,mlan_fw_info * fw_info)3076 void wifi_request_get_fw_info(mlan_private *priv, mlan_fw_info *fw_info)
3077 {
3078 (void)memset(fw_info, 0x0, sizeof(mlan_fw_info));
3079
3080 fw_info->fw_ver = mlan_adap->fw_release_number;
3081 (void)memcpy(fw_info->mac_addr, priv->curr_addr, MLAN_MAC_ADDR_LENGTH);
3082 fw_info->fw_bands = mlan_adap->fw_bands;
3083 fw_info->hw_dev_mcs_support = mlan_adap->hw_dev_mcs_support;
3084
3085 fw_info->hw_2g_hecap_len = mlan_adap->hw_2g_hecap_len;
3086
3087 (void)memcpy(fw_info->hw_2g_he_cap, mlan_adap->hw_2g_he_cap, mlan_adap->hw_2g_hecap_len);
3088
3089 fw_info->hw_hecap_len = mlan_adap->hw_hecap_len;
3090
3091 (void)memcpy(fw_info->hw_he_cap, mlan_adap->hw_he_cap, mlan_adap->hw_hecap_len);
3092 }
3093 #endif
3094
3095 #if CONFIG_WIFI_CAPA
wifi_get_fw_info(mlan_bss_type type,t_u16 * fw_bands)3096 void wifi_get_fw_info(mlan_bss_type type, t_u16 *fw_bands)
3097 {
3098 mlan_fw_info fw_info;
3099
3100 (void)memset(&fw_info, 0x0, sizeof(mlan_fw_info));
3101 fw_info.fw_ver = mlan_adap->fw_release_number;
3102 (void)memcpy(fw_info.mac_addr, mlan_adap->priv[type]->curr_addr, MLAN_MAC_ADDR_LENGTH);
3103 fw_info.fw_bands = mlan_adap->fw_bands;
3104 fw_info.hw_dev_mcs_support = mlan_adap->hw_dev_mcs_support;
3105
3106 *fw_bands = fw_info.fw_bands;
3107 }
3108 #endif
3109
wifi_get_firmware_version_ext(wifi_fw_version_ext_t * version_ext)3110 int wifi_get_firmware_version_ext(wifi_fw_version_ext_t *version_ext)
3111 {
3112 if (version_ext == MNULL)
3113 {
3114 return -WM_E_INVAL;
3115 }
3116
3117 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
3118 mlan_status rv = wifi_prepare_and_send_cmd(pmpriv, HostCmd_CMD_VERSION_EXT, HostCmd_ACT_GEN_GET, 0, NULL,
3119 &version_ext->version_str_sel, MLAN_BSS_TYPE_STA, version_ext);
3120 return (rv == MLAN_STATUS_SUCCESS ? WM_SUCCESS : -WM_FAIL);
3121 }
3122
wifi_get_firmware_version(wifi_fw_version_t * ver)3123 int wifi_get_firmware_version(wifi_fw_version_t *ver)
3124 {
3125 if (ver == MNULL)
3126 {
3127 return -WM_E_INVAL;
3128 }
3129
3130 union
3131 {
3132 uint32_t l;
3133 uint8_t c[4];
3134 } u_ver;
3135 char fw_ver[32];
3136
3137 u_ver.l = mlan_adap->fw_release_number;
3138 (void)sprintf(fw_ver, "%u.%u.%u.p%u", u_ver.c[2], u_ver.c[1], u_ver.c[0], u_ver.c[3]);
3139
3140 (void)snprintf(ver->version_str, MLAN_MAX_VER_STR_LEN, driver_version_format, fw_ver, driver_version);
3141
3142 return WM_SUCCESS;
3143 }
3144
3145 /* Region: US(US) or Canada(CA) or Singapore(SG) 2.4 GHz */
3146 static wifi_sub_band_set_t subband_US_CA_SG_2_4_GHz[] = {{1, 11, 20}};
3147
3148 /* Region: Europe(EU), Australia(AU), Republic of Korea(KR),
3149 China(CN) 2.4 GHz */
3150 static wifi_sub_band_set_t subband_EU_AU_KR_CN_2_4GHz[] = {{1, 13, 20}};
3151
3152 /* Region: Japan(JP) 2.4 GHz */
3153 static wifi_sub_band_set_t subband_JP_2_4GHz[] = {
3154 {1, 14, 20},
3155 };
3156
3157 /* Region: World Wide Safe Mode(WWSM) 2.4 GHz */
3158 static wifi_sub_band_set_t subband_WWSM_2_4GHz[] = {
3159 {1, 14, 22},
3160 };
3161
3162 /* Region: Constrained 2.4 Ghz */
3163 static wifi_sub_band_set_t subband_CS_2_4GHz[] = {{1, 9, 20}, {10, 2, 10}};
3164
3165 #if CONFIG_5GHz_SUPPORT
3166
3167 #if (CONFIG_UNII4_BAND_SUPPORT)
3168 /* Region: US(US) 5 GHz */
3169 wifi_sub_band_set_t subband_US_5_GHz[] = {{36, 8, 20}, {100, 11, 20}, {149, 8, 20}};
3170
3171 /* Region: France(FR) or Singapore(SG) 5 GHz */
3172 wifi_sub_band_set_t subband_SG_FR_5_GHz[] = {{36, 8, 20}, {100, 11, 20}, {149, 5, 20}};
3173 #else
3174 /* Region: US(US) or France(FR) or Singapore(SG) 5 GHz */
3175 static wifi_sub_band_set_t subband_US_SG_FR_5_GHz[] = {{36, 8, 20}, {100, 11, 20}, {149, 5, 20}};
3176 #endif
3177
3178 /* Region: Canada(CA) 5 GHz */
3179 static wifi_sub_band_set_t subband_CA_5_GHz[] = {{36, 8, 20}, {100, 5, 20}, {132, 3, 20}, {149, 5, 20}};
3180
3181 /* Region: Region: Europe(EU), Australia(AU), Republic of Korea(KR)
3182 * 5 GHz */
3183 static wifi_sub_band_set_t subband_EU_AU_KR_5_GHz[] = {
3184 {36, 8, 20},
3185 {100, 11, 20},
3186 {149, 5, 20},
3187 };
3188
3189 /* Region: Japan(JP) 5 GHz */
3190 static wifi_sub_band_set_t subband_JP_5_GHz[] = {
3191 {8, 3, 23},
3192 {36, 8, 23},
3193 {100, 11, 23},
3194 };
3195
3196 /* Region: China(CN) 5 Ghz */
3197 static wifi_sub_band_set_t subband_CN_5_GHz[] = {
3198 {36, 4, 23},
3199 {52, 4, 23},
3200 {149, 5, 33},
3201 };
3202
3203 /* Region: World Wide Safe Mode(WWSM) 5 GHz */
3204 static wifi_sub_band_set_t subband_WWSM_5_GHz[] = {{36, 8, 22}, {100, 11, 22}, {149, 5, 22}};
3205
3206 #endif /* CONFIG_5GHz_SUPPORT */
3207
wifi_get_region_code(t_u32 * region_code)3208 int wifi_get_region_code(t_u32 *region_code)
3209 {
3210 *region_code = mlan_adap->region_code;
3211 return WM_SUCCESS;
3212 }
3213
wifi_set_region_code(t_u32 region_code)3214 int wifi_set_region_code(t_u32 region_code)
3215 {
3216 mlan_ds_misc_cfg misc = {
3217 .param.region_code = region_code,
3218 };
3219
3220 if ((misc.param.region_code == 0x41) || (misc.param.region_code == 0xFE))
3221 {
3222 (void)PRINTF("Region code 0XFF is used for Japan to support channels of both 2.4GHz band and 5GHz band.\r\n");
3223 (void)PRINTF("Region code 0X40 is used for Japan to support channels of 5GHz band.\r\n");
3224 return -WM_FAIL;
3225 }
3226
3227 mlan_ioctl_req req = {
3228 .bss_index = 0,
3229 .pbuf = (t_u8 *)&misc,
3230 .action = MLAN_ACT_SET,
3231 };
3232
3233 mlan_status mrv = wlan_misc_ioctl_region(mlan_adap, &req);
3234 if (mrv != MLAN_STATUS_SUCCESS)
3235 {
3236 wifi_w("Unable to set region code");
3237 return -WM_FAIL;
3238 }
3239
3240 return WM_SUCCESS;
3241 }
3242
wifi_enable_11d_support()3243 int wifi_enable_11d_support()
3244 {
3245 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
3246
3247 wrapper_wlan_11d_enable(ENABLE_11D);
3248
3249 wlan_11d_support_APIs(pmpriv);
3250
3251 return wlan_enable_11d_support(pmpriv);
3252 }
3253
wifi_disable_11d_support()3254 int wifi_disable_11d_support()
3255 {
3256 mlan_adap->priv[0]->state_11d.user_enable_11d_support = DISABLE_11D;
3257 wrapper_wlan_11d_enable(DISABLE_11D);
3258
3259 return WM_SUCCESS;
3260 }
3261
3262 #if UAP_SUPPORT
wifi_enable_uap_11d_support()3263 int wifi_enable_uap_11d_support()
3264 {
3265 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[1];
3266
3267 wrapper_wlan_uap_11d_enable(ENABLE_11D);
3268
3269 wlan_11d_support_APIs(pmpriv);
3270
3271 /* set callback for setting domain params when uap start */
3272 wifi_uap_enable_11d_support();
3273
3274 return wlan_enable_11d_support(pmpriv);
3275 }
3276
wifi_disable_uap_11d_support()3277 int wifi_disable_uap_11d_support()
3278 {
3279 mlan_adap->priv[1]->state_11d.user_enable_11d_support = DISABLE_11D;
3280 wrapper_wlan_uap_11d_enable(DISABLE_11D);
3281
3282 wm_wifi.enable_11d_support = false;
3283 wm_wifi.uap_support_11d_apis = MNULL;
3284 return WM_SUCCESS;
3285 }
3286 #endif /* UAP_SUPPORT */
3287
wifi_enable_11d_support_APIs(void)3288 int wifi_enable_11d_support_APIs(void)
3289 {
3290 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
3291
3292 return wlan_11d_support_APIs(pmpriv);
3293 }
3294
get_sub_band_from_region_code(int region_code,t_u8 * nr_sb)3295 wifi_sub_band_set_t *get_sub_band_from_region_code(int region_code, t_u8 *nr_sb)
3296 {
3297 *nr_sb = 1;
3298 wifi_sub_band_set_t *ret_band = NULL;
3299
3300 switch (region_code)
3301 {
3302 case 0x10:
3303 case 0x20:
3304 ret_band = subband_US_CA_SG_2_4_GHz;
3305 break;
3306 case 0x30:
3307 case 0x32:
3308 case 0x50:
3309 ret_band = subband_EU_AU_KR_CN_2_4GHz;
3310 break;
3311 case 0xFF:
3312 ret_band = subband_JP_2_4GHz;
3313 break;
3314 case 0x00:
3315 ret_band = subband_WWSM_2_4GHz;
3316 break;
3317 default:
3318 *nr_sb = 2;
3319 ret_band = subband_CS_2_4GHz;
3320 break;
3321 }
3322 return ret_band;
3323 }
3324
3325 #if CONFIG_5GHz_SUPPORT
get_sub_band_from_region_code_5ghz(int region_code,t_u8 * nr_sb)3326 wifi_sub_band_set_t *get_sub_band_from_region_code_5ghz(int region_code, t_u8 *nr_sb)
3327 {
3328 *nr_sb = 1;
3329 wifi_sub_band_set_t *ret_band = NULL;
3330
3331 switch (region_code)
3332 {
3333 case 0x10:
3334 #if (CONFIG_UNII4_BAND_SUPPORT)
3335 *nr_sb = 3;
3336 return subband_US_5_GHz;
3337 #endif
3338 case 0x32:
3339 *nr_sb = 3;
3340 #if (CONFIG_UNII4_BAND_SUPPORT)
3341 ret_band = subband_SG_FR_5_GHz;
3342 #else
3343 ret_band = subband_US_SG_FR_5_GHz;
3344 #endif
3345 break;
3346 case 0x20:
3347 *nr_sb = 4;
3348 ret_band = subband_CA_5_GHz;
3349 break;
3350 case 0x30:
3351 *nr_sb = 3;
3352 ret_band = subband_EU_AU_KR_5_GHz;
3353 break;
3354 case 0x40:
3355 case 0xFF:
3356 *nr_sb = 3;
3357 ret_band = subband_JP_5_GHz;
3358 break;
3359 case 0x50:
3360 *nr_sb = 3;
3361 ret_band = subband_CN_5_GHz;
3362 break;
3363 case 0x00:
3364 *nr_sb = 3;
3365 ret_band = subband_WWSM_5_GHz;
3366 break;
3367 default:
3368 *nr_sb = 3;
3369 #if (CONFIG_UNII4_BAND_SUPPORT)
3370 ret_band = subband_US_5_GHz;
3371 #else
3372 ret_band = subband_US_SG_FR_5_GHz;
3373 #endif
3374 break;
3375 }
3376 return ret_band;
3377 }
3378 #endif /* CONFIG_5GHz_SUPPORT */
3379
wifi_11d_is_channel_allowed(int channel)3380 bool wifi_11d_is_channel_allowed(int channel)
3381 {
3382 t_u8 i, j;
3383 t_u8 k;
3384 t_u8 nr_sb = 0;
3385
3386 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
3387
3388 wifi_sub_band_set_t *sub_band = NULL;
3389
3390 if (channel > 14)
3391 {
3392 #if CONFIG_5GHz_SUPPORT
3393 sub_band = get_sub_band_from_region_code_5ghz(pmpriv->adapter->region_code, &nr_sb);
3394 #else
3395 wifi_w("5 GHz support is not enabled");
3396
3397 return false;
3398 #endif /* CONFIG_5GHz_SUPPORT */
3399 }
3400 else
3401 {
3402 sub_band = get_sub_band_from_region_code(pmpriv->adapter->region_code, &nr_sb);
3403 }
3404
3405 for (i = 0; i < nr_sb; i++)
3406 {
3407 j = sub_band[i].first_chan;
3408
3409 for (k = 0; k < sub_band[i].no_of_chan; k++)
3410 {
3411 if (j == channel)
3412 {
3413 return true;
3414 }
3415
3416 if (channel > 14)
3417 {
3418 j += 4;
3419 }
3420 else
3421 {
3422 j++;
3423 }
3424 }
3425 }
3426
3427 /*For channel 144*/
3428 if (144 == channel)
3429 {
3430 return wlan_check_channel_by_region_table(pmpriv, channel);
3431 }
3432
3433 return false;
3434 }
3435
wifi_enable_ecsa_support(void)3436 int wifi_enable_ecsa_support(void)
3437 {
3438 return wrapper_wlan_ecsa_enable();
3439 }
3440
wifi_is_ecsa_enabled(void)3441 bool wifi_is_ecsa_enabled(void)
3442 {
3443 return mlan_adap->ecsa_enable;
3444 }
3445
get_free_mgmt_ie_index(unsigned int * mgmt_ie_index)3446 static int get_free_mgmt_ie_index(unsigned int *mgmt_ie_index)
3447 {
3448 unsigned int idx;
3449
3450 for (idx = 0; idx < 32; idx++)
3451 {
3452 if ((mgmt_ie_index_bitmap & MBIT((t_u32)idx)) == 0U)
3453 {
3454 *mgmt_ie_index = idx;
3455 return WM_SUCCESS;
3456 }
3457 }
3458 return -WM_FAIL;
3459 }
3460
set_ie_index(unsigned int index)3461 static void set_ie_index(unsigned int index)
3462 {
3463 mgmt_ie_index_bitmap |= (MBIT(index));
3464 }
3465
clear_ie_index(unsigned int index)3466 static void clear_ie_index(unsigned int index)
3467 {
3468 mgmt_ie_index_bitmap &= ~(MBIT(index));
3469 }
3470
3471 #ifdef SD8801
wifi_config_ext_coex(int action,const wifi_ext_coex_config_t * ext_coex_config,wifi_ext_coex_stats_t * ext_coex_stats)3472 static int wifi_config_ext_coex(int action,
3473 const wifi_ext_coex_config_t *ext_coex_config,
3474 wifi_ext_coex_stats_t *ext_coex_stats)
3475 {
3476 int ret;
3477 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
3478
3479 (void)wifi_get_command_lock();
3480
3481 cmd->command = HostCmd_CMD_ROBUST_COEX;
3482 cmd->size = sizeof(HostCmd_DS_ExtBLECoex_Config_t) + S_DS_GEN;
3483 cmd->seq_num = 0;
3484 cmd->result = 0;
3485 cmd->params.ext_ble_coex_cfg.action = action;
3486 cmd->params.ext_ble_coex_cfg.reserved = 0;
3487 cmd->params.ext_ble_coex_cfg.coex_cfg_data.header.type = TLV_TYPE_EXT_BLE_COEX_CFG;
3488 cmd->params.ext_ble_coex_cfg.coex_cfg_data.header.len =
3489 sizeof(MrvlIETypes_ExtBLECoex_Config_t) - sizeof(MrvlIEtypesHeader_t);
3490
3491 if (action == HostCmd_ACT_GEN_SET)
3492 {
3493 cmd->params.ext_ble_coex_cfg.coex_cfg_data.Enabled = ext_coex_config->Enabled;
3494 cmd->params.ext_ble_coex_cfg.coex_cfg_data.IgnorePriority = ext_coex_config->IgnorePriority;
3495 cmd->params.ext_ble_coex_cfg.coex_cfg_data.DefaultPriority = ext_coex_config->DefaultPriority;
3496 cmd->params.ext_ble_coex_cfg.coex_cfg_data.EXT_RADIO_REQ_ip_gpio_num =
3497 ext_coex_config->EXT_RADIO_REQ_ip_gpio_num;
3498 cmd->params.ext_ble_coex_cfg.coex_cfg_data.EXT_RADIO_REQ_ip_gpio_polarity =
3499 ext_coex_config->EXT_RADIO_REQ_ip_gpio_polarity;
3500 cmd->params.ext_ble_coex_cfg.coex_cfg_data.EXT_RADIO_PRI_ip_gpio_num =
3501 ext_coex_config->EXT_RADIO_PRI_ip_gpio_num;
3502 cmd->params.ext_ble_coex_cfg.coex_cfg_data.EXT_RADIO_PRI_ip_gpio_polarity =
3503 ext_coex_config->EXT_RADIO_PRI_ip_gpio_polarity;
3504 cmd->params.ext_ble_coex_cfg.coex_cfg_data.WLAN_GRANT_op_gpio_num = ext_coex_config->WLAN_GRANT_op_gpio_num;
3505 cmd->params.ext_ble_coex_cfg.coex_cfg_data.WLAN_GRANT_op_gpio_polarity =
3506 ext_coex_config->WLAN_GRANT_op_gpio_polarity;
3507 cmd->params.ext_ble_coex_cfg.coex_cfg_data.reserved_1 = ext_coex_config->reserved_1;
3508 cmd->params.ext_ble_coex_cfg.coex_cfg_data.reserved_2 = ext_coex_config->reserved_2;
3509 }
3510 ret = wifi_wait_for_cmdresp(ext_coex_stats);
3511 return ret;
3512 }
3513 #endif
3514
ie_index_is_set(unsigned int index)3515 static bool ie_index_is_set(unsigned int index)
3516 {
3517 return (mgmt_ie_index_bitmap & (MBIT(index))) ? MTRUE : MFALSE;
3518 }
3519
reset_ie_index()3520 void reset_ie_index()
3521 {
3522 mgmt_ie_index_bitmap = 0x0000000F;
3523 }
3524
wifi_config_mgmt_ie(mlan_bss_type bss_type,t_u16 action,IEEEtypes_ElementId_t index,void * buffer,unsigned int * ie_len,int mgmt_bitmap_index)3525 static int wifi_config_mgmt_ie(mlan_bss_type bss_type,
3526 t_u16 action,
3527 IEEEtypes_ElementId_t index,
3528 void *buffer,
3529 unsigned int *ie_len,
3530 int mgmt_bitmap_index)
3531 {
3532 uint8_t *buf, *pos;
3533 IEEEtypes_Header_t *ptlv_header = NULL;
3534 uint16_t buf_len = 0;
3535 tlvbuf_custom_ie *tlv = NULL;
3536 custom_ie *ie_ptr = NULL;
3537 unsigned int mgmt_ie_index = -1;
3538 int total_len =
3539 sizeof(tlvbuf_custom_ie) + 2U * (sizeof(custom_ie) - MAX_IE_SIZE) + sizeof(IEEEtypes_Header_t) + *ie_len;
3540 int ret = WM_SUCCESS;
3541
3542 #if !CONFIG_MEM_POOLS
3543 buf = (uint8_t *)OSA_MemoryAllocate(total_len);
3544 #else
3545 buf = OSA_MemoryPoolAllocate(buf_512_MemoryPool);
3546 #endif
3547 if (buf == MNULL)
3548 {
3549 wifi_e("Cannot allocate memory");
3550 return -WM_FAIL;
3551 }
3552
3553 (void)memset(buf, 0, total_len);
3554
3555 tlv = (tlvbuf_custom_ie *)(void *)buf;
3556 tlv->type = MRVL_MGMT_IE_LIST_TLV_ID;
3557
3558 /* Locate headers */
3559 ie_ptr = (custom_ie *)(tlv->ie_data);
3560 /* Set TLV fields */
3561 buf_len = sizeof(tlvbuf_custom_ie);
3562
3563 if (action == HostCmd_ACT_GEN_SET)
3564 {
3565 if (*ie_len == 0U)
3566 {
3567 /*
3568 MGMT_WPA_IE = MGMT_VENDOR_SPECIFIC_221
3569 MGMT_WPS_IE = MGMT_VENDOR_SPECIFIC_221
3570 */
3571
3572 if (!ie_index_is_set(mgmt_bitmap_index))
3573 {
3574 #if !CONFIG_MEM_POOLS
3575 OSA_MemoryFree(buf);
3576 #else
3577 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3578 #endif
3579 return -WM_FAIL;
3580 }
3581
3582 ie_ptr->mgmt_subtype_mask = MGMT_MASK_CLEAR;
3583 ie_ptr->ie_length = 0;
3584 ie_ptr->ie_index = (t_u16)mgmt_bitmap_index;
3585
3586 tlv->length = sizeof(custom_ie) - MAX_IE_SIZE;
3587 buf_len += tlv->length;
3588 clear_ie_index(mgmt_bitmap_index);
3589 }
3590 else
3591 {
3592 ret = get_free_mgmt_ie_index(&mgmt_ie_index);
3593
3594 if (WM_SUCCESS != ret)
3595 {
3596 #if !CONFIG_MEM_POOLS
3597 OSA_MemoryFree(buf);
3598 #else
3599 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3600 #endif
3601 return -WM_FAIL;
3602 }
3603
3604 pos = ie_ptr->ie_buffer;
3605 ptlv_header = (IEEEtypes_Header_t *)(void *)pos;
3606 pos += sizeof(IEEEtypes_Header_t);
3607
3608 ptlv_header->element_id = (IEEEtypes_ElementId_e)index;
3609 ptlv_header->len = *ie_len;
3610 if (bss_type == MLAN_BSS_TYPE_UAP)
3611 {
3612 ie_ptr->mgmt_subtype_mask =
3613 MGMT_MASK_BEACON | MGMT_MASK_PROBE_RESP | MGMT_MASK_ASSOC_RESP | MGMT_MASK_REASSOC_RESP;
3614 }
3615 else if (bss_type == MLAN_BSS_TYPE_STA)
3616 {
3617 ie_ptr->mgmt_subtype_mask = MGMT_MASK_PROBE_REQ | MGMT_MASK_ASSOC_REQ | MGMT_MASK_REASSOC_REQ;
3618 }
3619 else
3620 { /* Do Nothing */
3621 }
3622
3623 tlv->length = sizeof(custom_ie) + sizeof(IEEEtypes_Header_t) + *ie_len - MAX_IE_SIZE;
3624 ie_ptr->ie_length = sizeof(IEEEtypes_Header_t) + *ie_len;
3625 ie_ptr->ie_index = mgmt_ie_index;
3626
3627 buf_len += tlv->length;
3628
3629 (void)memcpy((void *)pos, (const void *)buffer, *ie_len);
3630 }
3631 }
3632 else if (action == HostCmd_ACT_GEN_GET)
3633 {
3634 /* Get WPS IE */
3635 tlv->length = 0;
3636 }
3637 else
3638 { /* Do Nothing */
3639 }
3640
3641 mlan_status rv = wrapper_wlan_cmd_mgmt_ie(bss_type, buf, buf_len, action);
3642
3643 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
3644 {
3645 #if !CONFIG_MEM_POOLS
3646 OSA_MemoryFree(buf);
3647 #else
3648 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3649 #endif
3650 return -WM_FAIL;
3651 }
3652
3653 if (action == HostCmd_ACT_GEN_GET)
3654 {
3655 if (wm_wifi.cmd_resp_status != 0)
3656 {
3657 wifi_w("Unable to get mgmt ie buffer");
3658 #if !CONFIG_MEM_POOLS
3659 OSA_MemoryFree(buf);
3660 #else
3661 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3662 #endif
3663 return wm_wifi.cmd_resp_status;
3664 }
3665 ie_ptr = (custom_ie *)(void *)(buf);
3666 (void)memcpy((void *)buffer, (const void *)ie_ptr->ie_buffer, ie_ptr->ie_length);
3667 *ie_len = ie_ptr->ie_length;
3668 }
3669 #if !CONFIG_MEM_POOLS
3670 OSA_MemoryFree(buf);
3671 #else
3672 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3673 #endif
3674
3675 if ((action == HostCmd_ACT_GEN_SET) && *ie_len)
3676 {
3677 set_ie_index(mgmt_ie_index);
3678 return mgmt_ie_index;
3679 }
3680 else
3681 {
3682 return WM_SUCCESS;
3683 }
3684 }
3685
wifi_get_mgmt_ie(mlan_bss_type bss_type,IEEEtypes_ElementId_t index,void * buf,unsigned int * buf_len)3686 int wifi_get_mgmt_ie(mlan_bss_type bss_type, IEEEtypes_ElementId_t index, void *buf, unsigned int *buf_len)
3687 {
3688 return wifi_config_mgmt_ie(bss_type, HostCmd_ACT_GEN_GET, index, buf, buf_len, 0);
3689 }
3690
wifi_set_mgmt_ie(mlan_bss_type bss_type,IEEEtypes_ElementId_t id,void * buf,unsigned int buf_len)3691 int wifi_set_mgmt_ie(mlan_bss_type bss_type, IEEEtypes_ElementId_t id, void *buf, unsigned int buf_len)
3692 {
3693 unsigned int data_len = buf_len;
3694
3695 return wifi_config_mgmt_ie(bss_type, HostCmd_ACT_GEN_SET, id, buf, &data_len, 0);
3696 }
3697
wifi_clear_mgmt_ie(mlan_bss_type bss_type,IEEEtypes_ElementId_t index,int mgmt_bitmap_index)3698 int wifi_clear_mgmt_ie(mlan_bss_type bss_type, IEEEtypes_ElementId_t index, int mgmt_bitmap_index)
3699 {
3700 unsigned int data_len = 0;
3701 return wifi_config_mgmt_ie(bss_type, HostCmd_ACT_GEN_SET, index, NULL, &data_len, mgmt_bitmap_index);
3702 }
3703
wifi_config_mgmt_ie2(mlan_bss_type bss_type,t_u16 action,t_u16 mask,void * buffer,unsigned int * ie_len,int mgmt_bitmap_index)3704 static int wifi_config_mgmt_ie2(
3705 mlan_bss_type bss_type, t_u16 action, t_u16 mask, void *buffer, unsigned int *ie_len, int mgmt_bitmap_index)
3706 {
3707 uint8_t *buf;
3708 uint16_t buf_len = 0;
3709 tlvbuf_custom_ie *tlv = NULL;
3710 custom_ie *ie_ptr = NULL;
3711 unsigned int mgmt_ie_index = -1;
3712 int total_len = sizeof(tlvbuf_custom_ie) + (sizeof(custom_ie) - MAX_IE_SIZE) + *ie_len;
3713 int ret = WM_SUCCESS;
3714
3715 #if !CONFIG_MEM_POOLS
3716 buf = (uint8_t *)OSA_MemoryAllocate(total_len);
3717 #else
3718 buf = OSA_MemoryPoolAllocate(buf_512_MemoryPool);
3719 #endif
3720 if (buf == MNULL)
3721 {
3722 wifi_e("Cannot allocate memory");
3723 return -WM_FAIL;
3724 }
3725
3726 (void)memset(buf, 0, total_len);
3727
3728 tlv = (tlvbuf_custom_ie *)(void *)buf;
3729 tlv->type = MRVL_MGMT_IE_LIST_TLV_ID;
3730
3731 /* Locate headers */
3732 ie_ptr = (custom_ie *)(tlv->ie_data);
3733 /* Set TLV fields */
3734 buf_len = sizeof(tlvbuf_custom_ie);
3735
3736 if (action == HostCmd_ACT_GEN_SET)
3737 {
3738 if (*ie_len == 0U)
3739 {
3740 /*
3741 MGMT_WPA_IE = MGMT_VENDOR_SPECIFIC_221
3742 MGMT_WPS_IE = MGMT_VENDOR_SPECIFIC_221
3743 */
3744
3745 if (!ie_index_is_set(mgmt_bitmap_index))
3746 {
3747 #if !CONFIG_MEM_POOLS
3748 OSA_MemoryFree(buf);
3749 #else
3750 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3751 #endif
3752 return -WM_FAIL;
3753 }
3754
3755 ie_ptr->mgmt_subtype_mask = MGMT_MASK_CLEAR;
3756 ie_ptr->ie_length = 0;
3757 ie_ptr->ie_index = (t_u16)mgmt_bitmap_index;
3758
3759 tlv->length = sizeof(custom_ie) - MAX_IE_SIZE;
3760 buf_len += tlv->length;
3761 clear_ie_index(mgmt_bitmap_index);
3762 }
3763 else
3764 {
3765 ret = get_free_mgmt_ie_index(&mgmt_ie_index);
3766
3767 if (WM_SUCCESS != ret)
3768 {
3769 #if !CONFIG_MEM_POOLS
3770 OSA_MemoryFree(buf);
3771 #else
3772 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3773 #endif
3774 return -WM_FAIL;
3775 }
3776
3777 tlv->length = (sizeof(custom_ie) - MAX_IE_SIZE) + *ie_len;
3778 ie_ptr->ie_index = mgmt_ie_index;
3779
3780 ie_ptr->mgmt_subtype_mask = mask;
3781
3782 ie_ptr->ie_length = *ie_len;
3783
3784 buf_len += tlv->length;
3785
3786 (void)memcpy((void *)&ie_ptr->ie_buffer, (const void *)buffer, *ie_len);
3787 }
3788 }
3789 else if (action == HostCmd_ACT_GEN_GET)
3790 {
3791 /* Get WPS IE */
3792 tlv->length = 0;
3793 }
3794 else
3795 { /* Do Nothing */
3796 }
3797
3798 mlan_status rv = wrapper_wlan_cmd_mgmt_ie(bss_type, buf, buf_len, action);
3799
3800 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
3801 {
3802 #if !CONFIG_MEM_POOLS
3803 OSA_MemoryFree(buf);
3804 #else
3805 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3806 #endif
3807 return -WM_FAIL;
3808 }
3809
3810 if (action == HostCmd_ACT_GEN_GET)
3811 {
3812 if (wm_wifi.cmd_resp_status != 0)
3813 {
3814 wifi_w("Unable to get mgmt ie buffer");
3815 #if !CONFIG_MEM_POOLS
3816 OSA_MemoryFree(buf);
3817 #else
3818 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3819 #endif
3820 return wm_wifi.cmd_resp_status;
3821 }
3822 ie_ptr = (custom_ie *)(void *)(buf);
3823 (void)memcpy((void *)buffer, (const void *)ie_ptr->ie_buffer, ie_ptr->ie_length);
3824 *ie_len = ie_ptr->ie_length;
3825 }
3826
3827 #if !CONFIG_MEM_POOLS
3828 OSA_MemoryFree(buf);
3829 #else
3830 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
3831 #endif
3832
3833 if ((action == HostCmd_ACT_GEN_SET) && *ie_len)
3834 {
3835 set_ie_index(mgmt_ie_index);
3836 return mgmt_ie_index;
3837 }
3838 else
3839 {
3840 return WM_SUCCESS;
3841 }
3842 }
3843
wifi_get_mgmt_ie2(mlan_bss_type bss_type,void * buf,unsigned int * buf_len)3844 int wifi_get_mgmt_ie2(mlan_bss_type bss_type, void *buf, unsigned int *buf_len)
3845 {
3846 return wifi_config_mgmt_ie2(bss_type, HostCmd_ACT_GEN_GET, 0, buf, buf_len, 0);
3847 }
3848
wifi_set_mgmt_ie2(mlan_bss_type bss_type,unsigned short mask,void * buf,unsigned int buf_len)3849 int wifi_set_mgmt_ie2(mlan_bss_type bss_type, unsigned short mask, void *buf, unsigned int buf_len)
3850 {
3851 unsigned int data_len = buf_len;
3852
3853 return wifi_config_mgmt_ie2(bss_type, HostCmd_ACT_GEN_SET, mask, buf, &data_len, 0);
3854 }
3855
wifi_clear_mgmt_ie2(mlan_bss_type bss_type,int mgmt_bitmap_index)3856 int wifi_clear_mgmt_ie2(mlan_bss_type bss_type, int mgmt_bitmap_index)
3857 {
3858 unsigned int data_len = 0;
3859
3860 return wifi_config_mgmt_ie2(bss_type, HostCmd_ACT_GEN_SET, 0, NULL, &data_len, mgmt_bitmap_index);
3861 }
3862
3863 #ifdef SD8801
wifi_get_ext_coex_stats(wifi_ext_coex_stats_t * ext_coex_stats)3864 int wifi_get_ext_coex_stats(wifi_ext_coex_stats_t *ext_coex_stats)
3865 {
3866 if (ext_coex_stats == NULL)
3867 {
3868 wifi_e("Invalid structure passed");
3869 return -WM_FAIL;
3870 }
3871
3872 return wifi_config_ext_coex(HostCmd_ACT_GEN_GET, NULL, ext_coex_stats);
3873 }
3874
wifi_set_ext_coex_config(const wifi_ext_coex_config_t * ext_coex_config)3875 int wifi_set_ext_coex_config(const wifi_ext_coex_config_t *ext_coex_config)
3876 {
3877 if (ext_coex_config == NULL)
3878 {
3879 wifi_e("Invalid structure passed");
3880 return -WM_FAIL;
3881 }
3882
3883 return wifi_config_ext_coex(HostCmd_ACT_GEN_SET, ext_coex_config, NULL);
3884 }
3885 #endif
3886
3887 #if CONFIG_WPA_SUPP
3888 #if UAP_SUPPORT
wifi_set_custom_ie(custom_ie * beacon_ies_data,custom_ie * beacon_wps_ies_data,custom_ie * proberesp_ies_data,custom_ie * assocresp_ies_data)3889 int wifi_set_custom_ie(custom_ie *beacon_ies_data,
3890 custom_ie *beacon_wps_ies_data,
3891 custom_ie *proberesp_ies_data,
3892 custom_ie *assocresp_ies_data)
3893 {
3894 mlan_ds_misc_custom_ie *pcustom_ie = NULL;
3895 t_u8 *pos = NULL;
3896 t_u16 len = 0;
3897 mlan_status status = MLAN_STATUS_SUCCESS;
3898 t_u32 remain_len = 0;
3899 HostCmd_DS_COMMAND *cmd = NULL;
3900
3901 ENTER();
3902
3903 pcustom_ie = OSA_MemoryAllocate(sizeof(mlan_ds_misc_custom_ie));
3904 if (!pcustom_ie)
3905 {
3906 PRINTM(MERROR, "Fail to allocate custome_ie\n");
3907 status = MLAN_STATUS_FAILURE;
3908 goto done;
3909 }
3910
3911 pcustom_ie->type = TLV_TYPE_MGMT_IE;
3912
3913 pos = (t_u8 *)pcustom_ie->ie_data_list;
3914 remain_len = sizeof(pcustom_ie->ie_data_list);
3915 if (beacon_ies_data)
3916 {
3917 len = sizeof(*beacon_ies_data) - MAX_IE_SIZE + beacon_ies_data->ie_length;
3918 memcpy(pos, beacon_ies_data, len);
3919 pos += len;
3920 remain_len -= len;
3921 pcustom_ie->len += len;
3922 }
3923
3924 if (beacon_wps_ies_data)
3925 {
3926 len = sizeof(*beacon_wps_ies_data) - MAX_IE_SIZE + beacon_wps_ies_data->ie_length;
3927 memcpy(pos, beacon_wps_ies_data, len);
3928 pos += len;
3929 remain_len -= len;
3930 pcustom_ie->len += len;
3931 }
3932
3933 if (proberesp_ies_data)
3934 {
3935 len = sizeof(*proberesp_ies_data) - MAX_IE_SIZE + proberesp_ies_data->ie_length;
3936 memcpy(pos, proberesp_ies_data, len);
3937 pos += len;
3938 remain_len -= len;
3939 pcustom_ie->len += len;
3940 }
3941
3942 if (assocresp_ies_data)
3943 {
3944 len = sizeof(*assocresp_ies_data) - MAX_IE_SIZE + assocresp_ies_data->ie_length;
3945 memcpy(pos, assocresp_ies_data, len);
3946 pos += len;
3947 remain_len -= len;
3948 pcustom_ie->len += len;
3949 }
3950
3951 (void)wifi_get_command_lock();
3952
3953 cmd = wifi_get_command_buffer();
3954
3955 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
3956
3957 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0U /* seq_num */, 0U /* bss_num */, MLAN_BSS_TYPE_UAP);
3958
3959 cmd->result = 0x0;
3960
3961 status = wlan_ops_uap_prepare_cmd((mlan_private *)mlan_adap->priv[1], HOST_CMD_APCMD_SYS_CONFIGURE,
3962 HostCmd_ACT_GEN_SET, 0, NULL, (void *)pcustom_ie, cmd);
3963
3964 (void)wifi_wait_for_cmdresp(NULL);
3965
3966 OSA_MemoryFree(pcustom_ie);
3967
3968 done:
3969 LEAVE();
3970 return status;
3971 }
3972 #endif
3973
wifi_get_scan_table(mlan_private * pmpriv,mlan_scan_resp * pscan_resp)3974 void wifi_get_scan_table(mlan_private *pmpriv, mlan_scan_resp *pscan_resp)
3975 {
3976 mlan_adapter *pmadapter = pmpriv->adapter;
3977
3978 pscan_resp->pscan_table = (t_u8 *)pmadapter->pscan_table;
3979 pscan_resp->num_in_scan_table = pmadapter->num_in_scan_table;
3980 pscan_resp->age_in_secs = pmadapter->age_in_secs;
3981 #if CONFIG_SCAN_CHANNEL_GAP
3982 pscan_resp->pchan_stats = (t_u8 *)pmadapter->pchan_stats;
3983 pscan_resp->num_in_chan_stats = pmadapter->num_in_chan_stats;
3984 #endif
3985 }
3986 #endif
3987
wifi_set_chanlist(wifi_chanlist_t * chanlist)3988 int wifi_set_chanlist(wifi_chanlist_t *chanlist)
3989 {
3990 mlan_status ret;
3991 t_u8 i = 0;
3992 t_u8 cfp_no_bg = 0;
3993 #if CONFIG_5GHz_SUPPORT
3994 t_u8 cfp_no_a = 0;
3995 #endif
3996 mlan_adapter *pmadapter = mlan_adap->priv[0]->adapter;
3997
3998 #ifdef OTP_CHANINFO
3999 if ((pmadapter->otp_region == MNULL) || (pmadapter->otp_region->force_reg == 0U))
4000 {
4001 #endif
4002 /*
4003 * Validate if the channels provided in the channel list
4004 * are valid channels according to World Wide Safe Mode.
4005 */
4006 for (i = 0; i < chanlist->num_chans; i++)
4007 {
4008 if (!wlan_is_channel_and_freq_valid(pmadapter, chanlist->chan_info[i].chan_num,
4009 chanlist->chan_info[i].chan_freq))
4010 {
4011 wifi_e("Invalid channel %d\r\n", chanlist->chan_info[i].chan_num);
4012 return -WM_FAIL;
4013 }
4014 }
4015
4016 /* Configure Custom CFP Tables */
4017 #if CONFIG_5GHz_SUPPORT
4018 ret = wlan_set_custom_cfp_table(chanlist, &cfp_no_bg, &cfp_no_a);
4019 #else
4020 ret = wlan_set_custom_cfp_table(chanlist, &cfp_no_bg);
4021 #endif
4022 if (ret != MLAN_STATUS_SUCCESS)
4023 {
4024 wifi_e("Failed to set Custom CFP Table");
4025 return -WM_FAIL;
4026 }
4027
4028 /* Set Region Table */
4029 #if CONFIG_5GHz_SUPPORT
4030 wlan_set_custom_regiontable((mlan_private *)mlan_adap->priv[0], cfp_no_bg, cfp_no_a);
4031 #else
4032 wlan_set_custom_regiontable((mlan_private *)mlan_adap->priv[0], cfp_no_bg);
4033 #endif
4034 #ifdef OTP_CHANINFO
4035 }
4036 #endif
4037
4038 return WM_SUCCESS;
4039 }
4040
wifi_get_chanlist(wifi_chanlist_t * chanlist)4041 int wifi_get_chanlist(wifi_chanlist_t *chanlist)
4042 {
4043 mlan_adapter *pmadapter = mlan_adap->priv[0]->adapter;
4044 region_chan_t *pchan_region = MNULL;
4045 const chan_freq_power_t *cfp = MNULL;
4046 t_u32 region_idx = 0;
4047 t_u32 next_chan = 0;
4048 chanlist->num_chans = 0;
4049
4050 for (region_idx = 0; region_idx < NELEMENTS(pmadapter->region_channel); region_idx++)
4051 {
4052 if (!pmadapter->region_channel[region_idx].valid)
4053 {
4054 continue;
4055 }
4056
4057 pchan_region = &pmadapter->region_channel[region_idx];
4058
4059 for (next_chan = 0; next_chan < pchan_region->num_cfp; next_chan++)
4060 {
4061 cfp = pchan_region->pcfp + next_chan;
4062 if (cfp == MNULL)
4063 {
4064 wifi_e("No cfp configured");
4065 return -WM_FAIL;
4066 }
4067
4068 if ((cfp->dynamic.flags & NXP_CHANNEL_DISABLED) != 0U)
4069 {
4070 continue;
4071 }
4072
4073 chanlist->chan_info[chanlist->num_chans].chan_num = cfp->channel;
4074 chanlist->chan_info[chanlist->num_chans].chan_freq = cfp->freq;
4075 chanlist->chan_info[chanlist->num_chans].passive_scan_or_radar_detect = cfp->passive_scan_or_radar_detect;
4076 chanlist->num_chans++;
4077
4078 if (chanlist->num_chans >= NELEMENTS(chanlist->chan_info))
4079 {
4080 break;
4081 }
4082 }
4083 }
4084
4085 return WM_SUCCESS;
4086 }
4087
4088 #if UAP_SUPPORT
wifi_get_active_channel_list(t_u8 * chan_list,t_u8 * num_chans,t_u16 acs_band)4089 void wifi_get_active_channel_list(t_u8 *chan_list, t_u8 *num_chans, t_u16 acs_band)
4090 {
4091 if (chan_list != MNULL && num_chans != MNULL)
4092 {
4093 wlan_get_active_channel_list((mlan_private *)mlan_adap->priv[1], chan_list, num_chans, acs_band);
4094 }
4095 }
4096 #endif
4097
wifi_set_txpwrlimit(wifi_txpwrlimit_t * txpwrlimit)4098 int wifi_set_txpwrlimit(wifi_txpwrlimit_t *txpwrlimit)
4099 {
4100 t_u8 i;
4101 int ret;
4102 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4103 t_u8 *pByte = NULL;
4104 MrvlIETypes_ChanTRPCConfig_t *trpc_tlv = NULL;
4105
4106 (void)wifi_get_command_lock();
4107
4108 cmd->command = HostCmd_CMD_CHANNEL_TRPC_CONFIG;
4109 cmd->seq_num = 0x0;
4110 cmd->result = 0x0;
4111 cmd->size = S_DS_GEN + 2U * sizeof(t_u16) +
4112 txpwrlimit->num_chans * (sizeof(MrvlIEtypesHeader_t) + sizeof(MrvlChannelDesc_t)) +
4113 (txpwrlimit->num_chans * txpwrlimit->txpwrlimit_config->num_mod_grps * sizeof(MrvlChanTrpcEntry_t));
4114
4115 HostCmd_DS_CHAN_TRPC_CONFIG *txpwrlimit_config = (HostCmd_DS_CHAN_TRPC_CONFIG *)(void *)((uint8_t *)cmd + S_DS_GEN);
4116
4117 txpwrlimit_config->action = HostCmd_ACT_GEN_SET;
4118 txpwrlimit_config->reserved = txpwrlimit->subband;
4119
4120 pByte = (t_u8 *)txpwrlimit_config->tlv_buffer;
4121
4122 for (i = 0; i < txpwrlimit->num_chans; i++)
4123 {
4124 trpc_tlv = (MrvlIETypes_ChanTRPCConfig_t *)(void *)pByte;
4125 trpc_tlv->header.type = TLV_TYPE_CHANNEL_TRPC_CONFIG;
4126 trpc_tlv->header.len =
4127 sizeof(MrvlChannelDesc_t) + txpwrlimit->txpwrlimit_config->num_mod_grps * sizeof(MrvlChanTrpcEntry_t);
4128 trpc_tlv->start_freq = txpwrlimit->txpwrlimit_config[i].chan_desc.start_freq;
4129 trpc_tlv->width = txpwrlimit->txpwrlimit_config[i].chan_desc.chan_width;
4130 trpc_tlv->chan_num = txpwrlimit->txpwrlimit_config[i].chan_desc.chan_num;
4131 (void)memcpy((void *)trpc_tlv->mod_group, (const void *)txpwrlimit->txpwrlimit_config[i].txpwrlimit_entry,
4132 txpwrlimit->txpwrlimit_config->num_mod_grps * sizeof(MrvlChanTrpcEntry_t));
4133 pByte += trpc_tlv->header.len + sizeof(trpc_tlv->header);
4134 }
4135 ret = wifi_wait_for_cmdresp(NULL);
4136 return ret;
4137 }
4138
wifi_get_txpwrlimit(wifi_SubBand_t subband,wifi_txpwrlimit_t * txpwrlimit)4139 int wifi_get_txpwrlimit(wifi_SubBand_t subband, wifi_txpwrlimit_t *txpwrlimit)
4140 {
4141 int ret;
4142
4143 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4144
4145 (void)wifi_get_command_lock();
4146
4147 cmd->command = HostCmd_CMD_CHANNEL_TRPC_CONFIG;
4148 cmd->seq_num = 0x0;
4149 cmd->result = 0x0;
4150 cmd->size = S_DS_GEN + 2U * sizeof(t_u16);
4151
4152 HostCmd_DS_CHAN_TRPC_CONFIG *txpwrlimit_config = (HostCmd_DS_CHAN_TRPC_CONFIG *)(void *)((uint8_t *)cmd + S_DS_GEN);
4153
4154 txpwrlimit_config->action = HostCmd_ACT_GEN_GET;
4155 txpwrlimit_config->reserved = subband;
4156
4157 ret = wifi_wait_for_cmdresp(txpwrlimit);
4158 return ret;
4159 }
4160
4161 #if CONFIG_WIFI_RTS_THRESHOLD
wifi_set_rts(int rts,mlan_bss_type bss_type)4162 int wifi_set_rts(int rts, mlan_bss_type bss_type)
4163 {
4164 mlan_ioctl_req req;
4165 mlan_ds_snmp_mib *mib = NULL;
4166 mlan_status ret = MLAN_STATUS_FAILURE;
4167 #if UAP_SUPPORT
4168 wifi_sta_list_t *sl = NULL;
4169 #endif
4170
4171 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
4172
4173 /* Allocate an IOCTL request buffer */
4174 #if !CONFIG_MEM_POOLS
4175 mib = OSA_MemoryAllocate(sizeof(mlan_ds_snmp_mib));
4176 #else
4177 mib = OSA_MemoryPoolAllocate(buf_128_MemoryPool);
4178 #endif
4179
4180 if (mib == NULL)
4181 return -WM_FAIL;
4182
4183 /* Fill request buffer */
4184 mib->sub_command = MLAN_OID_SNMP_MIB_RTS_THRESHOLD;
4185 req.pbuf = (t_u8 *)mib;
4186 req.buf_len = sizeof(mlan_ds_snmp_mib);
4187 req.req_id = MLAN_IOCTL_SNMP_MIB;
4188 req.action = MLAN_ACT_SET;
4189 req.bss_index = bss_type;
4190
4191 if (req.action == MLAN_ACT_SET)
4192 {
4193 if (rts < MLAN_RTS_MIN_VALUE || rts > MLAN_RTS_MAX_VALUE)
4194 {
4195 #if !CONFIG_MEM_POOLS
4196 OSA_MemoryFree(mib);
4197 #else
4198 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4199 #endif
4200 return -WM_FAIL;
4201 }
4202 mib->param.rts_threshold = rts;
4203 }
4204
4205 #if UAP_SUPPORT
4206 if (bss_type == MLAN_BSS_TYPE_UAP)
4207 {
4208 if (!is_uap_started())
4209 {
4210 wifi_e("uap isn't up\n\r");
4211 #if !CONFIG_MEM_POOLS
4212 OSA_MemoryFree(mib);
4213 #else
4214 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4215 #endif
4216 return -WM_FAIL;
4217 }
4218 wifi_uap_bss_sta_list(&sl);
4219 if (!sl)
4220 {
4221 wifi_e("Failed to get sta list\n\r");
4222 #if !CONFIG_MEM_POOLS
4223 OSA_MemoryFree(mib);
4224 #else
4225 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4226 #endif
4227 return -WM_FAIL;
4228 }
4229 if (sl->count >= 1)
4230 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
4231 else
4232 wifi_e("uap required sta to connect before setting rts threshold\n\r");
4233 }
4234 else if (bss_type == MLAN_BSS_TYPE_STA)
4235 #else
4236 if (bss_type == MLAN_BSS_TYPE_STA)
4237 #endif
4238 {
4239 if (is_sta_connected())
4240 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
4241 else
4242 wifi_e("sta connection required before setting rts threshold\n\r");
4243 }
4244
4245 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
4246 {
4247 #if !CONFIG_MEM_POOLS
4248 OSA_MemoryFree(mib);
4249 #else
4250 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4251 #endif
4252 return -WM_FAIL;
4253 }
4254
4255 #if !CONFIG_MEM_POOLS
4256 OSA_MemoryFree(mib);
4257 #else
4258 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4259 #endif
4260
4261 return WM_SUCCESS;
4262 }
4263 #endif
4264
4265 #if CONFIG_WIFI_FRAG_THRESHOLD
wifi_set_frag(int frag,mlan_bss_type bss_type)4266 int wifi_set_frag(int frag, mlan_bss_type bss_type)
4267 {
4268 mlan_ioctl_req req;
4269 mlan_ds_snmp_mib *mib = NULL;
4270 mlan_status ret = MLAN_STATUS_FAILURE;
4271 #if UAP_SUPPORT
4272 wifi_sta_list_t *sl = NULL;
4273 #endif
4274
4275 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
4276
4277 /* Allocate an IOCTL request buffer */
4278 #if !CONFIG_MEM_POOLS
4279 mib = OSA_MemoryAllocate(sizeof(mlan_ds_snmp_mib));
4280 #else
4281 mib = OSA_MemoryPoolAllocate(buf_128_MemoryPool);
4282 #endif
4283
4284 if (mib == NULL)
4285 return -WM_FAIL;
4286
4287 /* Fill request buffer */
4288 mib->sub_command = MLAN_OID_SNMP_MIB_FRAG_THRESHOLD;
4289 req.pbuf = (t_u8 *)mib;
4290 req.buf_len = sizeof(mlan_ds_snmp_mib);
4291 req.req_id = MLAN_IOCTL_SNMP_MIB;
4292 req.action = MLAN_ACT_SET;
4293 req.bss_index = bss_type;
4294
4295 if (req.action == MLAN_ACT_SET)
4296 {
4297 if (frag < MLAN_FRAG_MIN_VALUE || frag > MLAN_FRAG_MAX_VALUE)
4298 {
4299 #if !CONFIG_MEM_POOLS
4300 OSA_MemoryFree(mib);
4301 #else
4302 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4303 #endif
4304 return -WM_FAIL;
4305 }
4306 mib->param.frag_threshold = frag;
4307 }
4308
4309 #if UAP_SUPPORT
4310 if (bss_type == MLAN_BSS_TYPE_UAP)
4311 {
4312 if (!is_uap_started())
4313 {
4314 wifi_e("uap isn't up\n\r");
4315 #if !CONFIG_MEM_POOLS
4316 OSA_MemoryFree(mib);
4317 #else
4318 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4319 #endif
4320 return -WM_FAIL;
4321 }
4322 wifi_uap_bss_sta_list(&sl);
4323 if (!sl)
4324 {
4325 wifi_e("Failed to get sta list\n\r");
4326 #if !CONFIG_MEM_POOLS
4327 OSA_MemoryFree(mib);
4328 #else
4329 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4330 #endif
4331 return -WM_FAIL;
4332 }
4333
4334 if (sl->count >= 1)
4335 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
4336 else
4337 wifi_e("uap required sta to connect before setting fragment threshold\n\r");
4338 }
4339 else if (bss_type == MLAN_BSS_TYPE_STA)
4340 #else
4341 if (bss_type == MLAN_BSS_TYPE_STA)
4342 #endif
4343 {
4344 if (is_sta_connected())
4345 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
4346 else
4347 wifi_e("sta connection required before setting fragment threshold\n\r");
4348 }
4349
4350 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
4351 {
4352 #if !CONFIG_MEM_POOLS
4353 OSA_MemoryFree(mib);
4354 #else
4355 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4356 #endif
4357 return -WM_FAIL;
4358 }
4359 #if !CONFIG_MEM_POOLS
4360 OSA_MemoryFree(mib);
4361 #else
4362 OSA_MemoryPoolFree(buf_128_MemoryPool, mib);
4363 #endif
4364 return WM_SUCCESS;
4365 }
4366 #endif
4367
wifi_set_curr_bss_channel(uint8_t channel)4368 void wifi_set_curr_bss_channel(uint8_t channel)
4369 {
4370 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
4371
4372 pmpriv->curr_bss_params.bss_descriptor.channel = channel;
4373 }
4374
4375 #if CONFIG_11K_OFFLOAD
wifi_11k_cfg(int enable_11k)4376 int wifi_11k_cfg(int enable_11k)
4377 {
4378 mlan_ioctl_req req;
4379 mlan_ds_11k_cfg *pcfg_11k = NULL;
4380 mlan_status ret = MLAN_STATUS_SUCCESS;
4381
4382 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
4383
4384 /* Allocate an IOCTL request buffer */
4385 #if !CONFIG_MEM_POOLS
4386 pcfg_11k = OSA_MemoryAllocate(sizeof(mlan_ds_11k_cfg));
4387 #else
4388 pcfg_11k = OSA_MemoryPoolAllocate(buf_128_MemoryPool);
4389 #endif
4390
4391 if (pcfg_11k == NULL)
4392 {
4393 ret = MLAN_STATUS_FAILURE;
4394 return ret;
4395 }
4396
4397 /* Fill request buffer */
4398 pcfg_11k->sub_command = MLAN_OID_11K_CFG_ENABLE;
4399 req.pbuf = (t_u8 *)pcfg_11k;
4400 req.buf_len = sizeof(mlan_ds_11k_cfg);
4401 req.req_id = MLAN_IOCTL_11K_CFG;
4402 req.action = MLAN_ACT_SET;
4403
4404 if (enable_11k != 0 && enable_11k != 1)
4405 {
4406 ret = MLAN_STATUS_FAILURE;
4407 #if !CONFIG_MEM_POOLS
4408 OSA_MemoryFree(pcfg_11k);
4409 #else
4410 OSA_MemoryPoolFree(buf_128_MemoryPool, pcfg_11k);
4411 #endif
4412 return ret;
4413 }
4414
4415 pcfg_11k->param.enable_11k = enable_11k;
4416
4417 if (!is_sta_connected())
4418 {
4419 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
4420 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
4421 {
4422 #if !CONFIG_MEM_POOLS
4423 OSA_MemoryFree(pcfg_11k);
4424 #else
4425 OSA_MemoryPoolFree(buf_128_MemoryPool, pcfg_11k);
4426 #endif
4427 return -WM_FAIL;
4428 }
4429 }
4430 else
4431 wifi_e("sta disconnection is required before enable/disable 11k\r\n");
4432
4433 #if !CONFIG_MEM_POOLS
4434 OSA_MemoryFree(pcfg_11k);
4435 #else
4436 OSA_MemoryPoolFree(buf_128_MemoryPool, pcfg_11k);
4437 #endif
4438
4439 return WM_SUCCESS;
4440 }
4441
wifi_11k_neighbor_req()4442 int wifi_11k_neighbor_req()
4443 {
4444 if (!is_sta_connected())
4445 {
4446 wifi_e("sta connection is required before sending neighbor report req\r\n");
4447 return -WM_FAIL;
4448 }
4449
4450 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4451
4452 wifi_get_command_lock();
4453
4454 cmd->seq_num = 0x0;
4455 cmd->result = 0x0;
4456
4457 wlan_cmd_11k_neighbor_req((mlan_private *)mlan_adap->priv[0], cmd);
4458
4459 wifi_wait_for_cmdresp(NULL);
4460
4461 return WM_SUCCESS;
4462 }
4463 #endif
4464
4465 #if CONFIG_11K
wifi_host_11k_cfg(int enable_11k)4466 int wifi_host_11k_cfg(int enable_11k)
4467 {
4468 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
4469 #if !CONFIG_WPA_SUPP
4470 IEEEtypes_RrmElement_t rrmCap;
4471 #endif
4472 int ret = (int)MLAN_STATUS_SUCCESS;
4473
4474 #if CONFIG_11K_OFFLOAD
4475 /* Check if fw base 11k is enabled */
4476 if (enable_11k == 1 && pmpriv->enable_11k == (t_u8)1U)
4477 {
4478 return -WM_E_PERM;
4479 }
4480 #endif
4481 if (enable_11k == (int)pmpriv->enable_host_11k)
4482 {
4483 return (int)MLAN_STATUS_SUCCESS;
4484 }
4485
4486 #if !CONFIG_WPA_SUPP
4487 if (enable_11k == 1)
4488 {
4489 if (pmpriv->rrm_mgmt_bitmap_index != -1)
4490 {
4491 ret = wifi_clear_mgmt_ie(MLAN_BSS_TYPE_STA, MGMT_RRM_ENABLED_CAP, pmpriv->rrm_mgmt_bitmap_index);
4492
4493 pmpriv->rrm_mgmt_bitmap_index = -1;
4494 }
4495 rrmCap.element_id = (t_u8)MGMT_RRM_ENABLED_CAP;
4496 rrmCap.len = (t_u8)sizeof(IEEEtypes_RrmEnabledCapabilities_t);
4497 wlan_dot11k_formatRrmCapabilities(&(rrmCap.RrmEnabledCapabilities), 100);
4498
4499 /* Append the passed data to the end of
4500 * the genIeBuffer */
4501 __memcpy(pmpriv->adapter, pmpriv->assoc_req_buf, &rrmCap, sizeof(IEEEtypes_RrmElement_t));
4502
4503 /* Increment the stored buffer length by
4504 * the size passed */
4505 pmpriv->assoc_req_size = sizeof(IEEEtypes_RrmElement_t);
4506 }
4507 else
4508 {
4509 pmpriv->assoc_req_size = 0;
4510 }
4511 #endif
4512
4513 pmpriv->enable_host_11k = (t_u8)enable_11k;
4514
4515 return ret;
4516 }
4517
wifi_host_11k_neighbor_req(const char * ssid)4518 int wifi_host_11k_neighbor_req(const char *ssid)
4519 {
4520 if (wlan_strlen((t_s8 *)ssid) > IEEEtypes_SSID_SIZE)
4521 {
4522 return -WM_FAIL;
4523 }
4524 else
4525 {
4526 return wlan_send_mgmt_rm_neighbor_request(mlan_adap->priv[0], (t_u8 *)ssid, (t_u8)wlan_strlen((t_s8 *)ssid));
4527 }
4528 }
4529 #endif
4530
4531 #if CONFIG_11V
wifi_host_11v_bss_trans_query(t_u8 query_reason)4532 int wifi_host_11v_bss_trans_query(t_u8 query_reason)
4533 {
4534 return wlan_send_mgmt_bss_trans_query(mlan_adap->priv[0], query_reason);
4535 }
4536 #endif
4537
4538 #if CONFIG_DRIVER_MBO
wifi_host_mbo_cfg(int enable_mbo)4539 int wifi_host_mbo_cfg(int enable_mbo)
4540 {
4541 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
4542 IEEEtypes_VendorSpecific_t mboie;
4543 int ret = (int)MLAN_STATUS_SUCCESS;
4544 t_u8 *pos;
4545 int meas_vend_hdr_len = 0;
4546
4547 if ((t_u8)enable_mbo == pmpriv->enable_mbo)
4548 {
4549 /* Do nothing */
4550 return (int)MLAN_STATUS_SUCCESS;
4551 }
4552
4553 if (enable_mbo != 0)
4554 {
4555 mboie.vend_hdr.element_id = (IEEEtypes_ElementId_e)MGMT_MBO_IE;
4556 pos = mboie.vend_hdr.oui;
4557 pos = wlan_add_mbo_oui(pos);
4558 pos = wlan_add_mbo_oui_type(pos);
4559 pos = wlan_add_mbo_cellular_cap(pos);
4560 meas_vend_hdr_len = pos - mboie.vend_hdr.oui;
4561 mboie.vend_hdr.len = (t_u8)meas_vend_hdr_len;
4562 pmpriv->mbo_mgmt_bitmap_index =
4563 wifi_set_mgmt_ie(MLAN_BSS_TYPE_STA, MGMT_MBO_IE, (void *)&(mboie.vend_hdr.oui), mboie.vend_hdr.len);
4564 }
4565 else
4566 {
4567 ret = wifi_clear_mgmt_ie(MLAN_BSS_TYPE_STA, MGMT_MBO_IE, pmpriv->mbo_mgmt_bitmap_index);
4568 }
4569 pmpriv->enable_mbo = (t_u8)enable_mbo;
4570
4571 return ret;
4572 }
4573
wifi_mbo_preferch_cfg(t_u8 ch0,t_u8 pefer0,t_u8 ch1,t_u8 pefer1)4574 int wifi_mbo_preferch_cfg(t_u8 ch0, t_u8 pefer0, t_u8 ch1, t_u8 pefer1)
4575 {
4576 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
4577 IEEEtypes_VendorSpecific_t mboie;
4578 int ret = (int)MLAN_STATUS_SUCCESS;
4579 t_u8 *pos;
4580 int meas_vend_hdr_len = 0;
4581
4582 if (0U == pmpriv->enable_mbo)
4583 {
4584 wifi_e("Please enable MBO first!");
4585 return (int)MLAN_STATUS_FAILURE;
4586 }
4587
4588 if (pmpriv->enable_mbo != 0U)
4589 {
4590 /* remove MBO OCE IE in case there is already a MBO OCE IE. */
4591 ret = wifi_clear_mgmt_ie(MLAN_BSS_TYPE_STA, MGMT_MBO_IE, pmpriv->mbo_mgmt_bitmap_index);
4592 mboie.vend_hdr.element_id = (IEEEtypes_ElementId_e)MGMT_MBO_IE;
4593 pos = mboie.vend_hdr.oui;
4594 pos = wlan_add_mbo_oui(pos);
4595 pos = wlan_add_mbo_oui_type(pos);
4596 pos = wlan_add_mbo_cellular_cap(pos);
4597 pos = wlan_add_mbo_prefer_ch(pos, ch0, pefer0, ch1, pefer1);
4598 meas_vend_hdr_len = pos - mboie.vend_hdr.oui;
4599 mboie.vend_hdr.len = (t_u8)meas_vend_hdr_len;
4600 pmpriv->mbo_mgmt_bitmap_index =
4601 wifi_set_mgmt_ie(MLAN_BSS_TYPE_STA, MGMT_MBO_IE, (void *)&(mboie.vend_hdr.oui), mboie.vend_hdr.len);
4602 }
4603
4604 return ret;
4605 }
4606
wifi_mbo_send_preferch_wnm(t_u8 * src_addr,t_u8 * target_bssid,t_u8 ch0,t_u8 pefer0,t_u8 ch1,t_u8 pefer1)4607 int wifi_mbo_send_preferch_wnm(t_u8 *src_addr, t_u8 *target_bssid, t_u8 ch0, t_u8 pefer0, t_u8 ch1, t_u8 pefer1)
4608 {
4609 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
4610 int ret = MLAN_STATUS_SUCCESS;
4611 t_u8 *buf, *pos, *pos_len1, *pos_len2;
4612 t_u8 global_oper_class_0 = 0, global_oper_class_1 = 0, num = 0, i;
4613
4614 if (0 == pmpriv->enable_mbo)
4615 {
4616 wifi_e("Please enable MBO first!\r\n");
4617 return MLAN_STATUS_FAILURE;
4618 }
4619
4620 if (pmpriv->enable_mbo)
4621 {
4622 #if !CONFIG_MEM_POOLS
4623 buf = OSA_MemoryAllocate(sizeof(IEEEtypes_VendorSpecific_t));
4624 #else
4625 buf = OSA_MemoryPoolAllocate(buf_512_MemoryPool);
4626 #endif
4627 pos = buf;
4628
4629 /* No non-preferred channels */
4630 if (!ch0 && !pefer0 && !ch1 && !pefer1)
4631 {
4632 *pos = MGMT_MBO_IE;
4633 pos++;
4634 *pos = 4;
4635 pos++;
4636 pos = wlan_add_mbo_oui(pos);
4637 pos = wlan_add_mbo_attr_id(pos);
4638 }
4639 else
4640 {
4641 wlan_get_curr_oper_class(pmpriv, ch0, BW_20MHZ, &global_oper_class_0);
4642 wlan_get_curr_oper_class(pmpriv, ch1, BW_20MHZ, &global_oper_class_1);
4643 if (global_oper_class_0 != global_oper_class_1 || pefer0 != pefer1)
4644 num = 2;
4645 else
4646 num = 1;
4647
4648 for (i = 0; i < num; i++)
4649 {
4650 *pos = MGMT_MBO_IE;
4651 pos++;
4652 if (i == 0)
4653 pos_len1 = pos;
4654 else
4655 pos_len2 = pos;
4656 pos++;
4657 pos = wlan_add_mbo_oui(pos);
4658 pos = wlan_add_mbo_attr_id(pos);
4659 if (num == 1)
4660 {
4661 pos[0] = global_oper_class_0;
4662 pos[1] = ch0;
4663 pos[2] = ch1;
4664 pos[3] = pefer0;
4665 pos += 4;
4666 }
4667 else
4668 {
4669 if (i == 0)
4670 {
4671 pos[0] = global_oper_class_0;
4672 pos[1] = ch0;
4673 pos[2] = pefer0;
4674 }
4675 else
4676 {
4677 pos[0] = global_oper_class_1;
4678 pos[1] = ch1;
4679 pos[2] = pefer1;
4680 }
4681 pos += 3;
4682 }
4683
4684 /* Reason code */
4685 *pos = 0;
4686 pos++;
4687
4688 if (i == 0)
4689 *pos_len1 = pos - (pos_len1 + 1);
4690 else
4691 *pos_len2 = pos - (pos_len2 + 1);
4692 }
4693 }
4694 wlan_send_mgmt_wnm_notification(src_addr, target_bssid, target_bssid, buf, pos - buf, false);
4695 }
4696 #if !CONFIG_MEM_POOLS
4697 OSA_MemoryFree(buf);
4698 #else
4699 OSA_MemoryPoolFree(buf_512_MemoryPool, buf);
4700 #endif
4701
4702 return ret;
4703 }
4704 #endif
4705
4706 #ifdef OTP_CHANINFO
wifi_get_fw_region_and_cfp_tables(void)4707 int wifi_get_fw_region_and_cfp_tables(void)
4708 {
4709 int ret;
4710
4711 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4712
4713 (void)wifi_get_command_lock();
4714
4715 cmd->command = HostCmd_CMD_CHAN_REGION_CFG;
4716 cmd->seq_num = 0x0;
4717 cmd->result = 0x0;
4718 cmd->size = S_DS_GEN + sizeof(HostCmd_DS_CHAN_REGION_CFG);
4719
4720 HostCmd_DS_CHAN_REGION_CFG *chan_region_cfg = (HostCmd_DS_CHAN_REGION_CFG *)(void *)((uint8_t *)cmd + S_DS_GEN);
4721
4722 chan_region_cfg->action = HostCmd_ACT_GEN_GET;
4723
4724 ret = wifi_wait_for_cmdresp(NULL);
4725 return ret;
4726 }
4727
wifi_free_fw_region_and_cfp_tables(void)4728 void wifi_free_fw_region_and_cfp_tables(void)
4729 {
4730 mlan_adapter *pmadapter = mlan_adap->priv[0]->adapter;
4731 wlan_free_fw_cfp_tables(pmadapter);
4732 }
4733 #endif
4734
wifi_set_ed_mac_mode(wifi_ed_mac_ctrl_t * wifi_ed_mac_ctrl,int bss_type)4735 int wifi_set_ed_mac_mode(wifi_ed_mac_ctrl_t *wifi_ed_mac_ctrl, int bss_type)
4736 {
4737 int ret;
4738
4739 if (wifi_ed_mac_ctrl == MNULL)
4740 {
4741 return -WM_FAIL;
4742 }
4743
4744 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[bss_type];
4745 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
4746 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4747
4748 (void)wifi_get_command_lock();
4749
4750 cmd->command = HostCmd_CMD_ED_MAC_MODE;
4751 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
4752 cmd->result = 0x0;
4753 cmd->size = S_DS_GEN + sizeof(HostCmd_CONFIG_ED_MAC_MODE);
4754
4755 HostCmd_CONFIG_ED_MAC_MODE *ed_mac_mode = (HostCmd_CONFIG_ED_MAC_MODE *)(void *)((uint8_t *)cmd + S_DS_GEN);
4756
4757 ed_mac_mode->ed_ctrl_2g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_ctrl_2g);
4758 ed_mac_mode->ed_offset_2g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_offset_2g);
4759 #if CONFIG_5GHz_SUPPORT
4760 ed_mac_mode->ed_ctrl_5g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_ctrl_5g);
4761 ed_mac_mode->ed_offset_5g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_offset_5g);
4762 #if defined(SD9177)
4763 ed_mac_mode->ed_bitmap_txq_lock = 0x1e00ff;
4764 #else
4765 ed_mac_mode->ed_bitmap_txq_lock = 0xff;
4766 #endif
4767 #endif
4768
4769 pmpriv->ed_mac_mode.ed_ctrl_2g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_ctrl_2g);
4770 pmpriv->ed_mac_mode.ed_offset_2g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_offset_2g);
4771 #if CONFIG_5GHz_SUPPORT
4772 pmpriv->ed_mac_mode.ed_ctrl_5g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_ctrl_5g);
4773 pmpriv->ed_mac_mode.ed_offset_5g = wlan_cpu_to_le16(wifi_ed_mac_ctrl->ed_offset_5g);
4774 #endif
4775
4776 ret = wifi_wait_for_cmdresp(NULL);
4777 return ret;
4778 }
4779
wifi_get_ed_mac_mode(wifi_ed_mac_ctrl_t * wifi_ed_mac_ctrl,int bss_type)4780 int wifi_get_ed_mac_mode(wifi_ed_mac_ctrl_t *wifi_ed_mac_ctrl, int bss_type)
4781 {
4782 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[bss_type];
4783 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
4784
4785 if (wifi_ed_mac_ctrl == MNULL)
4786 {
4787 return -WM_FAIL;
4788 }
4789
4790 (void)memset(wifi_ed_mac_ctrl, 0x00, sizeof(wifi_ed_mac_ctrl_t));
4791
4792 wifi_ed_mac_ctrl->ed_ctrl_2g = wlan_cpu_to_le16(pmpriv->ed_mac_mode.ed_ctrl_2g);
4793 wifi_ed_mac_ctrl->ed_offset_2g = wlan_cpu_to_le16(pmpriv->ed_mac_mode.ed_offset_2g);
4794 #if CONFIG_5GHz_SUPPORT
4795 wifi_ed_mac_ctrl->ed_ctrl_5g = wlan_cpu_to_le16(pmpriv->ed_mac_mode.ed_ctrl_5g);
4796 wifi_ed_mac_ctrl->ed_offset_5g = wlan_cpu_to_le16(pmpriv->ed_mac_mode.ed_offset_5g);
4797 #endif
4798
4799 return WM_SUCCESS;
4800 }
4801
4802 #ifndef IEEEtypes_SSID_SIZE
4803 #define IEEEtypes_SSID_SIZE 32
4804 #endif /* IEEEtypes_SSID_SIZE */
4805 #if UAP_SUPPORT
4806 #define MRVL_SSID_TLV_ID 0x0000
4807 #define MRVL_BEACON_PERIOD_TLV_ID (PROPRIETARY_TLV_BASE_ID + 0x2cU)
4808 #define TLV_TYPE_SMCADDRRANGE (PROPRIETARY_TLV_BASE_ID + 0xccU)
4809 #define TLV_TYPE_SMCFRAMEFILTER (PROPRIETARY_TLV_BASE_ID + 0xd1U)
4810
wifi_set_smart_mode_cfg(char * ssid,int beacon_period,wifi_chan_list_param_set_t * chan_list,uint8_t * smc_start_addr,uint8_t * smc_end_addr,uint16_t filter_type,int smc_frame_filter_len,uint8_t * smc_frame_filter,int custom_ie_len,uint8_t * custom_ie)4811 int wifi_set_smart_mode_cfg(char *ssid,
4812 int beacon_period,
4813 wifi_chan_list_param_set_t *chan_list,
4814 uint8_t *smc_start_addr,
4815 uint8_t *smc_end_addr,
4816 uint16_t filter_type,
4817 int smc_frame_filter_len,
4818 uint8_t *smc_frame_filter,
4819 int custom_ie_len,
4820 uint8_t *custom_ie)
4821 {
4822 unsigned int ssid_len = 0, i;
4823 uint32_t size = S_DS_GEN + sizeof(HostCmd_DS_SYS_CONFIG) - 1U;
4824 MrvlIEtypes_SsIdParamSet_t *tlv_ssid = NULL;
4825 MrvlIEtypes_beacon_period_t *tlv_beacon_period = NULL;
4826 MrvlIEtypes_ChanListParamSet_t *tlv_chan_list = NULL;
4827 MrvlIEtypes_Data_t *tlv_custom_ie = NULL;
4828 MrvlIETypes_SmcAddrRange_t *tlv_smc_addr_range = NULL;
4829 MrvlIETypes_SmcFrameFilter_t *tlv_smc_frame_filter = NULL;
4830
4831 (void)wifi_get_command_lock();
4832 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4833
4834 cmd->command = wlan_cpu_to_le16(HOST_CMD_SMART_MODE_CFG);
4835 HostCmd_DS_SYS_CONFIG *sys_config_cmd = (HostCmd_DS_SYS_CONFIG *)((uint32_t)cmd + S_DS_GEN);
4836 sys_config_cmd->action = HostCmd_ACT_GEN_SET;
4837 uint8_t *tlv = (uint8_t *)sys_config_cmd->tlv_buffer;
4838
4839 ssid_len = strlen(ssid);
4840 if (ssid_len > IEEEtypes_SSID_SIZE || custom_ie_len > 255)
4841 {
4842 return -WM_E_INVAL;
4843 };
4844
4845 tlv_ssid = (MrvlIEtypes_SsIdParamSet_t *)(void *)sys_config_cmd->tlv_buffer;
4846 tlv_ssid->header.type = MRVL_SSID_TLV_ID;
4847 tlv_ssid->header.len = strlen(ssid);
4848 (void)memcpy((void *)tlv_ssid->ssid, (const void *)ssid, strlen(ssid));
4849 size += sizeof(tlv_ssid->header) + tlv_ssid->header.len;
4850 tlv += sizeof(tlv_ssid->header) + tlv_ssid->header.len;
4851 tlv_beacon_period = (MrvlIEtypes_beacon_period_t *)(void *)tlv;
4852 tlv_beacon_period->header.type = MRVL_BEACON_PERIOD_TLV_ID;
4853 tlv_beacon_period->header.len = sizeof(uint16_t);
4854 tlv_beacon_period->beacon_period = beacon_period;
4855
4856 size += sizeof(tlv_beacon_period->header) + tlv_beacon_period->header.len;
4857 tlv += sizeof(tlv_beacon_period->header) + tlv_beacon_period->header.len;
4858
4859 tlv_chan_list = (MrvlIEtypes_ChanListParamSet_t *)(void *)tlv;
4860 tlv_chan_list->header.type = TLV_TYPE_CHANLIST;
4861 tlv_chan_list->header.len = chan_list->no_of_channels * sizeof(ChanScanParamSet_t);
4862
4863 for (i = 0; i < chan_list->no_of_channels; i++)
4864 {
4865 tlv_chan_list->chan_scan_param[i].chan_number = chan_list->chan_scan_param[i].chan_number;
4866 tlv_chan_list->chan_scan_param[i].min_scan_time = chan_list->chan_scan_param[i].min_scan_time;
4867 tlv_chan_list->chan_scan_param[i].max_scan_time = chan_list->chan_scan_param[i].max_scan_time;
4868 }
4869
4870 size += sizeof(tlv_chan_list->header) + tlv_chan_list->header.len;
4871 tlv += sizeof(tlv_chan_list->header) + tlv_chan_list->header.len;
4872
4873 if (custom_ie != MNULL && custom_ie_len > 0)
4874 {
4875 tlv_custom_ie = (MrvlIEtypes_Data_t *)(void *)tlv;
4876 tlv_custom_ie->header.type = TLV_TYPE_PASSTHROUGH;
4877 tlv_custom_ie->header.len = custom_ie_len;
4878 (void)memcpy((void *)tlv_custom_ie->data, (const void *)custom_ie, custom_ie_len);
4879
4880 size += sizeof(tlv_custom_ie->header) + tlv_custom_ie->header.len;
4881 tlv += sizeof(tlv_custom_ie->header) + tlv_custom_ie->header.len;
4882 }
4883
4884 if (smc_start_addr != MNULL && smc_end_addr != MNULL)
4885 {
4886 tlv_smc_addr_range = (MrvlIETypes_SmcAddrRange_t *)(void *)tlv;
4887 tlv_smc_addr_range->header.type = TLV_TYPE_SMCADDRRANGE;
4888 tlv_smc_addr_range->header.len = 2U * MLAN_MAC_ADDR_LENGTH + sizeof(uint16_t);
4889
4890 (void)memcpy((void *)tlv_smc_addr_range->smcstartAddr, (const void *)smc_start_addr, MLAN_MAC_ADDR_LENGTH);
4891 (void)memcpy((void *)tlv_smc_addr_range->smcendAddr, (const void *)smc_end_addr, MLAN_MAC_ADDR_LENGTH);
4892
4893 tlv_smc_addr_range->filter_type = filter_type;
4894
4895 size += sizeof(tlv_smc_addr_range->header) + tlv_smc_addr_range->header.len;
4896 tlv += sizeof(tlv_smc_addr_range->header) + tlv_smc_addr_range->header.len;
4897 }
4898
4899 tlv_smc_frame_filter = (MrvlIETypes_SmcFrameFilter_t *)(void *)tlv;
4900 tlv_smc_frame_filter->header.type = TLV_TYPE_SMCFRAMEFILTER;
4901 tlv_smc_frame_filter->header.len = smc_frame_filter_len;
4902 (void)memcpy((void *)tlv_smc_frame_filter->frame_filter, (const void *)smc_frame_filter, smc_frame_filter_len);
4903
4904 size += sizeof(tlv_smc_frame_filter->header) + tlv_smc_frame_filter->header.len;
4905 tlv += sizeof(tlv_smc_frame_filter->header) + tlv_smc_frame_filter->header.len;
4906
4907 cmd->size = size;
4908 cmd->seq_num = 0x00;
4909 cmd->result = 0x00;
4910
4911 (void)wifi_wait_for_cmdresp(NULL);
4912
4913 return WM_SUCCESS;
4914 }
4915
wifi_get_smart_mode_cfg(void)4916 int wifi_get_smart_mode_cfg(void)
4917 {
4918 uint32_t size = S_DS_GEN + sizeof(HostCmd_DS_SYS_CONFIG) - 1U;
4919
4920 (void)wifi_get_command_lock();
4921 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4922
4923 cmd->command = wlan_cpu_to_le16(HOST_CMD_SMART_MODE_CFG);
4924 HostCmd_DS_SYS_CONFIG *sys_config_cmd = (HostCmd_DS_SYS_CONFIG *)((uint32_t)cmd + S_DS_GEN);
4925 sys_config_cmd->action = HostCmd_ACT_GEN_GET;
4926
4927 cmd->size = size;
4928 cmd->seq_num = 0x00;
4929 cmd->result = 0x00;
4930
4931 (void)wifi_wait_for_cmdresp(NULL);
4932 return WM_SUCCESS;
4933 }
4934
wifi_start_smart_mode(void)4935 int wifi_start_smart_mode(void)
4936 {
4937 uint32_t size = S_DS_GEN + sizeof(HostCmd_DS_SYS_CONFIG) - 1U;
4938
4939 (void)wifi_get_command_lock();
4940 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4941
4942 cmd->command = wlan_cpu_to_le16(HOST_CMD_SMART_MODE_CFG);
4943 HostCmd_DS_SYS_CONFIG *sys_config_cmd = (HostCmd_DS_SYS_CONFIG *)((uint32_t)cmd + S_DS_GEN);
4944 sys_config_cmd->action = HostCmd_ACT_GEN_START;
4945
4946 cmd->size = size;
4947 cmd->seq_num = 0x00;
4948 cmd->result = 0x00;
4949
4950 (void)wifi_wait_for_cmdresp(NULL);
4951 return WM_SUCCESS;
4952 }
4953
wifi_stop_smart_mode(void)4954 int wifi_stop_smart_mode(void)
4955 {
4956 uint32_t size = S_DS_GEN + sizeof(HostCmd_DS_SYS_CONFIG) - 1U;
4957
4958 (void)wifi_get_command_lock();
4959 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
4960
4961 cmd->command = wlan_cpu_to_le16(HOST_CMD_SMART_MODE_CFG);
4962 HostCmd_DS_SYS_CONFIG *sys_config_cmd = (HostCmd_DS_SYS_CONFIG *)((uint32_t)cmd + S_DS_GEN);
4963 sys_config_cmd->action = HostCmd_ACT_GEN_STOP;
4964
4965 cmd->size = size;
4966 cmd->seq_num = 0x00;
4967 cmd->result = 0x00;
4968
4969 (void)wifi_wait_for_cmdresp(NULL);
4970
4971 return WM_SUCCESS;
4972 }
4973 #endif /* UAP_SUPPORT */
4974
4975 #if CONFIG_BG_SCAN
wifi_get_band(mlan_private * pmpriv,int * band)4976 void wifi_get_band(mlan_private *pmpriv, int *band)
4977 {
4978 int support_band = 0;
4979
4980 if (pmpriv->config_bands & (BAND_B | BAND_G | BAND_GN))
4981 support_band |= WIFI_FREQUENCY_BAND_2GHZ;
4982 #if CONFIG_5GHz_SUPPORT
4983 if (pmpriv->config_bands & (BAND_A | BAND_AN))
4984 support_band |= WIFI_FREQUENCY_BAND_5GHZ;
4985 #endif
4986 *band = support_band;
4987 if (support_band == WIFI_FREQUENCY_ALL_BAND)
4988 *band = WIFI_FREQUENCY_BAND_AUTO;
4989 }
4990
wifi_get_bgscan_results(mlan_private * pmpriv)4991 int wifi_get_bgscan_results(mlan_private *pmpriv)
4992 {
4993 mlan_adapter *pmadapter = pmpriv->adapter;
4994 int ret = 0;
4995 #if CONFIG_WPA_SUPP
4996 BSSDescriptor_t *bss_entry = NULL;
4997 int i;
4998 #endif
4999
5000 ENTER();
5001
5002 #if CONFIG_WPA_SUPP
5003 pmadapter->wpa_supp_scan_triggered = MTRUE;
5004 for (i = 0; i < pmadapter->num_in_scan_table; i++)
5005 {
5006 bss_entry = &pmadapter->pscan_table[i];
5007 if (bss_entry && bss_entry->ies != NULL)
5008 {
5009 OSA_MemoryFree(bss_entry->ies);
5010 }
5011 }
5012 #endif
5013
5014 memset(pmadapter->pscan_table, 0x00, sizeof(BSSDescriptor_t) * MRVDRV_MAX_BSSID_LIST);
5015 pmadapter->num_in_scan_table = 0;
5016 ret = wifi_request_bgscan_query(pmpriv);
5017 pmadapter->bgscan_reported = MFALSE;
5018 LEAVE();
5019 return ret;
5020 }
5021
wifi_send_scan_query(void)5022 int wifi_send_scan_query(void)
5023 {
5024 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
5025 int ret = 0;
5026
5027 ENTER();
5028 ret = wifi_get_bgscan_results(pmpriv);
5029 if (ret)
5030 {
5031 PRINTM(MERROR, "Failed to get scan results\n");
5032 goto done;
5033 }
5034 done:
5035 /* config rssi low threshold again */
5036 pmpriv->rssi_low = DEFAULT_RSSI_LOW_THRESHOLD;
5037 LEAVE();
5038 return ret;
5039 }
5040 #endif
5041
wifi_send_hostcmd(const void * cmd_buf,uint32_t cmd_buf_len,void * resp_buf,uint32_t resp_buf_len,uint32_t * reqd_resp_len)5042 int wifi_send_hostcmd(
5043 const void *cmd_buf, uint32_t cmd_buf_len, void *resp_buf, uint32_t resp_buf_len, uint32_t *reqd_resp_len)
5044 {
5045 uint32_t ret = WM_SUCCESS;
5046 /* Store IN & OUT params to be used by driver to update internaally*/
5047 /* These variables are updated from reponse handlers */
5048 wm_wifi.hostcmd_cfg.resp_buf = resp_buf;
5049 wm_wifi.hostcmd_cfg.resp_buf_len = resp_buf_len;
5050 wm_wifi.hostcmd_cfg.reqd_resp_len = reqd_resp_len;
5051
5052 /* Check if command is larger than the command size that can be handled by firmware */
5053 if (cmd_buf_len > WIFI_FW_CMDBUF_SIZE)
5054 {
5055 *reqd_resp_len = 0;
5056 return WM_E_INBIG;
5057 }
5058 else if (cmd_buf_len < WIFI_HOST_CMD_FIXED_HEADER_LEN)
5059 /* Check if command is smaller than the minimum command size needed, which is WIFI_HOST_CMD_FIXED_HEADER_LEN */
5060 {
5061 *reqd_resp_len = 0;
5062 return WM_E_INSMALL;
5063 }
5064 else
5065 {
5066 /* Do Nothing */
5067 }
5068 (void)wifi_get_command_lock();
5069 /* Copy command buffer to driver command buffer */
5070 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5071 (void)memcpy((void *)cmd, (const void *)cmd_buf, cmd_buf_len);
5072
5073 /* Set global variable to say that this command is from user invocation */
5074 wm_wifi.hostcmd_cfg.is_hostcmd = true;
5075 (void)wifi_wait_for_cmdresp(&wm_wifi.hostcmd_cfg);
5076
5077 if (*reqd_resp_len > resp_buf_len)
5078 {
5079 ret = WM_E_OUTBIG;
5080 }
5081 /*Response fail check not checked here, as thats caller's responsibility */
5082 return ret;
5083 }
5084
5085 #if CONFIG_WIFI_EU_CRYPTO
wifi_set_eu_crypto(EU_Crypto * Crypto_Data,enum _crypto_algorithm Algorithm,t_u16 EncDec)5086 int wifi_set_eu_crypto(EU_Crypto *Crypto_Data, enum _crypto_algorithm Algorithm, t_u16 EncDec)
5087 {
5088 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5089 t_u16 cmd_size;
5090 t_u16 *DataLength = Crypto_Data->DataLength;
5091
5092 wifi_get_command_lock();
5093
5094 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
5095 cmd->command = HostCmd_CMD_EU_CRYPTO;
5096 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, MLAN_BSS_ROLE_STA);
5097
5098 switch (Algorithm)
5099 {
5100 case CRYPTO_RC4:
5101 case CRYPTO_AES_ECB:
5102 case CRYPTO_AES_WRAP:
5103 {
5104 cmd_size = sizeof(HostCmd_DS_EU_CRYPTO) - 1 + 8 /*cmd header */;
5105 cmd->params.eu_crypto.Algorithm = Algorithm;
5106 cmd->params.eu_crypto.KeyLength = Crypto_Data->KeyLength;
5107 memcpy(cmd->params.eu_crypto.Key, Crypto_Data->Key, Crypto_Data->KeyLength);
5108 cmd->params.eu_crypto.KeyIVLength = Crypto_Data->KeyIVLength;
5109 memcpy(cmd->params.eu_crypto.KeyIV, Crypto_Data->KeyIV, Crypto_Data->KeyIVLength);
5110 cmd->params.eu_crypto.DataLength = *DataLength;
5111 memcpy(cmd->params.eu_crypto.Data, Crypto_Data->Data, *DataLength);
5112 cmd_size += cmd->params.eu_crypto.DataLength;
5113 cmd->params.eu_crypto.EncDec = EncDec;
5114 cmd->params.eu_crypto.DataType = 0x0111;
5115 break;
5116 }
5117 case CRYPTO_AES_CCMP:
5118 case CRYPTO_AES_GCMP:
5119 {
5120 cmd_size = sizeof(HostCmd_DS_EU_AES_CRYPTO) - 1 + 8 /* cmd header */;
5121 cmd->params.eu_aes_crypto.Algorithm = Algorithm;
5122 cmd->params.eu_aes_crypto.KeyLength = Crypto_Data->KeyLength;
5123 memcpy(cmd->params.eu_aes_crypto.Key, Crypto_Data->Key, Crypto_Data->KeyLength);
5124 cmd->params.eu_aes_crypto.NonceLength = Crypto_Data->NonceLength;
5125 memcpy(cmd->params.eu_aes_crypto.Nonce, Crypto_Data->Nonce, Crypto_Data->NonceLength);
5126 cmd->params.eu_aes_crypto.AADLength = Crypto_Data->AADLength;
5127 memcpy(cmd->params.eu_aes_crypto.AAD, Crypto_Data->AAD, Crypto_Data->AADLength);
5128 cmd->params.eu_aes_crypto.DataLength = *DataLength;
5129 memcpy(cmd->params.eu_aes_crypto.Data, Crypto_Data->Data, *DataLength);
5130 cmd_size += cmd->params.eu_aes_crypto.DataLength;
5131 cmd->params.eu_aes_crypto.EncDec = EncDec;
5132 cmd->params.eu_aes_crypto.DataType = 0x0111;
5133 break;
5134 }
5135 default:
5136 return -WM_FAIL;
5137 }
5138 cmd->size = cmd_size;
5139
5140 return wifi_wait_for_cmdresp(Crypto_Data);
5141 }
5142 #endif
5143
wifi_set_rx_mgmt_indication(unsigned int bss_type,unsigned int mgmt_subtype_mask)5144 int wifi_set_rx_mgmt_indication(unsigned int bss_type, unsigned int mgmt_subtype_mask)
5145 {
5146 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[bss_type];
5147 CHECK_BSS_TYPE(bss_type, -WM_FAIL);
5148
5149 mlan_ds_rx_mgmt_indication rx_mgmt_indication;
5150
5151 memset(&rx_mgmt_indication, 0x00, sizeof(mlan_ds_rx_mgmt_indication));
5152
5153 rx_mgmt_indication.mgmt_subtype_mask = mgmt_subtype_mask;
5154
5155 wifi_get_command_lock();
5156 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5157
5158 cmd->command = HostCmd_CMD_RX_MGMT_IND;
5159 #if CONFIG_P2P
5160 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0U /* seq_num */, 0U /* bss_num */, MLAN_BSS_TYPE_WIFIDIRECT);
5161 #else
5162 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0U /* seq_num */, 0U /* bss_num */, bss_type);
5163 #endif /* CONFIG_P2P */
5164 cmd->result = 0x0;
5165
5166 wlan_cmd_rx_mgmt_indication(pmpriv, cmd, HostCmd_ACT_GEN_SET, &rx_mgmt_indication);
5167
5168 wifi_wait_for_cmdresp(NULL);
5169
5170 return wm_wifi.cmd_resp_status;
5171 }
5172
wifi_get_set_bandcfg(wifi_bandcfg_t * bandcfg,mlan_act_ioctl action)5173 int wifi_get_set_bandcfg(wifi_bandcfg_t *bandcfg, mlan_act_ioctl action)
5174 {
5175 mlan_ioctl_req req;
5176 mlan_ds_radio_cfg radio_cfg;
5177
5178 if ((action != MLAN_ACT_GET) && (action != MLAN_ACT_SET))
5179 {
5180 return -WM_FAIL;
5181 }
5182
5183 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
5184 (void)memset(&radio_cfg, 0x00, sizeof(mlan_ds_radio_cfg));
5185 radio_cfg.sub_command = MLAN_OID_BAND_CFG;
5186
5187 req.pbuf = (t_u8 *)&radio_cfg;
5188 req.buf_len = sizeof(mlan_ds_radio_cfg);
5189 req.bss_index = 0;
5190 req.req_id = MLAN_IOCTL_RADIO_CFG;
5191 req.action = action;
5192 if (action == MLAN_ACT_SET)
5193 {
5194 radio_cfg.param.band_cfg.config_bands = bandcfg->config_bands;
5195 }
5196
5197 mlan_status rv = wlan_ops_sta_ioctl(mlan_adap, &req);
5198 if (rv != MLAN_STATUS_SUCCESS)
5199 {
5200 return -WM_FAIL;
5201 }
5202
5203 if (action == MLAN_ACT_GET)
5204 {
5205 bandcfg->config_bands = radio_cfg.param.band_cfg.config_bands;
5206 bandcfg->fw_bands = radio_cfg.param.band_cfg.fw_bands;
5207 }
5208
5209 return WM_SUCCESS;
5210 }
5211
5212 #if CONFIG_WPS2
5213 /* enable/disable WPS session */
wifi_send_wps_cfg_cmd(int option)5214 int wifi_send_wps_cfg_cmd(int option)
5215 {
5216 mlan_ioctl_req req;
5217 mlan_ds_wps_cfg pwps;
5218
5219 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
5220 (void)memset(&pwps, 0x00, sizeof(mlan_ds_wps_cfg));
5221 pwps.sub_command = MLAN_OID_WPS_CFG_SESSION;
5222 if (option)
5223 pwps.param.wps_session = MLAN_WPS_CFG_SESSION_START;
5224 else
5225 pwps.param.wps_session = MLAN_WPS_CFG_SESSION_END;
5226 req.pbuf = (t_u8 *)&pwps;
5227 req.buf_len = sizeof(mlan_ds_wps_cfg);
5228 req.bss_index = 0;
5229 req.req_id = MLAN_IOCTL_WPS_CFG;
5230 req.action = MLAN_ACT_SET;
5231
5232 mlan_status rv = wlan_ops_sta_ioctl(mlan_adap, &req);
5233 if (rv != MLAN_STATUS_SUCCESS && rv != MLAN_STATUS_PENDING)
5234 {
5235 return -WM_FAIL;
5236 }
5237
5238 return WM_SUCCESS;
5239 }
5240 #endif /* CONFIG_WPS2 */
5241
wifi_PrepDefaultMgtMsg(t_u8 sub_type,mlan_802_11_mac_addr * DestAddr,mlan_802_11_mac_addr * SrcAddr,mlan_802_11_mac_addr * Bssid,t_u16 pkt_len)5242 wlan_mgmt_pkt *wifi_PrepDefaultMgtMsg(t_u8 sub_type,
5243 mlan_802_11_mac_addr *DestAddr,
5244 mlan_802_11_mac_addr *SrcAddr,
5245 mlan_802_11_mac_addr *Bssid,
5246 t_u16 pkt_len)
5247 {
5248 wlan_mgmt_pkt *pmgmt_pkt_hdr = MNULL;
5249 IEEEtypes_FrameCtl_t *mgmt_fc_p = MNULL;
5250 t_u8 *pBuf = MNULL;
5251
5252 #if !CONFIG_MEM_POOLS
5253 pBuf = OSA_MemoryAllocate(pkt_len);
5254 #else
5255 pBuf = OSA_MemoryPoolAllocate(buf_1536_MemoryPool);
5256 #endif
5257
5258 if (pBuf == MNULL)
5259 {
5260 return MNULL;
5261 }
5262
5263 pmgmt_pkt_hdr = (wlan_mgmt_pkt *)(void *)pBuf;
5264 /* 802.11 header */
5265 mgmt_fc_p = (IEEEtypes_FrameCtl_t *)(void *)&pmgmt_pkt_hdr->wlan_header.frm_ctl;
5266 mgmt_fc_p->sub_type = sub_type;
5267 mgmt_fc_p->type = (t_u8)IEEE_TYPE_MANAGEMENT;
5268 (void)memcpy(pmgmt_pkt_hdr->wlan_header.addr1, DestAddr, MLAN_MAC_ADDR_LENGTH);
5269 (void)memcpy(pmgmt_pkt_hdr->wlan_header.addr2, SrcAddr, MLAN_MAC_ADDR_LENGTH);
5270 (void)memcpy(pmgmt_pkt_hdr->wlan_header.addr3, Bssid, MLAN_MAC_ADDR_LENGTH);
5271
5272 return pmgmt_pkt_hdr;
5273 }
5274
5275 #if CONFIG_ECSA
5276 wifi_ecsa_status_control ecsa_status_control = {false, 0};
5277
set_ecsa_block_tx_time(t_u8 switch_count)5278 void set_ecsa_block_tx_time(t_u8 switch_count)
5279 {
5280 ecsa_status_control.block_time = switch_count;
5281 }
5282
get_ecsa_block_tx_time()5283 t_u8 get_ecsa_block_tx_time()
5284 {
5285 return ecsa_status_control.block_time;
5286 }
5287
set_ecsa_block_tx_flag(bool block_tx)5288 void set_ecsa_block_tx_flag(bool block_tx)
5289 {
5290 ecsa_status_control.required = block_tx;
5291 }
5292
get_ecsa_block_tx_flag()5293 bool get_ecsa_block_tx_flag()
5294 {
5295 return ecsa_status_control.required;
5296 }
5297
wifi_put_ecsa_sem()5298 void wifi_put_ecsa_sem()
5299 {
5300 OSA_SemaphorePost((osa_semaphore_handle_t)ecsa_status_control.ecsa_sem);
5301 }
5302
wlan_get_nonglobal_operclass_by_bw_channel(t_u8 bandwidth,t_u8 channel,t_u8 * oper_class)5303 int wlan_get_nonglobal_operclass_by_bw_channel(t_u8 bandwidth, t_u8 channel, t_u8 *oper_class)
5304 {
5305 int ret = 0;
5306 mlan_ioctl_req req;
5307 mlan_ds_misc_cfg *misc = NULL;
5308 mlan_status status = MLAN_STATUS_SUCCESS;
5309
5310 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
5311
5312 #if !CONFIG_MEM_POOLS
5313 misc = OSA_MemoryAllocate(sizeof(mlan_ds_misc_cfg));
5314 #else
5315 misc = OSA_MemoryPoolAllocate(buf_512_MemoryPool);
5316 #endif
5317
5318 if (misc == NULL)
5319 {
5320 return -WM_FAIL;
5321 }
5322
5323 req.bss_index = MLAN_BSS_ROLE_UAP;
5324 req.pbuf = (t_u8 *)misc;
5325 misc->sub_command = MLAN_OID_MISC_OPER_CLASS;
5326 req.req_id = MLAN_IOCTL_MISC_CFG;
5327 req.action = MLAN_ACT_GET;
5328 misc->param.bw_chan_oper.bandwidth = bandwidth;
5329 misc->param.bw_chan_oper.channel = channel;
5330
5331 status = wlan_ops_uap_ioctl(mlan_adap, &req);
5332 if (status != MLAN_STATUS_SUCCESS)
5333 {
5334 wifi_e("Failed to get operclass");
5335 #if !CONFIG_MEM_POOLS
5336 OSA_MemoryFree(misc);
5337 #else
5338 OSA_MemoryPoolFree(buf_512_MemoryPool, misc);
5339 #endif
5340 return -WM_FAIL;
5341 }
5342 *oper_class = misc->param.bw_chan_oper.oper_class;
5343
5344 #if !CONFIG_MEM_POOLS
5345 OSA_MemoryFree(misc);
5346 #else
5347 OSA_MemoryPoolFree(buf_512_MemoryPool, misc);
5348 #endif
5349
5350 return ret;
5351 }
5352
wifi_set_ecsa_cfg(t_u8 block_tx,t_u8 oper_class,t_u8 channel,t_u8 switch_count,t_u8 band_width,t_u8 ecsa)5353 int wifi_set_ecsa_cfg(t_u8 block_tx, t_u8 oper_class, t_u8 channel, t_u8 switch_count, t_u8 band_width, t_u8 ecsa)
5354 {
5355 IEEEtypes_ExtChanSwitchAnn_t *ext_chan_switch = NULL;
5356 IEEEtypes_ChanSwitchAnn_t *chan_switch = NULL;
5357 custom_ie *pcust_chansw_ie = NULL;
5358 t_u32 usr_dot_11n_dev_cap = 0;
5359 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[1];
5360 BSSDescriptor_t *pbss_desc;
5361 pbss_desc = &pmpriv->curr_bss_params.bss_descriptor;
5362 t_u8 new_oper_class = oper_class;
5363 t_u8 bw;
5364 int ret = MLAN_STATUS_SUCCESS;
5365 #if (CONFIG_11AC)
5366 t_u8 center_freq_idx = 0;
5367 IEEEtypes_Header_t *pChanSwWrap_ie = NULL;
5368 IEEEtypes_WideBWChanSwitch_t *pbwchansw_ie = NULL;
5369 IEEEtypes_VhtTpcEnvelope_t *pvhttpcEnv_ie = NULL;
5370 #endif
5371 uint8_t *buf = NULL;
5372 tlvbuf_custom_ie *tlv = NULL;
5373 unsigned int mgmt_ie_index = -1;
5374 int total_len = sizeof(tlvbuf_custom_ie) + (sizeof(custom_ie) - MAX_IE_SIZE) + sizeof(IEEEtypes_ChanSwitchAnn_t) +
5375 sizeof(IEEEtypes_ExtChanSwitchAnn_t);
5376 #if (CONFIG_11AC)
5377 total_len += sizeof(IEEEtypes_WideBWChanSwitch_t) + sizeof(IEEEtypes_VhtTpcEnvelope_t) + sizeof(IEEEtypes_Header_t);
5378 #endif
5379 uint16_t buf_len = 0;
5380
5381 #if !CONFIG_MEM_POOLS
5382 buf = (uint8_t *)OSA_MemoryAllocate(total_len);
5383 #else
5384 buf = OSA_MemoryPoolAllocate(buf_1024_MemoryPool);
5385 #endif
5386 if (!buf)
5387 {
5388 wifi_e("ECSA allocate memory failed \r\n");
5389 return -WM_FAIL;
5390 }
5391
5392 (void)memset(buf, 0, total_len);
5393 tlv = (tlvbuf_custom_ie *)buf;
5394 tlv->type = MRVL_MGMT_IE_LIST_TLV_ID;
5395
5396 ret = get_free_mgmt_ie_index(&mgmt_ie_index);
5397 if (WM_SUCCESS != ret)
5398 {
5399 #if !CONFIG_MEM_POOLS
5400 OSA_MemoryFree(buf);
5401 #else
5402 OSA_MemoryPoolFree(buf_1024_MemoryPool, buf);
5403 #endif
5404 return -WM_FAIL;
5405 }
5406
5407 pcust_chansw_ie = (custom_ie *)(tlv->ie_data);
5408 pcust_chansw_ie->ie_index = mgmt_ie_index;
5409 pcust_chansw_ie->ie_length = sizeof(IEEEtypes_ChanSwitchAnn_t);
5410 pcust_chansw_ie->mgmt_subtype_mask = MGMT_MASK_BEACON | MGMT_MASK_PROBE_RESP; /*Add IE for
5411 BEACON/probe resp*/
5412 chan_switch = (IEEEtypes_ChanSwitchAnn_t *)pcust_chansw_ie->ie_buffer;
5413 chan_switch->element_id = CHANNEL_SWITCH_ANN;
5414 chan_switch->len = 3;
5415 chan_switch->chan_switch_mode = block_tx;
5416 chan_switch->new_channel_num = channel;
5417 chan_switch->chan_switch_count = switch_count;
5418 DBG_HEXDUMP(MCMD_D, "CSA IE", (t_u8 *)pcust_chansw_ie->ie_buffer, pcust_chansw_ie->ie_length);
5419
5420 #if CONFIG_5GHz_SUPPORT
5421 if (pbss_desc->bss_band & BAND_A)
5422 usr_dot_11n_dev_cap = mlan_adap->usr_dot_11n_dev_cap_a;
5423 else
5424 #endif
5425 usr_dot_11n_dev_cap = mlan_adap->usr_dot_11n_dev_cap_bg;
5426
5427 if (!ISSUPP_CHANWIDTH40(usr_dot_11n_dev_cap))
5428 {
5429 band_width = 0;
5430 }
5431
5432 switch (band_width)
5433 {
5434 case CHANNEL_BW_40MHZ_ABOVE:
5435 case CHANNEL_BW_40MHZ_BELOW:
5436 bw = 40;
5437 break;
5438 #if (CONFIG_11AC)
5439 case CHANNEL_BW_80MHZ:
5440 bw = 80;
5441 break;
5442 case CHANNEL_BW_160MHZ:
5443 bw = 160;
5444 break;
5445 #endif
5446 default:
5447 bw = 20;
5448 break;
5449 }
5450
5451 if (!new_oper_class && ecsa)
5452 wlan_get_nonglobal_operclass_by_bw_channel(bw, channel, &new_oper_class);
5453
5454 if (new_oper_class)
5455 {
5456 pcust_chansw_ie->ie_length += sizeof(IEEEtypes_ExtChanSwitchAnn_t);
5457 ext_chan_switch =
5458 (IEEEtypes_ExtChanSwitchAnn_t *)(pcust_chansw_ie->ie_buffer + sizeof(IEEEtypes_ChanSwitchAnn_t));
5459 ext_chan_switch->element_id = EXTEND_CHANNEL_SWITCH_ANN;
5460 ext_chan_switch->len = 4;
5461 ext_chan_switch->chan_switch_mode = block_tx;
5462 ext_chan_switch->new_oper_class = new_oper_class;
5463 ext_chan_switch->new_channel_num = channel;
5464 ext_chan_switch->chan_switch_count = switch_count;
5465 DBG_HEXDUMP(MCMD_D, "ECSA IE", (t_u8 *)(pcust_chansw_ie->ie_buffer + sizeof(IEEEtypes_ChanSwitchAnn_t)),
5466 pcust_chansw_ie->ie_length - sizeof(IEEEtypes_ChanSwitchAnn_t));
5467 }
5468
5469 #if (CONFIG_11AC)
5470 /* bandwidth 40/80/160 should set channel switch wrapper ie for 11ac 5G
5471 * channel*/
5472 if (band_width && channel > 14)
5473 {
5474 pChanSwWrap_ie = (IEEEtypes_Header_t *)(pcust_chansw_ie->ie_buffer + pcust_chansw_ie->ie_length);
5475 pChanSwWrap_ie->element_id = EXT_POWER_CONSTR;
5476 pChanSwWrap_ie->len = sizeof(IEEEtypes_WideBWChanSwitch_t);
5477
5478 pbwchansw_ie = (IEEEtypes_WideBWChanSwitch_t *)((t_u8 *)pChanSwWrap_ie + sizeof(IEEEtypes_Header_t));
5479 pbwchansw_ie->ieee_hdr.element_id = BW_CHANNEL_SWITCH;
5480 pbwchansw_ie->ieee_hdr.len = sizeof(IEEEtypes_WideBWChanSwitch_t) - sizeof(IEEEtypes_Header_t);
5481
5482 center_freq_idx = wlan_get_center_freq_idx((mlan_private *)mlan_adap->priv[1], BAND_AAC, channel, band_width);
5483 if (band_width == CHANNEL_BW_40MHZ_ABOVE || band_width == CHANNEL_BW_40MHZ_BELOW)
5484 {
5485 pbwchansw_ie->new_channel_width = 0;
5486 pbwchansw_ie->new_channel_center_freq0 = center_freq_idx;
5487 }
5488 else if (band_width == CHANNEL_BW_80MHZ)
5489 {
5490 pbwchansw_ie->new_channel_width = 1;
5491 pbwchansw_ie->new_channel_center_freq0 = center_freq_idx - 4;
5492 pbwchansw_ie->new_channel_center_freq1 = center_freq_idx + 4;
5493 }
5494 else if (band_width == CHANNEL_BW_160MHZ)
5495 {
5496 pbwchansw_ie->new_channel_width = 2;
5497 pbwchansw_ie->new_channel_center_freq0 = center_freq_idx - 8;
5498 pbwchansw_ie->new_channel_center_freq1 = center_freq_idx + 8;
5499 }
5500 else
5501 wifi_e("Invalid bandwidth.Support value 1/3/4/5 for 40+/40-/80/160MHZ\n");
5502
5503 /*prepare the VHT Transmit Power Envelope IE*/
5504 pvhttpcEnv_ie = (IEEEtypes_VhtTpcEnvelope_t *)((t_u8 *)pChanSwWrap_ie + sizeof(IEEEtypes_Header_t) +
5505 sizeof(IEEEtypes_WideBWChanSwitch_t));
5506 pvhttpcEnv_ie->ieee_hdr.element_id = VHT_TX_POWER_ENV;
5507 pvhttpcEnv_ie->ieee_hdr.len = sizeof(IEEEtypes_VhtTpcEnvelope_t) - sizeof(IEEEtypes_Header_t);
5508 /* Local Max TX Power Count= 3,
5509 * Local TX Power Unit Inter=EIP(0) */
5510 pvhttpcEnv_ie->tpc_info = 3;
5511 pvhttpcEnv_ie->local_max_tp_20mhz = 0xff;
5512 pvhttpcEnv_ie->local_max_tp_40mhz = 0xff;
5513 pvhttpcEnv_ie->local_max_tp_80mhz = 0xff;
5514 pvhttpcEnv_ie->local_max_tp_160mhz_80_80mhz = 0xff;
5515 pChanSwWrap_ie->len += sizeof(IEEEtypes_VhtTpcEnvelope_t);
5516 pcust_chansw_ie->ie_length += pChanSwWrap_ie->len + sizeof(IEEEtypes_Header_t);
5517 DBG_HEXDUMP(MCMD_D, "Channel switch wrapper IE", (t_u8 *)pChanSwWrap_ie,
5518 pChanSwWrap_ie->len + sizeof(IEEEtypes_Header_t));
5519 }
5520 #endif
5521 tlv->length = sizeof(custom_ie) + pcust_chansw_ie->ie_length - MAX_IE_SIZE;
5522
5523 buf_len = pcust_chansw_ie->ie_length + sizeof(tlvbuf_custom_ie) + sizeof(custom_ie) - MAX_IE_SIZE;
5524
5525 ret = wrapper_wlan_cmd_mgmt_ie(MLAN_BSS_TYPE_UAP, buf, buf_len, HostCmd_ACT_GEN_SET);
5526 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
5527 {
5528 wifi_e("Failed to set ECSA IE");
5529 #if !CONFIG_MEM_POOLS
5530 OSA_MemoryFree(buf);
5531 #else
5532 OSA_MemoryPoolFree(buf_1024_MemoryPool, buf);
5533 #endif
5534 return -WM_FAIL;
5535 }
5536 set_ie_index(mgmt_ie_index);
5537
5538 OSA_SemaphoreWait((osa_semaphore_handle_t)ecsa_status_control.ecsa_sem, (switch_count + 2) * wm_wifi.beacon_period);
5539 set_ecsa_block_tx_flag(false);
5540
5541 if (!ie_index_is_set(mgmt_ie_index))
5542 {
5543 #if !CONFIG_MEM_POOLS
5544 OSA_MemoryFree(buf);
5545 #else
5546 OSA_MemoryPoolFree(buf_1024_MemoryPool, buf);
5547 #endif
5548 return -WM_FAIL;
5549 }
5550
5551 /*Clear ECSA ie*/
5552 (void)memset(buf, 0, total_len);
5553 tlv = (tlvbuf_custom_ie *)buf;
5554 tlv->type = MRVL_MGMT_IE_LIST_TLV_ID;
5555 tlv->length = sizeof(custom_ie) - MAX_IE_SIZE;
5556
5557 pcust_chansw_ie->mgmt_subtype_mask = MGMT_MASK_CLEAR;
5558 pcust_chansw_ie->ie_length = 0;
5559 pcust_chansw_ie->ie_index = mgmt_ie_index;
5560 buf_len = sizeof(tlvbuf_custom_ie) + tlv->length;
5561
5562 ret = wrapper_wlan_cmd_mgmt_ie(MLAN_BSS_TYPE_UAP, buf, buf_len, HostCmd_ACT_GEN_SET);
5563 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
5564 {
5565 wifi_e("Failed to clear ECSA IE");
5566 #if !CONFIG_MEM_POOLS
5567 OSA_MemoryFree(buf);
5568 #else
5569 OSA_MemoryPoolFree(buf_1024_MemoryPool, buf);
5570 #endif
5571 return -WM_FAIL;
5572 }
5573 clear_ie_index(mgmt_ie_index);
5574
5575 #if !CONFIG_MEM_POOLS
5576 OSA_MemoryFree(buf);
5577 #else
5578 OSA_MemoryPoolFree(buf_1024_MemoryPool, buf);
5579 #endif
5580
5581 return WM_SUCCESS;
5582 }
5583
wifi_set_action_ecsa_cfg(t_u8 block_tx,t_u8 oper_class,t_u8 channel,t_u8 switch_count)5584 int wifi_set_action_ecsa_cfg(t_u8 block_tx, t_u8 oper_class, t_u8 channel, t_u8 switch_count)
5585 {
5586 mlan_status ret = MLAN_STATUS_SUCCESS;
5587 mlan_ds_bss *bss = NULL;
5588 mlan_ioctl_req req;
5589
5590 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
5591
5592 #if !CONFIG_MEM_POOLS
5593 bss = OSA_MemoryAllocate(sizeof(mlan_ds_bss));
5594 #else
5595 bss = OSA_MemoryPoolAllocate(buf_1024_MemoryPool);
5596 #endif
5597
5598 if (bss == NULL)
5599 {
5600 return -WM_FAIL;
5601 }
5602
5603 req.bss_index = MLAN_BSS_ROLE_UAP;
5604 req.pbuf = (t_u8 *)bss;
5605 bss->sub_command = MLAN_OID_ACTION_CHAN_SWITCH;
5606 req.req_id = MLAN_IOCTL_BSS;
5607 req.action = MLAN_ACT_SET;
5608 bss->param.chanswitch.chan_switch_mode = block_tx;
5609 bss->param.chanswitch.new_channel_num = channel;
5610 bss->param.chanswitch.chan_switch_count = switch_count;
5611 bss->param.chanswitch.new_oper_class = oper_class;
5612
5613 ret = wlan_ops_uap_ioctl(mlan_adap, &req);
5614
5615 if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
5616 {
5617 wifi_e("Failed to set ECSA IE");
5618 #if !CONFIG_MEM_POOLS
5619 OSA_MemoryFree(bss);
5620 #else
5621 OSA_MemoryPoolFree(buf_1024_MemoryPool, bss);
5622 #endif
5623 return -WM_FAIL;
5624 }
5625 #if !CONFIG_MEM_POOLS
5626 OSA_MemoryFree(bss);
5627 #else
5628 OSA_MemoryPoolFree(buf_1024_MemoryPool, bss);
5629 #endif
5630
5631 return WM_SUCCESS;
5632 }
5633
5634 #endif
5635
5636 #define SUBTYPE_AUTH 11
5637 #define AUTH_REQUEST_BUF_SIZE 512
5638
5639 #if CONFIG_WPA_SUPP
5640
5641 #if CONFIG_11R
wifi_same_ess_ft()5642 bool wifi_same_ess_ft()
5643 {
5644 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
5645
5646 return pmpriv->auth_alg == MLAN_AUTH_MODE_FT ? true : false;
5647 }
5648 #endif
5649
wifi_nxp_set_default_scan_ies(const u8 * ies,size_t ies_len)5650 int wifi_nxp_set_default_scan_ies(const u8 *ies, size_t ies_len)
5651 {
5652 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
5653
5654 if (ies && ies_len < sizeof(pmpriv->default_scan_ies))
5655 {
5656 pmpriv->default_scan_ies_len = ies_len;
5657 memcpy(pmpriv->default_scan_ies, ies, ies_len);
5658 }
5659
5660 return WM_SUCCESS;
5661 }
5662
5663 #define HEADER_SIZE 8
5664 // frmctl + durationid + addr1 + addr2 + addr3 + seqctl + addr4
5665 #define MGMT_HEADER_LEN (2 + 2 + 6 + 6 + 6 + 2 + 6)
5666 // 6 = auth_alg + auth_transaction +auth_status
5667 #define AUTH_BODY_LEN 6
5668
wlan_send_mgmt_auth_request(mlan_private * pmpriv,const t_u8 channel,const t_u8 auth_alg,const t_u8 * auth_seq_num,const t_u8 * status_code,const t_u8 * dest,const t_u8 * sae_data,const t_u16 sae_data_len)5669 static int wlan_send_mgmt_auth_request(mlan_private *pmpriv,
5670 const t_u8 channel,
5671 const t_u8 auth_alg,
5672 const t_u8 *auth_seq_num,
5673 const t_u8 *status_code,
5674 const t_u8 *dest,
5675 const t_u8 *sae_data,
5676 const t_u16 sae_data_len)
5677 {
5678 mlan_adapter *pmadapter = pmpriv->adapter;
5679 t_u16 pkt_len = 0;
5680 mlan_802_11_mac_addr *da = MNULL;
5681 mlan_802_11_mac_addr *sa = MNULL;
5682 wlan_mgmt_pkt *pmgmt_pkt_hdr = MNULL;
5683 t_u8 *pos = MNULL;
5684 int meas_pkt_len = 0;
5685 t_s32 i = -1;
5686 BSSDescriptor_t *pbss_desc = MNULL;
5687 WLAN_802_11_RATES rates = {0x00};
5688 t_u32 rates_size;
5689 t_u8 addr[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
5690 t_u8 baserates[] = {0x82, 0x84, 0x8b, 0x96, 0x8c, 0x98, 0xb0};
5691
5692 if (pmpriv->bss_index != (t_u8)MLAN_BSS_ROLE_STA)
5693 {
5694 wifi_d("invalid interface %d for sending auth request", pmpriv->bss_index);
5695 return (int)MLAN_STATUS_FAILURE;
5696 }
5697
5698 da = (mlan_802_11_mac_addr *)(void *)dest;
5699 sa = (mlan_802_11_mac_addr *)(void *)(&pmpriv->curr_addr[0]);
5700
5701 i = wlan_find_bssid_in_list(pmpriv, dest, MLAN_BSS_MODE_AUTO);
5702 if (i >= 0)
5703 {
5704 pbss_desc = &pmadapter->pscan_table[i];
5705 if (wlan_setup_rates_from_bssdesc(pmpriv, pbss_desc, rates, &rates_size) != MLAN_STATUS_SUCCESS)
5706 {
5707 wifi_d("Not support the rates");
5708 return (int)MLAN_STATUS_FAILURE;
5709 }
5710 t_u8 *prate = (t_u8 *)&(pbss_desc->supported_rates);
5711 t_u8 rateIndex = 0xff;
5712
5713 for (int j = 0; j < rates_size; j++)
5714 {
5715 if (prate[j] >= 0x82)
5716 {
5717 for (int k = 0; k < sizeof(baserates); k++)
5718 {
5719 if (prate[j] == baserates[k] && k < rateIndex)
5720 rateIndex = k;
5721 }
5722 }
5723 }
5724 pmpriv->pkt_tx_ctrl |= 1 << 15;
5725 switch (baserates[rateIndex])
5726 {
5727 case 0x82:
5728 pmpriv->pkt_tx_ctrl |= 0 << 16;
5729 break;
5730 case 0x84:
5731 pmpriv->pkt_tx_ctrl |= 1 << 16;
5732 break;
5733 case 0x8b:
5734 pmpriv->pkt_tx_ctrl |= 2 << 16;
5735 break;
5736 case 0x96:
5737 pmpriv->pkt_tx_ctrl |= 3 << 16;
5738 break;
5739 case 0x8c:
5740 pmpriv->pkt_tx_ctrl |= 5 << 16;
5741 break;
5742 case 0x98:
5743 pmpriv->pkt_tx_ctrl |= 7 << 16;
5744 break;
5745 case 0xb0:
5746 pmpriv->pkt_tx_ctrl |= 9 << 16;
5747 break;
5748 default:
5749 pmpriv->pkt_tx_ctrl = 0;
5750 wifi_d("Not support the base rates");
5751 break;
5752 }
5753 }
5754 if (pmadapter->cmd_tx_data == 1U)
5755 {
5756 (void)wifi_get_command_lock();
5757 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5758 mlan_ds_misc_tx_frame tx_frame = {0};
5759 wlan_802_11_header *pwlan_pkt_hdr = MNULL;
5760 IEEEtypes_FrameCtl_t *mgmt_fc_p = MNULL;
5761 t_u8 *pBuf = &tx_frame.tx_buf[0];
5762 t_u32 pkt_type;
5763
5764 pkt_len = MGMT_HEADER_LEN + AUTH_BODY_LEN;
5765
5766 memset(cmd, 0x00, pkt_len);
5767
5768 pkt_type = MRVL_PKT_TYPE_MGMT_FRAME;
5769
5770 /* Add pkt_type and tx_control */
5771 memcpy(pBuf, &pkt_type, sizeof(pkt_type));
5772 memcpy(pBuf + sizeof(pkt_type), &(pmpriv->pkt_tx_ctrl), sizeof(pmpriv->pkt_tx_ctrl));
5773
5774 pwlan_pkt_hdr = (wlan_802_11_header *)(void *)(pBuf + HEADER_SIZE + sizeof(pkt_len));
5775 /* 802.11 header */
5776 mgmt_fc_p = (IEEEtypes_FrameCtl_t *)(void *)&pwlan_pkt_hdr->frm_ctl;
5777 mgmt_fc_p->sub_type = SUBTYPE_AUTH;
5778 mgmt_fc_p->type = (t_u8)IEEE_TYPE_MANAGEMENT;
5779 (void)memcpy(pwlan_pkt_hdr->addr1, da, MLAN_MAC_ADDR_LENGTH);
5780 (void)memcpy(pwlan_pkt_hdr->addr2, sa, MLAN_MAC_ADDR_LENGTH);
5781 (void)memcpy(pwlan_pkt_hdr->addr3, da, MLAN_MAC_ADDR_LENGTH);
5782
5783 (void)memcpy(pwlan_pkt_hdr->addr4, addr, MLAN_MAC_ADDR_LENGTH);
5784
5785 /* 802.11 management body */
5786 pos = (t_u8 *)pwlan_pkt_hdr + sizeof(wlan_802_11_header);
5787 pos[0] = auth_alg;
5788 pos[1] = 0;
5789 pos[2] = auth_seq_num[0];
5790 pos[3] = auth_seq_num[1];
5791 pos[4] = status_code[0];
5792 pos[5] = status_code[1];
5793
5794 pos += 6;
5795
5796 if ((sae_data != NULL) && (sae_data_len > 0))
5797 {
5798 memcpy(pos, sae_data, sae_data_len);
5799 pos += sae_data_len;
5800 }
5801
5802 meas_pkt_len = pos - (t_u8 *)pwlan_pkt_hdr;
5803 pkt_len = (t_u16)meas_pkt_len;
5804
5805 /*Add packet len*/
5806 pkt_len = wlan_cpu_to_le16(pkt_len);
5807 memcpy(pBuf + HEADER_SIZE, &pkt_len, sizeof(pkt_len));
5808
5809 tx_frame.bandcfg.chanBand = channel > 14 ? BAND_5GHZ : BAND_2GHZ;
5810 tx_frame.channel = channel;
5811 tx_frame.data_len = HEADER_SIZE + pkt_len + 2 * sizeof(pkt_len);
5812 tx_frame.buf_type = MLAN_BUF_TYPE_RAW_DATA;
5813 tx_frame.priority = 7;
5814
5815 cmd->seq_num = 0x0;
5816 cmd->result = 0x0;
5817
5818 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_TX_FRAME,
5819 HostCmd_ACT_GEN_SET, 0, NULL, &tx_frame, cmd);
5820 if (rv != MLAN_STATUS_SUCCESS)
5821 {
5822 return -WM_FAIL;
5823 }
5824
5825 (void)wifi_wait_for_cmdresp(NULL);
5826 return wm_wifi.cmd_resp_status;
5827 }
5828 else
5829 {
5830 pmgmt_pkt_hdr = wifi_PrepDefaultMgtMsg(SUBTYPE_AUTH, da, sa, da, sizeof(wlan_mgmt_pkt) + AUTH_REQUEST_BUF_SIZE);
5831 if (pmgmt_pkt_hdr == MNULL)
5832 {
5833 wifi_e("No memory for auth request");
5834 return (int)MLAN_STATUS_FAILURE;
5835 }
5836
5837 (void)memcpy(pmgmt_pkt_hdr->wlan_header.addr4, addr, MLAN_MAC_ADDR_LENGTH);
5838
5839 /* 802.11 management body */
5840 pos = (t_u8 *)pmgmt_pkt_hdr + sizeof(wlan_mgmt_pkt);
5841 pos[0] = auth_alg;
5842 pos[1] = 0;
5843 pos[2] = auth_seq_num[0];
5844 pos[3] = auth_seq_num[1];
5845 pos[4] = status_code[0];
5846 pos[5] = status_code[1];
5847
5848 pos += 6;
5849
5850 if ((sae_data != NULL) && (sae_data_len > 0))
5851 {
5852 memcpy(pos, sae_data, sae_data_len);
5853 pos += sae_data_len;
5854 }
5855
5856 meas_pkt_len = pos - (t_u8 *)pmgmt_pkt_hdr;
5857 pkt_len = (t_u16)meas_pkt_len;
5858 pmgmt_pkt_hdr->frm_len = pkt_len - (t_u16)sizeof(pmgmt_pkt_hdr->frm_len);
5859
5860 (void)wifi_inject_frame(WLAN_BSS_TYPE_STA, (t_u8 *)pmgmt_pkt_hdr, pkt_len);
5861
5862 #if !CONFIG_MEM_POOLS
5863 OSA_MemoryFree(pmgmt_pkt_hdr);
5864 #else
5865 OSA_MemoryPoolFree(buf_1536_MemoryPool, pmgmt_pkt_hdr);
5866 #endif
5867 }
5868
5869 pmpriv->pkt_tx_ctrl = 0;
5870 return (int)MLAN_STATUS_SUCCESS;
5871 }
5872
wifi_send_mgmt_auth_request(const t_u8 channel,const t_u8 auth_alg,const t_u8 * auth_seq_num,const t_u8 * status_code,const t_u8 * dest,const t_u8 * sae_data,const t_u16 sae_data_len)5873 int wifi_send_mgmt_auth_request(const t_u8 channel,
5874 const t_u8 auth_alg,
5875 const t_u8 *auth_seq_num,
5876 const t_u8 *status_code,
5877 const t_u8 *dest,
5878 const t_u8 *sae_data,
5879 const t_u16 sae_data_len)
5880 {
5881 mlan_private *pmpriv = (mlan_private *)mlan_adap->priv[0];
5882 int ret;
5883
5884 if ((pmpriv->auth_alg != WLAN_AUTH_SAE) && (pmpriv->auth_flag & HOST_MLME_AUTH_PENDING))
5885 {
5886 wifi_d("pending auth on going");
5887 return -WM_FAIL;
5888 }
5889
5890 #if CONFIG_11R
5891 if (auth_alg == MLAN_AUTH_MODE_FT)
5892 {
5893 pmpriv->ft_roam = MTRUE;
5894 }
5895 #endif
5896
5897 if (pmpriv->auth_flag == 0)
5898 {
5899 wifi_set_rx_mgmt_indication(MLAN_BSS_TYPE_STA, WIFI_MGMT_AUTH | WIFI_MGMT_DEAUTH | WIFI_MGMT_DIASSOC);
5900
5901 wifi_remain_on_channel(true, channel, 2400);
5902 }
5903
5904 pmpriv->curr_bss_params.host_mlme = 1;
5905 pmpriv->auth_flag = HOST_MLME_AUTH_PENDING;
5906 pmpriv->auth_alg = wlan_cpu_to_le16(auth_alg);
5907
5908 ret =
5909 wlan_send_mgmt_auth_request(pmpriv, channel, auth_alg, auth_seq_num, status_code, dest, sae_data, sae_data_len);
5910
5911 if (ret != WM_SUCCESS)
5912 {
5913 wifi_set_rx_mgmt_indication(MLAN_BSS_TYPE_STA, 0);
5914 wifi_remain_on_channel(false, 0, 0);
5915
5916 pmpriv->curr_bss_params.host_mlme = 0;
5917 pmpriv->auth_flag = 0;
5918 pmpriv->auth_alg = 0xFFFF;
5919 #if CONFIG_11R
5920 pmpriv->ft_roam = MFALSE;
5921 #endif
5922 }
5923 return ret;
5924 }
5925 #endif
5926
5927 #if CONFIG_WMM_UAPSD
wifi_set_wmm_qos_cfg(t_u8 qos_cfg)5928 int wifi_set_wmm_qos_cfg(t_u8 qos_cfg)
5929 {
5930 mlan_status ret = MLAN_STATUS_SUCCESS;
5931 mlan_ioctl_req req;
5932 mlan_ds_wmm_cfg cfg;
5933
5934 (void)memset(&req, 0x00, sizeof(mlan_ioctl_req));
5935 (void)memset(&cfg, 0x00, sizeof(mlan_ds_wmm_cfg));
5936 cfg.sub_command = MLAN_OID_WMM_CFG_QOS;
5937 cfg.param.qos_cfg = qos_cfg;
5938 req.pbuf = (t_u8 *)&cfg;
5939 req.buf_len = sizeof(mlan_ds_wmm_cfg);
5940 req.req_id = MLAN_IOCTL_WMM_CFG;
5941 req.action = MLAN_ACT_SET;
5942
5943 ret = wlan_ops_sta_ioctl(mlan_adap, &req);
5944 return ret;
5945 }
5946
wifi_set_sleep_period(uint16_t sleep_period)5947 void wifi_set_sleep_period(uint16_t sleep_period)
5948 {
5949 wifi_get_command_lock();
5950 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5951 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
5952 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, MLAN_BSS_TYPE_STA);
5953 cmd->result = 0x0;
5954 wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_SLEEP_PERIOD, HostCmd_ACT_GEN_SET,
5955 0, NULL, &sleep_period, cmd);
5956 wifi_wait_for_cmdresp(NULL);
5957 }
5958 #endif
5959
5960 #if CONFIG_11AX
5961 #if CONFIG_MMSF
wifi_mmsf_cfg(const t_u16 action,t_u8 * enable,t_u8 * Density,t_u8 * MMSF)5962 int wifi_mmsf_cfg(const t_u16 action, t_u8 *enable, t_u8 *Density, t_u8 *MMSF)
5963 {
5964 wifi_get_command_lock();
5965 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
5966 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
5967
5968 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_DBGS_CFG);
5969 cmd->size = S_DS_GEN;
5970
5971 HostCmd_DS_MMSF_CFG *MMSF_CFG = (HostCmd_DS_MMSF_CFG *)&cmd->params.mmsf_cfg;
5972 MMSF_CFG->action = wlan_cpu_to_le16(action);
5973 MMSF_CFG->sub_id = wlan_cpu_to_le16(MLAN_11AX_DEBUG_MMSF_SUBID);
5974
5975 (void)memcpy(&MMSF_CFG->enableMMSF, enable, sizeof(MMSF_CFG->enableMMSF));
5976 (void)memcpy(&MMSF_CFG->ampduDensity, Density, sizeof(MMSF_CFG->ampduDensity));
5977 (void)memcpy(&MMSF_CFG->ampduMMSF, MMSF, sizeof(MMSF_CFG->ampduMMSF));
5978
5979 cmd->size += sizeof(HostCmd_DS_MMSF_CFG);
5980 cmd->size = wlan_cpu_to_le16(cmd->size);
5981
5982 if (action == ACTION_SET)
5983 {
5984 return wifi_wait_for_cmdresp(NULL);
5985 }
5986 else
5987 {
5988 wifi_mmsf_cfg_t mmsf_cfg_resp;
5989 mmsf_cfg_resp.enable = enable;
5990 mmsf_cfg_resp.Density = Density;
5991 mmsf_cfg_resp.MMSF = MMSF;
5992 return wifi_wait_for_cmdresp(&mmsf_cfg_resp);
5993 }
5994 }
5995 #endif
5996 #endif
5997
5998 #if CONFIG_WIFI_RECOVERY
wifi_recovery_test(void)5999 int wifi_recovery_test(void)
6000 {
6001 wifi_get_command_lock();
6002 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6003 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6004
6005 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_DBGS_CFG);
6006 cmd->size = S_DS_GEN;
6007 //HostCmd_DS_TMRC_CFG tmrc_cfg;
6008
6009 HostCmd_DS_TMRC_CFG *tmrc_cfg = (HostCmd_DS_TMRC_CFG *)&cmd->params.tmrc_cfg;
6010 tmrc_cfg->action = wlan_cpu_to_le16(HostCmd_ACT_GEN_GET);
6011 tmrc_cfg->sub_id = wlan_cpu_to_le16(MLAN_RECOVERY_TEST_SUBID);
6012
6013 cmd->size += sizeof(HostCmd_DS_TMRC_CFG);
6014 cmd->size = wlan_cpu_to_le16(cmd->size);
6015
6016 return wifi_wait_for_cmdresp(NULL);
6017 }
6018 #endif
6019
6020 #if CONFIG_TX_AMPDU_PROT_MODE
wifi_tx_ampdu_prot_mode(tx_ampdu_prot_mode_para * prot_mode,t_u16 action)6021 int wifi_tx_ampdu_prot_mode(tx_ampdu_prot_mode_para *prot_mode, t_u16 action)
6022 {
6023 wifi_get_command_lock();
6024 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6025
6026 cmd->seq_num = 0x00;
6027 cmd->result = 0x0;
6028
6029 wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_TX_AMPDU_PROT_MODE, action, 0, NULL,
6030 prot_mode, cmd);
6031
6032 return wifi_wait_for_cmdresp(action == HostCmd_ACT_GEN_GET ? prot_mode : NULL);
6033 }
6034 #endif
6035
6036 #if CONFIG_CSI
wifi_csi_cfg(wifi_csi_config_params_t * csi_params)6037 int wifi_csi_cfg(wifi_csi_config_params_t *csi_params)
6038 {
6039 t_u16 action = CSI_CMD_DISABLE;
6040
6041 action = csi_params->csi_enable;
6042 if (action != CSI_CMD_ENABLE && action != CSI_CMD_DISABLE)
6043 return -WM_FAIL;
6044
6045 wifi_get_command_lock();
6046 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6047
6048 if (csi_params->bss_type == BSS_TYPE_UAP)
6049 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, BSS_TYPE_UAP);
6050 else
6051 cmd->seq_num = 0x0;
6052 cmd->result = 0x0;
6053
6054 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_CSI,
6055 csi_params->csi_enable, 0, NULL, csi_params, cmd);
6056 if (rv != MLAN_STATUS_SUCCESS)
6057 {
6058 wifi_put_command_lock();
6059 return -WM_FAIL;
6060 }
6061
6062 return wifi_wait_for_cmdresp(NULL);
6063 }
6064 #endif
6065
6066 #if (CONFIG_IPS)
6067 /* enable/disable config for IPS */
wifi_set_ips_config(mlan_bss_type interface,int option)6068 int wifi_set_ips_config(mlan_bss_type interface, int option)
6069 {
6070 wifi_get_command_lock();
6071 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6072 t_u16 cmd_size;
6073
6074 if ((option != 0) && (option != 1))
6075 return -WM_FAIL;
6076
6077 cmd_size = sizeof(HostCmd_DS_IPS_CONFIG) + S_DS_GEN /* cmd header */;
6078 (void)memset(cmd, 0x00, cmd_size);
6079 cmd->command = HostCmd_CMD_IPS_CONFIG;
6080 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, interface);
6081 cmd->size = cmd_size;
6082
6083 cmd->params.ips_config.enable = option;
6084
6085 return wifi_wait_for_cmdresp(NULL);
6086 }
6087 #endif
6088
6089 #if CONFIG_NET_MONITOR
wifi_net_monitor_cfg(wifi_net_monitor_t * monitor)6090 int wifi_net_monitor_cfg(wifi_net_monitor_t *monitor)
6091 {
6092 t_u16 action = HostCmd_ACT_GEN_SET;
6093
6094 action = monitor->action;
6095
6096 if (action != HostCmd_ACT_GEN_GET && action != HostCmd_ACT_GEN_SET)
6097 return -WM_FAIL;
6098
6099 wifi_get_command_lock();
6100 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6101
6102 cmd->seq_num = 0x0;
6103 cmd->result = 0x0;
6104
6105 mlan_status rv = wlan_ops_sta_prepare_cmd((mlan_private *)mlan_adap->priv[0], HostCmd_CMD_802_11_NET_MONITOR,
6106 monitor->action, 0, NULL, monitor, cmd);
6107 if (rv != MLAN_STATUS_SUCCESS)
6108 return -WM_FAIL;
6109
6110 return wifi_wait_for_cmdresp(NULL);
6111 }
6112 #endif
6113
6114 #if CONFIG_TSP
wifi_tsp_cfg(const t_u16 action,t_u16 * enable,t_u32 * back_off,t_u32 * highThreshold,t_u32 * lowThreshold,t_u32 * dutycycstep,t_u32 * dutycycmin,int * highthrtemp,int * lowthrtemp,int * currCAUTemp,int * currRFUTemp)6115 int wifi_tsp_cfg(const t_u16 action,
6116 t_u16 *enable,
6117 t_u32 *back_off,
6118 t_u32 *highThreshold,
6119 t_u32 *lowThreshold,
6120 t_u32 *dutycycstep,
6121 t_u32 *dutycycmin,
6122 int *highthrtemp,
6123 int *lowthrtemp,
6124 int *currCAUTemp,
6125 int *currRFUTemp)
6126 {
6127 wifi_get_command_lock();
6128 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6129 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6130 HostCmd_DS_TSP_CFG *tsp_cfg = &cmd->params.tsp_cfg;
6131
6132 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_TSP_CFG);
6133 cmd->size = sizeof(HostCmd_DS_TSP_CFG) + S_DS_GEN;
6134
6135 (void)memcpy(&tsp_cfg->thermalPowerMgmtenable, enable, sizeof(t_u16));
6136 (void)memcpy(&tsp_cfg->powerMgmtBackoff, back_off, sizeof(t_u32));
6137 (void)memcpy(&tsp_cfg->highPwrBOThrshld, highThreshold, sizeof(t_u32));
6138 (void)memcpy(&tsp_cfg->lowPwrBOThrshld, lowThreshold, sizeof(t_u32));
6139 (void)memcpy(&tsp_cfg->dutycycstep, dutycycstep, sizeof(t_u32));
6140 (void)memcpy(&tsp_cfg->dutycycmin, dutycycmin, sizeof(t_u32));
6141 (void)memcpy(&tsp_cfg->highthrtemp, highthrtemp, sizeof(t_s32));
6142 (void)memcpy(&tsp_cfg->lowthrtemp, lowthrtemp, sizeof(t_s32));
6143
6144 tsp_cfg->action = wlan_cpu_to_le16(action);
6145 tsp_cfg->thermalPowerMgmtenable = wlan_cpu_to_le16(tsp_cfg->thermalPowerMgmtenable);
6146 tsp_cfg->powerMgmtBackoff = wlan_cpu_to_le16(tsp_cfg->powerMgmtBackoff);
6147 tsp_cfg->highPwrBOThrshld = wlan_cpu_to_le16(tsp_cfg->highPwrBOThrshld);
6148 tsp_cfg->lowPwrBOThrshld = wlan_cpu_to_le16(tsp_cfg->lowPwrBOThrshld);
6149 tsp_cfg->dutycycstep = wlan_cpu_to_le16(tsp_cfg->dutycycstep);
6150 tsp_cfg->dutycycmin = wlan_cpu_to_le16(tsp_cfg->dutycycmin);
6151 tsp_cfg->highthrtemp = wlan_cpu_to_le16(tsp_cfg->highthrtemp);
6152 tsp_cfg->lowthrtemp = wlan_cpu_to_le16(tsp_cfg->lowthrtemp);
6153
6154 cmd->size = wlan_cpu_to_le16(cmd->size);
6155
6156 if (action == MLAN_ACT_SET)
6157 return wifi_wait_for_cmdresp(NULL);
6158 else
6159 {
6160 TSP_CFG tsp_get_cfg;
6161 tsp_get_cfg.thermalPowerMgmtenable = enable;
6162 tsp_get_cfg.powerMgmtBackoff = back_off;
6163 tsp_get_cfg.highPwrBOThrshld = highThreshold;
6164 tsp_get_cfg.lowPwrBOThrshld = lowThreshold;
6165 tsp_get_cfg.dutycycstep = dutycycstep;
6166 tsp_get_cfg.dutycycmin = dutycycmin;
6167 tsp_get_cfg.highthrtemp = highthrtemp;
6168 tsp_get_cfg.lowthrtemp = lowthrtemp;
6169 tsp_get_cfg.currCAUTemp = currCAUTemp;
6170 tsp_get_cfg.currRFUTemp = currRFUTemp;
6171
6172 return wifi_wait_for_cmdresp(&tsp_get_cfg);
6173 }
6174 }
6175 #endif
6176
6177 #if CONFIG_TURBO_MODE
wifi_get_turbo_mode(t_u8 * mode)6178 int wifi_get_turbo_mode(t_u8 *mode)
6179 {
6180 return wlan_get_set_turbo_mode(ACTION_GET, mode, MLAN_BSS_TYPE_STA);
6181 }
6182
wifi_get_uap_turbo_mode(t_u8 * mode)6183 int wifi_get_uap_turbo_mode(t_u8 *mode)
6184 {
6185 return wlan_get_set_turbo_mode(ACTION_GET, mode, MLAN_BSS_TYPE_UAP);
6186 }
6187
wifi_set_turbo_mode(t_u8 mode)6188 int wifi_set_turbo_mode(t_u8 mode)
6189 {
6190 return wlan_get_set_turbo_mode(ACTION_SET, &mode, MLAN_BSS_TYPE_STA);
6191 }
6192
wifi_set_uap_turbo_mode(t_u8 mode)6193 int wifi_set_uap_turbo_mode(t_u8 mode)
6194 {
6195 return wlan_get_set_turbo_mode(ACTION_SET, &mode, MLAN_BSS_TYPE_UAP);
6196 }
6197
wlan_get_set_turbo_mode(t_u16 action,t_u8 * mode,mlan_bss_type bss_type)6198 int wlan_get_set_turbo_mode(t_u16 action, t_u8 *mode, mlan_bss_type bss_type)
6199 {
6200 wifi_get_command_lock();
6201 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6202 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6203
6204 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_802_11_SNMP_MIB);
6205 cmd->size = S_DS_GEN;
6206 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
6207
6208 uint8_t *tlv = (uint8_t *)((uint8_t *)cmd + S_DS_GEN);
6209
6210 turbo_mode_para *turbo_ptr = (turbo_mode_para *)tlv;
6211 turbo_ptr->action = action;
6212 turbo_ptr->oid = OID_WMM_TURBO_MODE;
6213 turbo_ptr->size = 0x1;
6214 if (action == ACTION_SET)
6215 (void)memcpy(&turbo_ptr->mode, mode, sizeof(t_u8));
6216
6217 cmd->size += sizeof(turbo_mode_para);
6218 cmd->size = wlan_cpu_to_le16(cmd->size);
6219
6220 if (action == ACTION_GET)
6221 return wifi_wait_for_cmdresp(mode);
6222 else
6223 return wifi_wait_for_cmdresp(NULL);
6224 }
6225 #endif
6226
6227 #if (CONFIG_11MC) || (CONFIG_11AZ)
wifi_ftm_start_stop(const t_u16 action,const t_u8 loop_cnt,const t_u8 * mac,const t_u8 channel)6228 int wifi_ftm_start_stop(const t_u16 action, const t_u8 loop_cnt, const t_u8 *mac, const t_u8 channel)
6229 {
6230 if (action == FTM_ACTION_START)
6231 {
6232 ftm_param.channel = channel;
6233 (void)memcpy(ftm_param.peer_mac, mac, MLAN_MAC_ADDR_LENGTH);
6234 ftm_param.loop_cnt = loop_cnt;
6235 ftm_param.status = (ftm_param.loop_cnt == 0) ? 1 : 0;
6236 return wifi_ftm_start(FTM_ACTION_START, mac, channel);
6237 }
6238 else
6239 {
6240 ftm_param.loop_cnt = 0;
6241 ftm_param.status = 0;
6242 return wifi_ftm_stop(FTM_ACTION_STOP, ftm_param.peer_mac, ftm_param.channel);
6243 }
6244 }
6245
wifi_ftm_start(const t_u16 action,const t_u8 * mac,const t_u8 channel)6246 int wifi_ftm_start(const t_u16 action, const t_u8 *mac, const t_u8 channel)
6247 {
6248 if (!is_sta_connected())
6249 {
6250 PRINTF("Cannot Start FTM, STA not associated !\r\n");
6251 return -WM_FAIL;
6252 }
6253 wifi_get_command_lock();
6254 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6255
6256 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_FTM_SESSION_CTRL);
6257 cmd->size = S_DS_GEN + sizeof(HostCmd_FTM_SESSION_CTRL);
6258 cmd->size = wlan_cpu_to_le16(cmd->size);
6259 cmd->params.ftm_session_ctrl.action = wlan_cpu_to_le16(action);
6260 cmd->params.ftm_session_ctrl.for_ranging = wlan_cpu_to_le16(FOR_RANGING);
6261 (void)memcpy(cmd->params.ftm_session_ctrl.peer_mac, mac, MLAN_MAC_ADDR_LENGTH);
6262 cmd->params.ftm_session_ctrl.chan = wlan_cpu_to_le16(channel);
6263
6264 dump_hex(cmd, cmd->size);
6265 return wifi_wait_for_cmdresp(NULL);
6266 }
6267
wifi_ftm_stop(const t_u16 action,const t_u8 * mac,const t_u8 channel)6268 int wifi_ftm_stop(const t_u16 action, const t_u8 *mac, const t_u8 channel)
6269 {
6270 wifi_get_command_lock();
6271 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6272
6273 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_FTM_SESSION_CTRL);
6274 cmd->size = S_DS_GEN + sizeof(HostCmd_FTM_SESSION_CTRL);
6275 cmd->size = wlan_cpu_to_le16(cmd->size);
6276 cmd->params.ftm_session_ctrl.action = wlan_cpu_to_le16(action);
6277 cmd->params.ftm_session_ctrl.for_ranging = wlan_cpu_to_le16(FOR_RANGING);
6278 (void)memcpy(cmd->params.ftm_session_ctrl.peer_mac, mac, MLAN_MAC_ADDR_LENGTH);
6279 cmd->params.ftm_session_ctrl.chan = wlan_cpu_to_le16(channel);
6280
6281 return wifi_wait_for_cmdresp(NULL);
6282 }
6283
wifi_ftm_11mc_cfg(ftm_11mc_nego_cfg_t * ftm_11mc_nego_cfg)6284 int wifi_ftm_11mc_cfg(ftm_11mc_nego_cfg_t *ftm_11mc_nego_cfg)
6285 {
6286 wifi_get_command_lock();
6287 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6288
6289 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_FTM_SESSION_CFG);
6290 cmd->size = wlan_cpu_to_le16(S_DS_GEN);
6291 cmd->params.ftm_session_cfg.action = MLAN_ACT_SET;
6292
6293 wlan_dot11mc_ftm_cfg(cmd, ftm_11mc_nego_cfg);
6294
6295 return wifi_wait_for_cmdresp(NULL);
6296 }
6297
wifi_ftm_location_cfg(location_cfg_info_t * ftm_location_cfg)6298 int wifi_ftm_location_cfg(location_cfg_info_t *ftm_location_cfg)
6299 {
6300 wlan_location_ftm_cfg(ftm_location_cfg);
6301 }
6302
wifi_ftm_civic_cfg(location_civic_rep_t * ftm_civic_cfg)6303 int wifi_ftm_civic_cfg(location_civic_rep_t *ftm_civic_cfg)
6304 {
6305 wlan_civic_ftm_cfg(ftm_civic_cfg);
6306 }
6307
wifi_ftm_cfg(const t_u8 protocol,ranging_11az_cfg_t * ftm_ranging_cfg)6308 int wifi_ftm_cfg(const t_u8 protocol, ranging_11az_cfg_t *ftm_ranging_cfg)
6309 {
6310 wifi_get_command_lock();
6311 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6312
6313 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_FTM_SESSION_CFG);
6314 cmd->size = wlan_cpu_to_le16(S_DS_GEN);
6315 cmd->params.ftm_session_cfg.action = MLAN_ACT_SET;
6316
6317 HostCmd_FTM_SESSION_CFG ftm_session_cfg;
6318 dot11az_ftm_cfg_t *cfg_11az = (dot11az_ftm_cfg_t *)&ftm_session_cfg.tlv.cfg_11az;
6319 cfg_11az->range_tlv.val.format_bw = ftm_ranging_cfg->format_bw;
6320 cfg_11az->range_tlv.val.max_i2r_sts_upto80 = ftm_ranging_cfg->max_i2r_sts_upto80;
6321 cfg_11az->range_tlv.val.max_r2i_sts_upto80 = ftm_ranging_cfg->max_r2i_sts_upto80;
6322 cfg_11az->range_tlv.val.az_measurement_freq = ftm_ranging_cfg->az_measurement_freq;
6323 cfg_11az->range_tlv.val.az_number_of_measurements = ftm_ranging_cfg->az_number_of_measurements;
6324 cfg_11az->range_tlv.val.i2r_lmr_feedback = ftm_ranging_cfg->i2r_lmr_feedback;
6325 cfg_11az->range_tlv.val.civic_req = ftm_ranging_cfg->civic_req;
6326 cfg_11az->range_tlv.val.lci_req = ftm_ranging_cfg->lci_req;
6327 wlan_dto11az_ranging_cfg(cmd, protocol, &ftm_session_cfg);
6328
6329 return wifi_wait_for_cmdresp(NULL);
6330 }
6331
wifi_process_wlc_ftm_event()6332 int wifi_process_wlc_ftm_event()
6333 {
6334 int ret = -WM_FAIL;
6335 if (ftm_param.loop_cnt > 0)
6336 ftm_param.loop_cnt--;
6337 if (ftm_param.loop_cnt > 0 || (ftm_param.status))
6338 ret = wifi_ftm_start(FTM_ACTION_START, ftm_param.peer_mac, ftm_param.channel);
6339 // else
6340 // ret = wifi_ftm_stop(FTM_ACTION_STOP, ftm_param.peer_mac, ftm_param.channel);
6341
6342 return ret;
6343 }
6344
6345 #if CONFIG_WLS_CSI_PROC
6346
mlanwls_update_distance_to_gui(int distance,unsigned int tsf)6347 static int mlanwls_update_distance_to_gui(int distance, unsigned int tsf)
6348 {
6349 int distance_m, distance_cm;
6350 unsigned int time_ms = tsf / 1000;
6351 float distance_flt = 1.0f * distance / (1 << 8); // in meters
6352 float distance_kalman;
6353
6354 if (range_input_str.time == 0)
6355 {
6356 range_kalman_init(&range_input_str, distance_flt, time_ms, RANGE_DRIVE_VAR, RANGE_MEASUREMENT_VAR,
6357 RANGE_RATE_INIT);
6358 range_input_str.time = 1;
6359 }
6360 else
6361 {
6362 range_input_str.range_measurement = distance_flt;
6363 range_input_str.time = time_ms;
6364 range_kalman(&range_input_str);
6365 }
6366 distance_kalman = range_input_str.last_range;
6367
6368 distance_cm = (int)(distance_kalman * 100);
6369 distance_m = distance_cm / 100;
6370 distance_cm -= distance_m * 100;
6371
6372 wifi_d("Measured Distance: %f m; Kalman Distance: %f m [%d ms]\r\n", (double)distance_flt, (double)distance_kalman,
6373 time_ms);
6374
6375 return 0;
6376 }
6377
send_csi_ack(unsigned int * resArray)6378 static int send_csi_ack(unsigned int *resArray)
6379 {
6380 int ret;
6381 wifi_get_command_lock();
6382 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6383 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6384 HostCmd_WLS_CSI_ACK *phostcmd = (HostCmd_WLS_CSI_ACK *)&cmd->params.wls_csi_ack;
6385
6386 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_DBGS_CFG);
6387 cmd->size = S_DS_GEN + sizeof(HostCmd_WLS_CSI_ACK) + 8;
6388 phostcmd->action = 0;
6389 phostcmd->sub_id = 0x333;
6390 phostcmd->ack = 1;
6391
6392 phostcmd->phase_roll = resArray[0];
6393 phostcmd->firstpath_delay = resArray[1];
6394 phostcmd->fft_size_pointer = resArray[2];
6395 phostcmd->csi_tsf = resArray[3];
6396
6397 cmd->size += CSI_TSF_LEN;
6398 cmd->size = wlan_cpu_to_le16(cmd->size);
6399
6400 ret = wifi_wait_for_cmdresp(NULL);
6401
6402 return ret;
6403 }
6404
proc_csi_event(void * event,unsigned int * resArray)6405 static void proc_csi_event(void *event, unsigned int *resArray)
6406 {
6407 uint8_t *csiBuffer = (uint8_t *)(event);
6408 hal_wls_packet_params_t packetparams;
6409 hal_wls_processing_input_params_t inputVals;
6410 unsigned int tsf = ((unsigned int *)csiBuffer)[3];
6411 int distance = ((unsigned int *)csiBuffer)[19];
6412
6413 if (distance >= 0)
6414 mlanwls_update_distance_to_gui(distance, tsf);
6415
6416 inputVals.enableCsi = 1; // turn on CSI processing
6417 inputVals.enableAoA = AOA_DEFAULT; // turn on AoA (req. enableCsi==1)
6418 inputVals.nTx = 3; // limit # tx streams to process
6419 inputVals.nRx = 3; // limit # rx to process
6420 inputVals.selCal = 0; // choose cal values
6421 inputVals.dumpMul = 0; // dump extra peaks in AoA
6422 inputVals.enableAntCycling = 0; // enable antenna cycling
6423 inputVals.dumpRawAngle = 0; // Dump Raw Angle
6424 inputVals.useToaMin = TOA_MIN_DEFAULT; // 1: use min combining, 0: power combining;
6425 inputVals.useSubspace = SUBSPACE_DEFAULT; // 1: use subspace algo; 0: no;
6426 inputVals.useFindAngleDelayPeaks = ENABLE_DELAY_PEAKS; // use this algorithm for AoA
6427
6428 resArray[0] = 0xffffffff;
6429 resArray[1] = 0xffffffff;
6430 resArray[2] = 0xffffffff;
6431 resArray[3] = 0xffffffff;
6432
6433 wls_process_csi((unsigned int *)csiBuffer, (unsigned int *)fftInBuffer_t, &packetparams, &inputVals, resArray);
6434 // record TSF
6435 resArray[3] = tsf;
6436
6437 wifi_d("EVENT: MLAN_CSI Processing results: %d | %d (%x), TSF[%x]\r\n", resArray[0], resArray[1], resArray[2], tsf);
6438
6439 return;
6440 }
6441
wifi_process_wls_csi_event(void * p_data)6442 int wifi_process_wls_csi_event(void *p_data)
6443 {
6444 int ret;
6445
6446 proc_csi_event(((t_u8 *)p_data + sizeof(csi_event_t)), csi_res_array);
6447 // wifi_put_wls_csi_sem(); // After processing CSI raw data, release csi sem for next CSI event.
6448 ret = send_csi_ack(csi_res_array);
6449 return ret;
6450 }
6451
6452 #endif
6453
6454 #endif
6455
6456 #if CONFIG_COEX_DUTY_CYCLE
wifi_single_ant_duty_cycle(t_u16 enable,t_u16 nbTime,t_u16 wlanTime)6457 int wifi_single_ant_duty_cycle(t_u16 enable, t_u16 nbTime, t_u16 wlanTime)
6458 {
6459 wifi_get_command_lock();
6460 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6461 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6462
6463 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_ROBUST_COEX);
6464 cmd->size = sizeof(HostCmd_SIGNLE_ANT_DUTY_CYCLE) + S_DS_GEN;
6465 cmd->seq_num = 0x0;
6466 cmd->result = 0x00;
6467 cmd->params.single_ant_duty_cycle.action = HostCmd_ACT_GEN_SET;
6468 cmd->params.single_ant_duty_cycle.reserved = 0;
6469 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.header.type = TLV_TYPE_COEX_DUTY_CYCLE;
6470
6471 if (enable)
6472 {
6473 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.header.len =
6474 sizeof(MrvlIETypes_SingleAntDutyCycle_Config_t) - 4;
6475 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.enabled = 0x0002;
6476 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.nbTime = nbTime;
6477 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.wlanTime = wlanTime;
6478 }
6479 else
6480 {
6481 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.header.len = sizeof(t_u16);
6482 cmd->params.single_ant_duty_cycle.single_ant_cfg_data.enabled = 0x0004;
6483 }
6484
6485 wifi_wait_for_cmdresp(NULL);
6486
6487 return wm_wifi.cmd_resp_status;
6488 }
6489
wifi_dual_ant_duty_cycle(t_u16 enable,t_u16 nbTime,t_u16 wlanTime,t_u16 wlanBlockTime)6490 int wifi_dual_ant_duty_cycle(t_u16 enable, t_u16 nbTime, t_u16 wlanTime, t_u16 wlanBlockTime)
6491 {
6492 wifi_get_command_lock();
6493 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6494 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6495
6496 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_ROBUST_COEX);
6497 cmd->size = sizeof(HostCmd_DUAL_ANT_DUTY_CYCLE) + S_DS_GEN;
6498 cmd->seq_num = 0x0;
6499 cmd->result = 0x00;
6500 cmd->params.dual_ant_duty_cycle.action = HostCmd_ACT_GEN_SET;
6501 cmd->params.dual_ant_duty_cycle.reserved = 0;
6502 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.header.type = TLV_TYPE_COEX_DUTY_CYCLE;
6503
6504 if (enable)
6505 {
6506 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.header.len =
6507 sizeof(MrvlIETypes_DualAntDutyCycle_Config_t) - 4;
6508 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.enabled = 0x0002;
6509 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.nbTime = nbTime;
6510 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.wlanTime = wlanTime;
6511 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.wlanBlockTime = wlanBlockTime;
6512 }
6513 else
6514 {
6515 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.header.len = sizeof(t_u16);
6516 cmd->params.dual_ant_duty_cycle.dual_ant_cfg_data.enabled = 0x0004;
6517 }
6518
6519 wifi_wait_for_cmdresp(NULL);
6520
6521 return wm_wifi.cmd_resp_status;
6522 }
6523 #endif
6524
6525 #if CONFIG_EXTERNAL_COEX_PTA
6526
wifi_external_coex_pta_cfg(ext_coex_pta_cfg coex_pta_config)6527 int wifi_external_coex_pta_cfg(ext_coex_pta_cfg coex_pta_config)
6528 {
6529 wifi_get_command_lock();
6530 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6531 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6532
6533 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_ROBUST_COEX);
6534 cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_EXTERNAL_COEX_PTA) + S_DS_GEN);
6535 cmd->seq_num = 0x0;
6536 cmd->result = 0x00;
6537
6538 HostCmd_EXTERNAL_COEX_PTA *external_coex_pta = (HostCmd_EXTERNAL_COEX_PTA *)&cmd->params.external_coex_pta;
6539 external_coex_pta->action = wlan_cpu_to_le16(ACTION_SET);
6540 external_coex_pta->reserved = 0x00;
6541
6542 MrvlIETypes_ExternalCoexPta_Config_t *coex_pta_cfg_data =
6543 (MrvlIETypes_ExternalCoexPta_Config_t *)&external_coex_pta->coex_pta_cfg_data;
6544
6545 coex_pta_cfg_data->param.tlv_type = wlan_cpu_to_le16(TLV_TYPE_ROBUST_COEX);
6546 coex_pta_cfg_data->param.tlv_length =
6547 wlan_cpu_to_le16(sizeof(MrvlIETypes_ExternalCoexPta_Config_t) - sizeof(MrvlIETypes_Coex_params_t));
6548
6549 coex_pta_cfg_data->enabled = wlan_cpu_to_le16(coex_pta_config.enabled);
6550 coex_pta_cfg_data->ext_WifiBtArb = wlan_cpu_to_le16(coex_pta_config.ext_WifiBtArb);
6551 coex_pta_cfg_data->polGrantPin = wlan_cpu_to_le16(coex_pta_config.polGrantPin);
6552 coex_pta_cfg_data->enable_PriPtaInt = wlan_cpu_to_le16(coex_pta_config.enable_PriPtaInt);
6553 coex_pta_cfg_data->enable_StatusFromPta = wlan_cpu_to_le16(coex_pta_config.enable_StatusFromPta);
6554 coex_pta_cfg_data->setPriSampTiming = wlan_cpu_to_le16(coex_pta_config.setPriSampTiming);
6555 coex_pta_cfg_data->setStateInfoSampTiming = wlan_cpu_to_le16(coex_pta_config.setStateInfoSampTiming);
6556 coex_pta_cfg_data->extRadioTrafficPrio = wlan_cpu_to_le16(coex_pta_config.extRadioTrafficPrio);
6557 coex_pta_cfg_data->extCoexHwIntWci2 = wlan_cpu_to_le16(coex_pta_config.extCoexHwIntWci2);
6558
6559 wifi_wait_for_cmdresp(NULL);
6560
6561 return wm_wifi.cmd_resp_status;
6562 }
6563 #endif
6564
6565 #if CONFIG_IMD3_CFG
wifi_imd3_cfg(t_u8 imd3_value)6566 int wifi_imd3_cfg(t_u8 imd3_value)
6567 {
6568 wifi_get_command_lock();
6569 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6570 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6571
6572 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_ROBUST_COEX);
6573 cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_IMD3_CFG) + S_DS_GEN);
6574 cmd->seq_num = 0x0;
6575 cmd->result = 0x00;
6576
6577 HostCmd_IMD3_CFG *imd3_cfg = (HostCmd_IMD3_CFG *)&cmd->params.imd3_cfg;
6578 imd3_cfg->action = wlan_cpu_to_le16(ACTION_SET);
6579 imd3_cfg->reserved = 0x00;
6580
6581 MrvlIETypes_IMD_Config_t *imd_cfg = (MrvlIETypes_IMD_Config_t *)&imd3_cfg->imd_cfg;
6582
6583 imd_cfg->param.tlv_type = wlan_cpu_to_le16(TLV_TYPE_IMD_VALIDATION);
6584 imd_cfg->param.tlv_length = wlan_cpu_to_le16(sizeof(MrvlIETypes_IMD_Config_t) - sizeof(MrvlIETypes_Coex_params_t));
6585
6586 imd_cfg->rbc_mode = 0x00;
6587 imd_cfg->reserved = wlan_cpu_to_le16(imd3_value);
6588 imd_cfg->DynamicMode = 0x0000;
6589
6590 wifi_wait_for_cmdresp(NULL);
6591
6592 return wm_wifi.cmd_resp_status;
6593 }
6594 #endif
6595
6596 #if CONFIG_INACTIVITY_TIMEOUT_EXT
wifi_sta_inactivityto(wifi_inactivity_to_t * inac_to,t_u16 cmd_action)6597 int wifi_sta_inactivityto(wifi_inactivity_to_t *inac_to, t_u16 cmd_action)
6598 {
6599 wifi_get_command_lock();
6600 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6601 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6602 HostCmd_DS_INACTIVITY_TIMEOUT_EXT *inac_to_ext = (HostCmd_DS_INACTIVITY_TIMEOUT_EXT *)&cmd->params.inactivity_to;
6603
6604 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_INACTIVITY_TIMEOUT_EXT);
6605 cmd->size = wlan_cpu_to_le16(sizeof(HostCmd_DS_INACTIVITY_TIMEOUT_EXT) + S_DS_GEN);
6606 cmd->seq_num = 0x0;
6607 cmd->result = 0x00;
6608
6609 inac_to_ext->action = wlan_cpu_to_le16(cmd_action);
6610 if (cmd_action == HostCmd_ACT_GEN_SET)
6611 {
6612 inac_to_ext->timeout_unit = wlan_cpu_to_le16((t_u16)inac_to->timeout_unit);
6613 inac_to_ext->unicast_timeout = wlan_cpu_to_le16((t_u16)inac_to->unicast_timeout);
6614 inac_to_ext->mcast_timeout = wlan_cpu_to_le16((t_u16)inac_to->mcast_timeout);
6615 inac_to_ext->ps_entry_timeout = wlan_cpu_to_le16((t_u16)inac_to->ps_entry_timeout);
6616 inac_to_ext->ps_cmd_timeout = wlan_cpu_to_le16((t_u16)inac_to->ps_cmd_timeout);
6617 wifi_wait_for_cmdresp(NULL);
6618 }
6619 else
6620 {
6621 wifi_wait_for_cmdresp(inac_to);
6622 }
6623
6624 return wm_wifi.cmd_resp_status;
6625 }
6626 #endif
6627
6628 #if CONFIG_AUTO_NULL_TX
wifi_auto_null_tx(wifi_auto_null_tx_t * auto_null_tx,mlan_bss_type bss_type)6629 int wifi_auto_null_tx(wifi_auto_null_tx_t *auto_null_tx, mlan_bss_type bss_type)
6630 {
6631 wifi_get_command_lock();
6632 HostCmd_DS_COMMAND *cmd = wifi_get_command_buffer();
6633 HostCmd_DS_AUTO_TX *auto_tx_cmd = (HostCmd_DS_AUTO_TX *)((t_u8 *)cmd + S_DS_GEN);
6634
6635 if (auto_null_tx == NULL)
6636 return -WM_E_INVAL;
6637
6638 (void)memset(cmd, 0x00, sizeof(HostCmd_DS_COMMAND));
6639 cmd->seq_num = HostCmd_SET_SEQ_NO_BSS_INFO(0 /* seq_num */, 0 /* bss_num */, bss_type);
6640 cmd->command = wlan_cpu_to_le16(HostCmd_CMD_AUTO_TX);
6641 cmd->size = S_DS_GEN + sizeof(HostCmd_DS_AUTO_TX);
6642 auto_tx_cmd->action = wlan_cpu_to_le16(HostCmd_ACT_GEN_SET);
6643
6644 if (auto_null_tx->start)
6645 {
6646 MrvlIEtypes_Auto_Null_Tx_t *auto_null_tx_tlv =
6647 (MrvlIEtypes_Auto_Null_Tx_t *)((t_u8 *)auto_tx_cmd + sizeof(auto_tx_cmd->action));
6648 auto_null_tx_tlv->header.type = wlan_cpu_to_le16(TLV_TYPE_AUTO_TX);
6649 auto_null_tx_tlv->header.len =
6650 wlan_cpu_to_le16(sizeof(MrvlIEtypes_Auto_Null_Tx_t) - sizeof(MrvlIEtypesHeader_t));
6651 auto_null_tx_tlv->interval = auto_null_tx->interval;
6652 auto_null_tx_tlv->priority = auto_null_tx->priority;
6653 /* Packet index, set to 0 for auto null tx */
6654 auto_null_tx_tlv->index = 0;
6655 /* getTodToAForPkts, set to 0 for auto null tx */
6656 auto_null_tx_tlv->getTodToAForPkts = 0;
6657 auto_null_tx_tlv->frame_len = sizeof(auto_null_tx_tlv->dest_mac_addr) +
6658 sizeof(auto_null_tx_tlv->dest_mac_addr) +
6659 sizeof(auto_null_tx_tlv->frame_body_len);
6660
6661 (void)memcpy((void *)auto_null_tx_tlv->dest_mac_addr, (const void *)auto_null_tx->dst_mac,
6662 MLAN_MAC_ADDR_LENGTH);
6663 (void)memcpy((void *)auto_null_tx_tlv->src_mac_addr, (const void *)auto_null_tx->src_mac, MLAN_MAC_ADDR_LENGTH);
6664 /* fram body length, '0x00,0x00' for auto null tx */
6665 auto_null_tx_tlv->frame_body_len = 0;
6666 cmd->size = cmd->size + sizeof(MrvlIEtypes_Auto_Null_Tx_t);
6667 cmd->size = wlan_cpu_to_le16(cmd->size);
6668 }
6669
6670 cmd->result = 0x00;
6671
6672 wifi_wait_for_cmdresp(NULL);
6673
6674 return wm_wifi.cmd_resp_status;
6675 }
6676 #endif
6677
