1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
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.
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
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 #include <osdep_service.h>
23 #include <drv_types.h>
24 #include <rtw_efuse.h>
25 #include <usb_ops_linux.h>
27 /*------------------------Define local variable------------------------------*/
29 u32 fakeEfuseUsedBytes
;
30 u8 fakeEfuseContent
[EFUSE_MAX_HW_SIZE
] = {0};
31 u8 fakeEfuseInitMap
[EFUSE_MAX_MAP_LEN
] = {0};
32 u8 fakeEfuseModifiedMap
[EFUSE_MAX_MAP_LEN
] = {0};
35 u8 BTEfuseContent
[EFUSE_MAX_BT_BANK
][EFUSE_MAX_HW_SIZE
];
36 u8 BTEfuseInitMap
[EFUSE_BT_MAX_MAP_LEN
] = {0};
37 u8 BTEfuseModifiedMap
[EFUSE_BT_MAX_MAP_LEN
] = {0};
39 u32 fakeBTEfuseUsedBytes
;
40 u8 fakeBTEfuseContent
[EFUSE_MAX_BT_BANK
][EFUSE_MAX_HW_SIZE
];
41 u8 fakeBTEfuseInitMap
[EFUSE_BT_MAX_MAP_LEN
] = {0};
42 u8 fakeBTEfuseModifiedMap
[EFUSE_BT_MAX_MAP_LEN
] = {0};
43 /*------------------------Define local variable------------------------------*/
46 #define REG_EFUSE_CTRL 0x0030
47 #define EFUSE_CTRL REG_EFUSE_CTRL /* E-Fuse Control. */
51 Efuse_Read1ByteFromFakeContent(
52 struct adapter
*pAdapter
,
56 Efuse_Read1ByteFromFakeContent(
57 struct adapter
*pAdapter
,
61 if (Offset
>= EFUSE_MAX_HW_SIZE
)
63 if (fakeEfuseBank
== 0)
64 *Value
= fakeEfuseContent
[Offset
];
66 *Value
= fakeBTEfuseContent
[fakeEfuseBank
-1][Offset
];
71 Efuse_Write1ByteToFakeContent(
72 struct adapter
*pAdapter
,
76 if (Offset
>= EFUSE_MAX_HW_SIZE
)
78 if (fakeEfuseBank
== 0)
79 fakeEfuseContent
[Offset
] = Value
;
81 fakeBTEfuseContent
[fakeEfuseBank
-1][Offset
] = Value
;
85 /*-----------------------------------------------------------------------------
86 * Function: Efuse_PowerSwitch
88 * Overview: When we want to enable write operation, we should change to
89 * pwr on state. When we stop write, we should switch to 500k mode
90 * and disable LDO 2.5V.
100 * 11/17/2008 MHC Create Version 0.
102 *---------------------------------------------------------------------------*/
105 struct adapter
*pAdapter
,
109 pAdapter
->HalFunc
.EfusePowerSwitch(pAdapter
, write
, PwrState
);
112 /*-----------------------------------------------------------------------------
113 * Function: efuse_GetCurrentSize
115 * Overview: Get current efuse size!!!
125 * 11/16/2008 MHC Create Version 0.
127 *---------------------------------------------------------------------------*/
129 Efuse_GetCurrentSize(
130 struct adapter
*pAdapter
,
135 ret
= pAdapter
->HalFunc
.EfuseGetCurrentSize(pAdapter
, pseudo
);
140 /* 11/16/2008 MH Add description. Get current efuse area enabled word!!. */
142 Efuse_CalculateWordCnts(u8 word_en
)
145 if (!(word_en
& BIT(0)))
146 word_cnts
++; /* 0 : write enable */
147 if (!(word_en
& BIT(1)))
149 if (!(word_en
& BIT(2)))
151 if (!(word_en
& BIT(3)))
158 * Execute E-Fuse read byte operation.
159 * Referred from SD1 Richard.
161 * 1. Boot from E-Fuse and successfully auto-load.
162 * 2. PASSIVE_LEVEL (USB interface)
163 * Created by Roger, 2008.10.21.
167 struct adapter
*Adapter
,
177 Efuse_Read1ByteFromFakeContent(Adapter
, _offset
, pbuf
);
182 usb_write8(Adapter
, EFUSE_CTRL
+1, (_offset
& 0xff));
183 readbyte
= usb_read8(Adapter
, EFUSE_CTRL
+2);
184 usb_write8(Adapter
, EFUSE_CTRL
+2, ((_offset
>> 8) & 0x03) | (readbyte
& 0xfc));
187 readbyte
= usb_read8(Adapter
, EFUSE_CTRL
+3);
188 usb_write8(Adapter
, EFUSE_CTRL
+3, (readbyte
& 0x7f));
190 /* Check bit 32 read-ready */
192 value32
= usb_read32(Adapter
, EFUSE_CTRL
);
193 while (!(((value32
>> 24) & 0xff) & 0x80) && (retry
< 10000)) {
194 value32
= usb_read32(Adapter
, EFUSE_CTRL
);
198 /* 20100205 Joseph: Add delay suggested by SD1 Victor. */
199 /* This fix the problem that Efuse read error in high temperature condition. */
200 /* Designer says that there shall be some delay after ready bit is set, or the */
201 /* result will always stay on last data we read. */
203 value32
= usb_read32(Adapter
, EFUSE_CTRL
);
205 *pbuf
= (u8
)(value32
& 0xff);
209 * 1. Execute E-Fuse read byte operation according as map offset and
210 * save to E-Fuse table.
211 * 2. Referred from SD1 Richard.
213 * 1. Boot from E-Fuse and successfully auto-load.
214 * 2. PASSIVE_LEVEL (USB interface)
215 * Created by Roger, 2008.10.21.
217 * 1. Reorganize code flow and reserve bytes. and add description.
218 * 2. Add efuse utilization collect.
220 * Read Efuse must check if we write section 1 data again!!!
221 * Sec1 write addr must be after sec5.
224 static void efuse_ReadEFuse(struct adapter
*Adapter
, u8 efuseType
, u16 _offset
, u16 _size_byte
, u8
*pbuf
, bool pseudo
)
226 Adapter
->HalFunc
.ReadEFuse(Adapter
, efuseType
, _offset
, _size_byte
, pbuf
, pseudo
);
229 void EFUSE_GetEfuseDefinition(struct adapter
*pAdapter
, u8 efuseType
, u8 type
, void *pOut
, bool pseudo
232 pAdapter
->HalFunc
.EFUSEGetEfuseDefinition(pAdapter
, efuseType
, type
, pOut
);
235 /*-----------------------------------------------------------------------------
236 * Function: EFUSE_Read1Byte
238 * Overview: Copy from WMAC fot EFUSE read 1 byte.
248 * 09/23/2008 MHC Copy from WMAC.
250 *---------------------------------------------------------------------------*/
251 u8
EFUSE_Read1Byte(struct adapter
*Adapter
, u16 Address
)
254 u8 Bytetemp
= {0x00};
259 EFUSE_GetEfuseDefinition(Adapter
, EFUSE_WIFI
, TYPE_EFUSE_REAL_CONTENT_LEN
, (void *)&contentLen
, false);
261 if (Address
< contentLen
) { /* E-fuse 512Byte */
262 /* Write E-fuse Register address bit0~7 */
263 temp
= Address
& 0xFF;
264 usb_write8(Adapter
, EFUSE_CTRL
+1, temp
);
265 Bytetemp
= usb_read8(Adapter
, EFUSE_CTRL
+2);
266 /* Write E-fuse Register address bit8~9 */
267 temp
= ((Address
>> 8) & 0x03) | (Bytetemp
& 0xFC);
268 usb_write8(Adapter
, EFUSE_CTRL
+2, temp
);
270 /* Write 0x30[31]= 0 */
271 Bytetemp
= usb_read8(Adapter
, EFUSE_CTRL
+3);
272 temp
= Bytetemp
& 0x7F;
273 usb_write8(Adapter
, EFUSE_CTRL
+3, temp
);
275 /* Wait Write-ready (0x30[31]= 1) */
276 Bytetemp
= usb_read8(Adapter
, EFUSE_CTRL
+3);
277 while (!(Bytetemp
& 0x80)) {
278 Bytetemp
= usb_read8(Adapter
, EFUSE_CTRL
+3);
285 data
= usb_read8(Adapter
, EFUSE_CTRL
);
291 } /* EFUSE_Read1Byte */
293 /* 11/16/2008 MH Read one byte from real Efuse. */
294 u8
efuse_OneByteRead(struct adapter
*pAdapter
, u16 addr
, u8
*data
, bool pseudo
)
300 result
= Efuse_Read1ByteFromFakeContent(pAdapter
, addr
, data
);
303 /* -----------------e-fuse reg ctrl --------------------------------- */
305 usb_write8(pAdapter
, EFUSE_CTRL
+1, (u8
)(addr
& 0xff));
306 usb_write8(pAdapter
, EFUSE_CTRL
+2, ((u8
)((addr
>>8) & 0x03)) |
307 (usb_read8(pAdapter
, EFUSE_CTRL
+2) & 0xFC));
309 usb_write8(pAdapter
, EFUSE_CTRL
+3, 0x72);/* read cmd */
311 while (!(0x80 & usb_read8(pAdapter
, EFUSE_CTRL
+3)) && (tmpidx
< 100))
314 *data
= usb_read8(pAdapter
, EFUSE_CTRL
);
323 /* 11/16/2008 MH Write one byte to reald Efuse. */
324 u8
efuse_OneByteWrite(struct adapter
*pAdapter
, u16 addr
, u8 data
, bool pseudo
)
330 result
= Efuse_Write1ByteToFakeContent(pAdapter
, addr
, data
);
334 /* -----------------e-fuse reg ctrl --------------------------------- */
336 usb_write8(pAdapter
, EFUSE_CTRL
+1, (u8
)(addr
&0xff));
337 usb_write8(pAdapter
, EFUSE_CTRL
+2,
338 (usb_read8(pAdapter
, EFUSE_CTRL
+2) & 0xFC) |
339 (u8
)((addr
>>8) & 0x03));
340 usb_write8(pAdapter
, EFUSE_CTRL
, data
);/* data */
342 usb_write8(pAdapter
, EFUSE_CTRL
+3, 0xF2);/* write cmd */
344 while ((0x80 & usb_read8(pAdapter
, EFUSE_CTRL
+3)) && (tmpidx
< 100))
355 int Efuse_PgPacketRead(struct adapter
*pAdapter
, u8 offset
, u8
*data
, bool pseudo
)
359 ret
= pAdapter
->HalFunc
.Efuse_PgPacketRead(pAdapter
, offset
, data
, pseudo
);
364 int Efuse_PgPacketWrite(struct adapter
*pAdapter
, u8 offset
, u8 word_en
, u8
*data
, bool pseudo
)
368 ret
= pAdapter
->HalFunc
.Efuse_PgPacketWrite(pAdapter
, offset
, word_en
, data
, pseudo
);
374 static int Efuse_PgPacketWrite_BT(struct adapter
*pAdapter
, u8 offset
, u8 word_en
, u8
*data
, bool pseudo
)
378 ret
= pAdapter
->HalFunc
.Efuse_PgPacketWrite_BT(pAdapter
, offset
, word_en
, data
, pseudo
);
383 /*-----------------------------------------------------------------------------
384 * Function: efuse_WordEnableDataRead
386 * Overview: Read allowed word in current efuse section data.
396 * 11/16/2008 MHC Create Version 0.
397 * 11/21/2008 MHC Fix Write bug when we only enable late word.
399 *---------------------------------------------------------------------------*/
400 void efuse_WordEnableDataRead(u8 word_en
, u8
*sourdata
, u8
*targetdata
)
402 if (!(word_en
&BIT(0))) {
403 targetdata
[0] = sourdata
[0];
404 targetdata
[1] = sourdata
[1];
406 if (!(word_en
&BIT(1))) {
407 targetdata
[2] = sourdata
[2];
408 targetdata
[3] = sourdata
[3];
410 if (!(word_en
&BIT(2))) {
411 targetdata
[4] = sourdata
[4];
412 targetdata
[5] = sourdata
[5];
414 if (!(word_en
&BIT(3))) {
415 targetdata
[6] = sourdata
[6];
416 targetdata
[7] = sourdata
[7];
420 u8
Efuse_WordEnableDataWrite(struct adapter
*pAdapter
, u16 efuse_addr
, u8 word_en
, u8
*data
, bool pseudo
)
424 ret
= pAdapter
->HalFunc
.Efuse_WordEnableDataWrite(pAdapter
, efuse_addr
, word_en
, data
, pseudo
);
429 static u8
efuse_read8(struct adapter
*padapter
, u16 address
, u8
*value
)
431 return efuse_OneByteRead(padapter
, address
, value
, false);
434 static u8
efuse_write8(struct adapter
*padapter
, u16 address
, u8
*value
)
436 return efuse_OneByteWrite(padapter
, address
, *value
, false);
440 * read/wirte raw efuse data
442 u8
rtw_efuse_access(struct adapter
*padapter
, u8 write
, u16 start_addr
, u16 cnts
, u8
*data
)
445 u16 real_content_len
= 0, max_available_size
= 0;
447 u8 (*rw8
)(struct adapter
*, u16
, u8
*);
449 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_EFUSE_REAL_CONTENT_LEN
, (void *)&real_content_len
, false);
450 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, (void *)&max_available_size
, false);
452 if (start_addr
> real_content_len
)
456 if ((start_addr
+ cnts
) > max_available_size
)
463 Efuse_PowerSwitch(padapter
, write
, true);
465 /* e-fuse one byte read / write */
466 for (i
= 0; i
< cnts
; i
++) {
467 if (start_addr
>= real_content_len
) {
472 res
= rw8(padapter
, start_addr
++, data
++);
477 Efuse_PowerSwitch(padapter
, write
, false);
482 u16
efuse_GetMaxSize(struct adapter
*padapter
)
485 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, (void *)&max_size
, false);
489 u8
efuse_GetCurrentSize(struct adapter
*padapter
, u16
*size
)
491 Efuse_PowerSwitch(padapter
, false, true);
492 *size
= Efuse_GetCurrentSize(padapter
, false);
493 Efuse_PowerSwitch(padapter
, false, false);
498 u8
rtw_efuse_map_read(struct adapter
*padapter
, u16 addr
, u16 cnts
, u8
*data
)
502 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, false);
504 if ((addr
+ cnts
) > mapLen
)
507 Efuse_PowerSwitch(padapter
, false, true);
509 efuse_ReadEFuse(padapter
, EFUSE_WIFI
, addr
, cnts
, data
, false);
511 Efuse_PowerSwitch(padapter
, false, false);
516 u8
rtw_BT_efuse_map_read(struct adapter
*padapter
, u16 addr
, u16 cnts
, u8
*data
)
520 EFUSE_GetEfuseDefinition(padapter
, EFUSE_BT
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, false);
522 if ((addr
+ cnts
) > mapLen
)
525 Efuse_PowerSwitch(padapter
, false, true);
527 efuse_ReadEFuse(padapter
, EFUSE_BT
, addr
, cnts
, data
, false);
529 Efuse_PowerSwitch(padapter
, false, false);
534 u8
rtw_efuse_map_write(struct adapter
*padapter
, u16 addr
, u16 cnts
, u8
*data
)
538 u8 newdata
[PGPKT_DATA_SIZE
+ 1];
543 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, false);
545 if ((addr
+ cnts
) > mapLen
)
548 map
= rtw_zmalloc(mapLen
);
552 ret
= rtw_efuse_map_read(padapter
, 0, mapLen
, map
);
556 Efuse_PowerSwitch(padapter
, true, true);
558 offset
= (addr
>> 3);
560 _rtw_memset(newdata
, 0xFF, PGPKT_DATA_SIZE
+ 1);
561 i
= addr
& 0x7; /* index of one package */
562 idx
= 0; /* data index */
566 if (data
[idx
] != map
[addr
+idx
]) {
567 word_en
&= ~BIT(i
>> 1);
568 newdata
[i
-1] = map
[addr
+idx
-1];
569 newdata
[i
] = data
[idx
];
575 for (; i
< PGPKT_DATA_SIZE
; i
+= 2) {
578 if ((cnts
- idx
) == 1) {
579 if (data
[idx
] != map
[addr
+idx
]) {
580 word_en
&= ~BIT(i
>> 1);
581 newdata
[i
] = data
[idx
];
582 newdata
[i
+1] = map
[addr
+idx
+1];
587 if ((data
[idx
] != map
[addr
+idx
]) ||
588 (data
[idx
+1] != map
[addr
+idx
+1])) {
589 word_en
&= ~BIT(i
>> 1);
590 newdata
[i
] = data
[idx
];
591 newdata
[i
+1] = data
[idx
+ 1];
599 if (word_en
!= 0xF) {
600 ret
= Efuse_PgPacketWrite(padapter
, offset
, word_en
, newdata
, false);
601 DBG_88E("offset=%x\n", offset
);
602 DBG_88E("word_en=%x\n", word_en
);
604 for (i
= 0; i
< PGPKT_DATA_SIZE
; i
++)
605 DBG_88E("data=%x \t", newdata
[i
]);
616 _rtw_memset(newdata
, 0xFF, PGPKT_DATA_SIZE
);
619 Efuse_PowerSwitch(padapter
, true, false);
626 u8
rtw_BT_efuse_map_write(struct adapter
*padapter
, u16 addr
, u16 cnts
, u8
*data
)
630 u8 newdata
[PGPKT_DATA_SIZE
+ 1];
635 EFUSE_GetEfuseDefinition(padapter
, EFUSE_BT
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, false);
637 if ((addr
+ cnts
) > mapLen
)
640 map
= rtw_zmalloc(mapLen
);
644 ret
= rtw_BT_efuse_map_read(padapter
, 0, mapLen
, map
);
648 Efuse_PowerSwitch(padapter
, true, true);
650 offset
= (addr
>> 3);
652 _rtw_memset(newdata
, 0xFF, PGPKT_DATA_SIZE
+ 1);
653 i
= addr
& 0x7; /* index of one package */
654 idx
= 0; /* data index */
658 if (data
[idx
] != map
[addr
+idx
]) {
659 word_en
&= ~BIT(i
>> 1);
660 newdata
[i
-1] = map
[addr
+idx
-1];
661 newdata
[i
] = data
[idx
];
667 for (; i
< PGPKT_DATA_SIZE
; i
+= 2) {
670 if ((cnts
- idx
) == 1) {
671 if (data
[idx
] != map
[addr
+idx
]) {
672 word_en
&= ~BIT(i
>> 1);
673 newdata
[i
] = data
[idx
];
674 newdata
[i
+1] = map
[addr
+idx
+1];
679 if ((data
[idx
] != map
[addr
+idx
]) ||
680 (data
[idx
+1] != map
[addr
+idx
+1])) {
681 word_en
&= ~BIT(i
>> 1);
682 newdata
[i
] = data
[idx
];
683 newdata
[i
+1] = data
[idx
+ 1];
691 if (word_en
!= 0xF) {
692 DBG_88E("%s: offset=%#X\n", __func__
, offset
);
693 DBG_88E("%s: word_en=%#X\n", __func__
, word_en
);
694 DBG_88E("%s: data=", __func__
);
695 for (i
= 0; i
< PGPKT_DATA_SIZE
; i
++)
696 DBG_88E("0x%02X ", newdata
[i
]);
699 ret
= Efuse_PgPacketWrite_BT(padapter
, offset
, word_en
, newdata
, false);
710 _rtw_memset(newdata
, 0xFF, PGPKT_DATA_SIZE
);
713 Efuse_PowerSwitch(padapter
, true, false);
722 /*-----------------------------------------------------------------------------
723 * Function: efuse_ShadowRead1Byte
724 * efuse_ShadowRead2Byte
725 * efuse_ShadowRead4Byte
727 * Overview: Read from efuse init map by one/two/four bytes !!!!!
737 * 11/12/2008 MHC Create Version 0.
739 *---------------------------------------------------------------------------*/
741 efuse_ShadowRead1Byte(
742 struct adapter
*pAdapter
,
746 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(pAdapter
);
748 *Value
= pEEPROM
->efuse_eeprom_data
[Offset
];
750 } /* EFUSE_ShadowRead1Byte */
754 efuse_ShadowRead2Byte(
755 struct adapter
*pAdapter
,
759 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(pAdapter
);
761 *Value
= pEEPROM
->efuse_eeprom_data
[Offset
];
762 *Value
|= pEEPROM
->efuse_eeprom_data
[Offset
+1]<<8;
764 } /* EFUSE_ShadowRead2Byte */
766 /* Read Four Bytes */
768 efuse_ShadowRead4Byte(
769 struct adapter
*pAdapter
,
773 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(pAdapter
);
775 *Value
= pEEPROM
->efuse_eeprom_data
[Offset
];
776 *Value
|= pEEPROM
->efuse_eeprom_data
[Offset
+1]<<8;
777 *Value
|= pEEPROM
->efuse_eeprom_data
[Offset
+2]<<16;
778 *Value
|= pEEPROM
->efuse_eeprom_data
[Offset
+3]<<24;
780 } /* efuse_ShadowRead4Byte */
782 /*-----------------------------------------------------------------------------
783 * Function: Efuse_ReadAllMap
785 * Overview: Read All Efuse content
795 * 11/11/2008 MHC Create Version 0.
797 *---------------------------------------------------------------------------*/
798 static void Efuse_ReadAllMap(struct adapter
*pAdapter
, u8 efuseType
, u8
*Efuse
, bool pseudo
)
802 Efuse_PowerSwitch(pAdapter
, false, true);
804 EFUSE_GetEfuseDefinition(pAdapter
, efuseType
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, pseudo
);
806 efuse_ReadEFuse(pAdapter
, efuseType
, 0, mapLen
, Efuse
, pseudo
);
808 Efuse_PowerSwitch(pAdapter
, false, false);
811 /*-----------------------------------------------------------------------------
812 * Function: EFUSE_ShadowMapUpdate
814 * Overview: Transfer current EFUSE content to shadow init and modify map.
824 * 11/13/2008 MHC Create Version 0.
826 *---------------------------------------------------------------------------*/
827 void EFUSE_ShadowMapUpdate(
828 struct adapter
*pAdapter
,
832 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(pAdapter
);
835 EFUSE_GetEfuseDefinition(pAdapter
, efuseType
, TYPE_EFUSE_MAP_LEN
, (void *)&mapLen
, pseudo
);
837 if (pEEPROM
->bautoload_fail_flag
)
838 _rtw_memset(pEEPROM
->efuse_eeprom_data
, 0xFF, mapLen
);
840 Efuse_ReadAllMap(pAdapter
, efuseType
, pEEPROM
->efuse_eeprom_data
, pseudo
);
841 } /* EFUSE_ShadowMapUpdate */
843 /*-----------------------------------------------------------------------------
844 * Function: EFUSE_ShadowRead
846 * Overview: Read from efuse init map !!!!!
856 * 11/12/2008 MHC Create Version 0.
858 *---------------------------------------------------------------------------*/
859 void EFUSE_ShadowRead(struct adapter
*pAdapter
, u8 Type
, u16 Offset
, u32
*Value
)
862 efuse_ShadowRead1Byte(pAdapter
, Offset
, (u8
*)Value
);
864 efuse_ShadowRead2Byte(pAdapter
, Offset
, (u16
*)Value
);
866 efuse_ShadowRead4Byte(pAdapter
, Offset
, (u32
*)Value
);
868 } /* EFUSE_ShadowRead */