]> git.sur5r.net Git - u-boot/blob - cpu/i386/interrupts.c
ads5121: fix compiler warnings (unused variables)
[u-boot] / cpu / i386 / interrupts.c
1 /*
2  * (C) Copyright 2002
3  * Daniel Engström, Omicron Ceti AB, daniel@omicron.se.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <malloc.h>
26 #include <asm/io.h>
27 #include <asm/i8259.h>
28 #include <asm/ibmpc.h>
29
30
31 struct idt_entry {
32         u16     base_low;
33         u16     selector;
34         u8      res;
35         u8      access;
36         u16     base_high;
37 } __attribute__ ((packed));
38
39
40 struct idt_entry idt[256];
41
42
43 #define MAX_IRQ 16
44
45 typedef struct irq_handler {
46         struct irq_handler *next;
47         interrupt_handler_t* isr_func;
48         void *isr_data;
49 } irq_handler_t;
50
51 #define IRQ_DISABLED   1
52
53 typedef struct {
54         irq_handler_t *handler;
55         unsigned long status;
56 } irq_desc_t;
57
58 static irq_desc_t irq_table[MAX_IRQ];
59
60 asm ("irq_return:\n"
61      "     addl  $4, %esp\n"
62      "     popa\n"
63      "     iret\n");
64
65 asm ("exp_return:\n"
66      "     addl  $12, %esp\n"
67      "     pop   %esp\n"
68      "     popa\n"
69      "     iret\n");
70
71 char exception_stack[4096];
72
73 #define DECLARE_INTERRUPT(x) \
74         asm(".globl irq_"#x"\n" \
75                     "irq_"#x":\n" \
76                     "pusha \n" \
77                     "pushl $"#x"\n" \
78                     "pushl $irq_return\n" \
79                     "jmp   do_irq\n"); \
80         void __attribute__ ((regparm(0))) irq_##x(void)
81
82 #define DECLARE_EXCEPTION(x, f) \
83         asm(".globl exp_"#x"\n" \
84                     "exp_"#x":\n" \
85                     "pusha \n" \
86                     "movl     %esp, %ebx\n" \
87                     "movl     $exception_stack, %eax\n" \
88                     "movl     %eax, %esp \n" \
89                     "pushl    %ebx\n" \
90                     "movl     32(%esp), %ebx\n" \
91                     "xorl     %edx, %edx\n" \
92                     "movw     36(%esp), %dx\n" \
93                     "pushl    %edx\n" \
94                     "pushl    %ebx\n" \
95                     "pushl    $"#x"\n" \
96                     "pushl    $exp_return\n" \
97                     "jmp      "#f"\n"); \
98         void __attribute__ ((regparm(0))) exp_##x(void)
99
100 DECLARE_EXCEPTION(0, divide_exception_entry);      /* Divide exception */
101 DECLARE_EXCEPTION(1, debug_exception_entry);       /* Debug exception */
102 DECLARE_EXCEPTION(2, nmi_entry);                   /* NMI */
103 DECLARE_EXCEPTION(3, unknown_exception_entry);     /* Breakpoint/Coprocessor Error */
104 DECLARE_EXCEPTION(4, unknown_exception_entry);     /* Overflow */
105 DECLARE_EXCEPTION(5, unknown_exception_entry);     /* Bounds */
106 DECLARE_EXCEPTION(6, invalid_instruction_entry);   /* Invalid instruction */
107 DECLARE_EXCEPTION(7, unknown_exception_entry);     /* Device not present */
108 DECLARE_EXCEPTION(8, double_fault_entry);          /* Double fault */
109 DECLARE_EXCEPTION(9, unknown_exception_entry);     /* Co-processor segment overrun */
110 DECLARE_EXCEPTION(10, invalid_tss_exception_entry);/* Invalid TSS */
111 DECLARE_EXCEPTION(11, seg_fault_entry);            /* Segment not present */
112 DECLARE_EXCEPTION(12, stack_fault_entry);          /* Stack overflow */
113 DECLARE_EXCEPTION(13, gpf_entry);                  /* GPF */
114 DECLARE_EXCEPTION(14, page_fault_entry);           /* PF */
115 DECLARE_EXCEPTION(15, unknown_exception_entry);    /* Reserved */
116 DECLARE_EXCEPTION(16, fp_exception_entry);         /* Floating point */
117 DECLARE_EXCEPTION(17, alignment_check_entry);      /* alignment check */
118 DECLARE_EXCEPTION(18, machine_check_entry);        /* machine check */
119 DECLARE_EXCEPTION(19, unknown_exception_entry);    /* Reserved */
120 DECLARE_EXCEPTION(20, unknown_exception_entry);    /* Reserved */
121 DECLARE_EXCEPTION(21, unknown_exception_entry);    /* Reserved */
122 DECLARE_EXCEPTION(22, unknown_exception_entry);    /* Reserved */
123 DECLARE_EXCEPTION(23, unknown_exception_entry);    /* Reserved */
124 DECLARE_EXCEPTION(24, unknown_exception_entry);    /* Reserved */
125 DECLARE_EXCEPTION(25, unknown_exception_entry);    /* Reserved */
126 DECLARE_EXCEPTION(26, unknown_exception_entry);    /* Reserved */
127 DECLARE_EXCEPTION(27, unknown_exception_entry);    /* Reserved */
128 DECLARE_EXCEPTION(28, unknown_exception_entry);    /* Reserved */
129 DECLARE_EXCEPTION(29, unknown_exception_entry);    /* Reserved */
130 DECLARE_EXCEPTION(30, unknown_exception_entry);    /* Reserved */
131 DECLARE_EXCEPTION(31, unknown_exception_entry);    /* Reserved */
132
133 DECLARE_INTERRUPT(0);
134 DECLARE_INTERRUPT(1);
135 DECLARE_INTERRUPT(3);
136 DECLARE_INTERRUPT(4);
137 DECLARE_INTERRUPT(5);
138 DECLARE_INTERRUPT(6);
139 DECLARE_INTERRUPT(7);
140 DECLARE_INTERRUPT(8);
141 DECLARE_INTERRUPT(9);
142 DECLARE_INTERRUPT(10);
143 DECLARE_INTERRUPT(11);
144 DECLARE_INTERRUPT(12);
145 DECLARE_INTERRUPT(13);
146 DECLARE_INTERRUPT(14);
147 DECLARE_INTERRUPT(15);
148
149 void __attribute__ ((regparm(0))) default_isr(void);
150 asm ("default_isr: iret\n");
151
152 void disable_irq(int irq)
153 {
154         if (irq >= MAX_IRQ) {
155                 return;
156         }
157         irq_table[irq].status |= IRQ_DISABLED;
158
159 }
160
161 void enable_irq(int irq)
162 {
163         if (irq >= MAX_IRQ) {
164                 return;
165         }
166         irq_table[irq].status &= ~IRQ_DISABLED;
167 }
168
169 /* masks one specific IRQ in the PIC */
170 static void unmask_irq(int irq)
171 {
172         int imr_port;
173
174         if (irq >= MAX_IRQ) {
175                 return;
176         }
177         if (irq > 7) {
178                 imr_port = SLAVE_PIC + IMR;
179         } else {
180                 imr_port = MASTER_PIC + IMR;
181         }
182
183         outb(inb(imr_port)&~(1<<(irq&7)), imr_port);
184 }
185
186
187 /* unmasks one specific IRQ in the PIC */
188 static void mask_irq(int irq)
189 {
190         int imr_port;
191
192         if (irq >= MAX_IRQ) {
193                 return;
194         }
195         if (irq > 7) {
196                 imr_port = SLAVE_PIC + IMR;
197         } else {
198                 imr_port = MASTER_PIC + IMR;
199         }
200
201         outb(inb(imr_port)|(1<<(irq&7)), imr_port);
202 }
203
204
205 /* issue a Specific End Of Interrupt instruciton */
206 static void specific_eoi(int irq)
207 {
208         /* If it is on the slave PIC this have to be performed on
209          * both the master and the slave PICs */
210         if (irq > 7) {
211                 outb(OCW2_SEOI|(irq&7), SLAVE_PIC + OCW2);
212                 irq = SEOI_IR2;               /* also do IR2 on master */
213         }
214         outb(OCW2_SEOI|irq, MASTER_PIC + OCW2);
215 }
216
217 void __attribute__ ((regparm(0))) do_irq(int irq)
218 {
219
220         mask_irq(irq);
221
222         if (irq_table[irq].status & IRQ_DISABLED) {
223                 unmask_irq(irq);
224                 specific_eoi(irq);
225                 return;
226         }
227
228
229         if (NULL != irq_table[irq].handler) {
230                 irq_handler_t *handler;
231                 for (handler = irq_table[irq].handler;
232                      NULL!= handler; handler = handler->next) {
233                         handler->isr_func(handler->isr_data);
234                 }
235         } else {
236                 if ((irq & 7) != 7) {
237                         printf("Spurious irq %d\n", irq);
238                 }
239         }
240         unmask_irq(irq);
241         specific_eoi(irq);
242 }
243
244
245 void __attribute__ ((regparm(0))) unknown_exception_entry(int cause, int ip, int seg)
246 {
247         printf("Unknown Exception %d at %04x:%08x\n", cause, seg, ip);
248 }
249
250 void __attribute__ ((regparm(0))) divide_exception_entry(int cause, int ip, int seg)
251 {
252         printf("Divide Error (Division by zero) at %04x:%08x\n", seg, ip);
253         while(1);
254 }
255
256 void __attribute__ ((regparm(0))) debug_exception_entry(int cause, int ip, int seg)
257 {
258         printf("Debug Interrupt (Single step) at %04x:%08x\n", seg, ip);
259 }
260
261 void __attribute__ ((regparm(0))) nmi_entry(int cause, int ip, int seg)
262 {
263         printf("NMI Interrupt at %04x:%08x\n", seg, ip);
264 }
265
266 void __attribute__ ((regparm(0))) invalid_instruction_entry(int cause, int ip, int seg)
267 {
268         printf("Invalid Instruction at %04x:%08x\n", seg, ip);
269         while(1);
270 }
271
272 void __attribute__ ((regparm(0))) double_fault_entry(int cause, int ip, int seg)
273 {
274         printf("Double fault at %04x:%08x\n", seg, ip);
275         while(1);
276 }
277
278 void __attribute__ ((regparm(0))) invalid_tss_exception_entry(int cause, int ip, int seg)
279 {
280         printf("Invalid TSS at %04x:%08x\n", seg, ip);
281 }
282
283 void __attribute__ ((regparm(0))) seg_fault_entry(int cause, int ip, int seg)
284 {
285         printf("Segmentation fault at %04x:%08x\n", seg, ip);
286         while(1);
287 }
288
289 void __attribute__ ((regparm(0))) stack_fault_entry(int cause, int ip, int seg)
290 {
291         printf("Stack fault at %04x:%08x\n", seg, ip);
292         while(1);
293 }
294
295 void __attribute__ ((regparm(0))) gpf_entry(int cause, int ip, int seg)
296 {
297         printf("General protection fault at %04x:%08x\n", seg, ip);
298 }
299
300 void __attribute__ ((regparm(0))) page_fault_entry(int cause, int ip, int seg)
301 {
302         printf("Page fault at %04x:%08x\n", seg, ip);
303         while(1);
304 }
305
306 void __attribute__ ((regparm(0))) fp_exception_entry(int cause, int ip, int seg)
307 {
308         printf("Floating point exception at %04x:%08x\n", seg, ip);
309 }
310
311 void __attribute__ ((regparm(0))) alignment_check_entry(int cause, int ip, int seg)
312 {
313         printf("Alignment check at %04x:%08x\n", seg, ip);
314 }
315
316 void __attribute__ ((regparm(0))) machine_check_entry(int cause, int ip, int seg)
317 {
318         printf("Machine check exception at %04x:%08x\n", seg, ip);
319 }
320
321
322 void irq_install_handler(int ino, interrupt_handler_t *func, void *pdata)
323 {
324         int status;
325
326         if (ino>MAX_IRQ) {
327                 return;
328         }
329
330         if (NULL != irq_table[ino].handler) {
331                 return;
332         }
333
334         status = disable_interrupts();
335         irq_table[ino].handler = malloc(sizeof(irq_handler_t));
336         if (NULL == irq_table[ino].handler) {
337                 return;
338         }
339
340         memset(irq_table[ino].handler, 0, sizeof(irq_handler_t));
341
342         irq_table[ino].handler->isr_func = func;
343         irq_table[ino].handler->isr_data = pdata;
344         if (status) {
345                 enable_interrupts();
346         }
347
348         unmask_irq(ino);
349
350         return;
351 }
352
353 void irq_free_handler(int ino)
354 {
355         int status;
356         if (ino>MAX_IRQ) {
357                 return;
358         }
359
360         status = disable_interrupts();
361         mask_irq(ino);
362         if (NULL == irq_table[ino].handler) {
363                 return;
364         }
365         free(irq_table[ino].handler);
366         irq_table[ino].handler=NULL;
367         if (status) {
368                 enable_interrupts();
369         }
370         return;
371 }
372
373
374 asm ("idt_ptr:\n"
375         ".word  0x800\n" /* size of the table 8*256 bytes */
376         ".long  idt\n"   /* offset */
377         ".word  0x18\n");/* data segment */
378
379 static void set_vector(int intnum, void *routine)
380 {
381         idt[intnum].base_high = (u16)((u32)(routine)>>16);
382         idt[intnum].base_low = (u16)((u32)(routine)&0xffff);
383 }
384
385
386 int interrupt_init(void)
387 {
388         int i;
389
390         /* Just in case... */
391         disable_interrupts();
392
393         /* Initialize the IDT and stuff */
394
395
396         memset(irq_table, 0, sizeof(irq_table));
397
398         /* Setup the IDT */
399         for (i=0;i<256;i++) {
400                 idt[i].access = 0x8e;
401                 idt[i].res = 0;
402                 idt[i].selector = 0x10;
403                 set_vector(i, default_isr);
404         }
405
406         asm ("cs lidt idt_ptr\n");
407
408         /* Setup exceptions */
409         set_vector(0x00, exp_0);
410         set_vector(0x01, exp_1);
411         set_vector(0x02, exp_2);
412         set_vector(0x03, exp_3);
413         set_vector(0x04, exp_4);
414         set_vector(0x05, exp_5);
415         set_vector(0x06, exp_6);
416         set_vector(0x07, exp_7);
417         set_vector(0x08, exp_8);
418         set_vector(0x09, exp_9);
419         set_vector(0x0a, exp_10);
420         set_vector(0x0b, exp_11);
421         set_vector(0x0c, exp_12);
422         set_vector(0x0d, exp_13);
423         set_vector(0x0e, exp_14);
424         set_vector(0x0f, exp_15);
425         set_vector(0x10, exp_16);
426         set_vector(0x11, exp_17);
427         set_vector(0x12, exp_18);
428         set_vector(0x13, exp_19);
429         set_vector(0x14, exp_20);
430         set_vector(0x15, exp_21);
431         set_vector(0x16, exp_22);
432         set_vector(0x17, exp_23);
433         set_vector(0x18, exp_24);
434         set_vector(0x19, exp_25);
435         set_vector(0x1a, exp_26);
436         set_vector(0x1b, exp_27);
437         set_vector(0x1c, exp_28);
438         set_vector(0x1d, exp_29);
439         set_vector(0x1e, exp_30);
440         set_vector(0x1f, exp_31);
441
442
443         /* Setup interrupts */
444         set_vector(0x20, irq_0);
445         set_vector(0x21, irq_1);
446         set_vector(0x23, irq_3);
447         set_vector(0x24, irq_4);
448         set_vector(0x25, irq_5);
449         set_vector(0x26, irq_6);
450         set_vector(0x27, irq_7);
451         set_vector(0x28, irq_8);
452         set_vector(0x29, irq_9);
453         set_vector(0x2a, irq_10);
454         set_vector(0x2b, irq_11);
455         set_vector(0x2c, irq_12);
456         set_vector(0x2d, irq_13);
457         set_vector(0x2e, irq_14);
458         set_vector(0x2f, irq_15);
459         /* vectors 0x30-0x3f are reserved for irq 16-31 */
460
461
462         /* Mask all interrupts */
463         outb(0xff, MASTER_PIC + IMR);
464         outb(0xff, SLAVE_PIC + IMR);
465
466         /* Master PIC */
467         outb(ICW1_SEL|ICW1_EICW4, MASTER_PIC + ICW1);
468         outb(0x20, MASTER_PIC + ICW2);          /* Place master PIC interrupts at INT20 */
469         outb(IR2, MASTER_PIC + ICW3);           /* ICW3, One slevc PIC is present */
470         outb(ICW4_PM, MASTER_PIC + ICW4);
471
472         for (i=0;i<8;i++) {
473                 outb(OCW2_SEOI|i, MASTER_PIC + OCW2);
474         }
475
476         /* Slave PIC */
477         outb(ICW1_SEL|ICW1_EICW4, SLAVE_PIC + ICW1);
478         outb(0x28, SLAVE_PIC + ICW2);           /* Place slave PIC interrupts at INT28 */
479         outb(0x02, SLAVE_PIC + ICW3);           /* Slave ID */
480         outb(ICW4_PM, SLAVE_PIC + ICW4);
481
482         for (i=0;i<8;i++) {
483                 outb(OCW2_SEOI|i, SLAVE_PIC + OCW2);
484         }
485
486
487         /* enable cascade interrerupt */
488         outb(0xfb, MASTER_PIC + IMR);
489         outb(0xff, SLAVE_PIC + IMR);
490
491         /* It is now safe to enable interrupts */
492         enable_interrupts();
493
494         return 0;
495 }
496
497 void enable_interrupts(void)
498 {
499         asm("sti\n");
500 }
501
502 int disable_interrupts(void)
503 {
504         long flags;
505
506         asm volatile ("pushfl ; popl %0 ; cli\n" : "=g" (flags) : );
507
508         return (flags&0x200); /* IE flags is bit 9 */
509 }
510
511
512 #ifdef CFG_RESET_GENERIC
513
514 void __attribute__ ((regparm(0))) generate_gpf(void);
515 asm(".globl generate_gpf\n"
516     "generate_gpf:\n"
517     "ljmp   $0x70, $0x47114711\n"); /* segment 0x70 is an arbitrary segment which does not
518                                     * exist */
519 void reset_cpu(ulong addr)
520 {
521         set_vector(13, generate_gpf);  /* general protection fault handler */
522         set_vector(8, generate_gpf);   /* double fault handler */
523         generate_gpf();                /* start the show */
524 }
525 #endif