1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2009 by Zachary T Welch <zw@superlucidity.net> *
6 * Copyright (C) 2011 by Mauro Gamba <maurillo71@gmail.com> *
7 ***************************************************************************/
15 #include <helper/log.h>
16 #include <jtag/adapter.h>
17 #include "libusb_helper.h"
20 * comment from libusb:
21 * As per the USB 3.0 specs, the current maximum limit for the depth is 7.
23 #define MAX_USB_PORTS 7
25 static struct libusb_context
*jtag_libusb_context
; /**< Libusb context **/
26 static struct libusb_device
**devs
; /**< The usb device list **/
28 static int jtag_libusb_error(int err
)
33 case LIBUSB_ERROR_TIMEOUT
:
34 return ERROR_TIMEOUT_REACHED
;
36 case LIBUSB_ERROR_INVALID_PARAM
:
37 case LIBUSB_ERROR_ACCESS
:
38 case LIBUSB_ERROR_NO_DEVICE
:
39 case LIBUSB_ERROR_NOT_FOUND
:
40 case LIBUSB_ERROR_BUSY
:
41 case LIBUSB_ERROR_OVERFLOW
:
42 case LIBUSB_ERROR_PIPE
:
43 case LIBUSB_ERROR_INTERRUPTED
:
44 case LIBUSB_ERROR_NO_MEM
:
45 case LIBUSB_ERROR_NOT_SUPPORTED
:
46 case LIBUSB_ERROR_OTHER
:
53 bool jtag_libusb_match_ids(struct libusb_device_descriptor
*dev_desc
,
54 const uint16_t vids
[], const uint16_t pids
[])
56 for (unsigned i
= 0; vids
[i
]; i
++) {
57 if (dev_desc
->idVendor
== vids
[i
] &&
58 dev_desc
->idProduct
== pids
[i
]) {
65 #ifdef HAVE_LIBUSB_GET_PORT_NUMBERS
66 static bool jtag_libusb_location_equal(struct libusb_device
*device
)
68 uint8_t port_path
[MAX_USB_PORTS
];
72 path_len
= libusb_get_port_numbers(device
, port_path
, MAX_USB_PORTS
);
73 if (path_len
== LIBUSB_ERROR_OVERFLOW
) {
74 LOG_WARNING("cannot determine path to usb device! (more than %i ports in path)\n",
78 dev_bus
= libusb_get_bus_number(device
);
80 return adapter_usb_location_equal(dev_bus
, port_path
, path_len
);
82 #else /* HAVE_LIBUSB_GET_PORT_NUMBERS */
83 static bool jtag_libusb_location_equal(struct libusb_device
*device
)
87 #endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */
90 /* Returns true if the string descriptor indexed by str_index in device matches string */
91 static bool string_descriptor_equal(struct libusb_device_handle
*device
, uint8_t str_index
,
96 char desc_string
[256+1]; /* Max size of string descriptor */
101 retval
= libusb_get_string_descriptor_ascii(device
, str_index
,
102 (unsigned char *)desc_string
, sizeof(desc_string
)-1);
104 LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval
);
108 /* Null terminate descriptor string in case it needs to be logged. */
109 desc_string
[sizeof(desc_string
)-1] = '\0';
111 matched
= strncmp(string
, desc_string
, sizeof(desc_string
)) == 0;
113 LOG_DEBUG("Device serial number '%s' doesn't match requested serial '%s'",
114 desc_string
, string
);
118 static bool jtag_libusb_match_serial(struct libusb_device_handle
*device
,
119 struct libusb_device_descriptor
*dev_desc
, const char *serial
,
120 adapter_get_alternate_serial_fn adapter_get_alternate_serial
)
122 if (string_descriptor_equal(device
, dev_desc
->iSerialNumber
, serial
))
125 /* check the alternate serial helper */
126 if (!adapter_get_alternate_serial
)
129 /* get the alternate serial */
130 char *alternate_serial
= adapter_get_alternate_serial(device
, dev_desc
);
132 /* check possible failures */
133 if (!alternate_serial
)
136 /* then compare and free the alternate serial */
138 if (strcmp(serial
, alternate_serial
) == 0)
141 LOG_DEBUG("Device alternate serial number '%s' doesn't match requested serial '%s'",
142 alternate_serial
, serial
);
144 free(alternate_serial
);
148 int jtag_libusb_open(const uint16_t vids
[], const uint16_t pids
[],
149 const char *product
, struct libusb_device_handle
**out
,
150 adapter_get_alternate_serial_fn adapter_get_alternate_serial
)
152 int cnt
, idx
, err_code
;
153 int retval
= ERROR_FAIL
;
154 bool serial_mismatch
= false;
155 bool product_mismatch
= false;
156 struct libusb_device_handle
*libusb_handle
= NULL
;
157 const char *serial
= adapter_get_required_serial();
159 if (libusb_init(&jtag_libusb_context
) < 0)
162 cnt
= libusb_get_device_list(jtag_libusb_context
, &devs
);
164 for (idx
= 0; idx
< cnt
; idx
++) {
165 struct libusb_device_descriptor dev_desc
;
167 if (libusb_get_device_descriptor(devs
[idx
], &dev_desc
) != 0)
170 if (!jtag_libusb_match_ids(&dev_desc
, vids
, pids
))
173 if (adapter_usb_get_location() && !jtag_libusb_location_equal(devs
[idx
]))
176 err_code
= libusb_open(devs
[idx
], &libusb_handle
);
179 LOG_ERROR("libusb_open() failed with %s",
180 libusb_error_name(err_code
));
184 /* Device must be open to use libusb_get_string_descriptor_ascii. */
186 !jtag_libusb_match_serial(libusb_handle
, &dev_desc
, serial
, adapter_get_alternate_serial
)) {
187 serial_mismatch
= true;
188 libusb_close(libusb_handle
);
193 !string_descriptor_equal(libusb_handle
, dev_desc
.iProduct
, product
)) {
194 product_mismatch
= true;
195 libusb_close(libusb_handle
);
200 *out
= libusb_handle
;
202 serial_mismatch
= false;
203 product_mismatch
= false;
207 libusb_free_device_list(devs
, 1);
210 LOG_INFO("No device matches the serial string");
212 if (product_mismatch
)
213 LOG_INFO("No device matches the product string");
215 if (retval
!= ERROR_OK
)
216 libusb_exit(jtag_libusb_context
);
221 void jtag_libusb_close(struct libusb_device_handle
*dev
)
226 libusb_exit(jtag_libusb_context
);
229 int jtag_libusb_control_transfer(struct libusb_device_handle
*dev
, uint8_t request_type
,
230 uint8_t request
, uint16_t value
, uint16_t index
, char *bytes
,
231 uint16_t size
, unsigned int timeout
, int *transferred
)
233 int retval
= libusb_control_transfer(dev
, request_type
, request
, value
, index
,
234 (unsigned char *)bytes
, size
, timeout
);
237 LOG_ERROR("libusb_control_transfer error: %s", libusb_error_name(retval
));
240 return jtag_libusb_error(retval
);
244 *transferred
= retval
;
249 int jtag_libusb_bulk_write(struct libusb_device_handle
*dev
, int ep
, char *bytes
,
250 int size
, int timeout
, int *transferred
)
256 ret
= libusb_bulk_transfer(dev
, ep
, (unsigned char *)bytes
, size
,
257 transferred
, timeout
);
258 if (ret
!= LIBUSB_SUCCESS
) {
259 LOG_ERROR("libusb_bulk_write error: %s", libusb_error_name(ret
));
260 return jtag_libusb_error(ret
);
266 int jtag_libusb_bulk_read(struct libusb_device_handle
*dev
, int ep
, char *bytes
,
267 int size
, int timeout
, int *transferred
)
273 ret
= libusb_bulk_transfer(dev
, ep
, (unsigned char *)bytes
, size
,
274 transferred
, timeout
);
275 if (ret
!= LIBUSB_SUCCESS
) {
276 LOG_ERROR("libusb_bulk_read error: %s", libusb_error_name(ret
));
277 return jtag_libusb_error(ret
);
283 int jtag_libusb_set_configuration(struct libusb_device_handle
*devh
,
286 struct libusb_device
*udev
= libusb_get_device(devh
);
289 struct libusb_config_descriptor
*config
= NULL
;
290 int current_config
= -1;
292 retval
= libusb_get_configuration(devh
, ¤t_config
);
296 retval
= libusb_get_config_descriptor(udev
, configuration
, &config
);
297 if (retval
!= 0 || !config
)
300 /* Only change the configuration if it is not already set to the
301 same one. Otherwise this issues a lightweight reset and hangs
302 LPC-Link2 with JLink firmware. */
303 if (current_config
!= config
->bConfigurationValue
)
304 retval
= libusb_set_configuration(devh
, config
->bConfigurationValue
);
306 libusb_free_config_descriptor(config
);
311 int jtag_libusb_choose_interface(struct libusb_device_handle
*devh
,
312 unsigned int *usb_read_ep
,
313 unsigned int *usb_write_ep
,
314 int bclass
, int subclass
, int protocol
, int trans_type
)
316 struct libusb_device
*udev
= libusb_get_device(devh
);
317 const struct libusb_interface
*inter
;
318 const struct libusb_interface_descriptor
*interdesc
;
319 const struct libusb_endpoint_descriptor
*epdesc
;
320 struct libusb_config_descriptor
*config
;
322 *usb_read_ep
= *usb_write_ep
= 0;
324 libusb_get_config_descriptor(udev
, 0, &config
);
325 for (int i
= 0; i
< (int)config
->bNumInterfaces
; i
++) {
326 inter
= &config
->interface
[i
];
328 interdesc
= &inter
->altsetting
[0];
330 k
< (int)interdesc
->bNumEndpoints
; k
++) {
331 if ((bclass
> 0 && interdesc
->bInterfaceClass
!= bclass
) ||
332 (subclass
> 0 && interdesc
->bInterfaceSubClass
!= subclass
) ||
333 (protocol
> 0 && interdesc
->bInterfaceProtocol
!= protocol
))
336 epdesc
= &interdesc
->endpoint
[k
];
337 if (trans_type
> 0 && (epdesc
->bmAttributes
& 0x3) != trans_type
)
340 uint8_t epnum
= epdesc
->bEndpointAddress
;
341 bool is_input
= epnum
& 0x80;
342 LOG_DEBUG("usb ep %s %02x",
343 is_input
? "in" : "out", epnum
);
346 *usb_read_ep
= epnum
;
348 *usb_write_ep
= epnum
;
350 if (*usb_read_ep
&& *usb_write_ep
) {
351 LOG_DEBUG("Claiming interface %d", (int)interdesc
->bInterfaceNumber
);
352 libusb_claim_interface(devh
, (int)interdesc
->bInterfaceNumber
);
353 libusb_free_config_descriptor(config
);
358 libusb_free_config_descriptor(config
);
363 int jtag_libusb_get_pid(struct libusb_device
*dev
, uint16_t *pid
)
365 struct libusb_device_descriptor dev_desc
;
367 if (libusb_get_device_descriptor(dev
, &dev_desc
) == 0) {
368 *pid
= dev_desc
.idProduct
;
376 int jtag_libusb_handle_events_completed(int *completed
)
378 return libusb_handle_events_completed(jtag_libusb_context
, completed
);
382 DEV_MEM_NOT_YET_DECIDED
,
384 DEV_MEM_FALLBACK_MALLOC
385 } dev_mem_allocation
;
387 /* Older libusb does not implement following API calls - define stubs instead */
388 #if !defined(LIBUSB_API_VERSION) || (LIBUSB_API_VERSION < 0x01000105)
389 static uint8_t *libusb_dev_mem_alloc(libusb_device_handle
*devh
, size_t length
)
394 static int libusb_dev_mem_free(libusb_device_handle
*devh
,
395 uint8_t *buffer
, size_t length
)
397 return LIBUSB_ERROR_NOT_SUPPORTED
;
401 uint8_t *oocd_libusb_dev_mem_alloc(libusb_device_handle
*devh
,
404 uint8_t *buffer
= NULL
;
405 if (dev_mem_allocation
!= DEV_MEM_FALLBACK_MALLOC
)
406 buffer
= libusb_dev_mem_alloc(devh
, length
);
408 if (dev_mem_allocation
== DEV_MEM_NOT_YET_DECIDED
)
409 dev_mem_allocation
= buffer
? DEV_MEM_AVAILABLE
: DEV_MEM_FALLBACK_MALLOC
;
411 if (dev_mem_allocation
== DEV_MEM_FALLBACK_MALLOC
)
412 buffer
= malloc(length
);
417 int oocd_libusb_dev_mem_free(libusb_device_handle
*devh
,
418 uint8_t *buffer
, size_t length
)
423 switch (dev_mem_allocation
) {
424 case DEV_MEM_AVAILABLE
:
425 return jtag_libusb_error(libusb_dev_mem_free(devh
, buffer
, length
));
427 case DEV_MEM_FALLBACK_MALLOC
:
431 case DEV_MEM_NOT_YET_DECIDED
: