usbdev_+

Samsung S3C2443 Monitor program source code

			break;


		// === GET_DESCRIPTOR:ENDPOINT 1 ONLY===
		case EP0_STATE_GD_EP0_ONLY_0:
			Outp32(BYTE_WRITE_CNT_REG, ENDPOINT_DESC_SIZE);
			Inp32(SYS_STATUS_REG, usSysStatus);
			WrPktEp0((U8 *)&m_poDesc->oDescEndpt1+0, ENDPOINT_DESC_SIZE);
			m_uEp0State = EP0_STATE_INIT;
			break;

		// === GET_DESCRIPTOR:ENDPOINT 2 ONLY===
		case EP0_STATE_GD_EP1_ONLY_0:
			Outp32(BYTE_WRITE_CNT_REG, ENDPOINT_DESC_SIZE);
			Inp32(SYS_STATUS_REG, usSysStatus);
			WrPktEp0((U8 *)&m_poDesc->oDescEndpt3+0, ENDPOINT_DESC_SIZE);
			m_uEp0State = EP0_STATE_INIT;
			break;

				// === GET_DESCRIPTOR:STRING ===
		case EP0_STATE_GD_STR_I0:
			Outp32(BYTE_WRITE_CNT_REG, 4);
			DbgUsb(("[GDS0_0]"));
			WrPktEp0((U8 *)aDescStr0, 4);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_STATE_GD_STR_I1:
			DbgUsb(("[GDS1_%d]", m_uEp0SubState));
			if ((m_uEp0SubState*m_uEp0MaxPktSize+m_uEp0MaxPktSize)<sizeof(aDescStr1))
			{
				Outp32(BYTE_WRITE_CNT_REG, m_uEp0MaxPktSize);
				WrPktEp0((U8 *)aDescStr1+(m_uEp0SubState*m_uEp0MaxPktSize), m_uEp0MaxPktSize);
				m_uEp0State = EP0_STATE_GD_STR_I1;
				m_uEp0SubState++;
			}
			else
			{
				Outp32(BYTE_WRITE_CNT_REG, sizeof(aDescStr1)-(m_uEp0SubState*m_uEp0MaxPktSize));
				WrPktEp0((U8 *)aDescStr1+(m_uEp0SubState*m_uEp0MaxPktSize), sizeof(aDescStr1)-(m_uEp0SubState*m_uEp0MaxPktSize));
				m_uEp0State = EP0_STATE_INIT;
				m_uEp0SubState = 0;
			}
			break;

		case EP0_STATE_GD_STR_I2:
			DbgUsb(("[GDS2_%d]", m_uEp0SubState));
			if ((m_uEp0SubState*m_uEp0MaxPktSize+m_uEp0MaxPktSize)<sizeof(aDescStr2))
			{
				Outp32(BYTE_WRITE_CNT_REG, m_uEp0MaxPktSize);
				WrPktEp0((U8 *)aDescStr2+(m_uEp0SubState*m_uEp0MaxPktSize), m_uEp0MaxPktSize);
				m_uEp0State = EP0_STATE_GD_STR_I2;
				m_uEp0SubState++;
			}
			else
			{
				DbgUsb(("[E]"));
				Outp32(BYTE_WRITE_CNT_REG, sizeof(aDescStr2)-(m_uEp0SubState*m_uEp0MaxPktSize));
				WrPktEp0((U8 *)aDescStr2+(m_uEp0SubState*m_uEp0MaxPktSize), sizeof(aDescStr2)-(m_uEp0SubState*m_uEp0MaxPktSize));
				m_uEp0State = EP0_STATE_INIT;
				m_uEp0SubState = 0;
			}
			break;

		case EP0_STATE_GD_DEV_QUALIFIER:
			Outp32(BYTE_WRITE_CNT_REG, 10);
			WrPktEp0((U8 *)aDeviceQualifierDescriptor+0, 10);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_INTERFACE_GET:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poInterfaceGet+0, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;


		case EP0_GET_STATUS0:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poStatusGet+0, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_GET_STATUS1:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poStatusGet+1, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_GET_STATUS2:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poStatusGet+2, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_GET_STATUS3:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poStatusGet+3, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;

		case EP0_GET_STATUS4:
			Outp32(BYTE_WRITE_CNT_REG, 1);
			WrPktEp0((U8 *)m_poStatusGet+4, 1);
			m_uEp0State = EP0_STATE_INIT;
			break;

		default:
			break;


	}
}

// ======================================================================
// HandleBulkIn()
//
// This is function for Endpoint One ( Bulk In)function routine.
// ======================================================================
void USBDEV::HandleEvent_BulkIn(void)
{
	U16 ep1csr;
	U32 temp;

	// EP1 CSR register status check
	Outp32(INDEX_REG, 0x01);
	Inp32(EP_STATUS_REG, ep1csr);
	Outp32(EP_STATUS_REG, ep1csr);
	Inp32(DMA_TOTAL_CNT1_REG, temp);
	printf("EP1: DMA_TOTAL_CNT1_REG : %x\n", temp);

	if (ep1csr & EP_SENT_STALL) { // SENT STALL : protocol stall.
		DbgUsb(("Sent Stall \n"));
		Outp32(EP_STATUS_REG, EP_SENT_STALL);
	}

	if (ep1csr & EP_TX_SUCCESS)
	{
		printf("EP1_TX_SUCCESS\n");
		Outp32(EP_STATUS_REG, EP_TX_SUCCESS); // Endpoint Status Register Clear
		if (m_eOpMode == USB_CPU)
		{
			if (m_uBulkInCount != 0)
				PrepareEp1Fifo(m_uBulkInAddr);
		}
	}

	if (DMA_TOTAL_COUNT_ZERO & ep1csr)
	{
		printf("USB_DMA_MODE, DMA TX Done(DMA_TOTAL_COUNT_ZERO) !!\n");
		Outp32(DMA_CON_REG, DMA_TX_STOP|USB_INT_MODE);
		Outp32(FCON, DMA_DISABLE);
	}
}

// ======================================================================
// HandleBulkOut()
//
// This is function for Endpoint Three ( Bulk Out)function routine.
// ======================================================================

void USBDEV::HandleEvent_BulkOut(void)
{
	U32 ReadData;
	U32 RecDataCnt;
	U16 ep3csr, ep2con, sys_status;
	U32 CBWSignature=0, CBWTag=0, i;
	U8  TempBuf[16];
	U16 fifoCnt;
	U16 fifoCntByte;
	U32 DmaCurrAddr;
	U32 temp;
	U32 uUploadSize;
	U32 uUploadAddr;
	U32 uDownloadFileSize;

	Outp32(INDEX_REG, EP3);
	Inp32(EP_STATUS_REG, ep3csr);
	Outp32(EP_STATUS_REG, ep3csr);
// 	DbgUsb(("Bulk Out Int, ep3csr : %x\n", ep3csr));
	Inp32(DMA_TOTAL_CNT1_REG, temp);
	DbgUsb(("EP3: DMA_TOTAL_CNT1_REG : %x\n", temp));


	if (ep3csr & EP_SENT_STALL) // SENT STALL : protocol stall.
	{
		// Uart_Printf(" Sent Stall \n");
		Outp32(EP_STATUS_REG, EP_SENT_STALL);
		return;
	}

	if (ep3csr & EP_FIFO_FLUSH)
	{
		Outp32(EP_CON_REG, EP_FIFO_FLUSH);
		return;
	}
//ahn..	
	if (DMA_TOTAL_COUNT_ZERO & ep3csr)
	{
		DbgUsb(("USB_DMA_MODE, DMA RX Done(DMA_TOTAL_COUNT_ZERO) !!\n"));
		Outp32(DMA_CON_REG, DMA_RX_STOP|USB_INT_MODE);
		Outp32(FCON, DMA_DISABLE);
		m_eOpMode = USB_CPU;
		Inp32(DMA_MEM_CURRENT_ADDR, DmaCurrAddr);
		m_pDownPt = (U8 *)DmaCurrAddr;
		
		Inp32(EP_STATUS_REG, ep3csr);
		DbgUsb(("DMA_TOTAL_COUNT_ZERO, ep3csr : %x\n", ep3csr));
		return;
	}
//ahn..
	if (ep3csr & EP_RX_SUCCESS)
	{
		DbgUsb(("EP3_RX_PKT_SUCCESS\n"));
		Outp32(EP_INT_REG, INT_REG_EP3); //  ahn Interrupt Clear
		if (m_uDownloadFileSize==0)
		{
			Inp32(BYTE_READ_CNT_REG, fifoCnt);

			if (fifoCnt == 5)
			{
				RdPktEp3((U8 *)TempBuf, 10);
				temp = *((U8 *)(TempBuf+8))+
					(*((U8 *)(TempBuf+9))<<8);
				DbgUsb(("temp: %x\n", temp));
				if (temp==0x1)
				{
					uUploadAddr =
						*((U8 *)(TempBuf+0))+
						(*((U8 *)(TempBuf+1))<<8)+
						(*((U8 *)(TempBuf+2))<<16)+
						(*((U8 *)(TempBuf+3))<<24);

					uUploadSize =
						*((U8 *)(TempBuf+4))+
						(*((U8 *)(TempBuf+5))<<8)+
						(*((U8 *)(TempBuf+6))<<16)+
						(*((U8 *)(TempBuf+7))<<24);
				
					printf("UploadAddress : %x, UploadSize: %x\n", uUploadAddr, uUploadSize);
					if (m_eOpMode == USB_CPU)
					{
						DbgUsb(("CPU_MODE Bulk In Function\n"));
						m_uBulkInCount = uUploadSize;
						PrepareEp1Fifo(uUploadAddr);
					}
					else
					{
						DbgUsb(("DMA_MODE Bulk In Function\n"));
						Outp32(FCON, DMA_ENABLE);				// USB Dma Enable in Core Outside
						Outp32(INDEX_REG, EP1);					// IN Direction  Device -> Host
						Outp32(DMA_IF_CON_REG, MAX_BURST_INCR16);
						Outp32(BYTE_WRITE_CNT_REG, m_uEp1MaxPktSize);
						Outp32(MAX_PKT_REG, m_uEp1MaxPktSize);
						Outp32(DMA_FIFO_CNT_REG, m_uEp1MaxPktSize);
						Outp32(DMA_CNT_REG, m_uEp1MaxPktSize);
						Outp32(DMA_MEM_BASE_ADDR, uUploadAddr);
						Outp32(DMA_TOTAL_CNT1_REG, (U16)uUploadSize);
						Outp32(DMA_TOTAL_CNT2_REG, (U16)(uUploadSize>>16));
						Outp32(DMA_CON_REG, DMA_FLY_ENABLE|DMA_TX_START|USB_DMA_MODE);
					}
				}
				m_uDownloadFileSize=0;
				return;
			}
			else
			{
			    if(download_run==0)
   	    		{
					m_uDownloadAddress=tempDownloadAddress; 
					printf("tempDownloadAddress = %x\n",tempDownloadAddress);
	    		}
	    		else
	    		{
					RdPktEp3((U8 *)TempBuf, 8);
					if (ep3csr&(0x1<<4))
						fifoCntByte = fifoCnt * 2 -1;
					else
						fifoCntByte = fifoCnt * 2;
					DbgUsb(("downloadFileSize==0, 1'st BYTE_READ_CNT_REG : %x\n", fifoCntByte));
					m_uDownloadAddress=
						*((U8 *)(TempBuf+0))+
						(*((U8 *)(TempBuf+1))<<8)+
						(*((U8 *)(TempBuf+2))<<16)+
						(*((U8 *)(TempBuf+3))<<24);
	    		}
				if(download_run==0)
   	    		{
					RdPktEp3((U8 *)TempBuf, 8);
					if (ep3csr&(0x1<<4))
						fifoCntByte = fifoCnt * 2 -1;
					else
						fifoCntByte = fifoCnt * 2;
   	    		}
				//	DbgUsb(("downloadFileSize==0, 1'st BYTE_READ_CNT_REG : %x\n", fifoCntByte));
					m_uDownloadFileSize=
						*((U8 *)(TempBuf+4))+
						(*((U8 *)(TempBuf+5))<<8)+
						(*((U8 *)(TempBuf+6))<<16)+
						(*((U8 *)(TempBuf+7))<<24);

				m_pDownPt=(U8 *)m_uDownloadAddress;
				//DbgUsb(("downloadAddress : %x, downloadFileSize: %x\n", m_uDownloadAddress, m_uDownloadFileSize));
				//printf("downloadAddress : %x, downloadFileSize: %x\n", m_uDownloadAddress, m_uDownloadFileSize));
				//printf("*");
				RdPktEp3((U8 *)m_pDownPt, fifoCntByte-8); // The first 8-bytes are deleted.

				if (m_eOpMode == USB_CPU)
				{
					if (ep3csr & (0x2<<2))
					{
						Inp32(BYTE_READ_CNT_REG, fifoCnt);
						if (ep3csr&(0x1<<4))
							fifoCntByte = fifoCnt * 2 -1;
						else
							fifoCntByte = fifoCnt * 2;
						DbgUsb(("2'd BYTE_READ_CNT_REG : %x\n", fifoCntByte));
						RdPktEp3((U8 *)m_pDownPt, fifoCntByte);
					
					}
				}
				else
				{
						uDownloadFileSize = m_uDownloadFileSize-fifoCntByte;
					if (uDownloadFileSize > m_uEp3MaxPktSize)
					{
						Outp32(FCON, DMA_ENABLE);				// USB Dma Enable in Core Outside
						Outp32(INDEX_REG, EP3);					// OUT Direction  Host -> Device
						Outp32(DMA_IF_CON_REG, MAX_BURST_INCR16);
						Outp32(MAX_PKT_REG, m_uEp3MaxPktSize);
						Outp32(DMA_FIFO_CNT_REG, m_uEp3MaxPktSize);
						Outp32(DMA_CNT_REG, m_uEp3MaxPktSize);
						Outp32(DMA_MEM_BASE_ADDR, m_uDownloadAddress+fifoCntByte-8);
						uDownloadFileSize = (uDownloadFileSize/m_uEp3MaxPktSize)*m_uEp3MaxPktSize;	
						Outp32(DMA_TOTAL_CNT1_REG, (U16)(uDownloadFileSize));
						Outp32(DMA_TOTAL_CNT2_REG, (U16)(uDownloadFileSize>>16));
						DbgUsb(("Out Direction DMA RX Start\n"));
						Outp32(DMA_CON_REG, DMA_FLY_ENABLE|DMA_RX_START|USB_DMA_MODE);
					}
					else
						m_eOpMode = USB_CPU;
				}
			}
		}

		else
		{
			if (m_eOpMode == USB_CPU)
			{
				Inp32(BYTE_READ_CNT_REG, fifoCnt);
				if (ep3csr&(0x1<<4))
					fifoCntByte = fifoCnt * 2 -1;
				else
					fifoCntByte = fifoCnt * 2;
				DbgUsb(("downloadFileSize!=0, 1'st BYTE_READ_CNT_REG : %x\n", fifoCntByte));
				RdPktEp3((U8 *)m_pDownPt, fifoCntByte);

				if (ep3csr & (0x2<<2))
				{
					Inp32(BYTE_READ_CNT_REG, fifoCnt);
					if (ep3csr&(0x1<<4))
						fifoCntByte = fifoCnt * 2 -1;
					else
						fifoCntByte = fifoCnt * 2;
					DbgUsb(("2'd BYTE_READ_CNT_REG : %x\n", fifoCntByte));
					RdPktEp3((U8 *)m_pDownPt, fifoCntByte);
				
				}
			}
		}
	}
/*
		if (DMA_TOTAL_COUNT_ZERO & ep3csr)
	{

		Delay(10);
		Outp32(DMA_CON_REG, DMA_RX_STOP|USB_INT_MODE);
		Outp32(FCON, DMA_DISABLE);
	//	Inp32(EP_STATUS_REG, ep3csr);
	//	printf("ep3csr = %x \n",ep3csr); 
		Inp32(EP_STATUS_REG, ep3csr);
		if (ep3csr & EP_RX_SUCCESS)									// short packet handled			
		{
			Inp32(BYTE_READ_CNT_REG, fifoCnt);
			if (ep3csr&(0x1<<4)) // RX packet success but remain Odd word 
				fifoCntByte = fifoCnt * 2 -1;
			else
				fifoCntByte = fifoCnt * 2;
		//	printf("downloadFileSize!=0, 1'st BYTE_READ_CNT_REG : %x\n", fifoCntByte);
			Inp32(DMA_MEM_CURRENT_ADDR, DmaCurrAddr);
			m_pDownPt = (U8 *)DmaCurrAddr;
			RdPktEp3((U8 *)m_pDownPt, fifoCntByte);

			if (ep3csr & (0x2<<2))
			{
				Inp32(BYTE_READ_CNT_REG, fifoCnt);
				if (ep3csr&(0x1<<4))
					fifoCntByte = fifoCnt * 2 -1;
				else
					fifoCntByte = fifoCnt * 2;
				DbgUsb(("2'd BYTE_READ_CNT_REG : %x\n", fifoCntByte));
				RdPktEp3((U8 *)m_pDownPt, fifoCntByte);
			}
			dma_done =1;	
		}
		else
		dma_done =1;
		
	}
//	printf("ep3csr = %x \n",ep3csr); 
*/	
}