1 /*
2 * \file libusb-glue.c
3 * Low-level USB interface glue towards libusb.
4 *
5 * Copyright (C) 2005-2007 Richard A. Low <richard@wentnet.com>
6 * Copyright (C) 2005-2008 Linus Walleij <triad@df.lth.se>
7 * Copyright (C) 2006-2007 Marcus Meissner
8 * Copyright (C) 2007 Ted Bullock
9 * Copyright (C) 2008 Chris Bagwell <chris@cnpbagwell.com>
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the
23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 * Boston, MA 02111-1307, USA.
25 *
26 * Created by Richard Low on 24/12/2005. (as mtp-utils.c)
27 * Modified by Linus Walleij 2006-03-06
28 * (Notice that Anglo-Saxons use little-endian dates and Swedes
29 * use big-endian dates.)
30 *
31 */
32 #include "config.h"
33 #include "libmtp.h"
34 #include "libusb-glue.h"
35 #include "device-flags.h"
36 #include "util.h"
37 #include "ptp.h"
38
39 #include <errno.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <usb.h>
44
45 #include "ptp-pack.c"
46
47 /* Aha, older libusb does not have USB_CLASS_PTP */
48 #ifndef USB_CLASS_PTP
49 #define USB_CLASS_PTP 6
50 #endif
51
52 /* libusb dosn't have misc class defined */
53 #ifndef USB_CLASS_MISC
54 #define USB_CLASS_MISC 0xEF
55 #endif
56
57 /* To enable debug prints for USB stuff, switch on this */
58 //#define ENABLE_USB_BULK_DEBUG
59
60 /* Default USB timeout length. This can be overridden as needed
61 * but should start with a reasonable value so most common
62 * requests can be completed. The original value of 4000 was
63 * not long enough for large file transfer. Also, players can
64 * spend a bit of time collecting data. Higher values also
65 * make connecting/disconnecting more reliable.
66 */
67 #define USB_TIMEOUT_DEFAULT 10000
68
69 /* USB control message data phase direction */
70 #ifndef USB_DP_HTD
71 #define USB_DP_HTD (0x00 << 7) /* host to device */
72 #endif
73 #ifndef USB_DP_DTH
74 #define USB_DP_DTH (0x01 << 7) /* device to host */
75 #endif
76
77 /* USB Feature selector HALT */
78 #ifndef USB_FEATURE_HALT
79 #define USB_FEATURE_HALT 0x00
80 #endif
81
82 /* Internal data types */
83 struct mtpdevice_list_struct {
84 struct usb_device *libusb_device;
85 PTPParams *params;
86 PTP_USB *ptp_usb;
87 uint32_t bus_location;
88 struct mtpdevice_list_struct *next;
89 };
90 typedef struct mtpdevice_list_struct mtpdevice_list_t;
91
92 static const LIBMTP_device_entry_t mtp_device_table[] = {
93 /* We include an .h file which is shared between us and libgphoto2 */
94 #include "music-players.h"
95 };
96 static const int mtp_device_table_size = sizeof(mtp_device_table) / sizeof(LIBMTP_device_entry_t);
97
98 // Local functions
99 static struct usb_bus* init_usb();
100 static void close_usb(PTP_USB* ptp_usb);
101 static void find_interface_and_endpoints(struct usb_device *dev,
102 uint8_t *interface,
103 int* inep,
104 int* inep_maxpacket,
105 int* outep,
106 int* outep_maxpacket,
107 int* intep);
108 static void clear_stall(PTP_USB* ptp_usb);
109 static int init_ptp_usb (PTPParams* params, PTP_USB* ptp_usb, struct usb_device* dev);
110 static short ptp_write_func (unsigned long,PTPDataHandler*,void *data,unsigned long*);
111 static short ptp_read_func (unsigned long,PTPDataHandler*,void *data,unsigned long*,int);
112 static int usb_clear_stall_feature(PTP_USB* ptp_usb, int ep);
113 static int usb_get_endpoint_status(PTP_USB* ptp_usb, int ep, uint16_t* status);
114
115 /**
116 * Get a list of the supported USB devices.
117 *
118 * The developers depend on users of this library to constantly
119 * add in to the list of supported devices. What we need is the
120 * device name, USB Vendor ID (VID) and USB Product ID (PID).
121 * put this into a bug ticket at the project homepage, please.
122 * The VID/PID is used to let e.g. udev lift the device to
123 * console userspace access when it's plugged in.
124 *
125 * @param devices a pointer to a pointer that will hold a device
126 * list after the call to this function, if it was
127 * successful.
128 * @param numdevs a pointer to an integer that will hold the number
129 * of devices in the device list if the call was successful.
130 * @return 0 if the list was successfull retrieved, any other
131 * value means failure.
132 */
LIBMTP_Get_Supported_Devices_List(LIBMTP_device_entry_t ** const devices,int * const numdevs)133 int LIBMTP_Get_Supported_Devices_List(LIBMTP_device_entry_t ** const devices, int * const numdevs)
134 {
135 *devices = (LIBMTP_device_entry_t *) &mtp_device_table;
136 *numdevs = mtp_device_table_size;
137 return 0;
138 }
139
140
init_usb()141 static struct usb_bus* init_usb()
142 {
143 usb_init();
144 usb_find_busses();
145 usb_find_devices();
146 return (usb_get_busses());
147 }
148
149 /**
150 * Small recursive function to append a new usb_device to the linked list of
151 * USB MTP devices
152 * @param devlist dynamic linked list of pointers to usb devices with MTP
153 * properties, to be extended with new device.
154 * @param newdevice the new device to add.
155 * @param bus_location bus for this device.
156 * @return an extended array or NULL on failure.
157 */
append_to_mtpdevice_list(mtpdevice_list_t * devlist,struct usb_device * newdevice,uint32_t bus_location)158 static mtpdevice_list_t *append_to_mtpdevice_list(mtpdevice_list_t *devlist,
159 struct usb_device *newdevice,
160 uint32_t bus_location)
161 {
162 mtpdevice_list_t *new_list_entry;
163
164 new_list_entry = (mtpdevice_list_t *) malloc(sizeof(mtpdevice_list_t));
165 if (new_list_entry == NULL) {
166 return NULL;
167 }
168 // Fill in USB device, if we *HAVE* to make a copy of the device do it here.
169 new_list_entry->libusb_device = newdevice;
170 new_list_entry->bus_location = bus_location;
171 new_list_entry->next = NULL;
172
173 if (devlist == NULL) {
174 return new_list_entry;
175 } else {
176 mtpdevice_list_t *tmp = devlist;
177 while (tmp->next != NULL) {
178 tmp = tmp->next;
179 }
180 tmp->next = new_list_entry;
181 }
182 return devlist;
183 }
184
185 /**
186 * Small recursive function to free dynamic memory allocated to the linked list
187 * of USB MTP devices
188 * @param devlist dynamic linked list of pointers to usb devices with MTP
189 * properties.
190 * @return nothing
191 */
free_mtpdevice_list(mtpdevice_list_t * devlist)192 static void free_mtpdevice_list(mtpdevice_list_t *devlist)
193 {
194 mtpdevice_list_t *tmplist = devlist;
195
196 if (devlist == NULL)
197 return;
198 while (tmplist != NULL) {
199 mtpdevice_list_t *tmp = tmplist;
200 tmplist = tmplist->next;
201 // Do not free() the fields (ptp_usb, params)! These are used elsewhere.
202 free(tmp);
203 }
204 return;
205 }
206
207 /* Comment out this define to enable the original, more aggressive probing. */
208 #define MILD_MTP_PROBING
209
210 #ifdef MILD_MTP_PROBING
211 /**
212 * This checks if a device has an interface with MTP description.
213 *
214 * @param dev a device struct from libusb.
215 * @param dumpfile set to non-NULL to make the descriptors dump out
216 * to this file in human-readable hex so we can scruitinze them.
217 * @return 1 if the device is MTP compliant, 0 if not.
218 */
probe_device_descriptor(struct usb_device * dev,FILE * dumpfile)219 static int probe_device_descriptor(struct usb_device *dev, FILE *dumpfile)
220 {
221 usb_dev_handle *devh;
222 unsigned char buf[1024];
223 int i;
224 int ret;
225
226 /*
227 * Don't examine devices that are not likely to
228 * contain any MTP interface, update this the day
229 * you find some weird combination...
230 */
231 if (!(dev->descriptor.bDeviceClass == USB_CLASS_PER_INTERFACE ||
232 dev->descriptor.bDeviceClass == USB_CLASS_COMM ||
233 dev->descriptor.bDeviceClass == USB_CLASS_PTP ||
234 dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC ||
235 dev->descriptor.bDeviceClass == USB_CLASS_MISC)) {
236 return 0;
237 }
238
239 /* Attempt to open Device on this port */
240 devh = usb_open(dev);
241 if (devh == NULL) {
242 /* Could not open this device */
243 return 0;
244 }
245
246 /*
247 * This sometimes crashes on the j for loop below
248 * I think it is because config is NULL yet
249 * dev->descriptor.bNumConfigurations > 0
250 * this check should stop this
251 */
252 if (dev->config) {
253 /*
254 * Loop over the interfaces, and check for string "MTP"
255 * in the descriptions.
256 */
257
258 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
259 uint8_t j;
260
261 for (j = 0; j < dev->config[i].bNumInterfaces; j++) {
262 int k;
263 for (k = 0; k < dev->config[i].interface[j].num_altsetting; k++) {
264 /* Current interface descriptor */
265 struct usb_interface_descriptor *intf =
266 &dev->config[i].interface[j].altsetting[k];
267
268 buf[0] = '\0';
269 ret = usb_get_string_simple(devh,
270 dev->config[i].interface[j].altsetting[k].iInterface,
271 (char *) buf,
272 1024);
273
274 if (ret < 3)
275 continue;
276 if (strcmp((char *) buf, "MTP") == 0) {
277 if (dumpfile != NULL) {
278 fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
279 fprintf(dumpfile, " Interface description contains the string \"MTP\"\n");
280 fprintf(dumpfile, " Device recognized as MTP, no further probing.\n");
281 }
282 usb_close(devh);
283 return 1;
284 }
285 }
286 }
287 }
288 }
289
290 usb_close(devh);
291 return 0;
292 }
293
294 #else /* MILD_MTP_PROBING */
295 /**
296 * This checks if a device has an MTP descriptor. The descriptor was
297 * elaborated about in gPhoto bug 1482084, and some official documentation
298 * with no strings attached was published by Microsoft at
299 * http://www.microsoft.com/whdc/system/bus/USB/USBFAQ_intermed.mspx#E3HAC
300 *
301 * @param dev a device struct from libusb.
302 * @param dumpfile set to non-NULL to make the descriptors dump out
303 * to this file in human-readable hex so we can scruitinze them.
304 * @return 1 if the device is MTP compliant, 0 if not.
305 */
probe_device_descriptor(struct usb_device * dev,FILE * dumpfile)306 static int probe_device_descriptor(struct usb_device *dev, FILE *dumpfile)
307 {
308 usb_dev_handle *devh;
309 unsigned char buf[1024], cmd;
310 int i;
311 int ret;
312
313 /* Don't examine hubs (no point in that) */
314 if (dev->descriptor.bDeviceClass == USB_CLASS_HUB) {
315 return 0;
316 }
317
318 /* Attempt to open Device on this port */
319 devh = usb_open(dev);
320 if (devh == NULL) {
321 /* Could not open this device */
322 return 0;
323 }
324
325 /*
326 * This sometimes crashes on the j for loop below
327 * I think it is because config is NULL yet
328 * dev->descriptor.bNumConfigurations > 0
329 * this check should stop this
330 */
331 if (dev->config) {
332 /*
333 * Loop over the device configurations and interfaces. Nokia MTP-capable
334 * handsets (possibly others) typically have the string "MTP" in their
335 * MTP interface descriptions, that's how they can be detected, before
336 * we try the more esoteric "OS descriptors" (below).
337 */
338 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
339 uint8_t j;
340
341 for (j = 0; j < dev->config[i].bNumInterfaces; j++) {
342 int k;
343 for (k = 0; k < dev->config[i].interface[j].num_altsetting; k++) {
344 /* Current interface descriptor */
345 struct usb_interface_descriptor *intf =
346 &dev->config[i].interface[j].altsetting[k];
347
348
349 buf[0] = '\0';
350 ret = usb_get_string_simple(devh,
351 dev->config[i].interface[j].altsetting[k].iInterface,
352 (char *) buf,
353 1024);
354 if (ret < 3)
355 continue;
356 if (strcmp((char *) buf, "MTP") == 0) {
357 if (dumpfile != NULL) {
358 fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
359 fprintf(dumpfile, " Interface description contains the string \"MTP\"\n");
360 fprintf(dumpfile, " Device recognized as MTP, no further probing.\n");
361 }
362 usb_close(devh);
363 return 1;
364 }
365 #ifdef LIBUSB_HAS_GET_DRIVER_NP
366 {
367 /*
368 * Specifically avoid probing anything else than USB mass storage devices
369 * and non-associated drivers in Linux.
370 */
371 char devname[0x10];
372
373 devname[0] = '\0';
374 ret = usb_get_driver_np(devh,
375 dev->config[i].interface[j].altsetting[k].iInterface,
376 devname,
377 sizeof(devname));
378 if (devname[0] != '\0' && strcmp(devname, "usb-storage")) {
379 printf("avoid probing device using kernel interface \"%s\"\n", devname);
380 return 0;
381 }
382 }
383 #endif
384 }
385 }
386 }
387 } else {
388 if (dev->descriptor.bNumConfigurations)
389 printf("dev->config is NULL in probe_device_descriptor yet dev->descriptor.bNumConfigurations > 0\n");
390 }
391
392 /* Read the special descriptor */
393 ret = usb_get_descriptor(devh, 0x03, 0xee, buf, sizeof(buf));
394
395 // Dump it, if requested
396 if (dumpfile != NULL && ret > 0) {
397 fprintf(dumpfile, "Microsoft device descriptor 0xee:\n");
398 data_dump_ascii(dumpfile, buf, ret, 16);
399 }
400
401 /* Check if descriptor length is at least 10 bytes */
402 if (ret < 10) {
403 usb_close(devh);
404 return 0;
405 }
406
407 /* Check if this device has a Microsoft Descriptor */
408 if (!((buf[2] == 'M') && (buf[4] == 'S') &&
409 (buf[6] == 'F') && (buf[8] == 'T'))) {
410 usb_close(devh);
411 return 0;
412 }
413
414 /* Check if device responds to control message 1 or if there is an error */
415 cmd = buf[16];
416 ret = usb_control_msg (devh,
417 USB_ENDPOINT_IN|USB_RECIP_DEVICE|USB_TYPE_VENDOR,
418 cmd,
419 0,
420 4,
421 (char *) buf,
422 sizeof(buf),
423 USB_TIMEOUT_DEFAULT);
424
425 // Dump it, if requested
426 if (dumpfile != NULL && ret > 0) {
427 fprintf(dumpfile, "Microsoft device response to control message 1, CMD 0x%02x:\n", cmd);
428 data_dump_ascii(dumpfile, buf, ret, 16);
429 }
430
431 /* If this is true, the device either isn't MTP or there was an error */
432 if (ret <= 0x15) {
433 /* TODO: If there was an error, flag it and let the user know somehow */
434 /* if(ret == -1) {} */
435 usb_close(devh);
436 return 0;
437 }
438
439 /* Check if device is MTP or if it is something like a USB Mass Storage
440 device with Janus DRM support */
441 if ((buf[0x12] != 'M') || (buf[0x13] != 'T') || (buf[0x14] != 'P')) {
442 usb_close(devh);
443 return 0;
444 }
445
446 /* After this point we are probably dealing with an MTP device */
447
448 /* Check if device responds to control message 2 or if there is an error*/
449 ret = usb_control_msg (devh,
450 USB_ENDPOINT_IN|USB_RECIP_DEVICE|USB_TYPE_VENDOR,
451 cmd,
452 0,
453 5,
454 (char *) buf,
455 sizeof(buf),
456 USB_TIMEOUT_DEFAULT);
457
458 // Dump it, if requested
459 if (dumpfile != NULL && ret > 0) {
460 fprintf(dumpfile, "Microsoft device response to control message 2, CMD 0x%02x:\n", cmd);
461 data_dump_ascii(dumpfile, buf, ret, 16);
462 }
463
464 /* If this is true, the device errored against control message 2 */
465 if (ret == -1) {
466 /* TODO: Implement callback function to let managing program know there
467 was a problem, along with description of the problem */
468 fprintf(stderr, "Potential MTP Device with VendorID:%04x and "
469 "ProductID:%04x encountered an error responding to "
470 "control message 2.\n"
471 "Problems may arrise but continuing\n",
472 dev->descriptor.idVendor, dev->descriptor.idProduct);
473 } else if (ret <= 0x15) {
474 /* TODO: Implement callback function to let managing program know there
475 was a problem, along with description of the problem */
476 fprintf(stderr, "Potential MTP Device with VendorID:%04x and "
477 "ProductID:%04x responded to control message 2 with a "
478 "response that was too short. Problems may arrise but "
479 "continuing\n",
480 dev->descriptor.idVendor, dev->descriptor.idProduct);
481 } else if ((buf[0x12] != 'M') || (buf[0x13] != 'T') || (buf[0x14] != 'P')) {
482 /* TODO: Implement callback function to let managing program know there
483 was a problem, along with description of the problem */
484 fprintf(stderr, "Potential MTP Device with VendorID:%04x and "
485 "ProductID:%04x encountered an error responding to "
486 "control message 2\n"
487 "Problems may arrise but continuing\n",
488 dev->descriptor.idVendor, dev->descriptor.idProduct);
489 }
490
491 /* Close the USB device handle */
492 usb_close(devh);
493 return 1;
494 }
495 #endif /* MILD_MTP_PROBING */
496
497 /**
498 * This function scans through the connected usb devices on a machine and
499 * if they match known Vendor and Product identifiers appends them to the
500 * dynamic array mtp_device_list. Be sure to call
501 * <code>free_mtpdevice_list(mtp_device_list)</code> when you are done
502 * with it, assuming it is not NULL.
503 * @param mtp_device_list dynamic array of pointers to usb devices with MTP
504 * properties (if this list is not empty, new entries will be appended
505 * to the list).
506 * @return LIBMTP_ERROR_NONE implies that devices have been found, scan the list
507 * appropriately. LIBMTP_ERROR_NO_DEVICE_ATTACHED implies that no
508 * devices have been found.
509 */
get_mtp_usb_device_list(mtpdevice_list_t ** mtp_device_list)510 static LIBMTP_error_number_t get_mtp_usb_device_list(mtpdevice_list_t ** mtp_device_list)
511 {
512 struct usb_bus *bus = init_usb();
513 for (; bus != NULL; bus = bus->next) {
514 struct usb_device *dev = bus->devices;
515 for (; dev != NULL; dev = dev->next) {
516 if (dev->descriptor.bDeviceClass != USB_CLASS_HUB) {
517 int i;
518 int found = 0;
519
520 // First check if we know about the device already.
521 // Devices well known to us will not have their descriptors
522 // probed, it caused problems with some devices.
523 for(i = 0; i < mtp_device_table_size; i++) {
524 if(dev->descriptor.idVendor == mtp_device_table[i].vendor_id &&
525 dev->descriptor.idProduct == mtp_device_table[i].product_id) {
526 /* Append this usb device to the MTP device list */
527 *mtp_device_list = append_to_mtpdevice_list(*mtp_device_list,
528 dev,
529 bus->location);
530 found = 1;
531 break;
532 }
533 }
534 // If we didn't know it, try probing the "OS Descriptor".
535 if (!found) {
536 if (probe_device_descriptor(dev, NULL)) {
537 /* Append this usb device to the MTP USB Device List */
538 *mtp_device_list = append_to_mtpdevice_list(*mtp_device_list,
539 dev,
540 bus->location);
541 }
542 /*
543 * By thomas_-_s: Also append devices that are no MTP but PTP devices
544 * if this is commented out.
545 */
546 /*
547 else {
548 // Check whether the device is no USB hub but a PTP.
549 if ( dev->config != NULL &&dev->config->interface->altsetting->bInterfaceClass == USB_CLASS_PTP && dev->descriptor.bDeviceClass != USB_CLASS_HUB ) {
550 *mtp_device_list = append_to_mtpdevice_list(*mtp_device_list, dev, bus->location);
551 }
552 }
553 */
554 }
555 }
556 }
557 }
558
559 /* If nothing was found we end up here. */
560 if(*mtp_device_list == NULL) {
561 return LIBMTP_ERROR_NO_DEVICE_ATTACHED;
562 }
563 return LIBMTP_ERROR_NONE;
564 }
565
566 /**
567 * Detect the raw MTP device descriptors and return a list of
568 * of the devices found.
569 *
570 * @param devices a pointer to a variable that will hold
571 * the list of raw devices found. This may be NULL
572 * on return if the number of detected devices is zero.
573 * The user shall simply <code>free()</code> this
574 * variable when finished with the raw devices,
575 * in order to release memory.
576 * @param numdevs a pointer to an integer that will hold
577 * the number of devices in the list. This may
578 * be 0.
579 * @return 0 if successful, any other value means failure.
580 */
LIBMTP_Detect_Raw_Devices(LIBMTP_raw_device_t ** devices,int * numdevs)581 LIBMTP_error_number_t LIBMTP_Detect_Raw_Devices(LIBMTP_raw_device_t ** devices,
582 int * numdevs)
583 {
584 mtpdevice_list_t *devlist = NULL;
585 mtpdevice_list_t *dev;
586 LIBMTP_error_number_t ret;
587 LIBMTP_raw_device_t *retdevs;
588 int devs = 0;
589 int i, j;
590
591 ret = get_mtp_usb_device_list(&devlist);
592 if (ret == LIBMTP_ERROR_NO_DEVICE_ATTACHED) {
593 *devices = NULL;
594 *numdevs = 0;
595 return ret;
596 } else if (ret != LIBMTP_ERROR_NONE) {
597 fprintf(stderr, "LIBMTP PANIC: get_mtp_usb_device_list() "
598 "error code: %d on line %d\n", ret, __LINE__);
599 return ret;
600 }
601
602 // Get list size
603 dev = devlist;
604 while (dev != NULL) {
605 devs++;
606 dev = dev->next;
607 }
608 if (devs == 0) {
609 *devices = NULL;
610 *numdevs = 0;
611 return LIBMTP_ERROR_NONE;
612 }
613 // Conjure a device list
614 retdevs = (LIBMTP_raw_device_t *) malloc(sizeof(LIBMTP_raw_device_t) * devs);
615 if (retdevs == NULL) {
616 // Out of memory
617 *devices = NULL;
618 *numdevs = 0;
619 return LIBMTP_ERROR_MEMORY_ALLOCATION;
620 }
621 dev = devlist;
622 i = 0;
623 while (dev != NULL) {
624 int device_known = 0;
625
626 // Assign default device info
627 retdevs[i].device_entry.vendor = NULL;
628 retdevs[i].device_entry.vendor_id = dev->libusb_device->descriptor.idVendor;
629 retdevs[i].device_entry.product = NULL;
630 retdevs[i].device_entry.product_id = dev->libusb_device->descriptor.idProduct;
631 retdevs[i].device_entry.device_flags = 0x00000000U;
632 // See if we can locate some additional vendor info and device flags
633 for(j = 0; j < mtp_device_table_size; j++) {
634 if(dev->libusb_device->descriptor.idVendor == mtp_device_table[j].vendor_id &&
635 dev->libusb_device->descriptor.idProduct == mtp_device_table[j].product_id) {
636 device_known = 1;
637 retdevs[i].device_entry.vendor = mtp_device_table[j].vendor;
638 retdevs[i].device_entry.product = mtp_device_table[j].product;
639 retdevs[i].device_entry.device_flags = mtp_device_table[j].device_flags;
640
641 #ifdef _AFT_BUILD
642 // Disable the following features for all devices.
643 retdevs[i].device_entry.device_flags |= DEVICE_FLAG_BROKEN_MTPGETOBJPROPLIST|
644 DEVICE_FLAG_BROKEN_SET_OBJECT_PROPLIST|
645 DEVICE_FLAG_BROKEN_SEND_OBJECT_PROPLIST;
646 #endif
647
648 #ifdef ENABLE_USB_BULK_DEBUG
649 // This device is known to the developers
650 fprintf(stderr, "Device %d (VID=%04x and PID=%04x) is a %s %s.\n",
651 i,
652 dev->libusb_device->descriptor.idVendor,
653 dev->libusb_device->descriptor.idProduct,
654 mtp_device_table[j].vendor,
655 mtp_device_table[j].product);
656 #endif
657 break;
658 }
659 }
660 if (!device_known) {
661 // This device is unknown to the developers
662 fprintf(stderr, "Device %d (VID=%04x and PID=%04x) is UNKNOWN.\n",
663 i,
664 dev->libusb_device->descriptor.idVendor,
665 dev->libusb_device->descriptor.idProduct);
666 fprintf(stderr, "Please report this VID/PID and the device model to the "
667 "libmtp development team\n");
668 /*
669 * Trying to get iManufacturer or iProduct from the device at this
670 * point would require opening a device handle, that we don't want
671 * to do right now. (Takes time for no good enough reason.)
672 */
673 }
674 // Save the location on the bus
675 retdevs[i].bus_location = dev->bus_location;
676 retdevs[i].devnum = dev->libusb_device->devnum;
677 i++;
678 dev = dev->next;
679 }
680 *devices = retdevs;
681 *numdevs = i;
682 free_mtpdevice_list(devlist);
683 return LIBMTP_ERROR_NONE;
684 }
685
686 /**
687 * This routine just dumps out low-level
688 * USB information about the current device.
689 * @param ptp_usb the USB device to get information from.
690 */
dump_usbinfo(PTP_USB * ptp_usb)691 void dump_usbinfo(PTP_USB *ptp_usb)
692 {
693 struct usb_device *dev;
694
695 #ifdef LIBUSB_HAS_GET_DRIVER_NP
696 char devname[0x10];
697 int res;
698
699 devname[0] = '\0';
700 res = usb_get_driver_np(ptp_usb->handle, (int) ptp_usb->interface, devname, sizeof(devname));
701 if (devname[0] != '\0') {
702 printf(" Using kernel interface \"%s\"\n", devname);
703 }
704 #endif
705 dev = usb_device(ptp_usb->handle);
706 printf(" bcdUSB: %d\n", dev->descriptor.bcdUSB);
707 printf(" bDeviceClass: %d\n", dev->descriptor.bDeviceClass);
708 printf(" bDeviceSubClass: %d\n", dev->descriptor.bDeviceSubClass);
709 printf(" bDeviceProtocol: %d\n", dev->descriptor.bDeviceProtocol);
710 printf(" idVendor: %04x\n", dev->descriptor.idVendor);
711 printf(" idProduct: %04x\n", dev->descriptor.idProduct);
712 printf(" IN endpoint maxpacket: %d bytes\n", ptp_usb->inep_maxpacket);
713 printf(" OUT endpoint maxpacket: %d bytes\n", ptp_usb->outep_maxpacket);
714 printf(" Raw device info:\n");
715 printf(" Bus location: %d\n", ptp_usb->rawdevice.bus_location);
716 printf(" Device number: %d\n", ptp_usb->rawdevice.devnum);
717 printf(" Device entry info:\n");
718 printf(" Vendor: %s\n", ptp_usb->rawdevice.device_entry.vendor);
719 printf(" Vendor id: 0x%04x\n", ptp_usb->rawdevice.device_entry.vendor_id);
720 printf(" Product: %s\n", ptp_usb->rawdevice.device_entry.product);
721 printf(" Vendor id: 0x%04x\n", ptp_usb->rawdevice.device_entry.product_id);
722 printf(" Device flags: 0x%08x\n", ptp_usb->rawdevice.device_entry.device_flags);
723 (void) probe_device_descriptor(dev, stdout);
724 }
725
726 /**
727 * Retrieve the apropriate playlist extension for this
728 * device. Rather hacky at the moment. This is probably
729 * desired by the managing software, but when creating
730 * lists on the device itself you notice certain preferences.
731 * @param ptp_usb the USB device to get suggestion for.
732 * @return the suggested playlist extension.
733 */
get_playlist_extension(PTP_USB * ptp_usb)734 const char *get_playlist_extension(PTP_USB *ptp_usb)
735 {
736 struct usb_device *dev;
737 static char creative_pl_extension[] = ".zpl";
738 static char default_pl_extension[] = ".pla";
739
740 dev = usb_device(ptp_usb->handle);
741 if (dev->descriptor.idVendor == 0x041e) {
742 return creative_pl_extension;
743 }
744 return default_pl_extension;
745 }
746
747 static void
libusb_glue_debug(PTPParams * params,const char * format,...)748 libusb_glue_debug (PTPParams *params, const char *format, ...)
749 {
750 va_list args;
751
752 va_start (args, format);
753 if (params->debug_func!=NULL)
754 params->debug_func (params->data, format, args);
755 else
756 {
757 vfprintf (stderr, format, args);
758 fprintf (stderr,"\n");
759 fflush (stderr);
760 }
761 va_end (args);
762 }
763
764 static void
libusb_glue_error(PTPParams * params,const char * format,...)765 libusb_glue_error (PTPParams *params, const char *format, ...)
766 {
767 va_list args;
768
769 va_start (args, format);
770 if (params->error_func!=NULL)
771 params->error_func (params->data, format, args);
772 else
773 {
774 vfprintf (stderr, format, args);
775 fprintf (stderr,"\n");
776 fflush (stderr);
777 }
778 va_end (args);
779 }
780
781
782 /*
783 * ptp_read_func() and ptp_write_func() are
784 * based on same functions usb.c in libgphoto2.
785 * Much reading packet logs and having fun with trials and errors
786 * reveals that WMP / Windows is probably using an algorithm like this
787 * for large transfers:
788 *
789 * 1. Send the command (0x0c bytes) if headers are split, else, send
790 * command plus sizeof(endpoint) - 0x0c bytes.
791 * 2. Send first packet, max size to be sizeof(endpoint) but only when using
792 * split headers. Else goto 3.
793 * 3. REPEAT send 0x10000 byte chunks UNTIL remaining bytes < 0x10000
794 * We call 0x10000 CONTEXT_BLOCK_SIZE.
795 * 4. Send remaining bytes MOD sizeof(endpoint)
796 * 5. Send remaining bytes. If this happens to be exactly sizeof(endpoint)
797 * then also send a zero-length package.
798 *
799 * Further there is some special quirks to handle zero reads from the
800 * device, since some devices can't do them at all due to shortcomings
801 * of the USB slave controller in the device.
802 */
803 #define CONTEXT_BLOCK_SIZE_1 0x3e00
804 #define CONTEXT_BLOCK_SIZE_2 0x200
805 #define CONTEXT_BLOCK_SIZE CONTEXT_BLOCK_SIZE_1+CONTEXT_BLOCK_SIZE_2
806 static short
ptp_read_func(unsigned long size,PTPDataHandler * handler,void * data,unsigned long * readbytes,int readzero)807 ptp_read_func (
808 unsigned long size, PTPDataHandler *handler,void *data,
809 unsigned long *readbytes,
810 int readzero
811 ) {
812 PTP_USB *ptp_usb = (PTP_USB *)data;
813 unsigned long toread = 0;
814 int result = 0;
815 unsigned long curread = 0;
816 unsigned long written;
817 unsigned char *bytes;
818 int expect_terminator_byte = 0;
819
820 // This is the largest block we'll need to read in.
821 bytes = malloc(CONTEXT_BLOCK_SIZE);
822 while (curread < size) {
823
824 #ifdef ENABLE_USB_BULK_DEBUG
825 printf("Remaining size to read: 0x%04lx bytes\n", size - curread);
826 #endif
827 // check equal to condition here
828 if (size - curread < CONTEXT_BLOCK_SIZE)
829 {
830 // this is the last packet
831 toread = size - curread;
832 // this is equivalent to zero read for these devices
833 if (readzero && FLAG_NO_ZERO_READS(ptp_usb) && toread % 64 == 0) {
834 toread += 1;
835 expect_terminator_byte = 1;
836 }
837 }
838 else if (curread == 0)
839 // we are first packet, but not last packet
840 toread = CONTEXT_BLOCK_SIZE_1;
841 else if (toread == CONTEXT_BLOCK_SIZE_1)
842 toread = CONTEXT_BLOCK_SIZE_2;
843 else if (toread == CONTEXT_BLOCK_SIZE_2)
844 toread = CONTEXT_BLOCK_SIZE_1;
845 else
846 printf("unexpected toread size 0x%04x, 0x%04x remaining bytes\n",
847 (unsigned int) toread, (unsigned int) (size-curread));
848
849 #ifdef ENABLE_USB_BULK_DEBUG
850 printf("Reading in 0x%04lx bytes\n", toread);
851 #endif
852 result = USB_BULK_READ(ptp_usb->handle, ptp_usb->inep, (char*)bytes, toread, ptp_usb->timeout);
853 #ifdef ENABLE_USB_BULK_DEBUG
854 printf("Result of read: 0x%04x\n", result);
855 #endif
856
857 if (result < 0) {
858 return PTP_ERROR_IO;
859 }
860 #ifdef ENABLE_USB_BULK_DEBUG
861 printf("<==USB IN\n");
862 if (result == 0)
863 printf("Zero Read\n");
864 else if (result < 0)
865 fprintf(stderr, "USB_BULK_READ result=%#x\n", result);
866 else
867 data_dump_ascii (stdout,bytes,result,16);
868 #endif
869
870 // want to discard extra byte
871 if (expect_terminator_byte && result == toread)
872 {
873 #ifdef ENABLE_USB_BULK_DEBUG
874 printf("<==USB IN\nDiscarding extra byte\n");
875 #endif
876 result--;
877 }
878
879 int putfunc_ret = handler->putfunc(NULL, handler->priv, result, bytes, &written);
880 if (putfunc_ret != PTP_RC_OK)
881 return putfunc_ret;
882
883 ptp_usb->current_transfer_complete += result;
884 curread += result;
885
886 // Increase counters, call callback
887 if (ptp_usb->callback_active) {
888 if (ptp_usb->current_transfer_complete >= ptp_usb->current_transfer_total) {
889 // send last update and disable callback.
890 ptp_usb->current_transfer_complete = ptp_usb->current_transfer_total;
891 ptp_usb->callback_active = 0;
892 }
893 if (ptp_usb->current_transfer_callback != NULL) {
894 int ret;
895 ret = ptp_usb->current_transfer_callback(ptp_usb->current_transfer_complete,
896 ptp_usb->current_transfer_total,
897 ptp_usb->current_transfer_callback_data);
898 if (ret != 0) {
899 return PTP_ERROR_CANCEL;
900 }
901 }
902 }
903
904 if (result < toread) /* short reads are common */
905 break;
906 }
907 if (readbytes) *readbytes = curread;
908 free (bytes);
909
910 // there might be a zero packet waiting for us...
911 if (readzero &&
912 !FLAG_NO_ZERO_READS(ptp_usb) &&
913 curread % ptp_usb->outep_maxpacket == 0) {
914 char temp;
915 int zeroresult = 0;
916
917 #ifdef ENABLE_USB_BULK_DEBUG
918 printf("<==USB IN\n");
919 printf("Zero Read\n");
920 #endif
921 zeroresult = USB_BULK_READ(ptp_usb->handle, ptp_usb->inep, &temp, 0, ptp_usb->timeout);
922 if (zeroresult != 0)
923 printf("LIBMTP panic: unable to read in zero packet, response 0x%04x", zeroresult);
924 }
925
926 return PTP_RC_OK;
927 }
928
929 static short
ptp_write_func(unsigned long size,PTPDataHandler * handler,void * data,unsigned long * written)930 ptp_write_func (
931 unsigned long size,
932 PTPDataHandler *handler,
933 void *data,
934 unsigned long *written
935 ) {
936 PTP_USB *ptp_usb = (PTP_USB *)data;
937 unsigned long towrite = 0;
938 int result = 0;
939 unsigned long curwrite = 0;
940 unsigned char *bytes;
941
942 // This is the largest block we'll need to read in.
943 bytes = malloc(CONTEXT_BLOCK_SIZE);
944 if (!bytes) {
945 return PTP_ERROR_IO;
946 }
947 while (curwrite < size) {
948 unsigned long usbwritten = 0;
949 towrite = size-curwrite;
950 if (towrite > CONTEXT_BLOCK_SIZE) {
951 towrite = CONTEXT_BLOCK_SIZE;
952 } else {
953 // This magic makes packets the same size that WMP send them.
954 if (towrite > ptp_usb->outep_maxpacket && towrite % ptp_usb->outep_maxpacket != 0) {
955 towrite -= towrite % ptp_usb->outep_maxpacket;
956 }
957 }
958 int getfunc_ret = handler->getfunc(NULL, handler->priv,towrite,bytes,&towrite);
959 if (getfunc_ret != PTP_RC_OK)
960 return getfunc_ret;
961 while (usbwritten < towrite) {
962 result = USB_BULK_WRITE(ptp_usb->handle,ptp_usb->outep,((char*)bytes+usbwritten),towrite-usbwritten,ptp_usb->timeout);
963 #ifdef ENABLE_USB_BULK_DEBUG
964 printf("USB OUT==>\n");
965 if (result > 0) {
966 data_dump_ascii (stdout,bytes+usbwritten,result,16);
967 } else {
968 fprintf(stderr, "USB_BULK_WRITE: result=%#x\n", result);
969 }
970 #endif
971 if (result < 0) {
972 return PTP_ERROR_IO;
973 }
974 // check for result == 0 perhaps too.
975 // Increase counters
976 ptp_usb->current_transfer_complete += result;
977 curwrite += result;
978 usbwritten += result;
979 }
980 // call callback
981 if (ptp_usb->callback_active) {
982 if (ptp_usb->current_transfer_complete >= ptp_usb->current_transfer_total) {
983 // send last update and disable callback.
984 ptp_usb->current_transfer_complete = ptp_usb->current_transfer_total;
985 ptp_usb->callback_active = 0;
986 }
987 if (ptp_usb->current_transfer_callback != NULL) {
988 int ret;
989 ret = ptp_usb->current_transfer_callback(ptp_usb->current_transfer_complete,
990 ptp_usb->current_transfer_total,
991 ptp_usb->current_transfer_callback_data);
992 if (ret != 0) {
993 return PTP_ERROR_CANCEL;
994 }
995 }
996 }
997 if (result < towrite) /* short writes happen */
998 break;
999 }
1000 free (bytes);
1001 if (written) {
1002 *written = curwrite;
1003 }
1004
1005
1006 // If this is the last transfer send a zero write if required
1007 if (ptp_usb->current_transfer_complete >= ptp_usb->current_transfer_total) {
1008 if ((towrite % ptp_usb->outep_maxpacket) == 0) {
1009 #ifdef ENABLE_USB_BULK_DEBUG
1010 printf("USB OUT==>\n");
1011 printf("Zero Write\n");
1012 #endif
1013 result=USB_BULK_WRITE(ptp_usb->handle,ptp_usb->outep,(char *)"x",0,ptp_usb->timeout);
1014 }
1015 }
1016
1017 if (result < 0)
1018 return PTP_ERROR_IO;
1019 return PTP_RC_OK;
1020 }
1021
1022 /* memory data get/put handler */
1023 typedef struct {
1024 unsigned char *data;
1025 unsigned long size, curoff;
1026 } PTPMemHandlerPrivate;
1027
1028 static uint16_t
memory_getfunc(PTPParams * params,void * private,unsigned long wantlen,unsigned char * data,unsigned long * gotlen)1029 memory_getfunc(PTPParams* params, void* private,
1030 unsigned long wantlen, unsigned char *data,
1031 unsigned long *gotlen
1032 ) {
1033 PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)private;
1034 unsigned long tocopy = wantlen;
1035
1036 if (priv->curoff + tocopy > priv->size)
1037 tocopy = priv->size - priv->curoff;
1038 memcpy (data, priv->data + priv->curoff, tocopy);
1039 priv->curoff += tocopy;
1040 *gotlen = tocopy;
1041 return PTP_RC_OK;
1042 }
1043
1044 static uint16_t
memory_putfunc(PTPParams * params,void * private,unsigned long sendlen,unsigned char * data,unsigned long * putlen)1045 memory_putfunc(PTPParams* params, void* private,
1046 unsigned long sendlen, unsigned char *data,
1047 unsigned long *putlen
1048 ) {
1049 PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)private;
1050
1051 if (priv->curoff + sendlen > priv->size) {
1052 priv->data = realloc (priv->data, priv->curoff+sendlen);
1053 priv->size = priv->curoff + sendlen;
1054 }
1055 memcpy (priv->data + priv->curoff, data, sendlen);
1056 priv->curoff += sendlen;
1057 *putlen = sendlen;
1058 return PTP_RC_OK;
1059 }
1060
1061 /* init private struct for receiving data. */
1062 static uint16_t
ptp_init_recv_memory_handler(PTPDataHandler * handler)1063 ptp_init_recv_memory_handler(PTPDataHandler *handler) {
1064 PTPMemHandlerPrivate* priv;
1065 priv = malloc (sizeof(PTPMemHandlerPrivate));
1066 handler->priv = priv;
1067 handler->getfunc = memory_getfunc;
1068 handler->putfunc = memory_putfunc;
1069 priv->data = NULL;
1070 priv->size = 0;
1071 priv->curoff = 0;
1072 return PTP_RC_OK;
1073 }
1074
1075 /* init private struct and put data in for sending data.
1076 * data is still owned by caller.
1077 */
1078 static uint16_t
ptp_init_send_memory_handler(PTPDataHandler * handler,unsigned char * data,unsigned long len)1079 ptp_init_send_memory_handler(PTPDataHandler *handler,
1080 unsigned char *data, unsigned long len
1081 ) {
1082 PTPMemHandlerPrivate* priv;
1083 priv = malloc (sizeof(PTPMemHandlerPrivate));
1084 if (!priv)
1085 return PTP_RC_GeneralError;
1086 handler->priv = priv;
1087 handler->getfunc = memory_getfunc;
1088 handler->putfunc = memory_putfunc;
1089 priv->data = data;
1090 priv->size = len;
1091 priv->curoff = 0;
1092 return PTP_RC_OK;
1093 }
1094
1095 /* free private struct + data */
1096 static uint16_t
ptp_exit_send_memory_handler(PTPDataHandler * handler)1097 ptp_exit_send_memory_handler (PTPDataHandler *handler) {
1098 PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)handler->priv;
1099 /* data is owned by caller */
1100 free (priv);
1101 return PTP_RC_OK;
1102 }
1103
1104 /* hand over our internal data to caller */
1105 static uint16_t
ptp_exit_recv_memory_handler(PTPDataHandler * handler,unsigned char ** data,unsigned long * size)1106 ptp_exit_recv_memory_handler (PTPDataHandler *handler,
1107 unsigned char **data, unsigned long *size
1108 ) {
1109 PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)handler->priv;
1110 *data = priv->data;
1111 *size = priv->size;
1112 free (priv);
1113 return PTP_RC_OK;
1114 }
1115
1116 /* send / receive functions */
1117
1118 uint16_t
ptp_usb_sendreq(PTPParams * params,PTPContainer * req)1119 ptp_usb_sendreq (PTPParams* params, PTPContainer* req)
1120 {
1121 uint16_t ret;
1122 PTPUSBBulkContainer usbreq;
1123 PTPDataHandler memhandler;
1124 unsigned long written = 0;
1125 unsigned long towrite;
1126 #ifdef ENABLE_USB_BULK_DEBUG
1127 char txt[256];
1128
1129 (void) ptp_render_opcode (params, req->Code, sizeof(txt), txt);
1130 printf("REQUEST: 0x%04x, %s\n", req->Code, txt);
1131 #endif
1132 /* build appropriate USB container */
1133 usbreq.length=htod32(PTP_USB_BULK_REQ_LEN-
1134 (sizeof(uint32_t)*(5-req->Nparam)));
1135 usbreq.type=htod16(PTP_USB_CONTAINER_COMMAND);
1136 usbreq.code=htod16(req->Code);
1137 usbreq.trans_id=htod32(req->Transaction_ID);
1138 usbreq.payload.params.param1=htod32(req->Param1);
1139 usbreq.payload.params.param2=htod32(req->Param2);
1140 usbreq.payload.params.param3=htod32(req->Param3);
1141 usbreq.payload.params.param4=htod32(req->Param4);
1142 usbreq.payload.params.param5=htod32(req->Param5);
1143 /* send it to responder */
1144 towrite = PTP_USB_BULK_REQ_LEN-(sizeof(uint32_t)*(5-req->Nparam));
1145 ptp_init_send_memory_handler (&memhandler, (unsigned char*)&usbreq, towrite);
1146 ret=ptp_write_func(
1147 towrite,
1148 &memhandler,
1149 params->data,
1150 &written
1151 );
1152 ptp_exit_send_memory_handler (&memhandler);
1153 if (ret!=PTP_RC_OK && ret!=PTP_ERROR_CANCEL) {
1154 ret = PTP_ERROR_IO;
1155 }
1156 if (written != towrite && ret != PTP_ERROR_CANCEL && ret != PTP_ERROR_IO) {
1157 libusb_glue_error (params,
1158 "PTP: request code 0x%04x sending req wrote only %ld bytes instead of %d",
1159 req->Code, written, towrite
1160 );
1161 ret = PTP_ERROR_IO;
1162 }
1163 return ret;
1164 }
1165
1166 uint16_t
ptp_usb_senddata(PTPParams * params,PTPContainer * ptp,unsigned long size,PTPDataHandler * handler)1167 ptp_usb_senddata (PTPParams* params, PTPContainer* ptp,
1168 unsigned long size, PTPDataHandler *handler
1169 ) {
1170 uint16_t ret;
1171 int wlen, datawlen;
1172 unsigned long written;
1173 PTPUSBBulkContainer usbdata;
1174 uint32_t bytes_left_to_transfer;
1175 PTPDataHandler memhandler;
1176
1177 #ifdef ENABLE_USB_BULK_DEBUG
1178 printf("SEND DATA PHASE\n");
1179 #endif
1180 /* build appropriate USB container */
1181 usbdata.length = htod32(PTP_USB_BULK_HDR_LEN+size);
1182 usbdata.type = htod16(PTP_USB_CONTAINER_DATA);
1183 usbdata.code = htod16(ptp->Code);
1184 usbdata.trans_id= htod32(ptp->Transaction_ID);
1185
1186 ((PTP_USB*)params->data)->current_transfer_complete = 0;
1187 ((PTP_USB*)params->data)->current_transfer_total = size+PTP_USB_BULK_HDR_LEN;
1188
1189 if (params->split_header_data) {
1190 datawlen = 0;
1191 wlen = PTP_USB_BULK_HDR_LEN;
1192 } else {
1193 unsigned long gotlen;
1194 /* For all camera devices. */
1195 datawlen = (size<PTP_USB_BULK_PAYLOAD_LEN_WRITE)?size:PTP_USB_BULK_PAYLOAD_LEN_WRITE;
1196 wlen = PTP_USB_BULK_HDR_LEN + datawlen;
1197
1198 ret = handler->getfunc(params, handler->priv, datawlen, usbdata.payload.data, &gotlen);
1199 if (ret != PTP_RC_OK)
1200 return ret;
1201 if (gotlen != datawlen)
1202 return PTP_RC_GeneralError;
1203 }
1204 ptp_init_send_memory_handler (&memhandler, (unsigned char *)&usbdata, wlen);
1205 /* send first part of data */
1206 ret = ptp_write_func(wlen, &memhandler, params->data, &written);
1207 ptp_exit_send_memory_handler (&memhandler);
1208 if (ret!=PTP_RC_OK) {
1209 return ret;
1210 }
1211 if (size <= datawlen) return ret;
1212 /* if everything OK send the rest */
1213 bytes_left_to_transfer = size-datawlen;
1214 ret = PTP_RC_OK;
1215 while(bytes_left_to_transfer > 0) {
1216 ret = ptp_write_func (bytes_left_to_transfer, handler, params->data, &written);
1217 if (ret != PTP_RC_OK)
1218 break;
1219 if (written == 0) {
1220 ret = PTP_ERROR_IO;
1221 break;
1222 }
1223 bytes_left_to_transfer -= written;
1224 }
1225 if (ret!=PTP_RC_OK && ret!=PTP_ERROR_CANCEL)
1226 ret = PTP_ERROR_IO;
1227 return ret;
1228 }
1229
ptp_usb_getpacket(PTPParams * params,PTPUSBBulkContainer * packet,unsigned long * rlen)1230 static uint16_t ptp_usb_getpacket(PTPParams *params,
1231 PTPUSBBulkContainer *packet, unsigned long *rlen)
1232 {
1233 PTPDataHandler memhandler;
1234 uint16_t ret;
1235 unsigned char *x = NULL;
1236
1237 /* read the header and potentially the first data */
1238 if (params->response_packet_size > 0) {
1239 /* If there is a buffered packet, just use it. */
1240 memcpy(packet, params->response_packet, params->response_packet_size);
1241 *rlen = params->response_packet_size;
1242 free(params->response_packet);
1243 params->response_packet = NULL;
1244 params->response_packet_size = 0;
1245 /* Here this signifies a "virtual read" */
1246 return PTP_RC_OK;
1247 }
1248 ptp_init_recv_memory_handler (&memhandler);
1249 ret = ptp_read_func(PTP_USB_BULK_HS_MAX_PACKET_LEN_READ, &memhandler, params->data, rlen, 0);
1250 ptp_exit_recv_memory_handler (&memhandler, &x, rlen);
1251 if (x) {
1252 memcpy (packet, x, *rlen);
1253 free (x);
1254 }
1255 return ret;
1256 }
1257
1258 uint16_t
ptp_usb_getdata(PTPParams * params,PTPContainer * ptp,PTPDataHandler * handler)1259 ptp_usb_getdata (PTPParams* params, PTPContainer* ptp, PTPDataHandler *handler)
1260 {
1261 uint16_t ret;
1262 PTPUSBBulkContainer usbdata;
1263 unsigned long written;
1264 PTP_USB *ptp_usb = (PTP_USB *) params->data;
1265
1266 #ifdef ENABLE_USB_BULK_DEBUG
1267 printf("GET DATA PHASE\n");
1268 #endif
1269 memset(&usbdata,0,sizeof(usbdata));
1270 do {
1271 unsigned long len, rlen;
1272
1273 ret = ptp_usb_getpacket(params, &usbdata, &rlen);
1274 if (ret!=PTP_RC_OK) {
1275 ret = PTP_ERROR_IO;
1276 break;
1277 }
1278 if (dtoh16(usbdata.type)!=PTP_USB_CONTAINER_DATA) {
1279 ret = PTP_ERROR_DATA_EXPECTED;
1280 break;
1281 }
1282 if (dtoh16(usbdata.code)!=ptp->Code) {
1283 if (FLAG_IGNORE_HEADER_ERRORS(ptp_usb)) {
1284 libusb_glue_debug (params, "ptp2/ptp_usb_getdata: detected a broken "
1285 "PTP header, code field insane, expect problems! (But continuing)");
1286 // Repair the header, so it won't wreak more havoc, don't just ignore it.
1287 // Typically these two fields will be broken.
1288 usbdata.code = htod16(ptp->Code);
1289 usbdata.trans_id = htod32(ptp->Transaction_ID);
1290 ret = PTP_RC_OK;
1291 } else {
1292 ret = dtoh16(usbdata.code);
1293 // This filters entirely insane garbage return codes, but still
1294 // makes it possible to return error codes in the code field when
1295 // getting data. It appears Windows ignores the contents of this
1296 // field entirely.
1297 if (ret < PTP_RC_Undefined || ret > PTP_RC_SpecificationOfDestinationUnsupported) {
1298 libusb_glue_debug (params, "ptp2/ptp_usb_getdata: detected a broken "
1299 "PTP header, code field insane.");
1300 ret = PTP_ERROR_IO;
1301 }
1302 break;
1303 }
1304 }
1305 if (usbdata.length == 0xffffffffU) {
1306 /* Copy first part of data to 'data' */
1307 int putfunc_ret =
1308 handler->putfunc(
1309 params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data,
1310 &written
1311 );
1312 if (putfunc_ret != PTP_RC_OK)
1313 return putfunc_ret;
1314 /* stuff data directly to passed data handler */
1315 while (1) {
1316 unsigned long readdata;
1317 uint16_t xret;
1318
1319 xret = ptp_read_func(
1320 PTP_USB_BULK_HS_MAX_PACKET_LEN_READ,
1321 handler,
1322 params->data,
1323 &readdata,
1324 0
1325 );
1326 if (xret != PTP_RC_OK)
1327 return xret;
1328 if (readdata < PTP_USB_BULK_HS_MAX_PACKET_LEN_READ)
1329 break;
1330 }
1331 return PTP_RC_OK;
1332 }
1333 if (rlen > dtoh32(usbdata.length)) {
1334 /*
1335 * Buffer the surplus response packet if it is >=
1336 * PTP_USB_BULK_HDR_LEN
1337 * (i.e. it is probably an entire package)
1338 * else discard it as erroneous surplus data.
1339 * This will even work if more than 2 packets appear
1340 * in the same transaction, they will just be handled
1341 * iteratively.
1342 *
1343 * Marcus observed stray bytes on iRiver devices;
1344 * these are still discarded.
1345 */
1346 unsigned int packlen = dtoh32(usbdata.length);
1347 unsigned int surplen = rlen - packlen;
1348
1349 if (surplen >= PTP_USB_BULK_HDR_LEN) {
1350 params->response_packet = malloc(surplen);
1351 memcpy(params->response_packet,
1352 (uint8_t *) &usbdata + packlen, surplen);
1353 params->response_packet_size = surplen;
1354 /* Ignore reading one extra byte if device flags have been set */
1355 } else if(!FLAG_NO_ZERO_READS(ptp_usb) &&
1356 (rlen - dtoh32(usbdata.length) == 1)) {
1357 libusb_glue_debug (params, "ptp2/ptp_usb_getdata: read %d bytes "
1358 "too much, expect problems!",
1359 rlen - dtoh32(usbdata.length));
1360 }
1361 rlen = packlen;
1362 }
1363
1364 /* For most PTP devices rlen is 512 == sizeof(usbdata)
1365 * here. For MTP devices splitting header and data it might
1366 * be 12.
1367 */
1368 /* Evaluate full data length. */
1369 len=dtoh32(usbdata.length)-PTP_USB_BULK_HDR_LEN;
1370
1371 /* autodetect split header/data MTP devices */
1372 if (dtoh32(usbdata.length) > 12 && (rlen==12))
1373 params->split_header_data = 1;
1374
1375 /* Copy first part of data to 'data' */
1376 int putfunc_ret =
1377 handler->putfunc(
1378 params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data,
1379 &written
1380 );
1381 if (putfunc_ret != PTP_RC_OK)
1382 return putfunc_ret;
1383
1384 if (FLAG_NO_ZERO_READS(ptp_usb) &&
1385 len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ) {
1386 #ifdef ENABLE_USB_BULK_DEBUG
1387 printf("Reading in extra terminating byte\n");
1388 #endif
1389 // need to read in extra byte and discard it
1390 int result = 0;
1391 char byte = 0;
1392 result = USB_BULK_READ(ptp_usb->handle, ptp_usb->inep, &byte, 1, ptp_usb->timeout);
1393
1394 if (result != 1)
1395 printf("Could not read in extra byte for PTP_USB_BULK_HS_MAX_PACKET_LEN_READ long file, return value 0x%04x\n", result);
1396 } else if (len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ && params->split_header_data == 0) {
1397 int zeroresult = 0;
1398 char zerobyte = 0;
1399
1400 #ifdef ENABLE_USB_BULK_DEBUG
1401 printf("Reading in zero packet after header\n");
1402 #endif
1403 zeroresult = USB_BULK_READ(ptp_usb->handle, ptp_usb->inep, &zerobyte, 0, ptp_usb->timeout);
1404
1405 if (zeroresult != 0)
1406 printf("LIBMTP panic: unable to read in zero packet, response 0x%04x", zeroresult);
1407 }
1408
1409 /* Is that all of data? */
1410 if (len+PTP_USB_BULK_HDR_LEN<=rlen) {
1411 break;
1412 }
1413
1414 ret = ptp_read_func(len - (rlen - PTP_USB_BULK_HDR_LEN),
1415 handler,
1416 params->data, &rlen, 1);
1417
1418 if (ret!=PTP_RC_OK) {
1419 break;
1420 }
1421 } while (0);
1422 return ret;
1423 }
1424
1425 uint16_t
ptp_usb_getresp(PTPParams * params,PTPContainer * resp)1426 ptp_usb_getresp (PTPParams* params, PTPContainer* resp)
1427 {
1428 uint16_t ret;
1429 unsigned long rlen;
1430 PTPUSBBulkContainer usbresp;
1431 PTP_USB *ptp_usb = (PTP_USB *)(params->data);
1432
1433 #ifdef ENABLE_USB_BULK_DEBUG
1434 printf("RESPONSE: ");
1435 #endif
1436 memset(&usbresp,0,sizeof(usbresp));
1437 /* read response, it should never be longer than sizeof(usbresp) */
1438 ret = ptp_usb_getpacket(params, &usbresp, &rlen);
1439
1440 // Fix for bevahiour reported by Scott Snyder on Samsung YP-U3. The player
1441 // sends a packet containing just zeroes of length 2 (up to 4 has been seen too)
1442 // after a NULL packet when it should send the response. This code ignores
1443 // such illegal packets.
1444 while (ret==PTP_RC_OK && rlen<PTP_USB_BULK_HDR_LEN && usbresp.length==0) {
1445 libusb_glue_debug (params, "ptp_usb_getresp: detected short response "
1446 "of %d bytes, expect problems! (re-reading "
1447 "response), rlen");
1448 ret = ptp_usb_getpacket(params, &usbresp, &rlen);
1449 }
1450
1451 if (ret!=PTP_RC_OK) {
1452 ret = PTP_ERROR_IO;
1453 } else
1454 if (dtoh16(usbresp.type)!=PTP_USB_CONTAINER_RESPONSE) {
1455 ret = PTP_ERROR_RESP_EXPECTED;
1456 } else
1457 if (dtoh16(usbresp.code)!=resp->Code) {
1458 ret = dtoh16(usbresp.code);
1459 }
1460 #ifdef ENABLE_USB_BULK_DEBUG
1461 printf("%04x\n", ret);
1462 #endif
1463 if (ret!=PTP_RC_OK) {
1464 /* libusb_glue_error (params,
1465 "PTP: request code 0x%04x getting resp error 0x%04x",
1466 resp->Code, ret);*/
1467 return ret;
1468 }
1469 /* build an appropriate PTPContainer */
1470 resp->Code=dtoh16(usbresp.code);
1471 resp->SessionID=params->session_id;
1472 resp->Transaction_ID=dtoh32(usbresp.trans_id);
1473 if (FLAG_IGNORE_HEADER_ERRORS(ptp_usb)) {
1474 if (resp->Transaction_ID != params->transaction_id-1) {
1475 libusb_glue_debug (params, "ptp_usb_getresp: detected a broken "
1476 "PTP header, transaction ID insane, expect "
1477 "problems! (But continuing)");
1478 // Repair the header, so it won't wreak more havoc.
1479 resp->Transaction_ID = params->transaction_id-1;
1480 }
1481 }
1482 resp->Param1=dtoh32(usbresp.payload.params.param1);
1483 resp->Param2=dtoh32(usbresp.payload.params.param2);
1484 resp->Param3=dtoh32(usbresp.payload.params.param3);
1485 resp->Param4=dtoh32(usbresp.payload.params.param4);
1486 resp->Param5=dtoh32(usbresp.payload.params.param5);
1487 return ret;
1488 }
1489
1490 /* Event handling functions */
1491
1492 /* PTP Events wait for or check mode */
1493 #define PTP_EVENT_CHECK 0x0000 /* waits for */
1494 #define PTP_EVENT_CHECK_FAST 0x0001 /* checks */
1495
1496 static inline uint16_t
ptp_usb_event(PTPParams * params,PTPContainer * event,int wait)1497 ptp_usb_event (PTPParams* params, PTPContainer* event, int wait)
1498 {
1499 uint16_t ret;
1500 int result;
1501 unsigned long rlen;
1502 PTPUSBEventContainer usbevent;
1503 PTP_USB *ptp_usb = (PTP_USB *)(params->data);
1504
1505 memset(&usbevent,0,sizeof(usbevent));
1506
1507 if ((params==NULL) || (event==NULL))
1508 return PTP_ERROR_BADPARAM;
1509 ret = PTP_RC_OK;
1510 switch(wait) {
1511 case PTP_EVENT_CHECK:
1512 result=USB_BULK_READ(ptp_usb->handle, ptp_usb->intep,(char *)&usbevent,sizeof(usbevent),ptp_usb->timeout);
1513 if (result==0)
1514 result = USB_BULK_READ(ptp_usb->handle, ptp_usb->intep,(char *) &usbevent, sizeof(usbevent), ptp_usb->timeout);
1515 if (result < 0) ret = PTP_ERROR_IO;
1516 break;
1517 case PTP_EVENT_CHECK_FAST:
1518 result=USB_BULK_READ(ptp_usb->handle, ptp_usb->intep,(char *)&usbevent,sizeof(usbevent),ptp_usb->timeout);
1519 if (result==0)
1520 result = USB_BULK_READ(ptp_usb->handle, ptp_usb->intep,(char *) &usbevent, sizeof(usbevent), ptp_usb->timeout);
1521 if (result < 0) ret = PTP_ERROR_IO;
1522 break;
1523 default:
1524 ret=PTP_ERROR_BADPARAM;
1525 break;
1526 }
1527 if (ret!=PTP_RC_OK) {
1528 libusb_glue_error (params,
1529 "PTP: reading event an error 0x%04x occurred", ret);
1530 return PTP_ERROR_IO;
1531 }
1532 rlen = result;
1533 if (rlen < 8) {
1534 libusb_glue_error (params,
1535 "PTP: reading event an short read of %ld bytes occurred", rlen);
1536 return PTP_ERROR_IO;
1537 }
1538 /* if we read anything over interrupt endpoint it must be an event */
1539 /* build an appropriate PTPContainer */
1540 event->Code=dtoh16(usbevent.code);
1541 event->SessionID=params->session_id;
1542 event->Transaction_ID=dtoh32(usbevent.trans_id);
1543 event->Param1=dtoh32(usbevent.param1);
1544 event->Param2=dtoh32(usbevent.param2);
1545 event->Param3=dtoh32(usbevent.param3);
1546 return ret;
1547 }
1548
1549 uint16_t
ptp_usb_event_check(PTPParams * params,PTPContainer * event)1550 ptp_usb_event_check (PTPParams* params, PTPContainer* event) {
1551
1552 return ptp_usb_event (params, event, PTP_EVENT_CHECK_FAST);
1553 }
1554
1555 uint16_t
ptp_usb_event_wait(PTPParams * params,PTPContainer * event)1556 ptp_usb_event_wait (PTPParams* params, PTPContainer* event) {
1557
1558 return ptp_usb_event (params, event, PTP_EVENT_CHECK);
1559 }
1560
1561 uint16_t
ptp_usb_control_cancel_request(PTPParams * params,uint32_t transactionid)1562 ptp_usb_control_cancel_request (PTPParams *params, uint32_t transactionid) {
1563 PTP_USB *ptp_usb = (PTP_USB *)(params->data);
1564 int ret;
1565 unsigned char buffer[6];
1566
1567 htod16a(&buffer[0],PTP_EC_CancelTransaction);
1568 htod32a(&buffer[2],transactionid);
1569 ret = usb_control_msg(ptp_usb->handle,
1570 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1571 0x64, 0x0000, 0x0000, (char *) buffer, sizeof(buffer), ptp_usb->timeout);
1572 if (ret < sizeof(buffer))
1573 return PTP_ERROR_IO;
1574 return PTP_RC_OK;
1575 }
1576
init_ptp_usb(PTPParams * params,PTP_USB * ptp_usb,struct usb_device * dev)1577 static int init_ptp_usb (PTPParams* params, PTP_USB* ptp_usb, struct usb_device* dev)
1578 {
1579 usb_dev_handle *device_handle;
1580
1581 params->sendreq_func=ptp_usb_sendreq;
1582 params->senddata_func=ptp_usb_senddata;
1583 params->getresp_func=ptp_usb_getresp;
1584 params->getdata_func=ptp_usb_getdata;
1585 params->cancelreq_func=ptp_usb_control_cancel_request;
1586 params->data=ptp_usb;
1587 params->transaction_id=0;
1588 /*
1589 * This is hardcoded here since we have no devices whatsoever that are BE.
1590 * Change this the day we run into our first BE device (if ever).
1591 */
1592 params->byteorder = PTP_DL_LE;
1593
1594 ptp_usb->timeout = USB_TIMEOUT_DEFAULT;
1595
1596 device_handle = usb_open(dev);
1597 if (!device_handle) {
1598 perror("usb_open()");
1599 return -1;
1600 }
1601
1602 ptp_usb->handle = device_handle;
1603 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1604 /*
1605 * If this device is known to be wrongfully claimed by other kernel
1606 * drivers (such as mass storage), then try to unload it to make it
1607 * accessible from user space.
1608 */
1609 if (FLAG_UNLOAD_DRIVER(ptp_usb)) {
1610 if (usb_detach_kernel_driver_np(device_handle, (int) ptp_usb->interface)) {
1611 // Totally ignore this error!
1612 // perror("usb_detach_kernel_driver_np()");
1613 }
1614 }
1615 #endif
1616 #ifdef __WIN32__
1617 // Only needed on Windows, and cause problems on other platforms.
1618 if (usb_set_configuration(device_handle, dev->config->bConfigurationValue)) {
1619 perror("usb_set_configuration()");
1620 return -1;
1621 }
1622 #endif
1623 if (usb_claim_interface(device_handle, (int) ptp_usb->interface)) {
1624 perror("usb_claim_interface()");
1625 return -1;
1626 }
1627
1628 return 0;
1629 }
1630
clear_stall(PTP_USB * ptp_usb)1631 static void clear_stall(PTP_USB* ptp_usb)
1632 {
1633 uint16_t status;
1634 int ret;
1635
1636 /* check the inep status */
1637 status = 0;
1638 ret = usb_get_endpoint_status(ptp_usb,ptp_usb->inep,&status);
1639 if (ret<0) {
1640 perror ("inep: usb_get_endpoint_status()");
1641 } else if (status) {
1642 printf("Clearing stall on IN endpoint\n");
1643 ret = usb_clear_stall_feature(ptp_usb,ptp_usb->inep);
1644 if (ret<0) {
1645 perror ("usb_clear_stall_feature()");
1646 }
1647 }
1648
1649 /* check the outep status */
1650 status=0;
1651 ret = usb_get_endpoint_status(ptp_usb,ptp_usb->outep,&status);
1652 if (ret<0) {
1653 perror("outep: usb_get_endpoint_status()");
1654 } else if (status) {
1655 printf("Clearing stall on OUT endpoint\n");
1656 ret = usb_clear_stall_feature(ptp_usb,ptp_usb->outep);
1657 if (ret<0) {
1658 perror("usb_clear_stall_feature()");
1659 }
1660 }
1661
1662 /* TODO: do we need this for INTERRUPT (ptp_usb->intep) too? */
1663 }
1664
clear_halt(PTP_USB * ptp_usb)1665 static void clear_halt(PTP_USB* ptp_usb)
1666 {
1667 int ret;
1668
1669 ret = usb_clear_halt(ptp_usb->handle,ptp_usb->inep);
1670 if (ret<0) {
1671 perror("usb_clear_halt() on IN endpoint");
1672 }
1673 ret = usb_clear_halt(ptp_usb->handle,ptp_usb->outep);
1674 if (ret<0) {
1675 perror("usb_clear_halt() on OUT endpoint");
1676 }
1677 ret = usb_clear_halt(ptp_usb->handle,ptp_usb->intep);
1678 if (ret<0) {
1679 perror("usb_clear_halt() on INTERRUPT endpoint");
1680 }
1681 }
1682
close_usb(PTP_USB * ptp_usb)1683 static void close_usb(PTP_USB* ptp_usb)
1684 {
1685 // Commented out since it was confusing some
1686 // devices to do these things.
1687 if (!FLAG_NO_RELEASE_INTERFACE(ptp_usb)) {
1688
1689 /*
1690 * Clear any stalled endpoints
1691 * On misbehaving devices designed for Windows/Mac, quote from:
1692 * http://www2.one-eyed-alien.net/~mdharm/linux-usb/target_offenses.txt
1693 * Device does Bad Things(tm) when it gets a GET_STATUS after CLEAR_HALT
1694 * (...) Windows, when clearing a stall, only sends the CLEAR_HALT command,
1695 * and presumes that the stall has cleared. Some devices actually choke
1696 * if the CLEAR_HALT is followed by a GET_STATUS (used to determine if the
1697 * STALL is persistant or not).
1698 */
1699 clear_stall(ptp_usb);
1700 // Clear halts on any endpoints
1701 clear_halt(ptp_usb);
1702 // Added to clear some stuff on the OUT endpoint
1703 // TODO: is this good on the Mac too?
1704 // HINT: some devices may need that you comment these two out too.
1705 usb_resetep(ptp_usb->handle, ptp_usb->outep);
1706 usb_release_interface(ptp_usb->handle, (int) ptp_usb->interface);
1707 }
1708
1709 usb_close(ptp_usb->handle);
1710 }
1711
1712 /**
1713 * Self-explanatory?
1714 */
find_interface_and_endpoints(struct usb_device * dev,uint8_t * interface,int * inep,int * inep_maxpacket,int * outep,int * outep_maxpacket,int * intep)1715 static void find_interface_and_endpoints(struct usb_device *dev,
1716 uint8_t *interface,
1717 int* inep,
1718 int* inep_maxpacket,
1719 int* outep,
1720 int *outep_maxpacket,
1721 int* intep)
1722 {
1723 int i;
1724
1725 // Loop over the device configurations
1726 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
1727 uint8_t j;
1728
1729 for (j = 0; j < dev->config[i].bNumInterfaces; j++) {
1730 uint8_t k;
1731 uint8_t no_ep;
1732 struct usb_endpoint_descriptor *ep;
1733
1734 if (dev->descriptor.bNumConfigurations > 1 || dev->config[i].bNumInterfaces > 1) {
1735 // OK This device has more than one interface, so we have to find out
1736 // which one to use!
1737 // FIXME: Probe the interface.
1738 // FIXME: Release modules attached to all other interfaces in Linux...?
1739 }
1740
1741 *interface = dev->config[i].interface[j].altsetting->bInterfaceNumber;
1742 ep = dev->config[i].interface[j].altsetting->endpoint;
1743 no_ep = dev->config[i].interface[j].altsetting->bNumEndpoints;
1744
1745 for (k = 0; k < no_ep; k++) {
1746 if (ep[k].bmAttributes==USB_ENDPOINT_TYPE_BULK) {
1747 if ((ep[k].bEndpointAddress&USB_ENDPOINT_DIR_MASK)==
1748 USB_ENDPOINT_DIR_MASK)
1749 {
1750 *inep=ep[k].bEndpointAddress;
1751 *inep_maxpacket=ep[k].wMaxPacketSize;
1752 }
1753 if ((ep[k].bEndpointAddress&USB_ENDPOINT_DIR_MASK)==0)
1754 {
1755 *outep=ep[k].bEndpointAddress;
1756 *outep_maxpacket=ep[k].wMaxPacketSize;
1757 }
1758 } else if (ep[k].bmAttributes==USB_ENDPOINT_TYPE_INTERRUPT){
1759 if ((ep[k].bEndpointAddress&USB_ENDPOINT_DIR_MASK)==
1760 USB_ENDPOINT_DIR_MASK)
1761 {
1762 *intep=ep[k].bEndpointAddress;
1763 }
1764 }
1765 }
1766 // We assigned the endpoints so return here.
1767 return;
1768 }
1769 }
1770 }
1771
1772 /**
1773 * This function assigns params and usbinfo given a raw device
1774 * as input.
1775 * @param device the device to be assigned.
1776 * @param usbinfo a pointer to the new usbinfo.
1777 * @return an error code.
1778 */
configure_usb_device(LIBMTP_raw_device_t * device,PTPParams * params,void ** usbinfo)1779 LIBMTP_error_number_t configure_usb_device(LIBMTP_raw_device_t *device,
1780 PTPParams *params,
1781 void **usbinfo)
1782 {
1783 PTP_USB *ptp_usb;
1784 struct usb_device *libusb_device;
1785 uint16_t ret = 0;
1786 struct usb_bus *bus;
1787 int found = 0;
1788
1789 /* See if we can find this raw device again... */
1790 bus = init_usb();
1791 for (; bus != NULL; bus = bus->next) {
1792 if (bus->location == device->bus_location) {
1793 struct usb_device *dev = bus->devices;
1794
1795 for (; dev != NULL; dev = dev->next) {
1796 if(dev->devnum == device->devnum &&
1797 dev->descriptor.idVendor == device->device_entry.vendor_id &&
1798 dev->descriptor.idProduct == device->device_entry.product_id ) {
1799 libusb_device = dev;
1800 found = 1;
1801 break;
1802 }
1803 }
1804 if (found)
1805 break;
1806 }
1807 }
1808 /* Device has gone since detecting raw devices! */
1809 if (!found) {
1810 return LIBMTP_ERROR_NO_DEVICE_ATTACHED;
1811 }
1812
1813 /* Allocate structs */
1814 ptp_usb = (PTP_USB *) malloc(sizeof(PTP_USB));
1815 if (ptp_usb == NULL) {
1816 return LIBMTP_ERROR_MEMORY_ALLOCATION;
1817 }
1818 /* Start with a blank slate (includes setting device_flags to 0) */
1819 memset(ptp_usb, 0, sizeof(PTP_USB));
1820
1821 /* Copy the raw device */
1822 memcpy(&ptp_usb->rawdevice, device, sizeof(LIBMTP_raw_device_t));
1823
1824 /*
1825 * Some devices must have their "OS Descriptor" massaged in order
1826 * to work.
1827 */
1828 if (FLAG_ALWAYS_PROBE_DESCRIPTOR(ptp_usb)) {
1829 // Massage the device descriptor
1830 (void) probe_device_descriptor(libusb_device, NULL);
1831 }
1832
1833
1834 /* Assign endpoints to usbinfo... */
1835 find_interface_and_endpoints(libusb_device,
1836 &ptp_usb->interface,
1837 &ptp_usb->inep,
1838 &ptp_usb->inep_maxpacket,
1839 &ptp_usb->outep,
1840 &ptp_usb->outep_maxpacket,
1841 &ptp_usb->intep);
1842
1843 /* Attempt to initialize this device */
1844 if (init_ptp_usb(params, ptp_usb, libusb_device) < 0) {
1845 fprintf(stderr, "LIBMTP PANIC: Unable to initialize device\n");
1846 return LIBMTP_ERROR_CONNECTING;
1847 }
1848
1849 /*
1850 * This works in situations where previous bad applications
1851 * have not used LIBMTP_Release_Device on exit
1852 */
1853 if ((ret = ptp_opensession(params, 1)) == PTP_ERROR_IO) {
1854 fprintf(stderr, "PTP_ERROR_IO: Trying again after re-initializing USB interface\n");
1855 close_usb(ptp_usb);
1856
1857 if(init_ptp_usb(params, ptp_usb, libusb_device) <0) {
1858 fprintf(stderr, "LIBMTP PANIC: Could not open session on device\n");
1859 return LIBMTP_ERROR_CONNECTING;
1860 }
1861
1862 /* Device has been reset, try again */
1863 ret = ptp_opensession(params, 1);
1864 }
1865
1866 /* Was the transaction id invalid? Try again */
1867 if (ret == PTP_RC_InvalidTransactionID) {
1868 fprintf(stderr, "LIBMTP WARNING: Transaction ID was invalid, increment and try again\n");
1869 params->transaction_id += 10;
1870 ret = ptp_opensession(params, 1);
1871 }
1872
1873 if (ret != PTP_RC_SessionAlreadyOpened && ret != PTP_RC_OK) {
1874 fprintf(stderr, "LIBMTP PANIC: Could not open session! "
1875 "(Return code %d)\n Try to reset the device.\n",
1876 ret);
1877 usb_release_interface(ptp_usb->handle,
1878 (int) ptp_usb->interface);
1879 return LIBMTP_ERROR_CONNECTING;
1880 }
1881
1882 /* OK configured properly */
1883 *usbinfo = (void *) ptp_usb;
1884 return LIBMTP_ERROR_NONE;
1885 }
1886
1887
close_device(PTP_USB * ptp_usb,PTPParams * params)1888 void close_device (PTP_USB *ptp_usb, PTPParams *params)
1889 {
1890 if (ptp_closesession(params)!=PTP_RC_OK)
1891 fprintf(stderr,"ERROR: Could not close session!\n");
1892 close_usb(ptp_usb);
1893 }
1894
set_usb_device_timeout(PTP_USB * ptp_usb,int timeout)1895 void set_usb_device_timeout(PTP_USB *ptp_usb, int timeout)
1896 {
1897 ptp_usb->timeout = timeout;
1898 }
1899
get_usb_device_timeout(PTP_USB * ptp_usb,int * timeout)1900 void get_usb_device_timeout(PTP_USB *ptp_usb, int *timeout)
1901 {
1902 *timeout = ptp_usb->timeout;
1903 }
1904
usb_clear_stall_feature(PTP_USB * ptp_usb,int ep)1905 static int usb_clear_stall_feature(PTP_USB* ptp_usb, int ep)
1906 {
1907
1908 return (usb_control_msg(ptp_usb->handle,
1909 USB_RECIP_ENDPOINT, USB_REQ_CLEAR_FEATURE, USB_FEATURE_HALT,
1910 ep, NULL, 0, ptp_usb->timeout));
1911 }
1912
usb_get_endpoint_status(PTP_USB * ptp_usb,int ep,uint16_t * status)1913 static int usb_get_endpoint_status(PTP_USB* ptp_usb, int ep, uint16_t* status)
1914 {
1915 return (usb_control_msg(ptp_usb->handle,
1916 USB_DP_DTH|USB_RECIP_ENDPOINT, USB_REQ_GET_STATUS,
1917 USB_FEATURE_HALT, ep, (char *)status, 2, ptp_usb->timeout));
1918 }
1919