void hal_platform_init(void)
{
#if defined(CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT)
// Set up eCos/ROM interfaces
hal_if_init();
#endif
#if defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) && \
(defined(CYGSEM_HAL_USE_ROM_MONITOR_CygMon) || \
defined(CYGSEM_HAL_USE_ROM_MONITOR_GDB_stubs))
{
extern CYG_ADDRESS hal_virtual_vector_table[32];
void patch_dbg_syscalls( void * );
patch_dbg_syscalls( (void *)(&hal_virtual_vector_table[0]) );
}
#endif
}
void hal_platform_init(void)
{
// Note that the hardware seems to come up with the
// caches containing random data. Hence they must be
// invalidated before being enabled.
HAL_ICACHE_INVALIDATE_ALL();
HAL_ICACHE_ENABLE();
HAL_DCACHE_INVALIDATE_ALL();
HAL_DCACHE_ENABLE();
#if defined(CYGPKG_KERNEL) && \
defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) && \
defined(CYGSEM_HAL_USE_ROM_MONITOR_CygMon)
{
extern CYG_ADDRESS hal_virtual_vector_table[32];
extern void patch_dbg_syscalls(void * vector);
patch_dbg_syscalls( (void *)(&hal_virtual_vector_table[0]) );
}
#endif
}
void hal_platform_init(void)
{
HAL_WRITE_UINT8(HAL_LED_ADDRESS, cyg_hal_plf_led_val(8));
#if defined(CYG_HAL_STARTUP_ROM)
// Note that the hardware seems to come up with the
// caches containing random data. Hence they must be
// invalidated before being enabled.
// However, we only do this if we are in ROM. If we are
// in RAM, then we leave the caches in the state chosen
// by the ROM monitor. If we enable them when the monitor
// is not expecting it, we can end up breaking things if the
// monitor is not doing cache flushes.
//HAL_ICACHE_INVALIDATE_ALL();
//HAL_ICACHE_ENABLE();
//HAL_DCACHE_INVALIDATE_ALL();
//HAL_DCACHE_ENABLE();
#endif
// Set up eCos/ROM interfaces
hal_if_init();
#if defined(CYGPKG_KERNEL) && \
defined(CYGFUN_HAL_COMMON_KERNEL_SUPPORT) && \
defined(CYGSEM_HAL_USE_ROM_MONITOR_GDB_stubs)
{
extern void patch_dbg_syscalls(void * vector);
patch_dbg_syscalls( (void *)(&hal_virtual_vector_table[0]) );
}
#endif
#if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
{
static void hal_ctrlc_isr_init(void);
hal_ctrlc_isr_init();
}
#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
}