#define    GLOBAL_CLK        1

 #include <stdlib.h>

 #include <string.h>

 #include “def.h”

 #include “option.h”

 #include “2440addr.h”

 #include “2440lib.h”

 #include “2440slib.h”

 #include “mmu.h”

 #include “profile.h”

 #include “memtest.h”

 //extern置于变量或函数之前，以标示变量或函数的定义在别的文件中

 extern char Image$$RO$$Limit[];

 extern char Image$$RO$$Base[];

 extern char Image$$RW$$Limit[];

 extern char Image$$RW$$Base[];

 extern char Image$$ZI$$Limit[];

 extern char Image$$ZI$$Base[];

 //RO是程序中的指令和常量；RO就是readonly，

 //RW是程序中的已初始化变量； RW就是read/write，

 // ZI是程序中的未初始化的变量；ZI就是zero；

 //|Image$$RO$$Limit|：表示RO区末地址后面的地址，即RW数据源的起始地址

  //|Image$$RW$$Base|：RW区在RAM里的执行区起始地址，也就是编译器选项RW_Base指定的地址

  //|Image$$ZI$$Base|：ZI区在RAM里面的起始地址

  //|Image$$ZI$$Limit|：ZI区在RAM里面的结束地址后面的一个地址

 void Isr_Init(void);

 void HaltUndef(void);

 void HaltSwi(void);

 void HaltPabort(void);

 void HaltDabort(void);

 void ClearMemory(void);

 void Clk0_Enable(int clock_sel);

 void Clk1_Enable(int clock_sel);

 void Clk0_Disable(void);

 void Clk1_Disable(void);

 //extern置于变量或函数之前，以标示变量或函数的定义在别的文件中

 extern void Lcd_TFT_Init(void);

 extern void Lcd_TFT_Test( void ) ;

 extern void Test_Touchpanel(void) ;

 extern void Test_Adc(void) ;

 extern void KeyScan_Test(void) ;

 extern void RTC_Display(void) ;

 extern void Test_IrDA_Tx(void) ;

 extern void PlayMusicTest(void) ;

 extern void RecordTest( void ) ;

 extern void Test_Iic(void) ;

 extern void Test_SDI(void) ;

 extern void Camera_Test( void ) ;

 //volatile影响编译器编译的结果，指出volatile变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化。

 volatile U32 downloadAddress;

 //void (*restart)(void)，定义一个指针，指针名为restart，指针指向函数，函数的返回类型为void

 // (void (*)(void))0×0，将0×0强制转换，使其符合等号左边的类型。

 void (*restart)(void)=(void (*)(void))×;

 volatile unsigned char *downPt;

 volatile U32 downloadFileSize;

 volatile U16 checkSum;

 volatile unsigned int err=;

 volatile U32 totalDmaCount;

 volatile int isUsbdSetConfiguration;

 int download_run=;

 U32 tempDownloadAddress;

 int menuUsed=;

 extern char Image$$RW$$Limit[];

 U32 *pMagicNum=(U32 *)Image$$RW$$Limit;

 int consoleNum;

 /*在全局变量之前，加上关键字static，全局变量就被定义成为一个全局静态变量。

 1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

 2）初始化：未经初始化的全局静态变量会被程序自动初始化为0

 3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地将从定义之处开始到文件结尾*/

 static U32 cpu_freq;

 static U32 UPLL;

  /*在函数的返回类型前加上关键字static，函数就被定义成为静态函数。

 函数的定义和声明默认情况下是extern的，但静态函数只是在声明它的文件当中可见，不能被其他文件使用。*/

 static void cal_cpu_bus_clk(void)

 {

     U32 val;

     U8 m, p, s;

     val = rMPLLCON;

     m = (val>>)&0xff;   // m=92=MDIV

     p = (val>>)&0x3f;     // p=1=PDIV

     s = val&;                  // s=1=SDIV

     //(m+8)*FIN*2 不要超出32位数!

    /* 按照手册上面的计算，Fout=2*m*Fin/(p*2s),其中Fin=12MHz。但m、p、s与上面的不一样。公式中m=MDIV+8，p=PDIV+2,s=SDIV

     (1<<s),将1左移S位。逻辑左移相当于乘以2的N次方。而逻辑右移，相当于除以2的N次方

    FIN、FCLK在option.h中定义，FIN=12000000，经计算FCLK=400MHz*/

     FCLK = ((m+)*(FIN/)*)/((p+)*(<<s))*;

     val = rCLKDIVN;

     m = (val>>)&;//m=2=HDIVN

     p = val&;        // P=1=PDIVN

     val = rCAMDIVN;

    // 由于之前没有设置过CAMDIVN寄存器，所以是默认值

    s=0x0000_0000,其最后两位00，代表没移位之前的CAMDIVN[9][8]

     s = val>>;

     switch (m) {

     case :

         HCLK = FCLK;

         break;

     case :

         HCLK = FCLK>>;

         break;

     case :

         if(s&)

             m=2,CAMDIVN[9]=0,表示FCLK:HCK=1:4

             HCLK = FCLK>>;

         else

             HCLK = FCLK>>;

         break;

     case :

         if(s&)

             HCLK = FCLK/;

         else

             HCLK = FCLK/;

         break;

     }

     if(p)

         //p=1，表示HCLK:PCLK=1:2

         PCLK = HCLK>>;

     else

         PCLK = HCLK;

     if(s&×)

         cpu_freq = HCLK;

     else

       // s=0，表示CPU频率等于FCLK频率

         cpu_freq = FCLK;

    // UPLLCON在Main函数里没有设置，但在2440init里有设置

     val = rUPLLCON;

     m==MDIV

     m = (val>>)&0xff;

     p==PDIV

     p = (val>>)&0x3f;

     s==SDIV

     s = val&;

    //UPLL的计算方法，同MPLL一样，经计算知，UPLL=48MHz

     UPLL = ((m+)*FIN)/((p+)*(<<s));

     /*根据2440init里CLKVAL的值，CLKDIVN[3]=DIVN_UPLL=0

     rCLKDIVN&8=0，所以UCLK=UPLL=48MHz*/

     UCLK = (rCLKDIVN&)?(UPLL>>):UPLL;

 }

 void Temp_function() { Uart_Printf(“\nPlease input - to select test!!!\n”); }

    /* 定义一个结构体，没有结构体类型名称，但其结构体变量为CmdTip[]，为一个数组。

     结构体成员：

            有一个指针，名为fun。其指向一个函数，函数的返回类型为void。

            有一个指针，名为tip，其指向字符型。

            函数的函数名就像数组名一样，其本身就是指针，代表函数的入口地址*/

 struct {

     void (*fun)(void);

     char *tip;

 }CmdTip[] = {

                 { Temp_function, “Please input - to select test” } ,

                 { BUZZER_PWM_Test, “Test PWM” } ,

                 { RTC_Display, “RTC time display” } ,

                 { Test_Adc, “Test ADC” } ,

                 { KeyScan_Test, “Test interrupt and key scan” } ,

                 { Test_Touchpanel, “Test Touchpanel” } ,

                 { Lcd_TFT_Test, “Test TFT LCD” } ,

                 { Test_Iic, “Test IIC EEPROM” } ,

                 { PlayMusicTest, “UDA1341 play music” } ,

                 { RecordTest, “UDA1341 record voice” } ,

                 { Test_SDI, “Test SD Card” } ,

                 { Camera_Test, “Test CMOS Camera”},

                 { , }

             };

 void Main(void)

 {

     char *mode;

     int i;

     U8 key;

     U32 mpll_val =  ;

     //U32 divn_upll = 0 ;

    /*#if如果给定条件为真，则编译下面代码，直到出现#else、#elif或#endif为止；否则就不编译。

    ADS10在option.h定义，ADS10=1，这段没有任何作用*/

     #if ADS10

 //    __rt_lib_init(); //for ADS 1.0

     #endif

   /*S3C2440有130个管脚。可以通过软件配置每个管脚的功能来满足系统及外设的要求。所以在程序开始之前，你必须定义每个管脚的配置。

     端口初始化，设置GPA/B/C/D/E/F/G/H/J相应的管脚，EXTINT0/1/2/3*/

     Port_Init();

    /*设置中断服务程序，初始化。

     把所有中断设置为IRQ模式，屏蔽所有中断请求*/

     Isr_Init();

     i =  ;    //don’t use 100M!

     switch ( i ) {

     case :    //

         key = ;

         mpll_val = (<<)|(<<)|();

         break;

     case :    //

         key = ;

         mpll_val = (<<)|(<<)|();

         break;

     case :    //400

       // 设置时钟分频比的值，FCLK:HCLK:PCLK

         key = ;

      //  设置FCLK的值，MDIV=92,PDIV=1,SDIV=1

         mpll_val = (<<)|(<<)|();

         break;

     case :    //440!!!

         key = ;

         mpll_val = (<<)|(<<)|();

         break;

     default:

         key = ;

         mpll_val = (<<)|(<<)|();

         break;

     }

     //init FCLK=400M, so change MPLL first

     /*此函数在2440lib.c中定义。改变MPLLCON的值，MPLL的值影响FCLK。

     但是设置MPLL，在2440init.s已经完成了，也是FCLK=400Mhz*/

     ChangeMPllValue((mpll_val>>)&0xff, (mpll_val>>)&0x3f, mpll_val&);

     /*设置MPLLCON后，得到FCLK的值。再设置CLKDIVN，得到HCLK、PCLK的值此函数在2440lib.c中定义。使得FCLK:HCLK:PCLK=1:4:8。如果FCLK:HCLK!=1:1，还要执行，
        MMU_SetAsyncBusMode()。同2440init.s一样*/

     ChangeClockDivider(key, );

    //计算FCLK、HCLK、PCLK、UCLK、cpu_freq

     cal_cpu_bus_clk();

     consoleNum = ;    // Uart 1 select for debug.

     //UART初始化。此函数定义在2440lib.c

     Uart_Init( , );

     /*S3C2440共有三个UART。在2440lib.c的静态变量whichUart=consoleNum。在此选择UART0*/

     Uart_Select( consoleNum );

    //蜂鸣声

     Beep(, );

    // 发送字节的函数

     Uart_SendByte(‘\n’);

    // 显示字符串的函数

     Uart_Printf(“<***************************************>\n”);

     Uart_Printf(“               TQ2440 Test Program\n”);

     Uart_Printf(“                www.embedsky.net\n”);

 //    Uart_Printf(“      Build time is: %s  %s\n”, __DATE__ , __TIME__  );

     Uart_Printf(“<***************************************>\n”);

   /*指针变量，本质上是一个变量，只是它是存放地址的变量，指针的类型代表的是它所指向的变量的类型。因此就有了指向整型、字符型、浮点型等其他类型的指针，但实际上所有类型的
 69     指针变量存放的都是int型的地址。因此从本质上不同类型的指针变量并没有区别。到底声明不同类型的指针变量的背后是什么？其实声明不同类型的指针变量即是规定了该变量结合指针
 70     运算符时读取内存中的字节数，同样在指针移动和指针的运算（加、减），在内存中移动的最小字节数。rMISCCR在2440addr中定义。

     其原型为 #define rMISCCR (*(volatile unsigned *)0×56000080)。0×56000080为寄存器MISCCR的地址值。

     *(volatile unsigned *)0×56000080 含义：因为()优先级高于*，所以先执行(volatile unsigned *)0×56000080 这个表示将0×56000080强制转化为指针类型，指针指向的
 74     类型是unsigned，指针存放的地址为0×56000080。也就是说指针指向寄存器MISCCR。然后在执行()外面的*，表示取出指针所指向的值。整个表达式，就是取出寄存器MISCCR中存放
 75     的值。但rMISCCR的值改变，寄存器MISCCR中的值也随着改变。清零MISCCR[3]，即use USB1 as device*/

     rMISCCR=rMISCCR&~(<<); // USBD is selected instead of USBH1

     //清零MISCCR[13],即USB port1 suspend mode=normal mode

     rMISCCR=rMISCCR&~(<<); // USB port 1 is enabled.

     rDSC0 = 0x2aa;

     rDSC1 = 0x2aaaaaaa;

     //Enable NAND, USBD, PWM TImer, UART0,1 and GPIO clock,

     //the others must be enabled in OS!!!

     rCLKCON = 0xfffff0;

    //内存存储管理。裸奔暂时用不上

    MMU_Init();    //

     ISR_STARTADDRESS=0x33ff_ff00

    // 将值（0x33ff_ff00+0xf0）的值，载入到pISR_SWI的地址中（0x33ff_ff00+0×8）

     pISR_SWI=(_ISR_STARTADDRESS+0xf0);    //for pSOS

     GPB5=nLED1，GPB6=nLED2，GPB7=nLED3，GPB8=nLED4

    // LED2、3亮

     Led_Display(×);

     mode=”DMA”;

     //将GPH9设置为input，其值为10时，管脚功能是CLKOUT0

     Clk0_Disable();

    // 将GPH10设置为input，其值为10时，管脚功能是CLKOUT1

     Clk1_Disable();

     mpll_val = rMPLLCON;

     Lcd_TFT_Init() ;        // LCD initial

     download_run=; //The default menu is the Download & Run mode.

     while()

     {

         U8 idx;

         Uart_Printf(“\nPlease select function : \n”);

         for(i=; CmdTip[i].fun!=; i++)

             Uart_Printf(“%d : %s\n”, i, CmdTip[i].tip);

         idx = Uart_GetIntNum_GJ() ;

         if(idx<i)

         {

             (*CmdTip[idx].fun)();

             Delay();

             Uart_Init( , );

         }

     }         

 }

 void Isr_Init(void)

 {

     /*pISR_UNDEF在2440addr.h中定义。

 4     _ISR_STARTADDRESS在option.h中定义。_ISR_STARTADDRESS=0x33ff_ff00*/

     #define pISR_UNDEF (*(unsigned *)(_ISR_STARTADDRESS+0×4))//取出UNDEF中断服务程序地址中的内容

 6     //(unsigned)HaltUndef中HaltUndef为函数名，其代表函数的入口地址。

 7     //这条语句的意思就是将HaltUndef函数的入口地址放到UNDEF中断程序服务地址中。

     pISR_UNDEF=(unsigned)HaltUndef;

     pISR_SWI  =(unsigned)HaltSwi;

     pISR_PABORT=(unsigned)HaltPabort;

     pISR_DABORT=(unsigned)HaltDabort;

     //所有的中断都设置为IRQ模式

     rINTMOD=×;      // All=IRQ mode

     BIT_ALLMSK=0xffff_ffff//在2440addr.h中定义

     //屏蔽所有的中断的请求，这些中断就是INTMOD中的那些中断

     rINTMSK=BIT_ALLMSK;      // All interrupt is masked.

 }

 void HaltUndef(void)

 {

     Uart_Printf(“Undefined instruction exception!!!\n”);

     while();

 }

 void HaltSwi(void)

 {

     Uart_Printf(“SWI exception!!!\n”);

     while();

 }

 void HaltPabort(void)

 {

     Uart_Printf(“Pabort exception!!!\n”);

     while();

 }

 void HaltDabort(void)

 {

     Uart_Printf(“Dabort exception!!!\n”);

     while();

 }

 void ClearMemory(void)

 {

     int memError=;

     U32 *pt;

     Uart_Printf(“Clear Memory (%xh-%xh):WR”,_RAM_STARTADDRESS,HEAPEND);

     pt=(U32 *)_RAM_STARTADDRESS;

     while((U32)pt < HEAPEND)

     {

         *pt=(U32)×;

         pt++;

     }

     if(memError==)Uart_Printf(“\b\bO.K.\n”);

 }

 void Clk0_Enable(int clock_sel)

 {    // 0:MPLLin, 1:UPLL, 2:FCLK, 3:HCLK, 4:PCLK, 5:DCLK0

     rMISCCR = rMISCCR&~(<<) | (clock_sel<<);

     rGPHCON = rGPHCON&~(<<) | (<<);

 }

 void Clk1_Enable(int clock_sel)

 {    // 0:MPLLout, 1:UPLL, 2:RTC, 3:HCLK, 4:PCLK, 5:DCLK1

     rMISCCR = rMISCCR&~(<<) | (clock_sel<<);

     rGPHCON = rGPHCON&~(<<) | (<<);

 }

 void Clk0_Disable(void)

 {

     rGPHCON = rGPHCON&~(<<);    // GPH9 Input

 }

 void Clk1_Disable(void)

 {

     rGPHCON = rGPHCON&~(<<);    // GPH10 Input

 }