int bus_write(struct bus_t *self_p,
int id,
const void *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(buf_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
int number_of_receivers;
struct bus_listener_t *curr_p;
rwlock_reader_take(&self_p->rwlock);
curr_p = (struct bus_listener_t *)binary_tree_search(
&self_p->listeners, id);
number_of_receivers = 0;
while (curr_p != NULL) {
((struct chan_t *)curr_p->chan_p)->write(curr_p->chan_p,
buf_p,
size);
number_of_receivers++;
curr_p = curr_p->next_p;
}
rwlock_reader_give(&self_p->rwlock);
return (number_of_receivers);
}
ssize_t settings_write_by_name(const char *name_p,
const void *src_p,
size_t size)
{
ASSERTN(name_p != NULL, EINVAL);
ASSERTN(src_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
const FAR struct setting_t *setting_p;
/* Find the setting in the settings array. */
setting_p = &settings[0];
while (setting_p->name_p != NULL) {
if (std_strcmp(name_p, setting_p->name_p) == 0) {
if (size > setting_p->size) {
return (-1);
}
return (settings_write(setting_p->address, src_p, size));
}
setting_p++;
}
return (-1);
}
int spi_init(struct spi_driver_t *self_p,
struct spi_device_t *dev_p,
struct pin_device_t *ss_pin_p,
int mode,
int speed,
int polarity,
int phase)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(dev_p != NULL, EINVAL);
ASSERTN(ss_pin_p != NULL, EINVAL);
self_p->dev_p = dev_p;
self_p->mode = mode;
self_p->speed = speed;
self_p->polarity = polarity;
self_p->phase = phase;
return (spi_port_init(self_p,
dev_p,
ss_pin_p,
mode,
speed,
polarity,
phase));
}
int queue_init(struct queue_t *self_p,
void *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN((buf_p == NULL)
|| ((buf_p != NULL) && (size > 0)), EINVAL);
chan_init(&self_p->base,
(chan_read_fn_t)queue_read,
(chan_write_fn_t)queue_write,
(chan_size_fn_t)queue_size);
chan_set_write_isr_cb(&self_p->base, (chan_write_fn_t)queue_write_isr);
self_p->buffer.begin_p = buf_p;
self_p->buffer.read_p = buf_p;
self_p->buffer.write_p = buf_p;
self_p->buffer.end_p = &((char*)buf_p)[size];
self_p->buffer.size = size;
self_p->state = QUEUE_STATE_INITIALIZED;
self_p->buf_p = NULL;
self_p->size = 0;
self_p->left = 0;
return (0);
}
int heap_free(struct heap_t *self_p,
void *buf_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(buf_p != NULL, EINVAL);
int count;
struct heap_buffer_header_t *header_p;
header_p = &((struct heap_buffer_header_t *)buf_p)[-1];
sys_lock();
if (header_p->count > 0) {
header_p->count--;
count = header_p->count;
/* Free when count is zero. */
if (count == 0) {
if (header_p->u.fixed_p != NULL) {
count = free_fixed_size(self_p, header_p);
} else {
count = free_dynamic_buffer(self_p, header_p);
}
}
} else {
count = -1;
}
sys_unlock();
return (count);
}
int http_server_init(struct http_server_t *self_p,
struct http_server_listener_t *listener_p,
struct http_server_connection_t *connections_p,
const char *root_path_p,
const struct http_server_route_t *routes_p,
http_server_route_callback_t on_no_route)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(listener_p != NULL, EINVAL)
ASSERTN(connections_p != NULL, EINVAL);
ASSERTN(routes_p != NULL, EINVAL);
ASSERTN(on_no_route != NULL, EINVAL);
struct http_server_connection_t *connection_p;
self_p->listener_p = listener_p;
self_p->connections_p = connections_p;
self_p->root_path_p = root_path_p;
self_p->routes_p = routes_p;
self_p->on_no_route = on_no_route;
connection_p = self_p->connections_p;
while (connection_p->thrd.name_p != NULL) {
connection_p->state = http_server_connection_state_free_t;
connection_p->self_p = self_p;
event_init(&connection_p->events);
connection_p++;
}
event_init(&self_p->events);
return (0);
}
ssize_t event_read(struct event_t *self_p,
void *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(buf_p != NULL, EINVAL);
ASSERTN(size == sizeof(uint32_t), EINVAL);
uint32_t *mask_p, mask;
mask_p = (uint32_t *)buf_p;
sys_lock();
mask = (self_p->mask & *mask_p);
/* Event already set? Otherwise wait for it. */
if (mask != 0) {
*mask_p = mask;
} else {
self_p->base.reader_p = thrd_self();
thrd_suspend_isr(NULL);
*mask_p = (self_p->mask & *mask_p);
}
/* Remove read events from the event channel. */
self_p->mask &= (~(*mask_p));
sys_unlock();
return (size);
}
int pin_write(struct pin_driver_t *self_p, int value)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN((value == 0) || (value == 1), EINVAL);
return (pin_port_write(self_p, value));
}
int network_interface_wifi_init(struct network_interface_wifi_t *self_p,
const char *name_p,
struct network_interface_wifi_driver_t *driver_p,
void *arg_p,
const char *ssid_p,
const char *password_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(name_p != NULL, EINVAL);
ASSERTN(driver_p != NULL, EINVAL);
ASSERTN(ssid_p != NULL, EINVAL);
self_p->network_interface.name_p = name_p;
self_p->network_interface.start =
(network_interface_start_t)network_interface_wifi_start;
self_p->network_interface.stop =
(network_interface_stop_t)network_interface_wifi_stop;
self_p->network_interface.is_up =
(network_interface_is_up_t)network_interface_wifi_is_up;
self_p->network_interface.set_ip_info =
(network_interface_set_ip_info_t)network_interface_wifi_set_ip_info;
self_p->network_interface.get_ip_info =
(network_interface_get_ip_info_t)network_interface_wifi_get_ip_info;
self_p->driver_p = driver_p;
self_p->arg_p = arg_p;
self_p->ssid_p = ssid_p;
self_p->password_p = password_p;
self_p->info_p = NULL;
/* Initialize the driver. */
driver_p->init(arg_p);
return (0);
}
ssize_t settings_read(void *dst_p, size_t src, size_t size)
{
ASSERTN(dst_p != NULL, EINVAL);
ASSERTN(src >= 0, EINVAL);
ASSERTN(size > 0, EINVAL);
return (settings_port_read(dst_p, src, size));
}
ssize_t settings_write(size_t dst, const void *src_p, size_t size)
{
ASSERTN(dst >= 0, EINVAL);
ASSERTN(src_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
return (settings_port_write(dst, src_p, size));
}
int network_interface_wifi_get_ip_info(struct network_interface_wifi_t *self_p,
struct inet_if_ip_info_t *info_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(info_p != NULL, EINVAL);
return (self_p->driver_p->get_ip_info(self_p->arg_p, info_p));
}
ssize_t spi_get(struct spi_driver_t *self_p,
uint8_t *data_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(data_p != NULL, EINVAL);
return (spi_read(self_p, data_p, 1));
}
ssize_t spi_read(struct spi_driver_t *self_p,
void *rxbuf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(rxbuf_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
return (spi_transfer(self_p, rxbuf_p, NULL, size));
}
ssize_t can_read(struct can_driver_t *self_p,
struct can_frame_t *frame_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(frame_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
return (queue_read(&self_p->chin, frame_p, size));
}
ssize_t spi_write(struct spi_driver_t *self_p,
const void *txbuf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(txbuf_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
return (spi_transfer(self_p, NULL, txbuf_p, size));
}
int dac_convert(struct dac_driver_t *self_p,
uint32_t *samples_p,
size_t length)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(samples_p != NULL, EINVAL);
ASSERTN(length > 0, EINVAL);
return (dac_port_convert(self_p, samples_p, length));
}
ssize_t can_write(struct can_driver_t *self_p,
const struct can_frame_t *frame_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(frame_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
return (chan_write(&self_p->base, frame_p, size));
}
ssize_t spi_transfer(struct spi_driver_t *self_p,
void *rxbuf_p,
const void *txbuf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN((rxbuf_p != NULL) || (txbuf_p != NULL), EINVAL);
ASSERTN(size > 0, EINVAL);
return(spi_port_transfer(self_p, rxbuf_p, txbuf_p, size));
}
int pin_init(struct pin_driver_t *self_p,
struct pin_device_t *dev_p,
int mode)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(dev_p != NULL, EINVAL);
self_p->dev_p = dev_p;
return (pin_port_init(self_p, dev_p, mode));
}
ssize_t usb_device_write_isr(struct usb_device_driver_t *self_p,
int endpoint,
const void *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, INVAL);
ASSERTN(endpoint > 0, INVAL);
ASSERTN(buf_p != NULL, INVAL);
ASSERTN(size > 0, INVAL);
return (usb_device_port_write_isr(self_p, endpoint, buf_p, size));
}
int configfile_init(struct configfile_t *self_p,
char *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(buf_p != NULL, EINVAL);
ASSERTN(size > 0, EINVAL);
self_p->buf_p = buf_p;
self_p->size = size;
return (0);
}
int bus_listener_init(struct bus_listener_t *self_p,
int id,
void *chan_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(chan_p != NULL, EINVAL);
self_p->base.key = id;
self_p->id = id;
self_p->chan_p = chan_p;
self_p->next_p = NULL;
return (0);
}
ssize_t event_write(struct event_t *self_p,
const void *buf_p,
size_t size)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(buf_p != NULL, EINVAL);
ASSERTN(size == sizeof(uint32_t), EINVAL);
sys_lock();
size = event_write_isr(self_p, buf_p, size);
sys_unlock();
return (size);
}
int dac_init(struct dac_driver_t *self_p,
struct dac_device_t *dev_p,
struct pin_device_t *pin0_dev_p,
struct pin_device_t *pin1_dev_p,
int sampling_rate)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(sampling_rate > 0, EINVAL);
return (dac_port_init(self_p,
dev_p,
pin0_dev_p,
pin1_dev_p,
sampling_rate));
}
int hash_map_add(struct hash_map_t *self_p,
long key,
void *value_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(value_p != NULL, EINVAL);
int hash;
struct hash_map_bucket_t *bucket_p;
struct hash_map_entry_t *entry_p;
/* Hash key. */
hash = self_p->hash(key);
hash %= self_p->buckets_max;
bucket_p = &self_p->buckets_p[hash];
/* Is the key already in map? */
if (bucket_p->list_p != NULL) {
entry_p = bucket_p->list_p;
while (entry_p != NULL) {
if (entry_p->key == key) {
entry_p->value_p = value_p;
return (0);
}
entry_p = entry_p->next_p;
}
}
/* Allocate new entry. */
entry_p = entry_alloc(self_p);
if (entry_p == NULL) {
return (-ENOMEM);
}
/* Initiate entry.*/
entry_p->key = key;
entry_p->value_p = value_p;
/* Insert in list. */
entry_p->next_p = bucket_p->list_p;
bucket_p->list_p = entry_p;
return (0);
}
void *hash_map_get(struct hash_map_t *self_p,
long key)
{
ASSERTN(self_p != NULL, EINVAL);
int hash;
struct hash_map_bucket_t *bucket_p;
struct hash_map_entry_t *entry_p;
/* Hash key. */
hash = self_p->hash(key);
hash %= self_p->buckets_max;
bucket_p = &self_p->buckets_p[hash];
/* Search for key. */
if (bucket_p->list_p != NULL) {
entry_p = bucket_p->list_p;
while (entry_p != NULL) {
if (entry_p->key == key) {
return (entry_p->value_p);
}
entry_p = entry_p->next_p;
}
}
return (NULL);
}
int http_server_start(struct http_server_t *self_p)
{
ASSERTN(self_p != NULL, EINVAL);
struct http_server_connection_t *connection_p;
/* Spawn the listener thread. */
self_p->listener_p->thrd.id_p =
thrd_spawn(listener_main,
self_p,
0,
self_p->listener_p->thrd.stack.buf_p,
self_p->listener_p->thrd.stack.size);
connection_p = self_p->connections_p;
/* Spawn the connection threads. */
while (connection_p->thrd.stack.buf_p != NULL) {
connection_p->thrd.id_p =
thrd_spawn(connection_main,
connection_p,
0,
connection_p->thrd.stack.buf_p,
connection_p->thrd.stack.size);
connection_p++;
}
return (0);
}
ssize_t spi_put(struct spi_driver_t *self_p,
uint8_t data)
{
ASSERTN(self_p != NULL, EINVAL);
return (spi_write(self_p, &data, 1));
}
int usb_device_start(struct usb_device_driver_t *self_p)
{
ASSERTN(self_p != NULL, INVAL);
module.driver_p = self_p;
return (usb_device_port_start(self_p));
}
