core_xor.c

来自「6440linuxDriver的源代码」· C语言 代码 · 共 1,454 行 · 第 1/4 页

	PMV_SG_Entry sg;				//---
	PSG_Buffer pSGBuf, pNextSGBuf, pTempBuf;
		
	pSGBuf = GetSGBufferFromPool(pCore);
	if (pSGBuf == NULL)
	{
		MV_DPRINT(("Ran out of SG Buffers!\n"));
		List_Add(&pReq->Queue_Pointer, &pCore->XOR_Waiting_List);
		return;
	}
	else
	{
		pReq->SG_Buffer = pSGBuf;
	}

	pReq->SlotNo=0xfff;

	SlotNo=XORGetOneCommandSlot(pCore, &pCmdHeader);
	pReq->SlotNo=SlotNo;

	sg = pSGBuf->Buffer_Vir;	//---

	tmpPhyAddress.value = pCore->Cmd_Table_DMA.value + ((MV_PU8)&pCmdTbl[SlotNo].NextTableAddressLo - (MV_PU8)pCore->Cmd_Table);
	pCmdHeader->Table_Address= tmpPhyAddress.parts.low;
	pCmdHeader->Table_Address_High= tmpPhyAddress.parts.high;

	pCmdHeader->XORTblLen=((sizeof(XOR_CMD_ENTRY)*MAX_XOR_CMD_ENTRY)/sizeof(MV_U32))+4;

	MV_ZeroMemory(&pCmdTbl[SlotNo], sizeof(MV_XOR_Command_Table));

/*
XOR_PRD 0:
	1. Fill Buffer0 from Src[0]
	2. if RAID6, Fill Buffer1 from Src[0]
XOR_PRD 1..n:
	3. XOR to Buffer0 from Src[1..n]
	4. if RAID6, GF_Multiply and XOR to Buffer1 from Src[1..n]
XOR_PRD n+1:
	5. Write to Tgt0 from Buffer0
XOR_PRD n+2:
	6. if RAID6, Write to Tgt1 from Buffer1
*/
//XOR_PRD 0:
#ifdef USE_NEW_SGTABLE
	consumed = sgdt_prepare_hwprd( pCore, &pReq->Source_SG_Table_List[0], sg, availSg );
#else
	consumed = pReq->Source_SG_Table_List[0].Valid_Entry_Count;
	for(i=0;i<pReq->Source_SG_Table_List[0].Valid_Entry_Count;i++)
	{
		MV_CopyMemory(&sg[i], &pReq->Source_SG_Table_List[0].Entry_Ptr[i], sizeof(MV_SG_Entry));
	}
#endif
	MV_ASSERT( consumed );
	MV_ASSERT( availSg >= consumed );

	pCmdTbl[SlotNo].XOR_PRD[0].PRDEntryCount = (MV_U8) consumed;
	U64_ASSIGN_U64(tmpPhyAddress, pSGBuf->Buffer_DMA);

	sg += consumed;
	availSg -= consumed;

	pCmdTbl[SlotNo].XOR_PRD[0].PRDTableAddress=tmpPhyAddress.parts.low;
	pCmdTbl[SlotNo].XOR_PRD[0].PRDTableAddressHigh=tmpPhyAddress.parts.high;

	pCmdTbl[SlotNo].XOR_PRD[0].Buffer0OpCode=OP_DIRECT_FILL; //direct fill
	if(pReq->Target_SG_Table_Count>1)
		pCmdTbl[SlotNo].XOR_PRD[0].Buffer1OpCode=OP_DIRECT_FILL; //direct fill

	pCmdTbl[SlotNo].TotalByteCount=pReq->Source_SG_Table_List[0].Byte_Count;

//XOR_PRD 1..n:
	for(sId=1;sId<pReq->Source_SG_Table_Count;sId++)
	{
		//if (availSg < pReq->Source_SG_Table_List[sId].Valid_Entry_Count)
		// Need a better solution. We don't know how many entries will be used in sgdt_prepare_hwprd.
		if (availSg < SG_BUFFER_SINGLE_COUNT)
		{
			pNextSGBuf = GetSGBufferFromPool(pCore);
			if (pNextSGBuf == NULL)
			{
				MV_DPRINT(("Ran out of SG Buffers!\n"));
				Tag_ReleaseOne(&pCore->XOR_Tag_Pool, SlotNo);
				while (pReq->SG_Buffer)
				{
					pTempBuf = ((PSG_Buffer)pReq->SG_Buffer)->NextBuffer;
					FreeSGBufferToPool(pCore, (PSG_Buffer *) &pReq->SG_Buffer);
					pReq->SG_Buffer = pTempBuf;
				}
				List_Add(&pReq->Queue_Pointer, &pCore->XOR_Waiting_List);
				return;
			}
			pSGBuf->NextBuffer = pNextSGBuf;
			sg = pNextSGBuf->Buffer_Vir;
			availSg = SG_BUFFER_SINGLE_COUNT; 
			pSGBuf = pNextSGBuf;
		}
#ifdef USE_NEW_SGTABLE
		consumed = sgdt_prepare_hwprd( pCore, &pReq->Source_SG_Table_List[sId], sg, availSg );
#else
		consumed = pReq->Source_SG_Table_List[sId].Valid_Entry_Count;
		for(i=0;i<pReq->Source_SG_Table_List[sId].Valid_Entry_Count;i++)
		{
			MV_CopyMemory(&sg[i], &pReq->Source_SG_Table_List[sId].Entry_Ptr[i], sizeof(MV_SG_Entry));
		}
#endif
		MV_ASSERT( consumed );
		MV_ASSERT( availSg >= consumed );

		pCmdTbl[SlotNo].XOR_PRD[sId].PRDEntryCount = (MV_U8) consumed;
		tmpPhyAddress.value = pSGBuf->Buffer_DMA.value + ((MV_PU8)sg - (MV_PU8)pSGBuf->Buffer_Vir);

		sg += consumed;
		availSg -= consumed;

		pCmdTbl[SlotNo].XOR_PRD[sId].PRDTableAddress=tmpPhyAddress.parts.low;
		pCmdTbl[SlotNo].XOR_PRD[sId].PRDTableAddressHigh=tmpPhyAddress.parts.high;

		pCmdTbl[SlotNo].XOR_PRD[sId].Buffer0OpCode=OP_XOR_ENABLE; //XOR
/* or we can do 
		pCmdTbl[SlotNo].XOR_PRD[sId].DataByte0=pReq->Coef[0][sId];
		pCmdTbl[SlotNo].XOR_PRD[sId].Buffer0OpCode=OP_GF_XOR_ENABLE; //1st GF+XOR
*/
		if(pReq->Target_SG_Table_Count>1)
		{
			pCmdTbl[SlotNo].XOR_PRD[sId].DataByte1=pReq->Coef[1][sId];
			pCmdTbl[SlotNo].XOR_PRD[sId].Buffer1OpCode=OP_GF_XOR_ENABLE; //GF+XOR
		}
	}

//XOR_PRD n..m(1 or 2):
	for(tId=0;tId<pReq->Target_SG_Table_Count;tId++)
	{
//		if (availSg < pReq->Target_SG_Table_List[tId].Valid_Entry_Count)
		// Need a better solution. We don't know how many entries will be used in sgdt_prepare_hwprd.
		if (availSg < SG_BUFFER_SINGLE_COUNT)
		{
			pNextSGBuf = GetSGBufferFromPool(pCore);
			if (pNextSGBuf == NULL)
			{
				MV_DPRINT(("Ran out of SG Buffers!\n"));
				Tag_ReleaseOne(&pCore->XOR_Tag_Pool, SlotNo);
				while (pReq->SG_Buffer)
				{
					pTempBuf = ((PSG_Buffer)pReq->SG_Buffer)->NextBuffer;
					FreeSGBufferToPool(pCore, (PSG_Buffer *) &pReq->SG_Buffer);
					pReq->SG_Buffer = pTempBuf;
				}
				List_Add(&pReq->Queue_Pointer, &pCore->XOR_Waiting_List);
				return;
			}
			pSGBuf->NextBuffer = pNextSGBuf;
			sg = pNextSGBuf->Buffer_Vir;
			availSg = SG_BUFFER_SINGLE_COUNT; 
			pSGBuf = pNextSGBuf;
		}
#ifdef USE_NEW_SGTABLE
		consumed = sgdt_prepare_hwprd( pCore, &pReq->Target_SG_Table_List[tId], sg, availSg );
#else
		consumed = pReq->Target_SG_Table_List[tId].Valid_Entry_Count;
		for(i=0;i<pReq->Target_SG_Table_List[tId].Valid_Entry_Count;i++)
		{
			MV_CopyMemory(&sg[i], &pReq->Target_SG_Table_List[tId].Entry_Ptr[i], sizeof(MV_SG_Entry));
		}
#endif
		MV_ASSERT( consumed );
		MV_ASSERT( availSg >= consumed );

		pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count+tId].PRDEntryCount = (MV_U8) consumed;
		tmpPhyAddress.value = pSGBuf->Buffer_DMA.value + ((MV_PU8)sg - (MV_PU8)pSGBuf->Buffer_Vir);

		sg += consumed;
		availSg -= consumed;

		pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count+tId].PRDTableAddress=tmpPhyAddress.parts.low;
		pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count+tId].PRDTableAddressHigh=tmpPhyAddress.parts.high;

		if(tId<1)
			pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count+tId].Buffer0OpCode=OP_WRITE_ENABLE; //write
		else
			pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count+tId].Buffer1OpCode=OP_WRITE_ENABLE; //write
	}

	pCmdTbl[SlotNo].InterruptEnable=1;
	pCmdTbl[SlotNo].ValidEntry=pReq->Source_SG_Table_Count+pReq->Target_SG_Table_Count;

	pCore->XOR_Running_Req[SlotNo]=pReq;
	pCore->XOR_Req_Count++;

	XORPrepareDeliveryQueueEntry(pCore, SlotNo, &DELV_Q_Entry);
	XORWriteDELV_Q_Entry(pCore, &DELV_Q_Entry);

	//MV_DumpXORRegister(pCore);
	/* Request is sent to the hardware and not finished yet. */
	pReq->Request_Status = XOR_STATUS_SUCCESS;
}
#endif

void
XORCompareCommand_A1(
	IN PCore_Driver_Extension pCore,
	IN PMV_XOR_Request pReq
	)
{

	MV_U16 SlotNo;
	MV_PHYSICAL_ADDR tmpPhyAddress;
	PMV_XOR_Command_Header_A1 pCmdHeader;
	PMV_XOR_Command_Table_A1 pCmdTbl= (PMV_XOR_Command_Table_A1)pCore->XOR_Cmd_Table;
	XOR_DELIVERY_QUEUE_ENTRY DELV_Q_Entry;
	MV_U8 sId;
	int availSg = SG_BUFFER_SINGLE_COUNT;	//---
	int consumed;					//---
	PMV_SG_Entry sg;				//---
	PSG_Buffer pSGBuf, pNextSGBuf, pTempBuf;

	pSGBuf = GetSGBufferFromPool(pCore);
	if (pSGBuf == NULL)
	{
		MV_DPRINT(("Ran out of SG Buffers!\n"));
		List_Add(&pReq->Queue_Pointer, &pCore->XOR_Waiting_List);
		return;
	}
	else
	{
		pReq->SG_Buffer = pSGBuf;
	}

	pReq->SlotNo=0xfff;

	SlotNo=XORGetOneCommandSlot(pCore, &pCmdHeader);
	pReq->SlotNo=SlotNo;

	sg = pSGBuf->Buffer_Vir;	//---

	tmpPhyAddress.value = pCore->Cmd_Table_DMA.value + ((MV_PU8)&pCmdTbl[SlotNo].NextTableAddressLo - (MV_PU8)pCore->Cmd_Table);
	pCmdHeader->Table_Address= tmpPhyAddress.parts.low;
	pCmdHeader->Table_Address_High= tmpPhyAddress.parts.high;

	pCmdHeader->XORTblLen=((sizeof(XOR_CMD_ENTRY_A1)*MAX_XOR_CMD_ENTRY)/sizeof(MV_U32))+3;

	MV_ZeroMemory(&pCmdTbl[SlotNo], sizeof(MV_XOR_Command_Table_A1));

/*
XOR_PRD 0:
	1. Fill Buffer0 from Src[0]
	2. if RAID6, Fill Buffer1 from Src[0]
XOR_PRD 1..n:
	3. XOR to Buffer0 from Src[1..n]
	4. if RAID6, GF_Multiply and XOR to Buffer1 from Src[1..n]
XOR_PRD n+1:
	5. XOR to Buffer0 from Tgt0
XOR_PRD n+2:
	6. if RAID6, XOR to Buffer1 from Tgt1
XOR_PRD ..+1:
	3. Zero check on Buffer0
	4. if RAID6, Zero check on Buffer1
*/
#ifdef USE_NEW_SGTABLE
	consumed = sgdt_prepare_hwprd( pCore, &pReq->Source_SG_Table_List[0], sg, availSg );
#else
	consumed = pReq->Source_SG_Table_List[0].Valid_Entry_Count;
	for(i=0;i<pReq->Source_SG_Table_List[0].Valid_Entry_Count;i++)
	{
		MV_CopyMemory(&sg[i], &pReq->Source_SG_Table_List[0].Entry_Ptr[i], sizeof(MV_SG_Entry));
	}
#endif
	MV_ASSERT( consumed );
	MV_ASSERT( availSg >= consumed );

	pCmdTbl[SlotNo].XOR_PRD[0].PRDEntryCount = (MV_U8) consumed;
	U64_ASSIGN_U64(tmpPhyAddress, pSGBuf->Buffer_DMA);

	sg += consumed;
	availSg -= consumed;

	pCmdTbl[SlotNo].XOR_PRD[0].PRDTableAddress=tmpPhyAddress.parts.low;
	pCmdTbl[SlotNo].XOR_PRD[0].PRDTableAddressHigh=tmpPhyAddress.parts.high;

	pCmdTbl[SlotNo].XOR_PRD[0].Buffer0OpCode=OP_DIRECT_FILL; //direct fill
	if(pReq->Target_SG_Table_Count>1)
		pCmdTbl[SlotNo].XOR_PRD[0].Buffer1OpCode=OP_DIRECT_FILL; //direct fill

	pCmdTbl[SlotNo].TotalByteCount=pReq->Source_SG_Table_List[0].Byte_Count;

	for(sId=1;sId<pReq->Source_SG_Table_Count;sId++)
	{
		//if (availSg < pReq->Source_SG_Table_List[sId].Valid_Entry_Count)
		// Need a better solution. We don't know how many entries will be used in sgdt_prepare_hwprd.
		if (availSg < SG_BUFFER_SINGLE_COUNT)
		{
			pNextSGBuf = GetSGBufferFromPool(pCore);
			if (pNextSGBuf == NULL)
			{
				MV_DPRINT(("Ran out of SG Buffers!\n"));
				Tag_ReleaseOne(&pCore->XOR_Tag_Pool, SlotNo);
				while (pReq->SG_Buffer)
				{
					pTempBuf = ((PSG_Buffer)pReq->SG_Buffer)->NextBuffer;
					FreeSGBufferToPool(pCore, (PSG_Buffer *) &pReq->SG_Buffer);
					pReq->SG_Buffer = pTempBuf;
				}
				List_Add(&pReq->Queue_Pointer, &pCore->XOR_Waiting_List);
				return;
			}
			pSGBuf->NextBuffer = pNextSGBuf;
			sg = pNextSGBuf->Buffer_Vir;
			availSg = SG_BUFFER_SINGLE_COUNT; 
			pSGBuf = pNextSGBuf;
		}
#ifdef USE_NEW_SGTABLE
		consumed = sgdt_prepare_hwprd( pCore, &pReq->Source_SG_Table_List[sId], sg, availSg );
#else
		consumed = pReq->Source_SG_Table_List[sId].Valid_Entry_Count;
		for(i=0;i<pReq->Source_SG_Table_List[sId].Valid_Entry_Count;i++)
		{
			MV_CopyMemory(&sg[i], &pReq->Source_SG_Table_List[sId].Entry_Ptr[i], sizeof(MV_SG_Entry));
		}
#endif
		MV_ASSERT( consumed );
		MV_ASSERT( availSg >= consumed );

		pCmdTbl[SlotNo].XOR_PRD[sId].PRDEntryCount = (MV_U8) consumed;
		tmpPhyAddress.value = pSGBuf->Buffer_DMA.value + ((MV_PU8)sg - (MV_PU8)pSGBuf->Buffer_Vir);

		sg += consumed;
		availSg -= consumed;

		pCmdTbl[SlotNo].XOR_PRD[sId].PRDTableAddress=tmpPhyAddress.parts.low;
		pCmdTbl[SlotNo].XOR_PRD[sId].PRDTableAddressHigh=tmpPhyAddress.parts.high;

		pCmdTbl[SlotNo].XOR_PRD[sId].Buffer0OpCode=OP_XOR_ENABLE; //XOR
		if(pReq->Target_SG_Table_Count>1)
		{
			pCmdTbl[SlotNo].XOR_PRD[sId].DataByte=pReq->Coef[1][sId];
			pCmdTbl[SlotNo].XOR_PRD[sId].Buffer1OpCode=OP_GF_XOR_ENABLE; //GF+XOR
		}
	}

	pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count].PRDEntryCount=1; //to workaround hardware no-action check
	pCmdTbl[SlotNo].XOR_PRD[pReq->Source_SG_Table_Count].Buffer0OpCode=OP_ZERO_CHECK_ENABLE; //Zero Check
	pCmdTbl[SlotNo].ValidEntry=pReq->Source_SG_Table_Count+1;			// add 1 for the zero check entry

	pCmdTbl[SlotNo].InterruptEnable=1;

	pCore->XOR_Running_Req[SlotNo]=pReq;
	pCore->XOR_Req_Count++;

	XORPrepareDeliveryQueueEntry(pCore, SlotNo, &DELV_Q_Entry);
	XORWriteDELV_Q_Entry(pCore, &DELV_Q_Entry);

//	MV_DumpXORRegister(pCore);
	/* Request is sent to the hardware and not finished yet. */
	pReq->Request_Status = XOR_STATUS_SUCCESS;
}

#ifndef RAID6_HARDWARE_XOR
void
XORCompareCommand(
	IN PCore_Driver_Extension pCore,
	IN PMV_XOR_Request pReq
	)
{

	MV_U16 SlotNo;