isr.c

基于D12的USB固件驱动

#include <macros.h>    /* for CLI() SEI() _NOP() macro */
#include <string.h>    /* typedef unsigned int size_t; size_t is sizeof()'s return type*/
#include "usb100.h"
#include "mainloop.h"
#include "d12ci.h"

#define D12_INT_ENDP0OUT             0x01    
#define D12_INT_ENDP0IN              0x02
#define D12_INT_ENDP1OUT             0x04
#define D12_INT_ENDP1IN              0x08
#define D12_INT_ENDP2OUT             0x10
#define D12_INT_ENDP2IN              0x20
#define D12_INT_BUSRESET             0x40
#define D12_INT_SUSPENDCHANGE        0x80
#define D12_INT_EOT                  0x0100

#define D12_SETUPPACKET              0x20 

#define USB_IDLE            0
#define USB_TRANSMIT        1
#define USB_RECEIVE         2

//#define  SWAP(x) x        
#define  SWAP(x)    ((((x) & 0xFF) <<8 )|(((x)>> 8 ) & 0xFF))         
//#define  MSB(x)    (((x)>>8) & 0xFF))
//#define  LSB(x)    ((x) & 0xFF)

extern  EPPFLAGS bEPPflags;
extern  CONTROL_XFER ControlData;
unsigned short D12_ReadInterruptRegister(void);
unsigned char D12_ReadLastTransactionStatus(unsigned char bEndp);
unsigned char D12_ReadEndpointStatus(unsigned char bEndp);
void D12_SetEndpointStatus(unsigned char bEndp, unsigned char bStalled);
void D12_AcknowledgeEndpoint(unsigned char endp);
unsigned char D12_ReadEndpoint(unsigned char endp, unsigned char len, unsigned char *buf);
unsigned char D12_WriteEndpoint(unsigned char endp, unsigned char len, unsigned char *buf);

/*INT3*/
#pragma interrupt_handler int3_usb_isr:5   
/*used by isr.c only*/
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);
//extern void dma_eot(void);

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

  ###################################################################*/
/*General Endpoint Buffer*/
unsigned char idata_GenEpBuf[EP1_PACKET_SIZE];
/*Main Endpoint Buffer*/
unsigned char idata_EpBuf[EP2_PACKET_SIZE];
/*for Removing Warning*/
unsigned char ReturnValue;   
unsigned char marking;                  

/*###################################################################
        
                            int3_usb_isr  

  ###################################################################*/
void int3_usb_isr(void)
{
    unsigned int i_st = 0;
    
	CLI();
    
	bEPPflags.bits.in_isr = 1;   
    
	i_st = D12_ReadInterruptRegister();
    
	if (i_st != 0)
    {
        if (i_st & D12_INT_BUSRESET)	     
        {
		    bEPPflags.bits.bus_reset = 1;
		}
        
		if (i_st & D12_INT_SUSPENDCHANGE)
        {
		    bEPPflags.bits.suspend = 1;
		}        
        
		if (i_st & D12_INT_EOT)
        /* dma_eot(); */
        {
		    _NOP();
		}
        
		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;
        
		SEI();
    }
}   

/*********************************************************************
  Function:     ep0_rxdone
  Description:  EP0 Out Interrupt/RXD Done Routine                   
  Calls:        D12_ReadLastTransactionStatus(); D12_ReadEndpoint(); D12_SetEndpointStatus();
                D12_AcknowledgeEndpoint(); 
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/
void ep0_rxdone(void)
{
    unsigned char ep_last, i;
   
    ep_last = D12_ReadLastTransactionStatus(0);    
   
    if (ep_last & D12_SETUPPACKET)/*Receive SETUP Packet*/
    { 
        ControlData.wLength = 0;
        ControlData.wCount = 0;
        
	    i = sizeof(DEVICE_REQUEST);
        
		if (D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
           (unsigned char*)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST))
        {   /*SETUP PACKET ERROR,RETURN*/
            D12_SetEndpointStatus(0,1);   
                                             /*Stall EP0,Ep1,if Packet Error*/
			D12_SetEndpointStatus(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);
        
		/*Give ACK In/Out of Control Endpoint*/      
        D12_AcknowledgeEndpoint(0);       
        D12_AcknowledgeEndpoint(1); 
       
	    ControlData.wLength = ControlData.DeviceRequest.wLength;      
        ControlData.wCount = 0;
       
        if (ControlData.DeviceRequest.bmRequestType           

               & (unsigned char)USB_ENDPOINT_DIRECTION_MASK)    /*0X80*/
        {
            bEPPflags.bits.setup_packet = 1;
           
		    bEPPflags.bits.control_state = USB_TRANSMIT;
        }
        else
        {
            if (ControlData.DeviceRequest.wLength == 0)
            {
                bEPPflags.bits.setup_packet = 1; 
               
			    bEPPflags.bits.control_state = USB_IDLE;
            }
            else
            {
                if (ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE)
                {
                   bEPPflags.bits.control_state = USB_IDLE; 
                   
				   D12_SetEndpointStatus(0,1);
                   
				   D12_SetEndpointStatus(1,1);
                }
                else
                {
                    bEPPflags.bits.control_state = USB_RECEIVE;
                }
           }/*Set Command with Data*/
       } /*Without Read Request*/
   }/*Setup Packet*/ 
   else if(bEPPflags.bits.control_state == USB_RECEIVE)
   {
       i = D12_ReadEndpoint(0, EP0_PACKET_SIZE, ControlData.dataBuffer + ControlData.wCount);
       
	   ControlData.wCount += i;
       
	   if (i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength)
       {   /*Finish Data Receive*/
           bEPPflags.bits.setup_packet = 1; 
           bEPPflags.bits.control_state = USB_IDLE;
       }
   }
   else
   {
       bEPPflags.bits.control_state = USB_IDLE;
   }
}

/*********************************************************************
  Function:     ep0_txdone
  Description:  EP0 In Interrupt/TXD Done Routine
  Calls:        D12_ReadLastTransactionStatus(); D12_WriteEndpoint();
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/
void ep0_txdone(void)
{
    unsigned short i = ControlData.wLength-ControlData.wCount;
    /*Clear Interrupt Flag*/
    ReturnValue = D12_ReadLastTransactionStatus(1);           
   
    if (bEPPflags.bits.control_state == !USB_TRANSMIT)
    {
        /*No Transmit Status,Return*/
	    return;    
    }
   
    if (i >= EP0_PACKET_SIZE)
    {   /*Data >16 byte,Transmit 16 byte*/
        ReturnValue = D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
       
	    ControlData.wCount += EP0_PACKET_SIZE;
       
	    bEPPflags.bits.control_state = USB_TRANSMIT;
    }
    else
    {   
        if (i != 0)
        {   /*Transmit remanent Data*/
            ReturnValue = D12_WriteEndpoint(1, (unsigned char)i, ControlData.pData + ControlData.wCount);
            
		    ControlData.wCount += i;
           
		    bEPPflags.bits.control_state = USB_IDLE;
        }
        else 
        {   /*Finish Transmit,Transmit 0 Byte*/
            ReturnValue = D12_WriteEndpoint(1, 0, 0);
            
			bEPPflags.bits.control_state = USB_IDLE;
        }
    }
}/*TXD done Routine*/

/*********************************************************************
  Function:     ep1_rxdone
  Description:  EP1 Out Interrupt/RXD Done Routine
  Calls:        D12_ReadLastTransactionStatus(); D12_ReadEndpoint();
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/ 
void ep1_rxdone(void)
{
    unsigned char len;
   
    ReturnValue = D12_ReadLastTransactionStatus(2);
   
    len = D12_ReadEndpoint(2, sizeof(idata_GenEpBuf), idata_GenEpBuf);
   
    if (len != 0)
    {   
        /*Flag Received Data*/
        bEPPflags.bits.ep1_rxdone = 1;
    }      
}      
       
/*********************************************************************
  Function:     ep1_txdone
  Description:  EP1 In Interrupt/TXD Done Routine   
  Calls:        D12_ReadLastTransactionStatus();
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/    
void ep1_txdone(void)
{   
    /*Clear Interrupt Flags*/
    ReturnValue = D12_ReadLastTransactionStatus(3);   
}      

/*********************************************************************
  Function:     main_rxdone
  Description:  EP2 Out Interrupt/RXD Done Routine      
  Calls:        D12_ReadLastTransactionStatus(); D12_ReadEndpoint(); D12_ReadEndpointStatus(); 
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/
void main_rxdone(void)
{
    unsigned char len,epstatus;
  
    ReturnValue = D12_ReadLastTransactionStatus(4);    /*Clear Interrupt Flags*/
      
    len = D12_ReadEndpoint(4, 64, idata_EpBuf);   
  
    /*Read Buffer Status*/
    epstatus = D12_ReadEndpointStatus(4); 
  
    /*D12_BUFFERFULL=0x60*/
    epstatus &= D12_BUFFERFULL;           
  
    if(epstatus == 0x60)
    {
        ReturnValue = D12_ReadEndpoint(4,64,idata_EpBuf);
    }
   
    marking=0xff;
   
    NOP();
}      

/*********************************************************************
  Function:     main_txdone
  Description:  EP2 In Interrupt/TXD Done Routine   
  Calls:        D12_ReadLastTransactionStatus();
  Called By:    int3_usb_isr();
  Input:        void                  
  Output:                       
  Return:       void                     
  Others:                            
*********************************************************************/
void main_txdone(void)
{   
    /*Clear Interrupt Flags*/
	ReturnValue = D12_ReadLastTransactionStatus(5);   
}