102ac6454SAndrew Thompson /*- 202ac6454SAndrew Thompson * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 302ac6454SAndrew Thompson * Copyright (c) 2004 The NetBSD Foundation, Inc. All rights reserved. 402ac6454SAndrew Thompson * Copyright (c) 2004 Lennart Augustsson. All rights reserved. 502ac6454SAndrew Thompson * Copyright (c) 2004 Charles M. Hannum. All rights reserved. 602ac6454SAndrew Thompson * 702ac6454SAndrew Thompson * Redistribution and use in source and binary forms, with or without 802ac6454SAndrew Thompson * modification, are permitted provided that the following conditions 902ac6454SAndrew Thompson * are met: 1002ac6454SAndrew Thompson * 1. Redistributions of source code must retain the above copyright 1102ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer. 1202ac6454SAndrew Thompson * 2. Redistributions in binary form must reproduce the above copyright 1302ac6454SAndrew Thompson * notice, this list of conditions and the following disclaimer in the 1402ac6454SAndrew Thompson * documentation and/or other materials provided with the distribution. 1502ac6454SAndrew Thompson * 1602ac6454SAndrew Thompson * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1702ac6454SAndrew Thompson * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1802ac6454SAndrew Thompson * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1902ac6454SAndrew Thompson * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 2002ac6454SAndrew Thompson * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2102ac6454SAndrew Thompson * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2202ac6454SAndrew Thompson * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2302ac6454SAndrew Thompson * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2402ac6454SAndrew Thompson * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2502ac6454SAndrew Thompson * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2602ac6454SAndrew Thompson * SUCH DAMAGE. 2702ac6454SAndrew Thompson */ 2802ac6454SAndrew Thompson 2902ac6454SAndrew Thompson /* 3002ac6454SAndrew Thompson * USB Enhanced Host Controller Driver, a.k.a. USB 2.0 controller. 3102ac6454SAndrew Thompson * 3202ac6454SAndrew Thompson * The EHCI 0.96 spec can be found at 3302ac6454SAndrew Thompson * http://developer.intel.com/technology/usb/download/ehci-r096.pdf 3402ac6454SAndrew Thompson * The EHCI 1.0 spec can be found at 3502ac6454SAndrew Thompson * http://developer.intel.com/technology/usb/download/ehci-r10.pdf 3602ac6454SAndrew Thompson * and the USB 2.0 spec at 3702ac6454SAndrew Thompson * http://www.usb.org/developers/docs/usb_20.zip 3802ac6454SAndrew Thompson * 3902ac6454SAndrew Thompson */ 4002ac6454SAndrew Thompson 4102ac6454SAndrew Thompson /* 4202ac6454SAndrew Thompson * TODO: 4302ac6454SAndrew Thompson * 1) command failures are not recovered correctly 4402ac6454SAndrew Thompson */ 4502ac6454SAndrew Thompson 4602ac6454SAndrew Thompson #include <sys/cdefs.h> 4702ac6454SAndrew Thompson __FBSDID("$FreeBSD$"); 4802ac6454SAndrew Thompson 49ed6d949aSAndrew Thompson #include <sys/stdint.h> 50ed6d949aSAndrew Thompson #include <sys/stddef.h> 51ed6d949aSAndrew Thompson #include <sys/param.h> 52ed6d949aSAndrew Thompson #include <sys/queue.h> 53ed6d949aSAndrew Thompson #include <sys/types.h> 54ed6d949aSAndrew Thompson #include <sys/systm.h> 55ed6d949aSAndrew Thompson #include <sys/kernel.h> 56ed6d949aSAndrew Thompson #include <sys/bus.h> 57ed6d949aSAndrew Thompson #include <sys/linker_set.h> 58ed6d949aSAndrew Thompson #include <sys/module.h> 59ed6d949aSAndrew Thompson #include <sys/lock.h> 60ed6d949aSAndrew Thompson #include <sys/mutex.h> 61ed6d949aSAndrew Thompson #include <sys/condvar.h> 62ed6d949aSAndrew Thompson #include <sys/sysctl.h> 63ed6d949aSAndrew Thompson #include <sys/sx.h> 64ed6d949aSAndrew Thompson #include <sys/unistd.h> 65ed6d949aSAndrew Thompson #include <sys/callout.h> 66ed6d949aSAndrew Thompson #include <sys/malloc.h> 67ed6d949aSAndrew Thompson #include <sys/priv.h> 68ed6d949aSAndrew Thompson 6902ac6454SAndrew Thompson #include <dev/usb/usb.h> 70ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h> 7102ac6454SAndrew Thompson 7202ac6454SAndrew Thompson #define USB_DEBUG_VAR ehcidebug 7302ac6454SAndrew Thompson 7402ac6454SAndrew Thompson #include <dev/usb/usb_core.h> 7502ac6454SAndrew Thompson #include <dev/usb/usb_debug.h> 7602ac6454SAndrew Thompson #include <dev/usb/usb_busdma.h> 7702ac6454SAndrew Thompson #include <dev/usb/usb_process.h> 7802ac6454SAndrew Thompson #include <dev/usb/usb_transfer.h> 7902ac6454SAndrew Thompson #include <dev/usb/usb_device.h> 8002ac6454SAndrew Thompson #include <dev/usb/usb_hub.h> 8102ac6454SAndrew Thompson #include <dev/usb/usb_util.h> 8202ac6454SAndrew Thompson 8302ac6454SAndrew Thompson #include <dev/usb/usb_controller.h> 8402ac6454SAndrew Thompson #include <dev/usb/usb_bus.h> 8502ac6454SAndrew Thompson #include <dev/usb/controller/ehci.h> 861def609aSAndrew Thompson #include <dev/usb/controller/ehcireg.h> 8702ac6454SAndrew Thompson 88578d0effSAndrew Thompson #define EHCI_BUS2SC(bus) \ 89578d0effSAndrew Thompson ((ehci_softc_t *)(((uint8_t *)(bus)) - \ 90578d0effSAndrew Thompson ((uint8_t *)&(((ehci_softc_t *)0)->sc_bus)))) 9102ac6454SAndrew Thompson 92b850ecc1SAndrew Thompson #ifdef USB_DEBUG 9302ac6454SAndrew Thompson static int ehcidebug = 0; 9402ac6454SAndrew Thompson static int ehcinohighspeed = 0; 95cf223a88SAndrew Thompson static int ehciiaadbug = 0; 96cf223a88SAndrew Thompson static int ehcilostintrbug = 0; 9702ac6454SAndrew Thompson 989360ae40SAndrew Thompson SYSCTL_NODE(_hw_usb, OID_AUTO, ehci, CTLFLAG_RW, 0, "USB ehci"); 999360ae40SAndrew Thompson SYSCTL_INT(_hw_usb_ehci, OID_AUTO, debug, CTLFLAG_RW, 10002ac6454SAndrew Thompson &ehcidebug, 0, "Debug level"); 1019360ae40SAndrew Thompson SYSCTL_INT(_hw_usb_ehci, OID_AUTO, no_hs, CTLFLAG_RW, 10202ac6454SAndrew Thompson &ehcinohighspeed, 0, "Disable High Speed USB"); 103cf223a88SAndrew Thompson SYSCTL_INT(_hw_usb_ehci, OID_AUTO, iaadbug, CTLFLAG_RW, 104cf223a88SAndrew Thompson &ehciiaadbug, 0, "Enable doorbell bug workaround"); 105cf223a88SAndrew Thompson SYSCTL_INT(_hw_usb_ehci, OID_AUTO, lostintrbug, CTLFLAG_RW, 106cf223a88SAndrew Thompson &ehcilostintrbug, 0, "Enable lost interrupt bug workaround"); 10702ac6454SAndrew Thompson 108c13fd8d4SAndrew Thompson TUNABLE_INT("hw.usb.ehci.debug", &ehcidebug); 109c13fd8d4SAndrew Thompson TUNABLE_INT("hw.usb.ehci.no_hs", &ehcinohighspeed); 110cf223a88SAndrew Thompson TUNABLE_INT("hw.usb.ehci.iaadbug", &ehciiaadbug); 111cf223a88SAndrew Thompson TUNABLE_INT("hw.usb.ehci.lostintrbug", &ehcilostintrbug); 112c13fd8d4SAndrew Thompson 11302ac6454SAndrew Thompson static void ehci_dump_regs(ehci_softc_t *sc); 11402ac6454SAndrew Thompson static void ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *sqh); 11502ac6454SAndrew Thompson 11602ac6454SAndrew Thompson #endif 11702ac6454SAndrew Thompson 11802ac6454SAndrew Thompson #define EHCI_INTR_ENDPT 1 11902ac6454SAndrew Thompson 120760bc48eSAndrew Thompson extern struct usb_bus_methods ehci_bus_methods; 121760bc48eSAndrew Thompson extern struct usb_pipe_methods ehci_device_bulk_methods; 122760bc48eSAndrew Thompson extern struct usb_pipe_methods ehci_device_ctrl_methods; 123760bc48eSAndrew Thompson extern struct usb_pipe_methods ehci_device_intr_methods; 124760bc48eSAndrew Thompson extern struct usb_pipe_methods ehci_device_isoc_fs_methods; 125760bc48eSAndrew Thompson extern struct usb_pipe_methods ehci_device_isoc_hs_methods; 12602ac6454SAndrew Thompson 12730b22abeSAndrew Thompson static void ehci_do_poll(struct usb_bus *); 12830b22abeSAndrew Thompson static void ehci_device_done(struct usb_xfer *, usb_error_t); 12930b22abeSAndrew Thompson static uint8_t ehci_check_transfer(struct usb_xfer *); 13030b22abeSAndrew Thompson static void ehci_timeout(void *); 13130b22abeSAndrew Thompson static void ehci_poll_timeout(void *); 13230b22abeSAndrew Thompson 13339307315SAndrew Thompson static void ehci_root_intr(ehci_softc_t *sc); 13402ac6454SAndrew Thompson 13502ac6454SAndrew Thompson struct ehci_std_temp { 13602ac6454SAndrew Thompson ehci_softc_t *sc; 137760bc48eSAndrew Thompson struct usb_page_cache *pc; 13802ac6454SAndrew Thompson ehci_qtd_t *td; 13902ac6454SAndrew Thompson ehci_qtd_t *td_next; 14002ac6454SAndrew Thompson uint32_t average; 14102ac6454SAndrew Thompson uint32_t qtd_status; 14202ac6454SAndrew Thompson uint32_t len; 14302ac6454SAndrew Thompson uint16_t max_frame_size; 14402ac6454SAndrew Thompson uint8_t shortpkt; 14502ac6454SAndrew Thompson uint8_t auto_data_toggle; 14602ac6454SAndrew Thompson uint8_t setup_alt_next; 1470f7d4548SAndrew Thompson uint8_t last_frame; 148c8a14b91SAndrew Thompson uint8_t can_use_next; 14902ac6454SAndrew Thompson }; 15002ac6454SAndrew Thompson 15102ac6454SAndrew Thompson void 152e0a69b51SAndrew Thompson ehci_iterate_hw_softc(struct usb_bus *bus, usb_bus_mem_sub_cb_t *cb) 15302ac6454SAndrew Thompson { 15402ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(bus); 15502ac6454SAndrew Thompson uint32_t i; 15602ac6454SAndrew Thompson 15702ac6454SAndrew Thompson cb(bus, &sc->sc_hw.pframes_pc, &sc->sc_hw.pframes_pg, 15802ac6454SAndrew Thompson sizeof(uint32_t) * EHCI_FRAMELIST_COUNT, EHCI_FRAMELIST_ALIGN); 15902ac6454SAndrew Thompson 16002ac6454SAndrew Thompson cb(bus, &sc->sc_hw.async_start_pc, &sc->sc_hw.async_start_pg, 16102ac6454SAndrew Thompson sizeof(ehci_qh_t), EHCI_QH_ALIGN); 16202ac6454SAndrew Thompson 16302ac6454SAndrew Thompson for (i = 0; i != EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { 16402ac6454SAndrew Thompson cb(bus, sc->sc_hw.intr_start_pc + i, 16502ac6454SAndrew Thompson sc->sc_hw.intr_start_pg + i, 16602ac6454SAndrew Thompson sizeof(ehci_qh_t), EHCI_QH_ALIGN); 16702ac6454SAndrew Thompson } 16802ac6454SAndrew Thompson 16902ac6454SAndrew Thompson for (i = 0; i != EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { 17002ac6454SAndrew Thompson cb(bus, sc->sc_hw.isoc_hs_start_pc + i, 17102ac6454SAndrew Thompson sc->sc_hw.isoc_hs_start_pg + i, 17202ac6454SAndrew Thompson sizeof(ehci_itd_t), EHCI_ITD_ALIGN); 17302ac6454SAndrew Thompson } 17402ac6454SAndrew Thompson 17502ac6454SAndrew Thompson for (i = 0; i != EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { 17602ac6454SAndrew Thompson cb(bus, sc->sc_hw.isoc_fs_start_pc + i, 17702ac6454SAndrew Thompson sc->sc_hw.isoc_fs_start_pg + i, 17802ac6454SAndrew Thompson sizeof(ehci_sitd_t), EHCI_SITD_ALIGN); 17902ac6454SAndrew Thompson } 18002ac6454SAndrew Thompson } 18102ac6454SAndrew Thompson 182e0a69b51SAndrew Thompson usb_error_t 183e55e1ebcSAndrew Thompson ehci_reset(ehci_softc_t *sc) 18402ac6454SAndrew Thompson { 18502ac6454SAndrew Thompson uint32_t hcr; 186e55e1ebcSAndrew Thompson int i; 187e55e1ebcSAndrew Thompson 188e55e1ebcSAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, EHCI_CMD_HCRESET); 189e55e1ebcSAndrew Thompson for (i = 0; i < 100; i++) { 190a593f6b8SAndrew Thompson usb_pause_mtx(NULL, hz / 1000); 191e55e1ebcSAndrew Thompson hcr = EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_HCRESET; 192e55e1ebcSAndrew Thompson if (!hcr) { 193e55e1ebcSAndrew Thompson if (sc->sc_flags & (EHCI_SCFLG_SETMODE | EHCI_SCFLG_BIGEMMIO)) { 194e55e1ebcSAndrew Thompson /* 195e55e1ebcSAndrew Thompson * Force USBMODE as requested. Controllers 196e55e1ebcSAndrew Thompson * may have multiple operating modes. 197e55e1ebcSAndrew Thompson */ 198e55e1ebcSAndrew Thompson uint32_t usbmode = EOREAD4(sc, EHCI_USBMODE); 199e55e1ebcSAndrew Thompson if (sc->sc_flags & EHCI_SCFLG_SETMODE) { 200e55e1ebcSAndrew Thompson usbmode = (usbmode &~ EHCI_UM_CM) | EHCI_UM_CM_HOST; 201e55e1ebcSAndrew Thompson device_printf(sc->sc_bus.bdev, 202e55e1ebcSAndrew Thompson "set host controller mode\n"); 203e55e1ebcSAndrew Thompson } 204e55e1ebcSAndrew Thompson if (sc->sc_flags & EHCI_SCFLG_BIGEMMIO) { 205e55e1ebcSAndrew Thompson usbmode = (usbmode &~ EHCI_UM_ES) | EHCI_UM_ES_BE; 206e55e1ebcSAndrew Thompson device_printf(sc->sc_bus.bdev, 207e55e1ebcSAndrew Thompson "set big-endian mode\n"); 208e55e1ebcSAndrew Thompson } 209e55e1ebcSAndrew Thompson EOWRITE4(sc, EHCI_USBMODE, usbmode); 210e55e1ebcSAndrew Thompson } 211e55e1ebcSAndrew Thompson return (0); 212e55e1ebcSAndrew Thompson } 213e55e1ebcSAndrew Thompson } 214e55e1ebcSAndrew Thompson device_printf(sc->sc_bus.bdev, "reset timeout\n"); 215e55e1ebcSAndrew Thompson return (USB_ERR_IOERROR); 216e55e1ebcSAndrew Thompson } 217e55e1ebcSAndrew Thompson 218e0a69b51SAndrew Thompson static usb_error_t 219e55e1ebcSAndrew Thompson ehci_hcreset(ehci_softc_t *sc) 220e55e1ebcSAndrew Thompson { 221e55e1ebcSAndrew Thompson uint32_t hcr; 222e55e1ebcSAndrew Thompson int i; 22302ac6454SAndrew Thompson 22402ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, 0); /* Halt controller */ 225e55e1ebcSAndrew Thompson for (i = 0; i < 100; i++) { 226a593f6b8SAndrew Thompson usb_pause_mtx(NULL, hz / 1000); 227e55e1ebcSAndrew Thompson hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; 228e55e1ebcSAndrew Thompson if (hcr) 22902ac6454SAndrew Thompson break; 23002ac6454SAndrew Thompson } 231e55e1ebcSAndrew Thompson if (!hcr) 23202ac6454SAndrew Thompson /* 23302ac6454SAndrew Thompson * Fall through and try reset anyway even though 23402ac6454SAndrew Thompson * Table 2-9 in the EHCI spec says this will result 23502ac6454SAndrew Thompson * in undefined behavior. 23602ac6454SAndrew Thompson */ 237e55e1ebcSAndrew Thompson device_printf(sc->sc_bus.bdev, "stop timeout\n"); 23802ac6454SAndrew Thompson 239e55e1ebcSAndrew Thompson return ehci_reset(sc); 24002ac6454SAndrew Thompson } 24102ac6454SAndrew Thompson 242e0a69b51SAndrew Thompson usb_error_t 24302ac6454SAndrew Thompson ehci_init(ehci_softc_t *sc) 24402ac6454SAndrew Thompson { 245760bc48eSAndrew Thompson struct usb_page_search buf_res; 24602ac6454SAndrew Thompson uint32_t version; 24702ac6454SAndrew Thompson uint32_t sparams; 24802ac6454SAndrew Thompson uint32_t cparams; 24902ac6454SAndrew Thompson uint32_t hcr; 25002ac6454SAndrew Thompson uint16_t i; 25102ac6454SAndrew Thompson uint16_t x; 25202ac6454SAndrew Thompson uint16_t y; 25302ac6454SAndrew Thompson uint16_t bit; 254e0a69b51SAndrew Thompson usb_error_t err = 0; 25502ac6454SAndrew Thompson 25602ac6454SAndrew Thompson DPRINTF("start\n"); 25702ac6454SAndrew Thompson 258a593f6b8SAndrew Thompson usb_callout_init_mtx(&sc->sc_tmo_pcd, &sc->sc_bus.bus_mtx, 0); 25930b22abeSAndrew Thompson usb_callout_init_mtx(&sc->sc_tmo_poll, &sc->sc_bus.bus_mtx, 0); 26002ac6454SAndrew Thompson 261b850ecc1SAndrew Thompson #ifdef USB_DEBUG 262cf223a88SAndrew Thompson if (ehciiaadbug) 263cf223a88SAndrew Thompson sc->sc_flags |= EHCI_SCFLG_IAADBUG; 264cf223a88SAndrew Thompson if (ehcilostintrbug) 265cf223a88SAndrew Thompson sc->sc_flags |= EHCI_SCFLG_LOSTINTRBUG; 26602ac6454SAndrew Thompson if (ehcidebug > 2) { 26702ac6454SAndrew Thompson ehci_dump_regs(sc); 26802ac6454SAndrew Thompson } 26902ac6454SAndrew Thompson #endif 27002ac6454SAndrew Thompson 27102ac6454SAndrew Thompson sc->sc_offs = EREAD1(sc, EHCI_CAPLENGTH); 27202ac6454SAndrew Thompson 27302ac6454SAndrew Thompson version = EREAD2(sc, EHCI_HCIVERSION); 27402ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "EHCI version %x.%x\n", 27502ac6454SAndrew Thompson version >> 8, version & 0xff); 27602ac6454SAndrew Thompson 27702ac6454SAndrew Thompson sparams = EREAD4(sc, EHCI_HCSPARAMS); 27802ac6454SAndrew Thompson DPRINTF("sparams=0x%x\n", sparams); 27902ac6454SAndrew Thompson 28002ac6454SAndrew Thompson sc->sc_noport = EHCI_HCS_N_PORTS(sparams); 28102ac6454SAndrew Thompson cparams = EREAD4(sc, EHCI_HCCPARAMS); 28202ac6454SAndrew Thompson DPRINTF("cparams=0x%x\n", cparams); 28302ac6454SAndrew Thompson 28402ac6454SAndrew Thompson if (EHCI_HCC_64BIT(cparams)) { 28502ac6454SAndrew Thompson DPRINTF("HCC uses 64-bit structures\n"); 28602ac6454SAndrew Thompson 28702ac6454SAndrew Thompson /* MUST clear segment register if 64 bit capable */ 28802ac6454SAndrew Thompson EWRITE4(sc, EHCI_CTRLDSSEGMENT, 0); 28902ac6454SAndrew Thompson } 29002ac6454SAndrew Thompson sc->sc_bus.usbrev = USB_REV_2_0; 29102ac6454SAndrew Thompson 29202ac6454SAndrew Thompson /* Reset the controller */ 29302ac6454SAndrew Thompson DPRINTF("%s: resetting\n", device_get_nameunit(sc->sc_bus.bdev)); 29402ac6454SAndrew Thompson 295e55e1ebcSAndrew Thompson err = ehci_hcreset(sc); 29602ac6454SAndrew Thompson if (err) { 29702ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "reset timeout\n"); 29802ac6454SAndrew Thompson return (err); 29902ac6454SAndrew Thompson } 30002ac6454SAndrew Thompson /* 30102ac6454SAndrew Thompson * use current frame-list-size selection 0: 1024*4 bytes 1: 512*4 30202ac6454SAndrew Thompson * bytes 2: 256*4 bytes 3: unknown 30302ac6454SAndrew Thompson */ 30402ac6454SAndrew Thompson if (EHCI_CMD_FLS(EOREAD4(sc, EHCI_USBCMD)) == 3) { 30502ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "invalid frame-list-size\n"); 30602ac6454SAndrew Thompson return (USB_ERR_IOERROR); 30702ac6454SAndrew Thompson } 30802ac6454SAndrew Thompson /* set up the bus struct */ 30902ac6454SAndrew Thompson sc->sc_bus.methods = &ehci_bus_methods; 31002ac6454SAndrew Thompson 31102ac6454SAndrew Thompson sc->sc_eintrs = EHCI_NORMAL_INTRS; 31202ac6454SAndrew Thompson 31302ac6454SAndrew Thompson for (i = 0; i < EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { 31402ac6454SAndrew Thompson ehci_qh_t *qh; 31502ac6454SAndrew Thompson 316a593f6b8SAndrew Thompson usbd_get_page(sc->sc_hw.intr_start_pc + i, 0, &buf_res); 31702ac6454SAndrew Thompson 31802ac6454SAndrew Thompson qh = buf_res.buffer; 31902ac6454SAndrew Thompson 32002ac6454SAndrew Thompson /* initialize page cache pointer */ 32102ac6454SAndrew Thompson 32202ac6454SAndrew Thompson qh->page_cache = sc->sc_hw.intr_start_pc + i; 32302ac6454SAndrew Thompson 32402ac6454SAndrew Thompson /* store a pointer to queue head */ 32502ac6454SAndrew Thompson 32602ac6454SAndrew Thompson sc->sc_intr_p_last[i] = qh; 32702ac6454SAndrew Thompson 32802ac6454SAndrew Thompson qh->qh_self = 329e55e1ebcSAndrew Thompson htohc32(sc, buf_res.physaddr) | 330e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_QH); 33102ac6454SAndrew Thompson 33202ac6454SAndrew Thompson qh->qh_endp = 333e55e1ebcSAndrew Thompson htohc32(sc, EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH)); 33402ac6454SAndrew Thompson qh->qh_endphub = 335e55e1ebcSAndrew Thompson htohc32(sc, EHCI_QH_SET_MULT(1)); 33602ac6454SAndrew Thompson qh->qh_curqtd = 0; 33702ac6454SAndrew Thompson 33802ac6454SAndrew Thompson qh->qh_qtd.qtd_next = 339e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_TERMINATE); 34002ac6454SAndrew Thompson qh->qh_qtd.qtd_altnext = 341e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_TERMINATE); 34202ac6454SAndrew Thompson qh->qh_qtd.qtd_status = 343e55e1ebcSAndrew Thompson htohc32(sc, EHCI_QTD_HALTED); 34402ac6454SAndrew Thompson } 34502ac6454SAndrew Thompson 34602ac6454SAndrew Thompson /* 34702ac6454SAndrew Thompson * the QHs are arranged to give poll intervals that are 34802ac6454SAndrew Thompson * powers of 2 times 1ms 34902ac6454SAndrew Thompson */ 35002ac6454SAndrew Thompson bit = EHCI_VIRTUAL_FRAMELIST_COUNT / 2; 35102ac6454SAndrew Thompson while (bit) { 35202ac6454SAndrew Thompson x = bit; 35302ac6454SAndrew Thompson while (x & bit) { 35402ac6454SAndrew Thompson ehci_qh_t *qh_x; 35502ac6454SAndrew Thompson ehci_qh_t *qh_y; 35602ac6454SAndrew Thompson 35702ac6454SAndrew Thompson y = (x ^ bit) | (bit / 2); 35802ac6454SAndrew Thompson 35902ac6454SAndrew Thompson qh_x = sc->sc_intr_p_last[x]; 36002ac6454SAndrew Thompson qh_y = sc->sc_intr_p_last[y]; 36102ac6454SAndrew Thompson 36202ac6454SAndrew Thompson /* 36302ac6454SAndrew Thompson * the next QH has half the poll interval 36402ac6454SAndrew Thompson */ 36502ac6454SAndrew Thompson qh_x->qh_link = qh_y->qh_self; 36602ac6454SAndrew Thompson 36702ac6454SAndrew Thompson x++; 36802ac6454SAndrew Thompson } 36902ac6454SAndrew Thompson bit >>= 1; 37002ac6454SAndrew Thompson } 37102ac6454SAndrew Thompson 37202ac6454SAndrew Thompson if (1) { 37302ac6454SAndrew Thompson ehci_qh_t *qh; 37402ac6454SAndrew Thompson 37502ac6454SAndrew Thompson qh = sc->sc_intr_p_last[0]; 37602ac6454SAndrew Thompson 37702ac6454SAndrew Thompson /* the last (1ms) QH terminates */ 378e55e1ebcSAndrew Thompson qh->qh_link = htohc32(sc, EHCI_LINK_TERMINATE); 37902ac6454SAndrew Thompson } 38002ac6454SAndrew Thompson for (i = 0; i < EHCI_VIRTUAL_FRAMELIST_COUNT; i++) { 38102ac6454SAndrew Thompson ehci_sitd_t *sitd; 38202ac6454SAndrew Thompson ehci_itd_t *itd; 38302ac6454SAndrew Thompson 384a593f6b8SAndrew Thompson usbd_get_page(sc->sc_hw.isoc_fs_start_pc + i, 0, &buf_res); 38502ac6454SAndrew Thompson 38602ac6454SAndrew Thompson sitd = buf_res.buffer; 38702ac6454SAndrew Thompson 38802ac6454SAndrew Thompson /* initialize page cache pointer */ 38902ac6454SAndrew Thompson 39002ac6454SAndrew Thompson sitd->page_cache = sc->sc_hw.isoc_fs_start_pc + i; 39102ac6454SAndrew Thompson 39202ac6454SAndrew Thompson /* store a pointer to the transfer descriptor */ 39302ac6454SAndrew Thompson 39402ac6454SAndrew Thompson sc->sc_isoc_fs_p_last[i] = sitd; 39502ac6454SAndrew Thompson 39602ac6454SAndrew Thompson /* initialize full speed isochronous */ 39702ac6454SAndrew Thompson 39802ac6454SAndrew Thompson sitd->sitd_self = 399e55e1ebcSAndrew Thompson htohc32(sc, buf_res.physaddr) | 400e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_SITD); 40102ac6454SAndrew Thompson 40202ac6454SAndrew Thompson sitd->sitd_back = 403e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_TERMINATE); 40402ac6454SAndrew Thompson 40502ac6454SAndrew Thompson sitd->sitd_next = 40602ac6454SAndrew Thompson sc->sc_intr_p_last[i | (EHCI_VIRTUAL_FRAMELIST_COUNT / 2)]->qh_self; 40702ac6454SAndrew Thompson 40802ac6454SAndrew Thompson 409a593f6b8SAndrew Thompson usbd_get_page(sc->sc_hw.isoc_hs_start_pc + i, 0, &buf_res); 41002ac6454SAndrew Thompson 41102ac6454SAndrew Thompson itd = buf_res.buffer; 41202ac6454SAndrew Thompson 41302ac6454SAndrew Thompson /* initialize page cache pointer */ 41402ac6454SAndrew Thompson 41502ac6454SAndrew Thompson itd->page_cache = sc->sc_hw.isoc_hs_start_pc + i; 41602ac6454SAndrew Thompson 41702ac6454SAndrew Thompson /* store a pointer to the transfer descriptor */ 41802ac6454SAndrew Thompson 41902ac6454SAndrew Thompson sc->sc_isoc_hs_p_last[i] = itd; 42002ac6454SAndrew Thompson 42102ac6454SAndrew Thompson /* initialize high speed isochronous */ 42202ac6454SAndrew Thompson 42302ac6454SAndrew Thompson itd->itd_self = 424e55e1ebcSAndrew Thompson htohc32(sc, buf_res.physaddr) | 425e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_ITD); 42602ac6454SAndrew Thompson 42702ac6454SAndrew Thompson itd->itd_next = 42802ac6454SAndrew Thompson sitd->sitd_self; 42902ac6454SAndrew Thompson } 43002ac6454SAndrew Thompson 431a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); 43202ac6454SAndrew Thompson 43302ac6454SAndrew Thompson if (1) { 43402ac6454SAndrew Thompson uint32_t *pframes; 43502ac6454SAndrew Thompson 43602ac6454SAndrew Thompson pframes = buf_res.buffer; 43702ac6454SAndrew Thompson 43802ac6454SAndrew Thompson /* 43902ac6454SAndrew Thompson * execution order: 44002ac6454SAndrew Thompson * pframes -> high speed isochronous -> 44102ac6454SAndrew Thompson * full speed isochronous -> interrupt QH's 44202ac6454SAndrew Thompson */ 44302ac6454SAndrew Thompson for (i = 0; i < EHCI_FRAMELIST_COUNT; i++) { 44402ac6454SAndrew Thompson pframes[i] = sc->sc_isoc_hs_p_last 44502ac6454SAndrew Thompson [i & (EHCI_VIRTUAL_FRAMELIST_COUNT - 1)]->itd_self; 44602ac6454SAndrew Thompson } 44702ac6454SAndrew Thompson } 44802ac6454SAndrew Thompson /* setup sync list pointer */ 44902ac6454SAndrew Thompson EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr); 45002ac6454SAndrew Thompson 451a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); 45202ac6454SAndrew Thompson 45302ac6454SAndrew Thompson if (1) { 45402ac6454SAndrew Thompson 45502ac6454SAndrew Thompson ehci_qh_t *qh; 45602ac6454SAndrew Thompson 45702ac6454SAndrew Thompson qh = buf_res.buffer; 45802ac6454SAndrew Thompson 45902ac6454SAndrew Thompson /* initialize page cache pointer */ 46002ac6454SAndrew Thompson 46102ac6454SAndrew Thompson qh->page_cache = &sc->sc_hw.async_start_pc; 46202ac6454SAndrew Thompson 46302ac6454SAndrew Thompson /* store a pointer to the queue head */ 46402ac6454SAndrew Thompson 46502ac6454SAndrew Thompson sc->sc_async_p_last = qh; 46602ac6454SAndrew Thompson 46702ac6454SAndrew Thompson /* init dummy QH that starts the async list */ 46802ac6454SAndrew Thompson 46902ac6454SAndrew Thompson qh->qh_self = 470e55e1ebcSAndrew Thompson htohc32(sc, buf_res.physaddr) | 471e55e1ebcSAndrew Thompson htohc32(sc, EHCI_LINK_QH); 47202ac6454SAndrew Thompson 47302ac6454SAndrew Thompson /* fill the QH */ 47402ac6454SAndrew Thompson qh->qh_endp = 475e55e1ebcSAndrew Thompson htohc32(sc, EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH) | EHCI_QH_HRECL); 476e55e1ebcSAndrew Thompson qh->qh_endphub = htohc32(sc, EHCI_QH_SET_MULT(1)); 47702ac6454SAndrew Thompson qh->qh_link = qh->qh_self; 47802ac6454SAndrew Thompson qh->qh_curqtd = 0; 47902ac6454SAndrew Thompson 48002ac6454SAndrew Thompson /* fill the overlay qTD */ 481e55e1ebcSAndrew Thompson qh->qh_qtd.qtd_next = htohc32(sc, EHCI_LINK_TERMINATE); 482e55e1ebcSAndrew Thompson qh->qh_qtd.qtd_altnext = htohc32(sc, EHCI_LINK_TERMINATE); 483e55e1ebcSAndrew Thompson qh->qh_qtd.qtd_status = htohc32(sc, EHCI_QTD_HALTED); 48402ac6454SAndrew Thompson } 48502ac6454SAndrew Thompson /* flush all cache into memory */ 48602ac6454SAndrew Thompson 487a593f6b8SAndrew Thompson usb_bus_mem_flush_all(&sc->sc_bus, &ehci_iterate_hw_softc); 48802ac6454SAndrew Thompson 489b850ecc1SAndrew Thompson #ifdef USB_DEBUG 49002ac6454SAndrew Thompson if (ehcidebug) { 49102ac6454SAndrew Thompson ehci_dump_sqh(sc, sc->sc_async_p_last); 49202ac6454SAndrew Thompson } 49302ac6454SAndrew Thompson #endif 49402ac6454SAndrew Thompson 49502ac6454SAndrew Thompson /* setup async list pointer */ 49602ac6454SAndrew Thompson EOWRITE4(sc, EHCI_ASYNCLISTADDR, buf_res.physaddr | EHCI_LINK_QH); 49702ac6454SAndrew Thompson 49802ac6454SAndrew Thompson 49902ac6454SAndrew Thompson /* enable interrupts */ 50002ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); 50102ac6454SAndrew Thompson 50202ac6454SAndrew Thompson /* turn on controller */ 50302ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, 50402ac6454SAndrew Thompson EHCI_CMD_ITC_1 | /* 1 microframes interrupt delay */ 50502ac6454SAndrew Thompson (EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_FLS_M) | 50602ac6454SAndrew Thompson EHCI_CMD_ASE | 50702ac6454SAndrew Thompson EHCI_CMD_PSE | 50802ac6454SAndrew Thompson EHCI_CMD_RS); 50902ac6454SAndrew Thompson 51002ac6454SAndrew Thompson /* Take over port ownership */ 51102ac6454SAndrew Thompson EOWRITE4(sc, EHCI_CONFIGFLAG, EHCI_CONF_CF); 51202ac6454SAndrew Thompson 51302ac6454SAndrew Thompson for (i = 0; i < 100; i++) { 514a593f6b8SAndrew Thompson usb_pause_mtx(NULL, hz / 1000); 51502ac6454SAndrew Thompson hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; 51602ac6454SAndrew Thompson if (!hcr) { 51702ac6454SAndrew Thompson break; 51802ac6454SAndrew Thompson } 51902ac6454SAndrew Thompson } 52002ac6454SAndrew Thompson if (hcr) { 52102ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "run timeout\n"); 52202ac6454SAndrew Thompson return (USB_ERR_IOERROR); 52302ac6454SAndrew Thompson } 52402ac6454SAndrew Thompson 52502ac6454SAndrew Thompson if (!err) { 52602ac6454SAndrew Thompson /* catch any lost interrupts */ 52702ac6454SAndrew Thompson ehci_do_poll(&sc->sc_bus); 52802ac6454SAndrew Thompson } 52902ac6454SAndrew Thompson return (err); 53002ac6454SAndrew Thompson } 53102ac6454SAndrew Thompson 53202ac6454SAndrew Thompson /* 53302ac6454SAndrew Thompson * shut down the controller when the system is going down 53402ac6454SAndrew Thompson */ 53502ac6454SAndrew Thompson void 53602ac6454SAndrew Thompson ehci_detach(ehci_softc_t *sc) 53702ac6454SAndrew Thompson { 53802ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 53902ac6454SAndrew Thompson 540a593f6b8SAndrew Thompson usb_callout_stop(&sc->sc_tmo_pcd); 54130b22abeSAndrew Thompson usb_callout_stop(&sc->sc_tmo_poll); 54202ac6454SAndrew Thompson 543bda9babeSAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, 0); 544e55e1ebcSAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 54502ac6454SAndrew Thompson 546e55e1ebcSAndrew Thompson if (ehci_hcreset(sc)) { 54702ac6454SAndrew Thompson DPRINTF("reset failed!\n"); 54802ac6454SAndrew Thompson } 54902ac6454SAndrew Thompson 55002ac6454SAndrew Thompson /* XXX let stray task complete */ 551a593f6b8SAndrew Thompson usb_pause_mtx(NULL, hz / 20); 55202ac6454SAndrew Thompson 553a593f6b8SAndrew Thompson usb_callout_drain(&sc->sc_tmo_pcd); 55430b22abeSAndrew Thompson usb_callout_drain(&sc->sc_tmo_poll); 55502ac6454SAndrew Thompson } 55602ac6454SAndrew Thompson 55702ac6454SAndrew Thompson void 55802ac6454SAndrew Thompson ehci_suspend(ehci_softc_t *sc) 55902ac6454SAndrew Thompson { 56002ac6454SAndrew Thompson uint32_t cmd; 56102ac6454SAndrew Thompson uint32_t hcr; 56202ac6454SAndrew Thompson uint8_t i; 56302ac6454SAndrew Thompson 56402ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 56502ac6454SAndrew Thompson 56602ac6454SAndrew Thompson for (i = 1; i <= sc->sc_noport; i++) { 56702ac6454SAndrew Thompson cmd = EOREAD4(sc, EHCI_PORTSC(i)); 56802ac6454SAndrew Thompson if (((cmd & EHCI_PS_PO) == 0) && 56902ac6454SAndrew Thompson ((cmd & EHCI_PS_PE) == EHCI_PS_PE)) { 57002ac6454SAndrew Thompson EOWRITE4(sc, EHCI_PORTSC(i), 57102ac6454SAndrew Thompson cmd | EHCI_PS_SUSP); 57202ac6454SAndrew Thompson } 57302ac6454SAndrew Thompson } 57402ac6454SAndrew Thompson 57502ac6454SAndrew Thompson sc->sc_cmd = EOREAD4(sc, EHCI_USBCMD); 57602ac6454SAndrew Thompson 57702ac6454SAndrew Thompson cmd = sc->sc_cmd & ~(EHCI_CMD_ASE | EHCI_CMD_PSE); 57802ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, cmd); 57902ac6454SAndrew Thompson 58002ac6454SAndrew Thompson for (i = 0; i < 100; i++) { 58102ac6454SAndrew Thompson hcr = EOREAD4(sc, EHCI_USBSTS) & 58202ac6454SAndrew Thompson (EHCI_STS_ASS | EHCI_STS_PSS); 58302ac6454SAndrew Thompson 58402ac6454SAndrew Thompson if (hcr == 0) { 58502ac6454SAndrew Thompson break; 58602ac6454SAndrew Thompson } 587a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); 58802ac6454SAndrew Thompson } 58902ac6454SAndrew Thompson 59002ac6454SAndrew Thompson if (hcr != 0) { 59102ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "reset timeout\n"); 59202ac6454SAndrew Thompson } 59302ac6454SAndrew Thompson cmd &= ~EHCI_CMD_RS; 59402ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, cmd); 59502ac6454SAndrew Thompson 59602ac6454SAndrew Thompson for (i = 0; i < 100; i++) { 59702ac6454SAndrew Thompson hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; 59802ac6454SAndrew Thompson if (hcr == EHCI_STS_HCH) { 59902ac6454SAndrew Thompson break; 60002ac6454SAndrew Thompson } 601a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); 60202ac6454SAndrew Thompson } 60302ac6454SAndrew Thompson 60402ac6454SAndrew Thompson if (hcr != EHCI_STS_HCH) { 60502ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, 60602ac6454SAndrew Thompson "config timeout\n"); 60702ac6454SAndrew Thompson } 60802ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 60902ac6454SAndrew Thompson } 61002ac6454SAndrew Thompson 61102ac6454SAndrew Thompson void 61202ac6454SAndrew Thompson ehci_resume(ehci_softc_t *sc) 61302ac6454SAndrew Thompson { 614760bc48eSAndrew Thompson struct usb_page_search buf_res; 61502ac6454SAndrew Thompson uint32_t cmd; 61602ac6454SAndrew Thompson uint32_t hcr; 61702ac6454SAndrew Thompson uint8_t i; 61802ac6454SAndrew Thompson 61902ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 62002ac6454SAndrew Thompson 62102ac6454SAndrew Thompson /* restore things in case the bios doesn't */ 62202ac6454SAndrew Thompson EOWRITE4(sc, EHCI_CTRLDSSEGMENT, 0); 62302ac6454SAndrew Thompson 624a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.pframes_pc, 0, &buf_res); 62502ac6454SAndrew Thompson EOWRITE4(sc, EHCI_PERIODICLISTBASE, buf_res.physaddr); 62602ac6454SAndrew Thompson 627a593f6b8SAndrew Thompson usbd_get_page(&sc->sc_hw.async_start_pc, 0, &buf_res); 62802ac6454SAndrew Thompson EOWRITE4(sc, EHCI_ASYNCLISTADDR, buf_res.physaddr | EHCI_LINK_QH); 62902ac6454SAndrew Thompson 63002ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); 63102ac6454SAndrew Thompson 63202ac6454SAndrew Thompson hcr = 0; 63302ac6454SAndrew Thompson for (i = 1; i <= sc->sc_noport; i++) { 63402ac6454SAndrew Thompson cmd = EOREAD4(sc, EHCI_PORTSC(i)); 63502ac6454SAndrew Thompson if (((cmd & EHCI_PS_PO) == 0) && 63602ac6454SAndrew Thompson ((cmd & EHCI_PS_SUSP) == EHCI_PS_SUSP)) { 63702ac6454SAndrew Thompson EOWRITE4(sc, EHCI_PORTSC(i), 63802ac6454SAndrew Thompson cmd | EHCI_PS_FPR); 63902ac6454SAndrew Thompson hcr = 1; 64002ac6454SAndrew Thompson } 64102ac6454SAndrew Thompson } 64202ac6454SAndrew Thompson 64302ac6454SAndrew Thompson if (hcr) { 644a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 64502ac6454SAndrew Thompson USB_MS_TO_TICKS(USB_RESUME_WAIT)); 64602ac6454SAndrew Thompson 64702ac6454SAndrew Thompson for (i = 1; i <= sc->sc_noport; i++) { 64802ac6454SAndrew Thompson cmd = EOREAD4(sc, EHCI_PORTSC(i)); 64902ac6454SAndrew Thompson if (((cmd & EHCI_PS_PO) == 0) && 65002ac6454SAndrew Thompson ((cmd & EHCI_PS_SUSP) == EHCI_PS_SUSP)) { 65102ac6454SAndrew Thompson EOWRITE4(sc, EHCI_PORTSC(i), 65202ac6454SAndrew Thompson cmd & ~EHCI_PS_FPR); 65302ac6454SAndrew Thompson } 65402ac6454SAndrew Thompson } 65502ac6454SAndrew Thompson } 65602ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, sc->sc_cmd); 65702ac6454SAndrew Thompson 65802ac6454SAndrew Thompson for (i = 0; i < 100; i++) { 65902ac6454SAndrew Thompson hcr = EOREAD4(sc, EHCI_USBSTS) & EHCI_STS_HCH; 66002ac6454SAndrew Thompson if (hcr != EHCI_STS_HCH) { 66102ac6454SAndrew Thompson break; 66202ac6454SAndrew Thompson } 663a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 1000); 66402ac6454SAndrew Thompson } 66502ac6454SAndrew Thompson if (hcr == EHCI_STS_HCH) { 66602ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, "config timeout\n"); 66702ac6454SAndrew Thompson } 66802ac6454SAndrew Thompson 66902ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 67002ac6454SAndrew Thompson 671a593f6b8SAndrew Thompson usb_pause_mtx(NULL, 67202ac6454SAndrew Thompson USB_MS_TO_TICKS(USB_RESUME_WAIT)); 67302ac6454SAndrew Thompson 67402ac6454SAndrew Thompson /* catch any lost interrupts */ 67502ac6454SAndrew Thompson ehci_do_poll(&sc->sc_bus); 67602ac6454SAndrew Thompson } 67702ac6454SAndrew Thompson 67802ac6454SAndrew Thompson void 67902ac6454SAndrew Thompson ehci_shutdown(ehci_softc_t *sc) 68002ac6454SAndrew Thompson { 68102ac6454SAndrew Thompson DPRINTF("stopping the HC\n"); 68202ac6454SAndrew Thompson 683e55e1ebcSAndrew Thompson if (ehci_hcreset(sc)) { 68402ac6454SAndrew Thompson DPRINTF("reset failed!\n"); 68502ac6454SAndrew Thompson } 68602ac6454SAndrew Thompson } 68702ac6454SAndrew Thompson 688b850ecc1SAndrew Thompson #ifdef USB_DEBUG 68902ac6454SAndrew Thompson static void 69002ac6454SAndrew Thompson ehci_dump_regs(ehci_softc_t *sc) 69102ac6454SAndrew Thompson { 69202ac6454SAndrew Thompson uint32_t i; 69302ac6454SAndrew Thompson 69402ac6454SAndrew Thompson i = EOREAD4(sc, EHCI_USBCMD); 69502ac6454SAndrew Thompson printf("cmd=0x%08x\n", i); 69602ac6454SAndrew Thompson 69702ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_1) 69802ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_1\n"); 69902ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_2) 70002ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_2\n"); 70102ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_4) 70202ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_4\n"); 70302ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_8) 70402ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_8\n"); 70502ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_16) 70602ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_16\n"); 70702ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_32) 70802ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_32\n"); 70902ac6454SAndrew Thompson if (i & EHCI_CMD_ITC_64) 71002ac6454SAndrew Thompson printf(" EHCI_CMD_ITC_64\n"); 71102ac6454SAndrew Thompson if (i & EHCI_CMD_ASPME) 71202ac6454SAndrew Thompson printf(" EHCI_CMD_ASPME\n"); 71302ac6454SAndrew Thompson if (i & EHCI_CMD_ASPMC) 71402ac6454SAndrew Thompson printf(" EHCI_CMD_ASPMC\n"); 71502ac6454SAndrew Thompson if (i & EHCI_CMD_LHCR) 71602ac6454SAndrew Thompson printf(" EHCI_CMD_LHCR\n"); 71702ac6454SAndrew Thompson if (i & EHCI_CMD_IAAD) 71802ac6454SAndrew Thompson printf(" EHCI_CMD_IAAD\n"); 71902ac6454SAndrew Thompson if (i & EHCI_CMD_ASE) 72002ac6454SAndrew Thompson printf(" EHCI_CMD_ASE\n"); 72102ac6454SAndrew Thompson if (i & EHCI_CMD_PSE) 72202ac6454SAndrew Thompson printf(" EHCI_CMD_PSE\n"); 72302ac6454SAndrew Thompson if (i & EHCI_CMD_FLS_M) 72402ac6454SAndrew Thompson printf(" EHCI_CMD_FLS_M\n"); 72502ac6454SAndrew Thompson if (i & EHCI_CMD_HCRESET) 72602ac6454SAndrew Thompson printf(" EHCI_CMD_HCRESET\n"); 72702ac6454SAndrew Thompson if (i & EHCI_CMD_RS) 72802ac6454SAndrew Thompson printf(" EHCI_CMD_RS\n"); 72902ac6454SAndrew Thompson 73002ac6454SAndrew Thompson i = EOREAD4(sc, EHCI_USBSTS); 73102ac6454SAndrew Thompson 73202ac6454SAndrew Thompson printf("sts=0x%08x\n", i); 73302ac6454SAndrew Thompson 73402ac6454SAndrew Thompson if (i & EHCI_STS_ASS) 73502ac6454SAndrew Thompson printf(" EHCI_STS_ASS\n"); 73602ac6454SAndrew Thompson if (i & EHCI_STS_PSS) 73702ac6454SAndrew Thompson printf(" EHCI_STS_PSS\n"); 73802ac6454SAndrew Thompson if (i & EHCI_STS_REC) 73902ac6454SAndrew Thompson printf(" EHCI_STS_REC\n"); 74002ac6454SAndrew Thompson if (i & EHCI_STS_HCH) 74102ac6454SAndrew Thompson printf(" EHCI_STS_HCH\n"); 74202ac6454SAndrew Thompson if (i & EHCI_STS_IAA) 74302ac6454SAndrew Thompson printf(" EHCI_STS_IAA\n"); 74402ac6454SAndrew Thompson if (i & EHCI_STS_HSE) 74502ac6454SAndrew Thompson printf(" EHCI_STS_HSE\n"); 74602ac6454SAndrew Thompson if (i & EHCI_STS_FLR) 74702ac6454SAndrew Thompson printf(" EHCI_STS_FLR\n"); 74802ac6454SAndrew Thompson if (i & EHCI_STS_PCD) 74902ac6454SAndrew Thompson printf(" EHCI_STS_PCD\n"); 75002ac6454SAndrew Thompson if (i & EHCI_STS_ERRINT) 75102ac6454SAndrew Thompson printf(" EHCI_STS_ERRINT\n"); 75202ac6454SAndrew Thompson if (i & EHCI_STS_INT) 75302ac6454SAndrew Thompson printf(" EHCI_STS_INT\n"); 75402ac6454SAndrew Thompson 75502ac6454SAndrew Thompson printf("ien=0x%08x\n", 75602ac6454SAndrew Thompson EOREAD4(sc, EHCI_USBINTR)); 75702ac6454SAndrew Thompson printf("frindex=0x%08x ctrdsegm=0x%08x periodic=0x%08x async=0x%08x\n", 75802ac6454SAndrew Thompson EOREAD4(sc, EHCI_FRINDEX), 75902ac6454SAndrew Thompson EOREAD4(sc, EHCI_CTRLDSSEGMENT), 76002ac6454SAndrew Thompson EOREAD4(sc, EHCI_PERIODICLISTBASE), 76102ac6454SAndrew Thompson EOREAD4(sc, EHCI_ASYNCLISTADDR)); 76202ac6454SAndrew Thompson for (i = 1; i <= sc->sc_noport; i++) { 76302ac6454SAndrew Thompson printf("port %d status=0x%08x\n", i, 76402ac6454SAndrew Thompson EOREAD4(sc, EHCI_PORTSC(i))); 76502ac6454SAndrew Thompson } 76602ac6454SAndrew Thompson } 76702ac6454SAndrew Thompson 76802ac6454SAndrew Thompson static void 76902ac6454SAndrew Thompson ehci_dump_link(ehci_softc_t *sc, uint32_t link, int type) 77002ac6454SAndrew Thompson { 771e55e1ebcSAndrew Thompson link = hc32toh(sc, link); 77202ac6454SAndrew Thompson printf("0x%08x", link); 77302ac6454SAndrew Thompson if (link & EHCI_LINK_TERMINATE) 77402ac6454SAndrew Thompson printf("<T>"); 77502ac6454SAndrew Thompson else { 77602ac6454SAndrew Thompson printf("<"); 77702ac6454SAndrew Thompson if (type) { 77802ac6454SAndrew Thompson switch (EHCI_LINK_TYPE(link)) { 77902ac6454SAndrew Thompson case EHCI_LINK_ITD: 78002ac6454SAndrew Thompson printf("ITD"); 78102ac6454SAndrew Thompson break; 78202ac6454SAndrew Thompson case EHCI_LINK_QH: 78302ac6454SAndrew Thompson printf("QH"); 78402ac6454SAndrew Thompson break; 78502ac6454SAndrew Thompson case EHCI_LINK_SITD: 78602ac6454SAndrew Thompson printf("SITD"); 78702ac6454SAndrew Thompson break; 78802ac6454SAndrew Thompson case EHCI_LINK_FSTN: 78902ac6454SAndrew Thompson printf("FSTN"); 79002ac6454SAndrew Thompson break; 79102ac6454SAndrew Thompson } 79202ac6454SAndrew Thompson } 79302ac6454SAndrew Thompson printf(">"); 79402ac6454SAndrew Thompson } 79502ac6454SAndrew Thompson } 79602ac6454SAndrew Thompson 79702ac6454SAndrew Thompson static void 79802ac6454SAndrew Thompson ehci_dump_qtd(ehci_softc_t *sc, ehci_qtd_t *qtd) 79902ac6454SAndrew Thompson { 80002ac6454SAndrew Thompson uint32_t s; 80102ac6454SAndrew Thompson 80202ac6454SAndrew Thompson printf(" next="); 80302ac6454SAndrew Thompson ehci_dump_link(sc, qtd->qtd_next, 0); 80402ac6454SAndrew Thompson printf(" altnext="); 80502ac6454SAndrew Thompson ehci_dump_link(sc, qtd->qtd_altnext, 0); 80602ac6454SAndrew Thompson printf("\n"); 807e55e1ebcSAndrew Thompson s = hc32toh(sc, qtd->qtd_status); 80802ac6454SAndrew Thompson printf(" status=0x%08x: toggle=%d bytes=0x%x ioc=%d c_page=0x%x\n", 80902ac6454SAndrew Thompson s, EHCI_QTD_GET_TOGGLE(s), EHCI_QTD_GET_BYTES(s), 81002ac6454SAndrew Thompson EHCI_QTD_GET_IOC(s), EHCI_QTD_GET_C_PAGE(s)); 81102ac6454SAndrew Thompson printf(" cerr=%d pid=%d stat=%s%s%s%s%s%s%s%s\n", 81202ac6454SAndrew Thompson EHCI_QTD_GET_CERR(s), EHCI_QTD_GET_PID(s), 81302ac6454SAndrew Thompson (s & EHCI_QTD_ACTIVE) ? "ACTIVE" : "NOT_ACTIVE", 81402ac6454SAndrew Thompson (s & EHCI_QTD_HALTED) ? "-HALTED" : "", 81502ac6454SAndrew Thompson (s & EHCI_QTD_BUFERR) ? "-BUFERR" : "", 81602ac6454SAndrew Thompson (s & EHCI_QTD_BABBLE) ? "-BABBLE" : "", 81702ac6454SAndrew Thompson (s & EHCI_QTD_XACTERR) ? "-XACTERR" : "", 81802ac6454SAndrew Thompson (s & EHCI_QTD_MISSEDMICRO) ? "-MISSED" : "", 81902ac6454SAndrew Thompson (s & EHCI_QTD_SPLITXSTATE) ? "-SPLIT" : "", 82002ac6454SAndrew Thompson (s & EHCI_QTD_PINGSTATE) ? "-PING" : ""); 82102ac6454SAndrew Thompson 82202ac6454SAndrew Thompson for (s = 0; s < 5; s++) { 82302ac6454SAndrew Thompson printf(" buffer[%d]=0x%08x\n", s, 824e55e1ebcSAndrew Thompson hc32toh(sc, qtd->qtd_buffer[s])); 82502ac6454SAndrew Thompson } 82602ac6454SAndrew Thompson for (s = 0; s < 5; s++) { 82702ac6454SAndrew Thompson printf(" buffer_hi[%d]=0x%08x\n", s, 828e55e1ebcSAndrew Thompson hc32toh(sc, qtd->qtd_buffer_hi[s])); 82902ac6454SAndrew Thompson } 83002ac6454SAndrew Thompson } 83102ac6454SAndrew Thompson 83202ac6454SAndrew Thompson static uint8_t 83302ac6454SAndrew Thompson ehci_dump_sqtd(ehci_softc_t *sc, ehci_qtd_t *sqtd) 83402ac6454SAndrew Thompson { 83502ac6454SAndrew Thompson uint8_t temp; 83602ac6454SAndrew Thompson 837a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(sqtd->page_cache); 838e55e1ebcSAndrew Thompson printf("QTD(%p) at 0x%08x:\n", sqtd, hc32toh(sc, sqtd->qtd_self)); 83902ac6454SAndrew Thompson ehci_dump_qtd(sc, sqtd); 840e55e1ebcSAndrew Thompson temp = (sqtd->qtd_next & htohc32(sc, EHCI_LINK_TERMINATE)) ? 1 : 0; 84102ac6454SAndrew Thompson return (temp); 84202ac6454SAndrew Thompson } 84302ac6454SAndrew Thompson 84402ac6454SAndrew Thompson static void 84502ac6454SAndrew Thompson ehci_dump_sqtds(ehci_softc_t *sc, ehci_qtd_t *sqtd) 84602ac6454SAndrew Thompson { 84702ac6454SAndrew Thompson uint16_t i; 84802ac6454SAndrew Thompson uint8_t stop; 84902ac6454SAndrew Thompson 85002ac6454SAndrew Thompson stop = 0; 85102ac6454SAndrew Thompson for (i = 0; sqtd && (i < 20) && !stop; sqtd = sqtd->obj_next, i++) { 85202ac6454SAndrew Thompson stop = ehci_dump_sqtd(sc, sqtd); 85302ac6454SAndrew Thompson } 85402ac6454SAndrew Thompson if (sqtd) { 85502ac6454SAndrew Thompson printf("dump aborted, too many TDs\n"); 85602ac6454SAndrew Thompson } 85702ac6454SAndrew Thompson } 85802ac6454SAndrew Thompson 85902ac6454SAndrew Thompson static void 86002ac6454SAndrew Thompson ehci_dump_sqh(ehci_softc_t *sc, ehci_qh_t *qh) 86102ac6454SAndrew Thompson { 86202ac6454SAndrew Thompson uint32_t endp; 86302ac6454SAndrew Thompson uint32_t endphub; 86402ac6454SAndrew Thompson 865a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(qh->page_cache); 866e55e1ebcSAndrew Thompson printf("QH(%p) at 0x%08x:\n", qh, hc32toh(sc, qh->qh_self) & ~0x1F); 86702ac6454SAndrew Thompson printf(" link="); 86802ac6454SAndrew Thompson ehci_dump_link(sc, qh->qh_link, 1); 86902ac6454SAndrew Thompson printf("\n"); 870e55e1ebcSAndrew Thompson endp = hc32toh(sc, qh->qh_endp); 87102ac6454SAndrew Thompson printf(" endp=0x%08x\n", endp); 87202ac6454SAndrew Thompson printf(" addr=0x%02x inact=%d endpt=%d eps=%d dtc=%d hrecl=%d\n", 87302ac6454SAndrew Thompson EHCI_QH_GET_ADDR(endp), EHCI_QH_GET_INACT(endp), 87402ac6454SAndrew Thompson EHCI_QH_GET_ENDPT(endp), EHCI_QH_GET_EPS(endp), 87502ac6454SAndrew Thompson EHCI_QH_GET_DTC(endp), EHCI_QH_GET_HRECL(endp)); 87602ac6454SAndrew Thompson printf(" mpl=0x%x ctl=%d nrl=%d\n", 87702ac6454SAndrew Thompson EHCI_QH_GET_MPL(endp), EHCI_QH_GET_CTL(endp), 87802ac6454SAndrew Thompson EHCI_QH_GET_NRL(endp)); 879e55e1ebcSAndrew Thompson endphub = hc32toh(sc, qh->qh_endphub); 88002ac6454SAndrew Thompson printf(" endphub=0x%08x\n", endphub); 88102ac6454SAndrew Thompson printf(" smask=0x%02x cmask=0x%02x huba=0x%02x port=%d mult=%d\n", 88202ac6454SAndrew Thompson EHCI_QH_GET_SMASK(endphub), EHCI_QH_GET_CMASK(endphub), 88302ac6454SAndrew Thompson EHCI_QH_GET_HUBA(endphub), EHCI_QH_GET_PORT(endphub), 88402ac6454SAndrew Thompson EHCI_QH_GET_MULT(endphub)); 88502ac6454SAndrew Thompson printf(" curqtd="); 88602ac6454SAndrew Thompson ehci_dump_link(sc, qh->qh_curqtd, 0); 88702ac6454SAndrew Thompson printf("\n"); 88802ac6454SAndrew Thompson printf("Overlay qTD:\n"); 88902ac6454SAndrew Thompson ehci_dump_qtd(sc, (void *)&qh->qh_qtd); 89002ac6454SAndrew Thompson } 89102ac6454SAndrew Thompson 89202ac6454SAndrew Thompson static void 89302ac6454SAndrew Thompson ehci_dump_sitd(ehci_softc_t *sc, ehci_sitd_t *sitd) 89402ac6454SAndrew Thompson { 895a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(sitd->page_cache); 896e55e1ebcSAndrew Thompson printf("SITD(%p) at 0x%08x\n", sitd, hc32toh(sc, sitd->sitd_self) & ~0x1F); 897e55e1ebcSAndrew Thompson printf(" next=0x%08x\n", hc32toh(sc, sitd->sitd_next)); 89802ac6454SAndrew Thompson printf(" portaddr=0x%08x dir=%s addr=%d endpt=0x%x port=0x%x huba=0x%x\n", 899e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_portaddr), 900e55e1ebcSAndrew Thompson (sitd->sitd_portaddr & htohc32(sc, EHCI_SITD_SET_DIR_IN)) 90102ac6454SAndrew Thompson ? "in" : "out", 902e55e1ebcSAndrew Thompson EHCI_SITD_GET_ADDR(hc32toh(sc, sitd->sitd_portaddr)), 903e55e1ebcSAndrew Thompson EHCI_SITD_GET_ENDPT(hc32toh(sc, sitd->sitd_portaddr)), 904e55e1ebcSAndrew Thompson EHCI_SITD_GET_PORT(hc32toh(sc, sitd->sitd_portaddr)), 905e55e1ebcSAndrew Thompson EHCI_SITD_GET_HUBA(hc32toh(sc, sitd->sitd_portaddr))); 906e55e1ebcSAndrew Thompson printf(" mask=0x%08x\n", hc32toh(sc, sitd->sitd_mask)); 907e55e1ebcSAndrew Thompson printf(" status=0x%08x <%s> len=0x%x\n", hc32toh(sc, sitd->sitd_status), 908e55e1ebcSAndrew Thompson (sitd->sitd_status & htohc32(sc, EHCI_SITD_ACTIVE)) ? "ACTIVE" : "", 909e55e1ebcSAndrew Thompson EHCI_SITD_GET_LEN(hc32toh(sc, sitd->sitd_status))); 91002ac6454SAndrew Thompson printf(" back=0x%08x, bp=0x%08x,0x%08x,0x%08x,0x%08x\n", 911e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_back), 912e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_bp[0]), 913e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_bp[1]), 914e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_bp_hi[0]), 915e55e1ebcSAndrew Thompson hc32toh(sc, sitd->sitd_bp_hi[1])); 91602ac6454SAndrew Thompson } 91702ac6454SAndrew Thompson 91802ac6454SAndrew Thompson static void 91902ac6454SAndrew Thompson ehci_dump_itd(ehci_softc_t *sc, ehci_itd_t *itd) 92002ac6454SAndrew Thompson { 921a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(itd->page_cache); 922e55e1ebcSAndrew Thompson printf("ITD(%p) at 0x%08x\n", itd, hc32toh(sc, itd->itd_self) & ~0x1F); 923e55e1ebcSAndrew Thompson printf(" next=0x%08x\n", hc32toh(sc, itd->itd_next)); 924e55e1ebcSAndrew Thompson printf(" status[0]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[0]), 925e55e1ebcSAndrew Thompson (itd->itd_status[0] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 926e55e1ebcSAndrew Thompson printf(" status[1]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[1]), 927e55e1ebcSAndrew Thompson (itd->itd_status[1] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 928e55e1ebcSAndrew Thompson printf(" status[2]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[2]), 929e55e1ebcSAndrew Thompson (itd->itd_status[2] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 930e55e1ebcSAndrew Thompson printf(" status[3]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[3]), 931e55e1ebcSAndrew Thompson (itd->itd_status[3] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 932e55e1ebcSAndrew Thompson printf(" status[4]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[4]), 933e55e1ebcSAndrew Thompson (itd->itd_status[4] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 934e55e1ebcSAndrew Thompson printf(" status[5]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[5]), 935e55e1ebcSAndrew Thompson (itd->itd_status[5] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 936e55e1ebcSAndrew Thompson printf(" status[6]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[6]), 937e55e1ebcSAndrew Thompson (itd->itd_status[6] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 938e55e1ebcSAndrew Thompson printf(" status[7]=0x%08x; <%s>\n", hc32toh(sc, itd->itd_status[7]), 939e55e1ebcSAndrew Thompson (itd->itd_status[7] & htohc32(sc, EHCI_ITD_ACTIVE)) ? "ACTIVE" : ""); 940e55e1ebcSAndrew Thompson printf(" bp[0]=0x%08x\n", hc32toh(sc, itd->itd_bp[0])); 94102ac6454SAndrew Thompson printf(" addr=0x%02x; endpt=0x%01x\n", 942e55e1ebcSAndrew Thompson EHCI_ITD_GET_ADDR(hc32toh(sc, itd->itd_bp[0])), 943e55e1ebcSAndrew Thompson EHCI_ITD_GET_ENDPT(hc32toh(sc, itd->itd_bp[0]))); 944e55e1ebcSAndrew Thompson printf(" bp[1]=0x%08x\n", hc32toh(sc, itd->itd_bp[1])); 94502ac6454SAndrew Thompson printf(" dir=%s; mpl=0x%02x\n", 946e55e1ebcSAndrew Thompson (hc32toh(sc, itd->itd_bp[1]) & EHCI_ITD_SET_DIR_IN) ? "in" : "out", 947e55e1ebcSAndrew Thompson EHCI_ITD_GET_MPL(hc32toh(sc, itd->itd_bp[1]))); 94802ac6454SAndrew Thompson printf(" bp[2..6]=0x%08x,0x%08x,0x%08x,0x%08x,0x%08x\n", 949e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp[2]), 950e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp[3]), 951e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp[4]), 952e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp[5]), 953e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp[6])); 95402ac6454SAndrew Thompson printf(" bp_hi=0x%08x,0x%08x,0x%08x,0x%08x,\n" 95502ac6454SAndrew Thompson " 0x%08x,0x%08x,0x%08x\n", 956e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[0]), 957e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[1]), 958e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[2]), 959e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[3]), 960e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[4]), 961e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[5]), 962e55e1ebcSAndrew Thompson hc32toh(sc, itd->itd_bp_hi[6])); 96302ac6454SAndrew Thompson } 96402ac6454SAndrew Thompson 96502ac6454SAndrew Thompson static void 96602ac6454SAndrew Thompson ehci_dump_isoc(ehci_softc_t *sc) 96702ac6454SAndrew Thompson { 96802ac6454SAndrew Thompson ehci_itd_t *itd; 96902ac6454SAndrew Thompson ehci_sitd_t *sitd; 97002ac6454SAndrew Thompson uint16_t max = 1000; 97102ac6454SAndrew Thompson uint16_t pos; 97202ac6454SAndrew Thompson 97302ac6454SAndrew Thompson pos = (EOREAD4(sc, EHCI_FRINDEX) / 8) & 97402ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 97502ac6454SAndrew Thompson 97602ac6454SAndrew Thompson printf("%s: isochronous dump from frame 0x%03x:\n", 97702ac6454SAndrew Thompson __FUNCTION__, pos); 97802ac6454SAndrew Thompson 97902ac6454SAndrew Thompson itd = sc->sc_isoc_hs_p_last[pos]; 98002ac6454SAndrew Thompson sitd = sc->sc_isoc_fs_p_last[pos]; 98102ac6454SAndrew Thompson 98202ac6454SAndrew Thompson while (itd && max && max--) { 98302ac6454SAndrew Thompson ehci_dump_itd(sc, itd); 98402ac6454SAndrew Thompson itd = itd->prev; 98502ac6454SAndrew Thompson } 98602ac6454SAndrew Thompson 98702ac6454SAndrew Thompson while (sitd && max && max--) { 98802ac6454SAndrew Thompson ehci_dump_sitd(sc, sitd); 98902ac6454SAndrew Thompson sitd = sitd->prev; 99002ac6454SAndrew Thompson } 99102ac6454SAndrew Thompson } 99202ac6454SAndrew Thompson 99302ac6454SAndrew Thompson #endif 99402ac6454SAndrew Thompson 99502ac6454SAndrew Thompson static void 996760bc48eSAndrew Thompson ehci_transfer_intr_enqueue(struct usb_xfer *xfer) 99702ac6454SAndrew Thompson { 99802ac6454SAndrew Thompson /* check for early completion */ 99902ac6454SAndrew Thompson if (ehci_check_transfer(xfer)) { 100002ac6454SAndrew Thompson return; 100102ac6454SAndrew Thompson } 100202ac6454SAndrew Thompson /* put transfer on interrupt queue */ 1003a593f6b8SAndrew Thompson usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer); 100402ac6454SAndrew Thompson 100502ac6454SAndrew Thompson /* start timeout, if any */ 100602ac6454SAndrew Thompson if (xfer->timeout != 0) { 1007a593f6b8SAndrew Thompson usbd_transfer_timeout_ms(xfer, &ehci_timeout, xfer->timeout); 100802ac6454SAndrew Thompson } 100902ac6454SAndrew Thompson } 101002ac6454SAndrew Thompson 101102ac6454SAndrew Thompson #define EHCI_APPEND_FS_TD(std,last) (last) = _ehci_append_fs_td(std,last) 101202ac6454SAndrew Thompson static ehci_sitd_t * 101302ac6454SAndrew Thompson _ehci_append_fs_td(ehci_sitd_t *std, ehci_sitd_t *last) 101402ac6454SAndrew Thompson { 101502ac6454SAndrew Thompson DPRINTFN(11, "%p to %p\n", std, last); 101602ac6454SAndrew Thompson 101702ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 101802ac6454SAndrew Thompson 101902ac6454SAndrew Thompson std->next = last->next; 102002ac6454SAndrew Thompson std->sitd_next = last->sitd_next; 102102ac6454SAndrew Thompson 102202ac6454SAndrew Thompson std->prev = last; 102302ac6454SAndrew Thompson 1024a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->page_cache); 102502ac6454SAndrew Thompson 102602ac6454SAndrew Thompson /* 102702ac6454SAndrew Thompson * the last->next->prev is never followed: std->next->prev = std; 102802ac6454SAndrew Thompson */ 102902ac6454SAndrew Thompson last->next = std; 103002ac6454SAndrew Thompson last->sitd_next = std->sitd_self; 103102ac6454SAndrew Thompson 1032a593f6b8SAndrew Thompson usb_pc_cpu_flush(last->page_cache); 103302ac6454SAndrew Thompson 103402ac6454SAndrew Thompson return (std); 103502ac6454SAndrew Thompson } 103602ac6454SAndrew Thompson 103702ac6454SAndrew Thompson #define EHCI_APPEND_HS_TD(std,last) (last) = _ehci_append_hs_td(std,last) 103802ac6454SAndrew Thompson static ehci_itd_t * 103902ac6454SAndrew Thompson _ehci_append_hs_td(ehci_itd_t *std, ehci_itd_t *last) 104002ac6454SAndrew Thompson { 104102ac6454SAndrew Thompson DPRINTFN(11, "%p to %p\n", std, last); 104202ac6454SAndrew Thompson 104302ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 104402ac6454SAndrew Thompson 104502ac6454SAndrew Thompson std->next = last->next; 104602ac6454SAndrew Thompson std->itd_next = last->itd_next; 104702ac6454SAndrew Thompson 104802ac6454SAndrew Thompson std->prev = last; 104902ac6454SAndrew Thompson 1050a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->page_cache); 105102ac6454SAndrew Thompson 105202ac6454SAndrew Thompson /* 105302ac6454SAndrew Thompson * the last->next->prev is never followed: std->next->prev = std; 105402ac6454SAndrew Thompson */ 105502ac6454SAndrew Thompson last->next = std; 105602ac6454SAndrew Thompson last->itd_next = std->itd_self; 105702ac6454SAndrew Thompson 1058a593f6b8SAndrew Thompson usb_pc_cpu_flush(last->page_cache); 105902ac6454SAndrew Thompson 106002ac6454SAndrew Thompson return (std); 106102ac6454SAndrew Thompson } 106202ac6454SAndrew Thompson 106302ac6454SAndrew Thompson #define EHCI_APPEND_QH(sqh,last) (last) = _ehci_append_qh(sqh,last) 106402ac6454SAndrew Thompson static ehci_qh_t * 106502ac6454SAndrew Thompson _ehci_append_qh(ehci_qh_t *sqh, ehci_qh_t *last) 106602ac6454SAndrew Thompson { 106702ac6454SAndrew Thompson DPRINTFN(11, "%p to %p\n", sqh, last); 106802ac6454SAndrew Thompson 106902ac6454SAndrew Thompson if (sqh->prev != NULL) { 107002ac6454SAndrew Thompson /* should not happen */ 107102ac6454SAndrew Thompson DPRINTFN(0, "QH already linked!\n"); 107202ac6454SAndrew Thompson return (last); 107302ac6454SAndrew Thompson } 107402ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 107502ac6454SAndrew Thompson 107602ac6454SAndrew Thompson sqh->next = last->next; 107702ac6454SAndrew Thompson sqh->qh_link = last->qh_link; 107802ac6454SAndrew Thompson 107902ac6454SAndrew Thompson sqh->prev = last; 108002ac6454SAndrew Thompson 1081a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->page_cache); 108202ac6454SAndrew Thompson 108302ac6454SAndrew Thompson /* 108402ac6454SAndrew Thompson * the last->next->prev is never followed: sqh->next->prev = sqh; 108502ac6454SAndrew Thompson */ 108602ac6454SAndrew Thompson 108702ac6454SAndrew Thompson last->next = sqh; 108802ac6454SAndrew Thompson last->qh_link = sqh->qh_self; 108902ac6454SAndrew Thompson 1090a593f6b8SAndrew Thompson usb_pc_cpu_flush(last->page_cache); 109102ac6454SAndrew Thompson 109202ac6454SAndrew Thompson return (sqh); 109302ac6454SAndrew Thompson } 109402ac6454SAndrew Thompson 109502ac6454SAndrew Thompson #define EHCI_REMOVE_FS_TD(std,last) (last) = _ehci_remove_fs_td(std,last) 109602ac6454SAndrew Thompson static ehci_sitd_t * 109702ac6454SAndrew Thompson _ehci_remove_fs_td(ehci_sitd_t *std, ehci_sitd_t *last) 109802ac6454SAndrew Thompson { 109902ac6454SAndrew Thompson DPRINTFN(11, "%p from %p\n", std, last); 110002ac6454SAndrew Thompson 110102ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 110202ac6454SAndrew Thompson 110302ac6454SAndrew Thompson std->prev->next = std->next; 110402ac6454SAndrew Thompson std->prev->sitd_next = std->sitd_next; 110502ac6454SAndrew Thompson 1106a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->prev->page_cache); 110702ac6454SAndrew Thompson 110802ac6454SAndrew Thompson if (std->next) { 110902ac6454SAndrew Thompson std->next->prev = std->prev; 1110a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->next->page_cache); 111102ac6454SAndrew Thompson } 111202ac6454SAndrew Thompson return ((last == std) ? std->prev : last); 111302ac6454SAndrew Thompson } 111402ac6454SAndrew Thompson 111502ac6454SAndrew Thompson #define EHCI_REMOVE_HS_TD(std,last) (last) = _ehci_remove_hs_td(std,last) 111602ac6454SAndrew Thompson static ehci_itd_t * 111702ac6454SAndrew Thompson _ehci_remove_hs_td(ehci_itd_t *std, ehci_itd_t *last) 111802ac6454SAndrew Thompson { 111902ac6454SAndrew Thompson DPRINTFN(11, "%p from %p\n", std, last); 112002ac6454SAndrew Thompson 112102ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 112202ac6454SAndrew Thompson 112302ac6454SAndrew Thompson std->prev->next = std->next; 112402ac6454SAndrew Thompson std->prev->itd_next = std->itd_next; 112502ac6454SAndrew Thompson 1126a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->prev->page_cache); 112702ac6454SAndrew Thompson 112802ac6454SAndrew Thompson if (std->next) { 112902ac6454SAndrew Thompson std->next->prev = std->prev; 1130a593f6b8SAndrew Thompson usb_pc_cpu_flush(std->next->page_cache); 113102ac6454SAndrew Thompson } 113202ac6454SAndrew Thompson return ((last == std) ? std->prev : last); 113302ac6454SAndrew Thompson } 113402ac6454SAndrew Thompson 113502ac6454SAndrew Thompson #define EHCI_REMOVE_QH(sqh,last) (last) = _ehci_remove_qh(sqh,last) 113602ac6454SAndrew Thompson static ehci_qh_t * 113702ac6454SAndrew Thompson _ehci_remove_qh(ehci_qh_t *sqh, ehci_qh_t *last) 113802ac6454SAndrew Thompson { 113902ac6454SAndrew Thompson DPRINTFN(11, "%p from %p\n", sqh, last); 114002ac6454SAndrew Thompson 114102ac6454SAndrew Thompson /* (sc->sc_bus.mtx) must be locked */ 114202ac6454SAndrew Thompson 114302ac6454SAndrew Thompson /* only remove if not removed from a queue */ 114402ac6454SAndrew Thompson if (sqh->prev) { 114502ac6454SAndrew Thompson 114602ac6454SAndrew Thompson sqh->prev->next = sqh->next; 114702ac6454SAndrew Thompson sqh->prev->qh_link = sqh->qh_link; 114802ac6454SAndrew Thompson 1149a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->prev->page_cache); 115002ac6454SAndrew Thompson 115102ac6454SAndrew Thompson if (sqh->next) { 115202ac6454SAndrew Thompson sqh->next->prev = sqh->prev; 1153a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->next->page_cache); 115402ac6454SAndrew Thompson } 115502ac6454SAndrew Thompson last = ((last == sqh) ? sqh->prev : last); 115602ac6454SAndrew Thompson 115702ac6454SAndrew Thompson sqh->prev = 0; 115802ac6454SAndrew Thompson 1159a593f6b8SAndrew Thompson usb_pc_cpu_flush(sqh->page_cache); 116002ac6454SAndrew Thompson } 116102ac6454SAndrew Thompson return (last); 116202ac6454SAndrew Thompson } 116302ac6454SAndrew Thompson 1164e0a69b51SAndrew Thompson static usb_error_t 1165760bc48eSAndrew Thompson ehci_non_isoc_done_sub(struct usb_xfer *xfer) 116602ac6454SAndrew Thompson { 116702ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 116802ac6454SAndrew Thompson ehci_qtd_t *td; 116902ac6454SAndrew Thompson ehci_qtd_t *td_alt_next; 117002ac6454SAndrew Thompson uint32_t status; 117102ac6454SAndrew Thompson uint16_t len; 117202ac6454SAndrew Thompson 117302ac6454SAndrew Thompson td = xfer->td_transfer_cache; 117402ac6454SAndrew Thompson td_alt_next = td->alt_next; 117502ac6454SAndrew Thompson 117602ac6454SAndrew Thompson if (xfer->aframes != xfer->nframes) { 1177ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(xfer, xfer->aframes, 0); 117802ac6454SAndrew Thompson } 117902ac6454SAndrew Thompson while (1) { 118002ac6454SAndrew Thompson 1181a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 1182e55e1ebcSAndrew Thompson status = hc32toh(sc, td->qtd_status); 118302ac6454SAndrew Thompson 118402ac6454SAndrew Thompson len = EHCI_QTD_GET_BYTES(status); 118502ac6454SAndrew Thompson 118602ac6454SAndrew Thompson /* 118702ac6454SAndrew Thompson * Verify the status length and 118802ac6454SAndrew Thompson * add the length to "frlengths[]": 118902ac6454SAndrew Thompson */ 119002ac6454SAndrew Thompson if (len > td->len) { 119102ac6454SAndrew Thompson /* should not happen */ 119202ac6454SAndrew Thompson DPRINTF("Invalid status length, " 119302ac6454SAndrew Thompson "0x%04x/0x%04x bytes\n", len, td->len); 119402ac6454SAndrew Thompson status |= EHCI_QTD_HALTED; 119502ac6454SAndrew Thompson } else if (xfer->aframes != xfer->nframes) { 119602ac6454SAndrew Thompson xfer->frlengths[xfer->aframes] += td->len - len; 119702ac6454SAndrew Thompson } 119802ac6454SAndrew Thompson /* Check for last transfer */ 119902ac6454SAndrew Thompson if (((void *)td) == xfer->td_transfer_last) { 120002ac6454SAndrew Thompson td = NULL; 120102ac6454SAndrew Thompson break; 120202ac6454SAndrew Thompson } 120302ac6454SAndrew Thompson /* Check for transfer error */ 120402ac6454SAndrew Thompson if (status & EHCI_QTD_HALTED) { 120502ac6454SAndrew Thompson /* the transfer is finished */ 120602ac6454SAndrew Thompson td = NULL; 120702ac6454SAndrew Thompson break; 120802ac6454SAndrew Thompson } 120902ac6454SAndrew Thompson /* Check for short transfer */ 121002ac6454SAndrew Thompson if (len > 0) { 121102ac6454SAndrew Thompson if (xfer->flags_int.short_frames_ok) { 121202ac6454SAndrew Thompson /* follow alt next */ 121302ac6454SAndrew Thompson td = td->alt_next; 121402ac6454SAndrew Thompson } else { 121502ac6454SAndrew Thompson /* the transfer is finished */ 121602ac6454SAndrew Thompson td = NULL; 121702ac6454SAndrew Thompson } 121802ac6454SAndrew Thompson break; 121902ac6454SAndrew Thompson } 122002ac6454SAndrew Thompson td = td->obj_next; 122102ac6454SAndrew Thompson 122202ac6454SAndrew Thompson if (td->alt_next != td_alt_next) { 122302ac6454SAndrew Thompson /* this USB frame is complete */ 122402ac6454SAndrew Thompson break; 122502ac6454SAndrew Thompson } 122602ac6454SAndrew Thompson } 122702ac6454SAndrew Thompson 122802ac6454SAndrew Thompson /* update transfer cache */ 122902ac6454SAndrew Thompson 123002ac6454SAndrew Thompson xfer->td_transfer_cache = td; 123102ac6454SAndrew Thompson 1232b850ecc1SAndrew Thompson #ifdef USB_DEBUG 123302ac6454SAndrew Thompson if (status & EHCI_QTD_STATERRS) { 123402ac6454SAndrew Thompson DPRINTFN(11, "error, addr=%d, endpt=0x%02x, frame=0x%02x" 123502ac6454SAndrew Thompson "status=%s%s%s%s%s%s%s%s\n", 1236ae60fdfbSAndrew Thompson xfer->address, xfer->endpointno, xfer->aframes, 123702ac6454SAndrew Thompson (status & EHCI_QTD_ACTIVE) ? "[ACTIVE]" : "[NOT_ACTIVE]", 123802ac6454SAndrew Thompson (status & EHCI_QTD_HALTED) ? "[HALTED]" : "", 123902ac6454SAndrew Thompson (status & EHCI_QTD_BUFERR) ? "[BUFERR]" : "", 124002ac6454SAndrew Thompson (status & EHCI_QTD_BABBLE) ? "[BABBLE]" : "", 124102ac6454SAndrew Thompson (status & EHCI_QTD_XACTERR) ? "[XACTERR]" : "", 124202ac6454SAndrew Thompson (status & EHCI_QTD_MISSEDMICRO) ? "[MISSED]" : "", 124302ac6454SAndrew Thompson (status & EHCI_QTD_SPLITXSTATE) ? "[SPLIT]" : "", 124402ac6454SAndrew Thompson (status & EHCI_QTD_PINGSTATE) ? "[PING]" : ""); 124502ac6454SAndrew Thompson } 124602ac6454SAndrew Thompson #endif 124702ac6454SAndrew Thompson 124802ac6454SAndrew Thompson return ((status & EHCI_QTD_HALTED) ? 124902ac6454SAndrew Thompson USB_ERR_STALLED : USB_ERR_NORMAL_COMPLETION); 125002ac6454SAndrew Thompson } 125102ac6454SAndrew Thompson 125202ac6454SAndrew Thompson static void 1253760bc48eSAndrew Thompson ehci_non_isoc_done(struct usb_xfer *xfer) 125402ac6454SAndrew Thompson { 1255c8a14b91SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 1256c8a14b91SAndrew Thompson ehci_qh_t *qh; 1257c8a14b91SAndrew Thompson uint32_t status; 1258e0a69b51SAndrew Thompson usb_error_t err = 0; 125902ac6454SAndrew Thompson 1260ae60fdfbSAndrew Thompson DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n", 1261ae60fdfbSAndrew Thompson xfer, xfer->endpoint); 126202ac6454SAndrew Thompson 1263b850ecc1SAndrew Thompson #ifdef USB_DEBUG 126402ac6454SAndrew Thompson if (ehcidebug > 10) { 126502ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 126602ac6454SAndrew Thompson 126702ac6454SAndrew Thompson ehci_dump_sqtds(sc, xfer->td_transfer_first); 126802ac6454SAndrew Thompson } 126902ac6454SAndrew Thompson #endif 127002ac6454SAndrew Thompson 1271c8a14b91SAndrew Thompson /* extract data toggle directly from the QH's overlay area */ 1272c8a14b91SAndrew Thompson 1273c8a14b91SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 1274c8a14b91SAndrew Thompson 1275c8a14b91SAndrew Thompson usb_pc_cpu_invalidate(qh->page_cache); 1276c8a14b91SAndrew Thompson 1277c8a14b91SAndrew Thompson status = hc32toh(sc, qh->qh_qtd.qtd_status); 1278c8a14b91SAndrew Thompson 1279c8a14b91SAndrew Thompson xfer->endpoint->toggle_next = 1280c8a14b91SAndrew Thompson (status & EHCI_QTD_TOGGLE_MASK) ? 1 : 0; 1281c8a14b91SAndrew Thompson 128202ac6454SAndrew Thompson /* reset scanner */ 128302ac6454SAndrew Thompson 128402ac6454SAndrew Thompson xfer->td_transfer_cache = xfer->td_transfer_first; 128502ac6454SAndrew Thompson 128602ac6454SAndrew Thompson if (xfer->flags_int.control_xfr) { 128702ac6454SAndrew Thompson 128802ac6454SAndrew Thompson if (xfer->flags_int.control_hdr) { 128902ac6454SAndrew Thompson 129002ac6454SAndrew Thompson err = ehci_non_isoc_done_sub(xfer); 129102ac6454SAndrew Thompson } 129202ac6454SAndrew Thompson xfer->aframes = 1; 129302ac6454SAndrew Thompson 129402ac6454SAndrew Thompson if (xfer->td_transfer_cache == NULL) { 129502ac6454SAndrew Thompson goto done; 129602ac6454SAndrew Thompson } 129702ac6454SAndrew Thompson } 129802ac6454SAndrew Thompson while (xfer->aframes != xfer->nframes) { 129902ac6454SAndrew Thompson 130002ac6454SAndrew Thompson err = ehci_non_isoc_done_sub(xfer); 130102ac6454SAndrew Thompson xfer->aframes++; 130202ac6454SAndrew Thompson 130302ac6454SAndrew Thompson if (xfer->td_transfer_cache == NULL) { 130402ac6454SAndrew Thompson goto done; 130502ac6454SAndrew Thompson } 130602ac6454SAndrew Thompson } 130702ac6454SAndrew Thompson 130802ac6454SAndrew Thompson if (xfer->flags_int.control_xfr && 130902ac6454SAndrew Thompson !xfer->flags_int.control_act) { 131002ac6454SAndrew Thompson 131102ac6454SAndrew Thompson err = ehci_non_isoc_done_sub(xfer); 131202ac6454SAndrew Thompson } 131302ac6454SAndrew Thompson done: 131402ac6454SAndrew Thompson ehci_device_done(xfer, err); 131502ac6454SAndrew Thompson } 131602ac6454SAndrew Thompson 131702ac6454SAndrew Thompson /*------------------------------------------------------------------------* 131802ac6454SAndrew Thompson * ehci_check_transfer 131902ac6454SAndrew Thompson * 132002ac6454SAndrew Thompson * Return values: 132102ac6454SAndrew Thompson * 0: USB transfer is not finished 132202ac6454SAndrew Thompson * Else: USB transfer is finished 132302ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 132402ac6454SAndrew Thompson static uint8_t 1325760bc48eSAndrew Thompson ehci_check_transfer(struct usb_xfer *xfer) 132602ac6454SAndrew Thompson { 1327ae60fdfbSAndrew Thompson struct usb_pipe_methods *methods = xfer->endpoint->methods; 132802ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 132902ac6454SAndrew Thompson 133002ac6454SAndrew Thompson uint32_t status; 133102ac6454SAndrew Thompson 133202ac6454SAndrew Thompson DPRINTFN(13, "xfer=%p checking transfer\n", xfer); 133302ac6454SAndrew Thompson 133402ac6454SAndrew Thompson if (methods == &ehci_device_isoc_fs_methods) { 133502ac6454SAndrew Thompson ehci_sitd_t *td; 133602ac6454SAndrew Thompson 133702ac6454SAndrew Thompson /* isochronous full speed transfer */ 133802ac6454SAndrew Thompson 133902ac6454SAndrew Thompson td = xfer->td_transfer_last; 1340a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 1341e55e1ebcSAndrew Thompson status = hc32toh(sc, td->sitd_status); 134202ac6454SAndrew Thompson 134302ac6454SAndrew Thompson /* also check if first is complete */ 134402ac6454SAndrew Thompson 134502ac6454SAndrew Thompson td = xfer->td_transfer_first; 1346a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 1347e55e1ebcSAndrew Thompson status |= hc32toh(sc, td->sitd_status); 134802ac6454SAndrew Thompson 134902ac6454SAndrew Thompson if (!(status & EHCI_SITD_ACTIVE)) { 135002ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_NORMAL_COMPLETION); 135102ac6454SAndrew Thompson goto transferred; 135202ac6454SAndrew Thompson } 135302ac6454SAndrew Thompson } else if (methods == &ehci_device_isoc_hs_methods) { 135402ac6454SAndrew Thompson ehci_itd_t *td; 135502ac6454SAndrew Thompson 135602ac6454SAndrew Thompson /* isochronous high speed transfer */ 135702ac6454SAndrew Thompson 135889119752SAndrew Thompson /* check last transfer */ 135902ac6454SAndrew Thompson td = xfer->td_transfer_last; 1360a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 1361d1f7c4baSAndrew Thompson status = td->itd_status[0]; 1362d1f7c4baSAndrew Thompson status |= td->itd_status[1]; 1363d1f7c4baSAndrew Thompson status |= td->itd_status[2]; 1364d1f7c4baSAndrew Thompson status |= td->itd_status[3]; 1365d1f7c4baSAndrew Thompson status |= td->itd_status[4]; 1366d1f7c4baSAndrew Thompson status |= td->itd_status[5]; 1367d1f7c4baSAndrew Thompson status |= td->itd_status[6]; 1368d1f7c4baSAndrew Thompson status |= td->itd_status[7]; 136902ac6454SAndrew Thompson 137002ac6454SAndrew Thompson /* also check first transfer */ 137102ac6454SAndrew Thompson td = xfer->td_transfer_first; 1372a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 137389119752SAndrew Thompson status |= td->itd_status[0]; 1374d1f7c4baSAndrew Thompson status |= td->itd_status[1]; 1375d1f7c4baSAndrew Thompson status |= td->itd_status[2]; 1376d1f7c4baSAndrew Thompson status |= td->itd_status[3]; 1377d1f7c4baSAndrew Thompson status |= td->itd_status[4]; 1378d1f7c4baSAndrew Thompson status |= td->itd_status[5]; 1379d1f7c4baSAndrew Thompson status |= td->itd_status[6]; 1380d1f7c4baSAndrew Thompson status |= td->itd_status[7]; 138102ac6454SAndrew Thompson 138202ac6454SAndrew Thompson /* if no transactions are active we continue */ 1383e55e1ebcSAndrew Thompson if (!(status & htohc32(sc, EHCI_ITD_ACTIVE))) { 138402ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_NORMAL_COMPLETION); 138502ac6454SAndrew Thompson goto transferred; 138602ac6454SAndrew Thompson } 138702ac6454SAndrew Thompson } else { 138802ac6454SAndrew Thompson ehci_qtd_t *td; 1389c8a14b91SAndrew Thompson ehci_qh_t *qh; 139002ac6454SAndrew Thompson 139102ac6454SAndrew Thompson /* non-isochronous transfer */ 139202ac6454SAndrew Thompson 139302ac6454SAndrew Thompson /* 139402ac6454SAndrew Thompson * check whether there is an error somewhere in the middle, 139502ac6454SAndrew Thompson * or whether there was a short packet (SPD and not ACTIVE) 139602ac6454SAndrew Thompson */ 139702ac6454SAndrew Thompson td = xfer->td_transfer_cache; 139802ac6454SAndrew Thompson 1399c8a14b91SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 1400c8a14b91SAndrew Thompson 1401c8a14b91SAndrew Thompson usb_pc_cpu_invalidate(qh->page_cache); 1402c8a14b91SAndrew Thompson 1403c8a14b91SAndrew Thompson status = hc32toh(sc, qh->qh_qtd.qtd_status); 1404c8a14b91SAndrew Thompson if (status & EHCI_QTD_ACTIVE) { 1405c8a14b91SAndrew Thompson /* transfer is pending */ 1406c8a14b91SAndrew Thompson goto done; 1407c8a14b91SAndrew Thompson } 1408c8a14b91SAndrew Thompson 140902ac6454SAndrew Thompson while (1) { 1410a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 1411e55e1ebcSAndrew Thompson status = hc32toh(sc, td->qtd_status); 141202ac6454SAndrew Thompson 141302ac6454SAndrew Thompson /* 1414c8a14b91SAndrew Thompson * Check if there is an active TD which 1415c8a14b91SAndrew Thompson * indicates that the transfer isn't done. 141602ac6454SAndrew Thompson */ 141702ac6454SAndrew Thompson if (status & EHCI_QTD_ACTIVE) { 141802ac6454SAndrew Thompson /* update cache */ 1419c8a14b91SAndrew Thompson if (xfer->td_transfer_cache != td) { 142002ac6454SAndrew Thompson xfer->td_transfer_cache = td; 1421c8a14b91SAndrew Thompson if (qh->qh_qtd.qtd_next & 1422c8a14b91SAndrew Thompson htohc32(sc, EHCI_LINK_TERMINATE)) { 1423c8a14b91SAndrew Thompson /* XXX - manually advance to next frame */ 1424c8a14b91SAndrew Thompson qh->qh_qtd.qtd_next = td->qtd_self; 1425c8a14b91SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 1426c8a14b91SAndrew Thompson } 1427c8a14b91SAndrew Thompson } 142802ac6454SAndrew Thompson goto done; 142902ac6454SAndrew Thompson } 143002ac6454SAndrew Thompson /* 143102ac6454SAndrew Thompson * last transfer descriptor makes the transfer done 143202ac6454SAndrew Thompson */ 143302ac6454SAndrew Thompson if (((void *)td) == xfer->td_transfer_last) { 143402ac6454SAndrew Thompson break; 143502ac6454SAndrew Thompson } 143602ac6454SAndrew Thompson /* 143702ac6454SAndrew Thompson * any kind of error makes the transfer done 143802ac6454SAndrew Thompson */ 143902ac6454SAndrew Thompson if (status & EHCI_QTD_HALTED) { 144002ac6454SAndrew Thompson break; 144102ac6454SAndrew Thompson } 144202ac6454SAndrew Thompson /* 144302ac6454SAndrew Thompson * if there is no alternate next transfer, a short 144402ac6454SAndrew Thompson * packet also makes the transfer done 144502ac6454SAndrew Thompson */ 144602ac6454SAndrew Thompson if (EHCI_QTD_GET_BYTES(status)) { 144702ac6454SAndrew Thompson if (xfer->flags_int.short_frames_ok) { 144802ac6454SAndrew Thompson /* follow alt next */ 144902ac6454SAndrew Thompson if (td->alt_next) { 145002ac6454SAndrew Thompson td = td->alt_next; 145102ac6454SAndrew Thompson continue; 145202ac6454SAndrew Thompson } 145302ac6454SAndrew Thompson } 145402ac6454SAndrew Thompson /* transfer is done */ 145502ac6454SAndrew Thompson break; 145602ac6454SAndrew Thompson } 145702ac6454SAndrew Thompson td = td->obj_next; 145802ac6454SAndrew Thompson } 145902ac6454SAndrew Thompson ehci_non_isoc_done(xfer); 146002ac6454SAndrew Thompson goto transferred; 146102ac6454SAndrew Thompson } 146202ac6454SAndrew Thompson 146302ac6454SAndrew Thompson done: 146402ac6454SAndrew Thompson DPRINTFN(13, "xfer=%p is still active\n", xfer); 146502ac6454SAndrew Thompson return (0); 146602ac6454SAndrew Thompson 146702ac6454SAndrew Thompson transferred: 146802ac6454SAndrew Thompson return (1); 146902ac6454SAndrew Thompson } 147002ac6454SAndrew Thompson 147102ac6454SAndrew Thompson static void 147202ac6454SAndrew Thompson ehci_pcd_enable(ehci_softc_t *sc) 147302ac6454SAndrew Thompson { 147402ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 147502ac6454SAndrew Thompson 147602ac6454SAndrew Thompson sc->sc_eintrs |= EHCI_STS_PCD; 147702ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); 147802ac6454SAndrew Thompson 147902ac6454SAndrew Thompson /* acknowledge any PCD interrupt */ 148002ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBSTS, EHCI_STS_PCD); 148102ac6454SAndrew Thompson 148239307315SAndrew Thompson ehci_root_intr(sc); 148302ac6454SAndrew Thompson } 148402ac6454SAndrew Thompson 148502ac6454SAndrew Thompson static void 148602ac6454SAndrew Thompson ehci_interrupt_poll(ehci_softc_t *sc) 148702ac6454SAndrew Thompson { 1488760bc48eSAndrew Thompson struct usb_xfer *xfer; 148902ac6454SAndrew Thompson 149002ac6454SAndrew Thompson repeat: 149102ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 149202ac6454SAndrew Thompson /* 149302ac6454SAndrew Thompson * check if transfer is transferred 149402ac6454SAndrew Thompson */ 149502ac6454SAndrew Thompson if (ehci_check_transfer(xfer)) { 149602ac6454SAndrew Thompson /* queue has been modified */ 149702ac6454SAndrew Thompson goto repeat; 149802ac6454SAndrew Thompson } 149902ac6454SAndrew Thompson } 150002ac6454SAndrew Thompson } 150102ac6454SAndrew Thompson 150230b22abeSAndrew Thompson /* 150330b22abeSAndrew Thompson * Some EHCI chips from VIA / ATI seem to trigger interrupts before 150430b22abeSAndrew Thompson * writing back the qTD status, or miss signalling occasionally under 150530b22abeSAndrew Thompson * heavy load. If the host machine is too fast, we can miss 150630b22abeSAndrew Thompson * transaction completion - when we scan the active list the 150730b22abeSAndrew Thompson * transaction still seems to be active. This generally exhibits 150830b22abeSAndrew Thompson * itself as a umass stall that never recovers. 150930b22abeSAndrew Thompson * 151030b22abeSAndrew Thompson * We work around this behaviour by setting up this callback after any 151130b22abeSAndrew Thompson * softintr that completes with transactions still pending, giving us 151230b22abeSAndrew Thompson * another chance to check for completion after the writeback has 151330b22abeSAndrew Thompson * taken place. 151430b22abeSAndrew Thompson */ 151530b22abeSAndrew Thompson static void 151630b22abeSAndrew Thompson ehci_poll_timeout(void *arg) 151730b22abeSAndrew Thompson { 151830b22abeSAndrew Thompson ehci_softc_t *sc = arg; 151930b22abeSAndrew Thompson 152030b22abeSAndrew Thompson DPRINTFN(3, "\n"); 152130b22abeSAndrew Thompson ehci_interrupt_poll(sc); 152230b22abeSAndrew Thompson } 152330b22abeSAndrew Thompson 152402ac6454SAndrew Thompson /*------------------------------------------------------------------------* 152502ac6454SAndrew Thompson * ehci_interrupt - EHCI interrupt handler 152602ac6454SAndrew Thompson * 152702ac6454SAndrew Thompson * NOTE: Do not access "sc->sc_bus.bdev" inside the interrupt handler, 152802ac6454SAndrew Thompson * hence the interrupt handler will be setup before "sc->sc_bus.bdev" 152902ac6454SAndrew Thompson * is present ! 153002ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 153102ac6454SAndrew Thompson void 153202ac6454SAndrew Thompson ehci_interrupt(ehci_softc_t *sc) 153302ac6454SAndrew Thompson { 153402ac6454SAndrew Thompson uint32_t status; 153502ac6454SAndrew Thompson 153602ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 153702ac6454SAndrew Thompson 153802ac6454SAndrew Thompson DPRINTFN(16, "real interrupt\n"); 153902ac6454SAndrew Thompson 1540b850ecc1SAndrew Thompson #ifdef USB_DEBUG 154102ac6454SAndrew Thompson if (ehcidebug > 15) { 154202ac6454SAndrew Thompson ehci_dump_regs(sc); 154302ac6454SAndrew Thompson } 154402ac6454SAndrew Thompson #endif 154502ac6454SAndrew Thompson 154602ac6454SAndrew Thompson status = EHCI_STS_INTRS(EOREAD4(sc, EHCI_USBSTS)); 154702ac6454SAndrew Thompson if (status == 0) { 154802ac6454SAndrew Thompson /* the interrupt was not for us */ 154902ac6454SAndrew Thompson goto done; 155002ac6454SAndrew Thompson } 155102ac6454SAndrew Thompson if (!(status & sc->sc_eintrs)) { 155202ac6454SAndrew Thompson goto done; 155302ac6454SAndrew Thompson } 155402ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBSTS, status); /* acknowledge */ 155502ac6454SAndrew Thompson 155602ac6454SAndrew Thompson status &= sc->sc_eintrs; 155702ac6454SAndrew Thompson 155802ac6454SAndrew Thompson if (status & EHCI_STS_HSE) { 155902ac6454SAndrew Thompson printf("%s: unrecoverable error, " 156002ac6454SAndrew Thompson "controller halted\n", __FUNCTION__); 1561b850ecc1SAndrew Thompson #ifdef USB_DEBUG 156202ac6454SAndrew Thompson ehci_dump_regs(sc); 156302ac6454SAndrew Thompson ehci_dump_isoc(sc); 156402ac6454SAndrew Thompson #endif 156502ac6454SAndrew Thompson } 156602ac6454SAndrew Thompson if (status & EHCI_STS_PCD) { 156702ac6454SAndrew Thompson /* 156802ac6454SAndrew Thompson * Disable PCD interrupt for now, because it will be 156902ac6454SAndrew Thompson * on until the port has been reset. 157002ac6454SAndrew Thompson */ 157102ac6454SAndrew Thompson sc->sc_eintrs &= ~EHCI_STS_PCD; 157202ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); 157302ac6454SAndrew Thompson 157439307315SAndrew Thompson ehci_root_intr(sc); 157502ac6454SAndrew Thompson 157602ac6454SAndrew Thompson /* do not allow RHSC interrupts > 1 per second */ 1577a593f6b8SAndrew Thompson usb_callout_reset(&sc->sc_tmo_pcd, hz, 157802ac6454SAndrew Thompson (void *)&ehci_pcd_enable, sc); 157902ac6454SAndrew Thompson } 158002ac6454SAndrew Thompson status &= ~(EHCI_STS_INT | EHCI_STS_ERRINT | EHCI_STS_PCD | EHCI_STS_IAA); 158102ac6454SAndrew Thompson 158202ac6454SAndrew Thompson if (status != 0) { 158302ac6454SAndrew Thompson /* block unprocessed interrupts */ 158402ac6454SAndrew Thompson sc->sc_eintrs &= ~status; 158502ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBINTR, sc->sc_eintrs); 158602ac6454SAndrew Thompson printf("%s: blocking interrupts 0x%x\n", __FUNCTION__, status); 158702ac6454SAndrew Thompson } 158802ac6454SAndrew Thompson /* poll all the USB transfers */ 158902ac6454SAndrew Thompson ehci_interrupt_poll(sc); 159002ac6454SAndrew Thompson 159130b22abeSAndrew Thompson if (sc->sc_flags & EHCI_SCFLG_LOSTINTRBUG) { 159230b22abeSAndrew Thompson usb_callout_reset(&sc->sc_tmo_poll, hz / 128, 159330b22abeSAndrew Thompson (void *)&ehci_poll_timeout, sc); 159430b22abeSAndrew Thompson } 159530b22abeSAndrew Thompson 159602ac6454SAndrew Thompson done: 159702ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 159802ac6454SAndrew Thompson } 159902ac6454SAndrew Thompson 160002ac6454SAndrew Thompson /* 160102ac6454SAndrew Thompson * called when a request does not complete 160202ac6454SAndrew Thompson */ 160302ac6454SAndrew Thompson static void 160402ac6454SAndrew Thompson ehci_timeout(void *arg) 160502ac6454SAndrew Thompson { 1606760bc48eSAndrew Thompson struct usb_xfer *xfer = arg; 160702ac6454SAndrew Thompson 160802ac6454SAndrew Thompson DPRINTF("xfer=%p\n", xfer); 160902ac6454SAndrew Thompson 161002ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED); 161102ac6454SAndrew Thompson 161202ac6454SAndrew Thompson /* transfer is transferred */ 161302ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_TIMEOUT); 161402ac6454SAndrew Thompson } 161502ac6454SAndrew Thompson 161602ac6454SAndrew Thompson static void 1617760bc48eSAndrew Thompson ehci_do_poll(struct usb_bus *bus) 161802ac6454SAndrew Thompson { 161902ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(bus); 162002ac6454SAndrew Thompson 162102ac6454SAndrew Thompson USB_BUS_LOCK(&sc->sc_bus); 162202ac6454SAndrew Thompson ehci_interrupt_poll(sc); 162302ac6454SAndrew Thompson USB_BUS_UNLOCK(&sc->sc_bus); 162402ac6454SAndrew Thompson } 162502ac6454SAndrew Thompson 162602ac6454SAndrew Thompson static void 162702ac6454SAndrew Thompson ehci_setup_standard_chain_sub(struct ehci_std_temp *temp) 162802ac6454SAndrew Thompson { 1629760bc48eSAndrew Thompson struct usb_page_search buf_res; 163002ac6454SAndrew Thompson ehci_qtd_t *td; 163102ac6454SAndrew Thompson ehci_qtd_t *td_next; 163202ac6454SAndrew Thompson ehci_qtd_t *td_alt_next; 163302ac6454SAndrew Thompson uint32_t buf_offset; 163402ac6454SAndrew Thompson uint32_t average; 163502ac6454SAndrew Thompson uint32_t len_old; 16360f7d4548SAndrew Thompson uint32_t terminate; 163702ac6454SAndrew Thompson uint8_t shortpkt_old; 163802ac6454SAndrew Thompson uint8_t precompute; 163902ac6454SAndrew Thompson 16400f7d4548SAndrew Thompson terminate = htohc32(temp->sc, EHCI_LINK_TERMINATE); 164102ac6454SAndrew Thompson td_alt_next = NULL; 164202ac6454SAndrew Thompson buf_offset = 0; 164302ac6454SAndrew Thompson shortpkt_old = temp->shortpkt; 164402ac6454SAndrew Thompson len_old = temp->len; 164502ac6454SAndrew Thompson precompute = 1; 164602ac6454SAndrew Thompson 164702ac6454SAndrew Thompson restart: 164802ac6454SAndrew Thompson 164902ac6454SAndrew Thompson td = temp->td; 165002ac6454SAndrew Thompson td_next = temp->td_next; 165102ac6454SAndrew Thompson 165202ac6454SAndrew Thompson while (1) { 165302ac6454SAndrew Thompson 165402ac6454SAndrew Thompson if (temp->len == 0) { 165502ac6454SAndrew Thompson 165602ac6454SAndrew Thompson if (temp->shortpkt) { 165702ac6454SAndrew Thompson break; 165802ac6454SAndrew Thompson } 165902ac6454SAndrew Thompson /* send a Zero Length Packet, ZLP, last */ 166002ac6454SAndrew Thompson 166102ac6454SAndrew Thompson temp->shortpkt = 1; 166202ac6454SAndrew Thompson average = 0; 166302ac6454SAndrew Thompson 166402ac6454SAndrew Thompson } else { 166502ac6454SAndrew Thompson 166602ac6454SAndrew Thompson average = temp->average; 166702ac6454SAndrew Thompson 166802ac6454SAndrew Thompson if (temp->len < average) { 166902ac6454SAndrew Thompson if (temp->len % temp->max_frame_size) { 167002ac6454SAndrew Thompson temp->shortpkt = 1; 167102ac6454SAndrew Thompson } 167202ac6454SAndrew Thompson average = temp->len; 167302ac6454SAndrew Thompson } 167402ac6454SAndrew Thompson } 167502ac6454SAndrew Thompson 167602ac6454SAndrew Thompson if (td_next == NULL) { 167702ac6454SAndrew Thompson panic("%s: out of EHCI transfer descriptors!", __FUNCTION__); 167802ac6454SAndrew Thompson } 167902ac6454SAndrew Thompson /* get next TD */ 168002ac6454SAndrew Thompson 168102ac6454SAndrew Thompson td = td_next; 168202ac6454SAndrew Thompson td_next = td->obj_next; 168302ac6454SAndrew Thompson 168402ac6454SAndrew Thompson /* check if we are pre-computing */ 168502ac6454SAndrew Thompson 168602ac6454SAndrew Thompson if (precompute) { 168702ac6454SAndrew Thompson 168802ac6454SAndrew Thompson /* update remaining length */ 168902ac6454SAndrew Thompson 169002ac6454SAndrew Thompson temp->len -= average; 169102ac6454SAndrew Thompson 169202ac6454SAndrew Thompson continue; 169302ac6454SAndrew Thompson } 169402ac6454SAndrew Thompson /* fill out current TD */ 169502ac6454SAndrew Thompson 169602ac6454SAndrew Thompson td->qtd_status = 169702ac6454SAndrew Thompson temp->qtd_status | 1698c8a14b91SAndrew Thompson htohc32(temp->sc, EHCI_QTD_IOC | 1699c8a14b91SAndrew Thompson EHCI_QTD_SET_BYTES(average)); 170002ac6454SAndrew Thompson 170102ac6454SAndrew Thompson if (average == 0) { 170202ac6454SAndrew Thompson 170302ac6454SAndrew Thompson if (temp->auto_data_toggle == 0) { 170402ac6454SAndrew Thompson 170502ac6454SAndrew Thompson /* update data toggle, ZLP case */ 170602ac6454SAndrew Thompson 170702ac6454SAndrew Thompson temp->qtd_status ^= 1708e55e1ebcSAndrew Thompson htohc32(temp->sc, EHCI_QTD_TOGGLE_MASK); 170902ac6454SAndrew Thompson } 171002ac6454SAndrew Thompson td->len = 0; 171102ac6454SAndrew Thompson 171202ac6454SAndrew Thompson td->qtd_buffer[0] = 0; 171302ac6454SAndrew Thompson td->qtd_buffer_hi[0] = 0; 171402ac6454SAndrew Thompson 171502ac6454SAndrew Thompson td->qtd_buffer[1] = 0; 171602ac6454SAndrew Thompson td->qtd_buffer_hi[1] = 0; 171702ac6454SAndrew Thompson 171802ac6454SAndrew Thompson } else { 171902ac6454SAndrew Thompson 172002ac6454SAndrew Thompson uint8_t x; 172102ac6454SAndrew Thompson 172202ac6454SAndrew Thompson if (temp->auto_data_toggle == 0) { 172302ac6454SAndrew Thompson 172402ac6454SAndrew Thompson /* update data toggle */ 172502ac6454SAndrew Thompson 172602ac6454SAndrew Thompson if (((average + temp->max_frame_size - 1) / 172702ac6454SAndrew Thompson temp->max_frame_size) & 1) { 172802ac6454SAndrew Thompson temp->qtd_status ^= 1729e55e1ebcSAndrew Thompson htohc32(temp->sc, EHCI_QTD_TOGGLE_MASK); 173002ac6454SAndrew Thompson } 173102ac6454SAndrew Thompson } 173202ac6454SAndrew Thompson td->len = average; 173302ac6454SAndrew Thompson 173402ac6454SAndrew Thompson /* update remaining length */ 173502ac6454SAndrew Thompson 173602ac6454SAndrew Thompson temp->len -= average; 173702ac6454SAndrew Thompson 173802ac6454SAndrew Thompson /* fill out buffer pointers */ 173902ac6454SAndrew Thompson 1740a593f6b8SAndrew Thompson usbd_get_page(temp->pc, buf_offset, &buf_res); 174102ac6454SAndrew Thompson td->qtd_buffer[0] = 1742e55e1ebcSAndrew Thompson htohc32(temp->sc, buf_res.physaddr); 174302ac6454SAndrew Thompson td->qtd_buffer_hi[0] = 0; 174402ac6454SAndrew Thompson 174502ac6454SAndrew Thompson x = 1; 174602ac6454SAndrew Thompson 174702ac6454SAndrew Thompson while (average > EHCI_PAGE_SIZE) { 174802ac6454SAndrew Thompson average -= EHCI_PAGE_SIZE; 174902ac6454SAndrew Thompson buf_offset += EHCI_PAGE_SIZE; 1750a593f6b8SAndrew Thompson usbd_get_page(temp->pc, buf_offset, &buf_res); 175102ac6454SAndrew Thompson td->qtd_buffer[x] = 1752e55e1ebcSAndrew Thompson htohc32(temp->sc, 175302ac6454SAndrew Thompson buf_res.physaddr & (~0xFFF)); 175402ac6454SAndrew Thompson td->qtd_buffer_hi[x] = 0; 175502ac6454SAndrew Thompson x++; 175602ac6454SAndrew Thompson } 175702ac6454SAndrew Thompson 175802ac6454SAndrew Thompson /* 175902ac6454SAndrew Thompson * NOTE: The "average" variable is never zero after 176002ac6454SAndrew Thompson * exiting the loop above ! 176102ac6454SAndrew Thompson * 176202ac6454SAndrew Thompson * NOTE: We have to subtract one from the offset to 176302ac6454SAndrew Thompson * ensure that we are computing the physical address 176402ac6454SAndrew Thompson * of a valid page ! 176502ac6454SAndrew Thompson */ 176602ac6454SAndrew Thompson buf_offset += average; 1767a593f6b8SAndrew Thompson usbd_get_page(temp->pc, buf_offset - 1, &buf_res); 176802ac6454SAndrew Thompson td->qtd_buffer[x] = 1769e55e1ebcSAndrew Thompson htohc32(temp->sc, 177002ac6454SAndrew Thompson buf_res.physaddr & (~0xFFF)); 177102ac6454SAndrew Thompson td->qtd_buffer_hi[x] = 0; 177202ac6454SAndrew Thompson } 177302ac6454SAndrew Thompson 1774c8a14b91SAndrew Thompson if (temp->can_use_next) { 177502ac6454SAndrew Thompson if (td_next) { 177602ac6454SAndrew Thompson /* link the current TD with the next one */ 177702ac6454SAndrew Thompson td->qtd_next = td_next->qtd_self; 177802ac6454SAndrew Thompson } 1779c8a14b91SAndrew Thompson } else { 1780c8a14b91SAndrew Thompson /* 1781c8a14b91SAndrew Thompson * BUG WARNING: The EHCI HW can use the 1782c8a14b91SAndrew Thompson * qtd_next field instead of qtd_altnext when 1783c8a14b91SAndrew Thompson * a short packet is received! We work this 1784c8a14b91SAndrew Thompson * around in software by not queueing more 1785c8a14b91SAndrew Thompson * than one job/TD at a time! 1786c8a14b91SAndrew Thompson */ 1787c8a14b91SAndrew Thompson td->qtd_next = terminate; 1788c8a14b91SAndrew Thompson } 1789c8a14b91SAndrew Thompson 1790c8a14b91SAndrew Thompson td->qtd_altnext = terminate; 179102ac6454SAndrew Thompson td->alt_next = td_alt_next; 179202ac6454SAndrew Thompson 1793a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 179402ac6454SAndrew Thompson } 179502ac6454SAndrew Thompson 179602ac6454SAndrew Thompson if (precompute) { 179702ac6454SAndrew Thompson precompute = 0; 179802ac6454SAndrew Thompson 179902ac6454SAndrew Thompson /* setup alt next pointer, if any */ 18000f7d4548SAndrew Thompson if (temp->last_frame) { 18010f7d4548SAndrew Thompson td_alt_next = NULL; 180202ac6454SAndrew Thompson } else { 180302ac6454SAndrew Thompson /* we use this field internally */ 180402ac6454SAndrew Thompson td_alt_next = td_next; 180502ac6454SAndrew Thompson } 180602ac6454SAndrew Thompson 180702ac6454SAndrew Thompson /* restore */ 180802ac6454SAndrew Thompson temp->shortpkt = shortpkt_old; 180902ac6454SAndrew Thompson temp->len = len_old; 181002ac6454SAndrew Thompson goto restart; 181102ac6454SAndrew Thompson } 181202ac6454SAndrew Thompson temp->td = td; 181302ac6454SAndrew Thompson temp->td_next = td_next; 181402ac6454SAndrew Thompson } 181502ac6454SAndrew Thompson 181602ac6454SAndrew Thompson static void 1817760bc48eSAndrew Thompson ehci_setup_standard_chain(struct usb_xfer *xfer, ehci_qh_t **qh_last) 181802ac6454SAndrew Thompson { 181902ac6454SAndrew Thompson struct ehci_std_temp temp; 1820760bc48eSAndrew Thompson struct usb_pipe_methods *methods; 182102ac6454SAndrew Thompson ehci_qh_t *qh; 182202ac6454SAndrew Thompson ehci_qtd_t *td; 182302ac6454SAndrew Thompson uint32_t qh_endp; 182402ac6454SAndrew Thompson uint32_t qh_endphub; 182502ac6454SAndrew Thompson uint32_t x; 182602ac6454SAndrew Thompson 182702ac6454SAndrew Thompson DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n", 1828ae60fdfbSAndrew Thompson xfer->address, UE_GET_ADDR(xfer->endpointno), 1829a593f6b8SAndrew Thompson xfer->sumlen, usbd_get_speed(xfer->xroot->udev)); 183002ac6454SAndrew Thompson 1831578d0effSAndrew Thompson temp.average = xfer->max_hc_frame_size; 183202ac6454SAndrew Thompson temp.max_frame_size = xfer->max_frame_size; 183302ac6454SAndrew Thompson temp.sc = EHCI_BUS2SC(xfer->xroot->bus); 183402ac6454SAndrew Thompson 183502ac6454SAndrew Thompson /* toggle the DMA set we are using */ 183602ac6454SAndrew Thompson xfer->flags_int.curr_dma_set ^= 1; 183702ac6454SAndrew Thompson 183802ac6454SAndrew Thompson /* get next DMA set */ 183902ac6454SAndrew Thompson td = xfer->td_start[xfer->flags_int.curr_dma_set]; 184002ac6454SAndrew Thompson 184102ac6454SAndrew Thompson xfer->td_transfer_first = td; 184202ac6454SAndrew Thompson xfer->td_transfer_cache = td; 184302ac6454SAndrew Thompson 184402ac6454SAndrew Thompson temp.td = NULL; 184502ac6454SAndrew Thompson temp.td_next = td; 184602ac6454SAndrew Thompson temp.qtd_status = 0; 18470f7d4548SAndrew Thompson temp.last_frame = 0; 184802ac6454SAndrew Thompson temp.setup_alt_next = xfer->flags_int.short_frames_ok; 1849c8a14b91SAndrew Thompson temp.can_use_next = (xfer->flags_int.control_xfr || 1850c8a14b91SAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_OUT)); 185102ac6454SAndrew Thompson 185202ac6454SAndrew Thompson if (xfer->flags_int.control_xfr) { 1853ae60fdfbSAndrew Thompson if (xfer->endpoint->toggle_next) { 185402ac6454SAndrew Thompson /* DATA1 is next */ 185502ac6454SAndrew Thompson temp.qtd_status |= 1856e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_SET_TOGGLE(1)); 185702ac6454SAndrew Thompson } 185802ac6454SAndrew Thompson temp.auto_data_toggle = 0; 185902ac6454SAndrew Thompson } else { 186002ac6454SAndrew Thompson temp.auto_data_toggle = 1; 186102ac6454SAndrew Thompson } 186202ac6454SAndrew Thompson 1863a593f6b8SAndrew Thompson if (usbd_get_speed(xfer->xroot->udev) != USB_SPEED_HIGH) { 186402ac6454SAndrew Thompson /* max 3 retries */ 186502ac6454SAndrew Thompson temp.qtd_status |= 1866e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_SET_CERR(3)); 186702ac6454SAndrew Thompson } 186802ac6454SAndrew Thompson /* check if we should prepend a setup message */ 186902ac6454SAndrew Thompson 187002ac6454SAndrew Thompson if (xfer->flags_int.control_xfr) { 187102ac6454SAndrew Thompson if (xfer->flags_int.control_hdr) { 187202ac6454SAndrew Thompson 187302ac6454SAndrew Thompson temp.qtd_status &= 1874e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_SET_CERR(3)); 1875e55e1ebcSAndrew Thompson temp.qtd_status |= htohc32(temp.sc, 18765f128668SAndrew Thompson EHCI_QTD_ACTIVE | 187702ac6454SAndrew Thompson EHCI_QTD_SET_PID(EHCI_QTD_PID_SETUP) | 187802ac6454SAndrew Thompson EHCI_QTD_SET_TOGGLE(0)); 187902ac6454SAndrew Thompson 188002ac6454SAndrew Thompson temp.len = xfer->frlengths[0]; 188102ac6454SAndrew Thompson temp.pc = xfer->frbuffers + 0; 188202ac6454SAndrew Thompson temp.shortpkt = temp.len ? 1 : 0; 18830f7d4548SAndrew Thompson /* check for last frame */ 18840f7d4548SAndrew Thompson if (xfer->nframes == 1) { 18850f7d4548SAndrew Thompson /* no STATUS stage yet, SETUP is last */ 18860f7d4548SAndrew Thompson if (xfer->flags_int.control_act) { 18870f7d4548SAndrew Thompson temp.last_frame = 1; 18880f7d4548SAndrew Thompson temp.setup_alt_next = 0; 18890f7d4548SAndrew Thompson } 18900f7d4548SAndrew Thompson } 189102ac6454SAndrew Thompson ehci_setup_standard_chain_sub(&temp); 189202ac6454SAndrew Thompson } 189302ac6454SAndrew Thompson x = 1; 189402ac6454SAndrew Thompson } else { 189502ac6454SAndrew Thompson x = 0; 189602ac6454SAndrew Thompson } 189702ac6454SAndrew Thompson 189802ac6454SAndrew Thompson while (x != xfer->nframes) { 189902ac6454SAndrew Thompson 190002ac6454SAndrew Thompson /* DATA0 / DATA1 message */ 190102ac6454SAndrew Thompson 190202ac6454SAndrew Thompson temp.len = xfer->frlengths[x]; 190302ac6454SAndrew Thompson temp.pc = xfer->frbuffers + x; 190402ac6454SAndrew Thompson 190502ac6454SAndrew Thompson x++; 190602ac6454SAndrew Thompson 190702ac6454SAndrew Thompson if (x == xfer->nframes) { 19080f7d4548SAndrew Thompson if (xfer->flags_int.control_xfr) { 19090f7d4548SAndrew Thompson /* no STATUS stage yet, DATA is last */ 19100f7d4548SAndrew Thompson if (xfer->flags_int.control_act) { 19110f7d4548SAndrew Thompson temp.last_frame = 1; 191202ac6454SAndrew Thompson temp.setup_alt_next = 0; 191302ac6454SAndrew Thompson } 19140f7d4548SAndrew Thompson } else { 19150f7d4548SAndrew Thompson temp.last_frame = 1; 19160f7d4548SAndrew Thompson temp.setup_alt_next = 0; 19170f7d4548SAndrew Thompson } 19180f7d4548SAndrew Thompson } 191902ac6454SAndrew Thompson /* keep previous data toggle and error count */ 192002ac6454SAndrew Thompson 192102ac6454SAndrew Thompson temp.qtd_status &= 1922e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_SET_CERR(3) | 192302ac6454SAndrew Thompson EHCI_QTD_SET_TOGGLE(1)); 192402ac6454SAndrew Thompson 192502ac6454SAndrew Thompson if (temp.len == 0) { 192602ac6454SAndrew Thompson 192702ac6454SAndrew Thompson /* make sure that we send an USB packet */ 192802ac6454SAndrew Thompson 192902ac6454SAndrew Thompson temp.shortpkt = 0; 193002ac6454SAndrew Thompson 193102ac6454SAndrew Thompson } else { 193202ac6454SAndrew Thompson 193302ac6454SAndrew Thompson /* regular data transfer */ 193402ac6454SAndrew Thompson 193502ac6454SAndrew Thompson temp.shortpkt = (xfer->flags.force_short_xfer) ? 0 : 1; 193602ac6454SAndrew Thompson } 193702ac6454SAndrew Thompson 193802ac6454SAndrew Thompson /* set endpoint direction */ 193902ac6454SAndrew Thompson 194002ac6454SAndrew Thompson temp.qtd_status |= 1941ae60fdfbSAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_IN) ? 1942e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_ACTIVE | 194302ac6454SAndrew Thompson EHCI_QTD_SET_PID(EHCI_QTD_PID_IN)) : 1944e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_ACTIVE | 194502ac6454SAndrew Thompson EHCI_QTD_SET_PID(EHCI_QTD_PID_OUT)); 194602ac6454SAndrew Thompson 194702ac6454SAndrew Thompson ehci_setup_standard_chain_sub(&temp); 194802ac6454SAndrew Thompson } 194902ac6454SAndrew Thompson 195002ac6454SAndrew Thompson /* check if we should append a status stage */ 195102ac6454SAndrew Thompson 195202ac6454SAndrew Thompson if (xfer->flags_int.control_xfr && 195302ac6454SAndrew Thompson !xfer->flags_int.control_act) { 195402ac6454SAndrew Thompson 195502ac6454SAndrew Thompson /* 195602ac6454SAndrew Thompson * Send a DATA1 message and invert the current endpoint 195702ac6454SAndrew Thompson * direction. 195802ac6454SAndrew Thompson */ 195902ac6454SAndrew Thompson 1960e55e1ebcSAndrew Thompson temp.qtd_status &= htohc32(temp.sc, EHCI_QTD_SET_CERR(3) | 196102ac6454SAndrew Thompson EHCI_QTD_SET_TOGGLE(1)); 196202ac6454SAndrew Thompson temp.qtd_status |= 1963ae60fdfbSAndrew Thompson (UE_GET_DIR(xfer->endpointno) == UE_DIR_OUT) ? 1964e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_ACTIVE | 196502ac6454SAndrew Thompson EHCI_QTD_SET_PID(EHCI_QTD_PID_IN) | 196602ac6454SAndrew Thompson EHCI_QTD_SET_TOGGLE(1)) : 1967e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_QTD_ACTIVE | 196802ac6454SAndrew Thompson EHCI_QTD_SET_PID(EHCI_QTD_PID_OUT) | 196902ac6454SAndrew Thompson EHCI_QTD_SET_TOGGLE(1)); 197002ac6454SAndrew Thompson 197102ac6454SAndrew Thompson temp.len = 0; 197202ac6454SAndrew Thompson temp.pc = NULL; 197302ac6454SAndrew Thompson temp.shortpkt = 0; 19740f7d4548SAndrew Thompson temp.last_frame = 1; 19750f7d4548SAndrew Thompson temp.setup_alt_next = 0; 197602ac6454SAndrew Thompson 197702ac6454SAndrew Thompson ehci_setup_standard_chain_sub(&temp); 197802ac6454SAndrew Thompson } 197902ac6454SAndrew Thompson td = temp.td; 198002ac6454SAndrew Thompson 198102ac6454SAndrew Thompson /* the last TD terminates the transfer: */ 1982e55e1ebcSAndrew Thompson td->qtd_next = htohc32(temp.sc, EHCI_LINK_TERMINATE); 1983e55e1ebcSAndrew Thompson td->qtd_altnext = htohc32(temp.sc, EHCI_LINK_TERMINATE); 198402ac6454SAndrew Thompson 1985a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 198602ac6454SAndrew Thompson 198702ac6454SAndrew Thompson /* must have at least one frame! */ 198802ac6454SAndrew Thompson 198902ac6454SAndrew Thompson xfer->td_transfer_last = td; 199002ac6454SAndrew Thompson 1991b850ecc1SAndrew Thompson #ifdef USB_DEBUG 199202ac6454SAndrew Thompson if (ehcidebug > 8) { 199302ac6454SAndrew Thompson DPRINTF("nexttog=%d; data before transfer:\n", 1994ae60fdfbSAndrew Thompson xfer->endpoint->toggle_next); 199502ac6454SAndrew Thompson ehci_dump_sqtds(temp.sc, 199602ac6454SAndrew Thompson xfer->td_transfer_first); 199702ac6454SAndrew Thompson } 199802ac6454SAndrew Thompson #endif 199902ac6454SAndrew Thompson 2000ae60fdfbSAndrew Thompson methods = xfer->endpoint->methods; 200102ac6454SAndrew Thompson 200202ac6454SAndrew Thompson qh = xfer->qh_start[xfer->flags_int.curr_dma_set]; 200302ac6454SAndrew Thompson 200402ac6454SAndrew Thompson /* the "qh_link" field is filled when the QH is added */ 200502ac6454SAndrew Thompson 200602ac6454SAndrew Thompson qh_endp = 200702ac6454SAndrew Thompson (EHCI_QH_SET_ADDR(xfer->address) | 2008ae60fdfbSAndrew Thompson EHCI_QH_SET_ENDPT(UE_GET_ADDR(xfer->endpointno)) | 200902ac6454SAndrew Thompson EHCI_QH_SET_MPL(xfer->max_packet_size)); 201002ac6454SAndrew Thompson 2011a593f6b8SAndrew Thompson if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_HIGH) { 20122094ecdaSAndrew Thompson qh_endp |= EHCI_QH_SET_EPS(EHCI_QH_SPEED_HIGH); 201302ac6454SAndrew Thompson if (methods != &ehci_device_intr_methods) 201402ac6454SAndrew Thompson qh_endp |= EHCI_QH_SET_NRL(8); 201502ac6454SAndrew Thompson } else { 201602ac6454SAndrew Thompson 2017a593f6b8SAndrew Thompson if (usbd_get_speed(xfer->xroot->udev) == USB_SPEED_FULL) { 20182094ecdaSAndrew Thompson qh_endp |= EHCI_QH_SET_EPS(EHCI_QH_SPEED_FULL); 201902ac6454SAndrew Thompson } else { 20202094ecdaSAndrew Thompson qh_endp |= EHCI_QH_SET_EPS(EHCI_QH_SPEED_LOW); 202102ac6454SAndrew Thompson } 202202ac6454SAndrew Thompson 202302ac6454SAndrew Thompson if (methods == &ehci_device_ctrl_methods) { 202402ac6454SAndrew Thompson qh_endp |= EHCI_QH_CTL; 202502ac6454SAndrew Thompson } 202602ac6454SAndrew Thompson if (methods != &ehci_device_intr_methods) { 202702ac6454SAndrew Thompson /* Only try one time per microframe! */ 202802ac6454SAndrew Thompson qh_endp |= EHCI_QH_SET_NRL(1); 202902ac6454SAndrew Thompson } 203002ac6454SAndrew Thompson } 203102ac6454SAndrew Thompson 20322094ecdaSAndrew Thompson if (temp.auto_data_toggle == 0) { 20332094ecdaSAndrew Thompson /* software computes the data toggle */ 20342094ecdaSAndrew Thompson qh_endp |= EHCI_QH_DTC; 20352094ecdaSAndrew Thompson } 20362094ecdaSAndrew Thompson 2037e55e1ebcSAndrew Thompson qh->qh_endp = htohc32(temp.sc, qh_endp); 203802ac6454SAndrew Thompson 203902ac6454SAndrew Thompson qh_endphub = 204002ac6454SAndrew Thompson (EHCI_QH_SET_MULT(xfer->max_packet_count & 3) | 2041f12c6c29SAndrew Thompson EHCI_QH_SET_CMASK(xfer->endpoint->usb_cmask) | 2042f12c6c29SAndrew Thompson EHCI_QH_SET_SMASK(xfer->endpoint->usb_smask) | 204302ac6454SAndrew Thompson EHCI_QH_SET_HUBA(xfer->xroot->udev->hs_hub_addr) | 204402ac6454SAndrew Thompson EHCI_QH_SET_PORT(xfer->xroot->udev->hs_port_no)); 204502ac6454SAndrew Thompson 2046e55e1ebcSAndrew Thompson qh->qh_endphub = htohc32(temp.sc, qh_endphub); 20472094ecdaSAndrew Thompson qh->qh_curqtd = 0; 204802ac6454SAndrew Thompson 204902ac6454SAndrew Thompson /* fill the overlay qTD */ 205002ac6454SAndrew Thompson 20512094ecdaSAndrew Thompson if (temp.auto_data_toggle && xfer->endpoint->toggle_next) { 205202ac6454SAndrew Thompson /* DATA1 is next */ 20532094ecdaSAndrew Thompson qh->qh_qtd.qtd_status = htohc32(temp.sc, EHCI_QTD_SET_TOGGLE(1)); 20542094ecdaSAndrew Thompson } else { 20552094ecdaSAndrew Thompson qh->qh_qtd.qtd_status = 0; 205602ac6454SAndrew Thompson } 20572094ecdaSAndrew Thompson 205802ac6454SAndrew Thompson td = xfer->td_transfer_first; 205902ac6454SAndrew Thompson 206002ac6454SAndrew Thompson qh->qh_qtd.qtd_next = td->qtd_self; 206102ac6454SAndrew Thompson qh->qh_qtd.qtd_altnext = 2062e55e1ebcSAndrew Thompson htohc32(temp.sc, EHCI_LINK_TERMINATE); 206302ac6454SAndrew Thompson 2064a593f6b8SAndrew Thompson usb_pc_cpu_flush(qh->page_cache); 206502ac6454SAndrew Thompson 2066ec8f3127SAndrew Thompson if (xfer->xroot->udev->flags.self_suspended == 0) { 206702ac6454SAndrew Thompson EHCI_APPEND_QH(qh, *qh_last); 206802ac6454SAndrew Thompson } 206902ac6454SAndrew Thompson } 207002ac6454SAndrew Thompson 207102ac6454SAndrew Thompson static void 207239307315SAndrew Thompson ehci_root_intr(ehci_softc_t *sc) 207302ac6454SAndrew Thompson { 207402ac6454SAndrew Thompson uint16_t i; 207502ac6454SAndrew Thompson uint16_t m; 207602ac6454SAndrew Thompson 207702ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 207802ac6454SAndrew Thompson 207902ac6454SAndrew Thompson /* clear any old interrupt data */ 208039307315SAndrew Thompson memset(sc->sc_hub_idata, 0, sizeof(sc->sc_hub_idata)); 208102ac6454SAndrew Thompson 208202ac6454SAndrew Thompson /* set bits */ 208302ac6454SAndrew Thompson m = (sc->sc_noport + 1); 208402ac6454SAndrew Thompson if (m > (8 * sizeof(sc->sc_hub_idata))) { 208502ac6454SAndrew Thompson m = (8 * sizeof(sc->sc_hub_idata)); 208602ac6454SAndrew Thompson } 208702ac6454SAndrew Thompson for (i = 1; i < m; i++) { 208802ac6454SAndrew Thompson /* pick out CHANGE bits from the status register */ 208902ac6454SAndrew Thompson if (EOREAD4(sc, EHCI_PORTSC(i)) & EHCI_PS_CLEAR) { 209002ac6454SAndrew Thompson sc->sc_hub_idata[i / 8] |= 1 << (i % 8); 209102ac6454SAndrew Thompson DPRINTF("port %d changed\n", i); 209202ac6454SAndrew Thompson } 209302ac6454SAndrew Thompson } 209439307315SAndrew Thompson uhub_root_intr(&sc->sc_bus, sc->sc_hub_idata, 209539307315SAndrew Thompson sizeof(sc->sc_hub_idata)); 209602ac6454SAndrew Thompson } 209702ac6454SAndrew Thompson 209802ac6454SAndrew Thompson static void 2099760bc48eSAndrew Thompson ehci_isoc_fs_done(ehci_softc_t *sc, struct usb_xfer *xfer) 210002ac6454SAndrew Thompson { 210102ac6454SAndrew Thompson uint32_t nframes = xfer->nframes; 210202ac6454SAndrew Thompson uint32_t status; 210302ac6454SAndrew Thompson uint32_t *plen = xfer->frlengths; 210402ac6454SAndrew Thompson uint16_t len = 0; 210502ac6454SAndrew Thompson ehci_sitd_t *td = xfer->td_transfer_first; 210602ac6454SAndrew Thompson ehci_sitd_t **pp_last = &sc->sc_isoc_fs_p_last[xfer->qh_pos]; 210702ac6454SAndrew Thompson 2108ae60fdfbSAndrew Thompson DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n", 2109ae60fdfbSAndrew Thompson xfer, xfer->endpoint); 211002ac6454SAndrew Thompson 211102ac6454SAndrew Thompson while (nframes--) { 211202ac6454SAndrew Thompson if (td == NULL) { 211302ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 211402ac6454SAndrew Thompson __FUNCTION__, __LINE__); 211502ac6454SAndrew Thompson } 211602ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_fs_p_last[EHCI_VIRTUAL_FRAMELIST_COUNT]) { 211702ac6454SAndrew Thompson pp_last = &sc->sc_isoc_fs_p_last[0]; 211802ac6454SAndrew Thompson } 2119b850ecc1SAndrew Thompson #ifdef USB_DEBUG 212002ac6454SAndrew Thompson if (ehcidebug > 15) { 212102ac6454SAndrew Thompson DPRINTF("isoc FS-TD\n"); 212202ac6454SAndrew Thompson ehci_dump_sitd(sc, td); 212302ac6454SAndrew Thompson } 212402ac6454SAndrew Thompson #endif 2125a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 2126e55e1ebcSAndrew Thompson status = hc32toh(sc, td->sitd_status); 212702ac6454SAndrew Thompson 212802ac6454SAndrew Thompson len = EHCI_SITD_GET_LEN(status); 212902ac6454SAndrew Thompson 2130c773c254SAndrew Thompson DPRINTFN(2, "status=0x%08x, rem=%u\n", status, len); 2131c773c254SAndrew Thompson 213202ac6454SAndrew Thompson if (*plen >= len) { 213302ac6454SAndrew Thompson len = *plen - len; 213402ac6454SAndrew Thompson } else { 213502ac6454SAndrew Thompson len = 0; 213602ac6454SAndrew Thompson } 213702ac6454SAndrew Thompson 213802ac6454SAndrew Thompson *plen = len; 213902ac6454SAndrew Thompson 214002ac6454SAndrew Thompson /* remove FS-TD from schedule */ 214102ac6454SAndrew Thompson EHCI_REMOVE_FS_TD(td, *pp_last); 214202ac6454SAndrew Thompson 214302ac6454SAndrew Thompson pp_last++; 214402ac6454SAndrew Thompson plen++; 214502ac6454SAndrew Thompson td = td->obj_next; 214602ac6454SAndrew Thompson } 214702ac6454SAndrew Thompson 214802ac6454SAndrew Thompson xfer->aframes = xfer->nframes; 214902ac6454SAndrew Thompson } 215002ac6454SAndrew Thompson 215102ac6454SAndrew Thompson static void 2152760bc48eSAndrew Thompson ehci_isoc_hs_done(ehci_softc_t *sc, struct usb_xfer *xfer) 215302ac6454SAndrew Thompson { 215402ac6454SAndrew Thompson uint32_t nframes = xfer->nframes; 215502ac6454SAndrew Thompson uint32_t status; 215602ac6454SAndrew Thompson uint32_t *plen = xfer->frlengths; 215702ac6454SAndrew Thompson uint16_t len = 0; 215802ac6454SAndrew Thompson uint8_t td_no = 0; 215902ac6454SAndrew Thompson ehci_itd_t *td = xfer->td_transfer_first; 216002ac6454SAndrew Thompson ehci_itd_t **pp_last = &sc->sc_isoc_hs_p_last[xfer->qh_pos]; 216102ac6454SAndrew Thompson 2162ae60fdfbSAndrew Thompson DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n", 2163ae60fdfbSAndrew Thompson xfer, xfer->endpoint); 216402ac6454SAndrew Thompson 2165883bb300SAndrew Thompson while (nframes) { 216602ac6454SAndrew Thompson if (td == NULL) { 216702ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 216802ac6454SAndrew Thompson __FUNCTION__, __LINE__); 216902ac6454SAndrew Thompson } 217002ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_hs_p_last[EHCI_VIRTUAL_FRAMELIST_COUNT]) { 217102ac6454SAndrew Thompson pp_last = &sc->sc_isoc_hs_p_last[0]; 217202ac6454SAndrew Thompson } 2173b850ecc1SAndrew Thompson #ifdef USB_DEBUG 217402ac6454SAndrew Thompson if (ehcidebug > 15) { 217502ac6454SAndrew Thompson DPRINTF("isoc HS-TD\n"); 217602ac6454SAndrew Thompson ehci_dump_itd(sc, td); 217702ac6454SAndrew Thompson } 217802ac6454SAndrew Thompson #endif 217902ac6454SAndrew Thompson 2180a593f6b8SAndrew Thompson usb_pc_cpu_invalidate(td->page_cache); 2181e55e1ebcSAndrew Thompson status = hc32toh(sc, td->itd_status[td_no]); 218202ac6454SAndrew Thompson 218302ac6454SAndrew Thompson len = EHCI_ITD_GET_LEN(status); 218402ac6454SAndrew Thompson 2185c773c254SAndrew Thompson DPRINTFN(2, "status=0x%08x, len=%u\n", status, len); 2186c773c254SAndrew Thompson 2187f12c6c29SAndrew Thompson if (xfer->endpoint->usb_smask & (1 << td_no)) { 2188883bb300SAndrew Thompson 218902ac6454SAndrew Thompson if (*plen >= len) { 219002ac6454SAndrew Thompson /* 2191883bb300SAndrew Thompson * The length is valid. NOTE: The 2192883bb300SAndrew Thompson * complete length is written back 2193883bb300SAndrew Thompson * into the status field, and not the 2194883bb300SAndrew Thompson * remainder like with other transfer 2195883bb300SAndrew Thompson * descriptor types. 219602ac6454SAndrew Thompson */ 219702ac6454SAndrew Thompson } else { 219802ac6454SAndrew Thompson /* Invalid length - truncate */ 219902ac6454SAndrew Thompson len = 0; 220002ac6454SAndrew Thompson } 220102ac6454SAndrew Thompson 220202ac6454SAndrew Thompson *plen = len; 220302ac6454SAndrew Thompson plen++; 2204883bb300SAndrew Thompson nframes--; 2205883bb300SAndrew Thompson } 2206883bb300SAndrew Thompson 220702ac6454SAndrew Thompson td_no++; 220802ac6454SAndrew Thompson 220902ac6454SAndrew Thompson if ((td_no == 8) || (nframes == 0)) { 221002ac6454SAndrew Thompson /* remove HS-TD from schedule */ 221102ac6454SAndrew Thompson EHCI_REMOVE_HS_TD(td, *pp_last); 221202ac6454SAndrew Thompson pp_last++; 221302ac6454SAndrew Thompson 221402ac6454SAndrew Thompson td_no = 0; 221502ac6454SAndrew Thompson td = td->obj_next; 221602ac6454SAndrew Thompson } 221702ac6454SAndrew Thompson } 221802ac6454SAndrew Thompson xfer->aframes = xfer->nframes; 221902ac6454SAndrew Thompson } 222002ac6454SAndrew Thompson 222102ac6454SAndrew Thompson /* NOTE: "done" can be run two times in a row, 222202ac6454SAndrew Thompson * from close and from interrupt 222302ac6454SAndrew Thompson */ 222402ac6454SAndrew Thompson static void 2225e0a69b51SAndrew Thompson ehci_device_done(struct usb_xfer *xfer, usb_error_t error) 222602ac6454SAndrew Thompson { 2227ae60fdfbSAndrew Thompson struct usb_pipe_methods *methods = xfer->endpoint->methods; 222802ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 222902ac6454SAndrew Thompson 223002ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 223102ac6454SAndrew Thompson 2232ae60fdfbSAndrew Thompson DPRINTFN(2, "xfer=%p, endpoint=%p, error=%d\n", 2233ae60fdfbSAndrew Thompson xfer, xfer->endpoint, error); 223402ac6454SAndrew Thompson 223502ac6454SAndrew Thompson if ((methods == &ehci_device_bulk_methods) || 223602ac6454SAndrew Thompson (methods == &ehci_device_ctrl_methods)) { 2237b850ecc1SAndrew Thompson #ifdef USB_DEBUG 223802ac6454SAndrew Thompson if (ehcidebug > 8) { 223902ac6454SAndrew Thompson DPRINTF("nexttog=%d; data after transfer:\n", 2240ae60fdfbSAndrew Thompson xfer->endpoint->toggle_next); 224102ac6454SAndrew Thompson ehci_dump_sqtds(sc, 224202ac6454SAndrew Thompson xfer->td_transfer_first); 224302ac6454SAndrew Thompson } 224402ac6454SAndrew Thompson #endif 224502ac6454SAndrew Thompson 224602ac6454SAndrew Thompson EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 224702ac6454SAndrew Thompson sc->sc_async_p_last); 224802ac6454SAndrew Thompson } 224902ac6454SAndrew Thompson if (methods == &ehci_device_intr_methods) { 225002ac6454SAndrew Thompson EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 225102ac6454SAndrew Thompson sc->sc_intr_p_last[xfer->qh_pos]); 225202ac6454SAndrew Thompson } 225302ac6454SAndrew Thompson /* 225402ac6454SAndrew Thompson * Only finish isochronous transfers once which will update 225502ac6454SAndrew Thompson * "xfer->frlengths". 225602ac6454SAndrew Thompson */ 225702ac6454SAndrew Thompson if (xfer->td_transfer_first && 225802ac6454SAndrew Thompson xfer->td_transfer_last) { 225902ac6454SAndrew Thompson if (methods == &ehci_device_isoc_fs_methods) { 226002ac6454SAndrew Thompson ehci_isoc_fs_done(sc, xfer); 226102ac6454SAndrew Thompson } 226202ac6454SAndrew Thompson if (methods == &ehci_device_isoc_hs_methods) { 226302ac6454SAndrew Thompson ehci_isoc_hs_done(sc, xfer); 226402ac6454SAndrew Thompson } 226502ac6454SAndrew Thompson xfer->td_transfer_first = NULL; 226602ac6454SAndrew Thompson xfer->td_transfer_last = NULL; 226702ac6454SAndrew Thompson } 226802ac6454SAndrew Thompson /* dequeue transfer and start next transfer */ 2269a593f6b8SAndrew Thompson usbd_transfer_done(xfer, error); 227002ac6454SAndrew Thompson } 227102ac6454SAndrew Thompson 227202ac6454SAndrew Thompson /*------------------------------------------------------------------------* 227302ac6454SAndrew Thompson * ehci bulk support 227402ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 227502ac6454SAndrew Thompson static void 2276760bc48eSAndrew Thompson ehci_device_bulk_open(struct usb_xfer *xfer) 227702ac6454SAndrew Thompson { 227802ac6454SAndrew Thompson return; 227902ac6454SAndrew Thompson } 228002ac6454SAndrew Thompson 228102ac6454SAndrew Thompson static void 2282760bc48eSAndrew Thompson ehci_device_bulk_close(struct usb_xfer *xfer) 228302ac6454SAndrew Thompson { 228402ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_CANCELLED); 228502ac6454SAndrew Thompson } 228602ac6454SAndrew Thompson 228702ac6454SAndrew Thompson static void 2288760bc48eSAndrew Thompson ehci_device_bulk_enter(struct usb_xfer *xfer) 228902ac6454SAndrew Thompson { 229002ac6454SAndrew Thompson return; 229102ac6454SAndrew Thompson } 229202ac6454SAndrew Thompson 229302ac6454SAndrew Thompson static void 2294760bc48eSAndrew Thompson ehci_device_bulk_start(struct usb_xfer *xfer) 229502ac6454SAndrew Thompson { 229602ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 2297d1864afbSAndrew Thompson uint32_t temp; 229802ac6454SAndrew Thompson 229902ac6454SAndrew Thompson /* setup TD's and QH */ 230002ac6454SAndrew Thompson ehci_setup_standard_chain(xfer, &sc->sc_async_p_last); 230102ac6454SAndrew Thompson 230202ac6454SAndrew Thompson /* put transfer on interrupt queue */ 230302ac6454SAndrew Thompson ehci_transfer_intr_enqueue(xfer); 2304d1864afbSAndrew Thompson 2305cf223a88SAndrew Thompson /* 2306cf223a88SAndrew Thompson * XXX Certain nVidia chipsets choke when using the IAAD 2307cf223a88SAndrew Thompson * feature too frequently. 2308cf223a88SAndrew Thompson */ 2309cf223a88SAndrew Thompson if (sc->sc_flags & EHCI_SCFLG_IAADBUG) 2310cf223a88SAndrew Thompson return; 2311cf223a88SAndrew Thompson 2312d1864afbSAndrew Thompson /* XXX Performance quirk: Some Host Controllers have a too low 2313d1864afbSAndrew Thompson * interrupt rate. Issue an IAAD to stimulate the Host 2314d1864afbSAndrew Thompson * Controller after queueing the BULK transfer. 2315d1864afbSAndrew Thompson */ 2316d1864afbSAndrew Thompson temp = EOREAD4(sc, EHCI_USBCMD); 2317d1864afbSAndrew Thompson if (!(temp & EHCI_CMD_IAAD)) 2318d1864afbSAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, temp | EHCI_CMD_IAAD); 231902ac6454SAndrew Thompson } 232002ac6454SAndrew Thompson 2321760bc48eSAndrew Thompson struct usb_pipe_methods ehci_device_bulk_methods = 232202ac6454SAndrew Thompson { 232302ac6454SAndrew Thompson .open = ehci_device_bulk_open, 232402ac6454SAndrew Thompson .close = ehci_device_bulk_close, 232502ac6454SAndrew Thompson .enter = ehci_device_bulk_enter, 232602ac6454SAndrew Thompson .start = ehci_device_bulk_start, 232702ac6454SAndrew Thompson }; 232802ac6454SAndrew Thompson 232902ac6454SAndrew Thompson /*------------------------------------------------------------------------* 233002ac6454SAndrew Thompson * ehci control support 233102ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 233202ac6454SAndrew Thompson static void 2333760bc48eSAndrew Thompson ehci_device_ctrl_open(struct usb_xfer *xfer) 233402ac6454SAndrew Thompson { 233502ac6454SAndrew Thompson return; 233602ac6454SAndrew Thompson } 233702ac6454SAndrew Thompson 233802ac6454SAndrew Thompson static void 2339760bc48eSAndrew Thompson ehci_device_ctrl_close(struct usb_xfer *xfer) 234002ac6454SAndrew Thompson { 234102ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_CANCELLED); 234202ac6454SAndrew Thompson } 234302ac6454SAndrew Thompson 234402ac6454SAndrew Thompson static void 2345760bc48eSAndrew Thompson ehci_device_ctrl_enter(struct usb_xfer *xfer) 234602ac6454SAndrew Thompson { 234702ac6454SAndrew Thompson return; 234802ac6454SAndrew Thompson } 234902ac6454SAndrew Thompson 235002ac6454SAndrew Thompson static void 2351760bc48eSAndrew Thompson ehci_device_ctrl_start(struct usb_xfer *xfer) 235202ac6454SAndrew Thompson { 235302ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 235402ac6454SAndrew Thompson 235502ac6454SAndrew Thompson /* setup TD's and QH */ 235602ac6454SAndrew Thompson ehci_setup_standard_chain(xfer, &sc->sc_async_p_last); 235702ac6454SAndrew Thompson 235802ac6454SAndrew Thompson /* put transfer on interrupt queue */ 235902ac6454SAndrew Thompson ehci_transfer_intr_enqueue(xfer); 236002ac6454SAndrew Thompson } 236102ac6454SAndrew Thompson 2362760bc48eSAndrew Thompson struct usb_pipe_methods ehci_device_ctrl_methods = 236302ac6454SAndrew Thompson { 236402ac6454SAndrew Thompson .open = ehci_device_ctrl_open, 236502ac6454SAndrew Thompson .close = ehci_device_ctrl_close, 236602ac6454SAndrew Thompson .enter = ehci_device_ctrl_enter, 236702ac6454SAndrew Thompson .start = ehci_device_ctrl_start, 236802ac6454SAndrew Thompson }; 236902ac6454SAndrew Thompson 237002ac6454SAndrew Thompson /*------------------------------------------------------------------------* 237102ac6454SAndrew Thompson * ehci interrupt support 237202ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 237302ac6454SAndrew Thompson static void 2374760bc48eSAndrew Thompson ehci_device_intr_open(struct usb_xfer *xfer) 237502ac6454SAndrew Thompson { 237602ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 237702ac6454SAndrew Thompson uint16_t best; 237802ac6454SAndrew Thompson uint16_t bit; 237902ac6454SAndrew Thompson uint16_t x; 238002ac6454SAndrew Thompson 2381f12c6c29SAndrew Thompson usb_hs_bandwidth_alloc(xfer); 238202ac6454SAndrew Thompson 238302ac6454SAndrew Thompson /* 238402ac6454SAndrew Thompson * Find the best QH position corresponding to the given interval: 238502ac6454SAndrew Thompson */ 238602ac6454SAndrew Thompson 238702ac6454SAndrew Thompson best = 0; 238802ac6454SAndrew Thompson bit = EHCI_VIRTUAL_FRAMELIST_COUNT / 2; 238902ac6454SAndrew Thompson while (bit) { 239002ac6454SAndrew Thompson if (xfer->interval >= bit) { 239102ac6454SAndrew Thompson x = bit; 239202ac6454SAndrew Thompson best = bit; 239302ac6454SAndrew Thompson while (x & bit) { 239402ac6454SAndrew Thompson if (sc->sc_intr_stat[x] < 239502ac6454SAndrew Thompson sc->sc_intr_stat[best]) { 239602ac6454SAndrew Thompson best = x; 239702ac6454SAndrew Thompson } 239802ac6454SAndrew Thompson x++; 239902ac6454SAndrew Thompson } 240002ac6454SAndrew Thompson break; 240102ac6454SAndrew Thompson } 240202ac6454SAndrew Thompson bit >>= 1; 240302ac6454SAndrew Thompson } 240402ac6454SAndrew Thompson 240502ac6454SAndrew Thompson sc->sc_intr_stat[best]++; 240602ac6454SAndrew Thompson xfer->qh_pos = best; 240702ac6454SAndrew Thompson 240802ac6454SAndrew Thompson DPRINTFN(3, "best=%d interval=%d\n", 240902ac6454SAndrew Thompson best, xfer->interval); 241002ac6454SAndrew Thompson } 241102ac6454SAndrew Thompson 241202ac6454SAndrew Thompson static void 2413760bc48eSAndrew Thompson ehci_device_intr_close(struct usb_xfer *xfer) 241402ac6454SAndrew Thompson { 241502ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 241602ac6454SAndrew Thompson 241702ac6454SAndrew Thompson sc->sc_intr_stat[xfer->qh_pos]--; 241802ac6454SAndrew Thompson 241902ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_CANCELLED); 2420f12c6c29SAndrew Thompson 2421f12c6c29SAndrew Thompson /* bandwidth must be freed after device done */ 2422f12c6c29SAndrew Thompson usb_hs_bandwidth_free(xfer); 242302ac6454SAndrew Thompson } 242402ac6454SAndrew Thompson 242502ac6454SAndrew Thompson static void 2426760bc48eSAndrew Thompson ehci_device_intr_enter(struct usb_xfer *xfer) 242702ac6454SAndrew Thompson { 242802ac6454SAndrew Thompson return; 242902ac6454SAndrew Thompson } 243002ac6454SAndrew Thompson 243102ac6454SAndrew Thompson static void 2432760bc48eSAndrew Thompson ehci_device_intr_start(struct usb_xfer *xfer) 243302ac6454SAndrew Thompson { 243402ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 243502ac6454SAndrew Thompson 243602ac6454SAndrew Thompson /* setup TD's and QH */ 243702ac6454SAndrew Thompson ehci_setup_standard_chain(xfer, &sc->sc_intr_p_last[xfer->qh_pos]); 243802ac6454SAndrew Thompson 243902ac6454SAndrew Thompson /* put transfer on interrupt queue */ 244002ac6454SAndrew Thompson ehci_transfer_intr_enqueue(xfer); 244102ac6454SAndrew Thompson } 244202ac6454SAndrew Thompson 2443760bc48eSAndrew Thompson struct usb_pipe_methods ehci_device_intr_methods = 244402ac6454SAndrew Thompson { 244502ac6454SAndrew Thompson .open = ehci_device_intr_open, 244602ac6454SAndrew Thompson .close = ehci_device_intr_close, 244702ac6454SAndrew Thompson .enter = ehci_device_intr_enter, 244802ac6454SAndrew Thompson .start = ehci_device_intr_start, 244902ac6454SAndrew Thompson }; 245002ac6454SAndrew Thompson 245102ac6454SAndrew Thompson /*------------------------------------------------------------------------* 245202ac6454SAndrew Thompson * ehci full speed isochronous support 245302ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 245402ac6454SAndrew Thompson static void 2455760bc48eSAndrew Thompson ehci_device_isoc_fs_open(struct usb_xfer *xfer) 245602ac6454SAndrew Thompson { 245702ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 245802ac6454SAndrew Thompson ehci_sitd_t *td; 245902ac6454SAndrew Thompson uint32_t sitd_portaddr; 246002ac6454SAndrew Thompson uint8_t ds; 246102ac6454SAndrew Thompson 246202ac6454SAndrew Thompson sitd_portaddr = 246302ac6454SAndrew Thompson EHCI_SITD_SET_ADDR(xfer->address) | 2464ae60fdfbSAndrew Thompson EHCI_SITD_SET_ENDPT(UE_GET_ADDR(xfer->endpointno)) | 246502ac6454SAndrew Thompson EHCI_SITD_SET_HUBA(xfer->xroot->udev->hs_hub_addr) | 246602ac6454SAndrew Thompson EHCI_SITD_SET_PORT(xfer->xroot->udev->hs_port_no); 246702ac6454SAndrew Thompson 2468ae60fdfbSAndrew Thompson if (UE_GET_DIR(xfer->endpointno) == UE_DIR_IN) { 246902ac6454SAndrew Thompson sitd_portaddr |= EHCI_SITD_SET_DIR_IN; 247002ac6454SAndrew Thompson } 2471e55e1ebcSAndrew Thompson sitd_portaddr = htohc32(sc, sitd_portaddr); 247202ac6454SAndrew Thompson 247302ac6454SAndrew Thompson /* initialize all TD's */ 247402ac6454SAndrew Thompson 247502ac6454SAndrew Thompson for (ds = 0; ds != 2; ds++) { 247602ac6454SAndrew Thompson 247702ac6454SAndrew Thompson for (td = xfer->td_start[ds]; td; td = td->obj_next) { 247802ac6454SAndrew Thompson 247902ac6454SAndrew Thompson td->sitd_portaddr = sitd_portaddr; 248002ac6454SAndrew Thompson 248102ac6454SAndrew Thompson /* 248202ac6454SAndrew Thompson * TODO: make some kind of automatic 248302ac6454SAndrew Thompson * SMASK/CMASK selection based on micro-frame 248402ac6454SAndrew Thompson * usage 248502ac6454SAndrew Thompson * 248602ac6454SAndrew Thompson * micro-frame usage (8 microframes per 1ms) 248702ac6454SAndrew Thompson */ 2488e55e1ebcSAndrew Thompson td->sitd_back = htohc32(sc, EHCI_LINK_TERMINATE); 248902ac6454SAndrew Thompson 2490a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 249102ac6454SAndrew Thompson } 249202ac6454SAndrew Thompson } 249302ac6454SAndrew Thompson } 249402ac6454SAndrew Thompson 249502ac6454SAndrew Thompson static void 2496760bc48eSAndrew Thompson ehci_device_isoc_fs_close(struct usb_xfer *xfer) 249702ac6454SAndrew Thompson { 249802ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_CANCELLED); 249902ac6454SAndrew Thompson } 250002ac6454SAndrew Thompson 250102ac6454SAndrew Thompson static void 2502760bc48eSAndrew Thompson ehci_device_isoc_fs_enter(struct usb_xfer *xfer) 250302ac6454SAndrew Thompson { 2504760bc48eSAndrew Thompson struct usb_page_search buf_res; 250502ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 2506760bc48eSAndrew Thompson struct usb_fs_isoc_schedule *fss_start; 2507760bc48eSAndrew Thompson struct usb_fs_isoc_schedule *fss_end; 2508760bc48eSAndrew Thompson struct usb_fs_isoc_schedule *fss; 250902ac6454SAndrew Thompson ehci_sitd_t *td; 251002ac6454SAndrew Thompson ehci_sitd_t *td_last = NULL; 251102ac6454SAndrew Thompson ehci_sitd_t **pp_last; 251202ac6454SAndrew Thompson uint32_t *plen; 251302ac6454SAndrew Thompson uint32_t buf_offset; 251402ac6454SAndrew Thompson uint32_t nframes; 251502ac6454SAndrew Thompson uint32_t temp; 251602ac6454SAndrew Thompson uint32_t sitd_mask; 251702ac6454SAndrew Thompson uint16_t tlen; 251802ac6454SAndrew Thompson uint8_t sa; 251902ac6454SAndrew Thompson uint8_t sb; 252002ac6454SAndrew Thompson uint8_t error; 252102ac6454SAndrew Thompson 2522b850ecc1SAndrew Thompson #ifdef USB_DEBUG 252302ac6454SAndrew Thompson uint8_t once = 1; 252402ac6454SAndrew Thompson 252502ac6454SAndrew Thompson #endif 252602ac6454SAndrew Thompson 252702ac6454SAndrew Thompson DPRINTFN(6, "xfer=%p next=%d nframes=%d\n", 2528ae60fdfbSAndrew Thompson xfer, xfer->endpoint->isoc_next, xfer->nframes); 252902ac6454SAndrew Thompson 253002ac6454SAndrew Thompson /* get the current frame index */ 253102ac6454SAndrew Thompson 253202ac6454SAndrew Thompson nframes = EOREAD4(sc, EHCI_FRINDEX) / 8; 253302ac6454SAndrew Thompson 253402ac6454SAndrew Thompson /* 253502ac6454SAndrew Thompson * check if the frame index is within the window where the frames 253602ac6454SAndrew Thompson * will be inserted 253702ac6454SAndrew Thompson */ 2538ae60fdfbSAndrew Thompson buf_offset = (nframes - xfer->endpoint->isoc_next) & 253902ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 254002ac6454SAndrew Thompson 2541ae60fdfbSAndrew Thompson if ((xfer->endpoint->is_synced == 0) || 254202ac6454SAndrew Thompson (buf_offset < xfer->nframes)) { 254302ac6454SAndrew Thompson /* 254402ac6454SAndrew Thompson * If there is data underflow or the pipe queue is empty we 254502ac6454SAndrew Thompson * schedule the transfer a few frames ahead of the current 254602ac6454SAndrew Thompson * frame position. Else two isochronous transfers might 254702ac6454SAndrew Thompson * overlap. 254802ac6454SAndrew Thompson */ 2549ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (nframes + 3) & 255002ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 2551ae60fdfbSAndrew Thompson xfer->endpoint->is_synced = 1; 2552ae60fdfbSAndrew Thompson DPRINTFN(3, "start next=%d\n", xfer->endpoint->isoc_next); 255302ac6454SAndrew Thompson } 255402ac6454SAndrew Thompson /* 255502ac6454SAndrew Thompson * compute how many milliseconds the insertion is ahead of the 255602ac6454SAndrew Thompson * current frame position: 255702ac6454SAndrew Thompson */ 2558ae60fdfbSAndrew Thompson buf_offset = (xfer->endpoint->isoc_next - nframes) & 255902ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 256002ac6454SAndrew Thompson 256102ac6454SAndrew Thompson /* 256202ac6454SAndrew Thompson * pre-compute when the isochronous transfer will be finished: 256302ac6454SAndrew Thompson */ 256402ac6454SAndrew Thompson xfer->isoc_time_complete = 2565a593f6b8SAndrew Thompson usbd_fs_isoc_schedule_isoc_time_expand 256602ac6454SAndrew Thompson (xfer->xroot->udev, &fss_start, &fss_end, nframes) + buf_offset + 256702ac6454SAndrew Thompson xfer->nframes; 256802ac6454SAndrew Thompson 256902ac6454SAndrew Thompson /* get the real number of frames */ 257002ac6454SAndrew Thompson 257102ac6454SAndrew Thompson nframes = xfer->nframes; 257202ac6454SAndrew Thompson 257302ac6454SAndrew Thompson buf_offset = 0; 257402ac6454SAndrew Thompson 257502ac6454SAndrew Thompson plen = xfer->frlengths; 257602ac6454SAndrew Thompson 257702ac6454SAndrew Thompson /* toggle the DMA set we are using */ 257802ac6454SAndrew Thompson xfer->flags_int.curr_dma_set ^= 1; 257902ac6454SAndrew Thompson 258002ac6454SAndrew Thompson /* get next DMA set */ 258102ac6454SAndrew Thompson td = xfer->td_start[xfer->flags_int.curr_dma_set]; 258202ac6454SAndrew Thompson xfer->td_transfer_first = td; 258302ac6454SAndrew Thompson 2584ae60fdfbSAndrew Thompson pp_last = &sc->sc_isoc_fs_p_last[xfer->endpoint->isoc_next]; 258502ac6454SAndrew Thompson 258602ac6454SAndrew Thompson /* store starting position */ 258702ac6454SAndrew Thompson 2588ae60fdfbSAndrew Thompson xfer->qh_pos = xfer->endpoint->isoc_next; 258902ac6454SAndrew Thompson 259002ac6454SAndrew Thompson fss = fss_start + (xfer->qh_pos % USB_ISOC_TIME_MAX); 259102ac6454SAndrew Thompson 259202ac6454SAndrew Thompson while (nframes--) { 259302ac6454SAndrew Thompson if (td == NULL) { 259402ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 259502ac6454SAndrew Thompson __FUNCTION__, __LINE__); 259602ac6454SAndrew Thompson } 259702ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_fs_p_last[EHCI_VIRTUAL_FRAMELIST_COUNT]) { 259802ac6454SAndrew Thompson pp_last = &sc->sc_isoc_fs_p_last[0]; 259902ac6454SAndrew Thompson } 260002ac6454SAndrew Thompson if (fss >= fss_end) { 260102ac6454SAndrew Thompson fss = fss_start; 260202ac6454SAndrew Thompson } 260302ac6454SAndrew Thompson /* reuse sitd_portaddr and sitd_back from last transfer */ 260402ac6454SAndrew Thompson 260502ac6454SAndrew Thompson if (*plen > xfer->max_frame_size) { 2606b850ecc1SAndrew Thompson #ifdef USB_DEBUG 260702ac6454SAndrew Thompson if (once) { 260802ac6454SAndrew Thompson once = 0; 260902ac6454SAndrew Thompson printf("%s: frame length(%d) exceeds %d " 261002ac6454SAndrew Thompson "bytes (frame truncated)\n", 261102ac6454SAndrew Thompson __FUNCTION__, *plen, 261202ac6454SAndrew Thompson xfer->max_frame_size); 261302ac6454SAndrew Thompson } 261402ac6454SAndrew Thompson #endif 261502ac6454SAndrew Thompson *plen = xfer->max_frame_size; 261602ac6454SAndrew Thompson } 261702ac6454SAndrew Thompson /* 261802ac6454SAndrew Thompson * We currently don't care if the ISOCHRONOUS schedule is 261902ac6454SAndrew Thompson * full! 262002ac6454SAndrew Thompson */ 2621a593f6b8SAndrew Thompson error = usbd_fs_isoc_schedule_alloc(fss, &sa, *plen); 262202ac6454SAndrew Thompson if (error) { 262302ac6454SAndrew Thompson /* 262402ac6454SAndrew Thompson * The FULL speed schedule is FULL! Set length 262502ac6454SAndrew Thompson * to zero. 262602ac6454SAndrew Thompson */ 262702ac6454SAndrew Thompson *plen = 0; 262802ac6454SAndrew Thompson } 262902ac6454SAndrew Thompson if (*plen) { 263002ac6454SAndrew Thompson /* 2631a593f6b8SAndrew Thompson * only call "usbd_get_page()" when we have a 263202ac6454SAndrew Thompson * non-zero length 263302ac6454SAndrew Thompson */ 2634a593f6b8SAndrew Thompson usbd_get_page(xfer->frbuffers, buf_offset, &buf_res); 2635e55e1ebcSAndrew Thompson td->sitd_bp[0] = htohc32(sc, buf_res.physaddr); 263602ac6454SAndrew Thompson buf_offset += *plen; 263702ac6454SAndrew Thompson /* 263802ac6454SAndrew Thompson * NOTE: We need to subtract one from the offset so 263902ac6454SAndrew Thompson * that we are on a valid page! 264002ac6454SAndrew Thompson */ 2641a593f6b8SAndrew Thompson usbd_get_page(xfer->frbuffers, buf_offset - 1, 264202ac6454SAndrew Thompson &buf_res); 264302ac6454SAndrew Thompson temp = buf_res.physaddr & ~0xFFF; 264402ac6454SAndrew Thompson } else { 264502ac6454SAndrew Thompson td->sitd_bp[0] = 0; 264602ac6454SAndrew Thompson temp = 0; 264702ac6454SAndrew Thompson } 264802ac6454SAndrew Thompson 2649ae60fdfbSAndrew Thompson if (UE_GET_DIR(xfer->endpointno) == UE_DIR_OUT) { 265002ac6454SAndrew Thompson tlen = *plen; 265102ac6454SAndrew Thompson if (tlen <= 188) { 265202ac6454SAndrew Thompson temp |= 1; /* T-count = 1, TP = ALL */ 265302ac6454SAndrew Thompson tlen = 1; 265402ac6454SAndrew Thompson } else { 265502ac6454SAndrew Thompson tlen += 187; 265602ac6454SAndrew Thompson tlen /= 188; 265702ac6454SAndrew Thompson temp |= tlen; /* T-count = [1..6] */ 265802ac6454SAndrew Thompson temp |= 8; /* TP = Begin */ 265902ac6454SAndrew Thompson } 266002ac6454SAndrew Thompson 266102ac6454SAndrew Thompson tlen += sa; 266202ac6454SAndrew Thompson 266302ac6454SAndrew Thompson if (tlen >= 8) { 266402ac6454SAndrew Thompson sb = 0; 266502ac6454SAndrew Thompson } else { 266602ac6454SAndrew Thompson sb = (1 << tlen); 266702ac6454SAndrew Thompson } 266802ac6454SAndrew Thompson 266902ac6454SAndrew Thompson sa = (1 << sa); 267002ac6454SAndrew Thompson sa = (sb - sa) & 0x3F; 267102ac6454SAndrew Thompson sb = 0; 267202ac6454SAndrew Thompson } else { 267302ac6454SAndrew Thompson sb = (-(4 << sa)) & 0xFE; 267402ac6454SAndrew Thompson sa = (1 << sa) & 0x3F; 267502ac6454SAndrew Thompson } 267602ac6454SAndrew Thompson 267702ac6454SAndrew Thompson sitd_mask = (EHCI_SITD_SET_SMASK(sa) | 267802ac6454SAndrew Thompson EHCI_SITD_SET_CMASK(sb)); 267902ac6454SAndrew Thompson 2680e55e1ebcSAndrew Thompson td->sitd_bp[1] = htohc32(sc, temp); 268102ac6454SAndrew Thompson 2682e55e1ebcSAndrew Thompson td->sitd_mask = htohc32(sc, sitd_mask); 268302ac6454SAndrew Thompson 268402ac6454SAndrew Thompson if (nframes == 0) { 2685e55e1ebcSAndrew Thompson td->sitd_status = htohc32(sc, 26865f128668SAndrew Thompson EHCI_SITD_IOC | 268702ac6454SAndrew Thompson EHCI_SITD_ACTIVE | 268802ac6454SAndrew Thompson EHCI_SITD_SET_LEN(*plen)); 268902ac6454SAndrew Thompson } else { 2690e55e1ebcSAndrew Thompson td->sitd_status = htohc32(sc, 26915f128668SAndrew Thompson EHCI_SITD_ACTIVE | 269202ac6454SAndrew Thompson EHCI_SITD_SET_LEN(*plen)); 269302ac6454SAndrew Thompson } 2694a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 269502ac6454SAndrew Thompson 2696b850ecc1SAndrew Thompson #ifdef USB_DEBUG 269702ac6454SAndrew Thompson if (ehcidebug > 15) { 269802ac6454SAndrew Thompson DPRINTF("FS-TD %d\n", nframes); 269902ac6454SAndrew Thompson ehci_dump_sitd(sc, td); 270002ac6454SAndrew Thompson } 270102ac6454SAndrew Thompson #endif 270202ac6454SAndrew Thompson /* insert TD into schedule */ 270302ac6454SAndrew Thompson EHCI_APPEND_FS_TD(td, *pp_last); 270402ac6454SAndrew Thompson pp_last++; 270502ac6454SAndrew Thompson 270602ac6454SAndrew Thompson plen++; 270702ac6454SAndrew Thompson fss++; 270802ac6454SAndrew Thompson td_last = td; 270902ac6454SAndrew Thompson td = td->obj_next; 271002ac6454SAndrew Thompson } 271102ac6454SAndrew Thompson 271202ac6454SAndrew Thompson xfer->td_transfer_last = td_last; 271302ac6454SAndrew Thompson 271402ac6454SAndrew Thompson /* update isoc_next */ 2715ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (pp_last - &sc->sc_isoc_fs_p_last[0]) & 271602ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 271702ac6454SAndrew Thompson } 271802ac6454SAndrew Thompson 271902ac6454SAndrew Thompson static void 2720760bc48eSAndrew Thompson ehci_device_isoc_fs_start(struct usb_xfer *xfer) 272102ac6454SAndrew Thompson { 272202ac6454SAndrew Thompson /* put transfer on interrupt queue */ 272302ac6454SAndrew Thompson ehci_transfer_intr_enqueue(xfer); 272402ac6454SAndrew Thompson } 272502ac6454SAndrew Thompson 2726760bc48eSAndrew Thompson struct usb_pipe_methods ehci_device_isoc_fs_methods = 272702ac6454SAndrew Thompson { 272802ac6454SAndrew Thompson .open = ehci_device_isoc_fs_open, 272902ac6454SAndrew Thompson .close = ehci_device_isoc_fs_close, 273002ac6454SAndrew Thompson .enter = ehci_device_isoc_fs_enter, 273102ac6454SAndrew Thompson .start = ehci_device_isoc_fs_start, 273202ac6454SAndrew Thompson }; 273302ac6454SAndrew Thompson 273402ac6454SAndrew Thompson /*------------------------------------------------------------------------* 273502ac6454SAndrew Thompson * ehci high speed isochronous support 273602ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 273702ac6454SAndrew Thompson static void 2738760bc48eSAndrew Thompson ehci_device_isoc_hs_open(struct usb_xfer *xfer) 273902ac6454SAndrew Thompson { 274002ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 274102ac6454SAndrew Thompson ehci_itd_t *td; 274202ac6454SAndrew Thompson uint32_t temp; 274302ac6454SAndrew Thompson uint8_t ds; 2744883bb300SAndrew Thompson 2745f12c6c29SAndrew Thompson usb_hs_bandwidth_alloc(xfer); 274602ac6454SAndrew Thompson 274702ac6454SAndrew Thompson /* initialize all TD's */ 274802ac6454SAndrew Thompson 274902ac6454SAndrew Thompson for (ds = 0; ds != 2; ds++) { 275002ac6454SAndrew Thompson 275102ac6454SAndrew Thompson for (td = xfer->td_start[ds]; td; td = td->obj_next) { 275202ac6454SAndrew Thompson 275302ac6454SAndrew Thompson /* set TD inactive */ 275402ac6454SAndrew Thompson td->itd_status[0] = 0; 275502ac6454SAndrew Thompson td->itd_status[1] = 0; 275602ac6454SAndrew Thompson td->itd_status[2] = 0; 275702ac6454SAndrew Thompson td->itd_status[3] = 0; 275802ac6454SAndrew Thompson td->itd_status[4] = 0; 275902ac6454SAndrew Thompson td->itd_status[5] = 0; 276002ac6454SAndrew Thompson td->itd_status[6] = 0; 276102ac6454SAndrew Thompson td->itd_status[7] = 0; 276202ac6454SAndrew Thompson 276302ac6454SAndrew Thompson /* set endpoint and address */ 2764e55e1ebcSAndrew Thompson td->itd_bp[0] = htohc32(sc, 27655f128668SAndrew Thompson EHCI_ITD_SET_ADDR(xfer->address) | 2766ae60fdfbSAndrew Thompson EHCI_ITD_SET_ENDPT(UE_GET_ADDR(xfer->endpointno))); 276702ac6454SAndrew Thompson 276802ac6454SAndrew Thompson temp = 276902ac6454SAndrew Thompson EHCI_ITD_SET_MPL(xfer->max_packet_size & 0x7FF); 277002ac6454SAndrew Thompson 277102ac6454SAndrew Thompson /* set direction */ 2772ae60fdfbSAndrew Thompson if (UE_GET_DIR(xfer->endpointno) == UE_DIR_IN) { 277302ac6454SAndrew Thompson temp |= EHCI_ITD_SET_DIR_IN; 277402ac6454SAndrew Thompson } 277502ac6454SAndrew Thompson /* set maximum packet size */ 2776e55e1ebcSAndrew Thompson td->itd_bp[1] = htohc32(sc, temp); 277702ac6454SAndrew Thompson 277802ac6454SAndrew Thompson /* set transfer multiplier */ 2779e55e1ebcSAndrew Thompson td->itd_bp[2] = htohc32(sc, xfer->max_packet_count & 3); 278002ac6454SAndrew Thompson 2781a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 278202ac6454SAndrew Thompson } 278302ac6454SAndrew Thompson } 278402ac6454SAndrew Thompson } 278502ac6454SAndrew Thompson 278602ac6454SAndrew Thompson static void 2787760bc48eSAndrew Thompson ehci_device_isoc_hs_close(struct usb_xfer *xfer) 278802ac6454SAndrew Thompson { 278902ac6454SAndrew Thompson ehci_device_done(xfer, USB_ERR_CANCELLED); 2790f12c6c29SAndrew Thompson 2791f12c6c29SAndrew Thompson /* bandwidth must be freed after device done */ 2792f12c6c29SAndrew Thompson usb_hs_bandwidth_free(xfer); 279302ac6454SAndrew Thompson } 279402ac6454SAndrew Thompson 279502ac6454SAndrew Thompson static void 2796760bc48eSAndrew Thompson ehci_device_isoc_hs_enter(struct usb_xfer *xfer) 279702ac6454SAndrew Thompson { 2798760bc48eSAndrew Thompson struct usb_page_search buf_res; 279902ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(xfer->xroot->bus); 280002ac6454SAndrew Thompson ehci_itd_t *td; 280102ac6454SAndrew Thompson ehci_itd_t *td_last = NULL; 280202ac6454SAndrew Thompson ehci_itd_t **pp_last; 280302ac6454SAndrew Thompson bus_size_t page_addr; 280402ac6454SAndrew Thompson uint32_t *plen; 280502ac6454SAndrew Thompson uint32_t status; 280602ac6454SAndrew Thompson uint32_t buf_offset; 280702ac6454SAndrew Thompson uint32_t nframes; 280802ac6454SAndrew Thompson uint32_t itd_offset[8 + 1]; 280902ac6454SAndrew Thompson uint8_t x; 281002ac6454SAndrew Thompson uint8_t td_no; 281102ac6454SAndrew Thompson uint8_t page_no; 2812d1f7c4baSAndrew Thompson uint8_t shift = usbd_xfer_get_fps_shift(xfer); 281302ac6454SAndrew Thompson 2814b850ecc1SAndrew Thompson #ifdef USB_DEBUG 281502ac6454SAndrew Thompson uint8_t once = 1; 281602ac6454SAndrew Thompson 281702ac6454SAndrew Thompson #endif 281802ac6454SAndrew Thompson 2819d1f7c4baSAndrew Thompson DPRINTFN(6, "xfer=%p next=%d nframes=%d shift=%d\n", 2820d1f7c4baSAndrew Thompson xfer, xfer->endpoint->isoc_next, xfer->nframes, (int)shift); 282102ac6454SAndrew Thompson 282202ac6454SAndrew Thompson /* get the current frame index */ 282302ac6454SAndrew Thompson 282402ac6454SAndrew Thompson nframes = EOREAD4(sc, EHCI_FRINDEX) / 8; 282502ac6454SAndrew Thompson 282602ac6454SAndrew Thompson /* 282702ac6454SAndrew Thompson * check if the frame index is within the window where the frames 282802ac6454SAndrew Thompson * will be inserted 282902ac6454SAndrew Thompson */ 2830ae60fdfbSAndrew Thompson buf_offset = (nframes - xfer->endpoint->isoc_next) & 283102ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 283202ac6454SAndrew Thompson 2833ae60fdfbSAndrew Thompson if ((xfer->endpoint->is_synced == 0) || 2834d1f7c4baSAndrew Thompson (buf_offset < (((xfer->nframes << shift) + 7) / 8))) { 283502ac6454SAndrew Thompson /* 283602ac6454SAndrew Thompson * If there is data underflow or the pipe queue is empty we 283702ac6454SAndrew Thompson * schedule the transfer a few frames ahead of the current 283802ac6454SAndrew Thompson * frame position. Else two isochronous transfers might 283902ac6454SAndrew Thompson * overlap. 284002ac6454SAndrew Thompson */ 2841ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (nframes + 3) & 284202ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 2843ae60fdfbSAndrew Thompson xfer->endpoint->is_synced = 1; 2844ae60fdfbSAndrew Thompson DPRINTFN(3, "start next=%d\n", xfer->endpoint->isoc_next); 284502ac6454SAndrew Thompson } 284602ac6454SAndrew Thompson /* 284702ac6454SAndrew Thompson * compute how many milliseconds the insertion is ahead of the 284802ac6454SAndrew Thompson * current frame position: 284902ac6454SAndrew Thompson */ 2850ae60fdfbSAndrew Thompson buf_offset = (xfer->endpoint->isoc_next - nframes) & 285102ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 285202ac6454SAndrew Thompson 285302ac6454SAndrew Thompson /* 285402ac6454SAndrew Thompson * pre-compute when the isochronous transfer will be finished: 285502ac6454SAndrew Thompson */ 285602ac6454SAndrew Thompson xfer->isoc_time_complete = 2857a593f6b8SAndrew Thompson usb_isoc_time_expand(&sc->sc_bus, nframes) + buf_offset + 2858d1f7c4baSAndrew Thompson (((xfer->nframes << shift) + 7) / 8); 285902ac6454SAndrew Thompson 286002ac6454SAndrew Thompson /* get the real number of frames */ 286102ac6454SAndrew Thompson 286202ac6454SAndrew Thompson nframes = xfer->nframes; 286302ac6454SAndrew Thompson 286402ac6454SAndrew Thompson buf_offset = 0; 286502ac6454SAndrew Thompson td_no = 0; 286602ac6454SAndrew Thompson 286702ac6454SAndrew Thompson plen = xfer->frlengths; 286802ac6454SAndrew Thompson 286902ac6454SAndrew Thompson /* toggle the DMA set we are using */ 287002ac6454SAndrew Thompson xfer->flags_int.curr_dma_set ^= 1; 287102ac6454SAndrew Thompson 287202ac6454SAndrew Thompson /* get next DMA set */ 287302ac6454SAndrew Thompson td = xfer->td_start[xfer->flags_int.curr_dma_set]; 287402ac6454SAndrew Thompson xfer->td_transfer_first = td; 287502ac6454SAndrew Thompson 2876ae60fdfbSAndrew Thompson pp_last = &sc->sc_isoc_hs_p_last[xfer->endpoint->isoc_next]; 287702ac6454SAndrew Thompson 287802ac6454SAndrew Thompson /* store starting position */ 287902ac6454SAndrew Thompson 2880ae60fdfbSAndrew Thompson xfer->qh_pos = xfer->endpoint->isoc_next; 288102ac6454SAndrew Thompson 2882883bb300SAndrew Thompson while (nframes) { 288302ac6454SAndrew Thompson if (td == NULL) { 288402ac6454SAndrew Thompson panic("%s:%d: out of TD's\n", 288502ac6454SAndrew Thompson __FUNCTION__, __LINE__); 288602ac6454SAndrew Thompson } 288702ac6454SAndrew Thompson if (pp_last >= &sc->sc_isoc_hs_p_last[EHCI_VIRTUAL_FRAMELIST_COUNT]) { 288802ac6454SAndrew Thompson pp_last = &sc->sc_isoc_hs_p_last[0]; 288902ac6454SAndrew Thompson } 289002ac6454SAndrew Thompson /* range check */ 289102ac6454SAndrew Thompson if (*plen > xfer->max_frame_size) { 2892b850ecc1SAndrew Thompson #ifdef USB_DEBUG 289302ac6454SAndrew Thompson if (once) { 289402ac6454SAndrew Thompson once = 0; 289502ac6454SAndrew Thompson printf("%s: frame length(%d) exceeds %d bytes " 289602ac6454SAndrew Thompson "(frame truncated)\n", 289702ac6454SAndrew Thompson __FUNCTION__, *plen, xfer->max_frame_size); 289802ac6454SAndrew Thompson } 289902ac6454SAndrew Thompson #endif 290002ac6454SAndrew Thompson *plen = xfer->max_frame_size; 290102ac6454SAndrew Thompson } 2902883bb300SAndrew Thompson 2903f12c6c29SAndrew Thompson if (xfer->endpoint->usb_smask & (1 << td_no)) { 290402ac6454SAndrew Thompson status = (EHCI_ITD_SET_LEN(*plen) | 290502ac6454SAndrew Thompson EHCI_ITD_ACTIVE | 290602ac6454SAndrew Thompson EHCI_ITD_SET_PG(0)); 2907e55e1ebcSAndrew Thompson td->itd_status[td_no] = htohc32(sc, status); 290802ac6454SAndrew Thompson itd_offset[td_no] = buf_offset; 290902ac6454SAndrew Thompson buf_offset += *plen; 291002ac6454SAndrew Thompson plen++; 2911883bb300SAndrew Thompson nframes --; 2912883bb300SAndrew Thompson } else { 2913883bb300SAndrew Thompson td->itd_status[td_no] = 0; /* not active */ 2914883bb300SAndrew Thompson itd_offset[td_no] = buf_offset; 2915883bb300SAndrew Thompson } 2916883bb300SAndrew Thompson 291702ac6454SAndrew Thompson td_no++; 291802ac6454SAndrew Thompson 291902ac6454SAndrew Thompson if ((td_no == 8) || (nframes == 0)) { 292002ac6454SAndrew Thompson 292102ac6454SAndrew Thompson /* the rest of the transfers are not active, if any */ 292202ac6454SAndrew Thompson for (x = td_no; x != 8; x++) { 292302ac6454SAndrew Thompson td->itd_status[x] = 0; /* not active */ 292402ac6454SAndrew Thompson } 292502ac6454SAndrew Thompson 292602ac6454SAndrew Thompson /* check if there is any data to be transferred */ 292702ac6454SAndrew Thompson if (itd_offset[0] != buf_offset) { 292802ac6454SAndrew Thompson page_no = 0; 292902ac6454SAndrew Thompson itd_offset[td_no] = buf_offset; 293002ac6454SAndrew Thompson 293102ac6454SAndrew Thompson /* get first page offset */ 2932a593f6b8SAndrew Thompson usbd_get_page(xfer->frbuffers, itd_offset[0], &buf_res); 293302ac6454SAndrew Thompson /* get page address */ 293402ac6454SAndrew Thompson page_addr = buf_res.physaddr & ~0xFFF; 293502ac6454SAndrew Thompson /* update page address */ 2936e55e1ebcSAndrew Thompson td->itd_bp[0] &= htohc32(sc, 0xFFF); 2937e55e1ebcSAndrew Thompson td->itd_bp[0] |= htohc32(sc, page_addr); 293802ac6454SAndrew Thompson 293902ac6454SAndrew Thompson for (x = 0; x != td_no; x++) { 294002ac6454SAndrew Thompson /* set page number and page offset */ 294102ac6454SAndrew Thompson status = (EHCI_ITD_SET_PG(page_no) | 294202ac6454SAndrew Thompson (buf_res.physaddr & 0xFFF)); 2943e55e1ebcSAndrew Thompson td->itd_status[x] |= htohc32(sc, status); 294402ac6454SAndrew Thompson 294502ac6454SAndrew Thompson /* get next page offset */ 294602ac6454SAndrew Thompson if (itd_offset[x + 1] == buf_offset) { 294702ac6454SAndrew Thompson /* 294802ac6454SAndrew Thompson * We subtract one so that 294902ac6454SAndrew Thompson * we don't go off the last 295002ac6454SAndrew Thompson * page! 295102ac6454SAndrew Thompson */ 2952a593f6b8SAndrew Thompson usbd_get_page(xfer->frbuffers, buf_offset - 1, &buf_res); 295302ac6454SAndrew Thompson } else { 2954a593f6b8SAndrew Thompson usbd_get_page(xfer->frbuffers, itd_offset[x + 1], &buf_res); 295502ac6454SAndrew Thompson } 295602ac6454SAndrew Thompson 295702ac6454SAndrew Thompson /* check if we need a new page */ 295802ac6454SAndrew Thompson if ((buf_res.physaddr ^ page_addr) & ~0xFFF) { 295902ac6454SAndrew Thompson /* new page needed */ 296002ac6454SAndrew Thompson page_addr = buf_res.physaddr & ~0xFFF; 296102ac6454SAndrew Thompson if (page_no == 6) { 296202ac6454SAndrew Thompson panic("%s: too many pages\n", __FUNCTION__); 296302ac6454SAndrew Thompson } 296402ac6454SAndrew Thompson page_no++; 296502ac6454SAndrew Thompson /* update page address */ 2966e55e1ebcSAndrew Thompson td->itd_bp[page_no] &= htohc32(sc, 0xFFF); 2967e55e1ebcSAndrew Thompson td->itd_bp[page_no] |= htohc32(sc, page_addr); 296802ac6454SAndrew Thompson } 296902ac6454SAndrew Thompson } 297002ac6454SAndrew Thompson } 297102ac6454SAndrew Thompson /* set IOC bit if we are complete */ 297202ac6454SAndrew Thompson if (nframes == 0) { 2973883bb300SAndrew Thompson td->itd_status[td_no - 1] |= htohc32(sc, EHCI_ITD_IOC); 297402ac6454SAndrew Thompson } 2975a593f6b8SAndrew Thompson usb_pc_cpu_flush(td->page_cache); 2976b850ecc1SAndrew Thompson #ifdef USB_DEBUG 297702ac6454SAndrew Thompson if (ehcidebug > 15) { 297802ac6454SAndrew Thompson DPRINTF("HS-TD %d\n", nframes); 297902ac6454SAndrew Thompson ehci_dump_itd(sc, td); 298002ac6454SAndrew Thompson } 298102ac6454SAndrew Thompson #endif 298202ac6454SAndrew Thompson /* insert TD into schedule */ 298302ac6454SAndrew Thompson EHCI_APPEND_HS_TD(td, *pp_last); 298402ac6454SAndrew Thompson pp_last++; 298502ac6454SAndrew Thompson 298602ac6454SAndrew Thompson td_no = 0; 298702ac6454SAndrew Thompson td_last = td; 298802ac6454SAndrew Thompson td = td->obj_next; 298902ac6454SAndrew Thompson } 299002ac6454SAndrew Thompson } 299102ac6454SAndrew Thompson 299202ac6454SAndrew Thompson xfer->td_transfer_last = td_last; 299302ac6454SAndrew Thompson 299402ac6454SAndrew Thompson /* update isoc_next */ 2995ae60fdfbSAndrew Thompson xfer->endpoint->isoc_next = (pp_last - &sc->sc_isoc_hs_p_last[0]) & 299602ac6454SAndrew Thompson (EHCI_VIRTUAL_FRAMELIST_COUNT - 1); 299702ac6454SAndrew Thompson } 299802ac6454SAndrew Thompson 299902ac6454SAndrew Thompson static void 3000760bc48eSAndrew Thompson ehci_device_isoc_hs_start(struct usb_xfer *xfer) 300102ac6454SAndrew Thompson { 300202ac6454SAndrew Thompson /* put transfer on interrupt queue */ 300302ac6454SAndrew Thompson ehci_transfer_intr_enqueue(xfer); 300402ac6454SAndrew Thompson } 300502ac6454SAndrew Thompson 3006760bc48eSAndrew Thompson struct usb_pipe_methods ehci_device_isoc_hs_methods = 300702ac6454SAndrew Thompson { 300802ac6454SAndrew Thompson .open = ehci_device_isoc_hs_open, 300902ac6454SAndrew Thompson .close = ehci_device_isoc_hs_close, 301002ac6454SAndrew Thompson .enter = ehci_device_isoc_hs_enter, 301102ac6454SAndrew Thompson .start = ehci_device_isoc_hs_start, 301202ac6454SAndrew Thompson }; 301302ac6454SAndrew Thompson 301402ac6454SAndrew Thompson /*------------------------------------------------------------------------* 301502ac6454SAndrew Thompson * ehci root control support 301602ac6454SAndrew Thompson *------------------------------------------------------------------------* 301739307315SAndrew Thompson * Simulate a hardware hub by handling all the necessary requests. 301802ac6454SAndrew Thompson *------------------------------------------------------------------------*/ 301902ac6454SAndrew Thompson 302002ac6454SAndrew Thompson static const 3021760bc48eSAndrew Thompson struct usb_device_descriptor ehci_devd = 302202ac6454SAndrew Thompson { 3023760bc48eSAndrew Thompson sizeof(struct usb_device_descriptor), 302402ac6454SAndrew Thompson UDESC_DEVICE, /* type */ 302502ac6454SAndrew Thompson {0x00, 0x02}, /* USB version */ 302602ac6454SAndrew Thompson UDCLASS_HUB, /* class */ 302702ac6454SAndrew Thompson UDSUBCLASS_HUB, /* subclass */ 302802ac6454SAndrew Thompson UDPROTO_HSHUBSTT, /* protocol */ 302902ac6454SAndrew Thompson 64, /* max packet */ 303002ac6454SAndrew Thompson {0}, {0}, {0x00, 0x01}, /* device id */ 303102ac6454SAndrew Thompson 1, 2, 0, /* string indicies */ 303202ac6454SAndrew Thompson 1 /* # of configurations */ 303302ac6454SAndrew Thompson }; 303402ac6454SAndrew Thompson 303502ac6454SAndrew Thompson static const 3036760bc48eSAndrew Thompson struct usb_device_qualifier ehci_odevd = 303702ac6454SAndrew Thompson { 3038760bc48eSAndrew Thompson sizeof(struct usb_device_qualifier), 303902ac6454SAndrew Thompson UDESC_DEVICE_QUALIFIER, /* type */ 304002ac6454SAndrew Thompson {0x00, 0x02}, /* USB version */ 304102ac6454SAndrew Thompson UDCLASS_HUB, /* class */ 304202ac6454SAndrew Thompson UDSUBCLASS_HUB, /* subclass */ 304302ac6454SAndrew Thompson UDPROTO_FSHUB, /* protocol */ 304402ac6454SAndrew Thompson 0, /* max packet */ 304502ac6454SAndrew Thompson 0, /* # of configurations */ 304602ac6454SAndrew Thompson 0 304702ac6454SAndrew Thompson }; 304802ac6454SAndrew Thompson 304902ac6454SAndrew Thompson static const struct ehci_config_desc ehci_confd = { 305002ac6454SAndrew Thompson .confd = { 3051760bc48eSAndrew Thompson .bLength = sizeof(struct usb_config_descriptor), 305202ac6454SAndrew Thompson .bDescriptorType = UDESC_CONFIG, 305302ac6454SAndrew Thompson .wTotalLength[0] = sizeof(ehci_confd), 305402ac6454SAndrew Thompson .bNumInterface = 1, 305502ac6454SAndrew Thompson .bConfigurationValue = 1, 305602ac6454SAndrew Thompson .iConfiguration = 0, 305702ac6454SAndrew Thompson .bmAttributes = UC_SELF_POWERED, 305802ac6454SAndrew Thompson .bMaxPower = 0 /* max power */ 305902ac6454SAndrew Thompson }, 306002ac6454SAndrew Thompson .ifcd = { 3061760bc48eSAndrew Thompson .bLength = sizeof(struct usb_interface_descriptor), 306202ac6454SAndrew Thompson .bDescriptorType = UDESC_INTERFACE, 306302ac6454SAndrew Thompson .bNumEndpoints = 1, 306402ac6454SAndrew Thompson .bInterfaceClass = UICLASS_HUB, 306502ac6454SAndrew Thompson .bInterfaceSubClass = UISUBCLASS_HUB, 3066*1678e135SHans Petter Selasky .bInterfaceProtocol = 0, 306702ac6454SAndrew Thompson }, 306802ac6454SAndrew Thompson .endpd = { 3069760bc48eSAndrew Thompson .bLength = sizeof(struct usb_endpoint_descriptor), 307002ac6454SAndrew Thompson .bDescriptorType = UDESC_ENDPOINT, 307102ac6454SAndrew Thompson .bEndpointAddress = UE_DIR_IN | EHCI_INTR_ENDPT, 307202ac6454SAndrew Thompson .bmAttributes = UE_INTERRUPT, 307302ac6454SAndrew Thompson .wMaxPacketSize[0] = 8, /* max packet (63 ports) */ 307402ac6454SAndrew Thompson .bInterval = 255, 307502ac6454SAndrew Thompson }, 307602ac6454SAndrew Thompson }; 307702ac6454SAndrew Thompson 307802ac6454SAndrew Thompson static const 3079760bc48eSAndrew Thompson struct usb_hub_descriptor ehci_hubd = 308002ac6454SAndrew Thompson { 308102ac6454SAndrew Thompson 0, /* dynamic length */ 308202ac6454SAndrew Thompson UDESC_HUB, 308302ac6454SAndrew Thompson 0, 308402ac6454SAndrew Thompson {0, 0}, 308502ac6454SAndrew Thompson 0, 308602ac6454SAndrew Thompson 0, 308702ac6454SAndrew Thompson {0}, 308802ac6454SAndrew Thompson }; 308902ac6454SAndrew Thompson 309002ac6454SAndrew Thompson static void 309102ac6454SAndrew Thompson ehci_disown(ehci_softc_t *sc, uint16_t index, uint8_t lowspeed) 309202ac6454SAndrew Thompson { 309302ac6454SAndrew Thompson uint32_t port; 309402ac6454SAndrew Thompson uint32_t v; 309502ac6454SAndrew Thompson 309602ac6454SAndrew Thompson DPRINTF("index=%d lowspeed=%d\n", index, lowspeed); 309702ac6454SAndrew Thompson 309802ac6454SAndrew Thompson port = EHCI_PORTSC(index); 309902ac6454SAndrew Thompson v = EOREAD4(sc, port) & ~EHCI_PS_CLEAR; 310002ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PO); 310102ac6454SAndrew Thompson } 310202ac6454SAndrew Thompson 3103e0a69b51SAndrew Thompson static usb_error_t 3104760bc48eSAndrew Thompson ehci_roothub_exec(struct usb_device *udev, 3105760bc48eSAndrew Thompson struct usb_device_request *req, const void **pptr, uint16_t *plength) 310602ac6454SAndrew Thompson { 3107459d369eSAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(udev->bus); 3108459d369eSAndrew Thompson const char *str_ptr; 3109459d369eSAndrew Thompson const void *ptr; 311002ac6454SAndrew Thompson uint32_t port; 311102ac6454SAndrew Thompson uint32_t v; 3112459d369eSAndrew Thompson uint16_t len; 311302ac6454SAndrew Thompson uint16_t i; 311402ac6454SAndrew Thompson uint16_t value; 311502ac6454SAndrew Thompson uint16_t index; 311602ac6454SAndrew Thompson uint8_t l; 3117e0a69b51SAndrew Thompson usb_error_t err; 311802ac6454SAndrew Thompson 311902ac6454SAndrew Thompson USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED); 312002ac6454SAndrew Thompson 312102ac6454SAndrew Thompson /* buffer reset */ 3122459d369eSAndrew Thompson ptr = (const void *)&sc->sc_hub_desc; 3123459d369eSAndrew Thompson len = 0; 3124459d369eSAndrew Thompson err = 0; 312502ac6454SAndrew Thompson 3126459d369eSAndrew Thompson value = UGETW(req->wValue); 3127459d369eSAndrew Thompson index = UGETW(req->wIndex); 312802ac6454SAndrew Thompson 312902ac6454SAndrew Thompson DPRINTFN(3, "type=0x%02x request=0x%02x wLen=0x%04x " 313002ac6454SAndrew Thompson "wValue=0x%04x wIndex=0x%04x\n", 3131459d369eSAndrew Thompson req->bmRequestType, req->bRequest, 3132459d369eSAndrew Thompson UGETW(req->wLength), value, index); 313302ac6454SAndrew Thompson 313402ac6454SAndrew Thompson #define C(x,y) ((x) | ((y) << 8)) 3135459d369eSAndrew Thompson switch (C(req->bRequest, req->bmRequestType)) { 313602ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): 313702ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): 313802ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): 313902ac6454SAndrew Thompson /* 314002ac6454SAndrew Thompson * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops 314102ac6454SAndrew Thompson * for the integrated root hub. 314202ac6454SAndrew Thompson */ 314302ac6454SAndrew Thompson break; 314402ac6454SAndrew Thompson case C(UR_GET_CONFIG, UT_READ_DEVICE): 3145459d369eSAndrew Thompson len = 1; 314602ac6454SAndrew Thompson sc->sc_hub_desc.temp[0] = sc->sc_conf; 314702ac6454SAndrew Thompson break; 314802ac6454SAndrew Thompson case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): 314902ac6454SAndrew Thompson switch (value >> 8) { 315002ac6454SAndrew Thompson case UDESC_DEVICE: 315102ac6454SAndrew Thompson if ((value & 0xff) != 0) { 3152459d369eSAndrew Thompson err = USB_ERR_IOERROR; 315302ac6454SAndrew Thompson goto done; 315402ac6454SAndrew Thompson } 3155459d369eSAndrew Thompson len = sizeof(ehci_devd); 3156459d369eSAndrew Thompson ptr = (const void *)&ehci_devd; 315702ac6454SAndrew Thompson break; 315802ac6454SAndrew Thompson /* 315902ac6454SAndrew Thompson * We can't really operate at another speed, 316002ac6454SAndrew Thompson * but the specification says we need this 316102ac6454SAndrew Thompson * descriptor: 316202ac6454SAndrew Thompson */ 316302ac6454SAndrew Thompson case UDESC_DEVICE_QUALIFIER: 316402ac6454SAndrew Thompson if ((value & 0xff) != 0) { 3165459d369eSAndrew Thompson err = USB_ERR_IOERROR; 316602ac6454SAndrew Thompson goto done; 316702ac6454SAndrew Thompson } 3168459d369eSAndrew Thompson len = sizeof(ehci_odevd); 3169459d369eSAndrew Thompson ptr = (const void *)&ehci_odevd; 317002ac6454SAndrew Thompson break; 317102ac6454SAndrew Thompson 317202ac6454SAndrew Thompson case UDESC_CONFIG: 317302ac6454SAndrew Thompson if ((value & 0xff) != 0) { 3174459d369eSAndrew Thompson err = USB_ERR_IOERROR; 317502ac6454SAndrew Thompson goto done; 317602ac6454SAndrew Thompson } 3177459d369eSAndrew Thompson len = sizeof(ehci_confd); 3178459d369eSAndrew Thompson ptr = (const void *)&ehci_confd; 317902ac6454SAndrew Thompson break; 318002ac6454SAndrew Thompson 318102ac6454SAndrew Thompson case UDESC_STRING: 318202ac6454SAndrew Thompson switch (value & 0xff) { 318302ac6454SAndrew Thompson case 0: /* Language table */ 3184459d369eSAndrew Thompson str_ptr = "\001"; 318502ac6454SAndrew Thompson break; 318602ac6454SAndrew Thompson 318702ac6454SAndrew Thompson case 1: /* Vendor */ 3188459d369eSAndrew Thompson str_ptr = sc->sc_vendor; 318902ac6454SAndrew Thompson break; 319002ac6454SAndrew Thompson 319102ac6454SAndrew Thompson case 2: /* Product */ 3192459d369eSAndrew Thompson str_ptr = "EHCI root HUB"; 319302ac6454SAndrew Thompson break; 319402ac6454SAndrew Thompson 319502ac6454SAndrew Thompson default: 3196459d369eSAndrew Thompson str_ptr = ""; 319702ac6454SAndrew Thompson break; 319802ac6454SAndrew Thompson } 319902ac6454SAndrew Thompson 3200a593f6b8SAndrew Thompson len = usb_make_str_desc( 3201459d369eSAndrew Thompson sc->sc_hub_desc.temp, 320202ac6454SAndrew Thompson sizeof(sc->sc_hub_desc.temp), 3203459d369eSAndrew Thompson str_ptr); 320402ac6454SAndrew Thompson break; 320502ac6454SAndrew Thompson default: 3206459d369eSAndrew Thompson err = USB_ERR_IOERROR; 320702ac6454SAndrew Thompson goto done; 320802ac6454SAndrew Thompson } 320902ac6454SAndrew Thompson break; 321002ac6454SAndrew Thompson case C(UR_GET_INTERFACE, UT_READ_INTERFACE): 3211459d369eSAndrew Thompson len = 1; 321202ac6454SAndrew Thompson sc->sc_hub_desc.temp[0] = 0; 321302ac6454SAndrew Thompson break; 321402ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_DEVICE): 3215459d369eSAndrew Thompson len = 2; 321602ac6454SAndrew Thompson USETW(sc->sc_hub_desc.stat.wStatus, UDS_SELF_POWERED); 321702ac6454SAndrew Thompson break; 321802ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_INTERFACE): 321902ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_ENDPOINT): 3220459d369eSAndrew Thompson len = 2; 322102ac6454SAndrew Thompson USETW(sc->sc_hub_desc.stat.wStatus, 0); 322202ac6454SAndrew Thompson break; 322302ac6454SAndrew Thompson case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): 3224ab42e8b2SAndrew Thompson if (value >= EHCI_MAX_DEVICES) { 3225459d369eSAndrew Thompson err = USB_ERR_IOERROR; 322602ac6454SAndrew Thompson goto done; 322702ac6454SAndrew Thompson } 322802ac6454SAndrew Thompson sc->sc_addr = value; 322902ac6454SAndrew Thompson break; 323002ac6454SAndrew Thompson case C(UR_SET_CONFIG, UT_WRITE_DEVICE): 323102ac6454SAndrew Thompson if ((value != 0) && (value != 1)) { 3232459d369eSAndrew Thompson err = USB_ERR_IOERROR; 323302ac6454SAndrew Thompson goto done; 323402ac6454SAndrew Thompson } 323502ac6454SAndrew Thompson sc->sc_conf = value; 323602ac6454SAndrew Thompson break; 323702ac6454SAndrew Thompson case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): 323802ac6454SAndrew Thompson break; 323902ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_DEVICE): 324002ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): 324102ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): 3242459d369eSAndrew Thompson err = USB_ERR_IOERROR; 324302ac6454SAndrew Thompson goto done; 324402ac6454SAndrew Thompson case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): 324502ac6454SAndrew Thompson break; 324602ac6454SAndrew Thompson case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): 324702ac6454SAndrew Thompson break; 324802ac6454SAndrew Thompson /* Hub requests */ 324902ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): 325002ac6454SAndrew Thompson break; 325102ac6454SAndrew Thompson case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): 325202ac6454SAndrew Thompson DPRINTFN(9, "UR_CLEAR_PORT_FEATURE\n"); 325302ac6454SAndrew Thompson 325402ac6454SAndrew Thompson if ((index < 1) || 325502ac6454SAndrew Thompson (index > sc->sc_noport)) { 3256459d369eSAndrew Thompson err = USB_ERR_IOERROR; 325702ac6454SAndrew Thompson goto done; 325802ac6454SAndrew Thompson } 325902ac6454SAndrew Thompson port = EHCI_PORTSC(index); 326002ac6454SAndrew Thompson v = EOREAD4(sc, port) & ~EHCI_PS_CLEAR; 326102ac6454SAndrew Thompson switch (value) { 326202ac6454SAndrew Thompson case UHF_PORT_ENABLE: 326302ac6454SAndrew Thompson EOWRITE4(sc, port, v & ~EHCI_PS_PE); 326402ac6454SAndrew Thompson break; 326502ac6454SAndrew Thompson case UHF_PORT_SUSPEND: 326602ac6454SAndrew Thompson if ((v & EHCI_PS_SUSP) && (!(v & EHCI_PS_FPR))) { 326702ac6454SAndrew Thompson 326802ac6454SAndrew Thompson /* 326902ac6454SAndrew Thompson * waking up a High Speed device is rather 327002ac6454SAndrew Thompson * complicated if 327102ac6454SAndrew Thompson */ 327202ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_FPR); 327302ac6454SAndrew Thompson } 327402ac6454SAndrew Thompson /* wait 20ms for resume sequence to complete */ 3275a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50); 327602ac6454SAndrew Thompson 327702ac6454SAndrew Thompson EOWRITE4(sc, port, v & ~(EHCI_PS_SUSP | 327802ac6454SAndrew Thompson EHCI_PS_FPR | (3 << 10) /* High Speed */ )); 327902ac6454SAndrew Thompson 32804a35cda7SAndrew Thompson /* 4ms settle time */ 3281a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250); 328202ac6454SAndrew Thompson break; 328302ac6454SAndrew Thompson case UHF_PORT_POWER: 328402ac6454SAndrew Thompson EOWRITE4(sc, port, v & ~EHCI_PS_PP); 328502ac6454SAndrew Thompson break; 328602ac6454SAndrew Thompson case UHF_PORT_TEST: 328702ac6454SAndrew Thompson DPRINTFN(3, "clear port test " 328802ac6454SAndrew Thompson "%d\n", index); 328902ac6454SAndrew Thompson break; 329002ac6454SAndrew Thompson case UHF_PORT_INDICATOR: 329102ac6454SAndrew Thompson DPRINTFN(3, "clear port ind " 329202ac6454SAndrew Thompson "%d\n", index); 329302ac6454SAndrew Thompson EOWRITE4(sc, port, v & ~EHCI_PS_PIC); 329402ac6454SAndrew Thompson break; 329502ac6454SAndrew Thompson case UHF_C_PORT_CONNECTION: 329602ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_CSC); 329702ac6454SAndrew Thompson break; 329802ac6454SAndrew Thompson case UHF_C_PORT_ENABLE: 329902ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PEC); 330002ac6454SAndrew Thompson break; 330102ac6454SAndrew Thompson case UHF_C_PORT_SUSPEND: 330202ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_SUSP); 330302ac6454SAndrew Thompson break; 330402ac6454SAndrew Thompson case UHF_C_PORT_OVER_CURRENT: 330502ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_OCC); 330602ac6454SAndrew Thompson break; 330702ac6454SAndrew Thompson case UHF_C_PORT_RESET: 330802ac6454SAndrew Thompson sc->sc_isreset = 0; 330902ac6454SAndrew Thompson break; 331002ac6454SAndrew Thompson default: 3311459d369eSAndrew Thompson err = USB_ERR_IOERROR; 331202ac6454SAndrew Thompson goto done; 331302ac6454SAndrew Thompson } 331402ac6454SAndrew Thompson break; 331502ac6454SAndrew Thompson case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): 331602ac6454SAndrew Thompson if ((value & 0xff) != 0) { 3317459d369eSAndrew Thompson err = USB_ERR_IOERROR; 331802ac6454SAndrew Thompson goto done; 331902ac6454SAndrew Thompson } 3320b494261cSHans Petter Selasky v = EREAD4(sc, EHCI_HCSPARAMS); 332102ac6454SAndrew Thompson 332202ac6454SAndrew Thompson sc->sc_hub_desc.hubd = ehci_hubd; 332302ac6454SAndrew Thompson sc->sc_hub_desc.hubd.bNbrPorts = sc->sc_noport; 332402ac6454SAndrew Thompson USETW(sc->sc_hub_desc.hubd.wHubCharacteristics, 332502ac6454SAndrew Thompson (EHCI_HCS_PPC(v) ? UHD_PWR_INDIVIDUAL : UHD_PWR_NO_SWITCH) | 332602ac6454SAndrew Thompson (EHCI_HCS_P_INDICATOR(EREAD4(sc, EHCI_HCSPARAMS)) ? 332702ac6454SAndrew Thompson UHD_PORT_IND : 0)); 332802ac6454SAndrew Thompson /* XXX can't find out? */ 332902ac6454SAndrew Thompson sc->sc_hub_desc.hubd.bPwrOn2PwrGood = 200; 333002ac6454SAndrew Thompson for (l = 0; l < sc->sc_noport; l++) { 333102ac6454SAndrew Thompson /* XXX can't find out? */ 333202ac6454SAndrew Thompson sc->sc_hub_desc.hubd.DeviceRemovable[l / 8] &= ~(1 << (l % 8)); 333302ac6454SAndrew Thompson } 333402ac6454SAndrew Thompson sc->sc_hub_desc.hubd.bDescLength = 333502ac6454SAndrew Thompson 8 + ((sc->sc_noport + 7) / 8); 3336459d369eSAndrew Thompson len = sc->sc_hub_desc.hubd.bDescLength; 333702ac6454SAndrew Thompson break; 333802ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): 3339459d369eSAndrew Thompson len = 16; 334002ac6454SAndrew Thompson bzero(sc->sc_hub_desc.temp, 16); 334102ac6454SAndrew Thompson break; 334202ac6454SAndrew Thompson case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): 334302ac6454SAndrew Thompson DPRINTFN(9, "get port status i=%d\n", 334402ac6454SAndrew Thompson index); 334502ac6454SAndrew Thompson if ((index < 1) || 334602ac6454SAndrew Thompson (index > sc->sc_noport)) { 3347459d369eSAndrew Thompson err = USB_ERR_IOERROR; 334802ac6454SAndrew Thompson goto done; 334902ac6454SAndrew Thompson } 335002ac6454SAndrew Thompson v = EOREAD4(sc, EHCI_PORTSC(index)); 335102ac6454SAndrew Thompson DPRINTFN(9, "port status=0x%04x\n", v); 3352e55e1ebcSAndrew Thompson if (sc->sc_flags & (EHCI_SCFLG_FORCESPEED | EHCI_SCFLG_TT)) { 335302ac6454SAndrew Thompson if ((v & 0xc000000) == 0x8000000) 335402ac6454SAndrew Thompson i = UPS_HIGH_SPEED; 335502ac6454SAndrew Thompson else if ((v & 0xc000000) == 0x4000000) 335602ac6454SAndrew Thompson i = UPS_LOW_SPEED; 335702ac6454SAndrew Thompson else 335802ac6454SAndrew Thompson i = 0; 335902ac6454SAndrew Thompson } else { 336002ac6454SAndrew Thompson i = UPS_HIGH_SPEED; 336102ac6454SAndrew Thompson } 336202ac6454SAndrew Thompson if (v & EHCI_PS_CS) 336302ac6454SAndrew Thompson i |= UPS_CURRENT_CONNECT_STATUS; 336402ac6454SAndrew Thompson if (v & EHCI_PS_PE) 336502ac6454SAndrew Thompson i |= UPS_PORT_ENABLED; 336602ac6454SAndrew Thompson if ((v & EHCI_PS_SUSP) && !(v & EHCI_PS_FPR)) 336702ac6454SAndrew Thompson i |= UPS_SUSPEND; 336802ac6454SAndrew Thompson if (v & EHCI_PS_OCA) 336902ac6454SAndrew Thompson i |= UPS_OVERCURRENT_INDICATOR; 337002ac6454SAndrew Thompson if (v & EHCI_PS_PR) 337102ac6454SAndrew Thompson i |= UPS_RESET; 337202ac6454SAndrew Thompson if (v & EHCI_PS_PP) 337302ac6454SAndrew Thompson i |= UPS_PORT_POWER; 337402ac6454SAndrew Thompson USETW(sc->sc_hub_desc.ps.wPortStatus, i); 337502ac6454SAndrew Thompson i = 0; 337602ac6454SAndrew Thompson if (v & EHCI_PS_CSC) 337702ac6454SAndrew Thompson i |= UPS_C_CONNECT_STATUS; 337802ac6454SAndrew Thompson if (v & EHCI_PS_PEC) 337902ac6454SAndrew Thompson i |= UPS_C_PORT_ENABLED; 338002ac6454SAndrew Thompson if (v & EHCI_PS_OCC) 338102ac6454SAndrew Thompson i |= UPS_C_OVERCURRENT_INDICATOR; 338202ac6454SAndrew Thompson if (v & EHCI_PS_FPR) 338302ac6454SAndrew Thompson i |= UPS_C_SUSPEND; 338402ac6454SAndrew Thompson if (sc->sc_isreset) 338502ac6454SAndrew Thompson i |= UPS_C_PORT_RESET; 338602ac6454SAndrew Thompson USETW(sc->sc_hub_desc.ps.wPortChange, i); 3387459d369eSAndrew Thompson len = sizeof(sc->sc_hub_desc.ps); 338802ac6454SAndrew Thompson break; 338902ac6454SAndrew Thompson case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): 3390459d369eSAndrew Thompson err = USB_ERR_IOERROR; 339102ac6454SAndrew Thompson goto done; 339202ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): 339302ac6454SAndrew Thompson break; 339402ac6454SAndrew Thompson case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): 339502ac6454SAndrew Thompson if ((index < 1) || 339602ac6454SAndrew Thompson (index > sc->sc_noport)) { 3397459d369eSAndrew Thompson err = USB_ERR_IOERROR; 339802ac6454SAndrew Thompson goto done; 339902ac6454SAndrew Thompson } 340002ac6454SAndrew Thompson port = EHCI_PORTSC(index); 340102ac6454SAndrew Thompson v = EOREAD4(sc, port) & ~EHCI_PS_CLEAR; 340202ac6454SAndrew Thompson switch (value) { 340302ac6454SAndrew Thompson case UHF_PORT_ENABLE: 340402ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PE); 340502ac6454SAndrew Thompson break; 340602ac6454SAndrew Thompson case UHF_PORT_SUSPEND: 340702ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_SUSP); 340802ac6454SAndrew Thompson break; 340902ac6454SAndrew Thompson case UHF_PORT_RESET: 341002ac6454SAndrew Thompson DPRINTFN(6, "reset port %d\n", index); 3411b850ecc1SAndrew Thompson #ifdef USB_DEBUG 341202ac6454SAndrew Thompson if (ehcinohighspeed) { 341302ac6454SAndrew Thompson /* 341402ac6454SAndrew Thompson * Connect USB device to companion 341502ac6454SAndrew Thompson * controller. 341602ac6454SAndrew Thompson */ 341702ac6454SAndrew Thompson ehci_disown(sc, index, 1); 341802ac6454SAndrew Thompson break; 341902ac6454SAndrew Thompson } 342002ac6454SAndrew Thompson #endif 3421e55e1ebcSAndrew Thompson if (EHCI_PS_IS_LOWSPEED(v) && 3422e55e1ebcSAndrew Thompson (sc->sc_flags & EHCI_SCFLG_TT) == 0) { 342302ac6454SAndrew Thompson /* Low speed device, give up ownership. */ 342402ac6454SAndrew Thompson ehci_disown(sc, index, 1); 342502ac6454SAndrew Thompson break; 342602ac6454SAndrew Thompson } 342702ac6454SAndrew Thompson /* Start reset sequence. */ 342802ac6454SAndrew Thompson v &= ~(EHCI_PS_PE | EHCI_PS_PR); 342902ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PR); 343002ac6454SAndrew Thompson 343102ac6454SAndrew Thompson /* Wait for reset to complete. */ 3432a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 343302ac6454SAndrew Thompson USB_MS_TO_TICKS(USB_PORT_ROOT_RESET_DELAY)); 343402ac6454SAndrew Thompson 343502ac6454SAndrew Thompson /* Terminate reset sequence. */ 343602ac6454SAndrew Thompson if (!(sc->sc_flags & EHCI_SCFLG_NORESTERM)) 343702ac6454SAndrew Thompson EOWRITE4(sc, port, v); 343802ac6454SAndrew Thompson 343902ac6454SAndrew Thompson /* Wait for HC to complete reset. */ 3440a593f6b8SAndrew Thompson usb_pause_mtx(&sc->sc_bus.bus_mtx, 344102ac6454SAndrew Thompson USB_MS_TO_TICKS(EHCI_PORT_RESET_COMPLETE)); 344202ac6454SAndrew Thompson 344302ac6454SAndrew Thompson v = EOREAD4(sc, port); 344402ac6454SAndrew Thompson DPRINTF("ehci after reset, status=0x%08x\n", v); 344502ac6454SAndrew Thompson if (v & EHCI_PS_PR) { 344602ac6454SAndrew Thompson device_printf(sc->sc_bus.bdev, 344702ac6454SAndrew Thompson "port reset timeout\n"); 3448459d369eSAndrew Thompson err = USB_ERR_TIMEOUT; 344902ac6454SAndrew Thompson goto done; 345002ac6454SAndrew Thompson } 3451e55e1ebcSAndrew Thompson if (!(v & EHCI_PS_PE) && 3452e55e1ebcSAndrew Thompson (sc->sc_flags & EHCI_SCFLG_TT) == 0) { 3453e55e1ebcSAndrew Thompson /* Not a high speed device, give up ownership.*/ 345402ac6454SAndrew Thompson ehci_disown(sc, index, 0); 345502ac6454SAndrew Thompson break; 345602ac6454SAndrew Thompson } 345702ac6454SAndrew Thompson sc->sc_isreset = 1; 345802ac6454SAndrew Thompson DPRINTF("ehci port %d reset, status = 0x%08x\n", 345902ac6454SAndrew Thompson index, v); 346002ac6454SAndrew Thompson break; 346102ac6454SAndrew Thompson 346202ac6454SAndrew Thompson case UHF_PORT_POWER: 346302ac6454SAndrew Thompson DPRINTFN(3, "set port power %d\n", index); 346402ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PP); 346502ac6454SAndrew Thompson break; 346602ac6454SAndrew Thompson 346702ac6454SAndrew Thompson case UHF_PORT_TEST: 346802ac6454SAndrew Thompson DPRINTFN(3, "set port test %d\n", index); 346902ac6454SAndrew Thompson break; 347002ac6454SAndrew Thompson 347102ac6454SAndrew Thompson case UHF_PORT_INDICATOR: 347202ac6454SAndrew Thompson DPRINTFN(3, "set port ind %d\n", index); 347302ac6454SAndrew Thompson EOWRITE4(sc, port, v | EHCI_PS_PIC); 347402ac6454SAndrew Thompson break; 347502ac6454SAndrew Thompson 347602ac6454SAndrew Thompson default: 3477459d369eSAndrew Thompson err = USB_ERR_IOERROR; 347802ac6454SAndrew Thompson goto done; 347902ac6454SAndrew Thompson } 348002ac6454SAndrew Thompson break; 348102ac6454SAndrew Thompson case C(UR_CLEAR_TT_BUFFER, UT_WRITE_CLASS_OTHER): 348202ac6454SAndrew Thompson case C(UR_RESET_TT, UT_WRITE_CLASS_OTHER): 348302ac6454SAndrew Thompson case C(UR_GET_TT_STATE, UT_READ_CLASS_OTHER): 348402ac6454SAndrew Thompson case C(UR_STOP_TT, UT_WRITE_CLASS_OTHER): 348502ac6454SAndrew Thompson break; 348602ac6454SAndrew Thompson default: 3487459d369eSAndrew Thompson err = USB_ERR_IOERROR; 348802ac6454SAndrew Thompson goto done; 348902ac6454SAndrew Thompson } 349002ac6454SAndrew Thompson done: 3491459d369eSAndrew Thompson *plength = len; 3492459d369eSAndrew Thompson *pptr = ptr; 3493459d369eSAndrew Thompson return (err); 349402ac6454SAndrew Thompson } 349502ac6454SAndrew Thompson 349602ac6454SAndrew Thompson static void 3497760bc48eSAndrew Thompson ehci_xfer_setup(struct usb_setup_params *parm) 349802ac6454SAndrew Thompson { 3499760bc48eSAndrew Thompson struct usb_page_search page_info; 3500760bc48eSAndrew Thompson struct usb_page_cache *pc; 350102ac6454SAndrew Thompson ehci_softc_t *sc; 3502760bc48eSAndrew Thompson struct usb_xfer *xfer; 350302ac6454SAndrew Thompson void *last_obj; 350402ac6454SAndrew Thompson uint32_t nqtd; 350502ac6454SAndrew Thompson uint32_t nqh; 350602ac6454SAndrew Thompson uint32_t nsitd; 350702ac6454SAndrew Thompson uint32_t nitd; 350802ac6454SAndrew Thompson uint32_t n; 350902ac6454SAndrew Thompson 351002ac6454SAndrew Thompson sc = EHCI_BUS2SC(parm->udev->bus); 351102ac6454SAndrew Thompson xfer = parm->curr_xfer; 351202ac6454SAndrew Thompson 351302ac6454SAndrew Thompson nqtd = 0; 351402ac6454SAndrew Thompson nqh = 0; 351502ac6454SAndrew Thompson nsitd = 0; 351602ac6454SAndrew Thompson nitd = 0; 351702ac6454SAndrew Thompson 351802ac6454SAndrew Thompson /* 351902ac6454SAndrew Thompson * compute maximum number of some structures 352002ac6454SAndrew Thompson */ 352102ac6454SAndrew Thompson if (parm->methods == &ehci_device_ctrl_methods) { 352202ac6454SAndrew Thompson 352302ac6454SAndrew Thompson /* 352402ac6454SAndrew Thompson * The proof for the "nqtd" formula is illustrated like 352502ac6454SAndrew Thompson * this: 352602ac6454SAndrew Thompson * 352702ac6454SAndrew Thompson * +------------------------------------+ 352802ac6454SAndrew Thompson * | | 352902ac6454SAndrew Thompson * | |remainder -> | 353002ac6454SAndrew Thompson * | +-----+---+ | 353102ac6454SAndrew Thompson * | | xxx | x | frm 0 | 353202ac6454SAndrew Thompson * | +-----+---++ | 353302ac6454SAndrew Thompson * | | xxx | xx | frm 1 | 353402ac6454SAndrew Thompson * | +-----+----+ | 353502ac6454SAndrew Thompson * | ... | 353602ac6454SAndrew Thompson * +------------------------------------+ 353702ac6454SAndrew Thompson * 353802ac6454SAndrew Thompson * "xxx" means a completely full USB transfer descriptor 353902ac6454SAndrew Thompson * 354002ac6454SAndrew Thompson * "x" and "xx" means a short USB packet 354102ac6454SAndrew Thompson * 354202ac6454SAndrew Thompson * For the remainder of an USB transfer modulo 354302ac6454SAndrew Thompson * "max_data_length" we need two USB transfer descriptors. 354402ac6454SAndrew Thompson * One to transfer the remaining data and one to finalise 354502ac6454SAndrew Thompson * with a zero length packet in case the "force_short_xfer" 354602ac6454SAndrew Thompson * flag is set. We only need two USB transfer descriptors in 354702ac6454SAndrew Thompson * the case where the transfer length of the first one is a 354802ac6454SAndrew Thompson * factor of "max_frame_size". The rest of the needed USB 354902ac6454SAndrew Thompson * transfer descriptors is given by the buffer size divided 355002ac6454SAndrew Thompson * by the maximum data payload. 355102ac6454SAndrew Thompson */ 355202ac6454SAndrew Thompson parm->hc_max_packet_size = 0x400; 355302ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 355402ac6454SAndrew Thompson parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; 355502ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 355602ac6454SAndrew Thompson 3557a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 355802ac6454SAndrew Thompson 355902ac6454SAndrew Thompson nqh = 1; 356002ac6454SAndrew Thompson nqtd = ((2 * xfer->nframes) + 1 /* STATUS */ 3561578d0effSAndrew Thompson + (xfer->max_data_length / xfer->max_hc_frame_size)); 356202ac6454SAndrew Thompson 356302ac6454SAndrew Thompson } else if (parm->methods == &ehci_device_bulk_methods) { 356402ac6454SAndrew Thompson 356502ac6454SAndrew Thompson parm->hc_max_packet_size = 0x400; 356602ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 356702ac6454SAndrew Thompson parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; 356802ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 356902ac6454SAndrew Thompson 3570a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 357102ac6454SAndrew Thompson 357202ac6454SAndrew Thompson nqh = 1; 357302ac6454SAndrew Thompson nqtd = ((2 * xfer->nframes) 3574578d0effSAndrew Thompson + (xfer->max_data_length / xfer->max_hc_frame_size)); 357502ac6454SAndrew Thompson 357602ac6454SAndrew Thompson } else if (parm->methods == &ehci_device_intr_methods) { 357702ac6454SAndrew Thompson 357802ac6454SAndrew Thompson if (parm->speed == USB_SPEED_HIGH) { 357902ac6454SAndrew Thompson parm->hc_max_packet_size = 0x400; 358002ac6454SAndrew Thompson parm->hc_max_packet_count = 3; 358102ac6454SAndrew Thompson } else if (parm->speed == USB_SPEED_FULL) { 358202ac6454SAndrew Thompson parm->hc_max_packet_size = USB_FS_BYTES_PER_HS_UFRAME; 358302ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 358402ac6454SAndrew Thompson } else { 358502ac6454SAndrew Thompson parm->hc_max_packet_size = USB_FS_BYTES_PER_HS_UFRAME / 8; 358602ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 358702ac6454SAndrew Thompson } 358802ac6454SAndrew Thompson 358902ac6454SAndrew Thompson parm->hc_max_frame_size = EHCI_QTD_PAYLOAD_MAX; 359002ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 359102ac6454SAndrew Thompson 3592a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 359302ac6454SAndrew Thompson 359402ac6454SAndrew Thompson nqh = 1; 359502ac6454SAndrew Thompson nqtd = ((2 * xfer->nframes) 3596578d0effSAndrew Thompson + (xfer->max_data_length / xfer->max_hc_frame_size)); 359702ac6454SAndrew Thompson 359802ac6454SAndrew Thompson } else if (parm->methods == &ehci_device_isoc_fs_methods) { 359902ac6454SAndrew Thompson 360002ac6454SAndrew Thompson parm->hc_max_packet_size = 0x3FF; 360102ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 360202ac6454SAndrew Thompson parm->hc_max_frame_size = 0x3FF; 360302ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 360402ac6454SAndrew Thompson 3605a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 360602ac6454SAndrew Thompson 360702ac6454SAndrew Thompson nsitd = xfer->nframes; 360802ac6454SAndrew Thompson 360902ac6454SAndrew Thompson } else if (parm->methods == &ehci_device_isoc_hs_methods) { 361002ac6454SAndrew Thompson 361102ac6454SAndrew Thompson parm->hc_max_packet_size = 0x400; 361202ac6454SAndrew Thompson parm->hc_max_packet_count = 3; 361302ac6454SAndrew Thompson parm->hc_max_frame_size = 0xC00; 361402ac6454SAndrew Thompson xfer->flags_int.bdma_enable = 1; 361502ac6454SAndrew Thompson 3616a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 361702ac6454SAndrew Thompson 3618883bb300SAndrew Thompson nitd = ((xfer->nframes + 7) / 8) << 3619883bb300SAndrew Thompson usbd_xfer_get_fps_shift(xfer); 362002ac6454SAndrew Thompson 362102ac6454SAndrew Thompson } else { 362202ac6454SAndrew Thompson 362302ac6454SAndrew Thompson parm->hc_max_packet_size = 0x400; 362402ac6454SAndrew Thompson parm->hc_max_packet_count = 1; 362502ac6454SAndrew Thompson parm->hc_max_frame_size = 0x400; 362602ac6454SAndrew Thompson 3627a593f6b8SAndrew Thompson usbd_transfer_setup_sub(parm); 362802ac6454SAndrew Thompson } 362902ac6454SAndrew Thompson 363002ac6454SAndrew Thompson alloc_dma_set: 363102ac6454SAndrew Thompson 363202ac6454SAndrew Thompson if (parm->err) { 363302ac6454SAndrew Thompson return; 363402ac6454SAndrew Thompson } 363502ac6454SAndrew Thompson /* 363602ac6454SAndrew Thompson * Allocate queue heads and transfer descriptors 363702ac6454SAndrew Thompson */ 363802ac6454SAndrew Thompson last_obj = NULL; 363902ac6454SAndrew Thompson 3640a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 364102ac6454SAndrew Thompson parm, &pc, sizeof(ehci_itd_t), 364202ac6454SAndrew Thompson EHCI_ITD_ALIGN, nitd)) { 364302ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 364402ac6454SAndrew Thompson return; 364502ac6454SAndrew Thompson } 364602ac6454SAndrew Thompson if (parm->buf) { 364702ac6454SAndrew Thompson for (n = 0; n != nitd; n++) { 364802ac6454SAndrew Thompson ehci_itd_t *td; 364902ac6454SAndrew Thompson 3650a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 365102ac6454SAndrew Thompson 365202ac6454SAndrew Thompson td = page_info.buffer; 365302ac6454SAndrew Thompson 365402ac6454SAndrew Thompson /* init TD */ 3655e55e1ebcSAndrew Thompson td->itd_self = htohc32(sc, page_info.physaddr | EHCI_LINK_ITD); 365602ac6454SAndrew Thompson td->obj_next = last_obj; 365702ac6454SAndrew Thompson td->page_cache = pc + n; 365802ac6454SAndrew Thompson 365902ac6454SAndrew Thompson last_obj = td; 366002ac6454SAndrew Thompson 3661a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 366202ac6454SAndrew Thompson } 366302ac6454SAndrew Thompson } 3664a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 366502ac6454SAndrew Thompson parm, &pc, sizeof(ehci_sitd_t), 366602ac6454SAndrew Thompson EHCI_SITD_ALIGN, nsitd)) { 366702ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 366802ac6454SAndrew Thompson return; 366902ac6454SAndrew Thompson } 367002ac6454SAndrew Thompson if (parm->buf) { 367102ac6454SAndrew Thompson for (n = 0; n != nsitd; n++) { 367202ac6454SAndrew Thompson ehci_sitd_t *td; 367302ac6454SAndrew Thompson 3674a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 367502ac6454SAndrew Thompson 367602ac6454SAndrew Thompson td = page_info.buffer; 367702ac6454SAndrew Thompson 367802ac6454SAndrew Thompson /* init TD */ 3679e55e1ebcSAndrew Thompson td->sitd_self = htohc32(sc, page_info.physaddr | EHCI_LINK_SITD); 368002ac6454SAndrew Thompson td->obj_next = last_obj; 368102ac6454SAndrew Thompson td->page_cache = pc + n; 368202ac6454SAndrew Thompson 368302ac6454SAndrew Thompson last_obj = td; 368402ac6454SAndrew Thompson 3685a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 368602ac6454SAndrew Thompson } 368702ac6454SAndrew Thompson } 3688a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 368902ac6454SAndrew Thompson parm, &pc, sizeof(ehci_qtd_t), 369002ac6454SAndrew Thompson EHCI_QTD_ALIGN, nqtd)) { 369102ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 369202ac6454SAndrew Thompson return; 369302ac6454SAndrew Thompson } 369402ac6454SAndrew Thompson if (parm->buf) { 369502ac6454SAndrew Thompson for (n = 0; n != nqtd; n++) { 369602ac6454SAndrew Thompson ehci_qtd_t *qtd; 369702ac6454SAndrew Thompson 3698a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 369902ac6454SAndrew Thompson 370002ac6454SAndrew Thompson qtd = page_info.buffer; 370102ac6454SAndrew Thompson 370202ac6454SAndrew Thompson /* init TD */ 3703e55e1ebcSAndrew Thompson qtd->qtd_self = htohc32(sc, page_info.physaddr); 370402ac6454SAndrew Thompson qtd->obj_next = last_obj; 370502ac6454SAndrew Thompson qtd->page_cache = pc + n; 370602ac6454SAndrew Thompson 370702ac6454SAndrew Thompson last_obj = qtd; 370802ac6454SAndrew Thompson 3709a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 371002ac6454SAndrew Thompson } 371102ac6454SAndrew Thompson } 371202ac6454SAndrew Thompson xfer->td_start[xfer->flags_int.curr_dma_set] = last_obj; 371302ac6454SAndrew Thompson 371402ac6454SAndrew Thompson last_obj = NULL; 371502ac6454SAndrew Thompson 3716a593f6b8SAndrew Thompson if (usbd_transfer_setup_sub_malloc( 371702ac6454SAndrew Thompson parm, &pc, sizeof(ehci_qh_t), 371802ac6454SAndrew Thompson EHCI_QH_ALIGN, nqh)) { 371902ac6454SAndrew Thompson parm->err = USB_ERR_NOMEM; 372002ac6454SAndrew Thompson return; 372102ac6454SAndrew Thompson } 372202ac6454SAndrew Thompson if (parm->buf) { 372302ac6454SAndrew Thompson for (n = 0; n != nqh; n++) { 372402ac6454SAndrew Thompson ehci_qh_t *qh; 372502ac6454SAndrew Thompson 3726a593f6b8SAndrew Thompson usbd_get_page(pc + n, 0, &page_info); 372702ac6454SAndrew Thompson 372802ac6454SAndrew Thompson qh = page_info.buffer; 372902ac6454SAndrew Thompson 373002ac6454SAndrew Thompson /* init QH */ 3731e55e1ebcSAndrew Thompson qh->qh_self = htohc32(sc, page_info.physaddr | EHCI_LINK_QH); 373202ac6454SAndrew Thompson qh->obj_next = last_obj; 373302ac6454SAndrew Thompson qh->page_cache = pc + n; 373402ac6454SAndrew Thompson 373502ac6454SAndrew Thompson last_obj = qh; 373602ac6454SAndrew Thompson 3737a593f6b8SAndrew Thompson usb_pc_cpu_flush(pc + n); 373802ac6454SAndrew Thompson } 373902ac6454SAndrew Thompson } 374002ac6454SAndrew Thompson xfer->qh_start[xfer->flags_int.curr_dma_set] = last_obj; 374102ac6454SAndrew Thompson 374202ac6454SAndrew Thompson if (!xfer->flags_int.curr_dma_set) { 374302ac6454SAndrew Thompson xfer->flags_int.curr_dma_set = 1; 374402ac6454SAndrew Thompson goto alloc_dma_set; 374502ac6454SAndrew Thompson } 374602ac6454SAndrew Thompson } 374702ac6454SAndrew Thompson 374802ac6454SAndrew Thompson static void 3749760bc48eSAndrew Thompson ehci_xfer_unsetup(struct usb_xfer *xfer) 375002ac6454SAndrew Thompson { 375102ac6454SAndrew Thompson return; 375202ac6454SAndrew Thompson } 375302ac6454SAndrew Thompson 375402ac6454SAndrew Thompson static void 3755ae60fdfbSAndrew Thompson ehci_ep_init(struct usb_device *udev, struct usb_endpoint_descriptor *edesc, 3756ae60fdfbSAndrew Thompson struct usb_endpoint *ep) 375702ac6454SAndrew Thompson { 375802ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(udev->bus); 375902ac6454SAndrew Thompson 3760ae60fdfbSAndrew Thompson DPRINTFN(2, "endpoint=%p, addr=%d, endpt=%d, mode=%d (%d)\n", 3761ae60fdfbSAndrew Thompson ep, udev->address, 3762f29a0724SAndrew Thompson edesc->bEndpointAddress, udev->flags.usb_mode, 376302ac6454SAndrew Thompson sc->sc_addr); 376402ac6454SAndrew Thompson 3765f29a0724SAndrew Thompson if (udev->flags.usb_mode != USB_MODE_HOST) { 376602ac6454SAndrew Thompson /* not supported */ 376702ac6454SAndrew Thompson return; 376802ac6454SAndrew Thompson } 376939307315SAndrew Thompson if (udev->device_index != sc->sc_addr) { 377039307315SAndrew Thompson 377102ac6454SAndrew Thompson if ((udev->speed != USB_SPEED_HIGH) && 377202ac6454SAndrew Thompson ((udev->hs_hub_addr == 0) || 377302ac6454SAndrew Thompson (udev->hs_port_no == 0) || 3774495f25ceSAndrew Thompson (udev->parent_hs_hub == NULL) || 3775495f25ceSAndrew Thompson (udev->parent_hs_hub->hub == NULL))) { 377602ac6454SAndrew Thompson /* We need a transaction translator */ 377702ac6454SAndrew Thompson goto done; 377802ac6454SAndrew Thompson } 377902ac6454SAndrew Thompson switch (edesc->bmAttributes & UE_XFERTYPE) { 378002ac6454SAndrew Thompson case UE_CONTROL: 3781ae60fdfbSAndrew Thompson ep->methods = &ehci_device_ctrl_methods; 378202ac6454SAndrew Thompson break; 378302ac6454SAndrew Thompson case UE_INTERRUPT: 3784ae60fdfbSAndrew Thompson ep->methods = &ehci_device_intr_methods; 378502ac6454SAndrew Thompson break; 378602ac6454SAndrew Thompson case UE_ISOCHRONOUS: 378702ac6454SAndrew Thompson if (udev->speed == USB_SPEED_HIGH) { 3788ae60fdfbSAndrew Thompson ep->methods = &ehci_device_isoc_hs_methods; 378902ac6454SAndrew Thompson } else if (udev->speed == USB_SPEED_FULL) { 3790ae60fdfbSAndrew Thompson ep->methods = &ehci_device_isoc_fs_methods; 379102ac6454SAndrew Thompson } 379202ac6454SAndrew Thompson break; 379302ac6454SAndrew Thompson case UE_BULK: 3794ae60fdfbSAndrew Thompson ep->methods = &ehci_device_bulk_methods; 379502ac6454SAndrew Thompson break; 379602ac6454SAndrew Thompson default: 379702ac6454SAndrew Thompson /* do nothing */ 379802ac6454SAndrew Thompson break; 379902ac6454SAndrew Thompson } 380002ac6454SAndrew Thompson } 380102ac6454SAndrew Thompson done: 380202ac6454SAndrew Thompson return; 380302ac6454SAndrew Thompson } 380402ac6454SAndrew Thompson 380502ac6454SAndrew Thompson static void 3806527aa7b2SAndrew Thompson ehci_get_dma_delay(struct usb_device *udev, uint32_t *pus) 380702ac6454SAndrew Thompson { 380802ac6454SAndrew Thompson /* 380902ac6454SAndrew Thompson * Wait until the hardware has finished any possible use of 381002ac6454SAndrew Thompson * the transfer descriptor(s) and QH 381102ac6454SAndrew Thompson */ 381202ac6454SAndrew Thompson *pus = (188); /* microseconds */ 381302ac6454SAndrew Thompson } 381402ac6454SAndrew Thompson 381502ac6454SAndrew Thompson static void 3816760bc48eSAndrew Thompson ehci_device_resume(struct usb_device *udev) 381702ac6454SAndrew Thompson { 381802ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(udev->bus); 3819760bc48eSAndrew Thompson struct usb_xfer *xfer; 3820760bc48eSAndrew Thompson struct usb_pipe_methods *methods; 382102ac6454SAndrew Thompson 382202ac6454SAndrew Thompson DPRINTF("\n"); 382302ac6454SAndrew Thompson 382402ac6454SAndrew Thompson USB_BUS_LOCK(udev->bus); 382502ac6454SAndrew Thompson 382602ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 382702ac6454SAndrew Thompson 382802ac6454SAndrew Thompson if (xfer->xroot->udev == udev) { 382902ac6454SAndrew Thompson 3830ae60fdfbSAndrew Thompson methods = xfer->endpoint->methods; 383102ac6454SAndrew Thompson 383202ac6454SAndrew Thompson if ((methods == &ehci_device_bulk_methods) || 383302ac6454SAndrew Thompson (methods == &ehci_device_ctrl_methods)) { 383402ac6454SAndrew Thompson EHCI_APPEND_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 383502ac6454SAndrew Thompson sc->sc_async_p_last); 383602ac6454SAndrew Thompson } 383702ac6454SAndrew Thompson if (methods == &ehci_device_intr_methods) { 383802ac6454SAndrew Thompson EHCI_APPEND_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 383902ac6454SAndrew Thompson sc->sc_intr_p_last[xfer->qh_pos]); 384002ac6454SAndrew Thompson } 384102ac6454SAndrew Thompson } 384202ac6454SAndrew Thompson } 384302ac6454SAndrew Thompson 384402ac6454SAndrew Thompson USB_BUS_UNLOCK(udev->bus); 384502ac6454SAndrew Thompson 384602ac6454SAndrew Thompson return; 384702ac6454SAndrew Thompson } 384802ac6454SAndrew Thompson 384902ac6454SAndrew Thompson static void 3850760bc48eSAndrew Thompson ehci_device_suspend(struct usb_device *udev) 385102ac6454SAndrew Thompson { 385202ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(udev->bus); 3853760bc48eSAndrew Thompson struct usb_xfer *xfer; 3854760bc48eSAndrew Thompson struct usb_pipe_methods *methods; 385502ac6454SAndrew Thompson 385602ac6454SAndrew Thompson DPRINTF("\n"); 385702ac6454SAndrew Thompson 385802ac6454SAndrew Thompson USB_BUS_LOCK(udev->bus); 385902ac6454SAndrew Thompson 386002ac6454SAndrew Thompson TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) { 386102ac6454SAndrew Thompson 386202ac6454SAndrew Thompson if (xfer->xroot->udev == udev) { 386302ac6454SAndrew Thompson 3864ae60fdfbSAndrew Thompson methods = xfer->endpoint->methods; 386502ac6454SAndrew Thompson 386602ac6454SAndrew Thompson if ((methods == &ehci_device_bulk_methods) || 386702ac6454SAndrew Thompson (methods == &ehci_device_ctrl_methods)) { 386802ac6454SAndrew Thompson EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 386902ac6454SAndrew Thompson sc->sc_async_p_last); 387002ac6454SAndrew Thompson } 387102ac6454SAndrew Thompson if (methods == &ehci_device_intr_methods) { 387202ac6454SAndrew Thompson EHCI_REMOVE_QH(xfer->qh_start[xfer->flags_int.curr_dma_set], 387302ac6454SAndrew Thompson sc->sc_intr_p_last[xfer->qh_pos]); 387402ac6454SAndrew Thompson } 387502ac6454SAndrew Thompson } 387602ac6454SAndrew Thompson } 387702ac6454SAndrew Thompson 387802ac6454SAndrew Thompson USB_BUS_UNLOCK(udev->bus); 387902ac6454SAndrew Thompson 388002ac6454SAndrew Thompson return; 388102ac6454SAndrew Thompson } 388202ac6454SAndrew Thompson 388302ac6454SAndrew Thompson static void 3884760bc48eSAndrew Thompson ehci_set_hw_power(struct usb_bus *bus) 388502ac6454SAndrew Thompson { 388602ac6454SAndrew Thompson ehci_softc_t *sc = EHCI_BUS2SC(bus); 388702ac6454SAndrew Thompson uint32_t temp; 388802ac6454SAndrew Thompson uint32_t flags; 388902ac6454SAndrew Thompson 389002ac6454SAndrew Thompson DPRINTF("\n"); 389102ac6454SAndrew Thompson 389202ac6454SAndrew Thompson USB_BUS_LOCK(bus); 389302ac6454SAndrew Thompson 389402ac6454SAndrew Thompson flags = bus->hw_power_state; 389502ac6454SAndrew Thompson 389602ac6454SAndrew Thompson temp = EOREAD4(sc, EHCI_USBCMD); 389702ac6454SAndrew Thompson 389802ac6454SAndrew Thompson temp &= ~(EHCI_CMD_ASE | EHCI_CMD_PSE); 389902ac6454SAndrew Thompson 390002ac6454SAndrew Thompson if (flags & (USB_HW_POWER_CONTROL | 390102ac6454SAndrew Thompson USB_HW_POWER_BULK)) { 390202ac6454SAndrew Thompson DPRINTF("Async is active\n"); 390302ac6454SAndrew Thompson temp |= EHCI_CMD_ASE; 390402ac6454SAndrew Thompson } 390502ac6454SAndrew Thompson if (flags & (USB_HW_POWER_INTERRUPT | 390602ac6454SAndrew Thompson USB_HW_POWER_ISOC)) { 390702ac6454SAndrew Thompson DPRINTF("Periodic is active\n"); 390802ac6454SAndrew Thompson temp |= EHCI_CMD_PSE; 390902ac6454SAndrew Thompson } 391002ac6454SAndrew Thompson EOWRITE4(sc, EHCI_USBCMD, temp); 391102ac6454SAndrew Thompson 391202ac6454SAndrew Thompson USB_BUS_UNLOCK(bus); 391302ac6454SAndrew Thompson 391402ac6454SAndrew Thompson return; 391502ac6454SAndrew Thompson } 391602ac6454SAndrew Thompson 3917760bc48eSAndrew Thompson struct usb_bus_methods ehci_bus_methods = 391802ac6454SAndrew Thompson { 3919ae60fdfbSAndrew Thompson .endpoint_init = ehci_ep_init, 392002ac6454SAndrew Thompson .xfer_setup = ehci_xfer_setup, 392102ac6454SAndrew Thompson .xfer_unsetup = ehci_xfer_unsetup, 392202ac6454SAndrew Thompson .get_dma_delay = ehci_get_dma_delay, 392302ac6454SAndrew Thompson .device_resume = ehci_device_resume, 392402ac6454SAndrew Thompson .device_suspend = ehci_device_suspend, 392502ac6454SAndrew Thompson .set_hw_power = ehci_set_hw_power, 392639307315SAndrew Thompson .roothub_exec = ehci_roothub_exec, 3927dddb25f9SAlfred Perlstein .xfer_poll = ehci_do_poll, 392802ac6454SAndrew Thompson }; 3929