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 9

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 9 xianfeng 
        //Do not enable IRQ rearly. Xianfeng
137 
        //mtspr(SPR_SR, mfspr(SPR_SR) | SPR_SR_IEE);
138 7 xianfeng 
}
139 
 
140 
 
141 
int show_interrupts(struct seq_file *p, void *v)
142 
{
143 
        phx_warn("NOT implemented yet");
144 
#if 0
145 
        int i = *(loff_t *) v;
146 
        struct irqaction * action;
147 
        unsigned long flags;
148 
 
149 
        if (i < NR_IRQS) {
150 
                local_irq_save(flags);
151 
                action = irq_action[i];
152 
                if (!action)
153 
                        goto skip;
154 
                seq_printf(p, "%2d: %10u %c %s",
155 
                           i, kstat_cpu(0).irqs[i],
156 
                           (action->flags & SA_INTERRUPT) ? '+' : ' ',
157 
                           action->name);
158 
                for (action = action->next; action; action = action->next) {
159 
                        seq_printf(p, ",%s %s",
160 
                                   (action->flags & SA_INTERRUPT) ? " +" : "",
161 
                                   action->name);
162 
                }
163 
                seq_putc(p, '\n');
164 
        skip:
165 
                local_irq_restore(flags);
166 
        }
167 
#endif
168 
        return 0;
169 
}
170 
 
171 
asmlinkage void do_IRQ(struct pt_regs *regs)
172 
{
173 
        int irq;
174 
        int cpu;
175 
        unsigned long flags;
176 
 
177 
//      printk("x");
178 
        irq_enter();
179 
        local_irq_save(flags);
180 
 
181 
        check_stack(NULL, __FILE__, __FUNCTION__, __LINE__);
182 
        cpu = smp_processor_id();
183 
 
184 
        while((irq = pic_do_irq(regs)) >= 0) {
185 
//              printk("*");
186 
//              mtspr(SPR_PICMR, mfspr(SPR_PICMR) & ~(1UL << irq));
187 
 
188 
                if (irq_list[irq].handler)
189 
                        irq_list[irq].handler(irq, irq_list[irq].dev_id, regs);
190 
                else
191 
                        panic("No interrupt handler for autovector %d\n", irq);
192 
//              mtspr(SPR_PICMR, mfspr(SPR_PICMR) | (1UL << irq));
193 
                mtspr(SPR_PICSR, mfspr(SPR_PICSR) & ~(1UL << irq));
194 
 
195 
        }
196 
        local_irq_restore(flags);
197 
 
198 
        irq_exit();
199 
}
200 
 
201 
int request_irq(unsigned int irq,
202 
                irqreturn_t (*handler)(int, void *), /*RGD removed pt_reg*/
203 
                unsigned long flags, const char *devname, void *dev_id)
204 
{
205 
        if (irq >= NR_IRQS) {
206 
                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
207 
                return -ENXIO;
208 
        }
209 
 
210 
        if (!(irq_list[irq].flags & IRQ_FLG_STD)) {
211 
                if (irq_list[irq].flags & IRQ_FLG_LOCK) {
212 
                        printk("%s: IRQ %d from %s is not replaceable\n",
213 
                               __FUNCTION__, irq, irq_list[irq].devname);
214 
                        return -EBUSY;
215 
                }
216 
                if (flags & IRQ_FLG_REPLACE) {
217 
                        printk("%s: %s can't replace IRQ %d from %s\n",
218 
                               __FUNCTION__, devname, irq, irq_list[irq].devname);
219 
                        return -EBUSY;
220 
                }
221 
        }
222 
        irq_list[irq].handler = handler;
223 
        irq_list[irq].flags   = flags;
224 
        irq_list[irq].dev_id  = dev_id;
225 
        irq_list[irq].devname = devname;
226 
 
227 
        pic_enable_irq(irq);
228 
 
229 
        return 0;
230 
}
231 
 
232 
void free_irq(unsigned int irq, void *dev_id)
233 
{
234 
        if (irq >= NR_IRQS) {
235 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
236 
                return;
237 
        }
238 
 
239 
        pic_disable_irq(irq);
240 
 
241 
        irq_list[irq].handler = NULL;
242 
        irq_list[irq].flags   = IRQ_FLG_STD;
243 
        irq_list[irq].dev_id  = NULL;
244 
        irq_list[irq].devname = default_names[irq];
245 
}
246 
 
247 
unsigned long probe_irq_on (void)
248 
{
249 
        return 0;
250 
}
251 
 
252 
int probe_irq_off (unsigned long irqs)
253 
{
254 
        return 0;
255 
}
256 
 
257 
void enable_irq(unsigned int irq)
258 
{
259 
        if (irq >= NR_IRQS) {
260 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
261 
                return;
262 
        }
263 
        pic_enable_irq(irq);
264 
}
265 
 
266 
void disable_irq(unsigned int irq)
267 
{
268 
        if (irq >= NR_IRQS) {
269 
                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
270 
                return;
271 
        }
272 
        pic_disable_irq(irq);
273 
}
274 
 
275 
int get_irq_list(char *buf)
276 
{
277 
        int i, len = 0;
278 
 
279 
        /* autovector interrupts */
280 
        for (i = 0; i < NR_IRQS; i++) {
281 
                if (irq_list[i].handler) {
282 
                        if (irq_list[i].flags & IRQ_FLG_LOCK)
283 
                                len += sprintf(buf+len, "L ");
284 
                        else
285 
                                len += sprintf(buf+len, "  ");
286 
                        if (irq_list[i].flags & IRQ_FLG_PRI_HI)
287 
                                len += sprintf(buf+len, "H ");
288 
                        else
289 
                                len += sprintf(buf+len, "L ");
290 
                        len += sprintf(buf+len, "%s\n", irq_list[i].devname);
291 
                }
292 
        }
293 
 
294 
        return len;
295 
}
296 
 
297 
#if 0
298 
void dump(struct pt_regs *fp)
299 
{
300 
        unsigned long   *sp;
301 
        unsigned char   *tp;
302 
        int             i;
303 
 
304 
        printk("\nCURRENT PROCESS:\n\n");
305 
        printk("COMM=%s PID=%d\n", current->comm, current->pid);
306 
        if (current->mm) {
307 
                printk("TEXT=%08x-%08x DATA=%08x-%08x BSS=%08x-%08x\n",
308 
                        (int) current->mm->start_code,
309 
                        (int) current->mm->end_code,
310 
                        (int) current->mm->start_data,
311 
                        (int) current->mm->end_data,
312 
                        (int) current->mm->end_data,
313 
                        (int) current->mm->brk);
314 
                printk("USER-STACK=%08x  KERNEL-STACK=%08x\n\n",
315 
                        (int) current->mm->start_stack,
316 
                        (int) current->kernel_stack_page);
317 
        }
318 
        printk("PC: %08lx  Status: %08lx\n",
319 
               fp->pc, fp->sr);
320 
        printk("R0 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
321 
                0L,             fp->sp,      fp->gprs[0], fp->gprs[1],
322 
                fp->gprs[2], fp->gprs[3], fp->gprs[4], fp->gprs[5]);
323 
        printk("R8 : %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
324 
                fp->gprs[6], fp->gprs[7], fp->gprs[8], fp->gprs[9],
325 
                fp->gprs[10], fp->gprs[11], fp->gprs[12], fp->gprs[13]);
326 
        printk("R16: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
327 
                fp->gprs[14], fp->gprs[15], fp->gprs[16], fp->gprs[17],
328 
                fp->gprs[18], fp->gprs[19], fp->gprs[20], fp->gprs[21]);
329 
        printk("R24: %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx  %08lx\n",
330 
                fp->gprs[22], fp->gprs[23], fp->gprs[24], fp->gprs[25],
331 
                fp->gprs[26], fp->gprs[27], fp->gprs[28], fp->gprs[29]);
332 
 
333 
        printk("\nUSP: %08lx   TRAPFRAME: %08x\n",
334 
                fp->sp, (unsigned int) fp);
335 
 
336 
        printk("\nCODE:");
337 
        tp = ((unsigned char *) fp->pc) - 0x20;
338 
        for (sp = (unsigned long *) tp, i = 0; (i < 0x40);  i += 4) {
339 
                if ((i % 0x10) == 0)
340 
                        printk("\n%08x: ", (int) (tp + i));
341 
                printk("%08x ", (int) *sp++);
342 
        }
343 
        printk("\n");
344 
 
345 
        printk("\nKERNEL STACK:");
346 
        tp = ((unsigned char *) fp) - 0x40;
347 
        for (sp = (unsigned long *) tp, i = 0; (i < 0xc0); i += 4) {
348 
                if ((i % 0x10) == 0)
349 
                        printk("\n%08x: ", (int) (tp + i));
350 
                printk("%08x ", (int) *sp++);
351 
        }
352 
        printk("\n");
353 
        if (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page)
354 
                printk("(Possibly corrupted stack page??)\n");
355 
        printk("\n");
356 
 
357 
        printk("\nUSER STACK:");
358 
        tp = (unsigned char *) (fp->sp - 0x10);
359 
        for (sp = (unsigned long *) tp, i = 0; (i < 0x80); i += 4) {
360 
                if ((i % 0x10) == 0)
361 
                        printk("\n%08x: ", (int) (tp + i));
362 
                printk("%08x ", (int) *sp++);
363 
        }
364 
        printk("\n\n");
365 
}
366 
#endif /* 0 */
367 
 
368 
void init_irq_proc(void)
369 
{
370 
        phx_warn("TODO");
371 
}

powered by: WebSVN 2.1.0

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