#ifndef _V4L2_OSDEP_H_
#define _V4L2_OSDEP_H_

#include "platform/platform_stdlib.h"
#include "basic_types.h"
#include "osdep_api.h"
#include "usb_defs.h"
#include "errno.h"
//#include "hal_util.h"
#include "dlist.h"

#define V4L2_LAYER_DEBUG 0
#if     V4L2_LAYER_DEBUG
#define V4L2_PRINTF(fmt, args...)	printf("\n\r%s: " fmt, __FUNCTION__, ## args)
#define V4L2_ERROR(fmt, args...)        printf("\n\r%s: " fmt, __FUNCTION__, ## args)
#else
#define V4L2_PRINTF(fmt, args...)
#define V4L2_ERROR(fmt, args...)        printf("\n\r%s: " fmt, __FUNCTION__, ## args)
#endif

/* misc items */
#ifndef ssize_t
#define ssize_t SSIZE_T
#endif
#ifndef size_t
#define size_t SIZE_T
#endif

#ifndef __user
#define __user
#endif

#ifndef loff_t
#define loff_t long
#endif
#ifndef __u8
#define __u8 	u8
#endif
#ifndef __u16
#define __u16	u16
#endif
#ifndef __u32
#define __u32	u32
#endif
#ifndef __u64
#define __u64	u64
#endif
#ifndef __s8
#define __s8	s8
#endif
#ifndef __s16
#define __s16	s16
#endif
#ifndef __s32
#define __s32	s32
#endif
#ifndef __s64
#define __s64	s64
#endif

#ifndef spinlock_t
#define spinlock_t _Lock
#endif

#ifndef gfp_t
#define gfp_t	u32
#endif

#ifndef _atomic_spin_lock_irqsave
#define _atomic_spin_lock_irqsave(p, flags) 		SaveAndCli()
#endif
#ifndef _atomic_spin_unlock_irqrestore
#define _atomic_spin_unlock_irqrestore(p, flags)	RestoreFlags()
#endif
#ifndef local_irq_save
#define local_irq_save(flags)				SaveAndCli()
#endif
#ifndef local_irq_restore
#define local_irq_restore(flags)			RestoreFlags()
#endif
#ifndef cris_atomic_save
#define cris_atomic_save(addr, flags) 			local_irq_save(flags)
#endif
#ifndef cris_atomic_restore
#define cris_atomic_restore(addr, flags) 		local_irq_restore(flags)
#endif

/*
 * abs() handles unsigned and signed longs, ints, shorts and chars.  For all
 * input types abs() returns a signed long.
 * abs() should not be used for 64-bit types (s64, u64, long long) - use abs64()
 * for those.
 */

#ifndef abs
#define abs(x) ((x >= 0) ? (x) : (x * -1))
#endif

#ifndef min 
#define min(x, y) ((x) < (y) ? (x) : (y))
#endif
#ifndef max
#define max(x, y) ((x) > (y) ? (x) : (y))
#endif
#ifndef min_t 
#define min_t(type, x, y) ({                    \
         type __min1 = (x);                      \
         type __min2 = (y);                      \
         (__min1 < __min2) ? (__min1) : (__min2); })
#endif
#ifndef max_t
#define max_t(type, x, y) ({                    \
         type __max1 = (x);                      \
         type __max2 = (y);                      \
         (__max1 > __max2) ? (__max1) : (__max2); })
#endif
#ifndef max_tt
#define max_tt(ret,type,x,y) do{                    \
         type __max1 = (x);                      \
         type __max2 = (y);                      \
         ret = (__max1 > __max2) ? (__max1) : (__max2); }while(0) 
#endif
#ifndef min_tt 
#define min_tt(ret,type, x, y) do{                    \
         type __min1 = (x);                      \
         type __min2 = (y);                      \
         ret = (__min1 < __min2) ? (__min1) : (__min2); }while(0)
#endif 


/**
* container_of - cast a member of a structure out to the containing structure
* @p(ptr): 	   the pointer to the member.
* @t(type):	   the type of the container struct this is embedded in.
* @m(member):	   the name of the member within the struct.
*
*/
#ifndef container_of 
	#define container_of(ptr, type, member) \
			((type *)((char *)(ptr)-(SIZE_T)(&((type *)0)->member)))
#endif
	
	/**
	* list_next_entry - get the next element in list
	* @pos: 	   the type * to cursor
	* @member:	   the name of the list_struct within the struct.
	*/

#define list_next_entry(pos, member, type)				\
			 list_entry((pos)->member.next, type, member)

	/**
	* list_for_each_entry_continue - continue iteration over list of given type
	* @pos: 	   the type * to use as a loop cursor.
	* @head:	   the head for your list.
	* @member:	   the name of the list_struct within the struct.
	*
	* Continue to iterate over list of given type, continuing after
	* the current position.
	*/

#define list_for_each_entry_continue(pos, head, member, type)		\
		for (pos = list_next_entry(pos, member, type);			\
			&pos->member != (head); 					\
				pos = list_next_entry(pos, member, type))           
           

/* spin lock */
#ifndef spin_lock_init
	#define spin_lock_init(plock) 			RtlSpinlockInit((plock))
#endif
#ifndef spin_lock_free
	#define spin_lock_free(plock) 			RtlSpinlockFree((plock))
#endif
#ifndef spin_lock
	#define spin_lock(plock) 			RtlSpinlock((plock))
#endif
#ifndef spin_unlock 
	#define spin_unlock(plock) 			RtlSpinunlock((plock))
#endif


/* mutex */
#ifndef Mutex
	#define Mutex _Mutex
#endif
#ifndef mutex_init
	#define mutex_init(pmutex)			RtlMutexInit((pmutex))
#endif
#ifndef mutex_lock
	#define mutex_lock(pmutex)			RtlDownSema((pmutex))
#endif
#ifndef mutex_unlock
	#define mutex_unlock(pmutex)		RtlUpSema((pmutex))	
#endif
#ifndef mutex_destory
	#define mutex_destory(pmutex)			RtlMutexFree((pmutex))
#endif

/* semaphore */
#ifndef Sema
        #define Sema _Sema
#endif
#ifndef Sema_Init
	#define Sema_Init(pmutex, pval)			RtlInitSema(pmutex, pval)
#endif
#ifndef Sema_Free
	#define Sema_Free(pmutex)				RtlFreeSema(pmutex)
#endif
#ifndef Sema_Up
	#define Sema_Up(pmutex)				RtlUpSema(pmutex)
#endif
#ifndef Sema_Down
	#define Sema_Down(pmutex)				RtlDownSema(pmutex)
#endif
#ifndef Sema_Sown_WithTimeout
	#define Sema_Down_WithTimeout(pmutex,ptimeout)			RtlDownSemaWithTimeout(pmutex,ptimeout) //
#endif

/* Atomic integer operations */
#ifndef atomic_set
	#define atomic_set(v, i)		RTL_ATOMIC_SET((v), (i))
#endif
#ifndef atomic_read
	#define atomic_read(v)			RTL_ATOMIC_READ((v))
#endif
#ifndef atomic_add
	#define atomic_add(v, i)		RTL_ATOMIC_ADD((v), (i))
#endif
#ifndef atomic_sub
	#define atomic_sub(v, i)		RTL_ATOMIC_SUB((v), (i))
#endif
#ifndef atomic_inc
	#define atomic_inc(v)			RTL_ATOMIC_INC((v))
#endif
#ifndef atomic_dec
	#define atomic_dec(v)			RTL_ATOMIC_DEC((v))
#endif

           
// IOCTL ...
#ifndef _IOC_NRBITS
#define _IOC_NRBITS 	(8) 	
#endif
#ifndef _IOC_TYPEBITS
#define _IOC_TYPEBITS 	(8) 	
#endif
#ifndef _IOC_SIZEBITS
#define _IOC_SIZEBITS 	(14) 	
#endif
#ifndef _IOC_DIRBITS
#define _IOC_DIRBITS 	(2) 	
#endif
#ifndef _IOC_NRMASK
#define _IOC_NRMASK 	((1 << _IOC_NRBITS) - 1) 
#endif
#ifndef _IOC_TYPEMASK
#define _IOC_TYPEMASK 	((1 << _IOC_TYPEBITS) - 1)
#endif
#ifndef _IOC_SIZEMASK
#define _IOC_SIZEMASK 	((1 << _IOC_SIZEBITS) - 1)
#endif
#ifndef _IOC_DIRMASK
#define _IOC_DIRMASK 	((1 << _IOC_DIRBITS) - 1) 
#endif
#ifndef _IOC_NRSHIFT 
#define _IOC_NRSHIFT 	(0) 
#endif
#ifndef _IOC_TYPESHIFT
#define _IOC_TYPESHIFT 	(_IOC_NRSHIFT + _IOC_NRBITS) 
#endif
#ifndef _IOC_SIZESHIFT
#define _IOC_SIZESHIFT 	(_IOC_TYPESHIFT + _IOC_TYPEBITS) 
#endif
#ifndef _IOC_DIRSHIFT
#define _IOC_DIRSHIFT 	(_IOC_SIZESHIFT + _IOC_SIZEBITS) 
#endif 

/*
 * Direction bits.
 */
#ifndef _IOC_NONE
#define _IOC_NONE (0U) 
#endif
#ifndef _IOC_WRITE
#define _IOC_WRITE (1U) 
#endif
#ifndef _IOC_READ
#define _IOC_READ (2U) 
#endif 


/*
 * combine the four dir�Atype�Anr�Asize parameters to one cmd parameter
 *
 */
#ifndef _IOC
#define _IOC(dir,type,nr,size) \
       (((dir) << _IOC_DIRSHIFT) | \
        ((type) << _IOC_TYPESHIFT) | \
        ((nr) << _IOC_NRSHIFT) | \
        ((size) << _IOC_SIZESHIFT))
#endif
/*
 * used to create IOCTL cmd 
 */
#ifndef _IO
#define _IO(type,nr)        	_IOC(_IOC_NONE,(type), (nr), 0) 
#endif
#ifndef _IOR  
#define _IOR(type,nr,size)     	_IOC(_IOC_READ,(type), (nr), sizeof(size)) 
#endif
#ifndef _IOW
#define _IOW(type,nr,size)    	_IOC(_IOC_WRITE,(type), (nr), sizeof(size))
#endif
#ifndef _IOWR
#define _IOWR(type,nr,size) 	_IOC(_IOC_READ|_IOC_WRITE, (type), (nr), sizeof(size))
#endif
/* 
 * used to decode ioctl infoations..
 */
#ifndef _IOC_DIR
#define _IOC_DIR(nr) (((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
#endif
#ifndef _IOC_TYPE
#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
#endif
#ifndef _IOC_NR
#define _IOC_NR(nr) (((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
#endif
#ifndef _IOC_SIZE
#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
#endif 
/* ...and for the drivers/sound files... */
#ifndef IOC_IN
#define IOC_IN (_IOC_WRITE << _IOC_DIRSHIFT)
#endif
#ifndef IOC_OUT
#define IOC_OUT (_IOC_READ << _IOC_DIRSHIFT)
#endif
#ifndef IOC_INOUT
#define IOC_INOUT ((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
#endif
#ifndef IOCSIZE_MASK
#define IOCSIZE_MASK (_IOC_SIZEMASK << _IOC_SIZESHIFT)
#endif
#ifndef IOCSIZE_SHIFT
#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
#endif

#ifndef DIV_ROUND_UP
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
#endif
#ifndef BITS_PER_LONG
#define BITS_PER_LONG (32)
#endif
#ifndef BITS_PER_LONG_LONG
#define BITS_PER_LONG_LONG (32)
#endif
#ifndef BIT
#define BIT(nr)                 (1UL << (nr))
#endif
#ifndef BIT_ULL
#define BIT_ULL(nr)             (1ULL << (nr))
#endif
#ifndef BIT_MASK
#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
#endif
#ifndef BIT_WORD
#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
#endif
#ifndef BIT_ULL_MASK
#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
#endif
#ifndef BIT_ULL_WORD
#define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
#endif
#ifndef BITS_PER_BYTE
#define BITS_PER_BYTE           (8)
#endif
#ifndef BITS_TO_LONGS
#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
#endif

/* __ffs to find out the first exist 1 offset, from bit 0 ~ 31 */
#ifndef ffz
#define ffz(x)  __ffs(~(x))                     
#endif
/* __builtin_constant_p is gcc build-in function to check the parameter is const or not */
#ifndef small_const_nbits
#define small_const_nbits(nbits) \
         (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
#endif
/**
 * __ffs - find first bit in word.
 * @word: The word to search
 *
 * Undefined if no bit exists, so code should check against 0 first.
 */
static inline unsigned long __ffs(unsigned long word)
{
	int num = 0;

#if BITS_PER_LONG == 64
	if ((word & 0xffffffff) == 0) {
		num += 32;
		word >>= 32;
	}
#endif
	if ((word & 0xffff) == 0) {                         
		num += 16;                                      
		word >>= 16;
	}
	if ((word & 0xff) == 0) {                           
		num += 8;
		word >>= 8;
	}
	if ((word & 0xf) == 0) {
		num += 4;
		word >>= 4;
	}
	if ((word & 0x3) == 0) {
		num += 2;
		word >>= 2;
	}
	if ((word & 0x1) == 0)
		num += 1;
	
	return num;                                         
}

/**
  * __fls - find last (most-significant) set bit in a long word
  * @word: the word to search
  *
  * Undefined if no set bit exists, so code should check against 0 first.
  */
static inline unsigned long __fls(unsigned long word)
{
         int num = BITS_PER_LONG - 1;
 
 #if BITS_PER_LONG == 64
         if (!(word & (~0ul << 32))) {
                 num -= 32;
                 word <<= 32;
         }
 #endif
         if (!(word & (~0ul << (BITS_PER_LONG-16)))) {
                 num -= 16;
                 word <<= 16;
         }
         if (!(word & (~0ul << (BITS_PER_LONG-8)))) {
                 num -= 8;
                 word <<= 8;
         }
         if (!(word & (~0ul << (BITS_PER_LONG-4)))) {
                 num -= 4;
                 word <<= 4;
         }
         if (!(word & (~0ul << (BITS_PER_LONG-2)))) {
                 num -= 2;
                 word <<= 2;
         }
         if (!(word & (~0ul << (BITS_PER_LONG-1))))
                num -= 1;
        return num;
}

/**
 * test_bit - Determine whether a bit is set
 * @nr: bit number to test
 * @addr: Address to start counting from
 */
static inline int test_bit(int nr, const volatile unsigned long *addr)
{
        return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
}



/*
* Find the first cleared bit in a memory region.
*/
static inline unsigned long find_first_zero_bit(
	const unsigned long *addr, unsigned long size)
{
        const unsigned long *p = addr;
        unsigned long result = 0;
        unsigned long tmp;

        while (size & ~(BITS_PER_LONG-1)) {
                if (~(tmp = *(p++)))
                        goto found;
                result += BITS_PER_LONG;
                size -= BITS_PER_LONG;
        }
        if (!size)
                return result;

        tmp = (*p) | (~0UL << size);
        if (tmp == ~0UL)        /* Are any bits zero? */
                return result + size;   /* Nope. */
found:

	return result + ffz(tmp);
	//tmp = 0;
	//return result;

}

static inline unsigned long find_next_zero_bit(
	const unsigned long *addr,unsigned long size, unsigned long offset)
{
    const unsigned long *p = addr + BIT_WORD(offset); // offset��_p���V��long�a�}32���?
    unsigned long result = offset & ~(BITS_PER_LONG-1); // offset�O��result?4�r?
    unsigned long tmp;

    if (offset >= size)
        return size;
    size -= result;                                     // ?��32��㭿?�W
    offset %= BITS_PER_LONG;                            // offset��_32�쪺�ĤL��
    if (offset) {                                       // offset���b�@?long?�u����0��W,�b1-31�줤[luther.gliethttp]
        tmp = *(p++);
        tmp |= ~0UL >> (BITS_PER_LONG - offset);        // ?0-offset?�u��R�W1.
        if (size < BITS_PER_LONG)                       // ����32bits
            goto found_first;
        if (~tmp)                                       // ���D�D0?���t��0��
            goto found_middle;
        size -= BITS_PER_LONG;                          // �p�G�W��~tmp���_0,���\?��?*p?�u?32���1.[luther.gliethttp]
        result += BITS_PER_LONG;
    }
    while (size & ~(BITS_PER_LONG-1)) {                 // �n�F,?���?��,��?��offset�w??�b4�r?����0��W,�U��?��
        if (~(tmp = *(p++)))                            // 4�r?�ֳt�d?.�p�G~tmp�D0,?��?32��?�u���t��0?�u,���.[luther.gliethttp]
            goto found_middle;
        result += BITS_PER_LONG;                        // ��U�@?4�r?��?
        size -= BITS_PER_LONG;                          // ?��4�r??�u
    }
    if (!size)                                          // size���_0,?������size���_4�r?�㭿?,�䦸�Ҧ�?�u�w?�d��,
        return result;                                  // �Ҧ�?�u����?1,?��??0��,result���_size.[luther.gliethttp]
    tmp = *p;                                           // size���O32��㭿?,?�ѤL?bit?��?�d,???��U��?�d�u�@.[luther.gliethtp]

found_first:
    tmp |= ~0UL << size;                                // ?�b0-size?����?�u,size-31?���ϥΪ�?,�ҥH��?size-31�m����1.
    if (tmp == ~0UL)    /* Are any bits zero? */        // �p�Gtmp��1,���\?���N?���1?
        return result + size;    /* Nope. */             // result+size�N���_��??�J��??size�j�p.[luther.gliethttp]
found_middle:
    return result + ffz(tmp);                           // ��?�b32��?�u��0-31��??���w�s�b0���,?��L�O�ĤL��.[luther.gliethttp]
}

//int find_next_zero_bit(const void * p, int size, int offset);
//int find_first_bit(const unsigned long *p, unsigned size);
//int find_next_bit(const unsigned long *p, int size, int offset);
/**
* set_bit - Atomically set a bit in memory
* @nr: the bit to set
* @addr: the address to start counting from
*
* This function is atomic and may not be reordered.  See __set_bit()
* if you do not require the atomic guarantees.
*
* Note: there are no guarantees that this function will not be reordered
* on non x86 architectures, so if you are writing portable code,
* make sure not to rely on its reordering guarantees.
*
* Note that @nr may be almost arbitrarily large; this function is not
* restricted to acting on a single-word quantity.
*/
static inline void set_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long flags;
	(void)flags;
	//taskENTER_CRITICAL();
	_atomic_spin_lock_irqsave(p, flags);
	*p  |= mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	//taskEXIT_CRITICAL();
}

/**
* clear_bit - Clears a bit in memory
* @nr: Bit to clear
* @addr: Address to start counting from
*
* clear_bit() is atomic and may not be reordered.  However, it does
* not contain a memory barrier, so if it is used for locking purposes,
* you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
* in order to ensure changes are visible on other processors.
*/
static inline void clear_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long flags;
	(void)flags;
	_atomic_spin_lock_irqsave(p, flags);
	//taskENTER_CRITICAL();
	*p &= ~mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	//taskEXIT_CRITICAL();
}
 
/**
* change_bit - Toggle a bit in memory
* @nr: Bit to change
* @addr: Address to start counting from
*
* change_bit() is atomic and may not be reordered. It may be
* reordered on other architectures than x86.
* Note that @nr may be almost arbitrarily large; this function is not
* restricted to acting on a single-word quantity.
*/
static inline void change_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long flags;
	(void)flags;
	//taskENTER_CRITICAL();
	_atomic_spin_lock_irqsave(p, flags);
	*p ^= mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	//taskEXIT_CRITICAL();
}
 
/**
* test_and_set_bit - Set a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It may be reordered on other architectures than x86.
* It also implies a memory barrier.
*/
static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long old;
	unsigned long flags;
	(void)flags;
	//taskENTER_CRITICAL();
	
	_atomic_spin_lock_irqsave(p, flags);
	old = *p;
	*p = old | mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	//taskEXIT_CRITICAL();

	return (old & mask) != 0;
}

/**
* test_and_clear_bit - Clear a bit and return its old value
* @nr: Bit to clear
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It can be reorderdered on other architectures other than x86.
* It also implies a memory barrier.
*/
static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long old;
	unsigned long flags;
	(void)flags;
	//taskENTER_CRITICAL();
	_atomic_spin_lock_irqsave(p, flags);
	old = *p;
	*p = old & ~mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	//taskEXIT_CRITICAL();

	return (old & mask) != 0;
}
/**
* test_and_change_bit - Change a bit and return its old value
* @nr: Bit to change
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It also implies a memory barrier.
*/
static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
{
	unsigned long mask = BIT_MASK(nr);
	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
	unsigned long old;
	unsigned long flags;

	(void)flags;
	_atomic_spin_lock_irqsave(p, flags);
	old = *p;
	*p = old ^ mask;
	_atomic_spin_unlock_irqrestore(p, flags);
	

	return (old & mask) != 0;
}


static inline int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
				const unsigned long *bitmap2, int bits)
{
	int k;
	int nr = BITS_TO_LONGS(bits);
	unsigned long result = 0;

	for (k = 0; k < nr; k++)
	result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
	return result != 0;
}

static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
			const unsigned long *src2, int nbits)
{
//	if (small_const_nbits(nbits))
//		return (*dst = *src1 & ~(*src2)) != 0;
	return __bitmap_andnot(dst, src1, src2, nbits);
}

static inline int atomic_inc_return(volatile atomic_t *v)
{
         unsigned long flags;
         (void)flags;
         int retval;
         cris_atomic_save(v, flags);
         retval = ++(v->counter);
         cris_atomic_restore(v, flags);
         return retval;
}

typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64; 
typedef __u16 __sum16;
typedef __u32 __wsum;

#ifndef __GFP_WAIT
#define __GFP_WAIT             					(0x10u)
#endif
#ifndef __GFP_HIGH
#define __GFP_HIGH             					(0x20u)
#endif
#ifndef __GFP_IO
#define __GFP_IO               					(0x40u)
#endif
#ifndef __GFP_FS
#define __GFP_FS               					(0x80u)
#endif
#ifndef GFP_NOIO
#define GFP_NOIO 						(0x10u)
#endif
#ifndef __GFP_NOWARN
#define __GFP_NOWARN          					(0x200u)
#endif
#ifndef GFP_KERNEL
#define GFP_KERNEL	(__GFP_WAIT | __GFP_IO | __GFP_FS)
#endif

#ifndef copy_from_user
#define copy_from_user(to, from, sz) _memcpy((to), (from), (sz))
#endif
#ifndef copy_to_user
#define copy_to_user(to, from, sz)   _memcpy((to), (from), (sz))
#endif

#if 0 /*comment since we are not using polling*/
/* These are specified by iBCS2 */
#ifndef POLLIN 
#define POLLIN          0x0001
#endif
#ifndef POLLPRI
#define POLLPRI         0x0002
#endif
#ifndef POLLOUT
#define POLLOUT         0x0004
#endif
#ifndef POLLERR
#define POLLERR         0x0008
#endif
#ifndef POLLHUP
#define POLLHUP         0x0010
#endif
#ifndef POLLNVAL
#define POLLNVAL        0x0020
#endif 
/* The rest seem to be more-or-less nonstandard. Check them! */
#ifndef POLLRDNORM
#define POLLRDNORM      0x0040
#endif
#ifndef POLLRDBAND 
#define POLLRDBAND      0x0080
#endif
#ifndef POLLWRNORM
#define POLLWRNORM      0x0100
#endif
#ifndef POLLWRBAND
#define POLLWRBAND      0x0200
#endif
#ifndef POLLMSG
#define POLLMSG         0x0400
#endif
#ifndef POLLREMOVE
#define POLLREMOVE      0x1000
#endif
#ifndef POLLRDHUP
#define POLLRDHUP       0x2000
#endif 
#ifndef POLLFREE
#define POLLFREE        0x4000  /* currently only for epoll */
#endif
#ifndef POLL_BUSY_LOOP
#define POLL_BUSY_LOOP  0x8000
#endif
#endif

struct __wait_queue_head {
         _Sema lock;
         struct list_head        task_list;
};

typedef struct __wait_queue_head wait_queue_head_t;

static inline void __init_waitqueue_head(wait_queue_head_t *q)
{
         //spin_lock_init(&q->lock);
	 RtlInitSema(&q->lock,0);
	 INIT_LIST_HEAD(&q->task_list);
}
#ifndef init_waitqueue_head
#define init_waitqueue_head(q)      \
do {                                \
 	__init_waitqueue_head((q)); \
} while (0)
#endif
#ifndef DEFAULT_POLLMASK
#define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
#endif

#endif /*_V4L2_OSDEP_H_*/
