Mercurial > ecos
changeset 107:7f461c3a372c
Merge from eCos master repository on 2000-07-04-08:04:30-BST
line wrap: on
line diff
--- a/host/tools/configtool/ChangeLog +++ b/host/tools/configtool/ChangeLog @@ -1,3 +1,10 @@ +2000-07-03 John Dallaway <jld@redhat.com> + + * common/win32/CTCommonDoc.cpp: + + Modify SelectPackages() to inhibit option value refresh + while changing the version of an eCos package. + 2000-06-27 John Dallaway <jld@redhat.com> * standalone/win32/Configtool.rc:
--- a/host/tools/configtool/common/win32/CTCommonDoc.cpp +++ b/host/tools/configtool/common/win32/CTCommonDoc.cpp @@ -944,8 +944,10 @@ void CConfigToolDoc::SelectPackages () bChanged|=pItem->Unload(); } else if (bNowLoaded) {// if the package should be loaded const CString strVersion(dlg.GetVersion (strPackageName)); - if (bPreviouslyLoaded) { // if the package is not already loaded + if (bPreviouslyLoaded) { // if the package is already loaded + CdlTransactionCallback::set_callback_fn (NULL); // avoid value refresh attempts during load/unload bChanged|=pItem->ChangeVersion(strVersion); + CdlTransactionCallback::set_callback_fn (CdlTransactionHandler); // restore value refresh } else { // the package was not loaded but should now be loaded TRACE (_T("Loading package %s\n"), strMacroName);
--- a/packages/hal/arm/aeb/current/ChangeLog +++ b/packages/hal/arm/aeb/current/ChangeLog @@ -1,3 +1,13 @@ +2000-07-03 Jesper Skov <jskov@redhat.com> + + * src/hal_diag.c: + * src/aeb_misc.c: + * src/plf_stub.c: [deleted] + * include/plf_stub.h: + * include/hal_diag.h: + * cdl/hal_arm_aeb.cdl: + Changed to use virtual vectors. + 2000-06-21 Jonathan Larmour <jlarmour@redhat.co.uk> * src/flash_cksum.tcl: Fix quoting when invoking TCL interpreter
--- a/packages/hal/arm/aeb/current/cdl/hal_arm_aeb.cdl +++ b/packages/hal/arm/aeb/current/cdl/hal_arm_aeb.cdl @@ -51,10 +51,11 @@ cdl_package CYGPKG_HAL_ARM_AEB { The aeb HAL package provides the support needed to run eCos on a ARM AEB-1 eval board." - compile hal_diag.c plf_stub.c aeb_misc.c + compile hal_diag.c aeb_misc.c implements CYGINT_HAL_DEBUG_GDB_STUBS implements CYGINT_HAL_DEBUG_GDB_STUBS_BREAK + implements CYGINT_HAL_VIRTUAL_VECTOR_SUPPORT define_proc { puts $::cdl_system_header "#define CYGBLD_HAL_TARGET_H <pkgconf/hal_arm.h>" @@ -90,6 +91,33 @@ cdl_package CYGPKG_HAL_ARM_AEB { run with caches enabled." } + cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS { + display "Number of communication channels on the board" + flavor data + calculated 1 + } + + cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL { + display "Debug serial port" + flavor data + legal_values 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 + default_value 0 + description " + The AEB board has only one serial port. This option + chooses which port will be used to connect to a host + running GDB." + } + + cdl_option CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL { + display "Diagnostic serial port" + flavor data + legal_values 0 to CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS-1 + default_value 0 + description " + The AEB board has only one serial port. This option + chooses which port will be used for diagnostic output." + } + # Real-time clock/counter specifics cdl_component CYGNUM_HAL_RTC_CONSTANTS { display "Real-time clock constants" @@ -159,8 +187,8 @@ cdl_package CYGPKG_HAL_ARM_AEB { requires CYGSEM_HAL_ROM_MONITOR requires CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS requires ! CYGBLD_BUILD_COMMON_GDB_STUBS - requires ! CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT - requires ! CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT + requires CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT + requires CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT requires ! CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT requires ! CYGDBG_HAL_COMMON_CONTEXT_SAVE_MINIMUM no_define @@ -252,4 +280,25 @@ cdl_package CYGPKG_HAL_ARM_AEB { application. This enables features such as utilizing a separate interrupt stack when exceptions are generated." } + + cdl_option CYGSEM_HAL_USE_ROM_MONITOR { + display "Work with a ROM monitor" + flavor booldata + legal_values { "Generic" "GDB_stubs" } + default_value { CYG_HAL_STARTUP == "RAM" ? "GDB_stubs" : 0 } + parent CYGPKG_HAL_ROM_MONITOR + requires { CYG_HAL_STARTUP == "RAM" } + description " + Support can be enabled for different varieties of ROM monitor. + This support changes various eCos semantics such as the encoding + of diagnostic output, or the overriding of hardware interrupt + vectors. + Firstly there is \"Generic\" support which prevents the HAL + from overriding the hardware vectors that it does not use, to + instead allow an installed ROM monitor to handle them. This is + the most basic support which is likely to be common to most + implementations of ROM monitor. + \"GDB_stubs\" provides support when GDB stubs are included in + the ROM monitor or boot ROM." + } }
--- a/packages/hal/arm/aeb/current/include/hal_diag.h +++ b/packages/hal/arm/aeb/current/include/hal_diag.h @@ -49,8 +49,18 @@ #include <cyg/infra/cyg_type.h> -/*---------------------------------------------------------------------------*/ -/* functions implemented in hal_diag.c */ +#if defined(CYGSEM_HAL_VIRTUAL_VECTOR_DIAG) + +#include <cyg/hal/hal_if.h> + +#define HAL_DIAG_INIT() hal_if_diag_init() +#define HAL_DIAG_WRITE_CHAR(_c_) hal_if_diag_write_char(_c_) +#define HAL_DIAG_READ_CHAR(_c_) hal_if_diag_read_char(&_c_) + +#else // everything by steam + +//----------------------------------------------------------------------------- +// functions implemented in hal_diag.c externC void hal_diag_init(void); externC void hal_diag_write_char(char c); @@ -64,6 +74,8 @@ externC void hal_diag_read_char(char *c) #define HAL_DIAG_READ_CHAR(_c_) hal_diag_read_char(&_c_) +#endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG + /*---------------------------------------------------------------------------*/ /* end of hal_diag.h */ #endif /* CYGONCE_HAL_DIAG_H */
--- a/packages/hal/arm/aeb/current/include/plf_stub.h +++ b/packages/hal/arm/aeb/current/include/plf_stub.h @@ -54,30 +54,30 @@ #include <cyg/hal/arm_stub.h> // architecture stub support //---------------------------------------------------------------------------- -// Define serial stuff. +// Define some platform specific communication details. This is mostly +// handled by hal_if now, but we need to make sure the comms tables are +// properly initialized. -extern void hal_aeb_init_serial(void); -extern int hal_aeb_get_char(void); -extern void hal_aeb_put_char(int c); -extern int hal_aeb_interruptible(int); +externC void cyg_hal_plf_comms_init(void); -#define HAL_STUB_PLATFORM_INIT_SERIAL() hal_aeb_init_serial() -#define HAL_STUB_PLATFORM_GET_CHAR() hal_aeb_get_char() -#define HAL_STUB_PLATFORM_PUT_CHAR(c) hal_aeb_put_char((c)) +#define HAL_STUB_PLATFORM_INIT_SERIAL() cyg_hal_plf_comms_init() + #define HAL_STUB_PLATFORM_SET_BAUD_RATE(baud) CYG_UNUSED_PARAM(int, (baud)) -#define HAL_STUB_PLATFORM_INTERRUPTIBLE (&hal_aeb_interruptible) +#define HAL_STUB_PLATFORM_INTERRUPTIBLE 0 #define HAL_STUB_PLATFORM_INIT_BREAK_IRQ() CYG_EMPTY_STATEMENT //---------------------------------------------------------------------------- // Stub initializer. #define HAL_STUB_PLATFORM_INIT() CYG_EMPTY_STATEMENT +#endif // ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS + //---------------------------------------------------------------------------- // Reset. extern void hal_aeb_reset(void); #define HAL_STUB_PLATFORM_RESET() hal_aeb_reset() -#endif // ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS +#define HAL_STUB_PLATFORM_RESET_ENTRY 0x4018000 //----------------------------------------------------------------------------- #endif // CYGONCE_HAL_PLF_STUB_H
--- a/packages/hal/arm/aeb/current/src/aeb_misc.c +++ b/packages/hal/arm/aeb/current/src/aeb_misc.c @@ -52,6 +52,8 @@ #include <cyg/hal/hal_diag.h> #include <cyg/hal/hal_intr.h> // necessary? #include <cyg/hal/hal_cache.h> +#include <cyg/hal/hal_if.h> // calling interface +#include <cyg/hal/hal_misc.h> // helper functions #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT #include <cyg/hal/drv_api.h> // HAL ISR support #endif @@ -196,7 +198,7 @@ static cyg_handle_t abort_interrupt_han static int aeb_abort_isr(cyg_vector_t vector, cyg_addrword_t data, HAL_SavedRegisters *regs) { - cyg_hal_gdb_interrupt (regs->pc); + cyg_hal_user_break((CYG_ADDRWORD*)regs); cyg_drv_interrupt_acknowledge(CYGNUM_HAL_INTERRUPT_EXT0); return 0; // No need to run DSR } @@ -283,6 +285,9 @@ void hal_hardware_init(void) // Clear and initialize cache HAL_UCACHE_INVALIDATE_ALL(); HAL_UCACHE_ENABLE(); + + // Set up eCos/ROM interfaces + hal_if_init(); } // @@ -411,5 +416,44 @@ aeb_setup_timer1(cyg_uint32 period) } #endif +//----------------------------------------------------------------------------- +// Reset board (definitions from watchdog file aeb1.cxx) + +// Register definitions +#define CYGARC_REG_WATCHDOG_BASE 0xFFFFAC00 +#define CYGARC_REG_WATCHDOG_WDCTLR (CYGARC_REG_WATCHDOG_BASE+0x30) +#define CYGARC_REG_WATCHDOG_WDCNTR (CYGARC_REG_WATCHDOG_BASE+0x34) + +// Control register bits +#define CYGARC_REG_WATCHDOG_WDCTLR_EN 0x01 // enable +#define CYGARC_REG_WATCHDOG_WDCTLR_RSP_NMF 0x00 // non-maskable fiq +#define CYGARC_REG_WATCHDOG_WDCTLR_RSP_ER 0x04 // external reset +#define CYGARC_REG_WATCHDOG_WDCTLR_RSP_SR 0x06 // system reset +#define CYGARC_REG_WATCHDOG_WDCTLR_FRZ 0x08 // lock enable bit +#define CYGARC_REG_WATCHDOG_WDCTLR_TOP_MASK 0x70 // time out period + +#define CYGARC_REG_WATCHDOG_WDCTLR_TOP_17 0x00 // 2^17 +#define CYGARC_REG_WATCHDOG_WDCTLR_TOP_17_P 5242880 // = 5.2ms + +#define CYGARC_REG_WATCHDOG_WDCTLR_TOP_25 0x40 // 2^25 +#define CYGARC_REG_WATCHDOG_WDCTLR_TOP_25_P 1342177300 // = 1.3421773s + +void +hal_aeb_reset(void) +{ + // Clear the watchdog counter. + HAL_WRITE_UINT32(CYGARC_REG_WATCHDOG_WDCNTR, 0); + + // Enable the watchdog with the smallest timeout. + HAL_WRITE_UINT8(CYGARC_REG_WATCHDOG_WDCTLR, + (CYGARC_REG_WATCHDOG_WDCTLR_TOP_17 + | CYGARC_REG_WATCHDOG_WDCTLR_FRZ + | CYGARC_REG_WATCHDOG_WDCTLR_RSP_SR + | CYGARC_REG_WATCHDOG_WDCTLR_EN)); + + // Wait for it... + for(;;); +} + /*------------------------------------------------------------------------*/ // EOF hal_misc.c
--- a/packages/hal/arm/aeb/current/src/hal_diag.c +++ b/packages/hal/arm/aeb/current/src/hal_diag.c @@ -47,21 +47,12 @@ #include <cyg/infra/cyg_trac.h> // tracing macros #include <cyg/infra/cyg_ass.h> // assertion macros -#include <cyg/hal/hal_arch.h> // basic machine info -#include <cyg/hal/hal_intr.h> // interrupt macros +#include <cyg/hal/hal_arch.h> // SAVE/RESTORE GP macros #include <cyg/hal/hal_io.h> // IO macros -#include <cyg/hal/hal_diag.h> -#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS -#include <cyg/hal/drv_api.h> -#include <cyg/hal/hal_stub.h> // cyg_hal_gdb_interrupt -#endif - -// Assumption: all diagnostic output must be GDB packetized unless this is a ROM (i.e. -// totally stand-alone) system. - -#if defined(CYG_HAL_STARTUP_ROM) || defined(CYGDBG_HAL_DIAG_DISABLE_GDB_PROTOCOL) -#define HAL_DIAG_USES_HARDWARE -#endif +#include <cyg/hal/hal_if.h> // interface API +#include <cyg/hal/hal_intr.h> // HAL_ENABLE/MASK/UNMASK_INTERRUPTS +#include <cyg/hal/hal_misc.h> // Helper functions +#include <cyg/hal/drv_api.h> // CYG_ISR_HANDLED /*---------------------------------------------------------------------------*/ // AEB Serial Port (UART1) for Debug @@ -73,42 +64,26 @@ #define CYG_DEVICE_SERIAL_RS232_BAUD_MSB (0) #define CYG_DEVICE_SERIAL_RS232_BAUD_LSB (13*3) // This is the base address of UART1 -#define CYG_DEVICE_SERIAL_RS232_16550_BASE 0xFFFF0400 +#define CYG_DEV_UART1_BASE 0xFFFF0400 + +// Interrupt Enable Register +#define SIO_IER_RCV 0x01 +#define SIO_IER_XMT 0x02 +#define SIO_IER_LS 0x04 +#define SIO_IER_MS 0x08 // Define the serial registers. -#define CYG_DEVICE_SERIAL_RS232_16550_RBR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x00) - // receiver buffer register, read, dlab = 0 -#define CYG_DEVICE_SERIAL_RS232_16550_THR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x00) - // transmitter holding register, write, dlab = 0 -#define CYG_DEVICE_SERIAL_RS232_16550_DLL \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x00) - // divisor latch (LS), read/write, dlab = 1 -#define CYG_DEVICE_SERIAL_RS232_16550_IER \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x04) - // interrupt enable register, read/write, dlab = 0 -#define CYG_DEVICE_SERIAL_RS232_16550_DLM \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x04) - // divisor latch (MS), read/write, dlab = 1 -#define CYG_DEVICE_SERIAL_RS232_16550_IIR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x08) - // interrupt identification register, read, dlab = 0 -#define CYG_DEVICE_SERIAL_RS232_16550_FCR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x08) - // fifo control register, write, dlab = 0 -#define CYG_DEVICE_SERIAL_RS232_16550_LCR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x0C) - // line control register, read/write -#define CYG_DEVICE_SERIAL_RS232_16550_MCR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x10) - // modem control register, read/write -#define CYG_DEVICE_SERIAL_RS232_16550_LSR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x14) - // line status register, read -#define CYG_DEVICE_SERIAL_RS232_16550_MSR \ - ((volatile cyg_uint8 *) CYG_DEVICE_SERIAL_RS232_16550_BASE + 0x18) - // modem status register, read +#define CYG_DEV_RBR 0x00 // receiver buffer register, read, dlab = 0 +#define CYG_DEV_THR 0x00 // transmitter holding register, write, dlab = 0 +#define CYG_DEV_DLL 0x00 // divisor latch (LS), read/write, dlab = 1 +#define CYG_DEV_IER 0x04 // interrupt enable register, read/write, dlab = 0 +#define CYG_DEV_DLM 0x04 // divisor latch (MS), read/write, dlab = 1 +#define CYG_DEV_IIR 0x08 // interrupt identification register, read, dlab = 0 +#define CYG_DEV_FCR 0x08 // fifo control register, write, dlab = 0 +#define CYG_DEV_LCR 0x0C // line control register, read/write +#define CYG_DEV_MCR 0x10 // modem control register, read/write +#define CYG_DEV_LSR 0x14 // line status register, read +#define CYG_DEV_MSR 0x18 // modem status register, read // The line status register bits. #define SIO_LSR_DR 0x01 // data ready @@ -140,34 +115,290 @@ #define SIO_LCR_SB 0x40 // set break #define SIO_LCR_DLAB 0x80 // divisor latch access bit +// Modem Control Register +#define SIO_MCR_DTR 0x01 +#define SIO_MCR_RTS 0x02 +#define SIO_MCR_INT 0x08 // Enable interrupts + + +//----------------------------------------------------------------------------- +typedef struct { + cyg_uint8* base; + cyg_int32 msec_timeout; + int isr_vector; +} channel_data_t; + +//----------------------------------------------------------------------------- + +static void +cyg_hal_plf_serial_init_channel(void* __ch_data) +{ + cyg_uint8* base = ((channel_data_t*)__ch_data)->base; + cyg_uint8 lcr, dll, dlm; + + // 8-1-no parity. + HAL_WRITE_UINT8(base+CYG_DEV_LCR, SIO_LCR_WLS0 | SIO_LCR_WLS1); + + HAL_READ_UINT8(base+CYG_DEV_LCR, lcr); + lcr |= SIO_LCR_DLAB; + HAL_WRITE_UINT8(base+CYG_DEV_LCR, lcr); + HAL_READ_UINT8(base+CYG_DEV_DLL, dll); + HAL_READ_UINT8(base+CYG_DEV_DLM, dlm); + HAL_WRITE_UINT8 (base+CYG_DEV_DLL, CYG_DEVICE_SERIAL_RS232_BAUD_LSB); + HAL_WRITE_UINT8 (base+CYG_DEV_DLM, CYG_DEVICE_SERIAL_RS232_BAUD_MSB); + lcr &= ~SIO_LCR_DLAB; + HAL_WRITE_UINT8 (base+CYG_DEV_LCR, lcr); + HAL_WRITE_UINT8 (base+CYG_DEV_FCR, 0x07); // Enable & clear FIFO +} + +void +cyg_hal_plf_serial_putc(void *__ch_data, char c) +{ + cyg_uint8* base = ((channel_data_t*)__ch_data)->base; + cyg_uint8 lsr; + CYGARC_HAL_SAVE_GP(); + + do { + HAL_READ_UINT8(base+CYG_DEV_LSR, lsr); + } while ((lsr & SIO_LSR_THRE) == 0); + + HAL_WRITE_UINT8(base+CYG_DEV_THR, c); + + CYGARC_HAL_RESTORE_GP(); +} + +static cyg_bool +cyg_hal_plf_serial_getc_nonblock(void* __ch_data, cyg_uint8* ch) +{ + cyg_uint8* base = ((channel_data_t*)__ch_data)->base; + cyg_uint8 lsr; + + HAL_READ_UINT8(base+CYG_DEV_LSR, lsr); + if ((lsr & SIO_LSR_DR) == 0) + return false; + + HAL_READ_UINT8(base+CYG_DEV_RBR, *ch); + + return true; +} + +cyg_uint8 +cyg_hal_plf_serial_getc(void* __ch_data) +{ + cyg_uint8 ch; + CYGARC_HAL_SAVE_GP(); + + while(!cyg_hal_plf_serial_getc_nonblock(__ch_data, &ch)); + + CYGARC_HAL_RESTORE_GP(); + return ch; +} + +#if defined(CYGSEM_HAL_VIRTUAL_VECTOR_DIAG) \ + || defined(CYGPRI_HAL_IMPLEMENTS_IF_SERVICES) + +static void +cyg_hal_plf_serial_write(void* __ch_data, const cyg_uint8* __buf, + cyg_uint32 __len) +{ + CYGARC_HAL_SAVE_GP(); + + while(__len-- > 0) + cyg_hal_plf_serial_putc(__ch_data, *__buf++); + + CYGARC_HAL_RESTORE_GP(); +} + +static void +cyg_hal_plf_serial_read(void* __ch_data, cyg_uint8* __buf, cyg_uint32 __len) +{ + CYGARC_HAL_SAVE_GP(); + + while(__len-- > 0) + *__buf++ = cyg_hal_plf_serial_getc(__ch_data); + + CYGARC_HAL_RESTORE_GP(); +} + +cyg_bool +cyg_hal_plf_serial_getc_timeout(void* __ch_data, cyg_uint8* ch) +{ + int delay_count; + channel_data_t* chan = (channel_data_t*)__ch_data; + cyg_bool res; + CYGARC_HAL_SAVE_GP(); + + delay_count = chan->msec_timeout * 10; // delay in .1 ms steps + + for(;;) { + res = cyg_hal_plf_serial_getc_nonblock(__ch_data, ch); + if (res || 0 == delay_count--) + break; + + CYGACC_CALL_IF_DELAY_US(100); + } + + CYGARC_HAL_RESTORE_GP(); + return res; +} + +static int +cyg_hal_plf_serial_control(void *__ch_data, __comm_control_cmd_t __func, ...) +{ + static int irq_state = 0; + channel_data_t* chan = (channel_data_t*)__ch_data; + int ret = 0; + CYGARC_HAL_SAVE_GP(); + + switch (__func) { + case __COMMCTL_IRQ_ENABLE: + irq_state = 1; + + HAL_WRITE_UINT8(chan->base+CYG_DEV_IER, SIO_IER_RCV); + HAL_WRITE_UINT8(chan->base+CYG_DEV_MCR, SIO_MCR_INT|SIO_MCR_DTR|SIO_MCR_RTS); + + HAL_INTERRUPT_UNMASK(chan->isr_vector); + break; + case __COMMCTL_IRQ_DISABLE: + ret = irq_state; + irq_state = 0; + + HAL_WRITE_UINT8(chan->base+CYG_DEV_IER, 0); + HAL_WRITE_UINT8(chan->base+CYG_DEV_MCR, SIO_MCR_INT|SIO_MCR_DTR|SIO_MCR_RTS); + + HAL_INTERRUPT_MASK(chan->isr_vector); + break; + case __COMMCTL_DBG_ISR_VECTOR: + ret = chan->isr_vector; + break; + case __COMMCTL_SET_TIMEOUT: + { + va_list ap; + + va_start(ap, __func); + + ret = chan->msec_timeout; + chan->msec_timeout = va_arg(ap, cyg_uint32); + + va_end(ap); + } + default: + break; + } + CYGARC_HAL_RESTORE_GP(); + return ret; +} + +static int +cyg_hal_plf_serial_isr(void *__ch_data, int* __ctrlc, + CYG_ADDRWORD __vector, CYG_ADDRWORD __data) +{ + int res = 0; + channel_data_t* chan = (channel_data_t*)__ch_data; + char c; + cyg_uint8 lsr; + CYGARC_HAL_SAVE_GP(); + + cyg_drv_interrupt_acknowledge(chan->isr_vector); + + + *__ctrlc = 0; + HAL_READ_UINT8(chan->base+CYG_DEV_LSR, lsr); + if ( (lsr & SIO_LSR_DR) != 0 ) { + + HAL_READ_UINT8(chan->base+CYG_DEV_RBR, c); + if( cyg_hal_is_break( &c , 1 ) ) + *__ctrlc = 1; + + res = CYG_ISR_HANDLED; + } + + CYGARC_HAL_RESTORE_GP(); + return res; +} + +static channel_data_t aeb_ser_channels[1]; + +static void +cyg_hal_plf_serial_init(void) +{ + hal_virtual_comm_table_t* comm; + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + channel_data_t* chan; + + chan = &aeb_ser_channels[0]; + chan->base = (cyg_uint8*)CYG_DEV_UART1_BASE; + chan->isr_vector = CYGNUM_HAL_INTERRUPT_UART1; + chan->msec_timeout = 1000; + + // Init channel + cyg_hal_plf_serial_init_channel(chan); + + // Setup procs in the vector table + + // Set channel 0 + CYGACC_CALL_IF_SET_CONSOLE_COMM(0); + comm = CYGACC_CALL_IF_CONSOLE_PROCS(); + CYGACC_COMM_IF_CH_DATA_SET(*comm, chan); + CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write); + CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_serial_read); + CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_serial_putc); + CYGACC_COMM_IF_GETC_SET(*comm, cyg_hal_plf_serial_getc); + CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_plf_serial_control); + CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_serial_isr); + CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout); + + // Restore original console + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); +} + +void +cyg_hal_plf_comms_init(void) +{ + static int initialized = 0; + + if (initialized) + return; + + initialized = 1; + + cyg_hal_plf_serial_init(); +} +#endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES + +//============================================================================= +// Compatibility with older stubs +//============================================================================= + +#ifndef CYGSEM_HAL_VIRTUAL_VECTOR_DIAG + +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS +#include <cyg/hal/drv_api.h> +#include <cyg/hal/hal_stub.h> // cyg_hal_gdb_interrupt +#endif + +// Assumption: all diagnostic output must be GDB packetized unless this is a ROM (i.e. +// totally stand-alone) system. + +#if defined(CYG_HAL_STARTUP_ROM) || defined(CYGDBG_HAL_DIAG_DISABLE_GDB_PROTOCOL) +#define HAL_DIAG_USES_HARDWARE +#endif + + +static channel_data_t aeb_ser_channel = {(cyg_uint8*)CYG_DEV_UART1_BASE, 0, 0}; + #ifdef HAL_DIAG_USES_HARDWARE void hal_diag_init(void) { static int init = 0; char *msg = "\n\rAEB-1 eCos\n\r"; - cyg_uint8 lcr; - cyg_uint8 dll, dlm; if (init++) return; - // 8-1-no parity. - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LCR, - SIO_LCR_WLS0 | SIO_LCR_WLS1); + cyg_hal_plf_serial_init_channel(&aeb_ser_channel); - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LCR, lcr); - lcr |= SIO_LCR_DLAB; - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LCR, lcr); - HAL_READ_UINT8(CYG_DEVICE_SERIAL_RS232_16550_DLL, dll); - HAL_READ_UINT8(CYG_DEVICE_SERIAL_RS232_16550_DLM, dlm); - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_DLL, - CYG_DEVICE_SERIAL_RS232_BAUD_LSB); - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_DLM, - CYG_DEVICE_SERIAL_RS232_BAUD_MSB); - lcr &= ~SIO_LCR_DLAB; - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LCR, lcr); - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_FCR, 0x07); // Enable & clear FIFO - while (*msg) hal_diag_write_char(*msg++); + while (*msg) cyg_hal_plf_serial_putc(&aeb_ser_channel, *msg++); } #ifdef DEBUG_DIAG @@ -182,15 +413,10 @@ static int diag_bp = 0; void hal_diag_write_char(char c) { - cyg_uint8 lsr; + hal_diag_init(); - hal_diag_init(); - do { - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LSR, lsr); - } while ((lsr & SIO_LSR_THRE) == 0); + cyg_hal_plf_serial_putc(&aeb_ser_channel, c); - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_THR, c); - HAL_IO_BARRIER (); #ifdef DEBUG_DIAG diag_buffer[diag_bp++] = c; if (diag_bp == DIAG_BUFSIZE) diag_bp = 0; @@ -199,15 +425,7 @@ void hal_diag_write_char(char c) void hal_diag_read_char(char *c) { - cyg_uint8 lsr; - - do { - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LSR, lsr); - } while ((lsr & SIO_LSR_DR) == 0); - HAL_IO_BARRIER (); // Prevent RBR preload. - - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_RBR, *c); - HAL_IO_BARRIER (); + *c = cyg_hal_plf_serial_getc(&aeb_ser_channel); } #else // HAL_DIAG relies on GDB @@ -215,37 +433,25 @@ void hal_diag_read_char(char *c) // Initialize diag port - assume GDB channel is already set up void hal_diag_init(void) { + if (0) cyg_hal_plf_serial_init_channel(&aeb_ser_channel); // avoid warning } // Actually send character down the wire static void hal_diag_write_char_serial(char c) { - cyg_uint8 lsr; + hal_diag_init(); - hal_diag_init(); - do { - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LSR, lsr); - } while ((lsr & SIO_LSR_THRE) == 0); - - HAL_WRITE_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_THR, c); - HAL_IO_BARRIER (); + cyg_hal_plf_serial_putc(&aeb_ser_channel, c); } static bool hal_diag_read_serial(char *c) { long timeout = 1000000000; // A long time... - cyg_uint8 lsr; + while (!cyg_hal_plf_serial_getc_nonblock(&aeb_ser_channel, c)) + if (0 == --timeout) return false; - do { - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_LSR, lsr); - if (--timeout == 0) return false; - } while ((lsr & SIO_LSR_DR) == 0); - HAL_IO_BARRIER (); // Prevent RBR preload. - - HAL_READ_UINT8 (CYG_DEVICE_SERIAL_RS232_16550_RBR, *c); - HAL_IO_BARRIER (); return true; } @@ -340,5 +546,8 @@ hal_diag_write_char(char c) } #endif +#endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG + + /*---------------------------------------------------------------------------*/ /* End of hal_diag.c */
--- a/packages/hal/common/current/ChangeLog +++ b/packages/hal/common/current/ChangeLog @@ -1,3 +1,14 @@ +2000-06-30 Jesper Skov <jskov@redhat.com> + + * include/hal_if.h: Make CYGACC macros call functions. May have to + add some _GET macros at some time if anyone needs to access the + function pointers. + + * src/hal_stub.c: + * src/hal_misc.c: + * src/hal_if.c: + Matching changes of CYGACC clients. + 2000-06-29 Jesper Skov <jskov@redhat.com> * src/hal_stub.c (cyg_hal_gdb_diag_putc): Check console interrupt
--- a/packages/hal/common/current/include/hal_if.h +++ b/packages/hal/common/current/include/hal_if.h @@ -132,54 +132,54 @@ typedef volatile CYG_ADDRWORD hal_virtua typedef void* __comm_if_ch_data_t; #define CYGACC_COMM_IF_CH_DATA(_t_) \ - ((__comm_if_ch_data_t)(((_t_))[CYGNUM_COMM_IF_CH_DATA])) + ((__comm_if_ch_data_t)((_t_)[CYGNUM_COMM_IF_CH_DATA])) #define CYGACC_COMM_IF_CH_DATA_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_CH_DATA]=(CYG_ADDRWORD)(_x_) typedef void (*__comm_if_write_t)(void* __ch_data, const cyg_uint8* __buf, cyg_uint32 __len); -#define CYGACC_COMM_IF_WRITE(_t_) \ - ((__comm_if_write_t)(((_t_))[CYGNUM_COMM_IF_WRITE])) +#define CYGACC_COMM_IF_WRITE(_t_, _b_, _l_) \ + ((__comm_if_write_t)(((_t_))[CYGNUM_COMM_IF_WRITE]))(CYGACC_COMM_IF_CH_DATA(_t_), (_b_), (_l_)) #define CYGACC_COMM_IF_WRITE_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_WRITE]=(CYG_ADDRWORD)(_x_) typedef int (*__comm_if_read_t)(void* __ch_data, cyg_uint8* __buf, cyg_uint32 __len); -#define CYGACC_COMM_IF_READ(_t_) \ - ((__comm_if_read_t)(((_t_))[CYGNUM_COMM_IF_READ])) +#define CYGACC_COMM_IF_READ(_t_, _b_, _l_) \ + ((__comm_if_read_t)(((_t_))[CYGNUM_COMM_IF_READ]))(CYGACC_COMM_IF_CH_DATA(_t_), (_b_), (_l_)) #define CYGACC_COMM_IF_READ_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_READ]=(CYG_ADDRWORD)(_x_) typedef void (*__comm_if_putc_t)(void* __ch_data, cyg_uint8 __ch); -#define CYGACC_COMM_IF_PUTC(_t_) \ - ((__comm_if_putc_t)(((_t_))[CYGNUM_COMM_IF_PUTC])) +#define CYGACC_COMM_IF_PUTC(_t_, _c_) \ + ((__comm_if_putc_t)(((_t_))[CYGNUM_COMM_IF_PUTC]))(CYGACC_COMM_IF_CH_DATA(_t_), (_c_)) #define CYGACC_COMM_IF_PUTC_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_PUTC]=(CYG_ADDRWORD)(_x_) typedef cyg_uint8 (*__comm_if_getc_t)(void* __ch_data); #define CYGACC_COMM_IF_GETC(_t_) \ - ((__comm_if_getc_t)(((_t_))[CYGNUM_COMM_IF_GETC])) + ((__comm_if_getc_t)((_t_)[CYGNUM_COMM_IF_GETC]))(CYGACC_COMM_IF_CH_DATA(_t_)) #define CYGACC_COMM_IF_GETC_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_GETC]=(CYG_ADDRWORD)(_x_) typedef int (*__comm_if_control_t)(void *__ch_data, __comm_control_cmd_t __func, ...); -#define CYGACC_COMM_IF_CONTROL(_t_) \ - ((__comm_if_control_t)(((_t_))[CYGNUM_COMM_IF_CONTROL])) +#define CYGACC_COMM_IF_CONTROL(_t_, args...) \ + ((__comm_if_control_t)(((_t_))[CYGNUM_COMM_IF_CONTROL]))(CYGACC_COMM_IF_CH_DATA(_t_), ## args) #define CYGACC_COMM_IF_CONTROL_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_CONTROL]=(CYG_ADDRWORD)(_x_) typedef int (*__comm_if_dbg_isr_t)(void *__ch_data, int* __ctrlc, CYG_ADDRWORD __vector, CYG_ADDRWORD __data); -#define CYGACC_COMM_IF_DBG_ISR(_t_) \ - ((__comm_if_dbg_isr_t)(((_t_))[CYGNUM_COMM_IF_DBG_ISR])) +#define CYGACC_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_) \ + ((__comm_if_dbg_isr_t)(((_t_))[CYGNUM_COMM_IF_DBG_ISR]))(CYGACC_COMM_IF_CH_DATA(_t_), (_c_), (_v_), (_d_)) #define CYGACC_COMM_IF_DBG_ISR_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_DBG_ISR]=(CYG_ADDRWORD)(_x_) typedef cyg_bool (*__comm_if_getc_timeout_t)(void* __ch_data, cyg_uint8* __ch); -#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_) \ - ((__comm_if_getc_timeout_t)(((_t_))[CYGNUM_COMM_IF_GETC_TIMEOUT])) +#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_, _c_) \ + ((__comm_if_getc_timeout_t)(((_t_))[CYGNUM_COMM_IF_GETC_TIMEOUT]))(CYGACC_COMM_IF_CH_DATA(_t_), (_c_)) #define CYGACC_COMM_IF_GETC_TIMEOUT_SET(_t_, _x_) \ (_t_)[CYGNUM_COMM_IF_GETC_TIMEOUT]=(CYG_ADDRWORD)(_x_) @@ -282,14 +282,14 @@ typedef hal_virtual_comm_table_t *__call hal_virtual_vector_table[CYGNUM_CALL_IF_DEBUG_PROCS]=(CYG_ADDRWORD)(_x_) typedef void (*__call_if_flush_dcache_t)(void *__p, int __nbytes); -#define CYGACC_CALL_IF_FLUSH_DCACHE() \ - ((__call_if_flush_dcache_t)hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_DCACHE]) +#define CYGACC_CALL_IF_FLUSH_DCACHE(_p_, _n_) \ + ((__call_if_flush_dcache_t)hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_DCACHE])((_p_), (_n_)) #define CYGACC_CALL_IF_FLUSH_DCACHE_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_DCACHE]=(CYG_ADDRWORD)(_x_) typedef void (*__call_if_flush_icache_t)(void *__p, int __nbytes); -#define CYGACC_CALL_IF_FLUSH_ICACHE() \ - ((__call_if_flush_icache_t)hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_ICACHE]) +#define CYGACC_CALL_IF_FLUSH_ICACHE(_p_, _n_) \ + ((__call_if_flush_icache_t)hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_ICACHE])((_p_), (_n_)) #define CYGACC_CALL_IF_FLUSH_ICACHE_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_FLUSH_ICACHE]=(CYG_ADDRWORD)(_x_) @@ -307,26 +307,26 @@ typedef void* __call_if_board_data_t; typedef int (*__call_if_sysinfo_t)(int __id, void* __ap); //typedef int (*__call_if_sysinfo_t)(enum bsp_info_id __id, va_list __ap); -#define CYGACC_CALL_IF_SYSINFO() \ - ((__call_if_sysinfo_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SYSINFO]) +#define CYGACC_CALL_IF_SYSINFO(_i_, _a_) \ + ((__call_if_sysinfo_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SYSINFO])((_i_), (_a_)) #define CYGACC_CALL_IF_SYSINFO_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_SYSINFO]=(CYG_ADDRWORD)(_x_) typedef int (*__call_if_set_debug_comm_t)(int __comm_id); -#define CYGACC_CALL_IF_SET_DEBUG_COMM() \ - ((__call_if_set_debug_comm_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_DEBUG_COMM]) +#define CYGACC_CALL_IF_SET_DEBUG_COMM(_i_) \ + ((__call_if_set_debug_comm_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_DEBUG_COMM])((_i_)) #define CYGACC_CALL_IF_SET_DEBUG_COMM_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_SET_DEBUG_COMM]=(CYG_ADDRWORD)(_x_) typedef int (*__call_if_set_console_comm_t)(int __comm_id); -#define CYGACC_CALL_IF_SET_CONSOLE_COMM() \ - ((__call_if_set_console_comm_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_CONSOLE_COMM]) +#define CYGACC_CALL_IF_SET_CONSOLE_COMM(_i_) \ + ((__call_if_set_console_comm_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_CONSOLE_COMM])((_i_)) #define CYGACC_CALL_IF_SET_CONSOLE_COMM_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_SET_CONSOLE_COMM]=(CYG_ADDRWORD)(_x_) typedef int (*__call_if_set_serial_baud_t)(int __comm_id, int __baud); -#define CYGACC_CALL_IF_SET_SERIAL_BAUD() \ - ((__call_if_set_serial_baud_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_SERIAL_BAUD]) +#define CYGACC_CALL_IF_SET_SERIAL_BAUD(_i_, _b_) \ + ((__call_if_set_serial_baud_t)hal_virtual_vector_table[CYGNUM_CALL_IF_SET_SERIAL_BAUD])((_i_), (_b_)) #define CYGACC_CALL_IF_SET_SERIAL_BAUD_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_SET_SERIAL_BAUD]=(CYG_ADDRWORD)(_x_) @@ -345,9 +345,11 @@ typedef int (*__call_if_dbg_syscall_t) ( typedef void (*__call_if_reset_t)(void); #define CYGACC_CALL_IF_RESET() \ - ((__call_if_reset_t)hal_virtual_vector_table[CYGNUM_CALL_IF_RESET]) + ((__call_if_reset_t)hal_virtual_vector_table[CYGNUM_CALL_IF_RESET])() #define CYGACC_CALL_IF_RESET_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_RESET]=(CYG_ADDRWORD)(_x_) +#define CYGACC_CALL_IF_RESET_GET() \ + ((__call_if_reset_t)hal_virtual_vector_table[CYGNUM_CALL_IF_RESET]) typedef int __call_if_console_interrupt_flag_t; #define CYGACC_CALL_IF_CONSOLE_INTERRUPT_FLAG() \ @@ -356,14 +358,14 @@ typedef int __call_if_console_interrupt_ hal_virtual_vector_table[CYGNUM_CALL_IF_CONSOLE_INTERRUPT_FLAG]=(CYG_ADDRWORD)(_x_) typedef void (*__call_if_delay_us_t)(cyg_int32 usecs); -#define CYGACC_CALL_IF_DELAY_US() \ - ((__call_if_delay_us_t)hal_virtual_vector_table[CYGNUM_CALL_IF_DELAY_US]) +#define CYGACC_CALL_IF_DELAY_US(_u_) \ + ((__call_if_delay_us_t)hal_virtual_vector_table[CYGNUM_CALL_IF_DELAY_US])((_u_)) #define CYGACC_CALL_IF_DELAY_US_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_DELAY_US]=(CYG_ADDRWORD)(_x_) typedef void (*__call_if_install_bpt_fn_t)(void *__epc); -#define CYGACC_CALL_IF_INSTALL_BPT_FN() \ - ((__call_if_install_bpt_fn_t)hal_virtual_vector_table[CYGNUM_CALL_IF_INSTALL_BPT_FN]) +#define CYGACC_CALL_IF_INSTALL_BPT_FN(_e_) \ + ((__call_if_install_bpt_fn_t)hal_virtual_vector_table[CYGNUM_CALL_IF_INSTALL_BPT_FN])((_e_)) #define CYGACC_CALL_IF_INSTALL_BPT_FN_SET(_x_) \ hal_virtual_vector_table[CYGNUM_CALL_IF_INSTALL_BPT_FN]=(CYG_ADDRWORD)(_x_)
--- a/packages/hal/common/current/src/hal_if.c +++ b/packages/hal/common/current/src/hal_if.c @@ -201,7 +201,7 @@ set_debug_comm(int __comm_id) // Find the interrupt state of the channel. __chan = CYGACC_CALL_IF_DEBUG_PROCS(); if (__chan) - interrupt_state = CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), __COMMCTL_IRQ_DISABLE); + interrupt_state = CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE); __selected_id = __comm_id; CYGACC_CALL_IF_DEBUG_PROCS_SET(comm_channels[__comm_id]); @@ -209,9 +209,9 @@ set_debug_comm(int __comm_id) // Set interrupt state on the new channel. __chan = CYGACC_CALL_IF_DEBUG_PROCS(); if (interrupt_state) - CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), __COMMCTL_IRQ_ENABLE); + CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE); else - CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), __COMMCTL_IRQ_DISABLE); + CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE); } CYGARC_HAL_RESTORE_GP(); @@ -313,10 +313,10 @@ hal_if_diag_init(void) // Set console channel. This should only be done when the console channel // differs from the debug channel to prevent removing the debug agent's // mangler procs. - if (CYGACC_CALL_IF_SET_DEBUG_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT) + if (CYGACC_CALL_IF_SET_DEBUG_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT) != CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL) - CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL); + CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL); } void @@ -325,10 +325,10 @@ hal_if_diag_write_char(char c) hal_virtual_comm_table_t* __chan = CYGACC_CALL_IF_CONSOLE_PROCS(); if (__chan) - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), c); + CYGACC_COMM_IF_PUTC(*__chan, c); else { __chan = CYGACC_CALL_IF_DEBUG_PROCS(); - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), c); + CYGACC_COMM_IF_PUTC(*__chan, c); } // Check interrupt flag @@ -344,10 +344,10 @@ hal_if_diag_read_char(char *c) hal_virtual_comm_table_t* __chan = CYGACC_CALL_IF_CONSOLE_PROCS(); if (__chan) - *c = CYGACC_COMM_IF_GETC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan)); + *c = CYGACC_COMM_IF_GETC(*__chan); else { __chan = CYGACC_CALL_IF_DEBUG_PROCS(); - *c = CYGACC_COMM_IF_GETC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan)); + *c = CYGACC_COMM_IF_GETC(*__chan); } } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG @@ -371,8 +371,7 @@ hal_ctrlc_isr_init(void) return; #endif - CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), - __COMMCTL_IRQ_ENABLE); + CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE); } cyg_uint32 @@ -381,8 +380,7 @@ hal_ctrlc_isr(CYG_ADDRWORD vector, CYG_A hal_virtual_comm_table_t* __chan = CYGACC_CALL_IF_DEBUG_PROCS(); int isr_ret, ctrlc = 0; - isr_ret = CYGACC_COMM_IF_DBG_ISR(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), - &ctrlc, vector, data); + isr_ret = CYGACC_COMM_IF_DBG_ISR(*__chan, &ctrlc, vector, data); if (ctrlc) cyg_hal_user_break( (CYG_ADDRWORD *)hal_saved_interrupt_state ); return isr_ret;
--- a/packages/hal/common/current/src/hal_misc.c +++ b/packages/hal/common/current/src/hal_misc.c @@ -97,7 +97,7 @@ cyg_hal_user_break( CYG_ADDRWORD *regs ) if( regs == NULL ) __pc = __ra; else __pc = sreg->pc; - CYGACC_CALL_IF_INSTALL_BPT_FN()((void *)__pc); + CYGACC_CALL_IF_INSTALL_BPT_FN((void *)__pc); CYGARC_HAL_GET_RETURN_ADDRESS_BACKUP(); @@ -133,9 +133,7 @@ hal_default_isr(CYG_ADDRWORD vector, CYG // interrupts. It is a bit messy, but required in a transition period. if (CYGNUM_CALL_IF_TABLE_VERSION == CYGACC_CALL_IF_VERSION()) { hal_virtual_comm_table_t* comm = CYGACC_CALL_IF_DEBUG_PROCS(); - gdb_vector - = CYGACC_COMM_IF_CONTROL(*comm)(CYGACC_COMM_IF_CH_DATA(*comm), - __COMMCTL_DBG_ISR_VECTOR); + gdb_vector = CYGACC_COMM_IF_CONTROL(*comm, __COMMCTL_DBG_ISR_VECTOR); } if( vector == gdb_vector ) #else
--- a/packages/hal/common/current/src/hal_stub.c +++ b/packages/hal/common/current/src/hal_stub.c @@ -109,7 +109,7 @@ putDebugChar (int c) { #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS(); - CYGACC_COMM_IF_PUTC(*__debug_procs)(CYGACC_COMM_IF_CH_DATA(*__debug_procs), c); + CYGACC_COMM_IF_PUTC(*__debug_procs, c); #elif defined(CYGPKG_CYGMON) ecos_bsp_console_putc(c); #else @@ -123,7 +123,7 @@ getDebugChar (void) { #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS(); - return CYGACC_COMM_IF_GETC(*__debug_procs)(CYGACC_COMM_IF_CH_DATA(*__debug_procs)); + return CYGACC_COMM_IF_GETC(*__debug_procs); #elif defined(CYGPKG_CYGMON) return ecos_bsp_console_getc(); #else @@ -137,7 +137,7 @@ void { #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS(); - CYGACC_COMM_IF_CONTROL(*__debug_procs)(CYGACC_COMM_IF_CH_DATA(*__debug_procs), __COMMCTL_SETBAUD, baud); + CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_SETBAUD, baud); #elif defined(CYGPKG_CYGMON) // FIXME! #else @@ -250,7 +250,7 @@ interruptible(int state) { hal_virtual_comm_table_t* __chan; __chan = CYGACC_CALL_IF_DEBUG_PROCS(); - CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), __COMMCTL_IRQ_ENABLE); + CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE); } #else if (__interruptible_control) @@ -264,7 +264,7 @@ interruptible(int state) { hal_virtual_comm_table_t* __chan; __chan = CYGACC_CALL_IF_DEBUG_PROCS(); - CYGACC_COMM_IF_CONTROL(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), __COMMCTL_IRQ_DISABLE); + CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE); } #else if (__interruptible_control) @@ -288,7 +288,7 @@ cyg_hal_gdb_diag_getc(void* __ch_data) hal_virtual_comm_table_t* __chan = CYGACC_CALL_IF_DEBUG_PROCS(); CYGARC_HAL_SAVE_GP(); - __ch = CYGACC_COMM_IF_GETC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan)); + __ch = CYGACC_COMM_IF_GETC(*__chan); CYGARC_HAL_RESTORE_GP(); @@ -329,24 +329,24 @@ cyg_hal_gdb_diag_putc(void* __ch_data, c cyg_uint8 csum = 0, c1; int i; - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), '$'); - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), 'O'); + CYGACC_COMM_IF_PUTC(*__chan, '$'); + CYGACC_COMM_IF_PUTC(*__chan, 'O'); csum += 'O'; for( i = 0; i < pos; i++ ) { char ch = line[i]; char h = hex[(ch>>4)&0xF]; char l = hex[ch&0xF]; - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), h); - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), l); + CYGACC_COMM_IF_PUTC(*__chan, h); + CYGACC_COMM_IF_PUTC(*__chan, l); csum += h; csum += l; } - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), '#'); - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), hex[(csum>>4)&0xF]); - CYGACC_COMM_IF_PUTC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan), hex[csum&0xF]); + CYGACC_COMM_IF_PUTC(*__chan, '#'); + CYGACC_COMM_IF_PUTC(*__chan, hex[(csum>>4)&0xF]); + CYGACC_COMM_IF_PUTC(*__chan, hex[csum&0xF]); - c1 = CYGACC_COMM_IF_GETC(*__chan)(CYGACC_COMM_IF_CH_DATA(*__chan)); + c1 = CYGACC_COMM_IF_GETC(*__chan); if( c1 == '+' ) break; if( cyg_hal_is_break( &c1 , 1 ) ) { @@ -508,10 +508,10 @@ initHardware (void) #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT { hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Initialize mangler procs - CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_MANGLER); + CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_MANGLER); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_gdb_diag_write); CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_gdb_diag_read); @@ -525,10 +525,10 @@ initHardware (void) // previous channel matches the used for GDB communication. if (CYGNUM_CALL_IF_SET_COMM_ID_EMPTY != cur && CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL != cur) - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); // Set the debug channel. - CYGACC_CALL_IF_SET_DEBUG_COMM()(CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL); + CYGACC_CALL_IF_SET_DEBUG_COMM(CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL); } #ifdef HAL_STUB_PLATFORM_INIT @@ -553,7 +553,7 @@ void { #if !defined(CYGPKG_CYGMON) #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT - __call_if_reset_t __rom_reset = CYGACC_CALL_IF_RESET(); + __call_if_reset_t __rom_reset = CYGACC_CALL_IF_RESET_GET(); if (__rom_reset) __rom_reset(); #else
--- a/packages/hal/powerpc/cogent/current/ChangeLog +++ b/packages/hal/powerpc/cogent/current/ChangeLog @@ -1,3 +1,11 @@ +2000-06-30 Jesper Skov <jskov@redhat.com> + + * src/plf_stub.c (hal_plf_stub_init): calling i/f macro + changes. Always write to LCD for ROM monitor configs. + + * src/hal_diag.c: Use per-channel struct instead of code + cruft. calling i/f macro changes. + 2000-06-28 Jesper Skov <jskov@redhat.com> * src/hal_diag.c: Cleanup.
--- a/packages/hal/powerpc/cogent/current/src/hal_diag.c +++ b/packages/hal/powerpc/cogent/current/src/hal_diag.c @@ -156,9 +156,19 @@ cyg_hal_plf_comms_init(void) #define SIO_FCR_FCR1 0x02 // clear RCVR FIFO #define SIO_FCR_FCR2 0x04 // clear XMIT FIFO + +//----------------------------------------------------------------------------- +typedef struct { + cyg_uint8* base; + cyg_int32 msec_timeout; + int isr_vector; +} channel_data_t; + +//----------------------------------------------------------------------------- static void -init_serial_channel( cyg_uint8* base ) +init_serial_channel(const channel_data_t* __ch_data) { + cyg_uint8* base = __ch_data->base; cyg_uint8 lcr; HAL_WRITE_UINT8(base+CYG_DEV_SERIAL_IER, 0); @@ -205,7 +215,7 @@ init_serial_channel( cyg_uint8* base ) static cyg_bool cyg_hal_plf_serial_getc_nonblock(void* __ch_data, cyg_uint8* ch) { - cyg_uint8* base = (cyg_uint8*)__ch_data; + cyg_uint8* base = ((channel_data_t*)__ch_data)->base; cyg_uint8 lsr; HAL_READ_UINT8(base+CYG_DEV_SERIAL_LSR, lsr); @@ -233,7 +243,7 @@ cyg_hal_plf_serial_getc(void* __ch_data) void cyg_hal_plf_serial_putc(void* __ch_data, cyg_uint8 c) { - cyg_uint8* base = (cyg_uint8*)__ch_data; + cyg_uint8* base = ((channel_data_t*)__ch_data)->base; cyg_uint8 lsr; CYGARC_HAL_SAVE_GP(); @@ -254,6 +264,11 @@ cyg_hal_plf_serial_putc(void* __ch_data, #if defined(CYGSEM_HAL_VIRTUAL_VECTOR_DIAG) \ || defined(CYGPRI_HAL_IMPLEMENTS_IF_SERVICES) +static const channel_data_t channels[2] = { + { (cyg_uint8*)CYG_DEV_SERIAL_BASE_A, 1000, CYGNUM_HAL_INTERRUPT_SIU_IRQ1}, + { (cyg_uint8*)CYG_DEV_SERIAL_BASE_B, 1000, CYGNUM_HAL_INTERRUPT_SIU_IRQ1} +}; + static void cyg_hal_plf_serial_write(void* __ch_data, const cyg_uint8* __buf, cyg_uint32 __len) @@ -277,23 +292,21 @@ cyg_hal_plf_serial_read(void* __ch_data, CYGARC_HAL_RESTORE_GP(); } -static cyg_int32 msec_timeout[2] = { 1000, 1000 }; - cyg_bool cyg_hal_plf_serial_getc_timeout(void* __ch_data, cyg_uint8* ch) { int delay_count; + channel_data_t* chan = (channel_data_t*)__ch_data; cyg_bool res; CYGARC_HAL_SAVE_GP(); - // delay in .1 ms steps - delay_count = msec_timeout[__ch_data == (void*)CYG_DEV_SERIAL_BASE_A ? 0 : 1] * 10; + delay_count = chan->msec_timeout * 10; // delay in .1 ms steps for(;;) { res = cyg_hal_plf_serial_getc_nonblock(__ch_data, ch); if (res || 0 == delay_count--) break; - CYGACC_CALL_IF_DELAY_US()(100); + CYGACC_CALL_IF_DELAY_US(100); } CYGARC_HAL_RESTORE_GP(); @@ -304,30 +317,30 @@ static int cyg_hal_plf_serial_control(void *__ch_data, __comm_control_cmd_t __func, ...) { static int irq_state = 0; - cyg_uint8* base = (cyg_uint8*)__ch_data; + channel_data_t* chan = (channel_data_t*)__ch_data; cyg_uint8 ier; int ret = 0; CYGARC_HAL_SAVE_GP(); switch (__func) { case __COMMCTL_IRQ_ENABLE: - HAL_INTERRUPT_UNMASK(CYGNUM_HAL_INTERRUPT_SIU_IRQ1); - HAL_INTERRUPT_SET_LEVEL(CYGNUM_HAL_INTERRUPT_SIU_IRQ1, 1); - HAL_READ_UINT8(base+CYG_DEV_SERIAL_IER, ier); + HAL_INTERRUPT_UNMASK(chan->isr_vector); + HAL_INTERRUPT_SET_LEVEL(chan->isr_vector, 1); + HAL_READ_UINT8(chan->base+CYG_DEV_SERIAL_IER, ier); ier |= SIO_IER_ERDAI; - HAL_WRITE_UINT8(base+CYG_DEV_SERIAL_IER, ier); + HAL_WRITE_UINT8(chan->base+CYG_DEV_SERIAL_IER, ier); irq_state = 1; break; case __COMMCTL_IRQ_DISABLE: ret = irq_state; irq_state = 0; - HAL_INTERRUPT_MASK(CYGNUM_HAL_INTERRUPT_SIU_IRQ1); - HAL_READ_UINT8(base+CYG_DEV_SERIAL_IER, ier); + HAL_INTERRUPT_MASK(chan->isr_vector); + HAL_READ_UINT8(chan->base+CYG_DEV_SERIAL_IER, ier); ier &= ~SIO_IER_ERDAI; - HAL_WRITE_UINT8(base+CYG_DEV_SERIAL_IER, ier); + HAL_WRITE_UINT8(chan->base+CYG_DEV_SERIAL_IER, ier); break; case __COMMCTL_DBG_ISR_VECTOR: - ret = CYGNUM_HAL_INTERRUPT_SIU_IRQ1; + ret = chan->isr_vector; break; case __COMMCTL_SET_TIMEOUT: { @@ -335,9 +348,8 @@ cyg_hal_plf_serial_control(void *__ch_da va_start(ap, __func); - ret = msec_timeout[__ch_data == (void*)CYG_DEV_SERIAL_BASE_A ? 0 : 1]; - msec_timeout[__ch_data == (void*)CYG_DEV_SERIAL_BASE_A ? 0 : 1] - = va_arg(ap, cyg_uint32); + ret = chan->msec_timeout; + chan->msec_timeout = va_arg(ap, cyg_uint32); va_end(ap); } @@ -352,28 +364,28 @@ static int cyg_hal_plf_serial_isr(void *__ch_data, int* __ctrlc, CYG_ADDRWORD __vector, CYG_ADDRWORD __data) { - cyg_uint8* base = (cyg_uint8*)__ch_data; + channel_data_t* chan = (channel_data_t*)__ch_data; cyg_uint8 _iir; int res = 0; CYGARC_HAL_SAVE_GP(); - HAL_READ_UINT8(base+CYG_DEV_SERIAL_IIR, _iir); + HAL_READ_UINT8(chan->base+CYG_DEV_SERIAL_IIR, _iir); _iir &= SIO_IIR_ID_MASK; *__ctrlc = 0; if ( ISR_Rx == _iir ) { cyg_uint8 c, lsr; - HAL_READ_UINT8(base+CYG_DEV_SERIAL_LSR, lsr); + HAL_READ_UINT8(chan->base+CYG_DEV_SERIAL_LSR, lsr); if (lsr & SIO_LSR_DR) { - HAL_READ_UINT8(base+CYG_DEV_SERIAL_RBR, c); + HAL_READ_UINT8(chan->base+CYG_DEV_SERIAL_RBR, c); if( cyg_hal_is_break( &c , 1 ) ) *__ctrlc = 1; } // Acknowledge the interrupt - HAL_INTERRUPT_ACKNOWLEDGE(CYGNUM_HAL_INTERRUPT_SIU_IRQ1); + HAL_INTERRUPT_ACKNOWLEDGE(chan->isr_vector); res = CYG_ISR_HANDLED; } @@ -385,21 +397,22 @@ static void cyg_hal_plf_serial_init(void) { hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Disable interrupts. - HAL_INTERRUPT_MASK(CYGNUM_HAL_INTERRUPT_SIU_IRQ1); + HAL_INTERRUPT_MASK(channels[0].isr_vector); + HAL_INTERRUPT_MASK(channels[1].isr_vector); // Init channels - init_serial_channel((cyg_uint8*)CYG_DEV_SERIAL_BASE_A); - init_serial_channel((cyg_uint8*)CYG_DEV_SERIAL_BASE_B); + init_serial_channel(&channels[0]); + init_serial_channel(&channels[1]); // Setup procs in the vector table // Set channel 0 - CYGACC_CALL_IF_SET_CONSOLE_COMM()(0); + CYGACC_CALL_IF_SET_CONSOLE_COMM(0); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); - CYGACC_COMM_IF_CH_DATA_SET(*comm, CYG_DEV_SERIAL_BASE_A); + CYGACC_COMM_IF_CH_DATA_SET(*comm, &channels[0]); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write); CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_serial_read); CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_serial_putc); @@ -409,9 +422,9 @@ cyg_hal_plf_serial_init(void) CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout); // Set channel 1 - CYGACC_CALL_IF_SET_CONSOLE_COMM()(1); + CYGACC_CALL_IF_SET_CONSOLE_COMM(1); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); - CYGACC_COMM_IF_CH_DATA_SET(*comm, CYG_DEV_SERIAL_BASE_B); + CYGACC_COMM_IF_CH_DATA_SET(*comm, &channels[1]); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write); CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_serial_read); CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_serial_putc); @@ -421,7 +434,7 @@ cyg_hal_plf_serial_init(void) CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES @@ -626,7 +639,7 @@ static void cyg_hal_plf_lcd_init(void) { hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Init channel init_lcd_channel((cyg_uint8*)LCD_BASE); @@ -634,7 +647,7 @@ cyg_hal_plf_lcd_init(void) // Setup procs in the vector table // Set channel 2 - CYGACC_CALL_IF_SET_CONSOLE_COMM()(2); + CYGACC_CALL_IF_SET_CONSOLE_COMM(2); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_CH_DATA_SET(*comm, LCD_BASE); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_lcd_write); @@ -644,7 +657,7 @@ cyg_hal_plf_lcd_init(void) CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_plf_lcd_control); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES @@ -673,21 +686,23 @@ cyg_hal_plf_lcd_init(void) # error "Cannot use LCD" #endif +static channel_data_t channel = { __BASE, 0, 0}; + #ifdef HAL_DIAG_USES_HARDWARE void hal_diag_init(void) { - init_serial_channel(__BASE); + init_serial_channel(&channel); } void hal_diag_write_char(char __c) { - cyg_hal_plf_serial_putc(__BASE, __c); + cyg_hal_plf_serial_putc(&channel, __c); } void hal_diag_read_char(char *c) { - *c = cyg_hal_plf_serial_getc(__BASE); + *c = cyg_hal_plf_serial_getc(&channel); } #else // ifdef HAL_DIAG_USES_HARDWARE @@ -697,7 +712,7 @@ void hal_diag_init(void) { // Init devices - init_serial_channel(__BASE); + init_serial_channel(&channel); } void @@ -705,14 +720,14 @@ hal_diag_write_char_serial( char c ) { unsigned long __state; HAL_DISABLE_INTERRUPTS(__state); - cyg_hal_plf_serial_putc(__BASE, c); + cyg_hal_plf_serial_putc(&channel, c); HAL_RESTORE_INTERRUPTS(__state); } void hal_diag_read_char(char *c) { - *c = cyg_hal_plf_serial_getc(__BASE); + *c = cyg_hal_plf_serial_getc(&channel); } void @@ -798,8 +813,6 @@ hal_diag_write_char(char c) #endif // ifdef HAL_DIAG_USES_HARDWARE -#undef __BASE - #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG //-----------------------------------------------------------------------------
--- a/packages/hal/powerpc/cogent/current/src/plf_stub.c +++ b/packages/hal/powerpc/cogent/current/src/plf_stub.c @@ -51,18 +51,18 @@ void hal_plf_stub_init(void) { -#if defined(CYGSEM_HAL_ROM_MONITOR) && defined(CYGSEM_HAL_VIRTUAL_VECTOR) +#if defined(CYGSEM_HAL_ROM_MONITOR) // Put stub build date on the LCD. hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); - CYGACC_CALL_IF_SET_CONSOLE_COMM()(2); + CYGACC_CALL_IF_SET_CONSOLE_COMM(2); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); - CYGACC_COMM_IF_WRITE(*comm)(CYGACC_COMM_IF_CH_DATA(*comm), L1, strlen(L1)); - CYGACC_COMM_IF_WRITE(*comm)(CYGACC_COMM_IF_CH_DATA(*comm), L2, strlen(L2)); + CYGACC_COMM_IF_WRITE(*comm, L1, strlen(L1)); + CYGACC_COMM_IF_WRITE(*comm, L2, strlen(L2)); - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); #endif }
--- a/packages/hal/powerpc/quicc/current/ChangeLog +++ b/packages/hal/powerpc/quicc/current/ChangeLog @@ -1,3 +1,7 @@ +2000-06-30 Jesper Skov <jskov@redhat.com> + + * src/quicc_smc1.c: calling i/f macro changes. + 2000-06-28 Jesper Skov <jskov@redhat.com> * include/quicc_smc1.h:
--- a/packages/hal/powerpc/quicc/current/src/quicc_smc1.c +++ b/packages/hal/powerpc/quicc/current/src/quicc_smc1.c @@ -366,7 +366,7 @@ cyg_hal_plf_serial_getc_timeout(void* __ if (res || 0 == delay_count--) break; - CYGACC_CALL_IF_DELAY_US()(100); + CYGACC_CALL_IF_DELAY_US(100); } CYGARC_HAL_RESTORE_GP(); @@ -458,7 +458,7 @@ void cyg_hal_plf_serial_init(void) { hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); volatile EPPC *eppc = eppc_base(); int i; @@ -477,7 +477,7 @@ cyg_hal_plf_serial_init(void) // Setup procs in the vector table // Set channel 0 - CYGACC_CALL_IF_SET_CONSOLE_COMM()(0);// Should be configurable! + CYGACC_CALL_IF_SET_CONSOLE_COMM(0);// Should be configurable! comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_CH_DATA_SET(*comm, eppc_base()); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write); @@ -489,7 +489,7 @@ cyg_hal_plf_serial_init(void) CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES
--- a/packages/hal/sh/arch/current/ChangeLog +++ b/packages/hal/sh/arch/current/ChangeLog @@ -1,3 +1,14 @@ +2000-06-30 Jesper Skov <jskov@redhat.com> + + * src/vectors.S (__reset): Jump to VMA for RAM startup. + (_complete_setup): Fix merge bug. + + * src/sh3_scif.c: + * src/sh3_sci.c: + calling i/f macro changes. + + * src/vectors.S (__reset): Fix alignment problem. + 2000-06-29 Gary Thomas <gthomas@redhat.com> * src/vectors.S: Reorg initialization (reset) code to be all
--- a/packages/hal/sh/arch/current/src/sh3_sci.c +++ b/packages/hal/sh/arch/current/src/sh3_sci.c @@ -176,7 +176,7 @@ cyg_hal_plf_sci_getc_timeout(void* __ch_ if (res || 0 == delay_count--) break; - CYGACC_CALL_IF_DELAY_US()(100); + CYGACC_CALL_IF_DELAY_US(100); } CYGARC_HAL_RESTORE_GP(); @@ -263,7 +263,7 @@ cyg_hal_plf_sci_init(int sci_index, int { channel_data_t* chan = &channels[sci_index]; hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Initialize channel table chan->base = base; @@ -280,7 +280,7 @@ cyg_hal_plf_sci_init(int sci_index, int // Setup procs in the vector table // Initialize channel procs - CYGACC_CALL_IF_SET_CONSOLE_COMM()(comm_index); + CYGACC_CALL_IF_SET_CONSOLE_COMM(comm_index); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_CH_DATA_SET(*comm, chan); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_sci_write); @@ -292,7 +292,7 @@ cyg_hal_plf_sci_init(int sci_index, int CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_sci_getc_timeout); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES
--- a/packages/hal/sh/arch/current/src/sh3_scif.c +++ b/packages/hal/sh/arch/current/src/sh3_scif.c @@ -209,7 +209,7 @@ cyg_hal_plf_scif_getc_timeout(void* __ch if (res || 0 == delay_count--) break; - CYGACC_CALL_IF_DELAY_US()(100); + CYGACC_CALL_IF_DELAY_US(100); } CYGARC_HAL_RESTORE_GP(); @@ -298,7 +298,7 @@ cyg_hal_plf_scif_init(int scif_index, in { channel_data_t* chan = &channels[scif_index]; hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Initialize channel table chan->base = base; @@ -314,7 +314,7 @@ cyg_hal_plf_scif_init(int scif_index, in // Setup procs in the vector table // Initialize channel procs - CYGACC_CALL_IF_SET_CONSOLE_COMM()(comm_index); + CYGACC_CALL_IF_SET_CONSOLE_COMM(comm_index); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_CH_DATA_SET(*comm, chan); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_scif_write); @@ -326,7 +326,7 @@ cyg_hal_plf_scif_init(int scif_index, in CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_scif_getc_timeout); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } #endif // CYGSEM_HAL_VIRTUAL_VECTOR_DIAG || CYGPRI_HAL_IMPLEMENTS_IF_SERVICES
--- a/packages/hal/sh/arch/current/src/vectors.S +++ b/packages/hal/sh/arch/current/src/vectors.S @@ -106,8 +106,13 @@ # Note: this is the unmapped, shadow address of the start of code # Sadly, it is too far to just branch to. + .align 2 $__reset_platform: +#ifdef CYG_HAL_STARTUP_RAM + .long __reset_platform +#else .long __reset_platform-__reset+0xA0000000 +#endif #--------------------------------------------------------------------------- # Exception entry @@ -885,6 +890,12 @@ 2: jsr @r1 nop #endif +#if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT) \ + || defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT) + mov.l $_hal_ctrlc_isr_init,r1 + jsr @r1 + nop +#endif mov.l $_cyg_start,r1 jsr @r1 @@ -924,7 +935,12 @@ 9: $_initialize_stub: .long _initialize_stub #endif - +#if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT) \ + || defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT) + .extern _hal_ctrlc_isr_init +$_hal_ctrlc_isr_init: + .long _hal_ctrlc_isr_init +#endif #--------------------------------------------------------------------------- # Cache operations
--- a/packages/hal/v85x/ceb_v850/current/ChangeLog +++ b/packages/hal/v85x/ceb_v850/current/ChangeLog @@ -1,3 +1,7 @@ +2000-06-30 Jesper Skov <jskov@redhat.com> + + * src/hal_diag.c: calling i/f macro changes. + 2000-06-27 Jesper Skov <jskov@redhat.com> * src/plf_misc.c: Fix compiler warnings.
--- a/packages/hal/v85x/ceb_v850/current/src/hal_diag.c +++ b/packages/hal/v85x/ceb_v850/current/src/hal_diag.c @@ -182,7 +182,7 @@ cyg_hal_plf_serial_getc_timeout(void* __ if (res || 0 == delay_count--) break; - CYGACC_CALL_IF_DELAY_US()(100); + CYGACC_CALL_IF_DELAY_US(100); } CYGARC_HAL_RESTORE_GP(); @@ -253,7 +253,7 @@ static void cyg_hal_plf_serial_init(void) { hal_virtual_comm_table_t* comm; - int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM()(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); + int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT); // Disable interrupts. HAL_INTERRUPT_MASK(CYGNUM_HAL_VECTOR_INTCSI1); @@ -264,7 +264,7 @@ cyg_hal_plf_serial_init(void) // Setup procs in the vector table // Set channel 0 - CYGACC_CALL_IF_SET_CONSOLE_COMM()(0); + CYGACC_CALL_IF_SET_CONSOLE_COMM(0); comm = CYGACC_CALL_IF_CONSOLE_PROCS(); CYGACC_COMM_IF_CH_DATA_SET(*comm, 0); CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_serial_write); @@ -276,7 +276,7 @@ cyg_hal_plf_serial_init(void) CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout); // Restore original console - CYGACC_CALL_IF_SET_CONSOLE_COMM()(cur); + CYGACC_CALL_IF_SET_CONSOLE_COMM(cur); } void
--- a/packages/io/serial/current/ChangeLog +++ b/packages/io/serial/current/ChangeLog @@ -1,3 +1,7 @@ +2000-07-03 Jesper Skov <jskov@redhat.com> + + * src/common/serial.c (serial_data_rcv_req): Fix off-by-1 bug. + 2000-06-23 Jesper Skov <jskov@redhat.com> * tests/ser_test_protocol.inl: Added cq7708 definitions.
--- a/packages/io/serial/current/src/common/serial.c +++ b/packages/io/serial/current/src/common/serial.c @@ -538,7 +538,14 @@ serial_data_rcv_req(serial_channel *chan gap = cbuf->get - cbuf->put - 1; if (gap < 0) { // If failed, the gap is between put and the end of buffer - gap = cbuf->len - cbuf->put - 1; + gap = cbuf->len - cbuf->put; + + // If get is at the beginning of the buffer, we cannot + // fill the last character, since that would make put==get + // implying empty. In this case we must offer last chunk-1 only. + // GxxxxxP....... + if (cbuf->get == 0) + gap--; } }