usb_drv.c

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

	{
		return g_UsbDrvInfo.ep_out_stall_status[ep_num-1];
	}
}

/* if __OTG_ENABLE__, only activate OTG ISR*/
#ifndef __OTG_ENABLE__

void USB_Drv_Create_ISR(void)
{
	IRQ_Register_LISR(IRQ_USB_CODE, USB_LISR,"USB");
	DRV_Register_HISR(DRV_USB_HISR_ID, USB_HISR);
}

/* acivate USB interrput (LISR and HISR) */
void USB_Drv_Activate_ISR(void)
{
	IRQSensitivity(IRQ_USB_CODE,LEVEL_SENSITIVE);
	IRQUnmask(IRQ_USB_CODE);
}
#endif


/************************************************************
	system ctrl functions
*************************************************************/

/* USB PDN enable, other modules may need USB PDN*/
void USB_PDNEnable(USB_PDN_OWNER owner)
{
	 kal_uint32 savedMask;
	 
	 savedMask = SaveAndSetIRQMask();   
	 g_usb_pdn_owner &= (~(1<<owner));          
	 if(g_usb_pdn_owner == 0)
	 {
	 	DRVPDN_Enable(DRVPDN_CON0,DRVPDN_CON0_USB,PDN_USB);     	
	 }
	 RestoreIRQMask(savedMask);
}

/* USB PDN disable, other modules may need USB PDN*/
void USB_PDNDisable(USB_PDN_OWNER owner)
{
	kal_uint32 savedMask;
	
	savedMask = SaveAndSetIRQMask();   
	if(g_usb_pdn_owner == 0)
	{
		DRVPDN_Disable(DRVPDN_CON0,DRVPDN_CON0_USB,PDN_USB);  
	}
	g_usb_pdn_owner |= (1<<owner);    
	RestoreIRQMask(savedMask);
}

/* control usb power, pdn_en KAL_TRUE means power off */
void USB_PDNmode(kal_bool pdn_en)
{
	volatile kal_uint32 delay;

	if(pdn_en)
	{
		/* power down */
		IRQMask(IRQ_USB_CODE);
		/* disable sequence:1. GPIO(D+), 2. USB(USB register), 3. PDN_USB(USB power), 4. UPLL */
		USB_PowerControl(KAL_FALSE);
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))	
		DRV_WriteReg8(USB_CTL, 0);
		DRV_WriteReg8(USB_INT_ENB, 0);
		DRV_WriteReg8(OTG_INT_EN, 0);
		DRV_WriteReg8(USB_SOFT_RST, VUSB_SOFT_RST_EN);
		for(delay=0;delay<10;delay++);	/* wait for stable*/
#else
		DRV_WriteReg8(USB_ENABLE, USB_ENABLE_DIS);
#endif
		USB_PDNEnable(USB_PDN_OWNER_USB);
		UPLL_Disable(UPLL_OWNER_USB);
		// disable USB intr after PDN down	
		//IRQUnmask(IRQ_USB_CODE);
#ifdef DCM_ENABLE
		/* Prevent from USB cable have been plugged out before configuring any USB type */
		if(g_usb_dcm_handle != 255)
		{
			DCM_Enable(g_usb_dcm_handle);
		}
#endif
	}
	else
	{
#ifdef DCM_ENABLE
		if(g_usb_dcm_handle == 255)
			g_usb_dcm_handle = DCM_GetHandle();
		if(g_usb_dcm_handle == 255)
			EXT_ASSERT(0, g_usb_dcm_handle, 0, 0);	
		DCM_Disable(g_usb_dcm_handle);
#endif		
		/* enable sequence: 1. UPLL, 2.PDN_USB(USB power), 3.USB(USB register), 4.GPIO(D+) */
		UPLL_Enable(UPLL_OWNER_USB);
		USB_PDNDisable(USB_PDN_OWNER_USB);
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))		
#else		
		{
			// clear interrupt before previous power down PDN, the interrupts are read then clear
			kal_uint8 IntrUSB;
			IntrUSB = DRV_Reg8(USB_INTRUSB);
			IntrUSB = DRV_Reg8(USB_INTRIN1);
			IntrUSB = DRV_Reg8(USB_INTROUT1);
		}	
		DRV_WriteReg8(USB_ENABLE, USB_ENABLE_EN);
#endif
		for(delay=0;delay<500;delay++); /* wait for power stable*/
		USB_PowerControl(KAL_TRUE);
	}
}

/* reset hw power*/
void USB_Reset_Drv(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	WRITE_EP0_BDT_ADDR(USB_BDT_RX, USB_BDT_EVEN, USB_FIFO_RX0_EVEN);
	WRITE_EP0_BDT_ADDR(USB_BDT_RX, USB_BDT_ODD, USB_FIFO_RX0_ODD);
	WRITE_EP0_BDT_ADDR(USB_BDT_TX, USB_BDT_EVEN, USB_FIFO_TX0_ODD);
	WRITE_EP0_BDT_ADDR(USB_BDT_TX, USB_BDT_ODD, USB_FIFO_TX0_ODD);
	WRITE_EPN_BDT_ADDR(1, USB_BDT_RX, USB_FIFO_RX1);
	WRITE_EPN_BDT_ADDR(1, USB_BDT_TX, USB_FIFO_TX1);
	WRITE_EPN_BDT_ADDR(2, USB_BDT_RX, USB_FIFO_RX2);
	WRITE_EPN_BDT_ADDR(2, USB_BDT_TX, USB_FIFO_TX2);
	WRITE_EPN_BDT_ADDR(3, USB_BDT_RX, USB_FIFO_RX3);
	WRITE_EPN_BDT_ADDR(3, USB_BDT_TX, USB_FIFO_TX3);
	
	DRV_WriteReg8(USB_CTL, 0);
	DRV_WriteReg8(USB_ENDPT_CTL(0), VUSB_ENDPT_DISABLE);
	DRV_WriteReg8(USB_ENDPT_CTL(1), VUSB_ENDPT_DISABLE);
	DRV_WriteReg8(USB_ENDPT_CTL(2), VUSB_ENDPT_DISABLE);
	DRV_WriteReg8(USB_ENDPT_CTL(3), VUSB_ENDPT_DISABLE);

#else
	/* enable software reset, USB IP only can be reset by SW when detecting reset signal from bus */
	DRV_WriteReg8(USB_POWER, USB_POWER_SETSUSPEND|USB_POWER_SWRSTENAB);
#endif
}

/* initialize drv registers, including system global interrupt and EP0 interrupt*/
void USB_Initialize_Drv(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	kal_uint32 index;

	/*  
	This hardware has special hardware token done of 4 bytes deep FIFO
	Clear the status FIFOs
	*/
	DRV_WriteReg8(USB_INT_STAT, VUSB_INT_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_INT_STAT, VUSB_INT_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_INT_STAT, VUSB_INT_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_INT_STAT, VUSB_INT_STAT_TOKEN_DONE);

	/* FIFO deep 4*/
	DRV_WriteReg8(USB_FM_ERR_STAT, VUSB_FM_ERR_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_FM_ERR_STAT, VUSB_FM_ERR_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_FM_ERR_STAT, VUSB_FM_ERR_STAT_TOKEN_DONE);
	DRV_WriteReg8(USB_FM_ERR_STAT, VUSB_FM_ERR_STAT_TOKEN_DONE);

	/* clear all interrupts*/
	DRV_WriteReg8(USB_INT_STAT, 0xff);

	/* clear all endpoint ctrl */
	for(index=0; index<=MAX_INTR_EP_NUM; index++)
		DRV_WriteReg8(USB_ENDPT_CTL(index), 0);
	
	/* USB addr=0 (default) */
	DRV_WriteReg8(USB_ADDR, 0x0);

	WRITE_EP0_BDT_PID(USB_BDT_RX, USB_BDT_EVEN, 
							(USB_EP0_MAXP<<VUSB_BDT_BC_SHIFT)|VUSB_BDT_OWNS_BIT);
	WRITE_EP0_BDT_PID(USB_BDT_RX, USB_BDT_ODD, 
							(USB_EP0_MAXP<<VUSB_BDT_BC_SHIFT)|VUSB_BDT_OWNS_BIT);
	WRITE_EP0_BDT_PID(USB_BDT_TX, USB_BDT_EVEN, USB_EP0_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EP0_BDT_PID(USB_BDT_TX, USB_BDT_ODD, USB_EP0_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(1, USB_BDT_RX, USB_EP_BULK_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(1, USB_BDT_TX, USB_EP_BULK_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(2, USB_BDT_RX, USB_EP_BULK_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(2, USB_BDT_TX, USB_EP_BULK_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(3, USB_BDT_RX, USB_EP_INTR_MAXP<<VUSB_BDT_BC_SHIFT);
	WRITE_EPN_BDT_PID(3, USB_BDT_TX, USB_EP_INTR_MAXP<<VUSB_BDT_BC_SHIFT);

	DRV_WriteReg8(USB_BDT_PAGE_01, 0xBD);
	DRV_WriteReg8(USB_BDT_PAGE_02, 0xBD);
	DRV_WriteReg8(USB_BDT_PAGE_03, 0xBD);

	DRV_WriteReg8(USB_CTL, VUSB_CTL_ODD_RST|VUSB_CTL_USB_EN);
	DRV_WriteReg8(USB_CTL, VUSB_CTL_USB_EN);

	/* disable Fast mode*/
	DRV_WriteReg8(USB_FM_CTL, (DRV_Reg8(USB_FM_CTL)&(~VUSB_FM_CTL_FMENB)));
	DRV_WriteReg8(USB_FM_PKT_NUML, 0);
	DRV_WriteReg8(USB_FM_PKT_NUMH, 0);
	DRV_WriteReg8(USB_FM_PKT_CNTL, 0);
	DRV_WriteReg8(USB_FM_PKT_CNTH, 0);
	
	USB_EnSysIntr();
	USB_EP0En();	/* enable EP0 */
#else
	/* software reset */
	DRV_WriteReg8(USB_RSTCTRL, USB_RSTCTRL_SWRST);
	DRV_WriteReg8(USB_RSTCTRL, 0);	
	USB_EnSysIntr();
	USB_EP0En();	/* enable EP0 */
#endif
}

void USB_Release_Drv(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	DRV_WriteReg8(USB_INT_ENB, 0);
	DRV_WriteReg8(USB_INT_STAT, 0xff);
#endif	
}

/* enable system global interrupt*/
void USB_EnSysIntr(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	DRV_WriteReg8(USB_INT_ENB, 0xff&(~(VUSB_INT_ENB_SOF|VUSB_INT_ENB_RESUME)));
	DRV_WriteReg8(USB_ERR_ENB, 0xff);
	DRV_WriteReg8(USB_PHY_EXTRA, VUSB_PHY_RESUME_INT_ENB);
#else
	DRV_WriteReg8(USB_INTRIN1E, 0);
	DRV_WriteReg8(USB_INTROUT1E, 0);
	DRV_WriteReg8(USB_INTRUSBE, 0);
	DRV_WriteReg8(USB_INTRUSBE, (USB_INTRUSBE_SUSPEND|USB_INTRUSBE_RESUME|USB_INTRUSBE_RESET));
#endif
}

/* resume device */
void USB_Resume(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
#ifdef __OTG_ENABLE__
	/* Add for OTG function*/
	if(OTG_Get_Plug_Type()==OTG_PLUG_A)
		OTG_Set_Status(OTG_STATUS_A_DETECT_B_SUSPEND, KAL_FALSE);
	else
		OTG_Set_Status(OTG_STATUS_B_DETECT_A_SUSPEND, KAL_FALSE);
#endif	
#endif
}

/* suspend device */
void USB_Suspend(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
#ifdef __OTG_ENABLE__
	/* Add for OTG function*/
	if(OTG_Get_Plug_Type()==OTG_PLUG_A)
		OTG_Set_Status(OTG_STATUS_A_DETECT_B_SUSPEND, KAL_TRUE);
	else
		OTG_Set_Status(OTG_STATUS_B_DETECT_A_SUSPEND, KAL_TRUE);
#endif	
#endif
}

/* set address for hw*/
void USB_SetAddress(kal_uint8 addr, UBS_SET_ADDR_STATE state)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	if(state==USB_SET_ADDR_STATUS)	
		DRV_WriteReg8(USB_ADDR, addr);
#else
	if(state==USB_SET_ADDR_DATA)	
	DRV_WriteReg8(USB_FADDR, addr);
#endif
}

kal_uint16 USB_GetFrameCount(void)
{
	kal_uint8 count;
	kal_uint16 sof;

#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	count = DRV_Reg8(USB_FRM_NUML);
	sof = (kal_uint16)count;
	count = DRV_Reg8(USB_FRM_NUMH);
	sof+=(count<<8);
#else
	count = DRV_Reg8(USB_FRAME1);
	sof = (kal_uint16)count;
	count = DRV_Reg8(USB_FRAME2);
	sof+=(count<<8);
#endif
	return sof;
}


/************************************************************
	EP ctrl functinos
*************************************************************/

/* initialize EP IN */
void USB_InEPInit(kal_uint8 epno,kal_uint8 data_size, USB_ENDPT_TXFER_TYPE type)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	kal_uint8	epctl_value;

	if(epno==0)
		EXT_ASSERT(0, epno, 0, 0);
	/* check the packet size, FIFO only 8 bytes*/
	if(epno == 3)
		ASSERT(data_size == 8);

	switch(type)
{
	case USB_ENDPT_BULK:
		epctl_value = VUSB_ENDPT_BULK_TX;
		break;
	case USB_ENDPT_INTR:
		epctl_value = VUSB_ENDPT_BULK_TX;
		break;
	/* not support */
	case USB_ENDPT_CTRL:
	case USB_ENDPT_ISO:
		ASSERT(0);
		break;
}

	g_UsbDrvInfo.ep_in_max_data_size[epno-1] =  data_size;

	DRV_WriteReg8(USB_ENDPT_CTL(epno), DRV_Reg8(USB_ENDPT_CTL(epno))|epctl_value);

#else
	if(epno==0)
		ASSERT(0);
	DRV_WriteReg8(USB_INDEX,epno);
	DRV_WriteReg8(USB_INCSR1,(USB_INCSR1_CLRDATATOG | USB_INCSR1_FLUSHFIFO));
	DRV_WriteReg8(USB_INMAXP,(data_size/8));
#endif
}

/* initialize EP OUT */
void USB_OutEPInit(kal_uint8 epno,kal_uint8 data_size, USB_ENDPT_TXFER_TYPE type)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	kal_uint8	epctl_value;

	if(epno==0)
		ASSERT(0);
	/* check the packet size, FIFO only 8 bytes*/
	if(epno==3)
		ASSERT(data_size==8);

	switch(type)
	{
	case USB_ENDPT_BULK:
		epctl_value = VUSB_ENDPT_BULK_RX;
		break;
	case USB_ENDPT_INTR:
		epctl_value = VUSB_ENDPT_BULK_RX;
		break;
	/* not support */
	case USB_ENDPT_CTRL:
	case USB_ENDPT_ISO:
		ASSERT(0);
		break;
	}

	g_UsbDrvInfo.ep_out_max_data_size[epno-1] =  data_size;
	
	DRV_WriteReg8(USB_ENDPT_CTL(epno), DRV_Reg8(USB_ENDPT_CTL(epno))|epctl_value);
	
#else
	if(epno==0)
		ASSERT(0);
	DRV_WriteReg8(USB_INDEX,epno);
	DRV_WriteReg8(USB_OUTCSR1,(USB_OUTCSR1_CLRDATATOG | USB_OUTCSR1_FLUSHFIFO));
	DRV_WriteReg8(USB_OUTMAXP,(data_size/8));
#endif
}

void USB_EP0En(void)
{
#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	DRV_WriteReg8(USB_ENDPT_CTL(0), VUSB_ENDPT_CONTROL);
#else
	DRV_Reg8(USB_INTRIN1E) |= (USB_INTRIN1E_EP0 << 0);
#endif
}

void USB_InEPEn(kal_uint8 no, kal_bool bDMA)
{
	if(no==0)
		ASSERT(0);

#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	if(bDMA == KAL_TRUE)
	{
		g_UsbDrvInfo.ep_in_enb_state[no-1] = USB_EP_ENB_DMA;
	}	
	else
        {
		g_UsbDrvInfo.ep_in_enb_state[no-1] = USB_EP_ENB_NORMAL;
	}
#else
	DRV_WriteReg8(USB_INDEX, no);

	if(bDMA == KAL_TRUE)
	{
		DRV_Reg8(USB_INTRIN1E) = DRV_Reg8(USB_INTRIN1E) & (~(USB_INTRIN1E_EP0 << no));
		DRV_WriteReg8(USB_INCSR1,(USB_INCSR1_CLRDATATOG | USB_INCSR1_FLUSHFIFO));
		DRV_WriteReg8(USB_INCSR1,(USB_INCSR1_CLRDATATOG | USB_INCSR1_FLUSHFIFO));
		DRV_WriteReg8(USB_INCSR2,0);
		DRV_WriteReg8(USB_INCSR2,(USB_INCSR2_AUTOSET | USB_INCSR2_DMAENAB));
	}
	else
	{
		DRV_WriteReg8(USB_INCSR1,(USB_INCSR1_CLRDATATOG | USB_INCSR1_FLUSHFIFO));
		DRV_WriteReg8(USB_INCSR1,(USB_INCSR1_CLRDATATOG | USB_INCSR1_FLUSHFIFO));
		DRV_WriteReg8(USB_INCSR2,0);
		DRV_Reg8(USB_INTRIN1E) |= (USB_INTRIN1E_EP0 << no);
	}
#endif	
}

void USB_InEPDis(kal_uint8 no, kal_bool bDMA)
{
	if(no==0)
		ASSERT(0);

#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	if(g_UsbDrvInfo.ep_in_enb_state[no-1]==USB_EP_ENB_DMA)
		USB_Stop_DMA_Channel(no);
	g_UsbDrvInfo.ep_in_enb_state[no-1] = USB_EP_DIS;
	WRITE_EPN_BDT_PID(no, USB_BDT_TX, 0);
#else	
	DRV_WriteReg8(USB_INDEX, no);
	
	if(bDMA==KAL_TRUE)
        {
		USB_Stop_DMA_Channel(no);	
		DRV_Reg8(USB_INTRIN1E) = DRV_Reg8(USB_INTRIN1E) & (~(USB_INTRIN1E_EP0 << no));
		DRV_WriteReg8(USB_INCSR2,0);
	}
	else
	{
		DRV_Reg8(USB_INTRIN1E) = DRV_Reg8(USB_INTRIN1E) & (~(USB_INTRIN1E_EP0 << no));
		DRV_WriteReg8(USB_INCSR2,0);
	}
#endif	
}

void USB_OutEPEn(kal_uint8 no, kal_bool bDMA)
{
	if(no==0)
		ASSERT(0);

#if ( defined(MT6228) || defined(MT6229) || defined(MT6230))
	if(bDMA == KAL_TRUE)
	{
		g_UsbDrvInfo.ep_out_enb_state[no-1] = USB_EP_ENB_DMA;
		/* The first expect received packet is data0*/
		g_UsbDrvInfo.ep_out_data01[no-1] = 0;
	}	
	else
	{