drivers/scsi/thor/include/com_sgd.h - kernel/prism - Git at Google

 #ifndef __MV_COM_SGD_H__
 #define __MV_COM_SGD_H__

 struct _sgd_tbl_t;
 struct _sgd_t;

 #define SGD_DOMAIN_MASK	0xF0000000L

 #define SGD_EOT			(1L<<27)	/* End of table */
 #define SGD_COMPACT		(1L<<26)	/* Compact (12 bytes) SG format, not verified yet */
 #define SGD_WIDE		(1L<<25)	/* 32 byte SG format */
 #define SGD_X64			(1L<<24)	/* the 2nd part of SGD_WIDE */
 #define SGD_NEXT_TBL	(1L<<23)	/* Next SG table format */
 #define SGD_VIRTUAL		(1L<<22)	/* Virtual SG format, either 32 or 64 bit is determined during compile time. */
 #define SGD_REFTBL		(1L<<21)	/* sg table reference format, either 32 or 64 bit is determined during compile time. */
 #define SGD_REFSGD		(1L<<20)	/* sg item reference format */
 #define SGD_VP			(1L<<19)	/* virtual and physical, not verified yet */
 #define SGD_VWOXCTX		(1L<<18)	/* virtual without translation context */
 #define SGD_PCTX		(1L<<17)	/* sgd_pctx_t, 64 bit only */

 typedef struct _sg_common_t
 {
 	MV_U32	dword1;
 	MV_U32	dword2;
 	MV_U32	flags;	/* SGD_xxx */
 	MV_U32	dword3;
 } sg_common_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_t
 {
 	MV_U64	baseAddr;
 	MV_U32	flags;
 	MV_U32	size;
 } sgd_t;

 /*---------------------------------------------------------------------------*/

 #define GET_COMPACT_SGD_SIZE(sgd)	\
 	((((sgd_compact_t*)(sgd))->flags) & 0x3FFFFFL)

 #define SET_COMPACT_SGD_SIZE(sgd,sz) do {			\
 	(((sgd_compact_t*)(sgd))->flags) &= ~0x3FFFFFL;	\
 	(((sgd_compact_t*)(sgd))->flags) |= (sz);		\
 } while(0)

 #define SIZEOF_COMPACT_SGD	12

 typedef struct _sgd_compact_t
 {
 	MV_U64	baseAddr;
 	MV_U32	flags;
 } sgd_compact_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_v32_t
 {
 	MV_PVOID	vaddr;
 	MV_PVOID	xctx;
 	MV_U32		flags;
 	MV_U32		size;
 } sgd_v32_t;

 /* sgd_v_t defines 32/64 bit virtual sgd without translation context */
 typedef struct _sgd_v_t
 {
 	union {
 		MV_PVOID	vaddr;
 		MV_U64		dummy;
 	} u;
 	MV_U32		flags;
 	MV_U32		size;
 } sgd_v_t;

 typedef struct _sgd_v64_t
 {
 	union {
 		MV_PVOID	vaddr;
 		MV_U64		dummy;
 	} u1;
 	MV_U32	flags;
 	MV_U32	size;

 	union {
 		MV_PVOID	xctx;
 		MV_U64		dummy;
 	} u2;
 	MV_U32	flagsEx;
 	MV_U32	rsvd;
 } sgd_v64_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_ref32_t
 {
 	MV_PVOID	ref;
 	MV_U32		offset;
 	MV_U32		flags;
 	MV_U32		size;
 } sgd_ref32_t;

 typedef struct _sgd_ref64_t
 {
 	union {
 		MV_PVOID	ref;
 		MV_U64		dummy;
 	} u;
 	MV_U32	flags;
 	MV_U32	size;

 	MV_U32	offset;
 	MV_U32	rsvd1;
 	MV_U32	flagsEx;
 	MV_U32	rsvd2;
 } sgd_ref64_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_nt_t
 {
 	union {
 		struct _sgd_tbl_t*	next;
 		MV_U64	dummy;
 	} u;
 	MV_U32	flags;
 	MV_U32	rsvd;
 } sgd_nt_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_vp_t
 {
 	MV_U64	baseAddr;
 	MV_U32	flags;		// SGD_VP | SGD_WIDE
 	MV_U32	size;

 	union {
 		MV_PVOID vaddr;
 		MV_U64   dummy;
 	} u;
 	MV_U32	flagsEx;	// SGD_X64
 	MV_U32	rsvd;
 } sgd_vp_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_pctx_t
 {
 	MV_U64	baseAddr;
 	MV_U32	flags;		// SGD_PCTX | SGD_WIDE
 	MV_U32	size;

 	union {
 		MV_PVOID xctx;
 		MV_U64   dummy;
 	} u;
 	MV_U32	flagsEx;	// SGD_X64
 	MV_U32	rsvd;
 } sgd_pctx_t;

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_tbl_t
 {
 	MV_U8 Max_Entry_Count;
 	MV_U8 Valid_Entry_Count;
 	MV_U8 Flag;
 	MV_U8 Reserved0;
 	MV_U32 Byte_Count;
 	sgd_t* Entry_Ptr;
 } sgd_tbl_t;

 #define sgd_table_init(sgdt,maxCnt,entries) do {	\
 	MV_ZeroMemory(sgdt,sizeof(sgd_tbl_t));		\
 	(sgdt)->Max_Entry_Count = (maxCnt);				\
 	(sgdt)->Entry_Ptr = (sgd_t*)(entries);			\
 } while(0)

 /*---------------------------------------------------------------------------*/

 #define sgd_inc(sgd) do {	\
 	if( (sgd)->flags & SGD_COMPACT )					\
 		sgd = (sgd_t*)(((unsigned char*) (sgd)) + 12);	\
 	else if( (sgd)->flags & SGD_WIDE )					\
 		sgd = (sgd_t*)(((unsigned char*) (sgd)) + 32);	\
 	else sgd = (sgd_t*)(((unsigned char*) (sgd)) + 16);	\
 } while(0)

 #define sgd_get_vaddr(sgd,v) do {				\
 	if( (sgd)->flags & SGD_VIRTUAL ) {			\
 		if( (sgd)->flags & SGD_WIDE )			\
 			(v) = ((sgd_v64_t*)(sgd))->u1.vaddr;\
 		else (v) = ((sgd_v32_t*)(sgd))->vaddr;	\
 	}											\
 	else if( (sgd)->flags & SGD_VWOXCTX )		\
 		(v) = ((sgd_v_t*)sgd)->u.vaddr;			\
 	else if( (sgd)->flags & SGD_VP )			\
 		(v) = ((sgd_vp_t*)(sgd))->u.vaddr;		\
 	else										\
 		MV_ASSERT(MV_FALSE);					\
 } while(0)

 #define sgd_get_xctx(sgd,v) do {	\
 	if( (sgd)->flags & SGD_WIDE )	(v) = ((sgd_v64_t*)(sgd))->u2.xctx;	\
 	else (v) = ((sgd_v32_t*)(sgd))->xctx;	\
 } while(0)

 #define sgd_get_ref(sgd,_ref) do {	\
 	if( (sgd)->flags & SGD_WIDE ) (_ref) = ((sgd_ref64_t*)(sgd))->u.ref;	\
 	else (_ref) = ((sgd_ref32_t*)(sgd))->ref;	\
 } while(0)

 #define sgd_set_ref(sgd,_ref) do {	\
 	if( (sgd)->flags & SGD_WIDE ) ((sgd_ref64_t*)(sgd))->u.ref = (_ref);	\
 	else ((sgd_ref32_t*)(sgd))->ref = (_ref);	\
 } while(0)

 #define sgd_get_reftbl(sgd,reft) do {	\
 	if( (sgd)->flags & SGD_WIDE )		\
 		(reft) = (sgd_tbl_t*) (((sgd_ref64_t*)(sgd))->u.ref);	\
 	else (reft) = (sgd_tbl_t*)(((sgd_ref32_t*)(sgd))->ref);	\
 } while(0)

 #define sgd_get_refsgd(sgd,reft) do {	\
 	if( (sgd)->flags & SGD_WIDE )		\
 		(reft) = (sgd_t*) (((sgd_ref64_t*)(sgd))->u.ref);	\
 	else (reft) = (sgd_t*)(((sgd_ref32_t*)(sgd))->ref);	\
 } while(0)

 #define sgd_get_refoff(sgd,off) do {	\
 	if( (sgd)->flags & SGD_WIDE )	(off) = ((sgd_ref64_t*)(sgd))->offset;	\
 	else (off) = ((sgd_ref32_t*)(sgd))->offset;	\
 } while(0)

 #define sgd_set_refoff(sgd,off) do {	\
 	if( (sgd)->flags & SGD_WIDE )	((sgd_ref64_t*)(sgd))->offset = (off);	\
 	else ((sgd_ref32_t*)(sgd))->offset = (off);	\
 } while(0)

 #define sgd_get_nexttbl(sgd,n) do {	\
 	n = ((sgd_nt_t*)(sgd))->u.next;	\
 } while(0)

 #define sgd_mark_eot(sgd) \
 	((sgd)->flags |= SGD_EOT)

 #define sgd_clear_eot(sgd) \
 	((sgd)->flags &= ~SGD_EOT)

 #define sgd_eot(sgd)	\
 	((sgd)->flags & SGD_EOT)

 #define sgd_copy(sgdDst,sgdSrc) do {	\
 	*(sgdDst) = *(sgdSrc);	\
 	if( (sgdSrc)->flags & SGD_WIDE )	\
 		(sgdDst)[1] = (sgdSrc)[1];	\
 } while(0)

 #define sgd_getsz(sgd,sz) do {				\
 	if( (sgd)->flags & SGD_COMPACT )		\
 		(sz) = GET_COMPACT_SGD_SIZE(sgd);	\
 	else (sz) = (sgd)->size;				\
 } while(0)

 #define sgd_setsz(sgd,sz) do {				\
 	if( (sgd)->flags & SGD_COMPACT )		\
 		SET_COMPACT_SGD_SIZE(sgd,sz);		\
 	else (sgd)->size = (sz);				\
 } while(0)

 #define sgdt_get_lastsgd(sgdt,sgd) do {		\
 	(sgd) = &(sgdt)->Entry_Ptr[(sgdt)->Valid_Entry_Count];	\
 	(sgd)--;								\
 	if( (sgd)->flags & SGD_X64 ) (sgd)--;	\
 } while(0)

 /*---------------------------------------------------------------------------*/

 typedef int (*sgd_visitor_t)(sgd_t* sgd, MV_PVOID pContext);

 int sgd_table_walk(
 	sgd_tbl_t*		sgdt,
 	sgd_visitor_t	visitor,
 	MV_PVOID		ctx
 	);

 /*---------------------------------------------------------------------------*/

 typedef struct _sgd_iter_t
 {
 	sgd_t*	sgd;		/* current SG */
 	MV_U32	offset;		/* offset in the SG */
 	MV_U32	remainCnt;
 } sgd_iter_t;

 void  sgd_iter_init(
 	sgd_iter_t*	iter,
 	sgd_t*		sgd,
 	MV_U32		offset,
 	MV_U32		count
 	);

 int sgd_iter_get_next(
 	sgd_iter_t*	iter,
 	sgd_t*		sgd
 	);

 /*---------------------------------------------------------------------------*/

 void sgd_dump(sgd_t* sg, char* prefix);
 void sgdt_dump(sgd_tbl_t *SgTbl, char* prefix);

 /*---------------------------------------------------------------------------*/

 void sgdt_append(
 	sgd_tbl_t*	sgdt,
 	MV_U32		address,
 	MV_U32		addressHigh,
 	MV_U32		size
 	);

 void sgdt_append_pctx(
 	sgd_tbl_t*	sgdt,
 	MV_U32		address,
 	MV_U32		addressHigh,
 	MV_U32		size,
 	MV_PVOID	xctx
 	);

 int sgdt_append_virtual(
 	sgd_tbl_t* sgdt,
 	MV_PVOID virtual_address,
 	MV_PVOID translation_ctx,
 	MV_U32 size
 	);

 int sgdt_append_ref(
 	sgd_tbl_t*	sgdt,
 	MV_PVOID	ref,
 	MV_U32		offset,
 	MV_U32		size,
 	MV_BOOLEAN	refTbl
 	);

 int sgdt_append_vp(
 	sgd_tbl_t*	sgdt,
 	MV_PVOID	virtual_address,
 	MV_U32		size,
 	MV_U32		address,
 	MV_U32		addressHigh
 	);

 void
 sgdt_copy_partial(
 	sgd_tbl_t* sgdt,
 	sgd_t**	ppsgd,
 	MV_PU32	poff,
 	MV_U32	size
 	);

 void sgdt_append_sgd(
 	sgd_tbl_t*	sgdt,
 	sgd_t*		sgd
 	);

 #define sgdt_append_reftbl(sgdt,refSgdt,offset,size)	\
 	sgdt_append_ref(sgdt,refSgdt,offset,size,MV_TRUE)

 #define sgdt_append_refsgd(sgdt,refSgd,offset,size)	\
 	sgdt_append_ref(sgdt,refSgd,offset,size,MV_FALSE)

 /*---------------------------------------------------------------------------*/

 int sgdt_prepare_hwprd(
 	MV_PVOID		pCore,
 	sgd_tbl_t*		pSource,
 	sgd_t*			pSg,
 	int				availSgEntry
 	);

 #endif	/*__MV_COM_SGD_H__*/
	#ifndef __MV_COM_SGD_H__
	#define __MV_COM_SGD_H__

	struct _sgd_tbl_t;
	struct _sgd_t;

	#define SGD_DOMAIN_MASK 0xF0000000L

	#define SGD_EOT (1L<<27) /* End of table */
	#define SGD_COMPACT (1L<<26) /* Compact (12 bytes) SG format, not verified yet */
	#define SGD_WIDE (1L<<25) /* 32 byte SG format */
	#define SGD_X64 (1L<<24) /* the 2nd part of SGD_WIDE */
	#define SGD_NEXT_TBL (1L<<23) /* Next SG table format */
	#define SGD_VIRTUAL (1L<<22) /* Virtual SG format, either 32 or 64 bit is determined during compile time. */
	#define SGD_REFTBL (1L<<21) /* sg table reference format, either 32 or 64 bit is determined during compile time. */
	#define SGD_REFSGD (1L<<20) /* sg item reference format */
	#define SGD_VP (1L<<19) /* virtual and physical, not verified yet */
	#define SGD_VWOXCTX (1L<<18) /* virtual without translation context */
	#define SGD_PCTX (1L<<17) /* sgd_pctx_t, 64 bit only */

	typedef struct _sg_common_t
	{
	MV_U32 dword1;
	MV_U32 dword2;
	MV_U32 flags; /* SGD_xxx */
	MV_U32 dword3;
	} sg_common_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_t
	{
	MV_U64 baseAddr;
	MV_U32 flags;
	MV_U32 size;
	} sgd_t;

	/---------------------------------------------------------------------------/

	#define GET_COMPACT_SGD_SIZE(sgd) \
	((((sgd_compact_t*)(sgd))->flags) & 0x3FFFFFL)

	#define SET_COMPACT_SGD_SIZE(sgd,sz) do { \
	(((sgd_compact_t*)(sgd))->flags) &= ~0x3FFFFFL; \
	(((sgd_compact_t*)(sgd))->flags) \|= (sz); \
	} while(0)

	#define SIZEOF_COMPACT_SGD 12

	typedef struct _sgd_compact_t
	{
	MV_U64 baseAddr;
	MV_U32 flags;
	} sgd_compact_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_v32_t
	{
	MV_PVOID vaddr;
	MV_PVOID xctx;
	MV_U32 flags;
	MV_U32 size;
	} sgd_v32_t;

	/* sgd_v_t defines 32/64 bit virtual sgd without translation context */
	typedef struct _sgd_v_t
	{
	union {
	MV_PVOID vaddr;
	MV_U64 dummy;
	} u;
	MV_U32 flags;
	MV_U32 size;
	} sgd_v_t;

	typedef struct _sgd_v64_t
	{
	union {
	MV_PVOID vaddr;
	MV_U64 dummy;
	} u1;
	MV_U32 flags;
	MV_U32 size;

	union {
	MV_PVOID xctx;
	MV_U64 dummy;
	} u2;
	MV_U32 flagsEx;
	MV_U32 rsvd;
	} sgd_v64_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_ref32_t
	{
	MV_PVOID ref;
	MV_U32 offset;
	MV_U32 flags;
	MV_U32 size;
	} sgd_ref32_t;

	typedef struct _sgd_ref64_t
	{
	union {
	MV_PVOID ref;
	MV_U64 dummy;
	} u;
	MV_U32 flags;
	MV_U32 size;

	MV_U32 offset;
	MV_U32 rsvd1;
	MV_U32 flagsEx;
	MV_U32 rsvd2;
	} sgd_ref64_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_nt_t
	{
	union {
	struct _sgd_tbl_t* next;
	MV_U64 dummy;
	} u;
	MV_U32 flags;
	MV_U32 rsvd;
	} sgd_nt_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_vp_t
	{
	MV_U64 baseAddr;
	MV_U32 flags; // SGD_VP \| SGD_WIDE
	MV_U32 size;

	union {
	MV_PVOID vaddr;
	MV_U64 dummy;
	} u;
	MV_U32 flagsEx; // SGD_X64
	MV_U32 rsvd;
	} sgd_vp_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_pctx_t
	{
	MV_U64 baseAddr;
	MV_U32 flags; // SGD_PCTX \| SGD_WIDE
	MV_U32 size;

	union {
	MV_PVOID xctx;
	MV_U64 dummy;
	} u;
	MV_U32 flagsEx; // SGD_X64
	MV_U32 rsvd;
	} sgd_pctx_t;

	/---------------------------------------------------------------------------/

	typedef struct _sgd_tbl_t
	{
	MV_U8 Max_Entry_Count;
	MV_U8 Valid_Entry_Count;
	MV_U8 Flag;
	MV_U8 Reserved0;
	MV_U32 Byte_Count;
	sgd_t* Entry_Ptr;
	} sgd_tbl_t;

	#define sgd_table_init(sgdt,maxCnt,entries) do { \
	MV_ZeroMemory(sgdt,sizeof(sgd_tbl_t)); \
	(sgdt)->Max_Entry_Count = (maxCnt); \
	(sgdt)->Entry_Ptr = (sgd_t*)(entries); \
	} while(0)

	/---------------------------------------------------------------------------/

	#define sgd_inc(sgd) do { \
	if( (sgd)->flags & SGD_COMPACT ) \
	sgd = (sgd_t)(((unsigned char) (sgd)) + 12); \
	else if( (sgd)->flags & SGD_WIDE ) \
	sgd = (sgd_t)(((unsigned char) (sgd)) + 32); \
	else sgd = (sgd_t)(((unsigned char) (sgd)) + 16); \
	} while(0)

	#define sgd_get_vaddr(sgd,v) do { \
	if( (sgd)->flags & SGD_VIRTUAL ) { \
	if( (sgd)->flags & SGD_WIDE ) \
	(v) = ((sgd_v64_t*)(sgd))->u1.vaddr;\
	else (v) = ((sgd_v32_t*)(sgd))->vaddr; \
	} \
	else if( (sgd)->flags & SGD_VWOXCTX ) \
	(v) = ((sgd_v_t*)sgd)->u.vaddr; \
	else if( (sgd)->flags & SGD_VP ) \
	(v) = ((sgd_vp_t*)(sgd))->u.vaddr; \
	else \
	MV_ASSERT(MV_FALSE); \
	} while(0)

	#define sgd_get_xctx(sgd,v) do { \
	if( (sgd)->flags & SGD_WIDE ) (v) = ((sgd_v64_t*)(sgd))->u2.xctx; \
	else (v) = ((sgd_v32_t*)(sgd))->xctx; \
	} while(0)

	#define sgd_get_ref(sgd,_ref) do { \
	if( (sgd)->flags & SGD_WIDE ) (_ref) = ((sgd_ref64_t*)(sgd))->u.ref; \
	else (_ref) = ((sgd_ref32_t*)(sgd))->ref; \
	} while(0)

	#define sgd_set_ref(sgd,_ref) do { \
	if( (sgd)->flags & SGD_WIDE ) ((sgd_ref64_t*)(sgd))->u.ref = (_ref); \
	else ((sgd_ref32_t*)(sgd))->ref = (_ref); \
	} while(0)

	#define sgd_get_reftbl(sgd,reft) do { \
	if( (sgd)->flags & SGD_WIDE ) \
	(reft) = (sgd_tbl_t) (((sgd_ref64_t)(sgd))->u.ref); \
	else (reft) = (sgd_tbl_t)(((sgd_ref32_t)(sgd))->ref); \
	} while(0)

	#define sgd_get_refsgd(sgd,reft) do { \
	if( (sgd)->flags & SGD_WIDE ) \
	(reft) = (sgd_t) (((sgd_ref64_t)(sgd))->u.ref); \
	else (reft) = (sgd_t)(((sgd_ref32_t)(sgd))->ref); \
	} while(0)

	#define sgd_get_refoff(sgd,off) do { \
	if( (sgd)->flags & SGD_WIDE ) (off) = ((sgd_ref64_t*)(sgd))->offset; \
	else (off) = ((sgd_ref32_t*)(sgd))->offset; \
	} while(0)

	#define sgd_set_refoff(sgd,off) do { \
	if( (sgd)->flags & SGD_WIDE ) ((sgd_ref64_t*)(sgd))->offset = (off); \
	else ((sgd_ref32_t*)(sgd))->offset = (off); \
	} while(0)

	#define sgd_get_nexttbl(sgd,n) do { \
	n = ((sgd_nt_t*)(sgd))->u.next; \
	} while(0)

	#define sgd_mark_eot(sgd) \
	((sgd)->flags \|= SGD_EOT)

	#define sgd_clear_eot(sgd) \
	((sgd)->flags &= ~SGD_EOT)

	#define sgd_eot(sgd) \
	((sgd)->flags & SGD_EOT)

	#define sgd_copy(sgdDst,sgdSrc) do { \
	(sgdDst) = (sgdSrc); \
	if( (sgdSrc)->flags & SGD_WIDE ) \
	(sgdDst)[1] = (sgdSrc)[1]; \
	} while(0)

	#define sgd_getsz(sgd,sz) do { \
	if( (sgd)->flags & SGD_COMPACT ) \
	(sz) = GET_COMPACT_SGD_SIZE(sgd); \
	else (sz) = (sgd)->size; \
	} while(0)

	#define sgd_setsz(sgd,sz) do { \
	if( (sgd)->flags & SGD_COMPACT ) \
	SET_COMPACT_SGD_SIZE(sgd,sz); \
	else (sgd)->size = (sz); \
	} while(0)

	#define sgdt_get_lastsgd(sgdt,sgd) do { \
	(sgd) = &(sgdt)->Entry_Ptr[(sgdt)->Valid_Entry_Count]; \
	(sgd)--; \
	if( (sgd)->flags & SGD_X64 ) (sgd)--; \
	} while(0)

	/---------------------------------------------------------------------------/

	typedef int (sgd_visitor_t)(sgd_t sgd, MV_PVOID pContext);

	int sgd_table_walk(
	sgd_tbl_t* sgdt,
	sgd_visitor_t visitor,
	MV_PVOID ctx
	);

	/---------------------------------------------------------------------------/

	typedef struct _sgd_iter_t
	{
	sgd_t* sgd; /* current SG */
	MV_U32 offset; /* offset in the SG */
	MV_U32 remainCnt;
	} sgd_iter_t;

	void sgd_iter_init(
	sgd_iter_t* iter,
	sgd_t* sgd,
	MV_U32 offset,
	MV_U32 count
	);

	int sgd_iter_get_next(
	sgd_iter_t* iter,
	sgd_t* sgd
	);

	/---------------------------------------------------------------------------/

	void sgd_dump(sgd_t* sg, char* prefix);
	void sgdt_dump(sgd_tbl_t SgTbl, char prefix);

	/---------------------------------------------------------------------------/

	void sgdt_append(
	sgd_tbl_t* sgdt,
	MV_U32 address,
	MV_U32 addressHigh,
	MV_U32 size
	);

	void sgdt_append_pctx(
	sgd_tbl_t* sgdt,
	MV_U32 address,
	MV_U32 addressHigh,
	MV_U32 size,
	MV_PVOID xctx
	);

	int sgdt_append_virtual(
	sgd_tbl_t* sgdt,
	MV_PVOID virtual_address,
	MV_PVOID translation_ctx,
	MV_U32 size
	);

	int sgdt_append_ref(
	sgd_tbl_t* sgdt,
	MV_PVOID ref,
	MV_U32 offset,
	MV_U32 size,
	MV_BOOLEAN refTbl
	);

	int sgdt_append_vp(
	sgd_tbl_t* sgdt,
	MV_PVOID virtual_address,
	MV_U32 size,
	MV_U32 address,
	MV_U32 addressHigh
	);

	void
	sgdt_copy_partial(
	sgd_tbl_t* sgdt,
	sgd_t** ppsgd,
	MV_PU32 poff,
	MV_U32 size
	);

	void sgdt_append_sgd(
	sgd_tbl_t* sgdt,
	sgd_t* sgd
	);

	#define sgdt_append_reftbl(sgdt,refSgdt,offset,size) \
	sgdt_append_ref(sgdt,refSgdt,offset,size,MV_TRUE)

	#define sgdt_append_refsgd(sgdt,refSgd,offset,size) \
	sgdt_append_ref(sgdt,refSgd,offset,size,MV_FALSE)

	/---------------------------------------------------------------------------/

	int sgdt_prepare_hwprd(
	MV_PVOID pCore,
	sgd_tbl_t* pSource,
	sgd_t* pSg,
	int availSgEntry
	);

	#endif /__MV_COM_SGD_H__/