1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include "halmac_88xx_cfg.h"
3
4 HALMAC_RET_STATUS
5 halmac_dump_efuse_fw_88xx(
6 IN PHALMAC_ADAPTER pHalmac_adapter
7 );
8
9 HALMAC_RET_STATUS
10 halmac_dump_efuse_drv_88xx(
11 IN PHALMAC_ADAPTER pHalmac_adapter
12 );
13
14 HALMAC_RET_STATUS
15 halmac_update_eeprom_mask_88xx(
16 IN PHALMAC_ADAPTER pHalmac_adapter,
17 INOUT PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
18 OUT u8 *pEeprom_mask_updated
19 );
20
21 HALMAC_RET_STATUS
22 halmac_check_efuse_enough_88xx(
23 IN PHALMAC_ADAPTER pHalmac_adapter,
24 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
25 IN u8 *pEeprom_mask_updated
26 );
27
28 HALMAC_RET_STATUS
29 halmac_program_efuse_88xx(
30 IN PHALMAC_ADAPTER pHalmac_adapter,
31 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
32 IN u8 *pEeprom_mask_updated
33 );
34
35 HALMAC_RET_STATUS
36 halmac_parse_c2h_debug_88xx(
37 IN PHALMAC_ADAPTER pHalmac_adapter,
38 IN u8 *pC2h_buf,
39 IN u32 c2h_size
40 );
41
42 HALMAC_RET_STATUS
43 halmac_parse_scan_status_rpt_88xx(
44 IN PHALMAC_ADAPTER pHalmac_adapter,
45 IN u8 *pC2h_buf,
46 IN u32 c2h_size
47 );
48
49 HALMAC_RET_STATUS
50 halmac_parse_psd_data_88xx(
51 IN PHALMAC_ADAPTER pHalmac_adapter,
52 IN u8 *pC2h_buf,
53 IN u32 c2h_size
54 );
55
56 HALMAC_RET_STATUS
57 halmac_parse_efuse_data_88xx(
58 IN PHALMAC_ADAPTER pHalmac_adapter,
59 IN u8 *pC2h_buf,
60 IN u32 c2h_size
61 );
62
63
64 HALMAC_RET_STATUS
65 halmac_parse_h2c_ack_88xx(
66 IN PHALMAC_ADAPTER pHalmac_adapter,
67 IN u8 *pC2h_buf,
68 IN u32 c2h_size
69 );
70
71 HALMAC_RET_STATUS
72 halmac_parse_h2c_ack_physical_efuse_88xx(
73 IN PHALMAC_ADAPTER pHalmac_adapter,
74 IN u8 *pC2h_buf,
75 IN u32 c2h_size
76 );
77
78 HALMAC_RET_STATUS
79 halmac_enqueue_para_buff_88xx(
80 IN PHALMAC_ADAPTER pHalmac_adapter,
81 IN PHALMAC_PHY_PARAMETER_INFO para_info,
82 IN u8 *pCurr_buff_wptr,
83 OUT u8 *pEnd_cmd
84 );
85
86 HALMAC_RET_STATUS
87 halmac_parse_h2c_ack_cfg_para_88xx(
88 IN PHALMAC_ADAPTER pHalmac_adapter,
89 IN u8 *pC2h_buf,
90 IN u32 c2h_size
91 );
92
93 HALMAC_RET_STATUS
94 halmac_gen_cfg_para_h2c_88xx(
95 IN PHALMAC_ADAPTER pHalmac_adapter,
96 IN u8 *pH2c_buff
97 );
98
99 HALMAC_RET_STATUS
100 halmac_parse_h2c_ack_update_packet_88xx(
101 IN PHALMAC_ADAPTER pHalmac_adapter,
102 IN u8 *pC2h_buf,
103 IN u32 c2h_size
104 );
105 HALMAC_RET_STATUS
106 halmac_parse_h2c_ack_update_datapack_88xx(
107 IN PHALMAC_ADAPTER pHalmac_adapter,
108 IN u8 *pC2h_buf,
109 IN u32 c2h_size
110 );
111
112 HALMAC_RET_STATUS
113 halmac_parse_h2c_ack_run_datapack_88xx(
114 IN PHALMAC_ADAPTER pHalmac_adapter,
115 IN u8 *pC2h_buf,
116 IN u32 c2h_size
117 );
118
119 HALMAC_RET_STATUS
120 halmac_parse_h2c_ack_channel_switch_88xx(
121 IN PHALMAC_ADAPTER pHalmac_adapter,
122 IN u8 *pC2h_buf,
123 IN u32 c2h_size
124 );
125
126 HALMAC_RET_STATUS
127 halmac_parse_h2c_ack_iqk_88xx(
128 IN PHALMAC_ADAPTER pHalmac_adapter,
129 IN u8 *pC2h_buf,
130 IN u32 c2h_size
131 );
132
133 HALMAC_RET_STATUS
134 halmac_parse_h2c_ack_power_tracking_88xx(
135 IN PHALMAC_ADAPTER pHalmac_adapter,
136 IN u8 *pC2h_buf,
137 IN u32 c2h_size
138 );
139
140 HALMAC_RET_STATUS
halmac_dump_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_READ_CFG cfg)141 halmac_dump_efuse_88xx(
142 IN PHALMAC_ADAPTER pHalmac_adapter,
143 IN HALMAC_EFUSE_READ_CFG cfg
144 )
145 {
146 VOID *pDriver_adapter = NULL;
147 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
148 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.efuse_state_set.process_status);
149
150 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
151
152 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
153
154 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_H2C_SENT))
155 return HALMAC_RET_ERROR_STATE;
156
157 if (HALMAC_EFUSE_R_AUTO == cfg) {
158 if (HALMAC_DLFW_NONE == pHalmac_adapter->halmac_state.dlfw_state)
159 status = halmac_dump_efuse_drv_88xx(pHalmac_adapter);
160 else
161 status = halmac_dump_efuse_fw_88xx(pHalmac_adapter);
162 } else if (HALMAC_EFUSE_R_FW == cfg) {
163 status = halmac_dump_efuse_fw_88xx(pHalmac_adapter);
164 } else {
165 status = halmac_dump_efuse_drv_88xx(pHalmac_adapter);
166 }
167
168 if (HALMAC_RET_SUCCESS != status) {
169 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_efuse error = %x\n", status);
170 return status;
171 }
172
173 return status;
174 }
175
176 HALMAC_RET_STATUS
halmac_func_read_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 offset,IN u32 size,OUT u8 * pEfuse_map)177 halmac_func_read_efuse_88xx(
178 IN PHALMAC_ADAPTER pHalmac_adapter,
179 IN u32 offset,
180 IN u32 size,
181 OUT u8 *pEfuse_map
182 )
183 {
184 VOID *pDriver_adapter = NULL;
185
186 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
187
188 if (NULL == pEfuse_map) {
189 PLATFORM_MSG_PRINT(pHalmac_adapter->pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Malloc for dump efuse map error\n");
190 return HALMAC_RET_NULL_POINTER;
191 }
192
193 if (_TRUE == pHalmac_adapter->hal_efuse_map_valid)
194 PLATFORM_RTL_MEMCPY(pDriver_adapter, pEfuse_map, pHalmac_adapter->pHalEfuse_map + offset, size);
195 else
196 if (HALMAC_RET_SUCCESS != halmac_read_hw_efuse_88xx(pHalmac_adapter, offset, size, pEfuse_map))
197 return HALMAC_RET_EFUSE_R_FAIL;
198
199 return HALMAC_RET_SUCCESS;
200 }
201
202 HALMAC_RET_STATUS
halmac_read_hw_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 offset,IN u32 size,OUT u8 * pEfuse_map)203 halmac_read_hw_efuse_88xx(
204 IN PHALMAC_ADAPTER pHalmac_adapter,
205 IN u32 offset,
206 IN u32 size,
207 OUT u8 *pEfuse_map
208 )
209 {
210 u8 value8;
211 u32 value32;
212 u32 address;
213 u32 tmp32, counter;
214 VOID *pDriver_adapter = NULL;
215 PHALMAC_API pHalmac_api;
216
217 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
218 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
219
220 /* Read efuse no need 2.5V LDO */
221 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3);
222 if (value8 & BIT(7))
223 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3, (u8)(value8 & ~(BIT(7))));
224
225 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_EFUSE_CTRL);
226
227 for (address = offset; address < offset + size; address++) {
228 value32 = value32 & ~((BIT_MASK_EF_DATA) | (BIT_MASK_EF_ADDR << BIT_SHIFT_EF_ADDR));
229 value32 = value32 | ((address & BIT_MASK_EF_ADDR) << BIT_SHIFT_EF_ADDR);
230 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_EFUSE_CTRL, value32 & (~BIT_EF_FLAG));
231
232 counter = 100;
233 do {
234 tmp32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_EFUSE_CTRL);
235 counter--;
236 if (0 == counter) {
237 PLATFORM_MSG_PRINT(pHalmac_adapter->pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "HALMAC_RET_EFUSE_R_FAIL\n");
238 return HALMAC_RET_EFUSE_R_FAIL;
239 }
240 } while (0 == (tmp32 & BIT_EF_FLAG));
241
242 *(pEfuse_map + address - offset) = (u8)(tmp32 & BIT_MASK_EF_DATA);
243 }
244
245 return HALMAC_RET_SUCCESS;
246 }
247
248 HALMAC_RET_STATUS
halmac_dump_efuse_drv_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)249 halmac_dump_efuse_drv_88xx(
250 IN PHALMAC_ADAPTER pHalmac_adapter
251 )
252 {
253 u8 *pEfuse_map = NULL;
254 u32 efuse_size;
255 VOID *pDriver_adapter = NULL;
256
257 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
258
259 efuse_size = pHalmac_adapter->hw_config_info.efuse_size;
260
261 if (NULL == pHalmac_adapter->pHalEfuse_map) {
262 pHalmac_adapter->pHalEfuse_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, efuse_size);
263 if (NULL == pHalmac_adapter->pHalEfuse_map) {
264 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate efuse map Fail!!\n");
265 return HALMAC_RET_MALLOC_FAIL;
266 }
267 }
268
269 pEfuse_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, efuse_size);
270 if (NULL == pEfuse_map) {
271 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local efuse map Fail!!\n");
272 return HALMAC_RET_MALLOC_FAIL;
273 }
274
275 if (HALMAC_RET_SUCCESS != halmac_read_hw_efuse_88xx(pHalmac_adapter, 0, efuse_size, pEfuse_map))
276 return HALMAC_RET_EFUSE_R_FAIL;
277
278 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
279 PLATFORM_RTL_MEMCPY(pDriver_adapter, pHalmac_adapter->pHalEfuse_map, pEfuse_map, efuse_size);
280 pHalmac_adapter->hal_efuse_map_valid = _TRUE;
281 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
282
283 PLATFORM_RTL_FREE(pDriver_adapter, pEfuse_map, efuse_size);
284
285 return HALMAC_RET_SUCCESS;
286 }
287
288 HALMAC_RET_STATUS
halmac_dump_efuse_fw_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)289 halmac_dump_efuse_fw_88xx(
290 IN PHALMAC_ADAPTER pHalmac_adapter
291 )
292 {
293 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
294 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
295 u16 h2c_seq_mum = 0;
296 VOID *pDriver_adapter = NULL;
297 HALMAC_H2C_HEADER_INFO h2c_header_info;
298 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
299
300 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
301
302 h2c_header_info.sub_cmd_id = SUB_CMD_ID_DUMP_PHYSICAL_EFUSE;
303 h2c_header_info.content_size = 0;
304 h2c_header_info.ack = _TRUE;
305 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
306 pHalmac_adapter->halmac_state.efuse_state_set.seq_num = h2c_seq_mum;
307
308 if (NULL == pHalmac_adapter->pHalEfuse_map) {
309 pHalmac_adapter->pHalEfuse_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, pHalmac_adapter->hw_config_info.efuse_size);
310 if (NULL == pHalmac_adapter->pHalEfuse_map) {
311 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac allocate efuse map Fail!!\n");
312 return HALMAC_RET_MALLOC_FAIL;
313 }
314 }
315
316 if (_FALSE == pHalmac_adapter->hal_efuse_map_valid) {
317 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
318 if (HALMAC_RET_SUCCESS != status) {
319 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_read_efuse_fw Fail = %x!!\n", status);
320 return status;
321 }
322 }
323
324 return HALMAC_RET_SUCCESS;
325 }
326
327 HALMAC_RET_STATUS
halmac_func_write_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 offset,IN u8 value)328 halmac_func_write_efuse_88xx(
329 IN PHALMAC_ADAPTER pHalmac_adapter,
330 IN u32 offset,
331 IN u8 value
332 )
333 {
334 const u8 wite_protect_code = 0x69;
335 u32 value32, tmp32, counter;
336 VOID *pDriver_adapter = NULL;
337 PHALMAC_API pHalmac_api;
338
339 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
340 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
341
342 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
343 pHalmac_adapter->hal_efuse_map_valid = _FALSE;
344 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
345
346 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_PMC_DBG_CTRL2 + 3, wite_protect_code);
347
348 /* Enable 2.5V LDO */
349 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3) | BIT(7)));
350
351 value32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_EFUSE_CTRL);
352 value32 = value32 & ~((BIT_MASK_EF_DATA) | (BIT_MASK_EF_ADDR << BIT_SHIFT_EF_ADDR));
353 value32 = value32 | ((offset & BIT_MASK_EF_ADDR) << BIT_SHIFT_EF_ADDR) | (value & BIT_MASK_EF_DATA);
354 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_EFUSE_CTRL, value32 | BIT_EF_FLAG);
355
356 counter = 100;
357 do {
358 tmp32 = HALMAC_REG_READ_32(pHalmac_adapter, REG_EFUSE_CTRL);
359 counter--;
360 if (0 == counter) {
361 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_write_efuse Fail !!\n");
362 return HALMAC_RET_EFUSE_W_FAIL;
363 }
364 } while (BIT_EF_FLAG == (tmp32 & BIT_EF_FLAG));
365
366 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_PMC_DBG_CTRL2 + 3, 0x00);
367
368 /* Disable 2.5V LDO */
369 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 3) & ~(BIT(7))));
370
371 return HALMAC_RET_SUCCESS;
372 }
373
374
375 HALMAC_RET_STATUS
halmac_func_switch_efuse_bank_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_BANK efuse_bank)376 halmac_func_switch_efuse_bank_88xx(
377 IN PHALMAC_ADAPTER pHalmac_adapter,
378 IN HALMAC_EFUSE_BANK efuse_bank
379 )
380 {
381 u8 reg_value;
382 PHALMAC_API pHalmac_api;
383
384 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
385
386 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
387
388 if (HALMAC_RET_SUCCESS != halmac_transition_efuse_state_88xx(pHalmac_adapter, HALMAC_EFUSE_CMD_CONSTRUCT_BUSY))
389 return HALMAC_RET_ERROR_STATE;
390
391 reg_value = HALMAC_REG_READ_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 1);
392
393 if (efuse_bank == (reg_value & (BIT(0) | BIT(1))))
394 return HALMAC_RET_SUCCESS;
395
396 reg_value &= ~(BIT(0) | BIT(1));
397 reg_value |= efuse_bank;
398 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 1, reg_value);
399
400 if ((HALMAC_REG_READ_8(pHalmac_adapter, REG_LDO_EFUSE_CTRL + 1) & (BIT(0) | BIT(1))) != efuse_bank)
401 return HALMAC_RET_SWITCH_EFUSE_BANK_FAIL;
402
403 return HALMAC_RET_SUCCESS;
404 }
405
406 HALMAC_RET_STATUS
halmac_eeprom_parser_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pPhysical_efuse_map,OUT u8 * pLogical_efuse_map)407 halmac_eeprom_parser_88xx(
408 IN PHALMAC_ADAPTER pHalmac_adapter,
409 IN u8 *pPhysical_efuse_map,
410 OUT u8 *pLogical_efuse_map
411 )
412 {
413 u8 j;
414 u8 value8;
415 u8 block_index;
416 u8 valid_word_enable, word_enable;
417 u8 efuse_read_header, efuse_read_header2 = 0;
418 u32 eeprom_index;
419 u32 efuse_index = 0;
420 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
421 VOID *pDriver_adapter = NULL;
422
423 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
424
425 PLATFORM_RTL_MEMSET(pDriver_adapter, pLogical_efuse_map, 0xFF, eeprom_size);
426
427 while (1) {
428 value8 = *(pPhysical_efuse_map + efuse_index);
429 efuse_read_header = value8;
430
431 if ((efuse_read_header & 0x1f) == 0x0f) {
432 efuse_index++;
433 value8 = *(pPhysical_efuse_map + efuse_index);
434 efuse_read_header2 = value8;
435 block_index = ((efuse_read_header2 & 0xF0) >> 1) | ((efuse_read_header >> 5) & 0x07);
436 word_enable = efuse_read_header2 & 0x0F;
437 } else {
438 block_index = (efuse_read_header & 0xF0) >> 4;
439 word_enable = efuse_read_header & 0x0F;
440 }
441
442 if (efuse_read_header == 0xff)
443 break;
444
445 efuse_index++;
446
447 if (efuse_index >= pHalmac_adapter->hw_config_info.efuse_size - HALMAC_RESERVED_EFUSE_SIZE_88XX - 1)
448 return HALMAC_RET_EEPROM_PARSING_FAIL;
449
450 for (j = 0; j < 4; j++) {
451 valid_word_enable = (u8)((~(word_enable >> j)) & BIT(0));
452 if (valid_word_enable == 1) {
453 eeprom_index = (block_index << 3) + (j << 1);
454
455 if ((eeprom_index + 1) > eeprom_size) {
456 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Error: EEPROM addr exceeds eeprom_size:0x%X, at eFuse 0x%X\n", eeprom_size, efuse_index - 1);
457 if ((efuse_read_header & 0x1f) == 0x0f)
458 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Error: EEPROM header: 0x%X, 0x%X,\n", efuse_read_header, efuse_read_header2);
459 else
460 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "Error: EEPROM header: 0x%X,\n", efuse_read_header);
461 eeprom_index++;
462 efuse_index = efuse_index + 2;
463
464 return HALMAC_RET_EEPROM_PARSING_FAIL;
465 } else {
466 value8 = *(pPhysical_efuse_map + efuse_index);
467 *(pLogical_efuse_map + eeprom_index) = value8;
468
469 eeprom_index++;
470 efuse_index++;
471
472 if (efuse_index > pHalmac_adapter->hw_config_info.efuse_size - HALMAC_RESERVED_EFUSE_SIZE_88XX - 1)
473 return HALMAC_RET_EEPROM_PARSING_FAIL;
474
475 value8 = *(pPhysical_efuse_map + efuse_index);
476 *(pLogical_efuse_map + eeprom_index) = value8;
477
478 efuse_index++;
479
480 if (efuse_index > pHalmac_adapter->hw_config_info.efuse_size - HALMAC_RESERVED_EFUSE_SIZE_88XX)
481 return HALMAC_RET_EEPROM_PARSING_FAIL;
482 }
483 }
484 }
485 }
486
487 pHalmac_adapter->efuse_end = efuse_index;
488
489 return HALMAC_RET_SUCCESS;
490 }
491
492 HALMAC_RET_STATUS
halmac_read_logical_efuse_map_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pMap)493 halmac_read_logical_efuse_map_88xx(
494 IN PHALMAC_ADAPTER pHalmac_adapter,
495 IN u8 *pMap
496 )
497 {
498 u8 *pEfuse_map = NULL;
499 u32 efuse_size;
500 VOID *pDriver_adapter = NULL;
501 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
502
503 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
504 efuse_size = pHalmac_adapter->hw_config_info.efuse_size;
505
506 if (_FALSE == pHalmac_adapter->hal_efuse_map_valid) {
507 pEfuse_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, efuse_size);
508 if (NULL == pEfuse_map) {
509 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local efuse map Fail!!\n");
510 return HALMAC_RET_MALLOC_FAIL;
511 }
512
513 if (NULL == pHalmac_adapter->pHalEfuse_map) {
514 pHalmac_adapter->pHalEfuse_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, efuse_size);
515 if (NULL == pHalmac_adapter->pHalEfuse_map) {
516 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate efuse map Fail!!\n");
517 return HALMAC_RET_MALLOC_FAIL;
518 }
519 }
520
521 status = halmac_func_read_efuse_88xx(pHalmac_adapter, 0, efuse_size, pEfuse_map);
522 if (HALMAC_RET_SUCCESS != status) {
523 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_efuse error = %x\n", status);
524 return status;
525 }
526
527 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
528 PLATFORM_RTL_MEMCPY(pDriver_adapter, pHalmac_adapter->pHalEfuse_map, pEfuse_map, efuse_size);
529 pHalmac_adapter->hal_efuse_map_valid = _TRUE;
530 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
531
532 PLATFORM_RTL_FREE(pDriver_adapter, pEfuse_map, efuse_size);
533 }
534
535 if (HALMAC_RET_SUCCESS != halmac_eeprom_parser_88xx(pHalmac_adapter, pHalmac_adapter->pHalEfuse_map, pMap))
536 return HALMAC_RET_EEPROM_PARSING_FAIL;
537
538 return status;
539 }
540
541 HALMAC_RET_STATUS
halmac_func_write_logical_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 offset,IN u8 value)542 halmac_func_write_logical_efuse_88xx(
543 IN PHALMAC_ADAPTER pHalmac_adapter,
544 IN u32 offset,
545 IN u8 value
546 )
547 {
548 u8 pg_efuse_byte1, pg_efuse_byte2;
549 u8 pg_block, pg_block_index;
550 u8 pg_efuse_header, pg_efuse_header2;
551 u8 *pEeprom_map = NULL;
552 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
553 u32 efuse_end;
554 VOID *pDriver_adapter = NULL;
555 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
556
557 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
558
559 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
560 if (NULL == pEeprom_map) {
561 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
562 return HALMAC_RET_MALLOC_FAIL;
563 }
564 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
565
566 status = halmac_read_logical_efuse_map_88xx(pHalmac_adapter, pEeprom_map);
567 if (HALMAC_RET_SUCCESS != status) {
568 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_read_logical_efuse_map_88xx error = %x\n", status);
569 return status;
570 }
571
572 if (*(pEeprom_map + offset) != value) {
573 efuse_end = pHalmac_adapter->efuse_end;
574 pg_block = (u8)(offset >> 3);
575 pg_block_index = (u8)((offset & (8 - 1)) >> 1);
576
577 if (offset > 0x7f) {
578 pg_efuse_header = (((pg_block & 0x07) << 5) & 0xE0) | 0x0F;
579 pg_efuse_header2 = (u8)(((pg_block & 0x78) << 1) + ((0x1 << pg_block_index) ^ 0x0F));
580 } else {
581 pg_efuse_header = (u8)((pg_block << 4) + ((0x01 << pg_block_index) ^ 0x0F));
582 }
583
584 if ((offset & 1) == 0) {
585 pg_efuse_byte1 = value;
586 pg_efuse_byte2 = *(pEeprom_map + offset + 1);
587 } else {
588 pg_efuse_byte1 = *(pEeprom_map + offset - 1);
589 pg_efuse_byte2 = value;
590 }
591
592 if (offset > 0x7f) {
593 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, pg_efuse_header);
594 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 1, pg_efuse_header2);
595 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 2, pg_efuse_byte1);
596 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 3, pg_efuse_byte2);
597 } else {
598 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, pg_efuse_header);
599 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 1, pg_efuse_byte1);
600 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 2, pg_efuse_byte2);
601 }
602
603 if (HALMAC_RET_SUCCESS != status) {
604 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_write_logical_efuse error = %x\n", status);
605 return status;
606 }
607 }
608
609 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
610
611 return HALMAC_RET_SUCCESS;
612 }
613
614 HALMAC_RET_STATUS
halmac_func_pg_efuse_by_map_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,IN HALMAC_EFUSE_READ_CFG cfg)615 halmac_func_pg_efuse_by_map_88xx(
616 IN PHALMAC_ADAPTER pHalmac_adapter,
617 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
618 IN HALMAC_EFUSE_READ_CFG cfg
619 )
620 {
621 u8 *pEeprom_mask_updated = NULL;
622 u32 eeprom_mask_size = pHalmac_adapter->hw_config_info.eeprom_size >> 4;
623 VOID *pDriver_adapter = NULL;
624 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
625
626 pEeprom_mask_updated = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_mask_size);
627 if (NULL == pEeprom_mask_updated) {
628 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
629 return HALMAC_RET_MALLOC_FAIL;
630 }
631 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_mask_updated, 0x00, eeprom_mask_size);
632
633 status = halmac_update_eeprom_mask_88xx(pHalmac_adapter, pPg_efuse_info, pEeprom_mask_updated);
634
635 if (HALMAC_RET_SUCCESS != status) {
636 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_update_eeprom_mask_88xx error = %x\n", status);
637 return status;
638 }
639
640 status = halmac_check_efuse_enough_88xx(pHalmac_adapter, pPg_efuse_info, pEeprom_mask_updated);
641
642 if (HALMAC_RET_SUCCESS != status) {
643 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_check_efuse_enough_88xx error = %x\n", status);
644 return status;
645 }
646
647 status = halmac_program_efuse_88xx(pHalmac_adapter, pPg_efuse_info, pEeprom_mask_updated);
648
649 if (HALMAC_RET_SUCCESS != status) {
650 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac_program_efuse_88xx error = %x\n", status);
651 return status;
652 }
653
654 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_mask_updated, eeprom_mask_size);
655
656 return HALMAC_RET_SUCCESS;
657 }
658
659 HALMAC_RET_STATUS
halmac_update_eeprom_mask_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,INOUT PHALMAC_PG_EFUSE_INFO pPg_efuse_info,OUT u8 * pEeprom_mask_updated)660 halmac_update_eeprom_mask_88xx(
661 IN PHALMAC_ADAPTER pHalmac_adapter,
662 INOUT PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
663 OUT u8 *pEeprom_mask_updated
664 )
665 {
666 u8 *pEeprom_map = NULL;
667 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
668 u8 *pEeprom_map_pg, *pEeprom_mask;
669 u16 i, j;
670 u16 map_byte_offset, mask_byte_offset;
671 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
672
673 VOID *pDriver_adapter = NULL;
674
675 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
676
677 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
678 if (NULL == pEeprom_map) {
679 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
680 return HALMAC_RET_MALLOC_FAIL;
681 }
682 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
683
684 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_mask_updated, 0x00, pPg_efuse_info->efuse_mask_size);
685
686 status = halmac_read_logical_efuse_map_88xx(pHalmac_adapter, pEeprom_map);
687
688 if (HALMAC_RET_SUCCESS != status)
689 return status;
690
691 pEeprom_map_pg = pPg_efuse_info->pEfuse_map;
692 pEeprom_mask = pPg_efuse_info->pEfuse_mask;
693
694
695 for (i = 0; i < pPg_efuse_info->efuse_mask_size; i++)
696 *(pEeprom_mask_updated + i) = *(pEeprom_mask + i);
697
698 for (i = 0; i < pPg_efuse_info->efuse_map_size; i = i + 16) {
699 for (j = 0; j < 16; j = j + 2) {
700 map_byte_offset = i + j;
701 mask_byte_offset = i >> 4;
702 if (*(pEeprom_map_pg + map_byte_offset) == *(pEeprom_map + map_byte_offset)) {
703 if (*(pEeprom_map_pg + map_byte_offset + 1) == *(pEeprom_map + map_byte_offset + 1)) {
704 switch (j) {
705 case 0:
706 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(4) ^ 0xFF);
707 break;
708 case 2:
709 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(5) ^ 0xFF);
710 break;
711 case 4:
712 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(6) ^ 0xFF);
713 break;
714 case 6:
715 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(7) ^ 0xFF);
716 break;
717 case 8:
718 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(0) ^ 0xFF);
719 break;
720 case 10:
721 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(1) ^ 0xFF);
722 break;
723 case 12:
724 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(2) ^ 0xFF);
725 break;
726 case 14:
727 *(pEeprom_mask_updated + mask_byte_offset) = *(pEeprom_mask_updated + mask_byte_offset) & (BIT(3) ^ 0xFF);
728 break;
729 default:
730 break;
731 }
732 }
733 }
734 }
735 }
736
737 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
738
739 return status;
740 }
741
742 HALMAC_RET_STATUS
halmac_check_efuse_enough_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,IN u8 * pEeprom_mask_updated)743 halmac_check_efuse_enough_88xx(
744 IN PHALMAC_ADAPTER pHalmac_adapter,
745 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
746 IN u8 *pEeprom_mask_updated
747 )
748 {
749 u8 pre_word_enb, word_enb;
750 u8 pg_efuse_header, pg_efuse_header2;
751 u8 pg_block;
752 u16 i, j;
753 u32 efuse_end;
754 u32 tmp_eeprom_offset, pg_efuse_num = 0;
755
756 efuse_end = pHalmac_adapter->efuse_end;
757
758 for (i = 0; i < pPg_efuse_info->efuse_map_size; i = i + 8) {
759 tmp_eeprom_offset = i;
760
761 if ((tmp_eeprom_offset & 7) > 0) {
762 pre_word_enb = (*(pEeprom_mask_updated + (i >> 4)) & 0x0F);
763 word_enb = pre_word_enb ^ 0x0F;
764 } else {
765 pre_word_enb = (*(pEeprom_mask_updated + (i >> 4)) >> 4);
766 word_enb = pre_word_enb ^ 0x0F;
767 }
768
769 pg_block = (u8)(tmp_eeprom_offset >> 3);
770
771 if (pre_word_enb > 0) {
772 if (tmp_eeprom_offset > 0x7f) {
773 pg_efuse_header = (((pg_block & 0x07) << 5) & 0xE0) | 0x0F;
774 pg_efuse_header2 = (u8)(((pg_block & 0x78) << 1) + word_enb);
775 } else {
776 pg_efuse_header = (u8)((pg_block << 4) + word_enb);
777 }
778
779 if (tmp_eeprom_offset > 0x7f) {
780 pg_efuse_num++;
781 pg_efuse_num++;
782 efuse_end = efuse_end + 2;
783 for (j = 0; j < 4; j++) {
784 if (((pre_word_enb >> j) & 0x1) > 0) {
785 pg_efuse_num++;
786 pg_efuse_num++;
787 efuse_end = efuse_end + 2;
788 }
789 }
790 } else {
791 pg_efuse_num++;
792 efuse_end = efuse_end + 1;
793 for (j = 0; j < 4; j++) {
794 if (((pre_word_enb >> j) & 0x1) > 0) {
795 pg_efuse_num++;
796 pg_efuse_num++;
797 efuse_end = efuse_end + 2;
798 }
799 }
800 }
801 }
802 }
803
804 if ((pHalmac_adapter->hw_config_info.efuse_size - pg_efuse_num - HALMAC_RESERVED_EFUSE_SIZE_88XX - pHalmac_adapter->efuse_end) <= 0)
805 return HALMAC_RET_EFUSE_NOT_ENOUGH;
806
807 return HALMAC_RET_SUCCESS;
808 }
809
810 HALMAC_RET_STATUS
halmac_program_efuse_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,IN u8 * pEeprom_mask_updated)811 halmac_program_efuse_88xx(
812 IN PHALMAC_ADAPTER pHalmac_adapter,
813 IN PHALMAC_PG_EFUSE_INFO pPg_efuse_info,
814 IN u8 *pEeprom_mask_updated
815 )
816 {
817 u8 pre_word_enb, word_enb;
818 u8 pg_efuse_header, pg_efuse_header2;
819 u8 pg_block;
820 u16 i, j;
821 u32 efuse_end;
822 u32 tmp_eeprom_offset;
823 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
824
825 efuse_end = pHalmac_adapter->efuse_end;
826
827 for (i = 0; i < pPg_efuse_info->efuse_map_size; i = i + 8) {
828 tmp_eeprom_offset = i;
829
830 if (((tmp_eeprom_offset >> 3) & 1) > 0) {
831 pre_word_enb = (*(pEeprom_mask_updated + (i >> 4)) & 0x0F);
832 word_enb = pre_word_enb ^ 0x0F;
833 } else {
834 pre_word_enb = (*(pEeprom_mask_updated + (i >> 4)) >> 4);
835 word_enb = pre_word_enb ^ 0x0F;
836 }
837
838 pg_block = (u8)(tmp_eeprom_offset >> 3);
839
840 if (pre_word_enb > 0) {
841 if (tmp_eeprom_offset > 0x7f) {
842 pg_efuse_header = (((pg_block & 0x07) << 5) & 0xE0) | 0x0F;
843 pg_efuse_header2 = (u8)(((pg_block & 0x78) << 1) + word_enb);
844 } else {
845 pg_efuse_header = (u8)((pg_block << 4) + word_enb);
846 }
847
848 if (tmp_eeprom_offset > 0x7f) {
849 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, pg_efuse_header);
850 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 1, pg_efuse_header2);
851 efuse_end = efuse_end + 2;
852 for (j = 0; j < 4; j++) {
853 if (((pre_word_enb >> j) & 0x1) > 0) {
854 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, *(pPg_efuse_info->pEfuse_map + tmp_eeprom_offset + (j << 1)));
855 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 1, *(pPg_efuse_info->pEfuse_map + tmp_eeprom_offset + (j << 1) + 1));
856 efuse_end = efuse_end + 2;
857 }
858 }
859 } else {
860 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, pg_efuse_header);
861 efuse_end = efuse_end + 1;
862 for (j = 0; j < 4; j++) {
863 if (((pre_word_enb >> j) & 0x1) > 0) {
864 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end, *(pPg_efuse_info->pEfuse_map + tmp_eeprom_offset + (j << 1)));
865 status = halmac_func_write_efuse_88xx(pHalmac_adapter, efuse_end + 1, *(pPg_efuse_info->pEfuse_map + tmp_eeprom_offset + (j << 1) + 1));
866 efuse_end = efuse_end + 2;
867 }
868 }
869 }
870 }
871 }
872
873 return status;
874 }
875
876 HALMAC_RET_STATUS
halmac_dlfw_to_mem_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pRam_code,IN u32 dest,IN u32 code_size)877 halmac_dlfw_to_mem_88xx(
878 IN PHALMAC_ADAPTER pHalmac_adapter,
879 IN u8 *pRam_code,
880 IN u32 dest,
881 IN u32 code_size
882 )
883 {
884 u8 *pCode_ptr;
885 u8 first_part;
886 u32 mem_offset;
887 u32 pkt_size_tmp, send_pkt_size;
888 VOID *pDriver_adapter = NULL;
889 PHALMAC_API pHalmac_api;
890
891 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
892 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
893
894 pCode_ptr = pRam_code;
895 mem_offset = 0;
896 first_part = 1;
897 pkt_size_tmp = code_size;
898
899 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_DDMA_CH0CTRL, HALMAC_REG_READ_32(pHalmac_adapter, REG_DDMA_CH0CTRL) | BIT_DDMACH0_RESET_CHKSUM_STS);
900
901 while (0 != pkt_size_tmp) {
902 if (pkt_size_tmp >= pHalmac_adapter->max_download_size)
903 send_pkt_size = pHalmac_adapter->max_download_size;
904 else
905 send_pkt_size = pkt_size_tmp;
906
907 if (HALMAC_RET_SUCCESS != halmac_send_fwpkt_88xx(pHalmac_adapter, pCode_ptr + mem_offset, send_pkt_size)) {
908 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_send_fwpkt_88xx fail!!");
909 return HALMAC_RET_DLFW_FAIL;
910 }
911
912 if (HALMAC_RET_SUCCESS != halmac_iddma_dlfw_88xx(pHalmac_adapter, HALMAC_OCPBASE_TXBUF_88XX + pHalmac_adapter->hw_config_info.txdesc_size,
913 dest + mem_offset, send_pkt_size, first_part)) {
914 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_iddma_dlfw_88xx fail!!");
915 return HALMAC_RET_DLFW_FAIL;
916 }
917
918 first_part = 0;
919 mem_offset += send_pkt_size;
920 pkt_size_tmp -= send_pkt_size;
921 }
922
923 if (HALMAC_RET_SUCCESS != halmac_check_fw_chksum_88xx(pHalmac_adapter, dest)) {
924 PLATFORM_MSG_PRINT(pHalmac_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_check_fw_chksum_88xx fail!!");
925 return HALMAC_RET_DLFW_FAIL;
926 }
927
928 return HALMAC_RET_SUCCESS;
929 }
930
931 HALMAC_RET_STATUS
halmac_send_fwpkt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pRam_code,IN u32 code_size)932 halmac_send_fwpkt_88xx(
933 IN PHALMAC_ADAPTER pHalmac_adapter,
934 IN u8 *pRam_code,
935 IN u32 code_size
936 )
937 {
938 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
939
940 if (HALMAC_RET_SUCCESS != halmac_download_rsvd_page_88xx(pHalmac_adapter, pRam_code, code_size)) {
941 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "PLATFORM_SEND_RSVD_PAGE 0 error!!\n");
942 return HALMAC_RET_DL_RSVD_PAGE_FAIL;
943 }
944
945 return HALMAC_RET_SUCCESS;
946 }
947
948 HALMAC_RET_STATUS
halmac_iddma_dlfw_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 source,IN u32 dest,IN u32 length,IN u8 first)949 halmac_iddma_dlfw_88xx(
950 IN PHALMAC_ADAPTER pHalmac_adapter,
951 IN u32 source,
952 IN u32 dest,
953 IN u32 length,
954 IN u8 first
955 )
956 {
957 u32 counter;
958 u32 ch0_control = (u32)(BIT_DDMACH0_CHKSUM_EN | BIT_DDMACH0_OWN);
959 VOID *pDriver_adapter = NULL;
960 PHALMAC_API pHalmac_api;
961
962 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
963 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
964
965 counter = HALMC_DDMA_POLLING_COUNT;
966 while (HALMAC_REG_READ_32(pHalmac_adapter, REG_DDMA_CH0CTRL) & BIT_DDMACH0_OWN) {
967 counter--;
968 if (0 == counter) {
969 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "halmac_iddma_dlfw_88xx error-1!!\n");
970 return HALMAC_RET_DDMA_FAIL;
971 }
972 }
973
974 ch0_control |= (length & BIT_MASK_DDMACH0_DLEN);
975 if (0 == first)
976 ch0_control |= BIT_DDMACH0_CHKSUM_CONT;
977
978 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_DDMA_CH0SA, source);
979 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_DDMA_CH0DA, dest);
980 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_DDMA_CH0CTRL, ch0_control);
981
982 counter = HALMC_DDMA_POLLING_COUNT;
983 while (HALMAC_REG_READ_32(pHalmac_adapter, REG_DDMA_CH0CTRL) & BIT_DDMACH0_OWN) {
984 counter--;
985 if (0 == counter) {
986 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "halmac_iddma_dlfw_88xx error-2!!\n");
987 return HALMAC_RET_DDMA_FAIL;
988 }
989 }
990
991 return HALMAC_RET_SUCCESS;
992 }
993
994 HALMAC_RET_STATUS
halmac_check_fw_chksum_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 memory_address)995 halmac_check_fw_chksum_88xx(
996 IN PHALMAC_ADAPTER pHalmac_adapter,
997 IN u32 memory_address
998 )
999 {
1000 u8 mcu_fw_ctrl;
1001 VOID *pDriver_adapter = NULL;
1002 PHALMAC_API pHalmac_api;
1003
1004 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1005 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1006
1007 mcu_fw_ctrl = HALMAC_REG_READ_8(pHalmac_adapter, REG_MCUFW_CTRL);
1008
1009 if (HALMAC_REG_READ_32(pHalmac_adapter, REG_DDMA_CH0CTRL) & BIT_DDMACH0_CHKSUM_STS) {
1010 if (memory_address < HALMAC_OCPBASE_DMEM_88XX) {
1011 mcu_fw_ctrl |= BIT_IMEM_DW_OK;
1012 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(mcu_fw_ctrl & ~(BIT_IMEM_CHKSUM_OK)));
1013 } else {
1014 mcu_fw_ctrl |= BIT_DMEM_DW_OK;
1015 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(mcu_fw_ctrl & ~(BIT_DMEM_CHKSUM_OK)));
1016 }
1017
1018 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_FW, HALMAC_DBG_ERR, "halmac_check_fw_chksum_88xx error!!\n");
1019
1020 return HALMAC_RET_FW_CHECKSUM_FAIL;
1021 } else {
1022 if (memory_address < HALMAC_OCPBASE_DMEM_88XX) {
1023 mcu_fw_ctrl |= BIT_IMEM_DW_OK;
1024 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(mcu_fw_ctrl | BIT_IMEM_CHKSUM_OK));
1025 } else {
1026 mcu_fw_ctrl |= BIT_DMEM_DW_OK;
1027 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(mcu_fw_ctrl | BIT_DMEM_CHKSUM_OK));
1028 }
1029
1030 return HALMAC_RET_SUCCESS;
1031 }
1032 }
1033
1034 HALMAC_RET_STATUS
halmac_dlfw_end_flow_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)1035 halmac_dlfw_end_flow_88xx(
1036 IN PHALMAC_ADAPTER pHalmac_adapter
1037 )
1038 {
1039 u8 value8;
1040 u32 counter;
1041 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1042 PHALMAC_API pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1043
1044 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_TXDMA_STATUS, BIT(2));
1045
1046 /* Check IMEM & DMEM checksum is OK or not */
1047 if (0x50 == (HALMAC_REG_READ_8(pHalmac_adapter, REG_MCUFW_CTRL) & 0x50))
1048 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_MCUFW_CTRL, (u16)(HALMAC_REG_READ_16(pHalmac_adapter, REG_MCUFW_CTRL) | BIT_FW_DW_RDY));
1049 else
1050 return HALMAC_RET_DLFW_FAIL;
1051
1052 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_MCUFW_CTRL, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_MCUFW_CTRL) & ~(BIT(0))));
1053
1054 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_SYS_FUNC_EN + 1);
1055 value8 = (u8)(value8 | BIT(2));
1056 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_SYS_FUNC_EN + 1, value8); /* Release MCU reset */
1057 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Download Finish, Reset CPU\n");
1058
1059 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_AUTO_LLT_V1, (u8)(HALMAC_REG_READ_8(pHalmac_adapter, REG_AUTO_LLT_V1) | BIT_AUTO_INIT_LLT_V1));
1060 counter = 1000;
1061 while (HALMAC_REG_READ_8(pHalmac_adapter, REG_AUTO_LLT_V1) & BIT_AUTO_INIT_LLT_V1) {
1062 counter--;
1063 if (counter == 0)
1064 return HALMAC_RET_INIT_LLT_FAIL;
1065 }
1066 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Reset LLT\n");
1067
1068 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_WL2LTECOEX_INDIRECT_ACCESS_CTRL_V1, 0xC00F0038);
1069
1070 counter = 10000;
1071 while (0xC078 != HALMAC_REG_READ_16(pHalmac_adapter, REG_MCUFW_CTRL)) {
1072 if (counter == 0) {
1073 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Check 0x80 = 0xC078 fail\n");
1074 return HALMAC_RET_DLFW_FAIL;
1075 }
1076 counter--;
1077 PLATFORM_RTL_DELAY_US(pDriver_adapter, 50);
1078 }
1079
1080 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "Check 0x80 = 0xC078 counter = %d\n", counter);
1081
1082 return HALMAC_RET_SUCCESS;
1083 }
1084
1085 HALMAC_RET_STATUS
halmac_pwr_seq_parser_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 CUT,IN u8 FAB,IN u8 INTF,IN PHALMAC_WLAN_PWR_CFG PWR_SEQ_CFG)1086 halmac_pwr_seq_parser_88xx(
1087 IN PHALMAC_ADAPTER pHalmac_adapter,
1088 IN u8 CUT,
1089 IN u8 FAB,
1090 IN u8 INTF,
1091 IN PHALMAC_WLAN_PWR_CFG PWR_SEQ_CFG
1092 )
1093 {
1094 u8 value;
1095 u8 PollingBit = _FALSE;
1096 u32 AryIdx = 0;
1097 u32 PollingCount;
1098 u32 offset;
1099 VOID *pDriver_adapter = NULL;
1100 HALMAC_WLAN_PWR_CFG PWR_SEQ_CMD;
1101 PHALMAC_API pHalmac_api;
1102
1103 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1104 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1105
1106 do {
1107 PWR_SEQ_CMD = PWR_SEQ_CFG[AryIdx];
1108
1109 if ((PWR_SEQ_CMD.interface_msk & INTF) && (PWR_SEQ_CMD.fab_msk & FAB) && (PWR_SEQ_CMD.cut_msk & CUT)) {
1110 switch (PWR_SEQ_CMD.cmd) {
1111 case HALMAC_PWR_CMD_WRITE:
1112 if (PWR_SEQ_CMD.base == HALMAC_PWR_BASEADDR_SDIO)
1113 offset = PWR_SEQ_CMD.offset | SDIO_LOCAL_OFFSET;
1114 else
1115 offset = PWR_SEQ_CMD.offset;
1116
1117 value = HALMAC_REG_READ_8(pHalmac_adapter, offset);
1118 value = (u8)(value & (u8)(~(PWR_SEQ_CMD.msk)));
1119 value = (u8)(value | (u8)(PWR_SEQ_CMD.value & PWR_SEQ_CMD.msk));
1120
1121 HALMAC_REG_WRITE_8(pHalmac_adapter, offset, value);
1122 break;
1123 case HALMAC_PWR_CMD_POLLING:
1124 PollingBit = 0;
1125 PollingCount = HALMAC_POLLING_READY_TIMEOUT_COUNT;
1126
1127 if (PWR_SEQ_CMD.base == HALMAC_PWR_BASEADDR_SDIO)
1128 offset = PWR_SEQ_CMD.offset | SDIO_LOCAL_OFFSET;
1129 else
1130 offset = PWR_SEQ_CMD.offset;
1131
1132 do {
1133 PollingCount--;
1134 value = HALMAC_REG_READ_8(pHalmac_adapter, offset);
1135 value = (u8)(value & PWR_SEQ_CMD.msk);
1136
1137 if (value == (PWR_SEQ_CMD.value & PWR_SEQ_CMD.msk)) {
1138 PollingBit = 1;
1139 } else {
1140 if (0 == PollingCount) {
1141 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_pwr_seq_parser_88xx HALMAC_RET_PWRSEQ_POLLING_FAIL\n");
1142 return HALMAC_RET_PWRSEQ_POLLING_FAIL;
1143 } else {
1144 PLATFORM_RTL_DELAY_US(pDriver_adapter, 50);
1145 }
1146 }
1147 } while (!PollingBit);
1148 break;
1149 case HALMAC_PWR_CMD_DELAY:
1150 if (PWR_SEQ_CMD.value == HALMAC_PWRSEQ_DELAY_US)
1151 PLATFORM_RTL_DELAY_US(pDriver_adapter, PWR_SEQ_CMD.offset);
1152 else
1153 PLATFORM_RTL_DELAY_US(pDriver_adapter, 1000 * PWR_SEQ_CMD.offset);
1154 break;
1155 case HALMAC_PWR_CMD_READ:
1156 break;
1157 case HALMAC_PWR_CMD_END:
1158 return HALMAC_RET_SUCCESS;
1159 default:
1160 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_pwr_seq_parser_88xx HALMAC_RET_PWRSEQ_CMD_INCORRECT\n");
1161 return HALMAC_RET_PWRSEQ_CMD_INCORRECT;
1162 }
1163 }
1164 AryIdx++;
1165 } while (1);
1166
1167 return HALMAC_RET_SUCCESS;
1168 }
1169
1170 HALMAC_RET_STATUS
halmac_get_h2c_buff_free_space_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)1171 halmac_get_h2c_buff_free_space_88xx(
1172 IN PHALMAC_ADAPTER pHalmac_adapter
1173 )
1174 {
1175 u32 hw_wptr, fw_rptr;
1176 PHALMAC_API pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1177
1178 hw_wptr = HALMAC_REG_READ_32(pHalmac_adapter, REG_H2C_PKT_WRITEADDR) & BIT_MASK_H2C_WR_ADDR;
1179 fw_rptr = HALMAC_REG_READ_32(pHalmac_adapter, REG_H2C_PKT_READADDR) & BIT_MASK_H2C_READ_ADDR;
1180
1181 if (hw_wptr >= fw_rptr)
1182 pHalmac_adapter->h2c_buf_free_space = pHalmac_adapter->h2c_buff_size - (hw_wptr - fw_rptr);
1183 else
1184 pHalmac_adapter->h2c_buf_free_space = fw_rptr - hw_wptr;
1185
1186 return HALMAC_RET_SUCCESS;
1187 }
1188
1189 HALMAC_RET_STATUS
halmac_send_h2c_pkt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pHal_h2c_cmd,IN u32 size,IN u8 ack)1190 halmac_send_h2c_pkt_88xx(
1191 IN PHALMAC_ADAPTER pHalmac_adapter,
1192 IN u8 *pHal_h2c_cmd,
1193 IN u32 size,
1194 IN u8 ack
1195 )
1196 {
1197 u32 counter = 100;
1198 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1199 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1200
1201 while (pHalmac_adapter->h2c_buf_free_space <= HALMAC_H2C_CMD_SIZE_UNIT_88XX) {
1202 halmac_get_h2c_buff_free_space_88xx(pHalmac_adapter);
1203 counter--;
1204 if (0 == counter) {
1205 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "h2c free space is not enough!!\n");
1206 return HALMAC_RET_H2C_SPACE_FULL;
1207 }
1208 }
1209
1210 /* Send TxDesc + H2C_CMD */
1211 if (_FALSE == PLATFORM_SEND_H2C_PKT(pDriver_adapter, pHal_h2c_cmd, size)) {
1212 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Send H2C_CMD pkt error!!\n");
1213 return HALMAC_RET_SEND_H2C_FAIL;
1214 }
1215
1216 pHalmac_adapter->h2c_buf_free_space -= HALMAC_H2C_CMD_SIZE_UNIT_88XX;
1217
1218 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "H2C free space : %d\n", pHalmac_adapter->h2c_buf_free_space);
1219
1220 return status;
1221 }
1222
1223 HALMAC_RET_STATUS
halmac_download_rsvd_page_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pHal_buf,IN u32 size)1224 halmac_download_rsvd_page_88xx(
1225 IN PHALMAC_ADAPTER pHalmac_adapter,
1226 IN u8 *pHal_buf,
1227 IN u32 size
1228 )
1229 {
1230 u8 restore[3];
1231 u8 value8;
1232 u32 counter;
1233 VOID *pDriver_adapter = NULL;
1234 PHALMAC_API pHalmac_api;
1235 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1236
1237 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1238 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1239
1240 if (0 == size) {
1241 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Rsvd page packet size is zero!!\n");
1242 return HALMAC_RET_ZERO_LEN_RSVD_PACKET;
1243 }
1244
1245 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_FIFOPAGE_CTRL_2 + 1);
1246 value8 = (u8)(value8 | BIT(7));
1247 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_FIFOPAGE_CTRL_2 + 1, value8);
1248
1249 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_CR + 1);
1250 restore[0] = value8;
1251 value8 = (u8)(value8 | BIT(0));
1252 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CR + 1, value8);
1253
1254 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_BCN_CTRL);
1255 restore[1] = value8;
1256 value8 = (u8)((value8 & ~(BIT(3))) | BIT(4));
1257 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL, value8);
1258
1259 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_FWHW_TXQ_CTRL + 2);
1260 restore[2] = value8;
1261 value8 = (u8)(value8 & ~(BIT(6)));
1262 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_FWHW_TXQ_CTRL + 2, value8);
1263
1264 if (_FALSE == PLATFORM_SEND_RSVD_PAGE(pDriver_adapter, pHal_buf, size)) {
1265 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "PLATFORM_SEND_RSVD_PAGE 1 error!!\n");
1266 status = HALMAC_RET_DL_RSVD_PAGE_FAIL;
1267 }
1268
1269 /* Check Bcn_Valid_Bit */
1270 counter = 100;
1271 while (!(HALMAC_REG_READ_8(pHalmac_adapter, REG_FIFOPAGE_CTRL_2 + 1) & BIT(7))) {
1272 PLATFORM_RTL_DELAY_US(pDriver_adapter, 10);
1273 counter--;
1274 if (0 == counter) {
1275 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Polling Bcn_Valid_Fail error!!\n");
1276 status = HALMAC_RET_POLLING_BCN_VALID_FAIL;
1277 break;
1278 }
1279 }
1280
1281 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_FIFOPAGE_CTRL_2 + 1);
1282 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_FIFOPAGE_CTRL_2 + 1, (value8 | BIT(7)));
1283
1284 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_FWHW_TXQ_CTRL + 2, restore[2]);
1285 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_BCN_CTRL, restore[1]);
1286 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_CR + 1, restore[0]);
1287
1288 return status;
1289 }
1290
1291 HALMAC_RET_STATUS
halmac_set_h2c_header_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u8 * pHal_h2c_hdr,IN u16 * seq,IN u8 ack)1292 halmac_set_h2c_header_88xx(
1293 IN PHALMAC_ADAPTER pHalmac_adapter,
1294 OUT u8 *pHal_h2c_hdr,
1295 IN u16 *seq,
1296 IN u8 ack
1297 )
1298 {
1299 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1300
1301 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_set_h2c_header_88xx!!\n");
1302
1303 H2C_CMD_HEADER_SET_CATEGORY(pHal_h2c_hdr, 0x00);
1304 H2C_CMD_HEADER_SET_TOTAL_LEN(pHal_h2c_hdr, 16);
1305
1306 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->h2c_seq_mutex));
1307 H2C_CMD_HEADER_SET_SEQ_NUM(pHal_h2c_hdr, pHalmac_adapter->h2c_packet_seq);
1308 *seq = pHalmac_adapter->h2c_packet_seq;
1309 pHalmac_adapter->h2c_packet_seq++;
1310 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->h2c_seq_mutex));
1311
1312 if (_TRUE == ack)
1313 H2C_CMD_HEADER_SET_ACK(pHal_h2c_hdr, _TRUE);
1314
1315 return HALMAC_RET_SUCCESS;
1316 }
1317
1318 HALMAC_RET_STATUS
halmac_set_fw_offload_h2c_header_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u8 * pHal_h2c_hdr,IN PHALMAC_H2C_HEADER_INFO pH2c_header_info,OUT u16 * pSeq_num)1319 halmac_set_fw_offload_h2c_header_88xx(
1320 IN PHALMAC_ADAPTER pHalmac_adapter,
1321 OUT u8 *pHal_h2c_hdr,
1322 IN PHALMAC_H2C_HEADER_INFO pH2c_header_info,
1323 OUT u16 *pSeq_num
1324 )
1325 {
1326 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1327
1328 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_set_fw_offload_h2c_header_88xx!!\n");
1329
1330 FW_OFFLOAD_H2C_SET_TOTAL_LEN(pHal_h2c_hdr, 8 + pH2c_header_info->content_size);
1331 FW_OFFLOAD_H2C_SET_SUB_CMD_ID(pHal_h2c_hdr, pH2c_header_info->sub_cmd_id);
1332
1333 FW_OFFLOAD_H2C_SET_CATEGORY(pHal_h2c_hdr, 0x01);
1334 FW_OFFLOAD_H2C_SET_CMD_ID(pHal_h2c_hdr, 0xFF);
1335
1336 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->h2c_seq_mutex));
1337 FW_OFFLOAD_H2C_SET_SEQ_NUM(pHal_h2c_hdr, pHalmac_adapter->h2c_packet_seq);
1338 *pSeq_num = pHalmac_adapter->h2c_packet_seq;
1339 pHalmac_adapter->h2c_packet_seq++;
1340 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->h2c_seq_mutex));
1341
1342 if (_TRUE == pH2c_header_info->ack)
1343 FW_OFFLOAD_H2C_SET_ACK(pHal_h2c_hdr, _TRUE);
1344
1345 return HALMAC_RET_SUCCESS;
1346 }
1347
1348 HALMAC_RET_STATUS
halmac_send_h2c_set_pwr_mode_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_FWLPS_OPTION pHal_FwLps_Opt)1349 halmac_send_h2c_set_pwr_mode_88xx(
1350 IN PHALMAC_ADAPTER pHalmac_adapter,
1351 IN PHALMAC_FWLPS_OPTION pHal_FwLps_Opt
1352 )
1353 {
1354 u8 h2c_buff[HALMAC_H2C_CMD_SIZE_88XX];
1355 u8 *pH2c_header, *pH2c_cmd;
1356 u16 seq = 0;
1357 VOID *pDriver_adapter = NULL;
1358 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1359
1360 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_set_pwr_mode_88xx!!\n");
1361
1362 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1363 pH2c_header = h2c_buff;
1364 pH2c_cmd = pH2c_header + HALMAC_H2C_CMD_HDR_SIZE_88XX;
1365
1366 PLATFORM_RTL_MEMSET(pDriver_adapter, h2c_buff, 0x00, HALMAC_H2C_CMD_SIZE_88XX);
1367
1368 SET_PWR_MODE_SET_CMD_ID(pH2c_cmd, CMD_ID_SET_PWR_MODE);
1369 SET_PWR_MODE_SET_CLASS(pH2c_cmd, CLASS_SET_PWR_MODE);
1370 SET_PWR_MODE_SET_MODE(pH2c_cmd, pHal_FwLps_Opt->mode);
1371 SET_PWR_MODE_SET_CLK_REQUEST(pH2c_cmd, pHal_FwLps_Opt->clk_request);
1372 SET_PWR_MODE_SET_RLBM(pH2c_cmd, pHal_FwLps_Opt->rlbm);
1373 SET_PWR_MODE_SET_SMART_PS(pH2c_cmd, pHal_FwLps_Opt->smart_ps);
1374 SET_PWR_MODE_SET_AWAKE_INTERVAL(pH2c_cmd, pHal_FwLps_Opt->awake_interval);
1375 SET_PWR_MODE_SET_B_ALL_QUEUE_UAPSD(pH2c_cmd, pHal_FwLps_Opt->all_queue_uapsd);
1376 SET_PWR_MODE_SET_PWR_STATE(pH2c_cmd, pHal_FwLps_Opt->pwr_state);
1377 SET_PWR_MODE_SET_ANT_AUTO_SWITCH(pH2c_cmd, pHal_FwLps_Opt->ant_auto_switch);
1378 SET_PWR_MODE_SET_PS_ALLOW_BT_HIGH_PRIORITY(pH2c_cmd, pHal_FwLps_Opt->ps_allow_bt_high_Priority);
1379 SET_PWR_MODE_SET_PROTECT_BCN(pH2c_cmd, pHal_FwLps_Opt->protect_bcn);
1380 SET_PWR_MODE_SET_SILENCE_PERIOD(pH2c_cmd, pHal_FwLps_Opt->silence_period);
1381 SET_PWR_MODE_SET_FAST_BT_CONNECT(pH2c_cmd, pHal_FwLps_Opt->fast_bt_connect);
1382 SET_PWR_MODE_SET_TWO_ANTENNA_EN(pH2c_cmd, pHal_FwLps_Opt->two_antenna_en);
1383 SET_PWR_MODE_SET_ADOPT_USER_SETTING(pH2c_cmd, pHal_FwLps_Opt->adopt_user_Setting);
1384 SET_PWR_MODE_SET_DRV_BCN_EARLY_SHIFT(pH2c_cmd, pHal_FwLps_Opt->drv_bcn_early_shift);
1385
1386 halmac_set_h2c_header_88xx(pHalmac_adapter, pH2c_header, &seq, _TRUE);
1387
1388 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, h2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1389
1390 if (HALMAC_RET_SUCCESS != status) {
1391 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_set_pwr_mode_88xx Fail = %x!!\n", status);
1392 return status;
1393 }
1394
1395 return HALMAC_RET_SUCCESS;
1396 }
1397
1398 HALMAC_RET_STATUS
halmac_func_send_original_h2c_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * original_h2c,IN u16 * seq,IN u8 ack)1399 halmac_func_send_original_h2c_88xx(
1400 IN PHALMAC_ADAPTER pHalmac_adapter,
1401 IN u8 *original_h2c,
1402 IN u16 *seq,
1403 IN u8 ack
1404 )
1405 {
1406 u8 H2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1407 u8 *pH2c_header, *pH2c_cmd;
1408 VOID *pDriver_adapter = NULL;
1409 PHALMAC_API pHalmac_api;
1410 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1411
1412 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1413 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1414
1415 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_original_h2c ==========>\n");
1416
1417 pH2c_header = H2c_buff;
1418 pH2c_cmd = pH2c_header + HALMAC_H2C_CMD_HDR_SIZE_88XX;
1419 PLATFORM_RTL_MEMCPY(pDriver_adapter, pH2c_cmd, original_h2c, 8); /* Original H2C 8 byte */
1420
1421 halmac_set_h2c_header_88xx(pHalmac_adapter, pH2c_header, seq, ack);
1422
1423 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, H2c_buff, HALMAC_H2C_CMD_SIZE_88XX, ack);
1424
1425 if (HALMAC_RET_SUCCESS != status) {
1426 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_original_h2c Fail = %x!!\n", status);
1427 return status;
1428 }
1429
1430 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_original_h2c <==========\n");
1431
1432 return HALMAC_RET_SUCCESS;
1433 }
1434
1435 HALMAC_RET_STATUS
halmac_media_status_rpt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 op_mode,IN u8 mac_id_ind,IN u8 mac_id,IN u8 mac_id_end)1436 halmac_media_status_rpt_88xx(
1437 IN PHALMAC_ADAPTER pHalmac_adapter,
1438 IN u8 op_mode,
1439 IN u8 mac_id_ind,
1440 IN u8 mac_id,
1441 IN u8 mac_id_end
1442 )
1443 {
1444 u8 H2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1445 u8 *pH2c_header, *pH2c_cmd;
1446 u16 seq = 0;
1447 VOID *pDriver_adapter = NULL;
1448 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1449
1450 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_set_pwr_mode_88xx!!\n");
1451
1452 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1453 pH2c_header = H2c_buff;
1454 pH2c_cmd = pH2c_header + HALMAC_H2C_CMD_HDR_SIZE_88XX;
1455
1456 PLATFORM_RTL_MEMSET(pDriver_adapter, H2c_buff, 0x00, HALMAC_H2C_CMD_SIZE_88XX);
1457
1458 MEDIA_STATUS_RPT_SET_CMD_ID(pH2c_cmd, CMD_ID_MEDIA_STATUS_RPT);
1459 MEDIA_STATUS_RPT_SET_CLASS(pH2c_cmd, CLASS_MEDIA_STATUS_RPT);
1460 MEDIA_STATUS_RPT_SET_OP_MODE(pH2c_cmd, op_mode);
1461 MEDIA_STATUS_RPT_SET_MACID_IN(pH2c_cmd, mac_id_ind);
1462 MEDIA_STATUS_RPT_SET_MACID(pH2c_cmd, mac_id);
1463 MEDIA_STATUS_RPT_SET_MACID_END(pH2c_cmd, mac_id_end);
1464
1465 halmac_set_h2c_header_88xx(pHalmac_adapter, pH2c_header, &seq, _TRUE);
1466
1467 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, H2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1468
1469 if (HALMAC_RET_SUCCESS != status) {
1470 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_media_status_rpt_88xx Fail = %x!!\n", status);
1471 return status;
1472 }
1473
1474 return HALMAC_RET_SUCCESS;
1475 }
1476
1477 HALMAC_RET_STATUS
halmac_send_h2c_update_packet_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_PACKET_ID pkt_id,IN u8 * pkt,IN u32 pkt_size)1478 halmac_send_h2c_update_packet_88xx(
1479 IN PHALMAC_ADAPTER pHalmac_adapter,
1480 IN HALMAC_PACKET_ID pkt_id,
1481 IN u8 *pkt,
1482 IN u32 pkt_size
1483 )
1484 {
1485 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1486 u16 h2c_seq_mum = 0;
1487 VOID *pDriver_adapter = NULL;
1488 PHALMAC_API pHalmac_api;
1489 HALMAC_H2C_HEADER_INFO h2c_header_info;
1490 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
1491
1492 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1493 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1494
1495 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1496
1497 ret_status = halmac_download_rsvd_page_88xx(pHalmac_adapter, pkt, pkt_size);
1498
1499 if (HALMAC_RET_SUCCESS != ret_status) {
1500 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_download_rsvd_page_88xx Fail = %x!!\n", ret_status);
1501 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1502 return ret_status;
1503 }
1504
1505 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1506
1507 UPDATE_PACKET_SET_SIZE(pH2c_buff, pkt_size + pHalmac_adapter->hw_config_info.txdesc_size);
1508 UPDATE_PACKET_SET_PACKET_ID(pH2c_buff, pkt_id);
1509 UPDATE_PACKET_SET_PACKET_LOC(pH2c_buff, pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy - pHalmac_adapter->txff_allocation.rsvd_pg_bndy);
1510
1511 h2c_header_info.sub_cmd_id = SUB_CMD_ID_UPDATE_PACKET;
1512 h2c_header_info.content_size = 8;
1513 h2c_header_info.ack = _TRUE;
1514 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1515 pHalmac_adapter->halmac_state.update_packet_set.seq_num = h2c_seq_mum;
1516
1517 ret_status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1518
1519 if (HALMAC_RET_SUCCESS != ret_status) {
1520 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_update_packet_88xx Fail = %x!!\n", ret_status);
1521 return ret_status;
1522 }
1523
1524 return ret_status;
1525 }
1526
1527 HALMAC_RET_STATUS
halmac_send_h2c_phy_parameter_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PHY_PARAMETER_INFO para_info,IN u8 full_fifo)1528 halmac_send_h2c_phy_parameter_88xx(
1529 IN PHALMAC_ADAPTER pHalmac_adapter,
1530 IN PHALMAC_PHY_PARAMETER_INFO para_info,
1531 IN u8 full_fifo
1532 )
1533 {
1534 u8 drv_trigger_send = _FALSE;
1535 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1536 u16 h2c_seq_mum = 0;
1537 u32 info_size = 0;
1538 VOID *pDriver_adapter = NULL;
1539 PHALMAC_API pHalmac_api;
1540 HALMAC_H2C_HEADER_INFO h2c_header_info;
1541 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1542 PHALMAC_CONFIG_PARA_INFO pConfig_para_info;
1543
1544 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1545 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1546 pConfig_para_info = &(pHalmac_adapter->config_para_info);
1547
1548 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_phy_parameter_88xx!!\n"); */
1549
1550 if (NULL == pConfig_para_info->pCfg_para_buf) {
1551 if (_TRUE == full_fifo)
1552 pConfig_para_info->para_buf_size = HALMAC_EXTRA_INFO_BUFF_SIZE_FULL_FIFO_88XX;
1553 else
1554 pConfig_para_info->para_buf_size = HALMAC_EXTRA_INFO_BUFF_SIZE_88XX;
1555
1556 pConfig_para_info->pCfg_para_buf = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, pConfig_para_info->para_buf_size);
1557
1558 if (NULL != pConfig_para_info->pCfg_para_buf) {
1559 PLATFORM_RTL_MEMSET(pDriver_adapter, pConfig_para_info->pCfg_para_buf, 0x00, pConfig_para_info->para_buf_size);
1560 pConfig_para_info->full_fifo_mode = full_fifo;
1561 pConfig_para_info->pPara_buf_w = pConfig_para_info->pCfg_para_buf;
1562 pConfig_para_info->para_num = 0;
1563 pConfig_para_info->avai_para_buf_size = pConfig_para_info->para_buf_size;
1564 pConfig_para_info->value_accumulation = 0;
1565 pConfig_para_info->offset_accumulation = 0;
1566 } else {
1567 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Allocate pCfg_para_buf fail!!\n");
1568 return HALMAC_RET_MALLOC_FAIL;
1569 }
1570 }
1571
1572 if (HALMAC_RET_SUCCESS != halmac_transition_cfg_para_state_88xx(pHalmac_adapter, HALMAC_CFG_PARA_CMD_CONSTRUCT_CONSTRUCTING))
1573 return HALMAC_RET_ERROR_STATE;
1574
1575 halmac_enqueue_para_buff_88xx(pHalmac_adapter, para_info, pConfig_para_info->pPara_buf_w, &drv_trigger_send);
1576
1577 if (HALMAC_PARAMETER_CMD_END != para_info->cmd_id) {
1578 pConfig_para_info->para_num++;
1579 pConfig_para_info->pPara_buf_w += HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1580 pConfig_para_info->avai_para_buf_size = pConfig_para_info->avai_para_buf_size - HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1581 }
1582
1583 if (((pConfig_para_info->avai_para_buf_size - pHalmac_adapter->hw_config_info.txdesc_size) > HALMAC_FW_OFFLOAD_CMD_SIZE_88XX) &&
1584 (_FALSE == drv_trigger_send)) {
1585 return HALMAC_RET_SUCCESS;
1586 } else {
1587 if (0 == pConfig_para_info->para_num) {
1588 PLATFORM_RTL_FREE(pDriver_adapter, pConfig_para_info->pCfg_para_buf, pConfig_para_info->para_buf_size);
1589 pConfig_para_info->pCfg_para_buf = NULL;
1590 pConfig_para_info->pPara_buf_w = NULL;
1591 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "no cfg parameter element!!\n");
1592
1593 if (HALMAC_RET_SUCCESS != halmac_transition_cfg_para_state_88xx(pHalmac_adapter, HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE))
1594 return HALMAC_RET_ERROR_STATE;
1595
1596 return HALMAC_RET_SUCCESS;
1597 }
1598
1599 if (HALMAC_RET_SUCCESS != halmac_transition_cfg_para_state_88xx(pHalmac_adapter, HALMAC_CFG_PARA_CMD_CONSTRUCT_H2C_SENT))
1600 return HALMAC_RET_ERROR_STATE;
1601
1602 pHalmac_adapter->halmac_state.cfg_para_state_set.process_status = HALMAC_CMD_PROCESS_SENDING;
1603
1604 if (_TRUE == pConfig_para_info->full_fifo_mode)
1605 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, 0);
1606 else
1607 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1608
1609 info_size = pConfig_para_info->para_num * HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1610
1611 status = halmac_download_rsvd_page_88xx(pHalmac_adapter, (u8 *)pConfig_para_info->pCfg_para_buf, info_size);
1612
1613 if (HALMAC_RET_SUCCESS != status) {
1614 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_download_rsvd_page_88xx Fail!!\n");
1615 } else {
1616 halmac_gen_cfg_para_h2c_88xx(pHalmac_adapter, pH2c_buff);
1617
1618 h2c_header_info.sub_cmd_id = SUB_CMD_ID_CFG_PARAMETER;
1619 h2c_header_info.content_size = 4;
1620 h2c_header_info.ack = _TRUE;
1621 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1622
1623 pHalmac_adapter->halmac_state.cfg_para_state_set.seq_num = h2c_seq_mum;
1624
1625 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1626
1627 if (HALMAC_RET_SUCCESS != status)
1628 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail!!\n");
1629
1630 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "config parameter time = %d\n", HALMAC_REG_READ_32(pHalmac_adapter, REG_FW_DBG6));
1631 }
1632
1633 PLATFORM_RTL_FREE(pDriver_adapter, pConfig_para_info->pCfg_para_buf, pConfig_para_info->para_buf_size);
1634 pConfig_para_info->pCfg_para_buf = NULL;
1635 pConfig_para_info->pPara_buf_w = NULL;
1636
1637 /* Restore bcn head */
1638 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1639
1640 if (HALMAC_RET_SUCCESS != halmac_transition_cfg_para_state_88xx(pHalmac_adapter, HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE))
1641 return HALMAC_RET_ERROR_STATE;
1642 }
1643
1644 if (_FALSE == drv_trigger_send) {
1645 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Buffer full trigger sending H2C!!\n");
1646 return HALMAC_RET_PARA_SENDING;
1647 }
1648
1649 return status;
1650 }
1651
1652 HALMAC_RET_STATUS
halmac_enqueue_para_buff_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_PHY_PARAMETER_INFO para_info,IN u8 * pCurr_buff_wptr,OUT u8 * pEnd_cmd)1653 halmac_enqueue_para_buff_88xx(
1654 IN PHALMAC_ADAPTER pHalmac_adapter,
1655 IN PHALMAC_PHY_PARAMETER_INFO para_info,
1656 IN u8 *pCurr_buff_wptr,
1657 OUT u8 *pEnd_cmd
1658 )
1659 {
1660 VOID *pDriver_adapter = NULL;
1661 PHALMAC_CONFIG_PARA_INFO pConfig_para_info = &(pHalmac_adapter->config_para_info);
1662
1663 *pEnd_cmd = _FALSE;
1664
1665 PHY_PARAMETER_INFO_SET_LENGTH(pCurr_buff_wptr, HALMAC_FW_OFFLOAD_CMD_SIZE_88XX);
1666 PHY_PARAMETER_INFO_SET_IO_CMD(pCurr_buff_wptr, para_info->cmd_id);
1667
1668 switch (para_info->cmd_id) {
1669 case HALMAC_PARAMETER_CMD_BB_W8:
1670 case HALMAC_PARAMETER_CMD_BB_W16:
1671 case HALMAC_PARAMETER_CMD_BB_W32:
1672 case HALMAC_PARAMETER_CMD_MAC_W8:
1673 case HALMAC_PARAMETER_CMD_MAC_W16:
1674 case HALMAC_PARAMETER_CMD_MAC_W32:
1675 PHY_PARAMETER_INFO_SET_IO_ADDR(pCurr_buff_wptr, para_info->content.MAC_REG_W.offset);
1676 PHY_PARAMETER_INFO_SET_DATA(pCurr_buff_wptr, para_info->content.MAC_REG_W.value);
1677 PHY_PARAMETER_INFO_SET_MASK(pCurr_buff_wptr, para_info->content.MAC_REG_W.msk);
1678 PHY_PARAMETER_INFO_SET_MSK_EN(pCurr_buff_wptr, para_info->content.MAC_REG_W.msk_en);
1679 pConfig_para_info->value_accumulation += para_info->content.MAC_REG_W.value;
1680 pConfig_para_info->offset_accumulation += para_info->content.MAC_REG_W.offset;
1681 break;
1682 case HALMAC_PARAMETER_CMD_RF_W:
1683 PHY_PARAMETER_INFO_SET_RF_ADDR(pCurr_buff_wptr, para_info->content.RF_REG_W.offset); /*In rf register, the address is only 1 byte*/
1684 PHY_PARAMETER_INFO_SET_RF_PATH(pCurr_buff_wptr, para_info->content.RF_REG_W.rf_path);
1685 PHY_PARAMETER_INFO_SET_DATA(pCurr_buff_wptr, para_info->content.RF_REG_W.value);
1686 PHY_PARAMETER_INFO_SET_MASK(pCurr_buff_wptr, para_info->content.RF_REG_W.msk);
1687 PHY_PARAMETER_INFO_SET_MSK_EN(pCurr_buff_wptr, para_info->content.RF_REG_W.msk_en);
1688 pConfig_para_info->value_accumulation += para_info->content.RF_REG_W.value;
1689 pConfig_para_info->offset_accumulation += (para_info->content.RF_REG_W.offset + (para_info->content.RF_REG_W.rf_path << 8));
1690 break;
1691 case HALMAC_PARAMETER_CMD_DELAY_US:
1692 case HALMAC_PARAMETER_CMD_DELAY_MS:
1693 PHY_PARAMETER_INFO_SET_DELAY_VALUE(pCurr_buff_wptr, para_info->content.DELAY_TIME.delay_time);
1694 break;
1695 case HALMAC_PARAMETER_CMD_END:
1696 *pEnd_cmd = _TRUE;
1697 break;
1698 default:
1699 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, " halmac_send_h2c_phy_parameter_88xx illegal cmd_id!!\n");
1700 break;
1701 }
1702
1703 return HALMAC_RET_SUCCESS;
1704 }
1705
1706 HALMAC_RET_STATUS
halmac_gen_cfg_para_h2c_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pH2c_buff)1707 halmac_gen_cfg_para_h2c_88xx(
1708 IN PHALMAC_ADAPTER pHalmac_adapter,
1709 IN u8 *pH2c_buff
1710 )
1711 {
1712 VOID *pDriver_adapter = NULL;
1713 PHALMAC_CONFIG_PARA_INFO pConfig_para_info = &(pHalmac_adapter->config_para_info);
1714
1715 CFG_PARAMETER_SET_NUM(pH2c_buff, pConfig_para_info->para_num);
1716
1717 if (_TRUE == pConfig_para_info->full_fifo_mode) {
1718 CFG_PARAMETER_SET_INIT_CASE(pH2c_buff, 0x1);
1719 CFG_PARAMETER_SET_PHY_PARAMETER_LOC(pH2c_buff, 0);
1720 } else {
1721 CFG_PARAMETER_SET_INIT_CASE(pH2c_buff, 0x0);
1722 CFG_PARAMETER_SET_PHY_PARAMETER_LOC(pH2c_buff, pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy - pHalmac_adapter->txff_allocation.rsvd_pg_bndy);
1723 }
1724
1725 return HALMAC_RET_SUCCESS;
1726 }
1727 #if 0
1728 HALMAC_RET_STATUS
1729 halmac_send_h2c_update_datapack_88xx(
1730 IN PHALMAC_ADAPTER pHalmac_adapter,
1731 IN HALMAC_DATA_TYPE halmac_data_type,
1732 IN PHALMAC_PHY_PARAMETER_INFO para_info
1733 )
1734 {
1735 u8 drv_trigger_send = _FALSE;
1736 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1737 u8 *pCurr_buf_w;
1738 u16 h2c_seq_mum = 0;
1739 u32 info_size = 0;
1740 VOID *pDriver_adapter = NULL;
1741 PHALMAC_API pHalmac_api;
1742 PHALMAC_CONFIG_PARA_INFO pConfig_para_info;
1743 HALMAC_H2C_HEADER_INFO h2c_header_info;
1744 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1745
1746 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1747 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1748 pConfig_para_info = &(pHalmac_adapter->config_para_info);
1749
1750 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_phy_parameter_88xx!!\n");
1751
1752 if (NULL == pConfig_para_info->pCfg_para_buf) {/*Buff null, allocate memory according to use mode*/
1753 /*else, only 4k reserved page is used*/
1754 pConfig_para_info->para_buf_size = HALMAC_EXTRA_INFO_BUFF_SIZE_88XX;
1755 /* pConfig_para_info->datapack_segment =0; */
1756
1757
1758 pConfig_para_info->pCfg_para_buf = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, pConfig_para_info->para_buf_size);
1759 if (NULL != pConfig_para_info->pCfg_para_buf) {
1760 /*Reset buffer parameter*/
1761 PLATFORM_RTL_MEMSET(pDriver_adapter, pConfig_para_info->pCfg_para_buf, 0x00, pConfig_para_info->para_buf_size);
1762 /* pConfig_para_info->full_fifo_mode = full_fifo; */
1763 pConfig_para_info->data_type = halmac_data_type;
1764 pConfig_para_info->pPara_buf_w = pConfig_para_info->pCfg_para_buf;
1765 pConfig_para_info->para_num = 0;
1766 pConfig_para_info->avai_para_buf_size = pConfig_para_info->para_buf_size;
1767 } else {
1768 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Allocate pCfg_para_buf fail!!\n");
1769 return HALMAC_RET_MALLOC_FAIL;
1770 }
1771 }
1772
1773 pCurr_buf_w = pConfig_para_info->pPara_buf_w;
1774
1775 /*Start fill buffer content*/
1776 PHY_PARAMETER_INFO_SET_LENGTH(pCurr_buf_w, HALMAC_FW_OFFLOAD_CMD_SIZE_88XX);/* Each element is 12 Byte */
1777 PHY_PARAMETER_INFO_SET_IO_CMD(pCurr_buf_w, para_info->cmd_id);
1778
1779 switch (para_info->cmd_id) {
1780 case HALMAC_PARAMETER_CMD_BB_W8:
1781 case HALMAC_PARAMETER_CMD_BB_W16:
1782 case HALMAC_PARAMETER_CMD_BB_W32:
1783 case HALMAC_PARAMETER_CMD_MAC_W8:
1784 case HALMAC_PARAMETER_CMD_MAC_W16:
1785 case HALMAC_PARAMETER_CMD_MAC_W32:
1786 PHY_PARAMETER_INFO_SET_IO_ADDR(pCurr_buf_w, para_info->content.MAC_REG_W.offset);
1787 PHY_PARAMETER_INFO_SET_DATA(pCurr_buf_w, para_info->content.MAC_REG_W.value);
1788 PHY_PARAMETER_INFO_SET_MASK(pCurr_buf_w, para_info->content.MAC_REG_W.msk);
1789 PHY_PARAMETER_INFO_SET_MSK_EN(pCurr_buf_w, para_info->content.MAC_REG_W.msk_en);
1790 break;
1791 case HALMAC_PARAMETER_CMD_RF_W:
1792 PHY_PARAMETER_INFO_SET_RF_ADDR(pCurr_buf_w, para_info->content.RF_REG_W.offset); /* In rf register, the address is only 1 byte */
1793 PHY_PARAMETER_INFO_SET_RF_PATH(pCurr_buf_w, para_info->content.RF_REG_W.rf_path);
1794 PHY_PARAMETER_INFO_SET_DATA(pCurr_buf_w, para_info->content.RF_REG_W.value);
1795 PHY_PARAMETER_INFO_SET_MASK(pCurr_buf_w, para_info->content.RF_REG_W.msk);
1796 PHY_PARAMETER_INFO_SET_MSK_EN(pCurr_buf_w, para_info->content.MAC_REG_W.msk_en);
1797 break;
1798 case HALMAC_PARAMETER_CMD_DELAY_US:
1799 case HALMAC_PARAMETER_CMD_DELAY_MS:
1800 PHY_PARAMETER_INFO_SET_DELAY_VALUE(pCurr_buf_w, para_info->content.DELAY_TIME.delay_time);
1801 break;
1802
1803 case HALMAC_PARAMETER_CMD_END:
1804 /* PHY_PARAMETER_INFO_SET_MSK_EN(pHalmac_adapter->pPara_buf_w, 1); */
1805 drv_trigger_send = _TRUE;
1806 break;
1807 default:
1808 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "illegal cmd_id!!\n");
1809 /* return _FALSE; */
1810 break;
1811 }
1812
1813 /*Update parameter buffer variable*/
1814 if (HALMAC_PARAMETER_CMD_END != para_info->cmd_id) {
1815 pConfig_para_info->para_num++;
1816 pConfig_para_info->pPara_buf_w += HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1817 pConfig_para_info->avai_para_buf_size = pConfig_para_info->avai_para_buf_size - HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1818 }
1819
1820 if (((pConfig_para_info->avai_para_buf_size - pHalmac_adapter->hw_config_info.txdesc_size) > HALMAC_FW_OFFLOAD_CMD_SIZE_88XX) && (_FALSE == drv_trigger_send)) {
1821 /*There are still space for parameter cmd, and driver does not trigger it to send, so keep it in buffer temporarily*/
1822 return HALMAC_RET_SUCCESS_ENQUEUE;
1823 } else {
1824 /*There is no space or driver trigger it to send*/
1825
1826 /*Update the bcn head(dma)*/
1827 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->h2c_extra_info_boundary & BIT_MASK_BCN_HEAD_1_V1));
1828
1829 /* Download to reserved page */
1830 info_size = pConfig_para_info->para_num * HALMAC_FW_OFFLOAD_CMD_SIZE_88XX;
1831 status = halmac_download_rsvd_page_88xx(pHalmac_adapter, (u8 *)pConfig_para_info->pCfg_para_buf, info_size);
1832 if (HALMAC_RET_SUCCESS != status) {
1833 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_download_rsvd_page_88xx Fail!!\n");
1834 } else {/*download rsvd page ok, send h2c packet to fw*/
1835 /* Construct H2C Content */
1836 UPDATE_DATAPACK_SET_SIZE(pH2c_buff, pConfig_para_info->para_num * HALMAC_FW_OFFLOAD_CMD_SIZE_88XX);
1837 UPDATE_DATAPACK_SET_DATAPACK_ID(pH2c_buff, pConfig_para_info->data_type);
1838 UPDATE_DATAPACK_SET_DATAPACK_LOC(pH2c_buff, pHalmac_adapter->h2c_extra_info_boundary - pHalmac_adapter->Tx_boundary);
1839 UPDATE_DATAPACK_SET_DATAPACK_SEGMENT(pH2c_buff, pConfig_para_info->datapack_segment);
1840 UPDATE_DATAPACK_SET_END_SEGMENT(pH2c_buff, drv_trigger_send);
1841
1842 /* Fill in H2C Header */
1843 h2c_header_info.sub_cmd_id = SUB_CMD_ID_UPDATE_DATAPACK;
1844 h2c_header_info.content_size = 8;
1845 h2c_header_info.ack = _TRUE;
1846 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1847
1848 /* Send H2C Cmd Packet */
1849 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1850 if (HALMAC_RET_SUCCESS != status)
1851 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail!!\n");
1852 }
1853
1854 PLATFORM_RTL_FREE(pDriver_adapter, pConfig_para_info->pCfg_para_buf, pConfig_para_info->para_buf_size);
1855 if (_TRUE == drv_trigger_send)
1856 pConfig_para_info->datapack_segment = 0;
1857 else
1858 pConfig_para_info->datapack_segment++;
1859
1860 pConfig_para_info->pCfg_para_buf = NULL;
1861 pConfig_para_info->pPara_buf_w = NULL;
1862 pConfig_para_info->para_num = 0;
1863 pConfig_para_info->avai_para_buf_size = 0;
1864
1865 /*Restore Register after FW handle the H2C packet*/
1866
1867 /*only set bcn head back*/
1868 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->Tx_boundary & BIT_MASK_BCN_HEAD_1_V1));
1869 }
1870
1871 return status;
1872 }
1873 #endif
1874 HALMAC_RET_STATUS
halmac_send_h2c_run_datapack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_DATA_TYPE halmac_data_type)1875 halmac_send_h2c_run_datapack_88xx(
1876 IN PHALMAC_ADAPTER pHalmac_adapter,
1877 IN HALMAC_DATA_TYPE halmac_data_type
1878 )
1879 {
1880 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1881 u16 h2c_seq_mum = 0;
1882 VOID *pDriver_adapter = NULL;
1883 HALMAC_H2C_HEADER_INFO h2c_header_info;
1884 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1885
1886 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1887
1888 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_run_datapack_88xx!!\n");
1889
1890 RUN_DATAPACK_SET_DATAPACK_ID(pH2c_buff, halmac_data_type);
1891
1892 h2c_header_info.sub_cmd_id = SUB_CMD_ID_RUN_DATAPACK;
1893 h2c_header_info.content_size = 4;
1894 h2c_header_info.ack = _TRUE;
1895 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1896
1897 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
1898
1899 if (HALMAC_RET_SUCCESS != status) {
1900 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
1901 return status;
1902 }
1903
1904 return HALMAC_RET_SUCCESS;
1905 }
1906
1907 HALMAC_RET_STATUS
halmac_send_bt_coex_cmd_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pBt_buf,IN u32 bt_size,IN u8 ack)1908 halmac_send_bt_coex_cmd_88xx(
1909 IN PHALMAC_ADAPTER pHalmac_adapter,
1910 IN u8 *pBt_buf,
1911 IN u32 bt_size,
1912 IN u8 ack
1913 )
1914 {
1915 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1916 u16 h2c_seq_mum = 0;
1917 VOID *pDriver_adapter = NULL;
1918 HALMAC_H2C_HEADER_INFO h2c_header_info;
1919 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1920
1921 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1922
1923 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_bt_coex_cmd_88xx!!\n");
1924
1925 PLATFORM_RTL_MEMCPY(pDriver_adapter, pH2c_buff + 8, pBt_buf, bt_size);
1926
1927 h2c_header_info.sub_cmd_id = SUB_CMD_ID_BT_COEX;
1928 h2c_header_info.content_size = (u16)bt_size;
1929 h2c_header_info.ack = ack;
1930 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1931
1932 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, ack);
1933
1934 if (HALMAC_RET_SUCCESS != status) {
1935 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
1936 return status;
1937 }
1938
1939 return HALMAC_RET_SUCCESS;
1940 }
1941
1942
1943 HALMAC_RET_STATUS
halmac_func_ctrl_ch_switch_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_CH_SWITCH_OPTION pCs_option)1944 halmac_func_ctrl_ch_switch_88xx(
1945 IN PHALMAC_ADAPTER pHalmac_adapter,
1946 IN PHALMAC_CH_SWITCH_OPTION pCs_option
1947 )
1948 {
1949 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
1950 u16 h2c_seq_mum = 0;
1951 VOID *pDriver_adapter = NULL;
1952 PHALMAC_API pHalmac_api;
1953 HALMAC_H2C_HEADER_INFO h2c_header_info;
1954 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
1955 HALMAC_CMD_PROCESS_STATUS *pProcess_status = &(pHalmac_adapter->halmac_state.scan_state_set.process_status);
1956
1957 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_ctrl_ch_switch!!\n");
1958
1959 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
1960 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
1961
1962 if (HALMAC_RET_SUCCESS != halmac_transition_scan_state_88xx(pHalmac_adapter, HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT))
1963 return HALMAC_RET_ERROR_STATE;
1964
1965 *pProcess_status = HALMAC_CMD_PROCESS_SENDING;
1966
1967 if (0 != pCs_option->switch_en) {
1968 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1969
1970 status = halmac_download_rsvd_page_88xx(pHalmac_adapter, pHalmac_adapter->ch_sw_info.ch_info_buf, pHalmac_adapter->ch_sw_info.total_size);
1971
1972 if (HALMAC_RET_SUCCESS != status) {
1973 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_download_rsvd_page_88xx Fail = %x!!\n", status);
1974 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1975 return status;
1976 }
1977
1978 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_FIFOPAGE_CTRL_2, (u16)(pHalmac_adapter->txff_allocation.rsvd_pg_bndy & BIT_MASK_BCN_HEAD_1_V1));
1979 }
1980
1981 CHANNEL_SWITCH_SET_SWITCH_START(pH2c_buff, pCs_option->switch_en);
1982 CHANNEL_SWITCH_SET_CHANNEL_NUM(pH2c_buff, pHalmac_adapter->ch_sw_info.ch_num);
1983 CHANNEL_SWITCH_SET_CHANNEL_INFO_LOC(pH2c_buff, pHalmac_adapter->txff_allocation.rsvd_h2c_extra_info_pg_bndy - pHalmac_adapter->txff_allocation.rsvd_pg_bndy);
1984 CHANNEL_SWITCH_SET_DEST_CH_EN(pH2c_buff, pCs_option->dest_ch_en);
1985 CHANNEL_SWITCH_SET_DEST_CH(pH2c_buff, pCs_option->dest_ch);
1986 CHANNEL_SWITCH_SET_PRI_CH_IDX(pH2c_buff, pCs_option->dest_pri_ch_idx);
1987 CHANNEL_SWITCH_SET_ABSOLUTE_TIME(pH2c_buff, pCs_option->absolute_time_en);
1988 CHANNEL_SWITCH_SET_TSF_LOW(pH2c_buff, pCs_option->tsf_low);
1989 CHANNEL_SWITCH_SET_PERIODIC_OPTION(pH2c_buff, pCs_option->periodic_option);
1990 CHANNEL_SWITCH_SET_NORMAL_CYCLE(pH2c_buff, pCs_option->normal_cycle);
1991 CHANNEL_SWITCH_SET_NORMAL_PERIOD(pH2c_buff, pCs_option->normal_period);
1992 CHANNEL_SWITCH_SET_SLOW_PERIOD(pH2c_buff, pCs_option->phase_2_period);
1993 CHANNEL_SWITCH_SET_CHANNEL_INFO_SIZE(pH2c_buff, pHalmac_adapter->ch_sw_info.total_size);
1994
1995 h2c_header_info.sub_cmd_id = SUB_CMD_ID_CHANNEL_SWITCH;
1996 h2c_header_info.content_size = 20;
1997 h2c_header_info.ack = _TRUE;
1998 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
1999 pHalmac_adapter->halmac_state.scan_state_set.seq_num = h2c_seq_mum;
2000
2001 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
2002
2003 if (HALMAC_RET_SUCCESS != status)
2004 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
2005
2006 PLATFORM_RTL_FREE(pDriver_adapter, pHalmac_adapter->ch_sw_info.ch_info_buf, pHalmac_adapter->ch_sw_info.buf_size);
2007 pHalmac_adapter->ch_sw_info.ch_info_buf = NULL;
2008 pHalmac_adapter->ch_sw_info.ch_info_buf_w = NULL;
2009 pHalmac_adapter->ch_sw_info.extra_info_en = 0;
2010 pHalmac_adapter->ch_sw_info.buf_size = 0;
2011 pHalmac_adapter->ch_sw_info.avai_buf_size = 0;
2012 pHalmac_adapter->ch_sw_info.total_size = 0;
2013 pHalmac_adapter->ch_sw_info.ch_num = 0;
2014
2015 if (HALMAC_RET_SUCCESS != halmac_transition_scan_state_88xx(pHalmac_adapter, HALMAC_SCAN_CMD_CONSTRUCT_IDLE))
2016 return HALMAC_RET_ERROR_STATE;
2017
2018 return status;
2019 }
2020
2021 HALMAC_RET_STATUS
halmac_func_send_general_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_GENERAL_INFO pGeneral_info)2022 halmac_func_send_general_info_88xx(
2023 IN PHALMAC_ADAPTER pHalmac_adapter,
2024 IN PHALMAC_GENERAL_INFO pGeneral_info
2025 )
2026 {
2027 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
2028 u16 h2c_seq_mum = 0;
2029 VOID *pDriver_adapter = NULL;
2030 HALMAC_H2C_HEADER_INFO h2c_header_info;
2031 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2032
2033 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2034
2035 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_general_info!!\n");
2036
2037 GENERAL_INFO_SET_REF_TYPE(pH2c_buff, pGeneral_info->rfe_type);
2038 GENERAL_INFO_SET_RF_TYPE(pH2c_buff, pGeneral_info->rf_type);
2039 GENERAL_INFO_SET_FW_TX_BOUNDARY(pH2c_buff, pHalmac_adapter->txff_allocation.rsvd_fw_txbuff_pg_bndy - pHalmac_adapter->txff_allocation.rsvd_pg_bndy);
2040
2041 h2c_header_info.sub_cmd_id = SUB_CMD_ID_GENERAL_INFO;
2042 h2c_header_info.content_size = 4;
2043 h2c_header_info.ack = _FALSE;
2044 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
2045
2046 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
2047
2048 if (HALMAC_RET_SUCCESS != status)
2049 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
2050
2051 return status;
2052 }
2053
2054 HALMAC_RET_STATUS
halmac_send_h2c_update_bcn_parse_info_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_BCN_IE_INFO pBcn_ie_info)2055 halmac_send_h2c_update_bcn_parse_info_88xx(
2056 IN PHALMAC_ADAPTER pHalmac_adapter,
2057 IN PHALMAC_BCN_IE_INFO pBcn_ie_info
2058 )
2059 {
2060 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
2061 u16 h2c_seq_mum = 0;
2062 VOID *pDriver_adapter = NULL;
2063 HALMAC_H2C_HEADER_INFO h2c_header_info;
2064 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2065
2066 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_update_bcn_parse_info_88xx!!\n");
2067
2068 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2069
2070 UPDATE_BEACON_PARSING_INFO_SET_FUNC_EN(pH2c_buff, pBcn_ie_info->func_en);
2071 UPDATE_BEACON_PARSING_INFO_SET_SIZE_TH(pH2c_buff, pBcn_ie_info->size_th);
2072 UPDATE_BEACON_PARSING_INFO_SET_TIMEOUT(pH2c_buff, pBcn_ie_info->timeout);
2073
2074 UPDATE_BEACON_PARSING_INFO_SET_IE_ID_BMP_0(pH2c_buff, (u32)(pBcn_ie_info->ie_bmp[0]));
2075 UPDATE_BEACON_PARSING_INFO_SET_IE_ID_BMP_1(pH2c_buff, (u32)(pBcn_ie_info->ie_bmp[1]));
2076 UPDATE_BEACON_PARSING_INFO_SET_IE_ID_BMP_2(pH2c_buff, (u32)(pBcn_ie_info->ie_bmp[2]));
2077 UPDATE_BEACON_PARSING_INFO_SET_IE_ID_BMP_3(pH2c_buff, (u32)(pBcn_ie_info->ie_bmp[3]));
2078 UPDATE_BEACON_PARSING_INFO_SET_IE_ID_BMP_4(pH2c_buff, (u32)(pBcn_ie_info->ie_bmp[4]));
2079
2080 h2c_header_info.sub_cmd_id = SUB_CMD_ID_UPDATE_BEACON_PARSING_INFO;
2081 h2c_header_info.content_size = 24;
2082 h2c_header_info.ack = _TRUE;
2083 halmac_set_fw_offload_h2c_header_88xx(pHalmac_adapter, pH2c_buff, &h2c_header_info, &h2c_seq_mum);
2084
2085 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _TRUE);
2086
2087 if (HALMAC_RET_SUCCESS != status) {
2088 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail =%x !!\n", status);
2089 return status;
2090 }
2091
2092 return status;
2093 }
2094
2095 HALMAC_RET_STATUS
halmac_send_h2c_ps_tuning_para_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2096 halmac_send_h2c_ps_tuning_para_88xx(
2097 IN PHALMAC_ADAPTER pHalmac_adapter
2098 )
2099 {
2100 u8 pH2c_buff[HALMAC_H2C_CMD_SIZE_88XX] = { 0 };
2101 u8 *pH2c_header, *pH2c_cmd;
2102 u16 seq = 0;
2103 VOID *pDriver_adapter = NULL;
2104 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2105
2106 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2107
2108 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_send_h2c_ps_tuning_para_88xx!!\n");
2109
2110 pH2c_header = pH2c_buff;
2111 pH2c_cmd = pH2c_header + HALMAC_H2C_CMD_HDR_SIZE_88XX;
2112
2113 halmac_set_h2c_header_88xx(pHalmac_adapter, pH2c_header, &seq, _FALSE);
2114
2115 status = halmac_send_h2c_pkt_88xx(pHalmac_adapter, pH2c_buff, HALMAC_H2C_CMD_SIZE_88XX, _FALSE);
2116
2117 if (HALMAC_RET_SUCCESS != status) {
2118 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "halmac_send_h2c_pkt_88xx Fail = %x!!\n", status);
2119 return status;
2120 }
2121
2122 return status;
2123 }
2124
2125 HALMAC_RET_STATUS
halmac_parse_c2h_packet_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * halmac_buf,IN u32 halmac_size)2126 halmac_parse_c2h_packet_88xx(
2127 IN PHALMAC_ADAPTER pHalmac_adapter,
2128 IN u8 *halmac_buf,
2129 IN u32 halmac_size
2130 )
2131 {
2132 u8 c2h_cmd, c2h_sub_cmd_id;
2133 u8 *pC2h_buf = halmac_buf + pHalmac_adapter->hw_config_info.rxdesc_size;
2134 u32 c2h_size = halmac_size - pHalmac_adapter->hw_config_info.rxdesc_size;
2135 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2136 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2137
2138 /* PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "halmac_parse_c2h_packet_88xx!!\n"); */
2139
2140 c2h_cmd = (u8)C2H_HDR_GET_CMD_ID(pC2h_buf);
2141
2142 /* FW offload C2H cmd is 0xFF */
2143 if (0xFF != c2h_cmd) {
2144 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "C2H_PKT not for FwOffloadC2HFormat!!\n");
2145 return HALMAC_RET_C2H_NOT_HANDLED;
2146 }
2147
2148 /* Get C2H sub cmd ID */
2149 c2h_sub_cmd_id = (u8)C2H_HDR_GET_C2H_SUB_CMD_ID(pC2h_buf);
2150
2151 switch (c2h_sub_cmd_id) {
2152 case C2H_SUB_CMD_ID_C2H_DBG:
2153 status = halmac_parse_c2h_debug_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2154 break;
2155 case C2H_SUB_CMD_ID_H2C_ACK_HDR:
2156 status = halmac_parse_h2c_ack_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2157 break;
2158 case C2H_SUB_CMD_ID_BT_COEX_INFO:
2159 status = HALMAC_RET_C2H_NOT_HANDLED;
2160 break;
2161 case C2H_SUB_CMD_ID_SCAN_STATUS_RPT:
2162 status = halmac_parse_scan_status_rpt_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2163 break;
2164 case C2H_SUB_CMD_ID_PSD_DATA:
2165 status = halmac_parse_psd_data_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2166 break;
2167
2168 case C2H_SUB_CMD_ID_EFUSE_DATA:
2169 status = halmac_parse_efuse_data_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2170 break;
2171 default:
2172 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "c2h_sub_cmd_id switch case out of boundary!!\n");
2173 status = HALMAC_RET_C2H_NOT_HANDLED;
2174 break;
2175 }
2176
2177 return status;
2178 }
2179
2180 HALMAC_RET_STATUS
halmac_parse_c2h_debug_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2181 halmac_parse_c2h_debug_88xx(
2182 IN PHALMAC_ADAPTER pHalmac_adapter,
2183 IN u8 *pC2h_buf,
2184 IN u32 c2h_size
2185 )
2186 {
2187 VOID *pDriver_adapter = NULL;
2188 u8 *pC2h_buf_local = (u8 *)NULL;
2189 u32 c2h_size_local = 0;
2190 u8 dbg_content_length = 0;
2191 u8 dbg_seq_num = 0;
2192
2193 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2194 pC2h_buf_local = pC2h_buf;
2195 c2h_size_local = c2h_size;
2196
2197 dbg_content_length = (u8)C2H_HDR_GET_LEN((u8 *)pC2h_buf_local);
2198
2199 if (dbg_content_length > C2H_DBG_CONTENT_MAX_LENGTH) {
2200 return HALMAC_RET_SUCCESS;
2201 } else {
2202 *(pC2h_buf_local + C2H_DBG_HEADER_LENGTH + dbg_content_length - 2) = '\n';
2203 dbg_seq_num = (u8)(*(pC2h_buf_local + C2H_DBG_HEADER_LENGTH));
2204 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "[RTKFW, SEQ=%d]: %s", dbg_seq_num, (char *)(pC2h_buf_local + C2H_DBG_HEADER_LENGTH + 1));
2205 }
2206
2207 return HALMAC_RET_SUCCESS;
2208 }
2209
2210
2211 HALMAC_RET_STATUS
halmac_parse_scan_status_rpt_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2212 halmac_parse_scan_status_rpt_88xx(
2213 IN PHALMAC_ADAPTER pHalmac_adapter,
2214 IN u8 *pC2h_buf,
2215 IN u32 c2h_size
2216 )
2217 {
2218 u8 h2c_return_code;
2219 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2220 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2221
2222 h2c_return_code = (u8)SCAN_STATUS_RPT_GET_H2C_RETURN_CODE(pC2h_buf);
2223 process_status = (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) ? HALMAC_CMD_PROCESS_DONE : HALMAC_CMD_PROCESS_ERROR;
2224
2225 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_CHANNEL_SWITCH, process_status, NULL, 0);
2226
2227 pHalmac_adapter->halmac_state.scan_state_set.process_status = process_status;
2228
2229 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "scan status : %X\n", process_status);
2230
2231 return HALMAC_RET_SUCCESS;
2232 }
2233
2234
2235 HALMAC_RET_STATUS
halmac_parse_psd_data_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2236 halmac_parse_psd_data_88xx(
2237 IN PHALMAC_ADAPTER pHalmac_adapter,
2238 IN u8 *pC2h_buf,
2239 IN u32 c2h_size
2240 )
2241 {
2242 u8 segment_id = 0, segment_size = 0, h2c_seq = 0;
2243 u16 total_size;
2244 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2245 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2246 PHALMAC_PSD_STATE_SET pPsd_set = &(pHalmac_adapter->halmac_state.psd_set);
2247
2248 h2c_seq = (u8)PSD_DATA_GET_H2C_SEQ(pC2h_buf);
2249 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pPsd_set->seq_num, h2c_seq);
2250 if (h2c_seq != pPsd_set->seq_num) {
2251 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pPsd_set->seq_num, h2c_seq);
2252 return HALMAC_RET_SUCCESS;
2253 }
2254
2255 if (HALMAC_CMD_PROCESS_SENDING != pPsd_set->process_status) {
2256 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2257 return HALMAC_RET_SUCCESS;
2258 }
2259
2260 total_size = (u16)PSD_DATA_GET_TOTAL_SIZE(pC2h_buf);
2261 segment_id = (u8)PSD_DATA_GET_SEGMENT_ID(pC2h_buf);
2262 segment_size = (u8)PSD_DATA_GET_SEGMENT_SIZE(pC2h_buf);
2263 pPsd_set->data_size = total_size;
2264
2265 if (NULL == pPsd_set->pData)
2266 pPsd_set->pData = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, pPsd_set->data_size);
2267
2268 if (0 == segment_id)
2269 pPsd_set->segment_size = segment_size;
2270
2271 PLATFORM_RTL_MEMCPY(pDriver_adapter, pPsd_set->pData + segment_id * pPsd_set->segment_size, pC2h_buf + HALMAC_C2H_DATA_OFFSET_88XX, segment_size);
2272
2273 if (_FALSE == PSD_DATA_GET_END_SEGMENT(pC2h_buf))
2274 return HALMAC_RET_SUCCESS;
2275
2276 process_status = HALMAC_CMD_PROCESS_DONE;
2277 pPsd_set->process_status = process_status;
2278
2279 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_PSD, process_status, pPsd_set->pData, pPsd_set->data_size);
2280
2281 return HALMAC_RET_SUCCESS;
2282 }
2283
2284 HALMAC_RET_STATUS
halmac_parse_efuse_data_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2285 halmac_parse_efuse_data_88xx(
2286 IN PHALMAC_ADAPTER pHalmac_adapter,
2287 IN u8 *pC2h_buf,
2288 IN u32 c2h_size
2289 )
2290 {
2291 u8 segment_id = 0, segment_size = 0, h2c_seq = 0;
2292 u8 *pEeprom_map = NULL;
2293 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
2294 u8 h2c_return_code = 0;
2295 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2296 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2297
2298 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
2299 if (NULL == pEeprom_map) {
2300 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
2301 return HALMAC_RET_MALLOC_FAIL;
2302 }
2303 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
2304
2305 h2c_seq = (u8)EFUSE_DATA_GET_H2C_SEQ(pC2h_buf);
2306 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.efuse_state_set.seq_num, h2c_seq);
2307 if (h2c_seq != pHalmac_adapter->halmac_state.efuse_state_set.seq_num) {
2308 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.efuse_state_set.seq_num, h2c_seq);
2309 return HALMAC_RET_SUCCESS;
2310 }
2311
2312 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.efuse_state_set.process_status) {
2313 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2314 return HALMAC_RET_SUCCESS;
2315 }
2316
2317 pHalmac_adapter->halmac_state.efuse_state_set.fw_return_code = h2c_return_code;
2318 segment_id = (u8)EFUSE_DATA_GET_SEGMENT_ID(pC2h_buf);
2319 segment_size = (u8)EFUSE_DATA_GET_SEGMENT_SIZE(pC2h_buf);
2320 if (0 == segment_id)
2321 pHalmac_adapter->efuse_segment_size = segment_size;
2322
2323 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
2324 PLATFORM_RTL_MEMCPY(pDriver_adapter, pHalmac_adapter->pHalEfuse_map + segment_id * pHalmac_adapter->efuse_segment_size, \
2325 pC2h_buf + HALMAC_C2H_DATA_OFFSET_88XX, segment_size);
2326 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
2327
2328 if (_FALSE == EFUSE_DATA_GET_END_SEGMENT(pC2h_buf))
2329 return HALMAC_RET_SUCCESS;
2330
2331 if (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) {
2332 process_status = HALMAC_CMD_PROCESS_DONE;
2333 pHalmac_adapter->halmac_state.efuse_state_set.process_status = process_status;
2334
2335 PLATFORM_MUTEX_LOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
2336 pHalmac_adapter->hal_efuse_map_valid = _TRUE;
2337 PLATFORM_MUTEX_UNLOCK(pDriver_adapter, &(pHalmac_adapter->EfuseMutex));
2338
2339 if (1 == pHalmac_adapter->event_trigger.physical_efuse_map) {
2340 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE, process_status, pHalmac_adapter->pHalEfuse_map, pHalmac_adapter->hw_config_info.efuse_size);
2341 pHalmac_adapter->event_trigger.physical_efuse_map = 0;
2342 }
2343
2344 if (1 == pHalmac_adapter->event_trigger.logical_efuse_map) {
2345 if (HALMAC_RET_SUCCESS != halmac_eeprom_parser_88xx(pHalmac_adapter, pHalmac_adapter->pHalEfuse_map, pEeprom_map))
2346 return HALMAC_RET_EEPROM_PARSING_FAIL;
2347 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_LOGICAL_EFUSE, process_status, pEeprom_map, eeprom_size);
2348 pHalmac_adapter->event_trigger.logical_efuse_map = 0;
2349 }
2350 } else {
2351 process_status = HALMAC_CMD_PROCESS_ERROR;
2352 pHalmac_adapter->halmac_state.efuse_state_set.process_status = process_status;
2353
2354 if (1 == pHalmac_adapter->event_trigger.physical_efuse_map) {
2355 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_PHYSICAL_EFUSE, process_status, &(pHalmac_adapter->halmac_state.efuse_state_set.fw_return_code), 1);
2356 pHalmac_adapter->event_trigger.physical_efuse_map = 0;
2357 }
2358
2359 if (1 == pHalmac_adapter->event_trigger.logical_efuse_map) {
2360 if (HALMAC_RET_SUCCESS != halmac_eeprom_parser_88xx(pHalmac_adapter, pHalmac_adapter->pHalEfuse_map, pEeprom_map))
2361 return HALMAC_RET_EEPROM_PARSING_FAIL;
2362 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_DUMP_LOGICAL_EFUSE, process_status, &(pHalmac_adapter->halmac_state.efuse_state_set.fw_return_code), 1);
2363 pHalmac_adapter->event_trigger.logical_efuse_map = 0;
2364 }
2365 }
2366
2367 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
2368
2369 return HALMAC_RET_SUCCESS;
2370 }
2371
2372 HALMAC_RET_STATUS
halmac_parse_h2c_ack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2373 halmac_parse_h2c_ack_88xx(
2374 IN PHALMAC_ADAPTER pHalmac_adapter,
2375 IN u8 *pC2h_buf,
2376 IN u32 c2h_size
2377 )
2378 {
2379 u8 h2c_cmd_id, h2c_sub_cmd_id;
2380 u8 h2c_seq = 0, offset = 0, shift = 0;
2381 u8 h2c_return_code;
2382 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2383 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2384 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
2385
2386
2387 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Ack for C2H!!\n");
2388
2389 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2390 if (HALMAC_H2C_RETURN_SUCCESS != (HALMAC_H2C_RETURN_CODE)h2c_return_code)
2391 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "C2H_PKT Status Error!! Status = %d\n", h2c_return_code);
2392
2393 h2c_cmd_id = (u8)H2C_ACK_HDR_GET_H2C_CMD_ID(pC2h_buf);
2394
2395 if (0xFF != h2c_cmd_id) {
2396 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "original h2c ack is not handled!!\n");
2397 status = HALMAC_RET_C2H_NOT_HANDLED;
2398 } else {
2399 h2c_sub_cmd_id = (u8)H2C_ACK_HDR_GET_H2C_SUB_CMD_ID(pC2h_buf);
2400
2401 switch (h2c_sub_cmd_id) {
2402 case H2C_SUB_CMD_ID_DUMP_PHYSICAL_EFUSE_ACK:
2403 break;
2404 case H2C_SUB_CMD_ID_CFG_PARAMETER_ACK:
2405 status = halmac_parse_h2c_ack_cfg_para_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2406 break;
2407 case H2C_SUB_CMD_ID_UPDATE_PACKET_ACK:
2408 status = halmac_parse_h2c_ack_update_packet_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2409 break;
2410 case H2C_SUB_CMD_ID_UPDATE_DATAPACK_ACK:
2411 status = halmac_parse_h2c_ack_update_datapack_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2412 break;
2413 case H2C_SUB_CMD_ID_RUN_DATAPACK_ACK:
2414 status = halmac_parse_h2c_ack_run_datapack_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2415 break;
2416 case H2C_SUB_CMD_ID_CHANNEL_SWITCH_ACK:
2417 status = halmac_parse_h2c_ack_channel_switch_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2418 break;
2419 case H2C_SUB_CMD_ID_IQK_ACK:
2420 status = halmac_parse_h2c_ack_iqk_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2421 break;
2422 case H2C_SUB_CMD_ID_POWER_TRACKING_ACK:
2423 status = halmac_parse_h2c_ack_power_tracking_88xx(pHalmac_adapter, pC2h_buf, c2h_size);
2424 break;
2425 case H2C_SUB_CMD_ID_PSD_ACK:
2426 break;
2427 default:
2428 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "h2c_sub_cmd_id switch case out of boundary!!\n");
2429 status = HALMAC_RET_C2H_NOT_HANDLED;
2430 break;
2431 }
2432 }
2433
2434 return status;
2435 }
2436
2437 HALMAC_RET_STATUS
halmac_parse_h2c_ack_cfg_para_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2438 halmac_parse_h2c_ack_cfg_para_88xx(
2439 IN PHALMAC_ADAPTER pHalmac_adapter,
2440 IN u8 *pC2h_buf,
2441 IN u32 c2h_size
2442 )
2443 {
2444 u8 h2c_seq = 0;
2445 u8 h2c_return_code;
2446 u32 offset_accu = 0, value_accu = 0;
2447 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2448 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2449
2450 h2c_seq = (u8)H2C_ACK_HDR_GET_H2C_SEQ(pC2h_buf);
2451 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.cfg_para_state_set.seq_num, h2c_seq);
2452 if (h2c_seq != pHalmac_adapter->halmac_state.cfg_para_state_set.seq_num) {
2453 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.cfg_para_state_set.seq_num, h2c_seq);
2454 return HALMAC_RET_SUCCESS;
2455 }
2456
2457 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.cfg_para_state_set.process_status) {
2458 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2459 return HALMAC_RET_SUCCESS;
2460 }
2461
2462 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2463 pHalmac_adapter->halmac_state.cfg_para_state_set.fw_return_code = h2c_return_code;
2464 offset_accu = CFG_PARAMETER_ACK_GET_OFFSET_ACCUMULATION(pC2h_buf);
2465 value_accu = CFG_PARAMETER_ACK_GET_VALUE_ACCUMULATION(pC2h_buf);
2466
2467 if ((offset_accu != pHalmac_adapter->config_para_info.offset_accumulation) || (value_accu != pHalmac_adapter->config_para_info.value_accumulation)) {
2468 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "[C2H]offset_accu : %x, value_accu : %x!!\n", offset_accu, value_accu);
2469 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "[Adapter]offset_accu : %x, value_accu : %x!!\n", pHalmac_adapter->config_para_info.offset_accumulation, pHalmac_adapter->config_para_info.value_accumulation);
2470 process_status = HALMAC_CMD_PROCESS_ERROR;
2471 }
2472
2473 if ((HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) && (HALMAC_CMD_PROCESS_ERROR != process_status)) {
2474 process_status = HALMAC_CMD_PROCESS_DONE;
2475 pHalmac_adapter->halmac_state.cfg_para_state_set.process_status = process_status;
2476 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_CFG_PARA, process_status, NULL, 0);
2477 } else {
2478 process_status = HALMAC_CMD_PROCESS_ERROR;
2479 pHalmac_adapter->halmac_state.cfg_para_state_set.process_status = process_status;
2480 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_CFG_PARA, process_status, &(pHalmac_adapter->halmac_state.cfg_para_state_set.fw_return_code), 1);
2481 }
2482
2483 return HALMAC_RET_SUCCESS;
2484 }
2485
2486
2487 HALMAC_RET_STATUS
halmac_parse_h2c_ack_update_packet_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2488 halmac_parse_h2c_ack_update_packet_88xx(
2489 IN PHALMAC_ADAPTER pHalmac_adapter,
2490 IN u8 *pC2h_buf,
2491 IN u32 c2h_size
2492 )
2493 {
2494 u8 h2c_seq = 0;
2495 u8 h2c_return_code;
2496 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2497 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2498
2499 h2c_seq = (u8)H2C_ACK_HDR_GET_H2C_SEQ(pC2h_buf);
2500 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.update_packet_set.seq_num, h2c_seq);
2501 if (h2c_seq != pHalmac_adapter->halmac_state.update_packet_set.seq_num) {
2502 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.update_packet_set.seq_num, h2c_seq);
2503 return HALMAC_RET_SUCCESS;
2504 }
2505
2506 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.update_packet_set.process_status) {
2507 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2508 return HALMAC_RET_SUCCESS;
2509 }
2510
2511 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2512 pHalmac_adapter->halmac_state.update_packet_set.fw_return_code = h2c_return_code;
2513
2514 if (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) {
2515 process_status = HALMAC_CMD_PROCESS_DONE;
2516 pHalmac_adapter->halmac_state.update_packet_set.process_status = process_status;
2517 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_UPDATE_PACKET, process_status, NULL, 0);
2518 } else {
2519 process_status = HALMAC_CMD_PROCESS_ERROR;
2520 pHalmac_adapter->halmac_state.update_packet_set.process_status = process_status;
2521 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_UPDATE_PACKET, process_status, &(pHalmac_adapter->halmac_state.update_packet_set.fw_return_code), 1);
2522 }
2523
2524 return HALMAC_RET_SUCCESS;
2525 }
2526
2527 HALMAC_RET_STATUS
halmac_parse_h2c_ack_update_datapack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2528 halmac_parse_h2c_ack_update_datapack_88xx(
2529 IN PHALMAC_ADAPTER pHalmac_adapter,
2530 IN u8 *pC2h_buf,
2531 IN u32 c2h_size
2532 )
2533 {
2534 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2535 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2536
2537 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_UPDATE_DATAPACK, process_status, NULL, 0);
2538
2539 return HALMAC_RET_SUCCESS;
2540 }
2541
2542
2543 HALMAC_RET_STATUS
halmac_parse_h2c_ack_run_datapack_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2544 halmac_parse_h2c_ack_run_datapack_88xx(
2545 IN PHALMAC_ADAPTER pHalmac_adapter,
2546 IN u8 *pC2h_buf,
2547 IN u32 c2h_size
2548 )
2549 {
2550 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2551 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2552
2553 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_RUN_DATAPACK, process_status, NULL, 0);
2554
2555 return HALMAC_RET_SUCCESS;
2556 }
2557
2558
2559 HALMAC_RET_STATUS
halmac_parse_h2c_ack_channel_switch_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2560 halmac_parse_h2c_ack_channel_switch_88xx(
2561 IN PHALMAC_ADAPTER pHalmac_adapter,
2562 IN u8 *pC2h_buf,
2563 IN u32 c2h_size
2564 )
2565 {
2566 u8 h2c_seq = 0;
2567 u8 h2c_return_code;
2568 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2569 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2570
2571 h2c_seq = (u8)H2C_ACK_HDR_GET_H2C_SEQ(pC2h_buf);
2572 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.scan_state_set.seq_num, h2c_seq);
2573 if (h2c_seq != pHalmac_adapter->halmac_state.scan_state_set.seq_num) {
2574 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.scan_state_set.seq_num, h2c_seq);
2575 return HALMAC_RET_SUCCESS;
2576 }
2577
2578 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.scan_state_set.process_status) {
2579 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2580 return HALMAC_RET_SUCCESS;
2581 }
2582
2583 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2584 pHalmac_adapter->halmac_state.scan_state_set.fw_return_code = h2c_return_code;
2585
2586 if (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) {
2587 process_status = HALMAC_CMD_PROCESS_RCVD;
2588 pHalmac_adapter->halmac_state.scan_state_set.process_status = process_status;
2589 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_CHANNEL_SWITCH, process_status, NULL, 0);
2590 } else {
2591 process_status = HALMAC_CMD_PROCESS_ERROR;
2592 pHalmac_adapter->halmac_state.scan_state_set.process_status = process_status;
2593 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_CHANNEL_SWITCH, process_status, &(pHalmac_adapter->halmac_state.scan_state_set.fw_return_code), 1);
2594 }
2595
2596 return HALMAC_RET_SUCCESS;
2597 }
2598
2599 HALMAC_RET_STATUS
halmac_parse_h2c_ack_iqk_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2600 halmac_parse_h2c_ack_iqk_88xx(
2601 IN PHALMAC_ADAPTER pHalmac_adapter,
2602 IN u8 *pC2h_buf,
2603 IN u32 c2h_size
2604 )
2605 {
2606 u8 h2c_seq = 0;
2607 u8 h2c_return_code;
2608 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2609 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2610
2611 h2c_seq = (u8)H2C_ACK_HDR_GET_H2C_SEQ(pC2h_buf);
2612 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.iqk_set.seq_num, h2c_seq);
2613 if (h2c_seq != pHalmac_adapter->halmac_state.iqk_set.seq_num) {
2614 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.iqk_set.seq_num, h2c_seq);
2615 return HALMAC_RET_SUCCESS;
2616 }
2617
2618 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.iqk_set.process_status) {
2619 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2620 return HALMAC_RET_SUCCESS;
2621 }
2622
2623 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2624 pHalmac_adapter->halmac_state.iqk_set.fw_return_code = h2c_return_code;
2625
2626 if (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) {
2627 process_status = HALMAC_CMD_PROCESS_DONE;
2628 pHalmac_adapter->halmac_state.iqk_set.process_status = process_status;
2629 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_IQK, process_status, NULL, 0);
2630 } else {
2631 process_status = HALMAC_CMD_PROCESS_ERROR;
2632 pHalmac_adapter->halmac_state.iqk_set.process_status = process_status;
2633 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_IQK, process_status, &(pHalmac_adapter->halmac_state.iqk_set.fw_return_code), 1);
2634 }
2635
2636 return HALMAC_RET_SUCCESS;
2637 }
2638
2639 HALMAC_RET_STATUS
halmac_parse_h2c_ack_power_tracking_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * pC2h_buf,IN u32 c2h_size)2640 halmac_parse_h2c_ack_power_tracking_88xx(
2641 IN PHALMAC_ADAPTER pHalmac_adapter,
2642 IN u8 *pC2h_buf,
2643 IN u32 c2h_size
2644 )
2645 {
2646 u8 h2c_seq = 0;
2647 u8 h2c_return_code;
2648 VOID *pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2649 HALMAC_CMD_PROCESS_STATUS process_status = HALMAC_CMD_PROCESS_UNDEFINE;
2650
2651 h2c_seq = (u8)H2C_ACK_HDR_GET_H2C_SEQ(pC2h_buf);
2652 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_TRACE, "Seq num : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.power_tracking_set.seq_num, h2c_seq);
2653 if (h2c_seq != pHalmac_adapter->halmac_state.power_tracking_set.seq_num) {
2654 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Seq num mismactch : h2c -> %d c2h -> %d\n", pHalmac_adapter->halmac_state.power_tracking_set.seq_num, h2c_seq);
2655 return HALMAC_RET_SUCCESS;
2656 }
2657
2658 if (HALMAC_CMD_PROCESS_SENDING != pHalmac_adapter->halmac_state.power_tracking_set.process_status) {
2659 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_H2C, HALMAC_DBG_ERR, "Not in HALMAC_CMD_PROCESS_SENDING\n");
2660 return HALMAC_RET_SUCCESS;
2661 }
2662
2663 h2c_return_code = (u8)H2C_ACK_HDR_GET_H2C_RETURN_CODE(pC2h_buf);
2664 pHalmac_adapter->halmac_state.power_tracking_set.fw_return_code = h2c_return_code;
2665
2666 if (HALMAC_H2C_RETURN_SUCCESS == (HALMAC_H2C_RETURN_CODE)h2c_return_code) {
2667 process_status = HALMAC_CMD_PROCESS_DONE;
2668 pHalmac_adapter->halmac_state.power_tracking_set.process_status = process_status;
2669 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_POWER_TRACKING, process_status, NULL, 0);
2670 } else {
2671 process_status = HALMAC_CMD_PROCESS_ERROR;
2672 pHalmac_adapter->halmac_state.power_tracking_set.process_status = process_status;
2673 PLATFORM_EVENT_INDICATION(pDriver_adapter, HALMAC_FEATURE_POWER_TRACKING, process_status, &(pHalmac_adapter->halmac_state.power_tracking_set.fw_return_code), 1);
2674 }
2675
2676 return HALMAC_RET_SUCCESS;
2677 }
2678
2679 HALMAC_RET_STATUS
halmac_convert_to_sdio_bus_offset_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,INOUT u32 * halmac_offset)2680 halmac_convert_to_sdio_bus_offset_88xx(
2681 IN PHALMAC_ADAPTER pHalmac_adapter,
2682 INOUT u32 *halmac_offset
2683 )
2684 {
2685 VOID *pDriver_adapter = NULL;
2686
2687 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2688
2689 switch ((*halmac_offset) & 0xFFFF0000) {
2690 case WLAN_IOREG_OFFSET:
2691 *halmac_offset = (WLAN_IOREG_DEVICE_ID << 13) | (*halmac_offset & HALMAC_WLAN_IOREG_MSK);
2692 break;
2693 case SDIO_LOCAL_OFFSET:
2694 *halmac_offset = (SDIO_LOCAL_DEVICE_ID << 13) | (*halmac_offset & HALMAC_SDIO_LOCAL_MSK);
2695 break;
2696 default:
2697 *halmac_offset = 0xFFFFFFFF;
2698 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Unknown base address!!\n");
2699 return HALMAC_RET_CONVERT_SDIO_OFFSET_FAIL;
2700 }
2701
2702 return HALMAC_RET_SUCCESS;
2703 }
2704
2705 HALMAC_RET_STATUS
halmac_update_sdio_free_page_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2706 halmac_update_sdio_free_page_88xx(
2707 IN PHALMAC_ADAPTER pHalmac_adapter
2708 )
2709 {
2710 u32 free_page = 0, free_page2 = 0, oqt_free_page = 0;
2711 VOID *pDriver_adapter = NULL;
2712 PHALMAC_API pHalmac_api;
2713 PHALMAC_SDIO_FREE_SPACE pSdio_free_space;
2714
2715 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2716 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2717
2718 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_update_sdio_free_page_88xx ==========>\n");
2719
2720 pSdio_free_space = &(pHalmac_adapter->sdio_free_space);
2721
2722 free_page = HALMAC_REG_READ_32(pHalmac_adapter, REG_SDIO_FREE_TXPG);
2723 free_page2 = HALMAC_REG_READ_32(pHalmac_adapter, REG_SDIO_FREE_TXPG2);
2724
2725 pSdio_free_space->high_queue_number = (u16)BIT_GET_HIQ_FREEPG_V1(free_page);
2726 pSdio_free_space->normal_queue_number = (u16)BIT_GET_MID_FREEPG_V1(free_page);
2727 pSdio_free_space->low_queue_number = (u16)BIT_GET_LOW_FREEPG_V1(free_page2);
2728 pSdio_free_space->public_queue_number = (u16)BIT_GET_PUB_FREEPG_V1(free_page2);
2729 pSdio_free_space->extra_queue_number = (u16)BIT_GET_EXQ_FREEPG_V1(oqt_free_page);
2730
2731 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_update_sdio_free_page_88xx <==========\n");
2732
2733 return HALMAC_RET_SUCCESS;
2734 }
2735
2736 HALMAC_RET_STATUS
halmac_update_oqt_free_space_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2737 halmac_update_oqt_free_space_88xx(
2738 IN PHALMAC_ADAPTER pHalmac_adapter
2739 )
2740 {
2741 VOID *pDriver_adapter = NULL;
2742 PHALMAC_API pHalmac_api;
2743 PHALMAC_SDIO_FREE_SPACE pSdio_free_space;
2744
2745 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2746 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
2747
2748 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_update_oqt_free_space_88xx ==========>\n");
2749
2750 pSdio_free_space = &(pHalmac_adapter->sdio_free_space);
2751
2752 pSdio_free_space->ac_oqt_number = HALMAC_REG_READ_8(pHalmac_adapter, REG_SDIO_OQT_FREE_TXPG_V1 + 2);
2753 /* pSdio_free_space->non_ac_oqt_number = (u8)BIT_GET_NOAC_OQT_FREEPG_V1(oqt_free_page); */
2754
2755 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_update_oqt_free_space_88xx <==========\n");
2756
2757 return HALMAC_RET_SUCCESS;
2758 }
2759
2760 HALMAC_EFUSE_CMD_CONSTRUCT_STATE
halmac_query_efuse_curr_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2761 halmac_query_efuse_curr_state_88xx(
2762 IN PHALMAC_ADAPTER pHalmac_adapter
2763 )
2764 {
2765 return pHalmac_adapter->halmac_state.efuse_state_set.efuse_cmd_construct_state;
2766 }
2767
2768 HALMAC_RET_STATUS
halmac_transition_efuse_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_EFUSE_CMD_CONSTRUCT_STATE dest_state)2769 halmac_transition_efuse_state_88xx(
2770 IN PHALMAC_ADAPTER pHalmac_adapter,
2771 IN HALMAC_EFUSE_CMD_CONSTRUCT_STATE dest_state
2772 )
2773 {
2774 PHALMAC_EFUSE_STATE_SET pEfuse_state = &(pHalmac_adapter->halmac_state.efuse_state_set);
2775
2776 if ((HALMAC_EFUSE_CMD_CONSTRUCT_IDLE != pEfuse_state->efuse_cmd_construct_state) \
2777 && (HALMAC_EFUSE_CMD_CONSTRUCT_BUSY != pEfuse_state->efuse_cmd_construct_state) \
2778 && (HALMAC_EFUSE_CMD_CONSTRUCT_H2C_SENT != pEfuse_state->efuse_cmd_construct_state))
2779 return HALMAC_RET_ERROR_STATE;
2780
2781 if (pEfuse_state->efuse_cmd_construct_state == dest_state)
2782 return HALMAC_RET_ERROR_STATE;
2783
2784 if (HALMAC_EFUSE_CMD_CONSTRUCT_BUSY == dest_state) {
2785 if (HALMAC_EFUSE_CMD_CONSTRUCT_H2C_SENT == pEfuse_state->efuse_cmd_construct_state)
2786 return HALMAC_RET_ERROR_STATE;
2787 } else if (HALMAC_EFUSE_CMD_CONSTRUCT_H2C_SENT == dest_state) {
2788 if (HALMAC_EFUSE_CMD_CONSTRUCT_IDLE == pEfuse_state->efuse_cmd_construct_state)
2789 return HALMAC_RET_ERROR_STATE;
2790 }
2791
2792 pEfuse_state->efuse_cmd_construct_state = dest_state;
2793
2794 return HALMAC_RET_SUCCESS;
2795 }
2796
2797 HALMAC_CFG_PARA_CMD_CONSTRUCT_STATE
halmac_query_cfg_para_curr_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2798 halmac_query_cfg_para_curr_state_88xx(
2799 IN PHALMAC_ADAPTER pHalmac_adapter
2800 )
2801 {
2802 return pHalmac_adapter->halmac_state.cfg_para_state_set.cfg_para_cmd_construct_state;
2803 }
2804
2805 HALMAC_RET_STATUS
halmac_transition_cfg_para_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_CFG_PARA_CMD_CONSTRUCT_STATE dest_state)2806 halmac_transition_cfg_para_state_88xx(
2807 IN PHALMAC_ADAPTER pHalmac_adapter,
2808 IN HALMAC_CFG_PARA_CMD_CONSTRUCT_STATE dest_state
2809 )
2810 {
2811 PHALMAC_CFG_PARA_STATE_SET pCfg_para = &(pHalmac_adapter->halmac_state.cfg_para_state_set);
2812
2813 if ((HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE != pCfg_para->cfg_para_cmd_construct_state) && \
2814 (HALMAC_CFG_PARA_CMD_CONSTRUCT_CONSTRUCTING != pCfg_para->cfg_para_cmd_construct_state) && \
2815 (HALMAC_CFG_PARA_CMD_CONSTRUCT_H2C_SENT != pCfg_para->cfg_para_cmd_construct_state))
2816 return HALMAC_RET_ERROR_STATE;
2817
2818 if (HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE == dest_state) {
2819 if (HALMAC_CFG_PARA_CMD_CONSTRUCT_CONSTRUCTING == pCfg_para->cfg_para_cmd_construct_state)
2820 return HALMAC_RET_ERROR_STATE;
2821 } else if (HALMAC_CFG_PARA_CMD_CONSTRUCT_CONSTRUCTING == dest_state) {
2822 if (HALMAC_CFG_PARA_CMD_CONSTRUCT_H2C_SENT == pCfg_para->cfg_para_cmd_construct_state)
2823 return HALMAC_RET_ERROR_STATE;
2824 } else if (HALMAC_CFG_PARA_CMD_CONSTRUCT_H2C_SENT == dest_state) {
2825 if ((HALMAC_CFG_PARA_CMD_CONSTRUCT_IDLE == pCfg_para->cfg_para_cmd_construct_state) \
2826 || (HALMAC_CFG_PARA_CMD_CONSTRUCT_H2C_SENT == pCfg_para->cfg_para_cmd_construct_state))
2827 return HALMAC_RET_ERROR_STATE;
2828 }
2829
2830 pCfg_para->cfg_para_cmd_construct_state = dest_state;
2831
2832 return HALMAC_RET_SUCCESS;
2833 }
2834
2835 HALMAC_SCAN_CMD_CONSTRUCT_STATE
halmac_query_scan_curr_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)2836 halmac_query_scan_curr_state_88xx(
2837 IN PHALMAC_ADAPTER pHalmac_adapter
2838 )
2839 {
2840 return pHalmac_adapter->halmac_state.scan_state_set.scan_cmd_construct_state;
2841 }
2842
2843 HALMAC_RET_STATUS
halmac_transition_scan_state_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_SCAN_CMD_CONSTRUCT_STATE dest_state)2844 halmac_transition_scan_state_88xx(
2845 IN PHALMAC_ADAPTER pHalmac_adapter,
2846 IN HALMAC_SCAN_CMD_CONSTRUCT_STATE dest_state
2847 )
2848 {
2849 PHALMAC_SCAN_STATE_SET pScan = &(pHalmac_adapter->halmac_state.scan_state_set);
2850
2851 if ((pScan->scan_cmd_construct_state > HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT) || (pScan->scan_cmd_construct_state < HALMAC_SCAN_CMD_CONSTRUCT_IDLE))
2852 return HALMAC_RET_ERROR_STATE;
2853
2854 if (HALMAC_SCAN_CMD_CONSTRUCT_IDLE == dest_state) {
2855 if ((HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED == pScan->scan_cmd_construct_state) ||
2856 (HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING == pScan->scan_cmd_construct_state))
2857 return HALMAC_RET_ERROR_STATE;
2858 } else if (HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED == dest_state) {
2859 if (HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT == pScan->scan_cmd_construct_state)
2860 return HALMAC_RET_ERROR_STATE;
2861 } else if (HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING == dest_state) {
2862 if ((HALMAC_SCAN_CMD_CONSTRUCT_IDLE == pScan->scan_cmd_construct_state) ||
2863 (HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT == pScan->scan_cmd_construct_state))
2864 return HALMAC_RET_ERROR_STATE;
2865 } else if (HALMAC_SCAN_CMD_CONSTRUCT_H2C_SENT == dest_state) {
2866 if ((HALMAC_SCAN_CMD_CONSTRUCT_CONSTRUCTING != pScan->scan_cmd_construct_state) &&
2867 (HALMAC_SCAN_CMD_CONSTRUCT_BUFFER_CLEARED != pScan->scan_cmd_construct_state))
2868 return HALMAC_RET_ERROR_STATE;
2869 }
2870
2871 pScan->scan_cmd_construct_state = dest_state;
2872
2873 return HALMAC_RET_SUCCESS;
2874 }
2875
2876 HALMAC_RET_STATUS
halmac_query_cfg_para_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)2877 halmac_query_cfg_para_status_88xx(
2878 IN PHALMAC_ADAPTER pHalmac_adapter,
2879 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
2880 INOUT u8 *data,
2881 INOUT u32 *size
2882 )
2883 {
2884 PHALMAC_CFG_PARA_STATE_SET pCfg_para_state_set = &(pHalmac_adapter->halmac_state.cfg_para_state_set);
2885
2886 *pProcess_status = pCfg_para_state_set->process_status;
2887
2888 return HALMAC_RET_SUCCESS;
2889 }
2890
2891 HALMAC_RET_STATUS
halmac_query_dump_physical_efuse_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)2892 halmac_query_dump_physical_efuse_status_88xx(
2893 IN PHALMAC_ADAPTER pHalmac_adapter,
2894 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
2895 INOUT u8 *data,
2896 INOUT u32 *size
2897 )
2898 {
2899 VOID *pDriver_adapter = NULL;
2900 PHALMAC_EFUSE_STATE_SET pEfuse_state_set = &(pHalmac_adapter->halmac_state.efuse_state_set);
2901
2902 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2903
2904 *pProcess_status = pEfuse_state_set->process_status;
2905
2906 if (NULL == data)
2907 return HALMAC_RET_NULL_POINTER;
2908
2909 if (NULL == size)
2910 return HALMAC_RET_NULL_POINTER;
2911
2912 if (HALMAC_CMD_PROCESS_DONE == *pProcess_status) {
2913 if (*size < pHalmac_adapter->hw_config_info.efuse_size) {
2914 *size = pHalmac_adapter->hw_config_info.efuse_size;
2915 return HALMAC_RET_BUFFER_TOO_SMALL;
2916 }
2917
2918 *size = pHalmac_adapter->hw_config_info.efuse_size;
2919 PLATFORM_RTL_MEMCPY(pDriver_adapter, data, pHalmac_adapter->pHalEfuse_map, *size);
2920 }
2921
2922 return HALMAC_RET_SUCCESS;
2923 }
2924
2925 HALMAC_RET_STATUS
halmac_query_dump_logical_efuse_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)2926 halmac_query_dump_logical_efuse_status_88xx(
2927 IN PHALMAC_ADAPTER pHalmac_adapter,
2928 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
2929 INOUT u8 *data,
2930 INOUT u32 *size
2931 )
2932 {
2933 u8 *pEeprom_map = NULL;
2934 u32 eeprom_size = pHalmac_adapter->hw_config_info.eeprom_size;
2935 VOID *pDriver_adapter = NULL;
2936 PHALMAC_EFUSE_STATE_SET pEfuse_state_set = &(pHalmac_adapter->halmac_state.efuse_state_set);
2937
2938 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
2939
2940 *pProcess_status = pEfuse_state_set->process_status;
2941
2942 pEeprom_map = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, eeprom_size);
2943 if (NULL == pEeprom_map) {
2944 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_EFUSE, HALMAC_DBG_ERR, "halmac allocate local eeprom map Fail!!\n");
2945 return HALMAC_RET_MALLOC_FAIL;
2946 }
2947 PLATFORM_RTL_MEMSET(pDriver_adapter, pEeprom_map, 0xFF, eeprom_size);
2948
2949 if (NULL == data)
2950 return HALMAC_RET_NULL_POINTER;
2951
2952 if (NULL == size)
2953 return HALMAC_RET_NULL_POINTER;
2954
2955 if (HALMAC_CMD_PROCESS_DONE == *pProcess_status) {
2956 if (*size < eeprom_size) {
2957 *size = eeprom_size;
2958 return HALMAC_RET_BUFFER_TOO_SMALL;
2959 }
2960
2961 *size = eeprom_size;
2962 if (HALMAC_RET_SUCCESS != halmac_eeprom_parser_88xx(pHalmac_adapter, pHalmac_adapter->pHalEfuse_map, pEeprom_map))
2963 return HALMAC_RET_EEPROM_PARSING_FAIL;
2964 PLATFORM_RTL_MEMCPY(pDriver_adapter, data, pEeprom_map, *size);
2965 }
2966
2967 PLATFORM_RTL_FREE(pDriver_adapter, pEeprom_map, eeprom_size);
2968
2969 return HALMAC_RET_SUCCESS;
2970 }
2971
2972 HALMAC_RET_STATUS
halmac_query_channel_switch_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)2973 halmac_query_channel_switch_status_88xx(
2974 IN PHALMAC_ADAPTER pHalmac_adapter,
2975 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
2976 INOUT u8 *data,
2977 INOUT u32 *size
2978 )
2979 {
2980 PHALMAC_SCAN_STATE_SET pScan_state_set = &(pHalmac_adapter->halmac_state.scan_state_set);
2981
2982 *pProcess_status = pScan_state_set->process_status;
2983
2984 return HALMAC_RET_SUCCESS;
2985 }
2986
2987 HALMAC_RET_STATUS
halmac_query_update_packet_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)2988 halmac_query_update_packet_status_88xx(
2989 IN PHALMAC_ADAPTER pHalmac_adapter,
2990 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
2991 INOUT u8 *data,
2992 INOUT u32 *size
2993 )
2994 {
2995 PHALMAC_UPDATE_PACKET_STATE_SET pUpdate_packet_set = &(pHalmac_adapter->halmac_state.update_packet_set);
2996
2997 *pProcess_status = pUpdate_packet_set->process_status;
2998
2999 return HALMAC_RET_SUCCESS;
3000 }
3001
3002 HALMAC_RET_STATUS
halmac_query_iqk_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)3003 halmac_query_iqk_status_88xx(
3004 IN PHALMAC_ADAPTER pHalmac_adapter,
3005 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
3006 INOUT u8 *data,
3007 INOUT u32 *size
3008 )
3009 {
3010 PHALMAC_IQK_STATE_SET pIqk_set = &(pHalmac_adapter->halmac_state.iqk_set);
3011
3012 *pProcess_status = pIqk_set->process_status;
3013
3014 return HALMAC_RET_SUCCESS;
3015 }
3016
3017 HALMAC_RET_STATUS
halmac_query_power_tracking_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)3018 halmac_query_power_tracking_status_88xx(
3019 IN PHALMAC_ADAPTER pHalmac_adapter,
3020 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
3021 INOUT u8 *data,
3022 INOUT u32 *size
3023 )
3024 {
3025 PHALMAC_POWER_TRACKING_STATE_SET pPower_tracking_state_set = &(pHalmac_adapter->halmac_state.power_tracking_set);;
3026
3027 *pProcess_status = pPower_tracking_state_set->process_status;
3028
3029 return HALMAC_RET_SUCCESS;
3030 }
3031
3032 HALMAC_RET_STATUS
halmac_query_psd_status_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT HALMAC_CMD_PROCESS_STATUS * pProcess_status,INOUT u8 * data,INOUT u32 * size)3033 halmac_query_psd_status_88xx(
3034 IN PHALMAC_ADAPTER pHalmac_adapter,
3035 OUT HALMAC_CMD_PROCESS_STATUS *pProcess_status,
3036 INOUT u8 *data,
3037 INOUT u32 *size
3038 )
3039 {
3040 VOID *pDriver_adapter = NULL;
3041 PHALMAC_PSD_STATE_SET pPsd_set = &(pHalmac_adapter->halmac_state.psd_set);
3042
3043 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3044
3045 *pProcess_status = pPsd_set->process_status;
3046
3047 if (NULL == data)
3048 return HALMAC_RET_NULL_POINTER;
3049
3050 if (NULL == size)
3051 return HALMAC_RET_NULL_POINTER;
3052
3053 if (HALMAC_CMD_PROCESS_DONE == *pProcess_status) {
3054 if (*size < pPsd_set->data_size) {
3055 *size = pPsd_set->data_size;
3056 return HALMAC_RET_BUFFER_TOO_SMALL;
3057 }
3058
3059 *size = pPsd_set->data_size;
3060 PLATFORM_RTL_MEMCPY(pDriver_adapter, data, pPsd_set->pData, *size);
3061 }
3062
3063 return HALMAC_RET_SUCCESS;
3064 }
3065
3066 HALMAC_RET_STATUS
halmac_verify_io_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)3067 halmac_verify_io_88xx(
3068 IN PHALMAC_ADAPTER pHalmac_adapter
3069 )
3070 {
3071 u8 value8, wvalue8;
3072 u32 value32, value32_2, wvalue32;
3073 u32 halmac_offset;
3074 VOID *pDriver_adapter = NULL;
3075 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
3076
3077 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3078
3079 if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface) {
3080 halmac_offset = REG_PAGE5_DUMMY;
3081 if (0 == (halmac_offset & 0xFFFF0000))
3082 halmac_offset |= WLAN_IOREG_OFFSET;
3083
3084 halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
3085
3086 /* Verify CMD52 R/W */
3087 wvalue8 = 0xab;
3088 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset, wvalue8);
3089
3090 value8 = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset);
3091
3092 if (value8 != wvalue8) {
3093 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "cmd52 r/w fail write = %X read = %X\n", wvalue8, value8);
3094 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3095 } else {
3096 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "cmd52 r/w ok\n");
3097 }
3098
3099 /* Verify CMD53 R/W */
3100 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset, 0xaa);
3101 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 1, 0xbb);
3102 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 2, 0xcc);
3103 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 3, 0xdd);
3104
3105 value32 = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, halmac_offset);
3106
3107 if (0xddccbbaa != value32) {
3108 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "cmd53 r fail : read = %X\n");
3109 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3110 } else {
3111 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "cmd53 r ok\n");
3112 }
3113
3114 wvalue32 = 0x11223344;
3115 PLATFORM_SDIO_CMD53_WRITE_32(pDriver_adapter, halmac_offset, wvalue32);
3116
3117 value32 = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, halmac_offset);
3118
3119 if (value32 != wvalue32) {
3120 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "cmd53 w fail\n");
3121 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3122 } else {
3123 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "cmd53 w ok\n");
3124 }
3125
3126 value32 = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, halmac_offset + 2); /* value32 should be 0x33441122 */
3127
3128 wvalue32 = 0x11225566;
3129 PLATFORM_SDIO_CMD53_WRITE_32(pDriver_adapter, halmac_offset, wvalue32);
3130
3131 value32_2 = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, halmac_offset + 2); /* value32 should be 0x55661122 */
3132 if (value32_2 == value32) {
3133 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "cmd52 is used for HAL_SDIO_CMD53_READ_32\n");
3134 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3135 } else {
3136 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "cmd53 is correctly used\n");
3137 }
3138 } else {
3139 wvalue32 = 0x77665511;
3140 PLATFORM_REG_WRITE_32(pDriver_adapter, REG_PAGE5_DUMMY, wvalue32);
3141
3142 value32 = PLATFORM_REG_READ_32(pDriver_adapter, REG_PAGE5_DUMMY);
3143 if (value32 != wvalue32) {
3144 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "reg rw\n");
3145 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3146 } else {
3147 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "reg rw ok\n");
3148 }
3149 }
3150
3151 return ret_status;
3152 }
3153
3154 HALMAC_RET_STATUS
halmac_verify_send_rsvd_page_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)3155 halmac_verify_send_rsvd_page_88xx(
3156 IN PHALMAC_ADAPTER pHalmac_adapter
3157 )
3158 {
3159 u8 *rsvd_buf = NULL;
3160 u8 *rsvd_page = NULL;
3161 u32 i;
3162 u32 h2c_pkt_verify_size = 64, h2c_pkt_verify_payload = 0xab;
3163 VOID *pDriver_adapter = NULL;
3164 PHALMAC_API pHalmac_api;
3165 HALMAC_RET_STATUS ret_status = HALMAC_RET_SUCCESS;
3166
3167 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3168 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3169
3170 rsvd_buf = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, h2c_pkt_verify_size);
3171
3172 if (NULL == rsvd_buf) {
3173 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "rsvd buffer malloc fail!!\n");
3174 return HALMAC_RET_MALLOC_FAIL;
3175 }
3176
3177 rsvd_page = (u8 *)PLATFORM_RTL_MALLOC(pDriver_adapter, h2c_pkt_verify_size + pHalmac_adapter->hw_config_info.txdesc_size);
3178
3179 if (NULL == rsvd_page) {
3180 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "rsvd page malloc fail!!\n");
3181 return HALMAC_RET_MALLOC_FAIL;
3182 }
3183
3184 PLATFORM_RTL_MEMSET(pDriver_adapter, rsvd_buf, (u8)h2c_pkt_verify_payload, h2c_pkt_verify_size);
3185
3186 ret_status = halmac_download_rsvd_page_88xx(pHalmac_adapter, rsvd_buf, h2c_pkt_verify_size);
3187
3188 if (HALMAC_RET_SUCCESS != ret_status)
3189 return ret_status;
3190
3191 PLATFORM_RTL_MEMSET(pDriver_adapter, rsvd_page, 0x00, h2c_pkt_verify_size + pHalmac_adapter->hw_config_info.txdesc_size);
3192
3193 ret_status = halmac_dump_fifo_88xx(pHalmac_adapter, HAL_FIFO_SEL_RSVD_PAGE, rsvd_page, h2c_pkt_verify_size + pHalmac_adapter->hw_config_info.txdesc_size);
3194
3195 if (HALMAC_RET_SUCCESS != ret_status)
3196 return ret_status;
3197
3198 for (i = 0; i < h2c_pkt_verify_size; i++) {
3199 if (*(rsvd_buf + i) != *(rsvd_page + (i + pHalmac_adapter->hw_config_info.txdesc_size))) {
3200 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Compare RSVD page Fail\n");
3201 ret_status = HALMAC_RET_PLATFORM_API_INCORRECT;
3202 }
3203 }
3204
3205 PLATFORM_RTL_FREE(pDriver_adapter, rsvd_buf, h2c_pkt_verify_size);
3206 PLATFORM_RTL_FREE(pDriver_adapter, rsvd_page, h2c_pkt_verify_size + pHalmac_adapter->hw_config_info.txdesc_size);
3207 rsvd_buf = NULL;
3208 rsvd_page = NULL;
3209
3210 return ret_status;
3211 }
3212
3213 VOID
halmac_power_save_cb_88xx(IN VOID * CbData)3214 halmac_power_save_cb_88xx(
3215 IN VOID *CbData
3216 )
3217 {
3218 VOID *pDriver_adapter = NULL;
3219 PHALMAC_ADAPTER pHalmac_adapter = (PHALMAC_ADAPTER)NULL;
3220
3221 pHalmac_adapter = (PHALMAC_ADAPTER)CbData;
3222 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
3223
3224 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_PWR, HALMAC_DBG_TRACE, "halmac_power_save_cb_88xx\n");
3225 }
3226
3227 HALMAC_RET_STATUS
halmac_buffer_read_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 offset,IN u32 size,IN HAL_FIFO_SEL halmac_fifo_sel,OUT u8 * pFifo_map)3228 halmac_buffer_read_88xx(
3229 IN PHALMAC_ADAPTER pHalmac_adapter,
3230 IN u32 offset,
3231 IN u32 size,
3232 IN HAL_FIFO_SEL halmac_fifo_sel,
3233 OUT u8 *pFifo_map
3234 )
3235 {
3236 u32 start_page, value_read;
3237 u32 i, counter = 0, residue;
3238 PHALMAC_API pHalmac_api;
3239
3240 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3241
3242 if (HAL_FIFO_SEL_RSVD_PAGE == halmac_fifo_sel)
3243 offset = offset + (pHalmac_adapter->txff_allocation.rsvd_pg_bndy << 7);
3244
3245 start_page = offset >> 12;
3246 residue = offset & (4096 - 1);
3247
3248 if ((HAL_FIFO_SEL_TX == halmac_fifo_sel) || (HAL_FIFO_SEL_RSVD_PAGE == halmac_fifo_sel))
3249 start_page += 0x780;
3250 else if (HAL_FIFO_SEL_RX == halmac_fifo_sel)
3251 start_page += 0x700;
3252 else if (HAL_FIFO_SEL_REPORT == halmac_fifo_sel)
3253 start_page += 0x660;
3254 else if (HAL_FIFO_SEL_LLT == halmac_fifo_sel)
3255 start_page += 0x650;
3256
3257 value_read = HALMAC_REG_READ_16(pHalmac_adapter, REG_PKTBUF_DBG_CTRL);
3258
3259 while (1) {
3260 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_PKTBUF_DBG_CTRL, (u16)(start_page | (value_read & 0xF000)));
3261
3262 for (i = 0x8000 + residue; i <= 0x8FFF; i += 4) {
3263 *(u32 *)(pFifo_map + counter) = HALMAC_REG_READ_32(pHalmac_adapter, i);
3264 *(u32 *)(pFifo_map + counter) = rtk_le32_to_cpu(*(u32 *)(pFifo_map + counter));
3265 counter += 4;
3266 if (size == counter)
3267 goto HALMAC_BUF_READ_OK;
3268 }
3269
3270 residue = 0;
3271 start_page++;
3272 }
3273
3274 HALMAC_BUF_READ_OK:
3275 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_PKTBUF_DBG_CTRL, (u16)value_read);
3276
3277 return HALMAC_RET_SUCCESS;
3278 }
3279
3280 VOID
halmac_restore_mac_register_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_RESTORE_INFO pRestore_info,IN u32 restore_num)3281 halmac_restore_mac_register_88xx(
3282 IN PHALMAC_ADAPTER pHalmac_adapter,
3283 IN PHALMAC_RESTORE_INFO pRestore_info,
3284 IN u32 restore_num
3285 )
3286 {
3287 u8 value_length;
3288 u32 i;
3289 u32 mac_register;
3290 u32 mac_value;
3291 PHALMAC_API pHalmac_api;
3292 PHALMAC_RESTORE_INFO pCurr_restore_info = pRestore_info;
3293
3294 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3295
3296 for (i = 0; i < restore_num; i++) {
3297 mac_register = pCurr_restore_info->mac_register;
3298 mac_value = pCurr_restore_info->value;
3299 value_length = pCurr_restore_info->length;
3300
3301 if (1 == value_length)
3302 HALMAC_REG_WRITE_8(pHalmac_adapter, mac_register, (u8)mac_value);
3303 else if (2 == value_length)
3304 HALMAC_REG_WRITE_16(pHalmac_adapter, mac_register, (u16)mac_value);
3305 else if (4 == value_length)
3306 HALMAC_REG_WRITE_32(pHalmac_adapter, mac_register, mac_value);
3307
3308 pCurr_restore_info++;
3309 }
3310 }
3311
3312 VOID
halmac_api_record_id_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN HALMAC_API_ID api_id)3313 halmac_api_record_id_88xx(
3314 IN PHALMAC_ADAPTER pHalmac_adapter,
3315 IN HALMAC_API_ID api_id
3316 )
3317 {
3318 u8 array_wptr_last;
3319
3320 array_wptr_last = pHalmac_adapter->api_record.array_wptr;
3321
3322 if (array_wptr_last == API_ARRAY_SIZE - 1)
3323 array_wptr_last = 0;
3324 else if (HALMAC_API_STUFF == pHalmac_adapter->api_record.api_array[0])
3325 array_wptr_last = array_wptr_last;
3326 else
3327 array_wptr_last = array_wptr_last + 1;
3328
3329 pHalmac_adapter->api_record.api_array[array_wptr_last] = api_id;
3330 pHalmac_adapter->api_record.array_wptr = array_wptr_last;
3331 }
3332
3333 VOID
halmac_get_hcpwm_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u8 * pHcpwm)3334 halmac_get_hcpwm_88xx(
3335 IN PHALMAC_ADAPTER pHalmac_adapter,
3336 OUT u8 *pHcpwm
3337 )
3338 {
3339 PHALMAC_API pHalmac_api;
3340 u32 hcpwm_offset = 0;
3341
3342 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3343
3344 if (HALMAC_INTERFACE_PCIE == pHalmac_adapter->halmac_interface)
3345 hcpwm_offset = REG_PCIE_HCPWM1_V1;
3346 else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface)
3347 hcpwm_offset = 0xFE57;
3348 else if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface)
3349 hcpwm_offset = REG_SDIO_HCPWM1_V2;
3350
3351 *pHcpwm = HALMAC_REG_READ_8(pHalmac_adapter, hcpwm_offset);
3352 }
3353
3354 VOID
halmac_get_hcpwm2_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,OUT u16 * pHcpwm2)3355 halmac_get_hcpwm2_88xx(
3356 IN PHALMAC_ADAPTER pHalmac_adapter,
3357 OUT u16 *pHcpwm2
3358 )
3359 {
3360 PHALMAC_API pHalmac_api;
3361 u32 hcpwm2_offset = 0;
3362
3363
3364 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3365
3366 if (HALMAC_INTERFACE_PCIE == pHalmac_adapter->halmac_interface)
3367 hcpwm2_offset = REG_PCIE_HCPWM2_V1;
3368 else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface)
3369 hcpwm2_offset = 0xFE34;
3370 else if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface)
3371 hcpwm2_offset = REG_SDIO_HCPWM2_V2;
3372
3373 *pHcpwm2 = HALMAC_REG_READ_16(pHalmac_adapter, hcpwm2_offset);
3374 }
3375
3376 VOID
halmac_set_hrpwm_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 hrpwm)3377 halmac_set_hrpwm_88xx(
3378 IN PHALMAC_ADAPTER pHalmac_adapter,
3379 IN u8 hrpwm
3380 )
3381 {
3382 PHALMAC_API pHalmac_api;
3383 u32 hrpwm_offset = 0;
3384 u8 hrpwm_original = 0;
3385
3386 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3387
3388 if (HALMAC_INTERFACE_PCIE == pHalmac_adapter->halmac_interface)
3389 hrpwm_offset = REG_PCIE_HRPWM1_V1;
3390 else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface)
3391 hrpwm_offset = 0xFE58;
3392 else if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface)
3393 hrpwm_offset = REG_SDIO_HRPWM1;
3394
3395 hrpwm_original = HALMAC_REG_READ_8(pHalmac_adapter, hrpwm_offset);
3396 hrpwm = (hrpwm & 0x7F) | ((~hrpwm_original) & 0x80);
3397
3398 HALMAC_REG_WRITE_8(pHalmac_adapter, hrpwm_offset, hrpwm);
3399 }
3400
3401 VOID
halmac_set_hrpwm2_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u16 hrpwm2)3402 halmac_set_hrpwm2_88xx(
3403 IN PHALMAC_ADAPTER pHalmac_adapter,
3404 IN u16 hrpwm2
3405 )
3406 {
3407 PHALMAC_API pHalmac_api;
3408 u32 hrpwm2_offset = 0;
3409 u16 hrpwm2_original = 0;
3410
3411 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
3412
3413 if (HALMAC_INTERFACE_PCIE == pHalmac_adapter->halmac_interface)
3414 hrpwm2_offset = REG_PCIE_HRPWM2_V1;
3415 else if (HALMAC_INTERFACE_USB == pHalmac_adapter->halmac_interface)
3416 hrpwm2_offset = 0xFE36;
3417 else if (HALMAC_INTERFACE_SDIO == pHalmac_adapter->halmac_interface)
3418 hrpwm2_offset = REG_SDIO_HRPWM2;
3419
3420 hrpwm2_original = HALMAC_REG_READ_16(pHalmac_adapter, hrpwm2_offset);
3421 hrpwm2 = (hrpwm2 & 0x7FFF) | ((~hrpwm2_original) & 0x8000);
3422
3423 HALMAC_REG_WRITE_16(pHalmac_adapter, hrpwm2_offset, hrpwm2);
3424 }
3425