1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include "halmac_88xx_cfg.h"
3
4 /**
5 * halmac_init_adapter_para_88xx() - int halmac adapter
6 * @pHalmac_adapter
7 *
8 * SD1 internal use
9 *
10 * Author : KaiYuan Chang/Ivan Lin
11 * Return : VOID
12 */
13 VOID
halmac_init_adapter_para_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)14 halmac_init_adapter_para_88xx(
15 IN PHALMAC_ADAPTER pHalmac_adapter
16 )
17 {
18 pHalmac_adapter->api_record.array_wptr = 0;
19 pHalmac_adapter->pHalAdapter_backup = pHalmac_adapter;
20 pHalmac_adapter->h2c_packet_seq = 0;
21 pHalmac_adapter->pHalEfuse_map = (u8 *)NULL;
22 pHalmac_adapter->hal_efuse_map_valid = _FALSE;
23 pHalmac_adapter->efuse_end = 0;
24 pHalmac_adapter->pHal_mac_addr[0].Address_L_H.Address_Low = 0;
25 pHalmac_adapter->pHal_mac_addr[0].Address_L_H.Address_High = 0;
26 pHalmac_adapter->pHal_mac_addr[1].Address_L_H.Address_Low = 0;
27 pHalmac_adapter->pHal_mac_addr[1].Address_L_H.Address_High = 0;
28 pHalmac_adapter->pHal_bss_addr[0].Address_L_H.Address_Low = 0;
29 pHalmac_adapter->pHal_bss_addr[0].Address_L_H.Address_High = 0;
30 pHalmac_adapter->pHal_bss_addr[1].Address_L_H.Address_Low = 0;
31 pHalmac_adapter->pHal_bss_addr[1].Address_L_H.Address_High = 0;
32
33
34 pHalmac_adapter->low_clk = _FALSE;
35 pHalmac_adapter->h2c_buf_free_space = 0;
36 pHalmac_adapter->max_download_size = HALMAC_FW_MAX_DL_SIZE_88XX;
37
38 /* Init LPS Option */
39 pHalmac_adapter->fwlps_option.mode = 0x01; /*0:Active 1:LPS 2:WMMPS*/
40 pHalmac_adapter->fwlps_option.awake_interval = 1;
41 pHalmac_adapter->fwlps_option.enter_32K = 1;
42 pHalmac_adapter->fwlps_option.clk_request = 0;
43 pHalmac_adapter->fwlps_option.rlbm = 0;
44 pHalmac_adapter->fwlps_option.smart_ps = 0;
45 pHalmac_adapter->fwlps_option.awake_interval = 1;
46 pHalmac_adapter->fwlps_option.all_queue_uapsd = 0;
47 pHalmac_adapter->fwlps_option.pwr_state = 0;
48 pHalmac_adapter->fwlps_option.low_pwr_rx_beacon = 0;
49 pHalmac_adapter->fwlps_option.ant_auto_switch = 0;
50 pHalmac_adapter->fwlps_option.ps_allow_bt_high_Priority = 0;
51 pHalmac_adapter->fwlps_option.protect_bcn = 0;
52 pHalmac_adapter->fwlps_option.silence_period = 0;
53 pHalmac_adapter->fwlps_option.fast_bt_connect = 0;
54 pHalmac_adapter->fwlps_option.two_antenna_en = 0;
55 pHalmac_adapter->fwlps_option.adopt_user_Setting = 1;
56 pHalmac_adapter->fwlps_option.drv_bcn_early_shift = 0;
57
58 pHalmac_adapter->config_para_info.pCfg_para_buf = NULL;
59 pHalmac_adapter->config_para_info.pPara_buf_w = NULL;
60 pHalmac_adapter->config_para_info.para_num = 0;
61 pHalmac_adapter->config_para_info.full_fifo_mode = _FALSE;
62 pHalmac_adapter->config_para_info.para_buf_size = 0;
63 pHalmac_adapter->config_para_info.avai_para_buf_size = 0;
64 pHalmac_adapter->config_para_info.offset_accumulation = 0;
65 pHalmac_adapter->config_para_info.value_accumulation = 0;
66 pHalmac_adapter->config_para_info.datapack_segment = 0;
67
68 pHalmac_adapter->ch_sw_info.ch_info_buf = NULL;
69 pHalmac_adapter->ch_sw_info.ch_info_buf_w = NULL;
70 pHalmac_adapter->ch_sw_info.extra_info_en = 0;
71 pHalmac_adapter->ch_sw_info.buf_size = 0;
72 pHalmac_adapter->ch_sw_info.avai_buf_size = 0;
73 pHalmac_adapter->ch_sw_info.total_size = 0;
74 pHalmac_adapter->ch_sw_info.ch_num = 0;
75
76 pHalmac_adapter->gen_info_valid = _FALSE;
77
78 PLATFORM_RTL_MEMSET(pHalmac_adapter->pDriver_adapter, pHalmac_adapter->api_record.api_array, HALMAC_API_STUFF, sizeof(pHalmac_adapter->api_record.api_array));
79
80 halmac_init_state_machine_88xx(pHalmac_adapter);
81
82 }
83
84 /**
85 * halmac_init_state_machine_88xx() - init halmac software state machine
86 * @pHalmac_adapter
87 *
88 * SD1 internal use.
89 *
90 * Author : KaiYuan Chang/Ivan Lin
91 * Return : VOID
92 */
93 VOID
halmac_init_state_machine_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)94 halmac_init_state_machine_88xx(
95 IN PHALMAC_ADAPTER pHalmac_adapter
96 )
97 {
98 PHALMAC_STATE pState = &(pHalmac_adapter->halmac_state);
99
100 pState->efuse_state_set.efuse_cmd_construct_state = HALMAC_EFUSE_CMD_CONSTRUCT_IDLE;
101 pState->efuse_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
102 pState->efuse_state_set.seq_num = pHalmac_adapter->h2c_packet_seq;
103
104 pState->cfg_para_state_set.cfg_para_cmd_construct_state = HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE;
105 pState->cfg_para_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
106 pState->cfg_para_state_set.seq_num = pHalmac_adapter->h2c_packet_seq;
107
108 pState->scan_state_set.scan_cmd_construct_state = HALMAC_SCAN_CMD_CONSTRUCT_IDLE;
109 pState->scan_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
110 pState->scan_state_set.seq_num = pHalmac_adapter->h2c_packet_seq;
111
112 pState->update_packet_set.process_status = HALMAC_CMD_PROCESS_IDLE;
113 pState->update_packet_set.seq_num = pHalmac_adapter->h2c_packet_seq;
114
115 pState->iqk_set.process_status = HALMAC_CMD_PROCESS_IDLE;
116 pState->iqk_set.seq_num = pHalmac_adapter->h2c_packet_seq;
117
118 pState->power_tracking_set.process_status = HALMAC_CMD_PROCESS_IDLE;
119 pState->power_tracking_set.seq_num = pHalmac_adapter->h2c_packet_seq;
120
121 pState->psd_set.process_status = HALMAC_CMD_PROCESS_IDLE;
122 pState->psd_set.seq_num = pHalmac_adapter->h2c_packet_seq;
123 pState->psd_set.data_size = 0;
124 pState->psd_set.segment_size = 0;
125 pState->psd_set.pData = NULL;
126
127 pState->api_state = HALMAC_API_STATE_INIT;
128
129 pState->dlfw_state = HALMAC_DLFW_NONE;
130 pState->mac_power = HALMAC_MAC_POWER_OFF;
131 pState->ps_state = HALMAC_PS_STATE_UNDEFINE;
132 }
133
134 /**
135 * halmac_mount_api_88xx() - attach functions to function pointer
136 * @pHalmac_adapter
137 *
138 * SD1 internal use
139 *
140 * Author : KaiYuan Chang/Ivan Lin
141 * Return : HALMAC_RET_STATUS
142 */
143 HALMAC_RET_STATUS
halmac_mount_api_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)144 halmac_mount_api_88xx(
145 IN PHALMAC_ADAPTER pHalmac_adapter
146 )
147 {
148 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
149 PHALMAC_API pHalmac_api = (PHALMAC_API)NULL;
150 u8 chip_id, chip_version;
151 u32 polling_count;
152
153 pHalmac_adapter->pHalmac_api = (PHALMAC_API)PLATFORM_RTL_MALLOC(pDriver_adapter, sizeof(HALMAC_API));
154 if (NULL == pHalmac_adapter->pHalmac_api)
155 return HALMAC_RET_MALLOC_FAIL;
156 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
157
158 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, HALMAC_SVN_VER_88XX"\n");
159 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "HALMAC_MAJOR_VER_88XX = %x\n", HALMAC_MAJOR_VER_88XX);
160 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "HALMAC_PROTOTYPE_88XX = %x\n", HALMAC_PROTOTYPE_VER_88XX);
161 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "HALMAC_MINOR_VER_88XX = %x\n", HALMAC_MINOR_VER_88XX);
162
163
164 /* Mount function pointer */
165 pHalmac_api->halmac_download_firmware = halmac_download_firmware_88xx;
166 pHalmac_api->halmac_get_fw_version = halmac_get_fw_version_88xx;
167 pHalmac_api->halmac_cfg_mac_addr = halmac_cfg_mac_addr_88xx;
168 pHalmac_api->halmac_cfg_bssid = halmac_cfg_bssid_88xx;
169 pHalmac_api->halmac_cfg_multicast_addr = halmac_cfg_multicast_addr_88xx;
170 pHalmac_api->halmac_pre_init_system_cfg = halmac_pre_init_system_cfg_88xx;
171 pHalmac_api->halmac_init_system_cfg = halmac_init_system_cfg_88xx;
172 pHalmac_api->halmac_init_protocol_cfg = halmac_init_protocol_cfg_88xx;
173 pHalmac_api->halmac_init_edca_cfg = halmac_init_edca_cfg_88xx;
174 pHalmac_api->halmac_cfg_operation_mode = halmac_cfg_operation_mode_88xx;
175 pHalmac_api->halmac_cfg_ch_bw = halmac_cfg_ch_bw_88xx;
176 pHalmac_api->halmac_cfg_bw = halmac_cfg_bw_88xx;
177 pHalmac_api->halmac_init_wmac_cfg = halmac_init_wmac_cfg_88xx;
178 pHalmac_api->halmac_init_mac_cfg = halmac_init_mac_cfg_88xx;
179 pHalmac_api->halmac_init_sdio_cfg = halmac_init_sdio_cfg_88xx;
180 pHalmac_api->halmac_init_usb_cfg = halmac_init_usb_cfg_88xx;
181 pHalmac_api->halmac_init_pcie_cfg = halmac_init_pcie_cfg_88xx;
182 pHalmac_api->halmac_deinit_sdio_cfg = halmac_deinit_sdio_cfg_88xx;
183 pHalmac_api->halmac_deinit_usb_cfg = halmac_deinit_usb_cfg_88xx;
184 pHalmac_api->halmac_deinit_pcie_cfg = halmac_deinit_pcie_cfg_88xx;
185 pHalmac_api->halmac_dump_efuse_map = halmac_dump_efuse_map_88xx;
186 pHalmac_api->halmac_dump_efuse_map_bt = halmac_dump_efuse_map_bt_88xx;
187 pHalmac_api->halmac_write_efuse_bt = halmac_write_efuse_bt_88xx;
188 pHalmac_api->halmac_dump_logical_efuse_map = halmac_dump_logical_efuse_map_88xx;
189 /* pHalmac_api->halmac_write_efuse = halmac_write_efuse_88xx; */
190 pHalmac_api->halmac_pg_efuse_by_map = halmac_pg_efuse_by_map_88xx;
191 pHalmac_api->halmac_get_efuse_size = halmac_get_efuse_size_88xx;
192 pHalmac_api->halmac_get_efuse_available_size = halmac_get_efuse_available_size_88xx;
193 pHalmac_api->halmac_get_c2h_info = halmac_get_c2h_info_88xx;
194 /* pHalmac_api->halmac_read_efuse = halmac_read_efuse_88xx; */
195
196 pHalmac_api->halmac_get_logical_efuse_size = halmac_get_logical_efuse_size_88xx;
197
198 pHalmac_api->halmac_write_logical_efuse = halmac_write_logical_efuse_88xx;
199 pHalmac_api->halmac_read_logical_efuse = halmac_read_logical_efuse_88xx;
200
201 pHalmac_api->halmac_cfg_fwlps_option = halmac_cfg_fwlps_option_88xx;
202 pHalmac_api->halmac_cfg_fwips_option = halmac_cfg_fwips_option_88xx;
203 pHalmac_api->halmac_enter_wowlan = halmac_enter_wowlan_88xx;
204 pHalmac_api->halmac_leave_wowlan = halmac_leave_wowlan_88xx;
205 pHalmac_api->halmac_enter_ps = halmac_enter_ps_88xx;
206 pHalmac_api->halmac_leave_ps = halmac_leave_ps_88xx;
207 pHalmac_api->halmac_h2c_lb = halmac_h2c_lb_88xx;
208 pHalmac_api->halmac_debug = halmac_debug_88xx;
209 pHalmac_api->halmac_cfg_parameter = halmac_cfg_parameter_88xx;
210 pHalmac_api->halmac_update_datapack = halmac_update_datapack_88xx;
211 pHalmac_api->halmac_run_datapack = halmac_run_datapack_88xx;
212 pHalmac_api->halmac_cfg_drv_info = halmac_cfg_drv_info_88xx;
213 pHalmac_api->halmac_send_bt_coex = halmac_send_bt_coex_88xx;
214 pHalmac_api->halmac_verify_platform_api = halmac_verify_platform_api_88xx;
215 pHalmac_api->halmac_update_packet = halmac_update_packet_88xx;
216 pHalmac_api->halmac_bcn_ie_filter = halmac_bcn_ie_filter_88xx;
217 pHalmac_api->halmac_cfg_txbf = halmac_cfg_txbf_88xx;
218 pHalmac_api->halmac_cfg_mumimo = halmac_cfg_mumimo_88xx;
219 pHalmac_api->halmac_cfg_sounding = halmac_cfg_sounding_88xx;
220 pHalmac_api->halmac_del_sounding = halmac_del_sounding_88xx;
221 pHalmac_api->halmac_su_bfer_entry_init = halmac_su_bfer_entry_init_88xx;
222 pHalmac_api->halmac_su_bfee_entry_init = halmac_su_bfee_entry_init_88xx;
223 pHalmac_api->halmac_mu_bfer_entry_init = halmac_mu_bfer_entry_init_88xx;
224 pHalmac_api->halmac_mu_bfee_entry_init = halmac_mu_bfee_entry_init_88xx;
225 pHalmac_api->halmac_su_bfer_entry_del = halmac_su_bfer_entry_del_88xx;
226 pHalmac_api->halmac_su_bfee_entry_del = halmac_su_bfee_entry_del_88xx;
227 pHalmac_api->halmac_mu_bfer_entry_del = halmac_mu_bfer_entry_del_88xx;
228 pHalmac_api->halmac_mu_bfee_entry_del = halmac_mu_bfee_entry_del_88xx;
229
230 pHalmac_api->halmac_add_ch_info = halmac_add_ch_info_88xx;
231 pHalmac_api->halmac_add_extra_ch_info = halmac_add_extra_ch_info_88xx;
232 pHalmac_api->halmac_ctrl_ch_switch = halmac_ctrl_ch_switch_88xx;
233 pHalmac_api->halmac_clear_ch_info = halmac_clear_ch_info_88xx;
234 pHalmac_api->halmac_send_general_info = halmac_send_general_info_88xx;
235
236 pHalmac_api->halmac_start_iqk = halmac_start_iqk_88xx;
237 pHalmac_api->halmac_ctrl_pwr_tracking = halmac_ctrl_pwr_tracking_88xx;
238 pHalmac_api->halmac_psd = halmac_psd_88xx;
239 pHalmac_api->halmac_cfg_la_mode = halmac_cfg_la_mode_88xx;
240
241 pHalmac_api->halmac_get_hw_value = halmac_get_hw_value_88xx;
242 pHalmac_api->halmac_set_hw_value = halmac_set_hw_value_88xx;
243
244 pHalmac_api->halmac_cfg_drv_rsvd_pg_num = halmac_cfg_drv_rsvd_pg_num_88xx;
245 pHalmac_api->halmac_get_chip_version = halmac_get_chip_version_88xx;
246
247 pHalmac_api->halmac_query_status = halmac_query_status_88xx;
248 pHalmac_api->halmac_reset_feature = halmac_reset_feature_88xx;
249 pHalmac_api->halmac_check_fw_status = halmac_check_fw_status_88xx;
250 pHalmac_api->halmac_dump_fw_dmem = halmac_dump_fw_dmem_88xx;
251 pHalmac_api->halmac_cfg_max_dl_size = halmac_cfg_max_dl_size_88xx;
252
253 pHalmac_api->halmac_dump_fifo = halmac_dump_fifo_88xx;
254 pHalmac_api->halmac_get_fifo_size = halmac_get_fifo_size_88xx;
255
256 pHalmac_api->halmac_chk_txdesc = halmac_chk_txdesc_88xx;
257
258 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
259 pHalmac_api->halmac_cfg_rx_aggregation = halmac_cfg_rx_aggregation_88xx_sdio;
260 pHalmac_api->halmac_init_interface_cfg = halmac_init_sdio_cfg_88xx;
261 pHalmac_api->halmac_deinit_interface_cfg = halmac_deinit_sdio_cfg_88xx;
262 pHalmac_api->halmac_reg_read_8 = halmac_reg_read_8_sdio_88xx;
263 pHalmac_api->halmac_reg_write_8 = halmac_reg_write_8_sdio_88xx;
264 pHalmac_api->halmac_reg_read_16 = halmac_reg_read_16_sdio_88xx;
265 pHalmac_api->halmac_reg_write_16 = halmac_reg_write_16_sdio_88xx;
266 pHalmac_api->halmac_reg_read_32 = halmac_reg_read_32_sdio_88xx;
267 pHalmac_api->halmac_reg_write_32 = halmac_reg_write_32_sdio_88xx;
268 } else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface) {
269 pHalmac_api->halmac_cfg_rx_aggregation = halmac_cfg_rx_aggregation_88xx_usb;
270 pHalmac_api->halmac_init_interface_cfg = halmac_init_usb_cfg_88xx;
271 pHalmac_api->halmac_deinit_interface_cfg = halmac_deinit_usb_cfg_88xx;
272 pHalmac_api->halmac_reg_read_8 = halmac_reg_read_8_usb_88xx;
273 pHalmac_api->halmac_reg_write_8 = halmac_reg_write_8_usb_88xx;
274 pHalmac_api->halmac_reg_read_16 = halmac_reg_read_16_usb_88xx;
275 pHalmac_api->halmac_reg_write_16 = halmac_reg_write_16_usb_88xx;
276 pHalmac_api->halmac_reg_read_32 = halmac_reg_read_32_usb_88xx;
277 pHalmac_api->halmac_reg_write_32 = halmac_reg_write_32_usb_88xx;
278 } else if (HALMAC_INTERFACE_PCIE == pHalmac_adapter->halmac_interface) {
279 pHalmac_api->halmac_cfg_rx_aggregation = halmac_cfg_rx_aggregation_88xx_pcie;
280 pHalmac_api->halmac_init_interface_cfg = halmac_init_pcie_cfg_88xx;
281 pHalmac_api->halmac_deinit_interface_cfg = halmac_deinit_pcie_cfg_88xx;
282 pHalmac_api->halmac_reg_read_8 = halmac_reg_read_8_pcie_88xx;
283 pHalmac_api->halmac_reg_write_8 = halmac_reg_write_8_pcie_88xx;
284 pHalmac_api->halmac_reg_read_16 = halmac_reg_read_16_pcie_88xx;
285 pHalmac_api->halmac_reg_write_16 = halmac_reg_write_16_pcie_88xx;
286 pHalmac_api->halmac_reg_read_32 = halmac_reg_read_32_pcie_88xx;
287 pHalmac_api->halmac_reg_write_32 = halmac_reg_write_32_pcie_88xx;
288 } else {
289 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Set halmac io function Error!!\n");
290 }
291
292 pHalmac_api->halmac_set_bulkout_num = halmac_set_bulkout_num_88xx;
293 pHalmac_api->halmac_get_sdio_tx_addr = halmac_get_sdio_tx_addr_88xx;
294 pHalmac_api->halmac_get_usb_bulkout_id = halmac_get_usb_bulkout_id_88xx;
295 pHalmac_api->halmac_timer_2s = halmac_timer_2s_88xx;
296 pHalmac_api->halmac_fill_txdesc_checksum = halmac_fill_txdesc_check_sum_88xx;
297
298 /* Get Chip_id and Chip_version */
299 chip_id = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_CFG2);
300 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
301 if (chip_id == 0xEA) {
302 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SDIO_HSUS_CTRL, HALMAC_REG_READ_8(pHalmac_adapter, REG_SDIO_HSUS_CTRL) & ~(BIT(0)));
303
304 polling_count = HALMAC_POLLING_READY_TIMEOUT_COUNT;
305 while (!(HALMAC_REG_READ_8(pHalmac_adapter, REG_SDIO_HSUS_CTRL) & 0x02)) {
306 polling_count--;
307 if (polling_count == 0)
308 return HALMAC_RET_SDIO_LEAVE_SUSPEND_FAIL;
309 }
310 }
311 chip_id = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_CFG2);
312 }
313 chip_version = (u8)HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_CFG1 + 1) >> 4;
314
315 pHalmac_adapter->chip_version = (HALMAC_CHIP_VER)chip_version;
316
317 if (HALMAC_CHIP_ID_HW_DEF_8822B == chip_id) {
318 #if HALMAC_8822B_SUPPORT
319 /*mount 8822b function and data*/
320 halmac_mount_api_8822b(pHalmac_adapter);
321 #endif
322
323 } else if (HALMAC_CHIP_ID_HW_DEF_8821C == chip_id) {
324 #if HALMAC_8821C_SUPPORT
325 /*mount 8822b function and data*/
326 halmac_mount_api_8821c(pHalmac_adapter);
327 #endif
328 } else if (HALMAC_CHIP_ID_HW_DEF_8197F == chip_id) {
329 #if HALMAC_8197F_SUPPORT
330 /*mount 8822b function and data*/
331 halmac_mount_api_8197f(pHalmac_adapter);
332 #endif
333 } else {
334 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Chip ID undefine!!\n");
335 return HALMAC_RET_CHIP_NOT_SUPPORT;
336 }
337
338 pHalmac_adapter->txff_allocation.tx_fifo_pg_num = 0;
339 pHalmac_adapter->txff_allocation.ac_q_pg_num = 0;
340 pHalmac_adapter->txff_allocation.rsvd_pg_bndy = 0;
341 pHalmac_adapter->txff_allocation.rsvd_drv_pg_bndy = 0;
342 pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy = 0;
343 pHalmac_adapter->txff_allocation.rsvd_h2c_queue_pg_bndy = 0;
344 pHalmac_adapter->txff_allocation.rsvd_cpu_instr_pg_bndy = 0;
345 pHalmac_adapter->txff_allocation.rsvd_fw_txbuff_pg_bndy = 0;
346 pHalmac_adapter->txff_allocation.pub_queue_pg_num = 0;
347 pHalmac_adapter->txff_allocation.high_queue_pg_num = 0;
348 pHalmac_adapter->txff_allocation.low_queue_pg_num = 0;
349 pHalmac_adapter->txff_allocation.normal_queue_pg_num = 0;
350 pHalmac_adapter->txff_allocation.extra_queue_pg_num = 0;
351
352 pHalmac_adapter->txff_allocation.la_mode = HALMAC_LA_MODE_DISABLE;
353
354 #if HALMAC_PLATFORM_TESTPROGRAM
355 pHalmac_api->halmac_write_efuse = halmac_write_efuse_88xx;
356 pHalmac_api->halmac_read_efuse = halmac_read_efuse_88xx;
357 pHalmac_api->halmac_switch_efuse_bank = halmac_switch_efuse_bank_88xx;
358
359 pHalmac_api->halmac_gen_txdesc = halmac_gen_tx_desc_88xx;
360 pHalmac_api->halmac_txdesc_parser = halmac_tx_desc_parser_88xx;
361 pHalmac_api->halmac_rxdesc_parser = halmac_rx_desc_parser_88xx;
362 pHalmac_api->halmac_get_txdesc_size = halmac_get_txdesc_size_88xx;
363 pHalmac_api->halmac_send_packet = halmac_send_packet_88xx;
364 pHalmac_api->halmac_parse_packet = halmac_parse_packet_88xx;
365
366 pHalmac_api->halmac_get_pcie_packet = halmac_get_pcie_packet_88xx;
367 pHalmac_api->halmac_gen_txagg_desc = halmac_gen_txagg_desc_88xx;
368
369 pHalmac_api->halmac_bb_reg_read = halmac_bb_reg_read_88xx;
370 pHalmac_api->halmac_bb_reg_write = halmac_bb_reg_write_88xx;
371
372 pHalmac_api->halmac_rf_reg_read = halmac_rf_ac_reg_read_88xx;
373 pHalmac_api->halmac_rf_reg_write = halmac_rf_ac_reg_write_88xx;
374 pHalmac_api->halmac_init_antenna_selection = halmac_init_antenna_selection_88xx;
375 pHalmac_api->halmac_bb_preconfig = halmac_bb_preconfig_88xx;
376 pHalmac_api->halmac_init_crystal_capacity = halmac_init_crystal_capacity_88xx;
377 pHalmac_api->halmac_trx_antenna_setting = halmac_trx_antenna_setting_88xx;
378
379 pHalmac_api->halmac_himr_setting_sdio = halmac_himr_setting_88xx_sdio;
380
381 pHalmac_api->halmac_send_beacon = halmac_send_beacon_88xx;
382 pHalmac_api->halmac_stop_beacon = halmac_stop_beacon_88xx;
383 pHalmac_api->halmac_check_trx_status = halmac_check_trx_status_88xx;
384 pHalmac_api->halmac_set_agg_num = halmac_set_agg_num_88xx;
385 pHalmac_api->halmac_get_management_txdesc = halmac_get_management_txdesc_88xx;
386 pHalmac_api->halmac_send_control = halmac_send_control_88xx;
387 pHalmac_api->halmac_send_hiqueue = halmac_send_hiqueue_88xx;
388 pHalmac_api->halmac_media_status_rpt = halmac_media_status_rpt_88xx;
389
390 pHalmac_api->halmac_timer_10ms = halmac_timer_10ms_88xx;
391
392 pHalmac_api->halmac_download_firmware_fpag = halmac_download_firmware_fpga_88xx;
393 pHalmac_api->halmac_download_rom_fpga = halmac_download_rom_fpga_88xx;
394 pHalmac_api->halmac_download_flash = halmac_download_flash_88xx;
395 pHalmac_api->halmac_erase_flash = halmac_erase_flash_88xx;
396 pHalmac_api->halmac_check_flash = halmac_check_flash_88xx;
397 pHalmac_api->halmac_send_nlo = halmac_send_nlo_88xx;
398
399 pHalmac_api->halmac_config_security = halmac_config_security_88xx;
400 pHalmac_api->halmac_read_cam = halmac_read_cam_88xx;
401 pHalmac_api->halmac_write_cam = halmac_write_cam_88xx;
402 pHalmac_api->halmac_dump_cam_table = halmac_dump_cam_table_88xx;
403 pHalmac_api->halmac_load_cam_table = halmac_load_cam_table_88xx;
404
405 pHalmac_api->halmac_get_chip_type = halmac_get_chip_type_88xx;
406
407 pHalmac_api->halmac_get_rx_agg_num = halmac_get_rx_agg_num_88xx;
408
409 if (pHalmac_adapter->chip_id == HALMAC_CHIP_ID_8822B)
410 pHalmac_api->halmac_run_pwrseq = halmac_run_pwrseq_8822b;
411 else if (pHalmac_adapter->chip_id == HALMAC_CHIP_ID_8821C)
412 pHalmac_api->halmac_run_pwrseq = halmac_run_pwrseq_8821c;
413
414 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
415 pHalmac_api->halmac_reg_read_8 = halmac_reg_read_8_sdio_tp_88xx;
416 pHalmac_api->halmac_reg_write_8 = halmac_reg_write_8_sdio_tp_88xx;
417 pHalmac_api->halmac_reg_read_16 = halmac_reg_read_16_sdio_tp_88xx;
418 pHalmac_api->halmac_reg_write_16 = halmac_reg_write_16_sdio_tp_88xx;
419 pHalmac_api->halmac_reg_read_32 = halmac_reg_read_32_sdio_tp_88xx;
420 pHalmac_api->halmac_reg_write_32 = halmac_reg_write_32_sdio_tp_88xx;
421 }
422 #endif
423 return HALMAC_RET_SUCCESS;
424 }
425
426
427 /**
428 * halmac_download_firmware_88xx() - download Firmware
429 * @pHalmac_adapter
430 * @pHamacl_fw : FW bin file
431 * @halmac_fw_size
432 * Author : KaiYuan Chang/Ivan Lin
433 * Return : HALMAC_RET_STATUS
434 */
435 HALMAC_RET_STATUS
halmac_download_firmware_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pHamacl_fw,IN u32 halmac_fw_size)436 halmac_download_firmware_88xx(
437 IN PHALMAC_ADAPTER pHalmac_adapter,
438 IN u8 *pHamacl_fw,
439 IN u32 halmac_fw_size
440 )
441 {
442 u8 value8;
443 u8 *pFile_ptr;
444 u16 value16;
445 u32 restore_index = 0;
446 u32 halmac_h2c_ver = 0, fw_h2c_ver = 0;
447 u32 iram_pkt_size, dmem_pkt_size, eram_pkt_size = 0;
448 VOID *pDriver_adapter = NULL;
449 PHALMAC_API pHalmac_api;
450 HALMAC_RESTORE_INFO restore_info[DLFW_RESTORE_REG_NUM_88XX];
451 HALMAC_RET_STATUS status;
452
453 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
454 return HALMAC_RET_ADAPTER_INVALID;
455
456 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
457 return HALMAC_RET_API_INVALID;
458
459 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DOWNLOAD_FIRMWARE);
460
461 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
462 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
463
464 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_download_firmware_88xx ==========>\n");
465 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_download_firmware_88xx start!!\n");
466
467 if (halmac_fw_size > HALMAC_FW_SIZE_MAX_88XX || halmac_fw_size < HALMAC_FWHDR_SIZE_88XX) {
468 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "FW size error!\n");
469 return HALMAC_RET_FW_SIZE_ERR;
470 }
471
472 fw_h2c_ver = *((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_H2C_FORMAT_VER_88XX));
473 halmac_h2c_ver = H2C_FORMAT_VERSION;
474 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac h2c/c2h format = %x, fw h2c/c2h format = %x!!\n", halmac_h2c_ver, fw_h2c_ver);
475 if (fw_h2c_ver != halmac_h2c_ver)
476 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_WARN, "H2C/C2H version mismatch between HALMAC and FW, Offload Feature May fail!\n");
477
478 pHalmac_adapter->halmac_state.dlfw_state = HALMAC_DLFW_NONE;
479
480 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_FUNC_EN + 1);
481 value8 = (u8)(value8 & ~(BIT(2)));
482 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SYS_FUNC_EN + 1, value8); /* Disable CPU reset */
483
484
485 restore_info[restore_index].length = 1;
486 restore_info[restore_index].mac_register = REG_TXDMA_PQ_MAP + 1;
487 restore_info[restore_index].value = HALMAC_REG_READ_8(pHalmac_adapter, REG_TXDMA_PQ_MAP + 1);
488 restore_index++;
489 value8 = HALMAC_DMA_MAPPING_HIGH << 6;
490 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TXDMA_PQ_MAP + 1, value8); /* set HIQ to hi priority */
491
492 /* DLFW only use HIQ, map HIQ to hi priority */
493 pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_HI] = HALMAC_DMA_MAPPING_HIGH;
494 restore_info[restore_index].length = 1;
495 restore_info[restore_index].mac_register = REG_CR;
496 restore_info[restore_index].value = HALMAC_REG_READ_8(pHalmac_adapter, REG_CR);
497 restore_index++;
498 restore_info[restore_index].length = 4;
499 restore_info[restore_index].mac_register = REG_H2CQ_CSR;
500 restore_info[restore_index].value = BIT(31);
501 restore_index++;
502 value8 = BIT_HCI_TXDMA_EN | BIT_TXDMA_EN;
503 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CR, value8);
504 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_H2CQ_CSR, BIT(31));
505
506 /* Config hi priority queue and public priority queue page number (only for DLFW) */
507 restore_info[restore_index].length = 2;
508 restore_info[restore_index].mac_register = REG_FIFOPAGE_INFO_1;
509 restore_info[restore_index].value = HALMAC_REG_READ_16(pHalmac_adapter, REG_FIFOPAGE_INFO_1);
510 restore_index++;
511 restore_info[restore_index].length = 4;
512 restore_info[restore_index].mac_register = REG_RQPN_CTRL_2;
513 restore_info[restore_index].value = HALMAC_REG_READ_32(pHalmac_adapter, REG_RQPN_CTRL_2) | BIT(31);
514 restore_index++;
515 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_INFO_1, 0x200);
516 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RQPN_CTRL_2, restore_info[restore_index - 1].value);
517
518 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
519 HALMAC_REG_READ_32(pHalmac_adapter, REG_SDIO_FREE_TXPG);
520 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_SDIO_TX_CTRL, 0x00000000);
521 }
522
523 pHalmac_adapter->fw_version.version = rtk_le16_to_cpu(*((u16 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_VERSION_88XX)));
524 pHalmac_adapter->fw_version.sub_version = *(pHamacl_fw + HALMAC_FWHDR_OFFSET_SUBVERSION_88XX);
525 pHalmac_adapter->fw_version.sub_index = *(pHamacl_fw + HALMAC_FWHDR_OFFSET_SUBINDEX_88XX);
526
527 dmem_pkt_size = *((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_DMEM_SIZE_88XX));
528 iram_pkt_size = *((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_IRAM_SIZE_88XX));
529 if (0 != ((*(pHamacl_fw + HALMAC_FWHDR_OFFSET_MEM_USAGE_88XX)) & BIT(4)))
530 eram_pkt_size = *((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_ERAM_SIZE_88XX));
531
532 dmem_pkt_size = rtk_le32_to_cpu(dmem_pkt_size);
533 iram_pkt_size = rtk_le32_to_cpu(iram_pkt_size);
534 eram_pkt_size = rtk_le32_to_cpu(eram_pkt_size);
535
536 dmem_pkt_size += HALMAC_FW_CHKSUM_DUMMY_SIZE_88XX;
537 iram_pkt_size += HALMAC_FW_CHKSUM_DUMMY_SIZE_88XX;
538 if (0 != eram_pkt_size)
539 eram_pkt_size += HALMAC_FW_CHKSUM_DUMMY_SIZE_88XX;
540
541 if (halmac_fw_size != (HALMAC_FWHDR_SIZE_88XX + dmem_pkt_size + iram_pkt_size + eram_pkt_size)) {
542 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "FW size mismatch the real fw size!\n");
543 goto DLFW_FAIL;
544 }
545
546 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_CR + 1);
547 restore_info[restore_index].length = 1;
548 restore_info[restore_index].mac_register = REG_CR + 1;
549 restore_info[restore_index].value = value8;
550 restore_index++;
551 value8 = (u8)(value8 | BIT(0));
552 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CR + 1, value8); /* Enable SW TX beacon */
553
554 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL);
555 restore_info[restore_index].length = 1;
556 restore_info[restore_index].mac_register = REG_BCN_CTRL;
557 restore_info[restore_index].value = value8;
558 restore_index++;
559 value8 = (u8)((value8 & (~BIT(3))) | BIT(4));
560 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL, value8); /* Disable beacon related functions */
561
562 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_FWHW_TXQ_CTRL + 2);
563 restore_info[restore_index].length = 1;
564 restore_info[restore_index].mac_register = REG_FWHW_TXQ_CTRL + 2;
565 restore_info[restore_index].value = value8;
566 restore_index++;
567 value8 = (u8)(value8 & ~(BIT(6)));
568 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_FWHW_TXQ_CTRL + 2, value8); /* Disable ptcl tx bcnq */
569
570 restore_info[restore_index].length = 2;
571 restore_info[restore_index].mac_register = REG_FIFOPAGE_CTRL_2;
572 restore_info[restore_index].value = HALMAC_REG_READ_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2) | BIT(15);
573 restore_index++;
574 value16 = 0x8000;
575 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, value16); /* Set beacon header to 0 */
576
577 value16 = (u16)(HALMAC_REG_READ_16(pHalmac_adapter, REG_MCUFW_CTRL) & 0x3800);
578 value16 |= BIT(0);
579 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MCUFW_CTRL, value16); /* MCU/FW setting */
580
581 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_CPU_DMEM_CON + 2);
582 value8 &= ~(BIT(0));
583 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CPU_DMEM_CON + 2, value8);
584 value8 |= BIT(0);
585 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CPU_DMEM_CON + 2, value8);
586
587 /* Download to DMEM */
588 pFile_ptr = pHamacl_fw + HALMAC_FWHDR_SIZE_88XX;
589 /* if (HALMAC_RET_SUCCESS != halmac_dlfw_to_mem_88xx(pHalmac_adapter, pFile_ptr, HALMAC_OCPBASE_DMEM_88XX, dmem_pkt_size)) */
590 if (HALMAC_RET_SUCCESS != halmac_dlfw_to_mem_88xx(pHalmac_adapter, pFile_ptr,
591 (*((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_DMEM_ADDR_88XX))) & ~(BIT(31)), dmem_pkt_size))
592 goto DLFW_END;
593
594 /* Download to IMEM */
595 pFile_ptr = pHamacl_fw + HALMAC_FWHDR_SIZE_88XX + dmem_pkt_size;
596 /* if (HALMAC_RET_SUCCESS != halmac_dlfw_to_mem_88xx(pHalmac_adapter, pFile_ptr, HALMAC_OCPBASE_IMEM_88XX, iram_pkt_size)) */
597 if (HALMAC_RET_SUCCESS != halmac_dlfw_to_mem_88xx(pHalmac_adapter, pFile_ptr,
598 (*((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_IRAM_ADDR_88XX))) & ~(BIT(31)), iram_pkt_size))
599 goto DLFW_END;
600
601 /* Download to EMEM */
602 if (0 != eram_pkt_size) {
603 pFile_ptr = pHamacl_fw + HALMAC_FWHDR_SIZE_88XX + dmem_pkt_size + iram_pkt_size;
604 if (HALMAC_RET_SUCCESS != halmac_dlfw_to_mem_88xx(pHalmac_adapter, pFile_ptr,
605 (*((u32 *)(pHamacl_fw + HALMAC_FWHDR_OFFSET_EMEM_ADDR_88XX))) & ~(BIT(31)), eram_pkt_size))
606 goto DLFW_END;
607 }
608
609 DLFW_END:
610
611 halmac_restore_mac_register_88xx(pHalmac_adapter, restore_info, DLFW_RESTORE_REG_NUM_88XX);
612
613 if (HALMAC_RET_SUCCESS != halmac_dlfw_end_flow_88xx(pHalmac_adapter))
614 goto DLFW_FAIL;
615
616 pHalmac_adapter->halmac_state.dlfw_state = HALMAC_DLFW_DONE;
617
618
619 if (_TRUE == pHalmac_adapter->gen_info_valid) {
620 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Auto send halmac_send_general_info after redownload fw\n");
621 status = halmac_send_general_info_88xx(pHalmac_adapter, &(pHalmac_adapter->general_info));
622
623 if (HALMAC_RET_SUCCESS != status) {
624 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_send_general_info error = %x\n", status);
625 return status;
626 }
627 if (HALMAC_DLFW_DONE == pHalmac_adapter->halmac_state.dlfw_state)
628 pHalmac_adapter->halmac_state.dlfw_state = HALMAC_GEN_INFO_SENT;
629 }
630
631 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_download_firmware_88xx <==========\n");
632
633 return HALMAC_RET_SUCCESS;
634
635 DLFW_FAIL:
636
637 /* Disable FWDL_EN */
638 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_MCUFW_CTRL) & ~(BIT(0))));
639
640 return HALMAC_RET_DLFW_FAIL;
641 }
642
643 /**
644 * halmac_get_fw_version_88xx() - get FW version
645 * @pHalmac_adapter
646 * @pFw_version
647 * Author : Ivan Lin
648 * Return : HALMAC_RET_STATUS
649 */
650 HALMAC_RET_STATUS
halmac_get_fw_version_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT PHALMAC_FW_VERSION pFw_version)651 halmac_get_fw_version_88xx(
652 IN PHALMAC_ADAPTER pHalmac_adapter,
653 OUT PHALMAC_FW_VERSION pFw_version
654 )
655 {
656 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
657 return HALMAC_RET_ADAPTER_INVALID;
658
659 if (0 == pHalmac_adapter->halmac_state.dlfw_state) {
660 return HALMAC_RET_DLFW_FAIL;
661 } else {
662 pFw_version->version = pHalmac_adapter->fw_version.version;
663 pFw_version->sub_version = pHalmac_adapter->fw_version.sub_version;
664 pFw_version->sub_index = pHalmac_adapter->fw_version.sub_index;
665 }
666
667 return HALMAC_RET_SUCCESS;
668 }
669
670 /**
671 * halmac_cfg_mac_addr_88xx() - config Mac Address
672 * @pHalmac_adapter
673 * @halmac_port : 0 : port0 1 : port1
674 * @pHal_address : mac address
675 * Author : KaiYuan Chang/Ivan Lin
676 * Return : HALMAC_RET_STATUS
677 */
678 HALMAC_RET_STATUS
halmac_cfg_mac_addr_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 halmac_port,IN PHALMAC_WLAN_ADDR pHal_address)679 halmac_cfg_mac_addr_88xx(
680 IN PHALMAC_ADAPTER pHalmac_adapter,
681 IN u8 halmac_port,
682 IN PHALMAC_WLAN_ADDR pHal_address
683 )
684 {
685 u16 mac_address_H;
686 u32 mac_address_L;
687 VOID *pDriver_adapter = NULL;
688 PHALMAC_API pHalmac_api;
689
690 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
691 return HALMAC_RET_ADAPTER_INVALID;
692
693 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
694 return HALMAC_RET_API_INVALID;
695
696 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_MAC_ADDR);
697
698 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
699 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
700
701 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_mac_addr_88xx ==========>\n");
702
703 if (halmac_port > 2) {
704 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "port index > 2\n");
705 return HALMAC_RET_PORT_NOT_SUPPORT;
706 }
707
708 mac_address_L = pHal_address->Address_L_H.Address_Low;
709 mac_address_H = pHal_address->Address_L_H.Address_High;
710
711 mac_address_L = rtk_le32_to_cpu(mac_address_L);
712 mac_address_H = rtk_le16_to_cpu(mac_address_H);
713
714 pHalmac_adapter->pHal_mac_addr[halmac_port].Address_L_H.Address_Low = mac_address_L;
715 pHalmac_adapter->pHal_mac_addr[halmac_port].Address_L_H.Address_High = mac_address_H;
716
717 if (0 == halmac_port) {
718 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MACID, mac_address_L);
719 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MACID + 4, mac_address_H);
720 } else {
721 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MACID1, mac_address_L);
722 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MACID1 + 4, mac_address_H);
723 }
724
725 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_mac_addr_88xx <==========\n");
726
727 return HALMAC_RET_SUCCESS;
728 }
729
730 /**
731 * halmac_cfg_bssid_88xx() - config BSSID
732 * @pHalmac_adapter
733 * @halmac_port : 0 : port0 1 : port1
734 * @pHal_address : mac address
735 * Author : KaiYuan Chang/Ivan Lin
736 * Return : HALMAC_RET_STATUS
737 */
738 HALMAC_RET_STATUS
halmac_cfg_bssid_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 halmac_port,IN PHALMAC_WLAN_ADDR pHal_address)739 halmac_cfg_bssid_88xx(
740 IN PHALMAC_ADAPTER pHalmac_adapter,
741 IN u8 halmac_port,
742 IN PHALMAC_WLAN_ADDR pHal_address
743 )
744 {
745 u16 bssid_address_H;
746 u32 bssid_address_L;
747 VOID *pDriver_adapter = NULL;
748 PHALMAC_API pHalmac_api;
749
750 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
751 return HALMAC_RET_ADAPTER_INVALID;
752
753 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
754 return HALMAC_RET_API_INVALID;
755
756 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_BSSID);
757
758 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
759 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
760
761 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_bssid_88xx ==========>\n");
762
763 if (halmac_port > 2) {
764 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "port index > 2\n");
765 return HALMAC_RET_PORT_NOT_SUPPORT;
766 }
767
768 bssid_address_L = pHal_address->Address_L_H.Address_Low;
769 bssid_address_H = pHal_address->Address_L_H.Address_High;
770
771 bssid_address_L = rtk_le32_to_cpu(bssid_address_L);
772 bssid_address_H = rtk_le16_to_cpu(bssid_address_H);
773
774 pHalmac_adapter->pHal_bss_addr[halmac_port].Address_L_H.Address_Low = bssid_address_L;
775 pHalmac_adapter->pHal_bss_addr[halmac_port].Address_L_H.Address_High = bssid_address_H;
776
777 if (0 == halmac_port) {
778 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_BSSID, bssid_address_L);
779 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_BSSID + 4, bssid_address_H);
780 } else {
781 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_BSSID1, bssid_address_L);
782 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_BSSID1 + 4, bssid_address_H);
783 }
784
785 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_bssid_88xx <==========\n");
786
787 return HALMAC_RET_SUCCESS;
788 }
789
790 /**
791 * halmac_cfg_multicast_addr_88xx() - config multicast address
792 * @pHalmac_adapter
793 * @pHal_address : mac address
794 * Author : KaiYuan Chang/Ivan Lin
795 * Return : HALMAC_RET_STATUS
796 */
797 HALMAC_RET_STATUS
halmac_cfg_multicast_addr_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_WLAN_ADDR pHal_address)798 halmac_cfg_multicast_addr_88xx(
799 IN PHALMAC_ADAPTER pHalmac_adapter,
800 IN PHALMAC_WLAN_ADDR pHal_address
801 )
802 {
803 u16 address_H;
804 u32 address_L;
805 VOID *pDriver_adapter = NULL;
806 PHALMAC_API pHalmac_api;
807
808 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
809 return HALMAC_RET_ADAPTER_INVALID;
810
811 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
812 return HALMAC_RET_API_INVALID;
813
814 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_MULTICAST_ADDR);
815
816 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
817 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
818
819 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_multicast_addr_88xx ==========>\n");
820
821 address_L = pHal_address->Address_L_H.Address_Low;
822 address_H = pHal_address->Address_L_H.Address_High;
823
824 address_L = rtk_le32_to_cpu(address_L);
825 address_H = rtk_le16_to_cpu(address_H);
826
827 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MAR, address_L);
828 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MAR + 4, address_H);
829
830 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_multicast_addr_88xx <==========\n");
831
832 return HALMAC_RET_SUCCESS;
833 }
834
835 /**
836 * halmac_pre_init_system_cfg_88xx() - config system register before power on
837 * @pHalmac_adapter
838 * Author : KaiYuan Chang/Ivan Lin
839 * Return : HALMAC_RET_STATUS
840 */
841 HALMAC_RET_STATUS
halmac_pre_init_system_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)842 halmac_pre_init_system_cfg_88xx(
843 IN PHALMAC_ADAPTER pHalmac_adapter
844 )
845 {
846 u32 value32;
847 VOID *pDriver_adapter = NULL;
848 PHALMAC_API pHalmac_api;
849 u8 enable_bb;
850
851 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
852 return HALMAC_RET_ADAPTER_INVALID;
853
854 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
855 return HALMAC_RET_API_INVALID;
856
857 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_PRE_INIT_SYSTEM_CFG);
858
859 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
860 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
861
862 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_pre_init_system_cfg ==========>\n");
863
864 /* Config PIN Mux */
865 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_PAD_CTRL1);
866 value32 = value32 & (~(BIT(28) | BIT(29)));
867 value32 = value32 | BIT(28) | BIT(29);
868 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_PAD_CTRL1, value32);
869
870 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_LED_CFG);
871 value32 = value32 & (~(BIT(25) | BIT(26)));
872 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_LED_CFG, value32);
873
874 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_GPIO_MUXCFG);
875 value32 = value32 & (~(BIT(2)));
876 value32 = value32 | BIT(2);
877 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_GPIO_MUXCFG, value32);
878
879 enable_bb = _FALSE;
880 halmac_set_hw_value_88xx(pHalmac_adapter, HALMAC_HW_EN_BB_RF, &enable_bb);
881
882
883 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_pre_init_system_cfg <==========\n");
884
885 return HALMAC_RET_SUCCESS;
886 }
887
888 /**
889 * halmac_init_system_cfg_88xx() - config system register after power on
890 * @pHalmac_adapter
891 * Author : KaiYuan Chang/Ivan Lin
892 * Return : HALMAC_RET_STATUS
893 */
894 HALMAC_RET_STATUS
halmac_init_system_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)895 halmac_init_system_cfg_88xx(
896 IN PHALMAC_ADAPTER pHalmac_adapter
897 )
898 {
899 VOID *pDriver_adapter = NULL;
900 PHALMAC_API pHalmac_api;
901
902
903 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
904 return HALMAC_RET_ADAPTER_INVALID;
905
906 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
907 return HALMAC_RET_API_INVALID;
908
909 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_SYSTEM_CFG);
910
911 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
912 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
913
914 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_system_cfg ==========>\n");
915
916 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SYS_FUNC_EN + 1, HALMAC_FUNCTION_ENABLE_88XX);
917 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_SYS_SDIO_CTRL, (u32)(HALMAC_REG_READ_32(pHalmac_adapter, REG_SYS_SDIO_CTRL) | BIT_LTE_MUX_CTRL_PATH));
918 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_CPU_DMEM_CON, (u32)(HALMAC_REG_READ_32(pHalmac_adapter, REG_CPU_DMEM_CON) | BIT_WL_PLATFORM_RST));
919
920 /* pHalmac_api->halmac_init_h2c(pHalmac_adapter); */
921
922 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_system_cfg <==========\n");
923
924 return HALMAC_RET_SUCCESS;
925 }
926
927 /**
928 * halmac_init_protocol_cfg_88xx() - config protocol related register
929 * @pHalmac_adapter
930 * Author : KaiYuan Chang/Ivan Lin
931 * Return : HALMAC_RET_STATUS
932 */
933 HALMAC_RET_STATUS
halmac_init_protocol_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)934 halmac_init_protocol_cfg_88xx(
935 IN PHALMAC_ADAPTER pHalmac_adapter
936 )
937 {
938 u16 value16;
939 u32 value32;
940 VOID *pDriver_adapter = NULL;
941 PHALMAC_API pHalmac_api;
942
943 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
944 return HALMAC_RET_ADAPTER_INVALID;
945
946 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
947 return HALMAC_RET_API_INVALID;
948
949 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_PROTOCOL_CFG);
950
951 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
952 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
953
954 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_protocol_cfg_88xx ==========>\n");
955
956 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BASIC_CFEND_RATE, HALMAC_BASIC_CFEND_RATE_88XX);
957 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_STBC_CFEND_RATE, HALMAC_STBC_CFEND_RATE_88XX);
958
959 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_RRSR);
960 value32 = (value32 & ~BIT_MASK_RRSC_BITMAP) | HALMAC_RESPONSE_RATE_88XX;
961 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RRSR, value32);
962
963 value16 = HALMAC_SIFS_CCK_PTCL_88XX | (HALMAC_SIFS_OFDM_PTCL_88XX << BIT_SHIFT_SPEC_SIFS_OFDM_PTCL);
964 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_SPEC_SIFS, value16);
965
966 value16 = BIT_LRL(HALMAC_LONG_RETRY_LIMIT_88XX) | BIT_SRL(HALMAC_SHORT_RETRY_LIMIT_88XX);
967 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RETRY_LIMIT, value16);
968
969 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_protocol_cfg_88xx <==========\n");
970
971 return HALMAC_RET_SUCCESS;
972 }
973
974 /**
975 * halmac_init_edca_cfg_88xx() - config EDCA register
976 * @pHalmac_adapter
977 * Author : KaiYuan Chang/Ivan Lin
978 * Return : HALMAC_RET_STATUS
979 */
980 HALMAC_RET_STATUS
halmac_init_edca_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)981 halmac_init_edca_cfg_88xx(
982 IN PHALMAC_ADAPTER pHalmac_adapter
983 )
984 {
985 u8 value8;
986 u32 value32;
987 VOID *pDriver_adapter = NULL;
988 PHALMAC_API pHalmac_api;
989
990 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
991 return HALMAC_RET_ADAPTER_INVALID;
992
993 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
994 return HALMAC_RET_API_INVALID;
995
996 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_EDCA_CFG);
997
998 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
999 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1000
1001 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_edca_cfg_88xx ==========>\n");
1002
1003 /* Clear TX pause */
1004 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXPAUSE, 0x0000);
1005
1006 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SLOT, HALMAC_SLOT_TIME_88XX);
1007 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_PIFS, HALMAC_PIFS_TIME_88XX);
1008 value32 = HALMAC_SIFS_CCK_CTX_88XX | (HALMAC_SIFS_OFDM_CTX_88XX << BIT_SHIFT_SIFS_OFDM_CTX) |
1009 (HALMAC_SIFS_CCK_TRX_88XX << BIT_SHIFT_SIFS_CCK_TRX) | (HALMAC_SIFS_OFDM_TRX_88XX << BIT_SHIFT_SIFS_OFDM_TRX);
1010 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_SIFS, value32);
1011
1012 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_EDCA_VO_PARAM, HALMAC_REG_READ_32(pHalmac_adapter, REG_EDCA_VO_PARAM) & 0xFFFF);
1013 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_EDCA_VO_PARAM + 2, HALMAC_VO_TXOP_LIMIT_88XX);
1014 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_EDCA_VI_PARAM + 2, HALMAC_VI_TXOP_LIMIT_88XX);
1015
1016 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RD_NAV_NXT, HALMAC_RDG_NAV_88XX | (HALMAC_TXOP_NAV_88XX << 16));
1017 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RXTSF_OFFSET_CCK, HALMAC_CCK_RX_TSF_88XX | (HALMAC_OFDM_RX_TSF_88XX) << 8);
1018
1019 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_RD_CTRL + 1);
1020 value8 |= (BIT_VOQ_RD_INIT_EN | BIT_VIQ_RD_INIT_EN | BIT_BEQ_RD_INIT_EN);
1021 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RD_CTRL + 1, value8);
1022
1023 /* Set beacon cotrol - enable TSF and other related functions */
1024 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL) | BIT_EN_BCN_FUNCTION));
1025 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL_CLINT0, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL_CLINT0) | BIT_CLI0_EN_BCN_FUNCTION));
1026 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL_CLINT1, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL_CLINT1) | BIT_CLI1_EN_BCN_FUNCTION));
1027 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL_CLINT2, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL_CLINT2) | BIT_CLI2_EN_BCN_FUNCTION));
1028 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL_CLINT3, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL_CLINT3) | BIT_CLI3_EN_BCN_FUNCTION));
1029
1030 /* Set send beacon related registers */
1031 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_TBTT_PROHIBIT, HALMAC_TBTT_PROHIBIT_88XX | (HALMAC_TBTT_HOLD_TIME_88XX << BIT_SHIFT_TBTT_HOLD_TIME_AP));
1032 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_DRVERLYINT, HALMAC_DRIVER_EARLY_INT_88XX);
1033 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCNDMATIM, HALMAC_BEACON_DMA_TIM_88XX);
1034
1035 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_edca_cfg_88xx <==========\n");
1036
1037 return HALMAC_RET_SUCCESS;
1038 }
1039
1040 /**
1041 * halmac_init_wmac_cfg_88xx() - config WMAC register
1042 * @pHalmac_adapter
1043 * Author : KaiYuan Chang/Ivan Lin
1044 * Return : HALMAC_RET_STATUS
1045 */
1046 HALMAC_RET_STATUS
halmac_init_wmac_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)1047 halmac_init_wmac_cfg_88xx(
1048 IN PHALMAC_ADAPTER pHalmac_adapter
1049 )
1050 {
1051 VOID *pDriver_adapter = NULL;
1052 PHALMAC_API pHalmac_api;
1053
1054 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1055 return HALMAC_RET_ADAPTER_INVALID;
1056
1057 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1058 return HALMAC_RET_API_INVALID;
1059
1060 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_WMAC_CFG);
1061
1062 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1063 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1064
1065 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_wmac_cfg_88xx ==========>\n");
1066
1067 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RXFLTMAP0, HALMAC_RX_FILTER0_88XX);
1068 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RXFLTMAP, HALMAC_RX_FILTER_88XX);
1069
1070 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RCR, HALMAC_RCR_CONFIG_88XX);
1071
1072 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_SECCFG, HALMAC_SECURITY_CONFIG_88XX);
1073
1074 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TCR + 1, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_TCR + 1) | 0x30));
1075 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TCR + 2, 0x30);
1076 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TCR + 1, 0x00);
1077
1078 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WMAC_OPTION_FUNCTION + 8, 0x30810041);
1079 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WMAC_OPTION_FUNCTION + 4, 0x50802080);
1080 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WL2LTECOEX_INDIRECT_ACCESS_CTRL_V1, 0xC00F0038);
1081
1082 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_wmac_cfg_88xx <==========\n");
1083
1084 return HALMAC_RET_SUCCESS;
1085 }
1086
1087 /**
1088 * halmac_init_mac_cfg_88xx() - config page1~page7 register
1089 * @pHalmac_adapter
1090 * @mode : normal, trxshare, wmm, p2p, loopback
1091 * Author : KaiYuan Chang/Ivan Lin
1092 * Return : HALMAC_RET_STATUS
1093 */
1094 HALMAC_RET_STATUS
halmac_init_mac_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_TRX_MODE mode)1095 halmac_init_mac_cfg_88xx(
1096 IN PHALMAC_ADAPTER pHalmac_adapter,
1097 IN HALMAC_TRX_MODE mode
1098 )
1099 {
1100 VOID *pDriver_adapter = NULL;
1101 PHALMAC_API pHalmac_api;
1102 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1103
1104 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1105 return HALMAC_RET_ADAPTER_INVALID;
1106
1107 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1108 return HALMAC_RET_API_INVALID;
1109
1110 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_MAC_CFG);
1111
1112 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1113 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1114
1115 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_mac_cfg_88xx ==========>mode = %d\n", mode);
1116
1117 status = pHalmac_api->halmac_init_trx_cfg(pHalmac_adapter, mode);
1118 if (HALMAC_RET_SUCCESS != status) {
1119 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_init_trx_cfg errorr = %x\n", status);
1120 return status;
1121 }
1122 #if 1
1123 status = halmac_init_protocol_cfg_88xx(pHalmac_adapter);
1124 if (HALMAC_RET_SUCCESS != status) {
1125 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_init_protocol_cfg_88xx error = %x\n", status);
1126 return status;
1127 }
1128
1129 status = halmac_init_edca_cfg_88xx(pHalmac_adapter);
1130 if (HALMAC_RET_SUCCESS != status) {
1131 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_init_edca_cfg_88xx error = %x\n", status);
1132 return status;
1133 }
1134
1135 status = halmac_init_wmac_cfg_88xx(pHalmac_adapter);
1136 if (HALMAC_RET_SUCCESS != status) {
1137 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_init_wmac_cfg_88xx error = %x\n", status);
1138 return status;
1139 }
1140 #endif
1141 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_mac_cfg_88xx <==========\n");
1142
1143 return status;
1144 }
1145
1146 /**
1147 * halmac_cfg_operation_mode_88xx() - config operation mode
1148 * @pHalmac_adapter
1149 * @wireless_mode : b/g/n/ac
1150 * Author : KaiYuan Chang/Ivan Lin
1151 * Return : HALMAC_RET_STATUS
1152 */
1153 HALMAC_RET_STATUS
halmac_cfg_operation_mode_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_WIRELESS_MODE wireless_mode)1154 halmac_cfg_operation_mode_88xx(
1155 IN PHALMAC_ADAPTER pHalmac_adapter,
1156 IN HALMAC_WIRELESS_MODE wireless_mode
1157 )
1158 {
1159 VOID *pDriver_adapter = NULL;
1160 HALMAC_WIRELESS_MODE wireless_mode_local = HALMAC_WIRELESS_MODE_UNDEFINE;
1161
1162 wireless_mode_local = wireless_mode;
1163
1164 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1165 return HALMAC_RET_ADAPTER_INVALID;
1166
1167 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1168 return HALMAC_RET_API_INVALID;
1169
1170 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_OPERATION_MODE);
1171 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_operation_mode_88xx ==========>wireless_mode = %d\n", wireless_mode);
1172
1173 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1174
1175 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_operation_mode_88xx <==========\n");
1176
1177 return HALMAC_RET_SUCCESS;
1178 }
1179
1180 /**
1181 * halmac_cfg_bw_88xx() - config channel & bandwidth
1182 * @pHalmac_adapter
1183 * @channel : WLAN channel, support 2.4G & 5G
1184 * @pri_ch_idx : idx1, idx2, idx3, idx4
1185 * @bw : 20, 40, 80, 160, 5 ,10
1186 * Author : KaiYuan Chang
1187 * Return : HALMAC_RET_STATUS
1188 */
1189 HALMAC_RET_STATUS
halmac_cfg_ch_bw_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 channel,IN HALMAC_PRI_CH_IDX pri_ch_idx,IN HALMAC_BW bw)1190 halmac_cfg_ch_bw_88xx(
1191 IN PHALMAC_ADAPTER pHalmac_adapter,
1192 IN u8 channel,
1193 IN HALMAC_PRI_CH_IDX pri_ch_idx,
1194 IN HALMAC_BW bw
1195 )
1196 {
1197 VOID *pDriver_adapter = NULL;
1198 PHALMAC_API pHalmac_api;
1199
1200 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1201 return HALMAC_RET_ADAPTER_INVALID;
1202
1203 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1204 return HALMAC_RET_API_INVALID;
1205
1206 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_CH_BW);
1207
1208 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1209 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1210
1211 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_ch_bw_88xx ==========>ch = %d, idx=%d, bw=%d\n", channel, pri_ch_idx, bw);
1212
1213 halmac_cfg_pri_ch_idx_88xx(pHalmac_adapter, pri_ch_idx);
1214
1215 halmac_cfg_bw_88xx(pHalmac_adapter, bw);
1216
1217 halmac_cfg_ch_88xx(pHalmac_adapter, channel);
1218
1219 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_ch_bw_88xx <==========\n");
1220
1221 return HALMAC_RET_SUCCESS;
1222 }
1223
1224
1225 /**
1226 * halmac_cfg_bw_88xx() - config channel & bandwidth
1227 * @pHalmac_adapter
1228 * @channel : WLAN channel, support 2.4G & 5G
1229 * @pri_ch_idx : idx1, idx2, idx3, idx4
1230 * @bw : 20, 40, 80, 160, 5 ,10
1231 * Author : KaiYuan Chang
1232 * Return : HALMAC_RET_STATUS
1233 */
1234 HALMAC_RET_STATUS
halmac_cfg_ch_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 channel)1235 halmac_cfg_ch_88xx(
1236 IN PHALMAC_ADAPTER pHalmac_adapter,
1237 IN u8 channel
1238 )
1239 {
1240 u8 value8;
1241 VOID *pDriver_adapter = NULL;
1242 PHALMAC_API pHalmac_api;
1243
1244 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1245 return HALMAC_RET_ADAPTER_INVALID;
1246
1247 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1248 return HALMAC_RET_API_INVALID;
1249
1250 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_CH_BW);
1251
1252 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1253 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1254
1255 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_ch_88xx ==========>ch = %d\n", channel);
1256
1257 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_CCK_CHECK);
1258 value8 = value8 & (~(BIT(7)));
1259
1260 if (channel > 35)
1261 value8 = value8 | BIT(7);
1262
1263 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CCK_CHECK, value8);
1264
1265 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_ch_88xx <==========\n");
1266
1267 return HALMAC_RET_SUCCESS;
1268 }
1269
1270 /**
1271 * halmac_cfg_bw_88xx() - config channel & bandwidth
1272 * @pHalmac_adapter
1273 * @channel : WLAN channel, support 2.4G & 5G
1274 * @pri_ch_idx : idx1, idx2, idx3, idx4
1275 * @bw : 20, 40, 80, 160, 5 ,10
1276 * Author : KaiYuan Chang
1277 * Return : HALMAC_RET_STATUS
1278 */
1279 HALMAC_RET_STATUS
halmac_cfg_pri_ch_idx_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_PRI_CH_IDX pri_ch_idx)1280 halmac_cfg_pri_ch_idx_88xx(
1281 IN PHALMAC_ADAPTER pHalmac_adapter,
1282 IN HALMAC_PRI_CH_IDX pri_ch_idx
1283 )
1284 {
1285 u8 txsc_40 = 0, txsc_20 = 0;
1286 VOID *pDriver_adapter = NULL;
1287 PHALMAC_API pHalmac_api;
1288
1289 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1290 return HALMAC_RET_ADAPTER_INVALID;
1291
1292 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1293 return HALMAC_RET_API_INVALID;
1294
1295 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_CH_BW);
1296
1297 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1298 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1299
1300 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_pri_ch_idx_88xx ==========> idx=%d\n", pri_ch_idx);
1301
1302 txsc_20 = pri_ch_idx;
1303 if ((HALMAC_CH_IDX_1 == txsc_20) || (HALMAC_CH_IDX_3 == txsc_20))
1304 txsc_40 = 9;
1305 else
1306 txsc_40 = 10;
1307
1308 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_DATA_SC, BIT_TXSC_20M(txsc_20) | BIT_TXSC_40M(txsc_40));
1309
1310 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_pri_ch_idx_88xx <==========\n");
1311
1312 return HALMAC_RET_SUCCESS;
1313
1314 }
1315
1316 /**
1317 * halmac_cfg_bw_88xx() - config bandwidth
1318 * @pHalmac_adapter
1319 * @bw : 20, 40, 80, 160, 5 ,10
1320 * Author : KaiYuan Chang
1321 * Return : HALMAC_RET_STATUS
1322 */
1323 HALMAC_RET_STATUS
halmac_cfg_bw_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_BW bw)1324 halmac_cfg_bw_88xx(
1325 IN PHALMAC_ADAPTER pHalmac_adapter,
1326 IN HALMAC_BW bw
1327 )
1328 {
1329 u32 value32;
1330 VOID *pDriver_adapter = NULL;
1331 PHALMAC_API pHalmac_api;
1332
1333 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1334 return HALMAC_RET_ADAPTER_INVALID;
1335
1336 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1337 return HALMAC_RET_API_INVALID;
1338
1339 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_BW);
1340
1341 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1342 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1343
1344 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_bw_88xx ==========>bw=%d\n", bw);
1345
1346 /* RF Mode */
1347 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_WMAC_TRXPTCL_CTL);
1348 value32 = value32 & (~(BIT(7) | BIT(8)));
1349
1350 switch (bw) {
1351 case HALMAC_BW_80:
1352 value32 = value32 | BIT(7);
1353 break;
1354 case HALMAC_BW_40:
1355 value32 = value32 | BIT(8);
1356 break;
1357 case HALMAC_BW_20:
1358 case HALMAC_BW_10:
1359 case HALMAC_BW_5:
1360 value32 = value32;
1361 break;
1362 default:
1363 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_cfg_bw_88xx switch case not support\n");
1364 break;
1365 }
1366 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WMAC_TRXPTCL_CTL, value32);
1367
1368 /* MAC CLK */
1369 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_AFE_CTRL1);
1370 value32 = (value32 & (~(BIT(20) | BIT(21)))) | (HALMAC_MAC_CLOCK_HW_DEF_80M << BIT_SHIFT_MAC_CLK_SEL);
1371 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_AFE_CTRL1, value32);
1372
1373 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_USTIME_TSF, HALMAC_MAC_CLOCK_88XX);
1374 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_USTIME_EDCA, HALMAC_MAC_CLOCK_88XX);
1375
1376 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_bw_88xx <==========\n");
1377
1378 return HALMAC_RET_SUCCESS;
1379 }
1380
1381 /**
1382 * halmac_clear_security_cam_88xx() - clear security CAM
1383 * @pHalmac_adapter
1384 * Author : KaiYuan Chang
1385 * Return : HALMAC_RET_STATUS
1386 */
1387 HALMAC_RET_STATUS
halmac_clear_security_cam_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)1388 halmac_clear_security_cam_88xx(
1389 IN PHALMAC_ADAPTER pHalmac_adapter
1390 )
1391 {
1392 VOID *pDriver_adapter = NULL;
1393
1394 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1395 return HALMAC_RET_ADAPTER_INVALID;
1396
1397 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1398 return HALMAC_RET_API_INVALID;
1399
1400 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1401
1402 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_clear_security_cam_88xx ==========>\n");
1403
1404 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_clear_security_cam_88xx <==========\n");
1405
1406 return HALMAC_RET_SUCCESS;
1407 }
1408
1409 /**
1410 * halmac_dump_efuse_map_88xx() - dump "physical" efuse map
1411 * @pHalmac_adapter
1412 * @cfg : dump with auto/driver/FW
1413 * Author : Ivan Lin/KaiYuan Chang
1414 *
1415 * halmac_dump_efuse_map_88xx is async architecture, user can
1416 * refer to DumpEfuseMap page of FlowChart.vsd.
1417 * dump_efuse_map page of Halmac_flow_control.vsd is halmac api control
1418 * flow, only for SD1 internal use.
1419 *
1420 * Return : HALMAC_RET_STATUS
1421 */
1422 HALMAC_RET_STATUS
halmac_dump_efuse_map_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_READ_CFG cfg)1423 halmac_dump_efuse_map_88xx(
1424 IN PHALMAC_ADAPTER pHalmac_adapter,
1425 IN HALMAC_EFUSE_READ_CFG cfg
1426 )
1427 {
1428 VOID *pDriver_adapter = NULL;
1429 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1430 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1431
1432 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1433 return HALMAC_RET_ADAPTER_INVALID;
1434
1435 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1436 return HALMAC_RET_API_INVALID;
1437
1438 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DUMP_EFUSE_MAP);
1439
1440 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1441
1442 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_dump_efuse_map_88xx ==========>cfg=%d\n", cfg);
1443
1444 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1445 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(dump efuse)...\n");
1446 return HALMAC_RET_BUSY_STATE;
1447 }
1448
1449 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1450 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1451 return HALMAC_RET_ERROR_STATE;
1452 }
1453
1454 *pProcess_status = HALMAC_CMD_PROCESS_IDLE;
1455 pHalmac_adapter->event_trigger.physical_efuse_map = 1;
1456
1457 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, HALMAC_EFUSE_BANK_WIFI);
1458 if (HALMAC_RET_SUCCESS != status) {
1459 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1460 return status;
1461 }
1462
1463 status = halmac_dump_efuse_88xx(pHalmac_adapter, cfg);
1464
1465 if (HALMAC_RET_SUCCESS != status) {
1466 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_efuse error = %x\n", status);
1467 return status;
1468 }
1469
1470 if (_TRUE == pHalmac_adapter->hal_efuse_map_valid) {
1471 *pProcess_status = HALMAC_CMD_PROCESS_DONE;
1472
1473 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE, *pProcess_status,
1474 pHalmac_adapter->pHalEfuse_map, pHalmac_adapter->hw_config_info.efuse_size);
1475 pHalmac_adapter->event_trigger.physical_efuse_map = 0;
1476 }
1477
1478 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
1479 return HALMAC_RET_ERROR_STATE;
1480
1481 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_dump_efuse_map_88xx <==========\n");
1482
1483 return HALMAC_RET_SUCCESS;
1484 }
1485
1486 /**
1487 * halmac_dump_efuse_map_bt_88xx() - dump "BT physical" efuse map
1488 * @pHalmac_adapter
1489 * @cfg : dump with auto/driver/FW
1490 * Author : Soar / Ivan Lin
1491 *
1492 * halmac_dump_efuse_map_bt_88xx is async architecture, user can
1493 * refer to DumpEfuseMap page of FlowChart.vsd.
1494 * dump_efuse_map_bt page of Halmac_flow_control.vsd is halmac api control
1495 * flow, only for SD1 internal use.
1496 *
1497 * Return : HALMAC_RET_STATUS
1498 */
1499 HALMAC_RET_STATUS
halmac_dump_efuse_map_bt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_BANK halmac_efuse_bank,IN u32 bt_efuse_map_size,OUT u8 * pBT_efuse_map)1500 halmac_dump_efuse_map_bt_88xx(
1501 IN PHALMAC_ADAPTER pHalmac_adapter,
1502 IN HALMAC_EFUSE_BANK halmac_efuse_bank,
1503 IN u32 bt_efuse_map_size,
1504 OUT u8 *pBT_efuse_map
1505 )
1506 {
1507 VOID *pDriver_adapter = NULL;
1508 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1509 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1510
1511 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1512 return HALMAC_RET_ADAPTER_INVALID;
1513
1514 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1515 return HALMAC_RET_API_INVALID;
1516
1517 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DUMP_EFUSE_MAP_BT);
1518
1519 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1520
1521 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_dump_efuse_map_bt_88xx ==========>\n");
1522
1523 if (pHalmac_adapter->hw_config_info.bt_efuse_size != bt_efuse_map_size)
1524 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
1525
1526 if ((halmac_efuse_bank >= HALMAC_EFUSE_BANK_MAX) || (halmac_efuse_bank == HALMAC_EFUSE_BANK_WIFI)) {
1527 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Undefined BT bank\n");
1528 return HALMAC_RET_EFUSE_BANK_INCORRECT;
1529 }
1530
1531 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1532 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(dump efuse)...\n");
1533 return HALMAC_RET_BUSY_STATE;
1534 }
1535
1536 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1537 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1538 return HALMAC_RET_ERROR_STATE;
1539 }
1540
1541 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, halmac_efuse_bank);
1542 if (HALMAC_RET_SUCCESS != status) {
1543 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1544 return status;
1545 }
1546
1547 status = halmac_read_hw_efuse_88xx(pHalmac_adapter, 0, bt_efuse_map_size, pBT_efuse_map);
1548
1549 if (HALMAC_RET_SUCCESS != status) {
1550 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_hw_efuse_88xx error = %x\n", status);
1551 return status;
1552 }
1553
1554 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
1555 return HALMAC_RET_ERROR_STATE;
1556
1557 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_dump_efuse_map_bt_88xx <==========\n");
1558
1559 return HALMAC_RET_SUCCESS;
1560 }
1561
1562 /**
1563 * halmac_read_efuse_88xx() - read "physical" efuse offset
1564 * @pHalmac_adapter
1565 * @halmac_offset
1566 * @pValue
1567 * Author : Ivan Lin/KaiYuan Chang
1568 * Return : HALMAC_RET_STATUS
1569 */
1570 /*
1571 * HALMAC_RET_STATUS
1572 * halmac_read_efuse_88xx(
1573 * IN PHALMAC_ADAPTER pHalmac_adapter,
1574 * IN u32 halmac_offset,
1575 * OUT u8 *pValue
1576 *)
1577 */
1578
1579 /**
1580 * halmac_write_efuse_88xx() - write "physical" efuse offset
1581 * @pHalmac_adapter
1582 * @halmac_offset
1583 * @halmac_value
1584 * Author : Ivan Lin/KaiYuan Chang
1585 * Return : HALMAC_RET_STATUS
1586 */
1587 /*
1588 * HALMAC_RET_STATUS
1589 * halmac_write_efuse_88xx(
1590 * IN PHALMAC_ADAPTER pHalmac_adapter,
1591 * IN u32 halmac_offset,
1592 * IN u8 halmac_value
1593 *)
1594 */
1595
1596 /**
1597 * halmac_write_efuse_bt_88xx() - write "BT physical" efuse offset
1598 * @pHalmac_adapter
1599 * @halmac_offset
1600 * @halmac_value
1601 * Author : Soar
1602 * Return : HALMAC_RET_STATUS
1603 */
1604 HALMAC_RET_STATUS
halmac_write_efuse_bt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,IN u8 halmac_value,IN HALMAC_EFUSE_BANK halmac_efuse_bank)1605 halmac_write_efuse_bt_88xx(
1606 IN PHALMAC_ADAPTER pHalmac_adapter,
1607 IN u32 halmac_offset,
1608 IN u8 halmac_value,
1609 IN HALMAC_EFUSE_BANK halmac_efuse_bank
1610 )
1611 {
1612 VOID *pDriver_adapter = NULL;
1613 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1614
1615
1616 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1617
1618 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1619 return HALMAC_RET_ADAPTER_INVALID;
1620
1621 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1622 return HALMAC_RET_API_INVALID;
1623
1624 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_WRITE_EFUSE_BT);
1625
1626 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1627
1628 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_write_efuse_bt_88xx ==========>\n");
1629 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "offset : %X value : %X Bank : %X\n", halmac_offset, halmac_value, halmac_efuse_bank);
1630
1631 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1632 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait/Rcvd event(dump efuse)...\n");
1633 return HALMAC_RET_BUSY_STATE;
1634 }
1635
1636 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1637 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1638 return HALMAC_RET_ERROR_STATE;
1639 }
1640
1641 if (halmac_offset >= pHalmac_adapter->hw_config_info.efuse_size) {
1642 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Offset is too large\n");
1643 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
1644 }
1645
1646 if ((halmac_efuse_bank > HALMAC_EFUSE_BANK_MAX) || (halmac_efuse_bank == HALMAC_EFUSE_BANK_WIFI)) {
1647 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Undefined BT bank\n");
1648 return HALMAC_RET_EFUSE_BANK_INCORRECT;
1649 }
1650
1651 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, halmac_efuse_bank);
1652 if (HALMAC_RET_SUCCESS != status) {
1653 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1654 return status;
1655 }
1656
1657 status = halmac_func_write_efuse_88xx(pHalmac_adapter, halmac_offset, halmac_value);
1658 if (HALMAC_RET_SUCCESS != status) {
1659 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_write_efuse error = %x\n", status);
1660 return status;
1661 }
1662
1663 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
1664 return HALMAC_RET_ERROR_STATE;
1665
1666 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_write_efuse_bt_88xx <==========\n");
1667
1668 return HALMAC_RET_SUCCESS;
1669 }
1670
1671 /**
1672 * halmac_get_efuse_available_size_88xx() - get efuse available size
1673 * @pHalmac_adapter : the adapter of halmac
1674 * @halmac_size : physical efuse available size
1675 * Author : Soar
1676 * Return : HALMAC_RET_STATUS
1677 * More details of status code can be found in prototype document
1678 */
1679 HALMAC_RET_STATUS
halmac_get_efuse_available_size_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u32 * halmac_size)1680 halmac_get_efuse_available_size_88xx(
1681 IN PHALMAC_ADAPTER pHalmac_adapter,
1682 OUT u32 *halmac_size
1683 )
1684 {
1685 HALMAC_RET_STATUS status;
1686 VOID *pDriver_adapter = NULL;
1687
1688 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1689 return HALMAC_RET_ADAPTER_INVALID;
1690
1691 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1692 return HALMAC_RET_API_INVALID;
1693
1694 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1695
1696 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_efuse_available_size_88xx ==========>\n");
1697
1698 status = halmac_dump_logical_efuse_map_88xx(pHalmac_adapter, HALMAC_EFUSE_R_DRV);
1699
1700 if (HALMAC_RET_SUCCESS != status)
1701 return status;
1702
1703 *halmac_size = pHalmac_adapter->hw_config_info.efuse_size - HALMAC_PROTECTED_EFUSE_SIZE_88XX - pHalmac_adapter->efuse_end;
1704
1705 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_efuse_available_size_88xx <==========\n");
1706
1707 return HALMAC_RET_SUCCESS;
1708 }
1709
1710 /**
1711 * halmac_get_efuse_size_88xx() - get "physical" efuse size
1712 * @pHalmac_adapter
1713 * @halmac_size : Output physical efuse size
1714 * Author : Ivan Lin/KaiYuan Chang
1715 * Return : HALMAC_RET_STATUS
1716 */
1717 HALMAC_RET_STATUS
halmac_get_efuse_size_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u32 * halmac_size)1718 halmac_get_efuse_size_88xx(
1719 IN PHALMAC_ADAPTER pHalmac_adapter,
1720 OUT u32 *halmac_size
1721 )
1722 {
1723 VOID *pDriver_adapter = NULL;
1724
1725 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1726 return HALMAC_RET_ADAPTER_INVALID;
1727
1728 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1729 return HALMAC_RET_API_INVALID;
1730
1731 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_EFUSE_SIZE);
1732
1733 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1734
1735 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_efuse_size_88xx ==========>\n");
1736
1737 *halmac_size = pHalmac_adapter->hw_config_info.efuse_size;
1738
1739 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_efuse_size_88xx <==========\n");
1740
1741 return HALMAC_RET_SUCCESS;
1742 }
1743
1744 /**
1745 * halmac_get_logical_efuse_size_88xx() - get "logical" efuse size
1746 * @pHalmac_adapter
1747 * @halmac_size : Output logical efuse size
1748 * Author : Ivan Lin/KaiYuan Chang
1749 * Return : HALMAC_RET_STATUS
1750 */
1751 HALMAC_RET_STATUS
halmac_get_logical_efuse_size_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u32 * halmac_size)1752 halmac_get_logical_efuse_size_88xx(
1753 IN PHALMAC_ADAPTER pHalmac_adapter,
1754 OUT u32 *halmac_size
1755 )
1756 {
1757 VOID *pDriver_adapter = NULL;
1758
1759 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1760 return HALMAC_RET_ADAPTER_INVALID;
1761
1762 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1763 return HALMAC_RET_API_INVALID;
1764
1765 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_LOGICAL_EFUSE_SIZE);
1766
1767 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1768
1769 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_logical_efuse_size_88xx ==========>\n");
1770
1771 *halmac_size = pHalmac_adapter->hw_config_info.eeprom_size;
1772
1773 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_get_logical_efuse_size_88xx <==========\n");
1774
1775 return HALMAC_RET_SUCCESS;
1776 }
1777
1778 /**
1779 * halmac_dump_logical_efuse_map_88xx() - dump "logical" efuse map
1780 * @pHalmac_adapter
1781 * @cfg : dump with auto/driver/FW
1782 * Author : Soar
1783 *
1784 * halmac_dump_logical_efuse_map_88xx is async architecture, user can
1785 * refer to DumpEEPROMMap page of FlowChart.vsd.
1786 * dump_efuse_map page of Halmac_flow_control.vsd is halmac api control
1787 * flow, only for SD1 internal use.
1788 *
1789 * Return : HALMAC_RET_STATUS
1790 */
1791 HALMAC_RET_STATUS
halmac_dump_logical_efuse_map_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_READ_CFG cfg)1792 halmac_dump_logical_efuse_map_88xx(
1793 IN PHALMAC_ADAPTER pHalmac_adapter,
1794 IN HALMAC_EFUSE_READ_CFG cfg
1795 )
1796 {
1797 u8 *pEeprom_map = NULL;
1798 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
1799 VOID *pDriver_adapter = NULL;
1800 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1801 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1802
1803 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1804 return HALMAC_RET_ADAPTER_INVALID;
1805
1806 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1807 return HALMAC_RET_API_INVALID;
1808
1809 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DUMP_LOGICAL_EFUSE_MAP);
1810
1811 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1812
1813 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_dump_logical_efuse_map_88xx ==========>cfg = %d\n", cfg);
1814
1815 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1816 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait/Rcvd event(dump efuse)...\n");
1817 return HALMAC_RET_BUSY_STATE;
1818 }
1819
1820 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1821 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1822 return HALMAC_RET_ERROR_STATE;
1823 }
1824
1825 *pProcess_status = HALMAC_CMD_PROCESS_IDLE;
1826 pHalmac_adapter->event_trigger.logical_efuse_map = 1;
1827
1828 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, HALMAC_EFUSE_BANK_WIFI);
1829 if (HALMAC_RET_SUCCESS != status) {
1830 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1831 return status;
1832 }
1833
1834 status = halmac_dump_efuse_88xx(pHalmac_adapter, cfg);
1835
1836 if (HALMAC_RET_SUCCESS != status) {
1837 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_eeprom_parser_88xx error = %x\n", status);
1838 return status;
1839 }
1840
1841 if (_TRUE == pHalmac_adapter->hal_efuse_map_valid) {
1842 *pProcess_status = HALMAC_CMD_PROCESS_DONE;
1843
1844 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
1845 if (NULL == pEeprom_map) {
1846 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
1847 return HALMAC_RET_MALLOC_FAIL;
1848 }
1849 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
1850
1851 if (HALMAC_RET_SUCCESS != halmac_eeprom_parser_88xx(pHalmac_adapter, pHalmac_adapter->pHalEfuse_map, pEeprom_map))
1852 return HALMAC_RET_EEPROM_PARSING_FAIL;
1853
1854 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_LOGICAL_EFUSE, *pProcess_status, pEeprom_map, eeprom_size);
1855 pHalmac_adapter->event_trigger.logical_efuse_map = 0;
1856
1857 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
1858 }
1859
1860 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
1861 return HALMAC_RET_ERROR_STATE;
1862
1863 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_dump_logical_efuse_map_88xx <==========\n");
1864
1865 return HALMAC_RET_SUCCESS;
1866 }
1867
1868 /**
1869 * halmac_read_logical_efuse_88xx() - read "logical" efuse offset
1870 * @pHalmac_adapter
1871 * @halmac_offset
1872 * @pValue
1873 * Author : Soar
1874 * Return : HALMAC_RET_STATUS
1875 */
1876 HALMAC_RET_STATUS
halmac_read_logical_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,OUT u8 * pValue)1877 halmac_read_logical_efuse_88xx(
1878 IN PHALMAC_ADAPTER pHalmac_adapter,
1879 IN u32 halmac_offset,
1880 OUT u8 *pValue
1881 )
1882 {
1883 u8 *pEeprom_map = NULL;
1884 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
1885 VOID *pDriver_adapter = NULL;
1886 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1887
1888 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1889
1890 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1891 return HALMAC_RET_ADAPTER_INVALID;
1892
1893 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1894 return HALMAC_RET_API_INVALID;
1895
1896 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_READ_LOGICAL_EFUSE);
1897
1898 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1899
1900 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_read_logical_efuse_88xx ==========>\n");
1901
1902 if (halmac_offset >= eeprom_size) {
1903 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Offset is too large\n");
1904 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
1905 }
1906
1907 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1908 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait/Rcvd event(dump efuse)...\n");
1909 return HALMAC_RET_BUSY_STATE;
1910 }
1911 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1912 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1913 return HALMAC_RET_ERROR_STATE;
1914 }
1915
1916 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
1917 if (NULL == pEeprom_map) {
1918 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
1919 return HALMAC_RET_MALLOC_FAIL;
1920 }
1921 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
1922
1923 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, HALMAC_EFUSE_BANK_WIFI);
1924 if (HALMAC_RET_SUCCESS != status) {
1925 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1926 return status;
1927 }
1928
1929 status = halmac_read_logical_efuse_map_88xx(pHalmac_adapter, pEeprom_map);
1930 if (HALMAC_RET_SUCCESS != status) {
1931 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_logical_efuse_map error = %x\n", status);
1932 return status;
1933 }
1934
1935 *pValue = *(pEeprom_map + halmac_offset);
1936
1937 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
1938 return HALMAC_RET_ERROR_STATE;
1939
1940 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_read_logical_efuse_88xx <==========\n");
1941
1942 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
1943
1944 return HALMAC_RET_SUCCESS;
1945 }
1946
1947 /**
1948 * halmac_write_logical_efuse_88xx() - write "logical" efuse offset
1949 * @pHalmac_adapter
1950 * @halmac_offset
1951 * @halmac_value
1952 * Author : Soar
1953 * Return : HALMAC_RET_STATUS
1954 */
1955 HALMAC_RET_STATUS
halmac_write_logical_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,IN u8 halmac_value)1956 halmac_write_logical_efuse_88xx(
1957 IN PHALMAC_ADAPTER pHalmac_adapter,
1958 IN u32 halmac_offset,
1959 IN u8 halmac_value
1960 )
1961 {
1962 VOID *pDriver_adapter = NULL;
1963 PHALMAC_API pHalmac_api;
1964 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1965
1966 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
1967
1968 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
1969 return HALMAC_RET_ADAPTER_INVALID;
1970
1971 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
1972 return HALMAC_RET_API_INVALID;
1973
1974 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_WRITE_LOGICAL_EFUSE);
1975
1976 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1977 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1978
1979 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_write_logical_efuse_88xx ==========>\n");
1980
1981 if (halmac_offset >= pHalmac_adapter->hw_config_info.eeprom_size) {
1982 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Offset is too large\n");
1983 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
1984 }
1985
1986 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
1987 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait/Rcvd event(dump efuse)...\n");
1988 return HALMAC_RET_BUSY_STATE;
1989 }
1990
1991 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
1992 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
1993 return HALMAC_RET_ERROR_STATE;
1994 }
1995
1996 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, HALMAC_EFUSE_BANK_WIFI);
1997 if (HALMAC_RET_SUCCESS != status) {
1998 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
1999 return status;
2000 }
2001
2002 status = halmac_func_write_logical_efuse_88xx(pHalmac_adapter, halmac_offset, halmac_value);
2003 if (HALMAC_RET_SUCCESS != status) {
2004 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_write_logical_efuse error = %x\n", status);
2005 return status;
2006 }
2007
2008 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
2009 return HALMAC_RET_ERROR_STATE;
2010
2011 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_write_logical_efuse_88xx <==========\n");
2012
2013 return HALMAC_RET_SUCCESS;
2014 }
2015
2016 /**
2017 * halmac_pg_efuse_by_map_88xx() - pg efuse by map
2018 * @pHalmac_adapter
2019 * @pPg_efuse_info : map, map size, mask, mask size
2020 * @cfg : dump with auto/driver/FW
2021 * Author : Soar
2022 * Return : HALMAC_RET_STATUS
2023 */
2024 HALMAC_RET_STATUS
halmac_pg_efuse_by_map_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,IN HALMAC_EFUSE_READ_CFG cfg)2025 halmac_pg_efuse_by_map_88xx(
2026 IN PHALMAC_ADAPTER pHalmac_adapter,
2027 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
2028 IN HALMAC_EFUSE_READ_CFG cfg
2029 )
2030 {
2031 VOID *pDriver_adapter = NULL;
2032 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2033
2034 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
2035
2036 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2037 return HALMAC_RET_ADAPTER_INVALID;
2038
2039 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2040 return HALMAC_RET_API_INVALID;
2041
2042 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_PG_EFUSE_BY_MAP);
2043
2044 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2045
2046 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_pg_efuse_by_map_88xx ==========>\n");
2047
2048 if (pPg_efuse_info->efuse_map_size != pHalmac_adapter->hw_config_info.eeprom_size) {
2049 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "efuse_map_size is incorrect, should be %d bytes\n", pHalmac_adapter->hw_config_info.eeprom_size);
2050 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
2051 }
2052
2053 if ((pPg_efuse_info->efuse_map_size & 0xF) > 0) {
2054 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "efuse_map_size should be multiple of 16\n");
2055 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
2056 }
2057
2058 if (pPg_efuse_info->efuse_mask_size != pPg_efuse_info->efuse_map_size >> 4) {
2059 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "efuse_mask_size is incorrect, should be %d bytes\n", pPg_efuse_info->efuse_map_size >> 4);
2060 return HALMAC_RET_EFUSE_SIZE_INCORRECT;
2061 }
2062
2063 if (NULL == pPg_efuse_info->pEfuse_map) {
2064 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "efuse_map is NULL\n");
2065 return HALMAC_RET_NULL_POINTER;
2066 }
2067
2068 if (NULL == pPg_efuse_info->pEfuse_mask) {
2069 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "efuse_mask is NULL\n");
2070 return HALMAC_RET_NULL_POINTER;
2071 }
2072
2073 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
2074 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait/Rcvd event(dump efuse)...\n");
2075 return HALMAC_RET_BUSY_STATE;
2076 }
2077
2078 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != halmac_query_efuse_curr_state_88xx(pHalmac_adapter)) {
2079 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(dump efuse)...\n");
2080 return HALMAC_RET_ERROR_STATE;
2081 }
2082
2083 status = halmac_func_switch_efuse_bank_88xx(pHalmac_adapter, HALMAC_EFUSE_BANK_WIFI);
2084 if (HALMAC_RET_SUCCESS != status) {
2085 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_func_switch_efuse_bank error = %x\n", status);
2086 return status;
2087 }
2088
2089 status = halmac_func_pg_efuse_by_map_88xx(pHalmac_adapter, pPg_efuse_info, cfg);
2090
2091 if (HALMAC_RET_SUCCESS != status) {
2092 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_pg_efuse_by_map error = %x\n", status);
2093 return status;
2094 }
2095
2096 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_IDLE))
2097 return HALMAC_RET_ERROR_STATE;
2098
2099 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_TRACE, "halmac_pg_efuse_by_map_88xx <==========\n");
2100
2101 return HALMAC_RET_SUCCESS;
2102 }
2103
2104 /**
2105 * halmac_get_c2h_info_88xx() - process halmac C2H packet
2106 * @pHalmac_adapter
2107 * @halmac_buf
2108 * @halmac_size
2109 * Author : KaiYuan Chang/Ivan Lin
2110 *
2111 * Used to process c2h packet info from RX path. After receiving the packet,
2112 * user need to call this api and pass the packet pointer.
2113 *
2114 * Return : HALMAC_RET_STATUS
2115 */
2116 HALMAC_RET_STATUS
halmac_get_c2h_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * halmac_buf,IN u32 halmac_size)2117 halmac_get_c2h_info_88xx(
2118 IN PHALMAC_ADAPTER pHalmac_adapter,
2119 IN u8 *halmac_buf,
2120 IN u32 halmac_size
2121 )
2122 {
2123 VOID *pDriver_adapter = NULL;
2124 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2125
2126
2127 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2128 return HALMAC_RET_ADAPTER_INVALID;
2129
2130 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2131 return HALMAC_RET_API_INVALID;
2132
2133 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_C2H_INFO);
2134
2135 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2136
2137 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_c2h_info_88xx ==========>\n"); */
2138
2139 /* Check if it is C2H packet */
2140 if (_TRUE == GET_RX_DESC_C2H(halmac_buf)) {
2141 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "C2H packet, start parsing!\n");
2142
2143 status = halmac_parse_c2h_packet_88xx(pHalmac_adapter, halmac_buf, halmac_size);
2144
2145 if (HALMAC_RET_SUCCESS != status) {
2146 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_parse_c2h_packet_88xx error = %x\n", status);
2147 return status;
2148 }
2149 }
2150
2151 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_c2h_info_88xx <==========\n"); */
2152
2153 return HALMAC_RET_SUCCESS;
2154 }
2155
2156 /**
2157 * halmac_cfg_fwlps_option_88xx() -config FW LPS option
2158 * @pHalmac_adapter
2159 * @pLps_option : refer to HALMAC_FWLPS_OPTION structure
2160 * Author : KaiYuan Chang/Ivan Lin
2161 *
2162 * Used to config FW LPS option. If user has called this function,
2163 * halmac uses this setting to run FW LPS. If user never called this function,
2164 * halmac uses default setting to run FW LPS
2165 *
2166 * Return : HALMAC_RET_STATUS
2167 */
2168 HALMAC_RET_STATUS
halmac_cfg_fwlps_option_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_FWLPS_OPTION pLps_option)2169 halmac_cfg_fwlps_option_88xx(
2170 IN PHALMAC_ADAPTER pHalmac_adapter,
2171 IN PHALMAC_FWLPS_OPTION pLps_option
2172 )
2173 {
2174 VOID *pDriver_adapter = NULL;
2175 PHALMAC_FWLPS_OPTION pHal_fwlps_option;
2176
2177 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2178 return HALMAC_RET_ADAPTER_INVALID;
2179
2180 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2181 return HALMAC_RET_API_INVALID;
2182
2183 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_FWLPS_OPTION);
2184
2185 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2186 pHal_fwlps_option = &(pHalmac_adapter->fwlps_option);
2187
2188 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_cfg_fwlps_option_88xx ==========>\n");
2189
2190 pHal_fwlps_option->mode = pLps_option->mode;
2191 pHal_fwlps_option->clk_request = pLps_option->clk_request;
2192 pHal_fwlps_option->rlbm = pLps_option->rlbm;
2193 pHal_fwlps_option->smart_ps = pLps_option->smart_ps;
2194 pHal_fwlps_option->awake_interval = pLps_option->awake_interval;
2195 pHal_fwlps_option->all_queue_uapsd = pLps_option->all_queue_uapsd;
2196 pHal_fwlps_option->pwr_state = pLps_option->pwr_state;
2197 pHal_fwlps_option->low_pwr_rx_beacon = pLps_option->low_pwr_rx_beacon;
2198 pHal_fwlps_option->ant_auto_switch = pLps_option->ant_auto_switch;
2199 pHal_fwlps_option->ps_allow_bt_high_Priority = pLps_option->ps_allow_bt_high_Priority;
2200 pHal_fwlps_option->protect_bcn = pLps_option->protect_bcn;
2201 pHal_fwlps_option->silence_period = pLps_option->silence_period;
2202 pHal_fwlps_option->fast_bt_connect = pLps_option->fast_bt_connect;
2203 pHal_fwlps_option->two_antenna_en = pLps_option->two_antenna_en;
2204 pHal_fwlps_option->adopt_user_Setting = pLps_option->adopt_user_Setting;
2205 pHal_fwlps_option->drv_bcn_early_shift = pLps_option->drv_bcn_early_shift;
2206 pHal_fwlps_option->enter_32K = pLps_option->enter_32K;
2207
2208 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_cfg_fwlps_option_88xx <==========\n");
2209
2210 return HALMAC_RET_SUCCESS;
2211 }
2212
2213 /**
2214 * halmac_cfg_fwips_option_88xx() -config FW IPS option
2215 * @pHalmac_adapter
2216 * @pIps_option : refer to HALMAC_FWIPS_OPTION structure
2217 * Author : KaiYuan Chang/Ivan Lin
2218 *
2219 * Used to config FW IPS option. If user has called this function,
2220 * halmac uses this setting to run FW IPS. If user never called this function,
2221 * halmac uses default setting to run FW IPS
2222 *
2223 * Return : HALMAC_RET_STATUS
2224 */
2225 HALMAC_RET_STATUS
halmac_cfg_fwips_option_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_FWIPS_OPTION pIps_option)2226 halmac_cfg_fwips_option_88xx(
2227 IN PHALMAC_ADAPTER pHalmac_adapter,
2228 IN PHALMAC_FWIPS_OPTION pIps_option
2229 )
2230 {
2231 VOID *pDriver_adapter = NULL;
2232 PHALMAC_FWIPS_OPTION pIps_option_local;
2233
2234 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2235 return HALMAC_RET_ADAPTER_INVALID;
2236
2237 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2238 return HALMAC_RET_API_INVALID;
2239
2240 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_FWIPS_OPTION);
2241
2242 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2243
2244 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_cfg_fwips_option_88xx ==========>\n");
2245
2246 pIps_option_local = pIps_option;
2247
2248 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_cfg_fwips_option_88xx <==========\n");
2249
2250 return HALMAC_RET_SUCCESS;
2251 }
2252
2253 /**
2254 * halmac_enter_wowlan_88xx() - enter wowlan
2255 * @pHalmac_adapter
2256 * @pWowlan_option
2257 * Author : KaiYuan Chang/Ivan Lin
2258 * Return : HALMAC_RET_STATUS
2259 */
2260 HALMAC_RET_STATUS
halmac_enter_wowlan_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_WOWLAN_OPTION pWowlan_option)2261 halmac_enter_wowlan_88xx(
2262 IN PHALMAC_ADAPTER pHalmac_adapter,
2263 IN PHALMAC_WOWLAN_OPTION pWowlan_option
2264 )
2265 {
2266 VOID *pDriver_adapter = NULL;
2267 PHALMAC_WOWLAN_OPTION pWowlan_option_local;
2268
2269 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2270 return HALMAC_RET_ADAPTER_INVALID;
2271
2272 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2273 return HALMAC_RET_API_INVALID;
2274
2275 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_ENTER_WOWLAN);
2276
2277 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2278
2279 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_enter_wowlan_88xx ==========>\n");
2280
2281 pWowlan_option_local = pWowlan_option;
2282
2283 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_enter_wowlan_88xx <==========\n");
2284
2285 return HALMAC_RET_SUCCESS;
2286 }
2287
2288 /**
2289 * halmac_leave_wowlan_88xx() - leave wowlan
2290 * @pHalmac_adapter
2291 * Author : KaiYuan Chang/Ivan Lin
2292 * Return : HALMAC_RET_STATUS
2293 */
2294 HALMAC_RET_STATUS
halmac_leave_wowlan_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2295 halmac_leave_wowlan_88xx(
2296 IN PHALMAC_ADAPTER pHalmac_adapter
2297 )
2298 {
2299 VOID *pDriver_adapter = NULL;
2300
2301 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2302 return HALMAC_RET_ADAPTER_INVALID;
2303
2304 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2305 return HALMAC_RET_API_INVALID;
2306
2307 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_LEAVE_WOWLAN);
2308
2309 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2310
2311 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_leave_wowlan_88xx ==========>\n");
2312
2313
2314 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_leave_wowlan_88xx <==========\n");
2315
2316 return HALMAC_RET_SUCCESS;
2317 }
2318
2319 /**
2320 * halmac_enter_ps_88xx() - enter power saving state
2321 * @pHalmac_adapter
2322 * @ps_state
2323 *
2324 * If user has called halmac_cfg_fwlps_option or
2325 * halmac_cfg_fwips_option, halmac uses the specified setting.
2326 * Otherwise, halmac uses default setting.
2327 *
2328 * Author : KaiYuan Chang/Ivan Lin
2329 * Return : HALMAC_RET_STATUS
2330 */
2331 HALMAC_RET_STATUS
halmac_enter_ps_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_PS_STATE ps_state)2332 halmac_enter_ps_88xx(
2333 IN PHALMAC_ADAPTER pHalmac_adapter,
2334 IN HALMAC_PS_STATE ps_state
2335 )
2336 {
2337 u8 rpwm;
2338 VOID *pDriver_adapter = NULL;
2339 PHALMAC_API pHalmac_api;
2340 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2341
2342 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2343 return HALMAC_RET_ADAPTER_INVALID;
2344
2345 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2346 return HALMAC_RET_API_INVALID;
2347
2348 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2349 return HALMAC_RET_NO_DLFW;
2350
2351 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_ENTER_PS);
2352
2353 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2354 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2355
2356 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_enter_ps_88xx ==========>\n");
2357
2358 if (ps_state == pHalmac_adapter->halmac_state.ps_state) {
2359 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_ERR, "power state is already in PS State!!\n");
2360 return HALMAC_RET_SUCCESS;
2361 }
2362
2363 if (HALMAC_PS_STATE_LPS == ps_state) {
2364 status = halmac_send_h2c_set_pwr_mode_88xx(pHalmac_adapter, &(pHalmac_adapter->fwlps_option));
2365 if (HALMAC_RET_SUCCESS != status) {
2366 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_ERR, "halmac_send_h2c_set_pwr_mode_88xx error = %x!!\n", status);
2367 return status;
2368 }
2369 } else if (HALMAC_PS_STATE_IPS == ps_state) {
2370 }
2371
2372 pHalmac_adapter->halmac_state.ps_state = ps_state;
2373
2374 /* Enter 32K */
2375 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
2376 if (_TRUE == pHalmac_adapter->fwlps_option.enter_32K) {
2377 rpwm = (u8)(((pHalmac_adapter->rpwm_record ^ (BIT(7))) | (BIT(0))) & 0x81);
2378 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SDIO_HRPWM1, rpwm);
2379 pHalmac_adapter->low_clk = _TRUE;
2380 }
2381 } else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface) {
2382 if (_TRUE == pHalmac_adapter->fwlps_option.enter_32K) {
2383 rpwm = (u8)(((pHalmac_adapter->rpwm_record ^ (BIT(7))) | (BIT(0))) & 0x81);
2384 HALMAC_REG_WRITE_8(pHalmac_adapter, 0xFE58, rpwm);
2385 pHalmac_adapter->low_clk = _TRUE;
2386 }
2387 }
2388
2389 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_enter_ps_88xx <==========\n");
2390
2391 return HALMAC_RET_SUCCESS;
2392 }
2393
2394 /**
2395 * halmac_leave_ps_88xx() - leave power saving state
2396 * @pHalmac_adapter
2397 * Author : KaiYuan Chang/Ivan Lin
2398 * Return : HALMAC_RET_STATUS
2399 */
2400 HALMAC_RET_STATUS
halmac_leave_ps_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2401 halmac_leave_ps_88xx(
2402 IN PHALMAC_ADAPTER pHalmac_adapter
2403 )
2404 {
2405 u8 rpwm, cpwm;
2406 u32 counter;
2407 VOID *pDriver_adapter = NULL;
2408 PHALMAC_API pHalmac_api;
2409 HALMAC_FWLPS_OPTION fw_lps_option;
2410 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2411
2412
2413 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2414 return HALMAC_RET_ADAPTER_INVALID;
2415
2416 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2417 return HALMAC_RET_API_INVALID;
2418
2419 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2420 return HALMAC_RET_NO_DLFW;
2421
2422 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_LEAVE_PS);
2423
2424 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2425 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2426
2427 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_leave_ps_88xx ==========>\n");
2428
2429 if (HALMAC_PS_STATE_ACT == pHalmac_adapter->halmac_state.ps_state) {
2430 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_ERR, "power state is already in active!!\n");
2431 return HALMAC_RET_SUCCESS;
2432 }
2433
2434 if (_TRUE == pHalmac_adapter->low_clk) {
2435 cpwm = HALMAC_REG_READ_8(pHalmac_adapter, REG_SDIO_HRPWM1);
2436 rpwm = (u8)(((pHalmac_adapter->rpwm_record ^ (BIT(7))) | (BIT(6))) & 0xC0);
2437 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SDIO_HRPWM1, rpwm);
2438
2439 cpwm = (u8)((cpwm ^ BIT(7)) & BIT(7));
2440 counter = 100;
2441 while (cpwm != (HALMAC_REG_READ_8(pHalmac_adapter, REG_SDIO_HRPWM1) & BIT(7))) {
2442 PLATFORM_RTL_DELAY_US(pDriver_adapter, 50);
2443 counter--;
2444 if (0 == counter)
2445 return HALMAC_RET_CHANGE_PS_FAIL;
2446 }
2447 pHalmac_adapter->low_clk = _FALSE;
2448 }
2449
2450 PLATFORM_RTL_MEMCPY(pDriver_adapter, &fw_lps_option, &(pHalmac_adapter->fwlps_option), sizeof(HALMAC_FWLPS_OPTION));
2451 fw_lps_option.mode = 0;
2452
2453 status = halmac_send_h2c_set_pwr_mode_88xx(pHalmac_adapter, &(fw_lps_option));
2454 if (HALMAC_RET_SUCCESS != status) {
2455 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_ERR, "halmac_send_h2c_set_pwr_mode_88xx error!!=%x\n", status);
2456 return status;
2457 }
2458
2459 pHalmac_adapter->halmac_state.ps_state = HALMAC_PS_STATE_ACT;
2460
2461 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_leave_ps_88xx <==========\n");
2462
2463 return HALMAC_RET_SUCCESS;
2464 }
2465
2466 /**
2467 * halmac_h2c_lb_88xx() - send h2c loopback packet
2468 * @pHalmac_adapter
2469 * Author : KaiYuan Chang/Ivan Lin
2470 * Return : HALMAC_RET_STATUS
2471 */
2472 HALMAC_RET_STATUS
halmac_h2c_lb_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2473 halmac_h2c_lb_88xx(
2474 IN PHALMAC_ADAPTER pHalmac_adapter
2475 )
2476 {
2477 VOID *pDriver_adapter = NULL;
2478
2479 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2480 return HALMAC_RET_ADAPTER_INVALID;
2481
2482 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2483 return HALMAC_RET_API_INVALID;
2484
2485 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_H2C_LB);
2486
2487 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2488
2489 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_h2c_lb_88xx ==========>\n");
2490
2491 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_h2c_lb_88xx <==========\n");
2492
2493 return HALMAC_RET_SUCCESS;
2494 }
2495
2496 /**
2497 * halmac_debug_88xx() - read some registers for debug
2498 * @pHalmac_adapter
2499 * Author : KaiYuan Chang/Ivan Lin
2500 * Return : HALMAC_RET_STATUS
2501 */
2502 HALMAC_RET_STATUS
halmac_debug_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2503 halmac_debug_88xx(
2504 IN PHALMAC_ADAPTER pHalmac_adapter
2505 )
2506 {
2507 u8 temp8 = 0;
2508 u32 i = 0, temp32 = 0;
2509 VOID *pDriver_adapter = NULL;
2510 PHALMAC_API pHalmac_api;
2511
2512 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2513 return HALMAC_RET_ADAPTER_INVALID;
2514
2515 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2516 return HALMAC_RET_API_INVALID;
2517
2518 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DEBUG);
2519
2520 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2521 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2522
2523 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug_88xx ==========>\n");
2524
2525 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
2526 /* Dump CCCR, it needs new platform api */
2527
2528 /*Dump SDIO Local Register, use CMD52*/
2529 for (i = 0x10250000; i < 0x102500ff; i++) {
2530 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2531 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: sdio[%x]=%x\n", i, temp8);
2532 }
2533
2534 /*Dump MAC Register*/
2535 for (i = 0x0000; i < 0x17ff; i++) {
2536 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2537 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp8);
2538 }
2539
2540 /*Check RX Fifo status*/
2541 i = REG_RXFF_PTR_V1;
2542 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2543 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp8);
2544 i = REG_RXFF_WTR_V1;
2545 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2546 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp8);
2547 i = REG_RXFF_PTR_V1;
2548 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2549 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp8);
2550 i = REG_RXFF_WTR_V1;
2551 temp8 = PLATFORM_SDIO_CMD52_READ(pHalmac_adapter, i);
2552 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp8);
2553 } else {
2554 /*Dump MAC Register*/
2555 for (i = 0x0000; i < 0x17fc; i += 4) {
2556 temp32 = HALMAC_REG_READ_32(pHalmac_adapter, i);
2557 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp32);
2558 }
2559
2560 /*Check RX Fifo status*/
2561 i = REG_RXFF_PTR_V1;
2562 temp32 = HALMAC_REG_READ_32(pHalmac_adapter, i);
2563 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp32);
2564 i = REG_RXFF_WTR_V1;
2565 temp32 = HALMAC_REG_READ_32(pHalmac_adapter, i);
2566 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp32);
2567 i = REG_RXFF_PTR_V1;
2568 temp32 = HALMAC_REG_READ_32(pHalmac_adapter, i);
2569 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp32);
2570 i = REG_RXFF_WTR_V1;
2571 temp32 = HALMAC_REG_READ_32(pHalmac_adapter, i);
2572 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug: mac[%x]=%x\n", i, temp32);
2573 }
2574
2575 /* TODO: Add check register code, including MAC CLK, CPU CLK */
2576
2577 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_debug_88xx <==========\n");
2578
2579 return HALMAC_RET_SUCCESS;
2580 }
2581
2582 /**
2583 * halmac_cfg_parameter_88xx() - config register with register array
2584 * @pHalmac_adapter
2585 * @para_info : cmd id, content
2586 * @full_fifo
2587 *
2588 * If msk_en = _TRUE, the format of array is {reg_info, mask, value}.
2589 * If msk_en =_FAUSE, the format of array is {reg_info, value}
2590 * The format of reg_info is
2591 * reg_info[31]=rf_reg, 0: MAC_BB reg, 1: RF reg
2592 * reg_info[27:24]=rf_path, 0: path_A, 1: path_B
2593 * if rf_reg=0(MAC_BB reg), rf_path is meaningless.
2594 * ref_info[15:0]=offset
2595 *
2596 * Example: msk_en = _FALSE
2597 * {0x8100000a, 0x00001122}
2598 * =>Set RF register, path_B, offset 0xA to 0x00001122
2599 * {0x00000824, 0x11224433}
2600 * =>Set MAC_BB register, offset 0x800 to 0x11224433
2601 *
2602 * Note : full fifo mode only for init flow
2603 *
2604 * Author : KaiYuan Chang/Ivan Lin
2605 * Return : HALMAC_RET_STATUS
2606 */
2607 HALMAC_RET_STATUS
halmac_cfg_parameter_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PHY_PARAMETER_INFO para_info,IN u8 full_fifo)2608 halmac_cfg_parameter_88xx(
2609 IN PHALMAC_ADAPTER pHalmac_adapter,
2610 IN PHALMAC_PHY_PARAMETER_INFO para_info,
2611 IN u8 full_fifo
2612 )
2613 {
2614 VOID *pDriver_adapter = NULL;
2615 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
2616 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.cfg_para_state_set.process_status);
2617
2618 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2619 return HALMAC_RET_ADAPTER_INVALID;
2620
2621 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2622 return HALMAC_RET_API_INVALID;
2623
2624 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2625 return HALMAC_RET_NO_DLFW;
2626
2627 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_PARAMETER);
2628
2629 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2630
2631 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_parameter_88xx ==========>\n"); */
2632
2633 if (HALMAC_DLFW_NONE == pHalmac_adapter->halmac_state.dlfw_state) {
2634 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_cfg_parameter_88xx Fail due to DLFW NONE!!\n");
2635 return HALMAC_RET_DLFW_FAIL;
2636 }
2637
2638 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
2639 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(cfg para)...\n");
2640 return HALMAC_RET_BUSY_STATE;
2641 }
2642
2643 if ((HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE != halmac_query_cfg_para_curr_state_88xx(pHalmac_adapter)) &&
2644 (HALMAC_CFG_PARA_CMD_CONSTRUCT_CONSTRUCTING != halmac_query_cfg_para_curr_state_88xx(pHalmac_adapter))) {
2645 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Not idle state(cfg para)...\n");
2646 return HALMAC_RET_BUSY_STATE;
2647 }
2648
2649 *pProcess_status = HALMAC_CMD_PROCESS_IDLE;
2650
2651 ret_status = halmac_send_h2c_phy_parameter_88xx(pHalmac_adapter, para_info, full_fifo);
2652
2653 if (HALMAC_RET_SUCCESS != ret_status) {
2654 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_phy_parameter_88xx Fail!! = %x\n", ret_status);
2655 return ret_status;
2656 }
2657
2658 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_parameter_88xx <==========\n"); */
2659
2660 return ret_status;
2661 }
2662
2663 /**
2664 * halmac_update_packet_88xx() - send some specified packet to FW
2665 * @pHalmac_adapter
2666 * @pkt_id : probe request, sync beacon, discovery beacon
2667 * @pkt
2668 * @pkt_size
2669 *
2670 * Send new specified packet to FW.
2671 * Note : TX_DESC is not included in the @pkt
2672 *
2673 * Author : KaiYuan Chang/Ivan Lin
2674 * Return : HALMAC_RET_STATUS
2675 */
2676 HALMAC_RET_STATUS
halmac_update_packet_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_PACKET_ID pkt_id,IN u8 * pkt,IN u32 pkt_size)2677 halmac_update_packet_88xx(
2678 IN PHALMAC_ADAPTER pHalmac_adapter,
2679 IN HALMAC_PACKET_ID pkt_id,
2680 IN u8 *pkt,
2681 IN u32 pkt_size
2682 )
2683 {
2684 VOID *pDriver_adapter = NULL;
2685 PHALMAC_API pHalmac_api;
2686 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2687 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.update_packet_set.process_status);
2688
2689 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2690 return HALMAC_RET_ADAPTER_INVALID;
2691
2692 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2693 return HALMAC_RET_API_INVALID;
2694
2695 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2696 return HALMAC_RET_NO_DLFW;
2697
2698 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_UPDATE_PACKET);
2699
2700 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2701 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2702
2703 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_update_packet_88xx ==========>\n");
2704
2705 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
2706 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(update_packet)...\n");
2707 return HALMAC_RET_BUSY_STATE;
2708 }
2709
2710 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
2711
2712 status = halmac_send_h2c_update_packet_88xx(pHalmac_adapter, pkt_id, pkt, pkt_size);
2713
2714 if (HALMAC_RET_SUCCESS != status) {
2715 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_update_packet_88xx packet = %x, fail = %x!!\n", pkt_id, status);
2716 return status;
2717 }
2718
2719 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_update_packet_88xx <==========\n");
2720
2721 return HALMAC_RET_SUCCESS;
2722 }
2723
2724 /**
2725 * halmac_bcn_ie_filter_88xx() - filter beacon & probe response
2726 * @pHalmac_adapter
2727 * @pBcn_ie_info
2728 * Author : KaiYuan Chang/Ivan Lin
2729 * Return : HALMAC_RET_STATUS
2730 */
2731 HALMAC_RET_STATUS
halmac_bcn_ie_filter_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_BCN_IE_INFO pBcn_ie_info)2732 halmac_bcn_ie_filter_88xx(
2733 IN PHALMAC_ADAPTER pHalmac_adapter,
2734 IN PHALMAC_BCN_IE_INFO pBcn_ie_info
2735 )
2736 {
2737 VOID *pDriver_adapter = NULL;
2738 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2739
2740 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2741 return HALMAC_RET_ADAPTER_INVALID;
2742
2743 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2744 return HALMAC_RET_API_INVALID;
2745
2746 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2747 return HALMAC_RET_NO_DLFW;
2748
2749 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_BCN_IE_FILTER);
2750
2751 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2752
2753 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_bcn_ie_filter_88xx ==========>\n");
2754
2755 status = halmac_send_h2c_update_bcn_parse_info_88xx(pHalmac_adapter, pBcn_ie_info);
2756
2757 if (HALMAC_RET_SUCCESS != status) {
2758 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_update_bcn_parse_info_88xx fail = %x\n", status);
2759 return status;
2760 }
2761
2762 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_bcn_ie_filter_88xx <==========\n");
2763
2764 return HALMAC_RET_SUCCESS;
2765 }
2766
2767 /**
2768 * halmac_update_datapack_88xx() -
2769 * @pHalmac_adapter
2770 * @halmac_data_type
2771 * @para_info
2772 * Author : KaiYuan Chang/Ivan Lin
2773 * Return : HALMAC_RET_STATUS
2774 */
2775 HALMAC_RET_STATUS
halmac_update_datapack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_DATA_TYPE halmac_data_type,IN PHALMAC_PHY_PARAMETER_INFO para_info)2776 halmac_update_datapack_88xx(
2777 IN PHALMAC_ADAPTER pHalmac_adapter,
2778 IN HALMAC_DATA_TYPE halmac_data_type,
2779 IN PHALMAC_PHY_PARAMETER_INFO para_info
2780 )
2781 {
2782 VOID *pDriver_adapter = NULL;
2783 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
2784
2785 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2786 return HALMAC_RET_ADAPTER_INVALID;
2787
2788 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2789 return HALMAC_RET_API_INVALID;
2790
2791 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2792 return HALMAC_RET_NO_DLFW;
2793
2794 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_UPDATE_DATAPACK);
2795
2796 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_update_datapack_88xx ==========>\n");
2797
2798 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2799
2800 /* ret_status = halmac_send_h2c_update_datapack_88xx(pHalmac_adapter, halmac_data_type, para_info); */
2801
2802 if (HALMAC_RET_SUCCESS != ret_status) {
2803 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_update_datapack_88xx Fail, datatype = %x, status = %x\n", halmac_data_type, ret_status);
2804 return ret_status;
2805 }
2806
2807 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_update_datapack_88xx <==========\n");
2808
2809 return HALMAC_RET_SUCCESS;
2810 }
2811
2812 /**
2813 * halmac_run_datapack_88xx() -
2814 * @pHalmac_adapter
2815 * @halmac_data_type
2816 * Author : KaiYuan Chang/Ivan Lin
2817 * Return : HALMAC_RET_STATUS
2818 */
2819 HALMAC_RET_STATUS
halmac_run_datapack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_DATA_TYPE halmac_data_type)2820 halmac_run_datapack_88xx(
2821 IN PHALMAC_ADAPTER pHalmac_adapter,
2822 IN HALMAC_DATA_TYPE halmac_data_type
2823 )
2824 {
2825 VOID *pDriver_adapter = NULL;
2826 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
2827
2828 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2829 return HALMAC_RET_ADAPTER_INVALID;
2830
2831 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2832 return HALMAC_RET_API_INVALID;
2833
2834 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2835 return HALMAC_RET_NO_DLFW;
2836
2837 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_RUN_DATAPACK);
2838
2839 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2840
2841 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_run_datapack_88xx ==========>\n");
2842
2843 ret_status = halmac_send_h2c_run_datapack_88xx(pHalmac_adapter, halmac_data_type);
2844
2845 if (HALMAC_RET_SUCCESS != ret_status) {
2846 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_run_datapack_88xx Fail, datatype = %x, status = %x!!\n", halmac_data_type, ret_status);
2847 return ret_status;
2848 }
2849
2850 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_update_datapack_88xx <==========\n");
2851
2852 return HALMAC_RET_SUCCESS;
2853 }
2854
2855 /**
2856 * halmac_cfg_drv_info_88xx() - config driver info
2857 * @pHalmac_adapter
2858 * @halmac_drv_info : none, phy status, phy sniffer, phy plcp
2859 * Author : KaiYuan Chang/Ivan Lin
2860 * Return : HALMAC_RET_STATUS
2861 */
2862 HALMAC_RET_STATUS
halmac_cfg_drv_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_DRV_INFO halmac_drv_info)2863 halmac_cfg_drv_info_88xx(
2864 IN PHALMAC_ADAPTER pHalmac_adapter,
2865 IN HALMAC_DRV_INFO halmac_drv_info
2866 )
2867 {
2868 u8 drv_info_size = 0;
2869 u8 phy_status_en = 0;
2870 u8 sniffer_en = 0;
2871 u8 plcp_hdr_en = 0;
2872 u32 value32;
2873 VOID *pDriver_adapter = NULL;
2874 PHALMAC_API pHalmac_api;
2875 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2876
2877 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2878 return HALMAC_RET_ADAPTER_INVALID;
2879
2880 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2881 return HALMAC_RET_API_INVALID;
2882
2883 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_DRV_INFO);
2884
2885 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2886 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2887
2888 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_drv_info_88xx ==========>\n");
2889
2890 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_drv_info = %d\n", halmac_drv_info);
2891
2892 switch (halmac_drv_info) {
2893 case HALMAC_DRV_INFO_NONE:
2894 drv_info_size = 0;
2895 phy_status_en = 0;
2896 sniffer_en = 0;
2897 plcp_hdr_en = 0;
2898 break;
2899 case HALMAC_DRV_INFO_PHY_STATUS:
2900 drv_info_size = 4;
2901 phy_status_en = 1;
2902 sniffer_en = 0;
2903 plcp_hdr_en = 0;
2904 break;
2905 case HALMAC_DRV_INFO_PHY_SNIFFER:
2906 drv_info_size = 5; /* phy status 4byte, sniffer info 1byte */
2907 phy_status_en = 1;
2908 sniffer_en = 1;
2909 plcp_hdr_en = 0;
2910 break;
2911 case HALMAC_DRV_INFO_PHY_PLCP:
2912 drv_info_size = 6; /* phy status 4byte, plcp header 2byte */
2913 phy_status_en = 1;
2914 sniffer_en = 0;
2915 plcp_hdr_en = 1;
2916 break;
2917 default:
2918 status = HALMAC_RET_SW_CASE_NOT_SUPPORT;
2919 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_cfg_drv_info_88xx error = %x\n", status);
2920 return status;
2921 }
2922
2923 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RX_DRVINFO_SZ, drv_info_size);
2924
2925 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_RCR);
2926 value32 = (value32 & (~BIT_APP_PHYSTS));
2927 if (1 == phy_status_en)
2928 value32 = value32 | BIT_APP_PHYSTS;
2929 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_RCR, value32);
2930
2931 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_WMAC_OPTION_FUNCTION + 4);
2932 value32 = (value32 & (~(BIT(8) | BIT(9))));
2933 if (1 == sniffer_en)
2934 value32 = value32 | BIT(9);
2935 if (1 == plcp_hdr_en)
2936 value32 = value32 | BIT(8);
2937 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WMAC_OPTION_FUNCTION + 4, value32);
2938
2939 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_drv_info_88xx <==========\n");
2940
2941 return HALMAC_RET_SUCCESS;
2942 }
2943
2944 /**
2945 * halmac_send_bt_coex_88xx() -
2946 * @pHalmac_adapter
2947 * @pBt_buf
2948 * @bt_size
2949 * @ack
2950 * Author : KaiYuan Chang/Ivan Lin
2951 * Return : HALMAC_RET_STATUS
2952 */
2953 HALMAC_RET_STATUS
halmac_send_bt_coex_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pBt_buf,IN u32 bt_size,IN u8 ack)2954 halmac_send_bt_coex_88xx(
2955 IN PHALMAC_ADAPTER pHalmac_adapter,
2956 IN u8 *pBt_buf,
2957 IN u32 bt_size,
2958 IN u8 ack
2959 )
2960 {
2961 VOID *pDriver_adapter = NULL;
2962 PHALMAC_API pHalmac_api;
2963 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
2964
2965 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
2966 return HALMAC_RET_ADAPTER_INVALID;
2967
2968 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
2969 return HALMAC_RET_API_INVALID;
2970
2971 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
2972 return HALMAC_RET_NO_DLFW;
2973
2974 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SEND_BT_COEX);
2975
2976 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2977 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2978
2979 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_bt_coex_88xx ==========>\n");
2980
2981 ret_status = halmac_send_bt_coex_cmd_88xx(pHalmac_adapter, pBt_buf, bt_size, ack);
2982
2983 if (HALMAC_RET_SUCCESS != ret_status) {
2984 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_bt_coex_cmd_88xx Fail = %x!!\n", ret_status);
2985 return ret_status;
2986 }
2987
2988 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_bt_coex_88xx <==========\n");
2989
2990 return HALMAC_RET_SUCCESS;
2991 }
2992
2993 /**
2994 * halmac_verify_platform_api_88xx() - verify platform api
2995 * @pHalmac_adapter
2996 * Author : KaiYuan Chang/Ivan Lin
2997 * Return : HALMAC_RET_STATUS
2998 */
2999 HALMAC_RET_STATUS
halmac_verify_platform_api_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)3000 halmac_verify_platform_api_88xx(
3001 IN PHALMAC_ADAPTER pHalmac_adapter
3002 )
3003 {
3004 VOID *pDriver_adapter = NULL;
3005 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
3006
3007 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3008 return HALMAC_RET_ADAPTER_INVALID;
3009
3010 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3011 return HALMAC_RET_API_INVALID;
3012
3013 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_VERIFY_PLATFORM_API);
3014
3015 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3016
3017 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_verify_platform_api_88xx ==========>\n");
3018
3019 ret_status = halmac_verify_io_88xx(pHalmac_adapter);
3020
3021 if (HALMAC_RET_SUCCESS != ret_status)
3022 return ret_status;
3023
3024 if (HALMAC_LA_MODE_FULL != pHalmac_adapter->txff_allocation.la_mode)
3025 ret_status = halmac_verify_send_rsvd_page_88xx(pHalmac_adapter);
3026
3027 if (HALMAC_RET_SUCCESS != ret_status)
3028 return ret_status;
3029
3030 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_verify_platform_api_88xx <==========\n");
3031
3032 return ret_status;
3033 }
3034
3035 /**
3036 * halmac_send_original_h2c_88xx() - send original format h2c packet
3037 * @pHalmac_adapter
3038 * @original_h2c
3039 * @seq
3040 * @ack
3041 * Author : KaiYuan Chang/Ivan Lin
3042 * Return : HALMAC_RET_STATUS
3043 */
3044 HALMAC_RET_STATUS
halmac_send_original_h2c_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * original_h2c,IN u16 * seq,IN u8 ack)3045 halmac_send_original_h2c_88xx(
3046 IN PHALMAC_ADAPTER pHalmac_adapter,
3047 IN u8 *original_h2c,
3048 IN u16 *seq,
3049 IN u8 ack
3050 )
3051 {
3052 VOID *pDriver_adapter = NULL;
3053 PHALMAC_API pHalmac_api;
3054 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
3055
3056 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3057 return HALMAC_RET_ADAPTER_INVALID;
3058
3059 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3060 return HALMAC_RET_API_INVALID;
3061
3062 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
3063 return HALMAC_RET_NO_DLFW;
3064
3065 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SEND_ORIGINAL_H2C);
3066
3067 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3068 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3069
3070 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_original_h2c_88xx ==========>\n");
3071
3072 status = halmac_func_send_original_h2c_88xx(pHalmac_adapter, original_h2c, seq, ack);
3073
3074 if (HALMAC_RET_SUCCESS != status) {
3075 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_original_h2c FAIL = %x!!\n", status);
3076 return status;
3077 }
3078
3079 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_original_h2c_88xx <==========\n");
3080
3081 return HALMAC_RET_SUCCESS;
3082 }
3083
3084 /**
3085 * halmac_timer_2s_88xx() - periodic operation
3086 * @pHalmac_adapter
3087 * Author : KaiYuan Chang/Ivan Lin
3088 * Return : HALMAC_RET_STATUS
3089 */
3090 HALMAC_RET_STATUS
halmac_timer_2s_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)3091 halmac_timer_2s_88xx(
3092 IN PHALMAC_ADAPTER pHalmac_adapter
3093 )
3094 {
3095 VOID *pDriver_adapter = NULL;
3096
3097 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3098 return HALMAC_RET_ADAPTER_INVALID;
3099
3100 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3101 return HALMAC_RET_API_INVALID;
3102
3103 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3104
3105 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_timer_2s_88xx ==========>\n");
3106
3107
3108 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_timer_2s_88xx <==========\n");
3109
3110 return HALMAC_RET_SUCCESS;
3111 }
3112
3113 /**
3114 * halmac_fill_txdesc_check_sum_88xx() - fill in tx desc check sum
3115 * @pHalmac_adapter
3116 * @pCur_desc
3117 *
3118 * User input tx descriptor, halmac output tx descriptor check sum
3119 *
3120 * Author : KaiYuan Chang/Ivan Lin
3121 * Return : HALMAC_RET_STATUS
3122 */
3123 HALMAC_RET_STATUS
halmac_fill_txdesc_check_sum_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,INOUT u8 * pCur_desc)3124 halmac_fill_txdesc_check_sum_88xx(
3125 IN PHALMAC_ADAPTER pHalmac_adapter,
3126 INOUT u8 *pCur_desc
3127 )
3128 {
3129 u16 chk_result = 0;
3130 u16 *pData = (u16 *)NULL;
3131 u32 i;
3132 VOID *pDriver_adapter = NULL;
3133 PHALMAC_API pHalmac_api;
3134
3135 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3136 return HALMAC_RET_ADAPTER_INVALID;
3137
3138 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3139 return HALMAC_RET_API_INVALID;
3140
3141 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_FILL_TXDESC_CHECKSUM);
3142
3143 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3144 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3145
3146
3147 if (NULL == pCur_desc) {
3148 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_fill_txdesc_check_sum_88xx NULL PTR");
3149 return HALMAC_RET_NULL_POINTER;
3150 }
3151
3152 SET_TX_DESC_TXDESC_CHECKSUM(pCur_desc, 0x0000);
3153
3154 pData = (u16 *)(pCur_desc);
3155
3156 /* HW clculates only 32byte */
3157 for (i = 0; i < 8; i++)
3158 chk_result ^= (*(pData + 2 * i) ^ *(pData + (2 * i + 1)));
3159
3160 SET_TX_DESC_TXDESC_CHECKSUM(pCur_desc, chk_result);
3161
3162 return HALMAC_RET_SUCCESS;
3163 }
3164
3165 /**
3166 * halmac_dump_fifo_88xx() - dump fifo data
3167 * @pHalmac_adapter
3168 * @halmac_fifo_sel : tx, rx, rsvd page, report buff, llt
3169 * @pFifo_map
3170 * @halmac_fifo_dump_size
3171 *
3172 * Note : before dump fifo, user need to call halmac_get_fifo_size to
3173 * get fifo size. Then input this size to halmac_dump_fifo.
3174 *
3175 * Author : Ivan Lin/KaiYuan Chang
3176 * Return : HALMAC_RET_STATUS
3177 */
3178 HALMAC_RET_STATUS
halmac_dump_fifo_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HAL_FIFO_SEL halmac_fifo_sel,OUT u8 * pFifo_map,IN u32 halmac_fifo_dump_size)3179 halmac_dump_fifo_88xx(
3180 IN PHALMAC_ADAPTER pHalmac_adapter,
3181 IN HAL_FIFO_SEL halmac_fifo_sel,
3182 OUT u8 *pFifo_map,
3183 IN u32 halmac_fifo_dump_size
3184 )
3185 {
3186 VOID *pDriver_adapter = NULL;
3187 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
3188
3189 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3190 return HALMAC_RET_ADAPTER_INVALID;
3191
3192 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3193 return HALMAC_RET_API_INVALID;
3194
3195 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DUMP_FIFO);
3196
3197 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3198
3199 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_dump_fifo_88xx ==========>\n");
3200
3201 if (HAL_FIFO_SEL_TX == halmac_fifo_sel && halmac_fifo_dump_size > pHalmac_adapter->hw_config_info.tx_fifo_size) {
3202 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "TX fifo dump size is too large\n");
3203 return HALMAC_RET_DUMP_FIFOSIZE_INCORRECT;
3204 }
3205
3206 if (HAL_FIFO_SEL_RX == halmac_fifo_sel && halmac_fifo_dump_size > pHalmac_adapter->hw_config_info.rx_fifo_size) {
3207 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "RX fifo dump size is too large\n");
3208 return HALMAC_RET_DUMP_FIFOSIZE_INCORRECT;
3209 }
3210
3211 if (0 != (halmac_fifo_dump_size & (4 - 1))) {
3212 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_fifo_dump_size shall 4byte align\n");
3213 return HALMAC_RET_DUMP_FIFOSIZE_INCORRECT;
3214 }
3215
3216 if (NULL == pFifo_map) {
3217 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "pFifo_map address is NULL\n");
3218 return HALMAC_RET_NULL_POINTER;
3219 }
3220
3221 status = halmac_buffer_read_88xx(pHalmac_adapter, 0x00, halmac_fifo_dump_size, halmac_fifo_sel, pFifo_map);
3222
3223 if (HALMAC_RET_SUCCESS != status) {
3224 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_buffer_read_88xx error = %x\n", status);
3225 return status;
3226 }
3227
3228 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_dump_fifo_88xx <==========\n");
3229
3230 return HALMAC_RET_SUCCESS;
3231 }
3232
3233 /**
3234 * halmac_get_fifo_size_88xx() - get fifo size
3235 * @pHalmac_adapter
3236 * @halmac_fifo_sel : tx, rx, rsvd page, report buff, llt
3237 * Author : Ivan Lin/KaiYuan Chang
3238 * Return : fifo size
3239 */
3240 u32
halmac_get_fifo_size_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HAL_FIFO_SEL halmac_fifo_sel)3241 halmac_get_fifo_size_88xx(
3242 IN PHALMAC_ADAPTER pHalmac_adapter,
3243 IN HAL_FIFO_SEL halmac_fifo_sel
3244 )
3245 {
3246 u32 fifo_size = 0;
3247
3248 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3249 return HALMAC_RET_ADAPTER_INVALID;
3250
3251 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3252 return HALMAC_RET_API_INVALID;
3253
3254 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_FIFO_SIZE);
3255
3256 if (HAL_FIFO_SEL_TX == halmac_fifo_sel)
3257 fifo_size = pHalmac_adapter->hw_config_info.tx_fifo_size;
3258 else if (HAL_FIFO_SEL_RX == halmac_fifo_sel)
3259 fifo_size = pHalmac_adapter->hw_config_info.rx_fifo_size;
3260 else if (HAL_FIFO_SEL_RSVD_PAGE == halmac_fifo_sel)
3261 fifo_size = ((pHalmac_adapter->hw_config_info.tx_fifo_size >> 7) - pHalmac_adapter->txff_allocation.rsvd_pg_bndy) << 7;
3262 else if (HAL_FIFO_SEL_REPORT == halmac_fifo_sel)
3263 fifo_size = 65536;
3264 else if (HAL_FIFO_SEL_LLT == halmac_fifo_sel)
3265 fifo_size = 65536;
3266
3267 return fifo_size;
3268 }
3269
3270 /**
3271 * halmac_cfg_txbf_88xx() - enable/disable specific user's txbf
3272 * @pHalmac_adapter
3273 * Author : chunchu
3274 * Return : HALMAC_RET_STATUS
3275 */
3276 HALMAC_RET_STATUS
halmac_cfg_txbf_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 userid,IN HALMAC_BW bw,IN u8 txbf_en)3277 halmac_cfg_txbf_88xx(
3278 IN PHALMAC_ADAPTER pHalmac_adapter,
3279 IN u8 userid,
3280 IN HALMAC_BW bw,
3281 IN u8 txbf_en
3282 )
3283 {
3284 u16 temp42C = 0;
3285 VOID *pDriver_adapter = NULL;
3286 PHALMAC_API pHalmac_api;
3287
3288 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3289 return HALMAC_RET_ADAPTER_INVALID;
3290
3291 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3292 return HALMAC_RET_API_INVALID;
3293
3294 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_TXBF);
3295
3296 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3297 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3298
3299 if (txbf_en) {
3300 switch (bw) {
3301 case HALMAC_BW_80:
3302 temp42C |= BIT_R_TXBF0_80M;
3303 case HALMAC_BW_40:
3304 temp42C |= BIT_R_TXBF0_40M;
3305 case HALMAC_BW_20:
3306 temp42C |= BIT_R_TXBF0_20M;
3307 break;
3308 default:
3309 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_cfg_txbf_88xx invalid TXBF BW setting 0x%x of userid %d\n", bw, userid);
3310 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3311 }
3312 }
3313
3314 switch (userid) {
3315 case 0:
3316 temp42C |= HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL) & ~(BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M);
3317 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL, temp42C);
3318 break;
3319 case 1:
3320 temp42C |= HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL + 2) & ~(BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M);
3321 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL + 2, temp42C);
3322 break;
3323 default:
3324 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_cfg_txbf_88xx invalid userid %d\n", userid);
3325 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3326 }
3327
3328 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_cfg_txbf_88xx, txbf_en = %x <==========\n", txbf_en);
3329
3330 return HALMAC_RET_SUCCESS;
3331 }
3332
3333 /**
3334 * halmac_cfg_mumimo_88xx() -
3335 * @pHalmac_adapter
3336 * Author : chunchu
3337 * Return : HALMAC_RET_STATUS
3338 */
3339 HALMAC_RET_STATUS
halmac_cfg_mumimo_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_CFG_MUMIMO_PARA pCfgmu)3340 halmac_cfg_mumimo_88xx(
3341 IN PHALMAC_ADAPTER pHalmac_adapter,
3342 IN PHALMAC_CFG_MUMIMO_PARA pCfgmu
3343 )
3344 {
3345 VOID *pDriver_adapter = NULL;
3346 PHALMAC_API pHalmac_api;
3347 u8 i, idx, id0, id1, gid, mu_tab_sel;
3348 u8 mu_tab_valid = 0;
3349 u32 gid_valid[6] = {0};
3350 u8 temp14C0 = 0;
3351
3352 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3353 return HALMAC_RET_ADAPTER_INVALID;
3354
3355 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3356 return HALMAC_RET_API_INVALID;
3357
3358 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_MUMIMO);
3359
3360 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3361 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3362
3363 if (pCfgmu->role == HAL_BFEE) {
3364 /*config MU BFEE*/
3365 temp14C0 = HALMAC_REG_READ_8(pHalmac_adapter, REG_MU_TX_CTL) & ~BIT_MASK_R_MU_TABLE_VALID;
3366 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL, (temp14C0|BIT(0)|BIT(1)) & ~(BIT(7))); /*enable MU table 0 and 1, disable MU TX*/
3367
3368 /*config GID valid table and user position table*/
3369 mu_tab_sel = HALMAC_REG_READ_8(pHalmac_adapter, REG_MU_TX_CTL+1) & ~(BIT(0)|BIT(1)|BIT(2));
3370 for (i = 0; i < 2; i++) {
3371 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL+1, mu_tab_sel | i);
3372 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_GID_VLD, pCfgmu->given_gid_tab[i]);
3373 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_USER_POS_INFO, pCfgmu->given_user_pos[i*2]);
3374 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_USER_POS_INFO+4, pCfgmu->given_user_pos[i*2+1]);
3375 }
3376 } else {
3377 /*config MU BFER*/
3378 if (_FALSE == pCfgmu->mu_tx_en) {
3379 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL, HALMAC_REG_READ_8(pHalmac_adapter, REG_MU_TX_CTL) & ~(BIT(7)));
3380 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_cfg_mumimo_88xx disable mu tx <==========\n");
3381 return HALMAC_RET_SUCCESS;
3382 }
3383
3384 /*Transform BB grouping bitmap[14:0] to MAC GID_valid table*/
3385 for (idx = 0; idx < 15; idx++) {
3386 if (idx < 5) {
3387 /*grouping_bitmap bit0~4, MU_STA0 with MUSTA1~5*/
3388 id0 = 0;
3389 id1 = (u8)(idx + 1);
3390 } else if (idx < 9) {
3391 /*grouping_bitmap bit5~8, MU_STA1 with MUSTA2~5*/
3392 id0 = 1;
3393 id1 = (u8)(idx - 3);
3394 } else if (idx < 12) {
3395 /*grouping_bitmap bit9~11, MU_STA2 with MUSTA3~5*/
3396 id0 = 2;
3397 id1 = (u8)(idx - 6);
3398 } else if (idx < 14) {
3399 /*grouping_bitmap bit12~13, MU_STA3 with MUSTA4~5*/
3400 id0 = 3;
3401 id1 = (u8)(idx - 8);
3402 } else {
3403 /*grouping_bitmap bit14, MU_STA4 with MUSTA5*/
3404 id0 = 4;
3405 id1 = (u8)(idx - 9);
3406 }
3407 if (pCfgmu->grouping_bitmap & BIT(idx)) {
3408 /*Pair 1*/
3409 gid = (idx << 1) + 1;
3410 gid_valid[id0] |= (BIT(gid));
3411 gid_valid[id1] |= (BIT(gid));
3412 /*Pair 2*/
3413 gid += 1;
3414 gid_valid[id0] |= (BIT(gid));
3415 gid_valid[id1] |= (BIT(gid));
3416 } else {
3417 /*Pair 1*/
3418 gid = (idx << 1) + 1;
3419 gid_valid[id0] &= ~(BIT(gid));
3420 gid_valid[id1] &= ~(BIT(gid));
3421 /*Pair 2*/
3422 gid += 1;
3423 gid_valid[id0] &= ~(BIT(gid));
3424 gid_valid[id1] &= ~(BIT(gid));
3425 }
3426 }
3427
3428 /*set MU STA GID valid TABLE*/
3429 mu_tab_sel = HALMAC_REG_READ_8(pHalmac_adapter, REG_MU_TX_CTL+1) & ~(BIT(0)|BIT(1)|BIT(2));
3430 for (idx = 0; idx < 6; idx++) {
3431 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL+1, idx | mu_tab_sel);
3432 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_GID_VLD, gid_valid[idx]);
3433 }
3434
3435 /*To validate the sounding successful MU STA and enable MU TX*/
3436 for (i = 0; i < 6; i++) {
3437 if (_TRUE == pCfgmu->sounding_sts[i])
3438 mu_tab_valid |= BIT(i);
3439 }
3440 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL, mu_tab_valid | BIT(7));
3441 }
3442 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_cfg_mumimo_88xx <==========\n");
3443 return HALMAC_RET_SUCCESS;
3444 }
3445
3446 /**
3447 * halmac_cfg_sounding_88xx() - set general sounding control registers
3448 * @pHalmac_adapter
3449 * Author : chunchu
3450 * Return : HALMAC_RET_STATUS
3451 */
3452 HALMAC_RET_STATUS
halmac_cfg_sounding_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_SND_ROLE role,IN HALMAC_DATA_RATE datarate)3453 halmac_cfg_sounding_88xx(
3454 IN PHALMAC_ADAPTER pHalmac_adapter,
3455 IN HALMAC_SND_ROLE role,
3456 IN HALMAC_DATA_RATE datarate
3457 )
3458 {
3459 VOID *pDriver_adapter = NULL;
3460 PHALMAC_API pHalmac_api;
3461
3462 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3463 return HALMAC_RET_ADAPTER_INVALID;
3464
3465 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3466 return HALMAC_RET_API_INVALID;
3467
3468 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_SOUNDING);
3469
3470 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3471 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3472
3473 switch (role) {
3474 case HAL_BFER:
3475 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_TXBF_CTRL, HALMAC_REG_READ_32(pHalmac_adapter, REG_TXBF_CTRL) | BIT_R_ENABLE_NDPA
3476 | BIT_USE_NDPA_PARAMETER | BIT_R_EN_NDPA_INT | BIT_DIS_NDP_BFEN);
3477 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_NDPA_RATE, datarate);
3478 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_NDPA_OPT_CTRL, HALMAC_REG_READ_8(pHalmac_adapter, REG_NDPA_OPT_CTRL) & (~(BIT(0) | BIT(1))));
3479 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SND_PTCL_CTRL + 1, 0x2);
3480 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SND_PTCL_CTRL + 2, 0x2);
3481 break;
3482 case HAL_BFEE:
3483 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SND_PTCL_CTRL, 0xDB);
3484 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SND_PTCL_CTRL + 3, 0x50);
3485 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BBPSF_CTRL + 3, datarate);
3486 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RRSR, HALMAC_REG_READ_16(pHalmac_adapter, REG_RRSR) | BIT(datarate));
3487 break;
3488 default:
3489 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_cfg_sounding_88xx invalid role \n");
3490 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3491 }
3492
3493 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_cfg_sounding_88xx <==========\n");
3494
3495 return HALMAC_RET_SUCCESS;
3496 }
3497
3498 /**
3499 * halmac_del_sounding_88xx() - reset general sounding control registers
3500 * @pHalmac_adapter
3501 * Author : chunchu
3502 * Return : HALMAC_RET_STATUS
3503 */
3504 HALMAC_RET_STATUS
halmac_del_sounding_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_SND_ROLE role)3505 halmac_del_sounding_88xx(
3506 IN PHALMAC_ADAPTER pHalmac_adapter,
3507 IN HALMAC_SND_ROLE role
3508 )
3509 {
3510 VOID *pDriver_adapter = NULL;
3511 PHALMAC_API pHalmac_api;
3512
3513 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3514 return HALMAC_RET_ADAPTER_INVALID;
3515
3516 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3517 return HALMAC_RET_API_INVALID;
3518
3519 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DEL_SOUNDING);
3520
3521 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3522 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3523
3524 switch (role) {
3525 case HAL_BFER:
3526 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TXBF_CTRL + 3, 0);
3527 break;
3528 case HAL_BFEE:
3529 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SND_PTCL_CTRL, 0);
3530 break;
3531 default:
3532 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_del_sounding_88xx invalid role \n");
3533 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3534 }
3535
3536 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_del_sounding_88xx <==========\n");
3537
3538 return HALMAC_RET_SUCCESS;
3539 }
3540
3541 /**
3542 * halmac_su_bfee_entry_init_88xx() - config SU beamformee's registers
3543 * @pHalmac_adapter
3544 * Author : chunchu
3545 * Return : HALMAC_RET_STATUS
3546 */
3547 HALMAC_RET_STATUS
halmac_su_bfee_entry_init_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 userid,IN u16 paid)3548 halmac_su_bfee_entry_init_88xx(
3549 IN PHALMAC_ADAPTER pHalmac_adapter,
3550 IN u8 userid,
3551 IN u16 paid
3552 )
3553 {
3554 u16 temp42C = 0;
3555 VOID *pDriver_adapter = NULL;
3556 PHALMAC_API pHalmac_api;
3557
3558 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3559 return HALMAC_RET_ADAPTER_INVALID;
3560
3561 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3562 return HALMAC_RET_API_INVALID;
3563
3564 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SU_BFEE_ENTRY_INIT);
3565
3566 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3567 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3568
3569 switch (userid) {
3570 case 0:
3571 temp42C = HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL) & ~(BIT_MASK_R_TXBF0_AID | BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M);
3572 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL, temp42C | paid);
3573 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_ASSOCIATED_BFMEE_SEL + 3, 0x60);
3574 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMEE_SEL, paid | BIT(9));
3575 break;
3576 case 1:
3577 temp42C = HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL + 2) & ~(BIT_MASK_R_TXBF1_AID | BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M);
3578 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL + 2, temp42C | paid);
3579 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMEE_SEL + 2, paid | BIT(9) | 0xe000);
3580 break;
3581 default:
3582 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_su_bfee_entry_init_88xx invalid userid %d \n", userid);
3583 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3584 }
3585
3586 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_su_bfee_entry_init_88xx <==========\n");
3587
3588 return HALMAC_RET_SUCCESS;
3589 }
3590
3591 /**
3592 * halmac_su_bfee_entry_init_88xx() - config SU beamformer's registers
3593 * @pHalmac_adapter
3594 * Author : chunchu
3595 * Return : HALMAC_RET_STATUS
3596 */
3597 HALMAC_RET_STATUS
halmac_su_bfer_entry_init_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_SU_BFER_INIT_PARA pSu_bfer_init)3598 halmac_su_bfer_entry_init_88xx(
3599 IN PHALMAC_ADAPTER pHalmac_adapter,
3600 IN PHALMAC_SU_BFER_INIT_PARA pSu_bfer_init
3601 )
3602 {
3603 u16 mac_address_H;
3604 u32 mac_address_L;
3605 VOID *pDriver_adapter = NULL;
3606 PHALMAC_API pHalmac_api;
3607
3608 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3609 return HALMAC_RET_ADAPTER_INVALID;
3610
3611 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3612 return HALMAC_RET_API_INVALID;
3613
3614 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SU_BFER_ENTRY_INIT);
3615
3616 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3617 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3618
3619 /* mac_address_L = bfer_address.Address_L_H.Address_Low; */
3620 /* mac_address_H = bfer_address.Address_L_H.Address_High; */
3621
3622 mac_address_L = rtk_le32_to_cpu(pSu_bfer_init->pbfer_address->Address_L_H.Address_Low);
3623 mac_address_H = rtk_le16_to_cpu(pSu_bfer_init->pbfer_address->Address_L_H.Address_High);
3624
3625 switch (pSu_bfer_init->userid) {
3626 case 0:
3627 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO, mac_address_L);
3628 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 4, mac_address_H);
3629 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 6, pSu_bfer_init->paid);
3630 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TX_CSI_RPT_PARAM_BW20, pSu_bfer_init->csi_para);
3631 break;
3632 case 1:
3633 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER1_INFO, mac_address_L);
3634 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER1_INFO + 4, mac_address_H);
3635 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER1_INFO + 6, pSu_bfer_init->paid);
3636 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TX_CSI_RPT_PARAM_BW20 + 2, pSu_bfer_init->csi_para);
3637 break;
3638 default:
3639 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_su_bfer_entry_init_88xx invalid userid %d\n", pSu_bfer_init->userid);
3640 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3641 }
3642
3643 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_su_bfer_entry_init_88xx <==========\n");
3644
3645 return HALMAC_RET_SUCCESS;
3646 }
3647
3648 /**
3649 * halmac_mu_bfee_entry_init_88xx() - config MU beamformee's registers
3650 * @pHalmac_adapter
3651 * Author : chunchu
3652 * Return : HALMAC_RET_STATUS
3653 */
3654 HALMAC_RET_STATUS
halmac_mu_bfee_entry_init_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_MU_BFEE_INIT_PARA pMu_bfee_init)3655 halmac_mu_bfee_entry_init_88xx(
3656 IN PHALMAC_ADAPTER pHalmac_adapter,
3657 IN PHALMAC_MU_BFEE_INIT_PARA pMu_bfee_init
3658 )
3659 {
3660 u16 temp168X = 0, temp14C0;
3661 VOID *pDriver_adapter = NULL;
3662 PHALMAC_API pHalmac_api;
3663
3664 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3665 return HALMAC_RET_ADAPTER_INVALID;
3666
3667 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3668 return HALMAC_RET_API_INVALID;
3669
3670 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_MU_BFEE_ENTRY_INIT);
3671
3672 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3673 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3674
3675 temp168X |= pMu_bfee_init->paid | BIT(9);
3676 HALMAC_REG_WRITE_16(pHalmac_adapter, (0x1680 + pMu_bfee_init->userid * 2), temp168X);
3677
3678 temp14C0 = HALMAC_REG_READ_16(pHalmac_adapter, REG_MU_TX_CTL) & ~(BIT(8)|BIT(9)|BIT(10));
3679 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MU_TX_CTL, temp14C0|((pMu_bfee_init->userid-2)<<8));
3680 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_GID_VLD, 0);
3681 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_USER_POS_INFO, pMu_bfee_init->user_position_l);
3682 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_MU_STA_USER_POS_INFO+4, pMu_bfee_init->user_position_h);
3683
3684 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_mu_bfee_entry_init_88xx <==========\n");
3685
3686 return HALMAC_RET_SUCCESS;
3687 }
3688
3689 /**
3690 * halmac_mu_bfer_entry_init_88xx() - config SU beamformer's registers
3691 * @pHalmac_adapter
3692 * Author : chunchu
3693 * Return : HALMAC_RET_STATUS
3694 */
3695 HALMAC_RET_STATUS
halmac_mu_bfer_entry_init_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_MU_BFER_INIT_PARA pMu_bfer_init)3696 halmac_mu_bfer_entry_init_88xx(
3697 IN PHALMAC_ADAPTER pHalmac_adapter,
3698 IN PHALMAC_MU_BFER_INIT_PARA pMu_bfer_init
3699 )
3700 {
3701 u16 temp1680 = 0;
3702 u16 mac_address_H;
3703 u32 mac_address_L;
3704 VOID *pDriver_adapter = NULL;
3705 PHALMAC_API pHalmac_api;
3706
3707 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3708 return HALMAC_RET_ADAPTER_INVALID;
3709
3710 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3711 return HALMAC_RET_API_INVALID;
3712
3713 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_MU_BFER_ENTRY_INIT);
3714
3715 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3716 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3717
3718 /* mac_address_L = pHalmac_adapter->snd_info.bfer_address.Address_L_H.Address_Low; */
3719 /* mac_address_H = pHalmac_adapter->snd_info.bfer_address.Address_L_H.Address_High; */
3720
3721 mac_address_L = rtk_le32_to_cpu(pMu_bfer_init->pbfer_address->Address_L_H.Address_Low);
3722 mac_address_H = rtk_le16_to_cpu(pMu_bfer_init->pbfer_address->Address_L_H.Address_High);
3723
3724 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO, mac_address_L);
3725 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 4, mac_address_H);
3726 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 6, pMu_bfer_init->paid);
3727 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TX_CSI_RPT_PARAM_BW20, pMu_bfer_init->csi_para);
3728
3729 temp1680 = HALMAC_REG_READ_16(pHalmac_adapter, 0x1680) & 0xC000;
3730 temp1680 |= pMu_bfer_init->my_aid | (pMu_bfer_init->csi_length_sel << 12);
3731 HALMAC_REG_WRITE_16(pHalmac_adapter, 0x1680, temp1680);
3732
3733 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_mu_bfer_entry_init_88xx <==========\n");
3734
3735 return HALMAC_RET_SUCCESS;
3736 }
3737
3738 /**
3739 * halmac_su_bfee_entry_del_88xx() - reset SU beamformee's registers
3740 * @pHalmac_adapter
3741 * Author : chunchu
3742 * Return : HALMAC_RET_STATUS
3743 */
3744 HALMAC_RET_STATUS
halmac_su_bfee_entry_del_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 userid)3745 halmac_su_bfee_entry_del_88xx(
3746 IN PHALMAC_ADAPTER pHalmac_adapter,
3747 IN u8 userid
3748 )
3749 {
3750 VOID *pDriver_adapter = NULL;
3751 PHALMAC_API pHalmac_api;
3752
3753 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3754 return HALMAC_RET_ADAPTER_INVALID;
3755
3756 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3757 return HALMAC_RET_API_INVALID;
3758
3759 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SU_BFEE_ENTRY_DEL);
3760
3761 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3762 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3763
3764 switch (userid) {
3765 case 0:
3766 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL, HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL) & \
3767 ~(BIT_MASK_R_TXBF0_AID | BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M));
3768 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMEE_SEL, 0);
3769 break;
3770 case 1:
3771 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_TXBF_CTRL + 2, HALMAC_REG_READ_16(pHalmac_adapter, REG_TXBF_CTRL + 2) & \
3772 ~(BIT_MASK_R_TXBF1_AID | BIT_R_TXBF0_20M | BIT_R_TXBF0_40M | BIT_R_TXBF0_80M));
3773 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_ASSOCIATED_BFMEE_SEL + 2, 0);
3774 break;
3775 default:
3776 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_su_bfee_entry_del_88xx invalid userid %d\n", userid);
3777 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3778 }
3779
3780 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_su_bfee_entry_del_88xx <==========\n");
3781
3782 return HALMAC_RET_SUCCESS;
3783 }
3784
3785 /**
3786 * halmac_su_bfee_entry_del_88xx() - reset SU beamformer's registers
3787 * @pHalmac_adapter
3788 * Author : chunchu
3789 * Return : HALMAC_RET_STATUS
3790 */
3791 HALMAC_RET_STATUS
halmac_su_bfer_entry_del_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 userid)3792 halmac_su_bfer_entry_del_88xx(
3793 IN PHALMAC_ADAPTER pHalmac_adapter,
3794 IN u8 userid
3795 )
3796 {
3797 VOID *pDriver_adapter = NULL;
3798 PHALMAC_API pHalmac_api;
3799
3800 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3801 return HALMAC_RET_ADAPTER_INVALID;
3802
3803 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3804 return HALMAC_RET_API_INVALID;
3805
3806 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SU_BFER_ENTRY_DEL);
3807
3808 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3809 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3810
3811 switch (userid) {
3812 case 0:
3813 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO, 0);
3814 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 4, 0);
3815 break;
3816 case 1:
3817 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER1_INFO, 0);
3818 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER1_INFO + 4, 0);
3819 break;
3820 default:
3821 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_su_bfer_entry_del_88xx invalid userid %d\n", userid);
3822 return HALMAC_RET_INVALID_SOUNDING_SETTING;
3823 }
3824
3825 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_su_bfer_entry_del_88xx <==========\n");
3826
3827 return HALMAC_RET_SUCCESS;
3828 }
3829
3830 /**
3831 * halmac_mu_bfee_entry_del_88xx() - reset MU beamformee's registers
3832 * @pHalmac_adapter
3833 * Author : chunchu
3834 * Return : HALMAC_RET_STATUS
3835 */
3836 HALMAC_RET_STATUS
halmac_mu_bfee_entry_del_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 userid)3837 halmac_mu_bfee_entry_del_88xx(
3838 IN PHALMAC_ADAPTER pHalmac_adapter,
3839 IN u8 userid
3840 )
3841 {
3842 VOID *pDriver_adapter = NULL;
3843 PHALMAC_API pHalmac_api;
3844
3845 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3846 return HALMAC_RET_ADAPTER_INVALID;
3847
3848 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3849 return HALMAC_RET_API_INVALID;
3850
3851 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_MU_BFEE_ENTRY_DEL);
3852
3853 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3854 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3855
3856 HALMAC_REG_WRITE_16(pHalmac_adapter, 0x1680 + userid * 2, 0);
3857 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL, HALMAC_REG_READ_8(pHalmac_adapter, REG_MU_TX_CTL) & ~(BIT(userid-2)));
3858
3859 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_mu_bfee_entry_del_88xx <==========\n");
3860
3861 return HALMAC_RET_SUCCESS;
3862 }
3863
3864 /**
3865 * halmac_mu_bfer_entry_del_88xx() -reset MU beamformer's registers
3866 * @pHalmac_adapter
3867 * Author : chunchu
3868 * Return : HALMAC_RET_STATUS
3869 */
3870 HALMAC_RET_STATUS
halmac_mu_bfer_entry_del_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)3871 halmac_mu_bfer_entry_del_88xx(
3872 IN PHALMAC_ADAPTER pHalmac_adapter
3873 )
3874 {
3875 VOID *pDriver_adapter = NULL;
3876 PHALMAC_API pHalmac_api;
3877
3878 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3879 return HALMAC_RET_ADAPTER_INVALID;
3880
3881 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3882 return HALMAC_RET_API_INVALID;
3883
3884 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_MU_BFER_ENTRY_DEL);
3885
3886 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3887 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3888
3889 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO, 0);
3890 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_ASSOCIATED_BFMER0_INFO + 4, 0);
3891 HALMAC_REG_WRITE_16(pHalmac_adapter, 0x1680, 0);
3892 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MU_TX_CTL, 0);
3893
3894 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_TRACE, "halmac_mu_bfer_entry_del_88xx <==========\n");
3895
3896 return HALMAC_RET_SUCCESS;
3897 }
3898
3899 /**
3900 * halmac_add_ch_info_88xx() -used to construct channel info
3901 * @pHalmac_adapter
3902 * @pCh_info
3903 * Author : KaiYuan Chang/Ivan Lin
3904 * Return : HALMAC_RET_STATUS
3905 */
3906 HALMAC_RET_STATUS
halmac_add_ch_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_CH_INFO pCh_info)3907 halmac_add_ch_info_88xx(
3908 IN PHALMAC_ADAPTER pHalmac_adapter,
3909 IN PHALMAC_CH_INFO pCh_info
3910 )
3911 {
3912 VOID *pDriver_adapter = NULL;
3913 PHALMAC_CS_INFO pCh_sw_info;
3914 HALMAC_SCAN_CMD_CONSTRUCT_STATE state_scan;
3915
3916 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3917 return HALMAC_RET_ADAPTER_INVALID;
3918
3919 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
3920 return HALMAC_RET_API_INVALID;
3921
3922 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_ADD_CH_INFO);
3923
3924 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3925 pCh_sw_info = &(pHalmac_adapter->ch_sw_info);
3926
3927 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_add_ch_info_88xx ==========>\n");
3928
3929 if (HALMAC_GEN_INFO_SENT != pHalmac_adapter->halmac_state.dlfw_state) {
3930 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_ch_info_88xx: gen_info is not send to FW!!!!\n");
3931 return HALMAC_RET_GEN_INFO_NOT_SENT;
3932 }
3933
3934 state_scan = halmac_query_scan_curr_state_88xx(pHalmac_adapter);
3935 if ((HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED != state_scan) && (HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING != state_scan)) {
3936 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Scan machine fail(add ch info)...\n");
3937 return HALMAC_RET_ERROR_STATE;
3938 }
3939
3940 if (NULL == pCh_sw_info->ch_info_buf) {
3941 pCh_sw_info->ch_info_buf = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, HALMAC_EXTRA_INFO_BUFF_SIZE_88XX);
3942 pCh_sw_info->ch_info_buf_w = pCh_sw_info->ch_info_buf;
3943 pCh_sw_info->buf_size = HALMAC_EXTRA_INFO_BUFF_SIZE_88XX;
3944 pCh_sw_info->avai_buf_size = HALMAC_EXTRA_INFO_BUFF_SIZE_88XX;
3945 pCh_sw_info->total_size = 0;
3946 pCh_sw_info->extra_info_en = 0;
3947 pCh_sw_info->ch_num = 0;
3948 }
3949
3950 if (1 == pCh_sw_info->extra_info_en) {
3951 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_ch_info_88xx: construct sequence wrong!!\n");
3952 return HALMAC_RET_CH_SW_SEQ_WRONG;
3953 }
3954
3955 if (4 > pCh_sw_info->avai_buf_size) {
3956 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_ch_info_88xx: no availabe buffer!!\n");
3957 return HALMAC_RET_CH_SW_NO_BUF;
3958 }
3959
3960 if (HALMAC_RET_SUCCESS != halmac_transition_scan_state_88xx(pHalmac_adapter, HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING))
3961 return HALMAC_RET_ERROR_STATE;
3962
3963 CHANNEL_INFO_SET_CHANNEL(pCh_sw_info->ch_info_buf_w, pCh_info->channel);
3964 CHANNEL_INFO_SET_PRI_CH_IDX(pCh_sw_info->ch_info_buf_w, pCh_info->pri_ch_idx);
3965 CHANNEL_INFO_SET_BANDWIDTH(pCh_sw_info->ch_info_buf_w, pCh_info->bw);
3966 CHANNEL_INFO_SET_TIMEOUT(pCh_sw_info->ch_info_buf_w, pCh_info->timeout);
3967 CHANNEL_INFO_SET_ACTION_ID(pCh_sw_info->ch_info_buf_w, pCh_info->action_id);
3968 CHANNEL_INFO_SET_CH_EXTRA_INFO(pCh_sw_info->ch_info_buf_w, pCh_info->extra_info);
3969
3970 pCh_sw_info->avai_buf_size = pCh_sw_info->avai_buf_size - 4;
3971 pCh_sw_info->total_size = pCh_sw_info->total_size + 4;
3972 pCh_sw_info->ch_num++;
3973 pCh_sw_info->extra_info_en = pCh_info->extra_info;
3974 pCh_sw_info->ch_info_buf_w = pCh_sw_info->ch_info_buf_w + 4;
3975
3976 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_add_ch_info_88xx <==========\n");
3977
3978 return HALMAC_RET_SUCCESS;
3979 }
3980
3981 /**
3982 * halmac_add_extra_ch_info_88xx() -used to construct extra channel info
3983 * @pHalmac_adapter
3984 * @pCh_extra_info
3985 * Author : KaiYuan Chang/Ivan Lin
3986 * Return : HALMAC_RET_STATUS
3987 */
3988 HALMAC_RET_STATUS
halmac_add_extra_ch_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_CH_EXTRA_INFO pCh_extra_info)3989 halmac_add_extra_ch_info_88xx(
3990 IN PHALMAC_ADAPTER pHalmac_adapter,
3991 IN PHALMAC_CH_EXTRA_INFO pCh_extra_info
3992 )
3993 {
3994 VOID *pDriver_adapter = NULL;
3995 PHALMAC_CS_INFO pCh_sw_info;
3996
3997 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
3998 return HALMAC_RET_ADAPTER_INVALID;
3999
4000 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4001 return HALMAC_RET_API_INVALID;
4002
4003 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_ADD_EXTRA_CH_INFO);
4004
4005 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4006 pCh_sw_info = &(pHalmac_adapter->ch_sw_info);
4007
4008 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_add_extra_ch_info_88xx ==========>\n");
4009
4010 if (NULL == pCh_sw_info->ch_info_buf) {
4011 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_extra_ch_info_88xx: NULL==pCh_sw_info->ch_info_buf!!\n");
4012 return HALMAC_RET_CH_SW_SEQ_WRONG;
4013 }
4014
4015 if (0 == pCh_sw_info->extra_info_en) {
4016 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_extra_ch_info_88xx: construct sequence wrong!!\n");
4017 return HALMAC_RET_CH_SW_SEQ_WRONG;
4018 }
4019
4020 if (pCh_sw_info->avai_buf_size < (u32)(pCh_extra_info->extra_info_size + 2)) {/* 2:ch_extra_info_id, ch_extra_info, ch_extra_info_size are totally 2Byte */
4021 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_add_extra_ch_info_88xx: no availabe buffer!!\n");
4022 return HALMAC_RET_CH_SW_NO_BUF;
4023 }
4024
4025 if (HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING != halmac_query_scan_curr_state_88xx(pHalmac_adapter)) {
4026 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Scan machine fail(add extra ch info)...\n");
4027 return HALMAC_RET_ERROR_STATE;
4028 }
4029
4030 if (HALMAC_RET_SUCCESS != halmac_transition_scan_state_88xx(pHalmac_adapter, HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING))
4031 return HALMAC_RET_ERROR_STATE;
4032
4033 CH_EXTRA_INFO_SET_CH_EXTRA_INFO_ID(pCh_sw_info->ch_info_buf_w, pCh_extra_info->extra_action_id);
4034 CH_EXTRA_INFO_SET_CH_EXTRA_INFO(pCh_sw_info->ch_info_buf_w, pCh_extra_info->extra_info);
4035 CH_EXTRA_INFO_SET_CH_EXTRA_INFO_SIZE(pCh_sw_info->ch_info_buf_w, pCh_extra_info->extra_info_size);
4036 PLATFORM_RTL_MEMCPY(pDriver_adapter, pCh_sw_info->ch_info_buf_w + 2, pCh_extra_info->extra_info_data, pCh_extra_info->extra_info_size);
4037
4038 pCh_sw_info->avai_buf_size = pCh_sw_info->avai_buf_size - (2 + pCh_extra_info->extra_info_size);
4039 pCh_sw_info->total_size = pCh_sw_info->total_size + (2 + pCh_extra_info->extra_info_size);
4040 pCh_sw_info->extra_info_en = pCh_extra_info->extra_info;
4041 pCh_sw_info->ch_info_buf_w = pCh_sw_info->ch_info_buf_w + (2 + pCh_extra_info->extra_info_size);
4042
4043 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_add_extra_ch_info_88xx <==========\n");
4044
4045 return HALMAC_RET_SUCCESS;
4046 }
4047
4048 /**
4049 * halmac_ctrl_ch_switch_88xx() -used to send channel switch cmd
4050 * @pHalmac_adapter
4051 * @pCs_option
4052 * Author : KaiYuan Chang/Ivan Lin
4053 * Return : HALMAC_RET_STATUS
4054 */
4055 HALMAC_RET_STATUS
halmac_ctrl_ch_switch_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_CH_SWITCH_OPTION pCs_option)4056 halmac_ctrl_ch_switch_88xx(
4057 IN PHALMAC_ADAPTER pHalmac_adapter,
4058 IN PHALMAC_CH_SWITCH_OPTION pCs_option
4059 )
4060 {
4061 VOID *pDriver_adapter = NULL;
4062 PHALMAC_API pHalmac_api;
4063 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4064 HALMAC_SCAN_CMD_CONSTRUCT_STATE state_scan;
4065 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.scan_state_set.process_status);
4066
4067 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4068 return HALMAC_RET_ADAPTER_INVALID;
4069
4070 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4071 return HALMAC_RET_API_INVALID;
4072
4073 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
4074 return HALMAC_RET_NO_DLFW;
4075
4076 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CTRL_CH_SWITCH);
4077
4078 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4079 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
4080
4081 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_ctrl_ch_switch_88xx pCs_option->switch_en = %d==========>\n", pCs_option->switch_en);
4082
4083 if (_FALSE == pCs_option->switch_en)
4084 *pProcess_status = HALMAC_CMD_PROCESS_IDLE;
4085
4086 if ((HALMAC_CMD_PROCESS_SENDING == *pProcess_status) || (HALMAC_CMD_PROCESS_RCVD == *pProcess_status)) {
4087 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(ctrl ch switch)...\n");
4088 return HALMAC_RET_BUSY_STATE;
4089 }
4090
4091 state_scan = halmac_query_scan_curr_state_88xx(pHalmac_adapter);
4092 if (_TRUE == pCs_option->switch_en) {
4093 if (HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING != state_scan) {
4094 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_ctrl_ch_switch_88xx(on) invalid in state %x\n", state_scan);
4095 return HALMAC_RET_ERROR_STATE;
4096 }
4097 } else {
4098 if (HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED != state_scan) {
4099 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_ctrl_ch_switch_88xx(off) invalid in state %x\n", state_scan);
4100 return HALMAC_RET_ERROR_STATE;
4101 }
4102 }
4103
4104 status = halmac_func_ctrl_ch_switch_88xx(pHalmac_adapter, pCs_option);
4105
4106 if (HALMAC_RET_SUCCESS != status) {
4107 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_ctrl_ch_switch FAIL = %x!!\n", status);
4108 return status;
4109 }
4110
4111 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_ctrl_ch_switch_88xx <==========\n");
4112
4113 return HALMAC_RET_SUCCESS;
4114 }
4115
4116 /**
4117 * halmac_clear_ch_info_88xx() -used to clear channel info
4118 * @pHalmac_adapter
4119 * Author : KaiYuan Chang/Ivan Lin
4120 * Return : HALMAC_RET_STATUS
4121 */
4122 HALMAC_RET_STATUS
halmac_clear_ch_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)4123 halmac_clear_ch_info_88xx(
4124 IN PHALMAC_ADAPTER pHalmac_adapter
4125 )
4126 {
4127 VOID *pDriver_adapter = NULL;
4128 PHALMAC_API pHalmac_api;
4129
4130 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4131 return HALMAC_RET_ADAPTER_INVALID;
4132
4133 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4134 return HALMAC_RET_API_INVALID;
4135
4136 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CLEAR_CH_INFO);
4137
4138 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4139 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
4140
4141 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_clear_ch_info_88xx ==========>\n");
4142
4143 if (HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT == halmac_query_scan_curr_state_88xx(pHalmac_adapter)) {
4144 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Scan machine fail(clear ch info)...\n");
4145 return HALMAC_RET_ERROR_STATE;
4146 }
4147
4148 if (HALMAC_RET_SUCCESS != halmac_transition_scan_state_88xx(pHalmac_adapter, HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED))
4149 return HALMAC_RET_ERROR_STATE;
4150
4151 PLATFORM_RTL_FREE(pDriver_adapter, pHalmac_adapter->ch_sw_info.ch_info_buf, pHalmac_adapter->ch_sw_info.buf_size);
4152 pHalmac_adapter->ch_sw_info.ch_info_buf = NULL;
4153 pHalmac_adapter->ch_sw_info.ch_info_buf_w = NULL;
4154 pHalmac_adapter->ch_sw_info.extra_info_en = 0;
4155 pHalmac_adapter->ch_sw_info.buf_size = 0;
4156 pHalmac_adapter->ch_sw_info.avai_buf_size = 0;
4157 pHalmac_adapter->ch_sw_info.total_size = 0;
4158 pHalmac_adapter->ch_sw_info.ch_num = 0;
4159
4160 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_clear_ch_info_88xx <==========\n");
4161
4162 return HALMAC_RET_SUCCESS;
4163 }
4164
4165 /**
4166 * halmac_send_general_info_88xx() -send general info
4167 * @pHalmac_adapter
4168 * @pGeneral_info
4169 * Author : KaiYuan Chang/Ivan Lin
4170 * Return : HALMAC_RET_STATUS
4171 */
4172 HALMAC_RET_STATUS
halmac_send_general_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_GENERAL_INFO pGeneral_info)4173 halmac_send_general_info_88xx(
4174 IN PHALMAC_ADAPTER pHalmac_adapter,
4175 IN PHALMAC_GENERAL_INFO pGeneral_info
4176 )
4177 {
4178 VOID *pDriver_adapter = NULL;
4179 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4180
4181 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4182 return HALMAC_RET_ADAPTER_INVALID;
4183
4184 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4185 return HALMAC_RET_API_INVALID;
4186
4187 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
4188 return HALMAC_RET_NO_DLFW;
4189
4190 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SEND_GENERAL_INFO);
4191
4192 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4193
4194 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_general_info_88xx ==========>\n");
4195
4196 if (HALMAC_DLFW_NONE == pHalmac_adapter->halmac_state.dlfw_state) {
4197 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_general_info_88xx Fail due to DLFW NONE!!\n");
4198 return HALMAC_RET_DLFW_FAIL;
4199 }
4200
4201 status = halmac_func_send_general_info_88xx(pHalmac_adapter, pGeneral_info);
4202
4203 if (HALMAC_RET_SUCCESS != status) {
4204 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_send_general_info error = %x\n", status);
4205 return status;
4206 }
4207
4208 if (HALMAC_DLFW_DONE == pHalmac_adapter->halmac_state.dlfw_state)
4209 pHalmac_adapter->halmac_state.dlfw_state = HALMAC_GEN_INFO_SENT;
4210
4211 pHalmac_adapter->gen_info_valid = _TRUE;
4212 PLATFORM_RTL_MEMCPY(pDriver_adapter, &(pHalmac_adapter->general_info), pGeneral_info, sizeof(HALMAC_GENERAL_INFO));
4213
4214 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_general_info_88xx <==========\n");
4215
4216 return HALMAC_RET_SUCCESS;
4217 }
4218
4219 /**
4220 * halmac_start_iqk_88xx() -start iqk
4221 * @pHalmac_adapter
4222 * @clear
4223 * Author : KaiYuan Chang/Ivan Lin
4224 * Return : HALMAC_RET_STATUS
4225 */
4226 HALMAC_RET_STATUS
halmac_start_iqk_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 clear)4227 halmac_start_iqk_88xx(
4228 IN PHALMAC_ADAPTER pHalmac_adapter,
4229 IN u8 clear
4230 )
4231 {
4232 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
4233 u16 h2c_seq_num = 0;
4234 VOID *pDriver_adapter = NULL;
4235 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4236 HALMAC_H2C_HEADER_INFO h2c_header_info;
4237 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.iqk_set.process_status);
4238
4239 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4240 return HALMAC_RET_ADAPTER_INVALID;
4241
4242 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4243 return HALMAC_RET_API_INVALID;
4244
4245 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
4246 return HALMAC_RET_NO_DLFW;
4247
4248 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_START_IQK);
4249
4250 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4251
4252 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_start_iqk_88xx ==========>\n");
4253
4254 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
4255 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(iqk)...\n");
4256 return HALMAC_RET_BUSY_STATE;
4257 }
4258
4259 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
4260
4261 IQK_SET_CLEAR(pH2c_buff, clear);
4262
4263 h2c_header_info.sub_cmd_id = SUB_CMD_ID_IQK;
4264 h2c_header_info.content_size = 1;
4265 h2c_header_info.ack = _TRUE;
4266 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_num);
4267
4268 pHalmac_adapter->halmac_state.iqk_set.seq_num = h2c_seq_num;
4269
4270 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
4271
4272 if (HALMAC_RET_SUCCESS != status) {
4273 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
4274 return status;
4275 }
4276
4277 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_start_iqk_88xx <==========\n");
4278
4279 return HALMAC_RET_SUCCESS;
4280 }
4281
4282 /**
4283 * halmac_ctrl_pwr_tracking_88xx() -control power tracking
4284 * @pHalmac_adapter
4285 * @pPwr_tracking_opt
4286 * Author : KaiYuan Chang/Ivan Lin
4287 * Return : HALMAC_RET_STATUS
4288 */
4289 HALMAC_RET_STATUS
halmac_ctrl_pwr_tracking_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PWR_TRACKING_OPTION pPwr_tracking_opt)4290 halmac_ctrl_pwr_tracking_88xx(
4291 IN PHALMAC_ADAPTER pHalmac_adapter,
4292 IN PHALMAC_PWR_TRACKING_OPTION pPwr_tracking_opt
4293 )
4294 {
4295 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
4296 u16 h2c_seq_mum = 0;
4297 VOID *pDriver_adapter = NULL;
4298 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4299 HALMAC_H2C_HEADER_INFO h2c_header_info;
4300 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.power_tracking_set.process_status);
4301
4302 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4303 return HALMAC_RET_ADAPTER_INVALID;
4304
4305 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4306 return HALMAC_RET_API_INVALID;
4307
4308 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
4309 return HALMAC_RET_NO_DLFW;
4310
4311 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CTRL_PWR_TRACKING);
4312
4313 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4314
4315 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_start_iqk_88xx ==========>\n");
4316
4317 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
4318 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(pwr tracking)...\n");
4319 return HALMAC_RET_BUSY_STATE;
4320 }
4321
4322 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
4323
4324 POWER_TRACKING_SET_TYPE(pH2c_buff, pPwr_tracking_opt->type);
4325 POWER_TRACKING_SET_BBSWING_INDEX(pH2c_buff, pPwr_tracking_opt->bbswing_index);
4326 POWER_TRACKING_SET_ENABLE_A(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_A].enable);
4327 POWER_TRACKING_SET_TX_PWR_INDEX_A(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_A].tx_pwr_index);
4328 POWER_TRACKING_SET_PWR_TRACKING_OFFSET_VALUE_A(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_A].pwr_tracking_offset_value);
4329 POWER_TRACKING_SET_TSSI_VALUE_A(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_A].tssi_value);
4330 POWER_TRACKING_SET_ENABLE_B(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_B].enable);
4331 POWER_TRACKING_SET_TX_PWR_INDEX_B(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_B].tx_pwr_index);
4332 POWER_TRACKING_SET_PWR_TRACKING_OFFSET_VALUE_B(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_B].pwr_tracking_offset_value);
4333 POWER_TRACKING_SET_TSSI_VALUE_B(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_B].tssi_value);
4334 POWER_TRACKING_SET_ENABLE_C(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_C].enable);
4335 POWER_TRACKING_SET_TX_PWR_INDEX_C(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_C].tx_pwr_index);
4336 POWER_TRACKING_SET_PWR_TRACKING_OFFSET_VALUE_C(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_C].pwr_tracking_offset_value);
4337 POWER_TRACKING_SET_TSSI_VALUE_C(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_C].tssi_value);
4338 POWER_TRACKING_SET_ENABLE_D(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_D].enable);
4339 POWER_TRACKING_SET_TX_PWR_INDEX_D(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_D].tx_pwr_index);
4340 POWER_TRACKING_SET_PWR_TRACKING_OFFSET_VALUE_D(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_D].pwr_tracking_offset_value);
4341 POWER_TRACKING_SET_TSSI_VALUE_D(pH2c_buff, pPwr_tracking_opt->pwr_tracking_para[HALMAC_RF_PATH_D].tssi_value);
4342
4343 h2c_header_info.sub_cmd_id = SUB_CMD_ID_POWER_TRACKING;
4344 h2c_header_info.content_size = 20;
4345 h2c_header_info.ack = _TRUE;
4346 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
4347
4348 pHalmac_adapter->halmac_state.power_tracking_set.seq_num = h2c_seq_mum;
4349
4350 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
4351
4352 if (HALMAC_RET_SUCCESS != status) {
4353 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
4354 return status;
4355 }
4356
4357 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_start_iqk_88xx <==========\n");
4358
4359 return HALMAC_RET_SUCCESS;
4360 }
4361
4362 /**
4363 * halmac_query_status_88xx() -query async feature status
4364 * @pHalmac_adapter
4365 * @feature_id
4366 * @pProcess_status
4367 * @data
4368 * @size
4369 *
4370 * Note :
4371 * If user wants to know the data size, use can allocate random
4372 * size buffer first. If this size less than the data size, halmac
4373 * will return HALMAC_RET_BUFFER_TOO_SMALL. User need to
4374 * re-allocate data buffer with correct data size.
4375 *
4376 * Author : Ivan Lin/KaiYuan Chang
4377 * Return : HALMAC_RET_STATUS
4378 */
4379 HALMAC_RET_STATUS
halmac_query_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_FEATURE_ID feature_id,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)4380 halmac_query_status_88xx(
4381 IN PHALMAC_ADAPTER pHalmac_adapter,
4382 IN HALMAC_FEATURE_ID feature_id,
4383 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
4384 INOUT u8 *data,
4385 INOUT u32 *size
4386 )
4387 {
4388 VOID *pDriver_adapter = NULL;
4389 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4390
4391 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4392 return HALMAC_RET_ADAPTER_INVALID;
4393
4394 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4395 return HALMAC_RET_API_INVALID;
4396
4397 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_QUERY_STATE);
4398
4399 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4400
4401 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_query_status_88xx ==========>\n"); */
4402
4403 if (NULL == pProcess_status) {
4404 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "null pointer!!\n");
4405 return HALMAC_RET_NULL_POINTER;
4406 }
4407
4408 switch (feature_id) {
4409 case HALMAC_FEATURE_CFG_PARA:
4410 status = halmac_query_cfg_para_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4411 break;
4412 case HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE:
4413 status = halmac_query_dump_physical_efuse_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4414 break;
4415 case HALMAC_FEATURE_DUMP_LOGICAL_EFUSE:
4416 status = halmac_query_dump_logical_efuse_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4417 break;
4418 case HALMAC_FEATURE_CHANNEL_SWITCH:
4419 status = halmac_query_channel_switch_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4420 break;
4421 case HALMAC_FEATURE_UPDATE_PACKET:
4422 status = halmac_query_update_packet_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4423 break;
4424 case HALMAC_FEATURE_IQK:
4425 status = halmac_query_iqk_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4426 break;
4427 case HALMAC_FEATURE_POWER_TRACKING:
4428 status = halmac_query_power_tracking_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4429 break;
4430 case HALMAC_FEATURE_PSD:
4431 status = halmac_query_psd_status_88xx(pHalmac_adapter, pProcess_status, data, size);
4432 break;
4433 default:
4434 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_query_status_88xx invalid feature id %d\n", feature_id);
4435 return HALMAC_RET_INVALID_FEATURE_ID;
4436 }
4437
4438 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_query_status_88xx <==========\n"); */
4439
4440 return status;
4441 }
4442
4443 /**
4444 * halmac_reset_feature_88xx() -reset async feature status
4445 * @pHalmac_adapter
4446 * @feature_id
4447 * Author : Ivan Lin/KaiYuan Chang
4448 * Return : HALMAC_RET_STATUS
4449 */
4450 HALMAC_RET_STATUS
halmac_reset_feature_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_FEATURE_ID feature_id)4451 halmac_reset_feature_88xx(
4452 IN PHALMAC_ADAPTER pHalmac_adapter,
4453 IN HALMAC_FEATURE_ID feature_id
4454 )
4455 {
4456 VOID *pDriver_adapter = NULL;
4457 PHALMAC_STATE pState = &(pHalmac_adapter->halmac_state);
4458
4459 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4460 return HALMAC_RET_ADAPTER_INVALID;
4461
4462 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4463 return HALMAC_RET_API_INVALID;
4464
4465 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_RESET_FEATURE);
4466
4467 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4468
4469 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_reset_feature_88xx ==========>\n");
4470
4471 switch (feature_id) {
4472 case HALMAC_FEATURE_CFG_PARA:
4473 pState->cfg_para_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4474 pState->cfg_para_state_set.cfg_para_cmd_construct_state = HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE;
4475 break;
4476 case HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE:
4477 case HALMAC_FEATURE_DUMP_LOGICAL_EFUSE:
4478 pState->efuse_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4479 pState->efuse_state_set.efuse_cmd_construct_state = HALMAC_EFUSE_CMD_CONSTRUCT_IDLE;
4480 break;
4481 case HALMAC_FEATURE_CHANNEL_SWITCH:
4482 pState->scan_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4483 pState->scan_state_set.scan_cmd_construct_state = HALMAC_SCAN_CMD_CONSTRUCT_IDLE;
4484 break;
4485 case HALMAC_FEATURE_UPDATE_PACKET:
4486 pState->update_packet_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4487 break;
4488 case HALMAC_FEATURE_ALL:
4489 pState->cfg_para_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4490 pState->cfg_para_state_set.cfg_para_cmd_construct_state = HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE;
4491 pState->efuse_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4492 pState->efuse_state_set.efuse_cmd_construct_state = HALMAC_EFUSE_CMD_CONSTRUCT_IDLE;
4493 pState->scan_state_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4494 pState->scan_state_set.scan_cmd_construct_state = HALMAC_SCAN_CMD_CONSTRUCT_IDLE;
4495 pState->update_packet_set.process_status = HALMAC_CMD_PROCESS_IDLE;
4496 break;
4497 default:
4498 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_SND, HALMAC_DBG_ERR, "halmac_reset_feature_88xx invalid feature id %d \n", feature_id);
4499 return HALMAC_RET_INVALID_FEATURE_ID;
4500 }
4501
4502 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_reset_feature_88xx <==========\n");
4503
4504 return HALMAC_RET_SUCCESS;
4505 }
4506
4507 /**
4508 * halmac_check_fw_status_88xx() -check fw status
4509 * @pHalmac_adapter
4510 * @fw_status
4511 * Author : KaiYuan Chang/Ivan Lin
4512 * Return : HALMAC_RET_STATUS
4513 */
4514 HALMAC_RET_STATUS
halmac_check_fw_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u8 * fw_status)4515 halmac_check_fw_status_88xx(
4516 IN PHALMAC_ADAPTER pHalmac_adapter,
4517 OUT u8 *fw_status
4518 )
4519 {
4520 u32 value32 = 0, value32_backup = 0, i = 0;
4521 VOID *pDriver_adapter = NULL;
4522 PHALMAC_API pHalmac_api;
4523 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4524
4525 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4526 return HALMAC_RET_ADAPTER_INVALID;
4527
4528 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4529 return HALMAC_RET_API_INVALID;
4530
4531 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CHECK_FW_STATUS);
4532
4533 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4534 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
4535
4536 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_check_fw_status_88xx ==========>\n");
4537
4538 value32 = PLATFORM_REG_READ_32(pDriver_adapter, REG_FW_DBG6);
4539
4540 if (0 != value32) {
4541 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_check_fw_status REG_FW_DBG6 !=0\n");
4542 *fw_status = _FALSE;
4543 return status;
4544 }
4545
4546 value32_backup = PLATFORM_REG_READ_32(pDriver_adapter, REG_FW_DBG7);
4547
4548 for (i = 0; i <= 10; i++) {
4549 value32 = PLATFORM_REG_READ_32(pDriver_adapter, REG_FW_DBG7);
4550 if (value32_backup != value32) {
4551 break;
4552 } else {
4553 if (10 == i) {
4554 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_check_fw_status Polling FW PC fail\n");
4555 *fw_status = _FALSE;
4556 return status;
4557 }
4558 }
4559 }
4560
4561 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_check_fw_status_88xx <==========\n");
4562
4563 return status;
4564 }
4565
4566 /**
4567 * halmac_dump_fw_dmem_88xx() -dump dmem
4568 * @pHalmac_adapter
4569 * @dmem
4570 * @size
4571 * Author : KaiYuan Chang/Ivan Lin
4572 * Return : HALMAC_RET_STATUS
4573 */
4574 HALMAC_RET_STATUS
halmac_dump_fw_dmem_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,INOUT u8 * dmem,INOUT u32 * size)4575 halmac_dump_fw_dmem_88xx(
4576 IN PHALMAC_ADAPTER pHalmac_adapter,
4577 INOUT u8 *dmem,
4578 INOUT u32 *size
4579 )
4580 {
4581 VOID *pDriver_adapter = NULL;
4582 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4583
4584 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4585 return HALMAC_RET_ADAPTER_INVALID;
4586
4587 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4588 return HALMAC_RET_API_INVALID;
4589
4590 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DUMP_FW_DMEM);
4591
4592 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4593
4594 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_dump_fw_dmem_88xx ==========>\n");
4595
4596
4597
4598 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_dump_fw_dmem_88xx <==========\n");
4599
4600 return status;
4601 }
4602
4603 /**
4604 * halmac_cfg_max_dl_size_88xx() - config max download size
4605 * @pHalmac_adapter
4606 * @halmac_offset
4607 * Author : Ivan Lin/KaiYuan Chang
4608 *
4609 * Halmac uses this setting to set max packet size for
4610 * download FW.
4611 * If user has not called this API, halmac use default
4612 * setting for download FW
4613 * Note1 : size need power of 2
4614 * Note2 : max size is 31K
4615 *
4616 * Return : HALMAC_RET_STATUS
4617 */
4618 HALMAC_RET_STATUS
halmac_cfg_max_dl_size_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 size)4619 halmac_cfg_max_dl_size_88xx(
4620 IN PHALMAC_ADAPTER pHalmac_adapter,
4621 IN u32 size
4622 )
4623 {
4624 VOID *pDriver_adapter = NULL;
4625
4626 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4627 return HALMAC_RET_ADAPTER_INVALID;
4628
4629 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4630 return HALMAC_RET_API_INVALID;
4631
4632 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_MAX_DL_SIZE);
4633
4634 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4635
4636 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_TRACE, "halmac_cfg_max_dl_size_88xx ==========>\n");
4637
4638 if (size > HALMAC_FW_CFG_MAX_DL_SIZE_MAX_88XX) {
4639 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "size > HALMAC_FW_CFG_MAX_DL_SIZE_MAX!\n");
4640 return HALMAC_RET_CFG_DLFW_SIZE_FAIL;
4641 }
4642
4643 if (0 != (size & (2 - 1))) {
4644 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "size is not power of 2!\n");
4645 return HALMAC_RET_CFG_DLFW_SIZE_FAIL;
4646 }
4647
4648 pHalmac_adapter->max_download_size = size;
4649
4650 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_TRACE, "Cfg max size is : %X\n", size);
4651
4652 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_TRACE, "halmac_cfg_max_dl_size_88xx <==========\n");
4653
4654 return HALMAC_RET_SUCCESS;
4655 }
4656
4657 /**
4658 * halmac_psd_88xx() - trigger fw offload psd
4659 * @pHalmac_adapter
4660 * @start_psd
4661 * @end_psd
4662 * Author : KaiYuan Chang/Ivan Lin
4663 * Return : HALMAC_RET_STATUS
4664 */
4665 HALMAC_RET_STATUS
halmac_psd_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u16 start_psd,IN u16 end_psd)4666 halmac_psd_88xx(
4667 IN PHALMAC_ADAPTER pHalmac_adapter,
4668 IN u16 start_psd,
4669 IN u16 end_psd
4670 )
4671 {
4672 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
4673 u16 h2c_seq_mum = 0;
4674 VOID *pDriver_adapter = NULL;
4675 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4676 HALMAC_H2C_HEADER_INFO h2c_header_info;
4677 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.psd_set.process_status);
4678
4679 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4680 return HALMAC_RET_ADAPTER_INVALID;
4681
4682 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4683 return HALMAC_RET_API_INVALID;
4684
4685 if (HALMAC_RET_SUCCESS != halmac_fw_validate(pHalmac_adapter))
4686 return HALMAC_RET_NO_DLFW;
4687
4688 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_PSD);
4689
4690 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4691
4692 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_psd_88xx ==========>\n");
4693
4694 if (HALMAC_CMD_PROCESS_SENDING == *pProcess_status) {
4695 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Wait event(psd)...\n");
4696 return HALMAC_RET_BUSY_STATE;
4697 }
4698
4699 if (NULL != pHalmac_adapter->halmac_state.psd_set.pData) {
4700 PLATFORM_RTL_FREE(pDriver_adapter, pHalmac_adapter->halmac_state.psd_set.pData, pHalmac_adapter->halmac_state.psd_set.data_size);
4701 pHalmac_adapter->halmac_state.psd_set.pData = (u8 *)NULL;
4702 }
4703
4704 pHalmac_adapter->halmac_state.psd_set.data_size = 0;
4705 pHalmac_adapter->halmac_state.psd_set.segment_size = 0;
4706
4707 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
4708
4709 PSD_SET_START_PSD(pH2c_buff, start_psd);
4710 PSD_SET_END_PSD(pH2c_buff, end_psd);
4711
4712 h2c_header_info.sub_cmd_id = SUB_CMD_ID_PSD;
4713 h2c_header_info.content_size = 4;
4714 h2c_header_info.ack = _TRUE;
4715 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
4716
4717 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
4718
4719 if (HALMAC_RET_SUCCESS != status) {
4720 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
4721 return status;
4722 }
4723
4724 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_psd_88xx <==========\n");
4725
4726 return HALMAC_RET_SUCCESS;
4727 }
4728
4729 /**
4730 * halmac_cfg_la_mode_88xx() - config la mode
4731 * @pHalmac_adapter
4732 * @la_mode
4733 * Author : KaiYuan Chang
4734 * Return : HALMAC_RET_STATUS
4735 */
4736 HALMAC_RET_STATUS
halmac_cfg_la_mode_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_LA_MODE la_mode)4737 halmac_cfg_la_mode_88xx(
4738 IN PHALMAC_ADAPTER pHalmac_adapter,
4739 IN HALMAC_LA_MODE la_mode
4740 )
4741 {
4742 VOID *pDriver_adapter = NULL;
4743
4744 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4745 return HALMAC_RET_ADAPTER_INVALID;
4746
4747 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4748 return HALMAC_RET_API_INVALID;
4749
4750 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_LA_MODE);
4751
4752 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4753
4754 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_la_mode_88xx ==========>la_mode = %d\n", la_mode);
4755
4756 pHalmac_adapter->txff_allocation.la_mode = la_mode;
4757
4758 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_la_mode_88xx <==========\n");
4759
4760 return HALMAC_RET_SUCCESS;
4761 }
4762
4763
4764 /**
4765 * halmac_get_hw_value_88xx() -
4766 * @pHalmac_adapter
4767 * @hw_id
4768 * @pvalue
4769 * Author : KaiYuan Chang
4770 * Return : HALMAC_RET_STATUS
4771 */
4772 HALMAC_RET_STATUS
halmac_get_hw_value_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_HW_ID hw_id,OUT VOID * pvalue)4773 halmac_get_hw_value_88xx(
4774 IN PHALMAC_ADAPTER pHalmac_adapter,
4775 IN HALMAC_HW_ID hw_id,
4776 OUT VOID *pvalue
4777 )
4778 {
4779 VOID *pDriver_adapter = NULL;
4780 PHALMAC_RQPN_MAP pRQPN_Map;
4781 u32 *pEfuse_size, *pTxff_size;
4782 u16 *pDrv_pg_bndy;
4783 u16 hcpwm2 = 0;
4784 u8 hcpwm = 0;
4785 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
4786
4787 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4788 return HALMAC_RET_ADAPTER_INVALID;
4789
4790 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4791 return HALMAC_RET_API_INVALID;
4792
4793 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_HW_VALUE);
4794
4795 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4796
4797 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_hw_value_88xx ==========>\n");
4798
4799 if (NULL == pvalue) {
4800 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_get_hw_value_88xx (NULL ==pvalue)==========>\n");
4801 return HALMAC_RET_NULL_POINTER;
4802 }
4803 switch (hw_id) {
4804 case HALMAC_HW_RQPN_MAPPING:
4805 pRQPN_Map = (PHALMAC_RQPN_MAP)pvalue;
4806 pRQPN_Map->dma_map_vo = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VO];
4807 pRQPN_Map->dma_map_vi = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VI];
4808 pRQPN_Map->dma_map_be = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BE];
4809 pRQPN_Map->dma_map_bk = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BK];
4810 pRQPN_Map->dma_map_mg = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_MG];
4811 pRQPN_Map->dma_map_hi = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_HI];
4812 break;
4813 case HALMAC_HW_EFUSE_SIZE:
4814 pEfuse_size = (pu32)pvalue;
4815 halmac_get_efuse_size_88xx(pHalmac_adapter, pEfuse_size);
4816 break;
4817 case HALMAC_HW_EEPROM_SIZE:
4818 pEfuse_size = (pu32)pvalue;
4819 *pEfuse_size = pHalmac_adapter->hw_config_info.eeprom_size;
4820 halmac_get_logical_efuse_size_88xx(pHalmac_adapter, pEfuse_size);
4821 break;
4822 case HALMAC_HW_BT_BANK_EFUSE_SIZE:
4823 *(u32 *)pvalue = pHalmac_adapter->hw_config_info.bt_efuse_size;
4824 break;
4825 case HALMAC_HW_BT_BANK1_EFUSE_SIZE:
4826 case HALMAC_HW_BT_BANK2_EFUSE_SIZE:
4827 *(u32 *)pvalue = 0;
4828 break;
4829 case HALMAC_HW_TXFIFO_SIZE:
4830 pTxff_size = (pu32)pvalue;
4831 *pTxff_size = pHalmac_adapter->hw_config_info.tx_fifo_size;
4832 break;
4833 case HALMAC_HW_RSVD_PG_BNDY:
4834 pDrv_pg_bndy = (pu16)pvalue;
4835 *pDrv_pg_bndy = pHalmac_adapter->txff_allocation.rsvd_drv_pg_bndy;
4836 break;
4837 case HALMAC_HW_CAM_ENTRY_NUM:
4838 *(u8 *)pvalue = pHalmac_adapter->hw_config_info.cam_entry_num;
4839 break;
4840 case HALMAC_HW_HCPWM:
4841 halmac_get_hcpwm_88xx(pHalmac_adapter, &hcpwm);
4842 *(u8 *)pvalue = hcpwm;
4843 break;
4844 case HALMAC_HW_HCPWM2:
4845 halmac_get_hcpwm2_88xx(pHalmac_adapter, &hcpwm2);
4846 *(u16 *)pvalue = hcpwm2;
4847 break;
4848 case HALMAC_HW_WLAN_EFUSE_AVAILABLE_SIZE:
4849 status = halmac_dump_logical_efuse_map_88xx(pHalmac_adapter, HALMAC_EFUSE_R_DRV);
4850 if (HALMAC_RET_SUCCESS != status)
4851 return status;
4852 pEfuse_size = (pu32)pvalue;
4853 *pEfuse_size = pHalmac_adapter->hw_config_info.efuse_size - HALMAC_RESERVED_EFUSE_SIZE_88XX - pHalmac_adapter->efuse_end;
4854 break;
4855
4856 case HALMAC_HW_TXFF_ALLOCATION:
4857 PLATFORM_RTL_MEMCPY(pDriver_adapter, pvalue, &(pHalmac_adapter->txff_allocation), sizeof(HALMAC_TXFF_ALLOCATION));
4858 break;
4859 default:
4860 break;
4861 }
4862
4863
4864
4865 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_hw_value_88xx <==========\n");
4866
4867 return HALMAC_RET_SUCCESS;
4868 }
4869
4870
4871 /**
4872 * halmac_set_hw_value_88xx() -
4873 * @pHalmac_adapter
4874 * @hw_id
4875 * @pvalue
4876 * Author : KaiYuan Chang
4877 * Return : HALMAC_RET_STATUS
4878 */
4879 HALMAC_RET_STATUS
halmac_set_hw_value_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_HW_ID hw_id,IN void * pvalue)4880 halmac_set_hw_value_88xx(
4881 IN PHALMAC_ADAPTER pHalmac_adapter,
4882 IN HALMAC_HW_ID hw_id,
4883 IN void *pvalue
4884 )
4885 {
4886 VOID *pDriver_adapter = NULL;
4887 u16 hrpwm2 = 0;
4888 u8 hrpwm = 0, value8 = 0;
4889 HALMAC_USB_MODE usb_mode = HALMAC_USB_MODE_U2, current_usb_mode = HALMAC_USB_MODE_U2;
4890 u8 hw_seq_en = 0;
4891 u32 value32 = 0;
4892 u32 usb_temp = 0;
4893 HALMAC_BW bw;
4894 u8 channel, enable_bb;
4895 HALMAC_PRI_CH_IDX pri_ch_idx;
4896 PHALMAC_API pHalmac_api;
4897
4898 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
4899 return HALMAC_RET_ADAPTER_INVALID;
4900
4901 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
4902 return HALMAC_RET_API_INVALID;
4903
4904 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_HW_VALUE);
4905
4906 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
4907 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
4908
4909 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_set_hw_value_88xx ==========>\n");
4910
4911 if (NULL == pvalue) {
4912 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_set_hw_value_88xx (NULL ==pvalue)==========>\n");
4913 return HALMAC_RET_NULL_POINTER;
4914 }
4915
4916 switch (hw_id) {
4917 case HALMAC_HW_ID_UNDEFINE:
4918 break;
4919 case HALMAC_HW_HRPWM:
4920 hrpwm = *(u8 *)pvalue;
4921 halmac_set_hrpwm_88xx(pHalmac_adapter, hrpwm);
4922 break;
4923 case HALMAC_HW_HRPWM2:
4924 hrpwm2 = *(u16 *)pvalue;
4925 halmac_set_hrpwm2_88xx(pHalmac_adapter, hrpwm2);
4926 break;
4927 case HALMAC_HW_USB_MODE:
4928 /* Get driver config USB mode*/
4929 usb_mode = *(HALMAC_USB_MODE *)pvalue;
4930
4931 /* Get current USB mode*/
4932 current_usb_mode = (HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_CFG2 + 3) == 0x20) ? HALMAC_USB_MODE_U3 : HALMAC_USB_MODE_U2;
4933
4934 /*check if HW supports usb2_usb3 swtich*/
4935 usb_temp = HALMAC_REG_READ_32(pHalmac_adapter, REG_PAD_CTRL2);
4936 if (_FALSE == (BIT_GET_USB23_SW_MODE_V1(usb_temp) | (usb_temp & BIT_USB3_USB2_TRANSITION))) {
4937 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "HALMAC_HW_USB_MODE usb mode HW unsupport\n");
4938 return HALMAC_RET_USB2_3_SWITCH_UNSUPPORT;
4939 }
4940
4941 if (usb_mode == current_usb_mode) {
4942 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "HALMAC_HW_USB_MODE usb mode unchange\n");
4943 return HALMAC_RET_USB_MODE_UNCHANGE;
4944 }
4945
4946 usb_temp &= ~(BIT_USB23_SW_MODE_V1(0x3)); /* clear 0xC6[3:2] */
4947
4948 if (HALMAC_USB_MODE_U2 == usb_mode) {
4949 /* usb3 to usb2 */
4950 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_PAD_CTRL2, usb_temp | BIT_USB23_SW_MODE_V1(HALMAC_USB_MODE_U2) | BIT_RSM_EN_V1); /* set usb mode and enable timer */
4951 } else {
4952 /* usb2 to usb3 */
4953 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_PAD_CTRL2, usb_temp | BIT_USB23_SW_MODE_V1(HALMAC_USB_MODE_U3) | BIT_RSM_EN_V1); /* set usb mode and enable timer */
4954 }
4955
4956 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_PAD_CTRL2 + 1, 4); /* set counter down timer 4x64 ms */
4957 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_SYS_PW_CTRL, HALMAC_REG_READ_16(pHalmac_adapter, REG_SYS_PW_CTRL) | BIT_APFM_OFFMAC); /* auto MAC off */
4958 PLATFORM_RTL_DELAY_US(pDriver_adapter, 1000);
4959 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_PAD_CTRL2, HALMAC_REG_READ_32(pHalmac_adapter, REG_PAD_CTRL2) | BIT_NO_PDN_CHIPOFF_V1); /* chip off */
4960 break;
4961
4962 case HALMAC_HW_SEQ_EN:
4963
4964 hw_seq_en = *(u8 *)pvalue;
4965
4966 break;
4967 case HALMAC_HW_BANDWIDTH:
4968
4969 bw = *(HALMAC_BW *)pvalue;
4970 halmac_cfg_bw_88xx(pHalmac_adapter, bw);
4971
4972 break;
4973 case HALMAC_HW_CHANNEL:
4974
4975 channel = *(u8 *)pvalue;
4976 halmac_cfg_ch_88xx(pHalmac_adapter, channel);
4977
4978 break;
4979 case HALMAC_HW_PRI_CHANNEL_IDX:
4980
4981 pri_ch_idx = *(HALMAC_PRI_CH_IDX *)pvalue;
4982 halmac_cfg_pri_ch_idx_88xx(pHalmac_adapter, pri_ch_idx);
4983
4984 break;
4985 case HALMAC_HW_EN_BB_RF:
4986
4987 enable_bb = *(u8 *)pvalue;
4988
4989 if (_TRUE == enable_bb) {
4990 /* enable bb, rf */
4991 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_FUNC_EN);
4992 value8 = value8 | BIT(0) | BIT(1);
4993 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SYS_FUNC_EN, value8);
4994
4995 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_RF_CTRL);
4996 value8 = value8 | BIT(0) | BIT(1) | BIT(2);
4997 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RF_CTRL, value8);
4998
4999 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_WLRF1);
5000 value32 = value32 | BIT(24) | BIT(25) | BIT(26);
5001 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WLRF1, value32);
5002 } else {
5003 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_FUNC_EN);
5004 value8 = value8 & (~(BIT(0) | BIT(1)));
5005 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SYS_FUNC_EN, value8);
5006
5007 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_RF_CTRL);
5008 value8 = value8 & (~(BIT(0) | BIT(1) | BIT(2)));
5009 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RF_CTRL, value8);
5010
5011 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_WLRF1);
5012 value32 = value32 & (~(BIT(24) | BIT(25) | BIT(26)));
5013 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WLRF1, value32);
5014 }
5015
5016 break;
5017
5018 default:
5019 break;
5020 }
5021
5022 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_set_hw_value_88xx <==========\n");
5023
5024 return HALMAC_RET_SUCCESS;
5025 }
5026
5027
5028 /**
5029 * halmac_cfg_drv_rsvd_pg_num_88xx() -
5030 * @pHalmac_adapter
5031 * @pg_num
5032 * Author : KaiYuan Chang
5033 * Return : HALMAC_RET_STATUS
5034 */
5035 HALMAC_RET_STATUS
halmac_cfg_drv_rsvd_pg_num_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_DRV_RSVD_PG_NUM pg_num)5036 halmac_cfg_drv_rsvd_pg_num_88xx(
5037 IN PHALMAC_ADAPTER pHalmac_adapter,
5038 IN HALMAC_DRV_RSVD_PG_NUM pg_num
5039 )
5040 {
5041 VOID *pDriver_adapter = NULL;
5042
5043 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
5044 return HALMAC_RET_ADAPTER_INVALID;
5045
5046 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
5047 return HALMAC_RET_API_INVALID;
5048
5049 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_DRV_RSVD_PG_NUM);
5050
5051 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
5052
5053 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_drv_rsvd_pg_num_88xx ==========>pg_num = %d\n", pg_num);
5054
5055 switch (pg_num) {
5056 case HALMAC_RSVD_PG_NUM16:
5057 pHalmac_adapter->txff_allocation.rsvd_drv_pg_num = 16;
5058 break;
5059 case HALMAC_RSVD_PG_NUM24:
5060 pHalmac_adapter->txff_allocation.rsvd_drv_pg_num = 24;
5061 break;
5062 case HALMAC_RSVD_PG_NUM32:
5063 pHalmac_adapter->txff_allocation.rsvd_drv_pg_num = 32;
5064 break;
5065 }
5066
5067 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_cfg_drv_rsvd_pg_num_88xx <==========\n");
5068
5069 return HALMAC_RET_SUCCESS;
5070 }
5071
5072
5073 /**
5074 * halmac_get_chip_version_88xx() -
5075 * @pHalmac_adapter
5076 * @version
5077 * Author : KaiYuan Chang
5078 * Return : HALMAC_RET_STATUS
5079 */
5080 HALMAC_RET_STATUS
halmac_get_chip_version_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_VER pVersion)5081 halmac_get_chip_version_88xx(
5082 IN PHALMAC_ADAPTER pHalmac_adapter,
5083 IN PHALMAC_VER pVersion
5084 )
5085 {
5086 VOID *pDriver_adapter = NULL;
5087 PHALMAC_API pHalmac_api;
5088
5089 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
5090 return HALMAC_RET_ADAPTER_INVALID;
5091
5092 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
5093 return HALMAC_RET_API_INVALID;
5094
5095 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_SWITCH_EFUSE_BANK);
5096
5097 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
5098 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
5099
5100 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_chip_version_88xx ==========>\n");
5101 pVersion->major_ver = (u8)HALMAC_MAJOR_VER_88XX;
5102 pVersion->prototype_ver = (u8)HALMAC_PROTOTYPE_VER_88XX;
5103 pVersion->minor_ver = (u8)HALMAC_MINOR_VER_88XX;
5104 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_get_chip_version_88xx <==========\n");
5105
5106 return HALMAC_RET_SUCCESS;
5107 }
5108
5109 /**
5110 * halmac_chk_txdesc_88xx() -
5111 * @pHalmac_adapter
5112 * @halmac_buf
5113 * @halmac_size
5114 * Author : KaiYuan Chang
5115 * Return : HALMAC_RET_STATUS
5116 */
5117 HALMAC_RET_STATUS
halmac_chk_txdesc_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pHalmac_buf,IN u32 halmac_size)5118 halmac_chk_txdesc_88xx(
5119 IN PHALMAC_ADAPTER pHalmac_adapter,
5120 IN u8 *pHalmac_buf,
5121 IN u32 halmac_size
5122 )
5123 {
5124 VOID *pDriver_adapter = NULL;
5125 PHALMAC_API pHalmac_api;
5126
5127 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
5128 return HALMAC_RET_ADAPTER_INVALID;
5129
5130 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
5131 return HALMAC_RET_API_INVALID;
5132
5133 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
5134 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
5135
5136 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_chk_txdesc_88xx ==========>\n");
5137
5138 if (_TRUE == GET_TX_DESC_BMC(pHalmac_buf))
5139 if (_TRUE == GET_TX_DESC_AGG_EN(pHalmac_buf))
5140 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "TxDesc: Agg should not be set when BMC\n");
5141
5142 if (halmac_size < (GET_TX_DESC_TXPKTSIZE(pHalmac_buf) + GET_TX_DESC_OFFSET(pHalmac_buf)))
5143 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "TxDesc: PktSize too small\n");
5144
5145 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_WARN, "halmac_chk_txdesc_88xx <==========\n"); */
5146
5147 return HALMAC_RET_SUCCESS;
5148 }
5149