mvialcommonutils.c

此为marvell 6081芯片驱动源码

        if (iden[IDEN_ENABLED_COMMANDS1] & MV_BIT12)
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "WRITE BUFFER", "supported and enabled");
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "WRITE BUFFER", "supported and disabled");
        }
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "WRITE BUFFER",
				 "Not supported");
    }

    if ((iden[IDEN_SUPPORTED_COMMANDS1] & MV_BIT6))
    {
        pIdentifyInfo->readAheadSupported = MV_TRUE;
        if (iden[IDEN_ENABLED_COMMANDS1] & MV_BIT6)
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "READ LOOK-AHEAD", "supported and enabled");
            pIdentifyInfo->readAheadEnabled = MV_TRUE;
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "READ LOOK-AHEAD", "supported and disabled");
            pIdentifyInfo->readAheadEnabled = MV_FALSE;
        }
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n",
				 "READ LOOK-AHEAD","Not supported");
        pIdentifyInfo->readAheadSupported = MV_FALSE;
        pIdentifyInfo->readAheadEnabled = MV_FALSE;
    }

    if ((iden[IDEN_SUPPORTED_COMMANDS1] & MV_BIT5))
    {
        pIdentifyInfo->writeCacheSupported = MV_TRUE;
        if (iden[IDEN_ENABLED_COMMANDS1] & MV_BIT5)
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "WRITE CACHE", "supported and enabled");
            pIdentifyInfo->writeCacheEnabled = MV_TRUE;
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "WRITE CACHE", "supported and disabled");
            pIdentifyInfo->writeCacheEnabled = MV_FALSE;
        }
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "WRITE CACHE",
				 "Not supported");
        pIdentifyInfo->writeCacheSupported = MV_FALSE;
        pIdentifyInfo->writeCacheEnabled = MV_FALSE;
    }

    if ((iden[IDEN_SUPPORTED_COMMANDS1] & MV_BIT3))
    {

        if (iden[IDEN_ENABLED_COMMANDS1] & MV_BIT3)
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "POWER MANAGMENT", "supported and enabled");
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n",
					 "POWER MANAGMENT", "supported and disabled");
        }

    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n",
				 "POWER MANAGMENT","Not supported");
    }

    if ((iden[IDEN_SUPPORTED_COMMANDS1] & MV_BIT0))
    {

        if (iden[IDEN_ENABLED_COMMANDS1] & MV_BIT0)
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n", "SMART",
                     "supported and enabled");
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %20s\n", "SMART",
                     "supported and disabled");
        }
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "SMART",
				 "Not supported");
    }


    /* check if REAd/WRITE DMA QUEUE commands supported */
    pIdentifyInfo->DMAQueuedModeDepth = (iden[IDEN_QUEUE_DEPTH] & 0x1f) + 1;
    if ((version >= 5) &&(iden[IDEN_SUPPORTED_COMMANDS2] & MV_BIT1))
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %15s Queue Depth %d\n",
				 "READ/WRITE DMA QUEUE","supported",
				 (iden[IDEN_QUEUE_DEPTH] & 0x1f) + 1);
        pIdentifyInfo->DMAQueuedModeSupported = MV_TRUE;
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n",
				 "READ/WRITE DMA QUEUE", "not supported");
        pIdentifyInfo->DMAQueuedModeSupported = MV_FALSE;
    }

    /*check that the non-UDMA ATA commands supported*/

    /*FLUSH CHACHE*/
    if ((version >=6) && ((iden[IDEN_SUPPORTED_COMMANDS2] & MV_BIT12) == 0))
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n",
				 "FLUSH CACHE command", "not supported");
    }
    else
    {
        mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n",
				 "FLUSH CACHE command", "supported");
    }

    pIdentifyInfo->SATACapabilities.SATA_GEN_I_supported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.SATA_GEN_II_supported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.NCQSupported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.RxHostInitiatedPMSupported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.TxDeviceInitiatedPMSupported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.TxDeviceInitiatedPMEnabled = MV_FALSE;
    pIdentifyInfo->SATACapabilities.DMASetupAutoActiveSupported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.DMASetupAutoActiveEnables = MV_FALSE;
    pIdentifyInfo->SATACapabilities.NonZeroBufferOffsetSupported = MV_FALSE;
    pIdentifyInfo->SATACapabilities.NonZeroBufferOffsetEnabled = MV_FALSE;

    if (version >= 6)
    {
        if (iden[IDEN_SATA_CAPABILITIES] & MV_BIT1)
        {
            pIdentifyInfo->SATACapabilities.SATA_GEN_I_supported = MV_TRUE;
        }
        else
        {
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "SATA Gen I",
					 "not supported");
        }
        if (iden[IDEN_SATA_CAPABILITIES] & MV_BIT2)
        {
            pIdentifyInfo->SATACapabilities.SATA_GEN_II_supported = MV_TRUE;
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "SATA Gen II",
					 "supported");
        }

        if (iden[IDEN_SATA_CAPABILITIES] & MV_BIT8)
        {
            pIdentifyInfo->SATACapabilities.NCQSupported = MV_TRUE;         
            mvLogMsg(MV_IAL_COMMON_LOG_ID, MV_DEBUG, "%25s - %s\n", "NCQ",
					 "supported");
        }

        if (iden[IDEN_SATA_CAPABILITIES] & MV_BIT9)
        {
            pIdentifyInfo->SATACapabilities.RxHostInitiatedPMSupported = MV_TRUE;
        }

        if (iden[IDEN_SATA_FEATURES_SUPPORTED] & MV_BIT1)
        {
            pIdentifyInfo->SATACapabilities.NonZeroBufferOffsetSupported = MV_TRUE;
            if (iden[IDEN_SATA_FEATURES_ENABLED] & MV_BIT1)
            {
                pIdentifyInfo->SATACapabilities.NonZeroBufferOffsetEnabled = MV_TRUE;
            }
        }
        if (iden[IDEN_SATA_FEATURES_SUPPORTED] & MV_BIT2)
        {
            pIdentifyInfo->SATACapabilities.DMASetupAutoActiveSupported = MV_TRUE;
            if (iden[IDEN_SATA_FEATURES_ENABLED] & MV_BIT2)
            {
                pIdentifyInfo->SATACapabilities.DMASetupAutoActiveEnables = MV_TRUE;
            }
        }
        if (iden[IDEN_SATA_FEATURES_SUPPORTED] & MV_BIT3)
        {
            pIdentifyInfo->SATACapabilities.TxDeviceInitiatedPMSupported = MV_TRUE;
            if (iden[IDEN_SATA_FEATURES_ENABLED] & MV_BIT3)
            {
                pIdentifyInfo->SATACapabilities.TxDeviceInitiatedPMEnabled = MV_TRUE;
            }
        }
    }

    return MV_TRUE;
}
/*******************************************************************************
* mvGetSataDeviceType - short description
*
* DESCRIPTION:
*       None.
*
* INPUT:
*       None.
*
* OUTPUT:
*       None.
*
* RETURN:
*       None.
*
*******************************************************************************/
MV_SATA_DEVICE_TYPE mvGetSataDeviceType(
                                       MV_STORAGE_DEVICE_REGISTERS *mvStorageDevRegisters)
{
    if (((mvStorageDevRegisters->sectorCountRegister & 0xff) != 1) ||
        ((mvStorageDevRegisters->lbaLowRegister & 0xff) != 1))
    {
        return MV_SATA_DEVICE_TYPE_UNKNOWN;
    }
    if ((((mvStorageDevRegisters->lbaMidRegister & 0xff) == 0) &&
         ((mvStorageDevRegisters->lbaHighRegister & 0xff) == 0)) ||
        (((mvStorageDevRegisters->lbaMidRegister & 0xff) == 0x3C) &&/*ATA-7*/
         ((mvStorageDevRegisters->lbaHighRegister & 0xff) == 0xC3)))
    {
        return MV_SATA_DEVICE_TYPE_ATA_DISK;
    }
    if ((((mvStorageDevRegisters->lbaMidRegister & 0xff) == 0x14) &&
         ((mvStorageDevRegisters->lbaHighRegister & 0xff) == 0xEB))/* ||
         (((mvStorageDevRegisters->lbaMidRegister & 0xff) == 0x69) &&
         ((mvStorageDevRegisters->lbaHighRegister & 0xff) == 0x96))*/)
    {
        return MV_SATA_DEVICE_TYPE_ATAPI_DISK;
    }
    if (((mvStorageDevRegisters->lbaMidRegister & 0xff) == 0x69) &&
        ((mvStorageDevRegisters->lbaHighRegister & 0xff) == 0x96))
    {
        return MV_SATA_DEVICE_TYPE_PM;
    }
    return MV_SATA_DEVICE_TYPE_UNKNOWN;
}

#ifdef MV_LOG_DEBUG
static void printIdentifyBuffer(MV_U16_PTR identifyBuffer)
{    
    MV_U8 i,j;
    /*Print Identify buffer*/
    for (i = 0; i < 0x20; i++) 
    {
        mvLogMsg(MV_RAW_MSG_ID,  0, "Words [%03d-%03d]: ", i*8, i*8+7);
        for (j = 0; j < 0x8; j++) 
        {
            mvLogMsg(MV_RAW_MSG_ID,  0, "0x%04X ", identifyBuffer[i*8+j]);            
        }
        mvLogMsg(MV_RAW_MSG_ID,  0, "\n");        
    }
}
#endif

/*******************************************************************************
* mvConfigSataDisk - short description
*
* DESCRIPTION:
*       None.
*
* INPUT:
*       None.
*
* OUTPUT:
*       None.
*
* RETURN: