自学教程：C++ CYGACC_CALL_IF_SET_CONSOLE_COMM函数代码示例

/* Early initialization of comm channels. */voidcyg_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 chan = 0;    struct port_info *port;    static int init = 0;    if (init) return;    init++;    // Setup procs in the vector table        for (port = ports, chan = 0;  chan < NUM(ports);  chan++, port++) {                CYGACC_CALL_IF_SET_CONSOLE_COMM(chan);        comm = CYGACC_CALL_IF_CONSOLE_PROCS();        CYGACC_COMM_IF_CH_DATA_SET(*comm, port);        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_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_serial_getc_timeout);        if (port->is_smc) {            cyg_hal_plf_smcx_init_channel(port, port->cpm_page);            CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_smcx_isr);        } else {            cyg_hal_plf_sccx_init_channel(port, port->cpm_page);            CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_sccx_isr);        }    }    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

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                       iChannels = sizeof(s_atSerialChannels) / sizeof(s_atSerialChannels[0]);  int                       iIdx;  for(iIdx = 0; iIdx < iChannels; iIdx++)  {    // Disable interrupts.    HAL_INTERRUPT_MASK(s_atSerialChannels[iIdx].isr_vector);    // Init channels    cyg_hal_plf_serial_init_channel(&s_atSerialChannels[iIdx]);    // Setup procs in the vector table    CYGACC_CALL_IF_SET_CONSOLE_COMM(iIdx);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    CYGACC_COMM_IF_CH_DATA_SET(*comm, &s_atSerialChannels[iIdx]);    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);}

static voidcyg_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_screen_init(void){    hal_virtual_comm_table_t* comm;    int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    // Disable interrupts.    HAL_INTERRUPT_MASK(pc_ser_channels[PCMB_PORT_INDEX].isr_vector);    // Init channels    cyg_hal_plf_screen_init_channel(&pc_ser_channels[PCMB_PORT_INDEX]);    // Setup procs in the vector table    // Set channel 2    CYGACC_CALL_IF_SET_CONSOLE_COMM(PCMB_PORT_INDEX);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    CYGACC_COMM_IF_CH_DATA_SET(*comm, &pc_ser_channels[PCMB_PORT_INDEX]);    CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_plf_screen_write);    CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_screen_read);    CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_screen_putc);    CYGACC_COMM_IF_GETC_SET(*comm, cyg_hal_plf_screen_getc);    CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_plf_screen_control);    CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_screen_isr);    CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_screen_getc_timeout);    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

voidhal_if_diag_init(void){    // This function may be called from various places and the code    // should only run once.    static cyg_uint8 called = 0;    if (called) return;    called = 1;#ifndef CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE#if defined(CYGDBG_HAL_DIAG_TO_DEBUG_CHAN)    // Use the mangler channel, which in turn uses the debug channel.    CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_MANGLER);    // Initialize the mangler channel.#if defined(CYGSEM_HAL_DIAG_MANGLER_GDB)    cyg_hal_diag_mangler_gdb_init();#elif defined(CYGSEM_HAL_DIAG_MANGLER_None)    cyg_hal_diag_mangler_null_init();#endif#else // CYGDBG_HAL_DIAG_TO_DEBUG_CHAN    // Use an actual (raw) IO channel    CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL);#endif // CYGDBG_HAL_DIAG_TO_DEBUG_CHAN#endif // CYGSEM_HAL_VIRTUAL_VECTOR_INHERIT_CONSOLE}

static void CYGOPT_HAL_KINETIS_DIAG_FLASH_SECTION_ATTRcyg_hal_plf_serial_init(void){    hal_virtual_comm_table_t* comm;    int cur;    int chan_i;    cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    // Init channels    for(chan_i=0; chan_i<CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS; chan_i++) {        cyg_hal_plf_serial_init_channel(&plf_ser_channels[chan_i]);        // Setup procs in the vector table        CYGACC_CALL_IF_SET_CONSOLE_COMM(chan_i);        comm = CYGACC_CALL_IF_CONSOLE_PROCS();        CYGACC_COMM_IF_CH_DATA_SET(*comm, &plf_ser_channels[chan_i]);        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);#if (CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD != CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_BAUD)    plf_ser_channels[CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL]->baud_rate =        CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_BAUD;    update_baud_rate( &plf_ser_channels[CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL] );#endif}

voidcyg_hal_am33_serial_init(int first_chan){    hal_virtual_comm_table_t* comm;    int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    int i;    for (i = 0; i < AM33_NUM_UARTS; i++) {	// Disable interrupts.	HAL_INTERRUPT_MASK(channels[0].isr_vector);	// Init channel	cyg_hal_plf_serial_init_channel((void*)&channels[i]);	cyg_hal_plf_serial_set_baud(channels[i].base, CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD);	// Setup procs in the vector table	CYGACC_CALL_IF_SET_CONSOLE_COMM(i + first_chan);	comm = CYGACC_CALL_IF_CONSOLE_PROCS();	CYGACC_COMM_IF_CH_DATA_SET(*comm, &channels[i]);	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);}

voidcyg_hal_ixp425_serial_init(void){    hal_virtual_comm_table_t* comm;    int i, cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    for (i = 0; i < IXP425_NUM_UARTS; i++) {	// Disable interrupts.	HAL_INTERRUPT_MASK(plf_ser_channels[i].isr_vector);	// Init channels	cyg_hal_plf_serial_init_channel(&plf_ser_channels[i]);	// Setup procs in the vector table	CYGACC_CALL_IF_SET_CONSOLE_COMM(i);	comm = CYGACC_CALL_IF_CONSOLE_PROCS();	CYGACC_COMM_IF_CH_DATA_SET(*comm, &plf_ser_channels[i]);	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);}

static voidcyg_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 i;    // Init channels#define NUMOF(x) (sizeof(x)/sizeof(x[0]))    for (i = 0;  i < NUMOF(ser_channels);  i++) {        init_channel(&ser_channels[i]);        CYGACC_CALL_IF_SET_CONSOLE_COMM(i);        comm = CYGACC_CALL_IF_CONSOLE_PROCS();        CYGACC_COMM_IF_CH_DATA_SET(*comm, &ser_channels[i]);        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);}

voidmon_set_read_char_timeout(int ms){    hal_virtual_comm_table_t *__chan;#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    if (!console_selected) {        int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);        int i;        // Set timeout to minimum on each channel; total amounts to desired value        _mon_timeout = ms;        ms = 1;        for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {            CYGACC_CALL_IF_SET_CONSOLE_COMM(i);            if ((__chan = CYGACC_CALL_IF_CONSOLE_PROCS()) != 0) {                CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);            }        }        CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);            } else #endif    {        if ((__chan = CYGACC_CALL_IF_CONSOLE_PROCS()) != 0) {            CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);        }        if ((__chan = CYGACC_CALL_IF_DEBUG_PROCS()) != 0) {            CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_SET_TIMEOUT, ms);        }    }}

static voidcyg_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);    // Init channels    cyg_hal_plf_serial_init_channel(&aaed2000_ser_channels[0]);    // 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, &aaed2000_ser_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);    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);}

static voidcyg_hal_plf_serial_init(void){    hal_virtual_comm_table_t* comm;    int i, cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);#define NUM_CHANNELS CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS    for (i = 0; i < NUM_CHANNELS; i++) {	// Disable interrupts.	HAL_INTERRUPT_MASK(channels[i].isr_vector);	// Init channels	cyg_hal_plf_serial_init_channel((void*)&channels[i]);	// Setup procs in the vector table	// Set COMM callbacks for channel	CYGACC_CALL_IF_SET_CONSOLE_COMM(i);	comm = CYGACC_CALL_IF_CONSOLE_PROCS();	CYGACC_COMM_IF_CH_DATA_SET(*comm, &channels[i]);	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);}

static voidcyg_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);    // Disable interrupts.    HAL_INTERRUPT_MASK(CYGNUM_HAL_VECTOR_INTCSI1);    // Init channels    init_serial_channel((cyg_uint8*)0);    // 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, 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);    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);}

intset_console_baud_rate(int rate){    int ret = -1;#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    if (!console_selected) {        int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);        int i;        // Set baud for all channels        for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {            CYGACC_CALL_IF_SET_CONSOLE_COMM(i);	    ret = set_comm_baud_rate(CYGACC_CALL_IF_CONSOLE_PROCS(), rate);	    if (ret < 0)		break;        }        CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);    } else#endif    ret = set_comm_baud_rate(CYGACC_CALL_IF_CONSOLE_PROCS(), rate);    if (ret < 0)	diag_printf("Setting console baud rate to %d failed/n", rate);    return ret;}

void mon_write_char(unsigned char c){    hal_virtual_comm_table_t *__chan;#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    if (!console_selected) {        int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);        int i;        // Send output to all channels        for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++) {            CYGACC_CALL_IF_SET_CONSOLE_COMM(i);            __chan = CYGACC_CALL_IF_CONSOLE_PROCS();            CYGACC_COMM_IF_PUTC(*__chan, c);        }        CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);    } else #endif    {        __chan = CYGACC_CALL_IF_CONSOLE_PROCS();        if (__chan)            CYGACC_COMM_IF_PUTC(*__chan, c);        else {            __chan = CYGACC_CALL_IF_DEBUG_PROCS();            CYGACC_COMM_IF_PUTC(*__chan, c);        }    }}

static voidnet_io_assume_console(void){#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    console_selected = true;#endif    console_echo = false;    orig_console = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    CYGACC_CALL_IF_SET_CONSOLE_COMM(TCP_CHANNEL);    orig_debug = CYGACC_CALL_IF_SET_DEBUG_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    CYGACC_CALL_IF_SET_DEBUG_COMM(TCP_CHANNEL);}

boolmon_read_char_with_timeout(unsigned char *c){    bool res = false;    hal_virtual_comm_table_t *__chan;#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    if (!console_selected) {        int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);        int i, j, tot;        // Try input from all channels        tot = 0;        while (tot < _mon_timeout) {            for (i = 0;  i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  i++, tot++) {                CYGACC_CALL_IF_SET_CONSOLE_COMM(i);                __chan = CYGACC_CALL_IF_CONSOLE_PROCS();                res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);                if (res) {                    // Input available on this channel, make it be the console                    if (*c != '/0') {                        // Don't chose this unless real data have arrived                        console_selected = true;                        CYGACC_CALL_IF_SET_DEBUG_COMM(i);                        // Disable interrupts on all channels but this one                        for (j = 0;  j < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS;  j++) {                            if (i != j) {                                CYGACC_CALL_IF_SET_CONSOLE_COMM(j);                                __chan = CYGACC_CALL_IF_CONSOLE_PROCS();                                CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE);                            }                        }                        CYGACC_CALL_IF_SET_CONSOLE_COMM(i);                        return res;                    }                }            }        }        CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);            } else #endif    {        __chan = CYGACC_CALL_IF_CONSOLE_PROCS();        if (__chan)            res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);        else {            __chan = CYGACC_CALL_IF_DEBUG_PROCS();            res = CYGACC_COMM_IF_GETC_TIMEOUT(*__chan, c);        }    }    return res;}

static voidcyg_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);	// CYGACC_CALL_VV1(__call_if_set_console_comm_t*, CYGNUM_CALL_IF_SET_CONSOLE_COMM, -1)	//__call_VV1(CYGNUM_CALL_IF_SET_CONSOLE_COMM, __call_if_set_console_comm_t, int, int)    // Disable interrupts.    HAL_INTERRUPT_MASK(smdk_ser_channels[0].isr_vector);    HAL_INTERRUPT_MASK(smdk_ser_channels[1].isr_vector);    //Unmask UART0/1 RX interrupt    HAL_WRITE_UINT32(INTSUBMSK, __READ_UINT32(INTSUBMSK) & ~(BIT_SUB_RXD0|BIT_SUB_RXD1));    // Init channels    cyg_hal_plf_serial_init_channel(&smdk_ser_channels[0]);    cyg_hal_plf_serial_init_channel(&smdk_ser_channels[1]);    // 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, &smdk_ser_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);    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);    // Set channel 1    CYGACC_CALL_IF_SET_CONSOLE_COMM(1);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    CYGACC_COMM_IF_CH_DATA_SET(*comm, &smdk_ser_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);    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);}

/* * Note: this debug setup only works if the target platform has two serial ports * available so that the other one (currently only port 1) can be used for debug * messages. */static intzm_dprintf(char *fmt, ...){    int cur_console;    va_list args;    va_start(args, fmt);#ifdef REDBOOT    cur_console = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    CYGACC_CALL_IF_SET_CONSOLE_COMM(1);#endif    diag_vprintf(fmt, args);#ifdef REDBOOT    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur_console);#endif}

static voidcyg_hal_plf_serial_init(void){    hal_virtual_comm_table_t* comm;    int cur;    cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);#if 0 /* No interrupts yet */    // Disable interrupts.    HAL_INTERRUPT_MASK(channels[0].isr_vector);#endif    // Init channels    cyg_hal_plf_serial_init_channel((void*)&channels[0]);    // 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, &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);    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);#ifdef NOTANYMORE    // Set channel 1    CYGACC_CALL_IF_SET_CONSOLE_COMM(1);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    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);    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);#endif    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

//===========================================================================// Initialize serial channel//===========================================================================void cyg_hal_plf_serial_init(void){    hal_virtual_comm_table_t* comm;    int cur;    cur =        CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    // Init channels    cyg_hal_plf_serial_init_channel(&lpc2xxx_ser_channels[0]);#if CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS > 1    cyg_hal_plf_serial_init_channel(&lpc2xxx_ser_channels[1]);#endif    // 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, &lpc2xxx_ser_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);    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);#if CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS > 1    // Set channel 1    CYGACC_CALL_IF_SET_CONSOLE_COMM(1);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    CYGACC_COMM_IF_CH_DATA_SET(*comm, &lpc2xxx_ser_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);    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);#endif    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

// This is the COMMS init function. It gets called both by the stubs// and diag init code to initialize the COMMS mangler channel table -// that's all. The callers have to decide whether to actually use this// channel.voidcyg_hal_diag_mangler_null_init(void){    hal_virtual_comm_table_t* comm;    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);    comm = CYGACC_CALL_IF_CONSOLE_PROCS();    CYGACC_COMM_IF_WRITE_SET(*comm, cyg_hal_diag_mangler_null_write);    CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_diag_mangler_null_read);    CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_diag_mangler_null_putc);    CYGACC_COMM_IF_GETC_SET(*comm, cyg_hal_diag_mangler_null_getc);    CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_diag_mangler_null_control);        // Restore the original console channel.    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

static voidnet_io_revert_console(void){#ifdef CYGPKG_REDBOOT_ANY_CONSOLE    console_selected = false;#endif    CYGACC_CALL_IF_SET_CONSOLE_COMM(orig_console);    CYGACC_CALL_IF_SET_DEBUG_COMM(orig_debug);    console_echo = true;}

int start_console(void){    int cur_console =        CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);#ifdef CYGSEM_REDBOOT_FLASH_CONFIG    int i = 0;    if ( flash_get_config( "info_console_force", &i, CONFIG_BOOL) )        if ( i )            if ( ! flash_get_config( "info_console_number", &i, CONFIG_INT) )                i = 0; // the default, if that call failed.    if ( i )        CYGACC_CALL_IF_SET_CONSOLE_COMM(i);    else#endif        CYGACC_CALL_IF_SET_CONSOLE_COMM(0);    return cur_console;}

voidcyg_hal_plf_scif_init(int scif_index, int comm_index,                       int rcv_vect, cyg_uint8* base, bool irda_mode){    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);    // Initialize channel table    chan->base = base;    chan->isr_vector = rcv_vect;    chan->msec_timeout = 1000;    chan->irda_mode = irda_mode;#ifdef CYGHWR_HAL_SH_SH2_SCIF_ASYNC_RXTX    chan->async_rxtx_mode = false;#endif    // Disable interrupts.    HAL_INTERRUPT_MASK(chan->isr_vector);    // Init channel    cyg_hal_plf_scif_init_channel(chan);    // Setup procs in the vector table    // Initialize channel procs    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);    CYGACC_COMM_IF_READ_SET(*comm, cyg_hal_plf_scif_read);    CYGACC_COMM_IF_PUTC_SET(*comm, cyg_hal_plf_scif_putc);    CYGACC_COMM_IF_GETC_SET(*comm, cyg_hal_plf_scif_getc);    CYGACC_COMM_IF_CONTROL_SET(*comm, cyg_hal_plf_scif_control);    CYGACC_COMM_IF_DBG_ISR_SET(*comm, cyg_hal_plf_scif_isr);    CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, cyg_hal_plf_scif_getc_timeout);    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);}

static voiddo_channel(int argc, char *argv[]){    int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    if (argc == 2) { #ifdef CYGPKG_REDBOOT_ANY_CONSOLE        if (strcmp( argv[1], "-1") == 0) {            console_selected = false;            console_echo = true;        } else #endif        {            unsigned long chan;            if ( !parse_num( argv[1], &chan, NULL, NULL) ) {                diag_printf("** Error: invalid channel '%s'/n", argv[1]);            } else {                if (chan < CYGNUM_HAL_VIRTUAL_VECTOR_NUM_CHANNELS) {                    CYGACC_CALL_IF_SET_CONSOLE_COMM(chan);                    CYGACC_CALL_IF_SET_DEBUG_COMM(chan);                    if (chan != cur)                        console_echo = true;                }                else {                    diag_printf("**Error: bad channel number '%s'/n", argv[1]);                }            }        }    }    /* else display */     else {        diag_printf("Current console channel id: ");#ifdef CYGPKG_REDBOOT_ANY_CONSOLE        if (!console_selected)            diag_printf("-1/n");        else#endif            diag_printf("%d/n", cur);    }}

static voidhal_a2fxxx_serial_init(void){    hal_virtual_comm_table_t* comm;    int cur;    int i;    cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);    for( i = 0; i < CYGNUM_HAL_VIRTUAL_VECTOR_COMM_CHANNELS ; i++ )    {        hal_a2fxxx_serial_init_channel(&a2fxxx_ser_channels[i]);        CYGACC_CALL_IF_SET_CONSOLE_COMM(i);        comm = CYGACC_CALL_IF_CONSOLE_PROCS();        CYGACC_COMM_IF_CH_DATA_SET(*comm, &a2fxxx_ser_channels[i]);        CYGACC_COMM_IF_WRITE_SET(*comm, hal_a2fxxx_serial_write);        CYGACC_COMM_IF_READ_SET(*comm, hal_a2fxxx_serial_read);        CYGACC_COMM_IF_PUTC_SET(*comm, hal_a2fxxx_serial_putc);        CYGACC_COMM_IF_GETC_SET(*comm, hal_a2fxxx_serial_getc);        CYGACC_COMM_IF_CONTROL_SET(*comm, hal_a2fxxx_serial_control);        CYGACC_COMM_IF_DBG_ISR_SET(*comm, hal_a2fxxx_serial_isr);        CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, hal_a2fxxx_serial_getc_timeout);    }    // Restore original console    CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);    // set debug channel baud rate if different#if (CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD != CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_BAUD)    a2fxxx_ser_channels[CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL]->baud_rate =        CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL_BAUD;    update_baud_rate( &a2fxxx_ser_channels[CYGNUM_HAL_VIRTUAL_VECTOR_DEBUG_CHANNEL] );#endif}

static voidnet_io_init(void){    static int init = 0;    if (!init) {        hal_virtual_comm_table_t* comm;        int cur = CYGACC_CALL_IF_SET_CONSOLE_COMM(CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);        // Setup procs in the vector table        CYGACC_CALL_IF_SET_CONSOLE_COMM(TCP_CHANNEL);        comm = CYGACC_CALL_IF_CONSOLE_PROCS();        //CYGACC_COMM_IF_CH_DATA_SET(*comm, chan);        CYGACC_COMM_IF_WRITE_SET(*comm, net_io_write);        CYGACC_COMM_IF_READ_SET(*comm, net_io_read);        CYGACC_COMM_IF_PUTC_SET(*comm, net_io_putc);        CYGACC_COMM_IF_GETC_SET(*comm, net_io_getc);        CYGACC_COMM_IF_CONTROL_SET(*comm, net_io_control);        CYGACC_COMM_IF_DBG_ISR_SET(*comm, net_io_isr);        CYGACC_COMM_IF_GETC_TIMEOUT_SET(*comm, net_io_getc_timeout);        // Disable interrupts via this interface to set static        // state into correct state.        net_io_control( comm, __COMMCTL_IRQ_DISABLE );                // Restore original console        CYGACC_CALL_IF_SET_CONSOLE_COMM(cur);        init = 1;        gdb_active = false;    }    __tcp_listen(&tcp_sock, gdb_port);    state = tcp_sock.state; #ifdef DEBUG_TCP    diag_printf("show tcp = %p/n", (void *)&show_tcp);#endif}

intxyzModem_stream_open (connection_info_t * info, int *err){#ifdef REDBOOT  int console_chan;#endif  int stat = 0;  int retries = xyzModem_MAX_RETRIES;  int crc_retries = xyzModem_MAX_RETRIES_WITH_CRC;/*    ZM_DEBUG(zm_out = zm_out_start); */#ifdef xyzModem_zmodem  if (info->mode == xyzModem_zmodem)    {      *err = xyzModem_noZmodem;      return -1;    }#endif#ifdef REDBOOT  /* Set up the I/O channel.  Note: this allows for using a different port in the future */  console_chan =    CYGACC_CALL_IF_SET_CONSOLE_COMM    (CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT);  if (info->chan >= 0)    {      CYGACC_CALL_IF_SET_CONSOLE_COMM (info->chan);    }  else    {      CYGACC_CALL_IF_SET_CONSOLE_COMM (console_chan);    }  xyz.__chan = CYGACC_CALL_IF_CONSOLE_PROCS ();  CYGACC_CALL_IF_SET_CONSOLE_COMM (console_chan);  CYGACC_COMM_IF_CONTROL (*xyz.__chan, __COMMCTL_SET_TIMEOUT,			  xyzModem_CHAR_TIMEOUT);#else/* TODO: CHECK ! */  int dummy;  xyz.__chan = &dummy;#endif  xyz.len = 0;  xyz.crc_mode = true;  xyz.at_eof = false;  xyz.tx_ack = false;  xyz.mode = info->mode;  xyz.total_retries = 0;  xyz.total_SOH = 0;  xyz.total_STX = 0;  xyz.total_CAN = 0;#ifdef USE_YMODEM_LENGTH  xyz.read_length = 0;  xyz.file_length = 0;#endif  CYGACC_COMM_IF_PUTC (*xyz.__chan, (xyz.crc_mode ? 'C' : NAK));  if (xyz.mode == xyzModem_xmodem)    {      /* X-modem doesn't have an information header - exit here */      xyz.next_blk = 1;      return 0;    }  while (retries-- > 0)    {      stat = xyzModem_get_hdr ();      if (stat == 0)	{	  /* Y-modem file information header */	  if (xyz.blk == 0)	    {#ifdef USE_YMODEM_LENGTH	      /* skip filename */	      while (*xyz.bufp++);	      /* get the length */	      parse_num ((char *) xyz.bufp, &xyz.file_length, NULL, " ");#endif	      /* The rest of the file name data block quietly discarded */	      xyz.tx_ack = true;	    }	  xyz.next_blk = 1;	  xyz.len = 0;	  return 0;	}      else if (stat == xyzModem_timeout)	{	  if (--crc_retries <= 0)	    xyz.crc_mode = false;	  CYGACC_CALL_IF_DELAY_US (5 * 100000);	/* Extra delay for startup */	  CYGACC_COMM_IF_PUTC (*xyz.__chan, (xyz.crc_mode ? 'C' : NAK));	  xyz.total_retries++;	  ZM_DEBUG (zm_dprintf ("NAK (%d)/n", __LINE__));	}      if (stat == xyzModem_cancel)	{	  break;	}    }//.........这里部分代码省略.........