* Adjust indentation, whitespace and typos.
* Uniformly use #if 0 to deactivate code instead of C comments.
* 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>
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);
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-
/*
* USB Enhanced Host Controller Driver, a.k.a. USB 2.0 controller.
*
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);
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);
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(usb_take_controller, ehci_pci_take_controller),
- { 0, 0 }
+ { 0, 0 }
};
static driver_t ehci_driver = {
* SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-
/*
* USB Open Host Controller driver.
*
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-
/*
* USB Open Host Controller driver.
*
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;
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);
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(usb_take_controller, ohci_pci_take_controller),
- { 0, 0 }
+ { 0, 0 }
};
static driver_t ohci_driver = {
* 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
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-
/* Universal Host Controller Interface
*
* UHCI spec: http://www.intel.com/
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.
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(usb_take_controller, uhci_pci_take_controller),
- { 0, 0 }
+ { 0, 0 }
};
static driver_t uhci_driver = {
{
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;
}
}
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);
/* Let the USB explore process detach all devices. */
usb_root_mount_rel(bus);
-
+
USB_BUS_LOCK(bus);
/* Queue detach job */
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,
usb_dma_tag_unsetup(bus->dma_parent_tag);
#endif
- lockuninit(&bus->bus_lock);
+ lockuninit(&bus->bus_lock);
}
* 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>
/* 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,
* SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-
#include <sys/stdint.h>
#include <sys/param.h>
#include <sys/queue.h>
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(usb_take_controller, xhci_pci_take_controller),
- { 0, 0 }
+ { 0, 0 }
};
static driver_t xhci_driver = {
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) {
#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>
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 */
}
{
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;
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);
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,
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;
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 =
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 {
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);
}
/* 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 */
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
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)) {
-/* $fREEbSD$ */
+/* $FreeBSD$ */
/*-
* Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
*
#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,
/*------------------------------------------------------------------------*
* 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
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) {
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 */
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;
#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>
#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>
#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) \
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,
};
/* 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);
*/
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
DPRINTFN(2, "ref read\n");
crd->rxfifo->refcount++;
}
- lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
+ lockmgr(&usb_ref_lock, LK_EXCLUSIVE);
return (0);
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);
}
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);
}
crd->is_uref = 0;
}
- lockmgr(&usb_ref_lock, LK_RELEASE);
+ lockmgr(&usb_ref_lock, LK_RELEASE);
}
static struct usb_fifo *
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);
}
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) &&
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);
/* check if we are selected */
if (f->flag_isselect) {
-#ifdef XXXDF
+#if 0 /* XXXDF */
selwakeup(&f->selinfo);
#endif
f->flag_isselect = 0;
/* 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 */
*------------------------------------------------------------------------*/
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;
}
}
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);
}
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;
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 */
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");
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;
*------------------------------------------------------------------------*/
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;
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
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;
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;
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) {
}
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;
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) {
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;
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);
}
}
#define _USB_DEV_H_
#include <sys/file.h>
-//#include <sys/selinfo.h>
#include <sys/poll.h>
#include <sys/signalvar.h>
#include <sys/proc.h>
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;
#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);
if (cmd == USB_CFG_INIT) {
KKASSERT(lockstatus(&udev->enum_lock, curthread) == LK_EXCLUSIVE);
+
/* check for in-use endpoints */
ep = udev->endpoints;
}
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
}
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 */
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");
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);
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);
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 "
devctl_notify("USB", "INTERFACE", type, sbuf_data(sb));
sbuf_delete(sb);
}
+#endif
}
#endif
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. */
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. */
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. */
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);
}
/*
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);
}
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;
/* 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
/* 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
/* XXX this is a tradeoff */
- /* pause("WAIT", hz); */
- tsleep(usb_quirk_unload, 0, "WAIT", hz);
+ tsleep(usb_quirk_unload, 0, "WAIT", hz);
}
#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
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,
usbd_transfer_unsetup(f->xfer, n_setup);
}
}
- lockmgr(f->priv_lock, LK_EXCLUSIVE);
+ lockmgr(f->priv_lock, LK_EXCLUSIVE);
return (error);
}
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:
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);
}
/* 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);
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 */
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 */
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));
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);
}
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));
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;
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:
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);
USB_P2U(xfer->priv_fifo));
}
}
- lockmgr(f->priv_lock, LK_RELEASE);
+ lockmgr(f->priv_lock, LK_RELEASE);
break;
case USB_FS_OPEN:
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);
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);
/* $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.
lockinit(&sc->sc_lock, "USB HUB mutex", 0, 0);
-
ksnprintf(sc->sc_name, sizeof(sc->sc_name), "%s",
device_get_nameunit(dev));
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");
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);
}
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");
goto done;
}
done:
- /* XXX
+#if 0
mtx_unlock(&Giant);
- */
+#endif
+
return (0);
}
struct usb_hub *hub;
enum usb_dev_speed speed;
uint8_t x;
-
+
USB_BUS_LOCK_ASSERT(bus);
+
speed = usbd_get_speed(udev);
switch (speed) {
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,
* SUCH DAMAGE.
*/
-#include <sys/cdefs.h>
-//__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#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__)
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;
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);
}
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;
if (up->up_gone)
return (_pm0);
- KKASSERT(lockstatus(up->up_lock, curthread) != 0);
+ KKASSERT(lockstatus(up->up_lock, curthread) != 0);
t = 0;
* structure is initialised.
*/
if (up->up_lock != NULL)
- KKASSERT(lockstatus(up->up_lock, curthread)!=0);
-
+ KKASSERT(lockstatus(up->up_lock, curthread)!=0);
return (0);
}
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. */
/* 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 */
DPRINTF("WARNING: Someone is waiting "
"for USB process drain!\n");
}
- lockmgr(up->up_lock, LK_RELEASE);
+ lockmgr(up->up_lock, LK_RELEASE);
}
/*------------------------------------------------------------------------*
/* check if gone */
if (up->up_gone)
return;
+
KKASSERT(lockstatus(up->up_lock, curthread) != 0);
if (up->up_msleep == 0) {
#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
#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>
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);
}
/*
* 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);
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);
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 */
}
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);
}
}
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) {
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];
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) {
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;
{
struct usb_endpoint *ep;
-/*
+#if 0
USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
-*/
+#endif
+
USB_BUS_LOCK(xfer->xroot->bus);
ep = xfer->endpoint;
/* transfer is gone */
return;
}
- /*
+#if 0
USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
- */
+#endif
+
/* mark the USB transfer started */
if (!xfer->flags_int.started) {
/* 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) {
/* transfer is gone */
return (0);
}
- /*
+#if 0
USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
- */
+#endif
+
if (xfer->flags_int.transferring) {
/* trivial case */
return (1);
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;
* 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);
}
/*------------------------------------------------------------------------*
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) {
{
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:
*
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;
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 */
{
struct usb_xfer *xfer = arg;
struct usb_endpoint *ep = xfer->endpoint;
-
+
USB_BUS_LOCK_ASSERT(xfer->xroot->bus);
DPRINTF("start\n");
/* 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;
/* tearing down */
return;
}
-
USB_XFER_LOCK_ASSERT(xfer);
-
+
/* avoid any races by locking the USB mutex */
USB_BUS_LOCK(xfer->xroot->bus);
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);
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 &&
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:
/* 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++;
/* 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++;
}
/* 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);
}
}
* 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);
+ }
}
/*------------------------------------------------------------------------*
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);
}
* 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)
projects / dragonfly.git / commitdiff