Add realtek target files

Signed-off-by: Roman Yeryomin <roman@advem.lv>

1 files changed, 1254 insertions, 0 deletions

diff --git a/target/linux/realtek/files/drivers/net/rtl819x/common/mbuf.h b/target/linux/realtek/files/drivers/net/rtl819x/common/mbuf.h
new file mode 100644
index 000000000..dfe886b71
--- /dev/null
+++ b/target/linux/realtek/files/drivers/net/rtl819x/common/mbuf.h
@@ -0,0 +1,1254 @@
+
+/*
+* Copyright c                  Realtek Semiconductor Corporation, 2002
+* All rights reserved.
+*
+* Program : The mbuf module header file
+* Abstract :
+* Author : David Chun-Feng Liu (cfliu@realtek.com.tw)
+*
+*/
+#ifndef _MBUF_H_
+#define	_MBUF_H_
+
+/*********************************************************************************
+	SECTION 1:		mbuf module default settings
+**********************************************************************************/
+#define	PKT_MBUF_CLUSTER_LEN		1650
+
+#define PKT_BUF_SZ		PKT_MBUF_CLUSTER_LEN /* Size of each temporary Rx buffer.*/
+
+/*********************************************************************************
+	SECTION 2:		mbuf module data structure definitions
+**********************************************************************************/
+#define 	BUF_FREE			0x00   /* Buffer is Free  */
+#define 	BUF_USED			0x80   /* Buffer is occupied */
+#define 	BUF_ASICHOLD		0x80   /* Buffer is hold by ASIC */
+#define 	BUF_DRIVERHOLD 	0xc0   /* Buffer is hold by driver */
+
+#define 	MBUFTYPE_DATA		0x01	//not in use now. Keep for backward compatablity.
+
+/*@struct m_buf | The mbuf header associated with each cluster */
+
+struct rtl_mBuf
+{
+    struct rtl_mBuf *m_next;
+    struct rtl_pktHdr *m_pkthdr;            /* Points to the pkthdr structure */
+    uint16    m_len;                    /* data bytes used in this cluster */
+    int8      m_flags;                  /* mbuf flags; see below */
+#define MBUF_FREE            BUF_FREE   /* Free. Not occupied. should be on free list   */
+#define MBUF_USED            BUF_USED   /* Buffer is occupied */
+#define MBUF_EXT             0x10       /* has associated with an external cluster, this is always set. */
+#define MBUF_PKTHDR          0x08       /* is the 1st mbuf of this packet */
+#define MBUF_EOR             0x04       /* is the last mbuf of this packet. Set only by ASIC*/
+    uint8     *m_data;                  /*  location of data in the cluster */
+    uint8     *m_extbuf;                /* start of buffer*/
+    uint16    m_extsize;                /* sizeof the cluster */
+    int8      m_reserved[2];            /* padding */
+    void			*skb;
+};
+
+/*@struct rtl_pktHdr |  pkthdr records packet specific information. Each pkthdr is exactly 32 bytes.
+ first 20 bytes are for ASIC, the rest 12 bytes are for driver and software usage.
+ */
+struct rtl_pktHdr
+{
+    union
+    {
+        struct rtl_pktHdr *pkthdr_next;     /*  next pkthdr in free list */
+        struct rtl_mBuf *mbuf_first;        /*  1st mbuf of this pkt */
+    }PKTHDRNXT;
+#define ph_nextfree         PKTHDRNXT.pkthdr_next
+#define ph_mbuf             PKTHDRNXT.mbuf_first
+    uint16    ph_len;                   /*   total packet length */
+    uint16    ph_reserved1: 1;           /* reserved */
+    uint16    ph_queueId: 3;            /* bit 2~0: Queue ID */
+    uint16    ph_extPortList: 4;        /* dest extension port list. must be 0 for TX */
+		/* for ph_extPortList */
+		#define	PKTHDR_EXTPORT_MAGIC		0xA530
+		#define	PKTHDR_EXTPORT_MAGIC2		0xA531
+		#define	PKTHDR_EXTPORT_P1               6
+		#define	PKTHDR_EXTPORT_P2               7
+		#define	PKTHDR_EXTPORT_P3               8
+		
+		#define PKTHDR_EXTPORT_LIST_P0		0
+		#define PKTHDR_EXTPORT_LIST_P1		1
+		#define PKTHDR_EXTPORT_LIST_P2		2
+		#define PKTHDR_EXTPORT_LIST_CPU		3
+		#define PKTHDR_EXTPORTMASK_P0		(0x1 << (PKTHDR_EXTPORT_LIST_P0))
+		#define PKTHDR_EXTPORTMASK_P1		(0x1 << (PKTHDR_EXTPORT_LIST_P1))
+		#define PKTHDR_EXTPORTMASK_P2		(0x1 << (PKTHDR_EXTPORT_LIST_P2))
+		#define PKTHDR_EXTPORTMASK_CPU		(0x1 << (PKTHDR_EXTPORT_LIST_CPU))
+		#define PKTHDR_EXTPORTMASK_ALL		(	PKTHDR_EXTPORTMASK_P0 |\
+												PKTHDR_EXTPORTMASK_P1 |\
+												PKTHDR_EXTPORTMASK_P2 |\
+												PKTHDR_EXTPORTMASK_CPU \
+											)
+
+    uint16    ph_reserved2: 3;          /* reserved */
+    uint16    ph_hwFwd: 1;              /* hwFwd - copy from HSA bit 200 */
+    uint16    ph_isOriginal: 1;         /* isOriginal - DP included cpu port or more than one ext port */
+    uint16    ph_l2Trans: 1;            /* l2Trans - copy from HSA bit 129 */
+    uint16    ph_srcExtPortNum: 2;      /* Both in RX & TX. Source extension port number. */
+
+    uint16    ph_type: 3;
+#define	ph_proto				ph_type
+#define PKTHDR_ETHERNET      0
+#define PKTHDR_IP            2
+#define PKTHDR_ICMP          3
+#define PKTHDR_IGMP          4
+#define PKTHDR_TCP           5
+#define PKTHDR_UDP           6
+    uint16    ph_vlanTagged: 1;         /* the tag status after ALE */
+    uint16    ph_LLCTagged: 1;          /* the tag status after ALE */
+    uint16    ph_pppeTagged: 1;         /* the tag status after ALE */
+    uint16    ph_pppoeIdx: 3;
+    uint16    ph_linkID: 7;             /* for WLAN WDS multiple tunnel */
+    uint16    ph_reason;                /* indicates wht the packet is received by CPU */
+
+    uint16    ph_flags;                 /*  NEW:Packet header status bits */
+#define PKTHDR_FREE          (BUF_FREE << 8)        /* Free. Not occupied. should be on free list   */
+#define PKTHDR_USED          (BUF_USED << 8)
+#define PKTHDR_ASICHOLD      (BUF_ASICHOLD<<8)      /* Hold by ASIC */
+#define PKTHDR_DRIVERHOLD    (BUF_DRIVERHOLD<<8)    /* Hold by driver */
+#define PKTHDR_CPU_OWNED     0x4000
+#define PKT_INCOMING         0x1000     /* Incoming: packet is incoming */
+#define PKT_OUTGOING         0x0800     /*  Outgoing: packet is outgoing */
+#define PKT_BCAST            0x0100     /*send/received as link-level broadcast  */
+#define PKT_MCAST            0x0080     /*send/received as link-level multicast   */
+#define PKTHDR_BRIDGING      0x0040     /* when PKTHDR_HWLOOKUP is on. 1: Hardware assist to do L2 bridging only, 0:hardware assist to do NAPT*/
+#define PKTHDR_HWLOOKUP      0x0020	/* valid when ph_extPortList!=0. 1:Hardware table lookup assistance*/
+#define PKTHDR_PPPOE_AUTOADD    0x0004  /* PPPoE header auto-add */
+#define CSUM_TCPUDP_OK       0x0001     /*Incoming:TCP or UDP cksum checked */
+#define CSUM_IP_OK           0x0002     /* Incoming: IP header cksum has checked */
+#define CSUM_TCPUDP          0x0001     /*Outgoing:TCP or UDP cksum offload to ASIC*/
+#define CSUM_IP              0x0002     /* Outgoing: IP header cksum offload to ASIC*/
+
+   uint8      ph_orgtos;                /* RX: original TOS of IP header's value before remarking, TX: undefined */
+   uint8      ph_portlist;              /* RX: source port number, TX: destination portmask */
+
+   uint16     ph_vlanId_resv: 1;
+   uint16     ph_txPriority: 3;
+   uint16     ph_vlanId: 12;
+  // uint16     ph_flags2;
+	union
+	{
+		uint16	_flags2;			/* RX: bit 15: Reserved, bit14~12: Original Priority, bit 11~0: Original VLAN ID */
+								/* TX: bit 15~6: Reserved, bit 5~0: Per Port Tag mask setting for TX(bit 5:MII, bit 4~0: Physical Port) */
+		struct
+		{
+			/* RX: bit 15: Reserved, bit14~12: Original Priority, bit 11~0: Original VLAN ID */
+			uint16 _reserved:1;
+			uint16 _rxPktPriority:3;		/* Rx packet's original priority */
+			uint16 _svlanId:12;			/* Source (Original) VLAN ID */
+		} _rx;
+
+		struct
+		{
+			/* TX: bit 15~6: Reserved, bit 5~0: Per Port Tag mask setting for TX(bit 5:MII, bit 4~0: Physical Port) */
+			uint16 _reserved:10;
+			uint16 _txCVlanTagAutoAdd:6;	/* BitMask to indicate the port which would need to add VLAN tag */
+		} _tx;
+	} _flags2;
+	#define ph_dvlanId		ph_vlanId
+	#define ph_rxPriority		ph_txPriority
+
+	#define PKTHDR_TXPRIORITY_MIN			0
+	#define PKTHDR_TXPRIORITY_MAX			7
+
+	#define ph_flags2				_flags2._flags2
+	#define ph_svlanId				_flags2._rx._svlanId
+	#define ph_rxPktPriority			_flags2._rx._rxPktPriority
+	#define ph_txCVlanTagAutoAdd	_flags2._tx._txCVlanTagAutoAdd
+
+	#define PKTHDR_TXCVID(vid)					(vid & 0xfff)
+	#define PKTHDR_VLAN_P0_AUTOADD			(0x0001<<0)
+	#define PKTHDR_VLAN_P1_AUTOADD			(0x0001<<1)
+	#define PKTHDR_VLAN_P2_AUTOADD			(0x0001<<2)
+	#define PKTHDR_VLAN_P3_AUTOADD			(0x0001<<3)
+	#define PKTHDR_VLAN_P4_AUTOADD			(0x0001<<4)
+	#define PKTHDR_VLAN_P5_AUTOADD			(0x0001<<5)
+	#define PKTHDR_VLAN_AUTOADD				(	(PKTHDR_VLAN_P0_AUTOADD)|	\
+												(PKTHDR_VLAN_P1_AUTOADD)|	\
+												(PKTHDR_VLAN_P2_AUTOADD)|	\
+												(PKTHDR_VLAN_P3_AUTOADD)|	\
+												(PKTHDR_VLAN_P4_AUTOADD)|	\
+												(PKTHDR_VLAN_P5_AUTOADD)	)
+
+};
+
+	//property for ph_unnumber		: cw_du 
+	#define PHUNNUMBER_SRCGLOBEIP			0x01
+	#define PHUNNUMBER_DIRECTION			0x02		// 1 : WAN->LAN; 	0: LAN->WAN
+	#define PHUNNUMBER_UNNUMBEREDSRCIP	0x04
+	#define PHUNNUMBER_ADVRTMATCHED		0x08
+
+
+	#define PHUNNUMBER_ALLBITS				0xff
+
+	
+	#define PKTHDR_PHUNNUMBER_SET(pkthdrPtr, property) \
+		do{\
+			assert(pkthdrPtr);\
+			pkthdrPtr->ph_unnumber |=property;\
+		}while(0)
+
+	#define PKTHDR_PHUNNUMBER_CLR(pkthdrPtr, property) \
+		do{\
+			assert(pkthdrPtr);\
+			pkthdrPtr->ph_unnumber &= ~property;\
+		}while(0)
+
+	#define PKTHDR_PHUNNUMBER_TEST(pkthdrPtr, property) 	((pkthdrPtr->ph_unnumber & property) ? 1: 0)
+	
+
+
+
+
+
+struct rtl_mBufStatus
+{
+	uint32 	m_totalmbufs;	//Total mbufs allocated during initialization
+	uint32	m_totalclusters;	//Total clusters allocated during initialization
+	uint32	m_totalpkthdrs;	//Total pkthdrs allocated during initialization
+	uint32    m_freembufs;	/* free mbufs in pool now*/
+	uint32    m_freeclusters;	/* free clusters in  pool now*/
+	uint32	m_freepkthdrs;	/* free pkthdrs in pool now*/
+	uint32    m_msize;		/* length of an mbuf */
+	uint32    m_mclbytes;		/* length of an mbuf cluster */
+	uint32 	m_pkthdrsize;	/* length of an pkthdr */
+
+	uint32    m_wait;			/* times waited for space, includes mbuf, pkthdr and cluster */
+};
+
+
+/*********************************************************************************
+	SECTION 3:		mbuf module exported variables, symbols and macros
+**********************************************************************************/
+#define	MBUF_COPYALL		1000000000	   /* length for m_copy to copy all */
+#define	MBUF_WAITOK		0x01
+#define	MBUF_DONTWAIT	0x02	   /* Don't wait if there is no buffer available */
+#define	MBUF_ONLY	0x04	   /* Don't allocate a cluster in mBuf_get */
+#define	MBUF_ALLOCPKTHDR	0x08	   /* Allocate a packet header with mbuf chain in mBuf_getm, mBuf_cloneMbufChain, mBuf_dupMbufChain*/
+#define	MBUF_GETNEWMBUF 0x10		   /* In mBuf_prepend, alloate new mbufs directly */
+#define MBUF_CHECKPKTHDR(m)	((m)&&(ISSET((m)->m_flags, MBUF_USED) && ((m)->m_pkthdr))?1:0)
+#define MBUF_GETPKTHDRFIELD16(field)  (*((uint16 *)(field)))
+#define MBUF_SETPKTHDRFIELD16(field, value)	*((uint16 *)(field)) = (value)
+
+//The size of each cluster.
+extern int32 m_clusterSize;
+
+/*********************************************************************************
+	SECTION 4:		mbuf module exported API prototype
+**********************************************************************************/
+
+/* mbuf module exported APIs */
+
+/*	@doc MBUF_API
+
+	@module mbuf.h - Mbuf module API documentation	|
+	This document illustrates the API interface of the mbuf module.
+	@normal Chun-Feng Liu (cfliu@realtek.com.tw) <date>
+
+	Copyright <cp>2001 Realtek<tm> Semiconductor Cooperation, All Rights Reserved.
+
+ 	@head3 List of Symbols |
+ 	Here is a list of all functions and variables in this module.
+
+ 	@index | MBUF_API
+*/
+extern int32 mBuf_init(uint32, uint32, uint32, uint32, uint32);			   //was tunable_mbinit()
+#if defined(RTL865X_TEST)||defined(RTL865X_MODEL_USER)
+extern int32 mBuf_Reinit(void);
+#endif /* RTL865X_TEST */
+/*
+@func void	| mBuf_init	| mbuf module initialization
+@parm uint32 	| mbufs		| Number of mbufs
+@parm uint32 	| clusters	| Number of clusters
+@parm uint32 	| pkthdrs		| Number of packet headers
+@parm uint32		| clusterSize	| Size of each cluster. must be power of 2
+@parm uint32		| msgLogId	| Debuging message log list id
+@rdesc None
+@rvalue SUCCESS		| 	The mbuf module and its memory pool is initiated as requested
+@rvalue FAILED	| 	Failed to initialize the mbuf module.
+@comm mbuf module initialization. Allocate mbuf and related structure pools. Value for <p clusterSize> must be power of 2. 
+If <p clusters> is 0, clusters would be allocated externally through registered OS buffer allocation glue function. If clusters
+are allocated this way, MBUF_WAITOK flag can't be used for mBuf_get, mBuf_getm, mBuf_dupMbufChain, mBuf_dupPacket since
+mbuf module knows nothing about external cluter pool managed by OS hence doesn't know when to wakeup waiting threads.
+ */
+
+
+extern int32 mBuf_getBufStat(struct rtl_mBufStatus *mbs);
+/*
+@func  int32	| mBuf_getBufStat	| Returns current status of the mbuf module
+@parm struct rtl_mBufStatus *	| mbs	| A pointer to the mbstat structure for mBuf_getBufStat() to fill in
+@rdesc Returns current status of the mbuf module
+@rvalue <p FAILED>	| 	Failed to get mbuf module status. Maybe mbs is NULL or mbuf module not yet initiated.
+@rvalue <p SUCCESS>	| 	Mbuf module status is returned with the mbstat structure given.
+ */
+
+
+
+extern int32 mBuf_leadingSpace(struct rtl_mBuf *m);
+
+/*
+@func int32	| mBuf_leadingSpace	| Calculate the number of leading free data bytes.
+@parm struct rtl_mBuf * 	| m		| Pointer to the mbuf chain.
+@rdesc Returns the number of free leading space
+@rvalue n		| 	The number of free leading data bytes in cluster.
+@comm
+Calculate the number of leading free data bytes.
+@xref  <c mBuf_trailingSpace>
+
+ */
+
+
+extern int32 mBuf_trailingSpace(struct rtl_mBuf *m);
+
+/*
+@func int32	| mBuf_trailingSpace	| Calculate the number of trailing free data bytes.
+@parm struct rtl_mBuf * 	| m		| Pointer to the mbuf chain.
+@rdesc Returns the number of free trailing space
+@rvalue n		| 	The number of free trailing data bytes in cluster.
+@comm
+Calculate the number of trailing free data bytes.
+@xref <c mBuf_leadingSpace>
+
+ */
+
+
+extern int32 mBuf_clusterIsWritable(struct rtl_mBuf *m);
+
+/*
+@func int32	| mBuf_clusterIsWritable	| Determine whether <p m>'s cluster is writable or not.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf.
+@rdesc Returns TRUE or FALSE
+@rvalue TRUE		| 	The cluster is writable.
+@rvalue FALSE	| 	The cluster is not writable.
+@comm
+Determine whether <p m>'s cluster is writable or not. New mbufs allocated due to mBuf_clonePacket, mBuf_split, mBuf_cloneMbufChain
+should not modify its cluster becoz it is not the owner of these clusters. This function always return TRUE if the 'clusters' parameter 
+during mBuf_init() was initialized to 0.
+
+ */
+
+extern   uint32 mBuf_getPktlen(struct rtl_mBuf *m);
+/*
+@func uint32	| mBuf_getPktlen	| Get total number of data bytes in the packet which <p m> belongs to
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@rdesc Returns data length of the packet
+@rvalue -1		| 	Failed.
+@rvalue <p length>| 	The actual length of  packet
+@comm
+Get total number of data bytes in the packet which <p m> belongs to
+@xref <c MBUF_GETLEN>
+*/
+
+extern struct rtl_mBuf *mBuf_data2Mbuf(int8 * x);  //was dtom
+
+/*
+@func struct rtl_mBuf *	| mBuf_data2Mbuf	| Given data address <p x>, return mbuf address <p m>
+@parm int8  * 	|x		| Data address
+@rdesc Returns mbuf address <p m> which owns the cluster block where <p x> resides.
+@rvalue <p NULL>		| 	Can't find the address. The data address <p x> given might be within a zombie cluster whose owning mbuf has already been freed.
+@rvalue <p m>		| 	The address of owning mbuf
+@comm
+Finds the mbuf address of given data address <p x>
+This function can't be called if the 'clusters' parameter during mBuf_init() was initialized to 0.
+@devnote  Original BSD code define this as a dtom macro. In our implmentation, we make it a function.
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+
+	n = mBuf_data2Mbuf(x);
+	if (n != NULL) {
+		printf("There are %d bytes in the cluster", n->m_len);
+	}
+  @xref  <c MBUF2DATAPTR>
+*/
+
+
+
+extern struct rtl_mBuf *mBuf_get(int32 how, int32 unused, uint32 Nbuf);
+
+/*
+@func struct rtl_mBuf *	| mBuf_get	| mbuf space allocation routines.
+@parm int32			| how	| <p MBUF_WAITOK>, <p MBUF_DONTWAIT>, and/or <p MBUF_ONLY>
+@parm int32			| unused	| unused now. Keep for backward compatibility.
+@parm uint32 			| Nbuf	| The number of mbufs requesting.
+
+@rdesc Returns the address of allocated mbuf head
+@rvalue <p NULL>		| 	Can't allocate all  <p Nbuf>s at once.
+@rvalue <p n>		| 	The address of first mbuf allocated. All <p Nbuf>s have been linked together.
+@comm
+Get <p Nbuf> mbufs and clusters. All mbufs are chained via the <p m_next> pointer inside each mbuf. Note that memory content in all allocated clusters are NOT initialized.
+
+If <p how> has MBUF_DONTWAIT bit set, and we can't get all <p Nbuf>s immediately, return NULL.
+
+If <p how> has MBUF_WAITOK bit set, and we can't get all <p Nbuf>s right away, block waiting until our request is satisfied
+
+If <p how> has MBUF_ONLY bit set, then no clusters would be allocated. Only mbufs are allocated. Can be used with MBUF_DONTWAIT or MBUF_WAITOK
+
+@devnote
+1.Side effect: <p mBuf_get> wakes up any sleeping threads if they are block waiting for free mbufs or clusters.
+2. If the 'clusters' parameter during mBuf_init() was initialized to 0, mBuf_get doesn't accept MBUF_ONLY flag
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *m;
+	m= mBuf_get( MBUF_DONTWAIT, 0, 5);  //allocate 5 mbufs and clusters without blocking.
+	if (!m)
+		return NULL;
+
+  @xref
+  <c mBuf_getCleared> ,  <c mBuf_getm>, <c mBuf_driverGet>
+ */
+
+
+extern struct rtl_mBuf *mBuf_getCleared(int32 how, int32 unused, uint32 Nbuf);
+
+/*
+@func struct rtl_mBuf *	| mBuf_getCleared| Same as mBuf_get, but initialize all clusters to zero.
+@parm int32			|how	| <p MBUF_WAIT>, <p MBUF_DONTWAIT> and/or <p MBUF_ONLY>
+@parm int32			|unused	| unused now. Keep for backward compatibility.
+@parm uint32 			| Nbuf	| The number of mbufs requesting.
+
+@rdesc Returns the address of allocated mbuf head
+@rvalue <p NULL>		| 	Can't allocate all  <p Nbuf>s at once.
+@rvalue <p n>		| 	The address of first mbuf allocated. All <p Nbuf>s have been linked together and cleared to 0.
+@comm
+Same as <p mget>(). However, content in all mbufs and clusters have been cleared to 0.
+@ex The following example demonstrates how to use this function |
+	register struct rtl_mBuf *m;
+	m= mBuf_getCleared(MBUF_DONTWAIT | MBUF_ONLY, 0, 5);  //allocate 5  mbufs without blocking.
+	if (!m)
+		return NULL;
+
+  @xref
+  <c mBuf_get>,  <c mBuf_getm>, <c mBuf_driverGet>
+ */
+
+
+extern uint32 mBuf_driverGet(uint32 Nmbuf,struct rtl_mBuf **ppFirstMbuf, struct rtl_mBuf **ppLastMbuf);
+/*
+@func uint32	| mBuf_driverGet| Driver specific. Get multiple mbufs without blocking
+@parm uint32	|Nmbuf	| Number of mbufs requesting
+@parm struct rtl_mBuf **	|ppFirstMbuf	| Returns a pointer which points to  the first mbuf allocated.
+@parm struct rtl_mBuf **	| ppLastMbuf	| Returns a pointer which points to  the last mbuf allocated.
+@rdesc Returns number of mbufs successfully allocated.
+@comm
+An optimized mBuf_get() for driver. <p ppFirstMbuf> and <p ppLastMbuf> should not be NULL!!
+mbuf and cluster not initialized to zero. Only required fields in mBuf_driverGet have been properly filled.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf * localTempMbufHead,  * localTempMbufTail;
+	int32 allocated;
+	requested = 5;
+	allocated= mBuf_driverGet(requested, &localTempMbufHead, &localTempMbufTail);
+	if (allocated!=requested)
+		printf("Can't allocate all 5 mbufs in driver\n")
+
+  @xref
+  <c mBuf_get>,  <c mBuf_getm>, <c mBuf_getCleared>
+ */
+
+extern struct rtl_mBuf *mBuf_getm(struct rtl_mBuf *m, uint32 len, int32 how, int32 unused);
+
+/*
+@func struct rtl_mBuf *	| mBuf_getm| allocate <p len>-worth of  mbuf clusters and return a pointer to the top
+of the allocated chain.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain. Could be NULL.
+@parm uint32			|len		| Number of data bytes requesting.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT> and/or <p M_ALLOCPKTHDR>.
+@parm int32			|unused	| unused now. Keep for backward compatibility.
+@rdesc Returns return a pointer to the head of the allocated chain.
+@rvalue <p NULL>		| 	Allocation failed.
+@rvalue <p n>		| 	The memory address of first mbuf allocated.
+@comm
+If <p m> is non-null, then it is an mbuf chain to which we want <p len> bytes worth of clusters and their associating mbufs be attached, and so
+if allocation is successful, a pointer to m is returned. i.e <p n> = <p m>)
+
+If <p m> is null,  <p len> bytes worth of clusters and their associating mbufs would be allocated.
+
+If <p how> has M_ALLOCPKTHDR bit set, <p mBuf_getm> also allocates a pkthdr with the mbuf chain.
+If <p how> has MBUF_DONTWAIT bit set, and we can't get a pkthdr immediately, return NULL.
+If <p how> has MBUF_WAITOK bit set, and we can't get a pkthdr right away, block waiting until our request is satisfied.
+
+M_BUFONLY can't be used with mBuf_getm, in this case, you should use mBuf_get() and calculate how many mbufs you need on your own.
+
+@ex The following example demonstrates how to use this function |
+	m = mBuf_getm(m, size, MBUF_WAITOK, 0);
+	if (m == NULL)
+		return ENOBUFS;
+
+  @xref
+  <c mBuf_get> , <c mBuf_driverGet>, <c mBuf_getCleared>
+ */
+
+
+extern struct rtl_mBuf *mBuf_getPkthdr(struct rtl_mBuf *m, int32 how);
+/*
+@func struct rtl_mBuf *	| mBuf_getPkthdr| Allocate a packet header for mbuf chain <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to the mbuf chain.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT>
+
+@rdesc Returns the address of mbuf <p m> that holds a packet header.
+@rvalue <p NULL>		| 	Can't allocate a  pkthdr for mbuf <p m>.
+@rvalue <p m>		| 	A pkthdr is allocated to mbuf <p m>.
+@comm
+
+Given an mbuf <p m>, allocate a packet header (pkthdr) structure for <p m> and makes <p m> the owner of this pkthdr.
+If there is already a pkthdr owned by some mbuf after m on the same mbuf chain, m becomes the owner of that pkthdr without getting a new one. Corresponding pkthdr fields are modified accordingly.
+
+If <p how> has MBUF_DONTWAIT bit set, and we can't get a pkthdr immediately, return NULL.
+If <p how> has MBUF_WAITOK bit set, and we can't get a pkthdr right away, block waiting until our request is satisfied.
+
+
+ mBuf_getPkthdr may wake up other sleeping threads waiting for pkthdrs if any
+
+@ex The following example demonstrates how to use this function |
+	if (!mBuf_getPkthdr(pNewMbuf, MBUF_DONTWAIT))	//get a pkthdr
+		goto nospace;
+  @xref
+  <c mBuf_driverGetPkthdr>
+ */
+
+extern uint32 mBuf_driverGetPkthdr(uint32 Npkthdr,struct rtl_pktHdr **ppHeadPkthdr, struct rtl_pktHdr **ppTailPkthdr);
+/*
+@func uint32	| mBuf_driverGetPkthdr| Driver specific. Get multiple pkthdrs without blocking
+@parm uint32	|Npkthdr	| Number of pkthdrs requesting
+@parm struct rtl_pktHdr **	|ppHeadPkthdr	| Returns a pointer which points to  the first pkthdr allocated.
+@parm struct rtl_pktHdr **	| ppTailPkthdr	| Returns a pointer which points to  the last pkthdr allocated.
+@rdesc Returns number of pkthdrs successfully allocated.
+@comm
+This function is dedicated for driver.  <p ppHeadPkthdr> and <p ppTailPkthdr> should not be NULL!!
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_pktHdr * localTempPkthdrHead,  * localTempPkthdrTail;
+	int32 allocated;
+	requested = 5;
+	allocated= mBuf_driverGetPkthdr(requested, &localTempPkthdrHead, &localTempPkthdrTail);
+	if (allocated!=requested)
+		printf("Can't allocate all 5 mbufs in driver\n")
+
+  @xref
+  <c mBuf_getPkthdr>
+ */
+
+
+extern void mBuf_freeMbuf(struct rtl_mBuf *m);
+/*
+@func struct rtl_mBuf *	| mBuf_freeMbuf	| Free a single mbuf <p m>..
+@parm struct rtl_mBuf * 	| m		|  Pointer to an mbuf chain.
+@rdesc None
+@comm
+ Free a single mbuf. Leave assocated pkthdr or cluster, if any, intact.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+	mBuf_freeMbuf(m);
+@xref
+  <c mBuf_freeMbufChain> , <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>, <c mBuf_driverFreePkthdr>
+ */
+
+
+extern int32 mBuf_attachCluster(struct rtl_mBuf *m, void *buffer, uint32 id, uint32 size, uint16 datalen, uint16 align);
+/*
+@func struct rtl_mBuf *	| mBuf_attachCluster	| Attach a cluster to mbuf <p m>
+@parm struct rtl_mBuf * 	| m		|  Pointer to an mbuf chain.
+@parm void * 	| buffer	|  Address of cluster to be associated with mbuf <p m>.
+@parm uint32 	| id		| Identifier of cluster to be associated with mbuf <p m>.
+@parm uint32  	| size	|  Size of cluster to be associated with mbuf <p m>.
+@parm uint32  	| datalen	|  Byte count of data already in packet.
+@parm uint16  	| align	|  byte offset of first data byte in cluster <p buffer>,if any,from which <p m> attaches to. Default is 0.
+@rvalue <p SUCCESS>		| 	cluster has been successfully attached with mbuf <p m>.
+@rvalue <p FAILED>		| 	Failed to attach cluster with mbuf <p m>
+@comm
+Attach a cluster to mbuf <p m>. If there is already a cluster attached with mbuf <p m>, return FAILED.
+If <p align> is non-zero, mbuf <p m> sets it's data pointer from which <p m>'s data pointer attaches.
+@xref
+  <c mBuf_get> , <c mBuf_driverGetMbufChain>, <c mBuf_GetPkthdr>, <c mBuf_getm>
+ */
+
+
+extern int32 mBuf_freeOneMbufPkthdr(struct rtl_mBuf *m, void **buffer, uint32 *id, uint16 *size);
+/*
+@func struct int32	| mBuf_freeOneMbufPkthdr	| Free a single mbuf <p m> and associated pkthdr, if any. Returns information of cluster associated.
+@parm struct rtl_mBuf * 	| m		|  Pointer to an mbuf chain.
+@parm void * 	| buffer	|  placeholder for address of cluster associated on return.
+@parm void * 	| id		|  placeholder of identifier of cluster associated on return.
+@parm uint16 * 	| size	|  placeholder of size of cluster associated on return.
+@rdesc Returns number of mbufs being freed
+@rvalue <p n>		| 	number of mbufs being freed
+@comm
+ Free a single mbuf and associated pkthdr, if any. Place the successor, if any, in <p n>.
+ Note that this function DOES NOT free the associated cluster. 
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+	void *buffer ;
+	uint32 size, id;
+	n = mBuf_freeOne(m,&buffer,&id, &size);
+
+@xref
+  <c mBuf_freeMbufChain> , <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>, <c mBuf_driverFreePkthdr>, <c mBuf_freeOne>
+ */
+
+
+extern struct rtl_mBuf *mBuf_freeOne(struct rtl_mBuf *m);
+
+/*
+@func struct rtl_mBuf *	| mBuf_freeOne	| Free a single mbuf <p m> and associated cluster storage.
+@parm struct rtl_mBuf * 	| m		|  Pointer to an mbuf chain.
+@rdesc Returns address of next mbuf if any
+@rvalue <p NULL>		| 	<p m> has been freed and there isn't any successing mbufs.
+@rvalue <p n>		| 	The address of next mbuf after <p m>.
+@comm
+ Free a single mbuf and associated external storage. Place the successor, if any, in <p n>.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+	n = mBuf_freeOne(m);
+
+@xref
+  <c mBuf_freeMbufChain> , <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>, <c mBuf_driverFreePkthdr>
+ */
+
+extern uint32 mBuf_freeMbufChain(register struct rtl_mBuf *m);
+
+/*
+@func struct rtl_mBuf *	| mBuf_freeMbufChain| Free the whole mbuf chain started from <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to the mbuf chain.
+@rdesc Returns number of mbufs being freed in mbuf chain <p m>.
+@rvalue <p n>		| 	The number of mbufs being freed. If <p n> is 0, <p m> is not freed.
+@comm
+ Free the whole mbuf chain starting from <p m>.
+
+@devnote  Return type changed from void to int32 to provide more information.
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *m;
+	int32 n;
+	m = mBuf_get(MBUF_DONTWAIT, 0, 5);
+	n = mBuf_freeMbufChain(m);
+	if (n!=5){
+		//Do error handling...
+	}
+@xref
+  <c mBuf_freeOne> , <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>, <c mBuf_driverFreePkthdr>
+ */
+
+extern uint32 mBuf_driverFreeMbufChain(struct rtl_mBuf *pFirstMbuf);
+/*
+@func uint32	| mBuf_driverFreeMbufChain| Free the whole mbuf chain started from <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to the mbuf chain.
+@rdesc Returns number of mbufs being freed in mbuf chain <p m>.
+@rvalue <p n>		| 	The number of mbufs being freed. If <p n> is 0, <p m> is not freed.
+@comm
+ Free the whole mbuf chain starting from <p m>.  To be used only in driver.
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf * localTempMbufHead,  * localTempMbufTail;
+	int32 allocated;
+	requested = 5;
+	allocated= mBuf_driverGet(requested, &localTempMbufHead, &localTempMbufTail);
+	if (allocated==requested){
+		n = mBuf_driverFreeMbufChain(localTempMbufHead);
+		if(n==allocated)
+			printf("All mbufs successfully freed in driver\n");
+	}
+@xref
+  <c mBuf_freeOne> , <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>, <c mBuf_driverFreePkthdr>
+ */
+
+
+
+extern void mBuf_freePkthdr(struct rtl_pktHdr *ph);
+/*
+@func struct rtl_pktHdr *	| mBuf_freePkthdr| Free a pkthdr alone.
+@parm struct rtl_pktHdr *	|ph	| The pkthdr to be freed.
+@rdesc No return value
+@comm  Free a pkthdr alone. Callers should be aware that this is NOT the normal way to free a pkthdr with mbufs attached.
+You should use <p mBuf_freeOne> or <p mBuf_freeMbufChain> to free pkthdrs attached with mbuf chains. This function is usd once only in TCP module.
+@devnote
+Caller of this function should remove the links between mbufs and pkthdrs on their own before <p mBuf_freePkthdr> is called.
+@xref  <c mBuf_freeOne> , <c mBuf_freeMbufChain>, <c mBuf_driverFreeMbufChain>, <c mBuf_driverFreePkthdr>
+ */
+
+uint32 mBuf_driverFreePkthdr(struct rtl_pktHdr *ph, uint32 Npkthdr, struct rtl_pktHdr **ppHeadPkthdr);
+/*
+@func uint32	| mBuf_driverFreePkthdr| Driver specific. Free multiple pkthdrs without blocking
+@parm struct rtl_pktHdr *	|ph	| The first pkthdr to be freed
+@parm uint32	|Npkthdr	| Number of pkthdrs to be freed
+@parm struct rtl_pktHdr **	|ppHeadPkthdr	| Returns next un-freed pkthdr, if any.
+@rdesc Returns number of pkthdrs successfully freed.
+@comm
+This function is dedicated for driver.  <p ph> should not be NULL!!
+
+ @xref
+   <c mBuf_freeOne> , <c mBuf_freeMbufChain>, <c mBuf_driverFreeMbufChain>, <c mBuf_freePkthdr>
+ */
+
+extern struct rtl_mBuf *mBuf_adjHead(struct rtl_mBuf *, uint32 req_len);
+/*
+@func struct rtl_mBuf *	| mBuf_adjHead	| Remove <p req_len> bytes of data from head the mbuf chain pointed to by <p m>.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain. <p m> doesn't need to be the first mbuf in chain.
+@parm int32			| req_len	| Number of data bytes to be removed
+@rdesc m_adj returns the address of first mbuf after trimming data.
+@rvalue <p NULL>	| 	Can't adjust length of mbuf. <p m> might 1)be NULL 2)have no clusters.
+@rvalue <p m>		| 	When success, the first mbuf <p m> where user can read/write data is returned.
+@comm
+Remove <p req_len> bytes of data from the head of mbuf chain  <p m>. If user removed all
+data bytes in the whole packet, <p m> is returned.
+
+@devnote  If any clusters, after m_adj, is totally unused (ie. m_len=0),
+the m_data pointer would be reset to m_extbuf and the mbuf would NOT be freed.
+
+@xref
+  <c mBuf_adjTail>,   <c mBuf_trimHead>,  <c mBuf_trimTail>
+ */
+
+extern struct rtl_mBuf *mBuf_adjTail(struct rtl_mBuf *, uint32 req_len);
+/*
+@func struct rtl_mBuf *	| mBuf_adjTail	| Remove <p req_len> bytes of data from tail of the mbuf chain pointed to by <p m>.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain. <p m> doesn't need to be the first mbuf in chain.
+@parm int32			| req_len	| Number of data bytes to be removed
+@rdesc m_adj returns the address of mbuf which contains the last data byte.
+@rvalue <p NULL>	| 	Can't adjust length of mbuf. <p m> might 1)be NULL 2)have no clusters or <p req_len> is 0
+@rvalue <p m>		| 	When success, the address of the mbuf which hold the last data byte is returned.
+@comm
+Remove <p req_len> bytes of data from the tail of mbuf chain  <p m>. If user removed all
+data bytes in the whole packet, <p m> is returned.
+
+@devnote  If any clusters, after m_adj, is totally unused (ie. m_len=0),
+the m_data pointer would be reset to m_extbuf and the mbuf would NOT be freed.
+
+@xref
+  <c mBuf_adjHead>,   <c mBuf_trimHead>,  <c mBuf_trimTail>
+ */
+
+extern struct rtl_mBuf *mBuf_trimHead(struct rtl_mBuf *, uint32 req_len);
+/*
+@func struct rtl_mBuf *	| mBuf_trimHead	| Same as mBuf_adjHead, but also frees unused mbufs and clusters
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain. <p m> doesn't need to be the first mbuf in chain.
+@parm int32			| req_len	| Number of data bytes to be trimmed from head.
+@rdesc mBuf_trimHead returns the address of first mbuf after trimming.
+@rvalue <p NULL>	| 	Can't adjust length of mbuf or the whole mbuf chain is trimmed and freed.
+@rvalue <p m>		| 	When success, the first mbuf <p m> where user can read/write data is returned.
+@comm
+Same as mBuf_adjHead, but also frees unused mbufs and clusters
+
+@devnote  mBuf_trimHead is implemented with mBuf_split and mBuf_freeMbufChain. It first splits the mbuf
+to two mbuf chains from indicated position and frees the first one.
+There is a possible risk that mBuf_trimHead may fail when the mbuf chain <p m> consumes all mbufs and no free mbufs
+is available for mBuf_split to work correctly.
+
+@xref
+  <c mBuf_adjHead>,   <c mBuf_adjTail>,  <c mBuf_trimTail>
+ */
+
+extern struct rtl_mBuf *mBuf_trimTail(struct rtl_mBuf *, uint32 req_len);
+/*
+@func struct rtl_mBuf *	| mBuf_trimTail	| Same as mBuf_adjTail, but also frees unused mbufs and clusters
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain. <p m> doesn't need to be the first mbuf in chain.
+@parm int32			| req_len	| Number of data bytes to be trimmed from tail.
+@rdesc mBuf_trimTail returns the address <p m>.
+@rvalue <p NULL>	| 	Can't adjust length of mbuf or the whole mbuf chain is trimmed and freed.
+@rvalue <p m>		| 	When success, returns the first mbuf <p m> with data.
+@comm
+Same as mBuf_adjTail, but also frees unused mbufs and clusters
+
+@devnote  mBuf_trimTail is implemented with mBuf_split and mBuf_freeMbufChain. It first splits the mbuf
+to two mbuf chains from indicated position and frees the latter one.
+There is a possible risk that mBuf_trimTail may fail when the mbuf chain <p m> consumes all mbufs and no free mbufs
+is available for mBuf_split to work correctly.
+
+@xref
+  <c mBuf_adjHead>,   <c mBuf_adjTail>,  <c mBuf_trimTail>
+*/
+
+
+
+extern int32 mBuf_copyToMbuf(struct rtl_mBuf *, uint32 offset, uint32 len, int8 *cp);
+
+/*
+@func int32			| mBuf_copyToMbuf	| Copy <p len> bytes of data from user's buffer <p cp> to mbuf chain <p m>, started form offset <p offset>.
+@parm struct rtl_mBuf * 	| m		| Address of the mbuf chain.
+@parm uint32			|offset	| Starting byte to be copied in mbuf chain <p m>. Start from 0
+@parm uint32			|len		| Number of bytes to be copied from <p cp>
+@parm int8 * 		|cp		| Address of user's buffer.
+@rdesc Returns number of bytes successfully copied
+@rvalue <p -1>		| 	Failed.
+@rvalue <p n>		| 	<p n> bytes have been copied from <p cp> into indicated mbuf chain <p m>
+@comm
+Copy <p len> bytes from user's buffer <p cp>, to the indicated mbuf chain
+<p m> beginning from the <p offset>-th data byte in mbuf chain.
+If there aren't at least 'offset' bytes in mbuf chain, -1 is returned.
+mBuf_copyToMbuf() extends mbuf chain if neccessary.
+@comm 
+Be careful, when clusters are allocated externally by OS, mbuf module doesn't know which mbuf
+is the first referee and owns the write priviledge to cluster. Therefore, write priviledge
+is granted to ALL cluster referees.
+
+@ex The following example demonstrates how to use this function |
+	#define SIZE	100
+	int32 i;
+	int8 my_buffer[SIZE];
+	for(i=0; i<SIZE; i++)
+		my_buffer[i] = i;
+	if (100!=mBuf_copyToMbuf(m, 10, 100, my_buffer))	//copy 100 bytes from my_buffer to mbuf m, started from the 10th bytes in mbuf
+		printf("Can't copy all data!");
+  @xref
+  <c mBuf_copyToUserBuffer>
+ */
+
+
+
+extern int32 mBuf_copyToUserBuffer(struct rtl_mBuf *m, uint32 off, uint32 len, int8 * cp);
+
+/*
+@func int32			| mBuf_copyToUserBuffer	| Copy some data from an mbuf chain <p m> to user's buffer <p cp>.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm uint32			|offset	| The number of starting data byte in mbuf chain <p m>. Start from 0.
+@parm uint32			|len		| The number of data bytes to be copied. If <p len>=M_COPYALL, then copy all data till the end of mbuf chain.
+@parm int8 *			|cp		| User specified buffer address.
+@rdesc Returns number of bytes successfully received and copied to user's buffer
+@rvalue <p -1>		| 	Failed.
+@rvalue <p n>		| 	<p n> bytes have been copied from <p m> into indicated buffer <p cp> successfully.
+@comm
+Copy data from an mbuf chain starting from the <p offset>-th data byte,
+continuing for <p len> bytes, into the indicated buffer <p cp>. User should be sure that there is enough free space in
+the specified buffer <p cp>.
+
+@ex The following example demonstrates how to use this function |
+	int8 my_buffer[100];
+	mBuf_copyToUserBuffer(m, 10, 100, my_buffer); //copy 100 bytes from the 10-th byte in mbuf to user's cp buffer.
+
+  @xref
+  <c mBuf_copyToMbuf>
+ */
+
+extern struct rtl_mBuf *mBuf_cloneMbufChain(struct rtl_mBuf *pThisMbuf, int32 iOffset,
+							int32 iLength, int32 iWait);
+
+/*
+@func struct rtl_mBuf *	| mBuf_cloneMbufChain	| Clone a part of mbuf chain <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm int32			|offset	| The number of starting data byte in mbuf chain <p m>. Start from 0
+@parm int32			|len		| The number of data bytes to be cloned. If <p len>=M_COPYALL, then clone all data till the end of mbuf chain.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT> and/or <p M_ALLOCPKTHDR>
+@rdesc Returns address of the new, cloned mbuf chain <p n>.
+@rvalue <p NULL>		| 	Can't clone mbuf chain <p m>.
+@rvalue <p n>		| 	The address of cloned mbuf chain <p n>. Data in <p n> is read only.
+@comm
+Make a clone of an mbuf chain starting from <p offset>-th byte from the beginning,
+continuing for <p len> bytes.  If <p len> is M_COPYALL, then clone to end of the whole mbuf chain. (You may choose to use the optimized mBuf_clonePacket() in this case)
+The <p how> parameter is a choice of MBUF_WAIT or MBUF_DONTWAIT and/or M_ALLOCPKTHDR by the caller.
+If M_ALLOCPKTHDR flag is given, a new pkthdr would be allocated for duplicated packet. 
+
+Note that the clone is read-only, The new mbuf chain <p n> only shares cluster data with <p m>.
+<p n> can only read cluster data, but not write. <p m> still owns write priviledge.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+
+	n = mBuf_cloneMbufChain(m, 20, M_COPYALL, MBUF_WAIT);
+	if (n != NULL) {
+		// do following processing
+	}
+  @xref
+  <c mBuf_clonePacket>, <c mBuf_dupPacket>, <c mBuf_cloneMbufChain>
+ */
+
+extern struct rtl_mBuf *mBuf_dupMbufChain(struct rtl_mBuf *pMbufChain, int32 iOffset, int32 iLength,  int32 flag);
+
+/*
+@func struct rtl_mBuf *	| mBuf_dupMbufChain	| Duplicate a part of mbuf chain <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm int32			|offset	| The number of starting data byte in mbuf chain <p m>. Start from 0
+@parm int32			|len		| The number of data bytes to be cloned. If <p len>=M_COPYALL, then duplicate all data till the end of mbuf chain.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT> and/or <p M_ALLOCPKTHDR>
+@rdesc Returns address of the new, duplicated mbuf chain <p n>.
+@rvalue <p NULL>		| 	Can't duplicate mbuf chain <p m>.
+@rvalue <p n>		| 	The address of duplicated mbuf chain <p n>. Data in <p n> is writable.
+@comm
+Duplicate an mbuf chain starting from <p offset>-th byte from the beginning,
+continuing for <p len> bytes.  If <p len> is M_COPYALL, then duplicate to end of the whole mbuf chain. (You may choose to use the optimized mBuf_dupPacket() in this case)
+The <p how> parameter is a choice of MBUF_WAIT or MBUF_DONTWAIT and/or M_ALLOCPKTHDR by the caller.
+If M_ALLOCPKTHDR flag is given, a new pkthdr would be allocated for duplicated packet. 
+
+Note that the duplicated mbuf is writable..
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+
+	n = mBuf_dupMbufChain(m, 20, M_COPYALL, MBUF_WAIT);
+	if (n != NULL) {
+		// do following processing
+	}
+  @xref
+  <c mBuf_clonePacket>, <c mBuf_dupPacket>, <c mBuf_cloneMbufChain>
+ */
+
+
+
+extern struct rtl_mBuf *mBuf_clonePacket(struct rtl_mBuf *pMbuf, int32 iHow);
+
+/*
+@func struct rtl_mBuf *	| mBuf_clonePacket	| Clone the entire packet <p m>
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT>
+@rdesc Returns address of the new mbuf chain <p n>.
+@rvalue <p NULL>		| 	Can't clone mbuf chain <p m>.
+@rvalue <p n>		| 	The address of copied mbuf chain <p n>. Data in <p n> is read only.
+@comm
+Clone an entire mbuf chain <p m>, including the packet header (which must be present).
+An optimization of the common case `mBuf_cloneMbufChain(m, 0, M_COPYALL, how)'.
+The new cloned packet always allocates a new pkthdr.
+Note that the copy is read-only, because clusters are not copied, only their reference counts are incremented.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+	n = mBuf_clonePacket(m, MBUF_WAIT);
+	if (n != NULL) {
+		// do following processing
+	}
+  @xref
+  <c mBuf_dupPacket>, <c mBuf_cloneMbufChain>, <c mBuf_dupMbufChain>
+ */
+
+extern struct rtl_mBuf *mBuf_dupPacket(struct rtl_mBuf *pMbuf, int32 iHow);
+
+/*
+@func struct rtl_mBuf *	| mBuf_dupPacket	| Duplicate an mbuf chain <p m>, including its data,  into a completely new chain <p n>
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT>
+@rdesc Returns address of the new mbuf chain <p n>.
+@rvalue <p NULL>		| 	Can't duplicate mbuf chain <p m>.
+@rvalue <p n>		| 	The address of copied mbuf chain <p n>. Data in <p n> is writable.
+@comm
+Duplicate an mbuf chain <p m> into a completely new chain <p n>, including
+copying data in any <p m>'s mbuf clusters. 
+The new duplicated packet always allocates a new pkthdr.
+Use this instead of mBuf_clonePacket() when you need a writable copy of an mbuf chain.
+
+@ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+	n = mBuf_dupPacket(m, MBUF_WAIT);
+	if (n != NULL) {
+		// do following processing
+	}
+  @xref
+  <c mBuf_clonePacket> , <c mBuf_copyToUserBuffer>, <c mBuf_cloneMbufChain>
+ */
+
+
+
+
+
+extern struct rtl_mBuf *mBuf_prepend(struct rtl_mBuf *m, uint32 plen, int32 how);
+
+/*
+@func struct rtl_mBuf *	| mBuf_prepend	| Arrange to prepend space of size <p plen> to mbuf <p m>.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm uint32			|plen	| Number of bytes to be prepended before <p m>
+@parm int32			|how	| <p MBUF_WAIT>, <p MBUF_DONTWAIT>, <p M_GETNEWMBUF>
+@rdesc Returns address of the first mbuf.
+@rvalue <p NULL>		| 	Can't allocate memory or parameter problem.
+@rvalue <p n>		| 	The address of first mbuf after prepending.
+@comm
+Arrange to prepend space of size <p plen> to mbuf <p m>.
+ If new mbufs must be allocated, <p how> specifies whether to wait or not. When user calls mBuf_prepend, the
+ data length recorded in mbufs and pkthdr is incremented accordingly.
+
+By default, mBuf_prepend uses any leading free space before allocating any new clusters.
+But if <p M_GETNEWMBUF> is set, mBuf_prepend allocates new mbufs directly and leaves any leading free buffer space as is.
+
+If <p how> has MBUF_DONTWAIT bit set, and we can't get all buffers immediately, return NULL.
+If <p how> has MBUF_WAITOK bit set, and we can't get all buffers right away, block waiting until our request is satisfied.
+
+M_BUFONLY can't be used with mBuf_prepend.
+
+@ex The following example demonstrates how to use this function |
+	m0 = mBuf_prepend(m0, PPP_HDRLEN, MBUF_DONTWAIT | M_GETNEWMBUF);
+	if (m0 == 0) {
+	    error = ENOBUFS;
+	    goto bad;
+	}
+  @xref <c mBuf_cat>, <c mBuf_padding>
+
+ */
+
+extern struct rtl_mBuf *mBuf_padding(struct rtl_mBuf *m, uint32 plen, int32 how);
+/*
+@func struct rtl_mBuf *	| mBuf_padding	| Arrange to append space of size <p plen> to mbuf <p m>.
+@parm struct rtl_mBuf * 	| m		| Pointer to an mbuf chain.
+@parm uint32			|plen	| Number of bytes to append at <p m>
+@parm int32			|how	| <p MBUF_WAIT> or <p MBUF_DONTWAIT>
+@rdesc Returns address of the last mbuf padded.
+@rvalue <p NULL>		| 	Can't allocate memory or parameter problem.
+@rvalue <p n>		| 	The address of last mbuf after padding
+@comm
+Arrange to append space of size <p plen> to mbuf <p m>.
+ If new mbufs must be allocated, <p how> specifies whether to wait or not. When user calls mBuf_padding, the
+ data length recorded in mbufs and pkthdr are incremented accordingly.
+
+ M_BUFONLY can't be used with mBuf_padding.
+@devnote  API CHANGED:  If <p how> is MBUF_DONTWAIT and allocation fails, NULL is returned.
+Original mbuf <p m> is intact.
+
+@ex The following example demonstrates how to use this function |
+	m0 = mBuf_padding(m, (ETHER_MIN_LEN-ETHER_CRC_LEN-len), MBUF_DONTWAIT);
+	if (m0 == 0) {
+	    error = ENOBUFS;
+	    goto bad;
+	}
+@xref <c mBuf_split>, <c mBuf_cat>, <c mBuf_getm>, <c mBuf_prepend>, <c mBuf_split>
+
+
+ */
+
+
+extern struct rtl_mBuf *mBuf_cat(struct rtl_mBuf *m, struct rtl_mBuf *n);
+
+/*
+@func struct rtl_mBuf *	| mBuf_cat	| Concatenate mbuf chain <p n> to <p m>.
+@parm struct rtl_mBuf * 	| m		| mbuf chain to be appended.
+@parm struct rtl_mBuf * 	| n		| mbuf chain to be appended after <p m>
+@rdesc Returns the address of <p m> or NULL if failed.
+@rvalue <p NULL>		| 	Can't concatenate two mbuf chain
+@rvalue <p m>		| 	When success, the address of <p m> is returned..
+@comm
+Concatenate mbuf chain <p n> to <p m>.
+Total packet length of <p m> would be adjusted accordingly. However, <p n>'s control header, if any, would be freed
+@xref   <c mBuf_split>, <c mBuf_padding>, <p mBuf_getm>
+
+ */
+
+
+extern int32 mBuf_pullup(struct rtl_mBuf *, int32);
+
+/*
+@func int32		| mBuf_pullup| 	Rearange an mbuf chain so that <p len> bytes are contiguous
+ 								 in <p m>'s first cluster.
+@parm struct rtl_mBuf * 	| m	| Pointer to an mbuf chain.
+@parm 	int32			|len	| The number of databytes requested to put in <p m>'s first cluster. <p len> should not exceed the size of a cluster buffer (256 bytes).
+@rdesc	Returns total data bytes in the first mbuf cluster.
+@rvalue <p n>		| 	The number of data bytes in <p m>'s first cluster. If <p n> is less than <p len>,
+						that means <p mBuf_pullup> can't pull up all <p len> bytes requested because there isn't
+						so much data in mbuf chain.
+@comm  Original BSD4.4 note: Rearange an mbuf chain so that <p len> bytes are contiguous and in <p m>'s cluster.
+Successing mbufs are adjusted accordingly. If the return value <p n> is smaller than requested <p len>,
+maybe there isn't enough data bytes in the mbuf chain <p m>, or maybe the requested value <p len> exceeds
+the maximum capacity for a single cluster.
+
+Our implementation note:
+(cfliu 2002.02.19)This function is important in traditional BSD networking stack because
+original mbuf can't do dtom() if data is saved in cluster. This is not the
+case here since we offer a back pointer from cluster to mbuf via cltag_mbuf field.
+However, this function is still useful if we want to collect continous databytes from later clusters
+to the specified mbuf's cluster. The maximum number of  <p len> should be less than a cluster
+can hold (ie. len less than or equal to m_clusterSIze)
+
+(2002.08.11) If 1) requested length <p len> is smaller than m_clusterSize, and 2) there are enough data in this mbuf chain. However, the
+trailing space in <p m> is not large enough, <p mBuf_pullup> will move m's data upward first and then copy requested data from latter clusters
+
+@devnote  This function is different from traditional BSD mbuf code. When pull up fails, the mbuf chain will not be freed,
+and the return value has been changed to an integer instead of a pointer to mbuf structure.
+
+@ex The following example demonstrates how to use this function |
+	int32 n;
+
+	n = mBuf_pullup(m, 128);
+	if (n < 128) {
+		//There isn't so much data in mbuf chain.
+	}
+  @xref
+  <c m_pulldown>
+ */
+
+
+struct rtl_mBuf *mBuf_split(register struct rtl_mBuf *m0, uint32 len0, int32 wait);
+
+/*@func struct rtl_mBuf * | mBuf_split | Partition an mbuf chain in two pieces. Data is cloned
+  @parm struct rtl_mBuf * 	| m    	| Pointer to an mbuf chain
+  @parm 	int32			| len    	| The number of last data byte to remain in original mbuf chain <p m>
+  @parm  int32 			| wait   	| <p MBUF_DONTWAIT> or <p MBUF_WAIT>
+  @rdesc	Returns a pointer to the splited mbuf chain <p n>
+  @rvalue NULL		| Can't split the mbuf chain
+  @rvalue <p n>		| Success. <p n> is the address of second mbuf chain. It holds all data bytes after the <p len>-th byte in <p m>.
+  @comm  Partition an mbuf chain <p m> into two pieces, returning the tail mbuf chain <p n>. In case of failure, it returns NULL and
+ attempts to restore the chain to its original state. Data in clusters  are NOT copied, but cloned only.
+
+  @ex The following example demonstrates how to use this function |
+	struct rtl_mBuf *n;
+
+	n = mBuf_split(m, off, MBUF_DONTWAIT);
+	if (n == NULL) {
+		goto bad;
+	}
+  @xref
+  <c mBuf_cat>, <c mBuf_padding>, <c mBuf_getm>
+
+ */
+void mBuf_getBMjmpTable(uint8 *pat,  uint16 *jump_tbl,uint16 patLen, uint8 caseSensitive);
+int32 mBuf_BMpatternMatch(struct rtl_mBuf *m, uint32 len, uint8 *delimiter, uint32 delimitLen, uint16 *jmp_tbl, uint8 caseSensitive);
+
+#define MBUF_GETLEN(m)	 ((m)? ((m)->m_len : -1)
+/*
+@func MACRO	| MBUF_GETLEN	| Get total number of data bytes in the mbuf <p m>
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@rdesc Returns data length of the mbuf
+@rvalue -1		| 	Failed.
+@rvalue <p length>| 	The actual length of data in <p m>
+@comm
+ Get total number of data bytes in the mbuf <p m>
+@xref  <c mBuf_getPktlen>
+*/
+
+
+ struct rtl_mBuf *mBuf_attachHeader(void *buffer, uint32 id, uint32 bufsize,uint32 datalen, uint16 align);
+struct rtl_mBuf *mBuf_attachHeaderJumbo(void *buffer, uint32 id, uint32 bufsize,uint32 datalen);
+
+int32 mBuf_setNICRxRingSize(uint32 size);
+extern int32 mBuf_reserve(struct rtl_mBuf * m, uint16 headroom);
+
+
+#define MBUF_SET_PKTHDRFLAGS(m, Flags) do{\
+	assert((m));\
+	assert(ISSET((m)->m_flags, MBUF_USED));\
+	assert((m)->m_pkthdr);\
+	MBUF_SETPKTHDRFIELD16(((memaddr *)&(m)->m_pkthdr->ph_flags), (Flags));\
+ }while(0)
+
+
+/*
+@func MACRO	| MBUF_SET_PKTHDRFLAGS	| Set packet specific flags for ASIC processing
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@parm uint32	|Flags		| flag to be set
+@rdesc None
+@comm
+Set packet specific flags for ASIC processing. This overwrites original flag value. If you are adding flag bits rather than reseting it,
+remember to save its old value first
+
+@xref  <c MBUF_GET_PKTHDRFLAGS>
+*/
+
+
+#define MBUF_GET_PKTHDRFLAGS(m)	(MBUF_CHECKPKTHDR((m))? MBUF_GETPKTHDRFIELD16((memaddr *)(&m->m_pkthdr->ph_flags)):-1)
+/*
+@func MACRO	| MBUF_GET_PKTHDRFLAGS	| Get packet specific flags set by ASIC
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@rdesc Returns the result of execution
+@rvalue -1		| 	Failed. <p m> might have no pkthdrs.
+@rvalue FLAGS	| 	Returns the flags.
+@comm
+Get packet specific flags set by ASIC
+
+@xref  <c MBUF_SET_PKTHDRFLAGS>
+*/
+
+#define MBUF_SET_PORTLIST(m,Portlist)  do{\
+	assert((m));\
+	assert(ISSET((m)->m_flags, MBUF_USED));\
+	assert((m)->m_pkthdr);\
+	(m)->m_pkthdr->ph_portlist = (Portlist);\
+}while(0)
+
+/*
+@func MACRO	| MBUF_SET_PORTLIST	| Set outgoing port list
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@parm uint32	|Portlist		| port list
+@rdesc None
+@comm  Set outgoing port list
+@xref  <c MBUF_GET_PORTLIST>
+*/
+
+#define MBUF_GET_PORTLIST(m) (MBUF_CHECKPKTHDR((m))? ((m)->m_pkthdr->ph_portlist):-1)
+/*
+@func MACRO	| MBUF_GET_PORTLIST	| get incoming port list
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@rdesc Returns the result of execution
+@rvalue 0		| 	Failed. <p m> might have no pkthdrs.
+@rvalue Portlist	| 	Returns incoming portlist.
+@comm
+ get incoming port list
+
+@xref  <c MBUF_SET_PORTLIST>
+*/
+
+
+#define MBUF_SET_TRAPREASON(m, Reason)	do{\
+	assert((m));\
+	assert(ISSET((m)->m_flags, MBUF_USED));\
+	assert((m)->m_pkthdr);\
+	MBUF_SETPKTHDRFIELD16(((memaddr *)&(m)->m_pkthdr->ph_reason), (Reason));\
+}while(0)
+
+/*
+@func MACRO	| MBUF_SET_TRAPREASON	| Set packet trapping reason for ASIC processing
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@parm uint16	|Reason		| Trapping reason
+@rdesc None
+@comm
+Set packet trapping reason for ASIC processing
+
+@xref  <c MBUF_GET_TRAPREASON>
+*/
+
+#define MBUF_GET_TRAPREASON(m)	(MBUF_CHECKPKTHDR((m))? MBUF_GETPKTHDRFIELD16((memaddr *)(&m->m_pkthdr->ph_reason)):-1)
+/*
+@func MACRO	| MBUF_GET_TRAPREASON	| Get packet trapping reason set by ASIC
+@parm struct rtl_mBuf *	|m		| Indicate the packet
+@rdesc Returns the result of execution
+@rvalue -1		| 	Failed. <p m> might have no pkthdrs.
+@rvalue Reason	| 	Returns trap reason
+@comm
+Get packet trapping reason set by ASIC
+
+@xref  <c MBUF_SET_TRAPREASON>
+*/
+
+#define	MBUF2DATAPTR(m, t)	((t)((m)->m_data))
+/*
+@func MACRO	| MBUF2DATAPTR	| Given mbuf pointer 'm', returns address of m->m_data, and convert it to type 't'
+@parm struct rtl_mBuf *	|m		| Pointer to an mbuf
+@parm TYPE	|t		| A type to be casted
+@rdesc Address of m->m_data
+@comm
+Given mbuf pointer 'm', returns address of m->m_data, and convert it to type 't'
+@xref  <c mBuf_data2Mbuf>
+*/
+
+
+#define	MBUF_ALIGN(m, len) do {	\
+	assert((m)->m_len==0);\
+	assert(len>0);\
+	assert(((m)->m_extsize - (len))>0);\
+	(m)->m_data += ( (m)->m_extsize - (len)) & ~(sizeof(memaddr) - 1);	\
+} while (0)
+
+/*
+@func MACRO	| MBUF_ALIGN	| Align the m->m_data pointer from end of the cluster, for 'len' bytes.
+@parm struct rtl_mBuf *	|m		| Pointer to an mbuf
+@parm uint32	|len		| Size to be aligned.
+@rdesc None
+@comm
+Set the m_data pointer of a NEWLY-allocated cluster  to place
+an object of the specified size at the end of the mbuf, longword aligned.
+@xref  <c MBUF_RESERVE>
+*/
+
+
+#define	MBUF_RESERVE(m, len) do {	\
+	assert(len>0);\
+	(m)->m_data += ( ((len) > (m)->m_extsize)? (m)->m_extsize : len);	\
+} while (0)
+/*
+@func MACRO	| MBUF_RESERVE	| Reserve 'len' bytes from the beginning of the newly allocated cluster
+@parm struct rtl_mBuf *	|m		| Pointer to an mbuf
+@parm uint32	|len		| Size to be aligned.
+@rdesc None
+@comm
+Forward move the m_data pointer of a NEWLY-allocated cluster  for 'len' bytes.
+m_data won't move beyond m_extbuf + m_extsize, make sure 'len' you give is a reasonable value
+@xref  <c MBUF_ALIGN>
+*/
+#endif			   /* !_MBUF_H_ */
+