usb_isr.c

基于C8051单片机的USB Device driver

/*
This file includes all the standard request function and USB interrupt service
response function
*/

#include "c8051F320addr.h"
#include "USB_Descriptor.h"
#include "USB_Definition.h"

SETUP_BUFFER gSetup;          // Buffer for current device request information

DEVICE_STATUS gDeviceStatus;
EP_STATUS gEp0Status;        // Holds the status for endpoint0
EP_STATUS gEp1InStatus;      // Holds the status for endpoint1 IN
EP_STATUS gEp2OutStatus;     // Holds the status for endpoint2 OUT

BYTE xdata gInPacket[EP1_PACKET_SIZE];
BYTE xdata gOutPacket[EP2_PACKET_SIZE];

code BYTE ONES_PACKET[2] = {0x01, 0x00};        // These are response packets used for
code BYTE ZERO_PACKET[2] = {0x00, 0x00};        // communication with host

extern DEVICE_DESCRIPTOR gDevice_Desc;            // These are created in F34x_USB_Descriptor.h
extern CONFIGURATION_DESCRIPTOR gConfig_Desc;
extern INTERFACE_DESCRIPTOR gInterface_Desc;
extern ENDPOINT_DESCRIPTOR gEndpoint1_Desc;
extern ENDPOINT_DESCRIPTOR gEndpoint2_Desc;

void USB_ISR(void) interrupt 8     //Top-level USB ISR
{
   BYTE bCommon,bIn,bOut;
   READ_REGISTER(CMINT,bCommon);   // Read all interrupt registers
   READ_REGISTER(IN1INT,bIn);      // This read also clears the register
   READ_REGISTER(OUT1INT,bOut);    // This read also clears the register

   if (bCommon & rbRSUINT)    // Handle Resume interrupt
   {
      USBResume();
   }

   if (bCommon & rbRSTINT)
   {
      USBReset();
   }

   if (bCommon & rbSUSINT)
   {
      USBSuspend();
   }

   if (bIn & rbEP0)
   {
      HandleSetup();
   }

   if (bIn & rbIN1)
   {
      HandleIn1();
   }

   if (bOut & rbOUT2)
   {
      HandleOut2();
   }
}

//----------------------------------------------
//USb_ISR main function.c
//----------------------------------------------
void USBResume(void)
{
   volatile int k;
   k++;
}

void USBReset(void)
{
   BYTE i,bPower = 0;
   BYTE * pDevStatus;

   pDevStatus = (BYTE *)&gDeviceStatus;
   for (i=0;i<sizeof(DEVICE_STATUS);i++)
   {
      *pDevStatus++ = 0x00;
   }

   gDeviceStatus.bDevState = DEV_DEFAULT;
   gDeviceStatus.bRemoteWakeupStatus = REMOTE_WAKEUP_SUPPORT;
   gDeviceStatus.bSelfPoweredStatus = SELF_POWERED_SUPPORT;

   gEp0Status.bEpState = EP_IDLE;
   gEp1InStatus.bEpState = EP_HALT;
   gEp2OutStatus.bEpState = EP_HALT;

   if (SUSPEND_ENABLE)
   {
      bPower |= 0x01;
   }

   WRITE_REGISTER(POWER, bPower);
}

void USBSuspend(void)
{
   volatile int k;

   k++;
}

void HandleSetup(void)
{
   BYTE bTempReg = 0;
   BYTE bCsr1;

   WRITE_REGISTER(INDEX, EP0_IDX);
   READ_REGISTER(E0CSR, bCsr1);

   if (gEp0Status.bEpState == EP_ADDRESS)
   {
      WRITE_REGISTER(FADDR, gSetup.wValue.c[LSB]);
      gEp0Status.bEpState = EP_IDLE;
   }

   if (bCsr1 & rbSTSTL)
   {
      WRITE_REGISTER(E0CSR, 0);
      gEp0Status.bEpState = EP_IDLE;
      return;
   }

   if (bCsr1 & rbSUEND)
   {
      WRITE_REGISTER(E0CSR, rbDATAEND);
      WRITE_REGISTER(E0CSR, rbSSUEND);
      gEp0Status.bEpState = EP_IDLE;
   }

   if (gEp0Status.bEpState == EP_IDLE)
   {
      if (bCsr1 & rbOPRDY)
      {
         FIFORead(FIFO_EP0,8,(BYTE *)&gSetup);

         gSetup.wValue.i = gSetup.wValue.c[MSB] + 256*gSetup.wValue.c[LSB];
         gSetup.wIndex.i = gSetup.wIndex.c[MSB] + 256*gSetup.wIndex.c[LSB];
         gSetup.wLength.i = gSetup.wLength.c[MSB] + 256*gSetup.wLength.c[LSB];

         switch(gSetup.bRequest)
         {
            case GET_STATUS:
               GetStatus();
               break;
            case CLEAR_FEATURE:
               ClearFeature();
               break;
            case SET_FEATURE:
               SetFeature();
               break;
            case SET_ADDRESS:
               SetAddress();
               break;
            case GET_DESCRIPTOR:
               GetDescriptor();
               break;
            case GET_CONFIGURATION:
               GetConfiguration();
               break;
            case SET_CONFIGURATION:
               SetConfiguration();
               break;
            case GET_INTERFACE:
               GetInterface();
               break;
            case SET_INTERFACE:
               SetInterface();
               break;

            default:
               ForceStall();       // Send stall to host if invalid request
               break;
         }
      }
   }

   if (gEp0Status.bEpState== EP_TX)      // See if the endpoint has data to transmit to host
   {
      if (!(bCsr1 & rbINPRDY))
      {
         READ_REGISTER(E0CSR, bCsr1);

         if ((!(bCsr1 & rbSUEND)) || (!(bCsr1 & rbOPRDY)))
         {
            bTempReg = rbINPRDY;

            if (gEp0Status.uNumBytes >= EP0_PACKET_SIZE)
            {
               FIFOWrite(FIFO_EP0, EP0_PACKET_SIZE, (BYTE *)gEp0Status.pData);
               gEp0Status.pData += EP0_PACKET_SIZE;
               gEp0Status.uNumBytes -= EP0_PACKET_SIZE;
            }
            else
            {
               FIFOWrite(FIFO_EP0,  gEp0Status.uNumBytes, (BYTE *)gEp0Status.pData);
               bTempReg |= rbDATAEND;
               gEp0Status.bEpState = EP_IDLE;
            }

            if (gEp0Status.uNumBytes == 0)
            {
               bTempReg |= rbDATAEND;
               gEp0Status.bEpState = EP_IDLE;
            }

            WRITE_REGISTER(E0CSR, bTempReg);
         }
      }
   }
}

void HandleIn1(void)
{
   BYTE bCsrL;

   WRITE_REGISTER(INDEX, EP1_IN_IDX);
   READ_REGISTER(EINCSRL, bCsrL);

   if (gEp1InStatus.bEpState == EP_HALT)
   {
      WRITE_REGISTER(EINCSRL, rbInSDSTL);
   }
   else
   {
      if (bCsrL & rbInSTSTL)
      {
         WRITE_REGISTER(EINCSRL, rbInCLRDT);
      }

      if (bCsrL & rbInUNDRUN)
      {
         WRITE_REGISTER(EINCSRL, 0x00);
      }

      if (!(bCsrL & rbInINPRDY))
      {
         gEp1InStatus.uNumBytes = EP1_PACKET_SIZE;
         gEp1InStatus.pData = (BYTE *)&gInPacket;

         FIFOWrite(FIFO_EP1, gEp1InStatus.uNumBytes, (BYTE *) gEp1InStatus.pData);

         WRITE_REGISTER(EINCSRL, rbInINPRDY);
      }
   }
}

void HandleOut2(void)
{
   BYTE bTempCnt = 0;
   BYTE bCsrL;

   WRITE_REGISTER(INDEX, EP2_OUT_IDX);
   READ_REGISTER(EOUTCSRL, bCsrL);

   if (gEp2OutStatus.bEpState == EP_HALT)
   {
      WRITE_REGISTER(EOUTCSRL, rbOutSDSTL);
   }
   else
   {
      if (bCsrL & rbOutSTSTL)
      {
         WRITE_REGISTER(EOUTCSRL, rbOutCLRDT);
      }

      if (bCsrL & rbOutOPRDY)
      {
         READ_REGISTER(EOUTCNTL, bTempCnt);
         gEp2OutStatus.uNumBytes = bTempCnt;
         READ_REGISTER(EOUTCNTH, bTempCnt);
         gEp2OutStatus.uNumBytes |= (unsigned)bTempCnt<<8;
      }

      if (gEp2OutStatus.uNumBytes != EP2_PACKET_SIZE)     // If host did not send correct packet
                                          // size, flush buffer
      {
         WRITE_REGISTER(EOUTCSRL, rbOutFLUSH);
      }
      else                              // Otherwise get the data packet
      {
         FIFORead(FIFO_EP2, gEp2OutStatus.uNumBytes, (BYTE*)gEp2OutStatus.pData);
      }

      WRITE_REGISTER(EOUTCSRL, 0);     // Clear Out Packet ready bit
   }
}

//-----------------------------------------------------------
//Standard request.c
//-----------------------------------------------------------
void GetStatus(void)
{
   if (gSetup.wValue.c[MSB] || gSetup.wValue.c[LSB] ||
   gSetup.wLength.c[MSB] || (gSetup.wLength.c[LSB] != 2))
   {
      ForceStall();
   }

   switch(gSetup.bmRequestType)
   {
      case OUT_DEVICE:
         if(gSetup.wIndex.c[MSB] ||gSetup.wIndex.c[LSB])
         {
            ForceStall();
         }
         else
         {
            gEp0Status.pData = (BYTE *)&ZERO_PACKET;
            gEp0Status.uNumBytes = 2;
         }
         break;

      case OUT_INTERFACE:
         if ((gDeviceStatus.bDevState != DEV_CONFIGURED) ||
         gSetup.wIndex.c[MSB] || gSetup.wIndex.c[LSB])
         {
            ForceStall();
         }
         else
         {
            gEp0Status.pData = (BYTE *)&ZERO_PACKET;
            gEp0Status.uNumBytes = 2;
         }
         break;

      case OUT_ENDPOINT:
         if ((gDeviceStatus.bDevState != DEV_CONFIGURED) ||
         gSetup.wIndex.c[MSB])
         {
            ForceStall();
         }
         else
         {
            if (gSetup.wIndex.c[LSB] == IN_EP1)
            {
               if (gEp1InStatus.bEpState == EP_HALT)
               {
                  gEp0Status.pData = (BYTE *)&ONES_PACKET;
                  gEp0Status.uNumBytes = 2;
               }
               else
               {
                  gEp0Status.pData = (BYTE *)&ZERO_PACKET;
                  gEp0Status.uNumBytes = 2;
               }
            }
            else
            {
               if (gSetup.wIndex.c[LSB] == OUT_EP2)
               {
                  if (gEp0Status.bEpState == EP_HALT)
                  {
                     gEp0Status.pData = (BYTE *)&ONES_PACKET;
                     gEp0Status.uNumBytes = 2;