arch/microblaze/kernel/hw_exception_handler.S

   1 /*
   2  * Exception handling for Microblaze
   3  *
   4  * Rewriten interrupt handling
   5  *
   6  * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
   7  * Copyright (C) 2008-2009 PetaLogix
   8  *
   9  * uClinux customisation (C) 2005 John Williams
  10  *
  11  * MMU code derived from arch/ppc/kernel/head_4xx.S:
  12  *      Copyright (C) 1995-1996 Gary Thomas <gdt@linuxppc.org>
  13  *              Initial PowerPC version.
  14  *      Copyright (C) 1996 Cort Dougan <cort@cs.nmt.edu>
  15  *              Rewritten for PReP
  16  *      Copyright (C) 1996 Paul Mackerras <paulus@cs.anu.edu.au>
  17  *              Low-level exception handers, MMU support, and rewrite.
  18  *      Copyright (C) 1997 Dan Malek <dmalek@jlc.net>
  19  *              PowerPC 8xx modifications.
  20  *      Copyright (C) 1998-1999 TiVo, Inc.
  21  *              PowerPC 403GCX modifications.
  22  *      Copyright (C) 1999 Grant Erickson <grant@lcse.umn.edu>
  23  *              PowerPC 403GCX/405GP modifications.
  24  *      Copyright 2000 MontaVista Software Inc.
  25  *              PPC405 modifications
  26  *      PowerPC 403GCX/405GP modifications.
  27  *              Author: MontaVista Software, Inc.
  28  *              frank_rowand@mvista.com or source@mvista.com
  29  *              debbie_chu@mvista.com
  30  *
  31  * Original code
  32  * Copyright (C) 2004 Xilinx, Inc.
  33  *
  34  * This program is free software; you can redistribute it and/or modify it
  35  * under the terms of the GNU General Public License version 2 as published
  36  * by the Free Software Foundation.
  37  */
  38
  39 /*
  40  * Here are the handlers which don't require enabling translation
  41  * and calling other kernel code thus we can keep their design very simple
  42  * and do all processing in real mode. All what they need is a valid current
  43  * (that is an issue for the CONFIG_REGISTER_TASK_PTR case)
  44  * This handlers use r3,r4,r5,r6 and optionally r[current] to work therefore
  45  * these registers are saved/restored
  46  * The handlers which require translation are in entry.S --KAA
  47  *
  48  * Microblaze HW Exception Handler
  49  * - Non self-modifying exception handler for the following exception conditions
  50  *   - Unalignment
  51  *   - Instruction bus error
  52  *   - Data bus error
  53  *   - Illegal instruction opcode
  54  *   - Divide-by-zero
  55  *
  56  * Note we disable interrupts during exception handling, otherwise we will
  57  * possibly get multiple re-entrancy if interrupt handles themselves cause
  58  * exceptions. JW
  59  */
  60
  61 #include <asm/exceptions.h>
  62 #include <asm/unistd.h>
  63 #include <asm/page.h>
  64
  65 #include <asm/entry.h>
  66 #include <asm/current.h>
  67 #include <linux/linkage.h>
  68
  69 #include <asm/mmu.h>
  70 #include <asm/pgtable.h>
  71 #include <asm/asm-offsets.h>
  72
  73 /* Helpful Macros */
  74 #define EX_HANDLER_STACK_SIZ    (4*19)
  75 #define NUM_TO_REG(num)         r ## num
  76
  77 #define LWREG_NOP                       \
  78         bri     ex_handler_unhandled;   \
  79         nop;
  80
  81 #define SWREG_NOP                       \
  82         bri     ex_handler_unhandled;   \
  83         nop;
  84
  85 /* FIXME this is weird - for noMMU kernel is not possible to use brid
  86  * instruction which can shorten executed time
  87  */
  88
  89 /* r3 is the source */
  90 #define R3_TO_LWREG_V(regnum)                           \
  91         swi     r3, r1, 4 * regnum;                             \
  92         bri     ex_handler_done;
  93
  94 /* r3 is the source */
  95 #define R3_TO_LWREG(regnum)                             \
  96         or      NUM_TO_REG (regnum), r0, r3;            \
  97         bri     ex_handler_done;
  98
  99 /* r3 is the target */
 100 #define SWREG_TO_R3_V(regnum)                           \
 101         lwi     r3, r1, 4 * regnum;                             \
 102         bri     ex_sw_tail;
 103
 104 /* r3 is the target */
 105 #define SWREG_TO_R3(regnum)                             \
 106         or      r3, r0, NUM_TO_REG (regnum);            \
 107         bri     ex_sw_tail;
 108
 109 .extern other_exception_handler /* Defined in exception.c */
 110
 111 /*
 112  * hw_exception_handler - Handler for exceptions
 113  *
 114  * Exception handler notes:
 115  * - Handles all exceptions
 116  * - Does not handle unaligned exceptions during load into r17, r1, r0.
 117  * - Does not handle unaligned exceptions during store from r17 (cannot be
 118  *   done) and r1 (slows down common case)
 119  *
 120  *  Relevant register structures
 121  *
 122  *  EAR - |----|----|----|----|----|----|----|----|
 123  *      - <  ##   32 bit faulting address     ##  >
 124  *
 125  *  ESR - |----|----|----|----|----| - | - |-----|-----|
 126  *      -                            W   S   REG   EXC
 127  *
 128  *
 129  * STACK FRAME STRUCTURE (for NO_MMU)
 130  * ---------------------------------
 131  *
 132  *      +-------------+         + 0
 133  *      |     MSR     |
 134  *      +-------------+         + 4
 135  *      |     r1      |
 136  *      |      .      |
 137  *      |      .      |
 138  *      |      .      |
 139  *      |      .      |
 140  *      |     r18     |
 141  *      +-------------+         + 76
 142  *      |      .      |
 143  *      |      .      |
 144  *
 145  * NO_MMU kernel use the same r0_ram pointed space - look to vmlinux.lds.S
 146  * which is used for storing register values - old style was, that value were
 147  * stored in stack but in case of failure you lost information about register.
 148  * Currently you can see register value in memory in specific place.
 149  * In compare to with previous solution the speed should be the same.
 150  *
 151  * MMU exception handler has different handling compare to no MMU kernel.
 152  * Exception handler use jump table for directing of what happen. For MMU kernel
 153  * is this approach better because MMU relate exception are handled by asm code
 154  * in this file. In compare to with MMU expect of unaligned exception
 155  * is everything handled by C code.
 156  */
 157
 158 /*
 159  * every of these handlers is entered having R3/4/5/6/11/current saved on stack
 160  * and clobbered so care should be taken to restore them if someone is going to
 161  * return from exception
 162  */
 163
 164 /* wrappers to restore state before coming to entry.S */
 165
 166 .global _hw_exception_handler
 167 .section .text
 168 .align 4
 169 .ent _hw_exception_handler
 170 _hw_exception_handler:
 171         addik   r1, r1, -(EX_HANDLER_STACK_SIZ); /* Create stack frame */
 172         swi     r3, r1, PT_R3
 173         swi     r4, r1, PT_R4
 174         swi     r5, r1, PT_R5
 175         swi     r6, r1, PT_R6
 176
 177         mfs     r5, rmsr;
 178         nop
 179         swi     r5, r1, 0;
 180         mfs     r4, rbtr        /* Save BTR before jumping to handler */
 181         nop
 182         mfs     r3, resr
 183         nop
 184
 185         andi    r5, r3, 0x1000;         /* Check ESR[DS] */
 186         beqi    r5, not_in_delay_slot;  /* Branch if ESR[DS] not set */
 187         mfs     r17, rbtr;      /* ESR[DS] set - return address in BTR */
 188         nop
 189 not_in_delay_slot:
 190         swi     r17, r1, PT_R17
 191
 192         andi    r5, r3, 0x1F;           /* Extract ESR[EXC] */
 193
 194         /* Exceptions enabled here. This will allow nested exceptions */
 195         mfs     r6, rmsr;
 196         nop
 197         swi     r6, r1, 0; /* RMSR_OFFSET */
 198         ori     r6, r6, 0x100; /* Turn ON the EE bit */
 199         andi    r6, r6, ~2; /* Disable interrupts */
 200         mts     rmsr, r6;
 201         nop
 202
 203         xori    r6, r5, 1; /* 00001 = Unaligned Exception */
 204         /* Jump to unalignment exception handler */
 205         beqi    r6, handle_unaligned_ex;
 206
 207 handle_other_ex: /* Handle Other exceptions here */
 208         /* Save other volatiles before we make procedure calls below */
 209         swi     r7, r1, PT_R7
 210         swi     r8, r1, PT_R8
 211         swi     r9, r1, PT_R9
 212         swi     r10, r1, PT_R10
 213         swi     r11, r1, PT_R11
 214         swi     r12, r1, PT_R12
 215         swi     r14, r1, PT_R14
 216         swi     r15, r1, PT_R15
 217         swi     r18, r1, PT_R18
 218
 219         or      r5, r1, r0
 220         andi    r6, r3, 0x1F; /* Load ESR[EC] */
 221         lwi     r7, r0, PER_CPU(KM) /* MS: saving current kernel mode to regs */
 222         swi     r7, r1, PT_MODE
 223         mfs     r7, rfsr
 224         nop
 225         addk    r8, r17, r0; /* Load exception address */
 226         bralid  r15, full_exception; /* Branch to the handler */
 227         nop;
 228
 229         /*
 230          * Trigger execution of the signal handler by enabling
 231          * interrupts and calling an invalid syscall.
 232          */
 233         mfs     r5, rmsr;
 234         nop
 235         ori     r5, r5, 2;
 236         mts     rmsr, r5; /* enable interrupt */
 237         nop
 238         addi    r12, r0, __NR_syscalls;
 239         brki    r14, 0x08;
 240         mfs     r5, rmsr; /* disable interrupt */
 241         nop
 242         andi    r5, r5, ~2;
 243         mts     rmsr, r5;
 244         nop
 245
 246         lwi     r7, r1, PT_R7
 247         lwi     r8, r1, PT_R8
 248         lwi     r9, r1, PT_R9
 249         lwi     r10, r1, PT_R10
 250         lwi     r11, r1, PT_R11
 251         lwi     r12, r1, PT_R12
 252         lwi     r14, r1, PT_R14
 253         lwi     r15, r1, PT_R15
 254         lwi     r18, r1, PT_R18
 255
 256         bri     ex_handler_done; /* Complete exception handling */
 257
 258 /* 0x01 - Unaligned data access exception
 259  * This occurs when a word access is not aligned on a word boundary,
 260  * or when a 16-bit access is not aligned on a 16-bit boundary.
 261  * This handler perform the access, and returns, except for MMU when
 262  * the unaligned address is last on a 4k page or the physical address is
 263  * not found in the page table, in which case unaligned_data_trap is called.
 264  */
 265 handle_unaligned_ex:
 266         /* Working registers already saved: R3, R4, R5, R6
 267          *  R3 = ESR
 268          *  R4 = BTR
 269          */
 270         mfs     r4, rear;
 271         nop
 272
 273         andi    r6, r3, 0x3E0; /* Mask and extract the register operand */
 274         srl     r6, r6; /* r6 >> 5 */
 275         srl     r6, r6;
 276         srl     r6, r6;
 277         srl     r6, r6;
 278         srl     r6, r6;
 279         /* Store the register operand in a temporary location */
 280         sbi     r6, r0, TOPHYS(ex_reg_op);
 281
 282         andi    r6, r3, 0x400; /* Extract ESR[S] */
 283         bnei    r6, ex_sw;
 284 ex_lw:
 285         andi    r6, r3, 0x800; /* Extract ESR[W] */
 286         beqi    r6, ex_lhw;
 287         lbui    r5, r4, 0; /* Exception address in r4 */
 288         /* Load a word, byte-by-byte from destination address
 289                 and save it in tmp space */
 290         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_0);
 291         lbui    r5, r4, 1;
 292         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_1);
 293         lbui    r5, r4, 2;
 294         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_2);
 295         lbui    r5, r4, 3;
 296         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_3);
 297         /* Get the destination register value into r3 */
 298         lwi     r3, r0, TOPHYS(ex_tmp_data_loc_0);
 299         bri     ex_lw_tail;
 300 ex_lhw:
 301         lbui    r5, r4, 0; /* Exception address in r4 */
 302         /* Load a half-word, byte-by-byte from destination
 303                 address and save it in tmp space */
 304         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_0);
 305         lbui    r5, r4, 1;
 306         sbi     r5, r0, TOPHYS(ex_tmp_data_loc_1);
 307         /* Get the destination register value into r3 */
 308         lhui    r3, r0, TOPHYS(ex_tmp_data_loc_0);
 309 ex_lw_tail:
 310         /* Get the destination register number into r5 */
 311         lbui    r5, r0, TOPHYS(ex_reg_op);
 312         /* Form load_word jump table offset (lw_table + (8 * regnum)) */
 313         la      r6, r0, TOPHYS(lw_table);
 314         addk    r5, r5, r5;
 315         addk    r5, r5, r5;
 316         addk    r5, r5, r5;
 317         addk    r5, r5, r6;
 318         bra     r5;
 319 ex_lw_end: /* Exception handling of load word, ends */
 320 ex_sw:
 321         /* Get the destination register number into r5 */
 322         lbui    r5, r0, TOPHYS(ex_reg_op);
 323         /* Form store_word jump table offset (sw_table + (8 * regnum)) */
 324         la      r6, r0, TOPHYS(sw_table);
 325         add     r5, r5, r5;
 326         add     r5, r5, r5;
 327         add     r5, r5, r5;
 328         add     r5, r5, r6;
 329         bra     r5;
 330 ex_sw_tail:
 331         mfs     r6, resr;
 332         nop
 333         andi    r6, r6, 0x800; /* Extract ESR[W] */
 334         beqi    r6, ex_shw;
 335         /* Get the word - delay slot */
 336         swi     r3, r0, TOPHYS(ex_tmp_data_loc_0);
 337         /* Store the word, byte-by-byte into destination address */
 338         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_0);
 339         sbi     r3, r4, 0;
 340         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_1);
 341         sbi     r3, r4, 1;
 342         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_2);
 343         sbi     r3, r4, 2;
 344         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_3);
 345         sbi     r3, r4, 3;
 346         bri     ex_handler_done;
 347
 348 ex_shw:
 349         /* Store the lower half-word, byte-by-byte into destination address */
 350         swi     r3, r0, TOPHYS(ex_tmp_data_loc_0);
 351         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_2);
 352         sbi     r3, r4, 0;
 353         lbui    r3, r0, TOPHYS(ex_tmp_data_loc_3);
 354         sbi     r3, r4, 1;
 355 ex_sw_end: /* Exception handling of store word, ends. */
 356
 357 ex_handler_done:
 358         lwi     r5, r1, 0 /* RMSR */
 359         mts     rmsr, r5
 360         nop
 361         lwi     r3, r1, PT_R3
 362         lwi     r4, r1, PT_R4
 363         lwi     r5, r1, PT_R5
 364         lwi     r6, r1, PT_R6
 365         lwi     r17, r1, PT_R17
 366
 367         rted    r17, 0
 368         addik   r1, r1, (EX_HANDLER_STACK_SIZ); /* Restore stack frame */
 369
 370 .end _hw_exception_handler
 371
 372 ex_handler_unhandled:
 373 /* FIXME add handle function for unhandled exception - dump register */
 374         bri 0
 375
 376 .section .text
 377 .align 4
 378 lw_table:
 379 lw_r0:          R3_TO_LWREG     (0);
 380 lw_r1:          LWREG_NOP;
 381 lw_r2:          R3_TO_LWREG     (2);
 382 lw_r3:          R3_TO_LWREG_V   (3);
 383 lw_r4:          R3_TO_LWREG_V   (4);
 384 lw_r5:          R3_TO_LWREG_V   (5);
 385 lw_r6:          R3_TO_LWREG_V   (6);
 386 lw_r7:          R3_TO_LWREG     (7);
 387 lw_r8:          R3_TO_LWREG     (8);
 388 lw_r9:          R3_TO_LWREG     (9);
 389 lw_r10:         R3_TO_LWREG     (10);
 390 lw_r11:         R3_TO_LWREG     (11);
 391 lw_r12:         R3_TO_LWREG     (12);
 392 lw_r13:         R3_TO_LWREG     (13);
 393 lw_r14:         R3_TO_LWREG     (14);
 394 lw_r15:         R3_TO_LWREG     (15);
 395 lw_r16:         R3_TO_LWREG     (16);
 396 lw_r17:         LWREG_NOP;
 397 lw_r18:         R3_TO_LWREG     (18);
 398 lw_r19:         R3_TO_LWREG     (19);
 399 lw_r20:         R3_TO_LWREG     (20);
 400 lw_r21:         R3_TO_LWREG     (21);
 401 lw_r22:         R3_TO_LWREG     (22);
 402 lw_r23:         R3_TO_LWREG     (23);
 403 lw_r24:         R3_TO_LWREG     (24);
 404 lw_r25:         R3_TO_LWREG     (25);
 405 lw_r26:         R3_TO_LWREG     (26);
 406 lw_r27:         R3_TO_LWREG     (27);
 407 lw_r28:         R3_TO_LWREG     (28);
 408 lw_r29:         R3_TO_LWREG     (29);
 409 lw_r30:         R3_TO_LWREG     (30);
 410 lw_r31:         R3_TO_LWREG     (31);
 411
 412 sw_table:
 413 sw_r0:          SWREG_TO_R3     (0);
 414 sw_r1:          SWREG_NOP;
 415 sw_r2:          SWREG_TO_R3     (2);
 416 sw_r3:          SWREG_TO_R3_V   (3);
 417 sw_r4:          SWREG_TO_R3_V   (4);
 418 sw_r5:          SWREG_TO_R3_V   (5);
 419 sw_r6:          SWREG_TO_R3_V   (6);
 420 sw_r7:          SWREG_TO_R3     (7);
 421 sw_r8:          SWREG_TO_R3     (8);
 422 sw_r9:          SWREG_TO_R3     (9);
 423 sw_r10:         SWREG_TO_R3     (10);
 424 sw_r11:         SWREG_TO_R3     (11);
 425 sw_r12:         SWREG_TO_R3     (12);
 426 sw_r13:         SWREG_TO_R3     (13);
 427 sw_r14:         SWREG_TO_R3     (14);
 428 sw_r15:         SWREG_TO_R3     (15);
 429 sw_r16:         SWREG_TO_R3     (16);
 430 sw_r17:         SWREG_NOP;
 431 sw_r18:         SWREG_TO_R3     (18);
 432 sw_r19:         SWREG_TO_R3     (19);
 433 sw_r20:         SWREG_TO_R3     (20);
 434 sw_r21:         SWREG_TO_R3     (21);
 435 sw_r22:         SWREG_TO_R3     (22);
 436 sw_r23:         SWREG_TO_R3     (23);
 437 sw_r24:         SWREG_TO_R3     (24);
 438 sw_r25:         SWREG_TO_R3     (25);
 439 sw_r26:         SWREG_TO_R3     (26);
 440 sw_r27:         SWREG_TO_R3     (27);
 441 sw_r28:         SWREG_TO_R3     (28);
 442 sw_r29:         SWREG_TO_R3     (29);
 443 sw_r30:         SWREG_TO_R3     (30);
 444 sw_r31:         SWREG_TO_R3     (31);
 445
 446 /* Temporary data structures used in the handler */
 447 .section .data
 448 .align 4
 449 ex_tmp_data_loc_0:
 450         .byte 0
 451 ex_tmp_data_loc_1:
 452         .byte 0
 453 ex_tmp_data_loc_2:
 454         .byte 0
 455 ex_tmp_data_loc_3:
 456         .byte 0
 457 ex_reg_op:
 458         .byte 0