void hal_plf_stub_init(void) { // extern CYG_ADDRESS hal_virtual_vector_table[64]; extern void init_thread_syscall( void *); extern void install_async_breakpoint(void *epc); void (*oldvsr)(void); extern void __default_exception_vsr(void); // Ensure that the breakpoint VSR points to the default VSR. This will pass // it on to the stubs. HAL_VSR_SET( CYGNUM_HAL_VECTOR_BREAKPOINT, __default_exception_vsr, &oldvsr ); // Install async breakpoint handler into vector table. hal_virtual_vector_table[35] = (CYG_ADDRESS)install_async_breakpoint; #if !defined(CYGPKG_KERNEL) && defined(CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT) // Only include this code if we do not have a kernel. Otherwise // the kernel supplies the functionality for the app we are linked // with. // Prepare for application installation of thread info function in // vector table. hal_virtual_vector_table[15] = 0; init_thread_syscall( (void *)&hal_virtual_vector_table[15] ); #endif }
//-------------------------------------------------------------------------- // Init function. It should be called from the platform initialization code. // For monitor configurations it will initialize the calling interface table, // for client configurations it will patch the existing table as per // configuration. void hal_if_init(void) { //********************************************************************** // // Note that if your RAM application is configured to initialize // the whole table _or_ the communication channels, you _cannot_ // step through this function with the debugger. If your channel // configurations are set to the default, you should be able to // simply step over this function though (or use 'finish' once you // have entered this function if that GDB command works). // // If you really do need to debug this code, the best approach is // to have a working RedBoot / GDB stub in ROM and then change the // hal_virtual_vector_table to reside at some other address in the // RAM configuration than that used by the ROM monitor. Then // you'll be able to use the ROM monitor to debug the below code // and check that it does the right thing. // // Note that if you have a ROM monitor in ROM/flash which does // support virtual vectors, you should be able to disable the // option CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE. On some // targets (which predate the introduction of virtual vectors) // that option is enabled per default and needs to be explicitly // disabled when you have an updated ROM monitor. // //********************************************************************** #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_INIT_WHOLE_TABLE { int i; // Initialize tables with the NOP service. // This should only be done for service routine entries - data // pointers should be NULLed. for (i = 0; i < CYGNUM_CALL_IF_TABLE_SIZE; i++) hal_virtual_vector_table[i] = (CYG_ADDRWORD) &nop_service; // Version number CYGACC_CALL_IF_VERSION_SET(CYGNUM_CALL_IF_TABLE_VERSION_CALL |((CYG_ADDRWORD)CYGNUM_CALL_IF_TABLE_VERSION_COMM<<CYGNUM_CALL_IF_TABLE_VERSION_COMM_shift)); } #endif // Miscellaneous services with wrappers in this file. #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_RESET CYGACC_CALL_IF_RESET_SET(reset); #endif #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DELAY_US CYGACC_CALL_IF_DELAY_US_SET(delay_us); #endif #ifdef CYGSEM_REDBOOT_FLASH_CONFIG CYGACC_CALL_IF_FLASH_CFG_OP_SET(flash_config_op); #endif #ifdef CYGOPT_REDBOOT_FIS CYGACC_CALL_IF_FLASH_FIS_OP_SET(flash_fis_op); CYGACC_CALL_IF_FLASH_FIS_OP2_SET(flash_fis_op2); #endif // Data entries not currently supported in eCos #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_DATA CYGACC_CALL_IF_DBG_DATA_SET(0); #endif #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_VERSION CYGACC_CALL_IF_MONITOR_VERSION_SET(0); #endif // Comm controls #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_CLAIM_COMMS { int i, j; // Clear out tables with safe dummy function. for (j = 0; j < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS+1; j++) for (i = 0; i < CYGNUM_COMM_IF_TABLE_SIZE; i++) comm_channels[j][i] = (CYG_ADDRWORD) &nop_service; // Set accessor functions CYGACC_CALL_IF_SET_DEBUG_COMM_SET(set_debug_comm); CYGACC_CALL_IF_SET_CONSOLE_COMM_SET(set_console_comm); // Initialize console/debug procs. Note that these _must_ // be set to empty before the comms init call. set_debug_comm(CYGNUM_CALL_IF_SET_COMM_ID_EMPTY); set_console_comm(CYGNUM_CALL_IF_SET_COMM_ID_EMPTY); // Initialize channels. This used to be done in // hal_diag_init() and the stub initHardware() functions, but // it makes more sense to have here. cyg_hal_plf_comms_init(); // Always set the debug channel. If stubs are included, it is // necessary. If no stubs are included it does not hurt and is // likely to be required by the hal_if_diag_init code anyway // as it may rely on it if using a mangler. set_debug_comm(CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL); // Set console channel to a safe default. hal_if_diag_init // will override with console channel or mangler if necessary. set_console_comm(CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL); } // Reset console interrupt flag. CYGACC_CALL_IF_CONSOLE_INTERRUPT_FLAG_SET(0); #endif // Set up services provided by clients #if defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) && \ ( defined(CYGSEM_HAL_USE_ROM_MONITOR_GDB_stubs) \ || defined(CYGSEM_HAL_USE_ROM_MONITOR_CygMon)) patch_dbg_syscalls( (void *)(hal_virtual_vector_table) ); #endif // Init client services #if !defined(CYGPKG_KERNEL) && defined(CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT) // Only include this code if we do not have a kernel. Otherwise // the kernel supplies the functionality for the app we are linked // with. // Prepare for application installation of thread info function in // vector table. init_thread_syscall( (void *)&hal_virtual_vector_table[CYGNUM_CALL_IF_DBG_SYSCALL] ); #endif // Finally, install async breakpoint handler if it is configured in. // FIXME: this should probably check for STUBS instead (but code is // conditional on BREAK for now) #if defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT) // Install async breakpoint handler into vector table. CYGACC_CALL_IF_INSTALL_BPT_FN_SET(&cyg_hal_gdb_interrupt); #endif #if 0 != CYGINT_HAL_PLF_IF_INIT // Call platform specific initializations - should only be used // to augment what has already been set up, etc. plf_if_init(); #endif }