| #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 |
| |