echo.c 38 KB

Raw Blame History Permalink

/*HEADER******************************************************************
**************************************************************************
***
*** Copyright (c) 1989-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.c$
*** $Revision: 1.1 $
*** $Date: 2003/02/17 20:49:00 $
***
*** Description:
***  This file contains the USB 1.1 Echo example application
***
**************************************************************************
*END*********************************************************************/
#include "usbd.h"
#include "devapi.h"
#include "echo.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

DOUBLE_BUFFER_STRUCT ep1_buf, ep2_buf, ep3_buf;
boolean TEST_ECHO_ENABLED = FALSE;

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

/* 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 */
   0xe0,
   /* Device Subclass */
   0x00,
   /* Device Protocol */
   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(0x0001), USB_uint_16_high(0x0001),
   /* Manufacturer string index */
   0x0,
   /* 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 */
#define  CONFIG_DESC_SIZE           (0x86)
#define  USB_NUM_IFACES             (0x02)
#define  ENDPOINT_SPEAKER           (0x01)
#define  IFC1_ALT0_MAX              (0x0000)
#define  IFC1_ALT1_MAX              (0x0030)
#define  IFC1_ALT0_MAX_LO           (0x00)
#define  IFC1_ALT0_MAX_HI           (0x00)
#define  IFC1_ALT1_MAX_HI           (0x00)
#define  IFC1_ALT1_MAX_LO           (0x30)

uint_8 ConfigDesc[CONFIG_DESC_SIZE] =
{
   /* This table is retrieved by the host after the address has been set.
   ** This table defines the configurations available for the device.
   ** See section 9.6.2 of the Rev 1.0 USB specification (page 184).
   ** These fields are application DEPENDENT.
   ** Be sure to modify these to meet your specifications.
   */
   9,      /* bLength   Length of this descriptor */
   2,      /* bDescType   2=CONFIGURATION */

   CONFIG_DESC_SIZE & 0xff, CONFIG_DESC_SIZE >> 8,
   USB_NUM_IFACES,      /* bNumInterfaces   Number of interfaces */

   /* USB_CONFIG_VAL: */
   0x01,   /* bConfigValue   Configuration Value */
   0x04,   /* iConfig   String Index for this config = #01 */
   0xc0,   /* bmAttributes   attributes - self powered */
   0,      /* MaxPower   self-powered draws 0 mA from the bus. */
   /*   IIIII  FFFFF   CCCC   000
   **     I    F      C      0   0
   **     I    FFF    C      0   0
   **     I    F      C      0   0
   **   IIIII  F       CCCC   000
   */

   /* AUDIO CONTROL: See section 9.6.3, Rev 1.0 USB spec (page 185) */

   0x09,   /* blength   Length of this desriptor */
   4,      /* bDescriptorType   4=INTERFACE */
   0,      /* bIfaceNum   interface number */
   0,      /* bAltSetting   Alternate setting 0 (no others) */
   0,      /* bNumEndpoints   Number of endpoints= use EP0 only */
   0x01,   /* bIfaceClass   Interface class 01=AUDIO */
   0x01,   /* bIfaceSubClass   Audio COntrol */
   0x00,   /* bIfaceProtocol   none */
   0,      /* iInterface */

   /* USB_AC_IFACE: Audio Class Specific Audio Control (AC) I/F desc */
   0x09,      /* bLength */
   0x24,      /* Audio class specific interface descriptor */
   0x01,      /* HEADER type */
   0x09,0x00, /* spec rev = 0009 */
   0x1e,0x00, /* total length=001e */
   0x01,      /* number of streaming interfaces=1 */
   0x01,      /* Interface number=1 */

   0x0c,      /* bLength */
   0x24,      /* Audio class specific interface desc */
   0x02,      /* Input Terminal */
   0x01,      /* TerminalID */
   0x01,0x01, /* TerminalType=0101=Audio Streaming */
   0x00,      /* output AssocTerminal */
   0x02,      /* Number of Channels=2 */
   0x03,0x00, /* wChannelConfig=L,R */
   0x00,      /* iChannelNames=none */
   0x00,      /* iTerminal */

   0x09,      /* bLength */
   0x24,      /* Type=Audio class specific interface desc */
   0x03,      /* Output Terminal */
   0x02,      /* TerminalID */
   0x01,0x03, /* TerminalType=0301=Generic Speakers */
   0x00,      /* bAssocTerminal=terminalID connect to=0? */
   0x01,      /* bSourceID=TerminalID which is the source for this
              ** terminal=feature unit
              */
   0x00,      /* iTerminal=string */

   /*   IIIII  FFFFF   CCCC    1
   **     I    F      C       11
   **     I    FFF    C        1
   **     I    F      C        1
   **   IIIII  F       CCCC  11111
   */

   /* AUDIO STREAM See section 9.6.3, Rev 1.0 USB spec (page 185) */

   /*       AAA   L      TTTTT   000
   **      A   A  L        T    0   0
   **      AAAAA  L        T    0   0
   **      A   A  L        T    0   0
   **      A   A  LLLLL    T     000
   */

   0x09,   /* blength   Length of this desriptor */
   4,      /* bDescriptorType   4=INTERFACE */
   1,      /* bIfaceNum   interface number #1 */
   0,      /* bAltSetting   Alternate setting 0 Zero ISO Bandwidth
           ** version which is required by Win98
           */
   1,      /* bNumEndpoints   Number of endpoints= use EP0 only */
   0x01,   /* bIfaceClass   Interface class 01=AUDIO */
   0x02,   /* bIfaceSubClass   Audio Streaming */
   0x00,   /* bIfaceProtocol   none */
   4,      /* iInterface   String=#01 */

   0x07,   /* bLength */
   0x24,   /* Audio Class Specific AS Interface Desc. */
   0x01,   /* AS_GENERAL */
   0x01,   /* TermLink connected to terminal #1 */
   0x00,   /* Delay=0 */
   0x00,0x01,   /* FormatTag=PCM */

   0x0b,   /* bLength   Format Specification */
   0x24,   /* Audio Class Specific AS Interface Desc. */
   0x02,   /* FORMAT_TYPE */
   0x01,   /* formatType */
   0x02,   /* NrChannels=2 */
   0x02,   /* SubFrameSize=2 byte */
   16,     /* BitResolution=16 bits */
   0x01,   /* SamFreqType=1 type */
   0x00,0x00, /* ZERO BANDWIDTH */
   0x00,      /* SamFreq MSB (it's a 24 bit number in HZ) */

   9,         /* bLength   Length of this descriptor */
   5,         /* bDescType   5=ENDPOINT */
   ENDPOINT_SPEAKER,   /* bEndpntAddr   End Point address (EP2=out) */
   0x09,      /* bmAttr   ISO adaptive rate */
   IFC1_ALT0_MAX_LO,IFC1_ALT0_MAX_HI, /* wMaxPktSize   Max Packet Size */
   1,         /* bInterval */
   0,         /* bRefresh */
   0,         /* SyncAddr   None */

   /* USB_AS_DESC1: Class Specific Audio AS EP descriptor */
   7,         /* bLength   Length of this descriptor */
   0x25,      /* bDescType   Class specific ENDPOINT */
   1,         /* SubType   GENERAL */
   0,         /* bmAttr   none */
   2,         /* bDelayUnits   PCM samples */
   0x01,0x00, /* bLockDelay   1 sample delay */

   /*       AAA   L      TTTTT    1
   **      A   A  L        T     11
   **      AAAAA  L        T      1
   **      A   A  L        T      1
   **      A   A  LLLLL    T    11111
   */

   0x09,      /* blength   Length of this desriptor */
   4,         /* bDescriptorType   4=INTERFACE */
   1,         /* bIfaceNum   interface number #1 */
   1,         /* bAltSetting   Alternate setting #1 */
   1,         /* bNumEndpoints   Number of endpoints=1 */
   0x01,      /* bIfaceClass   Interface class 01=AUDIO */
   0x02,      /* bIfaceSubClass   Subclass 02=AUDIO_STREAMING */
   0x00,      /* bIfaceProtocol   protocol */
   05,        /* iInterface   String Index */

   /* USB_AS_IFACE: Audio Class Specific Audio Streaming (AS) Interface
   ** desc
   */
   0x07,      /* bLength */
   0x24,      /* Audio Class Specific AS Interface Desc. */
   0x01,      /* AS_GENERAL */
   0x01,      /* TermLink connected to terminal #1 */
   0x00,      /* Delay=0 */
   0x01,0x00, /* FormatTag=PCM */

   0x0b,      /* bLength Format Specification */
   0x24,      /* Audio Class Specific AS Interface Desc. */
   0x02,      /* FORMAT_TYPE */
   0x01,      /* formatType */
   0x02,      /* NrChannels=2 */
   0x02,      /* SubFrameSize=2 byte */
   16,        /* BitResolution=16 bits */
   0x01,      /* SamFreqType=1 type */
   0x11,0x2b, /*  SamFreq=11.025Khz */
   0x00,      /* SamFreq MSB (it's a 24 bit number in HZ) */

   /* USB_EP_DESC1:  table for the USB ENDPOINT Descriptor */
   /* See section 9.6.4 of the Rev 1.0 USB spec (page 187) */
   9,                /* bLength   Length of this descriptor */
   5,                /* bDescType   5=ENDPOINT */
   ENDPOINT_SPEAKER, /* bEndpntAddr   End Point address (EP2=out) */
   0x09,             /* bmAttr   ISO adaptive rate */
   IFC1_ALT1_MAX_LO,IFC1_ALT1_MAX_HI, /* wMaxPktSize   Max Packet Size */
   1,         /* bInterval  */
   0,         /* bRefresh */
   0,         /* SyncAddr   None */

   /* USB_AS_DESC1: Class Specific Audio AS EP descriptor */
   7,         /* bLength   Length of this descriptor */
   0x25,      /* bDescType   Class specific ENDPOINT */
   1,         /* SubType   GENERAL */
   0,         /* bmAttr   none */
   2,         /* bDelayUnits   PCM samples */
   0x01,0x00  /* bLockDelay   1 sample delay */
};

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[33] = {0x300 + sizeof(USB_STR_2),
      'A','R','C',' ','V','U','S','B',' ','S','y','n','t','h','e','s','i','z',\
      'a','b','l','e',' ','C','o','r','e',' ','D','e','m','o'};
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 */
            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);
   } /* 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 */
   _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);

   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);
   } /* Endif */

   TEST_ECHO_ENABLED = FALSE;

  return;
} /* EndBody */

/*FUNCTION*----------------------------------------------------------------
*
* Function Name  : main
* Returned Value : None
* Comments       :
*     First function called.  Initialises the USB and registers Chapter 9
*     callback functions.
*
*END*--------------------------------------------------------------------*/
void main
   (
      void
   )
{ /* Body */
   _usb_device_handle   handle;
   uint_8               error;

   _disable();

   /* Initialize the USB interface */
   error = _usb_device_init(0, &handle, 4);

   if (error != USB_OK) {
      printf("\nUSB Initialization failed. Error: %x", error);
      fflush(stdout);
   } /* Endif */

   error = _usb_device_register_service(handle, USB_SERVICE_EP0, service_ep0);

   if (error != USB_OK) {
      printf("\nUSB Service Registration failed. Error: %x", error);
      fflush(stdout);
   } /* Endif */

   error = _usb_device_register_service(handle, USB_SERVICE_BUS_RESET,
      reset_ep0);

   if (error != USB_OK) {
      printf("\nUSB Service Registration failed. Error: %x", error);
      fflush(stdout);
   } /* Endif */

   _enable();

   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 */
               break;
            } /* 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 */
               break;
            } /* Endif */
         } /* Endwhile */
      } /* Endif */
   } /* Endwhile */
} /* Endbody */

/* EOF */