echo_d.c 35.1 KB

Raw Blame History Permalink

/*HEADER******************************************************************
**************************************************************************
***
*** Copyright (c) 2001-2002 ARC International.
*** All rights reserved
***
*** This software embodies materials and concepts which are
*** confidential to ARC International and is made
*** available solely pursuant to the terms of a written license
*** agreement with ARC International
***
*** $Workfile:echo_d.c$
*** $Revision: 1.1 $
*** $Date: 2003/02/17 20:49:00 $
***
*** Description:
***  This file contains the VUSB32 device specific Echo example code.
***
**************************************************************************
*END*********************************************************************/
#include "usb.h"
#include "devapi.h"
#include "otgapi.h"
#include "echo_d.h"
#include "echo.h"
#include "test_h.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#define  APP_CONTROL_MAX_PKT_SIZE         (64)
#define  EP1_FS_MAX_PACKET_SIZE           (64)
#define  DEV_DESC_MAX_PACKET_SIZE         (7)
#define  APP_NON_ISO_MAX_PKT_SIZE         (64)
#define  APP_ISO_MAX_PKT_SIZE             (1023)
#define  TEST_SIZE                        (300)

extern _usb_otg_handle                    app_otg_handle;
extern _usb_device_handle                 dev_handle;

DOUBLE_BUFFER_STRUCT ep1_buf, ep2_buf, ep3_buf;
uchar mass_ep1_buf[BUFFERSIZE];
volatile boolean TEST_ECHO_ENABLED = FALSE, FIRST_SOF = TRUE;
extern volatile boolean PERIPHERAL;
extern volatile APP_GLOBAL_STRUCT app_test_struct;

/* Device descriptors are always 18 bytes */
uint_8  DevDesc[18] =
{
   /* Length of DevDesc */
   sizeof(DevDesc),
   /* "Device" Type of descriptor */
   1,
   /* BCD USB version */
   USB_uint_16_low(0x0110), USB_uint_16_high(0x0110),
   /* Device Class is indicated in the interface descriptors */
   0x00,
   /* Device Subclass is indicated in the interface descriptors */
   0x00,
   /* Mass storage devices do not use class-specific protocols */
   0x00,
   /* Max packet size */
   APP_CONTROL_MAX_PKT_SIZE,
   /* Vendor ID */
   USB_uint_16_low(0x05A3), USB_uint_16_high(0x05A3),
   /* Product ID */
   USB_uint_16_low(0x1), USB_uint_16_high(0x1),
   /* BCD Device version */
   USB_uint_16_low(0x0002), USB_uint_16_high(0x0002),
   /* Manufacturer string index */
   0x1,
   /* Product string index */
   0x2,
   /* Serial number string index */
   0x0,
   /* Number of configurations available */
   0x1
};

#define CONFIG_DESC_NUM_INTERFACES  (4)
/* This must be counted manually and updated with the descriptor */
/* 1*Config(9) + 1*Interface(9) + 2*Endpoint(7) = 32 bytes */
#define CONFIG_DESC_SIZE            (35)

uint_8 ConfigDesc[CONFIG_DESC_SIZE] =
{
   /* Configuration Descriptor - always 9 bytes */
   9,
   /* "Configuration" type of descriptor */
   2,
   /* Total length of the Configuration descriptor */
   USB_uint_16_low(CONFIG_DESC_SIZE), USB_uint_16_high(CONFIG_DESC_SIZE),
   /* NumInterfaces */
   1,
   /* Configuration Value */
   1,
   /* Configuration Description String Index*/
   4,
   /* Attributes.  Self-powered. */
   0xc0,
   /* Current draw from bus */
   0,
   /* Interface 0 Descriptor - always 9 bytes */
   9,
   /* "Interface" type of descriptor */
   4,
   /* Number of this interface */
   0,
   /* Alternate Setting */
   0,
   /* Number of endpoints on this interface */
   2,
   /* Interface Class */
   0x08,
   /* Interface Subclass: SCSI transparent command set */
   0x06,
   /* Interface Protocol: Bulk only protocol */
   0x50,
   /* Interface Description String Index */
   0,
   /* Endpoint 1 (Bulk In Endpoint), Interface 0 Descriptor - always 7 bytes*/
   7,
   /* "Endpoint" type of descriptor */
   5,
   /*
   ** Endpoint address.  The low nibble contains the endpoint number and the
   ** high bit indicates TX(1) or RX(0).
   */
   0x81,
   /* Attributes.  0=Control 1=Isochronous 2=Bulk 3=Interrupt */
   0x02,
   /* Max Packet Size for this endpoint */
   USB_uint_16_low(EP1_FS_MAX_PACKET_SIZE),
   USB_uint_16_high(EP1_FS_MAX_PACKET_SIZE),
   /* Polling Interval (ms) */
   0,
   /* Endpoint 2 (Bulk Out Endpoint), Interface 0 Descriptor - always 7 bytes*/
   7,
   /* "Endpoint" type of descriptor */
   5,
   /*
   ** Endpoint address.  The low nibble contains the endpoint number and the
   ** high bit indicates TX(1) or RX(0).
   */
   0x01,
   /* Attributes.  0=Control 1=Isochronous 2=Bulk 3=Interrupt */
   0x02,
   /* Max Packet Size for this endpoint */
   USB_uint_16_low(EP1_FS_MAX_PACKET_SIZE),
   USB_uint_16_high(EP1_FS_MAX_PACKET_SIZE),
   /* Polling Interval (ms) */
   0,
   /* OTG descriptor */
   3,
   9,    /* OTG type */
   3     /* HNP and SRP support */
};

uchar USB_IF_ALT[4] = {0, 0, 0, 0};

/* number of strings in the table not including 0 or n. */
const uint_8 USB_STR_NUM = 6;

/*
** if the number of strings changes, look for USB_STR_0 everywhere and make
** the obvious changes.  It should be found in 3 places.
*/

uint_16 USB_STR_0[ 2] = {0x300 + sizeof(USB_STR_0),0x0409};
uint_16 USB_STR_1[18] = {0x300 + sizeof(USB_STR_1),
      'A','R','C',' ','I','n','t','e','r','n','a','t','i','o','n','a','l'};
uint_16 USB_STR_2[24] = {0x300 + sizeof(USB_STR_2),
      'A','R','C',' ','M','a','s','s',' ','S','t','o','r','a','g','e',' ',\
      'D','e','v','i','c','e'};
uint_16 USB_STR_3[ 5] = {0x300 + sizeof(USB_STR_3),
      'B','E','T','A'};
uint_16 USB_STR_4[ 4] = {0x300 + sizeof(USB_STR_4),
      '#','0','2'};
uint_16 USB_STR_5[ 4] = {0x300 + sizeof(USB_STR_5),
      '_','A','1'};
uint_16 USB_STR_6[15] = {0x300 + sizeof(USB_STR_6),
      'Y','o','u','r',' ','n','a','m','e',' ','h','e','r','e'};
uint_16 USB_STR_n[17] = {0x300 + sizeof(USB_STR_n),
      'B','A','D',' ','S','T','R','I','N','G',' ','I','n','d','e','x'};

const uint_8_ptr USB_STRING_DESC[USB_STR_NUM+2] =
{
   (uint_8_ptr)USB_STR_0,
   (uint_8_ptr)USB_STR_1,
   (uint_8_ptr)USB_STR_2,
   (uint_8_ptr)USB_STR_3,
   (uint_8_ptr)USB_STR_4,
   (uint_8_ptr)USB_STR_5,
   (uint_8_ptr)USB_STR_6,
   (uint_8_ptr)USB_STR_n
};

uint_16        usb_status;
uint_8         endpoint, if_status;
uint_8         data_to_send;
uint_16        sof_count;
uint_8         setup_packet[sizeof(SETUP_STRUCT)];
SETUP_STRUCT   local_setup_packet;

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9GetStatus
* Returned Value : None
* Comments       :
*     Chapter 9 GetStatus command
*     wValue=Zero
*     wIndex=Zero
*     wLength=1
*     DATA=bmERR_STAT
*     The GET_STATUS command is used to read the bmERR_STAT register.
*
*     Return the status based on the bRrequestType bits:
*     device (0) = bit 0 = 1 = self powered
*                  bit 1 = 0 = DEVICE_REMOTE_WAKEUP which can be modified
*     with a SET_FEATURE/CLEAR_FEATURE command.
*     interface(1) = 0000.
*     endpoint(2) = bit 0 = stall.
*     static uint_8_ptr pData;
*
*     See section 9.4.5 (page 190) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9GetStatus
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   if (setup) {
      switch (setup_ptr->REQUESTTYPE) {

         case 0x80:
            /* Device request */
            _usb_device_get_status(handle, USB_STATUS_DEVICE_STATE, &usb_status);
            /* Send the requested data */
            _usb_device_send_data(handle, 0, (uchar_ptr)&usb_status,
               sizeof(usb_status));
            break;

         case 0x81:
            /* Interface request */
            if_status = USB_IF_ALT[setup_ptr->INDEX & 0x00FF];
            /* Send the requested data */
            _usb_device_send_data(handle, 0, &if_status, sizeof(if_status));
            break;

         case 0x82:
            /* Endpoint request */
            endpoint = setup_ptr->INDEX & USB_STATUS_ENDPOINT_NUMBER_MASK;
            _usb_device_get_status(handle,
               USB_STATUS_ENDPOINT | endpoint, &usb_status);
            /* Send the requested data */
            _usb_device_send_data(handle, 0, (uchar_ptr)&usb_status,
               sizeof(usb_status));
            break;

         default:
            /* Unknown request */
            _usb_device_stall_endpoint(handle, 0, 0);
            return;

      } /* Endswitch */

      /* status phase */
      _usb_device_recv_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9ClearFeature
* Returned Value : None
* Comments       :
*     Chapter 9 ClearFeature command
*     See section 9.4.1 (page 188) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9ClearFeature
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   static uint_8           endpoint;
   uint_16                 usb_status;

   _usb_device_get_status(handle, USB_STATUS_DEVICE_STATE, &usb_status);

   if ((usb_status != USB_STATE_CONFIG) && (usb_status != USB_STATE_ADDRESS)) {
      _usb_device_stall_endpoint(handle, 0, 0);
      return;
   } /* Endif */

   if (setup) {
      switch (setup_ptr->REQUESTTYPE) {

         case 0:
            /* DEVICE */
            if (setup_ptr->VALUE == 1) {
               /* clear remote wakeup */
               _usb_device_get_status(handle, USB_STATUS_DEVICE, &usb_status);
               usb_status &= ~USB_REMOTE_WAKEUP;
               _usb_device_set_status(handle, USB_STATUS_DEVICE, usb_status);
            } /* Endif */
            break;

         case 2:
            /* ENDPOINT */
            if (setup_ptr->VALUE != 0) {
               _usb_device_stall_endpoint(handle, 0, 0);
               return;
            } /* Endif */
            endpoint = setup_ptr->INDEX & USB_STATUS_ENDPOINT_NUMBER_MASK;
            _usb_device_get_status(handle, USB_STATUS_ENDPOINT | endpoint,
               &usb_status);
            /* set stall */
            _usb_device_set_status(handle, USB_STATUS_ENDPOINT | endpoint,
               0);
            break;

         default:
            _usb_device_stall_endpoint(handle, 0, 0);
            break;

      } /* Endswitch */
      /* status phase */
      _usb_device_send_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */


/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SetFeature
* Returned Value : None
* Comments       :
*     Chapter 9 SetFeature command
*     See section 9.4.9 (page 194) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SetFeature
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   uint_16           usb_status;
   uint_8            endpoint;

   if (setup) {
      switch (setup_ptr->REQUESTTYPE) {

         case 0:
            /* DEVICE */
            if (setup_ptr->VALUE == 1) {
               /* set remote wakeup */
               _usb_device_get_status(handle, USB_STATUS_DEVICE, &usb_status);
               usb_status |= USB_REMOTE_WAKEUP;
               _usb_device_set_status(handle, USB_STATUS_DEVICE, usb_status);
            } /* Endif */
            if (setup_ptr->VALUE & 0x04) {
               /* set a_hnp_support */
            } /* Endif */
            if (setup_ptr->VALUE & 0x05) {
               /* set a_alt_hnp_support */
            } /* Endif */
            break;

         case 2:
            /* ENDPOINT */
            if (setup_ptr->VALUE != 0) {
               _usb_device_stall_endpoint(handle, 0, 0);
               return;
            } /* Endif */
            endpoint = setup_ptr->INDEX & USB_STATUS_ENDPOINT_NUMBER_MASK;
            _usb_device_get_status(handle, USB_STATUS_ENDPOINT | endpoint,
               &usb_status);
            /* set stall */
            _usb_device_set_status(handle, USB_STATUS_ENDPOINT | endpoint,
               1);
            break;

         default:
            _usb_device_stall_endpoint(handle, 0, 0);
            return;

      } /* Endswitch */

      /* status phase */
      _usb_device_send_data(handle, 0, 0, 0);
   } else {
      if (setup_ptr->VALUE & 0x03) {
         /* sleep callback should be installed for HNP capable Dual role device */
         _usb_device_register_service(handle, USB_SERVICE_SLEEP, bus_suspend);
         /* set b_hnp_enable */
         _usb_otg_set_status(app_otg_handle, USB_OTG_B_HNP_ENABLE, TRUE);
         _usb_otg_set_status(app_otg_handle, USB_OTG_B_BUS_REQ, TRUE);
         app_test_struct.DO_HNP = TRUE;
         TEST_ECHO_ENABLED = FALSE;
      } /* Endif */
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SetAddress
* Returned Value : None
* Comments       :
*     Chapter 9 SetAddress command
*     We setup a TX packet of 0 length ready for the IN token
*     Once we get the TOK_DNE interrupt for the IN token, then
*     we change the ADDR register and go to the ADDRESS state.
*     See section 9.4.6 (page 192) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SetAddress
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   static uint_8 new_address;

   if (setup) {
      new_address = setup_ptr->VALUE;
      /* status phase */
      _usb_device_send_data(handle, 0, 0, 0);
   } else {
      _usb_device_set_status(handle, USB_STATUS_ADDRESS, new_address);
      _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
         USB_STATE_ADDRESS);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9GetDescription
* Returned Value : None
* Comments       :
*     Chapter 9 GetDescription command
*     The Device Request can ask for Device/Config/string/interface/endpoint
*     descriptors (via wValue). We then post an IN response to return the
*     requested descriptor.
*     And then wait for the OUT which terminates the control transfer.
*     See section 9.4.3 (page 189) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9GetDescription
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   if (setup) {
      /* Load the appropriate string depending on the descriptor requested.*/
      switch (setup_ptr->VALUE & 0xFF00) {

         case 0x0100:
            _usb_device_send_data(handle, 0, (uchar_ptr)&DevDesc,
               MIN(setup_ptr->LENGTH, sizeof(DevDesc)));
            break;

         case 0x0200:
            _usb_device_send_data(handle, 0, (uchar_ptr)&ConfigDesc,
               MIN(setup_ptr->LENGTH, sizeof(ConfigDesc)));
            break;

         case 0x0300:
            if ((setup_ptr->VALUE & 0x00FF) > USB_STR_NUM) {
               _usb_device_send_data(handle, 0, USB_STRING_DESC[USB_STR_NUM+1],
                  MIN(setup_ptr->LENGTH, USB_STRING_DESC[USB_STR_NUM+1][0]));
            } else {
               _usb_device_send_data(handle, 0,
                  USB_STRING_DESC[setup_ptr->VALUE & 0x00FF],
                  MIN(setup_ptr->LENGTH,
                     USB_STRING_DESC[setup_ptr->VALUE & 0x00FF][0]));
            } /* Endif */
            break;

         default:
            _usb_device_stall_endpoint(handle, 0, 0);
            return;
      } /* Endswitch */
      /* status phase */
      _usb_device_recv_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SetDescription
* Returned Value : None
* Comments       :
*     Chapter 9 SetDescription command
*     See section 9.4.8 (page 193) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SetDescription
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   _usb_device_stall_endpoint(handle, 0, 0);
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9GetConfig
* Returned Value : None
* Comments       :
*     Chapter 9 GetConfig command
*     See section 9.4.2 (page 189) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9GetConfig
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   uint_16 current_config;
   /* Return the currently selected configuration */
   if (setup){
      _usb_device_get_status(handle, USB_STATUS_CURRENT_CONFIG,
         &current_config);
      data_to_send = current_config;
      _usb_device_send_data(handle, 0, &data_to_send, sizeof(data_to_send));
      /* status phase */
      _usb_device_recv_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SetConfig
* Returned Value : None
* Comments       :
*     Chapter 9 SetConfig command
*     See section 9.4.7 (page 193) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SetConfig
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   uint_16 usb_state;

   _usb_device_get_status(handle, USB_STATUS_DEVICE_STATE, &usb_state);

   if ((usb_state == USB_STATE_CONFIG) || (usb_state == USB_STATE_ADDRESS)) {
      if (setup) {
         /* 0 indicates return to unconfigured state */
         if ((setup_ptr->VALUE & 0x00FF) == 0) {
            /* clear the currently selected config value */
            _usb_device_set_status(handle, USB_STATUS_CURRENT_CONFIG, 0);
            _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
               USB_STATE_ADDRESS);
            /* status phase */
            _usb_device_send_data(handle, 0, 0, 0);
            return;
         } /* Endif */

         /*
         ** If the configuration value (setup_ptr->VALUE & 0x00FF) differs
         ** from the current configuration value, then endpoints must be
         ** reconfigured to match the new device configuration
         */
         _usb_device_get_status(handle, USB_STATUS_CURRENT_CONFIG,
            &usb_state);
         if (usb_state != (setup_ptr->VALUE & 0x00FF)) {
            /* Reconfigure endpoints here */
            switch (setup_ptr->VALUE & 0x00FF) {

               default:
                  break;
            } /* Endswitch */
            _usb_device_set_status(handle, USB_STATUS_CURRENT_CONFIG,
               setup_ptr->VALUE & 0x00FF);
            _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
               USB_STATE_CONFIG);
            /* status phase */
            _usb_device_send_data(handle, 0, 0, 0);
            return;
         } /* Endif */
         _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
            USB_STATE_CONFIG);
         /* ack */
         _usb_device_send_data(handle, 0, 0, 0);
      } /* Endif */
   } else {
      _usb_device_stall_endpoint(handle, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9GetInterface
* Returned Value : None
* Comments       :
*     Chapter 9 GetInterface command
*     See section 9.4.4 (page 190) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9GetInterface
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   uint_16 usb_state;

   _usb_device_get_status(handle, USB_STATUS_DEVICE_STATE, &usb_state);
   if (usb_state != USB_STATE_CONFIG) {
      _usb_device_stall_endpoint(handle, 0, 0);
      return;
   } /* Endif */

   if (setup) {
      _usb_device_send_data(handle, 0, &USB_IF_ALT[setup_ptr->INDEX & 0x00FF],
         MIN(setup_ptr->LENGTH, sizeof(uint_8)));
      /* status phase */
      _usb_device_recv_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SetInterface
* Returned Value : None
* Comments       :
*     Chapter 9 SetInterface command
*     See section 9.4.10 (page 195) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SetInterface
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   if (setup) {
      if (setup_ptr->REQUESTTYPE != 0x01) {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      } /* Endif */

      /*
      ** If the alternate value (setup_ptr->VALUE & 0x00FF) differs
      ** from the current alternate value for the specified interface,
      ** then endpoints must be reconfigured to match the new alternate
      */
      if (USB_IF_ALT[setup_ptr->INDEX & 0x00FF]
         != (setup_ptr->VALUE & 0x00FF))
      {
         USB_IF_ALT[setup_ptr->INDEX & 0x00FF] = (setup_ptr->VALUE & 0x00FF);
         /* Reconfigure endpoints here. */

      } /* Endif */

      /* status phase */
      _usb_device_send_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9SynchFrame
* Returned Value :
* Comments       :
*     Chapter 9 SynchFrame command
*     See section 9.4.11 (page 195) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9SynchFrame
   (
      /* USB handle */
      _usb_device_handle handle,

      /* Is it a Setup phase? */
      boolean setup,

      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */

   if (setup) {
      if (setup_ptr->REQUESTTYPE != 0x02) {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      } /* Endif */

      if ((setup_ptr->INDEX & 0x00FF) >=
         ConfigDesc[CONFIG_DESC_NUM_INTERFACES])
      {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      } /* Endif */

      _usb_device_get_status(handle, USB_STATUS_SOF_COUNT, &sof_count);
      _usb_device_send_data(handle, 0, (uchar_ptr)&sof_count,
         MIN(setup_ptr->LENGTH, sizeof(sof_count)));
      /* status phase */
      _usb_device_recv_data(handle, 0, 0, 0);
   } /* Endif */
   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : ch9Vendor
* Returned Value :
* Comments       :
*     Chapter 9 SynchFrame command
*     See section 9.4.11 (page 195) of the USB 1.1 Specification.
*
*END*--------------------------------------------------------------------*/
void ch9Vendor
   (
      _usb_device_handle handle,
      boolean setup,
      SETUP_STRUCT_PTR setup_ptr
   )
{ /* Body */
   uint_16 ep_num, max_pkt;
   uint_8 ep_type;

   if (setup) {
      switch (setup_ptr->REQUEST) {
         case 2:
            ep_num = (setup_ptr->INDEX & 0xF);
            if (ep_num == 3) {
               ep_type = USB_ISOCHRONOUS_ENDPOINT;
               max_pkt = APP_ISO_MAX_PKT_SIZE;
            } else {
               ep_type = USB_BULK_ENDPOINT;
               max_pkt = APP_NON_ISO_MAX_PKT_SIZE;
            } /* Endif */
            _usb_device_init_endpoint(handle, ep_num,
               max_pkt, USB_RECV, ep_type, 0);
            _usb_device_init_endpoint(handle, ep_num,
               max_pkt, USB_SEND, ep_type, 0);
            if (ep_num == 3) {
               TEST_ECHO_ENABLED = TRUE;
            } /* Endif */
            break;
         default :
            _usb_device_stall_endpoint(handle, ep_num, 0);
            return;
      } /* EndSwitch */
      _usb_device_send_data(handle, 0, 0, 0);
  } /* Endif */

} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : service_ep0
* Returned Value : None
* Comments       :
*     Called upon a completed endpoint 0 (USB 1.1 Chapter 9) transfer
*
*END*--------------------------------------------------------------------*/
void service_ep0
   (
      /* [IN] Handle of the USB device */
      _usb_device_handle   handle,

      /* [IN] Is it a setup packet? */
      boolean              setup,

      /* [IN] Direction of the transfer.  Is it transmit? */
      uint_8               direction,

      /* [IN] Pointer to the data buffer */
      uint_8_ptr           buffer,

      /* [IN] Length of the transfer */
      uint_32              length
   )
{ /* Body */
   boolean  class_request = FALSE;

   if (setup) {
      _usb_device_read_setup_data(handle, 0, (uchar_ptr)&local_setup_packet);
   } else if (class_request) {
      class_request = FALSE;
      /* Finish your class or vendor request here */

      return;
   } /* Endif */

   switch (local_setup_packet.REQUESTTYPE & 0x60) {

      case 0x00:
         switch (local_setup_packet.REQUEST) {

            case 0x0:
               ch9GetStatus(handle, setup, &local_setup_packet);
               break;

            case 0x1:
               ch9ClearFeature(handle, setup, &local_setup_packet);
               break;

            case 0x3:
               ch9SetFeature(handle, setup, &local_setup_packet);
               break;

            case 0x5:
               ch9SetAddress(handle, setup, &local_setup_packet);
               break;

            case 0x6:
               ch9GetDescription(handle, setup, &local_setup_packet);
               break;

            case 0x7:
               ch9SetDescription(handle, setup, &local_setup_packet);
               break;

            case 0x8:
               ch9GetConfig(handle, setup, &local_setup_packet);
               break;

            case 0x9:
               ch9SetConfig(handle, setup, &local_setup_packet);
               break;

            case 0xa:
               ch9GetInterface(handle, setup, &local_setup_packet);
               break;

            case 0xb:
               ch9SetInterface(handle, setup, &local_setup_packet);
               break;

            case 0xc:
               ch9SynchFrame(handle, setup, &local_setup_packet);
               break;

            default:
               _usb_device_stall_endpoint(handle, 0, 0);
               break;

         } /* Endswitch */

         break;

      case 0x20:
         /* class specific request */
         class_request = TRUE;
         /* Queue your own packet for class data here */
         return;

      case 0x40:
         /* vendor specific request */
         ch9Vendor(handle, setup, &local_setup_packet);
         break;

      default:
         _usb_device_stall_endpoint(handle, 0, 0);
         break;

   } /* Endswitch */

} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : reset_ep0
* Returned Value : None
* Comments       :
*     Called upon a bus reset event.  Initialises the control endpoint.
*
*END*--------------------------------------------------------------------*/
void reset_ep0
   (
      /* [IN] Handle of the USB device */
      _usb_device_handle   handle,

      /* [IN] Unused */
      boolean              setup,

      /* [IN] Unused */
      uint_8               direction,

      /* [IN] Unused */
      uint_8_ptr           buffer,

      /* [IN] Unused */
      uint_32              length
   )
{ /* Body */
   uint_32 state;

   FIRST_SOF = TRUE;

   if (TEST_ECHO_ENABLED) {
      _usb_device_cancel_transfer(handle, 1, USB_RECV);
      _usb_device_cancel_transfer(handle, 1, USB_SEND);
      _usb_device_cancel_transfer(handle, 2, USB_RECV);
      _usb_device_cancel_transfer(handle, 2, USB_SEND);
      _usb_device_cancel_transfer(handle, 3, USB_RECV);
      _usb_device_cancel_transfer(handle, 3, USB_SEND);
      TEST_ECHO_ENABLED = FALSE;
   } /* Endif */
   _usb_otg_get_status(app_otg_handle, USB_OTG_STATE, &state);

   if ((!TEST_ECHO_ENABLED) &&
      ((state == B_PERIPHERAL) || (state == A_PERIPHERAL)))
   {
      _usb_device_init_endpoint(handle, 0, DevDesc[DEV_DESC_MAX_PACKET_SIZE], 0,
         USB_CONTROL_ENDPOINT, 0);
      _usb_device_init_endpoint(handle, 0, DevDesc[DEV_DESC_MAX_PACKET_SIZE], 1,
         USB_CONTROL_ENDPOINT, 0);
   } /* Endif */
   return;
} /* EndBody */


/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : bus_suspend
* Returned Value : None
* Comments       :
*     Called upon a SLEEP interrupt.
*
*END*--------------------------------------------------------------------*/
void bus_suspend
   (
      /* [IN] Handle of the USB device */
      _usb_device_handle   handle,

      /* [IN] Unused */
      boolean              setup,

      /* [IN] Unused */
      uint_8               direction,

      /* [IN] Unused */
      uint_8_ptr           buffer,

      /* [IN] Unused */
      uint_32              length
   )
{ /* Body */

   uint_32 state;

   _usb_otg_get_status(app_otg_handle, USB_OTG_STATE, &state);

   if (state == B_PERIPHERAL) {
      _usb_otg_set_status(app_otg_handle, USB_OTG_A_BUS_SUSPEND, TRUE);
   } else if (state == A_PERIPHERAL)  {
      _usb_otg_set_status(app_otg_handle, USB_OTG_B_BUS_SUSPEND,TRUE);
   } /* Endif */

   return;
} /* EndBody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : bus_sof
* Returned Value : None
* Comments       :
*     Called upon a a Start of Frame Interrupt.
*
*END*--------------------------------------------------------------------*/
void bus_sof
   (
      /* [IN] Handle of the USB device */
      _usb_device_handle   handle,

      /* [IN] Unused */
      boolean              setup,

      /* [IN] Unused */
      uint_8               direction,

      /* [IN] Unused */
      uint_8_ptr           buffer,

      /* [IN] Unused */
      uint_32              length
   )
{ /* Body */

   uint_32 state;
   _usb_otg_get_status(app_otg_handle, USB_OTG_STATE, &state);
   if ((state == A_PERIPHERAL) && (FIRST_SOF)) {
      _usb_device_register_service(handle, USB_SERVICE_SLEEP, bus_suspend);
      FIRST_SOF = FALSE;
   } /* Endif */
    return;
} /* EndBody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : main
* Returned Value : None
* Comments       :
*     First function called.  Initialises the USB and registers Chapter 9
*     callback functions.
*
*END*--------------------------------------------------------------------*/
void device_main
   (
      /* [IN] Handle of the USB device */
      _usb_device_handle   handle

   )
{ /* Body */

   INIT_DBUF(ep1_buf);
   INIT_DBUF(ep2_buf);
   INIT_DBUF(ep3_buf);

   while (TRUE) {
      if (TEST_ECHO_ENABLED) {
         if (_usb_device_get_transfer_status(handle, 3, USB_RECV) == USB_OK) {
            _usb_device_recv_data(handle, 3, DBUF(ep3_buf), 64);
         } /* Endif */

         if (_usb_device_get_transfer_status(handle, 2, USB_RECV) == USB_OK) {
            _usb_device_recv_data(handle, 2, DBUF(ep2_buf), TEST_SIZE);
         } /* Endif */

         if (_usb_device_get_transfer_status(handle, 1, USB_RECV) == USB_OK) {
            _usb_device_recv_data(handle, 1, DBUF(ep1_buf), TEST_SIZE);
         } /* Endif */

         while (_usb_device_get_transfer_status(handle, 1, USB_RECV) !=
            USB_STATUS_IDLE)
         {
            /* Wait until receive is complete */
            if (!TEST_ECHO_ENABLED) {
               /* break if bus reset was encountered */
               return;
            } /* Endif */
         } /* Endwhile */

         if (_usb_device_get_transfer_status(handle, 3, USB_SEND) == USB_OK){
            _usb_device_send_data(handle, 3, DBUF(ep3_buf), 64);
            TOGGLE_DBUF(ep3_buf);
         } /* Endif */

         if (_usb_device_get_transfer_status(handle, 2, USB_SEND) == USB_OK){
            _usb_device_send_data(handle, 2, DBUF(ep2_buf), TEST_SIZE);
            TOGGLE_DBUF(ep2_buf);
         } /* Endif */

         if (_usb_device_get_transfer_status(handle, 1, USB_SEND) == USB_OK){
            _usb_device_send_data(handle, 1, DBUF(ep1_buf), TEST_SIZE);
            TOGGLE_DBUF(ep1_buf);
         } /* Endif */


         while (_usb_device_get_transfer_status(handle, 1, USB_SEND) !=
            USB_STATUS_IDLE)
         {
            /* Wait forever */
            if (!TEST_ECHO_ENABLED) {
               /* break if bus reset was encountered */
               return;
            } /* Endif */
         } /* Endwhile */
      } /* Endif */
   } /* Endwhile */
} /* Endbody */

/* EOF */