ARM9代码分析启动MAIN.C

  1 #define    GLOBAL_CLK        1

  2 

  3 #include

  4 #include

  5 #include “def.h”

  6 #include “option.h”

  7 #include “2440addr.h”

  8 #include “2440lib.h”

  9 #include “2440slib.h”

 10 #include “mmu.h”

 11 #include “profile.h”

 12 #include “memtest.h”

 13 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 28  

 29 void Isr_Init(void);

 30 void HaltUndef(void);

 31 void HaltSwi(void);

 32 void HaltPabort(void);

 33 void HaltDabort(void);

 34 void ClearMemory(void);

 35 

 36 void Clk0_Enable(int clock_sel);   

 37 void Clk1_Enable(int clock_sel);

 38 void Clk0_Disable(void);

 39 void Clk1_Disable(void);

 40 

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

 42 extern void Lcd_TFT_Init(void);

 43 extern void Lcd_TFT_Test( void ) ;

 44 extern void Test_Touchpanel(void) ;

 45 extern void Test_Adc(void) ;

 46 extern void KeyScan_Test(void) ;

 47 extern void RTC_Display(void) ;

 48 extern void Test_IrDA_Tx(void) ;

 49 extern void PlayMusicTest(void) ;

 50 extern void RecordTest( void ) ;

 51 extern void Test_Iic(void) ;

 52 extern void Test_SDI(void) ;

 53 extern void Camera_Test( void ) ;

 54 

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

 56 volatile U32 downloadAddress;

 57 

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

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

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

 61 

 62 volatile unsigned char *downPt;

 63 volatile U32 downloadFileSize;

 64 volatile U16 checkSum;

 65 volatile unsigned int err=0;

 66 volatile U32 totalDmaCount;

 67 

 68 volatile int isUsbdSetConfiguration;

 69 

 70 int download_run=0;

 71 U32 tempDownloadAddress;

 72 int menuUsed=0;

 73 

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

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

 76 int consoleNum;

 77 

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

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

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

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

 82 static U32 cpu_freq;

 83 static U32 UPLL;

 84 

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

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

 87 static void cal_cpu_bus_clk(void)

 88 {

 89     U32 val;

 90     U8 m, p, s;

 91     val = rMPLLCON;

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

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

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

 95 

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

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

 98     (1<

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

100     FCLK = ((m+8)*(FIN/100)*2)/((p+2)*(1<

101     val = rCLKDIVN;

102     m = (val>>1)&3;//m=2=HDIVN

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

104     val = rCAMDIVN;

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

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

107     s = val>>8;

108     switch (m) {

109     case 0:

110         HCLK = FCLK;

111         break;

112     case 1:

113         HCLK = FCLK>>1;

114         break;

115     case 2:

116         if(s&2)

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

118             HCLK = FCLK>>3;

119         else

120             HCLK = FCLK>>2;

121         break;

122     case 3:

123         if(s&1)

124             HCLK = FCLK/6;

125         else

126             HCLK = FCLK/3;

127         break;

128     }

129     if(p)

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

131         PCLK = HCLK>>1;

132     else

133         PCLK = HCLK;

134     if(s&0×10)

135         cpu_freq = HCLK;

136     else

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

138         cpu_freq = FCLK;

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

140     val = rUPLLCON;

141     m=56=MDIV

142     m = (val>>12)&0xff;

143     p=2=PDIV

144     p = (val>>4)&0x3f;

145     s=2=SDIV

146     s = val&3;

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

148     UPLL = ((m+8)*FIN)/((p+2)*(1<

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

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

151     UCLK = (rCLKDIVN&8)?(UPLL>>1):UPLL;

152 }

153 

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

155 

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

157     结构体成员：

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

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

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

161 struct {

162     void (*fun)(void);

163     char *tip;

164 }CmdTip[] = {

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

166                 { BUZZER_PWM_Test, “Test PWM” } ,

167                 { RTC_Display, “RTC time display” } ,

168                 { Test_Adc, “Test ADC” } ,

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

170                 { Test_Touchpanel, “Test Touchpanel” } ,

171                 { Lcd_TFT_Test, “Test TFT LCD” } ,

172                 { Test_Iic, “Test IIC EEPROM” } ,

173                 { PlayMusicTest, “UDA1341 play music” } ,

174                 { RecordTest, “UDA1341 record voice” } ,

175                 { Test_SDI, “Test SD Card” } ,

176                 { Camera_Test, “Test CMOS Camera”},

177                 { 0, 0}                       

178             };

  1 void Main(void)

  2 {

  3     char *mode;

  4     int i;

  5     U8 key;

  6     U32 mpll_val = 0 ;

  7     //U32 divn_upll = 0 ;

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

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

 10     #if ADS10  

 11 //    __rt_lib_init(); //for ADS 1.0

 12     #endif

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

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

 15     Port_Init();

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

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

 18     Isr_Init();

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

 20     switch ( i ) {

 21     case 0:    //200

 22         key = 12;

 23         mpll_val = (92<<12)|(4<<4)|(1);

 24         break;

 25     case 1:    //300

 26         key = 13;

 27         mpll_val = (67<<12)|(1<<4)|(1);

 28         break;

 29     case 2:    //400

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

 31         key = 14;

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

 33         mpll_val = (92<<12)|(1<<4)|(1);

 34         break;

 35     case 3:    //440!!!

 36         key = 14;

 37         mpll_val = (102<<12)|(1<<4)|(1);

 38         break;

 39     default:

 40         key = 14;

 41         mpll_val = (92<<12)|(1<<4)|(1);

 42         break;

 43     }

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

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

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

 47     ChangeMPllValue((mpll_val>>12)&0xff, (mpll_val>>4)&0x3f, mpll_val&3);

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

        MMU_SetAsyncBusMode()。同2440init.s一样*/

 49     ChangeClockDivider(key, 12);

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

 51     cal_cpu_bus_clk();

 52     consoleNum = 0;    // Uart 1 select for debug.

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

 54     Uart_Init( 0,115200 );

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

 56     Uart_Select( consoleNum );

 57    //蜂鸣声

 58     Beep(2000, 100);

 59    // 发送字节的函数

 60     Uart_SendByte(‘\n’);

 61    // 显示字符串的函数

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

 63     Uart_Printf(“               TQ2440 Test Program\n”);

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

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

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

 67 

 68   /*指针变量，本质上是一个变量，只是它是存放地址的变量，指针的类型代表的是它所指向的变量的类型。因此就有了指向整型、字符型、浮点型等其他类型的指针，但实际上所有类型的

 69     指针变量存放的都是int型的地址。因此从本质上不同类型的指针变量并没有区别。到底声明不同类型的指针变量的背后是什么？其实声明不同类型的指针变量即是规定了该变量结合指针

 70     运算符时读取内存中的字节数，同样在指针移动和指针的运算（加、减），在内存中移动的最小字节数。rMISCCR在2440addr中定义。

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

 73     *(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*/

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

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

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

 79 

 80     rDSC0 = 0x2aa;

 81     rDSC1 = 0x2aaaaaaa;

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

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

 84     rCLKCON = 0xfffff0;

 85 

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

 87    MMU_Init();    //

 88 

 89     ISR_STARTADDRESS=0x33ff_ff00

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

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

 92 

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

 94    // LED2、3亮   

 95     Led_Display(0×66);

 96 

 97     mode=”DMA”;

 98 

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

100     Clk0_Disable();

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

102     Clk1_Disable();

103     mpll_val = rMPLLCON;

104 

105     Lcd_TFT_Init() ;        // LCD initial

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

107 

108     while(1)

109     {

110         U8 idx;

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

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

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

114         idx = Uart_GetIntNum_GJ() ;   

115         if(idx

116         {

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

118             Delay(20);

119             Uart_Init( 0,115200 );

120         }   

121     }         

122 

123 }

 1 void Isr_Init(void)

 2 {

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

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

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

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

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

 8     pISR_UNDEF=(unsigned)HaltUndef;

 9     pISR_SWI  =(unsigned)HaltSwi;

10     pISR_PABORT=(unsigned)HaltPabort;

11     pISR_DABORT=(unsigned)HaltDabort;

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

13     rINTMOD=0×0;      // All=IRQ mode

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

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

16     rINTMSK=BIT_ALLMSK;      // All interrupt is masked.

17 }

18 

19 void HaltUndef(void)

20 {

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

22     while(1);

23 }

24 

25 void HaltSwi(void)

26 {

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

28     while(1);

29 }

30 

31 void HaltPabort(void)

32 {

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

34     while(1);

35 }

36 

37 void HaltDabort(void)

38 {

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

40     while(1);

41 }

42 

43 void ClearMemory(void)

44 {

45     int memError=0;

46     U32 *pt;

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

48 

49     pt=(U32 *)_RAM_STARTADDRESS;

50     while((U32)pt < HEAPEND)

51     {

52         *pt=(U32)0×0;

53         pt++;

54     }

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

56 }

57 

58 void Clk0_Enable(int clock_sel)   

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

60     rMISCCR = rMISCCR&~(7<<4) | (clock_sel<<4);

61     rGPHCON = rGPHCON&~(3<<18) | (2<<18);

62 }

63 void Clk1_Enable(int clock_sel)

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

65     rMISCCR = rMISCCR&~(7<<8) | (clock_sel<<8);

66     rGPHCON = rGPHCON&~(3<<20) | (2<<20);

67 }

68 void Clk0_Disable(void)

69 {

70     rGPHCON = rGPHCON&~(3<<18);    // GPH9 Input

71 }

72 void Clk1_Disable(void)

73 {

74     rGPHCON = rGPHCON&~(3<<20);    // GPH10 Input

75 }