aboutsummaryrefslogtreecommitdiff
path: root/sys/dev/usb/serial
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/usb/serial')
-rw-r--r--sys/dev/usb/serial/u3g.c71
-rw-r--r--sys/dev/usb/serial/uark.c70
-rw-r--r--sys/dev/usb/serial/ubsa.c91
-rw-r--r--sys/dev/usb/serial/ubser.c76
-rw-r--r--sys/dev/usb/serial/uchcom.c91
-rw-r--r--sys/dev/usb/serial/ucycom.c100
-rw-r--r--sys/dev/usb/serial/ufoma.c161
-rw-r--r--sys/dev/usb/serial/uftdi.c79
-rw-r--r--sys/dev/usb/serial/ugensa.c68
-rw-r--r--sys/dev/usb/serial/uipaq.c68
-rw-r--r--sys/dev/usb/serial/ulpt.c134
-rw-r--r--sys/dev/usb/serial/umct.c91
-rw-r--r--sys/dev/usb/serial/umodem.c108
-rw-r--r--sys/dev/usb/serial/umoscom.c85
-rw-r--r--sys/dev/usb/serial/uplcom.c88
-rw-r--r--sys/dev/usb/serial/usb_serial.c32
-rw-r--r--sys/dev/usb/serial/uslcom.c67
-rw-r--r--sys/dev/usb/serial/uvisor.c69
-rw-r--r--sys/dev/usb/serial/uvscom.c87
19 files changed, 1025 insertions, 611 deletions
diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c
index fb25936c26be..eb12f8a68dd0 100644
--- a/sys/dev/usb/serial/u3g.c
+++ b/sys/dev/usb/serial/u3g.c
@@ -30,22 +30,37 @@
*
*/
-#include "usbdevs.h"
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR u3g_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_msctest.h>
#include <dev/usb/usb_dynamic.h>
+#include <dev/usb/usb_msctest.h>
#include <dev/usb/usb_device.h>
#include <dev/usb/serial/usb_serial.h>
@@ -501,8 +516,8 @@ u3g_attach(device_t dev)
/* set stall by default */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]);
mtx_unlock(&sc->sc_mtx);
nports++; /* found one port */
@@ -588,26 +603,27 @@ u3g_stop_write(struct ucom_softc *ucom)
}
static void
-u3g_write_callback(struct usb_xfer *xfer)
+u3g_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ucom_softc *ucom = xfer->priv_sc;
+ struct ucom_softc *ucom = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
case USB_ST_SETUP:
tr_setup:
- if (ucom_get_data(ucom, xfer->frbuffers, 0,
- U3G_BSIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(ucom, pc, 0, U3G_BSIZE, &actlen)) {
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
break;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* do a builtin clear-stall */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
@@ -616,24 +632,29 @@ tr_setup:
}
static void
-u3g_read_callback(struct usb_xfer *xfer)
+u3g_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ucom_softc *ucom = xfer->priv_sc;
+ struct ucom_softc *ucom = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* do a builtin clear-stall */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
diff --git a/sys/dev/usb/serial/uark.c b/sys/dev/usb/serial/uark.c
index 04861babd612..cff124eb0749 100644
--- a/sys/dev/usb/serial/uark.c
+++ b/sys/dev/usb/serial/uark.c
@@ -23,20 +23,36 @@
* be called from within the config thread function !
*/
-#include "usbdevs.h"
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usbhid.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
#include <dev/usb/serial/usb_serial.h>
@@ -198,8 +214,8 @@ uark_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -228,26 +244,28 @@ uark_detach(device_t dev)
}
static void
-uark_bulk_write_callback(struct usb_xfer *xfer)
+uark_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uark_softc *sc = xfer->priv_sc;
+ struct uark_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UARK_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -256,25 +274,29 @@ tr_setup:
}
static void
-uark_bulk_read_callback(struct usb_xfer *xfer)
+uark_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uark_softc *sc = xfer->priv_sc;
+ struct uark_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
- xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ubsa.c b/sys/dev/usb/serial/ubsa.c
index cc584c3f64df..3e8e61b7c6fd 100644
--- a/sys/dev/usb/serial/ubsa.c
+++ b/sys/dev/usb/serial/ubsa.c
@@ -62,21 +62,34 @@ __FBSDID("$FreeBSD$");
* POSSIBILITY OF SUCH DAMAGE.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR ubsa_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -305,8 +318,8 @@ ubsa_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UBSA_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -537,27 +550,29 @@ ubsa_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
}
static void
-ubsa_write_callback(struct usb_xfer *xfer)
+ubsa_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ubsa_softc *sc = xfer->priv_sc;
+ struct ubsa_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UBSA_BSIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -566,24 +581,29 @@ tr_setup:
}
static void
-ubsa_read_callback(struct usb_xfer *xfer)
+ubsa_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ubsa_softc *sc = xfer->priv_sc;
+ struct ubsa_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -592,17 +612,21 @@ tr_setup:
}
static void
-ubsa_intr_callback(struct usb_xfer *xfer)
+ubsa_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ubsa_softc *sc = xfer->priv_sc;
+ struct ubsa_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[4];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen >= sizeof(buf)) {
-
- usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+ if (actlen >= sizeof(buf)) {
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, sizeof(buf));
/*
* incidentally, Belkin adapter status bits match
@@ -616,20 +640,19 @@ ubsa_intr_callback(struct usb_xfer *xfer)
ucom_status_change(&sc->sc_ucom);
} else {
- DPRINTF("ignoring short packet, %d bytes\n",
- xfer->actlen);
+ DPRINTF("ignoring short packet, %d bytes\n", actlen);
}
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ubser.c b/sys/dev/usb/serial/ubser.c
index f184ecd6353d..a2c29f94b3bb 100644
--- a/sys/dev/usb/serial/ubser.c
+++ b/sys/dev/usb/serial/ubser.c
@@ -76,20 +76,34 @@ __FBSDID("$FreeBSD$");
* BWCT serial adapter driver
*/
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR ubser_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/usb_device.h>
#include <dev/usb/serial/usb_serial.h>
@@ -263,7 +277,7 @@ ubser_attach(device_t dev)
if (error) {
goto detach;
}
- sc->sc_tx_size = sc->sc_xfer[UBSER_BULK_DT_WR]->max_data_length;
+ sc->sc_tx_size = usbd_xfer_max_len(sc->sc_xfer[UBSER_BULK_DT_WR]);
if (sc->sc_tx_size == 0) {
DPRINTFN(0, "invalid tx_size!\n");
@@ -282,8 +296,8 @@ ubser_attach(device_t dev)
}
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UBSER_BULK_DT_RD]);
usbd_transfer_start(sc->sc_xfer[UBSER_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
@@ -367,9 +381,10 @@ ubser_inc_tx_unit(struct ubser_softc *sc)
}
static void
-ubser_write_callback(struct usb_xfer *xfer)
+ubser_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ubser_softc *sc = xfer->priv_sc;
+ struct ubser_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[1];
uint8_t first_unit = sc->sc_curr_tx_unit;
uint32_t actlen;
@@ -378,16 +393,17 @@ ubser_write_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
+ pc = usbd_xfer_get_frame(xfer, 0);
do {
if (ucom_get_data(sc->sc_ucom + sc->sc_curr_tx_unit,
- xfer->frbuffers, 1, sc->sc_tx_size - 1,
+ pc, 1, sc->sc_tx_size - 1,
&actlen)) {
buf[0] = sc->sc_curr_tx_unit;
- usbd_copy_in(xfer->frbuffers, 0, buf, 1);
+ usbd_copy_in(pc, 0, buf, 1);
- xfer->frlengths[0] = actlen + 1;
+ usbd_xfer_set_frame_len(xfer, 0, actlen + 1);
usbd_transfer_submit(xfer);
ubser_inc_tx_unit(sc); /* round robin */
@@ -401,9 +417,9 @@ tr_setup:
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -412,36 +428,40 @@ tr_setup:
}
static void
-ubser_read_callback(struct usb_xfer *xfer)
+ubser_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ubser_softc *sc = xfer->priv_sc;
+ struct ubser_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[1];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 1) {
+ if (actlen < 1) {
DPRINTF("invalid actlen=0!\n");
goto tr_setup;
}
- usbd_copy_out(xfer->frbuffers, 0, buf, 1);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, 1);
if (buf[0] >= sc->sc_numser) {
DPRINTF("invalid serial number!\n");
goto tr_setup;
}
- ucom_put_data(sc->sc_ucom + buf[0],
- xfer->frbuffers, 1, xfer->actlen - 1);
+ ucom_put_data(sc->sc_ucom + buf[0], pc, 1, actlen - 1);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uchcom.c b/sys/dev/usb/serial/uchcom.c
index 009a37db756d..705d3e6fdf08 100644
--- a/sys/dev/usb/serial/uchcom.c
+++ b/sys/dev/usb/serial/uchcom.c
@@ -69,22 +69,34 @@ __FBSDID("$FreeBSD$");
* driver for WinChipHead CH341/340, the worst USB-serial chip in the world.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
-#include <dev/usb/usb_ioctl.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uchcom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -341,8 +353,8 @@ uchcom_attach(device_t dev)
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UCHCOM_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -772,19 +784,23 @@ uchcom_stop_write(struct ucom_softc *ucom)
* callback when the modem status is changed.
*/
static void
-uchcom_intr_callback(struct usb_xfer *xfer)
+uchcom_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uchcom_softc *sc = xfer->priv_sc;
+ struct uchcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[UCHCOM_INTR_LEAST];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- DPRINTF("actlen = %u\n", xfer->actlen);
+ DPRINTF("actlen = %u\n", actlen);
- if (xfer->actlen >= UCHCOM_INTR_LEAST) {
- usbd_copy_out(xfer->frbuffers, 0, buf,
- UCHCOM_INTR_LEAST);
+ if (actlen >= UCHCOM_INTR_LEAST) {
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, UCHCOM_INTR_LEAST);
DPRINTF("data = 0x%02X 0x%02X 0x%02X 0x%02X\n",
(unsigned)buf[0], (unsigned)buf[1],
@@ -795,14 +811,14 @@ uchcom_intr_callback(struct usb_xfer *xfer)
}
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
break;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
@@ -810,29 +826,31 @@ tr_setup:
}
static void
-uchcom_write_callback(struct usb_xfer *xfer)
+uchcom_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uchcom_softc *sc = xfer->priv_sc;
+ struct uchcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UCHCOM_BULK_BUF_SIZE, &actlen)) {
DPRINTF("actlen = %d\n", actlen);
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -841,24 +859,29 @@ tr_setup:
}
static void
-uchcom_read_callback(struct usb_xfer *xfer)
+uchcom_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uchcom_softc *sc = xfer->priv_sc;
+ struct uchcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c
index 7825a2276695..1eb246089531 100644
--- a/sys/dev/usb/serial/ucycom.c
+++ b/sys/dev/usb/serial/ucycom.c
@@ -34,24 +34,35 @@ __FBSDID("$FreeBSD$");
* RS232 bridges.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
-#include <dev/usb/usb_ioctl.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbhid.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_hid.h>
#include <dev/usb/serial/usb_serial.h>
@@ -329,14 +340,18 @@ ucycom_stop_write(struct ucom_softc *ucom)
}
static void
-ucycom_ctrl_write_callback(struct usb_xfer *xfer)
+ucycom_ctrl_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ucycom_softc *sc = xfer->priv_sc;
+ struct ucycom_softc *sc = usbd_xfer_softc(xfer);
struct usb_device_request req;
+ struct usb_page_cache *pc0, *pc1;
uint8_t data[2];
uint8_t offset;
uint32_t actlen;
+ pc0 = usbd_xfer_get_frame(xfer, 0);
+ pc1 = usbd_xfer_get_frame(xfer, 1);
+
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
tr_transferred:
@@ -354,7 +369,7 @@ tr_transferred:
break;
}
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1, offset,
+ if (ucom_get_data(&sc->sc_ucom, pc1, offset,
sc->sc_olen - offset, &actlen)) {
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
@@ -376,22 +391,22 @@ tr_transferred:
break;
}
- usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
- usbd_copy_in(xfer->frbuffers + 1, 0, data, offset);
+ usbd_copy_in(pc0, 0, &req, sizeof(req));
+ usbd_copy_in(pc1, 0, data, offset);
- xfer->frlengths[0] = sizeof(req);
- xfer->frlengths[1] = sc->sc_olen;
- xfer->nframes = xfer->frlengths[1] ? 2 : 1;
+ usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
+ usbd_xfer_set_frame_len(xfer, 1, sc->sc_olen);
+ usbd_xfer_set_frames(xfer, sc->sc_olen ? 2 : 1);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error == USB_ERR_CANCELLED) {
+ if (error == USB_ERR_CANCELLED) {
return;
}
DPRINTF("error=%s\n",
- usbd_errstr(xfer->error));
+ usbd_errstr(error));
goto tr_transferred;
}
}
@@ -494,42 +509,45 @@ ucycom_cfg_param(struct ucom_softc *ucom, struct termios *t)
}
static void
-ucycom_intr_read_callback(struct usb_xfer *xfer)
+ucycom_intr_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ucycom_softc *sc = xfer->priv_sc;
+ struct ucycom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[2];
uint32_t offset;
uint32_t len;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
+ pc = usbd_xfer_get_frame(xfer, 0);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
switch (sc->sc_model) {
case MODEL_CY7C63743:
- if (xfer->actlen < 1) {
+ if (actlen < 1) {
goto tr_setup;
}
- usbd_copy_out(xfer->frbuffers, 0, buf, 1);
+ usbd_copy_out(pc, 0, buf, 1);
sc->sc_ist = buf[0] & ~0x07;
len = buf[0] & 0x07;
- (xfer->actlen)--;
-
+ actlen--;
offset = 1;
break;
case MODEL_CY7C64013:
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
goto tr_setup;
}
- usbd_copy_out(xfer->frbuffers, 0, buf, 2);
+ usbd_copy_out(pc, 0, buf, 2);
sc->sc_ist = buf[0] & ~0x07;
len = buf[1];
- (xfer->actlen) -= 2;
-
+ actlen -= 2;
offset = 2;
break;
@@ -539,23 +557,21 @@ ucycom_intr_read_callback(struct usb_xfer *xfer)
goto tr_setup;
}
- if (len > xfer->actlen) {
- len = xfer->actlen;
- }
- if (len) {
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers,
- offset, len);
- }
+ if (len > actlen)
+ len = actlen;
+ if (len)
+ ucom_put_data(&sc->sc_ucom, pc, offset, len);
+ /* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = sc->sc_ilen;
+ usbd_xfer_set_frame_len(xfer, 0, sc->sc_ilen);
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ufoma.c b/sys/dev/usb/serial/ufoma.c
index 89285edd213e..8b354e3355d1 100644
--- a/sys/dev/usb/serial/ufoma.c
+++ b/sys/dev/usb/serial/ufoma.c
@@ -82,26 +82,38 @@ __FBSDID("$FreeBSD$");
* be called from within the config thread function !
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+#include <sys/sbuf.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
#include <dev/usb/usb_cdc.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_parse.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
-#include <sys/sysctl.h>
-#include <sys/sbuf.h>
typedef struct ufoma_mobile_acm_descriptor {
uint8_t bFunctionLength;
@@ -426,8 +438,8 @@ ufoma_attach(device_t dev)
/* clear stall at first run, if any */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
- usbd_transfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
+ usbd_xfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_WRITE]);
+ usbd_xfer_set_stall(sc->sc_bulk_xfer[UFOMA_BULK_ENDPT_READ]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -544,21 +556,25 @@ ufoma_cfg_activate_state(struct ufoma_softc *sc, uint16_t state)
}
static void
-ufoma_ctrl_read_callback(struct usb_xfer *xfer)
+ufoma_ctrl_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ufoma_softc *sc = xfer->priv_sc;
+ struct ufoma_softc *sc = usbd_xfer_softc(xfer);
struct usb_device_request req;
+ struct usb_page_cache *pc0, *pc1;
+ int len, aframes, nframes;
+
+ usbd_xfer_status(xfer, NULL, NULL, &aframes, &nframes);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
tr_transferred:
- if (xfer->aframes != xfer->nframes) {
+ if (aframes != nframes)
goto tr_setup;
- }
- if (xfer->frlengths[1] > 0) {
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers + 1,
- 0, xfer->frlengths[1]);
- }
+ pc1 = usbd_xfer_get_frame(xfer, 1);
+ len = usbd_xfer_get_frame_len(xfer, 1);
+ if (len > 0)
+ ucom_put_data(&sc->sc_ucom, pc1, 0, len);
+ /* FALLTHROUGH */
case USB_ST_SETUP:
tr_setup:
if (sc->sc_num_msg) {
@@ -570,20 +586,21 @@ tr_setup:
USETW(req.wValue, 0);
USETW(req.wLength, UFOMA_CMD_BUF_SIZE);
- usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+ pc0 = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_in(pc0, 0, &req, sizeof(req));
- xfer->frlengths[0] = sizeof(req);
- xfer->frlengths[1] = UFOMA_CMD_BUF_SIZE;
- xfer->nframes = 2;
+ usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
+ usbd_xfer_set_frame_len(xfer, 1, UFOMA_CMD_BUF_SIZE);
+ usbd_xfer_set_frames(xfer, 2);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
DPRINTF("error = %s\n",
- usbd_errstr(xfer->error));
+ usbd_errstr(error));
- if (xfer->error == USB_ERR_CANCELLED) {
+ if (error == USB_ERR_CANCELLED) {
return;
} else {
goto tr_setup;
@@ -594,10 +611,11 @@ tr_setup:
}
static void
-ufoma_ctrl_write_callback(struct usb_xfer *xfer)
+ufoma_ctrl_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ufoma_softc *sc = xfer->priv_sc;
+ struct ufoma_softc *sc = usbd_xfer_softc(xfer);
struct usb_device_request req;
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
@@ -605,8 +623,8 @@ ufoma_ctrl_write_callback(struct usb_xfer *xfer)
tr_transferred:
case USB_ST_SETUP:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers + 1,
- 0, 1, &actlen)) {
+ pc = usbd_xfer_get_frame(xfer, 1);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0, 1, &actlen)) {
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req.bRequest = UCDC_SEND_ENCAPSULATED_COMMAND;
@@ -614,21 +632,21 @@ tr_setup:
USETW(req.wValue, 0);
USETW(req.wLength, 1);
- usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_in(pc, 0, &req, sizeof(req));
- xfer->frlengths[0] = sizeof(req);
- xfer->frlengths[1] = 1;
- xfer->nframes = 2;
+ usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
+ usbd_xfer_set_frame_len(xfer, 1, 1);
+ usbd_xfer_set_frames(xfer, 2);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- DPRINTF("error = %s\n",
- usbd_errstr(xfer->error));
+ DPRINTF("error = %s\n", usbd_errstr(error));
- if (xfer->error == USB_ERR_CANCELLED) {
+ if (error == USB_ERR_CANCELLED) {
return;
} else {
goto tr_setup;
@@ -639,31 +657,36 @@ tr_setup:
}
static void
-ufoma_intr_callback(struct usb_xfer *xfer)
+ufoma_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ufoma_softc *sc = xfer->priv_sc;
+ struct ufoma_softc *sc = usbd_xfer_softc(xfer);
struct usb_cdc_notification pkt;
+ struct usb_page_cache *pc;
uint16_t wLen;
uint16_t temp;
uint8_t mstatus;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 8) {
+ if (actlen < 8) {
DPRINTF("too short message\n");
goto tr_setup;
}
- if (xfer->actlen > sizeof(pkt)) {
+ if (actlen > sizeof(pkt)) {
DPRINTF("truncating message\n");
- xfer->actlen = sizeof(pkt);
+ actlen = sizeof(pkt);
}
- usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, &pkt, actlen);
- xfer->actlen -= 8;
+ actlen -= 8;
wLen = UGETW(pkt.wLength);
- if (xfer->actlen > wLen) {
- xfer->actlen = wLen;
+ if (actlen > wLen) {
+ actlen = wLen;
}
if ((pkt.bmRequestType == UT_READ_VENDOR_INTERFACE) &&
(pkt.bNotification == UMCPC_REQUEST_ACKNOWLEDGE)) {
@@ -698,9 +721,9 @@ ufoma_intr_callback(struct usb_xfer *xfer)
* Set the serial state in ucom driver based on
* the bits from the notify message
*/
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
DPRINTF("invalid notification "
- "length, %d bytes!\n", xfer->actlen);
+ "length, %d bytes!\n", actlen);
break;
}
DPRINTF("notify bytes = 0x%02x, 0x%02x\n",
@@ -730,14 +753,14 @@ ufoma_intr_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -745,26 +768,28 @@ tr_setup:
}
static void
-ufoma_bulk_write_callback(struct usb_xfer *xfer)
+ufoma_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ufoma_softc *sc = xfer->priv_sc;
+ struct ufoma_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UFOMA_BULK_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -772,25 +797,29 @@ tr_setup:
}
static void
-ufoma_bulk_read_callback(struct usb_xfer *xfer)
+ufoma_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ufoma_softc *sc = xfer->priv_sc;
+ struct ufoma_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
- xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uftdi.c b/sys/dev/usb/serial/uftdi.c
index 700d68b138e3..52a070b7015c 100644
--- a/sys/dev/usb/serial/uftdi.c
+++ b/sys/dev/usb/serial/uftdi.c
@@ -48,21 +48,34 @@ __FBSDID("$FreeBSD$");
* FTDI FT8U100AX serial adapter driver
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uftdi_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
#include <dev/usb/serial/uftdi_reg.h>
@@ -296,8 +309,8 @@ uftdi_attach(device_t dev)
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UFTDI_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
/* set a valid "lcr" value */
@@ -368,9 +381,10 @@ uftdi_cfg_open(struct ucom_softc *ucom)
}
static void
-uftdi_write_callback(struct usb_xfer *xfer)
+uftdi_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uftdi_softc *sc = xfer->priv_sc;
+ struct uftdi_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
uint8_t buf[1];
@@ -378,24 +392,25 @@ uftdi_write_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc,
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);
- usbd_copy_in(xfer->frbuffers, 0, buf, 1);
+ usbd_copy_in(pc, 0, buf, 1);
}
- xfer->frlengths[0] = actlen + sc->sc_hdrlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen + sc->sc_hdrlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -403,21 +418,26 @@ tr_setup:
}
static void
-uftdi_read_callback(struct usb_xfer *xfer)
+uftdi_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uftdi_softc *sc = xfer->priv_sc;
+ struct uftdi_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[2];
uint8_t ftdi_msr;
uint8_t msr;
uint8_t lsr;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
goto tr_setup;
}
- usbd_copy_out(xfer->frbuffers, 0, buf, 2);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, 2);
ftdi_msr = FTDI_GET_MSR(buf);
lsr = FTDI_GET_LSR(buf);
@@ -443,22 +463,21 @@ uftdi_read_callback(struct usb_xfer *xfer)
ucom_status_change(&sc->sc_ucom);
}
- xfer->actlen -= 2;
+ actlen -= 2;
- if (xfer->actlen > 0) {
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 2,
- xfer->actlen);
+ if (actlen > 0) {
+ ucom_put_data(&sc->sc_ucom, pc, 2, actlen);
}
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ugensa.c b/sys/dev/usb/serial/ugensa.c
index eada5da3d35f..86e858638a7d 100644
--- a/sys/dev/usb/serial/ugensa.c
+++ b/sys/dev/usb/serial/ugensa.c
@@ -42,21 +42,33 @@
* be called from within the config thread function !
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_device.h>
#include <dev/usb/serial/usb_serial.h>
@@ -221,8 +233,8 @@ ugensa_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
- usbd_transfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
+ usbd_xfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_WR]);
+ usbd_xfer_set_stall(ssc->sc_xfer[UGENSA_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
/* initialize port number */
@@ -264,26 +276,28 @@ ugensa_detach(device_t dev)
}
static void
-ugensa_bulk_write_callback(struct usb_xfer *xfer)
+ugensa_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ugensa_sub_softc *ssc = xfer->priv_sc;
+ struct ugensa_sub_softc *ssc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(ssc->sc_ucom_ptr, pc, 0,
UGENSA_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -291,25 +305,29 @@ tr_setup:
}
static void
-ugensa_bulk_read_callback(struct usb_xfer *xfer)
+ugensa_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ugensa_sub_softc *ssc = xfer->priv_sc;
+ struct ugensa_sub_softc *ssc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(ssc->sc_ucom_ptr, xfer->frbuffers, 0,
- xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(ssc->sc_ucom_ptr, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uipaq.c b/sys/dev/usb/serial/uipaq.c
index ca66866dde07..79fe21e5c2c4 100644
--- a/sys/dev/usb/serial/uipaq.c
+++ b/sys/dev/usb/serial/uipaq.c
@@ -51,21 +51,35 @@
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
#include <dev/usb/usb_cdc.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -1136,8 +1150,8 @@ uipaq_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UIPAQ_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -1267,26 +1281,28 @@ uipaq_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
}
static void
-uipaq_write_callback(struct usb_xfer *xfer)
+uipaq_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uipaq_softc *sc = xfer->priv_sc;
+ struct uipaq_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UIPAQ_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -1294,25 +1310,29 @@ tr_setup:
}
static void
-uipaq_read_callback(struct usb_xfer *xfer)
+uipaq_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uipaq_softc *sc = xfer->priv_sc;
+ struct uipaq_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
- xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/ulpt.c b/sys/dev/usb/serial/ulpt.c
index b7b622d163aa..fd21a1d05ded 100644
--- a/sys/dev/usb/serial/ulpt.c
+++ b/sys/dev/usb/serial/ulpt.c
@@ -45,25 +45,39 @@ __FBSDID("$FreeBSD$");
* Printer Class spec: http://www.usb.org/developers/devclass_docs/usbprint11.pdf
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+#include <sys/syslog.h>
+#include <sys/selinfo.h>
+#include <sys/conf.h>
+#include <sys/fcntl.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usbhid.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR ulpt_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_mbuf.h>
-#include <dev/usb/usb_dev.h>
-#include <dev/usb/usb_parse.h>
-
-#include <sys/syslog.h>
#if USB_DEBUG
static int ulpt_debug = 0;
@@ -189,35 +203,38 @@ ulpt_reset(struct ulpt_softc *sc)
}
static void
-ulpt_write_callback(struct usb_xfer *xfer)
+ulpt_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ulpt_softc *sc = xfer->priv_sc;
+ struct ulpt_softc *sc = usbd_xfer_softc(xfer);
struct usb_fifo *f = sc->sc_fifo_open[USB_FIFO_TX];
- uint32_t actlen;
+ struct usb_page_cache *pc;
+ int actlen, max;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
if (f == NULL) {
/* should not happen */
DPRINTF("no FIFO\n");
return;
}
- DPRINTF("state=0x%x actlen=%u\n",
- USB_GET_STATE(xfer), xfer->actlen);
+ DPRINTF("state=0x%x actlen=%d\n", USB_GET_STATE(xfer), actlen);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
case USB_ST_SETUP:
tr_setup:
- if (usb_fifo_get_data(f, xfer->frbuffers,
- 0, xfer->max_data_length, &actlen, 0)) {
- xfer->frlengths[0] = actlen;
+ pc = usbd_xfer_get_frame(xfer, 0);
+ max = usbd_xfer_max_len(xfer);
+ if (usb_fifo_get_data(f, pc, 0, max, &actlen, 0)) {
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
break;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
@@ -225,10 +242,14 @@ tr_setup:
}
static void
-ulpt_read_callback(struct usb_xfer *xfer)
+ulpt_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ulpt_softc *sc = xfer->priv_sc;
+ struct ulpt_softc *sc = usbd_xfer_softc(xfer);
struct usb_fifo *f = sc->sc_fifo_open[USB_FIFO_RX];
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
if (f == NULL) {
/* should not happen */
@@ -240,40 +261,40 @@ ulpt_read_callback(struct usb_xfer *xfer)
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen == 0) {
+ if (actlen == 0) {
if (sc->sc_zlps == 4) {
/* enable BULK throttle */
- xfer->interval = 500; /* ms */
+ usbd_xfer_set_interval(xfer, 500); /* ms */
} else {
sc->sc_zlps++;
}
} else {
/* disable BULK throttle */
- xfer->interval = 0;
+ usbd_xfer_set_interval(xfer, 0);
sc->sc_zlps = 0;
}
- usb_fifo_put_data(f, xfer->frbuffers,
- 0, xfer->actlen, 1);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usb_fifo_put_data(f, pc, 0, actlen, 1);
case USB_ST_SETUP:
tr_setup:
if (usb_fifo_put_bytes_max(f) != 0) {
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
}
break;
default: /* Error */
/* disable BULK throttle */
- xfer->interval = 0;
+ usbd_xfer_set_interval(xfer, 0);
sc->sc_zlps = 0;
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
break;
@@ -281,17 +302,19 @@ tr_setup:
}
static void
-ulpt_status_callback(struct usb_xfer *xfer)
+ulpt_status_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct ulpt_softc *sc = xfer->priv_sc;
+ struct ulpt_softc *sc = usbd_xfer_softc(xfer);
struct usb_device_request req;
+ struct usb_page_cache *pc;
uint8_t cur_status;
uint8_t new_status;
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- usbd_copy_out(xfer->frbuffers + 1, 0, &cur_status, 1);
+ pc = usbd_xfer_get_frame(xfer, 1);
+ usbd_copy_out(pc, 0, &cur_status, 1);
cur_status = (cur_status ^ LPS_INVERT) & LPS_MASK;
new_status = cur_status & ~sc->sc_last_status;
@@ -316,17 +339,18 @@ ulpt_status_callback(struct usb_xfer *xfer)
req.wIndex[1] = 0;
USETW(req.wLength, 1);
- usbd_copy_in(xfer->frbuffers, 0, &req, sizeof(req));
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_in(pc, 0, &req, sizeof(req));
- xfer->frlengths[0] = sizeof(req);
- xfer->frlengths[1] = 1;
- xfer->nframes = 2;
+ usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
+ usbd_xfer_set_frame_len(xfer, 1, 1);
+ usbd_xfer_set_frames(xfer, 2);
usbd_transfer_submit(xfer);
break;
default: /* Error */
- DPRINTF("error=%s\n", usbd_errstr(xfer->error));
- if (xfer->error != USB_ERR_CANCELLED) {
+ DPRINTF("error=%s\n", usbd_errstr(error));
+ if (error != USB_ERR_CANCELLED) {
/* wait for next watchdog timeout */
}
break;
@@ -365,7 +389,7 @@ static const struct usb_config ulpt_config[ULPT_N_TRANSFER] = {
static void
ulpt_start_read(struct usb_fifo *fifo)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_RD]);
}
@@ -373,7 +397,7 @@ ulpt_start_read(struct usb_fifo *fifo)
static void
ulpt_stop_read(struct usb_fifo *fifo)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_RD]);
}
@@ -381,7 +405,7 @@ ulpt_stop_read(struct usb_fifo *fifo)
static void
ulpt_start_write(struct usb_fifo *fifo)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
usbd_transfer_start(sc->sc_xfer[ULPT_BULK_DT_WR]);
}
@@ -389,7 +413,7 @@ ulpt_start_write(struct usb_fifo *fifo)
static void
ulpt_stop_write(struct usb_fifo *fifo)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
usbd_transfer_stop(sc->sc_xfer[ULPT_BULK_DT_WR]);
}
@@ -397,7 +421,7 @@ ulpt_stop_write(struct usb_fifo *fifo)
static int
ulpt_open(struct usb_fifo *fifo, int fflags)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
/* we assume that open is a serial process */
@@ -410,7 +434,7 @@ ulpt_open(struct usb_fifo *fifo, int fflags)
static int
unlpt_open(struct usb_fifo *fifo, int fflags)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
if (sc->sc_fflags & fflags) {
return (EBUSY);
@@ -418,10 +442,10 @@ unlpt_open(struct usb_fifo *fifo, int fflags)
if (fflags & FREAD) {
/* clear stall first */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
if (usb_fifo_alloc_buffer(fifo,
- sc->sc_xfer[ULPT_BULK_DT_RD]->max_data_length,
+ usbd_xfer_max_len(sc->sc_xfer[ULPT_BULK_DT_RD]),
ULPT_IFQ_MAXLEN)) {
return (ENOMEM);
}
@@ -431,10 +455,10 @@ unlpt_open(struct usb_fifo *fifo, int fflags)
if (fflags & FWRITE) {
/* clear stall first */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[ULPT_BULK_DT_WR]);
mtx_unlock(&sc->sc_mtx);
if (usb_fifo_alloc_buffer(fifo,
- sc->sc_xfer[ULPT_BULK_DT_WR]->max_data_length,
+ usbd_xfer_max_len(sc->sc_xfer[ULPT_BULK_DT_WR]),
ULPT_IFQ_MAXLEN)) {
return (ENOMEM);
}
@@ -448,7 +472,7 @@ unlpt_open(struct usb_fifo *fifo, int fflags)
static void
ulpt_close(struct usb_fifo *fifo, int fflags)
{
- struct ulpt_softc *sc = fifo->priv_sc0;
+ struct ulpt_softc *sc = usb_fifo_softc(fifo);
sc->sc_fflags &= ~(fflags & (FREAD | FWRITE));
diff --git a/sys/dev/usb/serial/umct.c b/sys/dev/usb/serial/umct.c
index 879b09071846..557a511adc04 100644
--- a/sys/dev/usb/serial/umct.c
+++ b/sys/dev/usb/serial/umct.c
@@ -44,22 +44,34 @@ __FBSDID("$FreeBSD$");
* be called from within the config thread function !
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR usb_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_device.h>
#include <dev/usb/serial/usb_serial.h>
@@ -226,7 +238,7 @@ umct_attach(device_t dev)
struct usb_attach_arg *uaa = device_get_ivars(dev);
struct umct_softc *sc = device_get_softc(dev);
int32_t error;
- uint16_t maxp;
+ //uint16_t maxp;
uint8_t iface_index;
sc->sc_udev = uaa->device;
@@ -254,6 +266,7 @@ umct_attach(device_t dev)
* The only way to differentiate it from the real interrupt
* endpoint is to look at the wMaxPacketSize field.
*/
+#ifdef XXX
maxp = UGETW(sc->sc_xfer[UMCT_BULK_DT_RD]->endpoint->edesc->wMaxPacketSize);
if (maxp == 0x2) {
@@ -267,7 +280,8 @@ umct_attach(device_t dev)
sc->sc_xfer[UMCT_BULK_DT_RD]->callback = &umct_read_callback;
sc->sc_xfer[UMCT_INTR_DT_RD]->callback = &umct_intr_callback;
}
- sc->sc_obufsize = sc->sc_xfer[UMCT_BULK_DT_WR]->max_data_length;
+#endif
+ sc->sc_obufsize = usbd_xfer_max_len(sc->sc_xfer[UMCT_BULK_DT_WR]);
if (uaa->info.idProduct == USB_PRODUCT_MCT_SITECOM_USB232) {
if (sc->sc_obufsize > 16) {
@@ -326,18 +340,23 @@ umct_cfg_do_request(struct umct_softc *sc, uint8_t request,
}
static void
-umct_intr_callback(struct usb_xfer *xfer)
+umct_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umct_softc *sc = xfer->priv_sc;
+ struct umct_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[2];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
DPRINTF("too short message\n");
goto tr_setup;
}
- usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, sizeof(buf));
sc->sc_msr = buf[0];
sc->sc_lsr = buf[1];
@@ -346,14 +365,14 @@ umct_intr_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -526,27 +545,29 @@ umct_stop_write(struct ucom_softc *ucom)
}
static void
-umct_write_callback(struct usb_xfer *xfer)
+umct_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umct_softc *sc = xfer->priv_sc;
+ struct umct_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
sc->sc_obufsize, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -554,25 +575,29 @@ tr_setup:
}
static void
-umct_read_callback(struct usb_xfer *xfer)
+umct_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umct_softc *sc = xfer->priv_sc;
+ struct umct_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers,
- 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/umodem.c b/sys/dev/usb/serial/umodem.c
index e409d07e8ab2..fc658c5b6649 100644
--- a/sys/dev/usb/serial/umodem.c
+++ b/sys/dev/usb/serial/umodem.c
@@ -80,23 +80,38 @@ __FBSDID("$FreeBSD$");
*
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usbhid.h>
#include <dev/usb/usb_cdc.h>
+#include "usbdevs.h"
+
#include <dev/usb/usb_ioctl.h>
#define USB_DEBUG_VAR umodem_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_device.h>
#include <dev/usb/serial/usb_serial.h>
@@ -353,8 +368,8 @@ umodem_attach(device_t dev)
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -600,31 +615,36 @@ umodem_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
}
static void
-umodem_intr_callback(struct usb_xfer *xfer)
+umodem_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
struct usb_cdc_notification pkt;
- struct umodem_softc *sc = xfer->priv_sc;
+ struct umodem_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint16_t wLen;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 8) {
+ if (actlen < 8) {
DPRINTF("received short packet, "
- "%d bytes\n", xfer->actlen);
+ "%d bytes\n", actlen);
goto tr_setup;
}
- if (xfer->actlen > sizeof(pkt)) {
+ if (actlen > sizeof(pkt)) {
DPRINTF("truncating message\n");
- xfer->actlen = sizeof(pkt);
+ actlen = sizeof(pkt);
}
- usbd_copy_out(xfer->frbuffers, 0, &pkt, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, &pkt, actlen);
- xfer->actlen -= 8;
+ actlen -= 8;
wLen = UGETW(pkt.wLength);
- if (xfer->actlen > wLen) {
- xfer->actlen = wLen;
+ if (actlen > wLen) {
+ actlen = wLen;
}
if (pkt.bmRequestType != UCDC_NOTIFICATION) {
DPRINTF("unknown message type, "
@@ -638,9 +658,9 @@ umodem_intr_callback(struct usb_xfer *xfer)
* Set the serial state in ucom driver based on
* the bits from the notify message
*/
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
DPRINTF("invalid notification "
- "length, %d bytes!\n", xfer->actlen);
+ "length, %d bytes!\n", actlen);
break;
}
DPRINTF("notify bytes = %02x%02x\n",
@@ -671,14 +691,14 @@ umodem_intr_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -687,27 +707,29 @@ tr_setup:
}
static void
-umodem_write_callback(struct usb_xfer *xfer)
+umodem_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umodem_softc *sc = xfer->priv_sc;
+ struct umodem_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UMODEM_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -715,28 +737,32 @@ tr_setup:
}
static void
-umodem_read_callback(struct usb_xfer *xfer)
+umodem_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umodem_softc *sc = xfer->priv_sc;
+ struct umodem_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- DPRINTF("actlen=%d\n", xfer->actlen);
+ DPRINTF("actlen=%d\n", actlen);
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0,
- xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/umoscom.c b/sys/dev/usb/serial/umoscom.c
index 7fd52c31f641..47f70f1f4d3a 100644
--- a/sys/dev/usb/serial/umoscom.c
+++ b/sys/dev/usb/serial/umoscom.c
@@ -17,21 +17,34 @@
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR umoscom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -313,8 +326,8 @@ umoscom_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UMOSCOM_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -583,9 +596,10 @@ umoscom_stop_write(struct ucom_softc *ucom)
}
static void
-umoscom_write_callback(struct usb_xfer *xfer)
+umoscom_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umoscom_softc *sc = xfer->priv_sc;
+ struct umoscom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
@@ -594,19 +608,20 @@ umoscom_write_callback(struct usb_xfer *xfer)
tr_setup:
DPRINTF("\n");
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UMOSCOM_BUFSIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
DPRINTFN(0, "transfer failed\n");
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -614,28 +629,33 @@ tr_setup:
}
static void
-umoscom_read_callback(struct usb_xfer *xfer)
+umoscom_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umoscom_softc *sc = xfer->priv_sc;
+ struct umoscom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- DPRINTF("got %d bytes\n", xfer->actlen);
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ DPRINTF("got %d bytes\n", actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
DPRINTF("\n");
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
DPRINTFN(0, "transfer failed\n");
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -643,13 +663,16 @@ tr_setup:
}
static void
-umoscom_intr_callback(struct usb_xfer *xfer)
+umoscom_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct umoscom_softc *sc = xfer->priv_sc;
+ struct umoscom_softc *sc = usbd_xfer_softc(xfer);
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen < 2) {
+ if (actlen < 2) {
DPRINTF("too short message\n");
goto tr_setup;
}
@@ -657,15 +680,15 @@ umoscom_intr_callback(struct usb_xfer *xfer)
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
DPRINTFN(0, "transfer failed\n");
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uplcom.c b/sys/dev/usb/serial/uplcom.c
index 0604b42fb9e1..399792f1ef15 100644
--- a/sys/dev/usb/serial/uplcom.c
+++ b/sys/dev/usb/serial/uplcom.c
@@ -84,21 +84,35 @@ __FBSDID("$FreeBSD$");
* documented in the datasheet.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
#include <dev/usb/usb_cdc.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uplcom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -389,8 +403,8 @@ uplcom_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -736,19 +750,24 @@ uplcom_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
}
static void
-uplcom_intr_callback(struct usb_xfer *xfer)
+uplcom_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uplcom_softc *sc = xfer->priv_sc;
+ struct uplcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[9];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- DPRINTF("actlen = %u\n", xfer->actlen);
+ DPRINTF("actlen = %u\n", actlen);
- if (xfer->actlen >= 9) {
+ if (actlen >= 9) {
- usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, sizeof(buf));
DPRINTF("status = 0x%02x\n", buf[8]);
@@ -768,14 +787,14 @@ uplcom_intr_callback(struct usb_xfer *xfer)
}
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -783,29 +802,31 @@ tr_setup:
}
static void
-uplcom_write_callback(struct usb_xfer *xfer)
+uplcom_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uplcom_softc *sc = xfer->priv_sc;
+ struct uplcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UPLCOM_BULK_BUF_SIZE, &actlen)) {
DPRINTF("actlen = %d\n", actlen);
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -813,24 +834,29 @@ tr_setup:
}
static void
-uplcom_read_callback(struct usb_xfer *xfer)
+uplcom_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uplcom_softc *sc = xfer->priv_sc;
+ struct uplcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/usb_serial.c b/sys/dev/usb/serial/usb_serial.c
index d6c4c1abd6da..e1b68d69d4f8 100644
--- a/sys/dev/usb/serial/usb_serial.c
+++ b/sys/dev/usb/serial/usb_serial.c
@@ -67,20 +67,34 @@ __FBSDID("$FreeBSD$");
* POSSIBILITY OF SUCH DAMAGE.
*/
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
-#include <dev/usb/usb_ioctl.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
#define USB_DEBUG_VAR ucom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
-#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
#include <dev/usb/usb_busdma.h>
-#include <dev/usb/usb_util.h>
+#include <dev/usb/usb_process.h>
#include <dev/usb/serial/usb_serial.h>
diff --git a/sys/dev/usb/serial/uslcom.c b/sys/dev/usb/serial/uslcom.c
index 2047cb292539..c319dfd74e54 100644
--- a/sys/dev/usb/serial/uslcom.c
+++ b/sys/dev/usb/serial/uslcom.c
@@ -19,20 +19,34 @@ __FBSDID("$FreeBSD$");
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uslcom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -242,8 +256,8 @@ uslcom_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -454,29 +468,31 @@ uslcom_set_break(struct ucom_softc *ucom, uint8_t onoff)
}
static void
-uslcom_write_callback(struct usb_xfer *xfer)
+uslcom_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uslcom_softc *sc = xfer->priv_sc;
+ struct uslcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
USLCOM_BULK_BUF_SIZE, &actlen)) {
DPRINTF("actlen = %d\n", actlen);
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -484,24 +500,29 @@ tr_setup:
}
static void
-uslcom_read_callback(struct usb_xfer *xfer)
+uslcom_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uslcom_softc *sc = xfer->priv_sc;
+ struct uslcom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uvisor.c b/sys/dev/usb/serial/uvisor.c
index 1e39947ae798..c7175e31a630 100644
--- a/sys/dev/usb/serial/uvisor.c
+++ b/sys/dev/usb/serial/uvisor.c
@@ -54,22 +54,34 @@
* Handspring Visor (Palmpilot compatible PDA) driver
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
-#include <dev/usb/usb_ioctl.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uvisor_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -324,8 +336,8 @@ uvisor_attach(device_t dev)
}
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UVISOR_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -562,27 +574,29 @@ uvisor_stop_write(struct ucom_softc *ucom)
}
static void
-uvisor_write_callback(struct usb_xfer *xfer)
+uvisor_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uvisor_softc *sc = xfer->priv_sc;
+ struct uvisor_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UVISOR_BUFSIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -590,24 +604,29 @@ tr_setup:
}
static void
-uvisor_read_callback(struct usb_xfer *xfer)
+uvisor_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uvisor_softc *sc = xfer->priv_sc;
+ struct uvisor_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
diff --git a/sys/dev/usb/serial/uvscom.c b/sys/dev/usb/serial/uvscom.c
index 40b09a655ffa..27f3919b286a 100644
--- a/sys/dev/usb/serial/uvscom.c
+++ b/sys/dev/usb/serial/uvscom.c
@@ -37,21 +37,34 @@ __FBSDID("$FreeBSD$");
* P-in m@ater and various data communication card adapters.
*/
-#include "usbdevs.h"
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
#include <dev/usb/usb.h>
-#include <dev/usb/usb_mfunc.h>
-#include <dev/usb/usb_error.h>
-#include <dev/usb/usb_cdc.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include "usbdevs.h"
#define USB_DEBUG_VAR uvscom_debug
-
-#include <dev/usb/usb_core.h>
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_process.h>
-#include <dev/usb/usb_request.h>
-#include <dev/usb/usb_lookup.h>
-#include <dev/usb/usb_util.h>
-#include <dev/usb/usb_busdma.h>
#include <dev/usb/serial/usb_serial.h>
@@ -297,8 +310,8 @@ uvscom_attach(device_t dev)
/* clear stall at first run */
mtx_lock(&sc->sc_mtx);
- usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
- usbd_transfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
+ usbd_xfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_WR]);
+ usbd_xfer_set_stall(sc->sc_xfer[UVSCOM_BULK_DT_RD]);
mtx_unlock(&sc->sc_mtx);
error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
@@ -338,27 +351,29 @@ uvscom_detach(device_t dev)
}
static void
-uvscom_write_callback(struct usb_xfer *xfer)
+uvscom_write_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uvscom_softc *sc = xfer->priv_sc;
+ struct uvscom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint32_t actlen;
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
case USB_ST_TRANSFERRED:
tr_setup:
- if (ucom_get_data(&sc->sc_ucom, xfer->frbuffers, 0,
+ pc = usbd_xfer_get_frame(xfer, 0);
+ if (ucom_get_data(&sc->sc_ucom, pc, 0,
UVSCOM_BULK_BUF_SIZE, &actlen)) {
- xfer->frlengths[0] = actlen;
+ usbd_xfer_set_frame_len(xfer, 0, actlen);
usbd_transfer_submit(xfer);
}
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -366,24 +381,29 @@ tr_setup:
}
static void
-uvscom_read_callback(struct usb_xfer *xfer)
+uvscom_read_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uvscom_softc *sc = xfer->priv_sc;
+ struct uvscom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- ucom_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
@@ -391,16 +411,21 @@ tr_setup:
}
static void
-uvscom_intr_callback(struct usb_xfer *xfer)
+uvscom_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
- struct uvscom_softc *sc = xfer->priv_sc;
+ struct uvscom_softc *sc = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
uint8_t buf[2];
+ int actlen;
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
switch (USB_GET_STATE(xfer)) {
case USB_ST_TRANSFERRED:
- if (xfer->actlen >= 2) {
+ if (actlen >= 2) {
- usbd_copy_out(xfer->frbuffers, 0, buf, sizeof(buf));
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, buf, sizeof(buf));
sc->sc_lsr = 0;
sc->sc_msr = 0;
@@ -429,14 +454,14 @@ uvscom_intr_callback(struct usb_xfer *xfer)
}
case USB_ST_SETUP:
tr_setup:
- xfer->frlengths[0] = xfer->max_data_length;
+ usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
usbd_transfer_submit(xfer);
return;
default: /* Error */
- if (xfer->error != USB_ERR_CANCELLED) {
+ if (error != USB_ERR_CANCELLED) {
/* try to clear stall first */
- xfer->flags.stall_pipe = 1;
+ usbd_xfer_set_stall(xfer);
goto tr_setup;
}
return;
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-28 20:27:37 +0000