sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

added DDEkit headers

Browse source
This commit is contained in:
Dirk Vogt 2011-02-25 12:31:20 +00:00
parent 8c8e44d0ae
commit 3c9012886f
23 changed files with 1241 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
include/Makefile
View file

@ -32,6 +32,14 @@ INCS+= minix/a.out.h minix/cdrom.h minix/cpufeature.h \
INCS+= net/hton.h net/if.h net/ioctl.h net/netlib.h
INCS+= netinet/if_ether.h netinet/in.h netinet/tcp.h
INCS+= ddekit/assert.h ddekit/initcall.h ddekit/memory.h ddekit/pgtab.h \
ddekit/thread.h ddekit/attribs.h ddekit/inline.h ddekit/printf.h \
ddekit/timer.h ddekit/condvar.h ddekit/interrupt.h ddekit/panic.h \
ddekit/resources.h ddekit/types.h ddekit/debug.h ddekit/lock.h \
ddekit/pci.h ddekit/semaphore.h ddekit/usb.h ddekit/minix/pci.h \
ddekit/minix/msg_queue.h ddekit/ddekit.h
.include <bsd.own.mk>
INCSDIR= /usr/include

23
include/ddekit/assert.h Normal file
View file

@ -0,0 +1,23 @@
#ifndef _ddekit_assert_h
#define _ddekit_assert_h
#include <ddekit/ddekit.h>
#include <ddekit/printf.h>
#include <ddekit/panic.h>
/** \file ddekit/assert.h */
/** Assert that an expression is true and panic if not.
* \ingroup DDEKit_util
*/
#define ddekit_assert(expr) do \
{ \
if (!(expr)) { \
ddekit_print("\033[31;1mDDE: Assertion failed: "#expr"\033[0m\n"); \
ddekit_printf(" File: %s:%d\n",__FILE__,__LINE__); \
ddekit_printf(" Function: %s()\n", __FUNCTION__); \
ddekit_panic("Assertion failed."); \
}} while (0);
#define Assert ddekit_assert
#endif

16
include/ddekit/attribs.h Normal file
View file

@ -0,0 +1,16 @@
#ifndef _DDEKIT_ATTRIBS_H
#define _DDEKIT_ATTRIBS_H
#ifdef __ACK__
#else
#define DDEKIT_USED __attribute__((used))
#define DDEKIT_CONSTRUCTOR __attribute__((constructor))
#define DDEKIT_PUBLIC PUBLIC
#define DDEKIT_PRIVATE static
#endif
#endif

32
include/ddekit/condvar.h Normal file
View file

@ -0,0 +1,32 @@
#ifndef _ddekit_condvar_h
#define _ddekit_condvar_h
/** \file ddekit/condvar.h */
#include <ddekit/ddekit.h>
#include <ddekit/lock.h>
struct ddekit_condvar;
typedef struct ddekit_condvar ddekit_condvar_t;
/* Initialize conditional variable. */
_PROTOTYPE( ddekit_condvar_t * ddekit_condvar_init, (void));
/* Uninitialize conditional variable. */
_PROTOTYPE( void ddekit_condvar_deinit, (ddekit_condvar_t *cvp));
/* Wait on a conditional variable. */
_PROTOTYPE( void ddekit_condvar_waiti, (ddekit_condvar_t *cvp,
ddekit_lock_t *mp));
/* Wait on a conditional variable at most until a timeout expires. (UNIMPL) */
_PROTOTYPE( int ddekit_condvar_wait_timed, (ddekit_condvar_t *cvp,
ddekit_lock_t *mp, int timo));
/* Send signal to the next one waiting for condvar. */
_PROTOTYPE( void ddekit_condvar_signal, (ddekit_condvar_t *cvp));
/* Send signal to all threads waiting for condvar. */
_PROTOTYPE( void ddekit_condvar_broadcast, (ddekit_condvar_t *cvp));
#endif

7
include/ddekit/ddekit.h Normal file
View file

@ -0,0 +1,7 @@
#ifndef _DDEKIT_DDEKIT_H
#define _DDEKIT_DDEKIT_H
#include <ansi.h>
_PROTOTYPE( void ddekit_init, (void) );
#endif

41
include/ddekit/debug.h Normal file
View file

@ -0,0 +1,41 @@
#ifndef DDEKIT_DEBUG_H
#define DDEKIT_DEBUG_H
#include <ddekit/ddekit.h>
#include <ddekit/printf.h>
#define DDEBUG_QUIET 0
#define DDEBUG_ERR 1
#define DDEBUG_WARN 2
#define DDEBUG_INFO 3
#define DDEBUG_VERBOSE 4
#define DDEBUG_MEM DDEBUG_INFO
#define DDEBUG_MSG_ERR(fmt, ...)
#define DDEBUG_MSG_WARN(fmt, ...)
#define DDEBUG_MSG_INFO(fmt, ...)
#define DDEBUG_MSG_VERBOSE(fmt, ...)
#if DDEBUG >= DDEBUG_ERR
#undef DDEBUG_MSG_ERR
#define DDEBUG_MSG_ERR(fmt, ...) ddekit_printf("%s : "fmt"\n", __func__, ##__VA_ARGS__ )
#endif
#if DDEBUG >= DDEBUG_WARN
#undef DDEBUG_MSG_WARN
#define DDEBUG_MSG_WARN(fmt, ...) ddekit_printf("%s: "fmt"\n", __func__, ##__VA_ARGS__ )
#endif
#if DDEBUG >= DDEBUG_INFO
#undef DDEBUG_MSG_INFO
#define DDEBUG_MSG_INFO(fmt, ...) ddekit_printf("%s: "fmt"\n", __func__, ##__VA_ARGS__ )
#endif
#if DDEBUG >= DDEBUG_VERBOSE
#undef DDEBUG_MSG_VERBOSE
#define DDEBUG_MSG_VERBOSE(fmt, ...) ddekit_printf("%s: "fmt"\n", __func__, ##__VA_ARGS__ )
#endif
#endif

30
include/ddekit/initcall.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef _DDEKIT_INITCALL_H
#define _DDEKIT_INITCALL_H
#include <ddekit/ddekit.h>
#include <ddekit/attribs.h>
typedef void (*ddekit_initcall_t)(void);
struct __ddekit_initcall_s {
ddekit_initcall_t func;
int prio;
struct __ddekit_initcall_s *next;
};
void __ddekit_add_initcall(struct __ddekit_initcall_s *dis);
/* Define a function to be a DDEKit initcall.
* This is the right place to place Linux' module_init functions & Co.
*/
#define DDEKIT_INITCALL(fn) DDEKIT_CTOR(fn, 1)
#define DDEKIT_CTOR(fn, prio) \
static void __attribute__((used)) __attribute__((constructor))\
__ddekit_initcall_##fn() { \
static struct __ddekit_initcall_s dis = {(ddekit_initcall_t)fn, prio, 0}; \
__ddekit_add_initcall(&dis); }
/* Runs all registered initcalls. */
_PROTOTYPE (void ddekit_do_initcalls, (void));
#endif

2
include/ddekit/inline.h Normal file
View file

@ -0,0 +1,2 @@
#define DDEKIT_INLINE __inline__ __attribute__((always_inline))

48
include/ddekit/interrupt.h Normal file
View file

@ -0,0 +1,48 @@
/*-
* Copyright (c) 2006 TU Dresden, All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef _DDEKIT_INTERUPT_H
#define _DDEKIT_INTERUPT_H
#include <ddekit/ddekit.h>
#include <ddekit/thread.h>
/** Attach to an interrupt */
_PROTOTYPE( ddekit_thread_t *ddekit_interrupt_attach,
( int irq, int shared, void(*thread_init)(void *),
void(*handler)(void *), void *priv) );
/* Detach from a previously attached interrupt. */
_PROTOTYPE( void ddekit_interrupt_detach, (int irq));
/* Block interrupt. */
_PROTOTYPE( void ddekit_interrupt_disable, (int irq));
/* Enable interrupt */
_PROTOTYPE( void ddekit_interrupt_enable, (int irq));
#endif

33
include/ddekit/lock.h Normal file
View file

@ -0,0 +1,33 @@
#ifndef _DDEKIT_LOCK_H
#define _DDEKIT_LOCK_H
#include <ddekit/ddekit.h>
struct ddekit_lock;
typedef struct ddekit_lock *ddekit_lock_t;
/* Initialize a DDEKit unlocked lock. */
#define ddekit_lock_init ddekit_lock_init_unlocked
/* Initialize a DDEKit unlocked lock. */
_PROTOTYPE( void ddekit_lock_init_unlocked, (ddekit_lock_t *mtx));
/* Initialize a DDEKit locked lock. */
_PROTOTYPE( void ddekit_lock_init_locked, (ddekit_lock_t *mtx));
/* Uninitialize a DDEKit lock. */
_PROTOTYPE( void ddekit_lock_deinit, (ddekit_lock_t *mtx));
/* Acquire a lock. */
_PROTOTYPE( void ddekit_lock_lock, (ddekit_lock_t *mtx));
/* Acquire a lock, non-blocking. */
_PROTOTYPE( int ddekit_lock_try_lock, (ddekit_lock_t *mtx));
/* Unlock function. */
_PROTOTYPE( void ddekit_lock_unlock, (ddekit_lock_t *mtx));
/* Get lock owner. */
_PROTOTYPE( int ddekit_lock_owner, (ddekit_lock_t *mtx));
#endif

146
include/ddekit/memory.h Normal file
View file

@ -0,0 +1,146 @@
/*-
* Copyright (c) 2006 Thomas Friebel <tf13@os.inf.tu-dresden.de>
* Copyright (c) 2006 Christian Helmuth <ch12@os.inf.tu-dresden.de>
* Copyright (c) 2010 Dirk Vogt <dvogt@few.vu.nl>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef _DDEKIT_MEMORY_H
#define _DDEKIT_MEMORY_H
#include <ddekit/ddekit.h>
/*******************
** Slab facility **
*******************/
struct ddekit_slab;
/* Store user pointer in slab cache */
_PROTOTYPE( void ddekit_slab_set_data, (struct ddekit_slab * slab,
void *data));
/* Read user pointer from slab cache */
_PROTOTYPE( void *ddekit_slab_get_data,(struct ddekit_slab * slab));
/* Allocate slab in slab cache */
_PROTOTYPE( void *ddekit_slab_alloc, (struct ddekit_slab * slab));
/* Allocate slab in slab cache */
_PROTOTYPE( void ddekit_slab_free, (struct ddekit_slab * slab, void *objp));
/*
* Setup page cache for all slabs
*
* pages: maximal number of memory pages
*
* If 'pages' is too low, memory pages may be given back to the memory server
* (dm_phys) and just to be allocated again later. This hits performance (but
* saves memory). Increase 'pages' to avoid this thrashing-like effect.
*
* If the maximal number of unused pages is exceeded, subsequent deallocation
* will be freed at the memory server. This page cache caches pages from all
* slabs.
*/
_PROTOTYPE( void ddekit_slab_setup_page_cache, (unsigned pages));
/*
* Destroy slab cache
*
* slab: pointer to slab cache structure
*/
_PROTOTYPE( void ddekit_slab_destroy, (struct ddekit_slab * slab));
/**
* Initialize slab cache
*
* \param size size of cache objects
* \param contiguous make this slab use physically contiguous memory
*
* \return pointer to new slab cache or 0 on error
*/
_PROTOTYPE( struct ddekit_slab * ddekit_slab_init,(unsigned size, int contiguous));
/**********************
** Memory allocator **
**********************/
/*
* Allocate large memory block
*
* \param size block size
* \return pointer to new memory block
*
* Allocations via this allocator may be slow (because memory servers are
* involved) and should be used only for large (i.e., > page size) blocks. If
* allocations/deallocations are relatively dynamic this may not be what you
* want.
*
* Allocated blocks have valid virt->phys mappings and are physically
* contiguous.
*/
_PROTOTYPE( void *ddekit_large_malloc, (int size));
/**
* Free large memory block
*
* \param p pointer to memory block
*/
_PROTOTYPE( void ddekit_large_free, (void *p));
/** FIXME
* contig_malloc() is the lowest-level allocator interface one could implement.
* we should consider to provide vmalloc() too. */
_PROTOTYPE( void *ddekit_contig_malloc,
(unsigned long size, unsigned long low,
unsigned long high, unsigned long alignment,
unsigned long boundary));
/*****************************
** Simple memory allocator **
*****************************/
/**
* Allocate memory block via simple allocator
*
* \param size block size
* \return pointer to new memory block
*
* The blocks allocated via this allocator CANNOT be used for DMA or other
* device operations, i.e., there exists no virt->phys mapping.
*/
_PROTOTYPE( void *ddekit_simple_malloc, (unsigned size));
/**
* Free memory block via simple allocator
*
* \param p pointer to memory block
*/
_PROTOTYPE( void ddekit_simple_free, (void *p));
#endif

22
include/ddekit/minix/msg_queue.h Normal file
View file

@ -0,0 +1,22 @@
#ifndef DDEKIT_SRC_MSG_QUEUE_H
#define DDEKIT_SRC_MSG_QUEUE_H
#include <ddekit/ddekit.h>
#include <ddekit/thread.h>
#include <minix/ipc.h>
struct ddekit_minix_msg_q;
_PROTOTYPE( void ddekit_minix_queue_msg, (message *m));
_PROTOTYPE( void ddekit_minix_rcv,
(struct ddekit_minix_msg_q * mq, message *m));
_PROTOTYPE( struct ddekit_minix_msg_q *ddekit_minix_create_msg_q,
(unsigned from, unsigned to));
_PROTOTYPE( void ddekit_minix_destroy_msg_q,
(struct ddekit_minix_msg_q *mq));
#endif /* DDEKIT_SRC_MSG_QUEUE_H */

4
include/ddekit/minix/pci.h Normal file
View file

@ -0,0 +1,4 @@
#ifndef DDEKIT_MINIX_PCI
#define DDEKIT_MINIX_PCI
void ddekit_pci_init_only_one(int skip);
#endif

18
include/ddekit/panic.h Normal file
View file

@ -0,0 +1,18 @@
#ifndef _DDEKIT_PANIC_H
#define _DDEKIT_PANIC_H
#include <ddekit/ddekit.h>
#include <stdarg.h>
/** \defgroup DDEKit_util */
/** Panic - print error message and enter the kernel debugger.
* \ingroup DDEKit_util
*/
_PROTOTYPE (void ddekit_panic, (char *fmt, ...));
/** Print a debug message.
* \ingroup DDEKit_util
*/
_PROTOTYPE (void ddekit_debug, (char *fmt, ...));
#endif

217
include/ddekit/pci.h Normal file
View file

@ -0,0 +1,217 @@
#ifndef _DDEKIT_PCI_H
#define _DDEKIT_PCI_H
#include <ddekit/ddekit.h>
#include <ddekit/types.h>
/** \defgroup DDEKit_pci */
/** Our version of PCI_ANY_ID */
#define DDEKIT_PCI_ANY_ID (~0)
/** Copy of L4IO_PCIDEV_RES */
#define DDEKIT_PCIDEV_RES 12
struct ddekit_pci_dev;
/** PCI resource descriptor. Copied from generic_io.
*
* XXX!
*/
typedef struct ddekit_pci_resource {
unsigned long start;
unsigned long end;
unsigned long flags;
} ddekit_pci_res_t;
_PROTOTYPE( void ddekit_pci_init, (void));
_PROTOTYPE( int ddekit_pci_get_device,(int nr, int *bus,
int *slot, int *func));
_PROTOTYPE( int ddekit_pci_read, (int bus, int slot, int func,
int pos, int len, ddekit_uint32_t *val));
_PROTOTYPE( int ddekit_pci_write, (int bus, int slot, int func,
int pos, int len, ddekit_uint32_t val));
/** Read byte from PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val read value
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readb, (int bus, int slot,
int func, int pos, ddekit_uint8_t *val));
/** Read word from PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val read value
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readw, (int bus, int slot,
int func, int pos, ddekit_uint16_t *val));
/** Read dword from PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val read value
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_readl, (int bus, int slot,
int func, int pos, ddekit_uint32_t *val));
/** Write byte to PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val value to write
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writeb, (int bus, int slot,
int func, int pos, ddekit_uint8_t val));
/** Write word to PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val value to write
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writew, (int bus, int slot,
int func, int pos, ddekit_uint16_t val));
/** Write word to PCI config space.
*
* \ingroup DDEKit_pci
*
* \param bus bus ID
* \param slot slot #
* \param func function #
* \param pos offset in config space
* \retval val value to write
*
* \return 0 success
*/
_PROTOTYPE( int ddekit_pci_writel, (int bus, int slot,
int func, int pos, ddekit_uint32_t val));
/** Find a PCI device.
*
* \ingroup DDEKit_pci
*
* \param bus pointer to bus number or \ref DDEKIT_PCI_ANY_ID
* \param slot pointer to slot number (devfn >> DEVFN_SLOTSHIFT) or \ref DDEKIT_PCI_ANY_ID
* \param func pointer to func number (devfc & DEVFN_FUNCMASK) or \ref DDEKIT_PCI_ANY_ID
* \param start search device list only behind this device (excluding it!), NULL
* searches whole device list
*
* \retval bus bus number
* \retval slot slot number
* \retval func function number
*
* \return device a valid PCI device
* \return NULL if no device found
*/
_PROTOTYPE( struct ddekit_pci_dev * ddekit_pci_find_device,
(int *bus, int *slot, int *func, struct ddekit_pci_dev *start));
/** Enable PCI device
* \ingroup DDEKit_pci
*/
_PROTOTYPE( int ddekit_pci_enable_device, (struct ddekit_pci_dev *dev));
/** Disable PCI device
* \ingroup DDEKit_pci
*/
_PROTOTYPE( int ddekit_pci_disable_device, (struct ddekit_pci_dev *dev));
/** Enable bus-mastering for device.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( void ddekit_pci_set_master, (struct ddekit_pci_dev *dev));
/** Get device vendor ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_vendor,
(struct ddekit_pci_dev *dev));
/** Get device ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_device_id,
(struct ddekit_pci_dev *dev));
/** Get device subvendor ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_sub_vendor,
(struct ddekit_pci_dev *dev));
/** Get subdevice ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned short ddekit_pci_get_sub_device,
(struct ddekit_pci_dev *dev));
/** Get device class ID.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned ddekit_pci_get_dev_class,
(struct ddekit_pci_dev *dev));
/** Get device's IRQ number.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( unsigned long ddekit_pci_get_irq,
(struct ddekit_pci_dev *dev));
/** Get device name.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( char *ddekit_pci_get_name, (struct ddekit_pci_dev *dev));
/** Get device's slot name.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( char *ddekit_pci_get_slot_name, (struct ddekit_pci_dev *dev));
/** Get one of the device's resources.
* \ingroup DDEKit_pci
*/
_PROTOTYPE( ddekit_pci_res_t *ddekit_pci_get_resource,
(struct ddekit_pci_dev *dev, unsigned int idx));
_PROTOTYPE( int ddekit_pci_irq_enable, (int bus, int slot,
int func, int pin, int *irq));
#endif

92
include/ddekit/pgtab.h Normal file
View file

@ -0,0 +1,92 @@
/*
* \brief Virtual page-table facility
* \author Thomas Friebel <tf13@os.inf.tu-dresden.de>
* \author Christian Helmuth <ch12@os.inf.tu-dresden.de>
* \date 2006-11-03
*/
#ifndef _DDEKIT_PGTAB_H
#define _DDEKIT_PGTAB_H
#include <ddekit/ddekit.h>
#include <ddekit/types.h>
/* FIXME Region types may be defined by pgtab users. Do we really need them
* here? */
enum ddekit_pgtab_type
{
PTE_TYPE_OTHER, PTE_TYPE_LARGE, PTE_TYPE_UMA, PTE_TYPE_CONTIG
};
/**
* Set virtual->physical mapping for VM region
*
* \param virt virtual start address for region
* \param phys physical start address for region
* \param pages number of pages in region
* \param type pgtab type for region
*/
_PROTOTYPE( void ddekit_pgtab_set_region,
(void *virt, ddekit_addr_t phys, int pages, int type));
/**
* Set virtual->physical mapping for VM region given a specific size in bytes.
*
* Internally, DDEKit manages regions with pages. However, DDEs do not need to tangle
* with the underlying mechanism and therefore can use this function that takes care
* of translating a size to an amount of pages.
*/
_PROTOTYPE( void ddekit_pgtab_set_region_with_size,
(void *virt, ddekit_addr_t phys, int size, int type));
/**
* Clear virtual->physical mapping for VM region
*
* \param virt virtual start address for region
* \param type pgtab type for region
*/
_PROTOTYPE( void ddekit_pgtab_clear_region,
(void *virt, int type));
/**
* Get physical address for virtual address
*
* \param virt virtual address
*
* \return physical address
*/
_PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_physaddr, (const void *virt));
/**
* Get virtual address for physical address
*
* \param physical physical address
*
* \return virtual address
*/
_PROTOTYPE( ddekit_addr_t ddekit_pgtab_get_virtaddr,
(const ddekit_addr_t physical));
/**
* Get type of VM region.
*
* \param virt virtual address
* \return VM region type
*/
_PROTOTYPE( int ddekit_pgtab_get_type, (const void *virt));
/**
* Get size of VM region.
*
* \param virt virtual address
*
* \return VM region size (in bytes)
*/
_PROTOTYPE( int ddekit_pgtab_get_size, (const void *virt));
#endif

34
include/ddekit/printf.h Normal file
View file

@ -0,0 +1,34 @@
#ifndef _DDEKIT_PRINTF_H
#define _DDEKIT_PRINTF_H
#include <ddekit/ddekit.h>
#include <stdarg.h>
/** Print message.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_print,(const char *));
/** Print message with format.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_printf,(const char *fmt, ...));
/** Print message with format list.
* \ingroup DDEKit_util
*/
_PROTOTYPE( int ddekit_vprintf, (const char *fmt, va_list va));
/** Log function and message.
* \ingroup DDEKit_util
*/
#define ddekit_log(doit, msg...) \
do { \
if (doit) { \
ddekit_printf("%s(): ", __func__); \
ddekit_printf(msg); \
ddekit_printf("\n"); \
} \
} while(0);
#endif

80
include/ddekit/resources.h Normal file
View file

@ -0,0 +1,80 @@
#ifndef _DDEKIT_RESOURCES_H
#define _DDEKIT_RESOURCES_H
#include <ddekit/ddekit.h>
#include <ddekit/types.h>
/*
* request/release an isa DMA-channel
*/
_PROTOTYPE( int ddekit_request_dma, (int nr));
_PROTOTYPE( int ddekit_release_dma, (int nr));
/*
* request/release an io-port range starting at addr start, lenght of count
*/
_PROTOTYPE( int ddekit_request_io, (ddekit_addr_t start, ddekit_addr_t count));
_PROTOTYPE( int ddekit_release_io, (ddekit_addr_t start, ddekit_addr_t count));
/*
* request an IO-Memory mapping from address start to vaddr of the length count
*/
_PROTOTYPE( int ddekit_request_mem,
(ddekit_addr_t start, ddekit_addr_t count, ddekit_addr_t *vaddr));
_PROTOTYPE( int ddekit_release_mem, (ddekit_addr_t start, ddekit_addr_t count));
/**
* Read I/O port (byte)
*
* \param port port to read
*
* \return value read from port
*/
_PROTOTYPE( unsigned char dde_kit_inb, (ddekit_addr_t port));
/**
* Read I/O port (2-byte)
*
* \param port port to read
*
* \return value read from port
*/
_PROTOTYPE( unsigned short dde_kit_inw, (ddekit_addr_t port));
/**
* Read I/O port (4-byte)
*
* \param port port to read
*
* \return value read from port
*/
_PROTOTYPE( unsigned long dde_kit_inl, (ddekit_addr_t port));
/**
* Write I/O port (byte)
*
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outb, (ddekit_addr_t port, unsigned char val));
/**
* Write I/O port (2-byte)
*
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outw, (ddekit_addr_t port, unsigned short val));
/**
* Write I/O port (4-byte)
*
* \param port port to write
* \param val value to write
*/
_PROTOTYPE( void dde_kit_outl, (ddekit_addr_t port, unsigned long val));
#endif

53
include/ddekit/semaphore.h Normal file
View file

@ -0,0 +1,53 @@
#ifndef _DDEKIT_SEMAPHORE_H
#define _DDEKIT_SEMAPHORE_H
#include <ddekit/ddekit.h>
/** \defgroup DDEKit_synchronization */
struct ddekit_sem;
typedef struct ddekit_sem ddekit_sem_t;
/** Initialize DDEKit semaphore.
*
* \ingroup DDEKit_synchronization
*
* \param value initial semaphore counter
*/
_PROTOTYPE( ddekit_sem_t *ddekit_sem_init, (int value));
/** Uninitialize semaphore.
*
* \ingroup DDEKit_synchronization
*/
_PROTOTYPE( void ddekit_sem_deinit, (ddekit_sem_t *sem));
/** Semaphore down method. */
_PROTOTYPE( void ddekit_sem_down, (ddekit_sem_t *sem));
/** Semaphore down method, non-blocking.
*
* \ingroup DDEKit_synchronization
*
* \return 0 success
* \return !=0 would block
*/
_PROTOTYPE( int ddekit_sem_down_try, (ddekit_sem_t *sem));
/** Semaphore down with timeout.
*
* \ingroup DDEKit_synchronization
*
* \return 0 success
* \return !=0 would block
*/
_PROTOTYPE( int ddekit_sem_down_timed, (ddekit_sem_t *sem, int timo));
/** Semaphore up method.
*
* \ingroup DDEKit_synchronization
*/
_PROTOTYPE( void ddekit_sem_up, (ddekit_sem_t *sem));
#endif

164
include/ddekit/thread.h Normal file
View file

@ -0,0 +1,164 @@
#ifndef _DDEKIT_THREAD_H
#define _DDEKIT_THREAD_H
/** \defgroup DDEKit_threads */
#include <ddekit/ddekit.h>
#include <ddekit/lock.h>
struct ddekit_thread;
typedef struct ddekit_thread ddekit_thread_t;
/** Create thread
*
* \ingroup DDEKit_threads
*
* Create a new thread running the specified thread function with the specified
* arguments. The thread is assigned the given internal name.
*
* Additionally, DDEKit threads possess a thread-local storage area where they
* may store arbitrary data.
*
* \param fun thread function
* \param arg optional argument to thread function, set to NULL if not needed
* \param name internal thread name
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_create,
(void (*fun)(void *), void *arg, const char *name));
/** Reference to own DDEKit thread id.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_myself, (void));
/** Initialize thread with given name.
*
* \ingroup DDEKit_threads
*
* This function may be used by threads that were not created using
* \ref ddekit_thread_create. This enables such threads to be handled as if they
* were DDEKit threads.
*/
_PROTOTYPE( ddekit_thread_t *ddekit_thread_setup_myself, (const char *name));
/** Get TLS data for a specific thread.
*
* \ingroup DDEKit_threads
*
* \return Pointer to TLS data of this thread.
*/
_PROTOTYPE( void *ddekit_thread_get_data, (ddekit_thread_t *thread));
/** Get TLS data for current thread.
*
* \ingroup DDEKit_threads
*
* Same as calling \ref ddekit_thread_get_data with \ref ddekit_thread_myself
* as parameter.
*
* \return Pointer to TLS data of current thread.
*/
_PROTOTYPE( void *ddekit_thread_get_my_data, (void));
/** Set TLS data for specific thread.
*
* \ingroup DDEKit_threads
*
* \param thread DDEKit thread
* \param data pointer to thread data
*/
_PROTOTYPE( void ddekit_thread_set_data, (ddekit_thread_t *thread,
void *data));
/** Set TLS data for current thread.
*
* \ingroup DDEKit_threads
*
* \param data pointer to thread data
*/
_PROTOTYPE( void ddekit_thread_set_my_data, (void *data));
/** Sleep for some miliseconds.
*
* \ingroup DDEKit_threads
*
* \param msecs time to sleep in ms.
*/
_PROTOTYPE( void ddekit_thread_msleep, (unsigned long msecs));
/** Sleep for some microseconds.
*
* \ingroup DDEKit_threads
*
* \param usecs time to sleep in µs.
*/
_PROTOTYPE( void ddekit_thread_usleep, (unsigned long usecs));
/** Sleep for some nanoseconds.
*
* \ingroup DDEKit_threads
*
* \param usecs time to sleep in ns.
*/
_PROTOTYPE( void ddekit_thread_nsleep, (unsigned long nsecs));
/** Sleep until a lock becomes unlocked.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_sleep, (ddekit_lock_t *lock));
/** Wakeup a waiting thread.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_wakeup, (ddekit_thread_t *thread));
/** Terminate a thread
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_exit, (void) __attribute__((noreturn)));
/** Terminate a thread
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_terminate, (ddekit_thread_t *thread));
/** Get the name, a thread registered with DDEKit.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( const char *ddekit_thread_get_name, (ddekit_thread_t *thread));
/** Get unique ID of a DDEKit thread.
*
* \ingroup DDEKit_threads
*
* DDEKit does not allow direct access to the thread data
* structure, since this struct contains L4-specific data types.
* However, applications might want to get some kind of ID related
* to a ddekit_thread, for instance to use it as a Linux-like PID.
*/
_PROTOTYPE( int ddekit_thread_get_id, (ddekit_thread_t *thread));
/** Hint that this thread is done and may be scheduled somehow.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_thread_schedule, (void));
/** Hint that this thread is done and may be scheduled somehow.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_yield, (void));
/** Initialize DDEKit thread subsystem.
*
* \ingroup DDEKit_threads
*/
_PROTOTYPE( void ddekit_init_threads, (void));
#endif

52
include/ddekit/timer.h Normal file
View file

@ -0,0 +1,52 @@
#ifndef _DDEKIT_TIMER_H
#define _DDEKIT_TIMER_H
#include <ddekit/ddekit.h>
#include <ddekit/thread.h>
/** \defgroup DDEKit_timer
*
* Timer subsystem
*
* DDEKit provides a generic timer implementation that enables users
* to execute a function with some arguments after a certain period
* of time. DDEKit therefore starts a timer thread that executes these
* functions and keeps track of the currently running timers.
*/
/** Add a timer event. After the absolute timeout has expired, function fn
* is called with args as arguments.
*
* \ingroup DDEKit_timer
*
* \return >=0 valid timer ID
* \return < 0 error
*/
_PROTOTYPE( int ddekit_add_timer,
(void (*fn)(void *), void *args, unsigned long timeout));
/** Delete timer with the corresponding timer id.
*
* \ingroup DDEKit_timer
*/
_PROTOTYPE( int ddekit_del_timer, (int timer));
/** Check whether a timer is pending
*
* \ingroup DDEKit_timer
*
* Linux needs this.
*/
_PROTOTYPE( int ddekit_timer_pending, (int timer));
/** Initialization function, startup timer thread
*
* \ingroup DDEKit_timer
*/
_PROTOTYPE( void ddekit_init_timers, (void));
/** Get the timer thread.
*/
_PROTOTYPE( ddekit_thread_t *ddekit_get_timer_thread, (void));
#endif

22
include/ddekit/types.h Normal file
View file

@ -0,0 +1,22 @@
/*
* \brief Types for ddekit (x86 version)
* \author Thomas Friebel <tf13@os.inf.tu-dresden.de>
* \author Christian Helmuth <ch12@os.inf.tu-dresden.de>
* \date 2006-11-09
*
* FIXME This is definitely arch-dependent! Move to ARCH-something
*/
#ifndef _DDEKIT_TYPES_H
#define _DDEKIT_TYPES_H
typedef signed char ddekit_int8_t;
typedef unsigned char ddekit_uint8_t;
typedef signed short int ddekit_int16_t;
typedef unsigned short int ddekit_uint16_t;
typedef signed int ddekit_int32_t;
typedef unsigned int ddekit_uint32_t;
typedef unsigned long ddekit_addr_t;
#endif

97
include/ddekit/usb.h Normal file
View file

@ -0,0 +1,97 @@
#ifndef _DDEKIT_USB_H
#define _DDEKIT_USB_H
#include <ddekit/ddekit.h>
#include <ddekit/types.h>
/** isochronous transfer */
#define DDEKIT_USB_TRANSFER_ISO 0
/** interrupt transfer */
#define DDEKIT_USB_TRANSFER_INT 1
/** control transfer */
#define DDEKIT_USB_TRANSFER_CTL 2
/** bulk transfer */
#define DDEKIT_USB_TRANSFER_BLK 3
#define DDEKIT_USB_IN 1
#define DDEKIT_USB_OUT 0
struct ddekit_usb_dev;
struct ddekit_usb_urb;
struct ddekit_usb_device_id {
ddekit_uint16_t idVendor;
ddekit_uint16_t idProduct;
ddekit_uint32_t bcdDevice;
ddekit_uint8_t bDeviceClass;
ddekit_uint8_t bDeviceSubClass;
ddekit_uint8_t bDeviceProtocol;
ddekit_uint8_t bInterfaceClass;
ddekit_uint8_t bInterfaceSubClass;
ddekit_uint8_t bInterfaceProtocol;
};
struct ddekit_usb_iso_packet_desc {
ddekit_int32_t offset;
ddekit_int32_t length; /* expected length */
ddekit_int32_t actual_length;
ddekit_int32_t status;
};
typedef void (*ddekit_usb_completion_cb)(void* priv);
typedef void (*ddekit_usb_connect_cb)(struct ddekit_usb_dev *dev,
unsigned int interfaces);
typedef void (*ddekit_usb_disconnect_cb)(struct ddekit_usb_dev *dev);
typedef void *(*ddekit_usb_malloc_fn)(unsigned size);
typedef void (*ddekit_usb_free_fn)(void *ptr);
struct ddekit_usb_driver {
ddekit_usb_completion_cb completion;
ddekit_usb_connect_cb connect;
ddekit_usb_disconnect_cb disconnect;
};
struct ddekit_usb_urb {
struct ddekit_usb_dev *dev;
ddekit_int32_t type;
ddekit_int32_t endpoint;
ddekit_int32_t direction;
ddekit_int32_t status;
ddekit_int32_t interval;
ddekit_uint32_t transfer_flags;
ddekit_uint32_t size;
ddekit_uint32_t actual_length;
ddekit_int32_t number_of_packets;
ddekit_int32_t error_count;
ddekit_int32_t start_frame;
char *setup_packet;
char *data;
struct ddekit_usb_iso_packet_desc *iso_desc;
void *priv;
void *ddekit_priv;
};
_PROTOTYPE( int ddekit_usb_dev_set_data,
(struct ddekit_usb_dev *dev, void *data));
_PROTOTYPE( void *ddekit_usb_dev_get_data, (struct ddekit_usb_dev *dev));
_PROTOTYPE( void ddekit_usb_get_device_id, (struct ddekit_usb_dev *dev,
struct ddekit_usb_device_id *id));
_PROTOTYPE( int ddekit_usb_submit_urb, (struct ddekit_usb_urb *d_urb));
_PROTOTYPE( int ddekit_usb_cancle_urb, (struct ddekit_usb_urb *d_urb));
/*
* This one is only implemented for the client side. For the server side is
* has to be implemented in the DDELinux/FBSD part.
*/
_PROTOTYPE( int ddekit_usb_init, (struct ddekit_usb_driver *drv,
ddekit_usb_malloc_fn *_m,
ddekit_usb_free_fn *_f));
#endif