uboot irq流程理解
作者：互联网
/*
* vectors - Generic ARM exception table code
*
* Copyright (c) 1998 Dan Malek <dmalek@jlc.net>
* Copyright (c) 1999 Magnus Damm <kieraypc01.p.y.kie.era.ericsson.se>
* Copyright (c) 2000 Wolfgang Denk <wd@denx.de>
* Copyright (c) 2001 Alex Züpke <azu@sysgo.de>
* Copyright (c) 2001 Marius Gr?ger <mag@sysgo.de>
* Copyright (c) 2002 Alex Züpke <azu@sysgo.de>
* Copyright (c) 2002 Gary Jennejohn <garyj@denx.de>
* Copyright (c) 2002 Kyle Harris <kharris@nexus-tech.net>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <config.h>
/*
*************************************************************************
*
* Symbol _start is referenced elsewhere, so make it global
*
*************************************************************************
*/
.globl _start
/*
*************************************************************************
*
* Vectors have their own section so linker script can map them easily
*
*************************************************************************
*/
.section ".vectors", "x"
/*
*************************************************************************
*
* Exception vectors as described in ARM reference manuals
*
* Uses indirect branch to allow reaching handlers anywhere in memory.
*
*************************************************************************
*/
#ifdef CONFIG_SYS_DV_NOR_BOOT_CFG
.word CONFIG_SYS_DV_NOR_BOOT_CFG
#endif
_start:
ldr pc, _reset_vec
ldr pc, _undefined_instruction
ldr pc, _software_interrupt
ldr pc, _prefetch_abort
ldr pc, _data_abort
ldr pc, _not_used
ldr pc, _irq
ldr pc, _fiq
/*
*************************************************************************
*
* Indirect vectors table
*
* Symbols referenced here must be defined somewhere else
*
*************************************************************************
*/
/*
*use _reset_vec as the variable name because the name "_reset" has been used in other place
*export _reset_vec for fix the vector table after code relocate
*modify by wangwei. 2014-12-01
*/
.globl _reset_vec
.globl _undefined_instruction
.globl _software_interrupt
.globl _prefetch_abort
.globl _data_abort
.globl _not_used
.globl _irq
.globl _fiq
_reset_vec: .word reset
_undefined_instruction: .word undefined_instruction
_software_interrupt: .word software_interrupt
_prefetch_abort: .word prefetch_abort
_data_abort: .word data_abort
_not_used: .word not_used
_irq: .word irq
_fiq: .word fiq
.balignl 16,0xdeadbeef
/*
*************************************************************************
*
* Interrupt handling
*
*************************************************************************
*/
/* SPL interrupt handling: just hang */
#ifdef CONFIG_SPL_BUILD
.align 5
undefined_instruction:
software_interrupt:
prefetch_abort:
data_abort:
not_used:
irq:
fiq:
1:
bl 1b /* hang and never return */
#else /* !CONFIG_SPL_BUILD */
/* IRQ stack memory (calculated at run-time) + 8 bytes */
.globl IRQ_STACK_START_IN
IRQ_STACK_START_IN:
.word 0x0badc0de
#ifdef CONFIG_USE_IRQ
/* IRQ stack memory (calculated at run-time) */
.globl IRQ_STACK_START
IRQ_STACK_START:
.word 0x0badc0de
/* IRQ stack memory (calculated at run-time) */
.globl FIQ_STACK_START
FIQ_STACK_START:
.word 0x0badc0de
#endif /* CONFIG_USE_IRQ */
@
@ IRQ stack frame.
@
#define S_FRAME_SIZE 72
#define S_OLD_R0 68
#define S_PSR 64
#define S_PC 60
#define S_LR 56
#define S_SP 52
#define S_IP 48
#define S_FP 44
#define S_R10 40
#define S_R9 36
#define S_R8 32
#define S_R7 28
#define S_R6 24
#define S_R5 20
#define S_R4 16
#define S_R3 12
#define S_R2 8
#define S_R1 4
#define S_R0 0
#define MODE_SVC 0x13
#define I_BIT 0x80
/*
* use bad_save_user_regs for abort/prefetch/undef/swi ...
* use irq_save_user_regs / irq_restore_user_regs for IRQ/FIQ handling
*/
.macro bad_save_user_regs
@ carve out a frame on current user stack
sub sp, sp, #S_FRAME_SIZE
stmia sp, {r0 - r12} @ Save user registers (now in svc mode) r0-r12
ldr r2, IRQ_STACK_START_IN
@ get values for "aborted" pc and cpsr (into parm regs)
ldmia r2, {r2 - r3}
add r0, sp, #S_FRAME_SIZE @ grab pointer to old stack
add r5, sp, #S_SP
mov r1, lr
stmia r5, {r0 - r3} @ save sp_SVC, lr_SVC, pc, cpsr
mov r0, sp @ save current stack into r0 (param register)
.endm
.macro irq_save_user_regs
sub sp, sp, #S_FRAME_SIZE
stmia sp, {r0 - r12} @ Calling r0-r12
@ !!!! R8 NEEDS to be saved !!!! a reserved stack spot would be good.
add r8, sp, #S_PC
stmdb r8, {sp, lr}^ @ Calling SP, LR
str lr, [r8, #0] @ Save calling PC
mrs r6, spsr
str r6, [r8, #4] @ Save CPSR
str r0, [r8, #8] @ Save OLD_R0
mov r0, sp
.endm
.macro irq_restore_user_regs
ldmia sp, {r0 - lr}^ @ Calling r0 - lr
mov r0, r0
ldr lr, [sp, #S_PC] @ Get PC
add sp, sp, #S_FRAME_SIZE
subs pc, lr, #4 @ return & move spsr_svc into cpsr
.endm
.macro get_bad_stack
ldr r13, IRQ_STACK_START_IN @ setup our mode stack
str lr, [r13] @ save caller lr in position 0 of saved stack
mrs lr, spsr @ get the spsr
str lr, [r13, #4] @ save spsr in position 1 of saved stack
mov r13, #MODE_SVC @ prepare SVC-Mode
@ msr spsr_c, r13
msr spsr, r13 @ switch modes, make sure moves will execute
mov lr, pc @ capture return pc
movs pc, lr @ jump to next instruction & switch modes.
.endm
.macro get_irq_stack @ setup IRQ stack
ldr sp, IRQ_STACK_START
.endm
.macro get_fiq_stack @ setup FIQ stack
ldr sp, FIQ_STACK_START
.endm
/*
* exception handlers
*/
.align 5
undefined_instruction:
get_bad_stack
bad_save_user_regs
bl do_undefined_instruction
.align 5
software_interrupt:
get_bad_stack
bad_save_user_regs
bl do_software_interrupt
.align 5
prefetch_abort:
get_bad_stack
bad_save_user_regs
bl do_prefetch_abort
.align 5
data_abort:
get_bad_stack
bad_save_user_regs
bl do_data_abort
.align 5
not_used:
get_bad_stack
bad_save_user_regs
bl do_not_used
#ifdef CONFIG_USE_IRQ
.align 5
irq:
@get_irq_stack kkkkk
@irq_save_user_regs xxxxx
//陷入irq模式后 cpsr = irq, spsr=svc, lr=从svc模式普通代码中断处的 返回点
sub sp, sp, #S_FRAME_SIZE @72
stmia sp, {r0 - r12} @ Calling r0-r12
//调用者(svc)的r0-r12,也是irq的(r0-r12)
//此时用的sp是irq模式的sp_irq
@ !!!! R8 NEEDS to be saved !!!! a reserved stack spot would be good.
add r8, sp, #S_PC @60
//stmdb r8, {sp, lr}^ @ Calling SP, LR
//保存用户态的堆栈和lr 现在是在irq态 uboot没有使用用户态 都是svc,irq态
//但是 堆栈设置了2个 普通程序堆栈(svc)和irq中断模式的堆栈
//'^'是一个后缀标志,不能在User模式和Sys系统模式下使用该标志.
//该标志有两个存在目的:
//a.对于LDM操作,同时恢复的寄存器中含有pc(r15)寄存器,
//那么指令执行的同时cpu自动将spsr拷贝到cpsr中
//如:在UND中断返回代码中ldmfd sp!, {r0-r13,pc}^
//当指令执行完毕,pc跳转之前,将spsr的值自动拷贝到cpsr中
//b.数据的送入,送出发生在User用户模式下的寄存器,而非当前模式寄存器
//如:ldmdb sp, {r0 - lr}^;
//表示sp栈中的数据恢复到User分组寄存器r0-lr中,
//而不是恢复到当前模式寄存器r0-lr
//当然对于User,System,IRQ,SVC,Abort,Undefined这6种模式来说r0-r12是共用的,
//只是r13和r14为分别独有,对于FIQ模式,仅仅r0-r7是和前6中模式的r0-r7共用,r8-r14都是FIQ模式下专有.
//其实usr模式的 lr和sp的保存 应该没有啥鸟用 因为用的是svc模式
//把上面一行注释 程序正常运行
ldr r1, =(0x88888888)
str r1, [r8, #-4]
ldr r1, =(0x99999999)
str r1, [r8, #-8]
//确实没有卵用 我加上上面几行代码 程序正常运行
str lr, [r8, #0] @ Save calling PC
//svc返回地址 中断点 从lr的上一条指令陷入irq模式
mrs r6, spsr
//保存 spsr寄存器 其值等于svc模式,因为是从svc模式进入的
@mrs r6, cpsr
str r6, [r8, #4] @ Save CPSR
str r0, [r8, #8] @ Save OLD_R0
mov r0, sp
stmdb sp!, {r0-r12}
bl do_irq_before_hook
ldmia sp!, {r0-r12}
//do_irq_before_hook
bl do_irq
@irq_restore_user_regs xxxxx
ldmia sp, {r0 - lr}^ @ Calling r0 - lr
mov r0, r0
ldr lr, [sp, #S_PC] @ Get PC
add sp, sp, #S_FRAME_SIZE
subs pc, lr, #4 @ return & move spsr_svc into cpsr
//流水线跨过了2条指令 回退一条指令(-4)
//注意这里有个 sub+s 表示更新cpsr
//把spsr的值去覆盖cpsr
//此时工作于irq模式 cpsr=irq,但是spsr=svc,因为是从svc模式陷入irq中断服务程序的
//所以可以从irq模式返回到svc模式
//MOV一般不影响CPSR,
//除非执行类似MOV pc, lr 效果上等同于BX lr
//可能会影响到T标志位
//MOVS总是会影响CPSR,
//包括N,Z,C标志位,执行 MOVS pc, lr时,
//CPSR会被SPSR覆盖(内核态,USER和SYSTEM模式下没有SPSR)
//举例,当USER模式下有一条未定义指令,CPU在译码阶段会发现指令未定义
//这时会跳转到相应的处理函数,切换到UND模式,并把未定义指令下一条指令的地址保存到lr寄存器
//当处理函数执行完成后,怎样去返回的同时把状态寄存器等恢复是个问题
//因为UND模式下sp和lr寄存器是该模式下特有的
//这时候就可以可以直接用MOVS pc, lr来返回并切换回USER模式
.align 5
fiq:
get_fiq_stack
/* someone ought to write a more effiction fiq_save_user_regs */
irq_save_user_regs
bl do_fiq
irq_restore_user_regs
#else
.align 5
irq:
get_bad_stackxxxx
bad_save_user_regs
bl do_irq
.align 5
fiq:
get_bad_stack
bad_save_user_regs
bl do_fiq
#endif /* CONFIG_USE_IRQ */
#endif /* CONFIG_SPL_BUILD */
/*
* (C) Copyright 2007-2013
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
* Jerry Wang <wangflord@allwinnertech.com>
*
* See file CREDITS for list of people who contributed to this
* project.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*/
#include <common.h>
#include <asm/io.h>
#include <asm/arch/ccmu.h>
#include <asm/arch/gic.h>
#include <sunxi_board.h>
DECLARE_GLOBAL_DATA_PTR;
struct _irq_handler
{
void *m_data;
void (*m_func)( void * data);
};
struct _irq_handler sunxi_int_handlers[GIC_IRQ_NUM];
extern int interrupts_is_open(void);
static void gic_spi_set_target(int irq_no, int cpu_id);
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void default_isr(void *data)
{
pr_msg("default_isr(): called from IRQ %d\n", (uint)data);
while(1);
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int irq_enable(int irq_no)
{
uint reg_val;
uint offset;
if (irq_no >= GIC_IRQ_NUM)
{
pr_msg("irq NO.(%d) > GIC_IRQ_NUM(%d) !!\n", irq_no, GIC_IRQ_NUM);
return -1;
}
if(irq_no == AW_IRQ_NMI)
{
*(volatile unsigned int *)(0x01f00c00 + 0x10) |= 1;
*(volatile unsigned int *)(0x01f00c00 + 0x40) |= 1;
}
gic_spi_set_target(irq_no, get_core_pos());
offset = irq_no >> 5; // 除32
reg_val = readl(GIC_SET_EN(offset));
reg_val |= 1 << (irq_no & 0x1f);
writel(reg_val, GIC_SET_EN(offset));
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int irq_disable(int irq_no)
{
uint reg_val;
uint offset;
if (irq_no >= GIC_IRQ_NUM)
{
pr_msg("irq NO.(%d) > GIC_IRQ_NUM(%d) !!\n", irq_no, GIC_IRQ_NUM);
return -1;
}
if(irq_no == AW_IRQ_NMI)
{
*(volatile unsigned int *)(0x01f00c00 + 0x10) |= 1;
*(volatile unsigned int *)(0x01f00c00 + 0x40) &= ~1;
}
gic_spi_set_target(irq_no, 0);
offset = irq_no >> 5; // 除32
reg_val = (1 << (irq_no & 0x1f));
writel(reg_val, GIC_CLR_EN(offset));
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_sgi_handler(uint irq_no)
{
pr_msg("SGI irq %d coming... \n", irq_no);
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_ppi_handler(uint irq_no)
{
pr_msg("PPI irq %d coming... \n", irq_no);
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_spi_handler(uint irq_no)
{
if (sunxi_int_handlers[irq_no].m_func != default_isr)
{
sunxi_int_handlers[irq_no].m_func(sunxi_int_handlers[irq_no].m_data);
}
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_clear_pending(uint irq_no)
{
uint reg_val;
uint offset;
offset = irq_no >> 5; // 除32
//reg_val = readl(GIC_PEND_CLR(offset));
reg_val = (1 << (irq_no & 0x1f));
writel(reg_val, GIC_PEND_CLR(offset));
return ;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
void irq_install_handler (int irq, interrupt_handler_t handle_irq, void *data)
{
pr_msg("install irq %d \n", irq);
debug("install irqx %d \n", irq);
//error!!!
int flag = interrupts_is_open();
//when irq_handler call this function , irq enable bit has already disabled in irq_mode,so don't need to enable I bit
if(flag)
{
disable_interrupts();
}
if (irq >= GIC_IRQ_NUM || !handle_irq)
{
goto __END;
}
sunxi_int_handlers[irq].m_data = data;
sunxi_int_handlers[irq].m_func = handle_irq;
__END:
if(flag)
{
enable_interrupts();
}
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
void irq_free_handler(int irq)
{
disable_interrupts();
if (irq >= GIC_IRQ_NUM)
{
enable_interrupts();
return;
}
sunxi_int_handlers[irq].m_data = NULL;
sunxi_int_handlers[irq].m_func = default_isr;
enable_interrupts();
}
extern int printf(const char *fmt, ...);
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
#ifdef CONFIG_USE_IRQ
__maybe_unused unsigned long get_cpsr( void )
{
unsigned long reg_var;
//mrs r0, cpsr
asm volatile("mrs %0, cpsr" :"=r"(reg_var): :);
return reg_var;
}
__maybe_unused unsigned long get_spsr( void )
{
unsigned long reg_var;
//mrs r0, cpsr
asm volatile("mrs %0, spsr" :"=r"(reg_var): :);
return reg_var;
}
__maybe_unused unsigned long get_lr( void )
{
unsigned long reg_var;
asm volatile("mov %0, lr" :"=r"(reg_var): :);
return reg_var;
}
__maybe_unused unsigned long get_sp( void )
{
unsigned long reg_var;
asm volatile("mov %0, sp" :"=r"(reg_var): :);
return reg_var;
}
extern int macdbg_dmphex(const char* buff, int len);
void do_asm_test_func(struct pt_regs *pt_regs)
{
char *p;
asm volatile("nop");
asm volatile("nop");
asm volatile("nop");
asm volatile("nop");
asm volatile( "ldr r0, =(0x12345678)" );
asm volatile( "ldr r1, =(0x11111111)" );
asm volatile( "ldr r2, =(0x22222222)" );
asm volatile( "ldr r3, =(0x33333333)" );
asm volatile( "ldr r4, =(0x44444444)" );
asm volatile( "ldr r5, =(0x55555555)" );
asm volatile( "ldr r6, =(0x66666666)" );
asm volatile( "ldr r7, =(0x77777777)" );
asm volatile( "ldr r8, =(0x88888888)" );
//asm volatile( "ldr r9, =(0x99999999)" );
asm volatile( "ldr r10, =(0xAAAAAAAA)" );
asm volatile( "ldr r11, =(0xbbbbbbbb)" );
asm volatile( "ldr r12, =(0xcccccccc)" );
asm volatile("stmdb sp!, {r0-r12}");
p = (char *)get_sp();
debug( "do_asm_test_func p2 = %p\n", p );
macdbg_dmphex((char *)p, 0x40);
asm volatile("ldmia sp!, {r0-r12}");
}
void do_irq_before_hook( struct pt_regs *pt_regs )
{
u32 idnum;
//volatile u32 secmode;
//debug( "in do_irq_before_hook = %d\n", 456 );
idnum = readl(GIC_INT_ACK_REG);
//debug( "idnum1 = %d\n", idnum );
char *p =NULL;
if( idnum == 85 || idnum == 84 ){
;
}else{
p=p;
show_regs (pt_regs);
//debug( "do_irq xxxc idnum = %d\n", idnum );
//p = (char *)get_sp();
//debug( "do_irq xxxc p = %p\n", p );
debug( "do_irq xxxc pt_regs = %p\n", pt_regs );
macdbg_dmphex((char *)pt_regs, 0x100);
debug( "do_irq xxxc get_sp() = %lx\n", get_sp() );
debug( "do_irq xxxc get_cpsr() = %lx\n", get_cpsr() );
debug( "do_irq xxxc get_spsr() = %lx\n", get_spsr() );
debug( "do_irq xxxc get_sp() = %lx\n", get_sp() );
//macdbg_dmphex((char *)p, 0x100);
//do_asm_test_func(pt_regs);
//do_timer_test
//pr_msg("spurious irq !!\n");
}
if( (idnum == 1022) || (idnum == 1023) ){
pr_msg("spurious irq !!\n");
return;
}
if (idnum >= GIC_IRQ_NUM) {
pr_msg("irq NO.(%d) > GIC_IRQ_NUM(%d) !!\n", idnum, GIC_IRQ_NUM-32);
return;
}
if (idnum < 16)
gic_sgi_handler(idnum);
else if (idnum < 32)
gic_ppi_handler(idnum);
else
gic_spi_handler(idnum);
writel(idnum, GIC_END_INT_REG);
writel(idnum, GIC_DEACT_INT_REG);
//writel(idnum, GIC_DEACT_INT_REG);
gic_clear_pending(idnum);
}
void do_irq (struct pt_regs *pt_regs)
{
//debug( "do_irq idnum = %d\n", 123 );
return;
}
int do_irqinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int irq;
pr_msg("Interrupt-Information:\n");
pr_msg("Nr(Max) Routine Arg\n");
for (irq = 0; irq < GIC_IRQ_NUM; irq ++)
{
if (sunxi_int_handlers[irq].m_func != NULL)
{
pr_msg("%d(%d) 0x%08lx 0x%08lx\n",
irq, GIC_IRQ_NUM,
(ulong)sunxi_int_handlers[irq].m_func,
(ulong)sunxi_int_handlers[irq].m_data);
}
}
return 0;
}
#endif
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_distributor_init(void)
{
__u32 cpumask = 0x01010101;
__u32 gic_irqs;
__u32 i;
writel(0, GIC_DIST_CON);
/* check GIC hardware configutation */
gic_irqs = ((readl(GIC_CON_TYPE) & 0x1f) + 1) * 32;
if (gic_irqs > 1020)
{
gic_irqs = 1020;
}
if (gic_irqs < GIC_IRQ_NUM)
{
pr_error("GIC parameter config error, only support %d"
" irqs < %d(spec define)!!\n", gic_irqs, GIC_IRQ_NUM);
return ;
}
/* set trigger type to be level-triggered, active low */
for (i=0; i<GIC_IRQ_NUM; i+=16)
{
writel(0, GIC_IRQ_MOD_CFG(i>>4));
}
/* set priority */
for (i=GIC_SRC_SPI(0); i<GIC_IRQ_NUM; i+=4)
{
writel(0xa0a0a0a0, GIC_SPI_PRIO((i-32)>>2));
}
/* set processor target */
for (i=32; i<GIC_IRQ_NUM; i+=4)
{
writel(cpumask, GIC_SPI_PROC_TARG((i-32)>>2));
}
/* disable all interrupts */
for (i=32; i<GIC_IRQ_NUM; i+=32)
{
writel(0xffffffff, GIC_CLR_EN(i>>5));
}
/* clear all interrupt active state */
for (i=32; i<GIC_IRQ_NUM; i+=32)
{
writel(0xffffffff, GIC_ACT_CLR(i>>5));
}
writel(1, GIC_DIST_CON);
return ;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_cpuif_init(void)
{
uint i;
writel(0, GIC_CPU_IF_CTRL);
/*
* Deal with the banked PPI and SGI interrupts - disable all
* PPI interrupts, ensure all SGI interrupts are enabled.
*/
writel(0xffff0000, GIC_CLR_EN(0));
writel(0x0000ffff, GIC_SET_EN(0));
/* Set priority on PPI and SGI interrupts */
for (i=0; i<16; i+=4)
{
writel(0xa0a0a0a0, GIC_SGI_PRIO(i>>2));
}
for (i=16; i<32; i+=4)
{
writel(0xa0a0a0a0, GIC_PPI_PRIO((i-16)>>2));
}
writel(0xf0, GIC_INT_PRIO_MASK);
writel(1, GIC_CPU_IF_CTRL);
return ;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
static void gic_spi_set_target(int irq_no, int cpu_id)
{
uint reg_val, addr, offset;
irq_no -= 32;
/* dispatch the usb interrupt to CPU1 */
addr = GIC_SPI_PROC_TARG(irq_no>>2);
reg_val = readl(addr);
offset = 8 * (irq_no & 3);
reg_val &= ~(0xff<<offset);
reg_val |= (((1<<cpu_id) & 0xf) <<offset);
writel(reg_val, addr);
return ;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int arch_interrupt_init (void)
{
int i;
for (i=0; i<GIC_IRQ_NUM; i++)
sunxi_int_handlers[i].m_data = default_isr;
if (sunxi_probe_secure_monitor() || sunxi_probe_secure_os())
pr_msg("gic: sec monitor mode\n");
else {
pr_msg("gic: normal mode\n");
gic_distributor_init();
gic_cpuif_init();
}
return 0;
}
/*
************************************************************************************************************
*
* function
*
* name :
*
* parmeters :
*
* return :
*
* note :
*
*
************************************************************************************************************
*/
int arch_interrupt_exit(void)
{
if (!(sunxi_probe_secure_monitor() || sunxi_probe_secure_os())) {
gic_distributor_init();
gic_cpuif_init();
}
return 0;
}
int sunxi_gic_cpu_interface_init(int cpu)
{
gic_cpuif_init();
return 0;
}
int sunxi_gic_cpu_interface_exit(void)
{
writel(0, GIC_CPU_IF_CTRL);
return 0;
}
标签：uboot,int,irq,流程,sp,GIC,IRQ,return 来源： https://blog.csdn.net/dp__mcu/article/details/116799426