static int __init genode_serial_init_port(int num) {
int irq;
unsigned long flags;
if (genode_serial_port[num].initialized)
return 0;
genode_serial_port[num].initialized = 1;
local_irq_save(flags);
genode_serial_port[num].irq_cap = genode_terminal_irq(num);
local_irq_restore(flags);
if((irq = l4x_register_irq(genode_serial_port[num].irq_cap)) < 0) {
return -EIO;
}
genode_serial_port[num].port.uartclk = 3686400;
genode_serial_port[num].port.ops = &genode_serial_pops;
genode_serial_port[num].port.fifosize = 8;
genode_serial_port[num].port.line = num;
genode_serial_port[num].port.iotype = UPIO_MEM;
genode_serial_port[num].port.membase = (void *)1;
genode_serial_port[num].port.mapbase = 1;
genode_serial_port[num].port.flags = UPF_BOOT_AUTOCONF;
genode_serial_port[num].port.irq = irq;
genode_serial_port[num].idx = num;
return 0;
}
/* Setup and register the device. */
static int __init genode_net_init(void)
{
int err = 0;
unsigned irq;
l4_cap_idx_t irq_cap;
if (!genode_net_ready())
return 0;
/* allocate network device */
if (!(net_dev = alloc_etherdev(sizeof(struct net_device_stats))))
goto out;
net_dev->netdev_ops = &genode_net_dev_ops;
net_dev->watchdog_timeo = 20 * HZ;
/* set MAC address */
genode_net_mac(net_dev->dev_addr, ETH_ALEN);
/**
* Obtain an IRQ for the device.
*/
irq_cap = genode_net_irq_cap();
if ((irq = l4x_register_irq(irq_cap)) < 0)
return -ENOMEM;
if ((err = request_irq(irq, event_interrupt, IRQF_SAMPLE_RANDOM,
"Genode net", net_dev))) {
printk(KERN_WARNING "%s: request_irq failed: %d\n", __func__, err);
return err;
}
/* register network device */
if ((err = register_netdev(net_dev))) {
panic("loopback: Failed to register netdevice: %d\n", err);
goto out_free;
}
return 0;
out_free:
free_netdev(net_dev);
out:
return err;
};
static int __init l4ser_shm_init_port(int num, const char *name)
{
int irq;
struct chunk_head *ch;
struct l4ser_shm_uart_port *p = &l4ser_shm_port[num];
L4XV_V(f);
if (p->inited)
return 0;
p->inited = 1;
if (shmsize < PAGE_SIZE)
shmsize = PAGE_SIZE;
pr_info("l4ser_shm: Requesting, role %s, Shmsize %d Kbytes\n",
p->create ? "Creator" : "User", shmsize >> 10);
L4XV_L(f);
if (p->create) {
if (l4shmc_create(name, shmsize)) {
L4XV_U(f);
pr_err("l4ser_shm/%s: Failed to create shm\n",
p->name);
return -ENOMEM;
}
}
if (l4shmc_attach_to(name, WAIT_TIMEOUT,
&p->shmcarea)) {
L4XV_U(f);
pr_err("l4ser_shm/%s: Failed to attach to shm\n", p->name);
return -ENOMEM;
}
if (l4shmc_add_chunk(&p->shmcarea, p->create ? "joe" : "bob",
chunk_size(&p->shmcarea),
&p->tx_chunk))
goto unlock;
if (l4shmc_add_signal(&p->shmcarea, p->create ? "joe" : "bob",
&p->tx_sig))
goto unlock;
if (l4shmc_connect_chunk_signal(&p->tx_chunk,
&p->tx_sig))
goto unlock;
/* Now get the receiving side */
if (l4shmc_get_chunk_to(&p->shmcarea, p->create ? "bob" : "joe",
WAIT_TIMEOUT, &p->rx_chunk))
goto unlock;
if (l4shmc_get_signal_to(&p->shmcarea, p->create ? "bob" : "joe",
WAIT_TIMEOUT, &p->rx_sig))
goto unlock;
if (l4shmc_connect_chunk_signal(&p->rx_chunk,
&p->rx_sig))
goto unlock;
L4XV_U(f);
if ((irq = l4x_register_irq(l4shmc_signal_cap(&p->rx_sig))) < 0)
return -ENOMEM;
ch = (struct chunk_head *)l4shmc_chunk_ptr(&p->tx_chunk);
ch->next_offs_to_write = 0;
ch->next_offs_to_read = 0;
ch->writer_blocked = 0;
p->tx_ring_size = l4shmc_chunk_capacity(&p->tx_chunk)
- sizeof(struct chunk_head);
p->rx_ring_size = l4shmc_chunk_capacity(&p->rx_chunk)
- sizeof(struct chunk_head);
p->tx_ring_start = (char *)l4shmc_chunk_ptr(&p->tx_chunk)
+ sizeof(struct chunk_head);
p->rx_ring_start = (char *)l4shmc_chunk_ptr(&p->rx_chunk)
+ sizeof(struct chunk_head);
p->port.uartclk = 3686400;
p->port.ops = &l4ser_shm_pops;
p->port.fifosize = 8;
p->port.line = num;
p->port.iotype = UPIO_MEM;
p->port.membase = (void *)1;
p->port.mapbase = 1;
p->port.flags = UPF_BOOT_AUTOCONF;
p->port.irq = irq;
return 0;
unlock:
L4XV_U(f);
return -ENOMEM;
}
static int l4x_rtc_platform_probe(struct platform_device *pdev)
{
int r;
if (l4x_re_resolve_name("rtc", &rtc_server)) {
pr_err("l4x-rtc: Could not find 'rtc' cap.\n");
return -ENOENT;
}
irq_cap = l4x_cap_alloc();
if (l4_is_invalid_cap(irq_cap)) {
pr_err("l4x-rtc: Could not allocate irq cap.\n");
return -ENOMEM;
}
if (L4XV_FN_e(l4_factory_create_irq(l4re_env()->factory, irq_cap))) {
pr_err("l4x-rtc: Could not create user irq.\n");
r = -ENOMEM;
goto free_cap;
}
if (L4XV_FN_e(l4_icu_bind(rtc_server, 0, irq_cap))) {
pr_err("l4x-rtc: Error registering for time updates.\n");
r = -ENOSYS;
goto free_irq_cap;
}
irq = l4x_register_irq(irq_cap);
if (irq < 0) {
pr_err("l4x-rtc: Error registering IRQ with L4Linux.\n");
r = irq;
goto free_irq_cap;
}
r = request_irq(irq, l4x_rtc_int, IRQF_TRIGGER_RISING, "l4x_rtc", NULL);
if (r) {
pr_err("l4x-rtc: Could not register IRQ.\n");
goto unregister_irq;
}
if (l4x_rtc_update_offset()) {
pr_err("l4x-rtc: Could not get the time offset to real time.\n");
r = -ENOSYS;
goto free_irq;
}
rtc_dev = rtc_device_register(driver_name, &(pdev->dev),
&l4x_rtc_ops, THIS_MODULE);
if (IS_ERR(rtc_dev)) {
pr_err("l4x-rtc: Could not register as rtc device.\n");
r = PTR_ERR(rtc_dev);
goto free_irq;
}
INIT_WORK(&w_update_time, l4x_rtc_update_time);
return 0;
free_irq:
free_irq(irq, NULL);
unregister_irq:
l4x_unregister_irq(irq);
free_irq_cap:
L4XV_FN_v(l4_task_release_cap(L4RE_THIS_TASK_CAP, irq_cap));
free_cap:
l4x_cap_free(irq_cap);
return r;
}
static int __init l4x_timer_init_ret(void)
{
int r;
l4lx_thread_t thread;
int irq;
L4XV_V(f);
timer_irq_cap = l4x_cap_alloc();
if (l4_is_invalid_cap(timer_irq_cap)) {
printk(KERN_ERR "l4timer: Failed to alloc\n");
return -ENOMEM;
}
r = L4XV_FN_i(l4_error(l4_factory_create_irq(l4re_env()->factory,
timer_irq_cap)));
if (r) {
printk(KERN_ERR "l4timer: Failed to create irq: %d\n", r);
goto out1;
}
if ((irq = l4x_register_irq(timer_irq_cap)) < 0) {
r = -ENOMEM;
goto out2;
}
printk("l4timer: Using IRQ%d\n", irq);
setup_irq(irq, &l4timer_irq);
L4XV_L(f);
thread = l4lx_thread_create
(timer_thread, /* thread function */
smp_processor_id(), /* cpu */
NULL, /* stack */
&timer_irq_cap, sizeof(timer_irq_cap), /* data */
l4x_cap_alloc(), /* cap */
PRIO_TIMER, /* prio */
0, /* vcpup */
"timer", /* name */
NULL);
L4XV_U(f);
timer_srv = l4lx_thread_get_cap(thread);
if (!l4lx_thread_is_valid(thread)) {
printk(KERN_ERR "l4timer: Failed to create thread\n");
r = -ENOMEM;
goto out3;
}
l4timer_clockevent.irq = irq;
l4timer_clockevent.mult =
div_sc(1000000, NSEC_PER_SEC, l4timer_clockevent.shift);
l4timer_clockevent.max_delta_ns =
clockevent_delta2ns(0xffffffff, &l4timer_clockevent);
l4timer_clockevent.min_delta_ns =
clockevent_delta2ns(0xf, &l4timer_clockevent);
l4timer_clockevent.cpumask = cpumask_of(0);
clockevents_register_device(&l4timer_clockevent);
return 0;
out3:
l4x_unregister_irq(irq);
out2:
L4XV_FN_v(l4_task_delete_obj(L4RE_THIS_TASK_CAP, timer_irq_cap));
out1:
l4x_cap_free(timer_irq_cap);
return r;
}
