#if !defined(COMMON_LIST_H)
#define COMMON_LIST_H

#include "com_define.h"

/*
 * Simple doubly linked list implementation.
 *
 * Some of the internal functions ("__xxx") are useful when
 * manipulating whole lists rather than single entries, as
 * sometimes we already know the next/prev entries and we can
 * generate better code by using them directly rather than
 * using the generic single-entry routines.
 */

#ifdef NEW_LINUX_DRIVER
/* use native code */
#define List_Head           struct list_head
#define PList_Head          struct list_head *

#define MV_LIST_HEAD        LIST_HEAD
#define MV_INIT_LIST_HEAD   LIST_HEAD_INIT
#define MV_LIST_HEAD_INIT   INIT_LIST_HEAD

//#define List_Add            list_add
//#define List_AddTail        list_add_tail
//#define List_Del            list_del
#define List_DelInit        list_del_init
#define List_Move           list_move
#define List_MoveTail       list_move_tail
#define List_Empty          list_empty

#define CONTAINER_OF        container_of
#define LIST_ENTRY          list_entry
#define LIST_FOR_EACH       list_for_each
#define LIST_FOR_EACH_PREV  list_for_each_prev
#define LIST_FOR_EACH_ENTRY list_for_each_entry
#define LIST_FOR_EACH_ENTRY_PREV list_for_each_entry_prev
#define LIST_FOR_EACH_ENTRY_TYPE(ptr, list_ptr, type, entry) \
           list_for_each_entry(ptr, list_ptr, entry)

#define List_Splice         list_splice
#define List_Splice_Init    list_splice_init
#define __List_Del          __list_del  /* internal function, use with care */
#if 0

static MV_INLINE void List_Del(List_Head *entry)
{
#ifdef SUPPORT_REQUEST_TIMER
	if((entry->prev) || (entry->next))
#endif
	__List_Del(entry->prev, entry->next);
	entry->next = NULL;
	entry->prev = NULL;
}


static inline struct list_head *List_GetFirst(struct list_head *head)
{
        struct list_head * one = NULL;
        if (list_empty(head))
		return NULL;

        one = head->next;
        list_del(one);
        return one;
}

static inline struct list_head *List_GetLast(struct list_head *head)
{
        struct list_head * one = NULL;
        if (list_empty(head))
		return NULL;

        one = head->prev;
        list_del(one);
        return one;
}
#endif

#else /* _OS_LINUX */
/*
 *
 *
 * Data Structure
 *
 *
 */
typedef struct _List_Head {
	struct _List_Head *prev, *next;
} List_Head, * PList_Head;


/*
 *
 *
 * Exposed Functions
 *
 *
 */
 
#define MV_LIST_HEAD(name) \
	List_Head name = { &(name), &(name) }

#define MV_LIST_HEAD_INIT(ptr) do { \
	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

static MV_INLINE void List_Add(List_Head *new_one, List_Head *head);

static MV_INLINE void List_AddTail(List_Head *new_one, List_Head *head);

static MV_INLINE void List_Del(List_Head *entry);

static MV_INLINE void List_DelInit(List_Head *entry);

static MV_INLINE void List_Move(List_Head *list, List_Head *head);

static MV_INLINE void List_MoveTail(List_Head *list,
				  List_Head *head);

static MV_INLINE int List_Empty(const List_Head *head);


#define CONTAINER_OF(ptr, type, member) 			\
        ( (type *)( (char *)(ptr) - OFFSET_OF(type,member) ) )

#define LIST_ENTRY(ptr, type, member) \
	CONTAINER_OF(ptr, type, member)

/**
 * LIST_FOR_EACH	-	iterate over a list
 * @pos:	the &List_Head to use as a loop counter.
 * @head:	the head for your list.
 */
#define LIST_FOR_EACH(pos, head) \
	for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * LIST_FOR_EACH_PREV	-	iterate over a list backwards
 * @pos:	the &List_Head to use as a loop counter.
 * @head:	the head for your list.
 */
#define LIST_FOR_EACH_PREV(pos, head) \
	for (pos = (head)->prev; pos != (head); pos = pos->prev)

/**
 * LIST_FOR_EACH_ENTRY	-	iterate over list of given type
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define LIST_FOR_EACH_ENTRY(pos, head, member)				\
	for (pos = LIST_ENTRY((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = LIST_ENTRY(pos->member.next, typeof(*pos), member))

/**
 * LIST_FOR_EACH_ENTRY_TYPE	-	iterate over list of given type
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 * @type:	the type of the struct this is embedded in.
*/
#define LIST_FOR_EACH_ENTRY_TYPE(pos, head, type, member)       \
	for (pos = LIST_ENTRY((head)->next, type, member);	\
	     &pos->member != (head); 	                        \
	     pos = LIST_ENTRY(pos->member.next, type, member))

/**
 * LIST_FOR_EACH_ENTRY_PREV - iterate backwards over list of given type.
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define LIST_FOR_EACH_ENTRY_PREV(pos, head, member)			\
	for (pos = LIST_ENTRY((head)->prev, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = LIST_ENTRY(pos->member.prev, typeof(*pos), member))

#ifndef _OS_BIOS
#include "com_list.c"
#endif

#endif /* _OS_LINUX */

#define List_GetFirstEntry(head, type, member)	\
	LIST_ENTRY(List_GetFirst(head), type, member)

#define List_GetLastEntry(head, type, member)	\
	LIST_ENTRY(List_GetLast(head), type, member)

#endif /* COMMON_LIST_H */