Changeset 02279d6 in rtems-libbsd


Ignore:
Timestamp:
Nov 12, 2015, 12:01:12 PM (4 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
a8f29d695e152575479ad1a97fa354f661bebd4d, freebsd-9.3, d892051f37c2c4ad7f345f6a817ea3d38e56a431
Children:
c5a141a
Parents:
c164446
Message:

USB: Update to FreeBSD trunk 2015-11-10

Files:
49 edited

Legend:

Unmodified
Added
Removed
  • freebsd/sys/dev/usb/controller/ehci.c

    rc164446 r02279d6  
    11#include <machine/rtems-bsd-kernel-space.h>
    22
     3/* $FreeBSD$ */
    34/*-
    45 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
     
    4647 */
    4748
    48 #include <sys/cdefs.h>
    49 __FBSDID("$FreeBSD$");
    50 
     49#ifdef USB_GLOBAL_INCLUDE_FILE
     50#include USB_GLOBAL_INCLUDE_FILE
     51#else
    5152#include <sys/stdint.h>
    5253#include <sys/stddef.h>
     
    8485#include <dev/usb/usb_controller.h>
    8586#include <dev/usb/usb_bus.h>
     87#endif                  /* USB_GLOBAL_INCLUDE_FILE */
     88
    8689#include <dev/usb/controller/ehci.h>
    8790#include <dev/usb/controller/ehcireg.h>
     
    98101
    99102static SYSCTL_NODE(_hw_usb, OID_AUTO, ehci, CTLFLAG_RW, 0, "USB ehci");
    100 SYSCTL_INT(_hw_usb_ehci, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
     103SYSCTL_INT(_hw_usb_ehci, OID_AUTO, debug, CTLFLAG_RWTUN,
    101104    &ehcidebug, 0, "Debug level");
    102 TUNABLE_INT("hw.usb.ehci.debug", &ehcidebug);
    103 SYSCTL_INT(_hw_usb_ehci, OID_AUTO, no_hs, CTLFLAG_RW | CTLFLAG_TUN,
     105SYSCTL_INT(_hw_usb_ehci, OID_AUTO, no_hs, CTLFLAG_RWTUN,
    104106    &ehcinohighspeed, 0, "Disable High Speed USB");
    105 TUNABLE_INT("hw.usb.ehci.no_hs", &ehcinohighspeed);
    106 SYSCTL_INT(_hw_usb_ehci, OID_AUTO, iaadbug, CTLFLAG_RW | CTLFLAG_TUN,
     107SYSCTL_INT(_hw_usb_ehci, OID_AUTO, iaadbug, CTLFLAG_RWTUN,
    107108    &ehciiaadbug, 0, "Enable doorbell bug workaround");
    108 TUNABLE_INT("hw.usb.ehci.iaadbug", &ehciiaadbug);
    109 SYSCTL_INT(_hw_usb_ehci, OID_AUTO, lostintrbug, CTLFLAG_RW | CTLFLAG_TUN,
     109SYSCTL_INT(_hw_usb_ehci, OID_AUTO, lostintrbug, CTLFLAG_RWTUN,
    110110    &ehcilostintrbug, 0, "Enable lost interrupt bug workaround");
    111 TUNABLE_INT("hw.usb.ehci.lostintrbug", &ehcilostintrbug);
    112 
    113111
    114112static void ehci_dump_regs(ehci_softc_t *sc);
     
    119117#define EHCI_INTR_ENDPT 1
    120118
    121 extern struct usb_bus_methods ehci_bus_methods;
    122 extern struct usb_pipe_methods ehci_device_bulk_methods;
    123 extern struct usb_pipe_methods ehci_device_ctrl_methods;
    124 extern struct usb_pipe_methods ehci_device_intr_methods;
    125 extern struct usb_pipe_methods ehci_device_isoc_fs_methods;
    126 extern struct usb_pipe_methods ehci_device_isoc_hs_methods;
     119static const struct usb_bus_methods ehci_bus_methods;
     120static const struct usb_pipe_methods ehci_device_bulk_methods;
     121static const struct usb_pipe_methods ehci_device_ctrl_methods;
     122static const struct usb_pipe_methods ehci_device_intr_methods;
     123static const struct usb_pipe_methods ehci_device_isoc_fs_methods;
     124static const struct usb_pipe_methods ehci_device_isoc_hs_methods;
    127125
    128126static void ehci_do_poll(struct usb_bus *);
     
    12901288ehci_check_transfer(struct usb_xfer *xfer)
    12911289{
    1292         struct usb_pipe_methods *methods = xfer->endpoint->methods;
     1290        const struct usb_pipe_methods *methods = xfer->endpoint->methods;
    12931291        ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus);
    12941292
     
    17821780{
    17831781        struct ehci_std_temp temp;
    1784         struct usb_pipe_methods *methods;
     1782        const struct usb_pipe_methods *methods;
    17851783        ehci_qh_t *qh;
    17861784        ehci_qtd_t *td;
     
    22022200ehci_device_done(struct usb_xfer *xfer, usb_error_t error)
    22032201{
    2204         struct usb_pipe_methods *methods = xfer->endpoint->methods;
     2202        const struct usb_pipe_methods *methods = xfer->endpoint->methods;
    22052203        ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus);
    22062204
     
    23062304}
    23072305
    2308 struct usb_pipe_methods ehci_device_bulk_methods =
     2306static const struct usb_pipe_methods ehci_device_bulk_methods =
    23092307{
    23102308        .open = ehci_device_bulk_open,
     
    23472345}
    23482346
    2349 struct usb_pipe_methods ehci_device_ctrl_methods =
     2347static const struct usb_pipe_methods ehci_device_ctrl_methods =
    23502348{
    23512349        .open = ehci_device_ctrl_open,
     
    24282426}
    24292427
    2430 struct usb_pipe_methods ehci_device_intr_methods =
     2428static const struct usb_pipe_methods ehci_device_intr_methods =
    24312429{
    24322430        .open = ehci_device_intr_open,
     
    27202718}
    27212719
    2722 struct usb_pipe_methods ehci_device_isoc_fs_methods =
     2720static const struct usb_pipe_methods ehci_device_isoc_fs_methods =
    27232721{
    27242722        .open = ehci_device_isoc_fs_open,
     
    30002998}
    30012999
    3002 struct usb_pipe_methods ehci_device_isoc_hs_methods =
     3000static const struct usb_pipe_methods ehci_device_isoc_hs_methods =
    30033001{
    30043002        .open = ehci_device_isoc_hs_open,
     
    38073805        ehci_softc_t *sc = EHCI_BUS2SC(udev->bus);
    38083806        struct usb_xfer *xfer;
    3809         struct usb_pipe_methods *methods;
     3807        const struct usb_pipe_methods *methods;
    38103808
    38113809        DPRINTF("\n");
     
    38413839        ehci_softc_t *sc = EHCI_BUS2SC(udev->bus);
    38423840        struct usb_xfer *xfer;
    3843         struct usb_pipe_methods *methods;
     3841        const struct usb_pipe_methods *methods;
    38443842
    38453843        DPRINTF("\n");
     
    39553953}
    39563954
    3957 struct usb_bus_methods ehci_bus_methods =
     3955static const struct usb_bus_methods ehci_bus_methods =
    39583956{
    39593957        .endpoint_init = ehci_ep_init,
  • freebsd/sys/dev/usb/controller/ehci.h

    rc164446 r02279d6  
    9191#define EHCI_ITD_SET_OFFS(x)    (x)
    9292#define EHCI_ITD_GET_OFFS(x)    (((x) >> 0) & 0xFFF)
    93 #define EHCI_ITD_ACTIVE         (1 << 31)
     93#define EHCI_ITD_ACTIVE         (1U << 31)
    9494#define EHCI_ITD_DATABUFERR     (1 << 30)
    9595#define EHCI_ITD_BABBLE         (1 << 29)
     
    127127        volatile uint32_t sitd_portaddr;
    128128#define EHCI_SITD_SET_DIR_OUT   (0 << 31)
    129 #define EHCI_SITD_SET_DIR_IN    (1 << 31)
     129#define EHCI_SITD_SET_DIR_IN    (1U << 31)
    130130#define EHCI_SITD_SET_ADDR(x)   (x)
    131131#define EHCI_SITD_GET_ADDR(x)   ((x) & 0x7F)
  • freebsd/sys/dev/usb/controller/ohci.c

    rc164446 r02279d6  
    11#include <machine/rtems-bsd-kernel-space.h>
    22
     3/* $FreeBSD$ */
    34/*-
    45 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
     
    2829 */
    2930
    30 #include <sys/cdefs.h>
    31 __FBSDID("$FreeBSD$");
    32 
    3331/*
    3432 * USB Open Host Controller driver.
     
    3836 */
    3937
     38#ifdef USB_GLOBAL_INCLUDE_FILE
     39#include USB_GLOBAL_INCLUDE_FILE
     40#else
    4041#include <sys/stdint.h>
    4142#include <sys/stddef.h>
     
    7374#include <dev/usb/usb_controller.h>
    7475#include <dev/usb/usb_bus.h>
     76#endif                  /* USB_GLOBAL_INCLUDE_FILE */
     77
    7578#include <dev/usb/controller/ohci.h>
    7679#include <dev/usb/controller/ohcireg.h>
     
    8487
    8588static SYSCTL_NODE(_hw_usb, OID_AUTO, ohci, CTLFLAG_RW, 0, "USB ohci");
    86 SYSCTL_INT(_hw_usb_ohci, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
     89SYSCTL_INT(_hw_usb_ohci, OID_AUTO, debug, CTLFLAG_RWTUN,
    8790    &ohcidebug, 0, "ohci debug level");
    88 TUNABLE_INT("hw.usb.ohci.debug", &ohcidebug);
    8991
    9092static void ohci_dumpregs(ohci_softc_t *);
     
    111113#define OHCI_INTR_ENDPT 1
    112114
    113 extern struct usb_bus_methods ohci_bus_methods;
    114 extern struct usb_pipe_methods ohci_device_bulk_methods;
    115 extern struct usb_pipe_methods ohci_device_ctrl_methods;
    116 extern struct usb_pipe_methods ohci_device_intr_methods;
    117 extern struct usb_pipe_methods ohci_device_isoc_methods;
     115static const struct usb_bus_methods ohci_bus_methods;
     116static const struct usb_pipe_methods ohci_device_bulk_methods;
     117static const struct usb_pipe_methods ohci_device_ctrl_methods;
     118static const struct usb_pipe_methods ohci_device_intr_methods;
     119static const struct usb_pipe_methods ohci_device_isoc_methods;
    118120
    119121static void ohci_do_poll(struct usb_bus *bus);
     
    13931395{
    13941396        struct ohci_std_temp temp;
    1395         struct usb_pipe_methods *methods;
     1397        const struct usb_pipe_methods *methods;
    13961398        ohci_ed_t *ed;
    13971399        ohci_td_t *td;
     
    16321634ohci_device_done(struct usb_xfer *xfer, usb_error_t error)
    16331635{
    1634         struct usb_pipe_methods *methods = xfer->endpoint->methods;
     1636        const struct usb_pipe_methods *methods = xfer->endpoint->methods;
    16351637        ohci_softc_t *sc = OHCI_BUS2SC(xfer->xroot->bus);
    16361638        ohci_ed_t *ed;
     
    16981700}
    16991701
    1700 struct usb_pipe_methods ohci_device_bulk_methods =
     1702static const struct usb_pipe_methods ohci_device_bulk_methods =
    17011703{
    17021704        .open = ohci_device_bulk_open,
     
    17391741}
    17401742
    1741 struct usb_pipe_methods ohci_device_ctrl_methods =
     1743static const struct usb_pipe_methods ohci_device_ctrl_methods =
    17421744{
    17431745        .open = ohci_device_ctrl_open,
     
    18111813}
    18121814
    1813 struct usb_pipe_methods ohci_device_intr_methods =
     1815static const struct usb_pipe_methods ohci_device_intr_methods =
    18141816{
    18151817        .open = ohci_device_intr_open,
     
    20192021}
    20202022
    2021 struct usb_pipe_methods ohci_device_isoc_methods =
     2023static const struct usb_pipe_methods ohci_device_isoc_methods =
    20222024{
    20232025        .open = ohci_device_isoc_open,
     
    25982600        struct ohci_softc *sc = OHCI_BUS2SC(udev->bus);
    25992601        struct usb_xfer *xfer;
    2600         struct usb_pipe_methods *methods;
     2602        const struct usb_pipe_methods *methods;
    26012603        ohci_ed_t *ed;
    26022604
     
    26362638        struct ohci_softc *sc = OHCI_BUS2SC(udev->bus);
    26372639        struct usb_xfer *xfer;
    2638         struct usb_pipe_methods *methods;
     2640        const struct usb_pipe_methods *methods;
    26392641        ohci_ed_t *ed;
    26402642
     
    27202722}
    27212723
    2722 struct usb_bus_methods ohci_bus_methods =
     2724static const struct usb_bus_methods ohci_bus_methods =
    27232725{
    27242726        .endpoint_init = ohci_ep_init,
  • freebsd/sys/dev/usb/controller/usb_controller.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <rtems/bsd/local/opt_ddb.h>
    3033
     
    6669#include <dev/usb/usb_pf.h>
    6770#include <rtems/bsd/local/usb_if.h>
     71#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6872
    6973/* function prototypes  */
     
    8488
    8589static SYSCTL_NODE(_hw_usb, OID_AUTO, ctrl, CTLFLAG_RW, 0, "USB controller");
    86 SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RW, &usb_ctrl_debug, 0,
     90SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RWTUN, &usb_ctrl_debug, 0,
    8791    "Debug level");
    8892#endif
    8993
     94#if USB_HAVE_ROOT_MOUNT_HOLD
     95static int usb_no_boot_wait = 0;
     96SYSCTL_INT(_hw_usb, OID_AUTO, no_boot_wait, CTLFLAG_RDTUN, &usb_no_boot_wait, 0,
     97    "No USB device enumerate waiting at boot.");
     98#endif
     99
    90100#ifndef __rtems__
    91 static int usb_no_boot_wait = 0;
    92 TUNABLE_INT("hw.usb.no_boot_wait", &usb_no_boot_wait);
    93 SYSCTL_INT(_hw_usb, OID_AUTO, no_boot_wait, CTLFLAG_RD|CTLFLAG_TUN, &usb_no_boot_wait, 0,
    94     "No USB device enumerate waiting at boot.");
    95 
    96101static int usb_no_suspend_wait = 0;
    97 TUNABLE_INT("hw.usb.no_suspend_wait", &usb_no_suspend_wait);
    98 SYSCTL_INT(_hw_usb, OID_AUTO, no_suspend_wait, CTLFLAG_RW|CTLFLAG_TUN,
     102SYSCTL_INT(_hw_usb, OID_AUTO, no_suspend_wait, CTLFLAG_RWTUN,
    99103    &usb_no_suspend_wait, 0, "No USB device waiting at system suspend.");
    100104
    101105static int usb_no_shutdown_wait = 0;
    102 TUNABLE_INT("hw.usb.no_shutdown_wait", &usb_no_shutdown_wait);
    103 SYSCTL_INT(_hw_usb, OID_AUTO, no_shutdown_wait, CTLFLAG_RW|CTLFLAG_TUN,
     106SYSCTL_INT(_hw_usb, OID_AUTO, no_shutdown_wait, CTLFLAG_RWTUN,
    104107    &usb_no_shutdown_wait, 0, "No USB device waiting at system shutdown.");
    105108#endif /* __rtems__ */
     
    114117        DEVMETHOD(device_resume, usb_resume),
    115118        DEVMETHOD(device_shutdown, usb_shutdown),
    116         {0, 0}
     119
     120        DEVMETHOD_END
    117121};
    118122
     
    133137DRIVER_MODULE(usbus, musbotg, usb_driver, usb_devclass, 0, 0);
    134138DRIVER_MODULE(usbus, uss820dci, usb_driver, usb_devclass, 0, 0);
     139DRIVER_MODULE(usbus, octusb, usb_driver, usb_devclass, 0, 0);
     140
     141/* Dual Mode Drivers */
     142DRIVER_MODULE(usbus, dwcotg, usb_driver, usb_devclass, 0, 0);
     143DRIVER_MODULE(usbus, saf1761otg, usb_driver, usb_devclass, 0, 0);
    135144
    136145/*------------------------------------------------------------------------*
     
    146155}
    147156
     157#if USB_HAVE_ROOT_MOUNT_HOLD
    148158static void
    149159usb_root_mount_rel(struct usb_bus *bus)
     
    157167#endif /* __rtems__ */
    158168}
     169#endif
    159170
    160171/*------------------------------------------------------------------------*
     
    173184        }
    174185
    175 #ifndef __rtems__
     186#if USB_HAVE_ROOT_MOUNT_HOLD
    176187        if (usb_no_boot_wait == 0) {
    177188                /* delay vfs_mountroot until the bus is explored */
    178189                bus->bus_roothold = root_mount_hold(device_get_nameunit(dev));
    179190        }
    180 #endif /* __rtems__ */
     191#endif
    181192
    182193        usb_attach_sub(dev, bus);
     
    202213        usb_callout_drain(&bus->power_wdog);
    203214
     215#if USB_HAVE_ROOT_MOUNT_HOLD
    204216        /* Let the USB explore process detach all devices. */
    205217        usb_root_mount_rel(bus);
     218#endif
    206219
    207220        USB_BUS_LOCK(bus);
    208221
    209222        /* Queue detach job */
    210         usb_proc_msignal(&bus->explore_proc,
     223        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    211224            &bus->detach_msg[0], &bus->detach_msg[1]);
    212225
    213226        /* Wait for detach to complete */
    214         usb_proc_mwait(&bus->explore_proc,
     227        usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
    215228            &bus->detach_msg[0], &bus->detach_msg[1]);
    216229
    217230#if USB_HAVE_UGEN
    218231        /* Wait for cleanup to complete */
    219         usb_proc_mwait(&bus->explore_proc,
     232        usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
    220233            &bus->cleanup_msg[0], &bus->cleanup_msg[1]);
    221234#endif
    222235        USB_BUS_UNLOCK(bus);
    223236
     237#if USB_HAVE_PER_BUS_PROCESS
    224238        /* Get rid of USB callback processes */
    225239
    226         usb_proc_free(&bus->giant_callback_proc);
    227         usb_proc_free(&bus->non_giant_callback_proc);
     240        usb_proc_free(USB_BUS_GIANT_PROC(bus));
     241        usb_proc_free(USB_BUS_NON_GIANT_ISOC_PROC(bus));
     242        usb_proc_free(USB_BUS_NON_GIANT_BULK_PROC(bus));
    228243
    229244        /* Get rid of USB explore process */
    230245
    231         usb_proc_free(&bus->explore_proc);
     246        usb_proc_free(USB_BUS_EXPLORE_PROC(bus));
    232247
    233248        /* Get rid of control transfer process */
    234249
    235         usb_proc_free(&bus->control_xfer_proc);
     250        usb_proc_free(USB_BUS_CONTROL_XFER_PROC(bus));
     251#endif
    236252
    237253#if USB_HAVE_PF
     
    257273
    258274        USB_BUS_LOCK(bus);
    259         usb_proc_msignal(&bus->explore_proc,
     275        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    260276            &bus->suspend_msg[0], &bus->suspend_msg[1]);
    261277#ifndef __rtems__
    262278        if (usb_no_suspend_wait == 0) {
    263279                /* wait for suspend callback to be executed */
    264                 usb_proc_mwait(&bus->explore_proc,
     280                usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
    265281                    &bus->suspend_msg[0], &bus->suspend_msg[1]);
    266282        }
     
    287303
    288304        USB_BUS_LOCK(bus);
    289         usb_proc_msignal(&bus->explore_proc,
     305        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    290306            &bus->resume_msg[0], &bus->resume_msg[1]);
    291307        USB_BUS_UNLOCK(bus);
     
    312328        device_printf(bus->parent, "Resetting controller\n");
    313329
    314         usb_proc_msignal(&bus->explore_proc,
     330        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    315331            &bus->reset_msg[0], &bus->reset_msg[1]);
    316332}
     
    335351        USB_BUS_LOCK(bus);
    336352#ifndef __rtems__
    337         usb_proc_msignal(&bus->explore_proc,
     353        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    338354            &bus->shutdown_msg[0], &bus->shutdown_msg[1]);
    339355        if (usb_no_shutdown_wait == 0) {
    340356                /* wait for shutdown callback to be executed */
    341                 usb_proc_mwait(&bus->explore_proc,
     357                usb_proc_mwait(USB_BUS_EXPLORE_PROC(bus),
    342358                    &bus->shutdown_msg[0], &bus->shutdown_msg[1]);
    343359        }
     
    390406                 * recover from DDB:
    391407                 */
    392                 usb_proc_rewakeup(&bus->control_xfer_proc);
    393                 usb_proc_rewakeup(&bus->giant_callback_proc);
    394                 usb_proc_rewakeup(&bus->non_giant_callback_proc);
     408                usb_proc_rewakeup(USB_BUS_CONTROL_XFER_PROC(bus));
     409                usb_proc_rewakeup(USB_BUS_GIANT_PROC(bus));
     410                usb_proc_rewakeup(USB_BUS_NON_GIANT_ISOC_PROC(bus));
     411                usb_proc_rewakeup(USB_BUS_NON_GIANT_BULK_PROC(bus));
    395412#endif
    396413
     
    407424                USB_BUS_LOCK(bus);
    408425        }
     426#if USB_HAVE_ROOT_MOUNT_HOLD
    409427        usb_root_mount_rel(bus);
     428#endif
    410429}
    411430
     
    673692         * DDB:
    674693         */
    675         usb_proc_rewakeup(&bus->explore_proc);  /* recover from DDB */
     694        usb_proc_rewakeup(USB_BUS_EXPLORE_PROC(bus));   /* recover from DDB */
    676695#endif
    677696
     
    732751        default:
    733752                device_printf(bus->bdev, "Unsupported USB revision\n");
     753#if USB_HAVE_ROOT_MOUNT_HOLD
    734754                usb_root_mount_rel(bus);
     755#endif
    735756                return;
    736757        }
     
    774795                device_printf(bus->bdev, "Root HUB problem, error=%s\n",
    775796                    usbd_errstr(err));
     797#if USB_HAVE_ROOT_MOUNT_HOLD
    776798                usb_root_mount_rel(bus);
     799#endif
    777800        }
    778801
     
    792815usb_attach_sub(device_t dev, struct usb_bus *bus)
    793816{
    794         const char *pname = device_get_nameunit(dev);
    795 
    796817        mtx_lock(&Giant);
    797818        if (usb_devclass_ptr == NULL)
     
    846867#endif
    847868
     869#if USB_HAVE_PER_BUS_PROCESS
    848870        /* Create USB explore and callback processes */
    849871
    850         if (usb_proc_create(&bus->giant_callback_proc,
    851             &bus->bus_mtx, pname, USB_PRI_MED)) {
     872        if (usb_proc_create(USB_BUS_GIANT_PROC(bus),
     873            &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
    852874                device_printf(dev, "WARNING: Creation of USB Giant "
    853875                    "callback process failed.\n");
    854         } else if (usb_proc_create(&bus->non_giant_callback_proc,
    855             &bus->bus_mtx, pname, USB_PRI_HIGH)) {
    856                 device_printf(dev, "WARNING: Creation of USB non-Giant "
     876        } else if (usb_proc_create(USB_BUS_NON_GIANT_ISOC_PROC(bus),
     877            &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_HIGHEST)) {
     878                device_printf(dev, "WARNING: Creation of USB non-Giant ISOC "
    857879                    "callback process failed.\n");
    858         } else if (usb_proc_create(&bus->explore_proc,
    859             &bus->bus_mtx, pname, USB_PRI_MED)) {
     880        } else if (usb_proc_create(USB_BUS_NON_GIANT_BULK_PROC(bus),
     881            &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_HIGH)) {
     882                device_printf(dev, "WARNING: Creation of USB non-Giant BULK "
     883                    "callback process failed.\n");
     884        } else if (usb_proc_create(USB_BUS_EXPLORE_PROC(bus),
     885            &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
    860886                device_printf(dev, "WARNING: Creation of USB explore "
    861887                    "process failed.\n");
    862         } else if (usb_proc_create(&bus->control_xfer_proc,
    863             &bus->bus_mtx, pname, USB_PRI_MED)) {
     888        } else if (usb_proc_create(USB_BUS_CONTROL_XFER_PROC(bus),
     889            &bus->bus_mtx, device_get_nameunit(dev), USB_PRI_MED)) {
    864890                device_printf(dev, "WARNING: Creation of USB control transfer "
    865891                    "process failed.\n");
    866         } else {
     892        } else
     893#endif
     894        {
    867895                /* Get final attach going */
    868896                USB_BUS_LOCK(bus);
    869                 usb_proc_msignal(&bus->explore_proc,
     897                usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    870898                    &bus->attach_msg[0], &bus->attach_msg[1]);
    871899                USB_BUS_UNLOCK(bus);
     
    875903        }
    876904}
    877 
    878905SYSUNINIT(usb_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb_bus_unload, NULL);
    879906
     
    934961
    935962        mtx_init(&bus->bus_mtx, device_get_nameunit(bus->parent),
    936             NULL, MTX_DEF | MTX_RECURSE);
     963            "usb_def_mtx", MTX_DEF | MTX_RECURSE);
     964
     965        mtx_init(&bus->bus_spin_lock, device_get_nameunit(bus->parent),
     966            "usb_spin_mtx", MTX_SPIN | MTX_RECURSE);
    937967
    938968        usb_callout_init_mtx(&bus->power_wdog,
     
    9891019
    9901020        mtx_destroy(&bus->bus_mtx);
     1021        mtx_destroy(&bus->bus_spin_lock);
    9911022}
    9921023
     
    9951026usb_proc_explore_mwait(struct usb_device *udev, void *pm1, void *pm2)
    9961027{
    997         usb_proc_mwait(&udev->bus->explore_proc, pm1, pm2);
     1028        usb_proc_mwait(USB_BUS_EXPLORE_PROC(udev->bus), pm1, pm2);
    9981029}
    9991030
     
    10011032usb_proc_explore_msignal(struct usb_device *udev, void *pm1, void *pm2)
    10021033{
    1003         return (usb_proc_msignal(&udev->bus->explore_proc, pm1, pm2));
     1034        return (usb_proc_msignal(USB_BUS_EXPLORE_PROC(udev->bus), pm1, pm2));
    10041035}
    10051036
  • freebsd/sys/dev/usb/quirk/usb_quirk.c

    rc164446 r02279d6  
    6464#define USB_DEV_QUIRKS_MAX 384
    6565#define USB_SUB_QUIRKS_MAX 8
     66#define USB_QUIRK_ENVROOT "hw.usb.quirk."
    6667
    6768struct usb_quirk_entry {
     
    9798        USB_QUIRK(LOGITECH, UN53B, 0x0000, 0xffff, UQ_NO_STRINGS),
    9899        USB_QUIRK(REALTEK, RTL8196EU, 0x0000, 0xffff, UQ_CFG_INDEX_1),
     100        USB_QUIRK(REALTEK, RTL8153, 0x0000, 0xffff, UQ_CFG_INDEX_1),
    99101        USB_QUIRK(ELSA, MODEM1, 0x0000, 0xffff, UQ_CFG_INDEX_1),
    100102        USB_QUIRK(PLANEX2, MZKUE150N, 0x0000, 0xffff, UQ_CFG_INDEX_1),
     103        USB_QUIRK(CISCOLINKSYS, USB3GIGV1, 0x0000, 0xffff, UQ_CFG_INDEX_1),
    101104        /* Quirks for printer devices */
    102105        USB_QUIRK(HP, 895C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
     
    113116        USB_QUIRK(CYPRESS, SILVERSHIELD, 0x0000, 0xffff, UQ_HID_IGNORE),
    114117        USB_QUIRK(DELORME, EARTHMATE, 0x0000, 0xffff, UQ_HID_IGNORE),
     118        USB_QUIRK(DREAMLINK, DL100B, 0x0000, 0xffff, UQ_HID_IGNORE),
    115119        USB_QUIRK(ITUNERNET, USBLCD2X20, 0x0000, 0xffff, UQ_HID_IGNORE),
    116120        USB_QUIRK(ITUNERNET, USBLCD4X20, 0x0000, 0xffff, UQ_HID_IGNORE),
     
    525529        USB_QUIRK(REALTEK, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
    526530        USB_QUIRK(INITIO, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
     531
     532        /* DYMO LabelManager Pnp */
     533        USB_QUIRK(DYMO, LABELMANAGERPNP, 0x0000, 0xffff, UQ_MSC_DYMO_EJECT),
    527534};
    528535#undef USB_QUIRK_VP
     
    548555        [UQ_MS_REVZ]            = "UQ_MS_REVZ",
    549556        [UQ_NO_STRINGS]         = "UQ_NO_STRINGS",
    550         [UQ_OPEN_CLEARSTALL]    = "UQ_OPEN_CLEARSTALL",
    551557        [UQ_POWER_CLAIM]        = "UQ_POWER_CLAIM",
    552558        [UQ_SPUR_BUT_UP]        = "UQ_SPUR_BUT_UP",
     
    595601        [UQ_AU_VENDOR_CLASS]            = "UQ_AU_VENDOR_CLASS",
    596602        [UQ_SINGLE_CMD_MIDI]            = "UQ_SINGLE_CMD_MIDI",
     603        [UQ_MSC_DYMO_EJECT]             = "UQ_MSC_DYMO_EJECT",
    597604};
    598605
     
    605612usb_quirkstr(uint16_t quirk)
    606613{
    607         return ((quirk < USB_QUIRK_MAX) ?
    608             usb_quirk_str[quirk] : "USB_QUIRK_UNKNOWN");
     614        return ((quirk < USB_QUIRK_MAX && usb_quirk_str[quirk] != NULL) ?
     615            usb_quirk_str[quirk] : "UQ_UNKNOWN");
     616}
     617
     618/*------------------------------------------------------------------------*
     619 *      usb_strquirk
     620 *
     621 * This function converts a string into a USB quirk code.
     622 *
     623 * Returns:
     624 * Less than USB_QUIRK_MAX: Quirk code
     625 * Else: Quirk code not found
     626 *------------------------------------------------------------------------*/
     627static uint16_t
     628usb_strquirk(const char *str, size_t len)
     629{
     630        const char *quirk;
     631        uint16_t x;
     632
     633        for (x = 0; x != USB_QUIRK_MAX; x++) {
     634                quirk = usb_quirkstr(x);
     635                if (strncmp(str, quirk, len) == 0 &&
     636                    quirk[len] == 0)
     637                        break;
     638        }
     639        return (x);
    609640}
    610641
     
    851882}
    852883
     884/*------------------------------------------------------------------------*
     885 *      usb_quirk_strtou16
     886 *
     887 * Helper function to scan a 16-bit integer.
     888 *------------------------------------------------------------------------*/
     889static uint16_t
     890usb_quirk_strtou16(const char **pptr, const char *name, const char *what)
     891{
     892        unsigned long value;
     893        char *end;
     894
     895        value = strtoul(*pptr, &end, 0);
     896        if (value > 65535 || *pptr == end || (*end != ' ' && *end != '\t')) {
     897                printf("%s: %s 16-bit %s value set to zero\n",
     898                    name, what, *end == 0 ? "incomplete" : "invalid");
     899                return (0);
     900        }
     901        *pptr = end + 1;
     902        return ((uint16_t)value);
     903}
     904
     905/*------------------------------------------------------------------------*
     906 *      usb_quirk_add_entry_from_str
     907 *
     908 * Add a USB quirk entry from string.
     909 *     "VENDOR PRODUCT LO_REV HI_REV QUIRK[,QUIRK[,...]]"
     910 *------------------------------------------------------------------------*/
     911static void
     912usb_quirk_add_entry_from_str(const char *name, const char *env)
     913{
     914        struct usb_quirk_entry entry = { };
     915        struct usb_quirk_entry *new;
     916        uint16_t quirk_idx;
     917        uint16_t quirk;
     918        const char *end;
     919
     920        /* check for invalid environment variable */
     921        if (name == NULL || env == NULL)
     922                return;
     923
     924        if (bootverbose)
     925                printf("Adding USB QUIRK '%s' = '%s'\n", name, env);
     926
     927        /* parse device information */
     928        entry.vid = usb_quirk_strtou16(&env, name, "Vendor ID");
     929        entry.pid = usb_quirk_strtou16(&env, name, "Product ID");
     930        entry.lo_rev = usb_quirk_strtou16(&env, name, "Low revision");
     931        entry.hi_rev = usb_quirk_strtou16(&env, name, "High revision");
     932
     933        /* parse quirk information */
     934        quirk_idx = 0;
     935        while (*env != 0 && quirk_idx != USB_SUB_QUIRKS_MAX) {
     936                /* skip whitespace before quirks */
     937                while (*env == ' ' || *env == '\t')
     938                        env++;
     939
     940                /* look for quirk separation character */
     941                end = strchr(env, ',');
     942                if (end == NULL)
     943                        end = env + strlen(env);
     944
     945                /* lookup quirk in string table */
     946                quirk = usb_strquirk(env, end - env);
     947                if (quirk < USB_QUIRK_MAX) {
     948                        entry.quirks[quirk_idx++] = quirk;
     949                } else {
     950                        printf("%s: unknown USB quirk '%.*s' (skipped)\n",
     951                            name, (int)(end - env), env);
     952                }
     953                env = end;
     954
     955                /* skip quirk delimiter, if any */
     956                if (*env != 0)
     957                        env++;
     958        }
     959
     960        /* register quirk */
     961        if (quirk_idx != 0) {
     962                if (*env != 0) {
     963                        printf("%s: Too many USB quirks, only %d allowed!\n",
     964                            name, USB_SUB_QUIRKS_MAX);
     965                }
     966                mtx_lock(&usb_quirk_mtx);
     967                new = usb_quirk_get_entry(entry.vid, entry.pid,
     968                    entry.lo_rev, entry.hi_rev, 1);
     969                if (new == NULL)
     970                        printf("%s: USB quirks table is full!\n", name);
     971                else
     972                        memcpy(new->quirks, entry.quirks, sizeof(entry.quirks));
     973                mtx_unlock(&usb_quirk_mtx);
     974        } else {
     975                printf("%s: No USB quirks found!\n", name);
     976        }
     977}
     978
    853979static void
    854980usb_quirk_init(void *arg)
    855981{
     982#ifndef __rtems__
     983        char envkey[sizeof(USB_QUIRK_ENVROOT) + 2];     /* 2 digits max, 0 to 99 */
     984        int i;
     985#endif /* __rtems__ */
     986 
    856987        /* initialize mutex */
    857988        mtx_init(&usb_quirk_mtx, "USB quirk", NULL, MTX_DEF);
    858989
     990#ifndef __rtems__
     991        /* look for quirks defined by the environment variable */
     992        for (i = 0; i != 100; i++) {
     993                snprintf(envkey, sizeof(envkey), USB_QUIRK_ENVROOT "%d", i);
     994
     995                /* Stop at first undefined var */
     996                if (!testenv(envkey))
     997                        break;
     998
     999                /* parse environment variable */
     1000                usb_quirk_add_entry_from_str(envkey, kern_getenv(envkey));
     1001        }
     1002#endif /* __rtems__ */
     1003       
    8591004        /* register our function */
    8601005        usb_test_quirk_p = &usb_test_quirk_by_info;
  • freebsd/sys/dev/usb/quirk/usb_quirk.h

    rc164446 r02279d6  
    5555        UQ_MS_REVZ,             /* mouse has Z-axis reversed */
    5656        UQ_NO_STRINGS,          /* string descriptors are broken */
    57         UQ_OPEN_CLEARSTALL,     /* device needs clear endpoint stall */
    5857        UQ_POWER_CLAIM,         /* hub lies about power status */
    5958        UQ_SPUR_BUT_UP,         /* spurious mouse button up events */
     
    110109        UQ_AU_VENDOR_CLASS,     /* audio device uses vendor and not audio class */
    111110        UQ_SINGLE_CMD_MIDI,     /* at most one command per USB packet */
     111        UQ_MSC_DYMO_EJECT,      /* ejects Dymo MSC device */
    112112
    113113        USB_QUIRK_MAX
  • freebsd/sys/dev/usb/storage/umass.c

    rc164446 r02279d6  
    170170
    171171static SYSCTL_NODE(_hw_usb, OID_AUTO, umass, CTLFLAG_RW, 0, "USB umass");
    172 SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
     172SYSCTL_INT(_hw_usb_umass, OID_AUTO, debug, CTLFLAG_RWTUN,
    173173    &umass_debug, 0, "umass debug level");
    174 TUNABLE_INT("hw.usb.umass.debug", &umass_debug);
    175 SYSCTL_INT(_hw_usb_umass, OID_AUTO, throttle, CTLFLAG_RW | CTLFLAG_TUN,
     174SYSCTL_INT(_hw_usb_umass, OID_AUTO, throttle, CTLFLAG_RWTUN,
    176175    &umass_throttle, 0, "Forced delay between commands in milliseconds");
    177 TUNABLE_INT("hw.usb.umass.throttle", &umass_throttle);
    178176#else
    179177#define DIF(...) do { } while (0)
     
    703701        DEVMETHOD(device_attach, umass_attach),
    704702        DEVMETHOD(device_detach, umass_detach),
    705         {0, 0}
     703
     704        DEVMETHOD_END
    706705};
    707706
     
    21262125        if (bootverbose)
    21272126#endif
    2128                 printf("%s:%d:%d:%d: Attached to scbus%d\n",
     2127                printf("%s:%d:%d: Attached to scbus%d\n",
    21292128                    sc->sc_name, cam_sim_path(sc->sc_sim),
    2130                     sc->sc_unit, CAM_LUN_WILDCARD,
    2131                     cam_sim_path(sc->sc_sim));
     2129                    sc->sc_unit, cam_sim_path(sc->sc_sim));
    21322130}
    21332131#endif /* __rtems__ */
     
    21812179                        }
    21822180
    2183                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SCSI_IO: "
     2181                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_SCSI_IO: "
    21842182                            "cmd: 0x%02x, flags: 0x%02x, "
    21852183                            "%db cmd/%db data/%db sense\n",
    21862184                            cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id,
    2187                             ccb->ccb_h.target_lun, cmd[0],
     2185                            (uintmax_t)ccb->ccb_h.target_lun, cmd[0],
    21882186                            ccb->ccb_h.flags & CAM_DIR_MASK, ccb->csio.cdb_len,
    21892187                            ccb->csio.dxfer_len, ccb->csio.sense_len);
    21902188
    21912189                        if (sc->sc_transfer.ccb) {
    2192                                 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SCSI_IO: "
     2190                                DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_SCSI_IO: "
    21932191                                    "I/O in progress, deferring\n",
    21942192                                    cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id,
    2195                                     ccb->ccb_h.target_lun);
     2193                                    (uintmax_t)ccb->ccb_h.target_lun);
    21962194                                ccb->ccb_h.status = CAM_SCSI_BUSY;
    21972195                                xpt_done(ccb);
     
    23112309                        struct ccb_pathinq *cpi = &ccb->cpi;
    23122310
    2313                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_PATH_INQ:.\n",
     2311                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_PATH_INQ:.\n",
    23142312                            sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id,
    2315                             ccb->ccb_h.target_lun);
     2313                            (uintmax_t)ccb->ccb_h.target_lun);
    23162314
    23172315                        /* host specific information */
     
    23662364        case XPT_RESET_DEV:
    23672365                {
    2368                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_RESET_DEV:.\n",
     2366                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_RESET_DEV:.\n",
    23692367                            cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id,
    2370                             ccb->ccb_h.target_lun);
     2368                            (uintmax_t)ccb->ccb_h.target_lun);
    23712369
    23722370                        umass_reset(sc);
     
    23802378                        struct ccb_trans_settings *cts = &ccb->cts;
    23812379
    2382                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_GET_TRAN_SETTINGS:.\n",
     2380                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_GET_TRAN_SETTINGS:.\n",
    23832381                            cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id,
    2384                             ccb->ccb_h.target_lun);
     2382                            (uintmax_t)ccb->ccb_h.target_lun);
    23852383
    23862384                        cts->protocol = PROTO_SCSI;
     
    23962394        case XPT_SET_TRAN_SETTINGS:
    23972395                {
    2398                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_SET_TRAN_SETTINGS:.\n",
     2396                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_SET_TRAN_SETTINGS:.\n",
    23992397                            cam_sim_path(sc->sc_sim), ccb->ccb_h.target_id,
    2400                             ccb->ccb_h.target_lun);
     2398                            (uintmax_t)ccb->ccb_h.target_lun);
    24012399
    24022400                        ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
     
    24142412        case XPT_NOOP:
    24152413                {
    2416                         DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:XPT_NOOP:.\n",
     2414                        DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:XPT_NOOP:.\n",
    24172415                            sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id,
    2418                             ccb->ccb_h.target_lun);
     2416                            (uintmax_t)ccb->ccb_h.target_lun);
    24192417
    24202418                        ccb->ccb_h.status = CAM_REQ_CMP;
     
    24232421                }
    24242422        default:
    2425                 DPRINTF(sc, UDMASS_SCSI, "%d:%d:%d:func_code 0x%04x: "
     2423                DPRINTF(sc, UDMASS_SCSI, "%d:%d:%jx:func_code 0x%04x: "
    24262424                    "Not implemented\n",
    24272425                    sc ? cam_sim_path(sc->sc_sim) : -1, ccb->ccb_h.target_id,
    2428                     ccb->ccb_h.target_lun, ccb->ccb_h.func_code);
     2426                    (uintmax_t)ccb->ccb_h.target_lun, ccb->ccb_h.func_code);
    24292427
    24302428                ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
     
    27112709        case SYNCHRONIZE_CACHE:
    27122710        case WRITE_10:
    2713         case 0x2f:                      /* VERIFY_10 is absent from
    2714                                          * scsi_all.h??? */
     2711        case VERIFY_10:
    27152712        case INQUIRY:
    27162713        case MODE_SELECT_10:
  • freebsd/sys/dev/usb/ufm_ioctl.h

    rc164446 r02279d6  
     1/* $FreeBSD$ */
    12/*-
    23 * Copyright (c) 2001 M. Warner Losh
     
    2930 */
    3031
    31 /*  $FreeBSD$ */
     32#ifndef _UFM_IOCTL_H_
     33#define _UFM_IOCTL_H_
    3234
    3335#include <sys/ioccom.h>
     
    3840#define FM_STOP         _IOWR('U', 203, int)
    3941#define FM_GET_STAT     _IOWR('U', 204, int)
     42
     43#endif                  /* _UFM_IOCTL_H_ */
  • freebsd/sys/dev/usb/usb.h

    rc164446 r02279d6  
    4141
    4242#if defined(_KERNEL)
     43#ifndef USB_GLOBAL_INCLUDE_FILE
    4344#include <rtems/bsd/local/opt_usb.h>
     45#endif
    4446
    4547/* Declare parent SYSCTL USB node. */
     
    4850#endif
    4951
     52#ifndef USB_GLOBAL_INCLUDE_FILE
    5053#include <sys/malloc.h>
     54#endif
    5155
    5256MALLOC_DECLARE(M_USB);
    5357MALLOC_DECLARE(M_USBDEV);
    54 MALLOC_DECLARE(M_USBHC);
    5558#endif /* _KERNEL */
    5659
     60#ifndef USB_GLOBAL_INCLUDE_FILE
    5761#include <dev/usb/usb_endian.h>
    5862#include <dev/usb/usb_freebsd.h>
     63#endif
    5964
    6065#define USB_STACK_VERSION 2000          /* 2.0 */
     
    108113/* Allow for marginal and non-conforming devices. */
    109114#define USB_PORT_RESET_DELAY            50      /* ms */
    110 #define USB_PORT_ROOT_RESET_DELAY       250     /* ms */
     115#define USB_PORT_ROOT_RESET_DELAY       200     /* ms */
    111116#define USB_PORT_RESET_RECOVERY         250     /* ms */
    112117#define USB_PORT_POWERUP_DELAY          300     /* ms */
     
    436441#define UISUBCLASS_NETWORK_CONTROL_MODEL 13
    437442
     443#define UIPROTO_CDC_NONE                0
    438444#define UIPROTO_CDC_AT                  1
    439445
     
    537543#define UE_ISO_SYNC     0x0c
    538544#define UE_GET_ISO_TYPE(a)      ((a) & UE_ISO_TYPE)
     545#define UE_ISO_USAGE    0x30
     546#define UE_ISO_USAGE_DATA       0x00
     547#define UE_ISO_USAGE_FEEDBACK   0x10
     548#define UE_ISO_USAGE_IMPLICT_FB 0x20
     549#define UE_GET_ISO_USAGE(a)     ((a) & UE_ISO_USAGE)
    539550        uWord   wMaxPacketSize;
    540551#define UE_ZERO_MPS 0xFFFF              /* for internal use only */
     
    548559        uByte   bMaxBurst;
    549560        uByte   bmAttributes;
     561#define UE_GET_BULK_STREAMS(x) ((x) & 0x0F)
     562#define UE_GET_SS_ISO_MULT(x) ((x) & 0x03)
    550563        uWord   wBytesPerInterval;
    551564} __packed;
     
    562575
    563576#define USB_MAKE_STRING_DESC(m,name)    \
    564 struct name {                           \
     577static const struct {                   \
    565578  uByte bLength;                        \
    566579  uByte bDescriptorType;                \
    567580  uByte bData[sizeof((uint8_t []){m})]; \
    568 } __packed;                             \
    569 static const struct name name = {       \
    570   .bLength = sizeof(struct name),       \
     581} __packed name = {                     \
     582  .bLength = sizeof(name),              \
    571583  .bDescriptorType = UDESC_STRING,      \
    572584  .bData = { m },                       \
    573585}
     586
     587struct usb_string_lang {
     588        uByte bLength;
     589        uByte bDescriptorType;
     590        uByte bData[2];
     591} __packed;
     592typedef struct usb_string_lang usb_string_lang_t;
    574593
    575594struct usb_hub_descriptor {
     
    746765
    747766/*
    748  * Supported host contoller modes.
     767 * Supported host controller modes.
    749768 */
    750769enum usb_hc_mode {
     
    756775
    757776/*
    758  * The "USB_MODE" macros defines all the supported device states.
     777 * The "USB_STATE" enums define all the supported device states.
    759778 */
    760779enum usb_dev_state {
     
    766785};
    767786#define USB_STATE_MAX   (USB_STATE_CONFIGURED+1)
     787
     788/*
     789 * The "USB_EP_MODE" macros define all the currently supported
     790 * endpoint modes.
     791 */
     792enum usb_ep_mode {
     793        USB_EP_MODE_DEFAULT,
     794        USB_EP_MODE_STREAMS,    /* USB3.0 specific */
     795        USB_EP_MODE_HW_MASS_STORAGE,
     796        USB_EP_MODE_HW_SERIAL,
     797        USB_EP_MODE_HW_ETHERNET_CDC,
     798        USB_EP_MODE_HW_ETHERNET_NCM,
     799        USB_EP_MODE_MAX
     800};
    768801#endif                                  /* _USB_STANDARD_H_ */
  • freebsd/sys/dev/usb/usb_bus.h

    rc164446 r02279d6  
    5454        struct usb_bus_stat stats_err;
    5555        struct usb_bus_stat stats_ok;
    56 #ifndef __rtems__
     56#if USB_HAVE_ROOT_MOUNT_HOLD
    5757        struct root_hold_token *bus_roothold;
    58 #endif /* __rtems__ */
     58#endif
     59
     60/* convenience macros */
     61#define USB_BUS_TT_PROC(bus) USB_BUS_NON_GIANT_ISOC_PROC(bus)
     62#define USB_BUS_CS_PROC(bus) USB_BUS_NON_GIANT_ISOC_PROC(bus)
     63 
     64#if USB_HAVE_PER_BUS_PROCESS
     65#define USB_BUS_GIANT_PROC(bus) (&(bus)->giant_callback_proc)
     66#define USB_BUS_NON_GIANT_ISOC_PROC(bus) (&(bus)->non_giant_isoc_callback_proc)
     67#define USB_BUS_NON_GIANT_BULK_PROC(bus) (&(bus)->non_giant_bulk_callback_proc)
     68#define USB_BUS_EXPLORE_PROC(bus) (&(bus)->explore_proc)
     69#define USB_BUS_CONTROL_XFER_PROC(bus) (&(bus)->control_xfer_proc)
    5970        /*
    60          * There are two callback processes. One for Giant locked
    61          * callbacks. One for non-Giant locked callbacks. This should
    62          * avoid congestion and reduce response time in most cases.
     71         * There are three callback processes. One for Giant locked
     72         * callbacks. One for non-Giant locked non-periodic callbacks
     73         * and one for non-Giant locked periodic callbacks. This
     74         * should avoid congestion and reduce response time in most
     75         * cases.
    6376         */
    6477        struct usb_process giant_callback_proc;
    65         struct usb_process non_giant_callback_proc;
     78        struct usb_process non_giant_isoc_callback_proc;
     79        struct usb_process non_giant_bulk_callback_proc;
    6680
    6781        /* Explore process */
     
    7084        /* Control request process */
    7185        struct usb_process control_xfer_proc;
     86#endif
    7287
    7388        struct usb_bus_msg explore_msg[2];
     
    86101         */
    87102        struct mtx bus_mtx;
     103        struct mtx bus_spin_lock;
    88104        struct usb_xfer_queue intr_q;
    89105        struct usb_callout power_wdog;  /* power management */
     
    96112        struct usb_dma_tag dma_tags[USB_BUS_DMA_TAG_MAX];
    97113#endif
    98         struct usb_bus_methods *methods;        /* filled by HC driver */
     114        const struct usb_bus_methods *methods;  /* filled by HC driver */
    99115        struct usb_device **devices;
    100116
  • freebsd/sys/dev/usb/usb_busdma.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    6265#include <dev/usb/usb_controller.h>
    6366#include <dev/usb/usb_bus.h>
     67#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6468
    6569#if USB_HAVE_BUSDMA
     
    130134        res->physaddr = 0;
    131135#endif
     136}
     137
     138/*------------------------------------------------------------------------*
     139 *  usb_pc_buffer_is_aligned - verify alignment
     140 *
     141 * This function is used to check if a page cache buffer is properly
     142 * aligned to reduce the use of bounce buffers in PIO mode.
     143 *------------------------------------------------------------------------*/
     144uint8_t
     145usb_pc_buffer_is_aligned(struct usb_page_cache *pc, usb_frlength_t offset,
     146    usb_frlength_t len, usb_frlength_t mask)
     147{
     148        struct usb_page_search buf_res;
     149
     150        while (len != 0) {
     151
     152                usbd_get_page(pc, offset, &buf_res);
     153
     154                if (buf_res.length > len)
     155                        buf_res.length = len;
     156                if (USB_P2U(buf_res.buffer) & mask)
     157                        return (0);
     158                if (buf_res.length & mask)
     159                        return (0);
     160
     161                offset += buf_res.length;
     162                len -= buf_res.length;
     163        }
     164        return (1);
    132165}
    133166
     
    442475        pc->page_offset_end += rem;
    443476#ifdef USB_DEBUG
    444         if (rem != (USB_P2U(pc->buffer) & (USB_PAGE_SIZE - 1))) {
     477        if (nseg > 1 &&
     478            ((segs->ds_addr + segs->ds_len) & (USB_PAGE_SIZE - 1)) !=
     479            ((segs + 1)->ds_addr & (USB_PAGE_SIZE - 1))) {
    445480                /*
    446                  * This check verifies that the physical address is correct:
     481                 * This check verifies there is no page offset hole
     482                 * between the first and second segment. See the
     483                 * BUS_DMA_KEEP_PG_OFFSET flag.
    447484                 */
    448485                DPRINTFN(0, "Page offset was not preserved\n");
  • freebsd/sys/dev/usb/usb_busdma.h

    rc164446 r02279d6  
    2828#define _USB_BUSDMA_H_
    2929
     30#ifndef USB_GLOBAL_INCLUDE_FILE
    3031#include <sys/uio.h>
    3132#include <sys/mbuf.h>
    3233
    3334#include <machine/bus.h>
     35#endif
    3436
    3537/* defines */
     
    158160void    usb_pc_dmamap_destroy(struct usb_page_cache *pc);
    159161void    usb_pc_free_mem(struct usb_page_cache *pc);
     162uint8_t usb_pc_buffer_is_aligned(struct usb_page_cache *pc,
     163            usb_frlength_t offset, usb_frlength_t len,
     164            usb_frlength_t mask);
    160165
    161166#endif                                  /* _USB_BUSDMA_H_ */
  • freebsd/sys/dev/usb/usb_controller.h

    rc164446 r02279d6  
    108108
    109109        void    (*get_hw_ep_profile) (struct usb_device *udev, const struct usb_hw_ep_profile **ppf, uint8_t ep_addr);
    110         void    (*set_stall) (struct usb_device *udev, struct usb_xfer *xfer, struct usb_endpoint *ep, uint8_t *did_stall);
     110        void    (*xfer_stall) (struct usb_xfer *xfer);
     111        void    (*set_stall) (struct usb_device *udev, struct usb_endpoint *ep, uint8_t *did_stall);
    111112
    112113        /* USB Device mode mandatory. USB Host mode optional. */
     
    143144
    144145        usb_error_t     (*set_address) (struct usb_device *, struct mtx *, uint16_t);
     146
     147        /* Optional for device and host mode */
     148
     149        usb_error_t     (*set_endpoint_mode) (struct usb_device *, struct usb_endpoint *, uint8_t);
    145150};
    146151
  • freebsd/sys/dev/usb/usb_core.c

    rc164446 r02279d6  
    3333 */
    3434
     35#ifdef USB_GLOBAL_INCLUDE_FILE
     36#include USB_GLOBAL_INCLUDE_FILE
     37#else
    3538#include <sys/stdint.h>
    3639#include <sys/stddef.h>
     
    5457#include <dev/usb/usb.h>
    5558#include <dev/usb/usbdi.h>
     59#endif                  /* USB_GLOBAL_INCLUDE_FILE */
     60
     61const struct usb_string_lang usb_string_lang_en = {
     62        sizeof(usb_string_lang_en), UDESC_STRING,
     63        { 0x09, 0x04 } /* American English */
     64};
    5665
    5766MALLOC_DEFINE(M_USB, "USB", "USB");
    5867MALLOC_DEFINE(M_USBDEV, "USBdev", "USB device");
    59 MALLOC_DEFINE(M_USBHC, "USBHC", "USB host controller");
    6068
    6169MODULE_VERSION(usb, 1);
  • freebsd/sys/dev/usb/usb_core.h

    rc164446 r02279d6  
    4545#define USB_BUS_UNLOCK(_b)              mtx_unlock(&(_b)->bus_mtx)
    4646#define USB_BUS_LOCK_ASSERT(_b, _t)     mtx_assert(&(_b)->bus_mtx, _t)
     47#define USB_BUS_SPIN_LOCK(_b)           mtx_lock_spin(&(_b)->bus_spin_lock)
     48#define USB_BUS_SPIN_UNLOCK(_b)         mtx_unlock_spin(&(_b)->bus_spin_lock)
     49#define USB_BUS_SPIN_LOCK_ASSERT(_b, _t)        mtx_assert(&(_b)->bus_spin_lock, _t)
    4750#define USB_XFER_LOCK(_x)               mtx_lock((_x)->xroot->xfer_mtx)
    4851#define USB_XFER_UNLOCK(_x)             mtx_unlock((_x)->xroot->xfer_mtx)
     
    7073struct usb_xfer;
    7174struct usb_xfer_root;
     75struct usb_string_lang;
    7276
    7377/* typedefs */
     
    155159        usb_frcount_t aframes;          /* actual number of USB frames
    156160                                         * transferred */
     161        usb_stream_t stream_id;         /* USB3.0 specific field */
    157162
    158163        uint16_t max_packet_size;
     
    177182
    178183extern struct mtx usb_ref_lock;
     184extern const struct usb_string_lang usb_string_lang_en;
    179185
    180186/* typedefs */
  • freebsd/sys/dev/usb/usb_debug.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5861#include <ddb/ddb.h>
    5962#include <ddb/db_sym.h>
     63#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6064
    6165/*
     
    6670
    6771SYSCTL_NODE(_hw, OID_AUTO, usb, CTLFLAG_RW, 0, "USB debugging");
    68 SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
     72SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RWTUN,
    6973    &usb_debug, 0, "Debug level");
    70 TUNABLE_INT("hw.usb.debug", &usb_debug);
    7174
    7275#ifdef USB_DEBUG
     
    7780static int usb_timings_sysctl_handler(SYSCTL_HANDLER_ARGS);
    7881
    79 TUNABLE_INT("hw.usb.timings.port_reset_delay", (int *)&usb_port_reset_delay);
    80 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_delay, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     82SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_delay, CTLTYPE_UINT | CTLFLAG_RWTUN,
    8183    &usb_port_reset_delay, sizeof(usb_port_reset_delay),
    8284    usb_timings_sysctl_handler, "IU", "Port Reset Delay");
    83 TUNABLE_INT("hw.usb.timings.port_root_reset_delay", (int *)&usb_port_root_reset_delay);
    84 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_root_reset_delay, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     85SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_root_reset_delay, CTLTYPE_UINT | CTLFLAG_RWTUN,
    8586    &usb_port_root_reset_delay, sizeof(usb_port_root_reset_delay),
    8687    usb_timings_sysctl_handler, "IU", "Root Port Reset Delay");
    87 TUNABLE_INT("hw.usb.timings.port_reset_recovery", (int *)&usb_port_reset_recovery);
    88 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_recovery, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     88SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_recovery, CTLTYPE_UINT | CTLFLAG_RWTUN,
    8989    &usb_port_reset_recovery, sizeof(usb_port_reset_recovery),
    9090    usb_timings_sysctl_handler, "IU", "Port Reset Recovery");
    91 TUNABLE_INT("hw.usb.timings.port_powerup_delay", (int *)&usb_port_powerup_delay);
    92 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_powerup_delay, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     91SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_powerup_delay, CTLTYPE_UINT | CTLFLAG_RWTUN,
    9392    &usb_port_powerup_delay, sizeof(usb_port_powerup_delay),
    9493    usb_timings_sysctl_handler, "IU", "Port PowerUp Delay");
    95 TUNABLE_INT("hw.usb.timings.port_resume_delay", (int *)&usb_port_resume_delay);
    96 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_resume_delay, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     94SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_resume_delay, CTLTYPE_UINT | CTLFLAG_RWTUN,
    9795    &usb_port_resume_delay, sizeof(usb_port_resume_delay),
    9896    usb_timings_sysctl_handler, "IU", "Port Resume Delay");
    99 TUNABLE_INT("hw.usb.timings.set_address_settle", (int *)&usb_set_address_settle);
    100 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, set_address_settle, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     97SYSCTL_PROC(_hw_usb_timings, OID_AUTO, set_address_settle, CTLTYPE_UINT | CTLFLAG_RWTUN,
    10198    &usb_set_address_settle, sizeof(usb_set_address_settle),
    10299    usb_timings_sysctl_handler, "IU", "Set Address Settle");
    103 TUNABLE_INT("hw.usb.timings.resume_delay", (int *)&usb_resume_delay);
    104 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_delay, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     100SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_delay, CTLTYPE_UINT | CTLFLAG_RWTUN,
    105101    &usb_resume_delay, sizeof(usb_resume_delay),
    106102    usb_timings_sysctl_handler, "IU", "Resume Delay");
    107 TUNABLE_INT("hw.usb.timings.resume_wait", (int *)&usb_resume_wait);
    108 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_wait, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     103SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_wait, CTLTYPE_UINT | CTLFLAG_RWTUN,
    109104    &usb_resume_wait, sizeof(usb_resume_wait),
    110105    usb_timings_sysctl_handler, "IU", "Resume Wait");
    111 TUNABLE_INT("hw.usb.timings.resume_recovery", (int *)&usb_resume_recovery);
    112 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_recovery, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     106SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_recovery, CTLTYPE_UINT | CTLFLAG_RWTUN,
    113107    &usb_resume_recovery, sizeof(usb_resume_recovery),
    114108    usb_timings_sysctl_handler, "IU", "Resume Recovery");
    115 TUNABLE_INT("hw.usb.timings.extra_power_up_time", (int *)&usb_extra_power_up_time);
    116 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, extra_power_up_time, CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_TUN,
     109SYSCTL_PROC(_hw_usb_timings, OID_AUTO, extra_power_up_time, CTLTYPE_UINT | CTLFLAG_RWTUN,
    117110    &usb_extra_power_up_time, sizeof(usb_extra_power_up_time),
    118111    usb_timings_sysctl_handler, "IU", "Extra PowerUp Time");
     
    164157{
    165158        struct usb_xfer *xfer;
     159        usb_stream_t x;
    166160
    167161        printf("usb_dump_queue: endpoint=%p xfer: ", ep);
    168         TAILQ_FOREACH(xfer, &ep->endpoint_q.head, wait_entry) {
    169                 printf(" %p", xfer);
     162        for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
     163                TAILQ_FOREACH(xfer, &ep->endpoint_q[x].head, wait_entry)
     164                        printf(" %p", xfer);
    170165        }
    171166        printf("\n");
  • freebsd/sys/dev/usb/usb_debug.h

    rc164446 r02279d6  
    3939  if ((USB_DEBUG_VAR) >= (n)) {                 \
    4040    printf("%s: " fmt,                          \
    41            __FUNCTION__,## __VA_ARGS__);        \
     41           __FUNCTION__ ,##__VA_ARGS__);        \
    4242  }                                             \
    4343} while (0)
  • freebsd/sys/dev/usb/usb_dev.c

    rc164446 r02279d6  
    3030 */
    3131
     32#ifdef USB_GLOBAL_INCLUDE_FILE
     33#include USB_GLOBAL_INCLUDE_FILE
     34#else
    3235#include <sys/stdint.h>
    3336#include <sys/stddef.h>
     
    7881
    7982#include <machine/stdarg.h>
     83#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    8084
    8185#if USB_HAVE_UGEN
     
    8589
    8690static SYSCTL_NODE(_hw_usb, OID_AUTO, dev, CTLFLAG_RW, 0, "USB device");
    87 SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN,
     91SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RWTUN,
    8892    &usb_fifo_debug, 0, "Debug Level");
    89 TUNABLE_INT("hw.usb.dev.debug", &usb_fifo_debug);
    9093#endif
    9194
     
    830833                                /* wait until all data has been written */
    831834                                f->flag_sleeping = 1;
    832                                 err = cv_wait_sig(&f->cv_io, f->priv_mtx);
     835                                err = cv_timedwait_sig(&f->cv_io, f->priv_mtx,
     836                                    USB_MS_TO_TICKS(USB_DEFAULT_TIMEOUT));
    833837                                if (err) {
    834838                                        DPRINTF("signal received\n");
  • freebsd/sys/dev/usb/usb_dev.h

    rc164446 r02279d6  
    2828#define _USB_DEV_H_
    2929
     30#ifndef USB_GLOBAL_INCLUDE_FILE
    3031#include <sys/file.h>
    3132#include <sys/selinfo.h>
     
    3334#include <sys/signalvar.h>
    3435#include <sys/proc.h>
     36#endif
    3537
    3638struct usb_fifo;
  • freebsd/sys/dev/usb/usb_device.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    8184#include <dev/usb/usb_controller.h>
    8285#include <dev/usb/usb_bus.h>
     86#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    8387
    8488/* function prototypes  */
     
    111115/* This variable is global to allow easy access to it: */
    112116
    113 int     usb_template = 0;
     117#ifdef  USB_TEMPLATE
     118int     usb_template = USB_TEMPLATE;
     119#else
     120int     usb_template;
     121#endif
    114122
    115123#ifndef __rtems__
    116 TUNABLE_INT("hw.usb.usb_template", &usb_template);
    117 SYSCTL_INT(_hw_usb, OID_AUTO, template, CTLFLAG_RW | CTLFLAG_TUN,
     124SYSCTL_INT(_hw_usb, OID_AUTO, template, CTLFLAG_RWTUN,
    118125    &usb_template, 0, "Selected USB device side template");
    119126#endif /* __rtems__ */
     
    125132
    126133#ifndef __rtems__
    127 TUNABLE_INT("hw.usb.usb_lang_id", &usb_lang_id);
    128 SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_id, CTLFLAG_RW | CTLFLAG_TUN,
     134SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_id, CTLFLAG_RWTUN,
    129135    &usb_lang_id, 0, "Preferred USB language ID");
    130136
    131 TUNABLE_INT("hw.usb.usb_lang_mask", &usb_lang_mask);
    132 SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_mask, CTLFLAG_RW | CTLFLAG_TUN,
     137SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_mask, CTLFLAG_RWTUN,
    133138    &usb_lang_mask, 0, "Preferred USB language mask");
    134139#endif /* __rtems__ */
     
    209214         * The default endpoint is always present and is checked separately:
    210215         */
    211         if ((udev->ctrl_ep.edesc) &&
     216        if ((udev->ctrl_ep.edesc != NULL) &&
    212217            ((udev->ctrl_ep.edesc->bEndpointAddress & EA_MASK) == ea_val)) {
    213218                ep = &udev->ctrl_ep;
     
    327332         * interface. "iface_index" and "direction" is ignored:
    328333         */
    329         if ((udev->ctrl_ep.edesc) &&
     334        if ((udev->ctrl_ep.edesc != NULL) &&
    330335            ((udev->ctrl_ep.edesc->bEndpointAddress & ea_mask) == ea_val) &&
    331336            ((udev->ctrl_ep.edesc->bmAttributes & type_mask) == type_val) &&
     
    361366        return (USB_ERR_NORMAL_COMPLETION);
    362367}
    363 
    364368
    365369/*------------------------------------------------------------------------*
     
    376380    struct usb_endpoint *ep)
    377381{
    378         struct usb_bus_methods *methods;
     382        const struct usb_bus_methods *methods;
     383        usb_stream_t x;
    379384
    380385        methods = udev->bus->methods;
     
    386391        ep->ecomp = ecomp;
    387392        ep->iface_index = iface_index;
    388         TAILQ_INIT(&ep->endpoint_q.head);
    389         ep->endpoint_q.command = &usbd_pipe_start;
     393
     394        /* setup USB stream queues */
     395        for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
     396                TAILQ_INIT(&ep->endpoint_q[x].head);
     397                ep->endpoint_q[x].command = &usbd_pipe_start;
     398        }
    390399
    391400        /* the pipe is not supported by the hardware */
    392401        if (ep->methods == NULL)
    393402                return;
     403
     404        /* check for SUPER-speed streams mode endpoint */
     405        if (udev->speed == USB_SPEED_SUPER && ecomp != NULL &&
     406            (edesc->bmAttributes & UE_XFERTYPE) == UE_BULK &&
     407            (UE_GET_BULK_STREAMS(ecomp->bmAttributes) != 0)) {
     408                usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_STREAMS);
     409        } else {
     410                usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_DEFAULT);
     411        }
    394412
    395413        /* clear stall, if any */
     
    495513#if USB_HAVE_COMPAT_LINUX
    496514        /* free Linux compat device, if any */
    497         if (udev->linux_endpoint_start) {
    498                 usb_linux_free_device(udev);
     515        if (udev->linux_endpoint_start != NULL) {
     516                usb_linux_free_device_p(udev);
    499517                udev->linux_endpoint_start = NULL;
    500518        }
     
    506524        if (udev->cdesc != NULL) {
    507525                if (udev->flags.usb_mode != USB_MODE_DEVICE)
    508                         free(udev->cdesc, M_USB);
     526                        usbd_free_config_desc(udev, udev->cdesc);
    509527                udev->cdesc = NULL;
    510528        }
     
    565583                /* normal request */
    566584                err = usbd_req_get_config_desc_full(udev,
    567                     NULL, &cdp, M_USB, index);
     585                    NULL, &cdp, index);
    568586        }
    569587        if (err) {
     
    742760        while ((id = usb_idesc_foreach(udev->cdesc, &ips))) {
    743761
    744                 /* check for interface overflow */
    745                 if (ips.iface_index == USB_IFACE_MAX)
    746                         break;                  /* crazy */
    747 
    748762                iface = udev->ifaces + ips.iface_index;
    749763
     
    792806                while ((ed = usb_edesc_foreach(udev->cdesc, ed))) {
    793807
    794                         if (temp == USB_EP_MAX)
    795                                 break;                  /* crazy */
     808                        /* check if endpoint limit has been reached */
     809                        if (temp >= USB_MAX_EP_UNITS) {
     810                                DPRINTF("Endpoint limit reached\n");
     811                                break;
     812                        }
    796813
    797814                        ep = udev->endpoints + temp;
     
    820837        if (cmd == USB_CFG_ALLOC) {
    821838                udev->ifaces_max = ips.iface_index;
     839#if (USB_HAVE_FIXED_IFACE == 0)
    822840                udev->ifaces = NULL;
    823841                if (udev->ifaces_max != 0) {
     
    829847                        }
    830848                }
     849#endif
     850#if (USB_HAVE_FIXED_ENDPOINT == 0)
    831851                if (ep_max != 0) {
    832852                        udev->endpoints = malloc(sizeof(*ep) * ep_max,
     
    839859                        udev->endpoints = NULL;
    840860                }
     861#endif
    841862                USB_BUS_LOCK(udev->bus);
    842863                udev->endpoints_max = ep_max;
     
    845866                USB_BUS_UNLOCK(udev->bus);
    846867        }
    847 
     868#if (USB_HAVE_FIXED_IFACE == 0) || (USB_HAVE_FIXED_ENDPOINT == 0)
    848869done:
     870#endif
    849871        if (err) {
    850872                if (cmd == USB_CFG_ALLOC) {
     
    856878                        USB_BUS_UNLOCK(udev->bus);
    857879
    858                         /* cleanup */
    859                         if (udev->ifaces != NULL)
    860                                 free(udev->ifaces, M_USB);
    861                         if (udev->endpoints != NULL)
    862                                 free(udev->endpoints, M_USB);
    863 
     880#if (USB_HAVE_FIXED_IFACE == 0)
     881                        free(udev->ifaces, M_USB);
    864882                        udev->ifaces = NULL;
     883#endif
     884#if (USB_HAVE_FIXED_ENDPOINT == 0)
     885                        free(udev->endpoints, M_USB);
    865886                        udev->endpoints = NULL;
     887#endif
    866888                        udev->ifaces_max = 0;
    867889                }
     
    949971{
    950972        struct usb_xfer *xfer;
     973        usb_stream_t x;
    951974        uint8_t et;
    952975        uint8_t was_stalled;
     
    9911014        if (do_stall || (!was_stalled)) {
    9921015                if (!was_stalled) {
    993                         /* lookup the current USB transfer, if any */
    994                         xfer = ep->endpoint_q.curr;
    995                 } else {
    996                         xfer = NULL;
    997                 }
    998 
    999                 /*
    1000                  * If "xfer" is non-NULL the "set_stall" method will
    1001                  * complete the USB transfer like in case of a timeout
    1002                  * setting the error code "USB_ERR_STALLED".
    1003                  */
    1004                 (udev->bus->methods->set_stall) (udev, xfer, ep, &do_stall);
     1016                        for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
     1017                                /* lookup the current USB transfer, if any */
     1018                                xfer = ep->endpoint_q[x].curr;
     1019                                if (xfer != NULL) {
     1020                                        /*
     1021                                         * The "xfer_stall" method
     1022                                         * will complete the USB
     1023                                         * transfer like in case of a
     1024                                         * timeout setting the error
     1025                                         * code "USB_ERR_STALLED".
     1026                                         */
     1027                                        (udev->bus->methods->xfer_stall) (xfer);
     1028                                }
     1029                        }
     1030                }
     1031                (udev->bus->methods->set_stall) (udev, ep, &do_stall);
    10051032        }
    10061033        if (!do_stall) {
     
    10101037                (udev->bus->methods->clear_stall) (udev, ep);
    10111038
    1012                 /* start up the current or next transfer, if any */
    1013                 usb_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr);
     1039                /* start the current or next transfer, if any */
     1040                for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
     1041                        usb_command_wrapper(&ep->endpoint_q[x],
     1042                            ep->endpoint_q[x].curr);
     1043                }
    10141044        }
    10151045        USB_BUS_UNLOCK(udev->bus);
     
    13191349         */
    13201350        if (iface_index == USB_IFACE_INDEX_ANY) {
     1351
     1352                if (usb_test_quirk(&uaa, UQ_MSC_DYMO_EJECT) != 0 &&
     1353                    usb_dymo_eject(udev, 0) == 0) {
     1354                        /* success, mark the udev as disappearing */
     1355                        uaa.dev_state = UAA_DEV_EJECTING;
     1356                }
    13211357
    13221358                EVENTHANDLER_INVOKE(usb_dev_configured, udev, &uaa);
     
    18621898                        goto repeat_set_config;
    18631899                }
     1900#if USB_HAVE_MSCTEST
    18641901                if (config_index == 0) {
    18651902                        /*
     
    18741911                        }
    18751912                }
    1876         }
     1913#endif
     1914        }
     1915#if USB_HAVE_MSCTEST
    18771916        if (set_config_failed == 0 && config_index == 0 &&
    18781917            usb_test_quirk(&uaa, UQ_MSC_NO_SYNC_CACHE) == 0 &&
     
    18901929                }
    18911930        }
     1931#endif
    18921932
    18931933config_done:
     
    19992039        LIST_INSERT_HEAD(&bus->pd_cleanup_list, pd, pd_next);
    20002040        /* get cleanup going */
    2001         usb_proc_msignal(&bus->explore_proc,
     2041        usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    20022042            &bus->cleanup_msg[0], &bus->cleanup_msg[1]);
    20032043        USB_BUS_UNLOCK(bus);
     
    21482188         */
    21492189        USB_BUS_LOCK(udev->bus);
    2150         usb_proc_mwait(&udev->bus->non_giant_callback_proc,
     2190        usb_proc_mwait(USB_BUS_CS_PROC(udev->bus),
    21512191            &udev->cs_msg[0], &udev->cs_msg[1]);
    21522192        USB_BUS_UNLOCK(udev->bus);
     
    28122852        return (USB_ERR_NOMEM);
    28132853}
     2854
     2855/*
     2856 * The following function is used to select the endpoint mode. It
     2857 * should not be called outside enumeration context.
     2858 */
     2859
     2860usb_error_t
     2861usbd_set_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep,
     2862    uint8_t ep_mode)
     2863{   
     2864        usb_error_t error;
     2865        uint8_t do_unlock;
     2866
     2867        /* Prevent re-enumeration */
     2868        do_unlock = usbd_enum_lock(udev);
     2869
     2870        if (udev->bus->methods->set_endpoint_mode != NULL) {
     2871                error = (udev->bus->methods->set_endpoint_mode) (
     2872                    udev, ep, ep_mode);
     2873        } else if (ep_mode != USB_EP_MODE_DEFAULT) {
     2874                error = USB_ERR_INVAL;
     2875        } else {
     2876                error = 0;
     2877        }
     2878
     2879        /* only set new mode regardless of error */
     2880        ep->ep_mode = ep_mode;
     2881
     2882        if (do_unlock)
     2883                usbd_enum_unlock(udev);
     2884        return (error);
     2885}
     2886
     2887uint8_t
     2888usbd_get_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep)
     2889{
     2890        return (ep->ep_mode);
     2891}
  • freebsd/sys/dev/usb/usb_device.h

    rc164446 r02279d6  
    4343#define USB_CTRL_XFER_MAX 2
    4444
    45 /* "usb_parse_config()" commands */
     45/* "usb_config_parse()" commands */
    4646
    4747#define USB_CFG_ALLOC 0
     
    140140        struct usb_config_descriptor *cd;
    141141        struct usb_device *udev;
    142         struct usb_bus_methods *methods;
     142        const struct usb_bus_methods *methods;
    143143        uint8_t bmOutAlloc[(USB_EP_MAX + 15) / 16];
    144144        uint8_t bmInAlloc[(USB_EP_MAX + 15) / 16];
     
    187187        struct cv ctrlreq_cv;
    188188        struct cv ref_cv;
     189#if (USB_HAVE_FIXED_IFACE == 0)
    189190        struct usb_interface *ifaces;
     191#else
     192        struct usb_interface ifaces[USB_IFACE_MAX];
     193#endif
    190194        struct usb_endpoint ctrl_ep;    /* Control Endpoint 0 */
     195#if (USB_HAVE_FIXED_ENDPOINT == 0)
    191196        struct usb_endpoint *endpoints;
     197#else
     198        struct usb_endpoint endpoints[USB_MAX_EP_UNITS];
     199#endif
    192200        struct usb_power_save pwr_save;/* power save data */
    193201        struct usb_bus *bus;            /* our USB BUS */
     
    265273
    266274        union usb_device_scratch scratch;
     275
     276#if (USB_HAVE_FIXED_CONFIG != 0)
     277        uint32_t config_data[(USB_CONFIG_MAX + 3) / 4];
     278#endif
    267279};
    268280
  • freebsd/sys/dev/usb/usb_dynamic.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5356#include <dev/usb/usb_device.h>
    5457#include <dev/usb/usb_dynamic.h>
     58#include <dev/usb/usb_request.h>
     59#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    5560
    5661/* function prototypes */
    5762static usb_handle_req_t usb_temp_get_desc_w;
    5863static usb_temp_setup_by_index_t usb_temp_setup_by_index_w;
     64#if USB_HAVE_COMPAT_LINUX
     65static usb_linux_free_device_t usb_linux_free_device_w;
     66#endif
    5967static usb_temp_unsetup_t usb_temp_unsetup_w;
    6068static usb_test_quirk_t usb_test_quirk_w;
     
    6472usb_handle_req_t *usb_temp_get_desc_p = &usb_temp_get_desc_w;
    6573usb_temp_setup_by_index_t *usb_temp_setup_by_index_p = &usb_temp_setup_by_index_w;
     74#if USB_HAVE_COMPAT_LINUX
     75usb_linux_free_device_t *usb_linux_free_device_p = &usb_linux_free_device_w;
     76#endif
    6677usb_temp_unsetup_t *usb_temp_unsetup_p = &usb_temp_unsetup_w;
    6778usb_test_quirk_t *usb_test_quirk_p = &usb_test_quirk_w;
     
    97108usb_temp_unsetup_w(struct usb_device *udev)
    98109{
    99         if (udev->usb_template_ptr) {
     110        usbd_free_config_desc(udev, udev->usb_template_ptr);
     111        udev->usb_template_ptr = NULL;
     112}
    100113
    101                 free(udev->usb_template_ptr, M_USB);
    102 
    103                 udev->usb_template_ptr = NULL;
    104         }
     114#if USB_HAVE_COMPAT_LINUX
     115static void
     116usb_linux_free_device_w(struct usb_device *udev)
     117{
     118        /* NOP */
    105119}
     120#endif
    106121
    107122void
     
    149164        pause("WAIT", hz);
    150165}
     166
     167#if USB_HAVE_COMPAT_LINUX
     168void
     169usb_linux_unload(void *arg)
     170{
     171        /* reset function pointers */
     172
     173        usb_linux_free_device_p = &usb_linux_free_device_w;
     174 
     175        /* wait for CPU to exit the loaded functions, if any */
     176
     177        /* XXX this is a tradeoff */
     178
     179        pause("WAIT", hz);
     180}
     181#endif
  • freebsd/sys/dev/usb/usb_dynamic.h

    rc164446 r02279d6  
    4343                            int fflag, struct thread *td);
    4444typedef void            (usb_temp_unsetup_t)(struct usb_device *udev);
     45typedef void            (usb_linux_free_device_t)(struct usb_device *udev);
    4546
    4647/* global function pointers */
     
    4849extern usb_handle_req_t *usb_temp_get_desc_p;
    4950extern usb_temp_setup_by_index_t *usb_temp_setup_by_index_p;
     51extern usb_linux_free_device_t *usb_linux_free_device_p;
    5052extern usb_temp_unsetup_t *usb_temp_unsetup_p;
    5153extern usb_test_quirk_t *usb_test_quirk_p;
     
    5557/* function prototypes */
    5658
     59void    usb_linux_unload(void *);
    5760void    usb_temp_unload(void *);
    5861void    usb_quirk_unload(void *);
  • freebsd/sys/dev/usb/usb_endian.h

    rc164446 r02279d6  
    2828#define _USB_ENDIAN_H_
    2929
     30#ifndef USB_GLOBAL_INCLUDE_FILE
    3031#include <sys/stdint.h>
    3132#include <sys/endian.h>
     33#endif
    3234
    3335/*
  • freebsd/sys/dev/usb/usb_error.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    4851#include <dev/usb/usb.h>
    4952#include <dev/usb/usbdi.h>
     53#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    5054
    5155static const char* usb_errstr_table[USB_ERR_MAX] = {
  • freebsd/sys/dev/usb/usb_freebsd.h

    rc164446 r02279d6  
    4343#define USB_HAVE_POWERD 1
    4444#define USB_HAVE_MSCTEST 1
     45#define USB_HAVE_MSCTEST_DETACH 1
    4546#define USB_HAVE_PF 1
     47#define USB_HAVE_ROOT_MOUNT_HOLD 1
     48#define USB_HAVE_ID_SECTION 1
     49#define USB_HAVE_PER_BUS_PROCESS 1
     50#define USB_HAVE_FIXED_ENDPOINT 0
     51#define USB_HAVE_FIXED_IFACE 0
     52#define USB_HAVE_FIXED_CONFIG 0
     53#define USB_HAVE_FIXED_PORT 0
     54#define USB_HAVE_DISABLE_ENUM 1
    4655#endif /* __rtems__ */
    4756
     
    5564/* Use default value. */
    5665#undef USB_HOST_ALIGN
     66#if defined(__arm__) || defined(__mips__) || defined(__powerpc__)
     67#define USB_HOST_ALIGN  32              /* Arm and MIPS need at least this much, if not more */
     68#else
    5769#define USB_HOST_ALIGN    8             /* bytes, must be power of two */
     70#endif
    5871#endif
    5972/* Sanity check for USB_HOST_ALIGN: Verify power of two. */
     
    6477#define USB_BUS_MAX 256                 /* units */
    6578#define USB_MAX_DEVICES 128             /* units */
     79#define USB_CONFIG_MAX 65535            /* bytes */
    6680#define USB_IFACE_MAX 32                /* units */
    6781#define USB_FIFO_MAX 128                /* units */
     82#define USB_MAX_EP_STREAMS 8            /* units */
     83#define USB_MAX_EP_UNITS 32             /* units */
     84#define USB_MAX_PORTS 255               /* units */
    6885
    6986#define USB_MAX_FS_ISOC_FRAMES_PER_XFER (120)   /* units */
     
    8299typedef uint32_t usb_ticks_t;           /* system defined */
    83100typedef uint16_t usb_power_mask_t;      /* see "USB_HW_POWER_XXX" */
     101typedef uint16_t usb_stream_t;          /* stream ID */
    84102
    85103#endif  /* _USB_FREEBSD_H_ */
  • freebsd/sys/dev/usb/usb_generic.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    7073#include <dev/usb/usb_controller.h>
    7174#include <dev/usb/usb_bus.h>
     75#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    7276
    7377#if USB_HAVE_UGEN
     
    130134
    131135static SYSCTL_NODE(_hw_usb, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic");
    132 SYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &ugen_debug,
     136SYSCTL_INT(_hw_usb_ugen, OID_AUTO, debug, CTLFLAG_RWTUN, &ugen_debug,
    133137    0, "Debug level");
    134 TUNABLE_INT("hw.usb.ugen.debug", &ugen_debug);
    135138#endif
    136139
     
    255258        usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
    256259        usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
     260        usb_config[0].stream_id = 0;    /* XXX support more stream ID's */
    257261        usb_config[0].direction = UE_DIR_TX;
    258262        usb_config[0].interval = USB_DEFAULT_INTERVAL;
     
    323327        usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
    324328        usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
     329        usb_config[0].stream_id = 0;    /* XXX support more stream ID's */
    325330        usb_config[0].direction = UE_DIR_RX;
    326331        usb_config[0].interval = USB_DEFAULT_INTERVAL;
     
    678683            (ugd->ugd_config_index == udev->curr_config_index)) {
    679684                cdesc = usbd_get_config_descriptor(udev);
    680                 if (cdesc == NULL) {
     685                if (cdesc == NULL)
    681686                        return (ENXIO);
    682                 }
    683687                free_data = 0;
    684688
    685689        } else {
     690#if (USB_HAVE_FIXED_CONFIG == 0)
    686691                if (usbd_req_get_config_desc_full(udev,
    687                     NULL, &cdesc, M_USBDEV,
    688                     ugd->ugd_config_index)) {
     692                    NULL, &cdesc, ugd->ugd_config_index)) {
    689693                        return (ENXIO);
    690694                }
    691695                free_data = 1;
     696#else
     697                /* configuration descriptor data is shared */
     698                return (EINVAL);
     699#endif
    692700        }
    693701
     
    703711        error = copyout(cdesc, ugd->ugd_data, len);
    704712
    705         if (free_data) {
    706                 free(cdesc, M_USBDEV);
    707         }
     713        if (free_data)
     714                usbd_free_config_desc(udev, cdesc);
     715
    708716        return (error);
    709717}
     
    13881396                struct usb_fs_stop *pstop;
    13891397                struct usb_fs_open *popen;
     1398                struct usb_fs_open_stream *popen_stream;
    13901399                struct usb_fs_close *pclose;
    13911400                struct usb_fs_clear_stall_sync *pstall;
     
    14521461
    14531462        case USB_FS_OPEN:
     1463        case USB_FS_OPEN_STREAM:
    14541464                if (u.popen->ep_index >= f->fs_ep_max) {
    14551465                        error = EINVAL;
     
    15031513                usb_config[0].bufsize = u.popen->max_bufsize;
    15041514                usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
     1515                if (cmd == USB_FS_OPEN_STREAM)
     1516                        usb_config[0].stream_id = u.popen_stream->stream_id;
    15051517
    15061518                if (usb_config[0].type == UE_CONTROL) {
  • freebsd/sys/dev/usb/usb_handle_request.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    6467#include <dev/usb/usb_controller.h>
    6568#include <dev/usb/usb_bus.h>
     69#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6670
    6771/* function prototypes */
  • freebsd/sys/dev/usb/usb_hid.c

    rc164446 r02279d6  
    11#include <machine/rtems-bsd-kernel-space.h>
    22
     3/* $FreeBSD$ */
    34/*      $NetBSD: hid.c,v 1.17 2001/11/13 06:24:53 lukem Exp $   */
    4 
    5 
    6 #include <sys/cdefs.h>
    7 __FBSDID("$FreeBSD$");
    85/*-
    96 * Copyright (c) 1998 The NetBSD Foundation, Inc.
     
    3633 */
    3734
     35#ifdef USB_GLOBAL_INCLUDE_FILE
     36#include USB_GLOBAL_INCLUDE_FILE
     37#else
    3838#include <sys/stdint.h>
    3939#include <sys/stddef.h>
     
    6767#include <dev/usb/usb_device.h>
    6868#include <dev/usb/usb_request.h>
     69#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6970
    7071static void hid_clear_local(struct hid_item *);
  • freebsd/sys/dev/usb/usb_hub.c

    rc164446 r02279d6  
    3333 */
    3434
     35#ifdef USB_GLOBAL_INCLUDE_FILE
     36#include USB_GLOBAL_INCLUDE_FILE
     37#else
    3538#include <sys/stdint.h>
    3639#include <sys/stddef.h>
     
    7174#include <dev/usb/usb_controller.h>
    7275#include <dev/usb/usb_bus.h>
     76#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    7377
    7478#define UHUB_INTR_INTERVAL 250          /* ms */
     
    8589
    8690static SYSCTL_NODE(_hw_usb, OID_AUTO, uhub, CTLFLAG_RW, 0, "USB HUB");
    87 SYSCTL_INT(_hw_usb_uhub, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &uhub_debug, 0,
     91SYSCTL_INT(_hw_usb_uhub, OID_AUTO, debug, CTLFLAG_RWTUN, &uhub_debug, 0,
    8892    "Debug level");
    89 TUNABLE_INT("hw.usb.uhub.debug", &uhub_debug);
    9093#endif
    9194
     
    9396static int usb_power_timeout = 30;      /* seconds */
    9497
    95 SYSCTL_INT(_hw_usb, OID_AUTO, power_timeout, CTLFLAG_RW,
     98SYSCTL_INT(_hw_usb, OID_AUTO, power_timeout, CTLFLAG_RWTUN,
    9699    &usb_power_timeout, 0, "USB power timeout");
     100#endif
     101
     102#if USB_HAVE_DISABLE_ENUM
     103static int usb_disable_enumeration = 0;
     104SYSCTL_INT(_hw_usb, OID_AUTO, disable_enumeration, CTLFLAG_RWTUN,
     105    &usb_disable_enumeration, 0, "Set to disable all USB device enumeration.");
     106
     107static int usb_disable_port_power = 0;
     108SYSCTL_INT(_hw_usb, OID_AUTO, disable_port_power, CTLFLAG_RWTUN,
     109    &usb_disable_port_power, 0, "Set to disable all USB port power.");
    97110#endif
    98111
     
    104117struct uhub_softc {
    105118        struct uhub_current_state sc_st;/* current state */
     119#if (USB_HAVE_FIXED_PORT != 0)
     120        struct usb_hub sc_hub;
     121#endif
    106122        device_t sc_dev;                /* base device */
    107123        struct mtx sc_mtx;              /* our mutex */
    108124        struct usb_device *sc_udev;     /* USB device */
    109125        struct usb_xfer *sc_xfer[UHUB_N_TRANSFER];      /* interrupt xfer */
     126#if USB_HAVE_DISABLE_ENUM
     127        int sc_disable_enumeration;
     128        int sc_disable_port_power;
     129#endif
    110130        uint8_t sc_flags;
    111131#define UHUB_FLAG_DID_EXPLORE 0x01
    112         char    sc_name[32];
    113132};
    114133
     
    182201        DEVMETHOD(bus_child_pnpinfo_str, uhub_child_pnpinfo_string),
    183202        DEVMETHOD(bus_driver_added, uhub_driver_added),
    184         {0, 0}
     203        DEVMETHOD_END
    185204};
    186205
     
    330349        up->req_reset_tt = req;
    331350        /* get reset transfer started */
    332         usb_proc_msignal(&udev->bus->non_giant_callback_proc,
     351        usb_proc_msignal(USB_BUS_TT_PROC(udev->bus),
    333352            &hub->tt_msg[0], &hub->tt_msg[1]);
    334353}
     
    616635            portno, UHF_C_PORT_CONNECTION);
    617636
    618         if (err) {
     637        if (err)
    619638                goto error;
    620         }
     639
    621640        /* check if there is a child */
    622641
     
    631650
    632651        err = uhub_read_port_status(sc, portno);
    633         if (err) {
     652        if (err)
    634653                goto error;
    635         }
     654
     655#if USB_HAVE_DISABLE_ENUM
     656        /* check if we should skip enumeration from this USB HUB */
     657        if (usb_disable_enumeration != 0 ||
     658            sc->sc_disable_enumeration != 0) {
     659                DPRINTF("Enumeration is disabled!\n");
     660                goto error;
     661        }
     662#endif
    636663        /* check if nothing is connected to the port */
    637664
    638         if (!(sc->sc_st.port_status & UPS_CURRENT_CONNECT_STATUS)) {
     665        if (!(sc->sc_st.port_status & UPS_CURRENT_CONNECT_STATUS))
    639666                goto error;
    640         }
     667
    641668        /* check if there is no power on the port and print a warning */
    642669
     
    11861213        struct usb_hub_descriptor hubdesc20;
    11871214        struct usb_hub_ss_descriptor hubdesc30;
     1215#if USB_HAVE_DISABLE_ENUM
     1216        struct sysctl_ctx_list *sysctl_ctx;
     1217        struct sysctl_oid *sysctl_tree;
     1218#endif
    11881219        uint16_t pwrdly;
     1220        uint16_t nports;
    11891221        uint8_t x;
    1190         uint8_t nports;
    11911222        uint8_t portno;
    11921223        uint8_t removable;
     
    11981229
    11991230        mtx_init(&sc->sc_mtx, "USB HUB mutex", NULL, MTX_DEF);
    1200 
    1201         snprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
    1202             device_get_nameunit(dev));
    12031231
    12041232        device_set_usb_desc(dev);
     
    13351363                goto error;
    13361364        }
     1365        if (nports > USB_MAX_PORTS) {
     1366                DPRINTF("Port limit exceeded\n");
     1367                goto error;
     1368        }
     1369#if (USB_HAVE_FIXED_PORT == 0)
    13371370        hub = malloc(sizeof(hub[0]) + (sizeof(hub->ports[0]) * nports),
    13381371            M_USBDEV, M_WAITOK | M_ZERO);
    13391372
    1340         if (hub == NULL) {
     1373        if (hub == NULL)
    13411374                goto error;
    1342         }
     1375#else
     1376        hub = &sc->sc_hub;
     1377#endif
    13431378        udev->hub = hub;
    13441379
     
    13791414        usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME));
    13801415
     1416#if USB_HAVE_DISABLE_ENUM
     1417        /* Add device sysctls */
     1418
     1419        sysctl_ctx = device_get_sysctl_ctx(dev);
     1420        sysctl_tree = device_get_sysctl_tree(dev);
     1421
     1422        if (sysctl_ctx != NULL && sysctl_tree != NULL) {
     1423                (void) SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
     1424                    OID_AUTO, "disable_enumeration", CTLFLAG_RWTUN,
     1425                    &sc->sc_disable_enumeration, 0,
     1426                    "Set to disable enumeration on this USB HUB.");
     1427
     1428                (void) SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
     1429                    OID_AUTO, "disable_port_power", CTLFLAG_RWTUN,
     1430                    &sc->sc_disable_port_power, 0,
     1431                    "Set to disable USB port power on this USB HUB.");
     1432        }
     1433#endif
    13811434        /*
    13821435         * To have the best chance of success we do things in the exact same
     
    14331486                        break;
    14341487                }
    1435                 if (!err) {
    1436                         /* turn the power on */
    1437                         err = usbd_req_set_port_feature(udev, NULL,
    1438                             portno, UHF_PORT_POWER);
    1439                 }
    1440                 if (err) {
    1441                         DPRINTFN(0, "port %d power on failed, %s\n",
     1488                if (err == 0) {
     1489#if USB_HAVE_DISABLE_ENUM
     1490                        /* check if we should disable USB port power or not */
     1491                        if (usb_disable_port_power != 0 ||
     1492                            sc->sc_disable_port_power != 0) {
     1493                                /* turn the power off */
     1494                                DPRINTFN(2, "Turning port %d power off\n", portno);
     1495                                err = usbd_req_clear_port_feature(udev, NULL,
     1496                                    portno, UHF_PORT_POWER);
     1497                        } else {
     1498#endif
     1499                                /* turn the power on */
     1500                                DPRINTFN(2, "Turning port %d power on\n", portno);
     1501                                err = usbd_req_set_port_feature(udev, NULL,
     1502                                    portno, UHF_PORT_POWER);
     1503#if USB_HAVE_DISABLE_ENUM
     1504                        }
     1505#endif
     1506                }
     1507                if (err != 0) {
     1508                        DPRINTFN(0, "port %d power on or off failed, %s\n",
    14421509                            portno, usbd_errstr(err));
    14431510                }
     
    14681535        usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
    14691536
    1470         if (udev->hub) {
    1471                 free(udev->hub, M_USBDEV);
    1472                 udev->hub = NULL;
    1473         }
     1537#if (USB_HAVE_FIXED_PORT == 0)
     1538        free(udev->hub, M_USBDEV);
     1539#endif
     1540        udev->hub = NULL;
    14741541
    14751542        mtx_destroy(&sc->sc_mtx);
     
    15151582        /* Make sure our TT messages are not queued anywhere */
    15161583        USB_BUS_LOCK(bus);
    1517         usb_proc_mwait(&bus->non_giant_callback_proc,
     1584        usb_proc_mwait(USB_BUS_TT_PROC(bus),
    15181585            &hub->tt_msg[0], &hub->tt_msg[1]);
    15191586        USB_BUS_UNLOCK(bus);
    15201587#endif
     1588
     1589#if (USB_HAVE_FIXED_PORT == 0)
    15211590        free(hub, M_USBDEV);
     1591#endif
    15221592        sc->sc_udev->hub = NULL;
    15231593
     
    16151685                goto done;
    16161686        }
     1687        snprintf(buf, buflen, "bus=%u hubaddr=%u port=%u devaddr=%u"
     1688            " interface=%u"
    16171689#if USB_HAVE_UGEN
    1618         ugen_name = res.udev->ugen_name;
    1619 #else
    1620         ugen_name = "?";
    1621 #endif
    1622         snprintf(buf, buflen, "bus=%u hubaddr=%u port=%u devaddr=%u interface=%u"
    1623             " ugen=%s",
    1624             (res.udev->parent_hub != NULL) ? res.udev->parent_hub->device_index : 0,
    1625             res.portno, device_get_unit(res.udev->bus->bdev),
    1626             res.udev->device_index, res.iface_index, ugen_name);
     1690            " ugen=%s"
     1691#endif
     1692            , device_get_unit(res.udev->bus->bdev)
     1693            , (res.udev->parent_hub != NULL) ?
     1694            res.udev->parent_hub->device_index : 0
     1695            , res.portno, res.udev->device_index, res.iface_index
     1696#if USB_HAVE_UGEN
     1697            , res.udev->ugen_name
     1698#endif
     1699            );
    16271700done:
    16281701        mtx_unlock(&Giant);
     
    20502123                }
    20512124
    2052                 /* check double buffered transfers */
    2053 
    2054                 TAILQ_FOREACH(pipe_xfer, &xfer->endpoint->endpoint_q.head,
     2125                /*
     2126                 * Check double buffered transfers. Only stream ID
     2127                 * equal to zero is valid here!
     2128                 */
     2129                TAILQ_FOREACH(pipe_xfer, &xfer->endpoint->endpoint_q[0].head,
    20552130                    wait_entry) {
    20562131
     
    22062281                bus->do_probe = 1;
    22072282        }
    2208         if (usb_proc_msignal(&bus->explore_proc,
     2283        if (usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
    22092284            &bus->explore_msg[0], &bus->explore_msg[1])) {
    22102285                /* ignore */
     
    27892864usbd_filter_power_mode(struct usb_device *udev, uint8_t power_mode)
    27902865{
    2791         struct usb_bus_methods *mtod;
     2866        const struct usb_bus_methods *mtod;
    27922867        int8_t temp;
    27932868
  • freebsd/sys/dev/usb/usb_hub.h

    rc164446 r02279d6  
    5555        uint8_t isoc_last_time;
    5656        uint8_t nports;
     57#if (USB_HAVE_FIXED_PORT == 0)
    5758        struct usb_port ports[0];
     59#else
     60        struct usb_port ports[USB_MAX_PORTS];
     61#endif
    5862};
    5963
  • freebsd/sys/dev/usb/usb_ioctl.h

    rc164446 r02279d6  
    3030#define _USB_IOCTL_H_
    3131
     32#ifndef USB_GLOBAL_INCLUDE_FILE
    3233#include <sys/ioccom.h>
    3334#include <sys/cdefs.h>
     
    3738#include <dev/usb/usb_endian.h>
    3839#include <dev/usb/usb.h>
     40#endif
    3941
    4042#define USB_DEVICE_NAME "usbctl"
     
    6365        USB_TEMP_KBD,           /* USB Keyboard */
    6466        USB_TEMP_MOUSE,         /* USB Mouse */
     67        USB_TEMP_PHONE,         /* USB Phone */
     68        USB_TEMP_SERIALNET,     /* USB CDC Ethernet and Modem */
     69        USB_TEMP_MIDI,          /* USB MIDI */
    6570        USB_TEMP_MAX,
    6671};
     
    330335#define USB_FS_CLOSE            _IOW ('U', 198, struct usb_fs_close)
    331336#define USB_FS_CLEAR_STALL_SYNC _IOW ('U', 199, struct usb_fs_clear_stall_sync)
     337#define USB_FS_OPEN_STREAM      _IOWR('U', 200, struct usb_fs_open_stream)
    332338
    333339/* USB quirk system interface */
  • freebsd/sys/dev/usb/usb_lookup.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5053#include <dev/usb/usb.h>
    5154#include <dev/usb/usbdi.h>
     55#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    5256
    5357/*------------------------------------------------------------------------*
     
    177181#endif
    178182
    179 #ifdef KLD_MODULE
     183#if defined(KLD_MODULE) && (USB_HAVE_ID_SECTION != 0)
    180184static const char __section("bus_autoconf_format") __used usb_id_format[] = {
    181185
  • freebsd/sys/dev/usb/usb_mbuf.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5053#include <dev/usb/usb_dev.h>
    5154#include <dev/usb/usb_mbuf.h>
     55#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    5256
    5357/*------------------------------------------------------------------------*
  • freebsd/sys/dev/usb/usb_msctest.c

    rc164446 r02279d6  
    3535 */
    3636
     37#ifdef USB_GLOBAL_INCLUDE_FILE
     38#include USB_GLOBAL_INCLUDE_FILE
     39#else
    3740#include <sys/stdint.h>
    3841#include <sys/stddef.h>
     
    6972#include <dev/usb/usb_util.h>
    7073#include <dev/usb/quirk/usb_quirk.h>
     74#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    7175
    7276enum {
     
    8690};
    8791
    88 #define SCSI_MAX_LEN    MAX(0x100, BULK_SIZE)
     92#define SCSI_MAX_LEN    MAX(SCSI_FIXED_BLOCK_SIZE, USB_MSCTEST_BULK_SIZE)
    8993#define SCSI_INQ_LEN    0x24
    9094#define SCSI_SENSE_LEN  0xFF
     95#define SCSI_FIXED_BLOCK_SIZE 512       /* bytes */
    9196
    9297static uint8_t scsi_test_unit_ready[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     
    114119static uint8_t scsi_allow_removal[] =   { 0x1e, 0, 0, 0, 0, 0 };
    115120
    116 #define BULK_SIZE               64      /* dummy */
     121#ifndef USB_MSCTEST_BULK_SIZE
     122#define USB_MSCTEST_BULK_SIZE   64      /* dummy */
     123#endif
     124
    117125#define ERR_CSW_FAILED          -1
    118126
     
    176184static usb_callback_t bbb_data_wr_cs_callback;
    177185static usb_callback_t bbb_status_callback;
     186static usb_callback_t bbb_raw_write_callback;
    178187
    179188static void     bbb_done(struct bbb_transfer *, int);
     
    183192static int      bbb_command_start(struct bbb_transfer *, uint8_t, uint8_t,
    184193                    void *, size_t, void *, size_t, usb_timeout_t);
    185 static struct bbb_transfer *bbb_attach(struct usb_device *, uint8_t);
     194static struct bbb_transfer *bbb_attach(struct usb_device *, uint8_t, uint8_t);
    186195static void     bbb_detach(struct bbb_transfer *);
    187196
     
    243252                .callback = &bbb_status_callback,
    244253                .timeout = 1 * USB_MS_HZ,       /* 1 second  */
     254        },
     255};
     256
     257static const struct usb_config bbb_raw_config[1] = {
     258
     259        [0] = {
     260                .type = UE_BULK_INTR,
     261                .endpoint = UE_ADDR_ANY,
     262                .direction = UE_DIR_OUT,
     263                .bufsize = SCSI_MAX_LEN,
     264                .flags = {.ext_buffer = 1,.proxy_buffer = 1,},
     265                .callback = &bbb_raw_write_callback,
     266                .timeout = 1 * USB_MS_HZ,       /* 1 second */
    245267        },
    246268};
     
    466488}
    467489
     490static void
     491bbb_raw_write_callback(struct usb_xfer *xfer, usb_error_t error)
     492{
     493        struct bbb_transfer *sc = usbd_xfer_softc(xfer);
     494        usb_frlength_t max_bulk = usbd_xfer_max_len(xfer);
     495        int actlen, sumlen;
     496
     497        usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
     498
     499        switch (USB_GET_STATE(xfer)) {
     500        case USB_ST_TRANSFERRED:
     501                sc->data_rem -= actlen;
     502                sc->data_ptr += actlen;
     503                sc->actlen += actlen;
     504
     505                if (actlen < sumlen) {
     506                        /* short transfer */
     507                        sc->data_rem = 0;
     508                }
     509        case USB_ST_SETUP:
     510                DPRINTF("max_bulk=%d, data_rem=%d\n",
     511                    max_bulk, sc->data_rem);
     512
     513                if (sc->data_rem == 0) {
     514                        bbb_done(sc, 0);
     515                        break;
     516                }
     517                if (max_bulk > sc->data_rem) {
     518                        max_bulk = sc->data_rem;
     519                }
     520                usbd_xfer_set_timeout(xfer, sc->data_timeout);
     521                usbd_xfer_set_frame_data(xfer, 0, sc->data_ptr, max_bulk);
     522                usbd_transfer_submit(xfer);
     523                break;
     524
     525        default:                        /* Error */
     526                bbb_done(sc, error);
     527                break;
     528        }
     529}
     530
    468531/*------------------------------------------------------------------------*
    469532 *      bbb_command_start - execute a SCSI command synchronously
     
    501564}
    502565
     566/*------------------------------------------------------------------------*
     567 *      bbb_raw_write - write a raw BULK message synchronously
     568 *
     569 * Return values
     570 * 0: Success
     571 * Else: Failure
     572 *------------------------------------------------------------------------*/
     573static int
     574bbb_raw_write(struct bbb_transfer *sc, const void *data_ptr, size_t data_len,
     575    usb_timeout_t data_timeout)
     576{
     577        sc->data_ptr = __DECONST(void *, data_ptr);
     578        sc->data_len = data_len;
     579        sc->data_rem = data_len;
     580        sc->data_timeout = (data_timeout + USB_MS_HZ);
     581        sc->actlen = 0;
     582        sc->error = 0;
     583
     584        DPRINTFN(1, "BULK DATA = %*D\n", (int)data_len,
     585            (const char *)data_ptr, ":");
     586
     587        mtx_lock(&sc->mtx);
     588        usbd_transfer_start(sc->xfer[0]);
     589        while (usbd_transfer_pending(sc->xfer[0]))
     590                cv_wait(&sc->cv, &sc->mtx);
     591        mtx_unlock(&sc->mtx);
     592        return (sc->error);
     593}
     594
    503595static struct bbb_transfer *
    504 bbb_attach(struct usb_device *udev, uint8_t iface_index)
     596bbb_attach(struct usb_device *udev, uint8_t iface_index,
     597    uint8_t bInterfaceClass)
    505598{
    506599        struct usb_interface *iface;
    507600        struct usb_interface_descriptor *id;
     601        const struct usb_config *pconfig;
    508602        struct bbb_transfer *sc;
    509603        usb_error_t err;
     604        int nconfig;
     605
     606#if USB_HAVE_MSCTEST_DETACH
    510607        uint8_t do_unlock;
    511608
     
    521618        if (do_unlock)
    522619                usbd_enum_unlock(udev);
     620#endif
    523621
    524622        iface = usbd_get_iface(udev, iface_index);
     
    527625
    528626        id = iface->idesc;
    529         if (id == NULL || id->bInterfaceClass != UICLASS_MASS)
     627        if (id == NULL || id->bInterfaceClass != bInterfaceClass)
    530628                return (NULL);
    531629
    532         switch (id->bInterfaceSubClass) {
    533         case UISUBCLASS_SCSI:
    534         case UISUBCLASS_UFI:
    535         case UISUBCLASS_SFF8020I:
    536         case UISUBCLASS_SFF8070I:
    537                 break;
    538         default:
    539                 return (NULL);
    540         }
    541 
    542         switch (id->bInterfaceProtocol) {
    543         case UIPROTO_MASS_BBB_OLD:
    544         case UIPROTO_MASS_BBB:
     630        switch (id->bInterfaceClass) {
     631        case UICLASS_MASS:
     632                switch (id->bInterfaceSubClass) {
     633                case UISUBCLASS_SCSI:
     634                case UISUBCLASS_UFI:
     635                case UISUBCLASS_SFF8020I:
     636                case UISUBCLASS_SFF8070I:
     637                        break;
     638                default:
     639                        return (NULL);
     640                }
     641                switch (id->bInterfaceProtocol) {
     642                case UIPROTO_MASS_BBB_OLD:
     643                case UIPROTO_MASS_BBB:
     644                        break;
     645                default:
     646                        return (NULL);
     647                }
     648                pconfig = bbb_config;
     649                nconfig = ST_MAX;
     650                break;
     651        case UICLASS_HID:
     652                switch (id->bInterfaceSubClass) {
     653                case 0:
     654                        break;
     655                default:
     656                        return (NULL);
     657                }
     658                pconfig = bbb_raw_config;
     659                nconfig = 1;
    545660                break;
    546661        default:
     
    552667        cv_init(&sc->cv, "WBBB");
    553668
    554         err = usbd_transfer_setup(udev, &iface_index, sc->xfer, bbb_config,
    555             ST_MAX, sc, &sc->mtx);
     669        err = usbd_transfer_setup(udev, &iface_index, sc->xfer, pconfig,
     670            nconfig, sc, &sc->mtx);
    556671        if (err) {
    557672                bbb_detach(sc);
    558673                return (NULL);
    559674        }
    560         /* store pointer to DMA buffers */
    561         sc->buffer = usbd_xfer_get_frame_buffer(
    562             sc->xfer[ST_DATA_RD], 0);
    563         sc->buffer_size =
    564             usbd_xfer_max_len(sc->xfer[ST_DATA_RD]);
    565         sc->cbw = usbd_xfer_get_frame_buffer(
    566             sc->xfer[ST_COMMAND], 0);
    567         sc->csw = usbd_xfer_get_frame_buffer(
    568             sc->xfer[ST_STATUS], 0);
    569 
     675        switch (id->bInterfaceClass) {
     676        case UICLASS_MASS:
     677                /* store pointer to DMA buffers */
     678                sc->buffer = usbd_xfer_get_frame_buffer(
     679                    sc->xfer[ST_DATA_RD], 0);
     680                sc->buffer_size =
     681                    usbd_xfer_max_len(sc->xfer[ST_DATA_RD]);
     682                sc->cbw = usbd_xfer_get_frame_buffer(
     683                    sc->xfer[ST_COMMAND], 0);
     684                sc->csw = usbd_xfer_get_frame_buffer(
     685                    sc->xfer[ST_STATUS], 0);
     686                break;
     687        default:
     688                break;
     689        }
    570690        return (sc);
    571691}
     
    596716        int err;
    597717
    598         sc = bbb_attach(udev, iface_index);
     718        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
    599719        if (sc == NULL)
    600720                return (0);
     
    652772        int err;
    653773
    654         sc = bbb_attach(udev, iface_index);
     774        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
    655775        if (sc == NULL)
    656776                return (0);
     
    821941        usb_error_t err;
    822942
    823         sc = bbb_attach(udev, iface_index);
     943        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
    824944        if (sc == NULL)
    825945                return (USB_ERR_INVAL);
     
    8801000        return (0);
    8811001}
     1002
     1003usb_error_t
     1004usb_dymo_eject(struct usb_device *udev, uint8_t iface_index)
     1005{
     1006        static const uint8_t data[3] = { 0x1b, 0x5a, 0x01 };
     1007        struct bbb_transfer *sc;
     1008        usb_error_t err;
     1009
     1010        sc = bbb_attach(udev, iface_index, UICLASS_HID);
     1011        if (sc == NULL)
     1012                return (USB_ERR_INVAL);
     1013        err = bbb_raw_write(sc, data, sizeof(data), USB_MS_HZ);
     1014        bbb_detach(sc);
     1015        return (err);
     1016}
     1017
     1018usb_error_t
     1019usb_msc_read_10(struct usb_device *udev, uint8_t iface_index,
     1020    uint32_t lba, uint32_t blocks, void *buffer)
     1021{
     1022        struct bbb_transfer *sc;
     1023        uint8_t cmd[10];
     1024        usb_error_t err;
     1025
     1026        cmd[0] = 0x28;          /* READ_10 */
     1027        cmd[1] = 0;
     1028        cmd[2] = lba >> 24;
     1029        cmd[3] = lba >> 16;
     1030        cmd[4] = lba >> 8;
     1031        cmd[5] = lba >> 0;
     1032        cmd[6] = 0;
     1033        cmd[7] = blocks >> 8;
     1034        cmd[8] = blocks;
     1035        cmd[9] = 0;
     1036
     1037        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
     1038        if (sc == NULL)
     1039                return (USB_ERR_INVAL);
     1040
     1041        err = bbb_command_start(sc, DIR_IN, 0, buffer,
     1042            blocks * SCSI_FIXED_BLOCK_SIZE, cmd, 10, USB_MS_HZ);
     1043
     1044        bbb_detach(sc);
     1045
     1046        return (err);
     1047}
     1048
     1049usb_error_t
     1050usb_msc_write_10(struct usb_device *udev, uint8_t iface_index,
     1051    uint32_t lba, uint32_t blocks, void *buffer)
     1052{
     1053        struct bbb_transfer *sc;
     1054        uint8_t cmd[10];
     1055        usb_error_t err;
     1056
     1057        cmd[0] = 0x2a;          /* WRITE_10 */
     1058        cmd[1] = 0;
     1059        cmd[2] = lba >> 24;
     1060        cmd[3] = lba >> 16;
     1061        cmd[4] = lba >> 8;
     1062        cmd[5] = lba >> 0;
     1063        cmd[6] = 0;
     1064        cmd[7] = blocks >> 8;
     1065        cmd[8] = blocks;
     1066        cmd[9] = 0;
     1067
     1068        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
     1069        if (sc == NULL)
     1070                return (USB_ERR_INVAL);
     1071
     1072        err = bbb_command_start(sc, DIR_OUT, 0, buffer,
     1073            blocks * SCSI_FIXED_BLOCK_SIZE, cmd, 10, USB_MS_HZ);
     1074
     1075        bbb_detach(sc);
     1076
     1077        return (err);
     1078}
     1079
     1080usb_error_t
     1081usb_msc_read_capacity(struct usb_device *udev, uint8_t iface_index,
     1082    uint32_t *lba_last, uint32_t *block_size)
     1083{
     1084        struct bbb_transfer *sc;
     1085        usb_error_t err;
     1086
     1087        sc = bbb_attach(udev, iface_index, UICLASS_MASS);
     1088        if (sc == NULL)
     1089                return (USB_ERR_INVAL);
     1090
     1091        err = bbb_command_start(sc, DIR_IN, 0, sc->buffer, 8,
     1092            &scsi_read_capacity, sizeof(scsi_read_capacity),
     1093            USB_MS_HZ);
     1094
     1095        *lba_last =
     1096            (sc->buffer[0] << 24) |
     1097            (sc->buffer[1] << 16) |
     1098            (sc->buffer[2] << 8) |
     1099            (sc->buffer[3]);
     1100
     1101        *block_size =
     1102            (sc->buffer[4] << 24) |
     1103            (sc->buffer[5] << 16) |
     1104            (sc->buffer[6] << 8) |
     1105            (sc->buffer[7]);
     1106
     1107        /* we currently only support one block size */
     1108        if (*block_size != SCSI_FIXED_BLOCK_SIZE)
     1109                err = USB_ERR_INVAL;
     1110
     1111        bbb_detach(sc);
     1112
     1113        return (err);
     1114}
  • freebsd/sys/dev/usb/usb_msctest.h

    rc164446 r02279d6  
    4444usb_error_t usb_msc_auto_quirk(struct usb_device *udev,
    4545            uint8_t iface_index);
     46usb_error_t usb_msc_read_10(struct usb_device *udev,
     47            uint8_t iface_index, uint32_t lba, uint32_t blocks,
     48            void *buffer);
     49usb_error_t usb_msc_write_10(struct usb_device *udev,
     50            uint8_t iface_index, uint32_t lba, uint32_t blocks,
     51            void *buffer);
     52usb_error_t usb_msc_read_capacity(struct usb_device *udev,
     53            uint8_t iface_index, uint32_t *lba_last,
     54            uint32_t *block_size);
     55usb_error_t usb_dymo_eject(struct usb_device *udev,
     56            uint8_t iface_index);
    4657
    4758#endif                                  /* _USB_MSCTEST_H_ */
  • freebsd/sys/dev/usb/usb_parse.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5053#include <dev/usb/usbdi_util.h>
    5154
     55#define USB_DEBUG_VAR usb_debug
     56
     57#include <dev/usb/usb_core.h>
     58#include <dev/usb/usb_debug.h>
     59#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    5260
    5361/*------------------------------------------------------------------------*
     
    142150
    143151        if (ps->desc == NULL) {
    144                 /* first time */
     152                /* first time or zero descriptors */
    145153        } else if (new_iface) {
    146154                /* new interface */
     
    150158                /* new alternate interface */
    151159                ps->iface_index_alt ++;
     160        }
     161#if (USB_IFACE_MAX <= 0)
     162#error "USB_IFACE_MAX must be defined greater than zero"
     163#endif
     164        /* check for too many interfaces */
     165        if (ps->iface_index >= USB_IFACE_MAX) {
     166                DPRINTF("Interface limit reached\n");
     167                id = NULL;
    152168        }
    153169
  • freebsd/sys/dev/usb/usb_process.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5861#include <sys/kthread.h>
    5962#include <sys/sched.h>
     63#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6064
    6165#if (__FreeBSD_version < 700000)
     
    7074                kproc_kthread_add((f), (s), &usbproc, (p), RFHIGHPID, \
    7175                    0, "usb", __VA_ARGS__)
     76#if (__FreeBSD_version >= 900000)
    7277#define USB_THREAD_SUSPEND_CHECK() kthread_suspend_check()
     78#else
     79#define USB_THREAD_SUSPEND_CHECK() kthread_suspend_check(curthread)
     80#endif
    7381#define USB_THREAD_SUSPEND(p)   kthread_suspend(p,0)
    7482#define USB_THREAD_EXIT(err)    kthread_exit()
     
    7684#define USB_THREAD_CREATE(f, s, p, ...) \
    7785                kthread_create((f), (s), (p), RFHIGHPID, 0, __VA_ARGS__)
    78 #define USB_THREAD_SUSPEND_CHECK() kthread_suspend_check()
     86#define USB_THREAD_SUSPEND_CHECK() kthread_suspend_check(curproc)
    7987#define USB_THREAD_SUSPEND(p)   kthread_suspend(p,0)
    8088#define USB_THREAD_EXIT(err)    kthread_exit(err)
     
    8593
    8694static SYSCTL_NODE(_hw_usb, OID_AUTO, proc, CTLFLAG_RW, 0, "USB process");
    87 SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, &usb_proc_debug, 0,
     95SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RWTUN, &usb_proc_debug, 0,
    8896    "Debug level");
    89 TUNABLE_INT("hw.usb.proc.debug", &usb_proc_debug);
    9097#endif
    9198
  • freebsd/sys/dev/usb/usb_process.h

    rc164446 r02279d6  
    2828#define _USB_PROCESS_H_
    2929
     30#ifndef USB_GLOBAL_INCLUDE_FILE
    3031#include <sys/interrupt.h>
    3132#include <sys/priority.h>
    3233#include <sys/runq.h>
     34#endif
    3335
    3436/* defines */
     37#define USB_PRI_HIGHEST PI_SWI(SWI_TTY)
    3538#define USB_PRI_HIGH    PI_SWI(SWI_NET)
    3639#define USB_PRI_MED     PI_SWI(SWI_CAMBIO)
  • freebsd/sys/dev/usb/usb_request.c

    rc164446 r02279d6  
    2929 */
    3030
     31#ifdef USB_GLOBAL_INCLUDE_FILE
     32#include USB_GLOBAL_INCLUDE_FILE
     33#else
    3134#include <sys/stdint.h>
    3235#include <sys/stddef.h>
     
    6871#include <dev/usb/usb_bus.h>
    6972#include <sys/ctype.h>
     73#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    7074
    7175static int usb_no_cs_fail;
    7276
    73 SYSCTL_INT(_hw_usb, OID_AUTO, no_cs_fail, CTLFLAG_RW,
     77SYSCTL_INT(_hw_usb, OID_AUTO, no_cs_fail, CTLFLAG_RWTUN,
    7478    &usb_no_cs_fail, 0, "USB clear stall failures are ignored, if set");
    7579
    7680static int usb_full_ddesc;
    7781
    78 SYSCTL_INT(_hw_usb, OID_AUTO, full_ddesc, CTLFLAG_RW,
     82SYSCTL_INT(_hw_usb, OID_AUTO, full_ddesc, CTLFLAG_RWTUN,
    7983    &usb_full_ddesc, 0, "USB always read complete device descriptor, if set");
    8084
     
    110114};
    111115
    112 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_bus_fail, CTLFLAG_RW,
     116SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_bus_fail, CTLFLAG_RWTUN,
    113117    &usb_ctrl_debug.bus_index, 0, "USB controller index to fail");
    114 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_dev_fail, CTLFLAG_RW,
     118SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_dev_fail, CTLFLAG_RWTUN,
    115119    &usb_ctrl_debug.dev_index, 0, "USB device address to fail");
    116 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_fail, CTLFLAG_RW,
     120SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_fail, CTLFLAG_RWTUN,
    117121    &usb_ctrl_debug.ds_fail, 0, "USB fail data stage");
    118 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_fail, CTLFLAG_RW,
     122SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_fail, CTLFLAG_RWTUN,
    119123    &usb_ctrl_debug.ss_fail, 0, "USB fail status stage");
    120 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_delay, CTLFLAG_RW,
     124SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ds_delay, CTLFLAG_RWTUN,
    121125    &usb_ctrl_debug.ds_delay, 0, "USB data stage delay in ms");
    122 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_delay, CTLFLAG_RW,
     126SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_ss_delay, CTLFLAG_RWTUN,
    123127    &usb_ctrl_debug.ss_delay, 0, "USB status stage delay in ms");
    124 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rt_fail, CTLFLAG_RW,
     128SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rt_fail, CTLFLAG_RWTUN,
    125129    &usb_ctrl_debug.bmRequestType_value, 0, "USB bmRequestType to fail");
    126 SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rv_fail, CTLFLAG_RW,
     130SYSCTL_INT(_hw_usb, OID_AUTO, ctrl_rv_fail, CTLFLAG_RWTUN,
    127131    &usb_ctrl_debug.bRequest_value, 0, "USB bRequest to fail");
    128132
     
    227231        struct usb_endpoint *ep_end;
    228232        struct usb_endpoint *ep_first;
     233        usb_stream_t x;
    229234        uint8_t to;
    230235
     
    254259                        /* some hardware needs a callback to clear the data toggle */
    255260                        usbd_clear_stall_locked(udev, ep);
    256                         /* start up the current or next transfer, if any */
    257                         usb_command_wrapper(&ep->endpoint_q,
    258                             ep->endpoint_q.curr);
     261                        for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
     262                                /* start the current or next transfer, if any */
     263                                usb_command_wrapper(&ep->endpoint_q[x],
     264                                    ep->endpoint_q[x].curr);
     265                        }
    259266                }
    260267                ep++;
     
    12661273
    12671274/*------------------------------------------------------------------------*
     1275 *      usbd_alloc_config_desc
     1276 *
     1277 * This function is used to allocate a zeroed configuration
     1278 * descriptor.
     1279 *
     1280 * Returns:
     1281 * NULL: Failure
     1282 * Else: Success
     1283 *------------------------------------------------------------------------*/
     1284void *
     1285usbd_alloc_config_desc(struct usb_device *udev, uint32_t size)
     1286{
     1287        if (size > USB_CONFIG_MAX) {
     1288                DPRINTF("Configuration descriptor too big\n");
     1289                return (NULL);
     1290        }
     1291#if (USB_HAVE_FIXED_CONFIG == 0)
     1292        return (malloc(size, M_USBDEV, M_ZERO | M_WAITOK));
     1293#else
     1294        memset(udev->config_data, 0, sizeof(udev->config_data));
     1295        return (udev->config_data);
     1296#endif
     1297}
     1298
     1299/*------------------------------------------------------------------------*
     1300 *      usbd_alloc_config_desc
     1301 *
     1302 * This function is used to free a configuration descriptor.
     1303 *------------------------------------------------------------------------*/
     1304void
     1305usbd_free_config_desc(struct usb_device *udev, void *ptr)
     1306{
     1307#if (USB_HAVE_FIXED_CONFIG == 0)
     1308        free(ptr, M_USBDEV);
     1309#endif
     1310}
     1311
     1312/*------------------------------------------------------------------------*
    12681313 *      usbd_req_get_config_desc_full
    12691314 *
    12701315 * This function gets the complete USB configuration descriptor and
    1271  * ensures that "wTotalLength" is correct.
     1316 * ensures that "wTotalLength" is correct. The returned configuration
     1317 * descriptor is freed by calling "usbd_free_config_desc()".
    12721318 *
    12731319 * Returns:
     
    12771323usb_error_t
    12781324usbd_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,
    1279     struct usb_config_descriptor **ppcd, struct malloc_type *mtype,
    1280     uint8_t index)
     1325    struct usb_config_descriptor **ppcd, uint8_t index)
    12811326{
    12821327        struct usb_config_descriptor cd;
    12831328        struct usb_config_descriptor *cdesc;
    1284         uint16_t len;
     1329        uint32_t len;
    12851330        usb_error_t err;
    12861331
     
    12901335
    12911336        err = usbd_req_get_config_desc(udev, mtx, &cd, index);
    1292         if (err) {
     1337        if (err)
    12931338                return (err);
    1294         }
     1339
    12951340        /* get full descriptor */
    12961341        len = UGETW(cd.wTotalLength);
    1297         if (len < sizeof(*cdesc)) {
     1342        if (len < (uint32_t)sizeof(*cdesc)) {
    12981343                /* corrupt descriptor */
    12991344                return (USB_ERR_INVAL);
    1300         }
    1301         cdesc = malloc(len, mtype, M_WAITOK);
    1302         if (cdesc == NULL) {
     1345        } else if (len > USB_CONFIG_MAX) {
     1346                DPRINTF("Configuration descriptor was truncated\n");
     1347                len = USB_CONFIG_MAX;
     1348        }
     1349        cdesc = usbd_alloc_config_desc(udev, len);
     1350        if (cdesc == NULL)
    13031351                return (USB_ERR_NOMEM);
    1304         }
    13051352        err = usbd_req_get_desc(udev, mtx, NULL, cdesc, len, len, 0,
    13061353            UDESC_CONFIG, index, 3);
    13071354        if (err) {
    1308                 free(cdesc, mtype);
     1355                usbd_free_config_desc(udev, cdesc);
    13091356                return (err);
    13101357        }
     
    19161963
    19171964        default:
    1918                 DPRINTF("Minimum MaxPacketSize is large enough "
     1965                DPRINTF("Minimum bMaxPacketSize is large enough "
    19191966                    "to hold the complete device descriptor or "
    1920                     "only once MaxPacketSize choice\n");
     1967                    "only one bMaxPacketSize choice\n");
    19211968
    19221969                /* get the full device descriptor */
  • freebsd/sys/dev/usb/usb_request.h

    rc164446 r02279d6  
    4545usb_error_t usbd_req_get_config_desc_full(struct usb_device *udev,
    4646                    struct mtx *mtx, struct usb_config_descriptor **ppcd,
    47                     struct malloc_type *mtype, uint8_t conf_index);
     47                    uint8_t conf_index);
    4848usb_error_t usbd_req_get_desc(struct usb_device *udev, struct mtx *mtx,
    4949                    uint16_t *actlen, void *desc, uint16_t min_len,
     
    9595                    uint8_t port, uint8_t besl, uint8_t addr, uint8_t rwe);
    9696
     97void *  usbd_alloc_config_desc(struct usb_device *, uint32_t);
     98void    usbd_free_config_desc(struct usb_device *, void *);
     99
    97100#endif                                  /* _USB_REQUEST_H_ */
  • freebsd/sys/dev/usb/usb_transfer.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    6467#include <dev/usb/usb_bus.h>
    6568#include <dev/usb/usb_pf.h>
     69#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6670#ifdef __rtems__
    6771#include <machine/rtems-bsd-cache.h>
     
    162166usbd_get_dma_delay(struct usb_device *udev)
    163167{
    164         struct usb_bus_methods *mtod;
     168        const struct usb_bus_methods *mtod;
    165169        uint32_t temp;
    166170
     
    187191 * pointed to a linear array of USB page caches afterwards.
    188192 *
     193 * If the "align" argument is equal to "1" a non-contiguous allocation
     194 * can happen. Else if the "align" argument is greater than "1", the
     195 * allocation will always be contiguous in memory.
     196 *
    189197 * Returns:
    190198 *    0: Success
     
    201209        void *buf;
    202210        usb_size_t n_dma_pc;
     211        usb_size_t n_dma_pg;
    203212        usb_size_t n_obj;
    204213        usb_size_t x;
     
    207216        usb_size_t z;
    208217
    209         USB_ASSERT(align > 1, ("Invalid alignment, 0x%08x\n",
     218        USB_ASSERT(align > 0, ("Invalid alignment, 0x%08x\n",
    210219            align));
    211220        USB_ASSERT(size > 0, ("Invalid size = 0\n"));
     
    230239         * allocations, hence DMA allocations are slow.
    231240         */
    232         if (size >= USB_PAGE_SIZE) {
     241        if (align == 1) {
     242                /* special case - non-cached multi page DMA memory */
    233243                n_dma_pc = count;
     244                n_dma_pg = (2 + (size / USB_PAGE_SIZE));
     245                n_obj = 1;
     246        } else if (size >= USB_PAGE_SIZE) {
     247                n_dma_pc = count;
     248                n_dma_pg = 1;
    234249                n_obj = 1;
    235250        } else {
    236251                /* compute number of objects per page */
     252#ifdef USB_DMA_SINGLE_ALLOC
     253                n_obj = 1;
     254#else
    237255                n_obj = (USB_PAGE_SIZE / size);
     256#endif
    238257                /*
    239258                 * Compute number of DMA chunks, rounded up
     
    241260                 */
    242261                n_dma_pc = ((count + n_obj - 1) / n_obj);
    243         }
    244 
     262                n_dma_pg = 1;
     263        }
     264
     265        /*
     266         * DMA memory is allocated once, but mapped twice. That's why
     267         * there is one list for auto-free and another list for
     268         * non-auto-free which only holds the mapping and not the
     269         * allocation.
     270         */
    245271        if (parm->buf == NULL) {
    246                 /* for the future */
    247                 parm->dma_page_ptr += n_dma_pc;
     272                /* reserve memory (auto-free) */
     273                parm->dma_page_ptr += n_dma_pc * n_dma_pg;
    248274                parm->dma_page_cache_ptr += n_dma_pc;
    249                 parm->dma_page_ptr += count;
     275
     276                /* reserve memory (no-auto-free) */
     277                parm->dma_page_ptr += count * n_dma_pg;
    250278                parm->xfer_page_cache_ptr += count;
    251279                return (0);
     
    262290        }
    263291
    264         if (ppc) {
    265                 *ppc = parm->xfer_page_cache_ptr;
     292        if (ppc != NULL) {
     293                if (n_obj != 1)
     294                        *ppc = parm->xfer_page_cache_ptr;
     295                else
     296                        *ppc = parm->dma_page_cache_ptr;
    266297        }
    267298        r = count;                      /* set remainder count */
     
    270301        pg = parm->dma_page_ptr;
    271302
    272         for (x = 0; x != n_dma_pc; x++) {
     303        if (n_obj == 1) {
     304            /*
     305             * Avoid mapping memory twice if only a single object
     306             * should be allocated per page cache:
     307             */
     308            for (x = 0; x != n_dma_pc; x++) {
     309                if (usb_pc_alloc_mem(parm->dma_page_cache_ptr,
     310                    pg, z, align)) {
     311                        return (1);     /* failure */
     312                }
     313                /* Make room for one DMA page cache and "n_dma_pg" pages */
     314                parm->dma_page_cache_ptr++;
     315                pg += n_dma_pg;
     316            }
     317        } else {
     318            for (x = 0; x != n_dma_pc; x++) {
    273319
    274320                if (r < n_obj) {
     
    283329                /* Set beginning of current buffer */
    284330                buf = parm->dma_page_cache_ptr->buffer;
    285                 /* Make room for one DMA page cache and one page */
     331                /* Make room for one DMA page cache and "n_dma_pg" pages */
    286332                parm->dma_page_cache_ptr++;
    287                 pg++;
    288 
    289                 for (y = 0; (y != n_obj); y++, r--, pc++, pg++) {
     333                pg += n_dma_pg;
     334
     335                for (y = 0; (y != n_obj); y++, r--, pc++, pg += n_dma_pg) {
    290336
    291337                        /* Load sub-chunk into DMA */
     
    303349                        mtx_unlock(pc->tag_parent->mtx);
    304350                }
     351            }
    305352        }
    306353
     
    372419                case UE_ISOCHRONOUS:
    373420                case UE_INTERRUPT:
    374                         xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3;
     421                        xfer->max_packet_count +=
     422                            (xfer->max_packet_size >> 11) & 3;
    375423
    376424                        /* check for invalid max packet count */
     
    401449                                uint8_t mult;
    402450
    403                                 mult = (ecomp->bmAttributes & 3) + 1;
     451                                mult = UE_GET_SS_ISO_MULT(
     452                                    ecomp->bmAttributes) + 1;
    404453                                if (mult > 3)
    405454                                        mult = 3;
     
    712761
    713762        if (!xfer->flags.ext_buffer) {
    714 
     763#if USB_HAVE_BUSDMA
     764                struct usb_page_search page_info;
     765                struct usb_page_cache *pc;
     766
     767                if (usbd_transfer_setup_sub_malloc(parm,
     768                    &pc, parm->bufsize, 1, 1)) {
     769                        parm->err = USB_ERR_NOMEM;
     770                } else if (parm->buf != NULL) {
     771
     772                        usbd_get_page(pc, 0, &page_info);
     773
     774                        xfer->local_buffer = page_info.buffer;
     775
     776                        usbd_xfer_set_frame_offset(xfer, 0, 0);
     777
     778                        if ((type == UE_CONTROL) && (n_frbuffers > 1)) {
     779                                usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
     780                        }
     781                }
     782#else
    715783                /* align data */
    716784#ifdef __rtems__
     
    722790#endif /* __rtems__ */
    723791
    724                 if (parm->buf) {
    725 
     792                if (parm->buf != NULL) {
    726793                        xfer->local_buffer =
    727794                            USB_ADD_BYTES(parm->buf, parm->size[0]);
     
    749816#endif /* __rtems__ */
    750817                parm->size[0] += ((-parm->size[0]) & (USB_HOST_ALIGN - 1));
     818#endif
    751819        }
    752820        /*
     
    835903}
    836904
     905static uint8_t
     906usbd_transfer_setup_has_bulk(const struct usb_config *setup_start,
     907    uint16_t n_setup)
     908{
     909        while (n_setup--) {
     910                uint8_t type = setup_start[n_setup].type;
     911                if (type == UE_BULK || type == UE_BULK_INTR ||
     912                    type == UE_TYPE_ANY)
     913                        return (1);
     914        }
     915        return (0);
     916}
     917
    837918/*------------------------------------------------------------------------*
    838919 *      usbd_transfer_setup - setup an array of USB transfers
     
    9711052                         */
    9721053                        if (setup_start == usb_control_ep_cfg)
    973                                 info->done_p = 
    974                                     &udev->bus->control_xfer_proc;
     1054                                info->done_p =
     1055                                    USB_BUS_CONTROL_XFER_PROC(udev->bus);
    9751056                        else if (xfer_mtx == &Giant)
    976                                 info->done_p =
    977                                     &udev->bus->giant_callback_proc;
     1057                                info->done_p =
     1058                                    USB_BUS_GIANT_PROC(udev->bus);
     1059                        else if (usbd_transfer_setup_has_bulk(setup_start, n_setup))
     1060                                info->done_p =
     1061                                    USB_BUS_NON_GIANT_BULK_PROC(udev->bus);
    9781062                        else
    979                                 info->done_p = 
    980                                     &udev->bus->non_giant_callback_proc;
     1063                                info->done_p =
     1064                                    USB_BUS_NON_GIANT_ISOC_PROC(udev->bus);
    9811065                }
    9821066                /* reset sizes */
     
    9971081                            ifaces[setup->if_index], setup);
    9981082
    999                         if ((ep == NULL) || (ep->methods == NULL)) {
     1083                        /*
     1084                         * Check that the USB PIPE is valid and that
     1085                         * the endpoint mode is proper.
     1086                         *
     1087                         * Make sure we don't allocate a streams
     1088                         * transfer when such a combination is not
     1089                         * valid.
     1090                         */
     1091                        if ((ep == NULL) || (ep->methods == NULL) ||
     1092                            ((ep->ep_mode != USB_EP_MODE_STREAMS) &&
     1093                            (ep->ep_mode != USB_EP_MODE_DEFAULT)) ||
     1094                            (setup->stream_id != 0 &&
     1095                            (setup->stream_id >= USB_MAX_EP_STREAMS ||
     1096                            (ep->ep_mode != USB_EP_MODE_STREAMS)))) {
    10001097                                if (setup->flags.no_pipe_ok)
    10011098                                        continue;
     
    10411138                        xfer->endpoint = ep;
    10421139
     1140                        /* set transfer stream ID */
     1141                        xfer->stream_id = setup->stream_id;
     1142
    10431143                        parm->size[0] += sizeof(xfer[0]);
    10441144                        parm->methods = xfer->endpoint->methods;
     
    11111211                 * the number of endpoints. The current estimate
    11121212                 * for maximum number of DMA tags per endpoint
    1113                  * is two.
     1213                 * is three:
     1214                 * 1) for loading memory
     1215                 * 2) for allocating memory
     1216                 * 3) for fixing memory [UHCI]
    11141217                 */
    1115                 parm->dma_tag_max += 2 * MIN(n_setup, USB_EP_MAX);
     1218                parm->dma_tag_max += 3 * MIN(n_setup, USB_EP_MAX);
    11161219
    11171220                /*
     
    16611764                        xfer->flags_int.can_cancel_immed = 1;
    16621765                        /* start the transfer */
    1663                         usb_command_wrapper(&xfer->endpoint->endpoint_q, xfer);
     1766                        usb_command_wrapper(&xfer->endpoint->
     1767                            endpoint_q[xfer->stream_id], xfer);
    16641768                        USB_BUS_UNLOCK(bus);
    16651769                        return;
     
    17821886
    17831887        /* start the transfer */
    1784         usb_command_wrapper(&ep->endpoint_q, xfer);
     1888        usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], xfer);
    17851889        USB_BUS_UNLOCK(xfer->xroot->bus);
    17861890}
     
    19032007                 * to start the next one:
    19042008                 */
    1905                 if (ep->endpoint_q.curr == xfer) {
    1906                         usb_command_wrapper(&ep->endpoint_q, NULL);
     2009                if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
     2010                        usb_command_wrapper(
     2011                            &ep->endpoint_q[xfer->stream_id], NULL);
    19072012                }
    19082013        }
     
    22222327                 * proceed !
    22232328                 */
    2224                 if (usb_proc_msignal(info->done_p,
    2225                     &info->done_m[0], &info->done_m[1])) {
    2226                         /* ignore */
    2227                 }
     2329                (void) usb_proc_msignal(info->done_p,
     2330                    &info->done_m[0], &info->done_m[1]);
    22282331        } else {
    22292332                /* clear second recurse flag */
     
    22492352
    22502353        USB_BUS_LOCK_ASSERT(info->bus, MA_OWNED);
    2251         if (!mtx_owned(info->xfer_mtx) && !SCHEDULER_STOPPED()) {
     2354        if ((pq->recurse_3 != 0 || mtx_owned(info->xfer_mtx) == 0) &&
     2355            SCHEDULER_STOPPED() == 0) {
    22522356                /*
    22532357                 * Cases that end up here:
    22542358                 *
    22552359                 * 5) HW interrupt done callback or other source.
     2360                 * 6) HW completed transfer during callback
    22562361                 */
    2257                 DPRINTFN(3, "case 5\n");
     2362                DPRINTFN(3, "case 5 and 6\n");
    22582363
    22592364                /*
    22602365                 * We have to postpone the callback due to the fact we
    22612366                 * will have a Lock Order Reversal, LOR, if we try to
    2262                  * proceed !
     2367                 * proceed!
     2368                 *
     2369                 * Postponing the callback also ensures that other USB
     2370                 * transfer queues get a chance.
    22632371                 */
    2264                 if (usb_proc_msignal(info->done_p,
    2265                     &info->done_m[0], &info->done_m[1])) {
    2266                         /* ignore */
    2267                 }
     2372                (void) usb_proc_msignal(info->done_p,
     2373                    &info->done_m[0], &info->done_m[1]);
    22682374                return;
    22692375        }
     
    23232429
    23242430#if USB_HAVE_PF
    2325         if (xfer->usb_state != USB_ST_SETUP)
     2431        if (xfer->usb_state != USB_ST_SETUP) {
     2432                USB_BUS_LOCK(info->bus);
    23262433                usbpf_xfertap(xfer, USBPF_XFERTAP_DONE);
     2434                USB_BUS_UNLOCK(info->bus);
     2435        }
    23272436#endif
    23282437        /* call processing routine */
     
    26322741                        if (udev->flags.usb_mode == USB_MODE_DEVICE) {
    26332742                                (udev->bus->methods->set_stall) (
    2634                                     udev, NULL, ep, &did_stall);
     2743                                    udev, ep, &did_stall);
    26352744                        } else if (udev->ctrl_xfer[1]) {
    26362745                                info = udev->ctrl_xfer[1]->xroot;
    26372746                                usb_proc_msignal(
    2638                                     &info->bus->non_giant_callback_proc,
     2747                                    USB_BUS_CS_PROC(info->bus),
    26392748                                    &udev->cs_msg[0], &udev->cs_msg[1]);
    26402749                        } else {
     
    29153024         */
    29163025        USB_BUS_LOCK(bus);
    2917         if (ep->endpoint_q.curr == xfer) {
    2918                 usb_command_wrapper(&ep->endpoint_q, NULL);
    2919 
    2920                 if (ep->endpoint_q.curr || TAILQ_FIRST(&ep->endpoint_q.head)) {
     3026        if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
     3027                usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], NULL);
     3028
     3029                if (ep->endpoint_q[xfer->stream_id].curr != NULL ||
     3030                    TAILQ_FIRST(&ep->endpoint_q[xfer->stream_id].head) != NULL) {
    29213031                        /* there is another USB transfer waiting */
    29223032                } else {
     
    29603070        if (!pq->recurse_1) {
    29613071
     3072                /* clear third recurse flag */
     3073                pq->recurse_3 = 0;
     3074
    29623075                do {
    2963 
    2964                         /* set both recurse flags */
     3076                        /* set two first recurse flags */
    29653077                        pq->recurse_1 = 1;
    29663078                        pq->recurse_2 = 1;
     
    29803092                        (pq->command) (pq);
    29813093                        DPRINTFN(6, "cb %p (leave)\n", pq->curr);
     3094
     3095                        /*
     3096                         * Set third recurse flag to indicate
     3097                         * recursion happened:
     3098                         */
     3099                        pq->recurse_3 = 1;
    29823100
    29833101                } while (!pq->recurse_2);
     
    32523370                }
    32533371
     3372#if USB_HAVE_PER_BUS_PROCESS
    32543373                /* Make sure cv_signal() and cv_broadcast() is not called */
    3255                 udev->bus->control_xfer_proc.up_msleep = 0;
    3256                 udev->bus->explore_proc.up_msleep = 0;
    3257                 udev->bus->giant_callback_proc.up_msleep = 0;
    3258                 udev->bus->non_giant_callback_proc.up_msleep = 0;
     3374                USB_BUS_CONTROL_XFER_PROC(udev->bus)->up_msleep = 0;
     3375                USB_BUS_EXPLORE_PROC(udev->bus)->up_msleep = 0;
     3376                USB_BUS_GIANT_PROC(udev->bus)->up_msleep = 0;
     3377                USB_BUS_NON_GIANT_ISOC_PROC(udev->bus)->up_msleep = 0;
     3378                USB_BUS_NON_GIANT_BULK_PROC(udev->bus)->up_msleep = 0;
     3379#endif
    32593380
    32603381                /* poll USB hardware */
  • freebsd/sys/dev/usb/usb_transfer.h

    rc164446 r02279d6  
    2727#ifndef _USB_TRANSFER_H_
    2828#define _USB_TRANSFER_H_
     29
     30/*
     31 * Definition of internal USB transfer states:
     32 * ===========================================
     33 *
     34 * The main reason there are many USB states is that we are allowed to
     35 * cancel USB transfers, then start the USB transfer again and that
     36 * this state transaction cannot always be done in a single atomic
     37 * operation without blocking the calling thread. One reason for this
     38 * is that the USB hardware sometimes needs to wait for DMA
     39 * controllers to finish which is done asynchronously and grows the
     40 * statemachine.
     41 *
     42 * When extending the following statemachine there are basically two
     43 * things you should think about: Which states should be executed or
     44 * modified in case of USB transfer stop and which states should be
     45 * executed or modified in case of USB transfer start. Also respect
     46 * the "can_cancel_immed" flag which basically tells if you can go
     47 * directly from a wait state to the cancelling states.
     48 */
     49
     50enum {
     51        /* XFER start execute state */
     52
     53        /* USB_ST_SETUP = 0 (already defined) */
     54
     55        /* XFER transferred execute state */
     56
     57        /* USB_ST_TRANSFERRED = 1 (already defined) */
     58
     59        /* XFER error execute state */
     60
     61        /* USB_ST_ERROR = 2 (already defined) */
     62
     63        /* XFER restart after error execute state */
     64
     65        USB_ST_RESTART = 8,
     66
     67        /* XFER transfer idle state */
     68
     69        USB_ST_WAIT_SETUP,
     70
     71        /* Other XFER execute states */
     72
     73        USB_ST_PIPE_OPEN = 16,
     74        USB_ST_PIPE_OPEN_ERROR,
     75        USB_ST_PIPE_OPEN_RESTART,
     76
     77        USB_ST_BDMA_LOAD,
     78        USB_ST_BDMA_LOAD_ERROR,
     79        USB_ST_BDMA_LOAD_RESTART,
     80
     81        USB_ST_IVAL_DLY,
     82        USB_ST_IVAL_DLY_ERROR,
     83        USB_ST_IVAL_DLY_RESTART,
     84
     85        USB_ST_PIPE_STALL,
     86        USB_ST_PIPE_STALL_ERROR,
     87        USB_ST_PIPE_STALL_RESTART,
     88
     89        USB_ST_ENTER,
     90        USB_ST_ENTER_ERROR,
     91        USB_ST_ENTER_RESTART,
     92
     93        USB_ST_START,
     94        USB_ST_START_ERROR,
     95        USB_ST_START_RESTART,
     96
     97        USB_ST_PIPE_CLOSE,
     98        USB_ST_PIPE_CLOSE_ERROR,
     99        USB_ST_PIPE_CLOSE_RESTART,
     100
     101        USB_ST_BDMA_DLY,
     102        USB_ST_BDMA_DLY_ERROR,
     103        USB_ST_BDMA_DLY_RESTART,
     104
     105        /* XFER transfer wait states */
     106
     107        USB_ST_WAIT_PIPE_OPEN = 64,
     108        USB_ST_WAIT_PIPE_OPEN_ERROR,
     109        USB_ST_WAIT_PIPE_OPEN_RESTART,
     110
     111        USB_ST_WAIT_BDMA_LOAD,
     112        USB_ST_WAIT_BDMA_LOAD_ERROR,
     113        USB_ST_WAIT_BDMA_LOAD_RESTART,
     114
     115        USB_ST_WAIT_IVAL_DLY,
     116        USB_ST_WAIT_IVAL_DLY_ERROR,
     117        USB_ST_WAIT_IVAL_DLY_RESTART,
     118
     119        USB_ST_WAIT_PIPE_STALL,
     120        USB_ST_WAIT_PIPE_STALL_ERROR,
     121        USB_ST_WAIT_PIPE_STALL_RESTART,
     122
     123        USB_ST_WAIT_ENTER,
     124        USB_ST_WAIT_ENTER_ERROR,
     125        USB_ST_WAIT_ENTER_RESTART,
     126
     127        USB_ST_WAIT_START,
     128        USB_ST_WAIT_START_ERROR,
     129        USB_ST_WAIT_START_RESTART,
     130
     131        USB_ST_WAIT_PIPE_CLOSE,
     132        USB_ST_WAIT_PIPE_CLOSE_ERROR,
     133        USB_ST_WAIT_PIPE_CLOSE_RESTART,
     134
     135        USB_ST_WAIT_BDMA_DLY,
     136        USB_ST_WAIT_BDMA_DLY_ERROR,
     137        USB_ST_WAIT_BDMA_DLY_RESTART,
     138
     139        USB_ST_WAIT_TRANSFERRED,
     140        USB_ST_WAIT_TRANSFERRED_ERROR,
     141        USB_ST_WAIT_TRANSFERRED_RESTART,
     142};
    29143
    30144/*
  • freebsd/sys/dev/usb/usb_util.c

    rc164446 r02279d6  
    2727 */
    2828
     29#ifdef USB_GLOBAL_INCLUDE_FILE
     30#include USB_GLOBAL_INCLUDE_FILE
     31#else
    2932#include <sys/stdint.h>
    3033#include <sys/stddef.h>
     
    5962#include <dev/usb/usb_controller.h>
    6063#include <dev/usb/usb_bus.h>
     64#endif                  /* USB_GLOBAL_INCLUDE_FILE */
    6165
    6266/*------------------------------------------------------------------------*
  • freebsd/sys/dev/usb/usbdi.h

    rc164446 r02279d6  
    103103
    104104/* USB events */
     105#ifndef USB_GLOBAL_INCLUDE_FILE
    105106#include <sys/eventhandler.h>
     107#endif
    106108typedef void (*usb_dev_configured_t)(void *, struct usb_device *,
    107109    struct usb_attach_arg *);
     
    127129        uint8_t recurse_1:1;
    128130        uint8_t recurse_2:1;
     131        uint8_t recurse_3:1;
     132        uint8_t reserved:5;
    129133};
    130134
     
    134138 */
    135139struct usb_endpoint {
    136         struct usb_xfer_queue endpoint_q;       /* queue of USB transfers */
     140        /* queue of USB transfers */
     141        struct usb_xfer_queue endpoint_q[USB_MAX_EP_STREAMS];
    137142
    138143        struct usb_endpoint_descriptor *edesc;
    139144        struct usb_endpoint_ss_comp_descriptor *ecomp;
    140         struct usb_pipe_methods *methods;       /* set by HC driver */
     145        const struct usb_pipe_methods *methods; /* set by HC driver */
    141146
    142147        uint16_t isoc_next;
     
    157162        uint8_t usb_cmask;              /* USB complete mask */
    158163        uint8_t usb_uframe;             /* USB microframe */
     164
     165        /* USB endpoint mode, see USB_EP_MODE_XXX */
     166
     167        uint8_t ep_mode;
    159168};
    160169
     
    221230        usb_timeout_t timeout;          /* transfer timeout in milliseconds */
    222231        struct usb_xfer_flags flags;    /* transfer flags */
     232        usb_stream_t stream_id;         /* USB3.0 specific */
    223233        enum usb_hc_mode usb_mode;      /* host or device mode */
    224234        uint8_t type;                   /* pipe type */
     
    234244 * both modes respectivly:
    235245 */
    236 #ifndef __rtems__
     246#if USB_HAVE_ID_SECTION
    237247#define STRUCT_USB_HOST_ID \
    238248    struct usb_device_id __section("usb_host_id")
     
    241251#define STRUCT_USB_DUAL_ID \
    242252    struct usb_device_id __section("usb_dual_id")
    243 #else /* __rtems__ */
     253#else
    244254#define STRUCT_USB_HOST_ID \
    245255    struct usb_device_id
     
    248258#define STRUCT_USB_DUAL_ID \
    249259    struct usb_device_id
    250 #endif /* __rtems__ */
     260#endif                  /* USB_HAVE_ID_SECTION */
    251261
    252262/*
     
    487497usb_error_t     usbd_add_dynamic_quirk(struct usb_device *udev,
    488498                        uint16_t quirk);
     499usb_error_t     usbd_set_endpoint_mode(struct usb_device *udev,
     500                        struct usb_endpoint *ep, uint8_t ep_mode);
     501uint8_t         usbd_get_endpoint_mode(struct usb_device *udev,
     502                        struct usb_endpoint *ep);
    489503
    490504const struct usb_device_id *usbd_lookup_id_by_info(
     
    530544void    usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen,
    531545            int *aframes, int *nframes);
    532 struct usb_page_cache *usbd_xfer_get_frame(struct usb_xfer *xfer,
    533             usb_frcount_t frindex);
     546struct usb_page_cache *usbd_xfer_get_frame(struct usb_xfer *, usb_frcount_t);
    534547void    *usbd_xfer_get_frame_buffer(struct usb_xfer *, usb_frcount_t);
    535548void    *usbd_xfer_softc(struct usb_xfer *xfer);
  • freebsd/sys/dev/usb/usbhid.h

    rc164446 r02279d6  
    3030#define _USB_HID_H_
    3131
     32#ifndef USB_GLOBAL_INCLUDE_FILE
    3233#include <dev/usb/usb_endian.h>
     34#endif
    3335
    3436#define UR_GET_HID_DESCRIPTOR   0x06
  • rtemsbsd/include/rtems/bsd/local/opt_usb.h

    rc164446 r02279d6  
    1818
    1919#define USB_HAVE_POWERD 1
     20
     21#define USB_HAVE_PER_BUS_PROCESS 1
  • rtemsbsd/include/rtems/bsd/local/usbdevs.h

    rc164446 r02279d6  
    460460#define USB_VENDOR_GARMIN       0x091e          /* Garmin International */
    461461#define USB_VENDOR_GOHUBS       0x0921          /* GoHubs */
     462#define USB_VENDOR_DYMO 0x0922          /* DYMO */
    462463#define USB_VENDOR_XEROX        0x0924          /* Xerox */
    463464#define USB_VENDOR_BIOMETRIC    0x0929          /* American Biometric Company */
     
    532533#define USB_VENDOR_ICOM 0x0c26          /* Icom Inc. */
    533534#define USB_VENDOR_GNOTOMETRICS 0x0c33          /* GN Otometrics */
    534 #define USB_VENDOR_CHICONY2     0x0c45          /* Chicony */
     535#define USB_VENDOR_CHICONY2     0x0c45          /* Chicony / Microdia / Sonix Technology Co., Ltd. */
    535536#define USB_VENDOR_REINERSCT    0x0c4b          /* Reiner-SCT */
    536537#define USB_VENDOR_SEALEVEL     0x0c52          /* Sealevel System */
     
    694695#define USB_VENDOR_METAGEEK     0x1781          /* MetaGeek */
    695696#define USB_VENDOR_KAMSTRUP     0x17a8          /* Kamstrup A/S */
     697#define USB_VENDOR_DISPLAYLINK  0x17e9          /* DisplayLink */
    696698#define USB_VENDOR_LENOVO       0x17ef          /* Lenovo */
    697699#define USB_VENDOR_WAVESENSE    0x17f4          /* WaveSense */
     
    782784#define USB_VENDOR_MARVELL      0x9e88          /* Marvell Technology Group Ltd. */
    783785#define USB_VENDOR_3COM3        0xa727          /* 3Com */
     786#define USB_VENDOR_CACE 0xcace          /* CACE Technologies */
    784787#define USB_VENDOR_EVOLUTION    0xdeee          /* Evolution Robotics products */
    785788#define USB_VENDOR_DATAAPEX     0xdaae          /* DataApex */
     
    869872#define USB_PRODUCT_ACCTON_RTL8192SU    0xc512          /* RTL8192SU */
    870873#define USB_PRODUCT_ACCTON_ZD1211B      0xe501          /* ZD1211B */
     874#define USB_PRODUCT_ACCTON_WN7512       0xf522          /* WN7512 */
    871875
    872876/* Aceeca products */
     
    12291233#define USB_PRODUCT_ATHEROS2_AR5523_3   0x0005          /* AR5523 */
    12301234#define USB_PRODUCT_ATHEROS2_AR5523_3_NF        0x0006          /* AR5523 (no firmware) */
     1235#define USB_PRODUCT_ATHEROS2_TG121N     0x1001          /* TG121N */
     1236#define USB_PRODUCT_ATHEROS2_WN821NV2   0x1002          /* WN821NV2 */
     1237#define USB_PRODUCT_ATHEROS2_3CRUSBN275 0x1010          /* 3CRUSBN275 */
     1238#define USB_PRODUCT_ATHEROS2_WN612      0x1011          /* WN612 */
     1239#define USB_PRODUCT_ATHEROS2_AR9170     0x9170          /* AR9170 */
    12311240
    12321241/* Atmel Comp. products */
     
    12431252/* Avision products */
    12441253#define USB_PRODUCT_AVISION_1200U       0x0268          /* 1200U scanner */
     1254
     1255/* AVM products */
     1256#define USB_PRODUCT_AVM_FRITZWLAN       0x8401          /* FRITZ!WLAN N */
    12451257
    12461258/* Axesstel products */
     
    13461358#define USB_PRODUCT_BTC_BTC7932 0x6782          /* Keyboard with mouse port */
    13471359
     1360/* CACE Technologies products */
     1361#define USB_PRODUCT_CACE_AIRPCAPNX      0x0300          /* AirPcap NX */
     1362
    13481363/* Canon, Inc. products */
    13491364#define USB_PRODUCT_CANON_N656U 0x2206          /* CanoScan N656U */
     
    14141429#define USB_PRODUCT_CISCOLINKSYS_WUSBF54G       0x0024          /* WUSBF54G */
    14151430#define USB_PRODUCT_CISCOLINKSYS_AE1000 0x002f          /* AE1000 */
     1431#define USB_PRODUCT_CISCOLINKSYS_USB3GIGV1      0x0041          /* USB3GIGV1 USB Ethernet Adapter */
    14161432#define USB_PRODUCT_CISCOLINKSYS2_RT3070        0x4001          /* RT3070 */
    14171433#define USB_PRODUCT_CISCOLINKSYS3_RT3070        0x0101          /* RT3070 */
     
    16051621#define USB_PRODUCT_DLINK_DWL120E       0x3200          /* DWL-120 rev E */
    16061622#define USB_PRODUCT_DLINK_DWA125D1      0x330f          /* DWA-125 rev D1 */
     1623#define USB_PRODUCT_DLINK_DWA123D1      0x3310          /* DWA-123 rev D1 */
    16071624#define USB_PRODUCT_DLINK_DWL122        0x3700          /* DWL-122 */
    16081625#define USB_PRODUCT_DLINK_DWLG120       0x3701          /* DWL-G120 */
     
    16441661#define USB_PRODUCT_DLINK2_RTL8192SU_2  0x3302          /* RTL8192SU */
    16451662#define USB_PRODUCT_DLINK2_DWA131A1     0x3303          /* DWA-131 A1 */
     1663#define USB_PRODUCT_DLINK2_DWA160A2     0x3a09          /* DWA-160 A2 */
    16461664#define USB_PRODUCT_DLINK2_DWA120       0x3a0c          /* DWA-120 */
    16471665#define USB_PRODUCT_DLINK2_DWA120_NF    0x3a0d          /* DWA-120 (no firmware) */
     1666#define USB_PRODUCT_DLINK2_DWA130D1     0x3a0f          /* DWA-130 D1 */
    16481667#define USB_PRODUCT_DLINK2_DWLG122C1    0x3c03          /* DWL-G122 c1 */
    16491668#define USB_PRODUCT_DLINK2_WUA1340      0x3c04          /* WUA-1340 */
     
    16561675#define USB_PRODUCT_DLINK2_RT3070_2     0x3c0e          /* RT3070 */
    16571676#define USB_PRODUCT_DLINK2_RT3070_3     0x3c0f          /* RT3070 */
     1677#define USB_PRODUCT_DLINK2_DWA160A1     0x3c10          /* DWA-160 A1 */
    16581678#define USB_PRODUCT_DLINK2_RT2870_2     0x3c11          /* RT2870 */
    16591679#define USB_PRODUCT_DLINK2_DWA130       0x3c13          /* DWA-130 */
     
    16621682#define USB_PRODUCT_DLINK3_DWM652       0x3e04          /* DWM-652 */
    16631683
     1684/* DisplayLink products */
     1685#define USB_PRODUCT_DISPLAYLINK_LCD4300U        0x01ba          /* LCD-4300U */
     1686#define USB_PRODUCT_DISPLAYLINK_LCD8000U        0x01bb          /* LCD-8000U */
     1687#define USB_PRODUCT_DISPLAYLINK_LD220   0x0100          /* Samsung LD220 */
     1688#define USB_PRODUCT_DISPLAYLINK_GUC2020 0x0059          /* IOGEAR DVI GUC2020 */
     1689#define USB_PRODUCT_DISPLAYLINK_VCUD60  0x0136          /* Rextron DVI */
     1690#define USB_PRODUCT_DISPLAYLINK_CONV    0x0138          /* StarTech CONV-USB2DVI */
     1691#define USB_PRODUCT_DISPLAYLINK_DLDVI   0x0141          /* DisplayLink DVI */
     1692#define USB_PRODUCT_DISPLAYLINK_VGA10   0x015a          /* CMP-USBVGA10 */
     1693#define USB_PRODUCT_DISPLAYLINK_WSDVI   0x0198          /* WS Tech DVI */
     1694#define USB_PRODUCT_DISPLAYLINK_EC008   0x019b          /* EasyCAP008 DVI */
     1695#define USB_PRODUCT_DISPLAYLINK_HPDOCK  0x01d4          /* HP USB Docking */
     1696#define USB_PRODUCT_DISPLAYLINK_NL571   0x01d7          /* HP USB DVI */
     1697#define USB_PRODUCT_DISPLAYLINK_M01061  0x01e2          /* Lenovo DVI */
     1698#define USB_PRODUCT_DISPLAYLINK_SWDVI   0x024c          /* SUNWEIT DVI */
     1699#define USB_PRODUCT_DISPLAYLINK_NBDOCK  0x0215          /* VideoHome NBdock1920 */
     1700#define USB_PRODUCT_DISPLAYLINK_LUM70   0x02a9          /* Lilliput UM-70 */
     1701#define USB_PRODUCT_DISPLAYLINK_UM7X0   0x401a          /* nanovision MiMo */
     1702#define USB_PRODUCT_DISPLAYLINK_LT1421  0x03e0          /* Lenovo ThinkVision LT1421 */
     1703#define USB_PRODUCT_DISPLAYLINK_POLARIS2        0x0117          /* Polaris2 USB dock */
     1704#define USB_PRODUCT_DISPLAYLINK_PLUGABLE        0x0377          /* Plugable docking station */
     1705
    16641706/* DMI products */
    16651707#define USB_PRODUCT_DMI_CFSM_RW 0xa109          /* CF/SM Reader/Writer */
     
    16771719#define USB_PRODUCT_DRESDENELEKTRONIK_DE_RFNODE 0x001c          /* deRFnode */
    16781720#define USB_PRODUCT_DRESDENELEKTRONIK_LEVELSHIFTERSTICKLOWCOST  0x0022          /* Levelshifter Stick Low Cost */
     1721
     1722/* DYMO */
     1723#define USB_PRODUCT_DYMO_LABELMANAGERPNP        0x1001          /* DYMO LabelManager PnP */
    16791724
    16801725/* Dynastream Innovations */
     
    17191764#define USB_PRODUCT_ELECOM_LDUSBTX1     0x4002          /* LD-USB/TX */
    17201765#define USB_PRODUCT_ELECOM_LDUSBLTX     0x4005          /* LD-USBL/TX */
     1766#define USB_PRODUCT_ELECOM_WDC150SU2M   0x4008          /* WDC-150SU2M */
    17211767#define USB_PRODUCT_ELECOM_LDUSBTX2     0x400b          /* LD-USB/TX */
    17221768#define USB_PRODUCT_ELECOM_LDUSB20      0x4010          /* LD-USB20 */
     
    18551901
    18561902/* Future Technology Devices products */
     1903#define USB_PRODUCT_FTDI_SCX8_USB_PHOENIX       0x5259          /* SCx8 USB Phoenix interface */
    18571904#define USB_PRODUCT_FTDI_SERIAL_8U100AX 0x8372          /* 8U100AX Serial */
    18581905#define USB_PRODUCT_FTDI_SERIAL_8U232AM 0x6001          /* 8U232AM Serial */
     
    23672414#define USB_PRODUCT_HUAWEI_K3772_INIT   0x1526          /* K3772 Initial */
    23682415#define USB_PRODUCT_HUAWEI_E3272_INIT   0x155b          /* LTE modem initial */
     2416#define USB_PRODUCT_HUAWEI_ME909U       0x1573          /* LTE modem */
    23692417#define USB_PRODUCT_HUAWEI_R215_INIT    0x1582          /* LTE modem initial */
    23702418#define USB_PRODUCT_HUAWEI_R215 0x1588          /* LTE modem */
     
    24452493#define USB_PRODUCT_IODATA_USBWNB11     0x0922          /* USB Airport WN-B11 */
    24462494#define USB_PRODUCT_IODATA_ETGUS2       0x0930          /* ETG-US2 */
     2495#define USB_PRODUCT_IODATA_WNGDNUS2     0x093f          /* WN-GDN/US2 */
    24472496#define USB_PRODUCT_IODATA_RT3072_1     0x0944          /* RT3072 */
    24482497#define USB_PRODUCT_IODATA_RT3072_2     0x0945          /* RT3072 */
     
    26102659
    26112660/* Lenovo products */
     2661#define USB_PRODUCT_LENOVO_GIGALAN      0x304b          /* USB 3.0 Ethernet */
    26122662#define USB_PRODUCT_LENOVO_ETHERNET     0x7203          /* USB 2.0 Ethernet */
    26132663
     
    29993049#define USB_PRODUCT_MELCO_WLIUCAG300N   0x012e          /* WLI-UC-AG300N */
    30003050#define USB_PRODUCT_MELCO_WLIUCG        0x0137          /* WLI-UC-G */
    3001 #define USB_PRODUCT_MELCO_RT2870_1      0x0148          /* RT2870 */
     3051#define USB_PRODUCT_MELCO_WLIUCG300HP   0x0148          /* WLI-UC-G300HP */
    30023052#define USB_PRODUCT_MELCO_RT2870_2      0x0150          /* RT2870 */
    30033053#define USB_PRODUCT_MELCO_WLIUCGN       0x015d          /* WLI-UC-GN */
    30043054#define USB_PRODUCT_MELCO_WLIUCG301N    0x016f          /* WLI-UC-G301N */
    30053055#define USB_PRODUCT_MELCO_WLIUCGNM      0x01a2          /* WLI-UC-GNM */
     3056#define USB_PRODUCT_MELCO_WLIUCG300HPV1 0x01a8          /* WLI-UC-G300HP-V1 */
    30063057#define USB_PRODUCT_MELCO_WLIUCGNM2     0x01ee          /* WLI-UC-GNM2 */
    30073058
     
    30253076#define USB_PRODUCT_MEI_CASHFLOW_SC     0x1100          /* Cashflow-SC Cash Acceptor */
    30263077#define USB_PRODUCT_MEI_S2000   0x1101          /* Series 2000 Combo Acceptor */
     3078
     3079/* Microdia / Sonix Techonology Co., Ltd. products */
     3080#define USB_PRODUCT_CHICONY2_YUREX      0x1010          /* YUREX */
     3081#define USB_PRODUCT_CHICONY2_CAM_1      0x62c0          /* CAM_1 */
     3082#define USB_PRODUCT_CHICONY2_TEMPER     0x7401          /* TEMPer sensor */
    30273083
    30283084/* Micro Star International products */
     
    31783234#define USB_PRODUCT_NEC_HUB_0050        0x0050          /* USB 2.0 7-Port Hub */
    31793235#define USB_PRODUCT_NEC_HUB_005A        0x005a          /* USB 2.0 4-Port Hub */
     3236#define USB_PRODUCT_NEC_WL300NUG        0x0249          /* WL300NU-G */
    31803237#define USB_PRODUCT_NEC_HUB     0x55aa          /* hub */
    31813238#define USB_PRODUCT_NEC_HUB_B   0x55ab          /* hub */
     
    32053262#define USB_PRODUCT_NETGEAR_FA120       0x1040          /* USB 2.0 Ethernet */
    32063263#define USB_PRODUCT_NETGEAR_M4100       0x1100          /* M4100/M5300/M7100 series switch */
    3207 #define USB_PRODUCT_NETGEAR_WG111V2_2   0x4240          /* PrismGT USB 2.0 WLAN */
     3264#define USB_PRODUCT_NETGEAR_WG111V1_2   0x4240          /* PrismGT USB 2.0 WLAN */
    32083265#define USB_PRODUCT_NETGEAR_WG111V3     0x4260          /* WG111v3 */
    32093266#define USB_PRODUCT_NETGEAR_WG111U      0x4300          /* WG111U */
    32103267#define USB_PRODUCT_NETGEAR_WG111U_NF   0x4301          /* WG111U (no firmware) */
    32113268#define USB_PRODUCT_NETGEAR_WG111V2     0x6a00          /* WG111V2 */
     3269#define USB_PRODUCT_NETGEAR_WN111V2     0x9001          /* WN111V2 */
     3270#define USB_PRODUCT_NETGEAR_WNDA3100    0x9010          /* WNDA3100 */
     3271#define USB_PRODUCT_NETGEAR_WNDA4100    0x9012          /* WNDA4100 */
     3272#define USB_PRODUCT_NETGEAR_WNDA3200    0x9018          /* WNDA3200 */
    32123273#define USB_PRODUCT_NETGEAR_RTL8192CU   0x9021          /* RTL8192CU */
     3274#define USB_PRODUCT_NETGEAR_WNA1000     0x9040          /* WNA1000 */
    32133275#define USB_PRODUCT_NETGEAR_WNA1000M    0x9041          /* WNA1000M */
    32143276#define USB_PRODUCT_NETGEAR2_MA101      0x4100          /* MA101 */
     
    34743536#define USB_PRODUCT_PLANEX2_GW_US11S    0x3220          /* GW-US11S WLAN */
    34753537#define USB_PRODUCT_PLANEX2_GW_US54GXS  0x5303          /* GW-US54GXS WLAN */
     3538#define USB_PRODUCT_PLANEX2_GW_US300    0x5304          /* GW-US300 */
    34763539#define USB_PRODUCT_PLANEX2_RTL8188CU_1 0xab2a          /* RTL8188CU */
    34773540#define USB_PRODUCT_PLANEX2_RTL8188CU_2 0xed17          /* RTL8188CU */
     
    36543717#define USB_PRODUCT_QUALCOMMINC_E0082   0x0082          /* 3G modem */
    36553718#define USB_PRODUCT_QUALCOMMINC_E0086   0x0086          /* 3G modem */
     3719#define USB_PRODUCT_QUALCOMMINC_MF112   0x0103          /* 3G modem */
    36563720#define USB_PRODUCT_QUALCOMMINC_SURFSTICK       0x0117          /* 1&1 Surf Stick */
    36573721#define USB_PRODUCT_QUALCOMMINC_K3772_Z_INIT    0x1179          /* K3772-Z Initial */
     
    37243788#define USB_PRODUCT_REALTEK_RTL8188CTV  0x018a          /* RTL8188CTV */
    37253789#define USB_PRODUCT_REALTEK_USBKR100    0x8150          /* USBKR100 USB Ethernet */
     3790#define USB_PRODUCT_REALTEK_RTL8153     0x8153          /* RTL8153 USB Ethernet */
    37263791#define USB_PRODUCT_REALTEK_RTL8188CE_0 0x8170          /* RTL8188CE */
    37273792#define USB_PRODUCT_REALTEK_RTL8171     0x8171          /* RTL8171 */
     
    37363801#define USB_PRODUCT_REALTEK_RTL8187     0x8187          /* RTL8187 Wireless Adapter */
    37373802#define USB_PRODUCT_REALTEK_RTL8187B_0  0x8189          /* RTL8187B Wireless Adapter */
     3803#define USB_PRODUCT_REALTEK_RTL8188CU_3 0x8191          /* RTL8188CU */
    37383804#define USB_PRODUCT_REALTEK_RTL8196EU   0x8196          /* RTL8196EU */
    37393805#define USB_PRODUCT_REALTEK_RTL8187B_1  0x8197          /* RTL8187B Wireless Adapter */
     
    40094075#define USB_PRODUCT_SIERRA_E6893        0x6893          /* E6893 */
    40104076#define USB_PRODUCT_SIERRA_MC8700       0x68A3          /* MC8700 */
    4011 #define USB_PRODUCT_SIERRA_AIRCARD875   0x6820          /* Aircard 875 HSDPA */
     4077#define USB_PRODUCT_SIERRA_MC7354       0x68C0          /* MC7354 */
     4078#define USB_PRODUCT_SIERRA_MC7355       0x9041          /* MC7355 */
    40124079#define USB_PRODUCT_SIERRA_AC313U       0x68aa          /* Sierra Wireless AirCard 313U */
    40134080#define USB_PRODUCT_SIERRA_TRUINSTALL   0x0fff          /* Aircard Tru Installer */
     
    43884455/* TRENDnet products */
    43894456#define USB_PRODUCT_TRENDNET_RTL8192CU  0x624d          /* RTL8192CU */
     4457#define USB_PRODUCT_TRENDNET_TEW646UBH  0x646b          /* TEW-646UBH */
    43904458#define USB_PRODUCT_TRENDNET_RTL8188CU  0x648b          /* RTL8188CU */
    43914459
     
    45414609
    45424610/* Wistron NeWeb products */
     4611#define USB_PRODUCT_WISTRONNEWEB_WNC0600        0x0326          /* WNC-0600USB */
    45434612#define USB_PRODUCT_WISTRONNEWEB_UR045G 0x0427          /* PrismGT USB 2.0 WLAN */
    45444613#define USB_PRODUCT_WISTRONNEWEB_UR055G 0x0711          /* UR055G */
     4614#define USB_PRODUCT_WISTRONNEWEB_O8494  0x0804          /* ORiNOCO 802.11n */
    45454615#define USB_PRODUCT_WISTRONNEWEB_AR5523_1       0x0826          /* AR5523 */
    45464616#define USB_PRODUCT_WISTRONNEWEB_AR5523_1_NF    0x0827          /* AR5523 (no firmware) */
     
    45914661#define USB_PRODUCT_ZCOM_ZD1211B        0x001a          /* ZD1211B */
    45924662#define USB_PRODUCT_ZCOM_RT2870_1       0x0022          /* RT2870 */
     4663#define USB_PRODUCT_ZCOM_UB81   0x0023          /* UB81 */
    45934664#define USB_PRODUCT_ZCOM_RT2870_2       0x0025          /* RT2870 */
     4665#define USB_PRODUCT_ZCOM_UB82   0x0026          /* UB82 */
    45944666
    45954667/* Zinwell products */
     
    46104682#define USB_PRODUCT_ZYDAS_ZD1211        0x1211          /* ZD1211 WLAN abg */
    46114683#define USB_PRODUCT_ZYDAS_ZD1211B       0x1215          /* ZD1211B */
     4684#define USB_PRODUCT_ZYDAS_ZD1221        0x1221          /* ZD1221 */
    46124685
    46134686/* ZyXEL Communication Co. products */
     
    46214694#define USB_PRODUCT_ZYXEL_G202  0x3410          /* G-202 */
    46224695#define USB_PRODUCT_ZYXEL_RT2870_1      0x3416          /* RT2870 */
     4696#define USB_PRODUCT_ZYXEL_NWD271N       0x3417          /* NWD-271N */
     4697#define USB_PRODUCT_ZYXEL_NWD211AN      0x3418          /* NWD-211AN */
    46234698#define USB_PRODUCT_ZYXEL_RT2870_2      0x341a          /* RT2870 */
    46244699#define USB_PRODUCT_ZYXEL_RT3070        0x341e          /* NWD2105 */
  • rtemsbsd/include/rtems/bsd/local/usbdevs_data.h

    rc164446 r02279d6  
    455455        },
    456456        {
     457            USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_WN7512,
     458            0,
     459            "Accton Technology",
     460            "WN7512",
     461        },
     462        {
    457463            USB_VENDOR_ACEECA, USB_PRODUCT_ACEECA_MEZ1000,
    458464            0,
     
    18591865        },
    18601866        {
     1867            USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_TG121N,
     1868            0,
     1869            "Atheros Communications",
     1870            "TG121N",
     1871        },
     1872        {
     1873            USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_WN821NV2,
     1874            0,
     1875            "Atheros Communications",
     1876            "WN821NV2",
     1877        },
     1878        {
     1879            USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_3CRUSBN275,
     1880            0,
     1881            "Atheros Communications",
     1882            "3CRUSBN275",
     1883        },
     1884        {
     1885            USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_WN612,
     1886            0,
     1887            "Atheros Communications",
     1888            "WN612",
     1889        },
     1890        {
     1891            USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_AR9170,
     1892            0,
     1893            "Atheros Communications",
     1894            "AR9170",
     1895        },
     1896        {
    18611897            USB_VENDOR_ATMEL, USB_PRODUCT_ATMEL_STK541,
    18621898            0,
     
    19071943        },
    19081944        {
     1945            USB_VENDOR_AVM, USB_PRODUCT_AVM_FRITZWLAN,
     1946            0,
     1947            "AVM",
     1948            "FRITZ!WLAN N",
     1949        },
     1950        {
    19091951            USB_VENDOR_AXESSTEL, USB_PRODUCT_AXESSTEL_DATAMODEM,
    19101952            0,
     
    23872429        },
    23882430        {
     2431            USB_VENDOR_CACE, USB_PRODUCT_CACE_AIRPCAPNX,
     2432            0,
     2433            "CACE Technologies",
     2434            "AirPcap NX",
     2435        },
     2436        {
    23892437            USB_VENDOR_CANON, USB_PRODUCT_CANON_N656U,
    23902438            0,
     
    25992647            USB_VENDOR_CHICONY2, USB_PRODUCT_CHICONY2_TWINKLECAM,
    26002648            0,
    2601             "Chicony",
     2649            "Chicony / Microdia / Sonix Technology Co., Ltd.",
    26022650            "TwinkleCam USB camera",
    26032651        },
     
    26812729        },
    26822730        {
     2731            USB_VENDOR_CISCOLINKSYS, USB_PRODUCT_CISCOLINKSYS_USB3GIGV1,
     2732            0,
     2733            "Cisco-Linksys",
     2734            "USB3GIGV1 USB Ethernet Adapter",
     2735        },
     2736        {
    26832737            USB_VENDOR_CISCOLINKSYS2, USB_PRODUCT_CISCOLINKSYS2_RT3070,
    26842738            0,
     
    34733527        },
    34743528        {
     3529            USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWA123D1,
     3530            0,
     3531            "D-Link",
     3532            "DWA-123 rev D1",
     3533        },
     3534        {
    34753535            USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWL122,
    34763536            0,
     
    37073767        },
    37083768        {
     3769            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160A2,
     3770            0,
     3771            "D-Link",
     3772            "DWA-160 A2",
     3773        },
     3774        {
    37093775            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA120,
    37103776            0,
     
    37193785        },
    37203786        {
     3787            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA130D1,
     3788            0,
     3789            "D-Link",
     3790            "DWA-130 D1",
     3791        },
     3792        {
    37213793            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWLG122C1,
    37223794            0,
     
    37793851        },
    37803852        {
     3853            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160A1,
     3854            0,
     3855            "D-Link",
     3856            "DWA-160 A1",
     3857        },
     3858        {
    37813859            USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_RT2870_2,
    37823860            0,
     
    38093887        },
    38103888        {
     3889            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD4300U,
     3890            0,
     3891            "DisplayLink",
     3892            "LCD-4300U",
     3893        },
     3894        {
     3895            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LCD8000U,
     3896            0,
     3897            "DisplayLink",
     3898            "LCD-8000U",
     3899        },
     3900        {
     3901            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LD220,
     3902            0,
     3903            "DisplayLink",
     3904            "Samsung LD220",
     3905        },
     3906        {
     3907            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_GUC2020,
     3908            0,
     3909            "DisplayLink",
     3910            "IOGEAR DVI GUC2020",
     3911        },
     3912        {
     3913            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VCUD60,
     3914            0,
     3915            "DisplayLink",
     3916            "Rextron DVI",
     3917        },
     3918        {
     3919            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_CONV,
     3920            0,
     3921            "DisplayLink",
     3922            "StarTech CONV-USB2DVI",
     3923        },
     3924        {
     3925            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_DLDVI,
     3926            0,
     3927            "DisplayLink",
     3928            "DisplayLink DVI",
     3929        },
     3930        {
     3931            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_VGA10,
     3932            0,
     3933            "DisplayLink",
     3934            "CMP-USBVGA10",
     3935        },
     3936        {
     3937            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_WSDVI,
     3938            0,
     3939            "DisplayLink",
     3940            "WS Tech DVI",
     3941        },
     3942        {
     3943            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_EC008,
     3944            0,
     3945            "DisplayLink",
     3946            "EasyCAP008 DVI",
     3947        },
     3948        {
     3949            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_HPDOCK,
     3950            0,
     3951            "DisplayLink",
     3952            "HP USB Docking",
     3953        },
     3954        {
     3955            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NL571,
     3956            0,
     3957            "DisplayLink",
     3958            "HP USB DVI",
     3959        },
     3960        {
     3961            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_M01061,
     3962            0,
     3963            "DisplayLink",
     3964            "Lenovo DVI",
     3965        },
     3966        {
     3967            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_SWDVI,
     3968            0,
     3969            "DisplayLink",
     3970            "SUNWEIT DVI",
     3971        },
     3972        {
     3973            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_NBDOCK,
     3974            0,
     3975            "DisplayLink",
     3976            "VideoHome NBdock1920",
     3977        },
     3978        {
     3979            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LUM70,
     3980            0,
     3981            "DisplayLink",
     3982            "Lilliput UM-70",
     3983        },
     3984        {
     3985            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_UM7X0,
     3986            0,
     3987            "DisplayLink",
     3988            "nanovision MiMo",
     3989        },
     3990        {
     3991            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_LT1421,
     3992            0,
     3993            "DisplayLink",
     3994            "Lenovo ThinkVision LT1421",
     3995        },
     3996        {
     3997            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_POLARIS2,
     3998            0,
     3999            "DisplayLink",
     4000            "Polaris2 USB dock",
     4001        },
     4002        {
     4003            USB_VENDOR_DISPLAYLINK, USB_PRODUCT_DISPLAYLINK_PLUGABLE,
     4004            0,
     4005            "DisplayLink",
     4006            "Plugable docking station",
     4007        },
     4008        {
    38114009            USB_VENDOR_DMI, USB_PRODUCT_DMI_CFSM_RW,
    38124010            0,
     
    38574055        },
    38584056        {
     4057            USB_VENDOR_DYMO, USB_PRODUCT_DYMO_LABELMANAGERPNP,
     4058            0,
     4059            "DYMO",
     4060            "DYMO LabelManager PnP",
     4061        },
     4062        {
    38594063            USB_VENDOR_DYNASTREAM, USB_PRODUCT_DYNASTREAM_ANTDEVBOARD,
    38604064            0,
     
    40134217        },
    40144218        {
     4219            USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_WDC150SU2M,
     4220            0,
     4221            "Elecom",
     4222            "WDC-150SU2M",
     4223        },
     4224        {
    40154225            USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBTX2,
    40164226            0,
     
    45534763        },
    45544764        {
     4765            USB_VENDOR_FTDI, USB_PRODUCT_FTDI_SCX8_USB_PHOENIX,
     4766            0,
     4767            "Future Technology Devices",
     4768            "SCx8 USB Phoenix interface",
     4769        },
     4770        {
    45554771            USB_VENDOR_FTDI, USB_PRODUCT_FTDI_SERIAL_8U100AX,
    45564772            0,
     
    72477463        },
    72487464        {
     7465            USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_ME909U,
     7466            0,
     7467            "Huawei Technologies",
     7468            "LTE modem",
     7469        },
     7470        {
    72497471            USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_R215_INIT,
    72507472            0,
     
    75597781        },
    75607782        {
     7783            USB_VENDOR_IODATA, USB_PRODUCT_IODATA_WNGDNUS2,
     7784            0,
     7785            "I-O Data",
     7786            "WN-GDN/US2",
     7787        },
     7788        {
    75617789            USB_VENDOR_IODATA, USB_PRODUCT_IODATA_RT3072_1,
    75627790            0,
     
    82018429        },
    82028430        {
     8431            USB_VENDOR_LENOVO, USB_PRODUCT_LENOVO_GIGALAN,
     8432            0,
     8433            "Lenovo",
     8434            "USB 3.0 Ethernet",
     8435        },
     8436        {
    82038437            USB_VENDOR_LENOVO, USB_PRODUCT_LENOVO_ETHERNET,
    82048438            0,
     
    1028910523        },
    1029010524        {
    10291             USB_VENDOR_MELCO, USB_PRODUCT_MELCO_RT2870_1,
     10525            USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCG300HP,
     10526            0,
     10527            "Melco",
     10528            "WLI-UC-G300HP",
     10529        },
     10530        {
     10531            USB_VENDOR_MELCO, USB_PRODUCT_MELCO_RT2870_2,
    1029210532            0,
    1029310533            "Melco",
     
    1029510535        },
    1029610536        {
    10297             USB_VENDOR_MELCO, USB_PRODUCT_MELCO_RT2870_2,
    10298             0,
    10299             "Melco",
    10300             "RT2870",
    10301         },
    10302         {
    1030310537            USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCGN,
    1030410538            0,
     
    1031910553        },
    1032010554        {
     10555            USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCG300HPV1,
     10556            0,
     10557            "Melco",
     10558            "WLI-UC-G300HP-V1",
     10559        },
     10560        {
    1032110561            USB_VENDOR_MELCO, USB_PRODUCT_MELCO_WLIUCGNM2,
    1032210562            0,
     
    1038510625        },
    1038610626        {
     10627            USB_VENDOR_CHICONY2, USB_PRODUCT_CHICONY2_YUREX,
     10628            0,
     10629            "Chicony / Microdia / Sonix Technology Co., Ltd.",
     10630            "YUREX",
     10631        },
     10632        {
     10633            USB_VENDOR_CHICONY2, USB_PRODUCT_CHICONY2_CAM_1,
     10634            0,
     10635            "Chicony / Microdia / Sonix Technology Co., Ltd.",
     10636            "CAM_1",
     10637        },
     10638        {
     10639            USB_VENDOR_CHICONY2, USB_PRODUCT_CHICONY2_TEMPER,
     10640            0,
     10641            "Chicony / Microdia / Sonix Technology Co., Ltd.",
     10642            "TEMPer sensor",
     10643        },
     10644        {
    1038710645            USB_VENDOR_MSI, USB_PRODUCT_MSI_BT_DONGLE,
    1038810646            0,
     
    1105111309        },
    1105211310        {
     11311            USB_VENDOR_NEC, USB_PRODUCT_NEC_WL300NUG,
     11312            0,
     11313            "NEC",
     11314            "WL300NU-G",
     11315        },
     11316        {
    1105311317            USB_VENDOR_NEC, USB_PRODUCT_NEC_HUB,
    1105411318            0,
     
    1115311417        },
    1115411418        {
    11155             USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WG111V2_2,
     11419            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WG111V1_2,
    1115611420            0,
    1115711421            "BayNETGEAR",
     
    1118311447        },
    1118411448        {
     11449            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WN111V2,
     11450            0,
     11451            "BayNETGEAR",
     11452            "WN111V2",
     11453        },
     11454        {
     11455            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNDA3100,
     11456            0,
     11457            "BayNETGEAR",
     11458            "WNDA3100",
     11459        },
     11460        {
     11461            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNDA4100,
     11462            0,
     11463            "BayNETGEAR",
     11464            "WNDA4100",
     11465        },
     11466        {
     11467            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNDA3200,
     11468            0,
     11469            "BayNETGEAR",
     11470            "WNDA3200",
     11471        },
     11472        {
    1118511473            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_RTL8192CU,
    1118611474            0,
     
    1118911477        },
    1119011478        {
     11479            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNA1000,
     11480            0,
     11481            "BayNETGEAR",
     11482            "WNA1000",
     11483        },
     11484        {
    1119111485            USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNA1000M,
    1119211486            0,
     
    1239512689        },
    1239612690        {
     12691            USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GW_US300,
     12692            0,
     12693            "Planex Communications",
     12694            "GW-US300",
     12695        },
     12696        {
    1239712697            USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_RTL8188CU_1,
    1239812698            0,
     
    1331913619        },
    1332013620        {
     13621            USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_MF112,
     13622            0,
     13623            "Qualcomm, Incorporated",
     13624            "3G modem",
     13625        },
     13626        {
    1332113627            USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_SURFSTICK,
    1332213628            0,
     
    1363713943        },
    1363813944        {
     13945            USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8153,
     13946            0,
     13947            "Realtek",
     13948            "RTL8153 USB Ethernet",
     13949        },
     13950        {
    1363913951            USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8188CE_0,
    1364013952            0,
     
    1370914021        },
    1371014022        {
     14023            USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8188CU_3,
     14024            0,
     14025            "Realtek",
     14026            "RTL8188CU",
     14027        },
     14028        {
    1371114029            USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8196EU,
    1371214030            0,
     
    1505915377        },
    1506015378        {
    15061             USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875,
     15379            USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC7354,
    1506215380            0,
    1506315381            "Sierra Wireless",
    15064             "Aircard 875 HSDPA",
     15382            "MC7354",
     15383        },
     15384        {
     15385            USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC7355,
     15386            0,
     15387            "Sierra Wireless",
     15388            "MC7355",
    1506515389        },
    1506615390        {
     
    1667316997        },
    1667416998        {
     16999            USB_VENDOR_TRENDNET, USB_PRODUCT_TRENDNET_TEW646UBH,
     17000            0,
     17001            "TRENDnet",
     17002            "TEW-646UBH",
     17003        },
     17004        {
    1667517005            USB_VENDOR_TRENDNET, USB_PRODUCT_TRENDNET_RTL8188CU,
    1667617006            0,
     
    1721917549        },
    1722017550        {
     17551            USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_WNC0600,
     17552            0,
     17553            "Wistron NeWeb",
     17554            "WNC-0600USB",
     17555        },
     17556        {
    1722117557            USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_UR045G,
    1722217558            0,
     
    1723117567        },
    1723217568        {
     17569            USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_O8494,
     17570            0,
     17571            "Wistron NeWeb",
     17572            "ORiNOCO 802.11n",
     17573        },
     17574        {
    1723317575            USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_AR5523_1,
    1723417576            0,
     
    1741117753        },
    1741217754        {
     17755            USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_UB81,
     17756            0,
     17757            "Z-Com",
     17758            "UB81",
     17759        },
     17760        {
    1741317761            USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_RT2870_2,
    1741417762            0,
     
    1741717765        },
    1741817766        {
     17767            USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_UB82,
     17768            0,
     17769            "Z-Com",
     17770            "UB82",
     17771        },
     17772        {
    1741917773            USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT2570,
    1742017774            0,
     
    1747717831        },
    1747817832        {
     17833            USB_VENDOR_ZYDAS, USB_PRODUCT_ZYDAS_ZD1221,
     17834            0,
     17835            "Zydas Technology Corporation",
     17836            "ZD1221",
     17837        },
     17838        {
    1747917839            USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_OMNI56K,
    1748017840            0,
     
    1753117891        },
    1753217892        {
     17893            USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_NWD271N,
     17894            0,