packages/hal/arm/arch/v2_0/src/hal_misc.c

   1 /*==========================================================================
   2 //
   3 //      hal_misc.c
   4 //
   5 //      HAL miscellaneous functions
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //==========================================================================
  41 //#####DESCRIPTIONBEGIN####
  42 //
  43 // Author(s):    nickg, gthomas
  44 // Contributors: nickg, gthomas
  45 // Date:         1999-02-20
  46 // Purpose:      HAL miscellaneous functions
  47 // Description:  This file contains miscellaneous functions provided by the
  48 //               HAL.
  49 //
  50 //####DESCRIPTIONEND####
  51 //
  52 //=========================================================================*/
  53
  54 #include <pkgconf/hal.h>
  55 #include <pkgconf/hal_arm.h>
  56 #ifdef CYGPKG_KERNEL
  57 #include <pkgconf/kernel.h>
  58 #endif
  59 #ifdef CYGPKG_CYGMON
  60 #include <pkgconf/cygmon.h>
  61 #endif
  62
  63 #include <cyg/infra/cyg_type.h>
  64 #include <cyg/infra/cyg_trac.h>         // tracing macros
  65 #include <cyg/infra/cyg_ass.h>          // assertion macros
  66
  67 #include <cyg/hal/hal_arch.h>           // HAL header
  68 #include <cyg/hal/hal_intr.h>           // HAL header
  69
  70 #include <cyg/infra/diag.h>
  71
  72 /*------------------------------------------------------------------------*/
  73 /* First level C exception handler.                                       */
  74
  75 externC void __handle_exception (void);
  76
  77 externC HAL_SavedRegisters *_hal_registers;
  78 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
  79 externC void* volatile __mem_fault_handler;
  80 #endif
  81
  82
  83 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
  84 /* Force exception handling into the GDB stubs.  This is done by taking over
  85    the exception vectors while executing in the stubs.  This allows for the
  86    debugged program to handle exceptions itself, except while the GDB
  87    processing is underway.  The only vector that can't be handled this way
  88    is the illegal instruction vector which is used for breakpoint/single-step
  89    and must be maintained by the stubs at all times.
  90    Note: the interrupt vectors are _not_ preempted as the stubs probably can't
  91    handle them properly.
  92 */
  93
  94 #define ARM_VECTORS 8
  95 extern unsigned long vectors[];  // exception vectors as defined by the stubs
  96
  97 #if !defined(CYGPKG_CYGMON)
  98 static unsigned long *hardware_vectors = (unsigned long *)0x20;
  99 static unsigned long hold_vectors[ARM_VECTORS];
 100 static int exception_level;
 101
 102 static void
 103 __take_over_debug_traps(void)
 104 {
 105     hold_vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH] = hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH];
 106     hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH] = vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH];
 107     hold_vectors[CYGNUM_HAL_VECTOR_ABORT_DATA] = hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_DATA];
 108     hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_DATA] = vectors[CYGNUM_HAL_VECTOR_ABORT_DATA];
 109 }
 110
 111 static void
 112 __restore_debug_traps(void)
 113 {
 114     hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH] = hold_vectors[CYGNUM_HAL_VECTOR_ABORT_PREFETCH];
 115     hardware_vectors[CYGNUM_HAL_VECTOR_ABORT_DATA] = hold_vectors[CYGNUM_HAL_VECTOR_ABORT_DATA];
 116 }
 117 #endif // !CYGPKG_CYGMON
 118 #endif
 119
 120 void
 121 exception_handler(HAL_SavedRegisters *regs)
 122 {
 123     // Special case handler for code which has chosen to take care
 124     // of data exceptions (i.e. code which expects them to happen)
 125     // This is common in discovery code, e.g. checking for a particular
 126     // device which may generate an exception when probing if the
 127     // device is not present
 128 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 129     if (__mem_fault_handler &&
 130         regs->vector == CYGNUM_HAL_EXCEPTION_DATA_ACCESS) {
 131         regs->pc = (unsigned long)__mem_fault_handler;
 132         return; // Caught an exception inside stubs
 133     }
 134 #endif
 135
 136 #if defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS) && !defined(CYGPKG_CYGMON)
 137     if (++exception_level == 1) __take_over_debug_traps();
 138
 139     _hal_registers = regs;
 140     __handle_exception();
 141
 142     if (--exception_level == 0) __restore_debug_traps();
 143
 144 #elif defined(CYGPKG_KERNEL_EXCEPTIONS)
 145
 146     // We should decode the vector and pass a more appropriate
 147     // value as the second argument. For now we simply pass a
 148     // pointer to the saved registers. We should also divert
 149     // breakpoint and other debug vectors into the debug stubs.
 150
 151     cyg_hal_deliver_exception( regs->vector, (CYG_ADDRWORD)regs );
 152
 153 #else
 154
 155     CYG_FAIL("Exception!!!");
 156
 157 #endif
 158
 159     return;
 160 }
 161
 162 void hal_spurious_IRQ(HAL_SavedRegisters *regs) CYGBLD_ATTRIB_WEAK;
 163 void
 164 hal_spurious_IRQ(HAL_SavedRegisters *regs)
 165 {
 166 #if defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)
 167     exception_handler(regs);
 168 #else
 169     CYG_FAIL("Spurious interrupt!!");
 170 #endif
 171 }
 172
 173 /*------------------------------------------------------------------------*/
 174 /* C++ support - run initial constructors                                 */
 175
 176 #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG
 177 cyg_bool cyg_hal_stop_constructors;
 178 #endif
 179
 180 typedef void (*pfunc) (void);
 181 extern pfunc __CTOR_LIST__[];
 182 extern pfunc __CTOR_END__[];
 183
 184 void
 185 cyg_hal_invoke_constructors (void)
 186 {
 187 #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG
 188     static pfunc *p = &__CTOR_END__[-1];
 189
 190     cyg_hal_stop_constructors = 0;
 191     for (; p >= __CTOR_LIST__; p--) {
 192         (*p) ();
 193         if (cyg_hal_stop_constructors) {
 194             p--;
 195             break;
 196         }
 197     }
 198 #else
 199     pfunc *p;
 200
 201     for (p = &__CTOR_END__[-1]; p >= __CTOR_LIST__; p--)
 202         (*p) ();
 203 #endif
 204 }
 205
 206 /*------------------------------------------------------------------------*/
 207 /* Architecture default ISR                                               */
 208
 209 externC cyg_uint32
 210 hal_arch_default_isr(CYG_ADDRWORD vector, CYG_ADDRWORD data)
 211 {
 212     CYG_TRACE1(true, "Interrupt: %d", vector);
 213
 214     CYG_FAIL("Spurious Interrupt!!!");
 215     return 0;
 216 }
 217
 218 /*-------------------------------------------------------------------------*/
 219 /* Misc functions                                                          */
 220
 221 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 222 /* This function will generate a breakpoint exception.  It is used at the
 223    beginning of a program to sync up with a debugger and can be used
 224    otherwise as a quick means to stop program execution and "break" into
 225    the debugger. */
 226
 227 void
 228 breakpoint(void)
 229 {
 230     HAL_BREAKPOINT(_breakinst);
 231 }
 232
 233
 234 /* This function returns the opcode for a 'trap' instruction.  */
 235
 236 unsigned long
 237 __break_opcode (void)
 238 {
 239     return HAL_BREAKINST;
 240 }
 241 #endif
 242
 243 int
 244 hal_lsbindex(int mask)
 245 {
 246     int i;
 247     for (i = 0;  i < 32;  i++) {
 248       if (mask & (1<<i)) return (i);
 249     }
 250     return (-1);
 251 }
 252
 253 int
 254 hal_msbindex(int mask)
 255 {
 256     int i;
 257     for (i = 31;  i >= 0;  i--) {
 258       if (mask & (1<<i)) return (i);
 259     }
 260     return (-1);
 261 }
 262
 263 #ifdef  CYGHWR_HAL_ARM_DUMP_EXCEPTIONS
 264 void
 265 dump_frame(unsigned char *frame)
 266 {
 267     HAL_SavedRegisters *rp = (HAL_SavedRegisters *)frame;
 268     int i;
 269     diag_dump_buf(frame, 128);
 270     diag_printf("Registers:\n");
 271     for (i = 0;  i <= 10;  i++) {
 272         if ((i == 0) || (i == 6)) diag_printf("R%d: ", i);
 273         diag_printf("%08X ", rp->d[i]);
 274         if ((i == 5) || (i == 10)) diag_printf("\n");
 275     }
 276     diag_printf("FP: %08X, SP: %08X, LR: %08X, PC: %08X, PSR: %08X\n",
 277                 rp->fp, rp->sp, rp->lr, rp->pc, rp->cpsr);
 278 }
 279 #endif
 280
 281 #if 0
 282 void
 283 show_frame_in(HAL_SavedRegisters *frame)
 284 {
 285     int old;
 286     HAL_DISABLE_INTERRUPTS(old);
 287     diag_printf("[IN] IRQ Frame:\n");
 288     dump_frame((unsigned char *)frame);
 289     HAL_RESTORE_INTERRUPTS(old);
 290 }
 291
 292 void
 293 show_frame_out(HAL_SavedRegisters *frame)
 294 {
 295     int old;
 296     HAL_DISABLE_INTERRUPTS(old);
 297     diag_printf("[OUT] IRQ Frame:\n");
 298     dump_frame((unsigned char *)frame);
 299     HAL_RESTORE_INTERRUPTS(old);
 300 }
 301 #endif
 302
 303 #ifdef  CYGHWR_HAL_ARM_DUMP_EXCEPTIONS
 304 // Debug routines
 305 void cyg_hal_report_undefined_instruction(HAL_SavedRegisters *frame)
 306 {
 307     int old;
 308     HAL_DISABLE_INTERRUPTS(old);
 309     diag_printf("[UNDEFINED INSTRUCTION] Frame:\n");
 310     dump_frame((unsigned char *)frame);
 311     HAL_RESTORE_INTERRUPTS(old);
 312 }
 313
 314 void cyg_hal_report_software_interrupt(HAL_SavedRegisters *frame)
 315 {
 316     int old;
 317     HAL_DISABLE_INTERRUPTS(old);
 318     diag_printf("[SOFTWARE INTERRUPT] Frame:\n");
 319     dump_frame((unsigned char *)frame);
 320     HAL_RESTORE_INTERRUPTS(old);
 321 }
 322
 323 void cyg_hal_report_abort_prefetch(HAL_SavedRegisters *frame)
 324 {
 325     int old;
 326     HAL_DISABLE_INTERRUPTS(old);
 327     diag_printf("[ABORT PREFETCH] Frame:\n");
 328     dump_frame((unsigned char *)frame);
 329     HAL_RESTORE_INTERRUPTS(old);
 330 }
 331
 332 void cyg_hal_report_abort_data(HAL_SavedRegisters *frame)
 333 {
 334     int old;
 335     HAL_DISABLE_INTERRUPTS(old);
 336     diag_printf("[ABORT DATA] Frame:\n");
 337     dump_frame((unsigned char *)frame);
 338     HAL_RESTORE_INTERRUPTS(old);
 339 }
 340
 341 void cyg_hal_report_exception_handler_returned(HAL_SavedRegisters *frame)
 342 {
 343     int old;
 344     HAL_DISABLE_INTERRUPTS(old);
 345     diag_printf("Exception handler returned!\n");
 346     dump_frame((unsigned char *)frame);
 347     HAL_RESTORE_INTERRUPTS(old);
 348 }
 349 #endif
 350
 351 /*------------------------------------------------------------------------*/
 352 // EOF hal_misc.c