2 * This file is part of the libjaylink project.
4 * Copyright (C) 2014-2016 Marc Schink <jaylink-dev@marcschink.de>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include <sys/types.h>
26 #include "libjaylink.h"
27 #include "libjaylink-internal.h"
30 * libusb.h includes windows.h and therefore must be included after anything
31 * that includes winsock2.h.
38 * Device discovery (USB).
42 /** USB Vendor ID (VID) of SEGGER products. */
43 #define USB_VENDOR_ID 0x1366
45 /* USB Product IDs (PID) and their corresponding USB addresses. */
46 static const uint16_t pids
[][2] = {
66 /** Maximum length of the USB string descriptor for the serial number. */
67 #define USB_SERIAL_NUMBER_LENGTH 12
70 * Maximum number of digits in a serial number
72 * The serial number of a device consists of at most 9 digits but user defined
73 * serial numbers are allowed with up to 10 digits.
75 #define MAX_SERIAL_NUMBER_DIGITS 10
78 static bool parse_serial_number(const char *str
, uint32_t *serial_number
)
85 * Skip the first digits which are not part of a valid serial number.
86 * This is necessary because some devices erroneously use random digits
87 * instead of zeros for padding.
89 if (length
> MAX_SERIAL_NUMBER_DIGITS
)
90 str
= str
+ (length
- MAX_SERIAL_NUMBER_DIGITS
);
92 if (jaylink_parse_serial_number(str
, serial_number
) != JAYLINK_OK
)
98 static bool compare_devices(const void *a
, const void *b
)
100 const struct jaylink_device
*dev
;
101 const struct libusb_device
*usb_dev
;
106 if (dev
->iface
!= JAYLINK_HIF_USB
)
109 if (dev
->usb_dev
== usb_dev
)
115 static struct jaylink_device
*find_device(const struct jaylink_context
*ctx
,
116 const struct libusb_device
*usb_dev
)
120 item
= list_find_custom(ctx
->devs
, &compare_devices
, usb_dev
);
128 static struct jaylink_device
*probe_device(struct jaylink_context
*ctx
,
129 struct libusb_device
*usb_dev
)
132 struct libusb_device_descriptor desc
;
133 struct libusb_device_handle
*usb_devh
;
134 struct jaylink_device
*dev
;
135 char buf
[USB_SERIAL_NUMBER_LENGTH
+ 1];
137 uint32_t serial_number
;
138 bool valid_serial_number
;
142 ret
= libusb_get_device_descriptor(usb_dev
, &desc
);
144 if (ret
!= LIBUSB_SUCCESS
) {
145 log_warn(ctx
, "Failed to get device descriptor: %s.",
146 libusb_error_name(ret
));
150 if (desc
.idVendor
!= USB_VENDOR_ID
)
153 found_device
= false;
155 for (i
= 0; i
< sizeof(pids
) / sizeof(pids
[0]); i
++) {
156 if (pids
[i
][0] == desc
.idProduct
) {
158 usb_address
= pids
[i
][1];
166 log_dbg(ctx
, "Found device (VID:PID = %04x:%04x, bus:address = "
167 "%03u:%03u).", desc
.idVendor
, desc
.idProduct
,
168 libusb_get_bus_number(usb_dev
),
169 libusb_get_device_address(usb_dev
));
172 * Search for an already allocated device instance for this device and
173 * if found return a reference to it.
175 dev
= find_device(ctx
, usb_dev
);
178 log_dbg(ctx
, "Device: USB address = %u.", dev
->usb_address
);
180 if (dev
->valid_serial_number
)
181 log_dbg(ctx
, "Device: Serial number = %u.",
184 log_dbg(ctx
, "Device: Serial number = N/A.");
186 log_dbg(ctx
, "Using existing device instance.");
187 return jaylink_ref_device(dev
);
190 /* Open the device to be able to retrieve its serial number. */
191 ret
= libusb_open(usb_dev
, &usb_devh
);
193 if (ret
!= LIBUSB_SUCCESS
) {
194 log_warn(ctx
, "Failed to open device: %s.",
195 libusb_error_name(ret
));
200 valid_serial_number
= true;
202 ret
= libusb_get_string_descriptor_ascii(usb_devh
, desc
.iSerialNumber
,
203 (unsigned char *)buf
, USB_SERIAL_NUMBER_LENGTH
+ 1);
205 libusb_close(usb_devh
);
208 log_warn(ctx
, "Failed to retrieve serial number: %s.",
209 libusb_error_name(ret
));
210 valid_serial_number
= false;
213 if (valid_serial_number
) {
214 if (!parse_serial_number(buf
, &serial_number
)) {
215 log_warn(ctx
, "Failed to parse serial number.");
220 log_dbg(ctx
, "Device: USB address = %u.", usb_address
);
222 if (valid_serial_number
)
223 log_dbg(ctx
, "Device: Serial number = %u.", serial_number
);
225 log_dbg(ctx
, "Device: Serial number = N/A.");
227 log_dbg(ctx
, "Allocating new device instance.");
229 dev
= device_allocate(ctx
);
232 log_warn(ctx
, "Device instance malloc failed.");
236 dev
->iface
= JAYLINK_HIF_USB
;
237 dev
->usb_dev
= libusb_ref_device(usb_dev
);
238 dev
->usb_address
= usb_address
;
239 dev
->serial_number
= serial_number
;
240 dev
->valid_serial_number
= valid_serial_number
;
245 JAYLINK_PRIV
int discovery_usb_scan(struct jaylink_context
*ctx
)
248 struct libusb_device
**devs
;
249 struct jaylink_device
*dev
;
253 ret
= libusb_get_device_list(ctx
->usb_ctx
, &devs
);
255 if (ret
== LIBUSB_ERROR_IO
) {
256 log_err(ctx
, "Failed to retrieve device list: input/output "
258 return JAYLINK_ERR_IO
;
259 } else if (ret
< 0) {
260 log_err(ctx
, "Failed to retrieve device list: %s.",
261 libusb_error_name(ret
));
267 for (i
= 0; devs
[i
]; i
++) {
268 dev
= probe_device(ctx
, devs
[i
]);
273 ctx
->discovered_devs
= list_prepend(ctx
->discovered_devs
, dev
);
277 libusb_free_device_list(devs
, true);
278 log_dbg(ctx
, "Found %zu USB device(s).", num
);