//===================================================================//
//     Project Name : ZBoard
//      Module Name : Master Firmware Program
//     Product Type : License
//      OS/Dev Tool : AT89C52, uVision 2
//  Original Author : Ray Yang
//     Organization : YBWork.com
//    Original Date : July, 25, 2001
//             Addr : Room 402, No. 131, Meilong No. 9
//              TEL : 86-21-54630718
//            EMail : rayyang2000@yahoo.com
//          Website : http://www.ybwork.com
//		  Copyright : Copyright (L) YBWork.com, 2001
//         Comments : 
//                    
//					<< History >> 
//					July, 25, 2001		The first release
//===================================================================//

#include "HAL.H"
#include "USBD12.H"
#include "ZBoard.H"
#include "USB110.H"
#include "USB.H"
#include "VDOR.H"

/*
//***********************************************************
// These functions is use for USB ISR routine
//***********************************************************
*/

void ISRx_Bus_Reset(void);

void ISRx_EP0_TxDone(void);
void ISRx_EP0_RxDone(void);

void ISRx_EP1_TxDone(void);
void ISRx_EP1_RxDone(void);

void ISRx_Main_TxDone(void);
void ISRx_Main_RxDone(void);

void ISRx_DMA_EOT(void);

void ISRx_FN_USB(void);

/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/

extern ZBOARDFLAGS bZBoardFlags;
unsigned char nCount = 0;
/* Control endpoint TX/RX buffers */
extern CONTROL_XFER ControlData;
extern CODE_DATA idata CodeData;

/* General Buffer*/
unsigned char idata GenBuf[GENBUF_LENGH];

/* ISR static vars */
unsigned long lClockTicks = 0;

// This variable is used for debugging
unsigned char nFlashPhase = 0;

void ISR_Timer2(void) interrupt 5
{
}

void ISR_COMM(void) interrupt 4
{
}

void ISR_Timer1(void) interrupt 3
{
}

void ISR_INT1(void) interrupt 2
{
}

void ISR_Timer0(void) interrupt 1
{
	DISABLE_INTERRUPTS;
	lClockTicks ++;
	bZBoardFlags.bits.bTimer = 1;
	nCount ++;
	if(bZBoardFlags.bits.bLED == LED_FLASH)
		IO_LED ^= 1;
	ENABLE_INTERRUPTS;
}


void ISR_INT0(void) interrupt 0
{
	DISABLE_INTERRUPTS;
	ISRx_FN_USB();
	ENABLE_INTERRUPTS;
}

void ISRx_FN_USB()
{
	unsigned int nST;

	bZBoardFlags.bits.bIN_ISR = 1;

	nST = USBD12_ReadInterruptRegister();

#ifdef _DEBUG
	printf("USBD12_ReadInterruptRegister() = 0x%02x\n", nST);
#endif

	if(nST != 0)
    	{
		if(nST & USBD12_INT_BUSRESET)
        	{
			ISRx_Bus_Reset();
			bZBoardFlags.bits.bBus_Reset = 1;
		}

		if(nST & USBD12_INT_EOT)
			ISRx_DMA_EOT();

		if(nST & USBD12_INT_SUSPENDCHANGE)
		{
			bZBoardFlags.bits.bSuspend = 1;
		}

		if(nST & USBD12_INT_ENDP0IN)
			ISRx_EP0_TxDone();
		if(nST & USBD12_INT_ENDP0OUT)
			ISRx_EP0_RxDone();
		if(nST & USBD12_INT_ENDP1IN)
			ISRx_EP1_TxDone();
		if(nST & USBD12_INT_ENDP1OUT)
			ISRx_EP1_RxDone();
		if(nST & USBD12_INT_ENDP2IN)
			ISRx_Main_TxDone();
		if(nST & USBD12_INT_ENDP2OUT)
			ISRx_Main_RxDone();
	}

	bZBoardFlags.bits.bIN_ISR = 0;

}

void ISRx_Bus_Reset(void)
{

}

// OUT Packet
void ISRx_EP0_RxDone(void)
{

	unsigned char ep_last, i;

	ep_last = USBD12_ReadLastTransactionStatus(0); // Clear interrupt flag

	if(ep_last & USBD12_SETUPPACKET)
	{
		ControlData.wLength = 0;
		ControlData.wCount = 0;

		if( USBD12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) )
		{

			USBD12_SetEndpointStatus(0, 1);
			USBD12_SetEndpointStatus(1, 1);
			bZBoardFlags.bits.bControl_State = USB_IDLE;
			
			return;
		}

		ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
		ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
		ControlData.DeviceRequest.wLength = SWAP(ControlData.DeviceRequest.wLength);

		// Acknowledge setup here to unlock in/out endp
		USBD12_AcknowledgeEndpoint(0);
		USBD12_AcknowledgeEndpoint(1);

		ControlData.wLength = ControlData.DeviceRequest.wLength;
		ControlData.wCount = 0;

		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)
		{
			bZBoardFlags.bits.bSetup_Packet = 1;
			bZBoardFlags.bits.bControl_State = USB_IDLE;		/* get command */
		}
		else
		{
			if (ControlData.DeviceRequest.wLength == 0)
			{
				bZBoardFlags.bits.bSetup_Packet = 1;
				bZBoardFlags.bits.bControl_State = USB_IDLE;		/* set command */
			}
			else
			{
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE)
				{
					bZBoardFlags.bits.bControl_State = USB_IDLE;
					USBD12_SetEndpointStatus(0, 1);
					USBD12_SetEndpointStatus(1, 1);
				}
				else
				{
					bZBoardFlags.bits.bControl_State = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet
	else if (bZBoardFlags.bits.bControl_State == USB_RECEIVE)
	{
		i =	USBD12_ReadEndpoint(0, ControlData.dataBuffer + ControlData.wCount,
			EP0_PACKET_SIZE);

		ControlData.wCount += i;
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength)
		{
			bZBoardFlags.bits.bSetup_Packet = 1;
			bZBoardFlags.bits.bControl_State = USB_IDLE;
		}
	}
	else
	{
		bZBoardFlags.bits.bControl_State = USB_IDLE;
	}
}

// IN Packet
void ISRx_EP0_TxDone(void)
{
#ifdef _DEBUG
	int j;
#endif
	short i = ControlData.wLength - ControlData.wCount;

	USBD12_ReadLastTransactionStatus(1); // Clear interrupt flag

	if(bZBoardFlags.bits.bControl_State != USB_TRANSMIT)
		return;

	if(i >= EP0_PACKET_SIZE)
	{
#ifdef _DEBUG
		printf("EP0Tx {");
		for(j=0; j<EP0_PACKET_SIZE; j++)
		{
			printf("%bx ", *(ControlData.pData + ControlData.wCount + j));
		}
		printf("}\n");
#endif
		USBD12_WriteEndpoint(1, ControlData.pData + ControlData.wCount, EP0_PACKET_SIZE);
		ControlData.wCount += EP0_PACKET_SIZE;

		bZBoardFlags.bits.bControl_State = USB_TRANSMIT;
	}
	else if(i != 0)
	{
#ifdef _DEBUG
		printf("EP0Tx {");
		for(j=0; j<i; j++)
		{
			printf("%bx ", *(ControlData.pData + ControlData.wCount + j));
		}
		printf("}\n");
#endif
		USBD12_WriteEndpoint(1, ControlData.pData + ControlData.wCount, i);
		ControlData.wCount += i;

		bZBoardFlags.bits.bControl_State = USB_IDLE;
	}
	else if (i == 0)
	{
#ifdef _DEBUG
		printf("EP0Tx { }\n");
#endif
		USBD12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???

		bZBoardFlags.bits.bControl_State = USB_IDLE;
	}
}

// End of DMA transfer
void ISRx_DMA_EOT(void)
{
}

// OUT Packet
void ISRx_EP1_RxDone(void)
{
}

// IN Packet
void ISRx_EP1_TxDone(void)
{
}

// OUT Packet
void ISRx_Main_RxDone(void)
{
	unsigned short nLen;

	nLen = USBD12_ReadLastTransactionStatus(4); /* Clear interrupt flag */
	if(!(nLen & USBD12_SUCCESS))
		return;

	nLen = CodeData.wCodeLength - CodeData.wCodeCount;
	nFlashPhase ++;
	if(nLen != 0)
	{
//READ_DATA:
		nLen = USBD12_ReadEndpoint(4, CodeData.pCodeData, sizeof(GenBuf));
//		nLen = USBD12_ReadMainEP(/*CodeData.pCodeData*/);
#ifdef _DEBUG
		printf("EP2 ISR nLen = 0x%02x\n", nLen);
#endif

		CodeData.wCodeCount += nLen;
		CodeData.pCodeData += nLen;
		if(CodeData.pCodeData > (GenBuf + sizeof(GenBuf) / 2))
			CodeData.pCodeData = GenBuf;
//		if(CodeData.pCodeData > (GenBuf + sizeof(GenBuf)))
//			CodeData.pCodeData = GenBuf + (CodeData.pCodeData - (GenBuf + sizeof(GenBuf)));

		if(CodeData.wCodeCount && (CodeData.wCodeCount % 128 == 0))
		{
#ifdef _DEBUG
			printf("FlashWrite\n");
#endif
			FlashWrite(GenBuf, CodeData.wCodeAddress, sizeof(GenBuf));
			CodeData.wCodeAddress += sizeof(GenBuf);
		}

/*
		if(((CodeData.wCodeLength - CodeData.wCodeCount) <= 64) &&
			(CodeData.wCodeLength - CodeData.wCodeCount) &&
			nLen)
		{
			goto READ_DATA;
		}
*/
	}
	else
		nLen = USBD12_ReadEndpoint(4, CodeData.pCodeData, sizeof(GenBuf));
}

// IN Packet
void ISRx_Main_TxDone(void)
{
	unsigned short nLen;

	USBD12_ReadLastTransactionStatus(5); /* Clear interrupt flag */

	nLen = CodeData.wCodeLength - CodeData.wCodeCount;
	if(nLen != 0)
	{
		if(nLen > EP2_TX_FIFO_SIZE)
			nLen = EP2_TX_FIFO_SIZE;

		FlashRead(CodeData.wCodeAddress, CodeData.pCodeData, nLen);
		nLen = USBD12_WriteEndpoint(5, CodeData.pCodeData, nLen);

		CodeData.pCodeData += nLen;
		if(CodeData.pCodeData > (GenBuf + sizeof(GenBuf) / 2))
			CodeData.pCodeData = GenBuf;
		CodeData.wCodeCount += nLen;
		CodeData.wCodeAddress += nLen;
	}
}