From 4eae601ebd1cb2311c79f5e179c235350252b96b Mon Sep 17 00:00:00 2001 From: Andrew Thompson Date: Sun, 5 Apr 2009 18:20:38 +0000 Subject: MFp4 //depot/projects/usb@159909 - make usb2_power_mask_t 16-bit - remove "usb2_config_sub" structure from "usb2_config". To compensate for this "usb2_config" has a new field called "usb_mode" which select for which mode the current xfer entry is active. Options are: a) Device mode only b) Host mode only (default-by-zero) c) Both modes. This change was scripted using the following sed script: "s/\.mh\././g". - the standard packet size table in "usb_transfer.c" is now a function, hence the code for the function uses less memory than the table itself. Submitted by: Hans Petter Selasky --- sys/dev/sound/usb/uaudio.c | 70 +++++------ sys/dev/usb/bluetooth/ng_ubt.c | 56 ++++----- sys/dev/usb/bluetooth/ubtbcmfw.c | 12 +- sys/dev/usb/controller/usb_controller.c | 15 ++- sys/dev/usb/input/uhid.c | 18 +-- sys/dev/usb/input/ukbd.c | 20 ++-- sys/dev/usb/input/ums.c | 6 +- sys/dev/usb/misc/udbp.c | 30 ++--- sys/dev/usb/net/if_aue.c | 20 ++-- sys/dev/usb/net/if_axe.c | 22 ++-- sys/dev/usb/net/if_cdce.c | 94 +++++++-------- sys/dev/usb/net/if_cdcereg.h | 7 +- sys/dev/usb/net/if_cue.c | 14 +-- sys/dev/usb/net/if_kue.c | 16 +-- sys/dev/usb/net/if_rue.c | 22 ++-- sys/dev/usb/net/if_udav.c | 22 ++-- sys/dev/usb/serial/u3g.c | 12 +- sys/dev/usb/serial/uark.c | 12 +- sys/dev/usb/serial/ubsa.c | 18 +-- sys/dev/usb/serial/ubser.c | 12 +- sys/dev/usb/serial/uchcom.c | 18 +-- sys/dev/usb/serial/ucycom.c | 12 +- sys/dev/usb/serial/ufoma.c | 32 ++--- sys/dev/usb/serial/uftdi.c | 12 +- sys/dev/usb/serial/ugensa.c | 12 +- sys/dev/usb/serial/uipaq.c | 12 +- sys/dev/usb/serial/ulpt.c | 18 +-- sys/dev/usb/serial/umct.c | 18 +-- sys/dev/usb/serial/umodem.c | 18 +-- sys/dev/usb/serial/umoscom.c | 18 +-- sys/dev/usb/serial/uplcom.c | 18 +-- sys/dev/usb/serial/uslcom.c | 12 +- sys/dev/usb/serial/uvisor.c | 12 +- sys/dev/usb/serial/uvscom.c | 18 +-- sys/dev/usb/storage/umass.c | 138 +++++++++++----------- sys/dev/usb/storage/urio.c | 28 ++--- sys/dev/usb/usb_compat_linux.c | 22 ++-- sys/dev/usb/usb_core.h | 35 +++--- sys/dev/usb/usb_device.c | 9 +- sys/dev/usb/usb_device.h | 1 - sys/dev/usb/usb_generic.c | 90 +++++++------- sys/dev/usb/usb_handle_request.c | 2 - sys/dev/usb/usb_hub.c | 34 ++++-- sys/dev/usb/usb_hub.h | 2 + sys/dev/usb/usb_msctest.c | 42 +++---- sys/dev/usb/usb_request.c | 13 ++- sys/dev/usb/usb_transfer.c | 200 ++++++++++++++++++++------------ sys/dev/usb/usb_transfer.h | 1 - sys/dev/usb/wlan/if_rum.c | 14 +-- sys/dev/usb/wlan/if_ural.c | 14 +-- sys/dev/usb/wlan/if_zyd.c | 28 ++--- 51 files changed, 744 insertions(+), 657 deletions(-) (limited to 'sys/dev') diff --git a/sys/dev/sound/usb/uaudio.c b/sys/dev/sound/usb/uaudio.c index 50728ee5dc80..50866dabec9b 100644 --- a/sys/dev/sound/usb/uaudio.c +++ b/sys/dev/sound/usb/uaudio.c @@ -400,20 +400,20 @@ static const struct usb2_config .type = UE_ISOCHRONOUS, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UAUDIO_MINFRAMES, - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &uaudio_chan_record_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UAUDIO_MINFRAMES, + .flags = {.short_xfer_ok = 1,}, + .callback = &uaudio_chan_record_callback, }, [1] = { .type = UE_ISOCHRONOUS, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UAUDIO_MINFRAMES, - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &uaudio_chan_record_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UAUDIO_MINFRAMES, + .flags = {.short_xfer_ok = 1,}, + .callback = &uaudio_chan_record_callback, }, }; @@ -423,20 +423,20 @@ static const struct usb2_config .type = UE_ISOCHRONOUS, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UAUDIO_MINFRAMES, - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &uaudio_chan_play_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UAUDIO_MINFRAMES, + .flags = {.short_xfer_ok = 1,}, + .callback = &uaudio_chan_play_callback, }, [1] = { .type = UE_ISOCHRONOUS, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UAUDIO_MINFRAMES, - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &uaudio_chan_play_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UAUDIO_MINFRAMES, + .flags = {.short_xfer_ok = 1,}, + .callback = &uaudio_chan_play_callback, }, }; @@ -446,9 +446,9 @@ static const struct usb2_config .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + 4), - .mh.callback = &uaudio_mixer_write_cfg_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = (sizeof(struct usb2_device_request) + 4), + .callback = &uaudio_mixer_write_cfg_callback, + .timeout = 1000, /* 1 second */ }, }; @@ -478,40 +478,40 @@ static const struct usb2_config .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UMIDI_BULK_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &umidi_bulk_write_callback, + .bufsize = UMIDI_BULK_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &umidi_bulk_write_callback, }, [1] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UMIDI_BULK_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &umidi_bulk_read_callback, + .bufsize = UMIDI_BULK_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &umidi_bulk_read_callback, }, [2] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.flags = {}, - .mh.callback = &umidi_write_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .flags = {}, + .callback = &umidi_write_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, [3] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.flags = {}, - .mh.callback = &umidi_read_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .flags = {}, + .callback = &umidi_read_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, }; diff --git a/sys/dev/usb/bluetooth/ng_ubt.c b/sys/dev/usb/bluetooth/ng_ubt.c index 149e1cf120de..a5a19ded53dd 100644 --- a/sys/dev/usb/bluetooth/ng_ubt.c +++ b/sys/dev/usb/bluetooth/ng_ubt.c @@ -276,9 +276,9 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, .if_index = 0, - .mh.bufsize = UBT_BULK_WRITE_BUFFER_SIZE, - .mh.flags = { .pipe_bof = 1, .force_short_xfer = 1, }, - .mh.callback = &ubt_bulk_write_callback, + .bufsize = UBT_BULK_WRITE_BUFFER_SIZE, + .flags = { .pipe_bof = 1, .force_short_xfer = 1, }, + .callback = &ubt_bulk_write_callback, }, /* Incoming bulk transfer - ACL packets */ [UBT_IF_0_BULK_DT_RD] = { @@ -286,9 +286,9 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 0, - .mh.bufsize = UBT_BULK_READ_BUFFER_SIZE, - .mh.flags = { .pipe_bof = 1, .short_xfer_ok = 1, }, - .mh.callback = &ubt_bulk_read_callback, + .bufsize = UBT_BULK_READ_BUFFER_SIZE, + .flags = { .pipe_bof = 1, .short_xfer_ok = 1, }, + .callback = &ubt_bulk_read_callback, }, /* Incoming interrupt transfer - HCI events */ [UBT_IF_0_INTR_DT_RD] = { @@ -296,9 +296,9 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 0, - .mh.flags = { .pipe_bof = 1, .short_xfer_ok = 1, }, - .mh.bufsize = UBT_INTR_BUFFER_SIZE, - .mh.callback = &ubt_intr_read_callback, + .flags = { .pipe_bof = 1, .short_xfer_ok = 1, }, + .bufsize = UBT_INTR_BUFFER_SIZE, + .callback = &ubt_intr_read_callback, }, /* Outgoing control transfer - HCI commands */ [UBT_IF_0_CTRL_DT_WR] = { @@ -306,9 +306,9 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = 0x00, /* control pipe */ .direction = UE_DIR_ANY, .if_index = 0, - .mh.bufsize = UBT_CTRL_BUFFER_SIZE, - .mh.callback = &ubt_ctrl_write_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = UBT_CTRL_BUFFER_SIZE, + .callback = &ubt_ctrl_write_callback, + .timeout = 5000, /* 5 seconds */ }, /* @@ -321,10 +321,10 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 1, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UBT_ISOC_NFRAMES, - .mh.flags = { .short_xfer_ok = 1, }, - .mh.callback = &ubt_isoc_read_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UBT_ISOC_NFRAMES, + .flags = { .short_xfer_ok = 1, }, + .callback = &ubt_isoc_read_callback, }, /* Incoming isochronous transfer #2 - SCO packets */ [UBT_IF_1_ISOC_DT_RD2] = { @@ -332,10 +332,10 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 1, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UBT_ISOC_NFRAMES, - .mh.flags = { .short_xfer_ok = 1, }, - .mh.callback = &ubt_isoc_read_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UBT_ISOC_NFRAMES, + .flags = { .short_xfer_ok = 1, }, + .callback = &ubt_isoc_read_callback, }, /* Outgoing isochronous transfer #1 - SCO packets */ [UBT_IF_1_ISOC_DT_WR1] = { @@ -343,10 +343,10 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, .if_index = 1, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UBT_ISOC_NFRAMES, - .mh.flags = { .short_xfer_ok = 1, }, - .mh.callback = &ubt_isoc_write_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UBT_ISOC_NFRAMES, + .flags = { .short_xfer_ok = 1, }, + .callback = &ubt_isoc_write_callback, }, /* Outgoing isochronous transfer #2 - SCO packets */ [UBT_IF_1_ISOC_DT_WR2] = { @@ -354,10 +354,10 @@ static const struct usb2_config ubt_config[UBT_N_TRANSFER] = .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, .if_index = 1, - .mh.bufsize = 0, /* use "wMaxPacketSize * frames" */ - .mh.frames = UBT_ISOC_NFRAMES, - .mh.flags = { .short_xfer_ok = 1, }, - .mh.callback = &ubt_isoc_write_callback, + .bufsize = 0, /* use "wMaxPacketSize * frames" */ + .frames = UBT_ISOC_NFRAMES, + .flags = { .short_xfer_ok = 1, }, + .callback = &ubt_isoc_write_callback, }, }; diff --git a/sys/dev/usb/bluetooth/ubtbcmfw.c b/sys/dev/usb/bluetooth/ubtbcmfw.c index bfa390f1a2ea..1932a3971a95 100644 --- a/sys/dev/usb/bluetooth/ubtbcmfw.c +++ b/sys/dev/usb/bluetooth/ubtbcmfw.c @@ -118,10 +118,10 @@ static const struct usb2_config ubtbcmfw_config[UBTBCMFW_N_TRANSFER] = .endpoint = 0x02, /* fixed */ .direction = UE_DIR_OUT, .if_index = UBTBCMFW_IFACE_IDX, - .mh.bufsize = UBTBCMFW_BSIZE, - .mh.flags = { .pipe_bof = 1, .force_short_xfer = 1, + .bufsize = UBTBCMFW_BSIZE, + .flags = { .pipe_bof = 1, .force_short_xfer = 1, .proxy_buffer = 1, }, - .mh.callback = &ubtbcmfw_write_callback, + .callback = &ubtbcmfw_write_callback, }, [UBTBCMFW_INTR_DT_RD] = { @@ -129,10 +129,10 @@ static const struct usb2_config ubtbcmfw_config[UBTBCMFW_N_TRANSFER] = .endpoint = 0x01, /* fixed */ .direction = UE_DIR_IN, .if_index = UBTBCMFW_IFACE_IDX, - .mh.bufsize = UBTBCMFW_BSIZE, - .mh.flags = { .pipe_bof = 1, .short_xfer_ok = 1, + .bufsize = UBTBCMFW_BSIZE, + .flags = { .pipe_bof = 1, .short_xfer_ok = 1, .proxy_buffer = 1, }, - .mh.callback = &ubtbcmfw_read_callback, + .callback = &ubtbcmfw_read_callback, }, }; diff --git a/sys/dev/usb/controller/usb_controller.c b/sys/dev/usb/controller/usb_controller.c index 28b99d367951..7ae0ce83605e 100644 --- a/sys/dev/usb/controller/usb_controller.c +++ b/sys/dev/usb/controller/usb_controller.c @@ -209,7 +209,6 @@ usb2_bus_explore(struct usb2_proc_msg *pm) * First update the USB power state! */ usb2_bus_powerd(bus); - /* * Explore the Root USB HUB. This call can sleep, * exiting Giant, which is actually Giant. @@ -328,6 +327,20 @@ usb2_bus_attach(struct usb2_proc_msg *pm) USB_BUS_UNLOCK(bus); mtx_lock(&Giant); /* XXX not required by USB */ + /* default power_mask value */ + bus->hw_power_state = + USB_HW_POWER_CONTROL | + USB_HW_POWER_BULK | + USB_HW_POWER_INTERRUPT | + USB_HW_POWER_ISOC | + USB_HW_POWER_NON_ROOT_HUB; + + /* make sure power is set at least once */ + + if (bus->methods->set_hw_power != NULL) { + (bus->methods->set_hw_power) (bus); + } + /* Allocate the Root USB device */ child = usb2_alloc_device(bus->bdev, bus, NULL, 0, 0, 1, diff --git a/sys/dev/usb/input/uhid.c b/sys/dev/usb/input/uhid.c index b6fa631fd31c..78931bdb7c48 100644 --- a/sys/dev/usb/input/uhid.c +++ b/sys/dev/usb/input/uhid.c @@ -316,27 +316,27 @@ static const struct usb2_config uhid_config[UHID_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = UHID_BSIZE, - .mh.callback = &uhid_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = UHID_BSIZE, + .callback = &uhid_intr_callback, }, [UHID_CTRL_DT_WR] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE, - .mh.callback = &uhid_write_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE, + .callback = &uhid_write_callback, + .timeout = 1000, /* 1 second */ }, [UHID_CTRL_DT_RD] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE, - .mh.callback = &uhid_read_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request) + UHID_BSIZE, + .callback = &uhid_read_callback, + .timeout = 1000, /* 1 second */ }, }; diff --git a/sys/dev/usb/input/ukbd.c b/sys/dev/usb/input/ukbd.c index df81ad9b799d..58e815169a73 100644 --- a/sys/dev/usb/input/ukbd.c +++ b/sys/dev/usb/input/ukbd.c @@ -562,28 +562,28 @@ static const struct usb2_config ukbd_config[UKBD_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &ukbd_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &ukbd_intr_callback, }, [UKBD_INTR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &ukbd_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &ukbd_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, [UKBD_CTRL_LED] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request) + 1, - .mh.callback = &ukbd_set_leds_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request) + 1, + .callback = &ukbd_set_leds_callback, + .timeout = 1000, /* 1 second */ }, }; diff --git a/sys/dev/usb/input/ums.c b/sys/dev/usb/input/ums.c index 9539e20905d2..04c0a0bb1054 100644 --- a/sys/dev/usb/input/ums.c +++ b/sys/dev/usb/input/ums.c @@ -312,9 +312,9 @@ static const struct usb2_config ums_config[UMS_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &ums_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &ums_intr_callback, }, }; diff --git a/sys/dev/usb/misc/udbp.c b/sys/dev/usb/misc/udbp.c index cba9780a7d44..e8acba81cfe8 100644 --- a/sys/dev/usb/misc/udbp.c +++ b/sys/dev/usb/misc/udbp.c @@ -192,39 +192,39 @@ static const struct usb2_config udbp_config[UDBP_T_MAX] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UDBP_BUFFERSIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &udbp_bulk_write_callback, - .mh.timeout = UDBP_TIMEOUT, + .bufsize = UDBP_BUFFERSIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &udbp_bulk_write_callback, + .timeout = UDBP_TIMEOUT, }, [UDBP_T_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UDBP_BUFFERSIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &udbp_bulk_read_callback, + .bufsize = UDBP_BUFFERSIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &udbp_bulk_read_callback, }, [UDBP_T_WR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &udbp_bulk_write_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &udbp_bulk_write_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, [UDBP_T_RD_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &udbp_bulk_read_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &udbp_bulk_read_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, }; diff --git a/sys/dev/usb/net/if_aue.c b/sys/dev/usb/net/if_aue.c index b014b01a0ace..ca72948f1507 100644 --- a/sys/dev/usb/net/if_aue.c +++ b/sys/dev/usb/net/if_aue.c @@ -209,28 +209,28 @@ static const struct usb2_config aue_config[AUE_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (MCLBYTES + 2), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = aue_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = (MCLBYTES + 2), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = aue_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [AUE_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = aue_bulk_read_callback, + .bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = aue_bulk_read_callback, }, [AUE_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = aue_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = aue_intr_callback, }, }; diff --git a/sys/dev/usb/net/if_axe.c b/sys/dev/usb/net/if_axe.c index 43ac676b79be..c0db84b0995a 100644 --- a/sys/dev/usb/net/if_axe.c +++ b/sys/dev/usb/net/if_axe.c @@ -182,10 +182,10 @@ static const struct usb2_config axe_config[AXE_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = AXE_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = axe_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = AXE_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = axe_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [AXE_BULK_DT_RD] = { @@ -195,19 +195,19 @@ static const struct usb2_config axe_config[AXE_N_TRANSFER] = { #if (MCLBYTES < 2048) #error "(MCLBYTES < 2048)" #endif - .mh.bufsize = MCLBYTES, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = axe_bulk_read_callback, - .mh.timeout = 0, /* no timeout */ + .bufsize = MCLBYTES, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = axe_bulk_read_callback, + .timeout = 0, /* no timeout */ }, [AXE_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = axe_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = axe_intr_callback, }, }; diff --git a/sys/dev/usb/net/if_cdce.c b/sys/dev/usb/net/if_cdce.c index 8e7aae44e127..9a9cb37da56f 100644 --- a/sys/dev/usb/net/if_cdce.c +++ b/sys/dev/usb/net/if_cdce.c @@ -96,59 +96,54 @@ SYSCTL_INT(_hw_usb2_cdce, OID_AUTO, debug, CTLFLAG_RW, &cdce_debug, 0, static const struct usb2_config cdce_config[CDCE_N_TRANSFER] = { - [CDCE_BULK_A] = { + [CDCE_BULK_RX] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, - .direction = UE_DIR_OUT, + .direction = UE_DIR_RX, .if_index = 0, - /* Host Mode */ - .mh.frames = CDCE_FRAMES_MAX, - .mh.bufsize = (CDCE_FRAMES_MAX * MCLBYTES), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,}, - .mh.callback = cdce_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ - /* Device Mode */ - .md.frames = CDCE_FRAMES_MAX, - .md.bufsize = (CDCE_FRAMES_MAX * MCLBYTES), - .md.flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,}, - .md.callback = cdce_bulk_read_callback, - .md.timeout = 0, /* no timeout */ + .frames = CDCE_FRAMES_MAX, + .bufsize = (CDCE_FRAMES_MAX * MCLBYTES), + .flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,}, + .callback = cdce_bulk_read_callback, + .timeout = 0, /* no timeout */ + .usb_mode = USB_MODE_MAX, /* both modes */ }, - [CDCE_BULK_B] = { + [CDCE_BULK_TX] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, - .direction = UE_DIR_IN, + .direction = UE_DIR_TX, .if_index = 0, - /* Host Mode */ - .mh.frames = CDCE_FRAMES_MAX, - .mh.bufsize = (CDCE_FRAMES_MAX * MCLBYTES), - .mh.flags = {.pipe_bof = 1,.short_frames_ok = 1,.short_xfer_ok = 1,.ext_buffer = 1,}, - .mh.callback = cdce_bulk_read_callback, - .mh.timeout = 0, /* no timeout */ - /* Device Mode */ - .md.frames = CDCE_FRAMES_MAX, - .md.bufsize = (CDCE_FRAMES_MAX * MCLBYTES), - .md.flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,}, - .md.callback = cdce_bulk_write_callback, - .md.timeout = 10000, /* 10 seconds */ + .frames = CDCE_FRAMES_MAX, + .bufsize = (CDCE_FRAMES_MAX * MCLBYTES), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,.ext_buffer = 1,}, + .callback = cdce_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ + .usb_mode = USB_MODE_MAX, /* both modes */ }, - [CDCE_INTR] = { + [CDCE_INTR_RX] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, - .direction = UE_DIR_IN, + .direction = UE_DIR_RX, .if_index = 1, - /* Host Mode */ - .mh.bufsize = CDCE_IND_SIZE_MAX, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,}, - .mh.callback = cdce_intr_read_callback, - .mh.timeout = 0, - /* Device Mode */ - .md.bufsize = CDCE_IND_SIZE_MAX, - .md.flags = {.pipe_bof = 1,.force_short_xfer = 1,.no_pipe_ok = 1,}, - .md.callback = cdce_intr_write_callback, - .md.timeout = 10000, /* 10 seconds */ + .bufsize = CDCE_IND_SIZE_MAX, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,}, + .callback = cdce_intr_read_callback, + .timeout = 0, + .usb_mode = USB_MODE_HOST, + }, + + [CDCE_INTR_TX] = { + .type = UE_INTERRUPT, + .endpoint = UE_ADDR_ANY, + .direction = UE_DIR_TX, + .if_index = 1, + .bufsize = CDCE_IND_SIZE_MAX, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,.no_pipe_ok = 1,}, + .callback = cdce_intr_write_callback, + .timeout = 10000, /* 10 seconds */ + .usb_mode = USB_MODE_DEVICE, }, }; @@ -416,8 +411,8 @@ cdce_start(struct usb2_ether *ue) /* * Start the USB transfers, if not already started: */ - usb2_transfer_start(sc->sc_xfer[CDCE_BULK_B]); - usb2_transfer_start(sc->sc_xfer[CDCE_BULK_A]); + usb2_transfer_start(sc->sc_xfer[CDCE_BULK_TX]); + usb2_transfer_start(sc->sc_xfer[CDCE_BULK_RX]); } static void @@ -557,13 +552,11 @@ cdce_init(struct usb2_ether *ue) ifp->if_drv_flags |= IFF_DRV_RUNNING; /* start interrupt transfer */ - usb2_transfer_start(sc->sc_xfer[CDCE_INTR]); + usb2_transfer_start(sc->sc_xfer[CDCE_INTR_RX]); + usb2_transfer_start(sc->sc_xfer[CDCE_INTR_TX]); /* stall data write direction, which depends on USB mode */ - if (usb2_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST) - usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_A]); - else - usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_B]); + usb2_transfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]); /* start data transfers */ cdce_start(ue); @@ -582,9 +575,10 @@ cdce_stop(struct usb2_ether *ue) /* * stop all the transfers, if not already stopped: */ - usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_A]); - usb2_transfer_stop(sc->sc_xfer[CDCE_BULK_B]); - usb2_transfer_stop(sc->sc_xfer[CDCE_INTR]); + 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]); } static void diff --git a/sys/dev/usb/net/if_cdcereg.h b/sys/dev/usb/net/if_cdcereg.h index dac512196fdd..0bcdde77352e 100644 --- a/sys/dev/usb/net/if_cdcereg.h +++ b/sys/dev/usb/net/if_cdcereg.h @@ -39,9 +39,10 @@ #define CDCE_IND_SIZE_MAX 32 /* bytes */ enum { - CDCE_BULK_A, - CDCE_BULK_B, - CDCE_INTR, + CDCE_BULK_RX, + CDCE_BULK_TX, + CDCE_INTR_RX, + CDCE_INTR_TX, CDCE_N_TRANSFER, }; diff --git a/sys/dev/usb/net/if_cue.c b/sys/dev/usb/net/if_cue.c index 54bff1de79e9..10fd03884a77 100644 --- a/sys/dev/usb/net/if_cue.c +++ b/sys/dev/usb/net/if_cue.c @@ -121,19 +121,19 @@ static const struct usb2_config cue_config[CUE_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (MCLBYTES + 2), - .mh.flags = {.pipe_bof = 1,}, - .mh.callback = cue_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = (MCLBYTES + 2), + .flags = {.pipe_bof = 1,}, + .callback = cue_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [CUE_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + 2), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = cue_bulk_read_callback, + .bufsize = (MCLBYTES + 2), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = cue_bulk_read_callback, }, }; diff --git a/sys/dev/usb/net/if_kue.c b/sys/dev/usb/net/if_kue.c index 8a648a4a978f..3056692c0d9f 100644 --- a/sys/dev/usb/net/if_kue.c +++ b/sys/dev/usb/net/if_kue.c @@ -163,20 +163,20 @@ static const struct usb2_config kue_config[KUE_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (MCLBYTES + 2 + 64), - .mh.flags = {.pipe_bof = 1,}, - .mh.callback = kue_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = (MCLBYTES + 2 + 64), + .flags = {.pipe_bof = 1,}, + .callback = kue_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [KUE_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + 2), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = kue_bulk_read_callback, - .mh.timeout = 0, /* no timeout */ + .bufsize = (MCLBYTES + 2), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = kue_bulk_read_callback, + .timeout = 0, /* no timeout */ }, }; diff --git a/sys/dev/usb/net/if_rue.c b/sys/dev/usb/net/if_rue.c index 73958d178cfe..dc7a31fdae58 100644 --- a/sys/dev/usb/net/if_rue.c +++ b/sys/dev/usb/net/if_rue.c @@ -141,29 +141,29 @@ static const struct usb2_config rue_config[RUE_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = MCLBYTES, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = rue_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = MCLBYTES, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = rue_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [RUE_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + 4), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = rue_bulk_read_callback, - .mh.timeout = 0, /* no timeout */ + .bufsize = (MCLBYTES + 4), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = rue_bulk_read_callback, + .timeout = 0, /* no timeout */ }, [RUE_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = rue_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = rue_intr_callback, }, }; diff --git a/sys/dev/usb/net/if_udav.c b/sys/dev/usb/net/if_udav.c index 76cdef45eb7f..5962d1915131 100644 --- a/sys/dev/usb/net/if_udav.c +++ b/sys/dev/usb/net/if_udav.c @@ -101,29 +101,29 @@ static const struct usb2_config udav_config[UDAV_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (MCLBYTES + 2), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = udav_bulk_write_callback, - .mh.timeout = 10000, /* 10 seconds */ + .bufsize = (MCLBYTES + 2), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = udav_bulk_write_callback, + .timeout = 10000, /* 10 seconds */ }, [UDAV_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + 3), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = udav_bulk_read_callback, - .mh.timeout = 0, /* no timeout */ + .bufsize = (MCLBYTES + 3), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = udav_bulk_read_callback, + .timeout = 0, /* no timeout */ }, [UDAV_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = udav_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = udav_intr_callback, }, }; diff --git a/sys/dev/usb/serial/u3g.c b/sys/dev/usb/serial/u3g.c index 19d3d506a98d..19009c6eea9b 100644 --- a/sys/dev/usb/serial/u3g.c +++ b/sys/dev/usb/serial/u3g.c @@ -116,18 +116,18 @@ static const struct usb2_config u3g_config[U3G_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = U3G_BSIZE,/* bytes */ - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &u3g_write_callback, + .bufsize = U3G_BSIZE,/* bytes */ + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &u3g_write_callback, }, [U3G_BULK_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = U3G_BSIZE,/* bytes */ - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &u3g_read_callback, + .bufsize = U3G_BSIZE,/* bytes */ + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &u3g_read_callback, }, }; diff --git a/sys/dev/usb/serial/uark.c b/sys/dev/usb/serial/uark.c index e0f9db7a5fee..bc0bace12188 100644 --- a/sys/dev/usb/serial/uark.c +++ b/sys/dev/usb/serial/uark.c @@ -106,18 +106,18 @@ static const struct usb2_config .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UARK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uark_bulk_write_callback, + .bufsize = UARK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uark_bulk_write_callback, }, [UARK_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UARK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uark_bulk_read_callback, + .bufsize = UARK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uark_bulk_read_callback, }, }; diff --git a/sys/dev/usb/serial/ubsa.c b/sys/dev/usb/serial/ubsa.c index 244ca653e9e0..a52c828b5152 100644 --- a/sys/dev/usb/serial/ubsa.c +++ b/sys/dev/usb/serial/ubsa.c @@ -188,27 +188,27 @@ static const struct usb2_config ubsa_config[UBSA_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UBSA_BSIZE, /* bytes */ - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &ubsa_write_callback, + .bufsize = UBSA_BSIZE, /* bytes */ + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &ubsa_write_callback, }, [UBSA_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UBSA_BSIZE, /* bytes */ - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &ubsa_read_callback, + .bufsize = UBSA_BSIZE, /* bytes */ + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &ubsa_read_callback, }, [UBSA_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &ubsa_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &ubsa_intr_callback, }, }; diff --git a/sys/dev/usb/serial/ubser.c b/sys/dev/usb/serial/ubser.c index 08d5e14e8840..6ec67ae1e9f1 100644 --- a/sys/dev/usb/serial/ubser.c +++ b/sys/dev/usb/serial/ubser.c @@ -156,18 +156,18 @@ static const struct usb2_config ubser_config[UBSER_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &ubser_write_callback, + .bufsize = 0, /* use wMaxPacketSize */ + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &ubser_write_callback, }, [UBSER_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &ubser_read_callback, + .bufsize = 0, /* use wMaxPacketSize */ + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &ubser_read_callback, }, }; diff --git a/sys/dev/usb/serial/uchcom.c b/sys/dev/usb/serial/uchcom.c index b99f0488ed03..413fb125cd4a 100644 --- a/sys/dev/usb/serial/uchcom.c +++ b/sys/dev/usb/serial/uchcom.c @@ -233,27 +233,27 @@ static const struct usb2_config uchcom_config_data[UCHCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UCHCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uchcom_write_callback, + .bufsize = UCHCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uchcom_write_callback, }, [UCHCOM_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UCHCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uchcom_read_callback, + .bufsize = UCHCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uchcom_read_callback, }, [UCHCOM_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &uchcom_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &uchcom_intr_callback, }, }; diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c index f3f99a25a888..a044c007286b 100644 --- a/sys/dev/usb/serial/ucycom.c +++ b/sys/dev/usb/serial/ucycom.c @@ -120,18 +120,18 @@ static const struct usb2_config ucycom_config[UCYCOM_N_TRANSFER] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + UCYCOM_MAX_IOLEN), - .mh.callback = &ucycom_ctrl_write_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = (sizeof(struct usb2_device_request) + UCYCOM_MAX_IOLEN), + .callback = &ucycom_ctrl_write_callback, + .timeout = 1000, /* 1 second */ }, [UCYCOM_INTR_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = UCYCOM_MAX_IOLEN, - .mh.callback = &ucycom_intr_read_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = UCYCOM_MAX_IOLEN, + .callback = &ucycom_intr_read_callback, }, }; diff --git a/sys/dev/usb/serial/ufoma.c b/sys/dev/usb/serial/ufoma.c index e84ab1da1d6d..62471e724ef8 100644 --- a/sys/dev/usb/serial/ufoma.c +++ b/sys/dev/usb/serial/ufoma.c @@ -232,28 +232,28 @@ static const struct usb2_config .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = sizeof(struct usb2_cdc_notification), - .mh.callback = &ufoma_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = sizeof(struct usb2_cdc_notification), + .callback = &ufoma_intr_callback, }, [UFOMA_CTRL_ENDPT_READ] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + UFOMA_CMD_BUF_SIZE), - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &ufoma_ctrl_read_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = (sizeof(struct usb2_device_request) + UFOMA_CMD_BUF_SIZE), + .flags = {.short_xfer_ok = 1,}, + .callback = &ufoma_ctrl_read_callback, + .timeout = 1000, /* 1 second */ }, [UFOMA_CTRL_ENDPT_WRITE] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + 1), - .mh.callback = &ufoma_ctrl_write_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = (sizeof(struct usb2_device_request) + 1), + .callback = &ufoma_ctrl_write_callback, + .timeout = 1000, /* 1 second */ }, }; @@ -264,18 +264,18 @@ static const struct usb2_config .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UFOMA_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &ufoma_bulk_write_callback, + .bufsize = UFOMA_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &ufoma_bulk_write_callback, }, [UFOMA_BULK_ENDPT_READ] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UFOMA_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &ufoma_bulk_read_callback, + .bufsize = UFOMA_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &ufoma_bulk_read_callback, }, }; diff --git a/sys/dev/usb/serial/uftdi.c b/sys/dev/usb/serial/uftdi.c index d03638f5cd33..c075b06f4037 100644 --- a/sys/dev/usb/serial/uftdi.c +++ b/sys/dev/usb/serial/uftdi.c @@ -150,18 +150,18 @@ static const struct usb2_config uftdi_config[UFTDI_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UFTDI_OBUFSIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uftdi_write_callback, + .bufsize = UFTDI_OBUFSIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uftdi_write_callback, }, [UFTDI_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UFTDI_IBUFSIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uftdi_read_callback, + .bufsize = UFTDI_IBUFSIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uftdi_read_callback, }, }; diff --git a/sys/dev/usb/serial/ugensa.c b/sys/dev/usb/serial/ugensa.c index 6174f1762892..f370e1b310fd 100644 --- a/sys/dev/usb/serial/ugensa.c +++ b/sys/dev/usb/serial/ugensa.c @@ -106,18 +106,18 @@ static const struct usb2_config .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UGENSA_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &ugensa_bulk_write_callback, + .bufsize = UGENSA_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &ugensa_bulk_write_callback, }, [UGENSA_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UGENSA_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &ugensa_bulk_read_callback, + .bufsize = UGENSA_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &ugensa_bulk_read_callback, }, }; diff --git a/sys/dev/usb/serial/uipaq.c b/sys/dev/usb/serial/uipaq.c index daebe8bf960a..24dbd25618bf 100644 --- a/sys/dev/usb/serial/uipaq.c +++ b/sys/dev/usb/serial/uipaq.c @@ -115,18 +115,18 @@ static const struct usb2_config uipaq_config_data[UIPAQ_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UIPAQ_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uipaq_write_callback, + .bufsize = UIPAQ_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uipaq_write_callback, }, [UIPAQ_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UIPAQ_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uipaq_read_callback, + .bufsize = UIPAQ_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uipaq_read_callback, }, }; diff --git a/sys/dev/usb/serial/ulpt.c b/sys/dev/usb/serial/ulpt.c index 56ff9fcc1a62..024325ee7433 100644 --- a/sys/dev/usb/serial/ulpt.c +++ b/sys/dev/usb/serial/ulpt.c @@ -338,27 +338,27 @@ static const struct usb2_config ulpt_config[ULPT_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = ULPT_BSIZE, - .mh.flags = {.pipe_bof = 1,.proxy_buffer = 1}, - .mh.callback = &ulpt_write_callback, + .bufsize = ULPT_BSIZE, + .flags = {.pipe_bof = 1,.proxy_buffer = 1}, + .callback = &ulpt_write_callback, }, [ULPT_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = ULPT_BSIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1}, - .mh.callback = &ulpt_read_callback, + .bufsize = ULPT_BSIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1}, + .callback = &ulpt_read_callback, }, [ULPT_INTR_DT_RD] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request) + 1, - .mh.callback = &ulpt_status_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request) + 1, + .callback = &ulpt_status_callback, + .timeout = 1000, /* 1 second */ }, }; diff --git a/sys/dev/usb/serial/umct.c b/sys/dev/usb/serial/umct.c index 9e49440d9312..db3ddb46ce59 100644 --- a/sys/dev/usb/serial/umct.c +++ b/sys/dev/usb/serial/umct.c @@ -137,18 +137,18 @@ static const struct usb2_config umct_config[UMCT_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &umct_write_callback, + .bufsize = 0, /* use wMaxPacketSize */ + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &umct_write_callback, }, [UMCT_BULK_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &umct_read_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &umct_read_callback, .ep_index = 0, /* first interrupt endpoint */ }, @@ -156,9 +156,9 @@ static const struct usb2_config umct_config[UMCT_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &umct_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &umct_intr_callback, .ep_index = 1, /* second interrupt endpoint */ }, }; diff --git a/sys/dev/usb/serial/umodem.c b/sys/dev/usb/serial/umodem.c index dedea151da9d..35186fd93a10 100644 --- a/sys/dev/usb/serial/umodem.c +++ b/sys/dev/usb/serial/umodem.c @@ -189,9 +189,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = { .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, .if_index = 0, - .mh.bufsize = UMODEM_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &umodem_write_callback, + .bufsize = UMODEM_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &umodem_write_callback, }, [UMODEM_BULK_RD] = { @@ -199,9 +199,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = { .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 0, - .mh.bufsize = UMODEM_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &umodem_read_callback, + .bufsize = UMODEM_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &umodem_read_callback, }, [UMODEM_INTR_RD] = { @@ -209,9 +209,9 @@ static const struct usb2_config umodem_config[UMODEM_N_TRANSFER] = { .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, .if_index = 1, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &umodem_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &umodem_intr_callback, }, }; diff --git a/sys/dev/usb/serial/umoscom.c b/sys/dev/usb/serial/umoscom.c index 8ced0c8cb9e6..f2820aec0d4c 100644 --- a/sys/dev/usb/serial/umoscom.c +++ b/sys/dev/usb/serial/umoscom.c @@ -204,27 +204,27 @@ static const struct usb2_config umoscom_config_data[UMOSCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UMOSCOM_BUFSIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &umoscom_write_callback, + .bufsize = UMOSCOM_BUFSIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &umoscom_write_callback, }, [UMOSCOM_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UMOSCOM_BUFSIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &umoscom_read_callback, + .bufsize = UMOSCOM_BUFSIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &umoscom_read_callback, }, [UMOSCOM_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &umoscom_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &umoscom_intr_callback, }, }; diff --git a/sys/dev/usb/serial/uplcom.c b/sys/dev/usb/serial/uplcom.c index a915160240ba..24a4b36eb049 100644 --- a/sys/dev/usb/serial/uplcom.c +++ b/sys/dev/usb/serial/uplcom.c @@ -187,9 +187,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UPLCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uplcom_write_callback, + .bufsize = UPLCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uplcom_write_callback, .if_index = 0, }, @@ -197,9 +197,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UPLCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uplcom_read_callback, + .bufsize = UPLCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uplcom_read_callback, .if_index = 0, }, @@ -207,9 +207,9 @@ static const struct usb2_config uplcom_config_data[UPLCOM_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &uplcom_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &uplcom_intr_callback, .if_index = 1, }, }; diff --git a/sys/dev/usb/serial/uslcom.c b/sys/dev/usb/serial/uslcom.c index d1351aa40a6c..5df0abb0867c 100644 --- a/sys/dev/usb/serial/uslcom.c +++ b/sys/dev/usb/serial/uslcom.c @@ -128,18 +128,18 @@ static const struct usb2_config uslcom_config[USLCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = USLCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uslcom_write_callback, + .bufsize = USLCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uslcom_write_callback, }, [USLCOM_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = USLCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uslcom_read_callback, + .bufsize = USLCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uslcom_read_callback, }, }; diff --git a/sys/dev/usb/serial/uvisor.c b/sys/dev/usb/serial/uvisor.c index bff317bef44a..54de2e29b8ee 100644 --- a/sys/dev/usb/serial/uvisor.c +++ b/sys/dev/usb/serial/uvisor.c @@ -196,18 +196,18 @@ static const struct usb2_config uvisor_config[UVISOR_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UVISOR_BUFSIZE, /* bytes */ - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uvisor_write_callback, + .bufsize = UVISOR_BUFSIZE, /* bytes */ + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uvisor_write_callback, }, [UVISOR_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UVISOR_BUFSIZE, /* bytes */ - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uvisor_read_callback, + .bufsize = UVISOR_BUFSIZE, /* bytes */ + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uvisor_read_callback, }, }; diff --git a/sys/dev/usb/serial/uvscom.c b/sys/dev/usb/serial/uvscom.c index 6de4f5b98489..cfda9f8cca0a 100644 --- a/sys/dev/usb/serial/uvscom.c +++ b/sys/dev/usb/serial/uvscom.c @@ -179,27 +179,27 @@ static const struct usb2_config uvscom_config[UVSCOM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UVSCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = &uvscom_write_callback, + .bufsize = UVSCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = &uvscom_write_callback, }, [UVSCOM_BULK_DT_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UVSCOM_BULK_BUF_SIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = &uvscom_read_callback, + .bufsize = UVSCOM_BULK_BUF_SIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = &uvscom_read_callback, }, [UVSCOM_INTR_DT_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &uvscom_intr_callback, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &uvscom_intr_callback, }, }; diff --git a/sys/dev/usb/storage/umass.c b/sys/dev/usb/storage/umass.c index 6ee17bfc63b2..2f2a163523fc 100644 --- a/sys/dev/usb/storage/umass.c +++ b/sys/dev/usb/storage/umass.c @@ -1063,87 +1063,87 @@ struct usb2_config umass_bbb_config[UMASS_T_BBB_MAX] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_bbb_reset1_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 500, /* 500 milliseconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_bbb_reset1_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 500, /* 500 milliseconds */ }, [UMASS_T_BBB_RESET2] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_bbb_reset2_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 50, /* 50 milliseconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_bbb_reset2_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 50, /* 50 milliseconds */ }, [UMASS_T_BBB_RESET3] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_bbb_reset3_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 50, /* 50 milliseconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_bbb_reset3_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 50, /* 50 milliseconds */ }, [UMASS_T_BBB_COMMAND] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = sizeof(umass_bbb_cbw_t), - .mh.callback = &umass_t_bbb_command_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = sizeof(umass_bbb_cbw_t), + .callback = &umass_t_bbb_command_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_BBB_DATA_READ] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UMASS_BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, - .mh.callback = &umass_t_bbb_data_read_callback, - .mh.timeout = 0, /* overwritten later */ + .bufsize = UMASS_BULK_SIZE, + .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, + .callback = &umass_t_bbb_data_read_callback, + .timeout = 0, /* overwritten later */ }, [UMASS_T_BBB_DATA_RD_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_bbb_data_rd_cs_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_bbb_data_rd_cs_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_BBB_DATA_WRITE] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UMASS_BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, - .mh.callback = &umass_t_bbb_data_write_callback, - .mh.timeout = 0, /* overwritten later */ + .bufsize = UMASS_BULK_SIZE, + .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, + .callback = &umass_t_bbb_data_write_callback, + .timeout = 0, /* overwritten later */ }, [UMASS_T_BBB_DATA_WR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_bbb_data_wr_cs_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_bbb_data_wr_cs_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_BBB_STATUS] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = sizeof(umass_bbb_csw_t), - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &umass_t_bbb_status_callback, - .mh.timeout = 5000, /* ms */ + .bufsize = sizeof(umass_bbb_csw_t), + .flags = {.short_xfer_ok = 1,}, + .callback = &umass_t_bbb_status_callback, + .timeout = 5000, /* ms */ }, }; @@ -1153,98 +1153,98 @@ struct usb2_config umass_cbi_config[UMASS_T_CBI_MAX] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + + .bufsize = (sizeof(struct usb2_device_request) + UMASS_CBI_DIAGNOSTIC_CMDLEN), - .mh.callback = &umass_t_cbi_reset1_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 500, /* 500 milliseconds */ + .callback = &umass_t_cbi_reset1_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 500, /* 500 milliseconds */ }, [UMASS_T_CBI_RESET2] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_cbi_reset2_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 50, /* 50 milliseconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_cbi_reset2_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 50, /* 50 milliseconds */ }, [UMASS_T_CBI_RESET3] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_cbi_reset3_callback, - .mh.timeout = 5000, /* 5 seconds */ - .mh.interval = 50, /* 50 milliseconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_cbi_reset3_callback, + .timeout = 5000, /* 5 seconds */ + .interval = 50, /* 50 milliseconds */ }, [UMASS_T_CBI_COMMAND] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = (sizeof(struct usb2_device_request) + + .bufsize = (sizeof(struct usb2_device_request) + UMASS_MAX_CMDLEN), - .mh.callback = &umass_t_cbi_command_callback, - .mh.timeout = 5000, /* 5 seconds */ + .callback = &umass_t_cbi_command_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_CBI_DATA_READ] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = UMASS_BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, - .mh.callback = &umass_t_cbi_data_read_callback, - .mh.timeout = 0, /* overwritten later */ + .bufsize = UMASS_BULK_SIZE, + .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, + .callback = &umass_t_cbi_data_read_callback, + .timeout = 0, /* overwritten later */ }, [UMASS_T_CBI_DATA_RD_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_cbi_data_rd_cs_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_cbi_data_rd_cs_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_CBI_DATA_WRITE] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = UMASS_BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, - .mh.callback = &umass_t_cbi_data_write_callback, - .mh.timeout = 0, /* overwritten later */ + .bufsize = UMASS_BULK_SIZE, + .flags = {.proxy_buffer = 1,.short_xfer_ok = 1, UMASS_USB_FLAGS}, + .callback = &umass_t_cbi_data_write_callback, + .timeout = 0, /* overwritten later */ }, [UMASS_T_CBI_DATA_WR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_cbi_data_wr_cs_callback, - .mh.timeout = 5000, /* 5 seconds */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_cbi_data_wr_cs_callback, + .timeout = 5000, /* 5 seconds */ }, [UMASS_T_CBI_STATUS] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.flags = {.short_xfer_ok = 1,}, - .mh.bufsize = sizeof(umass_cbi_sbl_t), - .mh.callback = &umass_t_cbi_status_callback, - .mh.timeout = 5000, /* ms */ + .flags = {.short_xfer_ok = 1,}, + .bufsize = sizeof(umass_cbi_sbl_t), + .callback = &umass_t_cbi_status_callback, + .timeout = 5000, /* ms */ }, [UMASS_T_CBI_RESET4] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &umass_t_cbi_reset4_callback, - .mh.timeout = 5000, /* ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &umass_t_cbi_reset4_callback, + .timeout = 5000, /* ms */ }, }; diff --git a/sys/dev/usb/storage/urio.c b/sys/dev/usb/storage/urio.c index ea80b4e5556c..0c27aa04d6cc 100644 --- a/sys/dev/usb/storage/urio.c +++ b/sys/dev/usb/storage/urio.c @@ -130,38 +130,38 @@ static const struct usb2_config urio_config[URIO_T_MAX] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = URIO_BSIZE, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,.proxy_buffer = 1,}, - .mh.callback = &urio_write_callback, + .bufsize = URIO_BSIZE, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,.proxy_buffer = 1,}, + .callback = &urio_write_callback, }, [URIO_T_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = URIO_BSIZE, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1,}, - .mh.callback = &urio_read_callback, + .bufsize = URIO_BSIZE, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1,}, + .callback = &urio_read_callback, }, [URIO_T_WR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &urio_write_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &urio_write_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, [URIO_T_RD_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &urio_read_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &urio_read_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ }, }; diff --git a/sys/dev/usb/usb_compat_linux.c b/sys/dev/usb/usb_compat_linux.c index 9641a81fe1a2..eed72ce93d8a 100644 --- a/sys/dev/usb/usb_compat_linux.c +++ b/sys/dev/usb/usb_compat_linux.c @@ -770,10 +770,10 @@ usb_setup_endpoint(struct usb_device *dev, cfg[0].type = type; cfg[0].endpoint = addr & UE_ADDR; cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN); - cfg[0].mh.callback = &usb_linux_isoc_callback; - cfg[0].mh.bufsize = 0; /* use wMaxPacketSize */ - cfg[0].mh.frames = usb_max_isoc_frames(dev); - cfg[0].mh.flags.proxy_buffer = 1; + cfg[0].callback = &usb_linux_isoc_callback; + cfg[0].bufsize = 0; /* use wMaxPacketSize */ + cfg[0].frames = usb_max_isoc_frames(dev); + cfg[0].flags.proxy_buffer = 1; #if 0 /* * The Linux USB API allows non back-to-back @@ -782,9 +782,9 @@ usb_setup_endpoint(struct usb_device *dev, * do a copy, and then we need a buffer for * that. Enable this at your own risk. */ - cfg[0].mh.flags.ext_buffer = 1; + cfg[0].flags.ext_buffer = 1; #endif - cfg[0].mh.flags.short_xfer_ok = 1; + cfg[0].flags.short_xfer_ok = 1; bcopy(cfg, cfg + 1, sizeof(*cfg)); @@ -804,11 +804,11 @@ usb_setup_endpoint(struct usb_device *dev, cfg[0].type = type; cfg[0].endpoint = addr & UE_ADDR; cfg[0].direction = addr & (UE_DIR_OUT | UE_DIR_IN); - cfg[0].mh.callback = &usb_linux_non_isoc_callback; - cfg[0].mh.bufsize = bufsize; - cfg[0].mh.flags.ext_buffer = 1; /* enable zero-copy */ - cfg[0].mh.flags.proxy_buffer = 1; - cfg[0].mh.flags.short_xfer_ok = 1; + cfg[0].callback = &usb_linux_non_isoc_callback; + cfg[0].bufsize = bufsize; + cfg[0].flags.ext_buffer = 1; /* enable zero-copy */ + cfg[0].flags.proxy_buffer = 1; + cfg[0].flags.short_xfer_ok = 1; if (usb2_transfer_setup(dev->bsd_udev, &uhe->bsd_iface_index, uhe->bsd_xfer, cfg, 1, uhe, &Giant)) { diff --git a/sys/dev/usb/usb_core.h b/sys/dev/usb/usb_core.h index 102866490361..71bd1e091ce4 100644 --- a/sys/dev/usb/usb_core.h +++ b/sys/dev/usb/usb_core.h @@ -112,6 +112,22 @@ #define USB_DEBUG 1 #endif +/* + * The following macro defines if USB transaction translator support + * shall be compiled for the USB HUB and USB controller drivers. + */ +#ifndef USB_HAVE_TT_SUPPORT +#define USB_HAVE_TT_SUPPORT 1 +#endif + +/* + * The following macro defines if the USB power daemon shall + * be compiled for the USB core. + */ +#ifndef USB_HAVE_POWERD +#define USB_HAVE_POWERD 1 +#endif + #ifndef USB_TD_GET_PROC #define USB_TD_GET_PROC(td) (td)->td_proc #endif @@ -277,7 +293,7 @@ typedef uint32_t usb2_ticks_t; /* system defined */ #endif #ifndef USB_HAVE_POWER_MASK_T -typedef uint32_t usb2_power_mask_t; /* see "USB_HW_POWER_XXX" */ +typedef uint16_t usb2_power_mask_t; /* see "USB_HW_POWER_XXX" */ #endif /* structures */ @@ -361,10 +377,10 @@ struct usb2_xfer_flags_int { }; /* - * The following structure defines the symmetric part of an USB config - * structure. + * The following structure define an USB configuration, that basically + * is used when setting up an USB transfer. */ -struct usb2_config_sub { +struct usb2_config { usb2_callback_t *callback; /* USB transfer callback */ usb2_frlength_t bufsize; /* total pipe buffer size in bytes */ usb2_frcount_t frames; /* maximum number of USB frames */ @@ -372,20 +388,13 @@ struct usb2_config_sub { #define USB_DEFAULT_INTERVAL 0 usb2_timeout_t timeout; /* transfer timeout in milliseconds */ struct usb2_xfer_flags flags; /* transfer flags */ -}; - -/* - * The following structure define an USB configuration, that basically - * is used when setting up an USB transfer. - */ -struct usb2_config { - struct usb2_config_sub mh; /* parameters for USB_MODE_HOST */ - struct usb2_config_sub md; /* parameters for USB_MODE_DEVICE */ uint8_t type; /* pipe type */ uint8_t endpoint; /* pipe number */ uint8_t direction; /* pipe direction */ uint8_t ep_index; /* pipe index match to use */ uint8_t if_index; /* "ifaces" index to use */ + uint8_t usb_mode; /* see "USB_MODE_XXX", + * "USB_MODE_MAX" means any mode! */ }; /* diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c index 9ae7b6164038..f497b12bc3d4 100644 --- a/sys/dev/usb/usb_device.c +++ b/sys/dev/usb/usb_device.c @@ -172,6 +172,14 @@ usb2_get_pipe(struct usb2_device *udev, uint8_t iface_index, udev, iface_index, setup->endpoint, setup->type, setup->direction, setup->ep_index); + /* check USB mode */ + + if ((setup->usb_mode != USB_MODE_MAX) && + (udev->flags.usb2_mode != setup->usb_mode)) { + /* wrong mode - no pipe */ + return (NULL); + } + /* setup expected endpoint direction mask and value */ if (setup->direction == UE_DIR_RX) { @@ -1481,7 +1489,6 @@ usb2_alloc_device(device_t parent_dev, struct usb2_bus *bus, */ udev->power_mode = USB_POWER_MODE_ON; udev->pwr_save.last_xfer_time = ticks; - /* we are not ready yet */ udev->refcount = 1; diff --git a/sys/dev/usb/usb_device.h b/sys/dev/usb/usb_device.h index 67f7b59ff3e5..2317b07ff607 100644 --- a/sys/dev/usb/usb_device.h +++ b/sys/dev/usb/usb_device.h @@ -119,7 +119,6 @@ struct usb2_device { struct usb2_pipe default_pipe; /* Control Endpoint 0 */ struct usb2_pipe *pipes; struct usb2_power_save pwr_save;/* power save data */ - struct usb2_bus *bus; /* our USB BUS */ device_t parent_dev; /* parent device */ struct usb2_device *parent_hub; diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c index f4010226a7f8..27de49b3b639 100644 --- a/sys/dev/usb/usb_generic.c +++ b/sys/dev/usb/usb_generic.c @@ -222,28 +222,29 @@ ugen_open_pipe_write(struct usb2_fifo *f) usb2_config[1].type = UE_CONTROL; usb2_config[1].endpoint = 0; usb2_config[1].direction = UE_DIR_ANY; - usb2_config[1].mh.timeout = 1000; /* 1 second */ - usb2_config[1].mh.interval = 50;/* 50 milliseconds */ - usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); - usb2_config[1].mh.callback = &ugen_write_clear_stall_callback; + usb2_config[1].timeout = 1000; /* 1 second */ + usb2_config[1].interval = 50;/* 50 milliseconds */ + usb2_config[1].bufsize = sizeof(struct usb2_device_request); + usb2_config[1].callback = &ugen_write_clear_stall_callback; + usb2_config[1].usb_mode = USB_MODE_HOST; usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; - usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); - usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; - usb2_config[0].mh.flags.proxy_buffer = 1; + usb2_config[0].direction = UE_DIR_TX; + usb2_config[0].interval = USB_DEFAULT_INTERVAL; + usb2_config[0].flags.proxy_buffer = 1; + usb2_config[0].usb_mode = USB_MODE_MAX; /* both modes */ switch (ed->bmAttributes & UE_XFERTYPE) { case UE_INTERRUPT: case UE_BULK: if (f->flag_short) { - usb2_config[0].mh.flags.force_short_xfer = 1; + usb2_config[0].flags.force_short_xfer = 1; } - usb2_config[0].mh.callback = &ugen_default_write_callback; - usb2_config[0].mh.timeout = f->timeout; - usb2_config[0].mh.frames = 1; - usb2_config[0].mh.bufsize = f->bufsize; - usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ + usb2_config[0].callback = &ugen_default_write_callback; + usb2_config[0].timeout = f->timeout; + usb2_config[0].frames = 1; + usb2_config[0].bufsize = f->bufsize; if (ugen_transfer_setup(f, usb2_config, 2)) { return (EIO); } @@ -252,12 +253,11 @@ ugen_open_pipe_write(struct usb2_fifo *f) break; case UE_ISOCHRONOUS: - usb2_config[0].mh.flags.short_xfer_ok = 1; - usb2_config[0].mh.bufsize = 0; /* use default */ - usb2_config[0].mh.frames = f->nframes; - usb2_config[0].mh.callback = &ugen_isoc_write_callback; - usb2_config[0].mh.timeout = 0; - usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ + usb2_config[0].flags.short_xfer_ok = 1; + usb2_config[0].bufsize = 0; /* use default */ + usb2_config[0].frames = f->nframes; + usb2_config[0].callback = &ugen_isoc_write_callback; + usb2_config[0].timeout = 0; /* clone configuration */ usb2_config[1] = usb2_config[0]; @@ -290,28 +290,29 @@ ugen_open_pipe_read(struct usb2_fifo *f) usb2_config[1].type = UE_CONTROL; usb2_config[1].endpoint = 0; usb2_config[1].direction = UE_DIR_ANY; - usb2_config[1].mh.timeout = 1000; /* 1 second */ - usb2_config[1].mh.interval = 50;/* 50 milliseconds */ - usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); - usb2_config[1].mh.callback = &ugen_read_clear_stall_callback; + usb2_config[1].timeout = 1000; /* 1 second */ + usb2_config[1].interval = 50;/* 50 milliseconds */ + usb2_config[1].bufsize = sizeof(struct usb2_device_request); + usb2_config[1].callback = &ugen_read_clear_stall_callback; + usb2_config[1].usb_mode = USB_MODE_HOST; usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; - usb2_config[0].direction = UE_DIR_IN; - usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; - usb2_config[0].mh.flags.proxy_buffer = 1; + usb2_config[0].direction = UE_DIR_RX; + usb2_config[0].interval = USB_DEFAULT_INTERVAL; + usb2_config[0].flags.proxy_buffer = 1; + usb2_config[0].usb_mode = USB_MODE_MAX; /* both modes */ switch (ed->bmAttributes & UE_XFERTYPE) { case UE_INTERRUPT: case UE_BULK: if (f->flag_short) { - usb2_config[0].mh.flags.short_xfer_ok = 1; + usb2_config[0].flags.short_xfer_ok = 1; } - usb2_config[0].mh.timeout = f->timeout; - usb2_config[0].mh.frames = 1; - usb2_config[0].mh.callback = &ugen_default_read_callback; - usb2_config[0].mh.bufsize = f->bufsize; - usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ + usb2_config[0].timeout = f->timeout; + usb2_config[0].frames = 1; + usb2_config[0].callback = &ugen_default_read_callback; + usb2_config[0].bufsize = f->bufsize; if (ugen_transfer_setup(f, usb2_config, 2)) { return (EIO); @@ -321,12 +322,11 @@ ugen_open_pipe_read(struct usb2_fifo *f) break; case UE_ISOCHRONOUS: - usb2_config[0].mh.flags.short_xfer_ok = 1; - usb2_config[0].mh.bufsize = 0; /* use default */ - usb2_config[0].mh.frames = f->nframes; - usb2_config[0].mh.callback = &ugen_isoc_read_callback; - usb2_config[0].mh.timeout = 0; - usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ + usb2_config[0].flags.short_xfer_ok = 1; + usb2_config[0].bufsize = 0; /* use default */ + usb2_config[0].frames = f->nframes; + usb2_config[0].callback = &ugen_isoc_read_callback; + usb2_config[0].timeout = 0; /* clone configuration */ usb2_config[1] = usb2_config[0]; @@ -1463,13 +1463,13 @@ ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags) usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); - usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; - usb2_config[0].mh.flags.proxy_buffer = 1; - usb2_config[0].mh.callback = &ugen_default_fs_callback; - usb2_config[0].mh.timeout = 0; /* no timeout */ - usb2_config[0].mh.frames = u.popen->max_frames; - usb2_config[0].mh.bufsize = u.popen->max_bufsize; - usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ + usb2_config[0].interval = USB_DEFAULT_INTERVAL; + usb2_config[0].flags.proxy_buffer = 1; + usb2_config[0].callback = &ugen_default_fs_callback; + usb2_config[0].timeout = 0; /* no timeout */ + usb2_config[0].frames = u.popen->max_frames; + usb2_config[0].bufsize = u.popen->max_bufsize; + usb2_config[0].usb_mode = USB_MODE_MAX; /* both modes */ if (usb2_config[0].type == UE_CONTROL) { if (f->udev->flags.usb2_mode != USB_MODE_HOST) { diff --git a/sys/dev/usb/usb_handle_request.c b/sys/dev/usb/usb_handle_request.c index aec9e02c820c..7a9a6974fc7f 100644 --- a/sys/dev/usb/usb_handle_request.c +++ b/sys/dev/usb/usb_handle_request.c @@ -398,9 +398,7 @@ usb2_handle_remote_wakeup(struct usb2_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); - return (0); /* success */ } diff --git a/sys/dev/usb/usb_hub.c b/sys/dev/usb/usb_hub.c index 02f546439489..d12cfeb513c9 100644 --- a/sys/dev/usb/usb_hub.c +++ b/sys/dev/usb/usb_hub.c @@ -109,11 +109,11 @@ static const struct usb2_config uhub_config[UHUB_N_TRANSFER] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_ANY, - .mh.timeout = 0, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.bufsize = 0, /* use wMaxPacketSize */ - .mh.callback = &uhub_intr_callback, - .mh.interval = UHUB_INTR_INTERVAL, + .timeout = 0, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .bufsize = 0, /* use wMaxPacketSize */ + .callback = &uhub_intr_callback, + .interval = UHUB_INTR_INTERVAL, }, }; @@ -712,9 +712,10 @@ uhub_attach(device_t dev) } udev->hub = hub; +#if USB_HAVE_TT_SUPPORT /* init FULL-speed ISOCHRONOUS schedule */ usb2_fs_isoc_schedule_init_all(hub->fs_isoc_schedule); - +#endif /* initialize HUB structure */ hub->hubsoftc = sc; hub->explore = &uhub_explore; @@ -1115,6 +1116,7 @@ usb2_intr_schedule_adjust(struct usb2_device *udev, int16_t len, uint8_t slot) * This function initialises an USB FULL speed isochronous schedule * entry. *------------------------------------------------------------------------*/ +#if USB_HAVE_TT_SUPPORT static void usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss) { @@ -1123,6 +1125,7 @@ usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss) fss->frame_bytes = (USB_FS_BYTES_PER_HS_UFRAME); fss->frame_slot = 0; } +#endif /*------------------------------------------------------------------------* * usb2_fs_isoc_schedule_init_all @@ -1130,6 +1133,7 @@ usb2_fs_isoc_schedule_init_sub(struct usb2_fs_isoc_schedule *fss) * 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 usb2_fs_isoc_schedule *fss) { @@ -1140,6 +1144,7 @@ usb2_fs_isoc_schedule_init_all(struct usb2_fs_isoc_schedule *fss) fss++; } } +#endif /*------------------------------------------------------------------------* * usb2_isoc_time_expand @@ -1187,6 +1192,7 @@ usb2_isoc_time_expand(struct usb2_bus *bus, uint16_t isoc_time_curr) * NOTE: This function depends on being called regularly with * intervals less than "USB_ISOC_TIME_MAX". *------------------------------------------------------------------------*/ +#if USB_HAVE_TT_SUPPORT uint16_t usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev, struct usb2_fs_isoc_schedule **pp_start, @@ -1233,6 +1239,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev, } return (isoc_time); } +#endif /*------------------------------------------------------------------------* * usb2_fs_isoc_schedule_alloc @@ -1247,6 +1254,7 @@ usb2_fs_isoc_schedule_isoc_time_expand(struct usb2_device *udev, * 0: Success * Else: Error *------------------------------------------------------------------------*/ +#if USB_HAVE_TT_SUPPORT uint8_t usb2_fs_isoc_schedule_alloc(struct usb2_fs_isoc_schedule *fss, uint8_t *pstart, uint16_t len) @@ -1279,6 +1287,7 @@ usb2_fs_isoc_schedule_alloc(struct usb2_fs_isoc_schedule *fss, *pstart = slot; return (0); /* success */ } +#endif /*------------------------------------------------------------------------* * usb2_bus_port_get_device @@ -1411,11 +1420,13 @@ usb2_needs_explore_all(void) * properly suspended or resumed according to the device transfer * state. *------------------------------------------------------------------------*/ +#if USB_HAVE_POWERD void usb2_bus_power_update(struct usb2_bus *bus) { usb2_needs_explore(bus, 0 /* no probe */ ); } +#endif /*------------------------------------------------------------------------* * usb2_transfer_power_ref @@ -1424,6 +1435,7 @@ usb2_bus_power_update(struct usb2_bus *bus) * wakeup the USB device associated with the given USB transfer, if * needed. *------------------------------------------------------------------------*/ +#if USB_HAVE_POWERD void usb2_transfer_power_ref(struct usb2_xfer *xfer, int val) { @@ -1493,8 +1505,8 @@ usb2_transfer_power_ref(struct usb2_xfer *xfer, int val) (udev->bus->methods->set_hw_power) (udev->bus); } } - return; } +#endif /*------------------------------------------------------------------------* * usb2_bus_powerd @@ -1502,6 +1514,7 @@ usb2_transfer_power_ref(struct usb2_xfer *xfer, int val) * 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 usb2_bus *bus) { @@ -1625,6 +1638,7 @@ usb2_bus_powerd(struct usb2_bus *bus) } return; } +#endif /*------------------------------------------------------------------------* * usb2_dev_resume_peer @@ -1684,6 +1698,7 @@ usb2_dev_resume_peer(struct usb2_device *udev) USB_BUS_LOCK(bus); /* set that this device is now resumed */ udev->pwr_save.suspended = 0; +#if USB_HAVE_POWERD /* make sure that we don't go into suspend right away */ udev->pwr_save.last_xfer_time = ticks; @@ -1696,6 +1711,7 @@ usb2_dev_resume_peer(struct usb2_device *udev) bus->hw_power_state |= USB_HW_POWER_INTERRUPT; if (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0) bus->hw_power_state |= USB_HW_POWER_ISOC; +#endif USB_BUS_UNLOCK(bus); if (bus->methods->set_hw_power != NULL) { @@ -1844,7 +1860,7 @@ usb2_set_power_mode(struct usb2_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); - - return; +#endif } diff --git a/sys/dev/usb/usb_hub.h b/sys/dev/usb/usb_hub.h index 2dae7af9ed8d..62ab0d733840 100644 --- a/sys/dev/usb/usb_hub.h +++ b/sys/dev/usb/usb_hub.h @@ -52,7 +52,9 @@ struct usb2_fs_isoc_schedule { * The following structure defines an USB HUB. */ struct usb2_hub { +#if USB_HAVE_TT_SUPPORT struct usb2_fs_isoc_schedule fs_isoc_schedule[USB_ISOC_TIME_MAX]; +#endif struct usb2_device *hubudev; /* the HUB device */ usb2_error_t (*explore) (struct usb2_device *hub); void *hubsoftc; diff --git a/sys/dev/usb/usb_msctest.c b/sys/dev/usb/usb_msctest.c index bd5fdacee626..960cd95a38db 100644 --- a/sys/dev/usb/usb_msctest.c +++ b/sys/dev/usb/usb_msctest.c @@ -137,57 +137,57 @@ static const struct usb2_config bbb_config[ST_MAX] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = sizeof(struct bbb_cbw), - .mh.callback = &bbb_command_callback, - .mh.timeout = 4 * USB_MS_HZ, /* 4 seconds */ + .bufsize = sizeof(struct bbb_cbw), + .callback = &bbb_command_callback, + .timeout = 4 * USB_MS_HZ, /* 4 seconds */ }, [ST_DATA_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,}, - .mh.callback = &bbb_data_read_callback, - .mh.timeout = 4 * USB_MS_HZ, /* 4 seconds */ + .bufsize = BULK_SIZE, + .flags = {.proxy_buffer = 1,.short_xfer_ok = 1,}, + .callback = &bbb_data_read_callback, + .timeout = 4 * USB_MS_HZ, /* 4 seconds */ }, [ST_DATA_RD_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &bbb_data_rd_cs_callback, - .mh.timeout = 1 * USB_MS_HZ, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &bbb_data_rd_cs_callback, + .timeout = 1 * USB_MS_HZ, /* 1 second */ }, [ST_DATA_WR] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = BULK_SIZE, - .mh.flags = {.proxy_buffer = 1,}, - .mh.callback = &bbb_data_write_callback, - .mh.timeout = 4 * USB_MS_HZ, /* 4 seconds */ + .bufsize = BULK_SIZE, + .flags = {.proxy_buffer = 1,}, + .callback = &bbb_data_write_callback, + .timeout = 4 * USB_MS_HZ, /* 4 seconds */ }, [ST_DATA_WR_CS] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &bbb_data_wr_cs_callback, - .mh.timeout = 1 * USB_MS_HZ, /* 1 second */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &bbb_data_wr_cs_callback, + .timeout = 1 * USB_MS_HZ, /* 1 second */ }, [ST_STATUS] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = sizeof(struct bbb_csw), - .mh.flags = {.short_xfer_ok = 1,}, - .mh.callback = &bbb_status_callback, - .mh.timeout = 1 * USB_MS_HZ, /* 1 second */ + .bufsize = sizeof(struct bbb_csw), + .flags = {.short_xfer_ok = 1,}, + .callback = &bbb_status_callback, + .timeout = 1 * USB_MS_HZ, /* 1 second */ }, }; diff --git a/sys/dev/usb/usb_request.c b/sys/dev/usb/usb_request.c index edb399f23a4f..05b8c90553fa 100644 --- a/sys/dev/usb/usb_request.c +++ b/sys/dev/usb/usb_request.c @@ -319,11 +319,15 @@ usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx, } USB_XFER_LOCK(xfer); - if (flags & USB_DELAY_STATUS_STAGE) { + if (flags & USB_DELAY_STATUS_STAGE) xfer->flags.manual_status = 1; - } else { + else xfer->flags.manual_status = 0; - } + + if (flags & USB_SHORT_XFER_OK) + xfer->flags.short_xfer_ok = 1; + else + xfer->flags.short_xfer_ok = 0; xfer->timeout = timeout; @@ -409,9 +413,6 @@ usb2_do_request_flags(struct usb2_device *udev, struct mtx *mtx, if (temp > xfer->actlen) { temp = xfer->actlen; - if (!(flags & USB_SHORT_XFER_OK)) { - err = USB_ERR_SHORT_XFER; - } length = temp; } if (temp > 0) { diff --git a/sys/dev/usb/usb_transfer.c b/sys/dev/usb/usb_transfer.c index 58fd877a4005..10b0b9cf24a0 100644 --- a/sys/dev/usb/usb_transfer.c +++ b/sys/dev/usb/usb_transfer.c @@ -50,45 +50,7 @@ struct usb2_std_packet_size { uint16_t fixed[4]; }; -/* - * This table stores the all the allowed packet sizes based on - * endpoint type and USB speed: - */ -static const struct usb2_std_packet_size - usb2_std_packet_size[4][USB_SPEED_MAX] = { - - [UE_INTERRUPT] = { - [USB_SPEED_LOW] = {.range = {0, 8}}, - [USB_SPEED_FULL] = {.range = {0, 64}}, - [USB_SPEED_HIGH] = {.range = {0, 1024}}, - [USB_SPEED_VARIABLE] = {.range = {0, 1024}}, - [USB_SPEED_SUPER] = {.range = {0, 1024}}, - }, - - [UE_CONTROL] = { - [USB_SPEED_LOW] = {.fixed = {8, 8, 8, 8}}, - [USB_SPEED_FULL] = {.fixed = {8, 16, 32, 64}}, - [USB_SPEED_HIGH] = {.fixed = {64, 64, 64, 64}}, - [USB_SPEED_VARIABLE] = {.fixed = {512, 512, 512, 512}}, - [USB_SPEED_SUPER] = {.fixed = {512, 512, 512, 512}}, - }, - - [UE_BULK] = { - [USB_SPEED_LOW] = {.fixed = {0, 0, 0, 0}}, /* invalid */ - [USB_SPEED_FULL] = {.fixed = {8, 16, 32, 64}}, - [USB_SPEED_HIGH] = {.fixed = {512, 512, 512, 512}}, - [USB_SPEED_VARIABLE] = {.fixed = {512, 512, 1024, 1536}}, - [USB_SPEED_SUPER] = {.fixed = {1024, 1024, 1024, 1024}}, - }, - - [UE_ISOCHRONOUS] = { - [USB_SPEED_LOW] = {.fixed = {0, 0, 0, 0}}, /* invalid */ - [USB_SPEED_FULL] = {.range = {0, 1023}}, - [USB_SPEED_HIGH] = {.range = {0, 1024}}, - [USB_SPEED_VARIABLE] = {.range = {0, 3584}}, - [USB_SPEED_SUPER] = {.range = {0, 1024}}, - }, -}; +static usb2_callback_t usb2_request_callback; static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { @@ -98,12 +60,10 @@ static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control endpoint */ .direction = UE_DIR_ANY, - .mh.bufsize = USB_EP0_BUFSIZE, /* bytes */ - .mh.flags = {.proxy_buffer = 1,.short_xfer_ok = 1,}, - .mh.callback = &usb2_do_request_callback, - .md.bufsize = USB_EP0_BUFSIZE, /* bytes */ - .md.flags = {.proxy_buffer = 1,.short_xfer_ok = 0,}, - .md.callback = &usb2_handle_request_callback, + .bufsize = USB_EP0_BUFSIZE, /* bytes */ + .flags = {.proxy_buffer = 1,}, + .callback = &usb2_request_callback, + .usb_mode = USB_MODE_MAX, /* both modes */ }, /* This transfer is used for generic clear stall only */ @@ -112,10 +72,11 @@ static const struct usb2_config usb2_control_ep_cfg[USB_DEFAULT_XFER_MAX] = { .type = UE_CONTROL, .endpoint = 0x00, /* Control pipe */ .direction = UE_DIR_ANY, - .mh.bufsize = sizeof(struct usb2_device_request), - .mh.callback = &usb2_do_clear_stall_callback, - .mh.timeout = 1000, /* 1 second */ - .mh.interval = 50, /* 50ms */ + .bufsize = sizeof(struct usb2_device_request), + .callback = &usb2_do_clear_stall_callback, + .timeout = 1000, /* 1 second */ + .interval = 50, /* 50ms */ + .usb_mode = USB_MODE_HOST, }, }; @@ -131,6 +92,20 @@ static void usb2_callback_wrapper(struct usb2_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 usb2_xfer *); +static void usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, + uint8_t type, uint8_t usb_speed); + +/*------------------------------------------------------------------------* + * usb2_request_callback + *------------------------------------------------------------------------*/ +static void +usb2_request_callback(struct usb2_xfer *xfer) +{ + if (xfer->flags_int.usb2_mode == USB_MODE_DEVICE) + usb2_handle_request_callback(xfer); + else + usb2_do_request_callback(xfer); +} /*------------------------------------------------------------------------* * usb2_update_max_frame_size @@ -320,7 +295,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm) MIN_PKT = 8, }; struct usb2_xfer *xfer = parm->curr_xfer; - const struct usb2_config_sub *setup_sub = parm->curr_setup_sub; + const struct usb2_config *setup = parm->curr_setup; struct usb2_endpoint_descriptor *edesc; struct usb2_std_packet_size std_size; usb2_frcount_t n_frlengths; @@ -343,18 +318,18 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm) type = (edesc->bmAttributes & UE_XFERTYPE); - xfer->flags = setup_sub->flags; - xfer->nframes = setup_sub->frames; - xfer->timeout = setup_sub->timeout; - xfer->callback = setup_sub->callback; - xfer->interval = setup_sub->interval; + xfer->flags = setup->flags; + xfer->nframes = setup->frames; + xfer->timeout = setup->timeout; + xfer->callback = setup->callback; + xfer->interval = setup->interval; xfer->endpoint = edesc->bEndpointAddress; xfer->max_packet_size = UGETW(edesc->wMaxPacketSize); xfer->max_packet_count = 1; /* make a shadow copy: */ xfer->flags_int.usb2_mode = parm->udev->flags.usb2_mode; - parm->bufsize = setup_sub->bufsize; + parm->bufsize = setup->bufsize; if (parm->speed == USB_SPEED_HIGH) { xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3; @@ -373,7 +348,7 @@ usb2_transfer_setup_sub(struct usb2_setup_params *parm) } /* filter "wMaxPacketSize" according to standard sizes */ - std_size = usb2_std_packet_size[type][parm->speed]; + usb2_get_std_packet_size(&std_size, type, parm->speed); if (std_size.range.min || std_size.range.max) { @@ -779,13 +754,11 @@ usb2_transfer_setup(struct usb2_device *udev, /* sanity checks */ for (setup = setup_start, n = 0; setup != setup_end; setup++, n++) { - if ((setup->mh.bufsize == (usb2_frlength_t)-1) || - (setup->md.bufsize == (usb2_frlength_t)-1)) { + if (setup->bufsize == (usb2_frlength_t)-1) { parm.err = USB_ERR_BAD_BUFSIZE; DPRINTF("invalid bufsize\n"); } - if ((setup->mh.callback == NULL) && - (setup->md.callback == NULL)) { + if (setup->callback == NULL) { parm.err = USB_ERR_NO_CALLBACK; DPRINTF("no callback\n"); } @@ -865,14 +838,8 @@ usb2_transfer_setup(struct usb2_device *udev, for (setup = setup_start, n = 0; setup != setup_end; setup++, n++) { - /* select mode specific structure */ - if (udev->flags.usb2_mode == USB_MODE_HOST) { - parm.curr_setup_sub = &setup->mh; - } else { - parm.curr_setup_sub = &setup->md; - } /* skip USB transfers without callbacks: */ - if (parm.curr_setup_sub->callback == NULL) { + if (setup->callback == NULL) { continue; } /* see if there is a matching endpoint */ @@ -880,18 +847,21 @@ usb2_transfer_setup(struct usb2_device *udev, ifaces[setup->if_index], setup); if (!pipe) { - if (parm.curr_setup_sub->flags.no_pipe_ok) { + if (setup->flags.no_pipe_ok) + continue; + if ((setup->usb_mode != USB_MODE_MAX) && + (setup->usb_mode != udev->flags.usb2_mode)) continue; - } parm.err = USB_ERR_NO_PIPE; goto done; } - /* store current setup pointer */ - parm.curr_setup = setup; /* align data properly */ parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1)); + /* store current setup pointer */ + parm.curr_setup = setup; + if (buf) { /* * Common initialization of the @@ -1418,9 +1388,10 @@ usb2_start_hardware(struct usb2_xfer *xfer) /* set "transferring" flag */ xfer->flags_int.transferring = 1; +#if USB_HAVE_POWERD /* increment power reference */ usb2_transfer_power_ref(xfer, 1); - +#endif /* * Check if the transfer is waiting on a queue, most * frequently the "done_q": @@ -1945,9 +1916,10 @@ usb2_callback_wrapper(struct usb2_xfer_queue *pq) USB_BUS_LOCK(xfer->xroot->bus); goto done; } +#if USB_HAVE_POWERD /* decrement power reference */ usb2_transfer_power_ref(xfer, -1); - +#endif xfer->flags_int.transferring = 0; if (xfer->error) { @@ -2669,8 +2641,9 @@ usb2_clear_data_toggle(struct usb2_device *udev, struct usb2_pipe *pipe) * .direction = UE_DIR_ANY, * .interval = 50, //50 milliseconds * .bufsize = sizeof(struct usb2_device_request), - * .mh.timeout = 1000, //1.000 seconds - * .mh.callback = &my_clear_stall_callback, // ** + * .timeout = 1000, //1.000 seconds + * .callback = &my_clear_stall_callback, // ** + * .usb_mode = USB_MODE_HOST, * }; * * ** "my_clear_stall_callback" calls "usb2_clear_stall_callback" @@ -2749,3 +2722,78 @@ usb2_do_poll(struct usb2_xfer **ppxfer, uint16_t max) "not supported!\n"); } } + +static void +usb2_get_std_packet_size(struct usb2_std_packet_size *ptr, + uint8_t type, uint8_t usb_speed) +{ + static const uint16_t intr_range_max[USB_SPEED_MAX] = { + [USB_SPEED_LOW] = 8, + [USB_SPEED_FULL] = 64, + [USB_SPEED_HIGH] = 1024, + [USB_SPEED_VARIABLE] = 1024, + [USB_SPEED_SUPER] = 1024, + }; + + static const uint16_t isoc_range_max[USB_SPEED_MAX] = { + [USB_SPEED_LOW] = 0, /* invalid */ + [USB_SPEED_FULL] = 1023, + [USB_SPEED_HIGH] = 1024, + [USB_SPEED_VARIABLE] = 3584, + [USB_SPEED_SUPER] = 1024, + }; + + static const uint16_t control_min[USB_SPEED_MAX] = { + [USB_SPEED_LOW] = 8, + [USB_SPEED_FULL] = 8, + [USB_SPEED_HIGH] = 64, + [USB_SPEED_VARIABLE] = 512, + [USB_SPEED_SUPER] = 512, + }; + + static const uint16_t bulk_min[USB_SPEED_MAX] = { + [USB_SPEED_LOW] = 0, /* not supported */ + [USB_SPEED_FULL] = 8, + [USB_SPEED_HIGH] = 512, + [USB_SPEED_VARIABLE] = 512, + [USB_SPEED_SUPER] = 1024, + }; + + uint16_t temp; + + memset(ptr, 0, sizeof(*ptr)); + + switch (type) { + case UE_INTERRUPT: + ptr->range.max = intr_range_max[usb_speed]; + break; + case UE_ISOCHRONOUS: + ptr->range.max = isoc_range_max[usb_speed]; + break; + default: + if (type == UE_BULK) + temp = bulk_min[usb_speed]; + else /* UE_CONTROL */ + temp = control_min[usb_speed]; + + /* default is fixed */ + ptr->fixed[0] = temp; + ptr->fixed[1] = temp; + ptr->fixed[2] = temp; + ptr->fixed[3] = temp; + + if (usb_speed == USB_SPEED_FULL) { + /* multiple sizes */ + ptr->fixed[1] = 16; + ptr->fixed[2] = 32; + ptr->fixed[3] = 64; + } + if ((usb_speed == USB_SPEED_VARIABLE) && + (type == UE_BULK)) { + /* multiple sizes */ + ptr->fixed[2] = 1024; + ptr->fixed[3] = 1536; + } + break; + } +} diff --git a/sys/dev/usb/usb_transfer.h b/sys/dev/usb/usb_transfer.h index 630fe4dd0bea..a15e8a3c0c96 100644 --- a/sys/dev/usb/usb_transfer.h +++ b/sys/dev/usb/usb_transfer.h @@ -93,7 +93,6 @@ struct usb2_setup_params { struct usb2_device *udev; struct usb2_xfer *curr_xfer; const struct usb2_config *curr_setup; - const struct usb2_config_sub *curr_setup_sub; const struct usb2_pipe_methods *methods; void *buf; usb2_frlength_t *xfer_length_ptr; diff --git a/sys/dev/usb/wlan/if_rum.c b/sys/dev/usb/wlan/if_rum.c index 5b6e72e70423..856ed3801d5a 100644 --- a/sys/dev/usb/wlan/if_rum.c +++ b/sys/dev/usb/wlan/if_rum.c @@ -363,18 +363,18 @@ static const struct usb2_config rum_config[RUM_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (MCLBYTES + RT2573_TX_DESC_SIZE + 8), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = rum_bulk_write_callback, - .mh.timeout = 5000, /* ms */ + .bufsize = (MCLBYTES + RT2573_TX_DESC_SIZE + 8), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = rum_bulk_write_callback, + .timeout = 5000, /* ms */ }, [RUM_BULK_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (MCLBYTES + RT2573_RX_DESC_SIZE), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = rum_bulk_read_callback, + .bufsize = (MCLBYTES + RT2573_RX_DESC_SIZE), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = rum_bulk_read_callback, }, }; diff --git a/sys/dev/usb/wlan/if_ural.c b/sys/dev/usb/wlan/if_ural.c index 39e51e1d92fd..919b66df1459 100644 --- a/sys/dev/usb/wlan/if_ural.c +++ b/sys/dev/usb/wlan/if_ural.c @@ -339,18 +339,18 @@ static const struct usb2_config ural_config[URAL_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = ural_bulk_write_callback, - .mh.timeout = 5000, /* ms */ + .bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = ural_bulk_write_callback, + .timeout = 5000, /* ms */ }, [URAL_BULK_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = ural_bulk_read_callback, + .bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = ural_bulk_read_callback, }, }; diff --git a/sys/dev/usb/wlan/if_zyd.c b/sys/dev/usb/wlan/if_zyd.c index b0342e746ef9..6858d55ab4b2 100644 --- a/sys/dev/usb/wlan/if_zyd.c +++ b/sys/dev/usb/wlan/if_zyd.c @@ -232,38 +232,38 @@ static const struct usb2_config zyd_config[ZYD_N_TRANSFER] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = ZYD_MAX_TXBUFSZ, - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = zyd_bulk_write_callback, + .bufsize = ZYD_MAX_TXBUFSZ, + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = zyd_bulk_write_callback, .ep_index = 0, - .mh.timeout = 10000, /* 10 seconds */ + .timeout = 10000, /* 10 seconds */ }, [ZYD_BULK_RD] = { .type = UE_BULK, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = ZYX_MAX_RXBUFSZ, - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = zyd_bulk_read_callback, + .bufsize = ZYX_MAX_RXBUFSZ, + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = zyd_bulk_read_callback, .ep_index = 0, }, [ZYD_INTR_WR] = { .type = UE_BULK_INTR, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_OUT, - .mh.bufsize = sizeof(struct zyd_cmd), - .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, - .mh.callback = zyd_intr_write_callback, - .mh.timeout = 1000, /* 1 second */ + .bufsize = sizeof(struct zyd_cmd), + .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, + .callback = zyd_intr_write_callback, + .timeout = 1000, /* 1 second */ .ep_index = 1, }, [ZYD_INTR_RD] = { .type = UE_INTERRUPT, .endpoint = UE_ADDR_ANY, .direction = UE_DIR_IN, - .mh.bufsize = sizeof(struct zyd_cmd), - .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, - .mh.callback = zyd_intr_read_callback, + .bufsize = sizeof(struct zyd_cmd), + .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, + .callback = zyd_intr_read_callback, }, }; #define zyd_read16_m(sc, val, data) do { \ -- cgit v1.2.3