static void
test_channel(const char *dev, cyg_io_handle_t channel)
{
Cyg_ErrNo res;
cyg_uint32 cfg_data;
cyg_uint32 len;
cyg_adc_sample_t sample;
int count;
diag_printf("\nTesting ADC channel '%s'\n", dev);
// Disable channel
res = cyg_io_set_config(channel, CYG_IO_SET_CONFIG_ADC_DISABLE, 0, 0);
if (res != ENOERR)
CYG_TEST_FAIL_FINISH("Failed to disable ADC channel");
// Make channel non-blocking
cfg_data = 0;
len = sizeof(cfg_data);
res = cyg_io_set_config(channel, CYG_IO_SET_CONFIG_READ_BLOCKING,
&cfg_data, &len);
if (res != ENOERR)
CYG_TEST_FAIL_FINISH("Failed to make ADC channel non-blocking");
// Set channel sampling rate
cfg_data = TEST_RATE;
len = sizeof(cfg_data);
res = cyg_io_set_config(channel, CYG_IO_SET_CONFIG_ADC_RATE,
&cfg_data, &len);
if (res != ENOERR)
CYG_TEST_FAIL_FINISH("Failed to set ADC channel sampling rate");
// Flush channel
do {
len = sizeof(sample);
res = cyg_io_read(channel, &sample, &len);
} while (res == ENOERR);
// Enable channel
res = cyg_io_set_config(channel, CYG_IO_SET_CONFIG_ADC_ENABLE, 0, 0);
if (res != ENOERR)
CYG_TEST_FAIL_FINISH("Failed to enable ADC channel");
// Read from channel
count = 0;
while (count < TEST_SAMPLES) {
len = sizeof(sample);
res = cyg_io_read(channel, &sample, &len);
if (res == ENOERR) {
diag_printf("%d\n", sample);
count++;
}
}
// Disable channel
res = cyg_io_set_config(channel, CYG_IO_SET_CONFIG_ADC_DISABLE, 0, 0);
if (res != ENOERR)
CYG_TEST_FAIL_FINISH("Failed to disable ADC channel");
}
/*
* restore_tty - restore the terminal to the saved settings.
*/
void
restore_tty(cyg_io_handle_t handle)
{
#ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS
if( modem )
{
// Restore callback handler if it was set.
Cyg_ErrNo err;
cyg_uint32 len = sizeof(ppp_tty.serial_callbacks);
db_printf("%s called\n", __PRETTY_FUNCTION__);
err = cyg_io_set_config( handle,
CYG_IO_SET_CONFIG_SERIAL_STATUS_CALLBACK,
&ppp_tty.serial_callbacks,
&len);
if( err != 0 ) {
syslog(LOG_ERR, "cyg_io_set_config(restore serial callbacks): %d",err);
die(1);
}
}
#endif
}
//===========================================================================
// READER THREAD
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_uint32 blocking;
cyg_can_event rx_event;
Cyg_ErrNo res;
blocking = 0;
len = sizeof(blocking);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_READ_BLOCKING ,&blocking, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
len = sizeof(rx_event);
res = cyg_io_read(hDrvFlexCAN, &rx_event, &len);
if (-EAGAIN == res)
{
CYG_TEST_PASS_FINISH("can_test1 test OK");
}
else if (-EINTR == res)
{
CYG_TEST_PASS_FINISH("can_test1 test OK");
}
else
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
}
/*
* Aborts a blocking sio_read() call.
*/
void sio_read_abort(sio_fd_t fd)
{
cyg_uint32 l = 0;
#ifdef CYGDBG_LWIP_DEBUG_SIO
diag_printf("sio_read_abort(fd=%p)\n", fd);
#endif
cyg_io_set_config((cyg_io_handle_t) fd, CYG_IO_GET_CONFIG_SERIAL_ABORT, NULL, &l);
}
void
tty_api_test(cyg_io_handle_t* handle)
{
int res;
cyg_uint32 len;
unsigned char buffer[16];
// Always return...
if (handle)
return;
CYG_TEST_FAIL_FINISH("Not reached");
// read & write
res = cyg_io_read(handle, &buffer[0], &len);
res = cyg_io_write(handle, &buffer[0], &len);
// cyg_io_get_config
// TTY layer
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_TTY_INFO, &buffer[0], &len);
// Call-throughs to serial layer.
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_INFO, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_INPUT_FLUSH, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_ABORT, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_OUTPUT_FLUSH, &buffer[0], &len);
// cyg_io_set_config
// TTY layer.
cyg_io_set_config(handle,
CYG_IO_SET_CONFIG_TTY_INFO, &buffer[0], &len);
// Call-throughs to serial layer.
cyg_io_set_config(handle,
CYG_IO_SET_CONFIG_SERIAL_INFO, &buffer[0], &len);
}
/*
* set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
* at the requested speed, etc. If `local' is true, set CLOCAL
* regardless of whether the modem option was specified.
*
* For *BSD, we assume that speed_t values numerically equal bits/second.
*/
void
set_up_tty(cyg_io_handle_t handle, int local)
{
cyg_serial_info_t cfg;
int err;
int len = sizeof(cfg);
err = cyg_io_get_config( handle,
CYG_IO_GET_CONFIG_SERIAL_INFO,
&cfg,
&len);
if( err != 0 ) {
syslog(LOG_ERR, "cyg_io_get_config: %d",err);
die(1);
}
switch ( flowctl )
{
case CYG_PPP_FLOWCTL_DEFAULT:
break;
case CYG_PPP_FLOWCTL_NONE:
cfg.flags &= ~(CYGNUM_SERIAL_FLOW_RTSCTS_RX|CYGNUM_SERIAL_FLOW_RTSCTS_TX|
CYGNUM_SERIAL_FLOW_XONXOFF_RX|CYGNUM_SERIAL_FLOW_XONXOFF_TX);
break;
case CYG_PPP_FLOWCTL_HARDWARE:
cfg.flags &= ~(CYGNUM_SERIAL_FLOW_XONXOFF_RX|CYGNUM_SERIAL_FLOW_XONXOFF_TX);
cfg.flags |= CYGNUM_SERIAL_FLOW_RTSCTS_RX|CYGNUM_SERIAL_FLOW_RTSCTS_TX;
break;
case CYG_PPP_FLOWCTL_SOFTWARE:
cfg.flags &= ~(CYGNUM_SERIAL_FLOW_RTSCTS_RX|CYGNUM_SERIAL_FLOW_RTSCTS_TX);
cfg.flags |= CYGNUM_SERIAL_FLOW_XONXOFF_RX|CYGNUM_SERIAL_FLOW_XONXOFF_TX;
break;
}
if( inspeed != 0 )
cfg.baud = inspeed;
err = cyg_io_set_config( handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&cfg,
&len);
if( err != 0 ) {
syslog(LOG_ERR, "cyg_io_set_config: %d",err);
die(1);
}
}
static Cyg_ErrNo
termios_set_config(cyg_io_handle_t handle, cyg_uint32 key, const void *buf, cyg_uint32 *len)
{
cyg_devtab_entry_t *t = (cyg_devtab_entry_t *)handle;
struct termios_private_info *priv = (struct termios_private_info *)t->priv;
cyg_io_handle_t chan = (cyg_io_handle_t)priv->dev_handle;
Cyg_ErrNo res = ENOERR;
switch (key) {
case CYG_IO_SET_CONFIG_TERMIOS:
{
setattr_struct *attr = (setattr_struct *)buf;
int optact = attr->optact;
if ( *len != sizeof( *attr ) ) {
return -EINVAL;
}
CYG_ASSERT( (optact == TCSAFLUSH) || (optact == TCSADRAIN) ||
(optact == TCSANOW), "Invalid optact" );
cyg_drv_mutex_lock( &priv->lock );
if ( ( TCSAFLUSH == optact ) ||
( TCSADRAIN == optact ) ) {
res = cyg_io_get_config( chan,
CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN,
NULL, NULL );
CYG_ASSERT( ENOERR == res, "Drain request failed" );
}
if ( TCSAFLUSH == optact ) {
res = cyg_io_get_config( chan,
CYG_IO_GET_CONFIG_SERIAL_INPUT_FLUSH,
NULL, NULL );
CYG_ASSERT( ENOERR == res, "Flush request failed" );
}
res = set_attr( attr->termios_p, priv );
cyg_drv_mutex_unlock( &priv->lock );
return res;
}
default: // Pass on to serial driver
res = cyg_io_set_config(chan, key, buf, len);
}
return res;
}
/* set framebuffer palette*/
void
ioctl_setpalette(int start, int len, short *red, short *green, short *blue)
{
diag_printf("%s - NOT IMPLEMENTED\n", __FUNCTION__); while (1) ;
#if 0
struct fb_cmap cmap;
cyg_uint32 sz = sizeof(cmap);
cmap.start = start;
cmap.len = len;
cmap.red = red;
cmap.green = green;
cmap.blue = blue;
cmap.transp = NULL;
cyg_io_set_config( fb_handle, CYG_IO_SET_CONFIG_FB_PALETTE, &cmap, &sz );
// ioctl(fb, FBIOPUTCMAP, &cmap);
#endif
}
void
cyg_start(void)
{
cyg_uint32 len;
cyg_can_info_t can_cfg;
CYG_TEST_INIT();
//
// open flexcan device driver
//
if (ENOERR != cyg_io_lookup("/dev/can0", &hDrvFlexCAN))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
}
//
// setup CAN baudrate 250 KBaud
//
can_cfg.baud = CYGNUM_CAN_KBAUD_250;
len = sizeof(can_cfg);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_INFO ,&can_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
//
// create the main thread
//
cyg_thread_create(4, can0_thread,
(cyg_addrword_t) 0,
"can0_thread",
(void *) can0_thread_data.stack,
1024 * sizeof(long),
&can0_thread_data.hdl,
&can0_thread_data.obj);
cyg_thread_resume(can0_thread_data.hdl);
cyg_scheduler_start();
}
void
serial_api_test(int dummy)
{
cyg_io_handle_t handle;
int res;
cyg_uint32 len;
unsigned char buffer[16];
// Always return...
if (dummy)
return;
CYG_TEST_FAIL_FINISH("Not reached");
test_open_ser(&handle);
// read & write
res = cyg_io_read(handle, &buffer[0], &len);
res = cyg_io_write(handle, &buffer[0], &len);
// cyg_io_get_config
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_INFO, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_INPUT_FLUSH, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_ABORT, &buffer[0], &len);
cyg_io_get_config(handle,
CYG_IO_GET_CONFIG_SERIAL_OUTPUT_FLUSH, &buffer[0], &len);
// cyg_io_set_config
cyg_io_set_config(handle,
CYG_IO_SET_CONFIG_SERIAL_INFO, &buffer[0], &len);
}
//===========================================================================
// READER THREAD
//===========================================================================
void can_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_callback_cfg callback_cfg;
cyg_can_message tx_msg;
cyg_bool_t wait_res;
//
// open CAN0 device driver
//
if (ENOERR != cyg_io_lookup("/dev/can0", &hCAN0))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can0");
}
//
// open CAN1 device driver
//
if (ENOERR != cyg_io_lookup("/dev/can1", &hCAN1))
{
CYG_TEST_FAIL_FINISH("Error opening /dev/can1");
}
//
// configure CAN0 callback
//
len = sizeof(callback_cfg);
callback_cfg.flag_mask = 0xFFFF;
callback_cfg.data = (CYG_ADDRWORD) hCAN0;
callback_cfg.callback_func = callback_func;
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_CALLBACK,
&callback_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
//
// transmit message from CAN1 to CAN0
//
tx_msg.id = 0x001;
tx_msg.ext = CYGNUM_CAN_ID_STD;
tx_msg.rtr = CYGNUM_CAN_FRAME_DATA;
tx_msg.dlc = 0;
len = sizeof(tx_msg);
if (ENOERR != cyg_io_write(hCAN1, &tx_msg, &len))
{
CYG_TEST_FAIL_FINISH("Error writing message to /dev/can1");
}
//
// Wait CAN0 callback
//
cyg_mutex_lock(&can_lock);
wait_res = cyg_cond_timed_wait(&can_wait, 100);
cyg_mutex_unlock(&can_lock);
//
// If result of wait is a signal operation, test is successed
// If timeout - test is failed, because callback_func() hasn't been
// called with correct parameters
//
if(wait_res)
{
CYG_TEST_PASS_FINISH("can_callback test OK");
}
else
{
CYG_TEST_FAIL_FINISH("can_callback test FAILED");
}
}
//===========================================================================
// Main thread
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_event rx_event;
cyg_uint16 i;
cyg_can_hdi hdi;
cyg_can_msgbuf_info msgbox_info;
cyg_can_msgbuf_cfg msgbox_cfg;
len = sizeof(hdi);
if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_HDI ,&hdi, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
//
// Normally the CAN modul should support message filters. So the
// FULLCAN flag should be set - if it is not, we treat this as an error
//
if (!(hdi.support_flags & CYGNUM_CAN_HDI_FULLCAN))
{
CYG_TEST_FAIL_FINISH("/dev/can0 does not support message buffers");
}
//
// Now reset message buffer configuration - this is mandatory bevore starting
// message buffer runtime configuration
//
msgbox_cfg.cfg_id = CYGNUM_CAN_MSGBUF_RESET_ALL;
len = sizeof(msgbox_cfg);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&msgbox_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error resetting message buffer configuration of /dev/can0");
}
//
// Now query number of available and free message boxes
//
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
//
// if there are no free message boxes available then this is a failure
//
if (!msgbox_info.free)
{
CYG_TEST_FAIL_FINISH("No free message boxes available for /dev/can0");
}
//
// We setup as many standard CAN message filters as there are free
// message buffers available.
//
for (i = 0; i < msgbox_info.free; ++i)
{
cyg_can_filter rx_filter;
rx_filter.cfg_id = CYGNUM_CAN_MSGBUF_RX_FILTER_ADD;
rx_filter.msg.id = i;
rx_filter.msg.ext = CYGNUM_CAN_ID_STD;
len = sizeof(rx_filter);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rx_filter, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
else if (CYGNUM_CAN_MSGBUF_NA == rx_filter.handle)
{
CYG_TEST_FAIL_FINISH("Error setting up message filter for /dev/can0");
}
}
diag_printf("\n\nNow try to send CAN messages. The device should only\n"
"receive messages identifiers in the range of 0x00 to 0x%X.\n"
"As soon as a standard message with ID 0x000 arrives, all\n"
"message filters will be cleared\n\n", (msgbox_info.free - 1));
//
// Now receive messages until a message arrives with largest ID of all
// available message filters
//
rx_event.msg.id = 1;
while(rx_event.msg.id != 0)
{
len = sizeof(rx_event);
if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
else if (rx_event.flags & CYGNUM_CAN_EVENT_RX)
{
print_can_msg(&rx_event.msg, "");
} // if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
else
{
print_can_flags(rx_event.flags, "");
rx_event.msg.id = 1;
}
} // while(1)
//
// Now enable reception of all available CAN messages
//
cyg_can_filter rx_filter;
rx_filter.cfg_id = CYGNUM_CAN_MSGBUF_RX_FILTER_ALL;
len = sizeof(rx_filter);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF , &rx_filter, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
diag_printf("\n\nAll message filters have been cleared an now the device\n"
"will receive any available CAN message identifiers.\n"
"Send a CAN message with ID 0x100 to stop this test.\n\n");
//
// Now receive messages until a message arrives with largest ID of all
// available message filters
//
rx_event.msg.id = 1;
while(rx_event.msg.id != 0x100)
{
len = sizeof(rx_event);
if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
else if (rx_event.flags & CYGNUM_CAN_EVENT_RX)
{
print_can_msg(&rx_event.msg, "");
} // if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
} // while(1)
CYG_TEST_PASS_FINISH("can_filter test OK");
}
static int
uart_control(void *base, int func, ...)
{
int rc = 0;
va_list ap;
int arg;
struct BSP_IO *io = (struct BSP_IO *)base;
va_start(ap, func);
if (func == COMMCTL_SETBAUD)
{
cyg_serial_info_t buffer = {
CYG_SERIAL_BAUD_DEFAULT,
CYG_SERIAL_STOP_DEFAULT,
CYG_SERIAL_PARITY_DEFAULT,
CYG_SERIAL_WORD_LENGTH_DEFAULT,
CYG_SERIAL_FLAGS_DEFAULT
};
int len = sizeof(buffer);
arg = va_arg(ap, int);
switch (arg)
{
case 50:
buffer.baud = CYG_SERIAL_BAUD_RATE(50);
break;
case 75:
buffer.baud = CYG_SERIAL_BAUD_RATE(75);
break;
case 110:
buffer.baud = CYG_SERIAL_BAUD_RATE(110);
break;
case 134:
buffer.baud = CYG_SERIAL_BAUD_RATE(134_5);
break;
case 135:
buffer.baud = CYG_SERIAL_BAUD_RATE(134_5);
break;
case 150:
buffer.baud = CYG_SERIAL_BAUD_RATE(150);
break;
case 200:
buffer.baud = CYG_SERIAL_BAUD_RATE(200);
break;
case 300:
buffer.baud = CYG_SERIAL_BAUD_RATE(300);
break;
case 600:
buffer.baud = CYG_SERIAL_BAUD_RATE(600);
break;
case 1200:
buffer.baud = CYG_SERIAL_BAUD_RATE(1200);
break;
case 1800:
buffer.baud = CYG_SERIAL_BAUD_RATE(1800);
break;
case 2400:
buffer.baud = CYG_SERIAL_BAUD_RATE(2400);
break;
case 3600:
buffer.baud = CYG_SERIAL_BAUD_RATE(3600);
break;
case 4800:
buffer.baud = CYG_SERIAL_BAUD_RATE(4800);
break;
case 7200:
buffer.baud = CYG_SERIAL_BAUD_RATE(7200);
break;
case 9600:
buffer.baud = CYG_SERIAL_BAUD_RATE(9600);
break;
case 14400:
buffer.baud = CYG_SERIAL_BAUD_RATE(14400);
break;
case 19200:
buffer.baud = CYG_SERIAL_BAUD_RATE(19200);
break;
case 38400:
buffer.baud = CYG_SERIAL_BAUD_RATE(38400);
break;
case 57600:
buffer.baud = CYG_SERIAL_BAUD_RATE(57600);
break;
case 115200:
buffer.baud = CYG_SERIAL_BAUD_RATE(115200);
break;
case 230400:
buffer.baud = CYG_SERIAL_BAUD_RATE(230400);
break;
default:
buffer.baud = -1;
rc = -1;
break;
}
if ((io->chan) && (buffer.baud != -1)) {
rc = cyg_io_set_config(io->chan, CYG_IO_SET_CONFIG_SERIAL_INFO, &buffer, &len);
}
}
void
console_test( CYG_ADDRWORD x )
{
Cyg_ErrNo res;
cyg_io_handle_t handle;
char msg[] = "This is a test\n";
int msglen = sizeof(msg)-1;
char in_msg[80];
int in_msglen = sizeof(in_msg)-1;
cyg_serial_info_t serial_info;
cyg_tty_info_t tty_info;
char short_msg[] = "This is a short message\n";
char long_msg[] = "This is a longer message 0123456789abcdefghijklmnopqrstuvwxyz\n";
char filler[] = " ";
char prompt[] = "\nPlease enter some data: ";
int i, len;
res = cyg_io_lookup(CYGDAT_IO_SERIAL_TTY_CONSOLE, &handle);
if (res != ENOERR) {
diag_printf("Can't lookup - DEVIO error: %d\n", res);
return;
}
len = sizeof(serial_info);
res = cyg_io_get_config(handle, CYG_IO_GET_CONFIG_SERIAL_INFO, &serial_info, &len);
if (res != ENOERR) {
diag_printf("Can't get serial config - DEVIO error: %d\n", res);
hang();
return;
}
len = sizeof(tty_info);
res = cyg_io_get_config(handle, CYG_IO_GET_CONFIG_TTY_INFO, &tty_info, &len);
if (res != ENOERR) {
diag_printf("Can't get tty config - DEVIO error: %d\n", res);
hang();
return;
}
diag_printf("Config - baud: %d, stop: %d, parity: %d, out flags: %x, in flags: %x\n",
serial_info.baud, serial_info.stop, serial_info.parity,
tty_info.tty_out_flags, tty_info.tty_in_flags);
len = sizeof(serial_info);
res = cyg_io_set_config(handle, CYG_IO_SET_CONFIG_SERIAL_INFO, &serial_info, &len);
if (res != ENOERR) {
diag_printf("Can't set serial config - DEVIO error: %d\n", res);
hang();
return;
}
len = sizeof(tty_info);
res = cyg_io_set_config(handle, CYG_IO_SET_CONFIG_TTY_INFO, &tty_info, &len);
if (res != ENOERR) {
diag_printf("Can't set tty config - DEVIO error: %d\n", res);
hang();
return;
}
msglen = strlen(msg);
res = cyg_io_write(handle, msg, &msglen);
if (res != ENOERR) {
diag_printf("Can't write data - DEVIO error: %d\n", res);
hang();
return;
}
for (i = 0; i < 10; i++) {
len = strlen(short_msg);
res = cyg_io_write(handle, short_msg, &len);
if (res != ENOERR) {
diag_printf("Can't write [short] data - DEVIO error: %d\n", res);
hang();
return;
}
}
for (i = 0; i < 100; i++) {
len = (i % 10) + 1;
cyg_io_write(handle, filler, &len);
len = strlen(long_msg);
res = cyg_io_write(handle, long_msg, &len);
if (res != ENOERR) {
diag_printf("Can't write [long] data - DEVIO error: %d\n", res);
hang();
return;
}
}
len = strlen(prompt);
cyg_io_write(handle, prompt, &len);
res = cyg_io_read(handle, in_msg, &in_msglen);
if (res != ENOERR) {
diag_printf("Can't read data - DEVIO error: %d\n", res);
hang();
return;
}
diag_printf("Read %d bytes\n", in_msglen);
dump_buf(in_msg, in_msglen);
CYG_TEST_PASS_FINISH("Console I/O test OK");
}
//===========================================================================
// READER THREAD
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_event rx_event;
cyg_can_remote_buf rtr_buf;
cyg_can_remote_buf rtr_buf2;
cyg_can_msgbuf_info msgbox_info;
cyg_can_mode mode;
cyg_can_state state;
//
// before we start configuring the CAN hardware we stop the chip
//
mode = CYGNUM_CAN_MODE_STOP;
len = sizeof(mode);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_MODE ,&mode, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
//
// now check if FlexCAN modul is really stopped
//
len = sizeof(state);
if (ENOERR != cyg_io_get_config(hDrvFlexCAN, CYG_IO_GET_CONFIG_CAN_STATE ,&state, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
if (state != CYGNUM_CAN_STATE_STOPPED)
{
CYG_TEST_FAIL_FINISH("Error stopping FlexCAN /dev/can0");
}
//
// We would like to setup 2 remote buffers - check if we have enough
// free message buffers
//
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hDrvFlexCAN, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
else
{
diag_printf("Message boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
if (msgbox_info.free < 2)
{
CYG_TEST_FAIL_FINISH("Not enough free message buffers/dev/can0");
}
//
// Setup the first remote response buffer for resception of standard
// remote frames
//
rtr_buf.cfg_id = CYGNUM_CAN_MSGBUF_REMOTE_BUF_ADD;
rtr_buf.msg.id = 0x7FF;
rtr_buf.msg.ext = CYGNUM_CAN_ID_STD;
rtr_buf.msg.rtr = CYGNUM_CAN_FRAME_DATA;
rtr_buf.msg.dlc = 1;
rtr_buf.msg.data[0] = 0xAB;
len = sizeof(rtr_buf);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rtr_buf, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
//
// setup the second remote response buffer for reception of extended
// remote frames
//
rtr_buf2.cfg_id = CYGNUM_CAN_MSGBUF_REMOTE_BUF_ADD;
rtr_buf2.msg.id = 0x800;
rtr_buf2.msg.ext = CYGNUM_CAN_ID_EXT;
rtr_buf2.msg.rtr = CYGNUM_CAN_FRAME_DATA;
rtr_buf2.msg.dlc = 4;
rtr_buf2.msg.data[0] = 0xAB;
len = sizeof(rtr_buf2);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rtr_buf2, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
if (rtr_buf.handle == CYGNUM_CAN_MSGBUF_NA)
{
CYG_TEST_FAIL_FINISH("No free message buffer available for /dev/can0");
}
//
// now configuration is finished and we can start chip again
//
mode = CYGNUM_CAN_MODE_START;
len = sizeof(mode);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_MODE ,&mode, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
diag_printf("Test of FlexCAN remote response buffer configuration\n"
"If a CAN node sends a remote request with ID 0x7FF\n"
"or 0x800 then the FlexCAN modul should respond with\n"
"data frames.\n");
diag_printf("!!! This test can be stopped by sending a data frame with ID 0x100 !!!\n\n");
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hDrvFlexCAN, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
else
{
diag_printf("Message boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
while (1)
{
len = sizeof(rx_event);
if (ENOERR != cyg_io_read(hDrvFlexCAN, &rx_event, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
if (0x100 == rx_event.msg.id)
{
CYG_TEST_PASS_FINISH("flexcan_remote test OK");
}
else
{
print_can_flags(rx_event.flags, "");
print_can_msg(&rx_event.msg, "");
}
}
}
//===========================================================================
// Setup acceptance filter
//===========================================================================
void can_setup_channel(cyg_io_handle_t hCAN, unsigned char Channel)
{
cyg_uint32 len;
cyg_can_msgbuf_cfg msgbox_cfg;
cyg_uint8 i;
cyg_uint32 blocking;
//
// First we reset message buffer configuration - this is mandatory bevore starting
// message buffer runtime configuration. This call clears/frees all message buffers
// The CAN controller cannot receive any further CAN message after this call
//
msgbox_cfg.cfg_id = CYGNUM_CAN_MSGBUF_RESET_ALL;
len = sizeof(msgbox_cfg);
if (ENOERR != cyg_io_set_config(hCAN, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&msgbox_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error resetting message buffer configuration of /dev/can0");
}
//
// Now setup 10 message filters for this channel
//
for (i = 0; i < 10; ++i)
{
cyg_can_filter rx_filter;
rx_filter.cfg_id = CYGNUM_CAN_MSGBUF_RX_FILTER_ADD;
rx_filter.msg.id = Channel * 0x100 + i;
rx_filter.msg.ext = CYGNUM_CAN_ID_STD;
len = sizeof(rx_filter);
if (ENOERR != cyg_io_set_config(hCAN, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rx_filter, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config");
}
else if (CYGNUM_CAN_MSGBUF_NA == rx_filter.handle)
{
CYG_TEST_FAIL_FINISH("Error setting up message filter");
}
}
//
// Now set driver into nonblocking mode because the receiver thread will
// receive the messages from all channels
//
blocking = 0;
len = sizeof(blocking);
if (ENOERR != cyg_io_set_config(hCAN, CYG_IO_SET_CONFIG_READ_BLOCKING ,&blocking, &len))
{
CYG_TEST_FAIL_FINISH("Error setting channel into nonblocking mode");
}
//
// If timeouts are supported we need to setup a timeout value of 0 because
// the driver should return immediatelly if no message is available
//
#ifdef CYGOPT_IO_CAN_SUPPORT_TIMEOUTS
cyg_can_timeout_info_t timeouts;
timeouts.rx_timeout = 0;
timeouts.tx_timeout = 0;
len = sizeof(timeouts);
if (ENOERR != cyg_io_set_config(hCAN, CYG_IO_SET_CONFIG_CAN_TIMEOUT ,&timeouts, &len))
{
CYG_TEST_FAIL_FINISH("Error setting timeout for channel");
}
#endif
}
// Mount disk/filesystem
static void
do_mount(int argc, char *argv[])
{
char *dev_str = "<undefined>", *type_str, *mp_str;
bool dev_set = false, type_set = false;
struct option_info opts[3];
int err, num_opts = 2;
int i,m=0; /* Set to 0 to silence warning */
#ifdef CYGPKG_IO_FLASH_BLOCK_DEVICE_LEGACY
char *part_str;
bool part_set = false;
#endif
init_opts(&opts[0], 'd', true, OPTION_ARG_TYPE_STR,
(void *)&dev_str, &dev_set, "device");
init_opts(&opts[1], 't', true, OPTION_ARG_TYPE_STR,
(void *)&type_str, &type_set, "fstype");
#ifdef CYGPKG_IO_FLASH_BLOCK_DEVICE_LEGACY
init_opts(&opts[2], 'f', true, OPTION_ARG_TYPE_STR,
(void *)&part_str, &part_set, "partition");
num_opts++;
#endif
CYG_ASSERT(num_opts <= NUM_ELEMS(opts), "Too many options");
if (!scan_opts(argc, argv, 1, opts, num_opts, &mp_str, OPTION_ARG_TYPE_STR, "mountpoint"))
return;
if (!type_set) {
err_printf("fs mount: Must specify file system type\n");
return;
}
if( mp_str == 0 )
mp_str = "/";
if( mount_count >= MAX_MOUNTS )
{
err_printf("fs mount: Maximum number of mounts exceeded\n");
return;
}
#ifdef CYGPKG_IO_FLASH_BLOCK_DEVICE_LEGACY
if (part_set) {
int len;
cyg_io_handle_t h;
if (dev_set && strcmp(dev_str, CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1)) {
err_printf("fs mount: May only set one of <device> or <partition>\n");
return;
}
dev_str = CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1;
len = strlen(part_str);
err = cyg_io_lookup(dev_str, &h);
if (err < 0) {
err_printf("fs mount: cyg_io_lookup of \"%s\" returned %d\n", err);
return;
}
err = cyg_io_set_config(h, CYG_IO_SET_CONFIG_FLASH_FIS_NAME,
part_str, &len);
if (err < 0) {
diag_printf("fs mount: FIS partition \"%s\" not found\n",
part_str);
return;
}
}
#endif
for( i = 0; i < MAX_MOUNTS; i++ )
{
if( mounts[i].mp_str[0] != '\0' )
{
if( strcmp(mounts[i].dev_str, dev_str ) == 0 )
{
err_printf("fs mount: Device %s already mounted\n",dev_str);
return;
}
}
else
m = i;
}
strcpy( mounts[m].mp_str, mp_str );
strcpy( mounts[m].dev_str, dev_str );
strcpy( mounts[m].type_str, type_str );
err = mount(mounts[m].dev_str, mounts[m].mp_str, mounts[m].type_str);
if (err)
{
err_printf("fs mount: mount(%s,%s,%s) failed %d\n", dev_str, mp_str, type_str, errno);
mounts[m].mp_str[0] = '\0'; // mount failed so don't let it appear mounted
}
else
{
if( mount_count == 0 )
chdir( "/" );
mount_count++;
}
}
//===========================================================================
// READER THREAD
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_event rx_event;
cyg_can_filtergroup_cfg acc_filt_grp;
cyg_can_msgbuf_cfg msgbox_cfg;
//
// First we reset message buffer configuration - this is mandatory bevore starting
// message buffer runtime configuration. This call clears/frees all message buffers
// The CAN controller cannot receive any further CAN message after this call
//
msgbox_cfg.cfg_id = CYGNUM_CAN_MSGBUF_RESET_ALL;
len = sizeof(msgbox_cfg);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&msgbox_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error resetting message buffer configuration of /dev/can0");
}
//
// Now we setup two different acceptance filter groups. Acceptance filter
// groups are not part of the CAN I/O layer and are a LPC2xxx specific
// feature. You should not use appcetance filter groups if you would like
// to code portable eCos CAN applications
//
#ifdef CYGOPT_IO_CAN_STD_CAN_ID
acc_filt_grp.ext = CYGNUM_CAN_ID_STD;
acc_filt_grp.lower_id_bound = 0x100;
acc_filt_grp.upper_id_bound = 0x110;
len = sizeof(acc_filt_grp);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_LPC2XXX_ACCFILT_GROUP ,&acc_filt_grp, &len))
{
CYG_TEST_FAIL_FINISH("Error adding filter group to /dev/can0");
}
#endif // CYGOPT_IO_CAN_STD_CAN_ID
#ifdef CYGOPT_IO_CAN_EXT_CAN_ID
acc_filt_grp.ext = CYGNUM_CAN_ID_EXT;
acc_filt_grp.lower_id_bound = 0x2000;
acc_filt_grp.upper_id_bound = 0x2200;
len = sizeof(acc_filt_grp);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_LPC2XXX_ACCFILT_GROUP ,&acc_filt_grp, &len))
{
CYG_TEST_FAIL_FINISH("Error adding filter group to /dev/can0");
}
#endif // CYGOPT_IO_CAN_STD_CAN_ID
diag_printf("\n\nNow try to send CAN messages. The device should only\n"
"receive standard messages identifiers in the range of 0x100\n"
"to 0x110 and/or extended identifiers in the range 0x2000 to\n"
"0x2200. As soon as a standard message with ID 0x110 or an\n"
"extended message with ID 0x2200 arrives, the test finishes\n\n");
while (1)
{
len = sizeof(rx_event);
if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
else
{
print_can_flags(rx_event.flags, "");
if (rx_event.flags & CYGNUM_CAN_EVENT_RX)
{
print_can_msg(&rx_event.msg, "");
#ifdef CYGOPT_IO_CAN_STD_CAN_ID
if (rx_event.msg.id == 0x110)
{
CYG_TEST_PASS_FINISH("LPC2xxx CAN message filter group test OK");
}
#endif // CYGOPT_IO_CAN_STD_CAN_ID
#ifdef CYGOPT_IO_CAN_EXT_CAN_ID
if (rx_event.msg.id == 0x2200)
{
CYG_TEST_PASS_FINISH("LPC2xxx CAN message filter group test OK");
}
#endif // CYGOPT_IO_CAN_EXT_CAN_ID
if (((rx_event.msg.id > 0x110) && (rx_event.msg.id < 0x2000))
|| (rx_event.msg.id > 0x2200))
{
CYG_TEST_FAIL_FINISH("Received CAN identifier outside filter group bounds");
}
}
}
} // while (1)
}
//===========================================================================
// Main thread
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_event rx_event;
cyg_can_remote_buf rtr_buf;
cyg_can_filter rx_filter;
cyg_can_msgbuf_info msgbox_info;
cyg_can_msgbuf_cfg msgbox_cfg;
//
// We would like to setup 2 remote buffers - check if we have enough
// free message buffers
//
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
else
{
diag_printf("\n\n\nMessage boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
//
// We have not enougth free message buffers, so we clear all message buffers now
// and try again
//
if (msgbox_info.free < 2)
{
msgbox_cfg.cfg_id = CYGNUM_CAN_MSGBUF_RESET_ALL;
len = sizeof(msgbox_cfg);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF, &msgbox_cfg, &len))
{
CYG_TEST_FAIL_FINISH("Error clearing message buffers of /dev/can0");
}
//
// Now query number of free message boxes again. We need 3 free message boxes.
// 2 message boxes for setup of remote response buffers and 1 message box for
// setup of receive message box for CAN identifier 0x100
//
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
else
{
diag_printf("Message boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
if (msgbox_info.free < 3)
{
CYG_TEST_FAIL_FINISH("Not enough free message buffers available for /dev/can0");
}
else
{
rx_filter.cfg_id = CYGNUM_CAN_MSGBUF_RX_FILTER_ADD;
CYG_CAN_MSG_SET_STD_ID(rx_filter.msg, 0x100);
len = sizeof(rx_filter);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rx_filter, &len))
{
CYG_TEST_FAIL_FINISH("Error adding rx filter for CAN ID 0x100 for /dev/can0");
}
} // if (msgbox_info.free < 3)
} // if (msgbox_info.free < 2)
#ifdef CYGOPT_IO_CAN_STD_CAN_ID
//
// Setup the first remote response buffer for resception of standard
// remote frames
//
rtr_buf.cfg_id = CYGNUM_CAN_MSGBUF_REMOTE_BUF_ADD;
CYG_CAN_MSG_SET_PARAM(rtr_buf.msg, 0x7FF, CYGNUM_CAN_ID_STD, 1, CYGNUM_CAN_FRAME_DATA);
CYG_CAN_MSG_SET_DATA(rtr_buf.msg, 0, 0xAB);
len = sizeof(rtr_buf);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rtr_buf, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
#endif
#ifdef CYGOPT_IO_CAN_EXT_CAN_ID
cyg_can_remote_buf rtr_buf2;
//
// setup the second remote response buffer for reception of extended
// remote frames
//
rtr_buf2.cfg_id = CYGNUM_CAN_MSGBUF_REMOTE_BUF_ADD;
CYG_CAN_MSG_SET_PARAM(rtr_buf2.msg, 0x800, CYGNUM_CAN_ID_EXT, 4, CYGNUM_CAN_FRAME_DATA);
CYG_CAN_MSG_SET_DATA(rtr_buf2.msg, 0, 0xCD);
len = sizeof(rtr_buf2);
if (ENOERR != cyg_io_set_config(hCAN0, CYG_IO_SET_CONFIG_CAN_MSGBUF ,&rtr_buf2, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
if (rtr_buf.handle == CYGNUM_CAN_MSGBUF_NA)
{
CYG_TEST_FAIL_FINISH("No free message buffer available for /dev/can0");
}
#endif
diag_printf("\nTest of CAN remote response buffer configuration\n"
"If a CAN node sends a remote request with ID 0x7FF (std. ID)\n"
"or 0x800 (ext. ID) then the CAN driver should respond with\n"
"data frames.\n\n");
diag_printf("!!! This test can be stopped by sending a data frame\n"
"with ID 0x100 !!!\n\n");
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hCAN0, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
else
{
diag_printf("Message boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
while (1)
{
len = sizeof(rx_event);
if (ENOERR != cyg_io_read(hCAN0, &rx_event, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
if (0x100 == rx_event.msg.id)
{
CYG_TEST_PASS_FINISH("can_remote test OK");
}
else
{
print_can_flags(rx_event.flags, "");
if (rx_event.flags & CYGNUM_CAN_EVENT_RX)
{
print_can_msg(&rx_event.msg, "");
}
}
}
}
static Cyg_ErrNo
set_attr( struct termios *t, struct termios_private_info *priv )
{
Cyg_ErrNo res = ENOERR;
cyg_serial_info_t dev_conf, new_dev_conf;
cyg_uint32 len = sizeof( dev_conf );
cc_t *tempcc = &priv->termios.c_cc[0];
struct termios *ptermios = &priv->termios;
// Get info from driver
res = cyg_io_get_config( priv->dev_handle, CYG_IO_GET_CONFIG_SERIAL_INFO,
&dev_conf, &len );
if ( ENOERR != res )
return res;
// We need to set up each facet of config to change one by one because
// POSIX says we should try and change as much of the config as possible
// This is tedious and has to be done by steam :-(
if ( t->c_ospeed != ptermios->c_ospeed ) {
new_dev_conf = dev_conf;
new_dev_conf.baud = map_posixbaud_to_ecosbaud( t->c_ospeed );
if ( 0 != new_dev_conf.baud ) {
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.baud = new_dev_conf.baud;
// and termios
ptermios->c_ispeed = t->c_ospeed;
ptermios->c_ospeed = t->c_ospeed;
}
}
}
if ( (t->c_cflag & CSTOPB) != (ptermios->c_cflag & CSTOPB) ) {
new_dev_conf = dev_conf;
if ( t->c_cflag & CSTOPB )
new_dev_conf.stop = CYGNUM_SERIAL_STOP_2;
else
new_dev_conf.stop = CYGNUM_SERIAL_STOP_1;
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.stop = new_dev_conf.stop;
// and termios
ptermios->c_cflag &= ~CSTOPB;
ptermios->c_cflag |= t->c_cflag & CSTOPB;
}
}
if ( ((t->c_cflag & PARENB) != (ptermios->c_cflag & PARENB)) ||
((t->c_cflag & PARODD) != (ptermios->c_cflag & PARODD)) ) {
new_dev_conf = dev_conf;
if ( t->c_cflag & PARENB )
if ( t->c_cflag & PARODD )
new_dev_conf.parity = CYGNUM_SERIAL_PARITY_ODD;
else
new_dev_conf.parity = CYGNUM_SERIAL_PARITY_EVEN;
else
new_dev_conf.parity = CYGNUM_SERIAL_PARITY_NONE;
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.parity = new_dev_conf.parity;
// and termios
ptermios->c_cflag &= ~(PARENB|PARODD);
ptermios->c_cflag |= t->c_cflag & (PARENB|PARODD);
}
}
if ( (t->c_cflag & CSIZE) != (ptermios->c_cflag & CSIZE) ) {
new_dev_conf = dev_conf;
switch ( t->c_cflag & CSIZE ) {
case CS5:
new_dev_conf.word_length = CYGNUM_SERIAL_WORD_LENGTH_5;
break;
case CS6:
new_dev_conf.word_length = CYGNUM_SERIAL_WORD_LENGTH_6;
break;
case CS7:
new_dev_conf.word_length = CYGNUM_SERIAL_WORD_LENGTH_7;
break;
case CS8:
new_dev_conf.word_length = CYGNUM_SERIAL_WORD_LENGTH_8;
break;
}
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.word_length = new_dev_conf.word_length;
// and termios
ptermios->c_cflag &= ~CSIZE;
ptermios->c_cflag |= t->c_cflag & CSIZE;
}
}
if ( (t->c_cflag & IXOFF) != (ptermios->c_cflag & IXOFF) ) {
new_dev_conf = dev_conf;
new_dev_conf.flags &=
~(CYGNUM_SERIAL_FLOW_XONXOFF_RX|CYGNUM_SERIAL_FLOW_RTSCTS_RX);
if ( t->c_cflag & IXOFF )
if ( t->c_cflag & CRTSCTS)
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_RTSCTS_RX;
else
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_XONXOFF_RX;
else
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_NONE;
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.flags = new_dev_conf.flags;
// and termios
ptermios->c_cflag &= ~(IXOFF|CRTSCTS);
ptermios->c_cflag |= t->c_cflag & (IXOFF|CRTSCTS);
}
}
if ( (t->c_cflag & IXON) != (ptermios->c_cflag & IXON) ) {
new_dev_conf = dev_conf;
new_dev_conf.flags &=
~(CYGNUM_SERIAL_FLOW_XONXOFF_TX|CYGNUM_SERIAL_FLOW_RTSCTS_TX);
if ( t->c_cflag & IXON )
if ( t->c_cflag & CRTSCTS)
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_RTSCTS_TX;
else
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_XONXOFF_TX;
else
new_dev_conf.flags |= CYGNUM_SERIAL_FLOW_NONE;
len = sizeof( new_dev_conf );
res = cyg_io_set_config( priv->dev_handle,
CYG_IO_SET_CONFIG_SERIAL_INFO,
&new_dev_conf, &len );
if ( ENOERR == res ) {
// It worked, so update dev_conf to reflect the new state
dev_conf.flags = new_dev_conf.flags;
// and termios
ptermios->c_cflag &= ~(IXON|CRTSCTS);
ptermios->c_cflag |= t->c_cflag & (IXON|CRTSCTS);
}
}
// Input/Output processing flags can just be set as we grok them all
// with few exceptions (see lflags below)
ptermios->c_iflag &= ~(BRKINT|ICRNL|IGNBRK|IGNCR|IGNPAR|INLCR|INPCK|
ISTRIP|PARMRK);
ptermios->c_iflag |= t->c_iflag & (
#ifdef CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS
BRKINT|
#endif
ICRNL|IGNBRK|IGNCR|IGNPAR|
INLCR|INPCK|ISTRIP|PARMRK );
ptermios->c_oflag &= ~(OPOST|ONLCR);
ptermios->c_oflag |= t->c_oflag & (OPOST|ONLCR);
ptermios->c_cflag &= ~(CLOCAL|CREAD|HUPCL);
ptermios->c_cflag |= t->c_cflag & (CLOCAL|CREAD|HUPCL);
ptermios->c_lflag &= ~(ECHO|ECHOE|ECHOK|ECHONL|ICANON|
IEXTEN|ISIG|NOFLSH|TOSTOP);
// Note we don't support IEXTEN nor TOSTOP so we don't set them
ptermios->c_lflag |= t->c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ICANON|
#ifdef CYGSEM_IO_SERIAL_TERMIOS_USE_SIGNALS
ISIG|
#endif
NOFLSH);
// control characters. We don't support changing of VSTART, VSTOP,
// VTIME or VSUSP though
tempcc[VEOF] = t->c_cc[VEOF];
tempcc[VEOL] = t->c_cc[VEOL];
tempcc[VERASE] = t->c_cc[VERASE];
tempcc[VINTR] = t->c_cc[VINTR];
tempcc[VKILL] = t->c_cc[VKILL];
tempcc[VMIN] = t->c_cc[VMIN];
tempcc[VQUIT] = t->c_cc[VQUIT];
return res;
}
//===========================================================================
// READER THREAD
//===========================================================================
void can0_thread(cyg_addrword_t data)
{
cyg_uint32 len;
cyg_can_event rx_event1;
cyg_can_event rx_event2;
cyg_can_msgbuf_info msgbox_info;
cyg_can_mode mode;
cyg_can_state state;
diag_printf("Test of FlexCAN standby mode with selfwakeup\n"
"As soon as a message arrives the FlexCAN modul\n"
"will leave standby and generates a leave standby event.\n"
"Each time you send a message you should see LSTY first\n"
"for \"leaving standby\" and then \"RX\" for the\n"
"RX event that caused the leave standby event. You can send\n"
"a CAN data frame with any ID\n");
diag_printf("!!! This test can be stopped by sending a data frame with ID 0x100 !!!\n\n");
len = sizeof(msgbox_info);
if (ENOERR != cyg_io_get_config(hDrvFlexCAN, CYG_IO_GET_CONFIG_CAN_MSGBUF_INFO ,&msgbox_info, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
else
{
diag_printf("Message boxes available: %d free: %d\n",
msgbox_info.count, msgbox_info.free);
}
while (1)
{
//
// now we set FlexCAN into standby mode
//
mode = CYGNUM_CAN_MODE_STANDBY;
len = sizeof(mode);
if (ENOERR != cyg_io_set_config(hDrvFlexCAN, CYG_IO_SET_CONFIG_CAN_MODE ,&mode, &len))
{
CYG_TEST_FAIL_FINISH("Error writing config of /dev/can0");
}
//
// now check if FlexCAN modul is really in standby mode
//
len = sizeof(state);
if (ENOERR != cyg_io_get_config(hDrvFlexCAN, CYG_IO_GET_CONFIG_CAN_STATE ,&state, &len))
{
CYG_TEST_FAIL_FINISH("Error reading config of /dev/can0");
}
if (state != CYGNUM_CAN_STATE_STANDBY)
{
CYG_TEST_FAIL_FINISH("Error stopping FlexCAN /dev/can0");
}
//
// as soon as a message arrives the FlexCAN modul leaves standby mode
// and we should receive a CYGNUM_CAN_EVENT_LEAVING_STANDBY event but
// we will also receive a RX event because a message arrived
//
len = sizeof(rx_event1);
if (ENOERR != cyg_io_read(hDrvFlexCAN, &rx_event1, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
len = sizeof(rx_event2);
if (ENOERR != cyg_io_read(hDrvFlexCAN, &rx_event2, &len))
{
CYG_TEST_FAIL_FINISH("Error reading from /dev/can0");
}
print_can_flags(rx_event1.flags, "");
print_can_flags(rx_event2.flags, "");
//
// The first event we receive should be a leaving standby event because
// first flexcan leaves standby and then a message will be received
//
if (!(rx_event1.flags & CYGNUM_CAN_EVENT_LEAVING_STANDBY))
{
CYG_TEST_FAIL_FINISH("CYGNUM_CAN_EVENT_LEAVING_STANDBY event expexted /dev/can0");
}
if (rx_event2.msg.id == 0x100)
{
CYG_TEST_PASS_FINISH("flexcan_wake test OK");
}
}
}
externC void
cyg_pppd_main(CYG_ADDRWORD arg)
{
int i;
struct timeval timo;
struct protent *protp;
int connect_attempts = 0;
phase = PHASE_INITIALIZE;
cyg_ppp_options_install( ((struct tty *)arg)->options );
for (i = 0; (protp = protocols[i]) != NULL; ++i)
(*protp->init)(0);
if (!ppp_available()) {
option_error(no_ppp_msg);
exit(1);
}
/*
* Initialize system-dependent stuff and magic number package.
*/
sys_init();
magic_init();
if (debug)
setlogmask(LOG_UPTO(LOG_DEBUG));
for (;;) {
need_holdoff = 1;
{
Cyg_ErrNo err;
while ((err = cyg_io_lookup(devnam, &tty_handle)) < 0) {
if (err != 0)
syslog(LOG_ERR, "Failed to open %s: %d", devnam,err);
}
#ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS
if( modem )
{
cyg_uint32 len = sizeof(ppp_tty.serial_callbacks);
ppp_tty.serial_callbacks.fn = cyg_ppp_serial_callback;
ppp_tty.serial_callbacks.priv = (CYG_ADDRWORD)&ppp_tty;
err = cyg_io_set_config( tty_handle,
CYG_IO_SET_CONFIG_SERIAL_STATUS_CALLBACK,
&ppp_tty.serial_callbacks,
&len);
if( err != 0 ) {
syslog(LOG_ERR, "cyg_io_set_config(serial callbacks): %d",err);
die(1);
}
}
#endif
}
hungup = 0;
kill_link = 0;
/* set line speed, flow control, etc.; clear CLOCAL if modem option */
set_up_tty(tty_handle, 0);
#ifdef CYGPKG_PPP_CHAT
if( script != NULL )
{
if( !cyg_ppp_chat( devnam, script ) )
{
connect_attempts++;
goto fail;
}
}
#endif
#ifdef CYGOPT_IO_SERIAL_SUPPORT_LINE_STATUS
if( modem )
{
while( !ppp_tty.carrier_detected )
cyg_thread_delay(100);
}
#endif
connect_attempts = 0; /* we made it through ok */
/* set up the serial device as a ppp interface */
establish_ppp(tty_handle);
syslog(LOG_INFO, "Using interface ppp%d", ifunit);
(void) sprintf(ifname, "ppp%d", ifunit);
/*
* Start opening the connection and wait for
* incoming events (reply, timeout, etc.).
*/
syslog(LOG_NOTICE, "Connect: %s <--> %s", ifname, devnam);
stime = time((time_t *) NULL);
lcp_lowerup(0);
lcp_open(0); /* Start protocol */
for (phase = PHASE_ESTABLISH; phase != PHASE_DEAD; ) {
wait_input(timeleft(&timo));
calltimeout();
get_input();
if (kill_link) {
lcp_close(0, "User request");
kill_link = 0;
}
if (open_ccp_flag) {
if (phase == PHASE_NETWORK) {
ccp_fsm[0].flags = OPT_RESTART; /* clears OPT_SILENT */
(*ccp_protent.open)(0);
}
open_ccp_flag = 0;
}
}
clean_check();
disestablish_ppp(tty_handle);
#ifdef CYGPKG_PPP_CHAT
fail:
#endif
if (tty_handle != 0)
close_tty();
/* limit to retries? */
if (max_con_attempts)
if (connect_attempts >= max_con_attempts)
break;
if (!persist)
die(1);
#if 0
if (holdoff > 0 && need_holdoff) {
phase = PHASE_HOLDOFF;
TIMEOUT(holdoff_end, NULL, holdoff);
do {
wait_time(timeleft(&timo));
calltimeout();
if (kill_link) {
if (!persist)
die(0);
kill_link = 0;
phase = PHASE_DORMANT; /* allow signal to end holdoff */
}
} while (phase == PHASE_HOLDOFF);
}
#endif
}
die(0);
}
//===========================================================================
// ADC THREAD
//===========================================================================
void adc_thread(cyg_addrword_t data)
{
int res;
cyg_io_handle_t handle[8] = {0, 0, 0, 0, 0, 0, 0, 0};
cyg_uint32 sample_cnt[8] = {0, 0, 0, 0, 0, 0, 0, 0};
cyg_uint32 cfg_data;
cyg_uint32 len;
cyg_uint32 start_time;
cyg_uint32 end_time;
int i;
cyg_uint8 seconds = 0;
float final_seconds;
cyg_uint32 samples_expected;
diag_printf("This test reads samples from all enabled ADC channels.\n"
"Each second the number of already acquired samples\n"
"will be printed. After 10 seconds all ADC channels\n"
"will be stopped and each ADC buffer will be read until\n"
"it is empty. If the number of acquired samples is much\n"
"smaller than the number of expected samples, then you\n"
"should lower the sample rate.\n\n");
// Get a handle for ADC device 0 channel 1 - 8
res = cyg_io_lookup( "/dev/adc00", &handle[0]);
res = cyg_io_lookup( "/dev/adc01", &handle[1]);
res = cyg_io_lookup( "/dev/adc02", &handle[2]);
res = cyg_io_lookup( "/dev/adc03", &handle[3]);
res = cyg_io_lookup( "/dev/adc04", &handle[4]);
res = cyg_io_lookup( "/dev/adc05", &handle[5]);
res = cyg_io_lookup( "/dev/adc06", &handle[6]);
res = cyg_io_lookup( "/dev/adc07", &handle[7]);
//
// switch all channels to non blocking
//
for (i = 0; i < 8; ++i)
{
if (handle[i])
{
cfg_data = 0;
len = sizeof(cfg_data);
res = cyg_io_set_config(handle[i],
CYG_IO_SET_CONFIG_READ_BLOCKING,
&cfg_data,
&len);
if (ENOERR != res)
{
CYG_TEST_FAIL_FINISH("Error switching ADC channel to non blocking");
}
sample_cnt[i] = 0;
} // if (handle[i])
} // for (i = 0; i < 8; ++i)
start_time = cyg_current_time();
do
{
for (i = 0; i < 8; ++i)
{
if (handle[i])
{
cyg_adc_sample_t sample;
// read a sample from the channel
do
{
cyg_uint32 len = sizeof(sample);
res = cyg_io_read( handle[i], &sample, &len );
}
while (-EAGAIN == res);
if (ENOERR == res)
{
sample_cnt[i]++;
}
} // if (handle[i])
}
//
// print number of acquired samples - if one second is expired.
// we expect that the number of acquired samples is nearly the
// sample rate
//
end_time = cyg_current_time();
if ((end_time - start_time) >= 100)
{
start_time = end_time;
diag_printf("%d\t %d\t %d\t %d\t %d\t %d\t %d\t %d\n",
sample_cnt[0],
sample_cnt[1],
sample_cnt[2],
sample_cnt[3],
sample_cnt[4],
sample_cnt[5],
sample_cnt[6],
sample_cnt[7]);
seconds++;
} // if ((end_time - start_time) >= 100)
} while (seconds < 10);
//
// Now stop all channels
//
for (i = 0; i < 8; ++i)
{
if (handle[i])
{
res = cyg_io_set_config(handle[i],
CYG_IO_SET_CONFIG_ADC_DISABLE,
0,
0);
if (ENOERR != res)
{
CYG_TEST_FAIL_FINISH("Error disabling ADC channel");
}
} // if (handle[i])
}
end_time = cyg_current_time();
end_time = seconds * 1000 + (end_time - start_time) * 10;
final_seconds = end_time / 1000.0;
//
// Now read all remaining samples from buffer
//
for (i = 0; i < 8; ++i)
{
if (handle[i])
{
do
{
cyg_adc_sample_t sample;
cyg_uint32 len = sizeof(sample);
res = cyg_io_read( handle[i], &sample, &len );
if (ENOERR == res)
{
sample_cnt[i]++;
}
} while (ENOERR == res);
} // if (handle[i])
}
diag_printf("\n\n----------------------------------------\n");
samples_expected = final_seconds * CYGNUM_DEVS_ADC_ARM_LPC24XX_DEFAULT_RATE;
diag_printf("Samples expected after %d milliseconds: %d\n",
end_time, samples_expected);
diag_printf("Samples read (per channel):\n");
diag_printf("%d\t %d\t %d\t %d\t %d\t %d\t %d\t %d\n",
sample_cnt[0],
sample_cnt[1],
sample_cnt[2],
sample_cnt[3],
sample_cnt[4],
sample_cnt[5],
sample_cnt[6],
sample_cnt[7]);
CYG_TEST_PASS_FINISH("ADC test OK");
}
