1 /* 2 * \file libusb-glue.c 3 * Low-level USB interface glue towards libusb. 4 * 5 * Copyright (C) 2005-2007 Richard A. Low <richard (at) wentnet.com> 6 * Copyright (C) 2005-2008 Linus Walleij <triad (at) df.lth.se> 7 * Copyright (C) 2006-2007 Marcus Meissner 8 * Copyright (C) 2007 Ted Bullock 9 * Copyright (C) 2008 Chris Bagwell <chris (at) 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 */ 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 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 1895 void set_usb_device_timeout(PTP_USB *ptp_usb, int timeout) 1896 { 1897 ptp_usb->timeout = timeout; 1898 } 1899 1900 void get_usb_device_timeout(PTP_USB *ptp_usb, int *timeout) 1901 { 1902 *timeout = ptp_usb->timeout; 1903 } 1904 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 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
