From 06303d491a0f2982d6774156ea92ce9b41f9b12c Mon Sep 17 00:00:00 2001 From: thompsa Date: Mon, 15 Jun 2009 01:02:43 +0000 Subject: s/usb2_/usb_|usbd_/ on all function names for the USB stack. --- sys/compat/ndis/subr_usbd.c | 54 +-- sys/dev/ata/ata-usb.c | 46 +- sys/dev/if_ndis/if_ndis_usb.c | 6 +- sys/dev/sound/usb/uaudio.c | 148 +++---- sys/dev/usb/controller/at91dci.c | 24 +- sys/dev/usb/controller/at91dci_atmelarm.c | 6 +- sys/dev/usb/controller/atmegadci.c | 26 +- sys/dev/usb/controller/atmegadci_atmelarm.c | 4 +- sys/dev/usb/controller/avr32dci.c | 24 +- sys/dev/usb/controller/ehci.c | 214 +++++----- sys/dev/usb/controller/ehci_ixp4xx.c | 4 +- sys/dev/usb/controller/ehci_mbus.c | 4 +- sys/dev/usb/controller/ehci_pci.c | 6 +- sys/dev/usb/controller/musb_otg.c | 40 +- sys/dev/usb/controller/musb_otg_atmelarm.c | 4 +- sys/dev/usb/controller/ohci.c | 130 +++--- sys/dev/usb/controller/ohci_atmelarm.c | 4 +- sys/dev/usb/controller/ohci_pci.c | 4 +- sys/dev/usb/controller/uhci.c | 154 +++---- sys/dev/usb/controller/uhci_pci.c | 4 +- sys/dev/usb/controller/usb_controller.c | 198 ++++----- sys/dev/usb/controller/uss820dci.c | 22 +- sys/dev/usb/controller/uss820dci_atmelarm.c | 4 +- sys/dev/usb/input/uhid.c | 74 ++-- sys/dev/usb/input/ukbd.c | 50 +-- sys/dev/usb/input/ums.c | 50 +-- sys/dev/usb/misc/udbp.c | 48 +-- sys/dev/usb/misc/ufm.c | 12 +- sys/dev/usb/net/if_aue.c | 100 ++--- sys/dev/usb/net/if_auereg.h | 4 +- sys/dev/usb/net/if_axe.c | 112 ++--- sys/dev/usb/net/if_axereg.h | 2 +- sys/dev/usb/net/if_cdce.c | 76 ++-- sys/dev/usb/net/if_cue.c | 82 ++-- sys/dev/usb/net/if_kue.c | 82 ++-- sys/dev/usb/net/if_rue.c | 84 ++-- sys/dev/usb/net/if_ruereg.h | 2 +- sys/dev/usb/net/if_udav.c | 78 ++-- sys/dev/usb/net/if_udavreg.h | 2 +- sys/dev/usb/net/usb_ethernet.c | 66 +-- sys/dev/usb/net/usb_ethernet.h | 32 +- sys/dev/usb/quirk/usb_quirk.c | 128 +++--- sys/dev/usb/serial/u3g.c | 66 +-- sys/dev/usb/serial/uark.c | 56 +-- sys/dev/usb/serial/ubsa.c | 68 +-- sys/dev/usb/serial/ubser.c | 58 +-- sys/dev/usb/serial/uchcom.c | 68 +-- sys/dev/usb/serial/ucycom.c | 62 +-- sys/dev/usb/serial/ufoma.c | 134 +++--- sys/dev/usb/serial/uftdi.c | 76 ++-- sys/dev/usb/serial/ugensa.c | 56 +-- sys/dev/usb/serial/uipaq.c | 58 +-- sys/dev/usb/serial/ulpt.c | 80 ++-- sys/dev/usb/serial/umct.c | 64 +-- sys/dev/usb/serial/umodem.c | 80 ++-- sys/dev/usb/serial/umoscom.c | 68 +-- sys/dev/usb/serial/uplcom.c | 90 ++-- sys/dev/usb/serial/usb_serial.c | 318 +++++++------- sys/dev/usb/serial/usb_serial.h | 50 +-- sys/dev/usb/serial/uslcom.c | 72 ++-- sys/dev/usb/serial/uvisor.c | 64 +-- sys/dev/usb/serial/uvscom.c | 76 ++-- sys/dev/usb/storage/umass.c | 96 ++--- sys/dev/usb/storage/urio.c | 56 +-- sys/dev/usb/storage/ustorage_fs.c | 36 +- sys/dev/usb/template/usb_template.c | 232 +++++----- sys/dev/usb/template/usb_template.h | 14 +- sys/dev/usb/template/usb_template_cdce.c | 4 +- sys/dev/usb/template/usb_template_msc.c | 4 +- sys/dev/usb/template/usb_template_mtp.c | 6 +- sys/dev/usb/usb_busdma.c | 194 ++++----- sys/dev/usb/usb_busdma.h | 44 +- sys/dev/usb/usb_compat_linux.c | 62 +-- sys/dev/usb/usb_compat_linux.h | 2 +- sys/dev/usb/usb_controller.h | 12 +- sys/dev/usb/usb_core.h | 82 ++-- sys/dev/usb/usb_debug.c | 38 +- sys/dev/usb/usb_debug.h | 12 +- sys/dev/usb/usb_dev.c | 466 ++++++++++----------- sys/dev/usb/usb_dev.h | 48 +-- sys/dev/usb/usb_device.c | 400 +++++++++--------- sys/dev/usb/usb_device.h | 36 +- sys/dev/usb/usb_dynamic.c | 66 +-- sys/dev/usb/usb_dynamic.h | 36 +- sys/dev/usb/usb_error.c | 4 +- sys/dev/usb/usb_generic.c | 166 ++++---- sys/dev/usb/usb_generic.h | 2 +- sys/dev/usb/usb_handle_request.c | 104 ++--- sys/dev/usb/usb_hid.c | 14 +- sys/dev/usb/usb_hid.h | 4 +- sys/dev/usb/usb_hub.c | 236 +++++------ sys/dev/usb/usb_hub.h | 16 +- sys/dev/usb/usb_lookup.c | 14 +- sys/dev/usb/usb_lookup.h | 6 +- sys/dev/usb/usb_mbuf.c | 4 +- sys/dev/usb/usb_mbuf.h | 16 +- sys/dev/usb/usb_msctest.c | 42 +- sys/dev/usb/usb_msctest.h | 2 +- sys/dev/usb/usb_parse.c | 28 +- sys/dev/usb/usb_parse.h | 10 +- sys/dev/usb/usb_process.c | 34 +- sys/dev/usb/usb_process.h | 12 +- sys/dev/usb/usb_request.c | 304 +++++++------- sys/dev/usb/usb_request.h | 66 +-- sys/dev/usb/usb_transfer.c | 394 ++++++++--------- sys/dev/usb/usb_transfer.h | 34 +- sys/dev/usb/usb_util.c | 24 +- sys/dev/usb/usb_util.h | 10 +- sys/dev/usb/wlan/if_rum.c | 64 +-- sys/dev/usb/wlan/if_uath.c | 40 +- sys/dev/usb/wlan/if_upgt.c | 32 +- sys/dev/usb/wlan/if_ural.c | 70 ++-- sys/dev/usb/wlan/if_urtw.c | 136 +++--- sys/dev/usb/wlan/if_zyd.c | 66 +-- sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c | 62 +-- sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c | 42 +- 116 files changed, 3941 insertions(+), 3941 deletions(-) (limited to 'sys') diff --git a/sys/compat/ndis/subr_usbd.c b/sys/compat/ndis/subr_usbd.c index a9d4376..de40cd3 100644 --- a/sys/compat/ndis/subr_usbd.c +++ b/sys/compat/ndis/subr_usbd.c @@ -472,7 +472,7 @@ usbd_func_getdesc(ip) * The NDIS driver is not allowed to change the * config! There is only one choice! */ - cdp = usb2_get_config_descriptor(sc->ndisusb_dev); + cdp = usbd_get_config_descriptor(sc->ndisusb_dev); if (cdp == NULL) { status = USB_ERR_INVAL; goto exit; @@ -492,7 +492,7 @@ usbd_func_getdesc(ip) status = USB_ERR_NORMAL_COMPLETION; } else { NDISUSB_LOCK(sc); - status = usb2_req_get_desc(sc->ndisusb_dev, &sc->ndisusb_mtx, + status = usbd_req_get_desc(sc->ndisusb_dev, &sc->ndisusb_mtx, &actlen, ctldesc->ucd_trans_buf, 2, ctldesc->ucd_trans_buflen, ctldesc->ucd_langid, ctldesc->ucd_desctype, ctldesc->ucd_idx, @@ -540,16 +540,16 @@ usbd_func_selconf(ip) intf = &selconf->usc_intf; for (i = 0; i < conf->bNumInterface && intf->uii_len > 0; i++) { - ret = usb2_set_alt_interface_index(udev, + ret = usbd_set_alt_interface_index(udev, intf->uii_intfnum, intf->uii_altset); if (ret != USB_ERR_NORMAL_COMPLETION && ret != USB_ERR_IN_USE) { device_printf(dev, "setting alternate interface failed: %s\n", - usb2_errstr(ret)); + usbd_errstr(ret)); return usbd_usb2urb(ret); } - for (j = 0; (ep = usb2_endpoint_foreach(udev, ep)); j++) { + for (j = 0; (ep = usb_endpoint_foreach(udev, ep)); j++) { if (j >= intf->uii_numeps) { device_printf(dev, "endpoint %d and above are ignored", @@ -608,11 +608,11 @@ usbd_setup_endpoint_one(ip, ifidx, ne, epconf) InitializeListHead(&ne->ne_pending); KeInitializeSpinLock(&ne->ne_lock); - status = usb2_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, + status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, epconf, 1, sc, &sc->ndisusb_mtx); if (status != USB_ERR_NORMAL_COMPLETION) { device_printf(dev, "couldn't setup xfer: %s\n", - usb2_errstr(status)); + usbd_errstr(status)); return (status); } xfer = ne->ne_xfer[0]; @@ -680,11 +680,11 @@ usbd_setup_endpoint(ip, ifidx, ep) if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN) cfg.flags.short_xfer_ok = 1; - status = usb2_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, + status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, &cfg, 1, sc, &sc->ndisusb_mtx); if (status != USB_ERR_NORMAL_COMPLETION) { device_printf(dev, "couldn't setup xfer: %s\n", - usb2_errstr(status)); + usbd_errstr(status)); return (status); } xfer = ne->ne_xfer[0]; @@ -718,8 +718,8 @@ usbd_func_abort_pipe(ip) } NDISUSB_LOCK(sc); - usb2_transfer_stop(ne->ne_xfer[0]); - usb2_transfer_start(ne->ne_xfer[0]); + usbd_transfer_stop(ne->ne_xfer[0]); + usbd_transfer_start(ne->ne_xfer[0]); NDISUSB_UNLOCK(sc); return (USBD_STATUS_SUCCESS); @@ -800,8 +800,8 @@ usbd_irpcancel(dobj, ip) * cancelled and then restarted. */ NDISUSB_LOCK(sc); - usb2_transfer_stop(ne->ne_xfer[0]); - usb2_transfer_start(ne->ne_xfer[0]); + usbd_transfer_stop(ne->ne_xfer[0]); + usbd_transfer_start(ne->ne_xfer[0]); NDISUSB_UNLOCK(sc); ip->irp_cancel = TRUE; @@ -873,7 +873,7 @@ usbd_non_isoc_callback(struct usb_xfer *xfer) /* copy in data with regard to the URB */ if (ne->ne_dirin != 0) - usb2_copy_out(xfer->frbuffers, 0, nx->nx_urbbuf, + usbd_copy_out(xfer->frbuffers, 0, nx->nx_urbbuf, xfer->frlengths[0]); nx->nx_urbbuf += xfer->frlengths[0]; nx->nx_urbactlen += xfer->frlengths[0]; @@ -929,10 +929,10 @@ next: extra: len = MIN(xfer->max_data_length, nx->nx_urblen); if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_OUT) - usb2_copy_in(xfer->frbuffers, 0, nx->nx_urbbuf, len); + usbd_copy_in(xfer->frbuffers, 0, nx->nx_urbbuf, len); xfer->frlengths[0] = len; xfer->nframes = 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: nx = usbd_aq_getfirst(sc, ne); @@ -941,7 +941,7 @@ extra: if (xfer->error != USB_ERR_CANCELLED) { xfer->flags.stall_pipe = 1; device_printf(sc->ndis_dev, "usb xfer warning (%s)\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); } usbd_xfer_complete(sc, ne, nx, xfer->error); if (xfer->error != USB_ERR_CANCELLED) @@ -974,7 +974,7 @@ usbd_ctrl_callback(struct usb_xfer *xfer) vcreq = &urb->uu_vcreq; if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) { - usb2_copy_out(xfer->frbuffers + 1, 0, + usbd_copy_out(xfer->frbuffers + 1, 0, vcreq->uvc_trans_buf, xfer->frlengths[1]); nx->nx_urbactlen += xfer->frlengths[1]; } @@ -1044,7 +1044,7 @@ next: nx->nx_urblen = vcreq->uvc_trans_buflen; nx->nx_urbactlen = 0; - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->nframes = 1; if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) { @@ -1066,13 +1066,13 @@ next: * the future if it needs to be. */ if (nx->nx_urblen > 0) { - usb2_copy_in(xfer->frbuffers + 1 , 0, + usbd_copy_in(xfer->frbuffers + 1 , 0, nx->nx_urbbuf, nx->nx_urblen); xfer->frlengths[1] = nx->nx_urblen; xfer->nframes = 2; } } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: nx = usbd_aq_getfirst(sc, ne); @@ -1081,7 +1081,7 @@ next: if (xfer->error != USB_ERR_CANCELLED) { xfer->flags.stall_pipe = 1; device_printf(sc->ndis_dev, "usb xfer warning (%s)\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); } usbd_xfer_complete(sc, ne, nx, xfer->error); if (xfer->error != USB_ERR_CANCELLED) @@ -1244,7 +1244,7 @@ usbd_task(dobj, arg) ne = usbd_get_ndisep(ip, urb->uu_bulkintr.ubi_epdesc); if (ne == NULL) goto exit; - usb2_transfer_start(ne->ne_xfer[0]); + usbd_transfer_start(ne->ne_xfer[0]); break; case NDISUSB_TASK_IRPCANCEL: ne = usbd_get_ndisep(ip, @@ -1254,14 +1254,14 @@ usbd_task(dobj, arg) if (ne == NULL) goto exit; - usb2_transfer_stop(ne->ne_xfer[0]); - usb2_transfer_start(ne->ne_xfer[0]); + usbd_transfer_stop(ne->ne_xfer[0]); + usbd_transfer_start(ne->ne_xfer[0]); break; case NDISUSB_TASK_VENDOR: ne = (urb->uu_vcreq.uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) ? &sc->ndisusb_dread_ep : &sc->ndisusb_dwrite_ep; - usb2_transfer_start(ne->ne_xfer[0]); + usbd_transfer_start(ne->ne_xfer[0]); break; default: break; @@ -1437,7 +1437,7 @@ USBD_ParseConfigurationDescriptorEx(conf, start, intfnum, struct usb_descriptor *next = NULL; usb_interface_descriptor_t *desc; - while ((next = usb2_desc_foreach(conf, next)) != NULL) { + while ((next = usb_desc_foreach(conf, next)) != NULL) { desc = (usb_interface_descriptor_t *)next; if (desc->bDescriptorType != UDESC_INTERFACE) continue; diff --git a/sys/dev/ata/ata-usb.c b/sys/dev/ata/ata-usb.c index a0db29e..aeef67d 100644 --- a/sys/dev/ata/ata-usb.c +++ b/sys/dev/ata/ata-usb.c @@ -288,7 +288,7 @@ atausb2_probe(device_t dev) /* give other drivers a try first */ return (ENXIO); } - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); if ((!id) || (id->bInterfaceClass != UICLASS_MASS)) { return (ENXIO); } @@ -328,16 +328,16 @@ atausb2_attach(device_t dev) uint8_t has_intr; int err; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->dev = dev; sc->maxlun = 0; sc->locked_ch = NULL; sc->restart_ch = NULL; - sc->usb2_speed = usb2_get_speed(uaa->device); + sc->usb2_speed = usbd_get_speed(uaa->device); mtx_init(&sc->locked_mtx, "ATAUSB lock", NULL, (MTX_DEF | MTX_RECURSE)); - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); switch (id->bInterfaceProtocol) { case UIPROTO_MASS_BBB: case UIPROTO_MASS_BBB_OLD: @@ -380,7 +380,7 @@ atausb2_attach(device_t dev) (strcmp(subclass, "ATAPI") && strcmp(subclass, "SCSI"))) { goto detach; } - err = usb2_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->xfer, atausb2_config, ATAUSB_T_BBB_MAX, sc, &sc->locked_mtx); @@ -389,7 +389,7 @@ atausb2_attach(device_t dev) if (err) { device_printf(sc->dev, "could not setup required " - "transfers, %s\n", usb2_errstr(err)); + "transfers, %s\n", usbd_errstr(err)); goto detach; } /* get number of devices so we can add matching channels */ @@ -398,12 +398,12 @@ atausb2_attach(device_t dev) USETW(request.wValue, 0); USETW(request.wIndex, sc->iface_no); USETW(request.wLength, sizeof(maxlun)); - err = usb2_do_request(uaa->device, &Giant, &request, &maxlun); + err = usbd_do_request(uaa->device, &Giant, &request, &maxlun); if (err) { if (bootverbose) { device_printf(sc->dev, "get maxlun not supported %s\n", - usb2_errstr(err)); + usbd_errstr(err)); } } else { sc->maxlun = maxlun; @@ -438,7 +438,7 @@ atausb2_detach(device_t dev) /* teardown our statemachine */ - usb2_transfer_unsetup(sc->xfer, ATAUSB_T_MAX); + usbd_transfer_unsetup(sc->xfer, ATAUSB_T_MAX); /* detach & delete all children, if any */ @@ -460,7 +460,7 @@ atausb2_transfer_start(struct atausb2_softc *sc, uint8_t xfer_no) } if (sc->xfer[xfer_no]) { sc->last_xfer_no = xfer_no; - usb2_transfer_start(sc->xfer[xfer_no]); + usbd_transfer_start(sc->xfer[xfer_no]); } else { atausb2_cancel_request(sc); } @@ -485,11 +485,11 @@ atausb2_t_bbb_reset1_callback(struct usb_xfer *xfer) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->nframes = 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -527,7 +527,7 @@ tr_transferred: return; case USB_ST_SETUP: - if (usb2_clear_stall_callback(xfer, sc->xfer[stall_xfer])) { + if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) { goto tr_transferred; } return; @@ -575,10 +575,10 @@ atausb2_t_bbb_command_callback(struct usb_xfer *xfer) bzero(sc->cbw.cdb, 16); bcopy(request->u.atapi.ccb, sc->cbw.cdb, 12); /* XXX SOS */ - usb2_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw)); + usbd_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw)); xfer->frlengths[0] = sizeof(sc->cbw); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -598,7 +598,7 @@ atausb2_t_bbb_data_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_copy_out(xfer->frbuffers, 0, + usbd_copy_out(xfer->frbuffers, 0, sc->ata_data, xfer->actlen); sc->ata_bytecount -= xfer->actlen; @@ -625,7 +625,7 @@ atausb2_t_bbb_data_read_callback(struct usb_xfer *xfer) xfer->timeout = sc->timeout; xfer->frlengths[0] = max_bulk; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -675,10 +675,10 @@ atausb2_t_bbb_data_write_callback(struct usb_xfer *xfer) xfer->timeout = sc->timeout; xfer->frlengths[0] = max_bulk; - usb2_copy_in(xfer->frbuffers, 0, + usbd_copy_in(xfer->frbuffers, 0, sc->ata_data, max_bulk); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -712,7 +712,7 @@ atausb2_t_bbb_status_callback(struct usb_xfer *xfer) if (xfer->actlen < sizeof(sc->csw)) { bzero(&sc->csw, sizeof(sc->csw)); } - usb2_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen); if (request->flags & (ATA_R_READ | ATA_R_WRITE)) { request->donecount = sc->ata_donecount; @@ -780,7 +780,7 @@ atausb2_t_bbb_status_callback(struct usb_xfer *xfer) case USB_ST_SETUP: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: @@ -828,7 +828,7 @@ atausb2_tr_error(struct usb_xfer *xfer) if (atausbdebug) { device_printf(sc->dev, "transfer failed, %s, in state %d " - "-> BULK reset\n", usb2_errstr(xfer->error), + "-> BULK reset\n", usbd_errstr(xfer->error), sc->last_xfer_no); } } @@ -903,7 +903,7 @@ ata_usbchannel_begin_transaction(struct ata_request *request) sc->ata_data = request->data; sc->ata_donecount = 0; - usb2_transfer_start(sc->xfer[sc->last_xfer_no]); + usbd_transfer_start(sc->xfer[sc->last_xfer_no]); error = ATA_OP_CONTINUES; } else { request->result = EIO; diff --git a/sys/dev/if_ndis/if_ndis_usb.c b/sys/dev/if_ndis/if_ndis_usb.c index 2098493..69fd1af 100644 --- a/sys/dev/if_ndis/if_ndis_usb.c +++ b/sys/dev/if_ndis/if_ndis_usb.c @@ -211,12 +211,12 @@ ndisusb_detach(device_t self) ndis_pnpevent_nic(self, NDIS_PNP_EVENT_SURPRISE_REMOVED); if (sc->ndisusb_status & NDISUSB_STATUS_SETUP_EP) { - usb2_transfer_unsetup(sc->ndisusb_dread_ep.ne_xfer, 1); - usb2_transfer_unsetup(sc->ndisusb_dwrite_ep.ne_xfer, 1); + usbd_transfer_unsetup(sc->ndisusb_dread_ep.ne_xfer, 1); + usbd_transfer_unsetup(sc->ndisusb_dwrite_ep.ne_xfer, 1); } for (i = 0; i < NDISUSB_ENDPT_MAX; i++) { ne = &sc->ndisusb_ep[i]; - usb2_transfer_unsetup(ne->ne_xfer, 1); + usbd_transfer_unsetup(ne->ne_xfer, 1); } (void)ndis_detach(self); diff --git a/sys/dev/sound/usb/uaudio.c b/sys/dev/sound/usb/uaudio.c index 1912008..48f8ce8 100644 --- a/sys/dev/sound/usb/uaudio.c +++ b/sys/dev/sound/usb/uaudio.c @@ -547,7 +547,7 @@ uaudio_probe(device_t dev) if ((uaa->info.bInterfaceClass == UICLASS_AUDIO) && (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL)) { - if (usb2_test_quirk(uaa, UQ_BAD_AUDIO)) + if (usb_test_quirk(uaa, UQ_BAD_AUDIO)) return (ENXIO); else return (0); @@ -567,23 +567,23 @@ uaudio_attach(device_t dev) sc->sc_rec_chan.priv_sc = sc; sc->sc_udev = uaa->device; - if (usb2_test_quirk(uaa, UQ_AUDIO_SWAP_LR)) + if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR)) sc->sc_uq_audio_swap_lr = 1; - if (usb2_test_quirk(uaa, UQ_AU_INP_ASYNC)) + if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC)) sc->sc_uq_au_inp_async = 1; - if (usb2_test_quirk(uaa, UQ_AU_NO_XU)) + if (usb_test_quirk(uaa, UQ_AU_NO_XU)) sc->sc_uq_au_no_xu = 1; - if (usb2_test_quirk(uaa, UQ_BAD_ADC)) + if (usb_test_quirk(uaa, UQ_BAD_ADC)) sc->sc_uq_bad_adc = 1; umidi_init(dev); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); uaudio_chan_fill_info(sc, uaa->device); @@ -728,7 +728,7 @@ repeat: if (error) { device_printf(dev, "Waiting for sound application to exit!\n"); - usb2_pause_mtx(NULL, 2 * hz); + usb_pause_mtx(NULL, 2 * hz); goto repeat; /* try again */ } return (0); /* success */ @@ -783,7 +783,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, const struct usb2_audio_streaming_endpoint_descriptor *sed = NULL; const usb2_endpoint_descriptor_audio_t *ed1 = NULL; const usb2_endpoint_descriptor_audio_t *ed2 = NULL; - struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev); + struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); struct usb_interface_descriptor *id; const struct uaudio_format *p_fmt; struct uaudio_chan *chan; @@ -800,7 +800,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, uint8_t audio_if = 0; uint8_t sample_size; - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if ((desc->bDescriptorType == UDESC_INTERFACE) && (desc->bLength >= sizeof(*id))) { @@ -832,7 +832,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, */ if ((sc->sc_midi_chan.valid == 0) && - usb2_get_iface(udev, curidx)) { + usbd_get_iface(udev, curidx)) { sc->sc_midi_chan.iface_index = curidx; sc->sc_midi_chan.iface_alt_index = alt_index; sc->sc_midi_chan.valid = 1; @@ -994,7 +994,7 @@ uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev, &sc->sc_rec_chan : &sc->sc_play_chan; - if ((chan->valid == 0) && usb2_get_iface(udev, curidx)) { + if ((chan->valid == 0) && usbd_get_iface(udev, curidx)) { chan->valid = 1; #if USB_DEBUG @@ -1061,7 +1061,7 @@ uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev) { uint32_t rate = uaudio_default_rate; uint32_t z; - uint16_t fps = usb2_get_isoc_fps(udev); + uint16_t fps = usbd_get_isoc_fps(udev); uint8_t bits = uaudio_default_bits; uint8_t y; uint8_t channels = uaudio_default_channels; @@ -1172,7 +1172,7 @@ tr_transferred: if (n > total) { n = total; } - usb2_copy_in(xfer->frbuffers, offset, ch->cur, n); + usbd_copy_in(xfer->frbuffers, offset, ch->cur, n); total -= n; ch->cur += n; @@ -1183,7 +1183,7 @@ tr_transferred: } } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -1249,7 +1249,7 @@ tr_transferred: if (m > p_len[n]) { m = p_len[n]; } - usb2_copy_out(xfer->frbuffers, offset1, ch->cur, m); + usbd_copy_out(xfer->frbuffers, offset1, ch->cur, m); p_len[n] -= m; offset1 += m; @@ -1282,7 +1282,7 @@ tr_transferred: DPRINTF("no buffer!\n"); return; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -1361,13 +1361,13 @@ uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b, DPRINTF("endpoint=0x%02x, speed=%d, iface=%d alt=%d\n", endpoint, ch->sample_rate, iface_index, alt_index); - err = usb2_set_alt_interface_index(sc->sc_udev, iface_index, alt_index); + err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, alt_index); if (err) { DPRINTF("setting of alternate index failed: %s!\n", - usb2_errstr(err)); + usbd_errstr(err)); goto error; } - usb2_set_parent_iface(sc->sc_udev, iface_index, sc->sc_mixer_iface_index); + usbd_set_parent_iface(sc->sc_udev, iface_index, sc->sc_mixer_iface_index); /* * If just one sampling rate is supported, @@ -1383,7 +1383,7 @@ uaudio_chan_init(struct uaudio_softc *sc, struct snd_dbuf *b, DPRINTF("setting of sample rate failed! (continuing anyway)\n"); } } - if (usb2_transfer_setup(sc->sc_udev, &iface_index, ch->xfer, + if (usbd_transfer_setup(sc->sc_udev, &iface_index, ch->xfer, ch->usb2_cfg, UAUDIO_NCHANBUFS, ch, ch->pcm_mtx)) { DPRINTF("could not allocate USB transfers!\n"); goto error; @@ -1402,7 +1402,7 @@ uaudio_chan_free(struct uaudio_chan *ch) free(ch->buf, M_DEVBUF); ch->buf = NULL; } - usb2_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS); + usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS); ch->valid = 0; @@ -1521,10 +1521,10 @@ uaudio_chan_start(struct uaudio_chan *ch) #error "please update code" #endif if (ch->xfer[0]) { - usb2_transfer_start(ch->xfer[0]); + usbd_transfer_start(ch->xfer[0]); } if (ch->xfer[1]) { - usb2_transfer_start(ch->xfer[1]); + usbd_transfer_start(ch->xfer[1]); } return (0); } @@ -1535,8 +1535,8 @@ uaudio_chan_stop(struct uaudio_chan *ch) #if (UAUDIO_NCHANBUFS != 2) #error "please update code" #endif - usb2_transfer_stop(ch->xfer[0]); - usb2_transfer_stop(ch->xfer[1]); + usbd_transfer_stop(ch->xfer[0]); + usbd_transfer_stop(ch->xfer[1]); return (0); } @@ -2677,7 +2677,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev, void *desc) { const struct usb2_audio_control_descriptor *acdp; - struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev); + struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); const struct usb_descriptor *dp; const struct usb2_audio_unit *au; struct uaudio_terminal_node *iot = NULL; @@ -2685,7 +2685,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev, uint8_t ID_max = 0; /* inclusive */ uint8_t i; - desc = usb2_desc_foreach(cd, desc); + desc = usb_desc_foreach(cd, desc); if (desc == NULL) { DPRINTF("no Audio Control header\n"); @@ -2724,7 +2724,7 @@ uaudio_mixer_fill_info(struct uaudio_softc *sc, struct usb_device *udev, DPRINTF("no memory!\n"); goto done; } - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { dp = desc; @@ -2939,9 +2939,9 @@ uaudio_mixer_get(struct usb_device *udev, uint8_t what, USETW(req.wIndex, mc->wIndex); USETW(req.wLength, len); - err = usb2_do_request(udev, &Giant, &req, data); + err = usbd_do_request(udev, &Giant, &req, data); if (err) { - DPRINTF("err=%s\n", usb2_errstr(err)); + DPRINTF("err=%s\n", usbd_errstr(err)); return (0); } if (len < 1) { @@ -3011,13 +3011,13 @@ tr_setup: if (len > 1) { buf[1] = (mc->wData[chan] >> 8) & 0xFF; } - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_copy_in(xfer->frbuffers + 1, 0, buf, len); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers + 1, 0, buf, len); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = len; xfer->nframes = xfer->frlengths[1] ? 2 : 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; } } @@ -3033,7 +3033,7 @@ tr_setup: break; default: /* Error */ - DPRINTF("error=%s\n", usb2_errstr(xfer->error)); + DPRINTF("error=%s\n", usbd_errstr(xfer->error)); if (xfer->error == USB_ERR_CANCELLED) { /* do nothing - we are detaching */ break; @@ -3059,7 +3059,7 @@ uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed) data[1] = speed >> 8; data[2] = speed >> 16; - return (usb2_do_request(udev, &Giant, &req, data)); + return (usbd_do_request(udev, &Giant, &req, data)); } static int @@ -3105,7 +3105,7 @@ uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc, /* start the transfer, if not already started */ - usb2_transfer_start(sc->sc_mixer_xfer[0]); + usbd_transfer_start(sc->sc_mixer_xfer[0]); } static void @@ -3142,7 +3142,7 @@ uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m) { DPRINTF("\n"); - if (usb2_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, + if (usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index, sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc, mixer_get_lock(m))) { DPRINTFN(0, "could not allocate USB " @@ -3163,7 +3163,7 @@ uaudio_mixer_uninit_sub(struct uaudio_softc *sc) { DPRINTF("\n"); - usb2_transfer_unsetup(sc->sc_mixer_xfer, 1); + usbd_transfer_unsetup(sc->sc_mixer_xfer, 1); return (0); } @@ -3242,10 +3242,10 @@ umidi_read_clear_stall_callback(struct usb_xfer *xfer) struct umidi_chan *chan = xfer->priv_sc; struct usb_xfer *xfer_other = chan->xfer[1]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); chan->flags &= ~UMIDI_FLAG_READ_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -3272,14 +3272,14 @@ umidi_bulk_read_callback(struct usb_xfer *xfer) while (xfer->actlen >= 4) { - usb2_copy_out(xfer->frbuffers, pos, buf, 1); + usbd_copy_out(xfer->frbuffers, pos, buf, 1); cmd_len = umidi_cmd_to_len[buf[0] & 0xF]; /* command length */ cn = buf[0] >> 4; /* cable number */ sub = &chan->sub[cn]; if (cmd_len && (cn < chan->max_cable) && sub->read_open) { - usb2_fifo_put_data(sub->fifo.fp[USB_FIFO_RX], xfer->frbuffers, + usb_fifo_put_data(sub->fifo.fp[USB_FIFO_RX], xfer->frbuffers, pos + 1, cmd_len, 1); } else { /* ignore the command */ @@ -3293,22 +3293,22 @@ umidi_bulk_read_callback(struct usb_xfer *xfer) DPRINTF("start\n"); if (chan->flags & UMIDI_FLAG_READ_STALL) { - usb2_transfer_start(chan->xfer[3]); + usbd_transfer_start(chan->xfer[3]); return; } xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: tr_error: - DPRINTF("error=%s\n", usb2_errstr(xfer->error)); + DPRINTF("error=%s\n", usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ chan->flags |= UMIDI_FLAG_READ_STALL; - usb2_transfer_start(chan->xfer[3]); + usbd_transfer_start(chan->xfer[3]); } return; @@ -3321,10 +3321,10 @@ umidi_write_clear_stall_callback(struct usb_xfer *xfer) struct umidi_chan *chan = xfer->priv_sc; struct usb_xfer *xfer_other = chan->xfer[0]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); chan->flags &= ~UMIDI_FLAG_WRITE_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -3481,7 +3481,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer) DPRINTF("start\n"); if (chan->flags & UMIDI_FLAG_WRITE_STALL) { - usb2_transfer_start(chan->xfer[2]); + usbd_transfer_start(chan->xfer[2]); return; } total_length = 0; /* reset */ @@ -3497,7 +3497,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer) sub = &chan->sub[chan->curr_cable]; if (sub->write_open) { - usb2_fifo_get_data(sub->fifo.fp[USB_FIFO_TX], + usb_fifo_get_data(sub->fifo.fp[USB_FIFO_TX], xfer->frbuffers, total_length, 1, &actlen, 0); } else { @@ -3505,7 +3505,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer) } if (actlen) { - usb2_copy_out(xfer->frbuffers, total_length, &buf, 1); + usbd_copy_out(xfer->frbuffers, total_length, &buf, 1); tr_any = 1; @@ -3517,7 +3517,7 @@ umidi_bulk_write_callback(struct usb_xfer *xfer) sub->temp_cmd[0], sub->temp_cmd[1], sub->temp_cmd[2], sub->temp_cmd[3]); - usb2_copy_in(xfer->frbuffers, total_length, + usbd_copy_in(xfer->frbuffers, total_length, sub->temp_cmd, 4); total_length += 4; @@ -3543,18 +3543,18 @@ umidi_bulk_write_callback(struct usb_xfer *xfer) if (total_length) { xfer->frlengths[0] = total_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: /* Error */ - DPRINTF("error=%s\n", usb2_errstr(xfer->error)); + DPRINTF("error=%s\n", usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ chan->flags |= UMIDI_FLAG_WRITE_STALL; - usb2_transfer_start(chan->xfer[2]); + usbd_transfer_start(chan->xfer[2]); } return; @@ -3587,7 +3587,7 @@ umidi_start_read(struct usb_fifo *fifo) { struct umidi_chan *chan = fifo->priv_sc0; - usb2_transfer_start(chan->xfer[1]); + usbd_transfer_start(chan->xfer[1]); } static void @@ -3614,7 +3614,7 @@ umidi_start_write(struct usb_fifo *fifo) { struct umidi_chan *chan = fifo->priv_sc0; - usb2_transfer_start(chan->xfer[0]); + usbd_transfer_start(chan->xfer[0]); } static void @@ -3629,8 +3629,8 @@ umidi_stop_write(struct usb_fifo *fifo) if (--(chan->write_open_refcount) == 0) { DPRINTF("(stopping write transfer)\n"); - usb2_transfer_stop(chan->xfer[2]); - usb2_transfer_stop(chan->xfer[0]); + usbd_transfer_stop(chan->xfer[2]); + usbd_transfer_stop(chan->xfer[0]); } } @@ -3641,7 +3641,7 @@ umidi_open(struct usb_fifo *fifo, int fflags) struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo); if (fflags & FREAD) { - if (usb2_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { + if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) { return (ENOMEM); } mtx_lock(fifo->priv_mtx); @@ -3650,7 +3650,7 @@ umidi_open(struct usb_fifo *fifo, int fflags) mtx_unlock(fifo->priv_mtx); } if (fflags & FWRITE) { - if (usb2_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { + if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) { return (ENOMEM); } /* clear stall first */ @@ -3670,10 +3670,10 @@ static void umidi_close(struct usb_fifo *fifo, int fflags) { if (fflags & FREAD) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } if (fflags & FWRITE) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } } @@ -3716,18 +3716,18 @@ umidi_probe(device_t dev) int error; uint32_t n; - if (usb2_set_alt_interface_index(sc->sc_udev, chan->iface_index, + if (usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, chan->iface_alt_index)) { DPRINTF("setting of alternate index failed!\n"); goto detach; } - usb2_set_parent_iface(sc->sc_udev, chan->iface_index, sc->sc_mixer_iface_index); + usbd_set_parent_iface(sc->sc_udev, chan->iface_index, sc->sc_mixer_iface_index); - error = usb2_transfer_setup(uaa->device, &chan->iface_index, + error = usbd_transfer_setup(uaa->device, &chan->iface_index, chan->xfer, umidi_config, UMIDI_N_TRANSFER, chan, &chan->mtx); if (error) { - DPRINTF("error=%s\n", usb2_errstr(error)); + DPRINTF("error=%s\n", usbd_errstr(error)); goto detach; } if ((chan->max_cable > UMIDI_CABLES_MAX) || @@ -3739,7 +3739,7 @@ umidi_probe(device_t dev) sub = &chan->sub[n]; - error = usb2_fifo_attach(sc->sc_udev, chan, &chan->mtx, + error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx, &umidi_fifo_methods, &sub->fifo, unit, n, chan->iface_index, UID_ROOT, GID_OPERATOR, 0644); @@ -3757,7 +3757,7 @@ umidi_probe(device_t dev) * NOTE: at least one device will not work properly unless * the BULK pipe is open all the time. */ - usb2_transfer_start(chan->xfer[1]); + usbd_transfer_start(chan->xfer[1]); mtx_unlock(&chan->mtx); @@ -3775,17 +3775,17 @@ umidi_detach(device_t dev) uint32_t n; for (n = 0; n < UMIDI_CABLES_MAX; n++) { - usb2_fifo_detach(&chan->sub[n].fifo); + usb_fifo_detach(&chan->sub[n].fifo); } mtx_lock(&chan->mtx); - usb2_transfer_stop(chan->xfer[3]); - usb2_transfer_stop(chan->xfer[1]); + usbd_transfer_stop(chan->xfer[3]); + usbd_transfer_stop(chan->xfer[1]); mtx_unlock(&chan->mtx); - usb2_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); + usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER); mtx_destroy(&chan->mtx); diff --git a/sys/dev/usb/controller/at91dci.c b/sys/dev/usb/controller/at91dci.c index 5831a7e..fd1b684 100644 --- a/sys/dev/usb/controller/at91dci.c +++ b/sys/dev/usb/controller/at91dci.c @@ -260,7 +260,7 @@ at91dci_wakeup_peer(struct at91dci_softc *sc) /* wait 8 milliseconds */ /* Wait for reset to complete. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); AT91_UDP_WRITE_4(sc, AT91_UDP_GSTATE, 0); } @@ -321,7 +321,7 @@ at91dci_setup_rx(struct at91dci_td *td) td->fifo_reg, (void *)&req, sizeof(req)); /* copy data into real buffer */ - usb2_copy_in(td->pc, 0, &req, sizeof(req)); + usbd_copy_in(td->pc, 0, &req, sizeof(req)); td->offset = sizeof(req); td->remainder = 0; @@ -442,7 +442,7 @@ repeat: return (0); /* we are complete */ } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -549,7 +549,7 @@ repeat: } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -865,7 +865,7 @@ at91dci_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.max_frame_size = xfer->max_frame_size; @@ -1046,11 +1046,11 @@ at91dci_start_standard_chain(struct usb_xfer *xfer) DPRINTFN(15, "enable interrupts on endpoint %d\n", ep_no); /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, + usbd_transfer_timeout_ms(xfer, &at91dci_timeout, xfer->timeout); } } @@ -1203,7 +1203,7 @@ at91dci_device_done(struct usb_xfer *xfer, usb_error_t error) DPRINTFN(15, "disable interrupts on endpoint %d\n", ep_no); } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } static void @@ -1375,7 +1375,7 @@ at91dci_init(struct at91dci_softc *sc) (sc->sc_clocks_on) (sc->sc_clocks_arg); } /* wait a little for things to stabilise */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); /* disable and clear all interrupts */ @@ -1632,7 +1632,7 @@ at91dci_device_isoc_fs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + xfer->nframes; /* compute frame number for next insertion */ @@ -2165,7 +2165,7 @@ at91dci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_packet_count = 1; parm->hc_max_frame_size = 0x500; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* * compute maximum number of TDs @@ -2193,7 +2193,7 @@ at91dci_xfer_setup(struct usb_setup_params *parm) } /* - * check if "usb2_transfer_setup_sub" set an error + * check if "usbd_transfer_setup_sub" set an error */ if (parm->err) { return; diff --git a/sys/dev/usb/controller/at91dci_atmelarm.c b/sys/dev/usb/controller/at91dci_atmelarm.c index aedd30f..37d79e5 100644 --- a/sys/dev/usb/controller/at91dci_atmelarm.c +++ b/sys/dev/usb/controller/at91dci_atmelarm.c @@ -144,7 +144,7 @@ at91_udp_attach(device_t dev) sc->sc_dci.sc_bus.devices_max = AT91_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_dci.sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_dci.sc_bus, USB_GET_DMA_TAG(dev), NULL)) { return (ENOMEM); } @@ -166,7 +166,7 @@ at91_udp_attach(device_t dev) at91_udp_pull_down(sc); /* wait 10ms for pulldown to stabilise */ - usb2_pause_mtx(NULL, hz / 100); + usb_pause_mtx(NULL, hz / 100); sc->sc_iclk = at91_pmc_clock_ref("udc_clk"); sc->sc_fclk = at91_pmc_clock_ref("udpck"); @@ -295,7 +295,7 @@ at91_udp_detach(device_t dev) sc->sc_dci.sc_io_res); sc->sc_dci.sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_dci.sc_bus, NULL); + usb_bus_mem_free_all(&sc->sc_dci.sc_bus, NULL); /* disable clocks */ at91_pmc_clock_disable(sc->sc_iclk); diff --git a/sys/dev/usb/controller/atmegadci.c b/sys/dev/usb/controller/atmegadci.c index 0f4ef24..79d9fcb 100644 --- a/sys/dev/usb/controller/atmegadci.c +++ b/sys/dev/usb/controller/atmegadci.c @@ -204,7 +204,7 @@ atmegadci_wakeup_peer(struct atmegadci_softc *sc) /* wait 8 milliseconds */ /* Wait for reset to complete. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); /* hardware should have cleared RMWKUP bit */ } @@ -267,7 +267,7 @@ atmegadci_setup_rx(struct atmegadci_td *td) (void *)&req, sizeof(req)); /* copy data into real buffer */ - usb2_copy_in(td->pc, 0, &req, sizeof(req)); + usbd_copy_in(td->pc, 0, &req, sizeof(req)); td->offset = sizeof(req); td->remainder = 0; @@ -378,7 +378,7 @@ repeat: return (0); /* we are complete */ } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -465,7 +465,7 @@ repeat: } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -768,7 +768,7 @@ atmegadci_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.max_frame_size = xfer->max_frame_size; @@ -929,11 +929,11 @@ atmegadci_start_standard_chain(struct usb_xfer *xfer) if (atmegadci_xfer_do_fifo(xfer)) { /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, + usbd_transfer_timeout_ms(xfer, &atmegadci_timeout, xfer->timeout); } } @@ -1089,7 +1089,7 @@ atmegadci_device_done(struct usb_xfer *xfer, usb_error_t error) DPRINTFN(15, "disabled interrupts!\n"); } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } static void @@ -1236,7 +1236,7 @@ atmegadci_init(struct atmegadci_softc *sc) if (ATMEGA_READ_1(sc, 0x49) & 0x01) break; /* wait a little bit for PLL to start */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); } /* make sure USB is enabled */ @@ -1252,7 +1252,7 @@ atmegadci_init(struct atmegadci_softc *sc) ATMEGA_WRITE_1(sc, ATMEGA_UDCON, ATMEGA_UDCON_DETACH); /* wait a little for things to stabilise */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20); /* enable interrupts */ ATMEGA_WRITE_1(sc, ATMEGA_UDIEN, @@ -1453,7 +1453,7 @@ atmegadci_device_isoc_fs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + xfer->nframes; /* compute frame number for next insertion */ @@ -2017,7 +2017,7 @@ atmegadci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_packet_count = 1; parm->hc_max_frame_size = 0x500; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* * compute maximum number of TDs @@ -2032,7 +2032,7 @@ atmegadci_xfer_setup(struct usb_setup_params *parm) } /* - * check if "usb2_transfer_setup_sub" set an error + * check if "usbd_transfer_setup_sub" set an error */ if (parm->err) return; diff --git a/sys/dev/usb/controller/atmegadci_atmelarm.c b/sys/dev/usb/controller/atmegadci_atmelarm.c index 6412851..3a85b50 100644 --- a/sys/dev/usb/controller/atmegadci_atmelarm.c +++ b/sys/dev/usb/controller/atmegadci_atmelarm.c @@ -84,7 +84,7 @@ atmegadci_attach(device_t dev) sc->sc_otg.sc_bus.devices_max = ATMEGA_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_otg.sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_otg.sc_bus, USB_GET_DMA_TAG(dev), NULL)) { return (ENOMEM); } @@ -168,7 +168,7 @@ atmegadci_detach(device_t dev) sc->sc_otg.sc_io_res); sc->sc_otg.sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL); + usb_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL); return (0); } diff --git a/sys/dev/usb/controller/avr32dci.c b/sys/dev/usb/controller/avr32dci.c index 5463b7f..edf7879 100644 --- a/sys/dev/usb/controller/avr32dci.c +++ b/sys/dev/usb/controller/avr32dci.c @@ -237,7 +237,7 @@ avr32dci_wakeup_peer(struct avr32dci_softc *sc) /* wait 8 milliseconds */ /* Wait for reset to complete. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); /* hardware should have cleared RMWKUP bit */ } @@ -289,7 +289,7 @@ avr32dci_setup_rx(struct avr32dci_td *td) memcpy(&req, sc->physdata, sizeof(req)); /* copy data into real buffer */ - usb2_copy_in(td->pc, 0, &req, sizeof(req)); + usbd_copy_in(td->pc, 0, &req, sizeof(req)); td->offset = sizeof(req); td->remainder = 0; @@ -390,7 +390,7 @@ repeat: return (0); /* we are complete */ } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -466,7 +466,7 @@ repeat: } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -738,7 +738,7 @@ avr32dci_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpoint), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.max_frame_size = xfer->max_frame_size; @@ -900,11 +900,11 @@ avr32dci_start_standard_chain(struct usb_xfer *xfer) avr32dci_mod_ien(sc, AVR32_INT_EPT_INT(ep_no), 0); /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, + usbd_transfer_timeout_ms(xfer, &avr32dci_timeout, xfer->timeout); } } @@ -1057,7 +1057,7 @@ avr32dci_device_done(struct usb_xfer *xfer, usb_error_t error) DPRINTFN(15, "disabled interrupts!\n"); } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } static void @@ -1198,7 +1198,7 @@ avr32dci_init(struct avr32dci_softc *sc) avr32dci_mod_ctrl(sc, AVR32_CTRL_DEV_DETACH, 0); /* wait a little for things to stabilise */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 20); /* disable interrupts */ avr32dci_mod_ien(sc, 0, 0xFFFFFFFF); @@ -1387,7 +1387,7 @@ avr32dci_device_isoc_fs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + xfer->nframes; /* compute frame number for next insertion */ @@ -1950,7 +1950,7 @@ avr32dci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_packet_count = 1; parm->hc_max_frame_size = 0x400; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* * compute maximum number of TDs @@ -1965,7 +1965,7 @@ avr32dci_xfer_setup(struct usb_setup_params *parm) } /* - * check if "usb2_transfer_setup_sub" set an error + * check if "usbd_transfer_setup_sub" set an error */ if (parm->err) return; diff --git a/sys/dev/usb/controller/ehci.c b/sys/dev/usb/controller/ehci.c index 6b51600..9bbb7c4 100644 --- a/sys/dev/usb/controller/ehci.c +++ b/sys/dev/usb/controller/ehci.c @@ -153,7 +153,7 @@ ehci_reset(ehci_softc_t *sc) EOWRITE4(sc, EHCI_USBCMD, EHCI_CMD_HCRESET); for (i = 0; i < 100; i++) { - usb2_pause_mtx(NULL, hz / 1000); + usb_pause_mtx(NULL, hz / 1000); hcr = EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_HCRESET; if (!hcr) { if (sc->sc_flags & (EHCI_SCFLG_SETMODE | EHCI_SCFLG_BIGEMMIO)) { @@ -189,7 +189,7 @@ ehci_hcreset(ehci_softc_t *sc) EOWRITE4(sc, EHCI_USBCMD, 0); /* Halt controller */ for (i = 0; i < 100; i++) { - usb2_pause_mtx(NULL, hz / 1000); + usb_pause_mtx(NULL, hz / 1000); hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; if (hcr) break; @@ -221,7 +221,7 @@ ehci_init(ehci_softc_t *sc) DPRINTF("start\n"); - usb2_callout_init_mtx(&sc->sc_tmo_pcd, &sc->sc_bus.bus_mtx, 0); + usb_callout_init_mtx(&sc->sc_tmo_pcd, &sc->sc_bus.bus_mtx, 0); #if USB_DEBUG if (ehcidebug > 2) { @@ -274,7 +274,7 @@ ehci_init(ehci_softc_t *sc) for (i = 0; i < EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { ehci_qh_t *qh; - usb2_get_page(sc->sc_hw.intr_start_pc + i, 0, &buf_res); + usbd_get_page(sc->sc_hw.intr_start_pc + i, 0, &buf_res); qh = buf_res.buffer; @@ -342,7 +342,7 @@ ehci_init(ehci_softc_t *sc) ehci_sitd_t *sitd; ehci_itd_t *itd; - usb2_get_page(sc->sc_hw.isoc_fs_start_pc + i, 0, &buf_res); + usbd_get_page(sc->sc_hw.isoc_fs_start_pc + i, 0, &buf_res); sitd = buf_res.buffer; @@ -367,7 +367,7 @@ ehci_init(ehci_softc_t *sc) sc->sc_intr_p_last[i | (EHCI_VIRTUAL_FRAMELIST_COUNT / 2)]->qh_self; - usb2_get_page(sc->sc_hw.isoc_hs_start_pc + i, 0, &buf_res); + usbd_get_page(sc->sc_hw.isoc_hs_start_pc + i, 0, &buf_res); itd = buf_res.buffer; @@ -389,7 +389,7 @@ ehci_init(ehci_softc_t *sc) sitd->sitd_self; } - usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); if (1) { uint32_t *pframes; @@ -409,7 +409,7 @@ ehci_init(ehci_softc_t *sc) /* setup sync list pointer */ EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr); - usb2_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); if (1) { @@ -445,7 +445,7 @@ ehci_init(ehci_softc_t *sc) } /* flush all cache into memory */ - usb2_bus_mem_flush_all(&sc->sc_bus, &ehci_iterate_hw_softc); + usb_bus_mem_flush_all(&sc->sc_bus, &ehci_iterate_hw_softc); #if USB_DEBUG if (ehcidebug) { @@ -472,7 +472,7 @@ ehci_init(ehci_softc_t *sc) EOWRITE4(sc, EHCI_CONFIGFLAG, EHCI_CONF_CF); for (i = 0; i < 100; i++) { - usb2_pause_mtx(NULL, hz / 1000); + usb_pause_mtx(NULL, hz / 1000); hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; if (!hcr) { break; @@ -498,7 +498,7 @@ ehci_detach(ehci_softc_t *sc) { USB_BUS_LOCK(&sc->sc_bus); - usb2_callout_stop(&sc->sc_tmo_pcd); + usb_callout_stop(&sc->sc_tmo_pcd); EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); USB_BUS_UNLOCK(&sc->sc_bus); @@ -508,9 +508,9 @@ ehci_detach(ehci_softc_t *sc) } /* XXX let stray task complete */ - usb2_pause_mtx(NULL, hz / 20); + usb_pause_mtx(NULL, hz / 20); - usb2_callout_drain(&sc->sc_tmo_pcd); + usb_callout_drain(&sc->sc_tmo_pcd); } void @@ -543,7 +543,7 @@ ehci_suspend(ehci_softc_t *sc) if (hcr == 0) { break; } - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); } if (hcr != 0) { @@ -557,7 +557,7 @@ ehci_suspend(ehci_softc_t *sc) if (hcr == EHCI_STS_HCH) { break; } - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); } if (hcr != EHCI_STS_HCH) { @@ -580,10 +580,10 @@ ehci_resume(ehci_softc_t *sc) /* restore things in case the bios doesn't */ EOWRITE4(sc, EHCI_CTRLDSSEGMENT, 0); - usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr); - usb2_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); EOWRITE4(sc, EHCI_ASYNCLISTADDR, buf_res.physaddr | EHCI_LINK_QH); EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); @@ -600,7 +600,7 @@ ehci_resume(ehci_softc_t *sc) } if (hcr) { - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_WAIT)); for (i = 1; i <= sc->sc_noport; i++) { @@ -619,7 +619,7 @@ ehci_resume(ehci_softc_t *sc) if (hcr != EHCI_STS_HCH) { break; } - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); } if (hcr == EHCI_STS_HCH) { device_printf(sc->sc_bus.bdev, "config timeout\n"); @@ -627,7 +627,7 @@ ehci_resume(ehci_softc_t *sc) USB_BUS_UNLOCK(&sc->sc_bus); - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_RESUME_WAIT)); /* catch any lost interrupts */ @@ -793,7 +793,7 @@ ehci_dump_sqtd(ehci_softc_t *sc, ehci_qtd_t *sqtd) { uint8_t temp; - usb2_pc_cpu_invalidate(sqtd->page_cache); + usb_pc_cpu_invalidate(sqtd->page_cache); printf("QTD(%p) at 0x%08x:\n", sqtd, hc32toh(sc, sqtd->qtd_self)); ehci_dump_qtd(sc, sqtd); temp = (sqtd->qtd_next & htohc32(sc, EHCI_LINK_TERMINATE)) ? 1 : 0; @@ -821,7 +821,7 @@ ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh) uint32_t endp; uint32_t endphub; - usb2_pc_cpu_invalidate(qh->page_cache); + usb_pc_cpu_invalidate(qh->page_cache); printf("QH(%p) at 0x%08x:\n", qh, hc32toh(sc, qh->qh_self) & ~0x1F); printf(" link="); ehci_dump_link(sc, qh->qh_link, 1); @@ -851,7 +851,7 @@ ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh) static void ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd) { - usb2_pc_cpu_invalidate(sitd->page_cache); + usb_pc_cpu_invalidate(sitd->page_cache); printf("SITD(%p) at 0x%08x\n", sitd, hc32toh(sc, sitd->sitd_self) & ~0x1F); printf(" next=0x%08x\n", hc32toh(sc, sitd->sitd_next)); printf(" portaddr=0x%08x dir=%s addr=%d endpt=0x%x port=0x%x huba=0x%x\n", @@ -877,7 +877,7 @@ ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd) static void ehci_dump_itd(ehci_softc_t *sc, ehci_itd_t *itd) { - usb2_pc_cpu_invalidate(itd->page_cache); + usb_pc_cpu_invalidate(itd->page_cache); printf("ITD(%p) at 0x%08x\n", itd, hc32toh(sc, itd->itd_self) & ~0x1F); printf(" next=0x%08x\n", hc32toh(sc, itd->itd_next)); printf(" status[0]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[0]), @@ -959,11 +959,11 @@ ehci_transfer_intr_enqueue(struct usb_xfer *xfer) return; } /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, &ehci_timeout, xfer->timeout); + usbd_transfer_timeout_ms(xfer, &ehci_timeout, xfer->timeout); } } @@ -980,7 +980,7 @@ _ehci_append_fs_td(ehci_sitd_t *std, ehci_sitd_t *last) std->prev = last; - usb2_pc_cpu_flush(std->page_cache); + usb_pc_cpu_flush(std->page_cache); /* * the last->next->prev is never followed: std->next->prev = std; @@ -988,7 +988,7 @@ _ehci_append_fs_td(ehci_sitd_t *std, ehci_sitd_t *last) last->next = std; last->sitd_next = std->sitd_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (std); } @@ -1006,7 +1006,7 @@ _ehci_append_hs_td(ehci_itd_t *std, ehci_itd_t *last) std->prev = last; - usb2_pc_cpu_flush(std->page_cache); + usb_pc_cpu_flush(std->page_cache); /* * the last->next->prev is never followed: std->next->prev = std; @@ -1014,7 +1014,7 @@ _ehci_append_hs_td(ehci_itd_t *std, ehci_itd_t *last) last->next = std; last->itd_next = std->itd_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (std); } @@ -1037,7 +1037,7 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last) sqh->prev = last; - usb2_pc_cpu_flush(sqh->page_cache); + usb_pc_cpu_flush(sqh->page_cache); /* * the last->next->prev is never followed: sqh->next->prev = sqh; @@ -1046,7 +1046,7 @@ _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last) last->next = sqh; last->qh_link = sqh->qh_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (sqh); } @@ -1062,11 +1062,11 @@ _ehci_remove_fs_td(ehci_sitd_t *std, ehci_sitd_t *last) std->prev->next = std->next; std->prev->sitd_next = std->sitd_next; - usb2_pc_cpu_flush(std->prev->page_cache); + usb_pc_cpu_flush(std->prev->page_cache); if (std->next) { std->next->prev = std->prev; - usb2_pc_cpu_flush(std->next->page_cache); + usb_pc_cpu_flush(std->next->page_cache); } return ((last == std) ? std->prev : last); } @@ -1082,11 +1082,11 @@ _ehci_remove_hs_td(ehci_itd_t *std, ehci_itd_t *last) std->prev->next = std->next; std->prev->itd_next = std->itd_next; - usb2_pc_cpu_flush(std->prev->page_cache); + usb_pc_cpu_flush(std->prev->page_cache); if (std->next) { std->next->prev = std->prev; - usb2_pc_cpu_flush(std->next->page_cache); + usb_pc_cpu_flush(std->next->page_cache); } return ((last == std) ? std->prev : last); } @@ -1105,17 +1105,17 @@ _ehci_remove_qh(ehci_qh_t *sqh, ehci_qh_t *last) sqh->prev->next = sqh->next; sqh->prev->qh_link = sqh->qh_link; - usb2_pc_cpu_flush(sqh->prev->page_cache); + usb_pc_cpu_flush(sqh->prev->page_cache); if (sqh->next) { sqh->next->prev = sqh->prev; - usb2_pc_cpu_flush(sqh->next->page_cache); + usb_pc_cpu_flush(sqh->next->page_cache); } last = ((last == sqh) ? sqh->prev : last); sqh->prev = 0; - usb2_pc_cpu_flush(sqh->page_cache); + usb_pc_cpu_flush(sqh->page_cache); } return (last); } @@ -1137,7 +1137,7 @@ ehci_non_isoc_done_sub(struct usb_xfer *xfer) } while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = hc32toh(sc, td->qtd_status); len = EHCI_QTD_GET_BYTES(status); @@ -1287,13 +1287,13 @@ ehci_check_transfer(struct usb_xfer *xfer) /* isochronous full speed transfer */ td = xfer->td_transfer_last; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = hc32toh(sc, td->sitd_status); /* also check if first is complete */ td = xfer->td_transfer_first; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status |= hc32toh(sc, td->sitd_status); if (!(status & EHCI_SITD_ACTIVE)) { @@ -1306,7 +1306,7 @@ ehci_check_transfer(struct usb_xfer *xfer) /* isochronous high speed transfer */ td = xfer->td_transfer_last; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = td->itd_status[0] | td->itd_status[1] | td->itd_status[2] | td->itd_status[3] | @@ -1315,7 +1315,7 @@ ehci_check_transfer(struct usb_xfer *xfer) /* also check first transfer */ td = xfer->td_transfer_first; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status |= td->itd_status[0] | td->itd_status[1] | td->itd_status[2] | td->itd_status[3] | @@ -1339,7 +1339,7 @@ ehci_check_transfer(struct usb_xfer *xfer) td = xfer->td_transfer_cache; while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = hc32toh(sc, td->qtd_status); /* @@ -1475,7 +1475,7 @@ ehci_interrupt(ehci_softc_t *sc) ehci_root_intr(sc); /* do not allow RHSC interrupts > 1 per second */ - usb2_callout_reset(&sc->sc_tmo_pcd, hz, + usb_callout_reset(&sc->sc_tmo_pcd, hz, (void *)&ehci_pcd_enable, sc); } status &= ~(EHCI_STS_INT | EHCI_STS_ERRINT | EHCI_STS_PCD | EHCI_STS_IAA); @@ -1634,7 +1634,7 @@ restart: /* fill out buffer pointers */ - usb2_get_page(temp->pc, buf_offset, &buf_res); + usbd_get_page(temp->pc, buf_offset, &buf_res); td->qtd_buffer[0] = htohc32(temp->sc, buf_res.physaddr); td->qtd_buffer_hi[0] = 0; @@ -1644,7 +1644,7 @@ restart: while (average > EHCI_PAGE_SIZE) { average -= EHCI_PAGE_SIZE; buf_offset += EHCI_PAGE_SIZE; - usb2_get_page(temp->pc, buf_offset, &buf_res); + usbd_get_page(temp->pc, buf_offset, &buf_res); td->qtd_buffer[x] = htohc32(temp->sc, buf_res.physaddr & (~0xFFF)); @@ -1661,7 +1661,7 @@ restart: * of a valid page ! */ buf_offset += average; - usb2_get_page(temp->pc, buf_offset - 1, &buf_res); + usbd_get_page(temp->pc, buf_offset - 1, &buf_res); td->qtd_buffer[x] = htohc32(temp->sc, buf_res.physaddr & (~0xFFF)); @@ -1675,7 +1675,7 @@ restart: td->qtd_altnext = qtd_altnext; td->alt_next = td_alt_next; - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } if (precompute) { @@ -1717,7 +1717,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.average = xfer->max_hc_frame_size; temp.max_frame_size = xfer->max_frame_size; @@ -1749,7 +1749,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) temp.auto_data_toggle = 1; } - if (usb2_get_speed(xfer->xroot->udev) != USB_SPEED_HIGH) { + if (usbd_get_speed(xfer->xroot->udev) != USB_SPEED_HIGH) { /* max 3 retries */ temp.qtd_status |= htohc32(temp.sc, EHCI_QTD_SET_CERR(3)); @@ -1872,7 +1872,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) td->qtd_altnext = htohc32(temp.sc, EHCI_LINK_TERMINATE); td->qtd_status |= htohc32(temp.sc, EHCI_QTD_IOC); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); /* must have at least one frame! */ @@ -1898,14 +1898,14 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) EHCI_QH_SET_ENDPT(UE_GET_ADDR(xfer->endpointno)) | EHCI_QH_SET_MPL(xfer->max_packet_size)); - if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { + if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { qh_endp |= (EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH) | EHCI_QH_DTC); if (methods != &ehci_device_intr_methods) qh_endp |= EHCI_QH_SET_NRL(8); } else { - if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_FULL) { + if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_FULL) { qh_endp |= (EHCI_QH_SET_EPS(EHCI_QH_SPEED_FULL) | EHCI_QH_DTC); } else { @@ -1926,8 +1926,8 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) qh_endphub = (EHCI_QH_SET_MULT(xfer->max_packet_count & 3) | - EHCI_QH_SET_CMASK(xfer->usb2_cmask) | - EHCI_QH_SET_SMASK(xfer->usb2_smask) | + EHCI_QH_SET_CMASK(xfer->usb_cmask) | + EHCI_QH_SET_SMASK(xfer->usb_smask) | EHCI_QH_SET_HUBA(xfer->xroot->udev->hs_hub_addr) | EHCI_QH_SET_PORT(xfer->xroot->udev->hs_port_no)); @@ -1955,7 +1955,7 @@ ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) qh->qh_qtd.qtd_altnext = htohc32(temp.sc, EHCI_LINK_TERMINATE); - usb2_pc_cpu_flush(qh->page_cache); + usb_pc_cpu_flush(qh->page_cache); if (xfer->xroot->udev->flags.self_suspended == 0) { EHCI_APPEND_QH(qh, *qh_last); @@ -2016,7 +2016,7 @@ ehci_isoc_fs_done(ehci_softc_t *sc, struct usb_xfer *xfer) ehci_dump_sitd(sc, td); } #endif - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = hc32toh(sc, td->sitd_status); len = EHCI_SITD_GET_LEN(status); @@ -2071,7 +2071,7 @@ ehci_isoc_hs_done(ehci_softc_t *sc, struct usb_xfer *xfer) } #endif - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = hc32toh(sc, td->itd_status[td_no]); len = EHCI_ITD_GET_LEN(status); @@ -2155,7 +2155,7 @@ ehci_device_done(struct usb_xfer *xfer, usb_error_t error) xfer->td_transfer_last = NULL; } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } /*------------------------------------------------------------------------* @@ -2263,17 +2263,17 @@ ehci_device_intr_open(struct usb_xfer *xfer) /* Allocate a microframe slot first: */ - slot = usb2_intr_schedule_adjust + slot = usb_intr_schedule_adjust (xfer->xroot->udev, xfer->max_frame_size, USB_HS_MICRO_FRAMES_MAX); - if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { - xfer->usb2_uframe = slot; - xfer->usb2_smask = (1 << slot) & 0xFF; - xfer->usb2_cmask = 0; + if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { + xfer->usb_uframe = slot; + xfer->usb_smask = (1 << slot) & 0xFF; + xfer->usb_cmask = 0; } else { - xfer->usb2_uframe = slot; - xfer->usb2_smask = (1 << slot) & 0x3F; - xfer->usb2_cmask = (-(4 << slot)) & 0xFE; + xfer->usb_uframe = slot; + xfer->usb_smask = (1 << slot) & 0x3F; + xfer->usb_cmask = (-(4 << slot)) & 0xFE; } /* @@ -2311,8 +2311,8 @@ ehci_device_intr_close(struct usb_xfer *xfer) ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); uint8_t slot; - slot = usb2_intr_schedule_adjust - (xfer->xroot->udev, -(xfer->max_frame_size), xfer->usb2_uframe); + slot = usb_intr_schedule_adjust + (xfer->xroot->udev, -(xfer->max_frame_size), xfer->usb_uframe); sc->sc_intr_stat[xfer->qh_pos]--; @@ -2384,7 +2384,7 @@ ehci_device_isoc_fs_open(struct usb_xfer *xfer) */ td->sitd_back = htohc32(sc, EHCI_LINK_TERMINATE); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } } } @@ -2459,7 +2459,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_fs_isoc_schedule_isoc_time_expand + usbd_fs_isoc_schedule_isoc_time_expand (xfer->xroot->udev, &fss_start, &fss_end, nframes) + buf_offset + xfer->nframes; @@ -2515,7 +2515,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer) * We currently don't care if the ISOCHRONOUS schedule is * full! */ - error = usb2_fs_isoc_schedule_alloc(fss, &sa, *plen); + error = usbd_fs_isoc_schedule_alloc(fss, &sa, *plen); if (error) { /* * The FULL speed schedule is FULL! Set length @@ -2525,17 +2525,17 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer) } if (*plen) { /* - * only call "usb2_get_page()" when we have a + * only call "usbd_get_page()" when we have a * non-zero length */ - usb2_get_page(xfer->frbuffers, buf_offset, &buf_res); + usbd_get_page(xfer->frbuffers, buf_offset, &buf_res); td->sitd_bp[0] = htohc32(sc, buf_res.physaddr); buf_offset += *plen; /* * NOTE: We need to subtract one from the offset so * that we are on a valid page! */ - usb2_get_page(xfer->frbuffers, buf_offset - 1, + usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); temp = buf_res.physaddr & ~0xFFF; } else { @@ -2588,7 +2588,7 @@ ehci_device_isoc_fs_enter(struct usb_xfer *xfer) EHCI_SITD_ACTIVE | EHCI_SITD_SET_LEN(*plen)); } - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); #if USB_DEBUG if (ehcidebug > 15) { @@ -2673,7 +2673,7 @@ ehci_device_isoc_hs_open(struct usb_xfer *xfer) /* set transfer multiplier */ td->itd_bp[2] = htohc32(sc, xfer->max_packet_count & 3); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } } } @@ -2745,7 +2745,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset + + usb_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset + ((xfer->nframes + 7) / 8); /* get the real number of frames */ @@ -2812,7 +2812,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer) itd_offset[td_no] = buf_offset; /* get first page offset */ - usb2_get_page(xfer->frbuffers, itd_offset[0], &buf_res); + usbd_get_page(xfer->frbuffers, itd_offset[0], &buf_res); /* get page address */ page_addr = buf_res.physaddr & ~0xFFF; /* update page address */ @@ -2832,9 +2832,9 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer) * we don't go off the last * page! */ - usb2_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); + usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); } else { - usb2_get_page(xfer->frbuffers, itd_offset[x + 1], &buf_res); + usbd_get_page(xfer->frbuffers, itd_offset[x + 1], &buf_res); } /* check if we need a new page */ @@ -2855,7 +2855,7 @@ ehci_device_isoc_hs_enter(struct usb_xfer *xfer) if (nframes == 0) { td->itd_status[7] |= htohc32(sc, EHCI_ITD_IOC); } - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); #if USB_DEBUG if (ehcidebug > 15) { DPRINTF("HS-TD %d\n", nframes); @@ -3081,7 +3081,7 @@ ehci_roothub_exec(struct usb_device *udev, break; } - len = usb2_make_str_desc( + len = usb_make_str_desc( sc->sc_hub_desc.temp, sizeof(sc->sc_hub_desc.temp), str_ptr); @@ -3156,13 +3156,13 @@ ehci_roothub_exec(struct usb_device *udev, EOWRITE4(sc, port, v | EHCI_PS_FPR); } /* wait 20ms for resume sequence to complete */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); EOWRITE4(sc, port, v & ~(EHCI_PS_SUSP | EHCI_PS_FPR | (3 << 10) /* High Speed */ )); /* 4ms settle time */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250); break; case UHF_PORT_POWER: EOWRITE4(sc, port, v & ~EHCI_PS_PP); @@ -3313,7 +3313,7 @@ ehci_roothub_exec(struct usb_device *udev, EOWRITE4(sc, port, v | EHCI_PS_PR); /* Wait for reset to complete. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY)); /* Terminate reset sequence. */ @@ -3321,7 +3321,7 @@ ehci_roothub_exec(struct usb_device *udev, EOWRITE4(sc, port, v); /* Wait for HC to complete reset. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(EHCI_PORT_RESET_COMPLETE)); v = EOREAD4(sc, port); @@ -3438,7 +3438,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 1; nqtd = ((2 * xfer->nframes) + 1 /* STATUS */ @@ -3451,7 +3451,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 1; nqtd = ((2 * xfer->nframes) @@ -3473,7 +3473,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 1; nqtd = ((2 * xfer->nframes) @@ -3486,7 +3486,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_frame_size = 0x3FF; xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nsitd = xfer->nframes; @@ -3497,7 +3497,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_frame_size = 0xC00; xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = (xfer->nframes + 7) / 8; @@ -3507,7 +3507,7 @@ ehci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_packet_count = 1; parm->hc_max_frame_size = 0x400; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); } alloc_dma_set: @@ -3520,7 +3520,7 @@ alloc_dma_set: */ last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ehci_itd_t), EHCI_ITD_ALIGN, nitd)) { parm->err = USB_ERR_NOMEM; @@ -3530,7 +3530,7 @@ alloc_dma_set: for (n = 0; n != nitd; n++) { ehci_itd_t *td; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); td = page_info.buffer; @@ -3541,10 +3541,10 @@ alloc_dma_set: last_obj = td; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ehci_sitd_t), EHCI_SITD_ALIGN, nsitd)) { parm->err = USB_ERR_NOMEM; @@ -3554,7 +3554,7 @@ alloc_dma_set: for (n = 0; n != nsitd; n++) { ehci_sitd_t *td; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); td = page_info.buffer; @@ -3565,10 +3565,10 @@ alloc_dma_set: last_obj = td; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ehci_qtd_t), EHCI_QTD_ALIGN, nqtd)) { parm->err = USB_ERR_NOMEM; @@ -3578,7 +3578,7 @@ alloc_dma_set: for (n = 0; n != nqtd; n++) { ehci_qtd_t *qtd; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); qtd = page_info.buffer; @@ -3589,14 +3589,14 @@ alloc_dma_set: last_obj = qtd; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj; last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ehci_qh_t), EHCI_QH_ALIGN, nqh)) { parm->err = USB_ERR_NOMEM; @@ -3606,7 +3606,7 @@ alloc_dma_set: for (n = 0; n != nqh; n++) { ehci_qh_t *qh; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); qh = page_info.buffer; @@ -3617,7 +3617,7 @@ alloc_dma_set: last_obj = qh; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj; diff --git a/sys/dev/usb/controller/ehci_ixp4xx.c b/sys/dev/usb/controller/ehci_ixp4xx.c index 672a6ee..a29375f 100644 --- a/sys/dev/usb/controller/ehci_ixp4xx.c +++ b/sys/dev/usb/controller/ehci_ixp4xx.c @@ -131,7 +131,7 @@ ehci_ixp_attach(device_t self) sc->sc_bus.devices_max = EHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) { return (ENOMEM); } @@ -273,7 +273,7 @@ ehci_ixp_detach(device_t self) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); return (0); } diff --git a/sys/dev/usb/controller/ehci_mbus.c b/sys/dev/usb/controller/ehci_mbus.c index eb9c101..73a8faf 100644 --- a/sys/dev/usb/controller/ehci_mbus.c +++ b/sys/dev/usb/controller/ehci_mbus.c @@ -140,7 +140,7 @@ ehci_mbus_attach(device_t self) sc->sc_bus.devices_max = EHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) { return (ENOMEM); } @@ -307,7 +307,7 @@ ehci_mbus_detach(device_t self) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); return (0); } diff --git a/sys/dev/usb/controller/ehci_pci.c b/sys/dev/usb/controller/ehci_pci.c index 744f5f5..77efeb3 100644 --- a/sys/dev/usb/controller/ehci_pci.c +++ b/sys/dev/usb/controller/ehci_pci.c @@ -231,7 +231,7 @@ ehci_pci_attach(device_t self) sc->sc_bus.devices_max = EHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), &ehci_iterate_hw_softc)) { return (ENOMEM); } @@ -408,7 +408,7 @@ ehci_pci_detach(device_t self) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc); return (0); } @@ -453,7 +453,7 @@ ehci_pci_takecontroller(device_t self) "timed out waiting for BIOS\n"); break; } - usb2_pause_mtx(NULL, hz / 100); /* wait 10ms */ + usb_pause_mtx(NULL, hz / 100); /* wait 10ms */ } } } diff --git a/sys/dev/usb/controller/musb_otg.c b/sys/dev/usb/controller/musb_otg.c index d242574..22ce005 100644 --- a/sys/dev/usb/controller/musb_otg.c +++ b/sys/dev/usb/controller/musb_otg.c @@ -209,7 +209,7 @@ musbotg_wakeup_peer(struct musbotg_softc *sc) /* wait 8 milliseconds */ /* Wait for reset to complete. */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125); temp = MUSB2_READ_1(sc, MUSB2_REG_POWER); temp &= ~MUSB2_MASK_RESUME; @@ -301,7 +301,7 @@ musbotg_setup_rx(struct musbotg_td *td) MUSB2_REG_EPFIFO(0), (void *)&req, sizeof(req)); /* copy data into real buffer */ - usb2_copy_in(td->pc, 0, &req, sizeof(req)); + usbd_copy_in(td->pc, 0, &req, sizeof(req)); td->offset = sizeof(req); td->remainder = 0; @@ -404,7 +404,7 @@ musbotg_setup_data_rx(struct musbotg_td *td) while (count > 0) { uint32_t temp; - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -428,7 +428,7 @@ musbotg_setup_data_rx(struct musbotg_td *td) MUSB2_REG_EPFIFO(0), (void *)(&sc->sc_bounce_buf[count / 4]), temp); } - usb2_copy_in(td->pc, td->offset, + usbd_copy_in(td->pc, td->offset, sc->sc_bounce_buf, count); /* update offset and remainder */ @@ -522,7 +522,7 @@ musbotg_setup_data_tx(struct musbotg_td *td) while (count > 0) { uint32_t temp; - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -531,7 +531,7 @@ musbotg_setup_data_tx(struct musbotg_td *td) /* check for unaligned memory address */ if (USB_P2U(buf_res.buffer) & 3) { - usb2_copy_out(td->pc, td->offset, + usbd_copy_out(td->pc, td->offset, sc->sc_bounce_buf, count); temp = count & ~3; @@ -692,7 +692,7 @@ repeat: while (count > 0) { uint32_t temp; - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -716,7 +716,7 @@ repeat: sc->sc_io_hdl, MUSB2_REG_EPFIFO(td->ep_no), ((void *)&sc->sc_bounce_buf[count / 4]), temp); } - usb2_copy_in(td->pc, td->offset, + usbd_copy_in(td->pc, td->offset, sc->sc_bounce_buf, count); /* update offset and remainder */ @@ -810,7 +810,7 @@ repeat: while (count > 0) { uint32_t temp; - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -819,7 +819,7 @@ repeat: /* check for unaligned memory address */ if (USB_P2U(buf_res.buffer) & 3) { - usb2_copy_out(td->pc, td->offset, + usbd_copy_out(td->pc, td->offset, sc->sc_bounce_buf, count); temp = count & ~3; @@ -1115,7 +1115,7 @@ musbotg_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(8, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.max_frame_size = xfer->max_frame_size; @@ -1297,11 +1297,11 @@ musbotg_start_standard_chain(struct usb_xfer *xfer) DPRINTFN(14, "enabled interrupts on endpoint\n"); /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, + usbd_transfer_timeout_ms(xfer, &musbotg_timeout, xfer->timeout); } } @@ -1449,7 +1449,7 @@ musbotg_device_done(struct usb_xfer *xfer, usb_error_t error) DPRINTFN(14, "disabled interrupts on endpoint\n"); } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } static void @@ -1689,7 +1689,7 @@ musbotg_init(struct musbotg_softc *sc) (sc->sc_clocks_on) (sc->sc_clocks_arg); } /* wait a little for things to stabilise */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); /* disable all interrupts */ @@ -1702,7 +1702,7 @@ musbotg_init(struct musbotg_softc *sc) musbotg_pull_common(sc, 0); /* wait a little bit (10ms) */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); /* disable double packet buffering */ MUSB2_WRITE_2(sc, MUSB2_REG_RXDBDIS, 0xFFFF); @@ -2011,7 +2011,7 @@ musbotg_device_isoc_enter(struct usb_xfer *xfer) */ temp = (nframes - xfer->endpoint->isoc_next) & MUSB2_MASK_FRAME; - if (usb2_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { + if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { fs_frames = (xfer->nframes + 7) / 8; } else { fs_frames = xfer->nframes; @@ -2039,7 +2039,7 @@ musbotg_device_isoc_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + fs_frames; /* compute frame number for next insertion */ @@ -2581,7 +2581,7 @@ musbotg_xfer_setup(struct usb_setup_params *parm) else parm->hc_max_packet_count = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* * compute maximum number of TDs @@ -2608,7 +2608,7 @@ musbotg_xfer_setup(struct usb_setup_params *parm) } /* - * check if "usb2_transfer_setup_sub" set an error + * check if "usbd_transfer_setup_sub" set an error */ if (parm->err) { return; diff --git a/sys/dev/usb/controller/musb_otg_atmelarm.c b/sys/dev/usb/controller/musb_otg_atmelarm.c index 2589287..fa5f7ed 100644 --- a/sys/dev/usb/controller/musb_otg_atmelarm.c +++ b/sys/dev/usb/controller/musb_otg_atmelarm.c @@ -99,7 +99,7 @@ musbotg_attach(device_t dev) sc->sc_otg.sc_bus.devices_max = MUSB2_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_otg.sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_otg.sc_bus, USB_GET_DMA_TAG(dev), NULL)) { return (ENOMEM); } @@ -192,7 +192,7 @@ musbotg_detach(device_t dev) sc->sc_otg.sc_io_res); sc->sc_otg.sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL); + usb_bus_mem_free_all(&sc->sc_otg.sc_bus, NULL); return (0); } diff --git a/sys/dev/usb/controller/ohci.c b/sys/dev/usb/controller/ohci.c index 2e6e6bc..5bce062 100644 --- a/sys/dev/usb/controller/ohci.c +++ b/sys/dev/usb/controller/ohci.c @@ -115,7 +115,7 @@ struct ohci_std_temp { static struct ohci_hcca * ohci_get_hcca(ohci_softc_t *sc) { - usb2_pc_cpu_invalidate(&sc->sc_hw.hcca_pc); + usb_pc_cpu_invalidate(&sc->sc_hw.hcca_pc); return (sc->sc_hcca_p); } @@ -162,7 +162,7 @@ ohci_controller_init(ohci_softc_t *sc) DPRINTF("SMM active, request owner change\n"); OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_OCR); for (i = 0; (i < 100) && (ctl & OHCI_IR); i++) { - usb2_pause_mtx(NULL, hz / 1000); + usb_pause_mtx(NULL, hz / 1000); ctl = OREAD4(sc, OHCI_CONTROL); } if (ctl & OHCI_IR) { @@ -175,7 +175,7 @@ ohci_controller_init(ohci_softc_t *sc) DPRINTF("cold started\n"); reset: /* controller was cold started */ - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_BUS_RESET_DELAY)); } @@ -186,7 +186,7 @@ reset: DPRINTF("%s: resetting\n", device_get_nameunit(sc->sc_bus.bdev)); OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_BUS_RESET_DELAY)); /* we now own the host controller and the bus has been reset */ @@ -214,13 +214,13 @@ reset: /* The controller is now in SUSPEND state, we have 2ms to finish. */ /* set up HC registers */ - usb2_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res); OWRITE4(sc, OHCI_HCCA, buf_res.physaddr); - usb2_get_page(&sc->sc_hw.ctrl_start_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.ctrl_start_pc, 0, &buf_res); OWRITE4(sc, OHCI_CONTROL_HEAD_ED, buf_res.physaddr); - usb2_get_page(&sc->sc_hw.bulk_start_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.bulk_start_pc, 0, &buf_res); OWRITE4(sc, OHCI_BULK_HEAD_ED, buf_res.physaddr); /* disable all interrupts and then switch on all desired interrupts */ @@ -249,7 +249,7 @@ reset: desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A); OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca | OHCI_NOCP); OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); /* Enable port power */ - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(OHCI_ENABLE_POWER_DELAY)); OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca); @@ -259,7 +259,7 @@ reset: */ sc->sc_noport = 0; for (i = 0; (i < 10) && (sc->sc_noport == 0); i++) { - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(OHCI_READ_DESC_DELAY)); sc->sc_noport = OHCI_GET_NDP(OREAD4(sc, OHCI_RH_DESCRIPTOR_A)); } @@ -278,7 +278,7 @@ ohci_init_ed(struct usb_page_cache *pc) struct usb_page_search buf_res; struct ohci_ed *ed; - usb2_get_page(pc, 0, &buf_res); + usbd_get_page(pc, 0, &buf_res); ed = buf_res.buffer; @@ -359,7 +359,7 @@ ohci_init(ohci_softc_t *sc) ed_int->next = ed_isc; ed_int->ed_next = ed_isc->ed_self; } - usb2_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.hcca_pc, 0, &buf_res); sc->sc_hcca_p = buf_res.buffer; @@ -373,12 +373,12 @@ ohci_init(ohci_softc_t *sc) } /* flush all cache into memory */ - usb2_bus_mem_flush_all(&sc->sc_bus, &ohci_iterate_hw_softc); + usb_bus_mem_flush_all(&sc->sc_bus, &ohci_iterate_hw_softc); /* set up the bus struct */ sc->sc_bus.methods = &ohci_bus_methods; - usb2_callout_init_mtx(&sc->sc_tmo_rhsc, &sc->sc_bus.bus_mtx, 0); + usb_callout_init_mtx(&sc->sc_tmo_rhsc, &sc->sc_bus.bus_mtx, 0); #if USB_DEBUG if (ohcidebug > 15) { @@ -410,7 +410,7 @@ ohci_detach(struct ohci_softc *sc) { USB_BUS_LOCK(&sc->sc_bus); - usb2_callout_stop(&sc->sc_tmo_rhsc); + usb_callout_stop(&sc->sc_tmo_rhsc); OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS); OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); @@ -418,9 +418,9 @@ ohci_detach(struct ohci_softc *sc) USB_BUS_UNLOCK(&sc->sc_bus); /* XXX let stray task complete */ - usb2_pause_mtx(NULL, hz / 20); + usb_pause_mtx(NULL, hz / 20); - usb2_callout_drain(&sc->sc_tmo_rhsc); + usb_callout_drain(&sc->sc_tmo_rhsc); } /* NOTE: suspend/resume is called from @@ -452,7 +452,7 @@ ohci_suspend(ohci_softc_t *sc) ctl |= OHCI_HCFS_SUSPEND; OWRITE4(sc, OHCI_CONTROL, ctl); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_WAIT)); USB_BUS_UNLOCK(&sc->sc_bus); @@ -483,11 +483,11 @@ ohci_resume(ohci_softc_t *sc) ctl = OREAD4(sc, OHCI_CONTROL); ctl |= OHCI_HCFS_RESUME; OWRITE4(sc, OHCI_CONTROL, ctl); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_DELAY)); ctl = (ctl & ~OHCI_HCFS_MASK) | OHCI_HCFS_OPERATIONAL; OWRITE4(sc, OHCI_CONTROL, ctl); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_RECOVERY)); sc->sc_control = sc->sc_intre = 0; @@ -557,7 +557,7 @@ ohci_dump_td(ohci_td_t *std) uint32_t td_flags; uint8_t temp; - usb2_pc_cpu_invalidate(std->page_cache); + usb_pc_cpu_invalidate(std->page_cache); td_flags = le32toh(std->td_flags); temp = (std->td_next == 0); @@ -587,7 +587,7 @@ ohci_dump_itd(ohci_itd_t *sitd) uint16_t i; uint8_t temp; - usb2_pc_cpu_invalidate(sitd->page_cache); + usb_pc_cpu_invalidate(sitd->page_cache); itd_flags = le32toh(sitd->itd_flags); temp = (sitd->itd_next == 0); @@ -627,7 +627,7 @@ ohci_dump_ed(ohci_ed_t *sed) uint32_t ed_flags; uint32_t ed_headp; - usb2_pc_cpu_invalidate(sed->page_cache); + usb_pc_cpu_invalidate(sed->page_cache); ed_flags = le32toh(sed->ed_flags); ed_headp = le32toh(sed->ed_headp); @@ -660,11 +660,11 @@ ohci_transfer_intr_enqueue(struct usb_xfer *xfer) return; } /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, &ohci_timeout, xfer->timeout); + usbd_transfer_timeout_ms(xfer, &ohci_timeout, xfer->timeout); } } @@ -687,7 +687,7 @@ _ohci_append_qh(ohci_ed_t *sed, ohci_ed_t *last) sed->prev = last; - usb2_pc_cpu_flush(sed->page_cache); + usb_pc_cpu_flush(sed->page_cache); /* * the last->next->prev is never followed: sed->next->prev = sed; @@ -696,7 +696,7 @@ _ohci_append_qh(ohci_ed_t *sed, ohci_ed_t *last) last->next = sed; last->ed_next = sed->ed_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (sed); } @@ -715,17 +715,17 @@ _ohci_remove_qh(ohci_ed_t *sed, ohci_ed_t *last) sed->prev->next = sed->next; sed->prev->ed_next = sed->ed_next; - usb2_pc_cpu_flush(sed->prev->page_cache); + usb_pc_cpu_flush(sed->prev->page_cache); if (sed->next) { sed->next->prev = sed->prev; - usb2_pc_cpu_flush(sed->next->page_cache); + usb_pc_cpu_flush(sed->next->page_cache); } last = ((last == sed) ? sed->prev : last); sed->prev = 0; - usb2_pc_cpu_flush(sed->page_cache); + usb_pc_cpu_flush(sed->page_cache); } return (last); } @@ -750,7 +750,7 @@ ohci_isoc_done(struct usb_xfer *xfer) ohci_dump_itd(td); } #endif - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); nframes = td->frames; olen = &td->itd_offset[0]; @@ -832,7 +832,7 @@ ohci_non_isoc_done_sub(struct usb_xfer *xfer) } while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); phy_start = le32toh(td->td_cbp); td_flags = le32toh(td->td_flags); cc = OHCI_TD_GET_CC(td_flags); @@ -971,7 +971,7 @@ ohci_check_transfer_sub(struct usb_xfer *xfer) while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); phy_start = le32toh(td->td_cbp); td_flags = le32toh(td->td_flags); td_next = le32toh(td->td_next); @@ -1011,7 +1011,7 @@ ohci_check_transfer_sub(struct usb_xfer *xfer) ed = xfer->qh_start[xfer->flags_int.curr_dma_set]; ed->ed_headp = td->td_self; - usb2_pc_cpu_flush(ed->page_cache); + usb_pc_cpu_flush(ed->page_cache); DPRINTFN(13, "xfer=%p following alt next\n", xfer); @@ -1052,7 +1052,7 @@ ohci_check_transfer(struct usb_xfer *xfer) ed = xfer->qh_start[xfer->flags_int.curr_dma_set]; - usb2_pc_cpu_invalidate(ed->page_cache); + usb_pc_cpu_invalidate(ed->page_cache); ed_headp = le32toh(ed->ed_headp); ed_tailp = le32toh(ed->ed_tailp); @@ -1169,7 +1169,7 @@ ohci_interrupt(ohci_softc_t *sc) } hcca->hcca_done_head = 0; - usb2_pc_cpu_flush(&sc->sc_hw.hcca_pc); + usb_pc_cpu_flush(&sc->sc_hw.hcca_pc); } else { status = OREAD4(sc, OHCI_INTERRUPT_STATUS) & ~OHCI_WDH; } @@ -1215,7 +1215,7 @@ ohci_interrupt(ohci_softc_t *sc) ohci_root_intr(sc); /* do not allow RHSC interrupts > 1 per second */ - usb2_callout_reset(&sc->sc_tmo_rhsc, hz, + usb_callout_reset(&sc->sc_tmo_rhsc, hz, (void *)&ohci_rhsc_enable, sc); } } @@ -1351,11 +1351,11 @@ restart: } else { - usb2_get_page(temp->pc, buf_offset, &buf_res); + usbd_get_page(temp->pc, buf_offset, &buf_res); td->td_cbp = htole32(buf_res.physaddr); buf_offset += (average - 1); - usb2_get_page(temp->pc, buf_offset, &buf_res); + usbd_get_page(temp->pc, buf_offset, &buf_res); td->td_be = htole32(buf_res.physaddr); buf_offset++; @@ -1380,7 +1380,7 @@ restart: td->alt_next = td_alt_next; - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } if (precompute) { @@ -1416,7 +1416,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.average = xfer->max_hc_frame_size; temp.max_frame_size = xfer->max_frame_size; @@ -1558,7 +1558,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last) td->td_flags &= ~htole32(OHCI_TD_INTR_MASK); td->td_flags |= htole32(OHCI_TD_SET_DI(1)); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); /* must have at least one frame! */ @@ -1604,7 +1604,7 @@ ohci_setup_standard_chain(struct usb_xfer *xfer, ohci_ed_t **ed_last) OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF); } } else { - usb2_pc_cpu_flush(ed->page_cache); + usb_pc_cpu_flush(ed->page_cache); } } @@ -1659,7 +1659,7 @@ ohci_device_done(struct usb_xfer *xfer, usb_error_t error) ed = xfer->qh_start[xfer->flags_int.curr_dma_set]; if (ed) { - usb2_pc_cpu_invalidate(ed->page_cache); + usb_pc_cpu_invalidate(ed->page_cache); } if (methods == &ohci_device_bulk_methods) { OHCI_REMOVE_QH(ed, sc->sc_bulk_p_last); @@ -1677,7 +1677,7 @@ ohci_device_done(struct usb_xfer *xfer, usb_error_t error) xfer->td_transfer_last = NULL; /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } /*------------------------------------------------------------------------* @@ -1897,7 +1897,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - (usb2_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset + + (usb_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset + xfer->nframes); /* get the real number of frames */ @@ -1957,12 +1957,12 @@ ohci_device_isoc_enter(struct usb_xfer *xfer) htole16(OHCI_ITD_MK_OFFS(0)); } } else { - usb2_get_page(xfer->frbuffers, buf_offset - length, &buf_res); + usbd_get_page(xfer->frbuffers, buf_offset - length, &buf_res); length = OHCI_PAGE_MASK(buf_res.physaddr); buf_res.physaddr = OHCI_PAGE(buf_res.physaddr); td->itd_bp0 = htole32(buf_res.physaddr); - usb2_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); + usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); td->itd_be = htole32(buf_res.physaddr); while (ncur--) { @@ -1982,7 +1982,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer) /* link the last TD with the next one */ td_last->itd_next = td->itd_self; } - usb2_pc_cpu_flush(td_last->page_cache); + usb_pc_cpu_flush(td_last->page_cache); } } @@ -1991,7 +1991,7 @@ ohci_device_isoc_enter(struct usb_xfer *xfer) td_last->itd_flags |= htole32(OHCI_ITD_SET_DI(0)); td_last->itd_next = 0; - usb2_pc_cpu_flush(td_last->page_cache); + usb_pc_cpu_flush(td_last->page_cache); xfer->td_transfer_last = td_last; @@ -2189,7 +2189,7 @@ ohci_roothub_exec(struct usb_device *udev, break; } - len = usb2_make_str_desc( + len = usb_make_str_desc( sc->sc_hub_desc.temp, sizeof(sc->sc_hub_desc.temp), str_ptr); @@ -2365,7 +2365,7 @@ ohci_roothub_exec(struct usb_device *udev, OWRITE4(sc, port, UPS_RESET); for (v = 0;; v++) { if (v < 12) { - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY)); if ((OREAD4(sc, port) & UPS_RESET) == 0) { @@ -2424,7 +2424,7 @@ ohci_xfer_setup(struct usb_setup_params *parm) if (parm->methods == &ohci_device_ctrl_methods) { xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = 0; ntd = ((2 * xfer->nframes) + 1 /* STATUS */ @@ -2434,7 +2434,7 @@ ohci_xfer_setup(struct usb_setup_params *parm) } else if (parm->methods == &ohci_device_bulk_methods) { xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = 0; ntd = ((2 * xfer->nframes) @@ -2444,7 +2444,7 @@ ohci_xfer_setup(struct usb_setup_params *parm) } else if (parm->methods == &ohci_device_intr_methods) { xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = 0; ntd = ((2 * xfer->nframes) @@ -2454,7 +2454,7 @@ ohci_xfer_setup(struct usb_setup_params *parm) } else if (parm->methods == &ohci_device_isoc_methods) { xfer->flags_int.bdma_enable = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = ((xfer->max_data_length / OHCI_PAGE_SIZE) + ((xfer->nframes + OHCI_ITD_NOFFSET - 1) / OHCI_ITD_NOFFSET) + @@ -2464,7 +2464,7 @@ ohci_xfer_setup(struct usb_setup_params *parm) } else { - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nitd = 0; ntd = 0; @@ -2478,7 +2478,7 @@ alloc_dma_set: } last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ohci_td_t), OHCI_TD_ALIGN, ntd)) { parm->err = USB_ERR_NOMEM; @@ -2488,7 +2488,7 @@ alloc_dma_set: for (n = 0; n != ntd; n++) { ohci_td_t *td; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); td = page_info.buffer; @@ -2499,10 +2499,10 @@ alloc_dma_set: last_obj = td; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ohci_itd_t), OHCI_ITD_ALIGN, nitd)) { parm->err = USB_ERR_NOMEM; @@ -2512,7 +2512,7 @@ alloc_dma_set: for (n = 0; n != nitd; n++) { ohci_itd_t *itd; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); itd = page_info.buffer; @@ -2523,14 +2523,14 @@ alloc_dma_set: last_obj = itd; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj; last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(ohci_ed_t), OHCI_ED_ALIGN, nqh)) { parm->err = USB_ERR_NOMEM; @@ -2540,7 +2540,7 @@ alloc_dma_set: for (n = 0; n != nqh; n++) { ohci_ed_t *ed; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); ed = page_info.buffer; @@ -2551,7 +2551,7 @@ alloc_dma_set: last_obj = ed; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj; diff --git a/sys/dev/usb/controller/ohci_atmelarm.c b/sys/dev/usb/controller/ohci_atmelarm.c index 0f213c5..a757611 100644 --- a/sys/dev/usb/controller/ohci_atmelarm.c +++ b/sys/dev/usb/controller/ohci_atmelarm.c @@ -73,7 +73,7 @@ ohci_atmelarm_attach(device_t dev) sc->sc_ohci.sc_bus.devices_max = OHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_ohci.sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_ohci.sc_bus, USB_GET_DMA_TAG(dev), &ohci_iterate_hw_softc)) { return (ENOMEM); } @@ -191,7 +191,7 @@ ohci_atmelarm_detach(device_t dev) sc->sc_ohci.sc_io_res); sc->sc_ohci.sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_ohci.sc_bus, &ohci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_ohci.sc_bus, &ohci_iterate_hw_softc); return (0); } diff --git a/sys/dev/usb/controller/ohci_pci.c b/sys/dev/usb/controller/ohci_pci.c index 031be52..76943c4 100644 --- a/sys/dev/usb/controller/ohci_pci.c +++ b/sys/dev/usb/controller/ohci_pci.c @@ -199,7 +199,7 @@ ohci_pci_attach(device_t self) sc->sc_bus.devices_max = OHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), &ohci_iterate_hw_softc)) { return (ENOMEM); } @@ -353,7 +353,7 @@ ohci_pci_detach(device_t self) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, &ohci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_bus, &ohci_iterate_hw_softc); return (0); } diff --git a/sys/dev/usb/controller/uhci.c b/sys/dev/usb/controller/uhci.c index d1ec1d1..6d6a67e 100644 --- a/sys/dev/usb/controller/uhci.c +++ b/sys/dev/usb/controller/uhci.c @@ -191,13 +191,13 @@ uhci_mem_layout_init(struct uhci_mem_layout *ml, struct usb_xfer *xfer) static void uhci_mem_layout_fixup(struct uhci_mem_layout *ml, struct uhci_td *td) { - usb2_get_page(ml->buf_pc, ml->buf_offset, &ml->buf_res); + usbd_get_page(ml->buf_pc, ml->buf_offset, &ml->buf_res); if (ml->buf_res.length < td->len) { /* need to do a fixup */ - usb2_get_page(ml->fix_pc, 0, &ml->fix_res); + usbd_get_page(ml->fix_pc, 0, &ml->fix_res); td->td_buffer = htole32(ml->fix_res.physaddr); @@ -219,17 +219,17 @@ uhci_mem_layout_fixup(struct uhci_mem_layout *ml, struct uhci_td *td) if ((td->td_token & htole32(UHCI_TD_PID)) == htole32(UHCI_TD_PID_IN)) { td->fix_pc = ml->fix_pc; - usb2_pc_cpu_invalidate(ml->fix_pc); + usb_pc_cpu_invalidate(ml->fix_pc); } else { td->fix_pc = NULL; /* copy data to fixup location */ - usb2_copy_out(ml->buf_pc, ml->buf_offset, + usbd_copy_out(ml->buf_pc, ml->buf_offset, ml->fix_res.buffer, td->len); - usb2_pc_cpu_flush(ml->fix_pc); + usb_pc_cpu_flush(ml->fix_pc); } /* prepare next fixup */ @@ -266,7 +266,7 @@ uhci_restart(uhci_softc_t *sc) DPRINTFN(2, "Restarting\n"); - usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); /* Reload fresh base address */ UWRITE4(sc, UHCI_FLBASEADDR, buf_res.physaddr); @@ -278,7 +278,7 @@ uhci_restart(uhci_softc_t *sc) /* wait 10 milliseconds */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); /* check that controller has started */ @@ -308,7 +308,7 @@ uhci_reset(uhci_softc_t *sc) /* wait */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_BUS_RESET_DELAY)); /* terminate all transfers */ @@ -321,7 +321,7 @@ uhci_reset(uhci_softc_t *sc) while (n--) { /* wait one millisecond */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); if (!(UREAD2(sc, UHCI_CMD) & UHCI_CMD_HCRESET)) { goto done_1; @@ -337,7 +337,7 @@ done_1: while (n--) { /* wait one millisecond */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); /* check if HC is stopped */ if (UREAD2(sc, UHCI_STS) & UHCI_STS_HCH) { @@ -357,7 +357,7 @@ done_2: USB_BUS_UNLOCK(&sc->sc_bus); /* stop root interrupt */ - usb2_callout_drain(&sc->sc_root_intr); + usb_callout_drain(&sc->sc_root_intr); USB_BUS_LOCK(&sc->sc_bus); } @@ -392,7 +392,7 @@ uhci_init_qh(struct usb_page_cache *pc) struct usb_page_search buf_res; struct uhci_qh *qh; - usb2_get_page(pc, 0, &buf_res); + usbd_get_page(pc, 0, &buf_res); qh = buf_res.buffer; @@ -411,7 +411,7 @@ uhci_init_td(struct usb_page_cache *pc) struct usb_page_search buf_res; struct uhci_td *td; - usb2_get_page(pc, 0, &buf_res); + usbd_get_page(pc, 0, &buf_res); td = buf_res.buffer; @@ -433,7 +433,7 @@ uhci_init(uhci_softc_t *sc) DPRINTF("start\n"); - usb2_callout_init_mtx(&sc->sc_root_intr, &sc->sc_bus.bus_mtx, 0); + usb_callout_init_mtx(&sc->sc_root_intr, &sc->sc_bus.bus_mtx, 0); #if USB_DEBUG if (uhcidebug > 2) { @@ -594,7 +594,7 @@ uhci_init(uhci_softc_t *sc) struct usb_page_search buf_res; uint32_t *pframes; - usb2_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); + usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); pframes = buf_res.buffer; @@ -616,7 +616,7 @@ uhci_init(uhci_softc_t *sc) } /* flush all cache into memory */ - usb2_bus_mem_flush_all(&sc->sc_bus, &uhci_iterate_hw_softc); + usb_bus_mem_flush_all(&sc->sc_bus, &uhci_iterate_hw_softc); /* set up the bus struct */ sc->sc_bus.methods = &uhci_bus_methods; @@ -662,7 +662,7 @@ uhci_suspend(uhci_softc_t *sc) UHCICMD(sc, UHCI_CMD_EGSM); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_WAIT)); USB_BUS_UNLOCK(&sc->sc_bus); @@ -681,7 +681,7 @@ uhci_resume(uhci_softc_t *sc) UHCICMD(sc, UHCI_CMD_FGR); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_RESUME_DELAY)); /* and start traffic again */ @@ -725,7 +725,7 @@ uhci_dump_td(uhci_td_t *p) uint32_t td_token; uint8_t temp; - usb2_pc_cpu_invalidate(p->page_cache); + usb_pc_cpu_invalidate(p->page_cache); td_next = le32toh(p->td_next); td_status = le32toh(p->td_status); @@ -781,7 +781,7 @@ uhci_dump_qh(uhci_qh_t *sqh) uint32_t qh_h_next; uint32_t qh_e_next; - usb2_pc_cpu_invalidate(sqh->page_cache); + usb_pc_cpu_invalidate(sqh->page_cache); qh_h_next = le32toh(sqh->qh_h_next); qh_e_next = le32toh(sqh->qh_e_next); @@ -872,7 +872,7 @@ uhci_add_loop(uhci_softc_t *sc) /* NOTE: we don't loop back the soft pointer */ qh_lst->qh_h_next = qh_rec->qh_self; - usb2_pc_cpu_flush(qh_lst->page_cache); + usb_pc_cpu_flush(qh_lst->page_cache); } } @@ -891,7 +891,7 @@ uhci_rem_loop(uhci_softc_t *sc) qh_lst = sc->sc_last_qh_p; qh_lst->qh_h_next = htole32(UHCI_PTR_T); - usb2_pc_cpu_flush(qh_lst->page_cache); + usb_pc_cpu_flush(qh_lst->page_cache); } } @@ -903,11 +903,11 @@ uhci_transfer_intr_enqueue(struct usb_xfer *xfer) return; } /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, &uhci_timeout, xfer->timeout); + usbd_transfer_timeout_ms(xfer, &uhci_timeout, xfer->timeout); } } @@ -924,7 +924,7 @@ _uhci_append_td(uhci_td_t *std, uhci_td_t *last) std->prev = last; - usb2_pc_cpu_flush(std->page_cache); + usb_pc_cpu_flush(std->page_cache); /* * the last->next->prev is never followed: std->next->prev = std; @@ -932,7 +932,7 @@ _uhci_append_td(uhci_td_t *std, uhci_td_t *last) last->next = std; last->td_next = std->td_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (std); } @@ -955,7 +955,7 @@ _uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last) sqh->h_prev = last; - usb2_pc_cpu_flush(sqh->page_cache); + usb_pc_cpu_flush(sqh->page_cache); /* * The "last->h_next->h_prev" is never followed: @@ -966,7 +966,7 @@ _uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last) last->h_next = sqh; last->qh_h_next = sqh->qh_self; - usb2_pc_cpu_flush(last->page_cache); + usb_pc_cpu_flush(last->page_cache); return (sqh); } @@ -984,11 +984,11 @@ _uhci_remove_td(uhci_td_t *std, uhci_td_t *last) std->prev->next = std->next; std->prev->td_next = std->td_next; - usb2_pc_cpu_flush(std->prev->page_cache); + usb_pc_cpu_flush(std->prev->page_cache); if (std->next) { std->next->prev = std->prev; - usb2_pc_cpu_flush(std->next->page_cache); + usb_pc_cpu_flush(std->next->page_cache); } return ((last == std) ? std->prev : last); } @@ -1007,17 +1007,17 @@ _uhci_remove_qh(uhci_qh_t *sqh, uhci_qh_t *last) sqh->h_prev->h_next = sqh->h_next; sqh->h_prev->qh_h_next = sqh->qh_h_next; - usb2_pc_cpu_flush(sqh->h_prev->page_cache); + usb_pc_cpu_flush(sqh->h_prev->page_cache); if (sqh->h_next) { sqh->h_next->h_prev = sqh->h_prev; - usb2_pc_cpu_flush(sqh->h_next->page_cache); + usb_pc_cpu_flush(sqh->h_next->page_cache); } last = ((last == sqh) ? sqh->h_prev : last); sqh->h_prev = 0; - usb2_pc_cpu_flush(sqh->page_cache); + usb_pc_cpu_flush(sqh->page_cache); } return (last); } @@ -1039,7 +1039,7 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer) /* sync any DMA memory before doing fixups */ - usb2_bdma_post_sync(xfer); + usb_bdma_post_sync(xfer); while (nframes--) { if (td == NULL) { @@ -1055,7 +1055,7 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer) uhci_dump_td(td); } #endif - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = le32toh(td->td_status); len = UHCI_TD_GET_ACTLEN(status); @@ -1065,13 +1065,13 @@ uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer) } if (td->fix_pc) { - usb2_get_page(td->fix_pc, 0, &res); + usbd_get_page(td->fix_pc, 0, &res); /* copy data from fixup location to real location */ - usb2_pc_cpu_invalidate(td->fix_pc); + usb_pc_cpu_invalidate(td->fix_pc); - usb2_copy_in(xfer->frbuffers, offset, + usbd_copy_in(xfer->frbuffers, offset, res.buffer, len); } offset += *plen; @@ -1107,7 +1107,7 @@ uhci_non_isoc_done_sub(struct usb_xfer *xfer) } while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = le32toh(td->td_status); token = le32toh(td->td_token); @@ -1127,16 +1127,16 @@ uhci_non_isoc_done_sub(struct usb_xfer *xfer) if (td->fix_pc) { - usb2_get_page(td->fix_pc, 0, &res); + usbd_get_page(td->fix_pc, 0, &res); /* * copy data from fixup location to real * location */ - usb2_pc_cpu_invalidate(td->fix_pc); + usb_pc_cpu_invalidate(td->fix_pc); - usb2_copy_in(xfer->frbuffers + xfer->aframes, + usbd_copy_in(xfer->frbuffers + xfer->aframes, xfer->frlengths[xfer->aframes], res.buffer, len); } /* update actual length */ @@ -1218,7 +1218,7 @@ uhci_non_isoc_done(struct usb_xfer *xfer) /* sync any DMA memory before doing fixups */ - usb2_bdma_post_sync(xfer); + usb_bdma_post_sync(xfer); /* reset scanner */ @@ -1291,7 +1291,7 @@ uhci_check_transfer_sub(struct usb_xfer *xfer) while (1) { td->td_token ^= htole32(UHCI_TD_SET_DT(1)); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); if (td == xfer->td_transfer_last) { /* last transfer */ @@ -1308,7 +1308,7 @@ skip: /* update the QH */ qh->qh_e_next = td_self; - usb2_pc_cpu_flush(qh->page_cache); + usb_pc_cpu_flush(qh->page_cache); DPRINTFN(13, "xfer=%p following alt next\n", xfer); } @@ -1334,14 +1334,14 @@ uhci_check_transfer(struct usb_xfer *xfer) td = xfer->td_transfer_last; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = le32toh(td->td_status); /* check also if the first is complete */ td = xfer->td_transfer_first; - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status |= le32toh(td->td_status); if (!(status & UHCI_TD_ACTIVE)) { @@ -1359,7 +1359,7 @@ uhci_check_transfer(struct usb_xfer *xfer) td = xfer->td_transfer_cache; while (1) { - usb2_pc_cpu_invalidate(td->page_cache); + usb_pc_cpu_invalidate(td->page_cache); status = le32toh(td->td_status); token = le32toh(td->td_token); @@ -1652,7 +1652,7 @@ restart: } } - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } if (precompute) { @@ -1684,7 +1684,7 @@ uhci_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.average = xfer->max_frame_size; temp.max_frame_size = xfer->max_frame_size; @@ -1836,7 +1836,7 @@ uhci_setup_standard_chain(struct usb_xfer *xfer) td->td_status |= htole32(UHCI_TD_IOC); - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); /* must have at least one frame! */ @@ -1870,7 +1870,7 @@ uhci_device_done(struct usb_xfer *xfer, usb_error_t error) qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; if (qh) { - usb2_pc_cpu_invalidate(qh->page_cache); + usb_pc_cpu_invalidate(qh->page_cache); } if (xfer->flags_int.bandwidth_reclaimed) { xfer->flags_int.bandwidth_reclaimed = 0; @@ -1902,7 +1902,7 @@ uhci_device_done(struct usb_xfer *xfer, usb_error_t error) xfer->td_transfer_last = NULL; } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } /*------------------------------------------------------------------------* @@ -1947,7 +1947,7 @@ uhci_device_bulk_start(struct usb_xfer *xfer) uhci_add_loop(sc); xfer->flags_int.bandwidth_reclaimed = 1; } else { - usb2_pc_cpu_flush(qh->page_cache); + usb_pc_cpu_flush(qh->page_cache); } /* put transfer on interrupt queue */ @@ -2010,7 +2010,7 @@ uhci_device_ctrl_start(struct usb_xfer *xfer) UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last); } } else { - usb2_pc_cpu_flush(qh->page_cache); + usb_pc_cpu_flush(qh->page_cache); } /* put transfer on interrupt queue */ uhci_transfer_intr_enqueue(xfer); @@ -2096,7 +2096,7 @@ uhci_device_intr_start(struct usb_xfer *xfer) /* enter QHs into the controller data structures */ UHCI_APPEND_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]); } else { - usb2_pc_cpu_flush(qh->page_cache); + usb_pc_cpu_flush(qh->page_cache); } /* put transfer on interrupt queue */ @@ -2138,7 +2138,7 @@ uhci_device_isoc_open(struct usb_xfer *xfer) td->td_status = htole32(UHCI_TD_IOS); td->td_token = td_token; - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); } } } @@ -2197,7 +2197,7 @@ uhci_device_isoc_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + xfer->nframes; /* get the real number of frames */ @@ -2280,7 +2280,7 @@ uhci_device_isoc_enter(struct usb_xfer *xfer) UHCI_TD_IOS)); } - usb2_pc_cpu_flush(td->page_cache); + usb_pc_cpu_flush(td->page_cache); #if USB_DEBUG if (uhcidebug > 5) { @@ -2415,7 +2415,7 @@ uhci_portreset(uhci_softc_t *sc, uint16_t index) x = URWMASK(UREAD2(sc, port)); UWRITE2(sc, port, x | UHCI_PORTSC_PR); - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY)); DPRINTFN(4, "uhci port %d reset, status0 = 0x%04x\n", @@ -2443,7 +2443,7 @@ uhci_portreset(uhci_softc_t *sc, uint16_t index) for (lim = 0; lim < 12; lim++) { - usb2_pause_mtx(&sc->sc_bus.bus_mtx, + usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY)); x = UREAD2(sc, port); @@ -2577,7 +2577,7 @@ uhci_roothub_exec(struct usb_device *udev, break; } - len = usb2_make_str_desc + len = usb_make_str_desc (sc->sc_hub_desc.temp, sizeof(sc->sc_hub_desc.temp), str_ptr); @@ -2738,14 +2738,14 @@ uhci_roothub_exec(struct usb_device *udev, UWRITE2(sc, port, URWMASK(x)); /* wait 20ms for resume sequence to complete */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); /* clear suspend and resume detect */ UWRITE2(sc, port, URWMASK(x) & ~(UHCI_PORTSC_RD | UHCI_PORTSC_SUSP)); /* wait a little bit */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 500); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 500); sc->sc_isresumed |= (1 << index); @@ -2837,7 +2837,7 @@ uhci_root_intr(uhci_softc_t *sc) } /* restart timer */ - usb2_callout_reset(&sc->sc_root_intr, hz, + usb_callout_reset(&sc->sc_root_intr, hz, (void *)&uhci_root_intr, sc); if (sc->sc_hub_idata[0] != 0) { @@ -2874,7 +2874,7 @@ uhci_xfer_setup(struct usb_setup_params *parm) xfer->flags_int.bdma_enable = 1; xfer->flags_int.bdma_no_post_sync = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* see EHCI HC driver for proof of "ntd" formula */ @@ -2886,7 +2886,7 @@ uhci_xfer_setup(struct usb_setup_params *parm) xfer->flags_int.bdma_enable = 1; xfer->flags_int.bdma_no_post_sync = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 1; ntd = ((2 * xfer->nframes) @@ -2896,7 +2896,7 @@ uhci_xfer_setup(struct usb_setup_params *parm) xfer->flags_int.bdma_enable = 1; xfer->flags_int.bdma_no_post_sync = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 1; ntd = ((2 * xfer->nframes) @@ -2906,14 +2906,14 @@ uhci_xfer_setup(struct usb_setup_params *parm) xfer->flags_int.bdma_enable = 1; xfer->flags_int.bdma_no_post_sync = 1; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 0; ntd = xfer->nframes; } else { - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); nqh = 0; ntd = 0; @@ -2957,7 +2957,7 @@ uhci_xfer_setup(struct usb_setup_params *parm) } align = (1 << n); - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, xfer->max_frame_size, align, nfixup)) { parm->err = USB_ERR_NOMEM; @@ -2972,7 +2972,7 @@ alloc_dma_set: } last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(uhci_td_t), UHCI_TD_ALIGN, ntd)) { parm->err = USB_ERR_NOMEM; @@ -2982,7 +2982,7 @@ alloc_dma_set: for (n = 0; n != ntd; n++) { uhci_td_t *td; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); td = page_info.buffer; @@ -3003,14 +3003,14 @@ alloc_dma_set: last_obj = td; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj; last_obj = NULL; - if (usb2_transfer_setup_sub_malloc( + if (usbd_transfer_setup_sub_malloc( parm, &pc, sizeof(uhci_qh_t), UHCI_QH_ALIGN, nqh)) { parm->err = USB_ERR_NOMEM; @@ -3020,7 +3020,7 @@ alloc_dma_set: for (n = 0; n != nqh; n++) { uhci_qh_t *qh; - usb2_get_page(pc + n, 0, &page_info); + usbd_get_page(pc + n, 0, &page_info); qh = page_info.buffer; @@ -3031,7 +3031,7 @@ alloc_dma_set: last_obj = qh; - usb2_pc_cpu_flush(pc + n); + usb_pc_cpu_flush(pc + n); } } xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj; diff --git a/sys/dev/usb/controller/uhci_pci.c b/sys/dev/usb/controller/uhci_pci.c index 061a178..ed7819e 100644 --- a/sys/dev/usb/controller/uhci_pci.c +++ b/sys/dev/usb/controller/uhci_pci.c @@ -250,7 +250,7 @@ uhci_pci_attach(device_t self) sc->sc_bus.devices_max = UHCI_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self), &uhci_iterate_hw_softc)) { return ENOMEM; } @@ -409,7 +409,7 @@ uhci_pci_detach(device_t self) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, &uhci_iterate_hw_softc); + usb_bus_mem_free_all(&sc->sc_bus, &uhci_iterate_hw_softc); return (0); } diff --git a/sys/dev/usb/controller/usb_controller.c b/sys/dev/usb/controller/usb_controller.c index 1e91643..3e7c0a7 100644 --- a/sys/dev/usb/controller/usb_controller.c +++ b/sys/dev/usb/controller/usb_controller.c @@ -28,7 +28,7 @@ #include #include -#define USB_DEBUG_VAR usb2_ctrl_debug +#define USB_DEBUG_VAR usb_ctrl_debug #include #include @@ -43,66 +43,66 @@ /* function prototypes */ -static device_probe_t usb2_probe; -static device_attach_t usb2_attach; -static device_detach_t usb2_detach; +static device_probe_t usb_probe; +static device_attach_t usb_attach; +static device_detach_t usb_detach; -static void usb2_attach_sub(device_t, struct usb_bus *); -static void usb2_post_init(void *); +static void usb_attach_sub(device_t, struct usb_bus *); +static void usb_post_init(void *); /* static variables */ #if USB_DEBUG -static int usb2_ctrl_debug = 0; +static int usb_ctrl_debug = 0; SYSCTL_NODE(_hw_usb, OID_AUTO, ctrl, CTLFLAG_RW, 0, "USB controller"); -SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RW, &usb2_ctrl_debug, 0, +SYSCTL_INT(_hw_usb_ctrl, OID_AUTO, debug, CTLFLAG_RW, &usb_ctrl_debug, 0, "Debug level"); #endif -static uint8_t usb2_post_init_called = 0; +static uint8_t usb_post_init_called = 0; -static devclass_t usb2_devclass; +static devclass_t usb_devclass; -static device_method_t usb2_methods[] = { - DEVMETHOD(device_probe, usb2_probe), - DEVMETHOD(device_attach, usb2_attach), - DEVMETHOD(device_detach, usb2_detach), +static device_method_t usb_methods[] = { + DEVMETHOD(device_probe, usb_probe), + DEVMETHOD(device_attach, usb_attach), + DEVMETHOD(device_detach, usb_detach), DEVMETHOD(device_suspend, bus_generic_suspend), DEVMETHOD(device_resume, bus_generic_resume), DEVMETHOD(device_shutdown, bus_generic_shutdown), {0, 0} }; -static driver_t usb2_driver = { +static driver_t usb_driver = { .name = "usbus", - .methods = usb2_methods, + .methods = usb_methods, .size = 0, }; -DRIVER_MODULE(usbus, ohci, usb2_driver, usb2_devclass, 0, 0); -DRIVER_MODULE(usbus, uhci, usb2_driver, usb2_devclass, 0, 0); -DRIVER_MODULE(usbus, ehci, usb2_driver, usb2_devclass, 0, 0); -DRIVER_MODULE(usbus, at91_udp, usb2_driver, usb2_devclass, 0, 0); -DRIVER_MODULE(usbus, uss820, usb2_driver, usb2_devclass, 0, 0); +DRIVER_MODULE(usbus, ohci, usb_driver, usb_devclass, 0, 0); +DRIVER_MODULE(usbus, uhci, usb_driver, usb_devclass, 0, 0); +DRIVER_MODULE(usbus, ehci, usb_driver, usb_devclass, 0, 0); +DRIVER_MODULE(usbus, at91_udp, usb_driver, usb_devclass, 0, 0); +DRIVER_MODULE(usbus, uss820, usb_driver, usb_devclass, 0, 0); /*------------------------------------------------------------------------* - * usb2_probe + * usb_probe * * This function is called from "{ehci,ohci,uhci}_pci_attach()". *------------------------------------------------------------------------*/ static int -usb2_probe(device_t dev) +usb_probe(device_t dev) { DPRINTF("\n"); return (0); } /*------------------------------------------------------------------------* - * usb2_attach + * usb_attach *------------------------------------------------------------------------*/ static int -usb2_attach(device_t dev) +usb_attach(device_t dev) { struct usb_bus *bus = device_get_ivars(dev); @@ -116,20 +116,20 @@ usb2_attach(device_t dev) /* delay vfs_mountroot until the bus is explored */ bus->bus_roothold = root_mount_hold(device_get_nameunit(dev)); - if (usb2_post_init_called) { + if (usb_post_init_called) { mtx_lock(&Giant); - usb2_attach_sub(dev, bus); + usb_attach_sub(dev, bus); mtx_unlock(&Giant); - usb2_needs_explore(bus, 1); + usb_needs_explore(bus, 1); } return (0); /* return success */ } /*------------------------------------------------------------------------* - * usb2_detach + * usb_detach *------------------------------------------------------------------------*/ static int -usb2_detach(device_t dev) +usb_detach(device_t dev) { struct usb_bus *bus = device_get_softc(dev); @@ -140,7 +140,7 @@ usb2_detach(device_t dev) return (0); } /* Stop power watchdog */ - usb2_callout_drain(&bus->power_wdog); + usb_callout_drain(&bus->power_wdog); /* Let the USB explore process detach all devices. */ if (bus->bus_roothold != NULL) { @@ -149,40 +149,40 @@ usb2_detach(device_t dev) } USB_BUS_LOCK(bus); - if (usb2_proc_msignal(&bus->explore_proc, + if (usb_proc_msignal(&bus->explore_proc, &bus->detach_msg[0], &bus->detach_msg[1])) { /* ignore */ } /* Wait for detach to complete */ - usb2_proc_mwait(&bus->explore_proc, + usb_proc_mwait(&bus->explore_proc, &bus->detach_msg[0], &bus->detach_msg[1]); USB_BUS_UNLOCK(bus); /* Get rid of USB callback processes */ - usb2_proc_free(&bus->giant_callback_proc); - usb2_proc_free(&bus->non_giant_callback_proc); + usb_proc_free(&bus->giant_callback_proc); + usb_proc_free(&bus->non_giant_callback_proc); /* Get rid of USB explore process */ - usb2_proc_free(&bus->explore_proc); + usb_proc_free(&bus->explore_proc); /* Get rid of control transfer process */ - usb2_proc_free(&bus->control_xfer_proc); + usb_proc_free(&bus->control_xfer_proc); return (0); } /*------------------------------------------------------------------------* - * usb2_bus_explore + * usb_bus_explore * * This function is used to explore the device tree from the root. *------------------------------------------------------------------------*/ static void -usb2_bus_explore(struct usb_proc_msg *pm) +usb_bus_explore(struct usb_proc_msg *pm) { struct usb_bus *bus; struct usb_device *udev; @@ -207,7 +207,7 @@ usb2_bus_explore(struct usb_proc_msg *pm) /* * First update the USB power state! */ - usb2_bus_powerd(bus); + usb_bus_powerd(bus); /* * Explore the Root USB HUB. This call can sleep, * exiting Giant, which is actually Giant. @@ -225,12 +225,12 @@ usb2_bus_explore(struct usb_proc_msg *pm) } /*------------------------------------------------------------------------* - * usb2_bus_detach + * usb_bus_detach * * This function is used to detach the device tree from the root. *------------------------------------------------------------------------*/ static void -usb2_bus_detach(struct usb_proc_msg *pm) +usb_bus_detach(struct usb_proc_msg *pm) { struct usb_bus *bus; struct usb_device *udev; @@ -252,7 +252,7 @@ usb2_bus_detach(struct usb_proc_msg *pm) * Free USB Root device, but not any sub-devices, hence they * are freed by the caller of this function: */ - usb2_free_device(udev, + usb_free_device(udev, USB_UNCFG_FLAG_FREE_EP0); mtx_unlock(&Giant); @@ -262,29 +262,29 @@ usb2_bus_detach(struct usb_proc_msg *pm) } static void -usb2_power_wdog(void *arg) +usb_power_wdog(void *arg) { struct usb_bus *bus = arg; USB_BUS_LOCK_ASSERT(bus, MA_OWNED); - usb2_callout_reset(&bus->power_wdog, - 4 * hz, usb2_power_wdog, arg); + usb_callout_reset(&bus->power_wdog, + 4 * hz, usb_power_wdog, arg); USB_BUS_UNLOCK(bus); - usb2_bus_power_update(bus); + usb_bus_power_update(bus); USB_BUS_LOCK(bus); } /*------------------------------------------------------------------------* - * usb2_bus_attach + * usb_bus_attach * * This function attaches USB in context of the explore thread. *------------------------------------------------------------------------*/ static void -usb2_bus_attach(struct usb_proc_msg *pm) +usb_bus_attach(struct usb_proc_msg *pm) { struct usb_bus *bus; struct usb_device *child; @@ -342,10 +342,10 @@ usb2_bus_attach(struct usb_proc_msg *pm) /* Allocate the Root USB device */ - child = usb2_alloc_device(bus->bdev, bus, NULL, 0, 0, 1, + child = usb_alloc_device(bus->bdev, bus, NULL, 0, 0, 1, speed, USB_MODE_HOST); if (child) { - err = usb2_probe_and_attach(child, + err = usb_probe_and_attach(child, USB_IFACE_INDEX_ANY); if (!err) { if ((bus->devices[USB_ROOT_HUB_ADDR] == NULL) || @@ -362,68 +362,68 @@ usb2_bus_attach(struct usb_proc_msg *pm) if (err) { device_printf(bus->bdev, "Root HUB problem, error=%s\n", - usb2_errstr(err)); + usbd_errstr(err)); } /* set softc - we are ready */ device_set_softc(dev, bus); /* start watchdog */ - usb2_power_wdog(bus); + usb_power_wdog(bus); } /*------------------------------------------------------------------------* - * usb2_attach_sub + * usb_attach_sub * * This function creates a thread which runs the USB attach code. It * is factored out, hence it can be called at two different places in * time. During bootup this function is called from - * "usb2_post_init". During hot-plug it is called directly from the - * "usb2_attach()" method. + * "usb_post_init". During hot-plug it is called directly from the + * "usb_attach()" method. *------------------------------------------------------------------------*/ static void -usb2_attach_sub(device_t dev, struct usb_bus *bus) +usb_attach_sub(device_t dev, struct usb_bus *bus) { const char *pname = device_get_nameunit(dev); /* Initialise USB process messages */ - bus->explore_msg[0].hdr.pm_callback = &usb2_bus_explore; + bus->explore_msg[0].hdr.pm_callback = &usb_bus_explore; bus->explore_msg[0].bus = bus; - bus->explore_msg[1].hdr.pm_callback = &usb2_bus_explore; + bus->explore_msg[1].hdr.pm_callback = &usb_bus_explore; bus->explore_msg[1].bus = bus; - bus->detach_msg[0].hdr.pm_callback = &usb2_bus_detach; + bus->detach_msg[0].hdr.pm_callback = &usb_bus_detach; bus->detach_msg[0].bus = bus; - bus->detach_msg[1].hdr.pm_callback = &usb2_bus_detach; + bus->detach_msg[1].hdr.pm_callback = &usb_bus_detach; bus->detach_msg[1].bus = bus; - bus->attach_msg[0].hdr.pm_callback = &usb2_bus_attach; + bus->attach_msg[0].hdr.pm_callback = &usb_bus_attach; bus->attach_msg[0].bus = bus; - bus->attach_msg[1].hdr.pm_callback = &usb2_bus_attach; + bus->attach_msg[1].hdr.pm_callback = &usb_bus_attach; bus->attach_msg[1].bus = bus; /* Create USB explore and callback processes */ - if (usb2_proc_create(&bus->giant_callback_proc, + if (usb_proc_create(&bus->giant_callback_proc, &bus->bus_mtx, pname, USB_PRI_MED)) { printf("WARNING: Creation of USB Giant " "callback process failed.\n"); - } else if (usb2_proc_create(&bus->non_giant_callback_proc, + } else if (usb_proc_create(&bus->non_giant_callback_proc, &bus->bus_mtx, pname, USB_PRI_HIGH)) { printf("WARNING: Creation of USB non-Giant " "callback process failed.\n"); - } else if (usb2_proc_create(&bus->explore_proc, + } else if (usb_proc_create(&bus->explore_proc, &bus->bus_mtx, pname, USB_PRI_MED)) { printf("WARNING: Creation of USB explore " "process failed.\n"); - } else if (usb2_proc_create(&bus->control_xfer_proc, + } else if (usb_proc_create(&bus->control_xfer_proc, &bus->bus_mtx, pname, USB_PRI_MED)) { printf("WARNING: Creation of USB control transfer " "process failed.\n"); } else { /* Get final attach going */ USB_BUS_LOCK(bus); - if (usb2_proc_msignal(&bus->explore_proc, + if (usb_proc_msignal(&bus->explore_proc, &bus->attach_msg[0], &bus->attach_msg[1])) { /* ignore */ } @@ -432,13 +432,13 @@ usb2_attach_sub(device_t dev, struct usb_bus *bus) } /*------------------------------------------------------------------------* - * usb2_post_init + * usb_post_init * * This function is called to attach all USB busses that were found * during bootup. *------------------------------------------------------------------------*/ static void -usb2_post_init(void *arg) +usb_post_init(void *arg) { struct usb_bus *bus; devclass_t dc; @@ -448,9 +448,9 @@ usb2_post_init(void *arg) mtx_lock(&Giant); - usb2_devclass_ptr = devclass_find("usbus"); + usb_devclass_ptr = devclass_find("usbus"); - dc = usb2_devclass_ptr; + dc = usb_devclass_ptr; if (dc) { max = devclass_get_maxunit(dc) + 1; for (n = 0; n != max; n++) { @@ -459,7 +459,7 @@ usb2_post_init(void *arg) bus = device_get_ivars(dev); if (bus) { mtx_lock(&Giant); - usb2_attach_sub(dev, bus); + usb_attach_sub(dev, bus); mtx_unlock(&Giant); } } @@ -467,69 +467,69 @@ usb2_post_init(void *arg) } else { DPRINTFN(0, "no devclass\n"); } - usb2_post_init_called = 1; + usb_post_init_called = 1; /* explore all USB busses in parallell */ - usb2_needs_explore_all(); + usb_needs_explore_all(); mtx_unlock(&Giant); } -SYSINIT(usb2_post_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb2_post_init, NULL); -SYSUNINIT(usb2_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb2_bus_unload, NULL); +SYSINIT(usb_post_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_post_init, NULL); +SYSUNINIT(usb_bus_unload, SI_SUB_KLD, SI_ORDER_ANY, usb_bus_unload, NULL); /*------------------------------------------------------------------------* - * usb2_bus_mem_flush_all_cb + * usb_bus_mem_flush_all_cb *------------------------------------------------------------------------*/ #if USB_HAVE_BUSDMA static void -usb2_bus_mem_flush_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, +usb_bus_mem_flush_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, struct usb_page *pg, usb_size_t size, usb_size_t align) { - usb2_pc_cpu_flush(pc); + usb_pc_cpu_flush(pc); } #endif /*------------------------------------------------------------------------* - * usb2_bus_mem_flush_all - factored out code + * usb_bus_mem_flush_all - factored out code *------------------------------------------------------------------------*/ #if USB_HAVE_BUSDMA void -usb2_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb) +usb_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb) { if (cb) { - cb(bus, &usb2_bus_mem_flush_all_cb); + cb(bus, &usb_bus_mem_flush_all_cb); } } #endif /*------------------------------------------------------------------------* - * usb2_bus_mem_alloc_all_cb + * usb_bus_mem_alloc_all_cb *------------------------------------------------------------------------*/ #if USB_HAVE_BUSDMA static void -usb2_bus_mem_alloc_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, +usb_bus_mem_alloc_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, struct usb_page *pg, usb_size_t size, usb_size_t align) { /* need to initialize the page cache */ pc->tag_parent = bus->dma_parent_tag; - if (usb2_pc_alloc_mem(pc, pg, size, align)) { + if (usb_pc_alloc_mem(pc, pg, size, align)) { bus->alloc_failed = 1; } } #endif /*------------------------------------------------------------------------* - * usb2_bus_mem_alloc_all - factored out code + * usb_bus_mem_alloc_all - factored out code * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ uint8_t -usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, +usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, usb_bus_mem_cb_t *cb) { bus->alloc_failed = 0; @@ -537,13 +537,13 @@ usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, mtx_init(&bus->bus_mtx, device_get_nameunit(bus->parent), NULL, MTX_DEF | MTX_RECURSE); - usb2_callout_init_mtx(&bus->power_wdog, + usb_callout_init_mtx(&bus->power_wdog, &bus->bus_mtx, 0); TAILQ_INIT(&bus->intr_q.head); #if USB_HAVE_BUSDMA - usb2_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags, + usb_dma_tag_setup(bus->dma_parent_tag, bus->dma_tags, dmat, &bus->bus_mtx, NULL, 32, USB_BUS_DMA_TAG_MAX); #endif if ((bus->devices_max > USB_MAX_DEVICES) || @@ -555,38 +555,38 @@ usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, } #if USB_HAVE_BUSDMA if (cb) { - cb(bus, &usb2_bus_mem_alloc_all_cb); + cb(bus, &usb_bus_mem_alloc_all_cb); } #endif if (bus->alloc_failed) { - usb2_bus_mem_free_all(bus, cb); + usb_bus_mem_free_all(bus, cb); } return (bus->alloc_failed); } /*------------------------------------------------------------------------* - * usb2_bus_mem_free_all_cb + * usb_bus_mem_free_all_cb *------------------------------------------------------------------------*/ #if USB_HAVE_BUSDMA static void -usb2_bus_mem_free_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, +usb_bus_mem_free_all_cb(struct usb_bus *bus, struct usb_page_cache *pc, struct usb_page *pg, usb_size_t size, usb_size_t align) { - usb2_pc_free_mem(pc); + usb_pc_free_mem(pc); } #endif /*------------------------------------------------------------------------* - * usb2_bus_mem_free_all - factored out code + * usb_bus_mem_free_all - factored out code *------------------------------------------------------------------------*/ void -usb2_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb) +usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb) { #if USB_HAVE_BUSDMA if (cb) { - cb(bus, &usb2_bus_mem_free_all_cb); + cb(bus, &usb_bus_mem_free_all_cb); } - usb2_dma_tag_unsetup(bus->dma_parent_tag); + usb_dma_tag_unsetup(bus->dma_parent_tag); #endif mtx_destroy(&bus->bus_mtx); diff --git a/sys/dev/usb/controller/uss820dci.c b/sys/dev/usb/controller/uss820dci.c index f3078d3..9f29bbf 100644 --- a/sys/dev/usb/controller/uss820dci.c +++ b/sys/dev/usb/controller/uss820dci.c @@ -303,7 +303,7 @@ uss820dci_setup_rx(struct uss820dci_td *td) USS820_RXCON, temp); /* copy data into real buffer */ - usb2_copy_in(td->pc, 0, &req, sizeof(req)); + usbd_copy_in(td->pc, 0, &req, sizeof(req)); td->offset = sizeof(req); td->remainder = 0; @@ -446,7 +446,7 @@ repeat: return (0); /* we are complete */ } while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -545,7 +545,7 @@ repeat: count_copy = count; while (count > 0) { - usb2_get_page(td->pc, td->offset, &buf_res); + usbd_get_page(td->pc, td->offset, &buf_res); /* get correct length */ if (buf_res.length > count) { @@ -830,7 +830,7 @@ uss820dci_setup_standard_chain(struct usb_xfer *xfer) DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", xfer->address, UE_GET_ADDR(xfer->endpointno), - xfer->sumlen, usb2_get_speed(xfer->xroot->udev)); + xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); temp.max_frame_size = xfer->max_frame_size; @@ -1030,11 +1030,11 @@ uss820dci_start_standard_chain(struct usb_xfer *xfer) uss820dci_intr_set(xfer, 1); /* put transfer on interrupt queue */ - usb2_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); + usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); /* start timeout, if any */ if (xfer->timeout != 0) { - usb2_transfer_timeout_ms(xfer, + usbd_transfer_timeout_ms(xfer, &uss820dci_timeout, xfer->timeout); } } @@ -1179,7 +1179,7 @@ uss820dci_device_done(struct usb_xfer *xfer, usb_error_t error) uss820dci_intr_set(xfer, 0); } /* dequeue transfer and start next transfer */ - usb2_transfer_done(xfer, error); + usbd_transfer_done(xfer, error); } static void @@ -1341,7 +1341,7 @@ uss820dci_init(struct uss820dci_softc *sc) uss820dci_pull_down(sc); /* wait 10ms for pulldown to stabilise */ - usb2_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); + usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); /* check hardware revision */ temp = USS820_READ_1(sc, USS820_REV); @@ -1676,7 +1676,7 @@ uss820dci_device_isoc_fs_enter(struct usb_xfer *xfer) * pre-compute when the isochronous transfer will be finished: */ xfer->isoc_time_complete = - usb2_isoc_time_expand(&sc->sc_bus, nframes) + temp + + usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + xfer->nframes; /* compute frame number for next insertion */ @@ -2201,7 +2201,7 @@ uss820dci_xfer_setup(struct usb_setup_params *parm) parm->hc_max_packet_count = 1; parm->hc_max_frame_size = 0x500; - usb2_transfer_setup_sub(parm); + usbd_transfer_setup_sub(parm); /* * compute maximum number of TDs @@ -2228,7 +2228,7 @@ uss820dci_xfer_setup(struct usb_setup_params *parm) } /* - * check if "usb2_transfer_setup_sub" set an error + * check if "usbd_transfer_setup_sub" set an error */ if (parm->err) { return; diff --git a/sys/dev/usb/controller/uss820dci_atmelarm.c b/sys/dev/usb/controller/uss820dci_atmelarm.c index 18b0eb3..f8988b8 100644 --- a/sys/dev/usb/controller/uss820dci_atmelarm.c +++ b/sys/dev/usb/controller/uss820dci_atmelarm.c @@ -137,7 +137,7 @@ uss820_atmelarm_attach(device_t dev) sc->sc_bus.devices_max = USS820_MAX_DEVICES; /* get all DMA memory */ - if (usb2_bus_mem_alloc_all(&sc->sc_bus, + if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(dev), NULL)) { return (ENOMEM); } @@ -227,7 +227,7 @@ uss820_atmelarm_detach(device_t dev) sc->sc_io_res); sc->sc_io_res = NULL; } - usb2_bus_mem_free_all(&sc->sc_bus, NULL); + usb_bus_mem_free_all(&sc->sc_bus, NULL); return (0); } diff --git a/sys/dev/usb/input/uhid.c b/sys/dev/usb/input/uhid.c index ae5a63c..9390a69 100644 --- a/sys/dev/usb/input/uhid.c +++ b/sys/dev/usb/input/uhid.c @@ -159,7 +159,7 @@ uhid_intr_callback(struct usb_xfer *xfer) DPRINTF("transferred!\n"); if (xfer->actlen >= sc->sc_isize) { - usb2_fifo_put_data( + usb_fifo_put_data( sc->sc_fifo.fp[USB_FIFO_RX], xfer->frbuffers, 0, sc->sc_isize, 1); @@ -171,10 +171,10 @@ uhid_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: re_submit: - if (usb2_fifo_put_bytes_max( + if (usb_fifo_put_bytes_max( sc->sc_fifo.fp[USB_FIFO_RX]) != 0) { xfer->frlengths[0] = sc->sc_isize; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -227,14 +227,14 @@ uhid_write_callback(struct usb_xfer *xfer) /* try to extract the ID byte */ if (sc->sc_oid) { - if (usb2_fifo_get_data( + if (usb_fifo_get_data( sc->sc_fifo.fp[USB_FIFO_TX], xfer->frbuffers, 0, 1, &actlen, 0)) { if (actlen != 1) { goto tr_error; } - usb2_copy_out(xfer->frbuffers, 0, &id, 1); + usbd_copy_out(xfer->frbuffers, 0, &id, 1); } else { return; @@ -246,7 +246,7 @@ uhid_write_callback(struct usb_xfer *xfer) id = 0; } - if (usb2_fifo_get_data( + if (usb_fifo_get_data( sc->sc_fifo.fp[USB_FIFO_TX], xfer->frbuffers + 1, 0, UHID_BSIZE, &actlen, 1)) { @@ -257,19 +257,19 @@ uhid_write_callback(struct usb_xfer *xfer) (&req, sc->sc_iface_no, UHID_OUTPUT_REPORT, id, size); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = size; xfer->nframes = xfer->frlengths[1] ? 2 : 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: tr_error: /* bomb out */ - usb2_fifo_get_data_error(sc->sc_fifo.fp[USB_FIFO_TX]); + usb_fifo_get_data_error(sc->sc_fifo.fp[USB_FIFO_TX]); return; } } @@ -282,30 +282,30 @@ uhid_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], xfer->frbuffers, + usb_fifo_put_data(sc->sc_fifo.fp[USB_FIFO_RX], xfer->frbuffers, sizeof(req), sc->sc_isize, 1); return; case USB_ST_SETUP: - if (usb2_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) > 0) { + if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) > 0) { uhid_fill_get_report (&req, sc->sc_iface_no, UHID_INPUT_REPORT, sc->sc_iid, sc->sc_isize); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = sc->sc_isize; xfer->nframes = xfer->frlengths[1] ? 2 : 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: /* Error */ /* bomb out */ - usb2_fifo_put_data_error(sc->sc_fifo.fp[USB_FIFO_RX]); + usb_fifo_put_data_error(sc->sc_fifo.fp[USB_FIFO_RX]); return; } } @@ -346,9 +346,9 @@ uhid_start_read(struct usb_fifo *fifo) struct uhid_softc *sc = fifo->priv_sc0; if (sc->sc_flags & UHID_FLAG_IMMED) { - usb2_transfer_start(sc->sc_xfer[UHID_CTRL_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_RD]); } else { - usb2_transfer_start(sc->sc_xfer[UHID_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UHID_INTR_DT_RD]); } } @@ -357,8 +357,8 @@ uhid_stop_read(struct usb_fifo *fifo) { struct uhid_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_RD]); - usb2_transfer_stop(sc->sc_xfer[UHID_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UHID_INTR_DT_RD]); } static void @@ -366,7 +366,7 @@ uhid_start_write(struct usb_fifo *fifo) { struct uhid_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[UHID_CTRL_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UHID_CTRL_DT_WR]); } static void @@ -374,7 +374,7 @@ uhid_stop_write(struct usb_fifo *fifo) { struct uhid_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UHID_CTRL_DT_WR]); } static int @@ -393,7 +393,7 @@ uhid_get_report(struct uhid_softc *sc, uint8_t type, } free_data = 1; } - err = usb2_req_get_report(sc->sc_udev, NULL, kern_data, + err = usbd_req_get_report(sc->sc_udev, NULL, kern_data, len, sc->sc_iface_index, type, id); if (err) { err = ENXIO; @@ -433,7 +433,7 @@ uhid_set_report(struct uhid_softc *sc, uint8_t type, goto done; } } - err = usb2_req_set_report(sc->sc_udev, NULL, kern_data, + err = usbd_req_set_report(sc->sc_udev, NULL, kern_data, len, sc->sc_iface_index, type, id); if (err) { err = ENXIO; @@ -459,13 +459,13 @@ uhid_open(struct usb_fifo *fifo, int fflags) /* reset flags */ sc->sc_flags &= ~UHID_FLAG_IMMED; - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_isize + 1, UHID_FRAME_NUM)) { return (ENOMEM); } } if (fflags & FWRITE) { - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_osize + 1, UHID_FRAME_NUM)) { return (ENOMEM); } @@ -477,7 +477,7 @@ static void uhid_close(struct usb_fifo *fifo, int fflags) { if (fflags & (FREAD | FWRITE)) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } } @@ -616,7 +616,7 @@ uhid_probe(device_t dev) return (ENXIO); } } - if (usb2_test_quirk(uaa, UQ_HID_IGNORE)) { + if (usb_test_quirk(uaa, UQ_HID_IGNORE)) { return (ENXIO); } return (0); @@ -632,7 +632,7 @@ uhid_attach(device_t dev) DPRINTFN(10, "sc=%p\n", sc); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uhid lock", NULL, MTX_DEF | MTX_RECURSE); @@ -641,12 +641,12 @@ uhid_attach(device_t dev) sc->sc_iface_no = uaa->info.bIfaceNum; sc->sc_iface_index = uaa->info.bIfaceIndex; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, uhid_config, UHID_N_TRANSFER, sc, &sc->sc_mtx); if (error) { - DPRINTF("error=%s\n", usb2_errstr(error)); + DPRINTF("error=%s\n", usbd_errstr(error)); goto detach; } if (uaa->info.idVendor == USB_VENDOR_WACOM) { @@ -668,13 +668,13 @@ uhid_attach(device_t dev) * feature report ID 2 before it'll start * returning digitizer data. */ - error = usb2_req_set_report(uaa->device, NULL, + error = usbd_req_set_report(uaa->device, NULL, reportbuf, sizeof(reportbuf), uaa->info.bIfaceIndex, UHID_FEATURE_REPORT, 2); if (error) { DPRINTF("set report failed, error=%s (ignored)\n", - usb2_errstr(error)); + usbd_errstr(error)); } sc->sc_repdesc_size = sizeof(uhid_graphire3_4x5_report_descr); sc->sc_repdesc_ptr = USB_ADD_BYTES(uhid_graphire3_4x5_report_descr, 0); @@ -691,7 +691,7 @@ uhid_attach(device_t dev) } if (sc->sc_repdesc_ptr == NULL) { - error = usb2_req_get_hid_desc(uaa->device, NULL, + error = usbd_req_get_hid_desc(uaa->device, NULL, &sc->sc_repdesc_ptr, &sc->sc_repdesc_size, M_USBDEV, uaa->info.bIfaceIndex); @@ -700,12 +700,12 @@ uhid_attach(device_t dev) goto detach; } } - error = usb2_req_set_idle(uaa->device, NULL, + error = usbd_req_set_idle(uaa->device, NULL, uaa->info.bIfaceIndex, 0, 0); if (error) { DPRINTF("set idle failed, error=%s (ignored)\n", - usb2_errstr(error)); + usbd_errstr(error)); } sc->sc_isize = hid_report_size (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_input, &sc->sc_iid); @@ -735,7 +735,7 @@ uhid_attach(device_t dev) sc->sc_fsize = UHID_BSIZE; } - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &uhid_fifo_methods, &sc->sc_fifo, unit, 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); @@ -754,9 +754,9 @@ uhid_detach(device_t dev) { struct uhid_softc *sc = device_get_softc(dev); - usb2_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo); - usb2_transfer_unsetup(sc->sc_xfer, UHID_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UHID_N_TRANSFER); if (sc->sc_repdesc_ptr) { if (!(sc->sc_flags & UHID_FLAG_STATIC_DESC)) { diff --git a/sys/dev/usb/input/ukbd.c b/sys/dev/usb/input/ukbd.c index 52b2176..52062fc 100644 --- a/sys/dev/usb/input/ukbd.c +++ b/sys/dev/usb/input/ukbd.c @@ -297,14 +297,14 @@ ukbd_get_key(struct ukbd_softc *sc, uint8_t wait) if (sc->sc_inputs == 0) { /* start transfer, if not already started */ - usb2_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); + usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); } if (sc->sc_flags & UKBD_FLAG_POLLING) { DPRINTFN(2, "polling\n"); while (sc->sc_inputs == 0) { - usb2_do_poll(sc->sc_xfer, UKBD_N_TRANSFER); + usbd_do_poll(sc->sc_xfer, UKBD_N_TRANSFER); DELAY(1000); /* delay 1 ms */ @@ -454,7 +454,7 @@ ukbd_timeout(void *arg) } ukbd_interrupt(sc); - usb2_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc); + usb_callout_reset(&sc->sc_callout, hz / 40, &ukbd_timeout, sc); } static uint8_t @@ -501,7 +501,7 @@ ukbd_intr_callback(struct usb_xfer *xfer) if (sc->sc_kbd_id != 0) { /* check and remove HID ID byte */ - usb2_copy_out(xfer->frbuffers, 0, &id, 1); + usbd_copy_out(xfer->frbuffers, 0, &id, 1); if (id != sc->sc_kbd_id) { DPRINTF("wrong HID ID\n"); goto tr_setup; @@ -518,7 +518,7 @@ ukbd_intr_callback(struct usb_xfer *xfer) if (len) { memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata)); - usb2_copy_out(xfer->frbuffers, offset, + usbd_copy_out(xfer->frbuffers, offset, &sc->sc_ndata, len); if ((sc->sc_flags & UKBD_FLAG_APPLE_EJECT) && @@ -568,14 +568,14 @@ ukbd_intr_callback(struct usb_xfer *xfer) tr_setup: if (sc->sc_inputs < UKBD_IN_BUF_FULL) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } else { DPRINTF("input queue is full!\n"); } break; default: /* Error */ - DPRINTF("error=%s\n", usb2_errstr(xfer->error)); + DPRINTF("error=%s\n", usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -617,18 +617,18 @@ ukbd_set_leds_callback(struct usb_xfer *xfer) buf[1] = 0; } - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = req.wLength[0]; xfer->nframes = 2; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: /* Error */ - DPRINTFN(0, "error=%s\n", usb2_errstr(xfer->error)); + DPRINTFN(0, "error=%s\n", usbd_errstr(xfer->error)); return; } } @@ -677,13 +677,13 @@ ukbd_probe(device_t dev) if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) && (uaa->info.bInterfaceProtocol == UPROTO_BOOT_KEYBOARD)) { - if (usb2_test_quirk(uaa, UQ_KBD_IGNORE)) + if (usb_test_quirk(uaa, UQ_KBD_IGNORE)) return (ENXIO); else return (0); } - error = usb2_req_get_hid_desc(uaa->device, NULL, + error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); if (error) @@ -691,7 +691,7 @@ ukbd_probe(device_t dev) if (hid_is_collection(d_ptr, d_len, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD))) { - if (usb2_test_quirk(uaa, UQ_KBD_IGNORE)) + if (usb_test_quirk(uaa, UQ_KBD_IGNORE)) error = ENXIO; else error = 0; @@ -721,7 +721,7 @@ ukbd_attach(device_t dev) kbd->kb_data = (void *)sc; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_udev = uaa->device; sc->sc_iface = uaa->iface; @@ -729,14 +729,14 @@ ukbd_attach(device_t dev) sc->sc_iface_no = uaa->info.bIfaceNum; sc->sc_mode = K_XLATE; - usb2_callout_init_mtx(&sc->sc_callout, &Giant, 0); + usb_callout_init_mtx(&sc->sc_callout, &Giant, 0); - err = usb2_transfer_setup(uaa->device, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, ukbd_config, UKBD_N_TRANSFER, sc, &Giant); if (err) { - DPRINTF("error=%s\n", usb2_errstr(err)); + DPRINTF("error=%s\n", usbd_errstr(err)); goto detach; } /* setup default keyboard maps */ @@ -761,7 +761,7 @@ ukbd_attach(device_t dev) KBD_PROBE_DONE(kbd); /* figure out if there is an ID byte in the data */ - err = usb2_req_get_hid_desc(uaa->device, NULL, &hid_ptr, + err = usbd_req_get_hid_desc(uaa->device, NULL, &hid_ptr, &hid_len, M_TEMP, uaa->info.bIfaceIndex); if (err == 0) { uint8_t temp_id; @@ -801,7 +801,7 @@ ukbd_attach(device_t dev) } /* ignore if SETIDLE fails, hence it is not crucial */ - err = usb2_req_set_idle(sc->sc_udev, &Giant, sc->sc_iface_index, 0, 0); + err = usbd_req_set_idle(sc->sc_udev, &Giant, sc->sc_iface_index, 0, 0); ukbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state); @@ -830,7 +830,7 @@ ukbd_attach(device_t dev) /* start the keyboard */ - usb2_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); + usbd_transfer_start(sc->sc_xfer[UKBD_INTR_DT]); /* start the timer */ @@ -858,7 +858,7 @@ ukbd_detach(device_t dev) } sc->sc_flags |= UKBD_FLAG_GONE; - usb2_callout_stop(&sc->sc_callout); + usb_callout_stop(&sc->sc_callout); ukbd_disable(&sc->sc_kbd); @@ -882,9 +882,9 @@ ukbd_detach(device_t dev) } sc->sc_kbd.kb_flags = 0; - usb2_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UKBD_N_TRANSFER); - usb2_callout_drain(&sc->sc_callout); + usb_callout_drain(&sc->sc_callout); DPRINTF("%s: disconnected\n", device_get_nameunit(dev)); @@ -1492,7 +1492,7 @@ ukbd_set_leds(struct ukbd_softc *sc, uint8_t leds) /* start transfer, if not already started */ - usb2_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]); + usbd_transfer_start(sc->sc_xfer[UKBD_CTRL_LED]); } static int diff --git a/sys/dev/usb/input/ums.c b/sys/dev/usb/input/ums.c index cf8ef5f..4eff1f2 100644 --- a/sys/dev/usb/input/ums.c +++ b/sys/dev/usb/input/ums.c @@ -197,7 +197,7 @@ ums_intr_callback(struct usb_xfer *xfer) if (len == 0) goto tr_setup; - usb2_copy_out(xfer->frbuffers, 0, buf, len); + usbd_copy_out(xfer->frbuffers, 0, buf, len); DPRINTFN(6, "data = %02x %02x %02x %02x " "%02x %02x %02x %02x\n", @@ -287,11 +287,11 @@ ums_intr_callback(struct usb_xfer *xfer) (dx == 0) && (dy == 0) && (dz == 0) && (dt == 0) && (dw == 0) && (buttons == 0)) { - usb2_callout_reset(&sc->sc_callout, hz / 20, + usb_callout_reset(&sc->sc_callout, hz / 20, &ums_put_queue_timeout, sc); } else { - usb2_callout_stop(&sc->sc_callout); + usb_callout_stop(&sc->sc_callout); ums_put_queue(sc, dx, dy, dz, dt, buttons); } @@ -299,10 +299,10 @@ ums_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: /* check if we can put more data into the FIFO */ - if (usb2_fifo_put_bytes_max( + if (usb_fifo_put_bytes_max( sc->sc_fifo.fp[USB_FIFO_RX]) != 0) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -348,7 +348,7 @@ ums_probe(device_t dev) (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE)) return (0); - error = usb2_req_get_hid_desc(uaa->device, NULL, + error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); if (error) @@ -476,11 +476,11 @@ ums_attach(device_t dev) DPRINTFN(11, "sc=%p\n", sc); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ums lock", NULL, MTX_DEF | MTX_RECURSE); - usb2_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0); + usb_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0); /* * Force the report (non-boot) protocol. @@ -488,18 +488,18 @@ ums_attach(device_t dev) * Mice without boot protocol support may choose not to implement * Set_Protocol at all; Ignore any error. */ - err = usb2_req_set_protocol(uaa->device, NULL, + err = usbd_req_set_protocol(uaa->device, NULL, uaa->info.bIfaceIndex, 1); - err = usb2_transfer_setup(uaa->device, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, ums_config, UMS_N_TRANSFER, sc, &sc->sc_mtx); if (err) { - DPRINTF("error=%s\n", usb2_errstr(err)); + DPRINTF("error=%s\n", usbd_errstr(err)); goto detach; } - err = usb2_req_get_hid_desc(uaa->device, NULL, &d_ptr, + err = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex); if (err) { @@ -515,7 +515,7 @@ ums_attach(device_t dev) * all of its other button positions are all off. It also reports that * it has two addional buttons and a tilt wheel. */ - if (usb2_test_quirk(uaa, UQ_MS_BAD_CLASS)) { + if (usb_test_quirk(uaa, UQ_MS_BAD_CLASS)) { info = &sc->sc_info[0]; info->sc_flags = (UMS_FLAG_X_AXIS | UMS_FLAG_Y_AXIS | @@ -542,7 +542,7 @@ ums_attach(device_t dev) } } - if (usb2_test_quirk(uaa, UQ_MS_REVZ)) { + if (usb_test_quirk(uaa, UQ_MS_REVZ)) { info = &sc->sc_info[0]; /* Some wheels need the Z axis reversed. */ info->sc_flags |= UMS_FLAG_REVZ; @@ -599,7 +599,7 @@ ums_attach(device_t dev) sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK; sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC; - err = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + err = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &ums_fifo_methods, &sc->sc_fifo, device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); @@ -623,11 +623,11 @@ ums_detach(device_t self) DPRINTF("sc=%p\n", sc); - usb2_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo); - usb2_transfer_unsetup(sc->sc_xfer, UMS_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UMS_N_TRANSFER); - usb2_callout_drain(&sc->sc_callout); + usb_callout_drain(&sc->sc_callout); mtx_destroy(&sc->sc_mtx); @@ -639,7 +639,7 @@ ums_start_read(struct usb_fifo *fifo) { struct ums_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[UMS_INTR_DT]); + usbd_transfer_start(sc->sc_xfer[UMS_INTR_DT]); } static void @@ -647,8 +647,8 @@ ums_stop_read(struct usb_fifo *fifo) { struct ums_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[UMS_INTR_DT]); - usb2_callout_stop(&sc->sc_callout); + usbd_transfer_stop(sc->sc_xfer[UMS_INTR_DT]); + usb_callout_stop(&sc->sc_callout); } @@ -694,7 +694,7 @@ ums_put_queue(struct ums_softc *sc, int32_t dx, int32_t dy, buf[6] = dz - (dz >> 1); buf[7] = (((~buttons) >> 3) & MOUSE_SYS_EXTBUTTONS); } - usb2_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf, + usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf, sc->sc_mode.packetsize, 1); } else { @@ -706,7 +706,7 @@ static void ums_reset_buf(struct ums_softc *sc) { /* reset read queue */ - usb2_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]); + usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]); } static int @@ -728,7 +728,7 @@ ums_open(struct usb_fifo *fifo, int fflags) sc->sc_status.dz = 0; /* sc->sc_status.dt = 0; */ - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, UMS_BUF_SIZE, UMS_IFQ_MAXLEN)) { return (ENOMEM); } @@ -740,7 +740,7 @@ static void ums_close(struct usb_fifo *fifo, int fflags) { if (fflags & FREAD) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } } diff --git a/sys/dev/usb/misc/udbp.c b/sys/dev/usb/misc/udbp.c index b17f587..e856296c 100644 --- a/sys/dev/usb/misc/udbp.c +++ b/sys/dev/usb/misc/udbp.c @@ -317,17 +317,17 @@ udbp_attach(device_t dev) struct udbp_softc *sc = device_get_softc(dev); int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", device_get_nameunit(dev)); mtx_init(&sc->sc_mtx, "udbp lock", NULL, MTX_DEF | MTX_RECURSE); - error = usb2_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, + error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, udbp_config, UDBP_T_MAX, sc, &sc->sc_mtx); if (error) { - DPRINTF("error=%s\n", usb2_errstr(error)); + DPRINTF("error=%s\n", usbd_errstr(error)); goto detach; } NG_BT_MBUFQ_INIT(&sc->sc_xmitq, UDBP_Q_MAXLEN); @@ -376,7 +376,7 @@ udbp_detach(device_t dev) } /* free USB transfers, if any */ - usb2_transfer_unsetup(sc->sc_xfer, UDBP_T_MAX); + usbd_transfer_unsetup(sc->sc_xfer, UDBP_T_MAX); mtx_destroy(&sc->sc_mtx); @@ -418,7 +418,7 @@ udbp_bulk_read_callback(struct usb_xfer *xfer) } m->m_pkthdr.len = m->m_len = xfer->actlen; - usb2_copy_out(xfer->frbuffers, 0, m->m_data, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, m->m_data, xfer->actlen); sc->sc_bulk_in_buffer = m; @@ -432,18 +432,18 @@ tr_setup: return; } if (sc->sc_flags & UDBP_FLAG_READ_STALL) { - usb2_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]); return; } xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ sc->sc_flags |= UDBP_FLAG_READ_STALL; - usb2_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_RD_CS]); } return; @@ -456,10 +456,10 @@ udbp_bulk_read_clear_stall_callback(struct usb_xfer *xfer) struct udbp_softc *sc = xfer->priv_sc; struct usb_xfer *xfer_other = sc->sc_xfer[UDBP_T_RD]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); sc->sc_flags &= ~UDBP_FLAG_READ_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -498,7 +498,7 @@ done: } /* start USB bulk-in transfer, if not already started */ - usb2_transfer_start(sc->sc_xfer[UDBP_T_RD]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_RD]); mtx_unlock(&sc->sc_mtx); } @@ -516,7 +516,7 @@ udbp_bulk_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: if (sc->sc_flags & UDBP_FLAG_WRITE_STALL) { - usb2_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]); return; } /* get next mbuf, if any */ @@ -535,7 +535,7 @@ udbp_bulk_write_callback(struct usb_xfer *xfer) MCLBYTES); m->m_pkthdr.len = MCLBYTES; } - usb2_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); + usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); xfer->frlengths[0] = m->m_pkthdr.len; @@ -544,14 +544,14 @@ udbp_bulk_write_callback(struct usb_xfer *xfer) DPRINTF("packet out: %d bytes\n", xfer->frlengths[0]); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ sc->sc_flags |= UDBP_FLAG_WRITE_STALL; - usb2_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_WR_CS]); } return; @@ -564,10 +564,10 @@ udbp_bulk_write_clear_stall_callback(struct usb_xfer *xfer) struct udbp_softc *sc = xfer->priv_sc; struct usb_xfer *xfer_other = sc->sc_xfer[UDBP_T_WR]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); sc->sc_flags &= ~UDBP_FLAG_WRITE_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -725,7 +725,7 @@ ng_udbp_rcvdata(hook_p hook, item_p item) /* * start bulk-out transfer, if not already started: */ - usb2_transfer_start(sc->sc_xfer[UDBP_T_WR]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_WR]); error = 0; } @@ -793,10 +793,10 @@ ng_udbp_connect(hook_p hook) UDBP_FLAG_WRITE_STALL); /* start bulk-in transfer */ - usb2_transfer_start(sc->sc_xfer[UDBP_T_RD]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_RD]); /* start bulk-out transfer */ - usb2_transfer_start(sc->sc_xfer[UDBP_T_WR]); + usbd_transfer_start(sc->sc_xfer[UDBP_T_WR]); mtx_unlock(&sc->sc_mtx); @@ -823,12 +823,12 @@ ng_udbp_disconnect(hook_p hook) } else { /* stop bulk-in transfer */ - usb2_transfer_stop(sc->sc_xfer[UDBP_T_RD_CS]); - usb2_transfer_stop(sc->sc_xfer[UDBP_T_RD]); + usbd_transfer_stop(sc->sc_xfer[UDBP_T_RD_CS]); + usbd_transfer_stop(sc->sc_xfer[UDBP_T_RD]); /* stop bulk-out transfer */ - usb2_transfer_stop(sc->sc_xfer[UDBP_T_WR_CS]); - usb2_transfer_stop(sc->sc_xfer[UDBP_T_WR]); + usbd_transfer_stop(sc->sc_xfer[UDBP_T_WR_CS]); + usbd_transfer_stop(sc->sc_xfer[UDBP_T_WR]); /* cleanup queues */ NG_BT_MBUFQ_DRAIN(&sc->sc_xmitq); diff --git a/sys/dev/usb/misc/ufm.c b/sys/dev/usb/misc/ufm.c index 1a95702..d8e4a9e 100644 --- a/sys/dev/usb/misc/ufm.c +++ b/sys/dev/usb/misc/ufm.c @@ -38,7 +38,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -137,9 +137,9 @@ ufm_attach(device_t dev) mtx_init(&sc->sc_mtx, "ufm lock", NULL, MTX_DEF | MTX_RECURSE); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &ufm_fifo_methods, &sc->sc_fifo, device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); @@ -158,7 +158,7 @@ ufm_detach(device_t dev) { struct ufm_softc *sc = device_get_softc(dev); - usb2_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo); mtx_destroy(&sc->sc_mtx); @@ -189,7 +189,7 @@ ufm_do_req(struct ufm_softc *sc, uint8_t request, USETW(req.wIndex, index); USETW(req.wLength, 1); - error = usb2_do_request(sc->sc_udev, NULL, &req, buf); + error = usbd_do_request(sc->sc_udev, NULL, &req, buf); if (retbuf) { *retbuf = buf[0]; @@ -284,7 +284,7 @@ ufm_get_stat(struct ufm_softc *sc, void *addr) * Note, there's a 240ms settle time before the status * will be valid, so sleep that amount. */ - usb2_pause_mtx(NULL, hz / 4); + usb_pause_mtx(NULL, hz / 4); if (ufm_do_req(sc, UFM_CMD0, 0x00, 0x24, &ret)) { diff --git a/sys/dev/usb/net/if_aue.c b/sys/dev/usb/net/if_aue.c index 1e37e8c..46ec901 100644 --- a/sys/dev/usb/net/if_aue.c +++ b/sys/dev/usb/net/if_aue.c @@ -64,8 +64,8 @@ __FBSDID("$FreeBSD$"); * the controller uses an external PHY chip, it's possible that board * designers might simply choose a 10Mbps PHY. * - * Registers are accessed using usb2_ether_do_request(). Packet - * transfers are done using usb2_transfer() and friends. + * Registers are accessed using uether_do_request(). Packet + * transfers are done using usbd_transfer() and friends. */ #include "usbdevs.h" @@ -297,7 +297,7 @@ aue_csr_read_1(struct aue_softc *sc, uint16_t reg) USETW(req.wIndex, reg); USETW(req.wLength, 1); - err = usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000); + err = uether_do_request(&sc->sc_ue, &req, &val, 1000); if (err) return (0); return (val); @@ -316,7 +316,7 @@ aue_csr_read_2(struct aue_softc *sc, uint16_t reg) USETW(req.wIndex, reg); USETW(req.wLength, 2); - err = usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000); + err = uether_do_request(&sc->sc_ue, &req, &val, 1000); if (err) return (0); return (le16toh(val)); @@ -334,7 +334,7 @@ aue_csr_write_1(struct aue_softc *sc, uint16_t reg, uint8_t val) USETW(req.wIndex, reg); USETW(req.wLength, 1); - if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) { + if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) { /* error ignored */ } } @@ -352,7 +352,7 @@ aue_csr_write_2(struct aue_softc *sc, uint16_t reg, uint16_t val) val = htole16(val); - if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) { + if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) { /* error ignored */ } } @@ -372,7 +372,7 @@ aue_eeprom_getword(struct aue_softc *sc, int addr, uint16_t *dest) for (i = 0; i != AUE_TIMEOUT; i++) { if (aue_csr_read_1(sc, AUE_EE_CTL) & AUE_EECTL_DONE) break; - if (usb2_ether_pause(&sc->sc_ue, hz / 100)) + if (uether_pause(&sc->sc_ue, hz / 100)) break; } @@ -429,7 +429,7 @@ aue_miibus_readreg(device_t dev, int phy, int reg) for (i = 0; i != AUE_TIMEOUT; i++) { if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE) break; - if (usb2_ether_pause(&sc->sc_ue, hz / 100)) + if (uether_pause(&sc->sc_ue, hz / 100)) break; } @@ -465,7 +465,7 @@ aue_miibus_writereg(device_t dev, int phy, int reg, int data) for (i = 0; i != AUE_TIMEOUT; i++) { if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE) break; - if (usb2_ether_pause(&sc->sc_ue, hz / 100)) + if (uether_pause(&sc->sc_ue, hz / 100)) break; } @@ -520,8 +520,8 @@ aue_miibus_statchg(device_t dev) static void aue_setmulti(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct aue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); struct ifmultiaddr *ifma; uint32_t h = 0; uint32_t i; @@ -576,7 +576,7 @@ aue_reset(struct aue_softc *sc) for (i = 0; i != AUE_TIMEOUT; i++) { if (!(aue_csr_read_1(sc, AUE_CTL1) & AUE_CTL1_RESETMAC)) break; - if (usb2_ether_pause(&sc->sc_ue, hz / 100)) + if (uether_pause(&sc->sc_ue, hz / 100)) break; } @@ -605,13 +605,13 @@ aue_reset(struct aue_softc *sc) aue_reset_pegasus_II(sc); /* Wait a little while for the chip to get its brains in order: */ - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } static void aue_attach_post(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); + struct aue_softc *sc = uether_getsc(ue); /* reset the adapter */ aue_reset(sc); @@ -644,7 +644,7 @@ aue_probe(device_t dev) uaa->info.bcdDevice == 0x0413) return (ENXIO); - return (usb2_lookup_id_by_uaa(aue_devs, sizeof(aue_devs), uaa)); + return (usbd_lookup_id_by_uaa(aue_devs, sizeof(aue_devs), uaa)); } /* @@ -667,11 +667,11 @@ aue_attach(device_t dev) sc->sc_flags |= AUE_FLAG_VER_2; } - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = AUE_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, aue_config, AUE_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -685,7 +685,7 @@ aue_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &aue_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -703,8 +703,8 @@ aue_detach(device_t dev) struct aue_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, AUE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, AUE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -714,7 +714,7 @@ static void aue_intr_callback(struct usb_xfer *xfer) { struct aue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct aue_intrpkt pkt; switch (USB_GET_STATE(xfer)) { @@ -723,7 +723,7 @@ aue_intr_callback(struct usb_xfer *xfer) if ((ifp->if_drv_flags & IFF_DRV_RUNNING) && xfer->actlen >= sizeof(pkt)) { - usb2_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt)); + usbd_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt)); if (pkt.aue_txstat0) ifp->if_oerrors++; @@ -735,7 +735,7 @@ aue_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -753,7 +753,7 @@ aue_bulk_read_callback(struct usb_xfer *xfer) { struct aue_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); struct aue_rxpkt stat; switch (USB_GET_STATE(xfer)) { @@ -772,7 +772,7 @@ aue_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, + usbd_copy_out(xfer->frbuffers, xfer->actlen - sizeof(stat), &stat, sizeof(stat)); /* @@ -787,19 +787,19 @@ aue_bulk_read_callback(struct usb_xfer *xfer) /* No errors; receive the packet. */ xfer->actlen -= (sizeof(stat) + ETHER_CRC_LEN); } - usb2_ether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen); + uether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen); /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -814,7 +814,7 @@ static void aue_bulk_write_callback(struct usb_xfer *xfer) { struct aue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; uint8_t buf[2]; @@ -842,7 +842,7 @@ tr_setup: xfer->frlengths[0] = m->m_pkthdr.len; - usb2_m_copy_in(xfer->frbuffers, 0, + usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); } else { @@ -860,9 +860,9 @@ tr_setup: buf[0] = (uint8_t)(m->m_pkthdr.len); buf[1] = (uint8_t)(m->m_pkthdr.len >> 8); - usb2_copy_in(xfer->frbuffers, 0, buf, 2); + usbd_copy_in(xfer->frbuffers, 0, buf, 2); - usb2_m_copy_in(xfer->frbuffers, 2, + usbd_m_copy_in(xfer->frbuffers, 2, m, 0, m->m_pkthdr.len); } @@ -874,12 +874,12 @@ tr_setup: m_freem(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -895,7 +895,7 @@ tr_setup: static void aue_tick(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); + struct aue_softc *sc = uether_getsc(ue); struct mii_data *mii = GET_MII(sc); AUE_LOCK_ASSERT(sc, MA_OWNED); @@ -912,21 +912,21 @@ aue_tick(struct usb_ether *ue) static void aue_start(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); + struct aue_softc *sc = uether_getsc(ue); /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[AUE_INTR_DT_RD]); - usb2_transfer_start(sc->sc_xfer[AUE_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[AUE_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[AUE_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[AUE_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[AUE_BULK_DT_WR]); } static void aue_init(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct aue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); int i; AUE_LOCK_ASSERT(sc, MA_OWNED); @@ -951,7 +951,7 @@ aue_init(struct usb_ether *ue) AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_TX_ENB); AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_EP3_CLR); - usb2_transfer_set_stall(sc->sc_xfer[AUE_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[AUE_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; aue_start(ue); @@ -960,8 +960,8 @@ aue_init(struct usb_ether *ue) static void aue_setpromisc(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct aue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); AUE_LOCK_ASSERT(sc, MA_OWNED); @@ -1017,8 +1017,8 @@ aue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) static void aue_stop(struct usb_ether *ue) { - struct aue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct aue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); AUE_LOCK_ASSERT(sc, MA_OWNED); @@ -1028,9 +1028,9 @@ aue_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[AUE_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[AUE_BULK_DT_RD]); - usb2_transfer_stop(sc->sc_xfer[AUE_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[AUE_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[AUE_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[AUE_INTR_DT_RD]); aue_csr_write_1(sc, AUE_CTL0, 0); aue_csr_write_1(sc, AUE_CTL1, 0); diff --git a/sys/dev/usb/net/if_auereg.h b/sys/dev/usb/net/if_auereg.h index f1f7398..4d0843e 100644 --- a/sys/dev/usb/net/if_auereg.h +++ b/sys/dev/usb/net/if_auereg.h @@ -55,7 +55,7 @@ /* * Note that while the ADMtek technically has four endpoints, the control * endpoint (endpoint 0) is regarded as special by the USB code and drivers - * don't have direct access to it (we access it using usb2_do_request() + * don't have direct access to it (we access it using usbd_do_request() * when reading/writing registers. Consequently, our endpoint indexes * don't match those in the ADMtek Pegasus manual: we consider the RX data * endpoint to be index 0 and work up from there. @@ -183,7 +183,7 @@ enum { #define AUE_RXSTAT_DRIBBLE 0x10 #define AUE_RXSTAT_MASK 0x1E -#define GET_MII(sc) usb2_ether_getmii(&(sc)->sc_ue) +#define GET_MII(sc) uether_getmii(&(sc)->sc_ue) struct aue_intrpkt { uint8_t aue_txstat0; diff --git a/sys/dev/usb/net/if_axe.c b/sys/dev/usb/net/if_axe.c index 69f9b00..83caec0 100644 --- a/sys/dev/usb/net/if_axe.c +++ b/sys/dev/usb/net/if_axe.c @@ -271,7 +271,7 @@ axe_cmd(struct axe_softc *sc, int cmd, int index, int val, void *buf) USETW(req.wIndex, index); USETW(req.wLength, AXE_CMD_LEN(cmd)); - err = usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000); + err = uether_do_request(&sc->sc_ue, &req, buf, 1000); return (err); } @@ -347,7 +347,7 @@ axe_miibus_statchg(device_t dev) if (!locked) AXE_LOCK(sc); - ifp = usb2_ether_getifp(&sc->sc_ue); + ifp = uether_getifp(&sc->sc_ue); if (mii == NULL || ifp == NULL || (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) goto done; @@ -442,8 +442,8 @@ axe_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) static void axe_setmulti(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct axe_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); struct ifmultiaddr *ifma; uint32_t h = 0; uint16_t rxmode; @@ -522,35 +522,35 @@ axe_ax88178_init(struct axe_softc *sc) } axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x008c, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 16); + uether_pause(&sc->sc_ue, hz / 16); if ((eeprom >> 8) != 0x01) { axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 32); + uether_pause(&sc->sc_ue, hz / 32); axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x001c, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 3); + uether_pause(&sc->sc_ue, hz / 3); axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 32); + uether_pause(&sc->sc_ue, hz / 32); } else { axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x0004, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 32); + uether_pause(&sc->sc_ue, hz / 32); axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x000c, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 32); + uether_pause(&sc->sc_ue, hz / 32); } /* soft reset */ axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 4); + uether_pause(&sc->sc_ue, hz / 4); axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_PRL | AXE_178_RESET_MAGIC, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 4); + uether_pause(&sc->sc_ue, hz / 4); /* Enable MII/GMII/RGMII interface to work with external PHY. */ axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 4); + uether_pause(&sc->sc_ue, hz / 4); axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL); } @@ -559,22 +559,22 @@ static void axe_ax88772_init(struct axe_softc *sc) { axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x00b0, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 16); + uether_pause(&sc->sc_ue, hz / 16); if (sc->sc_phyno == AXE_772_PHY_NO_EPHY) { /* ask for the embedded PHY */ axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x01, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 64); + uether_pause(&sc->sc_ue, hz / 64); /* power down and reset state, pin reset state */ axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 16); + uether_pause(&sc->sc_ue, hz / 16); /* power down/reset state, pin operating state */ axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 4); + uether_pause(&sc->sc_ue, hz / 4); /* power up, reset */ axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_PRL, NULL); @@ -585,14 +585,14 @@ axe_ax88772_init(struct axe_softc *sc) } else { /* ask for external PHY */ axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x00, NULL); - usb2_ether_pause(&sc->sc_ue, hz / 64); + uether_pause(&sc->sc_ue, hz / 64); /* power down internal PHY */ axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL); } - usb2_ether_pause(&sc->sc_ue, hz / 4); + uether_pause(&sc->sc_ue, hz / 4); axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL); } @@ -602,21 +602,21 @@ axe_reset(struct axe_softc *sc) struct usb_config_descriptor *cd; usb_error_t err; - cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev); + cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev); - err = usb2_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx, + err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx, cd->bConfigurationValue); if (err) DPRINTF("reset failed (ignored)\n"); /* Wait a little while for the chip to get its brains in order. */ - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } static void axe_attach_post(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); + struct axe_softc *sc = uether_getsc(ue); /* * Load PHY indexes first. Needed by axe_xxx_init(). @@ -669,7 +669,7 @@ axe_probe(device_t dev) if (uaa->info.bIfaceIndex != AXE_IFACE_IDX) return (ENXIO); - return (usb2_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa)); + return (usbd_lookup_id_by_uaa(axe_devs, sizeof(axe_devs), uaa)); } /* @@ -687,12 +687,12 @@ axe_attach(device_t dev) sc->sc_flags = USB_GET_DRIVER_INFO(uaa); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = AXE_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, axe_config, AXE_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(dev, "allocating USB transfers failed!\n"); @@ -705,7 +705,7 @@ axe_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &axe_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -723,8 +723,8 @@ axe_detach(device_t dev) struct axe_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, AXE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -738,7 +738,7 @@ axe_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -760,7 +760,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer) { struct axe_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); struct axe_sframe_hdr hdr; int error, pos, len, adjust; @@ -773,7 +773,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer) /* too little data */ break; } - usb2_copy_out(xfer->frbuffers, pos, &hdr, sizeof(hdr)); + usbd_copy_out(xfer->frbuffers, pos, &hdr, sizeof(hdr)); if ((hdr.len ^ hdr.ilen) != 0xFFFF) { /* we lost sync */ @@ -793,7 +793,7 @@ axe_bulk_read_callback(struct usb_xfer *xfer) len = xfer->actlen; adjust = 0; } - error = usb2_ether_rxbuf(ue, xfer->frbuffers, pos, len); + error = uether_rxbuf(ue, xfer->frbuffers, pos, len); if (error) break; @@ -815,13 +815,13 @@ axe_bulk_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -842,7 +842,7 @@ axe_bulk_write_callback(struct usb_xfer *xfer) { struct axe_softc *sc = xfer->priv_sc; struct axe_sframe_hdr hdr; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; int pos; @@ -878,7 +878,7 @@ tr_setup: hdr.len = htole16(m->m_pkthdr.len); hdr.ilen = ~hdr.len; - usb2_copy_in(xfer->frbuffers, pos, &hdr, sizeof(hdr)); + usbd_copy_in(xfer->frbuffers, pos, &hdr, sizeof(hdr)); pos += sizeof(hdr); @@ -890,7 +890,7 @@ tr_setup: * USB_FORCE_SHORT_XFER flag instead. */ } - usb2_m_copy_in(xfer->frbuffers, pos, + usbd_m_copy_in(xfer->frbuffers, pos, m, 0, m->m_pkthdr.len); pos += m->m_pkthdr.len; @@ -915,12 +915,12 @@ tr_setup: } xfer->frlengths[0] = pos; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -937,7 +937,7 @@ tr_setup: static void axe_tick(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); + struct axe_softc *sc = uether_getsc(ue); struct mii_data *mii = GET_MII(sc); AXE_LOCK_ASSERT(sc, MA_OWNED); @@ -953,21 +953,21 @@ axe_tick(struct usb_ether *ue) static void axe_start(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); + struct axe_softc *sc = uether_getsc(ue); /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[AXE_INTR_DT_RD]); - usb2_transfer_start(sc->sc_xfer[AXE_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[AXE_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[AXE_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[AXE_BULK_DT_WR]); } static void axe_init(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct axe_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); uint16_t rxmode; AXE_LOCK_ASSERT(sc, MA_OWNED); @@ -1010,7 +1010,7 @@ axe_init(struct usb_ether *ue) /* Load the multicast filter. */ axe_setmulti(ue); - usb2_transfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; axe_start(ue); @@ -1019,8 +1019,8 @@ axe_init(struct usb_ether *ue) static void axe_setpromisc(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct axe_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); uint16_t rxmode; axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, &rxmode); @@ -1041,8 +1041,8 @@ axe_setpromisc(struct usb_ether *ue) static void axe_stop(struct usb_ether *ue) { - struct axe_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct axe_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); AXE_LOCK_ASSERT(sc, MA_OWNED); @@ -1052,9 +1052,9 @@ axe_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]); - usb2_transfer_stop(sc->sc_xfer[AXE_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[AXE_INTR_DT_RD]); axe_reset(sc); } diff --git a/sys/dev/usb/net/if_axereg.h b/sys/dev/usb/net/if_axereg.h index 075dd24..ae1a1d6 100644 --- a/sys/dev/usb/net/if_axereg.h +++ b/sys/dev/usb/net/if_axereg.h @@ -166,7 +166,7 @@ struct axe_sframe_hdr { uint16_t ilen; } __packed; -#define GET_MII(sc) usb2_ether_getmii(&(sc)->sc_ue) +#define GET_MII(sc) uether_getmii(&(sc)->sc_ue) /* The interrupt endpoint is currently unused by the ASIX part. */ enum { diff --git a/sys/dev/usb/net/if_cdce.c b/sys/dev/usb/net/if_cdce.c index a4f2350..5083c87 100644 --- a/sys/dev/usb/net/if_cdce.c +++ b/sys/dev/usb/net/if_cdce.c @@ -207,7 +207,7 @@ cdce_probe(device_t dev) { struct usb_attach_arg *uaa = device_get_ivars(dev); - return (usb2_lookup_id_by_uaa(cdce_devs, sizeof(cdce_devs), uaa)); + return (usbd_lookup_id_by_uaa(cdce_devs, sizeof(cdce_devs), uaa)); } static void @@ -233,7 +233,7 @@ cdce_attach(device_t dev) sc->sc_flags = USB_GET_DRIVER_INFO(uaa); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); @@ -255,17 +255,17 @@ cdce_attach(device_t dev) for (i = 0;; i++) { - iface = usb2_get_iface(uaa->device, i); + iface = usbd_get_iface(uaa->device, i); if (iface) { - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id && (id->bInterfaceNumber == sc->sc_data_iface_no)) { sc->sc_ifaces_index[0] = i; sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex; - usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); + usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); break; } } else { @@ -301,7 +301,7 @@ alloc_transfers: for (i = 0; i != 32; i++) { - error = usb2_set_alt_interface_index + error = usbd_set_alt_interface_index (uaa->device, sc->sc_ifaces_index[0], i); if (error) { @@ -309,7 +309,7 @@ alloc_transfers: "setting found!\n"); goto detach; } - error = usb2_transfer_setup + error = usbd_transfer_setup (uaa->device, sc->sc_ifaces_index, sc->sc_xfer, cdce_config, CDCE_N_TRANSFER, sc, &sc->sc_mtx); @@ -326,7 +326,7 @@ alloc_transfers: if ((ued == NULL) || (ued->bLength < sizeof(*ued))) { error = USB_ERR_INVAL; } else { - error = usb2_req_get_string_any(uaa->device, NULL, + error = usbd_req_get_string_any(uaa->device, NULL, eaddr_str, sizeof(eaddr_str), ued->iMacAddress); } @@ -375,7 +375,7 @@ alloc_transfers: ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &cdce_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -394,8 +394,8 @@ cdce_detach(device_t dev) struct usb_ether *ue = &sc->sc_ue; /* stop all USB transfers first */ - usb2_transfer_unsetup(sc->sc_xfer, CDCE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, CDCE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -404,13 +404,13 @@ cdce_detach(device_t dev) static void cdce_start(struct usb_ether *ue) { - struct cdce_softc *sc = usb2_ether_getsc(ue); + struct cdce_softc *sc = uether_getsc(ue); /* * Start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[CDCE_BULK_TX]); - usb2_transfer_start(sc->sc_xfer[CDCE_BULK_RX]); + usbd_transfer_start(sc->sc_xfer[CDCE_BULK_TX]); + usbd_transfer_start(sc->sc_xfer[CDCE_BULK_RX]); } static void @@ -429,7 +429,7 @@ static void cdce_bulk_write_callback(struct usb_xfer *xfer) { struct cdce_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; struct mbuf *mt; uint32_t crc; @@ -487,7 +487,7 @@ tr_setup: } sc->sc_tx_buf[x] = m; xfer->frlengths[x] = m->m_len; - usb2_set_frame_data(xfer, m->m_data, x); + usbd_set_frame_data(xfer, m->m_data, x); /* * If there's a BPF listener, bounce a copy of @@ -497,13 +497,13 @@ tr_setup: } if (x != 0) { xfer->nframes = x; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); /* free all previous TX buffers */ cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX); @@ -542,19 +542,19 @@ cdce_m_crc32(struct mbuf *m, uint32_t src_offset, uint32_t src_len) static void cdce_init(struct usb_ether *ue) { - struct cdce_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cdce_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); CDCE_LOCK_ASSERT(sc, MA_OWNED); ifp->if_drv_flags |= IFF_DRV_RUNNING; /* start interrupt transfer */ - usb2_transfer_start(sc->sc_xfer[CDCE_INTR_RX]); - usb2_transfer_start(sc->sc_xfer[CDCE_INTR_TX]); + usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]); + usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]); /* stall data write direction, which depends on USB mode */ - usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]); + usbd_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]); /* start data transfers */ cdce_start(ue); @@ -563,8 +563,8 @@ cdce_init(struct usb_ether *ue) static void cdce_stop(struct usb_ether *ue) { - struct cdce_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cdce_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); CDCE_LOCK_ASSERT(sc, MA_OWNED); @@ -573,10 +573,10 @@ cdce_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_RX]); - usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_TX]); - usb2_transfer_stop(sc->sc_xfer[CDCE_INTR_RX]); - usb2_transfer_stop(sc->sc_xfer[CDCE_INTR_TX]); + usbd_transfer_stop(sc->sc_xfer[CDCE_BULK_RX]); + usbd_transfer_stop(sc->sc_xfer[CDCE_BULK_TX]); + usbd_transfer_stop(sc->sc_xfer[CDCE_INTR_RX]); + usbd_transfer_stop(sc->sc_xfer[CDCE_INTR_TX]); } static void @@ -635,7 +635,7 @@ cdce_bulk_read_callback(struct usb_xfer *xfer) continue; } /* queue up mbuf */ - usb2_ether_rxmbuf(&sc->sc_ue, m, xfer->frlengths[x]); + uether_rxmbuf(&sc->sc_ue, m, xfer->frlengths[x]); } /* FALLTHROUGH */ @@ -646,7 +646,7 @@ cdce_bulk_read_callback(struct usb_xfer *xfer) */ for (x = 0; x != 1; x++) { if (sc->sc_rx_buf[x] == NULL) { - m = usb2_ether_newbuf(); + m = uether_newbuf(); if (m == NULL) goto tr_stall; sc->sc_rx_buf[x] = m; @@ -654,26 +654,26 @@ cdce_bulk_read_callback(struct usb_xfer *xfer) m = sc->sc_rx_buf[x]; } - usb2_set_frame_data(xfer, m->m_data, x); + usbd_set_frame_data(xfer, m->m_data, x); xfer->frlengths[x] = m->m_len; } /* set number of frames and start hardware */ xfer->nframes = x; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* flush any received frames */ - usb2_ether_rxflush(&sc->sc_ue); + uether_rxflush(&sc->sc_ue); break; default: /* Error */ DPRINTF("error = %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { tr_stall: /* try to clear stall first */ xfer->flags.stall_pipe = 1; xfer->nframes = 0; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; } @@ -699,7 +699,7 @@ cdce_intr_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -726,7 +726,7 @@ cdce_intr_write_callback(struct usb_xfer *xfer) tr_setup: #if 0 xfer->frlengths[0] = XXX; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); #endif break; diff --git a/sys/dev/usb/net/if_cue.c b/sys/dev/usb/net/if_cue.c index cf37520..648722f 100644 --- a/sys/dev/usb/net/if_cue.c +++ b/sys/dev/usb/net/if_cue.c @@ -186,7 +186,7 @@ cue_csr_read_1(struct cue_softc *sc, uint16_t reg) USETW(req.wIndex, reg); USETW(req.wLength, 1); - if (usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000)) { + if (uether_do_request(&sc->sc_ue, &req, &val, 1000)) { /* ignore any errors */ } return (val); @@ -204,7 +204,7 @@ cue_csr_read_2(struct cue_softc *sc, uint8_t reg) USETW(req.wIndex, reg); USETW(req.wLength, 2); - (void)usb2_ether_do_request(&sc->sc_ue, &req, &val, 1000); + (void)uether_do_request(&sc->sc_ue, &req, &val, 1000); return (le16toh(val)); } @@ -219,7 +219,7 @@ cue_csr_write_1(struct cue_softc *sc, uint16_t reg, uint16_t val) USETW(req.wIndex, reg); USETW(req.wLength, 0); - return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000)); + return (uether_do_request(&sc->sc_ue, &req, NULL, 1000)); } static int @@ -236,7 +236,7 @@ cue_mem(struct cue_softc *sc, uint8_t cmd, uint16_t addr, void *buf, int len) USETW(req.wIndex, addr); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static int @@ -250,7 +250,7 @@ cue_getmac(struct cue_softc *sc, void *buf) USETW(req.wIndex, 0); USETW(req.wLength, ETHER_ADDR_LEN); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } #define CUE_BITS 9 @@ -269,8 +269,8 @@ cue_mchash(const uint8_t *addr) static void cue_setpromisc(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); CUE_LOCK_ASSERT(sc, MA_OWNED); @@ -287,8 +287,8 @@ cue_setpromisc(struct usb_ether *ue) static void cue_setmulti(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); struct ifmultiaddr *ifma; uint32_t h = 0, i; uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; @@ -337,20 +337,20 @@ cue_reset(struct cue_softc *sc) USETW(req.wIndex, 0); USETW(req.wLength, 0); - if (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000)) { + if (uether_do_request(&sc->sc_ue, &req, NULL, 1000)) { /* ignore any errors */ } /* * wait a little while for the chip to get its brains in order: */ - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } static void cue_attach_post(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); + struct cue_softc *sc = uether_getsc(ue); cue_getmac(sc, ue->ue_eaddr); } @@ -367,7 +367,7 @@ cue_probe(device_t dev) if (uaa->info.bIfaceIndex != CUE_IFACE_IDX) return (ENXIO); - return (usb2_lookup_id_by_uaa(cue_devs, sizeof(cue_devs), uaa)); + return (usbd_lookup_id_by_uaa(cue_devs, sizeof(cue_devs), uaa)); } /* @@ -383,11 +383,11 @@ cue_attach(device_t dev) uint8_t iface_index; int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = CUE_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, cue_config, CUE_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(dev, "allocating USB transfers failed!\n"); @@ -400,7 +400,7 @@ cue_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &cue_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -418,8 +418,8 @@ cue_detach(device_t dev) struct cue_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, CUE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, CUE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -430,7 +430,7 @@ cue_bulk_read_callback(struct usb_xfer *xfer) { struct cue_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); uint8_t buf[2]; int len; @@ -441,23 +441,23 @@ cue_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 2); + usbd_copy_out(xfer->frbuffers, 0, buf, 2); xfer->actlen -= 2; len = buf[0] | (buf[1] << 8); len = min(xfer->actlen, len); - usb2_ether_rxbuf(ue, xfer->frbuffers, 2, len); + uether_rxbuf(ue, xfer->frbuffers, 2, len); /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -473,7 +473,7 @@ static void cue_bulk_write_callback(struct usb_xfer *xfer) { struct cue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; uint8_t buf[2]; @@ -498,9 +498,9 @@ tr_setup: buf[0] = (uint8_t)(m->m_pkthdr.len); buf[1] = (uint8_t)(m->m_pkthdr.len >> 8); - usb2_copy_in(xfer->frbuffers, 0, buf, 2); + usbd_copy_in(xfer->frbuffers, 0, buf, 2); - usb2_m_copy_in(xfer->frbuffers, 2, + usbd_m_copy_in(xfer->frbuffers, 2, m, 0, m->m_pkthdr.len); /* @@ -511,13 +511,13 @@ tr_setup: m_freem(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -533,8 +533,8 @@ tr_setup: static void cue_tick(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); CUE_LOCK_ASSERT(sc, MA_OWNED); @@ -549,20 +549,20 @@ cue_tick(struct usb_ether *ue) static void cue_start(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); + struct cue_softc *sc = uether_getsc(ue); /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[CUE_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[CUE_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[CUE_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[CUE_BULK_DT_WR]); } static void cue_init(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); int i; CUE_LOCK_ASSERT(sc, MA_OWNED); @@ -598,7 +598,7 @@ cue_init(struct usb_ether *ue) /* Program the LED operation. */ cue_csr_write_1(sc, CUE_LEDCTL, CUE_LEDCTL_FOLLOW_LINK); - usb2_transfer_set_stall(sc->sc_xfer[CUE_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[CUE_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; cue_start(ue); @@ -611,8 +611,8 @@ cue_init(struct usb_ether *ue) static void cue_stop(struct usb_ether *ue) { - struct cue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct cue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); CUE_LOCK_ASSERT(sc, MA_OWNED); @@ -621,8 +621,8 @@ cue_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[CUE_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[CUE_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[CUE_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[CUE_BULK_DT_RD]); cue_csr_write_1(sc, CUE_ETHCTL, 0); cue_reset(sc); diff --git a/sys/dev/usb/net/if_kue.c b/sys/dev/usb/net/if_kue.c index a2a1c2d..555b493 100644 --- a/sys/dev/usb/net/if_kue.c +++ b/sys/dev/usb/net/if_kue.c @@ -223,7 +223,7 @@ kue_do_request(struct kue_softc *sc, struct usb_device_request *req, { usb_error_t err; - err = usb2_ether_do_request(&sc->sc_ue, req, data, 60000); + err = uether_do_request(&sc->sc_ue, req, data, 60000); return (err); } @@ -269,7 +269,7 @@ kue_load_fw(struct kue_softc *sc) uint16_t hwrev; usb_error_t err; - dd = usb2_get_device_descriptor(sc->sc_ue.ue_udev); + dd = usbd_get_device_descriptor(sc->sc_ue.ue_udev); hwrev = UGETW(dd->bcdDevice); /* @@ -294,7 +294,7 @@ kue_load_fw(struct kue_softc *sc) 0, kue_code_seg, sizeof(kue_code_seg)); if (err) { device_printf(sc->sc_ue.ue_dev, "failed to load code segment: %s\n", - usb2_errstr(err)); + usbd_errstr(err)); return(ENXIO); } @@ -303,7 +303,7 @@ kue_load_fw(struct kue_softc *sc) 0, kue_fix_seg, sizeof(kue_fix_seg)); if (err) { device_printf(sc->sc_ue.ue_dev, "failed to load fixup segment: %s\n", - usb2_errstr(err)); + usbd_errstr(err)); return(ENXIO); } @@ -312,7 +312,7 @@ kue_load_fw(struct kue_softc *sc) 0, kue_trig_seg, sizeof(kue_trig_seg)); if (err) { device_printf(sc->sc_ue.ue_dev, "failed to load trigger segment: %s\n", - usb2_errstr(err)); + usbd_errstr(err)); return(ENXIO); } @@ -322,8 +322,8 @@ kue_load_fw(struct kue_softc *sc) static void kue_setpromisc(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct kue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); KUE_LOCK_ASSERT(sc, MA_OWNED); @@ -338,8 +338,8 @@ kue_setpromisc(struct usb_ether *ue) static void kue_setmulti(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct kue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); struct ifmultiaddr *ifma; int i = 0; @@ -393,21 +393,21 @@ kue_reset(struct kue_softc *sc) struct usb_config_descriptor *cd; usb_error_t err; - cd = usb2_get_config_descriptor(sc->sc_ue.ue_udev); + cd = usbd_get_config_descriptor(sc->sc_ue.ue_udev); - err = usb2_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx, + err = usbd_req_set_config(sc->sc_ue.ue_udev, &sc->sc_mtx, cd->bConfigurationValue); if (err) DPRINTF("reset failed (ignored)\n"); /* wait a little while for the chip to get its brains in order */ - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } static void kue_attach_post(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); + struct kue_softc *sc = uether_getsc(ue); int error; /* load the firmware into the NIC */ @@ -443,7 +443,7 @@ kue_probe(device_t dev) if (uaa->info.bIfaceIndex != KUE_IFACE_IDX) return (ENXIO); - return (usb2_lookup_id_by_uaa(kue_devs, sizeof(kue_devs), uaa)); + return (usbd_lookup_id_by_uaa(kue_devs, sizeof(kue_devs), uaa)); } /* @@ -459,11 +459,11 @@ kue_attach(device_t dev) uint8_t iface_index; int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = KUE_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, kue_config, KUE_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(dev, "allocating USB transfers failed!\n"); @@ -483,7 +483,7 @@ kue_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &kue_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -501,8 +501,8 @@ kue_detach(device_t dev) struct kue_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, KUE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, KUE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); free(sc->sc_mcfilters, M_USBDEV); @@ -518,7 +518,7 @@ kue_bulk_read_callback(struct usb_xfer *xfer) { struct kue_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); uint8_t buf[2]; int len; @@ -529,23 +529,23 @@ kue_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 2); + usbd_copy_out(xfer->frbuffers, 0, buf, 2); xfer->actlen -= 2; len = buf[0] | (buf[1] << 8); len = min(xfer->actlen, len); - usb2_ether_rxbuf(ue, xfer->frbuffers, 2, len); + uether_rxbuf(ue, xfer->frbuffers, 2, len); /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -561,7 +561,7 @@ static void kue_bulk_write_callback(struct usb_xfer *xfer) { struct kue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; int total_len; int temp_len; @@ -589,12 +589,12 @@ tr_setup: buf[0] = (uint8_t)(m->m_pkthdr.len); buf[1] = (uint8_t)(m->m_pkthdr.len >> 8); - usb2_copy_in(xfer->frbuffers, 0, buf, 2); + usbd_copy_in(xfer->frbuffers, 0, buf, 2); - usb2_m_copy_in(xfer->frbuffers, 2, + usbd_m_copy_in(xfer->frbuffers, 2, m, 0, m->m_pkthdr.len); - usb2_bzero(xfer->frbuffers, temp_len, + usbd_frame_zero(xfer->frbuffers, temp_len, total_len - temp_len); xfer->frlengths[0] = total_len; @@ -607,13 +607,13 @@ tr_setup: m_freem(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -630,20 +630,20 @@ tr_setup: static void kue_start(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); + struct kue_softc *sc = uether_getsc(ue); /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[KUE_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[KUE_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[KUE_BULK_DT_WR]); } static void kue_init(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct kue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); KUE_LOCK_ASSERT(sc, MA_OWNED); @@ -664,7 +664,7 @@ kue_init(struct usb_ether *ue) /* load the multicast filter */ kue_setpromisc(ue); - usb2_transfer_set_stall(sc->sc_xfer[KUE_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[KUE_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; kue_start(ue); @@ -673,8 +673,8 @@ kue_init(struct usb_ether *ue) static void kue_stop(struct usb_ether *ue) { - struct kue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct kue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); KUE_LOCK_ASSERT(sc, MA_OWNED); @@ -683,6 +683,6 @@ kue_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[KUE_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[KUE_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[KUE_BULK_DT_RD]); } diff --git a/sys/dev/usb/net/if_rue.c b/sys/dev/usb/net/if_rue.c index 7eadb5c..36960d1 100644 --- a/sys/dev/usb/net/if_rue.c +++ b/sys/dev/usb/net/if_rue.c @@ -228,7 +228,7 @@ rue_read_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) USETW(req.wIndex, 0); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static int @@ -242,7 +242,7 @@ rue_write_mem(struct rue_softc *sc, uint16_t addr, void *buf, int len) USETW(req.wIndex, 0); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static uint8_t @@ -436,8 +436,8 @@ rue_miibus_statchg(device_t dev) static void rue_setpromisc(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct rue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); RUE_LOCK_ASSERT(sc, MA_OWNED); @@ -454,8 +454,8 @@ rue_setpromisc(struct usb_ether *ue) static void rue_setmulti(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct rue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); uint16_t rxcfg; int h = 0; uint32_t hashes[2] = { 0, 0 }; @@ -515,7 +515,7 @@ rue_reset(struct rue_softc *sc) rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST); for (i = 0; i != RUE_TIMEOUT; i++) { - if (usb2_ether_pause(&sc->sc_ue, hz / 1000)) + if (uether_pause(&sc->sc_ue, hz / 1000)) break; if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST)) break; @@ -523,13 +523,13 @@ rue_reset(struct rue_softc *sc) if (i == RUE_TIMEOUT) device_printf(sc->sc_ue.ue_dev, "reset never completed!\n"); - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } static void rue_attach_post(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); + struct rue_softc *sc = uether_getsc(ue); /* reset the adapter */ rue_reset(sc); @@ -553,7 +553,7 @@ rue_probe(device_t dev) if (uaa->info.bIfaceIndex != RUE_IFACE_IDX) return (ENXIO); - return (usb2_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); + return (usbd_lookup_id_by_uaa(rue_devs, sizeof(rue_devs), uaa)); } /* @@ -569,11 +569,11 @@ rue_attach(device_t dev) uint8_t iface_index; int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = RUE_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, rue_config, RUE_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -587,7 +587,7 @@ rue_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &rue_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -605,8 +605,8 @@ rue_detach(device_t dev) struct rue_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, RUE_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -616,7 +616,7 @@ static void rue_intr_callback(struct usb_xfer *xfer) { struct rue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct rue_intrpkt pkt; switch (USB_GET_STATE(xfer)) { @@ -625,7 +625,7 @@ rue_intr_callback(struct usb_xfer *xfer) if (ifp && (ifp->if_drv_flags & IFF_DRV_RUNNING) && (xfer->actlen >= sizeof(pkt))) { - usb2_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt)); + usbd_copy_out(xfer->frbuffers, 0, &pkt, sizeof(pkt)); ifp->if_ierrors += pkt.rue_rxlost_cnt; ifp->if_ierrors += pkt.rue_crcerr_cnt; @@ -635,7 +635,7 @@ rue_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -653,7 +653,7 @@ rue_bulk_read_callback(struct usb_xfer *xfer) { struct rue_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); uint16_t status; switch (USB_GET_STATE(xfer)) { @@ -663,7 +663,7 @@ rue_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, xfer->actlen - 4, + usbd_copy_out(xfer->frbuffers, xfer->actlen - 4, &status, sizeof(status)); xfer->actlen -= 4; @@ -673,18 +673,18 @@ rue_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_ether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen); + uether_rxbuf(ue, xfer->frbuffers, 0, xfer->actlen); /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -699,7 +699,7 @@ static void rue_bulk_write_callback(struct usb_xfer *xfer) { struct rue_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; int temp_len; @@ -725,7 +725,7 @@ tr_setup: m->m_pkthdr.len = MCLBYTES; temp_len = m->m_pkthdr.len; - usb2_m_copy_in(xfer->frbuffers, 0, + usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); /* @@ -734,7 +734,7 @@ tr_setup: * RUE_MIN_FRAMELEN (60) byte packet. */ if (temp_len < RUE_MIN_FRAMELEN) { - usb2_bzero(xfer->frbuffers, temp_len, + usbd_frame_zero(xfer->frbuffers, temp_len, RUE_MIN_FRAMELEN - temp_len); temp_len = RUE_MIN_FRAMELEN; } @@ -748,13 +748,13 @@ tr_setup: m_freem(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -770,7 +770,7 @@ tr_setup: static void rue_tick(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); + struct rue_softc *sc = uether_getsc(ue); struct mii_data *mii = GET_MII(sc); RUE_LOCK_ASSERT(sc, MA_OWNED); @@ -787,21 +787,21 @@ rue_tick(struct usb_ether *ue) static void rue_start(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); + struct rue_softc *sc = uether_getsc(ue); /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); - usb2_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[RUE_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[RUE_BULK_DT_WR]); } static void rue_init(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct rue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); RUE_LOCK_ASSERT(sc, MA_OWNED); @@ -829,7 +829,7 @@ rue_init(struct usb_ether *ue) /* Enable RX and TX */ rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN)); - usb2_transfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[RUE_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; rue_start(ue); @@ -876,8 +876,8 @@ rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) static void rue_stop(struct usb_ether *ue) { - struct rue_softc *sc = usb2_ether_getsc(ue); - struct ifnet *ifp = usb2_ether_getifp(ue); + struct rue_softc *sc = uether_getsc(ue); + struct ifnet *ifp = uether_getifp(ue); RUE_LOCK_ASSERT(sc, MA_OWNED); @@ -887,9 +887,9 @@ rue_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); - usb2_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[RUE_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[RUE_INTR_DT_RD]); rue_csr_write_1(sc, RUE_CR, 0x00); diff --git a/sys/dev/usb/net/if_ruereg.h b/sys/dev/usb/net/if_ruereg.h index edfa3d3..a4a4aec 100644 --- a/sys/dev/usb/net/if_ruereg.h +++ b/sys/dev/usb/net/if_ruereg.h @@ -144,7 +144,7 @@ #define RUE_RXSTAT_PMATCH (0x04 << 12) #define RUE_RXSTAT_MCAST (0x08 << 12) -#define GET_MII(sc) usb2_ether_getmii(&(sc)->sc_ue) +#define GET_MII(sc) uether_getmii(&(sc)->sc_ue) struct rue_intrpkt { uint8_t rue_tsr; diff --git a/sys/dev/usb/net/if_udav.c b/sys/dev/usb/net/if_udav.c index 008f408..be9af15 100644 --- a/sys/dev/usb/net/if_udav.c +++ b/sys/dev/usb/net/if_udav.c @@ -197,7 +197,7 @@ static const struct usb_device_id udav_devs[] = { static void udav_attach_post(struct usb_ether *ue) { - struct udav_softc *sc = usb2_ether_getsc(ue); + struct udav_softc *sc = uether_getsc(ue); /* reset the adapter */ udav_reset(sc); @@ -218,7 +218,7 @@ udav_probe(device_t dev) if (uaa->info.bIfaceIndex != UDAV_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(udav_devs, sizeof(udav_devs), uaa)); + return (usbd_lookup_id_by_uaa(udav_devs, sizeof(udav_devs), uaa)); } static int @@ -232,12 +232,12 @@ udav_attach(device_t dev) sc->sc_flags = USB_GET_DRIVER_INFO(uaa); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF); iface_index = UDAV_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, udav_config, UDAV_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(dev, "allocating USB transfers failed!\n"); @@ -250,7 +250,7 @@ udav_attach(device_t dev) ue->ue_mtx = &sc->sc_mtx; ue->ue_methods = &udav_ue_methods; - error = usb2_ether_ifattach(ue); + error = uether_ifattach(ue); if (error) { device_printf(dev, "could not attach interface\n"); goto detach; @@ -269,8 +269,8 @@ udav_detach(device_t dev) struct udav_softc *sc = device_get_softc(dev); struct usb_ether *ue = &sc->sc_ue; - usb2_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER); - usb2_ether_ifdetach(ue); + usbd_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER); + uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); @@ -291,7 +291,7 @@ udav_mem_read(struct udav_softc *sc, uint16_t offset, void *buf, USETW(req.wIndex, offset); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static int @@ -308,7 +308,7 @@ udav_mem_write(struct udav_softc *sc, uint16_t offset, void *buf, USETW(req.wIndex, offset); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static int @@ -323,7 +323,7 @@ udav_mem_write1(struct udav_softc *sc, uint16_t offset, USETW(req.wIndex, offset); USETW(req.wLength, 0x0000); - return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000)); + return (uether_do_request(&sc->sc_ue, &req, NULL, 1000)); } #endif @@ -340,7 +340,7 @@ udav_csr_read(struct udav_softc *sc, uint16_t offset, void *buf, int len) USETW(req.wIndex, offset); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static int @@ -357,7 +357,7 @@ udav_csr_write(struct udav_softc *sc, uint16_t offset, void *buf, int len) USETW(req.wIndex, offset); USETW(req.wLength, len); - return (usb2_ether_do_request(&sc->sc_ue, &req, buf, 1000)); + return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); } static uint8_t @@ -383,14 +383,14 @@ udav_csr_write1(struct udav_softc *sc, uint16_t offset, USETW(req.wIndex, offset); USETW(req.wLength, 0x0000); - return (usb2_ether_do_request(&sc->sc_ue, &req, NULL, 1000)); + return (uether_do_request(&sc->sc_ue, &req, NULL, 1000)); } static void udav_init(struct usb_ether *ue) { struct udav_softc *sc = ue->ue_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); UDAV_LOCK_ASSERT(sc, MA_OWNED); @@ -420,7 +420,7 @@ udav_init(struct usb_ether *ue) UDAV_SETBIT(sc, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0); UDAV_CLRBIT(sc, UDAV_GPR, UDAV_GPR_GEPIO0); - usb2_transfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]); ifp->if_drv_flags |= IFF_DRV_RUNNING; udav_start(ue); @@ -450,11 +450,11 @@ udav_reset(struct udav_softc *sc) for (i = 0; i < UDAV_TX_TIMEOUT; i++) { if (!(udav_csr_read1(sc, UDAV_NCR) & UDAV_NCR_RST)) break; - if (usb2_ether_pause(&sc->sc_ue, hz / 100)) + if (uether_pause(&sc->sc_ue, hz / 100)) break; } - usb2_ether_pause(&sc->sc_ue, hz / 100); + uether_pause(&sc->sc_ue, hz / 100); } #define UDAV_BITS 6 @@ -462,7 +462,7 @@ static void udav_setmulti(struct usb_ether *ue) { struct udav_softc *sc = ue->ue_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct ifmultiaddr *ifma; uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; int h = 0; @@ -502,7 +502,7 @@ static void udav_setpromisc(struct usb_ether *ue) { struct udav_softc *sc = ue->ue_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); uint8_t rxmode; rxmode = udav_csr_read1(sc, UDAV_RCR); @@ -525,16 +525,16 @@ udav_start(struct usb_ether *ue) /* * start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[UDAV_INTR_DT_RD]); - usb2_transfer_start(sc->sc_xfer[UDAV_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[UDAV_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UDAV_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_WR]); } static void udav_bulk_write_callback(struct usb_xfer *xfer) { struct udav_softc *sc = xfer->priv_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); struct mbuf *m; int extra_len; int temp_len; @@ -577,13 +577,13 @@ tr_setup: temp_len += 2; - usb2_copy_in(xfer->frbuffers, 0, buf, 2); + usbd_copy_in(xfer->frbuffers, 0, buf, 2); - usb2_m_copy_in(xfer->frbuffers, 2, + usbd_m_copy_in(xfer->frbuffers, 2, m, 0, m->m_pkthdr.len); if (extra_len) { - usb2_bzero(xfer->frbuffers, temp_len - extra_len, + usbd_frame_zero(xfer->frbuffers, temp_len - extra_len, extra_len); } /* @@ -595,12 +595,12 @@ tr_setup: m_freem(m); xfer->frlengths[0] = temp_len; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; @@ -618,7 +618,7 @@ udav_bulk_read_callback(struct usb_xfer *xfer) { struct udav_softc *sc = xfer->priv_sc; struct usb_ether *ue = &sc->sc_ue; - struct ifnet *ifp = usb2_ether_getifp(ue); + struct ifnet *ifp = uether_getifp(ue); struct udav_rxpkt stat; int len; @@ -629,7 +629,7 @@ udav_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, &stat, sizeof(stat)); + usbd_copy_out(xfer->frbuffers, 0, &stat, sizeof(stat)); xfer->actlen -= sizeof(stat); len = min(xfer->actlen, le16toh(stat.pktlen)); len -= ETHER_CRC_LEN; @@ -642,18 +642,18 @@ udav_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_ether_rxbuf(ue, xfer->frbuffers, sizeof(stat), len); + uether_rxbuf(ue, xfer->frbuffers, sizeof(stat), len); /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); - usb2_ether_rxflush(ue); + usbd_transfer_submit(xfer); + uether_rxflush(ue); return; default: /* Error */ DPRINTF("bulk read error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -672,7 +672,7 @@ udav_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -689,7 +689,7 @@ static void udav_stop(struct usb_ether *ue) { struct udav_softc *sc = ue->ue_sc; - struct ifnet *ifp = usb2_ether_getifp(&sc->sc_ue); + struct ifnet *ifp = uether_getifp(&sc->sc_ue); UDAV_LOCK_ASSERT(sc, MA_OWNED); @@ -699,9 +699,9 @@ udav_stop(struct usb_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_WR]); - usb2_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_RD]); - usb2_transfer_stop(sc->sc_xfer[UDAV_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UDAV_INTR_DT_RD]); udav_reset(sc); } diff --git a/sys/dev/usb/net/if_udavreg.h b/sys/dev/usb/net/if_udavreg.h index 6dba64c..82715e8 100644 --- a/sys/dev/usb/net/if_udavreg.h +++ b/sys/dev/usb/net/if_udavreg.h @@ -137,7 +137,7 @@ #define UDAV_GPR_GEPIO1 (1<<1) /* General purpose 1 */ #define UDAV_GPR_GEPIO0 (1<<0) /* General purpose 0 */ -#define GET_MII(sc) usb2_ether_getmii(&(sc)->sc_ue) +#define GET_MII(sc) uether_getmii(&(sc)->sc_ue) struct udav_rxpkt { uint8_t rxstat; diff --git a/sys/dev/usb/net/usb_ethernet.c b/sys/dev/usb/net/usb_ethernet.c index 3d7ae51..3c42be6 100644 --- a/sys/dev/usb/net/usb_ethernet.c +++ b/sys/dev/usb/net/usb_ethernet.c @@ -67,13 +67,13 @@ static void ue_watchdog(void *); * Else: device has been detached */ uint8_t -usb2_ether_pause(struct usb_ether *ue, unsigned int _ticks) +uether_pause(struct usb_ether *ue, unsigned int _ticks) { - if (usb2_proc_is_gone(&ue->ue_tq)) { + if (usb_proc_is_gone(&ue->ue_tq)) { /* nothing to do */ return (1); } - usb2_pause_mtx(ue->ue_mtx, _ticks); + usb_pause_mtx(ue->ue_mtx, _ticks); return (0); } @@ -86,7 +86,7 @@ ue_queue_command(struct usb_ether *ue, UE_LOCK_ASSERT(ue, MA_OWNED); - if (usb2_proc_is_gone(&ue->ue_tq)) { + if (usb_proc_is_gone(&ue->ue_tq)) { return; /* nothing to do */ } /* @@ -95,7 +95,7 @@ ue_queue_command(struct usb_ether *ue, * structure after that the message got queued. */ task = (struct usb_ether_cfg_task *) - usb2_proc_msignal(&ue->ue_tq, t0, t1); + usb_proc_msignal(&ue->ue_tq, t0, t1); /* Setup callback and self pointers */ task->hdr.pm_callback = fn; @@ -105,23 +105,23 @@ ue_queue_command(struct usb_ether *ue, * Start and stop must be synchronous! */ if ((fn == ue_start_task) || (fn == ue_stop_task)) - usb2_proc_mwait(&ue->ue_tq, t0, t1); + usb_proc_mwait(&ue->ue_tq, t0, t1); } struct ifnet * -usb2_ether_getifp(struct usb_ether *ue) +uether_getifp(struct usb_ether *ue) { return (ue->ue_ifp); } struct mii_data * -usb2_ether_getmii(struct usb_ether *ue) +uether_getmii(struct usb_ether *ue) { return (device_get_softc(ue->ue_miibus)); } void * -usb2_ether_getsc(struct usb_ether *ue) +uether_getsc(struct usb_ether *ue) { return (ue->ue_sc); } @@ -137,7 +137,7 @@ ue_sysctl_parent(SYSCTL_HANDLER_ARGS) } int -usb2_ether_ifattach(struct usb_ether *ue) +uether_ifattach(struct usb_ether *ue) { int error; @@ -148,7 +148,7 @@ usb2_ether_ifattach(struct usb_ether *ue) (ue->ue_methods == NULL)) return (EINVAL); - error = usb2_proc_create(&ue->ue_tq, ue->ue_mtx, + error = usb_proc_create(&ue->ue_tq, ue->ue_mtx, device_get_nameunit(ue->ue_dev), USB_PRI_MED); if (error) { device_printf(ue->ue_dev, "could not setup taskqueue\n"); @@ -182,7 +182,7 @@ ue_attach_post_task(struct usb_proc_msg *_task) UE_UNLOCK(ue); ue->ue_unit = alloc_unr(ueunit); - usb2_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0); + usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_mtx, 0); sysctl_ctx_init(&ue->ue_sysctl_ctx); ifp = if_alloc(IFT_ETHER); @@ -198,7 +198,7 @@ ue_attach_post_task(struct usb_proc_msg *_task) if (ue->ue_methods->ue_ioctl != NULL) ifp->if_ioctl = ue->ue_methods->ue_ioctl; else - ifp->if_ioctl = usb2_ether_ioctl; + ifp->if_ioctl = uether_ioctl; ifp->if_start = ue_start; ifp->if_init = ue_init; IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); @@ -244,12 +244,12 @@ error: } void -usb2_ether_ifdetach(struct usb_ether *ue) +uether_ifdetach(struct usb_ether *ue) { struct ifnet *ifp; /* wait for any post attach or other command to complete */ - usb2_proc_drain(&ue->ue_tq); + usb_proc_drain(&ue->ue_tq); /* read "ifnet" pointer after taskqueue drain */ ifp = ue->ue_ifp; @@ -262,7 +262,7 @@ usb2_ether_ifdetach(struct usb_ether *ue) UE_UNLOCK(ue); /* drain any callouts */ - usb2_callout_drain(&ue->ue_watchdog); + usb_callout_drain(&ue->ue_watchdog); /* detach miibus */ if (ue->ue_miibus != NULL) { @@ -285,13 +285,13 @@ usb2_ether_ifdetach(struct usb_ether *ue) } /* free taskqueue, if any */ - usb2_proc_free(&ue->ue_tq); + usb_proc_free(&ue->ue_tq); } uint8_t -usb2_ether_is_gone(struct usb_ether *ue) +uether_is_gone(struct usb_ether *ue) { - return (usb2_proc_is_gone(&ue->ue_tq)); + return (usb_proc_is_gone(&ue->ue_tq)); } static void @@ -322,7 +322,7 @@ ue_start_task(struct usb_proc_msg *_task) return; if (ue->ue_methods->ue_tick != NULL) - usb2_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); + usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); } static void @@ -334,7 +334,7 @@ ue_stop_task(struct usb_proc_msg *_task) UE_LOCK_ASSERT(ue, MA_OWNED); - usb2_callout_stop(&ue->ue_watchdog); + usb_callout_stop(&ue->ue_watchdog); ue->ue_methods->ue_stop(ue); } @@ -411,7 +411,7 @@ ue_watchdog(void *arg) &ue->ue_tick_task[0].hdr, &ue->ue_tick_task[1].hdr); - usb2_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); + usb_callout_reset(&ue->ue_watchdog, hz, ue_watchdog, ue); } static void @@ -429,7 +429,7 @@ ue_tick_task(struct usb_proc_msg *_task) } int -usb2_ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) +uether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) { struct usb_ether *ue = ifp->if_softc; struct ifreq *ifr = (struct ifreq *)data; @@ -479,7 +479,7 @@ usb2_ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) } static int -usb2_ether_modevent(module_t mod, int type, void *data) +uether_modevent(module_t mod, int type, void *data) { switch (type) { @@ -493,14 +493,14 @@ usb2_ether_modevent(module_t mod, int type, void *data) } return (0); } -static moduledata_t usb2_ether_mod = { +static moduledata_t uether_mod = { "uether", - usb2_ether_modevent, + uether_modevent, 0 }; struct mbuf * -usb2_ether_newbuf(void) +uether_newbuf(void) { struct mbuf *m_new; @@ -514,7 +514,7 @@ usb2_ether_newbuf(void) } int -usb2_ether_rxmbuf(struct usb_ether *ue, struct mbuf *m, +uether_rxmbuf(struct usb_ether *ue, struct mbuf *m, unsigned int len) { struct ifnet *ifp = ue->ue_ifp; @@ -532,7 +532,7 @@ usb2_ether_rxmbuf(struct usb_ether *ue, struct mbuf *m, } int -usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, +uether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, unsigned int offset, unsigned int len) { struct ifnet *ifp = ue->ue_ifp; @@ -543,13 +543,13 @@ usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, if (len < ETHER_HDR_LEN || len > MCLBYTES - ETHER_ALIGN) return (1); - m = usb2_ether_newbuf(); + m = uether_newbuf(); if (m == NULL) { ifp->if_ierrors++; return (ENOMEM); } - usb2_copy_out(pc, offset, mtod(m, uint8_t *), len); + usbd_copy_out(pc, offset, mtod(m, uint8_t *), len); /* finalize mbuf */ ifp->if_ipackets++; @@ -562,7 +562,7 @@ usb2_ether_rxbuf(struct usb_ether *ue, struct usb_page_cache *pc, } void -usb2_ether_rxflush(struct usb_ether *ue) +uether_rxflush(struct usb_ether *ue) { struct ifnet *ifp = ue->ue_ifp; struct mbuf *m; @@ -583,5 +583,5 @@ usb2_ether_rxflush(struct usb_ether *ue) } } -DECLARE_MODULE(uether, usb2_ether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +DECLARE_MODULE(uether, uether_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); MODULE_VERSION(uether, 1); diff --git a/sys/dev/usb/net/usb_ethernet.h b/sys/dev/usb/net/usb_ethernet.h index 10908cc..ad57a85 100644 --- a/sys/dev/usb/net/usb_ethernet.h +++ b/sys/dev/usb/net/usb_ethernet.h @@ -81,7 +81,7 @@ struct usb_ether { const struct usb_ether_methods *ue_methods; struct sysctl_oid *ue_sysctl_oid; void *ue_sc; - struct usb_device *ue_udev; /* used by usb2_ether_do_request() */ + struct usb_device *ue_udev; /* used by uether_do_request() */ device_t ue_dev; device_t ue_miibus; @@ -101,22 +101,22 @@ struct usb_ether { uint8_t ue_eaddr[ETHER_ADDR_LEN]; }; -#define usb2_ether_do_request(ue,req,data,timo) \ - usb2_do_request_proc((ue)->ue_udev,&(ue)->ue_tq,req,data,0,NULL,timo) - -uint8_t usb2_ether_pause(struct usb_ether *, unsigned int); -struct ifnet *usb2_ether_getifp(struct usb_ether *); -struct mii_data *usb2_ether_getmii(struct usb_ether *); -void *usb2_ether_getsc(struct usb_ether *); -int usb2_ether_ifattach(struct usb_ether *); -void usb2_ether_ifdetach(struct usb_ether *); -int usb2_ether_ioctl(struct ifnet *, u_long, caddr_t); -struct mbuf *usb2_ether_newbuf(void); -int usb2_ether_rxmbuf(struct usb_ether *, struct mbuf *, +#define uether_do_request(ue,req,data,timo) \ + usbd_do_request_proc((ue)->ue_udev,&(ue)->ue_tq,req,data,0,NULL,timo) + +uint8_t uether_pause(struct usb_ether *, unsigned int); +struct ifnet *uether_getifp(struct usb_ether *); +struct mii_data *uether_getmii(struct usb_ether *); +void *uether_getsc(struct usb_ether *); +int uether_ifattach(struct usb_ether *); +void uether_ifdetach(struct usb_ether *); +int uether_ioctl(struct ifnet *, u_long, caddr_t); +struct mbuf *uether_newbuf(void); +int uether_rxmbuf(struct usb_ether *, struct mbuf *, unsigned int); -int usb2_ether_rxbuf(struct usb_ether *, +int uether_rxbuf(struct usb_ether *, struct usb_page_cache *, unsigned int, unsigned int); -void usb2_ether_rxflush(struct usb_ether *); -uint8_t usb2_ether_is_gone(struct usb_ether *); +void uether_rxflush(struct usb_ether *); +uint8_t uether_is_gone(struct usb_ether *); #endif /* _USB2_ETHERNET_H_ */ diff --git a/sys/dev/usb/quirk/usb_quirk.c b/sys/dev/usb/quirk/usb_quirk.c index fa7ab11..3228aa2 100644 --- a/sys/dev/usb/quirk/usb_quirk.c +++ b/sys/dev/usb/quirk/usb_quirk.c @@ -31,7 +31,7 @@ #include #include "usbdevs.h" -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -52,7 +52,7 @@ MODULE_VERSION(usb_quirk, 1); #define USB_DEV_QUIRKS_MAX 128 #define USB_SUB_QUIRKS_MAX 8 -struct usb2_quirk_entry { +struct usb_quirk_entry { uint16_t vid; uint16_t pid; uint16_t lo_rev; @@ -60,9 +60,9 @@ struct usb2_quirk_entry { uint16_t quirks[USB_SUB_QUIRKS_MAX]; }; -static struct mtx usb2_quirk_mtx; +static struct mtx usb_quirk_mtx; -static struct usb2_quirk_entry usb2_quirks[USB_DEV_QUIRKS_MAX] = { +static struct usb_quirk_entry usb_quirks[USB_DEV_QUIRKS_MAX] = { {USB_QUIRK_ENTRY(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_LCM, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)}, {USB_QUIRK_ENTRY(USB_VENDOR_INSIDEOUT, USB_PRODUCT_INSIDEOUT_EDGEPORT4, 0x094, 0x094, UQ_SWAP_UNICODE, UQ_NONE)}, {USB_QUIRK_ENTRY(USB_VENDOR_DALLAS, USB_PRODUCT_DALLAS_J6502, 0x0a2, 0x0a2, UQ_BAD_ADC, UQ_NONE)}, @@ -137,26 +137,26 @@ static const char *usb_quirk_str[USB_QUIRK_MAX] = { }; /*------------------------------------------------------------------------* - * usb2_quirkstr + * usb_quirkstr * * This function converts an USB quirk code into a string. *------------------------------------------------------------------------*/ static const char * -usb2_quirkstr(uint16_t quirk) +usb_quirkstr(uint16_t quirk) { return ((quirk < USB_QUIRK_MAX) ? usb_quirk_str[quirk] : "USB_QUIRK_UNKNOWN"); } /*------------------------------------------------------------------------* - * usb2_test_quirk_by_info + * usb_test_quirk_by_info * * Returns: * 0: Quirk not found * Else: Quirk found *------------------------------------------------------------------------*/ static uint8_t -usb2_test_quirk_by_info(const struct usb_lookup_info *info, uint16_t quirk) +usb_test_quirk_by_info(const struct usbd_lookup_info *info, uint16_t quirk) { uint16_t x; uint16_t y; @@ -164,53 +164,53 @@ usb2_test_quirk_by_info(const struct usb_lookup_info *info, uint16_t quirk) if (quirk == UQ_NONE) { return (0); } - mtx_lock(&usb2_quirk_mtx); + mtx_lock(&usb_quirk_mtx); for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) { /* see if quirk information does not match */ - if ((usb2_quirks[x].vid != info->idVendor) || - (usb2_quirks[x].pid != info->idProduct) || - (usb2_quirks[x].lo_rev > info->bcdDevice) || - (usb2_quirks[x].hi_rev < info->bcdDevice)) { + if ((usb_quirks[x].vid != info->idVendor) || + (usb_quirks[x].pid != info->idProduct) || + (usb_quirks[x].lo_rev > info->bcdDevice) || + (usb_quirks[x].hi_rev < info->bcdDevice)) { continue; } /* lookup quirk */ for (y = 0; y != USB_SUB_QUIRKS_MAX; y++) { - if (usb2_quirks[x].quirks[y] == quirk) { - mtx_unlock(&usb2_quirk_mtx); - DPRINTF("Found quirk '%s'.\n", usb2_quirkstr(quirk)); + if (usb_quirks[x].quirks[y] == quirk) { + mtx_unlock(&usb_quirk_mtx); + DPRINTF("Found quirk '%s'.\n", usb_quirkstr(quirk)); return (1); } } /* no quirk found */ break; } - mtx_unlock(&usb2_quirk_mtx); + mtx_unlock(&usb_quirk_mtx); return (0); } -static struct usb2_quirk_entry * -usb2_quirk_get_entry(uint16_t vid, uint16_t pid, +static struct usb_quirk_entry * +usb_quirk_get_entry(uint16_t vid, uint16_t pid, uint16_t lo_rev, uint16_t hi_rev, uint8_t do_alloc) { uint16_t x; - mtx_assert(&usb2_quirk_mtx, MA_OWNED); + mtx_assert(&usb_quirk_mtx, MA_OWNED); if ((vid | pid | lo_rev | hi_rev) == 0) { /* all zero - special case */ - return (usb2_quirks + USB_DEV_QUIRKS_MAX - 1); + return (usb_quirks + USB_DEV_QUIRKS_MAX - 1); } /* search for an existing entry */ for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) { /* see if quirk information does not match */ - if ((usb2_quirks[x].vid != vid) || - (usb2_quirks[x].pid != pid) || - (usb2_quirks[x].lo_rev != lo_rev) || - (usb2_quirks[x].hi_rev != hi_rev)) { + if ((usb_quirks[x].vid != vid) || + (usb_quirks[x].pid != pid) || + (usb_quirks[x].lo_rev != lo_rev) || + (usb_quirks[x].hi_rev != hi_rev)) { continue; } - return (usb2_quirks + x); + return (usb_quirks + x); } if (do_alloc == 0) { @@ -220,18 +220,18 @@ usb2_quirk_get_entry(uint16_t vid, uint16_t pid, /* search for a free entry */ for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) { /* see if quirk information does not match */ - if ((usb2_quirks[x].vid | - usb2_quirks[x].pid | - usb2_quirks[x].lo_rev | - usb2_quirks[x].hi_rev) != 0) { + if ((usb_quirks[x].vid | + usb_quirks[x].pid | + usb_quirks[x].lo_rev | + usb_quirks[x].hi_rev) != 0) { continue; } - usb2_quirks[x].vid = vid; - usb2_quirks[x].pid = pid; - usb2_quirks[x].lo_rev = lo_rev; - usb2_quirks[x].hi_rev = hi_rev; + usb_quirks[x].vid = vid; + usb_quirks[x].pid = pid; + usb_quirks[x].lo_rev = lo_rev; + usb_quirks[x].hi_rev = hi_rev; - return (usb2_quirks + x); + return (usb_quirks + x); } /* no entry found */ @@ -239,18 +239,18 @@ usb2_quirk_get_entry(uint16_t vid, uint16_t pid, } /*------------------------------------------------------------------------* - * usb2_quirk_ioctl - handle quirk IOCTLs + * usb_quirk_ioctl - handle quirk IOCTLs * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static int -usb2_quirk_ioctl(unsigned long cmd, caddr_t data, +usb_quirk_ioctl(unsigned long cmd, caddr_t data, int fflag, struct thread *td) { struct usb_gen_quirk *pgq; - struct usb2_quirk_entry *pqe; + struct usb_quirk_entry *pqe; uint32_t x; uint32_t y; int err; @@ -263,16 +263,16 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, if (y >= USB_DEV_QUIRKS_MAX) { return (EINVAL); } - mtx_lock(&usb2_quirk_mtx); + mtx_lock(&usb_quirk_mtx); /* copy out data */ - pgq->vid = usb2_quirks[y].vid; - pgq->pid = usb2_quirks[y].pid; - pgq->bcdDeviceLow = usb2_quirks[y].lo_rev; - pgq->bcdDeviceHigh = usb2_quirks[y].hi_rev; + pgq->vid = usb_quirks[y].vid; + pgq->pid = usb_quirks[y].pid; + pgq->bcdDeviceLow = usb_quirks[y].lo_rev; + pgq->bcdDeviceHigh = usb_quirks[y].hi_rev; strlcpy(pgq->quirkname, - usb2_quirkstr(usb2_quirks[y].quirks[x]), + usb_quirkstr(usb_quirks[y].quirks[x]), sizeof(pgq->quirkname)); - mtx_unlock(&usb2_quirk_mtx); + mtx_unlock(&usb_quirk_mtx); return (0); /* success */ case USB_QUIRK_NAME_GET: @@ -282,7 +282,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, return (EINVAL); } strlcpy(pgq->quirkname, - usb2_quirkstr(x), sizeof(pgq->quirkname)); + usb_quirkstr(x), sizeof(pgq->quirkname)); return (0); /* success */ case USB_DEV_QUIRK_ADD: @@ -295,7 +295,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, } /* convert quirk string into numerical */ for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) { - if (strcmp(pgq->quirkname, usb2_quirkstr(y)) == 0) { + if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) { break; } } @@ -305,8 +305,8 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, if (y == UQ_NONE) { return (EINVAL); } - mtx_lock(&usb2_quirk_mtx); - pqe = usb2_quirk_get_entry(pgq->vid, pgq->pid, + mtx_lock(&usb_quirk_mtx); + pqe = usb_quirk_get_entry(pgq->vid, pgq->pid, pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 1); for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) { if (pqe->quirks[x] == UQ_NONE) { @@ -314,7 +314,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, break; } } - mtx_unlock(&usb2_quirk_mtx); + mtx_unlock(&usb_quirk_mtx); if (x == USB_SUB_QUIRKS_MAX) { return (ENOMEM); } @@ -329,7 +329,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, } /* convert quirk string into numerical */ for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) { - if (strcmp(pgq->quirkname, usb2_quirkstr(y)) == 0) { + if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) { break; } } @@ -339,8 +339,8 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, if (y == UQ_NONE) { return (EINVAL); } - mtx_lock(&usb2_quirk_mtx); - pqe = usb2_quirk_get_entry(pgq->vid, pgq->pid, + mtx_lock(&usb_quirk_mtx); + pqe = usb_quirk_get_entry(pgq->vid, pgq->pid, pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 0); for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) { if (pqe->quirks[x] == y) { @@ -349,7 +349,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, } } if (x == USB_SUB_QUIRKS_MAX) { - mtx_unlock(&usb2_quirk_mtx); + mtx_unlock(&usb_quirk_mtx); return (ENOMEM); } for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) { @@ -361,7 +361,7 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, /* all quirk entries are unused - release */ memset(pqe, 0, sizeof(pqe)); } - mtx_unlock(&usb2_quirk_mtx); + mtx_unlock(&usb_quirk_mtx); return (0); /* success */ default: @@ -371,24 +371,24 @@ usb2_quirk_ioctl(unsigned long cmd, caddr_t data, } static void -usb2_quirk_init(void *arg) +usb_quirk_init(void *arg) { /* initialize mutex */ - mtx_init(&usb2_quirk_mtx, "USB quirk", NULL, MTX_DEF); + mtx_init(&usb_quirk_mtx, "USB quirk", NULL, MTX_DEF); /* register our function */ - usb2_test_quirk_p = &usb2_test_quirk_by_info; - usb2_quirk_ioctl_p = &usb2_quirk_ioctl; + usb_test_quirk_p = &usb_test_quirk_by_info; + usb_quirk_ioctl_p = &usb_quirk_ioctl; } static void -usb2_quirk_uninit(void *arg) +usb_quirk_uninit(void *arg) { - usb2_quirk_unload(arg); + usb_quirk_unload(arg); /* destroy mutex */ - mtx_destroy(&usb2_quirk_mtx); + mtx_destroy(&usb_quirk_mtx); } -SYSINIT(usb2_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb2_quirk_init, NULL); -SYSUNINIT(usb2_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb2_quirk_uninit, NULL); +SYSINIT(usb_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_quirk_init, NULL); +SYSUNINIT(usb_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb_quirk_uninit, NULL); diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c index 91190d4..fb25936 100644 --- a/sys/dev/usb/serial/u3g.c +++ b/sys/dev/usb/serial/u3g.c @@ -131,10 +131,10 @@ static const struct usb_config u3g_config[U3G_N_TRANSFER] = { }; static const struct ucom_callback u3g_callback = { - .usb2_com_start_read = &u3g_start_read, - .usb2_com_stop_read = &u3g_stop_read, - .usb2_com_start_write = &u3g_start_write, - .usb2_com_stop_write = &u3g_stop_write, + .ucom_start_read = &u3g_start_read, + .ucom_stop_read = &u3g_stop_read, + .ucom_start_write = &u3g_start_write, + .ucom_stop_write = &u3g_stop_write, }; static device_method_t u3g_methods[] = { @@ -238,7 +238,7 @@ u3g_sierra_init(struct usb_device *udev) USETW(req.wIndex, UHF_PORT_CONNECTION); USETW(req.wLength, 0); - if (usb2_do_request_flags(udev, NULL, &req, + if (usbd_do_request_flags(udev, NULL, &req, NULL, 0, NULL, USB_MS_HZ)) { /* ignore any errors */ } @@ -258,7 +258,7 @@ u3g_huawei_init(struct usb_device *udev) USETW(req.wIndex, UHF_PORT_SUSPEND); USETW(req.wLength, 0); - if (usb2_do_request_flags(udev, NULL, &req, + if (usbd_do_request_flags(udev, NULL, &req, NULL, 0, NULL, USB_MS_HZ)) { /* ignore any errors */ } @@ -306,7 +306,7 @@ u3g_sael_m460_init(struct usb_device *udev) DPRINTFN(1, "\n"); - if (usb2_req_set_alt_interface_no(udev, NULL, 0, 0)) { + if (usbd_req_set_alt_interface_no(udev, NULL, 0, 0)) { DPRINTFN(0, "Alt setting 0 failed\n"); return; } @@ -321,13 +321,13 @@ u3g_sael_m460_init(struct usb_device *udev) DPRINTFN(0, "too small buffer\n"); continue; } - err = usb2_do_request(udev, NULL, &req, buf); + err = usbd_do_request(udev, NULL, &req, buf); } else { if (len > (sizeof(setup[0]) - 8)) { DPRINTFN(0, "too small buffer\n"); continue; } - err = usb2_do_request(udev, NULL, &req, + err = usbd_do_request(udev, NULL, &req, __DECONST(uint8_t *, &setup[n][8])); } if (err) { @@ -349,7 +349,7 @@ static int u3g_lookup_huawei(struct usb_attach_arg *uaa) { /* Calling the lookup function will also set the driver info! */ - return (usb2_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa)); + return (usbd_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa)); } /* @@ -369,7 +369,7 @@ u3g_test_huawei_autoinst(struct usb_device *udev, if (udev == NULL) { return (USB_ERR_INVAL); } - iface = usb2_get_iface(udev, 0); + iface = usbd_get_iface(udev, 0); if (iface == NULL) { return (USB_ERR_INVAL); } @@ -389,7 +389,7 @@ u3g_test_huawei_autoinst(struct usb_device *udev, if (flags & U3GFL_HUAWEI_INIT) { u3g_huawei_init(udev); } else if (flags & U3GFL_SCSI_EJECT) { - return (usb2_test_autoinstall(udev, 0, 1)); + return (usb_test_autoinstall(udev, 0, 1)); } else if (flags & U3GFL_SIERRA_INIT) { u3g_sierra_init(udev); } else { @@ -405,10 +405,10 @@ u3g_driver_loaded(struct module *mod, int what, void *arg) switch (what) { case MOD_LOAD: /* register our autoinstall handler */ - usb2_test_huawei_autoinst_p = &u3g_test_huawei_autoinst; + usb_test_huawei_autoinst_p = &u3g_test_huawei_autoinst; break; case MOD_UNLOAD: - usb2_test_huawei_unload(NULL); + usb_test_huawei_unload(NULL); break; default: return (EOPNOTSUPP); @@ -457,7 +457,7 @@ u3g_attach(device_t dev) for (n = 0; n != U3G_N_TRANSFER; n++) u3g_config_tmp[n] = u3g_config[n]; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "u3g", NULL, MTX_DEF); sc->sc_udev = uaa->device; @@ -465,13 +465,13 @@ u3g_attach(device_t dev) /* Claim all interfaces on the device */ iface_valid = 0; for (i = uaa->info.bIfaceIndex; i < USB_IFACE_MAX; i++) { - iface = usb2_get_iface(uaa->device, i); + iface = usbd_get_iface(uaa->device, i); if (iface == NULL) break; - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id == NULL || id->bInterfaceClass != UICLASS_VENDOR) continue; - usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); + usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); iface_valid |= (1<device, &i, + error = usbd_transfer_setup(uaa->device, &i, sc->sc_xfer[nports], u3g_config_tmp, U3G_N_TRANSFER, &sc->sc_ucom[nports], &sc->sc_mtx); if (error) { @@ -501,8 +501,8 @@ u3g_attach(device_t dev) /* set stall by default */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]); - usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]); + usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]); + usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]); mtx_unlock(&sc->sc_mtx); nports++; /* found one port */ @@ -516,10 +516,10 @@ u3g_attach(device_t dev) } sc->sc_numports = nports; - error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom, + error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numports, sc, &u3g_callback, &sc->sc_mtx); if (error) { - DPRINTF("usb2_com_attach failed\n"); + DPRINTF("ucom_attach failed\n"); goto detach; } if (sc->sc_numports > 1) @@ -540,10 +540,10 @@ u3g_detach(device_t dev) DPRINTF("sc=%p\n", sc); /* NOTE: It is not dangerous to detach more ports than attached! */ - usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, U3G_MAXPORTS); + ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, U3G_MAXPORTS); for (m = 0; m != U3G_MAXPORTS; m++) - usb2_transfer_unsetup(sc->sc_xfer[m], U3G_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer[m], U3G_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -555,7 +555,7 @@ u3g_start_read(struct ucom_softc *ucom) struct u3g_softc *sc = ucom->sc_parent; /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]); + usbd_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]); return; } @@ -565,7 +565,7 @@ u3g_stop_read(struct ucom_softc *ucom) struct u3g_softc *sc = ucom->sc_parent; /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]); + usbd_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]); return; } @@ -574,7 +574,7 @@ u3g_start_write(struct ucom_softc *ucom) { struct u3g_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]); return; } @@ -583,7 +583,7 @@ u3g_stop_write(struct ucom_softc *ucom) { struct u3g_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]); + usbd_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]); return; } @@ -597,10 +597,10 @@ u3g_write_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: case USB_ST_SETUP: tr_setup: - if (usb2_com_get_data(ucom, xfer->frbuffers, 0, + if (ucom_get_data(ucom, xfer->frbuffers, 0, U3G_BSIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -622,12 +622,12 @@ u3g_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ diff --git a/sys/dev/usb/serial/uark.c b/sys/dev/usb/serial/uark.c index 69c5602..04861ba 100644 --- a/sys/dev/usb/serial/uark.c +++ b/sys/dev/usb/serial/uark.c @@ -29,7 +29,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -122,14 +122,14 @@ static const struct usb_config }; static const struct ucom_callback uark_callback = { - .usb2_com_cfg_get_status = &uark_cfg_get_status, - .usb2_com_cfg_set_break = &uark_cfg_set_break, - .usb2_com_cfg_param = &uark_cfg_param, - .usb2_com_pre_param = &uark_pre_param, - .usb2_com_start_read = &uark_start_read, - .usb2_com_stop_read = &uark_stop_read, - .usb2_com_start_write = &uark_start_write, - .usb2_com_stop_write = &uark_stop_write, + .ucom_cfg_get_status = &uark_cfg_get_status, + .ucom_cfg_set_break = &uark_cfg_set_break, + .ucom_cfg_param = &uark_cfg_param, + .ucom_pre_param = &uark_pre_param, + .ucom_start_read = &uark_start_read, + .ucom_stop_read = &uark_stop_read, + .ucom_start_write = &uark_start_write, + .ucom_stop_write = &uark_stop_write, }; static device_method_t uark_methods[] = { @@ -170,7 +170,7 @@ uark_probe(device_t dev) if (uaa->info.bIfaceIndex != UARK_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa)); + return (usbd_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa)); } static int @@ -181,13 +181,13 @@ uark_attach(device_t dev) int32_t error; uint8_t iface_index; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uark", NULL, MTX_DEF); sc->sc_udev = uaa->device; iface_index = UARK_IFACE_INDEX; - error = usb2_transfer_setup + error = usbd_transfer_setup (uaa->device, &iface_index, sc->sc_xfer, uark_xfer_config, UARK_N_TRANSFER, sc, &sc->sc_mtx); @@ -198,14 +198,14 @@ uark_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uark_callback, &sc->sc_mtx); if (error) { - DPRINTF("usb2_com_attach failed\n"); + DPRINTF("ucom_attach failed\n"); goto detach; } return (0); /* success */ @@ -220,8 +220,8 @@ uark_detach(device_t dev) { struct uark_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -237,10 +237,10 @@ uark_bulk_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UARK_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -262,13 +262,13 @@ uark_bulk_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -286,7 +286,7 @@ uark_start_read(struct ucom_softc *ucom) { struct uark_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]); } static void @@ -294,7 +294,7 @@ uark_stop_read(struct ucom_softc *ucom) { struct uark_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]); } static void @@ -302,7 +302,7 @@ uark_start_write(struct ucom_softc *ucom) { struct uark_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]); } static void @@ -310,7 +310,7 @@ uark_stop_write(struct ucom_softc *ucom) { struct uark_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]); } static int @@ -402,10 +402,10 @@ uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value) USETW(req.wIndex, index); USETW(req.wLength, 0); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } } diff --git a/sys/dev/usb/serial/ubsa.c b/sys/dev/usb/serial/ubsa.c index cb7a337..cc584c3 100644 --- a/sys/dev/usb/serial/ubsa.c +++ b/sys/dev/usb/serial/ubsa.c @@ -213,16 +213,16 @@ static const struct usb_config ubsa_config[UBSA_N_TRANSFER] = { }; static const struct ucom_callback ubsa_callback = { - .usb2_com_cfg_get_status = &ubsa_cfg_get_status, - .usb2_com_cfg_set_dtr = &ubsa_cfg_set_dtr, - .usb2_com_cfg_set_rts = &ubsa_cfg_set_rts, - .usb2_com_cfg_set_break = &ubsa_cfg_set_break, - .usb2_com_cfg_param = &ubsa_cfg_param, - .usb2_com_pre_param = &ubsa_pre_param, - .usb2_com_start_read = &ubsa_start_read, - .usb2_com_stop_read = &ubsa_stop_read, - .usb2_com_start_write = &ubsa_start_write, - .usb2_com_stop_write = &ubsa_stop_write, + .ucom_cfg_get_status = &ubsa_cfg_get_status, + .ucom_cfg_set_dtr = &ubsa_cfg_set_dtr, + .ucom_cfg_set_rts = &ubsa_cfg_set_rts, + .ucom_cfg_set_break = &ubsa_cfg_set_break, + .ucom_cfg_param = &ubsa_cfg_param, + .ucom_pre_param = &ubsa_pre_param, + .ucom_start_read = &ubsa_start_read, + .ucom_stop_read = &ubsa_stop_read, + .ucom_start_write = &ubsa_start_write, + .ucom_stop_write = &ubsa_stop_write, }; static const struct usb_device_id ubsa_devs[] = { @@ -277,7 +277,7 @@ ubsa_probe(device_t dev) if (uaa->info.bIfaceIndex != UBSA_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(ubsa_devs, sizeof(ubsa_devs), uaa)); + return (usbd_lookup_id_by_uaa(ubsa_devs, sizeof(ubsa_devs), uaa)); } static int @@ -289,14 +289,14 @@ ubsa_attach(device_t dev) DPRINTF("sc=%p\n", sc); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ubsa", NULL, MTX_DEF); sc->sc_udev = uaa->device; sc->sc_iface_no = uaa->info.bIfaceNum; sc->sc_iface_index = UBSA_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index, + error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, sc->sc_xfer, ubsa_config, UBSA_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -305,14 +305,14 @@ ubsa_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &ubsa_callback, &sc->sc_mtx); if (error) { - DPRINTF("usb2_com_attach failed\n"); + DPRINTF("ucom_attach failed\n"); goto detach; } return (0); @@ -329,8 +329,8 @@ ubsa_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UBSA_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UBSA_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -349,11 +349,11 @@ ubsa_cfg_request(struct ubsa_softc *sc, uint8_t index, uint16_t value) req.wIndex[1] = 0; USETW(req.wLength, 0); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } } @@ -491,10 +491,10 @@ ubsa_start_read(struct ucom_softc *ucom) struct ubsa_softc *sc = ucom->sc_parent; /* start interrupt endpoint */ - usb2_transfer_start(sc->sc_xfer[UBSA_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UBSA_INTR_DT_RD]); /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UBSA_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UBSA_BULK_DT_RD]); } static void @@ -503,10 +503,10 @@ ubsa_stop_read(struct ucom_softc *ucom) struct ubsa_softc *sc = ucom->sc_parent; /* stop interrupt endpoint */ - usb2_transfer_stop(sc->sc_xfer[UBSA_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UBSA_INTR_DT_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_RD]); } static void @@ -514,7 +514,7 @@ ubsa_start_write(struct ucom_softc *ucom) { struct ubsa_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UBSA_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UBSA_BULK_DT_WR]); } static void @@ -522,7 +522,7 @@ ubsa_stop_write(struct ucom_softc *ucom) { struct ubsa_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UBSA_BULK_DT_WR]); } static void @@ -546,11 +546,11 @@ ubsa_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UBSA_BSIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -572,12 +572,12 @@ ubsa_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -602,7 +602,7 @@ ubsa_intr_callback(struct usb_xfer *xfer) if (xfer->actlen >= sizeof(buf)) { - usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); + usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); /* * incidentally, Belkin adapter status bits match @@ -614,7 +614,7 @@ ubsa_intr_callback(struct usb_xfer *xfer) DPRINTF("lsr = 0x%02x, msr = 0x%02x\n", sc->sc_lsr, sc->sc_msr); - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); } else { DPRINTF("ignoring short packet, %d bytes\n", xfer->actlen); @@ -623,7 +623,7 @@ ubsa_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/ubser.c b/sys/dev/usb/serial/ubser.c index 3857a5a..f184ecd 100644 --- a/sys/dev/usb/serial/ubser.c +++ b/sys/dev/usb/serial/ubser.c @@ -172,13 +172,13 @@ static const struct usb_config ubser_config[UBSER_N_TRANSFER] = { }; static const struct ucom_callback ubser_callback = { - .usb2_com_cfg_set_break = &ubser_cfg_set_break, - .usb2_com_cfg_get_status = &ubser_cfg_get_status, - .usb2_com_pre_param = &ubser_pre_param, - .usb2_com_start_read = &ubser_start_read, - .usb2_com_stop_read = &ubser_stop_read, - .usb2_com_start_write = &ubser_start_write, - .usb2_com_stop_write = &ubser_stop_write, + .ucom_cfg_set_break = &ubser_cfg_set_break, + .ucom_cfg_get_status = &ubser_cfg_get_status, + .ucom_pre_param = &ubser_pre_param, + .ucom_start_read = &ubser_start_read, + .ucom_stop_read = &ubser_stop_read, + .ucom_start_write = &ubser_start_write, + .ucom_stop_write = &ubser_stop_write, }; static device_method_t ubser_methods[] = { @@ -226,7 +226,7 @@ ubser_attach(device_t dev) uint8_t n; int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ubser", NULL, MTX_DEF); snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", @@ -243,14 +243,14 @@ ubser_attach(device_t dev) req.wIndex[0] = sc->sc_iface_no; req.wIndex[1] = 0; USETW(req.wLength, 1); - error = usb2_do_request_flags(uaa->device, NULL, + error = usbd_do_request_flags(uaa->device, NULL, &req, &sc->sc_numser, 0, NULL, USB_DEFAULT_TIMEOUT); if (error || (sc->sc_numser == 0)) { device_printf(dev, "failed to get number " "of serial ports: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } if (sc->sc_numser > UBSER_UNIT_MAX) @@ -258,7 +258,7 @@ ubser_attach(device_t dev) device_printf(dev, "found %i serials\n", sc->sc_numser); - error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index, + error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, sc->sc_xfer, ubser_config, UBSER_N_TRANSFER, sc, &sc->sc_mtx); if (error) { goto detach; @@ -275,16 +275,16 @@ ubser_attach(device_t dev) sc->sc_ucom[n].sc_portno = n; } - error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom, + error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numser, sc, &ubser_callback, &sc->sc_mtx); if (error) { goto detach; } mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]); - usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); return (0); /* success */ @@ -301,8 +301,8 @@ ubser_detach(device_t dev) DPRINTF("\n"); - usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numser); - usb2_transfer_unsetup(sc->sc_xfer, UBSER_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_numser); + usbd_transfer_unsetup(sc->sc_xfer, UBSER_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -379,16 +379,16 @@ ubser_write_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: tr_setup: do { - if (usb2_com_get_data(sc->sc_ucom + sc->sc_curr_tx_unit, + if (ucom_get_data(sc->sc_ucom + sc->sc_curr_tx_unit, xfer->frbuffers, 1, sc->sc_tx_size - 1, &actlen)) { buf[0] = sc->sc_curr_tx_unit; - usb2_copy_in(xfer->frbuffers, 0, buf, 1); + usbd_copy_in(xfer->frbuffers, 0, buf, 1); xfer->frlengths[0] = actlen + 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); ubser_inc_tx_unit(sc); /* round robin */ @@ -423,19 +423,19 @@ ubser_read_callback(struct usb_xfer *xfer) DPRINTF("invalid actlen=0!\n"); goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 1); + usbd_copy_out(xfer->frbuffers, 0, buf, 1); if (buf[0] >= sc->sc_numser) { DPRINTF("invalid serial number!\n"); goto tr_setup; } - usb2_com_put_data(sc->sc_ucom + buf[0], + ucom_put_data(sc->sc_ucom + buf[0], xfer->frbuffers, 1, xfer->actlen - 1); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -467,11 +467,11 @@ ubser_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - err = usb2_com_cfg_do_request(sc->sc_udev, ucom, + err = ucom_cfg_do_request(sc->sc_udev, ucom, &req, NULL, 0, 1000); if (err) { DPRINTFN(0, "send break failed, error=%s\n", - usb2_errstr(err)); + usbd_errstr(err)); } } } @@ -489,7 +489,7 @@ ubser_start_read(struct ucom_softc *ucom) { struct ubser_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]); } static void @@ -497,7 +497,7 @@ ubser_stop_read(struct ucom_softc *ucom) { struct ubser_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_RD]); } static void @@ -505,7 +505,7 @@ ubser_start_write(struct ucom_softc *ucom) { struct ubser_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UBSER_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_WR]); } static void @@ -513,5 +513,5 @@ ubser_stop_write(struct ucom_softc *ucom) { struct ubser_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UBSER_BULK_DT_WR]); } diff --git a/sys/dev/usb/serial/uchcom.c b/sys/dev/usb/serial/uchcom.c index 6ed4905..009a37d 100644 --- a/sys/dev/usb/serial/uchcom.c +++ b/sys/dev/usb/serial/uchcom.c @@ -258,16 +258,16 @@ static const struct usb_config uchcom_config_data[UCHCOM_N_TRANSFER] = { }; static struct ucom_callback uchcom_callback = { - .usb2_com_cfg_get_status = &uchcom_cfg_get_status, - .usb2_com_cfg_set_dtr = &uchcom_cfg_set_dtr, - .usb2_com_cfg_set_rts = &uchcom_cfg_set_rts, - .usb2_com_cfg_set_break = &uchcom_cfg_set_break, - .usb2_com_cfg_param = &uchcom_cfg_param, - .usb2_com_pre_param = &uchcom_pre_param, - .usb2_com_start_read = &uchcom_start_read, - .usb2_com_stop_read = &uchcom_stop_read, - .usb2_com_start_write = &uchcom_start_write, - .usb2_com_stop_write = &uchcom_stop_write, + .ucom_cfg_get_status = &uchcom_cfg_get_status, + .ucom_cfg_set_dtr = &uchcom_cfg_set_dtr, + .ucom_cfg_set_rts = &uchcom_cfg_set_rts, + .ucom_cfg_set_break = &uchcom_cfg_set_break, + .ucom_cfg_param = &uchcom_cfg_param, + .ucom_pre_param = &uchcom_pre_param, + .ucom_start_read = &uchcom_start_read, + .ucom_stop_read = &uchcom_stop_read, + .ucom_start_write = &uchcom_start_write, + .ucom_stop_write = &uchcom_stop_write, }; /* ---------------------------------------------------------------------- @@ -290,7 +290,7 @@ uchcom_probe(device_t dev) if (uaa->info.bIfaceIndex != UCHCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uchcom_devs, sizeof(uchcom_devs), uaa)); + return (usbd_lookup_id_by_uaa(uchcom_devs, sizeof(uchcom_devs), uaa)); } static int @@ -303,7 +303,7 @@ uchcom_attach(device_t dev) DPRINTFN(11, "\n"); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uchcom", NULL, MTX_DEF); sc->sc_udev = uaa->device; @@ -318,13 +318,13 @@ uchcom_attach(device_t dev) } iface_index = UCHCOM_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, uchcom_config_data, UCHCOM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { DPRINTF("one or more missing USB endpoints, " - "error=%s\n", usb2_errstr(error)); + "error=%s\n", usbd_errstr(error)); goto detach; } /* @@ -341,11 +341,11 @@ uchcom_attach(device_t dev) /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uchcom_callback, &sc->sc_mtx); if (error) { goto detach; @@ -364,8 +364,8 @@ uchcom_detach(device_t dev) DPRINTFN(11, "\n"); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UCHCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UCHCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -387,7 +387,7 @@ uchcom_ctrl_write(struct uchcom_softc *sc, uint8_t reqno, USETW(req.wIndex, index); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -403,7 +403,7 @@ uchcom_ctrl_read(struct uchcom_softc *sc, uint8_t reqno, USETW(req.wIndex, index); USETW(req.wLength, buflen); - usb2_com_cfg_do_request(sc->sc_udev, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, buf, USB_SHORT_XFER_OK, 1000); } @@ -734,10 +734,10 @@ uchcom_start_read(struct ucom_softc *ucom) struct uchcom_softc *sc = ucom->sc_parent; /* start interrupt endpoint */ - usb2_transfer_start(sc->sc_xfer[UCHCOM_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UCHCOM_INTR_DT_RD]); /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_RD]); } static void @@ -746,10 +746,10 @@ uchcom_stop_read(struct ucom_softc *ucom) struct uchcom_softc *sc = ucom->sc_parent; /* stop interrupt endpoint */ - usb2_transfer_stop(sc->sc_xfer[UCHCOM_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UCHCOM_INTR_DT_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_RD]); } static void @@ -757,7 +757,7 @@ uchcom_start_write(struct ucom_softc *ucom) { struct uchcom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UCHCOM_BULK_DT_WR]); } static void @@ -765,7 +765,7 @@ uchcom_stop_write(struct ucom_softc *ucom) { struct uchcom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UCHCOM_BULK_DT_WR]); } /* ---------------------------------------------------------------------- @@ -783,7 +783,7 @@ uchcom_intr_callback(struct usb_xfer *xfer) DPRINTF("actlen = %u\n", xfer->actlen); if (xfer->actlen >= UCHCOM_INTR_LEAST) { - usb2_copy_out(xfer->frbuffers, 0, buf, + usbd_copy_out(xfer->frbuffers, 0, buf, UCHCOM_INTR_LEAST); DPRINTF("data = 0x%02X 0x%02X 0x%02X 0x%02X\n", @@ -791,12 +791,12 @@ uchcom_intr_callback(struct usb_xfer *xfer) (unsigned)buf[2], (unsigned)buf[3]); uchcom_convert_status(sc, buf[UCHCOM_INTR_STAT1]); - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); } case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -819,13 +819,13 @@ uchcom_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UCHCOM_BULK_BUF_SIZE, &actlen)) { DPRINTF("actlen = %d\n", actlen); xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -847,12 +847,12 @@ uchcom_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c index 794b86c..7825a22 100644 --- a/sys/dev/usb/serial/ucycom.c +++ b/sys/dev/usb/serial/ucycom.c @@ -42,7 +42,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -136,13 +136,13 @@ static const struct usb_config ucycom_config[UCYCOM_N_TRANSFER] = { }; static const struct ucom_callback ucycom_callback = { - .usb2_com_cfg_param = &ucycom_cfg_param, - .usb2_com_cfg_open = &ucycom_cfg_open, - .usb2_com_pre_param = &ucycom_pre_param, - .usb2_com_start_read = &ucycom_start_read, - .usb2_com_stop_read = &ucycom_stop_read, - .usb2_com_start_write = &ucycom_start_write, - .usb2_com_stop_write = &ucycom_stop_write, + .ucom_cfg_param = &ucycom_cfg_param, + .ucom_cfg_open = &ucycom_cfg_open, + .ucom_pre_param = &ucycom_pre_param, + .ucom_start_read = &ucycom_start_read, + .ucom_stop_read = &ucycom_stop_read, + .ucom_start_write = &ucycom_start_write, + .ucom_stop_write = &ucycom_stop_write, }; static device_method_t ucycom_methods[] = { @@ -188,7 +188,7 @@ ucycom_probe(device_t dev) if (uaa->info.bIfaceIndex != UCYCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(ucycom_devs, sizeof(ucycom_devs), uaa)); + return (usbd_lookup_id_by_uaa(ucycom_devs, sizeof(ucycom_devs), uaa)); } static int @@ -203,7 +203,7 @@ ucycom_attach(device_t dev) sc->sc_udev = uaa->device; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ucycom", NULL, MTX_DEF); snprintf(sc->sc_name, sizeof(sc->sc_name), @@ -221,14 +221,14 @@ ucycom_attach(device_t dev) /* get report descriptor */ - error = usb2_req_get_hid_desc(uaa->device, NULL, + error = usbd_req_get_hid_desc(uaa->device, NULL, &urd_ptr, &urd_len, M_USBDEV, UCYCOM_IFACE_INDEX); if (error) { device_printf(dev, "failed to get report " "descriptor: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } /* get report sizes */ @@ -248,7 +248,7 @@ ucycom_attach(device_t dev) sc->sc_iface_no = uaa->info.bIfaceNum; iface_index = UCYCOM_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, ucycom_config, UCYCOM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -256,7 +256,7 @@ ucycom_attach(device_t dev) "transfers failed!\n"); goto detach; } - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &ucycom_callback, &sc->sc_mtx); if (error) { @@ -280,8 +280,8 @@ ucycom_detach(device_t dev) { struct ucycom_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UCYCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UCYCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -301,7 +301,7 @@ ucycom_start_read(struct ucom_softc *ucom) { struct ucycom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UCYCOM_INTR_RD]); + usbd_transfer_start(sc->sc_xfer[UCYCOM_INTR_RD]); } static void @@ -309,7 +309,7 @@ ucycom_stop_read(struct ucom_softc *ucom) { struct ucycom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UCYCOM_INTR_RD]); + usbd_transfer_stop(sc->sc_xfer[UCYCOM_INTR_RD]); } static void @@ -317,7 +317,7 @@ ucycom_start_write(struct ucom_softc *ucom) { struct ucycom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UCYCOM_CTRL_RD]); + usbd_transfer_start(sc->sc_xfer[UCYCOM_CTRL_RD]); } static void @@ -325,7 +325,7 @@ ucycom_stop_write(struct ucom_softc *ucom) { struct ucycom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UCYCOM_CTRL_RD]); + usbd_transfer_stop(sc->sc_xfer[UCYCOM_CTRL_RD]); } static void @@ -354,7 +354,7 @@ tr_transferred: break; } - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers + 1, offset, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1, offset, sc->sc_olen - offset, &actlen)) { req.bmRequestType = UT_WRITE_CLASS_INTERFACE; @@ -376,13 +376,13 @@ tr_transferred: break; } - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_copy_in(xfer->frbuffers + 1, 0, data, offset); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers + 1, 0, data, offset); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = sc->sc_olen; xfer->nframes = xfer->frlengths[1] ? 2 : 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -391,7 +391,7 @@ tr_transferred: return; } DPRINTF("error=%s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); goto tr_transferred; } } @@ -422,11 +422,11 @@ ucycom_cfg_write(struct ucycom_softc *sc, uint32_t baud, uint8_t cfg) sc->sc_temp_cfg[3] = (baud >> 24) & 0xff; sc->sc_temp_cfg[4] = cfg; - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, sc->sc_temp_cfg, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } } @@ -508,7 +508,7 @@ ucycom_intr_read_callback(struct usb_xfer *xfer) if (xfer->actlen < 1) { goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 1); + usbd_copy_out(xfer->frbuffers, 0, buf, 1); sc->sc_ist = buf[0] & ~0x07; len = buf[0] & 0x07; @@ -523,7 +523,7 @@ ucycom_intr_read_callback(struct usb_xfer *xfer) if (xfer->actlen < 2) { goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 2); + usbd_copy_out(xfer->frbuffers, 0, buf, 2); sc->sc_ist = buf[0] & ~0x07; len = buf[1]; @@ -543,13 +543,13 @@ ucycom_intr_read_callback(struct usb_xfer *xfer) len = xfer->actlen; } if (len) { - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, offset, len); } case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = sc->sc_ilen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/ufoma.c b/sys/dev/usb/serial/ufoma.c index 3e1f134..89285ed 100644 --- a/sys/dev/usb/serial/ufoma.c +++ b/sys/dev/usb/serial/ufoma.c @@ -88,7 +88,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -109,7 +109,7 @@ typedef struct ufoma_mobile_acm_descriptor { uint8_t bDescriptorSubtype; uint8_t bType; uint8_t bMode[1]; -} __packed usb2_mcpc_acm_descriptor; +} __packed usb_mcpc_acm_descriptor; #define UISUBCLASS_MCPC 0x88 @@ -280,18 +280,18 @@ static const struct usb_config }; static const struct ucom_callback ufoma_callback = { - .usb2_com_cfg_get_status = &ufoma_cfg_get_status, - .usb2_com_cfg_set_dtr = &ufoma_cfg_set_dtr, - .usb2_com_cfg_set_rts = &ufoma_cfg_set_rts, - .usb2_com_cfg_set_break = &ufoma_cfg_set_break, - .usb2_com_cfg_param = &ufoma_cfg_param, - .usb2_com_cfg_open = &ufoma_cfg_open, - .usb2_com_cfg_close = &ufoma_cfg_close, - .usb2_com_pre_param = &ufoma_pre_param, - .usb2_com_start_read = &ufoma_start_read, - .usb2_com_stop_read = &ufoma_stop_read, - .usb2_com_start_write = &ufoma_start_write, - .usb2_com_stop_write = &ufoma_stop_write, + .ucom_cfg_get_status = &ufoma_cfg_get_status, + .ucom_cfg_set_dtr = &ufoma_cfg_set_dtr, + .ucom_cfg_set_rts = &ufoma_cfg_set_rts, + .ucom_cfg_set_break = &ufoma_cfg_set_break, + .ucom_cfg_param = &ufoma_cfg_param, + .ucom_cfg_open = &ufoma_cfg_open, + .ucom_cfg_close = &ufoma_cfg_close, + .ucom_pre_param = &ufoma_pre_param, + .ucom_start_read = &ufoma_start_read, + .ucom_stop_read = &ufoma_stop_read, + .ucom_start_write = &ufoma_start_write, + .ucom_stop_write = &ufoma_stop_write, }; static device_method_t ufoma_methods[] = { @@ -320,13 +320,13 @@ ufoma_probe(device_t dev) struct usb_attach_arg *uaa = device_get_ivars(dev); struct usb_interface_descriptor *id; struct usb_config_descriptor *cd; - usb2_mcpc_acm_descriptor *mad; + usb_mcpc_acm_descriptor *mad; if (uaa->usb_mode != USB_MODE_HOST) { return (ENXIO); } - id = usb2_get_interface_descriptor(uaa->iface); - cd = usb2_get_config_descriptor(uaa->device); + id = usbd_get_interface_descriptor(uaa->iface); + cd = usbd_get_config_descriptor(uaa->device); if ((id == NULL) || (cd == NULL) || @@ -357,7 +357,7 @@ ufoma_attach(device_t dev) struct sysctl_ctx_list *sctx; struct sysctl_oid *soid; - usb2_mcpc_acm_descriptor *mad; + usb_mcpc_acm_descriptor *mad; uint8_t elements; int32_t error; @@ -368,7 +368,7 @@ ufoma_attach(device_t dev) mtx_init(&sc->sc_mtx, "ufoma", NULL, MTX_DEF); cv_init(&sc->sc_cv, "CWAIT"); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", device_get_nameunit(dev)); @@ -377,12 +377,12 @@ ufoma_attach(device_t dev) /* setup control transfers */ - cd = usb2_get_config_descriptor(uaa->device); - id = usb2_get_interface_descriptor(uaa->iface); + cd = usbd_get_config_descriptor(uaa->device); + id = usbd_get_interface_descriptor(uaa->iface); sc->sc_ctrl_iface_no = id->bInterfaceNumber; sc->sc_ctrl_iface_index = uaa->info.bIfaceIndex; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &sc->sc_ctrl_iface_index, sc->sc_ctrl_xfer, ufoma_ctrl_config, UFOMA_CTRL_ENDPT_MAX, sc, &sc->sc_mtx); @@ -426,14 +426,14 @@ ufoma_attach(device_t dev) /* clear stall at first run, if any */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); - usb2_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); + usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); + usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &ufoma_callback, &sc->sc_mtx); if (error) { - DPRINTF("usb2_com_attach failed\n"); + DPRINTF("ucom_attach failed\n"); goto detach; } /*Sysctls*/ @@ -467,9 +467,9 @@ ufoma_detach(device_t dev) { struct ufoma_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_ctrl_xfer, UFOMA_CTRL_ENDPT_MAX); - usb2_transfer_unsetup(sc->sc_bulk_xfer, UFOMA_BULK_ENDPT_MAX); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_ctrl_xfer, UFOMA_CTRL_ENDPT_MAX); + usbd_transfer_unsetup(sc->sc_bulk_xfer, UFOMA_BULK_ENDPT_MAX); if (sc->sc_modetable) { free(sc->sc_modetable, M_USBDEV); @@ -486,7 +486,7 @@ ufoma_get_intconf(struct usb_config_descriptor *cd, struct usb_interface_descrip { struct usb_descriptor *desc = (void *)id; - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if (desc->bDescriptorType == UDESC_INTERFACE) { return (NULL); @@ -511,7 +511,7 @@ ufoma_cfg_link_state(struct ufoma_softc *sc) USETW(req.wIndex, sc->sc_ctrl_iface_no); USETW(req.wLength, sc->sc_modetable[0]); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, sc->sc_modetable, 0, 1000); error = cv_timedwait(&sc->sc_cv, &sc->sc_mtx, hz); @@ -533,7 +533,7 @@ ufoma_cfg_activate_state(struct ufoma_softc *sc, uint16_t state) USETW(req.wIndex, sc->sc_ctrl_iface_no); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); error = cv_timedwait(&sc->sc_cv, &sc->sc_mtx, @@ -556,7 +556,7 @@ tr_transferred: goto tr_setup; } if (xfer->frlengths[1] > 0) { - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers + 1, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers + 1, 0, xfer->frlengths[1]); } case USB_ST_SETUP: @@ -570,18 +570,18 @@ tr_setup: USETW(req.wValue, 0); USETW(req.wLength, UFOMA_CMD_BUF_SIZE); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = UFOMA_CMD_BUF_SIZE; xfer->nframes = 2; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: /* Error */ DPRINTF("error = %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error == USB_ERR_CANCELLED) { return; @@ -605,7 +605,7 @@ ufoma_ctrl_write_callback(struct usb_xfer *xfer) tr_transferred: case USB_ST_SETUP: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers + 1, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1, 0, 1, &actlen)) { req.bmRequestType = UT_WRITE_CLASS_INTERFACE; @@ -614,19 +614,19 @@ tr_setup: USETW(req.wValue, 0); USETW(req.wLength, 1); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = 1; xfer->nframes = 2; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; default: /* Error */ DPRINTF("error = %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error == USB_ERR_CANCELLED) { return; @@ -657,7 +657,7 @@ ufoma_intr_callback(struct usb_xfer *xfer) DPRINTF("truncating message\n"); xfer->actlen = sizeof(pkt); } - usb2_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen); xfer->actlen -= 8; @@ -686,7 +686,7 @@ ufoma_intr_callback(struct usb_xfer *xfer) if (sc->sc_num_msg != 0xFF) { sc->sc_num_msg++; } - usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); + usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); break; case UCDC_N_SERIAL_STATE: @@ -721,7 +721,7 @@ ufoma_intr_callback(struct usb_xfer *xfer) if (mstatus & UCDC_N_SERIAL_DCD) { sc->sc_msr |= SER_DCD; } - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); break; default: @@ -731,7 +731,7 @@ ufoma_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -754,10 +754,10 @@ ufoma_bulk_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UFOMA_BULK_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -778,13 +778,13 @@ ufoma_bulk_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -846,7 +846,7 @@ ufoma_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -875,7 +875,7 @@ ufoma_cfg_set_line_state(struct ufoma_softc *sc) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -972,7 +972,7 @@ ufoma_cfg_param(struct ucom_softc *ucom, struct termios *t) req.wIndex[1] = 0; USETW(req.wLength, UCDC_LINE_STATE_LENGTH); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, &ls, 0, 1000); } @@ -988,8 +988,8 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc, uint8_t i; int32_t error; - cd = usb2_get_config_descriptor(uaa->device); - id = usb2_get_interface_descriptor(uaa->iface); + cd = usbd_get_config_descriptor(uaa->device); + id = usbd_get_interface_descriptor(uaa->iface); cmd = ufoma_get_intconf(cd, id, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM); @@ -1018,15 +1018,15 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc, for (i = 0;; i++) { - iface = usb2_get_iface(uaa->device, i); + iface = usbd_get_iface(uaa->device, i); if (iface) { - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id && (id->bInterfaceNumber == sc->sc_data_iface_no)) { sc->sc_data_iface_index = i; - usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); + usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); break; } } else { @@ -1035,7 +1035,7 @@ ufoma_modem_setup(device_t dev, struct ufoma_softc *sc, } } - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &sc->sc_data_iface_index, sc->sc_bulk_xfer, ufoma_bulk_config, UFOMA_BULK_ENDPT_MAX, sc, &sc->sc_mtx); @@ -1053,13 +1053,13 @@ ufoma_start_read(struct ucom_softc *ucom) struct ufoma_softc *sc = ucom->sc_parent; /* start interrupt transfer */ - usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]); + usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]); /* start data transfer */ if (sc->sc_nobulk) { - usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); + usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); } else { - usb2_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); + usbd_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); } } @@ -1069,13 +1069,13 @@ ufoma_stop_read(struct ucom_softc *ucom) struct ufoma_softc *sc = ucom->sc_parent; /* stop interrupt transfer */ - usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]); + usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_INTR]); /* stop data transfer */ if (sc->sc_nobulk) { - usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); + usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_READ]); } else { - usb2_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); + usbd_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]); } } @@ -1085,9 +1085,9 @@ ufoma_start_write(struct ucom_softc *ucom) struct ufoma_softc *sc = ucom->sc_parent; if (sc->sc_nobulk) { - usb2_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]); + usbd_transfer_start(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]); } else { - usb2_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); + usbd_transfer_start(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); } } @@ -1097,9 +1097,9 @@ ufoma_stop_write(struct ucom_softc *ucom) struct ufoma_softc *sc = ucom->sc_parent; if (sc->sc_nobulk) { - usb2_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]); + usbd_transfer_stop(sc->sc_ctrl_xfer[UFOMA_CTRL_ENDPT_WRITE]); } else { - usb2_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); + usbd_transfer_stop(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]); } } diff --git a/sys/dev/usb/serial/uftdi.c b/sys/dev/usb/serial/uftdi.c index 7726abd..700d68b 100644 --- a/sys/dev/usb/serial/uftdi.c +++ b/sys/dev/usb/serial/uftdi.c @@ -166,17 +166,17 @@ static const struct usb_config uftdi_config[UFTDI_N_TRANSFER] = { }; static const struct ucom_callback uftdi_callback = { - .usb2_com_cfg_get_status = &uftdi_cfg_get_status, - .usb2_com_cfg_set_dtr = &uftdi_cfg_set_dtr, - .usb2_com_cfg_set_rts = &uftdi_cfg_set_rts, - .usb2_com_cfg_set_break = &uftdi_cfg_set_break, - .usb2_com_cfg_param = &uftdi_cfg_param, - .usb2_com_cfg_open = &uftdi_cfg_open, - .usb2_com_pre_param = &uftdi_pre_param, - .usb2_com_start_read = &uftdi_start_read, - .usb2_com_stop_read = &uftdi_stop_read, - .usb2_com_start_write = &uftdi_start_write, - .usb2_com_stop_write = &uftdi_stop_write, + .ucom_cfg_get_status = &uftdi_cfg_get_status, + .ucom_cfg_set_dtr = &uftdi_cfg_set_dtr, + .ucom_cfg_set_rts = &uftdi_cfg_set_rts, + .ucom_cfg_set_break = &uftdi_cfg_set_break, + .ucom_cfg_param = &uftdi_cfg_param, + .ucom_cfg_open = &uftdi_cfg_open, + .ucom_pre_param = &uftdi_pre_param, + .ucom_start_read = &uftdi_start_read, + .ucom_stop_read = &uftdi_stop_read, + .ucom_start_write = &uftdi_start_write, + .ucom_stop_write = &uftdi_stop_write, }; static device_method_t uftdi_methods[] = { @@ -248,7 +248,7 @@ uftdi_probe(device_t dev) } /* attach to all present interfaces */ - return (usb2_lookup_id_by_uaa(uftdi_devs, sizeof(uftdi_devs), uaa)); + return (usbd_lookup_id_by_uaa(uftdi_devs, sizeof(uftdi_devs), uaa)); } static int @@ -262,7 +262,7 @@ uftdi_attach(device_t dev) sc->sc_dev = dev; sc->sc_unit = device_get_unit(dev); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uftdi", NULL, MTX_DEF); snprintf(sc->sc_name, sizeof(sc->sc_name), @@ -283,7 +283,7 @@ uftdi_attach(device_t dev) break; } - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, sc->sc_xfer, uftdi_config, UFTDI_N_TRANSFER, sc, &sc->sc_mtx); @@ -296,8 +296,8 @@ uftdi_attach(device_t dev) /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); /* set a valid "lcr" value */ @@ -307,7 +307,7 @@ uftdi_attach(device_t dev) FTDI_SIO_SET_DATA_PARITY_NONE | FTDI_SIO_SET_DATA_BITS(8)); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uftdi_callback, &sc->sc_mtx); if (error) { goto detach; @@ -324,8 +324,8 @@ uftdi_detach(device_t dev) { struct uftdi_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UFTDI_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UFTDI_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -347,7 +347,7 @@ uftdi_cfg_open(struct ucom_softc *ucom) USETW(req.wValue, FTDI_SIO_RESET_SIO); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); /* turn on RTS/CTS flow control */ @@ -357,7 +357,7 @@ uftdi_cfg_open(struct ucom_softc *ucom) USETW(req.wValue, 0); USETW2(req.wIndex, FTDI_SIO_RTS_CTS_HS, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); /* @@ -378,17 +378,17 @@ uftdi_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, sc->sc_hdrlen, UFTDI_OBUFSIZE - sc->sc_hdrlen, &actlen)) { if (sc->sc_hdrlen > 0) { buf[0] = FTDI_OUT_TAG(actlen, sc->sc_ucom.sc_portno); - usb2_copy_in(xfer->frbuffers, 0, buf, 1); + usbd_copy_in(xfer->frbuffers, 0, buf, 1); } xfer->frlengths[0] = actlen + sc->sc_hdrlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -417,7 +417,7 @@ uftdi_read_callback(struct usb_xfer *xfer) if (xfer->actlen < 2) { goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, 2); + usbd_copy_out(xfer->frbuffers, 0, buf, 2); ftdi_msr = FTDI_GET_MSR(buf); lsr = FTDI_GET_LSR(buf); @@ -441,18 +441,18 @@ uftdi_read_callback(struct usb_xfer *xfer) sc->sc_msr = msr; sc->sc_lsr = lsr; - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); } xfer->actlen -= 2; if (xfer->actlen > 0) { - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 2, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 2, xfer->actlen); } case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -480,7 +480,7 @@ uftdi_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wValue, wValue); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -499,7 +499,7 @@ uftdi_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wValue, wValue); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -524,7 +524,7 @@ uftdi_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wValue, wValue); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -657,7 +657,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wValue, cfg.rate); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; @@ -665,7 +665,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wValue, cfg.lcr); USETW(req.wIndex, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; @@ -673,7 +673,7 @@ uftdi_cfg_param(struct ucom_softc *ucom, struct termios *t) USETW2(req.wValue, cfg.v_stop, cfg.v_start); USETW2(req.wIndex, cfg.v_flow, wIndex); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -694,7 +694,7 @@ uftdi_start_read(struct ucom_softc *ucom) { struct uftdi_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_RD]); } static void @@ -702,7 +702,7 @@ uftdi_stop_read(struct ucom_softc *ucom) { struct uftdi_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_RD]); } static void @@ -710,7 +710,7 @@ uftdi_start_write(struct ucom_softc *ucom) { struct uftdi_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UFTDI_BULK_DT_WR]); } static void @@ -718,7 +718,7 @@ uftdi_stop_write(struct ucom_softc *ucom) { struct uftdi_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UFTDI_BULK_DT_WR]); } /*------------------------------------------------------------------------* diff --git a/sys/dev/usb/serial/ugensa.c b/sys/dev/usb/serial/ugensa.c index 1a16ab5..eada5da 100644 --- a/sys/dev/usb/serial/ugensa.c +++ b/sys/dev/usb/serial/ugensa.c @@ -48,7 +48,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -72,7 +72,7 @@ enum { }; struct ugensa_sub_softc { - struct ucom_softc *sc_usb2_com_ptr; + struct ucom_softc *sc_ucom_ptr; struct usb_xfer *sc_xfer[UGENSA_N_TRANSFER]; }; @@ -122,10 +122,10 @@ static const struct usb_config }; static const struct ucom_callback ugensa_callback = { - .usb2_com_start_read = &ugensa_start_read, - .usb2_com_stop_read = &ugensa_stop_read, - .usb2_com_start_write = &ugensa_start_write, - .usb2_com_stop_write = &ugensa_stop_write, + .ucom_start_read = &ugensa_start_read, + .ucom_stop_read = &ugensa_stop_read, + .ucom_start_write = &ugensa_start_write, + .ucom_stop_write = &ugensa_stop_write, }; static device_method_t ugensa_methods[] = { @@ -170,7 +170,7 @@ ugensa_probe(device_t dev) if (uaa->info.bIfaceIndex != 0) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(ugensa_devs, sizeof(ugensa_devs), uaa)); + return (usbd_lookup_id_by_uaa(ugensa_devs, sizeof(ugensa_devs), uaa)); } static int @@ -184,13 +184,13 @@ ugensa_attach(device_t dev) uint8_t iface_index; int x, cnt; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ugensa", NULL, MTX_DEF); /* Figure out how many interfaces this device has got */ for (cnt = 0; cnt < UGENSA_IFACE_MAX; cnt++) { - if ((usb2_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 0) == NULL) || - (usb2_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 1) == NULL)) { + if ((usbd_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 0) == NULL) || + (usbd_get_endpoint(uaa->device, cnt, ugensa_xfer_config + 1) == NULL)) { /* we have reached the end */ break; } @@ -201,16 +201,16 @@ ugensa_attach(device_t dev) goto detach; } for (x = 0; x < cnt; x++) { - iface = usb2_get_iface(uaa->device, x); + iface = usbd_get_iface(uaa->device, x); if (iface->idesc->bInterfaceClass != UICLASS_VENDOR) /* Not a serial port, most likely a SD reader */ continue; ssc = sc->sc_sub + sc->sc_niface; - ssc->sc_usb2_com_ptr = sc->sc_ucom + sc->sc_niface; + ssc->sc_ucom_ptr = sc->sc_ucom + sc->sc_niface; iface_index = (UGENSA_IFACE_INDEX + x); - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &iface_index, ssc->sc_xfer, ugensa_xfer_config, UGENSA_N_TRANSFER, ssc, &sc->sc_mtx); @@ -221,20 +221,20 @@ ugensa_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]); - usb2_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]); + usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]); + usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); /* initialize port number */ - ssc->sc_usb2_com_ptr->sc_portno = sc->sc_niface; + ssc->sc_ucom_ptr->sc_portno = sc->sc_niface; sc->sc_niface++; if (x != uaa->info.bIfaceIndex) - usb2_set_parent_iface(uaa->device, x, + usbd_set_parent_iface(uaa->device, x, uaa->info.bIfaceIndex); } device_printf(dev, "Found %d interfaces.\n", sc->sc_niface); - error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface, sc, + error = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface, sc, &ugensa_callback, &sc->sc_mtx); if (error) { DPRINTF("attach failed\n"); @@ -253,10 +253,10 @@ ugensa_detach(device_t dev) struct ugensa_softc *sc = device_get_softc(dev); uint8_t x; - usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface); + ucom_detach(&sc->sc_super_ucom, sc->sc_ucom, sc->sc_niface); for (x = 0; x < sc->sc_niface; x++) { - usb2_transfer_unsetup(sc->sc_sub[x].sc_xfer, UGENSA_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_sub[x].sc_xfer, UGENSA_N_TRANSFER); } mtx_destroy(&sc->sc_mtx); @@ -273,10 +273,10 @@ ugensa_bulk_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(ssc->sc_usb2_com_ptr, xfer->frbuffers, 0, + if (ucom_get_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0, UGENSA_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -297,13 +297,13 @@ ugensa_bulk_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(ssc->sc_usb2_com_ptr, xfer->frbuffers, 0, + ucom_put_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -322,7 +322,7 @@ ugensa_start_read(struct ucom_softc *ucom) struct ugensa_softc *sc = ucom->sc_parent; struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno; - usb2_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_RD]); + usbd_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_RD]); } static void @@ -331,7 +331,7 @@ ugensa_stop_read(struct ucom_softc *ucom) struct ugensa_softc *sc = ucom->sc_parent; struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno; - usb2_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_RD]); + usbd_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_RD]); } static void @@ -340,7 +340,7 @@ ugensa_start_write(struct ucom_softc *ucom) struct ugensa_softc *sc = ucom->sc_parent; struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno; - usb2_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_WR]); + usbd_transfer_start(ssc->sc_xfer[UGENSA_BULK_DT_WR]); } static void @@ -349,5 +349,5 @@ ugensa_stop_write(struct ucom_softc *ucom) struct ugensa_softc *sc = ucom->sc_parent; struct ugensa_sub_softc *ssc = sc->sc_sub + ucom->sc_portno; - usb2_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_WR]); + usbd_transfer_stop(ssc->sc_xfer[UGENSA_BULK_DT_WR]); } diff --git a/sys/dev/usb/serial/uipaq.c b/sys/dev/usb/serial/uipaq.c index 3ac9942..ca66866 100644 --- a/sys/dev/usb/serial/uipaq.c +++ b/sys/dev/usb/serial/uipaq.c @@ -57,7 +57,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -131,13 +131,13 @@ static const struct usb_config uipaq_config_data[UIPAQ_N_TRANSFER] = { }; static const struct ucom_callback uipaq_callback = { - .usb2_com_cfg_set_dtr = &uipaq_cfg_set_dtr, - .usb2_com_cfg_set_rts = &uipaq_cfg_set_rts, - .usb2_com_cfg_set_break = &uipaq_cfg_set_break, - .usb2_com_start_read = &uipaq_start_read, - .usb2_com_stop_read = &uipaq_stop_read, - .usb2_com_start_write = &uipaq_start_write, - .usb2_com_stop_write = &uipaq_stop_write, + .ucom_cfg_set_dtr = &uipaq_cfg_set_dtr, + .ucom_cfg_set_rts = &uipaq_cfg_set_rts, + .ucom_cfg_set_break = &uipaq_cfg_set_break, + .ucom_start_read = &uipaq_start_read, + .ucom_stop_read = &uipaq_stop_read, + .ucom_start_write = &uipaq_start_write, + .ucom_stop_write = &uipaq_stop_write, }; /* @@ -1089,7 +1089,7 @@ uipaq_probe(device_t dev) if (uaa->info.bIfaceIndex != UIPAQ_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uipaq_devs, sizeof(uipaq_devs), uaa)); + return (usbd_lookup_id_by_uaa(uipaq_devs, sizeof(uipaq_devs), uaa)); } static int @@ -1104,7 +1104,7 @@ uipaq_attach(device_t dev) sc->sc_udev = uaa->device; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uipaq", NULL, MTX_DEF); /* @@ -1119,15 +1119,15 @@ uipaq_attach(device_t dev) USETW(req.wLength, 0); for (i = 0; i != 64; i++) { error = - usb2_do_request_flags(uaa->device, NULL, &req, + usbd_do_request_flags(uaa->device, NULL, &req, NULL, 0, NULL, 100); if (error == 0) break; - usb2_pause_mtx(NULL, hz / 10); + usb_pause_mtx(NULL, hz / 10); } iface_index = UIPAQ_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, uipaq_config_data, UIPAQ_N_TRANSFER, sc, &sc->sc_mtx); @@ -1136,11 +1136,11 @@ uipaq_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uipaq_callback, &sc->sc_mtx); if (error) { goto detach; @@ -1157,8 +1157,8 @@ uipaq_detach(device_t dev) { struct uipaq_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UIPAQ_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UIPAQ_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -1170,7 +1170,7 @@ uipaq_start_read(struct ucom_softc *ucom) struct uipaq_softc *sc = ucom->sc_parent; /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_RD]); } static void @@ -1179,7 +1179,7 @@ uipaq_stop_read(struct ucom_softc *ucom) struct uipaq_softc *sc = ucom->sc_parent; /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_RD]); } static void @@ -1187,7 +1187,7 @@ uipaq_start_write(struct ucom_softc *ucom) { struct uipaq_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UIPAQ_BULK_DT_WR]); } static void @@ -1195,7 +1195,7 @@ uipaq_stop_write(struct ucom_softc *ucom) { struct uipaq_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UIPAQ_BULK_DT_WR]); } static void @@ -1218,7 +1218,7 @@ uipaq_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -1242,7 +1242,7 @@ uipaq_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -1262,7 +1262,7 @@ uipaq_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -1276,10 +1276,10 @@ uipaq_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UIPAQ_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -1300,13 +1300,13 @@ uipaq_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/ulpt.c b/sys/dev/usb/serial/ulpt.c index 056b48a..b7b622d 100644 --- a/sys/dev/usb/serial/ulpt.c +++ b/sys/dev/usb/serial/ulpt.c @@ -177,10 +177,10 @@ ulpt_reset(struct ulpt_softc *sc) mtx_lock(&sc->sc_mtx); req.bmRequestType = UT_WRITE_CLASS_OTHER; - if (usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx, + if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, &req, NULL, 0, NULL, 2 * USB_MS_HZ)) { /* 1.0 */ req.bmRequestType = UT_WRITE_CLASS_INTERFACE; - if (usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx, + if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, &req, NULL, 0, NULL, 2 * USB_MS_HZ)) { /* 1.1 */ /* ignore error */ } @@ -207,10 +207,10 @@ ulpt_write_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: case USB_ST_SETUP: tr_setup: - if (usb2_fifo_get_data(f, xfer->frbuffers, + if (usb_fifo_get_data(f, xfer->frbuffers, 0, xfer->max_data_length, &actlen, 0)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -255,14 +255,14 @@ ulpt_read_callback(struct usb_xfer *xfer) sc->sc_zlps = 0; } - usb2_fifo_put_data(f, xfer->frbuffers, + usb_fifo_put_data(f, xfer->frbuffers, 0, xfer->actlen, 1); case USB_ST_SETUP: tr_setup: - if (usb2_fifo_put_bytes_max(f) != 0) { + if (usb_fifo_put_bytes_max(f) != 0) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -291,7 +291,7 @@ ulpt_status_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_copy_out(xfer->frbuffers + 1, 0, &cur_status, 1); + usbd_copy_out(xfer->frbuffers + 1, 0, &cur_status, 1); cur_status = (cur_status ^ LPS_INVERT) & LPS_MASK; new_status = cur_status & ~sc->sc_last_status; @@ -316,16 +316,16 @@ ulpt_status_callback(struct usb_xfer *xfer) req.wIndex[1] = 0; USETW(req.wLength, 1); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = 1; xfer->nframes = 2; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ - DPRINTF("error=%s\n", usb2_errstr(xfer->error)); + DPRINTF("error=%s\n", usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* wait for next watchdog timeout */ } @@ -367,7 +367,7 @@ ulpt_start_read(struct usb_fifo *fifo) { struct ulpt_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[ULPT_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_RD]); } static void @@ -375,7 +375,7 @@ ulpt_stop_read(struct usb_fifo *fifo) { struct ulpt_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_RD]); } static void @@ -383,7 +383,7 @@ ulpt_start_write(struct usb_fifo *fifo) { struct ulpt_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[ULPT_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_WR]); } static void @@ -391,7 +391,7 @@ ulpt_stop_write(struct usb_fifo *fifo) { struct ulpt_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_WR]); } static int @@ -418,9 +418,9 @@ unlpt_open(struct usb_fifo *fifo, int fflags) if (fflags & FREAD) { /* clear stall first */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_xfer[ULPT_BULK_DT_RD]->max_data_length, ULPT_IFQ_MAXLEN)) { return (ENOMEM); @@ -431,9 +431,9 @@ unlpt_open(struct usb_fifo *fifo, int fflags) if (fflags & FWRITE) { /* clear stall first */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]); mtx_unlock(&sc->sc_mtx); - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_xfer[ULPT_BULK_DT_WR]->max_data_length, ULPT_IFQ_MAXLEN)) { return (ENOMEM); @@ -453,7 +453,7 @@ ulpt_close(struct usb_fifo *fifo, int fflags) sc->sc_fflags &= ~(fflags & (FREAD | FWRITE)); if (fflags & (FREAD | FWRITE)) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } } @@ -500,15 +500,15 @@ ulpt_attach(device_t dev) sc->sc_dev = dev; sc->sc_udev = uaa->device; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ulpt lock", NULL, MTX_DEF | MTX_RECURSE); - usb2_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0); + usb_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0); /* search through all the descriptors looking for bidir mode */ - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); alt_index = 0 - 1; while (1) { if (id == NULL) { @@ -527,8 +527,8 @@ ulpt_attach(device_t dev) } } } - id = (void *)usb2_desc_foreach( - usb2_get_config_descriptor(uaa->device), (void *)id); + id = (void *)usb_desc_foreach( + usbd_get_config_descriptor(uaa->device), (void *)id); } goto detach; @@ -539,22 +539,22 @@ found: if (alt_index) { - error = usb2_set_alt_interface_index + error = usbd_set_alt_interface_index (uaa->device, iface_index, alt_index); if (error) { DPRINTF("could not set alternate " - "config, error=%s\n", usb2_errstr(error)); + "config, error=%s\n", usbd_errstr(error)); goto detach; } } sc->sc_iface_no = id->bInterfaceNumber; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, ulpt_config, ULPT_N_TRANSFER, sc, &sc->sc_mtx); if (error) { - DPRINTF("error=%s\n", usb2_errstr(error)); + DPRINTF("error=%s\n", usbd_errstr(error)); goto detach; } device_printf(sc->sc_dev, "using bi-directional mode\n"); @@ -566,7 +566,7 @@ found: * UHCI and less often with OHCI. *sigh* */ { - struct usb_config_descriptor *cd = usb2_get_config_descriptor(dev); + struct usb_config_descriptor *cd = usbd_get_config_descriptor(dev); struct usb_device_request req; int len, alen; @@ -575,7 +575,7 @@ found: USETW(req.wValue, cd->bConfigurationValue); USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting); USETW(req.wLength, sizeof devinfo - 1); - error = usb2_do_request_flags(dev, &req, devinfo, USB_SHORT_XFER_OK, + error = usbd_do_request_flags(dev, &req, devinfo, USB_SHORT_XFER_OK, &alen, USB_DEFAULT_TIMEOUT); if (error) { device_printf(sc->sc_dev, "cannot get device id\n"); @@ -595,14 +595,14 @@ found: } #endif - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &ulpt_fifo_methods, &sc->sc_fifo, unit, 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); if (error) { goto detach; } - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &unlpt_fifo_methods, &sc->sc_fifo_noreset, unit, 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); @@ -628,15 +628,15 @@ ulpt_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_fifo_detach(&sc->sc_fifo); - usb2_fifo_detach(&sc->sc_fifo_noreset); + usb_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo_noreset); mtx_lock(&sc->sc_mtx); - usb2_callout_stop(&sc->sc_watchdog); + usb_callout_stop(&sc->sc_watchdog); mtx_unlock(&sc->sc_mtx); - usb2_transfer_unsetup(sc->sc_xfer, ULPT_N_TRANSFER); - usb2_callout_drain(&sc->sc_watchdog); + usbd_transfer_unsetup(sc->sc_xfer, ULPT_N_TRANSFER); + usb_callout_drain(&sc->sc_watchdog); mtx_destroy(&sc->sc_mtx); return (0); @@ -696,9 +696,9 @@ ulpt_watchdog(void *arg) mtx_assert(&sc->sc_mtx, MA_OWNED); - usb2_transfer_start(sc->sc_xfer[ULPT_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[ULPT_INTR_DT_RD]); - usb2_callout_reset(&sc->sc_watchdog, + usb_callout_reset(&sc->sc_watchdog, hz, &ulpt_watchdog, sc); } diff --git a/sys/dev/usb/serial/umct.c b/sys/dev/usb/serial/umct.c index eff8ec2..879b090 100644 --- a/sys/dev/usb/serial/umct.c +++ b/sys/dev/usb/serial/umct.c @@ -50,7 +50,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -164,16 +164,16 @@ static const struct usb_config umct_config[UMCT_N_TRANSFER] = { }; static const struct ucom_callback umct_callback = { - .usb2_com_cfg_get_status = &umct_cfg_get_status, - .usb2_com_cfg_set_dtr = &umct_cfg_set_dtr, - .usb2_com_cfg_set_rts = &umct_cfg_set_rts, - .usb2_com_cfg_set_break = &umct_cfg_set_break, - .usb2_com_cfg_param = &umct_cfg_param, - .usb2_com_pre_param = &umct_pre_param, - .usb2_com_start_read = &umct_start_read, - .usb2_com_stop_read = &umct_stop_read, - .usb2_com_start_write = &umct_start_write, - .usb2_com_stop_write = &umct_stop_write, + .ucom_cfg_get_status = &umct_cfg_get_status, + .ucom_cfg_set_dtr = &umct_cfg_set_dtr, + .ucom_cfg_set_rts = &umct_cfg_set_rts, + .ucom_cfg_set_break = &umct_cfg_set_break, + .ucom_cfg_param = &umct_cfg_param, + .ucom_pre_param = &umct_pre_param, + .ucom_start_read = &umct_start_read, + .ucom_stop_read = &umct_stop_read, + .ucom_start_write = &umct_start_write, + .ucom_stop_write = &umct_stop_write, }; static const struct usb_device_id umct_devs[] = { @@ -217,7 +217,7 @@ umct_probe(device_t dev) if (uaa->info.bIfaceIndex != UMCT_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(umct_devs, sizeof(umct_devs), uaa)); + return (usbd_lookup_id_by_uaa(umct_devs, sizeof(umct_devs), uaa)); } static int @@ -232,7 +232,7 @@ umct_attach(device_t dev) sc->sc_udev = uaa->device; sc->sc_unit = device_get_unit(dev); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "umct", NULL, MTX_DEF); snprintf(sc->sc_name, sizeof(sc->sc_name), @@ -241,7 +241,7 @@ umct_attach(device_t dev) sc->sc_iface_no = uaa->info.bIfaceNum; iface_index = UMCT_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, umct_config, UMCT_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -274,7 +274,7 @@ umct_attach(device_t dev) sc->sc_obufsize = 16; } } - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &umct_callback, &sc->sc_mtx); if (error) { goto detach; @@ -291,8 +291,8 @@ umct_detach(device_t dev) { struct umct_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UMCT_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UMCT_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -316,11 +316,11 @@ umct_cfg_do_request(struct umct_softc *sc, uint8_t request, USETW(req.wLength, len); USETDW(temp, value); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, temp, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } return; } @@ -337,17 +337,17 @@ umct_intr_callback(struct usb_xfer *xfer) DPRINTF("too short message\n"); goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); + usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); sc->sc_msr = buf[0]; sc->sc_lsr = buf[1]; - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -491,10 +491,10 @@ umct_start_read(struct ucom_softc *ucom) struct umct_softc *sc = ucom->sc_parent; /* start interrupt endpoint */ - usb2_transfer_start(sc->sc_xfer[UMCT_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UMCT_INTR_DT_RD]); /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UMCT_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UMCT_BULK_DT_RD]); } static void @@ -503,10 +503,10 @@ umct_stop_read(struct ucom_softc *ucom) struct umct_softc *sc = ucom->sc_parent; /* stop interrupt endpoint */ - usb2_transfer_stop(sc->sc_xfer[UMCT_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UMCT_INTR_DT_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_RD]); } static void @@ -514,7 +514,7 @@ umct_start_write(struct ucom_softc *ucom) { struct umct_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UMCT_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UMCT_BULK_DT_WR]); } static void @@ -522,7 +522,7 @@ umct_stop_write(struct ucom_softc *ucom) { struct umct_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UMCT_BULK_DT_WR]); } static void @@ -535,11 +535,11 @@ umct_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, sc->sc_obufsize, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -560,13 +560,13 @@ umct_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/umodem.c b/sys/dev/usb/serial/umodem.c index 55a9d29..13cdeea 100644 --- a/sys/dev/usb/serial/umodem.c +++ b/sys/dev/usb/serial/umodem.c @@ -216,17 +216,17 @@ static const struct usb_config umodem_config[UMODEM_N_TRANSFER] = { }; static const struct ucom_callback umodem_callback = { - .usb2_com_cfg_get_status = &umodem_cfg_get_status, - .usb2_com_cfg_set_dtr = &umodem_cfg_set_dtr, - .usb2_com_cfg_set_rts = &umodem_cfg_set_rts, - .usb2_com_cfg_set_break = &umodem_cfg_set_break, - .usb2_com_cfg_param = &umodem_cfg_param, - .usb2_com_pre_param = &umodem_pre_param, - .usb2_com_ioctl = &umodem_ioctl, - .usb2_com_start_read = &umodem_start_read, - .usb2_com_stop_read = &umodem_stop_read, - .usb2_com_start_write = &umodem_start_write, - .usb2_com_stop_write = &umodem_stop_write, + .ucom_cfg_get_status = &umodem_cfg_get_status, + .ucom_cfg_set_dtr = &umodem_cfg_set_dtr, + .ucom_cfg_set_rts = &umodem_cfg_set_rts, + .ucom_cfg_set_break = &umodem_cfg_set_break, + .ucom_cfg_param = &umodem_cfg_param, + .ucom_pre_param = &umodem_pre_param, + .ucom_ioctl = &umodem_ioctl, + .ucom_start_read = &umodem_start_read, + .ucom_stop_read = &umodem_stop_read, + .ucom_start_write = &umodem_start_write, + .ucom_stop_write = &umodem_stop_write, }; static device_method_t umodem_methods[] = { @@ -260,7 +260,7 @@ umodem_probe(device_t dev) if (uaa->usb_mode != USB_MODE_HOST) { return (ENXIO); } - error = usb2_lookup_id_by_uaa(umodem_devs, sizeof(umodem_devs), uaa); + error = usbd_lookup_id_by_uaa(umodem_devs, sizeof(umodem_devs), uaa); return (error); } @@ -274,7 +274,7 @@ umodem_attach(device_t dev) uint8_t i; int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "umodem", NULL, MTX_DEF); sc->sc_ctrl_iface_no = uaa->info.bIfaceNum; @@ -315,15 +315,15 @@ umodem_attach(device_t dev) struct usb_interface *iface; struct usb_interface_descriptor *id; - iface = usb2_get_iface(uaa->device, i); + iface = usbd_get_iface(uaa->device, i); if (iface) { - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id && (id->bInterfaceNumber == sc->sc_data_iface_no)) { sc->sc_iface_index[0] = i; - usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); + usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); break; } } else { @@ -343,7 +343,7 @@ umodem_attach(device_t dev) } sc->sc_cm_over_data = 1; } - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, sc->sc_iface_index, sc->sc_xfer, umodem_config, UMODEM_N_TRANSFER, sc, &sc->sc_mtx); @@ -353,11 +353,11 @@ umodem_attach(device_t dev) /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &umodem_callback, &sc->sc_mtx); if (error) { goto detach; @@ -375,10 +375,10 @@ umodem_start_read(struct ucom_softc *ucom) struct umodem_softc *sc = ucom->sc_parent; /* start interrupt endpoint, if any */ - usb2_transfer_start(sc->sc_xfer[UMODEM_INTR_RD]); + usbd_transfer_start(sc->sc_xfer[UMODEM_INTR_RD]); /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UMODEM_BULK_RD]); + usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_RD]); } static void @@ -387,10 +387,10 @@ umodem_stop_read(struct ucom_softc *ucom) struct umodem_softc *sc = ucom->sc_parent; /* stop interrupt endpoint, if any */ - usb2_transfer_stop(sc->sc_xfer[UMODEM_INTR_RD]); + usbd_transfer_stop(sc->sc_xfer[UMODEM_INTR_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UMODEM_BULK_RD]); + usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_RD]); } static void @@ -398,7 +398,7 @@ umodem_start_write(struct ucom_softc *ucom) { struct umodem_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UMODEM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_WR]); } static void @@ -406,7 +406,7 @@ umodem_stop_write(struct ucom_softc *ucom) { struct umodem_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UMODEM_BULK_WR]); + usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_WR]); } static void @@ -493,7 +493,7 @@ umodem_cfg_param(struct ucom_softc *ucom, struct termios *t) req.wIndex[1] = 0; USETW(req.wLength, sizeof(ls)); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, &ls, 0, 1000); } @@ -546,7 +546,7 @@ umodem_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -570,7 +570,7 @@ umodem_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -594,7 +594,7 @@ umodem_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } } @@ -618,7 +618,7 @@ umodem_intr_callback(struct usb_xfer *xfer) DPRINTF("truncating message\n"); xfer->actlen = sizeof(pkt); } - usb2_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen); xfer->actlen -= 8; @@ -660,7 +660,7 @@ umodem_intr_callback(struct usb_xfer *xfer) if (pkt.data[0] & UCDC_N_SERIAL_DCD) { sc->sc_msr |= SER_DCD; } - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); break; default: @@ -672,7 +672,7 @@ umodem_intr_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -696,11 +696,11 @@ umodem_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UMODEM_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -724,13 +724,13 @@ umodem_read_callback(struct usb_xfer *xfer) DPRINTF("actlen=%d\n", xfer->actlen); - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -768,7 +768,7 @@ umodem_set_comm_feature(struct usb_device *udev, uint8_t iface_no, USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH); USETW(ast.wState, state); - return (usb2_do_request(udev, NULL, &req, &ast)); + return (usbd_do_request(udev, NULL, &req, &ast)); } static int @@ -778,8 +778,8 @@ umodem_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UMODEM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UMODEM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); diff --git a/sys/dev/usb/serial/umoscom.c b/sys/dev/usb/serial/umoscom.c index 22a497d..7fd52c3 100644 --- a/sys/dev/usb/serial/umoscom.c +++ b/sys/dev/usb/serial/umoscom.c @@ -230,20 +230,20 @@ static const struct usb_config umoscom_config_data[UMOSCOM_N_TRANSFER] = { static const struct ucom_callback umoscom_callback = { /* configuration callbacks */ - .usb2_com_cfg_get_status = &umoscom_cfg_get_status, - .usb2_com_cfg_set_dtr = &umoscom_cfg_set_dtr, - .usb2_com_cfg_set_rts = &umoscom_cfg_set_rts, - .usb2_com_cfg_set_break = &umoscom_cfg_set_break, - .usb2_com_cfg_param = &umoscom_cfg_param, - .usb2_com_cfg_open = &umoscom_cfg_open, - .usb2_com_cfg_close = &umoscom_cfg_close, + .ucom_cfg_get_status = &umoscom_cfg_get_status, + .ucom_cfg_set_dtr = &umoscom_cfg_set_dtr, + .ucom_cfg_set_rts = &umoscom_cfg_set_rts, + .ucom_cfg_set_break = &umoscom_cfg_set_break, + .ucom_cfg_param = &umoscom_cfg_param, + .ucom_cfg_open = &umoscom_cfg_open, + .ucom_cfg_close = &umoscom_cfg_close, /* other callbacks */ - .usb2_com_pre_param = &umoscom_pre_param, - .usb2_com_start_read = &umoscom_start_read, - .usb2_com_stop_read = &umoscom_stop_read, - .usb2_com_start_write = &umoscom_start_write, - .usb2_com_stop_write = &umoscom_stop_write, + .ucom_pre_param = &umoscom_pre_param, + .ucom_start_read = &umoscom_start_read, + .ucom_stop_read = &umoscom_stop_read, + .ucom_start_write = &umoscom_start_write, + .ucom_stop_write = &umoscom_stop_write, }; static device_method_t umoscom_methods[] = { @@ -283,7 +283,7 @@ umoscom_probe(device_t dev) if (uaa->info.bIfaceIndex != UMOSCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(umoscom_devs, sizeof(umoscom_devs), uaa)); + return (usbd_lookup_id_by_uaa(umoscom_devs, sizeof(umoscom_devs), uaa)); } static int @@ -304,7 +304,7 @@ umoscom_attach(device_t dev) mtx_init(&sc->sc_mtx, "umoscom", NULL, MTX_DEF); iface_index = UMOSCOM_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, umoscom_config_data, UMOSCOM_N_TRANSFER, sc, &sc->sc_mtx); @@ -313,11 +313,11 @@ umoscom_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &umoscom_callback, &sc->sc_mtx); if (error) { goto detach; @@ -325,7 +325,7 @@ umoscom_attach(device_t dev) return (0); detach: - device_printf(dev, "attach error: %s\n", usb2_errstr(error)); + device_printf(dev, "attach error: %s\n", usbd_errstr(error)); umoscom_detach(dev); return (ENXIO); } @@ -335,8 +335,8 @@ umoscom_detach(device_t dev) { struct umoscom_softc *sc = device_get_softc(dev); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UMOSCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UMOSCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -517,7 +517,7 @@ umoscom_cfg_write(struct umoscom_softc *sc, uint16_t reg, uint16_t val) USETW(req.wIndex, reg); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -533,7 +533,7 @@ umoscom_cfg_read(struct umoscom_softc *sc, uint16_t reg) USETW(req.wIndex, reg); USETW(req.wLength, 1); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, &val, 0, 1000); DPRINTF("reg=0x%04x, val=0x%02x\n", reg, val); @@ -548,10 +548,10 @@ umoscom_start_read(struct ucom_softc *ucom) #if 0 /* start interrupt endpoint */ - usb2_transfer_start(sc->sc_xfer[UMOSCOM_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UMOSCOM_INTR_DT_RD]); #endif /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); } static void @@ -560,10 +560,10 @@ umoscom_stop_read(struct ucom_softc *ucom) struct umoscom_softc *sc = ucom->sc_parent; /* stop interrupt transfer */ - usb2_transfer_stop(sc->sc_xfer[UMOSCOM_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UMOSCOM_INTR_DT_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_RD]); } static void @@ -571,7 +571,7 @@ umoscom_start_write(struct ucom_softc *ucom) { struct umoscom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); } static void @@ -579,7 +579,7 @@ umoscom_stop_write(struct ucom_softc *ucom) { struct umoscom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UMOSCOM_BULK_DT_WR]); } static void @@ -594,11 +594,11 @@ umoscom_write_callback(struct usb_xfer *xfer) tr_setup: DPRINTF("\n"); - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UMOSCOM_BUFSIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -621,14 +621,14 @@ umoscom_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: DPRINTF("got %d bytes\n", xfer->actlen); - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: DPRINTF("\n"); xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -653,12 +653,12 @@ umoscom_intr_callback(struct usb_xfer *xfer) DPRINTF("too short message\n"); goto tr_setup; } - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/uplcom.c b/sys/dev/usb/serial/uplcom.c index 23d18c0..0604b42 100644 --- a/sys/dev/usb/serial/uplcom.c +++ b/sys/dev/usb/serial/uplcom.c @@ -215,16 +215,16 @@ static const struct usb_config uplcom_config_data[UPLCOM_N_TRANSFER] = { }; static struct ucom_callback uplcom_callback = { - .usb2_com_cfg_get_status = &uplcom_cfg_get_status, - .usb2_com_cfg_set_dtr = &uplcom_cfg_set_dtr, - .usb2_com_cfg_set_rts = &uplcom_cfg_set_rts, - .usb2_com_cfg_set_break = &uplcom_cfg_set_break, - .usb2_com_cfg_param = &uplcom_cfg_param, - .usb2_com_pre_param = &uplcom_pre_param, - .usb2_com_start_read = &uplcom_start_read, - .usb2_com_stop_read = &uplcom_stop_read, - .usb2_com_start_write = &uplcom_start_write, - .usb2_com_stop_write = &uplcom_stop_write, + .ucom_cfg_get_status = &uplcom_cfg_get_status, + .ucom_cfg_set_dtr = &uplcom_cfg_set_dtr, + .ucom_cfg_set_rts = &uplcom_cfg_set_rts, + .ucom_cfg_set_break = &uplcom_cfg_set_break, + .ucom_cfg_param = &uplcom_cfg_param, + .ucom_pre_param = &uplcom_pre_param, + .ucom_start_read = &uplcom_start_read, + .ucom_stop_read = &uplcom_stop_read, + .ucom_start_write = &uplcom_start_write, + .ucom_stop_write = &uplcom_stop_write, }; #define USB_UPL(v,p,rl,rh,t) \ @@ -315,7 +315,7 @@ uplcom_probe(device_t dev) if (uaa->info.bIfaceIndex != UPLCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uplcom_devs, sizeof(uplcom_devs), uaa)); + return (usbd_lookup_id_by_uaa(uplcom_devs, sizeof(uplcom_devs), uaa)); } static int @@ -329,7 +329,7 @@ uplcom_attach(device_t dev) DPRINTFN(11, "\n"); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uplcom", NULL, MTX_DEF); DPRINTF("sc = %p\n", sc); @@ -357,43 +357,43 @@ uplcom_attach(device_t dev) sc->sc_ctrl_iface_no = uaa->info.bIfaceNum; sc->sc_iface_index[1] = UPLCOM_IFACE_INDEX; - iface = usb2_get_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX); + iface = usbd_get_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX); if (iface) { - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id == NULL) { device_printf(dev, "no interface descriptor (2)!\n"); goto detach; } sc->sc_data_iface_no = id->bInterfaceNumber; sc->sc_iface_index[0] = UPLCOM_SECOND_IFACE_INDEX; - usb2_set_parent_iface(uaa->device, + usbd_set_parent_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX, uaa->info.bIfaceIndex); } else { sc->sc_data_iface_no = sc->sc_ctrl_iface_no; sc->sc_iface_index[0] = UPLCOM_IFACE_INDEX; } - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, sc->sc_iface_index, sc->sc_xfer, uplcom_config_data, UPLCOM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { DPRINTF("one or more missing USB endpoints, " - "error=%s\n", usb2_errstr(error)); + "error=%s\n", usbd_errstr(error)); goto detach; } error = uplcom_reset(sc, uaa->device); if (error) { device_printf(dev, "reset failed, error=%s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uplcom_callback, &sc->sc_mtx); if (error) { goto detach; @@ -422,8 +422,8 @@ uplcom_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UPLCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UPLCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -441,7 +441,7 @@ uplcom_reset(struct uplcom_softc *sc, struct usb_device *udev) req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, NULL, &req, NULL)); + return (usbd_do_request(udev, NULL, &req, NULL)); } struct pl2303x_init { @@ -485,9 +485,9 @@ uplcom_pl2303x_init(struct usb_device *udev) USETW(req.wIndex, pl2303x[i].index); USETW(req.wLength, pl2303x[i].length); - err = usb2_do_request(udev, NULL, &req, buf); + err = usbd_do_request(udev, NULL, &req, buf); if (err) { - DPRINTF("error=%s\n", usb2_errstr(err)); + DPRINTF("error=%s\n", usbd_errstr(err)); return (EIO); } } @@ -514,7 +514,7 @@ uplcom_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -538,7 +538,7 @@ uplcom_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -560,7 +560,7 @@ uplcom_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } @@ -655,7 +655,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t) req.wIndex[1] = 0; USETW(req.wLength, UCDC_LINE_STATE_LENGTH); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, &ls, 0, 1000); if (t->c_cflag & CRTSCTS) { @@ -671,7 +671,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wIndex, UPLCOM_SET_CRTSCTS); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } else { req.bmRequestType = UT_WRITE_VENDOR_DEVICE; @@ -679,7 +679,7 @@ uplcom_cfg_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, 0); - usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); } } @@ -690,10 +690,10 @@ uplcom_start_read(struct ucom_softc *ucom) struct uplcom_softc *sc = ucom->sc_parent; /* start interrupt endpoint */ - usb2_transfer_start(sc->sc_xfer[UPLCOM_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UPLCOM_INTR_DT_RD]); /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_RD]); } static void @@ -702,10 +702,10 @@ uplcom_stop_read(struct ucom_softc *ucom) struct uplcom_softc *sc = ucom->sc_parent; /* stop interrupt endpoint */ - usb2_transfer_stop(sc->sc_xfer[UPLCOM_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UPLCOM_INTR_DT_RD]); /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_RD]); } static void @@ -713,7 +713,7 @@ uplcom_start_write(struct ucom_softc *ucom) { struct uplcom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_WR]); } static void @@ -721,7 +721,7 @@ uplcom_stop_write(struct ucom_softc *ucom) { struct uplcom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_WR]); } static void @@ -748,7 +748,7 @@ uplcom_intr_callback(struct usb_xfer *xfer) if (xfer->actlen >= 9) { - usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); + usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); DPRINTF("status = 0x%02x\n", buf[8]); @@ -764,12 +764,12 @@ uplcom_intr_callback(struct usb_xfer *xfer) if (buf[8] & RSAQ_STATUS_DCD) { sc->sc_msr |= SER_DCD; } - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); } case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -792,13 +792,13 @@ uplcom_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UPLCOM_BULK_BUF_SIZE, &actlen)) { DPRINTF("actlen = %d\n", actlen); xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -819,12 +819,12 @@ uplcom_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/usb_serial.c b/sys/dev/usb/serial/usb_serial.c index 6bb0f6d..d6c4c1a 100644 --- a/sys/dev/usb/serial/usb_serial.c +++ b/sys/dev/usb/serial/usb_serial.c @@ -73,7 +73,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_com_debug +#define USB_DEBUG_VAR ucom_debug #include #include @@ -85,49 +85,49 @@ __FBSDID("$FreeBSD$"); #include #if USB_DEBUG -static int usb2_com_debug = 0; +static int ucom_debug = 0; SYSCTL_NODE(_hw_usb, OID_AUTO, ucom, CTLFLAG_RW, 0, "USB ucom"); SYSCTL_INT(_hw_usb_ucom, OID_AUTO, debug, CTLFLAG_RW, - &usb2_com_debug, 0, "ucom debug level"); + &ucom_debug, 0, "ucom debug level"); #endif -static usb_proc_callback_t usb2_com_cfg_start_transfers; -static usb_proc_callback_t usb2_com_cfg_open; -static usb_proc_callback_t usb2_com_cfg_close; -static usb_proc_callback_t usb2_com_cfg_line_state; -static usb_proc_callback_t usb2_com_cfg_status_change; -static usb_proc_callback_t usb2_com_cfg_param; - -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 *, +static usb_proc_callback_t ucom_cfg_start_transfers; +static usb_proc_callback_t ucom_cfg_open; +static usb_proc_callback_t ucom_cfg_close; +static usb_proc_callback_t ucom_cfg_line_state; +static usb_proc_callback_t ucom_cfg_status_change; +static usb_proc_callback_t ucom_cfg_param; + +static uint8_t ucom_units_alloc(uint32_t, uint32_t *); +static void ucom_units_free(uint32_t, uint32_t); +static int ucom_attach_tty(struct ucom_softc *, uint32_t); +static void ucom_detach_tty(struct ucom_softc *); +static void ucom_queue_command(struct ucom_softc *, usb_proc_callback_t *, struct termios *pt, 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_dtr(struct ucom_softc *, uint8_t); -static void usb2_com_rts(struct ucom_softc *, uint8_t); - -static tsw_open_t usb2_com_open; -static tsw_close_t usb2_com_close; -static tsw_ioctl_t usb2_com_ioctl; -static tsw_modem_t usb2_com_modem; -static tsw_param_t usb2_com_param; -static tsw_outwakeup_t usb2_com_outwakeup; -static tsw_free_t usb2_com_free; - -static struct ttydevsw usb2_com_class = { +static void ucom_shutdown(struct ucom_softc *); +static void ucom_break(struct ucom_softc *, uint8_t); +static void ucom_dtr(struct ucom_softc *, uint8_t); +static void ucom_rts(struct ucom_softc *, uint8_t); + +static tsw_open_t ucom_open; +static tsw_close_t ucom_close; +static tsw_ioctl_t ucom_ioctl; +static tsw_modem_t ucom_modem; +static tsw_param_t ucom_param; +static tsw_outwakeup_t ucom_outwakeup; +static tsw_free_t ucom_free; + +static struct ttydevsw ucom_class = { .tsw_flags = TF_INITLOCK | TF_CALLOUT, - .tsw_open = usb2_com_open, - .tsw_close = usb2_com_close, - .tsw_outwakeup = usb2_com_outwakeup, - .tsw_ioctl = usb2_com_ioctl, - .tsw_param = usb2_com_param, - .tsw_modem = usb2_com_modem, - .tsw_free = usb2_com_free, + .tsw_open = ucom_open, + .tsw_close = ucom_close, + .tsw_outwakeup = ucom_outwakeup, + .tsw_ioctl = ucom_ioctl, + .tsw_param = ucom_param, + .tsw_modem = ucom_modem, + .tsw_free = ucom_free, }; MODULE_DEPEND(ucom, usb, 1, 1, 1); @@ -136,10 +136,10 @@ MODULE_VERSION(ucom, 1); #define UCOM_UNIT_MAX 0x1000 /* exclusive */ #define UCOM_SUB_UNIT_MAX 0x100 /* exclusive */ -static uint8_t usb2_com_bitmap[(UCOM_UNIT_MAX + 7) / 8]; +static uint8_t ucom_bitmap[(UCOM_UNIT_MAX + 7) / 8]; static uint8_t -usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit) +ucom_units_alloc(uint32_t sub_units, uint32_t *p_root_unit) { uint32_t n; uint32_t o; @@ -157,7 +157,7 @@ usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit) x = n + o; - if (usb2_com_bitmap[x / 8] & (1 << (x % 8))) { + if (ucom_bitmap[x / 8] & (1 << (x % 8))) { goto skip; } } @@ -168,7 +168,7 @@ usb2_com_units_alloc(uint32_t sub_units, uint32_t *p_root_unit) x = n + o; - usb2_com_bitmap[x / 8] |= (1 << (x % 8)); + ucom_bitmap[x / 8] |= (1 << (x % 8)); } error = 0; @@ -190,7 +190,7 @@ skip: ; } static void -usb2_com_units_free(uint32_t root_unit, uint32_t sub_units) +ucom_units_free(uint32_t root_unit, uint32_t sub_units) { uint32_t x; @@ -198,7 +198,7 @@ usb2_com_units_free(uint32_t root_unit, uint32_t sub_units) while (sub_units--) { x = root_unit + sub_units; - usb2_com_bitmap[x / 8] &= ~(1 << (x % 8)); + ucom_bitmap[x / 8] &= ~(1 << (x % 8)); } mtx_unlock(&Giant); @@ -215,7 +215,7 @@ usb2_com_units_free(uint32_t root_unit, uint32_t sub_units) * before calling into the ucom-layer! */ int -usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, +ucom_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, uint32_t sub_units, void *parent, const struct ucom_callback *callback, struct mtx *mtx) { @@ -231,13 +231,13 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, } /* XXX unit management does not really belong here */ - if (usb2_com_units_alloc(sub_units, &root_unit)) { + if (ucom_units_alloc(sub_units, &root_unit)) { return (ENOMEM); } - error = usb2_proc_create(&ssc->sc_tq, mtx, "ucom", USB_PRI_MED); + error = usb_proc_create(&ssc->sc_tq, mtx, "ucom", USB_PRI_MED); if (error) { - usb2_com_units_free(root_unit, sub_units); + ucom_units_free(root_unit, sub_units); return (error); } @@ -249,10 +249,10 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, sc->sc_parent = parent; sc->sc_callback = callback; - error = usb2_com_attach_tty(sc, sub_units); + error = ucom_attach_tty(sc, sub_units); if (error) { - usb2_com_detach(ssc, sc - n, n); - usb2_com_units_free(root_unit + n, sub_units - n); + ucom_detach(ssc, sc - n, n); + ucom_units_free(root_unit + n, sub_units - n); return (error); } sc->sc_flag |= UCOM_FLAG_ATTACHED; @@ -265,35 +265,35 @@ usb2_com_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, * the structure pointed to by "ssc" and "sc" is zero. */ void -usb2_com_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc, +ucom_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc, uint32_t sub_units) { uint32_t n; - usb2_proc_drain(&ssc->sc_tq); + usb_proc_drain(&ssc->sc_tq); for (n = 0; n != sub_units; n++, sc++) { if (sc->sc_flag & UCOM_FLAG_ATTACHED) { - usb2_com_detach_tty(sc); + ucom_detach_tty(sc); - usb2_com_units_free(sc->sc_unit, 1); + ucom_units_free(sc->sc_unit, 1); /* avoid duplicate detach: */ sc->sc_flag &= ~UCOM_FLAG_ATTACHED; } } - usb2_proc_free(&ssc->sc_tq); + usb_proc_free(&ssc->sc_tq); } static int -usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units) +ucom_attach_tty(struct ucom_softc *sc, uint32_t sub_units) { struct tty *tp; int error = 0; char buf[32]; /* temporary TTY device name buffer */ - tp = tty_alloc_mutex(&usb2_com_class, sc, sc->sc_mtx); + tp = tty_alloc_mutex(&ucom_class, sc, sc->sc_mtx); if (tp == NULL) { error = ENOMEM; goto done; @@ -303,8 +303,8 @@ usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units) buf[0] = 0; /* set some default value */ /* Check if the client has a custom TTY name */ - if (sc->sc_callback->usb2_com_tty_name) { - sc->sc_callback->usb2_com_tty_name(sc, buf, + if (sc->sc_callback->ucom_tty_name) { + sc->sc_callback->ucom_tty_name(sc, buf, sizeof(buf), sc->sc_local_unit); } if (buf[0] == 0) { @@ -328,14 +328,14 @@ usb2_com_attach_tty(struct ucom_softc *sc, uint32_t sub_units) sc->sc_tty = tp; DPRINTF("ttycreate: %s\n", buf); - cv_init(&sc->sc_cv, "usb2_com"); + cv_init(&sc->sc_cv, "ucom"); done: return (error); } static void -usb2_com_detach_tty(struct ucom_softc *sc) +ucom_detach_tty(struct ucom_softc *sc) { struct tty *tp = sc->sc_tty; @@ -351,7 +351,7 @@ usb2_com_detach_tty(struct ucom_softc *sc) if (tp) { tty_lock(tp); - usb2_com_close(tp); /* close, if any */ + ucom_close(tp); /* close, if any */ tty_rel_gone(tp); @@ -362,11 +362,11 @@ usb2_com_detach_tty(struct ucom_softc *sc) /* * make sure that read and write transfers are stopped */ - if (sc->sc_callback->usb2_com_stop_read) { - (sc->sc_callback->usb2_com_stop_read) (sc); + if (sc->sc_callback->ucom_stop_read) { + (sc->sc_callback->ucom_stop_read) (sc); } - if (sc->sc_callback->usb2_com_stop_write) { - (sc->sc_callback->usb2_com_stop_write) (sc); + if (sc->sc_callback->ucom_stop_write) { + (sc->sc_callback->ucom_stop_write) (sc); } mtx_unlock(sc->sc_mtx); } @@ -374,7 +374,7 @@ usb2_com_detach_tty(struct ucom_softc *sc) } static void -usb2_com_queue_command(struct ucom_softc *sc, +ucom_queue_command(struct ucom_softc *sc, usb_proc_callback_t *fn, struct termios *pt, struct usb_proc_msg *t0, struct usb_proc_msg *t1) { @@ -383,7 +383,7 @@ usb2_com_queue_command(struct ucom_softc *sc, mtx_assert(sc->sc_mtx, MA_OWNED); - if (usb2_proc_is_gone(&ssc->sc_tq)) { + if (usb_proc_is_gone(&ssc->sc_tq)) { DPRINTF("proc is gone\n"); return; /* nothing to do */ } @@ -393,7 +393,7 @@ usb2_com_queue_command(struct ucom_softc *sc, * structure after that the message got queued. */ task = (struct ucom_param_task *) - usb2_proc_msignal(&ssc->sc_tq, t0, t1); + usb_proc_msignal(&ssc->sc_tq, t0, t1); /* Setup callback and softc pointers */ task->hdr.pm_callback = fn; @@ -409,19 +409,19 @@ usb2_com_queue_command(struct ucom_softc *sc, /* * Closing the device should be synchronous. */ - if (fn == usb2_com_cfg_close) - usb2_proc_mwait(&ssc->sc_tq, t0, t1); + if (fn == ucom_cfg_close) + usb_proc_mwait(&ssc->sc_tq, t0, t1); /* * In case of multiple configure requests, * keep track of the last one! */ - if (fn == usb2_com_cfg_start_transfers) + if (fn == ucom_cfg_start_transfers) sc->sc_last_start_xfer = &task->hdr; } static void -usb2_com_shutdown(struct ucom_softc *sc) +ucom_shutdown(struct ucom_softc *sc) { struct tty *tp = sc->sc_tty; @@ -433,7 +433,7 @@ usb2_com_shutdown(struct ucom_softc *sc) * Hang up if necessary: */ if (tp->t_termios.c_cflag & HUPCL) { - usb2_com_modem(tp, 0, SER_DTR); + ucom_modem(tp, 0, SER_DTR); } } @@ -443,15 +443,15 @@ usb2_com_shutdown(struct ucom_softc *sc) * else: taskqueue is draining or gone */ uint8_t -usb2_com_cfg_is_gone(struct ucom_softc *sc) +ucom_cfg_is_gone(struct ucom_softc *sc) { struct ucom_super_softc *ssc = sc->sc_super; - return (usb2_proc_is_gone(&ssc->sc_tq)); + return (usb_proc_is_gone(&ssc->sc_tq)); } static void -usb2_com_cfg_start_transfers(struct usb_proc_msg *_task) +ucom_cfg_start_transfers(struct usb_proc_msg *_task) { struct ucom_cfg_task *task = (struct ucom_cfg_task *)_task; @@ -468,16 +468,16 @@ usb2_com_cfg_start_transfers(struct usb_proc_msg *_task) if (_task == sc->sc_last_start_xfer) sc->sc_flag |= UCOM_FLAG_GP_DATA; - if (sc->sc_callback->usb2_com_start_read) { - (sc->sc_callback->usb2_com_start_read) (sc); + if (sc->sc_callback->ucom_start_read) { + (sc->sc_callback->ucom_start_read) (sc); } - if (sc->sc_callback->usb2_com_start_write) { - (sc->sc_callback->usb2_com_start_write) (sc); + if (sc->sc_callback->ucom_start_write) { + (sc->sc_callback->ucom_start_write) (sc); } } static void -usb2_com_start_transfers(struct ucom_softc *sc) +ucom_start_transfers(struct ucom_softc *sc) { if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { return; @@ -486,16 +486,16 @@ usb2_com_start_transfers(struct ucom_softc *sc) * Make sure that data transfers are started in both * directions: */ - if (sc->sc_callback->usb2_com_start_read) { - (sc->sc_callback->usb2_com_start_read) (sc); + if (sc->sc_callback->ucom_start_read) { + (sc->sc_callback->ucom_start_read) (sc); } - if (sc->sc_callback->usb2_com_start_write) { - (sc->sc_callback->usb2_com_start_write) (sc); + if (sc->sc_callback->ucom_start_write) { + (sc->sc_callback->ucom_start_write) (sc); } } static void -usb2_com_cfg_open(struct usb_proc_msg *_task) +ucom_cfg_open(struct usb_proc_msg *_task) { struct ucom_cfg_task *task = (struct ucom_cfg_task *)_task; @@ -511,17 +511,17 @@ usb2_com_cfg_open(struct usb_proc_msg *_task) sc->sc_flag |= UCOM_FLAG_LL_READY; - if (sc->sc_callback->usb2_com_cfg_open) { - (sc->sc_callback->usb2_com_cfg_open) (sc); + if (sc->sc_callback->ucom_cfg_open) { + (sc->sc_callback->ucom_cfg_open) (sc); /* wait a little */ - usb2_pause_mtx(sc->sc_mtx, hz / 10); + usb_pause_mtx(sc->sc_mtx, hz / 10); } } } static int -usb2_com_open(struct tty *tp) +ucom_open(struct tty *tp) { struct ucom_softc *sc = tty_softc(tp); int error; @@ -537,12 +537,12 @@ usb2_com_open(struct tty *tp) } DPRINTF("tp = %p\n", tp); - if (sc->sc_callback->usb2_com_pre_open) { + if (sc->sc_callback->ucom_pre_open) { /* * give the lower layer a chance to disallow TTY open, for * example if the device is not present: */ - error = (sc->sc_callback->usb2_com_pre_open) (sc); + error = (sc->sc_callback->ucom_pre_open) (sc); if (error) { return (error); } @@ -561,26 +561,26 @@ usb2_com_open(struct tty *tp) sc->sc_pls_set = 0; sc->sc_pls_clr = 0; - usb2_com_queue_command(sc, usb2_com_cfg_open, NULL, + ucom_queue_command(sc, ucom_cfg_open, NULL, &sc->sc_open_task[0].hdr, &sc->sc_open_task[1].hdr); /* Queue transfer enable command last */ - usb2_com_queue_command(sc, usb2_com_cfg_start_transfers, NULL, + ucom_queue_command(sc, ucom_cfg_start_transfers, NULL, &sc->sc_start_task[0].hdr, &sc->sc_start_task[1].hdr); - usb2_com_modem(tp, SER_DTR | SER_RTS, 0); + ucom_modem(tp, SER_DTR | SER_RTS, 0); - usb2_com_break(sc, 0); + ucom_break(sc, 0); - usb2_com_status_change(sc); + ucom_status_change(sc); return (0); } static void -usb2_com_cfg_close(struct usb_proc_msg *_task) +ucom_cfg_close(struct usb_proc_msg *_task) { struct ucom_cfg_task *task = (struct ucom_cfg_task *)_task; @@ -590,15 +590,15 @@ usb2_com_cfg_close(struct usb_proc_msg *_task) if (sc->sc_flag & UCOM_FLAG_LL_READY) { sc->sc_flag &= ~UCOM_FLAG_LL_READY; - if (sc->sc_callback->usb2_com_cfg_close) - (sc->sc_callback->usb2_com_cfg_close) (sc); + if (sc->sc_callback->ucom_cfg_close) + (sc->sc_callback->ucom_cfg_close) (sc); } else { /* already closed */ } } static void -usb2_com_close(struct tty *tp) +ucom_close(struct tty *tp) { struct ucom_softc *sc = tty_softc(tp); @@ -610,21 +610,21 @@ usb2_com_close(struct tty *tp) DPRINTF("tp=%p already closed\n", tp); return; } - usb2_com_shutdown(sc); + ucom_shutdown(sc); - usb2_com_queue_command(sc, usb2_com_cfg_close, NULL, + ucom_queue_command(sc, ucom_cfg_close, NULL, &sc->sc_close_task[0].hdr, &sc->sc_close_task[1].hdr); sc->sc_flag &= ~(UCOM_FLAG_HL_READY | UCOM_FLAG_RTS_IFLOW); - if (sc->sc_callback->usb2_com_stop_read) { - (sc->sc_callback->usb2_com_stop_read) (sc); + if (sc->sc_callback->ucom_stop_read) { + (sc->sc_callback->ucom_stop_read) (sc); } } static int -usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td) +ucom_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td) { struct ucom_softc *sc = tty_softc(tp); int error; @@ -638,16 +638,16 @@ usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td) switch (cmd) { case TIOCSBRK: - usb2_com_break(sc, 1); + ucom_break(sc, 1); error = 0; break; case TIOCCBRK: - usb2_com_break(sc, 0); + ucom_break(sc, 0); error = 0; break; default: - if (sc->sc_callback->usb2_com_ioctl) { - error = (sc->sc_callback->usb2_com_ioctl) + if (sc->sc_callback->ucom_ioctl) { + error = (sc->sc_callback->ucom_ioctl) (sc, cmd, data, 0, td); } else { error = ENOIOCTL; @@ -658,7 +658,7 @@ usb2_com_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td) } static int -usb2_com_modem(struct tty *tp, int sigon, int sigoff) +ucom_modem(struct tty *tp, int sigon, int sigoff) { struct ucom_softc *sc = tty_softc(tp); uint8_t onoff; @@ -703,16 +703,16 @@ usb2_com_modem(struct tty *tp, int sigon, int sigoff) sc->sc_mcr &= ~SER_RTS; } onoff = (sc->sc_mcr & SER_DTR) ? 1 : 0; - usb2_com_dtr(sc, onoff); + ucom_dtr(sc, onoff); onoff = (sc->sc_mcr & SER_RTS) ? 1 : 0; - usb2_com_rts(sc, onoff); + ucom_rts(sc, onoff); return (0); } static void -usb2_com_cfg_line_state(struct usb_proc_msg *_task) +ucom_cfg_line_state(struct usb_proc_msg *_task) { struct ucom_cfg_task *task = (struct ucom_cfg_task *)_task; @@ -729,11 +729,11 @@ usb2_com_cfg_line_state(struct usb_proc_msg *_task) mask = 0; /* compute callback mask */ - if (sc->sc_callback->usb2_com_cfg_set_dtr) + if (sc->sc_callback->ucom_cfg_set_dtr) mask |= UCOM_LS_DTR; - if (sc->sc_callback->usb2_com_cfg_set_rts) + if (sc->sc_callback->ucom_cfg_set_rts) mask |= UCOM_LS_RTS; - if (sc->sc_callback->usb2_com_cfg_set_break) + if (sc->sc_callback->ucom_cfg_set_break) mask |= UCOM_LS_BREAK; /* compute the bits we are to program */ @@ -749,29 +749,29 @@ usb2_com_cfg_line_state(struct usb_proc_msg *_task) /* ensure that we don't loose any levels */ if (notch_bits & UCOM_LS_DTR) - sc->sc_callback->usb2_com_cfg_set_dtr(sc, + sc->sc_callback->ucom_cfg_set_dtr(sc, (prev_value & UCOM_LS_DTR) ? 1 : 0); if (notch_bits & UCOM_LS_RTS) - sc->sc_callback->usb2_com_cfg_set_rts(sc, + sc->sc_callback->ucom_cfg_set_rts(sc, (prev_value & UCOM_LS_RTS) ? 1 : 0); if (notch_bits & UCOM_LS_BREAK) - sc->sc_callback->usb2_com_cfg_set_break(sc, + sc->sc_callback->ucom_cfg_set_break(sc, (prev_value & UCOM_LS_BREAK) ? 1 : 0); /* set last value */ if (any_bits & UCOM_LS_DTR) - sc->sc_callback->usb2_com_cfg_set_dtr(sc, + sc->sc_callback->ucom_cfg_set_dtr(sc, (last_value & UCOM_LS_DTR) ? 1 : 0); if (any_bits & UCOM_LS_RTS) - sc->sc_callback->usb2_com_cfg_set_rts(sc, + sc->sc_callback->ucom_cfg_set_rts(sc, (last_value & UCOM_LS_RTS) ? 1 : 0); if (any_bits & UCOM_LS_BREAK) - sc->sc_callback->usb2_com_cfg_set_break(sc, + sc->sc_callback->ucom_cfg_set_break(sc, (last_value & UCOM_LS_BREAK) ? 1 : 0); } static void -usb2_com_line_state(struct ucom_softc *sc, +ucom_line_state(struct ucom_softc *sc, uint8_t set_bits, uint8_t clear_bits) { mtx_assert(sc->sc_mtx, MA_OWNED); @@ -789,46 +789,46 @@ usb2_com_line_state(struct ucom_softc *sc, sc->sc_pls_clr |= clear_bits; /* defer driver programming */ - usb2_com_queue_command(sc, usb2_com_cfg_line_state, NULL, + ucom_queue_command(sc, ucom_cfg_line_state, NULL, &sc->sc_line_state_task[0].hdr, &sc->sc_line_state_task[1].hdr); } static void -usb2_com_break(struct ucom_softc *sc, uint8_t onoff) +ucom_break(struct ucom_softc *sc, uint8_t onoff) { DPRINTF("onoff = %d\n", onoff); if (onoff) - usb2_com_line_state(sc, UCOM_LS_BREAK, 0); + ucom_line_state(sc, UCOM_LS_BREAK, 0); else - usb2_com_line_state(sc, 0, UCOM_LS_BREAK); + ucom_line_state(sc, 0, UCOM_LS_BREAK); } static void -usb2_com_dtr(struct ucom_softc *sc, uint8_t onoff) +ucom_dtr(struct ucom_softc *sc, uint8_t onoff) { DPRINTF("onoff = %d\n", onoff); if (onoff) - usb2_com_line_state(sc, UCOM_LS_DTR, 0); + ucom_line_state(sc, UCOM_LS_DTR, 0); else - usb2_com_line_state(sc, 0, UCOM_LS_DTR); + ucom_line_state(sc, 0, UCOM_LS_DTR); } static void -usb2_com_rts(struct ucom_softc *sc, uint8_t onoff) +ucom_rts(struct ucom_softc *sc, uint8_t onoff) { DPRINTF("onoff = %d\n", onoff); if (onoff) - usb2_com_line_state(sc, UCOM_LS_RTS, 0); + ucom_line_state(sc, UCOM_LS_RTS, 0); else - usb2_com_line_state(sc, 0, UCOM_LS_RTS); + ucom_line_state(sc, 0, UCOM_LS_RTS); } static void -usb2_com_cfg_status_change(struct usb_proc_msg *_task) +ucom_cfg_status_change(struct usb_proc_msg *_task) { struct ucom_cfg_task *task = (struct ucom_cfg_task *)_task; @@ -845,7 +845,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task) if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { return; } - if (sc->sc_callback->usb2_com_cfg_get_status == NULL) { + if (sc->sc_callback->ucom_cfg_get_status == NULL) { return; } /* get status */ @@ -853,7 +853,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task) new_msr = 0; new_lsr = 0; - (sc->sc_callback->usb2_com_cfg_get_status) (sc, &new_lsr, &new_msr); + (sc->sc_callback->ucom_cfg_get_status) (sc, &new_lsr, &new_msr); if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { /* TTY device closed */ @@ -875,7 +875,7 @@ usb2_com_cfg_status_change(struct usb_proc_msg *_task) } void -usb2_com_status_change(struct ucom_softc *sc) +ucom_status_change(struct ucom_softc *sc) { mtx_assert(sc->sc_mtx, MA_OWNED); @@ -884,13 +884,13 @@ usb2_com_status_change(struct ucom_softc *sc) } DPRINTF("\n"); - usb2_com_queue_command(sc, usb2_com_cfg_status_change, NULL, + ucom_queue_command(sc, ucom_cfg_status_change, NULL, &sc->sc_status_task[0].hdr, &sc->sc_status_task[1].hdr); } static void -usb2_com_cfg_param(struct usb_proc_msg *_task) +ucom_cfg_param(struct usb_proc_msg *_task) { struct ucom_param_task *task = (struct ucom_param_task *)_task; @@ -899,18 +899,18 @@ usb2_com_cfg_param(struct usb_proc_msg *_task) if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { return; } - if (sc->sc_callback->usb2_com_cfg_param == NULL) { + if (sc->sc_callback->ucom_cfg_param == NULL) { return; } - (sc->sc_callback->usb2_com_cfg_param) (sc, &task->termios_copy); + (sc->sc_callback->ucom_cfg_param) (sc, &task->termios_copy); /* wait a little */ - usb2_pause_mtx(sc->sc_mtx, hz / 10); + usb_pause_mtx(sc->sc_mtx, hz / 10); } static int -usb2_com_param(struct tty *tp, struct termios *t) +ucom_param(struct tty *tp, struct termios *t) { struct ucom_softc *sc = tty_softc(tp); uint8_t opened; @@ -925,7 +925,7 @@ usb2_com_param(struct tty *tp, struct termios *t) /* XXX the TTY layer should call "open()" first! */ - error = usb2_com_open(tp); + error = ucom_open(tp); if (error) { goto done; } @@ -946,9 +946,9 @@ usb2_com_param(struct tty *tp, struct termios *t) } t->c_ispeed = t->c_ospeed; - if (sc->sc_callback->usb2_com_pre_param) { + if (sc->sc_callback->ucom_pre_param) { /* Let the lower layer verify the parameters */ - error = (sc->sc_callback->usb2_com_pre_param) (sc, t); + error = (sc->sc_callback->ucom_pre_param) (sc, t); if (error) { DPRINTF("callback error = %d\n", error); goto done; @@ -959,12 +959,12 @@ usb2_com_param(struct tty *tp, struct termios *t) sc->sc_flag &= ~UCOM_FLAG_GP_DATA; /* Queue baud rate programming command first */ - usb2_com_queue_command(sc, usb2_com_cfg_param, t, + ucom_queue_command(sc, ucom_cfg_param, t, &sc->sc_param_task[0].hdr, &sc->sc_param_task[1].hdr); /* Queue transfer enable command last */ - usb2_com_queue_command(sc, usb2_com_cfg_start_transfers, NULL, + ucom_queue_command(sc, ucom_cfg_start_transfers, NULL, &sc->sc_start_task[0].hdr, &sc->sc_start_task[1].hdr); @@ -972,19 +972,19 @@ usb2_com_param(struct tty *tp, struct termios *t) sc->sc_flag |= UCOM_FLAG_RTS_IFLOW; } else if (sc->sc_flag & UCOM_FLAG_RTS_IFLOW) { sc->sc_flag &= ~UCOM_FLAG_RTS_IFLOW; - usb2_com_modem(tp, SER_RTS, 0); + ucom_modem(tp, SER_RTS, 0); } done: if (error) { if (opened) { - usb2_com_close(tp); + ucom_close(tp); } } return (error); } static void -usb2_com_outwakeup(struct tty *tp) +ucom_outwakeup(struct tty *tp) { struct ucom_softc *sc = tty_softc(tp); @@ -996,18 +996,18 @@ usb2_com_outwakeup(struct tty *tp) /* The higher layer is not ready */ return; } - usb2_com_start_transfers(sc); + ucom_start_transfers(sc); } /*------------------------------------------------------------------------* - * usb2_com_get_data + * ucom_get_data * * Return values: * 0: No data is available. * Else: Data is available. *------------------------------------------------------------------------*/ uint8_t -usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, +ucom_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, uint32_t offset, uint32_t len, uint32_t *actlen) { struct usb_page_search res; @@ -1026,7 +1026,7 @@ usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, while (len != 0) { - usb2_get_page(pc, offset, &res); + usbd_get_page(pc, offset, &res); if (res.length > len) { res.length = len; @@ -1054,7 +1054,7 @@ usb2_com_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, } void -usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, +ucom_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, uint32_t offset, uint32_t len) { struct usb_page_search res; @@ -1074,7 +1074,7 @@ usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, while (len > 0) { - usb2_get_page(pc, offset, &res); + usbd_get_page(pc, offset, &res); if (res.length > len) { res.length = len; @@ -1111,7 +1111,7 @@ usb2_com_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, } static void -usb2_com_free(void *xsc) +ucom_free(void *xsc) { struct ucom_softc *sc = xsc; diff --git a/sys/dev/usb/serial/usb_serial.h b/sys/dev/usb/serial/usb_serial.h index 6f896ce..66a65da 100644 --- a/sys/dev/usb/serial/usb_serial.h +++ b/sys/dev/usb/serial/usb_serial.h @@ -85,26 +85,26 @@ struct usb_device_request; struct thread; /* - * NOTE: There is no guarantee that "usb2_com_cfg_close()" will - * be called after "usb2_com_cfg_open()" if the device is detached + * NOTE: There is no guarantee that "ucom_cfg_close()" will + * be called after "ucom_cfg_open()" if the device is detached * while it is open! */ struct ucom_callback { - void (*usb2_com_cfg_get_status) (struct ucom_softc *, uint8_t *plsr, uint8_t *pmsr); - void (*usb2_com_cfg_set_dtr) (struct ucom_softc *, uint8_t); - void (*usb2_com_cfg_set_rts) (struct ucom_softc *, uint8_t); - void (*usb2_com_cfg_set_break) (struct ucom_softc *, uint8_t); - void (*usb2_com_cfg_param) (struct ucom_softc *, struct termios *); - void (*usb2_com_cfg_open) (struct ucom_softc *); - void (*usb2_com_cfg_close) (struct ucom_softc *); - int (*usb2_com_pre_open) (struct ucom_softc *); - int (*usb2_com_pre_param) (struct ucom_softc *, struct termios *); - int (*usb2_com_ioctl) (struct ucom_softc *, uint32_t, caddr_t, int, struct thread *); - void (*usb2_com_start_read) (struct ucom_softc *); - void (*usb2_com_stop_read) (struct ucom_softc *); - void (*usb2_com_start_write) (struct ucom_softc *); - void (*usb2_com_stop_write) (struct ucom_softc *); - void (*usb2_com_tty_name) (struct ucom_softc *, char *pbuf, uint16_t buflen, uint16_t local_subunit); + void (*ucom_cfg_get_status) (struct ucom_softc *, uint8_t *plsr, uint8_t *pmsr); + void (*ucom_cfg_set_dtr) (struct ucom_softc *, uint8_t); + void (*ucom_cfg_set_rts) (struct ucom_softc *, uint8_t); + void (*ucom_cfg_set_break) (struct ucom_softc *, uint8_t); + void (*ucom_cfg_param) (struct ucom_softc *, struct termios *); + void (*ucom_cfg_open) (struct ucom_softc *); + void (*ucom_cfg_close) (struct ucom_softc *); + int (*ucom_pre_open) (struct ucom_softc *); + int (*ucom_pre_param) (struct ucom_softc *, struct termios *); + int (*ucom_ioctl) (struct ucom_softc *, uint32_t, caddr_t, int, struct thread *); + void (*ucom_start_read) (struct ucom_softc *); + void (*ucom_stop_read) (struct ucom_softc *); + void (*ucom_start_write) (struct ucom_softc *); + void (*ucom_stop_write) (struct ucom_softc *); + void (*ucom_tty_name) (struct ucom_softc *, char *pbuf, uint16_t buflen, uint16_t local_subunit); }; /* Line status register */ @@ -182,18 +182,18 @@ struct ucom_softc { #define UCOM_LS_BREAK 0x04 }; -#define usb2_com_cfg_do_request(udev,com,req,ptr,flags,timo) \ - usb2_do_request_proc(udev,&(com)->sc_super->sc_tq,req,ptr,flags,NULL,timo) +#define ucom_cfg_do_request(udev,com,req,ptr,flags,timo) \ + usbd_do_request_proc(udev,&(com)->sc_super->sc_tq,req,ptr,flags,NULL,timo) -int usb2_com_attach(struct ucom_super_softc *, +int ucom_attach(struct ucom_super_softc *, struct ucom_softc *, uint32_t, void *, const struct ucom_callback *callback, struct mtx *); -void usb2_com_detach(struct ucom_super_softc *, +void ucom_detach(struct ucom_super_softc *, struct ucom_softc *, uint32_t); -void usb2_com_status_change(struct ucom_softc *); -uint8_t usb2_com_get_data(struct ucom_softc *, struct usb_page_cache *, +void ucom_status_change(struct ucom_softc *); +uint8_t ucom_get_data(struct ucom_softc *, struct usb_page_cache *, uint32_t, uint32_t, uint32_t *); -void usb2_com_put_data(struct ucom_softc *, struct usb_page_cache *, +void ucom_put_data(struct ucom_softc *, struct usb_page_cache *, uint32_t, uint32_t); -uint8_t usb2_com_cfg_is_gone(struct ucom_softc *); +uint8_t ucom_cfg_is_gone(struct ucom_softc *); #endif /* _USB2_SERIAL_H_ */ diff --git a/sys/dev/usb/serial/uslcom.c b/sys/dev/usb/serial/uslcom.c index 66d9461..2047cb2 100644 --- a/sys/dev/usb/serial/uslcom.c +++ b/sys/dev/usb/serial/uslcom.c @@ -144,18 +144,18 @@ static const struct usb_config uslcom_config[USLCOM_N_TRANSFER] = { }; static struct ucom_callback uslcom_callback = { - .usb2_com_cfg_open = &uslcom_open, - .usb2_com_cfg_close = &uslcom_close, - .usb2_com_cfg_get_status = &uslcom_get_status, - .usb2_com_cfg_set_dtr = &uslcom_set_dtr, - .usb2_com_cfg_set_rts = &uslcom_set_rts, - .usb2_com_cfg_set_break = &uslcom_set_break, - .usb2_com_cfg_param = &uslcom_param, - .usb2_com_pre_param = &uslcom_pre_param, - .usb2_com_start_read = &uslcom_start_read, - .usb2_com_stop_read = &uslcom_stop_read, - .usb2_com_start_write = &uslcom_start_write, - .usb2_com_stop_write = &uslcom_stop_write, + .ucom_cfg_open = &uslcom_open, + .ucom_cfg_close = &uslcom_close, + .ucom_cfg_get_status = &uslcom_get_status, + .ucom_cfg_set_dtr = &uslcom_set_dtr, + .ucom_cfg_set_rts = &uslcom_set_rts, + .ucom_cfg_set_break = &uslcom_set_break, + .ucom_cfg_param = &uslcom_param, + .ucom_pre_param = &uslcom_pre_param, + .ucom_start_read = &uslcom_start_read, + .ucom_stop_read = &uslcom_stop_read, + .ucom_start_write = &uslcom_start_write, + .ucom_stop_write = &uslcom_stop_write, }; static const struct usb_device_id uslcom_devs[] = { @@ -215,7 +215,7 @@ uslcom_probe(device_t dev) if (uaa->info.bIfaceIndex != USLCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uslcom_devs, sizeof(uslcom_devs), uaa)); + return (usbd_lookup_id_by_uaa(uslcom_devs, sizeof(uslcom_devs), uaa)); } static int @@ -227,26 +227,26 @@ uslcom_attach(device_t dev) DPRINTFN(11, "\n"); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uslcom", NULL, MTX_DEF); sc->sc_udev = uaa->device; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, uslcom_config, USLCOM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { DPRINTF("one or more missing USB endpoints, " - "error=%s\n", usb2_errstr(error)); + "error=%s\n", usbd_errstr(error)); goto detach; } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uslcom_callback, &sc->sc_mtx); if (error) { goto detach; @@ -265,8 +265,8 @@ uslcom_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, USLCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, USLCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -284,7 +284,7 @@ uslcom_open(struct ucom_softc *ucom) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("UART enable failed (ignored)\n"); } @@ -302,7 +302,7 @@ uslcom_close(struct ucom_softc *ucom) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("UART disable failed (ignored)\n"); } @@ -326,7 +326,7 @@ uslcom_set_dtr(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("Setting DTR failed (ignored)\n"); } @@ -350,7 +350,7 @@ uslcom_set_rts(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("Setting DTR failed (ignored)\n"); } @@ -379,7 +379,7 @@ uslcom_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("Set baudrate failed (ignored)\n"); } @@ -416,7 +416,7 @@ uslcom_param(struct ucom_softc *ucom, struct termios *t) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("Set format failed (ignored)\n"); } @@ -447,7 +447,7 @@ uslcom_set_break(struct ucom_softc *ucom, uint8_t onoff) USETW(req.wIndex, USLCOM_PORT_NO); USETW(req.wLength, 0); - if (usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000)) { DPRINTF("Set BREAK failed (ignored)\n"); } @@ -463,13 +463,13 @@ uslcom_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, USLCOM_BULK_BUF_SIZE, &actlen)) { DPRINTF("actlen = %d\n", actlen); xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -490,12 +490,12 @@ uslcom_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -514,7 +514,7 @@ uslcom_start_read(struct ucom_softc *ucom) struct uslcom_softc *sc = ucom->sc_parent; /* start read endpoint */ - usb2_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_RD]); } static void @@ -523,7 +523,7 @@ uslcom_stop_read(struct ucom_softc *ucom) struct uslcom_softc *sc = ucom->sc_parent; /* stop read endpoint */ - usb2_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_RD]); } static void @@ -531,7 +531,7 @@ uslcom_start_write(struct ucom_softc *ucom) { struct uslcom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_WR]); } static void @@ -539,5 +539,5 @@ uslcom_stop_write(struct ucom_softc *ucom) { struct uslcom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_WR]); } diff --git a/sys/dev/usb/serial/uvisor.c b/sys/dev/usb/serial/uvisor.c index 11d8fad..1e39947 100644 --- a/sys/dev/usb/serial/uvisor.c +++ b/sys/dev/usb/serial/uvisor.c @@ -212,12 +212,12 @@ static const struct usb_config uvisor_config[UVISOR_N_TRANSFER] = { }; static const struct ucom_callback uvisor_callback = { - .usb2_com_cfg_open = &uvisor_cfg_open, - .usb2_com_cfg_close = &uvisor_cfg_close, - .usb2_com_start_read = &uvisor_start_read, - .usb2_com_stop_read = &uvisor_stop_read, - .usb2_com_start_write = &uvisor_start_write, - .usb2_com_stop_write = &uvisor_stop_write, + .ucom_cfg_open = &uvisor_cfg_open, + .ucom_cfg_close = &uvisor_cfg_close, + .ucom_start_read = &uvisor_start_read, + .ucom_stop_read = &uvisor_stop_read, + .ucom_start_write = &uvisor_start_write, + .ucom_stop_write = &uvisor_stop_write, }; static device_method_t uvisor_methods[] = { @@ -282,7 +282,7 @@ uvisor_probe(device_t dev) if (uaa->info.bIfaceIndex != UVISOR_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uvisor_devs, sizeof(uvisor_devs), uaa)); + return (usbd_lookup_id_by_uaa(uvisor_devs, sizeof(uvisor_devs), uaa)); } static int @@ -296,7 +296,7 @@ uvisor_attach(device_t dev) DPRINTF("sc=%p\n", sc); bcopy(uvisor_config, uvisor_config_copy, sizeof(uvisor_config_copy)); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uvisor", NULL, MTX_DEF); @@ -312,10 +312,10 @@ uvisor_attach(device_t dev) if (error) { DPRINTF("init failed, error=%s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } - error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index, + error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, sc->sc_xfer, uvisor_config_copy, UVISOR_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -324,14 +324,14 @@ uvisor_attach(device_t dev) } /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uvisor_callback, &sc->sc_mtx); if (error) { - DPRINTF("usb2_com_attach failed\n"); + DPRINTF("ucom_attach failed\n"); goto detach; } return (0); @@ -348,8 +348,8 @@ uvisor_detach(device_t dev) DPRINTF("sc=%p\n", sc); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UVISOR_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UVISOR_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -373,7 +373,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE); - err = usb2_do_request_flags(udev, NULL, + err = usbd_do_request_flags(udev, NULL, &req, &coninfo, USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT); @@ -426,7 +426,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wIndex, 0); USETW(req.wLength, UVISOR_GET_PALM_INFORMATION_LEN); - err = usb2_do_request_flags + err = usbd_do_request_flags (udev, NULL, &req, &pconinfo, USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT); @@ -453,7 +453,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, UVISOR_GET_PALM_INFORMATION_LEN); - err = usb2_do_request(udev, &req, buffer); + err = usbd_do_request(udev, &req, buffer); if (err) { goto done; } @@ -468,7 +468,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wIndex, 0); USETW(req.wLength, 1); - err = usb2_do_request(udev, NULL, &req, buffer); + err = usbd_do_request(udev, NULL, &req, buffer); if (err) { goto done; } @@ -479,7 +479,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, 1); - err = usb2_do_request(udev, NULL, &req, buffer); + err = usbd_do_request(udev, NULL, &req, buffer); if (err) { goto done; } @@ -490,7 +490,7 @@ uvisor_init(struct uvisor_softc *sc, struct usb_device *udev, struct usb_config USETW(req.wValue, 0); USETW(req.wIndex, 5); USETW(req.wLength, sizeof(wAvail)); - err = usb2_do_request(udev, NULL, &req, &wAvail); + err = usbd_do_request(udev, NULL, &req, &wAvail); if (err) { goto done; } @@ -521,11 +521,11 @@ uvisor_cfg_close(struct ucom_softc *ucom) USETW(req.wIndex, 0); USETW(req.wLength, UVISOR_CONNECTION_INFO_SIZE); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, buffer, 0, 1000); if (err) { DPRINTFN(0, "close notification failed, error=%s\n", - usb2_errstr(err)); + usbd_errstr(err)); } } @@ -534,7 +534,7 @@ uvisor_start_read(struct ucom_softc *ucom) { struct uvisor_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_RD]); } static void @@ -542,7 +542,7 @@ uvisor_stop_read(struct ucom_softc *ucom) { struct uvisor_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_RD]); } static void @@ -550,7 +550,7 @@ uvisor_start_write(struct ucom_softc *ucom) { struct uvisor_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UVISOR_BULK_DT_WR]); } static void @@ -558,7 +558,7 @@ uvisor_stop_write(struct ucom_softc *ucom) { struct uvisor_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UVISOR_BULK_DT_WR]); } static void @@ -571,11 +571,11 @@ uvisor_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UVISOR_BUFSIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -596,12 +596,12 @@ uvisor_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ diff --git a/sys/dev/usb/serial/uvscom.c b/sys/dev/usb/serial/uvscom.c index 435c738..40b09a6 100644 --- a/sys/dev/usb/serial/uvscom.c +++ b/sys/dev/usb/serial/uvscom.c @@ -204,19 +204,19 @@ static const struct usb_config uvscom_config[UVSCOM_N_TRANSFER] = { }; static const struct ucom_callback uvscom_callback = { - .usb2_com_cfg_get_status = &uvscom_cfg_get_status, - .usb2_com_cfg_set_dtr = &uvscom_cfg_set_dtr, - .usb2_com_cfg_set_rts = &uvscom_cfg_set_rts, - .usb2_com_cfg_set_break = &uvscom_cfg_set_break, - .usb2_com_cfg_param = &uvscom_cfg_param, - .usb2_com_cfg_open = &uvscom_cfg_open, - .usb2_com_cfg_close = &uvscom_cfg_close, - .usb2_com_pre_open = &uvscom_pre_open, - .usb2_com_pre_param = &uvscom_pre_param, - .usb2_com_start_read = &uvscom_start_read, - .usb2_com_stop_read = &uvscom_stop_read, - .usb2_com_start_write = &uvscom_start_write, - .usb2_com_stop_write = &uvscom_stop_write, + .ucom_cfg_get_status = &uvscom_cfg_get_status, + .ucom_cfg_set_dtr = &uvscom_cfg_set_dtr, + .ucom_cfg_set_rts = &uvscom_cfg_set_rts, + .ucom_cfg_set_break = &uvscom_cfg_set_break, + .ucom_cfg_param = &uvscom_cfg_param, + .ucom_cfg_open = &uvscom_cfg_open, + .ucom_cfg_close = &uvscom_cfg_close, + .ucom_pre_open = &uvscom_pre_open, + .ucom_pre_param = &uvscom_pre_param, + .ucom_start_read = &uvscom_start_read, + .ucom_stop_read = &uvscom_stop_read, + .ucom_start_write = &uvscom_start_write, + .ucom_stop_write = &uvscom_stop_write, }; static const struct usb_device_id uvscom_devs[] = { @@ -266,7 +266,7 @@ uvscom_probe(device_t dev) if (uaa->info.bIfaceIndex != UVSCOM_IFACE_INDEX) { return (ENXIO); } - return (usb2_lookup_id_by_uaa(uvscom_devs, sizeof(uvscom_devs), uaa)); + return (usbd_lookup_id_by_uaa(uvscom_devs, sizeof(uvscom_devs), uaa)); } static int @@ -276,7 +276,7 @@ uvscom_attach(device_t dev) struct uvscom_softc *sc = device_get_softc(dev); int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uvscom", NULL, MTX_DEF); sc->sc_udev = uaa->device; @@ -286,7 +286,7 @@ uvscom_attach(device_t dev) sc->sc_iface_no = uaa->info.bIfaceNum; sc->sc_iface_index = UVSCOM_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index, + error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, sc->sc_xfer, uvscom_config, UVSCOM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { @@ -297,18 +297,18 @@ uvscom_attach(device_t dev) /* clear stall at first run */ mtx_lock(&sc->sc_mtx); - usb2_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]); - usb2_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]); + usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]); + usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]); mtx_unlock(&sc->sc_mtx); - error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, + error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, &uvscom_callback, &sc->sc_mtx); if (error) { goto detach; } /* start interrupt pipe */ mtx_lock(&sc->sc_mtx); - usb2_transfer_start(sc->sc_xfer[UVSCOM_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UVSCOM_INTR_DT_RD]); mtx_unlock(&sc->sc_mtx); return (0); @@ -328,10 +328,10 @@ uvscom_detach(device_t dev) /* stop interrupt pipe */ if (sc->sc_xfer[UVSCOM_INTR_DT_RD]) - usb2_transfer_stop(sc->sc_xfer[UVSCOM_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UVSCOM_INTR_DT_RD]); - usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); - usb2_transfer_unsetup(sc->sc_xfer, UVSCOM_N_TRANSFER); + ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); + usbd_transfer_unsetup(sc->sc_xfer, UVSCOM_N_TRANSFER); mtx_destroy(&sc->sc_mtx); return (0); @@ -347,11 +347,11 @@ uvscom_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: tr_setup: - if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, + if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0, UVSCOM_BULK_BUF_SIZE, &actlen)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -372,12 +372,12 @@ uvscom_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); + ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -400,7 +400,7 @@ uvscom_intr_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: if (xfer->actlen >= 2) { - usb2_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); + usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf)); sc->sc_lsr = 0; sc->sc_msr = 0; @@ -425,12 +425,12 @@ uvscom_intr_callback(struct usb_xfer *xfer) * the UCOM layer will ignore this call if the TTY * device is closed! */ - usb2_com_status_change(&sc->sc_ucom); + ucom_status_change(&sc->sc_ucom); } case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -632,7 +632,7 @@ uvscom_start_read(struct ucom_softc *ucom) { struct uvscom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_RD]); } static void @@ -640,7 +640,7 @@ uvscom_stop_read(struct ucom_softc *ucom) { struct uvscom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_RD]); } static void @@ -648,7 +648,7 @@ uvscom_start_write(struct ucom_softc *ucom) { struct uvscom_softc *sc = ucom->sc_parent; - usb2_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UVSCOM_BULK_DT_WR]); } static void @@ -656,7 +656,7 @@ uvscom_stop_write(struct ucom_softc *ucom) { struct uvscom_softc *sc = ucom->sc_parent; - usb2_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UVSCOM_BULK_DT_WR]); } static void @@ -680,11 +680,11 @@ uvscom_cfg_write(struct uvscom_softc *sc, uint8_t index, uint16_t value) USETW(req.wIndex, 0); USETW(req.wLength, 0); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, NULL, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } } @@ -701,11 +701,11 @@ uvscom_cfg_read_status(struct uvscom_softc *sc) USETW(req.wIndex, 0); USETW(req.wLength, 2); - err = usb2_com_cfg_do_request(sc->sc_udev, &sc->sc_ucom, + err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, &req, data, 0, 1000); if (err) { DPRINTFN(0, "device request failed, err=%s " - "(ignored)\n", usb2_errstr(err)); + "(ignored)\n", usbd_errstr(err)); } return (data[0] | (data[1] << 8)); } diff --git a/sys/dev/usb/storage/umass.c b/sys/dev/usb/storage/umass.c index 55c199f..02e60a4 100644 --- a/sys/dev/usb/storage/umass.c +++ b/sys/dev/usb/storage/umass.c @@ -1307,7 +1307,7 @@ umass_get_proto(struct usb_interface *iface) retval = 0; /* Check for a standards compliant device */ - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if ((id == NULL) || (id->bInterfaceClass != UICLASS_MASS)) { goto done; @@ -1468,14 +1468,14 @@ umass_attach(device_t dev) snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", device_get_nameunit(dev)); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF | MTX_RECURSE); /* get interface index */ - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); if (id == NULL) { device_printf(dev, "failed to get " "interface number\n"); @@ -1526,7 +1526,7 @@ umass_attach(device_t dev) #endif if (sc->sc_quirks & ALT_IFACE_1) { - err = usb2_set_alt_interface_index + err = usbd_set_alt_interface_index (uaa->device, uaa->info.bIfaceIndex, 1); if (err) { @@ -1539,7 +1539,7 @@ umass_attach(device_t dev) if (sc->sc_proto & UMASS_PROTO_BBB) { - err = usb2_transfer_setup(uaa->device, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, umass_bbb_config, UMASS_T_BBB_MAX, sc, &sc->sc_mtx); @@ -1548,7 +1548,7 @@ umass_attach(device_t dev) } else if (sc->sc_proto & (UMASS_PROTO_CBI | UMASS_PROTO_CBI_I)) { - err = usb2_transfer_setup(uaa->device, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, umass_cbi_config, (sc->sc_proto & UMASS_PROTO_CBI_I) ? UMASS_T_CBI_MAX : (UMASS_T_CBI_MAX - 2), sc, @@ -1563,7 +1563,7 @@ umass_attach(device_t dev) if (err) { device_printf(dev, "could not setup required " - "transfers, %s\n", usb2_errstr(err)); + "transfers, %s\n", usbd_errstr(err)); goto detach; } sc->sc_transform = @@ -1594,7 +1594,7 @@ umass_attach(device_t dev) * some devices need a delay after that the configuration value is * set to function properly: */ - usb2_pause_mtx(NULL, hz); + usb_pause_mtx(NULL, hz); /* register the SIM */ err = umass_cam_attach_sim(sc); @@ -1622,7 +1622,7 @@ umass_detach(device_t dev) /* teardown our statemachine */ - usb2_transfer_unsetup(sc->sc_xfer, UMASS_T_MAX); + usbd_transfer_unsetup(sc->sc_xfer, UMASS_T_MAX); #if (__FreeBSD_version >= 700037) mtx_lock(&sc->sc_mtx); @@ -1653,7 +1653,7 @@ umass_init_shuttle(struct umass_softc *sc) req.wIndex[0] = sc->sc_iface_no; req.wIndex[1] = 0; USETW(req.wLength, sizeof(status)); - err = usb2_do_request(sc->sc_udev, NULL, &req, &status); + err = usbd_do_request(sc->sc_udev, NULL, &req, &status); DPRINTF(sc, UDMASS_GEN, "Shuttle init returned 0x%02x%02x\n", status[0], status[1]); @@ -1671,7 +1671,7 @@ umass_transfer_start(struct umass_softc *sc, uint8_t xfer_index) if (sc->sc_xfer[xfer_index]) { sc->sc_last_xfer_index = xfer_index; - usb2_transfer_start(sc->sc_xfer[xfer_index]); + usbd_transfer_start(sc->sc_xfer[xfer_index]); } else { umass_cancel_ccb(sc); } @@ -1685,7 +1685,7 @@ umass_reset(struct umass_softc *sc) /* * stop the last transfer, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]); + usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]); umass_transfer_start(sc, 0); } @@ -1715,7 +1715,7 @@ umass_tr_error(struct usb_xfer *xfer) if (xfer->error != USB_ERR_CANCELLED) { DPRINTF(sc, UDMASS_GEN, "transfer error, %s -> " - "reset\n", usb2_errstr(xfer->error)); + "reset\n", usbd_errstr(xfer->error)); } umass_cancel_ccb(sc); } @@ -1759,11 +1759,11 @@ umass_t_bbb_reset1_callback(struct usb_xfer *xfer) req.wIndex[1] = 0; USETW(req.wLength, 0); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); xfer->frlengths[0] = sizeof(req); xfer->nframes = 1; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -1801,7 +1801,7 @@ tr_transferred: return; case USB_ST_SETUP: - if (usb2_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { + if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { goto tr_transferred; } return; @@ -1881,10 +1881,10 @@ umass_t_bbb_command_callback(struct usb_xfer *xfer) DIF(UDMASS_BBB, umass_bbb_dump_cbw(sc, &sc->cbw)); - usb2_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw)); + usbd_copy_in(xfer->frbuffers, 0, &sc->cbw, sizeof(sc->cbw)); xfer->frlengths[0] = sizeof(sc->cbw); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -1904,7 +1904,7 @@ umass_t_bbb_data_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: if (!xfer->flags.ext_buffer) { - usb2_copy_out(xfer->frbuffers, 0, + usbd_copy_out(xfer->frbuffers, 0, sc->sc_transfer.data_ptr, xfer->actlen); } sc->sc_transfer.data_rem -= xfer->actlen; @@ -1930,9 +1930,9 @@ umass_t_bbb_data_read_callback(struct usb_xfer *xfer) xfer->frlengths[0] = max_bulk; if (xfer->flags.ext_buffer) { - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -1984,13 +1984,13 @@ umass_t_bbb_data_write_callback(struct usb_xfer *xfer) xfer->frlengths[0] = max_bulk; if (xfer->flags.ext_buffer) { - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); } else { - usb2_copy_in(xfer->frbuffers, 0, + usbd_copy_in(xfer->frbuffers, 0, sc->sc_transfer.data_ptr, max_bulk); } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -2031,7 +2031,7 @@ umass_t_bbb_status_callback(struct usb_xfer *xfer) if (xfer->actlen < sizeof(sc->csw)) { bzero(&sc->csw, sizeof(sc->csw)); } - usb2_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, &sc->csw, xfer->actlen); DIF(UDMASS_BBB, umass_bbb_dump_csw(sc, &sc->csw)); @@ -2105,13 +2105,13 @@ umass_t_bbb_status_callback(struct usb_xfer *xfer) case USB_ST_SETUP: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: tr_error: DPRINTF(sc, UDMASS_BBB, "Failed to read CSW: %s, try %d\n", - usb2_errstr(xfer->error), sc->sc_status_try); + usbd_errstr(xfer->error), sc->sc_status_try); if ((xfer->error == USB_ERR_CANCELLED) || (sc->sc_status_try)) { @@ -2150,7 +2150,7 @@ umass_command_start(struct umass_softc *sc, uint8_t dir, sc->sc_transfer.ccb = ccb; if (sc->sc_xfer[sc->sc_last_xfer_index]) { - usb2_transfer_start(sc->sc_xfer[sc->sc_last_xfer_index]); + usbd_transfer_start(sc->sc_xfer[sc->sc_last_xfer_index]); } else { ccb->ccb_h.status = CAM_TID_INVALID; xpt_done(ccb); @@ -2172,13 +2172,13 @@ umass_bbb_get_max_lun(struct umass_softc *sc) req.wIndex[1] = 0; USETW(req.wLength, 1); - err = usb2_do_request(sc->sc_udev, NULL, &req, &buf); + err = usbd_do_request(sc->sc_udev, NULL, &req, &buf); if (err) { buf = 0; /* Device doesn't support Get Max Lun request. */ printf("%s: Get Max Lun not supported (%s)\n", - sc->sc_name, usb2_errstr(err)); + sc->sc_name, usbd_errstr(err)); } return (buf); } @@ -2255,13 +2255,13 @@ umass_t_cbi_reset1_callback(struct usb_xfer *xfer) buf[i] = 0xff; } - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers + 1, 0, buf, sizeof(buf)); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = sizeof(buf); xfer->nframes = 2; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -2315,7 +2315,7 @@ tr_transferred: return; case USB_ST_SETUP: - if (usb2_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { + if (usbd_clear_stall_callback(xfer, sc->sc_xfer[stall_xfer])) { goto tr_transferred; /* should not happen */ } return; @@ -2365,8 +2365,8 @@ umass_t_cbi_command_callback(struct usb_xfer *xfer) req.wLength[0] = sc->sc_transfer.cmd_len; req.wLength[1] = 0; - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_copy_in(xfer->frbuffers + 1, 0, sc->sc_transfer.cmd_data, + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers + 1, 0, sc->sc_transfer.cmd_data, sc->sc_transfer.cmd_len); xfer->frlengths[0] = sizeof(req); @@ -2378,7 +2378,7 @@ umass_t_cbi_command_callback(struct usb_xfer *xfer) sc->sc_transfer.cmd_data, sc->sc_transfer.cmd_len)); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -2398,7 +2398,7 @@ umass_t_cbi_data_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: if (!xfer->flags.ext_buffer) { - usb2_copy_out(xfer->frbuffers, 0, + usbd_copy_out(xfer->frbuffers, 0, sc->sc_transfer.data_ptr, xfer->actlen); } sc->sc_transfer.data_rem -= xfer->actlen; @@ -2423,10 +2423,10 @@ umass_t_cbi_data_read_callback(struct usb_xfer *xfer) xfer->timeout = sc->sc_transfer.data_timeout; if (xfer->flags.ext_buffer) { - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); } xfer->frlengths[0] = max_bulk; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -2478,14 +2478,14 @@ umass_t_cbi_data_write_callback(struct usb_xfer *xfer) xfer->timeout = sc->sc_transfer.data_timeout; if (xfer->flags.ext_buffer) { - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); } else { - usb2_copy_in(xfer->frbuffers, 0, + usbd_copy_in(xfer->frbuffers, 0, sc->sc_transfer.data_ptr, max_bulk); } xfer->frlengths[0] = max_bulk; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -2521,7 +2521,7 @@ umass_t_cbi_status_callback(struct usb_xfer *xfer) if (xfer->actlen < sizeof(sc->sbl)) { goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, &sc->sbl, sizeof(sc->sbl)); + usbd_copy_out(xfer->frbuffers, 0, &sc->sbl, sizeof(sc->sbl)); residue = (sc->sc_transfer.data_len - sc->sc_transfer.actlen); @@ -2585,12 +2585,12 @@ umass_t_cbi_status_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ DPRINTF(sc, UDMASS_CBI, "Failed to read CSW: %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); umass_tr_error(xfer); return; @@ -2976,7 +2976,7 @@ umass_cam_action(struct cam_sim *sim, union ccb *ccb) if (sc->sc_quirks & FLOPPY_SPEED) { cpi->base_transfer_speed = UMASS_FLOPPY_TRANSFER_SPEED; - } else if (usb2_get_speed(sc->sc_udev) == + } else if (usbd_get_speed(sc->sc_udev) == USB_SPEED_HIGH) { cpi->base_transfer_speed = UMASS_HIGH_TRANSFER_SPEED; @@ -3081,7 +3081,7 @@ umass_cam_poll(struct cam_sim *sim) DPRINTF(sc, UDMASS_SCSI, "CAM poll\n"); - usb2_do_poll(sc->sc_xfer, UMASS_T_MAX); + usbd_do_poll(sc->sc_xfer, UMASS_T_MAX); } diff --git a/sys/dev/usb/storage/urio.c b/sys/dev/usb/storage/urio.c index 1163b11..01502bb 100644 --- a/sys/dev/usb/storage/urio.c +++ b/sys/dev/usb/storage/urio.c @@ -209,7 +209,7 @@ urio_attach(device_t dev) struct urio_softc *sc = device_get_softc(dev); int error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_udev = uaa->device; @@ -218,16 +218,16 @@ urio_attach(device_t dev) snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", device_get_nameunit(dev)); - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, urio_config, URIO_T_MAX, sc, &sc->sc_mtx); if (error) { - DPRINTF("error=%s\n", usb2_errstr(error)); + DPRINTF("error=%s\n", usbd_errstr(error)); goto detach; } - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &urio_fifo_methods, &sc->sc_fifo, device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); @@ -252,14 +252,14 @@ urio_write_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: case USB_ST_SETUP: if (sc->sc_flags & URIO_FLAG_WRITE_STALL) { - usb2_transfer_start(sc->sc_xfer[URIO_T_WR_CS]); + usbd_transfer_start(sc->sc_xfer[URIO_T_WR_CS]); return; } - if (usb2_fifo_get_data(f, xfer->frbuffers, 0, + if (usb_fifo_get_data(f, xfer->frbuffers, 0, xfer->max_data_length, &actlen, 0)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -267,7 +267,7 @@ urio_write_callback(struct usb_xfer *xfer) if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ sc->sc_flags |= URIO_FLAG_WRITE_STALL; - usb2_transfer_start(sc->sc_xfer[URIO_T_WR_CS]); + usbd_transfer_start(sc->sc_xfer[URIO_T_WR_CS]); } return; } @@ -279,10 +279,10 @@ urio_write_clear_stall_callback(struct usb_xfer *xfer) struct urio_softc *sc = xfer->priv_sc; struct usb_xfer *xfer_other = sc->sc_xfer[URIO_T_WR]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); sc->sc_flags &= ~URIO_FLAG_WRITE_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -294,17 +294,17 @@ urio_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_fifo_put_data(f, xfer->frbuffers, 0, + usb_fifo_put_data(f, xfer->frbuffers, 0, xfer->actlen, 1); case USB_ST_SETUP: if (sc->sc_flags & URIO_FLAG_READ_STALL) { - usb2_transfer_start(sc->sc_xfer[URIO_T_RD_CS]); + usbd_transfer_start(sc->sc_xfer[URIO_T_RD_CS]); return; } - if (usb2_fifo_put_bytes_max(f) != 0) { + if (usb_fifo_put_bytes_max(f) != 0) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } return; @@ -312,7 +312,7 @@ urio_read_callback(struct usb_xfer *xfer) if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ sc->sc_flags |= URIO_FLAG_READ_STALL; - usb2_transfer_start(sc->sc_xfer[URIO_T_RD_CS]); + usbd_transfer_start(sc->sc_xfer[URIO_T_RD_CS]); } return; } @@ -324,10 +324,10 @@ urio_read_clear_stall_callback(struct usb_xfer *xfer) struct urio_softc *sc = xfer->priv_sc; struct usb_xfer *xfer_other = sc->sc_xfer[URIO_T_RD]; - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTF("stall cleared\n"); sc->sc_flags &= ~URIO_FLAG_READ_STALL; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -336,7 +336,7 @@ urio_start_read(struct usb_fifo *fifo) { struct urio_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[URIO_T_RD]); + usbd_transfer_start(sc->sc_xfer[URIO_T_RD]); } static void @@ -344,8 +344,8 @@ urio_stop_read(struct usb_fifo *fifo) { struct urio_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[URIO_T_RD_CS]); - usb2_transfer_stop(sc->sc_xfer[URIO_T_RD]); + usbd_transfer_stop(sc->sc_xfer[URIO_T_RD_CS]); + usbd_transfer_stop(sc->sc_xfer[URIO_T_RD]); } static void @@ -353,7 +353,7 @@ urio_start_write(struct usb_fifo *fifo) { struct urio_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[URIO_T_WR]); + usbd_transfer_start(sc->sc_xfer[URIO_T_WR]); } static void @@ -361,8 +361,8 @@ urio_stop_write(struct usb_fifo *fifo) { struct urio_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[URIO_T_WR_CS]); - usb2_transfer_stop(sc->sc_xfer[URIO_T_WR]); + usbd_transfer_stop(sc->sc_xfer[URIO_T_WR_CS]); + usbd_transfer_stop(sc->sc_xfer[URIO_T_WR]); } static int @@ -379,7 +379,7 @@ urio_open(struct usb_fifo *fifo, int fflags) sc->sc_flags |= URIO_FLAG_READ_STALL; mtx_unlock(&sc->sc_mtx); - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_xfer[URIO_T_RD]->max_data_length, URIO_IFQ_MAXLEN)) { return (ENOMEM); @@ -389,7 +389,7 @@ urio_open(struct usb_fifo *fifo, int fflags) /* clear stall first */ sc->sc_flags |= URIO_FLAG_WRITE_STALL; - if (usb2_fifo_alloc_buffer(fifo, + if (usb_fifo_alloc_buffer(fifo, sc->sc_xfer[URIO_T_WR]->max_data_length, URIO_IFQ_MAXLEN)) { return (ENOMEM); @@ -402,7 +402,7 @@ static void urio_close(struct usb_fifo *fifo, int fflags) { if (fflags & (FREAD | FWRITE)) { - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } } @@ -465,9 +465,9 @@ urio_detach(device_t dev) DPRINTF("\n"); - usb2_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo); - usb2_transfer_unsetup(sc->sc_xfer, URIO_T_MAX); + usbd_transfer_unsetup(sc->sc_xfer, URIO_T_MAX); mtx_destroy(&sc->sc_mtx); diff --git a/sys/dev/usb/storage/ustorage_fs.c b/sys/dev/usb/storage/ustorage_fs.c index 80dcb9b..2af5d66 100644 --- a/sys/dev/usb/storage/ustorage_fs.c +++ b/sys/dev/usb/storage/ustorage_fs.c @@ -325,7 +325,7 @@ ustorage_fs_probe(device_t dev) return (ENXIO); } /* Check for a standards compliant device */ - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); if ((id == NULL) || (id->bInterfaceClass != UICLASS_MASS) || (id->bInterfaceSubClass != UISUBCLASS_SCSI) || @@ -371,14 +371,14 @@ ustorage_fs_attach(device_t dev) sc->sc_lun[0].removable = 1; } - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "USTORAGE_FS lock", NULL, (MTX_DEF | MTX_RECURSE)); /* get interface index */ - id = usb2_get_interface_descriptor(uaa->iface); + id = usbd_get_interface_descriptor(uaa->iface); if (id == NULL) { device_printf(dev, "failed to get " "interface number\n"); @@ -386,12 +386,12 @@ ustorage_fs_attach(device_t dev) } sc->sc_iface_no = id->bInterfaceNumber; - err = usb2_transfer_setup(uaa->device, + err = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, sc->sc_xfer, ustorage_fs_bbb_config, USTORAGE_FS_T_BBB_MAX, sc, &sc->sc_mtx); if (err) { device_printf(dev, "could not setup required " - "transfers, %s\n", usb2_errstr(err)); + "transfers, %s\n", usbd_errstr(err)); goto detach; } /* start Mass Storage State Machine */ @@ -414,7 +414,7 @@ ustorage_fs_detach(device_t dev) /* teardown our statemachine */ - usb2_transfer_unsetup(sc->sc_xfer, USTORAGE_FS_T_BBB_MAX); + usbd_transfer_unsetup(sc->sc_xfer, USTORAGE_FS_T_BBB_MAX); mtx_destroy(&sc->sc_mtx); @@ -444,16 +444,16 @@ ustorage_fs_transfer_start(struct ustorage_fs_softc *sc, uint8_t xfer_index) { if (sc->sc_xfer[xfer_index]) { sc->sc_last_xfer_index = xfer_index; - usb2_transfer_start(sc->sc_xfer[xfer_index]); + usbd_transfer_start(sc->sc_xfer[xfer_index]); } } static void ustorage_fs_transfer_stop(struct ustorage_fs_softc *sc) { - usb2_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]); + usbd_transfer_stop(sc->sc_xfer[sc->sc_last_xfer_index]); mtx_unlock(&sc->sc_mtx); - usb2_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]); + usbd_transfer_drain(sc->sc_xfer[sc->sc_last_xfer_index]); mtx_lock(&sc->sc_mtx); } @@ -585,8 +585,8 @@ tr_setup: } xfer->frlengths[0] = sizeof(sc->sc_cbw); - usb2_set_frame_data(xfer, &sc->sc_cbw, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, &sc->sc_cbw, 0); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -654,7 +654,7 @@ tr_setup: xfer->flags.stall_pipe = 0; } xfer->frlengths[0] = max_bulk; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -708,8 +708,8 @@ tr_setup: } xfer->frlengths[0] = max_bulk; - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -767,8 +767,8 @@ tr_setup: } xfer->frlengths[0] = max_bulk; - usb2_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, sc->sc_transfer.data_ptr, 0); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -812,8 +812,8 @@ tr_setup: } xfer->frlengths[0] = sizeof(sc->sc_csw); - usb2_set_frame_data(xfer, &sc->sc_csw, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, &sc->sc_csw, 0); + usbd_transfer_submit(xfer); break; default: diff --git a/sys/dev/usb/template/usb_template.c b/sys/dev/usb/template/usb_template.c index 167d4ef..d4c192d 100644 --- a/sys/dev/usb/template/usb_template.c +++ b/sys/dev/usb/template/usb_template.c @@ -34,7 +34,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -54,50 +54,50 @@ MODULE_VERSION(usb_template, 1); /* function prototypes */ -static void usb2_make_raw_desc(struct usb_temp_setup *, const uint8_t *); -static void usb2_make_endpoint_desc(struct usb_temp_setup *, +static void usb_make_raw_desc(struct usb_temp_setup *, const uint8_t *); +static void usb_make_endpoint_desc(struct usb_temp_setup *, const struct usb_temp_endpoint_desc *); -static void usb2_make_interface_desc(struct usb_temp_setup *, +static void usb_make_interface_desc(struct usb_temp_setup *, const struct usb_temp_interface_desc *); -static void usb2_make_config_desc(struct usb_temp_setup *, +static void usb_make_config_desc(struct usb_temp_setup *, const struct usb_temp_config_desc *); -static void usb2_make_device_desc(struct usb_temp_setup *, +static void usb_make_device_desc(struct usb_temp_setup *, const struct usb_temp_device_desc *); -static uint8_t usb2_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t, +static uint8_t usb_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t, uint8_t); -static uint8_t usb2_hw_ep_find_match(struct usb_hw_ep_scratch *, +static uint8_t usb_hw_ep_find_match(struct usb_hw_ep_scratch *, struct usb_hw_ep_scratch_sub *, uint8_t); -static uint8_t usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t, +static uint8_t usb_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t, uint8_t); -static usb_error_t usb2_hw_ep_resolve(struct usb_device *, +static usb_error_t usb_hw_ep_resolve(struct usb_device *, 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 void *usb2_temp_get_qualifier_desc(struct usb_device *); -static void *usb2_temp_get_config_desc(struct usb_device *, uint16_t *, +static const struct usb_temp_device_desc *usb_temp_get_tdd(struct usb_device *); +static void *usb_temp_get_device_desc(struct usb_device *); +static void *usb_temp_get_qualifier_desc(struct usb_device *); +static void *usb_temp_get_config_desc(struct usb_device *, uint16_t *, uint8_t); -static const void *usb2_temp_get_string_desc(struct usb_device *, uint16_t, +static const void *usb_temp_get_string_desc(struct usb_device *, uint16_t, uint8_t); -static const void *usb2_temp_get_vendor_desc(struct usb_device *, +static const void *usb_temp_get_vendor_desc(struct usb_device *, const struct usb_device_request *); -static const void *usb2_temp_get_hub_desc(struct usb_device *); -static usb_error_t usb2_temp_get_desc(struct usb_device *, +static const void *usb_temp_get_hub_desc(struct usb_device *); +static usb_error_t usb_temp_get_desc(struct usb_device *, struct usb_device_request *, const void **, uint16_t *); static usb_error_t usb_temp_setup(struct usb_device *, const struct usb_temp_device_desc *); -static void usb2_temp_unsetup(struct usb_device *); -static usb_error_t usb2_temp_setup_by_index(struct usb_device *, +static void usb_temp_unsetup(struct usb_device *); +static usb_error_t usb_temp_setup_by_index(struct usb_device *, uint16_t index); -static void usb2_temp_init(void *); +static void usb_temp_init(void *); /*------------------------------------------------------------------------* - * usb2_make_raw_desc + * usb_make_raw_desc * * This function will insert a raw USB descriptor into the generated * USB configuration. *------------------------------------------------------------------------*/ static void -usb2_make_raw_desc(struct usb_temp_setup *temp, +usb_make_raw_desc(struct usb_temp_setup *temp, const uint8_t *raw) { void *dst; @@ -132,14 +132,14 @@ usb2_make_raw_desc(struct usb_temp_setup *temp, } /*------------------------------------------------------------------------* - * usb2_make_endpoint_desc + * usb_make_endpoint_desc * * This function will generate an USB endpoint descriptor from the * given USB template endpoint descriptor, which will be inserted into * the USB configuration. *------------------------------------------------------------------------*/ static void -usb2_make_endpoint_desc(struct usb_temp_setup *temp, +usb_make_endpoint_desc(struct usb_temp_setup *temp, const struct usb_temp_endpoint_desc *ted) { struct usb_endpoint_descriptor *ed; @@ -158,7 +158,7 @@ usb2_make_endpoint_desc(struct usb_temp_setup *temp, rd = ted->ppRawDesc; if (rd) { while (*rd) { - usb2_make_raw_desc(temp, *rd); + usb_make_raw_desc(temp, *rd); rd++; } } @@ -232,14 +232,14 @@ usb2_make_endpoint_desc(struct usb_temp_setup *temp, } /*------------------------------------------------------------------------* - * usb2_make_interface_desc + * usb_make_interface_desc * * This function will generate an USB interface descriptor from the * given USB template interface descriptor, which will be inserted * into the USB configuration. *------------------------------------------------------------------------*/ static void -usb2_make_interface_desc(struct usb_temp_setup *temp, +usb_make_interface_desc(struct usb_temp_setup *temp, const struct usb_temp_interface_desc *tid) { struct usb_interface_descriptor *id; @@ -267,7 +267,7 @@ usb2_make_interface_desc(struct usb_temp_setup *temp, if (rd) { while (*rd) { - usb2_make_raw_desc(temp, *rd); + usb_make_raw_desc(temp, *rd); rd++; } } @@ -280,7 +280,7 @@ usb2_make_interface_desc(struct usb_temp_setup *temp, ted = tid->ppEndpoints; if (ted) { while (*ted) { - usb2_make_endpoint_desc(temp, *ted); + usb_make_endpoint_desc(temp, *ted); ted++; } } @@ -303,14 +303,14 @@ usb2_make_interface_desc(struct usb_temp_setup *temp, } /*------------------------------------------------------------------------* - * usb2_make_config_desc + * usb_make_config_desc * * This function will generate an USB config descriptor from the given * USB template config descriptor, which will be inserted into the USB * configuration. *------------------------------------------------------------------------*/ static void -usb2_make_config_desc(struct usb_temp_setup *temp, +usb_make_config_desc(struct usb_temp_setup *temp, const struct usb_temp_config_desc *tcd) { struct usb_config_descriptor *cd; @@ -332,7 +332,7 @@ usb2_make_config_desc(struct usb_temp_setup *temp, tid = tcd->ppIfaceDesc; if (tid) { while (*tid) { - usb2_make_interface_desc(temp, *tid); + usb_make_interface_desc(temp, *tid); tid++; } } @@ -365,13 +365,13 @@ usb2_make_config_desc(struct usb_temp_setup *temp, } /*------------------------------------------------------------------------* - * usb2_make_device_desc + * usb_make_device_desc * * This function will generate an USB device descriptor from the * given USB template device descriptor. *------------------------------------------------------------------------*/ static void -usb2_make_device_desc(struct usb_temp_setup *temp, +usb_make_device_desc(struct usb_temp_setup *temp, const struct usb_temp_device_desc *tdd) { struct usb_temp_data *utd; @@ -389,7 +389,7 @@ usb2_make_device_desc(struct usb_temp_setup *temp, tcd = tdd->ppConfigDesc; if (tcd) { while (*tcd) { - usb2_make_config_desc(temp, *tcd); + usb_make_config_desc(temp, *tcd); temp->bConfigurationValue++; tcd++; } @@ -460,14 +460,14 @@ usb2_make_device_desc(struct usb_temp_setup *temp, } /*------------------------------------------------------------------------* - * usb2_hw_ep_match + * usb_hw_ep_match * * Return values: * 0: The endpoint profile does not match the criterias * Else: The endpoint profile matches the criterias *------------------------------------------------------------------------*/ static uint8_t -usb2_hw_ep_match(const struct usb_hw_ep_profile *pf, +usb_hw_ep_match(const struct usb_hw_ep_profile *pf, uint8_t ep_type, uint8_t ep_dir_in) { if (ep_type == UE_CONTROL) { @@ -486,7 +486,7 @@ usb2_hw_ep_match(const struct usb_hw_ep_profile *pf, } /*------------------------------------------------------------------------* - * usb2_hw_ep_find_match + * usb_hw_ep_find_match * * This function is used to find the best matching endpoint profile * for and endpoint belonging to an USB descriptor. @@ -496,7 +496,7 @@ usb2_hw_ep_match(const struct usb_hw_ep_profile *pf, * Else: Failure. No match. *------------------------------------------------------------------------*/ static uint8_t -usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues, +usb_hw_ep_find_match(struct usb_hw_ep_scratch *ues, struct usb_hw_ep_scratch_sub *ep, uint8_t is_simplex) { const struct usb_hw_ep_profile *pf; @@ -555,7 +555,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues, continue; } /* check if HW endpoint matches */ - if (!usb2_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { + if (!usb_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { /* mismatch */ continue; } @@ -601,7 +601,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues, } /*------------------------------------------------------------------------* - * usb2_hw_ep_get_needs + * usb_hw_ep_get_needs * * This function will figure out the type and number of endpoints * which are needed for an USB configuration. @@ -611,7 +611,7 @@ usb2_hw_ep_find_match(struct usb_hw_ep_scratch *ues, * Else: Failure. *------------------------------------------------------------------------*/ static uint8_t -usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *ues, +usb_hw_ep_get_needs(struct usb_hw_ep_scratch *ues, uint8_t ep_type, uint8_t is_complete) { const struct usb_hw_ep_profile *pf; @@ -632,11 +632,11 @@ usb2_hw_ep_get_needs(struct usb_hw_ep_scratch *ues, ep_end = ues->ep + USB_EP_MAX; ep_max = ues->ep_max; desc = NULL; - speed = usb2_get_speed(ues->udev); + speed = usbd_get_speed(ues->udev); repeat: - while ((desc = usb2_desc_foreach(ues->cd, desc))) { + while ((desc = usb_desc_foreach(ues->cd, desc))) { if ((desc->bDescriptorType == UDESC_INTERFACE) && (desc->bLength >= sizeof(*id))) { @@ -771,7 +771,7 @@ handle_endpoint_desc: } /*------------------------------------------------------------------------* - * usb2_hw_ep_resolve + * usb_hw_ep_resolve * * This function will try to resolve endpoint requirements by the * given endpoint profiles that the USB hardware reports. @@ -781,7 +781,7 @@ handle_endpoint_desc: * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t -usb2_hw_ep_resolve(struct usb_device *udev, +usb_hw_ep_resolve(struct usb_device *udev, struct usb_descriptor *desc) { struct usb_hw_ep_scratch *ues; @@ -812,7 +812,7 @@ usb2_hw_ep_resolve(struct usb_device *udev, if (pf == NULL) { return (USB_ERR_INVAL); } - if (!usb2_hw_ep_match(pf, UE_CONTROL, 0)) { + if (!usb_hw_ep_match(pf, UE_CONTROL, 0)) { DPRINTFN(0, "Endpoint 0 does not " "support control\n"); return (USB_ERR_INVAL); @@ -868,10 +868,10 @@ usb2_hw_ep_resolve(struct usb_device *udev, /* Get all the endpoints we need */ - if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || - usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || - usb2_hw_ep_get_needs(ues, UE_CONTROL, 0) || - usb2_hw_ep_get_needs(ues, UE_BULK, 0)) { + if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || + usb_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || + usb_hw_ep_get_needs(ues, UE_CONTROL, 0) || + usb_hw_ep_get_needs(ues, UE_BULK, 0)) { DPRINTFN(0, "Could not get needs\n"); return (USB_ERR_INVAL); } @@ -883,8 +883,8 @@ usb2_hw_ep_resolve(struct usb_device *udev, * First try to use a simplex endpoint. * Then try to use a duplex endpoint. */ - if (usb2_hw_ep_find_match(ues, ep, 1) && - usb2_hw_ep_find_match(ues, ep, 0)) { + if (usb_hw_ep_find_match(ues, ep, 1) && + usb_hw_ep_find_match(ues, ep, 0)) { DPRINTFN(0, "Could not find match\n"); return (USB_ERR_INVAL); } @@ -895,10 +895,10 @@ usb2_hw_ep_resolve(struct usb_device *udev, /* Update all endpoint addresses */ - if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || - usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || - usb2_hw_ep_get_needs(ues, UE_CONTROL, 1) || - usb2_hw_ep_get_needs(ues, UE_BULK, 1)) { + if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || + usb_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || + usb_hw_ep_get_needs(ues, UE_CONTROL, 1) || + usb_hw_ep_get_needs(ues, UE_BULK, 1)) { DPRINTFN(0, "Could not update endpoint address\n"); return (USB_ERR_INVAL); } @@ -906,37 +906,37 @@ usb2_hw_ep_resolve(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_temp_get_tdd + * usb_temp_get_tdd * * Returns: * NULL: No USB template device descriptor found. * Else: Pointer to the USB template device descriptor. *------------------------------------------------------------------------*/ static const struct usb_temp_device_desc * -usb2_temp_get_tdd(struct usb_device *udev) +usb_temp_get_tdd(struct usb_device *udev) { - if (udev->usb2_template_ptr == NULL) { + if (udev->usb_template_ptr == NULL) { return (NULL); } - return (udev->usb2_template_ptr->tdd); + return (udev->usb_template_ptr->tdd); } /*------------------------------------------------------------------------* - * usb2_temp_get_device_desc + * usb_temp_get_device_desc * * Returns: * NULL: No USB device descriptor found. * Else: Pointer to USB device descriptor. *------------------------------------------------------------------------*/ static void * -usb2_temp_get_device_desc(struct usb_device *udev) +usb_temp_get_device_desc(struct usb_device *udev) { struct usb_device_descriptor *dd; - if (udev->usb2_template_ptr == NULL) { + if (udev->usb_template_ptr == NULL) { return (NULL); } - dd = &udev->usb2_template_ptr->udd; + dd = &udev->usb_template_ptr->udd; if (dd->bDescriptorType != UDESC_DEVICE) { /* sanity check failed */ return (NULL); @@ -945,21 +945,21 @@ usb2_temp_get_device_desc(struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_temp_get_qualifier_desc + * usb_temp_get_qualifier_desc * * Returns: * NULL: No USB device_qualifier descriptor found. * Else: Pointer to USB device_qualifier descriptor. *------------------------------------------------------------------------*/ static void * -usb2_temp_get_qualifier_desc(struct usb_device *udev) +usb_temp_get_qualifier_desc(struct usb_device *udev) { struct usb_device_qualifier *dq; - if (udev->usb2_template_ptr == NULL) { + if (udev->usb_template_ptr == NULL) { return (NULL); } - dq = &udev->usb2_template_ptr->udq; + dq = &udev->usb_template_ptr->udq; if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) { /* sanity check failed */ return (NULL); @@ -968,25 +968,25 @@ usb2_temp_get_qualifier_desc(struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_temp_get_config_desc + * usb_temp_get_config_desc * * Returns: * NULL: No USB config descriptor found. * Else: Pointer to USB config descriptor having index "index". *------------------------------------------------------------------------*/ static void * -usb2_temp_get_config_desc(struct usb_device *udev, +usb_temp_get_config_desc(struct usb_device *udev, uint16_t *pLength, uint8_t index) { struct usb_device_descriptor *dd; struct usb_config_descriptor *cd; uint16_t temp; - if (udev->usb2_template_ptr == NULL) { + if (udev->usb_template_ptr == NULL) { return (NULL); } - dd = &udev->usb2_template_ptr->udd; - cd = (void *)(udev->usb2_template_ptr + 1); + dd = &udev->usb_template_ptr->udd; + cd = (void *)(udev->usb_template_ptr + 1); if (index >= dd->bNumConfigurations) { /* out of range */ @@ -1008,19 +1008,19 @@ usb2_temp_get_config_desc(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_temp_get_vendor_desc + * usb_temp_get_vendor_desc * * Returns: * NULL: No vendor descriptor found. * Else: Pointer to a vendor descriptor. *------------------------------------------------------------------------*/ static const void * -usb2_temp_get_vendor_desc(struct usb_device *udev, +usb_temp_get_vendor_desc(struct usb_device *udev, const struct usb_device_request *req) { const struct usb_temp_device_desc *tdd; - tdd = usb2_temp_get_tdd(udev); + tdd = usb_temp_get_tdd(udev); if (tdd == NULL) { return (NULL); } @@ -1031,19 +1031,19 @@ usb2_temp_get_vendor_desc(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_temp_get_string_desc + * usb_temp_get_string_desc * * Returns: * NULL: No string descriptor found. * Else: Pointer to a string descriptor. *------------------------------------------------------------------------*/ static const void * -usb2_temp_get_string_desc(struct usb_device *udev, +usb_temp_get_string_desc(struct usb_device *udev, uint16_t lang_id, uint8_t string_index) { const struct usb_temp_device_desc *tdd; - tdd = usb2_temp_get_tdd(udev); + tdd = usb_temp_get_tdd(udev); if (tdd == NULL) { return (NULL); } @@ -1054,26 +1054,26 @@ usb2_temp_get_string_desc(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_temp_get_hub_desc + * usb_temp_get_hub_desc * * Returns: * NULL: No USB HUB descriptor found. * Else: Pointer to a USB HUB descriptor. *------------------------------------------------------------------------*/ static const void * -usb2_temp_get_hub_desc(struct usb_device *udev) +usb_temp_get_hub_desc(struct usb_device *udev) { return (NULL); /* needs to be implemented */ } /*------------------------------------------------------------------------* - * usb2_temp_get_desc + * usb_temp_get_desc * * This function is a demultiplexer for local USB device side control * endpoint requests. *------------------------------------------------------------------------*/ static usb_error_t -usb2_temp_get_desc(struct usb_device *udev, struct usb_device_request *req, +usb_temp_get_desc(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength) { const uint8_t *buf; @@ -1101,7 +1101,7 @@ usb2_temp_get_desc(struct usb_device *udev, struct usb_device_request *req, break; case UT_READ_VENDOR_DEVICE: case UT_READ_VENDOR_OTHER: - buf = usb2_temp_get_vendor_desc(udev, req); + buf = usb_temp_get_vendor_desc(udev, req); goto tr_valid; default: goto tr_stalled; @@ -1113,7 +1113,7 @@ tr_handle_get_descriptor: if (req->wValue[0]) { goto tr_stalled; } - buf = usb2_temp_get_device_desc(udev); + buf = usb_temp_get_device_desc(udev); goto tr_valid; case UDESC_DEVICE_QUALIFIER: if (udev->speed != USB_SPEED_HIGH) { @@ -1122,18 +1122,18 @@ tr_handle_get_descriptor: if (req->wValue[0]) { goto tr_stalled; } - buf = usb2_temp_get_qualifier_desc(udev); + buf = usb_temp_get_qualifier_desc(udev); goto tr_valid; case UDESC_OTHER_SPEED_CONFIGURATION: if (udev->speed != USB_SPEED_HIGH) { goto tr_stalled; } case UDESC_CONFIG: - buf = usb2_temp_get_config_desc(udev, + buf = usb_temp_get_config_desc(udev, &len, req->wValue[0]); goto tr_valid; case UDESC_STRING: - buf = usb2_temp_get_string_desc(udev, + buf = usb_temp_get_string_desc(udev, UGETW(req->wIndex), req->wValue[0]); goto tr_valid; default: @@ -1145,7 +1145,7 @@ tr_handle_get_class_descriptor: if (req->wValue[0]) { goto tr_stalled; } - buf = usb2_temp_get_hub_desc(udev); + buf = usb_temp_get_hub_desc(udev); goto tr_valid; tr_valid: @@ -1197,7 +1197,7 @@ usb_temp_setup(struct usb_device *udev, /* first pass */ - usb2_make_device_desc(uts, tdd); + usb_make_device_desc(uts, tdd); if (uts->err) { /* some error happened */ @@ -1217,12 +1217,12 @@ usb_temp_setup(struct usb_device *udev, uts->size = 0; - usb2_make_device_desc(uts, tdd); + usb_make_device_desc(uts, tdd); /* * Store a pointer to our descriptors: */ - udev->usb2_template_ptr = uts->buf; + udev->usb_template_ptr = uts->buf; if (uts->err) { /* some error happened during second pass */ @@ -1231,66 +1231,66 @@ usb_temp_setup(struct usb_device *udev, /* * Resolve all endpoint addresses ! */ - buf = usb2_temp_get_device_desc(udev); - uts->err = usb2_hw_ep_resolve(udev, buf); + buf = usb_temp_get_device_desc(udev); + uts->err = usb_hw_ep_resolve(udev, buf); if (uts->err) { DPRINTFN(0, "Could not resolve endpoints for " "Device Descriptor, error = %s\n", - usb2_errstr(uts->err)); + usbd_errstr(uts->err)); goto error; } for (n = 0;; n++) { - buf = usb2_temp_get_config_desc(udev, NULL, n); + buf = usb_temp_get_config_desc(udev, NULL, n); if (buf == NULL) { break; } - uts->err = usb2_hw_ep_resolve(udev, buf); + uts->err = usb_hw_ep_resolve(udev, buf); if (uts->err) { DPRINTFN(0, "Could not resolve endpoints for " "Config Descriptor %u, error = %s\n", n, - usb2_errstr(uts->err)); + usbd_errstr(uts->err)); goto error; } } return (uts->err); error: - usb2_temp_unsetup(udev); + usb_temp_unsetup(udev); return (uts->err); } /*------------------------------------------------------------------------* - * usb2_temp_unsetup + * usb_temp_unsetup * * This function frees any memory associated with the currently * setup template, if any. *------------------------------------------------------------------------*/ static void -usb2_temp_unsetup(struct usb_device *udev) +usb_temp_unsetup(struct usb_device *udev) { - if (udev->usb2_template_ptr) { + if (udev->usb_template_ptr) { - free(udev->usb2_template_ptr, M_USB); + free(udev->usb_template_ptr, M_USB); - udev->usb2_template_ptr = NULL; + udev->usb_template_ptr = NULL; } } static usb_error_t -usb2_temp_setup_by_index(struct usb_device *udev, uint16_t index) +usb_temp_setup_by_index(struct usb_device *udev, uint16_t index) { usb_error_t err; switch (index) { case 0: - err = usb_temp_setup(udev, &usb2_template_msc); + err = usb_temp_setup(udev, &usb_template_msc); break; case 1: - err = usb_temp_setup(udev, &usb2_template_cdce); + err = usb_temp_setup(udev, &usb_template_cdce); break; case 2: - err = usb_temp_setup(udev, &usb2_template_mtp); + err = usb_temp_setup(udev, &usb_template_mtp); break; default: return (USB_ERR_INVAL); @@ -1300,13 +1300,13 @@ usb2_temp_setup_by_index(struct usb_device *udev, uint16_t index) } static void -usb2_temp_init(void *arg) +usb_temp_init(void *arg) { /* register our functions */ - usb2_temp_get_desc_p = &usb2_temp_get_desc; - usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index; - usb2_temp_unsetup_p = &usb2_temp_unsetup; + usb_temp_get_desc_p = &usb_temp_get_desc; + usb_temp_setup_by_index_p = &usb_temp_setup_by_index; + usb_temp_unsetup_p = &usb_temp_unsetup; } -SYSINIT(usb2_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb2_temp_init, NULL); -SYSUNINIT(usb2_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb2_temp_unload, NULL); +SYSINIT(usb_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_temp_init, NULL); +SYSUNINIT(usb_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb_temp_unload, NULL); diff --git a/sys/dev/usb/template/usb_template.h b/sys/dev/usb/template/usb_template.h index 60f733b..cc9ca0c 100644 --- a/sys/dev/usb/template/usb_template.h +++ b/sys/dev/usb/template/usb_template.h @@ -30,8 +30,8 @@ #ifndef _USB_TEMPLATE_H_ #define _USB_TEMPLATE_H_ -typedef const void *(usb2_temp_get_string_desc_t)(uint16_t lang_id, uint8_t string_index); -typedef const void *(usb2_temp_get_vendor_desc_t)(const struct usb_device_request *req); +typedef const void *(usb_temp_get_string_desc_t)(uint16_t lang_id, uint8_t string_index); +typedef const void *(usb_temp_get_vendor_desc_t)(const struct usb_device_request *req); struct usb_temp_packet_size { uint16_t mps[USB_SPEED_MAX]; @@ -72,8 +72,8 @@ struct usb_temp_config_desc { }; struct usb_temp_device_desc { - usb2_temp_get_string_desc_t *getStringDesc; - usb2_temp_get_vendor_desc_t *getVendorDesc; + usb_temp_get_string_desc_t *getStringDesc; + usb_temp_get_vendor_desc_t *getVendorDesc; const struct usb_temp_config_desc **ppConfigDesc; uint16_t idVendor; uint16_t idProduct; @@ -94,9 +94,9 @@ struct usb_temp_data { /* prototypes */ -extern const struct usb_temp_device_desc usb2_template_cdce; -extern const struct usb_temp_device_desc usb2_template_msc; /* Mass Storage Class */ -extern const struct usb_temp_device_desc usb2_template_mtp; /* Message Transfer +extern const struct usb_temp_device_desc usb_template_cdce; +extern const struct usb_temp_device_desc usb_template_msc; /* Mass Storage Class */ +extern const struct usb_temp_device_desc usb_template_mtp; /* Message Transfer * Protocol */ #endif /* _USB_TEMPLATE_H_ */ diff --git a/sys/dev/usb/template/usb_template_cdce.c b/sys/dev/usb/template/usb_template_cdce.c index b8e0f8a..f648dd8 100644 --- a/sys/dev/usb/template/usb_template_cdce.c +++ b/sys/dev/usb/template/usb_template_cdce.c @@ -116,7 +116,7 @@ USB_MAKE_STRING_DESC(STRING_ETH_SERIAL, string_eth_serial); /* prototypes */ -static usb2_temp_get_string_desc_t eth_get_string_desc; +static usb_temp_get_string_desc_t eth_get_string_desc; static const struct usb_cdc_union_descriptor eth_union_desc = { .bLength = sizeof(eth_union_desc), @@ -244,7 +244,7 @@ static const struct usb_temp_config_desc *eth_configs[] = { NULL, }; -const struct usb_temp_device_desc usb2_template_cdce = { +const struct usb_temp_device_desc usb_template_cdce = { .getStringDesc = ð_get_string_desc, .ppConfigDesc = eth_configs, .idVendor = 0x0001, diff --git a/sys/dev/usb/template/usb_template_msc.c b/sys/dev/usb/template/usb_template_msc.c index 8f2e7ba..b42cdb6 100644 --- a/sys/dev/usb/template/usb_template_msc.c +++ b/sys/dev/usb/template/usb_template_msc.c @@ -95,7 +95,7 @@ USB_MAKE_STRING_DESC(STRING_MSC_SERIAL, string_msc_serial); /* prototypes */ -static usb2_temp_get_string_desc_t msc_get_string_desc; +static usb_temp_get_string_desc_t msc_get_string_desc; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, @@ -153,7 +153,7 @@ static const struct usb_temp_config_desc *msc_configs[] = { NULL, }; -const struct usb_temp_device_desc usb2_template_msc = { +const struct usb_temp_device_desc usb_template_msc = { .getStringDesc = &msc_get_string_desc, .ppConfigDesc = msc_configs, .idVendor = 0x0001, diff --git a/sys/dev/usb/template/usb_template_mtp.c b/sys/dev/usb/template/usb_template_mtp.c index 1cb694f..acc088a 100644 --- a/sys/dev/usb/template/usb_template_mtp.c +++ b/sys/dev/usb/template/usb_template_mtp.c @@ -100,8 +100,8 @@ USB_MAKE_STRING_DESC(STRING_MTP_SERIAL, string_mtp_serial); /* prototypes */ -static usb2_temp_get_string_desc_t mtp_get_string_desc; -static usb2_temp_get_vendor_desc_t mtp_get_vendor_desc; +static usb_temp_get_string_desc_t mtp_get_string_desc; +static usb_temp_get_vendor_desc_t mtp_get_vendor_desc; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, @@ -171,7 +171,7 @@ static const struct usb_temp_config_desc *mtp_configs[] = { NULL, }; -const struct usb_temp_device_desc usb2_template_mtp = { +const struct usb_temp_device_desc usb_template_mtp = { .getStringDesc = &mtp_get_string_desc, .getVendorDesc = &mtp_get_vendor_desc, .ppConfigDesc = mtp_configs, diff --git a/sys/dev/usb/usb_busdma.c b/sys/dev/usb/usb_busdma.c index 0059303..48fb603 100644 --- a/sys/dev/usb/usb_busdma.c +++ b/sys/dev/usb/usb_busdma.c @@ -28,7 +28,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -42,23 +42,23 @@ #include #if USB_HAVE_BUSDMA -static void usb2_dma_tag_create(struct usb_dma_tag *, usb_size_t, usb_size_t); -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); -static void usb2_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int); -static void usb2_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int, +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); +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, uint8_t); #endif /*------------------------------------------------------------------------* - * usb2_get_page - lookup DMA-able memory for the given offset + * usbd_get_page - lookup DMA-able memory for the given offset * * NOTE: Only call this function when the "page_cache" structure has * been properly initialized ! *------------------------------------------------------------------------*/ void -usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset, +usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset, struct usb_page_search *res) { struct usb_page *page; @@ -111,17 +111,17 @@ usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset, } /*------------------------------------------------------------------------* - * usb2_copy_in - copy directly to DMA-able memory + * usbd_copy_in - copy directly to DMA-able memory *------------------------------------------------------------------------*/ void -usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, +usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len) { struct usb_page_search buf_res; while (len != 0) { - usb2_get_page(cache, offset, &buf_res); + usbd_get_page(cache, offset, &buf_res); if (buf_res.length > len) { buf_res.length = len; @@ -135,7 +135,7 @@ usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, } /*------------------------------------------------------------------------* - * usb2_copy_in_user - copy directly to DMA-able memory from userland + * usbd_copy_in_user - copy directly to DMA-able memory from userland * * Return values: * 0: Success @@ -143,7 +143,7 @@ usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, *------------------------------------------------------------------------*/ #if USB_HAVE_USER_IO int -usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, +usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len) { struct usb_page_search buf_res; @@ -151,7 +151,7 @@ usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, while (len != 0) { - usb2_get_page(cache, offset, &buf_res); + usbd_get_page(cache, offset, &buf_res); if (buf_res.length > len) { buf_res.length = len; @@ -169,41 +169,41 @@ usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, #endif /*------------------------------------------------------------------------* - * usb2_m_copy_in - copy a mbuf chain directly into DMA-able memory + * usbd_m_copy_in - copy a mbuf chain directly into DMA-able memory *------------------------------------------------------------------------*/ #if USB_HAVE_MBUF -struct usb2_m_copy_in_arg { +struct usb_m_copy_in_arg { struct usb_page_cache *cache; usb_frlength_t dst_offset; }; static int -usb2_m_copy_in_cb(void *arg, void *src, uint32_t count) +usbd_m_copy_in_cb(void *arg, void *src, uint32_t count) { - register struct usb2_m_copy_in_arg *ua = arg; + register struct usb_m_copy_in_arg *ua = arg; - usb2_copy_in(ua->cache, ua->dst_offset, src, count); + usbd_copy_in(ua->cache, ua->dst_offset, src, count); ua->dst_offset += count; return (0); } void -usb2_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, +usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len) { - struct usb2_m_copy_in_arg arg = {cache, dst_offset}; + struct usb_m_copy_in_arg arg = {cache, dst_offset}; int error; - error = m_apply(m, src_offset, src_len, &usb2_m_copy_in_cb, &arg); + error = m_apply(m, src_offset, src_len, &usbd_m_copy_in_cb, &arg); } #endif /*------------------------------------------------------------------------* - * usb2_uiomove - factored out code + * usb_uiomove - factored out code *------------------------------------------------------------------------*/ #if USB_HAVE_USER_IO int -usb2_uiomove(struct usb_page_cache *pc, struct uio *uio, +usb_uiomove(struct usb_page_cache *pc, struct uio *uio, usb_frlength_t pc_offset, usb_frlength_t len) { struct usb_page_search res; @@ -211,7 +211,7 @@ usb2_uiomove(struct usb_page_cache *pc, struct uio *uio, while (len != 0) { - usb2_get_page(pc, pc_offset, &res); + usbd_get_page(pc, pc_offset, &res); if (res.length > len) { res.length = len; @@ -233,17 +233,17 @@ usb2_uiomove(struct usb_page_cache *pc, struct uio *uio, #endif /*------------------------------------------------------------------------* - * usb2_copy_out - copy directly from DMA-able memory + * usbd_copy_out - copy directly from DMA-able memory *------------------------------------------------------------------------*/ void -usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, +usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len) { struct usb_page_search res; while (len != 0) { - usb2_get_page(cache, offset, &res); + usbd_get_page(cache, offset, &res); if (res.length > len) { res.length = len; @@ -257,7 +257,7 @@ usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, } /*------------------------------------------------------------------------* - * usb2_copy_out_user - copy directly from DMA-able memory to userland + * usbd_copy_out_user - copy directly from DMA-able memory to userland * * Return values: * 0: Success @@ -265,7 +265,7 @@ usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, *------------------------------------------------------------------------*/ #if USB_HAVE_USER_IO int -usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, +usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len) { struct usb_page_search res; @@ -273,7 +273,7 @@ usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, while (len != 0) { - usb2_get_page(cache, offset, &res); + usbd_get_page(cache, offset, &res); if (res.length > len) { res.length = len; @@ -291,17 +291,17 @@ usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, #endif /*------------------------------------------------------------------------* - * usb2_bzero - zero DMA-able memory + * usbd_frame_zero - zero DMA-able memory *------------------------------------------------------------------------*/ void -usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset, +usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset, usb_frlength_t len) { struct usb_page_search res; while (len != 0) { - usb2_get_page(cache, offset, &res); + usbd_get_page(cache, offset, &res); if (res.length > len) { res.length = len; @@ -316,22 +316,22 @@ usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset, #if USB_HAVE_BUSDMA /*------------------------------------------------------------------------* - * usb2_dma_lock_cb - dummy callback + * usb_dma_lock_cb - dummy callback *------------------------------------------------------------------------*/ static void -usb2_dma_lock_cb(void *arg, bus_dma_lock_op_t op) +usb_dma_lock_cb(void *arg, bus_dma_lock_op_t op) { /* we use "mtx_owned()" instead of this function */ } /*------------------------------------------------------------------------* - * usb2_dma_tag_create - allocate a DMA tag + * usb_dma_tag_create - allocate a DMA tag * * NOTE: If the "align" parameter has a value of 1 the DMA-tag will * allow multi-segment mappings. Else all mappings are single-segment. *------------------------------------------------------------------------*/ static void -usb2_dma_tag_create(struct usb_dma_tag *udt, +usb_dma_tag_create(struct usb_dma_tag *udt, usb_size_t size, usb_size_t align) { bus_dma_tag_t tag; @@ -350,7 +350,7 @@ usb2_dma_tag_create(struct usb_dma_tag *udt, /* maxsegsz */ (align == 1) ? USB_PAGE_SIZE : size, /* flags */ BUS_DMA_KEEP_PG_OFFSET, - /* lockfn */ &usb2_dma_lock_cb, + /* lockfn */ &usb_dma_lock_cb, /* lockarg */ NULL, &tag)) { tag = NULL; @@ -359,39 +359,39 @@ usb2_dma_tag_create(struct usb_dma_tag *udt, } /*------------------------------------------------------------------------* - * usb2_dma_tag_free - free a DMA tag + * usb_dma_tag_free - free a DMA tag *------------------------------------------------------------------------*/ static void -usb2_dma_tag_destroy(struct usb_dma_tag *udt) +usb_dma_tag_destroy(struct usb_dma_tag *udt) { bus_dma_tag_destroy(udt->tag); } /*------------------------------------------------------------------------* - * usb2_pc_alloc_mem_cb - BUS-DMA callback function + * usb_pc_alloc_mem_cb - BUS-DMA callback function *------------------------------------------------------------------------*/ static void -usb2_pc_alloc_mem_cb(void *arg, bus_dma_segment_t *segs, +usb_pc_alloc_mem_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) { - usb2_pc_common_mem_cb(arg, segs, nseg, error, 0); + usb_pc_common_mem_cb(arg, segs, nseg, error, 0); } /*------------------------------------------------------------------------* - * usb2_pc_load_mem_cb - BUS-DMA callback function + * usb_pc_load_mem_cb - BUS-DMA callback function *------------------------------------------------------------------------*/ static void -usb2_pc_load_mem_cb(void *arg, bus_dma_segment_t *segs, +usb_pc_load_mem_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) { - usb2_pc_common_mem_cb(arg, segs, nseg, error, 1); + usb_pc_common_mem_cb(arg, segs, nseg, error, 1); } /*------------------------------------------------------------------------* - * usb2_pc_common_mem_cb - BUS-DMA callback function + * usb_pc_common_mem_cb - BUS-DMA callback function *------------------------------------------------------------------------*/ static void -usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs, +usb_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error, uint8_t isload) { struct usb_dma_parent_tag *uptag; @@ -452,14 +452,14 @@ done: } /*------------------------------------------------------------------------* - * usb2_pc_alloc_mem - allocate DMA'able memory + * usb_pc_alloc_mem - allocate DMA'able memory * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ uint8_t -usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, +usb_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, usb_size_t size, usb_size_t align) { struct usb_dma_parent_tag *uptag; @@ -505,7 +505,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, #endif } /* get the correct DMA tag */ - utag = usb2_dma_tag_find(uptag, size, align); + utag = usb_dma_tag_find(uptag, size, align); if (utag == NULL) { goto error; } @@ -527,7 +527,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, /* load memory into DMA */ err = bus_dmamap_load( - utag->tag, map, ptr, size, &usb2_pc_alloc_mem_cb, + utag->tag, map, ptr, size, &usb_pc_alloc_mem_cb, pc, (BUS_DMA_WAITOK | BUS_DMA_COHERENT)); if (err == EINPROGRESS) { @@ -542,7 +542,7 @@ usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, } bzero(ptr, size); - usb2_pc_cpu_flush(pc); + usb_pc_cpu_flush(pc); return (0); @@ -558,12 +558,12 @@ error: } /*------------------------------------------------------------------------* - * usb2_pc_free_mem - free DMA memory + * usb_pc_free_mem - free DMA memory * * This function is NULL safe. *------------------------------------------------------------------------*/ void -usb2_pc_free_mem(struct usb_page_cache *pc) +usb_pc_free_mem(struct usb_page_cache *pc) { if (pc && pc->buffer) { @@ -576,14 +576,14 @@ usb2_pc_free_mem(struct usb_page_cache *pc) } /*------------------------------------------------------------------------* - * usb2_pc_load_mem - load virtual memory into DMA + * usb_pc_load_mem - load virtual memory into DMA * * Return values: * 0: Success * Else: Error *------------------------------------------------------------------------*/ uint8_t -usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync) +usb_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync) { /* setup page cache */ pc->page_offset_buf = 0; @@ -610,7 +610,7 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync) */ err = bus_dmamap_load( pc->tag, pc->map, pc->buffer, size, - &usb2_pc_alloc_mem_cb, pc, BUS_DMA_WAITOK); + &usb_pc_alloc_mem_cb, pc, BUS_DMA_WAITOK); if (err == EINPROGRESS) { cv_wait(uptag->cv, uptag->mtx); err = 0; @@ -632,7 +632,7 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync) */ if (bus_dmamap_load( pc->tag, pc->map, pc->buffer, size, - &usb2_pc_load_mem_cb, pc, BUS_DMA_WAITOK)) { + &usb_pc_load_mem_cb, pc, BUS_DMA_WAITOK)) { } } } else { @@ -649,10 +649,10 @@ usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, uint8_t sync) } /*------------------------------------------------------------------------* - * usb2_pc_cpu_invalidate - invalidate CPU cache + * usb_pc_cpu_invalidate - invalidate CPU cache *------------------------------------------------------------------------*/ void -usb2_pc_cpu_invalidate(struct usb_page_cache *pc) +usb_pc_cpu_invalidate(struct usb_page_cache *pc) { if (pc->page_offset_end == pc->page_offset_buf) { /* nothing has been loaded into this page cache! */ @@ -663,10 +663,10 @@ usb2_pc_cpu_invalidate(struct usb_page_cache *pc) } /*------------------------------------------------------------------------* - * usb2_pc_cpu_flush - flush CPU cache + * usb_pc_cpu_flush - flush CPU cache *------------------------------------------------------------------------*/ void -usb2_pc_cpu_flush(struct usb_page_cache *pc) +usb_pc_cpu_flush(struct usb_page_cache *pc) { if (pc->page_offset_end == pc->page_offset_buf) { /* nothing has been loaded into this page cache! */ @@ -677,14 +677,14 @@ usb2_pc_cpu_flush(struct usb_page_cache *pc) } /*------------------------------------------------------------------------* - * usb2_pc_dmamap_create - create a DMA map + * usb_pc_dmamap_create - create a DMA map * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ uint8_t -usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size) +usb_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size) { struct usb_xfer_root *info; struct usb_dma_tag *utag; @@ -696,7 +696,7 @@ usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size) if (info == NULL) { goto error; } - utag = usb2_dma_tag_find(pc->tag_parent, size, 1); + utag = usb_dma_tag_find(pc->tag_parent, size, 1); if (utag == NULL) { goto error; } @@ -714,12 +714,12 @@ error: } /*------------------------------------------------------------------------* - * usb2_pc_dmamap_destroy + * usb_pc_dmamap_destroy * * This function is NULL safe. *------------------------------------------------------------------------*/ void -usb2_pc_dmamap_destroy(struct usb_page_cache *pc) +usb_pc_dmamap_destroy(struct usb_page_cache *pc) { if (pc && pc->tag) { bus_dmamap_destroy(pc->tag, pc->map); @@ -729,10 +729,10 @@ usb2_pc_dmamap_destroy(struct usb_page_cache *pc) } /*------------------------------------------------------------------------* - * usb2_dma_tag_find - factored out code + * usb_dma_tag_find - factored out code *------------------------------------------------------------------------*/ struct usb_dma_tag * -usb2_dma_tag_find(struct usb_dma_parent_tag *udpt, +usb_dma_tag_find(struct usb_dma_parent_tag *udpt, usb_size_t size, usb_size_t align) { struct usb_dma_tag *udt; @@ -747,7 +747,7 @@ usb2_dma_tag_find(struct usb_dma_parent_tag *udpt, while (nudt--) { if (udt->align == 0) { - usb2_dma_tag_create(udt, size, align); + usb_dma_tag_create(udt, size, align); if (udt->tag == NULL) { return (NULL); } @@ -764,10 +764,10 @@ usb2_dma_tag_find(struct usb_dma_parent_tag *udpt, } /*------------------------------------------------------------------------* - * usb2_dma_tag_setup - initialise USB DMA tags + * usb_dma_tag_setup - initialise USB DMA tags *------------------------------------------------------------------------*/ void -usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt, +usb_dma_tag_setup(struct usb_dma_parent_tag *udpt, struct usb_dma_tag *udt, bus_dma_tag_t dmat, struct mtx *mtx, usb_dma_callback_t *func, uint8_t ndmabits, uint8_t nudt) @@ -800,10 +800,10 @@ usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt, } /*------------------------------------------------------------------------* - * usb2_bus_tag_unsetup - factored out code + * usb_bus_tag_unsetup - factored out code *------------------------------------------------------------------------*/ void -usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt) +usb_dma_tag_unsetup(struct usb_dma_parent_tag *udpt) { struct usb_dma_tag *udt; uint8_t nudt; @@ -815,7 +815,7 @@ usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt) if (udt->align) { /* destroy the USB DMA tag */ - usb2_dma_tag_destroy(udt); + usb_dma_tag_destroy(udt); udt->align = 0; } udt++; @@ -828,13 +828,13 @@ usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt) } /*------------------------------------------------------------------------* - * usb2_bdma_work_loop + * usb_bdma_work_loop * * This function handles loading of virtual buffers into DMA and is * only called when "dma_refcount" is zero. *------------------------------------------------------------------------*/ void -usb2_bdma_work_loop(struct usb_xfer_queue *pq) +usb_bdma_work_loop(struct usb_xfer_queue *pq) { struct usb_xfer_root *info; struct usb_xfer *xfer; @@ -848,7 +848,7 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq) if (xfer->error) { /* some error happened */ USB_BUS_LOCK(info->bus); - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); USB_BUS_UNLOCK(info->bus); return; } @@ -922,7 +922,7 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq) } if (info->dma_error) { USB_BUS_LOCK(info->bus); - usb2_transfer_done(xfer, USB_ERR_DMA_LOAD_FAILED); + usbd_transfer_done(xfer, USB_ERR_DMA_LOAD_FAILED); USB_BUS_UNLOCK(info->bus); return; } @@ -930,12 +930,12 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq) if (info->dma_currframe == 0) { /* special case */ - usb2_pc_load_mem(xfer->frbuffers, + usb_pc_load_mem(xfer->frbuffers, info->dma_frlength_0, 0); } else { /* default case */ nframes = info->dma_currframe; - usb2_pc_load_mem(xfer->frbuffers + nframes, + usb_pc_load_mem(xfer->frbuffers + nframes, xfer->frlengths[nframes], 0); } @@ -945,23 +945,23 @@ usb2_bdma_work_loop(struct usb_xfer_queue *pq) return; } /* go ahead */ - usb2_bdma_pre_sync(xfer); + usb_bdma_pre_sync(xfer); /* start loading next USB transfer, if any */ - usb2_command_wrapper(pq, NULL); + usb_command_wrapper(pq, NULL); /* finally start the hardware */ - usb2_pipe_enter(xfer); + usbd_pipe_enter(xfer); } /*------------------------------------------------------------------------* - * usb2_bdma_done_event + * usb_bdma_done_event * * This function is called when the BUS-DMA has loaded virtual memory * into DMA, if any. *------------------------------------------------------------------------*/ void -usb2_bdma_done_event(struct usb_dma_parent_tag *udpt) +usb_bdma_done_event(struct usb_dma_parent_tag *udpt) { struct usb_xfer_root *info; @@ -973,18 +973,18 @@ usb2_bdma_done_event(struct usb_dma_parent_tag *udpt) info->dma_error = udpt->dma_error; /* enter workloop again */ - usb2_command_wrapper(&info->dma_q, + usb_command_wrapper(&info->dma_q, info->dma_q.curr); } /*------------------------------------------------------------------------* - * usb2_bdma_pre_sync + * usb_bdma_pre_sync * * This function handles DMA synchronisation that must be done before * an USB transfer is started. *------------------------------------------------------------------------*/ void -usb2_bdma_pre_sync(struct usb_xfer *xfer) +usb_bdma_pre_sync(struct usb_xfer *xfer) { struct usb_page_cache *pc; usb_frcount_t nframes; @@ -1002,22 +1002,22 @@ usb2_bdma_pre_sync(struct usb_xfer *xfer) while (nframes--) { if (pc->isread) { - usb2_pc_cpu_invalidate(pc); + usb_pc_cpu_invalidate(pc); } else { - usb2_pc_cpu_flush(pc); + usb_pc_cpu_flush(pc); } pc++; } } /*------------------------------------------------------------------------* - * usb2_bdma_post_sync + * usb_bdma_post_sync * * This function handles DMA synchronisation that must be done after * an USB transfer is complete. *------------------------------------------------------------------------*/ void -usb2_bdma_post_sync(struct usb_xfer *xfer) +usb_bdma_post_sync(struct usb_xfer *xfer) { struct usb_page_cache *pc; usb_frcount_t nframes; @@ -1034,7 +1034,7 @@ usb2_bdma_post_sync(struct usb_xfer *xfer) while (nframes--) { if (pc->isread) { - usb2_pc_cpu_invalidate(pc); + usb_pc_cpu_invalidate(pc); } pc++; } diff --git a/sys/dev/usb/usb_busdma.h b/sys/dev/usb/usb_busdma.h index ef2ee5d..9d7c2d6 100644 --- a/sys/dev/usb/usb_busdma.h +++ b/sys/dev/usb/usb_busdma.h @@ -136,40 +136,40 @@ struct usb_dma_tag {}; /* empty struct */ /* function prototypes */ -int usb2_uiomove(struct usb_page_cache *pc, struct uio *uio, +int usb_uiomove(struct usb_page_cache *pc, struct uio *uio, usb_frlength_t pc_offset, usb_frlength_t len); -struct usb_dma_tag *usb2_dma_tag_find(struct usb_dma_parent_tag *udpt, +struct usb_dma_tag *usb_dma_tag_find(struct usb_dma_parent_tag *udpt, usb_size_t size, usb_size_t align); -uint8_t usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, +uint8_t usb_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg, usb_size_t size, usb_size_t align); -uint8_t usb2_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size); -uint8_t usb2_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, +uint8_t usb_pc_dmamap_create(struct usb_page_cache *pc, usb_size_t size); +uint8_t usb_pc_load_mem(struct usb_page_cache *pc, usb_size_t size, 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_bzero(struct usb_page_cache *cache, usb_frlength_t offset, +void usb_bdma_done_event(struct usb_dma_parent_tag *udpt); +void usb_bdma_post_sync(struct usb_xfer *xfer); +void usb_bdma_pre_sync(struct usb_xfer *xfer); +void usb_bdma_work_loop(struct usb_xfer_queue *pq); +void usbd_frame_zero(struct usb_page_cache *cache, usb_frlength_t offset, usb_frlength_t len); -void usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, +void usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len); -int usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, +int usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len); -void usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, +void usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len); -int usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, +int usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len); -void usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt, +void usb_dma_tag_setup(struct usb_dma_parent_tag *udpt, struct usb_dma_tag *udt, bus_dma_tag_t dmat, struct mtx *mtx, usb_dma_callback_t *func, uint8_t ndmabits, uint8_t nudt); -void usb2_dma_tag_unsetup(struct usb_dma_parent_tag *udpt); -void usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset, +void usb_dma_tag_unsetup(struct usb_dma_parent_tag *udpt); +void usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset, struct usb_page_search *res); -void usb2_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, +void usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len); -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); -void usb2_pc_free_mem(struct usb_page_cache *pc); +void usb_pc_cpu_flush(struct usb_page_cache *pc); +void usb_pc_cpu_invalidate(struct usb_page_cache *pc); +void usb_pc_dmamap_destroy(struct usb_page_cache *pc); +void usb_pc_free_mem(struct usb_page_cache *pc); #endif /* _USB2_BUSDMA_H_ */ diff --git a/sys/dev/usb/usb_compat_linux.c b/sys/dev/usb/usb_compat_linux.c index dc3829d..f971fe3 100644 --- a/sys/dev/usb/usb_compat_linux.c +++ b/sys/dev/usb/usb_compat_linux.c @@ -30,7 +30,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -254,7 +254,7 @@ usb_linux_attach(device_t dev) } if (usb_linux_create_usb_device(uaa->device, dev) != 0) return (ENOMEM); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_fbsd_udev = uaa->device; sc->sc_fbsd_dev = dev; @@ -359,7 +359,7 @@ static uint16_t usb_max_isoc_frames(struct usb_device *dev) { ; /* indent fix */ - switch (usb2_get_speed(dev)) { + switch (usbd_get_speed(dev)) { case USB_SPEED_LOW: case USB_SPEED_FULL: return (USB_MAX_FULL_SPEED_ISOC_FRAMES); @@ -403,8 +403,8 @@ usb_submit_urb(struct urb *urb, uint16_t mem_flags) urb->status = -EINPROGRESS; - usb2_transfer_start(uhe->bsd_xfer[0]); - usb2_transfer_start(uhe->bsd_xfer[1]); + usbd_transfer_start(uhe->bsd_xfer[0]); + usbd_transfer_start(uhe->bsd_xfer[1]); } else { /* no pipes have been setup yet! */ urb->status = -EINVAL; @@ -430,16 +430,16 @@ usb_unlink_bsd(struct usb_xfer *xfer, struct urb *urb, uint8_t drain) { if (xfer && - usb2_transfer_pending(xfer) && + usbd_transfer_pending(xfer) && (xfer->priv_fifo == (void *)urb)) { if (drain) { mtx_unlock(&Giant); - usb2_transfer_drain(xfer); + usbd_transfer_drain(xfer); mtx_lock(&Giant); } else { - usb2_transfer_stop(xfer); + usbd_transfer_stop(xfer); } - usb2_transfer_start(xfer); + usbd_transfer_start(xfer); } } @@ -515,11 +515,11 @@ usb_clear_halt(struct usb_device *dev, struct usb_host_endpoint *uhe) cfg[0].endpoint = addr & UE_ADDR; cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN); - ep = usb2_get_endpoint(dev, uhe->bsd_iface_index, cfg); + ep = usbd_get_endpoint(dev, uhe->bsd_iface_index, cfg); if (ep == NULL) return (-EINVAL); - usb2_clear_data_toggle(dev, ep); + usbd_clear_data_toggle(dev, ep); return (usb_control_msg(dev, &dev->ep0, UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT, @@ -618,7 +618,7 @@ usb_control_msg(struct usb_device *dev, struct usb_host_endpoint *uhe, * The FreeBSD USB stack supports standard control * transfers on control endpoint zero: */ - err = usb2_do_request_flags(dev, + err = usbd_do_request_flags(dev, &Giant, &req, data, USB_SHORT_XFER_OK, &actlen, timeout); if (err) { @@ -689,7 +689,7 @@ usb_set_interface(struct usb_device *dev, uint8_t iface_no, uint8_t alt_index) if (alt_index >= p_ui->num_altsetting) return (-EINVAL); usb_linux_cleanup_interface(dev, p_ui); - err = -usb2_set_alt_interface_index(dev, + err = -usbd_set_alt_interface_index(dev, p_ui->bsd_iface_index, alt_index); if (err == 0) { p_ui->cur_altsetting = p_ui->altsetting + alt_index; @@ -720,7 +720,7 @@ usb_setup_endpoint(struct usb_device *dev, /* optimize */ return (0); } - usb2_transfer_unsetup(uhe->bsd_xfer, 2); + usbd_transfer_unsetup(uhe->bsd_xfer, 2); uhe->fbsd_buf_size = bufsize; @@ -759,7 +759,7 @@ usb_setup_endpoint(struct usb_device *dev, /* Allocate and setup two generic FreeBSD USB transfers */ - if (usb2_transfer_setup(dev, &uhe->bsd_iface_index, + if (usbd_transfer_setup(dev, &uhe->bsd_iface_index, uhe->bsd_xfer, cfg, 2, uhe, &Giant)) { return (-EINVAL); } @@ -779,7 +779,7 @@ usb_setup_endpoint(struct usb_device *dev, cfg[0].flags.proxy_buffer = 1; cfg[0].flags.short_xfer_ok = 1; - if (usb2_transfer_setup(dev, &uhe->bsd_iface_index, + if (usbd_transfer_setup(dev, &uhe->bsd_iface_index, uhe->bsd_xfer, cfg, 1, uhe, &Giant)) { return (-EINVAL); } @@ -797,7 +797,7 @@ usb_setup_endpoint(struct usb_device *dev, static int usb_linux_create_usb_device(struct usb_device *udev, device_t dev) { - struct usb_config_descriptor *cd = usb2_get_config_descriptor(udev); + struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev); struct usb_descriptor *desc; struct usb_interface_descriptor *id; struct usb_endpoint_descriptor *ed; @@ -828,7 +828,7 @@ usb_linux_create_usb_device(struct usb_device *udev, device_t dev) * Iterate over all the USB descriptors. Use the USB config * descriptor pointer provided by the FreeBSD USB stack. */ - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { /* * Build up a tree according to the descriptors we @@ -1065,10 +1065,10 @@ usb_buffer_alloc(struct usb_device *dev, usb_size_t size, uint16_t mem_flags, ui } /*------------------------------------------------------------------------* - * usb_get_intfdata + * usbd_get_intfdata *------------------------------------------------------------------------*/ void * -usb_get_intfdata(struct usb_interface *intf) +usbd_get_intfdata(struct usb_interface *intf) { return (intf->bsd_priv_sc); } @@ -1091,7 +1091,7 @@ usb_linux_register(void *arg) LIST_INSERT_HEAD(&usb_linux_driver_list, drv, linux_driver_list); mtx_unlock(&Giant); - usb2_needs_explore_all(); + usb_needs_explore_all(); } /*------------------------------------------------------------------------* @@ -1306,7 +1306,7 @@ usb_linux_isoc_callback(struct usb_xfer *xfer) uipd->actual_length = xfer->frlengths[x]; uipd->status = 0; if (!xfer->flags.ext_buffer) { - usb2_copy_out(xfer->frbuffers, offset, + usbd_copy_out(xfer->frbuffers, offset, USB_ADD_BYTES(urb->transfer_buffer, uipd->offset), uipd->actual_length); } @@ -1377,7 +1377,7 @@ tr_setup: uipd = urb->iso_frame_desc + x; xfer->frlengths[x] = uipd->length; if (!xfer->flags.ext_buffer) { - usb2_copy_in(xfer->frbuffers, offset, + usbd_copy_in(xfer->frbuffers, offset, USB_ADD_BYTES(urb->transfer_buffer, uipd->offset), uipd->length); } @@ -1402,14 +1402,14 @@ tr_setup: if (xfer->flags.ext_buffer) { /* set virtual address to load */ - usb2_set_frame_data(xfer, + usbd_set_frame_data(xfer, urb->transfer_buffer, 0); } xfer->priv_fifo = urb; xfer->flags.force_short_xfer = 0; xfer->timeout = urb->timeout; xfer->nframes = urb->number_of_packets; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -1473,7 +1473,7 @@ usb_linux_non_isoc_callback(struct usb_xfer *xfer) } if (urb->bsd_isread && (!xfer->flags.ext_buffer)) { /* copy in data with regard to the URB */ - usb2_copy_out(xfer->frbuffers + data_frame, 0, + usbd_copy_out(xfer->frbuffers + data_frame, 0, urb->bsd_data_ptr, xfer->frlengths[data_frame]); } urb->bsd_length_rem -= xfer->frlengths[data_frame]; @@ -1524,11 +1524,11 @@ tr_setup: * First copy in the header, then copy in data! */ if (!xfer->flags.ext_buffer) { - usb2_copy_in(xfer->frbuffers, 0, + usbd_copy_in(xfer->frbuffers, 0, urb->setup_packet, REQ_SIZE); } else { /* set virtual address to load */ - usb2_set_frame_data(xfer, + usbd_set_frame_data(xfer, urb->setup_packet, 0); } @@ -1567,11 +1567,11 @@ setup_bulk: if (xfer->flags.ext_buffer) { /* set virtual address to load */ - usb2_set_frame_data(xfer, urb->bsd_data_ptr, + usbd_set_frame_data(xfer, urb->bsd_data_ptr, data_frame); } else if (!urb->bsd_isread) { /* copy out data with regard to the URB */ - usb2_copy_in(xfer->frbuffers + data_frame, 0, + usbd_copy_in(xfer->frbuffers + data_frame, 0, urb->bsd_data_ptr, max_bulk); } xfer->frlengths[data_frame] = max_bulk; @@ -1584,7 +1584,7 @@ setup_bulk: } else { xfer->nframes = 1; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); return; default: diff --git a/sys/dev/usb/usb_compat_linux.h b/sys/dev/usb/usb_compat_linux.h index 6ac8859..5ce8196 100644 --- a/sys/dev/usb/usb_compat_linux.h +++ b/sys/dev/usb/usb_compat_linux.h @@ -328,7 +328,7 @@ struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, uint8_t iface_no); void *usb_buffer_alloc(struct usb_device *dev, usb_size_t size, uint16_t mem_flags, uint8_t *dma_addr); -void *usb_get_intfdata(struct usb_interface *intf); +void *usbd_get_intfdata(struct usb_interface *intf); void usb_buffer_free(struct usb_device *dev, usb_size_t size, void *addr, uint8_t dma_addr); void usb_free_urb(struct urb *urb); diff --git a/sys/dev/usb/usb_controller.h b/sys/dev/usb/usb_controller.h index dbf86a6..1b5a391 100644 --- a/sys/dev/usb/usb_controller.h +++ b/sys/dev/usb/usb_controller.h @@ -183,11 +183,11 @@ struct usb_temp_setup { /* prototypes */ -void usb2_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb); -uint8_t usb2_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, usb_bus_mem_cb_t *cb); -void usb2_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb); -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); +void usb_bus_mem_flush_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb); +uint8_t usb_bus_mem_alloc_all(struct usb_bus *bus, bus_dma_tag_t dmat, usb_bus_mem_cb_t *cb); +void usb_bus_mem_free_all(struct usb_bus *bus, usb_bus_mem_cb_t *cb); +uint16_t usb_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr); +uint16_t usbd_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 usbd_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len); #endif /* _USB2_CONTROLLER_H_ */ diff --git a/sys/dev/usb/usb_core.h b/sys/dev/usb/usb_core.h index dd6990f..c7018af 100644 --- a/sys/dev/usb/usb_core.h +++ b/sys/dev/usb/usb_core.h @@ -216,7 +216,7 @@ * The following macro will return the current state of an USB * transfer like defined by the "USB_ST_XXX" enums. */ -#define USB_GET_STATE(xfer) ((xfer)->usb2_state) +#define USB_GET_STATE(xfer) ((xfer)->usb_state) /* * The following macro will tell if an USB transfer is currently @@ -238,11 +238,11 @@ /* macros */ -#define usb2_callout_init_mtx(c,m,f) callout_init_mtx(&(c)->co,m,f) -#define usb2_callout_reset(c,t,f,d) callout_reset(&(c)->co,t,f,d) -#define usb2_callout_stop(c) callout_stop(&(c)->co) -#define usb2_callout_drain(c) callout_drain(&(c)->co) -#define usb2_callout_pending(c) callout_pending(&(c)->co) +#define usb_callout_init_mtx(c,m,f) callout_init_mtx(&(c)->co,m,f) +#define usb_callout_reset(c,t,f,d) callout_reset(&(c)->co,t,f,d) +#define usb_callout_stop(c) callout_stop(&(c)->co) +#define usb_callout_drain(c) callout_drain(&(c)->co) +#define usb_callout_pending(c) callout_pending(&(c)->co) #define USB_BUS_LOCK(_b) mtx_lock(&(_b)->bus_mtx) #define USB_BUS_UNLOCK(_b) mtx_unlock(&(_b)->bus_mtx) @@ -446,10 +446,10 @@ struct usb_xfer { uint8_t address; /* physical USB address */ uint8_t endpointno; /* physical USB endpoint */ uint8_t max_packet_count; - uint8_t usb2_smask; - uint8_t usb2_cmask; - uint8_t usb2_uframe; - uint8_t usb2_state; + uint8_t usb_smask; + uint8_t usb_cmask; + uint8_t usb_uframe; + uint8_t usb_state; usb_error_t error; @@ -461,7 +461,7 @@ struct usb_xfer { * The following structure keeps information that is used to match * against an array of "usb_device_id" elements. */ -struct usb_lookup_info { +struct usbd_lookup_info { uint16_t idVendor; uint16_t idProduct; uint16_t bcdDevice; @@ -480,7 +480,7 @@ struct usb_lookup_info { /* Structure used by probe and attach */ struct usb_attach_arg { - struct usb_lookup_info info; + struct usbd_lookup_info info; device_t temp_dev; /* for internal use */ unsigned long driver_info; /* for internal use */ void *driver_ivar; @@ -497,49 +497,49 @@ MALLOC_DECLARE(M_USB); MALLOC_DECLARE(M_USBDEV); MALLOC_DECLARE(M_USBHC); -extern struct mtx usb2_ref_lock; +extern struct mtx usb_ref_lock; /* prototypes */ -const char *usb2_errstr(usb_error_t error); -const char *usb2_statestr(enum usb_dev_state state); -struct usb_config_descriptor *usb2_get_config_descriptor( +const char *usbd_errstr(usb_error_t error); +const char *usb_statestr(enum usb_dev_state state); +struct usb_config_descriptor *usbd_get_config_descriptor( struct usb_device *udev); -struct usb_device_descriptor *usb2_get_device_descriptor( +struct usb_device_descriptor *usbd_get_device_descriptor( struct usb_device *udev); -struct usb_interface *usb2_get_iface(struct usb_device *udev, +struct usb_interface *usbd_get_iface(struct usb_device *udev, uint8_t iface_index); -struct usb_interface_descriptor *usb2_get_interface_descriptor( +struct usb_interface_descriptor *usbd_get_interface_descriptor( struct usb_interface *iface); -uint8_t usb2_clear_stall_callback(struct usb_xfer *xfer1, +uint8_t usbd_clear_stall_callback(struct usb_xfer *xfer1, struct usb_xfer *xfer2); -uint8_t usb2_get_interface_altindex(struct usb_interface *iface); -usb_error_t usb2_set_alt_interface_index(struct usb_device *udev, +uint8_t usbd_get_interface_altindex(struct usb_interface *iface); +usb_error_t usbd_set_alt_interface_index(struct usb_device *udev, 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); -usb_error_t usb2_transfer_setup(struct usb_device *udev, +enum usb_hc_mode usbd_get_mode(struct usb_device *udev); +enum usb_dev_speed usbd_get_speed(struct usb_device *udev); +uint32_t usbd_get_isoc_fps(struct usb_device *udev); +usb_error_t usbd_transfer_setup(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 usbd_set_frame_data(struct usb_xfer *xfer, void *ptr, usb_frcount_t frindex); -void usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, +void usbd_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, usb_frcount_t frindex); -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); -void usb2_transfer_set_stall(struct usb_xfer *xfer); -uint8_t usb2_transfer_pending(struct usb_xfer *xfer); -void usb2_transfer_start(struct usb_xfer *xfer); -void usb2_transfer_stop(struct usb_xfer *xfer); -void usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup); -void usb2_set_parent_iface(struct usb_device *udev, uint8_t iface_index, +void usbd_transfer_submit(struct usb_xfer *xfer); +void usbd_transfer_clear_stall(struct usb_xfer *xfer); +void usbd_transfer_drain(struct usb_xfer *xfer); +void usbd_transfer_set_stall(struct usb_xfer *xfer); +uint8_t usbd_transfer_pending(struct usb_xfer *xfer); +void usbd_transfer_start(struct usb_xfer *xfer); +void usbd_transfer_stop(struct usb_xfer *xfer); +void usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup); +void usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index, uint8_t parent_index); -uint8_t usb2_get_bus_index(struct usb_device *udev); -uint8_t usb2_get_device_index(struct usb_device *udev); -void usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode); -uint8_t usb2_device_attached(struct usb_device *udev); +uint8_t usbd_get_bus_index(struct usb_device *udev); +uint8_t usbd_get_device_index(struct usb_device *udev); +void usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode); +uint8_t usbd_device_attached(struct usb_device *udev); #endif /* _USB2_CORE_H_ */ diff --git a/sys/dev/usb/usb_debug.c b/sys/dev/usb/usb_debug.c index 5a18701..d8be33a 100644 --- a/sys/dev/usb/usb_debug.c +++ b/sys/dev/usb/usb_debug.c @@ -37,21 +37,21 @@ * Define this unconditionally in case a kernel module is loaded that * has been compiled with debugging options. */ -int usb2_debug = 0; +int usb_debug = 0; SYSCTL_NODE(_hw, OID_AUTO, usb, CTLFLAG_RW, 0, "USB debugging"); SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RW, - &usb2_debug, 0, "Debug level"); + &usb_debug, 0, "Debug level"); /*------------------------------------------------------------------------* - * usb2_dump_iface + * usb_dump_iface * * This function dumps information about an USB interface. *------------------------------------------------------------------------*/ void -usb2_dump_iface(struct usb_interface *iface) +usb_dump_iface(struct usb_interface *iface) { - printf("usb2_dump_iface: iface=%p\n", iface); + printf("usb_dump_iface: iface=%p\n", iface); if (iface == NULL) { return; } @@ -60,14 +60,14 @@ usb2_dump_iface(struct usb_interface *iface) } /*------------------------------------------------------------------------* - * usb2_dump_device + * usb_dump_device * * This function dumps information about an USB device. *------------------------------------------------------------------------*/ void -usb2_dump_device(struct usb_device *udev) +usb_dump_device(struct usb_device *udev) { - printf("usb2_dump_device: dev=%p\n", udev); + printf("usb_dump_device: dev=%p\n", udev); if (udev == NULL) { return; } @@ -80,16 +80,16 @@ usb2_dump_device(struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_dump_queue + * usb_dump_queue * * This function dumps the USB transfer that are queued up on an USB endpoint. *------------------------------------------------------------------------*/ void -usb2_dump_queue(struct usb_endpoint *ep) +usb_dump_queue(struct usb_endpoint *ep) { struct usb_xfer *xfer; - printf("usb2_dump_queue: endpoint=%p xfer: ", ep); + printf("usb_dump_queue: endpoint=%p xfer: ", ep); TAILQ_FOREACH(xfer, &ep->endpoint_q.head, wait_entry) { printf(" %p", xfer); } @@ -97,15 +97,15 @@ usb2_dump_queue(struct usb_endpoint *ep) } /*------------------------------------------------------------------------* - * usb2_dump_endpoint + * usb_dump_endpoint * * This function dumps information about an USB endpoint. *------------------------------------------------------------------------*/ void -usb2_dump_endpoint(struct usb_endpoint *ep) +usb_dump_endpoint(struct usb_endpoint *ep) { if (ep) { - printf("usb2_dump_endpoint: endpoint=%p", ep); + printf("usb_dump_endpoint: endpoint=%p", ep); printf(" edesc=%p isoc_next=%d toggle_next=%d", ep->edesc, ep->isoc_next, ep->toggle_next); @@ -115,22 +115,22 @@ usb2_dump_endpoint(struct usb_endpoint *ep) ep->edesc->bEndpointAddress); } printf("\n"); - usb2_dump_queue(ep); + usb_dump_queue(ep); } else { - printf("usb2_dump_endpoint: endpoint=NULL\n"); + printf("usb_dump_endpoint: endpoint=NULL\n"); } } /*------------------------------------------------------------------------* - * usb2_dump_xfer + * usb_dump_xfer * * This function dumps information about an USB transfer. *------------------------------------------------------------------------*/ void -usb2_dump_xfer(struct usb_xfer *xfer) +usb_dump_xfer(struct usb_xfer *xfer) { struct usb_device *udev; - printf("usb2_dump_xfer: xfer=%p\n", xfer); + printf("usb_dump_xfer: xfer=%p\n", xfer); if (xfer == NULL) { return; } diff --git a/sys/dev/usb/usb_debug.h b/sys/dev/usb/usb_debug.h index d3e6127..d0b5846 100644 --- a/sys/dev/usb/usb_debug.h +++ b/sys/dev/usb/usb_debug.h @@ -33,7 +33,7 @@ SYSCTL_DECL(_hw_usb); /* Declare global USB debug variable. */ -extern int usb2_debug; +extern int usb_debug; /* Check if USB debugging is enabled. */ #ifdef USB_DEBUG_VAR @@ -56,10 +56,10 @@ struct usb_device; struct usb_endpoint; struct usb_xfer; -void usb2_dump_iface(struct usb_interface *iface); -void usb2_dump_device(struct usb_device *udev); -void usb2_dump_queue(struct usb_endpoint *ep); -void usb2_dump_endpoint(struct usb_endpoint *ep); -void usb2_dump_xfer(struct usb_xfer *xfer); +void usb_dump_iface(struct usb_interface *iface); +void usb_dump_device(struct usb_device *udev); +void usb_dump_queue(struct usb_endpoint *ep); +void usb_dump_endpoint(struct usb_endpoint *ep); +void usb_dump_xfer(struct usb_xfer *xfer); #endif /* _USB2_DEBUG_H_ */ diff --git a/sys/dev/usb/usb_dev.c b/sys/dev/usb/usb_dev.c index 80b7f46..39c3951 100644 --- a/sys/dev/usb/usb_dev.c +++ b/sys/dev/usb/usb_dev.c @@ -24,7 +24,7 @@ * SUCH DAMAGE. * * - * usb2_dev.c - An abstraction layer for creating devices under /dev/... + * usb_dev.c - An abstraction layer for creating devices under /dev/... */ #include @@ -32,7 +32,7 @@ #include #include -#define USB_DEBUG_VAR usb2_fifo_debug +#define USB_DEBUG_VAR usb_fifo_debug #include #include @@ -57,11 +57,11 @@ #if USB_HAVE_UGEN #if USB_DEBUG -static int usb2_fifo_debug = 0; +static int usb_fifo_debug = 0; SYSCTL_NODE(_hw_usb, OID_AUTO, dev, CTLFLAG_RW, 0, "USB device"); SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW, - &usb2_fifo_debug, 0, "Debug Level"); + &usb_fifo_debug, 0, "Debug Level"); #endif #if ((__FreeBSD_version >= 700001) || (__FreeBSD_version == 0) || \ @@ -73,72 +73,72 @@ SYSCTL_INT(_hw_usb_dev, OID_AUTO, debug, CTLFLAG_RW, /* prototypes */ -static int usb2_fifo_open(struct usb_cdev_privdata *, +static int usb_fifo_open(struct usb_cdev_privdata *, struct usb_fifo *, int); -static void usb2_fifo_close(struct usb_fifo *, int); -static void usb2_dev_init(void *); -static void usb2_dev_init_post(void *); -static void usb2_dev_uninit(void *); -static int usb2_fifo_uiomove(struct usb_fifo *, void *, int, +static void usb_fifo_close(struct usb_fifo *, int); +static void usb_dev_init(void *); +static void usb_dev_init_post(void *); +static void usb_dev_uninit(void *); +static int usb_fifo_uiomove(struct usb_fifo *, void *, int, struct uio *); -static void usb2_fifo_check_methods(struct usb_fifo_methods *); -static struct usb_fifo *usb2_fifo_alloc(void); -static struct usb_endpoint *usb2_dev_get_ep(struct usb_device *, uint8_t, +static void usb_fifo_check_methods(struct usb_fifo_methods *); +static struct usb_fifo *usb_fifo_alloc(void); +static struct usb_endpoint *usb_dev_get_ep(struct usb_device *, uint8_t, uint8_t); -static void usb2_loc_fill(struct usb_fs_privdata *, +static void usb_loc_fill(struct usb_fs_privdata *, struct usb_cdev_privdata *); -static void usb2_close(void *); -static usb_error_t usb2_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int); -static usb_error_t usb2_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); -static void usb2_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); +static void usb_close(void *); +static usb_error_t usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *, int); +static usb_error_t usb_usb_ref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); +static void usb_unref_device(struct usb_cdev_privdata *, struct usb_cdev_refdata *); -static d_open_t usb2_open; -static d_ioctl_t usb2_ioctl; -static d_read_t usb2_read; -static d_write_t usb2_write; -static d_poll_t usb2_poll; +static d_open_t usb_open; +static d_ioctl_t usb_ioctl; +static d_read_t usb_read; +static d_write_t usb_write; +static d_poll_t usb_poll; -static d_ioctl_t usb2_static_ioctl; +static d_ioctl_t usb_static_ioctl; -static usb_fifo_open_t usb2_fifo_dummy_open; -static usb_fifo_close_t usb2_fifo_dummy_close; -static usb_fifo_ioctl_t usb2_fifo_dummy_ioctl; -static usb_fifo_cmd_t usb2_fifo_dummy_cmd; +static usb_fifo_open_t usb_fifo_dummy_open; +static usb_fifo_close_t usb_fifo_dummy_close; +static usb_fifo_ioctl_t usb_fifo_dummy_ioctl; +static usb_fifo_cmd_t usb_fifo_dummy_cmd; /* character device structure used for devices (/dev/ugenX.Y and /dev/uXXX) */ -struct cdevsw usb2_devsw = { +struct cdevsw usb_devsw = { .d_version = D_VERSION, - .d_open = usb2_open, - .d_ioctl = usb2_ioctl, + .d_open = usb_open, + .d_ioctl = usb_ioctl, .d_name = "usbdev", .d_flags = D_TRACKCLOSE, - .d_read = usb2_read, - .d_write = usb2_write, - .d_poll = usb2_poll + .d_read = usb_read, + .d_write = usb_write, + .d_poll = usb_poll }; -static struct cdev* usb2_dev = NULL; +static struct cdev* usb_dev = NULL; /* character device structure used for /dev/usb */ -static struct cdevsw usb2_static_devsw = { +static struct cdevsw usb_static_devsw = { .d_version = D_VERSION, - .d_ioctl = usb2_static_ioctl, + .d_ioctl = usb_static_ioctl, .d_name = "usb" }; -static TAILQ_HEAD(, usb_symlink) usb2_sym_head; -static struct sx usb2_sym_lock; +static TAILQ_HEAD(, usb_symlink) usb_sym_head; +static struct sx usb_sym_lock; -struct mtx usb2_ref_lock; +struct mtx usb_ref_lock; /*------------------------------------------------------------------------* - * usb2_loc_fill + * usb_loc_fill * * This is used to fill out a usb_cdev_privdata structure based on the * device's address as contained in usb_fs_privdata. *------------------------------------------------------------------------*/ static void -usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd) +usb_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd) { cpd->bus_index = pd->bus_index; cpd->dev_index = pd->dev_index; @@ -147,7 +147,7 @@ usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd) } /*------------------------------------------------------------------------* - * usb2_ref_device + * usb_ref_device * * This function is used to atomically refer an USB device by its * device location. If this function returns success the USB device @@ -158,7 +158,7 @@ usb2_loc_fill(struct usb_fs_privdata* pd, struct usb_cdev_privdata *cpd) * Else: Failure. *------------------------------------------------------------------------*/ usb_error_t -usb2_ref_device(struct usb_cdev_privdata *cpd, +usb_ref_device(struct usb_cdev_privdata *cpd, struct usb_cdev_refdata *crd, int need_uref) { struct usb_fifo **ppf; @@ -169,8 +169,8 @@ usb2_ref_device(struct usb_cdev_privdata *cpd, /* clear all refs */ memset(crd, 0, sizeof(*crd)); - mtx_lock(&usb2_ref_lock); - cpd->bus = devclass_get_softc(usb2_devclass_ptr, cpd->bus_index); + mtx_lock(&usb_ref_lock); + 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); goto error; @@ -188,7 +188,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd, DPRINTFN(2, "ref udev - needed\n"); cpd->udev->refcount++; - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); /* * We need to grab the sx-lock before grabbing the @@ -196,7 +196,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd, */ sx_xlock(cpd->udev->default_sx + 1); - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); /* * Set "is_uref" after grabbing the default SX lock @@ -250,7 +250,7 @@ usb2_ref_device(struct usb_cdev_privdata *cpd, DPRINTFN(2, "ref read\n"); crd->rxfifo->refcount++; } - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); if (crd->is_uref) { mtx_lock(&Giant); /* XXX */ @@ -264,13 +264,13 @@ error: cv_signal(cpd->udev->default_cv + 1); } } - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); DPRINTFN(2, "fail\n"); return (USB_ERR_INVAL); } /*------------------------------------------------------------------------* - * usb2_usb_ref_device + * usb_usb_ref_device * * This function is used to upgrade an USB reference to include the * USB device reference on a USB location. @@ -280,7 +280,7 @@ error: * Else: Failure. *------------------------------------------------------------------------*/ static usb_error_t -usb2_usb_ref_device(struct usb_cdev_privdata *cpd, +usb_usb_ref_device(struct usb_cdev_privdata *cpd, struct usb_cdev_refdata *crd) { /* @@ -293,19 +293,19 @@ usb2_usb_ref_device(struct usb_cdev_privdata *cpd, * To avoid deadlock at detach we need to drop the FIFO ref * and re-acquire a new ref! */ - usb2_unref_device(cpd, crd); + usb_unref_device(cpd, crd); - return (usb2_ref_device(cpd, crd, 1 /* need uref */)); + return (usb_ref_device(cpd, crd, 1 /* need uref */)); } /*------------------------------------------------------------------------* - * usb2_unref_device + * usb_unref_device * * This function will release the reference count by one unit for the * given USB device. *------------------------------------------------------------------------*/ void -usb2_unref_device(struct usb_cdev_privdata *cpd, +usb_unref_device(struct usb_cdev_privdata *cpd, struct usb_cdev_refdata *crd) { @@ -315,7 +315,7 @@ usb2_unref_device(struct usb_cdev_privdata *cpd, mtx_unlock(&Giant); /* XXX */ sx_unlock(cpd->udev->default_sx + 1); } - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); if (crd->is_read) { if (--(crd->rxfifo->refcount) == 0) { cv_signal(&crd->rxfifo->cv_drain); @@ -334,11 +334,11 @@ usb2_unref_device(struct usb_cdev_privdata *cpd, } crd->is_uref = 0; } - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); } static struct usb_fifo * -usb2_fifo_alloc(void) +usb_fifo_alloc(void) { struct usb_fifo *f; @@ -352,10 +352,10 @@ usb2_fifo_alloc(void) } /*------------------------------------------------------------------------* - * usb2_fifo_create + * usb_fifo_create *------------------------------------------------------------------------*/ static int -usb2_fifo_create(struct usb_cdev_privdata *cpd, +usb_fifo_create(struct usb_cdev_privdata *cpd, struct usb_cdev_refdata *crd) { struct usb_device *udev = cpd->udev; @@ -464,13 +464,13 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd, /* Check TX FIFO */ if (is_tx && (udev->fifo[n + USB_FIFO_TX] == NULL)) { - ep = usb2_dev_get_ep(udev, e, USB_FIFO_TX); + ep = usb_dev_get_ep(udev, e, USB_FIFO_TX); DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_TX); if (ep == NULL) { DPRINTFN(5, "dev_get_endpoint returned NULL\n"); return (EINVAL); } - f = usb2_fifo_alloc(); + f = usb_fifo_alloc(); if (f == NULL) { DPRINTFN(5, "could not alloc tx fifo\n"); return (ENOMEM); @@ -480,24 +480,24 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd, f->dev_ep_index = e; f->priv_mtx = udev->default_mtx; f->priv_sc0 = ep; - f->methods = &usb2_ugen_methods; + f->methods = &usb_ugen_methods; f->iface_index = ep->iface_index; f->udev = udev; - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); udev->fifo[n + USB_FIFO_TX] = f; - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); } /* Check RX FIFO */ if (is_rx && (udev->fifo[n + USB_FIFO_RX] == NULL)) { - ep = usb2_dev_get_ep(udev, e, USB_FIFO_RX); + ep = usb_dev_get_ep(udev, e, USB_FIFO_RX); DPRINTFN(5, "dev_get_endpoint(%d, 0x%x)\n", e, USB_FIFO_RX); if (ep == NULL) { DPRINTFN(5, "dev_get_endpoint returned NULL\n"); return (EINVAL); } - f = usb2_fifo_alloc(); + f = usb_fifo_alloc(); if (f == NULL) { DPRINTFN(5, "could not alloc rx fifo\n"); return (ENOMEM); @@ -507,12 +507,12 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd, f->dev_ep_index = e; f->priv_mtx = udev->default_mtx; f->priv_sc0 = ep; - f->methods = &usb2_ugen_methods; + f->methods = &usb_ugen_methods; f->iface_index = ep->iface_index; f->udev = udev; - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); udev->fifo[n + USB_FIFO_RX] = f; - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); } if (is_tx) { crd->txfifo = udev->fifo[n + USB_FIFO_TX]; @@ -530,7 +530,7 @@ usb2_fifo_create(struct usb_cdev_privdata *cpd, } void -usb2_fifo_free(struct usb_fifo *f) +usb_fifo_free(struct usb_fifo *f) { uint8_t n; @@ -541,11 +541,11 @@ usb2_fifo_free(struct usb_fifo *f) /* destroy symlink devices, if any */ for (n = 0; n != 2; n++) { if (f->symlink[n]) { - usb2_free_symlink(f->symlink[n]); + usb_free_symlink(f->symlink[n]); f->symlink[n] = NULL; } } - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); /* delink ourselves to stop calls from userland */ if ((f->fifo_index < USB_FIFO_MAX) && @@ -562,7 +562,7 @@ usb2_fifo_free(struct usb_fifo *f) f->flag_iserror = 1; /* need to wait until all callers have exited */ while (f->refcount != 0) { - mtx_unlock(&usb2_ref_lock); /* avoid LOR */ + mtx_unlock(&usb_ref_lock); /* avoid LOR */ mtx_lock(f->priv_mtx); /* get I/O thread out of any sleep state */ if (f->flag_sleeping) { @@ -570,15 +570,15 @@ usb2_fifo_free(struct usb_fifo *f) cv_broadcast(&f->cv_io); } mtx_unlock(f->priv_mtx); - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); /* wait for sync */ - cv_wait(&f->cv_drain, &usb2_ref_lock); + cv_wait(&f->cv_drain, &usb_ref_lock); } - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); /* take care of closing the device here, if any */ - usb2_fifo_close(f, 0); + usb_fifo_close(f, 0); cv_destroy(&f->cv_io); cv_destroy(&f->cv_drain); @@ -587,7 +587,7 @@ usb2_fifo_free(struct usb_fifo *f) } static struct usb_endpoint * -usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir) +usb_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir) { struct usb_endpoint *ep; uint8_t ep_dir; @@ -608,7 +608,7 @@ usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir) ep_dir = UE_DIR_IN; } } - ep = usb2_get_ep_by_addr(udev, ep_index | ep_dir); + ep = usbd_get_ep_by_addr(udev, ep_index | ep_dir); } if (ep == NULL) { @@ -623,14 +623,14 @@ usb2_dev_get_ep(struct usb_device *udev, uint8_t ep_index, uint8_t dir) } /*------------------------------------------------------------------------* - * usb2_fifo_open + * usb_fifo_open * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static int -usb2_fifo_open(struct usb_cdev_privdata *cpd, +usb_fifo_open(struct usb_cdev_privdata *cpd, struct usb_fifo *f, int fflags) { int err; @@ -685,13 +685,13 @@ usb2_fifo_open(struct usb_cdev_privdata *cpd, /* reset ASYNC proc flag */ f->async_p = NULL; - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); /* flag the fifo as opened to prevent others */ f->curr_cpd = cpd; - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); /* reset queue */ - usb2_fifo_reset(f); + usb_fifo_reset(f); mtx_unlock(f->priv_mtx); done: @@ -699,10 +699,10 @@ done: } /*------------------------------------------------------------------------* - * usb2_fifo_reset + * usb_fifo_reset *------------------------------------------------------------------------*/ void -usb2_fifo_reset(struct usb_fifo *f) +usb_fifo_reset(struct usb_fifo *f) { struct usb_mbuf *m; @@ -720,10 +720,10 @@ usb2_fifo_reset(struct usb_fifo *f) } /*------------------------------------------------------------------------* - * usb2_fifo_close + * usb_fifo_close *------------------------------------------------------------------------*/ static void -usb2_fifo_close(struct usb_fifo *f, int fflags) +usb_fifo_close(struct usb_fifo *f, int fflags) { int err; @@ -799,10 +799,10 @@ usb2_fifo_close(struct usb_fifo *f, int fflags) } /*------------------------------------------------------------------------* - * usb2_open - cdev callback + * usb_open - cdev callback *------------------------------------------------------------------------*/ static int -usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td) +usb_open(struct cdev *dev, int fflags, int devtype, struct thread *td) { struct usb_fs_privdata* pd = (struct usb_fs_privdata*)dev->si_drv1; struct usb_cdev_refdata refs; @@ -821,8 +821,8 @@ usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td) cpd = malloc(sizeof(*cpd), M_USBDEV, M_WAITOK | M_ZERO); ep = cpd->ep_addr = pd->ep_addr; - usb2_loc_fill(pd, cpd); - err = usb2_ref_device(cpd, &refs, 1); + usb_loc_fill(pd, cpd); + err = usb_ref_device(cpd, &refs, 1); if (err) { DPRINTFN(2, "cannot ref device\n"); free(cpd, M_USBDEV); @@ -831,46 +831,46 @@ usb2_open(struct cdev *dev, int fflags, int devtype, struct thread *td) cpd->fflags = fflags; /* access mode for open lifetime */ /* create FIFOs, if any */ - err = usb2_fifo_create(cpd, &refs); + err = usb_fifo_create(cpd, &refs); /* check for error */ if (err) { DPRINTFN(2, "cannot create fifo\n"); - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); free(cpd, M_USBDEV); return (err); } if (fflags & FREAD) { - err = usb2_fifo_open(cpd, refs.rxfifo, fflags); + err = usb_fifo_open(cpd, refs.rxfifo, fflags); if (err) { DPRINTFN(2, "read open failed\n"); - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); free(cpd, M_USBDEV); return (err); } } if (fflags & FWRITE) { - err = usb2_fifo_open(cpd, refs.txfifo, fflags); + err = usb_fifo_open(cpd, refs.txfifo, fflags); if (err) { DPRINTFN(2, "write open failed\n"); if (fflags & FREAD) { - usb2_fifo_close(refs.rxfifo, fflags); + usb_fifo_close(refs.rxfifo, fflags); } - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); free(cpd, M_USBDEV); return (err); } } - usb2_unref_device(cpd, &refs); - devfs_set_cdevpriv(cpd, usb2_close); + usb_unref_device(cpd, &refs); + devfs_set_cdevpriv(cpd, usb_close); return (0); } /*------------------------------------------------------------------------* - * usb2_close - cdev callback + * usb_close - cdev callback *------------------------------------------------------------------------*/ static void -usb2_close(void *arg) +usb_close(void *arg) { struct usb_cdev_refdata refs; struct usb_cdev_privdata *cpd = arg; @@ -878,68 +878,68 @@ usb2_close(void *arg) DPRINTFN(2, "cpd=%p\n", cpd); - err = usb2_ref_device(cpd, &refs, 1); + err = usb_ref_device(cpd, &refs, 1); if (err) { free(cpd, M_USBDEV); return; } if (cpd->fflags & FREAD) { - usb2_fifo_close(refs.rxfifo, cpd->fflags); + usb_fifo_close(refs.rxfifo, cpd->fflags); } if (cpd->fflags & FWRITE) { - usb2_fifo_close(refs.txfifo, cpd->fflags); + usb_fifo_close(refs.txfifo, cpd->fflags); } - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); free(cpd, M_USBDEV); return; } static void -usb2_dev_init(void *arg) +usb_dev_init(void *arg) { - mtx_init(&usb2_ref_lock, "USB ref mutex", NULL, MTX_DEF); - sx_init(&usb2_sym_lock, "USB sym mutex"); - TAILQ_INIT(&usb2_sym_head); + mtx_init(&usb_ref_lock, "USB ref mutex", NULL, MTX_DEF); + sx_init(&usb_sym_lock, "USB sym mutex"); + TAILQ_INIT(&usb_sym_head); /* check the UGEN methods */ - usb2_fifo_check_methods(&usb2_ugen_methods); + usb_fifo_check_methods(&usb_ugen_methods); } -SYSINIT(usb2_dev_init, SI_SUB_KLD, SI_ORDER_FIRST, usb2_dev_init, NULL); +SYSINIT(usb_dev_init, SI_SUB_KLD, SI_ORDER_FIRST, usb_dev_init, NULL); static void -usb2_dev_init_post(void *arg) +usb_dev_init_post(void *arg) { /* * Create /dev/usb - this is needed for usbconfig(8), which * needs a well-known device name to access. */ - usb2_dev = make_dev(&usb2_static_devsw, 0, UID_ROOT, GID_OPERATOR, + usb_dev = make_dev(&usb_static_devsw, 0, UID_ROOT, GID_OPERATOR, 0644, USB_DEVICE_NAME); - if (usb2_dev == NULL) { + if (usb_dev == NULL) { DPRINTFN(0, "Could not create usb bus device!\n"); } } -SYSINIT(usb2_dev_init_post, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, usb2_dev_init_post, NULL); +SYSINIT(usb_dev_init_post, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, usb_dev_init_post, NULL); static void -usb2_dev_uninit(void *arg) +usb_dev_uninit(void *arg) { - if (usb2_dev != NULL) { - destroy_dev(usb2_dev); - usb2_dev = NULL; + if (usb_dev != NULL) { + destroy_dev(usb_dev); + usb_dev = NULL; } - mtx_destroy(&usb2_ref_lock); - sx_destroy(&usb2_sym_lock); + mtx_destroy(&usb_ref_lock); + sx_destroy(&usb_sym_lock); } -SYSUNINIT(usb2_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb2_dev_uninit, NULL); +SYSUNINIT(usb_dev_uninit, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, usb_dev_uninit, NULL); static int -usb2_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, +usb_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, struct thread *td) { int error = 0; @@ -984,10 +984,10 @@ usb2_ioctl_f_sub(struct usb_fifo *f, u_long cmd, void *addr, } /*------------------------------------------------------------------------* - * usb2_ioctl - cdev callback + * usb_ioctl - cdev callback *------------------------------------------------------------------------*/ static int -usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td) +usb_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* td) { struct usb_cdev_refdata refs; struct usb_cdev_privdata* cpd; @@ -1006,7 +1006,7 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* * don't need the USB reference first. Then we grab the USB * reference if we need it! */ - err = usb2_ref_device(cpd, &refs, 0 /* no uref */ ); + err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); if (err) { return (ENXIO); } @@ -1017,18 +1017,18 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* if (fflags & FWRITE) { f = refs.txfifo; - err = usb2_ioctl_f_sub(f, cmd, addr, td); + err = usb_ioctl_f_sub(f, cmd, addr, td); } if (fflags & FREAD) { f = refs.rxfifo; - err = usb2_ioctl_f_sub(f, cmd, addr, td); + err = usb_ioctl_f_sub(f, cmd, addr, td); } KASSERT(f != NULL, ("fifo not found")); if (err == ENOIOCTL) { err = (f->methods->f_ioctl) (f, cmd, addr, fflags); DPRINTFN(2, "f_ioctl cmd 0x%lx = %d\n", cmd, err); if (err == ENOIOCTL) { - if (usb2_usb_ref_device(cpd, &refs)) { + if (usb_usb_ref_device(cpd, &refs)) { err = ENXIO; goto done; } @@ -1040,13 +1040,13 @@ usb2_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int fflag, struct thread* err = ENOTTY; } done: - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (err); } /* ARGSUSED */ static int -usb2_poll(struct cdev* dev, int events, struct thread* td) +usb_poll(struct cdev* dev, int events, struct thread* td) { struct usb_cdev_refdata refs; struct usb_cdev_privdata* cpd; @@ -1055,7 +1055,7 @@ usb2_poll(struct cdev* dev, int events, struct thread* td) int fflags, revents; if (devfs_get_cdevpriv((void **)&cpd) != 0 || - usb2_ref_device(cpd, &refs, 0) != 0) + usb_ref_device(cpd, &refs, 0) != 0) return (events & (POLLHUP|POLLIN|POLLRDNORM|POLLOUT|POLLWRNORM)); @@ -1146,12 +1146,12 @@ usb2_poll(struct cdev* dev, int events, struct thread* td) mtx_unlock(f->priv_mtx); } - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (revents); } static int -usb2_read(struct cdev *dev, struct uio *uio, int ioflag) +usb_read(struct cdev *dev, struct uio *uio, int ioflag) { struct usb_cdev_refdata refs; struct usb_cdev_privdata* cpd; @@ -1167,7 +1167,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag) if (err != 0) return (err); - err = usb2_ref_device(cpd, &refs, 0 /* no uref */ ); + err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); if (err) { return (ENXIO); } @@ -1176,7 +1176,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag) f = refs.rxfifo; if (f == NULL) { /* should not happen */ - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (EPERM); } @@ -1218,7 +1218,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag) } DPRINTF("sleeping\n"); - err = usb2_fifo_wait(f); + err = usb_fifo_wait(f); if (err) { break; } @@ -1239,7 +1239,7 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag) DPRINTFN(2, "transfer %d bytes from %p\n", io_len, m->cur_data_ptr); - err = usb2_fifo_uiomove(f, + err = usb_fifo_uiomove(f, m->cur_data_ptr, io_len, uio); m->cur_data_len -= io_len; @@ -1268,13 +1268,13 @@ usb2_read(struct cdev *dev, struct uio *uio, int ioflag) done: mtx_unlock(f->priv_mtx); - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (err); } static int -usb2_write(struct cdev *dev, struct uio *uio, int ioflag) +usb_write(struct cdev *dev, struct uio *uio, int ioflag) { struct usb_cdev_refdata refs; struct usb_cdev_privdata* cpd; @@ -1292,7 +1292,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag) if (err != 0) return (err); - err = usb2_ref_device(cpd, &refs, 0 /* no uref */ ); + err = usb_ref_device(cpd, &refs, 0 /* no uref */ ); if (err) { return (ENXIO); } @@ -1301,7 +1301,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag) f = refs.txfifo; if (f == NULL) { /* should not happen */ - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (EPERM); } resid = uio->uio_resid; @@ -1342,7 +1342,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag) } DPRINTF("sleeping\n"); - err = usb2_fifo_wait(f); + err = usb_fifo_wait(f); if (err) { break; } @@ -1359,7 +1359,7 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag) DPRINTFN(2, "transfer %d bytes to %p\n", io_len, m->cur_data_ptr); - err = usb2_fifo_uiomove(f, + err = usb_fifo_uiomove(f, m->cur_data_ptr, io_len, uio); if (err) { @@ -1382,13 +1382,13 @@ usb2_write(struct cdev *dev, struct uio *uio, int ioflag) done: mtx_unlock(f->priv_mtx); - usb2_unref_device(cpd, &refs); + usb_unref_device(cpd, &refs); return (err); } int -usb2_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, +usb_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td) { union { @@ -1400,30 +1400,30 @@ usb2_static_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, u.data = data; switch (cmd) { case USB_READ_DIR: - err = usb2_read_symlink(u.urd->urd_data, + err = usb_read_symlink(u.urd->urd_data, u.urd->urd_startentry, u.urd->urd_maxlen); break; case USB_DEV_QUIRK_GET: case USB_QUIRK_NAME_GET: case USB_DEV_QUIRK_ADD: case USB_DEV_QUIRK_REMOVE: - err = usb2_quirk_ioctl_p(cmd, data, fflag, td); + err = usb_quirk_ioctl_p(cmd, data, fflag, td); break; case USB_GET_TEMPLATE: - *(int *)data = usb2_template; + *(int *)data = usb_template; break; case USB_SET_TEMPLATE: err = priv_check(curthread, PRIV_DRIVER); if (err) break; - usb2_template = *(int *)data; + usb_template = *(int *)data; break; } return (err); } static int -usb2_fifo_uiomove(struct usb_fifo *f, void *cp, +usb_fifo_uiomove(struct usb_fifo *f, void *cp, int n, struct uio *uio) { int error; @@ -1442,7 +1442,7 @@ usb2_fifo_uiomove(struct usb_fifo *f, void *cp, } int -usb2_fifo_wait(struct usb_fifo *f) +usb_fifo_wait(struct usb_fifo *f) { int err; @@ -1464,7 +1464,7 @@ usb2_fifo_wait(struct usb_fifo *f) } void -usb2_fifo_signal(struct usb_fifo *f) +usb_fifo_signal(struct usb_fifo *f) { if (f->flag_sleeping) { f->flag_sleeping = 0; @@ -1473,9 +1473,9 @@ usb2_fifo_signal(struct usb_fifo *f) } void -usb2_fifo_wakeup(struct usb_fifo *f) +usb_fifo_wakeup(struct usb_fifo *f) { - usb2_fifo_signal(f); + usb_fifo_signal(f); if (f->flag_isselect) { selwakeup(&f->selinfo); @@ -1489,61 +1489,61 @@ usb2_fifo_wakeup(struct usb_fifo *f) } static int -usb2_fifo_dummy_open(struct usb_fifo *fifo, int fflags) +usb_fifo_dummy_open(struct usb_fifo *fifo, int fflags) { return (0); } static void -usb2_fifo_dummy_close(struct usb_fifo *fifo, int fflags) +usb_fifo_dummy_close(struct usb_fifo *fifo, int fflags) { return; } static int -usb2_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags) +usb_fifo_dummy_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags) { return (ENOIOCTL); } static void -usb2_fifo_dummy_cmd(struct usb_fifo *fifo) +usb_fifo_dummy_cmd(struct usb_fifo *fifo) { fifo->flag_flushing = 0; /* not flushing */ } static void -usb2_fifo_check_methods(struct usb_fifo_methods *pm) +usb_fifo_check_methods(struct usb_fifo_methods *pm) { /* check that all callback functions are OK */ if (pm->f_open == NULL) - pm->f_open = &usb2_fifo_dummy_open; + pm->f_open = &usb_fifo_dummy_open; if (pm->f_close == NULL) - pm->f_close = &usb2_fifo_dummy_close; + pm->f_close = &usb_fifo_dummy_close; if (pm->f_ioctl == NULL) - pm->f_ioctl = &usb2_fifo_dummy_ioctl; + pm->f_ioctl = &usb_fifo_dummy_ioctl; if (pm->f_ioctl_post == NULL) - pm->f_ioctl_post = &usb2_fifo_dummy_ioctl; + pm->f_ioctl_post = &usb_fifo_dummy_ioctl; if (pm->f_start_read == NULL) - pm->f_start_read = &usb2_fifo_dummy_cmd; + pm->f_start_read = &usb_fifo_dummy_cmd; if (pm->f_stop_read == NULL) - pm->f_stop_read = &usb2_fifo_dummy_cmd; + pm->f_stop_read = &usb_fifo_dummy_cmd; if (pm->f_start_write == NULL) - pm->f_start_write = &usb2_fifo_dummy_cmd; + pm->f_start_write = &usb_fifo_dummy_cmd; if (pm->f_stop_write == NULL) - pm->f_stop_write = &usb2_fifo_dummy_cmd; + pm->f_stop_write = &usb_fifo_dummy_cmd; } /*------------------------------------------------------------------------* - * usb2_fifo_attach + * usb_fifo_attach * * The following function will create a duplex FIFO. * @@ -1552,7 +1552,7 @@ usb2_fifo_check_methods(struct usb_fifo_methods *pm) * Else: Failure. *------------------------------------------------------------------------*/ int -usb2_fifo_attach(struct usb_device *udev, void *priv_sc, +usb_fifo_attach(struct usb_device *udev, void *priv_sc, struct mtx *priv_mtx, struct usb_fifo_methods *pm, struct usb_fifo_sc *f_sc, uint16_t unit, uint16_t subunit, uint8_t iface_index, uid_t uid, gid_t gid, int mode) @@ -1570,7 +1570,7 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, return (EINVAL); /* check the methods */ - usb2_fifo_check_methods(pm); + usb_fifo_check_methods(pm); if (priv_mtx == NULL) priv_mtx = &Giant; @@ -1593,12 +1593,12 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, break; } - f_tx = usb2_fifo_alloc(); - f_rx = usb2_fifo_alloc(); + f_tx = usb_fifo_alloc(); + f_rx = usb_fifo_alloc(); if ((f_tx == NULL) || (f_rx == NULL)) { - usb2_fifo_free(f_tx); - usb2_fifo_free(f_rx); + usb_fifo_free(f_tx); + usb_fifo_free(f_rx); return (ENOMEM); } /* initialise FIFO structures */ @@ -1622,10 +1622,10 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, f_sc->fp[USB_FIFO_TX] = f_tx; f_sc->fp[USB_FIFO_RX] = f_rx; - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); udev->fifo[f_tx->fifo_index] = f_tx; udev->fifo[f_rx->fifo_index] = f_rx; - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); for (n = 0; n != 4; n++) { @@ -1653,10 +1653,10 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, */ if (n & 1) { f_rx->symlink[n / 2] = - usb2_alloc_symlink(devname); + usb_alloc_symlink(devname); } else { f_tx->symlink[n / 2] = - usb2_alloc_symlink(devname); + usb_alloc_symlink(devname); } /* @@ -1671,7 +1671,7 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, pd->mode = FREAD|FWRITE; /* Now, create the device itself */ - f_sc->dev = make_dev(&usb2_devsw, 0, uid, gid, mode, + f_sc->dev = make_dev(&usb_devsw, 0, uid, gid, mode, devname); /* XXX setting si_drv1 and creating the device is not atomic! */ f_sc->dev->si_drv1 = pd; @@ -1682,23 +1682,23 @@ usb2_fifo_attach(struct usb_device *udev, void *priv_sc, } /*------------------------------------------------------------------------* - * usb2_fifo_alloc_buffer + * usb_fifo_alloc_buffer * * Return values: * 0: Success * Else failure *------------------------------------------------------------------------*/ int -usb2_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize, +usb_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize, uint16_t nbuf) { - usb2_fifo_free_buffer(f); + usb_fifo_free_buffer(f); /* allocate an endpoint */ f->free_q.ifq_maxlen = nbuf; f->used_q.ifq_maxlen = nbuf; - f->queue_data = usb2_alloc_mbufs( + f->queue_data = usb_alloc_mbufs( M_USBDEV, &f->free_q, bufsize, nbuf); if ((f->queue_data == NULL) && bufsize && nbuf) { @@ -1708,13 +1708,13 @@ usb2_fifo_alloc_buffer(struct usb_fifo *f, usb_size_t bufsize, } /*------------------------------------------------------------------------* - * usb2_fifo_free_buffer + * usb_fifo_free_buffer * * This function will free the buffers associated with a FIFO. This * function can be called multiple times in a row. *------------------------------------------------------------------------*/ void -usb2_fifo_free_buffer(struct usb_fifo *f) +usb_fifo_free_buffer(struct usb_fifo *f) { if (f->queue_data) { /* free old buffer */ @@ -1728,26 +1728,26 @@ usb2_fifo_free_buffer(struct usb_fifo *f) } static void -usb2_fifo_cleanup(void* ptr) +usb_fifo_cleanup(void* ptr) { free(ptr, M_USBDEV); } void -usb2_fifo_detach(struct usb_fifo_sc *f_sc) +usb_fifo_detach(struct usb_fifo_sc *f_sc) { if (f_sc == NULL) { return; } - usb2_fifo_free(f_sc->fp[USB_FIFO_TX]); - usb2_fifo_free(f_sc->fp[USB_FIFO_RX]); + usb_fifo_free(f_sc->fp[USB_FIFO_TX]); + usb_fifo_free(f_sc->fp[USB_FIFO_RX]); f_sc->fp[USB_FIFO_TX] = NULL; f_sc->fp[USB_FIFO_RX] = NULL; if (f_sc->dev != NULL) { destroy_dev_sched_cb(f_sc->dev, - usb2_fifo_cleanup, f_sc->dev->si_drv1); + usb_fifo_cleanup, f_sc->dev->si_drv1); f_sc->dev = NULL; } @@ -1755,7 +1755,7 @@ usb2_fifo_detach(struct usb_fifo_sc *f_sc) } usb_size_t -usb2_fifo_put_bytes_max(struct usb_fifo *f) +usb_fifo_put_bytes_max(struct usb_fifo *f) { struct usb_mbuf *m; usb_size_t len; @@ -1771,14 +1771,14 @@ usb2_fifo_put_bytes_max(struct usb_fifo *f) } /*------------------------------------------------------------------------* - * usb2_fifo_put_data + * usb_fifo_put_data * * what: * 0 - normal operation * 1 - set last packet flag to enforce framing *------------------------------------------------------------------------*/ void -usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, +usb_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, usb_frlength_t offset, usb_frlength_t len, uint8_t what) { struct usb_mbuf *m; @@ -1793,7 +1793,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, io_len = MIN(len, m->cur_data_len); - usb2_copy_out(pc, offset, m->cur_data_ptr, io_len); + usbd_copy_out(pc, offset, m->cur_data_ptr, io_len); m->cur_data_len = io_len; offset += io_len; @@ -1804,7 +1804,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, } USB_IF_ENQUEUE(&f->used_q, m); - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); if ((len == 0) || (what == 1)) { break; @@ -1816,7 +1816,7 @@ usb2_fifo_put_data(struct usb_fifo *f, struct usb_page_cache *pc, } void -usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr, +usb_fifo_put_data_linear(struct usb_fifo *f, void *ptr, usb_size_t len, uint8_t what) { struct usb_mbuf *m; @@ -1842,7 +1842,7 @@ usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr, } USB_IF_ENQUEUE(&f->used_q, m); - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); if ((len == 0) || (what == 1)) { break; @@ -1854,7 +1854,7 @@ usb2_fifo_put_data_linear(struct usb_fifo *f, void *ptr, } uint8_t -usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len) +usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len) { struct usb_mbuf *m; @@ -1864,21 +1864,21 @@ usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len) m->cur_data_len = len; m->cur_data_ptr = ptr; USB_IF_ENQUEUE(&f->used_q, m); - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); return (1); } return (0); } void -usb2_fifo_put_data_error(struct usb_fifo *f) +usb_fifo_put_data_error(struct usb_fifo *f) { f->flag_iserror = 1; - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); } /*------------------------------------------------------------------------* - * usb2_fifo_get_data + * usb_fifo_get_data * * what: * 0 - normal operation @@ -1889,7 +1889,7 @@ usb2_fifo_put_data_error(struct usb_fifo *f) * 1 - data in buffer *------------------------------------------------------------------------*/ uint8_t -usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, +usb_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen, uint8_t what) { @@ -1909,7 +1909,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, io_len = MIN(len, m->cur_data_len); - usb2_copy_in(pc, offset, m->cur_data_ptr, io_len); + usbd_copy_in(pc, offset, m->cur_data_ptr, io_len); len -= io_len; offset += io_len; @@ -1920,7 +1920,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, if ((m->cur_data_len == 0) || (what == 1)) { USB_IF_ENQUEUE(&f->free_q, m); - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); if (what == 1) { break; @@ -1943,7 +1943,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, } /* flushing complete */ f->flag_flushing = 0; - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); } break; } @@ -1955,7 +1955,7 @@ usb2_fifo_get_data(struct usb_fifo *f, struct usb_page_cache *pc, } uint8_t -usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr, +usb_fifo_get_data_linear(struct usb_fifo *f, void *ptr, usb_size_t len, usb_size_t *actlen, uint8_t what) { struct usb_mbuf *m; @@ -1985,7 +1985,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr, if ((m->cur_data_len == 0) || (what == 1)) { USB_IF_ENQUEUE(&f->free_q, m); - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); if (what == 1) { break; @@ -2008,7 +2008,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr, } /* flushing complete */ f->flag_flushing = 0; - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); } break; } @@ -2020,7 +2020,7 @@ usb2_fifo_get_data_linear(struct usb_fifo *f, void *ptr, } uint8_t -usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen) +usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen) { struct usb_mbuf *m; @@ -2036,21 +2036,21 @@ usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen) } void -usb2_fifo_get_data_error(struct usb_fifo *f) +usb_fifo_get_data_error(struct usb_fifo *f) { f->flag_iserror = 1; - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); } /*------------------------------------------------------------------------* - * usb2_alloc_symlink + * usb_alloc_symlink * * Return values: * NULL: Failure * Else: Pointer to symlink entry *------------------------------------------------------------------------*/ struct usb_symlink * -usb2_alloc_symlink(const char *target) +usb_alloc_symlink(const char *target) { struct usb_symlink *ps; @@ -2064,37 +2064,37 @@ usb2_alloc_symlink(const char *target) strlcpy(ps->dst_path, target, sizeof(ps->dst_path)); ps->dst_len = strlen(ps->dst_path); - sx_xlock(&usb2_sym_lock); - TAILQ_INSERT_TAIL(&usb2_sym_head, ps, sym_entry); - sx_unlock(&usb2_sym_lock); + sx_xlock(&usb_sym_lock); + TAILQ_INSERT_TAIL(&usb_sym_head, ps, sym_entry); + sx_unlock(&usb_sym_lock); return (ps); } /*------------------------------------------------------------------------* - * usb2_free_symlink + * usb_free_symlink *------------------------------------------------------------------------*/ void -usb2_free_symlink(struct usb_symlink *ps) +usb_free_symlink(struct usb_symlink *ps) { if (ps == NULL) { return; } - sx_xlock(&usb2_sym_lock); - TAILQ_REMOVE(&usb2_sym_head, ps, sym_entry); - sx_unlock(&usb2_sym_lock); + sx_xlock(&usb_sym_lock); + TAILQ_REMOVE(&usb_sym_head, ps, sym_entry); + sx_unlock(&usb_sym_lock); free(ps, M_USBDEV); } /*------------------------------------------------------------------------* - * usb2_read_symlink + * usb_read_symlink * * Return value: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ int -usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len) +usb_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len) { struct usb_symlink *ps; uint32_t temp; @@ -2102,9 +2102,9 @@ usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len) uint8_t len; int error = 0; - sx_xlock(&usb2_sym_lock); + sx_xlock(&usb_sym_lock); - TAILQ_FOREACH(ps, &usb2_sym_head, sym_entry) { + TAILQ_FOREACH(ps, &usb_sym_head, sym_entry) { /* * Compute total length of source and destination symlink @@ -2183,12 +2183,12 @@ usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len) error = copyout(&len, USB_ADD_BYTES(user_ptr, delta), 1); } - sx_unlock(&usb2_sym_lock); + sx_unlock(&usb_sym_lock); return (error); } void -usb2_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff) +usb_fifo_set_close_zlp(struct usb_fifo *f, uint8_t onoff) { if (f == NULL) return; diff --git a/sys/dev/usb/usb_dev.h b/sys/dev/usb/usb_dev.h index fb41e5a..0af1c79 100644 --- a/sys/dev/usb/usb_dev.h +++ b/sys/dev/usb/usb_dev.h @@ -167,41 +167,41 @@ struct usb_fifo_sc { struct cdev* dev; }; -extern struct cdevsw usb2_devsw; +extern struct cdevsw usb_devsw; -int usb2_fifo_wait(struct usb_fifo *fifo); -void usb2_fifo_signal(struct usb_fifo *fifo); -int usb2_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize, +int usb_fifo_wait(struct usb_fifo *fifo); +void usb_fifo_signal(struct usb_fifo *fifo); +int usb_fifo_alloc_buffer(struct usb_fifo *f, uint32_t bufsize, uint16_t nbuf); -void usb2_fifo_free_buffer(struct usb_fifo *f); -int usb2_fifo_attach(struct usb_device *udev, void *priv_sc, +void usb_fifo_free_buffer(struct usb_fifo *f); +int usb_fifo_attach(struct usb_device *udev, void *priv_sc, struct mtx *priv_mtx, struct usb_fifo_methods *pm, struct usb_fifo_sc *f_sc, uint16_t unit, uint16_t subunit, uint8_t iface_index, uid_t uid, gid_t gid, int mode); -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 usb_fifo_detach(struct usb_fifo_sc *f_sc); +uint32_t usb_fifo_put_bytes_max(struct usb_fifo *fifo); +void usb_fifo_put_data(struct usb_fifo *fifo, struct usb_page_cache *pc, usb_frlength_t offset, usb_frlength_t len, uint8_t what); -void usb2_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr, +void usb_fifo_put_data_linear(struct usb_fifo *fifo, void *ptr, usb_size_t len, uint8_t what); -uint8_t usb2_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len); -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 usb_fifo_put_data_buffer(struct usb_fifo *f, void *ptr, usb_size_t len); +void usb_fifo_put_data_error(struct usb_fifo *fifo); +uint8_t usb_fifo_get_data(struct usb_fifo *fifo, struct usb_page_cache *pc, usb_frlength_t offset, usb_frlength_t len, usb_frlength_t *actlen, uint8_t what); -uint8_t usb2_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr, +uint8_t usb_fifo_get_data_linear(struct usb_fifo *fifo, void *ptr, usb_size_t len, usb_size_t *actlen, uint8_t what); -uint8_t usb2_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, +uint8_t usb_fifo_get_data_buffer(struct usb_fifo *f, void **pptr, usb_size_t *plen); -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); -void usb2_fifo_reset(struct usb_fifo *f); -void usb2_fifo_wakeup(struct usb_fifo *f); -struct usb_symlink *usb2_alloc_symlink(const char *target); -void usb2_free_symlink(struct usb_symlink *ps); -int usb2_read_symlink(uint8_t *user_ptr, uint32_t startentry, +void usb_fifo_get_data_error(struct usb_fifo *fifo); +uint8_t usb_fifo_opened(struct usb_fifo *fifo); +void usb_fifo_free(struct usb_fifo *f); +void usb_fifo_reset(struct usb_fifo *f); +void usb_fifo_wakeup(struct usb_fifo *f); +struct usb_symlink *usb_alloc_symlink(const char *target); +void usb_free_symlink(struct usb_symlink *ps); +int usb_read_symlink(uint8_t *user_ptr, uint32_t startentry, uint32_t user_len); -void usb2_fifo_set_close_zlp(struct usb_fifo *, uint8_t); +void usb_fifo_set_close_zlp(struct usb_fifo *, uint8_t); #endif /* _USB2_DEV_H_ */ diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c index 1e7cf51..fd7a5af 100644 --- a/sys/dev/usb/usb_device.c +++ b/sys/dev/usb/usb_device.c @@ -30,7 +30,7 @@ #include #include "usbdevs.h" -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -57,36 +57,36 @@ /* function prototypes */ -static void usb2_init_endpoint(struct usb_device *, uint8_t, +static void usb_init_endpoint(struct usb_device *, uint8_t, struct usb_endpoint_descriptor *, struct usb_endpoint *); -static void usb2_unconfigure(struct usb_device *, uint8_t); -static void usb2_detach_device(struct usb_device *, uint8_t, uint8_t); -static void usb2_detach_device_sub(struct usb_device *, device_t *, +static void usb_unconfigure(struct usb_device *, uint8_t); +static void usb_detach_device(struct usb_device *, uint8_t, uint8_t); +static void usb_detach_device_sub(struct usb_device *, device_t *, uint8_t); -static uint8_t usb2_probe_and_attach_sub(struct usb_device *, +static uint8_t usb_probe_and_attach_sub(struct usb_device *, struct usb_attach_arg *); -static void usb2_init_attach_arg(struct usb_device *, +static void usb_init_attach_arg(struct usb_device *, struct usb_attach_arg *); -static void usb2_suspend_resume_sub(struct usb_device *, device_t, +static void usb_suspend_resume_sub(struct usb_device *, device_t, uint8_t); -static void usb2_clear_stall_proc(struct usb_proc_msg *_pm); -usb_error_t usb2_config_parse(struct usb_device *, uint8_t, uint8_t); -static void usb2_set_device_strings(struct usb_device *); +static void usbd_clear_stall_proc(struct usb_proc_msg *_pm); +usb_error_t usb_config_parse(struct usb_device *, uint8_t, uint8_t); +static void usbd_set_device_strings(struct usb_device *); #if USB_HAVE_UGEN -static void usb2_notify_addq(const char *type, struct usb_device *); -static void usb2_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t); -static struct cdev *usb2_make_dev(struct usb_device *, int, int); -static void usb2_cdev_create(struct usb_device *); -static void usb2_cdev_free(struct usb_device *); -static void usb2_cdev_cleanup(void *); +static void usb_notify_addq(const char *type, struct usb_device *); +static void usb_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t); +static struct cdev *usb_make_dev(struct usb_device *, int, int); +static void usb_cdev_create(struct usb_device *); +static void usb_cdev_free(struct usb_device *); +static void usb_cdev_cleanup(void *); #endif /* This variable is global to allow easy access to it: */ -int usb2_template = 0; +int usb_template = 0; SYSCTL_INT(_hw_usb, OID_AUTO, template, CTLFLAG_RW, - &usb2_template, 0, "Selected USB device side template"); + &usb_template, 0, "Selected USB device side template"); static const char* statestr[USB_STATE_MAX] = { [USB_STATE_DETACHED] = "DETACHED", @@ -97,13 +97,13 @@ static const char* statestr[USB_STATE_MAX] = { }; const char * -usb2_statestr(enum usb_dev_state state) +usb_statestr(enum usb_dev_state state) { return ((state < USB_STATE_MAX) ? statestr[state] : "UNKNOWN"); } /*------------------------------------------------------------------------* - * usb2_get_ep_by_addr + * usbd_get_ep_by_addr * * This function searches for an USB ep by endpoint address and * direction. @@ -113,7 +113,7 @@ usb2_statestr(enum usb_dev_state state) * Else: Success *------------------------------------------------------------------------*/ struct usb_endpoint * -usb2_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val) +usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val) { struct usb_endpoint *ep = udev->endpoints; struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max; @@ -157,7 +157,7 @@ found: } /*------------------------------------------------------------------------* - * usb2_get_endpoint + * usbd_get_endpoint * * This function searches for an USB endpoint based on the information * given by the passed "struct usb_config" pointer. @@ -167,7 +167,7 @@ found: * Else: Pointer to "struct usb_endpoint". *------------------------------------------------------------------------*/ struct usb_endpoint * -usb2_get_endpoint(struct usb_device *udev, uint8_t iface_index, +usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index, const struct usb_config *setup) { struct usb_endpoint *ep = udev->endpoints; @@ -277,7 +277,7 @@ found: } /*------------------------------------------------------------------------* - * usb2_interface_count + * usb_interface_count * * This function stores the number of USB interfaces excluding * alternate settings, which the USB config descriptor reports into @@ -288,7 +288,7 @@ found: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_interface_count(struct usb_device *udev, uint8_t *count) +usb_interface_count(struct usb_device *udev, uint8_t *count) { if (udev->cdesc == NULL) { *count = 0; @@ -300,14 +300,14 @@ usb2_interface_count(struct usb_device *udev, uint8_t *count) /*------------------------------------------------------------------------* - * usb2_init_endpoint + * usb_init_endpoint * * This function will initialise the USB endpoint structure pointed to by * the "endpoint" argument. The structure pointed to by "endpoint" must be * zeroed before calling this function. *------------------------------------------------------------------------*/ static void -usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index, +usb_init_endpoint(struct usb_device *udev, uint8_t iface_index, struct usb_endpoint_descriptor *edesc, struct usb_endpoint *ep) { struct usb_bus_methods *methods; @@ -320,7 +320,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index, ep->edesc = edesc; ep->iface_index = iface_index; TAILQ_INIT(&ep->endpoint_q.head); - ep->endpoint_q.command = &usb2_pipe_start; + ep->endpoint_q.command = &usbd_pipe_start; /* the pipe is not supported by the hardware */ if (ep->methods == NULL) @@ -335,7 +335,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index, } /*-----------------------------------------------------------------------* - * usb2_endpoint_foreach + * usb_endpoint_foreach * * This function will iterate all the USB endpoints except the control * endpoint. This function is NULL safe. @@ -345,7 +345,7 @@ usb2_init_endpoint(struct usb_device *udev, uint8_t iface_index, * Else: Pointer to next USB endpoint *------------------------------------------------------------------------*/ struct usb_endpoint * -usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep) +usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep) { struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max; @@ -369,7 +369,7 @@ usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep) } /*------------------------------------------------------------------------* - * usb2_unconfigure + * usb_unconfigure * * This function will free all USB interfaces and USB endpoints belonging * to an USB device. @@ -377,7 +377,7 @@ usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep) * Flag values, see "USB_UNCFG_FLAG_XXX". *------------------------------------------------------------------------*/ static void -usb2_unconfigure(struct usb_device *udev, uint8_t flag) +usb_unconfigure(struct usb_device *udev, uint8_t flag) { uint8_t do_unlock; @@ -390,16 +390,16 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag) } /* detach all interface drivers */ - usb2_detach_device(udev, USB_IFACE_INDEX_ANY, flag); + usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag); #if USB_HAVE_UGEN /* free all FIFOs except control endpoint FIFOs */ - usb2_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag); + usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag); /* * Free all cdev's, if any. */ - usb2_cdev_free(udev); + usb_cdev_free(udev); #endif #if USB_HAVE_COMPAT_LINUX @@ -410,7 +410,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag) } #endif - usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE); + usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE); /* free "cdesc" after "ifaces" and "endpoints", if any */ if (udev->cdesc != NULL) { @@ -428,7 +428,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag) } /*------------------------------------------------------------------------* - * usb2_set_config_index + * usbd_set_config_index * * This function selects configuration by index, independent of the * actual configuration number. This function should not be used by @@ -439,7 +439,7 @@ usb2_unconfigure(struct usb_device *udev, uint8_t flag) * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_set_config_index(struct usb_device *udev, uint8_t index) +usbd_set_config_index(struct usb_device *udev, uint8_t index) { struct usb_status ds; struct usb_config_descriptor *cdp; @@ -459,27 +459,27 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index) sx_xlock(udev->default_sx + 1); } - usb2_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV); + usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV); if (index == USB_UNCONFIG_INDEX) { /* * Leave unallocated when unconfiguring the - * device. "usb2_unconfigure()" will also reset + * device. "usb_unconfigure()" will also reset * the current config number and index. */ - err = usb2_req_set_config(udev, NULL, USB_UNCONFIG_NO); + err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO); if (udev->state == USB_STATE_CONFIGURED) - usb2_set_device_state(udev, USB_STATE_ADDRESSED); + usb_set_device_state(udev, USB_STATE_ADDRESSED); goto done; } /* get the full config descriptor */ if (udev->flags.usb_mode == USB_MODE_DEVICE) { /* save some memory */ - err = usb2_req_get_descriptor_ptr(udev, &cdp, + err = usbd_req_get_descriptor_ptr(udev, &cdp, (UDESC_CONFIG << 8) | index); } else { /* normal request */ - err = usb2_req_get_config_desc_full(udev, + err = usbd_req_get_config_desc_full(udev, NULL, &cdp, M_USB, index); } if (err) { @@ -497,11 +497,11 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index) /* May be self powered. */ if (cdp->bmAttributes & UC_BUS_POWERED) { /* Must ask device. */ - err = usb2_req_get_device_status(udev, NULL, &ds); + err = usbd_req_get_device_status(udev, NULL, &ds); if (err) { DPRINTFN(0, "could not read " "device status: %s\n", - usb2_errstr(err)); + usbd_errstr(err)); } else if (UGETW(ds.wStatus) & UDS_SELF_POWERED) { selfpowered = 1; } @@ -537,33 +537,33 @@ usb2_set_config_index(struct usb_device *udev, uint8_t index) udev->power = power; udev->curr_config_no = cdp->bConfigurationValue; udev->curr_config_index = index; - usb2_set_device_state(udev, USB_STATE_CONFIGURED); + usb_set_device_state(udev, USB_STATE_CONFIGURED); /* Set the actual configuration value. */ - err = usb2_req_set_config(udev, NULL, cdp->bConfigurationValue); + err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue); if (err) { goto done; } - err = usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC); + err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC); if (err) { goto done; } - err = usb2_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT); + err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT); if (err) { goto done; } #if USB_HAVE_UGEN /* create device nodes for each endpoint */ - usb2_cdev_create(udev); + usb_cdev_create(udev); #endif done: - DPRINTF("error=%s\n", usb2_errstr(err)); + DPRINTF("error=%s\n", usbd_errstr(err)); if (err) { - usb2_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV); + usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_SUBDEV); } if (do_unlock) { sx_unlock(udev->default_sx + 1); @@ -572,7 +572,7 @@ done: } /*------------------------------------------------------------------------* - * usb2_config_parse + * usb_config_parse * * This function will allocate and free USB interfaces and USB endpoints, * parse the USB configuration structure and initialise the USB endpoints @@ -589,7 +589,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) +usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) { struct usb_idesc_parse_state ips; struct usb_interface_descriptor *id; @@ -656,7 +656,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) ep_curr = 0; ep_max = 0; - while ((id = usb2_idesc_foreach(udev->cdesc, &ips))) { + while ((id = usb_idesc_foreach(udev->cdesc, &ips))) { /* check for interface overflow */ if (ips.iface_index == USB_IFACE_MAX) @@ -703,7 +703,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) temp = ep_curr; /* iterate all the endpoint descriptors */ - while ((ed = usb2_edesc_foreach(udev->cdesc, ed))) { + while ((ed = usb_edesc_foreach(udev->cdesc, ed))) { if (temp == USB_EP_MAX) break; /* crazy */ @@ -711,7 +711,7 @@ usb2_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd) ep = udev->endpoints + temp; if (do_init) { - usb2_init_endpoint(udev, + usb_init_endpoint(udev, ips.iface_index, ed, ep); } @@ -781,7 +781,7 @@ cleanup: } /*------------------------------------------------------------------------* - * usb2_set_alt_interface_index + * usbd_set_alt_interface_index * * This function will select an alternate interface index for the * given interface index. The interface should not be in use when this @@ -795,10 +795,10 @@ cleanup: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_set_alt_interface_index(struct usb_device *udev, +usbd_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); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); usb_error_t err; uint8_t do_unlock; @@ -814,7 +814,7 @@ usb2_set_alt_interface_index(struct usb_device *udev, goto done; } if (udev->flags.usb_mode == USB_MODE_DEVICE) { - usb2_detach_device(udev, iface_index, + usb_detach_device(udev, iface_index, USB_UNCFG_FLAG_FREE_SUBDEV); } else { if (iface->alt_index == alt_index) { @@ -831,14 +831,14 @@ usb2_set_alt_interface_index(struct usb_device *udev, * Free all generic FIFOs for this interface, except control * endpoint FIFOs: */ - usb2_fifo_free_wrap(udev, iface_index, 0); + usb_fifo_free_wrap(udev, iface_index, 0); #endif - err = usb2_config_parse(udev, iface_index, alt_index); + err = usb_config_parse(udev, iface_index, alt_index); if (err) { goto done; } - err = usb2_req_set_alt_interface_no(udev, NULL, iface_index, + err = usbd_req_set_alt_interface_no(udev, NULL, iface_index, iface->idesc->bAlternateSetting); done: @@ -849,7 +849,7 @@ done: } /*------------------------------------------------------------------------* - * usb2_set_endpoint_stall + * usbd_set_endpoint_stall * * This function is used to make a BULK or INTERRUPT endpoint * send STALL tokens. @@ -859,7 +859,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep, +usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep, uint8_t do_stall) { struct usb_xfer *xfer; @@ -925,17 +925,17 @@ usb2_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep, (udev->bus->methods->clear_stall) (udev, ep); /* start up the current or next transfer, if any */ - usb2_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr); + usb_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr); } USB_BUS_UNLOCK(udev->bus); return (0); } /*------------------------------------------------------------------------* - * usb2_reset_iface_endpoints - used in USB device side mode + * usb_reset_iface_endpoints - used in USB device side mode *------------------------------------------------------------------------*/ usb_error_t -usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) +usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) { struct usb_endpoint *ep; struct usb_endpoint *ep_end; @@ -951,7 +951,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) continue; } /* simulate a clear stall from the peer */ - err = usb2_set_endpoint_stall(udev, ep, 0); + err = usbd_set_endpoint_stall(udev, ep, 0); if (err) { /* just ignore */ } @@ -960,7 +960,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) } /*------------------------------------------------------------------------* - * usb2_detach_device_sub + * usb_detach_device_sub * * This function will try to detach an USB device. If it fails a panic * will result. @@ -968,7 +968,7 @@ usb2_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index) * Flag values, see "USB_UNCFG_FLAG_XXX". *------------------------------------------------------------------------*/ static void -usb2_detach_device_sub(struct usb_device *udev, device_t *ppdev, +usb_detach_device_sub(struct usb_device *udev, device_t *ppdev, uint8_t flag) { device_t dev; @@ -1016,7 +1016,7 @@ error: } /*------------------------------------------------------------------------* - * usb2_detach_device + * usb_detach_device * * The following function will detach the matching interfaces. * This function is NULL safe. @@ -1024,7 +1024,7 @@ error: * Flag values, see "USB_UNCFG_FLAG_XXX". *------------------------------------------------------------------------*/ void -usb2_detach_device(struct usb_device *udev, uint8_t iface_index, +usb_detach_device(struct usb_device *udev, uint8_t iface_index, uint8_t flag) { struct usb_interface *iface; @@ -1056,24 +1056,24 @@ usb2_detach_device(struct usb_device *udev, uint8_t iface_index, for (; i != iface_index; i++) { - iface = usb2_get_iface(udev, i); + iface = usbd_get_iface(udev, i); if (iface == NULL) { /* looks like the end of the USB interfaces */ break; } - usb2_detach_device_sub(udev, &iface->subdev, flag); + usb_detach_device_sub(udev, &iface->subdev, flag); } } /*------------------------------------------------------------------------* - * usb2_probe_and_attach_sub + * usb_probe_and_attach_sub * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static uint8_t -usb2_probe_and_attach_sub(struct usb_device *udev, +usb_probe_and_attach_sub(struct usb_device *udev, struct usb_attach_arg *uaa) { struct usb_interface *iface; @@ -1148,7 +1148,7 @@ usb2_probe_and_attach_sub(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_set_parent_iface + * usbd_set_parent_iface * * Using this function will lock the alternate interface setting on an * interface. It is typically used for multi interface drivers. In USB @@ -1158,19 +1158,19 @@ usb2_probe_and_attach_sub(struct usb_device *udev, * locked. *------------------------------------------------------------------------*/ void -usb2_set_parent_iface(struct usb_device *udev, uint8_t iface_index, +usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index, uint8_t parent_index) { struct usb_interface *iface; - iface = usb2_get_iface(udev, iface_index); + iface = usbd_get_iface(udev, iface_index); if (iface) { iface->parent_iface_index = parent_index; } } static void -usb2_init_attach_arg(struct usb_device *udev, +usb_init_attach_arg(struct usb_device *udev, struct usb_attach_arg *uaa) { bzero(uaa, sizeof(*uaa)); @@ -1190,17 +1190,17 @@ usb2_init_attach_arg(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_probe_and_attach + * usb_probe_and_attach * * This function is called from "uhub_explore_sub()", - * "usb2_handle_set_config()" and "usb2_handle_request()". + * "usb_handle_set_config()" and "usb_handle_request()". * * Returns: * 0: Success * Else: A control transfer failed *------------------------------------------------------------------------*/ usb_error_t -usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index) +usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index) { struct usb_attach_arg uaa; struct usb_interface *iface; @@ -1226,7 +1226,7 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index) } /* setup USB attach arguments */ - usb2_init_attach_arg(udev, &uaa); + usb_init_attach_arg(udev, &uaa); /* Check if only one interface should be probed: */ if (iface_index != USB_IFACE_INDEX_ANY) { @@ -1240,7 +1240,7 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index) /* Do the probe and attach */ for (; i != j; i++) { - iface = usb2_get_iface(udev, i); + iface = usbd_get_iface(udev, i); if (iface == NULL) { /* * Looks like the end of the USB @@ -1276,14 +1276,14 @@ usb2_probe_and_attach(struct usb_device *udev, uint8_t iface_index) /* try specific interface drivers first */ - if (usb2_probe_and_attach_sub(udev, &uaa)) { + if (usb_probe_and_attach_sub(udev, &uaa)) { /* ignore */ } /* try generic interface drivers last */ uaa.use_generic = 1; - if (usb2_probe_and_attach_sub(udev, &uaa)) { + if (usb_probe_and_attach_sub(udev, &uaa)) { /* ignore */ } } @@ -1303,13 +1303,13 @@ done: } /*------------------------------------------------------------------------* - * usb2_suspend_resume_sub + * usb_suspend_resume_sub * * This function is called when the suspend or resume methods should * be executed on an USB device. *------------------------------------------------------------------------*/ static void -usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend) +usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend) { int err; @@ -1331,7 +1331,7 @@ usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspen } /*------------------------------------------------------------------------* - * usb2_suspend_resume + * usb_suspend_resume * * The following function will suspend or resume the USB device. * @@ -1340,7 +1340,7 @@ usb2_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspen * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_suspend_resume(struct usb_device *udev, uint8_t do_suspend) +usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend) { struct usb_interface *iface; uint8_t i; @@ -1367,23 +1367,23 @@ usb2_suspend_resume(struct usb_device *udev, uint8_t do_suspend) for (i = 0; i != USB_IFACE_MAX; i++) { - iface = usb2_get_iface(udev, i); + iface = usbd_get_iface(udev, i); if (iface == NULL) { /* looks like the end of the USB interfaces */ break; } - usb2_suspend_resume_sub(udev, iface->subdev, do_suspend); + usb_suspend_resume_sub(udev, iface->subdev, do_suspend); } return (0); } /*------------------------------------------------------------------------* - * usb2_clear_stall_proc + * usbd_clear_stall_proc * * This function performs generic USB clear stall operations. *------------------------------------------------------------------------*/ static void -usb2_clear_stall_proc(struct usb_proc_msg *_pm) +usbd_clear_stall_proc(struct usb_proc_msg *_pm) { struct usb_clear_stall_msg *pm = (void *)_pm; struct usb_device *udev = pm->udev; @@ -1393,7 +1393,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm) mtx_lock(udev->default_mtx); /* Start clear stall callback */ - usb2_transfer_start(udev->default_xfer[1]); + usbd_transfer_start(udev->default_xfer[1]); /* Change lock */ mtx_unlock(udev->default_mtx); @@ -1401,7 +1401,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm) } /*------------------------------------------------------------------------* - * usb2_alloc_device + * usb_alloc_device * * This function allocates a new USB device. This function is called * when a new device has been put in the powered state, but not yet in @@ -1413,7 +1413,7 @@ usb2_clear_stall_proc(struct usb_proc_msg *_pm) * Else: Success *------------------------------------------------------------------------*/ struct usb_device * -usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, +usb_alloc_device(device_t parent_dev, struct usb_bus *bus, struct usb_device *parent_hub, uint8_t depth, uint8_t port_index, uint8_t port_no, enum usb_dev_speed speed, enum usb_hc_mode mode) { @@ -1471,9 +1471,9 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, mtx_init(udev->default_mtx, "USB device mutex", NULL, MTX_DEF); /* initialise generic clear stall */ - udev->cs_msg[0].hdr.pm_callback = &usb2_clear_stall_proc; + udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc; udev->cs_msg[0].udev = udev; - udev->cs_msg[1].hdr.pm_callback = &usb2_clear_stall_proc; + udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc; udev->cs_msg[1].udev = udev; /* initialise some USB device fields */ @@ -1485,7 +1485,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, udev->bus = bus; udev->address = USB_START_ADDR; /* default value */ udev->plugtime = (usb_ticks_t)ticks; - usb2_set_device_state(udev, USB_STATE_POWERED); + usb_set_device_state(udev, USB_STATE_POWERED); /* * We need to force the power mode to "on" because there are plenty * of USB devices out there that do not work very well with @@ -1526,7 +1526,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, } /* init the default endpoint */ - usb2_init_endpoint(udev, 0, + usb_init_endpoint(udev, 0, &udev->default_ep_desc, &udev->default_ep); @@ -1541,14 +1541,14 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, LIST_INIT(&udev->pd_list); /* Create the control endpoint device */ - udev->default_dev = usb2_make_dev(udev, 0, FREAD|FWRITE); + udev->default_dev = usb_make_dev(udev, 0, FREAD|FWRITE); /* Create a link from /dev/ugenX.X to the default endpoint */ make_dev_alias(udev->default_dev, udev->ugen_name); #endif if (udev->flags.usb_mode == USB_MODE_HOST) { - err = usb2_req_set_address(udev, NULL, device_index); + err = usbd_req_set_address(udev, NULL, device_index); /* This is the new USB device address from now on */ @@ -1566,10 +1566,10 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, if (err) { DPRINTFN(0, "set address %d failed " "(%s, ignored)\n", udev->address, - usb2_errstr(err)); + usbd_errstr(err)); } /* allow device time to set new address */ - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE)); } else { /* We are not self powered */ @@ -1580,33 +1580,33 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, udev->curr_config_index = USB_UNCONFIG_INDEX; /* Setup USB descriptors */ - err = (usb2_temp_setup_by_index_p) (udev, usb2_template); + err = (usb_temp_setup_by_index_p) (udev, usb_template); if (err) { DPRINTFN(0, "setting up USB template failed maybe the USB " "template module has not been loaded\n"); goto done; } } - usb2_set_device_state(udev, USB_STATE_ADDRESSED); + usb_set_device_state(udev, USB_STATE_ADDRESSED); /* * Get the first 8 bytes of the device descriptor ! * - * NOTE: "usb2_do_request" will check the device descriptor + * NOTE: "usbd_do_request" will check the device descriptor * next time we do a request to see if the maximum packet size * changed! The 8 first bytes of the device descriptor * contains the maximum packet size to use on control endpoint * 0. If this value is different from "USB_MAX_IPACKET" a new * USB control request will be setup! */ - err = usb2_req_get_desc(udev, NULL, NULL, &udev->ddesc, + err = usbd_req_get_desc(udev, NULL, NULL, &udev->ddesc, USB_MAX_IPACKET, USB_MAX_IPACKET, 0, UDESC_DEVICE, 0, 0); if (err) { DPRINTFN(0, "getting device descriptor " "at addr %d failed, %s!\n", udev->address, - usb2_errstr(err)); + usbd_errstr(err)); /* XXX try to re-enumerate the device */ - err = usb2_req_re_enumerate(udev, NULL); + err = usbd_req_re_enumerate(udev, NULL); if (err) { goto done; } @@ -1622,7 +1622,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, udev->speed); /* get the full device descriptor */ - err = usb2_req_get_device_desc(udev, NULL, &udev->ddesc); + err = usbd_req_get_device_desc(udev, NULL, &udev->ddesc); if (err) { DPRINTF("addr=%d, getting full desc failed\n", udev->address); @@ -1632,12 +1632,12 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, * Setup temporary USB attach args so that we can figure out some * basic quirks for this device. */ - usb2_init_attach_arg(udev, &uaa); + usb_init_attach_arg(udev, &uaa); - if (usb2_test_quirk(&uaa, UQ_BUS_POWERED)) { + if (usb_test_quirk(&uaa, UQ_BUS_POWERED)) { udev->flags.uq_bus_powered = 1; } - if (usb2_test_quirk(&uaa, UQ_NO_STRINGS)) { + if (usb_test_quirk(&uaa, UQ_NO_STRINGS)) { udev->flags.no_strings = 1; } /* @@ -1658,7 +1658,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, udev->ddesc.iProduct || udev->ddesc.iSerialNumber) { /* read out the language ID string */ - err = usb2_req_get_string_desc(udev, NULL, + err = usbd_req_get_string_desc(udev, NULL, (char *)scratch_ptr, 4, scratch_size, USB_LANGUAGE_TABLE); } else { @@ -1675,7 +1675,7 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, /* assume 100mA bus powered for now. Changed when configured. */ udev->power = USB_MIN_POWER; /* fetch the vendor and product strings from the device */ - usb2_set_device_strings(udev); + usbd_set_device_strings(udev); if (udev->flags.usb_mode == USB_MODE_HOST) { uint8_t config_index; @@ -1686,19 +1686,19 @@ usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, * Most USB devices should attach to config index 0 by * default */ - if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_0)) { + if (usb_test_quirk(&uaa, UQ_CFG_INDEX_0)) { config_index = 0; config_quirk = 1; - } else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_1)) { + } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_1)) { config_index = 1; config_quirk = 1; - } else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_2)) { + } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_2)) { config_index = 2; config_quirk = 1; - } else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_3)) { + } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_3)) { config_index = 3; config_quirk = 1; - } else if (usb2_test_quirk(&uaa, UQ_CFG_INDEX_4)) { + } else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_4)) { config_index = 4; config_quirk = 1; } else { @@ -1711,13 +1711,13 @@ repeat_set_config: DPRINTF("setting config %u\n", config_index); /* get the USB device configured */ - err = usb2_set_config_index(udev, config_index); + err = usbd_set_config_index(udev, config_index); if (err) { if (udev->ddesc.bNumConfigurations != 0) { if (!set_config_failed) { set_config_failed = 1; /* XXX try to re-enumerate the device */ - err = usb2_req_re_enumerate( + err = usbd_req_re_enumerate( udev, NULL); if (err == 0) goto repeat_set_config; @@ -1725,7 +1725,7 @@ repeat_set_config: DPRINTFN(0, "Failure selecting " "configuration index %u: %s, port %u, " "addr %u (ignored)\n", - config_index, usb2_errstr(err), udev->port_no, + config_index, usbd_errstr(err), udev->port_no, udev->address); } /* @@ -1739,7 +1739,7 @@ repeat_set_config: } else if ((config_index + 1) < udev->ddesc.bNumConfigurations) { if ((udev->cdesc->bNumInterface < 2) && - (usb2_get_no_descriptors(udev->cdesc, + (usbd_get_no_descriptors(udev->cdesc, UDESC_ENDPOINT) == 0)) { DPRINTFN(0, "Found no endpoints " "(trying next config)!\n"); @@ -1751,14 +1751,14 @@ repeat_set_config: * Try to figure out if we have an * auto-install disk there: */ - if (usb2_test_autoinstall(udev, 0, 0) == 0) { + if (usb_test_autoinstall(udev, 0, 0) == 0) { DPRINTFN(0, "Found possible auto-install " "disk (trying next config)\n"); config_index++; goto repeat_set_config; } } - } else if (usb2_test_huawei_autoinst_p(udev, &uaa) == 0) { + } else if (usb_test_huawei_autoinst_p(udev, &uaa) == 0) { DPRINTFN(0, "Found Huawei auto-install disk!\n"); err = USB_ERR_STALLED; /* fake an error */ } @@ -1770,23 +1770,23 @@ repeat_set_config: udev->address, udev, udev->parent_hub); /* register our device - we are ready */ - usb2_bus_port_set_device(bus, parent_hub ? + usb_bus_port_set_device(bus, parent_hub ? parent_hub->hub->ports + port_index : NULL, udev, device_index); #if USB_HAVE_UGEN /* Symlink the ugen device name */ - udev->ugen_symlink = usb2_alloc_symlink(udev->ugen_name); + udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name); /* Announce device */ printf("%s: <%s> at %s\n", udev->ugen_name, udev->manufacturer, device_get_nameunit(udev->bus->bdev)); - usb2_notify_addq("+", udev); + usb_notify_addq("+", udev); #endif done: if (err) { /* free device */ - usb2_free_device(udev, + usb_free_device(udev, USB_UNCFG_FLAG_FREE_SUBDEV | USB_UNCFG_FLAG_FREE_EP0); udev = NULL; @@ -1796,7 +1796,7 @@ done: #if USB_HAVE_UGEN static struct cdev * -usb2_make_dev(struct usb_device *udev, int ep, int mode) +usb_make_dev(struct usb_device *udev, int ep, int mode) { struct usb_fs_privdata* pd; char devname[20]; @@ -1812,7 +1812,7 @@ usb2_make_dev(struct usb_device *udev, int ep, int mode) /* Now, create the device itself */ snprintf(devname, sizeof(devname), "%u.%u.%u", pd->bus_index, pd->dev_index, pd->ep_addr); - pd->cdev = make_dev(&usb2_devsw, 0, UID_ROOT, + pd->cdev = make_dev(&usb_devsw, 0, UID_ROOT, GID_OPERATOR, 0600, USB_DEVICE_DIR "/%s", devname); pd->cdev->si_drv1 = pd; @@ -1820,7 +1820,7 @@ usb2_make_dev(struct usb_device *udev, int ep, int mode) } static void -usb2_cdev_create(struct usb_device *udev) +usb_cdev_create(struct usb_device *udev) { struct usb_config_descriptor *cd; struct usb_endpoint_descriptor *ed; @@ -1834,7 +1834,7 @@ usb2_cdev_create(struct usb_device *udev) DPRINTFN(2, "Creating device nodes\n"); - if (usb2_get_mode(udev) == USB_MODE_DEVICE) { + if (usbd_get_mode(udev) == USB_MODE_DEVICE) { inmode = FWRITE; outmode = FREAD; } else { /* USB_MODE_HOST */ @@ -1850,8 +1850,8 @@ usb2_cdev_create(struct usb_device *udev) * Collect all used endpoint numbers instead of just * generating 16 static endpoints. */ - cd = usb2_get_config_descriptor(udev); - while ((desc = usb2_desc_foreach(cd, desc))) { + cd = usbd_get_config_descriptor(udev); + while ((desc = usb_desc_foreach(cd, desc))) { /* filter out all endpoint descriptors */ if ((desc->bDescriptorType == UDESC_ENDPOINT) && (desc->bLength >= sizeof(*ed))) { @@ -1873,14 +1873,14 @@ usb2_cdev_create(struct usb_device *udev) if (mode == 0) continue; /* no IN or OUT endpoint */ - dev = usb2_make_dev(udev, ep, mode); + dev = usb_make_dev(udev, ep, mode); pd = dev->si_drv1; LIST_INSERT_HEAD(&udev->pd_list, pd, pd_next); } } static void -usb2_cdev_free(struct usb_device *udev) +usb_cdev_free(struct usb_device *udev) { struct usb_fs_privdata* pd; @@ -1889,28 +1889,28 @@ usb2_cdev_free(struct usb_device *udev) while ((pd = LIST_FIRST(&udev->pd_list)) != NULL) { KASSERT(pd->cdev->si_drv1 == pd, ("privdata corrupt")); - destroy_dev_sched_cb(pd->cdev, usb2_cdev_cleanup, pd); + destroy_dev_sched_cb(pd->cdev, usb_cdev_cleanup, pd); pd->cdev = NULL; LIST_REMOVE(pd, pd_next); } } static void -usb2_cdev_cleanup(void* arg) +usb_cdev_cleanup(void* arg) { free(arg, M_USBDEV); } #endif /*------------------------------------------------------------------------* - * usb2_free_device + * usb_free_device * * This function is NULL safe and will free an USB device. * * Flag values, see "USB_UNCFG_FLAG_XXX". *------------------------------------------------------------------------*/ void -usb2_free_device(struct usb_device *udev, uint8_t flag) +usb_free_device(struct usb_device *udev, uint8_t flag) { struct usb_bus *bus; @@ -1920,17 +1920,17 @@ usb2_free_device(struct usb_device *udev, uint8_t flag) DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no); bus = udev->bus; - usb2_set_device_state(udev, USB_STATE_DETACHED); + usb_set_device_state(udev, USB_STATE_DETACHED); #if USB_HAVE_UGEN - usb2_notify_addq("-", udev); + usb_notify_addq("-", udev); printf("%s: <%s> at %s (disconnected)\n", udev->ugen_name, udev->manufacturer, device_get_nameunit(bus->bdev)); /* Destroy UGEN symlink, if any */ if (udev->ugen_symlink) { - usb2_free_symlink(udev->ugen_symlink); + usb_free_symlink(udev->ugen_symlink); udev->ugen_symlink = NULL; } #endif @@ -1938,43 +1938,43 @@ usb2_free_device(struct usb_device *udev, uint8_t flag) * Unregister our device first which will prevent any further * references: */ - usb2_bus_port_set_device(bus, udev->parent_hub ? + usb_bus_port_set_device(bus, udev->parent_hub ? udev->parent_hub->hub->ports + udev->port_index : NULL, NULL, USB_ROOT_HUB_ADDR); #if USB_HAVE_UGEN /* wait for all pending references to go away: */ - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); udev->refcount--; while (udev->refcount != 0) { - cv_wait(udev->default_cv + 1, &usb2_ref_lock); + cv_wait(udev->default_cv + 1, &usb_ref_lock); } - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); - destroy_dev_sched_cb(udev->default_dev, usb2_cdev_cleanup, + destroy_dev_sched_cb(udev->default_dev, usb_cdev_cleanup, udev->default_dev->si_drv1); #endif if (udev->flags.usb_mode == USB_MODE_DEVICE) { /* stop receiving any control transfers (Device Side Mode) */ - usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); + usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); } /* the following will get the device unconfigured in software */ - usb2_unconfigure(udev, flag); + usb_unconfigure(udev, flag); /* unsetup any leftover default USB transfers */ - usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); + usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); /* template unsetup, if any */ - (usb2_temp_unsetup_p) (udev); + (usb_temp_unsetup_p) (udev); /* * Make sure that our clear-stall messages are not queued * anywhere: */ USB_BUS_LOCK(udev->bus); - usb2_proc_mwait(&udev->bus->non_giant_callback_proc, + usb_proc_mwait(&udev->bus->non_giant_callback_proc, &udev->cs_msg[0], &udev->cs_msg[1]); USB_BUS_UNLOCK(udev->bus); @@ -1997,7 +1997,7 @@ usb2_free_device(struct usb_device *udev, uint8_t flag) } /*------------------------------------------------------------------------* - * usb2_get_iface + * usbd_get_iface * * This function is the safe way to get the USB interface structure * pointer by interface index. @@ -2007,7 +2007,7 @@ usb2_free_device(struct usb_device *udev, uint8_t flag) * Else: Pointer to USB interface structure. *------------------------------------------------------------------------*/ struct usb_interface * -usb2_get_iface(struct usb_device *udev, uint8_t iface_index) +usbd_get_iface(struct usb_device *udev, uint8_t iface_index) { struct usb_interface *iface = udev->ifaces + iface_index; @@ -2040,23 +2040,23 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, struct usb_config_descriptor *cd; struct usb_interface *iface; - cd = usb2_get_config_descriptor(udev); + cd = usbd_get_config_descriptor(udev); if (cd == NULL) { return (NULL); } if (id == NULL) { - iface = usb2_get_iface(udev, iface_index); + iface = usbd_get_iface(udev, iface_index); if (iface == NULL) { return (NULL); } - id = usb2_get_interface_descriptor(iface); + id = usbd_get_interface_descriptor(iface); if (id == NULL) { return (NULL); } } desc = (void *)id; - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if (desc->bDescriptorType == UDESC_INTERFACE) { break; @@ -2070,7 +2070,7 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, } /*------------------------------------------------------------------------* - * usb2_devinfo + * usb_devinfo * * This function will dump information from the device descriptor * belonging to the USB device pointed to by "udev", to the string @@ -2078,7 +2078,7 @@ usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, * including the terminating zero. *------------------------------------------------------------------------*/ void -usb2_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len) +usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len) { struct usb_device_descriptor *udd = &udev->ddesc; uint16_t bcdDevice; @@ -2124,7 +2124,7 @@ struct usb_knowndev { #endif /* USB_VERBOSE */ static void -usb2_set_device_strings(struct usb_device *udev) +usbd_set_device_strings(struct usb_device *udev) { struct usb_device_descriptor *udd = &udev->ddesc; #if USB_VERBOSE @@ -2139,23 +2139,23 @@ usb2_set_device_strings(struct usb_device *udev) /* get serial number string */ bzero(temp, sizeof(temp)); - usb2_req_get_string_any(udev, NULL, temp, sizeof(temp), + usbd_req_get_string_any(udev, NULL, temp, sizeof(temp), udev->ddesc.iSerialNumber); udev->serial = strdup(temp, M_USB); /* get manufacturer string */ bzero(temp, sizeof(temp)); - usb2_req_get_string_any(udev, NULL, temp, sizeof(temp), + usbd_req_get_string_any(udev, NULL, temp, sizeof(temp), udev->ddesc.iManufacturer); - usb2_trim_spaces(temp); + usb_trim_spaces(temp); if (temp[0] != '\0') udev->manufacturer = strdup(temp, M_USB); /* get product string */ bzero(temp, sizeof(temp)); - usb2_req_get_string_any(udev, NULL, temp, sizeof(temp), + usbd_req_get_string_any(udev, NULL, temp, sizeof(temp), udev->ddesc.iProduct); - usb2_trim_spaces(temp); + usb_trim_spaces(temp); if (temp[0] != '\0') udev->product = strdup(temp, M_USB); @@ -2197,7 +2197,7 @@ usb2_set_device_strings(struct usb_device *udev) * See: USB_MODE_XXX */ enum usb_hc_mode -usb2_get_mode(struct usb_device *udev) +usbd_get_mode(struct usb_device *udev) { return (udev->flags.usb_mode); } @@ -2207,13 +2207,13 @@ usb2_get_mode(struct usb_device *udev) * See: USB_SPEED_XXX */ enum usb_dev_speed -usb2_get_speed(struct usb_device *udev) +usbd_get_speed(struct usb_device *udev) { return (udev->speed); } uint32_t -usb2_get_isoc_fps(struct usb_device *udev) +usbd_get_isoc_fps(struct usb_device *udev) { ; /* indent fix */ switch (udev->speed) { @@ -2226,7 +2226,7 @@ usb2_get_isoc_fps(struct usb_device *udev) } struct usb_device_descriptor * -usb2_get_device_descriptor(struct usb_device *udev) +usbd_get_device_descriptor(struct usb_device *udev) { if (udev == NULL) return (NULL); /* be NULL safe */ @@ -2234,7 +2234,7 @@ usb2_get_device_descriptor(struct usb_device *udev) } struct usb_config_descriptor * -usb2_get_config_descriptor(struct usb_device *udev) +usbd_get_config_descriptor(struct usb_device *udev) { if (udev == NULL) return (NULL); /* be NULL safe */ @@ -2242,23 +2242,23 @@ usb2_get_config_descriptor(struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_test_quirk - test a device for a given quirk + * usb_test_quirk - test a device for a given quirk * * Return values: * 0: The USB device does not have the given quirk. * Else: The USB device has the given quirk. *------------------------------------------------------------------------*/ uint8_t -usb2_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk) +usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk) { uint8_t found; - found = (usb2_test_quirk_p) (&uaa->info, quirk); + found = (usb_test_quirk_p) (&uaa->info, quirk); return (found); } struct usb_interface_descriptor * -usb2_get_interface_descriptor(struct usb_interface *iface) +usbd_get_interface_descriptor(struct usb_interface *iface) { if (iface == NULL) return (NULL); /* be NULL safe */ @@ -2266,31 +2266,31 @@ usb2_get_interface_descriptor(struct usb_interface *iface) } uint8_t -usb2_get_interface_altindex(struct usb_interface *iface) +usbd_get_interface_altindex(struct usb_interface *iface) { return (iface->alt_index); } uint8_t -usb2_get_bus_index(struct usb_device *udev) +usbd_get_bus_index(struct usb_device *udev) { return ((uint8_t)device_get_unit(udev->bus->bdev)); } uint8_t -usb2_get_device_index(struct usb_device *udev) +usbd_get_device_index(struct usb_device *udev) { return (udev->device_index); } #if USB_HAVE_UGEN /*------------------------------------------------------------------------* - * usb2_notify_addq + * usb_notify_addq * * This function will generate events for dev. *------------------------------------------------------------------------*/ static void -usb2_notify_addq(const char *type, struct usb_device *udev) +usb_notify_addq(const char *type, struct usb_device *udev) { char *data = NULL; struct malloc_type *mt; @@ -2334,7 +2334,7 @@ usb2_notify_addq(const char *type, struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_fifo_free_wrap + * usb_fifo_free_wrap * * This function will free the FIFOs. * @@ -2346,7 +2346,7 @@ usb2_notify_addq(const char *type, struct usb_device *udev) * "USB_IFACE_INDEX_ANY" the flag has no effect. *------------------------------------------------------------------------*/ static void -usb2_fifo_free_wrap(struct usb_device *udev, +usb_fifo_free_wrap(struct usb_device *udev, uint8_t iface_index, uint8_t flag) { struct usb_fifo *f; @@ -2362,7 +2362,7 @@ usb2_fifo_free_wrap(struct usb_device *udev, } /* Check if the interface index matches */ if (iface_index == f->iface_index) { - if (f->methods != &usb2_ugen_methods) { + if (f->methods != &usb_ugen_methods) { /* * Don't free any non-generic FIFOs in * this case. @@ -2375,7 +2375,7 @@ usb2_fifo_free_wrap(struct usb_device *udev, continue; } } else if (iface_index == USB_IFACE_INDEX_ANY) { - if ((f->methods == &usb2_ugen_methods) && + if ((f->methods == &usb_ugen_methods) && (f->dev_ep_index == 0) && (!(flag & USB_UNCFG_FLAG_FREE_EP0)) && (f->fs_xfer == NULL)) { @@ -2387,20 +2387,20 @@ usb2_fifo_free_wrap(struct usb_device *udev, continue; } /* free this FIFO */ - usb2_fifo_free(f); + usb_fifo_free(f); } } #endif /*------------------------------------------------------------------------* - * usb2_peer_can_wakeup + * usb_peer_can_wakeup * * Return values: * 0: Peer cannot do resume signalling. * Else: Peer can do resume signalling. *------------------------------------------------------------------------*/ uint8_t -usb2_peer_can_wakeup(struct usb_device *udev) +usb_peer_can_wakeup(struct usb_device *udev) { const struct usb_config_descriptor *cdp; @@ -2412,18 +2412,18 @@ usb2_peer_can_wakeup(struct usb_device *udev) } void -usb2_set_device_state(struct usb_device *udev, enum usb_dev_state state) +usb_set_device_state(struct usb_device *udev, enum usb_dev_state state) { KASSERT(state < USB_STATE_MAX, ("invalid udev state")); DPRINTF("udev %p state %s -> %s\n", udev, - usb2_statestr(udev->state), usb2_statestr(state)); + usb_statestr(udev->state), usb_statestr(state)); udev->state = state; } uint8_t -usb2_device_attached(struct usb_device *udev) +usbd_device_attached(struct usb_device *udev) { return (udev->state > USB_STATE_DETACHED); } diff --git a/sys/dev/usb/usb_device.h b/sys/dev/usb/usb_device.h index fc2925a..32af2e2 100644 --- a/sys/dev/usb/usb_device.h +++ b/sys/dev/usb/usb_device.h @@ -32,13 +32,13 @@ struct usb_device; /* linux compat */ #define USB_DEFAULT_XFER_MAX 2 -/* "usb2_parse_config()" commands */ +/* "usb_parse_config()" commands */ #define USB_CFG_ALLOC 0 #define USB_CFG_FREE 1 #define USB_CFG_INIT 2 -/* "usb2_unconfigure()" flags */ +/* "usb_unconfigure()" flags */ #define USB_UNCFG_FLAG_NONE 0x00 #define USB_UNCFG_FLAG_FREE_SUBDEV 0x01 /* subdevices are freed */ @@ -166,7 +166,7 @@ struct usb_device { struct usb_config_descriptor *cdesc; /* full config descr */ struct usb_hub *hub; /* only if this is a hub */ struct usb_xfer *default_xfer[USB_DEFAULT_XFER_MAX]; - struct usb_temp_data *usb2_template_ptr; + struct usb_temp_data *usb_template_ptr; struct usb_endpoint *ep_curr; /* current clear stall endpoint */ #if USB_HAVE_UGEN struct usb_fifo *fifo[USB_FIFO_MAX]; @@ -224,36 +224,36 @@ struct usb_device { /* globals */ -extern int usb2_template; +extern int usb_template; /* function prototypes */ -struct usb_device *usb2_alloc_device(device_t parent_dev, struct usb_bus *bus, +struct usb_device *usb_alloc_device(device_t parent_dev, struct usb_bus *bus, struct usb_device *parent_hub, uint8_t depth, uint8_t port_index, uint8_t port_no, enum usb_dev_speed speed, enum usb_hc_mode mode); -struct usb_endpoint *usb2_get_endpoint(struct usb_device *udev, uint8_t iface_index, +struct usb_endpoint *usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index, const struct usb_config *setup); -struct usb_endpoint *usb2_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val); -usb_error_t usb2_interface_count(struct usb_device *udev, uint8_t *count); -usb_error_t usb2_probe_and_attach(struct usb_device *udev, +struct usb_endpoint *usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val); +usb_error_t usb_interface_count(struct usb_device *udev, uint8_t *count); +usb_error_t usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index); -usb_error_t usb2_reset_iface_endpoints(struct usb_device *udev, +usb_error_t usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index); -usb_error_t usb2_set_config_index(struct usb_device *udev, uint8_t index); -usb_error_t usb2_set_endpoint_stall(struct usb_device *udev, +usb_error_t usbd_set_config_index(struct usb_device *udev, uint8_t index); +usb_error_t usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep, uint8_t do_stall); -usb_error_t usb2_suspend_resume(struct usb_device *udev, +usb_error_t usb_suspend_resume(struct usb_device *udev, 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); +void usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len); +void usb_free_device(struct usb_device *, uint8_t); void *usb2_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index, uint8_t type, uint8_t type_mask, uint8_t subtype, uint8_t subtype_mask); void usb_linux_free_device(struct usb_device *dev); -uint8_t usb2_peer_can_wakeup(struct usb_device *udev); -struct usb_endpoint *usb2_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep); -void usb2_set_device_state(struct usb_device *udev, +uint8_t usb_peer_can_wakeup(struct usb_device *udev); +struct usb_endpoint *usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep); +void usb_set_device_state(struct usb_device *udev, enum usb_dev_state state); #endif /* _USB2_DEVICE_H_ */ diff --git a/sys/dev/usb/usb_dynamic.c b/sys/dev/usb/usb_dynamic.c index f60c930..eabb9df 100644 --- a/sys/dev/usb/usb_dynamic.c +++ b/sys/dev/usb/usb_dynamic.c @@ -34,72 +34,72 @@ #include /* function prototypes */ -static usb_handle_req_t usb2_temp_get_desc_w; -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_test_huawei_autoinst_t usb2_test_huawei_autoinst_w; -static usb2_quirk_ioctl_t usb2_quirk_ioctl_w; +static usb_handle_req_t usb_temp_get_desc_w; +static usb_temp_setup_by_index_t usb_temp_setup_by_index_w; +static usb_temp_unsetup_t usb_temp_unsetup_w; +static usb_test_quirk_t usb_test_quirk_w; +static usb_test_huawei_autoinst_t usb_test_huawei_autoinst_w; +static usb_quirk_ioctl_t usb_quirk_ioctl_w; /* global variables */ -usb_handle_req_t *usb2_temp_get_desc_p = &usb2_temp_get_desc_w; -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_test_huawei_autoinst_t *usb2_test_huawei_autoinst_p = &usb2_test_huawei_autoinst_w; -usb2_quirk_ioctl_t *usb2_quirk_ioctl_p = &usb2_quirk_ioctl_w; -devclass_t usb2_devclass_ptr = NULL; +usb_handle_req_t *usb_temp_get_desc_p = &usb_temp_get_desc_w; +usb_temp_setup_by_index_t *usb_temp_setup_by_index_p = &usb_temp_setup_by_index_w; +usb_temp_unsetup_t *usb_temp_unsetup_p = &usb_temp_unsetup_w; +usb_test_quirk_t *usb_test_quirk_p = &usb_test_quirk_w; +usb_test_huawei_autoinst_t *usb_test_huawei_autoinst_p = &usb_test_huawei_autoinst_w; +usb_quirk_ioctl_t *usb_quirk_ioctl_p = &usb_quirk_ioctl_w; +devclass_t usb_devclass_ptr = NULL; static usb_error_t -usb2_temp_setup_by_index_w(struct usb_device *udev, uint16_t index) +usb_temp_setup_by_index_w(struct usb_device *udev, uint16_t index) { return (USB_ERR_INVAL); } static uint8_t -usb2_test_quirk_w(const struct usb_lookup_info *info, uint16_t quirk) +usb_test_quirk_w(const struct usbd_lookup_info *info, uint16_t quirk) { return (0); /* no match */ } static int -usb2_quirk_ioctl_w(unsigned long cmd, caddr_t data, int fflag, struct thread *td) +usb_quirk_ioctl_w(unsigned long cmd, caddr_t data, int fflag, struct thread *td) { return (ENOIOCTL); } static usb_error_t -usb2_temp_get_desc_w(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength) +usb_temp_get_desc_w(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength) { /* stall */ return (USB_ERR_STALLED); } static void -usb2_temp_unsetup_w(struct usb_device *udev) +usb_temp_unsetup_w(struct usb_device *udev) { - if (udev->usb2_template_ptr) { + if (udev->usb_template_ptr) { - free(udev->usb2_template_ptr, M_USB); + free(udev->usb_template_ptr, M_USB); - udev->usb2_template_ptr = NULL; + udev->usb_template_ptr = NULL; } } static uint8_t -usb2_test_huawei_autoinst_w(struct usb_device *udev, +usb_test_huawei_autoinst_w(struct usb_device *udev, struct usb_attach_arg *uaa) { return (USB_ERR_INVAL); } void -usb2_quirk_unload(void *arg) +usb_quirk_unload(void *arg) { /* reset function pointers */ - usb2_test_quirk_p = &usb2_test_quirk_w; - usb2_quirk_ioctl_p = &usb2_quirk_ioctl_w; + usb_test_quirk_p = &usb_test_quirk_w; + usb_quirk_ioctl_p = &usb_quirk_ioctl_w; /* wait for CPU to exit the loaded functions, if any */ @@ -109,13 +109,13 @@ usb2_quirk_unload(void *arg) } void -usb2_temp_unload(void *arg) +usb_temp_unload(void *arg) { /* reset function pointers */ - usb2_temp_get_desc_p = &usb2_temp_get_desc_w; - usb2_temp_setup_by_index_p = &usb2_temp_setup_by_index_w; - usb2_temp_unsetup_p = &usb2_temp_unsetup_w; + usb_temp_get_desc_p = &usb_temp_get_desc_w; + usb_temp_setup_by_index_p = &usb_temp_setup_by_index_w; + usb_temp_unsetup_p = &usb_temp_unsetup_w; /* wait for CPU to exit the loaded functions, if any */ @@ -125,11 +125,11 @@ usb2_temp_unload(void *arg) } void -usb2_bus_unload(void *arg) +usb_bus_unload(void *arg) { /* reset function pointers */ - usb2_devclass_ptr = NULL; + usb_devclass_ptr = NULL; /* wait for CPU to exit the loaded functions, if any */ @@ -139,11 +139,11 @@ usb2_bus_unload(void *arg) } void -usb2_test_huawei_unload(void *arg) +usb_test_huawei_unload(void *arg) { /* reset function pointers */ - usb2_test_huawei_autoinst_p = &usb2_test_huawei_autoinst_w; + usb_test_huawei_autoinst_p = &usb_test_huawei_autoinst_w; /* wait for CPU to exit the loaded functions, if any */ diff --git a/sys/dev/usb/usb_dynamic.h b/sys/dev/usb/usb_dynamic.h index ec1d783..1c47c52 100644 --- a/sys/dev/usb/usb_dynamic.h +++ b/sys/dev/usb/usb_dynamic.h @@ -30,38 +30,38 @@ /* prototypes */ struct usb_device; -struct usb_lookup_info; +struct usbd_lookup_info; struct usb_device_request; /* typedefs */ -typedef usb_error_t (usb2_temp_setup_by_index_t)(struct usb_device *udev, +typedef usb_error_t (usb_temp_setup_by_index_t)(struct usb_device *udev, uint16_t index); -typedef usb_error_t (usb2_test_huawei_autoinst_t)(struct usb_device *udev, +typedef usb_error_t (usb_test_huawei_autoinst_t)(struct usb_device *udev, struct usb_attach_arg *uaa); -typedef uint8_t (usb2_test_quirk_t)(const struct usb_lookup_info *info, +typedef uint8_t (usb_test_quirk_t)(const struct usbd_lookup_info *info, uint16_t quirk); -typedef int (usb2_quirk_ioctl_t)(unsigned long cmd, caddr_t data, +typedef int (usb_quirk_ioctl_t)(unsigned long cmd, caddr_t data, int fflag, struct thread *td); -typedef void (usb2_temp_unsetup_t)(struct usb_device *udev); +typedef void (usb_temp_unsetup_t)(struct usb_device *udev); /* global function pointers */ -extern usb_handle_req_t *usb2_temp_get_desc_p; -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; -extern usb2_test_huawei_autoinst_t *usb2_test_huawei_autoinst_p; -extern usb2_quirk_ioctl_t *usb2_quirk_ioctl_p; -extern devclass_t usb2_devclass_ptr; +extern usb_handle_req_t *usb_temp_get_desc_p; +extern usb_temp_setup_by_index_t *usb_temp_setup_by_index_p; +extern usb_temp_unsetup_t *usb_temp_unsetup_p; +extern usb_test_quirk_t *usb_test_quirk_p; +extern usb_test_huawei_autoinst_t *usb_test_huawei_autoinst_p; +extern usb_quirk_ioctl_t *usb_quirk_ioctl_p; +extern devclass_t usb_devclass_ptr; /* function prototypes */ -void usb2_test_huawei_unload(void *); -void usb2_temp_unload(void *); -void usb2_quirk_unload(void *); -void usb2_bus_unload(void *); +void usb_test_huawei_unload(void *); +void usb_temp_unload(void *); +void usb_quirk_unload(void *); +void usb_bus_unload(void *); -uint8_t usb2_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk); +uint8_t usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk); #endif /* _USB2_DYNAMIC_H_ */ diff --git a/sys/dev/usb/usb_error.c b/sys/dev/usb/usb_error.c index c99652b..68a811f 100644 --- a/sys/dev/usb/usb_error.c +++ b/sys/dev/usb/usb_error.c @@ -62,12 +62,12 @@ static const char* usb_errstr_table[USB_ERR_MAX] = { }; /*------------------------------------------------------------------------* - * usb2_errstr + * usbd_errstr * * This function converts an USB error code into a string. *------------------------------------------------------------------------*/ const char * -usb2_errstr(usb_error_t err) +usbd_errstr(usb_error_t err) { return (err < USB_ERR_MAX ? usb_errstr_table[err] : "USB_ERR_UNKNOWN"); } diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c index 1a7939a..29a682a 100644 --- a/sys/dev/usb/usb_generic.c +++ b/sys/dev/usb/usb_generic.c @@ -82,7 +82,7 @@ static int ugen_set_interface(struct usb_fifo *, uint8_t, uint8_t); static int ugen_get_cdesc(struct usb_fifo *, struct usb_gen_descriptor *); static int ugen_get_sdesc(struct usb_fifo *, struct usb_gen_descriptor *); static int ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd); -static int usb2_gen_fill_deviceinfo(struct usb_fifo *, +static int usb_gen_fill_deviceinfo(struct usb_fifo *, struct usb_device_info *); static int ugen_re_enumerate(struct usb_fifo *); static int ugen_iface_ioctl(struct usb_fifo *, u_long, void *, int); @@ -91,7 +91,7 @@ static int ugen_fs_uninit(struct usb_fifo *f); /* structures */ -struct usb_fifo_methods usb2_ugen_methods = { +struct usb_fifo_methods usb_ugen_methods = { .f_open = &ugen_open, .f_close = &ugen_close, .f_ioctl = &ugen_ioctl, @@ -125,23 +125,23 @@ ugen_transfer_setup(struct usb_fifo *f, mtx_unlock(f->priv_mtx); /* - * "usb2_transfer_setup()" can sleep so one needs to make a wrapper, + * "usbd_transfer_setup()" can sleep so one needs to make a wrapper, * exiting the mutex and checking things */ - error = usb2_transfer_setup(udev, &iface_index, f->xfer, + error = usbd_transfer_setup(udev, &iface_index, f->xfer, setup, n_setup, f, f->priv_mtx); if (error == 0) { if (f->xfer[0]->nframes == 1) { - error = usb2_fifo_alloc_buffer(f, + error = usb_fifo_alloc_buffer(f, f->xfer[0]->max_data_length, 2); } else { - error = usb2_fifo_alloc_buffer(f, + error = usb_fifo_alloc_buffer(f, f->xfer[0]->max_frame_size, 2 * f->xfer[0]->nframes); } if (error) { - usb2_transfer_unsetup(f->xfer, n_setup); + usbd_transfer_unsetup(f->xfer, n_setup); } } mtx_lock(f->priv_mtx); @@ -159,7 +159,7 @@ ugen_open(struct usb_fifo *f, int fflags) DPRINTFN(6, "flag=0x%x\n", fflags); mtx_lock(f->priv_mtx); - switch (usb2_get_speed(f->udev)) { + switch (usbd_get_speed(f->udev)) { case USB_SPEED_LOW: case USB_SPEED_FULL: f->nframes = UGEN_HW_FRAMES; @@ -191,12 +191,12 @@ ugen_close(struct usb_fifo *f, int fflags) /* cleanup */ mtx_lock(f->priv_mtx); - usb2_transfer_stop(f->xfer[0]); - usb2_transfer_stop(f->xfer[1]); + usbd_transfer_stop(f->xfer[0]); + usbd_transfer_stop(f->xfer[1]); mtx_unlock(f->priv_mtx); - usb2_transfer_unsetup(f->xfer, 2); - usb2_fifo_free_buffer(f); + usbd_transfer_unsetup(f->xfer, 2); + usb_fifo_free_buffer(f); if (ugen_fs_uninit(f)) { /* ignore any errors - we are closing */ @@ -348,11 +348,11 @@ ugen_start_read(struct usb_fifo *f) /* check that pipes are open */ if (ugen_open_pipe_read(f)) { /* signal error */ - usb2_fifo_put_data_error(f); + usb_fifo_put_data_error(f); } /* start transfers */ - usb2_transfer_start(f->xfer[0]); - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[0]); + usbd_transfer_start(f->xfer[1]); } static void @@ -361,19 +361,19 @@ ugen_start_write(struct usb_fifo *f) /* check that pipes are open */ if (ugen_open_pipe_write(f)) { /* signal error */ - usb2_fifo_get_data_error(f); + usb_fifo_get_data_error(f); } /* start transfers */ - usb2_transfer_start(f->xfer[0]); - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[0]); + usbd_transfer_start(f->xfer[1]); } static void ugen_stop_io(struct usb_fifo *f) { /* stop transfers */ - usb2_transfer_stop(f->xfer[0]); - usb2_transfer_stop(f->xfer[1]); + usbd_transfer_stop(f->xfer[0]); + usbd_transfer_stop(f->xfer[1]); } static void @@ -401,28 +401,28 @@ ugen_default_read_callback(struct usb_xfer *xfer) xfer->interval = 0; f->fifo_zlp = 0; } - usb2_fifo_put_data(f, xfer->frbuffers, 0, + usb_fifo_put_data(f, xfer->frbuffers, 0, xfer->actlen, 1); case USB_ST_SETUP: if (f->flag_stall) { - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[1]); break; } USB_IF_POLL(&f->free_q, m); if (m) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { /* send a zero length packet to userland */ - usb2_fifo_put_data(f, xfer->frbuffers, 0, 0, 1); + usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1); f->flag_stall = 1; f->fifo_zlp = 0; - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[1]); } break; } @@ -444,23 +444,23 @@ ugen_default_write_callback(struct usb_xfer *xfer) * callback and solve the situation. */ if (f->flag_stall) { - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[1]); break; } /* * Write data, setup and perform hardware transfer. */ - if (usb2_fifo_get_data(f, xfer->frbuffers, 0, + if (usb_fifo_get_data(f, xfer->frbuffers, 0, xfer->max_data_length, &actlen, 0)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { f->flag_stall = 1; - usb2_transfer_start(f->xfer[1]); + usbd_transfer_start(f->xfer[1]); } break; } @@ -476,10 +476,10 @@ ugen_read_clear_stall_callback(struct usb_xfer *xfer) /* nothing to do */ return; } - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTFN(5, "f=%p: stall cleared\n", f); f->flag_stall = 0; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -493,10 +493,10 @@ ugen_write_clear_stall_callback(struct usb_xfer *xfer) /* nothing to do */ return; } - if (usb2_clear_stall_callback(xfer, xfer_other)) { + if (usbd_clear_stall_callback(xfer, xfer_other)) { DPRINTFN(5, "f=%p: stall cleared\n", f); f->flag_stall = 0; - usb2_transfer_start(xfer_other); + usbd_transfer_start(xfer_other); } } @@ -517,7 +517,7 @@ ugen_isoc_read_callback(struct usb_xfer *xfer) offset = 0; for (n = 0; n != xfer->aframes; n++) { - usb2_fifo_put_data(f, xfer->frbuffers, offset, + usb_fifo_put_data(f, xfer->frbuffers, offset, xfer->frlengths[n], 1); offset += xfer->max_frame_size; } @@ -528,7 +528,7 @@ tr_setup: /* setup size for next transfer */ xfer->frlengths[n] = xfer->max_frame_size; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -555,7 +555,7 @@ ugen_isoc_write_callback(struct usb_xfer *xfer) tr_setup: offset = 0; for (n = 0; n != xfer->nframes; n++) { - if (usb2_fifo_get_data(f, xfer->frbuffers, offset, + if (usb_fifo_get_data(f, xfer->frbuffers, offset, xfer->max_frame_size, &actlen, 1)) { xfer->frlengths[n] = actlen; offset += actlen; @@ -568,7 +568,7 @@ tr_setup: /* fill in zero frames */ xfer->frlengths[n] = 0; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -599,11 +599,11 @@ ugen_set_config(struct usb_fifo *f, uint8_t index) DPRINTFN(6, "no FIFOs\n"); } /* change setting - will free generic FIFOs, if any */ - if (usb2_set_config_index(f->udev, index)) { + if (usbd_set_config_index(f->udev, index)) { return (EIO); } /* probe and attach */ - if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) { + if (usb_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) { return (EIO); } return (0); @@ -626,11 +626,11 @@ ugen_set_interface(struct usb_fifo *f, DPRINTFN(6, "no FIFOs\n"); } /* change setting - will free generic FIFOs, if any */ - if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) { + if (usbd_set_alt_interface_index(f->udev, iface_index, alt_index)) { return (EIO); } /* probe and attach */ - if (usb2_probe_and_attach(f->udev, iface_index)) { + if (usb_probe_and_attach(f->udev, iface_index)) { return (EIO); } return (0); @@ -659,14 +659,14 @@ ugen_get_cdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd) } if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) || (ugd->ugd_config_index == udev->curr_config_index)) { - cdesc = usb2_get_config_descriptor(udev); + cdesc = usbd_get_config_descriptor(udev); if (cdesc == NULL) { return (ENXIO); } free_data = 0; } else { - if (usb2_req_get_config_desc_full(udev, + if (usbd_req_get_config_desc_full(udev, NULL, &cdesc, M_USBDEV, ugd->ugd_config_index)) { return (ENXIO); @@ -698,7 +698,7 @@ ugen_get_sdesc(struct usb_fifo *f, struct usb_gen_descriptor *ugd) uint16_t size = sizeof(f->udev->bus->scratch[0].data); int error; - if (usb2_req_get_string_desc(f->udev, NULL, ptr, + if (usbd_req_get_string_desc(f->udev, NULL, ptr, size, ugd->ugd_lang_id, ugd->ugd_string_index)) { error = EINVAL; } else { @@ -745,7 +745,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd) return (EINVAL); } - iface = usb2_get_iface(udev, ugd->ugd_iface_index); + iface = usbd_get_iface(udev, ugd->ugd_iface_index); if ((iface == NULL) || (iface->idesc == NULL)) { /* invalid interface index */ return (EINVAL); @@ -779,7 +779,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd) } /*------------------------------------------------------------------------* - * usb2_gen_fill_deviceinfo + * usb_gen_fill_deviceinfo * * This function dumps information about an USB device to the * structure pointed to by the "di" argument. @@ -789,7 +789,7 @@ ugen_get_iface_driver(struct usb_fifo *f, struct usb_gen_descriptor *ugd) * Else: Failure *------------------------------------------------------------------------*/ static int -usb2_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di) +usb_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di) { struct usb_device *udev; struct usb_device *hub; @@ -804,7 +804,7 @@ usb2_gen_fill_deviceinfo(struct usb_fifo *f, struct usb_device_info *di) strlcpy(di->udi_serial, udev->serial, sizeof(di->udi_serial)); strlcpy(di->udi_vendor, udev->manufacturer, sizeof(di->udi_vendor)); strlcpy(di->udi_product, udev->product, sizeof(di->udi_product)); - usb2_printBCD(di->udi_release, sizeof(di->udi_release), + usb_printbcd(di->udi_release, sizeof(di->udi_release), UGETW(udev->ddesc.bcdDevice)); di->udi_vendorNo = UGETW(udev->ddesc.idVendor); di->udi_productNo = UGETW(udev->ddesc.idProduct); @@ -864,13 +864,13 @@ ugen_check_request(struct usb_device *udev, struct usb_device_request *req) */ if (req->bmRequestType == UT_WRITE_ENDPOINT) { - ep = usb2_get_ep_by_addr(udev, req->wIndex[0]); + ep = usbd_get_ep_by_addr(udev, req->wIndex[0]); if (ep == NULL) { return (EINVAL); } if ((req->bRequest == UR_CLEAR_FEATURE) && (UGETW(req->wValue) == UF_ENDPOINT_HALT)) { - usb2_clear_data_toggle(udev, ep); + usbd_clear_data_toggle(udev, ep); } } /* TODO: add more checks to verify the interface index */ @@ -897,7 +897,7 @@ ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur) } } /* do the USB request */ - error = usb2_do_request_flags + error = usbd_do_request_flags (f->udev, NULL, &ur->ucr_request, ur->ucr_data, (ur->ucr_flags & USB_SHORT_XFER_OK) | USB_USER_DATA_PTR, &actlen, @@ -934,7 +934,7 @@ ugen_re_enumerate(struct usb_fifo *f) } /* do a bus-reset */ mtx_lock(f->priv_mtx); - error = usb2_req_re_enumerate(udev, f->priv_mtx); + error = usbd_req_re_enumerate(udev, f->priv_mtx); mtx_unlock(f->priv_mtx); if (error) { @@ -954,13 +954,13 @@ ugen_fs_uninit(struct usb_fifo *f) if (f->fs_xfer == NULL) { return (EINVAL); } - usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max); + usbd_transfer_unsetup(f->fs_xfer, f->fs_ep_max); free(f->fs_xfer, M_USB); f->fs_xfer = NULL; f->fs_ep_max = 0; f->fs_ep_ptr = NULL; f->flag_iscomplete = 0; - usb2_fifo_free_buffer(f); + usb_fifo_free_buffer(f); return (0); } @@ -1006,7 +1006,7 @@ ugen_fs_set_complete(struct usb_fifo *f, uint8_t index) f->flag_iscomplete = 1; - usb2_fifo_wakeup(f); + usb_fifo_wakeup(f); } static int @@ -1032,7 +1032,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index) return (EINVAL); } mtx_lock(f->priv_mtx); - if (usb2_transfer_pending(xfer)) { + if (usbd_transfer_pending(xfer)) { mtx_unlock(f->priv_mtx); return (EBUSY); /* should not happen */ } @@ -1059,7 +1059,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index) return (error); } /* reset first frame */ - usb2_set_frame_offset(xfer, 0, 0); + usbd_set_frame_offset(xfer, 0, 0); if (xfer->flags_int.control_xfr) { @@ -1162,7 +1162,7 @@ ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index) kaddr = USB_ADD_BYTES(kaddr, offset); } else { /* set current frame offset */ - usb2_set_frame_offset(xfer, offset, n); + usbd_set_frame_offset(xfer, offset, n); /* get kernel buffer address */ kaddr = xfer->frbuffers[n].buffer; @@ -1210,7 +1210,7 @@ ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index) return (EINVAL); mtx_lock(f->priv_mtx); - if (usb2_transfer_pending(xfer)) { + if (usbd_transfer_pending(xfer)) { mtx_unlock(f->priv_mtx); return (EBUSY); /* should not happen */ } @@ -1403,7 +1403,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; } mtx_lock(f->priv_mtx); - usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]); + usbd_transfer_start(f->fs_xfer[u.pstart->ep_index]); mtx_unlock(f->priv_mtx); break; @@ -1413,7 +1413,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; } mtx_lock(f->priv_mtx); - usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]); + usbd_transfer_stop(f->fs_xfer[u.pstop->ep_index]); mtx_unlock(f->priv_mtx); break; @@ -1437,7 +1437,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) error = EINVAL; break; } - ep = usb2_get_ep_by_addr(f->udev, u.popen->ep_no); + ep = usbd_get_ep_by_addr(f->udev, u.popen->ep_no); if (ep == NULL) { error = EINVAL; break; @@ -1488,7 +1488,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) } } } - error = usb2_transfer_setup(f->udev, &iface_index, + error = usbd_transfer_setup(f->udev, &iface_index, f->fs_xfer + u.popen->ep_index, usb_config, 1, f, f->priv_mtx); if (error == 0) { @@ -1513,7 +1513,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) error = EINVAL; break; } - usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1); + usbd_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1); break; case USB_FS_CLEAR_STALL_SYNC: @@ -1530,7 +1530,7 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; } mtx_lock(f->priv_mtx); - error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]); + error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]); mtx_unlock(f->priv_mtx); if (error) { @@ -1546,9 +1546,9 @@ ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags) req.wIndex[1] = 0; USETW(req.wLength, 0); - error = usb2_do_request(f->udev, NULL, &req, NULL); + error = usbd_do_request(f->udev, NULL, &req, NULL); if (error == 0) { - usb2_clear_data_toggle(f->udev, ep); + usbd_clear_data_toggle(f->udev, ep); } else { error = ENXIO; } @@ -1645,7 +1645,7 @@ ugen_get_iface_desc(struct usb_fifo *f, { struct usb_interface *iface; - iface = usb2_get_iface(f->udev, f->iface_index); + iface = usbd_get_iface(f->udev, f->iface_index); if (iface && iface->idesc) { *idesc = *(iface->idesc); } else { @@ -1702,7 +1702,7 @@ ugen_set_power_mode(struct usb_fifo *f, int mode) } /* clear port enable */ - err = usb2_req_clear_port_feature(udev->parent_hub, + err = usbd_req_clear_port_feature(udev->parent_hub, NULL, udev->port_no, UHF_PORT_ENABLE); break; @@ -1711,13 +1711,13 @@ ugen_set_power_mode(struct usb_fifo *f, int mode) break; case USB_POWER_MODE_RESUME: - err = usb2_req_clear_port_feature(udev->parent_hub, + err = usbd_req_clear_port_feature(udev->parent_hub, NULL, udev->port_no, UHF_PORT_SUSPEND); mode = USB_POWER_MODE_SAVE; break; case USB_POWER_MODE_SUSPEND: - err = usb2_req_set_port_feature(udev->parent_hub, + err = usbd_req_set_port_feature(udev->parent_hub, NULL, udev->port_no, UHF_PORT_SUSPEND); mode = USB_POWER_MODE_SAVE; break; @@ -1737,7 +1737,7 @@ ugen_set_power_mode(struct usb_fifo *f, int mode) } /* set new power mode */ - usb2_set_power_mode(udev, mode); + usbd_set_power_mode(udev, mode); return (0); /* success */ } @@ -1779,10 +1779,10 @@ ugen_do_port_feature(struct usb_fifo *f, uint8_t port_no, return (EINVAL); } if (set) - err = usb2_req_set_port_feature(udev, + err = usbd_req_set_port_feature(udev, NULL, port_no, feature); else - err = usb2_req_clear_port_feature(udev, + err = usbd_req_clear_port_feature(udev, NULL, port_no, feature); if (err) @@ -1960,7 +1960,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) switch (cmd) { case USB_DISCOVER: - usb2_needs_explore_all(); + usb_needs_explore_all(); break; case USB_SETDEBUG: @@ -1968,7 +1968,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) error = EPERM; break; } - usb2_debug = *(int *)addr; + usb_debug = *(int *)addr; break; case USB_GET_CONFIG: @@ -1984,7 +1984,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; case USB_GET_ALTINTERFACE: - iface = usb2_get_iface(f->udev, + iface = usbd_get_iface(f->udev, u.ai->uai_interface_index); if (iface && iface->idesc) { u.ai->uai_alt_index = iface->alt_index; @@ -2003,7 +2003,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; case USB_GET_DEVICE_DESC: - dtemp = usb2_get_device_descriptor(f->udev); + dtemp = usbd_get_device_descriptor(f->udev); if (!dtemp) { error = EIO; break; @@ -2012,7 +2012,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) break; case USB_GET_CONFIG_DESC: - ctemp = usb2_get_config_descriptor(f->udev); + ctemp = usbd_get_config_descriptor(f->udev); if (!ctemp) { error = EIO; break; @@ -2043,7 +2043,7 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) case USB_DEVICEINFO: case USB_GET_DEVICEINFO: - error = usb2_gen_fill_deviceinfo(f, addr); + error = usb_gen_fill_deviceinfo(f, addr); break; case USB_DEVICESTATS: @@ -2128,14 +2128,14 @@ ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags) error = EBUSY; break; } - error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max); + error = usb_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max); if (error) { break; } f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) * u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO); if (f->fs_xfer == NULL) { - usb2_fifo_free_buffer(f); + usb_fifo_free_buffer(f); error = ENOMEM; break; } @@ -2171,7 +2171,7 @@ ugen_default_fs_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_SETUP: - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo)); diff --git a/sys/dev/usb/usb_generic.h b/sys/dev/usb/usb_generic.h index 96b9d1d..1b6ea12 100644 --- a/sys/dev/usb/usb_generic.h +++ b/sys/dev/usb/usb_generic.h @@ -27,7 +27,7 @@ #ifndef _USB2_GENERIC_H_ #define _USB2_GENERIC_H_ -extern struct usb_fifo_methods usb2_ugen_methods; +extern struct usb_fifo_methods usb_ugen_methods; int ugen_do_request(struct usb_fifo *f, struct usb_ctl_request *ur); #endif /* _USB2_GENERIC_H_ */ diff --git a/sys/dev/usb/usb_handle_request.c b/sys/dev/usb/usb_handle_request.c index 0f2f8c0..e6f89f6 100644 --- a/sys/dev/usb/usb_handle_request.c +++ b/sys/dev/usb/usb_handle_request.c @@ -28,7 +28,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -44,24 +44,24 @@ /* function prototypes */ -static uint8_t usb2_handle_get_stall(struct usb_device *, uint8_t); -static usb_error_t usb2_handle_remote_wakeup(struct usb_xfer *, uint8_t); -static usb_error_t usb2_handle_request(struct usb_xfer *); -static usb_error_t usb2_handle_set_config(struct usb_xfer *, uint8_t); -static usb_error_t usb2_handle_set_stall(struct usb_xfer *, uint8_t, +static uint8_t usb_handle_get_stall(struct usb_device *, uint8_t); +static usb_error_t usb_handle_remote_wakeup(struct usb_xfer *, uint8_t); +static usb_error_t usb_handle_request(struct usb_xfer *); +static usb_error_t usb_handle_set_config(struct usb_xfer *, uint8_t); +static usb_error_t usb_handle_set_stall(struct usb_xfer *, uint8_t, uint8_t); -static usb_error_t usb2_handle_iface_request(struct usb_xfer *, void **, +static usb_error_t usb_handle_iface_request(struct usb_xfer *, void **, uint16_t *, struct usb_device_request, uint16_t, uint8_t); /*------------------------------------------------------------------------* - * usb2_handle_request_callback + * usb_handle_request_callback * * This function is the USB callback for generic USB Device control * transfers. *------------------------------------------------------------------------*/ void -usb2_handle_request_callback(struct usb_xfer *xfer) +usb_handle_request_callback(struct usb_xfer *xfer) { usb_error_t err; @@ -72,25 +72,25 @@ usb2_handle_request_callback(struct usb_xfer *xfer) case USB_ST_TRANSFERRED: /* handle the request */ - err = usb2_handle_request(xfer); + err = usb_handle_request(xfer); if (err) { if (err == USB_ERR_BAD_CONTEXT) { /* we need to re-setup the control transfer */ - usb2_needs_explore(xfer->xroot->bus, 0); + usb_needs_explore(xfer->xroot->bus, 0); break; } goto tr_restart; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* check if a control transfer is active */ if (xfer->flags_int.control_rem != 0xFFFF) { /* handle the request */ - err = usb2_handle_request(xfer); + err = usb_handle_request(xfer); } if (xfer->error != USB_ERR_CANCELLED) { /* should not happen - try stalling */ @@ -110,18 +110,18 @@ tr_restart: xfer->flags.manual_status = 1; xfer->flags.force_short_xfer = 0; xfer->flags.stall_pipe = 1; /* cancel previous transfer, if any */ - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } /*------------------------------------------------------------------------* - * usb2_handle_set_config + * usb_handle_set_config * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t -usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no) +usb_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no) { struct usb_device *udev = xfer->xroot->udev; usb_error_t err = 0; @@ -144,12 +144,12 @@ usb2_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no) conf_no--; } - if (usb2_set_config_index(udev, conf_no)) { + if (usbd_set_config_index(udev, conf_no)) { DPRINTF("set config %d failed\n", conf_no); err = USB_ERR_STALLED; goto done; } - if (usb2_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) { + if (usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) { DPRINTF("probe and attach failed\n"); err = USB_ERR_STALLED; goto done; @@ -162,14 +162,14 @@ done: } /*------------------------------------------------------------------------* - * usb2_handle_iface_request + * usb_handle_iface_request * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t -usb2_handle_iface_request(struct usb_xfer *xfer, +usb_handle_iface_request(struct usb_xfer *xfer, void **ppdata, uint16_t *plen, struct usb_device_request req, uint16_t off, uint8_t state) { @@ -196,7 +196,7 @@ usb2_handle_iface_request(struct usb_xfer *xfer, error = ENXIO; tr_repeat: - iface = usb2_get_iface(udev, iface_index); + iface = usbd_get_iface(udev, iface_index); if ((iface == NULL) || (iface->idesc == NULL)) { /* end of interfaces non-existing interface */ @@ -215,7 +215,7 @@ tr_repeat: &req, ppdata, plen, off, state); } - iface_parent = usb2_get_iface(udev, iface->parent_iface_index); + iface_parent = usbd_get_iface(udev, iface->parent_iface_index); if ((iface_parent == NULL) || (iface_parent->idesc == NULL)) { @@ -265,11 +265,11 @@ tr_repeat: */ if ((iface_parent != NULL) || (iface->alt_index == req.wValue[0])) { - error = usb2_reset_iface_endpoints(udev, + error = usb_reset_iface_endpoints(udev, iface_index); if (error) { DPRINTF("alt setting failed %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto tr_stalled; } break; @@ -278,14 +278,14 @@ tr_repeat: * Doing the alternate setting will detach the * interface aswell: */ - error = usb2_set_alt_interface_index(udev, + error = usbd_set_alt_interface_index(udev, iface_index, req.wValue[0]); if (error) { DPRINTF("alt setting failed %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto tr_stalled; } - error = usb2_probe_and_attach(udev, + error = usb_probe_and_attach(udev, iface_index); if (error) { DPRINTF("alt setting probe failed\n"); @@ -325,39 +325,39 @@ tr_stalled: } /*------------------------------------------------------------------------* - * usb2_handle_stall + * usb_handle_stall * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t -usb2_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall) +usb_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall) { struct usb_device *udev = xfer->xroot->udev; usb_error_t err; USB_XFER_UNLOCK(xfer); - err = usb2_set_endpoint_stall(udev, - usb2_get_ep_by_addr(udev, ep), do_stall); + err = usbd_set_endpoint_stall(udev, + usbd_get_ep_by_addr(udev, ep), do_stall); USB_XFER_LOCK(xfer); return (err); } /*------------------------------------------------------------------------* - * usb2_handle_get_stall + * usb_handle_get_stall * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static uint8_t -usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val) +usb_handle_get_stall(struct usb_device *udev, uint8_t ea_val) { struct usb_endpoint *ep; uint8_t halted; - ep = usb2_get_ep_by_addr(udev, ea_val); + ep = usbd_get_ep_by_addr(udev, ea_val); if (ep == NULL) { /* nothing to do */ return (0); @@ -370,14 +370,14 @@ usb2_handle_get_stall(struct usb_device *udev, uint8_t ea_val) } /*------------------------------------------------------------------------* - * usb2_handle_remote_wakeup + * usb_handle_remote_wakeup * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t -usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on) +usb_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on) { struct usb_device *udev; struct usb_bus *bus; @@ -396,12 +396,12 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on) USB_BUS_UNLOCK(bus); /* In case we are out of sync, update the power state. */ - usb2_bus_power_update(udev->bus); + usb_bus_power_update(udev->bus); return (0); /* success */ } /*------------------------------------------------------------------------* - * usb2_handle_request + * usb_handle_request * * Internal state sequence: * @@ -412,7 +412,7 @@ usb2_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on) * Else: Stall current transfer, if any *------------------------------------------------------------------------*/ static usb_error_t -usb2_handle_request(struct usb_xfer *xfer) +usb_handle_request(struct usb_xfer *xfer) { struct usb_device_request req; struct usb_device *udev; @@ -460,12 +460,12 @@ usb2_handle_request(struct usb_xfer *xfer) xfer->frlengths[0] = 0; - usb2_set_frame_offset(xfer, 0, 0); - usb2_set_frame_offset(xfer, sizeof(req), 1); + usbd_set_frame_offset(xfer, 0, 0); + usbd_set_frame_offset(xfer, sizeof(req), 1); /* get the current request, if any */ - usb2_copy_out(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req)); if (xfer->flags_int.control_rem == 0xFFFF) { /* first time - not initialised */ @@ -572,7 +572,7 @@ usb2_handle_request(struct usb_xfer *xfer) break; default: /* we use "USB_ADD_BYTES" to de-const the src_zcopy */ - err = usb2_handle_iface_request(xfer, + err = usb_handle_iface_request(xfer, USB_ADD_BYTES(&src_zcopy, 0), &max_len, req, off, state); if (err == 0) { @@ -595,7 +595,7 @@ usb2_handle_request(struct usb_xfer *xfer) goto tr_valid; tr_handle_get_descriptor: - err = (usb2_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len); + err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len); if (err) goto tr_stalled; if (src_zcopy == NULL) @@ -643,7 +643,7 @@ tr_handle_set_address: tr_handle_set_config: if (state == USB_HR_NOT_COMPLETE) { - if (usb2_handle_set_config(xfer, req.wValue[0])) { + if (usb_handle_set_config(xfer, req.wValue[0])) { goto tr_stalled; } } @@ -651,7 +651,7 @@ tr_handle_set_config: tr_handle_clear_halt: if (state == USB_HR_NOT_COMPLETE) { - if (usb2_handle_set_stall(xfer, req.wIndex[0], 0)) { + if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) { goto tr_stalled; } } @@ -659,7 +659,7 @@ tr_handle_clear_halt: tr_handle_clear_wakeup: if (state == USB_HR_NOT_COMPLETE) { - if (usb2_handle_remote_wakeup(xfer, 0)) { + if (usb_handle_remote_wakeup(xfer, 0)) { goto tr_stalled; } } @@ -667,7 +667,7 @@ tr_handle_clear_wakeup: tr_handle_set_halt: if (state == USB_HR_NOT_COMPLETE) { - if (usb2_handle_set_stall(xfer, req.wIndex[0], 1)) { + if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) { goto tr_stalled; } } @@ -675,7 +675,7 @@ tr_handle_set_halt: tr_handle_set_wakeup: if (state == USB_HR_NOT_COMPLETE) { - if (usb2_handle_remote_wakeup(xfer, 1)) { + if (usb_handle_remote_wakeup(xfer, 1)) { goto tr_stalled; } } @@ -684,7 +684,7 @@ tr_handle_set_wakeup: tr_handle_get_ep_status: if (state == USB_HR_NOT_COMPLETE) { temp.wStatus[0] = - usb2_handle_get_stall(udev, req.wIndex[0]); + usb_handle_get_stall(udev, req.wIndex[0]); temp.wStatus[1] = 0; src_mcopy = temp.wStatus; max_len = sizeof(temp.wStatus); @@ -732,10 +732,10 @@ tr_valid: if (max_len > 0) { if (src_mcopy) { src_mcopy = USB_ADD_BYTES(src_mcopy, off); - usb2_copy_in(xfer->frbuffers + 1, 0, + usbd_copy_in(xfer->frbuffers + 1, 0, src_mcopy, max_len); } else { - usb2_set_frame_data(xfer, + usbd_set_frame_data(xfer, USB_ADD_BYTES(src_zcopy, off), 1); } xfer->frlengths[1] = max_len; diff --git a/sys/dev/usb/usb_hid.c b/sys/dev/usb/usb_hid.c index df71978..63c625c 100644 --- a/sys/dev/usb/usb_hid.c +++ b/sys/dev/usb/usb_hid.c @@ -45,7 +45,7 @@ __FBSDID("$FreeBSD$"); #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -659,7 +659,7 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd, if (desc == NULL) { return (NULL); } - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if ((desc->bDescriptorType == UDESC_HID) && (desc->bLength >= USB_HID_DESCRIPTOR_SIZE(0))) { return (void *)desc; @@ -672,7 +672,7 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd, } /*------------------------------------------------------------------------* - * usb2_req_get_hid_desc + * usbd_req_get_hid_desc * * This function will read out an USB report descriptor from the USB * device. @@ -682,11 +682,11 @@ hid_get_descriptor_from_usb(struct usb_config_descriptor *cd, * Else: Success. The pointer should eventually be passed to free(). *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, void **descp, uint16_t *sizep, struct malloc_type *mem, uint8_t iface_index) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_hid_descriptor *hid; usb_error_t err; @@ -694,7 +694,7 @@ usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, return (USB_ERR_INVAL); } hid = hid_get_descriptor_from_usb - (usb2_get_config_descriptor(udev), iface->idesc); + (usbd_get_config_descriptor(udev), iface->idesc); if (hid == NULL) { return (USB_ERR_IOERROR); @@ -714,7 +714,7 @@ usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, if (*descp == NULL) { return (USB_ERR_NOMEM); } - err = usb2_req_get_report_descriptor + err = usbd_req_get_report_descriptor (udev, mtx, *descp, *sizep, iface_index); if (err) { diff --git a/sys/dev/usb/usb_hid.h b/sys/dev/usb/usb_hid.h index 4613d02..a0f4cfc 100644 --- a/sys/dev/usb/usb_hid.h +++ b/sys/dev/usb/usb_hid.h @@ -72,7 +72,7 @@ struct hid_item { struct hid_location loc; }; -/* prototypes from "usb2_hid.c" */ +/* prototypes from "usb_hid.c" */ struct hid_data *hid_start_parse(const void *d, usb_size_t len, int kindset); void hid_end_parse(struct hid_data *s); @@ -88,7 +88,7 @@ int hid_is_collection(const void *desc, usb_size_t size, uint32_t usage); struct usb_hid_descriptor *hid_get_descriptor_from_usb( struct usb_config_descriptor *cd, struct usb_interface_descriptor *id); -usb_error_t usb2_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx, void **descp, uint16_t *sizep, struct malloc_type *mem, uint8_t iface_index); diff --git a/sys/dev/usb/usb_hub.c b/sys/dev/usb/usb_hub.c index 595e7cd..2b48752 100644 --- a/sys/dev/usb/usb_hub.c +++ b/sys/dev/usb/usb_hub.c @@ -63,10 +63,10 @@ SYSCTL_INT(_hw_usb_uhub, OID_AUTO, debug, CTLFLAG_RW, &uhub_debug, 0, #endif #if USB_HAVE_POWERD -static int usb2_power_timeout = 30; /* seconds */ +static int usb_power_timeout = 30; /* seconds */ SYSCTL_INT(_hw_usb, OID_AUTO, power_timeout, CTLFLAG_RW, - &usb2_power_timeout, 0, "USB power timeout"); + &usb_power_timeout, 0, "USB power timeout"); #endif struct uhub_current_state { @@ -102,8 +102,8 @@ static bus_child_pnpinfo_str_t uhub_child_pnpinfo_string; static usb_callback_t uhub_intr_callback; -static void usb2_dev_resume_peer(struct usb_device *udev); -static void usb2_dev_suspend_peer(struct usb_device *udev); +static void usb_dev_resume_peer(struct usb_device *udev); +static void usb_dev_suspend_peer(struct usb_device *udev); static const struct usb_config uhub_config[UHUB_N_TRANSFER] = { @@ -162,11 +162,11 @@ uhub_intr_callback(struct usb_xfer *xfer) * event handler thread that we need * to be explored again: */ - usb2_needs_explore(sc->sc_udev->bus, 0); + usb_needs_explore(sc->sc_udev->bus, 0); case USB_ST_SETUP: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -178,7 +178,7 @@ uhub_intr_callback(struct usb_xfer *xfer) */ xfer->flags.stall_pipe = 1; xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; } @@ -206,7 +206,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up) refcount = bus->driver_added_refcount; /* get device assosiated with the given port */ - child = usb2_bus_port_get_device(bus, up); + child = usb_bus_port_get_device(bus, up); if (child == NULL) { /* nothing to do */ goto done; @@ -215,7 +215,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up) if (child->driver_added_refcount != refcount) { child->driver_added_refcount = refcount; - err = usb2_probe_and_attach(child, + err = usb_probe_and_attach(child, USB_IFACE_INDEX_ANY); if (err) { goto done; @@ -224,7 +224,7 @@ uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up) /* start control transfer, if device mode */ if (child->flags.usb_mode == USB_MODE_DEVICE) { - usb2_default_transfer_setup(child); + usbd_default_transfer_setup(child); } /* if a HUB becomes present, do a recursive HUB explore */ @@ -244,7 +244,7 @@ uhub_read_port_status(struct uhub_softc *sc, uint8_t portno) struct usb_port_status ps; usb_error_t err; - err = usb2_req_get_port_status( + err = usbd_req_get_port_status( sc->sc_udev, NULL, &ps, portno); /* update status regardless of error */ @@ -257,7 +257,7 @@ uhub_read_port_status(struct uhub_softc *sc, uint8_t portno) DPRINTFN(4, "port %d, wPortStatus=0x%04x, " "wPortChange=0x%04x, err=%s\n", portno, sc->sc_st.port_status, - sc->sc_st.port_change, usb2_errstr(err)); + sc->sc_st.port_change, usbd_errstr(err)); return (err); } @@ -283,14 +283,14 @@ uhub_reattach_port(struct uhub_softc *sc, uint8_t portno) err = 0; timeout = 0; udev = sc->sc_udev; - child = usb2_bus_port_get_device(udev->bus, + child = usb_bus_port_get_device(udev->bus, udev->hub->ports + portno - 1); repeat: /* first clear the port connection change bit */ - err = usb2_req_clear_port_feature(udev, NULL, + err = usbd_req_clear_port_feature(udev, NULL, portno, UHF_C_PORT_CONNECTION); if (err) { @@ -299,7 +299,7 @@ repeat: /* detach any existing devices */ if (child) { - usb2_free_device(child, + usb_free_device(child, USB_UNCFG_FLAG_FREE_SUBDEV | USB_UNCFG_FLAG_FREE_EP0); child = NULL; @@ -330,24 +330,24 @@ repeat: if (sc->sc_st.port_status & UPS_SUSPEND) { DPRINTF("Port %d was still " "suspended, clearing.\n", portno); - err = usb2_req_clear_port_feature(sc->sc_udev, + err = usbd_req_clear_port_feature(sc->sc_udev, NULL, portno, UHF_PORT_SUSPEND); } /* USB Host Mode */ /* wait for maximum device power up time */ - usb2_pause_mtx(NULL, + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_PORT_POWERUP_DELAY)); /* reset port, which implies enabling it */ - err = usb2_req_reset_port(udev, NULL, portno); + err = usbd_req_reset_port(udev, NULL, portno); if (err) { DPRINTFN(0, "port %d reset " "failed, error=%s\n", - portno, usb2_errstr(err)); + portno, usbd_errstr(err)); goto error; } /* get port status again, it might have changed during reset */ @@ -410,7 +410,7 @@ repeat: /* need to create a new child */ - child = usb2_alloc_device(sc->sc_dev, udev->bus, udev, + child = usb_alloc_device(sc->sc_dev, udev->bus, udev, udev->depth + 1, portno - 1, portno, speed, mode); if (child == NULL) { DPRINTFN(0, "could not allocate new device!\n"); @@ -420,21 +420,21 @@ repeat: error: if (child) { - usb2_free_device(child, + usb_free_device(child, USB_UNCFG_FLAG_FREE_SUBDEV | USB_UNCFG_FLAG_FREE_EP0); child = NULL; } if (err == 0) { if (sc->sc_st.port_status & UPS_PORT_ENABLED) { - err = usb2_req_clear_port_feature( + err = usbd_req_clear_port_feature( sc->sc_udev, NULL, portno, UHF_PORT_ENABLE); } } if (err) { DPRINTFN(0, "device problem (%s), " - "disabling port %d\n", usb2_errstr(err), portno); + "disabling port %d\n", usbd_errstr(err), portno); } return (err); } @@ -457,12 +457,12 @@ uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno) DPRINTF("port %d\n", portno); udev = sc->sc_udev; - child = usb2_bus_port_get_device(udev->bus, + child = usb_bus_port_get_device(udev->bus, udev->hub->ports + portno - 1); /* first clear the port suspend change bit */ - err = usb2_req_clear_port_feature(udev, NULL, + err = usbd_req_clear_port_feature(udev, NULL, portno, UHF_C_PORT_SUSPEND); if (err) { DPRINTF("clearing suspend failed.\n"); @@ -494,9 +494,9 @@ uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno) * suspend and resume here */ if (is_suspend == 0) - usb2_dev_resume_peer(child); + usb_dev_resume_peer(child); else if (child->flags.usb_mode == USB_MODE_DEVICE) - usb2_dev_suspend_peer(child); + usb_dev_suspend_peer(child); } done: return (err); @@ -514,7 +514,7 @@ uhub_root_intr(struct usb_bus *bus, const uint8_t *ptr, uint8_t len) { USB_BUS_LOCK_ASSERT(bus, MA_OWNED); - usb2_needs_explore(bus, 0); + usb_needs_explore(bus, 0); } /*------------------------------------------------------------------------* @@ -560,7 +560,7 @@ uhub_explore(struct usb_device *udev) } if (sc->sc_st.port_change & UPS_C_OVERCURRENT_INDICATOR) { DPRINTF("Overcurrent on port %u.\n", portno); - err = usb2_req_clear_port_feature( + err = usbd_req_clear_port_feature( udev, NULL, portno, UHF_C_PORT_OVER_CURRENT); if (err) { /* most likely the HUB is gone */ @@ -576,7 +576,7 @@ uhub_explore(struct usb_device *udev) UPS_C_CONNECT_STATUS; } if (sc->sc_st.port_change & UPS_C_PORT_ENABLED) { - err = usb2_req_clear_port_feature( + err = usbd_req_clear_port_feature( udev, NULL, portno, UHF_C_PORT_ENABLE); if (err) { /* most likely the HUB is gone */ @@ -675,7 +675,7 @@ uhub_attach(device_t dev) snprintf(sc->sc_name, sizeof(sc->sc_name), "%s", device_get_nameunit(dev)); - device_set_usb2_desc(dev); + device_set_usb_desc(dev); DPRINTFN(2, "depth=%d selfpowered=%d, parent=%p, " "parent->selfpowered=%d\n", @@ -701,17 +701,17 @@ uhub_attach(device_t dev) DPRINTFN(2, "getting HUB descriptor\n"); /* assuming that there is one port */ - err = usb2_req_get_hub_descriptor(udev, NULL, &hubdesc, 1); + err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc, 1); nports = hubdesc.bNbrPorts; if (!err && (nports >= 8)) { /* get complete HUB descriptor */ - err = usb2_req_get_hub_descriptor(udev, NULL, &hubdesc, nports); + err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc, nports); } if (err) { DPRINTFN(0, "getting hub descriptor failed," - "error=%s\n", usb2_errstr(err)); + "error=%s\n", usbd_errstr(err)); goto error; } if (hubdesc.bNbrPorts != nports) { @@ -732,7 +732,7 @@ uhub_attach(device_t dev) #if USB_HAVE_TT_SUPPORT /* init FULL-speed ISOCHRONOUS schedule */ - usb2_fs_isoc_schedule_init_all(hub->fs_isoc_schedule); + usbd_fs_isoc_schedule_init_all(hub->fs_isoc_schedule); #endif /* initialize HUB structure */ hub->hubsoftc = sc; @@ -754,16 +754,16 @@ uhub_attach(device_t dev) err = 0; } else { /* normal HUB */ - err = usb2_transfer_setup(udev, &iface_index, sc->sc_xfer, + err = usbd_transfer_setup(udev, &iface_index, sc->sc_xfer, uhub_config, UHUB_N_TRANSFER, sc, &Giant); } if (err) { DPRINTFN(0, "cannot setup interrupt transfer, " - "errstr=%s!\n", usb2_errstr(err)); + "errstr=%s!\n", usbd_errstr(err)); goto error; } /* wait with power off for a while */ - usb2_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME)); + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME)); /* * To have the best chance of success we do things in the exact same @@ -810,18 +810,18 @@ uhub_attach(device_t dev) } if (!err) { /* turn the power on */ - err = usb2_req_set_port_feature(udev, NULL, + err = usbd_req_set_port_feature(udev, NULL, portno, UHF_PORT_POWER); } if (err) { DPRINTFN(0, "port %d power on failed, %s\n", - portno, usb2_errstr(err)); + portno, usbd_errstr(err)); } DPRINTF("turn on port %d power\n", portno); /* wait for stable power */ - usb2_pause_mtx(NULL, USB_MS_TO_TICKS(pwrdly)); + usb_pause_mtx(NULL, USB_MS_TO_TICKS(pwrdly)); } device_printf(dev, "%d port%s with %d " @@ -832,18 +832,18 @@ uhub_attach(device_t dev) if (sc->sc_xfer[0] != NULL) { USB_XFER_LOCK(sc->sc_xfer[0]); - usb2_transfer_start(sc->sc_xfer[0]); + usbd_transfer_start(sc->sc_xfer[0]); USB_XFER_UNLOCK(sc->sc_xfer[0]); } /* Enable automatic power save on all USB HUBs */ - usb2_set_power_mode(udev, USB_POWER_MODE_SAVE); + usbd_set_power_mode(udev, USB_POWER_MODE_SAVE); return (0); error: - usb2_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER); if (udev->hub) { free(udev->hub, M_USBDEV); @@ -872,7 +872,7 @@ uhub_detach(device_t dev) } for (x = 0; x != hub->nports; x++) { - child = usb2_bus_port_get_device(sc->sc_udev->bus, hub->ports + x); + child = usb_bus_port_get_device(sc->sc_udev->bus, hub->ports + x); if (child == NULL) { continue; @@ -881,11 +881,11 @@ uhub_detach(device_t dev) * Subdevices are not freed, because the caller of * uhub_detach() will do that. */ - usb2_free_device(child, + usb_free_device(child, USB_UNCFG_FLAG_FREE_EP0); } - usb2_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER); free(hub, M_USBDEV); sc->sc_udev->hub = NULL; @@ -911,7 +911,7 @@ uhub_resume(device_t dev) static void uhub_driver_added(device_t dev, driver_t *driver) { - usb2_needs_explore_all(); + usb_needs_explore_all(); } struct hub_result { @@ -932,13 +932,13 @@ uhub_find_iface_index(struct usb_hub *hub, device_t child, nports = hub->nports; for (x = 0; x != nports; x++) { - udev = usb2_bus_port_get_device(hub->hubudev->bus, + udev = usb_bus_port_get_device(hub->hubudev->bus, hub->ports + x); if (!udev) { continue; } for (i = 0; i != USB_IFACE_MAX; i++) { - iface = usb2_get_iface(udev, i); + iface = usbd_get_iface(udev, i); if (iface && (iface->subdev == child)) { res->iface_index = i; @@ -996,7 +996,7 @@ uhub_child_pnpinfo_string(device_t parent, device_t child, } goto done; } - iface = usb2_get_iface(res.udev, res.iface_index); + iface = usbd_get_iface(res.udev, res.iface_index); if (iface && iface->idesc) { snprintf(buf, buflen, "vendor=0x%04x product=0x%04x " "devclass=0x%02x devsubclass=0x%02x " @@ -1052,13 +1052,13 @@ done: */ /*------------------------------------------------------------------------* - * usb2_intr_find_best_slot + * usb_intr_find_best_slot * * Return value: * The best Transaction Translation slot for an interrupt endpoint. *------------------------------------------------------------------------*/ static uint8_t -usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end) +usb_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end) { usb_size_t max = 0 - 1; uint8_t x; @@ -1078,7 +1078,7 @@ usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end) } /*------------------------------------------------------------------------* - * usb2_intr_schedule_adjust + * usb_intr_schedule_adjust * * This function will update the bandwith usage for the microframe * having index "slot" by "len" bytes. "len" can be negative. If the @@ -1090,7 +1090,7 @@ usb2_intr_find_best_slot(usb_size_t *ptr, uint8_t start, uint8_t end) * The slot on which the bandwidth update was done. *------------------------------------------------------------------------*/ uint8_t -usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) +usb_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) { struct usb_bus *bus = udev->bus; struct usb_hub *hub; @@ -1098,7 +1098,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) USB_BUS_LOCK_ASSERT(bus, MA_OWNED); - speed = usb2_get_speed(udev); + speed = usbd_get_speed(udev); switch (speed) { case USB_SPEED_LOW: @@ -1115,7 +1115,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) hub = udev->parent_hs_hub->hub; if (slot >= USB_HS_MICRO_FRAMES_MAX) { - slot = usb2_intr_find_best_slot(hub->uframe_usage, + slot = usb_intr_find_best_slot(hub->uframe_usage, USB_FS_ISOC_UFRAME_MAX, 6); } hub->uframe_usage[slot] += len; @@ -1123,7 +1123,7 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) break; default: if (slot >= USB_HS_MICRO_FRAMES_MAX) { - slot = usb2_intr_find_best_slot(bus->uframe_usage, 0, + slot = usb_intr_find_best_slot(bus->uframe_usage, 0, USB_HS_MICRO_FRAMES_MAX); } bus->uframe_usage[slot] += len; @@ -1133,14 +1133,14 @@ usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot) } /*------------------------------------------------------------------------* - * usb2_fs_isoc_schedule_init_sub + * usbd_fs_isoc_schedule_init_sub * * This function initialises an USB FULL speed isochronous schedule * entry. *------------------------------------------------------------------------*/ #if USB_HAVE_TT_SUPPORT static void -usb2_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss) +usbd_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss) { fss->total_bytes = (USB_FS_ISOC_UFRAME_MAX * USB_FS_BYTES_PER_HS_UFRAME); @@ -1150,26 +1150,26 @@ usb2_fs_isoc_schedule_init_sub(struct usb_fs_isoc_schedule *fss) #endif /*------------------------------------------------------------------------* - * usb2_fs_isoc_schedule_init_all + * usbd_fs_isoc_schedule_init_all * * This function will reset the complete USB FULL speed isochronous * bandwidth schedule. *------------------------------------------------------------------------*/ #if USB_HAVE_TT_SUPPORT void -usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss) +usbd_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss) { struct usb_fs_isoc_schedule *fss_end = fss + USB_ISOC_TIME_MAX; while (fss != fss_end) { - usb2_fs_isoc_schedule_init_sub(fss); + usbd_fs_isoc_schedule_init_sub(fss); fss++; } } #endif /*------------------------------------------------------------------------* - * usb2_isoc_time_expand + * usb_isoc_time_expand * * This function will expand the time counter from 7-bit to 16-bit. * @@ -1177,7 +1177,7 @@ usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss) * 16-bit isochronous time counter. *------------------------------------------------------------------------*/ uint16_t -usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr) +usb_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr) { uint16_t rem; @@ -1200,7 +1200,7 @@ usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr) } /*------------------------------------------------------------------------* - * usb2_fs_isoc_schedule_isoc_time_expand + * usbd_fs_isoc_schedule_isoc_time_expand * * This function does multiple things. First of all it will expand the * passed isochronous time, which is the return value. Then it will @@ -1216,7 +1216,7 @@ usb2_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr) *------------------------------------------------------------------------*/ #if USB_HAVE_TT_SUPPORT uint16_t -usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, +usbd_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) @@ -1226,7 +1226,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, struct usb_fs_isoc_schedule *fss_b; struct usb_hub *hs_hub; - isoc_time = usb2_isoc_time_expand(udev->bus, isoc_time); + isoc_time = usb_isoc_time_expand(udev->bus, isoc_time); hs_hub = udev->parent_hs_hub->hub; @@ -1250,7 +1250,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, fss_a = hs_hub->fs_isoc_schedule; continue; } - usb2_fs_isoc_schedule_init_sub(fss_a); + usbd_fs_isoc_schedule_init_sub(fss_a); fss_a++; } @@ -1264,7 +1264,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, #endif /*------------------------------------------------------------------------* - * usb2_fs_isoc_schedule_alloc + * usbd_fs_isoc_schedule_alloc * * This function will allocate bandwidth for an isochronous FULL speed * transaction in the FULL speed schedule. The microframe slot where @@ -1278,7 +1278,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb_device *udev, *------------------------------------------------------------------------*/ #if USB_HAVE_TT_SUPPORT uint8_t -usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, +usbd_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len) { uint8_t slot = fss->frame_slot; @@ -1312,12 +1312,12 @@ usb2_fs_isoc_schedule_alloc(struct usb_fs_isoc_schedule *fss, #endif /*------------------------------------------------------------------------* - * usb2_bus_port_get_device + * usb_bus_port_get_device * * This function is NULL safe. *------------------------------------------------------------------------*/ struct usb_device * -usb2_bus_port_get_device(struct usb_bus *bus, struct usb_port *up) +usb_bus_port_get_device(struct usb_bus *bus, struct usb_port *up) { if ((bus == NULL) || (up == NULL)) { /* be NULL safe */ @@ -1331,12 +1331,12 @@ usb2_bus_port_get_device(struct usb_bus *bus, struct usb_port *up) } /*------------------------------------------------------------------------* - * usb2_bus_port_set_device + * usb_bus_port_set_device * * This function is NULL safe. *------------------------------------------------------------------------*/ void -usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, +usb_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, struct usb_device *udev, uint8_t device_index) { if (bus == NULL) { @@ -1360,11 +1360,11 @@ usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, */ if (device_index != 0) { #if USB_HAVE_UGEN - mtx_lock(&usb2_ref_lock); + mtx_lock(&usb_ref_lock); #endif bus->devices[device_index] = udev; #if USB_HAVE_UGEN - mtx_unlock(&usb2_ref_lock); + mtx_unlock(&usb_ref_lock); #endif } /* @@ -1374,12 +1374,12 @@ usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, } /*------------------------------------------------------------------------* - * usb2_needs_explore + * usb_needs_explore * * This functions is called when the USB event thread needs to run. *------------------------------------------------------------------------*/ void -usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe) +usb_needs_explore(struct usb_bus *bus, uint8_t do_probe) { uint8_t do_unlock; @@ -1403,7 +1403,7 @@ usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe) if (do_probe) { bus->do_probe = 1; } - if (usb2_proc_msignal(&bus->explore_proc, + if (usb_proc_msignal(&bus->explore_proc, &bus->explore_msg[0], &bus->explore_msg[1])) { /* ignore */ } @@ -1413,13 +1413,13 @@ usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe) } /*------------------------------------------------------------------------* - * usb2_needs_explore_all + * usb_needs_explore_all * * This function is called whenever a new driver is loaded and will * cause that all USB busses are re-explored. *------------------------------------------------------------------------*/ void -usb2_needs_explore_all(void) +usb_needs_explore_all(void) { struct usb_bus *bus; devclass_t dc; @@ -1428,7 +1428,7 @@ usb2_needs_explore_all(void) DPRINTFN(3, "\n"); - dc = usb2_devclass_ptr; + dc = usb_devclass_ptr; if (dc == NULL) { DPRINTFN(0, "no devclass\n"); return; @@ -1442,7 +1442,7 @@ usb2_needs_explore_all(void) if (dev) { bus = device_get_softc(dev); if (bus) { - usb2_needs_explore(bus, 1); + usb_needs_explore(bus, 1); } } max--; @@ -1450,7 +1450,7 @@ usb2_needs_explore_all(void) } /*------------------------------------------------------------------------* - * usb2_bus_power_update + * usb_bus_power_update * * This function will ensure that all USB devices on the given bus are * properly suspended or resumed according to the device transfer @@ -1458,14 +1458,14 @@ usb2_needs_explore_all(void) *------------------------------------------------------------------------*/ #if USB_HAVE_POWERD void -usb2_bus_power_update(struct usb_bus *bus) +usb_bus_power_update(struct usb_bus *bus) { - usb2_needs_explore(bus, 0 /* no probe */ ); + usb_needs_explore(bus, 0 /* no probe */ ); } #endif /*------------------------------------------------------------------------* - * usb2_transfer_power_ref + * usbd_transfer_power_ref * * This function will modify the power save reference counts and * wakeup the USB device associated with the given USB transfer, if @@ -1473,7 +1473,7 @@ usb2_bus_power_update(struct usb_bus *bus) *------------------------------------------------------------------------*/ #if USB_HAVE_POWERD void -usb2_transfer_power_ref(struct usb_xfer *xfer, int val) +usbd_transfer_power_ref(struct usb_xfer *xfer, int val) { static const usb_power_mask_t power_mask[4] = { [UE_CONTROL] = USB_HW_POWER_CONTROL, @@ -1518,7 +1518,7 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val) needs_explore = (udev->pwr_save.write_refs != 0) || ((udev->pwr_save.read_refs != 0) && - (usb2_peer_can_wakeup(udev) == 0)); + (usb_peer_can_wakeup(udev) == 0)); else needs_explore = 0; @@ -1534,7 +1534,7 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val) if (needs_explore) { DPRINTF("update\n"); - usb2_bus_power_update(udev->bus); + usb_bus_power_update(udev->bus); } else if (needs_hw_power) { DPRINTF("needs power\n"); if (udev->bus->methods->set_hw_power != NULL) { @@ -1545,14 +1545,14 @@ usb2_transfer_power_ref(struct usb_xfer *xfer, int val) #endif /*------------------------------------------------------------------------* - * usb2_bus_powerd + * usb_bus_powerd * * This function implements the USB power daemon and is called * regularly from the USB explore thread. *------------------------------------------------------------------------*/ #if USB_HAVE_POWERD void -usb2_bus_powerd(struct usb_bus *bus) +usb_bus_powerd(struct usb_bus *bus) { struct usb_device *udev; usb_ticks_t temp; @@ -1562,7 +1562,7 @@ usb2_bus_powerd(struct usb_bus *bus) uint8_t x; uint8_t rem_wakeup; - limit = usb2_power_timeout; + limit = usb_power_timeout; if (limit == 0) limit = hz; else if (limit > 255) @@ -1585,7 +1585,7 @@ usb2_bus_powerd(struct usb_bus *bus) if (udev == NULL) continue; - rem_wakeup = usb2_peer_can_wakeup(udev); + rem_wakeup = usb_peer_can_wakeup(udev); temp = ticks - udev->pwr_save.last_xfer_time; @@ -1598,7 +1598,7 @@ usb2_bus_powerd(struct usb_bus *bus) /* check if we are suspended */ if (udev->flags.self_suspended != 0) { USB_BUS_UNLOCK(bus); - usb2_dev_resume_peer(udev); + usb_dev_resume_peer(udev); USB_BUS_LOCK(bus); } } else if (temp >= limit) { @@ -1606,7 +1606,7 @@ usb2_bus_powerd(struct usb_bus *bus) /* check if we are not suspended */ if (udev->flags.self_suspended == 0) { USB_BUS_UNLOCK(bus); - usb2_dev_suspend_peer(udev); + usb_dev_suspend_peer(udev); USB_BUS_LOCK(bus); } } @@ -1677,13 +1677,13 @@ usb2_bus_powerd(struct usb_bus *bus) #endif /*------------------------------------------------------------------------* - * usb2_dev_resume_peer + * usb_dev_resume_peer * * This function will resume an USB peer and do the required USB * signalling to get an USB device out of the suspended state. *------------------------------------------------------------------------*/ static void -usb2_dev_resume_peer(struct usb_device *udev) +usb_dev_resume_peer(struct usb_device *udev) { struct usb_bus *bus; int err; @@ -1715,17 +1715,17 @@ usb2_dev_resume_peer(struct usb_device *udev) bus = udev->bus; /* resume parent hub first */ - usb2_dev_resume_peer(udev->parent_hub); + usb_dev_resume_peer(udev->parent_hub); /* resume current port (Valid in Host and Device Mode) */ - err = usb2_req_clear_port_feature(udev->parent_hub, + err = usbd_req_clear_port_feature(udev->parent_hub, NULL, udev->port_no, UHF_PORT_SUSPEND); if (err) { DPRINTFN(0, "Resuming port failed!\n"); return; } /* resume settle time */ - usb2_pause_mtx(NULL, USB_MS_TO_TICKS(USB_PORT_RESUME_DELAY)); + usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_PORT_RESUME_DELAY)); if (bus->methods->device_resume != NULL) { /* resume USB device on the USB controller */ @@ -1756,31 +1756,31 @@ usb2_dev_resume_peer(struct usb_device *udev) } sx_xlock(udev->default_sx + 1); /* notify all sub-devices about resume */ - err = usb2_suspend_resume(udev, 0); + err = usb_suspend_resume(udev, 0); sx_unlock(udev->default_sx + 1); /* check if peer has wakeup capability */ - if (usb2_peer_can_wakeup(udev)) { + if (usb_peer_can_wakeup(udev)) { /* clear remote wakeup */ - err = usb2_req_clear_device_feature(udev, + err = usbd_req_clear_device_feature(udev, NULL, UF_DEVICE_REMOTE_WAKEUP); if (err) { DPRINTFN(0, "Clearing device " "remote wakeup failed: %s!\n", - usb2_errstr(err)); + usbd_errstr(err)); } } return; } /*------------------------------------------------------------------------* - * usb2_dev_suspend_peer + * usb_dev_suspend_peer * * This function will suspend an USB peer and do the required USB * signalling to get an USB device into the suspended state. *------------------------------------------------------------------------*/ static void -usb2_dev_suspend_peer(struct usb_device *udev) +usb_dev_suspend_peer(struct usb_device *udev) { struct usb_device *child; int err; @@ -1809,7 +1809,7 @@ repeat: /* check if all devices on the HUB are suspended */ for (x = 0; x != nports; x++) { - child = usb2_bus_port_get_device(udev->bus, + child = usb_bus_port_get_device(udev->bus, udev->hub->ports + x); if (child == NULL) @@ -1825,12 +1825,12 @@ repeat: sx_xlock(udev->default_sx + 1); /* notify all sub-devices about suspend */ - err = usb2_suspend_resume(udev, 1); + err = usb_suspend_resume(udev, 1); sx_unlock(udev->default_sx + 1); - if (usb2_peer_can_wakeup(udev)) { + if (usb_peer_can_wakeup(udev)) { /* allow device to do remote wakeup */ - err = usb2_req_set_device_feature(udev, + err = usbd_req_set_device_feature(udev, NULL, UF_DEVICE_REMOTE_WAKEUP); if (err) { DPRINTFN(0, "Setting device " @@ -1852,12 +1852,12 @@ repeat: (udev->bus->methods->device_suspend) (udev); /* do DMA delay */ - temp = usb2_get_dma_delay(udev->bus); - usb2_pause_mtx(NULL, USB_MS_TO_TICKS(temp)); + temp = usbd_get_dma_delay(udev->bus); + usb_pause_mtx(NULL, USB_MS_TO_TICKS(temp)); } /* suspend current port */ - err = usb2_req_set_port_feature(udev->parent_hub, + err = usbd_req_set_port_feature(udev->parent_hub, NULL, udev->port_no, UHF_PORT_SUSPEND); if (err) { DPRINTFN(0, "Suspending port failed\n"); @@ -1869,13 +1869,13 @@ repeat: } /*------------------------------------------------------------------------* - * usb2_set_power_mode + * usbd_set_power_mode * * This function will set the power mode, see USB_POWER_MODE_XXX for a * USB device. *------------------------------------------------------------------------*/ void -usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode) +usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode) { /* filter input argument */ if ((power_mode != USB_POWER_MODE_ON) && @@ -1885,6 +1885,6 @@ usb2_set_power_mode(struct usb_device *udev, uint8_t power_mode) udev->power_mode = power_mode; /* update copy of power mode */ #if USB_HAVE_POWERD - usb2_bus_power_update(udev->bus); + usb_bus_power_update(udev->bus); #endif } diff --git a/sys/dev/usb/usb_hub.h b/sys/dev/usb/usb_hub.h index 23db90c..0d69ba6 100644 --- a/sys/dev/usb/usb_hub.h +++ b/sys/dev/usb/usb_hub.h @@ -66,17 +66,17 @@ struct usb_hub { /* function prototypes */ -uint8_t usb2_intr_schedule_adjust(struct usb_device *udev, int16_t len, +uint8_t usb_intr_schedule_adjust(struct usb_device *udev, int16_t len, uint8_t slot); -void usb2_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss); -void usb2_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, +void usbd_fs_isoc_schedule_init_all(struct usb_fs_isoc_schedule *fss); +void usb_bus_port_set_device(struct usb_bus *bus, struct usb_port *up, struct usb_device *udev, uint8_t device_index); -struct usb_device *usb2_bus_port_get_device(struct usb_bus *bus, +struct usb_device *usb_bus_port_get_device(struct usb_bus *bus, struct usb_port *up); -void usb2_needs_explore(struct usb_bus *bus, uint8_t do_probe); -void usb2_needs_explore_all(void); -void usb2_bus_power_update(struct usb_bus *bus); -void usb2_bus_powerd(struct usb_bus *bus); +void usb_needs_explore(struct usb_bus *bus, uint8_t do_probe); +void usb_needs_explore_all(void); +void usb_bus_power_update(struct usb_bus *bus); +void usb_bus_powerd(struct usb_bus *bus); void uhub_root_intr(struct usb_bus *, const uint8_t *, uint8_t); #endif /* _USB2_HUB_H_ */ diff --git a/sys/dev/usb/usb_lookup.c b/sys/dev/usb/usb_lookup.c index 8cd887d..4950eaf 100644 --- a/sys/dev/usb/usb_lookup.c +++ b/sys/dev/usb/usb_lookup.c @@ -28,10 +28,10 @@ #include /*------------------------------------------------------------------------* - * usb2_lookup_id_by_info + * usbd_lookup_id_by_info * * This functions takes an array of "struct usb_device_id" and tries - * to match the entries with the information in "struct usb_lookup_info". + * to match the entries with the information in "struct usbd_lookup_info". * * NOTE: The "sizeof_id" parameter must be a multiple of the * usb_device_id structure size. Else the behaviour of this function @@ -42,8 +42,8 @@ * Else: Pointer to matching entry. *------------------------------------------------------------------------*/ const struct usb_device_id * -usb2_lookup_id_by_info(const struct usb_device_id *id, usb_size_t sizeof_id, - const struct usb_lookup_info *info) +usbd_lookup_id_by_info(const struct usb_device_id *id, usb_size_t sizeof_id, + const struct usbd_lookup_info *info) { const struct usb_device_id *id_end; @@ -114,17 +114,17 @@ done: } /*------------------------------------------------------------------------* - * usb2_lookup_id_by_uaa - factored out code + * usbd_lookup_id_by_uaa - factored out code * * Return values: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ int -usb2_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, +usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa) { - id = usb2_lookup_id_by_info(id, sizeof_id, &uaa->info); + id = usbd_lookup_id_by_info(id, sizeof_id, &uaa->info); if (id) { /* copy driver info */ uaa->driver_info = id->driver_info; diff --git a/sys/dev/usb/usb_lookup.h b/sys/dev/usb/usb_lookup.h index 759d0b9..63c3fbd 100644 --- a/sys/dev/usb/usb_lookup.h +++ b/sys/dev/usb/usb_lookup.h @@ -113,10 +113,10 @@ struct usb_device_id { #define USB_GET_DRIVER_INFO(did) \ (did)->driver_info -const struct usb_device_id *usb2_lookup_id_by_info( +const struct usb_device_id *usbd_lookup_id_by_info( const struct usb_device_id *id, usb_size_t sizeof_id, - const struct usb_lookup_info *info); -int usb2_lookup_id_by_uaa(const struct usb_device_id *id, + const struct usbd_lookup_info *info); +int usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa); #endif /* _USB2_LOOKUP_H_ */ diff --git a/sys/dev/usb/usb_mbuf.c b/sys/dev/usb/usb_mbuf.c index f57d274..f8ce154 100644 --- a/sys/dev/usb/usb_mbuf.c +++ b/sys/dev/usb/usb_mbuf.c @@ -28,14 +28,14 @@ #include /*------------------------------------------------------------------------* - * usb2_alloc_mbufs - allocate mbufs to an usbd interface queue + * usb_alloc_mbufs - allocate mbufs to an usbd interface queue * * Returns: * A pointer that should be passed to "free()" when the buffer(s) * should be released. *------------------------------------------------------------------------*/ void * -usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq, +usb_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq, usb_size_t block_size, uint16_t nblocks) { struct usb_mbuf *m_ptr; diff --git a/sys/dev/usb/usb_mbuf.h b/sys/dev/usb/usb_mbuf.h index 998f581..8b44519 100644 --- a/sys/dev/usb/usb_mbuf.h +++ b/sys/dev/usb/usb_mbuf.h @@ -34,8 +34,8 @@ struct usb_mbuf { uint8_t *cur_data_ptr; uint8_t *min_data_ptr; - struct usb_mbuf *usb2_nextpkt; - struct usb_mbuf *usb2_next; + struct usb_mbuf *usb_nextpkt; + struct usb_mbuf *usb_next; usb_size_t cur_data_len; usb_size_t max_data_len; @@ -56,11 +56,11 @@ struct usb_ifqueue { }; #define USB_IF_ENQUEUE(ifq, m) do { \ - (m)->usb2_nextpkt = NULL; \ + (m)->usb_nextpkt = NULL; \ if ((ifq)->ifq_tail == NULL) \ (ifq)->ifq_head = (m); \ else \ - (ifq)->ifq_tail->usb2_nextpkt = (m); \ + (ifq)->ifq_tail->usb_nextpkt = (m); \ (ifq)->ifq_tail = (m); \ (ifq)->ifq_len++; \ } while (0) @@ -68,16 +68,16 @@ struct usb_ifqueue { #define USB_IF_DEQUEUE(ifq, m) do { \ (m) = (ifq)->ifq_head; \ if (m) { \ - if (((ifq)->ifq_head = (m)->usb2_nextpkt) == NULL) { \ + if (((ifq)->ifq_head = (m)->usb_nextpkt) == NULL) { \ (ifq)->ifq_tail = NULL; \ } \ - (m)->usb2_nextpkt = NULL; \ + (m)->usb_nextpkt = NULL; \ (ifq)->ifq_len--; \ } \ } while (0) #define USB_IF_PREPEND(ifq, m) do { \ - (m)->usb2_nextpkt = (ifq)->ifq_head; \ + (m)->usb_nextpkt = (ifq)->ifq_head; \ if ((ifq)->ifq_tail == NULL) { \ (ifq)->ifq_tail = (m); \ } \ @@ -96,7 +96,7 @@ struct usb_ifqueue { } while (0) /* prototypes */ -void *usb2_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq, +void *usb_alloc_mbufs(struct malloc_type *type, struct usb_ifqueue *ifq, usb_size_t block_size, uint16_t nblocks); #endif /* _USB2_MBUF_H_ */ diff --git a/sys/dev/usb/usb_msctest.c b/sys/dev/usb/usb_msctest.c index f8981ac..e813bcc 100644 --- a/sys/dev/usb/usb_msctest.c +++ b/sys/dev/usb/usb_msctest.c @@ -36,7 +36,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -221,7 +221,7 @@ static void bbb_transfer_start(struct bbb_transfer *sc, uint8_t xfer_index) { sc->state = xfer_index; - usb2_transfer_start(sc->xfer[xfer_index]); + usbd_transfer_start(sc->xfer[xfer_index]); } static void @@ -230,7 +230,7 @@ bbb_data_clear_stall_callback(struct usb_xfer *xfer, { struct bbb_transfer *sc = xfer->priv_sc; - if (usb2_clear_stall_callback(xfer, sc->xfer[stall_xfer])) { + if (usbd_clear_stall_callback(xfer, sc->xfer[stall_xfer])) { switch (USB_GET_STATE(xfer)) { case USB_ST_SETUP: case USB_ST_TRANSFERRED: @@ -272,8 +272,8 @@ bbb_command_callback(struct usb_xfer *xfer) } xfer->frlengths[0] = sizeof(sc->cbw); - usb2_set_frame_data(xfer, &sc->cbw, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, &sc->cbw, 0); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -312,8 +312,8 @@ bbb_data_read_callback(struct usb_xfer *xfer) xfer->timeout = sc->data_timeout; xfer->frlengths[0] = max_bulk; - usb2_set_frame_data(xfer, sc->data_ptr, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, sc->data_ptr, 0); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -363,8 +363,8 @@ bbb_data_write_callback(struct usb_xfer *xfer) xfer->timeout = sc->data_timeout; xfer->frlengths[0] = max_bulk; - usb2_set_frame_data(xfer, sc->data_ptr, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, sc->data_ptr, 0); + usbd_transfer_submit(xfer); return; default: /* Error */ @@ -407,13 +407,13 @@ bbb_status_callback(struct usb_xfer *xfer) case USB_ST_SETUP: xfer->frlengths[0] = sizeof(sc->csw); - usb2_set_frame_data(xfer, &sc->csw, 0); - usb2_start_hardware(xfer); + usbd_set_frame_data(xfer, &sc->csw, 0); + usbd_transfer_submit(xfer); break; default: DPRINTFN(0, "Failed to read CSW: %s, try %d\n", - usb2_errstr(xfer->error), sc->status_try); + usbd_errstr(xfer->error), sc->status_try); if ((xfer->error == USB_ERR_CANCELLED) || (sc->status_try)) { @@ -447,23 +447,23 @@ bbb_command_start(struct bbb_transfer *sc, uint8_t dir, uint8_t lun, sc->actlen = 0; sc->cmd_len = cmd_len; - usb2_transfer_start(sc->xfer[sc->state]); + usbd_transfer_start(sc->xfer[sc->state]); - while (usb2_transfer_pending(sc->xfer[sc->state])) { + while (usbd_transfer_pending(sc->xfer[sc->state])) { cv_wait(&sc->cv, &sc->mtx); } return (sc->error); } /*------------------------------------------------------------------------* - * usb2_test_autoinstall + * usb_test_autoinstall * * Return values: * 0: This interface is an auto install disk (CD-ROM) * Else: Not an auto install disk. *------------------------------------------------------------------------*/ usb_error_t -usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index, +usb_test_autoinstall(struct usb_device *udev, uint8_t iface_index, uint8_t do_eject) { struct usb_interface *iface; @@ -476,7 +476,7 @@ usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index, if (udev == NULL) { return (USB_ERR_INVAL); } - iface = usb2_get_iface(udev, iface_index); + iface = usbd_get_iface(udev, iface_index); if (iface == NULL) { return (USB_ERR_INVAL); } @@ -510,7 +510,7 @@ usb2_test_autoinstall(struct usb_device *udev, uint8_t iface_index, mtx_init(&sc->mtx, "USB autoinstall", NULL, MTX_DEF); cv_init(&sc->cv, "WBBB"); - err = usb2_transfer_setup(udev, + err = usbd_transfer_setup(udev, &iface_index, sc->xfer, bbb_config, ST_MAX, sc, &sc->mtx); @@ -552,13 +552,13 @@ repeat_inquiry: NULL, 0, 6, USB_MS_HZ); DPRINTFN(0, "Eject CD command " - "status: %s\n", usb2_errstr(err)); + "status: %s\n", usbd_errstr(err)); } err = 0; goto done; } } else if ((err != 2) && --timeout) { - usb2_pause_mtx(&sc->mtx, hz); + usb_pause_mtx(&sc->mtx, hz); goto repeat_inquiry; } err = USB_ERR_INVAL; @@ -566,7 +566,7 @@ repeat_inquiry: done: mtx_unlock(&sc->mtx); - usb2_transfer_unsetup(sc->xfer, ST_MAX); + usbd_transfer_unsetup(sc->xfer, ST_MAX); mtx_destroy(&sc->mtx); cv_destroy(&sc->cv); free(sc, M_USB); diff --git a/sys/dev/usb/usb_msctest.h b/sys/dev/usb/usb_msctest.h index b7ce205..9fca458 100644 --- a/sys/dev/usb/usb_msctest.h +++ b/sys/dev/usb/usb_msctest.h @@ -27,7 +27,7 @@ #ifndef _USB2_MSCTEST_H_ #define _USB2_MSCTEST_H_ -usb_error_t usb2_test_autoinstall(struct usb_device *udev, +usb_error_t usb_test_autoinstall(struct usb_device *udev, uint8_t iface_index, uint8_t do_eject); #endif /* _USB2_MSCTEST_H_ */ diff --git a/sys/dev/usb/usb_parse.c b/sys/dev/usb/usb_parse.c index c6b3cca..aef7b14 100644 --- a/sys/dev/usb/usb_parse.c +++ b/sys/dev/usb/usb_parse.c @@ -31,7 +31,7 @@ #include /*------------------------------------------------------------------------* - * usb2_desc_foreach + * usb_desc_foreach * * This function is the safe way to iterate across the USB config * descriptor. It contains several checks against invalid @@ -43,7 +43,7 @@ * Else: Next descriptor after "desc" *------------------------------------------------------------------------*/ struct usb_descriptor * -usb2_desc_foreach(struct usb_config_descriptor *cd, +usb_desc_foreach(struct usb_config_descriptor *cd, struct usb_descriptor *_desc) { uint8_t *desc_next; @@ -84,7 +84,7 @@ usb2_desc_foreach(struct usb_config_descriptor *cd, } /*------------------------------------------------------------------------* - * usb2_idesc_foreach + * usb_idesc_foreach * * This function will iterate the interface descriptors in the config * descriptor. The parse state structure should be zeroed before @@ -95,7 +95,7 @@ usb2_desc_foreach(struct usb_config_descriptor *cd, * Else: A valid interface descriptor *------------------------------------------------------------------------*/ struct usb_interface_descriptor * -usb2_idesc_foreach(struct usb_config_descriptor *cd, +usb_idesc_foreach(struct usb_config_descriptor *cd, struct usb_idesc_parse_state *ps) { struct usb_interface_descriptor *id; @@ -108,7 +108,7 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd, while (1) { id = (struct usb_interface_descriptor *) - usb2_desc_foreach(cd, (struct usb_descriptor *)id); + usb_desc_foreach(cd, (struct usb_descriptor *)id); if (id == NULL) break; if ((id->bDescriptorType == UDESC_INTERFACE) && @@ -137,7 +137,7 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd, } /*------------------------------------------------------------------------* - * usb2_edesc_foreach + * usb_edesc_foreach * * This function will iterate all the endpoint descriptors within an * interface descriptor. Starting value for the "ped" argument should @@ -148,14 +148,14 @@ usb2_idesc_foreach(struct usb_config_descriptor *cd, * Else: A valid endpoint descriptor *------------------------------------------------------------------------*/ struct usb_endpoint_descriptor * -usb2_edesc_foreach(struct usb_config_descriptor *cd, +usb_edesc_foreach(struct usb_config_descriptor *cd, struct usb_endpoint_descriptor *ped) { struct usb_descriptor *desc; desc = ((struct usb_descriptor *)ped); - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if (desc->bDescriptorType == UDESC_INTERFACE) { break; } @@ -171,18 +171,18 @@ usb2_edesc_foreach(struct usb_config_descriptor *cd, } /*------------------------------------------------------------------------* - * usb2_get_no_descriptors + * usbd_get_no_descriptors * * This function will count the total number of descriptors in the * configuration descriptor of type "type". *------------------------------------------------------------------------*/ uint8_t -usb2_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type) +usbd_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type) { struct usb_descriptor *desc = NULL; uint8_t count = 0; - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if (desc->bDescriptorType == type) { count++; if (count == 0xFF) @@ -193,13 +193,13 @@ usb2_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type) } /*------------------------------------------------------------------------* - * usb2_get_no_alts + * usbd_get_no_alts * * Return value: * Number of alternate settings for the given interface descriptor pointer. *------------------------------------------------------------------------*/ uint8_t -usb2_get_no_alts(struct usb_config_descriptor *cd, +usbd_get_no_alts(struct usb_config_descriptor *cd, struct usb_interface_descriptor *id) { struct usb_descriptor *desc; @@ -210,7 +210,7 @@ usb2_get_no_alts(struct usb_config_descriptor *cd, desc = (struct usb_descriptor *)id; - while ((desc = usb2_desc_foreach(cd, desc))) { + while ((desc = usb_desc_foreach(cd, desc))) { if ((desc->bDescriptorType == UDESC_INTERFACE) && (desc->bLength >= sizeof(*id))) { id = (struct usb_interface_descriptor *)desc; diff --git a/sys/dev/usb/usb_parse.h b/sys/dev/usb/usb_parse.h index 4f36618..fc5f683 100644 --- a/sys/dev/usb/usb_parse.h +++ b/sys/dev/usb/usb_parse.h @@ -38,17 +38,17 @@ struct usb_idesc_parse_state { /* prototypes */ -struct usb_descriptor *usb2_desc_foreach(struct usb_config_descriptor *cd, +struct usb_descriptor *usb_desc_foreach(struct usb_config_descriptor *cd, struct usb_descriptor *desc); -struct usb_interface_descriptor *usb2_idesc_foreach( +struct usb_interface_descriptor *usb_idesc_foreach( struct usb_config_descriptor *cd, struct usb_idesc_parse_state *ps); -struct usb_endpoint_descriptor *usb2_edesc_foreach( +struct usb_endpoint_descriptor *usb_edesc_foreach( struct usb_config_descriptor *cd, struct usb_endpoint_descriptor *ped); -uint8_t usb2_get_no_descriptors(struct usb_config_descriptor *cd, +uint8_t usbd_get_no_descriptors(struct usb_config_descriptor *cd, uint8_t type); -uint8_t usb2_get_no_alts(struct usb_config_descriptor *cd, +uint8_t usbd_get_no_alts(struct usb_config_descriptor *cd, struct usb_interface_descriptor *id); #endif /* _USB2_PARSE_H_ */ diff --git a/sys/dev/usb/usb_process.c b/sys/dev/usb/usb_process.c index f36d57c..0732ee05 100644 --- a/sys/dev/usb/usb_process.c +++ b/sys/dev/usb/usb_process.c @@ -24,7 +24,7 @@ * SUCH DAMAGE. */ -#define USB_DEBUG_VAR usb2_proc_debug +#define USB_DEBUG_VAR usb_proc_debug #include #include @@ -53,10 +53,10 @@ #endif #if USB_DEBUG -static int usb2_proc_debug; +static int usb_proc_debug; SYSCTL_NODE(_hw_usb, OID_AUTO, proc, CTLFLAG_RW, 0, "USB process"); -SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RW, &usb2_proc_debug, 0, +SYSCTL_INT(_hw_usb_proc, OID_AUTO, debug, CTLFLAG_RW, &usb_proc_debug, 0, "Debug level"); #endif @@ -164,7 +164,7 @@ usb_process(void *arg) } /*------------------------------------------------------------------------* - * usb2_proc_create + * usb_proc_create * * This function will create a process using the given "prio" that can * execute callbacks. The mutex pointed to by "p_mtx" will be applied @@ -177,7 +177,7 @@ usb_process(void *arg) * Else: failure *------------------------------------------------------------------------*/ int -usb2_proc_create(struct usb_process *up, struct mtx *p_mtx, +usb_proc_create(struct usb_process *up, struct mtx *p_mtx, const char *pmesg, uint8_t prio) { up->up_mtx = p_mtx; @@ -197,12 +197,12 @@ usb2_proc_create(struct usb_process *up, struct mtx *p_mtx, return (0); error: - usb2_proc_free(up); + usb_proc_free(up); return (ENOMEM); } /*------------------------------------------------------------------------* - * usb2_proc_free + * usb_proc_free * * NOTE: If the structure pointed to by "up" is all zero, this * function does nothing. @@ -211,13 +211,13 @@ error: * removed nor called. *------------------------------------------------------------------------*/ void -usb2_proc_free(struct usb_process *up) +usb_proc_free(struct usb_process *up) { /* check if not initialised */ if (up->up_mtx == NULL) return; - usb2_proc_drain(up); + usb_proc_drain(up); cv_destroy(&up->up_cv); cv_destroy(&up->up_drain); @@ -227,7 +227,7 @@ usb2_proc_free(struct usb_process *up) } /*------------------------------------------------------------------------* - * usb2_proc_msignal + * usb_proc_msignal * * This function will queue one of the passed USB process messages on * the USB process queue. The first message that is not already queued @@ -238,7 +238,7 @@ usb2_proc_free(struct usb_process *up) * at a time. The message that was queued is returned. *------------------------------------------------------------------------*/ void * -usb2_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1) +usb_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1) { struct usb_proc_msg *pm0 = _pm0; struct usb_proc_msg *pm1 = _pm1; @@ -314,14 +314,14 @@ usb2_proc_msignal(struct usb_process *up, void *_pm0, void *_pm1) } /*------------------------------------------------------------------------* - * usb2_proc_is_gone + * usb_proc_is_gone * * Return values: * 0: USB process is running * Else: USB process is tearing down *------------------------------------------------------------------------*/ uint8_t -usb2_proc_is_gone(struct usb_process *up) +usb_proc_is_gone(struct usb_process *up) { if (up->up_gone) return (1); @@ -331,14 +331,14 @@ usb2_proc_is_gone(struct usb_process *up) } /*------------------------------------------------------------------------* - * usb2_proc_mwait + * usb_proc_mwait * * This function will return when the USB process message pointed to * by "pm" is no longer on a queue. This function must be called * having "up->up_mtx" locked. *------------------------------------------------------------------------*/ void -usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1) +usb_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1) { struct usb_proc_msg *pm0 = _pm0; struct usb_proc_msg *pm1 = _pm1; @@ -371,7 +371,7 @@ usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1) } /*------------------------------------------------------------------------* - * usb2_proc_drain + * usb_proc_drain * * This function will tear down an USB process, waiting for the * currently executing command to return. @@ -380,7 +380,7 @@ usb2_proc_mwait(struct usb_process *up, void *_pm0, void *_pm1) * this function does nothing. *------------------------------------------------------------------------*/ void -usb2_proc_drain(struct usb_process *up) +usb_proc_drain(struct usb_process *up) { /* check if not initialised */ if (up->up_mtx == NULL) diff --git a/sys/dev/usb/usb_process.h b/sys/dev/usb/usb_process.h index b248e9e..86f1536 100644 --- a/sys/dev/usb/usb_process.h +++ b/sys/dev/usb/usb_process.h @@ -77,12 +77,12 @@ struct usb_process { /* prototypes */ -uint8_t usb2_proc_is_gone(struct usb_process *up); -int usb2_proc_create(struct usb_process *up, struct mtx *p_mtx, +uint8_t usb_proc_is_gone(struct usb_process *up); +int usb_proc_create(struct usb_process *up, struct mtx *p_mtx, const char *pmesg, uint8_t prio); -void usb2_proc_drain(struct usb_process *up); -void usb2_proc_mwait(struct usb_process *up, void *pm0, void *pm1); -void usb2_proc_free(struct usb_process *up); -void *usb2_proc_msignal(struct usb_process *up, void *pm0, void *pm1); +void usb_proc_drain(struct usb_process *up); +void usb_proc_mwait(struct usb_process *up, void *pm0, void *pm1); +void usb_proc_free(struct usb_process *up); +void *usb_proc_msignal(struct usb_process *up, void *pm0, void *pm1); #endif /* _USB2_PROCESS_H_ */ diff --git a/sys/dev/usb/usb_request.c b/sys/dev/usb/usb_request.c index da694c5..da93b7b 100644 --- a/sys/dev/usb/usb_request.c +++ b/sys/dev/usb/usb_request.c @@ -32,7 +32,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -49,26 +49,26 @@ #include #if USB_DEBUG -static int usb2_pr_poll_delay = USB_PORT_RESET_DELAY; -static int usb2_pr_recovery_delay = USB_PORT_RESET_RECOVERY; -static int usb2_ss_delay = 0; +static int usb_pr_poll_delay = USB_PORT_RESET_DELAY; +static int usb_pr_recovery_delay = USB_PORT_RESET_RECOVERY; +static int usb_ss_delay = 0; SYSCTL_INT(_hw_usb, OID_AUTO, pr_poll_delay, CTLFLAG_RW, - &usb2_pr_poll_delay, 0, "USB port reset poll delay in ms"); + &usb_pr_poll_delay, 0, "USB port reset poll delay in ms"); SYSCTL_INT(_hw_usb, OID_AUTO, pr_recovery_delay, CTLFLAG_RW, - &usb2_pr_recovery_delay, 0, "USB port reset recovery delay in ms"); + &usb_pr_recovery_delay, 0, "USB port reset recovery delay in ms"); SYSCTL_INT(_hw_usb, OID_AUTO, ss_delay, CTLFLAG_RW, - &usb2_ss_delay, 0, "USB status stage delay in ms"); + &usb_ss_delay, 0, "USB status stage delay in ms"); #endif /*------------------------------------------------------------------------* - * usb2_do_request_callback + * usbd_do_request_callback * * This function is the USB callback for generic USB Host control * transfers. *------------------------------------------------------------------------*/ void -usb2_do_request_callback(struct usb_xfer *xfer) +usbd_do_request_callback(struct usb_xfer *xfer) { ; /* workaround for a bug in "indent" */ @@ -76,7 +76,7 @@ usb2_do_request_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_SETUP: - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: cv_signal(xfer->xroot->udev->default_cv); @@ -85,12 +85,12 @@ usb2_do_request_callback(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_do_clear_stall_callback + * usb_do_clear_stall_callback * * This function is the USB callback for generic clear stall requests. *------------------------------------------------------------------------*/ void -usb2_do_clear_stall_callback(struct usb_xfer *xfer) +usb_do_clear_stall_callback(struct usb_xfer *xfer) { struct usb_device_request req; struct usb_device *udev; @@ -119,7 +119,7 @@ usb2_do_clear_stall_callback(struct usb_xfer *xfer) ep->toggle_next = 0; ep->is_stalled = 0; /* start up the current or next transfer, if any */ - usb2_command_wrapper(&ep->endpoint_q, + usb_command_wrapper(&ep->endpoint_q, ep->endpoint_q.curr); } ep++; @@ -144,14 +144,14 @@ tr_setup: /* copy in the transfer */ - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); /* set length */ xfer->frlengths[0] = sizeof(req); xfer->nframes = 1; USB_BUS_UNLOCK(udev->bus); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); USB_BUS_LOCK(udev->bus); break; @@ -173,11 +173,11 @@ tr_setup: } static usb_handle_req_t * -usb2_get_hr_func(struct usb_device *udev) +usbd_get_hr_func(struct usb_device *udev) { /* figure out if there is a Handle Request function */ if (udev->flags.usb_mode == USB_MODE_DEVICE) - return (usb2_temp_get_desc_p); + return (usb_temp_get_desc_p); else if (udev->parent_hub == NULL) return (udev->bus->methods->roothub_exec); else @@ -185,7 +185,7 @@ usb2_get_hr_func(struct usb_device *udev) } /*------------------------------------------------------------------------* - * usb2_do_request_flags and usb2_do_request + * usbd_do_request_flags and usbd_do_request * * Description of arguments passed to these functions: * @@ -232,7 +232,7 @@ usb2_get_hr_func(struct usb_device *udev) * does not allow control requests without a timeout. * * NOTE: This function is thread safe. All calls to - * "usb2_do_request_flags" will be serialised by the use of an + * "usbd_do_request_flags" will be serialised by the use of an * internal "sx_lock". * * Returns: @@ -240,7 +240,7 @@ usb2_get_hr_func(struct usb_device *udev) * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, +usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout) { @@ -301,7 +301,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, sx_xlock(udev->default_sx); - hr_func = usb2_get_hr_func(udev); + hr_func = usbd_get_hr_func(udev); if (hr_func != NULL) { DPRINTF("Handle Request function is set\n"); @@ -354,7 +354,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, /* * Setup a new USB transfer or use the existing one, if any: */ - usb2_default_transfer_setup(udev); + usbd_default_transfer_setup(udev); xfer = udev->default_xfer[0]; if (xfer == NULL) { @@ -380,7 +380,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, max_ticks = USB_MS_TO_TICKS(timeout); - usb2_copy_in(xfer->frbuffers, 0, req, sizeof(*req)); + usbd_copy_in(xfer->frbuffers, 0, req, sizeof(*req)); xfer->frlengths[0] = sizeof(*req); xfer->nframes = 2; @@ -397,7 +397,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, #if USB_HAVE_USER_IO if (flags & USB_USER_DATA_PTR) { USB_XFER_UNLOCK(xfer); - err = usb2_copy_in_user(xfer->frbuffers + 1, + err = usbd_copy_in_user(xfer->frbuffers + 1, 0, data, temp); USB_XFER_LOCK(xfer); if (err) { @@ -406,7 +406,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, } } else #endif - usb2_copy_in(xfer->frbuffers + 1, + usbd_copy_in(xfer->frbuffers + 1, 0, data, temp); } xfer->nframes = 2; @@ -416,12 +416,12 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, #if USB_DEBUG int temp; - temp = usb2_ss_delay; + temp = usb_ss_delay; if (temp > 5000) { temp = 5000; } if (temp > 0) { - usb2_pause_mtx( + usb_pause_mtx( xfer->xroot->xfer_mtx, USB_MS_TO_TICKS(temp)); } @@ -434,9 +434,9 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, xfer->nframes = 1; } - usb2_transfer_start(xfer); + usbd_transfer_start(xfer); - while (usb2_transfer_pending(xfer)) { + while (usbd_transfer_pending(xfer)) { cv_wait(udev->default_cv, xfer->xroot->xfer_mtx); } @@ -465,7 +465,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, #if USB_HAVE_USER_IO if (flags & USB_USER_DATA_PTR) { USB_XFER_UNLOCK(xfer); - err = usb2_copy_out_user(xfer->frbuffers + 1, + err = usbd_copy_out_user(xfer->frbuffers + 1, 0, data, temp); USB_XFER_LOCK(xfer); if (err) { @@ -474,7 +474,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, } } else #endif - usb2_copy_out(xfer->frbuffers + 1, + usbd_copy_out(xfer->frbuffers + 1, 0, data, temp); } } @@ -509,7 +509,7 @@ usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, * Make sure that the control endpoint is no longer * blocked in case of a non-transfer related error: */ - usb2_transfer_stop(xfer); + usbd_transfer_stop(xfer); } USB_XFER_UNLOCK(xfer); @@ -523,17 +523,17 @@ done: } /*------------------------------------------------------------------------* - * usb2_do_request_proc - factored out code + * usbd_do_request_proc - factored out code * * This function is factored out code. It does basically the same like - * usb2_do_request_flags, except it will check the status of the + * usbd_do_request_flags, except it will check the status of the * passed process argument before doing the USB request. If the * process is draining the USB_ERR_IOERROR code will be returned. It * is assumed that the mutex associated with the process is locked * when calling this function. *------------------------------------------------------------------------*/ usb_error_t -usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc, +usbd_do_request_proc(struct usb_device *udev, struct usb_process *pproc, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout) { @@ -544,13 +544,13 @@ usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc, len = UGETW(req->wLength); /* check if the device is being detached */ - if (usb2_proc_is_gone(pproc)) { + if (usb_proc_is_gone(pproc)) { err = USB_ERR_IOERROR; goto done; } /* forward the USB request */ - err = usb2_do_request_flags(udev, pproc->up_mtx, + err = usbd_do_request_flags(udev, pproc->up_mtx, req, data, flags, actlen, timeout); done: @@ -566,7 +566,7 @@ done: } /*------------------------------------------------------------------------* - * usb2_req_reset_port + * usbd_req_reset_port * * This function will instruct an USB HUB to perform a reset sequence * on the specified port number. @@ -577,7 +577,7 @@ done: * disabled. *------------------------------------------------------------------------*/ usb_error_t -usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) +usbd_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) { struct usb_port_status ps; usb_error_t err; @@ -588,19 +588,19 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) uint16_t pr_recovery_delay; #endif - err = usb2_req_set_port_feature(udev, mtx, port, UHF_PORT_RESET); + err = usbd_req_set_port_feature(udev, mtx, port, UHF_PORT_RESET); if (err) { goto done; } #if USB_DEBUG /* range check input parameters */ - pr_poll_delay = usb2_pr_poll_delay; + pr_poll_delay = usb_pr_poll_delay; if (pr_poll_delay < 1) { pr_poll_delay = 1; } else if (pr_poll_delay > 1000) { pr_poll_delay = 1000; } - pr_recovery_delay = usb2_pr_recovery_delay; + pr_recovery_delay = usb_pr_recovery_delay; if (pr_recovery_delay > 1000) { pr_recovery_delay = 1000; } @@ -609,14 +609,14 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) while (1) { #if USB_DEBUG /* wait for the device to recover from reset */ - usb2_pause_mtx(mtx, USB_MS_TO_TICKS(pr_poll_delay)); + usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_poll_delay)); n += pr_poll_delay; #else /* wait for the device to recover from reset */ - usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY)); + usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY)); n += USB_PORT_RESET_DELAY; #endif - err = usb2_req_get_port_status(udev, mtx, &ps, port); + err = usbd_req_get_port_status(udev, mtx, &ps, port); if (err) { goto done; } @@ -636,7 +636,7 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) } /* clear port reset first */ - err = usb2_req_clear_port_feature( + err = usbd_req_clear_port_feature( udev, mtx, port, UHF_C_PORT_RESET); if (err) { goto done; @@ -648,20 +648,20 @@ usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port) } #if USB_DEBUG /* wait for the device to recover from reset */ - usb2_pause_mtx(mtx, USB_MS_TO_TICKS(pr_recovery_delay)); + usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_recovery_delay)); #else /* wait for the device to recover from reset */ - usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY)); + usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY)); #endif done: DPRINTFN(2, "port %d reset returning error=%s\n", - port, usb2_errstr(err)); + port, usbd_errstr(err)); return (err); } /*------------------------------------------------------------------------* - * usb2_req_get_desc + * usbd_req_get_desc * * This function can be used to retrieve USB descriptors. It contains * some additional logic like zeroing of missing descriptor bytes and @@ -685,7 +685,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_desc(struct usb_device *udev, +usbd_req_get_desc(struct usb_device *udev, struct mtx *mtx, uint16_t *actlen, void *desc, uint16_t min_len, uint16_t max_len, uint16_t id, uint8_t type, uint8_t index, @@ -711,7 +711,7 @@ usb2_req_get_desc(struct usb_device *udev, } USETW(req.wLength, min_len); - err = usb2_do_request_flags(udev, mtx, &req, + err = usbd_do_request_flags(udev, mtx, &req, desc, 0, NULL, 1000); if (err) { @@ -720,7 +720,7 @@ usb2_req_get_desc(struct usb_device *udev, } retries--; - usb2_pause_mtx(mtx, hz / 5); + usb_pause_mtx(mtx, hz / 5); continue; } @@ -764,7 +764,7 @@ done: } /*------------------------------------------------------------------------* - * usb2_req_get_string_any + * usbd_req_get_string_any * * This function will return the string given by "string_index" * using the first language ID. The maximum length "len" includes @@ -776,7 +776,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, +usbd_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, uint16_t len, uint8_t string_index) { char *s; @@ -800,7 +800,7 @@ usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, buf[0] = 0; return (USB_ERR_STALLED); } - err = usb2_req_get_string_desc + err = usbd_req_get_string_desc (udev, mtx, buf, len, udev->langid, string_index); if (err) { buf[0] = 0; @@ -861,26 +861,26 @@ usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, } /*------------------------------------------------------------------------* - * usb2_req_get_string_desc + * usbd_req_get_string_desc * * If you don't know the language ID, consider using - * "usb2_req_get_string_any()". + * "usbd_req_get_string_any()". * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc, +usbd_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) { - return (usb2_req_get_desc(udev, mtx, NULL, sdesc, 2, max_len, lang_id, + return (usbd_req_get_desc(udev, mtx, NULL, sdesc, 2, max_len, lang_id, UDESC_STRING, string_index, 0)); } /*------------------------------------------------------------------------* - * usb2_req_get_config_desc_ptr + * usbd_req_get_config_desc_ptr * * This function is used in device side mode to retrieve the pointer * to the generated config descriptor. This saves allocating space for @@ -891,7 +891,7 @@ usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, void *sdesc, * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_descriptor_ptr(struct usb_device *udev, +usbd_req_get_descriptor_ptr(struct usb_device *udev, struct usb_config_descriptor **ppcd, uint16_t wValue) { struct usb_device_request req; @@ -909,7 +909,7 @@ usb2_req_get_descriptor_ptr(struct usb_device *udev, ptr = NULL; len = 0; - hr_func = usb2_get_hr_func(udev); + hr_func = usbd_get_hr_func(udev); if (hr_func == NULL) err = USB_ERR_INVAL; @@ -930,21 +930,21 @@ usb2_req_get_descriptor_ptr(struct usb_device *udev, } /*------------------------------------------------------------------------* - * usb2_req_get_config_desc + * usbd_req_get_config_desc * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_config_desc(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_config_desc(struct usb_device *udev, struct mtx *mtx, struct usb_config_descriptor *d, uint8_t conf_index) { usb_error_t err; DPRINTFN(4, "confidx=%d\n", conf_index); - err = usb2_req_get_desc(udev, mtx, NULL, d, sizeof(*d), + err = usbd_req_get_desc(udev, mtx, NULL, d, sizeof(*d), sizeof(*d), 0, UDESC_CONFIG, conf_index, 0); if (err) { goto done; @@ -958,7 +958,7 @@ done: } /*------------------------------------------------------------------------* - * usb2_req_get_config_desc_full + * usbd_req_get_config_desc_full * * This function gets the complete USB configuration descriptor and * ensures that "wTotalLength" is correct. @@ -968,7 +968,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, struct usb_config_descriptor **ppcd, struct malloc_type *mtype, uint8_t index) { @@ -981,7 +981,7 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, *ppcd = NULL; - err = usb2_req_get_config_desc(udev, mtx, &cd, index); + err = usbd_req_get_config_desc(udev, mtx, &cd, index); if (err) { return (err); } @@ -995,7 +995,7 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, if (cdesc == NULL) { return (USB_ERR_NOMEM); } - err = usb2_req_get_desc(udev, mtx, NULL, cdesc, len, len, 0, + err = usbd_req_get_desc(udev, mtx, NULL, cdesc, len, len, 0, UDESC_CONFIG, index, 3); if (err) { free(cdesc, mtype); @@ -1010,33 +1010,33 @@ usb2_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, } /*------------------------------------------------------------------------* - * usb2_req_get_device_desc + * usbd_req_get_device_desc * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_device_desc(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_device_desc(struct usb_device *udev, struct mtx *mtx, struct usb_device_descriptor *d) { DPRINTFN(4, "\n"); - return (usb2_req_get_desc(udev, mtx, NULL, d, sizeof(*d), + return (usbd_req_get_desc(udev, mtx, NULL, d, sizeof(*d), sizeof(*d), 0, UDESC_DEVICE, 0, 3)); } /*------------------------------------------------------------------------* - * usb2_req_get_alt_interface_no + * usbd_req_get_alt_interface_no * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx, uint8_t *alt_iface_no, uint8_t iface_index) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1048,21 +1048,21 @@ usb2_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, 1); - return (usb2_do_request(udev, mtx, &req, alt_iface_no)); + return (usbd_do_request(udev, mtx, &req, alt_iface_no)); } /*------------------------------------------------------------------------* - * usb2_req_set_alt_interface_no + * usbd_req_set_alt_interface_no * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint8_t alt_no) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1075,18 +1075,18 @@ usb2_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_get_device_status + * usbd_req_get_device_status * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_device_status(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_device_status(struct usb_device *udev, struct mtx *mtx, struct usb_status *st) { struct usb_device_request req; @@ -1096,18 +1096,18 @@ usb2_req_get_device_status(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, sizeof(*st)); - return (usb2_do_request(udev, mtx, &req, st)); + return (usbd_do_request(udev, mtx, &req, st)); } /*------------------------------------------------------------------------* - * usb2_req_get_hub_descriptor + * usbd_req_get_hub_descriptor * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx, struct usb_hub_descriptor *hd, uint8_t nports) { struct usb_device_request req; @@ -1118,18 +1118,18 @@ usb2_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx, USETW2(req.wValue, UDESC_HUB, 0); USETW(req.wIndex, 0); USETW(req.wLength, len); - return (usb2_do_request(udev, mtx, &req, hd)); + return (usbd_do_request(udev, mtx, &req, hd)); } /*------------------------------------------------------------------------* - * usb2_req_get_hub_status + * usbd_req_get_hub_status * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, struct usb_hub_status *st) { struct usb_device_request req; @@ -1139,11 +1139,11 @@ usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, sizeof(struct usb_hub_status)); - return (usb2_do_request(udev, mtx, &req, st)); + return (usbd_do_request(udev, mtx, &req, st)); } /*------------------------------------------------------------------------* - * usb2_req_set_address + * usbd_req_set_address * * This function is used to set the address for an USB device. After * port reset the USB device will respond at address zero. @@ -1153,7 +1153,7 @@ usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr) +usbd_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr) { struct usb_device_request req; @@ -1166,19 +1166,19 @@ usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr) USETW(req.wLength, 0); /* Setting the address should not take more than 1 second ! */ - return (usb2_do_request_flags(udev, mtx, &req, NULL, + return (usbd_do_request_flags(udev, mtx, &req, NULL, USB_DELAY_STATUS_STAGE, NULL, 1000)); } /*------------------------------------------------------------------------* - * usb2_req_get_port_status + * usbd_req_get_port_status * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_port_status(struct usb_device *udev, struct mtx *mtx, struct usb_port_status *ps, uint8_t port) { struct usb_device_request req; @@ -1189,18 +1189,18 @@ usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = port; req.wIndex[1] = 0; USETW(req.wLength, sizeof *ps); - return (usb2_do_request(udev, mtx, &req, ps)); + return (usbd_do_request(udev, mtx, &req, ps)); } /*------------------------------------------------------------------------* - * usb2_req_clear_hub_feature + * usbd_req_clear_hub_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel) { struct usb_device_request req; @@ -1210,18 +1210,18 @@ usb2_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, sel); USETW(req.wIndex, 0); USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_set_hub_feature + * usbd_req_set_hub_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel) { struct usb_device_request req; @@ -1231,18 +1231,18 @@ usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, sel); USETW(req.wIndex, 0); USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_clear_port_feature + * usbd_req_clear_port_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx, uint8_t port, uint16_t sel) { struct usb_device_request req; @@ -1253,18 +1253,18 @@ usb2_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = port; req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_set_port_feature + * usbd_req_set_port_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_port_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_port_feature(struct usb_device *udev, struct mtx *mtx, uint8_t port, uint16_t sel) { struct usb_device_request req; @@ -1275,21 +1275,21 @@ usb2_req_set_port_feature(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = port; req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_set_protocol + * usbd_req_set_protocol * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_protocol(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint16_t report) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1304,21 +1304,21 @@ usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_set_report + * usbd_req_set_report * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16_t len, +usbd_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) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1332,21 +1332,21 @@ usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, void *data, uint16 req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, len); - return (usb2_do_request(udev, mtx, &req, data)); + return (usbd_do_request(udev, mtx, &req, data)); } /*------------------------------------------------------------------------* - * usb2_req_get_report + * usbd_req_get_report * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data, +usbd_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) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL) || (id == 0)) { @@ -1360,21 +1360,21 @@ usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, void *data, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, len); - return (usb2_do_request(udev, mtx, &req, data)); + return (usbd_do_request(udev, mtx, &req, data)); } /*------------------------------------------------------------------------* - * usb2_req_set_idle + * usbd_req_set_idle * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_idle(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint8_t duration, uint8_t id) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1388,21 +1388,21 @@ usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_get_report_descriptor + * usbd_req_get_report_descriptor * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx, +usbd_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx, void *d, uint16_t size, uint8_t iface_index) { - struct usb_interface *iface = usb2_get_iface(udev, iface_index); + struct usb_interface *iface = usbd_get_iface(udev, iface_index); struct usb_device_request req; if ((iface == NULL) || (iface->idesc == NULL)) { @@ -1414,11 +1414,11 @@ usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx, req.wIndex[0] = iface->idesc->bInterfaceNumber; req.wIndex[1] = 0; USETW(req.wLength, size); - return (usb2_do_request(udev, mtx, &req, d)); + return (usbd_do_request(udev, mtx, &req, d)); } /*------------------------------------------------------------------------* - * usb2_req_set_config + * usbd_req_set_config * * This function is used to select the current configuration number in * both USB device side mode and USB host side mode. When setting the @@ -1429,7 +1429,7 @@ usb2_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx, * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf) +usbd_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf) { struct usb_device_request req; @@ -1443,18 +1443,18 @@ usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf) req.wValue[1] = 0; USETW(req.wIndex, 0); USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_get_config + * usbd_req_get_config * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf) +usbd_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf) { struct usb_device_request req; @@ -1463,11 +1463,11 @@ usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf) USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, 1); - return (usb2_do_request(udev, mtx, &req, pconf)); + return (usbd_do_request(udev, mtx, &req, pconf)); } /*------------------------------------------------------------------------* - * usb2_req_re_enumerate + * usbd_req_re_enumerate * * NOTE: After this function returns the hardware is in the * unconfigured state! The application is responsible for setting a @@ -1478,7 +1478,7 @@ usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf) * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx) +usbd_req_re_enumerate(struct usb_device *udev, struct mtx *mtx) { struct usb_device *parent_hub; usb_error_t err; @@ -1494,10 +1494,10 @@ usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx) return (USB_ERR_INVAL); } retry: - err = usb2_req_reset_port(parent_hub, mtx, udev->port_no); + err = usbd_req_reset_port(parent_hub, mtx, udev->port_no); if (err) { DPRINTFN(0, "addr=%d, port reset failed, %s\n", - old_addr, usb2_errstr(err)); + old_addr, usbd_errstr(err)); goto done; } /* @@ -1512,39 +1512,39 @@ retry: /* * Restore device address: */ - err = usb2_req_set_address(udev, mtx, old_addr); + err = usbd_req_set_address(udev, mtx, old_addr); if (err) { /* XXX ignore any errors! */ DPRINTFN(0, "addr=%d, set address failed! (%s, ignored)\n", - old_addr, usb2_errstr(err)); + old_addr, usbd_errstr(err)); } /* restore device address */ udev->address = old_addr; /* allow device time to set new address */ - usb2_pause_mtx(mtx, USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE)); + usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_SET_ADDRESS_SETTLE)); /* get the device descriptor */ - err = usb2_req_get_desc(udev, mtx, NULL, &udev->ddesc, + err = usbd_req_get_desc(udev, mtx, NULL, &udev->ddesc, USB_MAX_IPACKET, USB_MAX_IPACKET, 0, UDESC_DEVICE, 0, 0); if (err) { DPRINTFN(0, "getting device descriptor " "at addr %d failed, %s!\n", udev->address, - usb2_errstr(err)); + usbd_errstr(err)); goto done; } /* get the full device descriptor */ - err = usb2_req_get_device_desc(udev, mtx, &udev->ddesc); + err = usbd_req_get_device_desc(udev, mtx, &udev->ddesc); if (err) { DPRINTFN(0, "addr=%d, getting device " "descriptor failed, %s!\n", old_addr, - usb2_errstr(err)); + usbd_errstr(err)); goto done; } done: if (err && do_retry) { /* give the USB firmware some time to load */ - usb2_pause_mtx(mtx, hz / 2); + usb_pause_mtx(mtx, hz / 2); /* no more retries after this retry */ do_retry = 0; /* try again */ @@ -1556,14 +1556,14 @@ done: } /*------------------------------------------------------------------------* - * usb2_req_clear_device_feature + * usbd_req_clear_device_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel) { struct usb_device_request req; @@ -1573,18 +1573,18 @@ usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, sel); USETW(req.wIndex, 0); USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } /*------------------------------------------------------------------------* - * usb2_req_set_device_feature + * usbd_req_set_device_feature * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, +usbd_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel) { struct usb_device_request req; @@ -1594,5 +1594,5 @@ usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, USETW(req.wValue, sel); USETW(req.wIndex, 0); USETW(req.wLength, 0); - return (usb2_do_request(udev, mtx, &req, 0)); + return (usbd_do_request(udev, mtx, &req, 0)); } diff --git a/sys/dev/usb/usb_request.h b/sys/dev/usb/usb_request.h index f6e6416..b02f345 100644 --- a/sys/dev/usb/usb_request.h +++ b/sys/dev/usb/usb_request.h @@ -29,78 +29,78 @@ struct usb_process; -usb_error_t usb2_do_request_flags(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout); -usb_error_t usb2_do_request_proc(struct usb_device *udev, struct usb_process *pproc, +usb_error_t usbd_do_request_proc(struct usb_device *udev, struct usb_process *pproc, struct usb_device_request *req, void *data, uint16_t flags, uint16_t *actlen, usb_timeout_t timeout); -usb_error_t usb2_req_clear_hub_feature(struct usb_device *udev, +usb_error_t usbd_req_clear_hub_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); -usb_error_t usb2_req_clear_port_feature(struct usb_device *udev, +usb_error_t usbd_req_clear_port_feature(struct usb_device *udev, struct mtx *mtx, uint8_t port, uint16_t sel); -usb_error_t usb2_req_get_alt_interface_no(struct usb_device *udev, +usb_error_t usbd_req_get_alt_interface_no(struct usb_device *udev, struct mtx *mtx, uint8_t *alt_iface_no, uint8_t iface_index); -usb_error_t usb2_req_get_config(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_config(struct usb_device *udev, struct mtx *mtx, uint8_t *pconf); -usb_error_t usb2_req_get_descriptor_ptr(struct usb_device *udev, +usb_error_t usbd_req_get_descriptor_ptr(struct usb_device *udev, struct usb_config_descriptor **ppcd, uint16_t wValue); -usb_error_t usb2_req_get_config_desc(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_config_desc(struct usb_device *udev, struct mtx *mtx, struct usb_config_descriptor *d, uint8_t conf_index); -usb_error_t usb2_req_get_config_desc_full(struct usb_device *udev, +usb_error_t usbd_req_get_config_desc_full(struct usb_device *udev, struct mtx *mtx, struct usb_config_descriptor **ppcd, struct malloc_type *mtype, uint8_t conf_index); -usb_error_t usb2_req_get_desc(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_desc(struct usb_device *udev, struct mtx *mtx, 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); -usb_error_t usb2_req_get_device_desc(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_device_desc(struct usb_device *udev, struct mtx *mtx, struct usb_device_descriptor *d); -usb_error_t usb2_req_get_device_status(struct usb_device *udev, +usb_error_t usbd_req_get_device_status(struct usb_device *udev, struct mtx *mtx, struct usb_status *st); -usb_error_t usb2_req_get_hub_descriptor(struct usb_device *udev, +usb_error_t usbd_req_get_hub_descriptor(struct usb_device *udev, struct mtx *mtx, struct usb_hub_descriptor *hd, uint8_t nports); -usb_error_t usb2_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_hub_status(struct usb_device *udev, struct mtx *mtx, struct usb_hub_status *st); -usb_error_t usb2_req_get_port_status(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_port_status(struct usb_device *udev, struct mtx *mtx, struct usb_port_status *ps, uint8_t port); -usb_error_t usb2_req_get_report(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_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); -usb_error_t usb2_req_get_report_descriptor(struct usb_device *udev, +usb_error_t usbd_req_get_report_descriptor(struct usb_device *udev, struct mtx *mtx, void *d, uint16_t size, uint8_t iface_index); -usb_error_t usb2_req_get_string_any(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_get_string_any(struct usb_device *udev, struct mtx *mtx, char *buf, uint16_t len, uint8_t string_index); -usb_error_t usb2_req_get_string_desc(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_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); -usb_error_t usb2_req_reset_port(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port); -usb_error_t usb2_req_set_address(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_set_address(struct usb_device *udev, struct mtx *mtx, uint16_t addr); -usb_error_t usb2_req_set_alt_interface_no(struct usb_device *udev, +usb_error_t usbd_req_set_alt_interface_no(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint8_t alt_no); -usb_error_t usb2_req_set_config(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf); -usb_error_t usb2_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_set_hub_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); -usb_error_t usb2_req_set_idle(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_set_idle(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint8_t duration, uint8_t id); -usb_error_t usb2_req_set_port_feature(struct usb_device *udev, +usb_error_t usbd_req_set_port_feature(struct usb_device *udev, struct mtx *mtx, uint8_t port, uint16_t sel); -usb_error_t usb2_req_set_protocol(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_req_set_protocol(struct usb_device *udev, struct mtx *mtx, uint8_t iface_index, uint16_t report); -usb_error_t usb2_req_set_report(struct usb_device *udev, struct mtx *mtx, +usb_error_t usbd_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); -usb_error_t usb2_req_re_enumerate(struct usb_device *udev, struct mtx *mtx); -usb_error_t usb2_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); -usb_error_t usb2_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); +usb_error_t usbd_req_re_enumerate(struct usb_device *udev, struct mtx *mtx); +usb_error_t usbd_req_clear_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); +usb_error_t usbd_req_set_device_feature(struct usb_device *udev, struct mtx *mtx, uint16_t sel); -#define usb2_do_request(u,m,r,d) \ - usb2_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT) +#define usbd_do_request(u,m,r,d) \ + usbd_do_request_flags(u,m,r,d,0,NULL,USB_DEFAULT_TIMEOUT) #endif /* _USB2_REQUEST_H_ */ diff --git a/sys/dev/usb/usb_transfer.c b/sys/dev/usb/usb_transfer.c index f258314..bad72d4 100644 --- a/sys/dev/usb/usb_transfer.c +++ b/sys/dev/usb/usb_transfer.c @@ -28,7 +28,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -41,7 +41,7 @@ #include #include -struct usb2_std_packet_size { +struct usb_std_packet_size { struct { uint16_t min; /* inclusive */ uint16_t max; /* inclusive */ @@ -50,9 +50,9 @@ struct usb2_std_packet_size { uint16_t fixed[4]; }; -static usb_callback_t usb2_request_callback; +static usb_callback_t usb_request_callback; -static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { +static const struct usb_config usb_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { /* This transfer is used for generic control endpoint transfers */ @@ -62,7 +62,7 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { .direction = UE_DIR_ANY, .bufsize = USB_EP0_BUFSIZE, /* bytes */ .flags = {.proxy_buffer = 1,}, - .callback = &usb2_request_callback, + .callback = &usb_request_callback, .usb_mode = USB_MODE_DUAL, /* both modes */ }, @@ -73,7 +73,7 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, .bufsize = sizeof(struct usb_device_request), - .callback = &usb2_do_clear_stall_callback, + .callback = &usb_do_clear_stall_callback, .timeout = 1000, /* 1 second */ .interval = 50, /* 50ms */ .usb_mode = USB_MODE_HOST, @@ -82,39 +82,39 @@ static const struct usb_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { /* function prototypes */ -static void usb2_update_max_frame_size(struct usb_xfer *); -static void usb2_transfer_unsetup_sub(struct usb_xfer_root *, uint8_t); -static void usb2_control_transfer_init(struct usb_xfer *); -static uint8_t usb2_start_hardware_sub(struct usb_xfer *); -static void usb2_callback_proc(struct usb_proc_msg *); -static void usb2_callback_ss_done_defer(struct usb_xfer *); -static void usb2_callback_wrapper(struct usb_xfer_queue *); -static void usb2_dma_delay_done_cb(void *); -static void usb2_transfer_start_cb(void *); -static uint8_t usb2_callback_wrapper_sub(struct usb_xfer *); -static void usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, +static void usbd_update_max_frame_size(struct usb_xfer *); +static void usbd_transfer_unsetup_sub(struct usb_xfer_root *, uint8_t); +static void usbd_control_transfer_init(struct usb_xfer *); +static uint8_t usbd_start_hardware_sub(struct usb_xfer *); +static void usb_callback_proc(struct usb_proc_msg *); +static void usbd_callback_ss_done_defer(struct usb_xfer *); +static void usbd_callback_wrapper(struct usb_xfer_queue *); +static void usb_dma_delay_done_cb(void *); +static void usbd_transfer_start_cb(void *); +static uint8_t usbd_callback_wrapper_sub(struct usb_xfer *); +static void usbd_get_std_packet_size(struct usb_std_packet_size *ptr, uint8_t type, enum usb_dev_speed speed); /*------------------------------------------------------------------------* - * usb2_request_callback + * usb_request_callback *------------------------------------------------------------------------*/ static void -usb2_request_callback(struct usb_xfer *xfer) +usb_request_callback(struct usb_xfer *xfer) { if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) - usb2_handle_request_callback(xfer); + usb_handle_request_callback(xfer); else - usb2_do_request_callback(xfer); + usbd_do_request_callback(xfer); } /*------------------------------------------------------------------------* - * usb2_update_max_frame_size + * usbd_update_max_frame_size * * This function updates the maximum frame size, hence high speed USB * can transfer multiple consecutive packets. *------------------------------------------------------------------------*/ static void -usb2_update_max_frame_size(struct usb_xfer *xfer) +usbd_update_max_frame_size(struct usb_xfer *xfer) { /* compute maximum frame size */ @@ -128,7 +128,7 @@ usb2_update_max_frame_size(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_get_dma_delay + * usbd_get_dma_delay * * The following function is called when we need to * synchronize with DMA hardware. @@ -138,7 +138,7 @@ usb2_update_max_frame_size(struct usb_xfer *xfer) * Else: milliseconds of DMA delay *------------------------------------------------------------------------*/ usb_timeout_t -usb2_get_dma_delay(struct usb_bus *bus) +usbd_get_dma_delay(struct usb_bus *bus) { uint32_t temp = 0; @@ -155,7 +155,7 @@ usb2_get_dma_delay(struct usb_bus *bus) } /*------------------------------------------------------------------------* - * usb2_transfer_setup_sub_malloc + * usbd_transfer_setup_sub_malloc * * This function will allocate one or more DMA'able memory chunks * according to "size", "align" and "count" arguments. "ppc" is @@ -167,7 +167,7 @@ usb2_get_dma_delay(struct usb_bus *bus) *------------------------------------------------------------------------*/ #if USB_HAVE_BUSDMA uint8_t -usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, +usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm, struct usb_page_cache **ppc, usb_size_t size, usb_size_t align, usb_size_t count) { @@ -244,7 +244,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, z = r * size; n_obj = r; } - if (usb2_pc_alloc_mem(parm->dma_page_cache_ptr, + if (usb_pc_alloc_mem(parm->dma_page_cache_ptr, pg, z, align)) { return (1); /* failure */ } @@ -257,14 +257,14 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, for (y = 0; (y != n_obj); y++, r--, pc++, pg++) { /* Load sub-chunk into DMA */ - if (usb2_pc_dmamap_create(pc, size)) { + if (usb_pc_dmamap_create(pc, size)) { return (1); /* failure */ } pc->buffer = USB_ADD_BYTES(buf, y * size); pc->page_start = pg; mtx_lock(pc->tag_parent->mtx); - if (usb2_pc_load_mem(pc, size, 1 /* synchronous */ )) { + if (usb_pc_load_mem(pc, size, 1 /* synchronous */ )) { mtx_unlock(pc->tag_parent->mtx); return (1); /* failure */ } @@ -279,7 +279,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, #endif /*------------------------------------------------------------------------* - * usb2_transfer_setup_sub - transfer setup subroutine + * usbd_transfer_setup_sub - transfer setup subroutine * * This function must be called from the "xfer_setup" callback of the * USB Host or Device controller driver when setting up an USB @@ -288,7 +288,7 @@ usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, * structure. *------------------------------------------------------------------------*/ void -usb2_transfer_setup_sub(struct usb_setup_params *parm) +usbd_transfer_setup_sub(struct usb_setup_params *parm) { enum { REQ_SIZE = 8, @@ -297,7 +297,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) struct usb_xfer *xfer = parm->curr_xfer; const struct usb_config *setup = parm->curr_setup; struct usb_endpoint_descriptor *edesc; - struct usb2_std_packet_size std_size; + struct usb_std_packet_size std_size; usb_frcount_t n_frlengths; usb_frcount_t n_frbuffers; usb_frcount_t x; @@ -348,7 +348,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) } /* filter "wMaxPacketSize" according to standard sizes */ - usb2_get_std_packet_size(&std_size, type, parm->speed); + usbd_get_std_packet_size(&std_size, type, parm->speed); if (std_size.range.min || std_size.range.max) { @@ -374,7 +374,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) /* compute "max_frame_size" */ - usb2_update_max_frame_size(xfer); + usbd_update_max_frame_size(xfer); /* check interrupt interval and transfer pre-delay */ @@ -478,7 +478,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) xfer->max_packet_size = MIN_PKT; xfer->max_packet_count = 1; parm->bufsize = 0; /* automatic setup length */ - usb2_update_max_frame_size(xfer); + usbd_update_max_frame_size(xfer); } else { parm->err = USB_ERR_ZERO_MAXP; @@ -601,10 +601,10 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) xfer->local_buffer = USB_ADD_BYTES(parm->buf, parm->size[0]); - usb2_set_frame_offset(xfer, 0, 0); + usbd_set_frame_offset(xfer, 0, 0); if ((type == UE_CONTROL) && (n_frbuffers > 1)) { - usb2_set_frame_offset(xfer, REQ_SIZE, 1); + usbd_set_frame_offset(xfer, REQ_SIZE, 1); } } parm->size[0] += parm->bufsize; @@ -676,7 +676,7 @@ usb2_transfer_setup_sub(struct usb_setup_params *parm) if (xfer->flags_int.bdma_enable && (parm->bufsize_max > 0)) { - if (usb2_pc_dmamap_create( + if (usb_pc_dmamap_create( xfer->frbuffers + x, parm->bufsize_max)) { parm->err = USB_ERR_NOMEM; @@ -701,10 +701,10 @@ done: } /*------------------------------------------------------------------------* - * usb2_transfer_setup - setup an array of USB transfers + * usbd_transfer_setup - setup an array of USB transfers * - * NOTE: You must always call "usb2_transfer_unsetup" after calling - * "usb2_transfer_setup" if success was returned. + * NOTE: You must always call "usbd_transfer_unsetup" after calling + * "usbd_transfer_setup" if success was returned. * * The idea is that the USB device driver should pre-allocate all its * transfers by one call to this function. @@ -714,7 +714,7 @@ done: * Else: Failure *------------------------------------------------------------------------*/ usb_error_t -usb2_transfer_setup(struct usb_device *udev, +usbd_transfer_setup(struct usb_device *udev, const uint8_t *ifaces, struct usb_xfer **ppxfer, const struct usb_config *setup_start, uint16_t n_setup, void *priv_sc, struct mtx *xfer_mtx) @@ -735,7 +735,7 @@ usb2_transfer_setup(struct usb_device *udev, info = NULL; WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, - "usb2_transfer_setup can sleep!"); + "usbd_transfer_setup can sleep!"); /* do some checking first */ @@ -771,7 +771,7 @@ usb2_transfer_setup(struct usb_device *udev, bzero(&parm, sizeof(parm)); parm.udev = udev; - parm.speed = usb2_get_speed(udev); + parm.speed = usbd_get_speed(udev); parm.hc_max_packet_count = 1; if (parm.speed >= USB_SPEED_MAX) { @@ -803,23 +803,23 @@ usb2_transfer_setup(struct usb_device *udev, info->xfer_mtx = xfer_mtx; #if USB_HAVE_BUSDMA - usb2_dma_tag_setup(&info->dma_parent_tag, + usb_dma_tag_setup(&info->dma_parent_tag, parm.dma_tag_p, udev->bus->dma_parent_tag[0].tag, - xfer_mtx, &usb2_bdma_done_event, 32, parm.dma_tag_max); + xfer_mtx, &usb_bdma_done_event, 32, parm.dma_tag_max); #endif info->bus = udev->bus; info->udev = udev; TAILQ_INIT(&info->done_q.head); - info->done_q.command = &usb2_callback_wrapper; + info->done_q.command = &usbd_callback_wrapper; #if USB_HAVE_BUSDMA TAILQ_INIT(&info->dma_q.head); - info->dma_q.command = &usb2_bdma_work_loop; + info->dma_q.command = &usb_bdma_work_loop; #endif - info->done_m[0].hdr.pm_callback = &usb2_callback_proc; + info->done_m[0].hdr.pm_callback = &usb_callback_proc; info->done_m[0].xroot = info; - info->done_m[1].hdr.pm_callback = &usb2_callback_proc; + info->done_m[1].hdr.pm_callback = &usb_callback_proc; info->done_m[1].xroot = info; /* @@ -828,7 +828,7 @@ usb2_transfer_setup(struct usb_device *udev, * context, else there is a chance of * deadlock! */ - if (setup_start == usb2_control_ep_cfg) + if (setup_start == usb_control_ep_cfg) info->done_p = &udev->bus->control_xfer_proc; else if (xfer_mtx == &Giant) @@ -852,7 +852,7 @@ usb2_transfer_setup(struct usb_device *udev, continue; } /* see if there is a matching endpoint */ - ep = usb2_get_endpoint(udev, + ep = usbd_get_endpoint(udev, ifaces[setup->if_index], setup); if ((ep == NULL) || (ep->methods == NULL)) { @@ -881,7 +881,7 @@ usb2_transfer_setup(struct usb_device *udev, xfer->priv_sc = priv_sc; xfer->xroot = info; - usb2_callout_init_mtx(&xfer->timeout_handle, + usb_callout_init_mtx(&xfer->timeout_handle, &udev->bus->bus_mtx, 0); } else { /* @@ -1031,26 +1031,26 @@ done: if (buf) { if (info->setup_refcount == 0) { /* - * "usb2_transfer_unsetup_sub" will unlock + * "usbd_transfer_unsetup_sub" will unlock * the bus mutex before returning ! */ USB_BUS_LOCK(info->bus); /* something went wrong */ - usb2_transfer_unsetup_sub(info, 0); + usbd_transfer_unsetup_sub(info, 0); } } if (parm.err) { - usb2_transfer_unsetup(ppxfer, n_setup); + usbd_transfer_unsetup(ppxfer, n_setup); } return (parm.err); } /*------------------------------------------------------------------------* - * usb2_transfer_unsetup_sub - factored out code + * usbd_transfer_unsetup_sub - factored out code *------------------------------------------------------------------------*/ static void -usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay) +usbd_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay) { struct usb_page_cache *pc; @@ -1060,13 +1060,13 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay) if (needs_delay) { usb_timeout_t temp; - temp = usb2_get_dma_delay(info->bus); - usb2_pause_mtx(&info->bus->bus_mtx, + temp = usbd_get_dma_delay(info->bus); + usb_pause_mtx(&info->bus->bus_mtx, USB_MS_TO_TICKS(temp)); } /* make sure that our done messages are not queued anywhere */ - usb2_proc_mwait(info->done_p, &info->done_m[0], &info->done_m[1]); + usb_proc_mwait(info->done_p, &info->done_m[0], &info->done_m[1]); USB_BUS_UNLOCK(info->bus); @@ -1074,19 +1074,19 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay) /* free DMA'able memory, if any */ pc = info->dma_page_cache_start; while (pc != info->dma_page_cache_end) { - usb2_pc_free_mem(pc); + usb_pc_free_mem(pc); pc++; } /* free DMA maps in all "xfer->frbuffers" */ pc = info->xfer_page_cache_start; while (pc != info->xfer_page_cache_end) { - usb2_pc_dmamap_destroy(pc); + usb_pc_dmamap_destroy(pc); pc++; } /* free all DMA tags */ - usb2_dma_tag_unsetup(&info->dma_parent_tag); + usb_dma_tag_unsetup(&info->dma_parent_tag); #endif cv_destroy(&info->cv_drain); @@ -1099,21 +1099,21 @@ usb2_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay) } /*------------------------------------------------------------------------* - * usb2_transfer_unsetup - unsetup/free an array of USB transfers + * usbd_transfer_unsetup - unsetup/free an array of USB transfers * * NOTE: All USB transfers in progress will get called back passing * the error code "USB_ERR_CANCELLED" before this function * returns. *------------------------------------------------------------------------*/ void -usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) +usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) { struct usb_xfer *xfer; struct usb_xfer_root *info; uint8_t needs_delay = 0; WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, - "usb2_transfer_unsetup can sleep!"); + "usbd_transfer_unsetup can sleep!"); while (n_setup--) { xfer = pxfer[n_setup]; @@ -1130,13 +1130,13 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) * HINT: when you start/stop a transfer, it might be a * good idea to directly use the "pxfer[]" structure: * - * usb2_transfer_start(sc->pxfer[0]); - * usb2_transfer_stop(sc->pxfer[0]); + * usbd_transfer_start(sc->pxfer[0]); + * usbd_transfer_stop(sc->pxfer[0]); * * That way, if your code has many parts that will not * stop running under the same lock, in other words - * "xfer_mtx", the usb2_transfer_start and - * usb2_transfer_stop functions will simply return + * "xfer_mtx", the usbd_transfer_start and + * usbd_transfer_stop functions will simply return * when they detect a NULL pointer argument. * * To avoid any races we clear the "pxfer[]" pointer @@ -1147,7 +1147,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) USB_BUS_UNLOCK(info->bus); USB_XFER_UNLOCK(xfer); - usb2_transfer_drain(xfer); + usbd_transfer_drain(xfer); #if USB_HAVE_BUSDMA if (xfer->flags_int.bdma_enable) @@ -1159,7 +1159,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) */ xfer->endpoint->refcount--; - usb2_callout_drain(&xfer->timeout_handle); + usb_callout_drain(&xfer->timeout_handle); USB_BUS_LOCK(info->bus); @@ -1169,7 +1169,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) info->setup_refcount--; if (info->setup_refcount == 0) { - usb2_transfer_unsetup_sub(info, + usbd_transfer_unsetup_sub(info, needs_delay); } else { USB_BUS_UNLOCK(info->bus); @@ -1178,7 +1178,7 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) } /*------------------------------------------------------------------------* - * usb2_control_transfer_init - factored out code + * usbd_control_transfer_init - factored out code * * In USB Device Mode we have to wait for the SETUP packet which * containst the "struct usb_device_request" structure, before we can @@ -1189,13 +1189,13 @@ usb2_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup) * initialisation code, so that we don't duplicate the code. *------------------------------------------------------------------------*/ static void -usb2_control_transfer_init(struct usb_xfer *xfer) +usbd_control_transfer_init(struct usb_xfer *xfer) { struct usb_device_request req; /* copy out the USB request header */ - usb2_copy_out(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req)); /* setup remainder */ @@ -1209,7 +1209,7 @@ usb2_control_transfer_init(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_start_hardware_sub + * usbd_start_hardware_sub * * This function handles initialisation of control transfers. Control * transfers are special in that regard that they can both transmit @@ -1220,7 +1220,7 @@ usb2_control_transfer_init(struct usb_xfer *xfer) * Else: Failure *------------------------------------------------------------------------*/ static uint8_t -usb2_start_hardware_sub(struct usb_xfer *xfer) +usbd_start_hardware_sub(struct usb_xfer *xfer) { usb_frlength_t len; @@ -1261,7 +1261,7 @@ usb2_start_hardware_sub(struct usb_xfer *xfer) /* setup control transfer */ if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) { - usb2_control_transfer_init(xfer); + usbd_control_transfer_init(xfer); } } /* get data length */ @@ -1294,14 +1294,14 @@ usb2_start_hardware_sub(struct usb_xfer *xfer) /* * Set a dummy "control_rem" value. This * variable will be overwritten later by a - * call to "usb2_control_transfer_init()" ! + * call to "usbd_control_transfer_init()" ! */ xfer->flags_int.control_rem = 0xFFFF; } else { /* setup "endpoint" and "control_rem" */ - usb2_control_transfer_init(xfer); + usbd_control_transfer_init(xfer); } /* set transfer-header flag */ @@ -1362,12 +1362,12 @@ error: } /*------------------------------------------------------------------------* - * usb2_start_hardware - start USB hardware for the given transfer + * usbd_transfer_submit - start USB hardware for the given transfer * * This function should only be called from the USB callback. *------------------------------------------------------------------------*/ void -usb2_start_hardware(struct usb_xfer *xfer) +usbd_transfer_submit(struct usb_xfer *xfer) { struct usb_xfer_root *info; struct usb_bus *bus; @@ -1384,7 +1384,7 @@ usb2_start_hardware(struct usb_xfer *xfer) if (USB_DEBUG_VAR > 0) { USB_BUS_LOCK(bus); - usb2_dump_endpoint(xfer->endpoint); + usb_dump_endpoint(xfer->endpoint); USB_BUS_UNLOCK(bus); } @@ -1408,7 +1408,7 @@ usb2_start_hardware(struct usb_xfer *xfer) #if USB_HAVE_POWERD /* increment power reference */ - usb2_transfer_power_ref(xfer, 1); + usbd_transfer_power_ref(xfer, 1); #endif /* * Check if the transfer is waiting on a queue, most @@ -1416,7 +1416,7 @@ usb2_start_hardware(struct usb_xfer *xfer) */ if (xfer->wait_queue) { USB_BUS_LOCK(bus); - usb2_transfer_dequeue(xfer); + usbd_transfer_dequeue(xfer); USB_BUS_UNLOCK(bus); } /* clear "did_dma_delay" flag */ @@ -1447,7 +1447,7 @@ usb2_start_hardware(struct usb_xfer *xfer) * Must return cancelled error code else * device drivers can hang. */ - usb2_transfer_done(xfer, USB_ERR_CANCELLED); + usbd_transfer_done(xfer, USB_ERR_CANCELLED); USB_BUS_UNLOCK(bus); return; } @@ -1464,12 +1464,12 @@ usb2_start_hardware(struct usb_xfer *xfer) USB_BUS_LOCK(bus); xfer->flags_int.can_cancel_immed = 1; /* start the transfer */ - usb2_command_wrapper(&xfer->endpoint->endpoint_q, xfer); + usb_command_wrapper(&xfer->endpoint->endpoint_q, xfer); USB_BUS_UNLOCK(bus); return; } USB_BUS_LOCK(bus); - usb2_transfer_done(xfer, USB_ERR_INVAL); + usbd_transfer_done(xfer, USB_ERR_INVAL); USB_BUS_UNLOCK(bus); return; } @@ -1480,7 +1480,7 @@ usb2_start_hardware(struct usb_xfer *xfer) if (xfer->sumlen < xfer->frlengths[x]) { /* length wrapped around */ USB_BUS_LOCK(bus); - usb2_transfer_done(xfer, USB_ERR_INVAL); + usbd_transfer_done(xfer, USB_ERR_INVAL); USB_BUS_UNLOCK(bus); return; } @@ -1495,9 +1495,9 @@ usb2_start_hardware(struct usb_xfer *xfer) if (xfer->flags_int.control_xfr) { - if (usb2_start_hardware_sub(xfer)) { + if (usbd_start_hardware_sub(xfer)) { USB_BUS_LOCK(bus); - usb2_transfer_done(xfer, USB_ERR_STALLED); + usbd_transfer_done(xfer, USB_ERR_STALLED); USB_BUS_UNLOCK(bus); return; } @@ -1540,7 +1540,7 @@ usb2_start_hardware(struct usb_xfer *xfer) #if USB_HAVE_BUSDMA if (xfer->flags_int.bdma_enable) { /* insert the USB transfer last in the BUS-DMA queue */ - usb2_command_wrapper(&xfer->xroot->dma_q, xfer); + usb_command_wrapper(&xfer->xroot->dma_q, xfer); return; } #endif @@ -1548,14 +1548,14 @@ usb2_start_hardware(struct usb_xfer *xfer) * Enter the USB transfer into the Host Controller or * Device Controller schedule: */ - usb2_pipe_enter(xfer); + usbd_pipe_enter(xfer); } /*------------------------------------------------------------------------* - * usb2_pipe_enter - factored out code + * usbd_pipe_enter - factored out code *------------------------------------------------------------------------*/ void -usb2_pipe_enter(struct usb_xfer *xfer) +usbd_pipe_enter(struct usb_xfer *xfer) { struct usb_endpoint *ep; @@ -1575,25 +1575,25 @@ usb2_pipe_enter(struct usb_xfer *xfer) /* check for transfer error */ if (xfer->error) { /* some error has happened */ - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); USB_BUS_UNLOCK(xfer->xroot->bus); return; } /* start the transfer */ - usb2_command_wrapper(&ep->endpoint_q, xfer); + usb_command_wrapper(&ep->endpoint_q, xfer); USB_BUS_UNLOCK(xfer->xroot->bus); } /*------------------------------------------------------------------------* - * usb2_transfer_start - start an USB transfer + * usbd_transfer_start - start an USB transfer * * NOTE: Calling this function more than one time will only * result in a single transfer start, until the USB transfer * completes. *------------------------------------------------------------------------*/ void -usb2_transfer_start(struct usb_xfer *xfer) +usbd_transfer_start(struct usb_xfer *xfer) { if (xfer == NULL) { /* transfer is gone */ @@ -1613,20 +1613,20 @@ usb2_transfer_start(struct usb_xfer *xfer) } USB_BUS_LOCK(xfer->xroot->bus); /* call the USB transfer callback */ - usb2_callback_ss_done_defer(xfer); + usbd_callback_ss_done_defer(xfer); USB_BUS_UNLOCK(xfer->xroot->bus); } /*------------------------------------------------------------------------* - * usb2_transfer_stop - stop an USB transfer + * usbd_transfer_stop - stop an USB transfer * * NOTE: Calling this function more than one time will only * result in a single transfer stop. * NOTE: When this function returns it is not safe to free nor - * reuse any DMA buffers. See "usb2_transfer_drain()". + * reuse any DMA buffers. See "usbd_transfer_drain()". *------------------------------------------------------------------------*/ void -usb2_transfer_stop(struct usb_xfer *xfer) +usbd_transfer_stop(struct usb_xfer *xfer) { struct usb_endpoint *ep; @@ -1679,7 +1679,7 @@ usb2_transfer_stop(struct usb_xfer *xfer) /* * Any additional DMA delay is done by - * "usb2_transfer_unsetup()". + * "usbd_transfer_unsetup()". */ /* @@ -1693,7 +1693,7 @@ usb2_transfer_stop(struct usb_xfer *xfer) * to start the next one: */ if (ep->endpoint_q.curr == xfer) { - usb2_command_wrapper(&ep->endpoint_q, NULL); + usb_command_wrapper(&ep->endpoint_q, NULL); } } @@ -1701,7 +1701,7 @@ usb2_transfer_stop(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_transfer_pending + * usbd_transfer_pending * * This function will check if an USB transfer is pending which is a * little bit complicated! @@ -1710,7 +1710,7 @@ usb2_transfer_stop(struct usb_xfer *xfer) * 1: Pending: The USB transfer will receive a callback in the future. *------------------------------------------------------------------------*/ uint8_t -usb2_transfer_pending(struct usb_xfer *xfer) +usbd_transfer_pending(struct usb_xfer *xfer) { struct usb_xfer_root *info; struct usb_xfer_queue *pq; @@ -1745,7 +1745,7 @@ usb2_transfer_pending(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_transfer_drain + * usbd_transfer_drain * * This function will stop the USB transfer and wait for any * additional BUS-DMA and HW-DMA operations to complete. Buffers that @@ -1753,10 +1753,10 @@ usb2_transfer_pending(struct usb_xfer *xfer) * function has returned. *------------------------------------------------------------------------*/ void -usb2_transfer_drain(struct usb_xfer *xfer) +usbd_transfer_drain(struct usb_xfer *xfer) { WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, - "usb2_transfer_drain can sleep!"); + "usbd_transfer_drain can sleep!"); if (xfer == NULL) { /* transfer is gone */ @@ -1767,9 +1767,9 @@ usb2_transfer_drain(struct usb_xfer *xfer) } USB_XFER_LOCK(xfer); - usb2_transfer_stop(xfer); + usbd_transfer_stop(xfer); - while (usb2_transfer_pending(xfer)) { + while (usbd_transfer_pending(xfer)) { xfer->flags_int.draining = 1; /* * Wait until the current outstanding USB @@ -1781,7 +1781,7 @@ usb2_transfer_drain(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_set_frame_data + * usbd_set_frame_data * * This function sets the pointer of the buffer that should * loaded directly into DMA for the given USB frame. Passing "ptr" @@ -1789,20 +1789,20 @@ usb2_transfer_drain(struct usb_xfer *xfer) * than zero gives undefined results! *------------------------------------------------------------------------*/ void -usb2_set_frame_data(struct usb_xfer *xfer, void *ptr, usb_frcount_t frindex) +usbd_set_frame_data(struct usb_xfer *xfer, void *ptr, usb_frcount_t frindex) { /* set virtual address to load and length */ xfer->frbuffers[frindex].buffer = ptr; } /*------------------------------------------------------------------------* - * usb2_set_frame_offset + * usbd_set_frame_offset * * This function sets the frame data buffer offset relative to the beginning * of the USB DMA buffer allocated for this USB transfer. *------------------------------------------------------------------------*/ void -usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, +usbd_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, usb_frcount_t frindex) { USB_ASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame " @@ -1814,12 +1814,12 @@ usb2_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset, } /*------------------------------------------------------------------------* - * usb2_callback_proc - factored out code + * usb_callback_proc - factored out code * * This function performs USB callbacks. *------------------------------------------------------------------------*/ static void -usb2_callback_proc(struct usb_proc_msg *_pm) +usb_callback_proc(struct usb_proc_msg *_pm) { struct usb_done_msg *pm = (void *)_pm; struct usb_xfer_root *info = pm->xroot; @@ -1835,20 +1835,20 @@ usb2_callback_proc(struct usb_proc_msg *_pm) USB_BUS_LOCK(info->bus); /* Continue where we lost track */ - usb2_command_wrapper(&info->done_q, + usb_command_wrapper(&info->done_q, info->done_q.curr); mtx_unlock(info->xfer_mtx); } /*------------------------------------------------------------------------* - * usb2_callback_ss_done_defer + * usbd_callback_ss_done_defer * * This function will defer the start, stop and done callback to the * correct thread. *------------------------------------------------------------------------*/ static void -usb2_callback_ss_done_defer(struct usb_xfer *xfer) +usbd_callback_ss_done_defer(struct usb_xfer *xfer) { struct usb_xfer_root *info = xfer->xroot; struct usb_xfer_queue *pq = &info->done_q; @@ -1856,7 +1856,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer) USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); if (pq->curr != xfer) { - usb2_transfer_enqueue(pq, xfer); + usbd_transfer_enqueue(pq, xfer); } if (!pq->recurse_1) { @@ -1865,7 +1865,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer) * will have a Lock Order Reversal, LOR, if we try to * proceed ! */ - if (usb2_proc_msignal(info->done_p, + if (usb_proc_msignal(info->done_p, &info->done_m[0], &info->done_m[1])) { /* ignore */ } @@ -1878,7 +1878,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_callback_wrapper + * usbd_callback_wrapper * * This is a wrapper for USB callbacks. This wrapper does some * auto-magic things like figuring out if we can call the callback @@ -1886,7 +1886,7 @@ usb2_callback_ss_done_defer(struct usb_xfer *xfer) * interrupt process. *------------------------------------------------------------------------*/ static void -usb2_callback_wrapper(struct usb_xfer_queue *pq) +usbd_callback_wrapper(struct usb_xfer_queue *pq) { struct usb_xfer *xfer = pq->curr; struct usb_xfer_root *info = xfer->xroot; @@ -1905,7 +1905,7 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq) * will have a Lock Order Reversal, LOR, if we try to * proceed ! */ - if (usb2_proc_msignal(info->done_p, + if (usb_proc_msignal(info->done_p, &info->done_m[0], &info->done_m[1])) { /* ignore */ } @@ -1928,7 +1928,7 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq) /* set correct USB state for callback */ if (!xfer->flags_int.transferring) { - xfer->usb2_state = USB_ST_SETUP; + xfer->usb_state = USB_ST_SETUP; if (!xfer->flags_int.started) { /* we got stopped before we even got started */ USB_BUS_LOCK(info->bus); @@ -1936,27 +1936,27 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq) } } else { - if (usb2_callback_wrapper_sub(xfer)) { + if (usbd_callback_wrapper_sub(xfer)) { /* the callback has been deferred */ USB_BUS_LOCK(info->bus); goto done; } #if USB_HAVE_POWERD /* decrement power reference */ - usb2_transfer_power_ref(xfer, -1); + usbd_transfer_power_ref(xfer, -1); #endif xfer->flags_int.transferring = 0; if (xfer->error) { - xfer->usb2_state = USB_ST_ERROR; + xfer->usb_state = USB_ST_ERROR; } else { /* set transferred state */ - xfer->usb2_state = USB_ST_TRANSFERRED; + xfer->usb_state = USB_ST_TRANSFERRED; #if USB_HAVE_BUSDMA /* sync DMA memory, if any */ if (xfer->flags_int.bdma_enable && (!xfer->flags_int.bdma_no_post_sync)) { - usb2_bdma_post_sync(xfer); + usb_bdma_post_sync(xfer); } #endif } @@ -1974,9 +1974,9 @@ usb2_callback_wrapper(struct usb_xfer_queue *pq) */ if ((!xfer->flags_int.open) && (xfer->flags_int.started) && - (xfer->usb2_state == USB_ST_ERROR)) { + (xfer->usb_state == USB_ST_ERROR)) { /* try to loop, but not recursivly */ - usb2_command_wrapper(&info->done_q, xfer); + usb_command_wrapper(&info->done_q, xfer); return; } @@ -1986,18 +1986,18 @@ done: */ if (xfer->flags_int.draining && (!xfer->flags_int.transferring)) { - /* "usb2_transfer_drain()" is waiting for end of transfer */ + /* "usbd_transfer_drain()" is waiting for end of transfer */ xfer->flags_int.draining = 0; cv_broadcast(&info->cv_drain); } /* do the next callback, if any */ - usb2_command_wrapper(&info->done_q, + usb_command_wrapper(&info->done_q, info->done_q.curr); } /*------------------------------------------------------------------------* - * usb2_dma_delay_done_cb + * usb_dma_delay_done_cb * * This function is called when the DMA delay has been exectuded, and * will make sure that the callback is called to complete the USB @@ -2005,7 +2005,7 @@ done: * error like USB_ERR_CANCELLED. *------------------------------------------------------------------------*/ static void -usb2_dma_delay_done_cb(void *arg) +usb_dma_delay_done_cb(void *arg) { struct usb_xfer *xfer = arg; @@ -2014,11 +2014,11 @@ usb2_dma_delay_done_cb(void *arg) DPRINTFN(3, "Completed %p\n", xfer); /* queue callback for execution, again */ - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); } /*------------------------------------------------------------------------* - * usb2_transfer_dequeue + * usbd_transfer_dequeue * * - This function is used to remove an USB transfer from a USB * transfer queue. @@ -2026,7 +2026,7 @@ usb2_dma_delay_done_cb(void *arg) * - This function can be called multiple times in a row. *------------------------------------------------------------------------*/ void -usb2_transfer_dequeue(struct usb_xfer *xfer) +usbd_transfer_dequeue(struct usb_xfer *xfer) { struct usb_xfer_queue *pq; @@ -2038,7 +2038,7 @@ usb2_transfer_dequeue(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_transfer_enqueue + * usbd_transfer_enqueue * * - This function is used to insert an USB transfer into a USB * * transfer queue. @@ -2046,7 +2046,7 @@ usb2_transfer_dequeue(struct usb_xfer *xfer) * - This function can be called multiple times in a row. *------------------------------------------------------------------------*/ void -usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer) +usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer) { /* * Insert the USB transfer into the queue, if it is not @@ -2059,7 +2059,7 @@ usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_transfer_done + * usbd_transfer_done * * - This function is used to remove an USB transfer from the busdma, * pipe or interrupt queue. @@ -2070,11 +2070,11 @@ usb2_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer) * - This function is used to stop any USB transfer timeouts. *------------------------------------------------------------------------*/ void -usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error) +usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error) { USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); - DPRINTF("err=%s\n", usb2_errstr(error)); + DPRINTF("err=%s\n", usbd_errstr(error)); /* * If we are not transferring then just return. @@ -2089,14 +2089,14 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error) xfer->error = error; } /* stop any callouts */ - usb2_callout_stop(&xfer->timeout_handle); + usb_callout_stop(&xfer->timeout_handle); /* * If we are waiting on a queue, just remove the USB transfer * from the queue, if any. We should have the required locks * locked to do the remove when this function is called. */ - usb2_transfer_dequeue(xfer); + usbd_transfer_dequeue(xfer); #if USB_HAVE_BUSDMA if (mtx_owned(xfer->xroot->xfer_mtx)) { @@ -2110,7 +2110,7 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error) if (pq->curr == xfer) { /* start the next BUS-DMA load, if any */ - usb2_command_wrapper(pq, NULL); + usb_command_wrapper(pq, NULL); } } #endif @@ -2124,18 +2124,18 @@ usb2_transfer_done(struct usb_xfer *xfer, usb_error_t error) } /* call the USB transfer callback */ - usb2_callback_ss_done_defer(xfer); + usbd_callback_ss_done_defer(xfer); } /*------------------------------------------------------------------------* - * usb2_transfer_start_cb + * usbd_transfer_start_cb * * This function is called to start the USB transfer when * "xfer->interval" is greater than zero, and and the endpoint type is * BULK or CONTROL. *------------------------------------------------------------------------*/ static void -usb2_transfer_start_cb(void *arg) +usbd_transfer_start_cb(void *arg) { struct usb_xfer *xfer = arg; struct usb_endpoint *ep = xfer->endpoint; @@ -2152,18 +2152,18 @@ usb2_transfer_start_cb(void *arg) /* check for error */ if (xfer->error) { /* some error has happened */ - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); } } /*------------------------------------------------------------------------* - * usb2_transfer_set_stall + * usbd_transfer_set_stall * * This function is used to set the stall flag outside the * callback. This function is NULL safe. *------------------------------------------------------------------------*/ void -usb2_transfer_set_stall(struct usb_xfer *xfer) +usbd_transfer_set_stall(struct usb_xfer *xfer) { if (xfer == NULL) { /* tearing down */ @@ -2180,13 +2180,13 @@ usb2_transfer_set_stall(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_transfer_clear_stall + * usbd_transfer_clear_stall * * This function is used to clear the stall flag outside the * callback. This function is NULL safe. *------------------------------------------------------------------------*/ void -usb2_transfer_clear_stall(struct usb_xfer *xfer) +usbd_transfer_clear_stall(struct usb_xfer *xfer) { if (xfer == NULL) { /* tearing down */ @@ -2203,12 +2203,12 @@ usb2_transfer_clear_stall(struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_pipe_start + * usbd_pipe_start * * This function is used to add an USB transfer to the pipe transfer list. *------------------------------------------------------------------------*/ void -usb2_pipe_start(struct usb_xfer_queue *pq) +usbd_pipe_start(struct usb_xfer_queue *pq) { struct usb_endpoint *ep; struct usb_xfer *xfer; @@ -2250,7 +2250,7 @@ usb2_pipe_start(struct usb_xfer_queue *pq) udev, NULL, ep); } else if (udev->default_xfer[1]) { info = udev->default_xfer[1]->xroot; - if (usb2_proc_msignal( + if (usb_proc_msignal( &info->bus->non_giant_callback_proc, &udev->cs_msg[0], &udev->cs_msg[1])) { /* ignore */ @@ -2269,7 +2269,7 @@ usb2_pipe_start(struct usb_xfer_queue *pq) if (xfer->nframes == 0) { /* we are complete */ xfer->aframes = 0; - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); return; } /* @@ -2287,8 +2287,8 @@ usb2_pipe_start(struct usb_xfer_queue *pq) type = (ep->edesc->bmAttributes & UE_XFERTYPE); if ((type == UE_BULK) || (type == UE_CONTROL)) { - usb2_transfer_timeout_ms(xfer, - &usb2_transfer_start_cb, + usbd_transfer_timeout_ms(xfer, + &usbd_transfer_start_cb, xfer->interval); return; } @@ -2303,30 +2303,30 @@ usb2_pipe_start(struct usb_xfer_queue *pq) /* check for error */ if (xfer->error) { /* some error has happened */ - usb2_transfer_done(xfer, 0); + usbd_transfer_done(xfer, 0); } } /*------------------------------------------------------------------------* - * usb2_transfer_timeout_ms + * usbd_transfer_timeout_ms * * This function is used to setup a timeout on the given USB * transfer. If the timeout has been deferred the callback given by * "cb" will get called after "ms" milliseconds. *------------------------------------------------------------------------*/ void -usb2_transfer_timeout_ms(struct usb_xfer *xfer, +usbd_transfer_timeout_ms(struct usb_xfer *xfer, void (*cb) (void *arg), usb_timeout_t ms) { USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); /* defer delay */ - usb2_callout_reset(&xfer->timeout_handle, + usb_callout_reset(&xfer->timeout_handle, USB_MS_TO_TICKS(ms), cb, xfer); } /*------------------------------------------------------------------------* - * usb2_callback_wrapper_sub + * usbd_callback_wrapper_sub * * - This function will update variables in an USB transfer after * that the USB transfer is complete. @@ -2343,7 +2343,7 @@ usb2_transfer_timeout_ms(struct usb_xfer *xfer, * Else: The callback has been deferred. *------------------------------------------------------------------------*/ static uint8_t -usb2_callback_wrapper_sub(struct usb_xfer *xfer) +usbd_callback_wrapper_sub(struct usb_xfer *xfer) { struct usb_endpoint *ep; usb_frcount_t x; @@ -2374,15 +2374,15 @@ usb2_callback_wrapper_sub(struct usb_xfer *xfer) /* we can not cancel this delay */ xfer->flags_int.can_cancel_immed = 0; - temp = usb2_get_dma_delay(xfer->xroot->bus); + temp = usbd_get_dma_delay(xfer->xroot->bus); DPRINTFN(3, "DMA delay, %u ms, " "on %p\n", temp, xfer); if (temp != 0) { USB_BUS_LOCK(xfer->xroot->bus); - usb2_transfer_timeout_ms(xfer, - &usb2_dma_delay_done_cb, temp); + usbd_transfer_timeout_ms(xfer, + &usb_dma_delay_done_cb, temp); USB_BUS_UNLOCK(xfer->xroot->bus); return (1); /* wait for new callback */ } @@ -2477,7 +2477,7 @@ usb2_callback_wrapper_sub(struct usb_xfer *xfer) */ USB_BUS_LOCK(xfer->xroot->bus); if (ep->endpoint_q.curr == xfer) { - usb2_command_wrapper(&ep->endpoint_q, NULL); + usb_command_wrapper(&ep->endpoint_q, NULL); if (ep->endpoint_q.curr || TAILQ_FIRST(&ep->endpoint_q.head)) { /* there is another USB transfer waiting */ @@ -2493,13 +2493,13 @@ done: } /*------------------------------------------------------------------------* - * usb2_command_wrapper + * usb_command_wrapper * * This function is used to execute commands non-recursivly on an USB * transfer. *------------------------------------------------------------------------*/ void -usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer) +usb_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer) { if (xfer) { /* @@ -2507,7 +2507,7 @@ usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer) * queue it! */ if (pq->curr != xfer) { - usb2_transfer_enqueue(pq, xfer); + usbd_transfer_enqueue(pq, xfer); if (pq->curr != NULL) { /* something is already processing */ DPRINTFN(6, "busy %p\n", pq->curr); @@ -2554,13 +2554,13 @@ usb2_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer) } /*------------------------------------------------------------------------* - * usb2_default_transfer_setup + * usbd_default_transfer_setup * * This function is used to setup the default USB control endpoint * transfer. *------------------------------------------------------------------------*/ void -usb2_default_transfer_setup(struct usb_device *udev) +usbd_default_transfer_setup(struct usb_device *udev) { struct usb_xfer *xfer; uint8_t no_resetup; @@ -2585,7 +2585,7 @@ repeat: * starting the USB transfer must be * atomic! */ - usb2_transfer_start(xfer); + usbd_transfer_start(xfer); } } USB_XFER_UNLOCK(xfer); @@ -2609,15 +2609,15 @@ repeat: /* * Unsetup any existing USB transfer: */ - usb2_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); + usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX); /* * Try to setup a new USB transfer for the * default control endpoint: */ iface_index = 0; - if (usb2_transfer_setup(udev, &iface_index, - udev->default_xfer, usb2_control_ep_cfg, USB_DEFAULT_XFER_MAX, NULL, + if (usbd_transfer_setup(udev, &iface_index, + udev->default_xfer, usb_control_ep_cfg, USB_DEFAULT_XFER_MAX, NULL, udev->default_mtx)) { DPRINTFN(0, "could not setup default " "USB transfer!\n"); @@ -2627,13 +2627,13 @@ repeat: } /*------------------------------------------------------------------------* - * usb2_clear_data_toggle - factored out code + * usbd_clear_data_toggle - factored out code * * NOTE: the intention of this function is not to reset the hardware * data toggle. *------------------------------------------------------------------------*/ void -usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep) +usbd_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep) { DPRINTFN(5, "udev=%p endpoint=%p\n", udev, ep); @@ -2643,7 +2643,7 @@ usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep) } /*------------------------------------------------------------------------* - * usb2_clear_stall_callback - factored out clear stall callback + * usbd_clear_stall_callback - factored out clear stall callback * * Input parameters: * xfer1: Clear Stall Control Transfer @@ -2668,11 +2668,11 @@ usb2_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep) * .usb_mode = USB_MODE_HOST, * }; * - * ** "my_clear_stall_callback" calls "usb2_clear_stall_callback" + * ** "my_clear_stall_callback" calls "usbd_clear_stall_callback" * passing the correct parameters. *------------------------------------------------------------------------*/ uint8_t -usb2_clear_stall_callback(struct usb_xfer *xfer1, +usbd_clear_stall_callback(struct usb_xfer *xfer1, struct usb_xfer *xfer2) { struct usb_device_request req; @@ -2693,7 +2693,7 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1, * "ata-usb.c" depends on this) */ - usb2_clear_data_toggle(xfer2->xroot->udev, xfer2->endpoint); + usbd_clear_data_toggle(xfer2->xroot->udev, xfer2->endpoint); /* setup a clear-stall packet */ @@ -2705,20 +2705,20 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1, USETW(req.wLength, 0); /* - * "usb2_transfer_setup_sub()" will ensure that + * "usbd_transfer_setup_sub()" will ensure that * we have sufficient room in the buffer for * the request structure! */ /* copy in the transfer */ - usb2_copy_in(xfer1->frbuffers, 0, &req, sizeof(req)); + usbd_copy_in(xfer1->frbuffers, 0, &req, sizeof(req)); /* set length */ xfer1->frlengths[0] = sizeof(req); xfer1->nframes = 1; - usb2_start_hardware(xfer1); + usbd_transfer_submit(xfer1); return (0); case USB_ST_TRANSFERRED: @@ -2734,19 +2734,19 @@ usb2_clear_stall_callback(struct usb_xfer *xfer1, } void -usb2_do_poll(struct usb_xfer **ppxfer, uint16_t max) +usbd_do_poll(struct usb_xfer **ppxfer, uint16_t max) { static uint8_t once = 0; /* polling is currently not supported */ if (!once) { once = 1; - printf("usb2_do_poll: USB polling is " + printf("usbd_do_poll: USB polling is " "not supported!\n"); } } static void -usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, +usbd_get_std_packet_size(struct usb_std_packet_size *ptr, uint8_t type, enum usb_dev_speed speed) { static const uint16_t intr_range_max[USB_SPEED_MAX] = { diff --git a/sys/dev/usb/usb_transfer.h b/sys/dev/usb/usb_transfer.h index 68cf393..9b5a33c 100644 --- a/sys/dev/usb/usb_transfer.h +++ b/sys/dev/usb/usb_transfer.h @@ -111,28 +111,28 @@ struct usb_setup_params { /* function prototypes */ -uint8_t usb2_transfer_setup_sub_malloc(struct usb_setup_params *parm, +uint8_t usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm, struct usb_page_cache **ppc, usb_size_t size, usb_size_t align, usb_size_t count); -void usb2_command_wrapper(struct usb_xfer_queue *pq, +void usb_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_done(struct usb_xfer *xfer, usb_error_t error); -void usb2_transfer_enqueue(struct usb_xfer_queue *pq, +void usbd_pipe_enter(struct usb_xfer *xfer); +void usbd_pipe_start(struct usb_xfer_queue *pq); +void usbd_transfer_dequeue(struct usb_xfer *xfer); +void usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error); +void usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer); -void usb2_transfer_setup_sub(struct usb_setup_params *parm); -void usb2_default_transfer_setup(struct usb_device *udev); -void usb2_clear_data_toggle(struct usb_device *udev, +void usbd_transfer_setup_sub(struct usb_setup_params *parm); +void usbd_default_transfer_setup(struct usb_device *udev); +void usbd_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep); -void usb2_do_poll(struct usb_xfer **ppxfer, uint16_t max); -usb_callback_t usb2_do_request_callback; -usb_callback_t usb2_handle_request_callback; -usb_callback_t usb2_do_clear_stall_callback; -void usb2_transfer_timeout_ms(struct usb_xfer *xfer, +void usbd_do_poll(struct usb_xfer **ppxfer, uint16_t max); +usb_callback_t usbd_do_request_callback; +usb_callback_t usb_handle_request_callback; +usb_callback_t usb_do_clear_stall_callback; +void usbd_transfer_timeout_ms(struct usb_xfer *xfer, void (*cb) (void *arg), usb_timeout_t ms); -usb_timeout_t usb2_get_dma_delay(struct usb_bus *bus); -void usb2_transfer_power_ref(struct usb_xfer *xfer, int val); +usb_timeout_t usbd_get_dma_delay(struct usb_bus *bus); +void usbd_transfer_power_ref(struct usb_xfer *xfer, int val); #endif /* _USB2_TRANSFER_H_ */ diff --git a/sys/dev/usb/usb_util.c b/sys/dev/usb/usb_util.c index ab0c987..8b16531 100644 --- a/sys/dev/usb/usb_util.c +++ b/sys/dev/usb/usb_util.c @@ -65,13 +65,13 @@ device_delete_all_children(device_t dev) #endif /*------------------------------------------------------------------------* - * device_set_usb2_desc + * device_set_usb_desc * * This function can be called at probe or attach to set the USB * device supplied textual description for the given device. *------------------------------------------------------------------------*/ void -device_set_usb2_desc(device_t dev) +device_set_usb_desc(device_t dev) { struct usb_attach_arg *uaa; struct usb_device *udev; @@ -103,13 +103,13 @@ device_set_usb2_desc(device_t dev) if (!err) { /* try to get the interface string ! */ - err = usb2_req_get_string_any + err = usbd_req_get_string_any (udev, NULL, temp_p, sizeof(udev->bus->scratch), iface->idesc->iInterface); } if (err) { /* use default description */ - usb2_devinfo(udev, temp_p, + usb_devinfo(udev, temp_p, sizeof(udev->bus->scratch)); } device_set_desc_copy(dev, temp_p); @@ -118,14 +118,14 @@ device_set_usb2_desc(device_t dev) } /*------------------------------------------------------------------------* - * usb2_pause_mtx - factored out code + * usb_pause_mtx - factored out code * * This function will delay the code by the passed number of system * ticks. The passed mutex "mtx" will be dropped while waiting, if * "mtx" is not NULL. *------------------------------------------------------------------------*/ void -usb2_pause_mtx(struct mtx *mtx, int _ticks) +usb_pause_mtx(struct mtx *mtx, int _ticks) { if (mtx != NULL) mtx_unlock(mtx); @@ -154,14 +154,14 @@ usb2_pause_mtx(struct mtx *mtx, int _ticks) } /*------------------------------------------------------------------------* - * usb2_printBCD + * usb_printbcd * * This function will print the version number "bcd" to the string * pointed to by "p" having a maximum length of "p_len" bytes * including the terminating zero. *------------------------------------------------------------------------*/ void -usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd) +usb_printbcd(char *p, uint16_t p_len, uint16_t bcd) { if (snprintf(p, p_len, "%x.%02x", bcd >> 8, bcd & 0xff)) { /* ignore any errors */ @@ -169,13 +169,13 @@ usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd) } /*------------------------------------------------------------------------* - * usb2_trim_spaces + * usb_trim_spaces * * This function removes spaces at the beginning and the end of the string * pointed to by the "p" argument. *------------------------------------------------------------------------*/ void -usb2_trim_spaces(char *p) +usb_trim_spaces(char *p) { char *q; char *e; @@ -192,10 +192,10 @@ usb2_trim_spaces(char *p) } /*------------------------------------------------------------------------* - * usb2_make_str_desc - convert an ASCII string into a UNICODE string + * usb_make_str_desc - convert an ASCII string into a UNICODE string *------------------------------------------------------------------------*/ uint8_t -usb2_make_str_desc(void *ptr, uint16_t max_len, const char *s) +usb_make_str_desc(void *ptr, uint16_t max_len, const char *s) { struct usb_string_descriptor *p = ptr; uint8_t totlen; diff --git a/sys/dev/usb/usb_util.h b/sys/dev/usb/usb_util.h index 4273306..6b8f027 100644 --- a/sys/dev/usb/usb_util.h +++ b/sys/dev/usb/usb_util.h @@ -28,10 +28,10 @@ #define _USB2_UTIL_H_ int device_delete_all_children(device_t dev); -uint8_t usb2_make_str_desc(void *ptr, uint16_t max_len, const char *s); -void device_set_usb2_desc(device_t dev); -void usb2_pause_mtx(struct mtx *mtx, int _ticks); -void usb2_printBCD(char *p, uint16_t p_len, uint16_t bcd); -void usb2_trim_spaces(char *p); +uint8_t usb_make_str_desc(void *ptr, uint16_t max_len, const char *s); +void device_set_usb_desc(device_t dev); +void usb_pause_mtx(struct mtx *mtx, int _ticks); +void usb_printbcd(char *p, uint16_t p_len, uint16_t bcd); +void usb_trim_spaces(char *p); #endif /* _USB2_UTIL_H_ */ diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c index fe86ac7..799abeb 100644 --- a/sys/dev/usb/wlan/if_rum.c +++ b/sys/dev/usb/wlan/if_rum.c @@ -418,7 +418,7 @@ rum_match(device_t self) if (uaa->info.bIfaceIndex != RT2573_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa)); + return (usbd_lookup_id_by_uaa(rum_devs, sizeof(rum_devs), uaa)); } static int @@ -432,7 +432,7 @@ rum_attach(device_t self) uint32_t tmp; int error, ntries; - device_set_usb2_desc(self); + device_set_usb_desc(self); sc->sc_udev = uaa->device; sc->sc_dev = self; @@ -440,11 +440,11 @@ rum_attach(device_t self) MTX_NETWORK_LOCK, MTX_DEF); iface_index = RT2573_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, &iface_index, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, rum_config, RUM_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(self, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); goto detach; } @@ -547,7 +547,7 @@ rum_detach(device_t self) struct ieee80211com *ic; /* stop all USB transfers */ - usb2_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER); /* free TX list, if any */ RUM_LOCK(sc); @@ -572,13 +572,13 @@ rum_do_request(struct rum_softc *sc, int ntries = 10; while (ntries--) { - err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx, + err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, req, data, 0, NULL, 250 /* ms */); if (err == 0) break; DPRINTFN(1, "Control request failed, %s (retrying)\n", - usb2_errstr(err)); + usbd_errstr(err)); if (rum_pause(sc, hz / 100)) break; } @@ -610,7 +610,7 @@ rum_vap_create(struct ieee80211com *ic, rvp->newstate = vap->iv_newstate; vap->iv_newstate = rum_newstate; - usb2_callout_init_mtx(&rvp->amrr_ch, &sc->sc_mtx, 0); + usb_callout_init_mtx(&rvp->amrr_ch, &sc->sc_mtx, 0); TASK_INIT(&rvp->amrr_task, 0, rum_amrr_task, rvp); ieee80211_amrr_init(&rvp->amrr, vap, IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD, @@ -629,7 +629,7 @@ rum_vap_delete(struct ieee80211vap *vap) struct rum_vap *rvp = RUM_VAP(vap); struct ieee80211com *ic = vap->iv_ic; - usb2_callout_drain(&rvp->amrr_ch); + usb_callout_drain(&rvp->amrr_ch); ieee80211_draintask(ic, &rvp->amrr_task); ieee80211_amrr_cleanup(&rvp->amrr); ieee80211_vap_detach(vap); @@ -718,7 +718,7 @@ rum_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) IEEE80211_UNLOCK(ic); RUM_LOCK(sc); - usb2_callout_stop(&rvp->amrr_ch); + usb_callout_stop(&rvp->amrr_ch); switch (nstate) { case IEEE80211_S_INIT: @@ -798,9 +798,9 @@ tr_setup: m->m_pkthdr.len); m->m_pkthdr.len = (MCLBYTES + RT2573_TX_DESC_SIZE); } - usb2_copy_in(xfer->frbuffers, 0, &data->desc, + usbd_copy_in(xfer->frbuffers, 0, &data->desc, RT2573_TX_DESC_SIZE); - usb2_m_copy_in(xfer->frbuffers, RT2573_TX_DESC_SIZE, m, + usbd_m_copy_in(xfer->frbuffers, RT2573_TX_DESC_SIZE, m, 0, m->m_pkthdr.len); vap = data->ni->ni_vap; @@ -825,13 +825,13 @@ tr_setup: xfer->frlengths[0] = len; xfer->priv_fifo = data; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; data = xfer->priv_fifo; @@ -877,7 +877,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer) } len -= RT2573_RX_DESC_SIZE; - usb2_copy_out(xfer->frbuffers, 0, &sc->sc_rx_desc, + usbd_copy_out(xfer->frbuffers, 0, &sc->sc_rx_desc, RT2573_RX_DESC_SIZE); rssi = rum_get_rssi(sc, sc->sc_rx_desc.rssi); @@ -899,7 +899,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, RT2573_RX_DESC_SIZE, + usbd_copy_out(xfer->frbuffers, RT2573_RX_DESC_SIZE, mtod(m, uint8_t *), len); /* finalize mbuf */ @@ -922,7 +922,7 @@ rum_bulk_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * At the end of a USB callback it is always safe to unlock @@ -1068,7 +1068,7 @@ rum_sendprot(struct rum_softc *sc, rum_setup_tx_desc(sc, &data->desc, flags, 0, mprot->m_pkthdr.len, protrate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]); return 0; } @@ -1128,7 +1128,7 @@ rum_tx_mgt(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, tp->mgmtrate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]); return (0); } @@ -1180,7 +1180,7 @@ rum_tx_raw(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni, m0->m_pkthdr.len, rate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]); return 0; } @@ -1262,7 +1262,7 @@ rum_tx_data(struct rum_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, rate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]); return 0; } @@ -1351,7 +1351,7 @@ rum_eeprom_read(struct rum_softc *sc, uint16_t addr, void *buf, int len) error = rum_do_request(sc, &req, buf); if (error != 0) { device_printf(sc->sc_dev, "could not read EEPROM: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1381,7 +1381,7 @@ rum_read_multi(struct rum_softc *sc, uint16_t reg, void *buf, int len) if (error != 0) { device_printf(sc->sc_dev, "could not multi read MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1409,7 +1409,7 @@ rum_write_multi(struct rum_softc *sc, uint16_t reg, void *buf, size_t len) if (error != 0) { device_printf(sc->sc_dev, "could not multi write MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } return (error); } @@ -2011,8 +2011,8 @@ rum_init_locked(struct rum_softc *sc) ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; ifp->if_drv_flags |= IFF_DRV_RUNNING; - usb2_transfer_set_stall(sc->sc_xfer[RUM_BULK_WR]); - usb2_transfer_start(sc->sc_xfer[RUM_BULK_RD]); + usbd_transfer_set_stall(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[RUM_BULK_RD]); return; fail: rum_stop(sc); @@ -2049,8 +2049,8 @@ rum_stop(struct rum_softc *sc) /* * Drain the USB transfers, if not already drained: */ - usb2_transfer_drain(sc->sc_xfer[RUM_BULK_WR]); - usb2_transfer_drain(sc->sc_xfer[RUM_BULK_RD]); + usbd_transfer_drain(sc->sc_xfer[RUM_BULK_WR]); + usbd_transfer_drain(sc->sc_xfer[RUM_BULK_RD]); RUM_LOCK(sc); @@ -2092,7 +2092,7 @@ rum_load_microcode(struct rum_softc *sc, const uint8_t *ucode, size_t size) err = rum_do_request(sc, &req, NULL); if (err != 0) { device_printf(sc->sc_dev, "could not run firmware: %s\n", - usb2_errstr(err)); + usbd_errstr(err)); } /* give the chip some time to boot */ @@ -2189,7 +2189,7 @@ rum_amrr_start(struct rum_softc *sc, struct ieee80211_node *ni) ieee80211_amrr_node_init(&rvp->amrr, &RUM_NODE(ni)->amn, ni); - usb2_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp); + usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp); } static void @@ -2227,7 +2227,7 @@ rum_amrr_task(void *arg, int pending) ifp->if_oerrors += fail; /* count TX retry-fail as Tx errors */ - usb2_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp); + usb_callout_reset(&rvp->amrr_ch, hz, rum_amrr_timeout, rvp); RUM_UNLOCK(sc); } @@ -2339,7 +2339,7 @@ static int rum_pause(struct rum_softc *sc, int timeout) { - usb2_pause_mtx(&sc->sc_mtx, timeout); + usb_pause_mtx(&sc->sc_mtx, timeout); return (0); } diff --git a/sys/dev/usb/wlan/if_uath.c b/sys/dev/usb/wlan/if_uath.c index 1c12a9c..29f2398 100644 --- a/sys/dev/usb/wlan/if_uath.c +++ b/sys/dev/usb/wlan/if_uath.c @@ -338,7 +338,7 @@ uath_match(device_t dev) if (uaa->info.bIfaceIndex != UATH_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(uath_devs, sizeof(uath_devs), uaa)); + return (usbd_lookup_id_by_uaa(uath_devs, sizeof(uath_devs), uaa)); } static int @@ -357,7 +357,7 @@ uath_attach(device_t dev) #ifdef UATH_DEBUG sc->sc_debug = uath_debug; #endif - device_set_usb2_desc(dev); + device_set_usb_desc(dev); /* * Only post-firmware devices here. @@ -378,11 +378,11 @@ uath_attach(device_t dev) goto fail; } - error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, uath_usbconfig, UATH_N_XFERS, sc, &sc->sc_mtx); if (error) { device_printf(dev, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); goto fail1; } @@ -497,7 +497,7 @@ uath_attach(device_t dev) fail4: if_free(ifp); fail3: UATH_UNLOCK(sc); -fail2: usb2_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS); +fail2: usbd_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS); fail1: uath_free_cmd_list(sc, sc->sc_cmd, UATH_CMD_LIST_COUNT); fail: return (error); @@ -519,7 +519,7 @@ uath_detach(device_t dev) callout_drain(&sc->stat_ch); callout_drain(&sc->watchdog_ch); - usb2_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS); + usbd_transfer_unsetup(sc->sc_xfer, UATH_N_XFERS); ieee80211_ifdetach(ic); /* free buffers */ @@ -735,10 +735,10 @@ uath_cmdsend(struct uath_softc *sc, uint32_t code, const void *idata, int ilen, STAILQ_INSERT_TAIL(&sc->sc_cmd_pending, cmd, next); UATH_STAT_INC(sc, st_cmd_pending); - usb2_transfer_start(sc->sc_xfer[UATH_INTR_TX]); + usbd_transfer_start(sc->sc_xfer[UATH_INTR_TX]); if (cmd->flags & UATH_CMD_FLAG_READ) { - usb2_transfer_start(sc->sc_xfer[UATH_INTR_RX]); + usbd_transfer_start(sc->sc_xfer[UATH_INTR_RX]); /* wait at most two seconds for command reply */ error = mtx_sleep(cmd, &sc->sc_mtx, 0, "uathcmd", 2 * hz); @@ -1168,7 +1168,7 @@ uath_init_locked(void *arg) /* XXX? check */ uath_cmd_write(sc, WDCMSG_RESET_KEY_CACHE, NULL, 0, 0); - usb2_transfer_start(sc->sc_xfer[UATH_BULK_RX]); + usbd_transfer_start(sc->sc_xfer[UATH_BULK_RX]); /* enable Rx */ uath_set_rxfilter(sc, 0x0, UATH_FILTER_OP_INIT); uath_set_rxfilter(sc, @@ -1355,7 +1355,7 @@ uath_abort_xfers(struct uath_softc *sc) UATH_ASSERT_LOCKED(sc); /* abort any pending transfers */ for (i = 0; i < UATH_N_XFERS; i++) - usb2_transfer_stop(sc->sc_xfer[i]); + usbd_transfer_stop(sc->sc_xfer[i]); } static int @@ -1425,7 +1425,7 @@ uath_dataflush(struct uath_softc *sc) STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next); UATH_STAT_INC(sc, st_tx_pending); sc->sc_tx_timer = 5; - usb2_transfer_start(sc->sc_xfer[UATH_BULK_TX]); + usbd_transfer_start(sc->sc_xfer[UATH_BULK_TX]); return (0); } @@ -1692,7 +1692,7 @@ uath_tx_start(struct uath_softc *sc, struct mbuf *m0, struct ieee80211_node *ni, STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next); UATH_STAT_INC(sc, st_tx_pending); - usb2_transfer_start(sc->sc_xfer[UATH_BULK_TX]); + usbd_transfer_start(sc->sc_xfer[UATH_BULK_TX]); return (0); } @@ -2401,12 +2401,12 @@ uath_intr_rx_callback(struct usb_xfer *xfer) KASSERT(xfer->actlen >= sizeof(struct uath_cmd_hdr), ("short xfer error")); - usb2_copy_out(xfer->frbuffers, 0, cmd->buf, xfer->actlen); + usbd_copy_out(xfer->frbuffers, 0, cmd->buf, xfer->actlen); uath_cmdeof(sc, cmd); case USB_ST_SETUP: setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: if (xfer->error != USB_ERR_CANCELLED) { @@ -2456,9 +2456,9 @@ setup: else UATH_STAT_INC(sc, st_cmd_active); - usb2_set_frame_data(xfer, cmd->buf, 0); + usbd_set_frame_data(xfer, cmd->buf, 0); xfer->frlengths[0] = cmd->buflen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: if (xfer->error != USB_ERR_CANCELLED) { @@ -2708,9 +2708,9 @@ setup: UATH_STAT_DEC(sc, st_rx_inactive); STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next); UATH_STAT_INC(sc, st_rx_active); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * To avoid LOR we should unlock our private mutex here to call @@ -2818,9 +2818,9 @@ setup: STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next); UATH_STAT_INC(sc, st_tx_active); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = data->buflen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); UATH_UNLOCK(sc); uath_start(ifp); diff --git a/sys/dev/usb/wlan/if_upgt.c b/sys/dev/usb/wlan/if_upgt.c index c1e5b12..b7e697c 100644 --- a/sys/dev/usb/wlan/if_upgt.c +++ b/sys/dev/usb/wlan/if_upgt.c @@ -239,7 +239,7 @@ upgt_match(device_t dev) if (uaa->info.bIfaceIndex != UPGT_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(upgt_devs_2, sizeof(upgt_devs_2), uaa)); + return (usbd_lookup_id_by_uaa(upgt_devs_2, sizeof(upgt_devs_2), uaa)); } static int @@ -257,7 +257,7 @@ upgt_attach(device_t dev) #ifdef UPGT_DEBUG sc->sc_debug = upgt_debug; #endif - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), MTX_NETWORK_LOCK, MTX_DEF); @@ -272,11 +272,11 @@ upgt_attach(device_t dev) if (error) goto fail2; - error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, upgt_config, UPGT_N_XFERS, sc, &sc->sc_mtx); if (error) { device_printf(dev, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); goto fail3; } @@ -382,7 +382,7 @@ upgt_attach(device_t dev) return (0); fail5: if_free(ifp); -fail4: usb2_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS); +fail4: usbd_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS); fail3: upgt_free_rx(sc); fail2: upgt_free_tx(sc); fail1: mtx_destroy(&sc->sc_mtx); @@ -641,7 +641,7 @@ upgt_init_locked(struct upgt_softc *sc) if (ifp->if_drv_flags & IFF_DRV_RUNNING) upgt_stop_locked(sc); - usb2_transfer_start(sc->sc_xfer[UPGT_BULK_RX]); + usbd_transfer_start(sc->sc_xfer[UPGT_BULK_RX]); (void)upgt_set_macfilter(sc, IEEE80211_S_SCAN); @@ -1319,7 +1319,7 @@ upgt_eeprom_read(struct upgt_softc *sc) int block, error, offset; UPGT_LOCK(sc); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); offset = 0; block = UPGT_EEPROM_BLOCK_SIZE; @@ -1679,7 +1679,7 @@ upgt_fw_load(struct upgt_softc *sc) upgt_bulk_tx(sc, data_cmd); /* waiting 'OK' response. */ - usb2_transfer_start(sc->sc_xfer[UPGT_BULK_RX]); + usbd_transfer_start(sc->sc_xfer[UPGT_BULK_RX]); error = mtx_sleep(sc, &sc->sc_mtx, 0, "upgtfw", 2 * hz); if (error != 0) { device_printf(sc->sc_dev, "firmware load failed!\n"); @@ -1911,7 +1911,7 @@ upgt_bulk_tx(struct upgt_softc *sc, struct upgt_data *data) STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next); UPGT_STAT_INC(sc, st_tx_pending); - usb2_transfer_start(sc->sc_xfer[UPGT_BULK_TX]); + usbd_transfer_start(sc->sc_xfer[UPGT_BULK_TX]); } static int @@ -1930,7 +1930,7 @@ upgt_device_reset(struct upgt_softc *sc) bcopy(init_cmd, data->buf, sizeof(init_cmd)); data->buflen = sizeof(init_cmd); upgt_bulk_tx(sc, data); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); UPGT_UNLOCK(sc); DPRINTF(sc, UPGT_DEBUG_FW, "%s: device initialized\n", __func__); @@ -2000,7 +2000,7 @@ upgt_detach(device_t dev) callout_drain(&sc->sc_led_ch); callout_drain(&sc->sc_watchdog_ch); - usb2_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS); + usbd_transfer_unsetup(sc->sc_xfer, UPGT_N_XFERS); ieee80211_ifdetach(ic); upgt_free_rx(sc); upgt_free_tx(sc); @@ -2045,7 +2045,7 @@ upgt_abort_xfers_locked(struct upgt_softc *sc) UPGT_ASSERT_LOCKED(sc); /* abort any pending transfers */ for (i = 0; i < UPGT_N_XFERS; i++) - usb2_transfer_stop(sc->sc_xfer[i]); + usbd_transfer_stop(sc->sc_xfer[i]); } static void @@ -2274,9 +2274,9 @@ setup: return; STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next); STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * To avoid LOR we should unlock our private mutex here to call @@ -2347,9 +2347,9 @@ setup: STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next); UPGT_STAT_INC(sc, st_tx_active); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = data->buflen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); UPGT_UNLOCK(sc); upgt_start(ifp); UPGT_LOCK(sc); diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c index 83e279ce..f450e31 100644 --- a/sys/dev/usb/wlan/if_ural.c +++ b/sys/dev/usb/wlan/if_ural.c @@ -421,7 +421,7 @@ ural_match(device_t self) if (uaa->info.bIfaceIndex != RAL_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa)); + return (usbd_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa)); } static int @@ -434,7 +434,7 @@ ural_attach(device_t self) uint8_t iface_index, bands; int error; - device_set_usb2_desc(self); + device_set_usb_desc(self); sc->sc_udev = uaa->device; sc->sc_dev = self; @@ -442,12 +442,12 @@ ural_attach(device_t self) MTX_NETWORK_LOCK, MTX_DEF); iface_index = RAL_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, ural_config, URAL_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(self, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); goto detach; } @@ -538,7 +538,7 @@ ural_detach(device_t self) struct ieee80211com *ic; /* stop all USB transfers */ - usb2_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER); /* free TX list, if any */ RAL_LOCK(sc); @@ -563,13 +563,13 @@ ural_do_request(struct ural_softc *sc, int ntries = 10; while (ntries--) { - err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx, + err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, req, data, 0, NULL, 250 /* ms */); if (err == 0) break; DPRINTFN(1, "Control request failed, %s (retrying)\n", - usb2_errstr(err)); + usbd_errstr(err)); if (ural_pause(sc, hz / 100)) break; } @@ -601,7 +601,7 @@ ural_vap_create(struct ieee80211com *ic, uvp->newstate = vap->iv_newstate; vap->iv_newstate = ural_newstate; - usb2_callout_init_mtx(&uvp->amrr_ch, &sc->sc_mtx, 0); + usb_callout_init_mtx(&uvp->amrr_ch, &sc->sc_mtx, 0); TASK_INIT(&uvp->amrr_task, 0, ural_amrr_task, uvp); ieee80211_amrr_init(&uvp->amrr, vap, IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD, @@ -620,7 +620,7 @@ ural_vap_delete(struct ieee80211vap *vap) struct ural_vap *uvp = URAL_VAP(vap); struct ieee80211com *ic = vap->iv_ic; - usb2_callout_drain(&uvp->amrr_ch); + usb_callout_drain(&uvp->amrr_ch); ieee80211_draintask(ic, &uvp->amrr_task); ieee80211_amrr_cleanup(&uvp->amrr); ieee80211_vap_detach(vap); @@ -707,7 +707,7 @@ ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) IEEE80211_UNLOCK(ic); RAL_LOCK(sc); - usb2_callout_stop(&uvp->amrr_ch); + usb_callout_stop(&uvp->amrr_ch); switch (nstate) { case IEEE80211_S_INIT: @@ -811,9 +811,9 @@ tr_setup: m->m_pkthdr.len); m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE); } - usb2_copy_in(xfer->frbuffers, 0, &data->desc, + usbd_copy_in(xfer->frbuffers, 0, &data->desc, RAL_TX_DESC_SIZE); - usb2_m_copy_in(xfer->frbuffers, RAL_TX_DESC_SIZE, m, 0, + usbd_m_copy_in(xfer->frbuffers, RAL_TX_DESC_SIZE, m, 0, m->m_pkthdr.len); vap = data->ni->ni_vap; @@ -838,13 +838,13 @@ tr_setup: xfer->frlengths[0] = len; xfer->priv_fifo = data; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ DPRINTFN(11, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; data = xfer->priv_fifo; @@ -891,7 +891,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer) len -= RAL_RX_DESC_SIZE; /* rx descriptor is located at the end */ - usb2_copy_out(xfer->frbuffers, len, &sc->sc_rx_desc, + usbd_copy_out(xfer->frbuffers, len, &sc->sc_rx_desc, RAL_RX_DESC_SIZE); rssi = URAL_RSSI(sc->sc_rx_desc.rssi); @@ -914,7 +914,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer) ifp->if_ierrors++; goto tr_setup; } - usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *), len); + usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *), len); /* finalize mbuf */ m->m_pkthdr.rcvif = ifp; @@ -939,7 +939,7 @@ ural_bulk_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * At the end of a USB callback it is always safe to unlock @@ -1071,7 +1071,7 @@ ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) m0->m_pkthdr.len, tp->mgmtrate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]); return (0); } @@ -1132,7 +1132,7 @@ ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) m0->m_pkthdr.len, tp->mgmtrate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]); return 0; } @@ -1183,7 +1183,7 @@ ural_sendprot(struct ural_softc *sc, ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]); return 0; } @@ -1236,7 +1236,7 @@ ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni, m0->m_pkthdr.len, rate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]); return 0; } @@ -1316,7 +1316,7 @@ ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) m0->m_pkthdr.len, rate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]); return 0; } @@ -1403,7 +1403,7 @@ ural_set_testmode(struct ural_softc *sc) error = ural_do_request(sc, &req, NULL); if (error != 0) { device_printf(sc->sc_dev, "could not set test mode: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1422,7 +1422,7 @@ ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len) error = ural_do_request(sc, &req, buf); if (error != 0) { device_printf(sc->sc_dev, "could not read EEPROM: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1442,7 +1442,7 @@ ural_read(struct ural_softc *sc, uint16_t reg) error = ural_do_request(sc, &req, &val); if (error != 0) { device_printf(sc->sc_dev, "could not read MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); return 0; } @@ -1464,7 +1464,7 @@ ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len) error = ural_do_request(sc, &req, buf); if (error != 0) { device_printf(sc->sc_dev, "could not read MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1483,7 +1483,7 @@ ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val) error = ural_do_request(sc, &req, NULL); if (error != 0) { device_printf(sc->sc_dev, "could not write MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -1502,7 +1502,7 @@ ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len) error = ural_do_request(sc, &req, buf); if (error != 0) { device_printf(sc->sc_dev, "could not write MAC register: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } } @@ -2120,8 +2120,8 @@ ural_init_locked(struct ural_softc *sc) ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; ifp->if_drv_flags |= IFF_DRV_RUNNING; - usb2_transfer_set_stall(sc->sc_xfer[URAL_BULK_WR]); - usb2_transfer_start(sc->sc_xfer[URAL_BULK_RD]); + usbd_transfer_set_stall(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]); return; fail: ural_stop(sc); @@ -2156,8 +2156,8 @@ ural_stop(struct ural_softc *sc) * Drain all the transfers, if not already drained: */ RAL_UNLOCK(sc); - usb2_transfer_drain(sc->sc_xfer[URAL_BULK_WR]); - usb2_transfer_drain(sc->sc_xfer[URAL_BULK_RD]); + usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]); + usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]); RAL_LOCK(sc); ural_unsetup_tx_list(sc); @@ -2234,7 +2234,7 @@ ural_amrr_start(struct ural_softc *sc, struct ieee80211_node *ni) ieee80211_amrr_node_init(&uvp->amrr, &URAL_NODE(ni)->amn, ni); - usb2_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp); + usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp); } static void @@ -2272,7 +2272,7 @@ ural_amrr_task(void *arg, int pending) ifp->if_oerrors += fail; /* count TX retry-fail as Tx errors */ - usb2_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp); + usb_callout_reset(&uvp->amrr_ch, hz, ural_amrr_timeout, uvp); RAL_UNLOCK(sc); } @@ -2280,6 +2280,6 @@ static int ural_pause(struct ural_softc *sc, int timeout) { - usb2_pause_mtx(&sc->sc_mtx, timeout); + usb_pause_mtx(&sc->sc_mtx, timeout); return (0); } diff --git a/sys/dev/usb/wlan/if_urtw.c b/sys/dev/usb/wlan/if_urtw.c index 883c1d9..30b14d3 100644 --- a/sys/dev/usb/wlan/if_urtw.c +++ b/sys/dev/usb/wlan/if_urtw.c @@ -730,7 +730,7 @@ urtw_match(device_t dev) if (uaa->info.bIfaceIndex != URTW_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(urtw_devs, sizeof(urtw_devs), uaa)); + return (usbd_lookup_id_by_uaa(urtw_devs, sizeof(urtw_devs), uaa)); } static int @@ -747,7 +747,7 @@ urtw_attach(device_t dev) uint32_t data; usb_error_t error; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_dev = dev; sc->sc_udev = uaa->device; @@ -759,7 +759,7 @@ urtw_attach(device_t dev) mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), MTX_NETWORK_LOCK, MTX_DEF); - usb2_callout_init_mtx(&sc->sc_led_ch, &sc->sc_mtx, 0); + usb_callout_init_mtx(&sc->sc_led_ch, &sc->sc_mtx, 0); TASK_INIT(&sc->sc_led_task, 0, urtw_ledtask, sc); callout_init(&sc->sc_watchdog_ch, 0); @@ -771,11 +771,11 @@ urtw_attach(device_t dev) n_setup = URTW_8187L_N_XFERS; } - error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, setup_start, n_setup, sc, &sc->sc_mtx); if (error) { device_printf(dev, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); ret = ENXIO; goto fail0; } @@ -865,7 +865,7 @@ urtw_attach(device_t dev) return (0); fail: URTW_UNLOCK(sc); -fail1: usb2_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ? +fail1: usbd_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ? URTW_8187B_N_XFERS : URTW_8187L_N_XFERS); fail0: return (ret); @@ -884,10 +884,10 @@ urtw_detach(device_t dev) urtw_stop(ifp, 1); ieee80211_draintask(ic, &sc->sc_led_task); - usb2_callout_drain(&sc->sc_led_ch); + usb_callout_drain(&sc->sc_led_ch); callout_drain(&sc->sc_watchdog_ch); - usb2_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ? + usbd_transfer_unsetup(sc->sc_xfer, (sc->sc_flags & URTW_RTL8187B) ? URTW_8187B_N_XFERS : URTW_8187L_N_XFERS); ieee80211_ifdetach(ic); @@ -1141,7 +1141,7 @@ urtw_adapter_start_b(struct urtw_softc *sc) urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, 0x0480); urtw_write16_m(sc, URTW_RF_PINS_SELECT, 0x2488); urtw_write16_m(sc, URTW_RF_PINS_ENABLE, 0x1fff); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); error = sc->sc_rf_init(sc); if (error != 0) @@ -1305,7 +1305,7 @@ urtw_8187b_cmd_reset(struct urtw_softc *sc) urtw_write8_m(sc, URTW_CMD, data8); for (i = 0; i < 20; i++) { - usb2_pause_mtx(&sc->sc_mtx, 2); + usb_pause_mtx(&sc->sc_mtx, 2); urtw_read8_m(sc, URTW_CMD, &data8); if (!(data8 & URTW_CMD_RST)) break; @@ -1320,7 +1320,7 @@ urtw_8187b_cmd_reset(struct urtw_softc *sc) goto fail; for (i = 0; i < 20; i++) { - usb2_pause_mtx(&sc->sc_mtx, 4); + usb_pause_mtx(&sc->sc_mtx, 4); urtw_read8_m(sc, URTW_EPROM_CMD, &data8); if (!(data8 & URTW_EPROM_CMD_CONFIG)) break; @@ -1358,15 +1358,15 @@ urtw_do_request(struct urtw_softc *sc, URTW_ASSERT_LOCKED(sc); while (ntries--) { - err = usb2_do_request_flags(sc->sc_udev, &sc->sc_mtx, + err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, req, data, 0, NULL, 250 /* ms */); if (err == 0) break; DPRINTF(sc, URTW_DEBUG_INIT, "Control request failed, %s (retrying)\n", - usb2_errstr(err)); - usb2_pause_mtx(&sc->sc_mtx, hz / 100); + usbd_errstr(err)); + usb_pause_mtx(&sc->sc_mtx, hz / 100); } return (err); } @@ -1431,9 +1431,9 @@ urtw_stop_locked(struct ifnet *ifp, int disable) fail: if (error) device_printf(sc->sc_dev, "failed to stop (%s)\n", - usb2_errstr(error)); + usbd_errstr(error)); - usb2_callout_stop(&sc->sc_led_ch); + usb_callout_stop(&sc->sc_led_ch); callout_stop(&sc->sc_watchdog_ch); urtw_abort_xfers(sc); @@ -1461,7 +1461,7 @@ urtw_abort_xfers(struct urtw_softc *sc) /* abort any pending transfers */ for (i = 0; i < max; i++) - usb2_transfer_stop(sc->sc_xfer[i]); + usbd_transfer_stop(sc->sc_xfer[i]); } static int @@ -1709,7 +1709,7 @@ urtw_set_channel(struct ieee80211com *ic) error = sc->sc_rf_set_chan(sc, ieee80211_chan2ieee(ic, ic->ic_curchan)); if (error != 0) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 10); + usb_pause_mtx(&sc->sc_mtx, 10); urtw_write32_m(sc, URTW_TX_CONF, orig); urtw_write16_m(sc, URTW_ATIM_WND, 2); @@ -1862,7 +1862,7 @@ urtw_tx_start(struct urtw_softc *sc, struct ieee80211_node *ni, struct mbuf *m0, sc->sc_xfer[URTW_8187L_BULK_TX_NORMAL]; STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next); - usb2_transfer_start(xfer); + usbd_transfer_start(xfer); error = urtw_led_ctl(sc, URTW_LED_CTL_TX); if (error != 0) @@ -1888,7 +1888,7 @@ urtw_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) IEEE80211_UNLOCK(ic); URTW_LOCK(sc); - usb2_callout_stop(&sc->sc_led_ch); + usb_callout_stop(&sc->sc_led_ch); callout_stop(&sc->sc_watchdog_ch); switch (nstate) { @@ -2528,20 +2528,20 @@ urtw_8225_rf_init(struct urtw_softc *sc) error = urtw_8185_rf_pins_enable(sc); if (error) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 1000); + usb_pause_mtx(&sc->sc_mtx, 1000); for (i = 0; i < N(urtw_8225_rf_part1); i++) { urtw_8225_write(sc, urtw_8225_rf_part1[i].reg, urtw_8225_rf_part1[i].val); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); } - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1); - usb2_pause_mtx(&sc->sc_mtx, 200); + usb_pause_mtx(&sc->sc_mtx, 200); urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2); - usb2_pause_mtx(&sc->sc_mtx, 200); + usb_pause_mtx(&sc->sc_mtx, 200); urtw_8225_write(sc, URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC3); @@ -2557,15 +2557,15 @@ urtw_8225_rf_init(struct urtw_softc *sc) for (i = 0; i < 128; i++) { urtw_8187_write_phy_ofdm(sc, 0xb, urtw_8225_agc[i]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); urtw_8187_write_phy_ofdm(sc, 0xa, (uint8_t)i + 0x80); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); } for (i = 0; i < N(urtw_8225_rf_part2); i++) { urtw_8187_write_phy_ofdm(sc, urtw_8225_rf_part2[i].reg, urtw_8225_rf_part2[i].val); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); } error = urtw_8225_setgain(sc, 4); @@ -2575,7 +2575,7 @@ urtw_8225_rf_init(struct urtw_softc *sc) for (i = 0; i < N(urtw_8225_rf_part3); i++) { urtw_8187_write_phy_cck(sc, urtw_8225_rf_part3[i].reg, urtw_8225_rf_part3[i].val); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); } urtw_write8_m(sc, URTW_TESTR, 0x0d); @@ -2585,9 +2585,9 @@ urtw_8225_rf_init(struct urtw_softc *sc) goto fail; urtw_8187_write_phy_cck(sc, 0x10, 0x9b); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); urtw_8187_write_phy_ofdm(sc, 0x26, 0x90); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); /* TX ant A, 0x0 for B */ error = urtw_8185_tx_antenna(sc, 0x3); @@ -2617,7 +2617,7 @@ urtw_8185_tx_antenna(struct urtw_softc *sc, uint8_t ant) usb_error_t error; urtw_write8_m(sc, URTW_TX_ANTENNA, ant); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -2649,7 +2649,7 @@ urtw_8187_write_phy(struct urtw_softc *sc, uint8_t addr, uint32_t data) urtw_write8_m(sc, URTW_PHY_MAGIC3, ((phyw & 0x00ff0000) >> 16)); urtw_write8_m(sc, URTW_PHY_MAGIC2, ((phyw & 0x0000ff00) >> 8)); urtw_write8_m(sc, URTW_PHY_MAGIC1, ((phyw & 0x000000ff))); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -2689,7 +2689,7 @@ urtw_8225_usb_init(struct urtw_softc *sc) urtw_write16_m(sc, URTW_RF_PINS_SELECT, 0x80); urtw_write16_m(sc, URTW_RF_PINS_ENABLE, 0x80); - usb2_pause_mtx(&sc->sc_mtx, 500); + usb_pause_mtx(&sc->sc_mtx, 500); fail: return (error); } @@ -2722,7 +2722,7 @@ urtw_8225_write_c(struct urtw_softc *sc, uint8_t addr, uint16_t data) DELAY(10); urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, d80 | URTW_BB_HOST_BANG_EN); urtw_write16_m(sc, URTW_RF_PINS_SELECT, d84); - usb2_pause_mtx(&sc->sc_mtx, 2); + usb_pause_mtx(&sc->sc_mtx, 2); fail: return (error); } @@ -2776,7 +2776,7 @@ urtw_8225_rf_set_chan(struct urtw_softc *sc, int chan) if (error) goto fail; urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]); - usb2_pause_mtx(&sc->sc_mtx, 10); + usb_pause_mtx(&sc->sc_mtx, 10); urtw_write8_m(sc, URTW_SIFS, 0x22); @@ -2855,7 +2855,7 @@ urtw_8225_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_8187_write_phy_cck(sc, 0x44 + i, cck_pwltable[idx * 8 + i]); } - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); /* OFDM power setting */ ofdm_pwrlvl = (ofdm_pwrlvl > (ofdm_pwrlvl_max - ofdm_pwrlvl_min)) ? @@ -2876,7 +2876,7 @@ urtw_8225_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_8225_tx_gain_cck_ofdm[set] >> 1); urtw_8187_write_phy_ofdm(sc, 0x5, urtw_8225_txpwr_ofdm[idx]); urtw_8187_write_phy_ofdm(sc, 0x7, urtw_8225_txpwr_ofdm[idx]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -2950,13 +2950,13 @@ urtw_8225v2_rf_init(struct urtw_softc *sc) if (error) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 500); + usb_pause_mtx(&sc->sc_mtx, 500); for (i = 0; i < N(urtw_8225v2_rf_part1); i++) { urtw_8225_write(sc, urtw_8225v2_rf_part1[i].reg, urtw_8225v2_rf_part1[i].val); } - usb2_pause_mtx(&sc->sc_mtx, 50); + usb_pause_mtx(&sc->sc_mtx, 50); urtw_8225_write(sc, URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC1); @@ -2975,10 +2975,10 @@ urtw_8225v2_rf_init(struct urtw_softc *sc) URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC2); urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); error = urtw_8225_read(sc, URTW_8225_ADDR_6_MAGIC, &data32); if (error != 0) @@ -2988,17 +2988,17 @@ urtw_8225v2_rf_init(struct urtw_softc *sc) if (!(data32 & URTW_8225_ADDR_6_DATA_MAGIC2)) { urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC1); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_8225_write(sc, URTW_8225_ADDR_2_MAGIC, URTW_8225_ADDR_2_DATA_MAGIC2); - usb2_pause_mtx(&sc->sc_mtx, 50); + usb_pause_mtx(&sc->sc_mtx, 50); error = urtw_8225_read(sc, URTW_8225_ADDR_6_MAGIC, &data32); if (error != 0) goto fail; if (!(data32 & URTW_8225_ADDR_6_DATA_MAGIC2)) device_printf(sc->sc_dev, "RF calibration failed\n"); } - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_8225_write(sc, URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC6); @@ -3054,7 +3054,7 @@ urtw_8225v2_rf_set_chan(struct urtw_softc *sc, int chan) goto fail; urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]); - usb2_pause_mtx(&sc->sc_mtx, 10); + usb_pause_mtx(&sc->sc_mtx, 10); urtw_write8_m(sc, URTW_SIFS, 0x22); @@ -3193,7 +3193,7 @@ urtw_8225v2_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_write8_m(sc, URTW_TX_GAIN_CCK, urtw_8225v2_tx_gain_cck_ofdm[cck_pwrlvl]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); /* OFDM power setting */ ofdm_pwrlvl = (ofdm_pwrlvl > (ofdm_pwrlvl_max - ofdm_pwrlvl_min)) ? @@ -3213,7 +3213,7 @@ urtw_8225v2_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_write8_m(sc, URTW_TX_GAIN_OFDM, urtw_8225v2_tx_gain_cck_ofdm[ofdm_pwrlvl]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -3227,13 +3227,13 @@ urtw_8225v2_setgain(struct urtw_softc *sc, int16_t gain) /* XXX for A? */ gainp = urtw_8225v2_gain_bg; urtw_8187_write_phy_ofdm(sc, 0x0d, gainp[gain * 3]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); urtw_8187_write_phy_ofdm(sc, 0x1b, gainp[gain * 3 + 1]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); urtw_8187_write_phy_ofdm(sc, 0x1d, gainp[gain * 3 + 2]); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); urtw_8187_write_phy_ofdm(sc, 0x21, 0x17); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -3249,7 +3249,7 @@ urtw_8225_isv2(struct urtw_softc *sc, int *ret) urtw_write16_m(sc, URTW_RF_PINS_OUTPUT, URTW_RF_PINS_MAGIC5); urtw_write16_m(sc, URTW_RF_PINS_SELECT, URTW_RF_PINS_MAGIC5); urtw_write16_m(sc, URTW_RF_PINS_ENABLE, URTW_RF_PINS_MAGIC5); - usb2_pause_mtx(&sc->sc_mtx, 500); + usb_pause_mtx(&sc->sc_mtx, 500); urtw_8225_write(sc, URTW_8225_ADDR_0_MAGIC, URTW_8225_ADDR_0_DATA_MAGIC1); @@ -3342,7 +3342,7 @@ urtw_8225v2b_rf_set_chan(struct urtw_softc *sc, int chan) goto fail; urtw_8225_write(sc, URTW_8225_ADDR_7_MAGIC, urtw_8225_channel[chan]); - usb2_pause_mtx(&sc->sc_mtx, 10); + usb_pause_mtx(&sc->sc_mtx, 10); urtw_write8_m(sc, URTW_SIFS, 0xa); if (ic->ic_flags & IEEE80211_F_SHSLOT) { @@ -3405,7 +3405,7 @@ urtw_8225v2b_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_write8_m(sc, URTW_TX_GAIN_CCK, urtw_8225v2_tx_gain_cck_ofdm[cck_pwrlvl] << 1); - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); /* OFDM power setting */ ofdm_pwrlvl = (ofdm_pwrlvl > 15) ? @@ -3437,7 +3437,7 @@ urtw_8225v2b_set_txpwrlvl(struct urtw_softc *sc, int chan) urtw_8187_write_phy_ofdm(sc, 0x89, 0x50); } } - usb2_pause_mtx(&sc->sc_mtx, 1); + usb_pause_mtx(&sc->sc_mtx, 1); fail: return (error); } @@ -3554,7 +3554,7 @@ urtw_reset(struct urtw_softc *sc) error = urtw_intr_disable(sc); if (error) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); error = urtw_write8e(sc, 0x18, 0x10); if (error != 0) @@ -3565,12 +3565,12 @@ urtw_reset(struct urtw_softc *sc) error = urtw_write8e(sc, 0x18, 0x00); if (error != 0) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_read8_m(sc, URTW_CMD, &data); data = (data & 0x2) | URTW_CMD_RST; urtw_write8_m(sc, URTW_CMD, data); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_read8_m(sc, URTW_CMD, &data); if (data & URTW_CMD_RST) { @@ -3581,7 +3581,7 @@ urtw_reset(struct urtw_softc *sc) error = urtw_set_mode(sc, URTW_EPROM_CMD_LOAD); if (error) goto fail; - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); error = urtw_8180_set_anaparam(sc, URTW_8225_ANAPARAM_ON); if (error) @@ -3654,11 +3654,11 @@ urtw_led_mode0(struct urtw_softc *sc, int mode) sc->sc_gpio_ledinprogress = 1; sc->sc_gpio_blinkstate = (sc->sc_gpio_ledon != 0) ? URTW_LED_OFF : URTW_LED_ON; - usb2_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc); + usb_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc); break; case URTW_LED_POWER_ON_BLINK: urtw_led_on(sc, URTW_LED_GPIO); - usb2_pause_mtx(&sc->sc_mtx, 100); + usb_pause_mtx(&sc->sc_mtx, 100); urtw_led_off(sc, URTW_LED_GPIO); break; default: @@ -3803,7 +3803,7 @@ urtw_led_blink(struct urtw_softc *sc) switch (sc->sc_gpio_ledstate) { case URTW_LED_BLINK_NORMAL: - usb2_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc); + usb_callout_reset(&sc->sc_led_ch, hz, urtw_led_ch, sc); break; default: panic("unknown LED status 0x%x", sc->sc_gpio_ledstate); @@ -3818,7 +3818,7 @@ urtw_rx_enable(struct urtw_softc *sc) uint8_t data; usb_error_t error; - usb2_transfer_start((sc->sc_flags & URTW_RTL8187B) ? + usbd_transfer_start((sc->sc_flags & URTW_RTL8187B) ? sc->sc_xfer[URTW_8187B_BULK_RX] : sc->sc_xfer[URTW_8187L_BULK_RX]); error = urtw_rx_setconf(sc); @@ -4055,9 +4055,9 @@ setup: } STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next); STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * To avoid LOR we should unlock our private mutex here to call @@ -4155,9 +4155,9 @@ setup: STAILQ_REMOVE_HEAD(&sc->sc_tx_pending, next); STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next); - usb2_set_frame_data(xfer, data->buf, 0); + usbd_set_frame_data(xfer, data->buf, 0); xfer->frlengths[0] = data->buflen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); URTW_UNLOCK(sc); urtw_start(ifp); diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c index a0079eb7..8627d81 100644 --- a/sys/dev/usb/wlan/if_zyd.c +++ b/sys/dev/usb/wlan/if_zyd.c @@ -110,7 +110,7 @@ enum { #endif #define zyd_do_request(sc,req,data) \ - usb2_do_request_flags((sc)->sc_udev, &(sc)->sc_mtx, req, data, 0, NULL, 5000) + usbd_do_request_flags((sc)->sc_udev, &(sc)->sc_mtx, req, data, 0, NULL, 5000) static device_probe_t zyd_match; static device_attach_t zyd_attach; @@ -330,7 +330,7 @@ zyd_match(device_t dev) if (uaa->info.bIfaceIndex != ZYD_IFACE_INDEX) return (ENXIO); - return (usb2_lookup_id_by_uaa(zyd_devs, sizeof(zyd_devs), uaa)); + return (usbd_lookup_id_by_uaa(zyd_devs, sizeof(zyd_devs), uaa)); } static int @@ -350,7 +350,7 @@ zyd_attach(device_t dev) return (EINVAL); } - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_dev = dev; sc->sc_udev = uaa->device; sc->sc_macrev = USB_GET_DRIVER_INFO(uaa); @@ -360,12 +360,12 @@ zyd_attach(device_t dev) STAILQ_INIT(&sc->sc_rqh); iface_index = ZYD_IFACE_INDEX; - error = usb2_transfer_setup(uaa->device, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, zyd_config, ZYD_N_TRANSFER, sc, &sc->sc_mtx); if (error) { device_printf(dev, "could not allocate USB transfers, " - "err=%s\n", usb2_errstr(error)); + "err=%s\n", usbd_errstr(error)); goto detach; } @@ -448,7 +448,7 @@ zyd_detach(device_t dev) struct ieee80211com *ic; /* stop all USB transfers */ - usb2_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER); /* free TX list, if any */ zyd_unsetup_tx_list(sc); @@ -644,7 +644,7 @@ zyd_intr_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_copy_out(xfer->frbuffers, 0, cmd, sizeof(*cmd)); + usbd_copy_out(xfer->frbuffers, 0, cmd, sizeof(*cmd)); switch (le16toh(cmd->code)) { case ZYD_NOTIF_RETRYSTATUS: @@ -720,12 +720,12 @@ zyd_intr_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ DPRINTF(sc, ZYD_DEBUG_CMD, "error = %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -760,19 +760,19 @@ tr_setup: if (rqp->flags & ZYD_CMD_FLAG_SENT) continue; - usb2_copy_in(xfer->frbuffers, 0, rqp->cmd, rqp->ilen); + usbd_copy_in(xfer->frbuffers, 0, rqp->cmd, rqp->ilen); xfer->frlengths[0] = rqp->ilen; xfer->priv_fifo = rqp; rqp->flags |= ZYD_CMD_FLAG_SENT; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; } break; default: /* Error */ DPRINTF(sc, ZYD_DEBUG_ANY, "error = %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -806,8 +806,8 @@ zyd_cmd(struct zyd_softc *sc, uint16_t code, const void *idata, int ilen, rq.olen = olen; rq.flags = flags; STAILQ_INSERT_TAIL(&sc->sc_rqh, &rq, rq); - usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); - usb2_transfer_start(sc->sc_xfer[ZYD_INTR_WR]); + usbd_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); + usbd_transfer_start(sc->sc_xfer[ZYD_INTR_WR]); /* wait at most one second for command reply */ error = mtx_sleep(&rq, &sc->sc_mtx, 0 , "zydcmd", hz); @@ -1922,7 +1922,7 @@ zyd_get_macaddr(struct zyd_softc *sc) error = zyd_do_request(sc, &req, sc->sc_bssid); if (error != 0) { device_printf(sc->sc_dev, "could not read EEPROM: %s\n", - usb2_errstr(error)); + usbd_errstr(error)); } return (error); @@ -2179,8 +2179,8 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) ifp->if_ierrors++; return; } - usb2_copy_out(xfer->frbuffers, offset, &plcp, sizeof(plcp)); - usb2_copy_out(xfer->frbuffers, offset + len - sizeof(stat), + usbd_copy_out(xfer->frbuffers, offset, &plcp, sizeof(plcp)); + usbd_copy_out(xfer->frbuffers, offset + len - sizeof(stat), &stat, sizeof(stat)); if (stat.flags & ZYD_RX_ERROR) { @@ -2213,7 +2213,7 @@ zyd_rx_data(struct usb_xfer *xfer, int offset, uint16_t len) } m->m_pkthdr.rcvif = ifp; m->m_pkthdr.len = m->m_len = rlen; - usb2_copy_out(xfer->frbuffers, offset + sizeof(plcp), + usbd_copy_out(xfer->frbuffers, offset + sizeof(plcp), mtod(m, uint8_t *), rlen); if (ieee80211_radiotap_active(ic)) { @@ -2255,7 +2255,7 @@ zyd_bulk_read_callback(struct usb_xfer *xfer) sc->sc_rx_count = 0; switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_copy_out(xfer->frbuffers, xfer->actlen - sizeof(desc), + usbd_copy_out(xfer->frbuffers, xfer->actlen - sizeof(desc), &desc, sizeof(desc)); offset = 0; @@ -2288,7 +2288,7 @@ zyd_bulk_read_callback(struct usb_xfer *xfer) case USB_ST_SETUP: tr_setup: xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); /* * At the end of a USB callback it is always safe to unlock @@ -2315,7 +2315,7 @@ tr_setup: break; default: /* Error */ - DPRINTF(sc, ZYD_DEBUG_ANY, "frame error: %s\n", usb2_errstr(xfer->error)); + DPRINTF(sc, ZYD_DEBUG_ANY, "frame error: %s\n", usbd_errstr(xfer->error)); if (xfer->error != USB_ERR_CANCELLED) { /* try to clear stall first */ @@ -2397,9 +2397,9 @@ tr_setup: m->m_pkthdr.len); m->m_pkthdr.len = ZYD_MAX_TXBUFSZ; } - usb2_copy_in(xfer->frbuffers, 0, &data->desc, + usbd_copy_in(xfer->frbuffers, 0, &data->desc, ZYD_TX_DESC_SIZE); - usb2_m_copy_in(xfer->frbuffers, ZYD_TX_DESC_SIZE, m, 0, + usbd_m_copy_in(xfer->frbuffers, ZYD_TX_DESC_SIZE, m, 0, m->m_pkthdr.len); vap = data->ni->ni_vap; @@ -2414,13 +2414,13 @@ tr_setup: xfer->frlengths[0] = ZYD_TX_DESC_SIZE + m->m_pkthdr.len; xfer->priv_fifo = data; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; default: /* Error */ DPRINTF(sc, ZYD_DEBUG_ANY, "transfer error, %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); ifp->if_oerrors++; data = xfer->priv_fifo; @@ -2553,7 +2553,7 @@ zyd_tx_start(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) rate); STAILQ_INSERT_TAIL(&sc->tx_q, data, next); - usb2_transfer_start(sc->sc_xfer[ZYD_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[ZYD_BULK_WR]); return (0); } @@ -2682,8 +2682,8 @@ zyd_init_locked(struct zyd_softc *sc) } /* reset device */ - cd = usb2_get_config_descriptor(sc->sc_udev); - error = usb2_req_set_config(sc->sc_udev, &sc->sc_mtx, + cd = usbd_get_config_descriptor(sc->sc_udev); + error = usbd_req_set_config(sc->sc_udev, &sc->sc_mtx, cd->bConfigurationValue); if (error) device_printf(sc->sc_dev, "reset failed, continuing\n"); @@ -2761,9 +2761,9 @@ zyd_init_locked(struct zyd_softc *sc) ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; ifp->if_drv_flags |= IFF_DRV_RUNNING; - usb2_transfer_set_stall(sc->sc_xfer[ZYD_BULK_WR]); - usb2_transfer_start(sc->sc_xfer[ZYD_BULK_RD]); - usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); + usbd_transfer_set_stall(sc->sc_xfer[ZYD_BULK_WR]); + usbd_transfer_start(sc->sc_xfer[ZYD_BULK_RD]); + usbd_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); return; @@ -2800,8 +2800,8 @@ zyd_stop(struct zyd_softc *sc) * Drain all the transfers, if not already drained: */ ZYD_UNLOCK(sc); - usb2_transfer_drain(sc->sc_xfer[ZYD_BULK_WR]); - usb2_transfer_drain(sc->sc_xfer[ZYD_BULK_RD]); + usbd_transfer_drain(sc->sc_xfer[ZYD_BULK_WR]); + usbd_transfer_drain(sc->sc_xfer[ZYD_BULK_RD]); ZYD_LOCK(sc); zyd_unsetup_tx_list(sc); diff --git a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c index b802d42..8299100 100644 --- a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c +++ b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c @@ -97,7 +97,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -127,7 +127,7 @@ static device_detach_t ubt_detach; static void ubt_task_schedule(ubt_softc_p, int); static task_fn_t ubt_task; -#define ubt_xfer_start(sc, i) usb2_transfer_start((sc)->sc_xfer[(i)]) +#define ubt_xfer_start(sc, i) usbd_transfer_start((sc)->sc_xfer[(i)]) /* Netgraph methods */ static ng_constructor_t ng_ubt_constructor; @@ -407,11 +407,11 @@ ubt_probe(device_t dev) if (uaa->use_generic == 0) return (ENXIO); - if (usb2_lookup_id_by_uaa(ubt_ignore_devs, + if (usbd_lookup_id_by_uaa(ubt_ignore_devs, sizeof(ubt_ignore_devs), uaa) == 0) return (ENXIO); - return (usb2_lookup_id_by_uaa(ubt_devs, sizeof(ubt_devs), uaa)); + return (usbd_lookup_id_by_uaa(ubt_devs, sizeof(ubt_devs), uaa)); } /* ubt_probe */ /* @@ -430,7 +430,7 @@ ubt_attach(device_t dev) uint8_t alt_index, i, j; uint8_t iface_index[2] = { 0, 1 }; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); sc->sc_dev = dev; sc->sc_debug = NG_UBT_WARN_LEVEL; @@ -502,8 +502,8 @@ ubt_attach(device_t dev) * Search through all the descriptors looking for the largest * packet size: */ - while ((ed = (struct usb_endpoint_descriptor *)usb2_desc_foreach( - usb2_get_config_descriptor(uaa->device), + while ((ed = (struct usb_endpoint_descriptor *)usb_desc_foreach( + usbd_get_config_descriptor(uaa->device), (struct usb_descriptor *)ed))) { if ((ed->bDescriptorType == UDESC_INTERFACE) && @@ -528,22 +528,22 @@ ubt_attach(device_t dev) /* Set alt configuration on interface #1 only if we found it */ if (wMaxPacketSize > 0 && - usb2_set_alt_interface_index(uaa->device, 1, alt_index)) { + usbd_set_alt_interface_index(uaa->device, 1, alt_index)) { UBT_ALERT(sc, "could not set alternate setting %d " \ "for interface 1!\n", alt_index); goto detach; } /* Setup transfers for both interfaces */ - if (usb2_transfer_setup(uaa->device, iface_index, sc->sc_xfer, + if (usbd_transfer_setup(uaa->device, iface_index, sc->sc_xfer, ubt_config, UBT_N_TRANSFER, sc, &sc->sc_if_mtx)) { UBT_ALERT(sc, "could not allocate transfers\n"); goto detach; } /* Claim all interfaces on the device */ - for (i = 1; usb2_get_iface(uaa->device, i) != NULL; i ++) - usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); + for (i = 1; usbd_get_iface(uaa->device, i) != NULL; i ++) + usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex); return (0); /* success */ @@ -575,7 +575,7 @@ ubt_detach(device_t dev) taskqueue_drain(taskqueue_swi, &sc->sc_task); /* Free USB transfers, if any */ - usb2_transfer_unsetup(sc->sc_xfer, UBT_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UBT_N_TRANSFER); /* Destroy queues */ UBT_NG_LOCK(sc); @@ -631,8 +631,8 @@ send_next: "bmRequestType=0x%02x, wLength=%d\n", req.bmRequestType, UGETW(req.wLength)); - usb2_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); - usb2_m_copy_in(xfer->frbuffers + 1, 0, m, 0, m->m_pkthdr.len); + usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req)); + usbd_m_copy_in(xfer->frbuffers + 1, 0, m, 0, m->m_pkthdr.len); xfer->frlengths[0] = sizeof(req); xfer->frlengths[1] = m->m_pkthdr.len; @@ -640,13 +640,13 @@ send_next: NG_FREE_M(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { UBT_WARN(sc, "control transfer failed: %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); UBT_STAT_OERROR(sc); goto send_next; @@ -694,7 +694,7 @@ ubt_intr_read_callback(struct usb_xfer *xfer) if (xfer->actlen > MCLBYTES - 1) xfer->actlen = MCLBYTES - 1; - usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1, + usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1, xfer->actlen); m->m_pkthdr.len += xfer->actlen; m->m_len += xfer->actlen; @@ -735,13 +735,13 @@ submit_next: NG_FREE_M(m); /* checks for m != NULL */ xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { UBT_WARN(sc, "interrupt transfer failed: %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); /* Try to clear stall first */ xfer->flags.stall_pipe = 1; @@ -790,7 +790,7 @@ ubt_bulk_read_callback(struct usb_xfer *xfer) if (xfer->actlen > MCLBYTES - 1) xfer->actlen = MCLBYTES - 1; - usb2_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1, + usbd_copy_out(xfer->frbuffers, 0, mtod(m, uint8_t *) + 1, xfer->actlen); m->m_pkthdr.len += xfer->actlen; m->m_len += xfer->actlen; @@ -831,13 +831,13 @@ submit_next: NG_FREE_M(m); /* checks for m != NULL */ xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { UBT_WARN(sc, "bulk-in transfer failed: %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); /* Try to clear stall first */ xfer->flags.stall_pipe = 1; @@ -884,7 +884,7 @@ send_next: * and schedule transfer */ - usb2_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); + usbd_m_copy_in(xfer->frbuffers, 0, m, 0, m->m_pkthdr.len); xfer->frlengths[0] = m->m_pkthdr.len; UBT_INFO(sc, "bulk-out transfer has been started, len=%d\n", @@ -892,13 +892,13 @@ send_next: NG_FREE_M(m); - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ if (xfer->error != USB_ERR_CANCELLED) { UBT_WARN(sc, "bulk-out transfer failed: %s\n", - usb2_errstr(xfer->error)); + usbd_errstr(xfer->error)); UBT_STAT_OERROR(sc); @@ -935,7 +935,7 @@ read_next: for (n = 0; n < xfer->nframes; n ++) xfer->frlengths[n] = xfer->max_frame_size; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -1003,7 +1003,7 @@ ubt_isoc_read_one_frame(struct usb_xfer *xfer, int frame_no) if (got + len > want) len = want - got; - usb2_copy_out(xfer->frbuffers, frame_no * xfer->max_frame_size, + usbd_copy_out(xfer->frbuffers, frame_no * xfer->max_frame_size, mtod(m, uint8_t *) + m->m_pkthdr.len, len); m->m_pkthdr.len += len; @@ -1070,7 +1070,7 @@ send_next: n = min(space, m->m_pkthdr.len); if (n > 0) { - usb2_m_copy_in(xfer->frbuffers, offset, m,0, n); + usbd_m_copy_in(xfer->frbuffers, offset, m,0, n); m_adj(m, n); offset += n; @@ -1101,7 +1101,7 @@ send_next: offset -= xfer->frlengths[n]; } - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); break; default: /* Error */ @@ -1233,12 +1233,12 @@ ubt_task(void *context, int pending) /* * Stop all USB transfers synchronously. * Stop interface #0 and #1 transfers at the same time and in the - * same loop. usb2_transfer_drain() will do appropriate locking. + * same loop. usbd_transfer_drain() will do appropriate locking. */ if (task_flags & UBT_FLAG_T_STOP_ALL) for (i = 0; i < UBT_N_TRANSFER; i ++) - usb2_transfer_drain(sc->sc_xfer[i]); + usbd_transfer_drain(sc->sc_xfer[i]); /* Start incoming interrupt and bulk, and all isoc. USB transfers */ if (task_flags & UBT_FLAG_T_START_ALL) { diff --git a/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c b/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c index 35b8233..00f364b 100644 --- a/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c +++ b/sys/netgraph/bluetooth/drivers/ubtbcmfw/ubtbcmfw.c @@ -37,7 +37,7 @@ #include #include -#define USB_DEBUG_VAR usb2_debug +#define USB_DEBUG_VAR usb_debug #include #include @@ -180,7 +180,7 @@ ubtbcmfw_probe(device_t dev) if (uaa->info.bIfaceIndex != 0) return (ENXIO); - return (usb2_lookup_id_by_uaa(devs, sizeof(devs), uaa)); + return (usbd_lookup_id_by_uaa(devs, sizeof(devs), uaa)); } /* ubtbcmfw_probe */ /* @@ -197,27 +197,27 @@ ubtbcmfw_attach(device_t dev) sc->sc_udev = uaa->device; - device_set_usb2_desc(dev); + device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "ubtbcmfw lock", NULL, MTX_DEF | MTX_RECURSE); iface_index = UBTBCMFW_IFACE_IDX; - error = usb2_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, + error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, ubtbcmfw_config, UBTBCMFW_N_TRANSFER, sc, &sc->sc_mtx); if (error != 0) { device_printf(dev, "allocating USB transfers failed. %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } - error = usb2_fifo_attach(uaa->device, sc, &sc->sc_mtx, + error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx, &ubtbcmfw_fifo_methods, &sc->sc_fifo, device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, UID_ROOT, GID_OPERATOR, 0644); if (error != 0) { device_printf(dev, "could not attach fifo. %s\n", - usb2_errstr(error)); + usbd_errstr(error)); goto detach; } @@ -238,9 +238,9 @@ ubtbcmfw_detach(device_t dev) { struct ubtbcmfw_softc *sc = device_get_softc(dev); - usb2_fifo_detach(&sc->sc_fifo); + usb_fifo_detach(&sc->sc_fifo); - usb2_transfer_unsetup(sc->sc_xfer, UBTBCMFW_N_TRANSFER); + usbd_transfer_unsetup(sc->sc_xfer, UBTBCMFW_N_TRANSFER); mtx_destroy(&sc->sc_mtx); @@ -262,10 +262,10 @@ ubtbcmfw_write_callback(struct usb_xfer *xfer) case USB_ST_SETUP: case USB_ST_TRANSFERRED: setup_next: - if (usb2_fifo_get_data(f, xfer->frbuffers, 0, + if (usb_fifo_get_data(f, xfer->frbuffers, 0, xfer->max_data_length, &actlen, 0)) { xfer->frlengths[0] = actlen; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -291,14 +291,14 @@ ubtbcmfw_read_callback(struct usb_xfer *xfer) switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: - usb2_fifo_put_data(fifo, xfer->frbuffers, 0, xfer->actlen, 1); + usb_fifo_put_data(fifo, xfer->frbuffers, 0, xfer->actlen, 1); /* FALLTHROUGH */ case USB_ST_SETUP: setup_next: - if (usb2_fifo_put_bytes_max(fifo) > 0) { + if (usb_fifo_put_bytes_max(fifo) > 0) { xfer->frlengths[0] = xfer->max_data_length; - usb2_start_hardware(xfer); + usbd_transfer_submit(xfer); } break; @@ -321,7 +321,7 @@ ubtbcmfw_start_read(struct usb_fifo *fifo) { struct ubtbcmfw_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]); + usbd_transfer_start(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]); } /* ubtbcmfw_start_read */ /* @@ -333,7 +333,7 @@ ubtbcmfw_stop_read(struct usb_fifo *fifo) { struct ubtbcmfw_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]); + usbd_transfer_stop(sc->sc_xfer[UBTBCMFW_INTR_DT_RD]); } /* ubtbcmfw_stop_read */ /* @@ -346,7 +346,7 @@ ubtbcmfw_start_write(struct usb_fifo *fifo) { struct ubtbcmfw_softc *sc = fifo->priv_sc0; - usb2_transfer_start(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]); + usbd_transfer_start(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]); } /* ubtbcmfw_start_write */ /* @@ -358,7 +358,7 @@ ubtbcmfw_stop_write(struct usb_fifo *fifo) { struct ubtbcmfw_softc *sc = fifo->priv_sc0; - usb2_transfer_stop(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]); + usbd_transfer_stop(sc->sc_xfer[UBTBCMFW_BULK_DT_WR]); } /* ubtbcmfw_stop_write */ /* @@ -383,7 +383,7 @@ ubtbcmfw_open(struct usb_fifo *fifo, int fflags) else return (EINVAL); /* should not happen */ - if (usb2_fifo_alloc_buffer(fifo, xfer->max_data_length, + if (usb_fifo_alloc_buffer(fifo, xfer->max_data_length, UBTBCMFW_IFQ_MAXLEN) != 0) return (ENOMEM); @@ -398,7 +398,7 @@ static void ubtbcmfw_close(struct usb_fifo *fifo, int fflags) { if (fflags & (FREAD | FWRITE)) - usb2_fifo_free_buffer(fifo); + usb_fifo_free_buffer(fifo); } /* ubtbcmfw_close */ /* @@ -414,7 +414,7 @@ ubtbcmfw_ioctl(struct usb_fifo *fifo, u_long cmd, void *data, switch (cmd) { case USB_GET_DEVICE_DESC: - memcpy(data, usb2_get_device_descriptor(sc->sc_udev), + memcpy(data, usbd_get_device_descriptor(sc->sc_udev), sizeof(struct usb_device_descriptor)); break; -- cgit v1.1