1 /******************************************************************************
2 *
3 * Copyright(c) 2019 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 /*
16 The purpose of hal_efuse.c
17
18 Provide efuse operations.
19 a. efuse init function
20 b. efuse shadow map read/write/update
21 c. efuse information query, map size/used bytes...
22
23 */
24
25 #define _HAL_EFUSE_C_
26 #include "../hal_headers.h"
27 #include "hal_efuse.h"
28 #include "hal_efuse_export.h"
29
30 /* WIFI EFUSE API */
efuse_shadow_read_one_byte(struct efuse_t * efuse,u16 offset,u8 * value)31 void efuse_shadow_read_one_byte(struct efuse_t *efuse, u16 offset, u8 *value)
32 {
33 *value = efuse->shadow_map[offset];
34 }
35
efuse_shadow_read_two_byte(struct efuse_t * efuse,u16 offset,u16 * value)36 void efuse_shadow_read_two_byte(struct efuse_t *efuse, u16 offset, u16 *value)
37 {
38 *value = efuse->shadow_map[offset];
39 *value |= efuse->shadow_map[offset+1] << 8;
40 }
41
efuse_shadow_read_four_byte(struct efuse_t * efuse,u16 offset,u32 * value)42 void efuse_shadow_read_four_byte(struct efuse_t *efuse, u16 offset, u32 *value)
43 {
44 *value = efuse->shadow_map[offset];
45 *value |= efuse->shadow_map[offset+1] << 8;
46 *value |= efuse->shadow_map[offset+2] << 16;
47 *value |= efuse->shadow_map[offset+3] << 24;
48 }
49
efuse_shadow_write_one_byte(struct efuse_t * efuse,u16 offset,u16 value)50 void efuse_shadow_write_one_byte(struct efuse_t *efuse, u16 offset, u16 value)
51 {
52 efuse->shadow_map[offset] = (u8)(value&0x00FF);
53 }
54
efuse_shadow_write_two_byte(struct efuse_t * efuse,u16 offset,u16 value)55 void efuse_shadow_write_two_byte(struct efuse_t *efuse, u16 offset, u16 value)
56 {
57 efuse->shadow_map[offset] = (u8)(value&0x00FF);
58 efuse->shadow_map[offset+1] = (u8)((value&0xFF00) >> 8);
59 }
60
efuse_shadow_write_four_byte(struct efuse_t * efuse,u16 offset,u32 value)61 void efuse_shadow_write_four_byte(struct efuse_t *efuse, u16 offset, u32 value)
62 {
63 efuse->shadow_map[offset] = (u8)(value&0x000000FF);
64 efuse->shadow_map[offset+1] = (u8)((value&0x0000FF00) >> 8);
65 efuse->shadow_map[offset+2] = (u8)((value&0x00FF0000) >> 16);
66 efuse->shadow_map[offset+3] = (u8)((value&0xFF000000) >> 24);
67 }
68
efuse_check_autoload(struct efuse_t * efuse)69 u32 efuse_check_autoload(struct efuse_t *efuse)
70 {
71 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
72
73 hal_status = rtw_hal_mac_check_efuse_autoload(efuse->hal_com,
74 &efuse->is_map_valid);
75 if (efuse->is_map_valid != true)
76 efuse->map_from_status = DEFAULT_MAP;
77
78 return hal_status;
79 }
80
efuse_hidden_handle(struct efuse_t * efuse)81 u32 efuse_hidden_handle(struct efuse_t *efuse)
82 {
83 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
84
85 hal_status = rtw_hal_mac_read_hidden_rpt(efuse->hal_com);
86
87 return hal_status;
88 }
89
efuse_set_hw_cap(struct efuse_t * efuse)90 enum rtw_hal_status efuse_set_hw_cap(struct efuse_t *efuse)
91 {
92 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
93 struct rtw_hal_com_t *hal_com = efuse->hal_com;
94 u8 pkg_type = 0xFF;
95 u8 rfe_type = 0xFF;
96 u8 xcap = 0xFF;
97 u8 domain = 0xFF;
98 u8 rf_board_opt = 0xFF;
99
100 status = rtw_efuse_get_info(efuse, EFUSE_INFO_RF_PKG_TYPE, &pkg_type,
101 sizeof(pkg_type));
102
103 if(status != RTW_HAL_STATUS_SUCCESS) {
104 PHL_WARN("%s: Get pkg type fail! Status(%x)\n", __FUNCTION__, status);
105 }
106
107 status = rtw_efuse_get_info(efuse, EFUSE_INFO_RF_RFE, &rfe_type,
108 sizeof(rfe_type));
109
110 if(status != RTW_HAL_STATUS_SUCCESS) {
111 PHL_WARN("%s: Get rfe type fail! Status(%x)\n", __FUNCTION__, status);
112 }
113
114 status = rtw_efuse_get_info(efuse, EFUSE_INFO_RF_XTAL, &xcap,
115 sizeof(xcap));
116
117 if(status != RTW_HAL_STATUS_SUCCESS) {
118 PHL_WARN("%s: Get xcap fail! Status(%x)\n", __FUNCTION__, status);
119 }
120
121 status = rtw_efuse_get_info(efuse, EFUSE_INFO_RF_CHAN_PLAN, &domain,
122 sizeof(domain));
123
124 if(status != RTW_HAL_STATUS_SUCCESS) {
125 PHL_WARN("%s: Get domain fail! Status(%x)\n", __FUNCTION__, status);
126 }
127
128 status = rtw_efuse_get_info(efuse, EFUSE_INFO_RF_BOARD_OPTION, &rf_board_opt,
129 sizeof(rf_board_opt));
130
131 if(status != RTW_HAL_STATUS_SUCCESS) {
132 PHL_WARN("%s: Get domain fail! Status(%x)\n", __FUNCTION__, status);
133 }
134
135 hal_com->dev_hw_cap.pkg_type = pkg_type;
136 hal_com->dev_hw_cap.rfe_type = rfe_type;
137 hal_com->dev_hw_cap.xcap = xcap;
138 hal_com->dev_hw_cap.domain = domain;
139 hal_com->dev_hw_cap.rf_board_opt = rf_board_opt;
140
141 return status;
142 }
143
rtw_efuse_logicmap_buf_load(void * efuse,u8 * buf,bool is_limit)144 enum rtw_hal_status rtw_efuse_logicmap_buf_load(void *efuse, u8* buf, bool is_limit)
145 {
146 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
147 struct efuse_t *efuse_info = efuse;
148
149 status = rtw_hal_mac_read_log_efuse_map(efuse_info->hal_com,
150 buf,
151 is_limit);
152 return status;
153 }
154
rtw_efuse_shadow_load(void * efuse,bool is_limit)155 enum rtw_hal_status rtw_efuse_shadow_load(void *efuse, bool is_limit)
156 {
157 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
158 struct efuse_t *efuse_info = efuse;
159
160 status = rtw_hal_mac_read_log_efuse_map(efuse_info->hal_com,
161 efuse_info->shadow_map,
162 is_limit);
163
164 if (efuse_info->is_map_valid == true && status == RTW_HAL_STATUS_SUCCESS)
165 efuse_info->map_from_status = HW_LOG_MAP;
166
167 return status;
168 }
169
rtw_efuse_shadow_file_load(void * efuse,char * ic_name,bool is_limit)170 enum rtw_hal_status rtw_efuse_shadow_file_load(void *efuse, char *ic_name, bool is_limit)
171 {
172 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
173
174 #ifdef CONFIG_EFUSE_CONFIG_FILE
175 struct efuse_t *efuse_info = efuse;
176
177 if (efuse_info->is_map_valid != true ||
178 rtw_hal_rf_check_efuse_data(efuse_info->hal_com, HW_PHY_0) != true) {
179
180 if (rtw_hal_efuse_shadow_file_load(efuse_info->hal_com ,
181 ic_name, is_limit) == RTW_HAL_STATUS_SUCCESS) {
182
183 if (rtw_hal_rf_check_efuse_data(efuse_info->hal_com, HW_PHY_0) == true) {
184 efuse_info->is_map_valid = true;
185 PHL_INFO(" %s() hal_rf check file efuse is_map_valid.\n", __FUNCTION__);
186 } else {
187 status = RTW_HAL_STATUS_FAILURE;
188 PHL_WARN(" %s() efuse Power invalid !\n", __FUNCTION__);
189 }
190 } else {
191 PHL_WARN("%s: efuse shadow_file_load fail!\n", __FUNCTION__);
192 status = RTW_HAL_STATUS_FAILURE;
193 }
194 }
195 #endif
196 return status;
197 }
198
rtw_efuse_shadow_update(void * efuse,bool is_limit)199 enum rtw_hal_status rtw_efuse_shadow_update(void *efuse, bool is_limit)
200 {
201 enum rtw_hal_status status = RTW_HAL_STATUS_EFUSE_PG_FAIL;
202 enum rtw_hal_status reload_status = RTW_HAL_STATUS_FAILURE;
203 struct efuse_t *efuse_info = efuse;
204 u32 map_size = 0, mask_size = 0;
205
206 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
207 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
208 status = RTW_HAL_STATUS_EFUSE_UNINIT;
209 goto exit;
210 }
211
212 /* Load efuse mask file before PG */
213 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_MASK_FILE_LOADED) == false) {
214 PHL_WARN("%s: efuse mask not load yet!\n", __FUNCTION__);
215 status = RTW_HAL_STATUS_EFUSE_PG_FAIL;
216 goto exit;
217 }
218
219 /*
220 * If driver does not load external map file,
221 * assign the map version with the mask version for the version check.
222 */
223 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_MAP_FILE_LOADED) == false) {
224 _os_mem_cpy(efuse_info->hal_com->drv_priv, efuse_info->map_version,
225 efuse_info->mask_version, efuse_info->version_len);
226 }
227
228 if(is_limit) {
229 map_size = efuse_info->limit_efuse_size;
230 mask_size = efuse_info->limit_mask_size;
231 }
232 else {
233 map_size = efuse_info->log_efuse_size;
234 mask_size = efuse_info->mask_size;
235 }
236
237 status = rtw_hal_mac_write_log_efuse_map(efuse_info->hal_com,
238 efuse_info->shadow_map,
239 map_size,
240 efuse_info->mask,
241 mask_size,
242 efuse_info->map_version,
243 efuse_info->mask_version,
244 efuse_info->version_len,
245 0,
246 is_limit);
247
248 if(status != RTW_HAL_STATUS_SUCCESS)
249 PHL_WARN("%s: PG Fail!\n", __FUNCTION__);
250
251 /* Reload shadow map after PG */
252 reload_status = rtw_hal_mac_read_log_efuse_map(efuse_info->hal_com,
253 efuse_info->shadow_map,
254 is_limit);
255 if(reload_status != RTW_HAL_STATUS_SUCCESS)
256 PHL_WARN("%s: Reload shadow map Fail!\n", __FUNCTION__);
257
258 /*
259 * Clear the load external map file flag and map version
260 * after reloading the map.
261 */
262 if(TEST_STATUS_FLAG(efuse_info->status,
263 EFUSE_STATUS_MAP_FILE_LOADED) == true) {
264 CLEAR_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_MAP_FILE_LOADED);
265 }
266
267 _os_mem_set(efuse_info->hal_com->drv_priv,
268 efuse_info->map_version,
269 0,
270 efuse_info->version_len);
271 exit:
272 return status;
273 }
274
275 enum rtw_hal_status
rtw_efuse_shadow_read(void * efuse,u8 byte_count,u16 offset,u32 * value,bool is_limit)276 rtw_efuse_shadow_read(void *efuse, u8 byte_count, u16 offset, u32 *value,
277 bool is_limit)
278 {
279 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
280 struct efuse_t *efuse_info = efuse;
281 u32 efuse_size = 0;
282
283 if(is_limit)
284 efuse_size = efuse_info->limit_efuse_size;
285 else
286 efuse_size = efuse_info->log_efuse_size;
287
288 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
289 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
290 status = RTW_HAL_STATUS_EFUSE_UNINIT;
291 goto exit;
292 }
293
294 if((u32)(offset+byte_count) > efuse_size) {
295 PHL_WARN("%s: Invalid offset!\n", __FUNCTION__);
296 status = RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
297 goto exit;
298 }
299
300 if (byte_count == 1)
301 efuse_shadow_read_one_byte(efuse_info, offset, (u8 *)value);
302 else if (byte_count == 2)
303 efuse_shadow_read_two_byte(efuse_info, offset, (u16 *)value);
304 else if (byte_count == 4)
305 efuse_shadow_read_four_byte(efuse_info, offset, (u32 *)value);
306
307 status = RTW_HAL_STATUS_SUCCESS;
308 exit:
309 return status;
310 }
311
312 enum rtw_hal_status
rtw_efuse_shadow_write(void * efuse,u8 byte_count,u16 offset,u32 value,bool is_limit)313 rtw_efuse_shadow_write(void *efuse, u8 byte_count, u16 offset, u32 value,
314 bool is_limit)
315 {
316 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
317 struct efuse_t *efuse_info = efuse;
318 u32 efuse_size = 0;
319
320 if(is_limit)
321 efuse_size = efuse_info->limit_efuse_size;
322 else
323 efuse_size = efuse_info->log_efuse_size;
324
325 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
326 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
327 status = RTW_HAL_STATUS_EFUSE_UNINIT;
328 goto exit;
329 }
330
331 if((u32)(offset+byte_count) > efuse_size) {
332 PHL_WARN("%s: Invalid offset!\n", __FUNCTION__);
333 status = RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
334 goto exit;
335 }
336
337 if (byte_count == 1)
338 efuse_shadow_write_one_byte(efuse_info, offset, (u8)value);
339 else if (byte_count == 2)
340 efuse_shadow_write_two_byte(efuse_info, offset, (u16)value);
341 else if (byte_count == 4)
342 efuse_shadow_write_four_byte(efuse_info, offset, (u32)value);
343
344 status = RTW_HAL_STATUS_SUCCESS;
345 exit:
346 return status;
347 }
348
349
350 /*
351 * This API is used for original mp dll command.
352 * usage = used percentage(1 Byte) + used bytes(2 Bytes)
353 */
rtw_efuse_get_usage(void * efuse,u32 * usage)354 enum rtw_hal_status rtw_efuse_get_usage(void *efuse, u32 *usage)
355 {
356 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
357 struct efuse_t *efuse_info = efuse;
358 u32 avl_size = 0;
359 u16 used_byte = 0;
360 u32 total_size = 0;
361 u8 used_percentage = 0;
362
363 status = rtw_hal_mac_get_efuse_avl(efuse_info->hal_com, &avl_size);
364 status = rtw_hal_mac_get_efuse_size(efuse_info->hal_com, &total_size);
365
366 if(total_size != 0){
367 used_byte = (u16)(total_size - avl_size);
368 used_percentage = (u8)(used_byte*100/total_size);
369 *usage = (used_percentage<<16)|(used_byte);
370 }
371
372 return status;
373 }
374
rtw_efuse_shadow2buf(void * efuse,u8 * destbuf,u16 buflen)375 enum rtw_hal_status rtw_efuse_shadow2buf(void *efuse, u8 *destbuf, u16 buflen)
376 {
377 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
378 struct efuse_t *efuse_info = efuse;
379
380 _os_mem_cpy(efuse_info->hal_com->drv_priv, (void *)destbuf,
381 (void *)efuse_info->shadow_map , buflen);
382
383 return status;
384 }
385
386 enum rtw_hal_status
efuse_map_buf2shadow(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)387 efuse_map_buf2shadow(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
388 {
389 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
390
391 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->shadow_map,
392 (void *)srcbuf, buflen);
393 SET_STATUS_FLAG(efuse->status, EFUSE_STATUS_MAP_FILE_LOADED);
394
395 return status;
396 }
397
398 enum rtw_hal_status
efuse_file_map2version(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)399 efuse_file_map2version(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
400 {
401 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
402
403 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->map_version,
404 (void *)srcbuf, buflen);
405 debug_dump_data(efuse->map_version, efuse->version_len,
406 "[HAL EFUSE] map version =");
407
408 return status;
409 }
410
411 enum rtw_hal_status
efuse_file_mask2buf(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)412 efuse_file_mask2buf(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
413 {
414 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
415
416 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->mask, (void *)srcbuf,
417 buflen);
418 SET_STATUS_FLAG(efuse->status, EFUSE_STATUS_MASK_FILE_LOADED);
419 status = RTW_HAL_STATUS_SUCCESS;
420
421 debug_dump_data(efuse->mask, efuse->mask_size, "[HAL EFUSE] mask data =");
422
423 return status;
424 }
425
426 enum rtw_hal_status
efuse_file_mask2version(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)427 efuse_file_mask2version(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
428 {
429 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
430
431 if (buflen <= efuse->version_len) {
432 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->mask_version,
433 (void *)srcbuf, buflen);
434 debug_dump_data(efuse->mask_version, efuse->version_len,
435 "[HAL EFUSE] mask ver =");
436 status = RTW_HAL_STATUS_SUCCESS;
437 }
438
439 return status;
440 }
441
efuse_file_open(void * d,char * filepath,u8 * buf,u32 buflen)442 static u16 efuse_file_open(void *d, char *filepath, u8 *buf, u32 buflen)
443 {
444 char *ptmpbuf = NULL, *ptr;
445 u32 bufsize = 5120;
446 u8 val8 = 0;
447 u32 file_size = 0, i = 0, j= 0, tmp = 0;
448 int err = 0;
449
450 ptmpbuf = _os_mem_alloc(d, bufsize);
451 if (ptmpbuf == NULL) {
452 PHL_INFO("%s, alloc buf FAIL!!\n", __FUNCTION__);
453 return 0;
454 }
455
456 file_size = _os_read_file(filepath, (u8*)ptmpbuf, bufsize);
457 if (file_size > 0) {
458 if (file_size <= 90) {
459 _os_mem_free(d, (void*)ptmpbuf, bufsize);
460 PHL_INFO("%s, filepatch %s, size=%d not over 90, FAIL!!\n",
461 __FUNCTION__, filepath, file_size);
462 return 0;
463 }
464 i = 0;
465 j = 0;
466 ptr = ptmpbuf;
467 while ((j < buflen) && (i < file_size)) {
468 if (ptmpbuf[i] == '\0')
469 break;
470 ptr = _os_strpbrk((char *)&ptmpbuf[i], " \t\n\r");
471 if (ptr) {
472 if (ptr == &ptmpbuf[i]) {
473 i++;
474 continue;
475 }
476 /* Add string terminating null */
477 *ptr = 0;
478 } else {
479 ptr = &ptmpbuf[file_size-1];
480 }
481
482 err = _os_sscanf((char *)&ptmpbuf[i], "%x", &tmp);
483
484 if (err != 1) {
485 PHL_INFO("Something wrong to parse efuse file, string=%s\n", &ptmpbuf[i]);
486 } else {
487 val8 = (u8)tmp;
488 buf[j] = val8;
489 PHL_INFO("i=%d, j=%d, 0x%02x\n", i, j, buf[j]);
490 j++;
491 }
492 i = (u32)(ptr - ptmpbuf + 1);
493 }
494 }
495 if (ptmpbuf)
496 _os_mem_free(d, (void*)ptmpbuf, bufsize);
497 PHL_INFO("%s, filepatch %s, size=%d, done\n", __FUNCTION__, filepath, file_size);
498 return (u16)j;
499 }
500
501 enum rtw_hal_status
rtw_efuse_file_map_load(void * efuse,char * file_path,u8 is_limit)502 rtw_efuse_file_map_load(void *efuse, char *file_path, u8 is_limit)
503 {
504 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
505 struct efuse_t *efuse_info = efuse;
506 void *d = efuse_info->hal_com->drv_priv;
507 u8 *mapbuf = NULL;
508 u16 data_len = 0;
509 u32 map_sz = 0, full_map_sz = 0;
510
511 if (is_limit)
512 map_sz = efuse_info->limit_efuse_size;
513 else
514 map_sz = efuse_info->log_efuse_size;
515
516 if (map_sz == 0) {
517 map_sz = MAX_EFUSE_MAP_LEN;
518 full_map_sz = MAX_EFUSE_MAP_LEN + MAX_EFUSE_FILE_VERSION_LENGTH;
519 } else
520 full_map_sz = map_sz + efuse_info->version_len;
521
522 if (file_path && full_map_sz != 0) {
523 mapbuf= _os_mem_alloc(d, full_map_sz);
524 if (mapbuf == NULL) {
525 PHL_INFO("%s, alloc buf FAIL!!\n", __FUNCTION__);
526 goto exit;
527 }
528 _os_mem_set(d, mapbuf, 0xFF, full_map_sz);
529
530 data_len = efuse_file_open(d, file_path, mapbuf, full_map_sz);
531
532 if ((data_len > map_sz) && (data_len <= full_map_sz)) {
533 efuse_file_map2version(efuse_info, mapbuf + map_sz,
534 efuse_info->version_len);
535
536 if (data_len > map_sz)
537 data_len -= efuse_info->version_len;
538
539 PHL_INFO("%s , File eFuse map to shadow len %d\n", __FUNCTION__, data_len);
540 hal_status = efuse_map_buf2shadow(efuse_info, mapbuf, data_len);
541 efuse_info->map_from_status = FILE_MAP;
542 } else {
543 PHL_INFO("Error No Map Version !, File Map Data Len %d not over 1536.\n", data_len);
544 goto exit;
545 }
546 }
547 exit:
548 if (mapbuf)
549 _os_mem_free(d, (void*)mapbuf, full_map_sz);
550
551 return hal_status;
552 }
553
554 enum rtw_hal_status
rtw_efuse_file_mask_load(void * efuse,char * file_path,u8 is_limit)555 rtw_efuse_file_mask_load(void *efuse, char *file_path, u8 is_limit)
556 {
557 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
558 struct efuse_t *efuse_info = efuse;
559 void *d = efuse_info->hal_com->drv_priv;
560 u8 *maskbuf = NULL;
561 u16 data_len = 0;
562 u32 mask_sz = 0, full_mask_sz = 0;
563
564 if (is_limit)
565 mask_sz = efuse_info->limit_mask_size;
566 else
567 mask_sz = efuse_info->mask_size;
568
569 if (mask_sz == 0) {
570 mask_sz = EFUSE_MASK_FILE_LEN;
571 full_mask_sz = EFUSE_MASK_FILE_LEN + MAX_EFUSE_FILE_VERSION_LENGTH;
572 } else
573 full_mask_sz = mask_sz + efuse_info->version_len;
574
575 if (file_path) {
576 maskbuf= _os_mem_alloc(d, full_mask_sz);
577 if (maskbuf == NULL) {
578 PHL_INFO("%s, alloc buf FAIL!!\n", __FUNCTION__);
579 goto exit;
580 }
581 _os_mem_set(d, maskbuf, 0xFF, full_mask_sz);
582
583 data_len = efuse_file_open(d, file_path, maskbuf, full_mask_sz);
584
585 if ((data_len > mask_sz) && (data_len <= full_mask_sz)) {
586 efuse_file_mask2version(efuse_info, maskbuf + mask_sz,
587 efuse_info->version_len);
588
589 if (data_len > mask_sz)
590 data_len -= efuse_info->version_len;
591
592 PHL_INFO("Mask File data 2 buf len %d\n", data_len);
593 hal_status = efuse_file_mask2buf(efuse_info, maskbuf, data_len);
594
595 } else {
596 PHL_INFO("Error No Map Version !, File Map Data Len %d not over 102.\n", data_len);
597 goto exit;
598 }
599 }
600 exit:
601 if (maskbuf)
602 _os_mem_free(d, (void*)maskbuf, full_mask_sz);
603
604 return hal_status;
605 }
606
rtw_efuse_get_logical_size(void * efuse,u32 * size,bool is_limited)607 enum rtw_hal_status rtw_efuse_get_logical_size(void *efuse, u32 *size,
608 bool is_limited)
609 {
610 struct efuse_t *efuse_info = efuse;
611
612 if(is_limited == true)
613 *size = efuse_info->limit_efuse_size;
614 else
615 *size = efuse_info->log_efuse_size;
616
617 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
618 return RTW_HAL_STATUS_SUCCESS;
619 }
620
rtw_efuse_get_size(void * efuse,u32 * size)621 enum rtw_hal_status rtw_efuse_get_size(void *efuse, u32 *size)
622 {
623 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
624 struct efuse_t *efuse_info = efuse;
625
626 status = rtw_hal_mac_get_efuse_size(efuse_info->hal_com, size);
627
628 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
629 return status;
630 }
631
rtw_efuse_get_avl(void * efuse,u32 * size)632 enum rtw_hal_status rtw_efuse_get_avl(void *efuse, u32 *size)
633 {
634 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
635 struct efuse_t *efuse_info = efuse;
636
637 status = rtw_hal_mac_get_efuse_avl(efuse_info->hal_com, size);
638
639 /* [TEMP] Set avl size for testing */
640 /* size = 512; */
641 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
642 return status;
643 }
644
rtw_efuse_get_offset_mask(void * efuse,u16 offset,u8 * mask)645 enum rtw_hal_status rtw_efuse_get_offset_mask(void *efuse, u16 offset, u8 *mask)
646 {
647 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
648 struct efuse_t *efuse_info = efuse;
649
650 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false)
651 return RTW_HAL_STATUS_EFUSE_UNINIT;
652
653 if(offset >= efuse_info->limit_mask_size)
654 return RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
655
656 *mask = efuse_info->mask[offset];
657 PHL_INFO("%s: offset = %x mask = %x\n", __FUNCTION__, offset, *mask);
658 return status;
659 }
660
rtw_efuse_get_mask_buf(void * efuse,u8 * destbuf,u32 * buflen)661 enum rtw_hal_status rtw_efuse_get_mask_buf(void *efuse, u8 *destbuf, u32 *buflen)
662 {
663 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
664 struct efuse_t *efuse_info = efuse;
665
666 if (efuse_info->mask_size > 0) {
667 _os_mem_cpy(efuse_info->hal_com->drv_priv, (void *)destbuf,
668 (void *)efuse_info->mask , efuse_info->mask_size);
669 *buflen = efuse_info->mask_size;
670
671 PHL_INFO("%s: size = %d\n", __FUNCTION__, efuse_info->mask_size);
672 status = RTW_HAL_STATUS_SUCCESS;
673 }
674
675 return status;
676 }
677
rtw_efuse_get_shadowmap_from(void * efuse,u8 * val)678 enum rtw_hal_status rtw_efuse_get_shadowmap_from(void *efuse, u8 *val)
679 {
680 struct efuse_t *efuse_info = efuse;
681
682 *val = efuse_info->map_from_status;
683
684 PHL_INFO("%s:get efuse %s\n", __FUNCTION__, SHADOWMAP_FROM2STR(*val));
685 return RTW_HAL_STATUS_SUCCESS;
686 }
687
rtw_efuse_get_shadowmap_from_to_str(void * efuse)688 char* rtw_efuse_get_shadowmap_from_to_str(void *efuse)
689 {
690 struct efuse_t *efuse_info = efuse;
691
692 return SHADOWMAP_FROM2STR(efuse_info->map_from_status);
693 }
694
695
rtw_efuse_get_info(void * efuse,enum rtw_efuse_info info_type,void * value,u8 size)696 enum rtw_hal_status rtw_efuse_get_info(void *efuse,
697 enum rtw_efuse_info info_type,
698 void *value,
699 u8 size)
700 {
701 struct efuse_t *efuse_info = efuse;
702 struct rtw_hal_com_t *hal_com = efuse_info->hal_com;
703 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
704
705 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false)
706 return RTW_HAL_STATUS_EFUSE_UNINIT;
707
708 if(info_type <= EFUSE_INFO_MAC_MAX)
709 hal_status = rtw_hal_mac_get_efuse_info(hal_com,
710 efuse_info->shadow_map,
711 info_type,
712 value,
713 size,
714 efuse_info->is_map_valid);
715 else if (info_type <= EFUSE_INFO_BB_MAX)
716 hal_status = rtw_hal_bb_get_efuse_info(hal_com,
717 efuse_info->shadow_map,
718 info_type,
719 value,
720 size,
721 efuse_info->is_map_valid);
722 else if (info_type <= EFUSE_INFO_RF_MAX)
723 hal_status = rtw_hal_rf_get_efuse_info(hal_com,
724 efuse_info->shadow_map,
725 info_type,
726 value,
727 size,
728 efuse_info->is_map_valid);
729 else
730 hal_status = rtw_hal_btc_get_efuse_info(hal_com,
731 efuse_info->shadow_map,
732 info_type,
733 value,
734 size,
735 efuse_info->is_map_valid);
736
737 return hal_status;
738 }
739
rtw_efuse_process(void * efuse,char * ic_name)740 void rtw_efuse_process(void *efuse, char *ic_name)
741 {
742 struct efuse_t *efuse_info = (struct efuse_t *)efuse;
743
744 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == true) {
745 PHL_INFO("%s EFUSE module is already initialized.\n", __FUNCTION__);
746 return;
747 }
748
749 efuse_check_autoload(efuse_info);
750 /* Load wifi full map to shadow map */
751 rtw_efuse_shadow_load(efuse_info, false);
752
753 SET_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS);
754
755 rtw_efuse_shadow_file_load(efuse_info, ic_name, true);
756
757 debug_dump_data(efuse_info->shadow_map, efuse_info->log_efuse_size,
758 "Logical EFUSE MAP:");
759 efuse_hidden_handle(efuse_info);
760
761 /*
762 * We can set the hw cap after we got the shadow map.
763 * The efuse get info API will check the efuse is processed or not.
764 */
765 efuse_set_hw_cap(efuse_info);
766
767 if (RTW_DRV_MODE_EQC == efuse_info->phl_com->drv_mode) {
768 rtw_hal_rf_get_default_rfe_type(efuse_info->hal_com);
769 rtw_hal_rf_get_default_xtal(efuse_info->hal_com);
770 PHL_WARN("%s: Use default RFE type(0x%x) / XTAL(0x%x) configuration for EQC mode\n",
771 __FUNCTION__,
772 efuse_info->hal_com->dev_hw_cap.rfe_type,
773 efuse_info->hal_com->dev_hw_cap.xcap);
774 }
775 }
776
rtw_efuse_init(struct rtw_phl_com_t * phl_com,struct rtw_hal_com_t * hal_com,void ** efuse)777 u32 rtw_efuse_init(struct rtw_phl_com_t *phl_com,
778 struct rtw_hal_com_t *hal_com, void **efuse)
779 {
780 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
781 struct efuse_t *efuse_info = NULL;
782
783 efuse_info = _os_mem_alloc(hal_com->drv_priv, sizeof(struct efuse_t));
784
785 if(efuse_info == NULL) {
786 hal_status = RTW_HAL_STATUS_RESOURCE;
787 goto error_efuse_init;
788 }
789
790 /* Allocate shadow map memory */
791 hal_status = rtw_hal_mac_get_log_efuse_size(hal_com,
792 &(efuse_info->log_efuse_size),
793 false);
794
795 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
796 PHL_ERR("%s Get full logical efuse map size fail!\n",__FUNCTION__);
797 goto error_efuse_shadow_init;
798 }
799
800 efuse_info->shadow_map = _os_mem_alloc(hal_com->drv_priv,
801 efuse_info->log_efuse_size);
802
803 if(efuse_info->shadow_map == NULL) {
804 hal_status = RTW_HAL_STATUS_RESOURCE;
805 PHL_ERR("%s Allocate shadow efuse map fail!\n", __FUNCTION__);
806 goto error_efuse_shadow_init;
807 }
808
809 hal_status = rtw_hal_mac_get_log_efuse_size(hal_com,
810 &(efuse_info->limit_efuse_size),
811 true);
812
813 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
814 PHL_ERR("%s Get limited logical efuse map size fail!\n", __FUNCTION__);
815 goto error_efuse_shadow_init;
816 }
817
818 /* Allocate mask memory */
819 hal_status = rtw_hal_mac_get_efuse_mask_size(hal_com,
820 &(efuse_info->mask_size),
821 false);
822
823 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
824 PHL_ERR("%s Get full efuse mask size fail!\n", __FUNCTION__);
825 goto error_efuse_mask_init;
826 }
827
828 efuse_info->mask = _os_mem_alloc(hal_com->drv_priv,
829 efuse_info->mask_size);
830
831 if(efuse_info->mask == NULL) {
832 hal_status = RTW_HAL_STATUS_RESOURCE;
833 PHL_ERR("%s Allocate efuse mask fail!\n", __FUNCTION__);
834 goto error_efuse_mask_init;
835 }
836
837 hal_status = rtw_hal_mac_get_efuse_mask_size(hal_com,
838 &(efuse_info->limit_mask_size),
839 true);
840
841 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
842 PHL_ERR("%s Get limited efuse mask size fail!\n", __FUNCTION__);
843 goto error_efuse_mask_init;
844 }
845
846 efuse_info->version_len = rtw_hal_mac_get_efuse_ver_len(hal_com);
847
848 efuse_info->map_version = _os_mem_alloc(hal_com->drv_priv,
849 efuse_info->version_len);
850
851 if(efuse_info->map_version == NULL) {
852 hal_status = RTW_HAL_STATUS_RESOURCE;
853 goto error_map_version_init;
854 }
855
856 efuse_info->mask_version = _os_mem_alloc(hal_com->drv_priv,
857 efuse_info->version_len);
858 if(efuse_info->mask_version == NULL) {
859 hal_status = RTW_HAL_STATUS_RESOURCE;
860 goto error_mask_version_init;
861 }
862
863 /* Allocate bt shadow map memory */
864 hal_status = rtw_hal_mac_get_log_efuse_bt_size(hal_com,
865 &(efuse_info->bt_log_efuse_size));
866
867 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
868 PHL_ERR("%s Get full logical efuse map size fail!\n",__FUNCTION__);
869 goto error_efuse_bt_shadow_init;
870 }
871
872 efuse_info->bt_shadow_map = _os_mem_alloc(hal_com->drv_priv,
873 efuse_info->bt_log_efuse_size);
874
875 if(efuse_info->bt_shadow_map == NULL) {
876 hal_status = RTW_HAL_STATUS_RESOURCE;
877 PHL_ERR("%s Allocate shadow efuse map fail!\n", __FUNCTION__);
878 goto error_efuse_bt_shadow_init;
879 }
880
881 /* Allocate mask memory */
882 hal_status = rtw_hal_mac_get_efuse_bt_mask_size(hal_com,
883 &(efuse_info->bt_mask_size));
884
885 if(hal_status != RTW_HAL_STATUS_SUCCESS) {
886 PHL_ERR("%s Get full efuse mask size fail!\n", __FUNCTION__);
887 goto error_efuse_bt_mask_init;
888 }
889
890 efuse_info->bt_mask = _os_mem_alloc(hal_com->drv_priv,
891 efuse_info->bt_mask_size);
892
893 if(efuse_info->bt_mask == NULL) {
894 hal_status = RTW_HAL_STATUS_RESOURCE;
895 PHL_ERR("%s Allocate efuse mask fail!\n", __FUNCTION__);
896 goto error_efuse_bt_mask_init;
897 }
898
899
900 efuse_info->phl_com = phl_com;
901 efuse_info->hal_com = hal_com;
902
903 *efuse = efuse_info;
904
905 hal_status = RTW_HAL_STATUS_SUCCESS;
906 return hal_status;
907
908 error_efuse_bt_mask_init:
909 _os_mem_free(hal_com->drv_priv, efuse_info->bt_shadow_map,
910 efuse_info->bt_log_efuse_size);
911
912 error_efuse_bt_shadow_init:
913 _os_mem_free(hal_com->drv_priv, efuse_info->mask_version,
914 efuse_info->version_len);
915
916 error_mask_version_init:
917 _os_mem_free(hal_com->drv_priv, efuse_info->map_version,
918 efuse_info->version_len);
919
920 error_map_version_init:
921 _os_mem_free(hal_com->drv_priv, efuse_info->mask,
922 efuse_info->mask_size);
923
924 error_efuse_mask_init:
925 _os_mem_free(hal_com->drv_priv, efuse_info->shadow_map,
926 efuse_info->log_efuse_size);
927
928 error_efuse_shadow_init:
929 _os_mem_free(hal_com->drv_priv, efuse_info, sizeof(struct efuse_t));
930
931 error_efuse_init:
932 return hal_status;
933 }
934
rtw_efuse_deinit(struct rtw_hal_com_t * hal_com,void * efuse)935 void rtw_efuse_deinit(struct rtw_hal_com_t *hal_com, void *efuse)
936 {
937 struct efuse_t *efuse_info = efuse;
938
939 if(efuse_info->bt_mask) {
940 _os_mem_free(hal_com->drv_priv, efuse_info->bt_mask,
941 efuse_info->bt_mask_size);
942 efuse_info->bt_mask = NULL;
943 }
944
945 if(efuse_info->bt_shadow_map) {
946 _os_mem_free(hal_com->drv_priv, efuse_info->bt_shadow_map,
947 efuse_info->bt_log_efuse_size);
948 efuse_info->bt_shadow_map = NULL;
949 }
950
951 if(efuse_info->mask) {
952 _os_mem_free(hal_com->drv_priv, efuse_info->mask,
953 efuse_info->mask_size);
954 efuse_info->mask = NULL;
955 }
956 if(efuse_info->map_version) {
957 _os_mem_free(hal_com->drv_priv, efuse_info->map_version,
958 efuse_info->version_len);
959 efuse_info->map_version = NULL;
960 }
961 if(efuse_info->mask_version) {
962 _os_mem_free(hal_com->drv_priv, efuse_info->mask_version,
963 efuse_info->version_len);
964 efuse_info->mask_version = NULL;
965 }
966 if(efuse_info->shadow_map) {
967 _os_mem_free(hal_com->drv_priv, efuse_info->shadow_map,
968 efuse_info->log_efuse_size);
969 efuse_info->shadow_map = NULL;
970 }
971
972 if (efuse_info) {
973 _os_mem_free(hal_com->drv_priv, efuse_info, sizeof(struct efuse_t));
974 efuse_info = NULL;
975 }
976 }
977
978 /* BT EFUSE API */
efuse_bt_shadow_read_one_byte(struct efuse_t * efuse,u16 offset,u8 * value)979 void efuse_bt_shadow_read_one_byte(struct efuse_t *efuse, u16 offset, u8 *value)
980 {
981 *value = efuse->bt_shadow_map[offset];
982 }
983
efuse_bt_shadow_read_two_byte(struct efuse_t * efuse,u16 offset,u16 * value)984 void efuse_bt_shadow_read_two_byte(struct efuse_t *efuse, u16 offset, u16 *value)
985 {
986 *value = efuse->bt_shadow_map[offset];
987 *value |= efuse->bt_shadow_map[offset+1] << 8;
988 }
989
efuse_bt_shadow_read_four_byte(struct efuse_t * efuse,u16 offset,u32 * value)990 void efuse_bt_shadow_read_four_byte(struct efuse_t *efuse, u16 offset, u32 *value)
991 {
992 *value = efuse->bt_shadow_map[offset];
993 *value |= efuse->bt_shadow_map[offset+1] << 8;
994 *value |= efuse->bt_shadow_map[offset+2] << 16;
995 *value |= efuse->bt_shadow_map[offset+3] << 24;
996 }
997
efuse_bt_shadow_write_one_byte(struct efuse_t * efuse,u16 offset,u16 value)998 void efuse_bt_shadow_write_one_byte(struct efuse_t *efuse, u16 offset, u16 value)
999 {
1000 efuse->bt_shadow_map[offset] = (u8)(value&0x00FF);
1001 }
1002
efuse_bt_shadow_write_two_byte(struct efuse_t * efuse,u16 offset,u16 value)1003 void efuse_bt_shadow_write_two_byte(struct efuse_t *efuse, u16 offset, u16 value)
1004 {
1005 efuse->bt_shadow_map[offset] = (u8)(value&0x00FF);
1006 efuse->bt_shadow_map[offset+1] = (u8)((value&0xFF00) >> 8);
1007 }
1008
efuse_bt_shadow_write_four_byte(struct efuse_t * efuse,u16 offset,u32 value)1009 void efuse_bt_shadow_write_four_byte(struct efuse_t *efuse, u16 offset, u32 value)
1010 {
1011 efuse->bt_shadow_map[offset] = (u8)(value&0x000000FF);
1012 efuse->bt_shadow_map[offset+1] = (u8)((value&0x0000FF00) >> 8);
1013 efuse->bt_shadow_map[offset+2] = (u8)((value&0x00FF0000) >> 16);
1014 efuse->bt_shadow_map[offset+3] = (u8)((value&0xFF000000) >> 24);
1015 }
1016
rtw_efuse_bt_shadow_load(void * efuse)1017 enum rtw_hal_status rtw_efuse_bt_shadow_load(void *efuse)
1018 {
1019 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1020 struct efuse_t *efuse_info = efuse;
1021
1022 status = rtw_hal_mac_read_log_efuse_bt_map(efuse_info->hal_com,
1023 efuse_info->bt_shadow_map);
1024
1025 return status;
1026 }
1027
rtw_efuse_bt_shadow_update(void * efuse)1028 enum rtw_hal_status rtw_efuse_bt_shadow_update(void *efuse)
1029 {
1030 enum rtw_hal_status status = RTW_HAL_STATUS_EFUSE_PG_FAIL;
1031 enum rtw_hal_status reload_status = RTW_HAL_STATUS_FAILURE;
1032 struct efuse_t *efuse_info = efuse;
1033 u32 map_size = 0, mask_size = 0;
1034
1035 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
1036 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
1037 status = RTW_HAL_STATUS_EFUSE_UNINIT;
1038 goto exit;
1039 }
1040
1041 /* Load efuse mask file before PG */
1042 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_BT_MASK_FILE_LOADED) == false) {
1043 PHL_WARN("%s: efuse mask not load yet!\n", __FUNCTION__);
1044 status = RTW_HAL_STATUS_EFUSE_PG_FAIL;
1045 goto exit;
1046 }
1047
1048 map_size = efuse_info->bt_log_efuse_size;
1049 mask_size = efuse_info->bt_mask_size;
1050
1051 status = rtw_hal_mac_write_log_efuse_bt_map(efuse_info->hal_com,
1052 efuse_info->bt_shadow_map,
1053 map_size,
1054 efuse_info->bt_mask,
1055 mask_size);
1056
1057 if(status != RTW_HAL_STATUS_SUCCESS)
1058 PHL_WARN("%s: BT PG Fail!\n", __FUNCTION__);
1059
1060 /* Reload shadow map after PG */
1061 reload_status = rtw_hal_mac_read_log_efuse_bt_map(efuse_info->hal_com,
1062 efuse_info->bt_shadow_map);
1063 if(reload_status != RTW_HAL_STATUS_SUCCESS)
1064 PHL_WARN("%s: Reload bt shadow map Fail!\n", __FUNCTION__);
1065
1066 /*
1067 * Clear the load external map file flag and map version
1068 * after reloading the map.
1069 */
1070 if(TEST_STATUS_FLAG(efuse_info->status,
1071 EFUSE_STATUS_BT_MAP_FILE_LOADED) == true) {
1072 CLEAR_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_BT_MAP_FILE_LOADED);
1073 }
1074
1075 exit:
1076 return status;
1077 }
1078
1079 enum rtw_hal_status
rtw_efuse_bt_shadow_read(void * efuse,u8 byte_count,u16 offset,u32 * value)1080 rtw_efuse_bt_shadow_read(void *efuse, u8 byte_count, u16 offset, u32 *value)
1081 {
1082 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1083 struct efuse_t *efuse_info = efuse;
1084 u32 efuse_bt_size = 0;
1085
1086 efuse_bt_size = efuse_info->bt_log_efuse_size;
1087
1088 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
1089 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
1090 status = RTW_HAL_STATUS_EFUSE_UNINIT;
1091 goto exit;
1092 }
1093
1094 if((u32)(offset+byte_count) > efuse_bt_size) {
1095 PHL_WARN("%s: Invalid offset!\n", __FUNCTION__);
1096 status = RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
1097 goto exit;
1098 }
1099
1100 if (byte_count == 1)
1101 efuse_bt_shadow_read_one_byte(efuse_info, offset, (u8 *)value);
1102 else if (byte_count == 2)
1103 efuse_bt_shadow_read_two_byte(efuse_info, offset, (u16 *)value);
1104 else if (byte_count == 4)
1105 efuse_bt_shadow_read_four_byte(efuse_info, offset, (u32 *)value);
1106
1107 status = RTW_HAL_STATUS_SUCCESS;
1108 exit:
1109 return status;
1110 }
1111
1112 enum rtw_hal_status
rtw_efuse_bt_shadow_write(void * efuse,u8 byte_count,u16 offset,u32 value)1113 rtw_efuse_bt_shadow_write(void *efuse, u8 byte_count, u16 offset, u32 value)
1114 {
1115 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1116 struct efuse_t *efuse_info = efuse;
1117 u32 efuse_bt_size = 0;
1118
1119 efuse_bt_size = efuse_info->bt_log_efuse_size;
1120
1121 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false) {
1122 PHL_WARN("%s: efuse map not load yet!\n", __FUNCTION__);
1123 status = RTW_HAL_STATUS_EFUSE_UNINIT;
1124 goto exit;
1125 }
1126
1127 if((u32)(offset+byte_count) > efuse_bt_size) {
1128 PHL_WARN("%s: Invalid offset!\n", __FUNCTION__);
1129 status = RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
1130 goto exit;
1131 }
1132
1133 if (byte_count == 1)
1134 efuse_bt_shadow_write_one_byte(efuse_info, offset, (u8)value);
1135 else if (byte_count == 2)
1136 efuse_bt_shadow_write_two_byte(efuse_info, offset, (u16)value);
1137 else if (byte_count == 4)
1138 efuse_bt_shadow_write_four_byte(efuse_info, offset, (u32)value);
1139
1140 status = RTW_HAL_STATUS_SUCCESS;
1141 exit:
1142 return status;
1143 }
1144
1145 /*
1146 * This API is used for original mp dll command.
1147 * usage = used percentage(1 Byte) + used bytes(2 Bytes)
1148 */
rtw_efuse_bt_get_usage(void * efuse,u32 * usage)1149 enum rtw_hal_status rtw_efuse_bt_get_usage(void *efuse, u32 *usage)
1150 {
1151 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1152 struct efuse_t *efuse_info = efuse;
1153 u32 avl_size = 0;
1154 u16 used_byte = 0;
1155 u32 total_size = 0;
1156 u8 used_percentage = 0;
1157
1158 status = rtw_hal_mac_get_efuse_bt_avl(efuse_info->hal_com, &avl_size);
1159 status = rtw_hal_mac_get_efuse_bt_size(efuse_info->hal_com, &total_size);
1160
1161 if(total_size != 0){
1162 used_byte = (u16)(total_size - avl_size);
1163 used_percentage = (u8)(used_byte*100/total_size);
1164 *usage = (used_percentage<<16)|(used_byte);
1165 }
1166
1167 return status;
1168 }
1169
rtw_efuse_bt_shadow2buf(void * efuse,u8 * destbuf,u16 buflen)1170 enum rtw_hal_status rtw_efuse_bt_shadow2buf(void *efuse, u8 *destbuf, u16 buflen)
1171 {
1172 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
1173 struct efuse_t *efuse_info = efuse;
1174
1175 _os_mem_cpy(efuse_info->hal_com->drv_priv, (void *)destbuf,
1176 (void *)efuse_info->bt_shadow_map , buflen);
1177
1178 return status;
1179 }
1180
1181 enum rtw_hal_status
efuse_bt_map_buf2shadow(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)1182 efuse_bt_map_buf2shadow(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
1183 {
1184 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1185
1186 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->bt_shadow_map,
1187 (void *)srcbuf, buflen);
1188 SET_STATUS_FLAG(efuse->status, EFUSE_STATUS_BT_MAP_FILE_LOADED);
1189 status = RTW_HAL_STATUS_SUCCESS;
1190
1191 return status;
1192 }
1193
1194 enum rtw_hal_status
efuse_bt_file_mask2buf(struct efuse_t * efuse,u8 * srcbuf,u16 buflen)1195 efuse_bt_file_mask2buf(struct efuse_t *efuse, u8 *srcbuf, u16 buflen)
1196 {
1197 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1198
1199 _os_mem_cpy(efuse->hal_com->drv_priv, (void *)efuse->bt_mask, (void *)srcbuf,
1200 buflen);
1201 SET_STATUS_FLAG(efuse->status, EFUSE_STATUS_BT_MASK_FILE_LOADED);
1202 status = RTW_HAL_STATUS_SUCCESS;
1203
1204 debug_dump_data(efuse->bt_mask, efuse->bt_mask_size, "[HAL EFUSE] bt mask data =");
1205
1206 return status;
1207 }
1208
1209 enum rtw_hal_status
rtw_efuse_bt_file_map_load(void * efuse,char * file_path)1210 rtw_efuse_bt_file_map_load(void *efuse, char *file_path)
1211 {
1212 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
1213 struct efuse_t *efuse_info = efuse;
1214 void *d = efuse_info->hal_com->drv_priv;
1215 u8 *mapbuf = NULL;
1216 u16 data_len = 0;
1217 u32 bt_map_sz = 0;
1218
1219 bt_map_sz = efuse_info->bt_log_efuse_size;
1220
1221 if (bt_map_sz == 0)
1222 bt_map_sz = MAX_EFUSE_MAP_LEN;
1223
1224 if (file_path) {
1225 mapbuf= _os_mem_alloc(d, bt_map_sz);
1226 if (mapbuf == NULL) {
1227 PHL_INFO("%s, alloc buf FAIL!!\n", __FUNCTION__);
1228 goto exit;
1229 }
1230 _os_mem_set(d, mapbuf, 0xFF, bt_map_sz);
1231
1232 data_len = efuse_file_open(d, file_path, mapbuf, bt_map_sz);
1233
1234 if (data_len <= bt_map_sz) {
1235 PHL_INFO("%s , File eFuse bt map to shadow len %d\n", __FUNCTION__, data_len);
1236 hal_status = efuse_bt_map_buf2shadow(efuse_info, mapbuf, data_len);
1237
1238 } else {
1239 PHL_INFO("Error No bt Map Version !, File Map Data Len %d not over 1024.\n", data_len);
1240 goto exit;
1241 }
1242 }
1243 exit:
1244 if (mapbuf)
1245 _os_mem_free(d, (void*)mapbuf, bt_map_sz);
1246
1247 return hal_status;
1248 }
1249
1250
1251 enum rtw_hal_status
rtw_efuse_bt_file_mask_load(void * efuse,char * file_path)1252 rtw_efuse_bt_file_mask_load(void *efuse, char *file_path)
1253 {
1254 enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
1255 struct efuse_t *efuse_info = efuse;
1256 void *d = efuse_info->hal_com->drv_priv;
1257 u8 *maskbuf = NULL;
1258 u16 data_len = 0;
1259 u32 bt_mask_sz = 0;
1260
1261 bt_mask_sz = efuse_info->bt_mask_size;
1262
1263 if (bt_mask_sz == 0)
1264 goto exit;
1265
1266 if (file_path) {
1267 maskbuf= _os_mem_alloc(d, bt_mask_sz);
1268 if (maskbuf == NULL) {
1269 PHL_INFO("%s, alloc buf FAIL!!\n", __FUNCTION__);
1270 goto exit;
1271 }
1272 _os_mem_set(d, maskbuf, 0xFF, bt_mask_sz);
1273
1274 data_len = efuse_file_open(d, file_path, maskbuf, bt_mask_sz);
1275
1276 if (data_len <= bt_mask_sz) {
1277 PHL_INFO("Mask File data 2 buf len %d\n", data_len);
1278 hal_status = efuse_bt_file_mask2buf(efuse_info, maskbuf, data_len);
1279
1280 } else {
1281 PHL_INFO("Error No Map Version !, File Map Data Len %d not over 96.\n", data_len);
1282 goto exit;
1283 }
1284 }
1285 exit:
1286 if (maskbuf)
1287 _os_mem_free(d, (void*)maskbuf, bt_mask_sz);
1288
1289 return hal_status;
1290 }
1291
rtw_efuse_bt_get_logical_size(void * efuse,u32 * size)1292 enum rtw_hal_status rtw_efuse_bt_get_logical_size(void *efuse, u32 *size)
1293 {
1294 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1295 struct efuse_t *efuse_info = efuse;
1296
1297 status = rtw_hal_mac_get_log_efuse_bt_size(efuse_info->hal_com, size);
1298
1299 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
1300 return status;
1301 }
1302
rtw_efuse_bt_get_size(void * efuse,u32 * size)1303 enum rtw_hal_status rtw_efuse_bt_get_size(void *efuse, u32 *size)
1304 {
1305 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1306 struct efuse_t *efuse_info = efuse;
1307
1308 status = rtw_hal_mac_get_efuse_bt_size(efuse_info->hal_com, size);
1309
1310 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
1311 return status;
1312 }
1313
rtw_efuse_bt_get_avl(void * efuse,u32 * size)1314 enum rtw_hal_status rtw_efuse_bt_get_avl(void *efuse, u32 *size)
1315 {
1316 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1317 struct efuse_t *efuse_info = efuse;
1318
1319 status = rtw_hal_mac_get_efuse_bt_avl(efuse_info->hal_com, size);
1320
1321 PHL_INFO("%s: size = %d\n", __FUNCTION__, *size);
1322 return status;
1323 }
1324
rtw_efuse_bt_get_offset_mask(void * efuse,u16 offset,u8 * mask)1325 enum rtw_hal_status rtw_efuse_bt_get_offset_mask(void *efuse, u16 offset, u8 *mask)
1326 {
1327 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1328 struct efuse_t *efuse_info = efuse;
1329
1330 if(TEST_STATUS_FLAG(efuse_info->status, EFUSE_STATUS_PROCESS) == false)
1331 return RTW_HAL_STATUS_EFUSE_UNINIT;
1332
1333 if(offset >= efuse_info->bt_mask_size)
1334 return RTW_HAL_STATUS_EFUSE_IVALID_OFFSET;
1335
1336 *mask = efuse_info->bt_mask[offset];
1337 PHL_INFO("%s: bt offset = %x mask = %x\n", __FUNCTION__, offset, *mask);
1338 return status;
1339 }
1340
rtw_efuse_bt_get_mask_buf(void * efuse,u8 * destbuf,u32 * buflen)1341 enum rtw_hal_status rtw_efuse_bt_get_mask_buf(void *efuse, u8 *destbuf, u32 *buflen)
1342 {
1343 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1344 struct efuse_t *efuse_info = efuse;
1345
1346 if (efuse_info->bt_mask_size > 0) {
1347 _os_mem_cpy(efuse_info->hal_com->drv_priv, (void *)destbuf,
1348 (void *)efuse_info->bt_mask , efuse_info->bt_mask_size);
1349 *buflen = efuse_info->bt_mask_size;
1350
1351 PHL_INFO("%s: size = %d\n", __FUNCTION__, efuse_info->bt_mask_size);
1352 status = RTW_HAL_STATUS_SUCCESS;
1353 }
1354 return status;
1355 }
1356
rtw_efuse_bt_read_hidden(void * efuse,u32 addr,u32 size,u8 * val)1357 enum rtw_hal_status rtw_efuse_bt_read_hidden(void *efuse, u32 addr, u32 size, u8 *val)
1358 {
1359 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1360 struct efuse_t *efuse_info = efuse;
1361
1362 status = rtw_hal_mac_read_efuse_bt_hidden(efuse_info->hal_com, addr, size, val);
1363
1364 if(status == RTW_HAL_STATUS_SUCCESS)
1365 {
1366 PHL_INFO("%s: bt hidden read ok!\n", __FUNCTION__);
1367 }else{
1368 PHL_INFO("%s: bt hidden read fail!\n", __FUNCTION__);
1369 }
1370
1371 return status;
1372 }
1373
rtw_efuse_bt_write_hidden(void * efuse,u32 addr,u8 val)1374 enum rtw_hal_status rtw_efuse_bt_write_hidden(void *efuse, u32 addr, u8 val)
1375 {
1376 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1377 struct efuse_t *efuse_info = efuse;
1378
1379 status = rtw_hal_mac_write_efuse_bt_hidden(efuse_info->hal_com, addr, val);
1380
1381 if(status == RTW_HAL_STATUS_SUCCESS)
1382 {
1383 PHL_INFO("%s: bt hidden PG ok!\n", __FUNCTION__);
1384 }else{
1385 PHL_INFO("%s: bt hidden PG fail!\n", __FUNCTION__);
1386 }
1387
1388 return status;
1389 }
1390
rtw_efuse_read_phy_wifi(void * efuse,u32 addr,u32 size,u8 * data,u8 type)1391 enum rtw_hal_status rtw_efuse_read_phy_wifi(void *efuse, u32 addr, u32 size, u8 *data, u8 type)
1392 {
1393 enum rtw_hal_status status = RTW_HAL_STATUS_FAILURE;
1394 struct efuse_t *efuse_info = efuse;
1395
1396 if(type == HAL_MP_EFUSE_WIFI)
1397 status = rtw_hal_mac_read_phy_efuse(efuse_info->hal_com, addr, size, data);
1398 else if(type == HAL_MP_EFUSE_BT)
1399 status = rtw_hal_mac_read_bt_phy_efuse(efuse_info->hal_com, addr, size, data);
1400
1401 if(status == RTW_HAL_STATUS_SUCCESS)
1402 {
1403 PHL_INFO("%s: real raw read ok!\n", __FUNCTION__);
1404 }else{
1405 PHL_INFO("%s: real raw read fail!\n", __FUNCTION__);
1406 }
1407
1408 return status;
1409 }
1410
rtw_efuse_renew(void * efuse,u8 type)1411 enum rtw_hal_status rtw_efuse_renew(void *efuse, u8 type)
1412 {
1413 enum rtw_hal_status status = RTW_HAL_STATUS_SUCCESS;
1414 struct efuse_t *efuse_info = efuse;
1415
1416 if (type == HAL_MP_EFUSE_WIFI) {
1417 rtw_hal_bb_get_efuse_init(efuse_info->hal_com);
1418 rtw_hal_rf_get_efuse_ex(efuse_info->hal_com, HW_PHY_MAX);
1419 PHL_INFO("%s: hal efuse renew done\n", __FUNCTION__);
1420
1421 } else if (type == HAL_MP_EFUSE_BT) {
1422 PHL_INFO("%s: Not ready\n", __FUNCTION__);
1423 }
1424
1425 return status;
1426 }
1427