userconfig.c

此压缩包为杰得开发得z228的BSP的源代码,可以实现很多功能,尤其是视频解码有很好的效果.

#include "UserConfig.h"

#define SHOW_DEBUG 0

unsigned long dwBlockAddr;
unsigned long dwTempAddr;
unsigned long dwBlockStartAddr;


int FLA_Init(void)
{
	PHYSICAL_ADDRESS blockaddr;
	RETAILMSG(SHOW_DEBUG, (_T("%s\r\n"), _T(__FUNCTION__)));
	
	blockaddr.HighPart = 0 ;
	blockaddr.LowPart  = START_FLASH_ADDR;
	dwBlockStartAddr = (unsigned long)MmMapIoSpace(blockaddr, COMMAND_SIZE, FALSE);
	RETAILMSG(SHOW_DEBUG, (_T("%s: @dwBlockStartAddr: 0x%x\r\n"), _T(__FUNCTION__), dwBlockStartAddr));	
	
	blockaddr.HighPart = 0 ;
	blockaddr.LowPart  = BASE_FLASH_ADDR;
	dwBlockAddr = (unsigned long)MmMapIoSpace(blockaddr, USERDEF_SIZE, FALSE);
	RETAILMSG(SHOW_DEBUG, (_T("%s: @dwBlockAddr: 0x%x\r\n"), _T(__FUNCTION__), dwBlockAddr));

	dwTempAddr = (unsigned long)malloc(BYTES_PER_BLOCK);
	RETAILMSG(SHOW_DEBUG, (_T("%s: @dwTempAddr: 0x%x\r\n"), _T(__FUNCTION__), dwTempAddr));
	return 1;
}

int FLA_Deinit(void)
{	
	RETAILMSG(SHOW_DEBUG, (_T("%s\r\n"), _T(__FUNCTION__)));
	free((void *)dwTempAddr);
	MmUnmapIoSpace((PVOID)dwBlockStartAddr, COMMAND_SIZE);
	MmUnmapIoSpace((PVOID)dwBlockAddr, USERDEF_SIZE);
	return 1;
}

/*
int FLA_check_status (unsigned long address)
{
	unsigned long mask;
	unsigned long status;

	// Creates a mask word.
	mask = 0x80;

	// Get the current status
	do
	{
		FLASH_COMMAND (address, 0x70);
		status = FLASH(address);
	}
	while ((status & mask) != mask);

	status &= ~mask;

	if (status)
		FLASH_COMMAND (address, 0x50);

	FLASH_COMMAND (address, 0xFF);

	// Return status
	if (status!=0)
		return -1;
	else
		return 0;
}


//------------------------------------------------------------------------------
//
// Writes a word to the flash device.
//   
// address - Address to write
// word - Data to write
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_write_word (unsigned long address, unsigned short word)
{
	FLASH_COMMAND(address, 0x40);
	FLASH(address) = word;
	return FLA_check_status (address);
}

//------------------------------------------------------------------------------
//
// Reads a word from the flash device.
//
// address - Address to read
// word - Pointer to data to read
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_read_word (unsigned long address, unsigned short * pword)
{
	*pword = FLASH(address);
	return FLA_check_status (address);
}


//------------------------------------------------------------------------------
//
// Erases a block.
//
// address - Address to erase
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_erase_block (unsigned long address)
{
	FLASH_COMMAND(address, 0x20);
	FLASH_COMMAND(address, 0xD0);
	return FLA_check_status (address);
}


//------------------------------------------------------------------------------
//
// Locks a single block.
//
// address - Address to lock
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_set_lock_bits (unsigned long address)
{
	FLASH_COMMAND (address, 0x60);
	FLASH_COMMAND (address, 0x01);
	return FLA_check_status (address);
}
//------------------------------------------------------------------------------
//
// UnLocks all blocks.
//
// address - Address to unlock
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_clear_lock_bits (unsigned long address)
{
	FLASH_COMMAND (address, 0x60);
	FLASH_COMMAND (address, 0xD0);
	return FLA_check_status (address);
}
*/

int FLA_check_status (unsigned long address)
{

	unsigned long dwTimeOut = 0;
	unsigned char status,Pre_status;
	
       Pre_status = FLASH(address) & 0x40;
	   
	// Get the current status	
	while(dwTimeOut < 0x7ffff)	{		
		status = FLASH(address) & 0x40;
		if(status == Pre_status)
			break;
		Pre_status = status;
		dwTimeOut ++;
	}
	
	// Return status
	if (dwTimeOut >= 0x7ffff)
		return -1;
	else
		return 0;
}

//------------------------------------------------------------------------------
//
// Writes a byte the flash device.
//   
// address - Address to write
// byte - Data to write
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_write_byte (unsigned long address, unsigned char byte)
{
	volatile int i;

	FLASH_COMMAND(0x5555, 0xaa);

	i = 1;
	while(i--);
  FLASH_COMMAND(0x2aaa, 0x55);

	i = 1;
	while(i--);
	FLASH_COMMAND(0x5555, 0xa0);

	i = 1;
	while(i--);
	FLASH(address) = byte;

	return FLA_check_status (address);
}

//------------------------------------------------------------------------------
//
// Reads a byte from the flash device.
//
// address - Address to read
// byte - Pointer to data to read
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_read_byte (unsigned long address, unsigned char * pbyte)
{
       *pbyte = FLASH(address);
       return FLA_check_status (address); 
}

//------------------------------------------------------------------------------
//
// Erases a block.
//
// address - Address to erase
//
// return 0 - Success -1 - Failure
//
//------------------------------------------------------------------------------
int FLA_erase_block (unsigned long address)
{
        //RETAILMSG(MSG_DATA, (_T("FLASH: FLA_cfi_erase_block: 0x%x\r\n"), address));
	volatile int i;

	FLASH_COMMAND(0x5555, 0xaa);
	i = 1;
	while(i--);

	FLASH_COMMAND(0x2aaa, 0x55);
	i = 1;
	while(i--);

	FLASH_COMMAND(0x5555, 0x80);
	i = 1;
	while(i--);

	FLASH_COMMAND(0x5555, 0xaa);
	i = 1;
	while(i--);

	FLASH_COMMAND(0x2aaa, 0x55);
	i = 1;
	while(i--);
	
	FLASH_DATA(address, 0x30);
	
	Sleep(1);
	
	return FLA_check_status (address);
}

int FLA_Read(unsigned long blocknum, unsigned char *buf, unsigned long size)
{
	unsigned long i;
//	assert(size <= BYTES_PER_BLOCK && size%2 == 0);
	RETAILMSG(SHOW_DEBUG, (_T("%s\r\n"), _T(__FUNCTION__)));
	
	RETAILMSG(SHOW_DEBUG, (_T("%s - blknum: 0x%x, buf: 0x%x, size: 0x%x, dwBlockAddr: 0x%x\r\n"), _T(__FUNCTION__), blocknum, buf, size, dwBlockAddr));

	for (i=0; i<size; i++)
	{
		FLA_read_byte(
			(dwBlockAddr + blocknum*BYTES_PER_BLOCK + i), 
			(unsigned char *)(buf + i)
			);
	}
	
	return 1;
}

int FLA_Write(unsigned long blocknum, unsigned char *buf, unsigned long size)
{
	volatile unsigned long i;
	
//	assert(size <= BYTES_PER_BLOCK && size%2 == 0);
	RETAILMSG(SHOW_DEBUG, (_T("%s\r\n"), _T(__FUNCTION__)));

	RETAILMSG(SHOW_DEBUG, (_T("%s - blknum: 0x%x, buf: 0x%x, size: 0x%x, dwBlockAddr: 0x%x\r\n"), _T(__FUNCTION__), blocknum, buf, size, dwBlockAddr));

//	FLA_Read(blocknum, (unsigned char *)dwTempAddr, BYTES_PER_BLOCK);
	memcpy((unsigned char *)dwTempAddr, buf, size);

//	memcpy(buf,(unsigned char *)dwTempAddr, size);
	RETAILMSG(SHOW_DEBUG,(L"SaveQAcc dwTempAddr:%x,%x,%x,%x,%x,%x,%x,%x\r\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]));

//	FLA_clear_lock_bits(dwBlockAddr + blocknum*BYTES_PER_BLOCK);
	FLA_erase_block(dwBlockAddr + blocknum*BYTES_PER_BLOCK);
	FLA_Read(0,buf,8);
	RETAILMSG(SHOW_DEBUG,(L"FLA_erase_block:%x,%x,%x,%x,%x,%x,%x,%x\r\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]));
	
	for (i=0; i<size; i++)
	{
			FLA_write_byte(
				(dwBlockAddr + blocknum*BYTES_PER_BLOCK + i), 
				*(unsigned char *)(dwTempAddr + i)
				);
				Sleep(1);
				
			
	}
//	FLA_set_lock_bits(dwBlockAddr + blocknum*BYTES_PER_BLOCK);
	return 1;
}