| /****************************************************************************** |
| * |
| * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of version 2 of the GNU General Public License as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| * You should have received a copy of the GNU General Public License along with |
| * this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA |
| * |
| * |
| ******************************************************************************/ |
| #define _RTW_EFUSE_C_ |
| |
| #include <osdep_service.h> |
| #include <drv_types.h> |
| #include <rtw_efuse.h> |
| |
| |
| |
| /*------------------------Define local variable------------------------------*/ |
| u8 fakeEfuseBank; |
| u32 fakeEfuseUsedBytes; |
| u8 fakeEfuseContent[EFUSE_MAX_HW_SIZE] = {0}; |
| u8 fakeEfuseInitMap[EFUSE_MAX_MAP_LEN] = {0}; |
| u8 fakeEfuseModifiedMap[EFUSE_MAX_MAP_LEN] = {0}; |
| |
| u32 BTEfuseUsedBytes; |
| u8 BTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE]; |
| u8 BTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0}; |
| u8 BTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0}; |
| |
| u32 fakeBTEfuseUsedBytes; |
| u8 fakeBTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE]; |
| u8 fakeBTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN] = {0}; |
| u8 fakeBTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN] = {0}; |
| /*------------------------Define local variable------------------------------*/ |
| |
| /* */ |
| #define REG_EFUSE_CTRL 0x0030 |
| #define EFUSE_CTRL REG_EFUSE_CTRL /* E-Fuse Control. */ |
| /* */ |
| |
| bool |
| Efuse_Read1ByteFromFakeContent( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u8 *Value); |
| bool |
| Efuse_Read1ByteFromFakeContent( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u8 *Value) |
| { |
| if (Offset >= EFUSE_MAX_HW_SIZE) |
| return false; |
| if (fakeEfuseBank == 0) |
| *Value = fakeEfuseContent[Offset]; |
| else |
| *Value = fakeBTEfuseContent[fakeEfuseBank-1][Offset]; |
| return true; |
| } |
| |
| static bool |
| Efuse_Write1ByteToFakeContent( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u8 Value) |
| { |
| if (Offset >= EFUSE_MAX_HW_SIZE) |
| return false; |
| if (fakeEfuseBank == 0) |
| fakeEfuseContent[Offset] = Value; |
| else |
| fakeBTEfuseContent[fakeEfuseBank-1][Offset] = Value; |
| return true; |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: Efuse_PowerSwitch |
| * |
| * Overview: When we want to enable write operation, we should change to |
| * pwr on state. When we stop write, we should switch to 500k mode |
| * and disable LDO 2.5V. |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/17/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| void |
| Efuse_PowerSwitch( |
| struct adapter *pAdapter, |
| u8 write, |
| u8 PwrState) |
| { |
| pAdapter->HalFunc.EfusePowerSwitch(pAdapter, write, PwrState); |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: efuse_GetCurrentSize |
| * |
| * Overview: Get current efuse size!!! |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/16/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| u16 |
| Efuse_GetCurrentSize( |
| struct adapter *pAdapter, |
| u8 efuseType, |
| bool pseudo) |
| { |
| u16 ret = 0; |
| |
| ret = pAdapter->HalFunc.EfuseGetCurrentSize(pAdapter, efuseType, pseudo); |
| |
| return ret; |
| } |
| |
| /* 11/16/2008 MH Add description. Get current efuse area enabled word!!. */ |
| u8 |
| Efuse_CalculateWordCnts(u8 word_en) |
| { |
| u8 word_cnts = 0; |
| if (!(word_en & BIT(0))) |
| word_cnts++; /* 0 : write enable */ |
| if (!(word_en & BIT(1))) |
| word_cnts++; |
| if (!(word_en & BIT(2))) |
| word_cnts++; |
| if (!(word_en & BIT(3))) |
| word_cnts++; |
| return word_cnts; |
| } |
| |
| /* |
| * Description: |
| * Execute E-Fuse read byte operation. |
| * Referred from SD1 Richard. |
| * Assumption: |
| * 1. Boot from E-Fuse and successfully auto-load. |
| * 2. PASSIVE_LEVEL (USB interface) |
| * Created by Roger, 2008.10.21. |
| */ |
| void |
| ReadEFuseByte( |
| struct adapter *Adapter, |
| u16 _offset, |
| u8 *pbuf, |
| bool pseudo) |
| { |
| u32 value32; |
| u8 readbyte; |
| u16 retry; |
| |
| if (pseudo) { |
| Efuse_Read1ByteFromFakeContent(Adapter, _offset, pbuf); |
| return; |
| } |
| |
| /* Write Address */ |
| rtw_write8(Adapter, EFUSE_CTRL+1, (_offset & 0xff)); |
| readbyte = rtw_read8(Adapter, EFUSE_CTRL+2); |
| rtw_write8(Adapter, EFUSE_CTRL+2, ((_offset >> 8) & 0x03) | (readbyte & 0xfc)); |
| |
| /* Write bit 32 0 */ |
| readbyte = rtw_read8(Adapter, EFUSE_CTRL+3); |
| rtw_write8(Adapter, EFUSE_CTRL+3, (readbyte & 0x7f)); |
| |
| /* Check bit 32 read-ready */ |
| retry = 0; |
| value32 = rtw_read32(Adapter, EFUSE_CTRL); |
| while (!(((value32 >> 24) & 0xff) & 0x80) && (retry < 10000)) { |
| value32 = rtw_read32(Adapter, EFUSE_CTRL); |
| retry++; |
| } |
| |
| /* 20100205 Joseph: Add delay suggested by SD1 Victor. */ |
| /* This fix the problem that Efuse read error in high temperature condition. */ |
| /* Designer says that there shall be some delay after ready bit is set, or the */ |
| /* result will always stay on last data we read. */ |
| udelay(50); |
| value32 = rtw_read32(Adapter, EFUSE_CTRL); |
| |
| *pbuf = (u8)(value32 & 0xff); |
| } |
| |
| /* Description: |
| * 1. Execute E-Fuse read byte operation according as map offset and |
| * save to E-Fuse table. |
| * 2. Referred from SD1 Richard. |
| * Assumption: |
| * 1. Boot from E-Fuse and successfully auto-load. |
| * 2. PASSIVE_LEVEL (USB interface) |
| * Created by Roger, 2008.10.21. |
| * 2008/12/12 MH |
| * 1. Reorganize code flow and reserve bytes. and add description. |
| * 2. Add efuse utilization collect. |
| * 2008/12/22 MH |
| * Read Efuse must check if we write section 1 data again!!! |
| * Sec1 write addr must be after sec5. |
| */ |
| |
| static void efuse_ReadEFuse(struct adapter *Adapter, u8 efuseType, u16 _offset, u16 _size_byte, u8 *pbuf, bool pseudo) |
| { |
| Adapter->HalFunc.ReadEFuse(Adapter, efuseType, _offset, _size_byte, pbuf, pseudo); |
| } |
| |
| void EFUSE_GetEfuseDefinition(struct adapter *pAdapter, u8 efuseType, u8 type, void *pOut, bool pseudo |
| ) |
| { |
| pAdapter->HalFunc.EFUSEGetEfuseDefinition(pAdapter, efuseType, type, pOut, pseudo); |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: EFUSE_Read1Byte |
| * |
| * Overview: Copy from WMAC fot EFUSE read 1 byte. |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 09/23/2008 MHC Copy from WMAC. |
| * |
| *---------------------------------------------------------------------------*/ |
| u8 EFUSE_Read1Byte(struct adapter *Adapter, u16 Address) |
| { |
| u8 data; |
| u8 Bytetemp = {0x00}; |
| u8 temp = {0x00}; |
| u32 k = 0; |
| u16 contentLen = 0; |
| |
| EFUSE_GetEfuseDefinition(Adapter, EFUSE_WIFI , TYPE_EFUSE_REAL_CONTENT_LEN, (void *)&contentLen, false); |
| |
| if (Address < contentLen) { /* E-fuse 512Byte */ |
| /* Write E-fuse Register address bit0~7 */ |
| temp = Address & 0xFF; |
| rtw_write8(Adapter, EFUSE_CTRL+1, temp); |
| Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+2); |
| /* Write E-fuse Register address bit8~9 */ |
| temp = ((Address >> 8) & 0x03) | (Bytetemp & 0xFC); |
| rtw_write8(Adapter, EFUSE_CTRL+2, temp); |
| |
| /* Write 0x30[31]= 0 */ |
| Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3); |
| temp = Bytetemp & 0x7F; |
| rtw_write8(Adapter, EFUSE_CTRL+3, temp); |
| |
| /* Wait Write-ready (0x30[31]= 1) */ |
| Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3); |
| while (!(Bytetemp & 0x80)) { |
| Bytetemp = rtw_read8(Adapter, EFUSE_CTRL+3); |
| k++; |
| if (k == 1000) { |
| k = 0; |
| break; |
| } |
| } |
| data = rtw_read8(Adapter, EFUSE_CTRL); |
| return data; |
| } else { |
| return 0xFF; |
| } |
| |
| } /* EFUSE_Read1Byte */ |
| |
| /* 11/16/2008 MH Read one byte from real Efuse. */ |
| u8 efuse_OneByteRead(struct adapter *pAdapter, u16 addr, u8 *data, bool pseudo) |
| { |
| u8 tmpidx = 0; |
| u8 result; |
| |
| if (pseudo) { |
| result = Efuse_Read1ByteFromFakeContent(pAdapter, addr, data); |
| return result; |
| } |
| /* -----------------e-fuse reg ctrl --------------------------------- */ |
| /* address */ |
| rtw_write8(pAdapter, EFUSE_CTRL+1, (u8)(addr & 0xff)); |
| rtw_write8(pAdapter, EFUSE_CTRL+2, ((u8)((addr>>8) & 0x03)) | |
| (rtw_read8(pAdapter, EFUSE_CTRL+2) & 0xFC)); |
| |
| rtw_write8(pAdapter, EFUSE_CTRL+3, 0x72);/* read cmd */ |
| |
| while (!(0x80 & rtw_read8(pAdapter, EFUSE_CTRL+3)) && (tmpidx < 100)) |
| tmpidx++; |
| if (tmpidx < 100) { |
| *data = rtw_read8(pAdapter, EFUSE_CTRL); |
| result = true; |
| } else { |
| *data = 0xff; |
| result = false; |
| } |
| return result; |
| } |
| |
| /* 11/16/2008 MH Write one byte to reald Efuse. */ |
| u8 efuse_OneByteWrite(struct adapter *pAdapter, u16 addr, u8 data, bool pseudo) |
| { |
| u8 tmpidx = 0; |
| u8 result; |
| |
| if (pseudo) { |
| result = Efuse_Write1ByteToFakeContent(pAdapter, addr, data); |
| return result; |
| } |
| |
| /* -----------------e-fuse reg ctrl --------------------------------- */ |
| /* address */ |
| rtw_write8(pAdapter, EFUSE_CTRL+1, (u8)(addr&0xff)); |
| rtw_write8(pAdapter, EFUSE_CTRL+2, |
| (rtw_read8(pAdapter, EFUSE_CTRL+2) & 0xFC) | |
| (u8)((addr>>8) & 0x03)); |
| rtw_write8(pAdapter, EFUSE_CTRL, data);/* data */ |
| |
| rtw_write8(pAdapter, EFUSE_CTRL+3, 0xF2);/* write cmd */ |
| |
| while ((0x80 & rtw_read8(pAdapter, EFUSE_CTRL+3)) && (tmpidx < 100)) |
| tmpidx++; |
| |
| if (tmpidx < 100) |
| result = true; |
| else |
| result = false; |
| |
| return result; |
| } |
| |
| int Efuse_PgPacketRead(struct adapter *pAdapter, u8 offset, u8 *data, bool pseudo) |
| { |
| int ret = 0; |
| |
| ret = pAdapter->HalFunc.Efuse_PgPacketRead(pAdapter, offset, data, pseudo); |
| |
| return ret; |
| } |
| |
| int Efuse_PgPacketWrite(struct adapter *pAdapter, u8 offset, u8 word_en, u8 *data, bool pseudo) |
| { |
| int ret; |
| |
| ret = pAdapter->HalFunc.Efuse_PgPacketWrite(pAdapter, offset, word_en, data, pseudo); |
| |
| return ret; |
| } |
| |
| |
| static int Efuse_PgPacketWrite_BT(struct adapter *pAdapter, u8 offset, u8 word_en, u8 *data, bool pseudo) |
| { |
| int ret; |
| |
| ret = pAdapter->HalFunc.Efuse_PgPacketWrite_BT(pAdapter, offset, word_en, data, pseudo); |
| |
| return ret; |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: efuse_WordEnableDataRead |
| * |
| * Overview: Read allowed word in current efuse section data. |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/16/2008 MHC Create Version 0. |
| * 11/21/2008 MHC Fix Write bug when we only enable late word. |
| * |
| *---------------------------------------------------------------------------*/ |
| void efuse_WordEnableDataRead(u8 word_en, u8 *sourdata, u8 *targetdata) |
| { |
| if (!(word_en&BIT(0))) { |
| targetdata[0] = sourdata[0]; |
| targetdata[1] = sourdata[1]; |
| } |
| if (!(word_en&BIT(1))) { |
| targetdata[2] = sourdata[2]; |
| targetdata[3] = sourdata[3]; |
| } |
| if (!(word_en&BIT(2))) { |
| targetdata[4] = sourdata[4]; |
| targetdata[5] = sourdata[5]; |
| } |
| if (!(word_en&BIT(3))) { |
| targetdata[6] = sourdata[6]; |
| targetdata[7] = sourdata[7]; |
| } |
| } |
| |
| u8 Efuse_WordEnableDataWrite(struct adapter *pAdapter, u16 efuse_addr, u8 word_en, u8 *data, bool pseudo) |
| { |
| u8 ret = 0; |
| |
| ret = pAdapter->HalFunc.Efuse_WordEnableDataWrite(pAdapter, efuse_addr, word_en, data, pseudo); |
| |
| return ret; |
| } |
| |
| static u8 efuse_read8(struct adapter *padapter, u16 address, u8 *value) |
| { |
| return efuse_OneByteRead(padapter, address, value, false); |
| } |
| |
| static u8 efuse_write8(struct adapter *padapter, u16 address, u8 *value) |
| { |
| return efuse_OneByteWrite(padapter, address, *value, false); |
| } |
| |
| /* |
| * read/wirte raw efuse data |
| */ |
| u8 rtw_efuse_access(struct adapter *padapter, u8 write, u16 start_addr, u16 cnts, u8 *data) |
| { |
| int i = 0; |
| u16 real_content_len = 0, max_available_size = 0; |
| u8 res = _FAIL; |
| u8 (*rw8)(struct adapter *, u16, u8*); |
| |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_REAL_CONTENT_LEN, (void *)&real_content_len, false); |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_available_size, false); |
| |
| if (start_addr > real_content_len) |
| return _FAIL; |
| |
| if (write) { |
| if ((start_addr + cnts) > max_available_size) |
| return _FAIL; |
| rw8 = &efuse_write8; |
| } else { |
| rw8 = &efuse_read8; |
| } |
| |
| Efuse_PowerSwitch(padapter, write, true); |
| |
| /* e-fuse one byte read / write */ |
| for (i = 0; i < cnts; i++) { |
| if (start_addr >= real_content_len) { |
| res = _FAIL; |
| break; |
| } |
| |
| res = rw8(padapter, start_addr++, data++); |
| if (_FAIL == res) |
| break; |
| } |
| |
| Efuse_PowerSwitch(padapter, write, false); |
| |
| return res; |
| } |
| /* */ |
| u16 efuse_GetMaxSize(struct adapter *padapter) |
| { |
| u16 max_size; |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI , TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (void *)&max_size, false); |
| return max_size; |
| } |
| /* */ |
| u8 efuse_GetCurrentSize(struct adapter *padapter, u16 *size) |
| { |
| Efuse_PowerSwitch(padapter, false, true); |
| *size = Efuse_GetCurrentSize(padapter, EFUSE_WIFI, false); |
| Efuse_PowerSwitch(padapter, false, false); |
| |
| return _SUCCESS; |
| } |
| /* */ |
| u8 rtw_efuse_map_read(struct adapter *padapter, u16 addr, u16 cnts, u8 *data) |
| { |
| u16 mapLen = 0; |
| |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, false); |
| |
| if ((addr + cnts) > mapLen) |
| return _FAIL; |
| |
| Efuse_PowerSwitch(padapter, false, true); |
| |
| efuse_ReadEFuse(padapter, EFUSE_WIFI, addr, cnts, data, false); |
| |
| Efuse_PowerSwitch(padapter, false, false); |
| |
| return _SUCCESS; |
| } |
| |
| u8 rtw_BT_efuse_map_read(struct adapter *padapter, u16 addr, u16 cnts, u8 *data) |
| { |
| u16 mapLen = 0; |
| |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, false); |
| |
| if ((addr + cnts) > mapLen) |
| return _FAIL; |
| |
| Efuse_PowerSwitch(padapter, false, true); |
| |
| efuse_ReadEFuse(padapter, EFUSE_BT, addr, cnts, data, false); |
| |
| Efuse_PowerSwitch(padapter, false, false); |
| |
| return _SUCCESS; |
| } |
| /* */ |
| u8 rtw_efuse_map_write(struct adapter *padapter, u16 addr, u16 cnts, u8 *data) |
| { |
| u8 offset, word_en; |
| u8 *map; |
| u8 newdata[PGPKT_DATA_SIZE + 1]; |
| s32 i, idx; |
| u8 ret = _SUCCESS; |
| u16 mapLen = 0; |
| |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, false); |
| |
| if ((addr + cnts) > mapLen) |
| return _FAIL; |
| |
| map = rtw_zmalloc(mapLen); |
| if (map == NULL) |
| return _FAIL; |
| |
| ret = rtw_efuse_map_read(padapter, 0, mapLen, map); |
| if (ret == _FAIL) |
| goto exit; |
| |
| Efuse_PowerSwitch(padapter, true, true); |
| |
| offset = (addr >> 3); |
| word_en = 0xF; |
| _rtw_memset(newdata, 0xFF, PGPKT_DATA_SIZE + 1); |
| i = addr & 0x7; /* index of one package */ |
| idx = 0; /* data index */ |
| |
| if (i & 0x1) { |
| /* odd start */ |
| if (data[idx] != map[addr+idx]) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i-1] = map[addr+idx-1]; |
| newdata[i] = data[idx]; |
| } |
| i++; |
| idx++; |
| } |
| do { |
| for (; i < PGPKT_DATA_SIZE; i += 2) { |
| if (cnts == idx) |
| break; |
| if ((cnts - idx) == 1) { |
| if (data[idx] != map[addr+idx]) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i] = data[idx]; |
| newdata[i+1] = map[addr+idx+1]; |
| } |
| idx++; |
| break; |
| } else { |
| if ((data[idx] != map[addr+idx]) || |
| (data[idx+1] != map[addr+idx+1])) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i] = data[idx]; |
| newdata[i+1] = data[idx + 1]; |
| } |
| idx += 2; |
| } |
| if (idx == cnts) |
| break; |
| } |
| |
| if (word_en != 0xF) { |
| ret = Efuse_PgPacketWrite(padapter, offset, word_en, newdata, false); |
| DBG_88E("offset=%x\n", offset); |
| DBG_88E("word_en=%x\n", word_en); |
| |
| for (i = 0; i < PGPKT_DATA_SIZE; i++) |
| DBG_88E("data=%x \t", newdata[i]); |
| if (ret == _FAIL) |
| break; |
| } |
| |
| if (idx == cnts) |
| break; |
| |
| offset++; |
| i = 0; |
| word_en = 0xF; |
| _rtw_memset(newdata, 0xFF, PGPKT_DATA_SIZE); |
| } while (1); |
| |
| Efuse_PowerSwitch(padapter, true, false); |
| exit: |
| kfree(map); |
| return ret; |
| } |
| |
| /* */ |
| u8 rtw_BT_efuse_map_write(struct adapter *padapter, u16 addr, u16 cnts, u8 *data) |
| { |
| u8 offset, word_en; |
| u8 *map; |
| u8 newdata[PGPKT_DATA_SIZE + 1]; |
| s32 i, idx; |
| u8 ret = _SUCCESS; |
| u16 mapLen = 0; |
| |
| EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, false); |
| |
| if ((addr + cnts) > mapLen) |
| return _FAIL; |
| |
| map = rtw_zmalloc(mapLen); |
| if (map == NULL) |
| return _FAIL; |
| |
| ret = rtw_BT_efuse_map_read(padapter, 0, mapLen, map); |
| if (ret == _FAIL) |
| goto exit; |
| |
| Efuse_PowerSwitch(padapter, true, true); |
| |
| offset = (addr >> 3); |
| word_en = 0xF; |
| _rtw_memset(newdata, 0xFF, PGPKT_DATA_SIZE + 1); |
| i = addr & 0x7; /* index of one package */ |
| idx = 0; /* data index */ |
| |
| if (i & 0x1) { |
| /* odd start */ |
| if (data[idx] != map[addr+idx]) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i-1] = map[addr+idx-1]; |
| newdata[i] = data[idx]; |
| } |
| i++; |
| idx++; |
| } |
| do { |
| for (; i < PGPKT_DATA_SIZE; i += 2) { |
| if (cnts == idx) |
| break; |
| if ((cnts - idx) == 1) { |
| if (data[idx] != map[addr+idx]) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i] = data[idx]; |
| newdata[i+1] = map[addr+idx+1]; |
| } |
| idx++; |
| break; |
| } else { |
| if ((data[idx] != map[addr+idx]) || |
| (data[idx+1] != map[addr+idx+1])) { |
| word_en &= ~BIT(i >> 1); |
| newdata[i] = data[idx]; |
| newdata[i+1] = data[idx + 1]; |
| } |
| idx += 2; |
| } |
| if (idx == cnts) |
| break; |
| } |
| |
| if (word_en != 0xF) { |
| DBG_88E("%s: offset=%#X\n", __func__, offset); |
| DBG_88E("%s: word_en=%#X\n", __func__, word_en); |
| DBG_88E("%s: data=", __func__); |
| for (i = 0; i < PGPKT_DATA_SIZE; i++) |
| DBG_88E("0x%02X ", newdata[i]); |
| DBG_88E("\n"); |
| |
| ret = Efuse_PgPacketWrite_BT(padapter, offset, word_en, newdata, false); |
| if (ret == _FAIL) |
| break; |
| } |
| |
| if (idx == cnts) |
| break; |
| |
| offset++; |
| i = 0; |
| word_en = 0xF; |
| _rtw_memset(newdata, 0xFF, PGPKT_DATA_SIZE); |
| } while (1); |
| |
| Efuse_PowerSwitch(padapter, true, false); |
| |
| exit: |
| |
| kfree(map); |
| |
| return ret; |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: efuse_ShadowRead1Byte |
| * efuse_ShadowRead2Byte |
| * efuse_ShadowRead4Byte |
| * |
| * Overview: Read from efuse init map by one/two/four bytes !!!!! |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/12/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| static void |
| efuse_ShadowRead1Byte( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u8 *Value) |
| { |
| struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(pAdapter); |
| |
| *Value = pEEPROM->efuse_eeprom_data[Offset]; |
| |
| } /* EFUSE_ShadowRead1Byte */ |
| |
| /* Read Two Bytes */ |
| static void |
| efuse_ShadowRead2Byte( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u16 *Value) |
| { |
| struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(pAdapter); |
| |
| *Value = pEEPROM->efuse_eeprom_data[Offset]; |
| *Value |= pEEPROM->efuse_eeprom_data[Offset+1]<<8; |
| |
| } /* EFUSE_ShadowRead2Byte */ |
| |
| /* Read Four Bytes */ |
| static void |
| efuse_ShadowRead4Byte( |
| struct adapter *pAdapter, |
| u16 Offset, |
| u32 *Value) |
| { |
| struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(pAdapter); |
| |
| *Value = pEEPROM->efuse_eeprom_data[Offset]; |
| *Value |= pEEPROM->efuse_eeprom_data[Offset+1]<<8; |
| *Value |= pEEPROM->efuse_eeprom_data[Offset+2]<<16; |
| *Value |= pEEPROM->efuse_eeprom_data[Offset+3]<<24; |
| |
| } /* efuse_ShadowRead4Byte */ |
| |
| /*----------------------------------------------------------------------------- |
| * Function: Efuse_ReadAllMap |
| * |
| * Overview: Read All Efuse content |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/11/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| static void Efuse_ReadAllMap(struct adapter *pAdapter, u8 efuseType, u8 *Efuse, bool pseudo) |
| { |
| u16 mapLen = 0; |
| |
| Efuse_PowerSwitch(pAdapter, false, true); |
| |
| EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, pseudo); |
| |
| efuse_ReadEFuse(pAdapter, efuseType, 0, mapLen, Efuse, pseudo); |
| |
| Efuse_PowerSwitch(pAdapter, false, false); |
| } |
| |
| /*----------------------------------------------------------------------------- |
| * Function: EFUSE_ShadowMapUpdate |
| * |
| * Overview: Transfer current EFUSE content to shadow init and modify map. |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/13/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| void EFUSE_ShadowMapUpdate( |
| struct adapter *pAdapter, |
| u8 efuseType, |
| bool pseudo) |
| { |
| struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(pAdapter); |
| u16 mapLen = 0; |
| |
| EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, pseudo); |
| |
| if (pEEPROM->bautoload_fail_flag) |
| _rtw_memset(pEEPROM->efuse_eeprom_data, 0xFF, mapLen); |
| else |
| Efuse_ReadAllMap(pAdapter, efuseType, pEEPROM->efuse_eeprom_data, pseudo); |
| } /* EFUSE_ShadowMapUpdate */ |
| |
| /*----------------------------------------------------------------------------- |
| * Function: EFUSE_ShadowRead |
| * |
| * Overview: Read from efuse init map !!!!! |
| * |
| * Input: NONE |
| * |
| * Output: NONE |
| * |
| * Return: NONE |
| * |
| * Revised History: |
| * When Who Remark |
| * 11/12/2008 MHC Create Version 0. |
| * |
| *---------------------------------------------------------------------------*/ |
| void EFUSE_ShadowRead(struct adapter *pAdapter, u8 Type, u16 Offset, u32 *Value) |
| { |
| if (Type == 1) |
| efuse_ShadowRead1Byte(pAdapter, Offset, (u8 *)Value); |
| else if (Type == 2) |
| efuse_ShadowRead2Byte(pAdapter, Offset, (u16 *)Value); |
| else if (Type == 4) |
| efuse_ShadowRead4Byte(pAdapter, Offset, (u32 *)Value); |
| |
| } /* EFUSE_ShadowRead */ |