libogc/exception.c

   1 /*-------------------------------------------------------------
   2
   3 exception.c -- PPC exception handling support
   4
   5 Copyright (C) 2004
   6 Michael Wiedenbauer (shagkur)
   7 Dave Murphy (WinterMute)
   8
   9 This software is provided 'as-is', without any express or implied
  10 warranty.  In no event will the authors be held liable for any
  11 damages arising from the use of this software.
  12
  13 Permission is granted to anyone to use this software for any
  14 purpose, including commercial applications, and to alter it and
  15 redistribute it freely, subject to the following restrictions:
  16
  17 1.      The origin of this software must not be misrepresented; you
  18 must not claim that you wrote the original software. If you use
  19 this software in a product, an acknowledgment in the product
  20 documentation would be appreciated but is not required.
  21
  22 2.      Altered source versions must be plainly marked as such, and
  23 must not be misrepresented as being the original software.
  24
  25 3.      This notice may not be removed or altered from any source
  26 distribution.
  27
  28 -------------------------------------------------------------*/
  29
  30
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include "asm.h"
  36 #include "processor.h"
  37 #include "cache.h"
  38 #include "irq.h"
  39 #include "context.h"
  40
  41 #include "system.h"
  42
  43 #include "gx.h"
  44 #include "pad.h"
  45 #include "consol.h"
  46 #include "console.h"
  47 #include "lwp_threads.h"
  48 #include "ios.h"
  49
  50 #include "ogc/video_types.h"
  51
  52 //#define _EXC_DEBUG
  53
  54 #define CPU_STACK_TRACE_DEPTH           10
  55
  56 typedef struct _framerec {
  57         struct _framerec *up;
  58         void *lr;
  59 } frame_rec, *frame_rec_t;
  60
  61 static void *exception_xfb = (void*)0xC1700000;                 //we use a static address above ArenaHi.
  62 static int reload_timer = -1;
  63
  64 void __exception_sethandler(u32 nExcept, void (*pHndl)(frame_context*));
  65
  66 extern void udelay(int us);
  67 extern void fpu_exceptionhandler();
  68 extern void irq_exceptionhandler();
  69 extern void dec_exceptionhandler();
  70 extern void default_exceptionhandler();
  71 extern void VIDEO_SetFramebuffer(void *);
  72 extern void __reload();
  73
  74 extern s8 exceptionhandler_start[],exceptionhandler_end[],exceptionhandler_patch[];
  75 extern s8 systemcallhandler_start[],systemcallhandler_end[];
  76
  77 void (*_exceptionhandlertable[NUM_EXCEPTIONS])(frame_context*);
  78
  79 static u32 exception_location[NUM_EXCEPTIONS] = {
  80                 0x00000100, 0x00000200, 0x00000300, 0x00000400,
  81                 0x00000500, 0x00000600, 0x00000700, 0x00000800,
  82                 0x00000900, 0x00000C00, 0x00000D00, 0x00000F00,
  83                 0x00001300, 0x00001400, 0x00001700 };
  84
  85 static const char *exception_name[NUM_EXCEPTIONS] = {
  86                 "System Reset", "Machine Check", "DSI", "ISI",
  87                 "Interrupt", "Alignment", "Program", "Floating Point",
  88                 "Decrementer", "System Call", "Trace", "Performance",
  89                 "IABR", "Reserved", "Thermal"};
  90
  91 void __exception_load(u32 nExc,void *data,u32 len,void *patch)
  92 {
  93         void *pAddr = (void*)(0x80000000|exception_location[nExc]);
  94         memcpy(pAddr,data,len);
  95         if(patch)
  96                 *(u32*)((u32)pAddr+(patch-data)) |= nExc;
  97
  98         DCFlushRangeNoSync(pAddr,len);
  99         ICInvalidateRange(pAddr,len);
 100         _sync();
 101 }
 102
 103 void __systemcall_init()
 104 {
 105         __exception_load(EX_SYS_CALL,systemcallhandler_start,(systemcallhandler_end-systemcallhandler_start),NULL);
 106 }
 107
 108 void __exception_init()
 109 {
 110         s32 i;
 111 #ifdef _EXC_DEBUG
 112         kprintf("__exception_init()\n\n");
 113 #endif
 114         // init all exceptions with the default handler & vector code
 115         for(i=0;i<NUM_EXCEPTIONS;i++) {
 116                 // load default exception vector handler code
 117                 __exception_load(i,exceptionhandler_start,(exceptionhandler_end-exceptionhandler_start),exceptionhandler_patch);
 118                 //set default exception handler into table
 119                 __exception_sethandler(i,default_exceptionhandler);
 120         }
 121         __exception_sethandler(EX_FP,fpu_exceptionhandler);
 122         __exception_sethandler(EX_INT,irq_exceptionhandler);
 123         __exception_sethandler(EX_DEC,dec_exceptionhandler);
 124
 125         mtmsr(mfmsr()|MSR_RI);
 126 }
 127
 128 void __exception_close(u32 except)
 129 {
 130         void *pAdd = (void*)(0x80000000|exception_location[except]);
 131         *(u32*)pAdd = 0x4C000064;
 132         DCFlushRangeNoSync(pAdd,0x100);
 133         ICInvalidateRange(pAdd,0x100);
 134         _sync();
 135 }
 136
 137 void __exception_closeall()
 138 {
 139         s32 i;
 140         for(i=0;i<NUM_EXCEPTIONS;i++) {
 141                 __exception_close(i);
 142         }
 143         mtmsr(mfmsr()&~MSR_EE);
 144         mtmsr(mfmsr()|(MSR_FP|MSR_RI));
 145 }
 146
 147 void __exception_sethandler(u32 nExcept, void (*pHndl)(frame_context*))
 148 {
 149         _exceptionhandlertable[nExcept] = pHndl;
 150 }
 151
 152 static void _cpu_print_stack(void *pc,void *lr,void *r1)
 153 {
 154         register u32 i = 0;
 155         register frame_rec_t l,p = (frame_rec_t)lr;
 156
 157         l = p;
 158         p = r1;
 159         if(!p) __asm__ __volatile__("mr %0,%%r1" : "=r"(p));
 160
 161         kprintf("\n\tSTACK DUMP:");
 162
 163         for(i=0;i<CPU_STACK_TRACE_DEPTH-1 && p->up;p=p->up,i++) {
 164                 if(i%4) kprintf(" --> ");
 165                 else {
 166                         if(i>0) kprintf(" -->\n\t");
 167                         else kprintf("\n\t");
 168                 }
 169
 170                 switch(i) {
 171                         case 0:
 172                                 if(pc) kprintf("%p",pc);
 173                                 break;
 174                         case 1:
 175                                 if(!l) l = (frame_rec_t)mfspr(8);
 176                                 kprintf("%p",(void*)l);
 177                                 break;
 178                         default:
 179                                 kprintf("%p",(void*)(p->up->lr));
 180                                 break;
 181                 }
 182         }
 183 }
 184
 185 void __exception_setreload(int t)
 186 {
 187         reload_timer = t*50;
 188 }
 189
 190 static void waitForReload()
 191 {
 192         u32 level;
 193
 194         PAD_Init();
 195
 196         if(reload_timer > 0)
 197                 kprintf("\n\tReloading in %d seconds\n", reload_timer/50);
 198
 199         while ( 1 )
 200         {
 201                 PAD_ScanPads();
 202
 203                 int buttonsDown = PAD_ButtonsDown(0);
 204
 205                 if( (buttonsDown & PAD_TRIGGER_Z) || SYS_ResetButtonDown() ||
 206                         reload_timer == 0 )
 207                 {
 208                         kprintf("\n\tReload\n\n\n");
 209                         _CPU_ISR_Disable(level);
 210                         __reload ();
 211                 }
 212
 213                 if ( buttonsDown & PAD_BUTTON_A )
 214                 {
 215                         kprintf("\n\tReset\n\n\n");
 216 #if defined(HW_DOL)
 217                         SYS_ResetSystem(SYS_HOTRESET,0,FALSE);
 218 #else
 219                         __reload ();
 220 #endif
 221                 }
 222
 223                 udelay(20000);
 224                 if(reload_timer > 0)
 225                         reload_timer--;
 226         }
 227 }
 228
 229 //just implement core for unrecoverable exceptions.
 230 void c_default_exceptionhandler(frame_context *pCtx)
 231 {
 232         GX_AbortFrame();
 233         VIDEO_SetFramebuffer(exception_xfb);
 234         __console_init(exception_xfb,20,20,640,574,1280);
 235         CON_EnableGecko(1, true);
 236
 237         kprintf("\n\n\n\tException (%s) occurred!\n", exception_name[pCtx->EXCPT_Number]);
 238
 239         kprintf("\tGPR00 %08X GPR08 %08X GPR16 %08X GPR24 %08X\n",pCtx->GPR[0], pCtx->GPR[8], pCtx->GPR[16], pCtx->GPR[24]);
 240         kprintf("\tGPR01 %08X GPR09 %08X GPR17 %08X GPR25 %08X\n",pCtx->GPR[1], pCtx->GPR[9], pCtx->GPR[17], pCtx->GPR[25]);
 241         kprintf("\tGPR02 %08X GPR10 %08X GPR18 %08X GPR26 %08X\n",pCtx->GPR[2], pCtx->GPR[10], pCtx->GPR[18], pCtx->GPR[26]);
 242         kprintf("\tGPR03 %08X GPR11 %08X GPR19 %08X GPR27 %08X\n",pCtx->GPR[3], pCtx->GPR[11], pCtx->GPR[19], pCtx->GPR[27]);
 243         kprintf("\tGPR04 %08X GPR12 %08X GPR20 %08X GPR28 %08X\n",pCtx->GPR[4], pCtx->GPR[12], pCtx->GPR[20], pCtx->GPR[28]);
 244         kprintf("\tGPR05 %08X GPR13 %08X GPR21 %08X GPR29 %08X\n",pCtx->GPR[5], pCtx->GPR[13], pCtx->GPR[21], pCtx->GPR[29]);
 245         kprintf("\tGPR06 %08X GPR14 %08X GPR22 %08X GPR30 %08X\n",pCtx->GPR[6], pCtx->GPR[14], pCtx->GPR[22], pCtx->GPR[30]);
 246         kprintf("\tGPR07 %08X GPR15 %08X GPR23 %08X GPR31 %08X\n",pCtx->GPR[7], pCtx->GPR[15], pCtx->GPR[23], pCtx->GPR[31]);
 247         kprintf("\tLR %08X SRR0 %08x SRR1 %08x MSR %08x\n", pCtx->LR, pCtx->SRR0, pCtx->SRR1,pCtx->MSR);
 248         kprintf("\tDAR %08X DSISR %08X\n", mfspr(19), mfspr(18));
 249
 250         _cpu_print_stack((void*)pCtx->SRR0,(void*)pCtx->LR,(void*)pCtx->GPR[1]);
 251
 252         if((pCtx->EXCPT_Number==EX_DSI) || (pCtx->EXCPT_Number==EX_FP)) {
 253                 u32 i;
 254                 u32 *pAdd = (u32*)pCtx->SRR0;
 255                 kprintf("\n\n\tCODE DUMP:\n");
 256                 for (i=0; i<12; i+=4)
 257                         kprintf("\t%p:  %08X %08X %08X %08X\n",
 258                         &(pAdd[i]),pAdd[i], pAdd[i+1], pAdd[i+2], pAdd[i+3]);
 259         }
 260
 261         waitForReload();
 262 }
 263