kitlusbser.c

来自「SAMSUNG S3C6410 CPU BSP for winmobile6」· C语言 代码 · 共 1,579 行 · 第 1/4 页

		oOtgDev.m_oDesc.oDescDevice.bcdUSBL=0x10;
		oOtgDev.m_oDesc.oDescDevice.bcdUSBH=0x01; 	// Ver 1.10
	}
	else {
		oOtgDev.m_oDesc.oDescDevice.bcdUSBL=0x00;
		oOtgDev.m_oDesc.oDescDevice.bcdUSBH=0x02; 	// Ver 2.0
	}

	// Standard configuration descriptor
	oOtgDev.m_oDesc.oDescConfig.bLength=CONFIG_DESC_SIZE; // 0x9 bytes
	oOtgDev.m_oDesc.oDescConfig.bDescriptorType=CONFIGURATION_DESCRIPTOR;
	oOtgDev.m_oDesc.oDescConfig.wTotalLengthL=CONFIG_DESC_TOTAL_SIZE; 
	oOtgDev.m_oDesc.oDescConfig.wTotalLengthH=0;
	oOtgDev.m_oDesc.oDescConfig.bNumInterfaces=1;
// dbg    descConf.bConfigurationValue=2; // why 2? There's no reason.
	oOtgDev.m_oDesc.oDescConfig.bConfigurationValue=1;
	oOtgDev.m_oDesc.oDescConfig.iConfiguration=0;
	oOtgDev.m_oDesc.oDescConfig.bmAttributes=CONF_ATTR_DEFAULT|CONF_ATTR_SELFPOWERED; // bus powered only.
	oOtgDev.m_oDesc.oDescConfig.maxPower=25; // draws 50mA current from the USB bus.

	// Standard interface descriptor
	oOtgDev.m_oDesc.oDescInterface.bLength=INTERFACE_DESC_SIZE; // 9
	oOtgDev.m_oDesc.oDescInterface.bDescriptorType=INTERFACE_DESCRIPTOR;
	oOtgDev.m_oDesc.oDescInterface.bInterfaceNumber=0x0;
	oOtgDev.m_oDesc.oDescInterface.bAlternateSetting=0x0; // ?
	oOtgDev.m_oDesc.oDescInterface.bNumEndpoints = 2;	// # of endpoints except EP0
	oOtgDev.m_oDesc.oDescInterface.bInterfaceClass=0xff; // 0x0 ?
	oOtgDev.m_oDesc.oDescInterface.bInterfaceSubClass=0xFF;
	oOtgDev.m_oDesc.oDescInterface.bInterfaceProtocol=0xFF;
	oOtgDev.m_oDesc.oDescInterface.iInterface=0x0;

	// Standard endpoint0 descriptor
	oOtgDev.m_oDesc.oDescEndpt1.bLength=ENDPOINT_DESC_SIZE;
	oOtgDev.m_oDesc.oDescEndpt1.bDescriptorType=ENDPOINT_DESCRIPTOR;
	oOtgDev.m_oDesc.oDescEndpt1.bEndpointAddress=BULK_IN_EP|EP_ADDR_IN; // 2400Xendpoint 1 is IN endpoint.
	oOtgDev.m_oDesc.oDescEndpt1.bmAttributes=EP_ATTR_BULK;
	oOtgDev.m_oDesc.oDescEndpt1.wMaxPacketSizeL=(UINT8)oOtgDev.m_uBulkInEPMaxPktSize; // 64
	oOtgDev.m_oDesc.oDescEndpt1.wMaxPacketSizeH=(UINT8)(oOtgDev.m_uBulkInEPMaxPktSize>>8);
	oOtgDev.m_oDesc.oDescEndpt1.bInterval=0x0; // not used

	// Standard endpoint1 descriptor
	oOtgDev.m_oDesc.oDescEndpt2.bLength=ENDPOINT_DESC_SIZE;
	oOtgDev.m_oDesc.oDescEndpt2.bDescriptorType=ENDPOINT_DESCRIPTOR;
	oOtgDev.m_oDesc.oDescEndpt2.bEndpointAddress=BULK_OUT_EP|EP_ADDR_OUT; // 2400X endpoint 3 is OUT endpoint.
	oOtgDev.m_oDesc.oDescEndpt2.bmAttributes=EP_ATTR_BULK;
	oOtgDev.m_oDesc.oDescEndpt2.wMaxPacketSizeL=(UINT8)oOtgDev.m_uBulkOutEPMaxPktSize; // 64
	oOtgDev.m_oDesc.oDescEndpt2.wMaxPacketSizeH=(UINT8)(oOtgDev.m_uBulkOutEPMaxPktSize>>8);
	oOtgDev.m_oDesc.oDescEndpt2.bInterval=0x0; // not used
}

//////////
// Function Name : OTGDEV_CheckEnumeratedSpeed
// Function Desctiption : This function checks the current usb speed.
// Input : eSpeed, usb speed(high or full)
// Output : NONE
// Version :
void OTGDEV_CheckEnumeratedSpeed(USB_SPEED *eSpeed)
{
	volatile UINT32 uDStatus;
	
	Inp32(DSTS, uDStatus); // System status read

	*eSpeed = (uDStatus&0x6) >>1;
}




//////////
// Function Name : OTGDEV_SetInEpXferSize
// Function Desctiption : This function sets DIEPTSIZn CSR according to input parameters.
// Input : eType, transfer type
//			uPktCnt, packet count to transfer
//			uXferSize, transfer size
// Output : NONE
// Version :
void OTGDEV_SetInEpXferSize(EP_TYPE eType, UINT32 uPktCnt, UINT32 uXferSize)
{	
	if(eType == EP_TYPE_CONTROL)
	{
		Outp32(DIEPTSIZ0, (uPktCnt<<19)|(uXferSize<<0));
	}
	else if(eType == EP_TYPE_BULK)
	{
		Outp32(bulkIn_DIEPTSIZ, (1<<29)|(uPktCnt<<19)|(uXferSize<<0));
	}
}

//////////
// Function Name : OTGDEV_SetOutEpXferSize
// Function Desctiption : This function sets DOEPTSIZn CSR according to input parameters.
// Input : eType, transfer type
//			uPktCnt, packet count to transfer
//			uXferSize, transfer size
// Output : NONE
// Version :
void OTGDEV_SetOutEpXferSize(EP_TYPE eType, UINT32 uPktCnt, UINT32 uXferSize)
{	
	if(eType == EP_TYPE_CONTROL)
	{
		Outp32(DOEPTSIZ0, (1<<29)|(uPktCnt<<19)|(uXferSize<<0));
	}
	else if(eType == EP_TYPE_BULK)
	{
		Outp32(bulkOut_DOEPTSIZ, (uPktCnt<<19)|(uXferSize<<0));
	}
}

//////////
// Function Name : OTGDEV_WrPktEp0
// Function Desctiption : This function reads data from the buffer and writes the data on EP0 FIFO.
// Input : buf, address of the data buffer to write on Control EP FIFO
//			num, size of the data to write on Control EP FIFO(byte count)
// Output : NONE
// Version :
void OTGDEV_WrPktEp0(UINT8 *buf, int num)
{
	int i;
	volatile UINT32 Wr_Data=0;

	for(i=0;i<num;i+=4)
	{
		Wr_Data = ((*(buf+3))<<24)|((*(buf+2))<<16)|((*(buf+1))<<8)|*buf;
		Outp32(control_EP_FIFO, Wr_Data);
		buf += 4;
	}
}

//////////
// Function Name : OTGDEV_PrintEp0Pkt
// Function Desctiption : This function reads data from the buffer and displays the data.
// Input : pt, address of the data buffer to read
//			count, size of the data to read(byte count)
// Output : NONE
// Version :
void OTGDEV_PrintEp0Pkt(UINT8 *pt, UINT8 count)
{
	int i;
	EdbgOutputDebugString("[DBG:");
	for(i=0;i<count;i++)
		EdbgOutputDebugString("%x,", pt[i]);
	EdbgOutputDebugString("]\n");
}


//////////
// Function Name : OTGDEV_WrPktBulkInEp
// Function Desctiption : This function reads data from the buffer and writes the data on Bulk In EP FIFO.
// Input : buf, address of the data buffer to write on Bulk In EP FIFO
//			num, size of the data to write on Bulk In EP FIFO(byte count)
// Output : NONE
// Version :
void OTGDEV_WrPktBulkInEp(UINT8 *buf, int num)
{
	int i;
	volatile UINT32 Wr_Data=0;

	for(i=0;i<num;i+=4)
	{
		Wr_Data=((*(buf+3))<<24)|((*(buf+2))<<16)|((*(buf+1))<<8)|*buf;
		Outp32(bulkIn_EP_FIFO, Wr_Data);
		buf += 4;
	}
}

//////////
// Function Name : OTGDEV_RdPktBulkOutEp
// Function Desctiption : This function reads data from Bulk Out EP FIFO and writes the data on the buffer.
// Input : buf, address of the data buffer to write
//			num, size of the data to read from Bulk Out EP FIFO(byte count)
// Output : NONE
// Version :
void OTGDEV_RdPktBulkOutEp(UINT8 *buf, int num)
{
	int i;
	volatile UINT32 Rdata;

	for (i=0;i<num;i+=4)
	{
		//Rdata = Inp32(bulkOut_EP_FIFO);
		Inp32(bulkOut_EP_FIFO, Rdata);

		buf[i] = (UINT8)Rdata;
		buf[i+1] = (UINT8)(Rdata>>8);
		buf[i+2] = (UINT8)(Rdata>>16);
		buf[i+3] = (UINT8)(Rdata>>24);
	}

	// increase global down pointer for usb download function
	g_pDownPt += num;
}



//////////
// Function Name : OTGDEV_IsUsbOtgSetConfiguration
// Function Desctiption : This function checks if Set Configuration is received from the USB Host.
// Input : NONE
// Output : configuration result
// Version :
BOOL OTGDEV_IsUsbOtgSetConfiguration(void)
{
	if (oOtgDev.m_uIsUsbOtgSetConfiguration == 0)
		return false;
	else
		return true;
}

//////////
// Function Name : OTGDEV_SetOpMode
// Function Desctiption : This function sets CSRs related to the operation mode.
// Input : eMode, operation mode(cpu or dma)
// Output : NONE
// Version :
void OTGDEV_SetOpMode(USB_OPMODE eMode)
{
	oOtgDev.m_eOpMode = eMode;

	Outp32(GINTMSK, INT_RESUME|INT_OUT_EP|INT_IN_EP|INT_ENUMDONE|INT_RESET|INT_SUSPEND|INT_RX_FIFO_NOT_EMPTY); //gint unmask
	Outp32(GAHBCFG, MODE_SLAVE|BURST_SINGLE|GBL_INT_UNMASK);

	OTGDEV_SetOutEpXferSize(EP_TYPE_BULK, 1, oOtgDev.m_uBulkOutEPMaxPktSize);
	OTGDEV_SetInEpXferSize(EP_TYPE_BULK, 1, 0);

	Outp32(bulkOut_DOEPCTL, 1<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkOutEPMaxPktSize<<0);		//bulk out ep enable, clear nak, bulk, usb active, next ep3, max pkt
	Outp32(bulkIn_DIEPCTL, 0<<31|1<<26|2<<18|1<<15|oOtgDev.m_uBulkInEPMaxPktSize<<0);		//bulk in ep enable, clear nak, bulk, usb active, next ep1, max pkt
}


/* S3C6410USBSER_Init
 *
 *  Called by PQOAL KITL framework to initialize the serial port
 *
 *  Return Value:
 */
BOOL S3C6410USBSER_Init (KITL_SERIAL_INFO *pSerInfo)
{
	volatile S3C6410_SYSCON_REG *g_pSysConReg;
	g_pSysConReg = (S3C6410_SYSCON_REG *)OALPAtoVA(S3C6410_BASE_REG_PA_SYSCON, FALSE);

	g_pSysConReg->HCLK_GATE |= (1<<20);

	

	memset(&g_Info, 0, sizeof(g_Info));
	memset(&USBSerInfo, 0, sizeof(USBSERKITL_INFO));

	KITLOutputDebugString ("Wait for connecting\n");

	KitlIoPortBase = (DWORD)pSerInfo->pAddress; 
	delayLoop(100);
	if (!KitlIoPortBase)
	{	
		return FALSE;
	}
	else
	{
		OTGDEV_InitOtg(USB_HIGH);		
//		OTGDEV_InitOtg(USB_FULL);
	}
	pSerInfo->bestSize = 512;
//	pSerInfo->bestSize = 64;

	return TRUE;
}

/* S3C6410USBSER_WriteData
 *
 *  Block until the byte is sent
 *
 *  Return Value: TRUE on success, FALSE otherwise
 */
 #define NPTxFEmpty (0x1<<5)
 
UINT16 S3C6410USBSER_WriteData (UINT8 *pch, UINT16 length)
{

	volatile UINT32 uGIntStatus;
	if (USBSerInfo.dwState != KITLUSBSER_STATE_CONNECTED)
	{
		return length;
	}

	while(1)
	{
		Inp32(GINTSTS, uGIntStatus); // Wait Until TX FIFO is availabled.
		if (uGIntStatus & NPTxFEmpty)
		{
			break;
		}
	}
	
	length = OTGDEV_HandleEvent_BulkIn(pch, length);
	return length;	
}


void S3C6410USBSER_SendComplete (UINT16 length)
{

	volatile UINT32 dwDiepint;
	Inp32(bulkIn_DIEPINT, dwDiepint);
	Outp32(bulkIn_DIEPINT, dwDiepint);
}



/* S3C6410USBSER_ReadData
 *
 *  Called from PQOAL KITL to read a byte from serial port
 *
 *  Return Value: TRUE on success, FALSE otherwise
 */
UINT16 S3C6410USBSER_ReadData (UINT8 *pch, UINT16 length)
{
	length = OTGDEV_HandleEvent(pch, length);
	return length;
}


/* S3C6410USBSER_EnableInt
 *
 *  Enable Recv data interrupt
 *
 *  Return Value:
 */

VOID S3C6410USBSER_EnableInt (void)
{
	volatile S3C6410_VIC_REG *g_pVIC1Reg;
	g_pVIC1Reg = (volatile S3C6410_VIC_REG *)OALPAtoVA(S3C6410_BASE_REG_PA_VIC1, FALSE);

	if (!USBSerKitl_POLL)
	{
		g_pVIC1Reg->VICINTENABLE = (1<<(IRQ_PH_OTG-32));
	}
}

/* S3C6410USBSER_DisableInt
 *
 *  Disable Recv data interrupt
 *
 *  Return Value:
 */
VOID S3C6410USBSER_DisableInt (void)
{
	volatile S3C6410_VIC_REG *g_pVIC1Reg;
	g_pVIC1Reg = (volatile S3C6410_VIC_REG *)OALPAtoVA(S3C6410_BASE_REG_PA_VIC1, FALSE);

	if (!USBSerKitl_POLL)
	{
		g_pVIC1Reg->VICINTENCLEAR = (1<<(IRQ_PH_OTG-32));
	}
}


VOID S3C6410USBSER_PowerOff (void)
{
	//KITLOutputDebugString ("+S3C6410USBSER_PowerOff\n");	
}

VOID S3C6410USBSER_PowerOn (void)
{
	//KITLOutputDebugString ("+S3C6410USBSER_PowerOn\n");
}

// serial driver
OAL_KITL_SERIAL_DRIVER DrvUSBSerial = {
	S3C6410USBSER_Init,
	NULL,
	S3C6410USBSER_WriteData,//TX
	S3C6410USBSER_SendComplete,//Clear EP1 Interrupt pending
	S3C6410USBSER_ReadData,//RX
	S3C6410USBSER_EnableInt,
	S3C6410USBSER_DisableInt,
	NULL,    //S3C6410USBSER_PowerOff,
	NULL,    //S3C6410USBSER_PowerOn,
	NULL, //flow control
};

const OAL_KITL_SERIAL_DRIVER *GetKitlUSBSerialDriver (void)
{
	return &DrvUSBSerial;
}

static void delayLoop(int count)
{
	volatile int j,k;
	for(j = 0; j < count; j++)
	{
		for(k=0;k<100000;k++);
	}
}