Subversion Repositories Kolibri OS

#define __TYPES_H__

#define true                 1

typedef unsigned int         count_t;

typedef unsigned int         addr_t;

typedef unsigned short       u16;

typedef unsigned int         u32;

typedef unsigned long long   u64;

typedef unsigned short       __u16;

typedef unsigned int         __u32;

typedef unsigned long long   __u64;

typedef signed short        __s16;

typedef signed int          __s32;

typedef signed long long    __s64;

typedef unsigned short       uint16_t;

typedef unsigned int         uint32_t;

typedef unsigned long long   uint64_t;

typedef unsigned short       u16_t;

typedef unsigned int         u32_t;

typedef unsigned long long   u64_t;

typedef signed long long     int64_t;

typedef uint32_t             resource_size_t;

#define cpu_to_le32(v32) (v32)

#define cpu_to_le64(v64) (v64)

#define le16_to_cpu(v16) (v16)

#define le32_to_cpu(v32) (v32)

#define le64_to_cpu(v64) (v64)

#define unlikely(x)     __builtin_expect(!!(x), 0)

        unsigned long name[BITS_TO_LONGS(bits)]

#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                 */

    printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg)

    printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg)

    BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))

#define BUG() do { \

         printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \

       /*  panic("BUG!"); */ \

 } while (0)

#endif

#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0)

#endif

#define MTRR_TYPE_WRCOMB     1

#define MTRR_TYPE_WRTHROUGH  4

#define MTRR_TYPE_WRPROT     5

#define MTRR_TYPE_WRBACK     6

#define MTRR_NUM_TYPES       7

void*   memset(void *s, int c, size_t n);

size_t  strlen(const char *s);

char *strncpy (char *dst, const char *src, size_t len);

#define kfree free

{

    void *ret = malloc(size);

    memset(ret, 0, size);

    return ret;

}

//    struct kref refcount;

//    struct kref handlecount;

//    struct drm_device *dev;

//    struct file *filp;

//    struct drm_map_list map_list;

     * Size of the object, in bytes.  Immutable over the object's

     * lifetime.

     */

    size_t size;

     * Global name for this object, starts at 1. 0 means unnamed.

     * Access is covered by the object_name_lock in the related drm_device

     */

    int name;

     * Memory domains. These monitor which caches contain read/write data

     * related to the object. When transitioning from one set of domains

     * to another, the driver is called to ensure that caches are suitably

     * flushed and invalidated

     */

    uint32_t read_domains;

    uint32_t write_domain;

     * While validating an exec operation, the

     * new read/write domain values are computed here.

     * They will be transferred to the above values

     * at the point that any cache flushing occurs

     */

    uint32_t pending_read_domains;

    uint32_t pending_write_domain;

};

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

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

#define mb() __asm__ __volatile__("lock; addl $0,0(%esp)")

#define PAGE_SHIFT      12

{

        if (nbits <= BITS_PER_LONG)

                *dst = 0UL;

        else {

                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);

                memset(dst, 0, len);

        }

}

#define IDR_FULL 0xfffffffful

        unsigned long            bitmap; /* A zero bit means "space here" */

        struct idr_layer        *ary[1<

        int                      count;  /* When zero, we can release it */

};

        struct idr_layer *top;

        struct idr_layer *id_free;

        int               layers;

        int               id_free_cnt;

//        spinlock_t        lock;

};

        typeof(x) _x = (x);     \

        typeof(y) _y = (y);     \

        (void) (&_x == &_y);            \

        _x < _y ? _x : _y; })

        typeof(x) _x = (x);     \

        typeof(y) _y = (y);     \

        (void) (&_x == &_y);            \

        _x > _y ? _x : _y; })

       uint32_t __base = (base);                       \

       uint32_t __rem;                                 \

       (void)(((typeof((n)) *)0) == ((uint64_t *)0));  \

       if (likely(((n) >> 32) == 0)) {                 \

               __rem = (uint32_t)(n) % __base;         \

               (n) = (uint32_t)(n) / __base;           \

       } else                                          \

               __rem = __div64_32(&(n), __base);       \

       __rem;                                          \

})

#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)

{

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

                return NULL;

        return kmalloc(n * size, 0);

}

>