ms.c

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

	}

	
	SetDataDma(dwBufferAddress);

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

	if ((swRetValue = Wait_For_INT_Pulse(&dwMcMsStatusTemp)))
	{
		MP_DEBUG1("-E- WaitTime1INT FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	
	if(dwMcMsStatusTemp & (STATUS_ERR||STATUS_CMDNK))
	{
		if ((swRetValue = GetIntValue(&bIntValue)))
		{
			MP_DEBUG1("-E- GetINT FAIL (swRetValue: %d)", swRetValue);
			return swRetValue;
		}
	}
	return PASS;
}

#endif


static SWORD ChangeBusWidth(BYTE bBusWidth)
{
	SWORD swRetValue;
	BYTE bSysParameter;


	SetRWRegTpcAddr(0x00, 0x00, 0x10, 0x01);
	if (bBusWidth == BUS_WIDTH_4)
	{
		bSysParameter = 0x00;
	}
	else
	{
		bSysParameter = 0x80;
	}

	if ((swRetValue = WriteTpcBs(TPC_SET_RW_REG_ADR, (BYTE *) (&sRWRegTpcAddr), 4)))
	{
		MP_DEBUG1("-E- TPC_SET_RW_REG_ADR FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}

	if ((swRetValue = WriteTpcBs(TPC_WRITE_REG, (BYTE *) (&bSysParameter), 1)))
	{
		MP_DEBUG1("-E- TPC_WRITE_REG FAIL (swRetValue: %d)", swRetValue);
		return swRetValue;
	}
	if (bBusWidth == BUS_WIDTH_4)
	{
	sInfo.bBusWidth = BUS_WIDTH_4;
	}
	else
	{
		sInfo.bBusWidth = BUS_WIDTH_1;
	}	

	return PASS;
}

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

	sChannel = (CHANNEL *) (DMA_MC_BASE);
	dwTimeOut = 0x00100000;
	while ((sChannel->Control & MCARD_DMA_ENABLE))
	{
		if (Polling_MS_Status())
			return FAIL;
		if (dwTimeOut == 0)
		{
			return DMA_TIMEOUT;
		}
		dwTimeOut--;
		TASK_YIELD();
	}
	return PASS;
}

static DWORD WaitCmdEnd(void)
{
	MCARD *sMcard;
	DWORD dwTimeOut;

	sMcard = (MCARD *) (MCARD_BASE);
	dwTimeOut = 0x001000;
#ifdef MS_IRQ
	while (!McardGetInt())
	{
		if (Polling_MS_Status())
			return FAIL;
		if (sMcard->
			McMsStatus & (STATUS_TIMEOUT1 | STATUS_TIMEOUT0 | STATUS_CRCERROR | STATUS_CMDEND))
		{
			break;
		}

		if (dwTimeOut == 0)		// abel add
		{
			sMcard->McMsStatus = STATUS_TIMEOUT1;
			break;
		}

		dwTimeOut--;
		TASK_YIELD();
	}

	sMcard->McMsIc = 0;
	SystemIntDis(IC_MCARD);
	McardClrInt();
#else
	while((sMcard->McMsStatus & STATUS_CMDEND) !=STATUS_CMDEND);	
#endif

	return sMcard->McMsStatus;
}

static DWORD WaitRdy(void)
{
	MCARD *sMcard;
	DWORD dwTimeOut;

	sMcard = (MCARD *) (MCARD_BASE);
	dwTimeOut = 0x0010000;
#ifdef MS_IRQ
	while (!McardGetInt())
	{
		if (Polling_MS_Status())
			return FAIL;
		if (sMcard->McMsStatus & STATUS_TIMEOUT0)
		{
			break;
		}

		if (dwTimeOut == 0)		// abel add
		{
			sMcard->McMsStatus = STATUS_TIMEOUT0;
			break;
		}

		dwTimeOut--;
		TASK_YIELD();
	}
	sMcard->McMsIc = 0x0;
	McardClrInt();
#else
		while(!(sMcard->McMsStatus & STATUS_TIMEOUT0))
#endif
	return sMcard->McMsStatus;
}

static SWORD GetIntValue(BYTE * bIntValue)
{
	register SWORD swRetValue;
	register BYTE bTemp;
	if ((swRetValue = ReadTpcBs(TPC_GET_INT, bIntValue, 1)))
	{
		return swRetValue;
	}
	return PASS;
}


static SWORD WaitINT(void)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, i;

	sMcard = (MCARD *) (MCARD_BASE);
	for (dwTimeOut = 0; dwTimeOut < 0x00010000; dwTimeOut++)
	{
		if (sMcard->McMsStatus & STATUS_CMDINT)
		{
			return PASS;
		}
		#if 0//rick ms pro fast , 7/25
		McardIODelay(50);
		#endif
		TASK_YIELD();
	}
	return TPC_INT_TIMEOUT;
}

static SWORD Wait_INT_Signal(DWORD *dwMcMsStatusTemp)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, i;

	sMcard = (MCARD *) (MCARD_BASE);
	for (dwTimeOut = 0; dwTimeOut < 0x10000000; dwTimeOut++)
	{
		*dwMcMsStatusTemp = sMcard->McMsStatus;
		if (*dwMcMsStatusTemp & STATUS_CMDINT)
		{
//			MP_DEBUG1("Wait_INT_Signal McMsStatus = %x",*dwMcMsStatusTemp);
			return PASS;
		}
		TASK_YIELD();
	}
	return TPC_INT_TIMEOUT;
}
static SWORD Wait_INT_Signal_BREQ(DWORD *dwMcMsStatusTemp)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, i;

	sMcard = (MCARD *) (MCARD_BASE);
	for (dwTimeOut = 0; dwTimeOut < 0x10000000; dwTimeOut++)
	{
		*dwMcMsStatusTemp = sMcard->McMsStatus;
		if (*dwMcMsStatusTemp & STATUS_BREQ)
		{
//			MP_DEBUG1("Wait_INT_Signal_BREQ McMsStatus = %x",*dwMcMsStatusTemp);
			return PASS;
		}
//		if(MsWrite == TRUE)
//			McardIODelay(50); // rick ,if remove will cause write fail

		TASK_YIELD();
	}

	return TPC_INT_TIMEOUT;
}
static SWORD Wait_INT_Signal_CED(DWORD *dwMcMsStatusTemp)
{
	register MCARD *sMcard;
	DWORD dwTimeOut, i;

	sMcard = (MCARD *) (MCARD_BASE);
	for (dwTimeOut = 0; dwTimeOut < 0x10000000; dwTimeOut++)
	{
		*dwMcMsStatusTemp = sMcard->McMsStatus;
		if (*dwMcMsStatusTemp & STATUS_CED)
		{
//			MP_DEBUG1("Wait_INT_Signal_CED McMsStatus = %x",*dwMcMsStatusTemp);
			return PASS;
		}
//		if(MsWrite == TRUE)
//			McardIODelay(50); // rick ,if remove will cause write fail

		TASK_YIELD();
	}
	return TPC_INT_TIMEOUT;
}

// Use hardware timeout (time1 setting)
// used at TPC_SET_CMD(TPC_EX_SET_CMD)

static SWORD WaitTime1INT(void)
{
	MCARD *sMcard;
	DWORD dwTimeout;

	sMcard = (MCARD *) (MCARD_BASE);
	#if 1// rick ms pro faster 7/4  , 7/25
	dwTimeout = 0x01000000;
	while (!(sMcard->McMsStatus & (STATUS_TIMEOUT1 | STATUS_CMDINT)))
	{
		if (Polling_MS_Status())
			return FAIL;
		if (dwTimeout == 0)
		{
			return TPC_INT_TIMEOUT;
		}
		McardIODelay(1);
		dwTimeout--;
	}
	#else
	while (!(sMcard->McMsStatus & STATUS_CMDINT))
	{
		if (Polling_MS_Status())
			return FAIL;
	}	
	#endif
	if (sMcard->McMsStatus & STATUS_TIMEOUT1)
	{
		return TPC_INT_TIMEOUT;
	}
	return PASS;
}

static SWORD Wait_For_INT_Pulse(DWORD *dwMcMsStatusTemp)//rick ms pro faster 7/4
{
	MCARD *sMcard;
	DWORD dwTimeout;
	sMcard = (MCARD *) (MCARD_BASE);
	dwTimeout = 0x01000000;
	while (!((*dwMcMsStatusTemp = sMcard->McMsStatus) & (STATUS_TIMEOUT1 | STATUS_CMDINT)))
	{
		if (Polling_MS_Status())
			return FAIL;
		if (dwTimeout == 0)
		{
			return TPC_INT_TIMEOUT;
		}
//		McardIODelay(1);
		dwTimeout--;
	}

	return PASS;
}

//Memory Stick Write TPC Bus State (none page mode)
static SWORD WriteTpcBs(register BYTE bTpc, register BYTE * pbBuffer, register BYTE bLen)
{
	register MCARD *sMcard;
	register DWORD dwTemp, dwTimeout;
	register BYTE i;

	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McardC = 0;
	#if ((STD_BOARD_VER == MP600PQFP_8M_SDRAM)||(STD_BOARD_VER == MP600_128PQFP_CPU_8M_SDRAM))
		sMcard->McardC = BIT11+MCARD_DMA_DIR_MC + sInfo.bBusWidth + (MCARD_FIFO_EMPTY | MCARD_ENABLE);    
	#else
		sMcard->McardC = MCARD_DMA_DIR_MC + sInfo.bBusWidth + (MCARD_FIFO_EMPTY | MCARD_ENABLE);
	#endif

	// Set int mask
	sMcard->McMsIc = 0;
	#ifdef MS_IRQ
	sMcard->McMsIc = (PL_ALL_HIGH | IM_CMDEND | IM_TIMEOUT1 | IM_INVALIDCMD);	// tpc cmd end, INT time out, invalid tpc cmd
	SystemIntEna(IC_MCARD);
	#else
	SystemIntDis(IC_MCARD);
	#endif
	sMcard->McMsCmd = bTpc + DATA_PATH_BY_CPU + PAGE_MOD_BY_DATA_LEN + (bLen << 8);

	// Wait write request
	dwTimeout = 0x800000;
	#if 1 //rick ms pro fast , 7/25
	while (!(sMcard->McMsStatus & STATUS_HWRREQ))
	{
      if (Polling_MS_Status()) return FAIL;
		if (dwTimeout == 0)
		{
			return TPC_RB_TIMEOUT;
		}
		dwTimeout--;
	}
	#endif

	for (i = 0; i < bLen; i = i + 4)
	{
		dwTemp =
			(pbBuffer[i] << 24) + (pbBuffer[i + 1] << 16) + (pbBuffer[i + 2] << 8) +
			(pbBuffer[i + 3]);
		sMcard->McMsFifo = dwTemp;
		dwTimeout = 0x00100000;
		while (sMcard->McMsStatus & STATUS_FIFOFULL)
		{
          if (Polling_MS_Status()) return FAIL;
			if (dwTimeout == 0)
			{
				return TPC_RB_TIMEOUT;
			}
			dwTimeout--;
		}
	}

	// Wait cmd end
	dwTemp = WaitCmdEnd();

	if (dwTemp & STATUS_TIMEOUT0)
	{
		return TPC_RB_TIMEOUT;
	}
	else if (dwTemp & STATUS_TIMEOUT1)
	{
		return TPC_INT_TIMEOUT;
	}
	else
	{
		return PASS;
	}
}

//Memory Stick Read TPC Bus State (none page mode)
static SWORD ReadTpcBs(register BYTE bTpc, register BYTE * pbBuffer, register BYTE bLen)
{
	register MCARD *sMcard;
	register DWORD dwTemp, dwTimeout;
	register WORD i;

	sMcard = (MCARD *) (MCARD_BASE);
	sMcard->McardC = 0;
 
	#if ((STD_BOARD_VER == MP600PQFP_8M_SDRAM)||(STD_BOARD_VER == MP600_128PQFP_CPU_8M_SDRAM))
		sMcard->McardC = BIT11+MCARD_DMA_DIR_CM + sInfo.bBusWidth + (MCARD_FIFO_EMPTY | MCARD_ENABLE);		  
	#else
		sMcard->McardC = MCARD_DMA_DIR_CM + sInfo.bBusWidth + (MCARD_FIFO_EMPTY | MCARD_ENABLE);		
	#endif

	dwTimeout = 0x100000;
	#if 1//rick ms pro fast , 7/25
	while (!(sMcard->McMsStatus & STATUS_FIFOIDLE))	// Wait fifo idle
	{
      if (Polling_MS_Status()) return FAIL;
		if (dwTimeout == 0)
		{
			return TPC_RB_TIMEOUT;
		}
		dwTimeout--;
	}
	#endif
	// Set int mask
	sMcard->McMsIc = 0;
	#ifdef MS_IRQ
	sMcard->McMsIc = (PL_ALL_HIGH | IM_CMDEND | IM_TIMEOUT1 | IM_INVALIDCMD | IM_HRDREQ);	// read req, tpc cmd end, INT time out, invalid tpc cmd
	SystemIntEna(IC_MCARD);
	#else
	SystemIntDis(IC_MCARD);
	#endif
	
	sMcard->McMsCmd = bTpc + DATA_PATH_BY_CPU + PAGE_MOD_BY_DATA_LEN + (bLen << 8);

	// Wait read request or r/b time out
	dwTemp = WaitRdy();
	if (dwTemp & STATUS_TIMEOUT0)
	{
		SystemIntDis(IC_MCARD);
		McardClrInt();
		return TPC_RB_TIMEOUT;
	}

	i = 0;
	while (i < bLen)
	{
		if (!(i & 0x03))
		{
			dwTimeout = 0x100000;
			while (sMcard->McMsStatus & STATUS_FIFOEMPTY)
			{
              if (Polling_MS_Status()) return FAIL;
				if (dwTimeout == 0)
				{
					return TPC_RB_TIMEOUT;
				}
				dwTimeout--;
			}
			dwTemp = sMcard->McMsFifo;
		}
		pbBuffer[i] = (BYTE) ((dwTemp & 0xff000000) >> 24);
		dwTemp <<= 8;
		i++;
	}

	// Wait cmd end
	dwTemp = WaitCmdEnd();
	if (dwTemp & STATUS_TIMEOUT1)
	{
		return TPC_INT_TIMEOUT;
	}
	else if (dwTemp & STATUS_CRCERROR)
	{
		return READ_DATA_CRC_ERROR;
	}
	else
	{