mirror of
https://github.com/genodelabs/genode.git
synced 2025-01-20 11:39:14 +00:00
Sebastian Sumpf
Christian Helmuth
parent
131758eae0
commit
0a1664b892
@ -1,4 +1,4 @@
|
||||
SRC_C += platform_device.c
|
||||
SRC_CC += platform_device.c
|
||||
INC_DIR += $(LIB_INC_DIR)/arm
|
||||
|
||||
vpath platform_device.c $(LIB_DIR)/arm
|
||||
vpath platform_device.cc $(LIB_DIR)/arm
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
LIB_DIR = $(REP_DIR)/src/lib/usb
|
||||
LIB_INC_DIR = $(LIB_DIR)/include
|
||||
|
||||
# FIXME should we *really* dde_kit to this shared library?
|
||||
LIBS += dde_kit libc-setjmp config
|
||||
LIBS += libc-setjmp config
|
||||
SRC_CC += main.cc lx_emul.cc irq.cc timer.cc event.cc storage.cc \
|
||||
input_component.cc nic.cc raw.cc
|
||||
SRC_C += dummies.c scsi.c evdev.c raw_driver.c
|
||||
|
||||
@ -56,7 +56,7 @@ append config {
|
||||
<provides><service name="Timer"/></provides>
|
||||
</start>
|
||||
<start name="usb_drv">
|
||||
<resource name="RAM" quantum="7M"/>
|
||||
<resource name="RAM" quantum="10M"/>
|
||||
<provides><service name="Input"/></provides>
|
||||
<config uhci="yes" ehci="yes" xhci="yes">
|
||||
<hid/>
|
||||
|
||||
@ -1,3 +1,3 @@
|
||||
TARGET = usb_drv
|
||||
SRC_CC = main.cc
|
||||
LIBS = usb server
|
||||
LIBS = base usb server
|
||||
|
||||
@ -11,7 +11,13 @@
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#include <os/attached_io_mem_dataspace.h>
|
||||
|
||||
#include <lx/extern_c_begin.h>
|
||||
#include <lx_emul.h>
|
||||
#include <lx/extern_c_end.h>
|
||||
|
||||
|
||||
|
||||
#define to_platform_driver(drv) (container_of((drv), struct platform_driver, \
|
||||
driver))
|
||||
@ -38,13 +44,15 @@ static int platform_drv_probe(struct device *_dev)
|
||||
|
||||
struct bus_type platform_bus_type = {
|
||||
.name = "platform",
|
||||
.match = platform_match,
|
||||
.probe = platform_drv_probe
|
||||
};
|
||||
|
||||
|
||||
int platform_driver_register(struct platform_driver *drv)
|
||||
{
|
||||
/* init plarform_bus_type */
|
||||
platform_bus_type.match = platform_match;
|
||||
platform_bus_type.probe = platform_drv_probe;
|
||||
|
||||
drv->driver.bus = &platform_bus_type;
|
||||
if (drv->probe)
|
||||
drv->driver.probe = platform_drv_probe;
|
||||
@ -57,7 +65,7 @@ int platform_driver_register(struct platform_driver *drv)
|
||||
struct resource *platform_get_resource(struct platform_device *dev,
|
||||
unsigned int type, unsigned int num)
|
||||
{
|
||||
int i;
|
||||
unsigned i;
|
||||
|
||||
for (i = 0; i < dev->num_resources; i++) {
|
||||
struct resource *r = &dev->resource[i];
|
||||
@ -74,7 +82,7 @@ struct resource *platform_get_resource_byname(struct platform_device *dev,
|
||||
unsigned int type,
|
||||
const char *name)
|
||||
{
|
||||
int i;
|
||||
unsigned i;
|
||||
|
||||
for (i = 0; i < dev->num_resources; i++) {
|
||||
struct resource *r = &dev->resource[i];
|
||||
@ -115,13 +123,13 @@ int platform_device_register(struct platform_device *pdev)
|
||||
|
||||
struct platform_device *platform_device_alloc(const char *name, int id)
|
||||
{
|
||||
struct platform_device *pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
|
||||
platform_device *pdev = (platform_device *)kzalloc(sizeof(struct platform_device), GFP_KERNEL);
|
||||
|
||||
if (!pdev)
|
||||
return 0;
|
||||
|
||||
int len = strlen(name);
|
||||
pdev->name = kzalloc(len + 1, GFP_KERNEL);
|
||||
pdev->name = (char *)kzalloc(len + 1, GFP_KERNEL);
|
||||
|
||||
if (!pdev->name) {
|
||||
kfree(pdev);
|
||||
@ -162,7 +170,7 @@ int platform_device_add_resources(struct platform_device *pdev,
|
||||
struct resource *r = NULL;
|
||||
|
||||
if (res) {
|
||||
r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
|
||||
r = (resource *)kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
|
||||
if (!r)
|
||||
return -ENOMEM;
|
||||
}
|
||||
@ -192,12 +200,15 @@ void platform_set_drvdata(struct platform_device *pdev, void *data)
|
||||
|
||||
void *_ioremap(resource_size_t phys_addr, unsigned long size, int wc)
|
||||
{
|
||||
dde_kit_addr_t map_addr;
|
||||
if (dde_kit_request_mem(phys_addr, size, wc, &map_addr)) {
|
||||
try {
|
||||
Genode::Attached_io_mem_dataspace *ds = new(Genode::env()->heap())
|
||||
Genode::Attached_io_mem_dataspace(phys_addr, size, !!wc);
|
||||
/* map base + page offset */
|
||||
return ds->local_addr<char>() + (phys_addr & (PAGE_SIZE - 1));
|
||||
} catch (...) {
|
||||
panic("Failed to request I/O memory: [%zx,%lx)", phys_addr, phys_addr + size);
|
||||
return 0;
|
||||
}
|
||||
return (void *)map_addr;
|
||||
}
|
||||
|
||||
|
||||
@ -57,14 +57,14 @@ static resource _dwc_otg_resource[] =
|
||||
***************************************/
|
||||
|
||||
#if VERBOSE_LX_EMUL
|
||||
#define TRACE dde_kit_printf("\033[32m%s\033[0m called, not implemented\n", __PRETTY_FUNCTION__)
|
||||
#define TRACE lx_printf("\033[32m%s\033[0m called, not implemented\n", __PRETTY_FUNCTION__)
|
||||
#else
|
||||
#define TRACE
|
||||
#endif
|
||||
|
||||
#define DUMMY(retval, name) \
|
||||
extern "C" long name() { \
|
||||
dde_kit_printf("\033[32m%s\033[0m called, not implemented, stop\n", #name); \
|
||||
lx_printf("\033[32m%s\033[0m called, not implemented, stop\n", #name); \
|
||||
bt(); \
|
||||
for (;;); \
|
||||
return retval; \
|
||||
@ -72,7 +72,7 @@ extern "C" long name() { \
|
||||
|
||||
#define CHECKED_DUMMY(retval, name) \
|
||||
extern "C" long name() { \
|
||||
dde_kit_printf("\033[32m%s\033[0m called, not implemented, ignored\n", #name); \
|
||||
lx_printf("\033[32m%s\033[0m called, not implemented, ignored\n", #name); \
|
||||
bt(); \
|
||||
return retval; \
|
||||
}
|
||||
@ -98,18 +98,6 @@ int in_irq()
|
||||
|
||||
unsigned long loops_per_jiffy = 1;
|
||||
|
||||
|
||||
/*********************
|
||||
** linux/jiffies.h **
|
||||
*********************/
|
||||
|
||||
unsigned int jiffies_to_msecs(const unsigned long j)
|
||||
{
|
||||
PDBG("not implemented. stop");
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/***********************************
|
||||
** Dummies for unused PCD driver **
|
||||
***********************************/
|
||||
|
||||
@ -16,21 +16,18 @@
|
||||
/* Linux kernel API */
|
||||
#include <lx_emul.h>
|
||||
|
||||
/* DDE-Kit includes */
|
||||
#include <dde_kit/printf.h>
|
||||
|
||||
/* Linux includes */
|
||||
#include <linux/input.h>
|
||||
|
||||
#define SKIP_VERBOSE 0
|
||||
|
||||
#if DEBUG_TRACE
|
||||
#define TRACE dde_kit_printf("\033[32m%s\033[0m called from %p, not implemented\n", __PRETTY_FUNCTION__, __builtin_return_address(0))
|
||||
#define TRACE lx_printf("\033[32m%s\033[0m called from %p, not implemented\n", __PRETTY_FUNCTION__, __builtin_return_address(0))
|
||||
#else
|
||||
#define TRACE
|
||||
#endif
|
||||
#if SKIP_VERBOSE
|
||||
#define SKIP dde_kit_printf("\033[34m%s\033[0m: skipped\n", __PRETTY_FUNCTION__)
|
||||
#define SKIP lx_printf("\033[34m%s\033[0m: skipped\n", __PRETTY_FUNCTION__)
|
||||
#else
|
||||
#define SKIP
|
||||
#endif
|
||||
@ -137,6 +134,9 @@ void assert_spin_locked(spinlock_t *lock) { TRACE;}
|
||||
|
||||
void mutex_lock_nested(struct mutex *lock, unsigned int subclass) { TRACE; }
|
||||
int mutex_lock_interruptible(struct mutex *m) { TRACE; return 0; }
|
||||
void mutex_init (struct mutex *m) { TRACE; }
|
||||
void mutex_lock (struct mutex *m) { TRACE; }
|
||||
void mutex_unlock(struct mutex *m) { TRACE; }
|
||||
|
||||
|
||||
/*******************
|
||||
|
||||
102
repos/dde_linux/src/lib/usb/include/list.h
Normal file
102
repos/dde_linux/src/lib/usb/include/list.h
Normal file
@ -0,0 +1,102 @@
|
||||
/*
|
||||
* \brief Slightly improved list
|
||||
* \author Christian Helmuth
|
||||
* \date 2014-09-25
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copyright (C) 2014 Genode Labs GmbH
|
||||
*
|
||||
* This file is part of the Genode OS framework, which is distributed
|
||||
* under the terms of the GNU General Public License version 2.
|
||||
*/
|
||||
|
||||
#ifndef _LIST_H_
|
||||
#define _LIST_H_
|
||||
|
||||
#include <util/list.h>
|
||||
|
||||
|
||||
namespace Lx {
|
||||
template <typename> class List;
|
||||
template <typename> class List_element;
|
||||
}
|
||||
|
||||
template <typename LT>
|
||||
class Lx::List : private Genode::List<LT>
|
||||
{
|
||||
private:
|
||||
|
||||
typedef Genode::List<LT> Base;
|
||||
|
||||
public:
|
||||
|
||||
using Base::Element;
|
||||
|
||||
void append(LT const *le)
|
||||
{
|
||||
LT *at = nullptr;
|
||||
|
||||
for (LT *l = first(); l; l = l->next())
|
||||
at = l;
|
||||
|
||||
Base::insert(le, at);
|
||||
}
|
||||
|
||||
void prepend(LT const *le)
|
||||
{
|
||||
Base::insert(le);
|
||||
}
|
||||
|
||||
void insert_before(LT const *le, LT const *at)
|
||||
{
|
||||
if (at == first()) {
|
||||
prepend(le);
|
||||
return;
|
||||
} else if (!at) {
|
||||
append(le);
|
||||
return;
|
||||
}
|
||||
|
||||
for (LT *l = first(); l; l = l->next())
|
||||
if (l->next() == at)
|
||||
at = l;
|
||||
|
||||
Base::insert(le, at);
|
||||
}
|
||||
|
||||
|
||||
/****************************
|
||||
** Genode::List interface **
|
||||
****************************/
|
||||
|
||||
LT *first() { return Base::first(); }
|
||||
LT const *first() const { return Base::first(); }
|
||||
|
||||
void insert(LT const *le, LT const *at = 0)
|
||||
{
|
||||
Base::insert(le, at);
|
||||
}
|
||||
|
||||
void remove(LT const *le)
|
||||
{
|
||||
Base::remove(le);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename T>
|
||||
class Lx::List_element : public Lx::List<List_element<T> >::Element
|
||||
{
|
||||
private:
|
||||
|
||||
T *_object;
|
||||
|
||||
public:
|
||||
|
||||
List_element(T *object) : _object(object) { }
|
||||
|
||||
T *object() const { return _object; }
|
||||
};
|
||||
|
||||
#endif /* _LIST_H_ */
|
||||
@ -18,15 +18,8 @@
|
||||
#ifndef _LX_EMUL_H_
|
||||
#define _LX_EMUL_H_
|
||||
|
||||
/* DDE Kit includes */
|
||||
#include <dde_kit/types.h>
|
||||
#include <dde_kit/printf.h>
|
||||
#include <dde_kit/panic.h>
|
||||
#include <dde_kit/lock.h>
|
||||
#include <dde_kit/spin_lock.h>
|
||||
#include <dde_kit/timer.h>
|
||||
#include <dde_kit/resources.h>
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <base/fixed_stdint.h>
|
||||
|
||||
#define DEBUG_COMPLETION 0
|
||||
#define DEBUG_DMA 0
|
||||
@ -46,10 +39,21 @@
|
||||
|
||||
#define KBUILD_MODNAME "mod-noname"
|
||||
|
||||
void lx_printf(char const *, ...) __attribute__((format(printf, 1, 2)));
|
||||
void lx_vprintf(char const *, va_list);
|
||||
|
||||
#define lx_log(doit, msg...) \
|
||||
do { \
|
||||
if (doit) { \
|
||||
lx_printf("%s(): ", __func__); \
|
||||
lx_printf(msg); \
|
||||
lx_printf("\n"); \
|
||||
} \
|
||||
} while(0);
|
||||
|
||||
static inline void bt()
|
||||
{
|
||||
dde_kit_printf("BT: 0x%p\n", __builtin_return_address(0));
|
||||
lx_printf("BT: 0x%p\n", __builtin_return_address(0));
|
||||
}
|
||||
|
||||
|
||||
@ -72,16 +76,16 @@ static inline void bt()
|
||||
|
||||
#define WARN_ON(condition) ({ \
|
||||
int ret = !!(condition); \
|
||||
if (ret) dde_kit_debug("[%s] WARN_ON(" #condition ") ", __func__); \
|
||||
if (ret) lx_printf("[%s] WARN_ON(" #condition ") ", __func__); \
|
||||
ret; })
|
||||
|
||||
#define WARN(condition, fmt, arg...) ({ \
|
||||
int ret = !!(condition); \
|
||||
if (ret) dde_kit_debug("[%s] *WARN* " fmt , __func__ , ##arg); \
|
||||
if (ret) lx_printf("[%s] *WARN* " fmt , __func__ , ##arg); \
|
||||
ret; })
|
||||
|
||||
#define BUG() do { \
|
||||
dde_kit_debug("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
|
||||
lx_printf("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
|
||||
while (1); \
|
||||
} while (0)
|
||||
|
||||
@ -133,15 +137,15 @@ int atomic_inc_return(atomic_t *v);
|
||||
** linux/types.h **
|
||||
*******************/
|
||||
|
||||
typedef dde_kit_int8_t int8_t;
|
||||
typedef dde_kit_uint8_t uint8_t;
|
||||
typedef dde_kit_int16_t int16_t;
|
||||
typedef dde_kit_uint16_t uint16_t;
|
||||
typedef dde_kit_int32_t int32_t;
|
||||
typedef dde_kit_uint32_t uint32_t;
|
||||
typedef dde_kit_size_t size_t;
|
||||
typedef dde_kit_int64_t int64_t;
|
||||
typedef dde_kit_uint64_t uint64_t;
|
||||
typedef genode_int8_t int8_t;
|
||||
typedef genode_uint8_t uint8_t;
|
||||
typedef genode_int16_t int16_t;
|
||||
typedef genode_uint16_t uint16_t;
|
||||
typedef genode_int32_t int32_t;
|
||||
typedef genode_uint32_t uint32_t;
|
||||
typedef __SIZE_TYPE__ size_t;
|
||||
typedef genode_int64_t int64_t;
|
||||
typedef genode_uint64_t uint64_t;
|
||||
|
||||
typedef uint32_t uint;
|
||||
typedef unsigned long ulong;
|
||||
@ -292,14 +296,18 @@ typedef unsigned short ushort;
|
||||
#define __printf(a, b) __attribute__((format(printf, a, b)))
|
||||
|
||||
|
||||
/**************************
|
||||
** linux/compiler-gcc.h **
|
||||
**************************/
|
||||
|
||||
#define __noreturn __attribute__((noreturn))
|
||||
|
||||
/*********************
|
||||
** linux/jiffies.h **
|
||||
*********************/
|
||||
|
||||
/* we directly map 'jiffies' to 'dde_kit_timer_ticks' */
|
||||
#define jiffies dde_kit_timer_ticks
|
||||
|
||||
extern volatile unsigned long jiffies;
|
||||
extern unsigned long jiffies;
|
||||
unsigned long msecs_to_jiffies(const unsigned int m);
|
||||
unsigned int jiffies_to_msecs(const unsigned long j);
|
||||
long time_after(long a, long b);
|
||||
@ -535,15 +543,24 @@ enum {
|
||||
* Debug macros
|
||||
*/
|
||||
#if DEBUG_PRINTK
|
||||
#define printk dde_kit_printf
|
||||
#define vprintk dde_kit_vprintf
|
||||
#define panic dde_kit_panic
|
||||
#define printk _printk
|
||||
#define vprintk _lx_vprintf
|
||||
#else
|
||||
#define printk(...)
|
||||
#define vprintk(...)
|
||||
#define panic(...)
|
||||
#endif
|
||||
|
||||
static inline __printf(1, 2) void panic(const char *fmt, ...) __noreturn;
|
||||
static inline void panic(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
lx_vprintf(fmt, args);
|
||||
va_end(args);
|
||||
lx_printf("panic()");
|
||||
while (1) ;
|
||||
}
|
||||
|
||||
/*
|
||||
* Bits and types
|
||||
*/
|
||||
@ -717,6 +734,16 @@ struct va_format
|
||||
va_list *va;
|
||||
};
|
||||
|
||||
static inline int _printk(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
|
||||
static inline int _printk(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
lx_vprintf(fmt, args);
|
||||
va_end(args);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**********************************
|
||||
** linux/bitops.h, asm/bitops.h **
|
||||
**********************************/
|
||||
@ -907,13 +934,13 @@ void *kcalloc(size_t n, size_t size, gfp_t flags);
|
||||
struct kmem_cache;
|
||||
|
||||
/**
|
||||
* Create slab cache using DDE kit
|
||||
* Create slab cache
|
||||
*/
|
||||
struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
|
||||
unsigned long, void (*)(void *));
|
||||
|
||||
/**
|
||||
* Destroy slab cache using DDE kit
|
||||
* Destroy slab cache
|
||||
*/
|
||||
void kmem_cache_destroy(struct kmem_cache *);
|
||||
|
||||
@ -937,7 +964,7 @@ void kmem_cache_free(struct kmem_cache *, void *);
|
||||
** linux/spinlock.h **
|
||||
**********************/
|
||||
|
||||
typedef dde_kit_spin_lock spinlock_t;
|
||||
typedef uint32_t spinlock_t;
|
||||
#define DEFINE_SPINLOCK(name) spinlock_t name = 0;
|
||||
|
||||
void spin_lock(spinlock_t *lock);
|
||||
@ -956,7 +983,7 @@ void assert_spin_locked(spinlock_t *lock);
|
||||
** linux/mutex.h **
|
||||
*******************/
|
||||
|
||||
struct mutex { struct dde_kit_lock *lock; };
|
||||
struct mutex { uint8_t d; };
|
||||
|
||||
void mutex_init(struct mutex *m);
|
||||
void mutex_lock(struct mutex *m);
|
||||
@ -964,7 +991,7 @@ void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
|
||||
void mutex_unlock(struct mutex *m);
|
||||
int mutex_lock_interruptible(struct mutex *m);
|
||||
|
||||
#define DEFINE_MUTEX(mutexname) struct mutex mutexname = { NULL };
|
||||
#define DEFINE_MUTEX(mutexname) struct mutex mutexname = { 0 };
|
||||
|
||||
|
||||
/***********************
|
||||
@ -1586,27 +1613,27 @@ bool device_can_wakeup(struct device *dev);
|
||||
** linux/device.h **
|
||||
********************/
|
||||
|
||||
#define dev_info(dev, format, arg...) dde_kit_printf("dev_info: " format, ## arg)
|
||||
#define dev_warn(dev, format, arg...) dde_kit_printf("dev_warn: " format, ## arg)
|
||||
#define dev_WARN(dev, format, arg...) dde_kit_printf("dev_WARN: " format, ## arg)
|
||||
#define dev_err( dev, format, arg...) dde_kit_printf("dev_error: " format, ## arg)
|
||||
#define dev_notice(dev, format, arg...) dde_kit_printf("dev_notice: " format, ## arg)
|
||||
#define dev_info(dev, format, arg...) lx_printf("dev_info: " format, ## arg)
|
||||
#define dev_warn(dev, format, arg...) lx_printf("dev_warn: " format, ## arg)
|
||||
#define dev_WARN(dev, format, arg...) lx_printf("dev_WARN: " format, ## arg)
|
||||
#define dev_err( dev, format, arg...) lx_printf("dev_error: " format, ## arg)
|
||||
#define dev_notice(dev, format, arg...) lx_printf("dev_notice: " format, ## arg)
|
||||
#define dev_dbg_ratelimited(dev, format, arg...)
|
||||
|
||||
|
||||
#if DEBUG_PRINTK
|
||||
#define dev_dbg(dev, format, arg...) dde_kit_printf("dev_dbg: " format, ## arg)
|
||||
#define dev_vdbg(dev, format, arg...) dde_kit_printf("dev_dbg: " format, ## arg)
|
||||
#define dev_dbg(dev, format, arg...) lx_printf("dev_dbg: " format, ## arg)
|
||||
#define dev_vdbg(dev, format, arg...) lx_printf("dev_dbg: " format, ## arg)
|
||||
#else
|
||||
#define dev_dbg( dev, format, arg...)
|
||||
#define dev_vdbg( dev, format, arg...)
|
||||
#endif
|
||||
|
||||
#define dev_printk(level, dev, format, arg...) \
|
||||
dde_kit_printf("dev_printk: " format, ## arg)
|
||||
lx_printf("dev_printk: " format, ## arg)
|
||||
|
||||
#define dev_warn_ratelimited(dev, format, arg...) \
|
||||
dde_kit_printf("dev_warn_ratelimited: " format "\n", ## arg)
|
||||
lx_printf("dev_warn_ratelimited: " format "\n", ## arg)
|
||||
|
||||
enum {
|
||||
BUS_NOTIFY_ADD_DEVICE = 0x00000001,
|
||||
@ -1866,8 +1893,8 @@ bool access_ok(int access, void *addr, size_t size);
|
||||
size_t copy_from_user(void *to, void const *from, size_t len);
|
||||
size_t copy_to_user(void *dst, void const *src, size_t len);
|
||||
|
||||
#define get_user(x, ptr) ({ dde_kit_printf("get_user not implemented"); (0);})
|
||||
#define put_user(x, ptr) ({ dde_kit_printf("put_user not implemented"); (0);})
|
||||
#define get_user(x, ptr) ({ lx_printf("get_user not implemented"); (0);})
|
||||
#define put_user(x, ptr) ({ lx_printf("put_user not implemented"); (0);})
|
||||
|
||||
|
||||
/*****************
|
||||
@ -2237,13 +2264,13 @@ void *phys_to_virt(unsigned long address);
|
||||
#define readl(addr) (*(volatile uint32_t *)(addr))
|
||||
#define readb(addr) (*(volatile uint8_t *)(addr))
|
||||
|
||||
static inline void outb(u8 value, u32 port) { dde_kit_outb(port, value); }
|
||||
static inline void outw(u16 value, u32 port) { dde_kit_outw(port, value); }
|
||||
static inline void outl(u32 value, u32 port) { dde_kit_outl(port, value); }
|
||||
void outb(u8 value, u32 port);
|
||||
void outw(u16 value, u32 port);
|
||||
void outl(u32 value, u32 port);
|
||||
|
||||
static inline u8 inb(u32 port) { return dde_kit_inb(port); }
|
||||
static inline u16 inw(u32 port) { return dde_kit_inw(port); }
|
||||
static inline u32 inl(u32 port) { return dde_kit_inl(port); }
|
||||
u8 inb(u32 port);
|
||||
u16 inw(u32 port);
|
||||
u32 inl(u32 port);
|
||||
|
||||
void native_io_delay(void);
|
||||
|
||||
@ -3112,8 +3139,8 @@ struct scsi_device
|
||||
#define to_scsi_device(d) \
|
||||
container_of(d, struct scsi_device, sdev_gendev)
|
||||
|
||||
#define shost_for_each_device(sdev, shost) dde_kit_printf("shost_for_each_device called\n");
|
||||
#define __shost_for_each_device(sdev, shost) dde_kit_printf("__shost_for_each_device called\n");
|
||||
#define shost_for_each_device(sdev, shost) lx_printf("shost_for_each_device called\n");
|
||||
#define __shost_for_each_device(sdev, shost) lx_printf("__shost_for_each_device called\n");
|
||||
|
||||
int scsi_device_blocked(struct scsi_device *);
|
||||
int scsi_device_get(struct scsi_device *);
|
||||
@ -3412,18 +3439,18 @@ int ethtool_op_get_ts_info(struct net_device *, struct ethtool_ts_info *);
|
||||
|
||||
#include <linux/netdev_features.h>
|
||||
|
||||
#define netif_err(priv, type, dev, fmt, args...) dde_kit_printf("netif_err: " fmt, ## args);
|
||||
#define netif_info(priv, type, dev, fmt, args...) dde_kit_printf("netif_info: " fmt, ## args);
|
||||
#define netif_err(priv, type, dev, fmt, args...) lx_printf("netif_err: " fmt, ## args);
|
||||
#define netif_info(priv, type, dev, fmt, args...) lx_printf("netif_info: " fmt, ## args);
|
||||
|
||||
#define netdev_err(dev, fmt, args...) dde_kit_printf("nedev_err: " fmt, ##args)
|
||||
#define netdev_warn(dev, fmt, args...) dde_kit_printf("nedev_warn: " fmt, ##args)
|
||||
#define netdev_info(dev, fmt, args...) dde_kit_printf("nedev_info: " fmt, ##args)
|
||||
#define netdev_err(dev, fmt, args...) lx_printf("nedev_err: " fmt, ##args)
|
||||
#define netdev_warn(dev, fmt, args...) lx_printf("nedev_warn: " fmt, ##args)
|
||||
#define netdev_info(dev, fmt, args...) lx_printf("nedev_info: " fmt, ##args)
|
||||
|
||||
#define netdev_for_each_mc_addr(a, b) if (0)
|
||||
|
||||
#if DEBUG_PRINTK
|
||||
#define netif_dbg(priv, type, dev, fmt, args...) dde_kit_printf("netif_dbg: " fmt, ## args)
|
||||
#define netdev_dbg(dev, fmt, args...) dde_kit_printf("netdev_dbg: " fmt, ##args)
|
||||
#define netif_dbg(priv, type, dev, fmt, args...) lx_printf("netif_dbg: " fmt, ## args)
|
||||
#define netdev_dbg(dev, fmt, args...) lx_printf("netdev_dbg: " fmt, ##args)
|
||||
#else
|
||||
#define netif_dbg(priv, type, dev, fmt, args...)
|
||||
#define netdev_dbg(dev, fmt, args...)
|
||||
@ -3755,7 +3782,7 @@ bool of_property_read_bool(const struct device_node *np, const char *propname);
|
||||
** linux/radix-tree.h **
|
||||
************************/
|
||||
|
||||
#define INIT_RADIX_TREE(root, mask) dde_kit_printf("INIT_RADIX_TREE not impelemnted\n")
|
||||
#define INIT_RADIX_TREE(root, mask) lx_printf("INIT_RADIX_TREE not impelemnted\n")
|
||||
struct radix_tree_root { };
|
||||
void *radix_tree_lookup(struct radix_tree_root *root, unsigned long index);
|
||||
int radix_tree_insert(struct radix_tree_root *, unsigned long, void *);
|
||||
|
||||
@ -18,15 +18,13 @@
|
||||
#include <util/list.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
extern "C" {
|
||||
#include <dde_kit/memory.h>
|
||||
}
|
||||
|
||||
#include <platform/platform.h>
|
||||
|
||||
static const bool verbose = false;
|
||||
|
||||
|
||||
namespace Timer {
|
||||
void update_jiffies();
|
||||
}
|
||||
/**
|
||||
* Allows pseudo-parallel execution of functions
|
||||
*/
|
||||
@ -137,6 +135,8 @@ class Routine : public Genode::List<Routine>::Element
|
||||
if (!_list()->first() && !_main)
|
||||
return;
|
||||
|
||||
Timer::update_jiffies();
|
||||
|
||||
if (_current == _main)
|
||||
all = true;
|
||||
|
||||
|
||||
@ -193,7 +193,7 @@ void genode_evdev_event(struct input_handle *handle, unsigned int type,
|
||||
|
||||
if (value != -1) {
|
||||
if (slots[slot].id != -1)
|
||||
dde_kit_printf("warning:: old tracking id in use and got new one\n");
|
||||
lx_printf("warning:: old tracking id in use and got new one\n");
|
||||
|
||||
slots[slot].id = value;
|
||||
return;
|
||||
@ -219,7 +219,7 @@ void genode_evdev_event(struct input_handle *handle, unsigned int type,
|
||||
if (disable_multitouch) return;
|
||||
|
||||
if (value >= sizeof(slots) / sizeof(slots[0])) {
|
||||
dde_kit_printf("warning: drop slot id %d\n", value);
|
||||
lx_printf("warning: drop slot id %d\n", value);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -28,16 +28,6 @@
|
||||
#include "lx_emul.h"
|
||||
#include <extern_c_end.h>
|
||||
|
||||
/* DDE kit includes */
|
||||
extern "C" {
|
||||
#include <dde_kit/semaphore.h>
|
||||
#include <dde_kit/memory.h>
|
||||
#include <dde_kit/pgtab.h>
|
||||
#include <dde_kit/resources.h>
|
||||
#include <dde_kit/interrupt.h>
|
||||
#include <dde_kit/thread.h>
|
||||
}
|
||||
|
||||
|
||||
namespace Genode {
|
||||
class Slab_backend_alloc;
|
||||
@ -54,8 +44,8 @@ class Genode::Slab_backend_alloc : public Genode::Allocator,
|
||||
|
||||
enum {
|
||||
VM_SIZE = 64 * 1024 * 1024, /* size of VM region to reserve */
|
||||
P_BLOCK_SIZE = 1024 * 1024, /* 1 MB physical contiguous */
|
||||
V_BLOCK_SIZE = P_BLOCK_SIZE * 2, /* 1 MB virtual used, 1 MB virtual left free to avoid that Allocator_avl merges virtual contiguous regions which are physically non-contiguous */
|
||||
P_BLOCK_SIZE = 2 * 1024 * 1024, /* 2 MB physical contiguous */
|
||||
V_BLOCK_SIZE = P_BLOCK_SIZE * 2, /* 2 MB virtual used, 2 MB virtual left free to avoid that Allocator_avl merges virtual contiguous regions which are physically non-contiguous */
|
||||
ELEMENTS = VM_SIZE / V_BLOCK_SIZE /* MAX number of dataspaces in VM */
|
||||
};
|
||||
|
||||
@ -203,7 +193,7 @@ class Malloc
|
||||
|
||||
enum {
|
||||
SLAB_START_LOG2 = 3, /* 8 B */
|
||||
SLAB_STOP_LOG2 = 16, /* 64 KB */
|
||||
SLAB_STOP_LOG2 = 17, /* 128 KB */
|
||||
NUM_SLABS = (SLAB_STOP_LOG2 - SLAB_START_LOG2) + 1,
|
||||
};
|
||||
|
||||
@ -255,6 +245,8 @@ class Malloc
|
||||
Slab_alloc(1U << i, alloc);
|
||||
}
|
||||
|
||||
static unsigned long max_alloc() { return 1U << SLAB_STOP_LOG2; }
|
||||
|
||||
/**
|
||||
* Alloc in slabs
|
||||
*/
|
||||
@ -348,6 +340,19 @@ class Malloc
|
||||
};
|
||||
|
||||
|
||||
void lx_printf(char const *fmt, ...)
|
||||
{
|
||||
va_list va;
|
||||
va_start(va, fmt);
|
||||
Genode::vprintf(fmt, va);
|
||||
va_end(va);
|
||||
}
|
||||
|
||||
|
||||
void lx_vprintf(char const *fmt, va_list va) {
|
||||
Genode::vprintf(fmt, va); }
|
||||
|
||||
|
||||
/***********************
|
||||
** Atomic operations **
|
||||
***********************/
|
||||
@ -366,14 +371,6 @@ void atomic_sub(int i, atomic_t *v) { (*(volatile int *)v) -= i; }
|
||||
|
||||
void atomic_set(atomic_t *p, unsigned int v) { (*(volatile int *)p) = v; }
|
||||
|
||||
/*******************
|
||||
** linux/mutex.h **
|
||||
*******************/
|
||||
|
||||
void mutex_init (struct mutex *m) { if (m->lock) dde_kit_lock_init (&m->lock); }
|
||||
void mutex_lock (struct mutex *m) { if (m->lock) dde_kit_lock_lock ( m->lock); }
|
||||
void mutex_unlock(struct mutex *m) { if (m->lock) dde_kit_lock_unlock( m->lock); }
|
||||
|
||||
|
||||
/*************************************
|
||||
** Memory allocation, linux/slab.h **
|
||||
@ -427,15 +424,15 @@ void kfree(const void *p)
|
||||
|
||||
void *vzalloc(unsigned long size)
|
||||
{
|
||||
void *ptr = dde_kit_simple_malloc(size);
|
||||
if (ptr)
|
||||
Genode::memset(ptr, 0, size);
|
||||
if (size > Malloc::max_alloc()) {
|
||||
PERR("vzalloc: size %lu > %lu", size, Malloc::max_alloc());
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ptr;
|
||||
return kmalloc(size, 0);
|
||||
}
|
||||
|
||||
|
||||
void vfree(void *addr) { dde_kit_simple_free(addr); }
|
||||
void vfree(void *addr) { kfree(addr); }
|
||||
|
||||
|
||||
/******************
|
||||
@ -444,7 +441,7 @@ void vfree(void *addr) { dde_kit_simple_free(addr); }
|
||||
|
||||
void kref_init(struct kref *kref)
|
||||
{
|
||||
dde_kit_log(DEBUG_KREF,"%s ref: %p", __func__, kref);
|
||||
lx_log(DEBUG_KREF,"%s ref: %p", __func__, kref);
|
||||
kref->refcount.v = 1;
|
||||
}
|
||||
|
||||
@ -452,13 +449,13 @@ void kref_init(struct kref *kref)
|
||||
void kref_get(struct kref *kref)
|
||||
{
|
||||
kref->refcount.v++;
|
||||
dde_kit_log(DEBUG_KREF, "%s ref: %p c: %d", __func__, kref, kref->refcount.v);
|
||||
lx_log(DEBUG_KREF, "%s ref: %p c: %d", __func__, kref, kref->refcount.v);
|
||||
}
|
||||
|
||||
|
||||
int kref_put(struct kref *kref, void (*release) (struct kref *kref))
|
||||
{
|
||||
dde_kit_log(DEBUG_KREF, "%s: ref: %p c: %d", __func__, kref, kref->refcount.v);
|
||||
lx_log(DEBUG_KREF, "%s: ref: %p c: %d", __func__, kref, kref->refcount.v);
|
||||
|
||||
if (!--kref->refcount.v) {
|
||||
release(kref);
|
||||
@ -609,15 +606,18 @@ struct kmem_cache
|
||||
{
|
||||
const char *name; /* cache name */
|
||||
unsigned size; /* object size */
|
||||
|
||||
struct dde_kit_slab *dde_kit_slab_cache; /* backing DDE kit cache */
|
||||
};
|
||||
|
||||
|
||||
struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align,
|
||||
unsigned long falgs, void (*ctor)(void *))
|
||||
{
|
||||
dde_kit_log(DEBUG_SLAB, "\"%s\" obj_size=%zd", name, size);
|
||||
lx_log(DEBUG_SLAB, "\"%s\" obj_size=%zd", name, size);
|
||||
|
||||
if (size > Malloc::max_alloc()) {
|
||||
PERR("kmem_cache_create: slab size > %lu", Malloc::max_alloc());
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct kmem_cache *cache;
|
||||
|
||||
@ -626,19 +626,12 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align
|
||||
return 0;
|
||||
}
|
||||
|
||||
cache = (struct kmem_cache *)dde_kit_simple_malloc(sizeof(*cache));
|
||||
cache = (struct kmem_cache *)kmalloc(sizeof(*cache), 0);
|
||||
if (!cache) {
|
||||
printk("No memory for slab cache\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* initialize a physically contiguous cache for kmem */
|
||||
if (!(cache->dde_kit_slab_cache = dde_kit_slab_init(size))) {
|
||||
printk("DDE kit slab init failed\n");
|
||||
dde_kit_simple_free(cache);
|
||||
return 0;
|
||||
}
|
||||
|
||||
cache->name = name;
|
||||
cache->size = size;
|
||||
|
||||
@ -648,10 +641,8 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align
|
||||
|
||||
void kmem_cache_destroy(struct kmem_cache *cache)
|
||||
{
|
||||
dde_kit_log(DEBUG_SLAB, "\"%s\"", cache->name);
|
||||
|
||||
dde_kit_slab_destroy(cache->dde_kit_slab_cache);
|
||||
dde_kit_simple_free(cache);
|
||||
lx_log(DEBUG_SLAB, "\"%s\"", cache->name);
|
||||
kfree(cache);
|
||||
}
|
||||
|
||||
|
||||
@ -659,24 +650,17 @@ void *kmem_cache_zalloc(struct kmem_cache *cache, gfp_t flags)
|
||||
{
|
||||
void *ret;
|
||||
|
||||
dde_kit_log(DEBUG_SLAB, "\"%s\" flags=%x", cache->name, flags);
|
||||
|
||||
ret = dde_kit_slab_alloc(cache->dde_kit_slab_cache);
|
||||
|
||||
/* return here in case of error */
|
||||
if (!ret) return 0;
|
||||
|
||||
/* zero page */
|
||||
memset(ret, 0, cache->size);
|
||||
lx_log(DEBUG_SLAB, "\"%s\" flags=%x", cache->name, flags);
|
||||
|
||||
ret = kzalloc(cache->size, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
void kmem_cache_free(struct kmem_cache *cache, void *objp)
|
||||
{
|
||||
dde_kit_log(DEBUG_SLAB, "\"%s\" (%p)", cache->name, objp);
|
||||
dde_kit_slab_free(cache->dde_kit_slab_cache, objp);
|
||||
lx_log(DEBUG_SLAB, "\"%s\" (%p)", cache->name, objp);
|
||||
kfree(objp);
|
||||
}
|
||||
|
||||
|
||||
@ -732,7 +716,7 @@ class Driver : public Genode::List<Driver>::Element
|
||||
return false;
|
||||
|
||||
bool ret = _drv->bus->match ? _drv->bus->match(dev, _drv) : true;
|
||||
dde_kit_log(DEBUG_DRIVER, "MATCH: %s ret: %u match: %p %p",
|
||||
lx_log(DEBUG_DRIVER, "MATCH: %s ret: %u match: %p %p",
|
||||
_drv->name, ret, _drv->bus->match, _drv->probe);
|
||||
return ret;
|
||||
}
|
||||
@ -745,10 +729,10 @@ class Driver : public Genode::List<Driver>::Element
|
||||
dev->driver = _drv;
|
||||
|
||||
if (dev->bus->probe) {
|
||||
dde_kit_log(DEBUG_DRIVER, "Probing device bus %p", dev->bus->probe);
|
||||
lx_log(DEBUG_DRIVER, "Probing device bus %p", dev->bus->probe);
|
||||
return dev->bus->probe(dev);
|
||||
} else if (_drv->probe) {
|
||||
dde_kit_log(DEBUG_DRIVER, "Probing driver: %s %p", _drv->name, _drv->probe);
|
||||
lx_log(DEBUG_DRIVER, "Probing driver: %s %p", _drv->name, _drv->probe);
|
||||
return _drv->probe(dev);
|
||||
}
|
||||
|
||||
@ -759,7 +743,7 @@ class Driver : public Genode::List<Driver>::Element
|
||||
|
||||
int driver_register(struct device_driver *drv)
|
||||
{
|
||||
dde_kit_log(DEBUG_DRIVER, "%s at %p", drv->name, drv);
|
||||
lx_log(DEBUG_DRIVER, "%s at %p", drv->name, drv);
|
||||
new (Genode::env()->heap()) Driver(drv);
|
||||
return 0;
|
||||
}
|
||||
@ -774,7 +758,7 @@ int device_add(struct device *dev)
|
||||
for (Driver *driver = Driver::list()->first(); driver; driver = driver->next())
|
||||
if (driver->match(dev)) {
|
||||
int ret = driver->probe(dev);
|
||||
dde_kit_log(DEBUG_DRIVER, "Probe return %d", ret);
|
||||
lx_log(DEBUG_DRIVER, "Probe return %d", ret);
|
||||
|
||||
if (!ret)
|
||||
return 0;
|
||||
@ -786,7 +770,7 @@ int device_add(struct device *dev)
|
||||
|
||||
void device_del(struct device *dev)
|
||||
{
|
||||
dde_kit_log(DEBUG_DRIVER, "Remove device %p", dev);
|
||||
lx_log(DEBUG_DRIVER, "Remove device %p", dev);
|
||||
if (dev->driver && dev->driver->remove)
|
||||
dev->driver->remove(dev);
|
||||
}
|
||||
@ -927,12 +911,11 @@ void mdelay(unsigned long msecs) { msleep(msecs); }
|
||||
** linux/jiffies.h **
|
||||
*********************/
|
||||
|
||||
/*
|
||||
* We use DDE kit's jiffies in 100Hz granularity.
|
||||
*/
|
||||
enum { JIFFIES_TICK_MS = 1000 / DDE_KIT_HZ };
|
||||
enum { JIFFIES_TICK_MS = 1000 / HZ };
|
||||
|
||||
unsigned long msecs_to_jiffies(const unsigned int m) { return m / JIFFIES_TICK_MS; }
|
||||
unsigned int jiffies_to_msecs(const unsigned long j) { return j * JIFFIES_TICK_MS; }
|
||||
|
||||
long time_after_eq(long a, long b) { return (a - b) >= 0; }
|
||||
long time_after(long a, long b) { return (b - a) < 0; }
|
||||
|
||||
@ -950,7 +933,7 @@ struct dma_pool
|
||||
struct dma_pool *dma_pool_create(const char *name, struct device *d, size_t size,
|
||||
size_t align, size_t alloc)
|
||||
{
|
||||
dde_kit_log(DEBUG_DMA, "size: %zx align:%zx %p", size, align, __builtin_return_address((0)));
|
||||
lx_log(DEBUG_DMA, "size: %zx align:%zx %p", size, align, __builtin_return_address((0)));
|
||||
|
||||
if (align & (align - 1))
|
||||
return 0;
|
||||
@ -964,7 +947,7 @@ struct dma_pool *dma_pool_create(const char *name, struct device *d, size_t size
|
||||
|
||||
void dma_pool_destroy(struct dma_pool *d)
|
||||
{
|
||||
dde_kit_log(DEBUG_DMA, "close");
|
||||
lx_log(DEBUG_DMA, "close");
|
||||
destroy(Genode::env()->heap(), d);
|
||||
}
|
||||
|
||||
@ -974,7 +957,7 @@ void *dma_pool_alloc(struct dma_pool *d, gfp_t f, dma_addr_t *dma)
|
||||
void *addr;
|
||||
addr = dma_alloc_coherent(0, d->size, dma, 0);
|
||||
|
||||
dde_kit_log(DEBUG_DMA, "addr: %p size %zx align %x phys: %lx pool %p",
|
||||
lx_log(DEBUG_DMA, "addr: %p size %zx align %x phys: %lx pool %p",
|
||||
addr, d->size, d->align, *dma, d);
|
||||
return addr;
|
||||
}
|
||||
@ -982,7 +965,7 @@ void *dma_pool_alloc(struct dma_pool *d, gfp_t f, dma_addr_t *dma)
|
||||
|
||||
void dma_pool_free(struct dma_pool *d, void *vaddr, dma_addr_t a)
|
||||
{
|
||||
dde_kit_log(DEBUG_DMA, "free: addr %p, size: %zx", vaddr, d->size);
|
||||
lx_log(DEBUG_DMA, "free: addr %p, size: %zx", vaddr, d->size);
|
||||
Malloc::dma()->free(vaddr);
|
||||
}
|
||||
|
||||
@ -994,7 +977,7 @@ void *dma_alloc_coherent(struct device *, size_t size, dma_addr_t *dma, gfp_t)
|
||||
if (!addr)
|
||||
return 0;
|
||||
|
||||
dde_kit_log(DEBUG_DMA, "DMA pool alloc addr: %p size %zx align: %d, phys: %lx",
|
||||
lx_log(DEBUG_DMA, "DMA pool alloc addr: %p size %zx align: %d, phys: %lx",
|
||||
addr, size, PAGE_SHIFT, *dma);
|
||||
return addr;
|
||||
}
|
||||
@ -1002,7 +985,7 @@ void *dma_alloc_coherent(struct device *, size_t size, dma_addr_t *dma, gfp_t)
|
||||
|
||||
void dma_free_coherent(struct device *, size_t size, void *vaddr, dma_addr_t)
|
||||
{
|
||||
dde_kit_log(DEBUG_DMA, "free: addr %p, size: %zx", vaddr, size);
|
||||
lx_log(DEBUG_DMA, "free: addr %p, size: %zx", vaddr, size);
|
||||
Malloc::dma()->free(vaddr);
|
||||
}
|
||||
|
||||
@ -1011,9 +994,6 @@ void dma_free_coherent(struct device *, size_t size, void *vaddr, dma_addr_t)
|
||||
** linux/dma-mapping.h **
|
||||
*************************/
|
||||
|
||||
/**
|
||||
* Translate virt to phys using DDE-kit
|
||||
*/
|
||||
dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
|
||||
size_t size,
|
||||
enum dma_data_direction dir,
|
||||
@ -1025,7 +1005,7 @@ dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
|
||||
PERR("translation virt->phys %p->%lx failed, return ip %p", ptr, phys,
|
||||
__builtin_return_address(0));
|
||||
|
||||
dde_kit_log(DEBUG_DMA, "virt: %p phys: %lx", ptr, phys);
|
||||
lx_log(DEBUG_DMA, "virt: %p phys: %lx", ptr, phys);
|
||||
return phys;
|
||||
}
|
||||
|
||||
@ -1034,7 +1014,7 @@ dma_addr_t dma_map_page(struct device *dev, struct page *page,
|
||||
size_t offset, size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
dde_kit_log(DEBUG_DMA, "virt: %p phys: %lx offs: %zx", page->virt, page->phys, offset);
|
||||
lx_log(DEBUG_DMA, "virt: %p phys: %lx offs: %zx", page->virt, page->phys, offset);
|
||||
return page->phys + offset;
|
||||
}
|
||||
|
||||
@ -1050,7 +1030,7 @@ int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
|
||||
|
||||
struct task_struct *kthread_run(int (*fn)(void *), void *arg, const char *n, ...)
|
||||
{
|
||||
dde_kit_log(DEBUG_THREAD, "Run %s", n);
|
||||
lx_log(DEBUG_THREAD, "Run %s", n);
|
||||
Routine::add(fn, arg, n);
|
||||
return 0;
|
||||
}
|
||||
@ -1064,7 +1044,7 @@ struct task_struct *kthread_create(int (*threadfn)(void *data),
|
||||
* This is just called for delayed device scanning (see
|
||||
* 'drivers/usb/storage/usb.c')
|
||||
*/
|
||||
dde_kit_log(DEBUG_THREAD, "Create %s", namefmt);
|
||||
lx_log(DEBUG_THREAD, "Create %s", namefmt);
|
||||
Routine::add(threadfn, data, namefmt);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -26,10 +26,6 @@
|
||||
#include <routine.h>
|
||||
#include <signal.h>
|
||||
|
||||
extern "C" {
|
||||
#include <dde_kit/timer.h>
|
||||
}
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
extern "C" int subsys_usb_init();
|
||||
@ -56,9 +52,6 @@ void breakpoint() { PDBG("BREAK"); }
|
||||
|
||||
static void init(Services *services)
|
||||
{
|
||||
/* start jiffies */
|
||||
dde_kit_timer_init(0, 0);
|
||||
|
||||
/*
|
||||
* The RAW driver is initialized first to make sure that it doesn't miss
|
||||
* notifications about added devices.
|
||||
|
||||
@ -444,7 +444,7 @@ struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, unsigned int l
|
||||
|
||||
void dev_kfree_skb(struct sk_buff *skb)
|
||||
{
|
||||
dde_kit_log(DEBUG_SKB, "free skb: %p start: %p cloned: %d",
|
||||
lx_log(DEBUG_SKB, "free skb: %p start: %p cloned: %d",
|
||||
skb, skb->start, skb->cloned);
|
||||
|
||||
if (skb->cloned) {
|
||||
@ -475,7 +475,7 @@ void skb_reserve(struct sk_buff *skb, int len)
|
||||
return;
|
||||
}
|
||||
skb->data += len;
|
||||
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %d", skb, skb->len, len);
|
||||
lx_log(DEBUG_SKB, "skb: %p slen: %u len: %d", skb, skb->len, len);
|
||||
}
|
||||
|
||||
|
||||
@ -493,7 +493,7 @@ unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
|
||||
skb->len += len;
|
||||
skb->data -= len;
|
||||
|
||||
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
lx_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
return skb->data;
|
||||
}
|
||||
|
||||
@ -512,7 +512,7 @@ unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
|
||||
unsigned char *old = skb_tail_pointer(skb);
|
||||
skb->len += len;
|
||||
skb->tail += len;
|
||||
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
lx_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
return old;
|
||||
}
|
||||
|
||||
@ -544,7 +544,7 @@ unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
|
||||
return 0;
|
||||
}
|
||||
skb->len -= len;
|
||||
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
lx_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
return skb->data += len;
|
||||
}
|
||||
|
||||
@ -563,7 +563,7 @@ void skb_trim(struct sk_buff *skb, unsigned int len)
|
||||
skb->len = len;
|
||||
skb_set_tail_pointer(skb, len);
|
||||
|
||||
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
lx_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -18,8 +18,10 @@
|
||||
#include <ram_session/client.h>
|
||||
|
||||
/* Genode os includes */
|
||||
#include <io_port_session/client.h>
|
||||
#include <pci_session/connection.h>
|
||||
#include <pci_device/client.h>
|
||||
#include <util/volatile_object.h>
|
||||
|
||||
/* Linux includes */
|
||||
#include <extern_c_begin.h>
|
||||
@ -29,6 +31,68 @@
|
||||
|
||||
struct bus_type pci_bus_type;
|
||||
|
||||
using namespace Genode;
|
||||
|
||||
class Io_port
|
||||
{
|
||||
|
||||
private:
|
||||
|
||||
unsigned _base = 0;
|
||||
unsigned _size = 0;
|
||||
Io_port_session_capability _cap;
|
||||
Lazy_volatile_object<Io_port_session_client> _port;
|
||||
|
||||
bool _valid(unsigned port) {
|
||||
return _cap.valid() && port >= _base && port < _base + _size; }
|
||||
|
||||
public:
|
||||
|
||||
~Io_port()
|
||||
{
|
||||
if (_cap.valid())
|
||||
_port.destruct();
|
||||
}
|
||||
|
||||
void session(unsigned base, unsigned size, Io_port_session_capability cap)
|
||||
{
|
||||
_base = base;
|
||||
_size = size;
|
||||
_cap = cap;
|
||||
_port.construct(_cap);
|
||||
}
|
||||
|
||||
template<typename POD>
|
||||
bool out(unsigned port, POD val)
|
||||
{
|
||||
if (!_valid(port))
|
||||
return false;
|
||||
|
||||
switch (sizeof(POD)) {
|
||||
case 1: _port->outb(port, val); break;
|
||||
case 2: _port->outw(port, val); break;
|
||||
case 4: _port->outl(port, val); break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename POD>
|
||||
bool in(unsigned port, POD *val)
|
||||
{
|
||||
if (!_valid(port))
|
||||
return false;;
|
||||
|
||||
switch (sizeof(POD)) {
|
||||
case 1: *val = _port->inb(port); break;
|
||||
case 2: *val = _port->inw(port); break;
|
||||
case 4: *val = _port->inl(port); break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Scan PCI bus and probe for HCDs
|
||||
@ -40,6 +104,7 @@ class Pci_driver : public Genode::List<Pci_driver>::Element
|
||||
pci_driver *_drv; /* Linux PCI driver */
|
||||
Pci::Device_capability _cap; /* PCI cap */
|
||||
pci_device_id const *_id; /* matched id for this driver */
|
||||
Io_port _port;
|
||||
|
||||
public:
|
||||
|
||||
@ -82,7 +147,7 @@ class Pci_driver : public Genode::List<Pci_driver>::Element
|
||||
|
||||
/* setup resources */
|
||||
bool io = false;
|
||||
for (int i = 0; i < Device::NUM_RESOURCES; i++) {
|
||||
for (unsigned i = 0; i < Device::NUM_RESOURCES; i++) {
|
||||
Device::Resource res = client.resource(i);
|
||||
_dev->resource[i].start = res.base();
|
||||
_dev->resource[i].end = res.base() + res.size() - 1;
|
||||
@ -91,18 +156,16 @@ class Pci_driver : public Genode::List<Pci_driver>::Element
|
||||
|
||||
/* request port I/O session */
|
||||
if (res.type() == Device::Resource::IO) {
|
||||
if (dde_kit_request_io(res.base(), res.size(), i, bus, dev,
|
||||
func))
|
||||
PERR("Failed to request I/O: [%u,%u)",
|
||||
res.base(), res.base() + res.size());
|
||||
uint8_t virt_bar = client.phys_bar_to_virt(i);
|
||||
_port.session(res.base(), res.size(), client.io_port(virt_bar));
|
||||
io = true;
|
||||
dde_kit_log(DEBUG_PCI, "I/O [%u-%u)",
|
||||
lx_log(DEBUG_PCI, "I/O [%u-%u)",
|
||||
res.base(), res.base() + res.size());
|
||||
}
|
||||
|
||||
/* request I/O memory (write combined) */
|
||||
if (res.type() == Device::Resource::MEMORY)
|
||||
dde_kit_log(DEBUG_PCI, "I/O memory [%x-%x)", res.base(),
|
||||
lx_log(DEBUG_PCI, "I/O memory [%x-%x)", res.base(),
|
||||
res.base() + res.size());
|
||||
}
|
||||
|
||||
@ -166,13 +229,6 @@ class Pci_driver : public Genode::List<Pci_driver>::Element
|
||||
if (!_dev)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < Pci::Device::NUM_RESOURCES; i++) {
|
||||
resource *r = &_dev->resource[i];
|
||||
|
||||
if (r->flags & IORESOURCE_IO)
|
||||
dde_kit_release_io(r->start, (r->end - r->start) + 1);
|
||||
}
|
||||
|
||||
_drivers().remove(this);
|
||||
|
||||
destroy(Genode::env()->heap(), _dev);
|
||||
@ -230,6 +286,22 @@ class Pci_driver : public Genode::List<Pci_driver>::Element
|
||||
PERR("Device using i/o memory of address %zx is unknown", phys);
|
||||
return Genode::Io_mem_session_capability();
|
||||
}
|
||||
|
||||
template <typename POD, bool READ = true>
|
||||
static POD port_io(unsigned port, POD val = 0)
|
||||
{
|
||||
for (Pci_driver *d = _drivers().first(); d; d = d->next()) {
|
||||
if (!d->_dev)
|
||||
continue;
|
||||
|
||||
if (READ && d->_port.in<POD>(port, &val))
|
||||
return val;
|
||||
else if (!READ && d->_port.out<POD>(port, val))
|
||||
return (POD)~0;
|
||||
}
|
||||
|
||||
return (POD)~0;
|
||||
}
|
||||
};
|
||||
|
||||
/********************************
|
||||
@ -279,7 +351,7 @@ static Genode::Object_pool<Memory_object_base> memory_pool;
|
||||
|
||||
int pci_register_driver(struct pci_driver *drv)
|
||||
{
|
||||
dde_kit_log(DEBUG_PCI, "DRIVER name: %s", drv->name);
|
||||
lx_log(DEBUG_PCI, "DRIVER name: %s", drv->name);
|
||||
drv->driver.name = drv->name;
|
||||
|
||||
pci_device_id const *id = drv->id_table;
|
||||
@ -293,7 +365,7 @@ int pci_register_driver(struct pci_driver *drv)
|
||||
while (id->class_ || id->class_mask || id->class_) {
|
||||
|
||||
if (id->class_ == (unsigned)PCI_ANY_ID) {
|
||||
dde_kit_log(DEBUG_PCI, "Skipping PCI_ANY_ID device class");
|
||||
lx_log(DEBUG_PCI, "Skipping PCI_ANY_ID device class");
|
||||
id++;
|
||||
continue;
|
||||
}
|
||||
@ -308,7 +380,7 @@ int pci_register_driver(struct pci_driver *drv)
|
||||
uint8_t bus, dev, func;
|
||||
Pci::Device_client client(cap);
|
||||
client.bus_address(&bus, &dev, &func);
|
||||
dde_kit_log(DEBUG_PCI, "bus: %x dev: %x func: %x", bus, dev, func);
|
||||
lx_log(DEBUG_PCI, "bus: %x dev: %x func: %x", bus, dev, func);
|
||||
}
|
||||
|
||||
Pci_driver *pci_drv = 0;
|
||||
@ -378,7 +450,7 @@ int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int, int where, u8 *v
|
||||
{
|
||||
Pci_driver *drv = (Pci_driver *)bus;
|
||||
drv->config_read(where, val);
|
||||
dde_kit_log(DEBUG_PCI, "READ %p: where: %x val: %x", drv, where, *val);
|
||||
lx_log(DEBUG_PCI, "READ %p: where: %x val: %x", drv, where, *val);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -387,7 +459,7 @@ int pci_bus_read_config_word(struct pci_bus *bus, unsigned int, int where, u16 *
|
||||
{
|
||||
Pci_driver *drv = (Pci_driver *)bus;
|
||||
drv->config_read(where, val);
|
||||
dde_kit_log(DEBUG_PCI, "READ %p: where: %x val: %x", drv, where, *val);
|
||||
lx_log(DEBUG_PCI, "READ %p: where: %x val: %x", drv, where, *val);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -395,7 +467,7 @@ int pci_bus_read_config_word(struct pci_bus *bus, unsigned int, int where, u16 *
|
||||
int pci_bus_write_config_word(struct pci_bus *bus, unsigned int, int where, u16 val)
|
||||
{
|
||||
Pci_driver *drv = (Pci_driver *)bus;
|
||||
dde_kit_log(DEBUG_PCI, "WRITE %p: where: %x val: %x", drv, where, val);
|
||||
lx_log(DEBUG_PCI, "WRITE %p: where: %x val: %x", drv, where, val);
|
||||
drv->config_write(where, val);
|
||||
return 0;
|
||||
}
|
||||
@ -404,7 +476,7 @@ int pci_bus_write_config_word(struct pci_bus *bus, unsigned int, int where, u16
|
||||
int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int, int where, u8 val)
|
||||
{
|
||||
Pci_driver *drv = (Pci_driver *)bus;
|
||||
dde_kit_log(DEBUG_PCI, "WRITE %p: where: %x val: %x", drv, where, val);
|
||||
lx_log(DEBUG_PCI, "WRITE %p: where: %x val: %x", drv, where, val);
|
||||
drv->config_write(where, val);
|
||||
return 0;
|
||||
}
|
||||
@ -462,6 +534,19 @@ void Backend_memory::free(Genode::Ram_dataspace_capability cap)
|
||||
}
|
||||
|
||||
|
||||
/**********************
|
||||
** asm-generic/io.h **
|
||||
**********************/
|
||||
|
||||
void outb(u8 value, u32 port) { Pci_driver::port_io<u8, false>(port, value); }
|
||||
void outw(u16 value, u32 port) { Pci_driver::port_io<u16, false>(port, value); }
|
||||
void outl(u32 value, u32 port) { Pci_driver::port_io<u32, false>(port, value); }
|
||||
|
||||
u8 inb(u32 port) { return Pci_driver::port_io<u8>(port); }
|
||||
u16 inw(u32 port) { return Pci_driver::port_io<u16>(port); }
|
||||
u32 inl(u32 port) { return Pci_driver::port_io<u32>(port); }
|
||||
|
||||
|
||||
/*****************************************
|
||||
** Platform specific irq cap discovery **
|
||||
*****************************************/
|
||||
|
||||
@ -143,14 +143,14 @@ void __wait_event()
|
||||
|
||||
void init_completion(struct completion *work)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "New completion %p", work);
|
||||
lx_log(DEBUG_COMPLETION, "New completion %p", work);
|
||||
work->done = 0;
|
||||
}
|
||||
|
||||
|
||||
void complete(struct completion *work)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p", work);
|
||||
lx_log(DEBUG_COMPLETION, "%p", work);
|
||||
work->done = 1;
|
||||
|
||||
/* send signal */
|
||||
@ -160,7 +160,7 @@ void complete(struct completion *work)
|
||||
|
||||
void complete_and_exit(struct completion *work, long code)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p", work);
|
||||
lx_log(DEBUG_COMPLETION, "%p", work);
|
||||
complete(work);
|
||||
Routine::remove();
|
||||
}
|
||||
@ -186,7 +186,7 @@ __wait_completion_timeout(struct completion *work, unsigned long timeout)
|
||||
__wait_event();
|
||||
|
||||
if (_j <= jiffies) {
|
||||
dde_kit_log(1, "Timeout");
|
||||
lx_log(1, "Timeout");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@ -200,14 +200,14 @@ __wait_completion_timeout(struct completion *work, unsigned long timeout)
|
||||
unsigned long wait_for_completion_timeout(struct completion *work,
|
||||
unsigned long timeout)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p state: %u timeout: %lu", work, work->done, timeout);
|
||||
lx_log(DEBUG_COMPLETION, "%p state: %u timeout: %lu", work, work->done, timeout);
|
||||
return __wait_completion_timeout(work, timeout);
|
||||
}
|
||||
|
||||
|
||||
int wait_for_completion_interruptible(struct completion *work)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
lx_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
|
||||
__wait_completion(work);
|
||||
return 0;
|
||||
@ -217,7 +217,7 @@ int wait_for_completion_interruptible(struct completion *work)
|
||||
long wait_for_completion_interruptible_timeout(struct completion *work,
|
||||
unsigned long timeout)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
lx_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
__wait_completion(work);
|
||||
return 1;
|
||||
}
|
||||
@ -225,7 +225,7 @@ long wait_for_completion_interruptible_timeout(struct completion *work,
|
||||
|
||||
void wait_for_completion(struct completion *work)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
lx_log(DEBUG_COMPLETION, "%p state: %u", work, work->done);
|
||||
__wait_completion(work);
|
||||
}
|
||||
|
||||
@ -236,7 +236,7 @@ void wait_for_completion(struct completion *work)
|
||||
|
||||
signed long schedule_timeout_uninterruptible(signed long timeout)
|
||||
{
|
||||
dde_kit_log(DEBUG_COMPLETION, "%ld\n", timeout);
|
||||
lx_log(DEBUG_COMPLETION, "%ld\n", timeout);
|
||||
__wait_event();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -105,7 +105,7 @@ class Irq_context : public Genode::List<Irq_context>::Element
|
||||
/* report IRQ to all clients */
|
||||
for (Irq_handler *h = _handler_list.first(); h; h = h->next())
|
||||
if ((handled = _handle_one(h))) {
|
||||
dde_kit_log(DEBUG_IRQ, "IRQ: %u ret: %u h: %p dev: %p", _irq, handled, h->handler, h->dev);
|
||||
lx_log(DEBUG_IRQ, "IRQ: %u ret: %u h: %p dev: %p", _irq, handled, h->handler, h->dev);
|
||||
break;
|
||||
}
|
||||
|
||||
@ -186,7 +186,7 @@ void Irq::check_irq()
|
||||
int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
|
||||
const char *name, void *dev)
|
||||
{
|
||||
dde_kit_log(DEBUG_IRQ, "Request irq %u handler %p", irq, handler);
|
||||
lx_log(DEBUG_IRQ, "Request irq %u handler %p", irq, handler);
|
||||
Irq_context::request_irq(irq, handler, dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -13,111 +13,325 @@
|
||||
|
||||
#include <base/env.h>
|
||||
#include <base/printf.h>
|
||||
#include <base/tslab.h>
|
||||
#include <timer_session/connection.h>
|
||||
#include <util/volatile_object.h>
|
||||
|
||||
#include <extern_c_begin.h>
|
||||
#include <lx_emul.h>
|
||||
#include <extern_c_end.h>
|
||||
|
||||
#include "signal.h"
|
||||
#include "list.h"
|
||||
|
||||
unsigned long jiffies;
|
||||
|
||||
|
||||
static void handler(void *timer);
|
||||
|
||||
namespace Lx {
|
||||
class Timer;
|
||||
}
|
||||
|
||||
/* our local incarnation of sender and receiver */
|
||||
static Signal_helper *_signal = 0;
|
||||
|
||||
static int run_timer(void *);
|
||||
|
||||
/**
|
||||
* Signal context for time-outs
|
||||
* Lx::Timer
|
||||
*/
|
||||
template<typename CLASS>
|
||||
class Timer_context
|
||||
class Lx::Timer
|
||||
{
|
||||
public:
|
||||
|
||||
/**
|
||||
* Context encapsulates a regular linux timer_list
|
||||
*/
|
||||
struct Context : public Lx::List<Context>::Element
|
||||
{
|
||||
enum { INVALID_TIMEOUT = ~0UL };
|
||||
enum Type { LIST, HR };
|
||||
|
||||
Type type;
|
||||
void *timer;
|
||||
bool pending { false };
|
||||
unsigned long timeout { INVALID_TIMEOUT }; /* absolute in jiffies */
|
||||
bool programmed { false };
|
||||
|
||||
Context(struct timer_list *timer) : type(LIST), timer(timer) { }
|
||||
Context(struct hrtimer *timer) : type(HR), timer(timer) { }
|
||||
|
||||
void expires(unsigned long e)
|
||||
{
|
||||
if (type == LIST)
|
||||
static_cast<timer_list *>(timer)->expires = e;
|
||||
}
|
||||
|
||||
void function()
|
||||
{
|
||||
switch (type) {
|
||||
case LIST:
|
||||
{
|
||||
timer_list *t = static_cast<timer_list *>(timer);
|
||||
if (t->function)
|
||||
t->function(t->data);
|
||||
}
|
||||
break;
|
||||
|
||||
case HR:
|
||||
{
|
||||
hrtimer *t = static_cast<hrtimer *>(timer);
|
||||
if (t->function)
|
||||
t->function(t);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
CLASS *_timer; /* Linux timer */
|
||||
dde_kit_timer *_dde_timer; /* DDE kit timer */
|
||||
Genode::Signal_rpc_member<Timer_context> _dispatcher;
|
||||
|
||||
/* call timer function */
|
||||
void _handle(unsigned) { _timer->function(_timer->data); }
|
||||
::Timer::Connection _timer_conn;
|
||||
Lx::List<Context> _list;
|
||||
Routine *_timer_task = Routine::add(run_timer, nullptr, "timer");
|
||||
Genode::Signal_rpc_member<Lx::Timer> _dispatcher;
|
||||
Genode::Tslab<Context, 32 * sizeof(Context)> _timer_alloc;
|
||||
|
||||
public:
|
||||
|
||||
Timer_context(CLASS *timer)
|
||||
: _timer(timer), _dde_timer(0),
|
||||
_dispatcher(_signal->ep(), *this, &Timer_context::_handle) {}
|
||||
bool ready { true };
|
||||
|
||||
/* schedule next timeout */
|
||||
void schedule(unsigned long expires)
|
||||
{
|
||||
if (!_dde_timer)
|
||||
_dde_timer = dde_kit_timer_add(handler, this, expires);
|
||||
else
|
||||
dde_kit_timer_schedule_absolute(_dde_timer, expires);
|
||||
}
|
||||
|
||||
char const *debug() { return "Timer_context"; }
|
||||
private:
|
||||
|
||||
/**
|
||||
* Return true if timer is pending
|
||||
* Lookup local timer
|
||||
*/
|
||||
bool pending() const
|
||||
Context *_find_context(void const *timer)
|
||||
{
|
||||
return _dde_timer ? dde_kit_timer_pending(_dde_timer) : false;
|
||||
for (Context *c = _list.first(); c; c = c->next())
|
||||
if (c->timer == timer)
|
||||
return c;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return internal signal cap
|
||||
* Program the first timer in the list
|
||||
*
|
||||
* The first timer is programmed if the 'programmed' flag was not set
|
||||
* before. The second timer is flagged as not programmed as
|
||||
* 'Timer::trigger_once' invalidates former registered one-shot
|
||||
* timeouts.
|
||||
*/
|
||||
Genode::Signal_context_capability cap() const { return _dispatcher; }
|
||||
void _program_first_timer()
|
||||
{
|
||||
Context *ctx = _list.first();
|
||||
if (!ctx)
|
||||
return;
|
||||
|
||||
if (ctx->programmed)
|
||||
return;
|
||||
|
||||
/* calculate relative microseconds for trigger */
|
||||
unsigned long us = ctx->timeout > jiffies ?
|
||||
jiffies_to_msecs(ctx->timeout - jiffies) * 1000 : 0;
|
||||
_timer_conn.trigger_once(us);
|
||||
|
||||
ctx->programmed = true;
|
||||
|
||||
/* possibly programmed successor must be reprogrammed later */
|
||||
if (Context *next = ctx->next())
|
||||
next->programmed = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert 'timer_list' to 'Timer_conext'
|
||||
* Schedule timer
|
||||
*
|
||||
* Add the context to the scheduling list depending on its timeout
|
||||
* and reprogram the first timer.
|
||||
*/
|
||||
static Timer_context *to_ctx(CLASS const *timer) {
|
||||
return static_cast<Timer_context<CLASS> *>(timer->timer); }
|
||||
|
||||
void remove()
|
||||
void _schedule_timer(Context *ctx, unsigned long expires)
|
||||
{
|
||||
if (_dde_timer)
|
||||
dde_kit_timer_del(_dde_timer);
|
||||
_list.remove(ctx);
|
||||
|
||||
_dde_timer = 0;
|
||||
ctx->timeout = expires;
|
||||
ctx->pending = true;
|
||||
ctx->programmed = false;
|
||||
/*
|
||||
* Also write the timeout value to the expires field in
|
||||
* struct timer_list because the checks
|
||||
* it directly.
|
||||
*/
|
||||
ctx->expires(expires);
|
||||
|
||||
Context *c;
|
||||
for (c = _list.first(); c; c = c->next())
|
||||
if (ctx->timeout <= c->timeout)
|
||||
break;
|
||||
_list.insert_before(ctx, c);
|
||||
|
||||
_program_first_timer();
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle trigger_once signal
|
||||
*/
|
||||
void _handle(unsigned)
|
||||
{
|
||||
ready = true;
|
||||
Routine::schedule_all();
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
Timer(Server::Entrypoint &ep)
|
||||
:
|
||||
_dispatcher(ep, *this, &Lx::Timer::_handle),
|
||||
_timer_alloc(Genode::env()->heap())
|
||||
{
|
||||
_timer_conn.sigh(_dispatcher);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add new linux timer
|
||||
*/
|
||||
template <typename TIMER>
|
||||
void add(TIMER *timer)
|
||||
{
|
||||
Context *t = new (&_timer_alloc) Context(timer);
|
||||
_list.append(t);
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete linux timer
|
||||
*/
|
||||
int del(void *timer)
|
||||
{
|
||||
Context *ctx = _find_context(timer);
|
||||
|
||||
/**
|
||||
* If the timer expired it was already cleaned up after its
|
||||
* execution.
|
||||
*/
|
||||
if (!ctx)
|
||||
return 0;
|
||||
|
||||
int rv = ctx->timeout != Context::INVALID_TIMEOUT ? 1 : 0;
|
||||
|
||||
_list.remove(ctx);
|
||||
destroy(&_timer_alloc, ctx);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initial scheduling of linux timer
|
||||
*/
|
||||
int schedule(void *timer, unsigned long expires)
|
||||
{
|
||||
Context *ctx = _find_context(timer);
|
||||
if (!ctx) {
|
||||
PERR("schedule unknown timer %p", timer);
|
||||
return -1; /* XXX better use 0 as rv? */
|
||||
}
|
||||
|
||||
/*
|
||||
* If timer was already active return 1, otherwise 0. The return
|
||||
* value is needed by mod_timer().
|
||||
*/
|
||||
int rv = ctx->timeout != Context::INVALID_TIMEOUT ? 1 : 0;
|
||||
|
||||
_schedule_timer(ctx, expires);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule next linux timer
|
||||
*/
|
||||
void schedule_next() { _program_first_timer(); }
|
||||
|
||||
/**
|
||||
* Check if the timer is currently pending
|
||||
*/
|
||||
bool pending(void const *timer)
|
||||
{
|
||||
Context *ctx = _find_context(timer);
|
||||
if (!ctx) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return ctx->pending;
|
||||
}
|
||||
|
||||
Context *find(void const *timer) {
|
||||
return _find_context(timer); }
|
||||
|
||||
/**
|
||||
* Update jiffie counter
|
||||
*/
|
||||
void update_jiffies()
|
||||
{
|
||||
jiffies = msecs_to_jiffies(_timer_conn.elapsed_ms());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get first timer context
|
||||
*/
|
||||
Context* first() { return _list.first(); }
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* C handler for DDE timer interface
|
||||
*/
|
||||
static void handler(void *timer)
|
||||
{
|
||||
Timer_context<timer_list> *t = static_cast<Timer_context<timer_list> *>(timer);
|
||||
Genode::Lazy_volatile_object<Lx::Timer> _lx_timer;
|
||||
|
||||
/* set context and submit */
|
||||
_signal->sender().context(t->cap());
|
||||
_signal->sender().submit();
|
||||
|
||||
void Timer::init(Server::Entrypoint &ep)
|
||||
{
|
||||
_lx_timer.construct(ep);
|
||||
|
||||
/* initialize value explicitly */
|
||||
jiffies = 0UL;
|
||||
}
|
||||
|
||||
void Timer::update_jiffies()
|
||||
{
|
||||
_lx_timer->update_jiffies();
|
||||
}
|
||||
|
||||
void Timer::init(Server::Entrypoint &ep) {
|
||||
_signal = new (Genode::env()->heap()) Signal_helper(ep); }
|
||||
static int run_timer(void *)
|
||||
{
|
||||
while (1) {
|
||||
_wait_event(_lx_timer->ready);
|
||||
|
||||
while (Lx::Timer::Context *ctx = _lx_timer->first()) {
|
||||
if (ctx->timeout > jiffies)
|
||||
break;
|
||||
|
||||
ctx->function();
|
||||
_lx_timer->del(ctx->timer);
|
||||
}
|
||||
|
||||
_lx_timer->ready = false;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*******************
|
||||
** linux/timer.h **
|
||||
*******************/
|
||||
|
||||
void init_timer(struct timer_list *timer) {
|
||||
timer->timer = (void *) new (Genode::env()->heap()) Timer_context<timer_list>(timer); }
|
||||
void init_timer(struct timer_list *timer) { }
|
||||
|
||||
|
||||
int mod_timer(struct timer_list *timer, unsigned long expires)
|
||||
{
|
||||
dde_kit_log(DEBUG_TIMER, "Timer: %p j: %lu ex: %lu func %p",
|
||||
timer, jiffies, expires, timer->function);
|
||||
Timer_context<timer_list>::to_ctx(timer)->schedule(expires);
|
||||
return 0;
|
||||
if (!_lx_timer->find(timer))
|
||||
_lx_timer->add(timer);
|
||||
|
||||
return _lx_timer->schedule(timer, expires);
|
||||
}
|
||||
|
||||
|
||||
@ -126,23 +340,24 @@ void setup_timer(struct timer_list *timer,void (*function)(unsigned long),
|
||||
{
|
||||
timer->function = function;
|
||||
timer->data = data;
|
||||
init_timer(timer);
|
||||
}
|
||||
|
||||
|
||||
int timer_pending(const struct timer_list * timer)
|
||||
{
|
||||
bool pending = Timer_context<timer_list>::to_ctx(timer)->pending();
|
||||
dde_kit_log(DEBUG_TIMER, "Pending %p %u", timer, pending);
|
||||
bool pending = _lx_timer->pending(timer);
|
||||
lx_log(DEBUG_TIMER, "Pending %p %u", timer, pending);
|
||||
return pending;
|
||||
}
|
||||
|
||||
|
||||
int del_timer(struct timer_list *timer)
|
||||
{
|
||||
dde_kit_log(DEBUG_TIMER, "Delete timer %p", timer);
|
||||
Timer_context<timer_list>::to_ctx(timer)->remove();
|
||||
return 0;
|
||||
lx_log(DEBUG_TIMER, "Delete timer %p", timer);
|
||||
int rv = _lx_timer->del(timer);
|
||||
_lx_timer->schedule_next();
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
||||
@ -150,25 +365,26 @@ int del_timer(struct timer_list *timer)
|
||||
** linux/hrtimer.h **
|
||||
*********************/
|
||||
|
||||
void hrtimer_init(struct hrtimer *timer, clockid_t clock_id, enum hrtimer_mode mode)
|
||||
{
|
||||
timer->timer = (void *) new (Genode::env()->heap()) Timer_context<hrtimer>(timer);
|
||||
timer->data = timer;
|
||||
}
|
||||
void hrtimer_init(struct hrtimer *timer, clockid_t clock_id, enum hrtimer_mode mode) { }
|
||||
|
||||
|
||||
int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
|
||||
unsigned long delta_ns, const enum hrtimer_mode mode)
|
||||
{
|
||||
unsigned long expires = tim.tv64 / (NSEC_PER_MSEC * DDE_KIT_HZ);
|
||||
dde_kit_log(DEBUG_TIMER, "HR: e: %lu j %lu", jiffies, expires);
|
||||
Timer_context<hrtimer>::to_ctx(timer)->schedule(expires);
|
||||
return 0;
|
||||
unsigned long expires = tim.tv64 / (NSEC_PER_MSEC * HZ);
|
||||
|
||||
if (!_lx_timer->find(timer))
|
||||
_lx_timer->add(timer);
|
||||
|
||||
lx_log(DEBUG_TIMER, "HR: e: %lu j %lu", jiffies, expires);
|
||||
return _lx_timer->schedule(timer, expires);
|
||||
}
|
||||
|
||||
|
||||
int hrtimer_cancel(struct hrtimer *timer)
|
||||
{
|
||||
Timer_context<hrtimer>::to_ctx(timer)->remove();
|
||||
return 0;
|
||||
int rv = _lx_timer->del(timer);
|
||||
_lx_timer->schedule_next();
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -46,7 +46,7 @@
|
||||
|
||||
struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *t, int priv_size)
|
||||
{
|
||||
dde_kit_log(DEBUG_SCSI, "t=%p, priv_size=%d", t, priv_size);
|
||||
lx_log(DEBUG_SCSI, "t=%p, priv_size=%d", t, priv_size);
|
||||
|
||||
static int free = 1;
|
||||
|
||||
@ -143,9 +143,9 @@ void _scsi_free_command(struct scsi_cmnd *cmnd)
|
||||
static void inquiry_done(struct scsi_cmnd *cmnd)
|
||||
{
|
||||
char *data = (char *)scsi_buffer_data(cmnd);
|
||||
dde_kit_printf("Vendor id: %c%c%c%c%c%c%c%c Product id: %s\n",
|
||||
data[8], data[9], data[10], data[11], data[12],
|
||||
data[13], data[14], data[15], &data[16]);
|
||||
lx_printf("Vendor id: %c%c%c%c%c%c%c%c Product id: %s\n",
|
||||
data[8], data[9], data[10], data[11], data[12],
|
||||
data[13], data[14], data[15], &data[16]);
|
||||
complete(cmnd->back);
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user