usb 2.17.0 → 2.18.0

package/libusb/libusb/libusb.h

@@ -65,9 +65,6 @@ typedef SSIZE_T ssize_t;
 #if defined(interface)
 #undef interface
 #endif
-#if !defined(__CYGWIN__)
-#include <winsock.h>
-#endif
 #endif /* _WIN32 || __CYGWIN__ */
 
 #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
@@ -168,9 +165,10 @@ typedef SSIZE_T ssize_t;
  * <li>libusb version 1.0.27: LIBUSB_API_VERSION = 0x0100010A
  * <li>libusb version 1.0.28: LIBUSB_API_VERSION = 0x0100010A
  * <li>libusb version 1.0.29: LIBUSB_API_VERSION = 0x0100010B
+ * <li>libusb version 1.0.30: LIBUSB_API_VERSION = 0x0100010C
  * </ul>
  */
-#define LIBUSB_API_VERSION 0x0100010B
+#define LIBUSB_API_VERSION 0x0100010C
 
 /** \def LIBUSBX_API_VERSION
  * \ingroup libusb_misc
@@ -192,7 +190,7 @@ extern "C" {
  * \param x the host-endian value to convert
  * \returns the value in little-endian byte order
  */
-static inline uint16_t libusb_cpu_to_le16(const uint16_t x)
+static inline uint16_t libusb_cpu_to_le16(uint16_t x)
 {
 	union {
 		uint8_t  b8[2];
@@ -264,6 +262,24 @@ enum libusb_class_code {
 	/** Personal Healthcare */
 	LIBUSB_CLASS_PERSONAL_HEALTHCARE = 0x0f,
 
+	/** Audio & Video */
+	LIBUSB_CLASS_AUDIO_VIDEO = 0x10,
+
+	/** Billboard */
+	LIBUSB_CLASS_BILLBOARD = 0x11,
+
+	/** Interface class */
+	LIBUSB_CLASS_TYPE_C_BRIDGE = 0x12,
+
+	/** Bulk display */
+	LIBUSB_CLASS_BULK_DISPLAY_PROTOCOL = 0x13,
+
+	/** MCTP */
+	LIBUSB_CLASS_MCTP = 0x14,
+
+	/** I3C */
+	LIBUSB_CLASS_I3C = 0x3c,
+
 	/** Diagnostic Device */
 	LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 0xdc,
 
@@ -1182,16 +1198,16 @@ struct libusb_device_handle;
  */
 struct libusb_version {
 	/** Library major version. */
-	const uint16_t major;
+	uint16_t major;
 
 	/** Library minor version. */
-	const uint16_t minor;
+	uint16_t minor;
 
 	/** Library micro version. */
-	const uint16_t micro;
+	uint16_t micro;
 
 	/** Library nano version. */
-	const uint16_t nano;
+	uint16_t nano;
 
 	/** Library release candidate suffix string, e.g. "-rc4". */
 	const char *rc;
@@ -1649,6 +1665,29 @@ enum libusb_option {
 	LIBUSB_OPTION_MAX = 4
 };
 
+/** \ingroup libusb_desc
+ * The device string type.
+ */
+enum libusb_device_string_type {
+	LIBUSB_DEVICE_STRING_MANUFACTURER,
+	LIBUSB_DEVICE_STRING_PRODUCT,
+	LIBUSB_DEVICE_STRING_SERIAL_NUMBER,
+	LIBUSB_DEVICE_STRING_COUNT  /* The total number of string types. */
+};
+
+/** \ingroup libusb_desc
+ * The maximum length for a device string descriptor in UTF-8.
+ * 
+ * 255 max descriptor length with 2 byte header 
+ *  => 253 bytes UTF-16LE, no null termination (USB 2.0 9.6.7)
+ *  => 126.5 codepoints
+ *  => 127 * 3 + 1
+ *  => 382 bytes
+ * 
+ * Stay with 256 * 3/2 = 384 to be safe.
+ */
+#define LIBUSB_DEVICE_STRING_BYTES_MAX  (384U)
+ 
 /** \ingroup libusb_lib
  * Callback function for handling log messages.
  * \param ctx the context which is related to the log message, or NULL if it
@@ -1696,6 +1735,8 @@ void LIBUSB_CALL libusb_free_device_list(libusb_device **list,
 libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev);
 void LIBUSB_CALL libusb_unref_device(libusb_device *dev);
 
+int LIBUSB_CALL libusb_get_device_string(libusb_device *dev,
+	enum libusb_device_string_type string_type, char *data, int length);
 int LIBUSB_CALL libusb_get_configuration(libusb_device_handle *dev,
 	int *config);
 int LIBUSB_CALL libusb_get_device_descriptor(libusb_device *dev,
@@ -1745,6 +1786,7 @@ int LIBUSB_CALL libusb_get_platform_descriptor(libusb_context *ctx,
 	struct libusb_platform_descriptor **platform_descriptor);
 void LIBUSB_CALL libusb_free_platform_descriptor(
 	struct libusb_platform_descriptor *platform_descriptor);
+unsigned long LIBUSB_CALL libusb_get_session_data(libusb_device *dev);
 uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev);
 uint8_t LIBUSB_CALL libusb_get_port_number(libusb_device *dev);
 int LIBUSB_CALL libusb_get_port_numbers(libusb_device *dev, uint8_t *port_numbers, int port_numbers_len);
@@ -1807,6 +1849,14 @@ int LIBUSB_CALL libusb_attach_kernel_driver(libusb_device_handle *dev_handle,
 int LIBUSB_CALL libusb_set_auto_detach_kernel_driver(
 	libusb_device_handle *dev_handle, int enable);
 
+int LIBUSB_CALL libusb_endpoint_supports_raw_io(libusb_device_handle* dev_handle,
+	uint8_t endpoint);
+int LIBUSB_CALL libusb_endpoint_set_raw_io(libusb_device_handle *dev_handle,
+	uint8_t endpoint, int enable);
+int LIBUSB_CALL libusb_get_max_raw_io_transfer_size(
+	libusb_device_handle *dev_handle,
+	uint8_t endpoint);
+
 /* async I/O */
 
 /** \ingroup libusb_asyncio

package/libusb/libusb/libusbi.h

@@ -369,30 +369,30 @@ struct libusb_context {
 	usbi_timer_t timer;
 #endif
 
-	struct list_head usb_devs;
 	usbi_mutex_t usb_devs_lock;
+	struct list_head usb_devs;
 
 	/* A list of open handles. Backends are free to traverse this if required.
 	 */
-	struct list_head open_devs;
 	usbi_mutex_t open_devs_lock;
+	struct list_head open_devs;
 
 	/* A list of registered hotplug callbacks */
+	usbi_mutex_t hotplug_cbs_lock;
 	struct list_head hotplug_cbs;
 	libusb_hotplug_callback_handle next_hotplug_cb_handle;
-	usbi_mutex_t hotplug_cbs_lock;
 
 	/* A flag to indicate that the context is ready for hotplug notifications */
 	usbi_atomic_t hotplug_ready;
 
+	/* Note paths taking both this and usbi_transfer->lock must always
+	 * take this lock first */
+	usbi_mutex_t flying_transfers_lock;
 	/* this is a list of in-flight transfer handles, sorted by timeout
 	 * expiration. URBs to timeout the soonest are placed at the beginning of
 	 * the list, URBs that will time out later are placed after, and urbs with
 	 * infinite timeout are always placed at the very end. */
 	struct list_head flying_transfers;
-	/* Note paths taking both this and usbi_transfer->lock must always
-	 * take this lock first */
-	usbi_mutex_t flying_transfers_lock; /* for flying_transfers and timeout_flags */
 
 #if !defined(PLATFORM_WINDOWS)
 	/* user callbacks for pollfd changes */
@@ -451,8 +451,8 @@ struct libusb_context {
 extern struct libusb_context *usbi_default_context;
 extern struct libusb_context *usbi_fallback_context;
 
-extern struct list_head active_contexts_list;
 extern usbi_mutex_static_t active_contexts_lock;
+extern struct list_head active_contexts_list;
 
 static inline struct libusb_context *usbi_get_context(struct libusb_context *ctx)
 {
@@ -523,6 +523,8 @@ struct libusb_device {
 
 	struct libusb_device_descriptor device_descriptor;
 	usbi_atomic_t attached;
+
+	char * device_strings_utf8[LIBUSB_DEVICE_STRING_COUNT];
 };
 
 struct libusb_device_handle {
@@ -583,7 +585,17 @@ void usbi_get_real_time(struct timespec *tp);
  */
 
 struct usbi_transfer {
-	int num_iso_packets;
+	/* this lock is held during libusb_submit_transfer() and
+	 * libusb_cancel_transfer() (allowing the OS backend to prevent duplicate
+	 * cancellation, submission-during-cancellation, etc). the OS backend
+	 * should also take this lock in the handle_events path, to prevent the user
+	 * cancelling the transfer from another thread while you are processing
+	 * its completion (presumably there would be races within your OS backend
+	 * if this were possible).
+	 * Note paths taking both this and the flying_transfers_lock must
+	 * always take the flying_transfers_lock first */
+	usbi_mutex_t lock;
+
 	struct list_head list;
 	struct list_head completed_list;
 	struct timespec timeout;
@@ -596,17 +608,6 @@ struct usbi_transfer {
 	 * even after dev_handle is set to NULL.  */
 	struct libusb_device *dev;
 
-	/* this lock is held during libusb_submit_transfer() and
-	 * libusb_cancel_transfer() (allowing the OS backend to prevent duplicate
-	 * cancellation, submission-during-cancellation, etc). the OS backend
-	 * should also take this lock in the handle_events path, to prevent the user
-	 * cancelling the transfer from another thread while you are processing
-	 * its completion (presumably there would be races within your OS backend
-	 * if this were possible).
-	 * Note paths taking both this and the flying_transfers_lock must
-	 * always take the flying_transfers_lock first */
-	usbi_mutex_t lock;
-
 	void *priv;
 };
 
@@ -814,21 +815,26 @@ struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
 struct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx,
 	unsigned long session_id);
 int usbi_sanitize_device(struct libusb_device *dev);
-void usbi_handle_disconnect(struct libusb_device_handle *dev_handle);
+void usbi_handle_disconnect(struct libusb_context *ctx, struct libusb_device_handle *dev_handle);
 
 int usbi_handle_transfer_completion(struct usbi_transfer *itransfer,
 	enum libusb_transfer_status status);
 int usbi_handle_transfer_cancellation(struct usbi_transfer *itransfer);
 void usbi_signal_transfer_completion(struct usbi_transfer *itransfer);
 
+void usbi_attach_device(struct libusb_device *dev);
+void usbi_detach_device(struct libusb_device *dev);
+
 void usbi_connect_device(struct libusb_device *dev);
 void usbi_disconnect_device(struct libusb_device *dev);
 
+struct usbi_event_source_data {
+	usbi_os_handle_t os_handle;
+	short poll_events;
+};
+
 struct usbi_event_source {
-	struct usbi_event_source_data {
-		usbi_os_handle_t os_handle;
-		short poll_events;
-	} data;
+	struct usbi_event_source_data data;
 	struct list_head list;
 };
 
@@ -995,7 +1001,9 @@ struct usbi_os_backend {
 	 * this point, you should be ready to provide device descriptors and so
 	 * on through the get_*_descriptor functions. Finally, call
 	 * usbi_sanitize_device() to perform some final sanity checks on the
-	 * device. Assuming all of the above succeeded, we can now continue.
+	 * device. Assuming all of the above succeeded, call
+	 * usbi_connect_device() to add the device to the context's device list
+	 * and make it discoverable by usbi_get_device_by_session_id().
 	 * If any of the above failed, remember to unreference the device that
 	 * was returned by usbi_alloc_device().
 	 *
@@ -1021,6 +1029,31 @@ struct usbi_os_backend {
 	int (*get_device_list)(struct libusb_context *ctx,
 		struct discovered_devs **discdevs);
 
+	/* Retrieve a device string without needing to open the device.
+	 *
+	 * The string should be retrieved without opening the device
+	 * and ideally without performing USB transactions to the device.
+	 * Most operating systems read and cache the common string 
+	 * descriptors.  Use the OS-specific calls to retrieve these strings.
+	 *
+	 * Since the USB string descriptor could be processed by the OS,
+	 * this function returns a UTF-8 encoded string.
+	 *
+	 * The string will be returned untranslated or in the default OS language
+	 * when supported by the OS and USB device.
+	 *
+	 * This function must not write more than length bytes into data,
+	 * including the null terminator.
+	 *
+	 * Return:
+	 * - The actual length in bytes including the null termintor on success.
+	 * - LIBUSB_ERROR_NO_DEVICE if device not found.
+	 * - LIBUSB_ERROR_INVALID_PARAM if any parameter is invalid.
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*get_device_string)(libusb_device *dev,
+		enum libusb_device_string_type string_type, char *data, int length);
+
 	/* Apps which were written before hotplug support, may listen for
 	 * hotplug events on their own and call libusb_get_device_list on
 	 * device addition. In this case libusb_get_device_list will likely
@@ -1353,6 +1386,37 @@ struct usbi_os_backend {
 	int (*attach_kernel_driver)(struct libusb_device_handle *dev_handle,
 		uint8_t interface_number);
 
+	/** Check if RAW_IO is supported by an endpoint.
+	 *
+	 * Return:
+	 * - 1 if yes
+	 * - 0 if no
+	 * - a LIBUSB_ERROR code on failure
+	 */
+	int (*endpoint_supports_raw_io)(struct libusb_device_handle* dev_handle,
+		uint8_t endpoint);
+
+	/** Enable/disable RAW_IO for an endpoint.
+	 *
+	 * Return:
+	 * - 0 on success
+	 * - LIBUSB_ERROR_NOT_SUPPORTED if RAW_IO is not supported by the endpoint
+	 * - another LIBUSB_ERROR code on other failure
+	 */
+	int (*endpoint_set_raw_io)(struct libusb_device_handle* dev_handle,
+		uint8_t endpoint, int enable);
+
+	/* Retrieve the maximum transfer size in bytes supported for WinUSB RAW_IO
+	 * for an inbound bulk or interrupt endpoint on an open device. Optional.
+	 *
+	 * Return:
+	 * - a positive maximum transfer size on success
+	 * - a LIBUSB_ERROR code on failure
+	 */
+	int (*get_max_raw_io_transfer_size)(
+		struct libusb_device_handle *dev_handle,
+		uint8_t endpoint);
+
 	/* Destroy a device. Optional.
 	 *
 	 * This function is called when the last reference to a device is