/********************************************************************\

  Name:         musbstd.c
  Created by:   Konstantin Olchanski, Stefan Ritt

  Contents:     Midas USB access

  $Id$

\********************************************************************/

#include <stdio.h>
#include <assert.h>
#include <musbstd.h>

#ifdef _MSC_VER                 // Windows includes

#include <windows.h>
#include <conio.h>
#include <winioctl.h>

#include <setupapi.h>
#include <initguid.h>           /* Required for GUID definition */

// link with SetupAPI.Lib.
#pragma comment (lib, "setupapi.lib")

// disable "deprecated" warning
#pragma warning( disable: 4996)

// {CBEB3FB1-AE9F-471c-9016-9B6AC6DCD323}
DEFINE_GUID(GUID_CLASS_MSCB_BULK, 0xcbeb3fb1, 0xae9f, 0x471c, 0x90, 0x16, 0x9b, 0x6a, 0xc6, 0xdc, 0xd3, 0x23);

#elif defined(OS_DARWIN)

#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <fcntl.h>

#include <assert.h>
#include <mach/mach.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/usb/IOUSBLib.h>

#elif defined(OS_LINUX)         // Linux includes

#include <unistd.h>
#include <string.h>
#include <stdlib.h>

#endif

#ifdef HAVE_LIBUSB
#include <errno.h>
#include <usb.h>
#endif

#ifdef HAVE_LIBUSB10
#include <errno.h>
#include <libusb-1.0/libusb.h>
#endif

#if !defined(HAVE_LIBUSB) && !defined(HAVE_LIBUSB10)
#ifdef OS_DARWIN

IOReturn darwin_configure_device(MUSB_INTERFACE* musb)
{
   IOReturn status;
   io_iterator_t iter;
   io_service_t service;
   IOCFPlugInInterface **plugin;
   SInt32 score;
   IOUSBInterfaceInterface **uinterface;
   UInt8 numend;

   IOUSBDeviceInterface **device = (IOUSBDeviceInterface **)musb->device;

   status = (*device)->SetConfiguration(device, musb->usb_configuration);
   assert(status == kIOReturnSuccess);

   IOUSBFindInterfaceRequest request;

   request.bInterfaceClass = kIOUSBFindInterfaceDontCare;
   request.bInterfaceSubClass = kIOUSBFindInterfaceDontCare;
   request.bInterfaceProtocol = kIOUSBFindInterfaceDontCare;
   request.bAlternateSetting = kIOUSBFindInterfaceDontCare;
   
   status = (*device)->CreateInterfaceIterator(device, &request, &iter);
   assert(status == kIOReturnSuccess);
  
   while ((service = IOIteratorNext(iter))) {
      int i;
      status =
        IOCreatePlugInInterfaceForService(service, kIOUSBInterfaceUserClientTypeID,
                                          kIOCFPlugInInterfaceID, &plugin, &score);
      assert(status == kIOReturnSuccess);
      
      status =
        (*plugin)->QueryInterface(plugin, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID),
                                  (void *) &uinterface);
      assert(status == kIOReturnSuccess);
      
      
      status = (*uinterface)->USBInterfaceOpen(uinterface);
      fprintf(stderr, "musb_open: USBInterfaceOpen status 0x%x\n", status);
      assert(status == kIOReturnSuccess);
      
      status = (*uinterface)->GetNumEndpoints(uinterface, &numend);
      assert(status == kIOReturnSuccess);
      
      fprintf(stderr, "musb_open: endpoints: %d\n", numend);
      
      for (i=1; i<=numend; i++) {
         status = (*uinterface)->GetPipeStatus(uinterface, i);
         fprintf(stderr, "musb_open: pipe %d status: 0x%x\n", i, status);
      
#if 0
         status = (*uinterface)->ClearPipeStall(uinterface, i);
         fprintf(stderr, "musb_open: pipe %d ClearPipeStall() status: 0x%x\n", i, status);
         status = (*uinterface)->ResetPipe(uinterface, i);
         fprintf(stderr, "musb_open: pipe %d ResetPipe() status: 0x%x\n", i, status);
         status = (*uinterface)->AbortPipe(uinterface, i);
         fprintf(stderr, "musb_open: pipe %d AbortPipe() status: 0x%x\n", i, status);
#endif
      }

      musb->interface = uinterface;
      return kIOReturnSuccess;
   }

   assert(!"Should never be reached!");
   return -1;
}
    
#endif

#endif

int musb_open(MUSB_INTERFACE **musb_interface, int vendor, int product, int instance, int configuration, int usbinterface)
{
#if defined(HAVE_LIBUSB)
   
   struct usb_bus *bus;
   struct usb_device *dev;
   int count = 0;
   
   usb_init();
   usb_find_busses();
   usb_find_devices();
   usb_set_debug(3);
   
   for (bus = usb_get_busses(); bus; bus = bus->next)
      for (dev = bus->devices; dev; dev = dev->next)
         if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
            if (count == instance) {
               int status;
               usb_dev_handle *udev;

               udev = usb_open(dev);
               if (!udev) {
                  fprintf(stderr, "musb_open: usb_open() error\n");
                  return MUSB_ACCESS_ERROR;
               }

               status = usb_set_configuration(udev, configuration);
               if (status < 0) {
                  fprintf(stderr, "musb_open: usb_set_configuration() error %d (%s)\n", status,
                     strerror(-status));
                  fprintf(stderr,
                     "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it: please check permissions on \"/proc/bus/usb/%s/%s\" and \"/dev/bus/usb/%s/%s\"\n",
                     vendor, product, instance, bus->dirname, dev->filename, bus->dirname, dev->filename);
                  return MUSB_ACCESS_ERROR;
               }

               /* see if we have write access */
               status = usb_claim_interface(udev, usbinterface);
               if (status < 0) {
                  fprintf(stderr, "musb_open: usb_claim_interface() error %d (%s)\n", status,
                     strerror(-status));

#ifdef _MSC_VER
                  fprintf(stderr,
                     "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it:\nDevice is probably used by another program\n",
                     vendor, product, instance);
#else
                  fprintf(stderr,
                     "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it: please check permissions on \"/proc/bus/usb/%s/%s\"\n",
                     vendor, product, instance, bus->dirname, dev->filename);
#endif

                  return MUSB_ACCESS_ERROR;
               }

               *musb_interface = (MUSB_INTERFACE*)calloc(1, sizeof(MUSB_INTERFACE));
               (*musb_interface)->dev = udev;
               (*musb_interface)->usb_configuration = configuration;
               (*musb_interface)->usb_interface     = usbinterface;
               return MUSB_SUCCESS;
            }

            count++;
         }
   
   return MUSB_NOT_FOUND;
   
#elif defined(HAVE_LIBUSB10)
   
   static int first_call = 1;

   libusb_device **dev_list;
   libusb_device_handle *dev;
   struct libusb_device_descriptor desc;
   
   int status, i, n;
   int count = 0;
   
   if (first_call) {
      first_call = 0;
      libusb_init(NULL);
      // libusb_set_debug(NULL, 3);
   }
      
   n = libusb_get_device_list(NULL, &dev_list);
   
   for (i=0 ; i<n ; i++) {
      status = libusb_get_device_descriptor(dev_list[i], &desc);
      if (desc.idVendor == vendor && desc.idProduct == product) {
         if (count == instance) {
            status = libusb_open(dev_list[i], &dev);
            if (status < 0) {
               fprintf(stderr, "musb_open: libusb_open() error %d\n", status);
               return MUSB_ACCESS_ERROR;
            }

            status = libusb_set_configuration(dev, configuration);
            if (status < 0) {
               fprintf(stderr, "musb_open: usb_set_configuration() error %d\n", status);
               fprintf(stderr,
                       "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it: please check permissions on \"/proc/bus/usb/%d/%d\" and \"/dev/bus/usb/%d/%d\"\n",
                       vendor, product, instance, libusb_get_bus_number(dev_list[i]), libusb_get_device_address(dev_list[i]), libusb_get_bus_number(dev_list[i]), libusb_get_device_address(dev_list[i]));
               return MUSB_ACCESS_ERROR;
            }
            
            /* see if we have write access */
            status = libusb_claim_interface(dev, usbinterface);
            if (status < 0) {
               fprintf(stderr, "musb_open: libusb_claim_interface() error %d\n", status);
               
#ifdef _MSC_VER
               fprintf(stderr,
                       "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it:\nDevice is probably used by another program\n",
                       vendor, product, instance);
#else
               fprintf(stderr,
                       "musb_open: Found USB device 0x%04x:0x%04x instance %d, but cannot initialize it: please check permissions on \"/proc/bus/usb/%d/%d\"\n",
                       vendor, product, instance, libusb_get_bus_number(dev_list[i]), libusb_get_device_address(dev_list[i]));
#endif
               
               return MUSB_ACCESS_ERROR;
            }

            *musb_interface = (MUSB_INTERFACE*)calloc(1, sizeof(MUSB_INTERFACE));
            (*musb_interface)->dev = dev;
            (*musb_interface)->usb_configuration = configuration;
            (*musb_interface)->usb_interface     = usbinterface;
            return MUSB_SUCCESS;

         }
         count++;
      }
   }
   
   libusb_free_device_list(dev_list, 1);
   
   return MUSB_NOT_FOUND;
     
#elif defined(OS_DARWIN)
   
   kern_return_t status;
   io_iterator_t iter;
   io_service_t service;
   IOCFPlugInInterface **plugin;
   SInt32 score;
   IOUSBDeviceInterface **device;
   UInt16 xvendor, xproduct;
   int count = 0;

   *musb_interface = calloc(1, sizeof(MUSB_INTERFACE));
   
   status = IORegistryCreateIterator(kIOMasterPortDefault, kIOUSBPlane, kIORegistryIterateRecursively, &iter);
   assert(status == kIOReturnSuccess);

   while ((service = IOIteratorNext(iter))) {
      status =
          IOCreatePlugInInterfaceForService(service, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID,
                                            &plugin, &score);
      assert(status == kIOReturnSuccess);

      status = IOObjectRelease(service);
      assert(status == kIOReturnSuccess);

      status =
          (*plugin)->QueryInterface(plugin, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (void *) &device);
      assert(status == kIOReturnSuccess);

      status = (*plugin)->Release(plugin);

      status = (*device)->GetDeviceVendor(device, &xvendor);
      assert(status == kIOReturnSuccess);
      status = (*device)->GetDeviceProduct(device, &xproduct);
      assert(status == kIOReturnSuccess);

      //fprintf(stderr, "musb_open: Found USB device: vendor 0x%04x, product 0x%04x\n", xvendor, xproduct);

      if (xvendor == vendor && xproduct == product) {
         if (count == instance) {

            fprintf(stderr, "musb_open: Found USB device: vendor 0x%04x, product 0x%04x, instance %d\n", xvendor, xproduct, instance);

            status = (*device)->USBDeviceOpen(device);
            fprintf(stderr, "musb_open: USBDeviceOpen status 0x%x\n", status);

            assert(status == kIOReturnSuccess);

            (*musb_interface)->usb_configuration = configuration;
            (*musb_interface)->usb_interface     = usbinterface;
            (*musb_interface)->device = (void*)device;
            (*musb_interface)->interface = NULL;

            status = darwin_configure_device(*musb_interface);

            if (status == kIOReturnSuccess)
               return MUSB_SUCCESS;

            fprintf(stderr, "musb_open: USB device exists, but configuration fails!");
            return MUSB_NOT_FOUND;
         }

         count++;
      }

      (*device)->Release(device);
   }

   return MUSB_NOT_FOUND;
#elif defined(_MSC_VER)
   GUID guid;
   HDEVINFO hDevInfoList;
   SP_DEVICE_INTERFACE_DATA deviceInfoData;
   PSP_DEVICE_INTERFACE_DETAIL_DATA functionClassDeviceData;
   ULONG predictedLength, requiredLength;
   int status;
   char device_name[256], str[256];

   *musb_interface = (MUSB_INTERFACE *)calloc(1, sizeof(MUSB_INTERFACE));

   guid = GUID_CLASS_MSCB_BULK;

   // Retrieve device list for GUID that has been specified.
   hDevInfoList = SetupDiGetClassDevs(&guid, NULL, NULL, (DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));

   status = FALSE;
   if (hDevInfoList != NULL) {

      // Clear data structure
      memset(&deviceInfoData, 0, sizeof(deviceInfoData));
      deviceInfoData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

      // retrieves a context structure for a device interface of a device information set.
      if (SetupDiEnumDeviceInterfaces(hDevInfoList, 0, &guid, instance, &deviceInfoData)) {
         // Must get the detailed information in two steps
         // First get the length of the detailed information and allocate the buffer
         // retrieves detailed information about a specified device interface.
         functionClassDeviceData = NULL;

         predictedLength = requiredLength = 0;

         SetupDiGetDeviceInterfaceDetail(hDevInfoList, &deviceInfoData, NULL,   // Not yet allocated
                                         0,     // Set output buffer length to zero
                                         &requiredLength,       // Find out memory requirement
                                         NULL);

         predictedLength = requiredLength;
         functionClassDeviceData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) malloc(predictedLength);
         functionClassDeviceData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

         // Second, get the detailed information
         if (SetupDiGetDeviceInterfaceDetail(hDevInfoList,
                                             &deviceInfoData, functionClassDeviceData,
                                             predictedLength, &requiredLength, NULL)) {

            // Save the device name for subsequent pipe open calls
            strcpy(device_name, functionClassDeviceData->DevicePath);
            free(functionClassDeviceData);

            // Signal device found
            status = TRUE;
         } else
            free(functionClassDeviceData);
      }
   }
   // SetupDiDestroyDeviceInfoList() destroys a device information set
   // and frees all associated memory.
   SetupDiDestroyDeviceInfoList(hDevInfoList);

   if (status) {

      // Get the read handle
      sprintf(str, "%s\\PIPE00", device_name);
      (*musb_interface)->rhandle = CreateFile(str,
                                    GENERIC_WRITE | GENERIC_READ,
                                    FILE_SHARE_WRITE | FILE_SHARE_READ, NULL,
                                    OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

      if ((*musb_interface)->rhandle == INVALID_HANDLE_VALUE)
         return MUSB_ACCESS_ERROR;

      // Get the write handle
      sprintf(str, "%s\\PIPE01", device_name);
      (*musb_interface)->whandle = CreateFile(str,
                                    GENERIC_WRITE | GENERIC_READ,
                                    FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

      if ((*musb_interface)->whandle == INVALID_HANDLE_VALUE)
         return MUSB_ACCESS_ERROR;

      return MUSB_SUCCESS;
   } 
     
   return MUSB_NOT_FOUND;
#endif
}

int musb_set_altinterface(MUSB_INTERFACE *musb_interface, int index)
{
#if defined (HAVE_LIBUSB)
   int status;

   status = usb_set_altinterface(musb_interface->dev, index);
   if (status < 0)
      fprintf(stderr, "musb_set_altinterface: usb_set_altinterface() error %d\n", status);

   return status;
#else
   return -1;
#endif
}

int musb_close(MUSB_INTERFACE *musb_interface)
{
#if defined(HAVE_LIBUSB)

   int status;
   status = usb_release_interface(musb_interface->dev, musb_interface->usb_interface);
   if (status < 0)
      fprintf(stderr, "musb_close: usb_release_interface() error %d\n", status);
   
#ifdef OS_LINUX   // linux wants a reset, otherwise the device cannot be accessed next time
   musb_reset(musb_interface);
#endif

   status = usb_close(musb_interface->dev);
   if (status < 0)
      fprintf(stderr, "musb_close: usb_close() error %d\n", status);
   
#elif defined(HAVE_LIBUSB10)   

   int status;
   status = libusb_release_interface(musb_interface->dev, musb_interface->usb_interface);
   if (status < 0)
      fprintf(stderr, "musb_close: libusb_release_interface() error %d\n", status);
   
#ifdef OS_LINUX   // linux wants a reset, otherwise the device cannot be accessed next time
   musb_reset(musb_interface);
#endif
   
   libusb_close(musb_interface->dev);

#elif defined(OS_DARWIN)

   IOReturn status;
   IOUSBInterfaceInterface **interface = (IOUSBInterfaceInterface **)musb_interface->interface;

   status = (*interface)->USBInterfaceClose(interface);
   if (status != kIOReturnSuccess)
      fprintf(stderr, "musb_close: USBInterfaceClose() status %d 0x%x\n", status, status);

   status = (*interface)->Release(interface);
   if (status != kIOReturnSuccess)
      fprintf(stderr, "musb_close: USB Interface Release() status %d 0x%x\n", status, status);

   IOUSBDeviceInterface **device = (IOUSBDeviceInterface**)musb_interface->device;
   status = (*device)->USBDeviceClose(device);
   if (status != kIOReturnSuccess)
      fprintf(stderr, "musb_close: USBDeviceClose() status %d 0x%x\n", status, status);

   status = (*device)->Release(device);
   if (status != kIOReturnSuccess)
      fprintf(stderr, "musb_close: USB Device Release() status %d 0x%x\n", status, status);

#elif defined(_MSC_VER)

   CloseHandle(musb_interface->rhandle);
   CloseHandle(musb_interface->whandle);

#else
   assert(!"musb_close() is not implemented");
#endif

   /* free memory allocated in musb_open() */
   free(musb_interface);
   return 0;
}

int musb_write(MUSB_INTERFACE *musb_interface, int endpoint, const void *buf, int count, int timeout)
{
   int n_written;

#if defined(HAVE_LIBUSB)
   n_written = usb_bulk_write(musb_interface->dev, endpoint, (char*)buf, count, timeout);
   if (n_written != count) {
      fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)\n", count, n_written, errno, strerror(errno));
   }
#elif defined(HAVE_LIBUSB10)
   int status = libusb_bulk_transfer(musb_interface->dev, endpoint, (unsigned char*)buf, count, &n_written, timeout);
   if (n_written != count) {
      fprintf(stderr, "musb_write: requested %d, wrote %d, errno %d (%s)\n", count, n_written, status, strerror(status));
   }
#elif defined(OS_DARWIN)
   IOReturn status;
   IOUSBInterfaceInterface182 **interface = (IOUSBInterfaceInterface182 **)musb_interface->interface;
   status = (*interface)->WritePipeTO(interface, endpoint, buf, count, 0, timeout);
   if (status != 0) {
      fprintf(stderr, "musb_write: WritePipe() status %d 0x%x\n", status, status);
      return -1;
   }
   n_written = count;
#elif defined(_MSC_VER)
   WriteFile(musb_interface->whandle, buf, count, &n_written, NULL);
#endif

   //fprintf(stderr, "musb_write(ep %d, %d bytes) (%s) returns %d\n", endpoint, count, buf, n_written); 

   return n_written;
}

int musb_read(MUSB_INTERFACE *musb_interface, int endpoint, void *buf, int count, int timeout)
{
   int n_read = 0;

#if defined(HAVE_LIBUSB)

   n_read = usb_bulk_read(musb_interface->dev, endpoint | 0x80, (char*)buf, count, timeout);
   /* errors should be handled in upper layer ....
   if (n_read <= 0) {
      fprintf(stderr, "musb_read: requested %d, read %d, errno %d (%s)\n", count, n_read, errno, strerror(errno));
   }
   */

#elif defined(HAVE_LIBUSB10)
   
   libusb_bulk_transfer(musb_interface->dev, endpoint | 0x80, (unsigned char*)buf, count, &n_read, timeout);
   /* errors should be handled in upper layer ....
    if (n_read <= 0) {
    fprintf(stderr, "musb_read: requested %d, read %d, errno %d (%s)\n", count, n_read, status, strerror(status));
    }
    */
   
#elif defined(OS_DARWIN)

   UInt32 xcount = count;
   IOReturn status;
   IOUSBInterfaceInterface182 **interface = (IOUSBInterfaceInterface182 **)musb_interface->interface;

   status = (*interface)->ReadPipeTO(interface, endpoint, buf, &xcount, 0, timeout);
   if (status != kIOReturnSuccess) {
      fprintf(stderr, "musb_read: requested %d, read %d, ReadPipe() status %d 0x%x (%s)\n", count, n_read, status, status, strerror(status));
      return -1;
   }

   n_read = xcount;

#elif defined(_MSC_VER)

   OVERLAPPED overlapped;
   int status;

   memset(&overlapped, 0, sizeof(overlapped));
   overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   n_read = 0;

   status = ReadFile(musb_interface->rhandle, buf, count, &n_read, &overlapped);
   
   if (!status) {

      status = GetLastError();
      if (status != ERROR_IO_PENDING)
         return 0;

      /* wait for completion with timeout */
      status = WaitForSingleObject(overlapped.hEvent, timeout);
      if (status == WAIT_TIMEOUT)
         CancelIo(musb_interface->rhandle);
      else
         GetOverlappedResult(musb_interface->rhandle, &overlapped, &n_read, FALSE);
   }

   CloseHandle(overlapped.hEvent);

#endif

   //fprintf(stderr, "musb_read(ep %d, %d bytes) returns %d (%s)\n", endpoint, count, n_read, buf); 

   return n_read;
}

int musb_reset(MUSB_INTERFACE *musb_interface)
{
#if defined(HAVE_LIBUSB)

   /* Causes re-enumeration: After calling usb_reset, the device will need 
      to re-enumerate and thusly, requires you to find the new device and 
      open a new handle. The handle used to call usb_reset will no longer work */

   int status;
   status = usb_reset(musb_interface->dev);
   if (status < 0)
      fprintf(stderr, "musb_reset: usb_reset() status %d\n", status);

#elif defined(HAVE_LIBUSB10)
   
   int status;
   status = libusb_reset_device(musb_interface->dev);
   if (status < 0)
      fprintf(stderr, "musb_reset: usb_reset() status %d\n", status);
   
#elif defined(OS_DARWIN)

   IOReturn status;
   IOUSBDeviceInterface **device = (IOUSBDeviceInterface**)musb_interface->device;

   status = (*device)->ResetDevice(device);
   fprintf(stderr, "musb_reset: ResetDevice() status 0x%x\n", status);

   status = darwin_configure_device(musb_interface);
   assert(status == kIOReturnSuccess);

#elif defined(_MSC_VER)

#define IOCTL_BULKUSB_RESET_DEVICE          CTL_CODE(FILE_DEVICE_UNKNOWN,     \
                                                     1,                       \
                                                     METHOD_BUFFERED,         \
                                                     FILE_ANY_ACCESS)
#define IOCTL_BULKUSB_RESET_PIPE            CTL_CODE(FILE_DEVICE_UNKNOWN,     \
                                                     2,                       \
                                                     METHOD_BUFFERED,         \
                                                     FILE_ANY_ACCESS)

   int status, n_bytes;

   status =  DeviceIoControl(musb_interface->rhandle,
                  IOCTL_BULKUSB_RESET_DEVICE,
                  NULL, 0, NULL, 0, &n_bytes, NULL);
   status =  DeviceIoControl(musb_interface->whandle,
                  IOCTL_BULKUSB_RESET_DEVICE,
                  NULL, 0, NULL, 0, &n_bytes, NULL);
   status =  DeviceIoControl(musb_interface->rhandle,
                  IOCTL_BULKUSB_RESET_PIPE,
                  NULL, 0, NULL, 0, &n_bytes, NULL);
   status =  DeviceIoControl(musb_interface->whandle,
                  IOCTL_BULKUSB_RESET_PIPE,
                  NULL, 0, NULL, 0, &n_bytes, NULL);
   return status;

#endif
   return 0;
}

int musb_get_device(MUSB_INTERFACE *usb_interface)
{
#ifdef HAVE_LIBUSB
   struct usb_device_descriptor d;
   usb_get_descriptor(usb_interface->dev, USB_DT_DEVICE, 0, &d, sizeof(d));
   return d.bcdDevice;
#elif HAVE_LIBUSB10
   struct libusb_device_descriptor d;
   libusb_get_descriptor(usb_interface->dev, LIBUSB_DT_DEVICE, 0, (unsigned char *)&d, sizeof(d));
   return d.bcdDevice;
#else
   return 0;
#endif
}

/* end */