irq_int.c

USB便携多道系统单片机固件程序.单片机固件程序采用CodeWarrior Development Studio for HC(S)08 Microcontrollers集成开发环境开发

//===================================================================//
//     Project Name : MOTOROLA-PDIUSBD12 USB-MCS CARD
//      Module Name : Master Firmware Program
//     Product Type : License
//      OS/Dev Tool : CodeWarrior Development Studio for HC(S)08 Microcontrollers
//  Original Author : Ming Zeng
//     Organization : Tsinghua University , DEP 
//    Original Date : Feb, 20, 2003
//             Addr : Tsinghua University, Beijing City
//              TEL : 
//            EMail : [e-mail]
//          Website : http://www.zming.net
//		  Copyright : Copyright ZMing.net, 2003
//         Comments : 
//                    
//			
//===================================================================//

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

//***********************************************************
// 用于响应D12中断的各个例程
//***********************************************************

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 COMMONFLAGS bCOMMONFlags;

/* Control endpoint TX/RX buffers */
extern CONTROL_XFER ControlData;
extern CODE_DATA CodeData;
/* General Buffer*/
unsigned char  GenBuf[GENBUF_LENGH];
// This variable is used for debugging
unsigned char nFlashPhase = 0;


/////////////////////////
//IRQ中断子程序
/////////////////////////
interrupt 2 void IRQInterrupt() //外中断，由D12产生
{
 	
	DisableInterrupts;
	INTSCR |= 0x02;//暂时关闭irq中断
	bCOMMONFlags.bits.bUSB_Busy = 1;
	EnableInterrupts;
}

//////////////////////////////////////////
//////////////////////////////////////////
void ISRx_FN_USB()//对D12的USB处理
{
	unsigned int nST;
	
	bCOMMONFlags.bits.bIN_ISR = 1;
	
	nST = USBD12_ReadInterruptRegister();
	if(nST != 0)
    {
		if(nST & USBD12_INT_BUSRESET)
        {
			ISRx_Bus_Reset();
			bCOMMONFlags.bits.bBus_Reset = 1;
		}

		if(nST & USBD12_INT_EOT)
			ISRx_DMA_EOT();

		if(nST & USBD12_INT_SUSPENDCHANGE)
			bCOMMONFlags.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();
	}

	bCOMMONFlags.bits.bIN_ISR = 0;
	bCOMMONFlags.bits.bUSB_Busy = 0;
	INTSCR &= 0xfd;//开启irq中断


}


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,(unsigned char *)(&(ControlData.DeviceRequest))
		, sizeof(ControlData.DeviceRequest)) != sizeof(DEVICE_REQUEST) )
		{
			USBD12_SetEndpointStatus(0, 1);
			USBD12_SetEndpointStatus(1, 1);
			bCOMMONFlags.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)
		{
			bCOMMONFlags.bits.bSetup_Packet = 1;
			bCOMMONFlags.bits.bControl_State = USB_IDLE;		/* get command */
		}
		else
		{
			if (ControlData.DeviceRequest.wLength == 0)
			{
				bCOMMONFlags.bits.bSetup_Packet = 1;
				bCOMMONFlags.bits.bControl_State = USB_IDLE;		/* set command */
			}
			else
			{
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE)
				{
					bCOMMONFlags.bits.bControl_State = USB_IDLE;
					USBD12_SetEndpointStatus(0, 1);
					USBD12_SetEndpointStatus(1, 1);
				}
				else
				{
					bCOMMONFlags.bits.bControl_State = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet
	else if (bCOMMONFlags.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)
		{
			bCOMMONFlags.bits.bSetup_Packet = 1;
			bCOMMONFlags.bits.bControl_State = USB_IDLE;
		}
	}
	else
	{
		bCOMMONFlags.bits.bControl_State = USB_IDLE;
	}
}

// IN Packet
void ISRx_EP0_TxDone(void)
{
	short i = ControlData.wLength - ControlData.wCount;

	USBD12_ReadLastTransactionStatus(1); // Clear interrupt flag

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

	if(i >= EP0_PACKET_SIZE)
	{
		USBD12_WriteEndpoint(1, ControlData.pData + ControlData.wCount, EP0_PACKET_SIZE);
		ControlData.wCount += EP0_PACKET_SIZE;

		bCOMMONFlags.bits.bControl_State = USB_TRANSMIT;
	}
	else {
	 	if(i != 0)
			{
			USBD12_WriteEndpoint(1, ControlData.pData + ControlData.wCount, i);
			ControlData.wCount += i;

			bCOMMONFlags.bits.bControl_State = USB_IDLE;
			}
		else {
			 if (i == 0)
				{
				USBD12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???

				bCOMMONFlags.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 */
	
	//nLen = USBD12_ReadEndpoint(4,CodeData.pCodeData, sizeof(GenBuf));
}

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

	USBD12_ReadLastTransactionStatus(5); /* Clear interrupt flag */
	
	switch (CodeData.bCodeCount)
	{
		case 1 : CodeData.pCodeData = GenBuf;
				 USBD12_WriteEndpointOnce(5,CodeData.pCodeData, EP2_TX_FIFO_SIZE);
				 CodeData.bCodeCount = 2;
				 break;
		case 2 : CodeData.pCodeData = GenBuf+ EP2_TX_FIFO_SIZE;
				 USBD12_WriteEndpointOnce(5,CodeData.pCodeData, EP2_TX_FIFO_SIZE);
				 CodeData.bCodeCount = 3;
				 break;
		case 3 : CodeData.pCodeData = GenBuf+ EP2_TX_FIFO_SIZE +EP2_TX_FIFO_SIZE;
				 USBD12_WriteEndpointOnce(5,CodeData.pCodeData, EP2_TX_FIFO_SIZE);
				 CodeData.bCodeCount = 4;
				 break;
		case 4 : CodeData.pCodeData = GenBuf+ EP2_TX_FIFO_SIZE +EP2_TX_FIFO_SIZE +EP2_TX_FIFO_SIZE;
				 USBD12_WriteEndpointOnce(5,CodeData.pCodeData, EP2_TX_FIFO_SIZE);
				 CodeData.bCodeCount = 1;
				 break;
	}
}