drivers/scsi/thor/lib/common/com_util.c - kernel/prism - Git at Google

 #include "com_define.h"
 #include "com_dbg.h"
 #include "com_scsi.h"
 #include "com_util.h"
 #include "com_u64.h"

 #if ERROR_HANDLING_SUPPORT
 void MV_ZeroMvRequest(PMV_Request pReq)
 {
 	PMV_SG_Entry pSGEntry;
 	MV_U8 maxEntryCount;
 	MV_PVOID pSenseBuffer;
 	MV_PVOID pbheh_ctx;
 #ifdef __RES_MGMT__
 	List_Head list;
 #endif
 	MV_DASSERT(pReq);
 	pSGEntry = pReq->SG_Table.Entry_Ptr;
 	maxEntryCount = pReq->SG_Table.Max_Entry_Count;
 	pSenseBuffer = pReq->Sense_Info_Buffer;
 	pbheh_ctx = pReq->bh_eh_ctx;
 #ifdef __RES_MGMT__
 	list = pReq->pool_entry;
 #endif
 	MV_ZeroMemory(pReq, MV_REQUEST_SIZE);
 #ifdef __RES_MGMT__
 	pReq->pool_entry = list;
 #endif
 	pReq->SG_Table.Entry_Ptr = pSGEntry;
 	pReq->SG_Table.Max_Entry_Count = maxEntryCount;
 	pReq->Sense_Info_Buffer = pSenseBuffer;
 	pReq->bh_eh_ctx = pbheh_ctx;
 }
 #else
 void MV_ZeroMvRequest(PMV_Request pReq)
 {
 	PMV_SG_Entry pSGEntry;
 	MV_U8 maxEntryCount;
 	MV_PVOID pSenseBuffer;
 #ifdef __RES_MGMT__
 	List_Head list;
 #endif

 	MV_DASSERT(pReq);
 	pSGEntry = pReq->SG_Table.Entry_Ptr;
 	maxEntryCount = pReq->SG_Table.Max_Entry_Count;
 	pSenseBuffer = pReq->Sense_Info_Buffer;
 #ifdef __RES_MGMT__
 	list = pReq->pool_entry;
 #endif
 	MV_ZeroMemory(pReq, MV_REQUEST_SIZE);
 #ifdef __RES_MGMT__
 	pReq->pool_entry = list;
 #endif
 	pReq->SG_Table.Entry_Ptr = pSGEntry;
 	pReq->SG_Table.Max_Entry_Count = maxEntryCount;
 	pReq->Sense_Info_Buffer = pSenseBuffer;
 }
 #endif

 void MV_CopySGTable(PMV_SG_Table pTargetSGTable, PMV_SG_Table pSourceSGTable)
 {
 	pTargetSGTable->Valid_Entry_Count = pSourceSGTable->Valid_Entry_Count;
 	pTargetSGTable->Flag = pSourceSGTable->Flag;
 	pTargetSGTable->Byte_Count = pSourceSGTable->Byte_Count;
 	MV_CopyMemory(pTargetSGTable->Entry_Ptr, pSourceSGTable->Entry_Ptr,
 					sizeof(MV_SG_Entry)*pTargetSGTable->Valid_Entry_Count);

 }

 #ifdef _OS_BIOS
 MV_U64 CPU_TO_BIG_ENDIAN_64(MV_U64 x)

 {
 	MV_U64 x1;
 	ZeroU64(x1);
 	x1.parts.low=CPU_TO_BIG_ENDIAN_32(x.parts.high);
 	x1.parts.high=CPU_TO_BIG_ENDIAN_32(x.parts.low);
 	return x1;
 }
 #endif	/* #ifdef _OS_BIOS */

 MV_BOOLEAN MV_Equals(
 	IN MV_PU8		des,
 	IN MV_PU8		src,
 	IN MV_U8		len
 )
 {
 	MV_U8 i;

 	for (i=0; i<len; i++){
 		if (*des != *src){
 			return MV_FALSE;
 		}
 		des++;
 		src++;
 	}
 	return MV_TRUE;
 }
 /*
  * SG Table operation
  */
 void SGTable_Init(
 	OUT PMV_SG_Table pSGTable,
 	IN MV_U8 flag
 	)
 {
 /*	pSGTable->Max_Entry_Count = MAX_SG_ENTRY;  set during module init */
 	pSGTable->Valid_Entry_Count = 0;
 	pSGTable->Flag = flag;
 	pSGTable->Byte_Count = 0;
 }

 #ifndef USE_NEW_SGTABLE
 void SGTable_Append(
 	OUT PMV_SG_Table pSGTable,
 	MV_U32 address,
 	MV_U32 addressHigh,
 	MV_U32 size
 	)
 {
 	PMV_SG_Entry pSGEntry;

 	pSGEntry = &pSGTable->Entry_Ptr[pSGTable->Valid_Entry_Count];

 	MV_ASSERT(pSGTable->Valid_Entry_Count < pSGTable->Max_Entry_Count);
 	/*
 	 * Workaround hardware issue:
 	 * If the transfer size is odd, some request cannot be finished.
 	 * Hopefully the workaround won't damage the system.
 	 */
 #ifdef PRD_SIZE_WORD_ALIGN
 	if ( size%2 ) size++;
 #endif

 	pSGTable->Valid_Entry_Count += 1;
 	pSGTable->Byte_Count += size;

 	pSGEntry->Base_Address = address;
 	pSGEntry->Base_Address_High = addressHigh;
 	pSGEntry->Size = size;
 	pSGEntry->Reserved0 = 0;
 }
 #endif

 MV_BOOLEAN SGTable_Available(
 	IN PMV_SG_Table pSGTable
 	)
 {
 	return (pSGTable->Valid_Entry_Count < pSGTable->Max_Entry_Count);
 }

 void MV_InitializeTargetIDTable(
 	IN PMV_Target_ID_Map pMapTable
 	)
 {
 	MV_FillMemory((MV_PVOID)pMapTable, sizeof(MV_Target_ID_Map)*MV_MAX_TARGET_NUMBER, 0xFF);
 }

 MV_U16 MV_MapTargetID(
 	IN PMV_Target_ID_Map	pMapTable,
 	IN MV_U16				deviceId,
 	IN MV_U8				deviceType
 	)
 {
 	MV_U16 i;
 	for (i=0; i<MV_MAX_TARGET_NUMBER; i++) {
 		if (pMapTable[i].Type==0xFF) {	/* not mapped yet */
 			pMapTable[i].Device_Id = deviceId;
 			pMapTable[i].Type = deviceType;
 			break;
 		}
 	}
 	return i;
 }

 MV_U16 MV_MapToSpecificTargetID(
 	IN PMV_Target_ID_Map	pMapTable,
 	IN MV_U16				specificId,
 	IN MV_U16				deviceId,
 	IN MV_U8				deviceType
 	)
 {
 	/* first check if the device can be mapped to the specific ID */
 	if (pMapTable[specificId].Type==0xFF) {	/* not used yet */
 		pMapTable[specificId].Device_Id = deviceId;
 		pMapTable[specificId].Type = deviceType;
 		return specificId;
 	}
 	/* cannot mapped to the specific ID */
 	/* just map the device to first available ID */
 	return MV_MapTargetID(pMapTable, deviceId, deviceType);
 }

 MV_U16 MV_RemoveTargetID(
 	IN PMV_Target_ID_Map	pMapTable,
 	IN MV_U16				deviceId,
 	IN MV_U8				deviceType
 	)
 {
 	MV_U16 i;
 	for (i=0; i<MV_MAX_TARGET_NUMBER; i++) {
 		if ( (pMapTable[i].Type==deviceType) && (pMapTable[i].Device_Id==deviceId) ) {
 			pMapTable[i].Type = 0xFF;
 			pMapTable[i].Device_Id = 0xFFFF;
 			break;
 		}
 	}
 	return i;
 }

 MV_U16 MV_GetMappedID(
 	IN PMV_Target_ID_Map	pMapTable,
 	IN MV_U16				deviceId,
 	IN MV_U8				deviceType
 	)
 {
 	MV_U16 mappedID;
 	for (mappedID=0; mappedID<MV_MAX_TARGET_NUMBER; mappedID++) {
 		if ( (pMapTable[mappedID].Type==deviceType) && (pMapTable[mappedID].Device_Id==deviceId) )
 			break;
 	}
 	if (mappedID >= MV_MAX_TARGET_NUMBER)
 		mappedID = 0xFFFF;
 	else {
 		MV_DASSERT(mappedID < MV_MAX_TARGET_NUMBER);
 #ifdef SUPPORT_SCSI_PASSTHROUGH
 		if (mappedID == VIRTUAL_DEVICE_ID) {
 			/* Device is on LUN 1 */
 			mappedID |= 0x0100;
 		}
 #endif /* SUPPORT_SCSI_PASSTHROUGH */
 	}
 	return mappedID;
 }

 void MV_DecodeReadWriteCDB(
 	IN MV_PU8 Cdb,
 	OUT MV_LBA *pLBA,
 	OUT MV_U32 *pSectorCount)
 {
 	MV_LBA tmpLBA;
 	MV_U32 tmpSectorCount;

 	if ((!SCSI_IS_READ(Cdb[0])) &&
 	    (!SCSI_IS_WRITE(Cdb[0])) &&
 	    (!SCSI_IS_VERIFY(Cdb[0])))
 		return;

 	/* This is READ/WRITE command */
 	switch (Cdb[0]) {
 	case SCSI_CMD_READ_6:
 	case SCSI_CMD_WRITE_6:
 		tmpLBA.value = (MV_U32)((((MV_U32)(Cdb[1] & 0x1F))<<16) |
 					((MV_U32)Cdb[2]<<8) |
 					((MV_U32)Cdb[3]));
 		tmpSectorCount = (MV_U32)Cdb[4];
 		break;
 	case SCSI_CMD_READ_10:
 	case SCSI_CMD_WRITE_10:
 	case SCSI_CMD_VERIFY_10:
 		tmpLBA.value = (MV_U32)(((MV_U32)Cdb[2]<<24) |
 					((MV_U32)Cdb[3]<<16) |
 					((MV_U32)Cdb[4]<<8) |
 					((MV_U32)Cdb[5]));
 		tmpSectorCount = ((MV_U32)Cdb[7]<<8) | (MV_U32)Cdb[8];
 		break;
 	case SCSI_CMD_READ_12:
 	case SCSI_CMD_WRITE_12:
 		tmpLBA.value = (MV_U32)(((MV_U32)Cdb[2]<<24) |
 					((MV_U32)Cdb[3]<<16) |
 					((MV_U32)Cdb[4]<<8) |
 					((MV_U32)Cdb[5]));
 		tmpSectorCount = (MV_U32)(((MV_U32)Cdb[6]<<24) |
 					  ((MV_U32)Cdb[7]<<16) |
 					  ((MV_U32)Cdb[8]<<8) |
 					  ((MV_U32)Cdb[9]));
 		break;
 	case SCSI_CMD_READ_16:
 	case SCSI_CMD_WRITE_16:
 	case SCSI_CMD_VERIFY_16:
 		tmpLBA.parts.high = (MV_U32)(((MV_U32)Cdb[2]<<24) |
 				       ((MV_U32)Cdb[3]<<16) |
 				       ((MV_U32)Cdb[4]<<8) |
 				       ((MV_U32)Cdb[5]));
 		tmpLBA.parts.low = (MV_U32)(((MV_U32)Cdb[6]<<24) |
 				      ((MV_U32)Cdb[7]<<16) |
 				      ((MV_U32)Cdb[8]<<8) |
 				      ((MV_U32)Cdb[9]));

 		tmpSectorCount = (MV_U32)(((MV_U32)Cdb[10]<<24) |
 					  ((MV_U32)Cdb[11]<<16) |
 					  ((MV_U32)Cdb[12]<<8) |
 					  ((MV_U32)Cdb[13]));
 		break;
 	default:
 		MV_DPRINT(("Unsupported READ/WRITE command [%x]\n", Cdb[0]));
 		U64_SET_VALUE(tmpLBA, 0);
 		tmpSectorCount = 0;
 	}
 	*pLBA = tmpLBA;
 	*pSectorCount = tmpSectorCount;
 }

 #ifndef _OS_BIOS
 void MV_DumpRequest(PMV_Request pReq, MV_BOOLEAN detail)
 {
 	MV_DPRINT(("Device[%d] Cdb[%2x,%2x,%2x,%2x, %2x,%2x,%2x,%2x, %2x,%2x,%2x,%2x].\n",
 		pReq->Device_Id,
 		pReq->Cdb[0],
 		pReq->Cdb[1],
 		pReq->Cdb[2],
 		pReq->Cdb[3],
 		pReq->Cdb[4],
 		pReq->Cdb[5],
 		pReq->Cdb[6],
 		pReq->Cdb[7],
 		pReq->Cdb[8],
 		pReq->Cdb[9],
 		pReq->Cdb[10],
 		pReq->Cdb[11]
 		));

 	if ( detail )
 	{
 		MV_DPRINT(("Scsi_Status=0x%x\n", pReq->Scsi_Status));
 		MV_DPRINT(("Tag=0x%x\n", pReq->Tag));
 		MV_DPRINT(("Data_Transfer_Length=%d\n", pReq->Data_Transfer_Length));
 		MV_DPRINT(("Sense_Info_Buffer_Length=%d\n", pReq->Sense_Info_Buffer_Length));
 		MV_DPRINT(("Org_Req : %p\n", pReq->Org_Req));
 	}
 }

 #if defined(SUPPORT_RAID6) && defined(RAID_DRIVER)
 void MV_DumpXORRequest(PMV_XOR_Request pXORReq, MV_BOOLEAN detail)
 {
 	MV_U32 i,j;

 	MV_PRINT("MV_XOR_Request: Type=0x%x, Source count=%d, Target count=%d\n",
 		pXORReq->Request_Type,
 		pXORReq->Source_SG_Table_Count,
 		pXORReq->Target_SG_Table_Count
 		);

 	if ( detail )
 	{
 		MV_PRINT("Source SG table...\n");
 		for ( i=0; i<pXORReq->Source_SG_Table_Count; i++ )
 			MV_DumpSGTable(&pXORReq->Source_SG_Table_List[i]);

 		MV_PRINT("Target SG table...\n");
 		for ( i=0; i<pXORReq->Target_SG_Table_Count; i++ )
 			MV_DumpSGTable(&pXORReq->Target_SG_Table_List[i]);

 		MV_PRINT("Coefficient...\n");
 		for ( i=0; i<pXORReq->Target_SG_Table_Count; i++ ) {
 			for ( j=0; j<pXORReq->Source_SG_Table_Count; j++ ) {
 				MV_PRINT("[%d,%d]=0x%x\n", i, j, pXORReq->Coef[i][j]);
 			}
 		}
 	}
 }
 #endif /* SUPPORT_RAID6 */

 void MV_DumpSGTable(PMV_SG_Table pSGTable)
 {
 #ifdef USE_NEW_SGTABLE
 	sgdt_dump(pSGTable, " ");
 #else
 	PMV_SG_Entry pSGEntry;
 	MV_U32 i;
 	MV_PRINT("SG Table: size(0x%x)\n", pSGTable->Byte_Count);
 	for ( i=0; i<pSGTable->Valid_Entry_Count; i++ )
 	{
 		pSGEntry = &pSGTable->Entry_Ptr[i];
 		MV_PRINT("%d: addr(0x%x-0x%x), size(0x%x).\n",
 			i, pSGEntry->Base_Address_High, pSGEntry->Base_Address, pSGEntry->Size);
 	}
 #endif
 }

 const char* MV_DumpSenseKey(MV_U8 sense)
 {
 	switch ( sense )
 	{
 		case SCSI_SK_NO_SENSE:
 			return "SCSI_SK_NO_SENSE";
 		case SCSI_SK_RECOVERED_ERROR:
 			return "SCSI_SK_RECOVERED_ERROR";
 		case SCSI_SK_NOT_READY:
 			return "SCSI_SK_NOT_READY";
 		case SCSI_SK_MEDIUM_ERROR:
 			return "SCSI_SK_MEDIUM_ERROR";
 		case SCSI_SK_HARDWARE_ERROR:
 			return "SCSI_SK_HARDWARE_ERROR";
 		case SCSI_SK_ILLEGAL_REQUEST:
 			return "SCSI_SK_ILLEGAL_REQUEST";
 		case SCSI_SK_UNIT_ATTENTION:
 			return "SCSI_SK_UNIT_ATTENTION";
 		case SCSI_SK_DATA_PROTECT:
 			return "SCSI_SK_DATA_PROTECT";
 		case SCSI_SK_BLANK_CHECK:
 			return "SCSI_SK_BLANK_CHECK";
 		case SCSI_SK_VENDOR_SPECIFIC:
 			return "SCSI_SK_VENDOR_SPECIFIC";
 		case SCSI_SK_COPY_ABORTED:
 			return "SCSI_SK_COPY_ABORTED";
 		case SCSI_SK_ABORTED_COMMAND:
 			return "SCSI_SK_ABORTED_COMMAND";
 		case SCSI_SK_VOLUME_OVERFLOW:
 			return "SCSI_SK_VOLUME_OVERFLOW";
 		case SCSI_SK_MISCOMPARE:
 			return "SCSI_SK_MISCOMPARE";
 		default:
 			MV_DPRINT(("Unknown sense key 0x%x.\n", sense));
 			return "Unknown sense key";
 	}
 }
 #endif	/* #ifndef _OS_BIOS */

 static MV_U32  BASEATTR crc_tab[] = {
         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
         0x2d02ef8dL
 };

 /* Calculate CRC and generate PD_Reference number */
 MV_U32 MV_CRC(
 	IN	MV_PU8		pData,
 	IN	MV_U16		len
 )
 {
     MV_U16 i;
     MV_U32 crc = MV_MAX_U32;

     for (i = 0;  i < len;  i ++) {
 		crc = crc_tab[(crc ^ pData[i]) & 0xff] ^ (crc >> 8);
     }
     return MV_CPU_TO_BE32(crc);
 }

 #ifdef MV_DEBUG
 void MV_CHECK_OS_SG_TABLE(
 	IN PMV_SG_Table pSGTable
 	)
 {
 #ifndef USE_NEW_SGTABLE
 	/* Check whether there are duplicated entries pointed to the same physical address. */
 	MV_U32 i,j;
 	static MV_BOOLEAN assertSGTable = MV_TRUE;

 	if ( assertSGTable ) {
 		for ( i=0; i<pSGTable->Valid_Entry_Count; i++ ) {
 			for ( j=i+1; j<pSGTable->Valid_Entry_Count; j++ ) {
 				MV_DASSERT( pSGTable->Entry_Ptr[i].Base_Address!=pSGTable->Entry_Ptr[j].Base_Address );
 			}
 		}
 	}
 #endif
 }
 #endif /* MV_DEBUG */

 #ifdef _OS_LINUX

 #if 1//def MV_DEBUG
 /*
  * Insert a new entry between two known consecutive entries.
  *
  * This is only for internal list manipulation where we know
  * the prev/next entries already!
  */

 void list_add_debug(struct list_head *new_list,
 			      struct list_head *prev,
 			      struct list_head *next)
 {
 	if (unlikely(next->prev != prev)) {
 		MV_DPRINT(( "list_add corruption. next->prev should be "
 			"prev (0x%p), but was 0x%p. (next=0x%p).\n",
 			prev, next->prev, next));

 		MV_DPRINT(( "prev=0x%p, prev->next=0x%p,  prev->prev=0x%p"
 			"next=0x%p, next->next=0x%p, next->prev=0x%p.\n",
 			prev, prev->next, prev->prev, next, next->next, next->prev));
 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif

 	}
 	if (unlikely(prev->next != next)) {
 		MV_DPRINT(( "list_add corruption. prev->next should be "
 			"next (0x%p), but was 0x%p. (prev=0x%p).\n",
 			next, prev->next, prev));

 		MV_DPRINT(( "prev=0x%p, prev->next=0x%p,  prev->prev=0x%p,"
 			"next=0x%p, next->next=0x%p, next->prev=0x%p.\n",
 			prev, prev->next, prev->prev, next, next->next, next->prev));

 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif

 	}
 	next->prev = new_list;
 	new_list->next = next;
 	new_list->prev = prev;
 	prev->next = new_list;
 }

 /**
  * list_del - deletes entry from list.
  * @entry: the element to delete from the list.
  * Note: list_empty on entry does not return true after this, the entry is
  * in an undefined state.
  */
 void List_Del(struct list_head *entry)
 {
 	if (unlikely(entry->prev->next != entry)) {
 		MV_DPRINT(("list_del corruption. prev->next should be %p, "
 				"but was %p\n", entry, entry->prev->next));
 		MV_DPRINT(( "entry->next=%p, entry->next->next=%p,  entry->next->prev=%p.\n"
 				"entry->prev=%p, entry->prev->next=%p, entry->prev->prev=%p.\n",
 			entry->prev, entry->next->next, entry->next->prev, entry->prev, entry->prev->next, entry->prev->prev));

 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}
 	if (unlikely(entry->next->prev != entry)) {
 		MV_DPRINT(( "list_del corruption. next->prev should be %p, "
 				"but was %p\n", entry, entry->next->prev));

 		MV_DPRINT(("entry->next=%p, entry->next->next=%p,  entry->next->prev=%p.\n"
 				"entry->prev=%p, entry->prev->next=%p, entry->prev->prev=%p.\n",
 			entry->next, entry->next->next, entry->next->prev, entry->prev, entry->prev->next, entry->prev->prev));

 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}

 	if(likely(entry->prev->next == entry) && likely(entry->next->prev == entry))
 		__list_del(entry->prev, entry->next);

 	entry->next = NULL;
 	entry->prev = NULL;
 }

 #else

 void List_Del(List_Head *entry)
 {
 #ifdef SUPPORT_REQUEST_TIMER
           BUG_ON(!entry);
           BUG_ON(!entry->prev);
           BUG_ON(!entry->next);
 #endif
 //	list_del(entry);	//Not use kernel function, which set next,prev not NULL but LIST_POISON1 under DEBUG mode
 	__list_del(entry->prev, entry->next);
 	entry->next = NULL;
 	entry->prev = NULL;

 //	if((entry->prev) || (entry->next))
 //	__List_Del(entry->prev, entry->next);
 //	entry->next = NULL;
 //	entry->prev = NULL;
 }


 #endif


 void List_Add(List_Head *new_one, List_Head *head)
 {
           BUG_ON(!head);
           BUG_ON(!head->prev);
           BUG_ON(!head->next);

           BUG_ON(!new_one);

 #ifdef MV_DEBUG
 	list_add_debug(new_one, head, head->next);
 #else
 	list_add(new_one, head);
 #endif
         BUG_ON(!new_one->next);
          BUG_ON(!new_one->prev);

 }

 void List_AddTail(List_Head *new_one, List_Head *head)
 {
           BUG_ON(!head);
           BUG_ON(!head->prev);
           BUG_ON(!head->next);

           BUG_ON(!new_one);

 #ifdef MV_DEBUG
 	list_add_debug(new_one, head->prev, head);
 #else
 	list_add_tail(new_one, head);
 #endif
         BUG_ON(!new_one->next);
          BUG_ON(!new_one->prev);

 }


 struct list_head *List_GetFirst(struct list_head *head)
 {
         struct list_head * one = NULL;
           BUG_ON(!head);
           BUG_ON(!head->prev);
           BUG_ON(!head->next);

 	if (unlikely(head->prev->next != head)) {
 		MV_DPRINT(( "List_GetFirst corruption. prev->next should be 0x%p, "
 				"but was 0x%p\n", head, head->prev->next));

 		MV_DPRINT(( "head=0x%p, head->next=0x%p,  head->prev=0x%p,"
 			"head->prev->next=0x%p, head->prev->prev=0x%p.\n",
 			head, head->next, head->prev,  head->prev->next, head->prev->prev));

 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}
 	if (unlikely(head->next->prev != head)) {
 		MV_DPRINT(( "List_GetFirst corruption. next->prev should be 0x%p, "
 				"but was 0x%p\n", head, head->next->prev));

 		MV_DPRINT(( "head=%p, head->next=%p,  head->prev=%p,"
 			"head->next->next=%p, head->next->prev=%p.\n",
 			head, head->next, head->prev, head->next->next, head->next->prev));

 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}

       	if (list_empty(head))
 		return NULL;

         one = head->next;
         BUG_ON(!one->next);
         BUG_ON(!one->prev);
       	List_Del(one);

 	if (unlikely(head->prev->next != head)) {
 		MV_DPRINT(( "List_GetFirst after del corruption. prev->next should be 0x%p, "
 				"but was 0x%p\n", head, head->prev->next));
 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}
 	if (unlikely(head->next->prev != head)) {
 		MV_DPRINT(("List_GetFirst after del corruption. next->prev should be 0x%p, "
 				"but was 0x%p\n", head, head->next->prev));
 #ifdef MV_LINUX_KGDB
 		MV_DASSERT(0);
 #endif
 	}

         return one;
 }

 struct list_head *List_GetLast(struct list_head *head)
 {
         struct list_head * one = NULL;
             BUG_ON(!head);
           BUG_ON(!head->prev);
           BUG_ON(!head->next);
         if (list_empty(head))
 		return NULL;

         one = head->prev;
          BUG_ON(!one->next);
         BUG_ON(!one->prev);
         List_Del(one);
         return one;
 }


 #endif
	#include "com_define.h"
	#include "com_dbg.h"
	#include "com_scsi.h"
	#include "com_util.h"
	#include "com_u64.h"

	#if ERROR_HANDLING_SUPPORT
	void MV_ZeroMvRequest(PMV_Request pReq)
	{
	PMV_SG_Entry pSGEntry;
	MV_U8 maxEntryCount;
	MV_PVOID pSenseBuffer;
	MV_PVOID pbheh_ctx;
	#ifdef __RES_MGMT__
	List_Head list;
	#endif
	MV_DASSERT(pReq);
	pSGEntry = pReq->SG_Table.Entry_Ptr;
	maxEntryCount = pReq->SG_Table.Max_Entry_Count;
	pSenseBuffer = pReq->Sense_Info_Buffer;
	pbheh_ctx = pReq->bh_eh_ctx;
	#ifdef __RES_MGMT__
	list = pReq->pool_entry;
	#endif
	MV_ZeroMemory(pReq, MV_REQUEST_SIZE);
	#ifdef __RES_MGMT__
	pReq->pool_entry = list;
	#endif
	pReq->SG_Table.Entry_Ptr = pSGEntry;
	pReq->SG_Table.Max_Entry_Count = maxEntryCount;
	pReq->Sense_Info_Buffer = pSenseBuffer;
	pReq->bh_eh_ctx = pbheh_ctx;
	}
	#else
	void MV_ZeroMvRequest(PMV_Request pReq)
	{
	PMV_SG_Entry pSGEntry;
	MV_U8 maxEntryCount;
	MV_PVOID pSenseBuffer;
	#ifdef __RES_MGMT__
	List_Head list;
	#endif

	MV_DASSERT(pReq);
	pSGEntry = pReq->SG_Table.Entry_Ptr;
	maxEntryCount = pReq->SG_Table.Max_Entry_Count;
	pSenseBuffer = pReq->Sense_Info_Buffer;
	#ifdef __RES_MGMT__
	list = pReq->pool_entry;
	#endif
	MV_ZeroMemory(pReq, MV_REQUEST_SIZE);
	#ifdef __RES_MGMT__
	pReq->pool_entry = list;
	#endif
	pReq->SG_Table.Entry_Ptr = pSGEntry;
	pReq->SG_Table.Max_Entry_Count = maxEntryCount;
	pReq->Sense_Info_Buffer = pSenseBuffer;
	}
	#endif

	void MV_CopySGTable(PMV_SG_Table pTargetSGTable, PMV_SG_Table pSourceSGTable)
	{
	pTargetSGTable->Valid_Entry_Count = pSourceSGTable->Valid_Entry_Count;
	pTargetSGTable->Flag = pSourceSGTable->Flag;
	pTargetSGTable->Byte_Count = pSourceSGTable->Byte_Count;
	MV_CopyMemory(pTargetSGTable->Entry_Ptr, pSourceSGTable->Entry_Ptr,
	sizeof(MV_SG_Entry)*pTargetSGTable->Valid_Entry_Count);

	}

	#ifdef _OS_BIOS
	MV_U64 CPU_TO_BIG_ENDIAN_64(MV_U64 x)

	{
	MV_U64 x1;
	ZeroU64(x1);
	x1.parts.low=CPU_TO_BIG_ENDIAN_32(x.parts.high);
	x1.parts.high=CPU_TO_BIG_ENDIAN_32(x.parts.low);
	return x1;
	}
	#endif /* #ifdef _OS_BIOS */

	MV_BOOLEAN MV_Equals(
	IN MV_PU8 des,
	IN MV_PU8 src,
	IN MV_U8 len
	)
	{
	MV_U8 i;

	for (i=0; i<len; i++){
	if (des != src){
	return MV_FALSE;
	}
	des++;
	src++;
	}
	return MV_TRUE;
	}
	/*
	* SG Table operation
	*/
	void SGTable_Init(
	OUT PMV_SG_Table pSGTable,
	IN MV_U8 flag
	)
	{
	/* pSGTable->Max_Entry_Count = MAX_SG_ENTRY; set during module init */
	pSGTable->Valid_Entry_Count = 0;
	pSGTable->Flag = flag;
	pSGTable->Byte_Count = 0;
	}

	#ifndef USE_NEW_SGTABLE
	void SGTable_Append(
	OUT PMV_SG_Table pSGTable,
	MV_U32 address,
	MV_U32 addressHigh,
	MV_U32 size
	)
	{
	PMV_SG_Entry pSGEntry;

	pSGEntry = &pSGTable->Entry_Ptr[pSGTable->Valid_Entry_Count];

	MV_ASSERT(pSGTable->Valid_Entry_Count < pSGTable->Max_Entry_Count);
	/*
	* Workaround hardware issue:
	* If the transfer size is odd, some request cannot be finished.
	* Hopefully the workaround won't damage the system.
	*/
	#ifdef PRD_SIZE_WORD_ALIGN
	if ( size%2 ) size++;
	#endif

	pSGTable->Valid_Entry_Count += 1;
	pSGTable->Byte_Count += size;

	pSGEntry->Base_Address = address;
	pSGEntry->Base_Address_High = addressHigh;
	pSGEntry->Size = size;
	pSGEntry->Reserved0 = 0;
	}
	#endif

	MV_BOOLEAN SGTable_Available(
	IN PMV_SG_Table pSGTable
	)
	{
	return (pSGTable->Valid_Entry_Count < pSGTable->Max_Entry_Count);
	}

	void MV_InitializeTargetIDTable(
	IN PMV_Target_ID_Map pMapTable
	)
	{
	MV_FillMemory((MV_PVOID)pMapTable, sizeof(MV_Target_ID_Map)*MV_MAX_TARGET_NUMBER, 0xFF);
	}

	MV_U16 MV_MapTargetID(
	IN PMV_Target_ID_Map pMapTable,
	IN MV_U16 deviceId,
	IN MV_U8 deviceType
	)
	{
	MV_U16 i;
	for (i=0; i<MV_MAX_TARGET_NUMBER; i++) {
	if (pMapTable[i].Type==0xFF) { /* not mapped yet */
	pMapTable[i].Device_Id = deviceId;
	pMapTable[i].Type = deviceType;
	break;
	}
	}
	return i;
	}

	MV_U16 MV_MapToSpecificTargetID(
	IN PMV_Target_ID_Map pMapTable,
	IN MV_U16 specificId,
	IN MV_U16 deviceId,
	IN MV_U8 deviceType
	)
	{
	/* first check if the device can be mapped to the specific ID */
	if (pMapTable[specificId].Type==0xFF) { /* not used yet */
	pMapTable[specificId].Device_Id = deviceId;
	pMapTable[specificId].Type = deviceType;
	return specificId;
	}
	/* cannot mapped to the specific ID */
	/* just map the device to first available ID */
	return MV_MapTargetID(pMapTable, deviceId, deviceType);
	}

	MV_U16 MV_RemoveTargetID(
	IN PMV_Target_ID_Map pMapTable,
	IN MV_U16 deviceId,
	IN MV_U8 deviceType
	)
	{
	MV_U16 i;
	for (i=0; i<MV_MAX_TARGET_NUMBER; i++) {
	if ( (pMapTable[i].Type==deviceType) && (pMapTable[i].Device_Id==deviceId) ) {
	pMapTable[i].Type = 0xFF;
	pMapTable[i].Device_Id = 0xFFFF;
	break;
	}
	}
	return i;
	}

	MV_U16 MV_GetMappedID(
	IN PMV_Target_ID_Map pMapTable,
	IN MV_U16 deviceId,
	IN MV_U8 deviceType
	)
	{
	MV_U16 mappedID;
	for (mappedID=0; mappedID<MV_MAX_TARGET_NUMBER; mappedID++) {
	if ( (pMapTable[mappedID].Type==deviceType) && (pMapTable[mappedID].Device_Id==deviceId) )
	break;
	}
	if (mappedID >= MV_MAX_TARGET_NUMBER)
	mappedID = 0xFFFF;
	else {
	MV_DASSERT(mappedID < MV_MAX_TARGET_NUMBER);
	#ifdef SUPPORT_SCSI_PASSTHROUGH
	if (mappedID == VIRTUAL_DEVICE_ID) {
	/* Device is on LUN 1 */
	mappedID \|= 0x0100;
	}
	#endif /* SUPPORT_SCSI_PASSTHROUGH */
	}
	return mappedID;
	}

	void MV_DecodeReadWriteCDB(
	IN MV_PU8 Cdb,
	OUT MV_LBA *pLBA,
	OUT MV_U32 *pSectorCount)
	{
	MV_LBA tmpLBA;
	MV_U32 tmpSectorCount;

	if ((!SCSI_IS_READ(Cdb[0])) &&
	(!SCSI_IS_WRITE(Cdb[0])) &&
	(!SCSI_IS_VERIFY(Cdb[0])))
	return;

	/* This is READ/WRITE command */
	switch (Cdb[0]) {
	case SCSI_CMD_READ_6:
	case SCSI_CMD_WRITE_6:
	tmpLBA.value = (MV_U32)((((MV_U32)(Cdb[1] & 0x1F))<<16) \|
	((MV_U32)Cdb[2]<<8) \|
	((MV_U32)Cdb[3]));
	tmpSectorCount = (MV_U32)Cdb[4];
	break;
	case SCSI_CMD_READ_10:
	case SCSI_CMD_WRITE_10:
	case SCSI_CMD_VERIFY_10:
	tmpLBA.value = (MV_U32)(((MV_U32)Cdb[2]<<24) \|
	((MV_U32)Cdb[3]<<16) \|
	((MV_U32)Cdb[4]<<8) \|
	((MV_U32)Cdb[5]));
	tmpSectorCount = ((MV_U32)Cdb[7]<<8) \| (MV_U32)Cdb[8];
	break;
	case SCSI_CMD_READ_12:
	case SCSI_CMD_WRITE_12:
	tmpLBA.value = (MV_U32)(((MV_U32)Cdb[2]<<24) \|
	((MV_U32)Cdb[3]<<16) \|
	((MV_U32)Cdb[4]<<8) \|
	((MV_U32)Cdb[5]));
	tmpSectorCount = (MV_U32)(((MV_U32)Cdb[6]<<24) \|
	((MV_U32)Cdb[7]<<16) \|
	((MV_U32)Cdb[8]<<8) \|
	((MV_U32)Cdb[9]));
	break;
	case SCSI_CMD_READ_16:
	case SCSI_CMD_WRITE_16:
	case SCSI_CMD_VERIFY_16:
	tmpLBA.parts.high = (MV_U32)(((MV_U32)Cdb[2]<<24) \|
	((MV_U32)Cdb[3]<<16) \|
	((MV_U32)Cdb[4]<<8) \|
	((MV_U32)Cdb[5]));
	tmpLBA.parts.low = (MV_U32)(((MV_U32)Cdb[6]<<24) \|
	((MV_U32)Cdb[7]<<16) \|
	((MV_U32)Cdb[8]<<8) \|
	((MV_U32)Cdb[9]));

	tmpSectorCount = (MV_U32)(((MV_U32)Cdb[10]<<24) \|
	((MV_U32)Cdb[11]<<16) \|
	((MV_U32)Cdb[12]<<8) \|
	((MV_U32)Cdb[13]));
	break;
	default:
	MV_DPRINT(("Unsupported READ/WRITE command [%x]\n", Cdb[0]));
	U64_SET_VALUE(tmpLBA, 0);
	tmpSectorCount = 0;
	}
	*pLBA = tmpLBA;
	*pSectorCount = tmpSectorCount;
	}

	#ifndef _OS_BIOS
	void MV_DumpRequest(PMV_Request pReq, MV_BOOLEAN detail)
	{
	MV_DPRINT(("Device[%d] Cdb[%2x,%2x,%2x,%2x, %2x,%2x,%2x,%2x, %2x,%2x,%2x,%2x].\n",
	pReq->Device_Id,
	pReq->Cdb[0],
	pReq->Cdb[1],
	pReq->Cdb[2],
	pReq->Cdb[3],
	pReq->Cdb[4],
	pReq->Cdb[5],
	pReq->Cdb[6],
	pReq->Cdb[7],
	pReq->Cdb[8],
	pReq->Cdb[9],
	pReq->Cdb[10],
	pReq->Cdb[11]
	));

	if ( detail )
	{
	MV_DPRINT(("Scsi_Status=0x%x\n", pReq->Scsi_Status));
	MV_DPRINT(("Tag=0x%x\n", pReq->Tag));
	MV_DPRINT(("Data_Transfer_Length=%d\n", pReq->Data_Transfer_Length));
	MV_DPRINT(("Sense_Info_Buffer_Length=%d\n", pReq->Sense_Info_Buffer_Length));
	MV_DPRINT(("Org_Req : %p\n", pReq->Org_Req));
	}
	}

	#if defined(SUPPORT_RAID6) && defined(RAID_DRIVER)
	void MV_DumpXORRequest(PMV_XOR_Request pXORReq, MV_BOOLEAN detail)
	{
	MV_U32 i,j;

	MV_PRINT("MV_XOR_Request: Type=0x%x, Source count=%d, Target count=%d\n",
	pXORReq->Request_Type,
	pXORReq->Source_SG_Table_Count,
	pXORReq->Target_SG_Table_Count
	);

	if ( detail )
	{
	MV_PRINT("Source SG table...\n");
	for ( i=0; i<pXORReq->Source_SG_Table_Count; i++ )
	MV_DumpSGTable(&pXORReq->Source_SG_Table_List[i]);

	MV_PRINT("Target SG table...\n");
	for ( i=0; i<pXORReq->Target_SG_Table_Count; i++ )
	MV_DumpSGTable(&pXORReq->Target_SG_Table_List[i]);

	MV_PRINT("Coefficient...\n");
	for ( i=0; i<pXORReq->Target_SG_Table_Count; i++ ) {
	for ( j=0; j<pXORReq->Source_SG_Table_Count; j++ ) {
	MV_PRINT("[%d,%d]=0x%x\n", i, j, pXORReq->Coef[i][j]);
	}
	}
	}
	}
	#endif /* SUPPORT_RAID6 */

	void MV_DumpSGTable(PMV_SG_Table pSGTable)
	{
	#ifdef USE_NEW_SGTABLE
	sgdt_dump(pSGTable, " ");
	#else
	PMV_SG_Entry pSGEntry;
	MV_U32 i;
	MV_PRINT("SG Table: size(0x%x)\n", pSGTable->Byte_Count);
	for ( i=0; i<pSGTable->Valid_Entry_Count; i++ )
	{
	pSGEntry = &pSGTable->Entry_Ptr[i];
	MV_PRINT("%d: addr(0x%x-0x%x), size(0x%x).\n",
	i, pSGEntry->Base_Address_High, pSGEntry->Base_Address, pSGEntry->Size);
	}
	#endif
	}

	const char* MV_DumpSenseKey(MV_U8 sense)
	{
	switch ( sense )
	{
	case SCSI_SK_NO_SENSE:
	return "SCSI_SK_NO_SENSE";
	case SCSI_SK_RECOVERED_ERROR:
	return "SCSI_SK_RECOVERED_ERROR";
	case SCSI_SK_NOT_READY:
	return "SCSI_SK_NOT_READY";
	case SCSI_SK_MEDIUM_ERROR:
	return "SCSI_SK_MEDIUM_ERROR";
	case SCSI_SK_HARDWARE_ERROR:
	return "SCSI_SK_HARDWARE_ERROR";
	case SCSI_SK_ILLEGAL_REQUEST:
	return "SCSI_SK_ILLEGAL_REQUEST";
	case SCSI_SK_UNIT_ATTENTION:
	return "SCSI_SK_UNIT_ATTENTION";
	case SCSI_SK_DATA_PROTECT:
	return "SCSI_SK_DATA_PROTECT";
	case SCSI_SK_BLANK_CHECK:
	return "SCSI_SK_BLANK_CHECK";
	case SCSI_SK_VENDOR_SPECIFIC:
	return "SCSI_SK_VENDOR_SPECIFIC";
	case SCSI_SK_COPY_ABORTED:
	return "SCSI_SK_COPY_ABORTED";
	case SCSI_SK_ABORTED_COMMAND:
	return "SCSI_SK_ABORTED_COMMAND";
	case SCSI_SK_VOLUME_OVERFLOW:
	return "SCSI_SK_VOLUME_OVERFLOW";
	case SCSI_SK_MISCOMPARE:
	return "SCSI_SK_MISCOMPARE";
	default:
	MV_DPRINT(("Unknown sense key 0x%x.\n", sense));
	return "Unknown sense key";
	}
	}
	#endif /* #ifndef _OS_BIOS */

	static MV_U32 BASEATTR crc_tab[] = {
	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
	0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
	0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
	0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
	0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
	0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
	0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
	0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
	0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
	0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
	0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
	0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
	0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
	0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
	0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
	0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
	0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
	0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
	0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
	0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
	0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
	0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
	0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
	0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
	0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
	0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
	0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
	0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
	0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
	0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
	0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
	0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
	0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
	0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
	0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
	0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
	0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
	0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
	0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
	0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
	0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
	0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
	0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
	0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
	0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
	0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
	0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
	0x2d02ef8dL
	};

	/* Calculate CRC and generate PD_Reference number */
	MV_U32 MV_CRC(
	IN MV_PU8 pData,
	IN MV_U16 len
	)
	{
	MV_U16 i;
	MV_U32 crc = MV_MAX_U32;

	for (i = 0; i < len; i ++) {
	crc = crc_tab[(crc ^ pData[i]) & 0xff] ^ (crc >> 8);
	}
	return MV_CPU_TO_BE32(crc);
	}

	#ifdef MV_DEBUG
	void MV_CHECK_OS_SG_TABLE(
	IN PMV_SG_Table pSGTable
	)
	{
	#ifndef USE_NEW_SGTABLE
	/* Check whether there are duplicated entries pointed to the same physical address. */
	MV_U32 i,j;
	static MV_BOOLEAN assertSGTable = MV_TRUE;

	if ( assertSGTable ) {
	for ( i=0; i<pSGTable->Valid_Entry_Count; i++ ) {
	for ( j=i+1; j<pSGTable->Valid_Entry_Count; j++ ) {
	MV_DASSERT( pSGTable->Entry_Ptr[i].Base_Address!=pSGTable->Entry_Ptr[j].Base_Address );
	}
	}
	}
	#endif
	}
	#endif /* MV_DEBUG */

	#ifdef _OS_LINUX

	#if 1//def MV_DEBUG
	/*
	* Insert a new entry between two known consecutive entries.
	*
	* This is only for internal list manipulation where we know
	* the prev/next entries already!
	*/

	void list_add_debug(struct list_head *new_list,
	struct list_head *prev,
	struct list_head *next)
	{
	if (unlikely(next->prev != prev)) {
	MV_DPRINT(( "list_add corruption. next->prev should be "
	"prev (0x%p), but was 0x%p. (next=0x%p).\n",
	prev, next->prev, next));

	MV_DPRINT(( "prev=0x%p, prev->next=0x%p, prev->prev=0x%p"
	"next=0x%p, next->next=0x%p, next->prev=0x%p.\n",
	prev, prev->next, prev->prev, next, next->next, next->prev));
	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif

	}
	if (unlikely(prev->next != next)) {
	MV_DPRINT(( "list_add corruption. prev->next should be "
	"next (0x%p), but was 0x%p. (prev=0x%p).\n",
	next, prev->next, prev));

	MV_DPRINT(( "prev=0x%p, prev->next=0x%p, prev->prev=0x%p,"
	"next=0x%p, next->next=0x%p, next->prev=0x%p.\n",
	prev, prev->next, prev->prev, next, next->next, next->prev));

	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif

	}
	next->prev = new_list;
	new_list->next = next;
	new_list->prev = prev;
	prev->next = new_list;
	}

	/**
	* list_del - deletes entry from list.
	* @entry: the element to delete from the list.
	* Note: list_empty on entry does not return true after this, the entry is
	* in an undefined state.
	*/
	void List_Del(struct list_head *entry)
	{
	if (unlikely(entry->prev->next != entry)) {
	MV_DPRINT(("list_del corruption. prev->next should be %p, "
	"but was %p\n", entry, entry->prev->next));
	MV_DPRINT(( "entry->next=%p, entry->next->next=%p, entry->next->prev=%p.\n"
	"entry->prev=%p, entry->prev->next=%p, entry->prev->prev=%p.\n",
	entry->prev, entry->next->next, entry->next->prev, entry->prev, entry->prev->next, entry->prev->prev));

	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}
	if (unlikely(entry->next->prev != entry)) {
	MV_DPRINT(( "list_del corruption. next->prev should be %p, "
	"but was %p\n", entry, entry->next->prev));

	MV_DPRINT(("entry->next=%p, entry->next->next=%p, entry->next->prev=%p.\n"
	"entry->prev=%p, entry->prev->next=%p, entry->prev->prev=%p.\n",
	entry->next, entry->next->next, entry->next->prev, entry->prev, entry->prev->next, entry->prev->prev));

	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}

	if(likely(entry->prev->next == entry) && likely(entry->next->prev == entry))
	__list_del(entry->prev, entry->next);

	entry->next = NULL;
	entry->prev = NULL;
	}

	#else

	void List_Del(List_Head *entry)
	{
	#ifdef SUPPORT_REQUEST_TIMER
	BUG_ON(!entry);
	BUG_ON(!entry->prev);
	BUG_ON(!entry->next);
	#endif
	// list_del(entry); //Not use kernel function, which set next,prev not NULL but LIST_POISON1 under DEBUG mode
	__list_del(entry->prev, entry->next);
	entry->next = NULL;
	entry->prev = NULL;

	// if((entry->prev) \|\| (entry->next))
	// __List_Del(entry->prev, entry->next);
	// entry->next = NULL;
	// entry->prev = NULL;
	}


	#endif


	void List_Add(List_Head new_one, List_Head head)
	{
	BUG_ON(!head);
	BUG_ON(!head->prev);
	BUG_ON(!head->next);

	BUG_ON(!new_one);

	#ifdef MV_DEBUG
	list_add_debug(new_one, head, head->next);
	#else
	list_add(new_one, head);
	#endif
	BUG_ON(!new_one->next);
	BUG_ON(!new_one->prev);

	}

	void List_AddTail(List_Head new_one, List_Head head)
	{
	BUG_ON(!head);
	BUG_ON(!head->prev);
	BUG_ON(!head->next);

	BUG_ON(!new_one);

	#ifdef MV_DEBUG
	list_add_debug(new_one, head->prev, head);
	#else
	list_add_tail(new_one, head);
	#endif
	BUG_ON(!new_one->next);
	BUG_ON(!new_one->prev);

	}



	struct list_head List_GetFirst(struct list_head head)
	{
	struct list_head * one = NULL;
	BUG_ON(!head);
	BUG_ON(!head->prev);
	BUG_ON(!head->next);

	if (unlikely(head->prev->next != head)) {
	MV_DPRINT(( "List_GetFirst corruption. prev->next should be 0x%p, "
	"but was 0x%p\n", head, head->prev->next));

	MV_DPRINT(( "head=0x%p, head->next=0x%p, head->prev=0x%p,"
	"head->prev->next=0x%p, head->prev->prev=0x%p.\n",
	head, head->next, head->prev, head->prev->next, head->prev->prev));

	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}
	if (unlikely(head->next->prev != head)) {
	MV_DPRINT(( "List_GetFirst corruption. next->prev should be 0x%p, "
	"but was 0x%p\n", head, head->next->prev));

	MV_DPRINT(( "head=%p, head->next=%p, head->prev=%p,"
	"head->next->next=%p, head->next->prev=%p.\n",
	head, head->next, head->prev, head->next->next, head->next->prev));

	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}

	if (list_empty(head))
	return NULL;

	one = head->next;
	BUG_ON(!one->next);
	BUG_ON(!one->prev);
	List_Del(one);

	if (unlikely(head->prev->next != head)) {
	MV_DPRINT(( "List_GetFirst after del corruption. prev->next should be 0x%p, "
	"but was 0x%p\n", head, head->prev->next));
	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}
	if (unlikely(head->next->prev != head)) {
	MV_DPRINT(("List_GetFirst after del corruption. next->prev should be 0x%p, "
	"but was 0x%p\n", head, head->next->prev));
	#ifdef MV_LINUX_KGDB
	MV_DASSERT(0);
	#endif
	}

	return one;
	}

	struct list_head List_GetLast(struct list_head head)
	{
	struct list_head * one = NULL;
	BUG_ON(!head);
	BUG_ON(!head->prev);
	BUG_ON(!head->next);
	if (list_empty(head))
	return NULL;

	one = head->prev;
	BUG_ON(!one->next);
	BUG_ON(!one->prev);
	List_Del(one);
	return one;
	}



	#endif