void
fatfs_node_rehash(fatfs_disk_t *disk, fatfs_node_t *node)
{
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(node);
if (!node_hash_remove_keyless(&disk->node_hash, node))
CYG_ASSERT(false, "node not in hash");
if (!node_hash_add(&disk->node_hash, node))
CYG_ASSERT(false, "node already in hash");
SANITY_CHECK();
}
extern speed_t
cfgetospeed( const struct termios *termios_p )
{
CYG_REPORT_FUNCTYPE( "returning speed code %d" );
CYG_CHECK_DATA_PTRC( termios_p );
CYG_REPORT_FUNCARG1XV( termios_p );
CYG_REPORT_RETVAL( termios_p->c_ospeed );
return termios_p->c_ospeed;
} // cfgetospeed()
void
fatfs_node_free(fatfs_disk_t *disk, fatfs_node_t *node)
{
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(node);
CYG_TRACE2(TNC, "node='%s' refcnt=%d", node->dentry.filename, node->refcnt);
CYG_ASSERTC(node->refcnt == 0);
CYG_ASSERTC(node != disk->root);
// Remove from dead list, from hash and free ptr
node_list_remove(&disk->dead_nlist, node);
if (!node_hash_remove(&disk->node_hash, node))
CYG_ASSERT(false, "node not in hash");
node_pool_free(disk, node);
SANITY_CHECK();
}
fatfs_node_t*
fatfs_node_find(fatfs_disk_t *disk,
const char *name,
unsigned int namelen,
unsigned int parent_cluster)
{
fatfs_node_t *node;
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(name);
node = node_hash_find(&disk->node_hash, name, namelen, parent_cluster);
NODE_FIND_CHECK();
CYG_TRACE3(TNC, "node name=%s pcluster=%d %s found in cache\n",
name, parent_cluster, ((node != NULL) ? "" : "not"));
return node;
}
void
fatfs_node_ref(fatfs_disk_t *disk, fatfs_node_t *node)
{
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(node);
CYG_TRACE2(TNC, "node='%s' refcnt=%d", node->dentry.filename, node->refcnt);
node->refcnt++;
if (1 == node->refcnt)
{
// First reference - move node from dead to live list
CYG_TRACE1(TNC, "node='%s' to live list", node->dentry.filename);
node_list_remove(&disk->dead_nlist, node);
node_list_head_add(&disk->live_nlist, node);
}
SANITY_CHECK();
}
void
fatfs_node_touch(fatfs_disk_t *disk, fatfs_node_t *node)
{
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(node);
CYG_TRACE2(TNC, "node='%s' refcnt=%d", node->dentry.filename, node->refcnt);
if (node->refcnt == 0)
{
node_list_remove(&disk->dead_nlist, node);
node_list_head_add(&disk->dead_nlist, node);
}
else
{
node_list_remove(&disk->live_nlist, node);
node_list_head_add(&disk->live_nlist, node);
}
SANITY_CHECK();
}
fatfs_node_t*
fatfs_node_alloc(fatfs_disk_t *disk, fatfs_dir_entry_t *dentry)
{
fatfs_node_t *node;
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(dentry);
node = node_pool_alloc(disk);
if (NULL == node)
{
CYG_TRACE2(TNC, "getting node from dead list (size=%d keep=%d)",
node_list_get_size(&disk->dead_nlist), DLIST_KEEP_NUM);
if (node_list_get_size(&disk->dead_nlist) <= DLIST_KEEP_NUM)
return NULL;
node = node_list_tail_get(&disk->dead_nlist);
if (NULL == node)
return NULL;
CYG_TRACE1(TNC, "recycling node='%s'", node->dentry.filename);
node_list_remove(&disk->dead_nlist, node);
if (!node_hash_remove(&disk->node_hash, node))
CYG_ASSERT(false, "node not in hash");
}
// Init new node
node->dentry = *dentry;
node->refcnt = 0;
node_list_head_add(&disk->dead_nlist, node);
if (!node_hash_add(&disk->node_hash, node))
CYG_ASSERT(false, "node already in hash");
SANITY_CHECK();
return node;
}
int main(int argc, char** argv)
{
CYG_ASSERT( true, message);
CYG_ASSERT( false, message);
CYG_ASSERTC(true);
CYG_ASSERTC(false);
CYG_FAIL(message);
CYG_CHECK_DATA_PTR( &argc, message);
CYG_CHECK_DATA_PTR( 0, message);
CYG_CHECK_FUNC_PTR( &main, message);
CYG_CHECK_FUNC_PTR( 0, message);
CYG_CHECK_DATA_PTRC(&argc);
CYG_CHECK_DATA_PTRC(0);
CYG_CHECK_FUNC_PTRC(&main);
CYG_CHECK_FUNC_PTRC(0);
CYG_PRECONDITION(true, message);
CYG_PRECONDITION(false, message);
CYG_PRECONDITIONC(true);
CYG_PRECONDITIONC(false);
CYG_POSTCONDITION(true, message);
CYG_POSTCONDITION(false, message);
CYG_POSTCONDITIONC(true);
CYG_POSTCONDITIONC(false);
CYG_LOOP_INVARIANT(true, message);
CYG_LOOP_INVARIANT(false, message);
CYG_LOOP_INVARIANTC(true);
CYG_LOOP_INVARIANTC(false);
CYG_INVARIANT(true, message);
CYG_INVARIANT(false, message);
CYG_INVARIANTC(true);
CYG_INVARIANTC(false);
CYG_TEST_PASS_FINISH("disabled assertions in C code do nothing");
return 0;
}
void
fatfs_node_unref(fatfs_disk_t *disk, fatfs_node_t *node)
{
CYG_CHECK_DATA_PTRC(disk);
CYG_CHECK_DATA_PTRC(node);
CYG_TRACE2(TNC, "node='%s' refcnt=%d", node->dentry.filename, node->refcnt);
CYG_ASSERT(node->refcnt > 0, "node->refcnt <= 0");
node->refcnt--;
if (0 == node->refcnt)
{
// No more references - move node from live to dead list
CYG_TRACE1(TNC, "node='%s' to dead list", node->dentry.filename);
node_list_remove(&disk->live_nlist, node);
node_list_head_add(&disk->dead_nlist, node);
}
SANITY_CHECK();
}
void
fatfs_node_cache_init(fatfs_disk_t *disk)
{
CYG_CHECK_DATA_PTRC(disk);
node_list_init(&disk->live_nlist);
node_list_init(&disk->dead_nlist);
node_hash_init(&disk->node_hash);
node_pool_init(disk);
SANITY_CHECK();
}
extern int
tcsetattr( int fildes, int optact, const struct termios *termios_p )
{
cyg_file *fp;
int ret;
setattr_struct attr;
int len = sizeof( attr );
CYG_REPORT_FUNCTYPE( "returning %d" );
CYG_REPORT_FUNCARG3( "fildes=%d, optact=%d, termios_p=%08x",
fildes, optact, termios_p );
CYG_CHECK_DATA_PTRC( termios_p );
if ( !isatty(fildes) ) {
errno = ENOTTY;
CYG_REPORT_RETVAL( -1 );
return -1;
}
if ( (optact != TCSANOW) && (optact != TCSADRAIN) &&
(optact != TCSAFLUSH) ) {
errno = EINVAL;
CYG_REPORT_RETVAL( -1 );
return -1;
}
fp = cyg_fp_get( fildes );
if ( NULL == fp ) {
errno = EBADF;
CYG_REPORT_RETVAL( -1 );
return -1;
}
attr.termios_p = termios_p;
attr.optact = optact;
ret = fp->f_ops->fo_setinfo( fp, CYG_IO_SET_CONFIG_TERMIOS, &attr,
len);
cyg_fp_free( fp );
if ( ret > 0 ) {
errno = ret;
CYG_REPORT_RETVAL( -1 );
return -1;
}
CYG_REPORT_RETVAL( 0 );
return 0;
} // tcsetattr()
extern int
cfsetispeed( struct termios *termios_p, speed_t speed )
{
CYG_REPORT_FUNCTYPE( "returning %d" );
CYG_CHECK_DATA_PTRC( termios_p );
CYG_REPORT_FUNCARG2( "termios_p=%08x, speed=%d", termios_p, speed );
if ( speed > B115200 ) {
errno = EINVAL;
CYG_REPORT_RETVAL( -1 );
return -1;
}
termios_p->c_ispeed = speed;
CYG_REPORT_RETVAL( 0 );
return 0;
} // cfsetispeed()
extern int
tcgetattr( int fildes, struct termios *termios_p )
{
cyg_file *fp;
int ret;
int len = sizeof( *termios_p );
CYG_REPORT_FUNCTYPE( "returning %d" );
CYG_REPORT_FUNCARG2( "fildes=%d, termios_p=%08x", fildes, termios_p );
CYG_CHECK_DATA_PTRC( termios_p );
if ( !isatty(fildes) ) {
errno = ENOTTY;
CYG_REPORT_RETVAL( -1 );
return -1;
}
fp = cyg_fp_get( fildes );
if ( NULL == fp ) {
errno = EBADF;
CYG_REPORT_RETVAL( -1 );
return -1;
}
ret = fp->f_ops->fo_getinfo( fp, CYG_IO_GET_CONFIG_TERMIOS, termios_p,
len);
cyg_fp_free( fp );
if ( ret > 0 ) {
errno = ret;
CYG_REPORT_RETVAL( -1 );
return -1;
}
CYG_REPORT_RETVAL( 0 );
return 0;
} // tcgetattr()
static Cyg_ErrNo
real_termios_init( struct termios_private_info *priv )
{
Cyg_ErrNo res;
struct termios *t;
cyg_serial_info_t dev_conf;
cyg_serial_buf_info_t dev_buf_conf;
cyg_uint32 len = sizeof( dev_conf );
CYG_REPORT_FUNCTYPE("returning %d");
CYG_REPORT_FUNCARG1XV( priv );
CYG_CHECK_DATA_PTRC( priv );
t = &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 ) {
len = sizeof( dev_buf_conf );
res = cyg_io_get_config( priv->dev_handle,
CYG_IO_GET_CONFIG_SERIAL_BUFFER_INFO,
&dev_buf_conf, &len );
}
priv->errbuf = (cyg_uint8 *)malloc( dev_buf_conf.rx_bufsize );
if ( NULL == priv->errbuf )
res = ENOMEM; // FIXME: Are we allowed to do this?
priv->errbufpos = priv->errbuf;
priv->errbufsize = dev_buf_conf.rx_bufsize;
if ( ENOERR != res ) {
CYG_REPORT_RETVAL( res );
return res;
}
// we only support symmetric baud rates
t->c_ispeed = t->c_ospeed = map_ecosbaud_to_posixbaud( dev_conf.baud );
t->c_iflag = C_IFLAG_INIT;
t->c_oflag = C_OFLAG_INIT;
t->c_cflag = C_CFLAG_INIT;
t->c_lflag = C_LFLAG_INIT;
memcpy( t->c_cc, c_cc_init, sizeof( t->c_cc ) );
switch ( dev_conf.parity ) {
case CYGNUM_SERIAL_PARITY_NONE:
t->c_iflag |= IGNPAR;
break;
case CYGNUM_SERIAL_PARITY_ODD:
t->c_cflag |= PARODD;
// DROPTHROUGH
case CYGNUM_SERIAL_PARITY_EVEN:
t->c_iflag |= PARENB;
break;
default:
CYG_FAIL( "Unsupported default parity" );
break;
}
switch( dev_conf.word_length ) {
case CYGNUM_SERIAL_WORD_LENGTH_5:
t->c_cflag |= CS5;
break;
case CYGNUM_SERIAL_WORD_LENGTH_6:
t->c_cflag |= CS6;
break;
case CYGNUM_SERIAL_WORD_LENGTH_7:
t->c_cflag |= CS7;
break;
case CYGNUM_SERIAL_WORD_LENGTH_8:
t->c_cflag |= CS8;
break;
default:
CYG_FAIL( "Unsupported word length" );
break;
}
switch ( dev_conf.stop ) {
case CYGNUM_SERIAL_STOP_1:
// Don't need to do anything
break;
case CYGNUM_SERIAL_STOP_2:
t->c_cflag |= CSTOPB;
break;
default:
CYG_FAIL( "Unsupported number of stop bits" );
break;
}
switch ( dev_conf.flags ) {
case CYGNUM_SERIAL_FLOW_RTSCTS_RX:
t->c_cflag |= CRTSCTS;
// drop through
case CYGNUM_SERIAL_FLOW_XONXOFF_RX:
t->c_iflag |= IXOFF;
break;
case CYGNUM_SERIAL_FLOW_RTSCTS_TX:
t->c_cflag |= CRTSCTS;
// drop through
case CYGNUM_SERIAL_FLOW_XONXOFF_TX:
t->c_iflag |= IXON;
break;
default:
// Ignore flags we don't grok
break;
}
return ENOERR;
} // real_termios_init()
