📄 romdrv_old_back.c
字号:
FlashWriteByte(Address,*(P_U8)DataPoint);
DataPoint++;
Address++;
}
lenX = lenX -(rawAddress % 4);
}
}
//// //FLASH_WRITE_ENABLE
/*
if((len%2) != 0)
lenX = len-1;
else lenX = len;
*/
counter = 0;
BufferCount = 0;
tempAddr = (R_U32)Address;
while(counter < lenX)
{
if( ( (U32)tempAddr + 32) / 0x20000 == (U32)tempAddr / 0x20000)
if( (counter + 32) > lenX )
BufferCount = (lenX - counter) / 2;
else
BufferCount = 16;
else
BufferCount = ( ( ( (U32)tempAddr / 0x20000) + 1) * 0x20000 - (U32)tempAddr) / 2;
if(BufferCount < 16)
{
(*FlashWriteBlockWordP)( (U32)tempAddr, DataPoint, BufferCount * 4);
tempAddr += BufferCount;
DataPoint += BufferCount * 4;
counter += BufferCount * 4;
}
else
{
counter1 = 0x0;
*tempAddr = 0xe800e8;
//while((*tempAddr & 0x80) == 0);
while( *tempAddr != 0x800080)
{
counter1++;
if(counter1 > 10000000)
break;
}
*tempAddr = 16 - 1;
counter += BufferCount * 4;
for(i = 0; i < 16; i++)
{
temp = *(R_U32)DataPoint;
*tempAddr = temp;
DataPoint += 4;
tempAddr++;
}
*(tempAddr - 1) = 0xd000d0;
counter1 = 0x0;
mid = *(tempAddr - 1);
*(tempAddr - 1) = 0x700070;
while( mid != 0x800080)
{
*(tempAddr - 1) = 0x700070;
mid = *(tempAddr - 1);
counter1++;
if(counter1 > 10000000)
break;
}
*(tempAddr - 1) = 0x500050;
*(tempAddr - 1) = 0xff00ff;
}
}
//// FLASH_WRITE_DISABLE
Address = (P_U8)tempAddr;
if(lenX != len)
{
for(i = 0; i < (lenX -lenX); i++) //fill left butes of lenX
{
FlashWriteByte(Address,*(P_U8)DataPoint);
DataPoint++;
Address++;
}
}
return(0);
}
void CopyFlashProgram()
{
P_U8 copyP,tempP;
U32 temp1,temp2,len;
len = (U32)CopyFlashProgram - (U32)FlashUnlockBlock;
tempP = (P_U8)SysLmalloc(len);
copyP = (P_U8)FlashUnlockBlock;
MoveBlock((R_U32)copyP, (R_U32)tempP, len);
FlashUnlockBlockP=tempP;
temp1 = (U32)FlashUnlockBlock;
temp2 = (U32)FlashLockBlock;
FlashLockBlockP = tempP + temp2 - temp1;
temp2 = (U32)FlashEraseBlock;
FlashEraseBlockP = tempP + temp2 - temp1;
temp2 = (U32)FlashWriteByte;
FlashWriteByteP = tempP + temp2 - temp1;
temp2 = (U32)FlashWriteBlockWord;
FlashWriteBlockWordP = tempP + temp2 - temp1;
temp2 = (U32)FlashWriteBlock;
FlashWriteBlockP = tempP + temp2 - temp1;
}
unsigned long FlashReadBlock( U32 buffer, U32 Address, unsigned long len )
{
*(U32 *)Address = 0xff00ff; //gfd read status
memcpy( (void *)buffer, (void *)Address, len );
return 0;
}
void drv_flash_write ( unsigned char *data, unsigned int start, unsigned int size )
{
#ifdef NORFLASH
//// (*FlashUnlockBlockP)(start);
(*FlashEraseBlockP)(start);
(*FlashWriteBlockP)( start, data, size );
//// (*FlashLockBlockP)( start ); ////gfd 0813
#else //NAND FLASH
nand_write(start, size, data);
#endif
}
void drv_flash_read ( unsigned char *data, unsigned int start, unsigned int size )
{
#ifdef NORFLASH
FlashReadBlock( data, start, size );
#else //NAND FLASH
nand_read(start, size, data);
#endif
}
/*gfd nor driver*/
/*
extern INT nor_rd_open(UINT16 driveno);
extern INT nor_rd_raw_open(UINT16 driveno);
extern INT nor_rd_close(UINT16 driveno);
extern INT nor_rd_io(UINT16 driveno, UINT32 block, VOID FAR *buffer, UINT16 count, INT do_read);
extern INT nor_rd_ioctl(UINT16 driveno, UINT16 command, VOID *buffer);
*/
#if 0
UINT8 *nor_rd_alloc_page(VOID)
{
STATUS status;
#if (RAMDISK_FROMPOOL)
UINT8 *mem_address;
/* Allocate a page. */
status = NU_Allocate_Partition(&NUF_RAMDISK_PARTITION, (VOID **)&mem_address,
NU_NO_SUSPEND);
if (status == NU_SUCCESS)
return(mem_address);
else
return((UINT8 *)0);
#else /* not RAMDISK_FROMPOOL */
/* Using MALLOC instead of Allocate_Partition */
UINT8 *mem_address;
OPTION preempt_status;
/* Don't let anyone interfere with the malloc. Anticpating DOS non-
reentrancy. */
preempt_status = NU_Change_Preemption(NU_NO_PREEMPT);
/* Get the memory. */
mem_address = (UINT8 *)malloc(NUF_RAMDISK_PARTITION_SIZE);
/* Others can take over now since the malloc is complete. */
NU_Change_Preemption(preempt_status);
return(mem_address);
#endif /* RAMDISK_FROMPOOL */
}
VOID nor_rd_free_page(UINT8 *page)
{
#if (RAMDISK_FROMPOOL)
/* If the input parameter is valid, deallocate. */
if (page)
NU_Deallocate_Partition((VOID *)page);
#else
/* Using free() instead of dealloc */
OPTION preempt_status;
/* Don't let anyone interfere with the malloc. Anticpating DOS non-
reentrancy. */
preempt_status = NU_Change_Preemption(NU_NO_PREEMPT);
/* If the input is valid, deallocate the page. */
if (page)
free(page);
/* Others can take over now since the malloc is complete. */
NU_Change_Preemption(preempt_status);
#endif
}
INT nor_rd_open(UINT16 driveno)
{
UINT16 i;
UINT16 j;
/* We don't use drive no. You could have multiple drives if wanted */
driveno = driveno;
/* If the ramdisk is not initialized, do it now */
if (!nor_rd_pages[0])
{
for (i = 0; i < NUM_RAMDISK_PAGES; i++)
{
nor_rd_pages[i] = nor_rd_alloc_page();
if (!nor_rd_pages[i])
{
for (j = 0; j < i; j++)
{
nor_rd_free_page(nor_rd_pages[j]);
nor_rd_pages[j] = 0;
}
return(NO);
}
}
}
nor_rd_opencount += 1;
return(YES);
}
INT nor_rd_close(UINT16 driveno)
{
int i;
if (nor_rd_opencount )
--nor_rd_opencount ;
if (!nor_rd_opencount )
{
for (i = 0; i < NUM_RAMDISK_PAGES; i++)
{
nor_rd_free_page(nor_rd_pages[i]);
nor_rd_pages[i] = 0;
}
}
driveno = driveno;
return(YES);
}
#endif
UINT8 *nor_rd_alloc_page(VOID)
{
return((UINT8 *)0);
}
VOID nor_rd_free_page(UINT8 *page)
{
}
INT nor_rd_open(UINT16 driveno)
{
return(YES);
}
INT nor_rd_close(UINT16 driveno)
{
return(YES);
}
int nor_rd_io(U16 driveno, U32 page, void FAR *buffer, U16 count, int do_read)
{
U32 *pbuffer = buffer;
U32 *pdatabuf = NULL;
U16 pageoffset = 0;
U32 status = YES;
U32 i=0;
do_read &= 0x01;
if(do_read == YES){
pbuffer = buffer;
for(i=0; i<count; i++)
{
status = nand_rd_page( page, (U32 *)pbuffer, YES);
if(status != YES) return NO;
page++; pbuffer += 0x80; //one page has 512BYTES for common
}
}
else
{
nand_erase_block(page);
status = nand_rd_block(page, (U32 *)pbuffer);
}
return(status);
}
INT nor_rd_io_old(UINT16 driveno, UINT32 page, VOID FAR *buffer, UINT16 count, INT do_read)
{
UINT8 *p;
UINT32 ltemp,tempblknum;
UINT32 page_number;
UINT32 byte_number;
UINT32 pageoffset = 0;
INT16 i;
UINT8 *pbuffer, *ptempbuffer;
INT flag;
/* We don't use drive no. You could have multiple drives if wanted */
driveno = driveno;
pbuffer = (UINT8 *)buffer;
flag = do_read;
flag &= 1;
while (count)
{
byte_number = 512*(page & 0x1ff);
tempblknum = (page >> 9);
/* Check. This shouldn't happen */
//if ( (page_number >= NUM_RAMDISK_PAGES) || !nor_rd_pages[page_number] )
// return(NO);
if(tempblknum != g_nor_blknum)
{
if (flag)
{
p = (UINT8 *)(FAT_FLASH_STARTADD + page * 512);
drv_flash_read(( unsigned char *)(pbuffer + (pageoffset++)*512), (unsigned int *)p, 512 );
}
else
{
drv_flash_write (( unsigned char *) g_nor_buf,( unsigned int *) (g_nor_blknum*512*512 + FAT_FLASH_STARTADD), FLASH_AREA_SIZE );
drv_flash_read(( unsigned char *)g_nor_buf, (unsigned int *)(tempblknum*512*512 + FAT_FLASH_STARTADD), FLASH_AREA_SIZE);
for (i = 0; i < 512; i++)
g_nor_buf[byte_number+i] = *pbuffer++;
g_nor_blknum = tempblknum;
}
}
else
{
if (flag)
{
for (i = 0; i < 512; i++)
*pbuffer++ = g_nor_buf[byte_number+i] ;
}
else
{
for (i = 0; i < 512; i++)
g_nor_buf[byte_number+i] = *pbuffer++;
}
}
count--;
page++;
}
if(do_read&FLUSH)
drv_flash_write (( unsigned char *) g_nor_buf,( unsigned int *) (g_nor_blknum*512*512 + FAT_FLASH_STARTADD), FLASH_AREA_SIZE );
return(YES);
}
INT nor_rd_raw_open(UINT16 driveno)
{
}
INT nor_rd_ioctl(UINT16 driveno, UINT16 command, VOID *buffer)
{
}
void nor_flush(void)
{
drv_flash_write (( unsigned char *) g_nor_buf,( unsigned int *) (g_nor_blknum*512*512 + FAT_FLASH_STARTADD), FLASH_AREA_SIZE );
}
int nor_write_page_format(U32 page, U32 *buffer, U32 do_read)
{
int i;
U8 *tmpbuffer;
U8 *tmpaddr;
tmpbuffer = (U8 *)buffer;
tmpaddr = (U8 *)(page<<9);
for(i = 0; i < 512; i++)
{
FlashWriteByte(tmpaddr,*tmpbuffer);
tmpbuffer ++;
tmpaddr ++;
}
return YES;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -