libmtp: Cherrypick upstream commit 15d18e31458be5006eb229df68869df2fff9 to fix device detection for…

src/libusb1-glue.c

 /*
  * \file libusb1-glue.c
  * Low-level USB interface glue towards libusb.
  *
  * Copyright (C) 2005-2007 Richard A. Low <richard@wentnet.com>
  * Copyright (C) 2005-2012 Linus Walleij <triad@df.lth.se>
  * Copyright (C) 2006-2012 Marcus Meissner
  * Copyright (C) 2007 Ted Bullock
  * Copyright (C) 2008 Chris Bagwell <chris@cnpbagwell.com>
  *
@@ skipping 69 matching lines @@
 static const LIBMTP_device_entry_t mtp_device_table[] = {
 /* We include an .h file which is shared between us and libgphoto2 */
 #include "music-players.h"
 };
 static const int mtp_device_table_size = sizeof(mtp_device_table) / sizeof(LIBMTP_device_entry_t);
 
 // Local functions
 static LIBMTP_error_number_t init_usb();
 static void close_usb(PTP_USB* ptp_usb);
 static int find_interface_and_endpoints(libusb_device *dev,
+                                        uint8_t *conf,
                                         uint8_t *interface,
+                                        uint8_t *altsetting,
                                         int* inep,
                                         int* inep_maxpacket,
                                         int* outep,
                                         int* outep_maxpacket,
                                         int* intep);
 static void clear_stall(PTP_USB* ptp_usb);
 static int init_ptp_usb (PTPParams* params, PTP_USB* ptp_usb, libusb_device* dev);
 static short ptp_write_func (unsigned long,PTPDataHandler*,void *data,unsigned long*);
 static short ptp_read_func (unsigned long,PTPDataHandler*,void *data,unsigned long*,int);
 static int usb_get_endpoint_status(PTP_USB* ptp_usb, int ep, uint16_t* status);
@@ skipping 189 matching lines @@
           }
 
           /*
            * Check for Still Image Capture class with PIMA 15740 protocol,
            * also known as PTP
            */
           if (intf->bInterfaceClass == LIBUSB_CLASS_PTP
               && intf->bInterfaceSubClass == 0x01
               && intf->bInterfaceProtocol == 0x01) {
             if (dumpfile != NULL) {
+              fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
               fprintf(dumpfile, "   Found PTP device, check vendor "
                       "extension...\n");
             }
             libusb_close(devh);
             return 1;
           }
 
           /*
            * Next we search for the MTP substring in the interface name.
            * For example : "RIM MS/MTP" should work.
            */
           buf[0] = '\0';
           ret = libusb_get_string_descriptor_ascii(devh,
                                       config->interface[j].altsetting[k].iInterface,
                                       buf,
                                       1024);
           if (ret < 3)
             continue;
           if (strstr((char *) buf, "MTP") != NULL) {
             if (dumpfile != NULL) {
               fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
               fprintf(dumpfile, "   Interface description contains the string \"MTP\"\n");
               fprintf(dumpfile, "   Device recognized as MTP, no further probing.\n");
             }
-            libusb_free_config_descriptor (config);
+            libusb_free_config_descriptor(config);
             libusb_close(devh);
             return 1;
           }
           if (libusb_kernel_driver_active(devh, config->interface[j].altsetting[k].iInterface))
           {
             /*
              * Specifically avoid probing anything else than USB mass storage devices
              * and non-associated drivers in Linux.
              */
             if (config->interface[j].altsetting[k].bInterfaceClass !=
                 LIBUSB_CLASS_MASS_STORAGE) {
               LIBMTP_INFO("avoid probing device using attached kernel interface\n");
-              libusb_free_config_descriptor (config);
+              libusb_free_config_descriptor(config);
               return 0;
             }
           }
         }
-      }
-    }
+     }
+     libusb_free_config_descriptor(config);
+  }
 
   /*
    * Only probe for OS descriptor if the device is vendor specific
    * or one of the interfaces found is.
    */
   if (desc.bDeviceClass == LIBUSB_CLASS_VENDOR_SPEC ||
       found_vendor_spec_interface) {
 
     /* Read the special descriptor */
     ret = libusb_get_descriptor(devh, 0x03, 0xee, buf, sizeof(buf));
@@ skipping 1262 matching lines @@
                               LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
                               0x64, 0x0000, 0x0000,
                               buffer,
                               sizeof(buffer),
                               ptp_usb->timeout);
         if (ret < sizeof(buffer))
                 return PTP_ERROR_IO;
         return PTP_RC_OK;
 }
 
-static int init_ptp_usb (PTPParams* params, PTP_USB* ptp_usb, libusb_device* dev)
+static int init_ptp_usb(PTPParams* params, PTP_USB* ptp_usb, libusb_device* dev)
 {
   libusb_device_handle *device_handle;
   unsigned char buf[255];
   int ret, usbresult;
+  struct libusb_config_descriptor *config;
 
   params->sendreq_func=ptp_usb_sendreq;
   params->senddata_func=ptp_usb_senddata;
   params->getresp_func=ptp_usb_getresp;
   params->getdata_func=ptp_usb_getdata;
   params->cancelreq_func=ptp_usb_control_cancel_request;
   params->data=ptp_usb;
   params->transaction_id=0;
   /*
    * This is hardcoded here since we have no devices whatsoever that are BE.
    * Change this the day we run into our first BE device (if ever).
    */
   params->byteorder = PTP_DL_LE;
 
   ptp_usb->timeout = get_timeout(ptp_usb);
 
   ret = libusb_open(dev, &device_handle);
   if (ret != LIBUSB_SUCCESS) {
-    perror("usb_open()");
+    perror("libusb_open() failed!");
     return -1;
   }
   ptp_usb->handle = device_handle;
+
   /*
    * If this device is known to be wrongfully claimed by other kernel
    * drivers (such as mass storage), then try to unload it to make it
    * accessible from user space.
    */
   if (FLAG_UNLOAD_DRIVER(ptp_usb) &&
-      libusb_kernel_driver_active (device_handle, ptp_usb->interface)
+      libusb_kernel_driver_active(device_handle, ptp_usb->interface)
   ) {
-      if (LIBUSB_SUCCESS != libusb_detach_kernel_driver (device_handle, ptp_usb->interface)) {
-        return -1;
+      if (LIBUSB_SUCCESS != libusb_detach_kernel_driver(device_handle, ptp_usb->interface)) {
+        perror("libusb_detach_kernel_driver() failed, continuing anyway...");
       }
   }
-#ifdef __WIN32__
-  // Only needed on Windows, and cause problems on other platforms.
-  if (libusb_set_configuration(device_handle, dev->config->bConfigurationValue)) {
-    perror("usb_set_configuration()");
+
+  /*
+   * Check if the config is set to something else than what we want
+   * to use. Only set the configuration if we absolutely have to.
+   * Also do not bail out if we fail.
+   */
+  ret = libusb_get_active_config_descriptor(dev, &config);
+  if (ret != LIBUSB_SUCCESS) {
+    perror("libusb_get_active_config_descriptor(1) failed");
     return -1;
   }
-#endif
-  // It seems like on kernel 2.6.31 if we already have it open on another
-  // pthread in our app, we'll get an error if we try to claim it again,
-  // but that error is harmless because our process already claimed the interface
+  if (config->bConfigurationValue != ptp_usb->config) {
+    fprintf(stderr, "desired configuration different from current, trying to set configuration\n");
+    if (libusb_set_configuration(device_handle, ptp_usb->config)) {
+      perror("libusb_set_configuration() failed, continuing anyway...");
+    }
+    /* Re-fetch the config descriptor if we changed */
+    libusb_free_config_descriptor(config);
+    ret = libusb_get_active_config_descriptor(dev, &config);
+    if (ret != LIBUSB_SUCCESS) {
+      perror("libusb_get_active_config_descriptor(2) failed");
+      return -1;
+    }
+  }
+
+  /*
+   * It seems like on kernel 2.6.31 if we already have it open on another
+   * pthread in our app, we'll get an error if we try to claim it again,
+   * but that error is harmless because our process already claimed the interface
+   */
   usbresult = libusb_claim_interface(device_handle, ptp_usb->interface);
 
   if (usbresult != 0)
-    fprintf(stderr, "ignoring usb_claim_interface = %d", usbresult);
+    fprintf(stderr, "ignoring libusb_claim_interface() = %d", usbresult);
 
-  // FIXME : Discovered in the Barry project
-  // kernels >= 2.6.28 don't set the interface the same way as
-  // previous versions did, and the Blackberry gets confused
-  // if it isn't explicitly set
-  // See above, same issue with pthreads means that if this fails it is not
-  // fatal
-  // However, this causes problems on Macs so disable here
+  /*
+   * If the altsetting is set to something different than we want, switch
+   * it.
+   *
+   * FIXME: this seems to cause trouble on the Mac:s so disable it. Retry
+   * this on the Mac now that it only sets this when the altsetting differs.
+   */
 #ifndef __APPLE__
-  usbresult = libusb_set_interface_alt_setting(device_handle, ptp_usb->interface, 0);
-  if (usbresult)
-    fprintf(stderr, "ignoring usb_claim_interface = %d", usbresult);
+#if 0 /* Disable this always, no idea on how to handle it */
+  if (config->interface[].altsetting[].bAlternateSetting !=
+      ptp_usb->altsetting) {
+    fprintf(stderr, "desired altsetting different from current, trying to set altsetting\n");
+    usbresult = libusb_set_interface_alt_setting(device_handle,
+                                                 ptp_usb->interface,
+                                                 ptp_usb->altsetting);
+    if (usbresult != 0)
+      fprintf(stderr, "ignoring libusb_set_interface_alt_setting() = %d\n", usbresult);
+  }
 #endif
+#endif
+
+  libusb_free_config_descriptor(config);
 
   if (FLAG_SWITCH_MODE_BLACKBERRY(ptp_usb)) {
     int ret;
 
     // FIXME : Only for BlackBerry Storm
     // What does it mean? Maybe switch mode...
     // This first control message is absolutely necessary
     usleep(1000);
     ret = libusb_control_transfer(device_handle,
                           LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
@@ skipping 114 matching lines @@
      */
     libusb_reset_device (ptp_usb->handle);
   }
   libusb_close(ptp_usb->handle);
 }
 
 /**
  * Self-explanatory?
  */
 static int find_interface_and_endpoints(libusb_device *dev,
+                                        uint8_t *conf,
                                         uint8_t *interface,
+                                        uint8_t *altsetting,
                                         int* inep,
                                         int* inep_maxpacket,
                                         int* outep,
                                         int *outep_maxpacket,
                                         int* intep)
 {
-  int i, ret;
+  uint8_t i, ret;
   struct libusb_device_descriptor desc;
 
-  ret = libusb_get_device_descriptor (dev, &desc);
-  if (ret != LIBUSB_SUCCESS) return -1;
+  ret = libusb_get_device_descriptor(dev, &desc);
+  if (ret != LIBUSB_SUCCESS)
+    return -1;
 
   // Loop over the device configurations
   for (i = 0; i < desc.bNumConfigurations; i++) {
     uint8_t j;
     struct libusb_config_descriptor *config;
 
-    ret = libusb_get_config_descriptor (dev, i, &config);
+    ret = libusb_get_config_descriptor(dev, i, &config);
+    if (ret != 0)
+      continue;
+
+    *conf = config->bConfigurationValue;
+
     if (ret != LIBUSB_SUCCESS) continue;
     // Loop over each configurations interfaces
     for (j = 0; j < config->bNumInterfaces; j++) {
-      uint8_t k;
+      uint8_t k, l;
       uint8_t no_ep;
       int found_inep = 0;
       int found_outep = 0;
       int found_intep = 0;
       const struct libusb_endpoint_descriptor *ep;
 
-      // MTP devices shall have 3 endpoints, ignore those interfaces
-      // that haven't.
-      no_ep = config->interface[j].altsetting->bNumEndpoints;
-      if (no_ep != 3)
-        continue;
+      // Inspect the altsettings of this interface...
+      for (k = 0; k < config->interface[j].num_altsetting; k++) {
 
-      *interface = config->interface[j].altsetting->bInterfaceNumber;
-      ep = config->interface[j].altsetting->endpoint;
+        // MTP devices shall have 3 endpoints, ignore those interfaces
+        // that haven't.
+        no_ep = config->interface[j].altsetting[k].bNumEndpoints;
+        if (no_ep != 3)
+          continue;
 
-      // Loop over the three endpoints to locate two bulk and
-      // one interrupt endpoint and FAIL if we cannot, and continue.
-      for (k = 0; k < no_ep; k++) {
-        if (ep[k].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) {
-          if ((ep[k].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) ==
-              LIBUSB_ENDPOINT_DIR_MASK) {
-            *inep = ep[k].bEndpointAddress;
-            *inep_maxpacket = ep[k].wMaxPacketSize;
-            found_inep = 1;
-          }
-          if ((ep[k].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == 0) {
-            *outep = ep[k].bEndpointAddress;
-            *outep_maxpacket = ep[k].wMaxPacketSize;
-            found_outep = 1;
-          }
-        } else if (ep[k].bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) {
-          if ((ep[k].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) ==
-              LIBUSB_ENDPOINT_DIR_MASK) {
-            *intep = ep[k].bEndpointAddress;
-            found_intep = 1;
+        *interface = config->interface[j].altsetting[k].bInterfaceNumber;
+        *altsetting = config->interface[j].altsetting[k].bAlternateSetting;
+        ep = config->interface[j].altsetting[k].endpoint;
+
+        // Loop over the three endpoints to locate two bulk and
+        // one interrupt endpoint and FAIL if we cannot, and continue.
+        for (l = 0; l < no_ep; l++) {
+          if (ep[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) {
+            if ((ep[l].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) ==
+                LIBUSB_ENDPOINT_DIR_MASK) {
+              *inep = ep[l].bEndpointAddress;
+              *inep_maxpacket = ep[l].wMaxPacketSize;
+              found_inep = 1;
+            }
+            if ((ep[l].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == 0) {
+              *outep = ep[l].bEndpointAddress;
+              *outep_maxpacket = ep[l].wMaxPacketSize;
+              found_outep = 1;
+            }
+          } else if (ep[l].bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) {
+            if ((ep[l].bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) ==
+                LIBUSB_ENDPOINT_DIR_MASK) {
+              *intep = ep[l].bEndpointAddress;
+              found_intep = 1;
+            }
           }
         }
-      }
-      if (found_inep && found_outep && found_intep) {
-        libusb_free_config_descriptor (config);
-        // We assigned the endpoints so return here.
-        return 0;
-      }
-      // Else loop to next interface/config
-    }
-    libusb_free_config_descriptor (config);
-  }
+        if (found_inep && found_outep && found_intep) {
+          libusb_free_config_descriptor(config);
+          // We assigned the endpoints so return here.
+          return 0;
+        }
+      } // Next altsetting
+    } // Next interface
+    libusb_free_config_descriptor(config);
+  } // Next config
   return -1;
 }
 
 /**
  * This function assigns params and usbinfo given a raw device
  * as input.
  * @param device the device to be assigned.
  * @param usbinfo a pointer to the new usbinfo.
  * @return an error code.
  */
 LIBMTP_error_number_t configure_usb_device(LIBMTP_raw_device_t *device,
                                            PTPParams *params,
                                            void **usbinfo)
 {
   PTP_USB *ptp_usb;
   libusb_device *ldevice;
   uint16_t ret = 0;
   int err, found = 0, i;
   ssize_t nrofdevs;
   libusb_device **devs = NULL;
   struct libusb_device_descriptor desc;
   LIBMTP_error_number_t init_usb_ret;
 
   /* See if we can find this raw device again... */
   init_usb_ret = init_usb();
   if (init_usb_ret != LIBMTP_ERROR_NONE)
     return init_usb_ret;
 
-  nrofdevs = libusb_get_device_list (NULL, &devs);
+  nrofdevs = libusb_get_device_list(NULL, &devs);
   for (i = 0; i < nrofdevs ; i++) {
-    if (libusb_get_bus_number (devs[i]) != device->bus_location)
+    if (libusb_get_bus_number(devs[i]) != device->bus_location)
       continue;
-    if (libusb_get_device_address (devs[i]) != device->devnum)
+    if (libusb_get_device_address(devs[i]) != device->devnum)
       continue;
 
-    ret = libusb_get_device_descriptor (devs[i], &desc);
+    ret = libusb_get_device_descriptor(devs[i], &desc);
     if (ret != LIBUSB_SUCCESS) continue;
 
     if(desc.idVendor  == device->device_entry.vendor_id &&
        desc.idProduct == device->device_entry.product_id ) {
           ldevice = devs[i];
           found = 1;
           break;
     }
   }
   /* Device has gone since detecting raw devices! */
@@ skipping 18 matching lines @@
    * Some devices must have their "OS Descriptor" massaged in order
    * to work.
    */
   if (FLAG_ALWAYS_PROBE_DESCRIPTOR(ptp_usb)) {
     // Massage the device descriptor
     (void) probe_device_descriptor(ldevice, NULL);
   }
 
   /* Assign interface and endpoints to usbinfo... */
   err = find_interface_and_endpoints(ldevice,
+                                     &ptp_usb->config,
                                      &ptp_usb->interface,
+                                     &ptp_usb->altsetting,
                                      &ptp_usb->inep,
                                      &ptp_usb->inep_maxpacket,
                                      &ptp_usb->outep,
                                      &ptp_usb->outep_maxpacket,
                                      &ptp_usb->intep);
 
   if (err) {
     libusb_free_device_list (devs, 0);
     LIBMTP_ERROR("LIBMTP PANIC: Unable to find interface & endpoints of device\n");
     return LIBMTP_ERROR_CONNECTING;
@@ skipping 101 matching lines @@
 {
   return libusb_control_transfer(ptp_usb->handle,
                           LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_ENDPOINT,
                           LIBUSB_REQUEST_GET_STATUS,
                           USB_FEATURE_HALT,
                           ep,
                           (unsigned char *) status,
                           2,
                           ptp_usb->timeout);
 }