usb 2.16.0 → 2.18.0

package/libusb/libusb/libusbi.h

@@ -103,6 +103,17 @@ typedef volatile LONG usbi_atomic_t;
 #define usbi_atomic_inc(a)	InterlockedIncrement((a))
 #define usbi_atomic_dec(a)	InterlockedDecrement((a))
 #else
+#if defined(__HAIKU__) && defined(__GNUC__) && !defined(__clang__)
+/* The Haiku port of libusb has some C++ files and GCC does not define
+ * anything in stdatomic.h when compiled in C++11 (only in C++23).
+ * This appears to be a bug in gcc's stdatomic.h, and should be fixed either
+ * in gcc or in Haiku. Until then, use the gcc builtins. */
+typedef long usbi_atomic_t;
+#define usbi_atomic_load(a)    __atomic_load_n((a), __ATOMIC_SEQ_CST)
+#define usbi_atomic_store(a, v)        __atomic_store_n((a), (v), __ATOMIC_SEQ_CST)
+#define usbi_atomic_inc(a)     __atomic_add_fetch((a), 1, __ATOMIC_SEQ_CST)
+#define usbi_atomic_dec(a)     __atomic_sub_fetch((a), 1, __ATOMIC_SEQ_CST)
+#else
 #include <stdatomic.h>
 typedef atomic_long usbi_atomic_t;
 #define usbi_atomic_load(a)	atomic_load((a))
@@ -110,6 +121,7 @@ typedef atomic_long usbi_atomic_t;
 #define usbi_atomic_inc(a)	(atomic_fetch_add((a), 1) + 1)
 #define usbi_atomic_dec(a)	(atomic_fetch_add((a), -1) - 1)
 #endif
+#endif
 
 /* Internal abstractions for event handling and thread synchronization */
 #if defined(PLATFORM_POSIX)
@@ -357,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 */
@@ -439,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)
 {
@@ -511,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 {
@@ -571,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;
@@ -584,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;
 };
 
@@ -802,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;
 };
 
@@ -983,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().
 	 *
@@ -1009,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
@@ -1341,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