The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/usbdi.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2009 Andrew Thompson
    3  *
    4  * Redistribution and use in source and binary forms, with or without
    5  * modification, are permitted provided that the following conditions
    6  * are met:
    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.
   12  *
   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.
   23  *
   24  * $FreeBSD: releng/11.2/sys/dev/usb/usbdi.h 331722 2018-03-29 02:50:57Z eadler $
   25  */
   26 #ifndef _USB_USBDI_H_
   27 #define _USB_USBDI_H_
   28 
   29 struct usb_fifo;
   30 struct usb_xfer;
   31 struct usb_device;
   32 struct usb_attach_arg;
   33 struct usb_interface;
   34 struct usb_endpoint;
   35 struct usb_page_cache;
   36 struct usb_page_search;
   37 struct usb_process;
   38 struct usb_proc_msg;
   39 struct usb_mbuf;
   40 struct usb_fs_privdata;
   41 struct mbuf;
   42 
   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 */
   73         USB_ERR_MAX
   74 } usb_error_t;
   75 
   76 /*
   77  * Flags for transfers
   78  */
   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 */
   85 
   86 #define USB_NO_TIMEOUT 0
   87 #define USB_DEFAULT_TIMEOUT 5000        /* 5000 ms = 5 seconds */
   88 
   89 #if defined(_KERNEL)
   90 /* typedefs */
   91 
   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 *);
   96 
   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);
  102 
  103 
  104 /* USB events */
  105 #ifndef USB_GLOBAL_INCLUDE_FILE
  106 #include <sys/eventhandler.h>
  107 #endif
  108 typedef void (*usb_dev_configured_t)(void *, struct usb_device *,
  109     struct usb_attach_arg *);
  110 EVENTHANDLER_DECLARE(usb_dev_configured, usb_dev_configured_t);
  111 
  112 /*
  113  * The following macros are used used to convert milliseconds into
  114  * HZ. We use 1024 instead of 1000 milliseconds per second to save a
  115  * full division.
  116  */
  117 #define USB_MS_HZ 1024
  118 
  119 #define USB_MS_TO_TICKS(ms) \
  120   (((uint32_t)((((uint32_t)(ms)) * ((uint32_t)(hz))) + USB_MS_HZ - 1)) / USB_MS_HZ)
  121 
  122 /*
  123  * Common queue structure for USB transfers.
  124  */
  125 struct usb_xfer_queue {
  126         TAILQ_HEAD(, usb_xfer) head;
  127         struct usb_xfer *curr;          /* current USB transfer processed */
  128         void    (*command) (struct usb_xfer_queue *pq);
  129         uint8_t recurse_1:1;
  130         uint8_t recurse_2:1;
  131         uint8_t recurse_3:1;
  132         uint8_t reserved:5;
  133 };
  134 
  135 /*
  136  * The following structure defines an USB endpoint
  137  * USB endpoint.
  138  */
  139 struct usb_endpoint {
  140         /* queue of USB transfers */
  141         struct usb_xfer_queue endpoint_q[USB_MAX_EP_STREAMS];
  142 
  143         struct usb_endpoint_descriptor *edesc;
  144         struct usb_endpoint_ss_comp_descriptor *ecomp;
  145         const struct usb_pipe_methods *methods; /* set by HC driver */
  146 
  147         uint16_t isoc_next;
  148 
  149         uint8_t toggle_next:1;          /* next data toggle value */
  150         uint8_t is_stalled:1;           /* set if endpoint is stalled */
  151         uint8_t is_synced:1;            /* set if we a synchronised */
  152         uint8_t unused:5;
  153         uint8_t iface_index;            /* not used by "default endpoint" */
  154 
  155         uint8_t refcount_alloc;         /* allocation refcount */
  156         uint8_t refcount_bw;            /* bandwidth refcount */
  157 #define USB_EP_REF_MAX 0x3f
  158 
  159         /* High-Speed resource allocation (valid if "refcount_bw" > 0) */
  160 
  161         uint8_t usb_smask;              /* USB start mask */
  162         uint8_t usb_cmask;              /* USB complete mask */
  163         uint8_t usb_uframe;             /* USB microframe */
  164 
  165         /* USB endpoint mode, see USB_EP_MODE_XXX */
  166 
  167         uint8_t ep_mode;
  168 };
  169 
  170 /*
  171  * The following structure defines an USB interface.
  172  */
  173 struct usb_interface {
  174         struct usb_interface_descriptor *idesc;
  175         device_t subdev;
  176         uint8_t alt_index;
  177         uint8_t parent_iface_index;
  178 
  179         /* Linux compat */
  180         struct usb_host_interface *altsetting;
  181         struct usb_host_interface *cur_altsetting;
  182         struct usb_device *linux_udev;
  183         void   *bsd_priv_sc;            /* device specific information */
  184         char   *pnpinfo;                /* additional PnP-info for this interface */
  185         uint8_t num_altsetting;         /* number of alternate settings */
  186         uint8_t bsd_iface_index;
  187 };
  188 
  189 /*
  190  * The following structure defines a set of USB transfer flags.
  191  */
  192 struct usb_xfer_flags {
  193         uint8_t force_short_xfer:1;     /* force a short transmit transfer
  194                                          * last */
  195         uint8_t short_xfer_ok:1;        /* allow short receive transfers */
  196         uint8_t short_frames_ok:1;      /* allow short frames */
  197         uint8_t pipe_bof:1;             /* block pipe on failure */
  198         uint8_t proxy_buffer:1;         /* makes buffer size a factor of
  199                                          * "max_frame_size" */
  200         uint8_t ext_buffer:1;           /* uses external DMA buffer */
  201         uint8_t manual_status:1;        /* non automatic status stage on
  202                                          * control transfers */
  203         uint8_t no_pipe_ok:1;           /* set if "USB_ERR_NO_PIPE" error can
  204                                          * be ignored */
  205         uint8_t stall_pipe:1;           /* set if the endpoint belonging to
  206                                          * this USB transfer should be stalled
  207                                          * before starting this transfer! */
  208         uint8_t pre_scale_frames:1;     /* "usb_config->frames" is
  209                                          * assumed to give the
  210                                          * buffering time in
  211                                          * milliseconds and is
  212                                          * converted into the nearest
  213                                          * number of frames when the
  214                                          * USB transfer is setup. This
  215                                          * option only has effect for
  216                                          * ISOCHRONOUS transfers.
  217                                          */
  218 };
  219 
  220 /*
  221  * The following structure define an USB configuration, that basically
  222  * is used when setting up an USB transfer.
  223  */
  224 struct usb_config {
  225         usb_callback_t *callback;       /* USB transfer callback */
  226         usb_frlength_t bufsize; /* total pipe buffer size in bytes */
  227         usb_frcount_t frames;           /* maximum number of USB frames */
  228         usb_timeout_t interval; /* interval in milliseconds */
  229 #define USB_DEFAULT_INTERVAL    0
  230         usb_timeout_t timeout;          /* transfer timeout in milliseconds */
  231         struct usb_xfer_flags flags;    /* transfer flags */
  232         usb_stream_t stream_id;         /* USB3.0 specific */
  233         enum usb_hc_mode usb_mode;      /* host or device mode */
  234         uint8_t type;                   /* pipe type */
  235         uint8_t endpoint;               /* pipe number */
  236         uint8_t direction;              /* pipe direction */
  237         uint8_t ep_index;               /* pipe index match to use */
  238         uint8_t if_index;               /* "ifaces" index to use */
  239 };
  240 
  241 /*
  242  * Use these macro when defining USB device ID arrays if you want to
  243  * have your driver module automatically loaded in host, device or
  244  * both modes respectively:
  245  */
  246 #if USB_HAVE_ID_SECTION
  247 #define STRUCT_USB_HOST_ID \
  248     struct usb_device_id __section("usb_host_id")
  249 #define STRUCT_USB_DEVICE_ID \
  250     struct usb_device_id __section("usb_device_id")
  251 #define STRUCT_USB_DUAL_ID \
  252     struct usb_device_id __section("usb_dual_id")
  253 #else
  254 #define STRUCT_USB_HOST_ID \
  255     struct usb_device_id
  256 #define STRUCT_USB_DEVICE_ID \
  257     struct usb_device_id
  258 #define STRUCT_USB_DUAL_ID \
  259     struct usb_device_id
  260 #endif                  /* USB_HAVE_ID_SECTION */
  261 
  262 /*
  263  * The following structure is used when looking up an USB driver for
  264  * an USB device. It is inspired by the Linux structure called
  265  * "usb_device_id".
  266  */
  267 struct usb_device_id {
  268 
  269         /* Select which fields to match against */
  270 #if BYTE_ORDER == LITTLE_ENDIAN
  271         uint16_t
  272                 match_flag_vendor:1,
  273                 match_flag_product:1,
  274                 match_flag_dev_lo:1,
  275                 match_flag_dev_hi:1,
  276 
  277                 match_flag_dev_class:1,
  278                 match_flag_dev_subclass:1,
  279                 match_flag_dev_protocol:1,
  280                 match_flag_int_class:1,
  281 
  282                 match_flag_int_subclass:1,
  283                 match_flag_int_protocol:1,
  284                 match_flag_unused:6;
  285 #else
  286         uint16_t
  287                 match_flag_unused:6,
  288                 match_flag_int_protocol:1,
  289                 match_flag_int_subclass:1,
  290 
  291                 match_flag_int_class:1,
  292                 match_flag_dev_protocol:1,
  293                 match_flag_dev_subclass:1,
  294                 match_flag_dev_class:1,
  295 
  296                 match_flag_dev_hi:1,
  297                 match_flag_dev_lo:1,
  298                 match_flag_product:1,
  299                 match_flag_vendor:1;
  300 #endif
  301 
  302         /* Used for product specific matches; the BCD range is inclusive */
  303         uint16_t idVendor;
  304         uint16_t idProduct;
  305         uint16_t bcdDevice_lo;
  306         uint16_t bcdDevice_hi;
  307 
  308         /* Used for device class matches */
  309         uint8_t bDeviceClass;
  310         uint8_t bDeviceSubClass;
  311         uint8_t bDeviceProtocol;
  312 
  313         /* Used for interface class matches */
  314         uint8_t bInterfaceClass;
  315         uint8_t bInterfaceSubClass;
  316         uint8_t bInterfaceProtocol;
  317 
  318 #if USB_HAVE_COMPAT_LINUX
  319         /* which fields to match against */
  320         uint16_t match_flags;
  321 #define USB_DEVICE_ID_MATCH_VENDOR              0x0001
  322 #define USB_DEVICE_ID_MATCH_PRODUCT             0x0002
  323 #define USB_DEVICE_ID_MATCH_DEV_LO              0x0004
  324 #define USB_DEVICE_ID_MATCH_DEV_HI              0x0008
  325 #define USB_DEVICE_ID_MATCH_DEV_CLASS           0x0010
  326 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS        0x0020
  327 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL        0x0040
  328 #define USB_DEVICE_ID_MATCH_INT_CLASS           0x0080
  329 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100
  330 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200
  331 #endif
  332 
  333         /* Hook for driver specific information */
  334         unsigned long driver_info;
  335 } __aligned(32);
  336 
  337 #define USB_STD_PNP_INFO "M16:mask;U16:vendor;U16:product;L16:release;G16:release;" \
  338         "U8:devclass;U8:devsubclass;U8:devprotocol;" \
  339         "U8:intclass;U8:intsubclass;U8:intprotocol;"
  340 #define USB_STD_PNP_HOST_INFO USB_STD_PNP_INFO "T:mode=host;"
  341 #define USB_STD_PNP_DEVICE_INFO USB_STD_PNP_INFO "T:mode=device;"
  342 #define USB_PNP_HOST_INFO(table)                                        \
  343         MODULE_PNP_INFO(USB_STD_PNP_HOST_INFO, usb, table, table, sizeof(table[0]), \
  344             sizeof(table) / sizeof(table[0]))
  345 #define USB_PNP_DEVICE_INFO(table)                                      \
  346         MODULE_PNP_INFO(USB_STD_PNP_DEVICE_INFO, usb, table, table, sizeof(table[0]), \
  347             sizeof(table) / sizeof(table[0]))
  348 #define USB_PNP_DUAL_INFO(table)                                        \
  349         MODULE_PNP_INFO(USB_STD_PNP_INFO, usb, table, table, sizeof(table[0]), \
  350             sizeof(table) / sizeof(table[0]))
  351 
  352 /* check that the size of the structure above is correct */
  353 extern char usb_device_id_assert[(sizeof(struct usb_device_id) == 32) ? 1 : -1];
  354 
  355 #define USB_VENDOR(vend)                        \
  356   .match_flag_vendor = 1, .idVendor = (vend)
  357 
  358 #define USB_PRODUCT(prod)                       \
  359   .match_flag_product = 1, .idProduct = (prod)
  360 
  361 #define USB_VP(vend,prod)                       \
  362   USB_VENDOR(vend), USB_PRODUCT(prod)
  363 
  364 #define USB_VPI(vend,prod,info)                 \
  365   USB_VENDOR(vend), USB_PRODUCT(prod), USB_DRIVER_INFO(info)
  366 
  367 #define USB_DEV_BCD_GTEQ(lo)    /* greater than or equal */ \
  368   .match_flag_dev_lo = 1, .bcdDevice_lo = (lo)
  369 
  370 #define USB_DEV_BCD_LTEQ(hi)    /* less than or equal */ \
  371   .match_flag_dev_hi = 1, .bcdDevice_hi = (hi)
  372 
  373 #define USB_DEV_CLASS(dc)                       \
  374   .match_flag_dev_class = 1, .bDeviceClass = (dc)
  375 
  376 #define USB_DEV_SUBCLASS(dsc)                   \
  377   .match_flag_dev_subclass = 1, .bDeviceSubClass = (dsc)
  378 
  379 #define USB_DEV_PROTOCOL(dp)                    \
  380   .match_flag_dev_protocol = 1, .bDeviceProtocol = (dp)
  381 
  382 #define USB_IFACE_CLASS(ic)                     \
  383   .match_flag_int_class = 1, .bInterfaceClass = (ic)
  384 
  385 #define USB_IFACE_SUBCLASS(isc)                 \
  386   .match_flag_int_subclass = 1, .bInterfaceSubClass = (isc)
  387 
  388 #define USB_IFACE_PROTOCOL(ip)                  \
  389   .match_flag_int_protocol = 1, .bInterfaceProtocol = (ip)
  390 
  391 #define USB_IF_CSI(class,subclass,info)                 \
  392   USB_IFACE_CLASS(class), USB_IFACE_SUBCLASS(subclass), USB_DRIVER_INFO(info)
  393 
  394 #define USB_DRIVER_INFO(n)                      \
  395   .driver_info = (n)
  396 
  397 #define USB_GET_DRIVER_INFO(did)                \
  398   (did)->driver_info
  399 
  400 /*
  401  * The following structure keeps information that is used to match
  402  * against an array of "usb_device_id" elements.
  403  */
  404 struct usbd_lookup_info {
  405         uint16_t idVendor;
  406         uint16_t idProduct;
  407         uint16_t bcdDevice;
  408         uint8_t bDeviceClass;
  409         uint8_t bDeviceSubClass;
  410         uint8_t bDeviceProtocol;
  411         uint8_t bInterfaceClass;
  412         uint8_t bInterfaceSubClass;
  413         uint8_t bInterfaceProtocol;
  414         uint8_t bIfaceIndex;
  415         uint8_t bIfaceNum;
  416         uint8_t bConfigIndex;
  417         uint8_t bConfigNum;
  418 };
  419 
  420 /* Structure used by probe and attach */
  421 
  422 struct usb_attach_arg {
  423         struct usbd_lookup_info info;
  424         device_t temp_dev;              /* for internal use */
  425         unsigned long driver_info;      /* for internal use */
  426         void *driver_ivar;
  427         struct usb_device *device;      /* current device */
  428         struct usb_interface *iface;    /* current interface */
  429         enum usb_hc_mode usb_mode;      /* host or device mode */
  430         uint8_t port;
  431         uint8_t dev_state;
  432 #define UAA_DEV_READY           0
  433 #define UAA_DEV_DISABLED        1
  434 #define UAA_DEV_EJECTING        2
  435 };
  436 
  437 /*
  438  * The following is a wrapper for the callout structure to ease
  439  * porting the code to other platforms.
  440  */
  441 struct usb_callout {
  442         struct callout co;
  443 };
  444 #define usb_callout_init_mtx(c,m,f) callout_init_mtx(&(c)->co,m,f)
  445 #define usb_callout_reset(c,t,f,d) callout_reset(&(c)->co,t,f,d)
  446 #define usb_callout_stop(c) callout_stop(&(c)->co)
  447 #define usb_callout_drain(c) callout_drain(&(c)->co)
  448 #define usb_callout_pending(c) callout_pending(&(c)->co)
  449 
  450 /* USB transfer states */
  451 
  452 #define USB_ST_SETUP       0
  453 #define USB_ST_TRANSFERRED 1
  454 #define USB_ST_ERROR       2
  455 
  456 /* USB handle request states */
  457 #define USB_HR_NOT_COMPLETE     0
  458 #define USB_HR_COMPLETE_OK      1
  459 #define USB_HR_COMPLETE_ERR     2
  460 
  461 /*
  462  * The following macro will return the current state of an USB
  463  * transfer like defined by the "USB_ST_XXX" enums.
  464  */
  465 #define USB_GET_STATE(xfer) (usbd_xfer_state(xfer))
  466 
  467 /*
  468  * The following structure defines the USB process message header.
  469  */
  470 struct usb_proc_msg {
  471         TAILQ_ENTRY(usb_proc_msg) pm_qentry;
  472         usb_proc_callback_t *pm_callback;
  473         usb_size_t pm_num;
  474 };
  475 
  476 #define USB_FIFO_TX 0
  477 #define USB_FIFO_RX 1
  478 
  479 /*
  480  * Locking note for the following functions.  All the
  481  * "usb_fifo_cmd_t" and "usb_fifo_filter_t" functions are called
  482  * locked. The others are called unlocked.
  483  */
  484 struct usb_fifo_methods {
  485         usb_fifo_open_t *f_open;
  486         usb_fifo_close_t *f_close;
  487         usb_fifo_ioctl_t *f_ioctl;
  488         /*
  489          * NOTE: The post-ioctl callback is called after the USB reference
  490          * gets locked in the IOCTL handler:
  491          */
  492         usb_fifo_ioctl_t *f_ioctl_post;
  493         usb_fifo_cmd_t *f_start_read;
  494         usb_fifo_cmd_t *f_stop_read;
  495         usb_fifo_cmd_t *f_start_write;
  496         usb_fifo_cmd_t *f_stop_write;
  497         usb_fifo_filter_t *f_filter_read;
  498         usb_fifo_filter_t *f_filter_write;
  499         const char *basename[4];
  500         const char *postfix[4];
  501 };
  502 
  503 struct usb_fifo_sc {
  504         struct usb_fifo *fp[2];
  505         struct usb_fs_privdata *dev;
  506 };
  507 
  508 const char *usbd_errstr(usb_error_t error);
  509 void    *usbd_find_descriptor(struct usb_device *udev, void *id,
  510             uint8_t iface_index, uint8_t type, uint8_t type_mask,
  511             uint8_t subtype, uint8_t subtype_mask);
  512 struct usb_config_descriptor *usbd_get_config_descriptor(
  513             struct usb_device *udev);
  514 struct usb_device_descriptor *usbd_get_device_descriptor(
  515             struct usb_device *udev);
  516 struct usb_interface *usbd_get_iface(struct usb_device *udev,
  517             uint8_t iface_index);
  518 struct usb_interface_descriptor *usbd_get_interface_descriptor(
  519             struct usb_interface *iface);
  520 struct usb_endpoint *usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
  521                     const struct usb_config *setup);
  522 struct usb_endpoint *usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val);
  523 usb_error_t     usbd_interface_count(struct usb_device *udev, uint8_t *count);
  524 enum usb_hc_mode usbd_get_mode(struct usb_device *udev);
  525 enum usb_dev_speed usbd_get_speed(struct usb_device *udev);
  526 void    device_set_usb_desc(device_t dev);
  527 void    usb_pause_mtx(struct mtx *mtx, int _ticks);
  528 usb_error_t     usbd_set_pnpinfo(struct usb_device *udev,
  529                         uint8_t iface_index, const char *pnpinfo);
  530 usb_error_t     usbd_add_dynamic_quirk(struct usb_device *udev,
  531                         uint16_t quirk);
  532 usb_error_t     usbd_set_endpoint_mode(struct usb_device *udev,
  533                         struct usb_endpoint *ep, uint8_t ep_mode);
  534 uint8_t         usbd_get_endpoint_mode(struct usb_device *udev,
  535                         struct usb_endpoint *ep);
  536 
  537 const struct usb_device_id *usbd_lookup_id_by_info(
  538             const struct usb_device_id *id, usb_size_t sizeof_id,
  539             const struct usbd_lookup_info *info);
  540 int     usbd_lookup_id_by_uaa(const struct usb_device_id *id,
  541             usb_size_t sizeof_id, struct usb_attach_arg *uaa);
  542 
  543 usb_error_t usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx,
  544                     struct usb_device_request *req, void *data, uint16_t flags,
  545                     uint16_t *actlen, usb_timeout_t timeout);
  546 #define usbd_do_request(u,m,r,d) \
  547   usbd_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT)
  548 
  549 uint8_t usbd_clear_stall_callback(struct usb_xfer *xfer1,
  550             struct usb_xfer *xfer2);
  551 uint8_t usbd_get_interface_altindex(struct usb_interface *iface);
  552 usb_error_t usbd_set_alt_interface_index(struct usb_device *udev,
  553             uint8_t iface_index, uint8_t alt_index);
  554 uint32_t usbd_get_isoc_fps(struct usb_device *udev);
  555 usb_error_t usbd_transfer_setup(struct usb_device *udev,
  556             const uint8_t *ifaces, struct usb_xfer **pxfer,
  557             const struct usb_config *setup_start, uint16_t n_setup,
  558             void *priv_sc, struct mtx *priv_mtx);
  559 void    usbd_transfer_submit(struct usb_xfer *xfer);
  560 void    usbd_transfer_clear_stall(struct usb_xfer *xfer);
  561 void    usbd_transfer_drain(struct usb_xfer *xfer);
  562 uint8_t usbd_transfer_pending(struct usb_xfer *xfer);
  563 void    usbd_transfer_start(struct usb_xfer *xfer);
  564 void    usbd_transfer_stop(struct usb_xfer *xfer);
  565 void    usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup);
  566 void    usbd_transfer_poll(struct usb_xfer **ppxfer, uint16_t max);
  567 void    usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
  568             uint8_t parent_index);
  569 uint8_t usbd_get_bus_index(struct usb_device *udev);
  570 uint8_t usbd_get_device_index(struct usb_device *udev);
  571 void    usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode);
  572 uint8_t usbd_filter_power_mode(struct usb_device *udev, uint8_t power_mode);
  573 uint8_t usbd_device_attached(struct usb_device *udev);
  574 
  575 usb_frlength_t
  576         usbd_xfer_old_frame_length(struct usb_xfer *xfer, usb_frcount_t frindex);
  577 void    usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen,
  578             int *aframes, int *nframes);
  579 struct usb_page_cache *usbd_xfer_get_frame(struct usb_xfer *, usb_frcount_t);
  580 void    *usbd_xfer_get_frame_buffer(struct usb_xfer *, usb_frcount_t);
  581 void    *usbd_xfer_softc(struct usb_xfer *xfer);
  582 void    *usbd_xfer_get_priv(struct usb_xfer *xfer);
  583 void    usbd_xfer_set_priv(struct usb_xfer *xfer, void *);
  584 void    usbd_xfer_set_interval(struct usb_xfer *xfer, int);
  585 uint8_t usbd_xfer_state(struct usb_xfer *xfer);
  586 void    usbd_xfer_set_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
  587             void *ptr, usb_frlength_t len);
  588 void    usbd_xfer_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
  589             void **ptr, int *len);
  590 void    usbd_xfer_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
  591             usb_frcount_t frindex);
  592 usb_frlength_t usbd_xfer_max_len(struct usb_xfer *xfer);
  593 usb_frlength_t usbd_xfer_max_framelen(struct usb_xfer *xfer);
  594 usb_frcount_t usbd_xfer_max_frames(struct usb_xfer *xfer);
  595 uint8_t usbd_xfer_get_fps_shift(struct usb_xfer *xfer);
  596 usb_frlength_t usbd_xfer_frame_len(struct usb_xfer *xfer,
  597             usb_frcount_t frindex);
  598 void    usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex,
  599             usb_frlength_t len);
  600 void    usbd_xfer_set_timeout(struct usb_xfer *xfer, int timeout);
  601 void    usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n);
  602 void    usbd_xfer_set_stall(struct usb_xfer *xfer);
  603 int     usbd_xfer_is_stalled(struct usb_xfer *xfer);
  604 void    usbd_xfer_set_flag(struct usb_xfer *xfer, int flag);
  605 void    usbd_xfer_clr_flag(struct usb_xfer *xfer, int flag);
  606 uint16_t usbd_xfer_get_timestamp(struct usb_xfer *xfer);
  607 uint8_t usbd_xfer_maxp_was_clamped(struct usb_xfer *xfer);
  608 
  609 void    usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
  610             const void *ptr, usb_frlength_t len);
  611 int     usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
  612             const void *ptr, usb_frlength_t len);
  613 void    usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
  614             void *ptr, usb_frlength_t len);
  615 int     usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
  616             void *ptr, usb_frlength_t len);
  617 void    usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
  618             struct usb_page_search *res);
  619 void    usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
  620             struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len);
  621 void    usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset,
  622             usb_frlength_t len);
  623 void    usbd_start_re_enumerate(struct usb_device *udev);
  624 usb_error_t
  625         usbd_start_set_config(struct usb_device *, uint8_t);
  626 
  627 int     usb_fifo_attach(struct usb_device *udev, void *priv_sc,
  628             struct mtx *priv_mtx, struct usb_fifo_methods *pm,
  629             struct usb_fifo_sc *f_sc, uint16_t unit, int16_t subunit,
  630             uint8_t iface_index, uid_t uid, gid_t gid, int mode);
  631 void    usb_fifo_detach(struct usb_fifo_sc *f_sc);
  632 int     usb_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize,
  633             uint16_t nbuf);
  634 void    usb_fifo_free_buffer(struct usb_fifo *f);
  635 uint32_t usb_fifo_put_bytes_max(struct usb_fifo *fifo);
  636 void    usb_fifo_put_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
  637             usb_frlength_t offset, usb_frlength_t len, uint8_t what);
  638 void    usb_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr,
  639             usb_size_t len, uint8_t what);
  640 uint8_t usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len);
  641 void    usb_fifo_put_data_error(struct usb_fifo *fifo);
  642 uint8_t usb_fifo_get_data(struct usb_fifo *fifo, struct usb_page_cache *pc,
  643             usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen,
  644             uint8_t what);
  645 uint8_t usb_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr,
  646             usb_size_t len, usb_size_t *actlen, uint8_t what);
  647 uint8_t usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr,
  648             usb_size_t *plen);
  649 void    usb_fifo_reset(struct usb_fifo *f);
  650 void    usb_fifo_wakeup(struct usb_fifo *f);
  651 void    usb_fifo_get_data_error(struct usb_fifo *fifo);
  652 void    *usb_fifo_softc(struct usb_fifo *fifo);
  653 void    usb_fifo_set_close_zlp(struct usb_fifo *, uint8_t);
  654 void    usb_fifo_set_write_defrag(struct usb_fifo *, uint8_t);
  655 void    usb_fifo_free(struct usb_fifo *f);
  656 #endif /* _KERNEL */
  657 #endif /* _USB_USBDI_H_ */

Cache object: 34711855379c4172a778842d09eedc4f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.