1 /* SPDX-License-Identifier: GPL-2.0 */
2 #include "halmac_88xx_cfg.h"
3
4 /**
5 * halmac_init_sdio_cfg_88xx() - init SDIO related register
6 * @pHalmac_adapter
7 * Author : KaiYuan Chang/Ivan Lin
8 * Return : HALMAC_RET_STATUS
9 */
10 HALMAC_RET_STATUS
halmac_init_sdio_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)11 halmac_init_sdio_cfg_88xx(
12 IN PHALMAC_ADAPTER pHalmac_adapter
13 )
14 {
15 VOID *pDriver_adapter = NULL;
16 PHALMAC_API pHalmac_api;
17
18 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
19 return HALMAC_RET_ADAPTER_INVALID;
20
21 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
22 return HALMAC_RET_API_INVALID;
23
24 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_INIT_SDIO_CFG);
25
26 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
27 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
28
29 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_sdio_cfg_88xx ==========>\n");
30
31 HALMAC_REG_READ_32(pHalmac_adapter, REG_SDIO_FREE_TXPG);
32 HALMAC_REG_WRITE_32(pHalmac_adapter, REG_SDIO_TX_CTRL, 0x00000000);
33
34 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_init_sdio_cfg_88xx <==========\n");
35
36 return HALMAC_RET_SUCCESS;
37 }
38
39 /**
40 * halmac_deinit_sdio_cfg_88xx() - deinit SDIO related register
41 * @pHalmac_adapter
42 * Author : KaiYuan Chang/Ivan Lin
43 * Return : HALMAC_RET_STATUS
44 */
45 HALMAC_RET_STATUS
halmac_deinit_sdio_cfg_88xx(IN PHALMAC_ADAPTER pHalmac_adapter)46 halmac_deinit_sdio_cfg_88xx(
47 IN PHALMAC_ADAPTER pHalmac_adapter
48 )
49 {
50 VOID *pDriver_adapter = NULL;
51
52 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
53 return HALMAC_RET_ADAPTER_INVALID;
54
55 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
56 return HALMAC_RET_API_INVALID;
57
58 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_DEINIT_SDIO_CFG);
59
60 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
61
62 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_deinit_sdio_cfg_88xx ==========>\n");
63
64 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_deinit_sdio_cfg_88xx <==========\n");
65
66 return HALMAC_RET_SUCCESS;
67 }
68
69 /**
70 * halmac_cfg_rx_aggregation_88xx_sdio() - config rx aggregation
71 * @pHalmac_adapter
72 * @halmac_rx_agg_mode
73 * Author : KaiYuan Chang/Ivan Lin
74 * Return : HALMAC_RET_STATUS
75 */
76 HALMAC_RET_STATUS
halmac_cfg_rx_aggregation_88xx_sdio(IN PHALMAC_ADAPTER pHalmac_adapter,IN PHALMAC_RXAGG_CFG phalmac_rxagg_cfg)77 halmac_cfg_rx_aggregation_88xx_sdio(
78 IN PHALMAC_ADAPTER pHalmac_adapter,
79 IN PHALMAC_RXAGG_CFG phalmac_rxagg_cfg
80 )
81 {
82 u8 value8, dma_usb_agg = 0;
83 u8 size = 0, timeout = 0, agg_enable = 0;
84 VOID *pDriver_adapter = NULL;
85 PHALMAC_API pHalmac_api;
86
87 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
88 return HALMAC_RET_ADAPTER_INVALID;
89
90 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
91 return HALMAC_RET_API_INVALID;
92
93 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_RX_AGGREGATION);
94
95 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
96 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
97
98 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_rx_aggregation_88xx_sdio ==========>\n");
99
100 dma_usb_agg = HALMAC_REG_READ_8(pHalmac_adapter, REG_RXDMA_AGG_PG_TH + 3);
101 agg_enable = HALMAC_REG_READ_8(pHalmac_adapter, REG_TXDMA_PQ_MAP);
102
103 switch (phalmac_rxagg_cfg->mode) {
104 case HALMAC_RX_AGG_MODE_NONE:
105 agg_enable &= ~(BIT_RXDMA_AGG_EN);
106 break;
107 case HALMAC_RX_AGG_MODE_DMA:
108 agg_enable |= BIT_RXDMA_AGG_EN;
109 dma_usb_agg |= BIT(7);
110 break;
111
112 case HALMAC_RX_AGG_MODE_USB:
113 agg_enable |= BIT_RXDMA_AGG_EN;
114 dma_usb_agg &= ~(BIT(7));
115 break;
116 default:
117 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_cfg_rx_aggregation_88xx_usb switch case not support\n");
118 agg_enable &= ~BIT_RXDMA_AGG_EN;
119 break;
120 }
121
122 if (_FALSE == phalmac_rxagg_cfg->threshold.drv_define) {
123 size = 0xFF;
124 timeout = 0x01;
125 } else {
126 size = phalmac_rxagg_cfg->threshold.size;
127 timeout = phalmac_rxagg_cfg->threshold.timeout;
128 }
129
130
131 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_TXDMA_PQ_MAP, agg_enable);
132 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RXDMA_AGG_PG_TH + 3, dma_usb_agg);
133 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RXDMA_AGG_PG_TH, (u16)(size | (timeout << BIT_SHIFT_DMA_AGG_TO)));
134
135 value8 = HALMAC_REG_READ_8(pHalmac_adapter, REG_RXDMA_MODE);
136 if (0 != (agg_enable & BIT_RXDMA_AGG_EN))
137 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RXDMA_MODE, value8 | BIT_DMA_MODE);
138 else
139 HALMAC_REG_WRITE_8(pHalmac_adapter, REG_RXDMA_MODE, value8 & ~(BIT_DMA_MODE));
140
141 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_rx_aggregation_88xx_sdio <==========\n");
142
143 return HALMAC_RET_SUCCESS;
144 }
145
146 /**
147 * halmac_reg_read_8_sdio_88xx() - read 1byte register
148 * @pHalmac_adapter
149 * @halmac_offset
150 * Author : KaiYuan Chang/Ivan Lin
151 * Return : HALMAC_RET_STATUS
152 */
153 u8
halmac_reg_read_8_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset)154 halmac_reg_read_8_sdio_88xx(
155 IN PHALMAC_ADAPTER pHalmac_adapter,
156 IN u32 halmac_offset
157 )
158 {
159 u8 value8;
160 VOID *pDriver_adapter = NULL;
161 PHALMAC_API pHalmac_api;
162 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
163
164 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
165 return HALMAC_RET_ADAPTER_INVALID;
166
167 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
168 return HALMAC_RET_API_INVALID;
169
170 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
171 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
172
173 if (0 == (halmac_offset & 0xFFFF0000))
174 halmac_offset |= WLAN_IOREG_OFFSET;
175
176 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
177
178 if (HALMAC_RET_SUCCESS != status) {
179 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_read_8_sdio_88xx error = %x\n", status);
180 return status;
181 }
182
183 value8 = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset);
184
185 return value8;
186 }
187
188 /**
189 * halmac_reg_write_8_sdio_88xx() - write 1byte register
190 * @pHalmac_adapter
191 * @halmac_offset
192 * @halmac_data
193 * Author : KaiYuan Chang/Ivan Lin
194 * Return : HALMAC_RET_STATUS
195 */
196 HALMAC_RET_STATUS
halmac_reg_write_8_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,IN u8 halmac_data)197 halmac_reg_write_8_sdio_88xx(
198 IN PHALMAC_ADAPTER pHalmac_adapter,
199 IN u32 halmac_offset,
200 IN u8 halmac_data
201 )
202 {
203 VOID *pDriver_adapter = NULL;
204 PHALMAC_API pHalmac_api;
205 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
206
207 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
208 return HALMAC_RET_ADAPTER_INVALID;
209
210 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
211 return HALMAC_RET_API_INVALID;
212
213 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
214 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
215
216 if (0 == (halmac_offset & 0xFFFF0000))
217 halmac_offset |= WLAN_IOREG_OFFSET;
218
219 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
220
221 if (HALMAC_RET_SUCCESS != status) {
222 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_write_8_sdio_88xx error = %x\n", status);
223 return status;
224 }
225
226 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset, halmac_data);
227
228 return HALMAC_RET_SUCCESS;
229 }
230
231 /**
232 * halmac_reg_read_16_sdio_88xx() - read 2byte register
233 * @pHalmac_adapter
234 * @halmac_offset
235 * Author : KaiYuan Chang/Ivan Lin
236 * Return : HALMAC_RET_STATUS
237 */
238 u16
halmac_reg_read_16_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset)239 halmac_reg_read_16_sdio_88xx(
240 IN PHALMAC_ADAPTER pHalmac_adapter,
241 IN u32 halmac_offset
242 )
243 {
244 VOID *pDriver_adapter = NULL;
245 PHALMAC_API pHalmac_api;
246 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
247
248 union {
249 u16 word;
250 u8 byte[2];
251 } value16 = { 0x0000 };
252
253 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
254 return HALMAC_RET_ADAPTER_INVALID;
255
256 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
257 return HALMAC_RET_API_INVALID;
258
259 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
260 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
261
262 if (0 == (halmac_offset & 0xFFFF0000))
263 halmac_offset |= WLAN_IOREG_OFFSET;
264
265 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
266
267 if (HALMAC_RET_SUCCESS != status) {
268 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_read_16_sdio_88xx error = %x\n", status);
269 return status;
270 }
271
272 if (HALMAC_MAC_POWER_OFF == pHalmac_adapter->halmac_state.mac_power) {
273 value16.byte[0] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset);
274 value16.byte[1] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset + 1);
275 value16.word = rtk_le16_to_cpu(value16.word);
276 } else {
277 if ((PLATFORM_SD_CLK > HALMAC_SD_CLK_THRESHOLD_88XX) && ((halmac_offset & 0xffffef00) == 0x00000000)) {
278 value16.byte[0] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset);
279 value16.byte[1] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset + 1);
280 value16.word = rtk_le16_to_cpu(value16.word);
281 } else {
282 value16.word = PLATFORM_SDIO_CMD53_READ_16(pDriver_adapter, halmac_offset);
283 }
284 }
285
286 return value16.word;
287 }
288
289 /**
290 * halmac_reg_write_16_sdio_88xx() - write 2byte register
291 * @pHalmac_adapter
292 * @halmac_offset
293 * @halmac_data
294 * Author : KaiYuan Chang/Ivan Lin
295 * Return : HALMAC_RET_STATUS
296 */
297 HALMAC_RET_STATUS
halmac_reg_write_16_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,IN u16 halmac_data)298 halmac_reg_write_16_sdio_88xx(
299 IN PHALMAC_ADAPTER pHalmac_adapter,
300 IN u32 halmac_offset,
301 IN u16 halmac_data
302 )
303 {
304 VOID *pDriver_adapter = NULL;
305 PHALMAC_API pHalmac_api;
306 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
307
308 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
309 return HALMAC_RET_ADAPTER_INVALID;
310
311 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
312 return HALMAC_RET_API_INVALID;
313
314 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
315 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
316
317 if (0 == (halmac_offset & 0xFFFF0000))
318 halmac_offset |= WLAN_IOREG_OFFSET;
319
320 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
321
322 if (HALMAC_RET_SUCCESS != status) {
323 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_write_16_sdio_88xx error = %x\n", status);
324 return status;
325 }
326
327 if (HALMAC_MAC_POWER_OFF == pHalmac_adapter->halmac_state.mac_power) {
328 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset, (u8)(halmac_data & 0xFF));
329 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 1, (u8)((halmac_data & 0xFF00) >> 8));
330 } else {
331 PLATFORM_SDIO_CMD53_WRITE_16(pDriver_adapter, halmac_offset, halmac_data);
332 }
333
334 return HALMAC_RET_SUCCESS;
335 }
336
337 /**
338 * halmac_reg_read_32_sdio_88xx() - read 4byte register
339 * @pHalmac_adapter
340 * @halmac_offset
341 * Author : KaiYuan Chang/Ivan Lin
342 * Return : HALMAC_RET_STATUS
343 */
344 u32
halmac_reg_read_32_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset)345 halmac_reg_read_32_sdio_88xx(
346 IN PHALMAC_ADAPTER pHalmac_adapter,
347 IN u32 halmac_offset
348 )
349 {
350 u8 rtemp = 0xFF;
351 u32 counter = 1000;
352 VOID *pDriver_adapter = NULL;
353 PHALMAC_API pHalmac_api;
354 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
355
356 union {
357 u32 dword;
358 u8 byte[4];
359 } value32 = { 0x00000000 };
360
361 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
362 return HALMAC_RET_ADAPTER_INVALID;
363
364 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
365 return HALMAC_RET_API_INVALID;
366
367 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
368 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
369
370 if (0 == (halmac_offset & 0xFFFF0000))
371 halmac_offset |= WLAN_IOREG_OFFSET;
372
373 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
374 if (HALMAC_RET_SUCCESS != status) {
375 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_read_32_sdio_88xx error = %x\n", status);
376 return status;
377 }
378
379 if (HALMAC_MAC_POWER_OFF == pHalmac_adapter->halmac_state.mac_power) {
380 value32.byte[0] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset);
381 value32.byte[1] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset + 1);
382 value32.byte[2] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset + 2);
383 value32.byte[3] = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, halmac_offset + 3);
384 value32.dword = rtk_le32_to_cpu(value32.dword);
385 } else {
386 if ((PLATFORM_SD_CLK > HALMAC_SD_CLK_THRESHOLD_88XX) && ((halmac_offset & 0xffffef00) == 0x00000000)) {
387 PLATFORM_SDIO_CMD53_WRITE_32(pDriver_adapter, REG_SDIO_INDIRECT_REG_CFG, halmac_offset | BIT(19) | BIT(17));
388
389 do {
390 rtemp = PLATFORM_SDIO_CMD52_READ(pDriver_adapter, REG_SDIO_INDIRECT_REG_CFG + 2);
391 counter--;
392 } while (((rtemp & BIT(4)) != 0) && (counter > 0));
393
394 value32.dword = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, REG_SDIO_INDIRECT_REG_DATA);
395 } else {
396 value32.dword = PLATFORM_SDIO_CMD53_READ_32(pDriver_adapter, halmac_offset);
397 }
398 }
399
400 return value32.dword;
401 }
402
403 /**
404 * halmac_reg_write_32_sdio_88xx() - write 4byte register
405 * @pHalmac_adapter
406 * @halmac_offset
407 * @halmac_data
408 * Author : KaiYuan Chang/Ivan Lin
409 * Return : HALMAC_RET_STATUS
410 */
411 HALMAC_RET_STATUS
halmac_reg_write_32_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u32 halmac_offset,IN u32 halmac_data)412 halmac_reg_write_32_sdio_88xx(
413 IN PHALMAC_ADAPTER pHalmac_adapter,
414 IN u32 halmac_offset,
415 IN u32 halmac_data
416 )
417 {
418 VOID *pDriver_adapter = NULL;
419 PHALMAC_API pHalmac_api;
420 HALMAC_RET_STATUS status = HALMAC_RET_SUCCESS;
421
422 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
423 return HALMAC_RET_ADAPTER_INVALID;
424
425 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
426 return HALMAC_RET_API_INVALID;
427
428 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
429 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
430
431 if (0 == (halmac_offset & 0xFFFF0000))
432 halmac_offset |= WLAN_IOREG_OFFSET;
433
434 status = halmac_convert_to_sdio_bus_offset_88xx(pHalmac_adapter, &halmac_offset);
435
436 if (HALMAC_RET_SUCCESS != status) {
437 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_reg_write_32_sdio_88xx error = %x\n", status);
438 return status;
439 }
440
441 if (HALMAC_MAC_POWER_OFF == pHalmac_adapter->halmac_state.mac_power) {
442 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset, (u8)(halmac_data & 0xFF));
443 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 1, (u8)((halmac_data & 0xFF00) >> 8));
444 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 2, (u8)((halmac_data & 0xFF0000) >> 16));
445 PLATFORM_SDIO_CMD52_WRITE(pDriver_adapter, halmac_offset + 3, (u8)((halmac_data & 0xFF000000) >> 24));
446 } else {
447 PLATFORM_SDIO_CMD53_WRITE_32(pDriver_adapter, halmac_offset, halmac_data);
448 }
449
450 return HALMAC_RET_SUCCESS;
451 }
452
453 /**
454 * halmac_get_sdio_tx_addr_88xx() - get CMD53 addr for the TX packet
455 * @pHalmac_adapter
456 * @halmac_buf
457 * @halmac_size
458 * @pcmd53_addr
459 * Author : KaiYuan Chang/Ivan Lin
460 * Return : HALMAC_RET_STATUS
461 */
462 HALMAC_RET_STATUS
halmac_get_sdio_tx_addr_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 * halmac_buf,IN u32 halmac_size,OUT u32 * pcmd53_addr)463 halmac_get_sdio_tx_addr_88xx(
464 IN PHALMAC_ADAPTER pHalmac_adapter,
465 IN u8 *halmac_buf,
466 IN u32 halmac_size,
467 OUT u32 *pcmd53_addr
468 )
469 {
470 u32 four_byte_len;
471 VOID *pDriver_adapter = NULL;
472 PHALMAC_API pHalmac_api;
473 HALMAC_QUEUE_SELECT queue_sel;
474 HALMAC_DMA_MAPPING dma_mapping;
475
476 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
477 return HALMAC_RET_ADAPTER_INVALID;
478
479 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
480 return HALMAC_RET_API_INVALID;
481
482 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_GET_SDIO_TX_ADDR);
483
484 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
485 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
486
487 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_get_sdio_tx_addr_88xx ==========>\n");
488
489 if (NULL == halmac_buf) {
490 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_buf is NULL!!\n");
491 return HALMAC_RET_DATA_BUF_NULL;
492 }
493
494 if (0 == halmac_size) {
495 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "halmac_size is 0!!\n");
496 return HALMAC_RET_DATA_SIZE_INCORRECT;
497 }
498
499 queue_sel = (HALMAC_QUEUE_SELECT)GET_TX_DESC_QSEL(halmac_buf);
500
501 switch (queue_sel) {
502 case HALMAC_QUEUE_SELECT_VO:
503 case HALMAC_QUEUE_SELECT_VO_V2:
504 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VO];
505 break;
506 case HALMAC_QUEUE_SELECT_VI:
507 case HALMAC_QUEUE_SELECT_VI_V2:
508 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_VI];
509 break;
510 case HALMAC_QUEUE_SELECT_BE:
511 case HALMAC_QUEUE_SELECT_BE_V2:
512 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BE];
513 break;
514 case HALMAC_QUEUE_SELECT_BK:
515 case HALMAC_QUEUE_SELECT_BK_V2:
516 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_BK];
517 break;
518 case HALMAC_QUEUE_SELECT_MGNT:
519 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_MG];
520 break;
521 case HALMAC_QUEUE_SELECT_HIGH:
522 case HALMAC_QUEUE_SELECT_BCN:
523 case HALMAC_QUEUE_SELECT_CMD:
524 dma_mapping = pHalmac_adapter->halmac_ptcl_queue[HALMAC_PTCL_QUEUE_HI];
525 break;
526 default:
527 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Qsel is out of range\n");
528 return HALMAC_RET_QSEL_INCORRECT;
529 }
530
531 four_byte_len = (halmac_size >> 2) + ((halmac_size & (4 - 1)) ? 1 : 0);
532
533 switch (dma_mapping) {
534 case HALMAC_DMA_MAPPING_HIGH:
535 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_HIGH;
536 break;
537 case HALMAC_DMA_MAPPING_NORMAL:
538 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_NORMAL;
539 break;
540 case HALMAC_DMA_MAPPING_LOW:
541 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_LOW;
542 break;
543 case HALMAC_DMA_MAPPING_EXTRA:
544 *pcmd53_addr = HALMAC_SDIO_CMD_ADDR_TXFF_EXTRA;
545 break;
546 default:
547 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "DmaMapping is out of range\n");
548 return HALMAC_RET_DMA_MAP_INCORRECT;
549 }
550
551 *pcmd53_addr = (*pcmd53_addr << 13) | (four_byte_len & HALMAC_SDIO_4BYTE_LEN_MASK);
552
553 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_get_sdio_tx_addr_88xx <==========\n");
554
555 return HALMAC_RET_SUCCESS;
556 }
557
558 /**
559 * halmac_cfg_tx_agg_align_sdio_88xx() -
560 * @pHalmac_adapter
561 * @enable
562 * @align_size
563 * Author : Soar Tu
564 * Return : HALMAC_RET_STATUS
565 */
566 HALMAC_RET_STATUS
halmac_cfg_tx_agg_align_sdio_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 enable,IN u16 align_size)567 halmac_cfg_tx_agg_align_sdio_88xx(
568 IN PHALMAC_ADAPTER pHalmac_adapter,
569 IN u8 enable,
570 IN u16 align_size
571 )
572 {
573 PHALMAC_API pHalmac_api;
574 VOID *pDriver_adapter = NULL;
575 u8 i, align_size_ok = 0;
576
577 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
578 return HALMAC_RET_ADAPTER_INVALID;
579
580 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
581 return HALMAC_RET_API_INVALID;
582
583 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_TX_AGG_ALIGN);
584
585 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
586 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
587
588
589 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_tx_agg_align_sdio_88xx ==========>\n");
590
591 if ((align_size & 0xF000) != 0) {
592 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Align size is out of range\n");
593 return HALMAC_RET_FAIL;
594 }
595
596 for (i = 3; i <= 11; i++) {
597 if (align_size == 1 << i) {
598 align_size_ok = 1;
599 break;
600 }
601 }
602 if (align_size_ok == 0) {
603 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_ERR, "Align size is not 2^3 ~ 2^11\n");
604 return HALMAC_RET_FAIL;
605 }
606
607 if (enable)
608 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RQPN_CTRL_2, 0x8000 | align_size);
609 else
610 HALMAC_REG_WRITE_16(pHalmac_adapter, REG_RQPN_CTRL_2, align_size);
611
612 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_tx_agg_align_sdio_88xx <==========\n");
613
614 return HALMAC_RET_SUCCESS;
615 }
616
617 /**
618 * halmac_cfg_tx_agg_align_sdio_not_support_88xx() -
619 * @pHalmac_adapter
620 * @enable
621 * @align_size
622 * Author : Soar Tu
623 * Return : HALMAC_RET_STATUS
624 */
625 HALMAC_RET_STATUS
halmac_cfg_tx_agg_align_sdio_not_support_88xx(IN PHALMAC_ADAPTER pHalmac_adapter,IN u8 enable,IN u16 align_size)626 halmac_cfg_tx_agg_align_sdio_not_support_88xx(
627 IN PHALMAC_ADAPTER pHalmac_adapter,
628 IN u8 enable,
629 IN u16 align_size
630 )
631 {
632 PHALMAC_API pHalmac_api;
633 VOID *pDriver_adapter = NULL;
634
635 if (HALMAC_RET_SUCCESS != halmac_adapter_validate(pHalmac_adapter))
636 return HALMAC_RET_ADAPTER_INVALID;
637
638 if (HALMAC_RET_SUCCESS != halmac_api_validate(pHalmac_adapter))
639 return HALMAC_RET_API_INVALID;
640
641 halmac_api_record_id_88xx(pHalmac_adapter, HALMAC_API_CFG_TX_AGG_ALIGN);
642
643 pDriver_adapter = pHalmac_adapter->pDriver_adapter;
644 pHalmac_api = (PHALMAC_API)pHalmac_adapter->pHalmac_api;
645
646
647 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_tx_agg_align_sdio_not_support_88xx ==========>\n");
648
649 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_tx_agg_align_sdio_not_support_88xx not support\n");
650 PLATFORM_MSG_PRINT(pDriver_adapter, HALMAC_MSG_INIT, HALMAC_DBG_TRACE, "halmac_cfg_tx_agg_align_sdio_not_support_88xx <==========\n");
651
652 return HALMAC_RET_SUCCESS;
653 }
654
655