core_extern.c

6440linuxDriver的源代码

#include "mv_include.h"

#include "core_header.h"
#include "core_helper.h"
#include "core_extern.h"
#include "core_spi.h"

MV_BOOLEAN Core_MakeDeviceResetReq(
	MV_PVOID			This,
	MV_PVOID			InitiatorModuleExtension,
	PMV_Request			pReq,
	MV_ReqCompletion	Completion,
	MV_U16				DeviceId
	)
{
	PCore_Driver_Extension pCore;

	if (!This || !InitiatorModuleExtension || !pReq || !Completion)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;

	if (MapDeviceId(pCore, DeviceId) == ID_NOT_MAPPED)
		return MV_FALSE;

	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_RESET_DEVICE;
	pReq->Device_Id = DeviceId;
	pReq->Cmd_Initiator = InitiatorModuleExtension;
	pReq->Completion = Completion;

	return MV_TRUE;
}

MV_BOOLEAN Core_MakePortResetReq(
	MV_PVOID			This,
	MV_PVOID			InitiatorModuleExtension,
	PMV_Request			pReq,
	MV_ReqCompletion	Completion,
	MV_U16				PortId
	)
{
	PCore_Driver_Extension pCore;

	if (!This || !InitiatorModuleExtension || !pReq || !Completion)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;

	if (MapPortId(pCore, PortId) == ID_NOT_MAPPED)
		return MV_FALSE;

	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_RESET_PORT;
	MV_CopyMemory(&pReq->Cdb[3], &PortId, 2);
	pReq->Device_Id = VIRTUAL_DEVICE_ID;
	pReq->Cmd_Initiator = InitiatorModuleExtension;
	pReq->Completion = Completion;

	return MV_TRUE;
}

MV_BOOLEAN Core_MakeSEPReq(
	MV_PVOID			This,
	MV_PVOID			InitiatorModuleExtension,
	PMV_Request			pReq,
	MV_ReqCompletion	Completion,
	MV_U16				DeviceId,
	MV_U8				SEPAddr,
	MV_U8				CmdType,
	MV_U8				SEMBAddr,
	MV_U8				SEPCommand,
	MV_PVOID			DataBuffer,
	MV_U32				DataBufferLength
	)
{
	PCore_Driver_Extension pCore;
	PDomain_Port pPort;
	PMV_SG_Table pSGTable;

	if (!This || !InitiatorModuleExtension || !pReq || !Completion || !DataBuffer)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;

	if (MapDeviceId(pCore, DeviceId) == ID_NOT_MAPPED)
		return MV_FALSE;

	pPort = &pCore->Ports[MapPortId(pCore, DeviceId)];
	if (!(pPort->Type & PORT_TYPE_I2C))
		return MV_FALSE;
	
	pReq->Cdb[0] = SEPCommand;
	pReq->Cdb[1] = SEPAddr;
	pReq->Cdb[2] = CmdType;
	pReq->Cdb[3] = SEMBAddr;

	pReq->Req_Flag |= REQ_FLAG_EXTERNAL;
	pReq->Device_Id = DeviceId;
	pReq->Cmd_Initiator = InitiatorModuleExtension;
	pReq->Data_Transfer_Length = DataBufferLength;
	pReq->Data_Buffer = DataBuffer;
	pReq->Completion = Completion;

	pSGTable = &pReq->SG_Table;
	SGTable_Init(pSGTable, 0);
#ifdef _OS_WINDOWS
	HBA_GenerateSGExternal(This, DataBuffer, DataBufferLength, pSGTable);
#endif /* _OS_WINDOWS */

	return MV_TRUE;
}

MV_BOOLEAN Core_MakeSMPReq(
	MV_PVOID			This,
	MV_PVOID			InitiatorModuleExtension,
	PMV_Request			pReq,
	MV_ReqCompletion	Completion,
	MV_U16				DeviceId,
	MV_PVOID			SmpRequestFrame,
	MV_U32				SmpRequestFrameLength,
	MV_PVOID			SmpResponseFrame,
	MV_U32				SmpResponseFrameLength
	)
{
	PCore_Driver_Extension pCore;
	PMV_SG_Table pSGTable;

	if (!This || !InitiatorModuleExtension || !pReq || !Completion || 
		!SmpRequestFrame || !SmpResponseFrame)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;

	// not an expander - error
	if (DeviceId < MIN_EXPANDER_ID)		
		return MV_FALSE;

	if (MapDeviceId(pCore, DeviceId) == ID_NOT_MAPPED)
		return MV_FALSE;

	pSGTable = &pReq->SG_Table;
	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_SMP;
	MV_CopyMemory(&pReq->Cdb[3], &SmpResponseFrameLength, 4);

	pReq->Req_Flag |= REQ_FLAG_EXTERNAL;
	pReq->Device_Id = DeviceId;
	pReq->Cmd_Initiator = InitiatorModuleExtension;
	pReq->Data_Transfer_Length = SmpRequestFrameLength;
	pReq->Data_Buffer = SmpRequestFrame;
	pReq->Context[MODULE_CORE] = SmpResponseFrame;
	pReq->Completion = Completion;

	SGTable_Init(pSGTable, 0);

	return MV_TRUE;
}

MV_BOOLEAN Core_MakeTMFReq(
	MV_PVOID			This,
	MV_PVOID			InitiatorModuleExtension,
	PMV_Request			pReq,
	MV_ReqCompletion	Completion,
	MV_U16				DeviceId,
	MV_U8				TaskManagementFunction,
	PMV_Request			OriginalRequest
	)
{
	PCore_Driver_Extension pCore;
	PDomain_Device pDevice;
	PMV_Request pTempReq;
	PMV_SG_Table pSGTable;
	MV_U16 Tag;
	MV_U32 count = 0;
	List_Head *pPos;

	if (!This || !InitiatorModuleExtension || !pReq || !Completion)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;

	if (MapDeviceId(pCore, DeviceId) == ID_NOT_MAPPED)
		return MV_FALSE;
	pDevice = &pCore->Devices[MapDeviceId(pCore, DeviceId)];
	if (!IS_SSP(pDevice))
		return MV_FALSE;

	if (TaskManagementFunction == ABORT_TASK_TMF || 
		TaskManagementFunction == QUERY_TASK_TMF)
	{
		if (OriginalRequest == NULL)
		{
			pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
			Completion(pCore, pReq);
			return MV_TRUE;
		}
		
		if (pCore->Running_Req[OriginalRequest->SlotNo] == NULL)
		{
			// see if this request is in waiting queue
			count = 0;
			LIST_FOR_EACH(pPos, &pCore->Waiting_List) {
				count++;
			}
			while ( count>0 )
			{
				pTempReq = (PMV_Request)List_GetFirstEntry(&pCore->Waiting_List, MV_Request, Queue_Pointer);
				
				if (pTempReq == OriginalRequest)
				{
					pReq->Scsi_Status = REQ_STATUS_SUCCESS;
					if (TaskManagementFunction == QUERY_TASK_TMF)
						List_AddTail(&pTempReq->Queue_Pointer, &pCore->Waiting_List);
					Completion(pCore, pReq);
					return MV_TRUE;
				}
				else
				{
					List_AddTail(&pTempReq->Queue_Pointer, &pCore->Waiting_List);
					count--;
				}
			}

			// request is not running and not in queue
			pReq->Scsi_Status = REQ_STATUS_INVALID_PARAMETER;
			Completion(pCore, pReq);
			return MV_TRUE;
		}
		
		pReq->Org_Req = OriginalRequest;
	}

	pSGTable = &pReq->SG_Table;
	Tag = pReq->Tag;

	pReq->Cdb[0] = SCSI_CMD_MARVELL_SPECIFIC;
	pReq->Cdb[1] = CDB_CORE_MODULE;
	pReq->Cdb[2] = CDB_CORE_TASK_MGMT;
	pReq->Cdb[3] = (MV_U8)(Tag&0xff);
	pReq->Cdb[4] = (MV_U8)(Tag>>8);
	pReq->Cdb[5] = TaskManagementFunction;

	MV_CopyMemory(&pReq->Cdb[6], pDevice->saslun, 8);

	pReq->Req_Flag |= REQ_FLAG_EXTERNAL;
	pReq->Device_Id = pDevice->Id;
	pReq->Cmd_Initiator = InitiatorModuleExtension;
	pReq->Data_Transfer_Length = 0;
	pReq->Data_Buffer = NULL;
	pReq->Completion = Completion;

	SGTable_Init(pSGTable, 0);

	return MV_TRUE;
}

MV_VOID Core_ModuleEnableDisablePHY(
	MV_PVOID	This,
	MV_U8		PhyId,
	MV_BOOLEAN	Enable
	)
{
	if (!This)
		return;

	if (Enable)
		mv_enable_xmt(This, PhyId);
	else
		mv_disable_xmt(This, PhyId);
}

MV_VOID Core_ModuleEnableDisableIRQ(
	MV_PVOID	This,
	MV_BOOLEAN	Enable
	)
{
	PCore_Driver_Extension pCore;
	MV_U32 tmp;

	if (!This)
		return;

	pCore = (PCore_Driver_Extension)This;
	tmp = MV_REG_READ_DWORD(pCore->Mmio_Base, HBA_CONTROL); 

	if (Enable)
		MV_REG_WRITE_DWORD(pCore->Mmio_Base, HBA_CONTROL, tmp | MV_HBA_INT_ENABLE);
	else
		MV_REG_WRITE_DWORD(pCore->Mmio_Base, HBA_CONTROL, tmp & ~MV_HBA_INT_ENABLE);
}

MV_BOOLEAN Core_ModuleCheckIRQ(
	MV_PVOID	This
	)
{
	PCore_Driver_Extension pCore;
	MV_U32 tmp;

	if (!This)
		return MV_FALSE;

	pCore = (PCore_Driver_Extension)This;
	tmp = MV_REG_READ_DWORD(pCore->Mmio_Base, HBA_IRQ_STAT);
	if ((tmp & SAS_SATA_IRQ_PENDING) || (tmp & XOR_IRQ_PENDING))
		return MV_TRUE;
	else
		return MV_FALSE;
}

MV_U32 Core_FlashGetSize(
	MV_PVOID	This
	)
{
	PCore_Driver_Extension pCore;
	AdapterInfo AI;

	if (!This)
		return 0;

	pCore = (PCore_Driver_Extension)This;
	AI.bar[2] = pCore->Base_Address[2];
	if (-1 == OdinSPI_Init(&AI))
		return 0;
	else
		return AI.FlashSize;
}

int Core_FlashRead( 
	MV_PVOID	This,
	MV_U32		Offset,
	MV_U32		Length,
	MV_PVOID	DataBuffer
	)
{
	PCore_Driver_Extension pCore;
	AdapterInfo AI;

	if (!This)
		return 0;

	pCore = (PCore_Driver_Extension)This;
	AI.bar[2] = pCore->Base_Address[2];
	if (-1 == OdinSPI_Init(&AI))
		return 0;

	OdinSPI_ReadBuf(&AI, Offset, (MV_PU8)DataBuffer, Length);
	return Length;
}

int Core_FlashWrite( 
	MV_PVOID	This,
	MV_U32		Offset,
	MV_U32		Length,
	MV_PVOID	DataBuffer
	)
{
	PCore_Driver_Extension pCore;
	AdapterInfo AI;

	if (!This)
		return 0;

	pCore = (PCore_Driver_Extension)This;
	AI.bar[2] = pCore->Base_Address[2];
	if (-1 == OdinSPI_Init(&AI))
		return 0;

	OdinSPI_WriteBuf(&AI, Offset, (MV_PU8)DataBuffer, Length);
	return Length;
}