mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 00:48:52 +09:00
![J. Tang](/assets/img/avatar_default.png)
Depending upon the compiler used, IRQ entries could vary in sizes. With GCC 5.x, the code generator will use short jumps for some IRQ entries but near jumps for others. For example, GCC 5.4.0 generates the following: $ objdump -d interrupt.o <snip> 00000207 <irq_18>: 207: 6a 12 push $0x12 209: eb 85 jmp 190 <irq_common_entry> 0000020b <irq_19>: 20b: 6a 13 push $0x13 20d: eb 81 jmp 190 <irq_common_entry> 0000020f <irq_20>: 20f: 6a 14 push $0x14 211: e9 7a ff ff ff jmp 190 <irq_common_entry> 00000216 <irq_21>: 216: 6a 15 push $0x15 218: e9 73 ff ff ff jmp 190 <irq_common_entry> This causes a problem in cpu_init_interrupts(), because the IDT setup assumed same sizes for all IRQ entries. GCC 4.x always generated 32-bit jumps, so this previously was not a problem. The fix is to force 32-bit near jumps for all entries within the inline assembly. This works for GCC 5.x, and 4.x was already using that form of jumping. Signed-off-by: Jason Tang <tang@jtang.org> Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
616 lines
14 KiB
C
616 lines
14 KiB
C
/*
|
|
* (C) Copyright 2008-2011
|
|
* Graeme Russ, <graeme.russ@gmail.com>
|
|
*
|
|
* (C) Copyright 2002
|
|
* Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
|
|
*
|
|
* Portions of this file are derived from the Linux kernel source
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <dm.h>
|
|
#include <asm/control_regs.h>
|
|
#include <asm/i8259.h>
|
|
#include <asm/interrupt.h>
|
|
#include <asm/io.h>
|
|
#include <asm/lapic.h>
|
|
#include <asm/processor-flags.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
#define DECLARE_INTERRUPT(x) \
|
|
".globl irq_"#x"\n" \
|
|
".hidden irq_"#x"\n" \
|
|
".type irq_"#x", @function\n" \
|
|
"irq_"#x":\n" \
|
|
"pushl $"#x"\n" \
|
|
"jmp.d32 irq_common_entry\n"
|
|
|
|
static char *exceptions[] = {
|
|
"Divide Error",
|
|
"Debug",
|
|
"NMI Interrupt",
|
|
"Breakpoint",
|
|
"Overflow",
|
|
"BOUND Range Exceeded",
|
|
"Invalid Opcode (Undefined Opcode)",
|
|
"Device Not Avaiable (No Math Coprocessor)",
|
|
"Double Fault",
|
|
"Coprocessor Segment Overrun",
|
|
"Invalid TSS",
|
|
"Segment Not Present",
|
|
"Stack Segment Fault",
|
|
"General Protection",
|
|
"Page Fault",
|
|
"Reserved",
|
|
"x87 FPU Floating-Point Error",
|
|
"Alignment Check",
|
|
"Machine Check",
|
|
"SIMD Floating-Point Exception",
|
|
"Virtualization Exception",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved",
|
|
"Reserved"
|
|
};
|
|
|
|
static void dump_regs(struct irq_regs *regs)
|
|
{
|
|
unsigned long cs, eip, eflags;
|
|
unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
|
|
unsigned long d0, d1, d2, d3, d6, d7;
|
|
unsigned long sp;
|
|
|
|
/*
|
|
* Some exceptions cause an error code to be saved on the current stack
|
|
* after the EIP value. We should extract CS/EIP/EFLAGS from different
|
|
* position on the stack based on the exception number.
|
|
*/
|
|
switch (regs->irq_id) {
|
|
case EXC_DF:
|
|
case EXC_TS:
|
|
case EXC_NP:
|
|
case EXC_SS:
|
|
case EXC_GP:
|
|
case EXC_PF:
|
|
case EXC_AC:
|
|
cs = regs->context.ctx2.xcs;
|
|
eip = regs->context.ctx2.eip;
|
|
eflags = regs->context.ctx2.eflags;
|
|
/* We should fix up the ESP due to error code */
|
|
regs->esp += 4;
|
|
break;
|
|
default:
|
|
cs = regs->context.ctx1.xcs;
|
|
eip = regs->context.ctx1.eip;
|
|
eflags = regs->context.ctx1.eflags;
|
|
break;
|
|
}
|
|
|
|
printf("EIP: %04x:[<%08lx>] EFLAGS: %08lx\n",
|
|
(u16)cs, eip, eflags);
|
|
if (gd->flags & GD_FLG_RELOC)
|
|
printf("Original EIP :[<%08lx>]\n", eip - gd->reloc_off);
|
|
|
|
printf("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
|
|
regs->eax, regs->ebx, regs->ecx, regs->edx);
|
|
printf("ESI: %08lx EDI: %08lx EBP: %08lx ESP: %08lx\n",
|
|
regs->esi, regs->edi, regs->ebp, regs->esp);
|
|
printf(" DS: %04x ES: %04x FS: %04x GS: %04x SS: %04x\n",
|
|
(u16)regs->xds, (u16)regs->xes, (u16)regs->xfs,
|
|
(u16)regs->xgs, (u16)regs->xss);
|
|
|
|
cr0 = read_cr0();
|
|
cr2 = read_cr2();
|
|
cr3 = read_cr3();
|
|
cr4 = read_cr4();
|
|
|
|
printf("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n",
|
|
cr0, cr2, cr3, cr4);
|
|
|
|
d0 = get_debugreg(0);
|
|
d1 = get_debugreg(1);
|
|
d2 = get_debugreg(2);
|
|
d3 = get_debugreg(3);
|
|
|
|
printf("DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n",
|
|
d0, d1, d2, d3);
|
|
|
|
d6 = get_debugreg(6);
|
|
d7 = get_debugreg(7);
|
|
printf("DR6: %08lx DR7: %08lx\n",
|
|
d6, d7);
|
|
|
|
printf("Stack:\n");
|
|
sp = regs->esp;
|
|
|
|
sp += 64;
|
|
|
|
while (sp > (regs->esp - 16)) {
|
|
if (sp == regs->esp)
|
|
printf("--->");
|
|
else
|
|
printf(" ");
|
|
printf("0x%8.8lx : 0x%8.8lx\n", sp, (ulong)readl(sp));
|
|
sp -= 4;
|
|
}
|
|
}
|
|
|
|
static void do_exception(struct irq_regs *regs)
|
|
{
|
|
printf("%s\n", exceptions[regs->irq_id]);
|
|
dump_regs(regs);
|
|
hang();
|
|
}
|
|
|
|
struct idt_entry {
|
|
u16 base_low;
|
|
u16 selector;
|
|
u8 res;
|
|
u8 access;
|
|
u16 base_high;
|
|
} __packed;
|
|
|
|
struct desc_ptr {
|
|
unsigned short size;
|
|
unsigned long address;
|
|
} __packed;
|
|
|
|
struct idt_entry idt[256] __aligned(16);
|
|
|
|
struct desc_ptr idt_ptr;
|
|
|
|
static inline void load_idt(const struct desc_ptr *dtr)
|
|
{
|
|
asm volatile("cs lidt %0" : : "m" (*dtr));
|
|
}
|
|
|
|
void set_vector(u8 intnum, void *routine)
|
|
{
|
|
idt[intnum].base_high = (u16)((ulong)(routine) >> 16);
|
|
idt[intnum].base_low = (u16)((ulong)(routine) & 0xffff);
|
|
}
|
|
|
|
/*
|
|
* Ideally these would be defined static to avoid a checkpatch warning, but
|
|
* the compiler cannot see them in the inline asm and complains that they
|
|
* aren't defined
|
|
*/
|
|
void irq_0(void);
|
|
void irq_1(void);
|
|
|
|
int cpu_init_interrupts(void)
|
|
{
|
|
int i;
|
|
|
|
int irq_entry_size = irq_1 - irq_0;
|
|
void *irq_entry = (void *)irq_0;
|
|
|
|
/* Setup the IDT */
|
|
for (i = 0; i < 256; i++) {
|
|
idt[i].access = 0x8e;
|
|
idt[i].res = 0;
|
|
idt[i].selector = X86_GDT_ENTRY_32BIT_CS * X86_GDT_ENTRY_SIZE;
|
|
set_vector(i, irq_entry);
|
|
irq_entry += irq_entry_size;
|
|
}
|
|
|
|
idt_ptr.size = 256 * 8 - 1;
|
|
idt_ptr.address = (unsigned long) idt;
|
|
|
|
load_idt(&idt_ptr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void *x86_get_idt(void)
|
|
{
|
|
return &idt_ptr;
|
|
}
|
|
|
|
void __do_irq(int irq)
|
|
{
|
|
printf("Unhandled IRQ : %d\n", irq);
|
|
}
|
|
void do_irq(int irq) __attribute__((weak, alias("__do_irq")));
|
|
|
|
void enable_interrupts(void)
|
|
{
|
|
asm("sti\n");
|
|
}
|
|
|
|
int disable_interrupts(void)
|
|
{
|
|
long flags;
|
|
|
|
#if CONFIG_IS_ENABLED(X86_64)
|
|
asm volatile ("pushfq ; popq %0 ; cli\n" : "=g" (flags) : );
|
|
#else
|
|
asm volatile ("pushfl ; popl %0 ; cli\n" : "=g" (flags) : );
|
|
#endif
|
|
return flags & X86_EFLAGS_IF;
|
|
}
|
|
|
|
int interrupt_init(void)
|
|
{
|
|
struct udevice *dev;
|
|
int ret;
|
|
|
|
/* Try to set up the interrupt router, but don't require one */
|
|
ret = uclass_first_device_err(UCLASS_IRQ, &dev);
|
|
if (ret && ret != -ENODEV)
|
|
return ret;
|
|
|
|
/*
|
|
* When running as an EFI application we are not in control of
|
|
* interrupts and should leave them alone.
|
|
*/
|
|
#ifndef CONFIG_EFI_APP
|
|
/* Just in case... */
|
|
disable_interrupts();
|
|
|
|
#ifdef CONFIG_I8259_PIC
|
|
/* Initialize the master/slave i8259 pic */
|
|
i8259_init();
|
|
#endif
|
|
|
|
lapic_setup();
|
|
|
|
/* Initialize core interrupt and exception functionality of CPU */
|
|
cpu_init_interrupts();
|
|
|
|
/*
|
|
* It is now safe to enable interrupts.
|
|
*
|
|
* TODO(sjg@chromium.org): But we don't handle these correctly when
|
|
* booted from EFI.
|
|
*/
|
|
if (ll_boot_init())
|
|
enable_interrupts();
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* IRQ Low-Level Service Routine */
|
|
void irq_llsr(struct irq_regs *regs)
|
|
{
|
|
/*
|
|
* For detailed description of each exception, refer to:
|
|
* Intel® 64 and IA-32 Architectures Software Developer's Manual
|
|
* Volume 1: Basic Architecture
|
|
* Order Number: 253665-029US, November 2008
|
|
* Table 6-1. Exceptions and Interrupts
|
|
*/
|
|
if (regs->irq_id < 32) {
|
|
/* Architecture defined exception */
|
|
do_exception(regs);
|
|
} else {
|
|
/* Hardware or User IRQ */
|
|
do_irq(regs->irq_id);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* OK - This looks really horrible, but it serves a purpose - It helps create
|
|
* fully relocatable code.
|
|
* - The call to irq_llsr will be a relative jump
|
|
* - The IRQ entries will be guaranteed to be in order
|
|
* Interrupt entries are now very small (a push and a jump) but they are
|
|
* now slower (all registers pushed on stack which provides complete
|
|
* crash dumps in the low level handlers
|
|
*
|
|
* Interrupt Entry Point:
|
|
* - Interrupt has caused eflags, CS and EIP to be pushed
|
|
* - Interrupt Vector Handler has pushed orig_eax
|
|
* - pt_regs.esp needs to be adjusted by 40 bytes:
|
|
* 12 bytes pushed by CPU (EFLAGSF, CS, EIP)
|
|
* 4 bytes pushed by vector handler (irq_id)
|
|
* 24 bytes pushed before SP (SS, GS, FS, ES, DS, EAX)
|
|
* NOTE: Only longs are pushed on/popped off the stack!
|
|
*/
|
|
asm(".globl irq_common_entry\n" \
|
|
".hidden irq_common_entry\n" \
|
|
".type irq_common_entry, @function\n" \
|
|
"irq_common_entry:\n" \
|
|
"cld\n" \
|
|
"pushl %ss\n" \
|
|
"pushl %gs\n" \
|
|
"pushl %fs\n" \
|
|
"pushl %es\n" \
|
|
"pushl %ds\n" \
|
|
"pushl %eax\n" \
|
|
"movl %esp, %eax\n" \
|
|
"addl $40, %eax\n" \
|
|
"pushl %eax\n" \
|
|
"pushl %ebp\n" \
|
|
"pushl %edi\n" \
|
|
"pushl %esi\n" \
|
|
"pushl %edx\n" \
|
|
"pushl %ecx\n" \
|
|
"pushl %ebx\n" \
|
|
"mov %esp, %eax\n" \
|
|
"call irq_llsr\n" \
|
|
"popl %ebx\n" \
|
|
"popl %ecx\n" \
|
|
"popl %edx\n" \
|
|
"popl %esi\n" \
|
|
"popl %edi\n" \
|
|
"popl %ebp\n" \
|
|
"popl %eax\n" \
|
|
"popl %eax\n" \
|
|
"popl %ds\n" \
|
|
"popl %es\n" \
|
|
"popl %fs\n" \
|
|
"popl %gs\n" \
|
|
"popl %ss\n" \
|
|
"add $4, %esp\n" \
|
|
"iret\n" \
|
|
DECLARE_INTERRUPT(0) \
|
|
DECLARE_INTERRUPT(1) \
|
|
DECLARE_INTERRUPT(2) \
|
|
DECLARE_INTERRUPT(3) \
|
|
DECLARE_INTERRUPT(4) \
|
|
DECLARE_INTERRUPT(5) \
|
|
DECLARE_INTERRUPT(6) \
|
|
DECLARE_INTERRUPT(7) \
|
|
DECLARE_INTERRUPT(8) \
|
|
DECLARE_INTERRUPT(9) \
|
|
DECLARE_INTERRUPT(10) \
|
|
DECLARE_INTERRUPT(11) \
|
|
DECLARE_INTERRUPT(12) \
|
|
DECLARE_INTERRUPT(13) \
|
|
DECLARE_INTERRUPT(14) \
|
|
DECLARE_INTERRUPT(15) \
|
|
DECLARE_INTERRUPT(16) \
|
|
DECLARE_INTERRUPT(17) \
|
|
DECLARE_INTERRUPT(18) \
|
|
DECLARE_INTERRUPT(19) \
|
|
DECLARE_INTERRUPT(20) \
|
|
DECLARE_INTERRUPT(21) \
|
|
DECLARE_INTERRUPT(22) \
|
|
DECLARE_INTERRUPT(23) \
|
|
DECLARE_INTERRUPT(24) \
|
|
DECLARE_INTERRUPT(25) \
|
|
DECLARE_INTERRUPT(26) \
|
|
DECLARE_INTERRUPT(27) \
|
|
DECLARE_INTERRUPT(28) \
|
|
DECLARE_INTERRUPT(29) \
|
|
DECLARE_INTERRUPT(30) \
|
|
DECLARE_INTERRUPT(31) \
|
|
DECLARE_INTERRUPT(32) \
|
|
DECLARE_INTERRUPT(33) \
|
|
DECLARE_INTERRUPT(34) \
|
|
DECLARE_INTERRUPT(35) \
|
|
DECLARE_INTERRUPT(36) \
|
|
DECLARE_INTERRUPT(37) \
|
|
DECLARE_INTERRUPT(38) \
|
|
DECLARE_INTERRUPT(39) \
|
|
DECLARE_INTERRUPT(40) \
|
|
DECLARE_INTERRUPT(41) \
|
|
DECLARE_INTERRUPT(42) \
|
|
DECLARE_INTERRUPT(43) \
|
|
DECLARE_INTERRUPT(44) \
|
|
DECLARE_INTERRUPT(45) \
|
|
DECLARE_INTERRUPT(46) \
|
|
DECLARE_INTERRUPT(47) \
|
|
DECLARE_INTERRUPT(48) \
|
|
DECLARE_INTERRUPT(49) \
|
|
DECLARE_INTERRUPT(50) \
|
|
DECLARE_INTERRUPT(51) \
|
|
DECLARE_INTERRUPT(52) \
|
|
DECLARE_INTERRUPT(53) \
|
|
DECLARE_INTERRUPT(54) \
|
|
DECLARE_INTERRUPT(55) \
|
|
DECLARE_INTERRUPT(56) \
|
|
DECLARE_INTERRUPT(57) \
|
|
DECLARE_INTERRUPT(58) \
|
|
DECLARE_INTERRUPT(59) \
|
|
DECLARE_INTERRUPT(60) \
|
|
DECLARE_INTERRUPT(61) \
|
|
DECLARE_INTERRUPT(62) \
|
|
DECLARE_INTERRUPT(63) \
|
|
DECLARE_INTERRUPT(64) \
|
|
DECLARE_INTERRUPT(65) \
|
|
DECLARE_INTERRUPT(66) \
|
|
DECLARE_INTERRUPT(67) \
|
|
DECLARE_INTERRUPT(68) \
|
|
DECLARE_INTERRUPT(69) \
|
|
DECLARE_INTERRUPT(70) \
|
|
DECLARE_INTERRUPT(71) \
|
|
DECLARE_INTERRUPT(72) \
|
|
DECLARE_INTERRUPT(73) \
|
|
DECLARE_INTERRUPT(74) \
|
|
DECLARE_INTERRUPT(75) \
|
|
DECLARE_INTERRUPT(76) \
|
|
DECLARE_INTERRUPT(77) \
|
|
DECLARE_INTERRUPT(78) \
|
|
DECLARE_INTERRUPT(79) \
|
|
DECLARE_INTERRUPT(80) \
|
|
DECLARE_INTERRUPT(81) \
|
|
DECLARE_INTERRUPT(82) \
|
|
DECLARE_INTERRUPT(83) \
|
|
DECLARE_INTERRUPT(84) \
|
|
DECLARE_INTERRUPT(85) \
|
|
DECLARE_INTERRUPT(86) \
|
|
DECLARE_INTERRUPT(87) \
|
|
DECLARE_INTERRUPT(88) \
|
|
DECLARE_INTERRUPT(89) \
|
|
DECLARE_INTERRUPT(90) \
|
|
DECLARE_INTERRUPT(91) \
|
|
DECLARE_INTERRUPT(92) \
|
|
DECLARE_INTERRUPT(93) \
|
|
DECLARE_INTERRUPT(94) \
|
|
DECLARE_INTERRUPT(95) \
|
|
DECLARE_INTERRUPT(97) \
|
|
DECLARE_INTERRUPT(96) \
|
|
DECLARE_INTERRUPT(98) \
|
|
DECLARE_INTERRUPT(99) \
|
|
DECLARE_INTERRUPT(100) \
|
|
DECLARE_INTERRUPT(101) \
|
|
DECLARE_INTERRUPT(102) \
|
|
DECLARE_INTERRUPT(103) \
|
|
DECLARE_INTERRUPT(104) \
|
|
DECLARE_INTERRUPT(105) \
|
|
DECLARE_INTERRUPT(106) \
|
|
DECLARE_INTERRUPT(107) \
|
|
DECLARE_INTERRUPT(108) \
|
|
DECLARE_INTERRUPT(109) \
|
|
DECLARE_INTERRUPT(110) \
|
|
DECLARE_INTERRUPT(111) \
|
|
DECLARE_INTERRUPT(112) \
|
|
DECLARE_INTERRUPT(113) \
|
|
DECLARE_INTERRUPT(114) \
|
|
DECLARE_INTERRUPT(115) \
|
|
DECLARE_INTERRUPT(116) \
|
|
DECLARE_INTERRUPT(117) \
|
|
DECLARE_INTERRUPT(118) \
|
|
DECLARE_INTERRUPT(119) \
|
|
DECLARE_INTERRUPT(120) \
|
|
DECLARE_INTERRUPT(121) \
|
|
DECLARE_INTERRUPT(122) \
|
|
DECLARE_INTERRUPT(123) \
|
|
DECLARE_INTERRUPT(124) \
|
|
DECLARE_INTERRUPT(125) \
|
|
DECLARE_INTERRUPT(126) \
|
|
DECLARE_INTERRUPT(127) \
|
|
DECLARE_INTERRUPT(128) \
|
|
DECLARE_INTERRUPT(129) \
|
|
DECLARE_INTERRUPT(130) \
|
|
DECLARE_INTERRUPT(131) \
|
|
DECLARE_INTERRUPT(132) \
|
|
DECLARE_INTERRUPT(133) \
|
|
DECLARE_INTERRUPT(134) \
|
|
DECLARE_INTERRUPT(135) \
|
|
DECLARE_INTERRUPT(136) \
|
|
DECLARE_INTERRUPT(137) \
|
|
DECLARE_INTERRUPT(138) \
|
|
DECLARE_INTERRUPT(139) \
|
|
DECLARE_INTERRUPT(140) \
|
|
DECLARE_INTERRUPT(141) \
|
|
DECLARE_INTERRUPT(142) \
|
|
DECLARE_INTERRUPT(143) \
|
|
DECLARE_INTERRUPT(144) \
|
|
DECLARE_INTERRUPT(145) \
|
|
DECLARE_INTERRUPT(146) \
|
|
DECLARE_INTERRUPT(147) \
|
|
DECLARE_INTERRUPT(148) \
|
|
DECLARE_INTERRUPT(149) \
|
|
DECLARE_INTERRUPT(150) \
|
|
DECLARE_INTERRUPT(151) \
|
|
DECLARE_INTERRUPT(152) \
|
|
DECLARE_INTERRUPT(153) \
|
|
DECLARE_INTERRUPT(154) \
|
|
DECLARE_INTERRUPT(155) \
|
|
DECLARE_INTERRUPT(156) \
|
|
DECLARE_INTERRUPT(157) \
|
|
DECLARE_INTERRUPT(158) \
|
|
DECLARE_INTERRUPT(159) \
|
|
DECLARE_INTERRUPT(160) \
|
|
DECLARE_INTERRUPT(161) \
|
|
DECLARE_INTERRUPT(162) \
|
|
DECLARE_INTERRUPT(163) \
|
|
DECLARE_INTERRUPT(164) \
|
|
DECLARE_INTERRUPT(165) \
|
|
DECLARE_INTERRUPT(166) \
|
|
DECLARE_INTERRUPT(167) \
|
|
DECLARE_INTERRUPT(168) \
|
|
DECLARE_INTERRUPT(169) \
|
|
DECLARE_INTERRUPT(170) \
|
|
DECLARE_INTERRUPT(171) \
|
|
DECLARE_INTERRUPT(172) \
|
|
DECLARE_INTERRUPT(173) \
|
|
DECLARE_INTERRUPT(174) \
|
|
DECLARE_INTERRUPT(175) \
|
|
DECLARE_INTERRUPT(176) \
|
|
DECLARE_INTERRUPT(177) \
|
|
DECLARE_INTERRUPT(178) \
|
|
DECLARE_INTERRUPT(179) \
|
|
DECLARE_INTERRUPT(180) \
|
|
DECLARE_INTERRUPT(181) \
|
|
DECLARE_INTERRUPT(182) \
|
|
DECLARE_INTERRUPT(183) \
|
|
DECLARE_INTERRUPT(184) \
|
|
DECLARE_INTERRUPT(185) \
|
|
DECLARE_INTERRUPT(186) \
|
|
DECLARE_INTERRUPT(187) \
|
|
DECLARE_INTERRUPT(188) \
|
|
DECLARE_INTERRUPT(189) \
|
|
DECLARE_INTERRUPT(190) \
|
|
DECLARE_INTERRUPT(191) \
|
|
DECLARE_INTERRUPT(192) \
|
|
DECLARE_INTERRUPT(193) \
|
|
DECLARE_INTERRUPT(194) \
|
|
DECLARE_INTERRUPT(195) \
|
|
DECLARE_INTERRUPT(196) \
|
|
DECLARE_INTERRUPT(197) \
|
|
DECLARE_INTERRUPT(198) \
|
|
DECLARE_INTERRUPT(199) \
|
|
DECLARE_INTERRUPT(200) \
|
|
DECLARE_INTERRUPT(201) \
|
|
DECLARE_INTERRUPT(202) \
|
|
DECLARE_INTERRUPT(203) \
|
|
DECLARE_INTERRUPT(204) \
|
|
DECLARE_INTERRUPT(205) \
|
|
DECLARE_INTERRUPT(206) \
|
|
DECLARE_INTERRUPT(207) \
|
|
DECLARE_INTERRUPT(208) \
|
|
DECLARE_INTERRUPT(209) \
|
|
DECLARE_INTERRUPT(210) \
|
|
DECLARE_INTERRUPT(211) \
|
|
DECLARE_INTERRUPT(212) \
|
|
DECLARE_INTERRUPT(213) \
|
|
DECLARE_INTERRUPT(214) \
|
|
DECLARE_INTERRUPT(215) \
|
|
DECLARE_INTERRUPT(216) \
|
|
DECLARE_INTERRUPT(217) \
|
|
DECLARE_INTERRUPT(218) \
|
|
DECLARE_INTERRUPT(219) \
|
|
DECLARE_INTERRUPT(220) \
|
|
DECLARE_INTERRUPT(221) \
|
|
DECLARE_INTERRUPT(222) \
|
|
DECLARE_INTERRUPT(223) \
|
|
DECLARE_INTERRUPT(224) \
|
|
DECLARE_INTERRUPT(225) \
|
|
DECLARE_INTERRUPT(226) \
|
|
DECLARE_INTERRUPT(227) \
|
|
DECLARE_INTERRUPT(228) \
|
|
DECLARE_INTERRUPT(229) \
|
|
DECLARE_INTERRUPT(230) \
|
|
DECLARE_INTERRUPT(231) \
|
|
DECLARE_INTERRUPT(232) \
|
|
DECLARE_INTERRUPT(233) \
|
|
DECLARE_INTERRUPT(234) \
|
|
DECLARE_INTERRUPT(235) \
|
|
DECLARE_INTERRUPT(236) \
|
|
DECLARE_INTERRUPT(237) \
|
|
DECLARE_INTERRUPT(238) \
|
|
DECLARE_INTERRUPT(239) \
|
|
DECLARE_INTERRUPT(240) \
|
|
DECLARE_INTERRUPT(241) \
|
|
DECLARE_INTERRUPT(242) \
|
|
DECLARE_INTERRUPT(243) \
|
|
DECLARE_INTERRUPT(244) \
|
|
DECLARE_INTERRUPT(245) \
|
|
DECLARE_INTERRUPT(246) \
|
|
DECLARE_INTERRUPT(247) \
|
|
DECLARE_INTERRUPT(248) \
|
|
DECLARE_INTERRUPT(249) \
|
|
DECLARE_INTERRUPT(250) \
|
|
DECLARE_INTERRUPT(251) \
|
|
DECLARE_INTERRUPT(252) \
|
|
DECLARE_INTERRUPT(253) \
|
|
DECLARE_INTERRUPT(254) \
|
|
DECLARE_INTERRUPT(255));
|