nordriver.c

(1)基于部分u-boot代码自己调试的vxworks BSP (2)实现了nand/nor flash的tffs文件系统 (3)实现了对spi dataflash的访问 (4)实现了对启动参数

    *((volatile UINT16 *)ROM_BASE_ADRS+0x2AA) = 0x55;
    *((volatile UINT16 *)ROM_BASE_ADRS+0x555) = 0x10;
	
#if 0

    taskDelay (sysClkRateGet () * 512);

#else

    for (i = 0; i < 513; i++)
    {
        if (*((volatile UINT16 *)ROM_BASE_ADRS)  == (UINT16)0xFFFF)
	     break;
		
	 taskDelay (sysClkRateGet());	
	 
	 printf(".");

    }
	
    printf("\r\n");	
	
    if (i == 10)
        printf("Erase chip failed!\r\n");	
    else	
        printf("Erase chip done!\r\n");
	
#endif

    return OK;
}


/*-----------------------------------------------------------------------------
Function:   flasherasesecotor

Overview:   

Input:      None

Output:     None

Return:     None
-----------------------------------------------------------------------------*/
STATUS amd_flash_cmd_erase_sector(char *pEraseSectorCmd)
{ 
#if 1
    UINT32 sector = 0;
    UINT32 sectoraddr = 0;
    UINT32 i = 0;	 
		
    if (sscanf(pEraseSectorCmd, "%*s %*s %d", &sector) == EOF)
    {
       return (ERROR);			 
    }

#if 0	
    if ((sector > 34) || (sector < 0))
    {
        printf("Sector Number error!\n");
        return ERROR;
    }
    else if (sector > 3)
    {
        sectoraddr = 0x08000 * (sector - 3);
    }
    else
    {
        switch (sector)
	     {
			 	case 0:
					sectoraddr = 0x00000;
					break;
				case 1:
					sectoraddr = 0x02000;
					break;
				case 2:
					sectoraddr = 0x03000; 
					break;
				case 3:
					sectoraddr = 0x04000;  
					break;
				default:
					break;
	     }
    }
#else

#ifdef AT91_NOR_FLASH_16M_TO_32M
    if (sector > 255)
    {
        printf("Invalid sector number.\r\n");
	    return ERROR;	
    }

	if(sector > 127)/*wurj*/
	{
		sectoraddr = (AT91_FLASH_SIZE) + NOR_FLASH_SECTOR_SIZE_IN_BYTES*(sector - 128);
	}
	else
	{
		sectoraddr = NOR_FLASH_SECTOR_SIZE_IN_BYTES * sector;
	}
#else /* AT91_NOR_FLASH_16M_TO_32M */

    if (sector > 127)
    {
        printf("Invalid sector number.\r\n");
	    return ERROR;	
    }

    sectoraddr = NOR_FLASH_SECTOR_SIZE_IN_BYTES * sector;
#endif /* AT91_NOR_FLASH_16M_TO_32M */
	
#endif
 
    *((volatile UINT16 *)ROM_BASE_ADRS+0x555) = 0xAA;
    *((volatile UINT16 *)ROM_BASE_ADRS+0x2AA) = 0x55;
    *((volatile UINT16 *)ROM_BASE_ADRS+0x555) = 0x80;
    *((volatile UINT16 *)ROM_BASE_ADRS+0x555) = 0xAA;
    *((volatile UINT16 *)ROM_BASE_ADRS+0x2AA) = 0x55;
    *((volatile UINT16 *)(ROM_BASE_ADRS+sectoraddr)) = 0x30;

    for (i = 0; i < 5; i++)
    {
        if (*((volatile UINT16 *)(ROM_BASE_ADRS+sectoraddr))  == (UINT16)0xFFFF)
	     break;
	 taskDelay (sysClkRateGet());	
	 printf(".");

    }

    printf("\r\n");
	
    if (i == 10)
        printf("Erase sector %d failed!\r\n", sector);	
    else	
        printf("Erase sector %d done!\r\n", sector);
	
    #endif
    return OK;
}

/*-----------------------------------------------------------------------------
Function:   amd_flash_cmd_identifier

Overview:   

Input:      None

Output:     None

Return:     None
-----------------------------------------------------------------------------*/

STATUS amd_flash_cmd_identifier()
{ 
    UINT16 ManufacturerID = 0;
    UINT16 DeviceID[3];
	
#if 0

    if (nor_flash_identify_chip(&ManufacturerID, DeviceID) != OK)
    {
        return ERROR;
    }

    nor_flash_reset();
	
    printf("Manufacturer ID : 0x%x\n", ManufacturerID);
    printf("DeviceID[0] : 0x%x\n", DeviceID[0]);	
    printf("DeviceID[1] : 0x%x\n", DeviceID[1]);
    printf("DeviceID[2] : 0x%x\n", DeviceID[2]);
	
#else

    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0xAA;
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x2AA) = 0x55;
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0x90;
    ManufacturerID = *((volatile UINT16 *)ROM_BASE_ADRS + 0x000);
    printf("Manufacturer ID : 0x%x\n", ManufacturerID);	
	
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0xAA;
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x2AA) = 0x55;
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0x90;
    DeviceID[0] = *((volatile UINT16 *)ROM_BASE_ADRS + 0x001);	
    DeviceID[1] = *((volatile UINT16 *)ROM_BASE_ADRS + 0x00E);
    DeviceID[2] = *((volatile UINT16 *)ROM_BASE_ADRS + 0x00F);
    printf("DeviceID : 0x%x 0x%x 0x%x\n", DeviceID[0], DeviceID[1], DeviceID[2]);
	
    /* Issue reset command to exit autoselect mode */	
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x000) = 0xF0;   
    
	
#endif

    return OK;
}


/*-----------------------------------------------------------------------------
Function:   amd_flash_cmd_reset

Overview:   

Input:      None

Output:     None

Return:     None
-----------------------------------------------------------------------------*/
STATUS amd_flash_cmd_reset()
{ 

    /* Issue reset command to exit autoselect mode */	
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x000) = 0xF0;  
	
    return OK;
}


/*-----------------------------------------------------------------------------
Function:   amd_flash_cmd_program

Overview:   

Input:      None

Output:     None

Return:     None
-----------------------------------------------------------------------------*/
STATUS amd_flash_cmd_program(char *pWriteCommand)
{ 
    UINT32 address = 0;
    UINT32 data = 0;
		
    if (sscanf(pWriteCommand, "%*s %*s %x %x", &address, &data) == EOF)/*%d -->%x wurj*/
    {
       return (ERROR);			 
    }

    printf("Flash program address: 0x%x\n", address);
    printf("Flash program data: 0x%x\n", data);
	
#if 0

    if (nor_flash_program(address, (UINT8 *)&data, sizeof(data)) != OK)
    {
        return ERROR;
    }
	
#else

    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0xAA;
    *((volatile UINT16*)ROM_BASE_ADRS + 0x2AA) = 0x55;
    *((volatile UINT16 *)ROM_BASE_ADRS + 0x555) = 0xA0;		
    *((volatile UINT16 *)(ROM_BASE_ADRS + address)) = data;
	
#endif
    return OK;
}
/*-----------------------------------------------------------------------------
Function:   amd_flash_cmd_read

Overview:   

Input:      None

Output:     None

Return:     None
-----------------------------------------------------------------------------*/
STATUS amd_flash_cmd_read(char *pReadCommand)
{ 
    UINT32 address = 0;
    UINT16 data = 0;

    if (sscanf(pReadCommand, "%*s %*s %x", &address) == EOF)/*%d -->%x wurj*/
    {
       return (ERROR);			 
    }
	
#if 0

    if (nor_flash_read((UINT8 *)&data, address, sizeof(data)) != OK)
   	{
   	    return ERROR;
   	}
	
#else		

    data = *((volatile UINT16 *)(ROM_BASE_ADRS + address));

    printf("Flash addr: 0x%x\n", address);
    printf("Flash data: 0x%x\n", data);
	
#endif		
    return OK;
}


#define NOR_FLASH_BASE_ADDRESS 0x10000000
#define NOR_FLASH_SECTOR_SIZE_IN_BYTES 0x20000



/* Nor flash return value */
#define NOR_FLASH_BUSY			       0x00
#define NOR_FLASH_OK				0x01
#define NOR_FLASH_ERROR			0x02
#define NOR_FLASH_BAD_ADDRESS	0x05


/* Driver State */
#define IDLE		0x0
#define BUSY		0x1
#define FLASH_ERROR	0x2

#define NOR_FLASH_ERASE_SECTOR_TIMEOUT 0x10000000
#define NOR_FLASH_PROGRAM_TIMEOUT 0x10000000

/*------------------------------------------------------------------------------*/
/* Function Name       : erase_nor_flash_sector 					*/
/* Object              : 				*/
/* Input Parameters    : 							*/
/* Return value		: 							*/
/*------------------------------------------------------------------------------*/
int erase_nor_flash_sector(unsigned int sector_num, unsigned int sector_count)
{
    unsigned int sector_offset_address = 0;	
    unsigned int i = 0;	
    int erase_ok = -1;	

    if ((sector_num + sector_count) > 255)/*128 or 256 wurj*/
    {
        printf("Invalid sector number.\r\n");
	 return NOR_FLASH_ERROR;	
    }

    printf("Erasing nor flash sector from sector %d, count %d\r\n", sector_num, sector_count);

    for (; sector_count > 0; sector_count--, sector_num++)
    {
        erase_ok = -1;
        sector_offset_address = NOR_FLASH_SECTOR_SIZE_IN_BYTES * sector_num;

        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x555) = 0xAA;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x2AA) = 0x55;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x555) = 0x80;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x555) = 0xAA;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x2AA) = 0x55;
        *((volatile unsigned short *)(NOR_FLASH_BASE_ADDRESS + sector_offset_address)) = 0x30;

        for (i = 0; i < NOR_FLASH_ERASE_SECTOR_TIMEOUT; i++)
        {
            if (*((volatile unsigned short *)(NOR_FLASH_BASE_ADDRESS + sector_offset_address))  == (unsigned short)0xFFFF)
            {
                erase_ok = 0;
	         break;
            }		 
        }	

	 if (erase_ok != 0)
	 {
            return NOR_FLASH_ERROR;
	 }
    }

    return NOR_FLASH_OK;

}


/*------------------------------------------------------------------------------*/
/* Function Name       : write_nor_flash 					*/
/* Object              : 				*/
/* Input Parameters    : 							*/
/* Return value		: 							*/
/*------------------------------------------------------------------------------*/
int write_nor_flash (unsigned int addr_dest, unsigned int addr_src, unsigned int size)
{    
    unsigned int start_sector_number = 0, sector_count = 0;

    int write_ok = -1;
    unsigned int time_out = 0;	
    volatile unsigned short * pData_Source =  (volatile unsigned short *)addr_src;
	
    if (((addr_src & 0x01) != 0) || ((size & 0x01) != 0))
    {
        return NOR_FLASH_ERROR;
    }    
#if 0
    printf("addr_dest = 0x%x addr_src = 0x%x size = 0x%x\r\n", addr_dest, addr_src, size);
#endif	
    /*Erase the sector used to strore the data*/
    start_sector_number = (addr_dest - NOR_FLASH_BASE_ADDRESS)/NOR_FLASH_SECTOR_SIZE_IN_BYTES;
    sector_count = size/NOR_FLASH_SECTOR_SIZE_IN_BYTES + 1;
    if (erase_nor_flash_sector(start_sector_number, sector_count) != NOR_FLASH_OK)	
    {
        printf("Erasing nor flash sectors failed.\r\n");
        return NOR_FLASH_ERROR;
    }
	
    /* Start to program the 16bits to the nor flash */
    while (size > 0)
    {
        write_ok = -1;
		
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x555) = 0xAA;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x2AA) = 0x55;
        *((volatile unsigned short *)NOR_FLASH_BASE_ADDRESS + 0x555) = 0xA0;		
        *((volatile unsigned short *)addr_dest) =  *pData_Source; 

        for (time_out = 0; time_out < NOR_FLASH_PROGRAM_TIMEOUT; time_out++)
        {
            if ((*((volatile unsigned short *)addr_dest)) == *pData_Source)
            {
                write_ok = 0;
                break;
            }
        }

        if (write_ok != 0)
        {
            printf("Writing nor flash failed.\r\n");
            return(NOR_FLASH_ERROR);
        }
		
	 addr_dest += 2;
        size -=2;
	 pData_Source++;
    }

    return NOR_FLASH_OK;

}


/*------------------------------------------------------------------------------*/
/* Function Name       : read_nor_flash 					*/
/* Object              : 				*/
/* Input Parameters    : 							*/
/* Return value		: 							*/
/*------------------------------------------------------------------------------*/
int read_nor_flash(unsigned int addr_src, unsigned int size, char *addr_dest)
{
    volatile unsigned short * pFlash = (unsigned short * )addr_dest;
	
    if (((addr_src & 0x01) != 0) || ((size & 0x01) != 0))
    {
        return NOR_FLASH_ERROR;
    }   
#if 0	
   printf("addr_dest = 0x%p addr_src = 0x%x size = 0x%x\r\n", addr_dest, addr_src, size);
#endif
    while (size > 0)
    {
        *pFlash = *((volatile unsigned short *)addr_src);
		
	 addr_src += 2;
	 pFlash++;
        size -=2;
    }

    return NOR_FLASH_OK;
}



#endif /* INCLUDE_NOR_FLASH */