dm642main.c

SEED的VPM642测试程序-板级支持库

/********************************************************************/
/*  Copyright 2004 by SEED Incorporated.							*/
/*  All rights reserved. Property of SEED Incorporated.				*/
/*  Restricted rights to use, duplicate or disclose this code are	*/
/*  granted through contract.									    */
/*  															    */
/********************************************************************/
/*
 *---------dm642main.c---------
 * This example uses a timer to read and write the ESAM.
 */


#include <stdio.h>
//#include <string.h>
#include <stdlib.h>

#include <csl.h>
#include <std.h>
#include <csl_irq.h>
#include <csl_chip.h>

#include "seeddm642.h"
#include "seed_rtciic.h"
#include "seed_eeprom.h"
#include "seed_io&led.h"
#include "seeddm642_ide.h"
#include "seeddm642_flash.h"
#include "seeddm642_uart.h"

#define SEEDDM642_SDRAM_BASE		0x80000000

SEEDDM642_RTC_Config rtcCfg = {
	0x2005,
	0x0008,
	0x0002,
	(0x004 + RTC_X1226_24),/*采用24小时的模式*/
	0x0017,
	0x0059,
	0x0003
};
Uint8 rtcregvalue = 0;

SEEDDM642_UART_Config UartConfig ={
	   0x00,/*寄存器IER*/
	   0x57,/*寄存器FCR*/
	   0x03,/*寄存器LCR*/
	   0x01,/*寄存器MCR*/
};
Uint16 uartbuffer;
SEEDDM642_UART_Handle SEEDuartHandleA;
SEEDDM642_UART_Handle SEEDuartHandleB;

void rtc_delay(Uint32 delay)
{
	Uint32 i = 0;
	for(i = 0; i<delay;i++)
	{
		SEEDDM642_waitusec(10000);
	}	
}
extern far void vectors();
/*测试SDRAM Memory*/
void mem_test();
/*测试IO*/
void IO_test();
/*测试LED*/
void LED_test();
/*测试IDE*/
void IDE_test();
/*测试Flash*/
void FLASH_test();
/*测试EEPROM*/
void EEPROM_test();
/*测试RTC写*/
void RTC_write_test();
/*测试RTC读*/
void RTC_read_test();
/*测试UART_A*/
void UART_A_test();
/*测试UART_B*/
void UART_B_test();

Uint32 bsltest = 0;
/* Define source and destination arrays for flash tests */
Uint16 buffer[256];
Uint32 atabuffer[512];
ATA_command atacommand;
char view[30];

/*此程序为BSL库的测试，命令参数从GEL菜单中传入*/
void main()
{

/*-------------------------------------------------------*/
/* perform all initializations                           */
/*-------------------------------------------------------*/
	SEEDVPM642_init();
/*----------------------------------------------------------*/
	/*中断向量表的初始化*/
	IRQ_globalDisable();
	//Point to the IRQ vector table
    IRQ_setVecs(vectors);  
/*----------------------------------------------------------*/
	*(int *)0x3FC = 0;
	
	 /* Open UART */
    SEEDuartHandleA = SEEDDM642_UART_open(SEEDDM642_UARTA, 
    									  SEEDDM642_UART_BAUD9600, 
    									  &UartConfig);
    /*Open UARTB*/
    SEEDuartHandleB = SEEDDM642_UART_open(SEEDDM642_UARTB, 
    									  SEEDDM642_UART_BAUD9600, 
    									  &UartConfig);
	/*test all*/
	while(TRUE)
	{
		bsltest = *(int *)0x3FC;
		bsltest = bsltest & 0xFF;
		switch(bsltest)
		{
			case 0xA0:
			/*测试SDRAM Memory*/
			*(int *)0x3FC = 0xFF;
			mem_test();
			break;
			case 0xA1:
			/*测试LED*/
			*(int *)0x3FC = 0xFF;
			LED_test();
			printf("the led test is finished!\n");
			break;
			case 0xA2:
			*(int *)0x3FC = 0xFF;
			/*测试IO*/
			IO_test();
			break;
			case 0xA3:
			/*测试IDE*/
			*(int *)0x3FC = 0xFF;
			IDE_test();
			break;
			case 0xA4:
			/*测试Flash*/
			*(int *)0x3FC = 0xFF;
			FLASH_test();
			break;
			case 0xA5:
			/*测试EEPROM*/
			*(int *)0x3FC = 0xFF;
			EEPROM_test();
			break;
			case 0xA6:
			/*测试RTC写*/
			*(int *)0x3FC = 0xFF;
			RTC_write_test();
			break;
			case 0xA7:
			/*测试RTC读*/
			RTC_read_test();
			break;
			case 0xA8:
			/*测试UART_A*/
			UART_A_test();
			break;
			case 0xA9:
			/*测试UART_A*/
			UART_B_test();
			break;
			default:
			break;
		}
	}
}
/*测试SDRAM Memory*/
void mem_test()
{
	Uint32 i;
	Uint8 check = 0;
	Uint32 block = 0;
	/*sdram的测试,sdram的地址从0x8000 0000开始，长度为32M字节*/
	//写头256个字节
	for(block = 0;block <0x20000;block++)
	{
		for(i = 0;i<0x100;i++)
		{
			*((Uint8 *)(SEEDDM642_SDRAM_BASE + i+(block<<8))) = i;
		}
		/*read and check*/
		for(i = 0;i<0x100;i++)
		{
			check = *((Uint8 *)(SEEDDM642_SDRAM_BASE + i+(block<<8)));
			if(check != i)
			{
				for(;;)
				{
					printf("the error address is 0x%x\n",SEEDDM642_SDRAM_BASE + i+(block<<8));
					break;
				}
			}
		}
	}
	printf("the SDRAM work well!\n");
	/*测试完成*/
}
/*测试IO*/
void IO_test()
{
	Uint32 temp;
	printf("the io value set is 0x55.\n");
	VPM642_io_write(0x55);
    SEEDDM642_waitusec(0x50000);
	temp = VPM642_io_read();
	temp = 0x55 | temp;

	printf("the io value readback is 0x%x\n",temp);
	printf("the io value set is 0xaa.\n");
	VPM642_io_write(0xAA);
	SEEDDM642_waitusec(0x50000);
	temp = VPM642_io_read();
	temp = 0xaa | temp;

	printf("the io value readback is 0x%x\n",temp);
	printf("the io value set is 0x33.\n");
	VPM642_io_write(0x33);
	SEEDDM642_waitusec(0x50000);
	temp = VPM642_io_read();
	temp = 0x33 | temp;
	printf("the io value readback is 0x%x\n",temp);
}
/*测试LED*/
void LED_test()
{
	int i;
	for(i = 0;i<20;i++)
	{
		VPM642_Led_onboard(VPM642_LED_D3,VPM642_LED_ON);
		SEEDDM642_waitusec(0x50000);
		VPM642_Led_onboard(VPM642_LED_D3,VPM642_LED_OFF);
		SEEDDM642_waitusec(0x50000);
		VPM642_Led_onboard(VPM642_LED_D4,VPM642_LED_ON);
		SEEDDM642_waitusec(0x50000);
		VPM642_Led_onboard(VPM642_LED_D4,VPM642_LED_OFF);
		SEEDDM642_waitusec(0x50000);
	}
}
/*测试IDE*/
void IDE_test()
{
	int  j,i;
//	Uint32 buffer[512];
	for(i = 0;i<512;i++)
	{
		atabuffer[i] = 0;
	}	
	ata_open();
/*----------------------------------------------------*/
	/*确定硬盘的型号与类型*/	
	/*提交设备确认命令*/
	atacommand.features = 0x100;
	atacommand.sector_count = 0x100;
	atacommand.LBA_l = 0x100;
	atacommand.LBA_M = 0x100;
	atacommand.LBA_H = 0x100;
	atacommand.device = 0x00;
	atacommand.prereq = ATA_BUS_DRDY;
	atacommand.complete_flag = ATA_BUS_DRQ;
	atacommand.com_code = IDENTIFY_DEVICE;
	if(FALSE ==ata_command( &atacommand,
							(Uint32)(&atabuffer),
							128))
	{
		for(;;){}
	}
	/*显示序列号*/
	i = 10;
	j = 0;
	do
	{	
		view[j++] = (atabuffer[i] >>8) & 0xff;
		view[j++] = atabuffer[i] & 0xff;
		i++;
	}while(view[j]!= 0x20);
	view[j]= 0x00;
	printf("the Serial number:%s\n",view);
	/*显示模块的名称*/
	i = 27;
	j = 0;
	do
	{	
		view[j++] = (atabuffer[i] >>8) & 0xff;
		view[j++] = atabuffer[i] & 0xff;
		i++;
	}while(view[j]!= 0x20);
	view[j] = 0x00;
	printf("the Model number:%s\n",view);
}
/*测试Flash*/
void FLASH_test()
{
	Uint16 i, j, k, page, limit;
    Uint32 startaddr, addr;
	/*FLash的测试*/
	/*测试每一页*/
    /* Program the Flash page by page, 256 words at a time */
    /* Set Flash page，选择第0页 */
    page  = 0;
    for(page = 0;page<8;page++)
    {
        SEEDDM642_rset(SEEDDM642_FLASHPAGE, page);
        /*等待延时*/
		SEEDDM642_waitusec(1);
        /* Erase all of the Flash for each page */
        SEEDDM642_FLASH_erase(SEEDDM642_FLASH_BASE, SEEDDM642_FLASH_PAGESIZE);
        /*等待延时*/
		SEEDDM642_waitusec(1);
    }
	/*取FLASh的首址*/
    addr = SEEDDM642_FLASH_BASE;
            
    for(page = 0;page<8;page++)
    {
        /*取FLASh的首址*/
    	addr = SEEDDM642_FLASH_BASE;
        /* Set Flash page*/
   		 SEEDDM642_rset(SEEDDM642_FLASHPAGE, page);       		 
   		 /*等待延时*/
		 SEEDDM642_waitusec(1);
        /*将数据写入第0页，每页512K*/
        limit = 8;
        for (i = 0; i < limit; i++)
        {
            for (j = 0; j < 128; j++)
            {
                startaddr = addr;
                /*每次写入512个字节，以16位的数据为基数*/
                for (k = 0; k < 256; k++)
                {
                    buffer[k] = (addr + i + page) & 0xffff;
                    addr += 2;
                }
                SEEDDM642_FLASH_write((Uint32)buffer, startaddr, 512);
            }
        }
   	 }
        
    /* Verify the Flash page by page, 512 bytes at a time */
    for (page = 0; page < 8; page++)
    {
        /*取FLASh的首址*/
        addr = SEEDDM642_FLASH_BASE;
        /* Set Flash page */
        SEEDDM642_rset(SEEDDM642_FLASHPAGE, page);
        /*等待延时*/
		SEEDDM642_waitusec(1);
        addr = SEEDDM642_FLASH_BASE;
        limit = 8;
        for (i = 0; i < limit; i++)
        {
            for (j = 0; j < 128; j++)
            {
                startaddr = addr;
                SEEDDM642_FLASH_read(startaddr, (Uint32)buffer, 512);
                for (k = 0; k < 256; k++)
                {
                    if (buffer[k] != ((addr + i + page) & 0xffff))
                    {     
                    	/*写入出错*/
                    	printf("the flash is error!\n");
                    	for(;;){}
                    }
                    addr += 2;
                }
            }
        }
    }
    /*测试完成*/
    printf("Flash test is OK!\n");
}
/*测试EEPROM*/
void EEPROM_test()
{
	Uint16 page, i;
    Uint8 *pdata;
	/*写eeprom*/    
    /* Write a pattern */
    for (page = 0; page < 4; page++)
    {
        pdata = (Uint8 *)buffer;
        for (i = 0; i < 64; i++)
        {
            *pdata++ = (page + i) & 0xff;
        }
        SEEDDM642_EEPROM_write( SEEDVPM642_I2C_hI2C,
        						(Uint32)buffer, 
        						page << 6, 
        						64);
    }
    
    /* Verify the pattern */
    for (page = 0; page < 4; page++)
    {
        SEEDDM642_EEPROM_read( SEEDVPM642_I2C_hI2C,
                               page << 6, 
                               (Uint32)buffer, 
                               64);
        
        pdata = (Uint8 *)buffer;
        for (i = 0; i < 64; i++)
        {
            if (*pdata++ != (page + i) & 0xff)
            {
                printf("the EEPROM is fail!\n");
                for(;;){}  // Fail     
            }
        }
    }
    printf("the EEPROM is ok!\n");
}
/*测试RTC写*/
void RTC_write_test()
{
	/*设置当前的时间值*/
	/*设置年*/
	rtcregvalue = (rtcCfg.year & 0xff00)>>8;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_Y2K,
						 &rtcregvalue);
						 
	rtcregvalue = rtcCfg.year & 0x00ff;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_YR, 
						 &rtcregvalue);
	/*设置月*/
	rtcregvalue = rtcCfg.month;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_MO,
						 &rtcregvalue);
	/*设置日*/
	rtcregvalue = rtcCfg.day;
	RTC_write( SEEDVPM642_I2C_hI2C,
						RTC_X1226_DT,
						&rtcregvalue);
	/*设置时*/
	rtcregvalue = rtcCfg.hour;
	RTC_write( SEEDVPM642_I2C_hI2C,
						RTC_X1226_HR,
						&rtcregvalue);
	/*设置分*/
	rtcregvalue = rtcCfg.minutes;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_MN,
						 &rtcregvalue);
	/*设置秒*/
	rtcregvalue = rtcCfg.seconds;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_SC, 
						 &rtcregvalue);
	/*设置星期*/
	rtcregvalue = rtcCfg.week;
	RTC_write( SEEDVPM642_I2C_hI2C,
						 RTC_X1226_DW,
						 &rtcregvalue);
	printf("the RTC set is over!\n");
}
/*测试RTC读*/
void RTC_read_test()
{
//   int i=0;
 //   while(1)
    {
	    /*读年*/ 
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_Y2K,   
							&rtcregvalue);
		rtcCfg.year = ( rtcregvalue & 0x00ff)<<8;
		
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_YR, 
							&rtcregvalue);
		rtcCfg.year = rtcCfg.year + (rtcregvalue & 0x00ff);
		/*读月*/	  
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_MO, 
							&rtcregvalue);
		rtcCfg.month = rtcregvalue;
		/*读日*/	
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_DT, 
							&rtcregvalue);
		rtcCfg.day = rtcregvalue;
		/*读时*/
		
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_HR, 
							&rtcregvalue);
		rtcCfg.hour = rtcregvalue - RTC_X1226_24;
		/*读分*/	
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_MN, 
							&rtcregvalue);
		rtcCfg.minutes = rtcregvalue;
		/*读秒*/	
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_SC, 
							&rtcregvalue);
		rtcCfg.seconds = rtcregvalue;
		/*读星期*/	
		RTC_read( SEEDVPM642_I2C_hI2C,
							RTC_X1226_DW, 
							&rtcregvalue);
		rtcCfg.week = rtcregvalue;
		printf("time is:%x年%x月%x日%x时%x分%x秒\n",rtcCfg.year,rtcCfg.month,
					 rtcCfg.day,rtcCfg.hour,rtcCfg.minutes,rtcCfg.seconds);
		/*延时1秒钟*/
		rtc_delay(80);
//		i++;
//		if(i==6)
//			{
//			*(int *)0x3FC = 0xFF;
//			break;
//			}
		}
		
}
/*测试UART_A*/
void UART_A_test()
{   
    while(1)
    {
		/*测试串口A*/
		uartbuffer = SEEDDM642_UART_getChar(SEEDuartHandleA);
	    SEEDDM642_UART_putChar(SEEDuartHandleA, (uartbuffer & 0xff)); 
	    if((uartbuffer & 0xff)=='\r')
	       {
	          *(int *)0x3FC = 0xFF;
	          break;
	       }
      
    } 
    return;
}
/*测试UART_B*/
void UART_B_test()
{
    while(1)
    {
		uartbuffer = SEEDDM642_UART_getChar(SEEDuartHandleB);
	    SEEDDM642_UART_putChar(SEEDuartHandleB, (uartbuffer & 0xff));
       if((uartbuffer & 0xff)=='\r')
	   {
          *(int *)0x3FC = 0xFF;
          break;
       }
	} 
}