102ac6454SAndrew Thompson /*- 202ac6454SAndrew Thompson * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 302ac6454SAndrew Thompson * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved. 402ac6454SAndrew Thompson * Copyright (c) 1998 Lennart Augustsson. All rights reserved. 502ac6454SAndrew Thompson * 602ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without 702ac6454SAndrew Thompson * modification, are permitted provided that the following conditions 802ac6454SAndrew Thompson * are met: 902ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 1002ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer. 1102ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 1202ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 1302ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution. 1402ac6454SAndrew Thompson * 1502ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1602ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1702ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1802ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 1902ac6454SAndrew Thompson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2002ac6454SAndrew Thompson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2102ac6454SAndrew Thompson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2202ac6454SAndrew Thompson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2302ac6454SAndrew Thompson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2402ac6454SAndrew Thompson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2502ac6454SAndrew Thompson * SUCH DAMAGE. 2602ac6454SAndrew Thompson */ 2702ac6454SAndrew Thompson 2802ac6454SAndrew Thompson #include <sys/cdefs.h> 2902ac6454SAndrew Thompson __FBSDID("$FreeBSD$"); 3002ac6454SAndrew Thompson 3102ac6454SAndrew Thompson /* 3202ac6454SAndrew Thompson * USB Universal Host Controller driver. 3302ac6454SAndrew Thompson * Handles e.g. PIIX3 and PIIX4. 3402ac6454SAndrew Thompson * 3502ac6454SAndrew Thompson * UHCI spec: http://developer.intel.com/design/USB/UHCI11D.htm 3602ac6454SAndrew Thompson * USB spec: http://www.usb.org/developers/docs/usbspec.zip 3702ac6454SAndrew Thompson * PIIXn spec: ftp://download.intel.com/design/intarch/datashts/29055002.pdf 3802ac6454SAndrew Thompson * ftp://download.intel.com/design/intarch/datashts/29056201.pdf 3902ac6454SAndrew Thompson */ 4002ac6454SAndrew Thompson 41ed6d949aSAndrew Thompson #include <sys/stdint.h> 42ed6d949aSAndrew Thompson #include <sys/stddef.h> 43ed6d949aSAndrew Thompson #include <sys/param.h> 44ed6d949aSAndrew Thompson #include <sys/queue.h> 45ed6d949aSAndrew Thompson #include <sys/types.h> 46ed6d949aSAndrew Thompson #include <sys/systm.h> 47ed6d949aSAndrew Thompson #include <sys/kernel.h> 48ed6d949aSAndrew Thompson #include <sys/bus.h> 49ed6d949aSAndrew Thompson #include <sys/module.h> 50ed6d949aSAndrew Thompson #include <sys/lock.h> 51ed6d949aSAndrew Thompson #include <sys/mutex.h> 52ed6d949aSAndrew Thompson #include <sys/condvar.h> 53ed6d949aSAndrew Thompson #include <sys/sysctl.h> 54ed6d949aSAndrew Thompson #include <sys/sx.h> 55ed6d949aSAndrew Thompson #include <sys/unistd.h> 56ed6d949aSAndrew Thompson #include <sys/callout.h> 57ed6d949aSAndrew Thompson #include <sys/malloc.h> 58ed6d949aSAndrew Thompson #include <sys/priv.h> 59ed6d949aSAndrew Thompson 6002ac6454SAndrew Thompson #include <dev/usb/usb.h> 61ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h> 6202ac6454SAndrew Thompson 6302ac6454SAndrew Thompson #define USB_DEBUG_VAR uhcidebug 6402ac6454SAndrew Thompson 6502ac6454SAndrew Thompson #include <dev/usb/usb_core.h> 6602ac6454SAndrew Thompson #include <dev/usb/usb_debug.h> 6702ac6454SAndrew Thompson #include <dev/usb/usb_busdma.h> 6802ac6454SAndrew Thompson #include <dev/usb/usb_process.h> 6902ac6454SAndrew Thompson #include <dev/usb/usb_transfer.h> 7002ac6454SAndrew Thompson #include <dev/usb/usb_device.h> 7102ac6454SAndrew Thompson #include <dev/usb/usb_hub.h> 7202ac6454SAndrew Thompson #include <dev/usb/usb_util.h> 7302ac6454SAndrew Thompson 7402ac6454SAndrew Thompson #include <dev/usb/usb_controller.h> 7502ac6454SAndrew Thompson #include <dev/usb/usb_bus.h> 7602ac6454SAndrew Thompson #include <dev/usb/controller/uhci.h> 771def609aSAndrew Thompson #include <dev/usb/controller/uhcireg.h> 7802ac6454SAndrew Thompson 7902ac6454SAndrew Thompson #define alt_next next 80578d0effSAndrew Thompson #define UHCI_BUS2SC(bus) \ 81578d0effSAndrew Thompson ((uhci_softc_t *)(((uint8_t *)(bus)) - \ 82578d0effSAndrew Thompson ((uint8_t *)&(((uhci_softc_t *)0)->sc_bus)))) 8302ac6454SAndrew Thompson 84b850ecc1SAndrew Thompson #ifdef USB_DEBUG 8502ac6454SAndrew Thompson static int uhcidebug = 0; 8602ac6454SAndrew Thompson static int uhcinoloop = 0; 8702ac6454SAndrew Thompson 886472ac3dSEd Schouten static SYSCTL_NODE(_hw_usb, OID_AUTO, uhci, CTLFLAG_RW, 0, "USB uhci"); 89*83cadd7dSHans Petter Selasky SYSCTL_INT(_hw_usb_uhci, OID_AUTO, debug, CTLFLAG_RW | CTLFLAG_TUN, 9002ac6454SAndrew Thompson &uhcidebug, 0, "uhci debug level"); 91c13fd8d4SAndrew Thompson TUNABLE_INT("hw.usb.uhci.debug", &uhcidebug); 92*83cadd7dSHans Petter Selasky SYSCTL_INT(_hw_usb_uhci, OID_AUTO, loop, CTLFLAG_RW | CTLFLAG_TUN, 93*83cadd7dSHans Petter Selasky &uhcinoloop, 0, "uhci noloop"); 94c13fd8d4SAndrew Thompson TUNABLE_INT("hw.usb.uhci.loop", &uhcinoloop); 95c13fd8d4SAndrew Thompson 9602ac6454SAndrew Thompson static void uhci_dumpregs(uhci_softc_t *sc); 9702ac6454SAndrew Thompson static void uhci_dump_tds(uhci_td_t *td); 9802ac6454SAndrew Thompson 9902ac6454SAndrew Thompson #endif 10002ac6454SAndrew Thompson 10102ac6454SAndrew Thompson #define UBARR(sc) bus_space_barrier((sc)->sc_io_tag, (sc)->sc_io_hdl, 0, (sc)->sc_io_size, \ 10202ac6454SAndrew Thompson BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE) 10302ac6454SAndrew Thompson #define UWRITE1(sc, r, x) \ 10402ac6454SAndrew Thompson do { UBARR(sc); bus_space_write_1((sc)->sc_io_tag, (sc)->sc_io_hdl, (r), (x)); \ 10502ac6454SAndrew Thompson } while (/*CONSTCOND*/0) 10602ac6454SAndrew Thompson #define UWRITE2(sc, r, x) \ 10702ac6454SAndrew Thompson do { UBARR(sc); bus_space_write_2((sc)->sc_io_tag, (sc)->sc_io_hdl, (r), (x)); \ 10802ac6454SAndrew Thompson } while (/*CONSTCOND*/0) 10902ac6454SAndrew Thompson #define UWRITE4(sc, r, x) \ 11002ac6454SAndrew Thompson do { UBARR(sc); bus_space_write_4((sc)->sc_io_tag, (sc)->sc_io_hdl, (r), (x)); \ 11102ac6454SAndrew Thompson } while (/*CONSTCOND*/0) 11202ac6454SAndrew Thompson #define UREAD1(sc, r) (UBARR(sc), bus_space_read_1((sc)->sc_io_tag, (sc)->sc_io_hdl, (r))) 11302ac6454SAndrew Thompson #define UREAD2(sc, r) (UBARR(sc), bus_space_read_2((sc)->sc_io_tag, (sc)->sc_io_hdl, (r))) 11402ac6454SAndrew Thompson #define UREAD4(sc, r) (UBARR(sc), bus_space_read_4((sc)->sc_io_tag, (sc)->sc_io_hdl, (r))) 11502ac6454SAndrew Thompson 11602ac6454SAndrew Thompson #define UHCICMD(sc, cmd) UWRITE2(sc, UHCI_CMD, cmd) 11702ac6454SAndrew Thompson #define UHCISTS(sc) UREAD2(sc, UHCI_STS) 11802ac6454SAndrew Thompson 11902ac6454SAndrew Thompson #define UHCI_RESET_TIMEOUT 100 /* ms, reset timeout */ 12002ac6454SAndrew Thompson 12102ac6454SAndrew Thompson #define UHCI_INTR_ENDPT 1 12202ac6454SAndrew Thompson 12302ac6454SAndrew Thompson struct uhci_mem_layout { 12402ac6454SAndrew Thompson 125760bc48eSAndrew Thompson struct usb_page_search buf_res; 126760bc48eSAndrew Thompson struct usb_page_search fix_res; 12702ac6454SAndrew Thompson 128760bc48eSAndrew Thompson struct usb_page_cache *buf_pc; 129760bc48eSAndrew Thompson struct usb_page_cache *fix_pc; 13002ac6454SAndrew Thompson 13102ac6454SAndrew Thompson uint32_t buf_offset; 13202ac6454SAndrew Thompson 13302ac6454SAndrew Thompson uint16_t max_frame_size; 13402ac6454SAndrew Thompson }; 13502ac6454SAndrew Thompson 13602ac6454SAndrew Thompson struct uhci_std_temp { 13702ac6454SAndrew Thompson 13802ac6454SAndrew Thompson struct uhci_mem_layout ml; 13902ac6454SAndrew Thompson uhci_td_t *td; 14002ac6454SAndrew Thompson uhci_td_t *td_next; 14102ac6454SAndrew Thompson uint32_t average; 14202ac6454SAndrew Thompson uint32_t td_status; 14302ac6454SAndrew Thompson uint32_t td_token; 14402ac6454SAndrew Thompson uint32_t len; 14502ac6454SAndrew Thompson uint16_t max_frame_size; 14602ac6454SAndrew Thompson uint8_t shortpkt; 14702ac6454SAndrew Thompson uint8_t setup_alt_next; 1480f7d4548SAndrew Thompson uint8_t last_frame; 14902ac6454SAndrew Thompson }; 15002ac6454SAndrew Thompson 151760bc48eSAndrew Thompson extern struct usb_bus_methods uhci_bus_methods; 152760bc48eSAndrew Thompson extern struct usb_pipe_methods uhci_device_bulk_methods; 153760bc48eSAndrew Thompson extern struct usb_pipe_methods uhci_device_ctrl_methods; 154760bc48eSAndrew Thompson extern struct usb_pipe_methods uhci_device_intr_methods; 155760bc48eSAndrew Thompson extern struct usb_pipe_methods uhci_device_isoc_methods; 15602ac6454SAndrew Thompson 157b9c81a5dSAndrew Thompson static uint8_t uhci_restart(uhci_softc_t *sc); 158760bc48eSAndrew Thompson static void uhci_do_poll(struct usb_bus *); 159e0a69b51SAndrew Thompson static void uhci_device_done(struct usb_xfer *, usb_error_t); 160760bc48eSAndrew Thompson static void uhci_transfer_intr_enqueue(struct usb_xfer *); 16102ac6454SAndrew Thompson static void uhci_timeout(void *); 162760bc48eSAndrew Thompson static uint8_t uhci_check_transfer(struct usb_xfer *); 16339307315SAndrew Thompson static void uhci_root_intr(uhci_softc_t *sc); 16402ac6454SAndrew Thompson 16502ac6454SAndrew Thompson void 166e0a69b51SAndrew Thompson uhci_iterate_hw_softc(struct usb_bus *bus, usb_bus_mem_sub_cb_t *cb) 16702ac6454SAndrew Thompson { 16802ac6454SAndrew Thompson struct uhci_softc *sc = UHCI_BUS2SC(bus); 16902ac6454SAndrew Thompson uint32_t i; 17002ac6454SAndrew Thompson 17102ac6454SAndrew Thompson cb(bus, &sc->sc_hw.pframes_pc, &sc->sc_hw.pframes_pg, 17202ac6454SAndrew Thompson sizeof(uint32_t) * UHCI_FRAMELIST_COUNT, UHCI_FRAMELIST_ALIGN); 17302ac6454SAndrew Thompson 17402ac6454SAndrew Thompson cb(bus, &sc->sc_hw.ls_ctl_start_pc, &sc->sc_hw.ls_ctl_start_pg, 17502ac6454SAndrew Thompson sizeof(uhci_qh_t), UHCI_QH_ALIGN); 17602ac6454SAndrew Thompson 17702ac6454SAndrew Thompson cb(bus, &sc->sc_hw.fs_ctl_start_pc, &sc->sc_hw.fs_ctl_start_pg, 17802ac6454SAndrew Thompson sizeof(uhci_qh_t), UHCI_QH_ALIGN); 17902ac6454SAndrew Thompson 18002ac6454SAndrew Thompson cb(bus, &sc->sc_hw.bulk_start_pc, &sc->sc_hw.bulk_start_pg, 18102ac6454SAndrew Thompson sizeof(uhci_qh_t), UHCI_QH_ALIGN); 18202ac6454SAndrew Thompson 18302ac6454SAndrew Thompson cb(bus, &sc->sc_hw.last_qh_pc, &sc->sc_hw.last_qh_pg, 18402ac6454SAndrew Thompson sizeof(uhci_qh_t), UHCI_QH_ALIGN); 18502ac6454SAndrew Thompson 18602ac6454SAndrew Thompson cb(bus, &sc->sc_hw.last_td_pc, &sc->sc_hw.last_td_pg, 18702ac6454SAndrew Thompson sizeof(uhci_td_t), UHCI_TD_ALIGN); 18802ac6454SAndrew Thompson 18902ac6454SAndrew Thompson for (i = 0; i != UHCI_VFRAMELIST_COUNT; i++) { 19002ac6454SAndrew Thompson cb(bus, sc->sc_hw.isoc_start_pc + i, 19102ac6454SAndrew Thompson sc->sc_hw.isoc_start_pg + i, 19202ac6454SAndrew Thompson sizeof(uhci_td_t), UHCI_TD_ALIGN); 19302ac6454SAndrew Thompson } 19402ac6454SAndrew Thompson 19502ac6454SAndrew Thompson for (i = 0; i != UHCI_IFRAMELIST_COUNT; i++) { 19602ac6454SAndrew Thompson cb(bus, sc->sc_hw.intr_start_pc + i, 19702ac6454SAndrew Thompson sc->sc_hw.intr_start_pg + i, 19802ac6454SAndrew Thompson sizeof(uhci_qh_t), UHCI_QH_ALIGN); 19902ac6454SAndrew Thompson } 20002ac6454SAndrew Thompson } 20102ac6454SAndrew Thompson 20202ac6454SAndrew Thompson static void 203760bc48eSAndrew Thompson uhci_mem_layout_init(struct uhci_mem_layout *ml, struct usb_xfer *xfer) 20402ac6454SAndrew Thompson { 20502ac6454SAndrew Thompson ml->buf_pc = xfer->frbuffers + 0; 20602ac6454SAndrew Thompson ml->fix_pc = xfer->buf_fixup; 20702ac6454SAndrew Thompson 20802ac6454SAndrew Thompson ml->buf_offset = 0; 20902ac6454SAndrew Thompson 21002ac6454SAndrew Thompson ml->max_frame_size = xfer->max_frame_size; 21102ac6454SAndrew Thompson } 21202ac6454SAndrew Thompson 21302ac6454SAndrew Thompson static void 21402ac6454SAndrew Thompson uhci_mem_layout_fixup(struct uhci_mem_layout *ml, struct uhci_td *td) 21502ac6454SAndrew Thompson { 216a593f6b8SAndrew Thompson usbd_get_page(ml->buf_pc, ml->buf_offset, &ml->buf_res); 21702ac6454SAndrew Thompson 21802ac6454SAndrew Thompson if (ml->buf_res.length < td->len) { 21902ac6454SAndrew Thompson 22002ac6454SAndrew Thompson /* need to do a fixup */ 22102ac6454SAndrew Thompson 222a593f6b8SAndrew Thompson usbd_get_page(ml->fix_pc, 0, &ml->fix_res); 22302ac6454SAndrew Thompson 22402ac6454SAndrew Thompson td->td_buffer = htole32(ml->fix_res.physaddr); 22502ac6454SAndrew Thompson 22602ac6454SAndrew Thompson /* 22702ac6454SAndrew Thompson * The UHCI driver cannot handle 22802ac6454SAndrew Thompson * page crossings, so a fixup is 22902ac6454SAndrew Thompson * needed: 23002ac6454SAndrew Thompson * 23102ac6454SAndrew Thompson * +----+----+ - - - 23202ac6454SAndrew Thompson * | YYY|Y | 23302ac6454SAndrew Thompson * +----+----+ - - - 23402ac6454SAndrew Thompson * \ \ 23502ac6454SAndrew Thompson * \ \ 23602ac6454SAndrew Thompson * +----+ 23702ac6454SAndrew Thompson * |YYYY| (fixup) 23802ac6454SAndrew Thompson * +----+ 23902ac6454SAndrew Thompson */ 24002ac6454SAndrew Thompson 24102ac6454SAndrew Thompson if ((td->td_token & htole32(UHCI_TD_PID)) == 24202ac6454SAndrew Thompson htole32(UHCI_TD_PID_IN)) { 24302ac6454SAndrew Thompson td->fix_pc = ml->fix_pc; 244a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(ml->fix_pc); 24502ac6454SAndrew Thompson 24602ac6454SAndrew Thompson } else { 24702ac6454SAndrew Thompson td->fix_pc = NULL; 24802ac6454SAndrew Thompson 24902ac6454SAndrew Thompson /* copy data to fixup location */ 25002ac6454SAndrew Thompson 251a593f6b8SAndrew Thompson usbd_copy_out(ml->buf_pc, ml->buf_offset, 25202ac6454SAndrew Thompson ml->fix_res.buffer, td->len); 25302ac6454SAndrew Thompson 254a593f6b8SAndrew Thompson usb_pc_cpu_flush(ml->fix_pc); 25502ac6454SAndrew Thompson } 25602ac6454SAndrew Thompson 25702ac6454SAndrew Thompson /* prepare next fixup */ 25802ac6454SAndrew Thompson 25902ac6454SAndrew Thompson ml->fix_pc++; 26002ac6454SAndrew Thompson 26102ac6454SAndrew Thompson } else { 26202ac6454SAndrew Thompson 26302ac6454SAndrew Thompson td->td_buffer = htole32(ml->buf_res.physaddr); 26402ac6454SAndrew Thompson td->fix_pc = NULL; 26502ac6454SAndrew Thompson } 26602ac6454SAndrew Thompson 26702ac6454SAndrew Thompson /* prepare next data location */ 26802ac6454SAndrew Thompson 26902ac6454SAndrew Thompson ml->buf_offset += td->len; 27002ac6454SAndrew Thompson } 27102ac6454SAndrew Thompson 272b9c81a5dSAndrew Thompson /* 273b9c81a5dSAndrew Thompson * Return values: 274b9c81a5dSAndrew Thompson * 0: Success 275b9c81a5dSAndrew Thompson * Else: Failure 276b9c81a5dSAndrew Thompson */ 277b9c81a5dSAndrew Thompson static uint8_t 278b9c81a5dSAndrew Thompson uhci_restart(uhci_softc_t *sc) 279b9c81a5dSAndrew Thompson { 280760bc48eSAndrew Thompson struct usb_page_search buf_res; 281b9c81a5dSAndrew Thompson 282b9c81a5dSAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 283b9c81a5dSAndrew Thompson 284b9c81a5dSAndrew Thompson if (UREAD2(sc, UHCI_CMD) & UHCI_CMD_RS) { 285b9c81a5dSAndrew Thompson DPRINTFN(2, "Already started\n"); 286b9c81a5dSAndrew Thompson return (0); 287b9c81a5dSAndrew Thompson } 288b9c81a5dSAndrew Thompson 289b9c81a5dSAndrew Thompson DPRINTFN(2, "Restarting\n"); 290b9c81a5dSAndrew Thompson 291a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); 292b9c81a5dSAndrew Thompson 293b9c81a5dSAndrew Thompson /* Reload fresh base address */ 294b9c81a5dSAndrew Thompson UWRITE4(sc, UHCI_FLBASEADDR, buf_res.physaddr); 295b9c81a5dSAndrew Thompson 296b9c81a5dSAndrew Thompson /* 297b9c81a5dSAndrew Thompson * Assume 64 byte packets at frame end and start HC controller: 298b9c81a5dSAndrew Thompson */ 299b9c81a5dSAndrew Thompson UHCICMD(sc, (UHCI_CMD_MAXP | UHCI_CMD_RS)); 300b9c81a5dSAndrew Thompson 301b9c81a5dSAndrew Thompson /* wait 10 milliseconds */ 302b9c81a5dSAndrew Thompson 303a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100); 304b9c81a5dSAndrew Thompson 305b9c81a5dSAndrew Thompson /* check that controller has started */ 306b9c81a5dSAndrew Thompson 307b9c81a5dSAndrew Thompson if (UREAD2(sc, UHCI_STS) & UHCI_STS_HCH) { 308b9c81a5dSAndrew Thompson DPRINTFN(2, "Failed\n"); 309b9c81a5dSAndrew Thompson return (1); 310b9c81a5dSAndrew Thompson } 311b9c81a5dSAndrew Thompson return (0); 312b9c81a5dSAndrew Thompson } 313b9c81a5dSAndrew Thompson 31402ac6454SAndrew Thompson void 31502ac6454SAndrew Thompson uhci_reset(uhci_softc_t *sc) 31602ac6454SAndrew Thompson { 31702ac6454SAndrew Thompson uint16_t n; 31802ac6454SAndrew Thompson 31902ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 32002ac6454SAndrew Thompson 32102ac6454SAndrew Thompson DPRINTF("resetting the HC\n"); 32202ac6454SAndrew Thompson 32302ac6454SAndrew Thompson /* disable interrupts */ 32402ac6454SAndrew Thompson 32502ac6454SAndrew Thompson UWRITE2(sc, UHCI_INTR, 0); 32602ac6454SAndrew Thompson 32702ac6454SAndrew Thompson /* global reset */ 32802ac6454SAndrew Thompson 32902ac6454SAndrew Thompson UHCICMD(sc, UHCI_CMD_GRESET); 33002ac6454SAndrew Thompson 33102ac6454SAndrew Thompson /* wait */ 33202ac6454SAndrew Thompson 333a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 33402ac6454SAndrew Thompson USB_MS_TO_TICKS(USB_BUS_RESET_DELAY)); 33502ac6454SAndrew Thompson 33602ac6454SAndrew Thompson /* terminate all transfers */ 33702ac6454SAndrew Thompson 33802ac6454SAndrew Thompson UHCICMD(sc, UHCI_CMD_HCRESET); 33902ac6454SAndrew Thompson 34002ac6454SAndrew Thompson /* the reset bit goes low when the controller is done */ 34102ac6454SAndrew Thompson 34202ac6454SAndrew Thompson n = UHCI_RESET_TIMEOUT; 34302ac6454SAndrew Thompson while (n--) { 34402ac6454SAndrew Thompson /* wait one millisecond */ 34502ac6454SAndrew Thompson 346a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); 34702ac6454SAndrew Thompson 34802ac6454SAndrew Thompson if (!(UREAD2(sc, UHCI_CMD) & UHCI_CMD_HCRESET)) { 34902ac6454SAndrew Thompson goto done_1; 35002ac6454SAndrew Thompson } 35102ac6454SAndrew Thompson } 35202ac6454SAndrew Thompson 35302ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, 35402ac6454SAndrew Thompson "controller did not reset\n"); 35502ac6454SAndrew Thompson 35602ac6454SAndrew Thompson done_1: 35702ac6454SAndrew Thompson 35802ac6454SAndrew Thompson n = 10; 35902ac6454SAndrew Thompson while (n--) { 36002ac6454SAndrew Thompson /* wait one millisecond */ 36102ac6454SAndrew Thompson 362a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); 36302ac6454SAndrew Thompson 36402ac6454SAndrew Thompson /* check if HC is stopped */ 36502ac6454SAndrew Thompson if (UREAD2(sc, UHCI_STS) & UHCI_STS_HCH) { 36602ac6454SAndrew Thompson goto done_2; 36702ac6454SAndrew Thompson } 36802ac6454SAndrew Thompson } 36902ac6454SAndrew Thompson 37002ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, 37102ac6454SAndrew Thompson "controller did not stop\n"); 37202ac6454SAndrew Thompson 37302ac6454SAndrew Thompson done_2: 37402ac6454SAndrew Thompson 3752e141748SHans Petter Selasky /* reset frame number */ 3762e141748SHans Petter Selasky UWRITE2(sc, UHCI_FRNUM, 0); 3772e141748SHans Petter Selasky /* set default SOF value */ 3782e141748SHans Petter Selasky UWRITE1(sc, UHCI_SOF, 0x40); 37939307315SAndrew Thompson 38039307315SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 38139307315SAndrew Thompson 38239307315SAndrew Thompson /* stop root interrupt */ 383a593f6b8SAndrew Thompson usb_callout_drain(&sc->sc_root_intr); 38439307315SAndrew Thompson 38539307315SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 38602ac6454SAndrew Thompson } 38702ac6454SAndrew Thompson 38802ac6454SAndrew Thompson static void 38902ac6454SAndrew Thompson uhci_start(uhci_softc_t *sc) 39002ac6454SAndrew Thompson { 39102ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 39202ac6454SAndrew Thompson 39302ac6454SAndrew Thompson DPRINTFN(2, "enabling\n"); 39402ac6454SAndrew Thompson 39502ac6454SAndrew Thompson /* enable interrupts */ 39602ac6454SAndrew Thompson 39702ac6454SAndrew Thompson UWRITE2(sc, UHCI_INTR, 39802ac6454SAndrew Thompson (UHCI_INTR_TOCRCIE | 39902ac6454SAndrew Thompson UHCI_INTR_RIE | 40002ac6454SAndrew Thompson UHCI_INTR_IOCE | 40102ac6454SAndrew Thompson UHCI_INTR_SPIE)); 40202ac6454SAndrew Thompson 403b9c81a5dSAndrew Thompson if (uhci_restart(sc)) { 40402ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, 40502ac6454SAndrew Thompson "cannot start HC controller\n"); 406b9c81a5dSAndrew Thompson } 40702ac6454SAndrew Thompson 40839307315SAndrew Thompson /* start root interrupt */ 40939307315SAndrew Thompson uhci_root_intr(sc); 41002ac6454SAndrew Thompson } 41102ac6454SAndrew Thompson 41202ac6454SAndrew Thompson static struct uhci_qh * 413760bc48eSAndrew Thompson uhci_init_qh(struct usb_page_cache *pc) 41402ac6454SAndrew Thompson { 415760bc48eSAndrew Thompson struct usb_page_search buf_res; 41602ac6454SAndrew Thompson struct uhci_qh *qh; 41702ac6454SAndrew Thompson 418a593f6b8SAndrew Thompson usbd_get_page(pc, 0, &buf_res); 41902ac6454SAndrew Thompson 42002ac6454SAndrew Thompson qh = buf_res.buffer; 42102ac6454SAndrew Thompson 42202ac6454SAndrew Thompson qh->qh_self = 42302ac6454SAndrew Thompson htole32(buf_res.physaddr) | 42402ac6454SAndrew Thompson htole32(UHCI_PTR_QH); 42502ac6454SAndrew Thompson 42602ac6454SAndrew Thompson qh->page_cache = pc; 42702ac6454SAndrew Thompson 42802ac6454SAndrew Thompson return (qh); 42902ac6454SAndrew Thompson } 43002ac6454SAndrew Thompson 43102ac6454SAndrew Thompson static struct uhci_td * 432760bc48eSAndrew Thompson uhci_init_td(struct usb_page_cache *pc) 43302ac6454SAndrew Thompson { 434760bc48eSAndrew Thompson struct usb_page_search buf_res; 43502ac6454SAndrew Thompson struct uhci_td *td; 43602ac6454SAndrew Thompson 437a593f6b8SAndrew Thompson usbd_get_page(pc, 0, &buf_res); 43802ac6454SAndrew Thompson 43902ac6454SAndrew Thompson td = buf_res.buffer; 44002ac6454SAndrew Thompson 44102ac6454SAndrew Thompson td->td_self = 44202ac6454SAndrew Thompson htole32(buf_res.physaddr) | 44302ac6454SAndrew Thompson htole32(UHCI_PTR_TD); 44402ac6454SAndrew Thompson 44502ac6454SAndrew Thompson td->page_cache = pc; 44602ac6454SAndrew Thompson 44702ac6454SAndrew Thompson return (td); 44802ac6454SAndrew Thompson } 44902ac6454SAndrew Thompson 450e0a69b51SAndrew Thompson usb_error_t 45102ac6454SAndrew Thompson uhci_init(uhci_softc_t *sc) 45202ac6454SAndrew Thompson { 45302ac6454SAndrew Thompson uint16_t bit; 45402ac6454SAndrew Thompson uint16_t x; 45502ac6454SAndrew Thompson uint16_t y; 45602ac6454SAndrew Thompson 45702ac6454SAndrew Thompson DPRINTF("start\n"); 45802ac6454SAndrew Thompson 459a593f6b8SAndrew Thompson usb_callout_init_mtx(&sc->sc_root_intr, &sc->sc_bus.bus_mtx, 0); 46039307315SAndrew Thompson 461b850ecc1SAndrew Thompson #ifdef USB_DEBUG 46202ac6454SAndrew Thompson if (uhcidebug > 2) { 46302ac6454SAndrew Thompson uhci_dumpregs(sc); 46402ac6454SAndrew Thompson } 46502ac6454SAndrew Thompson #endif 46602ac6454SAndrew Thompson /* 46702ac6454SAndrew Thompson * Setup QH's 46802ac6454SAndrew Thompson */ 46902ac6454SAndrew Thompson sc->sc_ls_ctl_p_last = 47002ac6454SAndrew Thompson uhci_init_qh(&sc->sc_hw.ls_ctl_start_pc); 47102ac6454SAndrew Thompson 47202ac6454SAndrew Thompson sc->sc_fs_ctl_p_last = 47302ac6454SAndrew Thompson uhci_init_qh(&sc->sc_hw.fs_ctl_start_pc); 47402ac6454SAndrew Thompson 47502ac6454SAndrew Thompson sc->sc_bulk_p_last = 47602ac6454SAndrew Thompson uhci_init_qh(&sc->sc_hw.bulk_start_pc); 47702ac6454SAndrew Thompson #if 0 47802ac6454SAndrew Thompson sc->sc_reclaim_qh_p = 47902ac6454SAndrew Thompson sc->sc_fs_ctl_p_last; 48002ac6454SAndrew Thompson #else 48102ac6454SAndrew Thompson /* setup reclaim looping point */ 48202ac6454SAndrew Thompson sc->sc_reclaim_qh_p = 48302ac6454SAndrew Thompson sc->sc_bulk_p_last; 48402ac6454SAndrew Thompson #endif 48502ac6454SAndrew Thompson 48602ac6454SAndrew Thompson sc->sc_last_qh_p = 48702ac6454SAndrew Thompson uhci_init_qh(&sc->sc_hw.last_qh_pc); 48802ac6454SAndrew Thompson 48902ac6454SAndrew Thompson sc->sc_last_td_p = 49002ac6454SAndrew Thompson uhci_init_td(&sc->sc_hw.last_td_pc); 49102ac6454SAndrew Thompson 49202ac6454SAndrew Thompson for (x = 0; x != UHCI_VFRAMELIST_COUNT; x++) { 49302ac6454SAndrew Thompson sc->sc_isoc_p_last[x] = 49402ac6454SAndrew Thompson uhci_init_td(sc->sc_hw.isoc_start_pc + x); 49502ac6454SAndrew Thompson } 49602ac6454SAndrew Thompson 49702ac6454SAndrew Thompson for (x = 0; x != UHCI_IFRAMELIST_COUNT; x++) { 49802ac6454SAndrew Thompson sc->sc_intr_p_last[x] = 49902ac6454SAndrew Thompson uhci_init_qh(sc->sc_hw.intr_start_pc + x); 50002ac6454SAndrew Thompson } 50102ac6454SAndrew Thompson 50202ac6454SAndrew Thompson /* 50302ac6454SAndrew Thompson * the QHs are arranged to give poll intervals that are 50402ac6454SAndrew Thompson * powers of 2 times 1ms 50502ac6454SAndrew Thompson */ 50602ac6454SAndrew Thompson bit = UHCI_IFRAMELIST_COUNT / 2; 50702ac6454SAndrew Thompson while (bit) { 50802ac6454SAndrew Thompson x = bit; 50902ac6454SAndrew Thompson while (x & bit) { 51002ac6454SAndrew Thompson uhci_qh_t *qh_x; 51102ac6454SAndrew Thompson uhci_qh_t *qh_y; 51202ac6454SAndrew Thompson 51302ac6454SAndrew Thompson y = (x ^ bit) | (bit / 2); 51402ac6454SAndrew Thompson 51502ac6454SAndrew Thompson /* 51602ac6454SAndrew Thompson * the next QH has half the poll interval 51702ac6454SAndrew Thompson */ 51802ac6454SAndrew Thompson qh_x = sc->sc_intr_p_last[x]; 51902ac6454SAndrew Thompson qh_y = sc->sc_intr_p_last[y]; 52002ac6454SAndrew Thompson 52102ac6454SAndrew Thompson qh_x->h_next = NULL; 52202ac6454SAndrew Thompson qh_x->qh_h_next = qh_y->qh_self; 52302ac6454SAndrew Thompson qh_x->e_next = NULL; 52402ac6454SAndrew Thompson qh_x->qh_e_next = htole32(UHCI_PTR_T); 52502ac6454SAndrew Thompson x++; 52602ac6454SAndrew Thompson } 52702ac6454SAndrew Thompson bit >>= 1; 52802ac6454SAndrew Thompson } 52902ac6454SAndrew Thompson 53002ac6454SAndrew Thompson if (1) { 53102ac6454SAndrew Thompson uhci_qh_t *qh_ls; 53202ac6454SAndrew Thompson uhci_qh_t *qh_intr; 53302ac6454SAndrew Thompson 53402ac6454SAndrew Thompson qh_ls = sc->sc_ls_ctl_p_last; 53502ac6454SAndrew Thompson qh_intr = sc->sc_intr_p_last[0]; 53602ac6454SAndrew Thompson 53702ac6454SAndrew Thompson /* start QH for interrupt traffic */ 53802ac6454SAndrew Thompson qh_intr->h_next = qh_ls; 53902ac6454SAndrew Thompson qh_intr->qh_h_next = qh_ls->qh_self; 54002ac6454SAndrew Thompson qh_intr->e_next = 0; 54102ac6454SAndrew Thompson qh_intr->qh_e_next = htole32(UHCI_PTR_T); 54202ac6454SAndrew Thompson } 54302ac6454SAndrew Thompson for (x = 0; x != UHCI_VFRAMELIST_COUNT; x++) { 54402ac6454SAndrew Thompson 54502ac6454SAndrew Thompson uhci_td_t *td_x; 54602ac6454SAndrew Thompson uhci_qh_t *qh_intr; 54702ac6454SAndrew Thompson 54802ac6454SAndrew Thompson td_x = sc->sc_isoc_p_last[x]; 54902ac6454SAndrew Thompson qh_intr = sc->sc_intr_p_last[x | (UHCI_IFRAMELIST_COUNT / 2)]; 55002ac6454SAndrew Thompson 55102ac6454SAndrew Thompson /* start TD for isochronous traffic */ 55202ac6454SAndrew Thompson td_x->next = NULL; 55302ac6454SAndrew Thompson td_x->td_next = qh_intr->qh_self; 55402ac6454SAndrew Thompson td_x->td_status = htole32(UHCI_TD_IOS); 55502ac6454SAndrew Thompson td_x->td_token = htole32(0); 55602ac6454SAndrew Thompson td_x->td_buffer = htole32(0); 55702ac6454SAndrew Thompson } 55802ac6454SAndrew Thompson 55902ac6454SAndrew Thompson if (1) { 56002ac6454SAndrew Thompson uhci_qh_t *qh_ls; 56102ac6454SAndrew Thompson uhci_qh_t *qh_fs; 56202ac6454SAndrew Thompson 56302ac6454SAndrew Thompson qh_ls = sc->sc_ls_ctl_p_last; 56402ac6454SAndrew Thompson qh_fs = sc->sc_fs_ctl_p_last; 56502ac6454SAndrew Thompson 56602ac6454SAndrew Thompson /* start QH where low speed control traffic will be queued */ 56702ac6454SAndrew Thompson qh_ls->h_next = qh_fs; 56802ac6454SAndrew Thompson qh_ls->qh_h_next = qh_fs->qh_self; 56902ac6454SAndrew Thompson qh_ls->e_next = 0; 57002ac6454SAndrew Thompson qh_ls->qh_e_next = htole32(UHCI_PTR_T); 57102ac6454SAndrew Thompson } 57202ac6454SAndrew Thompson if (1) { 57302ac6454SAndrew Thompson uhci_qh_t *qh_ctl; 57402ac6454SAndrew Thompson uhci_qh_t *qh_blk; 57502ac6454SAndrew Thompson uhci_qh_t *qh_lst; 57602ac6454SAndrew Thompson uhci_td_t *td_lst; 57702ac6454SAndrew Thompson 57802ac6454SAndrew Thompson qh_ctl = sc->sc_fs_ctl_p_last; 57902ac6454SAndrew Thompson qh_blk = sc->sc_bulk_p_last; 58002ac6454SAndrew Thompson 58102ac6454SAndrew Thompson /* start QH where full speed control traffic will be queued */ 58202ac6454SAndrew Thompson qh_ctl->h_next = qh_blk; 58302ac6454SAndrew Thompson qh_ctl->qh_h_next = qh_blk->qh_self; 58402ac6454SAndrew Thompson qh_ctl->e_next = 0; 58502ac6454SAndrew Thompson qh_ctl->qh_e_next = htole32(UHCI_PTR_T); 58602ac6454SAndrew Thompson 58702ac6454SAndrew Thompson qh_lst = sc->sc_last_qh_p; 58802ac6454SAndrew Thompson 58902ac6454SAndrew Thompson /* start QH where bulk traffic will be queued */ 59002ac6454SAndrew Thompson qh_blk->h_next = qh_lst; 59102ac6454SAndrew Thompson qh_blk->qh_h_next = qh_lst->qh_self; 59202ac6454SAndrew Thompson qh_blk->e_next = 0; 59302ac6454SAndrew Thompson qh_blk->qh_e_next = htole32(UHCI_PTR_T); 59402ac6454SAndrew Thompson 59502ac6454SAndrew Thompson td_lst = sc->sc_last_td_p; 59602ac6454SAndrew Thompson 59702ac6454SAndrew Thompson /* end QH which is used for looping the QHs */ 59802ac6454SAndrew Thompson qh_lst->h_next = 0; 59902ac6454SAndrew Thompson qh_lst->qh_h_next = htole32(UHCI_PTR_T); /* end of QH chain */ 60002ac6454SAndrew Thompson qh_lst->e_next = td_lst; 60102ac6454SAndrew Thompson qh_lst->qh_e_next = td_lst->td_self; 60202ac6454SAndrew Thompson 60302ac6454SAndrew Thompson /* 60402ac6454SAndrew Thompson * end TD which hangs from the last QH, to avoid a bug in the PIIX 60502ac6454SAndrew Thompson * that makes it run berserk otherwise 60602ac6454SAndrew Thompson */ 60702ac6454SAndrew Thompson td_lst->next = 0; 60802ac6454SAndrew Thompson td_lst->td_next = htole32(UHCI_PTR_T); 60902ac6454SAndrew Thompson td_lst->td_status = htole32(0); /* inactive */ 61002ac6454SAndrew Thompson td_lst->td_token = htole32(0); 61102ac6454SAndrew Thompson td_lst->td_buffer = htole32(0); 61202ac6454SAndrew Thompson } 61302ac6454SAndrew Thompson if (1) { 614760bc48eSAndrew Thompson struct usb_page_search buf_res; 61502ac6454SAndrew Thompson uint32_t *pframes; 61602ac6454SAndrew Thompson 617a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); 61802ac6454SAndrew Thompson 61902ac6454SAndrew Thompson pframes = buf_res.buffer; 62002ac6454SAndrew Thompson 62102ac6454SAndrew Thompson 62202ac6454SAndrew Thompson /* 62302ac6454SAndrew Thompson * Setup UHCI framelist 62402ac6454SAndrew Thompson * 62502ac6454SAndrew Thompson * Execution order: 62602ac6454SAndrew Thompson * 62702ac6454SAndrew Thompson * pframes -> full speed isochronous -> interrupt QH's -> low 62802ac6454SAndrew Thompson * speed control -> full speed control -> bulk transfers 62902ac6454SAndrew Thompson * 63002ac6454SAndrew Thompson */ 63102ac6454SAndrew Thompson 63202ac6454SAndrew Thompson for (x = 0; x != UHCI_FRAMELIST_COUNT; x++) { 63302ac6454SAndrew Thompson pframes[x] = 63402ac6454SAndrew Thompson sc->sc_isoc_p_last[x % UHCI_VFRAMELIST_COUNT]->td_self; 63502ac6454SAndrew Thompson } 63602ac6454SAndrew Thompson } 63702ac6454SAndrew Thompson /* flush all cache into memory */ 63802ac6454SAndrew Thompson 639a593f6b8SAndrew Thompson usb_bus_mem_flush_all(&sc->sc_bus, &uhci_iterate_hw_softc); 64002ac6454SAndrew Thompson 64102ac6454SAndrew Thompson /* set up the bus struct */ 64202ac6454SAndrew Thompson sc->sc_bus.methods = &uhci_bus_methods; 64302ac6454SAndrew Thompson 64402ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 64502ac6454SAndrew Thompson /* reset the controller */ 64602ac6454SAndrew Thompson uhci_reset(sc); 64702ac6454SAndrew Thompson 64802ac6454SAndrew Thompson /* start the controller */ 64902ac6454SAndrew Thompson uhci_start(sc); 65002ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 65102ac6454SAndrew Thompson 65202ac6454SAndrew Thompson /* catch lost interrupts */ 65302ac6454SAndrew Thompson uhci_do_poll(&sc->sc_bus); 65402ac6454SAndrew Thompson 65502ac6454SAndrew Thompson return (0); 65602ac6454SAndrew Thompson } 65702ac6454SAndrew Thompson 6582e141748SHans Petter Selasky static void 65902ac6454SAndrew Thompson uhci_suspend(uhci_softc_t *sc) 66002ac6454SAndrew Thompson { 661b850ecc1SAndrew Thompson #ifdef USB_DEBUG 66202ac6454SAndrew Thompson if (uhcidebug > 2) { 66302ac6454SAndrew Thompson uhci_dumpregs(sc); 66402ac6454SAndrew Thompson } 66502ac6454SAndrew Thompson #endif 66602ac6454SAndrew Thompson 6672e141748SHans Petter Selasky USB_BUS_LOCK(&sc->sc_bus); 66802ac6454SAndrew Thompson 66902ac6454SAndrew Thompson /* stop the controller */ 67002ac6454SAndrew Thompson 67102ac6454SAndrew Thompson uhci_reset(sc); 67202ac6454SAndrew Thompson 67302ac6454SAndrew Thompson /* enter global suspend */ 67402ac6454SAndrew Thompson 67502ac6454SAndrew Thompson UHCICMD(sc, UHCI_CMD_EGSM); 67602ac6454SAndrew Thompson 67702ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 67802ac6454SAndrew Thompson } 67902ac6454SAndrew Thompson 6802e141748SHans Petter Selasky static void 68102ac6454SAndrew Thompson uhci_resume(uhci_softc_t *sc) 68202ac6454SAndrew Thompson { 68302ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 68402ac6454SAndrew Thompson 68502ac6454SAndrew Thompson /* reset the controller */ 68602ac6454SAndrew Thompson 68702ac6454SAndrew Thompson uhci_reset(sc); 68802ac6454SAndrew Thompson 68902ac6454SAndrew Thompson /* force global resume */ 69002ac6454SAndrew Thompson 69102ac6454SAndrew Thompson UHCICMD(sc, UHCI_CMD_FGR); 69202ac6454SAndrew Thompson 69302ac6454SAndrew Thompson /* and start traffic again */ 69402ac6454SAndrew Thompson 69502ac6454SAndrew Thompson uhci_start(sc); 69602ac6454SAndrew Thompson 69702ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 69802ac6454SAndrew Thompson 6992e141748SHans Petter Selasky #ifdef USB_DEBUG 7002e141748SHans Petter Selasky if (uhcidebug > 2) 7012e141748SHans Petter Selasky uhci_dumpregs(sc); 7022e141748SHans Petter Selasky #endif 7032e141748SHans Petter Selasky 70402ac6454SAndrew Thompson /* catch lost interrupts */ 70502ac6454SAndrew Thompson uhci_do_poll(&sc->sc_bus); 70602ac6454SAndrew Thompson } 70702ac6454SAndrew Thompson 708b850ecc1SAndrew Thompson #ifdef USB_DEBUG 70902ac6454SAndrew Thompson static void 71002ac6454SAndrew Thompson uhci_dumpregs(uhci_softc_t *sc) 71102ac6454SAndrew Thompson { 71202ac6454SAndrew Thompson DPRINTFN(0, "%s regs: cmd=%04x, sts=%04x, intr=%04x, frnum=%04x, " 71302ac6454SAndrew Thompson "flbase=%08x, sof=%04x, portsc1=%04x, portsc2=%04x\n", 71402ac6454SAndrew Thompson device_get_nameunit(sc->sc_bus.bdev), 71502ac6454SAndrew Thompson UREAD2(sc, UHCI_CMD), 71602ac6454SAndrew Thompson UREAD2(sc, UHCI_STS), 71702ac6454SAndrew Thompson UREAD2(sc, UHCI_INTR), 71802ac6454SAndrew Thompson UREAD2(sc, UHCI_FRNUM), 71902ac6454SAndrew Thompson UREAD4(sc, UHCI_FLBASEADDR), 72002ac6454SAndrew Thompson UREAD1(sc, UHCI_SOF), 72102ac6454SAndrew Thompson UREAD2(sc, UHCI_PORTSC1), 72202ac6454SAndrew Thompson UREAD2(sc, UHCI_PORTSC2)); 72302ac6454SAndrew Thompson } 72402ac6454SAndrew Thompson 72502ac6454SAndrew Thompson static uint8_t 72602ac6454SAndrew Thompson uhci_dump_td(uhci_td_t *p) 72702ac6454SAndrew Thompson { 72802ac6454SAndrew Thompson uint32_t td_next; 72902ac6454SAndrew Thompson uint32_t td_status; 73002ac6454SAndrew Thompson uint32_t td_token; 73102ac6454SAndrew Thompson uint8_t temp; 73202ac6454SAndrew Thompson 733a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(p->page_cache); 73402ac6454SAndrew Thompson 73502ac6454SAndrew Thompson td_next = le32toh(p->td_next); 73602ac6454SAndrew Thompson td_status = le32toh(p->td_status); 73702ac6454SAndrew Thompson td_token = le32toh(p->td_token); 73802ac6454SAndrew Thompson 73902ac6454SAndrew Thompson /* 74002ac6454SAndrew Thompson * Check whether the link pointer in this TD marks the link pointer 74102ac6454SAndrew Thompson * as end of queue: 74202ac6454SAndrew Thompson */ 74302ac6454SAndrew Thompson temp = ((td_next & UHCI_PTR_T) || (td_next == 0)); 74402ac6454SAndrew Thompson 74502ac6454SAndrew Thompson printf("TD(%p) at 0x%08x = link=0x%08x status=0x%08x " 74602ac6454SAndrew Thompson "token=0x%08x buffer=0x%08x\n", 74702ac6454SAndrew Thompson p, 74802ac6454SAndrew Thompson le32toh(p->td_self), 74902ac6454SAndrew Thompson td_next, 75002ac6454SAndrew Thompson td_status, 75102ac6454SAndrew Thompson td_token, 75202ac6454SAndrew Thompson le32toh(p->td_buffer)); 75302ac6454SAndrew Thompson 75402ac6454SAndrew Thompson printf("TD(%p) td_next=%s%s%s td_status=%s%s%s%s%s%s%s%s%s%s%s, errcnt=%d, actlen=%d pid=%02x," 75502ac6454SAndrew Thompson "addr=%d,endpt=%d,D=%d,maxlen=%d\n", 75602ac6454SAndrew Thompson p, 75702ac6454SAndrew Thompson (td_next & 1) ? "-T" : "", 75802ac6454SAndrew Thompson (td_next & 2) ? "-Q" : "", 75902ac6454SAndrew Thompson (td_next & 4) ? "-VF" : "", 76002ac6454SAndrew Thompson (td_status & UHCI_TD_BITSTUFF) ? "-BITSTUFF" : "", 76102ac6454SAndrew Thompson (td_status & UHCI_TD_CRCTO) ? "-CRCTO" : "", 76202ac6454SAndrew Thompson (td_status & UHCI_TD_NAK) ? "-NAK" : "", 76302ac6454SAndrew Thompson (td_status & UHCI_TD_BABBLE) ? "-BABBLE" : "", 76402ac6454SAndrew Thompson (td_status & UHCI_TD_DBUFFER) ? "-DBUFFER" : "", 76502ac6454SAndrew Thompson (td_status & UHCI_TD_STALLED) ? "-STALLED" : "", 76602ac6454SAndrew Thompson (td_status & UHCI_TD_ACTIVE) ? "-ACTIVE" : "", 76702ac6454SAndrew Thompson (td_status & UHCI_TD_IOC) ? "-IOC" : "", 76802ac6454SAndrew Thompson (td_status & UHCI_TD_IOS) ? "-IOS" : "", 76902ac6454SAndrew Thompson (td_status & UHCI_TD_LS) ? "-LS" : "", 77002ac6454SAndrew Thompson (td_status & UHCI_TD_SPD) ? "-SPD" : "", 77102ac6454SAndrew Thompson UHCI_TD_GET_ERRCNT(td_status), 77202ac6454SAndrew Thompson UHCI_TD_GET_ACTLEN(td_status), 77302ac6454SAndrew Thompson UHCI_TD_GET_PID(td_token), 77402ac6454SAndrew Thompson UHCI_TD_GET_DEVADDR(td_token), 77502ac6454SAndrew Thompson UHCI_TD_GET_ENDPT(td_token), 77602ac6454SAndrew Thompson UHCI_TD_GET_DT(td_token), 77702ac6454SAndrew Thompson UHCI_TD_GET_MAXLEN(td_token)); 77802ac6454SAndrew Thompson 77902ac6454SAndrew Thompson return (temp); 78002ac6454SAndrew Thompson } 78102ac6454SAndrew Thompson 78202ac6454SAndrew Thompson static uint8_t 78302ac6454SAndrew Thompson uhci_dump_qh(uhci_qh_t *sqh) 78402ac6454SAndrew Thompson { 78502ac6454SAndrew Thompson uint8_t temp; 78602ac6454SAndrew Thompson uint32_t qh_h_next; 78702ac6454SAndrew Thompson uint32_t qh_e_next; 78802ac6454SAndrew Thompson 789a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(sqh->page_cache); 79002ac6454SAndrew Thompson 79102ac6454SAndrew Thompson qh_h_next = le32toh(sqh->qh_h_next); 79202ac6454SAndrew Thompson qh_e_next = le32toh(sqh->qh_e_next); 79302ac6454SAndrew Thompson 79402ac6454SAndrew Thompson DPRINTFN(0, "QH(%p) at 0x%08x: h_next=0x%08x e_next=0x%08x\n", sqh, 79502ac6454SAndrew Thompson le32toh(sqh->qh_self), qh_h_next, qh_e_next); 79602ac6454SAndrew Thompson 79702ac6454SAndrew Thompson temp = ((((sqh->h_next != NULL) && !(qh_h_next & UHCI_PTR_T)) ? 1 : 0) | 79802ac6454SAndrew Thompson (((sqh->e_next != NULL) && !(qh_e_next & UHCI_PTR_T)) ? 2 : 0)); 79902ac6454SAndrew Thompson 80002ac6454SAndrew Thompson return (temp); 80102ac6454SAndrew Thompson } 80202ac6454SAndrew Thompson 80302ac6454SAndrew Thompson static void 80402ac6454SAndrew Thompson uhci_dump_all(uhci_softc_t *sc) 80502ac6454SAndrew Thompson { 80602ac6454SAndrew Thompson uhci_dumpregs(sc); 80702ac6454SAndrew Thompson uhci_dump_qh(sc->sc_ls_ctl_p_last); 80802ac6454SAndrew Thompson uhci_dump_qh(sc->sc_fs_ctl_p_last); 80902ac6454SAndrew Thompson uhci_dump_qh(sc->sc_bulk_p_last); 81002ac6454SAndrew Thompson uhci_dump_qh(sc->sc_last_qh_p); 81102ac6454SAndrew Thompson } 81202ac6454SAndrew Thompson 81302ac6454SAndrew Thompson static void 81402ac6454SAndrew Thompson uhci_dump_tds(uhci_td_t *td) 81502ac6454SAndrew Thompson { 81602ac6454SAndrew Thompson for (; 81702ac6454SAndrew Thompson td != NULL; 81802ac6454SAndrew Thompson td = td->obj_next) { 81902ac6454SAndrew Thompson if (uhci_dump_td(td)) { 82002ac6454SAndrew Thompson break; 82102ac6454SAndrew Thompson } 82202ac6454SAndrew Thompson } 82302ac6454SAndrew Thompson } 82402ac6454SAndrew Thompson 82502ac6454SAndrew Thompson #endif 82602ac6454SAndrew Thompson 82702ac6454SAndrew Thompson /* 82802ac6454SAndrew Thompson * Let the last QH loop back to the full speed control transfer QH. 82902ac6454SAndrew Thompson * This is what intel calls "bandwidth reclamation" and improves 83002ac6454SAndrew Thompson * USB performance a lot for some devices. 83102ac6454SAndrew Thompson * If we are already looping, just count it. 83202ac6454SAndrew Thompson */ 83302ac6454SAndrew Thompson static void 83402ac6454SAndrew Thompson uhci_add_loop(uhci_softc_t *sc) 83502ac6454SAndrew Thompson { 83602ac6454SAndrew Thompson struct uhci_qh *qh_lst; 83702ac6454SAndrew Thompson struct uhci_qh *qh_rec; 83802ac6454SAndrew Thompson 839b850ecc1SAndrew Thompson #ifdef USB_DEBUG 84002ac6454SAndrew Thompson if (uhcinoloop) { 84102ac6454SAndrew Thompson return; 84202ac6454SAndrew Thompson } 84302ac6454SAndrew Thompson #endif 84402ac6454SAndrew Thompson if (++(sc->sc_loops) == 1) { 84502ac6454SAndrew Thompson DPRINTFN(6, "add\n"); 84602ac6454SAndrew Thompson 84702ac6454SAndrew Thompson qh_lst = sc->sc_last_qh_p; 84802ac6454SAndrew Thompson qh_rec = sc->sc_reclaim_qh_p; 84902ac6454SAndrew Thompson 85002ac6454SAndrew Thompson /* NOTE: we don't loop back the soft pointer */ 85102ac6454SAndrew Thompson 85202ac6454SAndrew Thompson qh_lst->qh_h_next = qh_rec->qh_self; 853a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh_lst->page_cache); 85402ac6454SAndrew Thompson } 85502ac6454SAndrew Thompson } 85602ac6454SAndrew Thompson 85702ac6454SAndrew Thompson static void 85802ac6454SAndrew Thompson uhci_rem_loop(uhci_softc_t *sc) 85902ac6454SAndrew Thompson { 86002ac6454SAndrew Thompson struct uhci_qh *qh_lst; 86102ac6454SAndrew Thompson 862b850ecc1SAndrew Thompson #ifdef USB_DEBUG 86302ac6454SAndrew Thompson if (uhcinoloop) { 86402ac6454SAndrew Thompson return; 86502ac6454SAndrew Thompson } 86602ac6454SAndrew Thompson #endif 86702ac6454SAndrew Thompson if (--(sc->sc_loops) == 0) { 86802ac6454SAndrew Thompson DPRINTFN(6, "remove\n"); 86902ac6454SAndrew Thompson 87002ac6454SAndrew Thompson qh_lst = sc->sc_last_qh_p; 87102ac6454SAndrew Thompson qh_lst->qh_h_next = htole32(UHCI_PTR_T); 872a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh_lst->page_cache); 87302ac6454SAndrew Thompson } 87402ac6454SAndrew Thompson } 87502ac6454SAndrew Thompson 87602ac6454SAndrew Thompson static void 877760bc48eSAndrew Thompson uhci_transfer_intr_enqueue(struct usb_xfer *xfer) 87802ac6454SAndrew Thompson { 87902ac6454SAndrew Thompson /* check for early completion */ 88002ac6454SAndrew Thompson if (uhci_check_transfer(xfer)) { 88102ac6454SAndrew Thompson return; 88202ac6454SAndrew Thompson } 88302ac6454SAndrew Thompson /* put transfer on interrupt queue */ 884a593f6b8SAndrew Thompson usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); 88502ac6454SAndrew Thompson 88602ac6454SAndrew Thompson /* start timeout, if any */ 88702ac6454SAndrew Thompson if (xfer->timeout != 0) { 888a593f6b8SAndrew Thompson usbd_transfer_timeout_ms(xfer, &uhci_timeout, xfer->timeout); 88902ac6454SAndrew Thompson } 89002ac6454SAndrew Thompson } 89102ac6454SAndrew Thompson 89202ac6454SAndrew Thompson #define UHCI_APPEND_TD(std,last) (last) = _uhci_append_td(std,last) 89302ac6454SAndrew Thompson static uhci_td_t * 89402ac6454SAndrew Thompson _uhci_append_td(uhci_td_t *std, uhci_td_t *last) 89502ac6454SAndrew Thompson { 89602ac6454SAndrew Thompson DPRINTFN(11, "%p to %p\n", std, last); 89702ac6454SAndrew Thompson 89802ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 89902ac6454SAndrew Thompson 90002ac6454SAndrew Thompson std->next = last->next; 90102ac6454SAndrew Thompson std->td_next = last->td_next; 90202ac6454SAndrew Thompson 90302ac6454SAndrew Thompson std->prev = last; 90402ac6454SAndrew Thompson 905a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->page_cache); 90602ac6454SAndrew Thompson 90702ac6454SAndrew Thompson /* 90802ac6454SAndrew Thompson * the last->next->prev is never followed: std->next->prev = std; 90902ac6454SAndrew Thompson */ 91002ac6454SAndrew Thompson last->next = std; 91102ac6454SAndrew Thompson last->td_next = std->td_self; 91202ac6454SAndrew Thompson 913a593f6b8SAndrew Thompson usb_pc_cpu_flush(last->page_cache); 91402ac6454SAndrew Thompson 91502ac6454SAndrew Thompson return (std); 91602ac6454SAndrew Thompson } 91702ac6454SAndrew Thompson 91802ac6454SAndrew Thompson #define UHCI_APPEND_QH(sqh,last) (last) = _uhci_append_qh(sqh,last) 91902ac6454SAndrew Thompson static uhci_qh_t * 92002ac6454SAndrew Thompson _uhci_append_qh(uhci_qh_t *sqh, uhci_qh_t *last) 92102ac6454SAndrew Thompson { 92202ac6454SAndrew Thompson DPRINTFN(11, "%p to %p\n", sqh, last); 92302ac6454SAndrew Thompson 92402ac6454SAndrew Thompson if (sqh->h_prev != NULL) { 92502ac6454SAndrew Thompson /* should not happen */ 92602ac6454SAndrew Thompson DPRINTFN(0, "QH already linked!\n"); 92702ac6454SAndrew Thompson return (last); 92802ac6454SAndrew Thompson } 92902ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 93002ac6454SAndrew Thompson 93102ac6454SAndrew Thompson sqh->h_next = last->h_next; 93202ac6454SAndrew Thompson sqh->qh_h_next = last->qh_h_next; 93302ac6454SAndrew Thompson 93402ac6454SAndrew Thompson sqh->h_prev = last; 93502ac6454SAndrew Thompson 936a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->page_cache); 93702ac6454SAndrew Thompson 93802ac6454SAndrew Thompson /* 93902ac6454SAndrew Thompson * The "last->h_next->h_prev" is never followed: 94002ac6454SAndrew Thompson * 94102ac6454SAndrew Thompson * "sqh->h_next->h_prev" = sqh; 94202ac6454SAndrew Thompson */ 94302ac6454SAndrew Thompson 94402ac6454SAndrew Thompson last->h_next = sqh; 94502ac6454SAndrew Thompson last->qh_h_next = sqh->qh_self; 94602ac6454SAndrew Thompson 947a593f6b8SAndrew Thompson usb_pc_cpu_flush(last->page_cache); 94802ac6454SAndrew Thompson 94902ac6454SAndrew Thompson return (sqh); 95002ac6454SAndrew Thompson } 95102ac6454SAndrew Thompson 95202ac6454SAndrew Thompson /**/ 95302ac6454SAndrew Thompson 95402ac6454SAndrew Thompson #define UHCI_REMOVE_TD(std,last) (last) = _uhci_remove_td(std,last) 95502ac6454SAndrew Thompson static uhci_td_t * 95602ac6454SAndrew Thompson _uhci_remove_td(uhci_td_t *std, uhci_td_t *last) 95702ac6454SAndrew Thompson { 95802ac6454SAndrew Thompson DPRINTFN(11, "%p from %p\n", std, last); 95902ac6454SAndrew Thompson 96002ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 96102ac6454SAndrew Thompson 96202ac6454SAndrew Thompson std->prev->next = std->next; 96302ac6454SAndrew Thompson std->prev->td_next = std->td_next; 96402ac6454SAndrew Thompson 965a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->prev->page_cache); 96602ac6454SAndrew Thompson 96702ac6454SAndrew Thompson if (std->next) { 96802ac6454SAndrew Thompson std->next->prev = std->prev; 969a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->next->page_cache); 97002ac6454SAndrew Thompson } 97102ac6454SAndrew Thompson return ((last == std) ? std->prev : last); 97202ac6454SAndrew Thompson } 97302ac6454SAndrew Thompson 97402ac6454SAndrew Thompson #define UHCI_REMOVE_QH(sqh,last) (last) = _uhci_remove_qh(sqh,last) 97502ac6454SAndrew Thompson static uhci_qh_t * 97602ac6454SAndrew Thompson _uhci_remove_qh(uhci_qh_t *sqh, uhci_qh_t *last) 97702ac6454SAndrew Thompson { 97802ac6454SAndrew Thompson DPRINTFN(11, "%p from %p\n", sqh, last); 97902ac6454SAndrew Thompson 98002ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 98102ac6454SAndrew Thompson 98202ac6454SAndrew Thompson /* only remove if not removed from a queue */ 98302ac6454SAndrew Thompson if (sqh->h_prev) { 98402ac6454SAndrew Thompson 98502ac6454SAndrew Thompson sqh->h_prev->h_next = sqh->h_next; 98602ac6454SAndrew Thompson sqh->h_prev->qh_h_next = sqh->qh_h_next; 98702ac6454SAndrew Thompson 988a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->h_prev->page_cache); 98902ac6454SAndrew Thompson 99002ac6454SAndrew Thompson if (sqh->h_next) { 99102ac6454SAndrew Thompson sqh->h_next->h_prev = sqh->h_prev; 992a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->h_next->page_cache); 99302ac6454SAndrew Thompson } 99402ac6454SAndrew Thompson last = ((last == sqh) ? sqh->h_prev : last); 99502ac6454SAndrew Thompson 99602ac6454SAndrew Thompson sqh->h_prev = 0; 99702ac6454SAndrew Thompson 998a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->page_cache); 99902ac6454SAndrew Thompson } 100002ac6454SAndrew Thompson return (last); 100102ac6454SAndrew Thompson } 100202ac6454SAndrew Thompson 100302ac6454SAndrew Thompson static void 1004760bc48eSAndrew Thompson uhci_isoc_done(uhci_softc_t *sc, struct usb_xfer *xfer) 100502ac6454SAndrew Thompson { 1006760bc48eSAndrew Thompson struct usb_page_search res; 100702ac6454SAndrew Thompson uint32_t nframes = xfer->nframes; 100802ac6454SAndrew Thompson uint32_t status; 100902ac6454SAndrew Thompson uint32_t offset = 0; 101002ac6454SAndrew Thompson uint32_t *plen = xfer->frlengths; 101102ac6454SAndrew Thompson uint16_t len = 0; 101202ac6454SAndrew Thompson uhci_td_t *td = xfer->td_transfer_first; 101302ac6454SAndrew Thompson uhci_td_t **pp_last = &sc->sc_isoc_p_last[xfer->qh_pos]; 101402ac6454SAndrew Thompson 1015ae60fdfbSAndrew Thompson DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n", 1016ae60fdfbSAndrew Thompson xfer, xfer->endpoint); 101702ac6454SAndrew Thompson 101802ac6454SAndrew Thompson /* sync any DMA memory before doing fixups */ 101902ac6454SAndrew Thompson 1020a593f6b8SAndrew Thompson usb_bdma_post_sync(xfer); 102102ac6454SAndrew Thompson 102202ac6454SAndrew Thompson while (nframes--) { 102302ac6454SAndrew Thompson if (td == NULL) { 102402ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 102502ac6454SAndrew Thompson __FUNCTION__, __LINE__); 102602ac6454SAndrew Thompson } 102702ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_p_last[UHCI_VFRAMELIST_COUNT]) { 102802ac6454SAndrew Thompson pp_last = &sc->sc_isoc_p_last[0]; 102902ac6454SAndrew Thompson } 1030b850ecc1SAndrew Thompson #ifdef USB_DEBUG 103102ac6454SAndrew Thompson if (uhcidebug > 5) { 103202ac6454SAndrew Thompson DPRINTF("isoc TD\n"); 103302ac6454SAndrew Thompson uhci_dump_td(td); 103402ac6454SAndrew Thompson } 103502ac6454SAndrew Thompson #endif 1036a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 103702ac6454SAndrew Thompson status = le32toh(td->td_status); 103802ac6454SAndrew Thompson 103902ac6454SAndrew Thompson len = UHCI_TD_GET_ACTLEN(status); 104002ac6454SAndrew Thompson 104102ac6454SAndrew Thompson if (len > *plen) { 104202ac6454SAndrew Thompson len = *plen; 104302ac6454SAndrew Thompson } 104402ac6454SAndrew Thompson if (td->fix_pc) { 104502ac6454SAndrew Thompson 1046a593f6b8SAndrew Thompson usbd_get_page(td->fix_pc, 0, &res); 104702ac6454SAndrew Thompson 104802ac6454SAndrew Thompson /* copy data from fixup location to real location */ 104902ac6454SAndrew Thompson 1050a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->fix_pc); 105102ac6454SAndrew Thompson 1052a593f6b8SAndrew Thompson usbd_copy_in(xfer->frbuffers, offset, 105302ac6454SAndrew Thompson res.buffer, len); 105402ac6454SAndrew Thompson } 105502ac6454SAndrew Thompson offset += *plen; 105602ac6454SAndrew Thompson 105702ac6454SAndrew Thompson *plen = len; 105802ac6454SAndrew Thompson 105902ac6454SAndrew Thompson /* remove TD from schedule */ 106002ac6454SAndrew Thompson UHCI_REMOVE_TD(td, *pp_last); 106102ac6454SAndrew Thompson 106202ac6454SAndrew Thompson pp_last++; 106302ac6454SAndrew Thompson plen++; 106402ac6454SAndrew Thompson td = td->obj_next; 106502ac6454SAndrew Thompson } 106602ac6454SAndrew Thompson 106702ac6454SAndrew Thompson xfer->aframes = xfer->nframes; 106802ac6454SAndrew Thompson } 106902ac6454SAndrew Thompson 1070e0a69b51SAndrew Thompson static usb_error_t 1071760bc48eSAndrew Thompson uhci_non_isoc_done_sub(struct usb_xfer *xfer) 107202ac6454SAndrew Thompson { 1073760bc48eSAndrew Thompson struct usb_page_search res; 107402ac6454SAndrew Thompson uhci_td_t *td; 107502ac6454SAndrew Thompson uhci_td_t *td_alt_next; 107602ac6454SAndrew Thompson uint32_t status; 107702ac6454SAndrew Thompson uint32_t token; 107802ac6454SAndrew Thompson uint16_t len; 107902ac6454SAndrew Thompson 108002ac6454SAndrew Thompson td = xfer->td_transfer_cache; 108102ac6454SAndrew Thompson td_alt_next = td->alt_next; 108202ac6454SAndrew Thompson 108302ac6454SAndrew Thompson if (xfer->aframes != xfer->nframes) { 1084ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, xfer->aframes, 0); 108502ac6454SAndrew Thompson } 108602ac6454SAndrew Thompson while (1) { 108702ac6454SAndrew Thompson 1088a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 108902ac6454SAndrew Thompson status = le32toh(td->td_status); 109002ac6454SAndrew Thompson token = le32toh(td->td_token); 109102ac6454SAndrew Thompson 109202ac6454SAndrew Thompson /* 109302ac6454SAndrew Thompson * Verify the status and add 109402ac6454SAndrew Thompson * up the actual length: 109502ac6454SAndrew Thompson */ 109602ac6454SAndrew Thompson 109702ac6454SAndrew Thompson len = UHCI_TD_GET_ACTLEN(status); 109802ac6454SAndrew Thompson if (len > td->len) { 109902ac6454SAndrew Thompson /* should not happen */ 110002ac6454SAndrew Thompson DPRINTF("Invalid status length, " 110102ac6454SAndrew Thompson "0x%04x/0x%04x bytes\n", len, td->len); 110202ac6454SAndrew Thompson status |= UHCI_TD_STALLED; 110302ac6454SAndrew Thompson 110402ac6454SAndrew Thompson } else if ((xfer->aframes != xfer->nframes) && (len > 0)) { 110502ac6454SAndrew Thompson 110602ac6454SAndrew Thompson if (td->fix_pc) { 110702ac6454SAndrew Thompson 1108a593f6b8SAndrew Thompson usbd_get_page(td->fix_pc, 0, &res); 110902ac6454SAndrew Thompson 111002ac6454SAndrew Thompson /* 111102ac6454SAndrew Thompson * copy data from fixup location to real 111202ac6454SAndrew Thompson * location 111302ac6454SAndrew Thompson */ 111402ac6454SAndrew Thompson 1115a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->fix_pc); 111602ac6454SAndrew Thompson 1117a593f6b8SAndrew Thompson usbd_copy_in(xfer->frbuffers + xfer->aframes, 111802ac6454SAndrew Thompson xfer->frlengths[xfer->aframes], res.buffer, len); 111902ac6454SAndrew Thompson } 112002ac6454SAndrew Thompson /* update actual length */ 112102ac6454SAndrew Thompson 112202ac6454SAndrew Thompson xfer->frlengths[xfer->aframes] += len; 112302ac6454SAndrew Thompson } 112402ac6454SAndrew Thompson /* Check for last transfer */ 112502ac6454SAndrew Thompson if (((void *)td) == xfer->td_transfer_last) { 112602ac6454SAndrew Thompson td = NULL; 112702ac6454SAndrew Thompson break; 112802ac6454SAndrew Thompson } 112902ac6454SAndrew Thompson if (status & UHCI_TD_STALLED) { 113002ac6454SAndrew Thompson /* the transfer is finished */ 113102ac6454SAndrew Thompson td = NULL; 113202ac6454SAndrew Thompson break; 113302ac6454SAndrew Thompson } 113402ac6454SAndrew Thompson /* Check for short transfer */ 113502ac6454SAndrew Thompson if (len != td->len) { 113602ac6454SAndrew Thompson if (xfer->flags_int.short_frames_ok) { 113702ac6454SAndrew Thompson /* follow alt next */ 113802ac6454SAndrew Thompson td = td->alt_next; 113902ac6454SAndrew Thompson } else { 114002ac6454SAndrew Thompson /* the transfer is finished */ 114102ac6454SAndrew Thompson td = NULL; 114202ac6454SAndrew Thompson } 114302ac6454SAndrew Thompson break; 114402ac6454SAndrew Thompson } 114502ac6454SAndrew Thompson td = td->obj_next; 114602ac6454SAndrew Thompson 114702ac6454SAndrew Thompson if (td->alt_next != td_alt_next) { 114802ac6454SAndrew Thompson /* this USB frame is complete */ 114902ac6454SAndrew Thompson break; 115002ac6454SAndrew Thompson } 115102ac6454SAndrew Thompson } 115202ac6454SAndrew Thompson 115302ac6454SAndrew Thompson /* update transfer cache */ 115402ac6454SAndrew Thompson 115502ac6454SAndrew Thompson xfer->td_transfer_cache = td; 115602ac6454SAndrew Thompson 115702ac6454SAndrew Thompson /* update data toggle */ 115802ac6454SAndrew Thompson 1159ae60fdfbSAndrew Thompson xfer->endpoint->toggle_next = (token & UHCI_TD_SET_DT(1)) ? 0 : 1; 116002ac6454SAndrew Thompson 1161b850ecc1SAndrew Thompson #ifdef USB_DEBUG 116202ac6454SAndrew Thompson if (status & UHCI_TD_ERROR) { 116302ac6454SAndrew Thompson DPRINTFN(11, "error, addr=%d, endpt=0x%02x, frame=0x%02x " 116402ac6454SAndrew Thompson "status=%s%s%s%s%s%s%s%s%s%s%s\n", 1165ae60fdfbSAndrew Thompson xfer->address, xfer->endpointno, xfer->aframes, 116602ac6454SAndrew Thompson (status & UHCI_TD_BITSTUFF) ? "[BITSTUFF]" : "", 116702ac6454SAndrew Thompson (status & UHCI_TD_CRCTO) ? "[CRCTO]" : "", 116802ac6454SAndrew Thompson (status & UHCI_TD_NAK) ? "[NAK]" : "", 116902ac6454SAndrew Thompson (status & UHCI_TD_BABBLE) ? "[BABBLE]" : "", 117002ac6454SAndrew Thompson (status & UHCI_TD_DBUFFER) ? "[DBUFFER]" : "", 117102ac6454SAndrew Thompson (status & UHCI_TD_STALLED) ? "[STALLED]" : "", 117202ac6454SAndrew Thompson (status & UHCI_TD_ACTIVE) ? "[ACTIVE]" : "[NOT_ACTIVE]", 117302ac6454SAndrew Thompson (status & UHCI_TD_IOC) ? "[IOC]" : "", 117402ac6454SAndrew Thompson (status & UHCI_TD_IOS) ? "[IOS]" : "", 117502ac6454SAndrew Thompson (status & UHCI_TD_LS) ? "[LS]" : "", 117602ac6454SAndrew Thompson (status & UHCI_TD_SPD) ? "[SPD]" : ""); 117702ac6454SAndrew Thompson } 117802ac6454SAndrew Thompson #endif 117902ac6454SAndrew Thompson return (status & UHCI_TD_STALLED) ? 118002ac6454SAndrew Thompson USB_ERR_STALLED : USB_ERR_NORMAL_COMPLETION; 118102ac6454SAndrew Thompson } 118202ac6454SAndrew Thompson 118302ac6454SAndrew Thompson static void 1184760bc48eSAndrew Thompson uhci_non_isoc_done(struct usb_xfer *xfer) 118502ac6454SAndrew Thompson { 1186e0a69b51SAndrew Thompson usb_error_t err = 0; 118702ac6454SAndrew Thompson 1188ae60fdfbSAndrew Thompson DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n", 1189ae60fdfbSAndrew Thompson xfer, xfer->endpoint); 119002ac6454SAndrew Thompson 1191b850ecc1SAndrew Thompson #ifdef USB_DEBUG 119202ac6454SAndrew Thompson if (uhcidebug > 10) { 119302ac6454SAndrew Thompson uhci_dump_tds(xfer->td_transfer_first); 119402ac6454SAndrew Thompson } 119502ac6454SAndrew Thompson #endif 119602ac6454SAndrew Thompson 119702ac6454SAndrew Thompson /* sync any DMA memory before doing fixups */ 119802ac6454SAndrew Thompson 1199a593f6b8SAndrew Thompson usb_bdma_post_sync(xfer); 120002ac6454SAndrew Thompson 120102ac6454SAndrew Thompson /* reset scanner */ 120202ac6454SAndrew Thompson 120302ac6454SAndrew Thompson xfer->td_transfer_cache = xfer->td_transfer_first; 120402ac6454SAndrew Thompson 120502ac6454SAndrew Thompson if (xfer->flags_int.control_xfr) { 120602ac6454SAndrew Thompson if (xfer->flags_int.control_hdr) { 120702ac6454SAndrew Thompson 120802ac6454SAndrew Thompson err = uhci_non_isoc_done_sub(xfer); 120902ac6454SAndrew Thompson } 121002ac6454SAndrew Thompson xfer->aframes = 1; 121102ac6454SAndrew Thompson 121202ac6454SAndrew Thompson if (xfer->td_transfer_cache == NULL) { 121302ac6454SAndrew Thompson goto done; 121402ac6454SAndrew Thompson } 121502ac6454SAndrew Thompson } 121602ac6454SAndrew Thompson while (xfer->aframes != xfer->nframes) { 121702ac6454SAndrew Thompson 121802ac6454SAndrew Thompson err = uhci_non_isoc_done_sub(xfer); 121902ac6454SAndrew Thompson xfer->aframes++; 122002ac6454SAndrew Thompson 122102ac6454SAndrew Thompson if (xfer->td_transfer_cache == NULL) { 122202ac6454SAndrew Thompson goto done; 122302ac6454SAndrew Thompson } 122402ac6454SAndrew Thompson } 122502ac6454SAndrew Thompson 122602ac6454SAndrew Thompson if (xfer->flags_int.control_xfr && 122702ac6454SAndrew Thompson !xfer->flags_int.control_act) { 122802ac6454SAndrew Thompson 122902ac6454SAndrew Thompson err = uhci_non_isoc_done_sub(xfer); 123002ac6454SAndrew Thompson } 123102ac6454SAndrew Thompson done: 123202ac6454SAndrew Thompson uhci_device_done(xfer, err); 123302ac6454SAndrew Thompson } 123402ac6454SAndrew Thompson 123502ac6454SAndrew Thompson /*------------------------------------------------------------------------* 123602ac6454SAndrew Thompson * uhci_check_transfer_sub 123702ac6454SAndrew Thompson * 123802ac6454SAndrew Thompson * The main purpose of this function is to update the data-toggle 123902ac6454SAndrew Thompson * in case it is wrong. 124002ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 124102ac6454SAndrew Thompson static void 1242760bc48eSAndrew Thompson uhci_check_transfer_sub(struct usb_xfer *xfer) 124302ac6454SAndrew Thompson { 124402ac6454SAndrew Thompson uhci_qh_t *qh; 124502ac6454SAndrew Thompson uhci_td_t *td; 124602ac6454SAndrew Thompson uhci_td_t *td_alt_next; 124702ac6454SAndrew Thompson 124802ac6454SAndrew Thompson uint32_t td_token; 124902ac6454SAndrew Thompson uint32_t td_self; 125002ac6454SAndrew Thompson 125102ac6454SAndrew Thompson td = xfer->td_transfer_cache; 125202ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 125302ac6454SAndrew Thompson 125402ac6454SAndrew Thompson td_token = td->obj_next->td_token; 125502ac6454SAndrew Thompson td = td->alt_next; 125602ac6454SAndrew Thompson xfer->td_transfer_cache = td; 125702ac6454SAndrew Thompson td_self = td->td_self; 125802ac6454SAndrew Thompson td_alt_next = td->alt_next; 125902ac6454SAndrew Thompson 12600f7d4548SAndrew Thompson if (xfer->flags_int.control_xfr) 12610f7d4548SAndrew Thompson goto skip; /* don't touch the DT value! */ 12620f7d4548SAndrew Thompson 12630f7d4548SAndrew Thompson if (!((td->td_token ^ td_token) & htole32(UHCI_TD_SET_DT(1)))) 12640f7d4548SAndrew Thompson goto skip; /* data toggle has correct value */ 126502ac6454SAndrew Thompson 126602ac6454SAndrew Thompson /* 12670f7d4548SAndrew Thompson * The data toggle is wrong and we need to toggle it ! 126802ac6454SAndrew Thompson */ 126902ac6454SAndrew Thompson while (1) { 127002ac6454SAndrew Thompson 127102ac6454SAndrew Thompson td->td_token ^= htole32(UHCI_TD_SET_DT(1)); 1272a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 127302ac6454SAndrew Thompson 127402ac6454SAndrew Thompson if (td == xfer->td_transfer_last) { 127502ac6454SAndrew Thompson /* last transfer */ 127602ac6454SAndrew Thompson break; 127702ac6454SAndrew Thompson } 127802ac6454SAndrew Thompson td = td->obj_next; 127902ac6454SAndrew Thompson 128002ac6454SAndrew Thompson if (td->alt_next != td_alt_next) { 128102ac6454SAndrew Thompson /* next frame */ 128202ac6454SAndrew Thompson break; 128302ac6454SAndrew Thompson } 128402ac6454SAndrew Thompson } 12850f7d4548SAndrew Thompson skip: 12860f7d4548SAndrew Thompson 128702ac6454SAndrew Thompson /* update the QH */ 128802ac6454SAndrew Thompson qh->qh_e_next = td_self; 1289a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh->page_cache); 129002ac6454SAndrew Thompson 129102ac6454SAndrew Thompson DPRINTFN(13, "xfer=%p following alt next\n", xfer); 129202ac6454SAndrew Thompson } 129302ac6454SAndrew Thompson 129402ac6454SAndrew Thompson /*------------------------------------------------------------------------* 129502ac6454SAndrew Thompson * uhci_check_transfer 129602ac6454SAndrew Thompson * 129702ac6454SAndrew Thompson * Return values: 129802ac6454SAndrew Thompson * 0: USB transfer is not finished 129902ac6454SAndrew Thompson * Else: USB transfer is finished 130002ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 130102ac6454SAndrew Thompson static uint8_t 1302760bc48eSAndrew Thompson uhci_check_transfer(struct usb_xfer *xfer) 130302ac6454SAndrew Thompson { 130402ac6454SAndrew Thompson uint32_t status; 130502ac6454SAndrew Thompson uint32_t token; 130602ac6454SAndrew Thompson uhci_td_t *td; 130702ac6454SAndrew Thompson 130802ac6454SAndrew Thompson DPRINTFN(16, "xfer=%p checking transfer\n", xfer); 130902ac6454SAndrew Thompson 1310ae60fdfbSAndrew Thompson if (xfer->endpoint->methods == &uhci_device_isoc_methods) { 131102ac6454SAndrew Thompson /* isochronous transfer */ 131202ac6454SAndrew Thompson 131302ac6454SAndrew Thompson td = xfer->td_transfer_last; 131402ac6454SAndrew Thompson 1315a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 131602ac6454SAndrew Thompson status = le32toh(td->td_status); 131702ac6454SAndrew Thompson 131802ac6454SAndrew Thompson /* check also if the first is complete */ 131902ac6454SAndrew Thompson 132002ac6454SAndrew Thompson td = xfer->td_transfer_first; 132102ac6454SAndrew Thompson 1322a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 132302ac6454SAndrew Thompson status |= le32toh(td->td_status); 132402ac6454SAndrew Thompson 132502ac6454SAndrew Thompson if (!(status & UHCI_TD_ACTIVE)) { 132602ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_NORMAL_COMPLETION); 132702ac6454SAndrew Thompson goto transferred; 132802ac6454SAndrew Thompson } 132902ac6454SAndrew Thompson } else { 133002ac6454SAndrew Thompson /* non-isochronous transfer */ 133102ac6454SAndrew Thompson 133202ac6454SAndrew Thompson /* 133302ac6454SAndrew Thompson * check whether there is an error somewhere 133402ac6454SAndrew Thompson * in the middle, or whether there was a short 133502ac6454SAndrew Thompson * packet (SPD and not ACTIVE) 133602ac6454SAndrew Thompson */ 133702ac6454SAndrew Thompson td = xfer->td_transfer_cache; 133802ac6454SAndrew Thompson 133902ac6454SAndrew Thompson while (1) { 1340a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 134102ac6454SAndrew Thompson status = le32toh(td->td_status); 134202ac6454SAndrew Thompson token = le32toh(td->td_token); 134302ac6454SAndrew Thompson 134402ac6454SAndrew Thompson /* 134502ac6454SAndrew Thompson * if there is an active TD the transfer isn't done 134602ac6454SAndrew Thompson */ 134702ac6454SAndrew Thompson if (status & UHCI_TD_ACTIVE) { 134802ac6454SAndrew Thompson /* update cache */ 134902ac6454SAndrew Thompson xfer->td_transfer_cache = td; 135002ac6454SAndrew Thompson goto done; 135102ac6454SAndrew Thompson } 135202ac6454SAndrew Thompson /* 135302ac6454SAndrew Thompson * last transfer descriptor makes the transfer done 135402ac6454SAndrew Thompson */ 135502ac6454SAndrew Thompson if (((void *)td) == xfer->td_transfer_last) { 135602ac6454SAndrew Thompson break; 135702ac6454SAndrew Thompson } 135802ac6454SAndrew Thompson /* 135902ac6454SAndrew Thompson * any kind of error makes the transfer done 136002ac6454SAndrew Thompson */ 136102ac6454SAndrew Thompson if (status & UHCI_TD_STALLED) { 136202ac6454SAndrew Thompson break; 136302ac6454SAndrew Thompson } 136402ac6454SAndrew Thompson /* 136502ac6454SAndrew Thompson * check if we reached the last packet 136602ac6454SAndrew Thompson * or if there is a short packet: 136702ac6454SAndrew Thompson */ 136802ac6454SAndrew Thompson if ((td->td_next == htole32(UHCI_PTR_T)) || 136902ac6454SAndrew Thompson (UHCI_TD_GET_ACTLEN(status) < td->len)) { 137002ac6454SAndrew Thompson 137102ac6454SAndrew Thompson if (xfer->flags_int.short_frames_ok) { 137202ac6454SAndrew Thompson /* follow alt next */ 137302ac6454SAndrew Thompson if (td->alt_next) { 137402ac6454SAndrew Thompson /* update cache */ 137502ac6454SAndrew Thompson xfer->td_transfer_cache = td; 137602ac6454SAndrew Thompson uhci_check_transfer_sub(xfer); 137702ac6454SAndrew Thompson goto done; 137802ac6454SAndrew Thompson } 137902ac6454SAndrew Thompson } 138002ac6454SAndrew Thompson /* transfer is done */ 138102ac6454SAndrew Thompson break; 138202ac6454SAndrew Thompson } 138302ac6454SAndrew Thompson td = td->obj_next; 138402ac6454SAndrew Thompson } 138502ac6454SAndrew Thompson uhci_non_isoc_done(xfer); 138602ac6454SAndrew Thompson goto transferred; 138702ac6454SAndrew Thompson } 138802ac6454SAndrew Thompson 138902ac6454SAndrew Thompson done: 139002ac6454SAndrew Thompson DPRINTFN(13, "xfer=%p is still active\n", xfer); 139102ac6454SAndrew Thompson return (0); 139202ac6454SAndrew Thompson 139302ac6454SAndrew Thompson transferred: 139402ac6454SAndrew Thompson return (1); 139502ac6454SAndrew Thompson } 139602ac6454SAndrew Thompson 139702ac6454SAndrew Thompson static void 139802ac6454SAndrew Thompson uhci_interrupt_poll(uhci_softc_t *sc) 139902ac6454SAndrew Thompson { 1400760bc48eSAndrew Thompson struct usb_xfer *xfer; 140102ac6454SAndrew Thompson 140202ac6454SAndrew Thompson repeat: 140302ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 140402ac6454SAndrew Thompson /* 140502ac6454SAndrew Thompson * check if transfer is transferred 140602ac6454SAndrew Thompson */ 140702ac6454SAndrew Thompson if (uhci_check_transfer(xfer)) { 140802ac6454SAndrew Thompson /* queue has been modified */ 140902ac6454SAndrew Thompson goto repeat; 141002ac6454SAndrew Thompson } 141102ac6454SAndrew Thompson } 141202ac6454SAndrew Thompson } 141302ac6454SAndrew Thompson 141402ac6454SAndrew Thompson /*------------------------------------------------------------------------* 141502ac6454SAndrew Thompson * uhci_interrupt - UHCI interrupt handler 141602ac6454SAndrew Thompson * 141702ac6454SAndrew Thompson * NOTE: Do not access "sc->sc_bus.bdev" inside the interrupt handler, 141802ac6454SAndrew Thompson * hence the interrupt handler will be setup before "sc->sc_bus.bdev" 141902ac6454SAndrew Thompson * is present ! 142002ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 142102ac6454SAndrew Thompson void 142202ac6454SAndrew Thompson uhci_interrupt(uhci_softc_t *sc) 142302ac6454SAndrew Thompson { 142402ac6454SAndrew Thompson uint32_t status; 142502ac6454SAndrew Thompson 142602ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 142702ac6454SAndrew Thompson 142802ac6454SAndrew Thompson DPRINTFN(16, "real interrupt\n"); 142902ac6454SAndrew Thompson 1430b850ecc1SAndrew Thompson #ifdef USB_DEBUG 143102ac6454SAndrew Thompson if (uhcidebug > 15) { 143202ac6454SAndrew Thompson uhci_dumpregs(sc); 143302ac6454SAndrew Thompson } 143402ac6454SAndrew Thompson #endif 143502ac6454SAndrew Thompson status = UREAD2(sc, UHCI_STS) & UHCI_STS_ALLINTRS; 143602ac6454SAndrew Thompson if (status == 0) { 143702ac6454SAndrew Thompson /* the interrupt was not for us */ 143802ac6454SAndrew Thompson goto done; 143902ac6454SAndrew Thompson } 144002ac6454SAndrew Thompson if (status & (UHCI_STS_RD | UHCI_STS_HSE | 144102ac6454SAndrew Thompson UHCI_STS_HCPE | UHCI_STS_HCH)) { 144202ac6454SAndrew Thompson 144302ac6454SAndrew Thompson if (status & UHCI_STS_RD) { 1444b850ecc1SAndrew Thompson #ifdef USB_DEBUG 144502ac6454SAndrew Thompson printf("%s: resume detect\n", 144602ac6454SAndrew Thompson __FUNCTION__); 144702ac6454SAndrew Thompson #endif 144802ac6454SAndrew Thompson } 144902ac6454SAndrew Thompson if (status & UHCI_STS_HSE) { 145002ac6454SAndrew Thompson printf("%s: host system error\n", 145102ac6454SAndrew Thompson __FUNCTION__); 145202ac6454SAndrew Thompson } 145302ac6454SAndrew Thompson if (status & UHCI_STS_HCPE) { 145402ac6454SAndrew Thompson printf("%s: host controller process error\n", 145502ac6454SAndrew Thompson __FUNCTION__); 145602ac6454SAndrew Thompson } 145702ac6454SAndrew Thompson if (status & UHCI_STS_HCH) { 145802ac6454SAndrew Thompson /* no acknowledge needed */ 145902ac6454SAndrew Thompson DPRINTF("%s: host controller halted\n", 146002ac6454SAndrew Thompson __FUNCTION__); 1461b850ecc1SAndrew Thompson #ifdef USB_DEBUG 146202ac6454SAndrew Thompson if (uhcidebug > 0) { 146302ac6454SAndrew Thompson uhci_dump_all(sc); 146402ac6454SAndrew Thompson } 146502ac6454SAndrew Thompson #endif 146602ac6454SAndrew Thompson } 146702ac6454SAndrew Thompson } 146802ac6454SAndrew Thompson /* get acknowledge bits */ 146902ac6454SAndrew Thompson status &= (UHCI_STS_USBINT | 147002ac6454SAndrew Thompson UHCI_STS_USBEI | 147102ac6454SAndrew Thompson UHCI_STS_RD | 147202ac6454SAndrew Thompson UHCI_STS_HSE | 147302ac6454SAndrew Thompson UHCI_STS_HCPE); 147402ac6454SAndrew Thompson 147502ac6454SAndrew Thompson if (status == 0) { 147602ac6454SAndrew Thompson /* nothing to acknowledge */ 147702ac6454SAndrew Thompson goto done; 147802ac6454SAndrew Thompson } 147902ac6454SAndrew Thompson /* acknowledge interrupts */ 148002ac6454SAndrew Thompson UWRITE2(sc, UHCI_STS, status); 148102ac6454SAndrew Thompson 148202ac6454SAndrew Thompson /* poll all the USB transfers */ 148302ac6454SAndrew Thompson uhci_interrupt_poll(sc); 148402ac6454SAndrew Thompson 148502ac6454SAndrew Thompson done: 148602ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 148702ac6454SAndrew Thompson } 148802ac6454SAndrew Thompson 148902ac6454SAndrew Thompson /* 149002ac6454SAndrew Thompson * called when a request does not complete 149102ac6454SAndrew Thompson */ 149202ac6454SAndrew Thompson static void 149302ac6454SAndrew Thompson uhci_timeout(void *arg) 149402ac6454SAndrew Thompson { 1495760bc48eSAndrew Thompson struct usb_xfer *xfer = arg; 149602ac6454SAndrew Thompson 149702ac6454SAndrew Thompson DPRINTF("xfer=%p\n", xfer); 149802ac6454SAndrew Thompson 149902ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); 150002ac6454SAndrew Thompson 150102ac6454SAndrew Thompson /* transfer is transferred */ 150202ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_TIMEOUT); 150302ac6454SAndrew Thompson } 150402ac6454SAndrew Thompson 150502ac6454SAndrew Thompson static void 1506760bc48eSAndrew Thompson uhci_do_poll(struct usb_bus *bus) 150702ac6454SAndrew Thompson { 150802ac6454SAndrew Thompson struct uhci_softc *sc = UHCI_BUS2SC(bus); 150902ac6454SAndrew Thompson 151002ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 151102ac6454SAndrew Thompson uhci_interrupt_poll(sc); 151202ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 151302ac6454SAndrew Thompson } 151402ac6454SAndrew Thompson 151502ac6454SAndrew Thompson static void 151602ac6454SAndrew Thompson uhci_setup_standard_chain_sub(struct uhci_std_temp *temp) 151702ac6454SAndrew Thompson { 151802ac6454SAndrew Thompson uhci_td_t *td; 151902ac6454SAndrew Thompson uhci_td_t *td_next; 152002ac6454SAndrew Thompson uhci_td_t *td_alt_next; 152102ac6454SAndrew Thompson uint32_t average; 152202ac6454SAndrew Thompson uint32_t len_old; 152302ac6454SAndrew Thompson uint8_t shortpkt_old; 152402ac6454SAndrew Thompson uint8_t precompute; 152502ac6454SAndrew Thompson 152602ac6454SAndrew Thompson td_alt_next = NULL; 152702ac6454SAndrew Thompson shortpkt_old = temp->shortpkt; 152802ac6454SAndrew Thompson len_old = temp->len; 152902ac6454SAndrew Thompson precompute = 1; 153002ac6454SAndrew Thompson 153102ac6454SAndrew Thompson /* software is used to detect short incoming transfers */ 153202ac6454SAndrew Thompson 153302ac6454SAndrew Thompson if ((temp->td_token & htole32(UHCI_TD_PID)) == htole32(UHCI_TD_PID_IN)) { 153402ac6454SAndrew Thompson temp->td_status |= htole32(UHCI_TD_SPD); 153502ac6454SAndrew Thompson } else { 153602ac6454SAndrew Thompson temp->td_status &= ~htole32(UHCI_TD_SPD); 153702ac6454SAndrew Thompson } 153802ac6454SAndrew Thompson 153902ac6454SAndrew Thompson temp->ml.buf_offset = 0; 154002ac6454SAndrew Thompson 154102ac6454SAndrew Thompson restart: 154202ac6454SAndrew Thompson 154302ac6454SAndrew Thompson temp->td_token &= ~htole32(UHCI_TD_SET_MAXLEN(0)); 154402ac6454SAndrew Thompson temp->td_token |= htole32(UHCI_TD_SET_MAXLEN(temp->average)); 154502ac6454SAndrew Thompson 154602ac6454SAndrew Thompson td = temp->td; 154702ac6454SAndrew Thompson td_next = temp->td_next; 154802ac6454SAndrew Thompson 154902ac6454SAndrew Thompson while (1) { 155002ac6454SAndrew Thompson 155102ac6454SAndrew Thompson if (temp->len == 0) { 155202ac6454SAndrew Thompson 155302ac6454SAndrew Thompson if (temp->shortpkt) { 155402ac6454SAndrew Thompson break; 155502ac6454SAndrew Thompson } 155602ac6454SAndrew Thompson /* send a Zero Length Packet, ZLP, last */ 155702ac6454SAndrew Thompson 155802ac6454SAndrew Thompson temp->shortpkt = 1; 155902ac6454SAndrew Thompson temp->td_token |= htole32(UHCI_TD_SET_MAXLEN(0)); 156002ac6454SAndrew Thompson average = 0; 156102ac6454SAndrew Thompson 156202ac6454SAndrew Thompson } else { 156302ac6454SAndrew Thompson 156402ac6454SAndrew Thompson average = temp->average; 156502ac6454SAndrew Thompson 156602ac6454SAndrew Thompson if (temp->len < average) { 156702ac6454SAndrew Thompson temp->shortpkt = 1; 156802ac6454SAndrew Thompson temp->td_token &= ~htole32(UHCI_TD_SET_MAXLEN(0)); 156902ac6454SAndrew Thompson temp->td_token |= htole32(UHCI_TD_SET_MAXLEN(temp->len)); 157002ac6454SAndrew Thompson average = temp->len; 157102ac6454SAndrew Thompson } 157202ac6454SAndrew Thompson } 157302ac6454SAndrew Thompson 157402ac6454SAndrew Thompson if (td_next == NULL) { 157502ac6454SAndrew Thompson panic("%s: out of UHCI transfer descriptors!", __FUNCTION__); 157602ac6454SAndrew Thompson } 157702ac6454SAndrew Thompson /* get next TD */ 157802ac6454SAndrew Thompson 157902ac6454SAndrew Thompson td = td_next; 158002ac6454SAndrew Thompson td_next = td->obj_next; 158102ac6454SAndrew Thompson 158202ac6454SAndrew Thompson /* check if we are pre-computing */ 158302ac6454SAndrew Thompson 158402ac6454SAndrew Thompson if (precompute) { 158502ac6454SAndrew Thompson 158602ac6454SAndrew Thompson /* update remaining length */ 158702ac6454SAndrew Thompson 158802ac6454SAndrew Thompson temp->len -= average; 158902ac6454SAndrew Thompson 159002ac6454SAndrew Thompson continue; 159102ac6454SAndrew Thompson } 159202ac6454SAndrew Thompson /* fill out current TD */ 159302ac6454SAndrew Thompson 159402ac6454SAndrew Thompson td->td_status = temp->td_status; 159502ac6454SAndrew Thompson td->td_token = temp->td_token; 159602ac6454SAndrew Thompson 159702ac6454SAndrew Thompson /* update data toggle */ 159802ac6454SAndrew Thompson 159902ac6454SAndrew Thompson temp->td_token ^= htole32(UHCI_TD_SET_DT(1)); 160002ac6454SAndrew Thompson 160102ac6454SAndrew Thompson if (average == 0) { 160202ac6454SAndrew Thompson 160302ac6454SAndrew Thompson td->len = 0; 160402ac6454SAndrew Thompson td->td_buffer = 0; 160502ac6454SAndrew Thompson td->fix_pc = NULL; 160602ac6454SAndrew Thompson 160702ac6454SAndrew Thompson } else { 160802ac6454SAndrew Thompson 160902ac6454SAndrew Thompson /* update remaining length */ 161002ac6454SAndrew Thompson 161102ac6454SAndrew Thompson temp->len -= average; 161202ac6454SAndrew Thompson 161302ac6454SAndrew Thompson td->len = average; 161402ac6454SAndrew Thompson 161502ac6454SAndrew Thompson /* fill out buffer pointer and do fixup, if any */ 161602ac6454SAndrew Thompson 161702ac6454SAndrew Thompson uhci_mem_layout_fixup(&temp->ml, td); 161802ac6454SAndrew Thompson } 161902ac6454SAndrew Thompson 162002ac6454SAndrew Thompson td->alt_next = td_alt_next; 162102ac6454SAndrew Thompson 162202ac6454SAndrew Thompson if ((td_next == td_alt_next) && temp->setup_alt_next) { 162302ac6454SAndrew Thompson /* we need to receive these frames one by one ! */ 162402ac6454SAndrew Thompson td->td_status |= htole32(UHCI_TD_IOC); 162502ac6454SAndrew Thompson td->td_next = htole32(UHCI_PTR_T); 162602ac6454SAndrew Thompson } else { 162702ac6454SAndrew Thompson if (td_next) { 162802ac6454SAndrew Thompson /* link the current TD with the next one */ 162902ac6454SAndrew Thompson td->td_next = td_next->td_self; 163002ac6454SAndrew Thompson } 163102ac6454SAndrew Thompson } 163202ac6454SAndrew Thompson 1633a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 163402ac6454SAndrew Thompson } 163502ac6454SAndrew Thompson 163602ac6454SAndrew Thompson if (precompute) { 163702ac6454SAndrew Thompson precompute = 0; 163802ac6454SAndrew Thompson 163902ac6454SAndrew Thompson /* setup alt next pointer, if any */ 16400f7d4548SAndrew Thompson if (temp->last_frame) { 16410f7d4548SAndrew Thompson td_alt_next = NULL; 164202ac6454SAndrew Thompson } else { 164302ac6454SAndrew Thompson /* we use this field internally */ 164402ac6454SAndrew Thompson td_alt_next = td_next; 164502ac6454SAndrew Thompson } 164602ac6454SAndrew Thompson 164702ac6454SAndrew Thompson /* restore */ 164802ac6454SAndrew Thompson temp->shortpkt = shortpkt_old; 164902ac6454SAndrew Thompson temp->len = len_old; 165002ac6454SAndrew Thompson goto restart; 165102ac6454SAndrew Thompson } 165202ac6454SAndrew Thompson temp->td = td; 165302ac6454SAndrew Thompson temp->td_next = td_next; 165402ac6454SAndrew Thompson } 165502ac6454SAndrew Thompson 165602ac6454SAndrew Thompson static uhci_td_t * 1657760bc48eSAndrew Thompson uhci_setup_standard_chain(struct usb_xfer *xfer) 165802ac6454SAndrew Thompson { 165902ac6454SAndrew Thompson struct uhci_std_temp temp; 166002ac6454SAndrew Thompson uhci_td_t *td; 166102ac6454SAndrew Thompson uint32_t x; 166202ac6454SAndrew Thompson 166302ac6454SAndrew Thompson DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", 1664ae60fdfbSAndrew Thompson xfer->address, UE_GET_ADDR(xfer->endpointno), 1665a593f6b8SAndrew Thompson xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); 166602ac6454SAndrew Thompson 166702ac6454SAndrew Thompson temp.average = xfer->max_frame_size; 166802ac6454SAndrew Thompson temp.max_frame_size = xfer->max_frame_size; 166902ac6454SAndrew Thompson 167002ac6454SAndrew Thompson /* toggle the DMA set we are using */ 167102ac6454SAndrew Thompson xfer->flags_int.curr_dma_set ^= 1; 167202ac6454SAndrew Thompson 167302ac6454SAndrew Thompson /* get next DMA set */ 167402ac6454SAndrew Thompson td = xfer->td_start[xfer->flags_int.curr_dma_set]; 167502ac6454SAndrew Thompson xfer->td_transfer_first = td; 167602ac6454SAndrew Thompson xfer->td_transfer_cache = td; 167702ac6454SAndrew Thompson 167802ac6454SAndrew Thompson temp.td = NULL; 167902ac6454SAndrew Thompson temp.td_next = td; 16800f7d4548SAndrew Thompson temp.last_frame = 0; 168102ac6454SAndrew Thompson temp.setup_alt_next = xfer->flags_int.short_frames_ok; 168202ac6454SAndrew Thompson 168302ac6454SAndrew Thompson uhci_mem_layout_init(&temp.ml, xfer); 168402ac6454SAndrew Thompson 168502ac6454SAndrew Thompson temp.td_status = 168602ac6454SAndrew Thompson htole32(UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(3) | 168702ac6454SAndrew Thompson UHCI_TD_ACTIVE)); 168802ac6454SAndrew Thompson 168902ac6454SAndrew Thompson if (xfer->xroot->udev->speed == USB_SPEED_LOW) { 169002ac6454SAndrew Thompson temp.td_status |= htole32(UHCI_TD_LS); 169102ac6454SAndrew Thompson } 169202ac6454SAndrew Thompson temp.td_token = 1693ae60fdfbSAndrew Thompson htole32(UHCI_TD_SET_ENDPT(xfer->endpointno) | 169402ac6454SAndrew Thompson UHCI_TD_SET_DEVADDR(xfer->address)); 169502ac6454SAndrew Thompson 1696ae60fdfbSAndrew Thompson if (xfer->endpoint->toggle_next) { 169702ac6454SAndrew Thompson /* DATA1 is next */ 169802ac6454SAndrew Thompson temp.td_token |= htole32(UHCI_TD_SET_DT(1)); 169902ac6454SAndrew Thompson } 170002ac6454SAndrew Thompson /* check if we should prepend a setup message */ 170102ac6454SAndrew Thompson 170202ac6454SAndrew Thompson if (xfer->flags_int.control_xfr) { 170302ac6454SAndrew Thompson 170402ac6454SAndrew Thompson if (xfer->flags_int.control_hdr) { 170502ac6454SAndrew Thompson 170602ac6454SAndrew Thompson temp.td_token &= htole32(UHCI_TD_SET_DEVADDR(0x7F) | 170702ac6454SAndrew Thompson UHCI_TD_SET_ENDPT(0xF)); 170802ac6454SAndrew Thompson temp.td_token |= htole32(UHCI_TD_PID_SETUP | 170902ac6454SAndrew Thompson UHCI_TD_SET_DT(0)); 171002ac6454SAndrew Thompson 171102ac6454SAndrew Thompson temp.len = xfer->frlengths[0]; 171202ac6454SAndrew Thompson temp.ml.buf_pc = xfer->frbuffers + 0; 171302ac6454SAndrew Thompson temp.shortpkt = temp.len ? 1 : 0; 17140f7d4548SAndrew Thompson /* check for last frame */ 17150f7d4548SAndrew Thompson if (xfer->nframes == 1) { 17160f7d4548SAndrew Thompson /* no STATUS stage yet, SETUP is last */ 17170f7d4548SAndrew Thompson if (xfer->flags_int.control_act) { 17180f7d4548SAndrew Thompson temp.last_frame = 1; 17190f7d4548SAndrew Thompson temp.setup_alt_next = 0; 17200f7d4548SAndrew Thompson } 17210f7d4548SAndrew Thompson } 172202ac6454SAndrew Thompson uhci_setup_standard_chain_sub(&temp); 172302ac6454SAndrew Thompson } 172402ac6454SAndrew Thompson x = 1; 172502ac6454SAndrew Thompson } else { 172602ac6454SAndrew Thompson x = 0; 172702ac6454SAndrew Thompson } 172802ac6454SAndrew Thompson 172902ac6454SAndrew Thompson while (x != xfer->nframes) { 173002ac6454SAndrew Thompson 173102ac6454SAndrew Thompson /* DATA0 / DATA1 message */ 173202ac6454SAndrew Thompson 173302ac6454SAndrew Thompson temp.len = xfer->frlengths[x]; 173402ac6454SAndrew Thompson temp.ml.buf_pc = xfer->frbuffers + x; 173502ac6454SAndrew Thompson 173602ac6454SAndrew Thompson x++; 173702ac6454SAndrew Thompson 173802ac6454SAndrew Thompson if (x == xfer->nframes) { 17390f7d4548SAndrew Thompson if (xfer->flags_int.control_xfr) { 17400f7d4548SAndrew Thompson /* no STATUS stage yet, DATA is last */ 17410f7d4548SAndrew Thompson if (xfer->flags_int.control_act) { 17420f7d4548SAndrew Thompson temp.last_frame = 1; 174302ac6454SAndrew Thompson temp.setup_alt_next = 0; 174402ac6454SAndrew Thompson } 17450f7d4548SAndrew Thompson } else { 17460f7d4548SAndrew Thompson temp.last_frame = 1; 17470f7d4548SAndrew Thompson temp.setup_alt_next = 0; 17480f7d4548SAndrew Thompson } 17490f7d4548SAndrew Thompson } 175002ac6454SAndrew Thompson /* 175102ac6454SAndrew Thompson * Keep previous data toggle, 175202ac6454SAndrew Thompson * device address and endpoint number: 175302ac6454SAndrew Thompson */ 175402ac6454SAndrew Thompson 175502ac6454SAndrew Thompson temp.td_token &= htole32(UHCI_TD_SET_DEVADDR(0x7F) | 175602ac6454SAndrew Thompson UHCI_TD_SET_ENDPT(0xF) | 175702ac6454SAndrew Thompson UHCI_TD_SET_DT(1)); 175802ac6454SAndrew Thompson 175902ac6454SAndrew Thompson if (temp.len == 0) { 176002ac6454SAndrew Thompson 176102ac6454SAndrew Thompson /* make sure that we send an USB packet */ 176202ac6454SAndrew Thompson 176302ac6454SAndrew Thompson temp.shortpkt = 0; 176402ac6454SAndrew Thompson 176502ac6454SAndrew Thompson } else { 176602ac6454SAndrew Thompson 176702ac6454SAndrew Thompson /* regular data transfer */ 176802ac6454SAndrew Thompson 176902ac6454SAndrew Thompson temp.shortpkt = (xfer->flags.force_short_xfer) ? 0 : 1; 177002ac6454SAndrew Thompson } 177102ac6454SAndrew Thompson 177202ac6454SAndrew Thompson /* set endpoint direction */ 177302ac6454SAndrew Thompson 177402ac6454SAndrew Thompson temp.td_token |= 1775ae60fdfbSAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_IN) ? 177602ac6454SAndrew Thompson htole32(UHCI_TD_PID_IN) : 177702ac6454SAndrew Thompson htole32(UHCI_TD_PID_OUT); 177802ac6454SAndrew Thompson 177902ac6454SAndrew Thompson uhci_setup_standard_chain_sub(&temp); 178002ac6454SAndrew Thompson } 178102ac6454SAndrew Thompson 178202ac6454SAndrew Thompson /* check if we should append a status stage */ 178302ac6454SAndrew Thompson 178402ac6454SAndrew Thompson if (xfer->flags_int.control_xfr && 178502ac6454SAndrew Thompson !xfer->flags_int.control_act) { 178602ac6454SAndrew Thompson 178702ac6454SAndrew Thompson /* 178802ac6454SAndrew Thompson * send a DATA1 message and reverse the current endpoint 178902ac6454SAndrew Thompson * direction 179002ac6454SAndrew Thompson */ 179102ac6454SAndrew Thompson 179202ac6454SAndrew Thompson temp.td_token &= htole32(UHCI_TD_SET_DEVADDR(0x7F) | 179302ac6454SAndrew Thompson UHCI_TD_SET_ENDPT(0xF) | 179402ac6454SAndrew Thompson UHCI_TD_SET_DT(1)); 179502ac6454SAndrew Thompson temp.td_token |= 1796ae60fdfbSAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_OUT) ? 179702ac6454SAndrew Thompson htole32(UHCI_TD_PID_IN | UHCI_TD_SET_DT(1)) : 179802ac6454SAndrew Thompson htole32(UHCI_TD_PID_OUT | UHCI_TD_SET_DT(1)); 179902ac6454SAndrew Thompson 180002ac6454SAndrew Thompson temp.len = 0; 180102ac6454SAndrew Thompson temp.ml.buf_pc = NULL; 180202ac6454SAndrew Thompson temp.shortpkt = 0; 18030f7d4548SAndrew Thompson temp.last_frame = 1; 18040f7d4548SAndrew Thompson temp.setup_alt_next = 0; 180502ac6454SAndrew Thompson 180602ac6454SAndrew Thompson uhci_setup_standard_chain_sub(&temp); 180702ac6454SAndrew Thompson } 180802ac6454SAndrew Thompson td = temp.td; 180902ac6454SAndrew Thompson 18100f7d4548SAndrew Thompson /* Ensure that last TD is terminating: */ 181102ac6454SAndrew Thompson td->td_next = htole32(UHCI_PTR_T); 181202ac6454SAndrew Thompson 181302ac6454SAndrew Thompson /* set interrupt bit */ 181402ac6454SAndrew Thompson 181502ac6454SAndrew Thompson td->td_status |= htole32(UHCI_TD_IOC); 181602ac6454SAndrew Thompson 1817a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 181802ac6454SAndrew Thompson 181902ac6454SAndrew Thompson /* must have at least one frame! */ 182002ac6454SAndrew Thompson 182102ac6454SAndrew Thompson xfer->td_transfer_last = td; 182202ac6454SAndrew Thompson 1823b850ecc1SAndrew Thompson #ifdef USB_DEBUG 182402ac6454SAndrew Thompson if (uhcidebug > 8) { 182502ac6454SAndrew Thompson DPRINTF("nexttog=%d; data before transfer:\n", 1826ae60fdfbSAndrew Thompson xfer->endpoint->toggle_next); 182702ac6454SAndrew Thompson uhci_dump_tds(xfer->td_transfer_first); 182802ac6454SAndrew Thompson } 182902ac6454SAndrew Thompson #endif 183002ac6454SAndrew Thompson return (xfer->td_transfer_first); 183102ac6454SAndrew Thompson } 183202ac6454SAndrew Thompson 183302ac6454SAndrew Thompson /* NOTE: "done" can be run two times in a row, 183402ac6454SAndrew Thompson * from close and from interrupt 183502ac6454SAndrew Thompson */ 183602ac6454SAndrew Thompson 183702ac6454SAndrew Thompson static void 1838e0a69b51SAndrew Thompson uhci_device_done(struct usb_xfer *xfer, usb_error_t error) 183902ac6454SAndrew Thompson { 1840ae60fdfbSAndrew Thompson struct usb_pipe_methods *methods = xfer->endpoint->methods; 184102ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 184202ac6454SAndrew Thompson uhci_qh_t *qh; 184302ac6454SAndrew Thompson 184402ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 184502ac6454SAndrew Thompson 1846ae60fdfbSAndrew Thompson DPRINTFN(2, "xfer=%p, endpoint=%p, error=%d\n", 1847ae60fdfbSAndrew Thompson xfer, xfer->endpoint, error); 184802ac6454SAndrew Thompson 184902ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 185002ac6454SAndrew Thompson if (qh) { 1851a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(qh->page_cache); 185202ac6454SAndrew Thompson } 185302ac6454SAndrew Thompson if (xfer->flags_int.bandwidth_reclaimed) { 185402ac6454SAndrew Thompson xfer->flags_int.bandwidth_reclaimed = 0; 185502ac6454SAndrew Thompson uhci_rem_loop(sc); 185602ac6454SAndrew Thompson } 185702ac6454SAndrew Thompson if (methods == &uhci_device_bulk_methods) { 185802ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_bulk_p_last); 185902ac6454SAndrew Thompson } 186002ac6454SAndrew Thompson if (methods == &uhci_device_ctrl_methods) { 186102ac6454SAndrew Thompson if (xfer->xroot->udev->speed == USB_SPEED_LOW) { 186202ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_ls_ctl_p_last); 186302ac6454SAndrew Thompson } else { 186402ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_fs_ctl_p_last); 186502ac6454SAndrew Thompson } 186602ac6454SAndrew Thompson } 186702ac6454SAndrew Thompson if (methods == &uhci_device_intr_methods) { 186802ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]); 186902ac6454SAndrew Thompson } 187002ac6454SAndrew Thompson /* 187102ac6454SAndrew Thompson * Only finish isochronous transfers once 187202ac6454SAndrew Thompson * which will update "xfer->frlengths". 187302ac6454SAndrew Thompson */ 187402ac6454SAndrew Thompson if (xfer->td_transfer_first && 187502ac6454SAndrew Thompson xfer->td_transfer_last) { 187602ac6454SAndrew Thompson if (methods == &uhci_device_isoc_methods) { 187702ac6454SAndrew Thompson uhci_isoc_done(sc, xfer); 187802ac6454SAndrew Thompson } 187902ac6454SAndrew Thompson xfer->td_transfer_first = NULL; 188002ac6454SAndrew Thompson xfer->td_transfer_last = NULL; 188102ac6454SAndrew Thompson } 188202ac6454SAndrew Thompson /* dequeue transfer and start next transfer */ 1883a593f6b8SAndrew Thompson usbd_transfer_done(xfer, error); 188402ac6454SAndrew Thompson } 188502ac6454SAndrew Thompson 188602ac6454SAndrew Thompson /*------------------------------------------------------------------------* 188702ac6454SAndrew Thompson * uhci bulk support 188802ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 188902ac6454SAndrew Thompson static void 1890760bc48eSAndrew Thompson uhci_device_bulk_open(struct usb_xfer *xfer) 189102ac6454SAndrew Thompson { 189202ac6454SAndrew Thompson return; 189302ac6454SAndrew Thompson } 189402ac6454SAndrew Thompson 189502ac6454SAndrew Thompson static void 1896760bc48eSAndrew Thompson uhci_device_bulk_close(struct usb_xfer *xfer) 189702ac6454SAndrew Thompson { 189802ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_CANCELLED); 189902ac6454SAndrew Thompson } 190002ac6454SAndrew Thompson 190102ac6454SAndrew Thompson static void 1902760bc48eSAndrew Thompson uhci_device_bulk_enter(struct usb_xfer *xfer) 190302ac6454SAndrew Thompson { 190402ac6454SAndrew Thompson return; 190502ac6454SAndrew Thompson } 190602ac6454SAndrew Thompson 190702ac6454SAndrew Thompson static void 1908760bc48eSAndrew Thompson uhci_device_bulk_start(struct usb_xfer *xfer) 190902ac6454SAndrew Thompson { 191002ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 191102ac6454SAndrew Thompson uhci_td_t *td; 191202ac6454SAndrew Thompson uhci_qh_t *qh; 191302ac6454SAndrew Thompson 191402ac6454SAndrew Thompson /* setup TD's */ 191502ac6454SAndrew Thompson td = uhci_setup_standard_chain(xfer); 191602ac6454SAndrew Thompson 191702ac6454SAndrew Thompson /* setup QH */ 191802ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 191902ac6454SAndrew Thompson 192002ac6454SAndrew Thompson qh->e_next = td; 192102ac6454SAndrew Thompson qh->qh_e_next = td->td_self; 192202ac6454SAndrew Thompson 1923ec8f3127SAndrew Thompson if (xfer->xroot->udev->flags.self_suspended == 0) { 192402ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_bulk_p_last); 192502ac6454SAndrew Thompson uhci_add_loop(sc); 192602ac6454SAndrew Thompson xfer->flags_int.bandwidth_reclaimed = 1; 192702ac6454SAndrew Thompson } else { 1928a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh->page_cache); 192902ac6454SAndrew Thompson } 193002ac6454SAndrew Thompson 193102ac6454SAndrew Thompson /* put transfer on interrupt queue */ 193202ac6454SAndrew Thompson uhci_transfer_intr_enqueue(xfer); 193302ac6454SAndrew Thompson } 193402ac6454SAndrew Thompson 1935760bc48eSAndrew Thompson struct usb_pipe_methods uhci_device_bulk_methods = 193602ac6454SAndrew Thompson { 193702ac6454SAndrew Thompson .open = uhci_device_bulk_open, 193802ac6454SAndrew Thompson .close = uhci_device_bulk_close, 193902ac6454SAndrew Thompson .enter = uhci_device_bulk_enter, 194002ac6454SAndrew Thompson .start = uhci_device_bulk_start, 194102ac6454SAndrew Thompson }; 194202ac6454SAndrew Thompson 194302ac6454SAndrew Thompson /*------------------------------------------------------------------------* 194402ac6454SAndrew Thompson * uhci control support 194502ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 194602ac6454SAndrew Thompson static void 1947760bc48eSAndrew Thompson uhci_device_ctrl_open(struct usb_xfer *xfer) 194802ac6454SAndrew Thompson { 194902ac6454SAndrew Thompson return; 195002ac6454SAndrew Thompson } 195102ac6454SAndrew Thompson 195202ac6454SAndrew Thompson static void 1953760bc48eSAndrew Thompson uhci_device_ctrl_close(struct usb_xfer *xfer) 195402ac6454SAndrew Thompson { 195502ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_CANCELLED); 195602ac6454SAndrew Thompson } 195702ac6454SAndrew Thompson 195802ac6454SAndrew Thompson static void 1959760bc48eSAndrew Thompson uhci_device_ctrl_enter(struct usb_xfer *xfer) 196002ac6454SAndrew Thompson { 196102ac6454SAndrew Thompson return; 196202ac6454SAndrew Thompson } 196302ac6454SAndrew Thompson 196402ac6454SAndrew Thompson static void 1965760bc48eSAndrew Thompson uhci_device_ctrl_start(struct usb_xfer *xfer) 196602ac6454SAndrew Thompson { 196702ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 196802ac6454SAndrew Thompson uhci_qh_t *qh; 196902ac6454SAndrew Thompson uhci_td_t *td; 197002ac6454SAndrew Thompson 197102ac6454SAndrew Thompson /* setup TD's */ 197202ac6454SAndrew Thompson td = uhci_setup_standard_chain(xfer); 197302ac6454SAndrew Thompson 197402ac6454SAndrew Thompson /* setup QH */ 197502ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 197602ac6454SAndrew Thompson 197702ac6454SAndrew Thompson qh->e_next = td; 197802ac6454SAndrew Thompson qh->qh_e_next = td->td_self; 197902ac6454SAndrew Thompson 198002ac6454SAndrew Thompson /* 198102ac6454SAndrew Thompson * NOTE: some devices choke on bandwidth- reclamation for control 198202ac6454SAndrew Thompson * transfers 198302ac6454SAndrew Thompson */ 1984ec8f3127SAndrew Thompson if (xfer->xroot->udev->flags.self_suspended == 0) { 198502ac6454SAndrew Thompson if (xfer->xroot->udev->speed == USB_SPEED_LOW) { 198602ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_ls_ctl_p_last); 198702ac6454SAndrew Thompson } else { 198802ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last); 198902ac6454SAndrew Thompson } 199002ac6454SAndrew Thompson } else { 1991a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh->page_cache); 199202ac6454SAndrew Thompson } 199302ac6454SAndrew Thompson /* put transfer on interrupt queue */ 199402ac6454SAndrew Thompson uhci_transfer_intr_enqueue(xfer); 199502ac6454SAndrew Thompson } 199602ac6454SAndrew Thompson 1997760bc48eSAndrew Thompson struct usb_pipe_methods uhci_device_ctrl_methods = 199802ac6454SAndrew Thompson { 199902ac6454SAndrew Thompson .open = uhci_device_ctrl_open, 200002ac6454SAndrew Thompson .close = uhci_device_ctrl_close, 200102ac6454SAndrew Thompson .enter = uhci_device_ctrl_enter, 200202ac6454SAndrew Thompson .start = uhci_device_ctrl_start, 200302ac6454SAndrew Thompson }; 200402ac6454SAndrew Thompson 200502ac6454SAndrew Thompson /*------------------------------------------------------------------------* 200602ac6454SAndrew Thompson * uhci interrupt support 200702ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 200802ac6454SAndrew Thompson static void 2009760bc48eSAndrew Thompson uhci_device_intr_open(struct usb_xfer *xfer) 201002ac6454SAndrew Thompson { 201102ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 201202ac6454SAndrew Thompson uint16_t best; 201302ac6454SAndrew Thompson uint16_t bit; 201402ac6454SAndrew Thompson uint16_t x; 201502ac6454SAndrew Thompson 201602ac6454SAndrew Thompson best = 0; 201702ac6454SAndrew Thompson bit = UHCI_IFRAMELIST_COUNT / 2; 201802ac6454SAndrew Thompson while (bit) { 201902ac6454SAndrew Thompson if (xfer->interval >= bit) { 202002ac6454SAndrew Thompson x = bit; 202102ac6454SAndrew Thompson best = bit; 202202ac6454SAndrew Thompson while (x & bit) { 202302ac6454SAndrew Thompson if (sc->sc_intr_stat[x] < 202402ac6454SAndrew Thompson sc->sc_intr_stat[best]) { 202502ac6454SAndrew Thompson best = x; 202602ac6454SAndrew Thompson } 202702ac6454SAndrew Thompson x++; 202802ac6454SAndrew Thompson } 202902ac6454SAndrew Thompson break; 203002ac6454SAndrew Thompson } 203102ac6454SAndrew Thompson bit >>= 1; 203202ac6454SAndrew Thompson } 203302ac6454SAndrew Thompson 203402ac6454SAndrew Thompson sc->sc_intr_stat[best]++; 203502ac6454SAndrew Thompson xfer->qh_pos = best; 203602ac6454SAndrew Thompson 203702ac6454SAndrew Thompson DPRINTFN(3, "best=%d interval=%d\n", 203802ac6454SAndrew Thompson best, xfer->interval); 203902ac6454SAndrew Thompson } 204002ac6454SAndrew Thompson 204102ac6454SAndrew Thompson static void 2042760bc48eSAndrew Thompson uhci_device_intr_close(struct usb_xfer *xfer) 204302ac6454SAndrew Thompson { 204402ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 204502ac6454SAndrew Thompson 204602ac6454SAndrew Thompson sc->sc_intr_stat[xfer->qh_pos]--; 204702ac6454SAndrew Thompson 204802ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_CANCELLED); 204902ac6454SAndrew Thompson } 205002ac6454SAndrew Thompson 205102ac6454SAndrew Thompson static void 2052760bc48eSAndrew Thompson uhci_device_intr_enter(struct usb_xfer *xfer) 205302ac6454SAndrew Thompson { 205402ac6454SAndrew Thompson return; 205502ac6454SAndrew Thompson } 205602ac6454SAndrew Thompson 205702ac6454SAndrew Thompson static void 2058760bc48eSAndrew Thompson uhci_device_intr_start(struct usb_xfer *xfer) 205902ac6454SAndrew Thompson { 206002ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 206102ac6454SAndrew Thompson uhci_qh_t *qh; 206202ac6454SAndrew Thompson uhci_td_t *td; 206302ac6454SAndrew Thompson 206402ac6454SAndrew Thompson /* setup TD's */ 206502ac6454SAndrew Thompson td = uhci_setup_standard_chain(xfer); 206602ac6454SAndrew Thompson 206702ac6454SAndrew Thompson /* setup QH */ 206802ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 206902ac6454SAndrew Thompson 207002ac6454SAndrew Thompson qh->e_next = td; 207102ac6454SAndrew Thompson qh->qh_e_next = td->td_self; 207202ac6454SAndrew Thompson 2073ec8f3127SAndrew Thompson if (xfer->xroot->udev->flags.self_suspended == 0) { 207402ac6454SAndrew Thompson /* enter QHs into the controller data structures */ 207502ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]); 207602ac6454SAndrew Thompson } else { 2077a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh->page_cache); 207802ac6454SAndrew Thompson } 207902ac6454SAndrew Thompson 208002ac6454SAndrew Thompson /* put transfer on interrupt queue */ 208102ac6454SAndrew Thompson uhci_transfer_intr_enqueue(xfer); 208202ac6454SAndrew Thompson } 208302ac6454SAndrew Thompson 2084760bc48eSAndrew Thompson struct usb_pipe_methods uhci_device_intr_methods = 208502ac6454SAndrew Thompson { 208602ac6454SAndrew Thompson .open = uhci_device_intr_open, 208702ac6454SAndrew Thompson .close = uhci_device_intr_close, 208802ac6454SAndrew Thompson .enter = uhci_device_intr_enter, 208902ac6454SAndrew Thompson .start = uhci_device_intr_start, 209002ac6454SAndrew Thompson }; 209102ac6454SAndrew Thompson 209202ac6454SAndrew Thompson /*------------------------------------------------------------------------* 209302ac6454SAndrew Thompson * uhci isochronous support 209402ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 209502ac6454SAndrew Thompson static void 2096760bc48eSAndrew Thompson uhci_device_isoc_open(struct usb_xfer *xfer) 209702ac6454SAndrew Thompson { 209802ac6454SAndrew Thompson uhci_td_t *td; 209902ac6454SAndrew Thompson uint32_t td_token; 210002ac6454SAndrew Thompson uint8_t ds; 210102ac6454SAndrew Thompson 210202ac6454SAndrew Thompson td_token = 2103ae60fdfbSAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_IN) ? 2104ae60fdfbSAndrew Thompson UHCI_TD_IN(0, xfer->endpointno, xfer->address, 0) : 2105ae60fdfbSAndrew Thompson UHCI_TD_OUT(0, xfer->endpointno, xfer->address, 0); 210602ac6454SAndrew Thompson 210702ac6454SAndrew Thompson td_token = htole32(td_token); 210802ac6454SAndrew Thompson 210902ac6454SAndrew Thompson /* initialize all TD's */ 211002ac6454SAndrew Thompson 211102ac6454SAndrew Thompson for (ds = 0; ds != 2; ds++) { 211202ac6454SAndrew Thompson 211302ac6454SAndrew Thompson for (td = xfer->td_start[ds]; td; td = td->obj_next) { 211402ac6454SAndrew Thompson 211502ac6454SAndrew Thompson /* mark TD as inactive */ 211602ac6454SAndrew Thompson td->td_status = htole32(UHCI_TD_IOS); 211702ac6454SAndrew Thompson td->td_token = td_token; 211802ac6454SAndrew Thompson 2119a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 212002ac6454SAndrew Thompson } 212102ac6454SAndrew Thompson } 212202ac6454SAndrew Thompson } 212302ac6454SAndrew Thompson 212402ac6454SAndrew Thompson static void 2125760bc48eSAndrew Thompson uhci_device_isoc_close(struct usb_xfer *xfer) 212602ac6454SAndrew Thompson { 212702ac6454SAndrew Thompson uhci_device_done(xfer, USB_ERR_CANCELLED); 212802ac6454SAndrew Thompson } 212902ac6454SAndrew Thompson 213002ac6454SAndrew Thompson static void 2131760bc48eSAndrew Thompson uhci_device_isoc_enter(struct usb_xfer *xfer) 213202ac6454SAndrew Thompson { 213302ac6454SAndrew Thompson struct uhci_mem_layout ml; 213402ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(xfer->xroot->bus); 213502ac6454SAndrew Thompson uint32_t nframes; 213602ac6454SAndrew Thompson uint32_t temp; 213702ac6454SAndrew Thompson uint32_t *plen; 213802ac6454SAndrew Thompson 2139b850ecc1SAndrew Thompson #ifdef USB_DEBUG 214002ac6454SAndrew Thompson uint8_t once = 1; 214102ac6454SAndrew Thompson 214202ac6454SAndrew Thompson #endif 214302ac6454SAndrew Thompson uhci_td_t *td; 214402ac6454SAndrew Thompson uhci_td_t *td_last = NULL; 214502ac6454SAndrew Thompson uhci_td_t **pp_last; 214602ac6454SAndrew Thompson 214702ac6454SAndrew Thompson DPRINTFN(6, "xfer=%p next=%d nframes=%d\n", 2148ae60fdfbSAndrew Thompson xfer, xfer->endpoint->isoc_next, xfer->nframes); 214902ac6454SAndrew Thompson 215002ac6454SAndrew Thompson nframes = UREAD2(sc, UHCI_FRNUM); 215102ac6454SAndrew Thompson 2152ae60fdfbSAndrew Thompson temp = (nframes - xfer->endpoint->isoc_next) & 215302ac6454SAndrew Thompson (UHCI_VFRAMELIST_COUNT - 1); 215402ac6454SAndrew Thompson 2155ae60fdfbSAndrew Thompson if ((xfer->endpoint->is_synced == 0) || 215602ac6454SAndrew Thompson (temp < xfer->nframes)) { 215702ac6454SAndrew Thompson /* 215802ac6454SAndrew Thompson * If there is data underflow or the pipe queue is empty we 215902ac6454SAndrew Thompson * schedule the transfer a few frames ahead of the current 216002ac6454SAndrew Thompson * frame position. Else two isochronous transfers might 216102ac6454SAndrew Thompson * overlap. 216202ac6454SAndrew Thompson */ 2163ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (nframes + 3) & (UHCI_VFRAMELIST_COUNT - 1); 2164ae60fdfbSAndrew Thompson xfer->endpoint->is_synced = 1; 2165ae60fdfbSAndrew Thompson DPRINTFN(3, "start next=%d\n", xfer->endpoint->isoc_next); 216602ac6454SAndrew Thompson } 216702ac6454SAndrew Thompson /* 216802ac6454SAndrew Thompson * compute how many milliseconds the insertion is ahead of the 216902ac6454SAndrew Thompson * current frame position: 217002ac6454SAndrew Thompson */ 2171ae60fdfbSAndrew Thompson temp = (xfer->endpoint->isoc_next - nframes) & 217202ac6454SAndrew Thompson (UHCI_VFRAMELIST_COUNT - 1); 217302ac6454SAndrew Thompson 217402ac6454SAndrew Thompson /* 217502ac6454SAndrew Thompson * pre-compute when the isochronous transfer will be finished: 217602ac6454SAndrew Thompson */ 217702ac6454SAndrew Thompson xfer->isoc_time_complete = 2178a593f6b8SAndrew Thompson usb_isoc_time_expand(&sc->sc_bus, nframes) + temp + 217902ac6454SAndrew Thompson xfer->nframes; 218002ac6454SAndrew Thompson 218102ac6454SAndrew Thompson /* get the real number of frames */ 218202ac6454SAndrew Thompson 218302ac6454SAndrew Thompson nframes = xfer->nframes; 218402ac6454SAndrew Thompson 218502ac6454SAndrew Thompson uhci_mem_layout_init(&ml, xfer); 218602ac6454SAndrew Thompson 218702ac6454SAndrew Thompson plen = xfer->frlengths; 218802ac6454SAndrew Thompson 218902ac6454SAndrew Thompson /* toggle the DMA set we are using */ 219002ac6454SAndrew Thompson xfer->flags_int.curr_dma_set ^= 1; 219102ac6454SAndrew Thompson 219202ac6454SAndrew Thompson /* get next DMA set */ 219302ac6454SAndrew Thompson td = xfer->td_start[xfer->flags_int.curr_dma_set]; 219402ac6454SAndrew Thompson xfer->td_transfer_first = td; 219502ac6454SAndrew Thompson 2196ae60fdfbSAndrew Thompson pp_last = &sc->sc_isoc_p_last[xfer->endpoint->isoc_next]; 219702ac6454SAndrew Thompson 219802ac6454SAndrew Thompson /* store starting position */ 219902ac6454SAndrew Thompson 2200ae60fdfbSAndrew Thompson xfer->qh_pos = xfer->endpoint->isoc_next; 220102ac6454SAndrew Thompson 220202ac6454SAndrew Thompson while (nframes--) { 220302ac6454SAndrew Thompson if (td == NULL) { 220402ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 220502ac6454SAndrew Thompson __FUNCTION__, __LINE__); 220602ac6454SAndrew Thompson } 220702ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_p_last[UHCI_VFRAMELIST_COUNT]) { 220802ac6454SAndrew Thompson pp_last = &sc->sc_isoc_p_last[0]; 220902ac6454SAndrew Thompson } 221002ac6454SAndrew Thompson if (*plen > xfer->max_frame_size) { 2211b850ecc1SAndrew Thompson #ifdef USB_DEBUG 221202ac6454SAndrew Thompson if (once) { 221302ac6454SAndrew Thompson once = 0; 221402ac6454SAndrew Thompson printf("%s: frame length(%d) exceeds %d " 221502ac6454SAndrew Thompson "bytes (frame truncated)\n", 221602ac6454SAndrew Thompson __FUNCTION__, *plen, 221702ac6454SAndrew Thompson xfer->max_frame_size); 221802ac6454SAndrew Thompson } 221902ac6454SAndrew Thompson #endif 222002ac6454SAndrew Thompson *plen = xfer->max_frame_size; 222102ac6454SAndrew Thompson } 222202ac6454SAndrew Thompson /* reuse td_token from last transfer */ 222302ac6454SAndrew Thompson 222402ac6454SAndrew Thompson td->td_token &= htole32(~UHCI_TD_MAXLEN_MASK); 222502ac6454SAndrew Thompson td->td_token |= htole32(UHCI_TD_SET_MAXLEN(*plen)); 222602ac6454SAndrew Thompson 222702ac6454SAndrew Thompson td->len = *plen; 222802ac6454SAndrew Thompson 222902ac6454SAndrew Thompson if (td->len == 0) { 223002ac6454SAndrew Thompson /* 223102ac6454SAndrew Thompson * Do not call "uhci_mem_layout_fixup()" when the 223202ac6454SAndrew Thompson * length is zero! 223302ac6454SAndrew Thompson */ 223402ac6454SAndrew Thompson td->td_buffer = 0; 223502ac6454SAndrew Thompson td->fix_pc = NULL; 223602ac6454SAndrew Thompson 223702ac6454SAndrew Thompson } else { 223802ac6454SAndrew Thompson 223902ac6454SAndrew Thompson /* fill out buffer pointer and do fixup, if any */ 224002ac6454SAndrew Thompson 224102ac6454SAndrew Thompson uhci_mem_layout_fixup(&ml, td); 224202ac6454SAndrew Thompson 224302ac6454SAndrew Thompson } 224402ac6454SAndrew Thompson 224502ac6454SAndrew Thompson /* update status */ 224602ac6454SAndrew Thompson if (nframes == 0) { 224702ac6454SAndrew Thompson td->td_status = htole32 224802ac6454SAndrew Thompson (UHCI_TD_ZERO_ACTLEN 224902ac6454SAndrew Thompson (UHCI_TD_SET_ERRCNT(0) | 225002ac6454SAndrew Thompson UHCI_TD_ACTIVE | 225102ac6454SAndrew Thompson UHCI_TD_IOS | 225202ac6454SAndrew Thompson UHCI_TD_IOC)); 225302ac6454SAndrew Thompson } else { 225402ac6454SAndrew Thompson td->td_status = htole32 225502ac6454SAndrew Thompson (UHCI_TD_ZERO_ACTLEN 225602ac6454SAndrew Thompson (UHCI_TD_SET_ERRCNT(0) | 225702ac6454SAndrew Thompson UHCI_TD_ACTIVE | 225802ac6454SAndrew Thompson UHCI_TD_IOS)); 225902ac6454SAndrew Thompson } 226002ac6454SAndrew Thompson 2261a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 226202ac6454SAndrew Thompson 2263b850ecc1SAndrew Thompson #ifdef USB_DEBUG 226402ac6454SAndrew Thompson if (uhcidebug > 5) { 226502ac6454SAndrew Thompson DPRINTF("TD %d\n", nframes); 226602ac6454SAndrew Thompson uhci_dump_td(td); 226702ac6454SAndrew Thompson } 226802ac6454SAndrew Thompson #endif 226902ac6454SAndrew Thompson /* insert TD into schedule */ 227002ac6454SAndrew Thompson UHCI_APPEND_TD(td, *pp_last); 227102ac6454SAndrew Thompson pp_last++; 227202ac6454SAndrew Thompson 227302ac6454SAndrew Thompson plen++; 227402ac6454SAndrew Thompson td_last = td; 227502ac6454SAndrew Thompson td = td->obj_next; 227602ac6454SAndrew Thompson } 227702ac6454SAndrew Thompson 227802ac6454SAndrew Thompson xfer->td_transfer_last = td_last; 227902ac6454SAndrew Thompson 228002ac6454SAndrew Thompson /* update isoc_next */ 2281ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (pp_last - &sc->sc_isoc_p_last[0]) & 228202ac6454SAndrew Thompson (UHCI_VFRAMELIST_COUNT - 1); 228302ac6454SAndrew Thompson } 228402ac6454SAndrew Thompson 228502ac6454SAndrew Thompson static void 2286760bc48eSAndrew Thompson uhci_device_isoc_start(struct usb_xfer *xfer) 228702ac6454SAndrew Thompson { 228802ac6454SAndrew Thompson /* put transfer on interrupt queue */ 228902ac6454SAndrew Thompson uhci_transfer_intr_enqueue(xfer); 229002ac6454SAndrew Thompson } 229102ac6454SAndrew Thompson 2292760bc48eSAndrew Thompson struct usb_pipe_methods uhci_device_isoc_methods = 229302ac6454SAndrew Thompson { 229402ac6454SAndrew Thompson .open = uhci_device_isoc_open, 229502ac6454SAndrew Thompson .close = uhci_device_isoc_close, 229602ac6454SAndrew Thompson .enter = uhci_device_isoc_enter, 229702ac6454SAndrew Thompson .start = uhci_device_isoc_start, 229802ac6454SAndrew Thompson }; 229902ac6454SAndrew Thompson 230002ac6454SAndrew Thompson /*------------------------------------------------------------------------* 230102ac6454SAndrew Thompson * uhci root control support 230202ac6454SAndrew Thompson *------------------------------------------------------------------------* 230339307315SAndrew Thompson * Simulate a hardware hub by handling all the necessary requests. 230402ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 230502ac6454SAndrew Thompson 230602ac6454SAndrew Thompson static const 2307760bc48eSAndrew Thompson struct usb_device_descriptor uhci_devd = 230802ac6454SAndrew Thompson { 2309760bc48eSAndrew Thompson sizeof(struct usb_device_descriptor), 231002ac6454SAndrew Thompson UDESC_DEVICE, /* type */ 231102ac6454SAndrew Thompson {0x00, 0x01}, /* USB version */ 231202ac6454SAndrew Thompson UDCLASS_HUB, /* class */ 231302ac6454SAndrew Thompson UDSUBCLASS_HUB, /* subclass */ 231402ac6454SAndrew Thompson UDPROTO_FSHUB, /* protocol */ 231502ac6454SAndrew Thompson 64, /* max packet */ 231602ac6454SAndrew Thompson {0}, {0}, {0x00, 0x01}, /* device id */ 231702ac6454SAndrew Thompson 1, 2, 0, /* string indicies */ 231802ac6454SAndrew Thompson 1 /* # of configurations */ 231902ac6454SAndrew Thompson }; 232002ac6454SAndrew Thompson 232102ac6454SAndrew Thompson static const struct uhci_config_desc uhci_confd = { 232202ac6454SAndrew Thompson .confd = { 2323760bc48eSAndrew Thompson .bLength = sizeof(struct usb_config_descriptor), 232402ac6454SAndrew Thompson .bDescriptorType = UDESC_CONFIG, 232502ac6454SAndrew Thompson .wTotalLength[0] = sizeof(uhci_confd), 232602ac6454SAndrew Thompson .bNumInterface = 1, 232702ac6454SAndrew Thompson .bConfigurationValue = 1, 232802ac6454SAndrew Thompson .iConfiguration = 0, 232902ac6454SAndrew Thompson .bmAttributes = UC_SELF_POWERED, 233002ac6454SAndrew Thompson .bMaxPower = 0 /* max power */ 233102ac6454SAndrew Thompson }, 233202ac6454SAndrew Thompson .ifcd = { 2333760bc48eSAndrew Thompson .bLength = sizeof(struct usb_interface_descriptor), 233402ac6454SAndrew Thompson .bDescriptorType = UDESC_INTERFACE, 233502ac6454SAndrew Thompson .bNumEndpoints = 1, 233602ac6454SAndrew Thompson .bInterfaceClass = UICLASS_HUB, 233702ac6454SAndrew Thompson .bInterfaceSubClass = UISUBCLASS_HUB, 233802ac6454SAndrew Thompson .bInterfaceProtocol = UIPROTO_FSHUB, 233902ac6454SAndrew Thompson }, 234002ac6454SAndrew Thompson .endpd = { 2341760bc48eSAndrew Thompson .bLength = sizeof(struct usb_endpoint_descriptor), 234202ac6454SAndrew Thompson .bDescriptorType = UDESC_ENDPOINT, 234302ac6454SAndrew Thompson .bEndpointAddress = UE_DIR_IN | UHCI_INTR_ENDPT, 234402ac6454SAndrew Thompson .bmAttributes = UE_INTERRUPT, 234502ac6454SAndrew Thompson .wMaxPacketSize[0] = 8, /* max packet (63 ports) */ 234602ac6454SAndrew Thompson .bInterval = 255, 234702ac6454SAndrew Thompson }, 234802ac6454SAndrew Thompson }; 234902ac6454SAndrew Thompson 235002ac6454SAndrew Thompson static const 2351760bc48eSAndrew Thompson struct usb_hub_descriptor_min uhci_hubd_piix = 235202ac6454SAndrew Thompson { 23536d917491SHans Petter Selasky .bDescLength = sizeof(uhci_hubd_piix), 23546d917491SHans Petter Selasky .bDescriptorType = UDESC_HUB, 23556d917491SHans Petter Selasky .bNbrPorts = 2, 23566d917491SHans Petter Selasky .wHubCharacteristics = {UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL, 0}, 23576d917491SHans Petter Selasky .bPwrOn2PwrGood = 50, 235802ac6454SAndrew Thompson }; 235902ac6454SAndrew Thompson 236002ac6454SAndrew Thompson /* 236102ac6454SAndrew Thompson * The USB hub protocol requires that SET_FEATURE(PORT_RESET) also 236202ac6454SAndrew Thompson * enables the port, and also states that SET_FEATURE(PORT_ENABLE) 236302ac6454SAndrew Thompson * should not be used by the USB subsystem. As we cannot issue a 236402ac6454SAndrew Thompson * SET_FEATURE(PORT_ENABLE) externally, we must ensure that the port 236502ac6454SAndrew Thompson * will be enabled as part of the reset. 236602ac6454SAndrew Thompson * 236702ac6454SAndrew Thompson * On the VT83C572, the port cannot be successfully enabled until the 236802ac6454SAndrew Thompson * outstanding "port enable change" and "connection status change" 236902ac6454SAndrew Thompson * events have been reset. 237002ac6454SAndrew Thompson */ 2371e0a69b51SAndrew Thompson static usb_error_t 23724a35cda7SAndrew Thompson uhci_portreset(uhci_softc_t *sc, uint16_t index) 237302ac6454SAndrew Thompson { 237402ac6454SAndrew Thompson uint16_t port; 237502ac6454SAndrew Thompson uint16_t x; 237602ac6454SAndrew Thompson uint8_t lim; 237702ac6454SAndrew Thompson 237802ac6454SAndrew Thompson if (index == 1) 237902ac6454SAndrew Thompson port = UHCI_PORTSC1; 238002ac6454SAndrew Thompson else if (index == 2) 238102ac6454SAndrew Thompson port = UHCI_PORTSC2; 238202ac6454SAndrew Thompson else 238302ac6454SAndrew Thompson return (USB_ERR_IOERROR); 238402ac6454SAndrew Thompson 238502ac6454SAndrew Thompson /* 238602ac6454SAndrew Thompson * Before we do anything, turn on SOF messages on the USB 238702ac6454SAndrew Thompson * BUS. Some USB devices do not cope without them! 238802ac6454SAndrew Thompson */ 2389b9c81a5dSAndrew Thompson uhci_restart(sc); 239002ac6454SAndrew Thompson 239102ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 239202ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_PR); 239302ac6454SAndrew Thompson 2394a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 239537506412SHans Petter Selasky USB_MS_TO_TICKS(usb_port_root_reset_delay)); 239602ac6454SAndrew Thompson 239702ac6454SAndrew Thompson DPRINTFN(4, "uhci port %d reset, status0 = 0x%04x\n", 239802ac6454SAndrew Thompson index, UREAD2(sc, port)); 239902ac6454SAndrew Thompson 240002ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 240102ac6454SAndrew Thompson UWRITE2(sc, port, x & ~UHCI_PORTSC_PR); 240202ac6454SAndrew Thompson 240302ac6454SAndrew Thompson 240402ac6454SAndrew Thompson mtx_unlock(&sc->sc_bus.bus_mtx); 240502ac6454SAndrew Thompson 240602ac6454SAndrew Thompson /* 240702ac6454SAndrew Thompson * This delay needs to be exactly 100us, else some USB devices 240802ac6454SAndrew Thompson * fail to attach! 240902ac6454SAndrew Thompson */ 241002ac6454SAndrew Thompson DELAY(100); 241102ac6454SAndrew Thompson 241202ac6454SAndrew Thompson mtx_lock(&sc->sc_bus.bus_mtx); 241302ac6454SAndrew Thompson 241402ac6454SAndrew Thompson DPRINTFN(4, "uhci port %d reset, status1 = 0x%04x\n", 241502ac6454SAndrew Thompson index, UREAD2(sc, port)); 241602ac6454SAndrew Thompson 241702ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 241802ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_PE); 241902ac6454SAndrew Thompson 242002ac6454SAndrew Thompson for (lim = 0; lim < 12; lim++) { 242102ac6454SAndrew Thompson 2422a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 242337506412SHans Petter Selasky USB_MS_TO_TICKS(usb_port_reset_delay)); 242402ac6454SAndrew Thompson 242502ac6454SAndrew Thompson x = UREAD2(sc, port); 242602ac6454SAndrew Thompson 242702ac6454SAndrew Thompson DPRINTFN(4, "uhci port %d iteration %u, status = 0x%04x\n", 242802ac6454SAndrew Thompson index, lim, x); 242902ac6454SAndrew Thompson 243002ac6454SAndrew Thompson if (!(x & UHCI_PORTSC_CCS)) { 243102ac6454SAndrew Thompson /* 243202ac6454SAndrew Thompson * No device is connected (or was disconnected 243302ac6454SAndrew Thompson * during reset). Consider the port reset. 243402ac6454SAndrew Thompson * The delay must be long enough to ensure on 243502ac6454SAndrew Thompson * the initial iteration that the device 243602ac6454SAndrew Thompson * connection will have been registered. 50ms 243702ac6454SAndrew Thompson * appears to be sufficient, but 20ms is not. 243802ac6454SAndrew Thompson */ 243902ac6454SAndrew Thompson DPRINTFN(4, "uhci port %d loop %u, device detached\n", 244002ac6454SAndrew Thompson index, lim); 244102ac6454SAndrew Thompson goto done; 244202ac6454SAndrew Thompson } 244302ac6454SAndrew Thompson if (x & (UHCI_PORTSC_POEDC | UHCI_PORTSC_CSC)) { 244402ac6454SAndrew Thompson /* 244502ac6454SAndrew Thompson * Port enabled changed and/or connection 244602ac6454SAndrew Thompson * status changed were set. Reset either or 244702ac6454SAndrew Thompson * both raised flags (by writing a 1 to that 244802ac6454SAndrew Thompson * bit), and wait again for state to settle. 244902ac6454SAndrew Thompson */ 245002ac6454SAndrew Thompson UWRITE2(sc, port, URWMASK(x) | 245102ac6454SAndrew Thompson (x & (UHCI_PORTSC_POEDC | UHCI_PORTSC_CSC))); 245202ac6454SAndrew Thompson continue; 245302ac6454SAndrew Thompson } 245402ac6454SAndrew Thompson if (x & UHCI_PORTSC_PE) { 245502ac6454SAndrew Thompson /* port is enabled */ 245602ac6454SAndrew Thompson goto done; 245702ac6454SAndrew Thompson } 245802ac6454SAndrew Thompson UWRITE2(sc, port, URWMASK(x) | UHCI_PORTSC_PE); 245902ac6454SAndrew Thompson } 246002ac6454SAndrew Thompson 246102ac6454SAndrew Thompson DPRINTFN(2, "uhci port %d reset timed out\n", index); 246202ac6454SAndrew Thompson return (USB_ERR_TIMEOUT); 246302ac6454SAndrew Thompson 246402ac6454SAndrew Thompson done: 246502ac6454SAndrew Thompson DPRINTFN(4, "uhci port %d reset, status2 = 0x%04x\n", 246602ac6454SAndrew Thompson index, UREAD2(sc, port)); 246702ac6454SAndrew Thompson 246802ac6454SAndrew Thompson sc->sc_isreset = 1; 246902ac6454SAndrew Thompson return (USB_ERR_NORMAL_COMPLETION); 247002ac6454SAndrew Thompson } 247102ac6454SAndrew Thompson 2472e0a69b51SAndrew Thompson static usb_error_t 2473760bc48eSAndrew Thompson uhci_roothub_exec(struct usb_device *udev, 2474760bc48eSAndrew Thompson struct usb_device_request *req, const void **pptr, uint16_t *plength) 247502ac6454SAndrew Thompson { 2476459d369eSAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(udev->bus); 2477459d369eSAndrew Thompson const void *ptr; 2478459d369eSAndrew Thompson const char *str_ptr; 247902ac6454SAndrew Thompson uint16_t x; 248002ac6454SAndrew Thompson uint16_t port; 248102ac6454SAndrew Thompson uint16_t value; 248202ac6454SAndrew Thompson uint16_t index; 248302ac6454SAndrew Thompson uint16_t status; 248402ac6454SAndrew Thompson uint16_t change; 2485459d369eSAndrew Thompson uint16_t len; 2486e0a69b51SAndrew Thompson usb_error_t err; 248702ac6454SAndrew Thompson 248802ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 248902ac6454SAndrew Thompson 249002ac6454SAndrew Thompson /* buffer reset */ 2491459d369eSAndrew Thompson ptr = (const void *)&sc->sc_hub_desc.temp; 2492459d369eSAndrew Thompson len = 0; 2493459d369eSAndrew Thompson err = 0; 249402ac6454SAndrew Thompson 2495459d369eSAndrew Thompson value = UGETW(req->wValue); 2496459d369eSAndrew Thompson index = UGETW(req->wIndex); 249702ac6454SAndrew Thompson 249802ac6454SAndrew Thompson DPRINTFN(3, "type=0x%02x request=0x%02x wLen=0x%04x " 249902ac6454SAndrew Thompson "wValue=0x%04x wIndex=0x%04x\n", 2500459d369eSAndrew Thompson req->bmRequestType, req->bRequest, 2501459d369eSAndrew Thompson UGETW(req->wLength), value, index); 250202ac6454SAndrew Thompson 250302ac6454SAndrew Thompson #define C(x,y) ((x) | ((y) << 8)) 2504459d369eSAndrew Thompson switch (C(req->bRequest, req->bmRequestType)) { 250502ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): 250602ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): 250702ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): 250802ac6454SAndrew Thompson /* 250902ac6454SAndrew Thompson * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops 251002ac6454SAndrew Thompson * for the integrated root hub. 251102ac6454SAndrew Thompson */ 251202ac6454SAndrew Thompson break; 251302ac6454SAndrew Thompson case C(UR_GET_CONFIG, UT_READ_DEVICE): 2514459d369eSAndrew Thompson len = 1; 251502ac6454SAndrew Thompson sc->sc_hub_desc.temp[0] = sc->sc_conf; 251602ac6454SAndrew Thompson break; 251702ac6454SAndrew Thompson case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): 251802ac6454SAndrew Thompson switch (value >> 8) { 251902ac6454SAndrew Thompson case UDESC_DEVICE: 252002ac6454SAndrew Thompson if ((value & 0xff) != 0) { 2521459d369eSAndrew Thompson err = USB_ERR_IOERROR; 252202ac6454SAndrew Thompson goto done; 252302ac6454SAndrew Thompson } 2524459d369eSAndrew Thompson len = sizeof(uhci_devd); 2525459d369eSAndrew Thompson ptr = (const void *)&uhci_devd; 252602ac6454SAndrew Thompson break; 252702ac6454SAndrew Thompson 252802ac6454SAndrew Thompson case UDESC_CONFIG: 252902ac6454SAndrew Thompson if ((value & 0xff) != 0) { 2530459d369eSAndrew Thompson err = USB_ERR_IOERROR; 253102ac6454SAndrew Thompson goto done; 253202ac6454SAndrew Thompson } 2533459d369eSAndrew Thompson len = sizeof(uhci_confd); 2534459d369eSAndrew Thompson ptr = (const void *)&uhci_confd; 253502ac6454SAndrew Thompson break; 253602ac6454SAndrew Thompson 253702ac6454SAndrew Thompson case UDESC_STRING: 253802ac6454SAndrew Thompson switch (value & 0xff) { 253902ac6454SAndrew Thompson case 0: /* Language table */ 2540459d369eSAndrew Thompson str_ptr = "\001"; 254102ac6454SAndrew Thompson break; 254202ac6454SAndrew Thompson 254302ac6454SAndrew Thompson case 1: /* Vendor */ 2544459d369eSAndrew Thompson str_ptr = sc->sc_vendor; 254502ac6454SAndrew Thompson break; 254602ac6454SAndrew Thompson 254702ac6454SAndrew Thompson case 2: /* Product */ 2548459d369eSAndrew Thompson str_ptr = "UHCI root HUB"; 254902ac6454SAndrew Thompson break; 255002ac6454SAndrew Thompson 255102ac6454SAndrew Thompson default: 2552459d369eSAndrew Thompson str_ptr = ""; 255302ac6454SAndrew Thompson break; 255402ac6454SAndrew Thompson } 255502ac6454SAndrew Thompson 2556a593f6b8SAndrew Thompson len = usb_make_str_desc 255702ac6454SAndrew Thompson (sc->sc_hub_desc.temp, 255802ac6454SAndrew Thompson sizeof(sc->sc_hub_desc.temp), 2559459d369eSAndrew Thompson str_ptr); 256002ac6454SAndrew Thompson break; 256102ac6454SAndrew Thompson 256202ac6454SAndrew Thompson default: 2563459d369eSAndrew Thompson err = USB_ERR_IOERROR; 256402ac6454SAndrew Thompson goto done; 256502ac6454SAndrew Thompson } 256602ac6454SAndrew Thompson break; 256702ac6454SAndrew Thompson case C(UR_GET_INTERFACE, UT_READ_INTERFACE): 2568459d369eSAndrew Thompson len = 1; 256902ac6454SAndrew Thompson sc->sc_hub_desc.temp[0] = 0; 257002ac6454SAndrew Thompson break; 257102ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_DEVICE): 2572459d369eSAndrew Thompson len = 2; 257302ac6454SAndrew Thompson USETW(sc->sc_hub_desc.stat.wStatus, UDS_SELF_POWERED); 257402ac6454SAndrew Thompson break; 257502ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_INTERFACE): 257602ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_ENDPOINT): 2577459d369eSAndrew Thompson len = 2; 257802ac6454SAndrew Thompson USETW(sc->sc_hub_desc.stat.wStatus, 0); 257902ac6454SAndrew Thompson break; 258002ac6454SAndrew Thompson case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): 2581ab42e8b2SAndrew Thompson if (value >= UHCI_MAX_DEVICES) { 2582459d369eSAndrew Thompson err = USB_ERR_IOERROR; 258302ac6454SAndrew Thompson goto done; 258402ac6454SAndrew Thompson } 258502ac6454SAndrew Thompson sc->sc_addr = value; 258602ac6454SAndrew Thompson break; 258702ac6454SAndrew Thompson case C(UR_SET_CONFIG, UT_WRITE_DEVICE): 258802ac6454SAndrew Thompson if ((value != 0) && (value != 1)) { 2589459d369eSAndrew Thompson err = USB_ERR_IOERROR; 259002ac6454SAndrew Thompson goto done; 259102ac6454SAndrew Thompson } 259202ac6454SAndrew Thompson sc->sc_conf = value; 259302ac6454SAndrew Thompson break; 259402ac6454SAndrew Thompson case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): 259502ac6454SAndrew Thompson break; 259602ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_DEVICE): 259702ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): 259802ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): 2599459d369eSAndrew Thompson err = USB_ERR_IOERROR; 260002ac6454SAndrew Thompson goto done; 260102ac6454SAndrew Thompson case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): 260202ac6454SAndrew Thompson break; 260302ac6454SAndrew Thompson case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): 260402ac6454SAndrew Thompson break; 260502ac6454SAndrew Thompson /* Hub requests */ 260602ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): 260702ac6454SAndrew Thompson break; 260802ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): 260902ac6454SAndrew Thompson DPRINTFN(4, "UR_CLEAR_PORT_FEATURE " 261002ac6454SAndrew Thompson "port=%d feature=%d\n", 261102ac6454SAndrew Thompson index, value); 261202ac6454SAndrew Thompson if (index == 1) 261302ac6454SAndrew Thompson port = UHCI_PORTSC1; 261402ac6454SAndrew Thompson else if (index == 2) 261502ac6454SAndrew Thompson port = UHCI_PORTSC2; 261602ac6454SAndrew Thompson else { 2617459d369eSAndrew Thompson err = USB_ERR_IOERROR; 261802ac6454SAndrew Thompson goto done; 261902ac6454SAndrew Thompson } 262002ac6454SAndrew Thompson switch (value) { 262102ac6454SAndrew Thompson case UHF_PORT_ENABLE: 262202ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 262302ac6454SAndrew Thompson UWRITE2(sc, port, x & ~UHCI_PORTSC_PE); 262402ac6454SAndrew Thompson break; 262502ac6454SAndrew Thompson case UHF_PORT_SUSPEND: 262602ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 262702ac6454SAndrew Thompson UWRITE2(sc, port, x & ~(UHCI_PORTSC_SUSP)); 262802ac6454SAndrew Thompson break; 262902ac6454SAndrew Thompson case UHF_PORT_RESET: 263002ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 263102ac6454SAndrew Thompson UWRITE2(sc, port, x & ~UHCI_PORTSC_PR); 263202ac6454SAndrew Thompson break; 263302ac6454SAndrew Thompson case UHF_C_PORT_CONNECTION: 263402ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 263502ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_CSC); 263602ac6454SAndrew Thompson break; 263702ac6454SAndrew Thompson case UHF_C_PORT_ENABLE: 263802ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 263902ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_POEDC); 264002ac6454SAndrew Thompson break; 264102ac6454SAndrew Thompson case UHF_C_PORT_OVER_CURRENT: 264202ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 264302ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_OCIC); 264402ac6454SAndrew Thompson break; 264502ac6454SAndrew Thompson case UHF_C_PORT_RESET: 264602ac6454SAndrew Thompson sc->sc_isreset = 0; 2647459d369eSAndrew Thompson err = USB_ERR_NORMAL_COMPLETION; 264802ac6454SAndrew Thompson goto done; 264902ac6454SAndrew Thompson case UHF_C_PORT_SUSPEND: 265002ac6454SAndrew Thompson sc->sc_isresumed &= ~(1 << index); 265102ac6454SAndrew Thompson break; 265202ac6454SAndrew Thompson case UHF_PORT_CONNECTION: 265302ac6454SAndrew Thompson case UHF_PORT_OVER_CURRENT: 265402ac6454SAndrew Thompson case UHF_PORT_POWER: 265502ac6454SAndrew Thompson case UHF_PORT_LOW_SPEED: 265602ac6454SAndrew Thompson default: 2657459d369eSAndrew Thompson err = USB_ERR_IOERROR; 265802ac6454SAndrew Thompson goto done; 265902ac6454SAndrew Thompson } 266002ac6454SAndrew Thompson break; 266102ac6454SAndrew Thompson case C(UR_GET_BUS_STATE, UT_READ_CLASS_OTHER): 266202ac6454SAndrew Thompson if (index == 1) 266302ac6454SAndrew Thompson port = UHCI_PORTSC1; 266402ac6454SAndrew Thompson else if (index == 2) 266502ac6454SAndrew Thompson port = UHCI_PORTSC2; 266602ac6454SAndrew Thompson else { 2667459d369eSAndrew Thompson err = USB_ERR_IOERROR; 266802ac6454SAndrew Thompson goto done; 266902ac6454SAndrew Thompson } 2670459d369eSAndrew Thompson len = 1; 267102ac6454SAndrew Thompson sc->sc_hub_desc.temp[0] = 267202ac6454SAndrew Thompson ((UREAD2(sc, port) & UHCI_PORTSC_LS) >> 267302ac6454SAndrew Thompson UHCI_PORTSC_LS_SHIFT); 267402ac6454SAndrew Thompson break; 267502ac6454SAndrew Thompson case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): 267602ac6454SAndrew Thompson if ((value & 0xff) != 0) { 2677459d369eSAndrew Thompson err = USB_ERR_IOERROR; 267802ac6454SAndrew Thompson goto done; 267902ac6454SAndrew Thompson } 2680459d369eSAndrew Thompson len = sizeof(uhci_hubd_piix); 2681459d369eSAndrew Thompson ptr = (const void *)&uhci_hubd_piix; 268202ac6454SAndrew Thompson break; 268302ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): 2684459d369eSAndrew Thompson len = 16; 2685271ae033SHans Petter Selasky memset(sc->sc_hub_desc.temp, 0, 16); 268602ac6454SAndrew Thompson break; 268702ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): 268802ac6454SAndrew Thompson if (index == 1) 268902ac6454SAndrew Thompson port = UHCI_PORTSC1; 269002ac6454SAndrew Thompson else if (index == 2) 269102ac6454SAndrew Thompson port = UHCI_PORTSC2; 269202ac6454SAndrew Thompson else { 2693459d369eSAndrew Thompson err = USB_ERR_IOERROR; 269402ac6454SAndrew Thompson goto done; 269502ac6454SAndrew Thompson } 269602ac6454SAndrew Thompson x = UREAD2(sc, port); 269702ac6454SAndrew Thompson status = change = 0; 269802ac6454SAndrew Thompson if (x & UHCI_PORTSC_CCS) 269902ac6454SAndrew Thompson status |= UPS_CURRENT_CONNECT_STATUS; 270002ac6454SAndrew Thompson if (x & UHCI_PORTSC_CSC) 270102ac6454SAndrew Thompson change |= UPS_C_CONNECT_STATUS; 270202ac6454SAndrew Thompson if (x & UHCI_PORTSC_PE) 270302ac6454SAndrew Thompson status |= UPS_PORT_ENABLED; 270402ac6454SAndrew Thompson if (x & UHCI_PORTSC_POEDC) 270502ac6454SAndrew Thompson change |= UPS_C_PORT_ENABLED; 270602ac6454SAndrew Thompson if (x & UHCI_PORTSC_OCI) 270702ac6454SAndrew Thompson status |= UPS_OVERCURRENT_INDICATOR; 270802ac6454SAndrew Thompson if (x & UHCI_PORTSC_OCIC) 270902ac6454SAndrew Thompson change |= UPS_C_OVERCURRENT_INDICATOR; 271002ac6454SAndrew Thompson if (x & UHCI_PORTSC_LSDA) 271102ac6454SAndrew Thompson status |= UPS_LOW_SPEED; 271202ac6454SAndrew Thompson if ((x & UHCI_PORTSC_PE) && (x & UHCI_PORTSC_RD)) { 271302ac6454SAndrew Thompson /* need to do a write back */ 271402ac6454SAndrew Thompson UWRITE2(sc, port, URWMASK(x)); 271502ac6454SAndrew Thompson 271602ac6454SAndrew Thompson /* wait 20ms for resume sequence to complete */ 2717a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); 271802ac6454SAndrew Thompson 271902ac6454SAndrew Thompson /* clear suspend and resume detect */ 272002ac6454SAndrew Thompson UWRITE2(sc, port, URWMASK(x) & ~(UHCI_PORTSC_RD | 272102ac6454SAndrew Thompson UHCI_PORTSC_SUSP)); 272202ac6454SAndrew Thompson 272302ac6454SAndrew Thompson /* wait a little bit */ 2724a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 500); 272502ac6454SAndrew Thompson 272602ac6454SAndrew Thompson sc->sc_isresumed |= (1 << index); 272702ac6454SAndrew Thompson 272802ac6454SAndrew Thompson } else if (x & UHCI_PORTSC_SUSP) { 272902ac6454SAndrew Thompson status |= UPS_SUSPEND; 273002ac6454SAndrew Thompson } 273102ac6454SAndrew Thompson status |= UPS_PORT_POWER; 273202ac6454SAndrew Thompson if (sc->sc_isresumed & (1 << index)) 273302ac6454SAndrew Thompson change |= UPS_C_SUSPEND; 273402ac6454SAndrew Thompson if (sc->sc_isreset) 273502ac6454SAndrew Thompson change |= UPS_C_PORT_RESET; 273602ac6454SAndrew Thompson USETW(sc->sc_hub_desc.ps.wPortStatus, status); 273702ac6454SAndrew Thompson USETW(sc->sc_hub_desc.ps.wPortChange, change); 2738459d369eSAndrew Thompson len = sizeof(sc->sc_hub_desc.ps); 273902ac6454SAndrew Thompson break; 274002ac6454SAndrew Thompson case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): 2741459d369eSAndrew Thompson err = USB_ERR_IOERROR; 274202ac6454SAndrew Thompson goto done; 274302ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): 274402ac6454SAndrew Thompson break; 274502ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): 274602ac6454SAndrew Thompson if (index == 1) 274702ac6454SAndrew Thompson port = UHCI_PORTSC1; 274802ac6454SAndrew Thompson else if (index == 2) 274902ac6454SAndrew Thompson port = UHCI_PORTSC2; 275002ac6454SAndrew Thompson else { 2751459d369eSAndrew Thompson err = USB_ERR_IOERROR; 275202ac6454SAndrew Thompson goto done; 275302ac6454SAndrew Thompson } 275402ac6454SAndrew Thompson switch (value) { 275502ac6454SAndrew Thompson case UHF_PORT_ENABLE: 275602ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 275702ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_PE); 275802ac6454SAndrew Thompson break; 275902ac6454SAndrew Thompson case UHF_PORT_SUSPEND: 276002ac6454SAndrew Thompson x = URWMASK(UREAD2(sc, port)); 276102ac6454SAndrew Thompson UWRITE2(sc, port, x | UHCI_PORTSC_SUSP); 276202ac6454SAndrew Thompson break; 276302ac6454SAndrew Thompson case UHF_PORT_RESET: 2764459d369eSAndrew Thompson err = uhci_portreset(sc, index); 276502ac6454SAndrew Thompson goto done; 276602ac6454SAndrew Thompson case UHF_PORT_POWER: 276702ac6454SAndrew Thompson /* pretend we turned on power */ 2768459d369eSAndrew Thompson err = USB_ERR_NORMAL_COMPLETION; 276902ac6454SAndrew Thompson goto done; 277002ac6454SAndrew Thompson case UHF_C_PORT_CONNECTION: 277102ac6454SAndrew Thompson case UHF_C_PORT_ENABLE: 277202ac6454SAndrew Thompson case UHF_C_PORT_OVER_CURRENT: 277302ac6454SAndrew Thompson case UHF_PORT_CONNECTION: 277402ac6454SAndrew Thompson case UHF_PORT_OVER_CURRENT: 277502ac6454SAndrew Thompson case UHF_PORT_LOW_SPEED: 277602ac6454SAndrew Thompson case UHF_C_PORT_SUSPEND: 277702ac6454SAndrew Thompson case UHF_C_PORT_RESET: 277802ac6454SAndrew Thompson default: 2779459d369eSAndrew Thompson err = USB_ERR_IOERROR; 278002ac6454SAndrew Thompson goto done; 278102ac6454SAndrew Thompson } 278202ac6454SAndrew Thompson break; 278302ac6454SAndrew Thompson default: 2784459d369eSAndrew Thompson err = USB_ERR_IOERROR; 278502ac6454SAndrew Thompson goto done; 278602ac6454SAndrew Thompson } 278702ac6454SAndrew Thompson done: 2788459d369eSAndrew Thompson *plength = len; 2789459d369eSAndrew Thompson *pptr = ptr; 2790459d369eSAndrew Thompson return (err); 279102ac6454SAndrew Thompson } 279202ac6454SAndrew Thompson 279302ac6454SAndrew Thompson /* 279439307315SAndrew Thompson * This routine is executed periodically and simulates interrupts from 279539307315SAndrew Thompson * the root controller interrupt pipe for port status change: 279602ac6454SAndrew Thompson */ 279702ac6454SAndrew Thompson static void 279839307315SAndrew Thompson uhci_root_intr(uhci_softc_t *sc) 279902ac6454SAndrew Thompson { 280002ac6454SAndrew Thompson DPRINTFN(21, "\n"); 280102ac6454SAndrew Thompson 280202ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 280302ac6454SAndrew Thompson 280402ac6454SAndrew Thompson sc->sc_hub_idata[0] = 0; 280502ac6454SAndrew Thompson 280602ac6454SAndrew Thompson if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC | 280702ac6454SAndrew Thompson UHCI_PORTSC_OCIC | UHCI_PORTSC_RD)) { 280802ac6454SAndrew Thompson sc->sc_hub_idata[0] |= 1 << 1; 280902ac6454SAndrew Thompson } 281002ac6454SAndrew Thompson if (UREAD2(sc, UHCI_PORTSC2) & (UHCI_PORTSC_CSC | 281102ac6454SAndrew Thompson UHCI_PORTSC_OCIC | UHCI_PORTSC_RD)) { 281202ac6454SAndrew Thompson sc->sc_hub_idata[0] |= 1 << 2; 281302ac6454SAndrew Thompson } 281402ac6454SAndrew Thompson 281539307315SAndrew Thompson /* restart timer */ 2816a593f6b8SAndrew Thompson usb_callout_reset(&sc->sc_root_intr, hz, 281739307315SAndrew Thompson (void *)&uhci_root_intr, sc); 281839307315SAndrew Thompson 281939307315SAndrew Thompson if (sc->sc_hub_idata[0] != 0) { 282039307315SAndrew Thompson uhub_root_intr(&sc->sc_bus, sc->sc_hub_idata, 282139307315SAndrew Thompson sizeof(sc->sc_hub_idata)); 282239307315SAndrew Thompson } 282339307315SAndrew Thompson } 282402ac6454SAndrew Thompson 282502ac6454SAndrew Thompson static void 2826760bc48eSAndrew Thompson uhci_xfer_setup(struct usb_setup_params *parm) 282702ac6454SAndrew Thompson { 2828760bc48eSAndrew Thompson struct usb_page_search page_info; 2829760bc48eSAndrew Thompson struct usb_page_cache *pc; 283002ac6454SAndrew Thompson uhci_softc_t *sc; 2831760bc48eSAndrew Thompson struct usb_xfer *xfer; 283202ac6454SAndrew Thompson void *last_obj; 283302ac6454SAndrew Thompson uint32_t ntd; 283402ac6454SAndrew Thompson uint32_t nqh; 283502ac6454SAndrew Thompson uint32_t nfixup; 283602ac6454SAndrew Thompson uint32_t n; 283702ac6454SAndrew Thompson uint16_t align; 283802ac6454SAndrew Thompson 283902ac6454SAndrew Thompson sc = UHCI_BUS2SC(parm->udev->bus); 284002ac6454SAndrew Thompson xfer = parm->curr_xfer; 284102ac6454SAndrew Thompson 284202ac6454SAndrew Thompson parm->hc_max_packet_size = 0x500; 284302ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 284402ac6454SAndrew Thompson parm->hc_max_frame_size = 0x500; 284502ac6454SAndrew Thompson 284602ac6454SAndrew Thompson /* 284702ac6454SAndrew Thompson * compute ntd and nqh 284802ac6454SAndrew Thompson */ 284902ac6454SAndrew Thompson if (parm->methods == &uhci_device_ctrl_methods) { 285002ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 285102ac6454SAndrew Thompson xfer->flags_int.bdma_no_post_sync = 1; 285202ac6454SAndrew Thompson 2853a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 285402ac6454SAndrew Thompson 285502ac6454SAndrew Thompson /* see EHCI HC driver for proof of "ntd" formula */ 285602ac6454SAndrew Thompson 285702ac6454SAndrew Thompson nqh = 1; 285802ac6454SAndrew Thompson ntd = ((2 * xfer->nframes) + 1 /* STATUS */ 285902ac6454SAndrew Thompson + (xfer->max_data_length / xfer->max_frame_size)); 286002ac6454SAndrew Thompson 286102ac6454SAndrew Thompson } else if (parm->methods == &uhci_device_bulk_methods) { 286202ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 286302ac6454SAndrew Thompson xfer->flags_int.bdma_no_post_sync = 1; 286402ac6454SAndrew Thompson 2865a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 286602ac6454SAndrew Thompson 286702ac6454SAndrew Thompson nqh = 1; 286802ac6454SAndrew Thompson ntd = ((2 * xfer->nframes) 286902ac6454SAndrew Thompson + (xfer->max_data_length / xfer->max_frame_size)); 287002ac6454SAndrew Thompson 287102ac6454SAndrew Thompson } else if (parm->methods == &uhci_device_intr_methods) { 287202ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 287302ac6454SAndrew Thompson xfer->flags_int.bdma_no_post_sync = 1; 287402ac6454SAndrew Thompson 2875a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 287602ac6454SAndrew Thompson 287702ac6454SAndrew Thompson nqh = 1; 287802ac6454SAndrew Thompson ntd = ((2 * xfer->nframes) 287902ac6454SAndrew Thompson + (xfer->max_data_length / xfer->max_frame_size)); 288002ac6454SAndrew Thompson 288102ac6454SAndrew Thompson } else if (parm->methods == &uhci_device_isoc_methods) { 288202ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 288302ac6454SAndrew Thompson xfer->flags_int.bdma_no_post_sync = 1; 288402ac6454SAndrew Thompson 2885a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 288602ac6454SAndrew Thompson 288702ac6454SAndrew Thompson nqh = 0; 288802ac6454SAndrew Thompson ntd = xfer->nframes; 288902ac6454SAndrew Thompson 289002ac6454SAndrew Thompson } else { 289102ac6454SAndrew Thompson 2892a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 289302ac6454SAndrew Thompson 289402ac6454SAndrew Thompson nqh = 0; 289502ac6454SAndrew Thompson ntd = 0; 289602ac6454SAndrew Thompson } 289702ac6454SAndrew Thompson 289802ac6454SAndrew Thompson if (parm->err) { 289902ac6454SAndrew Thompson return; 290002ac6454SAndrew Thompson } 290102ac6454SAndrew Thompson /* 290202ac6454SAndrew Thompson * NOTE: the UHCI controller requires that 290302ac6454SAndrew Thompson * every packet must be contiguous on 290402ac6454SAndrew Thompson * the same USB memory page ! 290502ac6454SAndrew Thompson */ 290602ac6454SAndrew Thompson nfixup = (parm->bufsize / USB_PAGE_SIZE) + 1; 290702ac6454SAndrew Thompson 290802ac6454SAndrew Thompson /* 290902ac6454SAndrew Thompson * Compute a suitable power of two alignment 291002ac6454SAndrew Thompson * for our "max_frame_size" fixup buffer(s): 291102ac6454SAndrew Thompson */ 291202ac6454SAndrew Thompson align = xfer->max_frame_size; 291302ac6454SAndrew Thompson n = 0; 291402ac6454SAndrew Thompson while (align) { 291502ac6454SAndrew Thompson align >>= 1; 291602ac6454SAndrew Thompson n++; 291702ac6454SAndrew Thompson } 291802ac6454SAndrew Thompson 291902ac6454SAndrew Thompson /* check for power of two */ 292002ac6454SAndrew Thompson if (!(xfer->max_frame_size & 292102ac6454SAndrew Thompson (xfer->max_frame_size - 1))) { 292202ac6454SAndrew Thompson n--; 292302ac6454SAndrew Thompson } 292402ac6454SAndrew Thompson /* 292502ac6454SAndrew Thompson * We don't allow alignments of 292602ac6454SAndrew Thompson * less than 8 bytes: 292702ac6454SAndrew Thompson * 292802ac6454SAndrew Thompson * NOTE: Allocating using an aligment 292902ac6454SAndrew Thompson * of 1 byte has special meaning! 293002ac6454SAndrew Thompson */ 293102ac6454SAndrew Thompson if (n < 3) { 293202ac6454SAndrew Thompson n = 3; 293302ac6454SAndrew Thompson } 293402ac6454SAndrew Thompson align = (1 << n); 293502ac6454SAndrew Thompson 2936a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 293702ac6454SAndrew Thompson parm, &pc, xfer->max_frame_size, 293802ac6454SAndrew Thompson align, nfixup)) { 293902ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 294002ac6454SAndrew Thompson return; 294102ac6454SAndrew Thompson } 294202ac6454SAndrew Thompson xfer->buf_fixup = pc; 294302ac6454SAndrew Thompson 294402ac6454SAndrew Thompson alloc_dma_set: 294502ac6454SAndrew Thompson 294602ac6454SAndrew Thompson if (parm->err) { 294702ac6454SAndrew Thompson return; 294802ac6454SAndrew Thompson } 294902ac6454SAndrew Thompson last_obj = NULL; 295002ac6454SAndrew Thompson 2951a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 295202ac6454SAndrew Thompson parm, &pc, sizeof(uhci_td_t), 295302ac6454SAndrew Thompson UHCI_TD_ALIGN, ntd)) { 295402ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 295502ac6454SAndrew Thompson return; 295602ac6454SAndrew Thompson } 295702ac6454SAndrew Thompson if (parm->buf) { 295802ac6454SAndrew Thompson for (n = 0; n != ntd; n++) { 295902ac6454SAndrew Thompson uhci_td_t *td; 296002ac6454SAndrew Thompson 2961a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 296202ac6454SAndrew Thompson 296302ac6454SAndrew Thompson td = page_info.buffer; 296402ac6454SAndrew Thompson 296502ac6454SAndrew Thompson /* init TD */ 296602ac6454SAndrew Thompson if ((parm->methods == &uhci_device_bulk_methods) || 296702ac6454SAndrew Thompson (parm->methods == &uhci_device_ctrl_methods) || 296802ac6454SAndrew Thompson (parm->methods == &uhci_device_intr_methods)) { 296902ac6454SAndrew Thompson /* set depth first bit */ 297002ac6454SAndrew Thompson td->td_self = htole32(page_info.physaddr | 297102ac6454SAndrew Thompson UHCI_PTR_TD | UHCI_PTR_VF); 297202ac6454SAndrew Thompson } else { 297302ac6454SAndrew Thompson td->td_self = htole32(page_info.physaddr | 297402ac6454SAndrew Thompson UHCI_PTR_TD); 297502ac6454SAndrew Thompson } 297602ac6454SAndrew Thompson 297702ac6454SAndrew Thompson td->obj_next = last_obj; 297802ac6454SAndrew Thompson td->page_cache = pc + n; 297902ac6454SAndrew Thompson 298002ac6454SAndrew Thompson last_obj = td; 298102ac6454SAndrew Thompson 2982a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 298302ac6454SAndrew Thompson } 298402ac6454SAndrew Thompson } 298502ac6454SAndrew Thompson xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj; 298602ac6454SAndrew Thompson 298702ac6454SAndrew Thompson last_obj = NULL; 298802ac6454SAndrew Thompson 2989a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 299002ac6454SAndrew Thompson parm, &pc, sizeof(uhci_qh_t), 299102ac6454SAndrew Thompson UHCI_QH_ALIGN, nqh)) { 299202ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 299302ac6454SAndrew Thompson return; 299402ac6454SAndrew Thompson } 299502ac6454SAndrew Thompson if (parm->buf) { 299602ac6454SAndrew Thompson for (n = 0; n != nqh; n++) { 299702ac6454SAndrew Thompson uhci_qh_t *qh; 299802ac6454SAndrew Thompson 2999a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 300002ac6454SAndrew Thompson 300102ac6454SAndrew Thompson qh = page_info.buffer; 300202ac6454SAndrew Thompson 300302ac6454SAndrew Thompson /* init QH */ 300402ac6454SAndrew Thompson qh->qh_self = htole32(page_info.physaddr | UHCI_PTR_QH); 300502ac6454SAndrew Thompson qh->obj_next = last_obj; 300602ac6454SAndrew Thompson qh->page_cache = pc + n; 300702ac6454SAndrew Thompson 300802ac6454SAndrew Thompson last_obj = qh; 300902ac6454SAndrew Thompson 3010a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 301102ac6454SAndrew Thompson } 301202ac6454SAndrew Thompson } 301302ac6454SAndrew Thompson xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj; 301402ac6454SAndrew Thompson 301502ac6454SAndrew Thompson if (!xfer->flags_int.curr_dma_set) { 301602ac6454SAndrew Thompson xfer->flags_int.curr_dma_set = 1; 301702ac6454SAndrew Thompson goto alloc_dma_set; 301802ac6454SAndrew Thompson } 301902ac6454SAndrew Thompson } 302002ac6454SAndrew Thompson 302102ac6454SAndrew Thompson static void 3022ae60fdfbSAndrew Thompson uhci_ep_init(struct usb_device *udev, struct usb_endpoint_descriptor *edesc, 3023ae60fdfbSAndrew Thompson struct usb_endpoint *ep) 302402ac6454SAndrew Thompson { 302502ac6454SAndrew Thompson uhci_softc_t *sc = UHCI_BUS2SC(udev->bus); 302602ac6454SAndrew Thompson 3027ae60fdfbSAndrew Thompson DPRINTFN(2, "endpoint=%p, addr=%d, endpt=%d, mode=%d (%d)\n", 3028ae60fdfbSAndrew Thompson ep, udev->address, 3029f29a0724SAndrew Thompson edesc->bEndpointAddress, udev->flags.usb_mode, 303002ac6454SAndrew Thompson sc->sc_addr); 303102ac6454SAndrew Thompson 303239307315SAndrew Thompson if (udev->device_index != sc->sc_addr) { 303302ac6454SAndrew Thompson switch (edesc->bmAttributes & UE_XFERTYPE) { 303402ac6454SAndrew Thompson case UE_CONTROL: 3035ae60fdfbSAndrew Thompson ep->methods = &uhci_device_ctrl_methods; 303602ac6454SAndrew Thompson break; 303702ac6454SAndrew Thompson case UE_INTERRUPT: 3038ae60fdfbSAndrew Thompson ep->methods = &uhci_device_intr_methods; 303902ac6454SAndrew Thompson break; 304002ac6454SAndrew Thompson case UE_ISOCHRONOUS: 304102ac6454SAndrew Thompson if (udev->speed == USB_SPEED_FULL) { 3042ae60fdfbSAndrew Thompson ep->methods = &uhci_device_isoc_methods; 304302ac6454SAndrew Thompson } 304402ac6454SAndrew Thompson break; 304502ac6454SAndrew Thompson case UE_BULK: 3046ae60fdfbSAndrew Thompson ep->methods = &uhci_device_bulk_methods; 304702ac6454SAndrew Thompson break; 304802ac6454SAndrew Thompson default: 304902ac6454SAndrew Thompson /* do nothing */ 305002ac6454SAndrew Thompson break; 305102ac6454SAndrew Thompson } 305202ac6454SAndrew Thompson } 305302ac6454SAndrew Thompson } 305402ac6454SAndrew Thompson 305502ac6454SAndrew Thompson static void 3056760bc48eSAndrew Thompson uhci_xfer_unsetup(struct usb_xfer *xfer) 305702ac6454SAndrew Thompson { 305802ac6454SAndrew Thompson return; 305902ac6454SAndrew Thompson } 306002ac6454SAndrew Thompson 306102ac6454SAndrew Thompson static void 3062527aa7b2SAndrew Thompson uhci_get_dma_delay(struct usb_device *udev, uint32_t *pus) 306302ac6454SAndrew Thompson { 306402ac6454SAndrew Thompson /* 306502ac6454SAndrew Thompson * Wait until hardware has finished any possible use of the 306602ac6454SAndrew Thompson * transfer descriptor(s) and QH 306702ac6454SAndrew Thompson */ 306802ac6454SAndrew Thompson *pus = (1125); /* microseconds */ 306902ac6454SAndrew Thompson } 307002ac6454SAndrew Thompson 307102ac6454SAndrew Thompson static void 3072760bc48eSAndrew Thompson uhci_device_resume(struct usb_device *udev) 307302ac6454SAndrew Thompson { 307402ac6454SAndrew Thompson struct uhci_softc *sc = UHCI_BUS2SC(udev->bus); 3075760bc48eSAndrew Thompson struct usb_xfer *xfer; 3076760bc48eSAndrew Thompson struct usb_pipe_methods *methods; 307702ac6454SAndrew Thompson uhci_qh_t *qh; 307802ac6454SAndrew Thompson 307902ac6454SAndrew Thompson DPRINTF("\n"); 308002ac6454SAndrew Thompson 308102ac6454SAndrew Thompson USB_BUS_LOCK(udev->bus); 308202ac6454SAndrew Thompson 308302ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 308402ac6454SAndrew Thompson 308502ac6454SAndrew Thompson if (xfer->xroot->udev == udev) { 308602ac6454SAndrew Thompson 3087ae60fdfbSAndrew Thompson methods = xfer->endpoint->methods; 308802ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 308902ac6454SAndrew Thompson 309002ac6454SAndrew Thompson if (methods == &uhci_device_bulk_methods) { 309102ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_bulk_p_last); 309202ac6454SAndrew Thompson uhci_add_loop(sc); 309302ac6454SAndrew Thompson xfer->flags_int.bandwidth_reclaimed = 1; 309402ac6454SAndrew Thompson } 309502ac6454SAndrew Thompson if (methods == &uhci_device_ctrl_methods) { 309602ac6454SAndrew Thompson if (xfer->xroot->udev->speed == USB_SPEED_LOW) { 309702ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_ls_ctl_p_last); 309802ac6454SAndrew Thompson } else { 309902ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_fs_ctl_p_last); 310002ac6454SAndrew Thompson } 310102ac6454SAndrew Thompson } 310202ac6454SAndrew Thompson if (methods == &uhci_device_intr_methods) { 310302ac6454SAndrew Thompson UHCI_APPEND_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]); 310402ac6454SAndrew Thompson } 310502ac6454SAndrew Thompson } 310602ac6454SAndrew Thompson } 310702ac6454SAndrew Thompson 310802ac6454SAndrew Thompson USB_BUS_UNLOCK(udev->bus); 310902ac6454SAndrew Thompson 311002ac6454SAndrew Thompson return; 311102ac6454SAndrew Thompson } 311202ac6454SAndrew Thompson 311302ac6454SAndrew Thompson static void 3114760bc48eSAndrew Thompson uhci_device_suspend(struct usb_device *udev) 311502ac6454SAndrew Thompson { 311602ac6454SAndrew Thompson struct uhci_softc *sc = UHCI_BUS2SC(udev->bus); 3117760bc48eSAndrew Thompson struct usb_xfer *xfer; 3118760bc48eSAndrew Thompson struct usb_pipe_methods *methods; 311902ac6454SAndrew Thompson uhci_qh_t *qh; 312002ac6454SAndrew Thompson 312102ac6454SAndrew Thompson DPRINTF("\n"); 312202ac6454SAndrew Thompson 312302ac6454SAndrew Thompson USB_BUS_LOCK(udev->bus); 312402ac6454SAndrew Thompson 312502ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 312602ac6454SAndrew Thompson 312702ac6454SAndrew Thompson if (xfer->xroot->udev == udev) { 312802ac6454SAndrew Thompson 3129ae60fdfbSAndrew Thompson methods = xfer->endpoint->methods; 313002ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 313102ac6454SAndrew Thompson 313202ac6454SAndrew Thompson if (xfer->flags_int.bandwidth_reclaimed) { 313302ac6454SAndrew Thompson xfer->flags_int.bandwidth_reclaimed = 0; 313402ac6454SAndrew Thompson uhci_rem_loop(sc); 313502ac6454SAndrew Thompson } 313602ac6454SAndrew Thompson if (methods == &uhci_device_bulk_methods) { 313702ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_bulk_p_last); 313802ac6454SAndrew Thompson } 313902ac6454SAndrew Thompson if (methods == &uhci_device_ctrl_methods) { 314002ac6454SAndrew Thompson if (xfer->xroot->udev->speed == USB_SPEED_LOW) { 314102ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_ls_ctl_p_last); 314202ac6454SAndrew Thompson } else { 314302ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_fs_ctl_p_last); 314402ac6454SAndrew Thompson } 314502ac6454SAndrew Thompson } 314602ac6454SAndrew Thompson if (methods == &uhci_device_intr_methods) { 314702ac6454SAndrew Thompson UHCI_REMOVE_QH(qh, sc->sc_intr_p_last[xfer->qh_pos]); 314802ac6454SAndrew Thompson } 314902ac6454SAndrew Thompson } 315002ac6454SAndrew Thompson } 315102ac6454SAndrew Thompson 315202ac6454SAndrew Thompson USB_BUS_UNLOCK(udev->bus); 315302ac6454SAndrew Thompson 315402ac6454SAndrew Thompson return; 315502ac6454SAndrew Thompson } 315602ac6454SAndrew Thompson 315702ac6454SAndrew Thompson static void 31582e141748SHans Petter Selasky uhci_set_hw_power_sleep(struct usb_bus *bus, uint32_t state) 31592e141748SHans Petter Selasky { 31602e141748SHans Petter Selasky struct uhci_softc *sc = UHCI_BUS2SC(bus); 31612e141748SHans Petter Selasky 31622e141748SHans Petter Selasky switch (state) { 31632e141748SHans Petter Selasky case USB_HW_POWER_SUSPEND: 31642e141748SHans Petter Selasky case USB_HW_POWER_SHUTDOWN: 31652e141748SHans Petter Selasky uhci_suspend(sc); 31662e141748SHans Petter Selasky break; 31672e141748SHans Petter Selasky case USB_HW_POWER_RESUME: 31682e141748SHans Petter Selasky uhci_resume(sc); 31692e141748SHans Petter Selasky break; 31702e141748SHans Petter Selasky default: 31712e141748SHans Petter Selasky break; 31722e141748SHans Petter Selasky } 31732e141748SHans Petter Selasky } 31742e141748SHans Petter Selasky 31752e141748SHans Petter Selasky static void 3176760bc48eSAndrew Thompson uhci_set_hw_power(struct usb_bus *bus) 317702ac6454SAndrew Thompson { 317802ac6454SAndrew Thompson struct uhci_softc *sc = UHCI_BUS2SC(bus); 317902ac6454SAndrew Thompson uint32_t flags; 318002ac6454SAndrew Thompson 318102ac6454SAndrew Thompson DPRINTF("\n"); 318202ac6454SAndrew Thompson 318302ac6454SAndrew Thompson USB_BUS_LOCK(bus); 318402ac6454SAndrew Thompson 318502ac6454SAndrew Thompson flags = bus->hw_power_state; 318602ac6454SAndrew Thompson 318702ac6454SAndrew Thompson /* 318802ac6454SAndrew Thompson * WARNING: Some FULL speed USB devices require periodic SOF 318902ac6454SAndrew Thompson * messages! If any USB devices are connected through the 319002ac6454SAndrew Thompson * UHCI, power save will be disabled! 319102ac6454SAndrew Thompson */ 319202ac6454SAndrew Thompson if (flags & (USB_HW_POWER_CONTROL | 319302ac6454SAndrew Thompson USB_HW_POWER_NON_ROOT_HUB | 319402ac6454SAndrew Thompson USB_HW_POWER_BULK | 319502ac6454SAndrew Thompson USB_HW_POWER_INTERRUPT | 319602ac6454SAndrew Thompson USB_HW_POWER_ISOC)) { 319702ac6454SAndrew Thompson DPRINTF("Some USB transfer is " 3198b9c81a5dSAndrew Thompson "active on unit %u.\n", 319902ac6454SAndrew Thompson device_get_unit(sc->sc_bus.bdev)); 3200b9c81a5dSAndrew Thompson uhci_restart(sc); 320102ac6454SAndrew Thompson } else { 3202b9c81a5dSAndrew Thompson DPRINTF("Power save on unit %u.\n", 320302ac6454SAndrew Thompson device_get_unit(sc->sc_bus.bdev)); 320402ac6454SAndrew Thompson UHCICMD(sc, UHCI_CMD_MAXP); 320502ac6454SAndrew Thompson } 320602ac6454SAndrew Thompson 320702ac6454SAndrew Thompson USB_BUS_UNLOCK(bus); 320802ac6454SAndrew Thompson 320902ac6454SAndrew Thompson return; 321002ac6454SAndrew Thompson } 321102ac6454SAndrew Thompson 321202ac6454SAndrew Thompson 3213760bc48eSAndrew Thompson struct usb_bus_methods uhci_bus_methods = 321402ac6454SAndrew Thompson { 3215ae60fdfbSAndrew Thompson .endpoint_init = uhci_ep_init, 321602ac6454SAndrew Thompson .xfer_setup = uhci_xfer_setup, 321702ac6454SAndrew Thompson .xfer_unsetup = uhci_xfer_unsetup, 321802ac6454SAndrew Thompson .get_dma_delay = uhci_get_dma_delay, 321902ac6454SAndrew Thompson .device_resume = uhci_device_resume, 322002ac6454SAndrew Thompson .device_suspend = uhci_device_suspend, 322102ac6454SAndrew Thompson .set_hw_power = uhci_set_hw_power, 32222e141748SHans Petter Selasky .set_hw_power_sleep = uhci_set_hw_power_sleep, 322339307315SAndrew Thompson .roothub_exec = uhci_roothub_exec, 3224dddb25f9SAlfred Perlstein .xfer_poll = uhci_do_poll, 322502ac6454SAndrew Thompson }; 3226