Subversion Repositories Kolibri OS

#ifndef _LINUX_KERNEL_H

#define _LINUX_KERNEL_H

/*

 * 'kernel.h' contains some often-used function prototypes etc

 */

#ifdef __KERNEL__

#include 

#include 

#include 

#include 

#define USHRT_MAX	((u16)(~0U))

#define SHRT_MAX	((s16)(USHRT_MAX>>1))

#define SHRT_MIN	((s16)(-SHRT_MAX - 1))

#define INT_MAX     ((int)(~0U>>1))

#define INT_MIN     (-INT_MAX - 1)

#define UINT_MAX    (~0U)

#define LONG_MAX    ((long)(~0UL>>1))

#define LONG_MIN    (-LONG_MAX - 1)

#define ULONG_MAX   (~0UL)

#define LLONG_MAX   ((long long)(~0ULL>>1))

#define LLONG_MIN   (-LLONG_MAX - 1)

#define ULLONG_MAX  (~0ULL)

#define ALIGN(x,a)      __ALIGN_MASK(x,(typeof(x))(a)-1)

#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))

#define PTR_ALIGN(p, a)     ((typeof(p))ALIGN((unsigned long)(p), (a)))

#define IS_ALIGNED(x, a)        (((x) & ((typeof(x))(a) - 1)) == 0)

/**

 * upper_32_bits - return bits 32-63 of a number

 * @n: the number we're accessing

 *

 * A basic shift-right of a 64- or 32-bit quantity.  Use this to suppress

 * the "right shift count >= width of type" warning when that quantity is

 * 32-bits.

 */

#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))

/**

 * lower_32_bits - return bits 0-31 of a number

 * @n: the number we're accessing

 */

#define lower_32_bits(n) ((u32)(n))

#define KERN_EMERG      "<0>"   /* system is unusable                   */

#define KERN_ALERT      "<1>"   /* action must be taken immediately     */

#define KERN_CRIT       "<2>"   /* critical conditions                  */

#define KERN_ERR        "<3>"   /* error conditions                     */

#define KERN_WARNING    "<4>"   /* warning conditions                   */

#define KERN_NOTICE     "<5>"   /* normal but significant condition     */

#define KERN_INFO       "<6>"   /* informational                        */

#define KERN_DEBUG      "<7>"   /* debug-level messages                 */

//int printk(const char *fmt, ...);

#define printk(fmt, arg...)    dbgprintf(fmt , ##arg)

/*

 * min()/max()/clamp() macros that also do

 * strict type-checking.. See the

 * "unnecessary" pointer comparison.

 */

#define min(x, y) ({                \

    typeof(x) _min1 = (x);          \

    typeof(y) _min2 = (y);          \

    (void) (&_min1 == &_min2);      \

    _min1 < _min2 ? _min1 : _min2; })

#define max(x, y) ({                \

    typeof(x) _max1 = (x);          \

    typeof(y) _max2 = (y);          \

    (void) (&_max1 == &_max2);      \

    _max1 > _max2 ? _max1 : _max2; })

/*

 * ..and if you can't take the strict

 * types, you can specify one yourself.

 *

 * Or not use min/max/clamp at all, of course.

 */

#define min_t(type, x, y) ({            \

    type __min1 = (x);          \

    type __min2 = (y);          \

    __min1 < __min2 ? __min1: __min2; })

#define max_t(type, x, y) ({            \

    type __max1 = (x);          \

    type __max2 = (y);          \

    __max1 > __max2 ? __max1: __max2; })

/**

 * container_of - cast a member of a structure out to the containing structure

 * @ptr:    the pointer to the member.

 * @type:   the type of the container struct this is embedded in.

 * @member: the name of the member within the struct.

 *

 */

#define container_of(ptr, type, member) ({          \

    const typeof( ((type *)0)->member ) *__mptr = (ptr);    \

    (type *)( (char *)__mptr - offsetof(type,member) );})

static inline void *kcalloc(size_t n, size_t size, uint32_t flags)

{

        if (n != 0 && size > ULONG_MAX / n)

                return NULL;

        return kzalloc(n * size, 0);

}

extern const char hex_asc[];

#define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]

#define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]

static inline char *pack_hex_byte(char *buf, u8 byte)

{

    *buf++ = hex_asc_hi(byte);

    *buf++ = hex_asc_lo(byte);

    return buf;

}

void free (void *ptr);

#endif /* __KERNEL__ */

typedef unsigned long   pgprotval_t;

typedef struct pgprot { pgprotval_t pgprot; } pgprot_t;

struct file {};

struct vm_area_struct {};

struct address_space {};

struct device

{

    struct device   *parent;

    void            *driver_data;

};

static inline void dev_set_drvdata(struct device *dev, void *data)

{

    dev->driver_data = data;

}

static inline void *dev_get_drvdata(struct device *dev)

{

    return dev->driver_data;

}

#define preempt_disable()       do { } while (0)

#define preempt_enable_no_resched() do { } while (0)

#define preempt_enable()        do { } while (0)

#define preempt_check_resched()     do { } while (0)

#define preempt_disable_notrace()       do { } while (0)

#define preempt_enable_no_resched_notrace() do { } while (0)

#define preempt_enable_notrace()        do { } while (0)

#define in_dbg_master() (0)

#endif