Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1 | /* |
| 2 | * File: arch/blackfin/mach-common/entry.S |
| 3 | * Based on: |
| 4 | * Author: Linus Torvalds |
| 5 | * |
| 6 | * Created: ? |
| 7 | * Description: contains the system-call and fault low-level handling routines. |
| 8 | * This also contains the timer-interrupt handler, as well as all |
| 9 | * interrupts and faults that can result in a task-switch. |
| 10 | * |
| 11 | * Modified: |
| 12 | * Copyright 2004-2006 Analog Devices Inc. |
| 13 | * |
| 14 | * Bugs: Enter bugs at http://blackfin.uclinux.org/ |
| 15 | * |
| 16 | * This program is free software; you can redistribute it and/or modify |
| 17 | * it under the terms of the GNU General Public License as published by |
| 18 | * the Free Software Foundation; either version 2 of the License, or |
| 19 | * (at your option) any later version. |
| 20 | * |
| 21 | * This program is distributed in the hope that it will be useful, |
| 22 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 23 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 24 | * GNU General Public License for more details. |
| 25 | * |
| 26 | * You should have received a copy of the GNU General Public License |
| 27 | * along with this program; if not, see the file COPYING, or write |
| 28 | * to the Free Software Foundation, Inc., |
| 29 | * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 30 | */ |
| 31 | |
Robin Getz | 2ebcade | 2007-10-09 17:24:30 +0800 | [diff] [blame] | 32 | /* NOTE: This code handles signal-recognition, which happens every time |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 33 | * after a timer-interrupt and after each system call. |
| 34 | */ |
| 35 | |
Mike Frysinger | 9cb07b2 | 2007-11-21 16:45:08 +0800 | [diff] [blame] | 36 | #include <linux/init.h> |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 37 | #include <linux/linkage.h> |
Mike Frysinger | 1f83b8f | 2007-07-12 22:58:21 +0800 | [diff] [blame] | 38 | #include <linux/unistd.h> |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 39 | #include <asm/blackfin.h> |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 40 | #include <asm/errno.h> |
| 41 | #include <asm/thread_info.h> /* TIF_NEED_RESCHED */ |
| 42 | #include <asm/asm-offsets.h> |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 43 | #include <asm/trace.h> |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 44 | |
| 45 | #include <asm/mach-common/context.S> |
| 46 | |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 47 | #if defined(CONFIG_BFIN_SCRATCH_REG_RETN) |
| 48 | # define EX_SCRATCH_REG RETN |
| 49 | #elif defined(CONFIG_BFIN_SCRATCH_REG_RETE) |
| 50 | # define EX_SCRATCH_REG RETE |
| 51 | #else |
| 52 | # define EX_SCRATCH_REG CYCLES |
| 53 | #endif |
| 54 | |
Robin Getz | b3f8b92 | 2007-10-10 17:28:27 +0800 | [diff] [blame] | 55 | #if ANOMALY_05000281 |
| 56 | ENTRY(_safe_speculative_execution) |
| 57 | NOP; |
| 58 | NOP; |
| 59 | NOP; |
| 60 | jump _safe_speculative_execution; |
| 61 | ENDPROC(_safe_speculative_execution) |
| 62 | #endif |
| 63 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 64 | #ifdef CONFIG_EXCPT_IRQ_SYSC_L1 |
| 65 | .section .l1.text |
| 66 | #else |
| 67 | .text |
| 68 | #endif |
| 69 | |
| 70 | /* Slightly simplified and streamlined entry point for CPLB misses. |
| 71 | * This one does not lower the level to IRQ5, and thus can be used to |
| 72 | * patch up CPLB misses on the kernel stack. |
| 73 | */ |
Mike Frysinger | 1aafd90 | 2007-07-25 11:19:14 +0800 | [diff] [blame] | 74 | #if ANOMALY_05000261 |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 75 | #define _ex_dviol _ex_workaround_261 |
| 76 | #define _ex_dmiss _ex_workaround_261 |
| 77 | #define _ex_dmult _ex_workaround_261 |
| 78 | |
| 79 | ENTRY(_ex_workaround_261) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 80 | /* |
| 81 | * Work around an anomaly: if we see a new DCPLB fault, return |
| 82 | * without doing anything. Then, if we get the same fault again, |
| 83 | * handle it. |
| 84 | */ |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 85 | P4 = R7; /* Store EXCAUSE */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 86 | p5.l = _last_cplb_fault_retx; |
| 87 | p5.h = _last_cplb_fault_retx; |
| 88 | r7 = [p5]; |
| 89 | r6 = retx; |
| 90 | [p5] = r6; |
| 91 | cc = r6 == r7; |
Mike Frysinger | 8d6c242 | 2007-11-21 15:53:49 +0800 | [diff] [blame] | 92 | if !cc jump _bfin_return_from_exception; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 93 | /* fall through */ |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 94 | R7 = P4; |
| 95 | R6 = 0x26; /* Data CPLB Miss */ |
| 96 | cc = R6 == R7; |
| 97 | if cc jump _ex_dcplb_miss (BP); |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 98 | R6 = 0x23; /* Data CPLB Miss */ |
| 99 | cc = R6 == R7; |
| 100 | if cc jump _ex_dcplb_viol (BP); |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 101 | /* Handle 0x23 Data CPLB Protection Violation |
| 102 | * and Data CPLB Multiple Hits - Linux Trap Zero |
| 103 | */ |
| 104 | jump _ex_trap_c; |
| 105 | ENDPROC(_ex_workaround_261) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 106 | |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 107 | #else |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 108 | #ifdef CONFIG_MPU |
| 109 | #define _ex_dviol _ex_dcplb_viol |
| 110 | #else |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 111 | #define _ex_dviol _ex_trap_c |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 112 | #endif |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 113 | #define _ex_dmiss _ex_dcplb_miss |
| 114 | #define _ex_dmult _ex_trap_c |
| 115 | #endif |
| 116 | |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 117 | |
| 118 | ENTRY(_ex_dcplb_viol) |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 119 | ENTRY(_ex_dcplb_miss) |
| 120 | ENTRY(_ex_icplb_miss) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 121 | (R7:6,P5:4) = [sp++]; |
| 122 | ASTAT = [sp++]; |
| 123 | SAVE_ALL_SYS |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 124 | #ifdef CONFIG_MPU |
| 125 | R0 = SEQSTAT; |
| 126 | R1 = SP; |
| 127 | sp += -12; |
| 128 | call _cplb_hdr; |
| 129 | sp += 12; |
| 130 | CC = R0 == 0; |
| 131 | IF !CC JUMP _handle_bad_cplb; |
| 132 | #else |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 133 | call __cplb_hdr; |
Bernd Schmidt | b97b8a9 | 2008-01-27 18:39:16 +0800 | [diff] [blame] | 134 | #endif |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 135 | DEBUG_START_HWTRACE(p5, r7) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 136 | RESTORE_ALL_SYS |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 137 | SP = EX_SCRATCH_REG; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 138 | rtx; |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 139 | ENDPROC(_ex_icplb_miss) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 140 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 141 | ENTRY(_ex_syscall) |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 142 | DEBUG_START_HWTRACE(p5, r7) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 143 | (R7:6,P5:4) = [sp++]; |
| 144 | ASTAT = [sp++]; |
| 145 | raise 15; /* invoked by TRAP #0, for sys call */ |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 146 | sp = EX_SCRATCH_REG; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 147 | rtx |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 148 | ENDPROC(_ex_syscall) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 149 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 150 | ENTRY(_ex_soft_bp) |
| 151 | r7 = retx; |
| 152 | r7 += -2; |
| 153 | retx = r7; |
| 154 | jump.s _ex_trap_c; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 155 | ENDPROC(_ex_soft_bp) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 156 | |
| 157 | ENTRY(_ex_single_step) |
| 158 | r7 = retx; |
| 159 | r6 = reti; |
| 160 | cc = r7 == r6; |
Mike Frysinger | 8d6c242 | 2007-11-21 15:53:49 +0800 | [diff] [blame] | 161 | if cc jump _bfin_return_from_exception |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 162 | r7 = syscfg; |
| 163 | bitclr (r7, 0); |
| 164 | syscfg = R7; |
| 165 | |
| 166 | p5.l = lo(IPEND); |
| 167 | p5.h = hi(IPEND); |
| 168 | r6 = [p5]; |
| 169 | cc = bittst(r6, 5); |
| 170 | if !cc jump _ex_trap_c; |
| 171 | p4.l = lo(EVT5); |
| 172 | p4.h = hi(EVT5); |
| 173 | r6.h = _exception_to_level5; |
| 174 | r6.l = _exception_to_level5; |
| 175 | r7 = [p4]; |
| 176 | cc = r6 == r7; |
| 177 | if !cc jump _ex_trap_c; |
Mike Frysinger | 46c87c3 | 2007-11-21 16:15:48 +0800 | [diff] [blame] | 178 | ENDPROC(_ex_single_step) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 179 | |
Mike Frysinger | 8d6c242 | 2007-11-21 15:53:49 +0800 | [diff] [blame] | 180 | ENTRY(_bfin_return_from_exception) |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 181 | DEBUG_START_HWTRACE(p5, r7) |
Mike Frysinger | 1aafd90 | 2007-07-25 11:19:14 +0800 | [diff] [blame] | 182 | #if ANOMALY_05000257 |
Michael Hennerich | 8af10b7 | 2007-05-21 18:09:09 +0800 | [diff] [blame] | 183 | R7=LC0; |
| 184 | LC0=R7; |
| 185 | R7=LC1; |
| 186 | LC1=R7; |
| 187 | #endif |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 188 | (R7:6,P5:4) = [sp++]; |
| 189 | ASTAT = [sp++]; |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 190 | sp = EX_SCRATCH_REG; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 191 | rtx; |
Mike Frysinger | 46c87c3 | 2007-11-21 16:15:48 +0800 | [diff] [blame] | 192 | ENDPROC(_bfin_return_from_exception) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 193 | |
| 194 | ENTRY(_handle_bad_cplb) |
| 195 | /* To get here, we just tried and failed to change a CPLB |
| 196 | * so, handle things in trap_c (C code), by lowering to |
| 197 | * IRQ5, just like we normally do. Since this is not a |
| 198 | * "normal" return path, we have a do alot of stuff to |
| 199 | * the stack to get ready so, we can fall through - we |
| 200 | * need to make a CPLB exception look like a normal exception |
| 201 | */ |
| 202 | |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 203 | DEBUG_START_HWTRACE(p5, r7) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 204 | RESTORE_ALL_SYS |
| 205 | [--sp] = ASTAT; |
| 206 | [--sp] = (R7:6, P5:4); |
| 207 | |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 208 | ENTRY(_ex_replaceable) |
| 209 | nop; |
| 210 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 211 | ENTRY(_ex_trap_c) |
Robin Getz | 2ebcade | 2007-10-09 17:24:30 +0800 | [diff] [blame] | 212 | /* Make sure we are not in a double fault */ |
| 213 | p4.l = lo(IPEND); |
| 214 | p4.h = hi(IPEND); |
| 215 | r7 = [p4]; |
| 216 | CC = BITTST (r7, 5); |
| 217 | if CC jump _double_fault; |
| 218 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 219 | /* Call C code (trap_c) to handle the exception, which most |
| 220 | * likely involves sending a signal to the current process. |
| 221 | * To avoid double faults, lower our priority to IRQ5 first. |
| 222 | */ |
| 223 | P5.h = _exception_to_level5; |
| 224 | P5.l = _exception_to_level5; |
| 225 | p4.l = lo(EVT5); |
| 226 | p4.h = hi(EVT5); |
| 227 | [p4] = p5; |
| 228 | csync; |
| 229 | |
| 230 | /* Disable all interrupts, but make sure level 5 is enabled so |
| 231 | * we can switch to that level. Save the old mask. */ |
| 232 | cli r6; |
| 233 | p4.l = _excpt_saved_imask; |
| 234 | p4.h = _excpt_saved_imask; |
| 235 | [p4] = r6; |
| 236 | r6 = 0x3f; |
| 237 | sti r6; |
| 238 | |
| 239 | /* Save the excause into a circular buffer, in case the instruction |
| 240 | * which caused this excecptions causes others. |
| 241 | */ |
| 242 | P5.l = _in_ptr_excause; |
| 243 | P5.h = _in_ptr_excause; |
| 244 | R7 = [P5]; |
| 245 | R7 += 4; |
| 246 | R6 = 0xF; |
| 247 | R7 = R7 & R6; |
| 248 | [P5] = R7; |
| 249 | R6.l = _excause_circ_buf; |
| 250 | R6.h = _excause_circ_buf; |
| 251 | R7 = R7 + R6; |
| 252 | p5 = R7; |
| 253 | R6 = SEQSTAT; |
| 254 | [P5] = R6; |
| 255 | |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 256 | DEBUG_START_HWTRACE(p5, r7) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 257 | (R7:6,P5:4) = [sp++]; |
| 258 | ASTAT = [sp++]; |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 259 | SP = EX_SCRATCH_REG; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 260 | raise 5; |
| 261 | rtx; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 262 | ENDPROC(_ex_trap_c) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 263 | |
Robin Getz | 2ebcade | 2007-10-09 17:24:30 +0800 | [diff] [blame] | 264 | /* We just realized we got an exception, while we were processing a different |
| 265 | * exception. This is a unrecoverable event, so crash |
| 266 | */ |
| 267 | ENTRY(_double_fault) |
| 268 | /* Turn caches & protection off, to ensure we don't get any more |
| 269 | * double exceptions |
| 270 | */ |
| 271 | |
| 272 | P4.L = LO(IMEM_CONTROL); |
| 273 | P4.H = HI(IMEM_CONTROL); |
| 274 | |
| 275 | R5 = [P4]; /* Control Register*/ |
| 276 | BITCLR(R5,ENICPLB_P); |
| 277 | SSYNC; /* SSYNC required before writing to IMEM_CONTROL. */ |
| 278 | .align 8; |
| 279 | [P4] = R5; |
| 280 | SSYNC; |
| 281 | |
| 282 | P4.L = LO(DMEM_CONTROL); |
| 283 | P4.H = HI(DMEM_CONTROL); |
| 284 | R5 = [P4]; |
| 285 | BITCLR(R5,ENDCPLB_P); |
| 286 | SSYNC; /* SSYNC required before writing to DMEM_CONTROL. */ |
| 287 | .align 8; |
| 288 | [P4] = R5; |
| 289 | SSYNC; |
| 290 | |
| 291 | /* Fix up the stack */ |
| 292 | (R7:6,P5:4) = [sp++]; |
| 293 | ASTAT = [sp++]; |
| 294 | SP = EX_SCRATCH_REG; |
| 295 | |
| 296 | /* We should be out of the exception stack, and back down into |
| 297 | * kernel or user space stack |
| 298 | */ |
| 299 | SAVE_ALL_SYS |
| 300 | |
| 301 | r0 = sp; /* stack frame pt_regs pointer argument ==> r0 */ |
| 302 | SP += -12; |
| 303 | call _double_fault_c; |
| 304 | SP += 12; |
| 305 | .L_double_fault_panic: |
| 306 | JUMP .L_double_fault_panic |
| 307 | |
| 308 | ENDPROC(_double_fault) |
| 309 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 310 | ENTRY(_exception_to_level5) |
| 311 | SAVE_ALL_SYS |
| 312 | |
| 313 | /* Restore interrupt mask. We haven't pushed RETI, so this |
| 314 | * doesn't enable interrupts until we return from this handler. */ |
| 315 | p4.l = _excpt_saved_imask; |
| 316 | p4.h = _excpt_saved_imask; |
| 317 | r6 = [p4]; |
| 318 | sti r6; |
| 319 | |
| 320 | /* Restore the hardware error vector. */ |
| 321 | P5.h = _evt_ivhw; |
| 322 | P5.l = _evt_ivhw; |
| 323 | p4.l = lo(EVT5); |
| 324 | p4.h = hi(EVT5); |
| 325 | [p4] = p5; |
| 326 | csync; |
| 327 | |
| 328 | p2.l = lo(IPEND); |
| 329 | p2.h = hi(IPEND); |
| 330 | csync; |
| 331 | r0 = [p2]; /* Read current IPEND */ |
| 332 | [sp + PT_IPEND] = r0; /* Store IPEND */ |
| 333 | |
| 334 | /* Pop the excause from the circular buffer and push it on the stack |
| 335 | * (in the right place - if you change the location of SEQSTAT, you |
| 336 | * must change this offset. |
| 337 | */ |
| 338 | .L_excep_to_5_again: |
| 339 | P5.l = _out_ptr_excause; |
| 340 | P5.h = _out_ptr_excause; |
| 341 | R7 = [P5]; |
| 342 | R7 += 4; |
| 343 | R6 = 0xF; |
| 344 | R7 = R7 & R6; |
| 345 | [P5] = R7; |
| 346 | R6.l = _excause_circ_buf; |
| 347 | R6.h = _excause_circ_buf; |
| 348 | R7 = R7 + R6; |
| 349 | P5 = R7; |
| 350 | R1 = [P5]; |
Robin Getz | 6f3ed70 | 2007-12-21 17:48:07 +0800 | [diff] [blame] | 351 | [SP + PT_SEQSTAT] = r1; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 352 | |
| 353 | r0 = sp; /* stack frame pt_regs pointer argument ==> r0 */ |
| 354 | SP += -12; |
| 355 | call _trap_c; |
| 356 | SP += 12; |
| 357 | |
| 358 | /* See if anything else is in the exception buffer |
| 359 | * if there is, process it |
| 360 | */ |
| 361 | P5.l = _out_ptr_excause; |
| 362 | P5.h = _out_ptr_excause; |
| 363 | P4.l = _in_ptr_excause; |
| 364 | P4.h = _in_ptr_excause; |
| 365 | R6 = [P5]; |
| 366 | R7 = [P4]; |
| 367 | CC = R6 == R7; |
| 368 | if ! CC JUMP .L_excep_to_5_again |
| 369 | |
| 370 | call _ret_from_exception; |
| 371 | RESTORE_ALL_SYS |
| 372 | rti; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 373 | ENDPROC(_exception_to_level5) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 374 | |
| 375 | ENTRY(_trap) /* Exception: 4th entry into system event table(supervisor mode)*/ |
| 376 | /* Since the kernel stack can be anywhere, it's not guaranteed to be |
| 377 | * covered by a CPLB. Switch to an exception stack; use RETN as a |
| 378 | * scratch register (for want of a better option). |
| 379 | */ |
Mike Frysinger | f0b5d12 | 2007-08-05 17:03:59 +0800 | [diff] [blame] | 380 | EX_SCRATCH_REG = sp; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 381 | sp.l = _exception_stack_top; |
| 382 | sp.h = _exception_stack_top; |
| 383 | /* Try to deal with syscalls quickly. */ |
| 384 | [--sp] = ASTAT; |
| 385 | [--sp] = (R7:6, P5:4); |
Robin Getz | 669b792 | 2007-06-21 16:34:08 +0800 | [diff] [blame] | 386 | DEBUG_STOP_HWTRACE(p5, r7) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 387 | r7 = SEQSTAT; /* reason code is in bit 5:0 */ |
| 388 | r6.l = lo(SEQSTAT_EXCAUSE); |
| 389 | r6.h = hi(SEQSTAT_EXCAUSE); |
| 390 | r7 = r7 & r6; |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 391 | p5.h = _ex_table; |
| 392 | p5.l = _ex_table; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 393 | p4 = r7; |
| 394 | p5 = p5 + (p4 << 2); |
| 395 | p4 = [p5]; |
| 396 | jump (p4); |
| 397 | |
| 398 | .Lbadsys: |
| 399 | r7 = -ENOSYS; /* signextending enough */ |
| 400 | [sp + PT_R0] = r7; /* return value from system call */ |
| 401 | jump .Lsyscall_really_exit; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 402 | ENDPROC(_trap) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 403 | |
| 404 | ENTRY(_kernel_execve) |
| 405 | link SIZEOF_PTREGS; |
| 406 | p0 = sp; |
| 407 | r3 = SIZEOF_PTREGS / 4; |
| 408 | r4 = 0(x); |
| 409 | 0: |
| 410 | [p0++] = r4; |
| 411 | r3 += -1; |
| 412 | cc = r3 == 0; |
| 413 | if !cc jump 0b (bp); |
| 414 | |
| 415 | p0 = sp; |
| 416 | sp += -16; |
| 417 | [sp + 12] = p0; |
| 418 | call _do_execve; |
| 419 | SP += 16; |
| 420 | cc = r0 == 0; |
| 421 | if ! cc jump 1f; |
| 422 | /* Success. Copy our temporary pt_regs to the top of the kernel |
| 423 | * stack and do a normal exception return. |
| 424 | */ |
| 425 | r1 = sp; |
| 426 | r0 = (-KERNEL_STACK_SIZE) (x); |
| 427 | r1 = r1 & r0; |
| 428 | p2 = r1; |
| 429 | p3 = [p2]; |
| 430 | r0 = KERNEL_STACK_SIZE - 4 (z); |
| 431 | p1 = r0; |
| 432 | p1 = p1 + p2; |
| 433 | |
| 434 | p0 = fp; |
| 435 | r4 = [p0--]; |
| 436 | r3 = SIZEOF_PTREGS / 4; |
| 437 | 0: |
| 438 | r4 = [p0--]; |
| 439 | [p1--] = r4; |
| 440 | r3 += -1; |
| 441 | cc = r3 == 0; |
| 442 | if ! cc jump 0b (bp); |
| 443 | |
| 444 | r0 = (KERNEL_STACK_SIZE - SIZEOF_PTREGS) (z); |
| 445 | p1 = r0; |
| 446 | p1 = p1 + p2; |
| 447 | sp = p1; |
| 448 | r0 = syscfg; |
| 449 | [SP + PT_SYSCFG] = r0; |
| 450 | [p3 + (TASK_THREAD + THREAD_KSP)] = sp; |
| 451 | |
| 452 | RESTORE_CONTEXT; |
| 453 | rti; |
| 454 | 1: |
| 455 | unlink; |
| 456 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 457 | ENDPROC(_kernel_execve) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 458 | |
| 459 | ENTRY(_system_call) |
| 460 | /* Store IPEND */ |
| 461 | p2.l = lo(IPEND); |
| 462 | p2.h = hi(IPEND); |
| 463 | csync; |
| 464 | r0 = [p2]; |
| 465 | [sp + PT_IPEND] = r0; |
| 466 | |
| 467 | /* Store RETS for now */ |
| 468 | r0 = rets; |
| 469 | [sp + PT_RESERVED] = r0; |
| 470 | /* Set the stack for the current process */ |
| 471 | r7 = sp; |
| 472 | r6.l = lo(ALIGN_PAGE_MASK); |
| 473 | r6.h = hi(ALIGN_PAGE_MASK); |
| 474 | r7 = r7 & r6; /* thread_info */ |
| 475 | p2 = r7; |
| 476 | p2 = [p2]; |
| 477 | |
| 478 | [p2+(TASK_THREAD+THREAD_KSP)] = sp; |
| 479 | |
| 480 | /* Check the System Call */ |
| 481 | r7 = __NR_syscall; |
| 482 | /* System call number is passed in P0 */ |
| 483 | r6 = p0; |
| 484 | cc = r6 < r7; |
| 485 | if ! cc jump .Lbadsys; |
| 486 | |
| 487 | /* are we tracing syscalls?*/ |
| 488 | r7 = sp; |
| 489 | r6.l = lo(ALIGN_PAGE_MASK); |
| 490 | r6.h = hi(ALIGN_PAGE_MASK); |
| 491 | r7 = r7 & r6; |
| 492 | p2 = r7; |
| 493 | r7 = [p2+TI_FLAGS]; |
| 494 | CC = BITTST(r7,TIF_SYSCALL_TRACE); |
| 495 | if CC JUMP _sys_trace; |
| 496 | |
| 497 | /* Execute the appropriate system call */ |
| 498 | |
| 499 | p4 = p0; |
| 500 | p5.l = _sys_call_table; |
| 501 | p5.h = _sys_call_table; |
| 502 | p5 = p5 + (p4 << 2); |
| 503 | r0 = [sp + PT_R0]; |
| 504 | r1 = [sp + PT_R1]; |
| 505 | r2 = [sp + PT_R2]; |
| 506 | p5 = [p5]; |
| 507 | |
| 508 | [--sp] = r5; |
| 509 | [--sp] = r4; |
| 510 | [--sp] = r3; |
| 511 | SP += -12; |
| 512 | call (p5); |
| 513 | SP += 24; |
| 514 | [sp + PT_R0] = r0; |
| 515 | |
| 516 | .Lresume_userspace: |
| 517 | r7 = sp; |
| 518 | r4.l = lo(ALIGN_PAGE_MASK); |
| 519 | r4.h = hi(ALIGN_PAGE_MASK); |
| 520 | r7 = r7 & r4; /* thread_info->flags */ |
| 521 | p5 = r7; |
| 522 | .Lresume_userspace_1: |
| 523 | /* Disable interrupts. */ |
| 524 | [--sp] = reti; |
| 525 | reti = [sp++]; |
| 526 | |
| 527 | r7 = [p5 + TI_FLAGS]; |
| 528 | r4.l = lo(_TIF_WORK_MASK); |
| 529 | r4.h = hi(_TIF_WORK_MASK); |
| 530 | r7 = r7 & r4; |
| 531 | |
| 532 | .Lsyscall_resched: |
| 533 | cc = BITTST(r7, TIF_NEED_RESCHED); |
| 534 | if !cc jump .Lsyscall_sigpending; |
| 535 | |
| 536 | /* Reenable interrupts. */ |
| 537 | [--sp] = reti; |
| 538 | r0 = [sp++]; |
| 539 | |
| 540 | SP += -12; |
| 541 | call _schedule; |
| 542 | SP += 12; |
| 543 | |
| 544 | jump .Lresume_userspace_1; |
| 545 | |
| 546 | .Lsyscall_sigpending: |
| 547 | cc = BITTST(r7, TIF_RESTORE_SIGMASK); |
| 548 | if cc jump .Lsyscall_do_signals; |
| 549 | cc = BITTST(r7, TIF_SIGPENDING); |
| 550 | if !cc jump .Lsyscall_really_exit; |
| 551 | .Lsyscall_do_signals: |
| 552 | /* Reenable interrupts. */ |
| 553 | [--sp] = reti; |
| 554 | r0 = [sp++]; |
| 555 | |
| 556 | r0 = sp; |
| 557 | SP += -12; |
| 558 | call _do_signal; |
| 559 | SP += 12; |
| 560 | |
| 561 | .Lsyscall_really_exit: |
| 562 | r5 = [sp + PT_RESERVED]; |
| 563 | rets = r5; |
| 564 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 565 | ENDPROC(_system_call) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 566 | |
| 567 | _sys_trace: |
| 568 | call _syscall_trace; |
| 569 | |
| 570 | /* Execute the appropriate system call */ |
| 571 | |
| 572 | p4 = [SP + PT_P0]; |
| 573 | p5.l = _sys_call_table; |
| 574 | p5.h = _sys_call_table; |
| 575 | p5 = p5 + (p4 << 2); |
| 576 | r0 = [sp + PT_R0]; |
| 577 | r1 = [sp + PT_R1]; |
| 578 | r2 = [sp + PT_R2]; |
| 579 | r3 = [sp + PT_R3]; |
| 580 | r4 = [sp + PT_R4]; |
| 581 | r5 = [sp + PT_R5]; |
| 582 | p5 = [p5]; |
| 583 | |
| 584 | [--sp] = r5; |
| 585 | [--sp] = r4; |
| 586 | [--sp] = r3; |
| 587 | SP += -12; |
| 588 | call (p5); |
| 589 | SP += 24; |
| 590 | [sp + PT_R0] = r0; |
| 591 | |
| 592 | call _syscall_trace; |
| 593 | jump .Lresume_userspace; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 594 | ENDPROC(_sys_trace) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 595 | |
| 596 | ENTRY(_resume) |
| 597 | /* |
| 598 | * Beware - when entering resume, prev (the current task) is |
| 599 | * in r0, next (the new task) is in r1. |
| 600 | */ |
| 601 | p0 = r0; |
| 602 | p1 = r1; |
| 603 | [--sp] = rets; |
| 604 | [--sp] = fp; |
| 605 | [--sp] = (r7:4, p5:3); |
| 606 | |
| 607 | /* save usp */ |
| 608 | p2 = usp; |
| 609 | [p0+(TASK_THREAD+THREAD_USP)] = p2; |
| 610 | |
| 611 | /* save current kernel stack pointer */ |
| 612 | [p0+(TASK_THREAD+THREAD_KSP)] = sp; |
| 613 | |
| 614 | /* save program counter */ |
| 615 | r1.l = _new_old_task; |
| 616 | r1.h = _new_old_task; |
| 617 | [p0+(TASK_THREAD+THREAD_PC)] = r1; |
| 618 | |
| 619 | /* restore the kernel stack pointer */ |
| 620 | sp = [p1+(TASK_THREAD+THREAD_KSP)]; |
| 621 | |
| 622 | /* restore user stack pointer */ |
| 623 | p0 = [p1+(TASK_THREAD+THREAD_USP)]; |
| 624 | usp = p0; |
| 625 | |
| 626 | /* restore pc */ |
| 627 | p0 = [p1+(TASK_THREAD+THREAD_PC)]; |
| 628 | jump (p0); |
| 629 | |
| 630 | /* |
| 631 | * Following code actually lands up in a new (old) task. |
| 632 | */ |
| 633 | |
| 634 | _new_old_task: |
| 635 | (r7:4, p5:3) = [sp++]; |
| 636 | fp = [sp++]; |
| 637 | rets = [sp++]; |
| 638 | |
| 639 | /* |
| 640 | * When we come out of resume, r0 carries "old" task, becuase we are |
| 641 | * in "new" task. |
| 642 | */ |
| 643 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 644 | ENDPROC(_resume) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 645 | |
| 646 | ENTRY(_ret_from_exception) |
| 647 | p2.l = lo(IPEND); |
| 648 | p2.h = hi(IPEND); |
| 649 | |
| 650 | csync; |
| 651 | r0 = [p2]; |
| 652 | [sp + PT_IPEND] = r0; |
| 653 | |
| 654 | 1: |
Robin Getz | d5c4b5e | 2007-12-21 17:49:53 +0800 | [diff] [blame] | 655 | r2 = LO(~0x37) (Z); |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 656 | r0 = r2 & r0; |
| 657 | cc = r0 == 0; |
| 658 | if !cc jump 4f; /* if not return to user mode, get out */ |
| 659 | |
| 660 | /* Make sure any pending system call or deferred exception |
| 661 | * return in ILAT for this process to get executed, otherwise |
| 662 | * in case context switch happens, system call of |
| 663 | * first process (i.e in ILAT) will be carried |
| 664 | * forward to the switched process |
| 665 | */ |
| 666 | |
| 667 | p2.l = lo(ILAT); |
| 668 | p2.h = hi(ILAT); |
| 669 | r0 = [p2]; |
| 670 | r1 = (EVT_IVG14 | EVT_IVG15) (z); |
| 671 | r0 = r0 & r1; |
| 672 | cc = r0 == 0; |
| 673 | if !cc jump 5f; |
| 674 | |
| 675 | /* Set the stack for the current process */ |
| 676 | r7 = sp; |
| 677 | r4.l = lo(ALIGN_PAGE_MASK); |
| 678 | r4.h = hi(ALIGN_PAGE_MASK); |
| 679 | r7 = r7 & r4; /* thread_info->flags */ |
| 680 | p5 = r7; |
| 681 | r7 = [p5 + TI_FLAGS]; |
| 682 | r4.l = lo(_TIF_WORK_MASK); |
| 683 | r4.h = hi(_TIF_WORK_MASK); |
| 684 | r7 = r7 & r4; |
| 685 | cc = r7 == 0; |
| 686 | if cc jump 4f; |
| 687 | |
| 688 | p0.l = lo(EVT15); |
| 689 | p0.h = hi(EVT15); |
| 690 | p1.l = _schedule_and_signal; |
| 691 | p1.h = _schedule_and_signal; |
| 692 | [p0] = p1; |
| 693 | csync; |
| 694 | raise 15; /* raise evt14 to do signal or reschedule */ |
| 695 | 4: |
| 696 | r0 = syscfg; |
| 697 | bitclr(r0, 0); |
| 698 | syscfg = r0; |
| 699 | 5: |
| 700 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 701 | ENDPROC(_ret_from_exception) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 702 | |
| 703 | ENTRY(_return_from_int) |
| 704 | /* If someone else already raised IRQ 15, do nothing. */ |
| 705 | csync; |
| 706 | p2.l = lo(ILAT); |
| 707 | p2.h = hi(ILAT); |
| 708 | r0 = [p2]; |
| 709 | cc = bittst (r0, EVT_IVG15_P); |
| 710 | if cc jump 2f; |
| 711 | |
| 712 | /* if not return to user mode, get out */ |
| 713 | p2.l = lo(IPEND); |
| 714 | p2.h = hi(IPEND); |
| 715 | r0 = [p2]; |
| 716 | r1 = 0x17(Z); |
| 717 | r2 = ~r1; |
| 718 | r2.h = 0; |
| 719 | r0 = r2 & r0; |
| 720 | r1 = 1; |
| 721 | r1 = r0 - r1; |
| 722 | r2 = r0 & r1; |
| 723 | cc = r2 == 0; |
| 724 | if !cc jump 2f; |
| 725 | |
| 726 | /* Lower the interrupt level to 15. */ |
| 727 | p0.l = lo(EVT15); |
| 728 | p0.h = hi(EVT15); |
| 729 | p1.l = _schedule_and_signal_from_int; |
| 730 | p1.h = _schedule_and_signal_from_int; |
| 731 | [p0] = p1; |
| 732 | csync; |
Mike Frysinger | 1aafd90 | 2007-07-25 11:19:14 +0800 | [diff] [blame] | 733 | #if ANOMALY_05000281 |
Robin Getz | b3f8b92 | 2007-10-10 17:28:27 +0800 | [diff] [blame] | 734 | r0.l = _safe_speculative_execution; |
| 735 | r0.h = _safe_speculative_execution; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 736 | reti = r0; |
| 737 | #endif |
| 738 | r0 = 0x801f (z); |
| 739 | STI r0; |
| 740 | raise 15; /* raise evt15 to do signal or reschedule */ |
| 741 | rti; |
| 742 | 2: |
| 743 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 744 | ENDPROC(_return_from_int) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 745 | |
| 746 | ENTRY(_lower_to_irq14) |
Mike Frysinger | 1aafd90 | 2007-07-25 11:19:14 +0800 | [diff] [blame] | 747 | #if ANOMALY_05000281 |
Robin Getz | b3f8b92 | 2007-10-10 17:28:27 +0800 | [diff] [blame] | 748 | r0.l = _safe_speculative_execution; |
| 749 | r0.h = _safe_speculative_execution; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 750 | reti = r0; |
| 751 | #endif |
| 752 | r0 = 0x401f; |
| 753 | sti r0; |
| 754 | raise 14; |
| 755 | rti; |
| 756 | ENTRY(_evt14_softirq) |
| 757 | #ifdef CONFIG_DEBUG_HWERR |
| 758 | r0 = 0x3f; |
| 759 | sti r0; |
| 760 | #else |
| 761 | cli r0; |
| 762 | #endif |
| 763 | [--sp] = RETI; |
| 764 | SP += 4; |
| 765 | rts; |
| 766 | |
| 767 | _schedule_and_signal_from_int: |
| 768 | /* To end up here, vector 15 was changed - so we have to change it |
| 769 | * back. |
| 770 | */ |
| 771 | p0.l = lo(EVT15); |
| 772 | p0.h = hi(EVT15); |
| 773 | p1.l = _evt_system_call; |
| 774 | p1.h = _evt_system_call; |
| 775 | [p0] = p1; |
| 776 | csync; |
Bernd Schmidt | c824498 | 2007-05-21 18:09:33 +0800 | [diff] [blame] | 777 | |
| 778 | /* Set orig_p0 to -1 to indicate this isn't the end of a syscall. */ |
| 779 | r0 = -1 (x); |
| 780 | [sp + PT_ORIG_P0] = r0; |
| 781 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 782 | p1 = rets; |
| 783 | [sp + PT_RESERVED] = p1; |
| 784 | |
| 785 | p0.l = _irq_flags; |
| 786 | p0.h = _irq_flags; |
| 787 | r0 = [p0]; |
| 788 | sti r0; |
| 789 | |
Bernd Schmidt | 7adfb58 | 2007-06-21 11:34:16 +0800 | [diff] [blame] | 790 | r0 = sp; |
| 791 | sp += -12; |
| 792 | call _finish_atomic_sections; |
| 793 | sp += 12; |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 794 | jump.s .Lresume_userspace; |
| 795 | |
| 796 | _schedule_and_signal: |
| 797 | SAVE_CONTEXT_SYSCALL |
| 798 | /* To end up here, vector 15 was changed - so we have to change it |
| 799 | * back. |
| 800 | */ |
| 801 | p0.l = lo(EVT15); |
| 802 | p0.h = hi(EVT15); |
| 803 | p1.l = _evt_system_call; |
| 804 | p1.h = _evt_system_call; |
| 805 | [p0] = p1; |
| 806 | csync; |
| 807 | p0.l = 1f; |
| 808 | p0.h = 1f; |
| 809 | [sp + PT_RESERVED] = P0; |
| 810 | call .Lresume_userspace; |
| 811 | 1: |
| 812 | RESTORE_CONTEXT |
| 813 | rti; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 814 | ENDPROC(_lower_to_irq14) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 815 | |
| 816 | /* Make sure when we start, that the circular buffer is initialized properly |
| 817 | * R0 and P0 are call clobbered, so we can use them here. |
| 818 | */ |
| 819 | ENTRY(_init_exception_buff) |
| 820 | r0 = 0; |
| 821 | p0.h = _in_ptr_excause; |
| 822 | p0.l = _in_ptr_excause; |
| 823 | [p0] = r0; |
| 824 | p0.h = _out_ptr_excause; |
| 825 | p0.l = _out_ptr_excause; |
| 826 | [p0] = r0; |
| 827 | rts; |
Mike Frysinger | 51be24c | 2007-06-11 15:31:30 +0800 | [diff] [blame] | 828 | ENDPROC(_init_exception_buff) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 829 | |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 830 | /* We handle this 100% in exception space - to reduce overhead |
| 831 | * Only potiential problem is if the software buffer gets swapped out of the |
| 832 | * CPLB table - then double fault. - so we don't let this happen in other places |
| 833 | */ |
| 834 | #ifdef CONFIG_DEBUG_BFIN_HWTRACE_EXPAND |
| 835 | ENTRY(_ex_trace_buff_full) |
| 836 | [--sp] = P3; |
| 837 | [--sp] = P2; |
| 838 | [--sp] = LC0; |
| 839 | [--sp] = LT0; |
| 840 | [--sp] = LB0; |
| 841 | P5.L = _trace_buff_offset; |
| 842 | P5.H = _trace_buff_offset; |
| 843 | P3 = [P5]; /* trace_buff_offset */ |
| 844 | P5.L = lo(TBUFSTAT); |
| 845 | P5.H = hi(TBUFSTAT); |
| 846 | R7 = [P5]; |
| 847 | R7 <<= 1; /* double, since we need to read twice */ |
| 848 | LC0 = R7; |
| 849 | R7 <<= 2; /* need to shift over again, |
| 850 | * to get the number of bytes */ |
| 851 | P5.L = lo(TBUF); |
| 852 | P5.H = hi(TBUF); |
| 853 | R6 = ((1 << CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN)*1024) - 1; |
| 854 | |
| 855 | P2 = R7; |
| 856 | P3 = P3 + P2; |
| 857 | R7 = P3; |
| 858 | R7 = R7 & R6; |
| 859 | P3 = R7; |
| 860 | P2.L = _trace_buff_offset; |
| 861 | P2.H = _trace_buff_offset; |
| 862 | [P2] = P3; |
| 863 | |
| 864 | P2.L = _software_trace_buff; |
| 865 | P2.H = _software_trace_buff; |
| 866 | |
| 867 | LSETUP (.Lstart, .Lend) LC0; |
| 868 | .Lstart: |
| 869 | R7 = [P5]; /* read TBUF */ |
| 870 | P4 = P3 + P2; |
| 871 | [P4] = R7; |
| 872 | P3 += -4; |
| 873 | R7 = P3; |
| 874 | R7 = R7 & R6; |
| 875 | .Lend: |
| 876 | P3 = R7; |
| 877 | |
| 878 | LB0 = [sp++]; |
| 879 | LT0 = [sp++]; |
| 880 | LC0 = [sp++]; |
| 881 | P2 = [sp++]; |
| 882 | P3 = [sp++]; |
Mike Frysinger | 8d6c242 | 2007-11-21 15:53:49 +0800 | [diff] [blame] | 883 | jump _bfin_return_from_exception; |
Robin Getz | 337d390 | 2007-10-09 17:31:46 +0800 | [diff] [blame] | 884 | ENDPROC(_ex_trace_buff_full) |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 885 | |
| 886 | #if CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN == 4 |
| 887 | .data |
| 888 | #else |
| 889 | .section .l1.data.B |
Robin Getz | 337d390 | 2007-10-09 17:31:46 +0800 | [diff] [blame] | 890 | #endif /* CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN */ |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 891 | ENTRY(_trace_buff_offset) |
| 892 | .long 0; |
| 893 | ALIGN |
| 894 | ENTRY(_software_trace_buff) |
| 895 | .rept ((1 << CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN)*256); |
| 896 | .long 0 |
| 897 | .endr |
Robin Getz | 337d390 | 2007-10-09 17:31:46 +0800 | [diff] [blame] | 898 | #endif /* CONFIG_DEBUG_BFIN_HWTRACE_EXPAND */ |
| 899 | |
| 900 | #if CONFIG_EARLY_PRINTK |
Mike Frysinger | 9cb07b2 | 2007-11-21 16:45:08 +0800 | [diff] [blame] | 901 | __INIT |
Robin Getz | 337d390 | 2007-10-09 17:31:46 +0800 | [diff] [blame] | 902 | ENTRY(_early_trap) |
| 903 | SAVE_ALL_SYS |
| 904 | trace_buffer_stop(p0,r0); |
| 905 | |
| 906 | /* Turn caches off, to ensure we don't get double exceptions */ |
| 907 | |
| 908 | P4.L = LO(IMEM_CONTROL); |
| 909 | P4.H = HI(IMEM_CONTROL); |
| 910 | |
| 911 | R5 = [P4]; /* Control Register*/ |
| 912 | BITCLR(R5,ENICPLB_P); |
| 913 | CLI R1; |
| 914 | SSYNC; /* SSYNC required before writing to IMEM_CONTROL. */ |
| 915 | .align 8; |
| 916 | [P4] = R5; |
| 917 | SSYNC; |
| 918 | |
| 919 | P4.L = LO(DMEM_CONTROL); |
| 920 | P4.H = HI(DMEM_CONTROL); |
| 921 | R5 = [P4]; |
| 922 | BITCLR(R5,ENDCPLB_P); |
| 923 | SSYNC; /* SSYNC required before writing to DMEM_CONTROL. */ |
| 924 | .align 8; |
| 925 | [P4] = R5; |
| 926 | SSYNC; |
| 927 | STI R1; |
| 928 | |
| 929 | r0 = sp; /* stack frame pt_regs pointer argument ==> r0 */ |
| 930 | r1 = RETX; |
| 931 | |
| 932 | SP += -12; |
| 933 | call _early_trap_c; |
| 934 | SP += 12; |
| 935 | ENDPROC(_early_trap) |
Mike Frysinger | 9cb07b2 | 2007-11-21 16:45:08 +0800 | [diff] [blame] | 936 | __FINIT |
Robin Getz | 337d390 | 2007-10-09 17:31:46 +0800 | [diff] [blame] | 937 | #endif /* CONFIG_EARLY_PRINTK */ |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 938 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 939 | /* |
| 940 | * Put these in the kernel data section - that should always be covered by |
| 941 | * a CPLB. This is needed to ensure we don't get double fault conditions |
| 942 | */ |
| 943 | |
| 944 | #ifdef CONFIG_SYSCALL_TAB_L1 |
| 945 | .section .l1.data |
| 946 | #else |
| 947 | .data |
| 948 | #endif |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 949 | |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 950 | ENTRY(_ex_table) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 951 | /* entry for each EXCAUSE[5:0] |
Mike Frysinger | 9401e61 | 2007-07-12 11:50:43 +0800 | [diff] [blame] | 952 | * This table must be in sync with the table in ./kernel/traps.c |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 953 | * EXCPT instruction can provide 4 bits of EXCAUSE, allowing 16 to be user defined |
| 954 | */ |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 955 | .long _ex_syscall /* 0x00 - User Defined - Linux Syscall */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 956 | .long _ex_soft_bp /* 0x01 - User Defined - Software breakpoint */ |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 957 | .long _ex_replaceable /* 0x02 - User Defined */ |
Mike Frysinger | 9401e61 | 2007-07-12 11:50:43 +0800 | [diff] [blame] | 958 | .long _ex_trap_c /* 0x03 - User Defined - userspace stack overflow */ |
Robin Getz | 9f336a5 | 2007-10-29 18:23:28 +0800 | [diff] [blame] | 959 | .long _ex_trap_c /* 0x04 - User Defined - dump trace buffer */ |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 960 | .long _ex_replaceable /* 0x05 - User Defined */ |
| 961 | .long _ex_replaceable /* 0x06 - User Defined */ |
| 962 | .long _ex_replaceable /* 0x07 - User Defined */ |
| 963 | .long _ex_replaceable /* 0x08 - User Defined */ |
| 964 | .long _ex_replaceable /* 0x09 - User Defined */ |
| 965 | .long _ex_replaceable /* 0x0A - User Defined */ |
| 966 | .long _ex_replaceable /* 0x0B - User Defined */ |
| 967 | .long _ex_replaceable /* 0x0C - User Defined */ |
| 968 | .long _ex_replaceable /* 0x0D - User Defined */ |
| 969 | .long _ex_replaceable /* 0x0E - User Defined */ |
| 970 | .long _ex_replaceable /* 0x0F - User Defined */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 971 | .long _ex_single_step /* 0x10 - HW Single step */ |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 972 | #ifdef CONFIG_DEBUG_BFIN_HWTRACE_EXPAND |
| 973 | .long _ex_trace_buff_full /* 0x11 - Trace Buffer Full */ |
| 974 | #else |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 975 | .long _ex_trap_c /* 0x11 - Trace Buffer Full */ |
Robin Getz | 518039b | 2007-07-25 11:03:28 +0800 | [diff] [blame] | 976 | #endif |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 977 | .long _ex_trap_c /* 0x12 - Reserved */ |
| 978 | .long _ex_trap_c /* 0x13 - Reserved */ |
| 979 | .long _ex_trap_c /* 0x14 - Reserved */ |
| 980 | .long _ex_trap_c /* 0x15 - Reserved */ |
| 981 | .long _ex_trap_c /* 0x16 - Reserved */ |
| 982 | .long _ex_trap_c /* 0x17 - Reserved */ |
| 983 | .long _ex_trap_c /* 0x18 - Reserved */ |
| 984 | .long _ex_trap_c /* 0x19 - Reserved */ |
| 985 | .long _ex_trap_c /* 0x1A - Reserved */ |
| 986 | .long _ex_trap_c /* 0x1B - Reserved */ |
| 987 | .long _ex_trap_c /* 0x1C - Reserved */ |
| 988 | .long _ex_trap_c /* 0x1D - Reserved */ |
| 989 | .long _ex_trap_c /* 0x1E - Reserved */ |
| 990 | .long _ex_trap_c /* 0x1F - Reserved */ |
| 991 | .long _ex_trap_c /* 0x20 - Reserved */ |
| 992 | .long _ex_trap_c /* 0x21 - Undefined Instruction */ |
| 993 | .long _ex_trap_c /* 0x22 - Illegal Instruction Combination */ |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 994 | .long _ex_dviol /* 0x23 - Data CPLB Protection Violation */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 995 | .long _ex_trap_c /* 0x24 - Data access misaligned */ |
| 996 | .long _ex_trap_c /* 0x25 - Unrecoverable Event */ |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 997 | .long _ex_dmiss /* 0x26 - Data CPLB Miss */ |
| 998 | .long _ex_dmult /* 0x27 - Data CPLB Multiple Hits - Linux Trap Zero */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 999 | .long _ex_trap_c /* 0x28 - Emulation Watchpoint */ |
| 1000 | .long _ex_trap_c /* 0x29 - Instruction fetch access error (535 only) */ |
| 1001 | .long _ex_trap_c /* 0x2A - Instruction fetch misaligned */ |
Robin Getz | f26fbc4 | 2007-11-12 22:21:30 +0800 | [diff] [blame] | 1002 | .long _ex_trap_c /* 0x2B - Instruction CPLB protection Violation */ |
| 1003 | .long _ex_icplb_miss /* 0x2C - Instruction CPLB miss */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1004 | .long _ex_trap_c /* 0x2D - Instruction CPLB Multiple Hits */ |
| 1005 | .long _ex_trap_c /* 0x2E - Illegal use of Supervisor Resource */ |
| 1006 | .long _ex_trap_c /* 0x2E - Illegal use of Supervisor Resource */ |
| 1007 | .long _ex_trap_c /* 0x2F - Reserved */ |
| 1008 | .long _ex_trap_c /* 0x30 - Reserved */ |
| 1009 | .long _ex_trap_c /* 0x31 - Reserved */ |
| 1010 | .long _ex_trap_c /* 0x32 - Reserved */ |
| 1011 | .long _ex_trap_c /* 0x33 - Reserved */ |
| 1012 | .long _ex_trap_c /* 0x34 - Reserved */ |
| 1013 | .long _ex_trap_c /* 0x35 - Reserved */ |
| 1014 | .long _ex_trap_c /* 0x36 - Reserved */ |
| 1015 | .long _ex_trap_c /* 0x37 - Reserved */ |
| 1016 | .long _ex_trap_c /* 0x38 - Reserved */ |
| 1017 | .long _ex_trap_c /* 0x39 - Reserved */ |
| 1018 | .long _ex_trap_c /* 0x3A - Reserved */ |
| 1019 | .long _ex_trap_c /* 0x3B - Reserved */ |
| 1020 | .long _ex_trap_c /* 0x3C - Reserved */ |
| 1021 | .long _ex_trap_c /* 0x3D - Reserved */ |
| 1022 | .long _ex_trap_c /* 0x3E - Reserved */ |
| 1023 | .long _ex_trap_c /* 0x3F - Reserved */ |
Mike Frysinger | 1ffe664 | 2007-08-05 17:14:04 +0800 | [diff] [blame] | 1024 | END(_ex_table) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1025 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1026 | ENTRY(_sys_call_table) |
Bryan Wu | 0b95f22 | 2007-09-23 00:51:32 +0800 | [diff] [blame] | 1027 | .long _sys_restart_syscall /* 0 */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1028 | .long _sys_exit |
| 1029 | .long _sys_fork |
| 1030 | .long _sys_read |
| 1031 | .long _sys_write |
| 1032 | .long _sys_open /* 5 */ |
| 1033 | .long _sys_close |
| 1034 | .long _sys_ni_syscall /* old waitpid */ |
| 1035 | .long _sys_creat |
| 1036 | .long _sys_link |
| 1037 | .long _sys_unlink /* 10 */ |
| 1038 | .long _sys_execve |
| 1039 | .long _sys_chdir |
| 1040 | .long _sys_time |
| 1041 | .long _sys_mknod |
| 1042 | .long _sys_chmod /* 15 */ |
| 1043 | .long _sys_chown /* chown16 */ |
| 1044 | .long _sys_ni_syscall /* old break syscall holder */ |
| 1045 | .long _sys_ni_syscall /* old stat */ |
| 1046 | .long _sys_lseek |
| 1047 | .long _sys_getpid /* 20 */ |
| 1048 | .long _sys_mount |
| 1049 | .long _sys_ni_syscall /* old umount */ |
| 1050 | .long _sys_setuid |
| 1051 | .long _sys_getuid |
| 1052 | .long _sys_stime /* 25 */ |
| 1053 | .long _sys_ptrace |
| 1054 | .long _sys_alarm |
| 1055 | .long _sys_ni_syscall /* old fstat */ |
| 1056 | .long _sys_pause |
| 1057 | .long _sys_ni_syscall /* old utime */ /* 30 */ |
| 1058 | .long _sys_ni_syscall /* old stty syscall holder */ |
| 1059 | .long _sys_ni_syscall /* old gtty syscall holder */ |
| 1060 | .long _sys_access |
| 1061 | .long _sys_nice |
| 1062 | .long _sys_ni_syscall /* 35 */ /* old ftime syscall holder */ |
| 1063 | .long _sys_sync |
| 1064 | .long _sys_kill |
| 1065 | .long _sys_rename |
| 1066 | .long _sys_mkdir |
| 1067 | .long _sys_rmdir /* 40 */ |
| 1068 | .long _sys_dup |
| 1069 | .long _sys_pipe |
| 1070 | .long _sys_times |
| 1071 | .long _sys_ni_syscall /* old prof syscall holder */ |
| 1072 | .long _sys_brk /* 45 */ |
| 1073 | .long _sys_setgid |
| 1074 | .long _sys_getgid |
| 1075 | .long _sys_ni_syscall /* old sys_signal */ |
| 1076 | .long _sys_geteuid /* geteuid16 */ |
| 1077 | .long _sys_getegid /* getegid16 */ /* 50 */ |
| 1078 | .long _sys_acct |
| 1079 | .long _sys_umount /* recycled never used phys() */ |
| 1080 | .long _sys_ni_syscall /* old lock syscall holder */ |
| 1081 | .long _sys_ioctl |
| 1082 | .long _sys_fcntl /* 55 */ |
| 1083 | .long _sys_ni_syscall /* old mpx syscall holder */ |
| 1084 | .long _sys_setpgid |
| 1085 | .long _sys_ni_syscall /* old ulimit syscall holder */ |
| 1086 | .long _sys_ni_syscall /* old old uname */ |
| 1087 | .long _sys_umask /* 60 */ |
| 1088 | .long _sys_chroot |
| 1089 | .long _sys_ustat |
| 1090 | .long _sys_dup2 |
| 1091 | .long _sys_getppid |
| 1092 | .long _sys_getpgrp /* 65 */ |
| 1093 | .long _sys_setsid |
| 1094 | .long _sys_ni_syscall /* old sys_sigaction */ |
| 1095 | .long _sys_sgetmask |
| 1096 | .long _sys_ssetmask |
| 1097 | .long _sys_setreuid /* setreuid16 */ /* 70 */ |
| 1098 | .long _sys_setregid /* setregid16 */ |
| 1099 | .long _sys_ni_syscall /* old sys_sigsuspend */ |
| 1100 | .long _sys_ni_syscall /* old sys_sigpending */ |
| 1101 | .long _sys_sethostname |
| 1102 | .long _sys_setrlimit /* 75 */ |
| 1103 | .long _sys_ni_syscall /* old getrlimit */ |
| 1104 | .long _sys_getrusage |
| 1105 | .long _sys_gettimeofday |
| 1106 | .long _sys_settimeofday |
| 1107 | .long _sys_getgroups /* getgroups16 */ /* 80 */ |
| 1108 | .long _sys_setgroups /* setgroups16 */ |
| 1109 | .long _sys_ni_syscall /* old_select */ |
| 1110 | .long _sys_symlink |
| 1111 | .long _sys_ni_syscall /* old lstat */ |
| 1112 | .long _sys_readlink /* 85 */ |
| 1113 | .long _sys_uselib |
| 1114 | .long _sys_ni_syscall /* sys_swapon */ |
| 1115 | .long _sys_reboot |
| 1116 | .long _sys_ni_syscall /* old_readdir */ |
| 1117 | .long _sys_ni_syscall /* sys_mmap */ /* 90 */ |
| 1118 | .long _sys_munmap |
| 1119 | .long _sys_truncate |
| 1120 | .long _sys_ftruncate |
| 1121 | .long _sys_fchmod |
| 1122 | .long _sys_fchown /* fchown16 */ /* 95 */ |
| 1123 | .long _sys_getpriority |
| 1124 | .long _sys_setpriority |
| 1125 | .long _sys_ni_syscall /* old profil syscall holder */ |
| 1126 | .long _sys_statfs |
| 1127 | .long _sys_fstatfs /* 100 */ |
| 1128 | .long _sys_ni_syscall |
| 1129 | .long _sys_ni_syscall /* old sys_socketcall */ |
| 1130 | .long _sys_syslog |
| 1131 | .long _sys_setitimer |
| 1132 | .long _sys_getitimer /* 105 */ |
| 1133 | .long _sys_newstat |
| 1134 | .long _sys_newlstat |
| 1135 | .long _sys_newfstat |
| 1136 | .long _sys_ni_syscall /* old uname */ |
| 1137 | .long _sys_ni_syscall /* iopl for i386 */ /* 110 */ |
| 1138 | .long _sys_vhangup |
| 1139 | .long _sys_ni_syscall /* obsolete idle() syscall */ |
| 1140 | .long _sys_ni_syscall /* vm86old for i386 */ |
| 1141 | .long _sys_wait4 |
| 1142 | .long _sys_ni_syscall /* 115 */ /* sys_swapoff */ |
| 1143 | .long _sys_sysinfo |
| 1144 | .long _sys_ni_syscall /* old sys_ipc */ |
| 1145 | .long _sys_fsync |
| 1146 | .long _sys_ni_syscall /* old sys_sigreturn */ |
| 1147 | .long _sys_clone /* 120 */ |
| 1148 | .long _sys_setdomainname |
| 1149 | .long _sys_newuname |
| 1150 | .long _sys_ni_syscall /* old sys_modify_ldt */ |
| 1151 | .long _sys_adjtimex |
| 1152 | .long _sys_ni_syscall /* 125 */ /* sys_mprotect */ |
| 1153 | .long _sys_ni_syscall /* old sys_sigprocmask */ |
| 1154 | .long _sys_ni_syscall /* old "creat_module" */ |
| 1155 | .long _sys_init_module |
| 1156 | .long _sys_delete_module |
| 1157 | .long _sys_ni_syscall /* 130: old "get_kernel_syms" */ |
| 1158 | .long _sys_quotactl |
| 1159 | .long _sys_getpgid |
| 1160 | .long _sys_fchdir |
| 1161 | .long _sys_bdflush |
| 1162 | .long _sys_ni_syscall /* 135 */ /* sys_sysfs */ |
| 1163 | .long _sys_personality |
| 1164 | .long _sys_ni_syscall /* for afs_syscall */ |
| 1165 | .long _sys_setfsuid /* setfsuid16 */ |
| 1166 | .long _sys_setfsgid /* setfsgid16 */ |
| 1167 | .long _sys_llseek /* 140 */ |
| 1168 | .long _sys_getdents |
| 1169 | .long _sys_ni_syscall /* sys_select */ |
| 1170 | .long _sys_flock |
| 1171 | .long _sys_ni_syscall /* sys_msync */ |
| 1172 | .long _sys_readv /* 145 */ |
| 1173 | .long _sys_writev |
| 1174 | .long _sys_getsid |
| 1175 | .long _sys_fdatasync |
| 1176 | .long _sys_sysctl |
| 1177 | .long _sys_ni_syscall /* 150 */ /* sys_mlock */ |
| 1178 | .long _sys_ni_syscall /* sys_munlock */ |
| 1179 | .long _sys_ni_syscall /* sys_mlockall */ |
| 1180 | .long _sys_ni_syscall /* sys_munlockall */ |
| 1181 | .long _sys_sched_setparam |
| 1182 | .long _sys_sched_getparam /* 155 */ |
| 1183 | .long _sys_sched_setscheduler |
| 1184 | .long _sys_sched_getscheduler |
| 1185 | .long _sys_sched_yield |
| 1186 | .long _sys_sched_get_priority_max |
| 1187 | .long _sys_sched_get_priority_min /* 160 */ |
| 1188 | .long _sys_sched_rr_get_interval |
| 1189 | .long _sys_nanosleep |
Bryan Wu | 0b95f22 | 2007-09-23 00:51:32 +0800 | [diff] [blame] | 1190 | .long _sys_mremap |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1191 | .long _sys_setresuid /* setresuid16 */ |
| 1192 | .long _sys_getresuid /* getresuid16 */ /* 165 */ |
| 1193 | .long _sys_ni_syscall /* for vm86 */ |
| 1194 | .long _sys_ni_syscall /* old "query_module" */ |
| 1195 | .long _sys_ni_syscall /* sys_poll */ |
Bryan Wu | 0b95f22 | 2007-09-23 00:51:32 +0800 | [diff] [blame] | 1196 | .long _sys_nfsservctl |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1197 | .long _sys_setresgid /* setresgid16 */ /* 170 */ |
| 1198 | .long _sys_getresgid /* getresgid16 */ |
| 1199 | .long _sys_prctl |
| 1200 | .long _sys_rt_sigreturn |
| 1201 | .long _sys_rt_sigaction |
| 1202 | .long _sys_rt_sigprocmask /* 175 */ |
| 1203 | .long _sys_rt_sigpending |
| 1204 | .long _sys_rt_sigtimedwait |
| 1205 | .long _sys_rt_sigqueueinfo |
| 1206 | .long _sys_rt_sigsuspend |
| 1207 | .long _sys_pread64 /* 180 */ |
| 1208 | .long _sys_pwrite64 |
| 1209 | .long _sys_lchown /* lchown16 */ |
| 1210 | .long _sys_getcwd |
| 1211 | .long _sys_capget |
| 1212 | .long _sys_capset /* 185 */ |
| 1213 | .long _sys_sigaltstack |
| 1214 | .long _sys_sendfile |
| 1215 | .long _sys_ni_syscall /* streams1 */ |
| 1216 | .long _sys_ni_syscall /* streams2 */ |
| 1217 | .long _sys_vfork /* 190 */ |
| 1218 | .long _sys_getrlimit |
| 1219 | .long _sys_mmap2 |
| 1220 | .long _sys_truncate64 |
| 1221 | .long _sys_ftruncate64 |
| 1222 | .long _sys_stat64 /* 195 */ |
| 1223 | .long _sys_lstat64 |
| 1224 | .long _sys_fstat64 |
| 1225 | .long _sys_chown |
| 1226 | .long _sys_getuid |
| 1227 | .long _sys_getgid /* 200 */ |
| 1228 | .long _sys_geteuid |
| 1229 | .long _sys_getegid |
| 1230 | .long _sys_setreuid |
| 1231 | .long _sys_setregid |
| 1232 | .long _sys_getgroups /* 205 */ |
| 1233 | .long _sys_setgroups |
| 1234 | .long _sys_fchown |
| 1235 | .long _sys_setresuid |
| 1236 | .long _sys_getresuid |
| 1237 | .long _sys_setresgid /* 210 */ |
| 1238 | .long _sys_getresgid |
| 1239 | .long _sys_lchown |
| 1240 | .long _sys_setuid |
| 1241 | .long _sys_setgid |
| 1242 | .long _sys_setfsuid /* 215 */ |
| 1243 | .long _sys_setfsgid |
| 1244 | .long _sys_pivot_root |
| 1245 | .long _sys_ni_syscall /* sys_mincore */ |
| 1246 | .long _sys_ni_syscall /* sys_madvise */ |
| 1247 | .long _sys_getdents64 /* 220 */ |
| 1248 | .long _sys_fcntl64 |
| 1249 | .long _sys_ni_syscall /* reserved for TUX */ |
| 1250 | .long _sys_ni_syscall |
| 1251 | .long _sys_gettid |
Bryan Wu | 0b95f22 | 2007-09-23 00:51:32 +0800 | [diff] [blame] | 1252 | .long _sys_readahead /* 225 */ |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1253 | .long _sys_setxattr |
| 1254 | .long _sys_lsetxattr |
| 1255 | .long _sys_fsetxattr |
| 1256 | .long _sys_getxattr |
| 1257 | .long _sys_lgetxattr /* 230 */ |
| 1258 | .long _sys_fgetxattr |
| 1259 | .long _sys_listxattr |
| 1260 | .long _sys_llistxattr |
| 1261 | .long _sys_flistxattr |
| 1262 | .long _sys_removexattr /* 235 */ |
| 1263 | .long _sys_lremovexattr |
| 1264 | .long _sys_fremovexattr |
| 1265 | .long _sys_tkill |
| 1266 | .long _sys_sendfile64 |
| 1267 | .long _sys_futex /* 240 */ |
| 1268 | .long _sys_sched_setaffinity |
| 1269 | .long _sys_sched_getaffinity |
| 1270 | .long _sys_ni_syscall /* sys_set_thread_area */ |
| 1271 | .long _sys_ni_syscall /* sys_get_thread_area */ |
| 1272 | .long _sys_io_setup /* 245 */ |
| 1273 | .long _sys_io_destroy |
| 1274 | .long _sys_io_getevents |
| 1275 | .long _sys_io_submit |
| 1276 | .long _sys_io_cancel |
| 1277 | .long _sys_ni_syscall /* 250 */ /* sys_alloc_hugepages */ |
| 1278 | .long _sys_ni_syscall /* sys_freec_hugepages */ |
| 1279 | .long _sys_exit_group |
| 1280 | .long _sys_lookup_dcookie |
| 1281 | .long _sys_bfin_spinlock |
| 1282 | .long _sys_epoll_create /* 255 */ |
| 1283 | .long _sys_epoll_ctl |
| 1284 | .long _sys_epoll_wait |
| 1285 | .long _sys_ni_syscall /* remap_file_pages */ |
| 1286 | .long _sys_set_tid_address |
| 1287 | .long _sys_timer_create /* 260 */ |
| 1288 | .long _sys_timer_settime |
| 1289 | .long _sys_timer_gettime |
| 1290 | .long _sys_timer_getoverrun |
| 1291 | .long _sys_timer_delete |
| 1292 | .long _sys_clock_settime /* 265 */ |
| 1293 | .long _sys_clock_gettime |
| 1294 | .long _sys_clock_getres |
| 1295 | .long _sys_clock_nanosleep |
| 1296 | .long _sys_statfs64 |
| 1297 | .long _sys_fstatfs64 /* 270 */ |
| 1298 | .long _sys_tgkill |
| 1299 | .long _sys_utimes |
| 1300 | .long _sys_fadvise64_64 |
| 1301 | .long _sys_ni_syscall /* vserver */ |
| 1302 | .long _sys_ni_syscall /* 275, mbind */ |
| 1303 | .long _sys_ni_syscall /* get_mempolicy */ |
| 1304 | .long _sys_ni_syscall /* set_mempolicy */ |
| 1305 | .long _sys_mq_open |
| 1306 | .long _sys_mq_unlink |
| 1307 | .long _sys_mq_timedsend /* 280 */ |
| 1308 | .long _sys_mq_timedreceive |
| 1309 | .long _sys_mq_notify |
| 1310 | .long _sys_mq_getsetattr |
| 1311 | .long _sys_ni_syscall /* kexec_load */ |
| 1312 | .long _sys_waitid /* 285 */ |
| 1313 | .long _sys_add_key |
| 1314 | .long _sys_request_key |
| 1315 | .long _sys_keyctl |
| 1316 | .long _sys_ioprio_set |
| 1317 | .long _sys_ioprio_get /* 290 */ |
| 1318 | .long _sys_inotify_init |
| 1319 | .long _sys_inotify_add_watch |
| 1320 | .long _sys_inotify_rm_watch |
| 1321 | .long _sys_ni_syscall /* migrate_pages */ |
| 1322 | .long _sys_openat /* 295 */ |
| 1323 | .long _sys_mkdirat |
| 1324 | .long _sys_mknodat |
| 1325 | .long _sys_fchownat |
| 1326 | .long _sys_futimesat |
| 1327 | .long _sys_fstatat64 /* 300 */ |
| 1328 | .long _sys_unlinkat |
| 1329 | .long _sys_renameat |
| 1330 | .long _sys_linkat |
| 1331 | .long _sys_symlinkat |
| 1332 | .long _sys_readlinkat /* 305 */ |
| 1333 | .long _sys_fchmodat |
| 1334 | .long _sys_faccessat |
| 1335 | .long _sys_pselect6 |
| 1336 | .long _sys_ppoll |
| 1337 | .long _sys_unshare /* 310 */ |
| 1338 | .long _sys_sram_alloc |
| 1339 | .long _sys_sram_free |
| 1340 | .long _sys_dma_memcpy |
| 1341 | .long _sys_accept |
| 1342 | .long _sys_bind /* 315 */ |
| 1343 | .long _sys_connect |
| 1344 | .long _sys_getpeername |
| 1345 | .long _sys_getsockname |
| 1346 | .long _sys_getsockopt |
| 1347 | .long _sys_listen /* 320 */ |
| 1348 | .long _sys_recv |
| 1349 | .long _sys_recvfrom |
| 1350 | .long _sys_recvmsg |
| 1351 | .long _sys_send |
| 1352 | .long _sys_sendmsg /* 325 */ |
| 1353 | .long _sys_sendto |
| 1354 | .long _sys_setsockopt |
| 1355 | .long _sys_shutdown |
| 1356 | .long _sys_socket |
| 1357 | .long _sys_socketpair /* 330 */ |
| 1358 | .long _sys_semctl |
| 1359 | .long _sys_semget |
| 1360 | .long _sys_semop |
| 1361 | .long _sys_msgctl |
| 1362 | .long _sys_msgget /* 335 */ |
| 1363 | .long _sys_msgrcv |
| 1364 | .long _sys_msgsnd |
| 1365 | .long _sys_shmat |
| 1366 | .long _sys_shmctl |
| 1367 | .long _sys_shmdt /* 340 */ |
| 1368 | .long _sys_shmget |
Bryan Wu | 0b95f22 | 2007-09-23 00:51:32 +0800 | [diff] [blame] | 1369 | .long _sys_splice |
| 1370 | .long _sys_sync_file_range |
| 1371 | .long _sys_tee |
| 1372 | .long _sys_vmsplice /* 345 */ |
| 1373 | .long _sys_epoll_pwait |
| 1374 | .long _sys_utimensat |
| 1375 | .long _sys_signalfd |
| 1376 | .long _sys_timerfd |
| 1377 | .long _sys_eventfd /* 350 */ |
| 1378 | .long _sys_pread64 |
| 1379 | .long _sys_pwrite64 |
| 1380 | .long _sys_fadvise64 |
| 1381 | .long _sys_set_robust_list |
| 1382 | .long _sys_get_robust_list /* 355 */ |
| 1383 | .long _sys_fallocate |
Bernd Schmidt | fc97551 | 2008-01-27 19:56:43 +0800 | [diff] [blame] | 1384 | .long _sys_semtimedop |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1385 | .rept NR_syscalls-(.-_sys_call_table)/4 |
| 1386 | .long _sys_ni_syscall |
| 1387 | .endr |
| 1388 | _excpt_saved_imask: |
| 1389 | .long 0; |
| 1390 | |
| 1391 | _exception_stack: |
| 1392 | .rept 1024 |
| 1393 | .long 0; |
| 1394 | .endr |
| 1395 | _exception_stack_top: |
| 1396 | |
Mike Frysinger | 1aafd90 | 2007-07-25 11:19:14 +0800 | [diff] [blame] | 1397 | #if ANOMALY_05000261 |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1398 | /* Used by the assembly entry point to work around an anomaly. */ |
| 1399 | _last_cplb_fault_retx: |
| 1400 | .long 0; |
| 1401 | #endif |
| 1402 | /* |
| 1403 | * Single instructions can have multiple faults, which need to be |
| 1404 | * handled by traps.c, in irq5. We store the exception cause to ensure |
| 1405 | * we don't miss a double fault condition |
| 1406 | */ |
| 1407 | ENTRY(_in_ptr_excause) |
| 1408 | .long 0; |
| 1409 | ENTRY(_out_ptr_excause) |
| 1410 | .long 0; |
| 1411 | ALIGN |
| 1412 | ENTRY(_excause_circ_buf) |
| 1413 | .rept 4 |
| 1414 | .long 0 |
| 1415 | .endr |