Mini2440裸机开发之中断控制器

set_svcmode:
    mrs  r0,cpsr               /* r0 = cpsr */ 
    bic  r0,r0,#0x1f           /* M[4:0]清0 */
    orr  r0,r0,#0xd3           /* 设置为SVC模式，并关闭fiq,irq中断 */
    msr  cpsr,r0               /* cpsr = r0 */
    mov  pc,lr                 /* bl指令将下一条指令地址复制到了lr,子程序返回  */ 

disable_interrupt:
        mvn  r1,#0x00              /*   取反赋值 r1 = 0xffffffff   */
        ldr  r0,=0X4A000008
        str  r1,[r0]                        /*   INTMASK每一位均写1  屏蔽中断 
        mov  pc,lr

    //K1,K2,K3,K4,K5,K6 对应的6根引脚设为中断功能
    GPGCON &= ~((0x03 << 0) | (0x03 << 6) | (0x03 << 10) | (0x03 << 12) | (0x03 << 14) | (0x03 << 22));            /* 清零 */
    GPGCON |= (0x02 << 0) | (0x02 << 6) | (0x02 << 10) | (0x02 << 12) | (0x02 << 14) | (0x02 << 22);   

// 对于EINT8,11,13,14,15,19，需要在EINTMASK寄存器中使能它 清零，中断使能
    EINTMASK &= ~((1 << 8) | (1 << 11) | (1 << 13) | (1 << 14)) | (1 << 15)) | (1 << 19));

     // EINT8~EINT23中断使能
    INTMSK &= ~BIT_EINT8_23;

 /*************************************************************
 *
 *  Function  : 初始化GPIO引脚为外部中断
 *              GPIO引脚用作外部中断时，默认为低电平触发、IRQ方式(不用设置INTMOD)
 *              K1        K2        K3        K4        K5        K6
 *        中断    EINT8    EINT11    EINT13    EINT14    EINT15    EINT19
 *    复用GPIO    GPG0    GPG3    GPG5    GPG6    GPG7    GPG11
 *
 **************************************************************/
void eint8_23_int_init()
{

    //K1,K2,K3,K4,K5,K6 对应的6根引脚设为中断功能
    GPGCON &= ~((0x03 << 0) | (0x03 << 6) | (0x03 << 10) | (0x03 << 12) | (0x03 << 14) | (0x03 << 22));            /* 清零 */
    GPGCON |= (0x02 << 0) | (0x02 << 6) | (0x02 << 10) | (0x02 << 12) | (0x02 << 14) | (0x02 << 22);               /* 设置为中断功能 */

    // 对于EINT8,11,13,14,15,19，需要在EINTMASK寄存器中使能它 清零，中断使能
    EINTMASK &= ~((1 << 8) | (1 << 11) | (1 << 13) | (1 << 14)) | (1 << 15)) | (1 << 19));

    /*
     * 看2440手册Figure 14-2. Priority Generating Block
     * EINT8~EINT23的优先级是一样的
     * 所以不用设置PRIORITY了
     */
     // EINT8~EINT23中断使能
    INTMSK &= ~BIT_EINT8_23;
}

void  vector_enable()
{
    __asm__(
      "mrs r0,cpsrn"                       /* r0 = cpsr */
      "bic r0,r0,#(0x01<<7 )n"             /* cpsr 的I位清零  */
      "msr cpsr_c,r0n"                     /* cpsr = r0 */
    );
}

            
/*************************************************************************
 *
 * Function   : 中断源5  外部中断8至23
 *              执行之前，必须先始化led
 *
 *************************************************************************/ 
void  EINT8_23_IRQHandler()
{
    if (EINTPEND & (1 << 8))
    {
        // K1被按下
        GPBDAT &= ~(1 << 5);      // LED1点亮
    }

    if (EINTPEND & (1 << 11))
    {
        // K2被按下
        GPBDAT &= ~(1 << 6);      // LED2点亮
    }

    if (EINTPEND & (1 << 13))
    {
        // K3被按下
        GPBDAT &= ~(1 << 7);      // LED3点亮
    }

    if (EINTPEND & (1 << 14))
    {
        // K4被按下
        GPBDAT &= ~(1 << 8);      // LED4点亮
    }

    if (EINTPEND & (1 << 15))
    {
        // K5被按下
        GPBDAT |= (0xF << 5);    // 所有LED熄灭
    }

    if (EINTPEND & (1 << 19))
    {
        // K6被按下
        GPBDAT &= ~(0xF << 5);      // 全部点亮
     }

    //清中断
    EINTPEND |= (1 << 8) | (1 << 11) | (1 << 13) | (1 << 14);          /* 清中断标志位  */

    SRCPND |= BIT_EINT8_23;                                            /* 清中断标志位  */
    INTPND |= BIT_EINT8_23;                                            /* 清中断标志位  */
}

    // 测试发现，这俩必须同时开启才生效
    INTSUBMSK &= ~BIT_SUB_RXD0;                /* 打开UART0接收中断，使能中断 */
    INTSUBMSK &= ~BIT_SUB_TXD0;                /* 打开UART0发送中断，使能中断 */

    INTMSK &= ~BIT_UART0;                      /* 关闭UART0中断屏蔽，总中断  */

void uart_int_init()
{
    SUBSRCPND |= BIT_SUB_RXD0 | BIT_SUB_TXD0 | BIT_SUB_ERR0;       /* 向相应位置写1清除次级源挂起寄存器 */
    SRCPND |= BIT_UART0;                                            /* 向相应位置写1清除源挂起寄存器 */
    INTPND |= BIT_UART0;                                            /* 向相应位置写1清除挂起寄存器 */

    // 测试发现，这俩必须同时开启才生效
    INTSUBMSK &= ~BIT_SUB_RXD0;                /* 打开UART0接收中断，使能中断 */
    INTSUBMSK &= ~BIT_SUB_TXD0;                /* 打开UART0发送中断，使能中断 */
    INTMSK &= ~BIT_UART0;                      /* 关闭UART0中断屏蔽，总中断  */
}

void  vector_enable()
{
    __asm__(
      "mrs r0,cpsrn"                       /* r0 = cpsr */
      "bic r0,r0,#(0x01<<7 )n"             /* cpsr 的I位清零  */
      "msr cpsr_c,r0n"                     /* cpsr = r0 */
    );
}

u16  UART0_RX_STA = 0;         /* 自定义接收状态寄存器 */

/*************************************************************************************************
 *
 *       UARTx_RX_BUF[UART_RX_LEN]:保存接收到的数据
 *     UARTx_RX_STA             :自定义16位接收状态寄存器
                                   bit15            bit14              bit13~0
                                   接收完成标志位     接收到0x0D标志位   接收到有效数据的个数
                                   当接收到Enter(Enter由两个字节组成，回车符0x0D和换行符0x0A)时，
 *
 **************************************************************************************************/
u8 UART0_RX_BUF[UART_RX_LEN] = { 0 };        /* 接收缓冲区 */

/*************************************************************************
 *
 * Function   : 中断源28   UART0 interrupt
 *              当接收到回车(回车由两个字节组成，回车符0x0D和换行符0x0A)时，
                表示一次数据接收完成
 *
 *************************************************************************/
void  UART0_IRQHandler()
{
    /***********************************************************************/
   /* MODEM [3] Modem interrupt generated.    0
      TXD [2] Transmit interrupt generated.   0
      ERROR [1] Error interrupt generated.    0
      RXD [0] Receive interrupt generated.    0
      Whenever one of above 4 bits is logical high (‘1’), each UART channel generates interrupt.
      This register has to be cleared in the interrupt service routine.
      You can clear specific bits of UINTP register by writing 1’s to the bits that you want to clear
    */
    /* 接收中断 */
    u8 temp;
    if (SUBSRCPND & BIT_SUB_RXD0)
    {
        temp = URXH0 & 0xFF;                         /* 获取接收到的数据 */
        if ((UART0_RX_STA & (1 << 15)) == 0)                  /* 接收数据未完成 */
        {
            if (UART0_RX_STA & (1 << 14))           /* 已经接收到了0x0D 回车符 */
            {
                if (temp != 0x0A)                    /* 接收到的数据有误 */
                    UART0_RX_STA = 0;                        /* 状态寄存器清零 */
                else
                {
                    UART0_RX_STA |= (1 << 15);         /* 已经接收到了0x0A 换行符,一次数据接收完成 */
                }
            }
            else                                                 /* 没有接收到0x0D 回车符 */
            {
                if (temp == 0x0D)                     /* 接收回车第一个字符 0x0D */
                {
                    UART0_RX_STA |= (1 << 14);          /* 设置状态寄存器 */
                }
                else                                    /* 接收到的是数据 */
                {
                    UART0_RX_BUF[UART0_RX_STA & 0x3FFF] = temp;       /* 保存数据 */
                    UART0_RX_STA++;                 /*  计算接收到的数据长度 */
                    if (UART0_RX_STA > (UART_RX_LEN - 1))
                        UART0_RX_STA = 0;               /* 接收数据超过最大长度，丢失数据，重新接收 */
                }
            }
        }
        /********************************************************/
        /* 用户自定义任务  */




        /*******************************************************/
    }


    /* 错误中断 */
    if (SUBSRCPND & BIT_SUB_ERR0)
    {
        
    }

    /* 发送中断 */
    if (SUBSRCPND & BIT_SUB_TXD0)
    {
        
    }


    SUBSRCPND |= BIT_SUB_ERR0 | BIT_SUB_TXD0 | BIT_SUB_RXD0;                     /* 清中断标志位  */
    SRCPND |= BIT_UART0;                                                         /* 清中断标志位  */
    INTPND |= BIT_UART0;                                                         /* 清中断标志位  */
}

#include "led.h"
#include "uart.h"

int main()
{
    int i = 0;
    // 开启中断
    vector_enable();

    // 初始化
    led_init();
    uart_init();

    // 开启中断
    uart_int_init();
    eint8_23_int_init();

    while(1)
    {
        // 数据接收完成
        while (UART0_RX_STA & 0x8000)
        {
            // 遍历数据
            for (i = 0; i < (UART0_RX_STA & 0x3FFF); i++)
            {
                uart_putchar(UART0_RX_BUF[i]);
            }
            uart_putchar('rn');
            // 清空接收标志位 
            UART0_RX_STA = 0;
        }
  }
   return 0;
}

.text
.global _start
_start:    b   reset
    /* https://blog.csdn.net/shenlong1356/article/details/104602535 */ 
    /* 没有使用伪指令ldr  pc,=undefined_instruction，位置有关指令，获取标号地址，  该地址与链接地址有关 */
    /* 因为该指令会在内存开辟一空间，把undefined_instruction的地址（这个地址取决于链接地址）存放在内存空间中，然后ldr从内存[pc,#xx]取值赋值给pc   */
    /* ldr  pc,_undefined_instruction，位置无关指令   获取标号的值 */
    ldr   pc,_undefined_instruction   /*  从内存取und异常函数地址到PC  */
    ldr   pc,_software_instruction    /*  从内存取swi异常函数地址到PC */
    ldr   pc,_prefetch_abort          /*  从内存取预取指令异常异常函数地址到PC */
    ldr   pc,_data_abort              /*  从内存取访问内存异常函数地址到PC */
    ldr   pc,_not_used                /*  保留 */
    ldr   pc,_irq                     /*  从内存取irq异常函数地址到PC */
    ldr   pc,_fiq                     /*  从内存取fiq异常函数地址到PC */

/*  IRQ正常中断请求处理程序地址  */
_irq:        
    .word    irq 

/*  IRQ正常中断请求处理程序  二级向量表实现中断跳转  */
irq:        
     sub    sp,sp,#4              /* 栈地址-4 */
     stmdb  sp!,{r0-r1}           /* *(sp-4) = r1, *(sp-8) = r0, sp = sp - 8 */  
     ldr    r1,=INTOFFSET
       ldr    r1,[r1]               /* r1 = *INTOFFSET */
     mov    r0,#31                /* r0=31 */
     sub    r1,r0,r1              /* r1=31-r1 这一步是因为我的向量表对应的中断源编号是反向的 */
     ldr    r0,=vector            /* r0 = &vector */
     add    r0,r0,r1,LSL #2       /* r0 = r0 + r1 * 4  r0保存具体中断地址 */
     ldr    r0,[r0]               /* r0 = [r0] */
     str    r0,[sp,#8]            /* *(sp+8) = r0 */
     ldmia  sp!,{r0-r1,pc}        /* r0 = *sp、r1=sp+4、pc=*(sp+0x08) 跳转到中断处理程序 并且sp = sp + x0x08*/

30000e58:    e52db004     push    {fp}        ; (str fp, [sp, #-4]!)
30000e5c:    e28db000     add    fp, sp, #0    ; 0x0
30000e60:    e24dd014     sub    sp, sp, #20    ; 0x14
...
30000fe8:    e28bd000     add    sp, fp, #0    ; 0x0
30000fec:    e8bd0800     pop    {fp}
30000ff0:    e12fff1e     bx    lr