void
cyg_spi_transaction_tick(cyg_spi_device* device, cyg_bool polled, cyg_uint32 count)
{
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_ASSERT(bus->spi_current_device == device, "SPI ticks requested without claiming the bus");
CYG_CHECK_FUNC_PTR(bus->spi_transaction_tick, "SPI device has not provided a tick function");
(*(bus->spi_transaction_tick))(device, polled, count);
}
void
cyg_spi_transaction_transfer(cyg_spi_device* device, cyg_bool polled,
cyg_uint32 count, const cyg_uint8* tx_data, cyg_uint8* rx_data,
cyg_bool drop_cs)
{
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_ASSERT(bus->spi_current_device == device, "SPI transfer requested without claiming the bus");
CYG_CHECK_FUNC_PTR(bus->spi_transaction_transfer, "SPI device has not provided a transfer function");
(*(bus->spi_transaction_transfer))(device, polled, count, tx_data, rx_data, drop_cs);
}
void
usbs_start_tx(usbs_tx_endpoint* endpoint)
{
CYG_CHECK_DATA_PTR( endpoint, "A valid USB endpoint must be supplied");
CYG_CHECK_FUNC_PTR( endpoint->start_tx_fn, "The USB endpoint must support receive operations");
(*endpoint->start_tx_fn)(endpoint);
}
void
usbs_set_tx_endpoint_halted(usbs_tx_endpoint* endpoint, cyg_bool halted)
{
CYG_CHECK_DATA_PTR( endpoint, "A valid USB endpoint must be supplied");
CYG_CHECK_FUNC_PTR( endpoint->set_halted_fn, "The USB endpoint should have a set-halted function");
(*endpoint->set_halted_fn)(endpoint, halted);
}
static int
fatfs_get_attrib(cyg_mtab_entry *mte,
cyg_dir dir,
const char *name,
cyg_fs_attrib_t * const file_attrib)
{
fatfs_disk_t *disk = (fatfs_disk_t *) mte->data;
fatfs_dirsearch_t ds;
int err;
CYG_TRACE4(TFS, "get_attrib mte=%p dir=%p name='%s' buf=%x",
mte, dir, name, file_attrib);
init_dirsearch(&ds, disk, (fatfs_node_t *) dir, name);
err = fatfs_find(&ds);
if (err != ENOERR)
return err;
// Get the attribute field
CYG_CHECK_DATA_PTR(file_attrib,"Invalid destination attribute pointer");
*file_attrib = ds.node->dentry.attrib;
return ENOERR;
}
// set_config is basically just a clone of the above, but using a different
// bus-specific operation.
int
cyg_spi_set_config(cyg_spi_device* device, cyg_uint32 key, const void* buf, cyg_uint32* len)
{
int result;
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_CHECK_FUNC_PTR(bus->spi_set_config, "SPI bus driver has not provided a set_config function");
while (!cyg_drv_mutex_lock(&(bus->spi_lock)));
result = (*(bus->spi_set_config))(device, key, buf, len);
cyg_drv_mutex_unlock(&(bus->spi_lock));
return result;
}
void
cyg_spi_transaction_end(cyg_spi_device* device)
{
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_ASSERT(bus->spi_current_device == device, "SPI transfer requested without claiming the bus");
CYG_CHECK_FUNC_PTR(bus->spi_transaction_end, "SPI device has not provided an end function");
// First, call the bus' end function.
(*(bus->spi_transaction_end))(device);
// Then release the SPI bus for other threads.
cyg_drv_mutex_unlock(&(bus->spi_lock));
}
Cyg_ErrNo
usbs_devtab_cwrite(cyg_io_handle_t handle, const void* buf, cyg_uint32* size)
{
usbs_callback_data wait;
cyg_devtab_entry_t* devtab_entry;
usbs_tx_endpoint* endpoint;
int result = ENOERR;
CYG_REPORT_FUNCTION();
wait.completed = 0;
cyg_drv_mutex_init(&wait.lock);
cyg_drv_cond_init(&wait.signal, &wait.lock);
devtab_entry = (cyg_devtab_entry_t*) handle;
CYG_CHECK_DATA_PTR( devtab_entry, "A valid endpoint must be supplied");
endpoint = (usbs_tx_endpoint*) devtab_entry->priv;
CYG_CHECK_DATA_PTR( endpoint, "The handle must correspond to a USB endpoint");
CYG_CHECK_FUNC_PTR( endpoint->start_tx_fn, "The endpoint must have a start_tx function");
endpoint->buffer = (unsigned char*) buf;
endpoint->buffer_size = (int) *size;
endpoint->complete_fn = &usbs_devtab_callback;
endpoint->complete_data = (void*) &wait;
(*endpoint->start_tx_fn)(endpoint);
cyg_drv_mutex_lock(&wait.lock);
cyg_drv_dsr_lock();
while (!wait.completed) {
cyg_drv_cond_wait(&wait.signal);
}
cyg_drv_dsr_unlock();
cyg_drv_mutex_unlock(&wait.lock);
if (wait.result < 0) {
result = wait.result;
} else {
*size = wait.result;
}
cyg_drv_cond_destroy(&wait.signal);
cyg_drv_mutex_destroy(&wait.lock);
CYG_REPORT_RETURN();
return result;
}
void
usbs_start(usbs_control_endpoint* endpoint)
{
CYG_CHECK_DATA_PTR( endpoint, "A valid USB endpoint must be supplied");
CYG_CHECK_FUNC_PTR( endpoint->start_fn, "The USB endpoint should have a start function");
(*endpoint->start_fn)(endpoint);
}
/* Initialise the resolver. Open a socket and bind it to the address
of the server. return -1 if something goes wrong, otherwise 0. If
we are being called a second time we have to be careful to allow
any ongoing lookups to finish before we close the socket and
connect to a different DNS server. The danger here is that we may
have to wait for upto 32 seconds if the DNS server is down.
*/
int
cyg_dns_res_init(struct in_addr *dns_server)
{
struct sockaddr_in server;
struct servent *sent;
static int init =0;
CYG_REPORT_FUNCNAMETYPE( "cyg_dns_res_init", "returning %d" );
CYG_REPORT_FUNCARG1( "dns_server=%08x", dns_server );
CYG_CHECK_DATA_PTR( dns_server, "dns_server is not a valid pointer!" );
if (init) {
cyg_drv_mutex_lock(&dns_mutex);
cyg_thread_free_data_index(ptdindex);
if (s >= 0) {
close(s);
}
} else {
init = 1;
cyg_drv_mutex_init(&dns_mutex);
cyg_drv_mutex_lock(&dns_mutex);
}
s = socket(PF_INET, SOCK_DGRAM, 0);
if (s < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( -1 );
return -1;
}
sent = getservbyname("domain", "udp");
if (sent == (struct servent *)0) {
s = -1;
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( -1 );
return -1;
}
memcpy((char *)&server.sin_addr, (const void *)dns_server, sizeof(server.sin_addr));
server.sin_port = sent->s_port;
server.sin_family = AF_INET;
server.sin_len = sizeof(server);
if (connect(s, (struct sockaddr *)&server, sizeof(server)) < 0) {
s = -1;
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( -1 );
return -1;
}
ptdindex = cyg_thread_new_data_index();
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( 0 );
return 0;
}
// transaction-begin involves getting sole access to the bus, then calling
// the bus driver's begin function to set up the hardware appropriately for
// the target device.
void
cyg_spi_transaction_begin(cyg_spi_device* device)
{
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_CHECK_FUNC_PTR(bus->spi_transaction_begin, "SPI device has not provided a transaction_begin function");
while (!cyg_drv_mutex_lock(&(bus->spi_lock)));
#ifdef CYGDBG_USE_ASSERTS
bus->spi_current_device = device;
#endif
// This thread now has exclusive access to the bus
(*(bus->spi_transaction_begin))(device);
// All done. Return with the bus still locked.
}
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;
}
// A variant of the above which returns immediately if some other thread
// is using the bus.
cyg_bool
cyg_spi_transaction_begin_nb(cyg_spi_device* device)
{
cyg_bool result = false;
cyg_spi_bus* bus;
CYG_CHECK_DATA_PTR(device, "valid SPI device pointer required");
bus = device->spi_bus;
CYG_CHECK_DATA_PTR(bus, "SPI device does not point at a valid bus structure");
CYG_CHECK_FUNC_PTR(bus->spi_transaction_begin, "SPI device has not provided a transaction_begin function");
if (cyg_drv_mutex_trylock(&(bus->spi_lock))) {
#ifdef CYGDBG_USE_ASSERTS
bus->spi_current_device = device;
#endif
(*(bus->spi_transaction_begin))(device);
result = true;
}
return result;
}
void
usbs_start_tx_buffer(usbs_tx_endpoint* endpoint,
const unsigned char* buf, int size,
void (*callback_fn)(void*, int), void *callback_arg)
{
CYG_CHECK_DATA_PTR( endpoint, "A valid USB endpoint must be supplied");
CYG_CHECK_FUNC_PTR( endpoint->start_tx_fn, "The USB endpoint must support receive operations");
endpoint->buffer = buf;
endpoint->buffer_size = size;
endpoint->complete_fn = callback_fn;
endpoint->complete_data = callback_arg;
(*endpoint->start_tx_fn)(endpoint);
}
/* Send the query to the server and read the response back. Return -1
if it fails, otherwise put the response back in msg and return the
length of the response. */
static int
send_recv(char * msg, int len, int msglen)
{
struct dns_header *dns_hdr;
struct timeval timeout;
int finished = false;
int backoff = 2;
fd_set readfds;
int written;
int ret;
CYG_REPORT_FUNCNAMETYPE( "send_recv", "returning %d" );
CYG_REPORT_FUNCARG3( "msg=%08x, len=%d, msglen", msg, len, msglen );
CYG_CHECK_DATA_PTR( msg, "msg is not a valid pointer!" );
dns_hdr = (struct dns_header *) msg;
do {
written = write(s, msg, len);
if (written < 0 || (written!=len)) {
ret = -1;
break;
}
FD_ZERO(&readfds);
FD_SET(s, &readfds);
timeout.tv_sec = backoff;
timeout.tv_usec = 0;
backoff = backoff << 1;
ret = select(s+1, &readfds, NULL, NULL, &timeout);
if (ret < 0) {
ret = -1;
break;
}
/* Timeout */
if (ret == 0) {
if (backoff > 16) {
h_errno = TRY_AGAIN;
ret = -1;
break;
}
}
if (ret == 1) {
ret = read(s, msg, msglen);
if (ret < 0) {
ret = -1;
break;
}
/* Reply to an old query. Ignore it */
if (ntohs(dns_hdr->id) != (id-1)) {
continue;
}
finished = true;
}
} while (!finished);
CYG_REPORT_RETVAL( ret );
return ret;
}
cyg_bool
usbs_tx_endpoint_halted(usbs_tx_endpoint* endpoint)
{
CYG_CHECK_DATA_PTR( endpoint, "A valid USB endpoint must be supplied");
return endpoint->halted;
}
