usb4bsd: Cleanup pass.
authorSascha Wildner <saw@online.de>
Mon, 1 Oct 2012 04:04:09 +0000 (06:04 +0200)
committerSascha Wildner <saw@online.de>
Thu, 11 Oct 2012 09:27:42 +0000 (11:27 +0200)
* Adjust indentation, whitespace and typos.

* Uniformly use #if 0 to deactivate code instead of C comments.

32 files changed:
sys/bus/u4b/controller/ehci.c
sys/bus/u4b/controller/ehci_pci.c
sys/bus/u4b/controller/ohci.c
sys/bus/u4b/controller/ohci_pci.c
sys/bus/u4b/controller/uhci.c
sys/bus/u4b/controller/uhci_pci.c
sys/bus/u4b/controller/usb_controller.c
sys/bus/u4b/controller/xhci.c
sys/bus/u4b/controller/xhci_pci.c
sys/bus/u4b/storage/umass.c
sys/bus/u4b/storage/ustorage_fs.c
sys/bus/u4b/usb_busdma.c
sys/bus/u4b/usb_compat_linux.c
sys/bus/u4b/usb_core.c
sys/bus/u4b/usb_core.h
sys/bus/u4b/usb_dev.c
sys/bus/u4b/usb_dev.h
sys/bus/u4b/usb_device.c
sys/bus/u4b/usb_device.h
sys/bus/u4b/usb_dynamic.c
sys/bus/u4b/usb_freebsd.h
sys/bus/u4b/usb_generic.c
sys/bus/u4b/usb_hid.c
sys/bus/u4b/usb_hub.c
sys/bus/u4b/usb_msctest.c
sys/bus/u4b/usb_pf.c
sys/bus/u4b/usb_process.c
sys/bus/u4b/usb_process.h
sys/bus/u4b/usb_request.c
sys/bus/u4b/usb_transfer.c
sys/bus/u4b/usb_util.c
sys/bus/u4b/usbdi.h

index 4738d9d..cdee012 100644 (file)
@@ -43,9 +43,6 @@
  * 1) command failures are not recovered correctly
  */
 
-#include <sys/cdefs.h>
-//__FBSDID("$FreeBSD$");
-
 #include <sys/stdint.h>
 #include <sys/param.h>
 #include <sys/queue.h>
@@ -1405,6 +1402,7 @@ static void
 ehci_pcd_enable(ehci_softc_t *sc)
 {
        USB_BUS_LOCK_ASSERT(&sc->sc_bus);
+
        sc->sc_eintrs |= EHCI_STS_PCD;
        EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs);
 
index d8ef48d..fc85158 100644 (file)
@@ -28,8 +28,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 /*
  * USB Enhanced Host Controller Driver, a.k.a. USB 2.0 controller.
  *
@@ -359,7 +357,7 @@ ehci_pci_attach(device_t self)
                ksprintf(sc->sc_vendor, "(0x%04x)", pci_get_vendor(self));
        }
 
-    /* XXX Can we make good use of the serialiser? */
+       /* XXX Can we make good use of the serializer? */
        err = bus_setup_intr(self, sc->sc_irq_res, INTR_MPSAFE,
            (driver_intr_t *)ehci_interrupt, sc, &sc->sc_intr_hdl, NULL);
 
@@ -447,10 +445,10 @@ ehci_pci_detach(device_t self)
                device_detach(bdev);
                device_delete_child(self, bdev);
        }
+#if 0 /* XXX */
        /* during module unload there are lots of children leftover */
-    /* XXX
        device_delete_children(self);
-    */
+#endif
 
        pci_disable_busmaster(self);
 
@@ -538,7 +536,7 @@ static device_method_t ehci_pci_methods[] = {
        DEVMETHOD(device_shutdown, bus_generic_shutdown),
        DEVMETHOD(usb_take_controller, ehci_pci_take_controller),
 
-    { 0, 0 }
+       { 0, 0 }
 };
 
 static driver_t ehci_driver = {
index 8b75319..95e653a 100644 (file)
@@ -25,8 +25,6 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 /*
  * USB Open Host Controller driver.
  *
index 335177c..938d150 100644 (file)
@@ -28,8 +28,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 /*
  * USB Open Host Controller driver.
  *
@@ -290,7 +288,6 @@ ohci_pci_attach(device_t self)
 
        err = bus_setup_intr(self, sc->sc_irq_res, INTR_MPSAFE,
            (driver_intr_t *)ohci_interrupt, sc, &sc->sc_intr_hdl, NULL);
-
        if (err) {
                device_printf(self, "Could not setup irq, %d\n", err);
                sc->sc_intr_hdl = NULL;
@@ -322,10 +319,10 @@ ohci_pci_detach(device_t self)
                device_detach(bdev);
                device_delete_child(self, bdev);
        }
-       /* during module unload there are lots of children leftover */
-    /* XXX Implement this
+#if 0 /* XXX Implement this */
+       /* during module unload there are lots of children leftover */
        device_delete_children(self);
-    */
+#endif
 
        pci_disable_busmaster(self);
 
@@ -368,7 +365,7 @@ static device_method_t ohci_pci_methods[] = {
        DEVMETHOD(device_shutdown, bus_generic_shutdown),
        DEVMETHOD(usb_take_controller, ohci_pci_take_controller),
 
-    { 0, 0 }
+       { 0, 0 }
 };
 
 static driver_t ohci_driver = {
index fe15913..5c9f12c 100644 (file)
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 /*
  * USB Universal Host Controller driver.
- * hANDLES e.g. PIIX3 and PIIX4.
+ * Handles e.g. PIIX3 and PIIX4.
  *
  * UHCI spec: http://developer.intel.com/design/USB/UHCI11D.htm
  * USB spec:  http://www.usb.org/developers/docs/usbspec.zip
index 15f4c0b..d65c67f 100644 (file)
@@ -28,8 +28,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 /* Universal Host Controller Interface
  *
  * UHCI spec: http://www.intel.com/
@@ -377,10 +375,11 @@ uhci_pci_detach(device_t self)
                device_detach(bdev);
                device_delete_child(self, bdev);
        }
+#if 0 /* XXX */
        /* during module unload there are lots of children leftover */
-/* XXX */
-/*     device_delete_children(self);
-*/
+       device_delete_children(self);
+#endif
+
        /*
         * disable interrupts that might have been switched on in
         * uhci_init.
@@ -429,7 +428,7 @@ static device_method_t uhci_pci_methods[] = {
        DEVMETHOD(device_shutdown, bus_generic_shutdown),
        DEVMETHOD(usb_take_controller, uhci_pci_take_controller),
 
-    { 0, 0 }
+       { 0, 0 }
 };
 
 static driver_t uhci_driver = {
index 37e76e4..92af53b 100644 (file)
@@ -139,8 +139,9 @@ usb_root_mount_rel(struct usb_bus *bus)
 {
        if (bus->bus_roothold != NULL) {
                DPRINTF("Releasing root mount hold %p\n", bus->bus_roothold);
-        /* XXX Dragonflybsd seems to not have this? */
-               /*root_mount_rel(bus->bus_roothold);*/
+#if 0 /* XXX Dragonflybsd seems to not have this? */
+               root_mount_rel(bus->bus_roothold);
+#endif
                bus->bus_roothold = NULL;
        }
 }
@@ -160,13 +161,12 @@ usb_attach(device_t dev)
                return (ENXIO);
        }
 
+#if 0 /* XXX: Dragonfly does not seem to have this mechanism? */
        if (usb_no_boot_wait == 0) {
                /* delay vfs_mountroot until the bus is explored */
-        /* XXX: Dragonfly does not seem to have this mechanism? */
-        /*
                bus->bus_roothold = root_mount_hold(device_get_nameunit(dev));
-        */
        }
+#endif
 
        usb_attach_sub(dev, bus);
 
@@ -192,7 +192,7 @@ usb_detach(device_t dev)
 
        /* Let the USB explore process detach all devices. */
        usb_root_mount_rel(bus);
-    
+
        USB_BUS_LOCK(bus);
 
        /* Queue detach job */
@@ -792,11 +792,7 @@ usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,
     usb_bus_mem_cb_t *cb)
 {
        bus->alloc_failed = 0;
-    /* XXX: Type mismatch, device_get_nameunit gives
-     * const char*, lockinit wants char *
-     */
-    const char *pname = device_get_nameunit(bus->parent);
-    kprintf("usb_bus_mem_alloc_all %s\n", pname);
+
        lockinit(&bus->bus_lock, "USB bus mem", 0, LK_CANRECURSE);
 
        usb_callout_init_mtx(&bus->power_wdog,
@@ -851,5 +847,5 @@ usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb)
        usb_dma_tag_unsetup(bus->dma_parent_tag);
 #endif
 
-    lockuninit(&bus->bus_lock);
+       lockuninit(&bus->bus_lock);
 }
index b7ed08a..9e207ac 100644 (file)
@@ -38,8 +38,6 @@
  * way we avoid too much diveration among USB drivers.
  */
 
-#include <sys/cdefs.h>
-
 #include <sys/stdint.h>
 #include <sys/param.h>
 #include <sys/queue.h>
@@ -514,7 +512,7 @@ xhci_init(struct xhci_softc *sc, device_t self)
 
        /* setup command queue mutex and condition varible */
        cv_init(&sc->sc_cmd_cv, "CMDQ");
-    lockinit(&sc->sc_cmd_lock, "CMDQ lock", 0, 0);
+       lockinit(&sc->sc_cmd_lock, "CMDQ lock", 0, 0);
 
        /* get all DMA memory */
        if (usb_bus_mem_alloc_all(&sc->sc_bus,
index 52b1a07..e36c2e9 100644 (file)
@@ -23,8 +23,6 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-
 #include <sys/stdint.h>
 #include <sys/param.h>
 #include <sys/queue.h>
@@ -72,7 +70,7 @@ static device_method_t xhci_device_methods[] = {
        DEVMETHOD(device_shutdown, bus_generic_shutdown),
        DEVMETHOD(usb_take_controller, xhci_pci_take_controller),
 
-    { 0, 0 }
+       { 0, 0 }
 };
 
 static driver_t xhci_driver = {
@@ -193,10 +191,11 @@ xhci_pci_detach(device_t self)
                device_detach(bdev);
                device_delete_child(self, bdev);
        }
+#if 0 /* XXX */
        /* during module unload there are lots of children leftover */
-    /* XXX
        device_delete_children(self);
-    */
+#endif
+
        pci_disable_busmaster(self);
 
        if (sc->sc_irq_res && sc->sc_intr_hdl) {
index 9497395..af04629 100644 (file)
 #include <bus/u4b/usbdi.h>
 #include <bus/u4b/usbdi_util.h>
 #include <bus/u4b/usbdevs.h>
-/*
-#include "usbdevs.h"
-*/
+
 #include <bus/u4b/quirk/usb_quirk.h>
 
 #include <bus/cam/cam.h>
@@ -1051,8 +1049,8 @@ umass_detach(device_t dev)
        lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
        umass_cam_detach_sim(sc);
 
-    lockmgr(&sc->sc_lock, LK_RELEASE);
-    lockuninit(&sc->sc_lock);
+       lockmgr(&sc->sc_lock, LK_RELEASE);
+       lockuninit(&sc->sc_lock);
 
        return (0);                     /* success */
 }
@@ -1115,8 +1113,10 @@ umass_cancel_ccb(struct umass_softc *sc)
 {
        union ccb *ccb;
 
-/*    KKASSERT(lockstatus(&sc->sc_lock, curthread) != 0);
-*/
+#if 0
+       KKASSERT(lockstatus(&sc->sc_lock, curthread) != 0);
+#endif
+
        ccb = sc->sc_transfer.ccb;
        sc->sc_transfer.ccb = NULL;
        sc->sc_last_xfer_index = 0;
@@ -2122,7 +2122,7 @@ umass_cam_attach_sim(struct umass_softc *sc)
                return (ENOMEM);
        }
 
-    lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
+       lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
 
        if (xpt_bus_register(sc->sc_sim, sc->sc_unit) != CAM_SUCCESS) {
                lockmgr(&sc->sc_lock, LK_RELEASE);
@@ -2323,7 +2323,7 @@ umass_cam_action(struct cam_sim *sim, union ccb *ccb)
                                        if ((sc->sc_quirks & (NO_INQUIRY_EVPD | NO_INQUIRY)) &&
                                            (sc->sc_transfer.cmd_data[1] & SI_EVPD)) {
 
-#ifdef XXXDF
+#if 0 /* XXXDF */
                                                scsi_set_sense_data(&ccb->csio.sense_data,
                                                        /*sense_format*/ SSD_TYPE_NONE,
                                                        /*current_error*/ 1,
@@ -2389,12 +2389,10 @@ umass_cam_action(struct cam_sim *sim, union ccb *ccb)
                        strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
                        cpi->unit_number = cam_sim_unit(sim);
                        cpi->bus_id = sc->sc_unit;
-//#if (__FreeBSD_version >= 700025)
                        cpi->protocol = PROTO_SCSI;
                        cpi->protocol_version = SCSI_REV_2;
                        cpi->transport = XPORT_USB;
                        cpi->transport_version = 0;
-//#endif
                        if (sc == NULL) {
                                cpi->base_transfer_speed = 0;
                                cpi->max_lun = 0;
@@ -2407,9 +2405,9 @@ umass_cam_action(struct cam_sim *sim, union ccb *ccb)
                                        case USB_SPEED_SUPER:
                                                cpi->base_transfer_speed =
                                                    UMASS_SUPER_TRANSFER_SPEED;
-                        /* XXX
+#if 0 /* XXX */
                                                cpi->maxio = MAXPHYS;
-                        */
+#endif
                                                break;
                                        case USB_SPEED_HIGH:
                                                cpi->base_transfer_speed =
@@ -2610,17 +2608,19 @@ umass_cam_sense_cb(struct umass_softc *sc, union ccb *ccb, uint32_t residue,
        switch (status) {
        case STATUS_CMD_OK:
        case STATUS_CMD_UNKNOWN:
-       case STATUS_CMD_FAILED: {
+       case STATUS_CMD_FAILED:
+       {
                int error, key, asc, ascq;
 
-               /* XXX
-       ccb->csio.sense_resid = residue;
+#if 0 /* XXX */
+               ccb->csio.sense_resid = residue;
                sense_len = ccb->csio.sense_len - ccb->csio.sense_resid;
                key = scsi_get_sense_key(&ccb->csio.sense_data, sense_len,
-                                        1);
-        */
-        scsi_extract_sense(&ccb->csio.sense_data, &error, &key, 
-                            &asc, &ascq);
+                                        /*show_errors*/ 1);
+#endif
+
+               scsi_extract_sense(&ccb->csio.sense_data, &error, &key, 
+                   &asc, &ascq);
                if (ccb->csio.ccb_h.flags & CAM_CDB_POINTER) {
                        cmd = (uint8_t *)(ccb->csio.cdb_io.cdb_ptr);
                } else {
index 2eabf30..ac8265c 100644 (file)
@@ -386,7 +386,8 @@ ustorage_fs_attach(device_t dev)
 
        device_set_usb_desc(dev);
 
-    lockinit(&sc->sc_lock, "USTORAGE_FS lock", 0, LK_CANRECURSE);
+       lockinit(&sc->sc_lock, "USTORAGE_FS lock", 0, LK_CANRECURSE);
+
        /* get interface index */
 
        id = usbd_get_interface_descriptor(uaa->iface);
@@ -407,9 +408,9 @@ ustorage_fs_attach(device_t dev)
        }
        /* start Mass Storage State Machine */
 
-    lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
+       lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
        ustorage_fs_transfer_start(sc, USTORAGE_FS_T_BBB_COMMAND);
-    lockmgr(&sc->sc_lock, LK_RELEASE);
+       lockmgr(&sc->sc_lock, LK_RELEASE);
 
        return (0);                     /* success */
 
@@ -463,9 +464,9 @@ static void
 ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc)
 {
        usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]);
-    lockmgr(&sc->sc_lock, LK_RELEASE);
+       lockmgr(&sc->sc_lock, LK_RELEASE);
        usbd_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]);
-    lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
+       lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
 }
 
 static int
@@ -481,12 +482,12 @@ ustorage_fs_handle_request(device_t dev,
                if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) &&
                    (req->bRequest == UR_BBB_RESET)) {
                        *plen = 0;
-            lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
+                       lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
                        ustorage_fs_transfer_stop(sc);
                        sc->sc_transfer.data_error = 1;
                        ustorage_fs_transfer_start(sc,
                            USTORAGE_FS_T_BBB_COMMAND);
-            lockmgr(&sc->sc_lock, LK_RELEASE);
+                       lockmgr(&sc->sc_lock, LK_RELEASE);
                        return (0);
                } else if ((req->bmRequestType == UT_READ_CLASS_INTERFACE) &&
                           (req->bRequest == UR_BBB_GET_MAX_LUN)) {
index e30f5cb..2fc9f21 100644 (file)
@@ -1,4 +1,4 @@
-/* $fREEbSD$ */
+/* $FreeBSD$ */
 /*-
  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
  *
@@ -62,7 +62,9 @@
 #if USB_HAVE_BUSDMA
 static void    usb_dma_tag_create(struct usb_dma_tag *, usb_size_t, usb_size_t);
 static void    usb_dma_tag_destroy(struct usb_dma_tag *);
-//static void  usb_dma_lock_cb(void *); //, bus_dma_lock_op_t);
+#if 0
+static void    usb_dma_lock_cb(void *, bus_dma_lock_op_t);
+#endif
 static void    usb_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);
 static void    usb_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int);
 static void    usb_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int,
@@ -336,11 +338,13 @@ usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset,
 /*------------------------------------------------------------------------*
  *     usb_dma_lock_cb - dummy callback
  *------------------------------------------------------------------------*/
-// static void
-//usb_dma_lock_cb(void *arg) // , bus_dma_lock_op_t op)
-//{
-//     /* we use "mtx_owned()" instead of this function */
-//}
+#if 0
+static void
+usb_dma_lock_cb(void *arg, bus_dma_lock_op_t op)
+{
+       /* we use "mtx_owned()" instead of this function */
+}
+#endif
 
 /*------------------------------------------------------------------------*
  *     usb_dma_tag_create - allocate a DMA tag
@@ -607,8 +611,7 @@ usb_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync)
        pc->page_offset_end = size;
        pc->ismultiseg = 1;
 
-       // mtx_assert(pc->tag_parent->mtx, MA_OWNED);
-    KKASSERT(lockstatus(pc->tag_parent->lock, curthread) != 0);
+       KKASSERT(lockstatus(pc->tag_parent->lock, curthread) != 0);
 
        if (size > 0) {
                if (sync) {
@@ -866,7 +869,7 @@ usb_bdma_work_loop(struct usb_xfer_queue *pq)
        xfer = pq->curr;
        info = xfer->xroot;
 
-    KKASSERT(lockstatus(info->xfer_lock, curthread) != 0);
+       KKASSERT(lockstatus(info->xfer_lock, curthread) != 0);
 
        if (xfer->error) {
                /* some error happened */
@@ -990,8 +993,7 @@ usb_bdma_done_event(struct usb_dma_parent_tag *udpt)
 
        info = USB_DMATAG_TO_XROOT(udpt);
 
-       // mtx_assert(info->xfer_mtx, MA_OWNED);
-    KKASSERT(lockstatus(info->xfer_lock, curthread) != 0);
+       KKASSERT(lockstatus(info->xfer_lock, curthread) != 0);
 
        /* copy error */
        info->dma_error = udpt->dma_error;
index 3567f51..2bdf4dc 100644 (file)
@@ -37,7 +37,6 @@
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/sysctl.h>
-//#include <sys/sx.h>
 #include <sys/unistd.h>
 #include <sys/callout.h>
 #include <sys/malloc.h>
index 5d4aa3a..db1ad3e 100644 (file)
@@ -42,7 +42,6 @@
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/sysctl.h>
-////#include <sys/sx.h>
 #include <sys/unistd.h>
 #include <sys/callout.h>
 #include <sys/malloc.h>
index ca06ae8..a011f19 100644 (file)
 
 #define        USB_BUS_LOCK(_b)                lockmgr(&(_b)->bus_lock, LK_EXCLUSIVE)
 #define        USB_BUS_UNLOCK(_b)              lockmgr(&(_b)->bus_lock, LK_RELEASE)
-#define        USB_BUS_LOCK_ASSERT(_b) KKASSERT(lockowned(&(_b)->bus_lock))
-#define USB_BUS_LOCK_ASSERT_NOTOWNED(_b) KKASSERT(!lockowned(&(_b)->bus_lock))
+#define        USB_BUS_LOCK_ASSERT(_b)         KKASSERT(lockowned(&(_b)->bus_lock))
+#define        USB_BUS_LOCK_ASSERT_NOTOWNED(_b) KKASSERT(!lockowned(&(_b)->bus_lock))
 #define        USB_XFER_LOCK(_x)               lockmgr((_x)->xroot->xfer_lock, LK_EXCLUSIVE)
 #define        USB_XFER_UNLOCK(_x)             lockmgr((_x)->xroot->xfer_lock, LK_RELEASE)
 #define        USB_XFER_LOCK_ASSERT(_x)        KKASSERT(lockstatus((_x)->xroot->xfer_lock, curthread) != 0)
-#define USB_XFER_LOCK_ASSERT_NOTOWNED(_x)   KKASSERT(lockstatus((_x)->xroot->xfer_lock, curthread) == 0)
+#define        USB_XFER_LOCK_ASSERT_NOTOWNED(_x) KKASSERT(lockstatus((_x)->xroot->xfer_lock, curthread) == 0)
 
 /* helper for converting pointers to integers */
 #define        USB_P2U(ptr) \
index 09ce6e2..84b4076 100644 (file)
@@ -127,23 +127,21 @@ static usb_fifo_ioctl_t usb_fifo_dummy_ioctl;
 static usb_fifo_cmd_t usb_fifo_dummy_cmd;
 
 /* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */
-struct dev_ops usb_devsw = {
-/*     .d_version = D_VERSION, */
-    { "usbdev", 0, D_MEM },
+struct dev_ops usb_ops = {
+       { "usbdev", 0, D_MEM },
        .d_open = usb_open,
-    .d_close = usb_close,
-    .d_ioctl = usb_ioctl,
+       .d_close = usb_close,
+       .d_ioctl = usb_ioctl,
        .d_read = usb_read,
        .d_write = usb_write,
-    .d_kqfilter = usb_kqfilter
+       .d_kqfilter = usb_kqfilter
 };
 
 static struct cdev* usb_dev = NULL;
 
 /* character device structure used for /bus/u4b */
-static struct dev_ops usb_static_devsw = {
-    { "usb", 0, D_MEM },
-/*     .d_version = D_VERSION, */
+static struct dev_ops usb_static_ops = {
+       { "usb", 0, D_MEM },
        .d_ioctl = usb_static_ioctl,
 };
 
@@ -190,7 +188,7 @@ usb_ref_device(struct usb_cdev_privdata *cpd,
        /* clear all refs */
        memset(crd, 0, sizeof(*crd));
 
-    lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+       lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
        cpd->bus = devclass_get_softc(usb_devclass_ptr, cpd->bus_index);
        if (cpd->bus == NULL) {
                DPRINTFN(2, "no bus at %u\n", cpd->bus_index);
@@ -217,7 +215,7 @@ usb_ref_device(struct usb_cdev_privdata *cpd,
                 */
                usbd_enum_lock(cpd->udev);
 
-        lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+               lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
 
                /* 
                 * Set "is_uref" after grabbing the default SX lock
@@ -271,7 +269,7 @@ usb_ref_device(struct usb_cdev_privdata *cpd,
                DPRINTFN(2, "ref read\n");
                crd->rxfifo->refcount++;
        }
-    lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+       lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
 
        return (0);
 
@@ -283,7 +281,7 @@ error:
                        cv_signal(&cpd->udev->ref_cv);
                }
        }
-    lockmgr(&usb_ref_lock, LK_RELEASE);
+       lockmgr(&usb_ref_lock, LK_RELEASE);
        DPRINTFN(2, "fail\n");
        return (USB_ERR_INVAL);
 }
@@ -333,7 +331,7 @@ usb_unref_device(struct usb_cdev_privdata *cpd,
        if (crd->is_uref)
                usbd_enum_unlock(cpd->udev);
 
-    lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+       lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
        if (crd->is_read) {
                if (--(crd->rxfifo->refcount) == 0) {
                        cv_signal(&crd->rxfifo->cv_drain);
@@ -352,7 +350,7 @@ usb_unref_device(struct usb_cdev_privdata *cpd,
                }
                crd->is_uref = 0;
        }
-    lockmgr(&usb_ref_lock, LK_RELEASE);
+       lockmgr(&usb_ref_lock, LK_RELEASE);
 }
 
 static struct usb_fifo *
@@ -501,7 +499,7 @@ usb_fifo_create(struct usb_cdev_privdata *cpd,
                f->methods = &usb_ugen_methods;
                f->iface_index = ep->iface_index;
                f->udev = udev;
-        lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+               lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
                udev->fifo[n + USB_FIFO_TX] = f;
                lockmgr(&usb_ref_lock, LK_RELEASE);
        }
@@ -563,7 +561,7 @@ usb_fifo_free(struct usb_fifo *f)
                        f->symlink[n] = NULL;
                }
        }
-    lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+       lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
 
        /* delink ourselves to stop calls from userland */
        if ((f->fifo_index < USB_FIFO_MAX) &&
@@ -580,20 +578,20 @@ usb_fifo_free(struct usb_fifo *f)
        f->flag_iserror = 1;
        /* need to wait until all callers have exited */
        while (f->refcount != 0) {
-        lockmgr(&usb_ref_lock, LK_RELEASE); /* avoid LOR */
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(&usb_ref_lock, LK_RELEASE);     /* avoid LOR */
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                /* get I/O thread out of any sleep state */
                if (f->flag_sleeping) {
                        f->flag_sleeping = 0;
                        cv_broadcast(&f->cv_io);
                }
-        lockmgr(f->priv_lock, LK_RELEASE);
-        lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
 
                /* wait for sync */
                cv_wait(&f->cv_drain, &usb_ref_lock);
        }
-    lockmgr(&usb_ref_lock, LK_RELEASE);
+       lockmgr(&usb_ref_lock, LK_RELEASE);
 
        /* take care of closing the device here, if any */
        usb_fifo_close(f, 0);
@@ -759,7 +757,7 @@ usb_fifo_close(struct usb_fifo *f, int fflags)
 
        /* check if we are selected */
        if (f->flag_isselect) {
-#ifdef XXXDF
+#if 0 /* XXXDF */
                selwakeup(&f->selinfo);
 #endif
                f->flag_isselect = 0;
@@ -767,7 +765,7 @@ usb_fifo_close(struct usb_fifo *f, int fflags)
        /* check if a thread wants SIGIO */
        if (f->async_p != NULL && lwkt_trytoken(&f->async_p->p_token)) {
                ksignal(f->async_p, SIGIO);
-        lwkt_reltoken(&f->async_p->p_token);
+               lwkt_reltoken(&f->async_p->p_token);
                f->async_p = NULL;
        }
        /* remove FWRITE and FREAD flags */
@@ -834,11 +832,9 @@ usb_fifo_close(struct usb_fifo *f, int fflags)
  *------------------------------------------------------------------------*/
 static int
 usb_open(struct dev_open_args *ap)
-/*struct cdev *dev, int fflags, int devtype, struct thread *td)
-*/
 {
-    struct cdev *dev = ap->a_head.a_dev;
-    int fflags = ap->a_oflags;
+       struct cdev *dev = ap->a_head.a_dev;
+       int fflags = ap->a_oflags;
        struct usb_fs_privdata* pd = (struct usb_fs_privdata*)dev->si_drv1;
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata *cpd;
@@ -896,10 +892,10 @@ usb_open(struct dev_open_args *ap)
                }
        }
        usb_unref_device(cpd, &refs);
-    /* XXX: markusp: which privs? 
+#if 0 /* XXX: markusp: which privs? */
        devfs_set_cdevpriv(cpd, usb_close);
-    */
-    /* XXX: This might not work as I expect! */
+#endif
+       /* XXX: This might not work as I expect! */
        dev->si_drv2 = (void *)cpd;
        return (0);
 }
@@ -910,7 +906,7 @@ usb_open(struct dev_open_args *ap)
 static int
 usb_close(struct dev_close_args *ap)
 {
-    struct cdev *dev = ap->a_head.a_dev;
+       struct cdev *dev = ap->a_head.a_dev;
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata *cpd = (struct usb_cdev_privdata *)dev->si_drv2;
        int err;
@@ -944,14 +940,14 @@ usb_close(struct dev_close_args *ap)
        usb_unref_device(cpd, &refs);
 done:
        kfree(cpd, M_USBDEV);
-    return 0;
+       return 0;
 }
 
 static void
 usb_dev_init(void *arg)
 {
        lockinit(&usb_ref_lock, "USB ref mutex", 0, 0);
-    lockinit(&usb_sym_lock, "USB sym mutex", 0, 0);
+       lockinit(&usb_sym_lock, "USB sym mutex", 0, 0);
        TAILQ_INIT(&usb_sym_head);
 
        /* check the UGEN methods */
@@ -965,10 +961,10 @@ static void
 usb_dev_init_post(void *arg)
 {
        /*
-        * Create /bus/u4b - this is needed for usbconfig(8), which
+        * Create /dev/usb - this is needed for usbconfig(8), which
         * needs a well-known device name to access.
         */
-       usb_dev = make_dev(&usb_static_devsw, 0, UID_ROOT, GID_OPERATOR,
+       usb_dev = make_dev(&usb_static_ops, 0, UID_ROOT, GID_OPERATOR,
            0644, USB_DEVICE_NAME);
        if (usb_dev == NULL) {
                DPRINTFN(0, "Could not create usb bus device\n");
@@ -991,7 +987,8 @@ usb_dev_uninit(void *arg)
 SYSUNINIT(usb_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_dev_uninit, NULL);
 
 static int
-usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, struct thread *td)
+usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr,
+    struct thread *td)
 {
        int error = 0;
 
@@ -1039,14 +1036,12 @@ usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, struct thread *td)
  *------------------------------------------------------------------------*/
 static int
 usb_ioctl(struct dev_ioctl_args *ap)
-/*usb_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td)
-*/
 {
-    struct cdev *dev = ap->a_head.a_dev;
-    u_long cmd = ap->a_cmd;
-    caddr_t addr = ap->a_data;
-    /* XXX: What is this thread and where is it supposed to come from */
-    struct thread *td = curthread;
+       struct cdev *dev = ap->a_head.a_dev;
+       u_long cmd = ap->a_cmd;
+       caddr_t addr = ap->a_data;
+       /* XXX: What is this thread and where is it supposed to come from */
+       struct thread *td = curthread;
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata* cpd;
        struct usb_fifo *f;
@@ -1055,18 +1050,21 @@ usb_ioctl(struct dev_ioctl_args *ap)
 
        DPRINTFN(2, "cmd=0x%lx\n", cmd);
 
-    /* XXX: cdev?
+#if 0 /* XXX: cdev? */
        err = devfs_get_cdevpriv((void **)&cpd);
        if (err != 0)
                return (err);
-    */
-    /* XXX: This might not work as I would like it to
-     * also I need a proper return value if it does */
-    if(dev->si_drv2 == NULL)
-        return(-1);
-    
-    cpd = (struct usb_cdev_privdata *)dev->si_drv2;
-    
+#endif
+
+       /*
+        * XXX: This might not work as I would like it to
+        * also I need a proper return value if it does
+        */
+       if(dev->si_drv2 == NULL)
+               return(-1);
+
+       cpd = (struct usb_cdev_privdata *)dev->si_drv2;
+
        /* 
         * Performance optimisation: We try to check for IOCTL's that
         * don't need the USB reference first. Then we grab the USB
@@ -1134,21 +1132,18 @@ done:
        return (err);
 }
 
-
 static int
 usb_kqfilter(struct dev_kqfilter_args *ap)
 {
-    usb_close(NULL);
-    return 0;
+       usb_close(NULL);
+       return 0;
 }
 
-/* XXX implement using kqfilter */
-#if XXXDF
+#if 0 /* XXX implement using kqfilter */
 /* ARGSUSED */
 static int
 usb_poll(struct cdev* dev, int events, struct thread* td)
 {
-
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata* cpd;
        struct usb_fifo *f;
@@ -1251,13 +1246,13 @@ usb_poll(struct cdev* dev, int events, struct thread* td)
        return (revents);
 }
 #endif
+
 static int
-/*usb_read(struct cdev *dev, struct uio *uio, int ioflag)*/
 usb_read(struct dev_read_args *ap)
 {
-    struct cdev *dev = ap->a_head.a_dev;
-    struct uio *uio = ap->a_uio;
-    int ioflag = ap->a_ioflag;
+       struct cdev *dev = ap->a_head.a_dev;
+       struct uio *uio = ap->a_uio;
+       int ioflag = ap->a_ioflag;
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata* cpd;
        struct usb_fifo *f;
@@ -1268,16 +1263,16 @@ usb_read(struct dev_read_args *ap)
        int err;
        uint8_t tr_data = 0;
 
-    /*
+#if 0
        err = devfs_get_cdevpriv((void **)&cpd);
        if (err != 0)
                return (err);
-    */
+#endif
 
-    if(dev->si_drv2 == NULL)
-        return(-1);
+       if(dev->si_drv2 == NULL)
+               return(-1);
     
-    cpd = (struct usb_cdev_privdata *)dev->si_drv2;
+       cpd = (struct usb_cdev_privdata *)dev->si_drv2;
   
        err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
        if (err) {
@@ -1386,12 +1381,11 @@ done:
 }
 
 static int
-/* usb_write(struct cdev *dev, struct uio *uio, int ioflag) */
 usb_write(struct dev_write_args *ap)
 {
-    struct cdev *dev = ap->a_head.a_dev;
-    struct uio *uio = ap->a_uio;
-    int ioflag = ap->a_ioflag;
+       struct cdev *dev = ap->a_head.a_dev;
+       struct uio *uio = ap->a_uio;
+       int ioflag = ap->a_ioflag;
        struct usb_cdev_refdata refs;
        struct usb_cdev_privdata* cpd;
        struct usb_fifo *f;
@@ -1405,15 +1399,16 @@ usb_write(struct dev_write_args *ap)
 
        DPRINTFN(2, "\n");
 
-#ifdef XXXDF
+#if 0 /* XXXDF */
        err = devfs_get_cdevpriv((void **)&cpd);
        if (err != 0)
                return (err);
 #endif
-    if(dev->si_drv2 == NULL)
-        return(-1);
+
+       if(dev->si_drv2 == NULL)
+               return(-1);
     
-    cpd = (struct usb_cdev_privdata *)dev->si_drv2;
+       cpd = (struct usb_cdev_privdata *)dev->si_drv2;
   
        err = usb_ref_device(cpd, &refs, 0 /* no uref */ );
        if (err) {
@@ -1538,18 +1533,15 @@ done:
 
 int
 usb_static_ioctl(struct dev_ioctl_args *ap)
-/*
-usb_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
-    struct thread *td)
-*/
 {
-    u_long cmd = ap->a_cmd;
-    caddr_t data = ap->a_data;
-    /* XXX: what is this thread descriptor and where is it
-     * supposed to come  from? 
-     */
-    struct thread *td = NULL;
-    int fflag = ap->a_fflag;
+       u_long cmd = ap->a_cmd;
+       caddr_t data = ap->a_data;
+       /*
+        * XXX: what is this thread descriptor and where is it
+        * supposed to come from? 
+        */
+       struct thread *td = NULL;
+       int fflag = ap->a_fflag;
        union {
                struct usb_read_dir *urd;
                void* data;
@@ -1641,14 +1633,14 @@ usb_fifo_wakeup(struct usb_fifo *f)
        usb_fifo_signal(f);
 
        if (f->flag_isselect) {
-#ifdef XXXDF
+#if 0 /* XXXDF */
                selwakeup(&f->selinfo);
 #endif
                f->flag_isselect = 0;
        }
        if (f->async_p != NULL && lwkt_trytoken(&f->async_p->p_token)) {
                ksignal(f->async_p, SIGIO);
-        lwkt_reltoken(&f->async_p->p_token);
+               lwkt_reltoken(&f->async_p->p_token);
        }
 }
 
index 5ab1095..4d507f2 100644 (file)
@@ -28,7 +28,6 @@
 #define        _USB_DEV_H_
 
 #include <sys/file.h>
-//#include <sys/selinfo.h>
 #include <sys/poll.h>
 #include <sys/signalvar.h>
 #include <sys/proc.h>
@@ -102,7 +101,7 @@ struct usb_fs_privdata {
 struct usb_fifo {
        struct usb_ifqueue free_q;
        struct usb_ifqueue used_q;
-#ifdef XXXDF
+#if 0 /* XXXDF */
        struct selinfo selinfo;
 #endif
        struct cv cv_io;
@@ -143,7 +142,7 @@ struct usb_fifo {
 #define        USB_FIFO_REF_MAX 0xFF
 };
 
-extern struct dev_ops usb_devsw;
+extern struct dev_ops usb_ops;
 
 int    usb_fifo_wait(struct usb_fifo *fifo);
 void   usb_fifo_signal(struct usb_fifo *fifo);
index 1d74dfc..df91771 100644 (file)
@@ -681,6 +681,7 @@ usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
 
        if (cmd == USB_CFG_INIT) {
                KKASSERT(lockstatus(&udev->enum_lock, curthread) == LK_EXCLUSIVE);
+
                /* check for in-use endpoints */
 
                ep = udev->endpoints;
@@ -1099,9 +1100,9 @@ usb_detach_device(struct usb_device *udev, uint8_t iface_index,
        }
        DPRINTFN(4, "udev=%p\n", udev);
 
-       /*
-     *  sx_assert(&udev->enum_sx, SA_LOCKED);
-     */
+#if 0
+       sx_assert(&udev->enum_sx, SA_LOCKED);
+#endif
 
        /*
         * First detach the child to give the child's detach routine a
@@ -1425,9 +1426,9 @@ usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
        }
        DPRINTFN(4, "udev=%p do_suspend=%d\n", udev, do_suspend);
 
-       /*
-     *  sx_assert(&udev->sr_sx, SA_LOCKED);
-    */
+#if 0
+       sx_assert(&udev->sr_sx, SA_LOCKED);
+#endif
 
        USB_BUS_LOCK(udev->bus);
        /* filter the suspend events */
@@ -1537,16 +1538,19 @@ usb_alloc_device(device_t parent_dev, struct usb_bus *bus,
        if (udev == NULL) {
                return (NULL);
        }
+#if 0
        /* initialise our SX-lock */
-       /* sx_init_flags(&udev->ctrl_sx, "USB device SX lock", SX_DUPOK); */
-    lockinit(&udev->ctrl_lock, "USB device SX lock", 0, 0);
+       sx_init_flags(&udev->ctrl_sx, "USB device SX lock", SX_DUPOK);
+#endif
+       lockinit(&udev->ctrl_lock, "USB device SX lock", 0, 0);
 
+#if 0
        /* initialise our SX-lock */
-       /* sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK);
+       sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK);
        sx_init_flags(&udev->sr_sx, "USB suspend and resume SX lock", SX_NOWITNESS);
-    */
-    lockinit(&udev->enum_lock, "USB config SX lock", 0, 0);
-    lockinit(&udev->sr_lock, "USB suspend and resume SX lock", 0, 0);
+#endif
+       lockinit(&udev->enum_lock, "USB config SX lock", 0, 0);
+       lockinit(&udev->sr_lock, "USB suspend and resume SX lock", 0, 0);
 
        cv_init(&udev->ctrlreq_cv, "WCTRL");
        cv_init(&udev->ref_cv, "UGONE");
@@ -1928,7 +1932,7 @@ usb_make_dev(struct usb_device *udev, const char *devname, int ep,
                    pd->bus_index, pd->dev_index, pd->ep_addr);
        }
 
-       pd->cdev = make_dev(&usb_devsw, 0, uid, gid, mode, "%s", devname);
+       pd->cdev = make_dev(&usb_ops, 0, uid, gid, mode, "%s", devname);
 
        if (pd->cdev == NULL) {
                DPRINTFN(0, "Failed to create device %s\n", devname);
@@ -2440,9 +2444,11 @@ usbd_get_device_index(struct usb_device *udev)
 static void
 usb_notify_addq(const char *type, struct usb_device *udev)
 {
+#if 0
        struct usb_interface *iface;
-       struct sbuf *sb;
        int i;
+#endif
+       struct sbuf *sb;
 
        /* announce the device */
        sb = sbuf_new(NULL, NULL, 4096, SBUF_AUTOEXTEND);
@@ -2485,17 +2491,17 @@ usb_notify_addq(const char *type, struct usb_device *udev)
        devctl_notify("USB", "DEVICE", type, sbuf_data(sb));
        sbuf_delete(sb);
 
+#if 0
        /* announce each interface */
        for (i = 0; i < USB_IFACE_MAX; i++) {
-        break;
-        iface = usbd_get_iface(udev, i);
+               iface = usbd_get_iface(udev, i);
                if (iface == NULL)
                        break;          /* end of interfaces */
                if (iface->idesc == NULL)
                        continue;       /* no interface descriptor */
                
-        sb = 0;
-        sb = sbuf_new(NULL, NULL, 4096, SBUF_AUTOEXTEND);
+               sb = 0;
+               sb = sbuf_new(NULL, NULL, 4096, SBUF_AUTOEXTEND);
                sbuf_printf(sb,
 #if USB_HAVE_UGEN
                    "ugen=%s "
@@ -2533,6 +2539,7 @@ usb_notify_addq(const char *type, struct usb_device *udev)
                devctl_notify("USB", "INTERFACE", type, sbuf_data(sb));
                sbuf_delete(sb);
        }
+#endif
 }
 #endif
 
@@ -2648,14 +2655,16 @@ usbd_device_attached(struct usb_device *udev)
 void
 usbd_enum_lock(struct usb_device *udev)
 {
-    lockmgr(&udev->enum_lock, LK_EXCLUSIVE);
-    lockmgr(&udev->sr_lock, LK_EXCLUSIVE);
+       lockmgr(&udev->enum_lock, LK_EXCLUSIVE);
+       lockmgr(&udev->sr_lock, LK_EXCLUSIVE);
        /* 
         * NEWBUS LOCK NOTE: We should check if any parent SX locks
         * are locked before locking Giant. Else the lock can be
         * locked multiple times.
         */
-       /* mtx_lock(&Giant); */
+#if 0
+       mtx_lock(&Giant);
+#endif
 }
 
 /* The following function unlocks enumerating the given USB device. */
@@ -2663,11 +2672,11 @@ usbd_enum_lock(struct usb_device *udev)
 void
 usbd_enum_unlock(struct usb_device *udev)
 {
-       /* mtx_unlock(&Giant); */
-       /* sx_xunlock(&udev->enum_sx);
-       sx_xunlock(&udev->sr_sx); */
-    lockmgr(&udev->enum_lock, LK_RELEASE);
-    lockmgr(&udev->sr_lock, LK_RELEASE);
+#if 0
+       mtx_unlock(&Giant);
+#endif
+       lockmgr(&udev->enum_lock, LK_RELEASE);
+       lockmgr(&udev->sr_lock, LK_RELEASE);
 }
 
 /* The following function locks suspend and resume. */
@@ -2675,13 +2684,15 @@ usbd_enum_unlock(struct usb_device *udev)
 void
 usbd_sr_lock(struct usb_device *udev)
 {
-    lockmgr(&udev->sr_lock, LK_EXCLUSIVE);
+       lockmgr(&udev->sr_lock, LK_EXCLUSIVE);
        /* 
         * NEWBUS LOCK NOTE: We should check if any parent SX locks
         * are locked before locking Giant. Else the lock can be
         * locked multiple times.
         */
-       /* mtx_lock(&Giant); */
+#if 0
+       mtx_lock(&Giant);
+#endif
 }
 
 /* The following function unlocks suspend and resume. */
@@ -2689,9 +2700,10 @@ usbd_sr_lock(struct usb_device *udev)
 void
 usbd_sr_unlock(struct usb_device *udev)
 {
-/*     mtx_unlock(&Giant);*/
-/*     sx_xunlock(&udev->sr_sx);*/
-    lockmgr(&udev->sr_lock, LK_RELEASE);
+#if 0
+       mtx_unlock(&Giant);
+#endif
+       lockmgr(&udev->sr_lock, LK_RELEASE);
 }
 
 /*
@@ -2702,7 +2714,7 @@ usbd_sr_unlock(struct usb_device *udev)
 uint8_t
 usbd_enum_is_locked(struct usb_device *udev)
 {
-    /* XXX: Make sure that we return a correct value here */
+       /* XXX: Make sure that we return a correct value here */
        return (lockstatus(&udev->enum_lock, curthread) == LK_EXCLUSIVE);
 }
 
index 2b699bc..e9872bc 100644 (file)
@@ -118,12 +118,7 @@ struct usb_device {
        struct lock enum_lock;
        struct lock sr_lock;
        struct lock mtx_lock;
-    struct lock device_lock;
-
-/*     struct sx ctrl_sx;
-       struct sx enum_sx;
-       struct sx sr_sx; 
-       struct mtx device_mtx; */
+       struct lock device_lock;
        struct cv ctrlreq_cv;
        struct cv ref_cv;
        struct usb_interface *ifaces;
index 1649188..35b3bde 100644 (file)
@@ -111,9 +111,8 @@ usb_quirk_unload(void *arg)
        /* wait for CPU to exit the loaded functions, if any */
 
        /* XXX this is a tradeoff */
-    /* XXX tsleep? */
-    tsleep(usb_quirk_unload, 0, "WAIT", hz);
-       /* pause("WAIT", hz); */
+
+       tsleep(usb_quirk_unload, 0, "WAIT", hz);
 }
 
 void
@@ -128,10 +127,8 @@ usb_temp_unload(void *arg)
        /* wait for CPU to exit the loaded functions, if any */
 
        /* XXX this is a tradeoff */
-    /* XXX tsleep? */
-       /* pause("WAIT", hz); */
 
-    tsleep(usb_quirk_unload, 0, "WAIT", hz);
+       tsleep(usb_quirk_unload, 0, "WAIT", hz);
 }
 
 void
@@ -145,6 +142,5 @@ usb_bus_unload(void *arg)
 
        /* XXX this is a tradeoff */
 
-   /*  pause("WAIT", hz); */
-    tsleep(usb_quirk_unload, 0, "WAIT", hz);
+       tsleep(usb_quirk_unload, 0, "WAIT", hz);
 }
index fe8c0be..8a53ad7 100644 (file)
 #define        USB_HAVE_UGEN 1
 #define        USB_HAVE_DEVCTL 1
 #define        USB_HAVE_BUSDMA 1
-/* XXX
+#if 0
 #define        USB_HAVE_COMPAT_LINUX 1
-*/
+#endif
 #define        USB_HAVE_USER_IO 1
 #define        USB_HAVE_MBUF 1
 #define        USB_HAVE_TT_SUPPORT 1
 #define        USB_HAVE_POWERD 1
 #define        USB_HAVE_MSCTEST 1
-/* XXX
+#if 0
 #define        USB_HAVE_PF 1
-*/
+#endif
 
 #define        USB_TD_GET_PROC(td) (td)->td_proc
 #define        USB_PROC_GET_GID(td) (td)->p_pgid
index a365ef7..5b3e052 100644 (file)
@@ -143,7 +143,7 @@ ugen_transfer_setup(struct usb_fifo *f,
        uint8_t iface_index = ep->iface_index;
        int error;
 
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
 
        /*
         * "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
@@ -165,7 +165,7 @@ ugen_transfer_setup(struct usb_fifo *f,
                        usbd_transfer_unsetup(f->xfer, n_setup);
                }
        }
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
 
        return (error);
 }
@@ -179,7 +179,7 @@ ugen_open(struct usb_fifo *f, int fflags)
 
        DPRINTFN(6, "flag=0x%x\n", fflags);
 
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
        switch (usbd_get_speed(f->udev)) {
        case USB_SPEED_LOW:
        case USB_SPEED_FULL:
@@ -199,7 +199,7 @@ ugen_open(struct usb_fifo *f, int fflags)
        f->timeout = USB_NO_TIMEOUT;
        f->flag_short = 0;
        f->fifo_zlp = 0;
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
 
        return (0);
 }
@@ -211,10 +211,10 @@ ugen_close(struct usb_fifo *f, int fflags)
 
        /* cleanup */
 
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
        usbd_transfer_stop(f->xfer[0]);
        usbd_transfer_stop(f->xfer[1]);
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
 
        usbd_transfer_unsetup(f->xfer, 2);
        usb_fifo_free_buffer(f);
@@ -232,7 +232,7 @@ ugen_open_pipe_write(struct usb_fifo *f)
        struct usb_endpoint *ep = usb_fifo_softc(f);
        struct usb_endpoint_descriptor *ed = ep->edesc;
 
-    KKASSERT(lockstatus(f->priv_lock, curthread) != 0);
+       KKASSERT(lockstatus(f->priv_lock, curthread) != 0);
 
        if (f->xfer[0] || f->xfer[1]) {
                /* transfers are already opened */
@@ -300,7 +300,7 @@ ugen_open_pipe_read(struct usb_fifo *f)
        struct usb_endpoint *ep = usb_fifo_softc(f);
        struct usb_endpoint_descriptor *ed = ep->edesc;
 
-    KKASSERT(lockstatus(f->priv_lock, curthread) != 0);
+       KKASSERT(lockstatus(f->priv_lock, curthread) != 0);
 
        if (f->xfer[0] || f->xfer[1]) {
                /* transfers are already opened */
@@ -1052,12 +1052,12 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
        if (xfer == NULL) {
                return (EINVAL);
        }
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
        if (usbd_transfer_pending(xfer)) {
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
                return (EBUSY);         /* should not happen */
        }
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
 
        error = copyin(f->fs_ep_ptr +
            ep_index, &fs_ep, sizeof(fs_ep));
@@ -1200,9 +1200,9 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
        return (error);
 
 complete:
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
        ugen_fs_set_complete(f, ep_index);
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
        return (0);
 }
 
@@ -1229,13 +1229,13 @@ ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
        xfer = f->fs_xfer[ep_index];
        if (xfer == NULL)
                return (EINVAL);
-    
-    lockmgr(f->priv_lock, LK_EXCLUSIVE);
+
+       lockmgr(f->priv_lock, LK_EXCLUSIVE);
        if (usbd_transfer_pending(xfer)) {
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
                return (EBUSY);         /* should not happen */
        }
-    lockmgr(f->priv_lock, LK_RELEASE);
+       lockmgr(f->priv_lock, LK_RELEASE);
 
        fs_ep_uptr = f->fs_ep_ptr + ep_index;
        error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
@@ -1408,9 +1408,9 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
 
        switch (cmd) {
        case USB_FS_COMPLETE:
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                error = ugen_fs_get_complete(f, &ep_index);
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
 
                if (error) {
                        error = EBUSY;
@@ -1424,10 +1424,10 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
                error = ugen_fs_copy_in(f, u.pstart->ep_index);
                if (error)
                        break;
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                xfer = f->fs_xfer[u.pstart->ep_index];
                usbd_transfer_start(xfer);
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
                break;
 
        case USB_FS_STOP:
@@ -1435,7 +1435,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
                        error = EINVAL;
                        break;
                }
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                xfer = f->fs_xfer[u.pstart->ep_index];
                if (usbd_transfer_pending(xfer)) {
                        usbd_transfer_stop(xfer);
@@ -1449,7 +1449,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
                                    USB_P2U(xfer->priv_fifo));
                        }
                }
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
                break;
 
        case USB_FS_OPEN:
@@ -1576,9 +1576,9 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
                        error = EINVAL;
                        break;
                }
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
 
                if (error) {
                        return (EBUSY);
@@ -2235,9 +2235,9 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
                break;
 
        default:
-        lockmgr(f->priv_lock, LK_EXCLUSIVE);
+               lockmgr(f->priv_lock, LK_EXCLUSIVE);
                error = ugen_iface_ioctl(f, cmd, addr, fflags);
-        lockmgr(f->priv_lock, LK_RELEASE);
+               lockmgr(f->priv_lock, LK_RELEASE);
                break;
        }
        DPRINTFN(6, "error=%d\n", error);
index 40fb5ce..85c98ce 100644 (file)
@@ -1,8 +1,6 @@
 /*     $NetBSD: hid.c,v 1.17 2001/11/13 06:24:53 lukem Exp $   */
 
 
-#include <sys/cdefs.h>
-// __FBSDID("$FreeBSD$");
 /*-
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
index 82e5955..7b08a35 100644 (file)
@@ -921,7 +921,6 @@ uhub_attach(device_t dev)
 
        lockinit(&sc->sc_lock, "USB HUB mutex", 0, 0);
 
-
        ksnprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
            device_get_nameunit(dev));
 
@@ -1311,9 +1310,9 @@ uhub_child_location_string(device_t parent, device_t child,
        sc = device_get_softc(parent);
        hub = sc->sc_udev->hub;
 
-       /* XXX 
-     * mtx_lock(&Giant);
-     */
+#if 0
+       mtx_lock(&Giant);
+#endif
        uhub_find_iface_index(hub, child, &res);
        if (!res.udev) {
                DPRINTF("device not on hub\n");
@@ -1327,9 +1326,9 @@ uhub_child_location_string(device_t parent, device_t child,
            res.portno, device_get_unit(res.udev->bus->bdev),
            res.udev->device_index, res.iface_index);
 done:
-       /* XXX
-     * mtx_unlock(&Giant);
-     */
+#if 0
+       mtx_unlock(&Giant);
+#endif
 
        return (0);
 }
@@ -1352,9 +1351,9 @@ uhub_child_pnpinfo_string(device_t parent, device_t child,
        sc = device_get_softc(parent);
        hub = sc->sc_udev->hub;
 
-    /* XXX
+#if 0
        mtx_lock(&Giant);
-    */
+#endif
        uhub_find_iface_index(hub, child, &res);
        if (!res.udev) {
                DPRINTF("device not on hub\n");
@@ -1391,9 +1390,10 @@ uhub_child_pnpinfo_string(device_t parent, device_t child,
                goto done;
        }
 done:
-    /* XXX
+#if 0
        mtx_unlock(&Giant);
-    */
+#endif
+
        return (0);
 }
 
@@ -1490,8 +1490,9 @@ usb_hs_bandwidth_adjust(struct usb_device *udev, int16_t len,
        struct usb_hub *hub;
        enum usb_dev_speed speed;
        uint8_t x;
-    
+
        USB_BUS_LOCK_ASSERT(bus);
+
        speed = usbd_get_speed(udev);
 
        switch (speed) {
index c74c79e..43e39eb 100644 (file)
@@ -541,7 +541,6 @@ bbb_attach(struct usb_device *udev, uint8_t iface_index)
 
        sc = kmalloc(sizeof(*sc), M_USB, M_WAITOK | M_ZERO);
        lockinit(&sc->lock, "USB autoinstall", 0, 0);
-
        cv_init(&sc->cv, "WBBB");
 
        err = usbd_transfer_setup(udev, &iface_index, sc->xfer, bbb_config,
index 3a3840d..b5df813 100644 (file)
@@ -32,8 +32,6 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
-//__FBSDID("$FreeBSD$");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
index 5c5d382..2ca2d16 100644 (file)
@@ -54,7 +54,6 @@
 #include <sys/kthread.h>
 #include <sys/sched.h>
 
-
 static int usb_pcount;
 #define        USB_THREAD_CREATE(f, s, p, ...) \
                kthread_create((f), (s), (p), __VA_ARGS__)
@@ -84,14 +83,14 @@ usb_process(void *arg)
        struct usb_proc_msg *pm;
        struct thread *td;
 
+#if 0 /* XXX Suspend here? */
        /* in case of attach error, check for suspended */
-       /* XXX Suspend here?
-    *  USB_THREAD_SUSPEND_CHECK();
-    */
+       USB_THREAD_SUSPEND_CHECK();
+#endif
 
        /* adjust priority */
-    td = curthread;
-    lwkt_setpri(td, up->up_prio);
+       td = curthread;
+       lwkt_setpri(td, up->up_prio);
        lockmgr(up->up_lock, LK_EXCLUSIVE);
 
        up->up_curtd = td;
@@ -173,11 +172,12 @@ usb_process(void *arg)
        up->up_ptr = NULL;
        cv_signal(&up->up_cv);
        lockmgr(up->up_lock, LK_RELEASE);
+#if 0
        /* Clear the proc pointer if this is the last thread. */
-/*
        if (--usb_pcount == 0)
                usbproc = NULL;
-*/
+#endif
+
        USB_THREAD_EXIT(0);
 }
 
@@ -198,8 +198,6 @@ int
 usb_proc_create(struct usb_process *up, struct lock *p_lock,
     const char *pmesg, uint8_t prio)
 {
-    kprintf("Creating usb_proc: %s\n", pmesg);
-
        up->up_lock = p_lock;
        up->up_prio = prio;
 
@@ -271,7 +269,7 @@ usb_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1)
        if (up->up_gone)
                return (_pm0);
 
-    KKASSERT(lockstatus(up->up_lock, curthread) != 0);
+       KKASSERT(lockstatus(up->up_lock, curthread) != 0);
 
        t = 0;
 
@@ -352,8 +350,7 @@ usb_proc_is_gone(struct usb_process *up)
         * structure is initialised.
         */
        if (up->up_lock != NULL)
-        KKASSERT(lockstatus(up->up_lock, curthread)!=0);
-
+               KKASSERT(lockstatus(up->up_lock, curthread)!=0);
        return (0);
 }
 
@@ -374,7 +371,7 @@ usb_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1)
        if (up->up_gone)
                return;
 
-    KKASSERT(lockstatus(up->up_lock, curthread) != 0);
+       KKASSERT(lockstatus(up->up_lock, curthread) != 0);
 
        if (up->up_curtd == curthread) {
                /* Just remove the messages from the queue. */
@@ -412,13 +409,14 @@ usb_proc_drain(struct usb_process *up)
        /* check if not initialised */
        if (up->up_lock == NULL)
                return;
+#if 0 /* XXX */
        /* handle special case with Giant */
-    /* XXX
        if (up->up_mtx != &Giant)
                mtx_assert(up->up_mtx, MA_NOTOWNED);
-    */
-    KKASSERT(lockstatus(up->up_lock, curthread) == 0);
+#else
+       KKASSERT(lockstatus(up->up_lock, curthread) == 0);
        lockmgr(up->up_lock, LK_EXCLUSIVE);
+#endif
 
        /* Set the gone flag */
 
@@ -451,7 +449,7 @@ usb_proc_drain(struct usb_process *up)
                DPRINTF("WARNING: Someone is waiting "
                    "for USB process drain!\n");
        }
-    lockmgr(up->up_lock, LK_RELEASE);
+       lockmgr(up->up_lock, LK_RELEASE);
 }
 
 /*------------------------------------------------------------------------*
@@ -471,6 +469,7 @@ usb_proc_rewakeup(struct usb_process *up)
        /* check if gone */
        if (up->up_gone)
                return;
+
        KKASSERT(lockstatus(up->up_lock, curthread) != 0);
 
        if (up->up_msleep == 0) {
index 03ae242..7db6af6 100644 (file)
 #include <sys/interrupt.h>
 #include <sys/signalvar.h>
 #include <sys/thread.h>
-//#include <sys/priority.h>
-//#include <sys/runq.h>
 
 /* defines */
 #define        USB_PRI_HIGH    TDPRI_INT_HIGH
-#define        USB_PRI_MED TDPRI_INT_MED
+#define        USB_PRI_MED     TDPRI_INT_MED
 
 #define        USB_PROC_WAIT_TIMEOUT 2
 #define        USB_PROC_WAIT_DRAIN   1
index 8448100..352053b 100644 (file)
@@ -38,7 +38,6 @@
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/sysctl.h>
-//#include <sys/sx.h>
 #include <sys/unistd.h>
 #include <sys/callout.h>
 #include <sys/malloc.h>
@@ -453,12 +452,12 @@ usbd_do_request_flags(struct usb_device *udev, struct lock *lock,
        if (flags & USB_USER_DATA_PTR)
                return (USB_ERR_INVAL);
 #endif
-    /*
+#if 0
        if ((mtx != NULL) && (mtx != &Giant)) {
-    */
-    if (lock != NULL) {
+#endif
+       if (lock != NULL) {
                lockmgr(lock, LK_RELEASE);
-        KKASSERT(lockstatus(lock, curthread) == 0);
+               KKASSERT(lockstatus(lock, curthread) == 0);
        }
 
        /*
@@ -472,7 +471,7 @@ usbd_do_request_flags(struct usb_device *udev, struct lock *lock,
         * Grab the default sx-lock so that serialisation
         * is achieved when multiple threads are involved:
         */
-    lockmgr(&udev->ctrl_lock, LK_EXCLUSIVE);
+       lockmgr(&udev->ctrl_lock, LK_EXCLUSIVE);
 
        hr_func = usbd_get_hr_func(udev);
 
@@ -716,15 +715,15 @@ usbd_do_request_flags(struct usb_device *udev, struct lock *lock,
        USB_XFER_UNLOCK(xfer);
 
 done:
-    lockmgr(&udev->ctrl_lock, LK_RELEASE);
+       lockmgr(&udev->ctrl_lock, LK_RELEASE);
 
        if (enum_locked)
                usbd_sr_lock(udev);
 
-/*
+#if 0
        if ((mtx != NULL) && (mtx != &Giant))
-*/
-    if (lock != NULL)
+#endif
+       if (lock != NULL)
                lockmgr(lock, LK_EXCLUSIVE);
 
        return ((usb_error_t)err);
index 9b88e38..6c05dfe 100644 (file)
@@ -198,12 +198,13 @@ usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm,
        usb_size_t y;
        usb_size_t r;
        usb_size_t z;
-    
-    /*
+
+#if 0
        USB_ASSERT(align > 1, ("Invalid alignment, 0x%08x\n",
            align));
        USB_ASSERT(size > 0, ("Invalid size = 0\n"));
-    */
+#endif
+
        if (count == 0) {
                return (0);             /* nothing to allocate */
        }
@@ -282,12 +283,12 @@ usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm,
                        pc->buffer = USB_ADD_BYTES(buf, y * size);
                        pc->page_start = pg;
 
-            lockmgr(pc->tag_parent->lock, LK_EXCLUSIVE);
+                       lockmgr(pc->tag_parent->lock, LK_EXCLUSIVE);
                        if (usb_pc_load_mem(pc, size, 1 /* synchronous */ )) {
-                lockmgr(pc->tag_parent->lock, LK_RELEASE);
+                               lockmgr(pc->tag_parent->lock, LK_RELEASE);
                                return (1);     /* failure */
                        }
-            lockmgr(pc->tag_parent->lock, LK_RELEASE);
+                       lockmgr(pc->tag_parent->lock, LK_RELEASE);
                }
        }
 
@@ -824,10 +825,11 @@ usbd_transfer_setup(struct usb_device *udev,
        refcount = 0;
        info = NULL;
 
-    /*   
+#if 0
        WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
            "usbd_transfer_setup can sleep!");
-    */
+#endif
+
        /* do some checking first */
 
        if (n_setup == 0) {
@@ -1215,10 +1217,10 @@ usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
        struct usb_xfer_root *info;
        uint8_t needs_delay = 0;
 
-    /*
+#if 0
        WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
            "usbd_transfer_unsetup can sleep!");
-    */
+#endif
 
        while (n_setup--) {
                xfer = pxfer[n_setup];
@@ -1269,10 +1271,12 @@ usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
                usb_callout_drain(&xfer->timeout_handle);
 
                USB_BUS_LOCK(info->bus);
-        /*
+
+#if 0
                USB_ASSERT(info->setup_refcount != 0, ("Invalid setup "
                    "reference count\n"));
-        */
+#endif
+
                info->setup_refcount--;
 
                if (info->setup_refcount == 0) {
@@ -1498,10 +1502,10 @@ usbd_transfer_submit(struct usb_xfer *xfer)
                USB_BUS_UNLOCK(bus);
        }
 #endif
-    
+
        USB_XFER_LOCK_ASSERT(xfer);
        USB_BUS_LOCK_ASSERT_NOTOWNED(bus);
-    
+
        /* Only open the USB transfer once! */
        if (!xfer->flags_int.open) {
                xfer->flags_int.open = 1;
@@ -1671,9 +1675,10 @@ usbd_pipe_enter(struct usb_xfer *xfer)
 {
        struct usb_endpoint *ep;
 
-/*
+#if 0
        USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
-*/
+#endif
+
        USB_BUS_LOCK(xfer->xroot->bus);
 
        ep = xfer->endpoint;
@@ -1712,9 +1717,10 @@ usbd_transfer_start(struct usb_xfer *xfer)
                /* transfer is gone */
                return;
        }
-    /*
+#if 0
        USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
-    */
+#endif
+
        /* mark the USB transfer started */
 
        if (!xfer->flags_int.started) {
@@ -1751,9 +1757,10 @@ usbd_transfer_stop(struct usb_xfer *xfer)
                /* transfer is gone */
                return;
        }
-    /*
+#if 0
        USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
-    */
+#endif
+
        /* check if the USB transfer was ever opened */
 
        if (!xfer->flags_int.open) {
@@ -1844,9 +1851,10 @@ usbd_transfer_pending(struct usb_xfer *xfer)
                /* transfer is gone */
                return (0);
        }
-    /*
+#if 0
        USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
-    */
+#endif
+
        if (xfer->flags_int.transferring) {
                /* trivial case */
                return (1);
@@ -1881,10 +1889,11 @@ usbd_transfer_pending(struct usb_xfer *xfer)
 void
 usbd_transfer_drain(struct usb_xfer *xfer)
 {
-    /*
+#if 0
        WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
            "usbd_transfer_drain can sleep!");
-    */
+#endif
+
        if (xfer == NULL) {
                /* transfer is gone */
                return;
@@ -2091,15 +2100,14 @@ usb_callback_proc(struct usb_proc_msg *_pm)
         * We exploit the fact that the mutex is the same for all
         * callbacks that will be called from this thread:
         */
-    lockmgr(info->xfer_lock, LK_EXCLUSIVE);
+       lockmgr(info->xfer_lock, LK_EXCLUSIVE);
        USB_BUS_LOCK(info->bus);
 
        /* Continue where we lost track */
        usb_command_wrapper(&info->done_q,
            info->done_q.curr);
 
-
-    lockmgr(info->xfer_lock, LK_RELEASE);
+       lockmgr(info->xfer_lock, LK_RELEASE);
 }
 
 /*------------------------------------------------------------------------*
@@ -2114,7 +2122,6 @@ usbd_callback_ss_done_defer(struct usb_xfer *xfer)
        struct usb_xfer_root *info = xfer->xroot;
        struct usb_xfer_queue *pq = &info->done_q;
 
-    
        USB_BUS_LOCK_ASSERT(xfer->xroot->bus);
    
        if (pq->curr != xfer) {
@@ -2152,12 +2159,12 @@ usbd_callback_wrapper(struct usb_xfer_queue *pq)
 {
        struct usb_xfer *xfer = pq->curr;
        struct usb_xfer_root *info = xfer->xroot;
-    
+
        USB_BUS_LOCK_ASSERT(info->bus);
-    /* XXX: This is probably to prevent deadlocks    
+#if 0 /* XXX: This is probably to prevent deadlocks */
        if (!lockstatus(info->xfer_mtx, curthread) && !SCHEDULER_STOPPED()) {
-    */
-    if (!lockstatus(info->xfer_lock, curthread)) {
+#endif
+       if (!lockstatus(info->xfer_lock, curthread)) {
                /*
                 * Cases that end up here:
                 *
@@ -2193,7 +2200,7 @@ usbd_callback_wrapper(struct usb_xfer_queue *pq)
 
        USB_BUS_UNLOCK(info->bus);
        USB_BUS_LOCK_ASSERT_NOTOWNED(info->bus);
-    
+
        /* set correct USB state for callback */
        if (!xfer->flags_int.transferring) {
                xfer->usb_state = USB_ST_SETUP;
@@ -2285,7 +2292,7 @@ void
 usb_dma_delay_done_cb(struct usb_xfer *xfer)
 {
        USB_BUS_LOCK_ASSERT(xfer->xroot->bus);
-    
+
        DPRINTFN(3, "Completed %p\n", xfer);
 
        /* queue callback for execution, again */
@@ -2416,7 +2423,7 @@ usbd_transfer_start_cb(void *arg)
 {
        struct usb_xfer *xfer = arg;
        struct usb_endpoint *ep = xfer->endpoint;
-    
+
        USB_BUS_LOCK_ASSERT(xfer->xroot->bus);
 
        DPRINTF("start\n");
@@ -2450,9 +2457,8 @@ usbd_xfer_set_stall(struct usb_xfer *xfer)
                /* tearing down */
                return;
        }
-    
        USB_XFER_LOCK_ASSERT(xfer);
-    
+
        /* avoid any races by locking the USB mutex */
        USB_BUS_LOCK(xfer->xroot->bus);
        xfer->flags.stall_pipe = 1;
@@ -2478,9 +2484,8 @@ usbd_transfer_clear_stall(struct usb_xfer *xfer)
                /* tearing down */
                return;
        }
-    
        USB_XFER_LOCK_ASSERT(xfer);
-    
+
        /* avoid any races by locking the USB mutex */
        USB_BUS_LOCK(xfer->xroot->bus);
 
@@ -2632,6 +2637,7 @@ usbd_transfer_timeout_ms(struct usb_xfer *xfer,
     void (*cb) (void *arg), usb_timeout_t ms)
 {
        USB_BUS_LOCK_ASSERT(xfer->xroot->bus);
+
        /* defer delay */
        usb_callout_reset(&xfer->timeout_handle,
            USB_MS_TO_TICKS(ms), cb, xfer);
@@ -2966,9 +2972,8 @@ repeat:
 void
 usbd_clear_stall_locked(struct usb_device *udev, struct usb_endpoint *ep)
 {
-    
        USB_BUS_LOCK_ASSERT(udev->bus);
-    
+
        /* check that we have a valid case */
        if (udev->flags.usb_mode == USB_MODE_HOST &&
            udev->parent_hub != NULL &&
@@ -3036,10 +3041,9 @@ usbd_clear_stall_callback(struct usb_xfer *xfer1,
                DPRINTF("NULL input parameter\n");
                return (0);
        }
-    
        USB_XFER_LOCK_ASSERT(xfer1);
        USB_XFER_LOCK_ASSERT(xfer2);
-    
+
        switch (USB_GET_STATE(xfer1)) {
        case USB_ST_SETUP:
 
@@ -3129,9 +3133,9 @@ usbd_transfer_poll(struct usb_xfer **ppxfer, uint16_t max)
 
                /* make sure that the BUS mutex is not locked */
                drop_bus = 0;
-        /* XXX 
+#if 0 /* XXX */
                while (lockstatus(&xroot->udev->bus->bus_lock, curthread) && !SCHEDULER_STOPPED()) {
-        */
+#endif
                while (lockstatus(&xroot->udev->bus->bus_lock, curthread)) {
                        lockmgr(&xroot->udev->bus->bus_lock, LK_RELEASE);
                        drop_bus++;
@@ -3139,11 +3143,11 @@ usbd_transfer_poll(struct usb_xfer **ppxfer, uint16_t max)
 
                /* make sure that the transfer mutex is not locked */
                drop_xfer = 0;
-        /* XXX
+#if 0 /* XXX */
                while (lockstatus(xroot->xfer_lock, curthread) && !SCHEDULER_STOPPED()) {
-        */
+#endif
                while (lockstatus(xroot->xfer_lock, curthread)) {
-            lockmgr(xroot->xfer_lock, LK_RELEASE);
+                       lockmgr(xroot->xfer_lock, LK_RELEASE);
                        drop_xfer++;
                }
 
@@ -3178,11 +3182,11 @@ usbd_transfer_poll(struct usb_xfer **ppxfer, uint16_t max)
 
                /* restore transfer mutex */
                while (drop_xfer--)
-            lockmgr(xroot->xfer_lock, LK_EXCLUSIVE);
+                       lockmgr(xroot->xfer_lock, LK_EXCLUSIVE);
 
                /* restore BUS mutex */
                while (drop_bus--)
-            lockmgr(&xroot->udev->bus->bus_lock, LK_EXCLUSIVE);
+                       lockmgr(&xroot->udev->bus->bus_lock, LK_EXCLUSIVE);
        }
 }
 
index 3e6be55..8c92171 100644 (file)
@@ -124,11 +124,11 @@ usb_pause_mtx(struct lock *lock, int timo)
         * timeout is positive and non-zero!
         */
        if (lock != NULL) {
-        lksleep(&usb_pause_mtx, lock, 0, "USBSLP", timo + 1);
-    } else {
-        KKASSERT(timo + 1 > 0);
-        tsleep(&usb_pause_mtx, PINTERLOCKED, "USBSLP", timo + 1);
-    }
+               lksleep(&usb_pause_mtx, lock, 0, "USBSLP", timo + 1);
+       } else {
+               KKASSERT(timo + 1 > 0);
+               tsleep(&usb_pause_mtx, PINTERLOCKED, "USBSLP", timo + 1);
+       }
 }
 
 /*------------------------------------------------------------------------*
@@ -210,34 +210,37 @@ usb_make_str_desc(void *ptr, uint16_t max_len, const char *s)
 void 
 usb_callout_timeout_wrapper(void *arg)
 {
-    struct usb_callout *uco = (struct usb_callout *)arg;
+       struct usb_callout *uco = (struct usb_callout *)arg;
 
-    KKASSERT(uco != NULL);
+       KKASSERT(uco != NULL);
 
-    /* Simulate FreeBSD's callout behaviour which allows
-     * a lock to be acquired before the function is called
-     */
+       /*
+        * Simulate FreeBSD's callout behaviour which allows
+        * a lock to be acquired before the function is called
+        */
 
-    lockmgr(uco->uco_lock, LK_EXCLUSIVE);
-    uco->uco_func(uco->uco_arg);
-    lockmgr(uco->uco_lock, LK_RELEASE);
-    /* XXX Have to introduce flags and release lock? */
+       lockmgr(uco->uco_lock, LK_EXCLUSIVE);
+       uco->uco_func(uco->uco_arg);
+       lockmgr(uco->uco_lock, LK_RELEASE);
+       /* XXX Have to introduce flags and release lock? */
 }
 
 void 
-usb_callout_init_mtx_dfly(struct usb_callout *uco, struct lock *lock, int flags)
+usb_callout_init_mtx_dfly(struct usb_callout *uco, struct lock *lock,
+    int flags)
 {
-    callout_init(&uco->co);
-    uco->uco_lock = lock;
-    uco->uco_flags = flags;    
+       callout_init(&uco->co);
+       uco->uco_lock = lock;
+       uco->uco_flags = flags;    
 }
 
 void
-usb_callout_reset_dfly(struct usb_callout *uco, int ticks, timeout_t *func, void *arg)
+usb_callout_reset_dfly(struct usb_callout *uco, int ticks, timeout_t *func,
+    void *arg)
 {
-    KKASSERT(uco != NULL);
-    uco->uco_func = func;
-    uco->uco_arg = arg;
+       KKASSERT(uco != NULL);
+       uco->uco_func = func;
+       uco->uco_arg = arg;
 
-    callout_reset(&uco->co, ticks, &usb_callout_timeout_wrapper, uco);
+       callout_reset(&uco->co, ticks, &usb_callout_timeout_wrapper, uco);
 }
index aed02ba..e5b3926 100644 (file)
@@ -387,20 +387,22 @@ struct usb_attach_arg {
  * porting the code to other platforms.
  */
 struct usb_callout {
-       struct callout co; 
-    struct lock *uco_lock;
-    void (*uco_func)(void *);
-    void *uco_arg;
-    int uco_flags;
+       struct callout co;
+       struct lock *uco_lock;
+       void (*uco_func)(void *);
+       void *uco_arg;
+       int uco_flags;
 };
 /* XXX what is supposed to happen with that mutex? */
 
 void usb_callout_timeout_wrapper(void *arg);
-void usb_callout_init_mtx_dfly(struct usb_callout *uco, struct lock *lock, int flags); 
-void usb_callout_reset_dfly(struct usb_callout *uco, int ticks, timeout_t *func, void *arg);    
+void usb_callout_init_mtx_dfly(struct usb_callout *uco, struct lock *lock,
+        int flags); 
+void usb_callout_reset_dfly(struct usb_callout *uco, int ticks,
+        timeout_t *func, void *arg);    
 
-#define        usb_callout_init_mtx(c,m,f) usb_callout_init_mtx_dfly(c,m,f) 
-#define        usb_callout_reset(c,t,f,d) usb_callout_reset_dfly(c,t,f,d)
+#define        usb_callout_init_mtx(c,m,f) usb_callout_init_mtx_dfly(c, m, f) 
+#define        usb_callout_reset(c,t,f,d) usb_callout_reset_dfly(c, t, f, d)
 #define        usb_callout_stop(c) callout_stop(&(c)->co)
 #define        usb_callout_drain(c) callout_stop_sync(&(c)->co)
 #define        usb_callout_pending(c) callout_pending(&(c)->co)