isr.c

基于AVR的USB单片机的源代码,其中部分代码被用在产品上.

//===================================================================//
//					Augest, 25, 2002		The Last Modified Date
//                  Modified by Dai LiZHou, HIT ([e-mail])
//===================================================================//
#include "AvrUsb.H"

//***********************************************************
// These functions is use for USB ISR routine
//***********************************************************
unsigned char buf[16];

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 AVRUSBFLAGS bAvrUsbFlags;
unsigned long  lClockTicks;
extern CONTROL_XFER ControlData;

#pragma interrupt_handler ISR_Timer0:8
void ISR_Timer0(void) 
{
	DISABLE_INTERRUPTS;
	lClockTicks ++;
	bAvrUsbFlags.bits.bTimer = 1;
	if(bAvrUsbFlags.bits.bLED == LED_FLASH)
	{
		if( PORTB&0x01 ) PORTB &= 0xFE;
		else             PORTB |= 0x01;
	}
	ENABLE_INTERRUPTS;
}

#pragma interrupt_handler ISR_INT0:2
void ISR_INT0(void)
{
	DISABLE_INTERRUPTS;
	ISRx_FN_USB();
	ENABLE_INTERRUPTS;
}

void ISRx_FN_USB(void)
{
	unsigned int nST;

	bAvrUsbFlags.bits.bIN_ISR = 1;
	nST = USBD12_ReadInterruptRegister();
	if(nST != 0)
    {
		if(nST & USBD12_INT_BUSRESET)
        {
			ISRx_Bus_Reset();
			bAvrUsbFlags.bits.bBus_Reset = 1;
		}
		if(nST & USBD12_INT_EOT) 			    ISRx_DMA_EOT();
		if(nST & USBD12_INT_SUSPENDCHANGE)		bAvrUsbFlags.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();
	}
	bAvrUsbFlags.bits.bIN_ISR = 0;
}

void ISRx_Bus_Reset(void)
{
}

// OUT Packet : Host to Device
void ISRx_EP0_RxDone(void)
{
	unsigned char ep_last, i;

	// Clear interrupt flag
	ep_last = USBD12_ReadLastTransactionStatus(0);
	
	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);
			bAvrUsbFlags.bits.bControl_State = USB_IDLE;
			return;
		}

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

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

	USBD12_ReadLastTransactionStatus(1); // Clear interrupt flag

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

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

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

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

		bAvrUsbFlags.bits.bControl_State = USB_IDLE;
	}
}

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

// OUT Packet
void ISRx_EP1_RxDone(void)
{
   unsigned short nLen;
   
   nLen=USBD12_ReadLastTransactionStatus(2);
   if( nLen&USBD12_SUCCESS )
   {
      nLen=USBD12_ReadEndpoint(2,buf,8);
   }
   bAvrUsbFlags.bits.bRead=1;
}

// IN Packet : Device to Host
void ISRx_EP1_TxDone(void)
{
   USBD12_ReadLastTransactionStatus(3);
}

// OUT Packet : Host to Device
void ISRx_Main_RxDone(void)
{
   unsigned short nLen;

   nLen=USBD12_ReadLastTransactionStatus(4);
   if( nLen&USBD12_SUCCESS )
   {
      nLen=USBD12_ReadEndpoint(4,buf,8);
   }
   bAvrUsbFlags.bits.bRead=1;
}

// IN Packet
void ISRx_Main_TxDone(void)
{
   USBD12_ReadLastTransactionStatus(5);
}