past the byte at offset (15 + bCBWCBLength - 1).
    */
    for(i = 0; i<gbCBWCBLength; i++)
     {
      gbCBWCB[i] = USB_FIFO[15+i];
     }

//    USIZE = 0;
    UCON |= EPFIFO_BSY;



    gbCSWStatus     = PASS;                  // default CSW Status
    gbBulkPipeStage = BS_DATA_PHASE;

    if (gbCBWCBLength>0)
     {
/* Now decode the CBWCB; the command block to be executed by the device. */
      switch (gbCBWCB[0])
       {
        case OP_READ10:
         {
          DoReadWrite();
          break;
         }

        case OP_WRITE10:
         {
          DoReadWrite();
          break;
         }

        case OP_TEST_UNIT_READY:
         {
/* This is called by WinXP typ. every 1 second to check the unit */
/* default: all OK */
          ReturnCSW();                       // return status
          break;
         }

        case OP_REQUEST_SENSE:
         {
          OnRequestSense();
          break;
         }

        case OP_INQUIRY:
         {
          OnInquiry();
          break;
         }

        case OP_MODE_SENSE10:
         {
          OnModeSense10();
          break;
         }

        case OP_MODE_SELECT10:
         {
          OnModeSelect10();
          break;
         }


        case OP_MODE_SENSE6:
         {
          OnModeSense6();
          break;
         }

        case OP_MODE_SELECT6:
         {
          OnModeSelect6();
          break;
         }


        case OP_READ_CAPACITY:
         {
          DoReadCapacity();
          break;
         }

        case OP_READ_FORMAT_CAPACITIES:
         {
          DoReadFormatCapacity();
          break;
         }


        case OP_MEDIA_REMOVEAL:
         {
          gbCSWStatus = FAIL;
          ReturnCSW();                       // return status
          break;
         }

        case OP_VERIFY:
         {
          gbCSWStatus = FAIL;
          ReturnCSW();                       // return status
          break;
         }

        default:
         {
          gbCSWStatus = FAIL;
          STALL_EP1();                       // unknown command
          gbBulkPipeStage = BS_CSW_PHASE;
          break;
         }
       }
     }
    else
     {
      ReturnCSW();                           // no command, return status
     }

   }
  else
   {
    gbCSWStatus = FAIL;
    STALL_EP1();                             // unknown command block type, STALL
    gbBulkPipeStage = BS_CBW_PHASE;
   }
 }














unsigned char USB_ISR_Counter;               // incremented every USB INT event

void UsbIsr(void) interrupt USB_VECTOR using 2
/******************************************************************************
 Function   : void UsbIsr()
 Parameters : none
 Description: USB interrupt service routine.
 Note:        Do not modify this routine !!!
 ******************************************************************************/
 {


  UCTL |= VISIBLE;                           // enable USB FIFO mapping in XDATA


  if (RSTF)
   {

    OnUsbReset();                            // USB Reset int

    UIE1  |= UMSC_MASK_IN_ENDPOINT;          //Enable EP0 IN INT
    UIE2  |= UMSC_MASK_OUT_ENDPOINT;         //Enable EP0 OUT INT

    USEL   = OUTDIR | UMSC_OUT_ENDPOINT;     //Select EP OUT
    UCON   = ENABLE_FIFO | EPFIFO_BSY;

    USEL   = INDIR | UMSC_IN_ENDPOINT;       //Select EP IN
    UCON   = ENABLE_FIFO;

    UIF1 = 0;
    UIF2 = 0;
    UIF3 = 0;
    UIF0 = 0;
    RSTF = 0;
    SUSPNDF = 0;

    if (UCON & TOGGLE)                       //only silicon revision #0
     {
      USIZE = 0;                            //send an empty packet to reach DATA=0
     }

    USTA = 0;                                //silicon revision #0
    UADDR = 0;                         //Reset device address, silicon revision #0

    gbBulkPipeStage = BS_CBW_PHASE;

   }





/* IN packets servicing, invoked when TuPSD+ sent an ACKed packet to a host */
  if (INF)
   {
    if (UIF1 & IN0F)                         // EP0 IN
     {
      UIF1 &= ~IN0F;
      TransmitEP0();
      if (usbState == US_ADDRESSED)     // DEVICE ADDRESS change after SET_ADDRESS
       {
        UADDR    = setupPacket.wValue.lo;    //device address
        usbState = US_DEFAULT;
       }
     }


    if (UIF1 & UMSC_MASK_IN_ENDPOINT)        // EP IN
     {
      switch (gbBulkPipeStage)
       {
        case BS_DATA_PHASE:
         {
          UIF1 &= ~UMSC_MASK_IN_ENDPOINT;
          ReadBufferFromFlash();
          break;
         }
        case BS_CBW_PHASE:
         {
                                             //UIF1 &= ~UMSC_MASK_IN_ENDPOINT;
          break;
         }
        case BS_CSW_PHASE:                   // DATA phase finished, preparing CSW
         {
          UIF1 &= ~UMSC_MASK_IN_ENDPOINT;
          ReturnCSW();
          break;
         }
        case BS_CSW_DONE_PHASE:              //CSW sent, IN FIFO became empty
         {
          UIF1 &= ~UMSC_MASK_IN_ENDPOINT;
          gbBulkPipeStage = BS_CBW_PHASE;    //CSW
          break;
         }
       }
     }

/*
    if (UIF1 & IN2F)                         //EP2 IN
    {
    UIF1 &= ~IN2F;                         // User code area
    }

    if (UIF1 & IN3F)                         //EP3 IN
    {
    UIF1 &= ~IN3F;                         // User code area
    }

    if (UIF1 & IN4F)                         //EP4 IN
    {
    UIF1 &= ~IN4F;                         // User code area
    }
    */
   }


/* OUT packets servicing,invoked when TuPSD+ receives an OUT packet from a host*/
  if (OUTF)
   {
    if (UIF2 & OUT0F)                        // EP0 OUT
     {
      UIF2 &= ~OUT0F;
      if (USTA & SETUP)
       {
        if (ReadSetupPacket())
         {
          OnSetupPacket();
         }
        if (usbState == US_CONFIGURED)
         {
          USEL  = INDIR | UMSC_IN_ENDPOINT;  //Select EP IN
          if (UCON & TOGGLE)                 //only silicon revision #0
           {
            USIZE = 0;                      //send an empty packet to reach DATA=0
           }
//    UCON &= ~TOGGLE;                       //clear toggle
          USEL  = OUTDIR | UMSC_OUT_ENDPOINT;//Select EP OUT
//    UCON &= ~TOGGLE;                       //clear toggle
         }
       }
      else
       {
       }
      gbBulkPipeStage = BS_CBW_PHASE;
     }

/*
    if (UIF2 & OUT1F)                        // EP1 OUT
    {
    UIF2 &= ~OUT1F;                        // User code area
    }

    if (UIF2 & OUT2F)                        // EP2 OUT
    {
    UIF2 &= ~OUT2F;                        // User code area
    }
    */

    if (UIF2 & UMSC_MASK_OUT_ENDPOINT)       // EP3 OUT
     {
      switch (gbBulkPipeStage)
       {
        case BS_CBW_PHASE:                   // Command received
         {
          UIF2 &= ~UMSC_MASK_OUT_ENDPOINT;
          CheckReceiveCBW();
          break;
         }
        case BS_DATA_PHASE:                  // Data block received
         {
          UIF2 &= ~UMSC_MASK_OUT_ENDPOINT;
          WriteBufferToFlash();
          break;
         }
        case BS_CSW_PHASE:
         {
          break;
         }
        case BS_CSW_DONE_PHASE:
         {
          break;
         }
       }

     }
/*
    if (UIF2 & OUT4F)                        // EP4 OUT
    {
    UIF2 &= ~OUT4F;                        // User code area
    }
    */
   }




  if (SUSPNDF)
   {
    if (RESUMF)
     {
      UIE0     |=  SUSPENDIE;
      UIE0     &= ~RESUMEIE;
      OnUsbResume();                         // resume int
      RESUMF  = 0;
      SUSPNDF = 0;
      gbBulkPipeStage = BS_CBW_PHASE;
                                             // only for DK3420
      ET0   = 1;                             // enable timer 0 interrupt
     }
    else
     {
      UIE0     |=  RESUMEIE;
      UIE0     &= ~SUSPENDIE;
      OnUsbSuspend();                        // suspend int
      gbBulkPipeStage = BS_CBW_PHASE;
                                             // only for DK3420
      ET0       = 0;                         // disable timer 0 interrupt
      P4_0      = 1;                         // GREEN LED OFF
      UPSD_xreg.DATAOUT_D = 255;             // RED LED OFF
     }
   }

  UCTL  &= ~VISIBLE;                         // Disable USB FIFO mapping in XDATA
  USB_ISR_Counter++;                         // USB activity indicator

 }



/* *************************************************************************
  ***                                                                      ***
  **                         *** End of File ***                            **
  ***                                                                      ***
  *************************************************************************  */