forked from Minki/linux
Staging: rt28x0: remove optional loading of EEPROM from file in eFuse mode
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
parent
782f111125
commit
44c68c23b1
@ -1194,16 +1194,6 @@ NDIS_STATUS RTMPSetProfileParameters(
|
||||
retval = RT_CfgSetCountryRegion(pAd, tmpbuf, BAND_5G);
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("CountryRegionABand=%d\n", pAd->CommonCfg.CountryRegionForABand));
|
||||
}
|
||||
#ifdef RTMP_EFUSE_SUPPORT
|
||||
#ifdef RT30xx
|
||||
//EfuseBufferMode
|
||||
if(RTMPGetKeyParameter("EfuseBufferMode", tmpbuf, 25, pBuffer, TRUE))
|
||||
{
|
||||
pAd->bEEPROMFile = (UCHAR) simple_strtol(tmpbuf, 0, 10);
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("EfuseBufferMode=%d\n", pAd->bUseEfuse));
|
||||
}
|
||||
#endif // RT30xx //
|
||||
#endif // RTMP_EFUSE_SUPPORT //
|
||||
//CountryCode
|
||||
if(RTMPGetKeyParameter("CountryCode", tmpbuf, 25, pBuffer, TRUE))
|
||||
{
|
||||
|
@ -67,21 +67,6 @@ typedef union _EFUSE_CTRL_STRUC {
|
||||
UINT32 word;
|
||||
} EFUSE_CTRL_STRUC, *PEFUSE_CTRL_STRUC;
|
||||
|
||||
static VOID eFuseWritePhysical(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
PUSHORT lpInBuffer,
|
||||
ULONG nInBufferSize,
|
||||
PUCHAR lpOutBuffer,
|
||||
ULONG nOutBufferSize);
|
||||
|
||||
|
||||
static NTSTATUS eFuseWriteRegistersFromBin(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN USHORT Offset,
|
||||
IN USHORT Length,
|
||||
IN USHORT* pData);
|
||||
|
||||
|
||||
/*
|
||||
========================================================================
|
||||
|
||||
@ -268,164 +253,6 @@ static VOID eFuseReadPhysical(
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================================================================
|
||||
|
||||
Routine Description:
|
||||
|
||||
Arguments:
|
||||
|
||||
Return Value:
|
||||
|
||||
Note:
|
||||
|
||||
========================================================================
|
||||
*/
|
||||
static VOID eFusePhysicalWriteRegisters(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN USHORT Offset,
|
||||
IN USHORT Length,
|
||||
OUT USHORT* pData)
|
||||
{
|
||||
EFUSE_CTRL_STRUC eFuseCtrlStruc;
|
||||
int i;
|
||||
USHORT efuseDataOffset;
|
||||
UINT32 data, eFuseDataBuffer[4];
|
||||
|
||||
//Step0. Write 16-byte of data to EFUSE_DATA0-3 (0x590-0x59C), where EFUSE_DATA0 is the LSB DW, EFUSE_DATA3 is the MSB DW.
|
||||
|
||||
/////////////////////////////////////////////////////////////////
|
||||
//read current values of 16-byte block
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
|
||||
//Step0. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment.
|
||||
eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0;
|
||||
|
||||
//Step1. Write EFSROM_MODE (0x580, bit7:bit6) to 1.
|
||||
eFuseCtrlStruc.field.EFSROM_MODE = 1;
|
||||
|
||||
//Step2. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical read procedure.
|
||||
eFuseCtrlStruc.field.EFSROM_KICK = 1;
|
||||
|
||||
NdisMoveMemory(&data, &eFuseCtrlStruc, 4);
|
||||
RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data);
|
||||
|
||||
//Step3. Polling EFSROM_KICK(0x580, bit30) until it become 0 again.
|
||||
i = 0;
|
||||
while(i < 500)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
|
||||
if(eFuseCtrlStruc.field.EFSROM_KICK == 0)
|
||||
break;
|
||||
RTMPusecDelay(2);
|
||||
i++;
|
||||
}
|
||||
|
||||
//Step4. Read 16-byte of data from EFUSE_DATA0-3 (0x59C-0x590)
|
||||
efuseDataOffset = EFUSE_DATA3;
|
||||
for(i=0; i< 4; i++)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, efuseDataOffset, (PUINT32) &eFuseDataBuffer[i]);
|
||||
efuseDataOffset -= 4;
|
||||
}
|
||||
|
||||
//Update the value, the offset is multiple of 2, length is 2
|
||||
efuseDataOffset = (Offset & 0xc) >> 2;
|
||||
data = pData[0] & 0xffff;
|
||||
//The offset should be 0x***10 or 0x***00
|
||||
if((Offset % 4) != 0)
|
||||
{
|
||||
eFuseDataBuffer[efuseDataOffset] = (eFuseDataBuffer[efuseDataOffset] & 0xffff) | (data << 16);
|
||||
}
|
||||
else
|
||||
{
|
||||
eFuseDataBuffer[efuseDataOffset] = (eFuseDataBuffer[efuseDataOffset] & 0xffff0000) | data;
|
||||
}
|
||||
|
||||
efuseDataOffset = EFUSE_DATA3;
|
||||
for(i=0; i< 4; i++)
|
||||
{
|
||||
RTMP_IO_WRITE32(pAd, efuseDataOffset, eFuseDataBuffer[i]);
|
||||
efuseDataOffset -= 4;
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////
|
||||
|
||||
//Step1. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment.
|
||||
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
|
||||
eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0;
|
||||
|
||||
//Step2. Write EFSROM_MODE (0x580, bit7:bit6) to 3.
|
||||
eFuseCtrlStruc.field.EFSROM_MODE = 3;
|
||||
|
||||
//Step3. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical write procedure.
|
||||
eFuseCtrlStruc.field.EFSROM_KICK = 1;
|
||||
|
||||
NdisMoveMemory(&data, &eFuseCtrlStruc, 4);
|
||||
RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data);
|
||||
|
||||
//Step4. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. It¡¦s done.
|
||||
i = 0;
|
||||
|
||||
while(i < 500)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
|
||||
if(eFuseCtrlStruc.field.EFSROM_KICK == 0)
|
||||
break;
|
||||
|
||||
RTMPusecDelay(2);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================================================================
|
||||
|
||||
Routine Description:
|
||||
|
||||
Arguments:
|
||||
|
||||
Return Value:
|
||||
|
||||
Note:
|
||||
|
||||
========================================================================
|
||||
*/
|
||||
static VOID eFuseWritePhysical(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
PUSHORT lpInBuffer,
|
||||
ULONG nInBufferSize,
|
||||
PUCHAR lpOutBuffer,
|
||||
ULONG nOutBufferSize
|
||||
)
|
||||
{
|
||||
USHORT* pInBuf = (USHORT*)lpInBuffer;
|
||||
int i;
|
||||
//USHORT* pOutBuf = (USHORT*)ioBuffer;
|
||||
USHORT Offset = pInBuf[0]; // addr
|
||||
USHORT Length = pInBuf[1]; // length
|
||||
USHORT* pValueX = &pInBuf[2]; // value ...
|
||||
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWritePhysical Offset=0x%x, length=%d\n", Offset, Length));
|
||||
|
||||
{
|
||||
// Little-endian S | S Big-endian
|
||||
// addr 3 2 1 0 | 0 1 2 3
|
||||
// Ori-V D C B A | A B C D
|
||||
// After swapping
|
||||
// D C B A | D C B A
|
||||
// Both the little and big-endian use the same sequence to write data.
|
||||
// Therefore, we only need swap data when read the data.
|
||||
for (i=0; i<Length; i+=2)
|
||||
{
|
||||
eFusePhysicalWriteRegisters(pAd, Offset+i, 2, &pValueX[i/2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================================================================
|
||||
|
||||
@ -492,442 +319,12 @@ USHORT InBuf[3];
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
INT set_eFuseLoadFromBin_Proc(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN PSTRING arg)
|
||||
{
|
||||
PSTRING src;
|
||||
RTMP_OS_FD srcf;
|
||||
RTMP_OS_FS_INFO osfsInfo;
|
||||
INT retval, memSize;
|
||||
PSTRING buffer, memPtr;
|
||||
INT i = 0,j=0,k=1;
|
||||
USHORT *PDATA;
|
||||
USHORT DATA;
|
||||
|
||||
memSize = 128 + MAX_EEPROM_BIN_FILE_SIZE + sizeof(USHORT) * 8;
|
||||
memPtr = kmalloc(memSize, MEM_ALLOC_FLAG);
|
||||
if (memPtr == NULL)
|
||||
return FALSE;
|
||||
|
||||
NdisZeroMemory(memPtr, memSize);
|
||||
src = memPtr; // kmalloc(128, MEM_ALLOC_FLAG);
|
||||
buffer = src + 128; // kmalloc(MAX_EEPROM_BIN_FILE_SIZE, MEM_ALLOC_FLAG);
|
||||
PDATA = (USHORT*)(buffer + MAX_EEPROM_BIN_FILE_SIZE); // kmalloc(sizeof(USHORT)*8,MEM_ALLOC_FLAG);
|
||||
|
||||
if(strlen(arg)>0)
|
||||
NdisMoveMemory(src, arg, strlen(arg));
|
||||
else
|
||||
NdisMoveMemory(src, EFUSE_EEPROM_DEFULT_FILE, strlen(EFUSE_EEPROM_DEFULT_FILE));
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src));
|
||||
|
||||
RtmpOSFSInfoChange(&osfsInfo, TRUE);
|
||||
|
||||
srcf = RtmpOSFileOpen(src, O_RDONLY, 0);
|
||||
if (IS_FILE_OPEN_ERR(srcf))
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error opening file %s\n", src));
|
||||
retval = FALSE;
|
||||
goto recoverFS;
|
||||
}
|
||||
else
|
||||
{
|
||||
// The object must have a read method
|
||||
while(RtmpOSFileRead(srcf, &buffer[i], 1)==1)
|
||||
{
|
||||
i++;
|
||||
if(i>MAX_EEPROM_BIN_FILE_SIZE)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error reading file %s, file size too large[>%d]\n", src, MAX_EEPROM_BIN_FILE_SIZE));
|
||||
retval = FALSE;
|
||||
goto closeFile;
|
||||
}
|
||||
}
|
||||
|
||||
retval = RtmpOSFileClose(srcf);
|
||||
if (retval)
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("--> Error closing file %s\n", src));
|
||||
}
|
||||
|
||||
|
||||
RtmpOSFSInfoChange(&osfsInfo, FALSE);
|
||||
|
||||
for(j=0;j<i;j++)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("%02X ",buffer[j]&0xff));
|
||||
if((j+1)%2==0)
|
||||
PDATA[j/2%8]=((buffer[j]<<8)&0xff00)|(buffer[j-1]&0xff);
|
||||
if(j%16==0)
|
||||
{
|
||||
k=buffer[j];
|
||||
}
|
||||
else
|
||||
{
|
||||
k&=buffer[j];
|
||||
if((j+1)%16==0)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, (" result=%02X,blk=%02x\n",k,j/16));
|
||||
if(k!=0xff)
|
||||
eFuseWriteRegistersFromBin(pAd,(USHORT)j-15, 16, PDATA);
|
||||
else
|
||||
{
|
||||
if(eFuseReadRegisters(pAd,j, 2,(PUSHORT)&DATA)!=0x3f)
|
||||
eFuseWriteRegistersFromBin(pAd,(USHORT)j-15, 16, PDATA);
|
||||
}
|
||||
/*
|
||||
for(l=0;l<8;l++)
|
||||
printk("%04x ",PDATA[l]);
|
||||
printk("\n");
|
||||
*/
|
||||
NdisZeroMemory(PDATA,16);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
|
||||
closeFile:
|
||||
if (srcf)
|
||||
RtmpOSFileClose(srcf);
|
||||
|
||||
recoverFS:
|
||||
RtmpOSFSInfoChange(&osfsInfo, FALSE);
|
||||
|
||||
|
||||
if (memPtr)
|
||||
kfree(memPtr);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
static NTSTATUS eFuseWriteRegistersFromBin(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN USHORT Offset,
|
||||
IN USHORT Length,
|
||||
IN USHORT* pData)
|
||||
{
|
||||
USHORT i;
|
||||
USHORT eFuseData;
|
||||
USHORT LogicalAddress, BlkNum = 0xffff;
|
||||
UCHAR EFSROM_AOUT,Loop=0;
|
||||
EFUSE_CTRL_STRUC eFuseCtrlStruc;
|
||||
USHORT efuseDataOffset;
|
||||
UINT32 data,tempbuffer;
|
||||
USHORT addr,tmpaddr, InBuf[3], tmpOffset;
|
||||
UINT32 buffer[4];
|
||||
BOOLEAN bWriteSuccess = TRUE;
|
||||
BOOLEAN bNotWrite=TRUE;
|
||||
BOOLEAN bAllocateNewBlk=TRUE;
|
||||
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin Offset=%x, pData=%04x:%04x:%04x:%04x\n", Offset, *pData,*(pData+1),*(pData+2),*(pData+3)));
|
||||
|
||||
do
|
||||
{
|
||||
//Step 0. find the entry in the mapping table
|
||||
//The address of EEPROM is 2-bytes alignment.
|
||||
//The last bit is used for alignment, so it must be 0.
|
||||
Loop++;
|
||||
tmpOffset = Offset & 0xfffe;
|
||||
EFSROM_AOUT = eFuseReadRegisters(pAd, tmpOffset, 2, &eFuseData);
|
||||
|
||||
if( EFSROM_AOUT == 0x3f)
|
||||
{ //find available logical address pointer
|
||||
//the logical address does not exist, find an empty one
|
||||
//from the first address of block 45=16*45=0x2d0 to the last address of block 47
|
||||
//==>48*16-3(reserved)=2FC
|
||||
bAllocateNewBlk=TRUE;
|
||||
for (i=EFUSE_USAGE_MAP_START; i<=EFUSE_USAGE_MAP_END; i+=2)
|
||||
{
|
||||
//Retrive the logical block nubmer form each logical address pointer
|
||||
//It will access two logical address pointer each time.
|
||||
eFusePhysicalReadRegisters(pAd, i, 2, &LogicalAddress);
|
||||
if( (LogicalAddress & 0xff) == 0)
|
||||
{//Not used logical address pointer
|
||||
BlkNum = i-EFUSE_USAGE_MAP_START;
|
||||
break;
|
||||
}
|
||||
else if(( (LogicalAddress >> 8) & 0xff) == 0)
|
||||
{//Not used logical address pointer
|
||||
if (i != EFUSE_USAGE_MAP_END)
|
||||
{
|
||||
BlkNum = i-EFUSE_USAGE_MAP_START+1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bAllocateNewBlk=FALSE;
|
||||
BlkNum = EFSROM_AOUT;
|
||||
}
|
||||
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegisters BlkNum = %d \n", BlkNum));
|
||||
|
||||
if(BlkNum == 0xffff)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegisters: out of free E-fuse space!!!\n"));
|
||||
return FALSE;
|
||||
}
|
||||
//Step 1.1.0
|
||||
//If the block is not existing in mapping table, create one
|
||||
//and write down the 16-bytes data to the new block
|
||||
if(bAllocateNewBlk)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("Allocate New Blk\n"));
|
||||
efuseDataOffset = EFUSE_DATA3;
|
||||
for(i=0; i< 4; i++)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("Allocate New Blk, Data%d=%04x%04x\n",3-i,pData[2*i+1],pData[2*i]));
|
||||
tempbuffer=((pData[2*i+1]<<16)&0xffff0000)|pData[2*i];
|
||||
|
||||
|
||||
RTMP_IO_WRITE32(pAd, efuseDataOffset,tempbuffer);
|
||||
efuseDataOffset -= 4;
|
||||
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////
|
||||
|
||||
//Step1.1.1. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment.
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
eFuseCtrlStruc.field.EFSROM_AIN = BlkNum* 0x10 ;
|
||||
|
||||
//Step1.1.2. Write EFSROM_MODE (0x580, bit7:bit6) to 3.
|
||||
eFuseCtrlStruc.field.EFSROM_MODE = 3;
|
||||
|
||||
//Step1.1.3. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical write procedure.
|
||||
eFuseCtrlStruc.field.EFSROM_KICK = 1;
|
||||
|
||||
NdisMoveMemory(&data, &eFuseCtrlStruc, 4);
|
||||
|
||||
RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data);
|
||||
|
||||
//Step1.1.4. Polling EFSROM_KICK(0x580, bit30) until it become 0 again. It¡¦s done.
|
||||
i = 0;
|
||||
while(i < 100)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, (PUINT32) &eFuseCtrlStruc);
|
||||
|
||||
if(eFuseCtrlStruc.field.EFSROM_KICK == 0)
|
||||
break;
|
||||
|
||||
RTMPusecDelay(2);
|
||||
i++;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{ //Step1.2.
|
||||
//If the same logical number is existing, check if the writting data and the data
|
||||
//saving in this block are the same.
|
||||
/////////////////////////////////////////////////////////////////
|
||||
//read current values of 16-byte block
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, &eFuseCtrlStruc.word);
|
||||
|
||||
//Step1.2.0. Write 10-bit of address to EFSROM_AIN (0x580, bit25:bit16). The address must be 16-byte alignment.
|
||||
eFuseCtrlStruc.field.EFSROM_AIN = Offset & 0xfff0;
|
||||
|
||||
//Step1.2.1. Write EFSROM_MODE (0x580, bit7:bit6) to 1.
|
||||
eFuseCtrlStruc.field.EFSROM_MODE = 0;
|
||||
|
||||
//Step1.2.2. Write EFSROM_KICK (0x580, bit30) to 1 to kick-off physical read procedure.
|
||||
eFuseCtrlStruc.field.EFSROM_KICK = 1;
|
||||
|
||||
NdisMoveMemory(&data, &eFuseCtrlStruc, 4);
|
||||
RTMP_IO_WRITE32(pAd, EFUSE_CTRL, data);
|
||||
|
||||
//Step1.2.3. Polling EFSROM_KICK(0x580, bit30) until it become 0 again.
|
||||
i = 0;
|
||||
while(i < 500)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, EFUSE_CTRL, (PUINT32) &eFuseCtrlStruc);
|
||||
|
||||
if(eFuseCtrlStruc.field.EFSROM_KICK == 0)
|
||||
break;
|
||||
RTMPusecDelay(2);
|
||||
i++;
|
||||
}
|
||||
|
||||
//Step1.2.4. Read 16-byte of data from EFUSE_DATA0-3 (0x59C-0x590)
|
||||
efuseDataOffset = EFUSE_DATA3;
|
||||
for(i=0; i< 4; i++)
|
||||
{
|
||||
RTMP_IO_READ32(pAd, efuseDataOffset, (PUINT32) &buffer[i]);
|
||||
efuseDataOffset -= 4;
|
||||
}
|
||||
//Step1.2.5. Check if the data of efuse and the writing data are the same.
|
||||
for(i =0; i<4; i++)
|
||||
{
|
||||
tempbuffer=((pData[2*i+1]<<16)&0xffff0000)|pData[2*i];
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("buffer[%d]=%x,pData[%d]=%x,pData[%d]=%x,tempbuffer=%x\n",i,buffer[i],2*i,pData[2*i],2*i+1,pData[2*i+1],tempbuffer));
|
||||
|
||||
if(((buffer[i]&0xffff0000)==(pData[2*i+1]<<16))&&((buffer[i]&0xffff)==pData[2*i]))
|
||||
bNotWrite&=TRUE;
|
||||
else
|
||||
{
|
||||
bNotWrite&=FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!bNotWrite)
|
||||
{
|
||||
printk("The data is not the same\n");
|
||||
|
||||
for(i =0; i<8; i++)
|
||||
{
|
||||
addr = BlkNum * 0x10 ;
|
||||
|
||||
InBuf[0] = addr+2*i;
|
||||
InBuf[1] = 2;
|
||||
InBuf[2] = pData[i];
|
||||
|
||||
eFuseWritePhysical(pAd, &InBuf[0], 6, NULL, 2);
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//Step 2. Write mapping table
|
||||
addr = EFUSE_USAGE_MAP_START+BlkNum;
|
||||
|
||||
tmpaddr = addr;
|
||||
|
||||
if(addr % 2 != 0)
|
||||
addr = addr -1;
|
||||
InBuf[0] = addr;
|
||||
InBuf[1] = 2;
|
||||
|
||||
//convert the address from 10 to 8 bit ( bit7, 6 = parity and bit5 ~ 0 = bit9~4), and write to logical map entry
|
||||
tmpOffset = Offset;
|
||||
tmpOffset >>= 4;
|
||||
tmpOffset |= ((~((tmpOffset & 0x01) ^ ( tmpOffset >> 1 & 0x01) ^ (tmpOffset >> 2 & 0x01) ^ (tmpOffset >> 3 & 0x01))) << 6) & 0x40;
|
||||
tmpOffset |= ((~( (tmpOffset >> 2 & 0x01) ^ (tmpOffset >> 3 & 0x01) ^ (tmpOffset >> 4 & 0x01) ^ ( tmpOffset >> 5 & 0x01))) << 7) & 0x80;
|
||||
|
||||
// write the logical address
|
||||
if(tmpaddr%2 != 0)
|
||||
InBuf[2] = tmpOffset<<8;
|
||||
else
|
||||
InBuf[2] = tmpOffset;
|
||||
|
||||
eFuseWritePhysical(pAd,&InBuf[0], 6, NULL, 0);
|
||||
|
||||
//Step 3. Compare data if not the same, invalidate the mapping entry, then re-write the data until E-fuse is exhausted
|
||||
bWriteSuccess = TRUE;
|
||||
for(i =0; i<8; i++)
|
||||
{
|
||||
addr = BlkNum * 0x10 ;
|
||||
|
||||
InBuf[0] = addr+2*i;
|
||||
InBuf[1] = 2;
|
||||
InBuf[2] = 0x0;
|
||||
|
||||
eFuseReadPhysical(pAd, &InBuf[0], 4, &InBuf[2], 2);
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("addr=%x, buffer[i]=%x,InBuf[2]=%x\n",InBuf[0],pData[i],InBuf[2]));
|
||||
if(pData[i] != InBuf[2])
|
||||
{
|
||||
bWriteSuccess = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//Step 4. invlidate mapping entry and find a free mapping entry if not succeed
|
||||
|
||||
if (!bWriteSuccess&&Loop<2)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin::Not bWriteSuccess BlkNum = %d\n", BlkNum));
|
||||
|
||||
// the offset of current mapping entry
|
||||
addr = EFUSE_USAGE_MAP_START+BlkNum;
|
||||
|
||||
//find a new mapping entry
|
||||
BlkNum = 0xffff;
|
||||
for (i=EFUSE_USAGE_MAP_START; i<=EFUSE_USAGE_MAP_END; i+=2)
|
||||
{
|
||||
eFusePhysicalReadRegisters(pAd, i, 2, &LogicalAddress);
|
||||
if( (LogicalAddress & 0xff) == 0)
|
||||
{
|
||||
BlkNum = i-EFUSE_USAGE_MAP_START;
|
||||
break;
|
||||
}
|
||||
else if(( (LogicalAddress >> 8) & 0xff) == 0)
|
||||
{
|
||||
if (i != EFUSE_USAGE_MAP_END)
|
||||
{
|
||||
BlkNum = i+1-EFUSE_USAGE_MAP_START;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin::Not bWriteSuccess new BlkNum = %d\n", BlkNum));
|
||||
if(BlkNum == 0xffff)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("eFuseWriteRegistersFromBin: out of free E-fuse space!!!\n"));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
//invalidate the original mapping entry if new entry is not found
|
||||
tmpaddr = addr;
|
||||
|
||||
if(addr % 2 != 0)
|
||||
addr = addr -1;
|
||||
InBuf[0] = addr;
|
||||
InBuf[1] = 2;
|
||||
|
||||
eFuseReadPhysical(pAd, &InBuf[0], 4, &InBuf[2], 2);
|
||||
|
||||
// write the logical address
|
||||
if(tmpaddr%2 != 0)
|
||||
{
|
||||
// Invalidate the high byte
|
||||
for (i=8; i<15; i++)
|
||||
{
|
||||
if( ( (InBuf[2] >> i) & 0x01) == 0)
|
||||
{
|
||||
InBuf[2] |= (0x1 <<i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// invalidate the low byte
|
||||
for (i=0; i<8; i++)
|
||||
{
|
||||
if( ( (InBuf[2] >> i) & 0x01) == 0)
|
||||
{
|
||||
InBuf[2] |= (0x1 <<i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
eFuseWritePhysical(pAd, &InBuf[0], 6, NULL, 0);
|
||||
}
|
||||
|
||||
}
|
||||
while(!bWriteSuccess&&Loop<2);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
int rtmp_ee_efuse_read16(
|
||||
IN RTMP_ADAPTER *pAd,
|
||||
IN USHORT Offset,
|
||||
OUT USHORT *pValue)
|
||||
{
|
||||
if(pAd->bFroceEEPROMBuffer || pAd->bEEPROMFile)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("Read from EEPROM Buffer\n"));
|
||||
NdisMoveMemory(pValue, &(pAd->EEPROMImage[Offset]), 2);
|
||||
}
|
||||
else
|
||||
eFuseReadRegisters(pAd, Offset, 2, pValue);
|
||||
eFuseReadRegisters(pAd, Offset, 2, pValue);
|
||||
return (*pValue);
|
||||
}
|
||||
|
||||
@ -944,177 +341,6 @@ int RtmpEfuseSupportCheck(
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT set_eFuseBufferModeWriteBack_Proc(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN PSTRING arg)
|
||||
{
|
||||
UINT Enable;
|
||||
|
||||
|
||||
if(strlen(arg)>0)
|
||||
{
|
||||
Enable= simple_strtol(arg, 0, 16);
|
||||
}
|
||||
else
|
||||
return FALSE;
|
||||
if(Enable==1)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("set_eFuseBufferMode_Proc:: Call WRITEEEPROMBUF"));
|
||||
eFuseWriteEeeppromBuf(pAd);
|
||||
}
|
||||
else
|
||||
return FALSE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
========================================================================
|
||||
|
||||
Routine Description:
|
||||
Load EEPROM from bin file for eFuse mode
|
||||
|
||||
Arguments:
|
||||
Adapter Pointer to our adapter
|
||||
|
||||
Return Value:
|
||||
NDIS_STATUS_SUCCESS firmware image load ok
|
||||
NDIS_STATUS_FAILURE image not found
|
||||
|
||||
IRQL = PASSIVE_LEVEL
|
||||
|
||||
========================================================================
|
||||
*/
|
||||
INT eFuseLoadEEPROM(
|
||||
IN PRTMP_ADAPTER pAd)
|
||||
{
|
||||
PSTRING src = NULL;
|
||||
INT retval;
|
||||
RTMP_OS_FD srcf;
|
||||
RTMP_OS_FS_INFO osFSInfo;
|
||||
|
||||
|
||||
src=EFUSE_BUFFER_PATH;
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src));
|
||||
|
||||
|
||||
RtmpOSFSInfoChange(&osFSInfo, TRUE);
|
||||
|
||||
if (src && *src)
|
||||
{
|
||||
srcf = RtmpOSFileOpen(src, O_RDONLY, 0);
|
||||
if (IS_FILE_OPEN_ERR(srcf))
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error %ld opening %s\n", -PTR_ERR(srcf),src));
|
||||
return FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
memset(pAd->EEPROMImage, 0x00, MAX_EEPROM_BIN_FILE_SIZE);
|
||||
|
||||
|
||||
retval =RtmpOSFileRead(srcf, (PSTRING)pAd->EEPROMImage, MAX_EEPROM_BIN_FILE_SIZE);
|
||||
if (retval > 0)
|
||||
{
|
||||
RTMPSetProfileParameters(pAd, (PSTRING)pAd->EEPROMImage);
|
||||
retval = NDIS_STATUS_SUCCESS;
|
||||
}
|
||||
else
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("Read file \"%s\" failed(errCode=%d)!\n", src, retval));
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error src or srcf is null\n"));
|
||||
return FALSE;
|
||||
|
||||
}
|
||||
|
||||
retval=RtmpOSFileClose(srcf);
|
||||
|
||||
if (retval)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("--> Error %d closing %s\n", -retval, src));
|
||||
}
|
||||
|
||||
|
||||
RtmpOSFSInfoChange(&osFSInfo, FALSE);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
INT eFuseWriteEeeppromBuf(
|
||||
IN PRTMP_ADAPTER pAd)
|
||||
{
|
||||
|
||||
PSTRING src = NULL;
|
||||
INT retval;
|
||||
RTMP_OS_FD srcf;
|
||||
RTMP_OS_FS_INFO osFSInfo;
|
||||
|
||||
|
||||
src=EFUSE_BUFFER_PATH;
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("FileName=%s\n",src));
|
||||
|
||||
RtmpOSFSInfoChange(&osFSInfo, TRUE);
|
||||
|
||||
|
||||
|
||||
if (src && *src)
|
||||
{
|
||||
srcf = RtmpOSFileOpen(src, O_WRONLY|O_CREAT, 0);
|
||||
|
||||
if (IS_FILE_OPEN_ERR(srcf))
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error %ld opening %s\n", -PTR_ERR(srcf),src));
|
||||
return FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
// The object must have a read method
|
||||
if (srcf->f_op && srcf->f_op->write)
|
||||
{
|
||||
// The object must have a read method
|
||||
srcf->f_op->write(srcf, pAd->EEPROMImage, 1024, &srcf->f_pos);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error!! System doest not support read function\n"));
|
||||
return FALSE;
|
||||
}
|
||||
*/
|
||||
|
||||
RtmpOSFileWrite(srcf, (PSTRING)pAd->EEPROMImage,MAX_EEPROM_BIN_FILE_SIZE);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("--> Error src or srcf is null\n"));
|
||||
return FALSE;
|
||||
|
||||
}
|
||||
|
||||
retval=RtmpOSFileClose(srcf);
|
||||
|
||||
if (retval)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("--> Error %d closing %s\n", -retval, src));
|
||||
}
|
||||
|
||||
RtmpOSFSInfoChange(&osFSInfo, FALSE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd,
|
||||
PUINT EfuseFreeBlock)
|
||||
{
|
||||
@ -1151,18 +377,6 @@ INT eFuse_init(
|
||||
UINT EfuseFreeBlock=0;
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("NVM is Efuse and its size =%x[%x-%x] \n",EFUSE_USAGE_MAP_SIZE,EFUSE_USAGE_MAP_START,EFUSE_USAGE_MAP_END));
|
||||
eFuseGetFreeBlockCount(pAd, &EfuseFreeBlock);
|
||||
//If the used block of efuse is less than 5. We assume the default value
|
||||
// of this efuse is empty and change to the buffer mode in odrder to
|
||||
//bring up interfaces successfully.
|
||||
if(EfuseFreeBlock > (EFUSE_USAGE_MAP_END-5))
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_ERROR, ("NVM is Efuse and the information is too less to bring up interface. Force to use EEPROM Buffer Mode\n"));
|
||||
pAd->bFroceEEPROMBuffer = TRUE;
|
||||
eFuseLoadEEPROM(pAd);
|
||||
}
|
||||
else
|
||||
pAd->bFroceEEPROMBuffer = FALSE;
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("NVM is Efuse and force to use EEPROM Buffer Mode=%x\n",pAd->bFroceEEPROMBuffer));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -69,10 +69,7 @@ INT RtmpChipOpsEepromHook(
|
||||
return 0 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
pAd->bFroceEEPROMBuffer = FALSE;
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("NVM is EEPROM\n"));
|
||||
}
|
||||
#endif // RTMP_EFUSE_SUPPORT //
|
||||
#endif // RT30xx //
|
||||
|
||||
|
@ -694,15 +694,6 @@ VOID NICReadEEPROMParameters(
|
||||
|
||||
if (pAd->chipOps.eeinit)
|
||||
pAd->chipOps.eeinit(pAd);
|
||||
#ifdef RTMP_EFUSE_SUPPORT
|
||||
#ifdef RT30xx
|
||||
if(!pAd->bFroceEEPROMBuffer && pAd->bEEPROMFile)
|
||||
{
|
||||
DBGPRINT(RT_DEBUG_TRACE, ("--> NICReadEEPROMParameters::(Efuse)Load to EEPROM Buffer Mode\n"));
|
||||
eFuseLoadEEPROM(pAd);
|
||||
}
|
||||
#endif // RT30xx //
|
||||
#endif // RTMP_EFUSE_SUPPORT //
|
||||
|
||||
// Init EEPROM Address Number, before access EEPROM; if 93c46, EEPROMAddressNum=6, else if 93c66, EEPROMAddressNum=8
|
||||
RTMP_IO_READ32(pAd, E2PROM_CSR, &data);
|
||||
|
@ -1065,26 +1065,6 @@ int RtmpOSFileWrite(RTMP_OS_FD osfd, char *pDataPtr, int writeLen)
|
||||
return osfd->f_op->write(osfd, pDataPtr, (size_t)writeLen, &osfd->f_pos);
|
||||
}
|
||||
|
||||
|
||||
void RtmpOSFSInfoChange(RTMP_OS_FS_INFO *pOSFSInfo, BOOLEAN bSet)
|
||||
{
|
||||
if (bSet)
|
||||
{
|
||||
// Save uid and gid used for filesystem access.
|
||||
// Set user and group to 0 (root)
|
||||
pOSFSInfo->fsuid = current_fsuid();
|
||||
pOSFSInfo->fsgid = current_fsgid();
|
||||
pOSFSInfo->fs = get_fs();
|
||||
set_fs(KERNEL_DS);
|
||||
}
|
||||
else
|
||||
{
|
||||
set_fs(pOSFSInfo->fs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
|
||||
Task create/management/kill related functions.
|
||||
|
@ -2258,8 +2258,6 @@ struct _RTMP_ADAPTER
|
||||
#ifdef RT30xx
|
||||
#ifdef RTMP_EFUSE_SUPPORT
|
||||
BOOLEAN bUseEfuse;
|
||||
BOOLEAN bEEPROMFile;
|
||||
BOOLEAN bFroceEEPROMBuffer;
|
||||
UCHAR EEPROMImage[1024];
|
||||
#endif // RTMP_EFUSE_SUPPORT //
|
||||
#endif // RT30xx //
|
||||
@ -4021,10 +4019,6 @@ INT set_eFusedump_Proc(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN PSTRING arg);
|
||||
|
||||
INT set_eFuseLoadFromBin_Proc(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN PSTRING arg);
|
||||
|
||||
VOID eFusePhysicalReadRegisters(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN USHORT Offset,
|
||||
@ -4034,16 +4028,6 @@ VOID eFusePhysicalReadRegisters(
|
||||
int RtmpEfuseSupportCheck(
|
||||
IN RTMP_ADAPTER *pAd);
|
||||
|
||||
INT set_eFuseBufferModeWriteBack_Proc(
|
||||
IN PRTMP_ADAPTER pAd,
|
||||
IN PSTRING arg);
|
||||
|
||||
INT eFuseLoadEEPROM(
|
||||
IN PRTMP_ADAPTER pAd);
|
||||
|
||||
INT eFuseWriteEeeppromBuf(
|
||||
IN PRTMP_ADAPTER pAd);
|
||||
|
||||
VOID eFuseGetFreeBlockCount(IN PRTMP_ADAPTER pAd,
|
||||
PUINT EfuseFreeBlock);
|
||||
|
||||
@ -5632,10 +5616,5 @@ int RtmpOSFileWrite(
|
||||
IN char *pDataPtr,
|
||||
IN int writeLen);
|
||||
|
||||
void RtmpOSFSInfoChange(
|
||||
IN RTMP_OS_FS_INFO *pOSFSInfo,
|
||||
IN BOOLEAN bSet);
|
||||
|
||||
|
||||
#endif // __RTMP_H__
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user