2 * Copyright (c) 2009 Andrew Thompson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 * $FreeBSD: head/sys/dev/usb/usbdi.h 267240 2014-06-08 20:10:29Z hselasky $
32 struct usb_attach_arg
;
35 struct usb_page_cache
;
36 struct usb_page_search
;
40 struct usb_fs_privdata
;
43 typedef enum { /* keep in sync with usb_errstr_table */
44 USB_ERR_NORMAL_COMPLETION
= 0,
45 USB_ERR_PENDING_REQUESTS
, /* 1 */
46 USB_ERR_NOT_STARTED
, /* 2 */
47 USB_ERR_INVAL
, /* 3 */
48 USB_ERR_NOMEM
, /* 4 */
49 USB_ERR_CANCELLED
, /* 5 */
50 USB_ERR_BAD_ADDRESS
, /* 6 */
51 USB_ERR_BAD_BUFSIZE
, /* 7 */
52 USB_ERR_BAD_FLAG
, /* 8 */
53 USB_ERR_NO_CALLBACK
, /* 9 */
54 USB_ERR_IN_USE
, /* 10 */
55 USB_ERR_NO_ADDR
, /* 11 */
56 USB_ERR_NO_PIPE
, /* 12 */
57 USB_ERR_ZERO_NFRAMES
, /* 13 */
58 USB_ERR_ZERO_MAXP
, /* 14 */
59 USB_ERR_SET_ADDR_FAILED
, /* 15 */
60 USB_ERR_NO_POWER
, /* 16 */
61 USB_ERR_TOO_DEEP
, /* 17 */
62 USB_ERR_IOERROR
, /* 18 */
63 USB_ERR_NOT_CONFIGURED
, /* 19 */
64 USB_ERR_TIMEOUT
, /* 20 */
65 USB_ERR_SHORT_XFER
, /* 21 */
66 USB_ERR_STALLED
, /* 22 */
67 USB_ERR_INTERRUPTED
, /* 23 */
68 USB_ERR_DMA_LOAD_FAILED
, /* 24 */
69 USB_ERR_BAD_CONTEXT
, /* 25 */
70 USB_ERR_NO_ROOT_HUB
, /* 26 */
71 USB_ERR_NO_INTR_THREAD
, /* 27 */
72 USB_ERR_NOT_LOCKED
, /* 28 */
79 #define USB_FORCE_SHORT_XFER 0x0001 /* force a short transmit last */
80 #define USB_SHORT_XFER_OK 0x0004 /* allow short reads */
81 #define USB_DELAY_STATUS_STAGE 0x0010 /* insert delay before STATUS stage */
82 #define USB_USER_DATA_PTR 0x0020 /* internal flag */
83 #define USB_MULTI_SHORT_OK 0x0040 /* allow multiple short frames */
84 #define USB_MANUAL_STATUS 0x0080 /* manual ctrl status */
86 #define USB_NO_TIMEOUT 0
87 #define USB_DEFAULT_TIMEOUT 5000 /* 5000 ms = 5 seconds */
92 typedef void (usb_callback_t
)(struct usb_xfer
*, usb_error_t
);
93 typedef void (usb_proc_callback_t
)(struct usb_proc_msg
*);
94 typedef usb_error_t (usb_handle_req_t
)(struct usb_device
*,
95 struct usb_device_request
*, const void **, uint16_t *);
97 typedef int (usb_fifo_open_t
)(struct usb_fifo
*fifo
, int fflags
);
98 typedef void (usb_fifo_close_t
)(struct usb_fifo
*fifo
, int fflags
);
99 typedef int (usb_fifo_ioctl_t
)(struct usb_fifo
*fifo
, u_long cmd
, void *addr
, int fflags
);
100 typedef void (usb_fifo_cmd_t
)(struct usb_fifo
*fifo
);
101 typedef void (usb_fifo_filter_t
)(struct usb_fifo
*fifo
, struct usb_mbuf
*m
);
105 #include <sys/eventhandler.h>
106 typedef void (*usb_dev_configured_t
)(void *, struct usb_device
*,
107 struct usb_attach_arg
*);
108 EVENTHANDLER_DECLARE(usb_dev_configured
, usb_dev_configured_t
);
111 * The following macros are used used to convert milliseconds into
112 * HZ. We use 1024 instead of 1000 milliseconds per second to save a
115 #define USB_MS_HZ 1024
117 #define USB_MS_TO_TICKS(ms) \
118 (((uint32_t)((((uint32_t)(ms)) * ((uint32_t)(hz))) + USB_MS_HZ - 1)) / USB_MS_HZ)
121 * Common queue structure for USB transfers.
123 struct usb_xfer_queue
{
124 TAILQ_HEAD(, usb_xfer
) head
;
125 struct usb_xfer
*curr
; /* current USB transfer processed */
126 void (*command
) (struct usb_xfer_queue
*pq
);
132 * The following structure defines an USB endpoint
135 struct usb_endpoint
{
136 /* queue of USB transfers */
137 struct usb_xfer_queue endpoint_q
[USB_MAX_EP_STREAMS
];
139 struct usb_endpoint_descriptor
*edesc
;
140 struct usb_endpoint_ss_comp_descriptor
*ecomp
;
141 const struct usb_pipe_methods
*methods
; /* set by HC driver */
145 uint8_t toggle_next
:1; /* next data toggle value */
146 uint8_t is_stalled
:1; /* set if endpoint is stalled */
147 uint8_t is_synced
:1; /* set if we a synchronised */
149 uint8_t iface_index
; /* not used by "default endpoint" */
151 uint8_t refcount_alloc
; /* allocation refcount */
152 uint8_t refcount_bw
; /* bandwidth refcount */
153 #define USB_EP_REF_MAX 0x3f
155 /* High-Speed resource allocation (valid if "refcount_bw" > 0) */
157 uint8_t usb_smask
; /* USB start mask */
158 uint8_t usb_cmask
; /* USB complete mask */
159 uint8_t usb_uframe
; /* USB microframe */
161 /* USB endpoint mode, see USB_EP_MODE_XXX */
167 * The following structure defines an USB interface.
169 struct usb_interface
{
170 struct usb_interface_descriptor
*idesc
;
173 uint8_t parent_iface_index
;
176 struct usb_host_interface
*altsetting
;
177 struct usb_host_interface
*cur_altsetting
;
178 struct usb_device
*linux_udev
;
179 void *bsd_priv_sc
; /* device specific information */
180 char *pnpinfo
; /* additional PnP-info for this interface */
181 uint8_t num_altsetting
; /* number of alternate settings */
182 uint8_t bsd_iface_index
;
186 * The following structure defines a set of USB transfer flags.
188 struct usb_xfer_flags
{
189 uint8_t force_short_xfer
:1; /* force a short transmit transfer
191 uint8_t short_xfer_ok
:1; /* allow short receive transfers */
192 uint8_t short_frames_ok
:1; /* allow short frames */
193 uint8_t pipe_bof
:1; /* block pipe on failure */
194 uint8_t proxy_buffer
:1; /* makes buffer size a factor of
195 * "max_frame_size" */
196 uint8_t ext_buffer
:1; /* uses external DMA buffer */
197 uint8_t manual_status
:1; /* non automatic status stage on
198 * control transfers */
199 uint8_t no_pipe_ok
:1; /* set if "USB_ERR_NO_PIPE" error can
201 uint8_t stall_pipe
:1; /* set if the endpoint belonging to
202 * this USB transfer should be stalled
203 * before starting this transfer! */
204 uint8_t pre_scale_frames
:1; /* "usb_config->frames" is
205 * assumed to give the
207 * milliseconds and is
208 * converted into the nearest
209 * number of frames when the
210 * USB transfer is setup. This
211 * option only has effect for
212 * ISOCHRONOUS transfers.
217 * The following structure define an USB configuration, that basically
218 * is used when setting up an USB transfer.
221 usb_callback_t
*callback
; /* USB transfer callback */
222 usb_frlength_t bufsize
; /* total pipe buffer size in bytes */
223 usb_frcount_t frames
; /* maximum number of USB frames */
224 usb_timeout_t interval
; /* interval in milliseconds */
225 #define USB_DEFAULT_INTERVAL 0
226 usb_timeout_t timeout
; /* transfer timeout in milliseconds */
227 struct usb_xfer_flags flags
; /* transfer flags */
228 usb_stream_t stream_id
; /* USB3.0 specific */
229 enum usb_hc_mode usb_mode
; /* host or device mode */
230 uint8_t type
; /* pipe type */
231 uint8_t endpoint
; /* pipe number */
232 uint8_t direction
; /* pipe direction */
233 uint8_t ep_index
; /* pipe index match to use */
234 uint8_t if_index
; /* "ifaces" index to use */
238 * Use these macro when defining USB device ID arrays if you want to
239 * have your driver module automatically loaded in host, device or
240 * both modes respectivly:
242 #if USB_HAVE_ID_SECTION
243 #define STRUCT_USB_HOST_ID \
244 struct usb_device_id __section("usb_host_id")
245 #define STRUCT_USB_DEVICE_ID \
246 struct usb_device_id __section("usb_device_id")
247 #define STRUCT_USB_DUAL_ID \
248 struct usb_device_id __section("usb_dual_id")
250 #define STRUCT_USB_HOST_ID \
252 #define STRUCT_USB_DEVICE_ID \
254 #define STRUCT_USB_DUAL_ID \
256 #endif /* USB_HAVE_ID_SECTION */
259 * The following structure is used when looking up an USB driver for
260 * an USB device. It is inspired by the Linux structure called
263 struct usb_device_id
{
265 /* Hook for driver specific information */
266 unsigned long driver_info
;
268 /* Used for product specific matches; the BCD range is inclusive */
271 uint16_t bcdDevice_lo
;
272 uint16_t bcdDevice_hi
;
274 /* Used for device class matches */
275 uint8_t bDeviceClass
;
276 uint8_t bDeviceSubClass
;
277 uint8_t bDeviceProtocol
;
279 /* Used for interface class matches */
280 uint8_t bInterfaceClass
;
281 uint8_t bInterfaceSubClass
;
282 uint8_t bInterfaceProtocol
;
284 /* Select which fields to match against */
285 uint8_t match_flag_vendor
:1;
286 uint8_t match_flag_product
:1;
287 uint8_t match_flag_dev_lo
:1;
288 uint8_t match_flag_dev_hi
:1;
290 uint8_t match_flag_dev_class
:1;
291 uint8_t match_flag_dev_subclass
:1;
292 uint8_t match_flag_dev_protocol
:1;
293 uint8_t match_flag_int_class
:1;
295 uint8_t match_flag_int_subclass
:1;
296 uint8_t match_flag_int_protocol
:1;
297 uint8_t match_flag_unused
:6;
299 #if USB_HAVE_COMPAT_LINUX
300 /* which fields to match against */
301 uint16_t match_flags
;
302 #define USB_DEVICE_ID_MATCH_VENDOR 0x0001
303 #define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
304 #define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
305 #define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
306 #define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
307 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
308 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
309 #define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
310 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
311 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
315 /* check that the size of the structure above is correct */
316 extern char usb_device_id_assert
[(sizeof(struct usb_device_id
) == 32) ? 1 : -1];
318 #define USB_VENDOR(vend) \
319 .match_flag_vendor = 1, .idVendor = (vend)
321 #define USB_PRODUCT(prod) \
322 .match_flag_product = 1, .idProduct = (prod)
324 #define USB_VP(vend,prod) \
325 USB_VENDOR(vend), USB_PRODUCT(prod)
327 #define USB_VPI(vend,prod,info) \
328 USB_VENDOR(vend), USB_PRODUCT(prod), USB_DRIVER_INFO(info)
330 #define USB_DEV_BCD_GTEQ(lo) /* greater than or equal */ \
331 .match_flag_dev_lo = 1, .bcdDevice_lo = (lo)
333 #define USB_DEV_BCD_LTEQ(hi) /* less than or equal */ \
334 .match_flag_dev_hi = 1, .bcdDevice_hi = (hi)
336 #define USB_DEV_CLASS(dc) \
337 .match_flag_dev_class = 1, .bDeviceClass = (dc)
339 #define USB_DEV_SUBCLASS(dsc) \
340 .match_flag_dev_subclass = 1, .bDeviceSubClass = (dsc)
342 #define USB_DEV_PROTOCOL(dp) \
343 .match_flag_dev_protocol = 1, .bDeviceProtocol = (dp)
345 #define USB_IFACE_CLASS(ic) \
346 .match_flag_int_class = 1, .bInterfaceClass = (ic)
348 #define USB_IFACE_SUBCLASS(isc) \
349 .match_flag_int_subclass = 1, .bInterfaceSubClass = (isc)
351 #define USB_IFACE_PROTOCOL(ip) \
352 .match_flag_int_protocol = 1, .bInterfaceProtocol = (ip)
354 #define USB_IF_CSI(class,subclass,info) \
355 USB_IFACE_CLASS(class), USB_IFACE_SUBCLASS(subclass), USB_DRIVER_INFO(info)
357 #define USB_DRIVER_INFO(n) \
360 #define USB_GET_DRIVER_INFO(did) \
364 * The following structure keeps information that is used to match
365 * against an array of "usb_device_id" elements.
367 struct usbd_lookup_info
{
371 uint8_t bDeviceClass
;
372 uint8_t bDeviceSubClass
;
373 uint8_t bDeviceProtocol
;
374 uint8_t bInterfaceClass
;
375 uint8_t bInterfaceSubClass
;
376 uint8_t bInterfaceProtocol
;
379 uint8_t bConfigIndex
;
383 /* Structure used by probe and attach */
385 struct usb_attach_arg
{
386 struct usbd_lookup_info info
;
387 device_t temp_dev
; /* for internal use */
388 unsigned long driver_info
; /* for internal use */
390 struct usb_device
*device
; /* current device */
391 struct usb_interface
*iface
; /* current interface */
392 enum usb_hc_mode usb_mode
; /* host or device mode */
395 #define UAA_DEV_READY 0
396 #define UAA_DEV_DISABLED 1
397 #define UAA_DEV_EJECTING 2
401 * The following is a wrapper for the callout structure to ease
402 * porting the code to other platforms.
408 #define usb_callout_init_mtx(c,m,f) callout_init_lk(&(c)->co, m)
409 #define usb_callout_reset(c,t,f,d) callout_reset(&(c)->co, t, f, d)
410 #define usb_callout_stop(c) callout_stop(&(c)->co)
411 #define usb_callout_drain(c) callout_stop_sync(&(c)->co)
412 #define usb_callout_pending(c) callout_pending(&(c)->co)
414 /* USB transfer states */
416 #define USB_ST_SETUP 0
417 #define USB_ST_TRANSFERRED 1
418 #define USB_ST_ERROR 2
420 /* USB handle request states */
421 #define USB_HR_NOT_COMPLETE 0
422 #define USB_HR_COMPLETE_OK 1
423 #define USB_HR_COMPLETE_ERR 2
426 * The following macro will return the current state of an USB
427 * transfer like defined by the "USB_ST_XXX" enums.
429 #define USB_GET_STATE(xfer) (usbd_xfer_state(xfer))
432 * The following structure defines the USB process message header.
434 struct usb_proc_msg
{
435 TAILQ_ENTRY(usb_proc_msg
) pm_qentry
;
436 usb_proc_callback_t
*pm_callback
;
440 #define USB_FIFO_TX 0
441 #define USB_FIFO_RX 1
444 * Locking note for the following functions. All the
445 * "usb_fifo_cmd_t" and "usb_fifo_filter_t" functions are called
446 * locked. The others are called unlocked.
448 struct usb_fifo_methods
{
449 usb_fifo_open_t
*f_open
;
450 usb_fifo_close_t
*f_close
;
451 usb_fifo_ioctl_t
*f_ioctl
;
453 * NOTE: The post-ioctl callback is called after the USB reference
454 * gets locked in the IOCTL handler:
456 usb_fifo_ioctl_t
*f_ioctl_post
;
457 usb_fifo_cmd_t
*f_start_read
;
458 usb_fifo_cmd_t
*f_stop_read
;
459 usb_fifo_cmd_t
*f_start_write
;
460 usb_fifo_cmd_t
*f_stop_write
;
461 usb_fifo_filter_t
*f_filter_read
;
462 usb_fifo_filter_t
*f_filter_write
;
463 const char *basename
[4];
464 const char *postfix
[4];
468 struct usb_fifo
*fp
[2];
469 struct usb_fs_privdata
*dev
;
472 const char *usbd_errstr(usb_error_t error
);
473 void *usbd_find_descriptor(struct usb_device
*udev
, void *id
,
474 uint8_t iface_index
, uint8_t type
, uint8_t type_mask
,
475 uint8_t subtype
, uint8_t subtype_mask
);
476 struct usb_config_descriptor
*usbd_get_config_descriptor(
477 struct usb_device
*udev
);
478 struct usb_device_descriptor
*usbd_get_device_descriptor(
479 struct usb_device
*udev
);
480 struct usb_interface
*usbd_get_iface(struct usb_device
*udev
,
481 uint8_t iface_index
);
482 struct usb_interface_descriptor
*usbd_get_interface_descriptor(
483 struct usb_interface
*iface
);
484 struct usb_endpoint
*usbd_get_endpoint(struct usb_device
*udev
, uint8_t iface_index
,
485 const struct usb_config
*setup
);
486 struct usb_endpoint
*usbd_get_ep_by_addr(struct usb_device
*udev
, uint8_t ea_val
);
487 usb_error_t
usbd_interface_count(struct usb_device
*udev
, uint8_t *count
);
488 enum usb_hc_mode
usbd_get_mode(struct usb_device
*udev
);
489 enum usb_dev_speed
usbd_get_speed(struct usb_device
*udev
);
490 void device_set_usb_desc(device_t dev
);
491 void usb_pause_mtx(struct lock
*lock
, int _ticks
);
492 void usb_pause_ls(struct lock
*lock
, struct lwkt_serialize
*slz
, int _ticks
);
493 usb_error_t
usbd_set_pnpinfo(struct usb_device
*udev
,
494 uint8_t iface_index
, const char *pnpinfo
);
495 usb_error_t
usbd_add_dynamic_quirk(struct usb_device
*udev
,
497 usb_error_t
usbd_set_endpoint_mode(struct usb_device
*udev
,
498 struct usb_endpoint
*ep
, uint8_t ep_mode
);
499 uint8_t usbd_get_endpoint_mode(struct usb_device
*udev
,
500 struct usb_endpoint
*ep
);
502 const struct usb_device_id
*usbd_lookup_id_by_info(
503 const struct usb_device_id
*id
, usb_size_t sizeof_id
,
504 const struct usbd_lookup_info
*info
);
505 int usbd_lookup_id_by_uaa(const struct usb_device_id
*id
,
506 usb_size_t sizeof_id
, struct usb_attach_arg
*uaa
);
508 usb_error_t
usbd_do_request_flags(struct usb_device
*udev
, struct lock
*lock
,
509 struct usb_device_request
*req
, void *data
, uint16_t flags
,
510 uint16_t *actlen
, usb_timeout_t timeout
);
511 #define usbd_do_request(u,m,r,d) \
512 usbd_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT)
514 uint8_t usbd_clear_stall_callback(struct usb_xfer
*xfer1
,
515 struct usb_xfer
*xfer2
);
516 uint8_t usbd_get_interface_altindex(struct usb_interface
*iface
);
517 usb_error_t
usbd_set_alt_interface_index(struct usb_device
*udev
,
518 uint8_t iface_index
, uint8_t alt_index
);
519 uint32_t usbd_get_isoc_fps(struct usb_device
*udev
);
520 usb_error_t
usbd_transfer_setup(struct usb_device
*udev
,
521 const uint8_t *ifaces
, struct usb_xfer
**pxfer
,
522 const struct usb_config
*setup_start
, uint16_t n_setup
,
523 void *priv_sc
, struct lock
*priv_lock
);
524 void usbd_transfer_submit(struct usb_xfer
*xfer
);
525 void usbd_transfer_clear_stall(struct usb_xfer
*xfer
);
526 void usbd_transfer_drain(struct usb_xfer
*xfer
);
527 uint8_t usbd_transfer_pending(struct usb_xfer
*xfer
);
528 void usbd_transfer_start(struct usb_xfer
*xfer
);
529 void usbd_transfer_stop(struct usb_xfer
*xfer
);
530 void usbd_transfer_unsetup(struct usb_xfer
**pxfer
, uint16_t n_setup
);
531 void usbd_transfer_poll(struct usb_xfer
**ppxfer
, uint16_t max
);
532 void usbd_set_parent_iface(struct usb_device
*udev
, uint8_t iface_index
,
533 uint8_t parent_index
);
534 uint8_t usbd_get_bus_index(struct usb_device
*udev
);
535 uint8_t usbd_get_device_index(struct usb_device
*udev
);
536 void usbd_set_power_mode(struct usb_device
*udev
, uint8_t power_mode
);
537 uint8_t usbd_filter_power_mode(struct usb_device
*udev
, uint8_t power_mode
);
538 uint8_t usbd_device_attached(struct usb_device
*udev
);
541 usbd_xfer_old_frame_length(struct usb_xfer
*xfer
, usb_frcount_t frindex
);
542 void usbd_xfer_status(struct usb_xfer
*xfer
, int *actlen
, int *sumlen
,
543 int *aframes
, int *nframes
);
544 struct usb_page_cache
*usbd_xfer_get_frame(struct usb_xfer
*, usb_frcount_t
);
545 void *usbd_xfer_get_frame_buffer(struct usb_xfer
*, usb_frcount_t
);
546 void *usbd_xfer_softc(struct usb_xfer
*xfer
);
547 void *usbd_xfer_get_priv(struct usb_xfer
*xfer
);
548 void usbd_xfer_set_priv(struct usb_xfer
*xfer
, void *);
549 void usbd_xfer_set_interval(struct usb_xfer
*xfer
, int);
550 uint8_t usbd_xfer_state(struct usb_xfer
*xfer
);
551 void usbd_xfer_set_frame_data(struct usb_xfer
*xfer
, usb_frcount_t frindex
,
552 void *ptr
, usb_frlength_t len
);
553 void usbd_xfer_frame_data(struct usb_xfer
*xfer
, usb_frcount_t frindex
,
554 void **ptr
, int *len
);
555 void usbd_xfer_set_frame_offset(struct usb_xfer
*xfer
, usb_frlength_t offset
,
556 usb_frcount_t frindex
);
557 usb_frlength_t
usbd_xfer_max_len(struct usb_xfer
*xfer
);
558 usb_frlength_t
usbd_xfer_max_framelen(struct usb_xfer
*xfer
);
559 usb_frcount_t
usbd_xfer_max_frames(struct usb_xfer
*xfer
);
560 uint8_t usbd_xfer_get_fps_shift(struct usb_xfer
*xfer
);
561 usb_frlength_t
usbd_xfer_frame_len(struct usb_xfer
*xfer
,
562 usb_frcount_t frindex
);
563 void usbd_xfer_set_frame_len(struct usb_xfer
*xfer
, usb_frcount_t frindex
,
565 void usbd_xfer_set_timeout(struct usb_xfer
*xfer
, int timeout
);
566 void usbd_xfer_set_frames(struct usb_xfer
*xfer
, usb_frcount_t n
);
567 void usbd_xfer_set_stall(struct usb_xfer
*xfer
);
568 int usbd_xfer_is_stalled(struct usb_xfer
*xfer
);
569 void usbd_xfer_set_flag(struct usb_xfer
*xfer
, int flag
);
570 void usbd_xfer_clr_flag(struct usb_xfer
*xfer
, int flag
);
571 uint16_t usbd_xfer_get_timestamp(struct usb_xfer
*xfer
);
572 uint8_t usbd_xfer_maxp_was_clamped(struct usb_xfer
*xfer
);
574 void usbd_copy_in(struct usb_page_cache
*cache
, usb_frlength_t offset
,
575 const void *ptr
, usb_frlength_t len
);
576 int usbd_copy_in_user(struct usb_page_cache
*cache
, usb_frlength_t offset
,
577 const void *ptr
, usb_frlength_t len
);
578 void usbd_copy_out(struct usb_page_cache
*cache
, usb_frlength_t offset
,
579 void *ptr
, usb_frlength_t len
);
580 int usbd_copy_out_user(struct usb_page_cache
*cache
, usb_frlength_t offset
,
581 void *ptr
, usb_frlength_t len
);
582 void usbd_get_page(struct usb_page_cache
*pc
, usb_frlength_t offset
,
583 struct usb_page_search
*res
);
584 void usbd_m_copy_in(struct usb_page_cache
*cache
, usb_frlength_t dst_offset
,
585 struct mbuf
*m
, usb_size_t src_offset
, usb_frlength_t src_len
);
586 void usbd_frame_zero(struct usb_page_cache
*cache
, usb_frlength_t offset
,
588 void usbd_start_re_enumerate(struct usb_device
*udev
);
590 usbd_start_set_config(struct usb_device
*, uint8_t);
592 int usb_fifo_attach(struct usb_device
*udev
, void *priv_sc
,
593 struct lock
*priv_lock
, struct usb_fifo_methods
*pm
,
594 struct usb_fifo_sc
*f_sc
, uint16_t unit
, int16_t subunit
,
595 uint8_t iface_index
, uid_t uid
, gid_t gid
, int mode
);
596 void usb_fifo_detach(struct usb_fifo_sc
*f_sc
);
597 int usb_fifo_alloc_buffer(struct usb_fifo
*f
, uint32_t bufsize
,
599 void usb_fifo_free_buffer(struct usb_fifo
*f
);
600 uint32_t usb_fifo_put_bytes_max(struct usb_fifo
*fifo
);
601 void usb_fifo_put_data(struct usb_fifo
*fifo
, struct usb_page_cache
*pc
,
602 usb_frlength_t offset
, usb_frlength_t len
, uint8_t what
);
603 void usb_fifo_put_data_linear(struct usb_fifo
*fifo
, void *ptr
,
604 usb_size_t len
, uint8_t what
);
605 uint8_t usb_fifo_put_data_buffer(struct usb_fifo
*f
, void *ptr
, usb_size_t len
);
606 void usb_fifo_put_data_error(struct usb_fifo
*fifo
);
607 uint8_t usb_fifo_get_data(struct usb_fifo
*fifo
, struct usb_page_cache
*pc
,
608 usb_frlength_t offset
, usb_frlength_t len
, usb_frlength_t
*actlen
,
610 uint8_t usb_fifo_get_data_linear(struct usb_fifo
*fifo
, void *ptr
,
611 usb_size_t len
, usb_size_t
*actlen
, uint8_t what
);
612 uint8_t usb_fifo_get_data_buffer(struct usb_fifo
*f
, void **pptr
,
614 void usb_fifo_reset(struct usb_fifo
*f
);
615 void usb_fifo_wakeup(struct usb_fifo
*f
);
616 void usb_fifo_get_data_error(struct usb_fifo
*fifo
);
617 void *usb_fifo_softc(struct usb_fifo
*fifo
);
618 void usb_fifo_set_close_zlp(struct usb_fifo
*, uint8_t);
619 void usb_fifo_set_write_defrag(struct usb_fifo
*, uint8_t);
620 void usb_fifo_free(struct usb_fifo
*f
);
622 #endif /* _USB_USBDI_H_ */