/*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.12 $
*** $Date: 2004/08/23 19:43:19 $
***
*** Description:      
***  This file contains the VUSB32 device specific Echo example code.
***                                                               
**************************************************************************
*END*********************************************************************/

#include "osint.h"
#include "host.h"
#include "device.h"

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;

DEV_GLOBAL_STRUCT dev_global_struct;

uchar USB_IF_ALT[4] = {0, 0, 0, 0};
#define MAX_USB_IF_ALT ((sizeof(USB_IF_ALT)/sizeof(USB_IF_ALT[0]))-1)

void dev_bus_suspend(_usb_device_handle,boolean,uint_8,uint_8_ptr,uint_32);

/*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*--------------------------------------------------------------------*/
static void
ch9GetStatus
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16 index;

//printf(">>ch9GetStatus\n");   
   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 */
            index = swab16(setup_ptr->INDEX) & 0x00FF;
	    index = MIN(index, MAX_USB_IF_ALT);
            if_status = USB_IF_ALT[index];
            /* Send the requested data */
            _usb_device_send_data(handle, 0, &if_status, sizeof(if_status));
            break;
      
         case 0x82:
            /* Endpoint request */
            endpoint = swab16(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;

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

/*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*--------------------------------------------------------------------*/
static void
ch9ClearFeature
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   static uint_8           endpoint;
   uint_16                 usb_status;
   uint_16                 value;

//printf(">>ch9ClearFeature\n");   
   _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;
   }

   if (setup) {
      value = swab16(setup_ptr->VALUE);
      switch (setup_ptr->REQUESTTYPE) {
      
         case 0:
            /* DEVICE */

            if (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);
            }
            break;
         
         case 2:
            /* ENDPOINT */
            if (value != 0) {
               _usb_device_stall_endpoint(handle, 0, 0);
               return;
            }
            endpoint = swab16(setup_ptr->INDEX) & USB_STATUS_ENDPOINT_NUMBER_MASK;
            if (dev_global_struct.funcs->stall_ep)
                dev_global_struct.funcs->stall_ep(handle, endpoint, 0);
            _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;

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


/*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*--------------------------------------------------------------------*/
static void
ch9SetFeature
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16           usb_status;
   uint_16           value;
   uint_8            endpoint;

//printf(">>ch9SetFeature\n");   
   value = swab16(setup_ptr->VALUE);
   if (setup) {
      switch (setup_ptr->REQUESTTYPE) {

         case 0:
            /* DEVICE */
            if (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);
            }
            if (value & 0x04) {
               /* set a_hnp_support */
            }
            if (value & 0x05) {
               /* set a_alt_hnp_support */
            }
            break;
            
         case 2:
            /* ENDPOINT */
            if (value != 0) {
               _usb_device_stall_endpoint(handle, 0, 0);
               return;
            }
            endpoint = swab16(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);
            if (dev_global_struct.funcs->stall_ep)
                dev_global_struct.funcs->stall_ep(handle, endpoint, 1);
            break;
            
         default:
            _usb_device_stall_endpoint(handle, 0, 0);
            return;

      }
      
      /* status phase */
      _usb_device_send_data(handle, 0, 0, 0);
   } else {
      if (value & 0x03) {
         /* sleep callback should be installed for HNP capable Dual role device */
         _usb_device_register_service(handle, USB_SERVICE_SLEEP, dev_bus_suspend);
      }
   }
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9SetAddress
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   static uint_8 new_address;

//printf(">>ch9SetAddress setup %d addr 0x%x\n", setup, swab16(setup_ptr->VALUE));

   if (setup) {
      new_address = swab16(setup_ptr->VALUE) & 0xFF;
      /* 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);
//printf(">>ch9SetAddress state = ADDRESS with addr 0x%x\n", new_address);   
      dev_global_struct.funcs->initeps(handle);
   }
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9GetDescription
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
//printf(">>ch9GetDescription\n");   
   dev_global_struct.funcs->get_desc(handle, setup, setup_ptr);
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9SetDescription
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
//printf(">>ch9SetDescription\n");   
   _usb_device_stall_endpoint(handle, 0, 0);
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9GetConfig
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16 current_config;
//printf(">>ch9GetConfig\n");   
   /* 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);
   }
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9SetConfig
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16 usb_state;
   uint_16 value;
//printf(">>ch9SetConfig\n");   
   
   _usb_device_get_status(handle, USB_STATUS_DEVICE_STATE, &usb_state);
   
   if ((usb_state == USB_STATE_CONFIG) || (usb_state == USB_STATE_ADDRESS)) {
      if (setup) {
	 value = swab16(setup_ptr->VALUE) & 0xFF;
//printf(">>ch9SetConfig new value 0x%x\n", value);   
         /* 0 indicates return to unconfigured state */
         if (value == 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;
         }

         /*
         ** 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 != value) {
            /* Reconfigure endpoints here */
            switch (value) {
         
               default:
                  break;
            }
            _usb_device_set_status(handle, USB_STATUS_CURRENT_CONFIG, value);
            _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
               USB_STATE_CONFIG);
            /* status phase */      
            _usb_device_send_data(handle, 0, 0, 0);
            return;
         }
         _usb_device_set_status(handle, USB_STATUS_DEVICE_STATE,
            USB_STATE_CONFIG);
         /* ack */
         _usb_device_send_data(handle, 0, 0, 0);
      }
   } else {
      _usb_device_stall_endpoint(handle, 0, 0);
   }
   return;
}

/*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*--------------------------------------------------------------------*/
static void 
ch9GetInterface
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16 usb_state;
   uint_16 index, length;

//printf(">>ch9GetInterface\n");   
   
   _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;
   }

   if (setup) {
      index = swab16(setup_ptr->INDEX) & 0x00FF;
      index = MIN(index, MAX_USB_IF_ALT);
      length = MIN(swab16(setup_ptr->LENGTH), sizeof(uint_8));
//printf(">>ch9GetInterface index %d, length %d\n", index, length);   
      _usb_device_send_data(handle, 0, &USB_IF_ALT[index], length);
      /* status phase */      
      _usb_device_recv_data(handle, 0, 0, 0);
   }
   return;
}

/*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*--------------------------------------------------------------------*/
static void
ch9SetInterface
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
   uint_16 index, value;

//printf(">>ch9SetInterface\n");   
   if (setup) {
      if (setup_ptr->REQUESTTYPE != 0x01) {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      }

      /*
      ** 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
      */
      index = swab16(setup_ptr->INDEX) & 0x00FF;
      index = MIN(index, MAX_USB_IF_ALT);
      value = swab16(setup_ptr->VALUE) & 0x00FF;
      if (USB_IF_ALT[index] != value)
      {
         USB_IF_ALT[index] = value;
         /* Reconfigure endpoints here. */
         
      }

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

/*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*--------------------------------------------------------------------*/
static void
ch9SynchFrame
   (
      /* USB handle */
      _usb_device_handle handle,
      
      /* Is it a Setup phase? */
      boolean setup,
            
      /* The setup packet pointer */
      SETUP_STRUCT_PTR setup_ptr
   )
{
	uint_16 index, length;

//printf(">>ch9SynchFrame\n");   
   
   if (setup) {
      if (setup_ptr->REQUESTTYPE != 0x02) {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      }

      index = swab16(setup_ptr->INDEX) & 0x00FF;
      if (index >= dev_global_struct.num_ifcs)
      {
         _usb_device_stall_endpoint(handle, 0, 0);
         return;
      }

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

/*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*--------------------------------------------------------------------*/
static void 
ch9Vendor
   (
      _usb_device_handle handle,
      boolean setup,
      SETUP_STRUCT_PTR setup_ptr
   )
{
//printf(">>ch9Vendor\n");   
	dev_global_struct.funcs->vendor(handle, setup, setup_ptr);
	return;
}

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : service_ep0
* Returned Value : None
* Comments       :
*     Called upon a completed endpoint 0 (USB 1.1 Chapter 9) transfer
* 
*END*--------------------------------------------------------------------*/
static void 
dev_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      
   )
{

//printf(">>dev_service_ep0: setup %d, dir %d, len %d\n", setup, direction, length);   
   if (setup) {
      _usb_device_read_setup_data(handle, 0, (uchar_ptr)&local_setup_packet);
   }
   
//printf(">>dev_service_ep0: setup packet REQT 0x%x, REQ 0x%x\n", local_setup_packet.REQUESTTYPE, local_setup_packet.REQUEST);
   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;

         }
         
         break;

      case 0x20:
         /* class specific request */
         /* 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;
         
   }
   
}

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : reset_ep0
* Returned Value : None
* Comments       :
*     Called upon a bus reset event.  Initialises the control endpoint.
* 
*END*--------------------------------------------------------------------*/
static void
dev_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      
   )
{
	dev_global_struct.FIRST_SOF = TRUE;
//printf(">>dev_reset_ep0\n");
	/* Call device specific reset_ep0 */
	dev_global_struct.funcs->reset_ep0(handle, setup, direction, buffer, length);
	if (dev_global_struct.dev_state != USB_DEV_STATE_ATTACHED)
	    dev_global_struct.dev_state = USB_DEV_STATE_RESET;
	return;
}


/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : bus_suspend
* Returned Value : None
* Comments       :
*     Called upon a SLEEP interrupt.
* 
*END*--------------------------------------------------------------------*/
void
dev_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      
   )
{
   return;
}

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : bus_sof
* Returned Value : None
* Comments       :
*     Called upon a Start of Frame Interrupt.
* 
*END*--------------------------------------------------------------------*/
static void
dev_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      
   )
{
    /* XXX this is useless overhead most of the time */
    /* XXX figure out a way to unregister this when we don't need it */
    if (dev_global_struct.FIRST_SOF) {
        _usb_device_register_service(handle, USB_SERVICE_SLEEP, dev_bus_suspend);
	dev_global_struct.FIRST_SOF = FALSE;
    }

}

/*
 * USB device state machine
 */
void
_usb_device_state_machine(_usb_device_handle handle)
{
#if 0
#ifdef	USB_ECHO_DEVICE
extern void echo_device_poll(_usb_device_handle);

	echo_device_poll(handle);
#endif
#endif
	return;
}

/*
 * Initialize the generic USB device layer.
 */
void
__usb_arc_device_setup(int which, _usb_device_handle *handlep)
{
#ifdef	USB_ECHO_DEVICE
extern void echo_device_init(_usb_device_handle);
extern struct usbdevfuncs echo_dev_funcs;
#endif
#ifdef	USB_RDBS_DEVICE
extern void rdbs_device_init(_usb_device_handle);
extern struct usbdevfuncs rdbs_dev_funcs;
#endif
	uint_8 error;
printf("arc_device_setup%d at ticks = %d\n", which, osGetCount());

	if (_usb_device_init(which, 0, handlep, 16)) {
		printf("_usb_device_init fails\n");
		return;
	}
   
	error = _usb_device_register_service(*handlep, USB_SERVICE_EP0, 
		dev_service_ep0);
	if (error != USB_OK) {
		printf("USB Device EP0 Registration failed: %x\n", error);
	}
   
	error = _usb_device_register_service(*handlep, USB_SERVICE_BUS_RESET, 
		dev_reset_ep0);
	if (error != USB_OK) {
		printf("USB Device RESET Registration failed: %x\n", error);
	}
   
	error = _usb_device_register_service(*handlep, USB_SERVICE_SOF,
		dev_bus_sof);
	if (error != USB_OK) {
		printf("USB Device SOF Registration failed: %x\n", error);
	}

	/*
	 * Device-specific initialization routines
	 */
#ifdef	USB_ECHO_DEVICE
	echo_device_init(*handlep);
	dev_global_struct.funcs = &echo_dev_funcs;
#endif
#ifdef	USB_RDBS_DEVICE
	rdbs_device_init(*handlep);
	dev_global_struct.funcs = &rdbs_dev_funcs;
#endif
	dev_global_struct.dev_state = USB_DEV_STATE_INIT;
	return;
}