msdc.c

8032底层驱动部分。因为可以移植 所以单独来拿出来

	}
	else
	{	// ON
		#if 0 // !defined(MSDC_USE_INT)
/* under construction !*/
		#endif		
		DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_MSDC,PDN_MSDC);
		#if defined(MSDC_USE_USB_CLK) && defined(__MSDC_SD_MMC__)
		if(gSD.flags & SD_FLAG_USE_USB_CLK)
			UPLL_Enable(UPLL_OWNER_MSDC);		
		#endif
	}
	// turn on MSDC_PDN bit always recently to cover sleep mode card detection
	#if 0 // !defined(USE_INT26_CARD_DETECTION)
/* under construction !*/
	#endif	


}
/*************************************************************************
* FUNCTION
*  MSDC_TimeOutHandler
*
* DESCRIPTION
*	Callback function of gpt timer, and launched while MSDC busy for a while

*
* PARAMETERS
*	
*
* RETURNS
*
* GLOBALS AFFECTED
*
*
*************************************************************************/
void MSDC_TimeOutHandler(void *parameter)
{
	kal_print("MSDC_TimeOutHandler");
	gMSDC_Handle.is_timeout = KAL_TRUE;	
	#if defined(__MSDC_MS__)||defined(__MSDC_MSPRO__)
	kal_set_eg_events(MSDC_Events,
				(EVENT_MSIFIRQ|EVENT_DMAIRQ|EVENT_MSRDYIRQ),
				KAL_OR);	
	#else
	kal_set_eg_events(MSDC_Events,
				(EVENT_SDCMDIRQ|EVENT_SDDATIRQ|EVENT_SDMCIRQ|EVENT_SDR1BIRQ|EVENT_DMAIRQ),
				KAL_OR);	
	#endif	
}

/*************************************************************************
* FUNCTION
*  MSDC_GetCardStatus
*
* DESCRIPTION
*	Check currently card is present or not.
*
* PARAMETERS
*	
*
* RETURNS
*
* GLOBALS AFFECTED
*	msdc_eint_state
*
*
*************************************************************************/
int MSDC_GetCardStatus(void * DriveData, int AckType)
{
	msdc_card_ind_strcut* ind = (msdc_card_ind_strcut*)DriveData;
	
	ind->type = gMSDC_Handle.mMSDC_type;
	ind->present = gMSDC_Handle.mIsPresent;
	send_ilm = KAL_TRUE;
	if(ind->present == KAL_FALSE)
		MSDC_PDNControl(KAL_TRUE);
	
	return 0;
}
/*************************************************************************
* FUNCTION
*  MSDC_SendCardInd
*
* DESCRIPTION
*	Send card indication to the specified module.
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*
*************************************************************************/
void MSDC_SendCardInd(module_type dest_id)
{
#if !defined(__MSDC_SD_SDIO__)
   ilm_struct *msdc_ilm;
   
	if(send_ilm)
	{
	   msdc_card_detect_ind_struct *local;
	   
	   local = (msdc_card_detect_ind_struct*)
				   construct_local_para(sizeof(msdc_card_detect_ind_struct), TD_CTRL);	   
	   local->media_size = 1;
	   local->media_array = &gMSDC_Handle;
	   
		send_ilm = KAL_FALSE;
	   msdc_ilm = allocate_ilm(MOD_DRV_HISR);
	   msdc_ilm->src_mod_id = MOD_DRV_HISR;
	   msdc_ilm->msg_id = MSG_ID_MSDC_CARD_DETECT_IND;
	   msdc_ilm->sap_id = DRIVER_PS_SAP;
	   msdc_ilm->local_para_ptr = (local_para_struct *)local;
	   msdc_ilm->peer_buff_ptr = NULL;   
	   msdc_ilm->dest_mod_id = dest_id;
	   msg_send_ext_queue(msdc_ilm);
	}
#endif
}
/*************************************************************************
* FUNCTION
*  MSDC_GetMediaChanged
*
* DESCRIPTION
*	Check if the media is changed, and clear the status after function call
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*
*************************************************************************/
kal_bool MSDC_GetMediaChanged(void)
{	
	kal_bool ret;
	kal_uint32 _savedMask;
	
	_savedMask = SaveAndSetIRQMask();
	
	ret = (gMSDC_Handle.mIsChanged )?(KAL_TRUE):(KAL_FALSE);
	gMSDC_Handle.mIsChanged = KAL_FALSE;
	
	RestoreIRQMask(_savedMask);
	
	return ret; 
}
/*************************************************************************
* FUNCTION
*  MSDC_InvertN
*
* DESCRIPTION
* 	Invert the order of bytes eg,
* 	src: 0x01 0x02, len: 2 => dest: 0x02 0x01 
*
* PARAMETERS
*	1. dest: used for store inverted result
*	2. src: source for inverting
*	3. len: bytes for inverting
*
* RETURNS
*
* GLOBALS AFFECTED
*
* NOTE
*	1. make sure dest has the same size with src.
*************************************************************************/
void MSDC_InvertN(kal_uint8 *dest, kal_uint8 *src, kal_uint8 len)
{
	int i;
	for(i=0; i<len; i++)
		*(dest+len-1-i) = *(src+i);
	
}
/*************************************************************************
* FUNCTION
*  MSDC_Config_INS_WP
*
* DESCRIPTION
* 	Configure the pull up or pull down status for INS and WP pin
*
* PARAMETERS
*	1. ins: MSDC_IOCTRL_PULL_DOWN, MSDC_IOCTRL_PULL_UP
*	2. wp: MSDC_IOCTRL_PULL_DOWN, MSDC_IOCTRL_PULL_UP
*
* RETURNS
*
* GLOBALS AFFECTED
*
* NOTE
*	1. MT6219 can not be configured to PULL up or down. They are all pulled up by IO.
*	2. MT6218B and MT6217, WP is configured with data lines.
*************************************************************************/
void MSDC_Config_INS_WP(msdc_ioctrl_enum ins, msdc_ioctrl_enum wp)
{
	kal_uint32 msdc_cfg,iocon;
		
	gMSDC_Handle.ins_level = ins;
	#if defined(MT6218B) || defined(MT6217) || defined(MT6225)
	// INS use PRCFG0, WP use PRCFG2 together with data line (must pull high)
	msdc_cfg = *(volatile kal_uint32 *)MSDC_CFG;
	msdc_cfg &= ~(MSDC_CFG_PRCFG0);	
	msdc_cfg |= (ins << 22); 
	*(volatile kal_uint32 *)MSDC_CFG = msdc_cfg;	
	#elif defined(MT6219)||defined(MT6227)||defined(MT6226)||defined(MT6226M)
   #ifndef __CUST_NEW__
	// INS use GPIO14, WP use GPIO15
	GPIO_ModeSetup(14,1); // enable card insertion signal
	GPIO_ModeSetup(15,1); // enable write protection signal		
   #endif /* __CUST_NEW__ */
	if(ins == MSDC_IOCTRL_PULL_DOWN)
		GPIO_PullenSetup(MSDC_GPIO_MCINS, KAL_FALSE);	
	//#elif defined(MT6228)||defined(MT6229)||defined(MT6227)||defined(MT6226)||defined(MT6226M)
	#else
	msdc_cfg = *(volatile kal_uint32 *)MSDC_CFG;
	// INS use PRCFG3, WP use PRCFG0
	msdc_cfg &= ~(MSDC_CFG_PRCFG0);	
	msdc_cfg |= (wp << 22); 
	*(volatile kal_uint32 *)MSDC_CFG = msdc_cfg;
	iocon = *(volatile kal_uint16*)MSDC_IOCON;
	iocon &= ~(MSDC_IOCON_PRCFG3);
	iocon |= (ins<<8);	
	*(volatile kal_uint32 *)MSDC_IOCON = iocon;
	#endif	
}
/*************************************************************************
* FUNCTION
*  MSDC_Initialize
*
* DESCRIPTION
*	Initialize the MS/SD host controller, called only once at drv_init
*
* PARAMETERS*	
*
* RETURNS
*  1: initailized failed 
*  0: successful
*
* GLOBALS AFFECTED
*	gMSDC_Handle
*
*************************************************************************/
void MSDC_Initialize(void)
{	
	// turn on the power of controler
	DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_MSDC,PDN_MSDC);
#if defined(__MSDC_MS__)
	MSDC_CLR_BIT32(MSDC_CFG, MSDC_CFG_MSDC);
	gMSDC_Handle.mMSDC_type = MS_CARD;
#elif defined(__MSDC_MSPRO__)
	MSDC_CLR_BIT32(MSDC_CFG, MSDC_CFG_MSDC);
	gMSDC_Handle.mMSDC_type = MSPRO_CARD;	
#elif defined(__MSDC_SD_MMC__)
	MSDC_SET_BIT32(MSDC_CFG, MSDC_CFG_MSDC)	;
	gMSDC_Handle.mMSDC_type = SD_CARD;
#endif		
	gMSDC_Handle.msdc_clock = MSDC_CLOCK;

	if(gMSDC_Handle.gpt_handle == 0)
		GPTI_GetHandle(&gMSDC_Handle.gpt_handle);

	#if !defined(__MSDC_TFLASH_DAT3_1BIT_HOT_PLUG__)
	MSDC_Config_INS_WP(MSDC_IOCTRL_PULL_UP,MSDC_IOCTRL_PULL_UP);
	#else
	MSDC_Config_INS_WP(MSDC_IOCTRL_PULL_DOWN,MSDC_IOCTRL_PULL_UP);
	// first time if card is present, no card insertion interrupt generated
	gMSDC_Handle.mIsPresent = KAL_TRUE; 
	#endif
	
	// turn on the power of memory card
	MSDC_SET_BIT32(MSDC_CFG,MSDC_CFG_VDDPD);
	MSDC_SET_FIFO(1);
	
	#if defined(__MSDC_NOT_SUPPORT_HOT_PLUG__)
	gMSDC_Handle.mIsPresent = KAL_TRUE; 
	#else
	// enable card detection
	*(volatile kal_uint32*)MSDC_PS = MSDC_PS_CDEN|MSDC_PS_PIEN0|MSDC_PS_POEN0;		
	if(*(volatile kal_uint16*)MSDC_PS & MSDC_PS_PIN0)
	{
		if(gMSDC_Handle.ins_level == MSDC_IOCTRL_PULL_UP)
			gMSDC_Handle.mIsPresent = KAL_FALSE;	
		else
			gMSDC_Handle.mIsPresent = KAL_TRUE;	
	}
	else
	{
		if(gMSDC_Handle.ins_level == MSDC_IOCTRL_PULL_UP)
			gMSDC_Handle.mIsPresent = KAL_TRUE;
		else
			gMSDC_Handle.mIsPresent = KAL_FALSE;	
	}
	#endif //__MSDC_NOT_SUPPORT_HOT_PLUG__
	
	#if !defined(__MSDC_NOT_SUPPORT_HOT_PLUG__) && !defined(USE_INT26_CARD_DETECTION)
	MSDC_SET_BIT32(MSDC_CFG, MSDC_CFG_PINEN);	
	#endif
			
	#ifdef MSDC_INT
	MSDC_INT_Init();	
	#endif	// end of MSDC_INT
	#ifdef MSDC_DMA
	MSDC_DMAInit();
	#endif	
	#ifdef __MULTI_BOOT__
	if(stack_query_boot_mode() != NORMAL_BOOT)
		send_ilm = KAL_FALSE;
	else
		send_ilm = KAL_TRUE;
	#else
		send_ilm = KAL_FALSE;
	#endif
		
	DRVPDN_Enable(DRVPDN_CON1,DRVPDN_CON1_MSDC,PDN_MSDC);	
}

/*************************************************************************
* FUNCTION
*  BitFieldWrite32
*
* DESCRIPTION
*	Write src to dest at mask position
*
* PARAMETERS
*	dest: destination to be update
*	src: value to be written
*	mask: bit mask
* RETURNS
*
* GLOBALS AFFECTED
*	
*
*************************************************************************/
// Note: mask must be a continuous area during 32bits. eg,
// dest : 00A30000 , src : BF, mask : 0000BF00.
// after BitFieldCpy, dest : 00A3BF00, copy src to dest at mask position.
void BitFieldWrite32(kal_uint32 * dest, kal_uint32 src, kal_uint32 mask)
{
	kal_uint8 bit_pos;
	kal_uint32 tmp;
	
	bit_pos = 0;
	tmp = *(kal_uint32 *)dest;
	// get bit positoin
	while(!((mask >> bit_pos++) & 1));	
	//use mask clear the corresponding area	
	tmp &= ~mask;
	//shift src to the corresponding positiion
	src <<= (bit_pos - 1);
	//copy src into destination	
	tmp |= src;
	*(kal_uint32 *)dest = tmp;	
}
/*************************************************************************
* FUNCTION
*  BitFieldRead32
*
* DESCRIPTION
*	read src to dest at mask position
*
* PARAMETERS
*	dest: destination to store
*	src: value to be written
*	mask: bit mask
* RETURNS
*
* GLOBALS AFFECTED
*	
*
*************************************************************************/

// Note: mask must ve continuous area during 32 bits.eg, 
// src : 00A3BF00, mask : 00FF0000
// after BitFieldRead, dest : A3
void BitFieldRead32(kal_uint32 * dest, kal_uint32 src, kal_uint32 mask)
{
	kal_uint8 bit_pos = 0;
	
	while(!((mask >> bit_pos++) & 1));
	src &= mask;
	*(kal_uint32 *)dest = src >> (bit_pos - 1);
}
// get the bit field value of start_bit with width bits
// note 1) start_bit start from bit 0
//		2) prepare dest with initialized with zeros
//		3) width must less than 32 if using the retrun value as a result
// eg,
// src:00110110, start_bit:2,width:3 => dest:101 
kal_uint32 GetBitFieldN(kal_uint8* dest, kal_uint8* src, kal_uint16 start_bit, kal_uint16 width)
{
	int i;
	kal_uint16 bytes, bits;

	// kal_mem_set(dest,0,width/8+1);
	for( i = 0; i < width; i++)
	{	
		bytes = (start_bit+i)/8;
		bits  = (start_bit+i)%8;		
		*(dest+i/8) |= (kal_uint8)(((*(src+bytes) >> bits) & 1) << (i%8));		
	}
	return *(kal_uint32*)dest;
}

#ifdef MSDC_DMA 
extern kal_uint8 DMA_GetChannel(DMA_Master DMA_CODE);
/*************************************************************************
* FUNCTION
*  MSDC_DMAInit
*
* DESCRIPTION
*	Initialize MSDC's DMA
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*	
*
*************************************************************************/
void MSDC_DMAInit(void)
{
	msdc_dmaport = DMA_GetChannel(DMA_MSDC);
	msdc_menu.TMOD.burst_mode = KAL_TRUE;
	msdc_menu.TMOD.cycle = 0x4;
	msdc_menu.master = DMA_MSDC;
	msdc_menu.addr = NULL;

	msdc_input.type = DMA_HWRX;
	msdc_input.size = DMA_LONG;
	msdc_input.count = 0;
	msdc_input.menu = &msdc_menu;
	//msdc_input.callback = MSDC_DMA_Callback;	
}
/*************************************************************************
* FUNCTION
*  MSDC_DMATransfer
*
* DESCRIPTION
*	MSDC using DAM for data transfer 
*
* PARAMETERS
*	adrs: data buffer
*	count: bytes to be transfered
*	isTx: ture for move data from MSDC to data buffer and vise versa
*
* RETURNS
*
* GLOBALS AFFECTED
*	
*
*************************************************************************/
void MSDC_DMATransferFirst(kal_uint32 adrs,kal_uint32 count, kal_bool isTx)
{
	kal_uint32 total_count;
	kal_bool is_aligned, is_poll;

	DMA_Stop(msdc_dmaport);	
	msdc_menu.addr = adrs;
	gMSDC_Handle.timeout_period = (10 + (count>>7));
	
	if(isTx)
	{
		gMSDC_Handle.timeout_period = (10 + (count>>5));
		msdc_input.type = DMA_HWTX;		
		if(count <= MSDC_WRITE_THD_POLL)
		//if(0)
		{
			msdc_input.callback = NULL;
			is_poll = KAL_TRUE;			
		}
		else
		{
			msdc_input.callback = MSDC_DMA_Callback;
			is_poll = KAL_FALSE;
		}
	}
	else