Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

retire PUBLIC, PRIVATE and FORWARD

Browse Source
This commit is contained in:
Ben Gras
2012-03-25 20:25:53 +02:00
parent 6a73e85ad1
commit 7336a67dfe
603 changed files with 5776 additions and 5779 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
lib/libddekit/src/condvar.c
View File

@@ -20,7 +20,7 @@ struct ddekit_condvar {
/*****************************************************************************/
/* ddekit_condvar_init */
/*****************************************************************************/
PUBLIC ddekit_condvar_t * ddekit_condvar_init(void) {
ddekit_condvar_t * ddekit_condvar_init(void) {
ddekit_condvar_t *cv;
cv = (ddekit_condvar_t *) ddekit_simple_malloc(sizeof(ddekit_condvar_t));
DDEBUG_MSG_VERBOSE("cv: %p", cv);
@@ -30,7 +30,7 @@ PUBLIC ddekit_condvar_t * ddekit_condvar_init(void) {
/*****************************************************************************/
/* ddekit_condvar_deinit */
/*****************************************************************************/
PUBLIC void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
DDEBUG_MSG_VERBOSE("cv: %p", cvp);
ddekit_simple_free(cvp);
}
@@ -38,7 +38,7 @@ PUBLIC void ddekit_condvar_deinit(ddekit_condvar_t *cvp) {
/*****************************************************************************/
/* ddekit_condvar_wait */
/*****************************************************************************/
PUBLIC void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
DDEBUG_MSG_VERBOSE("wait cv: %p, thread id: %d, name: %s",
cv, ddekit_thread_myself()->id, ddekit_thread_myself()->name);
@@ -65,7 +65,7 @@ PUBLIC void ddekit_condvar_wait(ddekit_condvar_t *cv, ddekit_lock_t *mp) {
/*****************************************************************************/
/* ddekit_condvar_wait_timed */
/*****************************************************************************/
PUBLIC int ddekit_condvar_wait_timed
int ddekit_condvar_wait_timed
(ddekit_condvar_t *cvp, ddekit_lock_t *mp, int timo)
{
/*
@@ -79,7 +79,7 @@ PUBLIC int ddekit_condvar_wait_timed
/*****************************************************************************/
/* ddekit_condvar_signal */
/*****************************************************************************/
PUBLIC void ddekit_condvar_signal(ddekit_condvar_t *cv)
void ddekit_condvar_signal(ddekit_condvar_t *cv)
{
DDEBUG_MSG_VERBOSE("cv: %p", cv);

10
lib/libddekit/src/dde.c
View File

@@ -22,13 +22,13 @@ void ddekit_pgtab_init(void);
static ddekit_thread_t *dispatch_th = 0;
FORWARD void dispatcher_thread(void * unused);
FORWARD void ddekit_dispatcher_thread_init(void);
static void dispatcher_thread(void * unused);
static void ddekit_dispatcher_thread_init(void);
/****************************************************************************/
/* dispatcher_thread */
/****************************************************************************/
PRIVATE void dispatcher_thread(void *unused) {
static void dispatcher_thread(void *unused) {
/*
* Gets all messages and dispatches them.
@@ -92,7 +92,7 @@ PRIVATE void dispatcher_thread(void *unused) {
/****************************************************************************/
/* ddekit_dispatcher_thread_init */
/****************************************************************************/
PRIVATE void ddekit_dispatcher_thread_init()
static void ddekit_dispatcher_thread_init()
{
dispatch_th = ddekit_thread_create(dispatcher_thread, NULL, "dispatch");
@@ -103,7 +103,7 @@ PRIVATE void ddekit_dispatcher_thread_init()
/****************************************************************************/
/* ddekit_init */
/****************************************************************************/
PUBLIC void ddekit_init(void)
void ddekit_init(void)
{
sef_startup();

4
lib/libddekit/src/initcall.c
View File

@@ -15,7 +15,7 @@ static struct __ddekit_initcall_s head = {0,0,0};
/****************************************************************************/
/* __ddekit_add_initcall */
/****************************************************************************/
PUBLIC void __attribute__((used))
void __attribute__((used))
__ddekit_add_initcall(struct __ddekit_initcall_s * ic) {
/* This function is required for the DDEKIT_INITCALL makro */
@@ -42,7 +42,7 @@ __ddekit_add_initcall(struct __ddekit_initcall_s * ic) {
/****************************************************************************/
/* ddekit_do_initcalls */
/****************************************************************************/
PUBLIC void ddekit_do_initcalls()
void ddekit_do_initcalls()
{
struct __ddekit_initcall_s *i = 0;

22
lib/libddekit/src/irq.c
View File

@@ -32,16 +32,16 @@ static ddekit_lock_t lock;
*****************************************************************************/
FORWARD void ddekit_irq_lock(void);
FORWARD void ddekit_irq_unlock(void);
FORWARD struct ddekit_irq_s* find_by_irq(int irq);
FORWARD void ddekit_irq_remove(struct ddekit_irq_s *irq_s);
FORWARD void ddekit_irq_thread(void *data);
static void ddekit_irq_lock(void);
static void ddekit_irq_unlock(void);
static struct ddekit_irq_s* find_by_irq(int irq);
static void ddekit_irq_remove(struct ddekit_irq_s *irq_s);
static void ddekit_irq_thread(void *data);
/******************************************************************************
* ddekit_irq_lock *
*****************************************************************************/
PRIVATE void ddekit_irq_lock(void)
static void ddekit_irq_lock(void)
{
ddekit_lock_lock(&lock);
}
@@ -49,7 +49,7 @@ PRIVATE void ddekit_irq_lock(void)
/******************************************************************************
* ddekit_irq_unlock *
*****************************************************************************/
PRIVATE void ddekit_irq_unlock(void)
static void ddekit_irq_unlock(void)
{
ddekit_lock_unlock(&lock);
}
@@ -57,7 +57,7 @@ PRIVATE void ddekit_irq_unlock(void)
/******************************************************************************
* find_by_irq *
*****************************************************************************/
PRIVATE struct ddekit_irq_s * find_by_irq(int irq)
static struct ddekit_irq_s * find_by_irq(int irq)
{
struct ddekit_irq_s * irq_s;
ddekit_irq_lock();
@@ -80,7 +80,7 @@ PRIVATE struct ddekit_irq_s * find_by_irq(int irq)
/******************************************************************************
* ddekit_irq_remove *
*****************************************************************************/
PRIVATE void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
static void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
{
struct ddekit_irq_s *i;
@@ -114,7 +114,7 @@ PRIVATE void ddekit_irq_remove(struct ddekit_irq_s *irq_s)
/******************************************************************************
* ddekit_irq_thread *
*****************************************************************************/
PRIVATE void ddekit_irq_thread(void *data)
static void ddekit_irq_thread(void *data)
{
/* For each IRQ line an own thread is started */
@@ -239,7 +239,7 @@ void ddekit_init_irqs()
/******************************************************************************
* _ddekit_interrupt_trigger *
*****************************************************************************/
PUBLIC void _ddekit_interrupt_trigger(int irq)
void _ddekit_interrupt_trigger(int irq)
{
struct ddekit_irq_s *irq_s;

14
lib/libddekit/src/lock.c
View File

@@ -21,7 +21,7 @@ struct ddekit_lock {
/******************************************************************************
* ddekit_lock_init_locked *
*****************************************************************************/
PUBLIC void ddekit_lock_init_locked(ddekit_lock_t *mtx)
void ddekit_lock_init_locked(ddekit_lock_t *mtx)
{
(*mtx) = (struct ddekit_lock *)
ddekit_simple_malloc(sizeof(struct ddekit_lock));
@@ -33,7 +33,7 @@ PUBLIC void ddekit_lock_init_locked(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_init_unlocked *
*****************************************************************************/
PUBLIC void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
{
(*mtx) = (struct ddekit_lock *)
ddekit_simple_malloc(sizeof(struct ddekit_lock));
@@ -44,7 +44,7 @@ PUBLIC void ddekit_lock_init_unlocked(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_deinit *
*****************************************************************************/
PUBLIC void ddekit_lock_deinit (ddekit_lock_t *mtx)
void ddekit_lock_deinit (ddekit_lock_t *mtx)
{
ddekit_simple_free(*mtx);
}
@@ -52,7 +52,7 @@ PUBLIC void ddekit_lock_deinit (ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_lock *
*****************************************************************************/
PUBLIC void ddekit_lock_lock (ddekit_lock_t *mtx)
void ddekit_lock_lock (ddekit_lock_t *mtx)
{
if ((*mtx)->owner == NULL) {
(*mtx)->owner = ddekit_thread_myself();
@@ -84,7 +84,7 @@ PUBLIC void ddekit_lock_lock (ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_try_lock *
*****************************************************************************/
PUBLIC int ddekit_lock_try_lock(ddekit_lock_t *mtx)
int ddekit_lock_try_lock(ddekit_lock_t *mtx)
{
if ((*mtx)->owner == NULL) {
(*mtx)->owner = ddekit_thread_myself();
@@ -97,7 +97,7 @@ PUBLIC int ddekit_lock_try_lock(ddekit_lock_t *mtx)
/******************************************************************************
* ddekit_lock_unlock *
*****************************************************************************/
PUBLIC void ddekit_lock_unlock (ddekit_lock_t *mtx) {
void ddekit_lock_unlock (ddekit_lock_t *mtx) {
ddekit_assert((*mtx)->owner != NULL);
(*mtx)->owner = NULL;
if((*mtx)->wait_queue) {
@@ -112,7 +112,7 @@ PUBLIC void ddekit_lock_unlock (ddekit_lock_t *mtx) {
/******************************************************************************
* ddekit_lock_owner *
*****************************************************************************/
PUBLIC int ddekit_lock_owner(ddekit_lock_t *mtx) {
int ddekit_lock_owner(ddekit_lock_t *mtx) {
return ddekit_thread_get_id((*mtx)->owner);
}

52
lib/libddekit/src/mem.c
View File

@@ -38,22 +38,22 @@ struct ddekit_slab {
struct ddekit_slab_slab empty;
};
FORWARD void ddekit_slab_lock(struct ddekit_slab * sc);
FORWARD void ddekit_slab_unlock(struct ddekit_slab * sc);
FORWARD struct ddekit_slab_slab * ddekit_slab_find_slab(struct
static void ddekit_slab_lock(struct ddekit_slab * sc);
static void ddekit_slab_unlock(struct ddekit_slab * sc);
static struct ddekit_slab_slab * ddekit_slab_find_slab(struct
ddekit_slab * sc, void * obj);
FORWARD void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
static void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_slab_remove(struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_grow(struct ddekit_slab * sc);
FORWARD void *ddekit_slab_getobj(struct ddekit_slab_slab *s);
FORWARD void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int
static void ddekit_slab_slab_remove(struct ddekit_slab_slab *s);
static void ddekit_slab_grow(struct ddekit_slab * sc);
static void *ddekit_slab_getobj(struct ddekit_slab_slab *s);
static void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int
cont);
/******************************************************************************
* ddekit_simple_malloc *
*****************************************************************************/
PUBLIC void *ddekit_simple_malloc(unsigned size)
void *ddekit_simple_malloc(unsigned size)
{
/* Simple memory allocation... malloc and free should be ok... */
void * r = malloc(size);
@@ -67,7 +67,7 @@ PUBLIC void *ddekit_simple_malloc(unsigned size)
/******************************************************************************
* ddekit_simple_free *
*****************************************************************************/
PUBLIC void ddekit_simple_free(void *p)
void ddekit_simple_free(void *p)
{
DDEBUG_MSG_VERBOSE("%p", p);
free(p);
@@ -76,7 +76,7 @@ PUBLIC void ddekit_simple_free(void *p)
/******************************************************************************
* ddekit_large_malloc *
*****************************************************************************/
PUBLIC void *ddekit_large_malloc(int size)
void *ddekit_large_malloc(int size)
{
ddekit_addr_t phys;
/* allocate a piece of coniguous memory */
@@ -93,7 +93,7 @@ PUBLIC void *ddekit_large_malloc(int size)
/******************************************************************************
* ddekit_large_free *
*****************************************************************************/
PUBLIC void ddekit_large_free(void *p)
void ddekit_large_free(void *p)
{
unsigned len;
DDEBUG_MSG_VERBOSE("get size of region %x", p);
@@ -109,7 +109,7 @@ PUBLIC void ddekit_large_free(void *p)
/******************************************************************************
* ddekit_contig_malloc *
*****************************************************************************/
PUBLIC void *ddekit_contig_malloc(unsigned long size, unsigned long low,
void *ddekit_contig_malloc(unsigned long size, unsigned long low,
unsigned long high, unsigned long aligment,
unsigned long boundary)
{
@@ -120,21 +120,21 @@ PUBLIC void *ddekit_contig_malloc(unsigned long size, unsigned long low,
/******************************************************************************
* ddekit_slab_lock *
*****************************************************************************/
PRIVATE DDEKIT_INLINE void ddekit_slab_lock(struct ddekit_slab * sc) {
static DDEKIT_INLINE void ddekit_slab_lock(struct ddekit_slab * sc) {
ddekit_lock_lock(&sc->lock);
}
/******************************************************************************
* ddekit_slab_unlock *
*****************************************************************************/
PRIVATE DDEKIT_INLINE void ddekit_slab_unlock(struct ddekit_slab * sc) {
static DDEKIT_INLINE void ddekit_slab_unlock(struct ddekit_slab * sc) {
ddekit_lock_unlock(&sc->lock);
}
/******************************************************************************
* ddekit_slab_find_slab *
*****************************************************************************/
PRIVATE struct ddekit_slab_slab *
static struct ddekit_slab_slab *
ddekit_slab_find_slab(struct ddekit_slab * sc, void * obj)
{
@@ -174,7 +174,7 @@ static void ddekit_slab_slab_insert(struct ddekit_slab_slab *list,
/******************************************************************************
* ddekit_slab_slab_remove *
*****************************************************************************/
PRIVATE void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
static void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
{
s->next->prev = s->prev;
s->prev->next = s->next;
@@ -185,7 +185,7 @@ PRIVATE void ddekit_slab_slab_remove(struct ddekit_slab_slab *s)
/******************************************************************************
* ddekit_slab_grow *
*****************************************************************************/
PRIVATE void ddekit_slab_grow(struct ddekit_slab *sc)
static void ddekit_slab_grow(struct ddekit_slab *sc)
{
/*
* NOTE:
@@ -249,7 +249,7 @@ PRIVATE void ddekit_slab_grow(struct ddekit_slab *sc)
/******************************************************************************
* ddekit_slab_getobj *
*****************************************************************************/
PRIVATE void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
static void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
{
struct ddekit_slab *sc;
void *ret = 0;
@@ -284,7 +284,7 @@ PRIVATE void *ddekit_slab_getobj(struct ddekit_slab_slab *s)
/******************************************************************************
* ddekit_slab_alloc *
*****************************************************************************/
PUBLIC void *ddekit_slab_alloc(struct ddekit_slab * sc)
void *ddekit_slab_alloc(struct ddekit_slab * sc)
{
struct ddekit_slab_slab *s=0;
@@ -318,7 +318,7 @@ PUBLIC void *ddekit_slab_alloc(struct ddekit_slab * sc)
/******************************************************************************
* ddekit_slab_free *
*****************************************************************************/
PUBLIC void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
{
void **p;
@@ -354,7 +354,7 @@ PUBLIC void ddekit_slab_free(struct ddekit_slab *sc, void* obj)
/******************************************************************************
* ddekit_slab_set_data *
*****************************************************************************/
PUBLIC void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
{
ddekit_slab_lock(sc);
sc->data = data;
@@ -364,7 +364,7 @@ PUBLIC void ddekit_slab_set_data(struct ddekit_slab * sc, void *data)
/******************************************************************************
* ddekit_slab_get_data *
*****************************************************************************/
PUBLIC void *ddekit_slab_get_data (struct ddekit_slab *sc)
void *ddekit_slab_get_data (struct ddekit_slab *sc)
{
void *ret;
ddekit_slab_lock(sc);
@@ -377,7 +377,7 @@ PUBLIC void *ddekit_slab_get_data (struct ddekit_slab *sc)
/******************************************************************************
* ddekit_slab_init *
*****************************************************************************/
PUBLIC struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
{
struct ddekit_slab * sc = 0;
@@ -412,7 +412,7 @@ PUBLIC struct ddekit_slab * ddekit_slab_init(unsigned size, int contiguous)
/******************************************************************************
* ddekit_slab_free_slab *
*****************************************************************************/
PRIVATE void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
static void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
{
struct ddekit_slab_slab *s,*t;
@@ -442,7 +442,7 @@ PRIVATE void ddekit_slab_free_slab(struct ddekit_slab_slab * sl, int cont)
/******************************************************************************
* ddekit_slab_destroy *
*****************************************************************************/
PUBLIC void ddekit_slab_destroy(struct ddekit_slab *sc)
void ddekit_slab_destroy(struct ddekit_slab *sc)
{
DDEBUG_MSG_VERBOSE("%p full", sc);
ddekit_slab_free_slab(&sc->full,sc->contiguous);

12
lib/libddekit/src/msg_queue.c
View File

@@ -25,14 +25,14 @@ struct ddekit_minix_msg_q {
struct ddekit_minix_msg_q *next;
};
PRIVATE struct ddekit_minix_msg_q * _list = NULL;
FORWARD void _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq,
static struct ddekit_minix_msg_q * _list = NULL;
static void _ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq,
message *m);
/*****************************************************************************
* ddekit_minix_create_msg_q *
****************************************************************************/
PUBLIC struct ddekit_minix_msg_q *
struct ddekit_minix_msg_q *
ddekit_minix_create_msg_q(unsigned from, unsigned to)
{
struct ddekit_minix_msg_q *mq = (struct ddekit_minix_msg_q *)
@@ -58,7 +58,7 @@ ddekit_minix_create_msg_q(unsigned from, unsigned to)
/*****************************************************************************
* ddekit_minix_deregister_msg_q *
****************************************************************************/
PUBLIC void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
{
struct ddekit_minix_msg_q *prev =_list, *it;
@@ -81,7 +81,7 @@ PUBLIC void ddekit_minix_deregister_msg_q(struct ddekit_minix_msg_q *mq)
/*****************************************************************************
* _ddekit_minix_queue_msg *
****************************************************************************/
PRIVATE void
static void
_ddekit_minix_queue_msg(struct ddekit_minix_msg_q *mq, message *m)
{
int full;
@@ -137,7 +137,7 @@ void ddekit_minix_queue_msg(message *m)
/*****************************************************************************
* ddekit_minix_rcv *
****************************************************************************/
PUBLIC void ddekit_minix_rcv(struct ddekit_minix_msg_q *mq, message *m)
void ddekit_minix_rcv(struct ddekit_minix_msg_q *mq, message *m)
{
DDEBUG_MSG_VERBOSE("waiting for message");

4
lib/libddekit/src/panic.c
View File

@@ -5,7 +5,7 @@
/****************************************************************************/
/* ddekit_panic */
/****************************************************************************/
PUBLIC void ddekit_panic(char *fmt, ...)
void ddekit_panic(char *fmt, ...)
{
int r;
@@ -24,7 +24,7 @@ PUBLIC void ddekit_panic(char *fmt, ...)
/****************************************************************************/
/* ddekit_debug */
/****************************************************************************/
PUBLIC void ddekit_debug(char *fmt, ...)
void ddekit_debug(char *fmt, ...)
{
int r;
va_list va;

52
lib/libddekit/src/pci.c
View File

@@ -34,13 +34,13 @@ struct ddekit_pci_dev {
struct ddekit_pci_dev pci_devs[PCI_MAX_DEVS];
FORWARD struct ddekit_pci_dev * ddekit_get_dev_helper(int bus, int slot,
static struct ddekit_pci_dev * ddekit_get_dev_helper(int bus, int slot,
int func);
/****************************************************************************/
/* ddekit_pci_init_only_one */
/****************************************************************************/
PUBLIC void ddekit_pci_init_only_one(int skip)
void ddekit_pci_init_only_one(int skip)
{
/*
* If skip is not PCI_TAKE_ALL this function will skip skip PCI DEVICES
@@ -108,7 +108,7 @@ PUBLIC void ddekit_pci_init_only_one(int skip)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PUBLIC void ddekit_pci_init(void)
void ddekit_pci_init(void)
{
ddekit_pci_init_only_one(DDEKIT_PCI_ANY_ID);
}
@@ -133,7 +133,7 @@ int ddekit_pci_get_device(int nr, int *bus, int *slot, int *func)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PRIVATE struct ddekit_pci_dev *
static struct ddekit_pci_dev *
ddekit_get_dev_helper(int bus, int slot, int func)
{
/*
@@ -153,7 +153,7 @@ ddekit_get_dev_helper(int bus, int slot, int func)
/****************************************************************************/
/* ddekit_pci_read */
/****************************************************************************/
PUBLIC int ddekit_pci_read
int ddekit_pci_read
(int bus, int slot, int func, int pos, int len, ddekit_uint32_t *val)
{
switch(len) {
@@ -172,7 +172,7 @@ PUBLIC int ddekit_pci_read
/****************************************************************************/
/* ddekit_pci_write */
/****************************************************************************/
PUBLIC int ddekit_pci_write
int ddekit_pci_write
(int bus, int slot, int func, int pos, int len, ddekit_uint32_t val)
{
switch(len) {
@@ -191,7 +191,7 @@ PUBLIC int ddekit_pci_write
/****************************************************************************/
/* ddekit_pci_readb */
/****************************************************************************/
PUBLIC int ddekit_pci_readb (int bus, int slot, int func, int pos, ddekit_uint8_t *val) {
int ddekit_pci_readb (int bus, int slot, int func, int pos, ddekit_uint8_t *val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
*val=0;
@@ -209,7 +209,7 @@ PUBLIC int ddekit_pci_readb (int bus, int slot, int func, int pos, ddekit_uint8_
/****************************************************************************/
/* ddekit_pci_readw */
/****************************************************************************/
PUBLIC int ddekit_pci_readw
int ddekit_pci_readw
(int bus, int slot, int func, int pos, ddekit_uint16_t *val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
@@ -228,7 +228,7 @@ PUBLIC int ddekit_pci_readw
/****************************************************************************/
/* ddekit_pci_readl */
/****************************************************************************/
PUBLIC int ddekit_pci_readl
int ddekit_pci_readl
(int bus, int slot, int func, int pos, ddekit_uint32_t *val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (func!=0) {
@@ -247,7 +247,7 @@ PUBLIC int ddekit_pci_readl
/****************************************************************************/
/* ddekit_pci_writeb */
/****************************************************************************/
PUBLIC int ddekit_pci_writeb
int ddekit_pci_writeb
(int bus, int slot, int func, int pos, ddekit_uint8_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -262,7 +262,7 @@ PUBLIC int ddekit_pci_writeb
/****************************************************************************/
/* ddekit_pci_writel */
/****************************************************************************/
PUBLIC int ddekit_pci_writew
int ddekit_pci_writew
(int bus, int slot, int func, int pos, ddekit_uint16_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -277,7 +277,7 @@ PUBLIC int ddekit_pci_writew
/****************************************************************************/
/* ddekit_pci_writel */
/****************************************************************************/
PUBLIC int ddekit_pci_writel
int ddekit_pci_writel
(int bus, int slot, int func, int pos, ddekit_uint32_t val) {
struct ddekit_pci_dev * dev = ddekit_get_dev_helper(bus, slot, func);
if (dev) {
@@ -291,7 +291,7 @@ PUBLIC int ddekit_pci_writel
/****************************************************************************/
/* ddekit_pci_find_device */
/****************************************************************************/
PUBLIC struct ddekit_pci_dev *ddekit_pci_find_device
struct ddekit_pci_dev *ddekit_pci_find_device
(int *bus, int *slot, int *func, struct ddekit_pci_dev *start)
{
int i,search=0;
@@ -323,7 +323,7 @@ PUBLIC struct ddekit_pci_dev *ddekit_pci_find_device
/****************************************************************************/
/* ddekit_pci_get_vendor */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
{
return dev->vid;
}
@@ -331,7 +331,7 @@ PUBLIC unsigned short ddekit_pci_get_vendor(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_device_id */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
{
return dev->did;
}
@@ -344,7 +344,7 @@ PUBLIC unsigned short ddekit_pci_get_device_id(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_enable_device */
/****************************************************************************/
PUBLIC int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -353,7 +353,7 @@ PUBLIC int ddekit_pci_enable_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_disable_device */
/****************************************************************************/
PUBLIC int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -362,7 +362,7 @@ PUBLIC int ddekit_pci_disable_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_set_master */
/****************************************************************************/
PUBLIC void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
}
@@ -371,7 +371,7 @@ PUBLIC void ddekit_pci_set_master(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_sub_vendor */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -380,7 +380,7 @@ PUBLIC unsigned short ddekit_pci_get_sub_vendor(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_sub_device */
/****************************************************************************/
PUBLIC unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -389,7 +389,7 @@ PUBLIC unsigned short ddekit_pci_get_sub_device(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_dev_class */
/****************************************************************************/
PUBLIC unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -398,7 +398,7 @@ PUBLIC unsigned ddekit_pci_get_dev_class(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_irq */
/****************************************************************************/
PUBLIC unsigned long
unsigned long
ddekit_pci_get_irq(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
@@ -408,7 +408,7 @@ ddekit_pci_get_irq(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_name */
/****************************************************************************/
PUBLIC char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -417,7 +417,7 @@ PUBLIC char *ddekit_pci_get_name(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_slot_name */
/****************************************************************************/
PUBLIC char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
{
WARN_UNIMPL;
return 0;
@@ -426,7 +426,7 @@ PUBLIC char *ddekit_pci_get_slot_name(struct ddekit_pci_dev *dev)
/****************************************************************************/
/* ddekit_pci_get_resource */
/****************************************************************************/
PUBLIC ddekit_pci_res_t *
ddekit_pci_res_t *
ddekit_pci_get_resource(struct ddekit_pci_dev *dev, unsigned int idx)
{
WARN_UNIMPL;
@@ -436,7 +436,7 @@ ddekit_pci_get_resource(struct ddekit_pci_dev *dev, unsigned int idx)
/****************************************************************************/
/* ddekit_pci_irq_enable */
/****************************************************************************/
PUBLIC int ddekit_pci_irq_enable
int ddekit_pci_irq_enable
(int bus, int slot, int func, int pin, int *irq)
{
/* call not needed */

54
lib/libddekit/src/pgtab.c
View File

@@ -23,14 +23,14 @@
#include "debug.h"
FORWARD void lock_pgtab(void);
FORWARD void unlock_pgtab(void);
FORWARD struct dde_pgtab_region * allocate_region(void);
FORWARD void free_region(struct dde_pgtab_region *r);
FORWARD void add_region(struct dde_pgtab_region *r);
FORWARD void rm_region(struct dde_pgtab_region *r);
FORWARD struct dde_pgtab_region * find_region_virt(ddekit_addr_t va);
FORWARD struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa);
static void lock_pgtab(void);
static void unlock_pgtab(void);
static struct dde_pgtab_region * allocate_region(void);
static void free_region(struct dde_pgtab_region *r);
static void add_region(struct dde_pgtab_region *r);
static void rm_region(struct dde_pgtab_region *r);
static struct dde_pgtab_region * find_region_virt(ddekit_addr_t va);
static struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa);
struct dde_pgtab_region {
ddekit_addr_t vm_start;
@@ -41,8 +41,8 @@ struct dde_pgtab_region {
struct dde_pgtab_region *prev;
};
PRIVATE struct dde_pgtab_region head = {0,0,0,0,&head,&head};
PRIVATE ddekit_lock_t lock;
static struct dde_pgtab_region head = {0,0,0,0,&head,&head};
static ddekit_lock_t lock;
/*
* INTERNAL HELPERS
@@ -51,7 +51,7 @@ PRIVATE ddekit_lock_t lock;
/****************************************************************************/
/* lock_pgtab */
/****************************************************************************/
PRIVATE void lock_pgtab()
static void lock_pgtab()
{
ddekit_lock_lock(&lock);
}
@@ -60,7 +60,7 @@ PRIVATE void lock_pgtab()
/****************************************************************************/
/* unlock_pgtab */
/****************************************************************************/
PRIVATE void unlock_pgtab()
static void unlock_pgtab()
{
ddekit_lock_unlock(&lock);
}
@@ -68,7 +68,7 @@ PRIVATE void unlock_pgtab()
/****************************************************************************/
/* dde_pgtab_region */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * allocate_region()
static struct dde_pgtab_region * allocate_region()
{
struct dde_pgtab_region * res;
@@ -84,7 +84,7 @@ PRIVATE struct dde_pgtab_region * allocate_region()
/****************************************************************************/
/* free_region */
/****************************************************************************/
PRIVATE void free_region(struct dde_pgtab_region *r)
static void free_region(struct dde_pgtab_region *r)
{
ddekit_simple_free(r);
}
@@ -92,7 +92,7 @@ PRIVATE void free_region(struct dde_pgtab_region *r)
/****************************************************************************/
/* add_region */
/****************************************************************************/
PRIVATE void add_region (struct dde_pgtab_region *r)
static void add_region (struct dde_pgtab_region *r)
{
r->next = head.next;
head.next = r;
@@ -108,7 +108,7 @@ PRIVATE void add_region (struct dde_pgtab_region *r)
/****************************************************************************/
/* rm_region */
/****************************************************************************/
PRIVATE void rm_region(struct dde_pgtab_region *r)
static void rm_region(struct dde_pgtab_region *r)
{
if (r->next) {
r->next->prev = r->prev;
@@ -124,7 +124,7 @@ PRIVATE void rm_region(struct dde_pgtab_region *r)
/****************************************************************************/
/* find_region_virt */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
static struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
{
struct dde_pgtab_region * r;
@@ -146,7 +146,7 @@ PRIVATE struct dde_pgtab_region * find_region_virt(ddekit_addr_t va)
/****************************************************************************/
/* find_region_phys */
/****************************************************************************/
PRIVATE struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
static struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
{
struct dde_pgtab_region * r;
@@ -166,7 +166,7 @@ PRIVATE struct dde_pgtab_region * find_region_phys(ddekit_addr_t pa)
/****************************************************************************/
/* ddekit_pgtab_do_fo_each_region */
/****************************************************************************/
PUBLIC void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
struct dde_pgtab_region * r;
for( r = head.next; r != &head ; r = r->next ) {
@@ -182,7 +182,7 @@ PUBLIC void ddekit_pgtab_do_fo_each_region(void (*func) (unsigned, unsigned)) {
/****************************************************************************/
/* ddekit_pgtab_set_region */
/****************************************************************************/
PUBLIC void ddekit_pgtab_set_region(void *virt, ddekit_addr_t phys, int pages, int type)
void ddekit_pgtab_set_region(void *virt, ddekit_addr_t phys, int pages, int type)
{
ddekit_pgtab_set_region_with_size(virt, phys, (4096)*pages, type);
}
@@ -190,7 +190,7 @@ PUBLIC void ddekit_pgtab_set_region(void *virt, ddekit_addr_t phys, int pages, i
/****************************************************************************/
/* ddekit_pgtab_set_region_with_size */
/****************************************************************************/
PUBLIC void ddekit_pgtab_set_region_with_size(void *virt, ddekit_addr_t phys, int size, int type)
void ddekit_pgtab_set_region_with_size(void *virt, ddekit_addr_t phys, int size, int type)
{
struct dde_pgtab_region * r;
@@ -212,7 +212,7 @@ PUBLIC void ddekit_pgtab_set_region_with_size(void *virt, ddekit_addr_t phys, in
/****************************************************************************/
/* ddekit_pgtab_clear_region */
/****************************************************************************/
PUBLIC void ddekit_pgtab_clear_region(void *virt, int type) {
void ddekit_pgtab_clear_region(void *virt, int type) {
struct dde_pgtab_region *r;
@@ -234,7 +234,7 @@ PUBLIC void ddekit_pgtab_clear_region(void *virt, int type) {
/****************************************************************************/
/* ddekit_pgtab_get_physaddr */
/****************************************************************************/
PUBLIC ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
{
struct dde_pgtab_region *r;
ddekit_addr_t ret = 0;
@@ -253,7 +253,7 @@ PUBLIC ddekit_addr_t ddekit_pgtab_get_physaddr(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_get_virtaddr */
/****************************************************************************/
PUBLIC ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
{
struct dde_pgtab_region *r;
lock_pgtab();
@@ -270,7 +270,7 @@ PUBLIC ddekit_addr_t ddekit_pgtab_get_virtaddr(const ddekit_addr_t physical)
/****************************************************************************/
/* ddekit_pgtab_get_size */
/****************************************************************************/
PUBLIC int ddekit_pgtab_get_type(const void *virt)
int ddekit_pgtab_get_type(const void *virt)
{
/*
* needed for dde fbsd
@@ -287,7 +287,7 @@ PUBLIC int ddekit_pgtab_get_type(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_get_size */
/****************************************************************************/
PUBLIC int ddekit_pgtab_get_size(const void *virt)
int ddekit_pgtab_get_size(const void *virt)
{
/*
* needed for fbsd
@@ -306,7 +306,7 @@ PUBLIC int ddekit_pgtab_get_size(const void *virt)
/****************************************************************************/
/* ddekit_pgtab_init */
/****************************************************************************/
PUBLIC void ddekit_pgtab_init() {
void ddekit_pgtab_init() {
/* called by ddekit_init() */
ddekit_lock_init(&lock);
}

6
lib/libddekit/src/printf.c
View File

@@ -4,7 +4,7 @@
/****************************************************************************/
/* ddekit_print */
/****************************************************************************/
PUBLIC int ddekit_print(const char* c)
int ddekit_print(const char* c)
{
return ddekit_printf(c);
}
@@ -12,7 +12,7 @@ PUBLIC int ddekit_print(const char* c)
/****************************************************************************/
/* ddekit_printf */
/****************************************************************************/
PUBLIC int ddekit_printf(const char* fmt, ...)
int ddekit_printf(const char* fmt, ...)
{
int r;
va_list va;
@@ -27,7 +27,7 @@ PUBLIC int ddekit_printf(const char* fmt, ...)
/****************************************************************************/
/* ddekit_vprintf */
/****************************************************************************/
PUBLIC int ddekit_vprintf(const char *fmt, va_list va)
int ddekit_vprintf(const char *fmt, va_list va)
{
return vprintf(fmt, va);
}

24
lib/libddekit/src/resource.c
View File

@@ -16,7 +16,7 @@
/****************************************************************************/
/* ddekit_release_dma */
/****************************************************************************/
PUBLIC int ddekit_request_dma(int nr) {
int ddekit_request_dma(int nr) {
WARN_UNIMPL;
/* do we stil use isa dma ? imho no.*/
return -1;
@@ -25,7 +25,7 @@ PUBLIC int ddekit_request_dma(int nr) {
/****************************************************************************/
/* ddekit_request_dma */
/****************************************************************************/
PUBLIC int ddekit_release_dma(int nr) {
int ddekit_release_dma(int nr) {
WARN_UNIMPL;
/* do we stil use isa dma ? imho no.*/
return -1;
@@ -37,17 +37,17 @@ PUBLIC int ddekit_release_dma(int nr) {
/****************************************************************************/
/* ddekit_release/request_io */
/****************************************************************************/
PUBLIC int ddekit_request_io (ddekit_addr_t start, ddekit_addr_t count) {
int ddekit_request_io (ddekit_addr_t start, ddekit_addr_t count) {
return 0;
}
PUBLIC int ddekit_release_io (ddekit_addr_t start, ddekit_addr_t count) {
int ddekit_release_io (ddekit_addr_t start, ddekit_addr_t count) {
return 0;
}
/****************************************************************************/
/* ddekit_request_mem */
/****************************************************************************/
PUBLIC int ddekit_request_mem
int ddekit_request_mem
(ddekit_addr_t start, ddekit_addr_t size, ddekit_addr_t *vaddr) {
*vaddr = (ddekit_addr_t) vm_map_phys(SELF, (void *)start, size);
@@ -64,7 +64,7 @@ PUBLIC int ddekit_request_mem
/****************************************************************************/
/* ddekit_release_mem */
/****************************************************************************/
PUBLIC int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
{
return vm_unmap_phys(SELF,(void *) start, size );
}
@@ -72,7 +72,7 @@ PUBLIC int ddekit_release_mem(ddekit_addr_t start, ddekit_addr_t size)
/****************************************************************************/
/* ddekit_inb */
/****************************************************************************/
PUBLIC unsigned char ddekit_inb(ddekit_addr_t port) {
unsigned char ddekit_inb(ddekit_addr_t port) {
u32_t ret;
if (sys_inb(port, &ret)) {
ddekit_panic("sys_inb failed.");
@@ -84,7 +84,7 @@ PUBLIC unsigned char ddekit_inb(ddekit_addr_t port) {
/****************************************************************************/
/* ddekit_inw */
/****************************************************************************/
PUBLIC unsigned short ddekit_inw(ddekit_addr_t port) {
unsigned short ddekit_inw(ddekit_addr_t port) {
u32_t ret;
if (sys_inw(port, &ret)) {
ddekit_panic("sys_inw failed.");
@@ -96,7 +96,7 @@ PUBLIC unsigned short ddekit_inw(ddekit_addr_t port) {
/****************************************************************************/
/* ddekit_inl */
/****************************************************************************/
PUBLIC unsigned long ddekit_inl(ddekit_addr_t port){
unsigned long ddekit_inl(ddekit_addr_t port){
u32_t ret;
if (sys_inl(port, &ret)) {
ddekit_panic("sys_outl failed.");
@@ -108,7 +108,7 @@ PUBLIC unsigned long ddekit_inl(ddekit_addr_t port){
/****************************************************************************/
/* ddekit_outb */
/****************************************************************************/
PUBLIC void ddekit_outb(ddekit_addr_t port, unsigned char val) {
void ddekit_outb(ddekit_addr_t port, unsigned char val) {
if (sys_outb(port,val)) {
ddekit_panic("sys_outb failed.");
}
@@ -118,7 +118,7 @@ PUBLIC void ddekit_outb(ddekit_addr_t port, unsigned char val) {
/****************************************************************************/
/* ddekit_outw */
/****************************************************************************/
PUBLIC void ddekit_outw(ddekit_addr_t port, unsigned short val) {
void ddekit_outw(ddekit_addr_t port, unsigned short val) {
if (sys_outw(port,val)) {
ddekit_panic("sys_outw failed.");
}
@@ -128,7 +128,7 @@ PUBLIC void ddekit_outw(ddekit_addr_t port, unsigned short val) {
/****************************************************************************/
/* ddekit_outl */
/****************************************************************************/
PUBLIC void ddekit_outl(ddekit_addr_t port, unsigned long val) {
void ddekit_outl(ddekit_addr_t port, unsigned long val) {
if (sys_outl(port,val)) {
ddekit_panic("sys_outl failed.");
}

12
lib/libddekit/src/semaphore.c
View File

@@ -26,7 +26,7 @@ struct ddekit_sem {
/*****************************************************************************
* ddekit_sem_init *
*************************+**************************************************/
PUBLIC ddekit_sem_t *ddekit_sem_init(int value)
ddekit_sem_t *ddekit_sem_init(int value)
{
ddekit_sem_t *sem;
@@ -42,7 +42,7 @@ PUBLIC ddekit_sem_t *ddekit_sem_init(int value)
/*****************************************************************************
* ddekit_sem_deinit *
****************************************************************************/
PUBLIC void ddekit_sem_deinit(ddekit_sem_t *sem)
void ddekit_sem_deinit(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
ddekit_simple_free(sem);
@@ -51,7 +51,7 @@ PUBLIC void ddekit_sem_deinit(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_down *
****************************************************************************/
PUBLIC void ddekit_sem_down(ddekit_sem_t *sem)
void ddekit_sem_down(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
if(sem->count == 0) {
@@ -73,7 +73,7 @@ PUBLIC void ddekit_sem_down(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_down_try *
****************************************************************************/
PUBLIC int ddekit_sem_down_try(ddekit_sem_t *sem)
int ddekit_sem_down_try(ddekit_sem_t *sem)
{
if(sem->count == 0) {
return -1;
@@ -85,7 +85,7 @@ PUBLIC int ddekit_sem_down_try(ddekit_sem_t *sem)
/*****************************************************************************
* ddekit_sem_up *
****************************************************************************/
PUBLIC void ddekit_sem_up(ddekit_sem_t *sem)
void ddekit_sem_up(ddekit_sem_t *sem)
{
SEM_DEBUG(p);
if (sem->wait_queue == NULL) {
@@ -103,7 +103,7 @@ PUBLIC void ddekit_sem_up(ddekit_sem_t *sem)
/****************************************************************************
* ddekit_sem_down_timed *
***************************************************************************/
PUBLIC int ddekit_sem_down_timed(ddekit_sem_t *sem, int timo )
int ddekit_sem_down_timed(ddekit_sem_t *sem, int timo )
{
ddekit_panic("not implemented!");
return 0;

60
lib/libddekit/src/thread.c
View File

@@ -17,22 +17,22 @@
/* Incremented to generate unique thread IDs */
PRIVATE unsigned id;
static unsigned id;
PRIVATE ddekit_thread_t *ready_queue[DDEKIT_THREAD_PRIOS];
static ddekit_thread_t *ready_queue[DDEKIT_THREAD_PRIOS];
PRIVATE ddekit_thread_t *sleep_queue;
static ddekit_thread_t *sleep_queue;
/* Handle to the running thread, set in _dde_kit_thread_schedule() */
PRIVATE ddekit_thread_t *current = NULL;
static ddekit_thread_t *current = NULL;
FORWARD void _ddekit_thread_start(ddekit_thread_t *th);
FORWARD void _ddekit_thread_sleep(unsigned long until);
static void _ddekit_thread_start(ddekit_thread_t *th);
static void _ddekit_thread_sleep(unsigned long until);
/*****************************************************************************
* _ddekit_thread_start *
****************************************************************************/
PRIVATE void _ddekit_thread_start(ddekit_thread_t *th)
static void _ddekit_thread_start(ddekit_thread_t *th)
{
/* entry point of newly created threads */
th->fun(th->arg);
@@ -42,7 +42,7 @@ PRIVATE void _ddekit_thread_start(ddekit_thread_t *th)
/*****************************************************************************
* _ddekit_thread_sleep *
****************************************************************************/
PRIVATE void _ddekit_thread_sleep(unsigned long until)
static void _ddekit_thread_sleep(unsigned long until)
{
current->next = sleep_queue;
sleep_queue = current;
@@ -58,7 +58,7 @@ PRIVATE void _ddekit_thread_sleep(unsigned long until)
/*****************************************************************************
* ddekit_yield *
****************************************************************************/
PUBLIC void ddekit_yield()
void ddekit_yield()
{
ddekit_thread_schedule();
}
@@ -66,7 +66,7 @@ PUBLIC void ddekit_yield()
/*****************************************************************************
* ddekit_thread_schedule *
****************************************************************************/
PUBLIC void ddekit_thread_schedule()
void ddekit_thread_schedule()
{
_ddekit_thread_enqueue(current);
_ddekit_thread_schedule();
@@ -75,7 +75,7 @@ PUBLIC void ddekit_thread_schedule()
/*****************************************************************************
* ddekit_thread_create *
****************************************************************************/
PUBLIC ddekit_thread_t *
ddekit_thread_t *
ddekit_thread_create(void (*fun)(void *), void *arg, const char *name)
{
ddekit_thread_t *th =
@@ -130,7 +130,7 @@ ddekit_thread_create(void (*fun)(void *), void *arg, const char *name)
/*****************************************************************************
* ddekit_thread_get_data *
****************************************************************************/
PUBLIC void *ddekit_thread_get_data(ddekit_thread_t *thread)
void *ddekit_thread_get_data(ddekit_thread_t *thread)
{
return thread->data;
}
@@ -138,7 +138,7 @@ PUBLIC void *ddekit_thread_get_data(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_my_data *
****************************************************************************/
PUBLIC void *ddekit_thread_get_my_data(void)
void *ddekit_thread_get_my_data(void)
{
return current->data;
}
@@ -146,7 +146,7 @@ PUBLIC void *ddekit_thread_get_my_data(void)
/*****************************************************************************
* ddekit_thread_myself *
****************************************************************************/
PUBLIC
ddekit_thread_t *ddekit_thread_myself(void)
{
return current;
@@ -155,7 +155,7 @@ ddekit_thread_t *ddekit_thread_myself(void)
/*****************************************************************************
* ddekit_thread_setup_myself *
****************************************************************************/
PUBLIC
ddekit_thread_t *ddekit_thread_setup_myself(const char *name) {
ddekit_thread_t *th =
(ddekit_thread_t *) ddekit_simple_malloc(sizeof(ddekit_thread_t));
@@ -176,7 +176,7 @@ ddekit_thread_t *ddekit_thread_setup_myself(const char *name) {
/*****************************************************************************
* ddekit_thread_set_data *
****************************************************************************/
PUBLIC void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
{
thread->data=data;
}
@@ -184,7 +184,7 @@ PUBLIC void ddekit_thread_set_data(ddekit_thread_t *thread, void *data)
/*****************************************************************************
* ddekit_thread_set_my_data *
****************************************************************************/
PUBLIC void ddekit_thread_set_my_data(void *data)
void ddekit_thread_set_my_data(void *data)
{
current->data = data;
}
@@ -217,7 +217,7 @@ void ddekit_thread_usleep(unsigned long usecs)
/*****************************************************************************
* ddekit_thread_nsleep *
****************************************************************************/
PUBLIC void ddekit_thread_nsleep(unsigned long nsecs)
void ddekit_thread_nsleep(unsigned long nsecs)
{
/*
* Cannot use usleep here, because it's implemented in vfs.
@@ -242,7 +242,7 @@ PUBLIC void ddekit_thread_nsleep(unsigned long nsecs)
/*****************************************************************************
* ddekit_thread_msleep *
****************************************************************************/
PUBLIC void ddekit_thread_msleep(unsigned long msecs)
void ddekit_thread_msleep(unsigned long msecs)
{
unsigned long to;
@@ -270,7 +270,7 @@ PUBLIC void ddekit_thread_msleep(unsigned long msecs)
/*****************************************************************************
* ddekit_thread_sleep *
****************************************************************************/
PUBLIC void ddekit_thread_sleep(ddekit_lock_t *lock)
void ddekit_thread_sleep(ddekit_lock_t *lock)
{
WARN_UNIMPL;
}
@@ -278,7 +278,7 @@ PUBLIC void ddekit_thread_sleep(ddekit_lock_t *lock)
/*****************************************************************************
* ddekit_thread_exit *
****************************************************************************/
PUBLIC void ddekit_thread_exit()
void ddekit_thread_exit()
{
ddekit_sem_down(current->sleep_sem);
ddekit_panic("thread running after exit!\n");
@@ -289,7 +289,7 @@ PUBLIC void ddekit_thread_exit()
/*****************************************************************************
* ddekit_thread_terminate *
****************************************************************************/
PUBLIC void ddekit_thread_terminate(ddekit_thread_t *thread)
void ddekit_thread_terminate(ddekit_thread_t *thread)
{
/* todo */
}
@@ -297,7 +297,7 @@ PUBLIC void ddekit_thread_terminate(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_name *
****************************************************************************/
PUBLIC const char *ddekit_thread_get_name(ddekit_thread_t *thread)
const char *ddekit_thread_get_name(ddekit_thread_t *thread)
{
return thread->name;
}
@@ -305,7 +305,7 @@ PUBLIC const char *ddekit_thread_get_name(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_thread_get_id *
****************************************************************************/
PUBLIC int ddekit_thread_get_id(ddekit_thread_t *thread)
int ddekit_thread_get_id(ddekit_thread_t *thread)
{
return thread->id;
}
@@ -313,7 +313,7 @@ PUBLIC int ddekit_thread_get_id(ddekit_thread_t *thread)
/*****************************************************************************
* ddekit_init_threads *
****************************************************************************/
PUBLIC void ddekit_init_threads(void)
void ddekit_init_threads(void)
{
int i;
@@ -333,7 +333,7 @@ PUBLIC void ddekit_init_threads(void)
/*****************************************************************************
* _ddekit_thread_schedule *
****************************************************************************/
PUBLIC void _ddekit_thread_schedule()
void _ddekit_thread_schedule()
{
DDEBUG_MSG_VERBOSE("called schedule id: %d name %s, prio: %d",
@@ -381,7 +381,7 @@ PUBLIC void _ddekit_thread_schedule()
/*****************************************************************************
* _ddekit_thread_enqueue *
****************************************************************************/
PUBLIC void _ddekit_thread_enqueue(ddekit_thread_t *th)
void _ddekit_thread_enqueue(ddekit_thread_t *th)
{
DDEBUG_MSG_VERBOSE("enqueueing thread: id: %d name %s, prio: %d",
@@ -407,7 +407,7 @@ PUBLIC void _ddekit_thread_enqueue(ddekit_thread_t *th)
/*****************************************************************************
* _ddekit_thread_set_myprio *
****************************************************************************/
PUBLIC void _ddekit_thread_set_myprio(int prio)
void _ddekit_thread_set_myprio(int prio)
{
DDEBUG_MSG_VERBOSE("changing thread prio, id: %d name %s, old prio: %d, "
"new prio: %d", current->id, current->name, current->prio);
@@ -419,7 +419,7 @@ PUBLIC void _ddekit_thread_set_myprio(int prio)
/*****************************************************************************
* _ddekit_thread_wakeup_sleeping *
****************************************************************************/
PUBLIC void _ddekit_thread_wakeup_sleeping()
void _ddekit_thread_wakeup_sleeping()
{
ddekit_thread_t *th = sleep_queue;
@@ -464,7 +464,7 @@ PUBLIC void _ddekit_thread_wakeup_sleeping()
/*****************************************************************************
* _ddekit_print_backtrace *
****************************************************************************/
PUBLIC void _ddekit_print_backtrace(ddekit_thread_t *th)
void _ddekit_print_backtrace(ddekit_thread_t *th)
{
unsigned long bp, pc, hbp;

52
lib/libddekit/src/timer.c
View File

@@ -28,26 +28,26 @@ struct ddekit_timer_s {
};
PRIVATE ddekit_sem_t *pending_timer_ints;
static ddekit_sem_t *pending_timer_ints;
/* are we currently expecting a alarm notify? */
int _ddekit_timer_pending = 0;
PUBLIC unsigned long long jiffies;
PUBLIC unsigned long HZ;
unsigned long long jiffies;
unsigned long HZ;
PRIVATE struct ddekit_timer_s list = {0,0,-1,1,0};
PRIVATE int _id = 0 ;
PRIVATE ddekit_thread_t *th;
PRIVATE ddekit_lock_t lock;
static struct ddekit_timer_s list = {0,0,-1,1,0};
static int _id = 0 ;
static ddekit_thread_t *th;
static ddekit_lock_t lock;
FORWARD void lock_timer(void);
FORWARD void unlock_timer(void);
FORWARD clock_t get_current_clock(void);
FORWARD void remove_timer(int id);
FORWARD int insert_timer(struct ddekit_timer_s *t);
FORWARD struct ddekit_timer_s * get_next( myclock_t exp );
FORWARD void ddekit_timer_thread(void *data);
static void lock_timer(void);
static void unlock_timer(void);
static clock_t get_current_clock(void);
static void remove_timer(int id);
static int insert_timer(struct ddekit_timer_s *t);
static struct ddekit_timer_s * get_next( myclock_t exp );
static void ddekit_timer_thread(void *data);
/****************************************************************************
* Private funtions *
@@ -56,7 +56,7 @@ FORWARD void ddekit_timer_thread(void *data);
/*****************************************************************************
* lock_timer *
****************************************************************************/
PRIVATE void lock_timer()
static void lock_timer()
{
ddekit_lock_lock(&lock);
}
@@ -83,7 +83,7 @@ static myclock_t get_current_clock()
/*****************************************************************************
* remove_timer *
****************************************************************************/
PRIVATE void remove_timer(int id)
static void remove_timer(int id)
{
/* removes a timer from the timer list */
struct ddekit_timer_s *l,*m;
@@ -112,7 +112,7 @@ PRIVATE void remove_timer(int id)
/*****************************************************************************
* insert_timer *
****************************************************************************/
PRIVATE int insert_timer(struct ddekit_timer_s *t)
static int insert_timer(struct ddekit_timer_s *t)
{
/* inserts a timer to the timer list */
int ret;
@@ -146,7 +146,7 @@ PRIVATE int insert_timer(struct ddekit_timer_s *t)
/*****************************************************************************
* get_next *
****************************************************************************/
PRIVATE struct ddekit_timer_s * get_next( myclock_t exp )
static struct ddekit_timer_s * get_next( myclock_t exp )
{
/*
* this one get the next timer, which's timeout expired,
@@ -169,7 +169,7 @@ PRIVATE struct ddekit_timer_s * get_next( myclock_t exp )
/*****************************************************************************
* ddekit_timer_thread *
****************************************************************************/
PRIVATE void ddekit_timer_thread(void * data)
static void ddekit_timer_thread(void * data)
{
struct ddekit_timer_s * l;
@@ -199,7 +199,7 @@ PRIVATE void ddekit_timer_thread(void * data)
/*****************************************************************************
* ddekit_add_timer *
****************************************************************************/
PUBLIC int ddekit_add_timer
int ddekit_add_timer
(void (*fn)(void *), void *args, unsigned long timeout)
{
struct ddekit_timer_s *t;
@@ -217,7 +217,7 @@ PUBLIC int ddekit_add_timer
/*****************************************************************************
* ddekit_del_timer *
****************************************************************************/
PUBLIC int ddekit_del_timer(int timer)
int ddekit_del_timer(int timer)
{
remove_timer(timer);
return 0;
@@ -226,7 +226,7 @@ PUBLIC int ddekit_del_timer(int timer)
/*****************************************************************************
* ddekit_timer_pending *
****************************************************************************/
PUBLIC int ddekit_timer_pending(int timer)
int ddekit_timer_pending(int timer)
{
int ret=0;
struct ddekit_timer_s *t;
@@ -244,7 +244,7 @@ PUBLIC int ddekit_timer_pending(int timer)
/*****************************************************************************
* ddekit_init_timers *
****************************************************************************/
PUBLIC void ddekit_init_timers(void)
void ddekit_init_timers(void)
{
static int first_time=0;
@@ -263,7 +263,7 @@ PUBLIC void ddekit_init_timers(void)
/*****************************************************************************
* ddekit_get_timer_thread *
****************************************************************************/
PUBLIC ddekit_thread_t *ddekit_get_timer_thread(void)
ddekit_thread_t *ddekit_get_timer_thread(void)
{
return th;
}
@@ -275,7 +275,7 @@ PUBLIC ddekit_thread_t *ddekit_get_timer_thread(void)
/*****************************************************************************
* _ddekit_timer_interrupt *
****************************************************************************/
PUBLIC void _ddekit_timer_interrupt(void)
void _ddekit_timer_interrupt(void)
{
jiffies = get_current_clock();
DDEBUG_MSG_VERBOSE("now: %d", jiffies);
@@ -285,7 +285,7 @@ PUBLIC void _ddekit_timer_interrupt(void)
/*****************************************************************************
* _ddekit_timer_update *
****************************************************************************/
PUBLIC void _ddekit_timer_update()
void _ddekit_timer_update()
{
lock_timer();

24
lib/libddekit/src/usb_client.c
View File

@@ -17,12 +17,12 @@ struct ddekit_usb_dev dev_list_head = {
.prev = &dev_list_head,
};
PRIVATE struct ddekit_usb_driver *d_usb_driver;
static struct ddekit_usb_driver *d_usb_driver;
FORWARD void _ddekit_usb_completion(struct usb_urb *mx);
FORWARD void _ddekit_usb_connect( unsigned int dev_id, unsigned int
static void _ddekit_usb_completion(struct usb_urb *mx);
static void _ddekit_usb_connect( unsigned int dev_id, unsigned int
interfaces);
FORWARD void _ddekit_usb_disconnect(unsigned dev_id);
static void _ddekit_usb_disconnect(unsigned dev_id);
struct usb_driver mx_usb_driver = {
.urb_completion = _ddekit_usb_completion,
@@ -33,7 +33,7 @@ struct usb_driver mx_usb_driver = {
/*****************************************************************************
* _ddekit_usb_completion *
****************************************************************************/
PRIVATE void _ddekit_usb_completion(struct usb_urb *mx_urb)
static void _ddekit_usb_completion(struct usb_urb *mx_urb)
{
struct ddekit_usb_urb *d_urb = (struct ddekit_usb_urb *) mx_urb->priv;
@@ -72,7 +72,7 @@ PRIVATE void _ddekit_usb_completion(struct usb_urb *mx_urb)
/*****************************************************************************
* _ddekit_usb_connect *
****************************************************************************/
PRIVATE void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
static void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
{
struct ddekit_usb_dev *d_dev = (struct ddekit_usb_dev *)
ddekit_simple_malloc(sizeof(struct ddekit_usb_dev));
@@ -94,7 +94,7 @@ PRIVATE void _ddekit_usb_connect(unsigned int dev_id, unsigned int interfaces)
/*****************************************************************************
* _ddekit_usb_disconnect *
****************************************************************************/
PUBLIC void _ddekit_usb_disconnect(unsigned dev_id)
void _ddekit_usb_disconnect(unsigned dev_id)
{
/* find dev */
struct ddekit_usb_dev *it;
@@ -118,7 +118,7 @@ PUBLIC void _ddekit_usb_disconnect(unsigned dev_id)
/*****************************************************************************
* ddekit_usb_dev_set_data *
****************************************************************************/
PUBLIC int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
{
dev->data = data;
return 0;
@@ -127,7 +127,7 @@ PUBLIC int ddekit_usb_dev_set_data(struct ddekit_usb_dev *dev, void *data)
/*****************************************************************************
* ddekit_usb_dev_get_data *
****************************************************************************/
PUBLIC void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
{
return dev->data;
}
@@ -135,7 +135,7 @@ PUBLIC void *ddekit_usb_dev_get_data(struct ddekit_usb_dev *dev)
/*****************************************************************************
* ddekit_usb_submit_urb *
****************************************************************************/
PUBLIC int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
{
int res;
unsigned urb_size = USB_URBSIZE(d_urb->size, d_urb->number_of_packets);
@@ -180,7 +180,7 @@ PUBLIC int ddekit_usb_submit_urb(struct ddekit_usb_urb *d_urb)
/*****************************************************************************
* ddekit_usb_cancle_urb *
****************************************************************************/
PUBLIC int ddekit_usb_cancle_urb(struct ddekit_usb_urb *d_urb)
int ddekit_usb_cancle_urb(struct ddekit_usb_urb *d_urb)
{
int res;
@@ -208,7 +208,7 @@ static void _ddekit_usb_thread()
/*****************************************************************************
* ddekit_usb_init *
****************************************************************************/
PUBLIC int ddekit_usb_init
int ddekit_usb_init
(struct ddekit_usb_driver *drv,
ddekit_usb_malloc_fn *unused,
ddekit_usb_free_fn *_unused)

88
lib/libddekit/src/usb_server.c
View File

@@ -58,29 +58,29 @@ struct minix_usb_device {
unsigned int interfaces;
};
FORWARD struct minix_usb_driver *find_driver(endpoint_t ep);
FORWARD struct minix_usb_driver *find_unused_driver(void);
FORWARD int add_to_pending_urbs(struct minix_usb_driver *drv, struct
static struct minix_usb_driver *find_driver(endpoint_t ep);
static struct minix_usb_driver *find_unused_driver(void);
static int add_to_pending_urbs(struct minix_usb_driver *drv, struct
ddekit_usb_urb *urb);
FORWARD int remove_from_pending_urbs(struct minix_usb_driver *drv,
static int remove_from_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb);
FORWARD struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver
static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver
*drv, unsigned urb_id);
FORWARD void register_driver(message *msg);
FORWARD struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb
static void register_driver(message *msg);
static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb
*mx_urb);
FORWARD void submit_urb(message *msg);
FORWARD void cancle_urb(message *msg);
FORWARD void completion_callback(void *priv);
static void submit_urb(message *msg);
static void cancle_urb(message *msg);
static void completion_callback(void *priv);
FORWARD void prepare_devman_usbdev(struct ddekit_usb_dev * dev, int
static void prepare_devman_usbdev(struct ddekit_usb_dev * dev, int
dev_id, unsigned int interfaces, struct devman_usb_dev *dudev);
FORWARD void device_disconnect_callback(struct ddekit_usb_dev * dev);
FORWARD int add_acl(int dev_id, unsigned interfaces, endpoint_t ep);
FORWARD int del_acl(int dev_id, unsigned interaces, endpoint_t ep);
FORWARD int handle_msg(message *msg);
FORWARD void _ddekit_usb_thread();
FORWARD void device_connect_callback(struct ddekit_usb_dev * dev,
static void device_disconnect_callback(struct ddekit_usb_dev * dev);
static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep);
static int del_acl(int dev_id, unsigned interaces, endpoint_t ep);
static int handle_msg(message *msg);
static void _ddekit_usb_thread();
static void device_connect_callback(struct ddekit_usb_dev * dev,
unsigned int interfaces);
char *_ddekit_usb_get_manufacturer(struct ddekit_usb_dev *ddev);
@@ -92,12 +92,12 @@ usb_interface_descriptor_t *_ddekit_usb_get_interface_desc(struct
ddekit_usb_dev *ddev, int inum);
PRIVATE ddekit_usb_malloc_fn my_malloc;
PRIVATE ddekit_usb_free_fn my_free;
PRIVATE struct minix_usb_driver gbl_drivers[MAX_DRIVERS];
PRIVATE struct minix_usb_device _devices[MAX_DEVS];
static ddekit_usb_malloc_fn my_malloc;
static ddekit_usb_free_fn my_free;
static struct minix_usb_driver gbl_drivers[MAX_DRIVERS];
static struct minix_usb_device _devices[MAX_DEVS];
PRIVATE struct ddekit_usb_driver my_driver = {
static struct ddekit_usb_driver my_driver = {
.completion = completion_callback,
.connect = device_connect_callback,
.disconnect = device_disconnect_callback,
@@ -107,7 +107,7 @@ PRIVATE struct ddekit_usb_driver my_driver = {
/*****************************************************************************
* find_driver *
****************************************************************************/
PRIVATE struct minix_usb_driver *find_driver(endpoint_t ep)
static struct minix_usb_driver *find_driver(endpoint_t ep)
{
int i;
for (i = 0; i < MAX_DRIVERS; i++ ){
@@ -121,7 +121,7 @@ PRIVATE struct minix_usb_driver *find_driver(endpoint_t ep)
/*****************************************************************************
* find_unused_driver *
****************************************************************************/
PRIVATE struct minix_usb_driver *find_unused_driver()
static struct minix_usb_driver *find_unused_driver()
{
int i;
for (i = 0; i < MAX_DRIVERS; i++ ){
@@ -135,7 +135,7 @@ PRIVATE struct minix_usb_driver *find_unused_driver()
/*****************************************************************************
* add_to_pending_urbs *
****************************************************************************/
PRIVATE int add_to_pending_urbs(struct minix_usb_driver *drv,
static int add_to_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb)
{
int i;
@@ -153,7 +153,7 @@ PRIVATE int add_to_pending_urbs(struct minix_usb_driver *drv,
/*****************************************************************************
* remove_from_pending_urbs *
****************************************************************************/
PRIVATE int remove_from_pending_urbs(struct minix_usb_driver *drv,
static int remove_from_pending_urbs(struct minix_usb_driver *drv,
struct ddekit_usb_urb *urb)
{
int i;
@@ -171,7 +171,7 @@ PRIVATE int remove_from_pending_urbs(struct minix_usb_driver *drv,
/*****************************************************************************
* find_pending_urb *
****************************************************************************/
PRIVATE struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
static struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
unsigned urb_id)
{
int i;
@@ -188,7 +188,7 @@ PRIVATE struct ddekit_usb_urb * find_pending_urb(struct minix_usb_driver *drv,
/*****************************************************************************
* register_driver *
****************************************************************************/
PRIVATE void register_driver(message *msg)
static void register_driver(message *msg)
{
endpoint_t ep = msg->m_source;
struct minix_usb_driver *drv;
@@ -222,7 +222,7 @@ PRIVATE void register_driver(message *msg)
/*****************************************************************************
* deregister_driver *
****************************************************************************/
PRIVATE void deregister_driver(message *msg)
static void deregister_driver(message *msg)
{
endpoint_t ep = msg->m_source;
@@ -245,7 +245,7 @@ PRIVATE void deregister_driver(message *msg)
/*****************************************************************************
* ddekit_usb_urb_from_mx_urb *
****************************************************************************/
PRIVATE struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb)
static struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb)
{
/*
* A helper function that generates (allocates and initializes)
@@ -284,7 +284,7 @@ PRIVATE struct ddekit_usb_urb *ddekit_usb_urb_from_mx_urb(struct usb_urb *mx_urb
/*****************************************************************************
* submit_urb *
****************************************************************************/
PRIVATE void submit_urb(message *msg)
static void submit_urb(message *msg)
{
/*
* submit_urb
@@ -410,7 +410,7 @@ out:
/*****************************************************************************
* cancle_urb *
****************************************************************************/
PRIVATE void cancle_urb(message *msg)
static void cancle_urb(message *msg)
{
endpoint_t ep = msg->m_source;
@@ -444,7 +444,7 @@ PRIVATE void cancle_urb(message *msg)
/*****************************************************************************
* completion_callback *
****************************************************************************/
PRIVATE void completion_callback(void *priv)
static void completion_callback(void *priv)
{
/*
* completion_callback
@@ -497,7 +497,7 @@ PRIVATE void completion_callback(void *priv)
/*****************************************************************************
* prepare_devman_usbdev *
****************************************************************************/
PRIVATE void prepare_devman_usbdev
static void prepare_devman_usbdev
(struct ddekit_usb_dev * dev, int dev_id, unsigned int interfaces,
struct devman_usb_dev *dudev)
{
@@ -531,7 +531,7 @@ PRIVATE void prepare_devman_usbdev
/*****************************************************************************
* device_connect_callback *
****************************************************************************/
PRIVATE void
static void
device_connect_callback
(struct ddekit_usb_dev * dev, unsigned int interfaces) {
@@ -574,7 +574,7 @@ device_connect_callback
/*****************************************************************************
* device_disconnect_callback *
****************************************************************************/
PRIVATE void device_disconnect_callback(struct ddekit_usb_dev * dev)
static void device_disconnect_callback(struct ddekit_usb_dev * dev)
{
int i;
@@ -616,7 +616,7 @@ PRIVATE void device_disconnect_callback(struct ddekit_usb_dev * dev)
/*****************************************************************************
* add_acl *
****************************************************************************/
PRIVATE int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
static int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
{
/*
* This functions binds a specific USB interface to a client.
@@ -657,7 +657,7 @@ PRIVATE int add_acl(int dev_id, unsigned interfaces, endpoint_t ep)
/*****************************************************************************
* del_acl *
****************************************************************************/
PRIVATE int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
static int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
{
struct minix_usb_driver *drv;
int dev, withdraw = 0;
@@ -692,7 +692,7 @@ PRIVATE int del_acl(int dev_id, unsigned interfaces, endpoint_t ep)
/*****************************************************************************
* handle_msg *
****************************************************************************/
PRIVATE int handle_msg(message *msg)
static int handle_msg(message *msg)
{
/*
* handle_msg
@@ -721,7 +721,7 @@ PRIVATE int handle_msg(message *msg)
/*****************************************************************************
* devman_tread *
****************************************************************************/
PRIVATE void devman_thread(void *unused)
static void devman_thread(void *unused)
{
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(DEVMAN_BASE,
DEVMAN_BASE + 0xff);
@@ -736,7 +736,7 @@ PRIVATE void devman_thread(void *unused)
/*****************************************************************************
* _ddekit_usb_thread *
****************************************************************************/
PRIVATE void _ddekit_usb_thread(void * unused)
static void _ddekit_usb_thread(void * unused)
{
struct ddekit_minix_msg_q *mq = ddekit_minix_create_msg_q(USB_BASE,
USB_BASE + 0xff);
@@ -758,7 +758,7 @@ PRIVATE void _ddekit_usb_thread(void * unused)
/*****************************************************************************
* bind_cb *
****************************************************************************/
PRIVATE int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
static int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
{
if(data) {
return add_acl(data->dev_id, data->interface, ep);
@@ -771,7 +771,7 @@ PRIVATE int bind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
/*****************************************************************************
* unbind_cb *
****************************************************************************/
PRIVATE int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
static int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
{
if(data) {
return del_acl(data->dev_id, data->interface, ep);
@@ -784,7 +784,7 @@ PRIVATE int unbind_cb (struct devman_usb_bind_cb_data *data, endpoint_t ep)
/*****************************************************************************
* ddekit_usb_server_init *
****************************************************************************/
PUBLIC void ddekit_usb_server_init()
void ddekit_usb_server_init()
{
int i;
/*