* This function should not generate any bus I/O and should not block.	 * If I/O is required (e.g. reading the active configuration value), it is	 * OK to ignore these suggestions :)	 *	 * This function is executed when the user wishes to retrieve a list	 * of USB devices connected to the system.	 *	 * Return 0 on success, or a LIBUSB_ERROR code on failure.	 */	int (*get_device_list)(struct libusb_context *ctx,		struct discovered_devs **discdevs);	/* Open a device for I/O and other USB operations. The device handle	 * is preallocated for you, you can retrieve the device in question	 * through handle->dev.	 *	 * Your backend should allocate any internal resources required for I/O	 * and other operations so that those operations can happen (hopefully)	 * without hiccup. This is also a good place to inform libusb that it	 * should monitor certain file descriptors related to this device -	 * see the usbi_add_pollfd() function.	 *	 * This function should not generate any bus I/O and should not block.	 *	 * This function is called when the user attempts to obtain a device	 * handle for a device.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_ACCESS if the user has insufficient permissions	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since	 *   discovery	 * - another LIBUSB_ERROR code on other failure	 *	 * Do not worry about freeing the handle on failed open, the upper layers	 * do this for you.	 */	int (*open)(struct libusb_device_handle *handle);	/* Close a device such that the handle cannot be used again. Your backend	 * should destroy any resources that were allocated in the open path.	 * This may also be a good place to call usbi_remove_pollfd() to inform	 * libusb of any file descriptors associated with this device that should	 * no longer be monitored.	 *	 * This function is called when the user closes a device handle.	 */	void (*close)(struct libusb_device_handle *handle);	/* Retrieve the device descriptor from a device.	 *	 * The descriptor should be retrieved from memory, NOT via bus I/O to the	 * device. This means that you may have to cache it in a private structure	 * during get_device_list enumeration. Alternatively, you may be able	 * to retrieve it from a kernel interface (some Linux setups can do this)	 * still without generating bus I/O.	 *	 * This function is expected to write DEVICE_DESC_LENGTH (18) bytes into	 * buffer, which is guaranteed to be big enough.	 *	 * This function is called when sanity-checking a device before adding	 * it to the list of discovered devices, and also when the user requests	 * to read the device descriptor.	 *	 * This function is expected to return the descriptor in bus-endian format	 * (LE). If it returns the multi-byte values in host-endian format,	 * set the host_endian output parameter to "1".	 *	 * Return 0 on success or a LIBUSB_ERROR code on failure.	 */	int (*get_device_descriptor)(struct libusb_device *device,		unsigned char *buffer, int *host_endian);	/* Get the ACTIVE configuration descriptor for a device.	 *	 * The descriptor should be retrieved from memory, NOT via bus I/O to the	 * device. This means that you may have to cache it in a private structure	 * during get_device_list enumeration. You may also have to keep track	 * of which configuration is active when the user changes it.	 *	 * This function is expected to write len bytes of data into buffer, which	 * is guaranteed to be big enough. If you can only do a partial write,	 * return an error code.	 *	 * This function is expected to return the descriptor in bus-endian format	 * (LE). If it returns the multi-byte values in host-endian format,	 * set the host_endian output parameter to "1".	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state	 * - another LIBUSB_ERROR code on other failure	 */	int (*get_active_config_descriptor)(struct libusb_device *device,		unsigned char *buffer, size_t len, int *host_endian);	/* Get a specific configuration descriptor for a device.	 *	 * The descriptor should be retrieved from memory, NOT via bus I/O to the	 * device. This means that you may have to cache it in a private structure	 * during get_device_list enumeration.	 *	 * The requested descriptor is expressed as a zero-based index (i.e. 0	 * indicates that we are requesting the first descriptor). The index does	 * not (necessarily) equal the bConfigurationValue of the configuration	 * being requested.	 *	 * This function is expected to write len bytes of data into buffer, which	 * is guaranteed to be big enough. If you can only do a partial write,	 * return an error code.	 *	 * This function is expected to return the descriptor in bus-endian format	 * (LE). If it returns the multi-byte values in host-endian format,	 * set the host_endian output parameter to "1".	 *	 * Return 0 on success or a LIBUSB_ERROR code on failure.	 */	int (*get_config_descriptor)(struct libusb_device *device,		uint8_t config_index, unsigned char *buffer, size_t len,		int *host_endian);	/* Get the bConfigurationValue for the active configuration for a device.	 * Optional. This should only be implemented if you can retrieve it from	 * cache (don't generate I/O).	 *	 * If you cannot retrieve this from cache, either do not implement this	 * function, or return LIBUSB_ERROR_NOT_SUPPORTED. This will cause	 * libusb to retrieve the information through a standard control transfer.	 *	 * This function must be non-blocking.	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - LIBUSB_ERROR_NOT_SUPPORTED if the value cannot be retrieved without	 *   blocking	 * - another LIBUSB_ERROR code on other failure.	 */	int (*get_configuration)(struct libusb_device_handle *handle, int *config);	/* Set the active configuration for a device.	 *	 * A configuration value of -1 should put the device in unconfigured state.	 *	 * This function can block.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if the configuration does not exist	 * - LIBUSB_ERROR_BUSY if interfaces are currently claimed (and hence	 *   configuration cannot be changed)	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure.	 */	int (*set_configuration)(struct libusb_device_handle *handle, int config);	/* Claim an interface. When claimed, the application can then perform	 * I/O to an interface's endpoints.	 *	 * This function should not generate any bus I/O and should not block.	 * Interface claiming is a logical operation that simply ensures that	 * no other drivers/applications are using the interface, and after	 * claiming, no other drivers/applicatiosn can use the interface because	 * we now "own" it.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if the interface does not exist	 * - LIBUSB_ERROR_BUSY if the interface is in use by another driver/app	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*claim_interface)(struct libusb_device_handle *handle, int iface);	/* Release a previously claimed interface.	 *	 * This function should also generate a SET_INTERFACE control request,	 * resetting the alternate setting of that interface to 0. It's OK for	 * this function to block as a result.	 *	 * You will only ever be asked to release an interface which was	 * successfully claimed earlier.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*release_interface)(struct libusb_device_handle *handle, int iface);	/* Set the alternate setting for an interface.	 *	 * You will only ever be asked to set the alternate setting for an	 * interface which was successfully claimed earlier.	 *	 * It's OK for this function to block.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if the alternate setting does not exist	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*set_interface_altsetting)(struct libusb_device_handle *handle,		int iface, int altsetting);	/* Clear a halt/stall condition on an endpoint.	 *	 * It's OK for this function to block.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*clear_halt)(struct libusb_device_handle *handle,		unsigned char endpoint);	/* Perform a USB port reset to reinitialize a device.	 *	 * If possible, the handle should still be usable after the reset	 * completes, assuming that the device descriptors did not change during	 * reset and all previous interface state can be restored.	 *	 * If something changes, or you cannot easily locate/verify the resetted	 * device, return LIBUSB_ERROR_NOT_FOUND. This prompts the application	 * to close the old handle and re-enumerate the device.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the device	 *   has been disconnected since it was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*reset_device)(struct libusb_device_handle *handle);	/* Determine if a kernel driver is active on an interface. Optional.	 *	 * The presence of a kernel driver on an interface indicates that any	 * calls to claim_interface would fail with the LIBUSB_ERROR_BUSY code.	 *	 * Return:	 * - 0 if no driver is active	 * - 1 if a driver is active	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*kernel_driver_active)(struct libusb_device_handle *handle,		int interface);		/* Detach a kernel driver from an interface. Optional.	 *	 * After detaching a kernel driver, the interface should be available	 * for claim.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active	 * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it	 *   was opened	 * - another LIBUSB_ERROR code on other failure	 */	int (*detach_kernel_driver)(struct libusb_device_handle *handle,		int interface);	/* Destroy a device. Optional.	 *	 * This function is called when the last reference to a device is	 * destroyed. It should free any resources allocated in the get_device_list	 * path.	 */	void (*destroy_device)(struct libusb_device *dev);	/* Submit a transfer. Your implementation should take the transfer,	 * morph it into whatever form your platform requires, and submit it	 * asynchronously.	 *	 * This function must not block.	 *	 * Return:	 * - 0 on success	 * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected	 * - another LIBUSB_ERROR code on other failure	 */	int (*submit_transfer)(struct usbi_transfer *itransfer);	/* Cancel a previously submitted transfer.	 *	 * This function must not block. The transfer cancellation must complete	 * later, resulting in a call to usbi_handle_transfer_cancellation()	 * from the context of handle_events.	 */	int (*cancel_transfer)(struct usbi_transfer *itransfer);	/* Clear a transfer as if it has completed or cancelled, but do not	 * report any completion/cancellation to the library. You should free	 * all private data from the transfer as if you were just about to report	 * completion or cancellation.	 *	 * This function might seem a bit out of place. It is used when libusb	 * detects a disconnected device - it calls this function for all pending	 * transfers before reporting completion (with the disconnect code) to	 * the user. Maybe we can improve upon this internal interface in future.	 */	void (*clear_transfer_priv)(struct usbi_transfer *itransfer);	/* Handle any pending events. This involves monitoring any active	 * transfers and processing their completion or cancellation.	 *	 * The function is passed an array of pollfd structures (size nfds)	 * as a result of the poll() system call. The num_ready parameter	 * indicates the number of file descriptors that have reported events	 * (i.e. the poll() return value). This should be enough information	 * for you to determine which actions need to be taken on the currently	 * active transfers.	 *	 * For any cancelled transfers, call usbi_handle_transfer_cancellation().	 * For completed transfers, call usbi_handle_transfer_completion().	 * For control/bulk/interrupt transfers, populate the "transferred"	 * element of the appropriate usbi_transfer structure before calling the	 * above functions. For isochronous transfers, populate the status and	 * transferred fields of the iso packet descriptors of the transfer.	 *	 * This function should also be able to detect disconnection of the	 * device, reporting that situation with usbi_handle_disconnect().	 *	 * Return 0 on success, or a LIBUSB_ERROR code on failure.	 */	int (*handle_events)(struct libusb_context *ctx,		struct pollfd *fds, nfds_t nfds, int num_ready);	/* Number of bytes to reserve for per-device private backend data.	 * This private data area is accessible through the "os_priv" field of	 * struct libusb_device. */	size_t device_priv_size;	/* Number of bytes to reserve for per-handle private backend data.	 * This private data area is accessible through the "os_priv" field of	 * struct libusb_device. */	size_t device_handle_priv_size;	/* Number of bytes to reserve for per-transfer private backend data.	 * This private data area is accessible by calling	 * usbi_transfer_get_os_priv() on the appropriate usbi_transfer instance.	 */	size_t transfer_priv_size;	/* Mumber of additional bytes for os_priv for each iso packet.	 * Can your backend use this? */	/* FIXME: linux can't use this any more. if other OS's cannot either,	 * then remove this */	size_t add_iso_packet_size;};extern const struct usbi_os_backend * const usbi_backend;extern const struct usbi_os_backend linux_usbfs_backend;#endif