OpenCores
URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [or32/] [kernel/] [irq.c] - Blame information for rev 7

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 7 xianfeng 
/*
2 
 *  linux/arch/or32/kernel/irq.c
3 
 *
4 
 *  or32 version
5 
 *    author(s): Matjaz Breskvar (phoenix@bsemi.com)
6 
 *
7 
 *  derived from cris, i386, m68k, ppc, sh ports.
8 
 *
9 
 *  changes:
10 
 *  18. 11. 2003: Matjaz Breskvar (phoenix@bsemi.com)
11 
 *    initial port to or32 architecture
12 
 *
13 
 */
14 
 
15 
#include <linux/ptrace.h>
16 
#include <linux/errno.h>
17 
#include <linux/kernel_stat.h>
18 
#include <linux/signal.h>
19 
#include <linux/sched.h>
20 
#include <linux/ioport.h>
21 
#include <linux/interrupt.h>
22 
#include <linux/timex.h>
23 
#include <linux/slab.h>
24 
#include <linux/random.h>
25 
#include <linux/init.h>
26 
 
27 
#include <asm/system.h>
28 
#include <asm/io.h>
29 
#include <asm/irq.h>
30 
#include <asm/bitops.h>
31 
#include <asm/page.h>
32 
#include <asm/machdep.h>
33 
#include <asm/or32-hf.h>
34 
 
35 
/* table for system interrupt handlers */
36 
static or_irq_handler_t irq_list[NR_IRQS]; /*RGD*/
37 
 
38 
static const char *default_names[NR_IRQS] = {
39 
        "int0", "int1", "int2", "int3", "int4", "int5", "int6", "int7"
40 
        "int8", "int9", "int10", "int11", "int12", "int13", "int14", "int15"
41 
        "int16", "int17", "int18", "int19", "int20", "int21", "int22", "int23"
42 
        "int24", "int25", "int26", "int27", "int28", "int29", "int30", "int31"
43 
};
44 
 
45 
int pic_enable_irq(unsigned int irq)
46 
{
47 
        /* Enable in the IMR */
48 
        mtspr(SPR_PICMR, mfspr(SPR_PICMR) | (0x00000001L << irq));
49 
 
50 
        return 0;
51 
}
52 
 
53 
int pic_disable_irq(unsigned int irq)
54 
{
55 
        /* Disable in the IMR */
56 
        mtspr(SPR_PICMR, mfspr(SPR_PICMR) & ~(0x00000001L << irq));
57 
 
58 
        return 0;
59 
}
60 
 
61 
int pic_init(void)
62 
{
63 
        /* turn off all interrupts */
64 
        mtspr(SPR_PICMR, 0);
65 
        return 0;
66 
}
67 
 
68 
int pic_do_irq(struct pt_regs *fp)
69 
{
70 
        int irq;
71 
        int mask;
72 
 
73 
        unsigned long pend = mfspr(SPR_PICSR) & 0xfffffffc;
74 
 
75 
        if (pend & 0x0000ffff) {
76 
                if (pend & 0x000000ff) {
77 
                        if (pend & 0x0000000f) {
78 
                                mask = 0x00000001;
79 
                                irq = 0;
80 
                        } else {
81 
                                mask = 0x00000010;
82 
                                irq = 4;
83 
                        }
84 
                } else {
85 
                        if (pend & 0x00000f00) {
86 
                                mask = 0x00000100;
87 
                                irq = 8;
88 
                        } else {
89 
                                mask = 0x00001000;
90 
                                irq = 12;
91 
                        }
92 
                }
93 
        } else if(pend & 0xffff0000) {
94 
                if (pend & 0x00ff0000) {
95 
                        if (pend & 0x000f0000) {
96 
                                mask = 0x00010000;
97 
                                irq = 16;
98 
                        } else {
99 
                                mask = 0x00100000;
100 
                                irq = 20;
101 
                        }
102 
                } else {
103 
                        if (pend & 0x0f000000) {
104 
                                mask = 0x01000000;
105 
                                irq = 24;
106 
                        } else {
107 
                                mask = 0x10000000;
108 
                                irq = 28;
109 
                        }
110 
                }
111 
        } else {
112 
                return -1;
113 
        }
114 
 
115 
        while (! (mask & pend)) {
116 
                mask <<=1;
117 
                irq++;
118 
        }
119 
 
120 
//      mtspr(SPR_PICSR, mfspr(SPR_PICSR) & ~mask);
121 
        return irq;
122 
}
123 
 
124 
void init_IRQ(void)
125 
{
126 
        int i;
127 
 
128 
        for (i = 0; i < NR_IRQS; i++) {
129 
                irq_list[i].handler = NULL;
130 
                irq_list[i].flags   = IRQ_FLG_STD;
131 
                irq_list[i].dev_id  = NULL;
132 
                irq_list[i].devname = default_names[i];
133 
        }
134 
 
135 
        pic_init();
136 
        mtspr(SPR_SR, mfspr(SPR_SR) | SPR_SR_IEE);
137 
}
138 
 
139 
 
140 
int show_interrupts(struct seq_file *p, void *v)
141 
{
142 
        phx_warn("NOT implemented yet");
143 
#if 0
144 
        int i = *(loff_t *) v;
145 
        struct irqaction * action;
146 
        unsigned long flags;
147 
 
148 
        if (i < NR_IRQS) {
149 
                local_irq_save(flags);
150 
                action = irq_action[i];
151 
                if (!action)
152 
                        goto skip;
153 
                seq_printf(p, "%2d: %10u %c %s",
154 
                           i, kstat_cpu(0).irqs[i],
155 
                           (action->flags & SA_INTERRUPT) ? '+' : ' ',
156 
                           action->name);
157 
                for (action = action->next; action; action = action->next) {
158 
                        seq_printf(p, ",%s %s",
159 
                                   (action->flags & SA_INTERRUPT) ? " +" : "",
160 
                                   action->name);
161 
                }
162 
                seq_putc(p, '\n');
163 
        skip:
164 
                local_irq_restore(flags);
165 
        }
166 
#endif
167 
        return 0;
168 
}
169 
 
170 
asmlinkage void do_IRQ(struct pt_regs *regs)
171 
{
172 
        int irq;
173 
        int cpu;
174 
        unsigned long flags;
175 
 
176 
//      printk("x");
177 
        irq_enter();
178 
        local_irq_save(flags);
179 
 
180 
        check_stack(NULL, __FILE__, __FUNCTION__, __LINE__);
181 
        cpu = smp_processor_id();
182 
 
183 
        while((irq = pic_do_irq(regs)) >= 0) {
184 
//              printk("*");
185 
//              mtspr(SPR_PICMR, mfspr(SPR_PICMR) & ~(1UL << irq));
186 
 
187 
                if (irq_list[irq].handler)
188 
                        irq_list[irq].handler(irq, irq_list[irq].dev_id, regs);
189 
                else
190 
                        panic("No interrupt handler for autovector %d\n", irq);
191 
//              mtspr(SPR_PICMR, mfspr(SPR_PICMR) | (1UL << irq));
192 
                mtspr(SPR_PICSR, mfspr(SPR_PICSR) & ~(1UL << irq));
193 
 
194 
        }
195 
        local_irq_restore(flags);
196 
 
197 
        irq_exit();
198 
}
199 
 
200 
int request_irq(unsigned int irq,
201 
                irqreturn_t (*handler)(int, void *), /*RGD removed pt_reg*/
202 
                unsigned long flags, const char *devname, void *dev_id)
203 
{
204 
        if (irq >= NR_IRQS) {
205 
                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
206 
                return -ENXIO;
207 
        }
208 
 
209 
        if (!(irq_list[irq].flags & IRQ_FLG_STD)) {
210 
                if (irq_list[irq].flags & IRQ_FLG_LOCK) {
211 
                        printk("%s: IRQ %d from %s is not replaceable\n",
212 
                               __FUNCTION__, irq, irq_list[irq].devname);
213 
                        return -EBUSY;
214 
                }
215 
                if (flags & IRQ_FLG_REPLACE) {
216 
                        printk("%s: %s can't replace IRQ %d from %s\n",
217 
                               __FUNCTION__, devname, irq, irq_list[irq].devname);
218 
                        return -EBUSY;
219 
                }
220 
        }
221 
        irq_list[irq].handler = handler;
222 
        irq_list[irq].flags   = flags;
223 
        irq_list[irq].dev_id  = dev_id;
224 
        irq_list[irq].devname = devname;
225 
 
226 
        pic_enable_irq(irq);
227 
 
228 
        return 0;
229 
}
230 
 
231 
void free_irq(unsigned int irq, void *dev_id)
232 
{
233 
        if (irq >= NR_IRQS) {
234 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
235 
                return;
236 
        }
237 
 
238 
        pic_disable_irq(irq);
239 
 
240 
        irq_list[irq].handler = NULL;
241 
        irq_list[irq].flags   = IRQ_FLG_STD;
242 
        irq_list[irq].dev_id  = NULL;
243 
        irq_list[irq].devname = default_names[irq];
244 
}
245 
 
246 
unsigned long probe_irq_on (void)
247 
{
248 
        return 0;
249 
}
250 
 
251 
int probe_irq_off (unsigned long irqs)
252 
{
253 
        return 0;
254 
}
255 
 
256 
void enable_irq(unsigned int irq)
257 
{
258 
        if (irq >= NR_IRQS) {
259 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
260 
                return;
261 
        }
262 
        pic_enable_irq(irq);
263 
}
264 
 
265 
void disable_irq(unsigned int irq)
266 
{
267 
        if (irq >= NR_IRQS) {
268 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
269 
                return;
270 
        }
271 
        pic_disable_irq(irq);
272 
}
273 
 
274 
int get_irq_list(char *buf)
275 
{
276 
        int i, len = 0;
277 
 
278 
        /* autovector interrupts */
279 
        for (i = 0; i < NR_IRQS; i++) {
280 
                if (irq_list[i].handler) {
281 
                        if (irq_list[i].flags & IRQ_FLG_LOCK)
282 
                                len += sprintf(buf+len, "L ");
283 
                        else
284 
                                len += sprintf(buf+len, "  ");
285 
                        if (irq_list[i].flags & IRQ_FLG_PRI_HI)
286 
                                len += sprintf(buf+len, "H ");
287 
                        else
288 
                                len += sprintf(buf+len, "L ");
289 
                        len += sprintf(buf+len, "%s\n", irq_list[i].devname);
290 
                }
291 
        }
292 
 
293 
        return len;
294 
}
295 
 
296 
#if 0
297 
void dump(struct pt_regs *fp)
298 
{
299 
        unsigned long   *sp;
300 
        unsigned char   *tp;
301 
        int             i;
302 
 
303 
        printk("\nCURRENT PROCESS:\n\n");
304 
        printk("COMM=%s PID=%d\n", current->comm, current->pid);
305 
        if (current->mm) {
306 
                printk("TEXT=%08x-%08x DATA=%08x-%08x BSS=%08x-%08x\n",
307 
                        (int) current->mm->start_code,
308 
                        (int) current->mm->end_code,
309 
                        (int) current->mm->start_data,
310 
                        (int) current->mm->end_data,
311 
                        (int) current->mm->end_data,
312 
                        (int) current->mm->brk);
313 
                printk("USER-STACK=%08x  KERNEL-STACK=%08x\n\n",
314 
                        (int) current->mm->start_stack,
315 
                        (int) current->kernel_stack_page);
316 
        }
317 
        printk("PC: %08lx  Status: %08lx\n",
318 
               fp->pc, fp->sr);
319 
        printk("R0 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
320 
                0L,             fp->sp,      fp->gprs[0], fp->gprs[1],
321 
                fp->gprs[2], fp->gprs[3], fp->gprs[4], fp->gprs[5]);
322 
        printk("R8 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
323 
                fp->gprs[6], fp->gprs[7], fp->gprs[8], fp->gprs[9],
324 
                fp->gprs[10], fp->gprs[11], fp->gprs[12], fp->gprs[13]);
325 
        printk("R16: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
326 
                fp->gprs[14], fp->gprs[15], fp->gprs[16], fp->gprs[17],
327 
                fp->gprs[18], fp->gprs[19], fp->gprs[20], fp->gprs[21]);
328 
        printk("R24: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
329 
                fp->gprs[22], fp->gprs[23], fp->gprs[24], fp->gprs[25],
330 
                fp->gprs[26], fp->gprs[27], fp->gprs[28], fp->gprs[29]);
331 
 
332 
        printk("\nUSP: %08lx   TRAPFRAME: %08x\n",
333 
                fp->sp, (unsigned int) fp);
334 
 
335 
        printk("\nCODE:");
336 
        tp = ((unsigned char *) fp->pc) - 0x20;
337 
        for (sp = (unsigned long *) tp, i = 0; (i < 0x40);  i += 4) {
338 
                if ((i % 0x10) == 0)
339 
                        printk("\n%08x: ", (int) (tp + i));
340 
                printk("%08x ", (int) *sp++);
341 
        }
342 
        printk("\n");
343 
 
344 
        printk("\nKERNEL STACK:");
345 
        tp = ((unsigned char *) fp) - 0x40;
346 
        for (sp = (unsigned long *) tp, i = 0; (i < 0xc0); i += 4) {
347 
                if ((i % 0x10) == 0)
348 
                        printk("\n%08x: ", (int) (tp + i));
349 
                printk("%08x ", (int) *sp++);
350 
        }
351 
        printk("\n");
352 
        if (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page)
353 
                printk("(Possibly corrupted stack page??)\n");
354 
        printk("\n");
355 
 
356 
        printk("\nUSER STACK:");
357 
        tp = (unsigned char *) (fp->sp - 0x10);
358 
        for (sp = (unsigned long *) tp, i = 0; (i < 0x80); i += 4) {
359 
                if ((i % 0x10) == 0)
360 
                        printk("\n%08x: ", (int) (tp + i));
361 
                printk("%08x ", (int) *sp++);
362 
        }
363 
        printk("\n\n");
364 
}
365 
#endif /* 0 */
366 
 
367 
void init_irq_proc(void)
368 
{
369 
        phx_warn("TODO");
370 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.