1bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* 2bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Internal header for libusb 3bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org> 4bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com> 5bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 6bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This library is free software; you can redistribute it and/or 7bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * modify it under the terms of the GNU Lesser General Public 8bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * License as published by the Free Software Foundation; either 9bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * version 2.1 of the License, or (at your option) any later version. 10bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 11bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This library is distributed in the hope that it will be useful, 12bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * but WITHOUT ANY WARRANTY; without even the implied warranty of 13bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Lesser General Public License for more details. 15bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 16bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * You should have received a copy of the GNU Lesser General Public 17bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * License along with this library; if not, write to the Free Software 18bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 20bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 21bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifndef __LIBUSBI_H__ 22bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define __LIBUSBI_H__ 23bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 24bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <config.h> 25bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 26bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <poll.h> 27bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <pthread.h> 28bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <stddef.h> 29bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <time.h> 30bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 31bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#include <libusb.h> 32bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 33bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define DEVICE_DESC_LENGTH 18 34bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 35bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define USB_MAXENDPOINTS 32 36bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define USB_MAXINTERFACES 32 37bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define USB_MAXCONFIG 8 38bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 39bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct list_head { 40bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head *prev, *next; 41bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 42bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 43bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* Get an entry from the list 44bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * ptr - the address of this list_head element in "type" 45bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * type - the data type that contains "member" 46bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * member - the list_head element in "type" 47bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 48bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define list_entry(ptr, type, member) \ 49bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev ((type *)((char *)(ptr) - (unsigned long)(&((type *)0L)->member))) 50bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 51bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* Get each entry from a list 52bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * pos - A structure pointer has a "member" element 53bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * head - list head 54bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * member - the list_head element in "pos" 55bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 56bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define list_for_each_entry(pos, head, member) \ 57bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev for (pos = list_entry((head)->next, typeof(*pos), member); \ 58bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev &pos->member != (head); \ 59bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pos = list_entry(pos->member.next, typeof(*pos), member)) 60bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 61bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define list_for_each_entry_safe(pos, n, head, member) \ 62bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev for (pos = list_entry((head)->next, typeof(*pos), member), \ 63bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev n = list_entry(pos->member.next, typeof(*pos), member); \ 64bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev &pos->member != (head); \ 65bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pos = n, n = list_entry(n->member.next, typeof(*n), member)) 66bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 67bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define list_empty(entry) ((entry)->next == (entry)) 68bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 69bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstatic inline void list_init(struct list_head *entry) 70bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev{ 71bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->prev = entry->next = entry; 72bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev} 73bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 74bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstatic inline void list_add(struct list_head *entry, struct list_head *head) 75bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev{ 76bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->next = head->next; 77bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->prev = head; 78bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 79bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev head->next->prev = entry; 80bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev head->next = entry; 81bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev} 82bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 83bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstatic inline void list_add_tail(struct list_head *entry, 84bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head *head) 85bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev{ 86bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->next = head; 87bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->prev = head->prev; 88bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 89bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev head->prev->next = entry; 90bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev head->prev = entry; 91bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev} 92bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 93bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstatic inline void list_del(struct list_head *entry) 94bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev{ 95bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->next->prev = entry->prev; 96bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev entry->prev->next = entry->next; 97bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev} 98bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 99bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define container_of(ptr, type, member) ({ \ 100bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev const typeof( ((type *)0)->member ) *__mptr = (ptr); \ 101bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev (type *)( (char *)__mptr - offsetof(type,member) );}) 102bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 103bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define MIN(a, b) ((a) < (b) ? (a) : (b)) 104bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define MAX(a, b) ((a) > (b) ? (a) : (b)) 105bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 106bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define TIMESPEC_IS_SET(ts) ((ts)->tv_sec != 0 || (ts)->tv_nsec != 0) 107bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 108bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevenum usbi_log_level { 109bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev LOG_LEVEL_DEBUG, 110bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev LOG_LEVEL_INFO, 111bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev LOG_LEVEL_WARNING, 112bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev LOG_LEVEL_ERROR, 113bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 114bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 115bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevvoid usbi_log(struct libusb_context *ctx, enum usbi_log_level, 116bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev const char *function, const char *format, ...); 117bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 118bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifdef ENABLE_LOGGING 119bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define _usbi_log(ctx, level, fmt...) usbi_log(ctx, level, __FUNCTION__, fmt) 120bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#else 121bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define _usbi_log(ctx, level, fmt...) 122bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 123bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 124bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifdef ENABLE_DEBUG_LOGGING 125bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_dbg(fmt...) _usbi_log(NULL, LOG_LEVEL_DEBUG, fmt) 126bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#else 127bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_dbg(fmt...) 128bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 129bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 130bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_info(ctx, fmt...) _usbi_log(ctx, LOG_LEVEL_INFO, fmt) 131bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_warn(ctx, fmt...) _usbi_log(ctx, LOG_LEVEL_WARNING, fmt) 132bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_err(ctx, fmt...) _usbi_log(ctx, LOG_LEVEL_ERROR, fmt) 133bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 134bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define USBI_GET_CONTEXT(ctx) if (!(ctx)) (ctx) = usbi_default_context 135bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define DEVICE_CTX(dev) ((dev)->ctx) 136bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define HANDLE_CTX(handle) (DEVICE_CTX((handle)->dev)) 137bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define TRANSFER_CTX(transfer) (HANDLE_CTX((transfer)->dev_handle)) 138bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define ITRANSFER_CTX(transfer) \ 139bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev (TRANSFER_CTX(__USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer))) 140bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 141bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevextern struct libusb_context *usbi_default_context; 142bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 143bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct libusb_context { 144bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int debug; 145bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int debug_fixed; 146bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 147bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* internal control pipe, used for interrupting event handling when 148bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * something needs to modify poll fds. */ 149bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int ctrl_pipe[2]; 150bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 151bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head usb_devs; 152bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t usb_devs_lock; 153bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 154bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* A list of open handles. Backends are free to traverse this if required. 155bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 156bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head open_devs; 157bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t open_devs_lock; 158bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 159bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* this is a list of in-flight transfer handles, sorted by timeout 160bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * expiration. URBs to timeout the soonest are placed at the beginning of 161bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * the list, URBs that will time out later are placed after, and urbs with 162bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * infinite timeout are always placed at the very end. */ 163bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head flying_transfers; 164bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t flying_transfers_lock; 165bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 166bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* list of poll fds */ 167bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head pollfds; 168bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t pollfds_lock; 169bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 170bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* a counter that is set when we want to interrupt event handling, in order 171bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * to modify the poll fd set. and a lock to protect it. */ 172bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned int pollfd_modify; 173bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t pollfd_modify_lock; 174bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 175bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* user callbacks for pollfd changes */ 176bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev libusb_pollfd_added_cb fd_added_cb; 177bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev libusb_pollfd_removed_cb fd_removed_cb; 178bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev void *fd_cb_user_data; 179bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 180bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* ensures that only one thread is handling events at any one time */ 181bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t events_lock; 182bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 183bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* used to see if there is an active thread doing event handling */ 184bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int event_handler_active; 185bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 186bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* used to wait for event completion in threads other than the one that is 187bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * event handling */ 188bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t event_waiters_lock; 189bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_cond_t event_waiters_cond; 190bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 191bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifdef USBI_TIMERFD_AVAILABLE 192bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* used for timeout handling, if supported by OS. 193bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * this timerfd is maintained to trigger on the next pending timeout */ 194bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int timerfd; 195bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 196bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 197bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 198bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifdef USBI_TIMERFD_AVAILABLE 199bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_using_timerfd(ctx) ((ctx)->timerfd >= 0) 200bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#else 201bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define usbi_using_timerfd(ctx) (0) 202bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 203bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 204bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct libusb_device { 205bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* lock protects refcnt, everything else is finalized at initialization 206bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * time */ 207bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t lock; 208bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int refcnt; 209bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 210bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct libusb_context *ctx; 211bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 212bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t bus_number; 213bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t device_address; 214bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t num_configurations; 215bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 216bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head list; 217bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned long session_data; 218bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned char os_priv[0]; 219bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 220bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 221bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct libusb_device_handle { 222bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* lock protects claimed_interfaces */ 223bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t lock; 224bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned long claimed_interfaces; 225bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 226bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head list; 227bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct libusb_device *dev; 228bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned char os_priv[0]; 229bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 230bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 231bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define USBI_TRANSFER_TIMED_OUT (1<<0) 232bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 233bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevenum { 234bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev USBI_CLOCK_MONOTONIC, 235bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev USBI_CLOCK_REALTIME 236bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 237bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 238bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* in-memory transfer layout: 239bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 240bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 1. struct usbi_transfer 241bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 2. struct libusb_transfer (which includes iso packets) [variable size] 242bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 3. os private data [variable size] 243bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 244bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * from a libusb_transfer, you can get the usbi_transfer by rewinding the 245bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * appropriate number of bytes. 246bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * the usbi_transfer includes the number of allocated packets, so you can 247bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * determine the size of the transfer and hence the start and length of the 248bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * OS-private data. 249bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 250bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 251bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct usbi_transfer { 252bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int num_iso_packets; 253bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head list; 254bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct timeval timeout; 255bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int transferred; 256bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t flags; 257bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 258bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* this lock is held during libusb_submit_transfer() and 259bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * libusb_cancel_transfer() (allowing the OS backend to prevent duplicate 260bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * cancellation, submission-during-cancellation, etc). the OS backend 261bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * should also take this lock in the handle_events path, to prevent the user 262bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * cancelling the transfer from another thread while you are processing 263bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * its completion (presumably there would be races within your OS backend 264bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * if this were possible). */ 265bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev pthread_mutex_t lock; 266bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 267bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 268bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define __USBI_TRANSFER_TO_LIBUSB_TRANSFER(transfer) \ 269bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev ((struct libusb_transfer *)(((void *)(transfer)) \ 270bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev + sizeof(struct usbi_transfer))) 271bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#define __LIBUSB_TRANSFER_TO_USBI_TRANSFER(transfer) \ 272bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev ((struct usbi_transfer *)(((void *)(transfer)) \ 273bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev - sizeof(struct usbi_transfer))) 274bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 275bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstatic inline void *usbi_transfer_get_os_priv(struct usbi_transfer *transfer) 276bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev{ 277bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev return ((void *)transfer) + sizeof(struct usbi_transfer) 278bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev + sizeof(struct libusb_transfer) 279bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev + (transfer->num_iso_packets 280bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * sizeof(struct libusb_iso_packet_descriptor)); 281bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev} 282bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 283bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* bus structures */ 284bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 285bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* All standard descriptors have these 2 fields in common */ 286bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct usb_descriptor_header { 287bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t bLength; 288bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t bDescriptorType; 289bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 290bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 291bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* shared data and functions */ 292bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 293bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_io_init(struct libusb_context *ctx); 294bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevvoid usbi_io_exit(struct libusb_context *ctx); 295bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 296bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct libusb_device *usbi_alloc_device(struct libusb_context *ctx, 297bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned long session_id); 298bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct libusb_device *usbi_get_device_by_session_id(struct libusb_context *ctx, 299bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned long session_id); 300bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_sanitize_device(struct libusb_device *dev); 301bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevvoid usbi_handle_disconnect(struct libusb_device_handle *handle); 302bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 303bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_handle_transfer_completion(struct usbi_transfer *itransfer, 304bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev enum libusb_transfer_status status); 305bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_handle_transfer_cancellation(struct usbi_transfer *transfer); 306bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 307bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_parse_descriptor(unsigned char *source, char *descriptor, void *dest, 308bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int host_endian); 309bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_get_config_index_by_value(struct libusb_device *dev, 310bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t bConfigurationValue, int *idx); 311bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 312bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* polling */ 313bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 314bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct usbi_pollfd { 315bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* must come first */ 316bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct libusb_pollfd pollfd; 317bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 318bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct list_head list; 319bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 320bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 321bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevint usbi_add_pollfd(struct libusb_context *ctx, int fd, short events); 322bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevvoid usbi_remove_pollfd(struct libusb_context *ctx, int fd); 323bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 324bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* device discovery */ 325bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 326bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* we traverse usbfs without knowing how many devices we are going to find. 327bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * so we create this discovered_devs model which is similar to a linked-list 328bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * which grows when required. it can be freed once discovery has completed, 329bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * eliminating the need for a list node in the libusb_device structure 330bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * itself. */ 331bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct discovered_devs { 332bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t len; 333bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t capacity; 334bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct libusb_device *devices[0]; 335bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 336bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 337bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct discovered_devs *discovered_devs_append( 338bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct discovered_devs *discdevs, struct libusb_device *dev); 339bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 340bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* OS abstraction */ 341bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 342bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev/* This is the interface that OS backends need to implement. 343bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * All fields are mandatory, except ones explicitly noted as optional. */ 344bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevstruct usbi_os_backend { 345bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* A human-readable name for your backend, e.g. "Linux usbfs" */ 346bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev const char *name; 347bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 348bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Perform initialization of your backend. You might use this function 349bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * to determine specific capabilities of the system, allocate required 350bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * data structures for later, etc. 351bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 352bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when a libusb user initializes the library 353bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * prior to use. 354bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 355bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return 0 on success, or a LIBUSB_ERROR code on failure. 356bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 357bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*init)(struct libusb_context *ctx); 358bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 359bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Deinitialization. Optional. This function should destroy anything 360bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * that was set up by init. 361bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 362bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when the user deinitializes the library. 363bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 364bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev void (*exit)(void); 365bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 366bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Enumerate all the USB devices on the system, returning them in a list 367bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * of discovered devices. 368bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 369bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Your implementation should enumerate all devices on the system, 370bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * regardless of whether they have been seen before or not. 371bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 372bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * When you have found a device, compute a session ID for it. The session 373bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * ID should uniquely represent that particular device for that particular 374bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * connection session since boot (i.e. if you disconnect and reconnect a 375bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device immediately after, it should be assigned a different session ID). 376bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If your OS cannot provide a unique session ID as described above, 377bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * presenting a session ID of (bus_number << 8 | device_address) should 378bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * be sufficient. Bus numbers and device addresses wrap and get reused, 379bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * but that is an unlikely case. 380bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 381bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * After computing a session ID for a device, call 382bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * usbi_get_device_by_session_id(). This function checks if libusb already 383bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * knows about the device, and if so, it provides you with a libusb_device 384bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * structure for it. 385bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 386bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If usbi_get_device_by_session_id() returns NULL, it is time to allocate 387bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * a new device structure for the device. Call usbi_alloc_device() to 388bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * obtain a new libusb_device structure with reference count 1. Populate 389bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * the bus_number and device_address attributes of the new device, and 390bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * perform any other internal backend initialization you need to do. At 391bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * this point, you should be ready to provide device descriptors and so 392bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * on through the get_*_descriptor functions. Finally, call 393bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * usbi_sanitize_device() to perform some final sanity checks on the 394bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device. Assuming all of the above succeeded, we can now continue. 395bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If any of the above failed, remember to unreference the device that 396bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was returned by usbi_alloc_device(). 397bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 398bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * At this stage we have a populated libusb_device structure (either one 399bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * that was found earlier, or one that we have just allocated and 400bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * populated). This can now be added to the discovered devices list 401bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * using discovered_devs_append(). Note that discovered_devs_append() 402bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * may reallocate the list, returning a new location for it, and also 403bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * note that reallocation can fail. Your backend should handle these 404bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * error conditions appropriately. 405bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 406bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function should not generate any bus I/O and should not block. 407bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If I/O is required (e.g. reading the active configuration value), it is 408bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * OK to ignore these suggestions :) 409bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 410bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is executed when the user wishes to retrieve a list 411bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * of USB devices connected to the system. 412bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 413bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return 0 on success, or a LIBUSB_ERROR code on failure. 414bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 415bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*get_device_list)(struct libusb_context *ctx, 416bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct discovered_devs **discdevs); 417bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 418bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Open a device for I/O and other USB operations. The device handle 419bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * is preallocated for you, you can retrieve the device in question 420bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * through handle->dev. 421bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 422bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Your backend should allocate any internal resources required for I/O 423bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * and other operations so that those operations can happen (hopefully) 424bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * without hiccup. This is also a good place to inform libusb that it 425bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * should monitor certain file descriptors related to this device - 426bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * see the usbi_add_pollfd() function. 427bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 428bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function should not generate any bus I/O and should not block. 429bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 430bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when the user attempts to obtain a device 431bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * handle for a device. 432bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 433bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 434bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 435bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_ACCESS if the user has insufficient permissions 436bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since 437bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * discovery 438bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 439bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 440bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Do not worry about freeing the handle on failed open, the upper layers 441bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * do this for you. 442bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 443bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*open)(struct libusb_device_handle *handle); 444bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 445bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Close a device such that the handle cannot be used again. Your backend 446bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * should destroy any resources that were allocated in the open path. 447bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This may also be a good place to call usbi_remove_pollfd() to inform 448bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * libusb of any file descriptors associated with this device that should 449bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * no longer be monitored. 450bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 451bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when the user closes a device handle. 452bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 453bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev void (*close)(struct libusb_device_handle *handle); 454bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 455bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Retrieve the device descriptor from a device. 456bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 457bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The descriptor should be retrieved from memory, NOT via bus I/O to the 458bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device. This means that you may have to cache it in a private structure 459bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * during get_device_list enumeration. Alternatively, you may be able 460bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * to retrieve it from a kernel interface (some Linux setups can do this) 461bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * still without generating bus I/O. 462bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 463bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to write DEVICE_DESC_LENGTH (18) bytes into 464bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * buffer, which is guaranteed to be big enough. 465bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 466bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when sanity-checking a device before adding 467bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * it to the list of discovered devices, and also when the user requests 468bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * to read the device descriptor. 469bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 470bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to return the descriptor in bus-endian format 471bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * (LE). If it returns the multi-byte values in host-endian format, 472bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * set the host_endian output parameter to "1". 473bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 474bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return 0 on success or a LIBUSB_ERROR code on failure. 475bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 476bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*get_device_descriptor)(struct libusb_device *device, 477bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned char *buffer, int *host_endian); 478bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 479bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Get the ACTIVE configuration descriptor for a device. 480bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 481bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The descriptor should be retrieved from memory, NOT via bus I/O to the 482bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device. This means that you may have to cache it in a private structure 483bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * during get_device_list enumeration. You may also have to keep track 484bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * of which configuration is active when the user changes it. 485bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 486bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to write len bytes of data into buffer, which 487bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * is guaranteed to be big enough. If you can only do a partial write, 488bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * return an error code. 489bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 490bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to return the descriptor in bus-endian format 491bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * (LE). If it returns the multi-byte values in host-endian format, 492bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * set the host_endian output parameter to "1". 493bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 494bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 495bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 496bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if the device is in unconfigured state 497bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 498bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 499bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*get_active_config_descriptor)(struct libusb_device *device, 500bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned char *buffer, size_t len, int *host_endian); 501bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 502bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Get a specific configuration descriptor for a device. 503bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 504bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The descriptor should be retrieved from memory, NOT via bus I/O to the 505bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device. This means that you may have to cache it in a private structure 506bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * during get_device_list enumeration. 507bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 508bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The requested descriptor is expressed as a zero-based index (i.e. 0 509bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * indicates that we are requesting the first descriptor). The index does 510bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * not (necessarily) equal the bConfigurationValue of the configuration 511bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * being requested. 512bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 513bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to write len bytes of data into buffer, which 514bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * is guaranteed to be big enough. If you can only do a partial write, 515bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * return an error code. 516bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 517bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is expected to return the descriptor in bus-endian format 518bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * (LE). If it returns the multi-byte values in host-endian format, 519bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * set the host_endian output parameter to "1". 520bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 521bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return 0 on success or a LIBUSB_ERROR code on failure. 522bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 523bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*get_config_descriptor)(struct libusb_device *device, 524bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev uint8_t config_index, unsigned char *buffer, size_t len, 525bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int *host_endian); 526bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 527bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Get the bConfigurationValue for the active configuration for a device. 528bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Optional. This should only be implemented if you can retrieve it from 529bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * cache (don't generate I/O). 530bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 531bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If you cannot retrieve this from cache, either do not implement this 532bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * function, or return LIBUSB_ERROR_NOT_SUPPORTED. This will cause 533bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * libusb to retrieve the information through a standard control transfer. 534bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 535bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function must be non-blocking. 536bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 537bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 538bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 539bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 540bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_SUPPORTED if the value cannot be retrieved without 541bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * blocking 542bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure. 543bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 544bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*get_configuration)(struct libusb_device_handle *handle, int *config); 545bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 546bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Set the active configuration for a device. 547bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 548bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * A configuration value of -1 should put the device in unconfigured state. 549bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 550bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function can block. 551bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 552bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 553bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 554bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if the configuration does not exist 555bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_BUSY if interfaces are currently claimed (and hence 556bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * configuration cannot be changed) 557bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 558bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 559bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure. 560bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 561bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*set_configuration)(struct libusb_device_handle *handle, int config); 562bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 563bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Claim an interface. When claimed, the application can then perform 564bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * I/O to an interface's endpoints. 565bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 566bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function should not generate any bus I/O and should not block. 567bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Interface claiming is a logical operation that simply ensures that 568bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * no other drivers/applications are using the interface, and after 569bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * claiming, no other drivers/applicatiosn can use the interface because 570bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * we now "own" it. 571bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 572bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 573bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 574bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if the interface does not exist 575bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_BUSY if the interface is in use by another driver/app 576bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 577bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 578bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 579bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 580bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*claim_interface)(struct libusb_device_handle *handle, int iface); 581bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 582bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Release a previously claimed interface. 583bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 584bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function should also generate a SET_INTERFACE control request, 585bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * resetting the alternate setting of that interface to 0. It's OK for 586bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * this function to block as a result. 587bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 588bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * You will only ever be asked to release an interface which was 589bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * successfully claimed earlier. 590bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 591bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 592bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 593bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 594bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 595bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 596bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 597bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*release_interface)(struct libusb_device_handle *handle, int iface); 598bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 599bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Set the alternate setting for an interface. 600bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 601bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * You will only ever be asked to set the alternate setting for an 602bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * interface which was successfully claimed earlier. 603bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 604bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * It's OK for this function to block. 605bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 606bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 607bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 608bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if the alternate setting does not exist 609bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 610bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 611bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 612bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 613bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*set_interface_altsetting)(struct libusb_device_handle *handle, 614bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int iface, int altsetting); 615bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 616bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Clear a halt/stall condition on an endpoint. 617bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 618bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * It's OK for this function to block. 619bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 620bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 621bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 622bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist 623bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 624bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 625bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 626bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 627bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*clear_halt)(struct libusb_device_handle *handle, 628bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev unsigned char endpoint); 629bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 630bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Perform a USB port reset to reinitialize a device. 631bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 632bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If possible, the handle should still be usable after the reset 633bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * completes, assuming that the device descriptors did not change during 634bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * reset and all previous interface state can be restored. 635bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 636bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * If something changes, or you cannot easily locate/verify the resetted 637bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device, return LIBUSB_ERROR_NOT_FOUND. This prompts the application 638bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * to close the old handle and re-enumerate the device. 639bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 640bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 641bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 642bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the device 643bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * has been disconnected since it was opened 644bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 645bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 646bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*reset_device)(struct libusb_device_handle *handle); 647bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 648bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Determine if a kernel driver is active on an interface. Optional. 649bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 650bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The presence of a kernel driver on an interface indicates that any 651bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * calls to claim_interface would fail with the LIBUSB_ERROR_BUSY code. 652bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 653bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 654bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 if no driver is active 655bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 1 if a driver is active 656bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 657bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 658bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 659bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 660bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*kernel_driver_active)(struct libusb_device_handle *handle, 661bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int interface); 662bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 663bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Detach a kernel driver from an interface. Optional. 664bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 665bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * After detaching a kernel driver, the interface should be available 666bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * for claim. 667bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 668bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 669bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 670bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active 671bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist 672bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 673bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 674bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 675bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 676bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*detach_kernel_driver)(struct libusb_device_handle *handle, 677bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int interface); 678bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 679bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Attach a kernel driver to an interface. Optional. 680bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 681bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Reattach a kernel driver to the device. 682bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 683bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 684bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 685bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NOT_FOUND if no kernel driver was active 686bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_INVALID_PARAM if the interface does not exist 687bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected since it 688bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * was opened 689bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_BUSY if a program or driver has claimed the interface, 690bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * preventing reattachment 691bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 692bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 693bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*attach_kernel_driver)(struct libusb_device_handle *handle, 694bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int interface); 695bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 696bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Destroy a device. Optional. 697bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 698bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function is called when the last reference to a device is 699bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * destroyed. It should free any resources allocated in the get_device_list 700bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * path. 701bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 702bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev void (*destroy_device)(struct libusb_device *dev); 703bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 704bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Submit a transfer. Your implementation should take the transfer, 705bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * morph it into whatever form your platform requires, and submit it 706bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * asynchronously. 707bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 708bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function must not block. 709bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 710bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return: 711bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - 0 on success 712bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - LIBUSB_ERROR_NO_DEVICE if the device has been disconnected 713bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * - another LIBUSB_ERROR code on other failure 714bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 715bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*submit_transfer)(struct usbi_transfer *itransfer); 716bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 717bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Cancel a previously submitted transfer. 718bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 719bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function must not block. The transfer cancellation must complete 720bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * later, resulting in a call to usbi_handle_transfer_cancellation() 721bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * from the context of handle_events. 722bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 723bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*cancel_transfer)(struct usbi_transfer *itransfer); 724bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 725bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Clear a transfer as if it has completed or cancelled, but do not 726bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * report any completion/cancellation to the library. You should free 727bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * all private data from the transfer as if you were just about to report 728bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * completion or cancellation. 729bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 730bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function might seem a bit out of place. It is used when libusb 731bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * detects a disconnected device - it calls this function for all pending 732bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * transfers before reporting completion (with the disconnect code) to 733bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * the user. Maybe we can improve upon this internal interface in future. 734bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 735bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev void (*clear_transfer_priv)(struct usbi_transfer *itransfer); 736bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 737bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Handle any pending events. This involves monitoring any active 738bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * transfers and processing their completion or cancellation. 739bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 740bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * The function is passed an array of pollfd structures (size nfds) 741bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * as a result of the poll() system call. The num_ready parameter 742bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * indicates the number of file descriptors that have reported events 743bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * (i.e. the poll() return value). This should be enough information 744bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * for you to determine which actions need to be taken on the currently 745bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * active transfers. 746bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 747bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * For any cancelled transfers, call usbi_handle_transfer_cancellation(). 748bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * For completed transfers, call usbi_handle_transfer_completion(). 749bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * For control/bulk/interrupt transfers, populate the "transferred" 750bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * element of the appropriate usbi_transfer structure before calling the 751bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * above functions. For isochronous transfers, populate the status and 752bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * transferred fields of the iso packet descriptors of the transfer. 753bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 754bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This function should also be able to detect disconnection of the 755bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * device, reporting that situation with usbi_handle_disconnect(). 756bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 757bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * When processing an event related to a transfer, you probably want to 758bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * take usbi_transfer.lock to prevent races. See the documentation for 759bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * the usbi_transfer structure. 760bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * 761bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Return 0 on success, or a LIBUSB_ERROR code on failure. 762bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 763bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*handle_events)(struct libusb_context *ctx, 764bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev struct pollfd *fds, nfds_t nfds, int num_ready); 765bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 766bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Get time from specified clock. At least two clocks must be implemented 767bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev by the backend: USBI_CLOCK_REALTIME, and USBI_CLOCK_MONOTONIC. 768bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 769bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev Description of clocks: 770bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev USBI_CLOCK_REALTIME : clock returns time since system epoch. 771bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev USBI_CLOCK_MONOTONIC: clock returns time since unspecified start 772bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev time (usually boot). 773bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 774bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev int (*clock_gettime)(int clkid, struct timespec *tp); 775bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 776bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#ifdef USBI_TIMERFD_AVAILABLE 777bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* clock ID of the clock that should be used for timerfd */ 778bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev clockid_t (*get_timerfd_clockid)(void); 779bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 780bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 781bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Number of bytes to reserve for per-device private backend data. 782bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This private data area is accessible through the "os_priv" field of 783bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * struct libusb_device. */ 784bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t device_priv_size; 785bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 786bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Number of bytes to reserve for per-handle private backend data. 787bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This private data area is accessible through the "os_priv" field of 788bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * struct libusb_device. */ 789bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t device_handle_priv_size; 790bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 791bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Number of bytes to reserve for per-transfer private backend data. 792bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * This private data area is accessible by calling 793bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * usbi_transfer_get_os_priv() on the appropriate usbi_transfer instance. 794bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev */ 795bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t transfer_priv_size; 796bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 797bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* Mumber of additional bytes for os_priv for each iso packet. 798bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * Can your backend use this? */ 799bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev /* FIXME: linux can't use this any more. if other OS's cannot either, 800bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev * then remove this */ 801bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev size_t add_iso_packet_size; 802bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev}; 803bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 804bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevextern const struct usbi_os_backend * const usbi_backend; 805bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 806bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevextern const struct usbi_os_backend linux_usbfs_backend; 807bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishevextern const struct usbi_os_backend darwin_backend; 808bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 809bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev#endif 810bda86ae8203fd360c4e87c310498da1e1e4c53a7Yavor Goulishev 811