arch/microblaze/kernel/entry.S

   1 /*
   2  * Low-level system-call handling, trap handlers and context-switching
   3  *
   4  * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
   5  * Copyright (C) 2008-2009 PetaLogix
   6  * Copyright (C) 2003           John Williams <jwilliams@itee.uq.edu.au>
   7  * Copyright (C) 2001,2002      NEC Corporation
   8  * Copyright (C) 2001,2002      Miles Bader <miles@gnu.org>
   9  *
  10  * This file is subject to the terms and conditions of the GNU General
  11  * Public License. See the file COPYING in the main directory of this
  12  * archive for more details.
  13  *
  14  * Written by Miles Bader <miles@gnu.org>
  15  * Heavily modified by John Williams for Microblaze
  16  */
  17
  18 #include <linux/sys.h>
  19 #include <linux/linkage.h>
  20
  21 #include <asm/entry.h>
  22 #include <asm/current.h>
  23 #include <asm/processor.h>
  24 #include <asm/exceptions.h>
  25 #include <asm/asm-offsets.h>
  26 #include <asm/thread_info.h>
  27
  28 #include <asm/page.h>
  29 #include <asm/unistd.h>
  30
  31 #include <linux/errno.h>
  32 #include <asm/signal.h>
  33
  34 #undef DEBUG
  35
  36 /* The size of a state save frame. */
  37 #define STATE_SAVE_SIZE         (PT_SIZE + STATE_SAVE_ARG_SPACE)
  38
  39 /* The offset of the struct pt_regs in a `state save frame' on the stack. */
  40 #define PTO     STATE_SAVE_ARG_SPACE /* 24 the space for args */
  41
  42 #define C_ENTRY(name)   .globl name; .align 4; name
  43
  44 /*
  45  * Various ways of setting and clearing BIP in flags reg.
  46  * This is mucky, but necessary using microblaze version that
  47  * allows msr ops to write to BIP
  48  */
  49 #if CONFIG_XILINX_MICROBLAZE0_USE_MSR_INSTR
  50         .macro  clear_bip
  51         msrclr  r0, MSR_BIP
  52         .endm
  53
  54         .macro  set_bip
  55         msrset  r0, MSR_BIP
  56         .endm
  57
  58         .macro  clear_eip
  59         msrclr  r0, MSR_EIP
  60         .endm
  61
  62         .macro  set_ee
  63         msrset  r0, MSR_EE
  64         .endm
  65
  66         .macro  disable_irq
  67         msrclr  r0, MSR_IE
  68         .endm
  69
  70         .macro  enable_irq
  71         msrset  r0, MSR_IE
  72         .endm
  73
  74         .macro  set_ums
  75         msrset  r0, MSR_UMS
  76         msrclr  r0, MSR_VMS
  77         .endm
  78
  79         .macro  set_vms
  80         msrclr  r0, MSR_UMS
  81         msrset  r0, MSR_VMS
  82         .endm
  83
  84         .macro  clear_ums
  85         msrclr  r0, MSR_UMS
  86         .endm
  87
  88         .macro  clear_vms_ums
  89         msrclr  r0, MSR_VMS | MSR_UMS
  90         .endm
  91 #else
  92         .macro  clear_bip
  93         mfs     r11, rmsr
  94         andi    r11, r11, ~MSR_BIP
  95         mts     rmsr, r11
  96         .endm
  97
  98         .macro  set_bip
  99         mfs     r11, rmsr
 100         ori     r11, r11, MSR_BIP
 101         mts     rmsr, r11
 102         .endm
 103
 104         .macro  clear_eip
 105         mfs     r11, rmsr
 106         andi    r11, r11, ~MSR_EIP
 107         mts     rmsr, r11
 108         .endm
 109
 110         .macro  set_ee
 111         mfs     r11, rmsr
 112         ori     r11, r11, MSR_EE
 113         mts     rmsr, r11
 114         .endm
 115
 116         .macro  disable_irq
 117         mfs     r11, rmsr
 118         andi    r11, r11, ~MSR_IE
 119         mts     rmsr, r11
 120         .endm
 121
 122         .macro  enable_irq
 123         mfs     r11, rmsr
 124         ori     r11, r11, MSR_IE
 125         mts     rmsr, r11
 126         .endm
 127
 128         .macro set_ums
 129         mfs     r11, rmsr
 130         ori     r11, r11, MSR_VMS
 131         andni   r11, r11, MSR_UMS
 132         mts     rmsr, r11
 133         .endm
 134
 135         .macro  set_vms
 136         mfs     r11, rmsr
 137         ori     r11, r11, MSR_VMS
 138         andni   r11, r11, MSR_UMS
 139         mts     rmsr, r11
 140         .endm
 141
 142         .macro  clear_ums
 143         mfs     r11, rmsr
 144         andni   r11, r11, MSR_UMS
 145         mts     rmsr,r11
 146         .endm
 147
 148         .macro  clear_vms_ums
 149         mfs     r11, rmsr
 150         andni   r11, r11, (MSR_VMS|MSR_UMS)
 151         mts     rmsr,r11
 152         .endm
 153 #endif
 154
 155 /* Define how to call high-level functions. With MMU, virtual mode must be
 156  * enabled when calling the high-level function. Clobbers R11.
 157  * VM_ON, VM_OFF, DO_JUMP_BIPCLR, DO_CALL
 158  */
 159
 160 /* turn on virtual protected mode save */
 161 #define VM_ON           \
 162         set_ums;        \
 163         rted    r0, 2f; \
 164         nop; \
 165 2:
 166
 167 /* turn off virtual protected mode save and user mode save*/
 168 #define VM_OFF                  \
 169         clear_vms_ums;          \
 170         rted    r0, TOPHYS(1f); \
 171         nop; \
 172 1:
 173
 174 #define SAVE_REGS \
 175         swi     r2, r1, PTO+PT_R2;      /* Save SDA */                  \
 176         swi     r3, r1, PTO+PT_R3;                                      \
 177         swi     r4, r1, PTO+PT_R4;                                      \
 178         swi     r5, r1, PTO+PT_R5;                                      \
 179         swi     r6, r1, PTO+PT_R6;                                      \
 180         swi     r7, r1, PTO+PT_R7;                                      \
 181         swi     r8, r1, PTO+PT_R8;                                      \
 182         swi     r9, r1, PTO+PT_R9;                                      \
 183         swi     r10, r1, PTO+PT_R10;                                    \
 184         swi     r11, r1, PTO+PT_R11;    /* save clobbered regs after rval */\
 185         swi     r12, r1, PTO+PT_R12;                                    \
 186         swi     r13, r1, PTO+PT_R13;    /* Save SDA2 */                 \
 187         swi     r14, r1, PTO+PT_PC;     /* PC, before IRQ/trap */       \
 188         swi     r15, r1, PTO+PT_R15;    /* Save LP */                   \
 189         swi     r18, r1, PTO+PT_R18;    /* Save asm scratch reg */      \
 190         swi     r19, r1, PTO+PT_R19;                                    \
 191         swi     r20, r1, PTO+PT_R20;                                    \
 192         swi     r21, r1, PTO+PT_R21;                                    \
 193         swi     r22, r1, PTO+PT_R22;                                    \
 194         swi     r23, r1, PTO+PT_R23;                                    \
 195         swi     r24, r1, PTO+PT_R24;                                    \
 196         swi     r25, r1, PTO+PT_R25;                                    \
 197         swi     r26, r1, PTO+PT_R26;                                    \
 198         swi     r27, r1, PTO+PT_R27;                                    \
 199         swi     r28, r1, PTO+PT_R28;                                    \
 200         swi     r29, r1, PTO+PT_R29;                                    \
 201         swi     r30, r1, PTO+PT_R30;                                    \
 202         swi     r31, r1, PTO+PT_R31;    /* Save current task reg */     \
 203         mfs     r11, rmsr;              /* save MSR */                  \
 204         swi     r11, r1, PTO+PT_MSR;
 205
 206 #define RESTORE_REGS \
 207         lwi     r11, r1, PTO+PT_MSR;                                    \
 208         mts     rmsr , r11;                                             \
 209         lwi     r2, r1, PTO+PT_R2;      /* restore SDA */               \
 210         lwi     r3, r1, PTO+PT_R3;                                      \
 211         lwi     r4, r1, PTO+PT_R4;                                      \
 212         lwi     r5, r1, PTO+PT_R5;                                      \
 213         lwi     r6, r1, PTO+PT_R6;                                      \
 214         lwi     r7, r1, PTO+PT_R7;                                      \
 215         lwi     r8, r1, PTO+PT_R8;                                      \
 216         lwi     r9, r1, PTO+PT_R9;                                      \
 217         lwi     r10, r1, PTO+PT_R10;                                    \
 218         lwi     r11, r1, PTO+PT_R11;    /* restore clobbered regs after rval */\
 219         lwi     r12, r1, PTO+PT_R12;                                    \
 220         lwi     r13, r1, PTO+PT_R13;    /* restore SDA2 */              \
 221         lwi     r14, r1, PTO+PT_PC;     /* RESTORE_LINK PC, before IRQ/trap */\
 222         lwi     r15, r1, PTO+PT_R15;    /* restore LP */                \
 223         lwi     r18, r1, PTO+PT_R18;    /* restore asm scratch reg */   \
 224         lwi     r19, r1, PTO+PT_R19;                                    \
 225         lwi     r20, r1, PTO+PT_R20;                                    \
 226         lwi     r21, r1, PTO+PT_R21;                                    \
 227         lwi     r22, r1, PTO+PT_R22;                                    \
 228         lwi     r23, r1, PTO+PT_R23;                                    \
 229         lwi     r24, r1, PTO+PT_R24;                                    \
 230         lwi     r25, r1, PTO+PT_R25;                                    \
 231         lwi     r26, r1, PTO+PT_R26;                                    \
 232         lwi     r27, r1, PTO+PT_R27;                                    \
 233         lwi     r28, r1, PTO+PT_R28;                                    \
 234         lwi     r29, r1, PTO+PT_R29;                                    \
 235         lwi     r30, r1, PTO+PT_R30;                                    \
 236         lwi     r31, r1, PTO+PT_R31;    /* Restore cur task reg */
 237
 238 #define SAVE_STATE      \
 239         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* save stack */     \
 240         /* See if already in kernel mode.*/                             \
 241         mfs     r1, rmsr;                                               \
 242         andi    r1, r1, MSR_UMS;                                        \
 243         bnei    r1, 1f;                                         \
 244         /* Kernel-mode state save.  */                                  \
 245         /* Reload kernel stack-ptr. */                                  \
 246         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP));                      \
 247         /* FIXME: I can add these two lines to one */                   \
 248         /* tophys(r1,r1); */                                            \
 249         /* addik        r1, r1, -STATE_SAVE_SIZE; */                    \
 250         addik   r1, r1, CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE; \
 251         SAVE_REGS                                                       \
 252         brid    2f;                                                     \
 253         swi     r1, r1, PTO+PT_MODE;                                    \
 254 1:      /* User-mode state save.  */                                    \
 255         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */\
 256         tophys(r1,r1);                                                  \
 257         lwi     r1, r1, TS_THREAD_INFO; /* get the thread info */       \
 258         /* MS these three instructions can be added to one */           \
 259         /* addik        r1, r1, THREAD_SIZE; */                         \
 260         /* tophys(r1,r1); */                                            \
 261         /* addik        r1, r1, -STATE_SAVE_SIZE; */                    \
 262         addik r1, r1, THREAD_SIZE + CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE; \
 263         SAVE_REGS                                                       \
 264         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));                     \
 265         swi     r11, r1, PTO+PT_R1; /* Store user SP.  */               \
 266         swi     r0, r1, PTO + PT_MODE; /* Was in user-mode.  */         \
 267         /* MS: I am clearing UMS even in case when I come from kernel space */ \
 268         clear_ums;                                                      \
 269 2:      lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 270
 271 .text
 272
 273 /*
 274  * User trap.
 275  *
 276  * System calls are handled here.
 277  *
 278  * Syscall protocol:
 279  * Syscall number in r12, args in r5-r10
 280  * Return value in r3
 281  *
 282  * Trap entered via brki instruction, so BIP bit is set, and interrupts
 283  * are masked. This is nice, means we don't have to CLI before state save
 284  */
 285 C_ENTRY(_user_exception):
 286         addi    r14, r14, 4     /* return address is 4 byte after call */
 287         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)) /* save stack */
 288
 289         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
 290         tophys(r1,r1);
 291         lwi     r1, r1, TS_THREAD_INFO; /* get stack from task_struct */
 292         /* MS these three instructions can be added to one */
 293         /* addik        r1, r1, THREAD_SIZE; */
 294         /* tophys(r1,r1); */
 295         /* addik        r1, r1, -STATE_SAVE_SIZE; */
 296         addik r1, r1, THREAD_SIZE + CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE;
 297         SAVE_REGS
 298
 299         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 300         swi     r11, r1, PTO+PT_R1;             /* Store user SP.  */
 301         clear_ums;
 302         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 303         /* Save away the syscall number.  */
 304         swi     r12, r1, PTO+PT_R0;
 305         tovirt(r1,r1)
 306
 307 /* where the trap should return need -8 to adjust for rtsd r15, 8*/
 308 /* Jump to the appropriate function for the system call number in r12
 309  * (r12 is not preserved), or return an error if r12 is not valid. The LP
 310  * register should point to the location where
 311  * the called function should return.  [note that MAKE_SYS_CALL uses label 1] */
 312
 313         /* Step into virtual mode */
 314         rtbd    r0, 3f
 315         nop
 316 3:
 317         lwi     r11, CURRENT_TASK, TS_THREAD_INFO /* get thread info */
 318         lwi     r11, r11, TI_FLAGS       /* get flags in thread info */
 319         andi    r11, r11, _TIF_WORK_SYSCALL_MASK
 320         beqi    r11, 4f
 321
 322         addik   r3, r0, -ENOSYS
 323         swi     r3, r1, PTO + PT_R3
 324         brlid   r15, do_syscall_trace_enter
 325         addik   r5, r1, PTO + PT_R0
 326
 327         # do_syscall_trace_enter returns the new syscall nr.
 328         addk    r12, r0, r3
 329         lwi     r5, r1, PTO+PT_R5;
 330         lwi     r6, r1, PTO+PT_R6;
 331         lwi     r7, r1, PTO+PT_R7;
 332         lwi     r8, r1, PTO+PT_R8;
 333         lwi     r9, r1, PTO+PT_R9;
 334         lwi     r10, r1, PTO+PT_R10;
 335 4:
 336 /* Jump to the appropriate function for the system call number in r12
 337  * (r12 is not preserved), or return an error if r12 is not valid.
 338  * The LP register should point to the location where the called function
 339  * should return.  [note that MAKE_SYS_CALL uses label 1] */
 340         /* See if the system call number is valid */
 341         addi    r11, r12, -__NR_syscalls;
 342         bgei    r11,5f;
 343         /* Figure out which function to use for this system call.  */
 344         /* Note Microblaze barrel shift is optional, so don't rely on it */
 345         add     r12, r12, r12;                  /* convert num -> ptr */
 346         add     r12, r12, r12;
 347
 348 #ifdef DEBUG
 349         /* Trac syscalls and stored them to r0_ram */
 350         lwi     r3, r12, 0x400 + r0_ram
 351         addi    r3, r3, 1
 352         swi     r3, r12, 0x400 + r0_ram
 353 #endif
 354
 355         # Find and jump into the syscall handler.
 356         lwi     r12, r12, sys_call_table
 357         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 358         addi    r15, r0, ret_from_trap-8
 359         bra     r12
 360
 361         /* The syscall number is invalid, return an error.  */
 362 5:
 363         rtsd    r15, 8;         /* looks like a normal subroutine return */
 364         addi    r3, r0, -ENOSYS;
 365
 366 /* Entry point used to return from a syscall/trap */
 367 /* We re-enable BIP bit before state restore */
 368 C_ENTRY(ret_from_trap):
 369         swi     r3, r1, PTO + PT_R3
 370         swi     r4, r1, PTO + PT_R4
 371
 372         /* We're returning to user mode, so check for various conditions that
 373          * trigger rescheduling. */
 374         /* FIXME: Restructure all these flag checks. */
 375         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 376         lwi     r11, r11, TI_FLAGS;             /* get flags in thread info */
 377         andi    r11, r11, _TIF_WORK_SYSCALL_MASK
 378         beqi    r11, 1f
 379
 380         brlid   r15, do_syscall_trace_leave
 381         addik   r5, r1, PTO + PT_R0
 382 1:
 383         /* We're returning to user mode, so check for various conditions that
 384          * trigger rescheduling. */
 385         /* get thread info from current task */
 386         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 387         lwi     r11, r11, TI_FLAGS;             /* get flags in thread info */
 388         andi    r11, r11, _TIF_NEED_RESCHED;
 389         beqi    r11, 5f;
 390
 391         bralid  r15, schedule;  /* Call scheduler */
 392         nop;                            /* delay slot */
 393
 394         /* Maybe handle a signal */
 395 5:      /* get thread info from current task*/
 396         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 397         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 398         andi    r11, r11, _TIF_SIGPENDING;
 399         beqi    r11, 1f;                /* Signals to handle, handle them */
 400
 401         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 402         addi    r7, r0, 1;              /* Arg 3: int in_syscall */
 403         bralid  r15, do_signal; /* Handle any signals */
 404         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 405
 406 /* Finally, return to user state.  */
 407 1:      set_bip;                        /*  Ints masked for state restore */
 408         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 409         VM_OFF;
 410         tophys(r1,r1);
 411         RESTORE_REGS;
 412         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 413         lwi     r1, r1, PT_R1 - PT_SIZE;/* Restore user stack pointer. */
 414 TRAP_return:            /* Make global symbol for debugging */
 415         rtbd    r14, 0; /* Instructions to return from an IRQ */
 416         nop;
 417
 418
 419 /* These syscalls need access to the struct pt_regs on the stack, so we
 420    implement them in assembly (they're basically all wrappers anyway).  */
 421
 422 C_ENTRY(sys_fork_wrapper):
 423         addi    r5, r0, SIGCHLD                 /* Arg 0: flags */
 424         lwi     r6, r1, PTO+PT_R1       /* Arg 1: child SP (use parent's) */
 425         addik   r7, r1, PTO                     /* Arg 2: parent context */
 426         add     r8. r0, r0                      /* Arg 3: (unused) */
 427         add     r9, r0, r0;                     /* Arg 4: (unused) */
 428         brid    do_fork         /* Do real work (tail-call) */
 429         add     r10, r0, r0;                    /* Arg 5: (unused) */
 430
 431 /* This the initial entry point for a new child thread, with an appropriate
 432    stack in place that makes it look the the child is in the middle of an
 433    syscall.  This function is actually `returned to' from switch_thread
 434    (copy_thread makes ret_from_fork the return address in each new thread's
 435    saved context).  */
 436 C_ENTRY(ret_from_fork):
 437         bralid  r15, schedule_tail; /* ...which is schedule_tail's arg */
 438         add     r3, r5, r0;     /* switch_thread returns the prev task */
 439                                 /* ( in the delay slot ) */
 440         brid    ret_from_trap;  /* Do normal trap return */
 441         add     r3, r0, r0;     /* Child's fork call should return 0. */
 442
 443 C_ENTRY(sys_vfork):
 444         brid    microblaze_vfork        /* Do real work (tail-call) */
 445         addik   r5, r1, PTO
 446
 447 C_ENTRY(sys_clone):
 448         bnei    r6, 1f;                 /* See if child SP arg (arg 1) is 0. */
 449         lwi     r6, r1, PTO + PT_R1;    /* If so, use paret's stack ptr */
 450 1:      addik   r7, r1, PTO;                    /* Arg 2: parent context */
 451         add     r8, r0, r0;                     /* Arg 3: (unused) */
 452         add     r9, r0, r0;                     /* Arg 4: (unused) */
 453         brid    do_fork         /* Do real work (tail-call) */
 454         add     r10, r0, r0;                    /* Arg 5: (unused) */
 455
 456 C_ENTRY(sys_execve):
 457         brid    microblaze_execve;      /* Do real work (tail-call).*/
 458         addik   r8, r1, PTO;            /* add user context as 4th arg */
 459
 460 C_ENTRY(sys_rt_sigreturn_wrapper):
 461         swi     r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
 462         swi     r4, r1, PTO+PT_R4;
 463         brlid   r15, sys_rt_sigreturn   /* Do real work */
 464         addik   r5, r1, PTO;            /* add user context as 1st arg */
 465         lwi     r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
 466         lwi     r4, r1, PTO+PT_R4;
 467         bri ret_from_trap /* fall through will not work here due to align */
 468         nop;
 469
 470 /*
 471  * HW EXCEPTION rutine start
 472  */
 473 C_ENTRY(full_exception_trap):
 474         /* adjust exception address for privileged instruction
 475          * for finding where is it */
 476         addik   r17, r17, -4
 477         SAVE_STATE /* Save registers */
 478         /* PC, before IRQ/trap - this is one instruction above */
 479         swi     r17, r1, PTO+PT_PC;
 480         tovirt(r1,r1)
 481         /* FIXME this can be store directly in PT_ESR reg.
 482          * I tested it but there is a fault */
 483         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 484         addik   r15, r0, ret_from_exc - 8
 485         mfs     r6, resr
 486         mfs     r7, rfsr;               /* save FSR */
 487         mts     rfsr, r0;       /* Clear sticky fsr */
 488         rted    r0, full_exception
 489         addik   r5, r1, PTO              /* parameter struct pt_regs * regs */
 490
 491 /*
 492  * Unaligned data trap.
 493  *
 494  * Unaligned data trap last on 4k page is handled here.
 495  *
 496  * Trap entered via exception, so EE bit is set, and interrupts
 497  * are masked.  This is nice, means we don't have to CLI before state save
 498  *
 499  * The assembler routine is in "arch/microblaze/kernel/hw_exception_handler.S"
 500  */
 501 C_ENTRY(unaligned_data_trap):
 502         /* MS: I have to save r11 value and then restore it because
 503          * set_bit, clear_eip, set_ee use r11 as temp register if MSR
 504          * instructions are not used. We don't need to do if MSR instructions
 505          * are used and they use r0 instead of r11.
 506          * I am using ENTRY_SP which should be primary used only for stack
 507          * pointer saving. */
 508         swi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 509         set_bip;        /* equalize initial state for all possible entries */
 510         clear_eip;
 511         set_ee;
 512         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 513         SAVE_STATE              /* Save registers.*/
 514         /* PC, before IRQ/trap - this is one instruction above */
 515         swi     r17, r1, PTO+PT_PC;
 516         tovirt(r1,r1)
 517         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 518         addik   r15, r0, ret_from_exc-8
 519         mfs     r3, resr                /* ESR */
 520         mfs     r4, rear                /* EAR */
 521         rtbd    r0, _unaligned_data_exception
 522         addik   r7, r1, PTO             /* parameter struct pt_regs * regs */
 523
 524 /*
 525  * Page fault traps.
 526  *
 527  * If the real exception handler (from hw_exception_handler.S) didn't find
 528  * the mapping for the process, then we're thrown here to handle such situation.
 529  *
 530  * Trap entered via exceptions, so EE bit is set, and interrupts
 531  * are masked.  This is nice, means we don't have to CLI before state save
 532  *
 533  * Build a standard exception frame for TLB Access errors.  All TLB exceptions
 534  * will bail out to this point if they can't resolve the lightweight TLB fault.
 535  *
 536  * The C function called is in "arch/microblaze/mm/fault.c", declared as:
 537  * void do_page_fault(struct pt_regs *regs,
 538  *                              unsigned long address,
 539  *                              unsigned long error_code)
 540  */
 541 /* data and intruction trap - which is choose is resolved int fault.c */
 542 C_ENTRY(page_fault_data_trap):
 543         SAVE_STATE              /* Save registers.*/
 544         /* PC, before IRQ/trap - this is one instruction above */
 545         swi     r17, r1, PTO+PT_PC;
 546         tovirt(r1,r1)
 547         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 548         addik   r15, r0, ret_from_exc-8
 549         mfs     r6, rear                /* parameter unsigned long address */
 550         mfs     r7, resr                /* parameter unsigned long error_code */
 551         rted    r0, do_page_fault
 552         addik   r5, r1, PTO             /* parameter struct pt_regs * regs */
 553
 554 C_ENTRY(page_fault_instr_trap):
 555         SAVE_STATE              /* Save registers.*/
 556         /* PC, before IRQ/trap - this is one instruction above */
 557         swi     r17, r1, PTO+PT_PC;
 558         tovirt(r1,r1)
 559         /* where the trap should return need -8 to adjust for rtsd r15, 8 */
 560         addik   r15, r0, ret_from_exc-8
 561         mfs     r6, rear                /* parameter unsigned long address */
 562         ori     r7, r0, 0               /* parameter unsigned long error_code */
 563         rted    r0, do_page_fault
 564         addik   r5, r1, PTO             /* parameter struct pt_regs * regs */
 565
 566 /* Entry point used to return from an exception.  */
 567 C_ENTRY(ret_from_exc):
 568         lwi     r11, r1, PTO + PT_MODE;
 569         bnei    r11, 2f;                /* See if returning to kernel mode, */
 570                                         /* ... if so, skip resched &c.  */
 571
 572         /* We're returning to user mode, so check for various conditions that
 573            trigger rescheduling. */
 574         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 575         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 576         andi    r11, r11, _TIF_NEED_RESCHED;
 577         beqi    r11, 5f;
 578
 579 /* Call the scheduler before returning from a syscall/trap. */
 580         bralid  r15, schedule;  /* Call scheduler */
 581         nop;                            /* delay slot */
 582
 583         /* Maybe handle a signal */
 584 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 585         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 586         andi    r11, r11, _TIF_SIGPENDING;
 587         beqi    r11, 1f;                /* Signals to handle, handle them */
 588
 589         /*
 590          * Handle a signal return; Pending signals should be in r18.
 591          *
 592          * Not all registers are saved by the normal trap/interrupt entry
 593          * points (for instance, call-saved registers (because the normal
 594          * C-compiler calling sequence in the kernel makes sure they're
 595          * preserved), and call-clobbered registers in the case of
 596          * traps), but signal handlers may want to examine or change the
 597          * complete register state.  Here we save anything not saved by
 598          * the normal entry sequence, so that it may be safely restored
 599          * (in a possibly modified form) after do_signal returns. */
 600         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 601         addi    r7, r0, 0;              /* Arg 3: int in_syscall */
 602         bralid  r15, do_signal; /* Handle any signals */
 603         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 604
 605 /* Finally, return to user state.  */
 606 1:      set_bip;                        /* Ints masked for state restore */
 607         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 608         VM_OFF;
 609         tophys(r1,r1);
 610
 611         RESTORE_REGS;
 612         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 613
 614         lwi     r1, r1, PT_R1 - PT_SIZE; /* Restore user stack pointer. */
 615         bri     6f;
 616 /* Return to kernel state.  */
 617 2:      set_bip;                        /* Ints masked for state restore */
 618         VM_OFF;
 619         tophys(r1,r1);
 620         RESTORE_REGS;
 621         addik   r1, r1, STATE_SAVE_SIZE         /* Clean up stack space.  */
 622
 623         tovirt(r1,r1);
 624 6:
 625 EXC_return:             /* Make global symbol for debugging */
 626         rtbd    r14, 0; /* Instructions to return from an IRQ */
 627         nop;
 628
 629 /*
 630  * HW EXCEPTION rutine end
 631  */
 632
 633 /*
 634  * Hardware maskable interrupts.
 635  *
 636  * The stack-pointer (r1) should have already been saved to the memory
 637  * location PER_CPU(ENTRY_SP).
 638  */
 639 C_ENTRY(_interrupt):
 640 /* MS: we are in physical address */
 641 /* Save registers, switch to proper stack, convert SP to virtual.*/
 642         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 643         /* MS: See if already in kernel mode. */
 644         mfs     r1, rmsr
 645         nop
 646         andi    r1, r1, MSR_UMS
 647         bnei    r1, 1f
 648
 649 /* Kernel-mode state save. */
 650         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 651         tophys(r1,r1); /* MS: I have in r1 physical address where stack is */
 652         /* save registers */
 653 /* MS: Make room on the stack -> activation record */
 654         addik   r1, r1, -STATE_SAVE_SIZE;
 655         SAVE_REGS
 656         brid    2f;
 657         swi     r1, r1, PTO + PT_MODE; /* 0 - user mode, 1 - kernel mode */
 658 1:
 659 /* User-mode state save. */
 660  /* MS: get the saved current */
 661         lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 662         tophys(r1,r1);
 663         lwi     r1, r1, TS_THREAD_INFO;
 664         addik   r1, r1, THREAD_SIZE;
 665         tophys(r1,r1);
 666         /* save registers */
 667         addik   r1, r1, -STATE_SAVE_SIZE;
 668         SAVE_REGS
 669         /* calculate mode */
 670         swi     r0, r1, PTO + PT_MODE;
 671         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 672         swi     r11, r1, PTO+PT_R1;
 673         clear_ums;
 674 2:
 675         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 676         tovirt(r1,r1)
 677         addik   r15, r0, irq_call;
 678 irq_call:rtbd   r0, do_IRQ;
 679         addik   r5, r1, PTO;
 680
 681 /* MS: we are in virtual mode */
 682 ret_from_irq:
 683         lwi     r11, r1, PTO + PT_MODE;
 684         bnei    r11, 2f;
 685
 686         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 687         lwi     r11, r11, TI_FLAGS; /* MS: get flags from thread info */
 688         andi    r11, r11, _TIF_NEED_RESCHED;
 689         beqi    r11, 5f
 690         bralid  r15, schedule;
 691         nop; /* delay slot */
 692
 693     /* Maybe handle a signal */
 694 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO; /* MS: get thread info */
 695         lwi     r11, r11, TI_FLAGS; /* get flags in thread info */
 696         andi    r11, r11, _TIF_SIGPENDING;
 697         beqid   r11, no_intr_resched
 698 /* Handle a signal return; Pending signals should be in r18. */
 699         addi    r7, r0, 0; /* Arg 3: int in_syscall */
 700         addik   r5, r1, PTO; /* Arg 1: struct pt_regs *regs */
 701         bralid  r15, do_signal; /* Handle any signals */
 702         add     r6, r0, r0; /* Arg 2: sigset_t *oldset */
 703
 704 /* Finally, return to user state. */
 705 no_intr_resched:
 706     /* Disable interrupts, we are now committed to the state restore */
 707         disable_irq
 708         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE);
 709         VM_OFF;
 710         tophys(r1,r1);
 711         RESTORE_REGS
 712         addik   r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
 713         lwi     r1, r1, PT_R1 - PT_SIZE;
 714         bri     6f;
 715 /* MS: Return to kernel state. */
 716 2:
 717 #ifdef CONFIG_PREEMPT
 718         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;
 719         /* MS: get preempt_count from thread info */
 720         lwi     r5, r11, TI_PREEMPT_COUNT;
 721         bgti    r5, restore;
 722
 723         lwi     r5, r11, TI_FLAGS;              /* get flags in thread info */
 724         andi    r5, r5, _TIF_NEED_RESCHED;
 725         beqi    r5, restore /* if zero jump over */
 726
 727 preempt:
 728         /* interrupts are off that's why I am calling preempt_chedule_irq */
 729         bralid  r15, preempt_schedule_irq
 730         nop
 731         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 732         lwi     r5, r11, TI_FLAGS;              /* get flags in thread info */
 733         andi    r5, r5, _TIF_NEED_RESCHED;
 734         bnei    r5, preempt /* if non zero jump to resched */
 735 restore:
 736 #endif
 737         VM_OFF /* MS: turn off MMU */
 738         tophys(r1,r1)
 739         RESTORE_REGS
 740         addik   r1, r1, STATE_SAVE_SIZE /* MS: Clean up stack space. */
 741         tovirt(r1,r1);
 742 6:
 743 IRQ_return: /* MS: Make global symbol for debugging */
 744         rtid    r14, 0
 745         nop
 746
 747 /*
 748  * Debug trap for KGDB. Enter to _debug_exception by brki r16, 0x18
 749  * and call handling function with saved pt_regs
 750  */
 751 C_ENTRY(_debug_exception):
 752         /* BIP bit is set on entry, no interrupts can occur */
 753         swi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP))
 754
 755         mfs     r1, rmsr
 756         nop
 757         andi    r1, r1, MSR_UMS
 758         bnei    r1, 1f
 759 /* MS: Kernel-mode state save - kgdb */
 760         lwi     r1, r0, TOPHYS(PER_CPU(ENTRY_SP)); /* Reload kernel stack-ptr*/
 761
 762         /* BIP bit is set on entry, no interrupts can occur */
 763         addik   r1, r1, CONFIG_KERNEL_BASE_ADDR - CONFIG_KERNEL_START - STATE_SAVE_SIZE;
 764         SAVE_REGS;
 765         /* save all regs to pt_reg structure */
 766         swi     r0, r1, PTO+PT_R0;      /* R0 must be saved too */
 767         swi     r14, r1, PTO+PT_R14     /* rewrite saved R14 value */
 768         swi     r16, r1, PTO+PT_R16
 769         swi     r16, r1, PTO+PT_PC; /* PC and r16 are the same */
 770         swi     r17, r1, PTO+PT_R17
 771         /* save special purpose registers to pt_regs */
 772         mfs     r11, rear;
 773         swi     r11, r1, PTO+PT_EAR;
 774         mfs     r11, resr;
 775         swi     r11, r1, PTO+PT_ESR;
 776         mfs     r11, rfsr;
 777         swi     r11, r1, PTO+PT_FSR;
 778
 779         /* stack pointer is in physical address at it is decrease
 780          * by STATE_SAVE_SIZE but we need to get correct R1 value */
 781         addik   r11, r1, CONFIG_KERNEL_START - CONFIG_KERNEL_BASE_ADDR + STATE_SAVE_SIZE;
 782         swi     r11, r1, PTO+PT_R1
 783         /* MS: r31 - current pointer isn't changed */
 784         tovirt(r1,r1)
 785 #ifdef CONFIG_KGDB
 786         addi    r5, r1, PTO /* pass pt_reg address as the first arg */
 787         la      r15, r0, dbtrap_call; /* return address */
 788         rtbd    r0, microblaze_kgdb_break
 789         nop;
 790 #endif
 791         /* MS: Place handler for brki from kernel space if KGDB is OFF.
 792          * It is very unlikely that another brki instruction is called. */
 793         bri 0
 794
 795 /* MS: User-mode state save - gdb */
 796 1:      lwi     r1, r0, TOPHYS(PER_CPU(CURRENT_SAVE)); /* get saved current */
 797         tophys(r1,r1);
 798         lwi     r1, r1, TS_THREAD_INFO; /* get the thread info */
 799         addik   r1, r1, THREAD_SIZE;    /* calculate kernel stack pointer */
 800         tophys(r1,r1);
 801
 802         addik   r1, r1, -STATE_SAVE_SIZE; /* Make room on the stack.  */
 803         SAVE_REGS;
 804         swi     r17, r1, PTO+PT_R17;
 805         swi     r16, r1, PTO+PT_R16;
 806         swi     r16, r1, PTO+PT_PC;     /* Save LP */
 807         swi     r0, r1, PTO + PT_MODE; /* Was in user-mode.  */
 808         lwi     r11, r0, TOPHYS(PER_CPU(ENTRY_SP));
 809         swi     r11, r1, PTO+PT_R1; /* Store user SP.  */
 810         lwi     CURRENT_TASK, r0, TOPHYS(PER_CPU(CURRENT_SAVE));
 811         tovirt(r1,r1)
 812         set_vms;
 813         addik   r5, r1, PTO;
 814         addik   r15, r0, dbtrap_call;
 815 dbtrap_call: /* Return point for kernel/user entry + 8 because of rtsd r15, 8 */
 816         rtbd    r0, sw_exception
 817         nop
 818
 819         /* MS: The first instruction for the second part of the gdb/kgdb */
 820         set_bip; /* Ints masked for state restore */
 821         lwi     r11, r1, PTO + PT_MODE;
 822         bnei    r11, 2f;
 823 /* MS: Return to user space - gdb */
 824         /* Get current task ptr into r11 */
 825         lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 826         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 827         andi    r11, r11, _TIF_NEED_RESCHED;
 828         beqi    r11, 5f;
 829
 830         /* Call the scheduler before returning from a syscall/trap. */
 831         bralid  r15, schedule;  /* Call scheduler */
 832         nop;                            /* delay slot */
 833
 834         /* Maybe handle a signal */
 835 5:      lwi     r11, CURRENT_TASK, TS_THREAD_INFO;      /* get thread info */
 836         lwi     r11, r11, TI_FLAGS;     /* get flags in thread info */
 837         andi    r11, r11, _TIF_SIGPENDING;
 838         beqi    r11, 1f;                /* Signals to handle, handle them */
 839
 840         addik   r5, r1, PTO;            /* Arg 1: struct pt_regs *regs */
 841         addi  r7, r0, 0;        /* Arg 3: int in_syscall */
 842         bralid  r15, do_signal; /* Handle any signals */
 843         add     r6, r0, r0;             /* Arg 2: sigset_t *oldset */
 844
 845 /* Finally, return to user state.  */
 846 1:      swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE); /* save current */
 847         VM_OFF;
 848         tophys(r1,r1);
 849         /* MS: Restore all regs */
 850         RESTORE_REGS
 851         lwi     r17, r1, PTO+PT_R17;
 852         lwi     r16, r1, PTO+PT_R16;
 853         addik   r1, r1, STATE_SAVE_SIZE  /* Clean up stack space */
 854         lwi     r1, r1, PT_R1 - PT_SIZE; /* Restore user stack pointer */
 855 DBTRAP_return_user: /* MS: Make global symbol for debugging */
 856         rtbd    r16, 0; /* MS: Instructions to return from a debug trap */
 857         nop;
 858
 859 /* MS: Return to kernel state - kgdb */
 860 2:      VM_OFF;
 861         tophys(r1,r1);
 862         /* MS: Restore all regs */
 863         RESTORE_REGS
 864         lwi     r14, r1, PTO+PT_R14;
 865         lwi     r16, r1, PTO+PT_PC;
 866         lwi     r17, r1, PTO+PT_R17;
 867         addik   r1, r1, STATE_SAVE_SIZE; /* MS: Clean up stack space */
 868         tovirt(r1,r1);
 869 DBTRAP_return_kernel: /* MS: Make global symbol for debugging */
 870         rtbd    r16, 0; /* MS: Instructions to return from a debug trap */
 871         nop;
 872
 873
 874 ENTRY(_switch_to)
 875         /* prepare return value */
 876         addk    r3, r0, CURRENT_TASK
 877
 878         /* save registers in cpu_context */
 879         /* use r11 and r12, volatile registers, as temp register */
 880         /* give start of cpu_context for previous process */
 881         addik   r11, r5, TI_CPU_CONTEXT
 882         swi     r1, r11, CC_R1
 883         swi     r2, r11, CC_R2
 884         /* skip volatile registers.
 885          * they are saved on stack when we jumped to _switch_to() */
 886         /* dedicated registers */
 887         swi     r13, r11, CC_R13
 888         swi     r14, r11, CC_R14
 889         swi     r15, r11, CC_R15
 890         swi     r16, r11, CC_R16
 891         swi     r17, r11, CC_R17
 892         swi     r18, r11, CC_R18
 893         /* save non-volatile registers */
 894         swi     r19, r11, CC_R19
 895         swi     r20, r11, CC_R20
 896         swi     r21, r11, CC_R21
 897         swi     r22, r11, CC_R22
 898         swi     r23, r11, CC_R23
 899         swi     r24, r11, CC_R24
 900         swi     r25, r11, CC_R25
 901         swi     r26, r11, CC_R26
 902         swi     r27, r11, CC_R27
 903         swi     r28, r11, CC_R28
 904         swi     r29, r11, CC_R29
 905         swi     r30, r11, CC_R30
 906         /* special purpose registers */
 907         mfs     r12, rmsr
 908         swi     r12, r11, CC_MSR
 909         mfs     r12, rear
 910         swi     r12, r11, CC_EAR
 911         mfs     r12, resr
 912         swi     r12, r11, CC_ESR
 913         mfs     r12, rfsr
 914         swi     r12, r11, CC_FSR
 915
 916         /* update r31, the current-give me pointer to task which will be next */
 917         lwi     CURRENT_TASK, r6, TI_TASK
 918         /* stored it to current_save too */
 919         swi     CURRENT_TASK, r0, PER_CPU(CURRENT_SAVE)
 920
 921         /* get new process' cpu context and restore */
 922         /* give me start where start context of next task */
 923         addik   r11, r6, TI_CPU_CONTEXT
 924
 925         /* non-volatile registers */
 926         lwi     r30, r11, CC_R30
 927         lwi     r29, r11, CC_R29
 928         lwi     r28, r11, CC_R28
 929         lwi     r27, r11, CC_R27
 930         lwi     r26, r11, CC_R26
 931         lwi     r25, r11, CC_R25
 932         lwi     r24, r11, CC_R24
 933         lwi     r23, r11, CC_R23
 934         lwi     r22, r11, CC_R22
 935         lwi     r21, r11, CC_R21
 936         lwi     r20, r11, CC_R20
 937         lwi     r19, r11, CC_R19
 938         /* dedicated registers */
 939         lwi     r18, r11, CC_R18
 940         lwi     r17, r11, CC_R17
 941         lwi     r16, r11, CC_R16
 942         lwi     r15, r11, CC_R15
 943         lwi     r14, r11, CC_R14
 944         lwi     r13, r11, CC_R13
 945         /* skip volatile registers */
 946         lwi     r2, r11, CC_R2
 947         lwi     r1, r11, CC_R1
 948
 949         /* special purpose registers */
 950         lwi     r12, r11, CC_FSR
 951         mts     rfsr, r12
 952         lwi     r12, r11, CC_MSR
 953         mts     rmsr, r12
 954
 955         rtsd    r15, 8
 956         nop
 957
 958 ENTRY(_reset)
 959         brai    0x70; /* Jump back to FS-boot */
 960
 961         /* These are compiled and loaded into high memory, then
 962          * copied into place in mach_early_setup */
 963         .section        .init.ivt, "ax"
 964         .org    0x0
 965         /* this is very important - here is the reset vector */
 966         /* in current MMU branch you don't care what is here - it is
 967          * used from bootloader site - but this is correct for FS-BOOT */
 968         brai    0x70
 969         nop
 970         brai    TOPHYS(_user_exception); /* syscall handler */
 971         brai    TOPHYS(_interrupt);     /* Interrupt handler */
 972         brai    TOPHYS(_debug_exception);       /* debug trap handler */
 973         brai    TOPHYS(_hw_exception_handler);  /* HW exception handler */
 974
 975 .section .rodata,"a"
 976 #include "syscall_table.S"
 977
 978 syscall_table_size=(.-sys_call_table)
 979
 980 type_SYSCALL:
 981         .ascii "SYSCALL\0"
 982 type_IRQ:
 983         .ascii "IRQ\0"
 984 type_IRQ_PREEMPT:
 985         .ascii "IRQ (PREEMPTED)\0"
 986 type_SYSCALL_PREEMPT:
 987         .ascii " SYSCALL (PREEMPTED)\0"
 988
 989         /*
 990          * Trap decoding for stack unwinder
 991          * Tuples are (start addr, end addr, string)
 992          * If return address lies on [start addr, end addr],
 993          * unwinder displays 'string'
 994          */
 995
 996         .align 4
 997 .global microblaze_trap_handlers
 998 microblaze_trap_handlers:
 999         /* Exact matches come first */
1000         .word ret_from_trap; .word ret_from_trap   ; .word type_SYSCALL
1001         .word ret_from_irq ; .word ret_from_irq    ; .word type_IRQ
1002         /* Fuzzy matches go here */
1003         .word ret_from_irq ; .word no_intr_resched ; .word type_IRQ_PREEMPT
1004         .word ret_from_trap; .word TRAP_return     ; .word type_SYSCALL_PREEMPT
1005         /* End of table */
1006         .word 0               ; .word 0               ; .word 0