usb_enum.c

Go to the documentation of this file.

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

#include "config.h"
#include "conf\conf_usb.h"
#include "lib_mcu\usb\usb_drv.h"
#include "usb_enum.h"
#include "usb_user_configuration.h"
#include "usb_user_enum.h"

//_____ M A C R O S ________________________________________________________


//_____ D E F I N I T I O N ________________________________________________

//_____ P R I V A T E   D E C L A R A T I O N ______________________________
        void    usb_get_descriptor(   void);
static  void    usb_read_request(     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);

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

#ifndef NO_SUPPORT_USB_PING_PONG
   bdata bit   rx_bank;
#endif
static  bit  zlp;
static  _MEM_TYPE_SLOW_ U8   endpoint_status[7];
        _MEM_TYPE_SLOW_ U8   *pbuffer;
        _MEM_TYPE_SLOW_ U8   data_to_transfer;


static  U8   bmRequestType;

_MEM_TYPE_SLOW_ U8   usb_configuration_nb;
extern  bit     usb_connected;
extern  code    S_usb_device_descriptor             usb_user_device_descriptor;
extern  code    S_usb_user_configuration_descriptor usb_user_configuration_descriptor;


void usb_enum_var_init (void)
{
U8 ep_num ;

   for( ep_num=0 ; ep_num<NB_ENDPOINTS ; ep_num++ )
   {
      endpoint_status[ep_num] = 0;
   }
   usb_connected        = FALSE;         
   usb_configuration_nb = 0    ;         
#ifndef NO_SUPPORT_USB_PING_PONG
   rx_bank = 0;
#endif

}


void usb_process_request(void)
{ 
U8 bmRequest;

   Usb_select_endpoint(EP_CONTROL); 

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

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

    case GET_CONFIGURATION: 
         if (0x80 == bmRequestType) { usb_get_configuration(); }
         else                       { usb_user_read_request(bmRequestType, bmRequest); }
         break;

    case SET_ADDRESS:
         if (0x00 == bmRequestType) { usb_set_address(); }
         else                       { usb_user_read_request(bmRequestType, bmRequest); }
         break;

    case SET_CONFIGURATION:
         if (0x00 == bmRequestType) { usb_set_configuration(); }
         else                       { usb_user_read_request(bmRequestType, bmRequest); }
         break;

    case CLEAR_FEATURE:
         if (0x02 >= bmRequestType) { usb_clear_feature(); }
         else                       { usb_user_read_request(bmRequestType, bmRequest); }
         break;

    case SET_FEATURE:
         if (0x02 >= bmRequestType) { usb_set_feature(); }
         else                       { usb_user_read_request(bmRequestType, bmRequest); }
         break;

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

    case GET_INTERFACE:
    case SET_DESCRIPTOR:
    case SET_INTERFACE:
    case SYNCH_FRAME:
    default: 
         if(usb_user_read_request(bmRequestType, bmRequest) == FALSE)
         {
            Usb_enable_stall_handshake();
            Usb_ack_receive_setup();
            return;
         }
         break;
  }
}


void usb_set_address(void)
{
U8 addr;

   addr = Usb_read_byte();
   Usb_ack_receive_setup();

   Usb_send_control_in();                    
   while(!Is_usb_in_ready());                

   Usb_ack_in_ready();              // for Tiger compatibility
   Usb_configure_address(addr);
   Usb_enable_address();
}


void usb_set_configuration( void )
{
U8 configuration_number;

   configuration_number = Usb_read_byte();

   if (configuration_number <= NB_CONFIGURATIONS)
   {
      Usb_ack_receive_setup();
      usb_configuration_nb = configuration_number;
   }
   else
   {
      Usb_enable_stall_handshake();
      Usb_ack_receive_setup();
      return;
   }

   Usb_send_control_in();                    
   while(!Is_usb_in_ready());
   Usb_ack_in_ready();

   usb_user_endpoint_init(usb_configuration_nb);  
   Usb_set_configuration_action();
}


void usb_get_descriptor(void)
{
U16  wLength         ;
U8   descriptor_type ;
U8   string_type     ;
U8   c;                    // New

   zlp             = FALSE;                  /* no zero length packet */
   string_type     = Usb_read_byte();        /* read LSB of wValue    */
   descriptor_type = Usb_read_byte();        /* read MSB of wValue    */
  
   switch (descriptor_type)
   {
    case DEVICE_DESCRIPTOR:
      data_to_transfer = Usb_get_dev_desc_length(); 
      pbuffer          = Usb_get_dev_desc_pointer();
      break;
    case CONFIGURATION_DESCRIPTOR:
      data_to_transfer = Usb_get_conf_desc_length(); 
      pbuffer          = Usb_get_conf_desc_pointer();
      break;
    default:
      if( usb_user_get_descriptor(descriptor_type, string_type)==FALSE )
      {
         Usb_enable_stall_handshake();
         Usb_ack_receive_setup();
         return;
      }
      break;
   }

   ACC = Usb_read_byte();                     
   ACC = Usb_read_byte();
   ((U8*)&wLength)[1] = Usb_read_byte();      
   ((U8*)&wLength)[0] = Usb_read_byte();
   Usb_ack_receive_setup() ;                  
   Usb_set_DIR();                            /* set out on EP0 */

   if (wLength > data_to_transfer)
   {
      if ((data_to_transfer % EP_CONTROL_LENGTH) == 0) { zlp = TRUE; }
      else { zlp = FALSE;}                   
   }
   else
   {
      data_to_transfer = (U8)wLength;         
   }

   while((data_to_transfer != 0) && (!Is_usb_receive_out()))
   {
      if (data_to_transfer > EP_CONTROL_LENGTH) { c = EP_CONTROL_LENGTH; }
                                           else { c = data_to_transfer;  }
      data_to_transfer -= c;
      while ( c!= 0 )
      {
         Usb_write_byte(*pbuffer);
         c--;
         pbuffer ++;
      }
      Usb_send_control_in();
      while((!Is_usb_read_control_enabled()) && (!Is_usb_receive_out()));
      Usb_ack_in_ready();
/*      while(!Is_usb_read_control_enabled());  // snd3 like, not compatible with c5131
      while(data_to_transfer != 0)
      {
         Usb_write_byte(*pbuffer);
         pbuffer ++;
         data_to_transfer --;
      }
      Usb_send_control_in();
*/
   }
  
//   Usb_send_control_in();
  
   if(Is_usb_receive_out())   
   {
      Usb_ack_receive_out();
      return;
   }
   if(zlp == TRUE)
   {
      Usb_send_control_in();
      while((!Is_usb_read_control_enabled()) && (!Is_usb_receive_out()));
      Usb_ack_in_ready();
   }

   while(!Is_usb_receive_out());
   Usb_ack_receive_out();
}


void usb_get_configuration(void)
{
   Usb_ack_receive_setup();
   Usb_set_DIR();                            /* set out on EP0 */

   Usb_write_byte(usb_configuration_nb);
//   Usb_ack_in_ready();
   Usb_send_control_in();
   while(!Is_usb_in_ready());//   while(!Is_usb_read_control_enabled());
   Usb_ack_in_ready();
   while( !Is_usb_receive_out() );
   Usb_ack_receive_out();
}

void usb_get_status(void)
{
U8 wIndex;

   ACC    = Usb_read_byte();                 
   ACC    = Usb_read_byte();                 
   wIndex = Usb_read_byte();

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

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

    case REQUEST_ENDPOINT_STATUS:  Usb_ack_receive_setup();
                                   Usb_set_DIR();
                                   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();
   while(!Is_usb_in_ready());
   Usb_ack_in_ready();
   while( !Is_usb_receive_out() );
   Usb_ack_receive_out();
}


void usb_set_feature(void)
{
U8 wValue;
U8 wIndex;

   if (bmRequestType == INTERFACE_TYPE)
   {
      Usb_enable_stall_handshake();
      Usb_ack_receive_setup();
      return;
   }
   else if (bmRequestType == ENDPOINT_TYPE)
   {
      wValue = Usb_read_byte();
      ACC    = Usb_read_byte();                

      if (wValue == FEATURE_ENDPOINT_HALT)
      {
         wIndex = (Usb_read_byte() & MSK_EP_DIR);
      
         if (wIndex == EP_CONTROL)
         {
            Usb_enable_stall_handshake();
            Usb_ack_receive_setup();
            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_enable_stall_handshake();
            Usb_ack_receive_setup();
            return;
         }
      }
      else
      {
         Usb_enable_stall_handshake();
         Usb_ack_receive_setup();
         return;
      }
   }
}


void usb_clear_feature(void)
{
U8 wValue;
U8 wIndex;

   if (bmRequestType == ZERO_TYPE)
   {
      Usb_enable_stall_handshake();
      Usb_ack_receive_setup();
      return;
   }
   else if (bmRequestType == INTERFACE_TYPE)
   {
      Usb_enable_stall_handshake();
      Usb_ack_receive_setup();
      return;
   }
   else if (bmRequestType == ENDPOINT_TYPE)
   {
      wValue = Usb_read_byte();
      ACC    = Usb_read_byte();                

      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
         {
            Usb_enable_stall_handshake();
            Usb_ack_receive_setup();
            return;
         }
      }
      else
      {
         Usb_enable_stall_handshake();
         Usb_ack_receive_setup();
         return;
      }
   }
}

---