sd old.c

常见卡(SD,NAND,XD,MS,ATA,CF)完整DRIVER

			}
#else
			MP_DEBUG("-I- Only Support MMC 1 bit");
#endif
		}
		// set BLOCK length
		SetBlockLen(MCARD_SECTOR_SIZE);

		#if SD_RW_COMPARE
		if(sInfo.bType  == SD_TYPE)
			SD_READ_WRITE_COMPARE();
		#endif

		if (swRetValue == SD_PASS)
		{		
			sInfo.bInitFlag = TRUE;
			return swRetValue;
		}
	}
	while (bRetryTimes > 0);

	return GENERAL_FAIL;
}


static void SetCommand(WORD wCommand, DWORD dwArgument)
{
	register MCARD *sMcard;
	sMcard = (MCARD *) (MCARD_BASE);
/*
	DWORD dwRetryCount = 0x10000;
	BYTE bReset;
	bReset = 0;
	while((sMcard->McSdC & 0x00001000) != 0)
	{
		dwRetryCount--;
//		MP_DEBUG1("FSM Busy,sMcard->McSdC = 0x%x",sMcard->McSdC);
		if(dwRetryCount == 0)
		{
			bReset = 1;
			break;
		}		
	}
	if(bReset == 1)
	{
		MP_DEBUG1("SetCommand FSM Busy,sMcard->McSdC = 0x%x",sMcard->McSdC);	
			sMcard->McardC &= ~ MCARD_ENABLE;
			sMcard->McardC |=  MCARD_ENABLE;		
	}
*/	
	sMcard->McSdC = (wCommand & 0x3f) + sInfo.dwBusWidth;
	sMcard->McSdArg = dwArgument;
	sMcard->McSdIc = IM_ALL;
	sMcard->McSdOp = (wCommand >> 8);
}

static SWORD WaitHostReady(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut;

	sMcard = (MCARD *) (MCARD_BASE);
	dwTimeOut = 10000;

	OpenDrainDelay();
	while (dwTimeOut)
	{
		//if (Polling_SD_Status()) return GENERAL_FAIL;
		if (!(sMcard->McSdC & FSMBUSY))
		{
			return SD_PASS;
		}

		TASK_YIELD();
		dwTimeOut--;
	}
	return GENERAL_FAIL;
}

static void OpenDrainDelay(void)
{
	DWORD dwCounter;

	dwCounter = dwOPEN_DRAIN_DELAY_1;
	while (dwCounter)
	{
		dwCounter--;
	}

	if (sInfo.dwClock != dwINITIAL_CLOCK)
	{
		return;
	}

	dwCounter = dwOPEN_DRAIN_DELAY_2;
	while (dwCounter)
	{
		dwCounter--;
	}
}

static SWORD WaitResponse(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, dwCause;

	sMcard = (MCARD *) MCARD_BASE;

	dwTimeOut = 10000000;
	OpenDrainDelay();
	while (!(sMcard->McSdIc & IC_RSPDONE))
	{
		//if (Polling_SD_Status()) return GENERAL_FAIL;
		if (dwTimeOut == 0)
		{
			//MP_DEBUG("-E- IC_RSPDONE fail");
			return RES_TIMEOUT;
		}
		dwTimeOut--;
	}

	dwCause = sMcard->McSdIc;
	if (dwCause & IC_RSPF)
	{
		//MP_DEBUG("-E- IC_RSPF fail");
		if (dwCause & IC_CRC16F)
		{
			//MP_DEBUG("-E- IC_CRC16F fail");
			return BAD_CRC16;
		}
		else if (dwCause & IC_CRC7F)
		{
			//MP_DEBUG("-E- IC_CRC7F fail");
			return BAD_CRC7;
		}
		else if (dwCause & IC_SDTO)
		{
			//MP_DEBUG("-E- IC_SDTO fail");
			return RES_TIMEOUT;
		}
		else if ((dwCause & IC_PGMF) || (dwCause & IC_WXF))
		{
			//MP_DEBUG("-E- IC_PGMF or IC_WXF fail");
			return PROGRAM_FAIL;
		}
		else
		{
			return PROGRAM_FAIL;
		}
	}
	return SD_PASS;
}

static SWORD SetBlockLen(DWORD dwBlockLen)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, dwCause;

	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McSdC = (CMD_SET_BLOCKLEN & 0x3f) + sInfo.dwBusWidth;	// set command index with current bus width setting
	sMcard->McSdArg = dwBlockLen;	// set argument
	sMcard->McSdOp = CMD_SET_BLOCKLEN >> 8;	// enable operation
//    dwTimeOut = 1000;
	dwTimeOut = 0x100000;
	OpenDrainDelay();
	while (dwTimeOut)
	{
		//if (Polling_SD_Status()) return RES_TIMEOUT;
		dwCause = sMcard->McSdIc;
		if (dwCause & IC_RSPDONE)
		{
			return SD_PASS;
		}
		dwTimeOut--;
	}
	MP_DEBUG1("-E- SetBlockLen FAIL (status: %x)", dwCause);
	return RES_TIMEOUT;
}

static SWORD SelCard(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, dwCause;

	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McSdC = (CMD_SELECT_CARD & 0x3f) + sInfo.dwBusWidth;	// set command index with current bus width setting
	sMcard->McSdArg = sInfo.dwRelativeCardAddr;	// set argument
	sMcard->McSdOp = (CMD_SELECT_CARD >> 8);	// enable operation
	dwTimeOut = 1000;

	OpenDrainDelay();
	while (dwTimeOut)
	{
		dwCause = sMcard->McSdIc;
		if (dwCause & IC_RSPDONE)
		{
			return SD_PASS;
		}
		dwTimeOut--;
	}
	MP_DEBUG1("-E- SelCard FAIL (status: %x)", dwCause);
	return RES_TIMEOUT;
}

static void TimeoutHandle(void)
{
	register CHANNEL *sChannel;

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	sChannel->Control = 0;
	DmaIntDis(IM_MCRDDM);
	blTimeOutFlag = 1;
	TaskWakeup(MCARD_TASK);
}


static void SetDataDma(DWORD dwBufferAddress, DWORD dwSize, DWORD dwDirection)
{
	register MCARD *sMcard;
	register CHANNEL *sChannel;
	DWORD dwTimeOut;

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McardC &= ~MCARD_FIFO_ENABLE;

	dwTimeOut = 5000000;
	while (!(sMcard->McardC & 0x400))
	{
		if (dwTimeOut-- == 0)
			break;
		//if (Polling_SD_Status()) return;
	}
	sChannel->Control = 0;
#if((STD_BOARD_VER == MP600PQFP_8M_SDRAM)||(STD_BOARD_VER == MP600PQFP_2M_SDRAM))
	sMcard->McardC = (MCARD_ENABLE + sInfo.dwCardTag + dwDirection+BIT11);
#else
	sMcard->McardC = (MCARD_ENABLE + sInfo.dwCardTag + dwDirection);
#endif
	sChannel->StartA = dwBufferAddress;
	sChannel->EndA = dwBufferAddress + dwSize - 1;
	sMcard->McDmarl = MCARD_DMA_LIMIT_ENABLE + (dwSize >> 2);
#ifdef SD_TIMEOUT_HANDLE
	DmaIntEna(IM_MCRDDM);
	blTimeOutFlag = 0;
	AddTimerProc(0xfffffff, TimeoutHandle);
	sChannel->Control = (MCARD_DMA_ENABLE | MCARD_INT_DBFEND_ENABLE);
#else
	sChannel->Control = MCARD_DMA_ENABLE;
#endif
	sMcard->McardC |= MCARD_FIFO_ENABLE;
}

static SWORD WaitChannelStop(void)
{
	register CHANNEL *sChannel;
	DWORD dwTimeOut;

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	dwTimeOut = 500000;
	while (dwTimeOut)
	{
		if (!(sChannel->Control & MCARD_DMA_ENABLE))
		{
			return SD_PASS;
		}
		dwTimeOut--;
	}
	MP_DEBUG1("-E- WaitChannelStop FAIL (status: %x)", sChannel->Control);
	return RES_TIMEOUT;
}

static void DmaReset(void)
{
	register CHANNEL *sChannel;
	register MCARD *sMcard;

	sMcard = (MCARD *) (MCARD_BASE);
	sChannel = (CHANNEL *) (DMA_MC_BASE);
	sChannel->Control = 0;
	sMcard->McDmarl = 0;
	sChannel->StartA = 0;
	sChannel->EndA = 0;
	sMcard->McSdIc = IM_ALL;
}


static SWORD WaitTranState(void)
{
	register MCARD *sMcard;
	DWORD dwCurState, dwRetryTime;

	dwRetryTime = 10000;
	sMcard = (MCARD *) (MCARD_BASE);

	while ((dwRetryTime--) > 0)
	{
		SetCommand(CMD_SEND_STATUS, sInfo.dwRelativeCardAddr);
		if (WaitResponse() != SD_PASS)
		{
			MP_DEBUG("send status cmd no response");
			return RES_TIMEOUT;
		}
		dwCurState = (sMcard->McSdRspA & 0xe00) >> 9;
		if (dwCurState == TRANSFER_STATE)
		{
			//MP_DEBUG("Transfer state");
			return SD_PASS;
		}

		if (dwCurState == RECEIVE_STATE)
		{
			//MP_DEBUG("Receive state");
			McardIODelay(50);
		#if 0

			SetCommand(CMD_STOP_TRANSMISSION, 0);
			if (WaitResponse() != SD_PASS)
			{
				MP_DEBUG("send stop cmd no response");				
				return RES_TIMEOUT;
			}
			SetCommand(CMD_SELECT_CARD, 0);
			if (WaitResponse() != SD_PASS)
			{
				MP_DEBUG("select to standby state no response");				
				return RES_TIMEOUT;
			}
			SetCommand(CMD_SELECT_CARD, sInfo.dwRelativeCardAddr);
			if (WaitResponse() != SD_PASS)
			{
				MP_DEBUG("select to transfer state no response");				
				return RES_TIMEOUT;
		}
		#endif			

		}

		if (dwCurState == STANDBY_STATE)
		{
            //MP_DEBUG("Standby state");
			SetCommand(CMD_SELECT_CARD, sInfo.dwRelativeCardAddr);
			if (WaitResponse() != SD_PASS)
			{
				MP_DEBUG("standby state select to transfer state no response");		
				return RES_TIMEOUT;
		}
		}

		if (dwCurState == PROGRAM_STATE)
		{
            //MP_DEBUG("Program state");
			McardIODelay(50);
		}
		if (dwCurState == NULL_STATE)
		{
//			MP_DEBUG("Null state");
//			McardIODelay(50);
		}		
		TASK_YIELD();
	}
	MP_DEBUG1("re init (dwCurState = %d)", dwCurState);
	OpenDrainDelay();
	OpenDrainDelay();
	return GoTransferMode();
}
static SWORD WaitDataRead(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, dwCause;

	sMcard = (MCARD *) (MCARD_BASE);

#ifdef SD_TIMEOUT_HANDLE
	TaskSleep();
	if (blTimeOutFlag == 1)
	{
		MP_DEBUG("-E- Read Time Out");
		return READ_TIMEOUT;
	}
	RemoveTimerProc(TimeoutHandle);
	dwCause = sMcard->McSdIc;
	if (dwCause & IC_SDTO)
	{
		MP_DEBUG1("-E- IC_SDTO FAIL (status: %x)", dwCause);
		return READ_TIMEOUT;
	}
	if (dwCause & IC_CRC16F)
	{
		MP_DEBUG1("-E- IC_CRC16F FAIL (status: %x)", dwCause);
		return BAD_CRC16;
	}
	if (dwCause & IC_TREND)
	{
		return SD_PASS;
	}
	MP_DEBUG1("-E- WaitDataRead FAIL (status: %x)", dwCause);
	return GENERAL_FAIL;
#else
	dwTimeOut = 10000000;
	while (dwTimeOut)
	{
		dwCause = sMcard->McSdIc;
		if (dwCause & IC_SDTO)
		{
			MP_DEBUG1("-E- IC_SDTO FAIL (status: %x)", dwCause);
			return READ_TIMEOUT;
		}
		if (dwCause & IC_CRC16F)
		{
			MP_DEBUG1("-E- IC_CRC16F FAIL (status: %x)", dwCause);
			return BAD_CRC16;
		}
		if (dwCause & IC_TREND)
		{
			return SD_PASS;
		}
		TASK_YIELD();
		dwTimeOut--;
	}
	MP_DEBUG1("-E- WaitDataRead FAIL (status: %x)", dwCause);
	return GENERAL_FAIL;
#endif
}

static SWORD WaitDataWrite(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, dwCause;
	sMcard = (MCARD *) (MCARD_BASE);
#ifdef SD_TIMEOUT_HANDLE
	TaskSleep();
	if (blTimeOutFlag == 1)
	{
		MP_DEBUG("-E- Write Time Out");
		return READ_TIMEOUT;
	}
	RemoveTimerProc(TimeoutHandle);
	dwCause = sMcard->McSdIc;
	if ((dwCause & IC_RSPF) || (dwCause & IC_WXF))
	{
		//MP_DEBUG1("-E- IC_RSPF or IC_WXF FAIL (status: %x)", dwCause);
		return PROGRAM_FAIL;
	}
	else if (dwCause & IC_SDTO)
	{
		//MP_DEBUG1("-E- IC_SDTO (status: %x)", dwCause);
		return WRITE_TIMEOUT;
	}
	else if (dwCause & IC_TREND)
	{
		return SD_PASS;
	}
	MP_DEBUG1("-E- WaitDataRead FAIL (status: %x)", dwCause);
	return GENERAL_FAIL;
#else
	dwTimeOut = 10000000;
	while (dwTimeOut)
	{
		dwCause = sMcard->McSdIc;
		if ((dwCause & IC_RSPF) || (dwCause & IC_WXF))
		{
			//MP_DEBUG1("-E- IC_RSPF or IC_WXF FAIL (status: %x)", dwCause);
			return PROGRAM_FAIL;
		}
		else if (dwCause & IC_SDTO)
		{
			//MP_DEBUG1("-E- IC_SDTO (status: %x)", dwCause);
			return WRITE_TIMEOUT;
		}
		else if (dwCause & IC_TREND)
		{
			return SD_PASS;
		}
		dwTimeOut--;
		TASK_YIELD();
	}
	MP_DEBUG1("-E- WaitDataWrite FAIL (status: %x)", dwCause);
	return GENERAL_FAIL;
#endif
}

static SWORD WaitBusy(void)
{
	DWORD dwTimeOut;
	register MCARD *mcard;

	mcard = (MCARD *) (MCARD_BASE);
	dwTimeOut = 10000;

	OpenDrainDelay();
	while (dwTimeOut)
	{
		if (mcard->McSdIc & IM_CRC16F)
		{
			OpenDrainDelay();
			return SD_PASS;
		}
		else
		{
			dwTimeOut--;
		}
	}
	MP_DEBUG1("-E- WaitBusy FAIL (status: %x)", mcard->McSdIc);
	return WRITE_TIMEOUT;
}

static SWORD FlatRead(DWORD dwBufferAddress, DWORD dwSectorCount, DWORD dwLogAddr)
{
	DWORD dwRetryTime;
	SWORD swRetValue;

	dwRetryTime = RETRY_TIME;
		MP_DEBUG3("-I- SD FlatRead  %d,dwLogAddr %d,dwSectorCount %d", dwRetryTime,dwLogAddr,dwSectorCount);
	while (dwRetryTime)
	{
		if (!(swRetValue = LogicalRead(dwBufferAddress, dwSectorCount, dwLogAddr)))
		{
			return SD_PASS;
		}
		dwRetryTime--;
		MP_DEBUG1("-I- FlatRead remain retry times %d", dwRetryTime);
	}
	MP_DEBUG1("-E- FlatRead FAIL (swRetValue: %d)", swRetValue);
	return swRetValue;
}

static SWORD LogicalRead(DWORD dwBufferAddress, DWORD dwSectorCount, DWORD dwLogAddr)
{
	register MCARD *sMcard;
	register CHANNEL *sChannel;
	DWORD dwTempDataBuf, dwTempBlkAddr, dwTempBlkCount, dwTemp;
	SWORD swStatus;
	if (!dwSectorCount)
	{
		return SD_PASS;
	}
	sMcard = (MCARD *) (MCARD_BASE);