packages/hal/common/v2_0/src/hal_stub.c

   1 //=============================================================================
   2 //
   3 //      hal_stub.c
   4 //
   5 //      Helper functions for stub, specific to eCos HAL
   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, 2003 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):   jskov (based on powerpc/cogent hal_stub.c)
  44 // Contributors:jskov, dmoseley
  45 // Date:        1999-02-12
  46 // Purpose:     Helper functions for stub, specific to eCos HAL
  47 // Description: Parts of the GDB stub requirements are provided by
  48 //              the eCos HAL, rather than target and/or board specific
  49 //              code.
  50 //
  51 //####DESCRIPTIONEND####
  52 //
  53 //=============================================================================
  54
  55 #include <pkgconf/hal.h>
  56 #ifdef CYGPKG_CYGMON
  57 #include <pkgconf/cygmon.h>
  58 #endif
  59
  60 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
  61
  62 #include <cyg/hal/hal_stub.h>           // Our header
  63
  64 #include <cyg/hal/hal_arch.h>           // HAL_BREAKINST
  65 #include <cyg/hal/hal_cache.h>          // HAL_xCACHE_x
  66 #include <cyg/hal/hal_intr.h>           // interrupt disable/restore
  67
  68 #include <cyg/hal/hal_if.h>             // ROM calling interface
  69 #include <cyg/hal/hal_misc.h>           // Helper functions
  70
  71 #ifdef CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
  72 #include <cyg/hal/dbg-threads-api.h>    // dbg_currthread_id
  73 #endif
  74
  75 #ifdef USE_LONG_NAMES_FOR_ENUM_REGNAMES
  76 #ifndef PC
  77 #define PC REG_PC
  78 #endif
  79 #ifndef SP
  80 #define SP REG_SP
  81 #endif
  82 #endif
  83
  84 //-----------------------------------------------------------------------------
  85 // Extra eCos data.
  86
  87 // Some architectures use registers of different sizes, so NUMREGS
  88 // alone is not suffucient to size the register save area. For those
  89 // architectures, HAL_STUB_REGISTERS_SIZE is defined as the number
  90 // of target_register_t sized elements in the register save area.
  91 #ifndef HAL_STUB_REGISTERS_SIZE
  92 #define HAL_STUB_REGISTERS_SIZE NUMREGS
  93 #endif
  94
  95 // Saved registers.
  96 HAL_SavedRegisters *_hal_registers;
  97 target_register_t registers[HAL_STUB_REGISTERS_SIZE];
  98 target_register_t alt_registers[HAL_STUB_REGISTERS_SIZE] ;  // Thread or saved process state
  99 target_register_t *_registers = registers;                 // Pointer to current set of registers
 100 #ifndef CYGPKG_REDBOOT
 101 target_register_t orig_registers[HAL_STUB_REGISTERS_SIZE];  // Registers to get back to original state
 102 #endif
 103
 104 #if defined(HAL_STUB_HW_WATCHPOINT) || defined(HAL_STUB_HW_BREAKPOINT)
 105 static int  _hw_stop_reason;   // Reason we were stopped by hw.
 106
 107 //#define HAL_STUB_HW_SEND_STOP_REASON_TEXT
 108 #ifdef CYGINT_HAL_ARM_ARCH_XSCALE
 109 #define HAL_STUB_HW_SEND_STOP_REASON_TEXT
 110 #endif
 111
 112 #ifdef HAL_STUB_HW_SEND_STOP_REASON_TEXT
 113 // strings indexed by hw stop reasons defined in hal_stub.h
 114
 115 // Not all GDBs understand this.
 116 static const char * const _hw_stop_str[] = {
 117         "",
 118         "hbreak",
 119         "watch",
 120         "rwatch",
 121         "awatch"
 122 };
 123 #endif // HAL_STUB_HW_SEND_STOP_REASON_TEXT
 124
 125 static void *_watch_data_addr; // The data address if stopped by watchpoint
 126 #endif // defined(HAL_STUB_HW_WATCHPOINT) || defined(HAL_STUB_HW_BREAKPOINT)
 127
 128 // Register validity checking
 129 #ifdef CYGHWR_REGISTER_VALIDITY_CHECKING
 130 int registers_valid[NUMREGS];
 131 int *_registers_valid = registers_valid;
 132 #endif
 133
 134 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 135 // Interrupt control.
 136 static volatile __PFI __interruptible_control;
 137 #endif
 138
 139 // Some architectures need extras regs reported in T packet
 140 #ifndef HAL_STUB_ARCH_T_PACKET_EXTRAS
 141 #define HAL_STUB_ARCH_T_PACKET_EXTRAS(x)
 142 #endif
 143
 144 //-----------------------------------------------------------------------------
 145 // Register access
 146
 147 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 148 // Return the currently-saved value corresponding to register REG of
 149 // the exception context.
 150 target_register_t
 151 get_register (regnames_t reg)
 152 {
 153         return _registers[reg];
 154 }
 155 #endif
 156
 157 #ifdef CYGHWR_REGISTER_VALIDITY_CHECKING
 158 // Return the validity of register REG.
 159 int
 160 get_register_valid (regnames_t reg)
 161 {
 162         return _registers_valid[reg];
 163 }
 164 #endif
 165
 166 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 167 // Store VALUE in the register corresponding to WHICH in the exception
 168 // context.
 169 void
 170 put_register (regnames_t which, target_register_t value)
 171 {
 172 #ifdef CYGPKG_HAL_MIPS_VR4300
 173         // This is a rather nasty kludge to compensate for the fact that
 174         // the VR4300 GDB is rather old and does not support proper 64 bit
 175         // registers. The only time this really matters is when setting
 176         // the PC after loading an executable. So here we detect this case
 177         // and artificially sign extend it.
 178
 179         if( which == PC && (value & 0x0000000080000000ULL ) )
 180         {
 181                 value |= 0xFFFFFFFF00000000ULL;
 182         }
 183 #endif
 184         _registers[which] = value;
 185 }
 186 #endif // CYGARC_STUB_REGISTER_ACCESS_DEFINED
 187
 188 //-----------------------------------------------------------------------------
 189 // Serial stuff
 190 #ifdef CYGPKG_CYGMON
 191 extern void ecos_bsp_console_putc(char);
 192 extern char ecos_bsp_console_getc(void);
 193 #endif
 194
 195 // Write C to the current serial port.
 196 void
 197 putDebugChar (int c)
 198 {
 199 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 200         __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
 201         CYGACC_COMM_IF_PUTC(*__debug_procs, c);
 202 #elif defined(CYGPKG_CYGMON)
 203         ecos_bsp_console_putc(c);
 204 #else
 205         HAL_STUB_PLATFORM_PUT_CHAR(c);
 206 #endif
 207 }
 208
 209 // Read one character from the current serial port.
 210 int
 211 getDebugChar (void)
 212 {
 213 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 214         __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
 215         return CYGACC_COMM_IF_GETC(*__debug_procs);
 216 #elif defined(CYGPKG_CYGMON)
 217         return ecos_bsp_console_getc();
 218 #else
 219         return HAL_STUB_PLATFORM_GET_CHAR();
 220 #endif
 221 }
 222
 223 // Flush output channel
 224 void
 225 hal_flush_output(void)
 226 {
 227 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 228         __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
 229         CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_FLUSH_OUTPUT);
 230 #endif
 231 }
 232
 233
 234 // Set the baud rate for the current serial port.
 235 void
 236 __set_baud_rate (int baud)
 237 {
 238 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 239         __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
 240         CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_SETBAUD, baud);
 241 #elif defined(CYGPKG_CYGMON)
 242         // FIXME!
 243 #else
 244         HAL_STUB_PLATFORM_SET_BAUD_RATE(baud);
 245 #endif
 246 }
 247
 248 //-----------------------------------------------------------------------------
 249 // GDB interrupt (BREAK) support.
 250
 251 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 252
 253 #ifndef CYGPKG_HAL_ARM
 254
 255 #if (HAL_BREAKINST_SIZE == 1)
 256 typedef cyg_uint8 t_inst;
 257 #elif (HAL_BREAKINST_SIZE == 2)
 258 typedef cyg_uint16 t_inst;
 259 #elif (HAL_BREAKINST_SIZE == 4)
 260 typedef cyg_uint32 t_inst;
 261 #else
 262 #error "Don't know how to handle that size"
 263 #endif
 264
 265 typedef struct
 266 {
 267         t_inst *targetAddr;
 268         t_inst savedInstr;
 269 } instrBuffer;
 270
 271 static instrBuffer break_buffer;
 272
 273 volatile int cyg_hal_gdb_running_step = 0;
 274
 275 void
 276 cyg_hal_gdb_place_break (target_register_t pc)
 277 {
 278         cyg_hal_gdb_interrupt( pc ); // Let's hope this becomes a drop-through:
 279 }
 280
 281 void
 282 cyg_hal_gdb_interrupt (target_register_t pc)
 283 {
 284         t_inst break_inst = HAL_BREAKINST;
 285
 286         CYGARC_HAL_SAVE_GP();
 287
 288         // Clear flag that we Continued instead of Stepping
 289         cyg_hal_gdb_running_step = 0;
 290         // and override existing break? So that a ^C takes effect...
 291         if (NULL != break_buffer.targetAddr)
 292                 cyg_hal_gdb_remove_break( (target_register_t)break_buffer.targetAddr );
 293
 294         if (NULL == break_buffer.targetAddr) {
 295                 // Not always safe to read/write directly to program
 296                 // memory due to possibly unaligned instruction, use the
 297                 // provided memory functions instead.
 298                 __read_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
 299                 __write_mem_safe(&break_inst, (t_inst*)pc, HAL_BREAKINST_SIZE);
 300
 301                 // Save the PC where we put the break, so we can remove
 302                 // it after the target takes the break.
 303                 break_buffer.targetAddr = (t_inst*)pc;
 304
 305                 __data_cache(CACHE_FLUSH);
 306                 __instruction_cache(CACHE_FLUSH);
 307         }
 308
 309         CYGARC_HAL_RESTORE_GP();
 310 }
 311
 312 int
 313 cyg_hal_gdb_remove_break (target_register_t pc)
 314 {
 315         if ( cyg_hal_gdb_running_step )
 316                 return 0;
 317
 318         if ((t_inst*)pc == break_buffer.targetAddr) {
 319
 320                 __write_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
 321                 break_buffer.targetAddr = NULL;
 322
 323                 __data_cache(CACHE_FLUSH);
 324                 __instruction_cache(CACHE_FLUSH);
 325                 return 1;
 326         }
 327         return 0;
 328 }
 329
 330 int
 331 cyg_hal_gdb_break_is_set (void)
 332 {
 333         if (NULL != break_buffer.targetAddr) {
 334                 return 1;
 335         }
 336         return 0;
 337 }
 338
 339 #endif // CYGPKG_HAL_ARM
 340
 341 #endif // CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 342
 343 // Use this function to disable serial interrupts whenever reply
 344 // characters are expected from GDB.  The reason we want to control
 345 // whether the target can be interrupted or not is simply that GDB on
 346 // the host will be sending acknowledge characters/commands while the
 347 // stub is running - if serial interrupts were still active, the
 348 // characters would never reach the (polling) getDebugChar.
 349 static void
 350 interruptible(int state)
 351 {
 352         static int __interrupts_suspended = 0;
 353
 354         if (state) {
 355                 __interrupts_suspended--;
 356                 if (0 >= __interrupts_suspended) {
 357                         __interrupts_suspended = 0;
 358 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
 359                         {
 360                                 hal_virtual_comm_table_t* __chan;
 361                                 __chan = CYGACC_CALL_IF_DEBUG_PROCS();
 362                                 CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE);
 363                         }
 364 #else
 365                         if (__interruptible_control)
 366                                 __interruptible_control(1);
 367 #endif
 368                 }
 369         } else {
 370                 __interrupts_suspended++;
 371                 if (1 == __interrupts_suspended)
 372 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
 373                 {
 374                         hal_virtual_comm_table_t* __chan;
 375                         __chan = CYGACC_CALL_IF_DEBUG_PROCS();
 376                         CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE);
 377                 }
 378 #else
 379                 if (__interruptible_control)
 380                         __interruptible_control(0);
 381 #endif
 382         }
 383 }
 384
 385 //-----------------------------------------------------------------------------
 386 // eCos stub entry and exit magic.
 387
 388 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 389 int cyg_hal_gdb_break;
 390 #endif
 391
 392 #ifdef CYGPKG_REDBOOT
 393 // Trampoline for returning to RedBoot from exception/stub code
 394 static void
 395 return_from_stub(int exit_status)
 396 {
 397         CYGACC_CALL_IF_MONITOR_RETURN(exit_status);
 398 }
 399 #endif
 400
 401 // Called at stub *kill*
 402 static void
 403 handle_exception_exit( void )
 404 {
 405 #ifdef CYGPKG_REDBOOT
 406 #ifdef CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
 407         {   // Reset the timer to default and cancel any callback
 408                 extern void sys_profile_reset(void);
 409                 sys_profile_reset();
 410         }
 411 #endif // CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
 412         set_pc((target_register_t)return_from_stub);
 413 #else
 414         int i;
 415
 416         for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
 417                 registers[i] = orig_registers[i];
 418 #endif
 419 }
 420
 421 // Called at stub *entry*
 422 static void
 423 handle_exception_cleanup( void )
 424 {
 425 #ifndef CYGPKG_REDBOOT
 426         static int orig_registers_set = 0;
 427 #endif
 428
 429         interruptible(0);
 430
 431         // Expand the HAL_SavedRegisters structure into the GDB register
 432         // array format.
 433         HAL_GET_GDB_REGISTERS(&registers[0], _hal_registers);
 434         _registers = &registers[0];
 435
 436 #ifndef CYGPKG_REDBOOT
 437         if (!orig_registers_set) {
 438                 int i;
 439                 for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
 440                         orig_registers[i] = registers[i];
 441                 _registers = &orig_registers[0];
 442                 if (__is_breakpoint_function ())
 443                         __skipinst ();
 444                 _registers = &registers[0];
 445                 orig_registers_set = 1;
 446         }
 447 #endif
 448
 449 #ifdef HAL_STUB_PLATFORM_STUBS_FIXUP
 450         // Some architectures may need to fix the PC in case of a partial
 451         // or fully executed trap instruction. GDB only takes correct action
 452         // when the PC is pointing to the breakpoint instruction it set.
 453         //
 454         // Most architectures would leave PC pointing at the trap
 455         // instruction itself though, and so do not need to do anything
 456         // special.
 457         HAL_STUB_PLATFORM_STUBS_FIXUP();
 458 #endif
 459
 460 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 461         // If we continued instead of stepping, when there was a break set
 462         // ie. we were stepping within a critical region, clear the break, and
 463         // that flag.  If we stopped for some other reason, this has no effect.
 464         if ( cyg_hal_gdb_running_step ) {
 465                 cyg_hal_gdb_running_step = 0;
 466                 cyg_hal_gdb_remove_break(get_register (PC));
 467         }
 468
 469         // FIXME: (there may be a better way to do this)
 470         // If we hit a breakpoint set by the gdb interrupt stub, make it
 471         // seem like an interrupt rather than having hit a breakpoint.
 472         cyg_hal_gdb_break = cyg_hal_gdb_remove_break(get_register (PC));
 473 #endif
 474
 475 #if defined(HAL_STUB_HW_WATCHPOINT) || defined(HAL_STUB_HW_BREAKPOINT)
 476         // For HW watchpoint/breakpoint support, we need to know if we
 477         // stopped because of watchpoint or hw break. We do that here
 478         // before GDB has a chance to remove the watchpoints and save
 479         // the information for later use in building response packets.
 480         _hw_stop_reason = HAL_STUB_IS_STOPPED_BY_HARDWARE(_watch_data_addr);
 481 #endif
 482 }
 483
 484 // Called at stub *exit*
 485 static void
 486 handle_exception_init( void )
 487 {
 488         // Compact register array again.
 489         HAL_SET_GDB_REGISTERS(_hal_registers, &registers[0]);
 490
 491         interruptible(1);
 492 }
 493
 494
 495 //-----------------------------------------------------------------------------
 496 // Initialization.
 497
 498 // Signal handler.
 499 int
 500 cyg_hal_process_signal (int signal)
 501 {
 502         // We don't care about the signal (atm).
 503         return 0;
 504 }
 505
 506 // Install the standard set of trap handlers for the stub.
 507 void
 508 __install_traps (void)
 509 {
 510         // Set signal handling vector so we can treat 'C<signum>' as 'c'.
 511         __process_signal_vec = &cyg_hal_process_signal;
 512         __process_exit_vec = &handle_exception_exit;
 513
 514         __cleanup_vec = &handle_exception_cleanup;
 515         __init_vec    = &handle_exception_init;
 516
 517 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 518 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 519         // Control of GDB interrupts.
 520         __interruptible_control = HAL_STUB_PLATFORM_INTERRUPTIBLE;
 521 #endif
 522 #endif
 523
 524         // Nothing further to do, handle_exception will be called when an
 525         // exception occurs.
 526 }
 527
 528 // Initialize the hardware.
 529 void
 530 initHardware (void)
 531 {
 532         static int initialized = 0;
 533
 534         if (initialized)
 535                 return;
 536         initialized = 1;
 537
 538         // Get serial port initialized.
 539         HAL_STUB_PLATFORM_INIT_SERIAL();
 540
 541 #ifdef HAL_STUB_PLATFORM_INIT
 542         // If the platform defines any initialization code, call it here.
 543         HAL_STUB_PLATFORM_INIT();
 544 #endif
 545
 546 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 547 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 548         // Get interrupt handler initialized.
 549         HAL_STUB_PLATFORM_INIT_BREAK_IRQ();
 550 #endif
 551 #endif // !CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 552 }
 553
 554 // Reset the board.
 555 void
 556 __reset (void)
 557 {
 558 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 559         __call_if_reset_t *__rom_reset = CYGACC_CALL_IF_RESET_GET();
 560         if (__rom_reset)
 561                 (*__rom_reset)();
 562 #else
 563         HAL_PLATFORM_RESET();
 564 #endif
 565 }
 566
 567 //-----------------------------------------------------------------------------
 568 // Breakpoint support.
 569
 570 #ifndef CYGPKG_HAL_ARM
 571 // This function will generate a breakpoint exception.  It is used at
 572 // the beginning of a program to sync up with a debugger and can be
 573 // used otherwise as a quick means to stop program execution and
 574 // "break" into the debugger.
 575 void
 576 breakpoint()
 577 {
 578         HAL_BREAKPOINT(_breakinst);
 579 }
 580
 581 // This function returns the opcode for a 'trap' instruction.
 582 unsigned long
 583 __break_opcode ()
 584 {
 585         return HAL_BREAKINST;
 586 }
 587 #endif
 588
 589 //-----------------------------------------------------------------------------
 590 // Write the 'T' packet in BUFFER. SIGVAL is the signal the program received.
 591 void
 592 __build_t_packet (int sigval, char *buf)
 593 {
 594         target_register_t addr;
 595         char *ptr = buf;
 596         target_register_t extend_val = 0;
 597
 598         *ptr++ = 'T';
 599         *ptr++ = __tohex (sigval >> 4);
 600         *ptr++ = __tohex (sigval);
 601
 602 #ifdef CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
 603         // Include thread ID if thread manipulation is required.
 604         {
 605                 int id = dbg_currthread_id ();
 606
 607                 if (id != 0) {
 608                         *ptr++ = 't';
 609                         *ptr++ = 'h';
 610                         *ptr++ = 'r';
 611                         *ptr++ = 'e';
 612                         *ptr++ = 'a';
 613                         *ptr++ = 'd';
 614                         *ptr++ = ':';
 615
 616 #if (CYG_BYTEORDER == CYG_LSBFIRST)
 617                         // FIXME: Temporary workaround for PR 18903. Thread ID must be
 618                         // big-endian in the T packet.
 619                         {
 620                                 unsigned char* bep = (unsigned char*)&id;
 621                                 int be_id;
 622
 623                                 be_id = id;
 624                                 *bep++ = (be_id >> 24) & 0xff ;
 625                                 *bep++ = (be_id >> 16) & 0xff ;
 626                                 *bep++ = (be_id >> 8) & 0xff ;
 627                                 *bep++ = (be_id & 0xff) ;
 628                         }
 629 #endif
 630                         ptr = __mem2hex((char *)&id, ptr, sizeof(id), 0);
 631                         *ptr++ = ';';
 632                 }
 633         }
 634 #endif
 635
 636 #ifdef HAL_STUB_HW_WATCHPOINT
 637         switch(_hw_stop_reason) {
 638         case HAL_STUB_HW_STOP_WATCH:
 639         case HAL_STUB_HW_STOP_RWATCH:
 640         case HAL_STUB_HW_STOP_AWATCH:
 641 #ifdef HAL_STUB_HW_SEND_STOP_REASON_TEXT
 642                 // Not all GDBs understand this.
 643                 strcpy(ptr, _hw_stop_str[_hw_stop_reason]);
 644                 ptr += strlen(_hw_stop_str[_hw_stop_reason]);
 645 #endif
 646                 *ptr++ = ':';
 647                 // Send address MSB first
 648                 ptr += __intToHex(ptr, (target_register_t)_watch_data_addr,
 649                                                 sizeof(_watch_data_addr) * 8);
 650                 *ptr++ = ';';
 651                 break;
 652         default:
 653                 break;
 654         }
 655 #endif
 656
 657         *ptr++ = __tohex (PC >> 4);
 658         *ptr++ = __tohex (PC);
 659         *ptr++ = ':';
 660         addr = get_register (PC);
 661         if (sizeof(addr) < REGSIZE(PC))
 662         {
 663                 // GDB is expecting REGSIZE(PC) number of bytes.
 664                 // We only have sizeof(addr) number.  Let's fill
 665                 // the appropriate number of bytes intelligently.
 666 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
 667                 {
 668                         unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
 669                         target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
 670                         if ((addr & sign_bit_mask) == sign_bit_mask)
 671                                 extend_val = ~0;
 672                 }
 673 #endif
 674         }
 675 #if (CYG_BYTEORDER == CYG_MSBFIRST)
 676         ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
 677 #endif
 678         ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
 679 #if (CYG_BYTEORDER == CYG_LSBFIRST)
 680         ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
 681 #endif
 682         *ptr++ = ';';
 683
 684         *ptr++ = __tohex (SP >> 4);
 685         *ptr++ = __tohex (SP);
 686         *ptr++ = ':';
 687         addr = (target_register_t) get_register (SP);
 688         if (sizeof(addr) < REGSIZE(SP))
 689         {
 690                 // GDB is expecting REGSIZE(SP) number of bytes.
 691                 // We only have sizeof(addr) number.  Let's fill
 692                 // the appropriate number of bytes intelligently.
 693                 extend_val = 0;
 694 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
 695                 {
 696                         unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
 697                         target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
 698                         if ((addr & sign_bit_mask) == sign_bit_mask)
 699                                 extend_val = ~0;
 700                 }
 701 #endif
 702                 ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(SP) - sizeof(addr), 0);
 703         }
 704         ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
 705         *ptr++ = ';';
 706
 707         HAL_STUB_ARCH_T_PACKET_EXTRAS(ptr);
 708
 709         *ptr++ = 0;
 710 }
 711
 712
 713 //-----------------------------------------------------------------------------
 714 // Cache functions.
 715
 716 // Perform the specified operation on the instruction cache.
 717 // Returns 1 if the cache is enabled, 0 otherwise.
 718 int
 719 __instruction_cache (cache_control_t request)
 720 {
 721         int state = 1;
 722
 723         switch (request) {
 724         case CACHE_ENABLE:
 725                 HAL_ICACHE_ENABLE();
 726                 break;
 727         case CACHE_DISABLE:
 728                 HAL_ICACHE_DISABLE();
 729                 state = 0;
 730                 break;
 731         case CACHE_FLUSH:
 732                 HAL_ICACHE_SYNC();
 733                 break;
 734         case CACHE_NOOP:
 735                 /* fall through */
 736         default:
 737                 break;
 738         }
 739
 740 #ifdef HAL_ICACHE_IS_ENABLED
 741         HAL_ICACHE_IS_ENABLED(state);
 742 #endif
 743
 744         return state;
 745 }
 746
 747 // Perform the specified operation on the data cache.
 748 // Returns 1 if the cache is enabled, 0 otherwise.
 749 int
 750 __data_cache (cache_control_t request)
 751 {
 752         int state = 1;
 753
 754         switch (request) {
 755         case CACHE_ENABLE:
 756                 HAL_DCACHE_ENABLE();
 757                 break;
 758         case CACHE_DISABLE:
 759                 HAL_DCACHE_DISABLE();
 760                 state = 0;
 761                 break;
 762         case CACHE_FLUSH:
 763                 HAL_DCACHE_SYNC();
 764                 break;
 765         case CACHE_NOOP:
 766                 /* fall through */
 767         default:
 768                 break;
 769         }
 770 #ifdef HAL_DCACHE_IS_ENABLED
 771         HAL_DCACHE_IS_ENABLED(state);
 772 #endif
 773
 774         return state;
 775 }
 776
 777 //-----------------------------------------------------------------------------
 778 // Memory accessor functions.
 779
 780 // The __mem_fault_handler pointer is volatile since it is only
 781 // set/cleared by the function below - which does not rely on any
 782 // other functions, so the compiler may decide to not bother updating
 783 // the pointer at all. If any of the memory accesses cause an
 784 // exception, the pointer must be set to ensure the exception handler
 785 // can make use of it.
 786
 787 void* volatile __mem_fault_handler = (void *)0;
 788
 789 /* These are the "arguments" to __do_read_mem and __do_write_mem,
 790    which are passed as globals to avoid squeezing them thru
 791    __set_mem_fault_trap.  */
 792
 793 static volatile target_register_t memCount;
 794
 795 static void
 796 __do_copy_mem (unsigned char* src, unsigned char* dst)
 797 {
 798         unsigned long *long_dst;
 799         unsigned long *long_src;
 800         unsigned short *short_dst;
 801         unsigned short *short_src;
 802
 803         // Zero memCount is not really an error, but the goto is necessary to
 804         // keep some compilers from reordering stuff across the 'err' label.
 805         if (memCount == 0) goto err;
 806
 807         __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
 808                                                                                   /* when the copy loop completes.  */
 809         __mem_fault_handler = &&err;
 810
 811         // See if it's safe to do multi-byte, aligned operations
 812         while (memCount) {
 813                 if ((memCount >= sizeof(long)) &&
 814                         (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
 815                         (((target_register_t)src & (sizeof(long)-1)) == 0)) {
 816
 817                         long_dst = (unsigned long *)dst;
 818                         long_src = (unsigned long *)src;
 819
 820                         *long_dst++ = *long_src++;
 821                         memCount -= sizeof(long);
 822
 823                         dst = (unsigned char *)long_dst;
 824                         src = (unsigned char *)long_src;
 825                 } else if ((memCount >= sizeof(short)) &&
 826                                 (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
 827                                 (((target_register_t)src & (sizeof(short)-1)) == 0)) {
 828
 829                         short_dst = (unsigned short *)dst;
 830                         short_src = (unsigned short *)src;
 831
 832                         *short_dst++ = *short_src++;
 833                         memCount -= sizeof(short);
 834
 835                         dst = (unsigned char *)short_dst;
 836                         src = (unsigned char *)short_src;
 837                 } else {
 838                         *dst++ = *src++;
 839                         memCount--;
 840                 }
 841         }
 842
 843         __mem_fault = 0;
 844
 845 err:
 846         __mem_fault_handler = (void *)0;
 847 }
 848
 849 /*
 850  * __read_mem_safe:
 851  * Get contents of target memory, abort on error.
 852  */
 853
 854 int
 855 __read_mem_safe (void *dst, void *src, int count)
 856 {
 857         if( !CYG_HAL_STUB_PERMIT_DATA_READ( src, count ) )
 858                 return 0;
 859
 860         memCount = count;
 861         __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
 862         return count - memCount;      // return number of bytes successfully read
 863 }
 864
 865 /*
 866  * __write_mem_safe:
 867  * Set contents of target memory, abort on error.
 868  */
 869
 870 int
 871 __write_mem_safe (void *src, void *dst, int count)
 872 {
 873         if( !CYG_HAL_STUB_PERMIT_DATA_READ( dst, count ) )
 874                 return 0;
 875
 876         memCount = count;
 877         __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
 878         return count - memCount;      // return number of bytes successfully written
 879 }
 880
 881 #ifdef TARGET_HAS_HARVARD_MEMORY
 882 static void
 883 __do_copy_from_progmem (unsigned char* src, unsigned char* dst)
 884 {
 885         unsigned long *long_dst;
 886         unsigned long *long_src;
 887         unsigned short *short_dst;
 888         unsigned short *short_src;
 889
 890         // Zero memCount is not really an error, but the goto is necessary to
 891         // keep some compilers from reordering stuff across the 'err' label.
 892         if (memCount == 0) goto err;
 893
 894         __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
 895                                                                                   /* when the copy loop completes.  */
 896         __mem_fault_handler = &&err;
 897
 898         // See if it's safe to do multi-byte, aligned operations
 899         while (memCount) {
 900                 if ((memCount >= sizeof(long)) &&
 901                         (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
 902                         (((target_register_t)src & (sizeof(long)-1)) == 0)) {
 903
 904                         long_dst = (unsigned long *)dst;
 905                         long_src = (unsigned long *)src;
 906
 907                         *long_dst++ = __read_prog_uint32(long_src++);
 908                         memCount -= sizeof(long);
 909
 910                         dst = (unsigned char *)long_dst;
 911                         src = (unsigned char *)long_src;
 912                 } else if ((memCount >= sizeof(short)) &&
 913                                 (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
 914                                 (((target_register_t)src & (sizeof(short)-1)) == 0)) {
 915
 916                         short_dst = (unsigned short *)dst;
 917                         short_src = (unsigned short *)src;
 918
 919                         *short_dst++ = __read_prog_uint16(short_src++);
 920                         memCount -= sizeof(short);
 921
 922                         dst = (unsigned char *)short_dst;
 923                         src = (unsigned char *)short_src;
 924                 } else {
 925                         *dst++ = __read_prog_uint8(src++);
 926                         memCount--;
 927                 }
 928         }
 929
 930         __mem_fault = 0;
 931
 932 err:
 933         __mem_fault_handler = (void *)0;
 934 }
 935
 936 static void
 937 __do_copy_to_progmem (unsigned char* src, unsigned char* dst)
 938 {
 939         unsigned long *long_dst;
 940         unsigned long *long_src;
 941         unsigned short *short_dst;
 942         unsigned short *short_src;
 943
 944         // Zero memCount is not really an error, but the goto is necessary to
 945         // keep some compilers from reordering stuff across the 'err' label.
 946         if (memCount == 0)      goto err;
 947
 948         __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
 949                                                                                   /* when the copy loop completes.  */
 950         __mem_fault_handler = &&err;
 951
 952         // See if it's safe to do multi-byte, aligned operations
 953         while (memCount) {
 954                 if ((memCount >= sizeof(long)) &&
 955                         (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
 956                         (((target_register_t)src & (sizeof(long)-1)) == 0)) {
 957
 958                         long_dst = (unsigned long *)dst;
 959                         long_src = (unsigned long *)src;
 960
 961                         __write_prog_uint32(long_dst++, *long_src++);
 962                         memCount -= sizeof(long);
 963
 964                         dst = (unsigned char *)long_dst;
 965                         src = (unsigned char *)long_src;
 966                 } else if ((memCount >= sizeof(short)) &&
 967                                 (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
 968                                 (((target_register_t)src & (sizeof(short)-1)) == 0)) {
 969
 970                         short_dst = (unsigned short *)dst;
 971                         short_src = (unsigned short *)src;
 972
 973                         __write_prog_uint16(short_dst++, *short_src++);
 974                         memCount -= sizeof(short);
 975
 976                         dst = (unsigned char *)short_dst;
 977                         src = (unsigned char *)short_src;
 978                 } else {
 979                         __write_prog_uint8(dst++, *src++);
 980                         memCount--;
 981                 }
 982         }
 983
 984         __mem_fault = 0;
 985
 986 err:
 987         __mem_fault_handler = (void *)0;
 988 }
 989
 990 /*
 991  * __read_progmem_safe:
 992  * Get contents of target memory, abort on error.
 993  */
 994
 995 int
 996 __read_progmem_safe (void *dst, void *src, int count)
 997 {
 998         if( !CYG_HAL_STUB_PERMIT_CODE_READ( src, count ) )
 999                 return 0;
1000
1001         memCount = count;
1002         __do_copy_from_progmem((unsigned char*) src, (unsigned char*) dst);
1003         return count - memCount;      // return number of bytes successfully read
1004 }
1005
1006 /*
1007  * __write_progmem_safe:
1008  * Set contents of target memory, abort on error.
1009  */
1010
1011 int
1012 __write_progmem_safe (void *src, void *dst, int count)
1013 {
1014         if( !CYG_HAL_STUB_PERMIT_CODE_WRITE( dst, count ) )
1015                 return 0;
1016
1017         memCount = count;
1018         __do_copy_to_progmem((unsigned char*) src, (unsigned char*) dst);
1019         return count - memCount;      // return number of bytes successfully written
1020 }
1021 #endif
1022
1023 //-----------------------------------------------------------------------------
1024 // Target extras?!
1025 int
1026 __process_target_query(char * pkt, char * out, int maxOut)
1027 { return 0 ; }
1028 int
1029 __process_target_set(char * pkt, char * out, int maxout)
1030 { return 0 ; }
1031 int
1032 __process_target_packet(char * pkt, char * out, int maxout)
1033 { return 0 ; }
1034
1035 // GDB string output, making sure interrupts are disabled.
1036 // This function gets used by some diag output functions.
1037 void
1038 hal_output_gdb_string(target_register_t str, int string_len)
1039 {
1040         unsigned long __state;
1041         HAL_DISABLE_INTERRUPTS(__state);
1042         __output_gdb_string(str, string_len);
1043         HAL_RESTORE_INTERRUPTS(__state);
1044 }
1045
1046 #endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS