core_exp.c

6440linuxDriver的源代码

#include "core_header.h"
#include "core_helper.h"

#ifdef _OS_BIOS
#include "biosmain.h"
extern PMV_DATA_STRUCT BASEATTR MyDriverDataBaseOff;
#endif

#include "core_exp.h"
#include "core_ibcd.h"
#include "core_init.h"
#include "core_api.h"
#include "core_xor.h"

#ifndef _OS_BIOS
/* For debug purpose only. */
static PCore_Driver_Extension gCore = NULL;
#endif

extern MV_BOOLEAN Category_CDB_Type(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq
	);

extern MV_BOOLEAN ATAPI_CDB2TaskFile(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	OUT PATA_TaskFile pTaskFile
	);

extern MV_BOOLEAN ATA_CDB2TaskFile(
	IN PDomain_Device pDevice,
	IN PMV_Request pReq, 
	IN MV_U8 tag,	//TBD: Do we really need it?
	OUT PATA_TaskFile pTaskFile
	);

extern MV_BOOLEAN Core_pass_thru_fill_taskfile(
	IN PMV_Request pReq,
	OUT PATA_TaskFile pTaskFile
	);

extern void UpdateWidePortPhyMap(
	PCore_Driver_Extension pCore
	);

extern void UpdatePhyInfo(
	PCore_Driver_Extension pCore, 
	MV_U8 i
	);

extern void DiscoveryCallBack(
	IN MV_PVOID pDiscoveryExtension,
	IN MV_PVOID This
	);

#ifdef SUPPORT_I2C
extern MV_QUEUE_COMMAND_RESULT I2C_PrepareAndSendCommand(
	IN PCore_Driver_Extension pCore,
	IN PMV_Request pReq
	);

extern MV_BOOLEAN I2C_InterruptServiceRoutine(MV_PVOID This);
#endif

extern MV_VOID SCSI_To_FIS(MV_PVOID pCore, PMV_Request pReq, PMV_Command_Table pCmdTable, PATA_TaskFile pTaskFile);

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
extern MV_BOOLEAN
SCSI_MakeSMARTReturnStatusCommand(
	PCore_Driver_Extension pCore,
	PMV_Request pReq
	);

extern MV_VOID
SCSI_MakeSynchronizeCacheCommmand(
	PCore_Driver_Extension pCore,
	PMV_Request pReq
	);

extern MV_BOOLEAN
SCSI_MakeCacheCommand(
	PCore_Driver_Extension pCore,
	PMV_Request pReq,
	MV_BOOLEAN writeCache,
	MV_BOOLEAN preread
	);
#endif

extern MV_BOOLEAN 
mvChannelStateMachine(
	PCore_Driver_Extension pCore,
	PDomain_Port pPort
	);

extern void CompleteRequest(
	IN PCore_Driver_Extension pCore,
	IN PMV_Request pReq,
	IN MV_U8 RegSet
	);

extern void CompleteRequestAndSlot(
	IN PCore_Driver_Extension pCore,
	IN PMV_Request pReq,
	IN PATA_TaskFile taskFiles
	);

#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
extern void CoreRestoreOriginalCDB(PCore_Driver_Extension pCore, PMV_Request pReq);
#endif

//TBD: In Dump. How many request can be? Not always 1.
static MV_U32 __core_ops_get_res_desc(enum Resource_Type type, MV_U16 maxIo)
{
	MV_U32 size = 0;
	MV_U8 devCount, expanderCount, pmCount, sgEntryCount, internalReqCount;
	MV_U8 SATAScratchCount, SMPScratchCount;
	MV_U16 slotCount, sgBufferCount;
	MV_U16 contextCount;
#ifndef SOFTWARE_XOR
	MV_U32 tmpSize1, tmpSize2;
#endif
	MV_U16 subReqCount;


	/*Init variable */
	devCount = expanderCount = pmCount = sgEntryCount = internalReqCount \
	= SATAScratchCount = SMPScratchCount = 0;
	slotCount = sgBufferCount = contextCount = 0;

	/* Decide values based on driver mode */
	Core_GetSupportedCounts(maxIo,
				&devCount,
				&expanderCount,
				&pmCount,
				&internalReqCount,
				&sgEntryCount,
				&sgBufferCount,
				&SATAScratchCount,
				&SMPScratchCount,
				&slotCount,
				&contextCount,
				&subReqCount);

#ifndef SOFTWARE_XOR
#ifndef RAID6_HARDWARE_XOR
	MV_ASSERT( MAX_XOR_TABLE_PER_XOR_REQUEST==1 );
#endif
#endif

	/* Extension quota */
	if ( type==RESOURCE_CACHED_MEMORY )		
	{
		MV_U32 DiscSize;

		size = ROUNDING(sizeof(Core_Driver_Extension), 8);
		/* Memory for Domain_Device */
		size += ROUNDING(sizeof(Domain_Device) * devCount, 8);
		/* Memory for Domain_Expander */
		size += ROUNDING(sizeof(Domain_Expander) * expanderCount, 8);
	#ifdef SUPPORT_PM
		/* Memory for Domain_PM */
		size += ROUNDING(sizeof(Domain_PM) * pmCount, 8);
	#endif
		/* Memory for Running_Req */
		size += ROUNDING(sizeof(PMV_Request) * slotCount, 8);

		/* 
		 * If performance mode, need memory to support expander 
		 * routing table
		 */
		if (maxIo == MAX_REQUEST_NUMBER_PERFORMANCE) 
			size += expanderCount * ROUNDING(sizeof(struct _Route_Table_Entry) * (MAX_PHY_NUM * MAX_ROUTE_INDEX), 8);

		size += internalReqCount*sizeof(MV_Request);
		size += sizeof(MV_SG_Entry) * sgEntryCount * internalReqCount;
		/* 
		 * the SATA scratch buffer size allocated here is 
		 * just the wrapper - buffer itself will still be in 
		 * uncached memory. SMP Scratch buffer is just 
		 * SMPRequest struct so it resides entirely in cached memory
		 */
		size += ROUNDING((sizeof(SATA_Scratch_Buffer) * SATAScratchCount + sizeof(SMP_Scratch_Buffer) * SMPScratchCount), 8);
		
		/*
		 * Allocate space for SG buffer wrapper - buffer itself will still
		 * be in uncached memory */
		size += ROUNDING((sizeof(SG_Buffer) * sgBufferCount), 8);

		/* Tag pools */
		/* Special case here: In hibernation we must handle only one request
			at a time, but we also need 2 slots in order for completion queue
			entry pointer to work properly. Therefore, slotCount will be
			allocated to 2 during hibernation but we only give one tag in the 
			pool; same for XOR slots */
		if( maxIo==1 )
			size += ROUNDING(((1 + devCount + pmCount + expanderCount + MAX_PORT_NUMBER) * sizeof(MV_U16)), 8);
		else
			size += ROUNDING(((slotCount + devCount + pmCount + expanderCount + MAX_PORT_NUMBER) * sizeof(MV_U16)), 8);

#ifndef SOFTWARE_XOR
		/* Memory for XOR_Running_Req */
		size += ROUNDING(sizeof(PMV_XOR_Request) * slotCount, 8);

	#ifdef RAID6_HARDWARE_XOR
		/* Memory for XOR Table Buffer wrapper */
		size += ROUNDING(sizeof(XOR_Table_Wrapper) * slotCount * MAX_XOR_TABLE_PER_XOR_REQUEST, 8);
		size += ROUNDING(sizeof(CORE_XOR_CONTEXT) * slotCount, 8);
	#endif
		/* Xor request Tag pool */
		if( maxIo==1 )
			size += ROUNDING(1 * sizeof(MV_U16), 8);
		else
			size += ROUNDING(slotCount * sizeof(MV_U16), 8);
#endif

	#ifdef SUPPORT_CONSOLIDATE
		if ( maxIo>1 )
		{
			size += ROUNDING(sizeof(Consolidate_Extension), 8);
			size += ROUNDING(sizeof(Consolidate_Device), 8) * devCount;
			/* resource for consolidate request */
			size += sizeof(MV_Request) * slotCount;
			/* resource for Consolidate_Extension->Requests[] SG Entry */
			size += sizeof(MV_SG_Entry) * sgEntryCount * slotCount;
		}
	#endif

	#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
		size += contextCount*sizeof(CORE_CONTEXT);
	#endif /* CORE_SAS_SUPPORT_ATA_COMMAND */

#ifdef SUPPORT_LARGE_REQUEST
		size += subReqCount * sizeof(MV_Request);
        size += sizeof(MV_SG_Entry) * sgEntryCount * subReqCount;
	size += sizeof(MV_Sense_Data) * subReqCount;
#endif /* SUPPORT_LARGE_REQUEST */

		DISC_GetResource(&DiscSize, expanderCount, devCount);
		size += ROUNDING(DiscSize, 8);

		MV_DUMPC32(0xCCCC8801);
		MV_DUMPC32(size);
		//MV_HALTKEY;
        return size;
	}
	
	/* Uncached memory quota */
	if ( type==RESOURCE_UNCACHED_MEMORY )
	{
		/* 
		 * SATA port alignment quota:
		 * Command list and received FIS is 64 byte aligned.
		 * Command table is 128 byte aligned.
		 * Data buffer is 8 byte aligned.
		 * This is different with AHCI.
		 */
//	#ifndef _OS_BIOS
#if 0
		MV_DPRINT(("Received FIS Size = 0x%x.\n", (MV_U32)RX_FIS_POOL_SIZE));
		MV_ASSERT(RX_FIS_POOL_SIZE==ROUNDING(RX_FIS_POOL_SIZE, 256));
#endif
#ifdef SUPPORT_LARGE_REQUEST
	PMV_Sense_Data pSenseBuffer;
	MV_U16 subReqCount;
#endif /* SUPPORT_LARGE_REQUEST */

		if ( maxIo>1 )
		{
			size = 64 + sizeof(MV_Command_Header) * slotCount;	/* Command List*/
			size += 256 + RX_FIS_POOL_SIZE;	/* Received FIS */
			size += 128 + sizeof(MV_Command_Table) * slotCount;
			size += 4 + sizeof(DELIVERY_QUEUE_ENTRY) * slotCount;
			size += 4 + sizeof(COMPLETION_QUEUE_ENTRY) * (slotCount + 1);
			
			/* Buffer for initialization like identify */
			size += 8 + SATA_SCRATCH_BUFFER_SIZE*SATAScratchCount;

			/* buffer for SG tables */
			size += 8 + SG_BUFFER_SIZE * sgBufferCount;

#ifndef SOFTWARE_XOR
//New 6440/6480
			tmpSize1 = 16 + sizeof(MV_XOR_Command_Header) * slotCount +
					(MAX_XOR_CMD_ENTRY+1)*16 +
					sizeof(MV_XOR_Command_Table) * MAX_XOR_TABLE_PER_XOR_REQUEST * slotCount;
//Old A1 6440
			tmpSize2 = 32 + sizeof(MV_XOR_Command_Header_A1) * slotCount +
					(MAX_XOR_CMD_ENTRY+1)*12 + 
					sizeof(MV_XOR_Command_Table_A1) * MAX_XOR_TABLE_PER_XOR_REQUEST * slotCount;

			size += (tmpSize1 > tmpSize2)?tmpSize1:tmpSize2;
			size += 4 + sizeof(XOR_DELIVERY_QUEUE_ENTRY) * slotCount;
			size += 4 + sizeof(XOR_COMPLETION_QUEUE_ENTRY) * (slotCount + 1);	
#endif
		}
		else
		{
			size = 64 + sizeof(MV_Command_Header);/* Command List*/
			size += 256 + RX_FIS_SIZE;	/* Received FIS */
			size += 128 + sizeof(MV_Command_Table);	/* Command Table */	
			size += 4 + sizeof(DELIVERY_QUEUE_ENTRY);
			size += 4 + sizeof(COMPLETION_QUEUE_ENTRY) * 2;		/* need at least 2 entries for completion queue */	
			/* Buffer for initialization like identify */
			size += 8 + SATA_SCRATCH_BUFFER_SIZE * SATAScratchCount;
#ifndef SOFTWARE_XOR
//New 6440/6480
			tmpSize1 = 16 + sizeof(MV_XOR_Command_Header) +
					(MAX_XOR_CMD_ENTRY+1)*16 + 
					sizeof(MV_XOR_Command_Table) * MAX_XOR_TABLE_PER_XOR_REQUEST;
//Old A1 6440
			tmpSize2 = 32 + sizeof(MV_XOR_Command_Header_A1) +
					(MAX_XOR_CMD_ENTRY+1)*12 + 
					sizeof(MV_XOR_Command_Table_A1) * MAX_XOR_TABLE_PER_XOR_REQUEST;

			size += (tmpSize1 > tmpSize2)?tmpSize1:tmpSize2;
			size += 4 + sizeof(XOR_DELIVERY_QUEUE_ENTRY);
			size += 4 + sizeof(XOR_COMPLETION_QUEUE_ENTRY) * 2;	
#endif
		}	

		//MV_DUMPC32(0xCC000002);
		//MV_DUMPC32(size);
		
		MV_DUMPC32(0xCCCC8802);
		MV_DUMPC32(size);
		//MV_HALTKEY;
		return size;
	}

	return 0;
}

extern int HBA_GetResource(struct mv_mod_desc *mod_desc,
			   enum Resource_Type type,
			   MV_U32  size,
			   Assigned_Uncached_Memory *dma_res);

//TBD: In Dump
static void __core_ops_init(struct mv_mod_desc *mod_desc,
			    MV_U32 extensionSize,
			    MV_U16 maxIo)
{
	PCore_Driver_Extension pCore;
	Assigned_Uncached_Memory dmaResource;
	PDomain_Port port;
	PSATA_Scratch_Buffer pSATASB;
	PSMP_Scratch_Buffer pSMPSB;
	MV_PVOID memVir;
	MV_PHYSICAL_ADDR memDMA;
	PSG_Buffer pSGBuf;
	MV_PTR_INTEGER temp;
	MV_U32 offset, usedSize = 0;
	MV_U16 slotCount, i;
	MV_U8 devCount, expanderCount, pmCount, internalReqCount, sgEntryCount;
	MV_U8 SATAScratchCount, SMPScratchCount;
	MV_U16 contextCount, sgBufferCount, subReqCount;
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	PCORE_CONTEXT pContext;
#endif
	MV_U32 size;
#ifndef SOFTWARE_XOR
	MV_U32 xorTableCount, xorTableSize;
#   ifdef RAID6_HARDWARE_XOR
	PXOR_Table_Wrapper pXORTableWrapper;
	PCORE_XOR_CONTEXT pXORContext;
#   endif /* RAID6_HARDWARE_XOR */
#endif /* SOFTWARE_XOR */

	pCore    = (PCore_Driver_Extension) mod_desc->extension;

#ifndef _OS_BIOS
	gCore = pCore;
#endif
	MV_DUMPC32(0xCCCCBB12);

	/* 
	 * Zero core driver extension. After that, I'll ignore many variables initialization. 
	 */
	MV_ZeroMemory(mod_desc->extension, mod_desc->extension_size);
	pCore->State = CORE_STATE_IDLE;

	/*Init variable */
	devCount = 0;
	expanderCount = 0;
	pmCount = 0;
	internalReqCount = 0;
	sgEntryCount = 0;
	SATAScratchCount = 0;
	SMPScratchCount = 0;
	contextCount = 0;
	sgBufferCount = 0;
	subReqCount = 0;

	/* Set up controller information */
	pCore->desc        = mod_desc;
	pCore->Vendor_Id   = mod_desc->hba_desc->Vendor_Id;
	pCore->Device_Id   = mod_desc->hba_desc->Device_Id;
	pCore->Revision_Id = mod_desc->hba_desc->Revision_Id;

	for ( i=0; i<MAX_BASE_ADDRESS; i++ )
	{
		pCore->Base_Address[i] = mod_desc->hba_desc->Base_Address[i];
	}
	pCore->Mmio_Base = mod_desc->hba_desc->Base_Address[MV_PCI_BAR];

	pCore->Adapter_State = ADAPTER_INITIALIZING;
	MV_LIST_HEAD_INIT(&pCore->Waiting_List);
	MV_LIST_HEAD_INIT(&pCore->Complete_List);
#if !__RES_MGMT__
	MV_LIST_HEAD_INIT(&pCore->Internal_Req_List);
#endif /* !__RES_MGMT__ */
#ifdef CORE_SAS_SUPPORT_ATA_COMMAND
	MV_LIST_HEAD_INIT(&pCore->Context_List);
#endif
	MV_LIST_HEAD_INIT(&pCore->SATA_Scratch_List);
	MV_LIST_HEAD_INIT(&pCore->SMP_Scratch_List);
	MV_LIST_HEAD_INIT(&pCore->SG_Buffer_List);
#ifdef RAID6_HARDWARE_XOR
	MV_LIST_HEAD_INIT(&pCore->XOR_Table_List);
	MV_LIST_HEAD_INIT(&pCore->XOR_Context_List);
#endif /* RAID6_HARDWARE_XOR */

	OSSW_INIT_TIMER(&pCore->timer);
	OSSW_INIT_SPIN_LOCK(&pCore->lock);


	/* Decide values based on driver mode */
	Core_GetSupportedCounts(maxIo,
				&devCount, 
				&expanderCount, 
				&pmCount,
				&internalReqCount,
				&sgEntryCount, 
				&sgBufferCount,
				&SATAScratchCount, 
				&SMPScratchCount, 
				&slotCount, 
				&contextCount,
				&subReqCount);

	pCore->Expander_Count_Supported = expanderCount;
	pCore->PD_Count_Supported = devCount;
#ifdef SUPPORT_PM
	pCore->PM_Count_Supported = pmCount;
#endif /* SUPPORT_PM */
	pCore->Slot_Count_Supported = slotCount;