isr.c

Six objects here: The document you re reading & its Chinese version Set of "HWDesign" includes

#include <reg51.h>	//SFR declarations

#include "usb100.h"
#include "base_io.h"
#include "d12_comm_if.h"
#include "mainloop.h"

extern void bus_reset(void);

extern void ep0_txdone(void);
extern void ep0_rxdone(void);

extern void ep1_txdone(void);
extern void ep1_rxdone(void);

extern void main_txdone(void);
extern void main_rxdone(void);

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

EPPFLAGS bEPPflags;

/* Control endpoint TX/RX buffers */
extern CONTROL_XFER ControlData;

/* ISR static vars */
unsigned char idata GenEpBuf[EP1_PACKET_SIZE];
unsigned char idata EpBuf[EP2_PACKET_SIZE];

unsigned char xdata MainEpBuf[256];

usb_isr() interrupt 0
{
	DISABLE;		//we're here:ISR!
	fn_usb_isr();
	ENABLE;			//OK! I'll be off-line.
}

void fn_usb_isr()	//main routine for INT
{
	unsigned int i_st;

	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadIntReg();

	if(i_st != 0)	//==0?? out of the question!!
	{
		if(i_st & D12_INT_BUSRESET)
			bEPPflags.bits.bus_reset = 1;

		if(i_st & D12_INT_ENDP0IN)
			ep0_txdone();
		if(i_st & D12_INT_ENDP0OUT)
			ep0_rxdone();
		if(i_st & D12_INT_ENDP1IN)
			ep1_txdone();
		if(i_st & D12_INT_ENDP1OUT)
			ep1_rxdone();
		if(i_st & D12_INT_ENDP2IN)
			main_txdone();
		if(i_st & D12_INT_ENDP2OUT)
			main_rxdone();
	}

	bEPPflags.bits.in_isr = 0;
}

void ep0_rxdone(void)
{
	unsigned char ep_last, i;

	ep_last = D12_ReadLastTransStatus(0);	//Clear Interrupt flag

	if (ep_last & D12_SETUPPACKET)
	{

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

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

			D12_SetEndPStatus(0, 1);
			D12_SetEndPStatus(1, 1);
			bEPPflags.bits.control_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
		D12_AckEndP(0);
		D12_AckEndP(1);

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

		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_TRANSMIT;		/* get command */
		}
		else {
			if (ControlData.DeviceRequest.wLength == 0) {
				bEPPflags.bits.setup_packet = 1;
				bEPPflags.bits.control_state = USB_IDLE;		/* set command */
			}
			else {
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) {
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndPStatus(0, 1);
					D12_SetEndPStatus(1, 1);
				}
				else {
					bEPPflags.bits.control_state = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet

	else if (bEPPflags.bits.control_state == USB_RECEIVE) {
		i =	D12_ReadEndP(0, EP0_PACKET_SIZE,
			ControlData.dataBuffer + ControlData.wCount);

		ControlData.wCount += i;
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;
		}
	}

	else {
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep0_txdone(void)
{
	short i = ControlData.wLength - ControlData.wCount;

	D12_ReadLastTransStatus(1); // Clear interrupt flag

	if (bEPPflags.bits.control_state != USB_TRANSMIT)
		return;

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

		bEPPflags.bits.control_state = USB_TRANSMIT;
	}
	else if( i != 0) {
		D12_WriteEndP(1, i, ControlData.pData + ControlData.wCount);
		ControlData.wCount += i;

		bEPPflags.bits.control_state = USB_IDLE;
	}
	else if (i == 0){
		D12_WriteEndP(1, 0, 0); // Send zero packet at the end ???

		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep1_txdone(void)
{
	D12_ReadLastTransStatus(3); /* Clear interrupt flag */
}

void ep1_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransStatus(2); /* Clear interrupt flag */

	len = D12_ReadEndP(2, sizeof(GenEpBuf), GenEpBuf);

	if(len != 0)
		bEPPflags.bits.ep1_rxdone = 1;
}

void main_txdone(void) {/*FILL Ur own code here*/}
void main_rxdone(void) {/*and here if U want to enhance MiniNurse*/}