#include <dev/if_ndis/if_ndisvar.h>

static driver_object usbd_driver;

#define USBD_CTRL_READ_PIPE 0

#define USBD_CTRL_WRITE_PIPE 1

static int32_t usbd_func_vendorclass(irp *);

static int32_t usbd_func_selconf(irp *);

static int32_t usbd_func_abort_pipe(irp *);

struct usb_endpoint_descriptor *);

struct ndisusb_ep *, struct usb_config *);

static int32_t usbd_func_getdesc(irp *);

static union usbd_urb *usbd_geturb(irp *);

return (STATUS_FAILURE);

}

static int32_t

usbd_usb2urb(int status)

{

uint32_t len;

union usbd_urb *urb;

usb_config_descriptor_t *cdp;

urb = usbd_geturb(ip);

ctldesc = &urb->uu_ctldesc;

union usbd_urb *urb;

usb_config_descriptor_t *conf;

usb_endpoint_descriptor_t *edesc;

urb = usbd_geturb(ip);

return USBD_STATUS_SUCCESS;

}

usbd_setup_endpoint_one(ip, ifidx, ne, epconf)

irp *ip;

uint8_t ifidx;

device_t dev = IRP_NDIS_DEV(ip);

struct ndis_softc *sc = device_get_softc(dev);

struct usb_xfer *xfer;

InitializeListHead(&ne->ne_active);

InitializeListHead(&ne->ne_pending);

return (status);

}

usbd_setup_endpoint_default(ip, ifidx)

irp *ip;

uint8_t ifidx;

{

device_t dev = IRP_NDIS_DEV(ip);

struct ndis_softc *sc = device_get_softc(dev);

if (ifidx > 0)

device_printf(dev, "warning: ifidx > 0 isn't supported.\n");

return (status);

}

usbd_setup_endpoint(ip, ifidx, ep)

irp *ip;

uint8_t ifidx;

struct ndisusb_ep *ne;

struct usb_config cfg;

struct usb_xfer *xfer;

/* check for non-supported transfer types */

if (UE_GET_XFERTYPE(ep->bmAttributes) == UE_CONTROL ||

static void

usbd_xfer_complete(struct ndis_softc *sc, struct ndisusb_ep *ne,

{

struct ndisusb_xferdone *nd;

uint8_t irql;

struct usbd_urb_bulk_or_intr_transfer *ubi;

struct usbd_urb_vendor_or_class_request *vcreq;

union usbd_urb *urb;

void *priv;

dev = sc->ndis_dev;

static device_attach_t atausb2_attach;

static device_detach_t atausb2_detach;

static void atausb2_cancel_request(struct atausb2_softc *sc);

static void atausb2_transfer_start(struct atausb2_softc *sc, uint8_t xfer_no);

};

struct ndisusb_xferdone {

struct ndisusb_xfer *nd_xfer;

list_entry nd_donelist;

};

static device_attach_t uaudio_attach;

static device_detach_t uaudio_detach;

static void uaudio_chan_fill_info_sub(struct uaudio_softc *,

struct usb_device *, uint32_t, uint16_t, uint8_t, uint8_t);

struct uaudio_mixer_node *);

static void uaudio_mixer_ctl_set(struct uaudio_softc *,

struct uaudio_mixer_node *, uint8_t, int32_t val);

static int uaudio_mixer_signext(uint8_t, int);

static int uaudio_mixer_bsd2value(struct uaudio_mixer_node *, int32_t val);

static const void *uaudio_mixer_verify_desc(const void *, uint32_t);

uint8_t endpoint;

uint8_t iface_index;

uint8_t alt_index;

/* compute required buffer size */

buf_size = (ch->bytes_per_frame * UAUDIO_MINFRAMES);

uint16_t val;

uint16_t len = MIX_SIZE(mc->type);

uint8_t data[4];

if (mc->wValue[0] == -1) {

return (0);

}

}

uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)

{

struct usb_device_request req;

static at91dci_cmd_t at91dci_data_rx;

static at91dci_cmd_t at91dci_data_tx;

static at91dci_cmd_t at91dci_data_tx_sync;

static void at91dci_do_poll(struct usb_bus *);

static void at91dci_standard_done(struct usb_xfer *);

static void at91dci_root_intr(struct at91dci_softc *sc);

sizeof(sc->sc_hub_idata));

}

at91dci_standard_done_sub(struct usb_xfer *xfer)

{

struct at91dci_td *td;

static void

at91dci_standard_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* same USB transfer!

*------------------------------------------------------------------------*/

static void

{

struct at91dci_softc *sc = AT9100_DCI_BUS2SC(xfer->xroot->bus);

uint8_t ep_no;

(ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));

}

at91dci_init(struct at91dci_softc *sc)

{

uint32_t csr_val;

USB_MAKE_STRING_DESC(STRING_VENDOR, at91dci_vendor);

USB_MAKE_STRING_DESC(STRING_PRODUCT, at91dci_product);

at91dci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t len;

uint16_t value;

uint16_t index;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

/* prototypes */

void at91dci_uninit(struct at91dci_softc *sc);

void at91dci_suspend(struct at91dci_softc *sc);

void at91dci_resume(struct at91dci_softc *sc);

static atmegadci_cmd_t atmegadci_data_rx;

static atmegadci_cmd_t atmegadci_data_tx;

static atmegadci_cmd_t atmegadci_data_tx_sync;

static void atmegadci_do_poll(struct usb_bus *);

static void atmegadci_standard_done(struct usb_xfer *);

static void atmegadci_root_intr(struct atmegadci_softc *sc);

sizeof(sc->sc_hub_idata));

}

atmegadci_standard_done_sub(struct usb_xfer *xfer)

{

struct atmegadci_td *td;

static void

atmegadci_standard_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* same USB transfer!

*------------------------------------------------------------------------*/

static void

{

struct atmegadci_softc *sc = ATMEGA_BUS2SC(xfer->xroot->bus);

uint8_t ep_no;

(ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));

}

atmegadci_init(struct atmegadci_softc *sc)

{

uint8_t n;

USB_MAKE_STRING_DESC(STRING_VENDOR, atmegadci_vendor);

USB_MAKE_STRING_DESC(STRING_PRODUCT, atmegadci_product);

atmegadci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t value;

uint16_t index;

uint8_t temp;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

/* prototypes */

void atmegadci_uninit(struct atmegadci_softc *sc);

void atmegadci_suspend(struct atmegadci_softc *sc);

void atmegadci_resume(struct atmegadci_softc *sc);

static avr32dci_cmd_t avr32dci_data_rx;

static avr32dci_cmd_t avr32dci_data_tx;

static avr32dci_cmd_t avr32dci_data_tx_sync;

static void avr32dci_do_poll(struct usb_bus *);

static void avr32dci_standard_done(struct usb_xfer *);

static void avr32dci_root_intr(struct avr32dci_softc *sc);

sizeof(sc->sc_hub_idata));

}

avr32dci_standard_done_sub(struct usb_xfer *xfer)

{

struct avr32dci_td *td;

static void

avr32dci_standard_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* same USB transfer!

*------------------------------------------------------------------------*/

static void

{

struct avr32dci_softc *sc = AVR32_BUS2SC(xfer->xroot->bus);

uint8_t ep_no;

(ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));

}

avr32dci_init(struct avr32dci_softc *sc)

{

uint8_t n;

USB_MAKE_STRING_DESC(STRING_VENDOR, avr32dci_vendor);

USB_MAKE_STRING_DESC(STRING_PRODUCT, avr32dci_product);

avr32dci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t value;

uint16_t index;

uint32_t temp;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

/* prototypes */

void avr32dci_uninit(struct avr32dci_softc *sc);

void avr32dci_suspend(struct avr32dci_softc *sc);

void avr32dci_resume(struct avr32dci_softc *sc);

extern struct usb_pipe_methods ehci_device_isoc_hs_methods;

static void ehci_do_poll(struct usb_bus *bus);

static uint8_t ehci_check_transfer(struct usb_xfer *xfer);

static void ehci_timeout(void *arg);

static void ehci_root_intr(ehci_softc_t *sc);

};

void

{

ehci_softc_t *sc = EHCI_BUS2SC(bus);

uint32_t i;

}

}

ehci_reset(ehci_softc_t *sc)

{

uint32_t hcr;

return (USB_ERR_IOERROR);

}

ehci_hcreset(ehci_softc_t *sc)

{

uint32_t hcr;

return ehci_reset(sc);

}

ehci_init(ehci_softc_t *sc)

{

struct usb_page_search buf_res;

uint16_t x;

uint16_t y;

uint16_t bit;

DPRINTF("start\n");

return (last);

}

ehci_non_isoc_done_sub(struct usb_xfer *xfer)

{

ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus);

static void

ehci_non_isoc_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* from close and from interrupt

*/

static void

{

struct usb_pipe_methods *methods = xfer->pipe->methods;

ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus);

EOWRITE4(sc, port, v | EHCI_PS_PO);

}

ehci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t value;

uint16_t index;

uint8_t l;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

}

#endif

void ehci_detach(struct ehci_softc *sc);

void ehci_suspend(struct ehci_softc *sc);

void ehci_resume(struct ehci_softc *sc);

static musbotg_cmd_t musbotg_setup_status;

static musbotg_cmd_t musbotg_data_rx;

static musbotg_cmd_t musbotg_data_tx;

static void musbotg_do_poll(struct usb_bus *);

static void musbotg_standard_done(struct usb_xfer *);

static void musbotg_interrupt_poll(struct musbotg_softc *);

sizeof(sc->sc_hub_idata));

}

musbotg_standard_done_sub(struct usb_xfer *xfer)

{

struct musbotg_td *td;

static void

musbotg_standard_done(struct usb_xfer *xfer)

{

DPRINTFN(12, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* same USB transfer!

*------------------------------------------------------------------------*/

static void

{

USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);

(ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));

}

musbotg_init(struct musbotg_softc *sc)

{

struct usb_hw_ep_profile *pf;

USB_MAKE_STRING_DESC(STRING_VENDOR, musbotg_vendor);

USB_MAKE_STRING_DESC(STRING_PRODUCT, musbotg_product);

musbotg_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t len;

uint16_t value;

uint16_t index;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

/* prototypes */

void musbotg_uninit(struct musbotg_softc *sc);

void musbotg_suspend(struct musbotg_softc *sc);

void musbotg_resume(struct musbotg_softc *sc);

extern struct usb_pipe_methods ohci_device_isoc_methods;

static void ohci_do_poll(struct usb_bus *bus);

static void ohci_timeout(void *arg);

static uint8_t ohci_check_transfer(struct usb_xfer *xfer);

static void ohci_root_intr(ohci_softc_t *sc);

}

void

{

struct ohci_softc *sc = OHCI_BUS2SC(bus);

uint32_t i;

}

}

ohci_controller_init(ohci_softc_t *sc)

{

struct usb_page_search buf_res;

return (ed);

}

ohci_init(ohci_softc_t *sc)

{

struct usb_page_search buf_res;

#endif

ohci_non_isoc_done_sub(struct usb_xfer *xfer)

{

ohci_td_t *td;

static void

ohci_non_isoc_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* from close and from interrupt

*/

static void

{

struct usb_pipe_methods *methods = xfer->pipe->methods;

ohci_softc_t *sc = OHCI_BUS2SC(xfer->xroot->bus);

{0},

};

ohci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t value;

uint16_t index;

uint8_t l;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

} ohci_softc_t;

void ohci_detach(struct ohci_softc *sc);

void ohci_suspend(ohci_softc_t *sc);

void ohci_resume(ohci_softc_t *sc);

static uint8_t uhci_restart(uhci_softc_t *sc);

static void uhci_do_poll(struct usb_bus *);

static void uhci_transfer_intr_enqueue(struct usb_xfer *);

static void uhci_timeout(void *);

static uint8_t uhci_check_transfer(struct usb_xfer *);

static void uhci_root_intr(uhci_softc_t *sc);

void

{

struct uhci_softc *sc = UHCI_BUS2SC(bus);

uint32_t i;

return (td);

}

uhci_init(uhci_softc_t *sc)

{

uint16_t bit;

xfer->aframes = xfer->nframes;

}

uhci_non_isoc_done_sub(struct usb_xfer *xfer)

{

struct usb_page_search res;

static void

uhci_non_isoc_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

*/

static void

{

struct usb_pipe_methods *methods = xfer->pipe->methods;

uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus);

* outstanding "port enable change" and "connection status change"

* events have been reset.

*/

uhci_portreset(uhci_softc_t *sc, uint16_t index)

{

uint16_t port;

return (USB_ERR_NORMAL_COMPLETION);

}

uhci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t status;

uint16_t change;

uint16_t len;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

char sc_vendor[16]; /* vendor string for root hub */

} uhci_softc_t;

void uhci_suspend(uhci_softc_t *sc);

void uhci_resume(uhci_softc_t *sc);

void uhci_reset(uhci_softc_t *sc);

struct usb_bus *bus;

struct usb_device *child;

device_t dev;

enum usb_dev_speed speed;

bus = ((struct usb_bus_msg *)pm)->bus;

*------------------------------------------------------------------------*/

#if USB_HAVE_BUSDMA

void

{

if (cb) {

cb(bus, &usb2_bus_mem_flush_all_cb);

*------------------------------------------------------------------------*/

uint8_t

usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat,

{

bus->alloc_failed = 0;

* usb2_bus_mem_free_all - factored out code

*------------------------------------------------------------------------*/

void

{

#if USB_HAVE_BUSDMA

if (cb) {

static uss820dci_cmd_t uss820dci_data_rx;

static uss820dci_cmd_t uss820dci_data_tx;

static uss820dci_cmd_t uss820dci_data_tx_sync;

static void uss820dci_do_poll(struct usb_bus *);

static void uss820dci_standard_done(struct usb_xfer *);

static void uss820dci_intr_set(struct usb_xfer *, uint8_t);

sizeof(sc->sc_hub_idata));

}

uss820dci_standard_done_sub(struct usb_xfer *xfer)

{

struct uss820dci_td *td;

static void

uss820dci_standard_done(struct usb_xfer *xfer)

{

DPRINTFN(13, "xfer=%p pipe=%p transfer done\n",

xfer, xfer->pipe);

* same USB transfer!

*------------------------------------------------------------------------*/

static void

{

USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);

(ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));

}

uss820dci_init(struct uss820dci_softc *sc)

{

const struct usb_hw_ep_profile *pf;

USB_MAKE_STRING_DESC(STRING_VENDOR, uss820dci_vendor);

USB_MAKE_STRING_DESC(STRING_PRODUCT, uss820dci_product);

uss820dci_roothub_exec(struct usb_device *udev,

struct usb_device_request *req, const void **pptr, uint16_t *plength)

{

uint16_t len;

uint16_t value;

uint16_t index;

USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);

/* prototypes */

void uss820dci_uninit(struct uss820dci_softc *sc);

void uss820dci_suspend(struct uss820dci_softc *sc);

void uss820dci_resume(struct uss820dci_softc *sc);

static device_attach_t uhid_attach;

static device_detach_t uhid_detach;

static struct usb_fifo_methods uhid_fifo_methods = {

.f_open = &uhid_open,

int32_t unit = device_get_unit(dev);

keyboard_t *kbd = &sc->sc_kbd;

void *hid_ptr = NULL;

uint32_t flags;

uint16_t n;

uint16_t hid_len;

static void ums_put_queue_timeout(void *__sc);

static device_probe_t ums_probe;

static device_attach_t ums_attach;

static device_detach_t ums_detach;

static void ums_put_queue(struct ums_softc *sc, int32_t dx, int32_t dy, int32_t dz, int32_t dt, int32_t buttons);

static device_attach_t udbp_attach;

static device_detach_t udbp_detach;

static void udbp_bulk_read_complete(node_p, hook_p, void *, int);

static device_attach_t ufm_attach;

static device_detach_t ufm_detach;

static struct usb_fifo_methods ufm_fifo_methods = {

.f_ioctl = &ufm_ioctl,

static miibus_writereg_t aue_miibus_writereg;

static miibus_statchg_t aue_miibus_statchg;

static uint8_t aue_csr_read_1(struct aue_softc *, uint16_t);

static uint16_t aue_csr_read_2(struct aue_softc *, uint16_t);

aue_csr_read_1(struct aue_softc *sc, uint16_t reg)

{

struct usb_device_request req;

uint8_t val;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

aue_csr_read_2(struct aue_softc *sc, uint16_t reg)

{

struct usb_device_request req;

uint16_t val;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

static device_attach_t axe_attach;

static device_detach_t axe_detach;

static miibus_readreg_t axe_miibus_readreg;

static miibus_writereg_t axe_miibus_writereg;

static miibus_statchg_t axe_miibus_statchg;

static int axe_ifmedia_upd(struct ifnet *);

static void axe_ifmedia_sts(struct ifnet *, struct ifmediareq *);

axe_cmd(struct axe_softc *sc, int cmd, int index, int val, void *buf)

{

struct usb_device_request req;

AXE_LOCK_ASSERT(sc, MA_OWNED);

axe_reset(struct axe_softc *sc)

{

struct usb_config_descriptor *cd;

cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev);

static device_resume_t cdce_resume;

static usb_handle_request_t cdce_handle_request;

static uint32_t cdce_m_crc32(struct mbuf *, uint32_t, uint32_t);

static device_attach_t cue_attach;

static device_detach_t cue_detach;

static uint8_t cue_csr_read_1(struct cue_softc *, uint16_t);

static uint16_t cue_csr_read_2(struct cue_softc *, uint8_t);

static device_attach_t kue_attach;

static device_detach_t kue_detach;

static int kue_do_request(struct kue_softc *,

struct usb_device_request *, void *);

kue_do_request(struct kue_softc *sc, struct usb_device_request *req,

void *data)

{

err = usb2_ether_do_request(&sc->sc_ue, req, data, 60000);

{

struct usb_device_descriptor *dd;

uint16_t hwrev;

dd = usb2_get_device_descriptor(sc->sc_ue.ue_udev);

hwrev = UGETW(dd->bcdDevice);

kue_reset(struct kue_softc *sc)

{

struct usb_config_descriptor *cd;

cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev);

static miibus_writereg_t rue_miibus_writereg;

static miibus_statchg_t rue_miibus_statchg;

static int rue_read_mem(struct rue_softc *, uint16_t, void *, int);

static int rue_write_mem(struct rue_softc *, uint16_t, void *, int);

static device_attach_t udav_attach;

static device_detach_t udav_detach;

static int udav_csr_read(struct udav_softc *, uint16_t, void *, int);

static int udav_csr_write(struct udav_softc *, uint16_t, void *, int);

static struct unrhdr *ueunit;

static void ue_init(void *);

static void ue_start(struct ifnet *);

static void

ue_queue_command(struct usb_ether *ue,

struct usb_proc_msg *t0, struct usb_proc_msg *t1)

{

struct usb_ether_cfg_task *task;

struct usb_ether;

struct usb_device_request;

struct usb_ether_methods {

int (*ue_mii_upd)(struct ifnet *);

void (*ue_mii_sts)(struct ifnet *,

struct ifmediareq *);

static device_attach_t u3g_attach;

static device_detach_t u3g_detach;

static void u3g_start_read(struct ucom_softc *ucom);

static void u3g_stop_read(struct ucom_softc *ucom);

};

struct usb_device_request req;

uint16_t len;

uint8_t buf[0x300];

uint8_t n;

* interface. After some command or some delay they change appearance

* to a modem.

*/

u3g_test_huawei_autoinst(struct usb_device *udev,

struct usb_attach_arg *uaa)

{

static device_attach_t uark_attach;

static device_detach_t uark_detach;

static void uark_start_read(struct ucom_softc *);

static void uark_stop_read(struct ucom_softc *);

uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value)

{

struct usb_device_request req;

req.bmRequestType = UARK_WRITE;

req.bRequest = UARK_REQUEST;

static device_attach_t ubsa_attach;

static device_detach_t ubsa_detach;

static void ubsa_cfg_request(struct ubsa_softc *, uint8_t, uint16_t);

static void ubsa_cfg_set_dtr(struct ucom_softc *, uint8_t);

ubsa_cfg_request(struct ubsa_softc *sc, uint8_t index, uint16_t value)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = index;

static device_attach_t ubser_attach;

static device_detach_t ubser_detach;

static int ubser_pre_param(struct ucom_softc *, struct termios *);

static void ubser_cfg_set_break(struct ucom_softc *, uint8_t);

struct ubser_softc *sc = ucom->sc_parent;

uint8_t x = ucom->sc_portno;

struct usb_device_request req;

if (onoff) {

static device_attach_t uchcom_attach;

static device_detach_t uchcom_detach;

static const struct usb_config uchcom_config_data[UCHCOM_N_TRANSFER] = {

static device_attach_t ucycom_attach;

static device_detach_t ucycom_detach;

static void ucycom_cfg_open(struct ucom_softc *);

static void ucycom_start_read(struct ucom_softc *);

{

struct usb_device_request req;

uint16_t len;

len = sc->sc_flen;

if (len > sizeof(sc->sc_temp_cfg)) {

static device_attach_t ufoma_attach;

static device_detach_t ufoma_detach;

static void *ufoma_get_intconf(struct usb_config_descriptor *,

struct usb_interface_descriptor *, uint8_t, uint8_t);

static device_attach_t uftdi_attach;

static device_detach_t uftdi_detach;

static void uftdi_cfg_open(struct ucom_softc *);

static void uftdi_cfg_set_dtr(struct ucom_softc *, uint8_t);

static device_attach_t ugensa_attach;

static device_detach_t ugensa_detach;

static void ugensa_start_read(struct ucom_softc *);

static void ugensa_stop_read(struct ucom_softc *);

static device_attach_t uipaq_attach;

static device_detach_t uipaq_detach;

static void uipaq_start_read(struct ucom_softc *);

static void uipaq_stop_read(struct ucom_softc *);

static device_attach_t ulpt_attach;

static device_detach_t ulpt_detach;

static void ulpt_reset(struct ulpt_softc *);

static void ulpt_watchdog(void *);

static struct usb_fifo_methods ulpt_fifo_methods = {

.f_close = &ulpt_close,

static device_attach_t umct_attach;

static device_detach_t umct_detach;

static void umct_cfg_do_request(struct umct_softc *sc, uint8_t request,

uint16_t len, uint32_t value);

uint16_t len, uint32_t value)

{

struct usb_device_request req;

uint8_t temp[4];

if (len > 4)

static device_attach_t umodem_attach;

static device_detach_t umodem_detach;

static void umodem_start_read(struct ucom_softc *);

static void umodem_stop_read(struct ucom_softc *);

static void umodem_cfg_set_rts(struct ucom_softc *, uint8_t);

static void umodem_cfg_set_break(struct ucom_softc *, uint8_t);

static void *umodem_get_desc(struct usb_attach_arg *, uint8_t, uint8_t);

uint16_t, uint16_t);

static const struct usb_config umodem_config[UMODEM_N_TRANSFER] = {

type, 0 - 1, subtype, 0 - 1));

}

umodem_set_comm_feature(struct usb_device *udev, uint8_t iface_no,

uint16_t feature, uint16_t state)

{

static device_attach_t umoscom_attach;

static device_detach_t umoscom_detach;

static void umoscom_cfg_open(struct ucom_softc *);

static void umoscom_cfg_close(struct ucom_softc *);

/* prototypes */

static int uplcom_pl2303x_init(struct usb_device *);

static void uplcom_cfg_set_dtr(struct ucom_softc *, uint8_t);

static void uplcom_cfg_set_rts(struct ucom_softc *, uint8_t);

static device_attach_t uplcom_attach;

static device_detach_t uplcom_detach;

static const struct usb_config uplcom_config_data[UPLCOM_N_TRANSFER] = {

return (0);

}

uplcom_reset(struct uplcom_softc *sc, struct usb_device *udev)

{

struct usb_device_request req;

uplcom_pl2303x_init(struct usb_device *udev)

{

struct usb_device_request req;

uint8_t buf[4];

uint8_t i;

&usb2_com_debug, 0, "ucom debug level");

#endif

static uint8_t usb2_com_units_alloc(uint32_t, uint32_t *);

static void usb2_com_units_free(uint32_t, uint32_t);

static int usb2_com_attach_tty(struct ucom_softc *, uint32_t);

static void usb2_com_detach_tty(struct ucom_softc *);

static void usb2_com_queue_command(struct ucom_softc *,

struct usb_proc_msg *t0, struct usb_proc_msg *t1);

static void usb2_com_shutdown(struct ucom_softc *);

static void usb2_com_break(struct ucom_softc *, uint8_t);

static void

usb2_com_queue_command(struct ucom_softc *sc,

struct usb_proc_msg *t0, struct usb_proc_msg *t1)

{

struct ucom_super_softc *ssc = sc->sc_super;

static device_attach_t uslcom_attach;

static device_detach_t uslcom_detach;

static void uslcom_open(struct ucom_softc *);

static void uslcom_close(struct ucom_softc *);

static device_attach_t uvisor_attach;

static device_detach_t uvisor_detach;

struct usb_config *);

static void uvisor_cfg_open(struct ucom_softc *);

static void uvisor_cfg_close(struct ucom_softc *);

return (0);

}

uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config *config)

{

struct usb_device_request req;

struct uvisor_connection_info coninfo;

struct uvisor_palm_connection_info pconinfo;

struct uvisor_softc *sc = ucom->sc_parent;

uint8_t buffer[UVISOR_CONNECTION_INFO_SIZE];

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_ENDPOINT; /* XXX read? */

req.bRequest = UVISOR_CLOSE_NOTIFICATION;

static device_attach_t uvscom_attach;

static device_detach_t uvscom_detach;

static void uvscom_cfg_set_dtr(struct ucom_softc *, uint8_t);

static void uvscom_cfg_set_rts(struct ucom_softc *, uint8_t);

uvscom_cfg_write(struct uvscom_softc *sc, uint8_t index, uint16_t value)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = index;

uvscom_cfg_read_status(struct uvscom_softc *sc)

{

struct usb_device_request req;

uint8_t data[2];

req.bmRequestType = UT_READ_VENDOR_DEVICE;

static device_attach_t umass_attach;

static device_detach_t umass_detach;

static void umass_cancel_ccb(struct umass_softc *);

static void umass_init_shuttle(struct umass_softc *);

umass_init_shuttle(struct umass_softc *sc)

{

struct usb_device_request req;

uint8_t status[2] = {0, 0};

/*

umass_bbb_get_max_lun(struct umass_softc *sc)

{

struct usb_device_request req;

uint8_t buf = 0;

/* The Get Max Lun command is a class-specific request. */

static device_attach_t urio_attach;

static device_detach_t urio_detach;

static struct usb_fifo_methods urio_fifo_methods = {

.f_close = &urio_close,

static device_resume_t ustorage_fs_resume;

static usb_handle_request_t ustorage_fs_handle_request;

static void ustorage_fs_transfer_start(struct ustorage_fs_softc *sc, uint8_t xfer_index);

static void ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc);

struct usb_hw_ep_scratch_sub *, uint8_t);

static uint8_t usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t,

uint8_t);

struct usb_descriptor *);

static const struct usb_temp_device_desc *usb2_temp_get_tdd(struct usb_device *);

static void *usb2_temp_get_device_desc(struct usb_device *);

static const void *usb2_temp_get_vendor_desc(struct usb_device *,

const struct usb_device_request *);

static const void *usb2_temp_get_hub_desc(struct usb_device *);

struct usb_device_request *, const void **, uint16_t *);

const struct usb_temp_device_desc *);

static void usb2_temp_unsetup(struct usb_device *);

uint16_t index);

static void usb2_temp_init(void *);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_hw_ep_resolve(struct usb_device *udev,

struct usb_descriptor *desc)

{

* This function is a demultiplexer for local USB device side control

* endpoint requests.

*------------------------------------------------------------------------*/

usb2_temp_get_desc(struct usb_device *udev, struct usb_device_request *req,

const void **pPtr, uint16_t *pLength)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb_temp_setup(struct usb_device *udev,

const struct usb_temp_device_desc *tdd)

{

}

}

usb2_temp_setup_by_index(struct usb_device *udev, uint16_t index)

{

switch (index) {

case 0:

struct usb_bus_methods *methods; /* filled by HC driver */

struct usb_device **devices;

uint16_t isoc_time_last; /* in milliseconds */

#include <dev/usb/usb_bus.h>

#if USB_HAVE_BUSDMA

static void usb2_dma_tag_destroy(struct usb_dma_tag *);

static void usb2_dma_lock_cb(void *, bus_dma_lock_op_t);

static void usb2_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);

* been properly initialized !

*------------------------------------------------------------------------*/

void

struct usb_page_search *res)

{

struct usb_page *page;

* usb2_copy_in - copy directly to DMA-able memory

*------------------------------------------------------------------------*/

void

{

struct usb_page_search buf_res;

*------------------------------------------------------------------------*/

#if USB_HAVE_USER_IO

int

{

struct usb_page_search buf_res;

int error;

#if USB_HAVE_MBUF

struct usb2_m_copy_in_arg {

struct usb_page_cache *cache;

};

static int

}

void

{

struct usb2_m_copy_in_arg arg = {cache, dst_offset};

int error;

#if USB_HAVE_USER_IO

int

usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,

{

struct usb_page_search res;

int error = 0;

* usb2_copy_out - copy directly from DMA-able memory

*------------------------------------------------------------------------*/

void

{

struct usb_page_search res;

*------------------------------------------------------------------------*/

#if USB_HAVE_USER_IO

int

{

struct usb_page_search res;

int error;

* usb2_bzero - zero DMA-able memory

*------------------------------------------------------------------------*/

void

{

struct usb_page_search res;

*------------------------------------------------------------------------*/

static void

usb2_dma_tag_create(struct usb_dma_tag *udt,

{

bus_dma_tag_t tag;

struct usb_dma_parent_tag *uptag;

struct usb_page_cache *pc;

struct usb_page *pg;

uint8_t owned;

pc = arg;

*------------------------------------------------------------------------*/

uint8_t

usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,

{

struct usb_dma_parent_tag *uptag;

struct usb_dma_tag *utag;

* Else: Error

*------------------------------------------------------------------------*/

uint8_t

{

/* setup page cache */

pc->page_offset_buf = 0;

* Else: Failure

*------------------------------------------------------------------------*/

uint8_t

{

struct usb_xfer_root *info;

struct usb_dma_tag *utag;

*------------------------------------------------------------------------*/

struct usb_dma_tag *

usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,

{

struct usb_dma_tag *udt;

uint8_t nudt;

void

usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,

struct usb_dma_tag *udt, bus_dma_tag_t dmat,

uint8_t ndmabits, uint8_t nudt)

{

bzero(udpt, sizeof(*udpt));

{

struct usb_xfer_root *info;

struct usb_xfer *xfer;

xfer = pq->curr;

info = xfer->xroot;

}

if (!xfer->flags_int.bdma_setup) {

struct usb_page *pg;

uint8_t isread;

xfer->flags_int.bdma_setup = 1;

usb2_bdma_pre_sync(struct usb_xfer *xfer)

{

struct usb_page_cache *pc;

if (xfer->flags_int.isochronous_xfr) {

/* only one frame buffer */

usb2_bdma_post_sync(struct usb_xfer *xfer)

{

struct usb_page_cache *pc;

if (xfer->flags_int.isochronous_xfr) {

/* only one frame buffer */

* The following typedef defines the USB DMA load done callback.

*/

/*

* The following structure defines physical and non kernel virtual

#if USB_HAVE_BUSDMA

bus_size_t physaddr;

#endif

};

/*

struct usb_dma_parent_tag *tag_parent; /* always set */

void *buffer; /* virtual buffer pointer */

#if USB_HAVE_BUSDMA

uint8_t isread:1; /* set if we are currently reading

* from the memory. Else write. */

uint8_t ismultiseg:1; /* set if we can have multiple

bus_dma_tag_t tag; /* always set */

struct mtx *mtx; /* private mutex, always set */

struct usb_dma_tag *utag_first;/* pointer to first USB DMA tag */

uint8_t dma_error; /* set if DMA load operation failed */

uint8_t dma_bits; /* number of DMA address lines */

struct usb_dma_tag {

struct usb_dma_parent_tag *tag_parent;

bus_dma_tag_t tag;

};

#else

struct usb_dma_tag {}; /* empty struct */

/* function prototypes */

int usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,

struct usb_dma_tag *usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,

uint8_t usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,

uint8_t sync);

void usb2_bdma_done_event(struct usb_dma_parent_tag *udpt);

void usb2_bdma_post_sync(struct usb_xfer *xfer);

void usb2_bdma_pre_sync(struct usb_xfer *xfer);

void usb2_bdma_work_loop(struct usb_xfer_queue *pq);

void usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,

struct usb_dma_tag *udt, bus_dma_tag_t dmat, struct mtx *mtx,

void usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt);

struct usb_page_search *res);

void usb2_pc_cpu_flush(struct usb_page_cache *pc);

void usb2_pc_cpu_invalidate(struct usb_page_cache *pc);

void usb2_pc_dmamap_destroy(struct usb_page_cache *pc);

static device_suspend_t usb_linux_suspend;

static device_resume_t usb_linux_resume;

static usb_complete_t usb_linux_wait_complete;

static uint16_t usb_max_isoc_frames(struct usb_device *);

static const struct usb_device_id *usb_linux_lookup_id(

const struct usb_device_id *, struct usb_attach_arg *);

static struct usb_driver *usb_linux_get_usb_driver(struct usb_linux_softc *);

* Linux USB transfers.

*------------------------------------------------------------------------*/

static int

{

int err;

usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *uhe,

uint8_t request, uint8_t requesttype,

uint16_t value, uint16_t index, void *data,

{

struct usb_device_request req;

struct urb *urb;

*------------------------------------------------------------------------*/

int

usb_setup_endpoint(struct usb_device *dev,

{

struct usb_config cfg[2];

uint8_t type = uhe->desc.bmAttributes & UE_XFERTYPE;

struct usb_interface *p_ui = NULL;

struct usb_host_interface *p_uhi = NULL;

struct usb_host_endpoint *p_uhe = NULL;

uint16_t niface_total;

uint16_t nedesc;

uint16_t iface_no_curr;

usb_alloc_urb(uint16_t iso_packets, uint16_t mem_flags)

{

struct urb *urb;

if (iso_packets == 0xFFFF) {

/*

* usb_buffer_alloc

*------------------------------------------------------------------------*/

void *

{

return (malloc(size, M_USBDEV, M_WAITOK | M_ZERO));

}

* usb_buffer_free

*------------------------------------------------------------------------*/

void

void *addr, uint8_t dma_addr)

{

free(addr, M_USBDEV);

static void

usb_linux_isoc_callback(struct usb_xfer *xfer)

{

struct urb *urb = xfer->priv_fifo;

struct usb_host_endpoint *uhe = xfer->priv_sc;

struct usb_iso_packet_descriptor *uipd;

struct urb *urb = xfer->priv_fifo;

struct usb_host_endpoint *uhe = xfer->priv_sc;

uint8_t *ptr;

uint8_t data_frame = xfer->flags_int.control_xfr ? 1 : 0;

DPRINTF("\n");

void *context; /* (in) context for completion */

usb_complete_t *complete; /* (in) completion routine */

uint16_t transfer_flags; /* (in) */

#define URB_SHORT_NOT_OK 0x0001 /* report short transfers like errors */

#define URB_WAIT_WAKEUP 0x0010 /* custom flags */

#define URB_IS_SLEEPING 0x0020 /* custom flags */

uint16_t interval; /* (modify) transfer interval

* (INT/ISO) */

uint16_t error_count; /* (return) number of ISO errors */

int usb_clear_halt(struct usb_device *dev, struct usb_host_endpoint *uhe);

int usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *pipe,

uint8_t request, uint8_t requesttype, uint16_t value,

int usb_set_interface(struct usb_device *dev, uint8_t ifnum,

uint8_t alternate);

int usb_setup_endpoint(struct usb_device *dev,

struct usb_host_endpoint *usb_find_host_endpoint(struct usb_device *dev,

uint8_t type, uint8_t ep);

const struct usb_interface *intf, uint8_t alt_index);

struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, uint8_t iface_no);

uint16_t mem_flags, uint8_t *dma_addr);

void *usb_get_intfdata(struct usb_interface *intf);

void usb_free_urb(struct urb *urb);

void usb_init_urb(struct urb *urb);

void usb_kill_urb(struct urb *urb);

/* typedefs */

/*

* The following structure is used to define all the USB BUS

/* USB Device and Host mode - Mandatory */

void (*pipe_init) (struct usb_device *, struct usb_endpoint_descriptor *, struct usb_pipe *);

void (*xfer_setup) (struct usb_setup_params *);

/* Mandatory USB Device and Host mode callbacks: */

/* Optional */

*/

struct usb_temp_setup {

void *buf;

enum usb_dev_speed usb_speed;

uint8_t self_powered;

uint8_t bNumEndpoints;

uint8_t bInterfaceNumber;

uint8_t bAlternateSetting;

uint8_t bConfigurationValue;

};

/* prototypes */

uint16_t usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr);

uint16_t usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, struct usb_fs_isoc_schedule **pp_start, struct usb_fs_isoc_schedule **pp_end, uint16_t isoc_time);

uint8_t usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len);

/* typedefs */

#ifndef USB_HAVE_USB_ERROR_T

#endif

#ifndef USB_HAVE_TIMEOUT_T

#endif

#ifndef USB_HAVE_FRLENGTH_T

#endif

#ifndef USB_HAVE_FRCOUNT_T

#endif

#ifndef USB_HAVE_TICKS_T

#endif

#ifndef USB_HAVE_POWER_MASK_T

#endif

struct usb_device_request *, const void **, uint16_t *);

/* structures */

* is used when setting up an USB transfer.

*/

struct usb_config {

#define USB_DEFAULT_INTERVAL 0

struct usb_xfer_flags flags; /* transfer flags */

enum usb_hc_mode usb_mode; /* host or device mode */

uint8_t type; /* pipe type */

void *priv_sc; /* device driver data pointer 1 */

void *priv_fifo; /* device driver data pointer 2 */

void *local_buffer;

struct usb_page_cache *frbuffers;

#define USB_NO_TIMEOUT 0

#define USB_DEFAULT_TIMEOUT 5000 /* 5000 ms = 5 seconds */

* setup */

* transferred */

uint16_t max_packet_size;

uint16_t max_frame_size;

uint16_t qh_pos;

uint16_t isoc_time_complete; /* in ms */

uint8_t address; /* physical USB address */

uint8_t endpoint; /* physical USB endpoint */

uint8_t usb2_uframe;

uint8_t usb2_state;

struct usb_xfer_flags flags;

struct usb_xfer_flags_int flags_int;

extern struct mtx usb2_ref_lock;

/* prototypes */

const char *usb2_statestr(enum usb_dev_state state);

struct usb_config_descriptor *usb2_get_config_descriptor(

struct usb_device *udev);

uint8_t usb2_clear_stall_callback(struct usb_xfer *xfer1,

struct usb_xfer *xfer2);

uint8_t usb2_get_interface_altindex(struct usb_interface *iface);

uint8_t iface_index, uint8_t alt_index);

enum usb_hc_mode usb2_get_mode(struct usb_device *udev);

enum usb_dev_speed usb2_get_speed(struct usb_device *udev);

uint32_t usb2_get_isoc_fps(struct usb_device *udev);

const uint8_t *ifaces, struct usb_xfer **pxfer,

const struct usb_config *setup_start, uint16_t n_setup,

void *priv_sc, struct mtx *priv_mtx);

void usb2_set_frame_data(struct usb_xfer *xfer, void *ptr,

void usb2_start_hardware(struct usb_xfer *xfer);

void usb2_transfer_clear_stall(struct usb_xfer *xfer);

void usb2_transfer_drain(struct usb_xfer *xfer);

static void usb2_loc_fill(struct usb_fs_privdata *,

struct usb_cdev_privdata *);

static void usb2_close(void *);

static void usb2_unref_device(struct usb_cdev_privdata *);

static d_open_t usb2_open;

static d_ioctl_t usb2_static_ioctl;

/* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */

struct cdevsw usb2_devsw = {

* 0: Success, refcount incremented on the given USB device.

* Else: Failure.

*------------------------------------------------------------------------*/

usb2_ref_device(struct usb_cdev_privdata* cpd, int need_uref)

{

struct usb_fifo **ppf;

* 0: Success, refcount incremented on the given USB device.

* Else: Failure.

*------------------------------------------------------------------------*/

usb2_usb_ref_device(struct usb_cdev_privdata *cpd)

{

/*

* Else failure

*------------------------------------------------------------------------*/

int

uint16_t nbuf)

{

usb2_fifo_free_buffer(f);

DPRINTFN(2, "detached %p\n", f_sc);

}

usb2_fifo_put_bytes_max(struct usb_fifo *f)

{

struct usb_mbuf *m;

USB_IF_POLL(&f->free_q, m);

*------------------------------------------------------------------------*/

void

usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc,

{

struct usb_mbuf *m;

while (len || (what == 1)) {

void

usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr,

{

struct usb_mbuf *m;

while (len || (what == 1)) {

}

uint8_t

{

struct usb_mbuf *m;

*------------------------------------------------------------------------*/

uint8_t

usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc,

uint8_t what)

{

struct usb_mbuf *m;

uint8_t tr_data = 0;

actlen[0] = 0;

uint8_t

usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr,

{

struct usb_mbuf *m;

uint8_t tr_data = 0;

actlen[0] = 0;

}

uint8_t

{

struct usb_mbuf *m;

struct usb_fifo;

struct usb_mbuf;

struct usb_symlink {

TAILQ_ENTRY(usb_symlink) sym_entry;

/*

* Locking note for the following functions. All the

* locked. The others are called unlocked.

*/

struct usb_fifo_methods {

/*

* NOTE: The post-ioctl callback is called after the USB reference

* gets locked in the IOCTL handler:

*/

const char *basename[4];

const char *postfix[4];

};

void *priv_sc0; /* client data */

void *priv_sc1; /* client data */

void *queue_data;

uint16_t dev_ep_index; /* our device endpoint index */

uint8_t flag_sleeping; /* set if FIFO is sleeping */

uint8_t flag_iscomplete; /* set if a USB transfer is complete */

void usb2_fifo_detach(struct usb_fifo_sc *f_sc);

uint32_t usb2_fifo_put_bytes_max(struct usb_fifo *fifo);

void usb2_fifo_put_data(struct usb_fifo *fifo, struct usb_page_cache *pc,

void usb2_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr,

void usb2_fifo_put_data_error(struct usb_fifo *fifo);

uint8_t usb2_fifo_get_data(struct usb_fifo *fifo, struct usb_page_cache *pc,

uint8_t what);

uint8_t usb2_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr,

uint8_t usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr,

void usb2_fifo_get_data_error(struct usb_fifo *fifo);

uint8_t usb2_fifo_opened(struct usb_fifo *fifo);

void usb2_fifo_free(struct usb_fifo *f);

static void usb2_suspend_resume_sub(struct usb_device *, device_t,

uint8_t);

static void usb2_clear_stall_proc(struct usb_proc_msg *_pm);

static void usb2_set_device_strings(struct usb_device *);

#if USB_HAVE_UGEN

static void usb2_notify_addq(const char *type, struct usb_device *);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_interface_count(struct usb_device *udev, uint8_t *count)

{

if (udev->cdesc == NULL) {

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_set_config_index(struct usb_device *udev, uint8_t index)

{

struct usb_status ds;

uint16_t max_power;

uint8_t selfpowered;

uint8_t do_unlock;

DPRINTFN(6, "udev=%p index=%d\n", udev, index);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)

{

struct usb_idesc_parse_state ips;

struct usb_endpoint_descriptor *ed;

struct usb_interface *iface;

struct usb_pipe *pipe;

uint8_t ep_curr;

uint8_t ep_max;

uint8_t temp;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_set_alt_interface_index(struct usb_device *udev,

uint8_t iface_index, uint8_t alt_index)

{

struct usb_interface *iface = usb2_get_iface(udev, iface_index);

uint8_t do_unlock;

/* automatic locking */

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_set_endpoint_stall(struct usb_device *udev, struct usb_pipe *pipe,

uint8_t do_stall)

{

/*------------------------------------------------------------------------*

* usb2_reset_iface_endpoints - used in USB device side mode

*------------------------------------------------------------------------*/

usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)

{

struct usb_pipe *pipe;

struct usb_pipe *pipe_end;

pipe = udev->pipes;

pipe_end = udev->pipes + udev->pipes_max;

* 0: Success

* Else: A control transfer failed

*------------------------------------------------------------------------*/

usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index)

{

struct usb_attach_arg uaa;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_suspend_resume(struct usb_device *udev, uint8_t do_suspend)

{

struct usb_interface *iface;

struct usb_device *hub;

uint8_t *scratch_ptr;

uint32_t scratch_size;

uint8_t device_index;

DPRINTF("parent_dev=%p, bus=%p, parent_hub=%p, depth=%u, "

udev->depth = depth;

udev->bus = bus;

udev->address = USB_START_ADDR; /* default value */

usb2_set_device_state(udev, USB_STATE_POWERED);

/*

* We need to force the power mode to "on" because there are plenty

TAILQ_HEAD(, urb) bsd_urb_list;

struct usb_xfer *bsd_xfer[2];

uint8_t *extra; /* Extra descriptors */

uint16_t extralen;

uint8_t bsd_iface_index;

} __aligned(USB_HOST_ALIGN);

* in this structure is protected by the USB BUS lock.

*/

struct usb_power_save {

};

/*

LIST_HEAD(,usb_fs_privdata) pd_list;

char ugen_name[20]; /* name of ugenX.X device */

#endif

enum usb_dev_state state;

enum usb_dev_speed speed;

struct usb_pipe *usb2_get_pipe(struct usb_device *udev, uint8_t iface_index,

const struct usb_config *setup);

struct usb_pipe *usb2_get_pipe_by_addr(struct usb_device *udev, uint8_t ea_val);

uint8_t iface_index);

uint8_t iface_index);

struct usb_pipe *pipe, uint8_t do_stall);

uint8_t do_suspend);

void usb2_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len);

void usb2_free_device(struct usb_device *, uint8_t);

#include <dev/usb/usb_dynamic.h>

/* function prototypes */

static usb2_temp_setup_by_index_t usb2_temp_setup_by_index_w;

static usb2_temp_unsetup_t usb2_temp_unsetup_w;

static usb2_test_quirk_t usb2_test_quirk_w;

static usb2_quirk_ioctl_t usb2_quirk_ioctl_w;

/* global variables */

usb2_temp_setup_by_index_t *usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index_w;

usb2_temp_unsetup_t *usb2_temp_unsetup_p = &usb2_temp_unsetup_w;

usb2_test_quirk_t *usb2_test_quirk_p = &usb2_test_quirk_w;

usb2_quirk_ioctl_t *usb2_quirk_ioctl_p = &usb2_quirk_ioctl_w;

devclass_t usb2_devclass_ptr = NULL;

usb2_temp_setup_by_index_w(struct usb_device *udev, uint16_t index)

{

return (USB_ERR_INVAL);

return (ENOIOCTL);

}

usb2_temp_get_desc_w(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength)

{

/* stall */

/* typedefs */

uint16_t index);

struct usb_attach_arg *uaa);

typedef uint8_t (usb2_test_quirk_t)(const struct usb_lookup_info *info,

uint16_t quirk);

/* global function pointers */

extern usb2_temp_setup_by_index_t *usb2_temp_setup_by_index_p;

extern usb2_temp_unsetup_t *usb2_temp_unsetup_p;

extern usb2_test_quirk_t *usb2_test_quirk_p;

* This function converts an USB error code into a string.

*------------------------------------------------------------------------*/

const char *

{

return (err < USB_ERR_MAX ? usb_errstr_table[err] : "USB_ERR_UNKNOWN");

}

/* function prototypes */

static int ugen_transfer_setup(struct usb_fifo *,

const struct usb_config *, uint8_t);

ugen_default_write_callback(struct usb_xfer *xfer)

{

struct usb_fifo *f = xfer->priv_sc;

DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);

ugen_isoc_read_callback(struct usb_xfer *xfer)

{

struct usb_fifo *f = xfer->priv_sc;

DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);

ugen_isoc_write_callback(struct usb_xfer *xfer)

{

struct usb_fifo *f = xfer->priv_sc;

DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes);

struct usb_fs_endpoint fs_ep;

void *uaddr; /* userland pointer */

void *kaddr;

uint32_t length;

int error;

uint8_t isread;

struct usb_fs_endpoint *fs_ep_uptr; /* userland ptr */

void *uaddr; /* userland ptr */

void *kaddr;

uint32_t length;

uint32_t temp;

int error;

static int

ugen_set_buffer_size(struct usb_fifo *f, void *addr)

{

if (*(int *)addr < 0)

t = 0; /* use "wMaxPacketSize" */

/* function prototypes */

static uint8_t usb2_handle_get_stall(struct usb_device *, uint8_t);

uint8_t);

uint16_t *, struct usb_device_request, uint16_t,

uint8_t);

void

usb2_handle_request_callback(struct usb_xfer *xfer)

{

/* check the current transfer state */

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no)

{

struct usb_device *udev = xfer->xroot->udev;

/*

* We need to protect against other threads doing probe and

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_handle_iface_request(struct usb_xfer *xfer,

void **ppdata, uint16_t *plen,

struct usb_device_request req, uint16_t off, uint8_t state)

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall)

{

struct usb_device *udev = xfer->xroot->udev;

USB_XFER_UNLOCK(xfer);

err = usb2_set_endpoint_stall(udev,

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on)

{

struct usb_device *udev;

* 0: Ready to start hardware

* Else: Stall current transfer, if any

*------------------------------------------------------------------------*/

usb2_handle_request(struct usb_xfer *xfer)

{

struct usb_device_request req;

uint16_t wValue;

uint16_t wIndex;

uint8_t state;

union {

uWord wStatus;

uint8_t buf[2];

* hid_start_parse

*------------------------------------------------------------------------*/

struct hid_data *

{

struct hid_data *s;

* hid_report_size

*------------------------------------------------------------------------*/

int

{

struct hid_data *d;

struct hid_item h;

* hid_locate

*------------------------------------------------------------------------*/

int

uint8_t index, struct hid_location *loc, uint32_t *flags, uint8_t *id)

{

struct hid_data *d;

* hid_get_data

*------------------------------------------------------------------------*/

uint32_t

{

uint32_t hpos = loc->pos;

uint32_t hsize = loc->size;

* hid_is_collection

*------------------------------------------------------------------------*/

int

{

struct hid_data *hd;

struct hid_item hi;

* NULL: Failure.

* Else: Success. The pointer should eventually be passed to free().

*------------------------------------------------------------------------*/

usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,

void **descp, uint16_t *sizep,

{

struct usb_interface *iface = usb2_get_iface(udev, iface_index);

struct usb_hid_descriptor *hid;

if ((iface == NULL) || (iface->idesc == NULL)) {

return (USB_ERR_INVAL);

/* prototypes from "usb2_hid.c" */

void hid_end_parse(struct hid_data *s);

int hid_get_item(struct hid_data *s, struct hid_item *h);

uint8_t *id);

enum hid_kind kind, uint8_t index, struct hid_location *loc,

uint32_t *flags, uint8_t *id);

struct hid_location *loc);

struct usb_hid_descriptor *hid_get_descriptor_from_usb(

struct usb_config_descriptor *cd,

struct usb_interface_descriptor *id);

uint8_t iface_index);

#endif /* _USB2_CORE_HID_H_ */

static bus_child_location_str_t uhub_child_location_string;

static bus_child_pnpinfo_str_t uhub_child_pnpinfo_string;

static void usb2_dev_resume_peer(struct usb_device *udev);

static void usb2_dev_suspend_peer(struct usb_device *udev);

* 0: Success

* Else: A control transaction failed

*------------------------------------------------------------------------*/

uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up)

{

struct usb_bus *bus;

struct usb_device *child;

uint8_t refcount;

bus = sc->sc_udev->bus;

err = 0;

/*------------------------------------------------------------------------*

* uhub_read_port_status - factored out code

*------------------------------------------------------------------------*/

uhub_read_port_status(struct uhub_softc *sc, uint8_t portno)

{

struct usb_port_status ps;

err = usb2_req_get_port_status(

sc->sc_udev, NULL, &ps, portno);

* 0: Success

* Else: A control transaction failed

*------------------------------------------------------------------------*/

uhub_reattach_port(struct uhub_softc *sc, uint8_t portno)

{

struct usb_device *child;

struct usb_device *udev;

enum usb_dev_speed speed;

enum usb_hc_mode mode;

uint8_t timeout;

DPRINTF("reattaching port %d\n", portno);

* 0: Success

* Else: A control transaction failed

*------------------------------------------------------------------------*/

uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno)

{

struct usb_device *child;

struct usb_device *udev;

uint8_t is_suspend;

DPRINTF("port %d\n", portno);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

uhub_explore(struct usb_device *udev)

{

struct usb_hub *hub;

struct uhub_softc *sc;

struct usb_port *up;

uint8_t portno;

uint8_t x;

uint8_t portno;

uint8_t removable;

uint8_t iface_index;

sc->sc_udev = udev;

sc->sc_dev = dev;

* The best Transaction Translation slot for an interrupt endpoint.

*------------------------------------------------------------------------*/

static uint8_t

{

uint8_t x;

uint8_t y;

void

usb2_transfer_power_ref(struct usb_xfer *xfer, int val)

{

[UE_CONTROL] = USB_HW_POWER_CONTROL,

[UE_BULK] = USB_HW_POWER_BULK,

[UE_INTERRUPT] = USB_HW_POWER_INTERRUPT,

usb2_bus_powerd(struct usb_bus *bus)

{

struct usb_device *udev;

uint8_t x;

uint8_t rem_wakeup;

USB_BUS_UNLOCK(udev->bus);

if (udev->bus->methods->device_suspend != NULL) {

/* suspend device on the USB controller */

(udev->bus->methods->device_suspend) (udev);

struct usb_fs_isoc_schedule fs_isoc_schedule[USB_ISOC_TIME_MAX];

#endif

struct usb_device *hubudev; /* the HUB device */

void *hubsoftc;

uint16_t portpower; /* mA per USB port */

uint8_t isoc_last_time;

uint8_t nports;

* Else: Pointer to matching entry.

*------------------------------------------------------------------------*/

const struct usb_device_id *

const struct usb_lookup_info *info)

{

const struct usb_device_id *id_end;

* Else: Failure

*------------------------------------------------------------------------*/

int

struct usb_attach_arg *uaa)

{

id = usb2_lookup_id_by_info(id, sizeof_id, &uaa->info);

(((const uint8_t *)((did)->driver_info)) - ((const uint8_t *)0))

const struct usb_device_id *usb2_lookup_id_by_info(

const struct usb_lookup_info *info);

int usb2_lookup_id_by_uaa(const struct usb_device_id *id,

#endif /* _USB2_LOOKUP_H_ */

*------------------------------------------------------------------------*/

void *

usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,

{

struct usb_mbuf *m_ptr;

uint8_t *data_ptr;

void *free_ptr = NULL;

/* align data */

block_size += ((-block_size) & (USB_HOST_ALIGN - 1));

struct usb_mbuf *usb2_nextpkt;

struct usb_mbuf *usb2_next;

uint8_t last_packet:1;

uint8_t unused:7;

};

struct usb_mbuf *ifq_head;

struct usb_mbuf *ifq_tail;

};

#define USB_IF_ENQUEUE(ifq, m) do { \

/* prototypes */

void *usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq,

#endif /* _USB2_MBUF_H_ */

uint8_t *data_ptr;

uint8_t cmd_len; /* bytes */

uint8_t dir;

uint8_t buffer[256];

};

static const struct usb_config bbb_config[ST_MAX] = {

bbb_data_read_callback(struct usb_xfer *xfer)

{

struct bbb_transfer *sc = xfer->priv_sc;

switch (USB_GET_STATE(xfer)) {

case USB_ST_TRANSFERRED:

bbb_data_write_callback(struct usb_xfer *xfer)

{

struct bbb_transfer *sc = xfer->priv_sc;

switch (USB_GET_STATE(xfer)) {

case USB_ST_TRANSFERRED:

*------------------------------------------------------------------------*/

static uint8_t

bbb_command_start(struct bbb_transfer *sc, uint8_t dir, uint8_t lun,

{

sc->lun = lun;

sc->dir = data_len ? dir : DIR_NONE;

* 0: This interface is an auto install disk (CD-ROM)

* Else: Not an auto install disk.

*------------------------------------------------------------------------*/

usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index,

uint8_t do_eject)

{

struct usb_interface *iface;

struct usb_interface_descriptor *id;

uint8_t timeout;

uint8_t sid_type;

struct bbb_transfer *sc;

#ifndef _USB2_MSCTEST_H_

#define _USB2_MSCTEST_H_

uint8_t iface_index, uint8_t do_eject);

#endif /* _USB2_MSCTEST_H_ */

struct usb_proc_msg *pm0 = _pm0;

struct usb_proc_msg *pm1 = _pm1;

struct usb_proc_msg *pm2;

uint8_t t;

/* check if gone, return dummy value */

/* typedefs */

/*

* The following structure defines the USB process message header.

*/

struct usb_proc_msg {

TAILQ_ENTRY(usb_proc_msg) pm_qentry;

};

/*

struct thread *up_curtd;

struct mtx *up_mtx;

uint8_t up_prio;

uint8_t up_gone;

USB_BUS_UNLOCK(udev->bus);

}

usb2_get_hr_func(struct usb_device *udev)

{

/* figure out if there is a Handle Request function */

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx,

struct usb_device_request *req, void *data, uint16_t flags,

{

struct usb_xfer *xfer;

const void *desc;

int err = 0;

uint16_t length;

uint16_t temp;

if (mtx) {

mtx_lock(mtx);

}

}

/*------------------------------------------------------------------------*

* is assumed that the mutex associated with the process is locked

* when calling this function.

*------------------------------------------------------------------------*/

usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc,

struct usb_device_request *req, void *data, uint16_t flags,

{

uint16_t len;

/* get request data length */

* Else: Failure. No USB device is present and the USB port should be

* disabled.

*------------------------------------------------------------------------*/

usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port)

{

struct usb_port_status ps;

uint16_t n;

#if USB_DEBUG

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_desc(struct usb_device *udev,

struct mtx *mtx, uint16_t *actlen, void *desc,

uint16_t min_len, uint16_t max_len,

{

struct usb_device_request req;

uint8_t *buf;

DPRINTFN(4, "id=%d, type=%d, index=%d, max_len=%d\n",

id, type, index, max_len);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf,

uint16_t len, uint8_t string_index)

{

uint16_t n;

uint16_t c;

uint8_t swap;

if (len == 0) {

/* should not happen */

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc,

uint16_t max_len, uint16_t lang_id,

uint8_t string_index)

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_descriptor_ptr(struct usb_device *udev,

struct usb_config_descriptor **ppcd, uint16_t wValue)

{

struct usb_device_request req;

const void *ptr;

uint16_t len;

req.bmRequestType = UT_READ_DEVICE;

req.bRequest = UR_GET_DESCRIPTOR;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_config_desc(struct usb_device *udev, struct mtx *mtx,

struct usb_config_descriptor *d, uint8_t conf_index)

{

DPRINTFN(4, "confidx=%d\n", conf_index);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx,

struct usb_config_descriptor **ppcd, struct malloc_type *mtype,

uint8_t index)

struct usb_config_descriptor cd;

struct usb_config_descriptor *cdesc;

uint16_t len;

DPRINTFN(4, "index=%d\n", index);

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_device_desc(struct usb_device *udev, struct mtx *mtx,

struct usb_device_descriptor *d)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx,

uint8_t *alt_iface_no, uint8_t iface_index)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx,

uint8_t iface_index, uint8_t alt_no)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_device_status(struct usb_device *udev, struct mtx *mtx,

struct usb_status *st)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx,

struct usb_hub_descriptor *hd, uint8_t nports)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx,

struct usb_hub_status *st)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr)

{

struct usb_device_request req;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx,

struct usb_port_status *ps, uint8_t port)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx,

uint16_t sel)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx,

uint16_t sel)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx,

uint8_t port, uint16_t sel)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_port_feature(struct usb_device *udev, struct mtx *mtx,

uint8_t port, uint16_t sel)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx,

uint8_t iface_index, uint16_t report)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16_t len,

uint8_t iface_index, uint8_t type, uint8_t id)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data,

uint16_t len, uint8_t iface_index, uint8_t type, uint8_t id)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx,

uint8_t iface_index, uint8_t duration, uint8_t id)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx,

void *d, uint16_t size, uint8_t iface_index)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)

{

struct usb_device_request req;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf)

{

struct usb_device_request req;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx)

{

struct usb_device *parent_hub;

uint8_t old_addr;

uint8_t do_retry = 1;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx,

uint16_t sel)

{

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx,

uint16_t sel)

{

struct usb_process;

struct usb_device_request *req, void *data, uint16_t flags,

struct usb_device_request *req, void *data, uint16_t flags,

struct mtx *mtx, uint16_t sel);

struct mtx *mtx, uint8_t port, uint16_t sel);

struct mtx *mtx, uint8_t *alt_iface_no,

uint8_t iface_index);

uint8_t *pconf);

struct usb_config_descriptor **ppcd, uint16_t wValue);

struct usb_config_descriptor *d, uint8_t conf_index);

struct mtx *mtx, struct usb_config_descriptor **ppcd,

struct malloc_type *mtype, uint8_t conf_index);

uint16_t *actlen, void *desc, uint16_t min_len,

uint16_t max_len, uint16_t id, uint8_t type,

uint8_t index, uint8_t retries);

struct usb_device_descriptor *d);

struct mtx *mtx, struct usb_status *st);

struct mtx *mtx, struct usb_hub_descriptor *hd,

uint8_t nports);

struct usb_hub_status *st);

struct usb_port_status *ps, uint8_t port);

void *data, uint16_t len, uint8_t iface_index, uint8_t type,

uint8_t id);

struct mtx *mtx, void *d, uint16_t size,

uint8_t iface_index);

char *buf, uint16_t len, uint8_t string_index);

void *sdesc, uint16_t max_len, uint16_t lang_id,

uint8_t string_index);

uint8_t port);

uint16_t addr);

struct mtx *mtx, uint8_t iface_index, uint8_t alt_no);

uint8_t conf);

uint16_t sel);

uint8_t iface_index, uint8_t duration, uint8_t id);

struct mtx *mtx, uint8_t port, uint16_t sel);

uint8_t iface_index, uint16_t report);

void *data, uint16_t len, uint8_t iface_index,

uint8_t type, uint8_t id);

#define usb2_do_request(u,m,r,d) \

usb2_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT)

uint16_t fixed[4];

};

static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {

* 0: no DMA delay required

* Else: milliseconds of DMA delay

*------------------------------------------------------------------------*/

usb2_get_dma_delay(struct usb_bus *bus)

{

uint32_t temp = 0;

#if USB_HAVE_BUSDMA

uint8_t

usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,

{

struct usb_page_cache *pc;

struct usb_page *pg;

void *buf;

USB_ASSERT(align > 1, ("Invalid alignment, 0x%08x!\n",

align));

const struct usb_config *setup = parm->curr_setup;

struct usb_endpoint_descriptor *edesc;

struct usb2_std_packet_size std_size;

uint8_t type;

uint8_t zmps;

* 0: Success

* Else: Failure

*------------------------------------------------------------------------*/

usb2_transfer_setup(struct usb_device *udev,

const uint8_t *ifaces, struct usb_xfer **ppxfer,

const struct usb_config *setup_start, uint16_t n_setup,

/* sanity checks */

for (setup = setup_start, n = 0;

setup != setup_end; setup++, n++) {

parm.err = USB_ERR_BAD_BUFSIZE;

DPRINTF("invalid bufsize\n");

}

/* wait for any outstanding DMA operations */

if (needs_delay) {

temp = usb2_get_dma_delay(info->bus);

usb2_pause_mtx(&info->bus->bus_mtx,

USB_MS_TO_TICKS(temp));

static uint8_t

usb2_start_hardware_sub(struct usb_xfer *xfer)

{

/* Check for control endpoint stall */

if (xfer->flags.stall_pipe && xfer->flags_int.control_act) {

{

struct usb_xfer_root *info;

struct usb_bus *bus;

info = xfer->xroot;

bus = info->bus;

* than zero gives undefined results!

*------------------------------------------------------------------------*/

void

{

/* set virtual address to load and length */

xfer->frbuffers[frindex].buffer = ptr;

* of the USB DMA buffer allocated for this USB transfer.

*------------------------------------------------------------------------*/

void

{

USB_ASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "

"when the USB buffer is external!\n"));

* - This function is used to stop any USB transfer timeouts.

*------------------------------------------------------------------------*/

void

{

USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);

*------------------------------------------------------------------------*/

void

usb2_transfer_timeout_ms(struct usb_xfer *xfer,

{

USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);

usb2_callback_wrapper_sub(struct usb_xfer *xfer)

{

struct usb_pipe *pipe;

if ((!xfer->flags_int.open) &&

(!xfer->flags_int.did_close)) {

(xfer->error == USB_ERR_TIMEOUT)) &&

(!xfer->flags_int.did_dma_delay)) {

/* only delay once */

xfer->flags_int.did_dma_delay = 1;

struct usb_bus *bus; /* pointer to USB bus (cached) */

struct usb_device *udev; /* pointer to USB device */

#if USB_HAVE_BUSDMA

uint8_t dma_error; /* set if virtual memory could not be

* loaded */

#endif

const struct usb_config *curr_setup;

const struct usb_pipe_methods *methods;

void *buf;

uint16_t hc_max_frame_size;

uint16_t hc_max_packet_size;

uint8_t hc_max_packet_count;

enum usb_dev_speed speed;

uint8_t dma_tag_max;

};

/* function prototypes */

uint8_t usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm,

void usb2_command_wrapper(struct usb_xfer_queue *pq,

struct usb_xfer *xfer);

void usb2_pipe_enter(struct usb_xfer *xfer);

void usb2_pipe_start(struct usb_xfer_queue *pq);

void usb2_transfer_dequeue(struct usb_xfer *xfer);

void usb2_transfer_enqueue(struct usb_xfer_queue *pq,

struct usb_xfer *xfer);

void usb2_transfer_setup_sub(struct usb_setup_params *parm);

void usb2_clear_data_toggle(struct usb_device *udev,

struct usb_pipe *pipe);

void usb2_do_poll(struct usb_xfer **ppxfer, uint16_t max);

void usb2_transfer_timeout_ms(struct usb_xfer *xfer,

void usb2_transfer_power_ref(struct usb_xfer *xfer, int val);

#endif /* _USB2_TRANSFER_H_ */

struct usb_device *udev;

struct usb_interface *iface;

char *temp_p;

if (dev == NULL) {

/* should not happen */

static device_attach_t rum_attach;

static device_detach_t rum_detach;

struct usb_device_request *req, void *data);

static struct ieee80211vap *rum_vap_create(struct ieee80211com *,

const char name[IFNAMSIZ], int unit, int opmode,

static uint32_t rum_read(struct rum_softc *, uint16_t);

static void rum_read_multi(struct rum_softc *, uint16_t, void *,

int);

size_t);

static void rum_bbp_write(struct rum_softc *, uint8_t, uint8_t);

static uint8_t rum_bbp_read(struct rum_softc *, uint8_t);

return (0);

}

rum_do_request(struct rum_softc *sc,

struct usb_device_request *req, void *data)

{

int ntries = 10;

while (ntries--) {

rum_eeprom_read(struct rum_softc *sc, uint16_t addr, void *buf, int len)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = RT2573_READ_EEPROM;

rum_read_multi(struct rum_softc *sc, uint16_t reg, void *buf, int len)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = RT2573_READ_MULTI_MAC;

}

}

rum_write(struct rum_softc *sc, uint16_t reg, uint32_t val)

{

uint32_t tmp = htole32(val);

return (rum_write_multi(sc, reg, &tmp, sizeof tmp));

}

rum_write_multi(struct rum_softc *sc, uint16_t reg, void *buf, size_t len)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = RT2573_WRITE_MULTI_MAC;

struct ifnet *ifp = sc->sc_ifp;

struct ieee80211com *ic = ifp->if_l2com;

uint32_t tmp;

int i, ntries;

RUM_LOCK_ASSERT(sc, MA_OWNED);

{

struct usb_device_request req;

uint16_t reg = RT2573_MCU_CODE_BASE;

/* copy firmware image into NIC */

for (; size >= 4; reg += 4, ucode += 4, size -= 4) {

#undef UATH_DEV

};

static const struct usb_config uath_usbconfig[UATH_N_XFERS] = {

[UATH_INTR_RX] = {

struct ieee80211com *ic;

struct ifnet *ifp;

uint8_t bands, iface_index = UATH_IFACE_INDEX; /* XXX */

uint8_t macaddr[IEEE80211_ADDR_LEN];

sc->sc_dev = dev;

UPGT_DEV(ZCOM, XM142)

};

static const struct usb_config upgt_config[UPGT_N_XFERS] = {

[UPGT_BULK_TX] = {

{ USB_VP(USB_VENDOR_ZINWELL, USB_PRODUCT_ZINWELL_RT2570) },

};

struct usb_device_request *req, void *data);

static struct ieee80211vap *ural_vap_create(struct ieee80211com *,

const char name[IFNAMSIZ], int unit, int opmode,

return (0);

}

ural_do_request(struct ural_softc *sc,

struct usb_device_request *req, void *data)

{

int ntries = 10;

while (ntries--) {

ural_set_testmode(struct ural_softc *sc)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = RAL_VENDOR_REQUEST;

ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = RAL_READ_EEPROM;

ural_read(struct ural_softc *sc, uint16_t reg)

{

struct usb_device_request req;

uint16_t val;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = RAL_READ_MULTI_MAC;

ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = RAL_WRITE_MAC;

ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)

{

struct usb_device_request req;

req.bmRequestType = UT_WRITE_VENDOR_DEVICE;

req.bRequest = RAL_WRITE_MULTI_MAC;

{ 0x8d, 0x10, 0 }, { 0x8e, 0x08, 0 }, { 0x8f, 0x00, 0 }

};

static const struct usb_config urtw_8187b_usbconfig[URTW_8187B_N_XFERS] = {

[URTW_8187B_BULK_RX] = {

static int urtw_isbmode(uint16_t);

static uint16_t urtw_rate2rtl(int);

static uint16_t urtw_rtl2rate(int);

int);

uint32_t *);

uint32_t);

uint8_t, uint32_t);

uint32_t);

uint16_t);

uint16_t *);

uint32_t *);

static void urtw_free_tx_data_list(struct urtw_softc *);

static void urtw_free_rx_data_list(struct urtw_softc *);

static void urtw_free_data_list(struct urtw_softc *,

struct urtw_data data[], int, int);

struct usb_device_request *, void *);

static void urtw_abort_xfers(struct urtw_softc *);

static struct urtw_data *

urtw_getbuf(struct urtw_softc *sc);

uint8_t bands, iface_index = URTW_IFACE_INDEX; /* XXX */

uint16_t n_setup;

uint32_t data;

device_set_usb2_desc(dev);

int ret;

struct urtw_softc *sc = arg;

struct ifnet *ifp = sc->sc_ifp;

if (ifp->if_drv_flags & IFF_DRV_RUNNING)

urtw_stop_locked(ifp, 0);

URTW_UNLOCK(sc);

}

urtw_adapter_start_b(struct urtw_softc *sc)

{

#define N(a) (sizeof(a) / sizeof((a)[0]))

int i;

uint8_t data8;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

#undef N

}

urtw_adapter_start(struct urtw_softc *sc)

{

error = urtw_reset(sc);

if (error)

return (error);

}

urtw_set_mode(struct urtw_softc *sc, uint32_t mode)

{

uint8_t data;

urtw_read8_m(sc, URTW_EPROM_CMD, &data);

data = (data & ~URTW_EPROM_CMD_MASK) | (mode << URTW_EPROM_CMD_SHIFT);

return (error);

}

urtw_8187b_cmd_reset(struct urtw_softc *sc)

{

int i;

uint8_t data8;

/* XXX the code can be duplicate with urtw_reset(). */

urtw_read8_m(sc, URTW_CMD, &data8);

return (error);

}

urtw_write16_i(struct urtw_softc *sc, int val, uint16_t data, int idx)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_do_request(struct urtw_softc *sc,

struct usb_device_request *req, void *data)

{

int ntries = 10;

URTW_ASSERT_LOCKED(sc);

return (err);

}

urtw_write8_i(struct urtw_softc *sc, int val, uint8_t data, int idx)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_write32_i(struct urtw_softc *sc, int val, uint32_t data, int idx)

{

struct usb_device_request req;

{

struct urtw_softc *sc = ifp->if_softc;

uint8_t data8;

(void)disable;

ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);

struct urtw_softc *sc = ic->ic_ifp->if_softc;

struct ifnet *ifp = sc->sc_ifp;

uint32_t data, orig;

/*

* if the user set a channel explicitly using ifconfig(8) this function

sc->sc_xfer[URTW_8187B_BULK_TX_VO]

};

struct usb_xfer *xfer;

URTW_ASSERT_LOCKED(sc);

struct ieee80211com *ic = vap->iv_ic;

struct urtw_softc *sc = ic->ic_ifp->if_softc;

struct urtw_vap *uvp = URTW_VAP(vap);

DPRINTF(sc, URTW_DEBUG_STATE, "%s: %s -> %s\n", __func__,

ieee80211_state_name[vap->iv_state],

IF_ADDR_UNLOCK(ifp);

}

urtw_set_rate(struct urtw_softc *sc)

{

int i, basic_rate, min_rr_rate, max_rr_rate;

uint16_t data;

basic_rate = urtw_rate2rtl(48);

min_rr_rate = urtw_rate2rtl(12);

#undef N

}

urtw_update_msr(struct urtw_softc *sc)

{

struct ifnet *ifp = sc->sc_ifp;

struct ieee80211com *ic = ifp->if_l2com;

uint8_t data;

urtw_read8_m(sc, URTW_MSR, &data);

data &= ~URTW_MSR_LINK_MASK;

return (error);

}

urtw_read8_c(struct urtw_softc *sc, int val, uint8_t *data)

{

struct usb_device_request req;

URTW_ASSERT_LOCKED(sc);

return (error);

}

urtw_read16_c(struct urtw_softc *sc, int val, uint16_t *data)

{

struct usb_device_request req;

URTW_ASSERT_LOCKED(sc);

return (error);

}

urtw_read32_c(struct urtw_softc *sc, int val, uint32_t *data)

{

struct usb_device_request req;

URTW_ASSERT_LOCKED(sc);

return (error);

}

urtw_write8_c(struct urtw_softc *sc, int val, uint8_t data)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_write16_c(struct urtw_softc *sc, int val, uint16_t data)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_write32_c(struct urtw_softc *sc, int val, uint32_t data)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_get_macaddr(struct urtw_softc *sc)

{

uint32_t data;

error = urtw_eprom_read32(sc, URTW_EPROM_MACADDR, &data);

if (error != 0)

return (error);

}

urtw_eprom_read32(struct urtw_softc *sc, uint32_t addr, uint32_t *data)

{

#define URTW_READCMD_LEN 3

int addrlen, i;

int16_t addrstr[8], data16, readcmd[] = { 1, 1, 0 };

/* NB: make sure the buffer is initialized */

*data = 0;

#undef URTW_READCMD_LEN

}

urtw_eprom_cs(struct urtw_softc *sc, int able)

{

uint8_t data;

urtw_read8_m(sc, URTW_EPROM_CMD, &data);

if (able == URTW_EPROM_ENABLE)

return (error);

}

urtw_eprom_ck(struct urtw_softc *sc)

{

uint8_t data;

/* masking */

urtw_read8_m(sc, URTW_EPROM_CMD, &data);

return (error);

}

urtw_eprom_readbit(struct urtw_softc *sc, int16_t *data)

{

uint8_t data8;

urtw_read8_m(sc, URTW_EPROM_CMD, &data8);

*data = (data8 & URTW_EPROM_READBIT) ? 1 : 0;

return (error);

}

urtw_eprom_writebit(struct urtw_softc *sc, int16_t bit)

{

uint8_t data;

urtw_read8_m(sc, URTW_EPROM_CMD, &data);

if (bit != 0)

return (error);

}

urtw_eprom_sendbits(struct urtw_softc *sc, int16_t *buf, int buflen)

{

int i = 0;

for (i = 0; i < buflen; i++) {

error = urtw_eprom_writebit(sc, buf[i]);

}

urtw_get_txpwr(struct urtw_softc *sc)

{

int i, j;

uint32_t data;

error = urtw_eprom_read32(sc, URTW_EPROM_TXPW_BASE, &data);

if (error != 0)

}

urtw_get_rfchip(struct urtw_softc *sc)

{

int ret;

uint8_t data8;

uint32_t data;

error = urtw_eprom_read32(sc, URTW_EPROM_RFCHIPID, &data);

if (error != 0)

}

urtw_led_init(struct urtw_softc *sc)

{

uint32_t rev;

urtw_read8_m(sc, URTW_PSR, &sc->sc_psr);

error = urtw_eprom_read32(sc, URTW_EPROM_SWREV, &rev);

}

urtw_8225_rf_init(struct urtw_softc *sc)

{

#define N(a) (sizeof(a) / sizeof((a)[0]))

int i;

uint16_t data;

error = urtw_8180_set_anaparam(sc, URTW_8225_ANAPARAM_ON);

if (error)

#undef N

}

urtw_8185_rf_pins_enable(struct urtw_softc *sc)

{

urtw_write16_m(sc, URTW_RF_PINS_ENABLE, 0x1ff7);

fail:

return (error);

}

urtw_8185_tx_antenna(struct urtw_softc *sc, uint8_t ant)

{

urtw_write8_m(sc, URTW_TX_ANTENNA, ant);

usb2_pause_mtx(&sc->sc_mtx, 1);

return (error);

}

urtw_8187_write_phy_ofdm_c(struct urtw_softc *sc, uint8_t addr, uint32_t data)

{

return urtw_8187_write_phy(sc, addr, data);

}

urtw_8187_write_phy_cck_c(struct urtw_softc *sc, uint8_t addr, uint32_t data)

{

return urtw_8187_write_phy(sc, addr, data | 0x10000);

}

urtw_8187_write_phy(struct urtw_softc *sc, uint8_t addr, uint32_t data)

{

uint32_t phyw;

phyw = ((data << 8) | (addr | 0x80));

urtw_write8_m(sc, URTW_PHY_MAGIC4, ((phyw & 0xff000000) >> 24));

return (error);

}

urtw_8225_setgain(struct urtw_softc *sc, int16_t gain)

{

urtw_8187_write_phy_ofdm(sc, 0x0d, urtw_8225_gain[gain * 4]);

urtw_8187_write_phy_ofdm(sc, 0x1b, urtw_8225_gain[gain * 4 + 2]);

return (error);

}

urtw_8225_usb_init(struct urtw_softc *sc)

{

uint8_t data;

urtw_write8_m(sc, URTW_RF_PINS_SELECT + 1, 0);

urtw_write8_m(sc, URTW_GPIO, 0);

return (error);

}

urtw_8225_write_c(struct urtw_softc *sc, uint8_t addr, uint16_t data)

{

uint16_t d80, d82, d84;

urtw_read16_m(sc, URTW_RF_PINS_OUTPUT, &d80);

d80 &= URTW_RF_PINS_MAGIC1;

}

/* XXX why we should allocalte memory buffer instead of using memory stack? */

urtw_8225_write_s16(struct urtw_softc *sc, uint8_t addr, int index,

uint16_t *data)

{

uint8_t *buf;

uint16_t data16;

struct usb_device_request *req;

data16 = *data;

req = (usb_device_request_t *)malloc(sizeof(usb_device_request_t),

fail0: return (error);

}

urtw_8225_rf_set_chan(struct urtw_softc *sc, int chan)

{

struct ieee80211com *ic = sc->sc_ifp->if_l2com;

struct ieee80211_channel *c = ic->ic_curchan;

error = urtw_8225_set_txpwrlvl(sc, chan);

if (error)

return (error);

}

urtw_8225_rf_set_sens(struct urtw_softc *sc, int sens)

{

if (sens < 0 || sens > 6)

return -1;

return (error);

}

urtw_8225_set_txpwrlvl(struct urtw_softc *sc, int chan)

{

int i, idx, set;

uint8_t cck_pwrlvl_max, ofdm_pwrlvl_min, ofdm_pwrlvl_max;

uint8_t cck_pwrlvl = sc->sc_txpwr_cck[chan] & 0xff;

uint8_t ofdm_pwrlvl = sc->sc_txpwr_ofdm[chan] & 0xff;

cck_pwrlvl_max = 11;

ofdm_pwrlvl_max = 25; /* 12 -> 25 */

}

urtw_8225_rf_stop(struct urtw_softc *sc)

{

uint8_t data;

urtw_8225_write(sc, 0x4, 0x1f);

return (error);

}

urtw_8225v2_rf_init(struct urtw_softc *sc)

{

#define N(a) (sizeof(a) / sizeof((a)[0]))

int i;

uint16_t data;

uint32_t data32;

error = urtw_8180_set_anaparam(sc, URTW_8225_ANAPARAM_ON);

if (error)

#undef N

}

urtw_8225v2_rf_set_chan(struct urtw_softc *sc, int chan)

{

struct ieee80211com *ic = sc->sc_ifp->if_l2com;

struct ieee80211_channel *c = ic->ic_curchan;

error = urtw_8225v2_set_txpwrlvl(sc, chan);

if (error)

return (error);

}

urtw_8225_read(struct urtw_softc *sc, uint8_t addr, uint32_t *data)

{

int i;

uint16_t o1, o2, o3, tmp;

uint32_t d2w = ((uint32_t)(addr & 0x1f)) << 27;

uint32_t mask = 0x80000000, value = 0;

urtw_read16_m(sc, URTW_RF_PINS_OUTPUT, &o1);

urtw_read16_m(sc, URTW_RF_PINS_ENABLE, &o2);

}

urtw_8225v2_set_txpwrlvl(struct urtw_softc *sc, int chan)

{

int i;

uint8_t cck_pwrlvl_max = 15, ofdm_pwrlvl_max = 25, ofdm_pwrlvl_min = 10;

uint8_t cck_pwrlvl = sc->sc_txpwr_cck[chan] & 0xff;

uint8_t ofdm_pwrlvl = sc->sc_txpwr_ofdm[chan] & 0xff;

/* CCK power setting */

cck_pwrlvl = (cck_pwrlvl > cck_pwrlvl_max) ? cck_pwrlvl_max : cck_pwrlvl;

return (error);

}

urtw_8225v2_setgain(struct urtw_softc *sc, int16_t gain)

{

uint8_t *gainp;

/* XXX for A? */

gainp = urtw_8225v2_gain_bg;

return (error);

}

urtw_8225_isv2(struct urtw_softc *sc, int *ret)

{

uint32_t data;

*ret = 1;

return (error);

}

urtw_8225v2b_rf_init(struct urtw_softc *sc)

{

#define N(a) (sizeof(a) / sizeof((a)[0]))

int i;

for (i = 0; i < N(urtw_8225v2b_rf_part1); i++)

urtw_8225_write(sc, urtw_8225v2b_rf_part1[i].reg,

#undef N

}

urtw_8225v2b_rf_set_chan(struct urtw_softc *sc, int chan)

{

int ack;

struct ieee80211com *ic = sc->sc_ifp->if_l2com;

error = urtw_8225v2b_set_txpwrlvl(sc, chan);

if (error)

return (error);

}

urtw_8225v2b_set_txpwrlvl(struct urtw_softc *sc, int chan)

{

int i;

uint8_t cck_pwrlvl_max = 15;

uint8_t cck_pwrlvl = sc->sc_txpwr_cck[chan] & 0xff;

uint8_t ofdm_pwrlvl = sc->sc_txpwr_ofdm[chan] & 0xff;

/* CCK power setting */

cck_pwrlvl = (cck_pwrlvl > cck_pwrlvl_max) ?

return (error);

}

urtw_read8e(struct urtw_softc *sc, int val, uint8_t *data)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = URTW_8187_GETREGS_REQ;

return (error);

}

urtw_write8e(struct urtw_softc *sc, int val, uint8_t data)

{

struct usb_device_request req;

return (urtw_do_request(sc, &req, &data));

}

urtw_8180_set_anaparam(struct urtw_softc *sc, uint32_t val)

{

uint8_t data;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

return (error);

}

urtw_8185_set_anaparam2(struct urtw_softc *sc, uint32_t val)

{

uint8_t data;

error = urtw_set_mode(sc, URTW_EPROM_CMD_CONFIG);

if (error)

return (error);

}

urtw_intr_enable(struct urtw_softc *sc)

{

urtw_write16_m(sc, URTW_INTR_MASK, 0xffff);

fail:

return (error);

}

urtw_intr_disable(struct urtw_softc *sc)

{

urtw_write16_m(sc, URTW_INTR_MASK, 0);

fail:

return (error);

}

urtw_reset(struct urtw_softc *sc)

{

uint8_t data;

error = urtw_8180_set_anaparam(sc, URTW_8225_ANAPARAM_ON);

if (error)

return (error);

}

urtw_led_ctl(struct urtw_softc *sc, int mode)

{

switch (sc->sc_strategy) {

case URTW_SW_LED_MODE0:

return (error);

}

urtw_led_mode0(struct urtw_softc *sc, int mode)

{

return (0);

}

urtw_led_mode1(struct urtw_softc *sc, int mode)

{

return (USB_ERR_INVAL);

}

urtw_led_mode2(struct urtw_softc *sc, int mode)

{

return (USB_ERR_INVAL);

}

urtw_led_mode3(struct urtw_softc *sc, int mode)

{

return (USB_ERR_INVAL);

}

urtw_led_on(struct urtw_softc *sc, int type)

{

if (type == URTW_LED_GPIO) {

switch (sc->sc_gpio_ledpin) {

return (error);

}

urtw_led_off(struct urtw_softc *sc, int type)

{

if (type == URTW_LED_GPIO) {

switch (sc->sc_gpio_ledpin) {

URTW_UNLOCK(sc);

}

urtw_led_blink(struct urtw_softc *sc)

{

uint8_t ing = 0;

if (sc->sc_gpio_blinkstate == URTW_LED_ON)

error = urtw_led_on(sc, URTW_LED_GPIO);

return (0);

}

urtw_rx_enable(struct urtw_softc *sc)

{

uint8_t data;

usb2_transfer_start((sc->sc_flags & URTW_RTL8187B) ?

sc->sc_xfer[URTW_8187B_BULK_RX] : sc->sc_xfer[URTW_8187L_BULK_RX]);

return (error);

}

urtw_tx_enable(struct urtw_softc *sc)

{

uint8_t data8;

uint32_t data;

if (sc->sc_flags & URTW_RTL8187B) {

urtw_read32_m(sc, URTW_TX_CONF, &data);

return (error);

}

urtw_rx_setconf(struct urtw_softc *sc)

{

struct ifnet *ifp = sc->sc_ifp;

struct ieee80211com *ic = ifp->if_l2com;

uint32_t data;

urtw_read32_m(sc, URTW_RX, &data);

data = data &~ URTW_RX_FILTER_MASK;

struct ieee80211_channel *sc_curchan;

/* for RF */

int);

int);

uint8_t sc_rfchip;

uint32_t sc_max_sens;

uint32_t sc_sens;

static device_attach_t zyd_attach;

static device_detach_t zyd_detach;

static struct ieee80211vap *zyd_vap_create(struct ieee80211com *,

const char name[IFNAMSIZ], int unit, int opmode,

zyd_get_macaddr(struct zyd_softc *sc)

{

struct usb_device_request req;

req.bmRequestType = UT_READ_VENDOR_DEVICE;

req.bRequest = ZYD_READFWDATAREQ;

****************************************************************************/

/* USB methods */

static int ubt_fwd_mbuf_up(ubt_softc_p, struct mbuf **);

static int ubt_isoc_read_one_frame(struct usb_xfer *, int);

static device_attach_t ubtbcmfw_attach;

static device_detach_t ubtbcmfw_detach;

static struct usb_fifo_methods ubtbcmfw_fifo_methods =

{