int init_module(void)
{
printk("TESTING RTDM SEMs [LOOPs %d, TIMEOUTs %d (ns)].\n", LOOPS, DELAY);
start_rt_timer(0);
rtdm_sem_init(&sem1, 0);
rtdm_sem_init(&sem2, 0);
rtdm_task_init_cpuid(&stask1, "task1", task1, NULL, 0, 0, 0);
rtdm_task_init_cpuid(&stask2, "task2", task2, NULL, 1, 0, 0);
return 0;
}
static int32_t ctxInit(
struct rtdm_dev_context * ctx) {
struct devCtx * devCtx;
uint32_t i;
int32_t ret;
ret = 0;
devCtx = getDevCtx(
ctx);
for (i = 0u; i < DEF_CHN_COUNT; i++) {
devCtx->chn[i].online = FALSE;
if (TRUE == portChnIsOnline(ctx->device, i)) {
devCtx->chn[i].online = TRUE;
}
}
rtdm_lock_init(&devCtx->lock);
rtdm_sem_init(
&devCtx->actvLock,
1ul);
devCtx->actvCnt = 0u;
ES_DBG_API_OBLIGATION(devCtx->signature = DEF_DEVCTX_SIGNATURE);
return (ret);
}
/***
* rt_socket_init - initialises a new socket structure
*/
int rt_socket_init(struct rtdm_dev_context *sockctx, unsigned short protocol)
{
struct rtsocket *sock = (struct rtsocket *)&sockctx->dev_private;
unsigned int pool_size;
sock->callback_func = NULL;
rtskb_queue_init(&sock->incoming);
sock->timeout = 0;
rtdm_lock_init(&sock->param_lock);
rtdm_sem_init(&sock->pending_sem, 0);
pool_size = rt_bare_socket_init(sock, protocol,
RTSKB_PRIO_VALUE(SOCK_DEF_PRIO,
RTSKB_DEF_RT_CHANNEL),
socket_rtskbs);
sock->pool_size = pool_size;
mutex_init(&sock->pool_nrt_lock);
if (pool_size < socket_rtskbs) {
/* fix statistics */
if (pool_size == 0)
rtskb_pools--;
rt_socket_cleanup(sockctx);
return -ENOMEM;
}
return 0;
}
void rtcan_socket_init(struct rtdm_dev_context *context)
{
struct rtcan_socket *sock = (struct rtcan_socket *)&context->dev_private;
rtdm_lockctx_t lock_ctx;
rtdm_sem_init(&sock->recv_sem, 0);
sock->recv_head = 0;
sock->recv_tail = 0;
atomic_set(&sock->ifindex, 0);
sock->flistlen = RTCAN_SOCK_UNBOUND;
sock->flist = NULL;
sock->err_mask = 0;
sock->rx_buf_full = 0;
#ifdef CONFIG_XENO_DRIVERS_CAN_LOOPBACK
sock->loopback = 1;
#endif
sock->tx_timeout = RTDM_TIMEOUT_INFINITE;
sock->rx_timeout = RTDM_TIMEOUT_INFINITE;
INIT_LIST_HEAD(&sock->tx_wait_head);
rtdm_lock_get_irqsave(&rtcan_recv_list_lock, lock_ctx);
list_add(&sock->socket_list, &rtcan_socket_list);
rtdm_lock_put_irqrestore(&rtcan_recv_list_lock, lock_ctx);
}
/***
* rt_socket_init - initialises a new socket structure
*/
int __rt_socket_init(struct rtdm_fd *fd, unsigned short protocol,
struct module *module)
{
struct rtsocket *sock = rtdm_fd_to_private(fd);
unsigned int pool_size;
sock->flags = 0;
sock->callback_func = NULL;
rtskb_queue_init(&sock->incoming);
sock->timeout = 0;
rtdm_lock_init(&sock->param_lock);
rtdm_sem_init(&sock->pending_sem, 0);
pool_size = __rt_bare_socket_init(fd, protocol,
RTSKB_PRIO_VALUE(SOCK_DEF_PRIO,
RTSKB_DEF_RT_CHANNEL),
socket_rtskbs, module);
sock->pool_size = pool_size;
mutex_init(&sock->pool_nrt_lock);
if (pool_size < socket_rtskbs) {
/* fix statistics */
if (pool_size == 0)
rtskb_pools--;
rt_socket_cleanup(fd);
return -ENOMEM;
}
return 0;
}
int setup_timer_handler(void)
{
int ret = 0;
priv = netdev_priv(get_vlc_dev());
//Get the first packets in the packet ring
rx_packet = get_rx_packet();
tx_packet = get_tx_packet();
//Init semas
rtdm_sem_init(&tx_sem, 1);
rtdm_sem_init(&rx_sem, 1);
//Store the current time
rx_sleep_slot = rtdm_clock_read_monotonic();
tx_sleep_slot = rx_sleep_slot + sleep_increment / 2;
early_late_slot = do_div(sleep_increment, 5);
//Return an error if either is NULL
if(!rx_packet || !tx_packet) goto error;
//Start the rx and tx handler tasks
rtdm_task_init(&rx_handler_task, "VLC rx handler", rx_handler,
NULL, RTDM_TASK_HIGHEST_PRIORITY, 0);
if(ret) goto error;
rtdm_task_init(&tx_handler_task, "VLC tx handler", tx_handler,
NULL, RTDM_TASK_HIGHEST_PRIORITY, 0);
if(ret) goto error;
return 0;
error:
rtdm_task_destroy(&rx_handler_task);
rtdm_task_destroy(&tx_handler_task);
return -1;
}
/* ************************************************************************
* ************************************************************************
* I N I T
* ************************************************************************
* ************************************************************************ */
static int __init rtnetproxy_init_module(void)
{
int err;
/* Initialize the proxy's rtskb pool (JK) */
if (rtskb_pool_init(&rtskb_pool, proxy_rtskbs) < proxy_rtskbs) {
rtskb_pool_release(&rtskb_pool);
return -ENOMEM;
}
dev_rtnetproxy.init = rtnetproxy_init;
SET_MODULE_OWNER(&dev_rtnetproxy);
/* Define the name for this unit */
err=dev_alloc_name(&dev_rtnetproxy,"rtproxy");
if(err<0) {
rtskb_pool_release(&rtskb_pool);
return err;
}
err = register_netdev(&dev_rtnetproxy);
if (err<0) {
rtskb_pool_release(&rtskb_pool);
return err;
}
/* Initialize the ringbuffers: */
memset(&ring_rtskb_kernel_rtnet, 0, sizeof(ring_rtskb_kernel_rtnet));
memset(&ring_rtskb_rtnet_kernel, 0, sizeof(ring_rtskb_rtnet_kernel));
memset(&ring_skb_kernel_rtnet, 0, sizeof(ring_skb_kernel_rtnet));
memset(&ring_skb_rtnet_kernel, 0, sizeof(ring_skb_rtnet_kernel));
/* Init the task for transmission */
rtdm_sem_init(&rtnetproxy_sem, 0);
rtdm_task_init(&rtnetproxy_thread, "rtnetproxy",
rtnetproxy_transmit_thread, 0,
RTDM_TASK_LOWEST_PRIORITY, 0);
/* Register srq */
rtdm_nrtsig_init(&rtnetproxy_signal, rtnetproxy_signal_handler);
/* rtNet stuff: */
rt_ip_register_fallback(rtnetproxy_recv);
printk("rtnetproxy installed as \"%s\"\n", dev_rtnetproxy.name);
return 0;
}
struct rtcan_device *rtcan_dev_alloc(int sizeof_priv, int sizeof_board_priv)
{
struct rtcan_device *dev;
struct rtcan_recv *recv_list_elem;
int alloc_size;
int j;
alloc_size = sizeof(*dev) + sizeof_priv + sizeof_board_priv;
dev = (struct rtcan_device *)kmalloc(alloc_size, GFP_KERNEL);
if (dev == NULL) {
printk(KERN_ERR "rtcan: cannot allocate rtcan device\n");
return NULL;
}
memset(dev, 0, alloc_size);
init_MUTEX(&dev->nrt_lock);
rtdm_lock_init(&dev->device_lock);
/* Init TX Semaphore, will be destroyed forthwith
* when setting stop mode */
rtdm_sem_init(&dev->tx_sem, 0);
#ifdef RTCAN_USE_REFCOUNT
atomic_set(&dev->refcount, 0);
#endif
/* Initialize receive list */
dev->empty_list = recv_list_elem = dev->receivers;
for (j = 0; j < RTCAN_MAX_RECEIVERS - 1; j++, recv_list_elem++)
recv_list_elem->next = recv_list_elem + 1;
recv_list_elem->next = NULL;
dev->free_entries = RTCAN_MAX_RECEIVERS;
if (sizeof_priv)
dev->priv = (void *)((unsigned long)dev + sizeof(*dev));
if (sizeof_board_priv)
dev->board_priv = (void *)((unsigned long)dev + sizeof(*dev) + sizeof_priv);
return dev;
}
static int rtdmtest_open(struct rtdm_dev_context *context,
rtdm_user_info_t *user_info, int oflags)
{
struct rtdmtest_context *ctx;
ctx = (struct rtdmtest_context *)context->dev_private;
ctx->event.state = 0;
rtdm_event_init(&ctx->event, 0);
rtdm_sem_init(&ctx->sem, 0);
rtdm_lock_count = 0;
rtdm_mutex_init(&ctx->mutex);
init_MUTEX(&ctx->nrt_mutex);
if (rtdm_nrtsig_init(&ctx->nrtsig, rtdmtest_nrtsig_handler)) {
printk("rtdm_nrtsig_init failed\n");
return -EINVAL;
}
return 0;
}
