Uprev libmtp to 1.1.12

src/libusb-glue.c

 /*
  * \file libusb-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-2007 Marcus Meissner
  * Copyright (C) 2007 Ted Bullock
  * Copyright (C) 2008 Chris Bagwell <chris@cnpbagwell.com>
  *
@@ skipping 658 matching lines @@
         LIBMTP_ERROR("Device %d (VID=%04x and PID=%04x) is a %s %s.\n",
                 i,
                 dev->libusb_device->descriptor.idVendor,
                 dev->libusb_device->descriptor.idProduct,
                 mtp_device_table[j].vendor,
                 mtp_device_table[j].product);
         break;
       }
     }
     if (!device_known) {
-      // This device is unknown to the developers
-      LIBMTP_ERROR("Device %d (VID=%04x and PID=%04x) is UNKNOWN.\n",
-              i,
-              dev->libusb_device->descriptor.idVendor,
-              dev->libusb_device->descriptor.idProduct);
-      LIBMTP_ERROR("Please report this VID/PID and the device model to the "
-              "libmtp development team\n");
-      /*
-       * Trying to get iManufacturer or iProduct from the device at this
-       * point would require opening a device handle, that we don't want
-       * to do right now. (Takes time for no good enough reason.)
-       */
+      device_unknown(i,
+                     dev->libusb_device->descriptor.idVendor,
+                     dev->libusb_device->descriptor.idProduct);
     }
     // Save the location on the bus
     retdevs[i].bus_location = dev->bus_location;
     retdevs[i].devnum = dev->libusb_device->devnum;
     i++;
     dev = dev->next;
   }
   *devices = retdevs;
   *numdevs = i;
   free_mtpdevice_list(devlist);
@@ skipping 113 matching lines @@
  * 5. Send remaining bytes. If this happens to be exactly sizeof(endpoint)
  *    then also send a zero-length package.
  *
  * Further there is some special quirks to handle zero reads from the
  * device, since some devices can't do them at all due to shortcomings
  * of the USB slave controller in the device.
  */
 #define CONTEXT_BLOCK_SIZE_1    0x3e00
 #define CONTEXT_BLOCK_SIZE_2  0x200
 #define CONTEXT_BLOCK_SIZE    CONTEXT_BLOCK_SIZE_1+CONTEXT_BLOCK_SIZE_2
+
 static short
 ptp_read_func (
         unsigned long size, PTPDataHandler *handler,void *data,
         unsigned long *readbytes,
         int readzero
 ) {
   PTP_USB *ptp_usb = (PTP_USB *)data;
   unsigned long toread = 0;
   int result = 0;
   unsigned long curread = 0;
-  unsigned long written;
   unsigned char *bytes;
   int expect_terminator_byte = 0;
+  unsigned long usb_inep_maxpacket_size;
+  unsigned long context_block_size_1;
+  unsigned long context_block_size_2;
+  uint16_t ptp_dev_vendor_id = ptp_usb->rawdevice.device_entry.vendor_id;
+
+  //"iRiver" device special handling
+  if (ptp_dev_vendor_id == 0x4102 || ptp_dev_vendor_id == 0x1006) {
+          usb_inep_maxpacket_size = ptp_usb->inep_maxpacket;
+          if (usb_inep_maxpacket_size == 0x400) {
+                  context_block_size_1 = CONTEXT_BLOCK_SIZE_1 - 0x200;
+                  context_block_size_2 = CONTEXT_BLOCK_SIZE_2 + 0x200;
+          }
+          else {
+                  context_block_size_1 = CONTEXT_BLOCK_SIZE_1;
+                  context_block_size_2 = CONTEXT_BLOCK_SIZE_2;
+          }
+  }
 
   // This is the largest block we'll need to read in.
   bytes = malloc(CONTEXT_BLOCK_SIZE);
   while (curread < size) {
 
     LIBMTP_USB_DEBUG("Remaining size to read: 0x%04lx bytes\n", size - curread);
 
     // check equal to condition here
     if (size - curread < CONTEXT_BLOCK_SIZE)
     {
       // this is the last packet
       toread = size - curread;
       // this is equivalent to zero read for these devices
       if (readzero && FLAG_NO_ZERO_READS(ptp_usb) && toread % 64 == 0) {
         toread += 1;
         expect_terminator_byte = 1;
       }
     }
-    else if (curread == 0)
-      // we are first packet, but not last packet
-      toread = CONTEXT_BLOCK_SIZE_1;
-    else if (toread == CONTEXT_BLOCK_SIZE_1)
-      toread = CONTEXT_BLOCK_SIZE_2;
-    else if (toread == CONTEXT_BLOCK_SIZE_2)
-      toread = CONTEXT_BLOCK_SIZE_1;
-    else
-      LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n", 
-             (unsigned int) toread, (unsigned int) (size-curread));
+    else if (ptp_dev_vendor_id == 0x4102 || ptp_dev_vendor_id == 0x1006) {
+            //"iRiver" device special handling
+            if (curread == 0)
+                    // we are first packet, but not last packet
+                    toread = context_block_size_1;
+            else if (toread == context_block_size_1)
+                    toread = context_block_size_2;
+            else if (toread == context_block_size_2)
+                    toread = context_block_size_1;
+            else
+                    LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n",
+                                (unsigned int) toread, (unsigned int) (size-curread));
+
+    } else
+            toread = CONTEXT_BLOCK_SIZE;
 
     LIBMTP_USB_DEBUG("Reading in 0x%04lx bytes\n", toread);
 
     result = USB_BULK_READ(ptp_usb->handle,
                            ptp_usb->inep,
                            (char*) bytes,
                            toread,
                            ptp_usb->timeout);
 
     LIBMTP_USB_DEBUG("Result of read: 0x%04x\n", result);
 
     if (result < 0) {
       return PTP_ERROR_IO;
     }
 
     LIBMTP_USB_DEBUG("<==USB IN\n");
     if (result == 0)
       LIBMTP_USB_DEBUG("Zero Read\n");
     else
       LIBMTP_USB_DATA(bytes, result, 16);
 
     // want to discard extra byte
     if (expect_terminator_byte && result == toread)
     {
       LIBMTP_USB_DEBUG("<==USB IN\nDiscarding extra byte\n");
 
       result--;
     }
 
-    int putfunc_ret = handler->putfunc(NULL, handler->priv, result, bytes, &written);
+    int putfunc_ret = handler->putfunc(NULL, handler->priv, result, bytes);
     if (putfunc_ret != PTP_RC_OK)
       return putfunc_ret;
 
     ptp_usb->current_transfer_complete += result;
     curread += result;
 
     // Increase counters, call callback
     if (ptp_usb->callback_active) {
       if (ptp_usb->current_transfer_complete >= ptp_usb->current_transfer_total) {
         // send last update and disable callback.
@@ skipping 152 matching lines @@
         if (priv->curoff + tocopy > priv->size)
                 tocopy = priv->size - priv->curoff;
         memcpy (data, priv->data + priv->curoff, tocopy);
         priv->curoff += tocopy;
         *gotlen = tocopy;
         return PTP_RC_OK;
 }
 
 static uint16_t
 memory_putfunc(PTPParams* params, void* private,
-               unsigned long sendlen, unsigned char *data,
-               unsigned long *putlen
+               unsigned long sendlen, unsigned char *data
 ) {
         PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)private;
 
         if (priv->curoff + sendlen > priv->size) {
                 priv->data = realloc (priv->data, priv->curoff+sendlen);
                 priv->size = priv->curoff + sendlen;
         }
         memcpy (priv->data + priv->curoff, data, sendlen);
         priv->curoff += sendlen;
-        *putlen = sendlen;
         return PTP_RC_OK;
 }
 
 /* init private struct for receiving data. */
 static uint16_t
 ptp_init_recv_memory_handler(PTPDataHandler *handler) {
         PTPMemHandlerPrivate* priv;
         priv = malloc (sizeof(PTPMemHandlerPrivate));
         handler->priv = priv;
         handler->getfunc = memory_getfunc;
@@ skipping 41 matching lines @@
         PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)handler->priv;
         *data = priv->data;
         *size = priv->size;
         free (priv);
         return PTP_RC_OK;
 }
 
 /* send / receive functions */
 
 uint16_t
-ptp_usb_sendreq (PTPParams* params, PTPContainer* req)
+ptp_usb_sendreq (PTPParams* params, PTPContainer* req, int dataphase)
 {
         uint16_t ret;
         PTPUSBBulkContainer usbreq;
         PTPDataHandler  memhandler;
         unsigned long written = 0;
         unsigned long towrite;
 
         char txt[256];
 
-        (void) ptp_render_opcode (params, req->Code, sizeof(txt), txt);
+        (void) ptp_render_ofc (params, req->Code, sizeof(txt), txt);
         LIBMTP_USB_DEBUG("REQUEST: 0x%04x, %s\n", req->Code, txt);
 
         /* build appropriate USB container */
         usbreq.length=htod32(PTP_USB_BULK_REQ_LEN-
                 (sizeof(uint32_t)*(5-req->Nparam)));
         usbreq.type=htod16(PTP_USB_CONTAINER_COMMAND);
         usbreq.code=htod16(req->Code);
         usbreq.trans_id=htod32(req->Transaction_ID);
         usbreq.payload.params.param1=htod32(req->Param1);
         usbreq.payload.params.param2=htod32(req->Param2);
@@ skipping 18 matching lines @@
                         "PTP: request code 0x%04x sending req wrote only %ld bytes instead of %d",
                         req->Code, written, towrite
                 );
                 ret = PTP_ERROR_IO;
         }
         return ret;
 }
 
 uint16_t
 ptp_usb_senddata (PTPParams* params, PTPContainer* ptp,
-                  unsigned long size, PTPDataHandler *handler
+                  uint64_t size, PTPDataHandler *handler
 ) {
         uint16_t ret;
         int wlen, datawlen;
         unsigned long written;
         PTPUSBBulkContainer usbdata;
-        uint32_t bytes_left_to_transfer;
+        uint64_t bytes_left_to_transfer;
         PTPDataHandler memhandler;
 
 
         LIBMTP_USB_DEBUG("SEND DATA PHASE\n");
 
         /* build appropriate USB container */
         usbdata.length  = htod32(PTP_USB_BULK_HDR_LEN+size);
         usbdata.type    = htod16(PTP_USB_CONTAINER_DATA);
         usbdata.code    = htod16(ptp->Code);
         usbdata.trans_id= htod32(ptp->Transaction_ID);
@@ skipping 41 matching lines @@
                 ret = PTP_ERROR_IO;
         return ret;
 }
 
 static uint16_t ptp_usb_getpacket(PTPParams *params,
                 PTPUSBBulkContainer *packet, unsigned long *rlen)
 {
         PTPDataHandler  memhandler;
         uint16_t        ret;
         unsigned char   *x = NULL;
+        unsigned long packet_size;
+        PTP_USB *ptp_usb = (PTP_USB *) params->data;
+
+        packet_size = ptp_usb->inep_maxpacket;
 
         /* read the header and potentially the first data */
         if (params->response_packet_size > 0) {
                 /* If there is a buffered packet, just use it. */
                 memcpy(packet, params->response_packet, params->response_packet_size);
                 *rlen = params->response_packet_size;
                 free(params->response_packet);
                 params->response_packet = NULL;
                 params->response_packet_size = 0;
                 /* Here this signifies a "virtual read" */
                 return PTP_RC_OK;
         }
         ptp_init_recv_memory_handler (&memhandler);
-        ret = ptp_read_func(PTP_USB_BULK_HS_MAX_PACKET_LEN_READ, &memhandler, params->data, rlen, 0);
+        ret = ptp_read_func(packet_size, &memhandler, params->data, rlen, 0);
         ptp_exit_recv_memory_handler (&memhandler, &x, rlen);
         if (x) {
                 memcpy (packet, x, *rlen);
                 free (x);
         }
         return ret;
 }
 
 uint16_t
 ptp_usb_getdata (PTPParams* params, PTPContainer* ptp, PTPDataHandler *handler)
 {
         uint16_t ret;
         PTPUSBBulkContainer usbdata;
-        unsigned long   written;
         PTP_USB *ptp_usb = (PTP_USB *) params->data;
         int putfunc_ret;
 
         LIBMTP_USB_DEBUG("GET DATA PHASE\n");
 
         memset(&usbdata,0,sizeof(usbdata));
         do {
                 unsigned long len, rlen;
 
                 ret = ptp_usb_getpacket(params, &usbdata, &rlen);
@@ skipping 21 matching lines @@
                                 // getting data. It appears Windows ignores the contents of this
                                 // field entirely.
                                 if (ret < PTP_RC_Undefined || ret > PTP_RC_SpecificationOfDestinationUnsupported) {
                                         libusb_glue_debug (params, "ptp2/ptp_usb_getdata: detected a broken "
                                                    "PTP header, code field insane.");
                                         ret = PTP_ERROR_IO;
                                 }
                                 break;
                         }
                 }
-                if (usbdata.length == 0xffffffffU) {
+                if (rlen == ptp_usb->inep_maxpacket) {
                   /* Copy first part of data to 'data' */
                   putfunc_ret =
                     handler->putfunc(
-                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data,
-                                     &written
+                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data
                                      );
                   if (putfunc_ret != PTP_RC_OK)
                     return putfunc_ret;
 
                   /* stuff data directly to passed data handler */
                   while (1) {
                     unsigned long readdata;
                     uint16_t xret;
 
                     xret = ptp_read_func(
-                                         PTP_USB_BULK_HS_MAX_PACKET_LEN_READ,
+                                         0x20000000,
                                          handler,
                                          params->data,
                                          &readdata,
                                          0
                                          );
                     if (xret != PTP_RC_OK)
                       return xret;
-                    if (readdata < PTP_USB_BULK_HS_MAX_PACKET_LEN_READ)
+                    if (readdata < 0x20000000)
                       break;
                   }
                   return PTP_RC_OK;
                 }
                 if (rlen > dtoh32(usbdata.length)) {
                         /*
                          * Buffer the surplus response packet if it is >=
                          * PTP_USB_BULK_HDR_LEN
                          * (i.e. it is probably an entire package)
                          * else discard it as erroneous surplus data.
@@ skipping 30 matching lines @@
                 len=dtoh32(usbdata.length)-PTP_USB_BULK_HDR_LEN;
 
                 /* autodetect split header/data MTP devices */
                 if (dtoh32(usbdata.length) > 12 && (rlen==12))
                         params->split_header_data = 1;
 
                 /* Copy first part of data to 'data' */
                 putfunc_ret =
                   handler->putfunc(
                                    params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN,
-                                   usbdata.payload.data,
-                                   &written
+                                   usbdata.payload.data
                                    );
                 if (putfunc_ret != PTP_RC_OK)
                   return putfunc_ret;
 
                 if (FLAG_NO_ZERO_READS(ptp_usb) &&
-                    len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ) {
+                    len+PTP_USB_BULK_HDR_LEN == ptp_usb->inep_maxpacket) {
 
                   LIBMTP_USB_DEBUG("Reading in extra terminating byte\n");
 
                   // need to read in extra byte and discard it
                   int result = 0;
                   char byte = 0;
                   result = USB_BULK_READ(ptp_usb->handle,
                                          ptp_usb->inep,
                                          &byte,
                                          1,
                                          ptp_usb->timeout);
 
                   if (result != 1)
-                    LIBMTP_INFO("Could not read in extra byte for PTP_USB_BULK_HS_MAX_PACKET_LEN_READ long file, return value 0x%04x\n", result);
-                } else if (len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ && params->split_header_data == 0) {
+                    LIBMTP_INFO("Could not read in extra byte for %d bytes long file, return value 0x%04x\n", ptp_usb->inep_maxpacket, result);
+                } else if (len+PTP_USB_BULK_HDR_LEN == ptp_usb->inep_maxpacket && params->split_header_data == 0) {
                   int zeroresult = 0;
                   char zerobyte = 0;
 
 
                   LIBMTP_INFO("Reading in zero packet after header\n");
 
                   zeroresult = USB_BULK_READ(ptp_usb->handle,
                                              ptp_usb->inep,
                                              &zerobyte,
                                              0,
@@ skipping 165 matching lines @@
         return ptp_usb_event (params, event, PTP_EVENT_CHECK_FAST);
 }
 
 uint16_t
 ptp_usb_event_wait (PTPParams* params, PTPContainer* event) {
 
         return ptp_usb_event (params, event, PTP_EVENT_CHECK);
 }
 
 uint16_t
+ptp_usb_event_async (PTPParams* params, PTPEventCbFn cb, void *user_data) {
+        /* Unsupported */
+        return PTP_ERROR_CANCEL;
+}
+
+int LIBMTP_Handle_Events_Timeout_Completed(struct timeval *tv, int *completed) {
+        /* Unsupported */
+        return -12;
+}
+
+uint16_t
 ptp_usb_control_cancel_request (PTPParams *params, uint32_t transactionid) {
         PTP_USB *ptp_usb = (PTP_USB *)(params->data);
         int ret;
         unsigned char buffer[6];
 
         htod16a(&buffer[0],PTP_EC_CancelTransaction);
         htod32a(&buffer[2],transactionid);
         ret = usb_control_msg(ptp_usb->handle,
                               USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                               0x64, 0x0000, 0x0000,
@@ skipping 192 matching lines @@
      * Clear any stalled endpoints
      * On misbehaving devices designed for Windows/Mac, quote from:
      * http://www2.one-eyed-alien.net/~mdharm/linux-usb/target_offenses.txt
      * Device does Bad Things(tm) when it gets a GET_STATUS after CLEAR_HALT
      * (...) Windows, when clearing a stall, only sends the CLEAR_HALT command,
      * and presumes that the stall has cleared.  Some devices actually choke
      * if the CLEAR_HALT is followed by a GET_STATUS (used to determine if the
      * STALL is persistant or not).
      */
     clear_stall(ptp_usb);
+#if 0
+    // causes troubles due to a kernel bug in 3.x kernels before/around 3.8
     // Clear halts on any endpoints
     clear_halt(ptp_usb);
     // Added to clear some stuff on the OUT endpoint
     // TODO: is this good on the Mac too?
     // HINT: some devices may need that you comment these two out too.
+#endif
     usb_resetep(ptp_usb->handle, ptp_usb->outep);
     usb_release_interface(ptp_usb->handle, (int) ptp_usb->interface);
   }
   if (FLAG_FORCE_RESET_ON_CLOSE(ptp_usb)) {
     /*
      * Some devices really love to get reset after being
      * disconnected. Again, since Windows never disconnects
      * a device closing behaviour is seldom or never exercised
      * on devices when engineered and often error prone.
      * Reset may help some.
@@ skipping 272 matching lines @@
 {
   return (usb_control_msg(ptp_usb->handle,
                           USB_DP_DTH|USB_RECIP_ENDPOINT,
                           USB_REQ_GET_STATUS,
                           USB_FEATURE_HALT,
                           ep,
                           (char *) status,
                           2,
                           ptp_usb->timeout));
 }