1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 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 #define _RTW_EFUSE_C_
16
17 #include <drv_types.h>
18 #include <hal_data.h>
19
20 #include "../hal/efuse/efuse_mask.h"
21
22 /*------------------------Define local variable------------------------------*/
23 u8 fakeEfuseBank = {0};
24 u32 fakeEfuseUsedBytes = {0};
25 u8 fakeEfuseContent[EFUSE_MAX_HW_SIZE] = {0};
26 u8 fakeEfuseInitMap[EFUSE_MAX_MAP_LEN] = {0};
27 u8 fakeEfuseModifiedMap[EFUSE_MAX_MAP_LEN] = {0};
28
29 u32 BTEfuseUsedBytes = {0};
30 u8 BTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
31 u8 BTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0};
32 u8 BTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0};
33
34 u32 fakeBTEfuseUsedBytes = {0};
35 u8 fakeBTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
36 u8 fakeBTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0};
37 u8 fakeBTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0};
38
39 u8 maskfileBuffer[64];
40 u8 btmaskfileBuffer[64];
41
42 /*------------------------Define local variable------------------------------*/
rtw_file_efuse_IsMasked(PADAPTER pAdapter,u16 Offset,u8 * maskbuf)43 BOOLEAN rtw_file_efuse_IsMasked(PADAPTER pAdapter, u16 Offset, u8 *maskbuf)
44 {
45 int r = Offset / 16;
46 int c = (Offset % 16) / 2;
47 int result = 0;
48
49 if (pAdapter->registrypriv.boffefusemask)
50 return FALSE;
51
52 if (c < 4) /* Upper double word */
53 result = (maskbuf[r] & (0x10 << c));
54 else
55 result = (maskbuf[r] & (0x01 << (c - 4)));
56
57 return (result > 0) ? 0 : 1;
58 }
59
efuse_IsBT_Masked(PADAPTER pAdapter,u16 Offset)60 BOOLEAN efuse_IsBT_Masked(PADAPTER pAdapter, u16 Offset)
61 {
62 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
63
64 if (pAdapter->registrypriv.boffefusemask)
65 return FALSE;
66
67 #ifdef CONFIG_BT_EFUSE_MASK
68 #ifdef CONFIG_RTL8822C
69 #ifdef CONFIG_USB_HCI
70 if (IS_HARDWARE_TYPE_8822C(pAdapter))
71 return (IS_BT_MASKED(8822C, _MUSB, Offset)) ? TRUE : FALSE;
72 #endif
73 #ifdef CONFIG_PCI_HCI
74 if (IS_HARDWARE_TYPE_8822C(pAdapter))
75 return (IS_BT_MASKED(8822C, _MPCIE, Offset)) ? TRUE : FALSE;
76 #endif
77 #ifdef CONFIG_SDIO_HCI
78 if (IS_HARDWARE_TYPE_8822C(pAdapter))
79 return (IS_BT_MASKED(8822C, _MSDIO, Offset)) ? TRUE : FALSE;
80 #endif
81 #endif /*#ifdef CONFIG_RTL8822C*/
82 #ifdef CONFIG_RTL8723F
83 #ifdef CONFIG_USB_HCI
84 if (IS_HARDWARE_TYPE_8723F(pAdapter))
85 return (IS_BT_MASKED(8723F, _MUSB, Offset)) ? TRUE : FALSE;
86 #endif
87 #ifdef CONFIG_SDIO_HCI
88 if (IS_HARDWARE_TYPE_8723F(pAdapter))
89 return (IS_BT_MASKED(8723F, _MSDIO, Offset)) ? TRUE : FALSE;
90 #endif
91 #endif /*#ifdef CONFIG_RTL8723F*/
92 #endif /* CONFIG_BT_EFUSE_MASK */
93 return FALSE;
94 }
95
rtw_bt_efuse_mask_array(PADAPTER pAdapter,u8 * pArray)96 void rtw_bt_efuse_mask_array(PADAPTER pAdapter, u8 *pArray)
97 {
98 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
99
100 #ifdef CONFIG_BT_EFUSE_MASK
101 #ifdef CONFIG_RTL8822C
102 #ifdef CONFIG_USB_HCI
103 if (IS_HARDWARE_TYPE_8822CU(pAdapter))
104 GET_BT_MASK_ARRAY(8822C, _MUSB, pArray);
105 #endif
106 #ifdef CONFIG_PCI_HCI
107 if (IS_HARDWARE_TYPE_8822CE(pAdapter))
108 GET_BT_MASK_ARRAY(8822C, _MPCIE, pArray);
109 #endif
110 #ifdef CONFIG_SDIO_HCI
111 if (IS_HARDWARE_TYPE_8822CS(pAdapter))
112 GET_BT_MASK_ARRAY(8822C, _MSDIO, pArray);
113 #endif
114 #endif /*#ifdef CONFIG_RTL8822C*/
115 #ifdef CONFIG_RTL8723F
116 #ifdef CONFIG_USB_HCI
117 if (IS_HARDWARE_TYPE_8723FU(pAdapter))
118 GET_BT_MASK_ARRAY(8723F, _MUSB, pArray);
119 #endif
120 #ifdef CONFIG_SDIO_HCI
121 if (IS_HARDWARE_TYPE_8723FS(pAdapter))
122 GET_BT_MASK_ARRAY(8723F, _MSDIO, pArray);
123 #endif
124 #endif /*#ifdef CONFIG_RTL8723F*/
125 #endif /* CONFIG_BT_EFUSE_MASK */
126
127 }
128
rtw_get_bt_efuse_mask_arraylen(PADAPTER pAdapter)129 u16 rtw_get_bt_efuse_mask_arraylen(PADAPTER pAdapter)
130 {
131 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);
132
133 #ifdef CONFIG_BT_EFUSE_MASK
134 #ifdef CONFIG_RTL8822C
135 #ifdef CONFIG_USB_HCI
136 if (IS_HARDWARE_TYPE_8822CU(pAdapter))
137 return GET_BT_MASK_ARRAY_LEN(8822C, _MUSB);
138 #endif
139 #ifdef CONFIG_PCI_HCI
140 if (IS_HARDWARE_TYPE_8822CE(pAdapter))
141 return GET_BT_MASK_ARRAY_LEN(8822C, _MPCIE);
142 #endif
143 #ifdef CONFIG_SDIO_HCI
144 if (IS_HARDWARE_TYPE_8822CS(pAdapter))
145 return GET_BT_MASK_ARRAY_LEN(8822C, _MSDIO);
146 #endif
147 #endif /*#ifdef CONFIG_RTL8822C*/
148 #ifdef CONFIG_RTL8723F
149 #ifdef CONFIG_USB_HCI
150 if (IS_HARDWARE_TYPE_8723FU(pAdapter))
151 return GET_BT_MASK_ARRAY_LEN(8723F, _MUSB);
152 #endif
153 #ifdef CONFIG_SDIO_HCI
154 if (IS_HARDWARE_TYPE_8723FS(pAdapter))
155 return GET_BT_MASK_ARRAY_LEN(8723F, _MSDIO);
156 #endif
157 #endif /*CONFIG_RTL8723F*/
158 #endif /* CONFIG_BT_EFUSE_MASK */
159
160 return 0;
161 }
162
efuse_IsMasked(PADAPTER pAdapter,u16 Offset)163 BOOLEAN efuse_IsMasked(PADAPTER pAdapter, u16 Offset)
164 {
165
166 if (pAdapter->registrypriv.boffefusemask)
167 return FALSE;
168
169 #ifdef CONFIG_USB_HCI
170 #if defined(CONFIG_RTL8188E)
171 if (IS_HARDWARE_TYPE_8188E(pAdapter))
172 return (IS_MASKED(8188E, _MUSB, Offset)) ? TRUE : FALSE;
173 #endif
174 #if defined(CONFIG_RTL8812A)
175 if (IS_HARDWARE_TYPE_8812(pAdapter))
176 return (IS_MASKED(8812A, _MUSB, Offset)) ? TRUE : FALSE;
177 #endif
178 #if defined(CONFIG_RTL8821A)
179 #if 0
180 if (IS_HARDWARE_TYPE_8811AU(pAdapter))
181 return (IS_MASKED(8811A, _MUSB, Offset)) ? TRUE : FALSE;
182 #endif
183 if (IS_HARDWARE_TYPE_8821(pAdapter))
184 return (IS_MASKED(8821A, _MUSB, Offset)) ? TRUE : FALSE;
185 #endif
186 #if defined(CONFIG_RTL8192E)
187 if (IS_HARDWARE_TYPE_8192E(pAdapter))
188 return (IS_MASKED(8192E, _MUSB, Offset)) ? TRUE : FALSE;
189 #endif
190 #if defined(CONFIG_RTL8723B)
191 if (IS_HARDWARE_TYPE_8723B(pAdapter))
192 return (IS_MASKED(8723B, _MUSB, Offset)) ? TRUE : FALSE;
193 #endif
194 #if defined(CONFIG_RTL8703B)
195 if (IS_HARDWARE_TYPE_8703B(pAdapter))
196 return (IS_MASKED(8703B, _MUSB, Offset)) ? TRUE : FALSE;
197 #endif
198 #if defined(CONFIG_RTL8814A)
199 if (IS_HARDWARE_TYPE_8814A(pAdapter))
200 return (IS_MASKED(8814A, _MUSB, Offset)) ? TRUE : FALSE;
201 #endif
202 #if defined(CONFIG_RTL8188F)
203 if (IS_HARDWARE_TYPE_8188F(pAdapter))
204 return (IS_MASKED(8188F, _MUSB, Offset)) ? TRUE : FALSE;
205 #endif
206 #if defined(CONFIG_RTL8188GTV)
207 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
208 return (IS_MASKED(8188GTV, _MUSB, Offset)) ? TRUE : FALSE;
209 #endif
210 #if defined(CONFIG_RTL8822B)
211 if (IS_HARDWARE_TYPE_8822B(pAdapter))
212 return (IS_MASKED(8822B, _MUSB, Offset)) ? TRUE : FALSE;
213 #endif
214 #if defined(CONFIG_RTL8723D)
215 if (IS_HARDWARE_TYPE_8723D(pAdapter))
216 return (IS_MASKED(8723D, _MUSB, Offset)) ? TRUE : FALSE;
217 #endif
218 #if defined(CONFIG_RTL8710B)
219 if (IS_HARDWARE_TYPE_8710B(pAdapter))
220 return (IS_MASKED(8710B, _MUSB, Offset)) ? TRUE : FALSE;
221 #endif
222 #if defined(CONFIG_RTL8821C)
223 if (IS_HARDWARE_TYPE_8821CU(pAdapter))
224 return (IS_MASKED(8821C, _MUSB, Offset)) ? TRUE : FALSE;
225 #endif
226
227 #if defined(CONFIG_RTL8192F)
228 if (IS_HARDWARE_TYPE_8192FU(pAdapter))
229 return (IS_MASKED(8192F, _MUSB, Offset)) ? TRUE : FALSE;
230 #endif
231 #if defined(CONFIG_RTL8822C)
232 if (IS_HARDWARE_TYPE_8822C(pAdapter))
233 return (IS_MASKED(8822C, _MUSB, Offset)) ? TRUE : FALSE;
234 #endif
235 #if defined(CONFIG_RTL8814B)
236 if (IS_HARDWARE_TYPE_8814B(pAdapter))
237 return (IS_MASKED(8814B, _MUSB, Offset)) ? TRUE : FALSE;
238 #endif
239 #if defined(CONFIG_RTL8723F)
240 if (IS_HARDWARE_TYPE_8723F(pAdapter))
241 return (IS_MASKED(8723F, _MUSB, Offset)) ? TRUE : FALSE;
242 #endif
243 #endif /*CONFIG_USB_HCI*/
244
245 #ifdef CONFIG_PCI_HCI
246 #if defined(CONFIG_RTL8188E)
247 if (IS_HARDWARE_TYPE_8188E(pAdapter))
248 return (IS_MASKED(8188E, _MPCIE, Offset)) ? TRUE : FALSE;
249 #endif
250 #if defined(CONFIG_RTL8192E)
251 if (IS_HARDWARE_TYPE_8192E(pAdapter))
252 return (IS_MASKED(8192E, _MPCIE, Offset)) ? TRUE : FALSE;
253 #endif
254 #if defined(CONFIG_RTL8812A)
255 if (IS_HARDWARE_TYPE_8812(pAdapter))
256 return (IS_MASKED(8812A, _MPCIE, Offset)) ? TRUE : FALSE;
257 #endif
258 #if defined(CONFIG_RTL8821A)
259 if (IS_HARDWARE_TYPE_8821(pAdapter))
260 return (IS_MASKED(8821A, _MPCIE, Offset)) ? TRUE : FALSE;
261 #endif
262 #if defined(CONFIG_RTL8723B)
263 if (IS_HARDWARE_TYPE_8723B(pAdapter))
264 return (IS_MASKED(8723B, _MPCIE, Offset)) ? TRUE : FALSE;
265 #endif
266 #if defined(CONFIG_RTL8814A)
267 if (IS_HARDWARE_TYPE_8814A(pAdapter))
268 return (IS_MASKED(8814A, _MPCIE, Offset)) ? TRUE : FALSE;
269 #endif
270 #if defined(CONFIG_RTL8822B)
271 if (IS_HARDWARE_TYPE_8822B(pAdapter))
272 return (IS_MASKED(8822B, _MPCIE, Offset)) ? TRUE : FALSE;
273 #endif
274 #if defined(CONFIG_RTL8821C)
275 if (IS_HARDWARE_TYPE_8821CE(pAdapter))
276 return (IS_MASKED(8821C, _MPCIE, Offset)) ? TRUE : FALSE;
277 #endif
278
279 #if defined(CONFIG_RTL8192F)
280 if (IS_HARDWARE_TYPE_8192FE(pAdapter))
281 return (IS_MASKED(8192F, _MPCIE, Offset)) ? TRUE : FALSE;
282 #endif
283 #if defined(CONFIG_RTL8822C)
284 if (IS_HARDWARE_TYPE_8822C(pAdapter))
285 return (IS_MASKED(8822C, _MPCIE, Offset)) ? TRUE : FALSE;
286 #endif
287 #if defined(CONFIG_RTL8814B)
288 if (IS_HARDWARE_TYPE_8814B(pAdapter))
289 return (IS_MASKED(8814B, _MPCIE, Offset)) ? TRUE : FALSE;
290 #endif
291 #endif /*CONFIG_PCI_HCI*/
292
293 #ifdef CONFIG_SDIO_HCI
294 #ifdef CONFIG_RTL8188E_SDIO
295 if (IS_HARDWARE_TYPE_8188E(pAdapter))
296 return (IS_MASKED(8188E, _MSDIO, Offset)) ? TRUE : FALSE;
297 #endif
298 #ifdef CONFIG_RTL8723B
299 if (IS_HARDWARE_TYPE_8723BS(pAdapter))
300 return (IS_MASKED(8723B, _MSDIO, Offset)) ? TRUE : FALSE;
301 #endif
302 #ifdef CONFIG_RTL8188F
303 if (IS_HARDWARE_TYPE_8188F(pAdapter))
304 return (IS_MASKED(8188F, _MSDIO, Offset)) ? TRUE : FALSE;
305 #endif
306 #ifdef CONFIG_RTL8188GTV
307 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
308 return (IS_MASKED(8188GTV, _MSDIO, Offset)) ? TRUE : FALSE;
309 #endif
310 #ifdef CONFIG_RTL8192E
311 if (IS_HARDWARE_TYPE_8192ES(pAdapter))
312 return (IS_MASKED(8192E, _MSDIO, Offset)) ? TRUE : FALSE;
313 #endif
314 #if defined(CONFIG_RTL8821A)
315 if (IS_HARDWARE_TYPE_8821S(pAdapter))
316 return (IS_MASKED(8821A, _MSDIO, Offset)) ? TRUE : FALSE;
317 #endif
318 #if defined(CONFIG_RTL8821C)
319 if (IS_HARDWARE_TYPE_8821CS(pAdapter))
320 return (IS_MASKED(8821C, _MSDIO, Offset)) ? TRUE : FALSE;
321 #endif
322 #if defined(CONFIG_RTL8822B)
323 if (IS_HARDWARE_TYPE_8822B(pAdapter))
324 return (IS_MASKED(8822B, _MSDIO, Offset)) ? TRUE : FALSE;
325 #endif
326 #if defined(CONFIG_RTL8192F)
327 if (IS_HARDWARE_TYPE_8192FS(pAdapter))
328 return (IS_MASKED(8192F, _MSDIO, Offset)) ? TRUE : FALSE;
329 #endif
330 #if defined(CONFIG_RTL8822C)
331 if (IS_HARDWARE_TYPE_8822C(pAdapter))
332 return (IS_MASKED(8822C, _MSDIO, Offset)) ? TRUE : FALSE;
333 #endif
334 #if defined(CONFIG_RTL8723F)
335 if (IS_HARDWARE_TYPE_8723F(pAdapter))
336 return (IS_MASKED(8723F, _MSDIO, Offset)) ? TRUE : FALSE;
337 #endif
338 #endif /*CONFIG_SDIO_HCI*/
339
340 return FALSE;
341 }
342
rtw_efuse_mask_array(PADAPTER pAdapter,u8 * pArray)343 void rtw_efuse_mask_array(PADAPTER pAdapter, u8 *pArray)
344 {
345
346 #ifdef CONFIG_USB_HCI
347 #if defined(CONFIG_RTL8188E)
348 if (IS_HARDWARE_TYPE_8188E(pAdapter))
349 GET_MASK_ARRAY(8188E, _MUSB, pArray);
350 #endif
351 #if defined(CONFIG_RTL8812A)
352 if (IS_HARDWARE_TYPE_8812(pAdapter))
353 GET_MASK_ARRAY(8812A, _MUSB, pArray);
354 #endif
355 #if defined(CONFIG_RTL8821A)
356 if (IS_HARDWARE_TYPE_8821(pAdapter))
357 GET_MASK_ARRAY(8821A, _MUSB, pArray);
358 #endif
359 #if defined(CONFIG_RTL8192E)
360 if (IS_HARDWARE_TYPE_8192E(pAdapter))
361 GET_MASK_ARRAY(8192E, _MUSB, pArray);
362 #endif
363 #if defined(CONFIG_RTL8723B)
364 if (IS_HARDWARE_TYPE_8723B(pAdapter))
365 GET_MASK_ARRAY(8723B, _MUSB, pArray);
366 #endif
367 #if defined(CONFIG_RTL8703B)
368 if (IS_HARDWARE_TYPE_8703B(pAdapter))
369 GET_MASK_ARRAY(8703B, _MUSB, pArray);
370 #endif
371 #if defined(CONFIG_RTL8188F)
372 if (IS_HARDWARE_TYPE_8188F(pAdapter))
373 GET_MASK_ARRAY(8188F, _MUSB, pArray);
374 #endif
375 #if defined(CONFIG_RTL8188GTV)
376 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
377 GET_MASK_ARRAY(8188GTV, _MUSB, pArray);
378 #endif
379 #if defined(CONFIG_RTL8814A)
380 if (IS_HARDWARE_TYPE_8814A(pAdapter))
381 GET_MASK_ARRAY(8814A, _MUSB, pArray);
382 #endif
383 #if defined(CONFIG_RTL8822B)
384 if (IS_HARDWARE_TYPE_8822B(pAdapter))
385 GET_MASK_ARRAY(8822B, _MUSB, pArray);
386 #endif
387 #if defined(CONFIG_RTL8821C)
388 if (IS_HARDWARE_TYPE_8821CU(pAdapter))
389 GET_MASK_ARRAY(8821C, _MUSB, pArray);
390 #endif
391 #if defined(CONFIG_RTL8192F)
392 if (IS_HARDWARE_TYPE_8192FU(pAdapter))
393 GET_MASK_ARRAY(8192F, _MUSB, pArray);
394 #endif
395 #if defined(CONFIG_RTL8822C)
396 if (IS_HARDWARE_TYPE_8822C(pAdapter))
397 GET_MASK_ARRAY(8822C, _MUSB, pArray);
398 #endif
399 #if defined(CONFIG_RTL8814B)
400 if (IS_HARDWARE_TYPE_8814B(pAdapter))
401 GET_MASK_ARRAY(8814B, _MUSB, pArray);
402 #endif
403 #if defined(CONFIG_RTL8723F)
404 if (IS_HARDWARE_TYPE_8723F(pAdapter))
405 GET_MASK_ARRAY(8723F, _MUSB, pArray);
406 #endif
407 #endif /*CONFIG_USB_HCI*/
408
409 #ifdef CONFIG_PCI_HCI
410 #if defined(CONFIG_RTL8188E)
411 if (IS_HARDWARE_TYPE_8188E(pAdapter))
412 GET_MASK_ARRAY(8188E, _MPCIE, pArray);
413 #endif
414 #if defined(CONFIG_RTL8192E)
415 if (IS_HARDWARE_TYPE_8192E(pAdapter))
416 GET_MASK_ARRAY(8192E, _MPCIE, pArray);
417 #endif
418 #if defined(CONFIG_RTL8812A)
419 if (IS_HARDWARE_TYPE_8812(pAdapter))
420 GET_MASK_ARRAY(8812A, _MPCIE, pArray);
421 #endif
422 #if defined(CONFIG_RTL8821A)
423 if (IS_HARDWARE_TYPE_8821(pAdapter))
424 GET_MASK_ARRAY(8821A, _MPCIE, pArray);
425 #endif
426 #if defined(CONFIG_RTL8723B)
427 if (IS_HARDWARE_TYPE_8723B(pAdapter))
428 GET_MASK_ARRAY(8723B, _MPCIE, pArray);
429 #endif
430 #if defined(CONFIG_RTL8814A)
431 if (IS_HARDWARE_TYPE_8814A(pAdapter))
432 GET_MASK_ARRAY(8814A, _MPCIE, pArray);
433 #endif
434 #if defined(CONFIG_RTL8822B)
435 if (IS_HARDWARE_TYPE_8822B(pAdapter))
436 GET_MASK_ARRAY(8822B, _MPCIE, pArray);
437 #endif
438 #if defined(CONFIG_RTL8821C)
439 if (IS_HARDWARE_TYPE_8821CE(pAdapter))
440 GET_MASK_ARRAY(8821C, _MPCIE, pArray);
441 #endif
442 #if defined(CONFIG_RTL8192F)
443 if (IS_HARDWARE_TYPE_8192FE(pAdapter))
444 GET_MASK_ARRAY(8192F, _MPCIE, pArray);
445 #endif
446 #if defined(CONFIG_RTL8822C)
447 if (IS_HARDWARE_TYPE_8822C(pAdapter))
448 GET_MASK_ARRAY(8822C, _MPCIE, pArray);
449 #endif
450 #if defined(CONFIG_RTL8814B)
451 if (IS_HARDWARE_TYPE_8814B(pAdapter))
452 GET_MASK_ARRAY(8814B, _MPCIE, pArray);
453 #endif
454 #endif /*CONFIG_PCI_HCI*/
455
456 #ifdef CONFIG_SDIO_HCI
457 #if defined(CONFIG_RTL8188E)
458 if (IS_HARDWARE_TYPE_8188E(pAdapter))
459 GET_MASK_ARRAY(8188E, _MSDIO, pArray);
460 #endif
461 #if defined(CONFIG_RTL8723B)
462 if (IS_HARDWARE_TYPE_8723BS(pAdapter))
463 GET_MASK_ARRAY(8723B, _MSDIO, pArray);
464 #endif
465 #if defined(CONFIG_RTL8188F)
466 if (IS_HARDWARE_TYPE_8188F(pAdapter))
467 GET_MASK_ARRAY(8188F, _MSDIO, pArray);
468 #endif
469 #if defined(CONFIG_RTL8188GTV)
470 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
471 GET_MASK_ARRAY(8188GTV, _MSDIO, pArray);
472 #endif
473 #if defined(CONFIG_RTL8192E)
474 if (IS_HARDWARE_TYPE_8192ES(pAdapter))
475 GET_MASK_ARRAY(8192E, _MSDIO, pArray);
476 #endif
477 #if defined(CONFIG_RTL8821A)
478 if (IS_HARDWARE_TYPE_8821S(pAdapter))
479 GET_MASK_ARRAY(8821A, _MSDIO, pArray);
480 #endif
481 #if defined(CONFIG_RTL8821C)
482 if (IS_HARDWARE_TYPE_8821CS(pAdapter))
483 GET_MASK_ARRAY(8821C , _MSDIO, pArray);
484 #endif
485 #if defined(CONFIG_RTL8822B)
486 if (IS_HARDWARE_TYPE_8822B(pAdapter))
487 GET_MASK_ARRAY(8822B , _MSDIO, pArray);
488 #endif
489 #if defined(CONFIG_RTL8192F)
490 if (IS_HARDWARE_TYPE_8192FS(pAdapter))
491 GET_MASK_ARRAY(8192F, _MSDIO, pArray);
492 #endif
493 #if defined(CONFIG_RTL8822C)
494 if (IS_HARDWARE_TYPE_8822C(pAdapter))
495 GET_MASK_ARRAY(8822C , _MSDIO, pArray);
496 #endif
497 #if defined(CONFIG_RTL8723F)
498 if (IS_HARDWARE_TYPE_8723F(pAdapter))
499 GET_MASK_ARRAY(8723F, _MSDIO, pArray);
500 #endif
501 #endif /*CONFIG_SDIO_HCI*/
502 }
503
rtw_get_efuse_mask_arraylen(PADAPTER pAdapter)504 u16 rtw_get_efuse_mask_arraylen(PADAPTER pAdapter)
505 {
506
507 #ifdef CONFIG_USB_HCI
508 #if defined(CONFIG_RTL8188E)
509 if (IS_HARDWARE_TYPE_8188E(pAdapter))
510 return GET_MASK_ARRAY_LEN(8188E, _MUSB);
511 #endif
512 #if defined(CONFIG_RTL8812A)
513 if (IS_HARDWARE_TYPE_8812(pAdapter))
514 return GET_MASK_ARRAY_LEN(8812A, _MUSB);
515 #endif
516 #if defined(CONFIG_RTL8821A)
517 if (IS_HARDWARE_TYPE_8821(pAdapter))
518 return GET_MASK_ARRAY_LEN(8821A, _MUSB);
519 #endif
520 #if defined(CONFIG_RTL8192E)
521 if (IS_HARDWARE_TYPE_8192E(pAdapter))
522 return GET_MASK_ARRAY_LEN(8192E, _MUSB);
523 #endif
524 #if defined(CONFIG_RTL8723B)
525 if (IS_HARDWARE_TYPE_8723B(pAdapter))
526 return GET_MASK_ARRAY_LEN(8723B, _MUSB);
527 #endif
528 #if defined(CONFIG_RTL8703B)
529 if (IS_HARDWARE_TYPE_8703B(pAdapter))
530 return GET_MASK_ARRAY_LEN(8703B, _MUSB);
531 #endif
532 #if defined(CONFIG_RTL8188F)
533 if (IS_HARDWARE_TYPE_8188F(pAdapter))
534 return GET_MASK_ARRAY_LEN(8188F, _MUSB);
535 #endif
536 #if defined(CONFIG_RTL8188GTV)
537 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
538 return GET_MASK_ARRAY_LEN(8188GTV, _MUSB);
539 #endif
540 #if defined(CONFIG_RTL8814A)
541 if (IS_HARDWARE_TYPE_8814A(pAdapter))
542 return GET_MASK_ARRAY_LEN(8814A, _MUSB);
543 #endif
544 #if defined(CONFIG_RTL8822B)
545 if (IS_HARDWARE_TYPE_8822B(pAdapter))
546 return GET_MASK_ARRAY_LEN(8822B, _MUSB);
547 #endif
548 #if defined(CONFIG_RTL8821C)
549 if (IS_HARDWARE_TYPE_8821CU(pAdapter))
550 return GET_MASK_ARRAY_LEN(8821C, _MUSB);
551 #endif
552 #if defined(CONFIG_RTL8192F)
553 if (IS_HARDWARE_TYPE_8192FU(pAdapter))
554 return GET_MASK_ARRAY_LEN(8192F, _MUSB);
555 #endif
556 #if defined(CONFIG_RTL8822C)
557 if (IS_HARDWARE_TYPE_8822C(pAdapter))
558 return GET_MASK_ARRAY_LEN(8822C, _MUSB);
559 #endif
560 #if defined(CONFIG_RTL8814B)
561 if (IS_HARDWARE_TYPE_8814B(pAdapter)) {
562 return GET_MASK_ARRAY_LEN(8814B, _MUSB);
563 }
564 #endif
565 #if defined(CONFIG_RTL8723F)
566 if (IS_HARDWARE_TYPE_8723F(pAdapter))
567 return GET_MASK_ARRAY_LEN(8723F, _MUSB);
568 #endif
569 #endif /*CONFIG_USB_HCI*/
570
571 #ifdef CONFIG_PCI_HCI
572 #if defined(CONFIG_RTL8188E)
573 if (IS_HARDWARE_TYPE_8188E(pAdapter))
574 return GET_MASK_ARRAY_LEN(8188E, _MPCIE);
575 #endif
576 #if defined(CONFIG_RTL8192E)
577 if (IS_HARDWARE_TYPE_8192E(pAdapter))
578 return GET_MASK_ARRAY_LEN(8192E, _MPCIE);
579 #endif
580 #if defined(CONFIG_RTL8812A)
581 if (IS_HARDWARE_TYPE_8812(pAdapter))
582 return GET_MASK_ARRAY_LEN(8812A, _MPCIE);
583 #endif
584 #if defined(CONFIG_RTL8821A)
585 if (IS_HARDWARE_TYPE_8821(pAdapter))
586 return GET_MASK_ARRAY_LEN(8821A, _MPCIE);
587 #endif
588 #if defined(CONFIG_RTL8723B)
589 if (IS_HARDWARE_TYPE_8723B(pAdapter))
590 return GET_MASK_ARRAY_LEN(8723B, _MPCIE);
591 #endif
592 #if defined(CONFIG_RTL8814A)
593 if (IS_HARDWARE_TYPE_8814A(pAdapter))
594 return GET_MASK_ARRAY_LEN(8814A, _MPCIE);
595 #endif
596 #if defined(CONFIG_RTL8822B)
597 if (IS_HARDWARE_TYPE_8822B(pAdapter))
598 return GET_MASK_ARRAY_LEN(8822B, _MPCIE);
599 #endif
600 #if defined(CONFIG_RTL8821C)
601 if (IS_HARDWARE_TYPE_8821CE(pAdapter))
602 return GET_MASK_ARRAY_LEN(8821C, _MPCIE);
603 #endif
604 #if defined(CONFIG_RTL8192F)
605 if (IS_HARDWARE_TYPE_8192FE(pAdapter))
606 return GET_MASK_ARRAY_LEN(8192F, _MPCIE);
607 #endif
608 #if defined(CONFIG_RTL8822C)
609 if (IS_HARDWARE_TYPE_8822C(pAdapter))
610 return GET_MASK_ARRAY_LEN(8822C, _MPCIE);
611 #endif
612 #if defined(CONFIG_RTL8814B)
613 if (IS_HARDWARE_TYPE_8814B(pAdapter))
614 return GET_MASK_ARRAY_LEN(8814B, _MPCIE);
615 #endif
616 #endif /*CONFIG_PCI_HCI*/
617
618 #ifdef CONFIG_SDIO_HCI
619 #if defined(CONFIG_RTL8188E)
620 if (IS_HARDWARE_TYPE_8188E(pAdapter))
621 return GET_MASK_ARRAY_LEN(8188E, _MSDIO);
622 #endif
623 #if defined(CONFIG_RTL8723B)
624 if (IS_HARDWARE_TYPE_8723BS(pAdapter))
625 return GET_MASK_ARRAY_LEN(8723B, _MSDIO);
626 #endif
627 #if defined(CONFIG_RTL8188F)
628 if (IS_HARDWARE_TYPE_8188F(pAdapter))
629 return GET_MASK_ARRAY_LEN(8188F, _MSDIO);
630 #endif
631 #if defined(CONFIG_RTL8188GTV)
632 if (IS_HARDWARE_TYPE_8188GTV(pAdapter))
633 return GET_MASK_ARRAY_LEN(8188GTV, _MSDIO);
634 #endif
635 #if defined(CONFIG_RTL8192E)
636 if (IS_HARDWARE_TYPE_8192ES(pAdapter))
637 return GET_MASK_ARRAY_LEN(8192E, _MSDIO);
638 #endif
639 #if defined(CONFIG_RTL8821A)
640 if (IS_HARDWARE_TYPE_8821S(pAdapter))
641 return GET_MASK_ARRAY_LEN(8821A, _MSDIO);
642 #endif
643 #if defined(CONFIG_RTL8821C)
644 if (IS_HARDWARE_TYPE_8821CS(pAdapter))
645 return GET_MASK_ARRAY_LEN(8821C, _MSDIO);
646 #endif
647 #if defined(CONFIG_RTL8822B)
648 if (IS_HARDWARE_TYPE_8822B(pAdapter))
649 return GET_MASK_ARRAY_LEN(8822B, _MSDIO);
650 #endif
651 #if defined(CONFIG_RTL8192F)
652 if (IS_HARDWARE_TYPE_8192FS(pAdapter))
653 return GET_MASK_ARRAY_LEN(8192F, _MSDIO);
654 #endif
655 #if defined(CONFIG_RTL8822C)
656 if (IS_HARDWARE_TYPE_8822C(pAdapter))
657 return GET_MASK_ARRAY_LEN(8822C, _MSDIO);
658 #endif
659 #if defined(CONFIG_RTL8723F)
660 if (IS_HARDWARE_TYPE_8723F(pAdapter))
661 return GET_MASK_ARRAY_LEN(8723F, _MSDIO);
662 #endif
663 #endif/*CONFIG_SDIO_HCI*/
664 return 0;
665 }
666
rtw_mask_map_read(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)667 static void rtw_mask_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
668 {
669 u16 i = 0;
670
671 if (padapter->registrypriv.boffefusemask == 0) {
672 for (i = 0; i < cnts; i++) {
673 if (padapter->registrypriv.bFileMaskEfuse == _TRUE) {
674 if (rtw_file_efuse_IsMasked(padapter, addr + i, maskfileBuffer)) /*use file efuse mask.*/
675 data[i] = 0xff;
676 else
677 RTW_DBG("data[%x] = %x\n", i, data[i]);
678 } else {
679 if (efuse_IsMasked(padapter, addr + i))
680 data[i] = 0xff;
681 else
682 RTW_DBG("data[%x] = %x\n", i, data[i]);
683 }
684 }
685 }
686 }
687
rtw_efuse_mask_map_read(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)688 u8 rtw_efuse_mask_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
689 {
690 u8 ret = _SUCCESS;
691 u16 mapLen = 0;
692
693 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
694
695 ret = rtw_efuse_map_read(padapter, addr, cnts , data);
696
697 rtw_mask_map_read(padapter, addr, cnts , data);
698
699 return ret;
700
701 }
702
703 /* ***********************************************************
704 * Efuse related code
705 * *********************************************************** */
hal_EfuseSwitchToBank(PADAPTER padapter,u8 bank,u8 bPseudoTest)706 static u8 hal_EfuseSwitchToBank(
707 PADAPTER padapter,
708 u8 bank,
709 u8 bPseudoTest)
710 {
711 u8 bRet = _FALSE;
712 u32 value32 = 0;
713 #ifdef HAL_EFUSE_MEMORY
714 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
715 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
716 #endif
717
718
719 RTW_INFO("%s: Efuse switch bank to %d\n", __FUNCTION__, bank);
720 if (bPseudoTest) {
721 #ifdef HAL_EFUSE_MEMORY
722 pEfuseHal->fakeEfuseBank = bank;
723 #else
724 fakeEfuseBank = bank;
725 #endif
726 bRet = _TRUE;
727 } else {
728 value32 = rtw_read32(padapter, 0x34);
729 bRet = _TRUE;
730 switch (bank) {
731 case 0:
732 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
733 break;
734 case 1:
735 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_0);
736 break;
737 case 2:
738 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_1);
739 break;
740 case 3:
741 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_2);
742 break;
743 default:
744 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
745 bRet = _FALSE;
746 break;
747 }
748 rtw_write32(padapter, 0x34, value32);
749 }
750
751 return bRet;
752 }
753
rtw_efuse_analyze(PADAPTER padapter,u8 Type,u8 Fake)754 void rtw_efuse_analyze(PADAPTER padapter, u8 Type, u8 Fake)
755 {
756 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
757 PEFUSE_HAL pEfuseHal = &(pHalData->EfuseHal);
758 u16 eFuse_Addr = 0;
759 u8 offset, wden;
760 u16 i, j;
761 u8 efuseHeader = 0, efuseExtHdr = 0, efuseData[EFUSE_MAX_WORD_UNIT*2] = {0}, dataCnt = 0;
762 u16 efuseHeader2Byte = 0;
763 u8 *eFuseWord = NULL;// [EFUSE_MAX_SECTION_NUM][EFUSE_MAX_WORD_UNIT];
764 u8 offset_2_0 = 0;
765 u8 pgSectionCnt = 0;
766 u8 wd_cnt = 0;
767 u8 max_section = 64;
768 u16 mapLen = 0, maprawlen = 0;
769 boolean bExtHeader = _FALSE;
770 u8 efuseType = EFUSE_WIFI;
771 boolean bPseudoTest = _FALSE;
772 u8 bank = 0, startBank = 0, endBank = 1-1;
773 boolean bCheckNextBank = FALSE;
774 u8 protectBytesBank = 0;
775 u16 efuse_max = 0;
776 u8 ParseEfuseExtHdr, ParseEfuseHeader, ParseOffset, ParseWDEN, ParseOffset2_0;
777
778 eFuseWord = rtw_zmalloc(EFUSE_MAX_SECTION_NUM * (EFUSE_MAX_WORD_UNIT * 2));
779
780 if (eFuseWord == NULL) {
781 RTW_INFO("%s:rtw_zmalloc eFuseWord = NULL !!\n", __func__);
782 return;
783 }
784
785 RTW_INFO("\n");
786 if (Type == 0) {
787 if (Fake == 0) {
788 RTW_INFO("\n\tEFUSE_Analyze Wifi Content\n");
789 efuseType = EFUSE_WIFI;
790 bPseudoTest = FALSE;
791 startBank = 0;
792 endBank = 0;
793 } else {
794 RTW_INFO("\n\tEFUSE_Analyze Wifi Pseudo Content\n");
795 efuseType = EFUSE_WIFI;
796 bPseudoTest = TRUE;
797 startBank = 0;
798 endBank = 0;
799 }
800 } else {
801 if (Fake == 0) {
802 RTW_INFO("\n\tEFUSE_Analyze BT Content\n");
803 efuseType = EFUSE_BT;
804 bPseudoTest = FALSE;
805 startBank = 1;
806 endBank = EFUSE_MAX_BANK - 1;
807 } else {
808 RTW_INFO("\n\tEFUSE_Analyze BT Pseudo Content\n");
809 efuseType = EFUSE_BT;
810 bPseudoTest = TRUE;
811 startBank = 1;
812 endBank = EFUSE_MAX_BANK - 1;
813 if (IS_HARDWARE_TYPE_8821(padapter))
814 endBank = 3 - 1;/*EFUSE_MAX_BANK_8821A - 1;*/
815 }
816 }
817
818 RTW_INFO("\n\r 1Byte header, [7:4]=offset, [3:0]=word enable\n");
819 RTW_INFO("\n\r 2Byte header, header[7:5]=offset[2:0], header[4:0]=0x0F\n");
820 RTW_INFO("\n\r 2Byte header, extHeader[7:4]=offset[6:3], extHeader[3:0]=word enable\n");
821
822 EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
823 EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_MAX_SECTION, (void *)&max_section, bPseudoTest);
824 EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_PROTECT_BYTES_BANK, (void *)&protectBytesBank, bPseudoTest);
825 EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_CONTENT_LEN_BANK, (void *)&efuse_max, bPseudoTest);
826 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_REAL_CONTENT_LEN, (void *)&maprawlen, _FALSE);
827
828 _rtw_memset(eFuseWord, 0xff, EFUSE_MAX_SECTION_NUM * (EFUSE_MAX_WORD_UNIT * 2));
829 _rtw_memset(pEfuseHal->fakeEfuseInitMap, 0xff, EFUSE_MAX_MAP_LEN);
830
831 if (IS_HARDWARE_TYPE_8821(padapter))
832 endBank = 3 - 1;/*EFUSE_MAX_BANK_8821A - 1;*/
833
834 for (bank = startBank; bank <= endBank; bank++) {
835 if (!hal_EfuseSwitchToBank(padapter, bank, bPseudoTest)) {
836 RTW_INFO("EFUSE_SwitchToBank() Fail!!\n");
837 goto out_free_buffer;
838 }
839
840 eFuse_Addr = bank * EFUSE_MAX_BANK_SIZE;
841
842 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest);
843
844 if (efuseHeader == 0xFF && bank == startBank && Fake != TRUE) {
845 RTW_INFO("Non-PGed Efuse\n");
846 goto out_free_buffer;
847 }
848 RTW_INFO("EFUSE_REAL_CONTENT_LEN = %d\n", maprawlen);
849
850 while ((efuseHeader != 0xFF) && ((efuseType == EFUSE_WIFI && (eFuse_Addr < maprawlen)) || (efuseType == EFUSE_BT && (eFuse_Addr < (endBank + 1) * EFUSE_MAX_BANK_SIZE)))) {
851
852 RTW_INFO("Analyzing: Offset: 0x%X\n", eFuse_Addr);
853
854 /* Check PG header for section num.*/
855 if (EXT_HEADER(efuseHeader)) {
856 bExtHeader = TRUE;
857 offset_2_0 = GET_HDR_OFFSET_2_0(efuseHeader);
858 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseExtHdr, bPseudoTest);
859
860 if (efuseExtHdr != 0xff) {
861 if (ALL_WORDS_DISABLED(efuseExtHdr)) {
862 /* Read next pg header*/
863 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest);
864 continue;
865 } else {
866 offset = ((efuseExtHdr & 0xF0) >> 1) | offset_2_0;
867 wden = (efuseExtHdr & 0x0F);
868 efuseHeader2Byte = (efuseExtHdr<<8)|efuseHeader;
869 RTW_INFO("Find efuseHeader2Byte = 0x%04X, offset=%d, wden=0x%x\n",
870 efuseHeader2Byte, offset, wden);
871 }
872 } else {
873 RTW_INFO("Error, efuse[%d]=0xff, efuseExtHdr=0xff\n", eFuse_Addr-1);
874 break;
875 }
876 } else {
877 offset = ((efuseHeader >> 4) & 0x0f);
878 wden = (efuseHeader & 0x0f);
879 }
880
881 _rtw_memset(efuseData, '\0', EFUSE_MAX_WORD_UNIT * 2);
882 dataCnt = 0;
883
884 if (offset < max_section) {
885 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
886 /* Check word enable condition in the section */
887 if (!(wden & (0x01<<i))) {
888 if (!((efuseType == EFUSE_WIFI && (eFuse_Addr + 2 < maprawlen)) ||
889 (efuseType == EFUSE_BT && (eFuse_Addr + 2 < (endBank + 1) * EFUSE_MAX_BANK_SIZE)))) {
890 RTW_INFO("eFuse_Addr exceeds, break\n");
891 break;
892 }
893 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData[dataCnt++], bPseudoTest);
894 eFuseWord[(offset * 8) + (i * 2)] = (efuseData[dataCnt - 1]);
895 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData[dataCnt++], bPseudoTest);
896 eFuseWord[(offset * 8) + (i * 2 + 1)] = (efuseData[dataCnt - 1]);
897 }
898 }
899 }
900
901 if (bExtHeader) {
902 RTW_INFO("Efuse PG Section (%d) = ", pgSectionCnt);
903 RTW_INFO("[ %04X ], [", efuseHeader2Byte);
904
905 } else {
906 RTW_INFO("Efuse PG Section (%d) = ", pgSectionCnt);
907 RTW_INFO("[ %02X ], [", efuseHeader);
908 }
909
910 for (j = 0; j < dataCnt; j++)
911 RTW_INFO(" %02X ", efuseData[j]);
912
913 RTW_INFO("]\n");
914
915
916 if (bExtHeader) {
917 ParseEfuseExtHdr = (efuseHeader2Byte & 0xff00) >> 8;
918 ParseEfuseHeader = (efuseHeader2Byte & 0xff);
919 ParseOffset2_0 = GET_HDR_OFFSET_2_0(ParseEfuseHeader);
920 ParseOffset = ((ParseEfuseExtHdr & 0xF0) >> 1) | ParseOffset2_0;
921 ParseWDEN = (ParseEfuseExtHdr & 0x0F);
922 RTW_INFO("Header=0x%x, ExtHeader=0x%x, ", ParseEfuseHeader, ParseEfuseExtHdr);
923 } else {
924 ParseEfuseHeader = efuseHeader;
925 ParseOffset = ((ParseEfuseHeader >> 4) & 0x0f);
926 ParseWDEN = (ParseEfuseHeader & 0x0f);
927 RTW_INFO("Header=0x%x, ", ParseEfuseHeader);
928 }
929 RTW_INFO("offset=0x%x(%d), word enable=0x%x\n", ParseOffset, ParseOffset, ParseWDEN);
930
931 wd_cnt = 0;
932 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
933 if (!(wden & (0x01 << i))) {
934 RTW_INFO("Map[ %02X ] = %02X %02X\n", ((offset * EFUSE_MAX_WORD_UNIT * 2) + (i * 2)), efuseData[wd_cnt * 2 + 0], efuseData[wd_cnt * 2 + 1]);
935 wd_cnt++;
936 }
937 }
938
939 pgSectionCnt++;
940 bExtHeader = FALSE;
941 efuse_OneByteRead(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest);
942 if (efuseHeader == 0xFF) {
943 if ((eFuse_Addr + protectBytesBank) >= efuse_max)
944 bCheckNextBank = TRUE;
945 else
946 bCheckNextBank = FALSE;
947 }
948 }
949 if (!bCheckNextBank) {
950 RTW_INFO("Not need to check next bank, eFuse_Addr=%d, protectBytesBank=%d, efuse_max=%d\n",
951 eFuse_Addr, protectBytesBank, efuse_max);
952 break;
953 }
954 }
955 /* switch bank back to 0 for BT/wifi later use*/
956 hal_EfuseSwitchToBank(padapter, 0, bPseudoTest);
957
958 /* 3. Collect 16 sections and 4 word unit into Efuse map.*/
959 for (i = 0; i < max_section; i++) {
960 for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++) {
961 pEfuseHal->fakeEfuseInitMap[(i*8)+(j*2)] = (eFuseWord[(i*8)+(j*2)]);
962 pEfuseHal->fakeEfuseInitMap[(i*8)+((j*2)+1)] = (eFuseWord[(i*8)+((j*2)+1)]);
963 }
964 }
965
966 RTW_INFO("\n\tEFUSE Analyze Map\n");
967 i = 0;
968 j = 0;
969
970 for (i = 0; i < mapLen; i++) {
971 if (i % 16 == 0)
972 RTW_PRINT_SEL(RTW_DBGDUMP, "0x%03x: ", i);
973 _RTW_PRINT_SEL(RTW_DBGDUMP, "%02X%s"
974 , pEfuseHal->fakeEfuseInitMap[i]
975 , ((i + 1) % 16 == 0) ? "\n" : (((i + 1) % 8 == 0) ? " " : " ")
976 );
977 }
978 _RTW_PRINT_SEL(RTW_DBGDUMP, "\n");
979
980 out_free_buffer:
981 if (eFuseWord)
982 rtw_mfree((u8 *)eFuseWord, EFUSE_MAX_SECTION_NUM * (EFUSE_MAX_WORD_UNIT * 2));
983 }
984
efuse_PreUpdateAction(PADAPTER pAdapter,u32 * BackupRegs)985 void efuse_PreUpdateAction(
986 PADAPTER pAdapter,
987 u32 *BackupRegs)
988 {
989 if (IS_HARDWARE_TYPE_8812AU(pAdapter) || IS_HARDWARE_TYPE_8822BU(pAdapter)) {
990 /* <20131115, Kordan> Turn off Rx to prevent from being busy when writing the EFUSE. (Asked by Chunchu.)*/
991 BackupRegs[0] = phy_query_mac_reg(pAdapter, REG_RCR, bMaskDWord);
992 BackupRegs[1] = phy_query_mac_reg(pAdapter, REG_RXFLTMAP0, bMaskDWord);
993 BackupRegs[2] = phy_query_mac_reg(pAdapter, REG_RXFLTMAP0+4, bMaskDWord);
994 #ifdef CONFIG_RTL8812A
995 BackupRegs[3] = phy_query_mac_reg(pAdapter, REG_AFE_MISC, bMaskDWord);
996 #endif
997 PlatformEFIOWrite4Byte(pAdapter, REG_RCR, 0x1);
998 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0, 0);
999 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0+1, 0);
1000 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0+2, 0);
1001 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0+3, 0);
1002 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0+4, 0);
1003 PlatformEFIOWrite1Byte(pAdapter, REG_RXFLTMAP0+5, 0);
1004 #ifdef CONFIG_RTL8812A
1005 /* <20140410, Kordan> 0x11 = 0x4E, lower down LX_SPS0 voltage. (Asked by Chunchu)*/
1006 phy_set_mac_reg(pAdapter, REG_AFE_MISC, bMaskByte1, 0x4E);
1007 #endif
1008 RTW_INFO(" %s , done\n", __func__);
1009
1010 }
1011 }
1012
1013
efuse_PostUpdateAction(PADAPTER pAdapter,u32 * BackupRegs)1014 void efuse_PostUpdateAction(
1015 PADAPTER pAdapter,
1016 u32 *BackupRegs)
1017 {
1018 if (IS_HARDWARE_TYPE_8812AU(pAdapter) || IS_HARDWARE_TYPE_8822BU(pAdapter)) {
1019 /* <20131115, Kordan> Turn on Rx and restore the registers. (Asked by Chunchu.)*/
1020 phy_set_mac_reg(pAdapter, REG_RCR, bMaskDWord, BackupRegs[0]);
1021 phy_set_mac_reg(pAdapter, REG_RXFLTMAP0, bMaskDWord, BackupRegs[1]);
1022 phy_set_mac_reg(pAdapter, REG_RXFLTMAP0+4, bMaskDWord, BackupRegs[2]);
1023 #ifdef CONFIG_RTL8812A
1024 phy_set_mac_reg(pAdapter, REG_AFE_MISC, bMaskDWord, BackupRegs[3]);
1025 #endif
1026 RTW_INFO(" %s , done\n", __func__);
1027 }
1028 }
1029
1030
1031 #ifdef RTW_HALMAC
1032 #include "../../hal/hal_halmac.h"
1033
Efuse_PowerSwitch(PADAPTER adapter,u8 write,u8 pwrstate)1034 void Efuse_PowerSwitch(PADAPTER adapter, u8 write, u8 pwrstate)
1035 {
1036 }
1037
BTEfuse_PowerSwitch(PADAPTER adapter,u8 write,u8 pwrstate)1038 void BTEfuse_PowerSwitch(PADAPTER adapter, u8 write, u8 pwrstate)
1039 {
1040 }
1041
efuse_GetCurrentSize(PADAPTER adapter,u16 * size)1042 u8 efuse_GetCurrentSize(PADAPTER adapter, u16 *size)
1043 {
1044 *size = 0;
1045
1046 return _FAIL;
1047 }
1048
efuse_GetMaxSize(PADAPTER adapter)1049 u16 efuse_GetMaxSize(PADAPTER adapter)
1050 {
1051 struct dvobj_priv *d;
1052 u32 size = 0;
1053 int err;
1054
1055 d = adapter_to_dvobj(adapter);
1056 err = rtw_halmac_get_physical_efuse_size(d, &size);
1057 if (err)
1058 return 0;
1059
1060 return size;
1061 }
1062
efuse_GetavailableSize(PADAPTER adapter)1063 u16 efuse_GetavailableSize(PADAPTER adapter)
1064 {
1065 struct dvobj_priv *d;
1066 u32 size = 0;
1067 int err;
1068
1069 d = adapter_to_dvobj(adapter);
1070 err = rtw_halmac_get_available_efuse_size(d, &size);
1071 if (err)
1072 return 0;
1073
1074 return size;
1075 }
1076
1077
efuse_bt_GetCurrentSize(PADAPTER adapter,u16 * usesize)1078 u8 efuse_bt_GetCurrentSize(PADAPTER adapter, u16 *usesize)
1079 {
1080 u8 *efuse_map;
1081
1082 *usesize = 0;
1083 efuse_map = rtw_malloc(EFUSE_BT_MAP_LEN);
1084 if (efuse_map == NULL) {
1085 RTW_DBG("%s: malloc FAIL\n", __FUNCTION__);
1086 return _FAIL;
1087 }
1088
1089 /* for get bt phy efuse last use byte */
1090 hal_ReadEFuse_BT_logic_map(adapter, 0x00, EFUSE_BT_MAP_LEN, efuse_map);
1091 *usesize = fakeBTEfuseUsedBytes;
1092
1093 if (efuse_map)
1094 rtw_mfree(efuse_map, EFUSE_BT_MAP_LEN);
1095
1096 return _SUCCESS;
1097 }
1098
efuse_bt_GetMaxSize(PADAPTER adapter)1099 u16 efuse_bt_GetMaxSize(PADAPTER adapter)
1100 {
1101 return EFUSE_BT_REAL_CONTENT_LEN - EFUSE_PROTECT_BYTES_BANK;
1102 }
1103
EFUSE_GetEfuseDefinition(PADAPTER adapter,u8 efusetype,u8 type,void * out,BOOLEAN test)1104 void EFUSE_GetEfuseDefinition(PADAPTER adapter, u8 efusetype, u8 type, void *out, BOOLEAN test)
1105 {
1106 struct dvobj_priv *d;
1107 u32 v32 = 0;
1108
1109
1110 d = adapter_to_dvobj(adapter);
1111
1112 if (adapter->hal_func.EFUSEGetEfuseDefinition) {
1113 adapter->hal_func.EFUSEGetEfuseDefinition(adapter, efusetype, type, out, test);
1114 return;
1115 }
1116
1117 if (EFUSE_WIFI == efusetype) {
1118 switch (type) {
1119 case TYPE_EFUSE_MAP_LEN:
1120 rtw_halmac_get_logical_efuse_size(d, &v32);
1121 *(u16 *)out = (u16)v32;
1122 return;
1123
1124 case TYPE_EFUSE_REAL_CONTENT_LEN:
1125 rtw_halmac_get_physical_efuse_size(d, &v32);
1126 *(u16 *)out = (u16)v32;
1127 return;
1128 }
1129 } else if (EFUSE_BT == efusetype) {
1130 switch (type) {
1131 case TYPE_EFUSE_MAP_LEN:
1132 *(u16 *)out = EFUSE_BT_MAP_LEN;
1133 return;
1134
1135 case TYPE_EFUSE_REAL_CONTENT_LEN:
1136 *(u16 *)out = EFUSE_BT_REAL_CONTENT_LEN;
1137 return;
1138 }
1139 }
1140 }
1141
1142 /*
1143 * read/write raw efuse data
1144 */
rtw_efuse_access(PADAPTER adapter,u8 write,u16 addr,u16 cnts,u8 * data)1145 u8 rtw_efuse_access(PADAPTER adapter, u8 write, u16 addr, u16 cnts, u8 *data)
1146 {
1147 struct dvobj_priv *d;
1148 u8 *efuse = NULL;
1149 u32 size;
1150 int err;
1151
1152
1153 d = adapter_to_dvobj(adapter);
1154 err = rtw_halmac_get_physical_efuse_size(d, &size);
1155 if (err){
1156 size = EFUSE_MAX_SIZE;
1157 RTW_INFO(" physical_efuse_size err size %d\n", size);
1158 }
1159
1160 if ((addr + cnts) > size)
1161 return _FAIL;
1162
1163 if (_TRUE == write) {
1164 err = rtw_halmac_write_physical_efuse(d, addr, cnts, data);
1165 if (err)
1166 return _FAIL;
1167 } else {
1168 if (cnts > 16)
1169 efuse = rtw_zmalloc(size);
1170
1171 if (efuse) {
1172 err = rtw_halmac_read_physical_efuse_map(d, efuse, size);
1173 if (err) {
1174 rtw_mfree(efuse, size);
1175 return _FAIL;
1176 }
1177
1178 _rtw_memcpy(data, efuse + addr, cnts);
1179 rtw_mfree(efuse, size);
1180 } else {
1181 err = rtw_halmac_read_physical_efuse(d, addr, cnts, data);
1182 if (err)
1183 return _FAIL;
1184 }
1185 }
1186
1187 return _SUCCESS;
1188 }
1189
dump_buf(u8 * buf,u32 len)1190 static inline void dump_buf(u8 *buf, u32 len)
1191 {
1192 u32 i;
1193
1194 RTW_INFO("-----------------Len %d----------------\n", len);
1195 for (i = 0; i < len; i++)
1196 printk("%2.2x-", *(buf + i));
1197 printk("\n");
1198 }
1199
1200 /*
1201 * read/write raw efuse data
1202 */
rtw_efuse_bt_access(PADAPTER adapter,u8 write,u16 addr,u16 cnts,u8 * data)1203 u8 rtw_efuse_bt_access(PADAPTER adapter, u8 write, u16 addr, u16 cnts, u8 *data)
1204 {
1205 struct dvobj_priv *d;
1206 u8 *efuse = NULL;
1207 u32 size;
1208 int err = _FAIL;
1209
1210
1211 d = adapter_to_dvobj(adapter);
1212
1213 size = EFUSE_BT_REAL_CONTENT_LEN;
1214
1215 if ((addr + cnts) > size)
1216 return _FAIL;
1217
1218 if (_TRUE == write) {
1219 err = rtw_halmac_write_bt_physical_efuse(d, addr, cnts, data);
1220 if (err == -1) {
1221 RTW_ERR("%s: rtw_halmac_write_bt_physical_efuse fail!\n", __FUNCTION__);
1222 return _FAIL;
1223 }
1224 RTW_INFO("%s: rtw_halmac_write_bt_physical_efuse OK! data 0x%x\n", __FUNCTION__, *data);
1225 } else {
1226 efuse = rtw_zmalloc(size);
1227
1228 if (efuse) {
1229 err = rtw_halmac_read_bt_physical_efuse_map(d, efuse, size);
1230
1231 if (err == -1) {
1232 RTW_ERR("%s: rtw_halmac_read_bt_physical_efuse_map fail!\n", __FUNCTION__);
1233 rtw_mfree(efuse, size);
1234 return _FAIL;
1235 }
1236 dump_buf(efuse + addr, cnts);
1237
1238 _rtw_memcpy(data, efuse + addr, cnts);
1239
1240 RTW_INFO("%s: rtw_halmac_read_bt_physical_efuse_map ok! data 0x%x\n", __FUNCTION__, *data);
1241 rtw_mfree(efuse, size);
1242 }
1243 }
1244
1245 return _SUCCESS;
1246 }
1247
rtw_efuse_map_read(PADAPTER adapter,u16 addr,u16 cnts,u8 * data)1248 u8 rtw_efuse_map_read(PADAPTER adapter, u16 addr, u16 cnts, u8 *data)
1249 {
1250 struct dvobj_priv *d;
1251 u8 *efuse = NULL;
1252 u32 size, i;
1253 int err;
1254 u32 backupRegs[4] = {0};
1255 u8 status = _SUCCESS;
1256
1257 efuse_PreUpdateAction(adapter, backupRegs);
1258
1259 d = adapter_to_dvobj(adapter);
1260 err = rtw_halmac_get_logical_efuse_size(d, &size);
1261 if (err) {
1262 status = _FAIL;
1263 RTW_DBG("halmac_get_logical_efuse_size fail\n");
1264 goto exit;
1265 }
1266 /* size error handle */
1267 if ((addr + cnts) > size) {
1268 if (addr < size)
1269 cnts = size - addr;
1270 else {
1271 status = _FAIL;
1272 RTW_DBG(" %s() ,addr + cnts) > size fail\n", __func__);
1273 goto exit;
1274 }
1275 }
1276
1277 if (cnts > 16)
1278 efuse = rtw_zmalloc(size);
1279
1280 if (efuse) {
1281 err = rtw_halmac_read_logical_efuse_map(d, efuse, size, NULL, 0);
1282 if (err) {
1283 rtw_mfree(efuse, size);
1284 status = _FAIL;
1285 RTW_DBG(" %s() ,halmac_read_logical_efus map fail\n", __func__);
1286 goto exit;
1287 }
1288
1289 _rtw_memcpy(data, efuse + addr, cnts);
1290 rtw_mfree(efuse, size);
1291 } else {
1292 err = rtw_halmac_read_logical_efuse(d, addr, cnts, data);
1293 if (err) {
1294 status = _FAIL;
1295 RTW_DBG(" %s() ,halmac_read_logical_efus data fail\n", __func__);
1296 goto exit;
1297 }
1298 }
1299 status = _SUCCESS;
1300 exit:
1301 efuse_PostUpdateAction(adapter, backupRegs);
1302
1303 return status;
1304 }
1305
1306
rtw_efuse_map_write(PADAPTER adapter,u16 addr,u16 cnts,u8 * data)1307 u8 rtw_efuse_map_write(PADAPTER adapter, u16 addr, u16 cnts, u8 *data)
1308 {
1309 struct dvobj_priv *d;
1310 u8 *efuse = NULL;
1311 u32 size;
1312 int err;
1313 u8 mask_buf[64] = "";
1314 u16 mask_len = sizeof(u8) * rtw_get_efuse_mask_arraylen(adapter);
1315 u32 backupRegs[4] = {0};
1316 u8 status = _SUCCESS;;
1317
1318 efuse_PreUpdateAction(adapter, backupRegs);
1319
1320 d = adapter_to_dvobj(adapter);
1321 err = rtw_halmac_get_logical_efuse_size(d, &size);
1322 if (err) {
1323 status = _FAIL;
1324 goto exit;
1325 }
1326
1327 if ((addr + cnts) > size) {
1328 status = _FAIL;
1329 goto exit;
1330 }
1331
1332 efuse = rtw_zmalloc(size);
1333 if (!efuse) {
1334 status = _FAIL;
1335 goto exit;
1336 }
1337
1338 err = rtw_halmac_read_logical_efuse_map(d, efuse, size, NULL, 0);
1339 if (err) {
1340 rtw_mfree(efuse, size);
1341 status = _FAIL;
1342 goto exit;
1343 }
1344
1345 _rtw_memcpy(efuse + addr, data, cnts);
1346
1347 if (adapter->registrypriv.boffefusemask == 0) {
1348 RTW_INFO("Use mask Array Len: %d\n", mask_len);
1349
1350 if (mask_len != 0) {
1351 if (adapter->registrypriv.bFileMaskEfuse == _TRUE)
1352 _rtw_memcpy(mask_buf, maskfileBuffer, mask_len);
1353 else
1354 rtw_efuse_mask_array(adapter, mask_buf);
1355
1356 err = rtw_halmac_write_logical_efuse_map(d, efuse, size, mask_buf, mask_len);
1357 } else
1358 err = rtw_halmac_write_logical_efuse_map(d, efuse, size, NULL, 0);
1359 } else {
1360 _rtw_memset(mask_buf, 0xFF, sizeof(mask_buf));
1361 RTW_INFO("Efuse mask off\n");
1362 err = rtw_halmac_write_logical_efuse_map(d, efuse, size, mask_buf, size/16);
1363 }
1364
1365 if (err) {
1366 rtw_mfree(efuse, size);
1367 status = _FAIL;
1368 goto exit;
1369 }
1370
1371 rtw_mfree(efuse, size);
1372 status = _SUCCESS;
1373 exit :
1374 efuse_PostUpdateAction(adapter, backupRegs);
1375
1376 return status;
1377 }
1378
Efuse_PgPacketRead(PADAPTER adapter,u8 offset,u8 * data,BOOLEAN test)1379 int Efuse_PgPacketRead(PADAPTER adapter, u8 offset, u8 *data, BOOLEAN test)
1380 {
1381 return _FALSE;
1382 }
1383
Efuse_PgPacketWrite(PADAPTER adapter,u8 offset,u8 word_en,u8 * data,BOOLEAN test)1384 int Efuse_PgPacketWrite(PADAPTER adapter, u8 offset, u8 word_en, u8 *data, BOOLEAN test)
1385 {
1386 return _FALSE;
1387 }
1388
rtw_bt_mask_map_read(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)1389 static void rtw_bt_mask_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
1390 {
1391 u16 i = 0;
1392
1393 #ifdef CONFIG_BT_EFUSE_MASK
1394 if (padapter->registrypriv.boffefusemask == 0) {
1395 for (i = 0; i < cnts; i++) {
1396 if (padapter->registrypriv.bBTFileMaskEfuse == _TRUE) {
1397 if (rtw_file_efuse_IsMasked(padapter, addr + i, btmaskfileBuffer)) /*use BT file efuse mask.*/
1398 data[i] = 0xff;
1399 else
1400 RTW_INFO("data[%x] = %x\n", i, data[i]);
1401 } else {
1402 if (efuse_IsBT_Masked(padapter, addr + i)) /*use drv internal efuse mask.*/
1403 data[i] = 0xff;
1404 else
1405 RTW_INFO("data[%x] = %x\n", i, data[i]);
1406 }
1407 }
1408 }
1409 #endif /*CONFIG_BT_EFUSE_MASK*/
1410 }
1411
rtw_BT_efuse_map_read(PADAPTER adapter,u16 addr,u16 cnts,u8 * data)1412 u8 rtw_BT_efuse_map_read(PADAPTER adapter, u16 addr, u16 cnts, u8 *data)
1413 {
1414 hal_ReadEFuse_BT_logic_map(adapter, addr, cnts, data);
1415
1416 rtw_bt_mask_map_read(adapter, addr, cnts, data);
1417
1418 return _SUCCESS;
1419 }
1420
1421
1422 static u16
hal_EfuseGetCurrentSize_BT(PADAPTER padapter,u8 bPseudoTest)1423 hal_EfuseGetCurrentSize_BT(
1424 PADAPTER padapter,
1425 u8 bPseudoTest)
1426 {
1427 #ifdef HAL_EFUSE_MEMORY
1428 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
1429 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
1430 #endif
1431 u16 btusedbytes;
1432 u16 efuse_addr;
1433 u8 bank, startBank;
1434 u8 hoffset = 0, hworden = 0;
1435 u8 efuse_data, word_cnts = 0;
1436 u16 retU2 = 0;
1437
1438
1439 btusedbytes = fakeBTEfuseUsedBytes;
1440
1441 efuse_addr = (u16)((btusedbytes % EFUSE_BT_REAL_BANK_CONTENT_LEN));
1442 startBank = (u8)(1 + (btusedbytes / EFUSE_BT_REAL_BANK_CONTENT_LEN));
1443
1444 RTW_INFO("%s: start from bank=%d addr=0x%X\n", __FUNCTION__, startBank, efuse_addr);
1445 retU2 = EFUSE_BT_REAL_CONTENT_LEN - EFUSE_PROTECT_BYTES_BANK;
1446
1447 for (bank = startBank; bank < 3; bank++) {
1448 if (hal_EfuseSwitchToBank(padapter, bank, bPseudoTest) == _FALSE) {
1449 RTW_ERR("%s: switch bank(%d) Fail!!\n", __FUNCTION__, bank);
1450 /* bank = EFUSE_MAX_BANK; */
1451 break;
1452 }
1453
1454 /* only when bank is switched we have to reset the efuse_addr. */
1455 if (bank != startBank)
1456 efuse_addr = 0;
1457
1458
1459 while (AVAILABLE_EFUSE_ADDR(efuse_addr)) {
1460 if (rtw_efuse_bt_access(padapter, _FALSE, efuse_addr, 1, &efuse_data) == _FALSE) {
1461 RTW_ERR("%s: efuse_OneByteRead Fail! addr=0x%X !!\n", __FUNCTION__, efuse_addr);
1462 /* bank = EFUSE_MAX_BANK; */
1463 break;
1464 }
1465 RTW_INFO("%s: efuse_OneByteRead ! addr=0x%X !efuse_data=0x%X! bank =%d\n", __FUNCTION__, efuse_addr, efuse_data, bank);
1466
1467 if (efuse_data == 0xFF)
1468 break;
1469
1470 if (EXT_HEADER(efuse_data)) {
1471 hoffset = GET_HDR_OFFSET_2_0(efuse_data);
1472 efuse_addr++;
1473 rtw_efuse_bt_access(padapter, _FALSE, efuse_addr, 1, &efuse_data);
1474 RTW_INFO("%s: efuse_OneByteRead EXT_HEADER ! addr=0x%X !efuse_data=0x%X! bank =%d\n", __FUNCTION__, efuse_addr, efuse_data, bank);
1475
1476 if (ALL_WORDS_DISABLED(efuse_data)) {
1477 efuse_addr++;
1478 continue;
1479 }
1480
1481 /* hoffset = ((hoffset & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1); */
1482 hoffset |= ((efuse_data & 0xF0) >> 1);
1483 hworden = efuse_data & 0x0F;
1484 } else {
1485 hoffset = (efuse_data >> 4) & 0x0F;
1486 hworden = efuse_data & 0x0F;
1487 }
1488
1489 RTW_INFO(FUNC_ADPT_FMT": Offset=%d Worden=%#X\n",
1490 FUNC_ADPT_ARG(padapter), hoffset, hworden);
1491
1492 word_cnts = Efuse_CalculateWordCnts(hworden);
1493 /* read next header */
1494 efuse_addr += (word_cnts * 2) + 1;
1495 }
1496 /* Check if we need to check next bank efuse */
1497 if (efuse_addr < retU2)
1498 break;/* don't need to check next bank. */
1499 }
1500 retU2 = ((bank - 1) * EFUSE_BT_REAL_BANK_CONTENT_LEN) + efuse_addr;
1501
1502 fakeBTEfuseUsedBytes = retU2;
1503 RTW_INFO("%s: CurrentSize=%d\n", __FUNCTION__, retU2);
1504 return retU2;
1505 }
1506
1507 #ifdef CONFIG_RTL8822C
rtw_pre_bt_efuse(PADAPTER padapter)1508 void rtw_pre_bt_efuse(PADAPTER padapter)
1509 {
1510 char pgdata[4] = {0x72, 0x80, 0x14, 0x90}; /*BT 5M PLL*/
1511 u8 status = 1;
1512 u8 bkmask;
1513 BOOLEAN bt_en;
1514
1515 bkmask = padapter->registrypriv.boffefusemask;
1516 padapter->registrypriv.boffefusemask = 1;
1517
1518 bt_en = rtw_read8(padapter, 0x6A) & BIT2 ? _TRUE : _FALSE;
1519 if (IS_HARDWARE_TYPE_8822C(padapter) && bt_en == _TRUE) {
1520 status = rtw_BT_efuse_map_write(padapter, 0x1f8, 4, pgdata);
1521 RTW_INFO("%s done!!!\n", __FUNCTION__);
1522 }
1523 if (status == _FAIL)
1524 RTW_INFO("%s: fail\n", __FUNCTION__);
1525 padapter->registrypriv.boffefusemask = bkmask;
1526 }
1527 #endif
1528
rtw_BT_efuse_map_write(PADAPTER adapter,u16 addr,u16 cnts,u8 * data)1529 u8 rtw_BT_efuse_map_write(PADAPTER adapter, u16 addr, u16 cnts, u8 *data)
1530 {
1531 #define RT_ASSERT_RET(expr) \
1532 if (!(expr)) { \
1533 printk("Assertion failed! %s at ......\n", #expr); \
1534 printk(" ......%s,%s, line=%d\n",__FILE__, __FUNCTION__, __LINE__); \
1535 return _FAIL; \
1536 }
1537
1538 u8 offset, word_en;
1539 u8 *efuse = NULL;
1540 u8 *map;
1541 u8 newdata[PGPKT_DATA_SIZE];
1542 s32 i = 0, j = 0, idx = 0, chk_total_byte = 0;
1543 u8 ret = _SUCCESS;
1544 u16 mapLen = 1024;
1545 u16 startAddr = 0;
1546
1547 if ((addr + cnts) > mapLen)
1548 return _FAIL;
1549
1550 RT_ASSERT_RET(PGPKT_DATA_SIZE == 8); /* have to be 8 byte alignment */
1551 RT_ASSERT_RET((mapLen & 0x7) == 0); /* have to be PGPKT_DATA_SIZE alignment for memcpy */
1552
1553 efuse = rtw_zmalloc(mapLen);
1554 if (!efuse)
1555 return _FAIL;
1556
1557 map = rtw_zmalloc(mapLen);
1558 if (map == NULL) {
1559 rtw_mfree(efuse, mapLen);
1560 return _FAIL;
1561 }
1562
1563 _rtw_memset(map, 0xFF, mapLen);
1564
1565 ret = rtw_BT_efuse_map_read(adapter, 0, mapLen, map);
1566 if (ret == _FAIL)
1567 goto exit;
1568
1569 _rtw_memcpy(efuse , map, mapLen);
1570 _rtw_memcpy(efuse + addr, data, cnts);
1571 #ifdef CONFIG_BT_EFUSE_MASK
1572 if (adapter->registrypriv.boffefusemask == 0) {
1573 for (i = 0; i < cnts; i++) {
1574 if (adapter->registrypriv.bBTFileMaskEfuse == _TRUE) {
1575 if (rtw_file_efuse_IsMasked(adapter, addr + i, btmaskfileBuffer)) /*use file efuse mask. */
1576 efuse[addr + i] = map[addr + i];
1577 } else {
1578 if (efuse_IsBT_Masked(adapter, addr + i))
1579 efuse[addr + i] = map[addr + i];
1580 }
1581 RTW_INFO("%s , efuse[%x] = %x, map = %x\n", __func__, addr + i, efuse[ addr + i], map[addr + i]);
1582 }
1583 }
1584 #endif /*CONFIG_BT_EFUSE_MASK*/
1585 /* precheck pg efuse data byte*/
1586 chk_total_byte = 0;
1587 idx = 0;
1588 offset = (addr >> 3);
1589
1590 while (idx < cnts) {
1591 word_en = 0xF;
1592 j = (addr + idx) & 0x7;
1593 for (i = j; i < PGPKT_DATA_SIZE && idx < cnts; i++, idx++) {
1594 if (efuse[addr + idx] != map[addr + idx])
1595 word_en &= ~BIT(i >> 1);
1596 }
1597
1598 if (word_en != 0xF) {
1599 chk_total_byte += Efuse_CalculateWordCnts(word_en) * 2;
1600
1601 if (offset >= EFUSE_MAX_SECTION_BASE) /* Over EFUSE_MAX_SECTION 16 for 2 ByteHeader */
1602 chk_total_byte += 2;
1603 else
1604 chk_total_byte += 1;
1605 }
1606
1607 offset++;
1608 }
1609
1610 RTW_INFO("Total PG bytes Count = %d\n", chk_total_byte);
1611 startAddr = hal_EfuseGetCurrentSize_BT(adapter, _FALSE);
1612 RTW_INFO("%s: startAddr=%#X\n", __func__, startAddr);
1613
1614 if (!AVAILABLE_EFUSE_ADDR(startAddr + chk_total_byte)) {
1615 RTW_INFO("%s: startAddr(0x%X) + PG data len %d >= efuse BT available offset (0x%X)\n",
1616 __func__, startAddr, chk_total_byte, EFUSE_BT_REAL_CONTENT_LEN - EFUSE_PROTECT_BYTES_BANK);
1617 ret = _FAIL;
1618 goto exit;
1619 }
1620
1621 idx = 0;
1622 offset = (addr >> 3);
1623 while (idx < cnts) {
1624 word_en = 0xF;
1625 j = (addr + idx) & 0x7;
1626 _rtw_memcpy(newdata, &map[offset << 3], PGPKT_DATA_SIZE);
1627 for (i = j; i < PGPKT_DATA_SIZE && idx < cnts; i++, idx++) {
1628 if (efuse[addr + idx] != map[addr + idx]) {
1629 word_en &= ~BIT(i >> 1);
1630 newdata[i] = efuse[addr + idx];
1631 }
1632 }
1633
1634 if (word_en != 0xF) {
1635 ret = EfusePgPacketWrite_BT(adapter, offset, word_en, newdata, _FALSE);
1636 RTW_INFO("offset=%x\n", offset);
1637 RTW_INFO("word_en=%x\n", word_en);
1638 RTW_INFO("%s: data=", __FUNCTION__);
1639 for (i = 0; i < PGPKT_DATA_SIZE; i++)
1640 RTW_INFO("0x%02X ", newdata[i]);
1641 RTW_INFO("\n");
1642 if (ret == _FAIL)
1643 break;
1644 }
1645 offset++;
1646 }
1647 exit:
1648 if (efuse)
1649 rtw_mfree(efuse, mapLen);
1650 if (map)
1651 rtw_mfree(map, mapLen);
1652 return ret;
1653 }
1654
hal_ReadEFuse_BT_logic_map(PADAPTER padapter,u16 _offset,u16 _size_byte,u8 * pbuf)1655 void hal_ReadEFuse_BT_logic_map(
1656 PADAPTER padapter,
1657 u16 _offset,
1658 u16 _size_byte,
1659 u8 *pbuf
1660 )
1661 {
1662
1663 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
1664
1665 u8 *efuseTbl, *phyefuse;
1666 u8 bank;
1667 u16 eFuse_Addr = 0;
1668 u8 efuseHeader, efuseExtHdr, efuseData;
1669 u8 offset, wden;
1670 u16 i, total, used;
1671 u8 efuse_usage;
1672
1673
1674 /* */
1675 /* Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10. */
1676 /* */
1677 if ((_offset + _size_byte) > EFUSE_BT_MAP_LEN) {
1678 RTW_INFO("%s: Invalid offset(%#x) with read bytes(%#x)!!\n", __FUNCTION__, _offset, _size_byte);
1679 return;
1680 }
1681
1682 efuseTbl = rtw_malloc(EFUSE_BT_MAP_LEN);
1683 phyefuse = rtw_malloc(EFUSE_BT_REAL_CONTENT_LEN);
1684 if (efuseTbl == NULL || phyefuse == NULL) {
1685 RTW_INFO("%s: efuseTbl or phyefuse malloc fail!\n", __FUNCTION__);
1686 goto exit;
1687 }
1688
1689 /* 0xff will be efuse default value instead of 0x00. */
1690 _rtw_memset(efuseTbl, 0xFF, EFUSE_BT_MAP_LEN);
1691 _rtw_memset(phyefuse, 0xFF, EFUSE_BT_REAL_CONTENT_LEN);
1692
1693 if (rtw_efuse_bt_access(padapter, _FALSE, 0, EFUSE_BT_REAL_CONTENT_LEN, phyefuse))
1694 dump_buf(phyefuse, EFUSE_BT_REAL_BANK_CONTENT_LEN);
1695
1696 total = BANK_NUM;
1697 for (bank = 1; bank <= total; bank++) { /* 8723d Max bake 0~2 */
1698 eFuse_Addr = 0;
1699
1700 while (AVAILABLE_EFUSE_ADDR(eFuse_Addr)) {
1701 /* ReadEFuseByte(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest); */
1702 efuseHeader = phyefuse[eFuse_Addr++];
1703
1704 if (efuseHeader == 0xFF)
1705 break;
1706 RTW_INFO("%s: efuse[%#X]=0x%02x (header)\n", __FUNCTION__, (((bank - 1) * EFUSE_BT_REAL_CONTENT_LEN) + eFuse_Addr - 1), efuseHeader);
1707
1708 /* Check PG header for section num. */
1709 if (EXT_HEADER(efuseHeader)) { /* extended header */
1710 offset = GET_HDR_OFFSET_2_0(efuseHeader);
1711 RTW_INFO("%s: extended header offset_2_0=0x%X\n", __FUNCTION__, offset);
1712
1713 /* ReadEFuseByte(padapter, eFuse_Addr++, &efuseExtHdr, bPseudoTest); */
1714 efuseExtHdr = phyefuse[eFuse_Addr++];
1715
1716 RTW_INFO("%s: efuse[%#X]=0x%02x (ext header)\n", __FUNCTION__, (((bank - 1) * EFUSE_BT_REAL_CONTENT_LEN) + eFuse_Addr - 1), efuseExtHdr);
1717 if (ALL_WORDS_DISABLED(efuseExtHdr))
1718 continue;
1719
1720 offset |= ((efuseExtHdr & 0xF0) >> 1);
1721 wden = (efuseExtHdr & 0x0F);
1722 } else {
1723 offset = ((efuseHeader >> 4) & 0x0f);
1724 wden = (efuseHeader & 0x0f);
1725 }
1726
1727 if (offset < EFUSE_BT_MAX_SECTION) {
1728 u16 addr;
1729
1730 /* Get word enable value from PG header */
1731 RTW_INFO("%s: Offset=%d Worden=%#X\n", __FUNCTION__, offset, wden);
1732
1733 addr = offset * PGPKT_DATA_SIZE;
1734 for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
1735 /* Check word enable condition in the section */
1736 if (!(wden & (0x01 << i))) {
1737 efuseData = 0;
1738 /* ReadEFuseByte(padapter, eFuse_Addr++, &efuseData, bPseudoTest); */
1739 efuseData = phyefuse[eFuse_Addr++];
1740
1741 RTW_INFO("%s: efuse[%#X]=0x%02X\n", __FUNCTION__, eFuse_Addr - 1, efuseData);
1742 efuseTbl[addr] = efuseData;
1743
1744 efuseData = 0;
1745 /* ReadEFuseByte(padapter, eFuse_Addr++, &efuseData, bPseudoTest); */
1746 efuseData = phyefuse[eFuse_Addr++];
1747
1748 RTW_INFO("%s: efuse[%#X]=0x%02X\n", __FUNCTION__, eFuse_Addr - 1, efuseData);
1749 efuseTbl[addr + 1] = efuseData;
1750 }
1751 addr += 2;
1752 }
1753 } else {
1754 RTW_INFO("%s: offset(%d) is illegal!!\n", __FUNCTION__, offset);
1755 eFuse_Addr += Efuse_CalculateWordCnts(wden) * 2;
1756 }
1757 }
1758
1759 if ((eFuse_Addr - 1) < total) {
1760 RTW_INFO("%s: bank(%d) data end at %#x\n", __FUNCTION__, bank, eFuse_Addr - 1);
1761 break;
1762 }
1763 }
1764
1765 /* switch bank back to bank 0 for later BT and wifi use. */
1766 //hal_EfuseSwitchToBank(padapter, 0, bPseudoTest);
1767
1768 /* Copy from Efuse map to output pointer memory!!! */
1769 for (i = 0; i < _size_byte; i++)
1770 pbuf[i] = efuseTbl[_offset + i];
1771 /* Calculate Efuse utilization */
1772 total = EFUSE_BT_REAL_BANK_CONTENT_LEN;
1773
1774 used = eFuse_Addr - 1;
1775
1776 if (total)
1777 efuse_usage = (u8)((used * 100) / total);
1778 else
1779 efuse_usage = 100;
1780
1781 fakeBTEfuseUsedBytes = used;
1782 RTW_INFO("%s: BTEfuseUsed last Bytes = %#x\n", __FUNCTION__, fakeBTEfuseUsedBytes);
1783
1784 exit:
1785 if (efuseTbl)
1786 rtw_mfree(efuseTbl, EFUSE_BT_MAP_LEN);
1787 if (phyefuse)
1788 rtw_mfree(phyefuse, EFUSE_BT_REAL_BANK_CONTENT_LEN);
1789 }
1790
1791
hal_EfusePartialWriteCheck(PADAPTER padapter,u8 efuseType,u16 * pAddr,PPGPKT_STRUCT pTargetPkt,u8 bPseudoTest)1792 static u8 hal_EfusePartialWriteCheck(
1793 PADAPTER padapter,
1794 u8 efuseType,
1795 u16 *pAddr,
1796 PPGPKT_STRUCT pTargetPkt,
1797 u8 bPseudoTest)
1798 {
1799 u8 bRet = _FALSE;
1800 u16 startAddr = 0, efuse_max_available_len = EFUSE_BT_REAL_BANK_CONTENT_LEN, efuse_max = EFUSE_BT_REAL_BANK_CONTENT_LEN;
1801 u8 efuse_data = 0;
1802
1803 startAddr = (u16)fakeBTEfuseUsedBytes;
1804
1805 startAddr %= efuse_max;
1806 RTW_INFO("%s: startAddr=%#X\n", __FUNCTION__, startAddr);
1807
1808 while (1) {
1809 if (startAddr >= efuse_max_available_len) {
1810 bRet = _FALSE;
1811 RTW_INFO("%s: startAddr(%d) >= efuse_max_available_len(%d)\n",
1812 __FUNCTION__, startAddr, efuse_max_available_len);
1813 break;
1814 }
1815 if (rtw_efuse_bt_access(padapter, _FALSE, startAddr, 1, &efuse_data)&& (efuse_data != 0xFF)) {
1816 bRet = _FALSE;
1817 RTW_INFO("%s: Something Wrong! last bytes(%#X=0x%02X) is not 0xFF\n",
1818 __FUNCTION__, startAddr, efuse_data);
1819 break;
1820 } else {
1821 /* not used header, 0xff */
1822 *pAddr = startAddr;
1823 /* RTW_INFO("%s: Started from unused header offset=%d\n", __FUNCTION__, startAddr)); */
1824 bRet = _TRUE;
1825 break;
1826 }
1827 }
1828
1829 return bRet;
1830 }
1831
1832
hal_EfusePgPacketWrite2ByteHeader(PADAPTER padapter,u8 efuseType,u16 * pAddr,PPGPKT_STRUCT pTargetPkt,u8 bPseudoTest)1833 static u8 hal_EfusePgPacketWrite2ByteHeader(
1834 PADAPTER padapter,
1835 u8 efuseType,
1836 u16 *pAddr,
1837 PPGPKT_STRUCT pTargetPkt,
1838 u8 bPseudoTest)
1839 {
1840 u16 efuse_addr, efuse_max_available_len = EFUSE_BT_REAL_BANK_CONTENT_LEN;
1841 u8 pg_header = 0, tmp_header = 0;
1842 u8 repeatcnt = 0;
1843
1844 /* RTW_INFO("%s\n", __FUNCTION__); */
1845
1846 efuse_addr = *pAddr;
1847 if (efuse_addr >= efuse_max_available_len) {
1848 RTW_INFO("%s: addr(%d) over avaliable(%d)!!\n", __FUNCTION__, efuse_addr, efuse_max_available_len);
1849 return _FALSE;
1850 }
1851
1852 pg_header = ((pTargetPkt->offset & 0x07) << 5) | 0x0F;
1853 /* RTW_INFO("%s: pg_header=0x%x\n", __FUNCTION__, pg_header); */
1854
1855 do {
1856
1857 rtw_efuse_bt_access(padapter, _TRUE, efuse_addr, 1, &pg_header);
1858 rtw_efuse_bt_access(padapter, _FALSE, efuse_addr, 1, &tmp_header);
1859
1860 if (tmp_header != 0xFF)
1861 break;
1862 if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_) {
1863 RTW_INFO("%s: Repeat over limit for pg_header!!\n", __FUNCTION__);
1864 return _FALSE;
1865 }
1866 } while (1);
1867
1868 if (tmp_header != pg_header) {
1869 RTW_ERR("%s: PG Header Fail!!(pg=0x%02X read=0x%02X)\n", __FUNCTION__, pg_header, tmp_header);
1870 return _FALSE;
1871 }
1872
1873 /* to write ext_header */
1874 efuse_addr++;
1875 pg_header = ((pTargetPkt->offset & 0x78) << 1) | pTargetPkt->word_en;
1876
1877 do {
1878 rtw_efuse_bt_access(padapter, _TRUE, efuse_addr, 1, &pg_header);
1879 rtw_efuse_bt_access(padapter, _FALSE, efuse_addr, 1, &tmp_header);
1880
1881 if (tmp_header != 0xFF)
1882 break;
1883 if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_) {
1884 RTW_INFO("%s: Repeat over limit for ext_header!!\n", __FUNCTION__);
1885 return _FALSE;
1886 }
1887 } while (1);
1888
1889 if (tmp_header != pg_header) { /* offset PG fail */
1890 RTW_ERR("%s: PG EXT Header Fail!!(pg=0x%02X read=0x%02X)\n", __FUNCTION__, pg_header, tmp_header);
1891 return _FALSE;
1892 }
1893
1894 *pAddr = efuse_addr;
1895
1896 return _TRUE;
1897 }
1898
1899
hal_EfusePgPacketWrite1ByteHeader(PADAPTER pAdapter,u8 efuseType,u16 * pAddr,PPGPKT_STRUCT pTargetPkt,u8 bPseudoTest)1900 static u8 hal_EfusePgPacketWrite1ByteHeader(
1901 PADAPTER pAdapter,
1902 u8 efuseType,
1903 u16 *pAddr,
1904 PPGPKT_STRUCT pTargetPkt,
1905 u8 bPseudoTest)
1906 {
1907 u8 pg_header = 0, tmp_header = 0;
1908 u16 efuse_addr = *pAddr;
1909 u8 repeatcnt = 0;
1910
1911
1912 /* RTW_INFO("%s\n", __FUNCTION__); */
1913 pg_header = ((pTargetPkt->offset << 4) & 0xf0) | pTargetPkt->word_en;
1914
1915 do {
1916 rtw_efuse_bt_access(pAdapter, _TRUE, efuse_addr, 1, &pg_header);
1917 rtw_efuse_bt_access(pAdapter, _FALSE, efuse_addr, 1, &tmp_header);
1918
1919 if (tmp_header != 0xFF)
1920 break;
1921 if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_) {
1922 RTW_INFO("%s: Repeat over limit for pg_header!!\n", __FUNCTION__);
1923 return _FALSE;
1924 }
1925 } while (1);
1926
1927 if (tmp_header != pg_header) {
1928 RTW_ERR("%s: PG Header Fail!!(pg=0x%02X read=0x%02X)\n", __FUNCTION__, pg_header, tmp_header);
1929 return _FALSE;
1930 }
1931
1932 *pAddr = efuse_addr;
1933
1934 return _TRUE;
1935 }
1936
hal_EfusePgPacketWriteHeader(PADAPTER padapter,u8 efuseType,u16 * pAddr,PPGPKT_STRUCT pTargetPkt,u8 bPseudoTest)1937 static u8 hal_EfusePgPacketWriteHeader(
1938 PADAPTER padapter,
1939 u8 efuseType,
1940 u16 *pAddr,
1941 PPGPKT_STRUCT pTargetPkt,
1942 u8 bPseudoTest)
1943 {
1944 u8 bRet = _FALSE;
1945
1946 if (pTargetPkt->offset >= EFUSE_MAX_SECTION_BASE)
1947 bRet = hal_EfusePgPacketWrite2ByteHeader(padapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
1948 else
1949 bRet = hal_EfusePgPacketWrite1ByteHeader(padapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
1950
1951 return bRet;
1952 }
1953
1954
1955 static u8
Hal_EfuseWordEnableDataWrite(PADAPTER padapter,u16 efuse_addr,u8 word_en,u8 * data,u8 bPseudoTest)1956 Hal_EfuseWordEnableDataWrite(
1957 PADAPTER padapter,
1958 u16 efuse_addr,
1959 u8 word_en,
1960 u8 *data,
1961 u8 bPseudoTest)
1962 {
1963 u16 tmpaddr = 0;
1964 u16 start_addr = efuse_addr;
1965 u8 badworden = 0x0F;
1966 u8 tmpdata[PGPKT_DATA_SIZE];
1967
1968
1969 /* RTW_INFO("%s: efuse_addr=%#x word_en=%#x\n", __FUNCTION__, efuse_addr, word_en); */
1970 _rtw_memset(tmpdata, 0xFF, PGPKT_DATA_SIZE);
1971
1972 if (!(word_en & BIT(0))) {
1973 tmpaddr = start_addr;
1974 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[0]);
1975 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[1]);
1976 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr, 1, &tmpdata[0]);
1977 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr + 1, 1, &tmpdata[1]);
1978 if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1]))
1979 badworden &= (~BIT(0));
1980 }
1981 if (!(word_en & BIT(1))) {
1982 tmpaddr = start_addr;
1983 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[2]);
1984 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[3]);
1985 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr, 1, &tmpdata[2]);
1986 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr + 1, 1, &tmpdata[3]);
1987 if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3]))
1988 badworden &= (~BIT(1));
1989 }
1990 if (!(word_en & BIT(2))) {
1991 tmpaddr = start_addr;
1992 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[4]);
1993 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[5]);
1994 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr, 1, &tmpdata[4]);
1995 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr + 1, 1, &tmpdata[5]);
1996 if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5]))
1997 badworden &= (~BIT(2));
1998 }
1999 if (!(word_en & BIT(3))) {
2000 tmpaddr = start_addr;
2001 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[6]);
2002 rtw_efuse_bt_access(padapter, _TRUE, start_addr++, 1, &data[7]);
2003 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr, 1, &tmpdata[6]);
2004 rtw_efuse_bt_access(padapter, _FALSE, tmpaddr + 1, 1, &tmpdata[7]);
2005
2006 if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7]))
2007 badworden &= (~BIT(3));
2008 }
2009
2010 return badworden;
2011 }
2012
2013 static void
hal_EfuseConstructPGPkt(u8 offset,u8 word_en,u8 * pData,PPGPKT_STRUCT pTargetPkt)2014 hal_EfuseConstructPGPkt(
2015 u8 offset,
2016 u8 word_en,
2017 u8 *pData,
2018 PPGPKT_STRUCT pTargetPkt)
2019 {
2020 _rtw_memset(pTargetPkt->data, 0xFF, PGPKT_DATA_SIZE);
2021 pTargetPkt->offset = offset;
2022 pTargetPkt->word_en = word_en;
2023 efuse_WordEnableDataRead(word_en, pData, pTargetPkt->data);
2024 pTargetPkt->word_cnts = Efuse_CalculateWordCnts(pTargetPkt->word_en);
2025 }
2026
2027 static u8
hal_EfusePgPacketWriteData(PADAPTER pAdapter,u8 efuseType,u16 * pAddr,PPGPKT_STRUCT pTargetPkt,u8 bPseudoTest)2028 hal_EfusePgPacketWriteData(
2029 PADAPTER pAdapter,
2030 u8 efuseType,
2031 u16 *pAddr,
2032 PPGPKT_STRUCT pTargetPkt,
2033 u8 bPseudoTest)
2034 {
2035 u16 efuse_addr;
2036 u8 badworden;
2037
2038 efuse_addr = *pAddr;
2039 badworden = Hal_EfuseWordEnableDataWrite(pAdapter, efuse_addr + 1, pTargetPkt->word_en, pTargetPkt->data, bPseudoTest);
2040 if (badworden != 0x0F) {
2041 RTW_INFO("%s: Fail!!\n", __FUNCTION__);
2042 return _FALSE;
2043 } else
2044 RTW_INFO("%s: OK!!\n", __FUNCTION__);
2045
2046 return _TRUE;
2047 }
2048
efuse_OneByteRead(struct _ADAPTER * a,u16 addr,u8 * data,u8 bPseudoTest)2049 u8 efuse_OneByteRead(struct _ADAPTER *a, u16 addr, u8 *data, u8 bPseudoTest)
2050 {
2051 struct dvobj_priv *d;
2052 int err;
2053 u8 ret = _TRUE;
2054
2055 d = adapter_to_dvobj(a);
2056 err = rtw_halmac_read_physical_efuse(d, addr, 1, data);
2057 if (err) {
2058 RTW_ERR("%s: addr=0x%x FAIL!!!\n", __FUNCTION__, addr);
2059 ret = _FALSE;
2060 }
2061
2062 return ret;
2063
2064 }
2065
2066
2067 static u8
hal_BT_EfusePgCheckAvailableAddr(PADAPTER pAdapter,u8 bPseudoTest)2068 hal_BT_EfusePgCheckAvailableAddr(
2069 PADAPTER pAdapter,
2070 u8 bPseudoTest)
2071 {
2072 u16 max_available = EFUSE_BT_REAL_CONTENT_LEN - EFUSE_PROTECT_BYTES_BANK;
2073 u16 current_size = 0;
2074
2075 RTW_INFO("%s: max_available=%d\n", __FUNCTION__, max_available);
2076 current_size = hal_EfuseGetCurrentSize_BT(pAdapter, bPseudoTest);
2077 if (current_size >= max_available) {
2078 RTW_INFO("%s: Error!! current_size(%d)>max_available(%d)\n", __FUNCTION__, current_size, max_available);
2079 return _FALSE;
2080 }
2081 return _TRUE;
2082 }
2083
EfusePgPacketWrite_BT(PADAPTER pAdapter,u8 offset,u8 word_en,u8 * pData,u8 bPseudoTest)2084 u8 EfusePgPacketWrite_BT(
2085 PADAPTER pAdapter,
2086 u8 offset,
2087 u8 word_en,
2088 u8 *pData,
2089 u8 bPseudoTest)
2090 {
2091 PGPKT_STRUCT targetPkt;
2092 u16 startAddr = 0;
2093 u8 efuseType = EFUSE_BT;
2094
2095 if (!hal_BT_EfusePgCheckAvailableAddr(pAdapter, bPseudoTest))
2096 return _FALSE;
2097
2098 hal_EfuseConstructPGPkt(offset, word_en, pData, &targetPkt);
2099
2100 if (!hal_EfusePartialWriteCheck(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
2101 return _FALSE;
2102
2103 if (!hal_EfusePgPacketWriteHeader(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
2104 return _FALSE;
2105
2106 if (!hal_EfusePgPacketWriteData(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
2107 return _FALSE;
2108
2109 return _TRUE;
2110 }
2111
2112
2113 #else /* !RTW_HALMAC */
2114 /* ------------------------------------------------------------------------------ */
2115 #define REG_EFUSE_CTRL 0x0030
2116 #define EFUSE_CTRL REG_EFUSE_CTRL /* E-Fuse Control. */
2117 /* ------------------------------------------------------------------------------ */
2118
2119
2120 BOOLEAN
2121 Efuse_Read1ByteFromFakeContent(
2122 PADAPTER pAdapter,
2123 u16 Offset,
2124 u8 *Value);
2125 BOOLEAN
Efuse_Read1ByteFromFakeContent(PADAPTER pAdapter,u16 Offset,u8 * Value)2126 Efuse_Read1ByteFromFakeContent(
2127 PADAPTER pAdapter,
2128 u16 Offset,
2129 u8 *Value)
2130 {
2131 if (Offset >= EFUSE_MAX_HW_SIZE)
2132 return _FALSE;
2133 /* DbgPrint("Read fake content, offset = %d\n", Offset); */
2134 if (fakeEfuseBank == 0)
2135 *Value = fakeEfuseContent[Offset];
2136 else
2137 *Value = fakeBTEfuseContent[fakeEfuseBank - 1][Offset];
2138 return _TRUE;
2139 }
2140
2141 BOOLEAN
2142 Efuse_Write1ByteToFakeContent(
2143 PADAPTER pAdapter,
2144 u16 Offset,
2145 u8 Value);
2146 BOOLEAN
Efuse_Write1ByteToFakeContent(PADAPTER pAdapter,u16 Offset,u8 Value)2147 Efuse_Write1ByteToFakeContent(
2148 PADAPTER pAdapter,
2149 u16 Offset,
2150 u8 Value)
2151 {
2152 if (Offset >= EFUSE_MAX_HW_SIZE)
2153 return _FALSE;
2154 if (fakeEfuseBank == 0)
2155 fakeEfuseContent[Offset] = Value;
2156 else
2157 fakeBTEfuseContent[fakeEfuseBank - 1][Offset] = Value;
2158 return _TRUE;
2159 }
2160
2161 /*-----------------------------------------------------------------------------
2162 * Function: Efuse_PowerSwitch
2163 *
2164 * Overview: When we want to enable write operation, we should change to
2165 * pwr on state. When we stop write, we should switch to 500k mode
2166 * and disable LDO 2.5V.
2167 *
2168 * Input: NONE
2169 *
2170 * Output: NONE
2171 *
2172 * Return: NONE
2173 *
2174 * Revised History:
2175 * When Who Remark
2176 * 11/17/2008 MHC Create Version 0.
2177 *
2178 *---------------------------------------------------------------------------*/
2179 void
Efuse_PowerSwitch(PADAPTER pAdapter,u8 bWrite,u8 PwrState)2180 Efuse_PowerSwitch(
2181 PADAPTER pAdapter,
2182 u8 bWrite,
2183 u8 PwrState)
2184 {
2185 pAdapter->hal_func.EfusePowerSwitch(pAdapter, bWrite, PwrState);
2186 }
2187
2188 void
BTEfuse_PowerSwitch(PADAPTER pAdapter,u8 bWrite,u8 PwrState)2189 BTEfuse_PowerSwitch(
2190 PADAPTER pAdapter,
2191 u8 bWrite,
2192 u8 PwrState)
2193 {
2194 if (pAdapter->hal_func.BTEfusePowerSwitch)
2195 pAdapter->hal_func.BTEfusePowerSwitch(pAdapter, bWrite, PwrState);
2196 }
2197
2198 /*-----------------------------------------------------------------------------
2199 * Function: efuse_GetCurrentSize
2200 *
2201 * Overview: Get current efuse size!!!
2202 *
2203 * Input: NONE
2204 *
2205 * Output: NONE
2206 *
2207 * Return: NONE
2208 *
2209 * Revised History:
2210 * When Who Remark
2211 * 11/16/2008 MHC Create Version 0.
2212 *
2213 *---------------------------------------------------------------------------*/
2214 u16
Efuse_GetCurrentSize(PADAPTER pAdapter,u8 efuseType,BOOLEAN bPseudoTest)2215 Efuse_GetCurrentSize(
2216 PADAPTER pAdapter,
2217 u8 efuseType,
2218 BOOLEAN bPseudoTest)
2219 {
2220 u16 ret = 0;
2221
2222 ret = pAdapter->hal_func.EfuseGetCurrentSize(pAdapter, efuseType, bPseudoTest);
2223
2224 return ret;
2225 }
2226
2227 /*
2228 * Description:
2229 * Execute E-Fuse read byte operation.
2230 * Refered from SD1 Richard.
2231 *
2232 * Assumption:
2233 * 1. Boot from E-Fuse and successfully auto-load.
2234 * 2. PASSIVE_LEVEL (USB interface)
2235 *
2236 * Created by Roger, 2008.10.21.
2237 * */
2238 void
ReadEFuseByte(PADAPTER Adapter,u16 _offset,u8 * pbuf,BOOLEAN bPseudoTest)2239 ReadEFuseByte(
2240 PADAPTER Adapter,
2241 u16 _offset,
2242 u8 *pbuf,
2243 BOOLEAN bPseudoTest)
2244 {
2245 u32 value32;
2246 u8 readbyte;
2247 u16 retry;
2248 /* systime start=rtw_get_current_time(); */
2249
2250 if (bPseudoTest) {
2251 Efuse_Read1ByteFromFakeContent(Adapter, _offset, pbuf);
2252 return;
2253 }
2254 if (IS_HARDWARE_TYPE_8723B(Adapter)) {
2255 /* <20130121, Kordan> For SMIC S55 EFUSE specificatoin. */
2256 /* 0x34[11]: SW force PGMEN input of efuse to high. (for the bank selected by 0x34[9:8]) */
2257 phy_set_mac_reg(Adapter, EFUSE_TEST, BIT11, 0);
2258 }
2259 /* Write Address */
2260 rtw_write8(Adapter, EFUSE_CTRL + 1, (_offset & 0xff));
2261 readbyte = rtw_read8(Adapter, EFUSE_CTRL + 2);
2262 rtw_write8(Adapter, EFUSE_CTRL + 2, ((_offset >> 8) & 0x03) | (readbyte & 0xfc));
2263
2264 /* Write bit 32 0 */
2265 readbyte = rtw_read8(Adapter, EFUSE_CTRL + 3);
2266 rtw_write8(Adapter, EFUSE_CTRL + 3, (readbyte & 0x7f));
2267
2268 /* Check bit 32 read-ready */
2269 retry = 0;
2270 value32 = rtw_read32(Adapter, EFUSE_CTRL);
2271 /* while(!(((value32 >> 24) & 0xff) & 0x80) && (retry<10)) */
2272 while (!(((value32 >> 24) & 0xff) & 0x80) && (retry < 10000)) {
2273 value32 = rtw_read32(Adapter, EFUSE_CTRL);
2274 retry++;
2275 }
2276
2277 /* 20100205 Joseph: Add delay suggested by SD1 Victor. */
2278 /* This fix the problem that Efuse read error in high temperature condition. */
2279 /* Designer says that there shall be some delay after ready bit is set, or the */
2280 /* result will always stay on last data we read. */
2281 rtw_udelay_os(50);
2282 value32 = rtw_read32(Adapter, EFUSE_CTRL);
2283
2284 *pbuf = (u8)(value32 & 0xff);
2285 /* RTW_INFO("ReadEFuseByte _offset:%08u, in %d ms\n",_offset ,rtw_get_passing_time_ms(start)); */
2286
2287 }
2288
2289 /*
2290 * Description:
2291 * 1. Execute E-Fuse read byte operation according as map offset and
2292 * save to E-Fuse table.
2293 * 2. Refered from SD1 Richard.
2294 *
2295 * Assumption:
2296 * 1. Boot from E-Fuse and successfully auto-load.
2297 * 2. PASSIVE_LEVEL (USB interface)
2298 *
2299 * Created by Roger, 2008.10.21.
2300 *
2301 * 2008/12/12 MH 1. Reorganize code flow and reserve bytes. and add description.
2302 * 2. Add efuse utilization collect.
2303 * 2008/12/22 MH Read Efuse must check if we write section 1 data again!!! Sec1
2304 * write addr must be after sec5.
2305 * */
2306
2307 void
2308 efuse_ReadEFuse(
2309 PADAPTER Adapter,
2310 u8 efuseType,
2311 u16 _offset,
2312 u16 _size_byte,
2313 u8 *pbuf,
2314 BOOLEAN bPseudoTest
2315 );
2316 void
efuse_ReadEFuse(PADAPTER Adapter,u8 efuseType,u16 _offset,u16 _size_byte,u8 * pbuf,BOOLEAN bPseudoTest)2317 efuse_ReadEFuse(
2318 PADAPTER Adapter,
2319 u8 efuseType,
2320 u16 _offset,
2321 u16 _size_byte,
2322 u8 *pbuf,
2323 BOOLEAN bPseudoTest
2324 )
2325 {
2326 Adapter->hal_func.ReadEFuse(Adapter, efuseType, _offset, _size_byte, pbuf, bPseudoTest);
2327 }
2328
2329 void
EFUSE_GetEfuseDefinition(PADAPTER pAdapter,u8 efuseType,u8 type,void * pOut,BOOLEAN bPseudoTest)2330 EFUSE_GetEfuseDefinition(
2331 PADAPTER pAdapter,
2332 u8 efuseType,
2333 u8 type,
2334 void *pOut,
2335 BOOLEAN bPseudoTest
2336 )
2337 {
2338 pAdapter->hal_func.EFUSEGetEfuseDefinition(pAdapter, efuseType, type, pOut, bPseudoTest);
2339 }
2340
2341
2342 /* 11/16/2008 MH Read one byte from real Efuse. */
2343 u8
efuse_OneByteRead(PADAPTER pAdapter,u16 addr,u8 * data,BOOLEAN bPseudoTest)2344 efuse_OneByteRead(
2345 PADAPTER pAdapter,
2346 u16 addr,
2347 u8 *data,
2348 BOOLEAN bPseudoTest)
2349 {
2350 u32 tmpidx = 0;
2351 u8 bResult;
2352 u8 readbyte;
2353 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);
2354
2355 /* RTW_INFO("===> EFUSE_OneByteRead(), addr = %x\n", addr); */
2356 /* RTW_INFO("===> EFUSE_OneByteRead() start, 0x34 = 0x%X\n", rtw_read32(pAdapter, EFUSE_TEST)); */
2357
2358 if (bPseudoTest) {
2359 bResult = Efuse_Read1ByteFromFakeContent(pAdapter, addr, data);
2360 return bResult;
2361 }
2362
2363 #ifdef CONFIG_RTL8710B
2364 /* <20171208, Peter>, Dont do the following write16(0x34) */
2365 if (IS_HARDWARE_TYPE_8710B(pAdapter)) {
2366 bResult = pAdapter->hal_func.efuse_indirect_read4(pAdapter, addr, data);
2367 return bResult;
2368 }
2369 #endif
2370
2371 if (IS_HARDWARE_TYPE_8723B(pAdapter) ||
2372 (IS_HARDWARE_TYPE_8192E(pAdapter) && (!IS_A_CUT(pHalData->version_id))) ||
2373 (IS_VENDOR_8188E_I_CUT_SERIES(pAdapter)) || (IS_CHIP_VENDOR_SMIC(pHalData->version_id))
2374 ) {
2375 /* <20130121, Kordan> For SMIC EFUSE specificatoin. */
2376 /* 0x34[11]: SW force PGMEN input of efuse to high. (for the bank selected by 0x34[9:8]) */
2377 /* phy_set_mac_reg(pAdapter, 0x34, BIT11, 0); */
2378 rtw_write16(pAdapter, 0x34, rtw_read16(pAdapter, 0x34) & (~BIT11));
2379 }
2380
2381 /* -----------------e-fuse reg ctrl --------------------------------- */
2382 /* address */
2383 rtw_write8(pAdapter, EFUSE_CTRL + 1, (u8)(addr & 0xff));
2384 rtw_write8(pAdapter, EFUSE_CTRL + 2, ((u8)((addr >> 8) & 0x03)) |
2385 (rtw_read8(pAdapter, EFUSE_CTRL + 2) & 0xFC));
2386
2387 /* rtw_write8(pAdapter, EFUSE_CTRL+3, 0x72); */ /* read cmd */
2388 /* Write bit 32 0 */
2389 readbyte = rtw_read8(pAdapter, EFUSE_CTRL + 3);
2390 rtw_write8(pAdapter, EFUSE_CTRL + 3, (readbyte & 0x7f));
2391
2392 while (!(0x80 & rtw_read8(pAdapter, EFUSE_CTRL + 3)) && (tmpidx < 1000)) {
2393 rtw_mdelay_os(1);
2394 tmpidx++;
2395 }
2396 if (tmpidx < 100) {
2397 *data = rtw_read8(pAdapter, EFUSE_CTRL);
2398 bResult = _TRUE;
2399 } else {
2400 *data = 0xff;
2401 bResult = _FALSE;
2402 RTW_INFO("%s: [ERROR] addr=0x%x bResult=%d time out 1s !!!\n", __FUNCTION__, addr, bResult);
2403 RTW_INFO("%s: [ERROR] EFUSE_CTRL =0x%08x !!!\n", __FUNCTION__, rtw_read32(pAdapter, EFUSE_CTRL));
2404 }
2405
2406 return bResult;
2407 }
2408
2409 /* 11/16/2008 MH Write one byte to reald Efuse. */
2410 u8
efuse_OneByteWrite(PADAPTER pAdapter,u16 addr,u8 data,BOOLEAN bPseudoTest)2411 efuse_OneByteWrite(
2412 PADAPTER pAdapter,
2413 u16 addr,
2414 u8 data,
2415 BOOLEAN bPseudoTest)
2416 {
2417 u8 tmpidx = 0;
2418 u8 bResult = _FALSE;
2419 u32 efuseValue = 0;
2420 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);
2421
2422 /* RTW_INFO("===> EFUSE_OneByteWrite(), addr = %x data=%x\n", addr, data); */
2423 /* RTW_INFO("===> EFUSE_OneByteWrite() start, 0x34 = 0x%X\n", rtw_read32(pAdapter, EFUSE_TEST)); */
2424
2425 if (bPseudoTest) {
2426 bResult = Efuse_Write1ByteToFakeContent(pAdapter, addr, data);
2427 return bResult;
2428 }
2429
2430 Efuse_PowerSwitch(pAdapter, _TRUE, _TRUE);
2431
2432 /* -----------------e-fuse reg ctrl --------------------------------- */
2433 /* address */
2434
2435
2436 efuseValue = rtw_read32(pAdapter, EFUSE_CTRL);
2437 efuseValue |= (BIT21 | BIT31);
2438 efuseValue &= ~(0x3FFFF);
2439 efuseValue |= ((addr << 8 | data) & 0x3FFFF);
2440
2441 /* <20130227, Kordan> 8192E MP chip A-cut had better not set 0x34[11] until B-Cut. */
2442 if (IS_HARDWARE_TYPE_8723B(pAdapter) ||
2443 (IS_HARDWARE_TYPE_8192E(pAdapter) && (!IS_A_CUT(pHalData->version_id))) ||
2444 (IS_VENDOR_8188E_I_CUT_SERIES(pAdapter)) || (IS_CHIP_VENDOR_SMIC(pHalData->version_id))
2445 ) {
2446 /* <20130121, Kordan> For SMIC EFUSE specificatoin. */
2447 /* 0x34[11]: SW force PGMEN input of efuse to high. (for the bank selected by 0x34[9:8]) */
2448 /* phy_set_mac_reg(pAdapter, 0x34, BIT11, 1); */
2449 rtw_write16(pAdapter, 0x34, rtw_read16(pAdapter, 0x34) | (BIT11));
2450 rtw_write32(pAdapter, EFUSE_CTRL, 0x90600000 | ((addr << 8 | data)));
2451 } else
2452 rtw_write32(pAdapter, EFUSE_CTRL, efuseValue);
2453
2454 rtw_mdelay_os(1);
2455
2456 while ((0x80 & rtw_read8(pAdapter, EFUSE_CTRL + 3)) && (tmpidx < 100)) {
2457 rtw_mdelay_os(1);
2458 tmpidx++;
2459 }
2460
2461 if (tmpidx < 100)
2462 bResult = _TRUE;
2463 else {
2464 bResult = _FALSE;
2465 RTW_INFO("%s: [ERROR] addr=0x%x ,efuseValue=0x%x ,bResult=%d time out 1s !!!\n",
2466 __FUNCTION__, addr, efuseValue, bResult);
2467 RTW_INFO("%s: [ERROR] EFUSE_CTRL =0x%08x !!!\n", __FUNCTION__, rtw_read32(pAdapter, EFUSE_CTRL));
2468 }
2469
2470 /* disable Efuse program enable */
2471 if (IS_HARDWARE_TYPE_8723B(pAdapter) ||
2472 (IS_HARDWARE_TYPE_8192E(pAdapter) && (!IS_A_CUT(pHalData->version_id))) ||
2473 (IS_VENDOR_8188E_I_CUT_SERIES(pAdapter)) || (IS_CHIP_VENDOR_SMIC(pHalData->version_id))
2474 )
2475 phy_set_mac_reg(pAdapter, EFUSE_TEST, BIT(11), 0);
2476
2477 Efuse_PowerSwitch(pAdapter, _TRUE, _FALSE);
2478
2479 return bResult;
2480 }
2481
2482 int
Efuse_PgPacketRead(PADAPTER pAdapter,u8 offset,u8 * data,BOOLEAN bPseudoTest)2483 Efuse_PgPacketRead(PADAPTER pAdapter,
2484 u8 offset,
2485 u8 *data,
2486 BOOLEAN bPseudoTest)
2487 {
2488 int ret = 0;
2489
2490 ret = pAdapter->hal_func.Efuse_PgPacketRead(pAdapter, offset, data, bPseudoTest);
2491
2492 return ret;
2493 }
2494
2495 int
Efuse_PgPacketWrite(PADAPTER pAdapter,u8 offset,u8 word_en,u8 * data,BOOLEAN bPseudoTest)2496 Efuse_PgPacketWrite(PADAPTER pAdapter,
2497 u8 offset,
2498 u8 word_en,
2499 u8 *data,
2500 BOOLEAN bPseudoTest)
2501 {
2502 int ret;
2503
2504 ret = pAdapter->hal_func.Efuse_PgPacketWrite(pAdapter, offset, word_en, data, bPseudoTest);
2505
2506 return ret;
2507 }
2508
2509
2510 int
Efuse_PgPacketWrite_BT(PADAPTER pAdapter,u8 offset,u8 word_en,u8 * data,BOOLEAN bPseudoTest)2511 Efuse_PgPacketWrite_BT(PADAPTER pAdapter,
2512 u8 offset,
2513 u8 word_en,
2514 u8 *data,
2515 BOOLEAN bPseudoTest)
2516 {
2517 int ret;
2518
2519 ret = pAdapter->hal_func.Efuse_PgPacketWrite_BT(pAdapter, offset, word_en, data, bPseudoTest);
2520
2521 return ret;
2522 }
2523
2524
2525 u8
Efuse_WordEnableDataWrite(PADAPTER pAdapter,u16 efuse_addr,u8 word_en,u8 * data,BOOLEAN bPseudoTest)2526 Efuse_WordEnableDataWrite(PADAPTER pAdapter,
2527 u16 efuse_addr,
2528 u8 word_en,
2529 u8 *data,
2530 BOOLEAN bPseudoTest)
2531 {
2532 u8 ret = 0;
2533
2534 ret = pAdapter->hal_func.Efuse_WordEnableDataWrite(pAdapter, efuse_addr, word_en, data, bPseudoTest);
2535
2536 return ret;
2537 }
2538
efuse_read8(PADAPTER padapter,u16 address,u8 * value)2539 static u8 efuse_read8(PADAPTER padapter, u16 address, u8 *value)
2540 {
2541 return efuse_OneByteRead(padapter, address, value, _FALSE);
2542 }
2543
efuse_write8(PADAPTER padapter,u16 address,u8 * value)2544 static u8 efuse_write8(PADAPTER padapter, u16 address, u8 *value)
2545 {
2546 return efuse_OneByteWrite(padapter, address, *value, _FALSE);
2547 }
2548
2549 /*
2550 * read/wirte raw efuse data
2551 */
rtw_efuse_access(PADAPTER padapter,u8 bWrite,u16 start_addr,u16 cnts,u8 * data)2552 u8 rtw_efuse_access(PADAPTER padapter, u8 bWrite, u16 start_addr, u16 cnts, u8 *data)
2553 {
2554 int i = 0;
2555 u16 real_content_len = 0, max_available_size = 0;
2556 u8 res = _FAIL ;
2557 u8(*rw8)(PADAPTER, u16, u8 *);
2558 u32 backupRegs[4] = {0};
2559
2560
2561 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_REAL_CONTENT_LEN, (void *)&real_content_len, _FALSE);
2562 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, _FALSE);
2563
2564 if (start_addr > real_content_len)
2565 return _FAIL;
2566
2567 if (_TRUE == bWrite) {
2568 if ((start_addr + cnts) > max_available_size)
2569 return _FAIL;
2570 rw8 = &efuse_write8;
2571 } else
2572 rw8 = &efuse_read8;
2573
2574 efuse_PreUpdateAction(padapter, backupRegs);
2575
2576 Efuse_PowerSwitch(padapter, bWrite, _TRUE);
2577
2578 /* e-fuse one byte read / write */
2579 for (i = 0; i < cnts; i++) {
2580 if (start_addr >= real_content_len) {
2581 res = _FAIL;
2582 break;
2583 }
2584
2585 res = rw8(padapter, start_addr++, data++);
2586 if (_FAIL == res)
2587 break;
2588 }
2589
2590 Efuse_PowerSwitch(padapter, bWrite, _FALSE);
2591
2592 efuse_PostUpdateAction(padapter, backupRegs);
2593
2594 return res;
2595 }
2596 /* ------------------------------------------------------------------------------ */
efuse_GetMaxSize(PADAPTER padapter)2597 u16 efuse_GetMaxSize(PADAPTER padapter)
2598 {
2599 u16 max_size;
2600
2601 max_size = 0;
2602 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI , TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_size, _FALSE);
2603 return max_size;
2604 }
2605 /* ------------------------------------------------------------------------------ */
efuse_GetCurrentSize(PADAPTER padapter,u16 * size)2606 u8 efuse_GetCurrentSize(PADAPTER padapter, u16 *size)
2607 {
2608 Efuse_PowerSwitch(padapter, _FALSE, _TRUE);
2609 *size = Efuse_GetCurrentSize(padapter, EFUSE_WIFI, _FALSE);
2610 Efuse_PowerSwitch(padapter, _FALSE, _FALSE);
2611
2612 return _SUCCESS;
2613 }
2614 /* ------------------------------------------------------------------------------ */
efuse_bt_GetMaxSize(PADAPTER padapter)2615 u16 efuse_bt_GetMaxSize(PADAPTER padapter)
2616 {
2617 u16 max_size;
2618
2619 max_size = 0;
2620 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT , TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_size, _FALSE);
2621 return max_size;
2622 }
2623
efuse_bt_GetCurrentSize(PADAPTER padapter,u16 * size)2624 u8 efuse_bt_GetCurrentSize(PADAPTER padapter, u16 *size)
2625 {
2626 Efuse_PowerSwitch(padapter, _FALSE, _TRUE);
2627 *size = Efuse_GetCurrentSize(padapter, EFUSE_BT, _FALSE);
2628 Efuse_PowerSwitch(padapter, _FALSE, _FALSE);
2629
2630 return _SUCCESS;
2631 }
2632
rtw_efuse_map_read(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)2633 u8 rtw_efuse_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
2634 {
2635 u16 mapLen = 0;
2636
2637 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
2638
2639 if ((addr + cnts) > mapLen)
2640 return _FAIL;
2641
2642 Efuse_PowerSwitch(padapter, _FALSE, _TRUE);
2643
2644 efuse_ReadEFuse(padapter, EFUSE_WIFI, addr, cnts, data, _FALSE);
2645
2646 Efuse_PowerSwitch(padapter, _FALSE, _FALSE);
2647
2648 return _SUCCESS;
2649 }
2650
rtw_BT_efuse_map_read(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)2651 u8 rtw_BT_efuse_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
2652 {
2653 u16 mapLen = 0;
2654
2655 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
2656
2657 if ((addr + cnts) > mapLen)
2658 return _FAIL;
2659
2660 Efuse_PowerSwitch(padapter, _FALSE, _TRUE);
2661
2662 efuse_ReadEFuse(padapter, EFUSE_BT, addr, cnts, data, _FALSE);
2663
2664 Efuse_PowerSwitch(padapter, _FALSE, _FALSE);
2665
2666 return _SUCCESS;
2667 }
2668
2669 /* ------------------------------------------------------------------------------ */
rtw_efuse_map_write(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)2670 u8 rtw_efuse_map_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
2671 {
2672 #define RT_ASSERT_RET(expr) \
2673 if (!(expr)) { \
2674 printk("Assertion failed! %s at ......\n", #expr); \
2675 printk(" ......%s,%s, line=%d\n",__FILE__, __FUNCTION__, __LINE__); \
2676 return _FAIL; \
2677 }
2678
2679 u8 *efuse = NULL;
2680 u8 offset, word_en;
2681 u8 *map = NULL;
2682 u8 newdata[PGPKT_DATA_SIZE];
2683 s32 i, j, idx, chk_total_byte;
2684 u8 ret = _SUCCESS;
2685 u16 mapLen = 0, startAddr = 0, efuse_max_available_len = 0;
2686 u32 backupRegs[4] = {0};
2687 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
2688 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
2689
2690
2691 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
2692 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &efuse_max_available_len, _FALSE);
2693
2694 if ((addr + cnts) > mapLen)
2695 return _FAIL;
2696
2697 RT_ASSERT_RET(PGPKT_DATA_SIZE == 8); /* have to be 8 byte alignment */
2698 RT_ASSERT_RET((mapLen & 0x7) == 0); /* have to be PGPKT_DATA_SIZE alignment for memcpy */
2699
2700 efuse = rtw_zmalloc(mapLen);
2701 if (!efuse)
2702 return _FAIL;
2703
2704 map = rtw_zmalloc(mapLen);
2705 if (map == NULL) {
2706 rtw_mfree(efuse, mapLen);
2707 return _FAIL;
2708 }
2709
2710 _rtw_memset(map, 0xFF, mapLen);
2711
2712 ret = rtw_efuse_map_read(padapter, 0, mapLen, map);
2713 if (ret == _FAIL)
2714 goto exit;
2715
2716 _rtw_memcpy(efuse , map, mapLen);
2717 _rtw_memcpy(efuse + addr, data, cnts);
2718
2719 if (padapter->registrypriv.boffefusemask == 0) {
2720 for (i = 0; i < cnts; i++) {
2721 if (padapter->registrypriv.bFileMaskEfuse == _TRUE) {
2722 if (rtw_file_efuse_IsMasked(padapter, addr + i, maskfileBuffer)) /*use file efuse mask. */
2723 efuse[addr + i] = map[addr + i];
2724 } else {
2725 if (efuse_IsMasked(padapter, addr + i))
2726 efuse[addr + i] = map[addr + i];
2727 }
2728 RTW_INFO("%s , data[%d] = %x, map[addr+i]= %x\n", __func__, addr + i, efuse[ addr + i], map[addr + i]);
2729 }
2730 }
2731 /*Efuse_PowerSwitch(padapter, _TRUE, _TRUE);*/
2732
2733 chk_total_byte = 0;
2734 idx = 0;
2735 offset = (addr >> 3);
2736
2737 while (idx < cnts) {
2738 word_en = 0xF;
2739 j = (addr + idx) & 0x7;
2740 for (i = j; i < PGPKT_DATA_SIZE && idx < cnts; i++, idx++) {
2741 if (efuse[addr + idx] != map[addr + idx])
2742 word_en &= ~BIT(i >> 1);
2743 }
2744
2745 if (word_en != 0xF) {
2746 chk_total_byte += Efuse_CalculateWordCnts(word_en) * 2;
2747
2748 if (offset >= EFUSE_MAX_SECTION_BASE) /* Over EFUSE_MAX_SECTION 16 for 2 ByteHeader */
2749 chk_total_byte += 2;
2750 else
2751 chk_total_byte += 1;
2752 }
2753
2754 offset++;
2755 }
2756
2757 RTW_INFO("Total PG bytes Count = %d\n", chk_total_byte);
2758 rtw_hal_get_hwreg(padapter, HW_VAR_EFUSE_BYTES, (u8 *)&startAddr);
2759
2760 if (startAddr == 0) {
2761 startAddr = Efuse_GetCurrentSize(padapter, EFUSE_WIFI, _FALSE);
2762 RTW_INFO("%s: Efuse_GetCurrentSize startAddr=%#X\n", __func__, startAddr);
2763 }
2764 RTW_DBG("%s: startAddr=%#X\n", __func__, startAddr);
2765
2766 if ((startAddr + chk_total_byte) >= efuse_max_available_len) {
2767 RTW_INFO("%s: startAddr(0x%X) + PG data len %d >= efuse_max_available_len(0x%X)\n",
2768 __func__, startAddr, chk_total_byte, efuse_max_available_len);
2769 ret = _FAIL;
2770 goto exit;
2771 }
2772
2773 efuse_PreUpdateAction(padapter, backupRegs);
2774
2775 idx = 0;
2776 offset = (addr >> 3);
2777 while (idx < cnts) {
2778 word_en = 0xF;
2779 j = (addr + idx) & 0x7;
2780 _rtw_memcpy(newdata, &map[offset << 3], PGPKT_DATA_SIZE);
2781 for (i = j; i < PGPKT_DATA_SIZE && idx < cnts; i++, idx++) {
2782 if (efuse[addr + idx] != map[addr + idx]) {
2783 word_en &= ~BIT(i >> 1);
2784 newdata[i] = efuse[addr + idx];
2785 #ifdef CONFIG_RTL8723B
2786 if (addr + idx == 0x8) {
2787 if (IS_C_CUT(pHalData->version_id) || IS_B_CUT(pHalData->version_id)) {
2788 if (pHalData->adjuseVoltageVal == 6) {
2789 newdata[i] = map[addr + idx];
2790 RTW_INFO(" %s ,\n adjuseVoltageVal = %d ,newdata[%d] = %x\n", __func__, pHalData->adjuseVoltageVal, i, newdata[i]);
2791 }
2792 }
2793 }
2794 #endif
2795 }
2796 }
2797
2798 if (word_en != 0xF) {
2799 ret = Efuse_PgPacketWrite(padapter, offset, word_en, newdata, _FALSE);
2800 RTW_INFO("offset=%x\n", offset);
2801 RTW_INFO("word_en=%x\n", word_en);
2802
2803 for (i = 0; i < PGPKT_DATA_SIZE; i++)
2804 RTW_INFO("data=%x \t", newdata[i]);
2805 if (ret == _FAIL)
2806 break;
2807 }
2808
2809 offset++;
2810 }
2811
2812 /*Efuse_PowerSwitch(padapter, _TRUE, _FALSE);*/
2813
2814 efuse_PostUpdateAction(padapter, backupRegs);
2815
2816 exit:
2817
2818 rtw_mfree(map, mapLen);
2819 rtw_mfree(efuse, mapLen);
2820
2821 return ret;
2822 }
2823
2824
rtw_BT_efuse_map_write(PADAPTER padapter,u16 addr,u16 cnts,u8 * data)2825 u8 rtw_BT_efuse_map_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data)
2826 {
2827 #define RT_ASSERT_RET(expr) \
2828 if (!(expr)) { \
2829 printk("Assertion failed! %s at ......\n", #expr); \
2830 printk(" ......%s,%s, line=%d\n",__FILE__, __FUNCTION__, __LINE__); \
2831 return _FAIL; \
2832 }
2833
2834 u8 offset, word_en;
2835 u8 *map;
2836 u8 newdata[PGPKT_DATA_SIZE];
2837 s32 i = 0, j = 0, idx;
2838 u8 ret = _SUCCESS;
2839 u16 mapLen = 0;
2840
2841 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
2842
2843 if ((addr + cnts) > mapLen)
2844 return _FAIL;
2845
2846 RT_ASSERT_RET(PGPKT_DATA_SIZE == 8); /* have to be 8 byte alignment */
2847 RT_ASSERT_RET((mapLen & 0x7) == 0); /* have to be PGPKT_DATA_SIZE alignment for memcpy */
2848
2849 map = rtw_zmalloc(mapLen);
2850 if (map == NULL)
2851 return _FAIL;
2852
2853 ret = rtw_BT_efuse_map_read(padapter, 0, mapLen, map);
2854 if (ret == _FAIL)
2855 goto exit;
2856 RTW_INFO("OFFSET\tVALUE(hex)\n");
2857 for (i = 0; i < 1024; i += 16) { /* set 512 because the iwpriv's extra size have limit 0x7FF */
2858 RTW_INFO("0x%03x\t", i);
2859 for (j = 0; j < 8; j++)
2860 RTW_INFO("%02X ", map[i + j]);
2861 RTW_INFO("\t");
2862 for (; j < 16; j++)
2863 RTW_INFO("%02X ", map[i + j]);
2864 RTW_INFO("\n");
2865 }
2866 RTW_INFO("\n");
2867 Efuse_PowerSwitch(padapter, _TRUE, _TRUE);
2868
2869 idx = 0;
2870 offset = (addr >> 3);
2871 while (idx < cnts) {
2872 word_en = 0xF;
2873 j = (addr + idx) & 0x7;
2874 _rtw_memcpy(newdata, &map[offset << 3], PGPKT_DATA_SIZE);
2875 for (i = j; i < PGPKT_DATA_SIZE && idx < cnts; i++, idx++) {
2876 if (data[idx] != map[addr + idx]) {
2877 word_en &= ~BIT(i >> 1);
2878 newdata[i] = data[idx];
2879 }
2880 }
2881
2882 if (word_en != 0xF) {
2883 RTW_INFO("offset=%x\n", offset);
2884 RTW_INFO("word_en=%x\n", word_en);
2885 RTW_INFO("%s: data=", __FUNCTION__);
2886 for (i = 0; i < PGPKT_DATA_SIZE; i++)
2887 RTW_INFO("0x%02X ", newdata[i]);
2888 RTW_INFO("\n");
2889 ret = Efuse_PgPacketWrite_BT(padapter, offset, word_en, newdata, _FALSE);
2890 if (ret == _FAIL)
2891 break;
2892 }
2893
2894 offset++;
2895 }
2896
2897 Efuse_PowerSwitch(padapter, _TRUE, _FALSE);
2898
2899 exit:
2900
2901 rtw_mfree(map, mapLen);
2902
2903 return ret;
2904 }
2905
2906 /*-----------------------------------------------------------------------------
2907 * Function: Efuse_ReadAllMap
2908 *
2909 * Overview: Read All Efuse content
2910 *
2911 * Input: NONE
2912 *
2913 * Output: NONE
2914 *
2915 * Return: NONE
2916 *
2917 * Revised History:
2918 * When Who Remark
2919 * 11/11/2008 MHC Create Version 0.
2920 *
2921 *---------------------------------------------------------------------------*/
2922 void
2923 Efuse_ReadAllMap(
2924 PADAPTER pAdapter,
2925 u8 efuseType,
2926 u8 *Efuse,
2927 BOOLEAN bPseudoTest);
2928 void
Efuse_ReadAllMap(PADAPTER pAdapter,u8 efuseType,u8 * Efuse,BOOLEAN bPseudoTest)2929 Efuse_ReadAllMap(
2930 PADAPTER pAdapter,
2931 u8 efuseType,
2932 u8 *Efuse,
2933 BOOLEAN bPseudoTest)
2934 {
2935 u16 mapLen = 0;
2936
2937 Efuse_PowerSwitch(pAdapter, _FALSE, _TRUE);
2938
2939 EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
2940
2941 efuse_ReadEFuse(pAdapter, efuseType, 0, mapLen, Efuse, bPseudoTest);
2942
2943 Efuse_PowerSwitch(pAdapter, _FALSE, _FALSE);
2944 }
2945
2946 /*-----------------------------------------------------------------------------
2947 * Function: efuse_ShadowWrite1Byte
2948 * efuse_ShadowWrite2Byte
2949 * efuse_ShadowWrite4Byte
2950 *
2951 * Overview: Write efuse modify map by one/two/four byte.
2952 *
2953 * Input: NONE
2954 *
2955 * Output: NONE
2956 *
2957 * Return: NONE
2958 *
2959 * Revised History:
2960 * When Who Remark
2961 * 11/12/2008 MHC Create Version 0.
2962 *
2963 *---------------------------------------------------------------------------*/
2964 #ifdef PLATFORM
2965 static void
2966 efuse_ShadowWrite1Byte(
2967 PADAPTER pAdapter,
2968 u16 Offset,
2969 u8 Value);
2970 #endif /* PLATFORM */
2971 static void
efuse_ShadowWrite1Byte(PADAPTER pAdapter,u16 Offset,u8 Value)2972 efuse_ShadowWrite1Byte(
2973 PADAPTER pAdapter,
2974 u16 Offset,
2975 u8 Value)
2976 {
2977 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
2978
2979 pHalData->efuse_eeprom_data[Offset] = Value;
2980
2981 } /* efuse_ShadowWrite1Byte */
2982
2983 /* ---------------Write Two Bytes */
2984 static void
efuse_ShadowWrite2Byte(PADAPTER pAdapter,u16 Offset,u16 Value)2985 efuse_ShadowWrite2Byte(
2986 PADAPTER pAdapter,
2987 u16 Offset,
2988 u16 Value)
2989 {
2990
2991 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
2992
2993
2994 pHalData->efuse_eeprom_data[Offset] = Value & 0x00FF;
2995 pHalData->efuse_eeprom_data[Offset + 1] = Value >> 8;
2996
2997 } /* efuse_ShadowWrite1Byte */
2998
2999 /* ---------------Write Four Bytes */
3000 static void
efuse_ShadowWrite4Byte(PADAPTER pAdapter,u16 Offset,u32 Value)3001 efuse_ShadowWrite4Byte(
3002 PADAPTER pAdapter,
3003 u16 Offset,
3004 u32 Value)
3005 {
3006 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
3007
3008 pHalData->efuse_eeprom_data[Offset] = (u8)(Value & 0x000000FF);
3009 pHalData->efuse_eeprom_data[Offset + 1] = (u8)((Value >> 8) & 0x0000FF);
3010 pHalData->efuse_eeprom_data[Offset + 2] = (u8)((Value >> 16) & 0x00FF);
3011 pHalData->efuse_eeprom_data[Offset + 3] = (u8)((Value >> 24) & 0xFF);
3012
3013 } /* efuse_ShadowWrite1Byte */
3014
3015
3016 /*-----------------------------------------------------------------------------
3017 * Function: EFUSE_ShadowWrite
3018 *
3019 * Overview: Write efuse modify map for later update operation to use!!!!!
3020 *
3021 * Input: NONE
3022 *
3023 * Output: NONE
3024 *
3025 * Return: NONE
3026 *
3027 * Revised History:
3028 * When Who Remark
3029 * 11/12/2008 MHC Create Version 0.
3030 *
3031 *---------------------------------------------------------------------------*/
3032 void
3033 EFUSE_ShadowWrite(
3034 PADAPTER pAdapter,
3035 u8 Type,
3036 u16 Offset,
3037 u32 Value);
3038 void
EFUSE_ShadowWrite(PADAPTER pAdapter,u8 Type,u16 Offset,u32 Value)3039 EFUSE_ShadowWrite(
3040 PADAPTER pAdapter,
3041 u8 Type,
3042 u16 Offset,
3043 u32 Value)
3044 {
3045 #if (MP_DRIVER == 0)
3046 return;
3047 #endif
3048 if (pAdapter->registrypriv.mp_mode == 0)
3049 return;
3050
3051
3052 if (Type == 1)
3053 efuse_ShadowWrite1Byte(pAdapter, Offset, (u8)Value);
3054 else if (Type == 2)
3055 efuse_ShadowWrite2Byte(pAdapter, Offset, (u16)Value);
3056 else if (Type == 4)
3057 efuse_ShadowWrite4Byte(pAdapter, Offset, (u32)Value);
3058
3059 } /* EFUSE_ShadowWrite */
3060
3061 #endif /* !RTW_HALMAC */
3062 /*-----------------------------------------------------------------------------
3063 * Function: efuse_ShadowRead1Byte
3064 * efuse_ShadowRead2Byte
3065 * efuse_ShadowRead4Byte
3066 *
3067 * Overview: Read from efuse init map by one/two/four bytes !!!!!
3068 *
3069 * Input: NONE
3070 *
3071 * Output: NONE
3072 *
3073 * Return: NONE
3074 *
3075 * Revised History:
3076 * When Who Remark
3077 * 11/12/2008 MHC Create Version 0.
3078 *
3079 *---------------------------------------------------------------------------*/
3080 static void
efuse_ShadowRead1Byte(PADAPTER pAdapter,u16 Offset,u8 * Value)3081 efuse_ShadowRead1Byte(
3082 PADAPTER pAdapter,
3083 u16 Offset,
3084 u8 *Value)
3085 {
3086 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
3087
3088 *Value = pHalData->efuse_eeprom_data[Offset];
3089
3090 } /* EFUSE_ShadowRead1Byte */
3091
3092 /* ---------------Read Two Bytes */
3093 static void
efuse_ShadowRead2Byte(PADAPTER pAdapter,u16 Offset,u16 * Value)3094 efuse_ShadowRead2Byte(
3095 PADAPTER pAdapter,
3096 u16 Offset,
3097 u16 *Value)
3098 {
3099 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
3100
3101 *Value = pHalData->efuse_eeprom_data[Offset];
3102 *Value |= pHalData->efuse_eeprom_data[Offset + 1] << 8;
3103
3104 } /* EFUSE_ShadowRead2Byte */
3105
3106 /* ---------------Read Four Bytes */
3107 static void
efuse_ShadowRead4Byte(PADAPTER pAdapter,u16 Offset,u32 * Value)3108 efuse_ShadowRead4Byte(
3109 PADAPTER pAdapter,
3110 u16 Offset,
3111 u32 *Value)
3112 {
3113 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
3114
3115 *Value = pHalData->efuse_eeprom_data[Offset];
3116 *Value |= pHalData->efuse_eeprom_data[Offset + 1] << 8;
3117 *Value |= pHalData->efuse_eeprom_data[Offset + 2] << 16;
3118 *Value |= pHalData->efuse_eeprom_data[Offset + 3] << 24;
3119
3120 } /* efuse_ShadowRead4Byte */
3121
3122 /*-----------------------------------------------------------------------------
3123 * Function: EFUSE_ShadowRead
3124 *
3125 * Overview: Read from pHalData->efuse_eeprom_data
3126 *---------------------------------------------------------------------------*/
3127 void
EFUSE_ShadowRead(PADAPTER pAdapter,u8 Type,u16 Offset,u32 * Value)3128 EFUSE_ShadowRead(
3129 PADAPTER pAdapter,
3130 u8 Type,
3131 u16 Offset,
3132 u32 *Value)
3133 {
3134 if (Type == 1)
3135 efuse_ShadowRead1Byte(pAdapter, Offset, (u8 *)Value);
3136 else if (Type == 2)
3137 efuse_ShadowRead2Byte(pAdapter, Offset, (u16 *)Value);
3138 else if (Type == 4)
3139 efuse_ShadowRead4Byte(pAdapter, Offset, (u32 *)Value);
3140
3141 } /* EFUSE_ShadowRead */
3142
3143 /* 11/16/2008 MH Add description. Get current efuse area enabled word!!. */
3144 u8
Efuse_CalculateWordCnts(u8 word_en)3145 Efuse_CalculateWordCnts(u8 word_en)
3146 {
3147 u8 word_cnts = 0;
3148 if (!(word_en & BIT(0)))
3149 word_cnts++; /* 0 : write enable */
3150 if (!(word_en & BIT(1)))
3151 word_cnts++;
3152 if (!(word_en & BIT(2)))
3153 word_cnts++;
3154 if (!(word_en & BIT(3)))
3155 word_cnts++;
3156 return word_cnts;
3157 }
3158
3159 /*-----------------------------------------------------------------------------
3160 * Function: efuse_WordEnableDataRead
3161 *
3162 * Overview: Read allowed word in current efuse section data.
3163 *
3164 * Input: NONE
3165 *
3166 * Output: NONE
3167 *
3168 * Return: NONE
3169 *
3170 * Revised History:
3171 * When Who Remark
3172 * 11/16/2008 MHC Create Version 0.
3173 * 11/21/2008 MHC Fix Write bug when we only enable late word.
3174 *
3175 *---------------------------------------------------------------------------*/
3176 void
efuse_WordEnableDataRead(u8 word_en,u8 * sourdata,u8 * targetdata)3177 efuse_WordEnableDataRead(u8 word_en,
3178 u8 *sourdata,
3179 u8 *targetdata)
3180 {
3181 if (!(word_en & BIT(0))) {
3182 targetdata[0] = sourdata[0];
3183 targetdata[1] = sourdata[1];
3184 }
3185 if (!(word_en & BIT(1))) {
3186 targetdata[2] = sourdata[2];
3187 targetdata[3] = sourdata[3];
3188 }
3189 if (!(word_en & BIT(2))) {
3190 targetdata[4] = sourdata[4];
3191 targetdata[5] = sourdata[5];
3192 }
3193 if (!(word_en & BIT(3))) {
3194 targetdata[6] = sourdata[6];
3195 targetdata[7] = sourdata[7];
3196 }
3197 }
3198
3199 /*-----------------------------------------------------------------------------
3200 * Function: EFUSE_ShadowMapUpdate
3201 *
3202 * Overview: Transfer current EFUSE content to shadow init and modify map.
3203 *
3204 * Input: NONE
3205 *
3206 * Output: NONE
3207 *
3208 * Return: NONE
3209 *
3210 * Revised History:
3211 * When Who Remark
3212 * 11/13/2008 MHC Create Version 0.
3213 *
3214 *---------------------------------------------------------------------------*/
EFUSE_ShadowMapUpdate(PADAPTER pAdapter,u8 efuseType,BOOLEAN bPseudoTest)3215 void EFUSE_ShadowMapUpdate(
3216 PADAPTER pAdapter,
3217 u8 efuseType,
3218 BOOLEAN bPseudoTest)
3219 {
3220 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);
3221 u16 mapLen = 0;
3222 #ifdef RTW_HALMAC
3223 u8 *efuse_map = NULL;
3224 int err;
3225
3226
3227 mapLen = EEPROM_MAX_SIZE;
3228 efuse_map = pHalData->efuse_eeprom_data;
3229 /* efuse default content is 0xFF */
3230 _rtw_memset(efuse_map, 0xFF, EEPROM_MAX_SIZE);
3231
3232 EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
3233 if (!mapLen) {
3234 RTW_WARN("%s: <ERROR> fail to get efuse size!\n", __FUNCTION__);
3235 mapLen = EEPROM_MAX_SIZE;
3236 }
3237 if (mapLen > EEPROM_MAX_SIZE) {
3238 RTW_WARN("%s: <ERROR> size of efuse data(%d) is large than expected(%d)!\n",
3239 __FUNCTION__, mapLen, EEPROM_MAX_SIZE);
3240 mapLen = EEPROM_MAX_SIZE;
3241 }
3242
3243 if (pHalData->bautoload_fail_flag == _FALSE) {
3244 err = rtw_halmac_read_logical_efuse_map(adapter_to_dvobj(pAdapter), efuse_map, mapLen, NULL, 0);
3245 if (err)
3246 RTW_ERR("%s: <ERROR> fail to get efuse map!\n", __FUNCTION__);
3247 }
3248 #else /* !RTW_HALMAC */
3249 EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, bPseudoTest);
3250
3251 if (pHalData->bautoload_fail_flag == _TRUE)
3252 _rtw_memset(pHalData->efuse_eeprom_data, 0xFF, mapLen);
3253 else {
3254 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
3255 if (_SUCCESS != retriveAdaptorInfoFile(pAdapter->registrypriv.adaptor_info_caching_file_path, pHalData->efuse_eeprom_data)) {
3256 #endif
3257
3258 Efuse_ReadAllMap(pAdapter, efuseType, pHalData->efuse_eeprom_data, bPseudoTest);
3259
3260 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
3261 storeAdaptorInfoFile(pAdapter->registrypriv.adaptor_info_caching_file_path, pHalData->efuse_eeprom_data);
3262 }
3263 #endif
3264 }
3265
3266 /* PlatformMoveMemory((void *)&pHalData->EfuseMap[EFUSE_MODIFY_MAP][0], */
3267 /* (void *)&pHalData->EfuseMap[EFUSE_INIT_MAP][0], mapLen); */
3268 #endif /* !RTW_HALMAC */
3269 #ifdef CONFIG_MP_INCLUDED
3270 if (rtw_mp_mode_check(pAdapter)) {
3271 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
3272
3273 if (GET_EFUSE_UPDATE_ON(pAdapter))
3274 _rtw_memcpy(pHalData->efuse_eeprom_data, pEfuseHal->fakeEfuseModifiedMap, mapLen);
3275 }
3276 #endif
3277 rtw_mask_map_read(pAdapter, 0x00, mapLen, pHalData->efuse_eeprom_data);
3278
3279 rtw_dump_cur_efuse(pAdapter);
3280 } /* EFUSE_ShadowMapUpdate */
3281
3282 const u8 _mac_hidden_max_bw_to_hal_bw_cap[MAC_HIDDEN_MAX_BW_NUM] = {
3283 0,
3284 0,
3285 (BW_CAP_160M | BW_CAP_80M | BW_CAP_40M | BW_CAP_20M | BW_CAP_10M | BW_CAP_5M),
3286 (BW_CAP_5M),
3287 (BW_CAP_10M | BW_CAP_5M),
3288 (BW_CAP_20M | BW_CAP_10M | BW_CAP_5M),
3289 (BW_CAP_40M | BW_CAP_20M | BW_CAP_10M | BW_CAP_5M),
3290 (BW_CAP_80M | BW_CAP_40M | BW_CAP_20M | BW_CAP_10M | BW_CAP_5M),
3291 };
3292
3293 const u8 _mac_hidden_proto_to_hal_proto_cap[MAC_HIDDEN_PROTOCOL_NUM] = {
3294 0,
3295 0,
3296 (PROTO_CAP_11N | PROTO_CAP_11G | PROTO_CAP_11B),
3297 (PROTO_CAP_11AC | PROTO_CAP_11N | PROTO_CAP_11G | PROTO_CAP_11B),
3298 };
3299
mac_hidden_wl_func_to_hal_wl_func(u8 func)3300 u8 mac_hidden_wl_func_to_hal_wl_func(u8 func)
3301 {
3302 u8 wl_func = 0;
3303
3304 if (func & BIT0)
3305 wl_func |= WL_FUNC_MIRACAST;
3306 if (func & BIT1)
3307 wl_func |= WL_FUNC_P2P;
3308 if (func & BIT2)
3309 wl_func |= WL_FUNC_TDLS;
3310 if (func & BIT3)
3311 wl_func |= WL_FUNC_FTM;
3312
3313 return wl_func;
3314 }
3315
3316 #ifdef PLATFORM_LINUX
3317 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
3318 /* #include <rtw_eeprom.h> */
3319
isAdaptorInfoFileValid(void)3320 int isAdaptorInfoFileValid(void)
3321 {
3322 return _TRUE;
3323 }
3324
storeAdaptorInfoFile(char * path,u8 * efuse_data)3325 int storeAdaptorInfoFile(char *path, u8 *efuse_data)
3326 {
3327 int ret = _SUCCESS;
3328
3329 if (path && efuse_data) {
3330 ret = rtw_store_to_file(path, efuse_data, EEPROM_MAX_SIZE_512);
3331 if (ret == EEPROM_MAX_SIZE)
3332 ret = _SUCCESS;
3333 else
3334 ret = _FAIL;
3335 } else {
3336 RTW_INFO("%s NULL pointer\n", __FUNCTION__);
3337 ret = _FAIL;
3338 }
3339 return ret;
3340 }
3341
retriveAdaptorInfoFile(char * path,u8 * efuse_data)3342 int retriveAdaptorInfoFile(char *path, u8 *efuse_data)
3343 {
3344 int ret = _SUCCESS;
3345 mm_segment_t oldfs;
3346 struct file *fp;
3347
3348 if (path && efuse_data) {
3349
3350 ret = rtw_retrieve_from_file(path, efuse_data, EEPROM_MAX_SIZE);
3351
3352 if (ret == EEPROM_MAX_SIZE)
3353 ret = _SUCCESS;
3354 else
3355 ret = _FAIL;
3356
3357 #if 0
3358 if (isAdaptorInfoFileValid())
3359 return 0;
3360 else
3361 return _FAIL;
3362 #endif
3363
3364 } else {
3365 RTW_INFO("%s NULL pointer\n", __FUNCTION__);
3366 ret = _FAIL;
3367 }
3368 return ret;
3369 }
3370 #endif /* CONFIG_ADAPTOR_INFO_CACHING_FILE */
3371
rtw_efuse_file_read(PADAPTER padapter,u8 * filepath,u8 * buf,u32 len)3372 u8 rtw_efuse_file_read(PADAPTER padapter, u8 *filepath, u8 *buf, u32 len)
3373 {
3374 char *ptmpbuf = NULL, *ptr;
3375 u8 val8;
3376 u32 count, i, j;
3377 int err;
3378 u32 bufsize = 4096;
3379
3380 ptmpbuf = rtw_zmalloc(bufsize);
3381 if (ptmpbuf == NULL)
3382 return _FALSE;
3383
3384 count = rtw_retrieve_from_file(filepath, ptmpbuf, bufsize);
3385 if (count <= 90) {
3386 rtw_mfree(ptmpbuf, bufsize);
3387 RTW_ERR("%s, filepatch %s, size=%d, FAIL!!\n", __FUNCTION__, filepath, count);
3388 return _FALSE;
3389 }
3390 i = 0;
3391 j = 0;
3392 ptr = ptmpbuf;
3393 while ((j < len) && (i < count)) {
3394 if (ptmpbuf[i] == '\0')
3395 break;
3396 ptr = strpbrk(&ptmpbuf[i], " \t\n\r");
3397 if (ptr) {
3398 if (ptr == &ptmpbuf[i]) {
3399 i++;
3400 continue;
3401 }
3402 /* Add string terminating null */
3403 *ptr = 0;
3404 } else {
3405 ptr = &ptmpbuf[count-1];
3406 }
3407
3408 err = sscanf(&ptmpbuf[i], "%hhx", &val8);
3409 if (err != 1) {
3410 RTW_WARN("Something wrong to parse efuse file, string=%s\n", &ptmpbuf[i]);
3411 } else {
3412 buf[j] = val8;
3413 RTW_DBG("i=%d, j=%d, 0x%02x\n", i, j, buf[j]);
3414 j++;
3415 }
3416 i = ptr - ptmpbuf + 1;
3417 }
3418 rtw_mfree(ptmpbuf, bufsize);
3419 RTW_INFO("%s, filepatch %s, size=%d, done\n", __FUNCTION__, filepath, count);
3420 return _TRUE;
3421 }
3422
3423 #if !defined(CONFIG_RTW_ANDROID_GKI)
rtw_efuse_file_store(PADAPTER padapter,u8 * filepath,u8 * buf,u32 len)3424 u8 rtw_efuse_file_store(PADAPTER padapter, u8 *filepath, u8 *buf, u32 len)
3425 {
3426 int err = 0, i = 0, j = 0, mapLen = 0 ;
3427 char *cbuf, *pchr;
3428
3429 cbuf = rtw_zmalloc(len * 3);
3430 pchr = cbuf;
3431
3432 if (filepath && buf) {
3433 if (cbuf == NULL) {
3434 RTW_INFO("%s, malloc cbuf _FAIL\n", __FUNCTION__);
3435 err = _FAIL;
3436 } else {
3437 for (i = 0; i <= len; i += 16) {
3438 for (j = 0; j < 16; j++)
3439 pchr += sprintf(pchr, "%02X ", buf[i + j]);
3440 pchr += sprintf(pchr, "\n");
3441 }
3442
3443 err = rtw_store_to_file(filepath, cbuf, strlen(cbuf));
3444 RTW_INFO("%s, rtw_store_to_file len=%d,err =%d, len(cbuf)=%zd\n", __FUNCTION__, len, err, strlen(cbuf));
3445 if (err == strlen(cbuf)) {
3446 err = _SUCCESS;
3447 RTW_INFO("%s, filepatch %s, len=%d, done\n", __FUNCTION__, filepath, len);
3448 } else {
3449 err = _FAIL;
3450 RTW_INFO("%s, filepatch %s, len=%d,err =%d, _FAIL\n", __FUNCTION__, filepath, len, err);
3451 }
3452 }
3453 }
3454 if (cbuf)
3455 rtw_mfree(cbuf, len * 3);
3456
3457 return err;
3458 }
3459 #endif /* !defined(CONFIG_RTW_ANDROID_GKI) */
3460
3461 #ifdef CONFIG_EFUSE_CONFIG_FILE
rtw_read_efuse_from_file(const char * path,u8 * buf,int map_size)3462 u32 rtw_read_efuse_from_file(const char *path, u8 *buf, int map_size)
3463 {
3464 u32 i;
3465 u8 c;
3466 u8 temp[3];
3467 u8 temp_i;
3468 u8 end = _FALSE;
3469 u32 ret = _FAIL;
3470
3471 u8 *file_data = NULL;
3472 u32 file_size = 16384, read_size, pos = 0;
3473 u8 *map = NULL;
3474
3475 if (rtw_readable_file_sz_chk(path, file_size) != _TRUE) {
3476 RTW_PRINT("%s %s is not readable\n", __func__, path);
3477 goto exit;
3478 }
3479
3480 file_data = rtw_vmalloc(file_size);
3481 if (!file_data) {
3482 RTW_ERR("%s rtw_vmalloc(%d) fail\n", __func__, file_size);
3483 goto exit;
3484 }
3485
3486 read_size = rtw_retrieve_from_file(path, file_data, file_size);
3487 if (read_size == 0) {
3488 RTW_ERR("%s read from %s fail\n", __func__, path);
3489 goto exit;
3490 }
3491
3492 map = rtw_vmalloc(map_size);
3493 if (!map) {
3494 RTW_ERR("%s rtw_vmalloc(%d) fail\n", __func__, map_size);
3495 goto exit;
3496 }
3497 _rtw_memset(map, 0xff, map_size);
3498
3499 temp[2] = 0; /* end of string '\0' */
3500
3501 for (i = 0 ; i < map_size ; i++) {
3502 temp_i = 0;
3503
3504 while (1) {
3505 if (pos >= read_size) {
3506 end = _TRUE;
3507 break;
3508 }
3509 c = file_data[pos++];
3510
3511 /* bypass spece or eol or null before first hex digit */
3512 if (temp_i == 0 && (is_eol(c) == _TRUE || is_space(c) == _TRUE || is_null(c) == _TRUE))
3513 continue;
3514
3515 if (IsHexDigit(c) == _FALSE) {
3516 RTW_ERR("%s invalid 8-bit hex format for offset:0x%03x\n", __func__, i);
3517 goto exit;
3518 }
3519
3520 temp[temp_i++] = c;
3521
3522 if (temp_i == 2) {
3523 /* parse value */
3524 if (sscanf(temp, "%hhx", &map[i]) != 1) {
3525 RTW_ERR("%s sscanf fail for offset:0x%03x\n", __func__, i);
3526 goto exit;
3527 }
3528 break;
3529 }
3530 }
3531
3532 if (end == _TRUE) {
3533 if (temp_i != 0) {
3534 RTW_ERR("%s incomplete 8-bit hex format for offset:0x%03x\n", __func__, i);
3535 goto exit;
3536 }
3537 break;
3538 }
3539 }
3540
3541 RTW_PRINT("efuse file:%s, 0x%03x byte content read\n", path, i);
3542
3543 _rtw_memcpy(buf, map, map_size);
3544
3545 ret = _SUCCESS;
3546
3547 exit:
3548 if (file_data)
3549 rtw_vmfree(file_data, file_size);
3550 if (map)
3551 rtw_vmfree(map, map_size);
3552
3553 return ret;
3554 }
3555
rtw_read_macaddr_from_file(const char * path,u8 * buf)3556 u32 rtw_read_macaddr_from_file(const char *path, u8 *buf)
3557 {
3558 u32 i;
3559 u8 temp[3];
3560 u32 ret = _FAIL;
3561
3562 u8 file_data[17];
3563 u32 read_size;
3564 u8 addr[ETH_ALEN];
3565
3566 if (rtw_is_file_readable(path) != _TRUE) {
3567 RTW_PRINT("%s %s is not readable\n", __func__, path);
3568 goto exit;
3569 }
3570
3571 read_size = rtw_retrieve_from_file(path, file_data, 17);
3572 if (read_size != 17) {
3573 RTW_ERR("%s read from %s fail\n", __func__, path);
3574 goto exit;
3575 }
3576
3577 temp[2] = 0; /* end of string '\0' */
3578
3579 for (i = 0 ; i < ETH_ALEN ; i++) {
3580 if (IsHexDigit(file_data[i * 3]) == _FALSE || IsHexDigit(file_data[i * 3 + 1]) == _FALSE) {
3581 RTW_ERR("%s invalid 8-bit hex format for address offset:%u\n", __func__, i);
3582 goto exit;
3583 }
3584
3585 if (i < ETH_ALEN - 1 && file_data[i * 3 + 2] != ':') {
3586 RTW_ERR("%s invalid separator after address offset:%u\n", __func__, i);
3587 goto exit;
3588 }
3589
3590 temp[0] = file_data[i * 3];
3591 temp[1] = file_data[i * 3 + 1];
3592 if (sscanf(temp, "%hhx", &addr[i]) != 1) {
3593 RTW_ERR("%s sscanf fail for address offset:0x%03x\n", __func__, i);
3594 goto exit;
3595 }
3596 }
3597
3598 _rtw_memcpy(buf, addr, ETH_ALEN);
3599
3600 RTW_PRINT("wifi_mac file: %s\n", path);
3601 #ifdef CONFIG_RTW_DEBUG
3602 RTW_INFO(MAC_FMT"\n", MAC_ARG(buf));
3603 #endif
3604
3605 ret = _SUCCESS;
3606
3607 exit:
3608 return ret;
3609 }
3610 #endif /* CONFIG_EFUSE_CONFIG_FILE */
3611
3612 #endif /* PLATFORM_LINUX */
3613