watchdog做复位用-裸机驱动程序

//本实验主要实验 看门狗定时 复位用的功能
2440init.h文件

#ifndef _2440INIT_H_
#define _2440INIT_H_

/* WATCHDOG寄存器 */
#define WTCON (*(volatile unsigned long *)0x53000000)
/* SDRAM寄存器 */
#define     MEM_CTL_BASE        0x48000000


/*系统时钟相关寄存器*/
#define    MPLLCON        (*(volatile unsigned long *)0x4c000004)
#define    CLKDIVN        (*(volatile unsigned long *)0x4c000014)
#define S3C2440_MPLL_200MHZ ((0x5c<<12)|(0x01<<4)|(0x02))


/**************************************************************************/
//中断相关寄存器
#define EXTINT0 (*(volatile unsigned long *)0x56000088)
#define EINTMASK (*(volatile unsigned long *)0x560000A4)
#define EINTPEND (*(volatile unsigned long *)0x560000A8)

#define SRCPND (*(volatile unsigned long *)0x4A000000)
#define INTMOD (*(volatile unsigned long *)0x4A000004)
#define INTMSK (*(volatile unsigned long *)0x4A000008)
#define PRIORITY (*(volatile unsigned long *)0x4A00000C)
#define INTPND (*(volatile unsigned long *)0x4A000010)
#define INTOFFSET (*(volatile unsigned long *)0x4A000014)

#define SUBSRCPND (*(volatile unsigned long *)0x4A000018)
#define INTSUBMSK (*(volatile unsigned long *)0x4A00001C)
/**************************************************************************/

/**************************************************************************/
//看门狗相关寄存器
#define WTCON (*(volatile unsigned long *)0x53000000)
#define WTDAT (*(volatile unsigned long *)0x53000004)
#define WTCNT (*(volatile unsigned long *)0x53000008)

#define SRCPND (*(volatile unsigned long *)0x4A000000)
#define INTMOD (*(volatile unsigned long *)0x4A000004)
#define INTMSK (*(volatile unsigned long *)0x4A000008)
#define PRIORITY (*(volatile unsigned long *)0x4A00000C)
#define INTPND (*(volatile unsigned long *)0x4A000010)
#define INTOFFSET (*(volatile unsigned long *)0x4A000014)

#define SUBSRCPND (*(volatile unsigned long *)0x4A000018)
#define INTSUBMSK (*(volatile unsigned long *)0x4A00001C)
/**************************************************************************/

/**************************************************************************/
//按键相关的GPIO
#define GPFCON (*(volatile unsigned long *)0x56000050)
#define GPFDAT (*(volatile unsigned long *)0x56000054)
#define GPFUP (*(volatile unsigned long *)0x56000058)
/*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

#define GPF0_EINT (2<<(0*2))
#define GPF1_EINT (2<<(1*2))
#define GPF2_EINT (2<<(2*2))
#define GPF4_EINT (2<<(4*2))
/**************************************************************************/

/**************************************************************************/
//LED相关的GPIO
#define GPBDAT (*(volatile unsigned long *)0x56000014)
#define GPBCON (*(volatile unsigned long *)0x56000010)
#define GPBUP (*(volatile unsigned long *)0x56000018)
/*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

#define GPB5_OUT (1<<(5*2))
#define GPB6_OUT (1<<(6*2))
#define GPB7_OUT (1<<(7*2))
#define GPB8_OUT (1<<(8*2))

#define GPB5_ON (~(1<<5))
#define GPB6_ON (~(1<<6))
#define GPB7_ON (~(1<<7))
#define GPB8_ON (~(1<<8))

#define GPB5_OFF (1<<5)
#define GPB6_OFF (1<<6)
#define GPB7_OFF (1<<7)
#define GPB8_OFF (1<<8)
/**************************************************************************/


/**************************************************************************/
//串口相关寄存器
#define rULCON0 (*(volatile unsigned *)0x50000000)
#define rUCON0 (*(volatile unsigned *)0x50000004)
#define rUFCON0 (*(volatile unsigned *)0x50000008)
#define rUMCON0 (*(volatile unsigned *)0x5000000c)
#define rUTRSTAT0 (*(volatile unsigned *)0x50000010)
#define rUBRDIV0 (*(volatile unsigned *)0x50000028)

#define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
#define RdURXH0() (*(volatile unsigned char *)0x50000024)

#define rGPHCON (*(volatile unsigned *)0x56000070)
#define rGPHUP (*(volatile unsigned *)0x56000078)

#define PCLK            50000000 // init.c中的clock_init函数设置PCLK为50MHz
#define UART_CLK        PCLK // UART0的时钟源设为PCLK
#define UART_BAUD_RATE  115200 // 波特率
#define UART_BRD ((UART_CLK / (UART_BAUD_RATE * 16)) - 1)

void init_uart(void);
void uart_sendByte(int data);
void uart_sendString(char *p);
void uart_sendByte_hex(unsigned long val);
char uart_getch(void);
void uart_getString(char *string);
/**************************************************************************/

void disable_watch_dog();
void memsetup();
void clock_init(void);
void init_led();
void init_irq();

#endif

init.c文件

#include "2440init.h"

/*
 * 功能：初始化watchdog相关寄存器
 * 注意：watchdog是内部2级中断
 */
void init_watchdog()
{
    //2级源挂起寄存器：第13位是表示看门狗中断发生的
    SUBSRCPND |= (1<<13);

    //源挂起寄存器：第9位是表示看门狗中断发生的
    SRCPND |= (1<<9);
    INTPND |= (1<<9);

    //2级中断屏蔽寄存器：第13位是表示看门狗中断使能
    INTSUBMSK &= ~(1<<13);
    INTMSK &= ~(1<<9);

    /*看门狗控制寄存器 ：WTCON
    *[15:8]=0x60，预分频系数
    *[5] 0：看门狗停止 1：看门狗启动
    *[4:3]=(11)b 分频系数：0b00：16，0b01：32,0b10：64,0b11:128
    *[2]=0：禁止中断，1：使能中断
    *[0]=1：当定时器达到0时输出复位信号 0：当定时器达到0时不输出复位信号
    *看门狗的工作频率       f_dog = PCLK/((预分频系数+1)*分频系数)
    *WTCNT每减1所消耗的时间 t_dog = 1/f_dog
    */
    WTCON |= ((0x60 << 8) | (1<<3) | (1<<0));
    WTCON &= (~(1<<2));
    //上面的配置：将看门狗定时器做复位用的，需要不停的喂狗。

    /*看门狗控制数据寄存器 ：WTDAT 只有16位
    *决定看门狗的超时周期  即定时周期，定时时间  T = t_dog * WTDAT
    *在定时器启动后，当计数器达到0时，WTDAT的值会自动赋值给WTCNT。
    *但是，第一次启动看门狗时，WTDAT的值不会自动赋值给WTCNT，需要程序员自己赋值。
    */
    WTDAT = 0x6000;
    /*看门狗控制计数寄存器 ：WTCNT
    *第一次启动时，程序员必须手工向这个寄存器赋值。
    *之后，每次计数达到0，WTDAT的值会自动赋值给WTCNT。
    *看门狗启动之后，这个寄存器就开始自动减1.
    */
    WTCNT = 0x6000;

    //WTCON &= ~(1<<0); //不输出复位信号
    //WTCON |= (1<<2); //看门狗当做普通定时器时候，一般需要上面一行+这一行
    WTCON |= (1<<5); //一般把看门狗启动单独列出来，放在初始化程序的最后
}

/*
 * 功能：初始化按键相关的GPIO引脚为外部中断
 * 本程序：
 * K1 : EINT1，引脚是GPF1
 * K2 : EINT4，引脚是GPF4
 * K3 : EINT2，引脚是GPF2
 * K4 : EINT0，引脚是GPF0
 */
void init_irq()
{
      GPFCON = (GPF0_EINT | GPF1_EINT | GPF2_EINT | GPF4_EINT); /*设置这几个引脚为中断功能*/
    GPFUP = 0x00;

    EXTINT0 = 0x00; /*设置外部中断控制寄存器，低电平触发，默认也是0x00，所以这句可以不要*/

        /*设置外部中断屏蔽寄存器，EINT4~EINT24，共20个需要在这个寄存器中使能他们,
         *EINTMASK只能使能EINT4， EINT0,EINT1,EINT2,EINT3 不受EINTMASK控制
         *EINTMASK[4]:禁止/使能EINT4
         */
        EINTMASK &= (~(1<<4));

        /*设置模式寄存器 ：在IRQ模式中处理，默认也是0x00，所以这句可以不要*/
        INTMOD = 0x00;

        /*设置中断优先级寄存器
        *仲裁租0和6，优先级不轮换使能，每个仲裁组下优先级顺序：0-1-2-3-4-5-6,默认也是这个顺序
        *最终按键产生中断的优先级顺序：K4(EINT0) > K1(EINT1) > K3(EINT2) > K2(EINT4)
        */
        PRIORITY &= (~(1<<0)) & (~(1<<6)) ;

        /*设置中断屏蔽寄存器，一级中断
        *INTMSK[0]:禁止/使能EINT0
        *INTMSK[1]:禁止/使能EINT1
        *INTMSK[2]:禁止/使能EINT2
        *INTMSK[4]:禁止/使能EINT4~EINT7
        */
        INTMSK &= (~(1<<0)) & (~(1<<1)) & (~(1<<2)) & (~(1<<4)); /*其实到这里，中断仍未完全开启，CPSR的I位还要清0*/
}

/*
 * 功能：初始化LED的GPIO引脚
 */
void init_led()
{
      GPBCON = (GPB5_OUT | GPB6_OUT | GPB7_OUT | GPB8_OUT);
    GPBUP = 0x1e0;
    GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
}

/*
 * 对于MPLLCON寄存器，[19:12]为MDIV，[9:4]为PDIV，[1:0]为SDIV
 * 有如下计算公式：
 * S3C2440: MPLL(FCLK) = (2 * m * Fin)/(p * 2^s)
 * 其中: m = MDIV + 8 = 92+8, p = PDIV + 2 = 1+2, s = SDIV = 2
 * 对于本开发板，Fin = 12MHz
 * 设置CLKDIVN，令分频比为：FCLK:HCLK:PCLK=1:2:4，
 * FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
 */
void clock_init(void)
{
    // LOCKTIME = 0x00ffffff; // 使用默认值即可
    CLKDIVN = 0x03; // FCLK:HCLK:PCLK=1:2:4, HDIVN=1,PDIVN=1
    /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */
__asm__(
    "mrc    p15, 0, r1, c1, c0, 0\n" /* 读出控制寄存器 */
    "orr    r1, r1, #0xc0000000\n" /* 设置为“asynchronous bus mode” */
    "mcr    p15, 0, r1, c1, c0, 0\n" /* 写入控制寄存器 */
    );

    MPLLCON = S3C2440_MPLL_200MHZ;
    /* 现在，FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
    并不保证你的任何设置都是合适的。所以，如果想要工作在200MHz，还是按照vivi的推荐值((0x5c<<12)|(0x01<<4)|(0x02))即可。
    */
}
/*
 * 关闭WATCHDOG，否则CPU会不断重启
 */
void disable_watch_dog(void)
{
    WTCON = 0; // 关闭WATCHDOG很简单，往这个寄存器写0即可
}

/*
*功能：设置存储控制器以使用SDRAM
*注意：REFRESH寄存器有特殊
* 未开启PLL时：HCLK=12MHz: REFRESH寄存器值取： 0x008C07A3,
* 开启PLL时：HCLK=100MHz: REFRESH寄存器值取： 0x008C04F4
*/
void memsetup(void)
{
    /* SDRAM 13个寄存器的值 */
    unsigned long const mem_cfg_val[]={ 0x22011110, //BWSCON
                                            0x00000700, //BANKCON0
                                            0x00000700, //BANKCON1
                                            0x00000700, //BANKCON2
                                            0x00000700, //BANKCON3
                                            0x00000700, //BANKCON4
                                            0x00000700, //BANKCON5
                                            0x00018005, //BANKCON6
                                            0x00018005, //BANKCON7
                                            0x008C04F4, //REFRESH
                                            0x000000B1, //BANKSIZE
                                            0x00000030, //MRSRB6
                                            0x00000030, //MRSRB7
                                    };
    int i = 0;
    volatile unsigned long *p = (volatile unsigned long *)MEM_CTL_BASE;
    for(; i < 13; i++)
        p[i] = mem_cfg_val[i];
}









/***********************************************************************************/
//串口相关函数
/*功能：初始化串口UART0
*轮询方式来使用串口
*/
void init_uart(void)
{
     /*GPHCON寄存器
    [7:6]=10,GPH2作为TXD0,串口发送数据引脚
    [5:4]=10,GPH3作为RXD0,串口接受数据引脚
    GPH2，GPH3控制串口通道0
    GPH4，GPH5控制串口通道1
    GPH6，GPH7控制串口通道2
    */
        rGPHCON = ((2<<6)|(2<<4)|(0<<2)|(0<<0));
        rGPHUP = ((1<<3)|(1<<2)); /*禁止上拉*/

        /*ULCON0串口线路控制寄存器:设置传输格式
        [6]=0，普通模式，非红外工作模式
        [5:3]=000，无奇偶校验位，100=奇校验，101=偶校验，110=固定校验位为1，111=固定校验位为0
        [2]=0，每帧1个停止位，1：每帧2个停止位
        [1:0]=11，8位，每帧发送或接受的数据位的个数。00=5位，01=6位，10=7位
        */
        rULCON0 = 0x3;

        /*UCON0:串口控制寄存器：用于选择UART时钟源，设置UART中断方式
        [15:12]: 当[11:10]选择PCLK时，这4位无效。选择FCLK/n时，表示n值。
        [11:10]=00: 选择PCLK给UART比特率，10：PCLK, 01：UEXTCLK, 11:FCLK/n。
        [9]=1: 中断请求类型
        [8]=0: 中断请求类型
        [7]=0: 禁止超时中断，1：使能超时中断
        [6]=1: 产生接受错误状态中断，1：不产生接受错误状态中断
        [5]=0: 正常操作，非回环模式。发送引脚发送的数据，直接到达接受引脚，一般是测试用。
        [4]=0: 正常操作，不发送断电信号
        [3:2]=01: 发送模式，中断或者轮询,如果中断寄存器不设置，就是轮询。
        [1:0]=01: 接受模式，中断或者轮询
        */
        rUCON0 = 0x5;

        /*UFCON:串口FIFO控制寄存器：用于设置是否使用FIFO,设置各FIFO的触发阀值。
        [7:6]=发送FIFO的触发深度，即在发送时，发送FIFO中还剩有多少个数据时，才触发中断，告诉CPU可以继续发送了。
        [5:4]=接受FIFO的触发深度，即在接受时，接受FIFO中接受了多少个数据后，才触发中断，告诉CPU已经有接受到的数据了。
        [3]=空
        [2]=TX的FIFO是否复位
        [1]=RX的FIFO是否复位
        [0]=0,不使用FIFO，非FIFO模式，相当于接受和发送时，不使用缓冲寄存器,上面的设置无效。如果这里是1，则上面的位肯定有对应的设置。
        */
        rUFCON0 = 0x0;

        /*UMCON:串口MODEM控制寄存器：用于流量控制
        [7:5]=000,规定必须为0
        [4]=0:禁止自动流控制(AFC)，即不使用流控。一般不使用这种硬件自动流控制手段。
        [3:1]=000:规定必须为0
        [0]=0:高电平(撤销nRTS),1:低电平(激活nRTS),因为,AFC位禁止,nRTS必须由软件控制。如果AFC使能，则忽略这个位。
        */
        rUMCON0 = 0x0;

        /*UBRDIV:波特率分频寄存器：用于设置波特率
        [15:0],波特率分频值。使用UEXTCLK作为输入时钟时，可以设置UBRDIV为0.
        UBRDIV = (int)(UART时钟/(波特率*16))-1
        */
        rUBRDIV0 = UART_BRD;
}

/*功能：向串口发送一个字符
*参数：待发送的字符

UTRSTAT0:用来表明数据是否已经发送完毕，是否已经接受到数据
串口收发TX/RX状态寄存器，是CPU自动更新的，程序员检测它的状态就行。
[2]:发送移位寄存器空标志。
检测为0：表示发送移位寄存器非空，或发送缓冲寄存器非空。
检测为1：表示发送移位寄存器为空，且发送缓冲寄存器为空，程序员可以继续发送数据了。
[1]:发送缓冲区空标志位。
检测为0：表示发送缓冲寄存器非空，即上次要发送的数据还没有发完。不能太快，否则会覆盖掉。
检测为1：表示发送缓冲寄存器为空，程序员可以继续发送数据了。(非FIFO模式，非请求中断，非DMA)
注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。
[0]:接收缓冲器数据就绪标志位。
检测为0：表示接收缓冲器为空。
检测为1：表示接收缓冲器接收到有效数据，程序员可以取数据了。(非FIFO模式，非请求中断，非DMA)
注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

UTXH0：串口发送缓冲寄存器
[7:0]:串口要发送的数据
*/
void uart_sendByte(int data)
{
    if(data == '\n')
    {
        while(!(rUTRSTAT0 &0x2));
        WrUTXH0('\r'); /*回车不换行*/
    }
    /*等待，直到发送缓冲区中的数据已经全部发送出去
    这里也可以检测UTRSTAT0[2]位*/
    while(!(rUTRSTAT0 &0x2));
    /*向UTXH0寄存器中写入数据，UART即自动将它发送出去
    #define rUTXH0 (*(volatile unsigned char *)0x50000020)    //UART 0 Transmission Hold
    #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
    所以：WrUTXH0(data); 相当于 rUTXH0 = data；
    */
    WrUTXH0(data);
}

/*功能：向串口打印一个字符串
*参数：待打印的字符串
*/
void uart_sendString(char *p)
{
    while(*p)
        uart_sendByte(*p++);
}

/*功能：向串口打印一个字符的16进制格式
*参数：待打印的字符
* 数字0=0x30，数字9=0x39
*/
void uart_sendByte_hex(unsigned long val)
{
    /* val = 0x1234ABCD */
    unsigned char c;
    int i = 0;

    uart_sendByte('0');
    uart_sendByte('x');

    for (i = 0; i < 8; i++)
    {
        c = (val >> ((7-i)*4)) & 0xf;
        if((c >= 0) && (c <= 9))
        {
            c = '0' + c;
        }
        else if ((c >= 0xA) && (c <= 0xF))
        {
            c = 'A' + (c - 0xA);
        }
        uart_sendByte(c);
    }
}

/*功能：向串口格式化打印一个字符串
*参数：格式化的字符串
这个函数编译不过去，不知道什么原因？？？？？？？？？？？？？
void uart_printf(char* fmt,...)
{
    va_list args; //动态参数列表
    char string[256];

    va_start(args,fmt);
    vsprintf(string,fmt, args);
    uart_sendString(string);
    va_end(args);
}
*/

/*功能：从串口接受一个字符
*返回值：接受到的字符

UTRSTAT0: 串口收发TX/RX状态寄存器
[0]:接收缓冲器数据就绪标志位。
0：接收缓冲器为空
1：接收缓冲器接收到有效数据(非FIFO模式，非请求中断，非DMA)
注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

URXH0：串口接受缓冲寄存器
[7:0]:串口接受到的数据
*/
char uart_getch(void)
{
    /*等待，直到接受缓冲区中有数据*/
    while(!(rUTRSTAT0 & 0x1));
    /*直接读取URXH0寄存器，即可以获得接受到的数据
    #define rURXH0 (*(volatile unsigned char *)0x50000024)    //UART 0 Receive buffer
    #define RdURXH0() (*(volatile unsigned char *)0x50000024)
    所以：return RdURXH0(); 相当于：return rURXH0；
    */
    return RdURXH0();
}

/*功能：从串口接受一个字符串
*参数：输入的字符串
*/
void uart_getString(char *string)
{
    char *string2 = string;
    char c;
    while((c=uart_getch()) != '\r')
    {
        if(c == '\b')
        {
            if((int)string2 < (int)string)
            {
                //uart_printf("\b\b");
                string--;
            }
        }
        else
        {
            *string++ = c;
            uart_sendByte(c);
        }
    }
    *string = '\0';
    uart_sendByte('\n');
}
/***********************************************************************************/

interrupt.c文件

#include "2440init.h"

/*
*功能：中断服务子程序
*注意：1,按键产生中断的优先级顺序：K4(EINT0) > K1(EINT1) > K3(EINT2) > K2(EINT4)
* 所以，同时按下其中2个，3个或者4个，只有优先级最高的哪个LED会被点亮
* 2,如果硬件接线有LED连接了EINT4，EINT5，由于他们的中断优先级相同,EINTPEND[4:5]都是1，但都只会让SRCPND[4]=1,
* 如果他们同时按下，则INTPND[4]=1,且INTOFFSET=4,走到case 4，EINTPEND[4:5]=11b,2个if都成立，所以，最后这2个LED会被同时点亮。
*/
void EINT_Handle()
{
            /*INTOFFSET:中断偏移寄存器，INTPND寄存器中的值被置1之后，中断偏移寄存器的值=32个一级中断的编号*/
            unsigned long offset = INTOFFSET;
            unsigned long eintval;

            uart_sendString("\n\nINTOFFSET=");
            uart_sendByte_hex(offset);
            uart_sendByte('\n');

            switch(offset)
            {
                    /*EINT0中断：K4被按下*/
                    case 0:
                    {
                                uart_sendString("K4 ON!->LED4 ON!\n");
                                GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
                                GPBDAT = GPB8_ON; /*LED4亮*/
                                break;
                    }
                    /*EINT1中断：K1被按下*/
                    case 1:
                    {
                                uart_sendString("K1 ON!->LED1 ON!\n");
                                GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
                                GPBDAT = GPB5_ON; /*LED1亮*/
                                break;
                    }
                    /*EINT2中断：K3被按下*/
                    case 2:
                    {
                                uart_sendString("K3 ON!->LED3 ON!\n");
                                GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
                                GPBDAT = GPB7_ON; /*LED3亮*/
                                break;
                    }
                    /*EINT4~EINT7中断：虽然这里可以肯定是，EINT4，K2被按下,但是还是做一下判断：具体是EINT4到EINT7中的哪一个？*/
                    case 4:
                    {
                                GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);

                                /*EINTPEND:外部中断挂起寄存器
                                *EINTPEND低4位保留
                                *EINTPEND[4]=1 : 表示EINT4发生
                                *EINTPEND[5]=1 : 表示EINT5发生
                                */
                                eintval = EINTPEND;
                                if(eintval & (1<<4))
                                {
                                        uart_sendString("K2 ON!->LED2 ON!\n");
                                        GPBDAT = GPB6_ON; /*LED2亮*/
                                }
                                if(eintval & (1<<5))
                                {

                                }
                                break;
                    }
                    default:
                    {
                                break;
                    }
            }
            /*中断处理完成之后：必须清除所有的挂起寄存器
            *注意：向挂起寄存器中写1，即可令此位为0；写入0是没有效果的，若写入0，挂起寄存器中的数据保持不变。
            */
            if(offset == 4) /*二级外部中断，还必须清除 EINTPEND*/
            {
                     EINTPEND = (1<<4);
            }
            SRCPND = (1<<offset);
            uart_sendString("SRCPND=");
            uart_sendByte_hex(SRCPND);
            uart_sendByte('\n');

            INTPND = (1<<offset);
            uart_sendString("INTPND=");
            uart_sendByte_hex(SRCPND);
            uart_sendString("\n*************************************");
            /*在清除 SRCPND INTPND时，INTOFFSET会被自动清除*/
}

head.S文件

@********************************************************************************
@功能：初始化，设置中断模式，系统模式的栈，设置中断处理函数
@********************************************************************************
.text
.global _start
_start:

@设置异常向量表，本程序只使用2个异常
@复位 : Reset 地址：0x00
        b Reset

@未定义指令终止 : HandleUndef 地址：0x04
HandleUndef:
        b HandleUndef

@软件中断 : HandleSWI 地址：0x08
HandleSWI:
        b HandleSWI

@指令欲取指终止 : HandlePrefetchAbort 地址：0x0C
HandlePrefetchAbort:
        b HandlePrefetchAbort

@数据访问终止 : HandleDataAbort 地址：0x10
HandleDataAbort:
        b HandleDataAbort

@保留 : HandleNotUsed 地址：0x14
HandleNotUsed:
        b HandleNotUsed

@普通中断 : HandleIRQ 地址：0x18
        b HandleIRQ

@快速中断 : HandleFIQ 地址：0x1C
HandleFIQ:
        b HandleFIQ

@产生复位异常时，跳转到这里来
Reset:
        LDR SP, =4096                    @设置栈指针，下面调用的是c函数，调用前需要设好栈。复位时，cpu进去系统模式，所以是系统模式栈指针
        BL disable_watch_dog    @关看门狗
        BL memsetup                        @初始化SDRAM寄存器,这个程序在4K内跑，没有用到SDRAM，所以这里可以没有
        BL clock_init                    @设置系统时钟
        BL init_uart                    @初始化串口

        MSR cpsr_c, #0xD2            @进入IRQ模式，I位,F位置1：不开中断
        LDR SP, =3072                    @设置IRQ模式的栈指针，sp是sp_irq

        MSR cpsr_c, #0xDF            @进入sys模式，I位,F位置1：不开中断
        LDR SP, =4096                    @设置sys模式的栈指针，sp是sp_sys

        BL init_led                        @初始化LED的GPIO引脚
        BL init_irq                        @初始化外部中断相关的寄存器
        BL init_watchdog      @初始化看门狗相关的寄存器
        MSR cpsr_c, #0x5F            @设置 I位=0,F位=1：开IRQ中断,不开FIQ
        LDR LR, =my_loop            @设置Reset函数的返回地址
        LDR PC, =main                    @调用main函数

my_loop:
        B my_loop

@产生普通中断时，跳转到这里来
HandleIRQ:
        SUB LR, LR, #4              @计算中断处理完毕之后的返回地址
        STMDB  { r0-r12, LR }   @保存中断程序的运行环境，即保存使用到的寄存器，sp是中断模式的栈sp_irq

        LDR LR, =int_return         @设置EINT_Handle函数执行完后的返回地址
        LDR PC, =EINT_Handle        @调用IRQ中断服务函数
int_return:
        LDMIA  { r0-r12, PC }^  @中断返回，^表示将SPSR的值复制到CPSR
                                                                @上面这句：将恢复中断程序的运行环境。
                                                                @进入中断模式时，CPU自动将原来的CPSR值保存到SPSR中，这里会将SPSR的值复制到CPSR，这会导致CPU切换到原来的工作模式(即调用中断前的工作模式)

main.c文件

#include "2440init.h"

int main()
{
     //本实验主要实验 看门狗定时 复位用的功能
        uart_sendString("\n main begin: \n"); //如果这一句不停的打印出现，将表示系统一直在复位。
        while(1)
        {
            //喂狗：在WTCNT减少到0之前，即在定时时间到来之前，给下面2个寄存器赋值，否则定时时间到，系统将复位。
            //WTDAT = 0x6000;
            //WTCNT = 0x6000;
        }
        return 0;
}

makefile文件

objs := head.o init.o interrupt.o main.o

watchdog.bin: $(objs)
    arm-linux-ld -Ttext 0x00000000 -o watchdog_elf $^
    arm-linux-objcopy -O binary -S watchdog_elf $@
    arm-linux-objdump -D -m arm watchdog_elf > watchdog.dis

%.o:%.c
    arm-linux-gcc -Wall -O2 -c -o $@ $<

%.o:%.S
    arm-linux-gcc -Wall -O2 -c -o $@ $<

clean:
    rm -f watchdog.bin watchdog_elf watchdog.dis *.o