usb_standard_request.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
/*! \file *********************************************************************
 *
 * \brief
 *      This file contains the USB endpoint 0 management routines corresponding to
 *      the standard enumeration process (refer to chapter 9 of the USB
 *      specification.
 *      This file calls routines of the usb_specific_request.c file for non-standard
 *      request management.
 *      The enumeration parameters (descriptor tables) are contained in the
 *      usb_descriptors.c file.
 *
 * \addtogroup usbdriver
 *
 * \author
 *      Atmel Corporation: http://www.atmel.com \n
 *      Support email: avr@atmel.com
 *
 ******************************************************************************/
/* Copyright (c) 2008  ATMEL Corporation
   All rights reserved.

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in
     the documentation and/or other materials provided with the
     distribution.
   * Neither the name of the copyright holders nor the names of
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
*/

//_____ I N C L U D E S ____________________________________________________

#include "config.h"
#include "usb_drv.h"
#include "usb_descriptors.h"
#include "usb_specific_request.h"
#include <string.h>

//_____ M A C R O S ________________________________________________________


//_____ D E F I N I T I O N ________________________________________________
#define PRINTF printf
#define PRINTF_P printf_P

//_____ P R I V A T E   D E C L A R A T I O N ______________________________

static  void    usb_get_descriptor(   void);
static  void    usb_set_address(      void);
static  void    usb_set_configuration(void);
static  void    usb_clear_feature(    void);
static  void    usb_set_feature(      void);
static  void    usb_get_status(       void);
static  void    usb_get_configuration(void);
static  void    usb_get_interface (void);
static  void    usb_set_interface (void);


//_____ D E C L A R A T I O N ______________________________________________

static  bit  zlp;
static  U8   endpoint_status[NB_ENDPOINTS];

#ifdef AVRGCC
        PGM_VOID_P pbuffer;
#else
        U8   FLASH *pbuffer;
#endif
        U8   data_to_transfer;

        U16  wInterface;

static  U8   bmRequestType;

        U8   usb_configuration_nb;

                usb_mode_t usb_mode = rndis_debug;

extern  bit     usb_connected;
extern  FLASH    S_usb_device_descriptor             usb_user_device_descriptor_network;
extern  FLASH    S_usb_user_configuration_descriptor_network usb_user_configuration_descriptor_network;
extern  FLASH    S_usb_device_descriptor             usb_user_device_descriptor_composite;
extern  FLASH    S_usb_user_configuration_descriptor_composite usb_user_configuration_descriptor_composite;

//! usb_process_request.
//!
//! @brief This function reads the SETUP request sent to the default control endpoint
//! and calls the appropriate function. When exiting of the usb_read_request
//! function, the device is ready to manage the next request.
//!
//! @note list of supported requests:
//! GET_DESCRIPTOR
//! GET_CONFIGURATION
//! SET_ADDRESS
//! SET_CONFIGURATION
//! CLEAR_FEATURE
//! SET_FEATURE
//! GET_STATUS
//!
void usb_process_request(void)
{
   U8  bmRequest;

   bmRequestType = Usb_read_byte();
   bmRequest     = Usb_read_byte();

   switch (bmRequest)
   {
    case GET_DESCRIPTOR:
         if (0x80 == bmRequestType) { usb_get_descriptor(); }
         else goto user_read;
         break;

    case GET_CONFIGURATION:
         if (0x80 == bmRequestType) { usb_get_configuration(); }
         else goto user_read;
         break;

    case SET_ADDRESS:
         if (0x00 == bmRequestType) { usb_set_address(); }
         else goto user_read;
         break;

    case SET_CONFIGURATION:
         if (0x00 == bmRequestType) { usb_set_configuration(); }
         else goto user_read;
         break;

    case CLEAR_FEATURE:
         if (0x02 >= bmRequestType) { usb_clear_feature(); }
         else goto user_read;
         break;

    case SET_FEATURE:
         if (0x02 >= bmRequestType) { usb_set_feature(); }
         else goto user_read;
         break;

    case GET_STATUS:
         if ((0x7F < bmRequestType) & (0x82 >= bmRequestType))
                                    { usb_get_status(); }
         else goto user_read;
         break;

    case GET_INTERFACE:
          if (bmRequestType == 0x81) { usb_get_interface(); }
                  else goto user_read;
          break;


    case SET_INTERFACE:
      if (bmRequestType == 0x01) {usb_set_interface();}
      break;

    case SET_DESCRIPTOR:
    case SYNCH_FRAME:
    default: //!< un-supported request => call to user read request
        user_read:
         usb_user_read_request(bmRequestType, bmRequest);
         break;
  }
        
        Usb_select_endpoint(EP_CONTROL);

        // If the receive setup flag hasn't been cleared
        // by this point then we can assume that we didn't
        // support this request and should stall.
        if(Is_usb_receive_setup())
                Usb_enable_stall_handshake();
        
        // Clear some flags.
        Usb_ack_receive_setup();
        Usb_ack_receive_out();
        Usb_ack_in_ready();
}

//! usb_set_address.
//!
//! This function manages the SET ADDRESS request. When complete, the device
//! will filter the requests using the new address.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_set_address(void)
{
   Usb_configure_address(Usb_read_byte());

   Usb_ack_receive_setup();

   Usb_send_control_in();                    //!< send a ZLP for STATUS phase
   while(!Is_usb_in_ready());                //!< waits for status phase done
                                             //!< before using the new address
   Usb_enable_address();
}

//! usb_set_configuration.
//!
//! This function manages the SET CONFIGURATION request. If the selected
//! configuration is valid, this function call the usb_user_endpoint_init()
//! function that will configure the endpoints following the configuration
//! number.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_set_configuration( void )
{
U8 configuration_number;

   configuration_number = Usb_read_byte();

   // TODO: Verify configuration_number!
   Usb_ack_receive_setup();
   usb_configuration_nb = configuration_number;

   Usb_send_control_in();                    //!< send a ZLP for STATUS phase
   while(!Is_usb_in_ready());

   usb_user_endpoint_init(usb_configuration_nb);  //!< endpoint configuration
   Usb_set_configuration_action();
}





void usb_get_string_descriptor_sram(U8  string_type) {
        U16 requested_length;
        U8  dummy;
        const char* user_str;

        user_str = usb_user_get_string_sram(string_type);
        
        dummy = Usb_read_byte();                     //!< don't care of wIndex field
        dummy = Usb_read_byte();
        requested_length = Usb_read_byte();              //!< read wLength
        requested_length |= Usb_read_byte()<<8;
        
        if(!user_str)
                return;
        
        const U8 actual_descriptor_size = 2+strlen(user_str)*2;

        if (requested_length > actual_descriptor_size) {
                zlp = ((actual_descriptor_size % EP_CONTROL_LENGTH) == 0);
                requested_length = actual_descriptor_size;
        }
        
        Usb_ack_receive_setup() ;                  //!< clear the receive setup flag

        if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                Usb_enable_stall_handshake();
                return;
        }

        // Output the length
        Usb_write_byte(actual_descriptor_size);
        
        // Output the type
        Usb_write_byte(STRING_DESCRIPTOR);

        requested_length -= 2;
        U8  nb_byte = 2;

        if(!requested_length) {
                Usb_send_control_in();
        }
                
   while((requested_length != 0) && (!Is_usb_receive_out()))
   {
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        break;
                }

      while(requested_length != 0)        //!< Send data until necessary
      {
         if(nb_byte==EP_CONTROL_LENGTH) //!< Check endpoint 0 size
         {
            nb_byte=0;
            break;
         }

         Usb_write_byte(*user_str);
         Usb_write_byte(0);
                 user_str++;
         requested_length -=2;
                 nb_byte+=2;
      }
      Usb_send_control_in();
   }

//bail:
        if(Is_usb_receive_out()) {
                //! abort from Host
                Usb_ack_receive_out();
                return;
        } 

        if(zlp == TRUE) {
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        return;
                }
                Usb_send_control_in();
        }

        usb_endpoint_wait_for_receive_out();
        Usb_ack_receive_out();
}


void usb_get_string_descriptor(U8  string_type) {
        U16 requested_length;
        U8  dummy;
        PGM_P user_str;

        user_str = usb_user_get_string(string_type);

        if(!user_str) {
                usb_get_string_descriptor_sram(string_type);
                return;
        }
        
        dummy = Usb_read_byte();                     //!< don't care of wIndex field
        dummy = Usb_read_byte();
        requested_length = Usb_read_byte();              //!< read wLength
        requested_length |= Usb_read_byte()<<8;
        
        
        const U8 actual_descriptor_size = 2+strlen_P(user_str)*2;

        if (requested_length > actual_descriptor_size) {
                zlp = ((actual_descriptor_size % EP_CONTROL_LENGTH) == 0);
                requested_length = actual_descriptor_size;
        }
        
        Usb_ack_receive_setup() ;                  //!< clear the receive setup flag

        if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                Usb_enable_stall_handshake();
                return;
        }
        U8  nb_byte = 0;

        // Output the length
        if(requested_length) {
                Usb_write_byte(actual_descriptor_size);
                requested_length--;
                nb_byte++;
        }
        
        // Output the type
        if(requested_length) {
                Usb_write_byte(STRING_DESCRIPTOR);
                requested_length--;
                nb_byte++;
        }
        
        if(!requested_length) {
                Usb_send_control_in();
        }
                
        while((requested_length != 0) && (!Is_usb_receive_out()))
        {
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        break;
                }

                while(requested_length != 0)        //!< Send data until necessary
                {
                        if(nb_byte==EP_CONTROL_LENGTH) { //!< Check endpoint 0 size
                                nb_byte=0;
                                break;
                        }

                        Usb_write_byte(pgm_read_byte_near((unsigned int)user_str++));
                        requested_length--;
                        nb_byte++;
                        if(requested_length) {
                                Usb_write_byte(0);
                                requested_length--;
                                nb_byte++;
                        }
                }
                Usb_send_control_in();
        }

//bail:

        if(Is_usb_receive_out()) {
                //! abort from Host
                Usb_ack_receive_out();
                return;
        } 

        if(zlp == TRUE) {
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        return;
                }
                Usb_send_control_in();
        }

        usb_endpoint_wait_for_receive_out();
        Usb_ack_receive_out();
}


//! usb_get_descriptor.
//!
//! This function manages the GET DESCRIPTOR request. The device descriptor,
//! the configuration descriptor and the device qualifier are supported. All
//! other descriptors must be supported by the usb_user_get_descriptor
//! function.
//! Only 1 configuration is supported.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_get_descriptor(void)
{
        U8  LSBwLength, MSBwLength;
        U8  descriptor_type ;
        U8  string_type     ;
        U8  dummy;
        U8  byteswereread;

        zlp             = FALSE;                  /* no zero length packet */
        string_type     = Usb_read_byte();        /* read LSB of wValue    */
        descriptor_type = Usb_read_byte();        /* read MSB of wValue    */
        byteswereread   = 0;

        switch (descriptor_type)
        {
        case DEVICE_DESCRIPTOR:
          data_to_transfer = Usb_get_dev_desc_length(); //!< sizeof (usb_user_device_descriptor);
          pbuffer          = Usb_get_dev_desc_pointer();
          break;
        case CONFIGURATION_DESCRIPTOR:
                data_to_transfer = Usb_get_conf_desc_length(string_type); //!< sizeof (usb_user_configuration_descriptor);
                pbuffer          = Usb_get_conf_desc_pointer(string_type);
          break;
#if 1 
        case STRING_DESCRIPTOR:
          if(string_type!=LANG_ID) {
                usb_get_string_descriptor(string_type);
                return;
          }
#endif
        default:
                dummy = Usb_read_byte();
                dummy = Usb_read_byte();
                LSBwLength = Usb_read_byte();
                MSBwLength = Usb_read_byte();
                byteswereread=1;
                if( usb_user_get_descriptor(descriptor_type, string_type)==FALSE ) {
                    Usb_enable_stall_handshake(); //TODO:is this necessary, Win7 flaky without?
                        Usb_ack_receive_setup();
                        return;
                }
          break;
        }
        if (byteswereread==0) {
                dummy = Usb_read_byte();                     //!< don't care of wIndex field
                dummy = Usb_read_byte();
                LSBwLength = Usb_read_byte();              //!< read wLength
                MSBwLength = Usb_read_byte();
        }

        Usb_ack_receive_setup() ;                  //!< clear the receive setup flag

        if ((LSBwLength > data_to_transfer) || (MSBwLength)) {
                if ((data_to_transfer % EP_CONTROL_LENGTH) == 0) { zlp = TRUE; }
                else { zlp = FALSE; }                   //!< no need of zero length packet

                LSBwLength = data_to_transfer;
                MSBwLength = 0x00;
        } else {
                data_to_transfer = LSBwLength;         //!< send only requested number of data
        }
        
        while((data_to_transfer != 0) && (!Is_usb_receive_out())) {
                U8  nb_byte = 0;
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        break;
                }

        //! Send data until necessary
                while(data_to_transfer != 0) {
//                      if(Is_usb_write_enabled()) //!< Check endpoint 0 size
                        if(nb_byte++==EP_CONTROL_LENGTH) //!< Check endpoint 0 size
                                break;

                        Usb_write_byte(pgm_read_byte_near((unsigned int)pbuffer++));
                        data_to_transfer --;

                }
                Usb_send_control_in();
        }

        if(Is_usb_receive_out()) {
                //! abort from Host
                Usb_ack_receive_out();
                return;
        }
        
        if(zlp == TRUE) {
                if(usb_endpoint_wait_for_read_control_enabled()!=0) {
                        Usb_enable_stall_handshake();
                        return;
                }
                Usb_send_control_in();
        }

        usb_endpoint_wait_for_receive_out();
        Usb_ack_receive_out();
}

//! usb_get_configuration.
//!
//! This function manages the GET CONFIGURATION request. The current
//! configuration number is returned.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_get_configuration(void)
{
   Usb_ack_receive_setup();

   Usb_write_byte(usb_configuration_nb);
   Usb_send_control_in();

   usb_endpoint_wait_for_receive_out();
   Usb_ack_receive_out();
}

//! usb_get_status.
//!
//! This function manages the GET STATUS request. The device, interface or
//! endpoint status is returned.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_get_status(void)
{
U8 wIndex;
U8 dummy;

   dummy    = Usb_read_byte();                 //!< dummy read
   dummy    = Usb_read_byte();                 //!< dummy read
   wIndex = Usb_read_byte();

   switch(bmRequestType)
   {
    case REQUEST_DEVICE_STATUS:    Usb_ack_receive_setup();
                                   Usb_write_byte(DEVICE_STATUS);
                                   break;

    case REQUEST_INTERFACE_STATUS: Usb_ack_receive_setup();
                                   Usb_write_byte(INTERFACE_STATUS);
                                   break;

    case REQUEST_ENDPOINT_STATUS:  Usb_ack_receive_setup();
                                   wIndex = wIndex & MSK_EP_DIR;
                                   Usb_write_byte(endpoint_status[wIndex]);
                                   break;
    default:
                                   Usb_enable_stall_handshake();
                                   Usb_ack_receive_setup();
                                   return;
   }

   Usb_write_byte(0x00);
   Usb_send_control_in();

   usb_endpoint_wait_for_receive_out();
   Usb_ack_receive_out();
}

//! usb_set_feature.
//!
//! This function manages the SET FEATURE request. The USB test modes are
//! supported by this function.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_set_feature(void)
{
U8 wValue;
U8 wIndex;
U8 dummy;

   if (bmRequestType == INTERFACE_TYPE)
   {
      return;
   }
   else if (bmRequestType == ENDPOINT_TYPE)
   {
      wValue = Usb_read_byte();
      dummy    = Usb_read_byte();                //!< dummy read

      if (wValue == FEATURE_ENDPOINT_HALT)
      {
         wIndex = (Usb_read_byte() & MSK_EP_DIR);

         if (wIndex == EP_CONTROL)
         {
            return;
         }

         Usb_select_endpoint(wIndex);
         if(Is_usb_endpoint_enabled())
         {
            Usb_enable_stall_handshake();
            Usb_select_endpoint(EP_CONTROL);
            endpoint_status[wIndex] = 0x01;
            Usb_ack_receive_setup();
            Usb_send_control_in();
         }
         else
         {
            Usb_select_endpoint(EP_CONTROL);
            return;
         }
      }
      else
      {
         return;
      }
   }
}

//! usb_clear_feature.
//!
//! This function manages the SET FEATURE request.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_clear_feature(void)
{
U8 wValue;
U8 wIndex;
U8 dummy;

   if (bmRequestType == ZERO_TYPE)
   {
      return;
   }
   else if (bmRequestType == INTERFACE_TYPE)
   {
      return;
   }
   else if (bmRequestType == ENDPOINT_TYPE)
   {
      wValue = Usb_read_byte();
      dummy  = Usb_read_byte();                //!< dummy read

      if (wValue == FEATURE_ENDPOINT_HALT)
      {
         wIndex = (Usb_read_byte() & MSK_EP_DIR);

         Usb_select_endpoint(wIndex);
         if(Is_usb_endpoint_enabled())
         {
            if(wIndex != EP_CONTROL)
            {
               Usb_disable_stall_handshake();
               Usb_reset_endpoint(wIndex);
               Usb_reset_data_toggle();
            }
            Usb_select_endpoint(EP_CONTROL);
            endpoint_status[wIndex] = 0x00;
            Usb_ack_receive_setup();
            Usb_send_control_in();

         }
         else
         {
            return;
         }
      }
      else
      {
         return;
      }
   }
}

//! usb_get_interface.
//!
//! TThis function manages the GET_INTERFACE request.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_get_interface (void)
{
        // Not yet implemented.
}

//! usb_set_interface.
//!
//! TThis function manages the SET_INTERFACE request.
//!
//! @warning Code:xx bytes (function code length)
//!
void usb_set_interface (void)
{
        U8 alt_setting;
        U8 dummy;
        U8 interface;
        
        alt_setting = Usb_read_byte();
        dummy    = Usb_read_byte();
        interface = Usb_read_byte();
        
        if(usb_user_set_alt_interface(interface, alt_setting)) {
                Usb_ack_receive_setup();
                Usb_send_control_in();                    //!< send a ZLP for STATUS phase
                while(!Is_usb_in_ready());

                usb_endpoint_wait_for_receive_out();
                Usb_ack_receive_out();
        }

}