URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [mips/] [kernel/] [entry.S] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1994 - 2000, 2001 by Ralf Baechle
 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
 * Copyright (C) 2001 MIPS Technologies, Inc.
 */
#include 
#include 
#include 
 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
 
 
                .text
                .align  5
                .set    push
                .set    reorder
FEXPORT(ret_from_irq)
FEXPORT(ret_from_exception)
                lw      t0, PT_STATUS(sp)       # returning to kernel mode?
                andi    t0, t0, KU_USER
                beqz    t0, restore_all
 
FEXPORT(ret_from_sys_call)              # here to prevent code duplication
ret_from_schedule:
                mfc0    t0, CP0_STATUS  # need_resched and signals atomic test
                ori     t0, t0, 1
                xori    t0, t0, 1
                mtc0    t0, CP0_STATUS
                SSNOP; SSNOP; SSNOP
 
                lw      v0, TASK_NEED_RESCHED($28)
                lw      v1, TASK_SIGPENDING($28)
                bnez    v0, reschedule
                bnez    v1, signal_return
restore_all:    .set    noat
                RESTORE_ALL_AND_RET
                .set    at
 
/* Put this behind restore_all for the sake of the branch prediction.  */
signal_return:
                .type   signal_return, @function
 
                mfc0    t0, CP0_STATUS
                ori     t0, t0, 1
                mtc0    t0, CP0_STATUS
 
                move    a0, zero
                move    a1, sp
                jal     do_signal
                b       restore_all
 
reschedule:
                jal     schedule
                b       ret_from_schedule
 
/*
 * Common spurious interrupt handler.
 */
                .text
                .align  5
LEAF(spurious_interrupt)
                /*
                 * Someone tried to fool us by sending an interrupt but we
                 * couldn't find a cause for it.
                 */
                lui     t1,%hi(irq_err_count)
                lw      t0,%lo(irq_err_count)(t1)
                addiu   t0,1
                sw      t0,%lo(irq_err_count)(t1)
                j       ret_from_irq
END(spurious_interrupt)
 
                __INIT
 
                .set    reorder
 
NESTED(except_vec1_generic, 0, sp)
                PANIC("Exception vector 1 called")
END(except_vec1_generic)
 
                /*
                 * General exception vector.  Used for all CPUs except R4000
                 * and R4400 SC and MC versions.
                 */
NESTED(except_vec3_generic, 0, sp)
#if R5432_CP0_INTERRUPT_WAR
                mfc0    k0, CP0_INDEX
#endif
                mfc0    k1, CP0_CAUSE
                la      k0, exception_handlers
                andi    k1, k1, 0x7c
                addu    k0, k0, k1
                lw      k0, (k0)
                jr      k0
END(except_vec3_generic)
                .set    at
 
                /* General exception vector R4000 version. */
NESTED(except_vec3_r4000, 0, sp)
                .set    push
                .set    mips3
                .set    noat
                mfc0    k1, CP0_CAUSE
                li      k0, 31<<2
                andi    k1, k1, 0x7c
                .set    noreorder
                beq     k1, k0, handle_vced
                 li     k0, 14<<2
                beq     k1, k0, handle_vcei
                 la     k0, exception_handlers
                .set    reorder
                addu    k0, k0, k1
                lw      k0, (k0)
                jr      k0
 
                /*
                 * Big shit, we now may have two dirty primary cache lines for
                 * the same physical address.  We can savely invalidate the
                 * line pointed to by c0_badvaddr because after return from
                 * this exception handler the load / store will be re-executed.
                 */
handle_vced:
                mfc0    k0, CP0_BADVADDR
                li      k1, -4
                and     k0, k1
                mtc0    zero, CP0_TAGLO
                cache   Index_Store_Tag_D,(k0)
                cache   Hit_Writeback_Inv_SD,(k0)
#ifdef CONFIG_PROC_FS
                lui     k0, %hi(vced_count)
                lw      k1, %lo(vced_count)(k0)
                addiu   k1, 1
                sw      k1, %lo(vced_count)(k0)
#endif
                eret
 
handle_vcei:
                mfc0    k0, CP0_BADVADDR
                cache   Hit_Writeback_Inv_SD, (k0)      # also cleans pi
#ifdef CONFIG_PROC_FS
                lui     k0, %hi(vcei_count)
                lw      k1, %lo(vcei_count)(k0)
                addiu   k1, 1
                sw      k1, %lo(vcei_count)(k0)
#endif
                eret
                .set    pop
END(except_vec3_r4000)
 
                __FINIT
 
/*
 * Build a default exception handler for the exceptions that don't need
 * special handlers.  If you didn't know yet - I *like* playing games with
 * the C preprocessor ...
 */
#define __BUILD_clear_none(exception)
#define __BUILD_clear_sti(exception)                                    \
                STI
#define __BUILD_clear_cli(exception)                                    \
                CLI
#define __BUILD_clear_fpe(exception)                                    \
                cfc1    a1,fcr31;                                       \
                li      a2,~(0x3f<<12);                                 \
                and     a2,a1;                                          \
                ctc1    a2,fcr31;                                       \
                STI
#define __BUILD_clear_ade(exception)                                    \
                .set    reorder;                                        \
                MFC0    t0,CP0_BADVADDR;                                \
                .set    noreorder;                                      \
                REG_S   t0,PT_BVADDR(sp);                               \
                KMODE
#define __BUILD_silent(exception)
 
#define fmt "Got %s at %08lx.\n"
 
#define __BUILD_verbose(exception)                                      \
                la      a1,8f;                                          \
                TEXT    (#exception);                                   \
                REG_L   a2,PT_EPC(sp);                                  \
                PRINT(fmt)
#define __BUILD_count(exception)                                        \
                .set    reorder;                                        \
                lw      t0,exception_count_##exception;                 \
                .set    noreorder;                                      \
                addiu   t0, 1;                                          \
                sw      t0,exception_count_##exception;                 \
                .data;                                                  \
EXPORT(exception_count_##exception);                                    \
                .word   0;                                              \
                .previous;
#define BUILD_HANDLER(exception,handler,clear,verbose)                  \
                .align  5;                                              \
NESTED(handle_##exception, PT_SIZE, sp);                                \
                .set    noat;                                           \
                SAVE_ALL;                                               \
FEXPORT(handle_##exception##_int);                                      \
                __BUILD_clear_##clear(exception);                       \
                .set    at;                                             \
                __BUILD_##verbose(exception);                           \
                jal     do_##handler;                                   \
                 move   a0, sp;                                         \
                j       ret_from_exception;                             \
                 nop;                                                   \
END(handle_##exception)
 
                BUILD_HANDLER(adel,ade,ade,silent)              /* #4  */
                BUILD_HANDLER(ades,ade,ade,silent)              /* #5  */
                BUILD_HANDLER(ibe,be,cli,silent)                /* #6  */
                BUILD_HANDLER(dbe,be,cli,silent)                /* #7  */
                BUILD_HANDLER(bp,bp,sti,silent)                 /* #9  */
                BUILD_HANDLER(ri,ri,sti,silent)                 /* #10 */
                BUILD_HANDLER(cpu,cpu,sti,silent)               /* #11 */
                BUILD_HANDLER(ov,ov,sti,silent)                 /* #12 */
                BUILD_HANDLER(tr,tr,sti,silent)                 /* #13 */
                BUILD_HANDLER(fpe,fpe,fpe,silent)               /* #15 */
                BUILD_HANDLER(mdmx,mdmx,sti,silent)             /* #22 */
                BUILD_HANDLER(watch,watch,sti,silent)           /* #23 */
                BUILD_HANDLER(mcheck,mcheck,cli,silent)         /* #24 */
                BUILD_HANDLER(reserved,reserved,sti,silent)     /* others */
 
                .set    pop
 
/*
 * Table of syscalls
 */
                .data
                .align  PTRLOG
EXPORT(sys_call_table)
#define SYS(call, narg) PTR call
 
                /* Reserved space for all SVR4 syscalls. */
                .space  (1000)*PTRSIZE
 
#ifdef CONFIG_BINFMT_IRIX
                /* 32bit IRIX5 system calls. */
#include "irix5sys.h"
#else
                .space  (1000)*PTRSIZE          /* No IRIX syscalls */
#endif
 
                /* Reserved space for all the BSD43 and POSIX syscalls. */
                .space  (2000)*PTRSIZE
 
                /* Linux flavoured syscalls. */
#include "syscalls.h"
 
/*
 * Number of arguments of each syscall
 */
EXPORT(sys_narg_table)
#undef SYS
#define SYS(call, narg) .byte narg
 
                /* Reserved space for all SVR4 flavoured syscalls. */
                .space  (1000)
 
#ifdef CONFIG_BINFMT_IRIX
                /* 32bit IRIX5 system calls. */
#include "irix5sys.h"
#else
                .space  (1000)                  /* No IRIX syscalls */
#endif
 
                /* Reserved space for all the BSD43 and POSIX syscalls. */
                .space  (2000)
 
                /* Linux flavoured syscalls. */
#include "syscalls.h"

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [mips/] [kernel/] [entry.S] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* This file is subject to the terms and conditions of the GNU General Public`
3			`* License. See the file "COPYING" in the main directory of this archive`
4			`* for more details.`
5			`*`
6			`* Copyright (C) 1994 - 2000, 2001 by Ralf Baechle`
7			`* Copyright (C) 1999, 2000 Silicon Graphics, Inc.`
8			`* Copyright (C) 2001 MIPS Technologies, Inc.`
9			`*/`
10			`#include`
11			`#include`
12			`#include`
13
14			`#include`
15			`#include`
16			`#include`
17			`#include`
18			`#include`
19			`#include`
20			`#include`
21			`#include`
22			`#include`
23			`#include`
24			`#include`
25			`#include`
26			`#include`
27			`#include`
28
29
30			`.text`
31			`.align 5`
32			`.set push`
33			`.set reorder`
34			`FEXPORT(ret_from_irq)`
35			`FEXPORT(ret_from_exception)`
36			`lw t0, PT_STATUS(sp) # returning to kernel mode?`
37			`andi t0, t0, KU_USER`
38			`beqz t0, restore_all`
39
40			`FEXPORT(ret_from_sys_call) # here to prevent code duplication`
41			`ret_from_schedule:`
42			`mfc0 t0, CP0_STATUS # need_resched and signals atomic test`
43			`ori t0, t0, 1`
44			`xori t0, t0, 1`
45			`mtc0 t0, CP0_STATUS`
46			`SSNOP; SSNOP; SSNOP`
47
48			`lw v0, TASK_NEED_RESCHED($28)`
49			`lw v1, TASK_SIGPENDING($28)`
50			`bnez v0, reschedule`
51			`bnez v1, signal_return`
52			`restore_all: .set noat`
53			`RESTORE_ALL_AND_RET`
54			`.set at`
55
56			`/* Put this behind restore_all for the sake of the branch prediction. */`
57			`signal_return:`
58			`.type signal_return, @function`
59
60			`mfc0 t0, CP0_STATUS`
61			`ori t0, t0, 1`
62			`mtc0 t0, CP0_STATUS`
63
64			`move a0, zero`
65			`move a1, sp`
66			`jal do_signal`
67			`b restore_all`
68
69			`reschedule:`
70			`jal schedule`
71			`b ret_from_schedule`
72
73			`/*`
74			`* Common spurious interrupt handler.`
75			`*/`
76			`.text`
77			`.align 5`
78			`LEAF(spurious_interrupt)`
79			`/*`
80			`* Someone tried to fool us by sending an interrupt but we`
81			`* couldn't find a cause for it.`
82			`*/`
83			`lui t1,%hi(irq_err_count)`
84			`lw t0,%lo(irq_err_count)(t1)`
85			`addiu t0,1`
86			`sw t0,%lo(irq_err_count)(t1)`
87			`j ret_from_irq`
88			`END(spurious_interrupt)`
89
90			`__INIT`
91
92			`.set reorder`
93
94			`NESTED(except_vec1_generic, 0, sp)`
95			`PANIC("Exception vector 1 called")`
96			`END(except_vec1_generic)`
97
98			`/*`
99			`* General exception vector. Used for all CPUs except R4000`
100			`* and R4400 SC and MC versions.`
101			`*/`
102			`NESTED(except_vec3_generic, 0, sp)`
103			`#if R5432_CP0_INTERRUPT_WAR`
104			`mfc0 k0, CP0_INDEX`
105			`#endif`
106			`mfc0 k1, CP0_CAUSE`
107			`la k0, exception_handlers`
108			`andi k1, k1, 0x7c`
109			`addu k0, k0, k1`
110			`lw k0, (k0)`
111			`jr k0`
112			`END(except_vec3_generic)`
113			`.set at`
114
115			`/* General exception vector R4000 version. */`
116			`NESTED(except_vec3_r4000, 0, sp)`
117			`.set push`
118			`.set mips3`
119			`.set noat`
120			`mfc0 k1, CP0_CAUSE`
121			`li k0, 31<<2`
122			`andi k1, k1, 0x7c`
123			`.set noreorder`
124			`beq k1, k0, handle_vced`
125			`li k0, 14<<2`
126			`beq k1, k0, handle_vcei`
127			`la k0, exception_handlers`
128			`.set reorder`
129			`addu k0, k0, k1`
130			`lw k0, (k0)`
131			`jr k0`
132
133			`/*`
134			`* Big shit, we now may have two dirty primary cache lines for`
135			`* the same physical address. We can savely invalidate the`
136			`* line pointed to by c0_badvaddr because after return from`
137			`* this exception handler the load / store will be re-executed.`
138			`*/`
139			`handle_vced:`
140			`mfc0 k0, CP0_BADVADDR`
141			`li k1, -4`
142			`and k0, k1`
143			`mtc0 zero, CP0_TAGLO`
144			`cache Index_Store_Tag_D,(k0)`
145			`cache Hit_Writeback_Inv_SD,(k0)`
146			`#ifdef CONFIG_PROC_FS`
147			`lui k0, %hi(vced_count)`
148			`lw k1, %lo(vced_count)(k0)`
149			`addiu k1, 1`
150			`sw k1, %lo(vced_count)(k0)`
151			`#endif`
152			`eret`
153
154			`handle_vcei:`
155			`mfc0 k0, CP0_BADVADDR`
156			`cache Hit_Writeback_Inv_SD, (k0) # also cleans pi`
157			`#ifdef CONFIG_PROC_FS`
158			`lui k0, %hi(vcei_count)`
159			`lw k1, %lo(vcei_count)(k0)`
160			`addiu k1, 1`
161			`sw k1, %lo(vcei_count)(k0)`
162			`#endif`
163			`eret`
164			`.set pop`
165			`END(except_vec3_r4000)`
166
167			`__FINIT`
168
169			`/*`
170			`* Build a default exception handler for the exceptions that don't need`
171			`* special handlers. If you didn't know yet - I like playing games with`
172			`* the C preprocessor ...`
173			`*/`
174			`#define __BUILD_clear_none(exception)`
175			`#define __BUILD_clear_sti(exception) \`
176			`STI`
177			`#define __BUILD_clear_cli(exception) \`
178			`CLI`
179			`#define __BUILD_clear_fpe(exception) \`
180			`cfc1 a1,fcr31; \`
181			`li a2,~(0x3f<<12); \`
182			`and a2,a1; \`
183			`ctc1 a2,fcr31; \`
184			`STI`
185			`#define __BUILD_clear_ade(exception) \`
186			`.set reorder; \`
187			`MFC0 t0,CP0_BADVADDR; \`
188			`.set noreorder; \`
189			`REG_S t0,PT_BVADDR(sp); \`
190			`KMODE`
191			`#define __BUILD_silent(exception)`
192
193			`#define fmt "Got %s at %08lx.\n"`
194
195			`#define __BUILD_verbose(exception) \`
196			`la a1,8f; \`
197			`TEXT (#exception); \`
198			`REG_L a2,PT_EPC(sp); \`
199			`PRINT(fmt)`
200			`#define __BUILD_count(exception) \`
201			`.set reorder; \`
202			`lw t0,exception_count_##exception; \`
203			`.set noreorder; \`
204			`addiu t0, 1; \`
205			`sw t0,exception_count_##exception; \`
206			`.data; \`
207			`EXPORT(exception_count_##exception); \`
208			`.word 0; \`
209			`.previous;`
210			`#define BUILD_HANDLER(exception,handler,clear,verbose) \`
211			`.align 5; \`
212			`NESTED(handle_##exception, PT_SIZE, sp); \`
213			`.set noat; \`
214			`SAVE_ALL; \`
215			`FEXPORT(handle_##exception##_int); \`
216			`__BUILD_clear_##clear(exception); \`
217			`.set at; \`
218			`__BUILD_##verbose(exception); \`
219			`jal do_##handler; \`
220			`move a0, sp; \`
221			`j ret_from_exception; \`
222			`nop; \`
223			`END(handle_##exception)`
224
225			`BUILD_HANDLER(adel,ade,ade,silent) /* #4 */`
226			`BUILD_HANDLER(ades,ade,ade,silent) /* #5 */`
227			`BUILD_HANDLER(ibe,be,cli,silent) /* #6 */`
228			`BUILD_HANDLER(dbe,be,cli,silent) /* #7 */`
229			`BUILD_HANDLER(bp,bp,sti,silent) /* #9 */`
230			`BUILD_HANDLER(ri,ri,sti,silent) /* #10 */`
231			`BUILD_HANDLER(cpu,cpu,sti,silent) /* #11 */`
232			`BUILD_HANDLER(ov,ov,sti,silent) /* #12 */`
233			`BUILD_HANDLER(tr,tr,sti,silent) /* #13 */`
234			`BUILD_HANDLER(fpe,fpe,fpe,silent) /* #15 */`
235			`BUILD_HANDLER(mdmx,mdmx,sti,silent) /* #22 */`
236			`BUILD_HANDLER(watch,watch,sti,silent) /* #23 */`
237			`BUILD_HANDLER(mcheck,mcheck,cli,silent) /* #24 */`
238			`BUILD_HANDLER(reserved,reserved,sti,silent) /* others */`
239
240			`.set pop`
241
242			`/*`
243			`* Table of syscalls`
244			`*/`
245			`.data`
246			`.align PTRLOG`
247			`EXPORT(sys_call_table)`
248			`#define SYS(call, narg) PTR call`
249
250			`/* Reserved space for all SVR4 syscalls. */`
251			`.space (1000)*PTRSIZE`
252
253			`#ifdef CONFIG_BINFMT_IRIX`
254			`/* 32bit IRIX5 system calls. */`
255			`#include "irix5sys.h"`
256			`#else`
257			`.space (1000)PTRSIZE / No IRIX syscalls */`
258			`#endif`
259
260			`/* Reserved space for all the BSD43 and POSIX syscalls. */`
261			`.space (2000)*PTRSIZE`
262
263			`/* Linux flavoured syscalls. */`
264			`#include "syscalls.h"`
265
266			`/*`
267			`* Number of arguments of each syscall`
268			`*/`
269			`EXPORT(sys_narg_table)`
270			`#undef SYS`
271			`#define SYS(call, narg) .byte narg`
272
273			`/* Reserved space for all SVR4 flavoured syscalls. */`
274			`.space (1000)`
275
276			`#ifdef CONFIG_BINFMT_IRIX`
277			`/* 32bit IRIX5 system calls. */`
278			`#include "irix5sys.h"`
279			`#else`
280			`.space (1000) /* No IRIX syscalls */`
281			`#endif`
282
283			`/* Reserved space for all the BSD43 and POSIX syscalls. */`
284			`.space (2000)`
285
286			`/* Linux flavoured syscalls. */`
287			`#include "syscalls.h"`