cf.c

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

			pbBuffer += MCARD_SECTOR_SIZE;
			dwCount--;
		}

		dwSectorCount = dwSectorCount - dwTempSectorCount;
		dwLogAddr = dwLogAddr + dwTempSectorCount;

		if ((swRetValue = WaitReady()))
		{
			MP_DEBUG1("-E- Ready FAIL(swRetValue: %d)", swRetValue);
			return swRetValue;
		}
	}

	return PASS;
}

static SWORD Identify(DWORD * pdwTotalSector)
{
	SWORD swRetValue;
	WORD wSign;

#pragma alignvar(4)
	BYTE bReadBuffer[MCARD_SECTOR_SIZE], *pbReadBuffer;

	SetCommand(COMMAND_IDENTIFY_DRIVE);
	if ((swRetValue = CommandReady()))
	{
		MP_DEBUG1("-E- Identify command FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	pbReadBuffer = (BYTE *) (((DWORD) bReadBuffer | 0xa0000000));
	if ((swRetValue = ReadSector((DWORD) pbReadBuffer, MCARD_SECTOR_SIZE)))
	{
		MP_DEBUG1("-E- DMA Read FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	wSign = ((pbReadBuffer[1] << 8) | pbReadBuffer[0]);
	MP_DEBUG1("-I- Sign %x", wSign);
	if ((wSign == IDENTIFY_ID)||(wSign == 0x0000) ||(wSign == 0x8c8a)||(wSign == 0x44a))   // roger fix the 128MB CF card
	{
		*pdwTotalSector =
			((pbReadBuffer[123] << 24) | (pbReadBuffer[122] << 16) | (pbReadBuffer[121] << 8) |
			 pbReadBuffer[120]);
		MP_DEBUG3("-I- Total %d(%x) sectors, %d KB", *pdwTotalSector, *pdwTotalSector,
				  (*pdwTotalSector >> 1));
		return PASS;
	}
	return FAIL;
}

static SWORD WriteSector(DWORD dwBufferAdress, WORD wSize)
{
	register CHANNEL *sChannel;
	register MCARD *sMcard;
	DWORD dwTimeOutCount;

	if (dwBufferAdress & 0x3)
	{
		MP_DEBUG("-E- source buffer must align to 4 bytes boundary !");
		return FAIL;
	}

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	sMcard = (MCARD *) (MCARD_BASE);

#ifdef CF_TIMEOUT_HANDLE
	DmaIntEna(IM_MCRDDM);
	blTimeOutFlag = 0;
	AddTimerProc(2000, TimeoutHandle);
	sChannel->Control = 0x0;
	sChannel->StartA = dwBufferAdress;
	sChannel->EndA = dwBufferAdress + wSize - 1;
	sMcard->McDmarl = MCARD_DMA_LIMIT_ENABLE + (wSize >> 2);
	sMcard->McardC = ((sMcard->McardC & 0xffffffef) | MCARD_DMA_DIR_MC | MCARD_FIFO_ENABLE);
	sChannel->Control = (MCARD_DMA_ENABLE | MCARD_INT_DBFEND_ENABLE);
	TaskSleep();
	if (blTimeOutFlag == 1)
	{
		MP_DEBUG1("-E- DMA end FAIL (status: %x)", sChannel->Control);
		return DMA_TIMEOUT;
	}
	RemoveTimerProc(TimeoutHandle);
	return PASS;
#else
	sChannel->Control = 0x0;
	sChannel->StartA = dwBufferAdress;
	sChannel->EndA = dwBufferAdress + wSize - 1;
	sMcard->McDmarl = MCARD_DMA_LIMIT_ENABLE + (wSize >> 2);
	sMcard->McardC = ((sMcard->McardC & 0xffffffef) | MCARD_DMA_DIR_MC | MCARD_FIFO_ENABLE);
	sChannel->Control = MCARD_DMA_ENABLE;

	dwTimeOutCount = (g_bAniFlag & ANI_VIDEO)? (TIMEOUT_COUNT>>4):TIMEOUT_COUNT;
	while (!(sMcard->McCfIc & IC_CFTCE))
	{
		if (Polling_CF_Status())
			return FAIL;
		if (dwTimeOutCount == 0)
		{
			MP_DEBUG1("-E- FIFO transaction count FAIL (status: %x)", sMcard->McCfIc);
			return IC_SFTCE_TIMEOUT;
		}
		dwTimeOutCount--;
		TASK_YIELD();
	}
	sMcard->McCfIc &= ~IC_CFTCE;

	dwTimeOutCount = (g_bAniFlag & ANI_VIDEO)? (TIMEOUT_COUNT>>4):TIMEOUT_COUNT;
	while ((sChannel->Control & MCARD_DMA_ENABLE))
	{
		if (Polling_CF_Status())
			return FAIL;
		if (dwTimeOutCount == 0)
		{
			MP_DEBUG1("-E- DMA end FAIL (status: %x)", sChannel->Control);
			return DMA_TIMEOUT;
		}
		dwTimeOutCount--;
		TASK_YIELD();
	}
	return PASS;
#endif
}

static SWORD ReadSector(DWORD dwBufferAdress, WORD wSize)
{
	register CHANNEL *sChannel;
	register MCARD *sMcard;
	register DWORD dwTimeOutCount;

	if (dwBufferAdress & 0x3)
	{
		MP_DEBUG("-E- target buffer must align to 4 bytes boundary !");
		return FAIL;
	}

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	sMcard = (MCARD *) (MCARD_BASE);

#ifdef CF_TIMEOUT_HANDLE
	DmaIntEna(IM_MCRDDM);
	blTimeOutFlag = 0;
	AddTimerProc(2000, TimeoutHandle);
	sChannel->Control = 0x0;
	sChannel->StartA = dwBufferAdress;
	sChannel->EndA = dwBufferAdress + wSize - 1;
	sMcard->McDmarl = MCARD_DMA_LIMIT_ENABLE + (wSize >> 2);
	sMcard->McardC = ((sMcard->McardC & 0xffffffef) | MCARD_DMA_DIR_CM | MCARD_FIFO_ENABLE);
	sChannel->Control = (MCARD_DMA_ENABLE | MCARD_INT_DBFEND_ENABLE);
	TaskSleep();
	if (blTimeOutFlag == 1)
	{
		MP_DEBUG1("-E- DMA end FAIL (status: %x)", sChannel->Control);
		return DMA_TIMEOUT;
	}
	RemoveTimerProc(TimeoutHandle);
	return PASS;
#else

#if ((CHIP_VER & 0xffff0000) == CHIP_VER_600)
	dwTimeOutCount = 0x40000; //TIMEOUT_COUNT;
        volatile register IPU *ipu;
        ipu = (IPU *)IPU_BASE;
        if (g_bAniFlag & ANI_VIDEO)
        {
        while (dwTimeOutCount ) 
        {
            if (ipu->IpIc & 0x1)
                break;
            dwTimeOutCount--;
        }
        }
#endif
	sChannel->Control = 0x0;
	sChannel->StartA = dwBufferAdress;
	sChannel->EndA = dwBufferAdress + wSize - 1;
	sMcard->McDmarl = MCARD_DMA_LIMIT_ENABLE + (wSize >> 2);
	sMcard->McardC = ((sMcard->McardC & 0xffffffef) | MCARD_DMA_DIR_CM | MCARD_FIFO_ENABLE);
	sChannel->Control = MCARD_DMA_ENABLE;
	dwTimeOutCount = (g_bAniFlag & ANI_VIDEO)? (TIMEOUT_COUNT>>4):TIMEOUT_COUNT;

	while (!(sMcard->McCfIc & IC_CFTCE))
	{
		//if (Polling_CF_Status())
		//	return FAIL;

		if (dwTimeOutCount == 0)
		{
			MP_DEBUG1("-E- FIFO transaction count FAIL (status: %x)", sMcard->McCfIc);
			return IC_SFTCE_TIMEOUT;
		}
		dwTimeOutCount--;
		TASK_YIELD();
	}
	sMcard->McCfIc &= ~IC_CFTCE;

	dwTimeOutCount = (g_bAniFlag & ANI_VIDEO)? (TIMEOUT_COUNT>>4):TIMEOUT_COUNT;
	while ((sChannel->Control & MCARD_DMA_ENABLE))
	{
		//if (Polling_CF_Status())
		//	return FAIL;

		if (dwTimeOutCount == 0)
		{
			MP_DEBUG1("-E- DMA end FAIL (status: %x)", sChannel->Control);
			return DMA_TIMEOUT;
		}
		dwTimeOutCount--;
		TASK_YIELD();
	}
	return PASS;
#endif
}

static void SetCommand(BYTE bCommand)
{
	register CFATA *sCfata;

	sCfata = (CFATA *) (MC_CFCOM_BASE);
	sCfata->StatusCommand = bCommand;
}

static void SetParameter(DWORD dwSectorCount, DWORD dwLogAddr)
{
	register CFATA *sCfata;

	sCfata = (CFATA *) (MC_CFCOM_BASE);
	sCfata->Lba0 = dwLogAddr & 0xff;
	sCfata->Lba1 = (dwLogAddr >> 8) & 0xff;
	sCfata->Lba2 = (dwLogAddr >> 16) & 0xff;
	sCfata->Lba3 = ((dwLogAddr >> 24) & 0xff) | DRIVE_PROPERTY;
	sCfata->SectorCount = dwSectorCount;
}

static void Select(BYTE bMode)
{
	register GPIO *sGpio;
	register MCARD *sMcard;
	register BYTE *pbAttr;

	sGpio = (GPIO *) (GPIO_BASE);
	sMcard = (MCARD *) (MCARD_BASE);
	pbAttr = (BYTE *) (MC_CFATR_BASE);
	sMcard->McardC = MCARD_ENABLE | MCARD_DMA_DIR_CM;
//	MP_DEBUG1("McardC =%x",sMcard->McardC);
	sMcard->McCfIc = IM_ALL;
	switch (bMode)
	{
	case INITIAL_MEMORY:
                        sGpio->Fgpcfg[0] &= 0x0000ffff;
			sGpio->Fgpcfg[0] &= ~(H_GPIO_DEFINE_0); // set Fgpio[0]~Fgpio[15] as CF FD0~FD15
			sGpio->Fgpcfg[0] |= GPIO_DEFINE_0; // set Fgpio[0]~Fgpio[15] as CF FD0~FD15
			sGpio->Fgpcfg[1] &= ~(H_GPIO_DEFINE_1);
			sGpio->Fgpcfg[1] |= GPIO_DEFINE_1; // set Fgpio[16]~Fgpio[26] as CF FA~FA10,Fgpio[27~31] as CE1#,CE2#,CD1#,CD2#,OE#
			sGpio->Fgpcfg[2] &= ~(H_GPIO_DEFINE_2);
			sGpio->Fgpcfg[2] |= GPIO_DEFINE_2;	
		#if((CHIP_VER  == (CHIP_VER_B |CHIP_VER_600))||(CHIP_VER == (CHIP_VER_600 | CHIP_VER_C)))	
			sGpio->Agpcfg &= ~0x00010001; 	
			sGpio->Agpcfg |= 0x00010000; 			
		#endif
		if (g_bAniFlag & ANI_VIDEO){
			sMcard->McRtm = MEMORY_READ_TIMMING1;
		}
		else{
			sMcard->McRtm = MEMORY_READ_TIMMING;			
		}
		sMcard->McWtm = MEMORY_WRITE_TIMMING;
		sMcard->McCfC = MEMORY_SETTING;
		//MP_DEBUG("-I- Memory Mode Select");
		break;

	case INITIAL_TRUE_IDE:
                sGpio->Fgpcfg[0] &= 0x0000ffff;
		sGpio->Fgpcfg[0] |= GPIO_DEFINE_0;
		sGpio->Fgpcfg[1] |= GPIO_DEFINE_1;
		sGpio->Fgpcfg[2] |= GPIO_DEFINE_2;
		sMcard->McCfC = TRUE_IDE_SETTING;
		sMcard->McRtm = IDE_READ_TIMMING;
		sMcard->McWtm = IDE_WRITE_TIMMING;
		//MP_DEBUG("-I- True IDE Mode Select");
		break;

	case INITIAL_IO:

		sGpio->Fgpcfg[0] |= GPIO_DEFINE_0;

		//////////////////////////////////////////////////////////////
		//simulate A9 
		//gpio->Fgpcfg[1] = gpio->Fgpcfg[1] | GPIO_DEFINE_1;
		sGpio->Fgpcfg[1] |= 0x0000fdff;
		sGpio->Fgpdat[1] |= 0x02000200;
		//////////////////////////////////////////////////////////////

		sGpio->Fgpcfg[2] |= GPIO_DEFINE_2;
		sMcard->McCfC = MEMORY_SETTING;
		sMcard->McRtm = MEMORY_READ_TIMMING;
		sMcard->McWtm = MEMORY_WRITE_TIMMING;
		*pbAttr = 0x1;
		sGpio->Fgpcfg[0] |= GPIO_DEFINE_0;
		sGpio->Fgpcfg[1] |= GPIO_DEFINE_1;
		sGpio->Fgpcfg[2] |= GPIO_DEFINE_2;
		sMcard->McCfC = IO_SETTING;
		sMcard->McRtm = I_O_READ_TIMMING;
		sMcard->McWtm = I_O_WRITE_TIMMING;
		//MP_DEBUG("-I- IO Mode Select");
		break;
	}
	WaitReady();
}

static void DeSelect(void)
{
	register MCARD *sMcard;

	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McardC = 0;
}

static SWORD FlatRead(DWORD dwBufferAddress, DWORD dwSectorCount, DWORD dwLogAddr)
{
	SWORD swRetValue;
	BYTE bRetry;
		MP_DEBUG2("-I- CF FlatRead dwLogAddr %d,dwSectorCount %d", dwLogAddr,dwSectorCount);
	bRetry = MCARD_RETRY_TIME;
	while (bRetry)
	{
		if (Polling_CF_Status())
			return FAIL;
		if (!(swRetValue = LogicalRead(dwBufferAddress, dwSectorCount, dwLogAddr)))
		{
			return PASS;
		}
		bRetry--;
		MP_DEBUG1("-I- remain retry times %d", bRetry);
	}
	return swRetValue;
}

static SWORD FlatWrite(DWORD dwBufferAddress, DWORD dwSectorCount, DWORD dwLogAddr)
{
	SWORD swRetValue;
	BYTE bRetry;
		MP_DEBUG2("-I- CF FlatWrite dwLogAddr %d,dwSectorCount %d", dwLogAddr,dwSectorCount);
	bRetry = MCARD_RETRY_TIME;
	while (bRetry)
	{
		if (Polling_CF_Status())
			return FAIL;
		if (!(swRetValue = LogicalWrite(dwBufferAddress, dwSectorCount, dwLogAddr)))
		{
			return PASS;
		}
		bRetry--;
		MP_DEBUG1("-I- remain retry times %d", bRetry);
	}
	return swRetValue;
}

static SWORD Format(void)
{
	ST_DISK_PARAMETER sDiskParam;
	DWORD i, dwSectorOffset, dwDiskSize;
	SWORD swRetValue;

#pragma alignvar(4)
	BYTE bTempBuffer[MCARD_SECTOR_SIZE], *pbBuffer;


	pbBuffer = (BYTE *) (((DWORD) (&bTempBuffer[0])) | 0xa0000000);
	if ((swRetValue = Identify(&dwDiskSize)))
	{
		MP_DEBUG1("-E- Identify FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	dwDiskSize = dwDiskSize * MCARD_SECTOR_SIZE;
	if (McardGetParameter(&sDiskParam, dwDiskSize))
	{
		MP_DEBUG1("-E- Get Parameter FAIL (swRetValue: %d)", swRetValue);
		return FAIL;
	}

	//create and check master boot record
	if ((swRetValue = FlatRead((DWORD) pbBuffer, 1, 0)))
	{
		MP_DEBUG1("-E- read master boot record FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	McardMakeMbr(&sDiskParam, pbBuffer,0);
	if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, 0)))
	{
		MP_DEBUG1("-E- write master boot record FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	memset(pbBuffer, 0, MCARD_SECTOR_SIZE);
	if ((swRetValue = FlatRead((DWORD) pbBuffer, 1, 0)))
	{
		MP_DEBUG1("-E- Read master boot record FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	if (McardCheckMbr(&sDiskParam, pbBuffer,0))
	{
		MP_DEBUG1("-E- Check master boot record FAIL (swRetValue: %d)", swRetValue);
		return FAIL;
	}

	//create and check partition boot record
	memset(pbBuffer, 0, MCARD_SECTOR_SIZE);
	McardMakePbr(&sDiskParam, pbBuffer);
	if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, sDiskParam.dwHiddenSectors)))
	{
		MP_DEBUG1("-E- write partition boot record FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	memset(pbBuffer, 0, MCARD_SECTOR_SIZE);
	if ((swRetValue = FlatRead((DWORD) pbBuffer, 1, sDiskParam.dwHiddenSectors)))
	{
		MP_DEBUG1("-E- Read partition boot record FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	if (McardCheckPbr(&sDiskParam, pbBuffer))
	{
		MP_DEBUG1("-E- Check partition boot record FAIL (swRetValue: %d)", swRetValue);
		return FAIL;
	}

	// initial fat table
	memset(pbBuffer, 0, MCARD_SECTOR_SIZE);
	pbBuffer[0] = 0xf8;
	pbBuffer[1] = pbBuffer[2] = 0xff;
	dwSectorOffset = (sDiskParam.dwLogStartSector + sDiskParam.wReserveSectors);
	if (sDiskParam.bFatType == 16)
	{
		pbBuffer[3] = 0xff;
	}

	if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, dwSectorOffset)))
	{
		MP_DEBUG1("-E- write fat table 1(0) FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, (dwSectorOffset + sDiskParam.wNumFatSectors))))
	{
		MP_DEBUG1("-E- write fat table 2(0) FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	pbBuffer[0] = pbBuffer[1] = pbBuffer[2] = pbBuffer[3] = 0x00;
	for (i = 1; i < sDiskParam.wNumFatSectors; i++)
	{
		if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, (dwSectorOffset + i))))
		{
			MP_DEBUG2("-E- write fat table 1(%d) FAIL (swRetValue: %d)", i, swRetValue);
			return swRetValue;
		}
		if ((swRetValue =
			 FlatWrite((DWORD) pbBuffer, 1, (dwSectorOffset + sDiskParam.wNumFatSectors + i))))
		{
			MP_DEBUG2("-E- write fat table 2(%d) FAIL (swRetValue: %d)", i, swRetValue);
			return swRetValue;
		}
	}

	// initial directory table
	memset(pbBuffer, 0, MCARD_SECTOR_SIZE);
	dwSectorOffset =
		sDiskParam.dwLogStartSector + sDiskParam.wReserveSectors +
		(sDiskParam.bNumFats * sDiskParam.wNumFatSectors);
	// 512x32/512=32 Sectors(so Root Directory occupy 32 Sectors)
	for (i = 0; i < (sDiskParam.wRootEntries * 32 / sDiskParam.wSectorSize); i++)
	{
		if ((swRetValue = FlatWrite((DWORD) pbBuffer, 1, (dwSectorOffset + i))))
		{
			MP_DEBUG2("-E- write directory table(%d) FAIL (swRetValue: %d)", i, swRetValue);
			return swRetValue;
		}
	}
	return PASS;
}
#endif   //#if CF_ENABLE //byAlexWang 24jun2007 m2project