Home | History | Annotate | Line # | Download | only in usb
ohci.c revision 1.115
      1  1.115    itojun /*	$NetBSD: ohci.c,v 1.115 2001/11/21 05:52:50 itojun Exp $	*/
      2   1.55  augustss /*	$FreeBSD: src/sys/dev/usb/ohci.c,v 1.22 1999/11/17 22:33:40 n_hibma Exp $	*/
      3    1.1  augustss 
      4    1.1  augustss /*
      5    1.1  augustss  * Copyright (c) 1998 The NetBSD Foundation, Inc.
      6    1.1  augustss  * All rights reserved.
      7    1.1  augustss  *
      8   1.11  augustss  * This code is derived from software contributed to The NetBSD Foundation
      9   1.89  augustss  * by Lennart Augustsson (lennart (at) augustsson.net) at
     10   1.11  augustss  * Carlstedt Research & Technology.
     11    1.1  augustss  *
     12    1.1  augustss  * Redistribution and use in source and binary forms, with or without
     13    1.1  augustss  * modification, are permitted provided that the following conditions
     14    1.1  augustss  * are met:
     15    1.1  augustss  * 1. Redistributions of source code must retain the above copyright
     16    1.1  augustss  *    notice, this list of conditions and the following disclaimer.
     17    1.1  augustss  * 2. Redistributions in binary form must reproduce the above copyright
     18    1.1  augustss  *    notice, this list of conditions and the following disclaimer in the
     19    1.1  augustss  *    documentation and/or other materials provided with the distribution.
     20    1.1  augustss  * 3. All advertising materials mentioning features or use of this software
     21    1.1  augustss  *    must display the following acknowledgement:
     22    1.1  augustss  *        This product includes software developed by the NetBSD
     23    1.1  augustss  *        Foundation, Inc. and its contributors.
     24    1.1  augustss  * 4. Neither the name of The NetBSD Foundation nor the names of its
     25    1.1  augustss  *    contributors may be used to endorse or promote products derived
     26    1.1  augustss  *    from this software without specific prior written permission.
     27    1.1  augustss  *
     28    1.1  augustss  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     29    1.1  augustss  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     30    1.1  augustss  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     31    1.1  augustss  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     32    1.1  augustss  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     33    1.1  augustss  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     34    1.1  augustss  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     35    1.1  augustss  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     36    1.1  augustss  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     37    1.1  augustss  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     38    1.1  augustss  * POSSIBILITY OF SUCH DAMAGE.
     39    1.1  augustss  */
     40    1.1  augustss 
     41    1.1  augustss /*
     42    1.1  augustss  * USB Open Host Controller driver.
     43    1.1  augustss  *
     44   1.96  augustss  * OHCI spec: http://www.compaq.com/productinfo/development/openhci.html
     45   1.96  augustss  * USB spec: http://www.usb.org/developers/data/usbspec.zip
     46    1.1  augustss  */
     47  1.108     lukem 
     48  1.108     lukem #include <sys/cdefs.h>
     49  1.115    itojun __KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.115 2001/11/21 05:52:50 itojun Exp $");
     50    1.1  augustss 
     51    1.1  augustss #include <sys/param.h>
     52    1.1  augustss #include <sys/systm.h>
     53    1.1  augustss #include <sys/malloc.h>
     54   1.36  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
     55   1.55  augustss #include <sys/kernel.h>
     56    1.1  augustss #include <sys/device.h>
     57   1.55  augustss #include <sys/select.h>
     58   1.15  augustss #elif defined(__FreeBSD__)
     59   1.15  augustss #include <sys/module.h>
     60   1.15  augustss #include <sys/bus.h>
     61   1.52  augustss #include <machine/bus_pio.h>
     62   1.52  augustss #include <machine/bus_memio.h>
     63   1.55  augustss #if defined(DIAGNOSTIC) && defined(__i386__) && defined(__FreeBSD__)
     64   1.55  augustss #include <machine/cpu.h>
     65   1.55  augustss #endif
     66   1.15  augustss #endif
     67    1.1  augustss #include <sys/proc.h>
     68    1.1  augustss #include <sys/queue.h>
     69    1.1  augustss 
     70    1.4  augustss #include <machine/bus.h>
     71   1.16  augustss #include <machine/endian.h>
     72    1.4  augustss 
     73    1.1  augustss #include <dev/usb/usb.h>
     74    1.1  augustss #include <dev/usb/usbdi.h>
     75    1.1  augustss #include <dev/usb/usbdivar.h>
     76   1.38  augustss #include <dev/usb/usb_mem.h>
     77    1.1  augustss #include <dev/usb/usb_quirks.h>
     78    1.1  augustss 
     79    1.1  augustss #include <dev/usb/ohcireg.h>
     80    1.1  augustss #include <dev/usb/ohcivar.h>
     81    1.1  augustss 
     82   1.15  augustss #if defined(__FreeBSD__)
     83   1.15  augustss #include <machine/clock.h>
     84   1.55  augustss 
     85   1.15  augustss #define delay(d)                DELAY(d)
     86   1.15  augustss #endif
     87    1.1  augustss 
     88   1.36  augustss #if defined(__OpenBSD__)
     89   1.36  augustss struct cfdriver ohci_cd = {
     90   1.36  augustss 	NULL, "ohci", DV_DULL
     91   1.36  augustss };
     92   1.36  augustss #endif
     93   1.36  augustss 
     94   1.52  augustss #ifdef OHCI_DEBUG
     95   1.52  augustss #define DPRINTF(x)	if (ohcidebug) logprintf x
     96   1.52  augustss #define DPRINTFN(n,x)	if (ohcidebug>(n)) logprintf x
     97   1.52  augustss int ohcidebug = 0;
     98   1.92        tv #ifndef __NetBSD__
     99   1.92        tv #define bitmask_snprintf(q,f,b,l) snprintf((b), (l), "%b", (q), (f))
    100   1.92        tv #endif
    101   1.52  augustss #else
    102   1.52  augustss #define DPRINTF(x)
    103   1.52  augustss #define DPRINTFN(n,x)
    104   1.52  augustss #endif
    105   1.52  augustss 
    106   1.16  augustss /*
    107   1.16  augustss  * The OHCI controller is little endian, so on big endian machines
    108   1.16  augustss  * the data strored in memory needs to be swapped.
    109   1.16  augustss  */
    110   1.84  augustss #if defined(__FreeBSD__) || defined(__OpenBSD__)
    111   1.16  augustss #if BYTE_ORDER == BIG_ENDIAN
    112   1.76   tsutsui #define htole32(x) (bswap32(x))
    113   1.76   tsutsui #define le32toh(x) (bswap32(x))
    114   1.16  augustss #else
    115   1.76   tsutsui #define htole32(x) (x)
    116   1.76   tsutsui #define le32toh(x) (x)
    117   1.76   tsutsui #endif
    118   1.16  augustss #endif
    119   1.16  augustss 
    120    1.1  augustss struct ohci_pipe;
    121    1.1  augustss 
    122   1.91  augustss Static ohci_soft_ed_t  *ohci_alloc_sed(ohci_softc_t *);
    123   1.91  augustss Static void		ohci_free_sed(ohci_softc_t *, ohci_soft_ed_t *);
    124    1.1  augustss 
    125   1.91  augustss Static ohci_soft_td_t  *ohci_alloc_std(ohci_softc_t *);
    126   1.91  augustss Static void		ohci_free_std(ohci_softc_t *, ohci_soft_td_t *);
    127    1.1  augustss 
    128   1.91  augustss Static ohci_soft_itd_t *ohci_alloc_sitd(ohci_softc_t *);
    129   1.91  augustss Static void		ohci_free_sitd(ohci_softc_t *,ohci_soft_itd_t *);
    130   1.60  augustss 
    131   1.53  augustss #if 0
    132   1.91  augustss Static void		ohci_free_std_chain(ohci_softc_t *, ohci_soft_td_t *,
    133   1.91  augustss 					    ohci_soft_td_t *);
    134   1.53  augustss #endif
    135   1.91  augustss Static usbd_status	ohci_alloc_std_chain(struct ohci_pipe *,
    136   1.77  augustss 			    ohci_softc_t *, int, int, usbd_xfer_handle,
    137   1.91  augustss 			    ohci_soft_td_t *, ohci_soft_td_t **);
    138   1.53  augustss 
    139   1.91  augustss Static void		ohci_shutdown(void *v);
    140   1.91  augustss Static void		ohci_power(int, void *);
    141   1.91  augustss Static usbd_status	ohci_open(usbd_pipe_handle);
    142   1.91  augustss Static void		ohci_poll(struct usbd_bus *);
    143   1.99  augustss Static void		ohci_softintr(void *);
    144   1.91  augustss Static void		ohci_waitintr(ohci_softc_t *, usbd_xfer_handle);
    145   1.91  augustss Static void		ohci_add_done(ohci_softc_t *, ohci_physaddr_t);
    146   1.91  augustss Static void		ohci_rhsc(ohci_softc_t *, usbd_xfer_handle);
    147   1.91  augustss 
    148   1.91  augustss Static usbd_status	ohci_device_request(usbd_xfer_handle xfer);
    149   1.91  augustss Static void		ohci_add_ed(ohci_soft_ed_t *, ohci_soft_ed_t *);
    150   1.91  augustss Static void		ohci_rem_ed(ohci_soft_ed_t *, ohci_soft_ed_t *);
    151   1.91  augustss Static void		ohci_hash_add_td(ohci_softc_t *, ohci_soft_td_t *);
    152   1.91  augustss Static void		ohci_hash_rem_td(ohci_softc_t *, ohci_soft_td_t *);
    153   1.91  augustss Static ohci_soft_td_t  *ohci_hash_find_td(ohci_softc_t *, ohci_physaddr_t);
    154   1.91  augustss Static void		ohci_hash_add_itd(ohci_softc_t *, ohci_soft_itd_t *);
    155   1.91  augustss Static void		ohci_hash_rem_itd(ohci_softc_t *, ohci_soft_itd_t *);
    156   1.91  augustss Static ohci_soft_itd_t  *ohci_hash_find_itd(ohci_softc_t *, ohci_physaddr_t);
    157   1.91  augustss 
    158   1.91  augustss Static usbd_status	ohci_setup_isoc(usbd_pipe_handle pipe);
    159   1.91  augustss Static void		ohci_device_isoc_enter(usbd_xfer_handle);
    160   1.91  augustss 
    161   1.91  augustss Static usbd_status	ohci_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t);
    162   1.91  augustss Static void		ohci_freem(struct usbd_bus *, usb_dma_t *);
    163   1.91  augustss 
    164   1.91  augustss Static usbd_xfer_handle	ohci_allocx(struct usbd_bus *);
    165   1.91  augustss Static void		ohci_freex(struct usbd_bus *, usbd_xfer_handle);
    166   1.91  augustss 
    167   1.91  augustss Static usbd_status	ohci_root_ctrl_transfer(usbd_xfer_handle);
    168   1.91  augustss Static usbd_status	ohci_root_ctrl_start(usbd_xfer_handle);
    169   1.91  augustss Static void		ohci_root_ctrl_abort(usbd_xfer_handle);
    170   1.91  augustss Static void		ohci_root_ctrl_close(usbd_pipe_handle);
    171   1.91  augustss Static void		ohci_root_ctrl_done(usbd_xfer_handle);
    172   1.91  augustss 
    173   1.91  augustss Static usbd_status	ohci_root_intr_transfer(usbd_xfer_handle);
    174   1.91  augustss Static usbd_status	ohci_root_intr_start(usbd_xfer_handle);
    175   1.91  augustss Static void		ohci_root_intr_abort(usbd_xfer_handle);
    176   1.91  augustss Static void		ohci_root_intr_close(usbd_pipe_handle);
    177   1.91  augustss Static void		ohci_root_intr_done(usbd_xfer_handle);
    178   1.91  augustss 
    179   1.91  augustss Static usbd_status	ohci_device_ctrl_transfer(usbd_xfer_handle);
    180   1.91  augustss Static usbd_status	ohci_device_ctrl_start(usbd_xfer_handle);
    181   1.91  augustss Static void		ohci_device_ctrl_abort(usbd_xfer_handle);
    182   1.91  augustss Static void		ohci_device_ctrl_close(usbd_pipe_handle);
    183   1.91  augustss Static void		ohci_device_ctrl_done(usbd_xfer_handle);
    184   1.91  augustss 
    185   1.91  augustss Static usbd_status	ohci_device_bulk_transfer(usbd_xfer_handle);
    186   1.91  augustss Static usbd_status	ohci_device_bulk_start(usbd_xfer_handle);
    187   1.91  augustss Static void		ohci_device_bulk_abort(usbd_xfer_handle);
    188   1.91  augustss Static void		ohci_device_bulk_close(usbd_pipe_handle);
    189   1.91  augustss Static void		ohci_device_bulk_done(usbd_xfer_handle);
    190   1.91  augustss 
    191   1.91  augustss Static usbd_status	ohci_device_intr_transfer(usbd_xfer_handle);
    192   1.91  augustss Static usbd_status	ohci_device_intr_start(usbd_xfer_handle);
    193   1.91  augustss Static void		ohci_device_intr_abort(usbd_xfer_handle);
    194   1.91  augustss Static void		ohci_device_intr_close(usbd_pipe_handle);
    195   1.91  augustss Static void		ohci_device_intr_done(usbd_xfer_handle);
    196   1.91  augustss 
    197   1.91  augustss Static usbd_status	ohci_device_isoc_transfer(usbd_xfer_handle);
    198   1.91  augustss Static usbd_status	ohci_device_isoc_start(usbd_xfer_handle);
    199   1.91  augustss Static void		ohci_device_isoc_abort(usbd_xfer_handle);
    200   1.91  augustss Static void		ohci_device_isoc_close(usbd_pipe_handle);
    201   1.91  augustss Static void		ohci_device_isoc_done(usbd_xfer_handle);
    202   1.91  augustss 
    203   1.91  augustss Static usbd_status	ohci_device_setintr(ohci_softc_t *sc,
    204   1.91  augustss 			    struct ohci_pipe *pipe, int ival);
    205   1.91  augustss 
    206   1.91  augustss Static int		ohci_str(usb_string_descriptor_t *, int, char *);
    207   1.91  augustss 
    208   1.91  augustss Static void		ohci_timeout(void *);
    209  1.114  augustss Static void		ohci_timeout_task(void *);
    210   1.91  augustss Static void		ohci_rhsc_able(ohci_softc_t *, int);
    211  1.104  augustss Static void		ohci_rhsc_enable(void *);
    212   1.91  augustss 
    213   1.91  augustss Static void		ohci_close_pipe(usbd_pipe_handle, ohci_soft_ed_t *);
    214   1.91  augustss Static void		ohci_abort_xfer(usbd_xfer_handle, usbd_status);
    215   1.53  augustss 
    216   1.91  augustss Static void		ohci_device_clear_toggle(usbd_pipe_handle pipe);
    217   1.91  augustss Static void		ohci_noop(usbd_pipe_handle pipe);
    218   1.37  augustss 
    219   1.52  augustss #ifdef OHCI_DEBUG
    220   1.91  augustss Static void		ohci_dumpregs(ohci_softc_t *);
    221   1.91  augustss Static void		ohci_dump_tds(ohci_soft_td_t *);
    222   1.91  augustss Static void		ohci_dump_td(ohci_soft_td_t *);
    223   1.91  augustss Static void		ohci_dump_ed(ohci_soft_ed_t *);
    224   1.91  augustss Static void		ohci_dump_itd(ohci_soft_itd_t *);
    225   1.91  augustss Static void		ohci_dump_itds(ohci_soft_itd_t *);
    226    1.1  augustss #endif
    227    1.1  augustss 
    228   1.88  augustss #define OBARR(sc) bus_space_barrier((sc)->iot, (sc)->ioh, 0, (sc)->sc_size, \
    229   1.88  augustss 			BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE)
    230   1.88  augustss #define OWRITE1(sc, r, x) \
    231   1.88  augustss  do { OBARR(sc); bus_space_write_1((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
    232   1.88  augustss #define OWRITE2(sc, r, x) \
    233   1.88  augustss  do { OBARR(sc); bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
    234   1.88  augustss #define OWRITE4(sc, r, x) \
    235   1.88  augustss  do { OBARR(sc); bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x)); } while (0)
    236   1.88  augustss #define OREAD1(sc, r) (OBARR(sc), bus_space_read_1((sc)->iot, (sc)->ioh, (r)))
    237   1.88  augustss #define OREAD2(sc, r) (OBARR(sc), bus_space_read_2((sc)->iot, (sc)->ioh, (r)))
    238   1.88  augustss #define OREAD4(sc, r) (OBARR(sc), bus_space_read_4((sc)->iot, (sc)->ioh, (r)))
    239    1.1  augustss 
    240    1.1  augustss /* Reverse the bits in a value 0 .. 31 */
    241   1.82  augustss Static u_int8_t revbits[OHCI_NO_INTRS] =
    242    1.1  augustss   { 0x00, 0x10, 0x08, 0x18, 0x04, 0x14, 0x0c, 0x1c,
    243    1.1  augustss     0x02, 0x12, 0x0a, 0x1a, 0x06, 0x16, 0x0e, 0x1e,
    244    1.1  augustss     0x01, 0x11, 0x09, 0x19, 0x05, 0x15, 0x0d, 0x1d,
    245    1.1  augustss     0x03, 0x13, 0x0b, 0x1b, 0x07, 0x17, 0x0f, 0x1f };
    246    1.1  augustss 
    247    1.1  augustss struct ohci_pipe {
    248    1.1  augustss 	struct usbd_pipe pipe;
    249    1.1  augustss 	ohci_soft_ed_t *sed;
    250   1.60  augustss 	union {
    251   1.60  augustss 		ohci_soft_td_t *td;
    252   1.60  augustss 		ohci_soft_itd_t *itd;
    253   1.60  augustss 	} tail;
    254    1.1  augustss 	/* Info needed for different pipe kinds. */
    255    1.1  augustss 	union {
    256    1.1  augustss 		/* Control pipe */
    257    1.1  augustss 		struct {
    258    1.4  augustss 			usb_dma_t reqdma;
    259    1.1  augustss 			u_int length;
    260   1.48  augustss 			ohci_soft_td_t *setup, *data, *stat;
    261    1.1  augustss 		} ctl;
    262    1.1  augustss 		/* Interrupt pipe */
    263    1.1  augustss 		struct {
    264    1.1  augustss 			int nslots;
    265    1.1  augustss 			int pos;
    266    1.1  augustss 		} intr;
    267    1.3  augustss 		/* Bulk pipe */
    268    1.3  augustss 		struct {
    269    1.3  augustss 			u_int length;
    270   1.32  augustss 			int isread;
    271    1.3  augustss 		} bulk;
    272   1.43  augustss 		/* Iso pipe */
    273   1.43  augustss 		struct iso {
    274   1.60  augustss 			int next, inuse;
    275   1.43  augustss 		} iso;
    276    1.1  augustss 	} u;
    277    1.1  augustss };
    278    1.1  augustss 
    279    1.1  augustss #define OHCI_INTR_ENDPT 1
    280    1.1  augustss 
    281   1.82  augustss Static struct usbd_bus_methods ohci_bus_methods = {
    282   1.42  augustss 	ohci_open,
    283   1.73  augustss 	ohci_softintr,
    284   1.42  augustss 	ohci_poll,
    285   1.42  augustss 	ohci_allocm,
    286   1.42  augustss 	ohci_freem,
    287   1.62  augustss 	ohci_allocx,
    288   1.62  augustss 	ohci_freex,
    289   1.42  augustss };
    290   1.42  augustss 
    291   1.82  augustss Static struct usbd_pipe_methods ohci_root_ctrl_methods = {
    292    1.1  augustss 	ohci_root_ctrl_transfer,
    293   1.17  augustss 	ohci_root_ctrl_start,
    294    1.1  augustss 	ohci_root_ctrl_abort,
    295    1.1  augustss 	ohci_root_ctrl_close,
    296   1.37  augustss 	ohci_noop,
    297   1.65  augustss 	ohci_root_ctrl_done,
    298    1.1  augustss };
    299    1.1  augustss 
    300   1.82  augustss Static struct usbd_pipe_methods ohci_root_intr_methods = {
    301    1.1  augustss 	ohci_root_intr_transfer,
    302   1.17  augustss 	ohci_root_intr_start,
    303    1.1  augustss 	ohci_root_intr_abort,
    304    1.1  augustss 	ohci_root_intr_close,
    305   1.37  augustss 	ohci_noop,
    306   1.38  augustss 	ohci_root_intr_done,
    307    1.1  augustss };
    308    1.1  augustss 
    309   1.82  augustss Static struct usbd_pipe_methods ohci_device_ctrl_methods = {
    310    1.1  augustss 	ohci_device_ctrl_transfer,
    311   1.17  augustss 	ohci_device_ctrl_start,
    312    1.1  augustss 	ohci_device_ctrl_abort,
    313    1.1  augustss 	ohci_device_ctrl_close,
    314   1.37  augustss 	ohci_noop,
    315   1.38  augustss 	ohci_device_ctrl_done,
    316    1.1  augustss };
    317    1.1  augustss 
    318   1.82  augustss Static struct usbd_pipe_methods ohci_device_intr_methods = {
    319    1.1  augustss 	ohci_device_intr_transfer,
    320   1.17  augustss 	ohci_device_intr_start,
    321    1.1  augustss 	ohci_device_intr_abort,
    322    1.1  augustss 	ohci_device_intr_close,
    323   1.37  augustss 	ohci_device_clear_toggle,
    324   1.38  augustss 	ohci_device_intr_done,
    325    1.1  augustss };
    326    1.1  augustss 
    327   1.82  augustss Static struct usbd_pipe_methods ohci_device_bulk_methods = {
    328    1.3  augustss 	ohci_device_bulk_transfer,
    329   1.17  augustss 	ohci_device_bulk_start,
    330    1.3  augustss 	ohci_device_bulk_abort,
    331    1.3  augustss 	ohci_device_bulk_close,
    332   1.37  augustss 	ohci_device_clear_toggle,
    333   1.38  augustss 	ohci_device_bulk_done,
    334    1.3  augustss };
    335    1.3  augustss 
    336   1.82  augustss Static struct usbd_pipe_methods ohci_device_isoc_methods = {
    337   1.43  augustss 	ohci_device_isoc_transfer,
    338   1.43  augustss 	ohci_device_isoc_start,
    339   1.43  augustss 	ohci_device_isoc_abort,
    340   1.43  augustss 	ohci_device_isoc_close,
    341   1.43  augustss 	ohci_noop,
    342   1.43  augustss 	ohci_device_isoc_done,
    343   1.43  augustss };
    344   1.43  augustss 
    345   1.55  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
    346   1.47  augustss int
    347   1.91  augustss ohci_activate(device_ptr_t self, enum devact act)
    348   1.47  augustss {
    349   1.49  augustss 	struct ohci_softc *sc = (struct ohci_softc *)self;
    350   1.47  augustss 	int rv = 0;
    351   1.47  augustss 
    352   1.47  augustss 	switch (act) {
    353   1.47  augustss 	case DVACT_ACTIVATE:
    354   1.47  augustss 		return (EOPNOTSUPP);
    355   1.47  augustss 		break;
    356   1.47  augustss 
    357   1.47  augustss 	case DVACT_DEACTIVATE:
    358   1.49  augustss 		if (sc->sc_child != NULL)
    359   1.49  augustss 			rv = config_deactivate(sc->sc_child);
    360   1.83  augustss 		sc->sc_dying = 1;
    361   1.47  augustss 		break;
    362   1.47  augustss 	}
    363   1.47  augustss 	return (rv);
    364   1.47  augustss }
    365   1.47  augustss 
    366   1.47  augustss int
    367   1.91  augustss ohci_detach(struct ohci_softc *sc, int flags)
    368   1.47  augustss {
    369   1.47  augustss 	int rv = 0;
    370   1.47  augustss 
    371   1.47  augustss 	if (sc->sc_child != NULL)
    372   1.47  augustss 		rv = config_detach(sc->sc_child, flags);
    373   1.47  augustss 
    374   1.47  augustss 	if (rv != 0)
    375   1.47  augustss 		return (rv);
    376   1.47  augustss 
    377  1.104  augustss 	usb_uncallout(sc->sc_tmo_rhsc, ohci_rhsc_enable, sc);
    378  1.104  augustss 
    379   1.71  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
    380   1.47  augustss 	powerhook_disestablish(sc->sc_powerhook);
    381   1.59  augustss 	shutdownhook_disestablish(sc->sc_shutdownhook);
    382   1.71  augustss #endif
    383   1.59  augustss 
    384   1.47  augustss 	/* free data structures XXX */
    385   1.47  augustss 
    386   1.47  augustss 	return (rv);
    387   1.47  augustss }
    388   1.55  augustss #endif
    389   1.47  augustss 
    390    1.1  augustss ohci_soft_ed_t *
    391   1.91  augustss ohci_alloc_sed(ohci_softc_t *sc)
    392    1.1  augustss {
    393    1.1  augustss 	ohci_soft_ed_t *sed;
    394   1.53  augustss 	usbd_status err;
    395    1.1  augustss 	int i, offs;
    396    1.4  augustss 	usb_dma_t dma;
    397    1.1  augustss 
    398   1.53  augustss 	if (sc->sc_freeeds == NULL) {
    399    1.1  augustss 		DPRINTFN(2, ("ohci_alloc_sed: allocating chunk\n"));
    400   1.53  augustss 		err = usb_allocmem(&sc->sc_bus, OHCI_SED_SIZE * OHCI_SED_CHUNK,
    401   1.53  augustss 			  OHCI_ED_ALIGN, &dma);
    402   1.53  augustss 		if (err)
    403   1.39  augustss 			return (0);
    404   1.39  augustss 		for(i = 0; i < OHCI_SED_CHUNK; i++) {
    405   1.39  augustss 			offs = i * OHCI_SED_SIZE;
    406   1.39  augustss 			sed = (ohci_soft_ed_t *)((char *)KERNADDR(&dma) +offs);
    407    1.1  augustss 			sed->physaddr = DMAADDR(&dma) + offs;
    408    1.1  augustss 			sed->next = sc->sc_freeeds;
    409    1.1  augustss 			sc->sc_freeeds = sed;
    410    1.1  augustss 		}
    411    1.1  augustss 	}
    412    1.1  augustss 	sed = sc->sc_freeeds;
    413    1.1  augustss 	sc->sc_freeeds = sed->next;
    414   1.39  augustss 	memset(&sed->ed, 0, sizeof(ohci_ed_t));
    415    1.1  augustss 	sed->next = 0;
    416   1.39  augustss 	return (sed);
    417    1.1  augustss }
    418    1.1  augustss 
    419    1.1  augustss void
    420   1.91  augustss ohci_free_sed(ohci_softc_t *sc, ohci_soft_ed_t *sed)
    421    1.1  augustss {
    422    1.1  augustss 	sed->next = sc->sc_freeeds;
    423    1.1  augustss 	sc->sc_freeeds = sed;
    424    1.1  augustss }
    425    1.1  augustss 
    426    1.1  augustss ohci_soft_td_t *
    427   1.91  augustss ohci_alloc_std(ohci_softc_t *sc)
    428    1.1  augustss {
    429    1.1  augustss 	ohci_soft_td_t *std;
    430   1.53  augustss 	usbd_status err;
    431    1.1  augustss 	int i, offs;
    432    1.4  augustss 	usb_dma_t dma;
    433   1.69  augustss 	int s;
    434    1.1  augustss 
    435   1.53  augustss 	if (sc->sc_freetds == NULL) {
    436    1.1  augustss 		DPRINTFN(2, ("ohci_alloc_std: allocating chunk\n"));
    437   1.53  augustss 		err = usb_allocmem(&sc->sc_bus, OHCI_STD_SIZE * OHCI_STD_CHUNK,
    438   1.53  augustss 			  OHCI_TD_ALIGN, &dma);
    439   1.53  augustss 		if (err)
    440   1.83  augustss 			return (NULL);
    441   1.69  augustss 		s = splusb();
    442   1.39  augustss 		for(i = 0; i < OHCI_STD_CHUNK; i++) {
    443   1.39  augustss 			offs = i * OHCI_STD_SIZE;
    444   1.39  augustss 			std = (ohci_soft_td_t *)((char *)KERNADDR(&dma) +offs);
    445    1.1  augustss 			std->physaddr = DMAADDR(&dma) + offs;
    446    1.1  augustss 			std->nexttd = sc->sc_freetds;
    447    1.1  augustss 			sc->sc_freetds = std;
    448    1.1  augustss 		}
    449   1.69  augustss 		splx(s);
    450    1.1  augustss 	}
    451   1.69  augustss 
    452   1.69  augustss 	s = splusb();
    453    1.1  augustss 	std = sc->sc_freetds;
    454    1.1  augustss 	sc->sc_freetds = std->nexttd;
    455   1.39  augustss 	memset(&std->td, 0, sizeof(ohci_td_t));
    456   1.83  augustss 	std->nexttd = NULL;
    457   1.83  augustss 	std->xfer = NULL;
    458   1.69  augustss 	ohci_hash_add_td(sc, std);
    459   1.69  augustss 	splx(s);
    460   1.69  augustss 
    461    1.1  augustss 	return (std);
    462    1.1  augustss }
    463    1.1  augustss 
    464    1.1  augustss void
    465   1.91  augustss ohci_free_std(ohci_softc_t *sc, ohci_soft_td_t *std)
    466    1.1  augustss {
    467   1.69  augustss 	int s;
    468   1.69  augustss 
    469   1.69  augustss 	s = splusb();
    470   1.69  augustss 	ohci_hash_rem_td(sc, std);
    471    1.1  augustss 	std->nexttd = sc->sc_freetds;
    472    1.1  augustss 	sc->sc_freetds = std;
    473   1.69  augustss 	splx(s);
    474    1.1  augustss }
    475    1.1  augustss 
    476    1.1  augustss usbd_status
    477   1.91  augustss ohci_alloc_std_chain(struct ohci_pipe *opipe, ohci_softc_t *sc,
    478   1.91  augustss 		     int alen, int rd, usbd_xfer_handle xfer,
    479   1.91  augustss 		     ohci_soft_td_t *sp, ohci_soft_td_t **ep)
    480   1.48  augustss {
    481   1.48  augustss 	ohci_soft_td_t *next, *cur;
    482   1.48  augustss 	ohci_physaddr_t dataphys, dataphysend;
    483   1.77  augustss 	u_int32_t tdflags;
    484   1.75  augustss 	int len, curlen;
    485   1.77  augustss 	usb_dma_t *dma = &xfer->dmabuf;
    486   1.77  augustss 	u_int16_t flags = xfer->flags;
    487   1.48  augustss 
    488   1.75  augustss 	DPRINTFN(alen < 4096,("ohci_alloc_std_chain: start len=%d\n", alen));
    489   1.75  augustss 
    490   1.75  augustss 	len = alen;
    491   1.48  augustss 	cur = sp;
    492   1.48  augustss 	dataphys = DMAADDR(dma);
    493   1.48  augustss 	dataphysend = OHCI_PAGE(dataphys + len - 1);
    494   1.77  augustss 	tdflags = htole32(
    495   1.61  augustss 	    (rd ? OHCI_TD_IN : OHCI_TD_OUT) |
    496   1.77  augustss 	    (flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0) |
    497   1.77  augustss 	    OHCI_TD_NOCC | OHCI_TD_TOGGLE_CARRY | OHCI_TD_NOINTR);
    498   1.61  augustss 
    499   1.48  augustss 	for (;;) {
    500   1.48  augustss 		next = ohci_alloc_std(sc);
    501   1.75  augustss 		if (next == NULL)
    502   1.61  augustss 			goto nomem;
    503   1.48  augustss 
    504   1.48  augustss 		/* The OHCI hardware can handle at most one page crossing. */
    505   1.48  augustss 		if (OHCI_PAGE(dataphys) == dataphysend ||
    506   1.48  augustss 		    OHCI_PAGE(dataphys) + OHCI_PAGE_SIZE == dataphysend) {
    507   1.48  augustss 			/* we can handle it in this TD */
    508   1.48  augustss 			curlen = len;
    509   1.48  augustss 		} else {
    510   1.48  augustss 			/* must use multiple TDs, fill as much as possible. */
    511   1.48  augustss 			curlen = 2 * OHCI_PAGE_SIZE -
    512   1.48  augustss 				 (dataphys & (OHCI_PAGE_SIZE-1));
    513   1.78  augustss 			/* the length must be a multiple of the max size */
    514   1.78  augustss 			curlen -= curlen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize);
    515   1.78  augustss #ifdef DIAGNOSTIC
    516   1.78  augustss 			if (curlen == 0)
    517   1.78  augustss 				panic("ohci_alloc_std: curlen == 0\n");
    518   1.78  augustss #endif
    519   1.48  augustss 		}
    520   1.48  augustss 		DPRINTFN(4,("ohci_alloc_std_chain: dataphys=0x%08x "
    521   1.48  augustss 			    "dataphysend=0x%08x len=%d curlen=%d\n",
    522   1.48  augustss 			    dataphys, dataphysend,
    523   1.48  augustss 			    len, curlen));
    524   1.48  augustss 		len -= curlen;
    525   1.48  augustss 
    526   1.77  augustss 		cur->td.td_flags = tdflags;
    527   1.76   tsutsui 		cur->td.td_cbp = htole32(dataphys);
    528   1.48  augustss 		cur->nexttd = next;
    529   1.76   tsutsui 		cur->td.td_nexttd = htole32(next->physaddr);
    530   1.76   tsutsui 		cur->td.td_be = htole32(dataphys + curlen - 1);
    531   1.48  augustss 		cur->len = curlen;
    532   1.48  augustss 		cur->flags = OHCI_ADD_LEN;
    533   1.77  augustss 		cur->xfer = xfer;
    534   1.48  augustss 		DPRINTFN(10,("ohci_alloc_std_chain: cbp=0x%08x be=0x%08x\n",
    535   1.48  augustss 			    dataphys, dataphys + curlen - 1));
    536   1.48  augustss 		if (len == 0)
    537   1.48  augustss 			break;
    538   1.48  augustss 		DPRINTFN(10,("ohci_alloc_std_chain: extend chain\n"));
    539   1.48  augustss 		dataphys += curlen;
    540   1.48  augustss 		cur = next;
    541   1.48  augustss 	}
    542   1.61  augustss 	if ((flags & USBD_FORCE_SHORT_XFER) &&
    543   1.75  augustss 	    alen % UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize) == 0) {
    544   1.61  augustss 		/* Force a 0 length transfer at the end. */
    545   1.75  augustss 
    546   1.75  augustss 		cur = next;
    547   1.61  augustss 		next = ohci_alloc_std(sc);
    548   1.75  augustss 		if (next == NULL)
    549   1.61  augustss 			goto nomem;
    550   1.61  augustss 
    551   1.77  augustss 		cur->td.td_flags = tdflags;
    552   1.61  augustss 		cur->td.td_cbp = 0; /* indicate 0 length packet */
    553   1.61  augustss 		cur->nexttd = next;
    554   1.76   tsutsui 		cur->td.td_nexttd = htole32(next->physaddr);
    555   1.75  augustss 		cur->td.td_be = ~0;
    556   1.61  augustss 		cur->len = 0;
    557   1.61  augustss 		cur->flags = 0;
    558   1.77  augustss 		cur->xfer = xfer;
    559   1.61  augustss 		DPRINTFN(2,("ohci_alloc_std_chain: add 0 xfer\n"));
    560   1.61  augustss 	}
    561   1.77  augustss 	*ep = cur;
    562   1.48  augustss 
    563   1.48  augustss 	return (USBD_NORMAL_COMPLETION);
    564   1.61  augustss 
    565   1.61  augustss  nomem:
    566   1.61  augustss 	/* XXX free chain */
    567   1.61  augustss 	return (USBD_NOMEM);
    568   1.48  augustss }
    569   1.48  augustss 
    570   1.53  augustss #if 0
    571   1.82  augustss Static void
    572   1.91  augustss ohci_free_std_chain(ohci_softc_t *sc, ohci_soft_td_t *std,
    573   1.91  augustss 		    ohci_soft_td_t *stdend)
    574   1.48  augustss {
    575   1.48  augustss 	ohci_soft_td_t *p;
    576   1.48  augustss 
    577   1.48  augustss 	for (; std != stdend; std = p) {
    578   1.48  augustss 		p = std->nexttd;
    579   1.48  augustss 		ohci_free_std(sc, std);
    580   1.48  augustss 	}
    581   1.48  augustss }
    582   1.53  augustss #endif
    583   1.48  augustss 
    584   1.60  augustss ohci_soft_itd_t *
    585   1.91  augustss ohci_alloc_sitd(ohci_softc_t *sc)
    586   1.60  augustss {
    587   1.60  augustss 	ohci_soft_itd_t *sitd;
    588   1.60  augustss 	usbd_status err;
    589   1.83  augustss 	int i, s, offs;
    590   1.60  augustss 	usb_dma_t dma;
    591   1.60  augustss 
    592   1.60  augustss 	if (sc->sc_freeitds == NULL) {
    593   1.60  augustss 		DPRINTFN(2, ("ohci_alloc_sitd: allocating chunk\n"));
    594   1.83  augustss 		err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
    595   1.83  augustss 			  OHCI_ITD_ALIGN, &dma);
    596   1.60  augustss 		if (err)
    597   1.83  augustss 			return (NULL);
    598   1.83  augustss 		for(i = 0; i < OHCI_SITD_CHUNK; i++) {
    599   1.83  augustss 			offs = i * OHCI_SITD_SIZE;
    600   1.60  augustss 			sitd = (ohci_soft_itd_t *)((char*)KERNADDR(&dma)+offs);
    601   1.60  augustss 			sitd->physaddr = DMAADDR(&dma) + offs;
    602   1.60  augustss 			sitd->nextitd = sc->sc_freeitds;
    603   1.60  augustss 			sc->sc_freeitds = sitd;
    604   1.60  augustss 		}
    605   1.60  augustss 	}
    606   1.83  augustss 
    607   1.83  augustss 	s = splusb();
    608   1.60  augustss 	sitd = sc->sc_freeitds;
    609   1.60  augustss 	sc->sc_freeitds = sitd->nextitd;
    610   1.60  augustss 	memset(&sitd->itd, 0, sizeof(ohci_itd_t));
    611   1.83  augustss 	sitd->nextitd = NULL;
    612   1.83  augustss 	sitd->xfer = NULL;
    613   1.83  augustss 	ohci_hash_add_itd(sc, sitd);
    614   1.83  augustss 	splx(s);
    615   1.83  augustss 
    616   1.83  augustss #ifdef DIAGNOSTIC
    617   1.83  augustss 	sitd->isdone = 0;
    618   1.83  augustss #endif
    619   1.83  augustss 
    620   1.60  augustss 	return (sitd);
    621   1.60  augustss }
    622   1.60  augustss 
    623   1.60  augustss void
    624   1.91  augustss ohci_free_sitd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
    625   1.60  augustss {
    626   1.83  augustss 	int s;
    627   1.83  augustss 
    628   1.83  augustss 	DPRINTFN(10,("ohci_free_sitd: sitd=%p\n", sitd));
    629   1.83  augustss 
    630   1.83  augustss #ifdef DIAGNOSTIC
    631   1.83  augustss 	if (!sitd->isdone) {
    632   1.83  augustss 		panic("ohci_free_sitd: sitd=%p not done\n", sitd);
    633   1.83  augustss 		return;
    634   1.83  augustss 	}
    635   1.83  augustss #endif
    636   1.83  augustss 
    637   1.83  augustss 	s = splusb();
    638   1.83  augustss 	ohci_hash_rem_itd(sc, sitd);
    639   1.60  augustss 	sitd->nextitd = sc->sc_freeitds;
    640   1.60  augustss 	sc->sc_freeitds = sitd;
    641   1.83  augustss 	splx(s);
    642   1.60  augustss }
    643   1.60  augustss 
    644   1.48  augustss usbd_status
    645   1.91  augustss ohci_init(ohci_softc_t *sc)
    646    1.1  augustss {
    647    1.1  augustss 	ohci_soft_ed_t *sed, *psed;
    648   1.53  augustss 	usbd_status err;
    649    1.1  augustss 	int i;
    650   1.68  augustss 	u_int32_t s, ctl, ival, hcr, fm, per, rev, desca;
    651   1.16  augustss 
    652    1.1  augustss 	DPRINTF(("ohci_init: start\n"));
    653   1.36  augustss #if defined(__OpenBSD__)
    654   1.55  augustss 	printf(",");
    655   1.36  augustss #else
    656   1.55  augustss 	printf("%s:", USBDEVNAME(sc->sc_bus.bdev));
    657   1.36  augustss #endif
    658   1.56  augustss 	rev = OREAD4(sc, OHCI_REVISION);
    659   1.55  augustss 	printf(" OHCI version %d.%d%s\n", OHCI_REV_HI(rev), OHCI_REV_LO(rev),
    660    1.1  augustss 	       OHCI_REV_LEGACY(rev) ? ", legacy support" : "");
    661   1.55  augustss 
    662    1.1  augustss 	if (OHCI_REV_HI(rev) != 1 || OHCI_REV_LO(rev) != 0) {
    663    1.1  augustss 		printf("%s: unsupported OHCI revision\n",
    664   1.15  augustss 		       USBDEVNAME(sc->sc_bus.bdev));
    665   1.56  augustss 		sc->sc_bus.usbrev = USBREV_UNKNOWN;
    666    1.1  augustss 		return (USBD_INVAL);
    667    1.1  augustss 	}
    668   1.56  augustss 	sc->sc_bus.usbrev = USBREV_1_0;
    669    1.1  augustss 
    670    1.1  augustss 	for (i = 0; i < OHCI_HASH_SIZE; i++)
    671    1.1  augustss 		LIST_INIT(&sc->sc_hash_tds[i]);
    672   1.83  augustss 	for (i = 0; i < OHCI_HASH_SIZE; i++)
    673   1.83  augustss 		LIST_INIT(&sc->sc_hash_itds[i]);
    674    1.1  augustss 
    675   1.62  augustss 	SIMPLEQ_INIT(&sc->sc_free_xfers);
    676   1.62  augustss 
    677   1.73  augustss 	/* XXX determine alignment by R/W */
    678    1.1  augustss 	/* Allocate the HCCA area. */
    679   1.53  augustss 	err = usb_allocmem(&sc->sc_bus, OHCI_HCCA_SIZE,
    680    1.4  augustss 			 OHCI_HCCA_ALIGN, &sc->sc_hccadma);
    681   1.53  augustss 	if (err)
    682   1.53  augustss 		return (err);
    683    1.1  augustss 	sc->sc_hcca = (struct ohci_hcca *)KERNADDR(&sc->sc_hccadma);
    684    1.1  augustss 	memset(sc->sc_hcca, 0, OHCI_HCCA_SIZE);
    685    1.1  augustss 
    686    1.1  augustss 	sc->sc_eintrs = OHCI_NORMAL_INTRS;
    687    1.1  augustss 
    688   1.60  augustss 	/* Allocate dummy ED that starts the control list. */
    689    1.1  augustss 	sc->sc_ctrl_head = ohci_alloc_sed(sc);
    690   1.53  augustss 	if (sc->sc_ctrl_head == NULL) {
    691   1.53  augustss 		err = USBD_NOMEM;
    692    1.1  augustss 		goto bad1;
    693    1.1  augustss 	}
    694   1.76   tsutsui 	sc->sc_ctrl_head->ed.ed_flags |= htole32(OHCI_ED_SKIP);
    695   1.34  augustss 
    696   1.60  augustss 	/* Allocate dummy ED that starts the bulk list. */
    697    1.1  augustss 	sc->sc_bulk_head = ohci_alloc_sed(sc);
    698   1.53  augustss 	if (sc->sc_bulk_head == NULL) {
    699   1.53  augustss 		err = USBD_NOMEM;
    700    1.1  augustss 		goto bad2;
    701    1.1  augustss 	}
    702   1.76   tsutsui 	sc->sc_bulk_head->ed.ed_flags |= htole32(OHCI_ED_SKIP);
    703    1.1  augustss 
    704   1.60  augustss 	/* Allocate dummy ED that starts the isochronous list. */
    705   1.60  augustss 	sc->sc_isoc_head = ohci_alloc_sed(sc);
    706   1.60  augustss 	if (sc->sc_isoc_head == NULL) {
    707   1.60  augustss 		err = USBD_NOMEM;
    708   1.60  augustss 		goto bad3;
    709   1.60  augustss 	}
    710   1.76   tsutsui 	sc->sc_isoc_head->ed.ed_flags |= htole32(OHCI_ED_SKIP);
    711   1.60  augustss 
    712    1.1  augustss 	/* Allocate all the dummy EDs that make up the interrupt tree. */
    713    1.1  augustss 	for (i = 0; i < OHCI_NO_EDS; i++) {
    714    1.1  augustss 		sed = ohci_alloc_sed(sc);
    715   1.53  augustss 		if (sed == NULL) {
    716    1.1  augustss 			while (--i >= 0)
    717    1.1  augustss 				ohci_free_sed(sc, sc->sc_eds[i]);
    718   1.53  augustss 			err = USBD_NOMEM;
    719   1.60  augustss 			goto bad4;
    720    1.1  augustss 		}
    721    1.1  augustss 		/* All ED fields are set to 0. */
    722    1.1  augustss 		sc->sc_eds[i] = sed;
    723   1.76   tsutsui 		sed->ed.ed_flags |= htole32(OHCI_ED_SKIP);
    724   1.60  augustss 		if (i != 0)
    725    1.1  augustss 			psed = sc->sc_eds[(i-1) / 2];
    726   1.60  augustss 		else
    727   1.60  augustss 			psed= sc->sc_isoc_head;
    728   1.60  augustss 		sed->next = psed;
    729   1.76   tsutsui 		sed->ed.ed_nexted = htole32(psed->physaddr);
    730    1.1  augustss 	}
    731    1.1  augustss 	/*
    732    1.1  augustss 	 * Fill HCCA interrupt table.  The bit reversal is to get
    733    1.1  augustss 	 * the tree set up properly to spread the interrupts.
    734    1.1  augustss 	 */
    735    1.1  augustss 	for (i = 0; i < OHCI_NO_INTRS; i++)
    736    1.1  augustss 		sc->sc_hcca->hcca_interrupt_table[revbits[i]] =
    737   1.76   tsutsui 		    htole32(sc->sc_eds[OHCI_NO_EDS-OHCI_NO_INTRS+i]->physaddr);
    738    1.1  augustss 
    739   1.73  augustss #ifdef OHCI_DEBUG
    740   1.73  augustss 	if (ohcidebug > 15) {
    741   1.73  augustss 		for (i = 0; i < OHCI_NO_EDS; i++) {
    742   1.73  augustss 			printf("ed#%d ", i);
    743   1.73  augustss 			ohci_dump_ed(sc->sc_eds[i]);
    744   1.73  augustss 		}
    745   1.73  augustss 		printf("iso ");
    746   1.73  augustss 		ohci_dump_ed(sc->sc_isoc_head);
    747   1.73  augustss 	}
    748   1.73  augustss #endif
    749   1.73  augustss 
    750    1.1  augustss 	/* Determine in what context we are running. */
    751    1.1  augustss 	ctl = OREAD4(sc, OHCI_CONTROL);
    752    1.1  augustss 	if (ctl & OHCI_IR) {
    753    1.1  augustss 		/* SMM active, request change */
    754    1.1  augustss 		DPRINTF(("ohci_init: SMM active, request owner change\n"));
    755    1.1  augustss 		s = OREAD4(sc, OHCI_COMMAND_STATUS);
    756    1.1  augustss 		OWRITE4(sc, OHCI_COMMAND_STATUS, s | OHCI_OCR);
    757    1.1  augustss 		for (i = 0; i < 100 && (ctl & OHCI_IR); i++) {
    758   1.53  augustss 			usb_delay_ms(&sc->sc_bus, 1);
    759    1.1  augustss 			ctl = OREAD4(sc, OHCI_CONTROL);
    760    1.1  augustss 		}
    761    1.1  augustss 		if ((ctl & OHCI_IR) == 0) {
    762   1.15  augustss 			printf("%s: SMM does not respond, resetting\n",
    763   1.15  augustss 			       USBDEVNAME(sc->sc_bus.bdev));
    764    1.1  augustss 			OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
    765    1.1  augustss 			goto reset;
    766    1.1  augustss 		}
    767  1.103  augustss #if 0
    768  1.103  augustss /* Don't bother trying to reuse the BIOS init, we'll reset it anyway. */
    769    1.1  augustss 	} else if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_RESET) {
    770    1.1  augustss 		/* BIOS started controller. */
    771    1.1  augustss 		DPRINTF(("ohci_init: BIOS active\n"));
    772    1.1  augustss 		if ((ctl & OHCI_HCFS_MASK) != OHCI_HCFS_OPERATIONAL) {
    773    1.1  augustss 			OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_OPERATIONAL);
    774   1.53  augustss 			usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
    775    1.1  augustss 		}
    776  1.103  augustss #endif
    777    1.1  augustss 	} else {
    778    1.1  augustss 		DPRINTF(("ohci_init: cold started\n"));
    779    1.1  augustss 	reset:
    780    1.1  augustss 		/* Controller was cold started. */
    781   1.53  augustss 		usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
    782    1.1  augustss 	}
    783    1.1  augustss 
    784   1.16  augustss 	/*
    785   1.25  augustss 	 * This reset should not be necessary according to the OHCI spec, but
    786   1.25  augustss 	 * without it some controllers do not start.
    787   1.16  augustss 	 */
    788   1.16  augustss 	DPRINTF(("%s: resetting\n", USBDEVNAME(sc->sc_bus.bdev)));
    789   1.16  augustss 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
    790   1.55  augustss 	usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY);
    791   1.16  augustss 
    792    1.1  augustss 	/* We now own the host controller and the bus has been reset. */
    793    1.1  augustss 	ival = OHCI_GET_IVAL(OREAD4(sc, OHCI_FM_INTERVAL));
    794    1.1  augustss 
    795    1.1  augustss 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_HCR); /* Reset HC */
    796    1.1  augustss 	/* Nominal time for a reset is 10 us. */
    797    1.1  augustss 	for (i = 0; i < 10; i++) {
    798    1.1  augustss 		delay(10);
    799    1.1  augustss 		hcr = OREAD4(sc, OHCI_COMMAND_STATUS) & OHCI_HCR;
    800    1.1  augustss 		if (!hcr)
    801    1.1  augustss 			break;
    802    1.1  augustss 	}
    803    1.1  augustss 	if (hcr) {
    804   1.15  augustss 		printf("%s: reset timeout\n", USBDEVNAME(sc->sc_bus.bdev));
    805   1.53  augustss 		err = USBD_IOERROR;
    806   1.60  augustss 		goto bad5;
    807    1.1  augustss 	}
    808   1.52  augustss #ifdef OHCI_DEBUG
    809    1.1  augustss 	if (ohcidebug > 15)
    810    1.1  augustss 		ohci_dumpregs(sc);
    811    1.1  augustss #endif
    812    1.1  augustss 
    813   1.60  augustss 	/* The controller is now in SUSPEND state, we have 2ms to finish. */
    814    1.1  augustss 
    815    1.1  augustss 	/* Set up HC registers. */
    816    1.1  augustss 	OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma));
    817    1.1  augustss 	OWRITE4(sc, OHCI_CONTROL_HEAD_ED, sc->sc_ctrl_head->physaddr);
    818    1.1  augustss 	OWRITE4(sc, OHCI_BULK_HEAD_ED, sc->sc_bulk_head->physaddr);
    819   1.55  augustss 	/* disable all interrupts and then switch on all desired interrupts */
    820    1.1  augustss 	OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS);
    821    1.1  augustss 	OWRITE4(sc, OHCI_INTERRUPT_ENABLE, sc->sc_eintrs | OHCI_MIE);
    822   1.55  augustss 	/* switch on desired functional features */
    823    1.1  augustss 	ctl = OREAD4(sc, OHCI_CONTROL);
    824    1.1  augustss 	ctl &= ~(OHCI_CBSR_MASK | OHCI_LES | OHCI_HCFS_MASK | OHCI_IR);
    825    1.1  augustss 	ctl |= OHCI_PLE | OHCI_IE | OHCI_CLE | OHCI_BLE |
    826    1.1  augustss 		OHCI_RATIO_1_4 | OHCI_HCFS_OPERATIONAL;
    827    1.1  augustss 	/* And finally start it! */
    828    1.1  augustss 	OWRITE4(sc, OHCI_CONTROL, ctl);
    829    1.1  augustss 
    830    1.1  augustss 	/*
    831    1.1  augustss 	 * The controller is now OPERATIONAL.  Set a some final
    832    1.1  augustss 	 * registers that should be set earlier, but that the
    833    1.1  augustss 	 * controller ignores when in the SUSPEND state.
    834    1.1  augustss 	 */
    835    1.1  augustss 	fm = (OREAD4(sc, OHCI_FM_INTERVAL) & OHCI_FIT) ^ OHCI_FIT;
    836    1.1  augustss 	fm |= OHCI_FSMPS(ival) | ival;
    837    1.1  augustss 	OWRITE4(sc, OHCI_FM_INTERVAL, fm);
    838    1.1  augustss 	per = OHCI_PERIODIC(ival); /* 90% periodic */
    839    1.1  augustss 	OWRITE4(sc, OHCI_PERIODIC_START, per);
    840    1.1  augustss 
    841   1.68  augustss 	/* Fiddle the No OverCurrent Protection bit to avoid chip bug. */
    842   1.68  augustss 	desca = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
    843   1.68  augustss 	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca | OHCI_NOCP);
    844   1.68  augustss 	OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); /* Enable port power */
    845   1.85  augustss 	usb_delay_ms(&sc->sc_bus, OHCI_ENABLE_POWER_DELAY);
    846   1.68  augustss 	OWRITE4(sc, OHCI_RH_DESCRIPTOR_A, desca);
    847    1.1  augustss 
    848   1.85  augustss 	/*
    849   1.85  augustss 	 * The AMD756 requires a delay before re-reading the register,
    850   1.85  augustss 	 * otherwise it will occasionally report 0 ports.
    851   1.85  augustss 	 */
    852   1.85  augustss 	usb_delay_ms(&sc->sc_bus, OHCI_READ_DESC_DELAY);
    853    1.1  augustss 	sc->sc_noport = OHCI_GET_NDP(OREAD4(sc, OHCI_RH_DESCRIPTOR_A));
    854    1.1  augustss 
    855   1.52  augustss #ifdef OHCI_DEBUG
    856    1.1  augustss 	if (ohcidebug > 5)
    857    1.1  augustss 		ohci_dumpregs(sc);
    858    1.1  augustss #endif
    859    1.1  augustss 
    860    1.1  augustss 	/* Set up the bus struct. */
    861   1.42  augustss 	sc->sc_bus.methods = &ohci_bus_methods;
    862    1.1  augustss 	sc->sc_bus.pipe_size = sizeof(struct ohci_pipe);
    863    1.1  augustss 
    864   1.71  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
    865  1.101   minoura 	sc->sc_control = sc->sc_intre = 0;
    866   1.47  augustss 	sc->sc_powerhook = powerhook_establish(ohci_power, sc);
    867   1.59  augustss 	sc->sc_shutdownhook = shutdownhook_establish(ohci_shutdown, sc);
    868   1.71  augustss #endif
    869   1.59  augustss 
    870  1.104  augustss 	usb_callout_init(sc->sc_tmo_rhsc);
    871  1.104  augustss 
    872    1.1  augustss 	return (USBD_NORMAL_COMPLETION);
    873    1.1  augustss 
    874   1.60  augustss  bad5:
    875   1.60  augustss 	for (i = 0; i < OHCI_NO_EDS; i++)
    876   1.60  augustss 		ohci_free_sed(sc, sc->sc_eds[i]);
    877   1.60  augustss  bad4:
    878   1.60  augustss 	ohci_free_sed(sc, sc->sc_isoc_head);
    879    1.1  augustss  bad3:
    880    1.1  augustss 	ohci_free_sed(sc, sc->sc_ctrl_head);
    881    1.1  augustss  bad2:
    882    1.1  augustss 	ohci_free_sed(sc, sc->sc_bulk_head);
    883    1.1  augustss  bad1:
    884   1.44  augustss 	usb_freemem(&sc->sc_bus, &sc->sc_hccadma);
    885   1.53  augustss 	return (err);
    886    1.1  augustss }
    887    1.1  augustss 
    888   1.42  augustss usbd_status
    889   1.91  augustss ohci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size)
    890   1.42  augustss {
    891   1.52  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
    892   1.42  augustss 	struct ohci_softc *sc = (struct ohci_softc *)bus;
    893   1.52  augustss #endif
    894   1.42  augustss 
    895   1.44  augustss 	return (usb_allocmem(&sc->sc_bus, size, 0, dma));
    896   1.42  augustss }
    897   1.42  augustss 
    898   1.42  augustss void
    899   1.91  augustss ohci_freem(struct usbd_bus *bus, usb_dma_t *dma)
    900   1.42  augustss {
    901   1.52  augustss #if defined(__NetBSD__) || defined(__OpenBSD__)
    902   1.42  augustss 	struct ohci_softc *sc = (struct ohci_softc *)bus;
    903   1.52  augustss #endif
    904   1.42  augustss 
    905   1.44  augustss 	usb_freemem(&sc->sc_bus, dma);
    906   1.62  augustss }
    907   1.62  augustss 
    908   1.62  augustss usbd_xfer_handle
    909   1.91  augustss ohci_allocx(struct usbd_bus *bus)
    910   1.62  augustss {
    911   1.62  augustss 	struct ohci_softc *sc = (struct ohci_softc *)bus;
    912   1.62  augustss 	usbd_xfer_handle xfer;
    913   1.62  augustss 
    914   1.62  augustss 	xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers);
    915   1.62  augustss 	if (xfer != NULL)
    916   1.62  augustss 		SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, xfer, next);
    917   1.62  augustss 	else
    918  1.114  augustss 		xfer = malloc(sizeof(struct ohci_xfer), M_USB, M_NOWAIT);
    919   1.63  augustss 	if (xfer != NULL)
    920  1.114  augustss 		memset(xfer, 0, sizeof (struct ohci_xfer));
    921   1.62  augustss 	return (xfer);
    922   1.62  augustss }
    923   1.62  augustss 
    924   1.62  augustss void
    925   1.91  augustss ohci_freex(struct usbd_bus *bus, usbd_xfer_handle xfer)
    926   1.62  augustss {
    927   1.62  augustss 	struct ohci_softc *sc = (struct ohci_softc *)bus;
    928   1.62  augustss 
    929   1.62  augustss 	SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next);
    930   1.42  augustss }
    931   1.42  augustss 
    932   1.59  augustss /*
    933   1.59  augustss  * Shut down the controller when the system is going down.
    934   1.59  augustss  */
    935   1.59  augustss void
    936   1.91  augustss ohci_shutdown(void *v)
    937   1.59  augustss {
    938   1.59  augustss 	ohci_softc_t *sc = v;
    939   1.59  augustss 
    940   1.59  augustss 	DPRINTF(("ohci_shutdown: stopping the HC\n"));
    941   1.59  augustss 	OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
    942   1.59  augustss }
    943   1.59  augustss 
    944   1.59  augustss /*
    945   1.59  augustss  * Handle suspend/resume.
    946   1.59  augustss  *
    947   1.59  augustss  * We need to switch to polling mode here, because this routine is
    948   1.59  augustss  * called from an intterupt context.  This is all right since we
    949   1.59  augustss  * are almost suspended anyway.
    950   1.59  augustss  */
    951   1.33  augustss void
    952   1.91  augustss ohci_power(int why, void *v)
    953   1.33  augustss {
    954   1.33  augustss 	ohci_softc_t *sc = v;
    955   1.97  augustss 	u_int32_t ctl;
    956   1.95  augustss 	int s;
    957   1.33  augustss 
    958   1.95  augustss #ifdef OHCI_DEBUG
    959   1.41  augustss 	DPRINTF(("ohci_power: sc=%p, why=%d\n", sc, why));
    960   1.33  augustss 	ohci_dumpregs(sc);
    961   1.33  augustss #endif
    962   1.95  augustss 
    963   1.98  augustss 	s = splhardusb();
    964   1.95  augustss 	switch (why) {
    965   1.95  augustss 	case PWR_SUSPEND:
    966   1.95  augustss 	case PWR_STANDBY:
    967   1.97  augustss 		sc->sc_bus.use_polling++;
    968  1.101   minoura 		ctl = OREAD4(sc, OHCI_CONTROL) & ~OHCI_HCFS_MASK;
    969  1.101   minoura 		if (sc->sc_control == 0) {
    970  1.101   minoura 			/*
    971  1.101   minoura 			 * Preserve register values, in case that APM BIOS
    972  1.101   minoura 			 * does not recover them.
    973  1.101   minoura 			 */
    974  1.101   minoura 			sc->sc_control = ctl;
    975  1.101   minoura 			sc->sc_intre = OREAD4(sc, OHCI_INTERRUPT_ENABLE);
    976  1.101   minoura 		}
    977  1.101   minoura 		ctl |= OHCI_HCFS_SUSPEND;
    978   1.97  augustss 		OWRITE4(sc, OHCI_CONTROL, ctl);
    979   1.97  augustss 		usb_delay_ms(&sc->sc_bus, USB_RESUME_WAIT);
    980   1.97  augustss 		sc->sc_bus.use_polling--;
    981   1.95  augustss 		break;
    982   1.95  augustss 	case PWR_RESUME:
    983   1.97  augustss 		sc->sc_bus.use_polling++;
    984  1.101   minoura 		/* Some broken BIOSes do not recover these values */
    985  1.101   minoura 		OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma));
    986  1.101   minoura 		OWRITE4(sc, OHCI_CONTROL_HEAD_ED, sc->sc_ctrl_head->physaddr);
    987  1.101   minoura 		OWRITE4(sc, OHCI_BULK_HEAD_ED, sc->sc_bulk_head->physaddr);
    988  1.101   minoura 		if (sc->sc_intre)
    989  1.101   minoura 			OWRITE4(sc, OHCI_INTERRUPT_ENABLE,
    990  1.101   minoura 				sc->sc_intre & (OHCI_ALL_INTRS | OHCI_MIE));
    991  1.101   minoura 		if (sc->sc_control)
    992  1.101   minoura 			ctl = sc->sc_control;
    993  1.101   minoura 		else
    994  1.101   minoura 			ctl = OREAD4(sc, OHCI_CONTROL);
    995  1.101   minoura 		ctl |= OHCI_HCFS_RESUME;
    996   1.97  augustss 		OWRITE4(sc, OHCI_CONTROL, ctl);
    997   1.97  augustss 		usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY);
    998   1.97  augustss 		ctl = (ctl & ~OHCI_HCFS_MASK) | OHCI_HCFS_OPERATIONAL;
    999   1.97  augustss 		OWRITE4(sc, OHCI_CONTROL, ctl);
   1000   1.97  augustss 		usb_delay_ms(&sc->sc_bus, USB_RESUME_RECOVERY);
   1001  1.101   minoura 		sc->sc_control = sc->sc_intre = 0;
   1002   1.97  augustss 		sc->sc_bus.use_polling--;
   1003   1.95  augustss 		break;
   1004   1.95  augustss 	case PWR_SOFTSUSPEND:
   1005   1.95  augustss 	case PWR_SOFTSTANDBY:
   1006   1.95  augustss 	case PWR_SOFTRESUME:
   1007   1.95  augustss 		break;
   1008   1.95  augustss 	}
   1009   1.95  augustss 	splx(s);
   1010   1.33  augustss }
   1011   1.33  augustss 
   1012   1.52  augustss #ifdef OHCI_DEBUG
   1013    1.1  augustss void
   1014   1.91  augustss ohci_dumpregs(ohci_softc_t *sc)
   1015    1.1  augustss {
   1016   1.41  augustss 	DPRINTF(("ohci_dumpregs: rev=0x%08x control=0x%08x command=0x%08x\n",
   1017   1.41  augustss 		 OREAD4(sc, OHCI_REVISION),
   1018   1.41  augustss 		 OREAD4(sc, OHCI_CONTROL),
   1019   1.41  augustss 		 OREAD4(sc, OHCI_COMMAND_STATUS)));
   1020   1.41  augustss 	DPRINTF(("               intrstat=0x%08x intre=0x%08x intrd=0x%08x\n",
   1021   1.41  augustss 		 OREAD4(sc, OHCI_INTERRUPT_STATUS),
   1022   1.41  augustss 		 OREAD4(sc, OHCI_INTERRUPT_ENABLE),
   1023   1.41  augustss 		 OREAD4(sc, OHCI_INTERRUPT_DISABLE)));
   1024   1.41  augustss 	DPRINTF(("               hcca=0x%08x percur=0x%08x ctrlhd=0x%08x\n",
   1025   1.41  augustss 		 OREAD4(sc, OHCI_HCCA),
   1026   1.41  augustss 		 OREAD4(sc, OHCI_PERIOD_CURRENT_ED),
   1027   1.41  augustss 		 OREAD4(sc, OHCI_CONTROL_HEAD_ED)));
   1028   1.41  augustss 	DPRINTF(("               ctrlcur=0x%08x bulkhd=0x%08x bulkcur=0x%08x\n",
   1029   1.41  augustss 		 OREAD4(sc, OHCI_CONTROL_CURRENT_ED),
   1030   1.41  augustss 		 OREAD4(sc, OHCI_BULK_HEAD_ED),
   1031   1.41  augustss 		 OREAD4(sc, OHCI_BULK_CURRENT_ED)));
   1032   1.41  augustss 	DPRINTF(("               done=0x%08x fmival=0x%08x fmrem=0x%08x\n",
   1033   1.41  augustss 		 OREAD4(sc, OHCI_DONE_HEAD),
   1034   1.41  augustss 		 OREAD4(sc, OHCI_FM_INTERVAL),
   1035   1.41  augustss 		 OREAD4(sc, OHCI_FM_REMAINING)));
   1036   1.41  augustss 	DPRINTF(("               fmnum=0x%08x perst=0x%08x lsthrs=0x%08x\n",
   1037   1.41  augustss 		 OREAD4(sc, OHCI_FM_NUMBER),
   1038   1.41  augustss 		 OREAD4(sc, OHCI_PERIODIC_START),
   1039   1.41  augustss 		 OREAD4(sc, OHCI_LS_THRESHOLD)));
   1040   1.41  augustss 	DPRINTF(("               desca=0x%08x descb=0x%08x stat=0x%08x\n",
   1041   1.41  augustss 		 OREAD4(sc, OHCI_RH_DESCRIPTOR_A),
   1042   1.41  augustss 		 OREAD4(sc, OHCI_RH_DESCRIPTOR_B),
   1043   1.41  augustss 		 OREAD4(sc, OHCI_RH_STATUS)));
   1044   1.41  augustss 	DPRINTF(("               port1=0x%08x port2=0x%08x\n",
   1045   1.41  augustss 		 OREAD4(sc, OHCI_RH_PORT_STATUS(1)),
   1046   1.41  augustss 		 OREAD4(sc, OHCI_RH_PORT_STATUS(2))));
   1047   1.41  augustss 	DPRINTF(("         HCCA: frame_number=0x%04x done_head=0x%08x\n",
   1048   1.76   tsutsui 		 le32toh(sc->sc_hcca->hcca_frame_number),
   1049   1.76   tsutsui 		 le32toh(sc->sc_hcca->hcca_done_head)));
   1050    1.1  augustss }
   1051    1.1  augustss #endif
   1052    1.1  augustss 
   1053   1.91  augustss Static int ohci_intr1(ohci_softc_t *);
   1054   1.53  augustss 
   1055    1.1  augustss int
   1056   1.91  augustss ohci_intr(void *p)
   1057    1.1  augustss {
   1058    1.1  augustss 	ohci_softc_t *sc = p;
   1059  1.111  augustss 
   1060  1.111  augustss 	if (sc->sc_dying)
   1061  1.111  augustss 		return (0);
   1062   1.53  augustss 
   1063   1.53  augustss 	/* If we get an interrupt while polling, then just ignore it. */
   1064   1.57  augustss 	if (sc->sc_bus.use_polling) {
   1065   1.57  augustss #ifdef DIAGNOSTIC
   1066   1.57  augustss 		printf("ohci_intr: ignored interrupt while polling\n");
   1067   1.57  augustss #endif
   1068   1.53  augustss 		return (0);
   1069   1.57  augustss 	}
   1070   1.53  augustss 
   1071   1.53  augustss 	return (ohci_intr1(sc));
   1072   1.53  augustss }
   1073   1.53  augustss 
   1074   1.82  augustss Static int
   1075   1.91  augustss ohci_intr1(ohci_softc_t *sc)
   1076   1.53  augustss {
   1077    1.1  augustss 	u_int32_t intrs, eintrs;
   1078    1.1  augustss 	ohci_physaddr_t done;
   1079    1.1  augustss 
   1080  1.105  augustss 	DPRINTFN(14,("ohci_intr1: enter\n"));
   1081  1.105  augustss 
   1082   1.15  augustss 	/* In case the interrupt occurs before initialization has completed. */
   1083   1.34  augustss 	if (sc == NULL || sc->sc_hcca == NULL) {
   1084   1.15  augustss #ifdef DIAGNOSTIC
   1085   1.15  augustss 		printf("ohci_intr: sc->sc_hcca == NULL\n");
   1086   1.15  augustss #endif
   1087   1.15  augustss 		return (0);
   1088   1.15  augustss 	}
   1089   1.15  augustss 
   1090   1.27  augustss         intrs = 0;
   1091   1.76   tsutsui 	done = le32toh(sc->sc_hcca->hcca_done_head);
   1092    1.1  augustss 	if (done != 0) {
   1093   1.26  augustss 		if (done & ~OHCI_DONE_INTRS)
   1094   1.26  augustss 			intrs = OHCI_WDH;
   1095    1.1  augustss 		if (done & OHCI_DONE_INTRS)
   1096    1.1  augustss 			intrs |= OREAD4(sc, OHCI_INTERRUPT_STATUS);
   1097    1.1  augustss 	} else
   1098    1.1  augustss 		intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS);
   1099   1.55  augustss 
   1100    1.1  augustss 	if (!intrs)
   1101    1.1  augustss 		return (0);
   1102   1.55  augustss 
   1103    1.1  augustss 	intrs &= ~OHCI_MIE;
   1104    1.1  augustss 	OWRITE4(sc, OHCI_INTERRUPT_STATUS, intrs); /* Acknowledge */
   1105    1.1  augustss 	eintrs = intrs & sc->sc_eintrs;
   1106    1.1  augustss 	if (!eintrs)
   1107    1.1  augustss 		return (0);
   1108    1.1  augustss 
   1109   1.45  augustss 	sc->sc_bus.intr_context++;
   1110   1.44  augustss 	sc->sc_bus.no_intrs++;
   1111   1.73  augustss 	DPRINTFN(7, ("ohci_intr: sc=%p intrs=0x%x(0x%x) eintrs=0x%x\n",
   1112    1.1  augustss 		     sc, (u_int)intrs, OREAD4(sc, OHCI_INTERRUPT_STATUS),
   1113    1.1  augustss 		     (u_int)eintrs));
   1114    1.1  augustss 
   1115    1.1  augustss 	if (eintrs & OHCI_SO) {
   1116  1.100  augustss 		sc->sc_overrun_cnt++;
   1117  1.100  augustss 		if (usbd_ratecheck(&sc->sc_overrun_ntc)) {
   1118  1.100  augustss 			printf("%s: %u scheduling overruns\n",
   1119  1.100  augustss 			    USBDEVNAME(sc->sc_bus.bdev), sc->sc_overrun_cnt);
   1120  1.100  augustss 			sc->sc_overrun_cnt = 0;
   1121  1.100  augustss 		}
   1122    1.1  augustss 		/* XXX do what */
   1123  1.106  augustss 		eintrs &= ~OHCI_SO;
   1124    1.1  augustss 	}
   1125    1.1  augustss 	if (eintrs & OHCI_WDH) {
   1126   1.83  augustss 		ohci_add_done(sc, done &~ OHCI_DONE_INTRS);
   1127   1.72  augustss 		sc->sc_hcca->hcca_done_head = 0;
   1128   1.72  augustss 		usb_schedsoftintr(&sc->sc_bus);
   1129  1.106  augustss 		eintrs &= ~OHCI_WDH;
   1130    1.1  augustss 	}
   1131    1.1  augustss 	if (eintrs & OHCI_RD) {
   1132   1.33  augustss 		printf("%s: resume detect\n", USBDEVNAME(sc->sc_bus.bdev));
   1133    1.1  augustss 		/* XXX process resume detect */
   1134    1.1  augustss 	}
   1135    1.1  augustss 	if (eintrs & OHCI_UE) {
   1136   1.15  augustss 		printf("%s: unrecoverable error, controller halted\n",
   1137   1.15  augustss 		       USBDEVNAME(sc->sc_bus.bdev));
   1138    1.1  augustss 		OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET);
   1139    1.1  augustss 		/* XXX what else */
   1140    1.1  augustss 	}
   1141    1.1  augustss 	if (eintrs & OHCI_RHSC) {
   1142   1.53  augustss 		ohci_rhsc(sc, sc->sc_intrxfer);
   1143    1.1  augustss 		/*
   1144    1.1  augustss 		 * Disable RHSC interrupt for now, because it will be
   1145    1.1  augustss 		 * on until the port has been reset.
   1146    1.1  augustss 		 */
   1147    1.1  augustss 		ohci_rhsc_able(sc, 0);
   1148  1.104  augustss 		/* Do not allow RHSC interrupts > 1 per second */
   1149  1.104  augustss                 usb_callout(sc->sc_tmo_rhsc, hz, ohci_rhsc_enable, sc);
   1150  1.106  augustss 		eintrs &= ~OHCI_RHSC;
   1151    1.1  augustss 	}
   1152    1.1  augustss 
   1153   1.45  augustss 	sc->sc_bus.intr_context--;
   1154   1.44  augustss 
   1155  1.106  augustss 	if (eintrs != 0) {
   1156  1.106  augustss 		/* Block unprocessed interrupts. XXX */
   1157  1.106  augustss 		OWRITE4(sc, OHCI_INTERRUPT_DISABLE, eintrs);
   1158  1.106  augustss 		sc->sc_eintrs &= ~eintrs;
   1159  1.106  augustss 		printf("%s: blocking intrs 0x%x\n",
   1160  1.106  augustss 		       USBDEVNAME(sc->sc_bus.bdev), eintrs);
   1161  1.106  augustss 	}
   1162    1.1  augustss 
   1163    1.1  augustss 	return (1);
   1164    1.1  augustss }
   1165    1.1  augustss 
   1166    1.1  augustss void
   1167   1.91  augustss ohci_rhsc_able(ohci_softc_t *sc, int on)
   1168    1.1  augustss {
   1169    1.1  augustss 	DPRINTFN(4, ("ohci_rhsc_able: on=%d\n", on));
   1170    1.1  augustss 	if (on) {
   1171    1.1  augustss 		sc->sc_eintrs |= OHCI_RHSC;
   1172    1.1  augustss 		OWRITE4(sc, OHCI_INTERRUPT_ENABLE, OHCI_RHSC);
   1173    1.1  augustss 	} else {
   1174    1.1  augustss 		sc->sc_eintrs &= ~OHCI_RHSC;
   1175    1.1  augustss 		OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_RHSC);
   1176    1.1  augustss 	}
   1177  1.104  augustss }
   1178  1.104  augustss 
   1179  1.104  augustss void
   1180  1.104  augustss ohci_rhsc_enable(void *v_sc)
   1181  1.104  augustss {
   1182  1.104  augustss 	ohci_softc_t *sc = v_sc;
   1183  1.104  augustss 
   1184  1.104  augustss 	ohci_rhsc_able(sc, 1);
   1185    1.1  augustss }
   1186    1.1  augustss 
   1187   1.52  augustss #ifdef OHCI_DEBUG
   1188   1.13  augustss char *ohci_cc_strs[] = {
   1189   1.13  augustss 	"NO_ERROR",
   1190   1.13  augustss 	"CRC",
   1191   1.13  augustss 	"BIT_STUFFING",
   1192   1.13  augustss 	"DATA_TOGGLE_MISMATCH",
   1193   1.13  augustss 	"STALL",
   1194   1.13  augustss 	"DEVICE_NOT_RESPONDING",
   1195   1.13  augustss 	"PID_CHECK_FAILURE",
   1196   1.13  augustss 	"UNEXPECTED_PID",
   1197   1.13  augustss 	"DATA_OVERRUN",
   1198   1.13  augustss 	"DATA_UNDERRUN",
   1199   1.13  augustss 	"BUFFER_OVERRUN",
   1200   1.13  augustss 	"BUFFER_UNDERRUN",
   1201   1.67  augustss 	"reserved",
   1202   1.67  augustss 	"reserved",
   1203   1.67  augustss 	"NOT_ACCESSED",
   1204   1.13  augustss 	"NOT_ACCESSED",
   1205   1.13  augustss };
   1206   1.13  augustss #endif
   1207   1.13  augustss 
   1208    1.1  augustss void
   1209   1.91  augustss ohci_add_done(ohci_softc_t *sc, ohci_physaddr_t done)
   1210   1.83  augustss {
   1211   1.83  augustss 	ohci_soft_itd_t *sitd, *sidone, **ip;
   1212   1.83  augustss 	ohci_soft_td_t  *std,  *sdone,  **p;
   1213   1.83  augustss 
   1214   1.83  augustss 	/* Reverse the done list. */
   1215   1.83  augustss 	for (sdone = NULL, sidone = NULL; done != 0; ) {
   1216   1.83  augustss 		std = ohci_hash_find_td(sc, done);
   1217   1.83  augustss 		if (std != NULL) {
   1218   1.83  augustss 			std->dnext = sdone;
   1219   1.83  augustss 			done = le32toh(std->td.td_nexttd);
   1220   1.83  augustss 			sdone = std;
   1221   1.83  augustss 			DPRINTFN(10,("add TD %p\n", std));
   1222   1.83  augustss 			continue;
   1223   1.83  augustss 		}
   1224   1.83  augustss 		sitd = ohci_hash_find_itd(sc, done);
   1225   1.83  augustss 		if (sitd != NULL) {
   1226   1.83  augustss 			sitd->dnext = sidone;
   1227   1.83  augustss 			done = le32toh(sitd->itd.itd_nextitd);
   1228   1.83  augustss 			sidone = sitd;
   1229   1.83  augustss 			DPRINTFN(5,("add ITD %p\n", sitd));
   1230   1.83  augustss 			continue;
   1231   1.83  augustss 		}
   1232   1.83  augustss 		panic("ohci_add_done: addr 0x%08lx not found\n", (u_long)done);
   1233   1.83  augustss 	}
   1234   1.83  augustss 
   1235   1.83  augustss 	/* sdone & sidone now hold the done lists. */
   1236   1.83  augustss 	/* Put them on the already processed lists. */
   1237   1.83  augustss 	for (p = &sc->sc_sdone; *p != NULL; p = &(*p)->dnext)
   1238   1.83  augustss 		;
   1239   1.83  augustss 	*p = sdone;
   1240   1.83  augustss 	for (ip = &sc->sc_sidone; *ip != NULL; ip = &(*ip)->dnext)
   1241   1.83  augustss 		;
   1242   1.83  augustss 	*ip = sidone;
   1243   1.83  augustss }
   1244   1.83  augustss 
   1245   1.83  augustss void
   1246   1.99  augustss ohci_softintr(void *v)
   1247   1.72  augustss {
   1248   1.99  augustss 	ohci_softc_t *sc = v;
   1249   1.83  augustss 	ohci_soft_itd_t *sitd, *sidone, *sitdnext;
   1250   1.83  augustss 	ohci_soft_td_t  *std,  *sdone,  *stdnext;
   1251   1.53  augustss 	usbd_xfer_handle xfer;
   1252   1.72  augustss 	int len, cc, s;
   1253   1.72  augustss 
   1254  1.105  augustss 	DPRINTFN(10,("ohci_softintr: enter\n:"));
   1255  1.105  augustss 
   1256   1.72  augustss 	sc->sc_bus.intr_context++;
   1257   1.72  augustss 
   1258   1.72  augustss 	s = splhardusb();
   1259   1.83  augustss 	sdone = sc->sc_sdone;
   1260   1.83  augustss 	sc->sc_sdone = NULL;
   1261   1.83  augustss 	sidone = sc->sc_sidone;
   1262   1.83  augustss 	sc->sc_sidone = NULL;
   1263   1.72  augustss 	splx(s);
   1264    1.1  augustss 
   1265  1.105  augustss 	DPRINTFN(10,("ohci_softintr: sdone=%p sidone=%p\n", sdone, sidone));
   1266    1.1  augustss 
   1267   1.52  augustss #ifdef OHCI_DEBUG
   1268    1.1  augustss 	if (ohcidebug > 10) {
   1269   1.41  augustss 		DPRINTF(("ohci_process_done: TD done:\n"));
   1270    1.1  augustss 		ohci_dump_tds(sdone);
   1271    1.1  augustss 	}
   1272    1.1  augustss #endif
   1273    1.1  augustss 
   1274   1.48  augustss 	for (std = sdone; std; std = stdnext) {
   1275   1.53  augustss 		xfer = std->xfer;
   1276   1.48  augustss 		stdnext = std->dnext;
   1277   1.53  augustss 		DPRINTFN(10, ("ohci_process_done: std=%p xfer=%p hcpriv=%p\n",
   1278   1.69  augustss 				std, xfer, xfer ? xfer->hcpriv : 0));
   1279   1.71  augustss 		if (xfer == NULL) {
   1280   1.71  augustss 			/* xfer == NULL: There seems to be no xfer associated
   1281   1.71  augustss 			 * with this TD. It is tailp that happened to end up on
   1282   1.71  augustss 			 * the done queue.
   1283   1.71  augustss 			 */
   1284   1.71  augustss 			continue;
   1285   1.71  augustss 		}
   1286   1.53  augustss 		if (xfer->status == USBD_CANCELLED ||
   1287   1.53  augustss 		    xfer->status == USBD_TIMEOUT) {
   1288   1.34  augustss 			DPRINTF(("ohci_process_done: cancel/timeout %p\n",
   1289   1.53  augustss 				 xfer));
   1290   1.38  augustss 			/* Handled by abort routine. */
   1291   1.83  augustss 			continue;
   1292   1.83  augustss 		}
   1293   1.83  augustss 		usb_uncallout(xfer->timeout_handle, ohci_timeout, xfer);
   1294   1.83  augustss 		cc = OHCI_TD_GET_CC(le32toh(std->td.td_flags));
   1295   1.83  augustss 		if (cc == OHCI_CC_NO_ERROR) {
   1296   1.34  augustss 			len = std->len;
   1297   1.39  augustss 			if (std->td.td_cbp != 0)
   1298   1.76   tsutsui 				len -= le32toh(std->td.td_be) -
   1299   1.76   tsutsui 				       le32toh(std->td.td_cbp) + 1;
   1300   1.75  augustss 			DPRINTFN(10, ("ohci_process_done: len=%d, flags=0x%x\n",
   1301   1.75  augustss 				      len, std->flags));
   1302   1.48  augustss 			if (std->flags & OHCI_ADD_LEN)
   1303   1.53  augustss 				xfer->actlen += len;
   1304   1.34  augustss 			if (std->flags & OHCI_CALL_DONE) {
   1305   1.53  augustss 				xfer->status = USBD_NORMAL_COMPLETION;
   1306   1.53  augustss 				usb_transfer_complete(xfer);
   1307   1.21  augustss 			}
   1308   1.48  augustss 			ohci_free_std(sc, std);
   1309    1.1  augustss 		} else {
   1310   1.48  augustss 			/*
   1311   1.48  augustss 			 * Endpoint is halted.  First unlink all the TDs
   1312   1.48  augustss 			 * belonging to the failed transfer, and then restart
   1313   1.48  augustss 			 * the endpoint.
   1314   1.48  augustss 			 */
   1315    1.1  augustss 			ohci_soft_td_t *p, *n;
   1316    1.1  augustss 			struct ohci_pipe *opipe =
   1317   1.53  augustss 				(struct ohci_pipe *)xfer->pipe;
   1318   1.48  augustss 
   1319   1.71  augustss 			DPRINTFN(15,("ohci_process_done: error cc=%d (%s)\n",
   1320   1.76   tsutsui 			  OHCI_TD_GET_CC(le32toh(std->td.td_flags)),
   1321   1.76   tsutsui 			  ohci_cc_strs[OHCI_TD_GET_CC(le32toh(std->td.td_flags))]));
   1322   1.48  augustss 
   1323   1.48  augustss 			/* remove TDs */
   1324   1.53  augustss 			for (p = std; p->xfer == xfer; p = n) {
   1325    1.1  augustss 				n = p->nexttd;
   1326    1.1  augustss 				ohci_free_std(sc, p);
   1327    1.1  augustss 			}
   1328   1.48  augustss 
   1329   1.16  augustss 			/* clear halt */
   1330   1.76   tsutsui 			opipe->sed->ed.ed_headp = htole32(p->physaddr);
   1331    1.1  augustss 			OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
   1332   1.48  augustss 
   1333    1.1  augustss 			if (cc == OHCI_CC_STALL)
   1334   1.53  augustss 				xfer->status = USBD_STALLED;
   1335    1.1  augustss 			else
   1336   1.53  augustss 				xfer->status = USBD_IOERROR;
   1337   1.53  augustss 			usb_transfer_complete(xfer);
   1338    1.1  augustss 		}
   1339    1.1  augustss 	}
   1340   1.72  augustss 
   1341   1.83  augustss #ifdef OHCI_DEBUG
   1342   1.83  augustss 	if (ohcidebug > 10) {
   1343  1.105  augustss 		DPRINTF(("ohci_softintr: ITD done:\n"));
   1344   1.83  augustss 		ohci_dump_itds(sidone);
   1345   1.83  augustss 	}
   1346   1.83  augustss #endif
   1347   1.83  augustss 
   1348   1.83  augustss 	for (sitd = sidone; sitd != NULL; sitd = sitdnext) {
   1349   1.83  augustss 		xfer = sitd->xfer;
   1350   1.83  augustss 		sitdnext = sitd->dnext;
   1351   1.83  augustss 		DPRINTFN(1, ("ohci_process_done: sitd=%p xfer=%p hcpriv=%p\n",
   1352   1.83  augustss 			     sitd, xfer, xfer ? xfer->hcpriv : 0));
   1353   1.83  augustss 		if (xfer == NULL)
   1354   1.83  augustss 			continue;
   1355   1.83  augustss 		if (xfer->status == USBD_CANCELLED ||
   1356   1.83  augustss 		    xfer->status == USBD_TIMEOUT) {
   1357   1.83  augustss 			DPRINTF(("ohci_process_done: cancel/timeout %p\n",
   1358   1.83  augustss 				 xfer));
   1359   1.83  augustss 			/* Handled by abort routine. */
   1360   1.83  augustss 			continue;
   1361   1.83  augustss 		}
   1362   1.83  augustss #ifdef DIAGNOSTIC
   1363   1.83  augustss 		if (sitd->isdone)
   1364   1.83  augustss 			printf("ohci_softintr: sitd=%p is done\n", sitd);
   1365   1.83  augustss 		sitd->isdone = 1;
   1366   1.83  augustss #endif
   1367   1.83  augustss 		cc = OHCI_ITD_GET_CC(le32toh(sitd->itd.itd_flags));
   1368   1.83  augustss 		if (cc == OHCI_CC_NO_ERROR) {
   1369   1.83  augustss 			/* XXX compute length for input */
   1370   1.83  augustss 			struct ohci_pipe *opipe =
   1371   1.83  augustss 				(struct ohci_pipe *)xfer->pipe;
   1372   1.83  augustss 			if (sitd->flags & OHCI_CALL_DONE) {
   1373   1.83  augustss 				opipe->u.iso.inuse -= xfer->nframes;
   1374   1.94  augustss 				/* XXX update frlengths with actual length */
   1375   1.83  augustss 				/* XXX xfer->actlen = actlen; */
   1376   1.83  augustss 				xfer->status = USBD_NORMAL_COMPLETION;
   1377   1.83  augustss 				usb_transfer_complete(xfer);
   1378   1.83  augustss 			}
   1379   1.83  augustss 		} else {
   1380   1.83  augustss 			/* XXX Do more */
   1381   1.83  augustss 			xfer->status = USBD_IOERROR;
   1382   1.83  augustss 			usb_transfer_complete(xfer);
   1383   1.83  augustss 		}
   1384   1.83  augustss 	}
   1385   1.83  augustss 
   1386   1.72  augustss 	sc->sc_bus.intr_context--;
   1387  1.105  augustss 	DPRINTFN(10,("ohci_softintr: done:\n"));
   1388    1.1  augustss }
   1389    1.1  augustss 
   1390    1.1  augustss void
   1391   1.91  augustss ohci_device_ctrl_done(usbd_xfer_handle xfer)
   1392    1.1  augustss {
   1393   1.53  augustss 	DPRINTFN(10,("ohci_ctrl_done: xfer=%p\n", xfer));
   1394    1.1  augustss 
   1395   1.38  augustss #ifdef DIAGNOSTIC
   1396   1.53  augustss 	if (!(xfer->rqflags & URQ_REQUEST)) {
   1397    1.8  augustss 		panic("ohci_ctrl_done: not a request\n");
   1398    1.1  augustss 	}
   1399   1.38  augustss #endif
   1400   1.55  augustss 	xfer->hcpriv = NULL;
   1401    1.1  augustss }
   1402    1.1  augustss 
   1403    1.1  augustss void
   1404   1.91  augustss ohci_device_intr_done(usbd_xfer_handle xfer)
   1405    1.1  augustss {
   1406   1.53  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   1407   1.38  augustss 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
   1408    1.1  augustss 	ohci_soft_ed_t *sed = opipe->sed;
   1409   1.48  augustss 	ohci_soft_td_t *data, *tail;
   1410    1.1  augustss 
   1411    1.1  augustss 
   1412   1.53  augustss 	DPRINTFN(10,("ohci_intr_done: xfer=%p, actlen=%d\n",
   1413   1.53  augustss 		     xfer, xfer->actlen));
   1414    1.1  augustss 
   1415   1.55  augustss 	xfer->hcpriv = NULL;
   1416   1.38  augustss 
   1417   1.53  augustss 	if (xfer->pipe->repeat) {
   1418   1.60  augustss 		data = opipe->tail.td;
   1419    1.1  augustss 		tail = ohci_alloc_std(sc); /* XXX should reuse TD */
   1420   1.53  augustss 		if (tail == NULL) {
   1421   1.53  augustss 			xfer->status = USBD_NOMEM;
   1422    1.1  augustss 			return;
   1423    1.1  augustss 		}
   1424   1.55  augustss 		tail->xfer = NULL;
   1425    1.1  augustss 
   1426   1.76   tsutsui 		data->td.td_flags = htole32(
   1427   1.16  augustss 			OHCI_TD_IN | OHCI_TD_NOCC |
   1428   1.16  augustss 			OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY);
   1429   1.53  augustss 		if (xfer->flags & USBD_SHORT_XFER_OK)
   1430   1.76   tsutsui 			data->td.td_flags |= htole32(OHCI_TD_R);
   1431   1.76   tsutsui 		data->td.td_cbp = htole32(DMAADDR(&xfer->dmabuf));
   1432   1.48  augustss 		data->nexttd = tail;
   1433   1.76   tsutsui 		data->td.td_nexttd = htole32(tail->physaddr);
   1434   1.76   tsutsui 		data->td.td_be = htole32(le32toh(data->td.td_cbp) +
   1435   1.76   tsutsui 			xfer->length - 1);
   1436   1.53  augustss 		data->len = xfer->length;
   1437   1.53  augustss 		data->xfer = xfer;
   1438   1.48  augustss 		data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
   1439   1.53  augustss 		xfer->hcpriv = data;
   1440   1.53  augustss 		xfer->actlen = 0;
   1441    1.1  augustss 
   1442   1.76   tsutsui 		sed->ed.ed_tailp = htole32(tail->physaddr);
   1443   1.60  augustss 		opipe->tail.td = tail;
   1444    1.1  augustss 	}
   1445    1.1  augustss }
   1446    1.1  augustss 
   1447    1.1  augustss void
   1448   1.91  augustss ohci_device_bulk_done(usbd_xfer_handle xfer)
   1449    1.3  augustss {
   1450   1.53  augustss 	DPRINTFN(10,("ohci_bulk_done: xfer=%p, actlen=%d\n",
   1451   1.53  augustss 		     xfer, xfer->actlen));
   1452    1.3  augustss 
   1453   1.53  augustss 	xfer->hcpriv = NULL;
   1454    1.3  augustss }
   1455    1.3  augustss 
   1456    1.3  augustss void
   1457   1.91  augustss ohci_rhsc(ohci_softc_t *sc, usbd_xfer_handle xfer)
   1458    1.1  augustss {
   1459    1.1  augustss 	usbd_pipe_handle pipe;
   1460    1.1  augustss 	struct ohci_pipe *opipe;
   1461    1.1  augustss 	u_char *p;
   1462    1.1  augustss 	int i, m;
   1463    1.1  augustss 	int hstatus;
   1464    1.1  augustss 
   1465    1.1  augustss 	hstatus = OREAD4(sc, OHCI_RH_STATUS);
   1466   1.53  augustss 	DPRINTF(("ohci_rhsc: sc=%p xfer=%p hstatus=0x%08x\n",
   1467   1.53  augustss 		 sc, xfer, hstatus));
   1468    1.1  augustss 
   1469   1.53  augustss 	if (xfer == NULL) {
   1470    1.1  augustss 		/* Just ignore the change. */
   1471    1.1  augustss 		return;
   1472    1.1  augustss 	}
   1473    1.1  augustss 
   1474   1.53  augustss 	pipe = xfer->pipe;
   1475    1.1  augustss 	opipe = (struct ohci_pipe *)pipe;
   1476    1.1  augustss 
   1477   1.53  augustss 	p = KERNADDR(&xfer->dmabuf);
   1478   1.53  augustss 	m = min(sc->sc_noport, xfer->length * 8 - 1);
   1479   1.53  augustss 	memset(p, 0, xfer->length);
   1480    1.1  augustss 	for (i = 1; i <= m; i++) {
   1481   1.87  augustss 		/* Pick out CHANGE bits from the status reg. */
   1482    1.1  augustss 		if (OREAD4(sc, OHCI_RH_PORT_STATUS(i)) >> 16)
   1483    1.1  augustss 			p[i/8] |= 1 << (i%8);
   1484    1.1  augustss 	}
   1485    1.1  augustss 	DPRINTF(("ohci_rhsc: change=0x%02x\n", *p));
   1486   1.53  augustss 	xfer->actlen = xfer->length;
   1487   1.53  augustss 	xfer->status = USBD_NORMAL_COMPLETION;
   1488    1.1  augustss 
   1489   1.53  augustss 	usb_transfer_complete(xfer);
   1490   1.38  augustss }
   1491   1.38  augustss 
   1492   1.38  augustss void
   1493   1.91  augustss ohci_root_intr_done(usbd_xfer_handle xfer)
   1494   1.65  augustss {
   1495   1.65  augustss 	xfer->hcpriv = NULL;
   1496   1.65  augustss }
   1497   1.65  augustss 
   1498   1.65  augustss void
   1499   1.91  augustss ohci_root_ctrl_done(usbd_xfer_handle xfer)
   1500   1.38  augustss {
   1501   1.53  augustss 	xfer->hcpriv = NULL;
   1502    1.1  augustss }
   1503    1.1  augustss 
   1504    1.1  augustss /*
   1505    1.1  augustss  * Wait here until controller claims to have an interrupt.
   1506    1.1  augustss  * Then call ohci_intr and return.  Use timeout to avoid waiting
   1507    1.1  augustss  * too long.
   1508    1.1  augustss  */
   1509    1.1  augustss void
   1510   1.91  augustss ohci_waitintr(ohci_softc_t *sc, usbd_xfer_handle xfer)
   1511    1.1  augustss {
   1512   1.53  augustss 	int timo = xfer->timeout;
   1513    1.1  augustss 	int usecs;
   1514    1.1  augustss 	u_int32_t intrs;
   1515    1.1  augustss 
   1516   1.53  augustss 	xfer->status = USBD_IN_PROGRESS;
   1517    1.1  augustss 	for (usecs = timo * 1000000 / hz; usecs > 0; usecs -= 1000) {
   1518   1.20  augustss 		usb_delay_ms(&sc->sc_bus, 1);
   1519    1.1  augustss 		intrs = OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs;
   1520   1.27  augustss 		DPRINTFN(15,("ohci_waitintr: 0x%04x\n", intrs));
   1521   1.52  augustss #ifdef OHCI_DEBUG
   1522    1.1  augustss 		if (ohcidebug > 15)
   1523    1.1  augustss 			ohci_dumpregs(sc);
   1524    1.1  augustss #endif
   1525    1.1  augustss 		if (intrs) {
   1526   1.53  augustss 			ohci_intr1(sc);
   1527   1.53  augustss 			if (xfer->status != USBD_IN_PROGRESS)
   1528    1.1  augustss 				return;
   1529    1.1  augustss 		}
   1530    1.1  augustss 	}
   1531   1.15  augustss 
   1532   1.15  augustss 	/* Timeout */
   1533    1.1  augustss 	DPRINTF(("ohci_waitintr: timeout\n"));
   1534   1.53  augustss 	xfer->status = USBD_TIMEOUT;
   1535   1.53  augustss 	usb_transfer_complete(xfer);
   1536   1.15  augustss 	/* XXX should free TD */
   1537    1.5  augustss }
   1538    1.5  augustss 
   1539    1.5  augustss void
   1540   1.91  augustss ohci_poll(struct usbd_bus *bus)
   1541    1.5  augustss {
   1542    1.5  augustss 	ohci_softc_t *sc = (ohci_softc_t *)bus;
   1543  1.105  augustss #ifdef OHCI_DEBUG
   1544  1.105  augustss 	static int last;
   1545  1.105  augustss 	int new;
   1546  1.105  augustss 	new = OREAD4(sc, OHCI_INTERRUPT_STATUS);
   1547  1.105  augustss 	if (new != last) {
   1548  1.105  augustss 		DPRINTFN(10,("ohci_poll: intrs=0x%04x\n", new));
   1549  1.105  augustss 		last = new;
   1550  1.105  augustss 	}
   1551  1.105  augustss #endif
   1552    1.5  augustss 
   1553    1.5  augustss 	if (OREAD4(sc, OHCI_INTERRUPT_STATUS) & sc->sc_eintrs)
   1554   1.53  augustss 		ohci_intr1(sc);
   1555    1.1  augustss }
   1556    1.1  augustss 
   1557    1.1  augustss usbd_status
   1558   1.91  augustss ohci_device_request(usbd_xfer_handle xfer)
   1559    1.1  augustss {
   1560   1.53  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   1561   1.53  augustss 	usb_device_request_t *req = &xfer->request;
   1562    1.1  augustss 	usbd_device_handle dev = opipe->pipe.device;
   1563    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
   1564    1.1  augustss 	int addr = dev->address;
   1565   1.77  augustss 	ohci_soft_td_t *setup, *stat, *next, *tail;
   1566    1.1  augustss 	ohci_soft_ed_t *sed;
   1567    1.1  augustss 	int isread;
   1568    1.1  augustss 	int len;
   1569   1.53  augustss 	usbd_status err;
   1570    1.1  augustss 	int s;
   1571    1.1  augustss 
   1572    1.1  augustss 	isread = req->bmRequestType & UT_READ;
   1573    1.1  augustss 	len = UGETW(req->wLength);
   1574    1.1  augustss 
   1575   1.14  augustss 	DPRINTFN(3,("ohci_device_control type=0x%02x, request=0x%02x, "
   1576   1.14  augustss 		    "wValue=0x%04x, wIndex=0x%04x len=%d, addr=%d, endpt=%d\n",
   1577    1.1  augustss 		    req->bmRequestType, req->bRequest, UGETW(req->wValue),
   1578    1.1  augustss 		    UGETW(req->wIndex), len, addr,
   1579    1.1  augustss 		    opipe->pipe.endpoint->edesc->bEndpointAddress));
   1580    1.1  augustss 
   1581   1.60  augustss 	setup = opipe->tail.td;
   1582    1.1  augustss 	stat = ohci_alloc_std(sc);
   1583   1.53  augustss 	if (stat == NULL) {
   1584   1.53  augustss 		err = USBD_NOMEM;
   1585    1.1  augustss 		goto bad1;
   1586    1.1  augustss 	}
   1587    1.1  augustss 	tail = ohci_alloc_std(sc);
   1588   1.53  augustss 	if (tail == NULL) {
   1589   1.53  augustss 		err = USBD_NOMEM;
   1590    1.1  augustss 		goto bad2;
   1591    1.1  augustss 	}
   1592   1.55  augustss 	tail->xfer = NULL;
   1593    1.1  augustss 
   1594    1.1  augustss 	sed = opipe->sed;
   1595    1.1  augustss 	opipe->u.ctl.length = len;
   1596    1.1  augustss 
   1597   1.10  augustss 	/* Update device address and length since they may have changed. */
   1598   1.10  augustss 	/* XXX This only needs to be done once, but it's too early in open. */
   1599   1.77  augustss 	/* XXXX Should not touch ED here! */
   1600   1.76   tsutsui 	sed->ed.ed_flags = htole32(
   1601   1.76   tsutsui 	 (le32toh(sed->ed.ed_flags) & ~(OHCI_ED_ADDRMASK | OHCI_ED_MAXPMASK)) |
   1602   1.16  augustss 	 OHCI_ED_SET_FA(addr) |
   1603   1.16  augustss 	 OHCI_ED_SET_MAXP(UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize)));
   1604    1.1  augustss 
   1605   1.77  augustss 	next = stat;
   1606   1.77  augustss 
   1607    1.1  augustss 	/* Set up data transaction */
   1608    1.1  augustss 	if (len != 0) {
   1609   1.77  augustss 		ohci_soft_td_t *std = stat;
   1610   1.77  augustss 
   1611   1.77  augustss 		err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer,
   1612   1.77  augustss 			  std, &stat);
   1613   1.77  augustss 		stat = stat->nexttd; /* point at free TD */
   1614   1.77  augustss 		if (err)
   1615    1.1  augustss 			goto bad3;
   1616   1.77  augustss 		/* Start toggle at 1 and then use the carried toggle. */
   1617   1.77  augustss 		std->td.td_flags &= htole32(~OHCI_TD_TOGGLE_MASK);
   1618   1.77  augustss 		std->td.td_flags |= htole32(OHCI_TD_TOGGLE_1);
   1619   1.34  augustss 	}
   1620    1.1  augustss 
   1621    1.1  augustss 	memcpy(KERNADDR(&opipe->u.ctl.reqdma), req, sizeof *req);
   1622    1.1  augustss 
   1623   1.76   tsutsui 	setup->td.td_flags = htole32(OHCI_TD_SETUP | OHCI_TD_NOCC |
   1624   1.76   tsutsui 				     OHCI_TD_TOGGLE_0 | OHCI_TD_NOINTR);
   1625   1.76   tsutsui 	setup->td.td_cbp = htole32(DMAADDR(&opipe->u.ctl.reqdma));
   1626    1.1  augustss 	setup->nexttd = next;
   1627   1.76   tsutsui 	setup->td.td_nexttd = htole32(next->physaddr);
   1628   1.76   tsutsui 	setup->td.td_be = htole32(le32toh(setup->td.td_cbp) + sizeof *req - 1);
   1629   1.77  augustss 	setup->len = 0;
   1630   1.53  augustss 	setup->xfer = xfer;
   1631   1.34  augustss 	setup->flags = 0;
   1632   1.53  augustss 	xfer->hcpriv = setup;
   1633    1.1  augustss 
   1634   1.76   tsutsui 	stat->td.td_flags = htole32(
   1635   1.77  augustss 		(isread ? OHCI_TD_OUT : OHCI_TD_IN) |
   1636   1.77  augustss 		OHCI_TD_NOCC | OHCI_TD_TOGGLE_1 | OHCI_TD_SET_DI(1));
   1637   1.39  augustss 	stat->td.td_cbp = 0;
   1638    1.1  augustss 	stat->nexttd = tail;
   1639   1.76   tsutsui 	stat->td.td_nexttd = htole32(tail->physaddr);
   1640   1.39  augustss 	stat->td.td_be = 0;
   1641   1.77  augustss 	stat->flags = OHCI_CALL_DONE;
   1642    1.1  augustss 	stat->len = 0;
   1643   1.53  augustss 	stat->xfer = xfer;
   1644    1.1  augustss 
   1645   1.52  augustss #ifdef OHCI_DEBUG
   1646    1.1  augustss 	if (ohcidebug > 5) {
   1647   1.41  augustss 		DPRINTF(("ohci_device_request:\n"));
   1648    1.1  augustss 		ohci_dump_ed(sed);
   1649    1.1  augustss 		ohci_dump_tds(setup);
   1650    1.1  augustss 	}
   1651    1.1  augustss #endif
   1652    1.1  augustss 
   1653    1.1  augustss 	/* Insert ED in schedule */
   1654    1.1  augustss 	s = splusb();
   1655   1.76   tsutsui 	sed->ed.ed_tailp = htole32(tail->physaddr);
   1656   1.60  augustss 	opipe->tail.td = tail;
   1657    1.1  augustss 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
   1658   1.53  augustss 	if (xfer->timeout && !sc->sc_bus.use_polling) {
   1659   1.81  augustss                 usb_callout(xfer->timeout_handle, MS_TO_TICKS(xfer->timeout),
   1660   1.80  augustss 			    ohci_timeout, xfer);
   1661   1.15  augustss 	}
   1662    1.1  augustss 	splx(s);
   1663    1.1  augustss 
   1664  1.115    itojun #ifdef OHCI_DEBUG
   1665  1.113  augustss 	if (ohcidebug > 20) {
   1666   1.77  augustss 		delay(10000);
   1667   1.41  augustss 		DPRINTF(("ohci_device_request: status=%x\n",
   1668   1.41  augustss 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
   1669  1.113  augustss 		ohci_dumpregs(sc);
   1670  1.113  augustss 		printf("ctrl head:\n");
   1671  1.113  augustss 		ohci_dump_ed(sc->sc_ctrl_head);
   1672  1.113  augustss 		printf("sed:\n");
   1673    1.1  augustss 		ohci_dump_ed(sed);
   1674    1.1  augustss 		ohci_dump_tds(setup);
   1675    1.1  augustss 	}
   1676    1.1  augustss #endif
   1677    1.1  augustss 
   1678    1.1  augustss 	return (USBD_NORMAL_COMPLETION);
   1679    1.1  augustss 
   1680    1.1  augustss  bad3:
   1681    1.1  augustss 	ohci_free_std(sc, tail);
   1682    1.1  augustss  bad2:
   1683    1.1  augustss 	ohci_free_std(sc, stat);
   1684    1.1  augustss  bad1:
   1685   1.53  augustss 	return (err);
   1686    1.1  augustss }
   1687    1.1  augustss 
   1688    1.1  augustss /*
   1689    1.1  augustss  * Add an ED to the schedule.  Called at splusb().
   1690    1.1  augustss  */
   1691    1.1  augustss void
   1692   1.91  augustss ohci_add_ed(ohci_soft_ed_t *sed, ohci_soft_ed_t *head)
   1693    1.1  augustss {
   1694  1.113  augustss 	DPRINTFN(8,("ohci_add_ed: sed=%p head=%p\n", sed, head));
   1695  1.113  augustss 
   1696   1.46  augustss 	SPLUSBCHECK;
   1697    1.1  augustss 	sed->next = head->next;
   1698   1.39  augustss 	sed->ed.ed_nexted = head->ed.ed_nexted;
   1699    1.1  augustss 	head->next = sed;
   1700   1.76   tsutsui 	head->ed.ed_nexted = htole32(sed->physaddr);
   1701    1.1  augustss }
   1702    1.1  augustss 
   1703    1.1  augustss /*
   1704    1.3  augustss  * Remove an ED from the schedule.  Called at splusb().
   1705    1.3  augustss  */
   1706    1.3  augustss void
   1707   1.91  augustss ohci_rem_ed(ohci_soft_ed_t *sed, ohci_soft_ed_t *head)
   1708    1.3  augustss {
   1709    1.3  augustss 	ohci_soft_ed_t *p;
   1710    1.3  augustss 
   1711   1.46  augustss 	SPLUSBCHECK;
   1712   1.46  augustss 
   1713    1.3  augustss 	/* XXX */
   1714   1.55  augustss 	for (p = head; p == NULL && p->next != sed; p = p->next)
   1715    1.3  augustss 		;
   1716   1.55  augustss 	if (p == NULL)
   1717    1.3  augustss 		panic("ohci_rem_ed: ED not found\n");
   1718    1.3  augustss 	p->next = sed->next;
   1719   1.39  augustss 	p->ed.ed_nexted = sed->ed.ed_nexted;
   1720    1.3  augustss }
   1721    1.3  augustss 
   1722    1.3  augustss /*
   1723    1.1  augustss  * When a transfer is completed the TD is added to the done queue by
   1724    1.1  augustss  * the host controller.  This queue is the processed by software.
   1725    1.1  augustss  * Unfortunately the queue contains the physical address of the TD
   1726    1.9  augustss  * and we have no simple way to translate this back to a kernel address.
   1727    1.1  augustss  * To make the translation possible (and fast) we use a hash table of
   1728    1.1  augustss  * TDs currently in the schedule.  The physical address is used as the
   1729    1.1  augustss  * hash value.
   1730    1.1  augustss  */
   1731    1.1  augustss 
   1732    1.1  augustss #define HASH(a) (((a) >> 4) % OHCI_HASH_SIZE)
   1733    1.1  augustss /* Called at splusb() */
   1734    1.1  augustss void
   1735   1.91  augustss ohci_hash_add_td(ohci_softc_t *sc, ohci_soft_td_t *std)
   1736    1.1  augustss {
   1737    1.1  augustss 	int h = HASH(std->physaddr);
   1738    1.1  augustss 
   1739   1.46  augustss 	SPLUSBCHECK;
   1740   1.46  augustss 
   1741    1.1  augustss 	LIST_INSERT_HEAD(&sc->sc_hash_tds[h], std, hnext);
   1742    1.1  augustss }
   1743    1.1  augustss 
   1744    1.1  augustss /* Called at splusb() */
   1745    1.1  augustss void
   1746   1.91  augustss ohci_hash_rem_td(ohci_softc_t *sc, ohci_soft_td_t *std)
   1747    1.1  augustss {
   1748   1.46  augustss 	SPLUSBCHECK;
   1749   1.46  augustss 
   1750    1.1  augustss 	LIST_REMOVE(std, hnext);
   1751    1.1  augustss }
   1752    1.1  augustss 
   1753    1.1  augustss ohci_soft_td_t *
   1754   1.91  augustss ohci_hash_find_td(ohci_softc_t *sc, ohci_physaddr_t a)
   1755    1.1  augustss {
   1756    1.1  augustss 	int h = HASH(a);
   1757    1.1  augustss 	ohci_soft_td_t *std;
   1758    1.1  augustss 
   1759    1.1  augustss 	for (std = LIST_FIRST(&sc->sc_hash_tds[h]);
   1760   1.53  augustss 	     std != NULL;
   1761    1.1  augustss 	     std = LIST_NEXT(std, hnext))
   1762    1.1  augustss 		if (std->physaddr == a)
   1763    1.1  augustss 			return (std);
   1764   1.83  augustss 	return (NULL);
   1765   1.83  augustss }
   1766   1.83  augustss 
   1767   1.83  augustss /* Called at splusb() */
   1768   1.83  augustss void
   1769   1.91  augustss ohci_hash_add_itd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
   1770   1.83  augustss {
   1771   1.83  augustss 	int h = HASH(sitd->physaddr);
   1772   1.83  augustss 
   1773   1.83  augustss 	SPLUSBCHECK;
   1774   1.83  augustss 
   1775   1.83  augustss 	DPRINTFN(10,("ohci_hash_add_itd: sitd=%p physaddr=0x%08lx\n",
   1776   1.83  augustss 		    sitd, (u_long)sitd->physaddr));
   1777   1.83  augustss 
   1778   1.83  augustss 	LIST_INSERT_HEAD(&sc->sc_hash_itds[h], sitd, hnext);
   1779   1.83  augustss }
   1780   1.83  augustss 
   1781   1.83  augustss /* Called at splusb() */
   1782   1.83  augustss void
   1783   1.91  augustss ohci_hash_rem_itd(ohci_softc_t *sc, ohci_soft_itd_t *sitd)
   1784   1.83  augustss {
   1785   1.83  augustss 	SPLUSBCHECK;
   1786   1.83  augustss 
   1787   1.83  augustss 	DPRINTFN(10,("ohci_hash_rem_itd: sitd=%p physaddr=0x%08lx\n",
   1788   1.83  augustss 		    sitd, (u_long)sitd->physaddr));
   1789   1.83  augustss 
   1790   1.83  augustss 	LIST_REMOVE(sitd, hnext);
   1791   1.83  augustss }
   1792   1.83  augustss 
   1793   1.83  augustss ohci_soft_itd_t *
   1794   1.91  augustss ohci_hash_find_itd(ohci_softc_t *sc, ohci_physaddr_t a)
   1795   1.83  augustss {
   1796   1.83  augustss 	int h = HASH(a);
   1797   1.83  augustss 	ohci_soft_itd_t *sitd;
   1798   1.83  augustss 
   1799   1.83  augustss 	for (sitd = LIST_FIRST(&sc->sc_hash_itds[h]);
   1800   1.83  augustss 	     sitd != NULL;
   1801   1.83  augustss 	     sitd = LIST_NEXT(sitd, hnext))
   1802   1.83  augustss 		if (sitd->physaddr == a)
   1803   1.83  augustss 			return (sitd);
   1804   1.83  augustss 	return (NULL);
   1805    1.1  augustss }
   1806    1.1  augustss 
   1807    1.1  augustss void
   1808   1.91  augustss ohci_timeout(void *addr)
   1809    1.1  augustss {
   1810  1.114  augustss 	struct ohci_xfer *oxfer = addr;
   1811  1.114  augustss 
   1812  1.114  augustss 	DPRINTF(("ohci_timeout: oxfer=%p\n", oxfer));
   1813  1.114  augustss 
   1814  1.114  augustss 	/* Execute the abort in a process context. */
   1815  1.114  augustss 	usb_init_task(&oxfer->abort_task, ohci_timeout_task, addr);
   1816  1.114  augustss 	usb_add_task(oxfer->xfer.pipe->device, &oxfer->abort_task);
   1817  1.114  augustss }
   1818  1.114  augustss 
   1819  1.114  augustss void
   1820  1.114  augustss ohci_timeout_task(void *addr)
   1821  1.114  augustss {
   1822   1.53  augustss 	usbd_xfer_handle xfer = addr;
   1823   1.48  augustss 	int s;
   1824    1.1  augustss 
   1825  1.114  augustss 	DPRINTF(("ohci_timeout_task: xfer=%p\n", xfer));
   1826   1.45  augustss 
   1827   1.48  augustss 	s = splusb();
   1828   1.54  augustss 	ohci_abort_xfer(xfer, USBD_TIMEOUT);
   1829   1.48  augustss 	splx(s);
   1830    1.1  augustss }
   1831    1.1  augustss 
   1832   1.52  augustss #ifdef OHCI_DEBUG
   1833    1.1  augustss void
   1834   1.91  augustss ohci_dump_tds(ohci_soft_td_t *std)
   1835    1.1  augustss {
   1836    1.1  augustss 	for (; std; std = std->nexttd)
   1837    1.1  augustss 		ohci_dump_td(std);
   1838    1.1  augustss }
   1839    1.1  augustss 
   1840    1.1  augustss void
   1841   1.91  augustss ohci_dump_td(ohci_soft_td_t *std)
   1842    1.1  augustss {
   1843   1.92        tv 	char sbuf[128];
   1844   1.92        tv 
   1845  1.112  augustss 	bitmask_snprintf((u_int32_t)le32toh(std->td.td_flags),
   1846   1.92        tv 			 "\20\23R\24OUT\25IN\31TOG1\32SETTOGGLE",
   1847   1.92        tv 			 sbuf, sizeof(sbuf));
   1848   1.92        tv 
   1849  1.107  augustss 	printf("TD(%p) at %08lx: %s delay=%d ec=%d cc=%d\ncbp=0x%08lx "
   1850  1.107  augustss 	       "nexttd=0x%08lx be=0x%08lx\n",
   1851  1.107  augustss 	       std, (u_long)std->physaddr, sbuf,
   1852  1.107  augustss 	       OHCI_TD_GET_DI(le32toh(std->td.td_flags)),
   1853  1.107  augustss 	       OHCI_TD_GET_EC(le32toh(std->td.td_flags)),
   1854  1.107  augustss 	       OHCI_TD_GET_CC(le32toh(std->td.td_flags)),
   1855  1.107  augustss 	       (u_long)le32toh(std->td.td_cbp),
   1856  1.107  augustss 	       (u_long)le32toh(std->td.td_nexttd),
   1857  1.107  augustss 	       (u_long)le32toh(std->td.td_be));
   1858    1.1  augustss }
   1859    1.1  augustss 
   1860    1.1  augustss void
   1861   1.91  augustss ohci_dump_itd(ohci_soft_itd_t *sitd)
   1862   1.83  augustss {
   1863   1.83  augustss 	int i;
   1864   1.83  augustss 
   1865  1.107  augustss 	printf("ITD(%p) at %08lx: sf=%d di=%d fc=%d cc=%d\n"
   1866  1.107  augustss 	       "bp0=0x%08lx next=0x%08lx be=0x%08lx\n",
   1867  1.107  augustss 	       sitd, (u_long)sitd->physaddr,
   1868  1.107  augustss 	       OHCI_ITD_GET_SF(le32toh(sitd->itd.itd_flags)),
   1869  1.107  augustss 	       OHCI_ITD_GET_DI(le32toh(sitd->itd.itd_flags)),
   1870  1.107  augustss 	       OHCI_ITD_GET_FC(le32toh(sitd->itd.itd_flags)),
   1871  1.107  augustss 	       OHCI_ITD_GET_CC(le32toh(sitd->itd.itd_flags)),
   1872  1.107  augustss 	       (u_long)le32toh(sitd->itd.itd_bp0),
   1873  1.107  augustss 	       (u_long)le32toh(sitd->itd.itd_nextitd),
   1874  1.107  augustss 	       (u_long)le32toh(sitd->itd.itd_be));
   1875   1.83  augustss 	for (i = 0; i < OHCI_ITD_NOFFSET; i++)
   1876  1.107  augustss 		printf("offs[%d]=0x%04x ", i,
   1877  1.107  augustss 		       (u_int)le16toh(sitd->itd.itd_offset[i]));
   1878  1.107  augustss 	printf("\n");
   1879   1.83  augustss }
   1880   1.83  augustss 
   1881   1.83  augustss void
   1882   1.91  augustss ohci_dump_itds(ohci_soft_itd_t *sitd)
   1883   1.83  augustss {
   1884   1.83  augustss 	for (; sitd; sitd = sitd->nextitd)
   1885   1.83  augustss 		ohci_dump_itd(sitd);
   1886   1.83  augustss }
   1887   1.83  augustss 
   1888   1.83  augustss void
   1889   1.91  augustss ohci_dump_ed(ohci_soft_ed_t *sed)
   1890    1.1  augustss {
   1891   1.92        tv 	char sbuf[128], sbuf2[128];
   1892   1.92        tv 
   1893  1.112  augustss 	bitmask_snprintf((u_int32_t)le32toh(sed->ed.ed_flags),
   1894   1.92        tv 			 "\20\14OUT\15IN\16LOWSPEED\17SKIP\20ISO",
   1895   1.92        tv 			 sbuf, sizeof(sbuf));
   1896  1.112  augustss 	bitmask_snprintf((u_int32_t)le32toh(sed->ed.ed_headp),
   1897   1.92        tv 			 "\20\1HALT\2CARRY", sbuf2, sizeof(sbuf2));
   1898   1.92        tv 
   1899  1.107  augustss 	printf("ED(%p) at 0x%08lx: addr=%d endpt=%d maxp=%d flags=%s\ntailp=0x%08lx "
   1900   1.92        tv 		 "headflags=%s headp=0x%08lx nexted=0x%08lx\n",
   1901   1.41  augustss 		 sed, (u_long)sed->physaddr,
   1902   1.76   tsutsui 		 OHCI_ED_GET_FA(le32toh(sed->ed.ed_flags)),
   1903   1.76   tsutsui 		 OHCI_ED_GET_EN(le32toh(sed->ed.ed_flags)),
   1904   1.92        tv 		 OHCI_ED_GET_MAXP(le32toh(sed->ed.ed_flags)), sbuf,
   1905   1.92        tv 		 (u_long)le32toh(sed->ed.ed_tailp), sbuf2,
   1906   1.76   tsutsui 		 (u_long)le32toh(sed->ed.ed_headp),
   1907  1.107  augustss 		 (u_long)le32toh(sed->ed.ed_nexted));
   1908    1.1  augustss }
   1909    1.1  augustss #endif
   1910    1.1  augustss 
   1911    1.1  augustss usbd_status
   1912   1.91  augustss ohci_open(usbd_pipe_handle pipe)
   1913    1.1  augustss {
   1914    1.1  augustss 	usbd_device_handle dev = pipe->device;
   1915    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
   1916    1.1  augustss 	usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc;
   1917    1.1  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   1918    1.1  augustss 	u_int8_t addr = dev->address;
   1919   1.60  augustss 	u_int8_t xfertype = ed->bmAttributes & UE_XFERTYPE;
   1920    1.1  augustss 	ohci_soft_ed_t *sed;
   1921    1.1  augustss 	ohci_soft_td_t *std;
   1922   1.60  augustss 	ohci_soft_itd_t *sitd;
   1923   1.60  augustss 	ohci_physaddr_t tdphys;
   1924   1.60  augustss 	u_int32_t fmt;
   1925   1.53  augustss 	usbd_status err;
   1926    1.1  augustss 	int s;
   1927   1.64  augustss 	int ival;
   1928    1.1  augustss 
   1929    1.1  augustss 	DPRINTFN(1, ("ohci_open: pipe=%p, addr=%d, endpt=%d (%d)\n",
   1930    1.1  augustss 		     pipe, addr, ed->bEndpointAddress, sc->sc_addr));
   1931   1.81  augustss 
   1932   1.90   thorpej 	std = NULL;
   1933   1.90   thorpej 	sed = NULL;
   1934   1.90   thorpej 
   1935    1.1  augustss 	if (addr == sc->sc_addr) {
   1936    1.1  augustss 		switch (ed->bEndpointAddress) {
   1937    1.1  augustss 		case USB_CONTROL_ENDPOINT:
   1938    1.1  augustss 			pipe->methods = &ohci_root_ctrl_methods;
   1939    1.1  augustss 			break;
   1940   1.40  augustss 		case UE_DIR_IN | OHCI_INTR_ENDPT:
   1941    1.1  augustss 			pipe->methods = &ohci_root_intr_methods;
   1942    1.1  augustss 			break;
   1943    1.1  augustss 		default:
   1944    1.1  augustss 			return (USBD_INVAL);
   1945    1.1  augustss 		}
   1946    1.1  augustss 	} else {
   1947    1.1  augustss 		sed = ohci_alloc_sed(sc);
   1948   1.53  augustss 		if (sed == NULL)
   1949    1.1  augustss 			goto bad0;
   1950    1.1  augustss 		opipe->sed = sed;
   1951   1.60  augustss 		if (xfertype == UE_ISOCHRONOUS) {
   1952   1.60  augustss 			sitd = ohci_alloc_sitd(sc);
   1953   1.60  augustss 			if (sitd == NULL) {
   1954   1.60  augustss 				ohci_free_sitd(sc, sitd);
   1955   1.60  augustss 				goto bad1;
   1956   1.60  augustss 			}
   1957   1.60  augustss 			opipe->tail.itd = sitd;
   1958   1.76   tsutsui 			tdphys = sitd->physaddr;
   1959   1.60  augustss 			fmt = OHCI_ED_FORMAT_ISO;
   1960   1.83  augustss 			if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
   1961   1.83  augustss 				fmt |= OHCI_ED_DIR_IN;
   1962   1.83  augustss 			else
   1963   1.83  augustss 				fmt |= OHCI_ED_DIR_OUT;
   1964   1.60  augustss 		} else {
   1965   1.60  augustss 			std = ohci_alloc_std(sc);
   1966   1.60  augustss 			if (std == NULL) {
   1967   1.60  augustss 				ohci_free_std(sc, std);
   1968   1.60  augustss 				goto bad1;
   1969   1.60  augustss 			}
   1970   1.60  augustss 			opipe->tail.td = std;
   1971   1.76   tsutsui 			tdphys = std->physaddr;
   1972   1.83  augustss 			fmt = OHCI_ED_FORMAT_GEN | OHCI_ED_DIR_TD;
   1973   1.60  augustss 		}
   1974   1.76   tsutsui 		sed->ed.ed_flags = htole32(
   1975    1.1  augustss 			OHCI_ED_SET_FA(addr) |
   1976    1.1  augustss 			OHCI_ED_SET_EN(ed->bEndpointAddress) |
   1977  1.109  augustss 			(dev->speed == USB_SPEED_LOW ? OHCI_ED_SPEED : 0) |
   1978  1.109  augustss 			fmt |
   1979   1.16  augustss 			OHCI_ED_SET_MAXP(UGETW(ed->wMaxPacketSize)));
   1980   1.76   tsutsui 		sed->ed.ed_headp = sed->ed.ed_tailp = htole32(tdphys);
   1981    1.1  augustss 
   1982   1.60  augustss 		switch (xfertype) {
   1983    1.1  augustss 		case UE_CONTROL:
   1984    1.1  augustss 			pipe->methods = &ohci_device_ctrl_methods;
   1985   1.53  augustss 			err = usb_allocmem(&sc->sc_bus,
   1986   1.53  augustss 				  sizeof(usb_device_request_t),
   1987   1.53  augustss 				  0, &opipe->u.ctl.reqdma);
   1988   1.53  augustss 			if (err)
   1989    1.1  augustss 				goto bad;
   1990    1.1  augustss 			s = splusb();
   1991    1.3  augustss 			ohci_add_ed(sed, sc->sc_ctrl_head);
   1992    1.1  augustss 			splx(s);
   1993    1.1  augustss 			break;
   1994    1.1  augustss 		case UE_INTERRUPT:
   1995    1.1  augustss 			pipe->methods = &ohci_device_intr_methods;
   1996   1.64  augustss 			ival = pipe->interval;
   1997   1.64  augustss 			if (ival == USBD_DEFAULT_INTERVAL)
   1998   1.64  augustss 				ival = ed->bInterval;
   1999   1.64  augustss 			return (ohci_device_setintr(sc, opipe, ival));
   2000    1.1  augustss 		case UE_ISOCHRONOUS:
   2001   1.60  augustss 			pipe->methods = &ohci_device_isoc_methods;
   2002   1.60  augustss 			return (ohci_setup_isoc(pipe));
   2003    1.1  augustss 		case UE_BULK:
   2004    1.3  augustss 			pipe->methods = &ohci_device_bulk_methods;
   2005    1.3  augustss 			s = splusb();
   2006    1.3  augustss 			ohci_add_ed(sed, sc->sc_bulk_head);
   2007    1.3  augustss 			splx(s);
   2008    1.3  augustss 			break;
   2009    1.1  augustss 		}
   2010    1.1  augustss 	}
   2011    1.1  augustss 	return (USBD_NORMAL_COMPLETION);
   2012    1.1  augustss 
   2013    1.1  augustss  bad:
   2014   1.90   thorpej 	if (std != NULL)
   2015   1.90   thorpej 		ohci_free_std(sc, std);
   2016    1.1  augustss  bad1:
   2017   1.90   thorpej 	if (sed != NULL)
   2018   1.90   thorpej 		ohci_free_sed(sc, sed);
   2019    1.1  augustss  bad0:
   2020    1.1  augustss 	return (USBD_NOMEM);
   2021    1.1  augustss 
   2022    1.1  augustss }
   2023    1.1  augustss 
   2024    1.1  augustss /*
   2025   1.34  augustss  * Close a reqular pipe.
   2026   1.34  augustss  * Assumes that there are no pending transactions.
   2027   1.34  augustss  */
   2028   1.34  augustss void
   2029   1.91  augustss ohci_close_pipe(usbd_pipe_handle pipe, ohci_soft_ed_t *head)
   2030   1.34  augustss {
   2031   1.34  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   2032   1.34  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2033   1.34  augustss 	ohci_soft_ed_t *sed = opipe->sed;
   2034   1.34  augustss 	int s;
   2035   1.34  augustss 
   2036   1.34  augustss 	s = splusb();
   2037   1.34  augustss #ifdef DIAGNOSTIC
   2038   1.76   tsutsui 	sed->ed.ed_flags |= htole32(OHCI_ED_SKIP);
   2039   1.76   tsutsui 	if ((le32toh(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
   2040   1.76   tsutsui 	    (le32toh(sed->ed.ed_headp) & OHCI_HEADMASK)) {
   2041   1.34  augustss 		ohci_soft_td_t *std;
   2042  1.106  augustss 		std = ohci_hash_find_td(sc, le32toh(sed->ed.ed_headp));
   2043   1.34  augustss 		printf("ohci_close_pipe: pipe not empty sed=%p hd=0x%x "
   2044   1.34  augustss 		       "tl=0x%x pipe=%p, std=%p\n", sed,
   2045   1.76   tsutsui 		       (int)le32toh(sed->ed.ed_headp),
   2046   1.76   tsutsui 		       (int)le32toh(sed->ed.ed_tailp),
   2047   1.34  augustss 		       pipe, std);
   2048  1.107  augustss #ifdef USB_DEBUG
   2049  1.107  augustss 		usbd_dump_pipe(&opipe->pipe);
   2050  1.107  augustss #endif
   2051  1.106  augustss #ifdef OHCI_DEBUG
   2052  1.106  augustss 		ohci_dump_ed(sed);
   2053  1.106  augustss 		if (std)
   2054  1.106  augustss 			ohci_dump_td(std);
   2055  1.106  augustss #endif
   2056   1.34  augustss 		usb_delay_ms(&sc->sc_bus, 2);
   2057   1.76   tsutsui 		if ((le32toh(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
   2058   1.76   tsutsui 		    (le32toh(sed->ed.ed_headp) & OHCI_HEADMASK))
   2059   1.34  augustss 			printf("ohci_close_pipe: pipe still not empty\n");
   2060   1.34  augustss 	}
   2061   1.34  augustss #endif
   2062   1.34  augustss 	ohci_rem_ed(sed, head);
   2063   1.34  augustss 	splx(s);
   2064   1.34  augustss 	ohci_free_sed(sc, opipe->sed);
   2065   1.34  augustss }
   2066   1.34  augustss 
   2067   1.34  augustss /*
   2068   1.34  augustss  * Abort a device request.
   2069   1.34  augustss  * If this routine is called at splusb() it guarantees that the request
   2070   1.34  augustss  * will be removed from the hardware scheduling and that the callback
   2071   1.34  augustss  * for it will be called with USBD_CANCELLED status.
   2072   1.34  augustss  * It's impossible to guarantee that the requested transfer will not
   2073   1.34  augustss  * have happened since the hardware runs concurrently.
   2074   1.34  augustss  * If the transaction has already happened we rely on the ordinary
   2075   1.34  augustss  * interrupt processing to process it.
   2076   1.34  augustss  */
   2077   1.34  augustss void
   2078   1.91  augustss ohci_abort_xfer(usbd_xfer_handle xfer, usbd_status status)
   2079   1.34  augustss {
   2080   1.53  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   2081  1.106  augustss 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
   2082  1.106  augustss 	ohci_soft_ed_t *sed = opipe->sed;
   2083  1.106  augustss 	ohci_soft_td_t *p, *n;
   2084  1.106  augustss 	ohci_physaddr_t headp;
   2085  1.106  augustss 	int s, hit;
   2086   1.34  augustss 
   2087  1.106  augustss 	DPRINTF(("ohci_abort_xfer: xfer=%p pipe=%p sed=%p\n", xfer, opipe,sed));
   2088   1.34  augustss 
   2089  1.106  augustss 	if (xfer->device->bus->intr_context || !curproc)
   2090  1.106  augustss 		panic("ohci_abort_xfer: not in process context\n");
   2091   1.34  augustss 
   2092  1.106  augustss 	/*
   2093  1.106  augustss 	 * Step 1: Make interrupt routine and hardware ignore xfer.
   2094  1.106  augustss 	 */
   2095  1.106  augustss 	s = splusb();
   2096  1.106  augustss 	xfer->status = status;	/* make software ignore it */
   2097   1.81  augustss 	usb_uncallout(xfer->timeout_handle, ohci_timeout, xfer);
   2098  1.106  augustss 	splx(s);
   2099   1.54  augustss 	DPRINTFN(1,("ohci_abort_xfer: stop ed=%p\n", sed));
   2100   1.76   tsutsui 	sed->ed.ed_flags |= htole32(OHCI_ED_SKIP); /* force hardware skip */
   2101   1.34  augustss 
   2102  1.106  augustss 	/*
   2103  1.106  augustss 	 * Step 2: Wait until we know hardware has finished any possible
   2104  1.106  augustss 	 * use of the xfer.  Also make sure the soft interrupt routine
   2105  1.106  augustss 	 * has run.
   2106  1.106  augustss 	 */
   2107  1.106  augustss 	usb_delay_ms(opipe->pipe.device->bus, 1); /* Hardware finishes in 1ms */
   2108  1.107  augustss 	/* XXX should have some communication with softintr() to know
   2109  1.107  augustss 	   when it's done */
   2110  1.107  augustss 	usb_delay_ms(opipe->pipe.device->bus, 250);
   2111  1.106  augustss 
   2112  1.106  augustss 	/*
   2113  1.106  augustss 	 * Step 3: Remove any vestiges of the xfer from the hardware.
   2114  1.106  augustss 	 * The complication here is that the hardware may have executed
   2115  1.106  augustss 	 * beyond the xfer we're trying to abort.  So as we're scanning
   2116  1.106  augustss 	 * the TDs of this xfer we check if the hardware points to
   2117  1.106  augustss 	 * any of them.
   2118  1.106  augustss 	 */
   2119  1.106  augustss 	s = splusb();		/* XXX why? */
   2120   1.53  augustss 	p = xfer->hcpriv;
   2121   1.34  augustss #ifdef DIAGNOSTIC
   2122   1.55  augustss 	if (p == NULL) {
   2123  1.102  augustss 		splx(s);
   2124  1.106  augustss 		printf("ohci_abort_xfer: hcpriv is NULL\n");
   2125   1.38  augustss 		return;
   2126   1.38  augustss 	}
   2127   1.34  augustss #endif
   2128  1.106  augustss #ifdef OHCI_DEBUG
   2129  1.106  augustss 	if (ohcidebug > 1) {
   2130  1.106  augustss 		DPRINTF(("ohci_abort_xfer: sed=\n"));
   2131  1.106  augustss 		ohci_dump_ed(sed);
   2132  1.106  augustss 		ohci_dump_tds(p);
   2133  1.106  augustss 	}
   2134  1.106  augustss #endif
   2135  1.106  augustss 	headp = le32toh(sed->ed.ed_headp) & OHCI_HEADMASK;
   2136  1.106  augustss 	hit = 0;
   2137   1.53  augustss 	for (; p->xfer == xfer; p = n) {
   2138  1.106  augustss 		hit |= headp == p->physaddr;
   2139   1.38  augustss 		n = p->nexttd;
   2140   1.38  augustss 		ohci_free_std(sc, p);
   2141   1.34  augustss 	}
   2142  1.106  augustss 	/* Zap headp register if hardware pointed inside the xfer. */
   2143  1.106  augustss 	if (hit) {
   2144  1.106  augustss 		DPRINTFN(1,("ohci_abort_xfer: set hd=0x08%x, tl=0x%08x\n",
   2145  1.106  augustss 			    (int)p->physaddr, (int)le32toh(sed->ed.ed_tailp)));
   2146  1.106  augustss 		sed->ed.ed_headp = htole32(p->physaddr); /* unlink TDs */
   2147  1.106  augustss 	} else {
   2148  1.106  augustss 		DPRINTFN(1,("ohci_abort_xfer: no hit\n"));
   2149  1.106  augustss 	}
   2150   1.34  augustss 
   2151  1.106  augustss 	/*
   2152  1.106  augustss 	 * Step 4: Turn on hardware again.
   2153  1.106  augustss 	 */
   2154   1.76   tsutsui 	sed->ed.ed_flags &= htole32(~OHCI_ED_SKIP); /* remove hardware skip */
   2155   1.38  augustss 
   2156  1.106  augustss 	/*
   2157  1.106  augustss 	 * Step 5: Execute callback.
   2158  1.106  augustss 	 */
   2159   1.53  augustss 	usb_transfer_complete(xfer);
   2160   1.38  augustss 
   2161   1.34  augustss 	splx(s);
   2162   1.34  augustss }
   2163   1.34  augustss 
   2164   1.34  augustss /*
   2165    1.1  augustss  * Data structures and routines to emulate the root hub.
   2166    1.1  augustss  */
   2167   1.82  augustss Static usb_device_descriptor_t ohci_devd = {
   2168    1.1  augustss 	USB_DEVICE_DESCRIPTOR_SIZE,
   2169    1.1  augustss 	UDESC_DEVICE,		/* type */
   2170    1.1  augustss 	{0x00, 0x01},		/* USB version */
   2171   1.74  augustss 	UDCLASS_HUB,		/* class */
   2172   1.74  augustss 	UDSUBCLASS_HUB,		/* subclass */
   2173  1.109  augustss 	UDPROTO_FSHUB,
   2174    1.1  augustss 	64,			/* max packet */
   2175    1.1  augustss 	{0},{0},{0x00,0x01},	/* device id */
   2176    1.1  augustss 	1,2,0,			/* string indicies */
   2177    1.1  augustss 	1			/* # of configurations */
   2178    1.1  augustss };
   2179    1.1  augustss 
   2180   1.82  augustss Static usb_config_descriptor_t ohci_confd = {
   2181    1.1  augustss 	USB_CONFIG_DESCRIPTOR_SIZE,
   2182    1.1  augustss 	UDESC_CONFIG,
   2183    1.1  augustss 	{USB_CONFIG_DESCRIPTOR_SIZE +
   2184    1.1  augustss 	 USB_INTERFACE_DESCRIPTOR_SIZE +
   2185    1.1  augustss 	 USB_ENDPOINT_DESCRIPTOR_SIZE},
   2186    1.1  augustss 	1,
   2187    1.1  augustss 	1,
   2188    1.1  augustss 	0,
   2189    1.1  augustss 	UC_SELF_POWERED,
   2190    1.1  augustss 	0			/* max power */
   2191    1.1  augustss };
   2192    1.1  augustss 
   2193   1.82  augustss Static usb_interface_descriptor_t ohci_ifcd = {
   2194    1.1  augustss 	USB_INTERFACE_DESCRIPTOR_SIZE,
   2195    1.1  augustss 	UDESC_INTERFACE,
   2196    1.1  augustss 	0,
   2197    1.1  augustss 	0,
   2198    1.1  augustss 	1,
   2199   1.74  augustss 	UICLASS_HUB,
   2200   1.74  augustss 	UISUBCLASS_HUB,
   2201  1.109  augustss 	UIPROTO_FSHUB,
   2202    1.1  augustss 	0
   2203    1.1  augustss };
   2204    1.1  augustss 
   2205   1.82  augustss Static usb_endpoint_descriptor_t ohci_endpd = {
   2206    1.1  augustss 	USB_ENDPOINT_DESCRIPTOR_SIZE,
   2207    1.1  augustss 	UDESC_ENDPOINT,
   2208   1.40  augustss 	UE_DIR_IN | OHCI_INTR_ENDPT,
   2209    1.1  augustss 	UE_INTERRUPT,
   2210    1.1  augustss 	{8, 0},			/* max packet */
   2211    1.1  augustss 	255
   2212    1.1  augustss };
   2213    1.1  augustss 
   2214   1.82  augustss Static usb_hub_descriptor_t ohci_hubd = {
   2215    1.1  augustss 	USB_HUB_DESCRIPTOR_SIZE,
   2216    1.1  augustss 	UDESC_HUB,
   2217    1.1  augustss 	0,
   2218    1.1  augustss 	{0,0},
   2219    1.1  augustss 	0,
   2220    1.1  augustss 	0,
   2221    1.1  augustss 	{0},
   2222    1.1  augustss };
   2223    1.1  augustss 
   2224   1.82  augustss Static int
   2225    1.1  augustss ohci_str(p, l, s)
   2226    1.1  augustss 	usb_string_descriptor_t *p;
   2227    1.1  augustss 	int l;
   2228    1.1  augustss 	char *s;
   2229    1.1  augustss {
   2230    1.1  augustss 	int i;
   2231    1.1  augustss 
   2232    1.1  augustss 	if (l == 0)
   2233    1.1  augustss 		return (0);
   2234    1.1  augustss 	p->bLength = 2 * strlen(s) + 2;
   2235    1.1  augustss 	if (l == 1)
   2236    1.1  augustss 		return (1);
   2237    1.1  augustss 	p->bDescriptorType = UDESC_STRING;
   2238    1.1  augustss 	l -= 2;
   2239    1.1  augustss 	for (i = 0; s[i] && l > 1; i++, l -= 2)
   2240    1.1  augustss 		USETW2(p->bString[i], 0, s[i]);
   2241    1.1  augustss 	return (2*i+2);
   2242    1.1  augustss }
   2243    1.1  augustss 
   2244    1.1  augustss /*
   2245    1.1  augustss  * Simulate a hardware hub by handling all the necessary requests.
   2246    1.1  augustss  */
   2247   1.82  augustss Static usbd_status
   2248   1.91  augustss ohci_root_ctrl_transfer(usbd_xfer_handle xfer)
   2249    1.1  augustss {
   2250   1.53  augustss 	usbd_status err;
   2251   1.17  augustss 
   2252   1.46  augustss 	/* Insert last in queue. */
   2253   1.53  augustss 	err = usb_insert_transfer(xfer);
   2254   1.53  augustss 	if (err)
   2255   1.53  augustss 		return (err);
   2256   1.46  augustss 
   2257   1.46  augustss 	/* Pipe isn't running, start first */
   2258   1.53  augustss 	return (ohci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
   2259   1.17  augustss }
   2260   1.17  augustss 
   2261   1.82  augustss Static usbd_status
   2262   1.91  augustss ohci_root_ctrl_start(usbd_xfer_handle xfer)
   2263   1.17  augustss {
   2264   1.53  augustss 	ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus;
   2265    1.1  augustss 	usb_device_request_t *req;
   2266   1.52  augustss 	void *buf = NULL;
   2267    1.1  augustss 	int port, i;
   2268   1.46  augustss 	int s, len, value, index, l, totlen = 0;
   2269    1.1  augustss 	usb_port_status_t ps;
   2270    1.1  augustss 	usb_hub_descriptor_t hubd;
   2271   1.53  augustss 	usbd_status err;
   2272    1.1  augustss 	u_int32_t v;
   2273    1.1  augustss 
   2274   1.83  augustss 	if (sc->sc_dying)
   2275   1.83  augustss 		return (USBD_IOERROR);
   2276   1.83  augustss 
   2277   1.42  augustss #ifdef DIAGNOSTIC
   2278   1.53  augustss 	if (!(xfer->rqflags & URQ_REQUEST))
   2279    1.1  augustss 		/* XXX panic */
   2280    1.1  augustss 		return (USBD_INVAL);
   2281   1.42  augustss #endif
   2282   1.53  augustss 	req = &xfer->request;
   2283    1.1  augustss 
   2284    1.1  augustss 	DPRINTFN(4,("ohci_root_ctrl_control type=0x%02x request=%02x\n",
   2285    1.1  augustss 		    req->bmRequestType, req->bRequest));
   2286    1.1  augustss 
   2287    1.1  augustss 	len = UGETW(req->wLength);
   2288    1.1  augustss 	value = UGETW(req->wValue);
   2289    1.1  augustss 	index = UGETW(req->wIndex);
   2290   1.43  augustss 
   2291   1.43  augustss 	if (len != 0)
   2292   1.53  augustss 		buf = KERNADDR(&xfer->dmabuf);
   2293   1.43  augustss 
   2294    1.1  augustss #define C(x,y) ((x) | ((y) << 8))
   2295    1.1  augustss 	switch(C(req->bRequest, req->bmRequestType)) {
   2296    1.1  augustss 	case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE):
   2297    1.1  augustss 	case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE):
   2298    1.1  augustss 	case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT):
   2299    1.1  augustss 		/*
   2300   1.15  augustss 		 * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops
   2301    1.1  augustss 		 * for the integrated root hub.
   2302    1.1  augustss 		 */
   2303    1.1  augustss 		break;
   2304    1.1  augustss 	case C(UR_GET_CONFIG, UT_READ_DEVICE):
   2305    1.1  augustss 		if (len > 0) {
   2306    1.1  augustss 			*(u_int8_t *)buf = sc->sc_conf;
   2307    1.1  augustss 			totlen = 1;
   2308    1.1  augustss 		}
   2309    1.1  augustss 		break;
   2310    1.1  augustss 	case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE):
   2311    1.1  augustss 		DPRINTFN(8,("ohci_root_ctrl_control wValue=0x%04x\n", value));
   2312    1.1  augustss 		switch(value >> 8) {
   2313    1.1  augustss 		case UDESC_DEVICE:
   2314    1.1  augustss 			if ((value & 0xff) != 0) {
   2315   1.53  augustss 				err = USBD_IOERROR;
   2316    1.1  augustss 				goto ret;
   2317    1.1  augustss 			}
   2318    1.1  augustss 			totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE);
   2319   1.29  augustss 			USETW(ohci_devd.idVendor, sc->sc_id_vendor);
   2320    1.1  augustss 			memcpy(buf, &ohci_devd, l);
   2321    1.1  augustss 			break;
   2322    1.1  augustss 		case UDESC_CONFIG:
   2323    1.1  augustss 			if ((value & 0xff) != 0) {
   2324   1.53  augustss 				err = USBD_IOERROR;
   2325    1.1  augustss 				goto ret;
   2326    1.1  augustss 			}
   2327    1.1  augustss 			totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE);
   2328    1.1  augustss 			memcpy(buf, &ohci_confd, l);
   2329    1.1  augustss 			buf = (char *)buf + l;
   2330    1.1  augustss 			len -= l;
   2331    1.1  augustss 			l = min(len, USB_INTERFACE_DESCRIPTOR_SIZE);
   2332    1.1  augustss 			totlen += l;
   2333    1.1  augustss 			memcpy(buf, &ohci_ifcd, l);
   2334    1.1  augustss 			buf = (char *)buf + l;
   2335    1.1  augustss 			len -= l;
   2336    1.1  augustss 			l = min(len, USB_ENDPOINT_DESCRIPTOR_SIZE);
   2337    1.1  augustss 			totlen += l;
   2338    1.1  augustss 			memcpy(buf, &ohci_endpd, l);
   2339    1.1  augustss 			break;
   2340    1.1  augustss 		case UDESC_STRING:
   2341    1.1  augustss 			if (len == 0)
   2342    1.1  augustss 				break;
   2343    1.1  augustss 			*(u_int8_t *)buf = 0;
   2344    1.1  augustss 			totlen = 1;
   2345    1.1  augustss 			switch (value & 0xff) {
   2346    1.1  augustss 			case 1: /* Vendor */
   2347    1.1  augustss 				totlen = ohci_str(buf, len, sc->sc_vendor);
   2348    1.1  augustss 				break;
   2349    1.1  augustss 			case 2: /* Product */
   2350    1.1  augustss 				totlen = ohci_str(buf, len, "OHCI root hub");
   2351    1.1  augustss 				break;
   2352    1.1  augustss 			}
   2353    1.1  augustss 			break;
   2354    1.1  augustss 		default:
   2355   1.53  augustss 			err = USBD_IOERROR;
   2356    1.1  augustss 			goto ret;
   2357    1.1  augustss 		}
   2358    1.1  augustss 		break;
   2359    1.1  augustss 	case C(UR_GET_INTERFACE, UT_READ_INTERFACE):
   2360    1.1  augustss 		if (len > 0) {
   2361    1.1  augustss 			*(u_int8_t *)buf = 0;
   2362    1.1  augustss 			totlen = 1;
   2363    1.1  augustss 		}
   2364    1.1  augustss 		break;
   2365    1.1  augustss 	case C(UR_GET_STATUS, UT_READ_DEVICE):
   2366    1.1  augustss 		if (len > 1) {
   2367    1.1  augustss 			USETW(((usb_status_t *)buf)->wStatus,UDS_SELF_POWERED);
   2368    1.1  augustss 			totlen = 2;
   2369    1.1  augustss 		}
   2370    1.1  augustss 		break;
   2371    1.1  augustss 	case C(UR_GET_STATUS, UT_READ_INTERFACE):
   2372    1.1  augustss 	case C(UR_GET_STATUS, UT_READ_ENDPOINT):
   2373    1.1  augustss 		if (len > 1) {
   2374    1.1  augustss 			USETW(((usb_status_t *)buf)->wStatus, 0);
   2375    1.1  augustss 			totlen = 2;
   2376    1.1  augustss 		}
   2377    1.1  augustss 		break;
   2378    1.1  augustss 	case C(UR_SET_ADDRESS, UT_WRITE_DEVICE):
   2379    1.1  augustss 		if (value >= USB_MAX_DEVICES) {
   2380   1.53  augustss 			err = USBD_IOERROR;
   2381    1.1  augustss 			goto ret;
   2382    1.1  augustss 		}
   2383    1.1  augustss 		sc->sc_addr = value;
   2384    1.1  augustss 		break;
   2385    1.1  augustss 	case C(UR_SET_CONFIG, UT_WRITE_DEVICE):
   2386    1.1  augustss 		if (value != 0 && value != 1) {
   2387   1.53  augustss 			err = USBD_IOERROR;
   2388    1.1  augustss 			goto ret;
   2389    1.1  augustss 		}
   2390    1.1  augustss 		sc->sc_conf = value;
   2391    1.1  augustss 		break;
   2392    1.1  augustss 	case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE):
   2393    1.1  augustss 		break;
   2394    1.1  augustss 	case C(UR_SET_FEATURE, UT_WRITE_DEVICE):
   2395    1.1  augustss 	case C(UR_SET_FEATURE, UT_WRITE_INTERFACE):
   2396    1.1  augustss 	case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT):
   2397   1.53  augustss 		err = USBD_IOERROR;
   2398    1.1  augustss 		goto ret;
   2399    1.1  augustss 	case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE):
   2400    1.1  augustss 		break;
   2401    1.1  augustss 	case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT):
   2402    1.1  augustss 		break;
   2403    1.1  augustss 	/* Hub requests */
   2404    1.1  augustss 	case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE):
   2405    1.1  augustss 		break;
   2406    1.1  augustss 	case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER):
   2407   1.14  augustss 		DPRINTFN(8, ("ohci_root_ctrl_control: UR_CLEAR_PORT_FEATURE "
   2408   1.14  augustss 			     "port=%d feature=%d\n",
   2409    1.1  augustss 			     index, value));
   2410    1.1  augustss 		if (index < 1 || index > sc->sc_noport) {
   2411   1.53  augustss 			err = USBD_IOERROR;
   2412    1.1  augustss 			goto ret;
   2413    1.1  augustss 		}
   2414    1.1  augustss 		port = OHCI_RH_PORT_STATUS(index);
   2415    1.1  augustss 		switch(value) {
   2416    1.1  augustss 		case UHF_PORT_ENABLE:
   2417    1.1  augustss 			OWRITE4(sc, port, UPS_CURRENT_CONNECT_STATUS);
   2418    1.1  augustss 			break;
   2419    1.1  augustss 		case UHF_PORT_SUSPEND:
   2420    1.1  augustss 			OWRITE4(sc, port, UPS_OVERCURRENT_INDICATOR);
   2421    1.1  augustss 			break;
   2422    1.1  augustss 		case UHF_PORT_POWER:
   2423   1.86  augustss 			/* Yes, writing to the LOW_SPEED bit clears power. */
   2424    1.1  augustss 			OWRITE4(sc, port, UPS_LOW_SPEED);
   2425    1.1  augustss 			break;
   2426    1.1  augustss 		case UHF_C_PORT_CONNECTION:
   2427    1.1  augustss 			OWRITE4(sc, port, UPS_C_CONNECT_STATUS << 16);
   2428    1.1  augustss 			break;
   2429    1.1  augustss 		case UHF_C_PORT_ENABLE:
   2430    1.1  augustss 			OWRITE4(sc, port, UPS_C_PORT_ENABLED << 16);
   2431    1.1  augustss 			break;
   2432    1.1  augustss 		case UHF_C_PORT_SUSPEND:
   2433    1.1  augustss 			OWRITE4(sc, port, UPS_C_SUSPEND << 16);
   2434    1.1  augustss 			break;
   2435    1.1  augustss 		case UHF_C_PORT_OVER_CURRENT:
   2436    1.1  augustss 			OWRITE4(sc, port, UPS_C_OVERCURRENT_INDICATOR << 16);
   2437    1.1  augustss 			break;
   2438    1.1  augustss 		case UHF_C_PORT_RESET:
   2439    1.1  augustss 			OWRITE4(sc, port, UPS_C_PORT_RESET << 16);
   2440    1.1  augustss 			break;
   2441    1.1  augustss 		default:
   2442   1.53  augustss 			err = USBD_IOERROR;
   2443    1.1  augustss 			goto ret;
   2444    1.1  augustss 		}
   2445    1.1  augustss 		switch(value) {
   2446    1.1  augustss 		case UHF_C_PORT_CONNECTION:
   2447    1.1  augustss 		case UHF_C_PORT_ENABLE:
   2448    1.1  augustss 		case UHF_C_PORT_SUSPEND:
   2449    1.1  augustss 		case UHF_C_PORT_OVER_CURRENT:
   2450    1.1  augustss 		case UHF_C_PORT_RESET:
   2451    1.1  augustss 			/* Enable RHSC interrupt if condition is cleared. */
   2452    1.1  augustss 			if ((OREAD4(sc, port) >> 16) == 0)
   2453    1.1  augustss 				ohci_rhsc_able(sc, 1);
   2454    1.1  augustss 			break;
   2455    1.1  augustss 		default:
   2456    1.1  augustss 			break;
   2457    1.1  augustss 		}
   2458    1.1  augustss 		break;
   2459    1.1  augustss 	case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE):
   2460    1.1  augustss 		if (value != 0) {
   2461   1.53  augustss 			err = USBD_IOERROR;
   2462    1.1  augustss 			goto ret;
   2463    1.1  augustss 		}
   2464    1.1  augustss 		v = OREAD4(sc, OHCI_RH_DESCRIPTOR_A);
   2465    1.1  augustss 		hubd = ohci_hubd;
   2466    1.1  augustss 		hubd.bNbrPorts = sc->sc_noport;
   2467   1.15  augustss 		USETW(hubd.wHubCharacteristics,
   2468    1.1  augustss 		      (v & OHCI_NPS ? UHD_PWR_NO_SWITCH :
   2469    1.1  augustss 		       v & OHCI_PSM ? UHD_PWR_GANGED : UHD_PWR_INDIVIDUAL)
   2470    1.1  augustss 		      /* XXX overcurrent */
   2471    1.1  augustss 		      );
   2472    1.1  augustss 		hubd.bPwrOn2PwrGood = OHCI_GET_POTPGT(v);
   2473    1.1  augustss 		v = OREAD4(sc, OHCI_RH_DESCRIPTOR_B);
   2474   1.15  augustss 		for (i = 0, l = sc->sc_noport; l > 0; i++, l -= 8, v >>= 8)
   2475   1.15  augustss 			hubd.DeviceRemovable[i++] = (u_int8_t)v;
   2476   1.15  augustss 		hubd.bDescLength = USB_HUB_DESCRIPTOR_SIZE + i;
   2477    1.1  augustss 		l = min(len, hubd.bDescLength);
   2478    1.1  augustss 		totlen = l;
   2479    1.1  augustss 		memcpy(buf, &hubd, l);
   2480    1.1  augustss 		break;
   2481    1.1  augustss 	case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE):
   2482    1.1  augustss 		if (len != 4) {
   2483   1.53  augustss 			err = USBD_IOERROR;
   2484    1.1  augustss 			goto ret;
   2485    1.1  augustss 		}
   2486    1.1  augustss 		memset(buf, 0, len); /* ? XXX */
   2487    1.1  augustss 		totlen = len;
   2488    1.1  augustss 		break;
   2489    1.1  augustss 	case C(UR_GET_STATUS, UT_READ_CLASS_OTHER):
   2490    1.1  augustss 		DPRINTFN(8,("ohci_root_ctrl_transfer: get port status i=%d\n",
   2491    1.1  augustss 			    index));
   2492    1.1  augustss 		if (index < 1 || index > sc->sc_noport) {
   2493   1.53  augustss 			err = USBD_IOERROR;
   2494    1.1  augustss 			goto ret;
   2495    1.1  augustss 		}
   2496    1.1  augustss 		if (len != 4) {
   2497   1.53  augustss 			err = USBD_IOERROR;
   2498    1.1  augustss 			goto ret;
   2499    1.1  augustss 		}
   2500    1.1  augustss 		v = OREAD4(sc, OHCI_RH_PORT_STATUS(index));
   2501    1.1  augustss 		DPRINTFN(8,("ohci_root_ctrl_transfer: port status=0x%04x\n",
   2502    1.1  augustss 			    v));
   2503    1.1  augustss 		USETW(ps.wPortStatus, v);
   2504    1.1  augustss 		USETW(ps.wPortChange, v >> 16);
   2505    1.1  augustss 		l = min(len, sizeof ps);
   2506    1.1  augustss 		memcpy(buf, &ps, l);
   2507    1.1  augustss 		totlen = l;
   2508    1.1  augustss 		break;
   2509    1.1  augustss 	case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE):
   2510   1.53  augustss 		err = USBD_IOERROR;
   2511    1.1  augustss 		goto ret;
   2512    1.1  augustss 	case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE):
   2513    1.1  augustss 		break;
   2514    1.1  augustss 	case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER):
   2515    1.1  augustss 		if (index < 1 || index > sc->sc_noport) {
   2516   1.53  augustss 			err = USBD_IOERROR;
   2517    1.1  augustss 			goto ret;
   2518    1.1  augustss 		}
   2519    1.1  augustss 		port = OHCI_RH_PORT_STATUS(index);
   2520    1.1  augustss 		switch(value) {
   2521    1.1  augustss 		case UHF_PORT_ENABLE:
   2522    1.1  augustss 			OWRITE4(sc, port, UPS_PORT_ENABLED);
   2523    1.1  augustss 			break;
   2524    1.1  augustss 		case UHF_PORT_SUSPEND:
   2525    1.1  augustss 			OWRITE4(sc, port, UPS_SUSPEND);
   2526    1.1  augustss 			break;
   2527    1.1  augustss 		case UHF_PORT_RESET:
   2528   1.14  augustss 			DPRINTFN(5,("ohci_root_ctrl_transfer: reset port %d\n",
   2529   1.14  augustss 				    index));
   2530    1.1  augustss 			OWRITE4(sc, port, UPS_RESET);
   2531  1.110  augustss 			for (i = 0; i < 5; i++) {
   2532  1.110  augustss 				usb_delay_ms(&sc->sc_bus,
   2533  1.110  augustss 					     USB_PORT_ROOT_RESET_DELAY);
   2534    1.1  augustss 				if ((OREAD4(sc, port) & UPS_RESET) == 0)
   2535    1.1  augustss 					break;
   2536    1.1  augustss 			}
   2537    1.1  augustss 			DPRINTFN(8,("ohci port %d reset, status = 0x%04x\n",
   2538    1.1  augustss 				    index, OREAD4(sc, port)));
   2539    1.1  augustss 			break;
   2540    1.1  augustss 		case UHF_PORT_POWER:
   2541   1.14  augustss 			DPRINTFN(2,("ohci_root_ctrl_transfer: set port power "
   2542   1.14  augustss 				    "%d\n", index));
   2543    1.1  augustss 			OWRITE4(sc, port, UPS_PORT_POWER);
   2544    1.1  augustss 			break;
   2545    1.1  augustss 		default:
   2546   1.53  augustss 			err = USBD_IOERROR;
   2547    1.1  augustss 			goto ret;
   2548    1.1  augustss 		}
   2549    1.1  augustss 		break;
   2550    1.1  augustss 	default:
   2551   1.53  augustss 		err = USBD_IOERROR;
   2552    1.1  augustss 		goto ret;
   2553    1.1  augustss 	}
   2554   1.53  augustss 	xfer->actlen = totlen;
   2555   1.53  augustss 	err = USBD_NORMAL_COMPLETION;
   2556    1.1  augustss  ret:
   2557   1.53  augustss 	xfer->status = err;
   2558   1.46  augustss 	s = splusb();
   2559   1.53  augustss 	usb_transfer_complete(xfer);
   2560   1.46  augustss 	splx(s);
   2561    1.1  augustss 	return (USBD_IN_PROGRESS);
   2562    1.1  augustss }
   2563    1.1  augustss 
   2564    1.1  augustss /* Abort a root control request. */
   2565   1.82  augustss Static void
   2566   1.91  augustss ohci_root_ctrl_abort(usbd_xfer_handle xfer)
   2567    1.1  augustss {
   2568    1.9  augustss 	/* Nothing to do, all transfers are synchronous. */
   2569    1.1  augustss }
   2570    1.1  augustss 
   2571    1.1  augustss /* Close the root pipe. */
   2572   1.82  augustss Static void
   2573   1.91  augustss ohci_root_ctrl_close(usbd_pipe_handle pipe)
   2574    1.1  augustss {
   2575    1.1  augustss 	DPRINTF(("ohci_root_ctrl_close\n"));
   2576   1.34  augustss 	/* Nothing to do. */
   2577    1.1  augustss }
   2578    1.1  augustss 
   2579   1.82  augustss Static usbd_status
   2580   1.91  augustss ohci_root_intr_transfer(usbd_xfer_handle xfer)
   2581    1.1  augustss {
   2582   1.53  augustss 	usbd_status err;
   2583   1.17  augustss 
   2584   1.46  augustss 	/* Insert last in queue. */
   2585   1.53  augustss 	err = usb_insert_transfer(xfer);
   2586   1.53  augustss 	if (err)
   2587   1.53  augustss 		return (err);
   2588   1.46  augustss 
   2589   1.46  augustss 	/* Pipe isn't running, start first */
   2590   1.53  augustss 	return (ohci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
   2591   1.17  augustss }
   2592   1.17  augustss 
   2593   1.82  augustss Static usbd_status
   2594   1.91  augustss ohci_root_intr_start(usbd_xfer_handle xfer)
   2595   1.17  augustss {
   2596   1.53  augustss 	usbd_pipe_handle pipe = xfer->pipe;
   2597    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2598    1.1  augustss 
   2599   1.83  augustss 	if (sc->sc_dying)
   2600   1.83  augustss 		return (USBD_IOERROR);
   2601   1.83  augustss 
   2602   1.53  augustss 	sc->sc_intrxfer = xfer;
   2603    1.1  augustss 
   2604    1.1  augustss 	return (USBD_IN_PROGRESS);
   2605    1.1  augustss }
   2606    1.1  augustss 
   2607    1.3  augustss /* Abort a root interrupt request. */
   2608   1.82  augustss Static void
   2609   1.91  augustss ohci_root_intr_abort(usbd_xfer_handle xfer)
   2610    1.1  augustss {
   2611   1.53  augustss 	int s;
   2612   1.53  augustss 
   2613   1.53  augustss 	if (xfer->pipe->intrxfer == xfer) {
   2614   1.51  augustss 		DPRINTF(("ohci_root_intr_abort: remove\n"));
   2615   1.53  augustss 		xfer->pipe->intrxfer = NULL;
   2616   1.51  augustss 	}
   2617   1.53  augustss 	xfer->status = USBD_CANCELLED;
   2618   1.53  augustss 	s = splusb();
   2619   1.53  augustss 	usb_transfer_complete(xfer);
   2620   1.53  augustss 	splx(s);
   2621    1.1  augustss }
   2622    1.1  augustss 
   2623    1.1  augustss /* Close the root pipe. */
   2624   1.82  augustss Static void
   2625   1.91  augustss ohci_root_intr_close(usbd_pipe_handle pipe)
   2626    1.1  augustss {
   2627    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2628    1.1  augustss 
   2629    1.1  augustss 	DPRINTF(("ohci_root_intr_close\n"));
   2630   1.34  augustss 
   2631   1.53  augustss 	sc->sc_intrxfer = NULL;
   2632    1.1  augustss }
   2633    1.1  augustss 
   2634    1.1  augustss /************************/
   2635    1.1  augustss 
   2636   1.82  augustss Static usbd_status
   2637   1.91  augustss ohci_device_ctrl_transfer(usbd_xfer_handle xfer)
   2638    1.1  augustss {
   2639   1.53  augustss 	usbd_status err;
   2640   1.17  augustss 
   2641   1.46  augustss 	/* Insert last in queue. */
   2642   1.53  augustss 	err = usb_insert_transfer(xfer);
   2643   1.53  augustss 	if (err)
   2644   1.53  augustss 		return (err);
   2645   1.46  augustss 
   2646   1.46  augustss 	/* Pipe isn't running, start first */
   2647   1.53  augustss 	return (ohci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
   2648   1.17  augustss }
   2649   1.17  augustss 
   2650   1.82  augustss Static usbd_status
   2651   1.91  augustss ohci_device_ctrl_start(usbd_xfer_handle xfer)
   2652   1.17  augustss {
   2653   1.53  augustss 	ohci_softc_t *sc = (ohci_softc_t *)xfer->pipe->device->bus;
   2654   1.53  augustss 	usbd_status err;
   2655    1.1  augustss 
   2656   1.83  augustss 	if (sc->sc_dying)
   2657   1.83  augustss 		return (USBD_IOERROR);
   2658   1.83  augustss 
   2659   1.42  augustss #ifdef DIAGNOSTIC
   2660   1.53  augustss 	if (!(xfer->rqflags & URQ_REQUEST)) {
   2661    1.1  augustss 		/* XXX panic */
   2662    1.1  augustss 		printf("ohci_device_ctrl_transfer: not a request\n");
   2663    1.1  augustss 		return (USBD_INVAL);
   2664    1.1  augustss 	}
   2665   1.42  augustss #endif
   2666    1.1  augustss 
   2667   1.53  augustss 	err = ohci_device_request(xfer);
   2668   1.53  augustss 	if (err)
   2669   1.53  augustss 		return (err);
   2670    1.1  augustss 
   2671    1.6  augustss 	if (sc->sc_bus.use_polling)
   2672   1.53  augustss 		ohci_waitintr(sc, xfer);
   2673    1.1  augustss 	return (USBD_IN_PROGRESS);
   2674    1.1  augustss }
   2675    1.1  augustss 
   2676    1.1  augustss /* Abort a device control request. */
   2677   1.82  augustss Static void
   2678   1.91  augustss ohci_device_ctrl_abort(usbd_xfer_handle xfer)
   2679    1.1  augustss {
   2680   1.53  augustss 	DPRINTF(("ohci_device_ctrl_abort: xfer=%p\n", xfer));
   2681   1.54  augustss 	ohci_abort_xfer(xfer, USBD_CANCELLED);
   2682    1.1  augustss }
   2683    1.1  augustss 
   2684    1.1  augustss /* Close a device control pipe. */
   2685   1.82  augustss Static void
   2686   1.91  augustss ohci_device_ctrl_close(usbd_pipe_handle pipe)
   2687    1.1  augustss {
   2688   1.60  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   2689    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2690    1.1  augustss 
   2691   1.34  augustss 	DPRINTF(("ohci_device_ctrl_close: pipe=%p\n", pipe));
   2692   1.34  augustss 	ohci_close_pipe(pipe, sc->sc_ctrl_head);
   2693   1.60  augustss 	ohci_free_std(sc, opipe->tail.td);
   2694    1.3  augustss }
   2695    1.3  augustss 
   2696    1.3  augustss /************************/
   2697   1.37  augustss 
   2698   1.82  augustss Static void
   2699   1.91  augustss ohci_device_clear_toggle(usbd_pipe_handle pipe)
   2700   1.37  augustss {
   2701   1.37  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   2702   1.37  augustss 
   2703   1.76   tsutsui 	opipe->sed->ed.ed_headp &= htole32(~OHCI_TOGGLECARRY);
   2704   1.37  augustss }
   2705   1.37  augustss 
   2706   1.82  augustss Static void
   2707   1.91  augustss ohci_noop(usbd_pipe_handle pipe)
   2708   1.37  augustss {
   2709   1.37  augustss }
   2710    1.3  augustss 
   2711   1.82  augustss Static usbd_status
   2712   1.91  augustss ohci_device_bulk_transfer(usbd_xfer_handle xfer)
   2713    1.3  augustss {
   2714   1.53  augustss 	usbd_status err;
   2715   1.17  augustss 
   2716   1.46  augustss 	/* Insert last in queue. */
   2717   1.53  augustss 	err = usb_insert_transfer(xfer);
   2718   1.53  augustss 	if (err)
   2719   1.53  augustss 		return (err);
   2720   1.46  augustss 
   2721   1.46  augustss 	/* Pipe isn't running, start first */
   2722   1.53  augustss 	return (ohci_device_bulk_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
   2723   1.17  augustss }
   2724   1.17  augustss 
   2725   1.82  augustss Static usbd_status
   2726   1.91  augustss ohci_device_bulk_start(usbd_xfer_handle xfer)
   2727   1.17  augustss {
   2728   1.53  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   2729    1.3  augustss 	usbd_device_handle dev = opipe->pipe.device;
   2730    1.3  augustss 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
   2731    1.3  augustss 	int addr = dev->address;
   2732   1.48  augustss 	ohci_soft_td_t *data, *tail, *tdp;
   2733    1.3  augustss 	ohci_soft_ed_t *sed;
   2734   1.40  augustss 	int s, len, isread, endpt;
   2735   1.53  augustss 	usbd_status err;
   2736    1.3  augustss 
   2737   1.83  augustss 	if (sc->sc_dying)
   2738   1.83  augustss 		return (USBD_IOERROR);
   2739   1.83  augustss 
   2740   1.34  augustss #ifdef DIAGNOSTIC
   2741   1.53  augustss 	if (xfer->rqflags & URQ_REQUEST) {
   2742    1.3  augustss 		/* XXX panic */
   2743   1.34  augustss 		printf("ohci_device_bulk_start: a request\n");
   2744    1.3  augustss 		return (USBD_INVAL);
   2745    1.3  augustss 	}
   2746   1.34  augustss #endif
   2747    1.3  augustss 
   2748   1.53  augustss 	len = xfer->length;
   2749   1.53  augustss 	endpt = xfer->pipe->endpoint->edesc->bEndpointAddress;
   2750   1.40  augustss 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
   2751    1.3  augustss 	sed = opipe->sed;
   2752    1.3  augustss 
   2753   1.53  augustss 	DPRINTFN(4,("ohci_device_bulk_start: xfer=%p len=%d isread=%d "
   2754   1.53  augustss 		    "flags=%d endpt=%d\n", xfer, len, isread, xfer->flags,
   2755   1.40  augustss 		    endpt));
   2756   1.34  augustss 
   2757   1.32  augustss 	opipe->u.bulk.isread = isread;
   2758    1.3  augustss 	opipe->u.bulk.length = len;
   2759    1.3  augustss 
   2760    1.3  augustss 	/* Update device address */
   2761   1.76   tsutsui 	sed->ed.ed_flags = htole32(
   2762   1.76   tsutsui 		(le32toh(sed->ed.ed_flags) & ~OHCI_ED_ADDRMASK) |
   2763   1.16  augustss 		OHCI_ED_SET_FA(addr));
   2764    1.3  augustss 
   2765   1.48  augustss 	/* Allocate a chain of new TDs (including a new tail). */
   2766   1.60  augustss 	data = opipe->tail.td;
   2767   1.77  augustss 	err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer,
   2768   1.77  augustss 		  data, &tail);
   2769   1.77  augustss 	/* We want interrupt at the end of the transfer. */
   2770   1.77  augustss 	tail->td.td_flags &= htole32(~OHCI_TD_INTR_MASK);
   2771   1.77  augustss 	tail->td.td_flags |= htole32(OHCI_TD_SET_DI(1));
   2772   1.77  augustss 	tail->flags |= OHCI_CALL_DONE;
   2773   1.77  augustss 	tail = tail->nexttd;	/* point at sentinel */
   2774   1.53  augustss 	if (err)
   2775   1.53  augustss 		return (err);
   2776   1.48  augustss 
   2777   1.53  augustss 	tail->xfer = NULL;
   2778   1.53  augustss 	xfer->hcpriv = data;
   2779    1.3  augustss 
   2780   1.34  augustss 	DPRINTFN(4,("ohci_device_bulk_start: ed_flags=0x%08x td_flags=0x%08x "
   2781   1.34  augustss 		    "td_cbp=0x%08x td_be=0x%08x\n",
   2782   1.76   tsutsui 		    (int)le32toh(sed->ed.ed_flags),
   2783   1.76   tsutsui 		    (int)le32toh(data->td.td_flags),
   2784   1.76   tsutsui 		    (int)le32toh(data->td.td_cbp),
   2785   1.76   tsutsui 		    (int)le32toh(data->td.td_be)));
   2786   1.34  augustss 
   2787   1.52  augustss #ifdef OHCI_DEBUG
   2788   1.75  augustss 	if (ohcidebug > 5) {
   2789   1.34  augustss 		ohci_dump_ed(sed);
   2790   1.48  augustss 		ohci_dump_tds(data);
   2791   1.34  augustss 	}
   2792   1.34  augustss #endif
   2793   1.34  augustss 
   2794    1.3  augustss 	/* Insert ED in schedule */
   2795    1.3  augustss 	s = splusb();
   2796   1.48  augustss 	for (tdp = data; tdp != tail; tdp = tdp->nexttd) {
   2797   1.53  augustss 		tdp->xfer = xfer;
   2798   1.48  augustss 	}
   2799   1.76   tsutsui 	sed->ed.ed_tailp = htole32(tail->physaddr);
   2800   1.60  augustss 	opipe->tail.td = tail;
   2801   1.76   tsutsui 	sed->ed.ed_flags &= htole32(~OHCI_ED_SKIP);
   2802    1.3  augustss 	OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
   2803   1.53  augustss 	if (xfer->timeout && !sc->sc_bus.use_polling) {
   2804   1.81  augustss                 usb_callout(xfer->timeout_handle, MS_TO_TICKS(xfer->timeout),
   2805   1.80  augustss 			    ohci_timeout, xfer);
   2806   1.15  augustss 	}
   2807   1.34  augustss 
   2808   1.52  augustss #if 0
   2809   1.52  augustss /* This goes wrong if we are too slow. */
   2810   1.75  augustss 	if (ohcidebug > 10) {
   2811   1.75  augustss 		delay(10000);
   2812   1.41  augustss 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
   2813   1.41  augustss 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
   2814   1.34  augustss 		ohci_dump_ed(sed);
   2815   1.48  augustss 		ohci_dump_tds(data);
   2816   1.34  augustss 	}
   2817   1.34  augustss #endif
   2818   1.34  augustss 
   2819    1.3  augustss 	splx(s);
   2820    1.3  augustss 
   2821    1.3  augustss 	return (USBD_IN_PROGRESS);
   2822    1.3  augustss }
   2823    1.3  augustss 
   2824   1.82  augustss Static void
   2825   1.91  augustss ohci_device_bulk_abort(usbd_xfer_handle xfer)
   2826    1.3  augustss {
   2827   1.53  augustss 	DPRINTF(("ohci_device_bulk_abort: xfer=%p\n", xfer));
   2828   1.54  augustss 	ohci_abort_xfer(xfer, USBD_CANCELLED);
   2829    1.3  augustss }
   2830    1.3  augustss 
   2831   1.34  augustss /*
   2832   1.34  augustss  * Close a device bulk pipe.
   2833   1.34  augustss  */
   2834   1.82  augustss Static void
   2835   1.91  augustss ohci_device_bulk_close(usbd_pipe_handle pipe)
   2836    1.3  augustss {
   2837   1.60  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   2838   1.34  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2839    1.3  augustss 
   2840   1.34  augustss 	DPRINTF(("ohci_device_bulk_close: pipe=%p\n", pipe));
   2841   1.34  augustss 	ohci_close_pipe(pipe, sc->sc_bulk_head);
   2842   1.60  augustss 	ohci_free_std(sc, opipe->tail.td);
   2843    1.1  augustss }
   2844    1.1  augustss 
   2845    1.1  augustss /************************/
   2846    1.1  augustss 
   2847   1.82  augustss Static usbd_status
   2848   1.91  augustss ohci_device_intr_transfer(usbd_xfer_handle xfer)
   2849   1.17  augustss {
   2850   1.53  augustss 	usbd_status err;
   2851   1.17  augustss 
   2852   1.46  augustss 	/* Insert last in queue. */
   2853   1.53  augustss 	err = usb_insert_transfer(xfer);
   2854   1.53  augustss 	if (err)
   2855   1.53  augustss 		return (err);
   2856   1.46  augustss 
   2857   1.46  augustss 	/* Pipe isn't running, start first */
   2858   1.53  augustss 	return (ohci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)));
   2859   1.17  augustss }
   2860   1.17  augustss 
   2861   1.82  augustss Static usbd_status
   2862   1.91  augustss ohci_device_intr_start(usbd_xfer_handle xfer)
   2863    1.1  augustss {
   2864   1.53  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   2865    1.1  augustss 	usbd_device_handle dev = opipe->pipe.device;
   2866    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
   2867    1.1  augustss 	ohci_soft_ed_t *sed = opipe->sed;
   2868   1.48  augustss 	ohci_soft_td_t *data, *tail;
   2869    1.1  augustss 	int len;
   2870    1.1  augustss 	int s;
   2871    1.1  augustss 
   2872   1.83  augustss 	if (sc->sc_dying)
   2873   1.83  augustss 		return (USBD_IOERROR);
   2874   1.83  augustss 
   2875   1.53  augustss 	DPRINTFN(3, ("ohci_device_intr_transfer: xfer=%p len=%d "
   2876   1.14  augustss 		     "flags=%d priv=%p\n",
   2877   1.53  augustss 		     xfer, xfer->length, xfer->flags, xfer->priv));
   2878    1.1  augustss 
   2879   1.42  augustss #ifdef DIAGNOSTIC
   2880   1.53  augustss 	if (xfer->rqflags & URQ_REQUEST)
   2881    1.1  augustss 		panic("ohci_device_intr_transfer: a request\n");
   2882   1.42  augustss #endif
   2883    1.1  augustss 
   2884   1.53  augustss 	len = xfer->length;
   2885    1.1  augustss 
   2886   1.60  augustss 	data = opipe->tail.td;
   2887    1.1  augustss 	tail = ohci_alloc_std(sc);
   2888   1.55  augustss 	if (tail == NULL)
   2889   1.43  augustss 		return (USBD_NOMEM);
   2890   1.53  augustss 	tail->xfer = NULL;
   2891    1.1  augustss 
   2892   1.76   tsutsui 	data->td.td_flags = htole32(
   2893   1.16  augustss 		OHCI_TD_IN | OHCI_TD_NOCC |
   2894   1.16  augustss 		OHCI_TD_SET_DI(1) | OHCI_TD_TOGGLE_CARRY);
   2895   1.53  augustss 	if (xfer->flags & USBD_SHORT_XFER_OK)
   2896   1.76   tsutsui 		data->td.td_flags |= htole32(OHCI_TD_R);
   2897   1.76   tsutsui 	data->td.td_cbp = htole32(DMAADDR(&xfer->dmabuf));
   2898   1.48  augustss 	data->nexttd = tail;
   2899   1.76   tsutsui 	data->td.td_nexttd = htole32(tail->physaddr);
   2900   1.76   tsutsui 	data->td.td_be = htole32(le32toh(data->td.td_cbp) + len - 1);
   2901   1.48  augustss 	data->len = len;
   2902   1.53  augustss 	data->xfer = xfer;
   2903   1.48  augustss 	data->flags = OHCI_CALL_DONE | OHCI_ADD_LEN;
   2904   1.53  augustss 	xfer->hcpriv = data;
   2905    1.1  augustss 
   2906   1.52  augustss #ifdef OHCI_DEBUG
   2907    1.1  augustss 	if (ohcidebug > 5) {
   2908   1.41  augustss 		DPRINTF(("ohci_device_intr_transfer:\n"));
   2909    1.1  augustss 		ohci_dump_ed(sed);
   2910   1.48  augustss 		ohci_dump_tds(data);
   2911    1.1  augustss 	}
   2912    1.1  augustss #endif
   2913    1.1  augustss 
   2914    1.1  augustss 	/* Insert ED in schedule */
   2915    1.1  augustss 	s = splusb();
   2916   1.76   tsutsui 	sed->ed.ed_tailp = htole32(tail->physaddr);
   2917   1.60  augustss 	opipe->tail.td = tail;
   2918   1.76   tsutsui 	sed->ed.ed_flags &= htole32(~OHCI_ED_SKIP);
   2919    1.1  augustss 
   2920   1.52  augustss #if 0
   2921   1.52  augustss /*
   2922   1.52  augustss  * This goes horribly wrong, printing thousands of descriptors,
   2923   1.52  augustss  * because false references are followed due to the fact that the
   2924   1.52  augustss  * TD is gone.
   2925   1.52  augustss  */
   2926    1.1  augustss 	if (ohcidebug > 5) {
   2927   1.55  augustss 		usb_delay_ms(&sc->sc_bus, 5);
   2928   1.41  augustss 		DPRINTF(("ohci_device_intr_transfer: status=%x\n",
   2929   1.41  augustss 			 OREAD4(sc, OHCI_COMMAND_STATUS)));
   2930    1.1  augustss 		ohci_dump_ed(sed);
   2931   1.48  augustss 		ohci_dump_tds(data);
   2932    1.1  augustss 	}
   2933    1.1  augustss #endif
   2934   1.26  augustss 	splx(s);
   2935    1.1  augustss 
   2936    1.1  augustss 	return (USBD_IN_PROGRESS);
   2937    1.1  augustss }
   2938    1.1  augustss 
   2939    1.1  augustss /* Abort a device control request. */
   2940   1.82  augustss Static void
   2941   1.91  augustss ohci_device_intr_abort(usbd_xfer_handle xfer)
   2942    1.1  augustss {
   2943   1.53  augustss 	if (xfer->pipe->intrxfer == xfer) {
   2944    1.1  augustss 		DPRINTF(("ohci_device_intr_abort: remove\n"));
   2945   1.55  augustss 		xfer->pipe->intrxfer = NULL;
   2946    1.1  augustss 	}
   2947   1.54  augustss 	ohci_abort_xfer(xfer, USBD_CANCELLED);
   2948    1.1  augustss }
   2949    1.1  augustss 
   2950    1.1  augustss /* Close a device interrupt pipe. */
   2951   1.82  augustss Static void
   2952   1.91  augustss ohci_device_intr_close(usbd_pipe_handle pipe)
   2953    1.1  augustss {
   2954    1.1  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   2955    1.1  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   2956    1.1  augustss 	int nslots = opipe->u.intr.nslots;
   2957    1.1  augustss 	int pos = opipe->u.intr.pos;
   2958    1.1  augustss 	int j;
   2959    1.1  augustss 	ohci_soft_ed_t *p, *sed = opipe->sed;
   2960    1.1  augustss 	int s;
   2961    1.1  augustss 
   2962    1.1  augustss 	DPRINTFN(1,("ohci_device_intr_close: pipe=%p nslots=%d pos=%d\n",
   2963    1.1  augustss 		    pipe, nslots, pos));
   2964    1.1  augustss 	s = splusb();
   2965   1.76   tsutsui 	sed->ed.ed_flags |= htole32(OHCI_ED_SKIP);
   2966   1.76   tsutsui 	if ((le32toh(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
   2967   1.76   tsutsui 	    (le32toh(sed->ed.ed_headp) & OHCI_HEADMASK))
   2968   1.20  augustss 		usb_delay_ms(&sc->sc_bus, 2);
   2969    1.1  augustss 
   2970    1.1  augustss 	for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next)
   2971    1.1  augustss 		;
   2972   1.53  augustss #ifdef DIAGNOSTIC
   2973   1.53  augustss 	if (p == NULL)
   2974    1.1  augustss 		panic("ohci_device_intr_close: ED not found\n");
   2975   1.53  augustss #endif
   2976    1.1  augustss 	p->next = sed->next;
   2977   1.39  augustss 	p->ed.ed_nexted = sed->ed.ed_nexted;
   2978    1.1  augustss 	splx(s);
   2979    1.1  augustss 
   2980    1.1  augustss 	for (j = 0; j < nslots; j++)
   2981   1.31  wrstuden 		--sc->sc_bws[(pos * nslots + j) % OHCI_NO_INTRS];
   2982    1.1  augustss 
   2983   1.60  augustss 	ohci_free_std(sc, opipe->tail.td);
   2984    1.1  augustss 	ohci_free_sed(sc, opipe->sed);
   2985    1.1  augustss }
   2986    1.1  augustss 
   2987   1.82  augustss Static usbd_status
   2988   1.91  augustss ohci_device_setintr(ohci_softc_t *sc, struct ohci_pipe *opipe, int ival)
   2989    1.1  augustss {
   2990    1.1  augustss 	int i, j, s, best;
   2991    1.1  augustss 	u_int npoll, slow, shigh, nslots;
   2992    1.1  augustss 	u_int bestbw, bw;
   2993    1.1  augustss 	ohci_soft_ed_t *hsed, *sed = opipe->sed;
   2994    1.1  augustss 
   2995    1.1  augustss 	DPRINTFN(2, ("ohci_setintr: pipe=%p\n", opipe));
   2996    1.1  augustss 	if (ival == 0) {
   2997    1.1  augustss 		printf("ohci_setintr: 0 interval\n");
   2998    1.1  augustss 		return (USBD_INVAL);
   2999    1.1  augustss 	}
   3000    1.1  augustss 
   3001    1.1  augustss 	npoll = OHCI_NO_INTRS;
   3002    1.1  augustss 	while (npoll > ival)
   3003    1.1  augustss 		npoll /= 2;
   3004    1.1  augustss 	DPRINTFN(2, ("ohci_setintr: ival=%d npoll=%d\n", ival, npoll));
   3005    1.1  augustss 
   3006    1.1  augustss 	/*
   3007    1.1  augustss 	 * We now know which level in the tree the ED must go into.
   3008    1.1  augustss 	 * Figure out which slot has most bandwidth left over.
   3009    1.1  augustss 	 * Slots to examine:
   3010    1.1  augustss 	 * npoll
   3011    1.1  augustss 	 * 1	0
   3012    1.1  augustss 	 * 2	1 2
   3013    1.1  augustss 	 * 4	3 4 5 6
   3014    1.1  augustss 	 * 8	7 8 9 10 11 12 13 14
   3015    1.1  augustss 	 * N    (N-1) .. (N-1+N-1)
   3016    1.1  augustss 	 */
   3017    1.1  augustss 	slow = npoll-1;
   3018    1.1  augustss 	shigh = slow + npoll;
   3019    1.1  augustss 	nslots = OHCI_NO_INTRS / npoll;
   3020    1.1  augustss 	for (best = i = slow, bestbw = ~0; i < shigh; i++) {
   3021    1.1  augustss 		bw = 0;
   3022    1.1  augustss 		for (j = 0; j < nslots; j++)
   3023   1.28  augustss 			bw += sc->sc_bws[(i * nslots + j) % OHCI_NO_INTRS];
   3024    1.1  augustss 		if (bw < bestbw) {
   3025    1.1  augustss 			best = i;
   3026    1.1  augustss 			bestbw = bw;
   3027    1.1  augustss 		}
   3028    1.1  augustss 	}
   3029    1.1  augustss 	DPRINTFN(2, ("ohci_setintr: best=%d(%d..%d) bestbw=%d\n",
   3030    1.1  augustss 		     best, slow, shigh, bestbw));
   3031    1.1  augustss 
   3032    1.1  augustss 	s = splusb();
   3033    1.1  augustss 	hsed = sc->sc_eds[best];
   3034    1.1  augustss 	sed->next = hsed->next;
   3035   1.39  augustss 	sed->ed.ed_nexted = hsed->ed.ed_nexted;
   3036    1.1  augustss 	hsed->next = sed;
   3037   1.76   tsutsui 	hsed->ed.ed_nexted = htole32(sed->physaddr);
   3038    1.1  augustss 	splx(s);
   3039    1.1  augustss 
   3040    1.1  augustss 	for (j = 0; j < nslots; j++)
   3041   1.28  augustss 		++sc->sc_bws[(best * nslots + j) % OHCI_NO_INTRS];
   3042    1.1  augustss 	opipe->u.intr.nslots = nslots;
   3043    1.1  augustss 	opipe->u.intr.pos = best;
   3044    1.1  augustss 
   3045    1.1  augustss 	DPRINTFN(5, ("ohci_setintr: returns %p\n", opipe));
   3046    1.1  augustss 	return (USBD_NORMAL_COMPLETION);
   3047   1.60  augustss }
   3048   1.60  augustss 
   3049   1.60  augustss /***********************/
   3050   1.60  augustss 
   3051   1.60  augustss usbd_status
   3052   1.91  augustss ohci_device_isoc_transfer(usbd_xfer_handle xfer)
   3053   1.60  augustss {
   3054   1.60  augustss 	usbd_status err;
   3055   1.60  augustss 
   3056   1.60  augustss 	DPRINTFN(5,("ohci_device_isoc_transfer: xfer=%p\n", xfer));
   3057   1.60  augustss 
   3058   1.60  augustss 	/* Put it on our queue, */
   3059   1.60  augustss 	err = usb_insert_transfer(xfer);
   3060   1.60  augustss 
   3061   1.60  augustss 	/* bail out on error, */
   3062   1.60  augustss 	if (err && err != USBD_IN_PROGRESS)
   3063   1.60  augustss 		return (err);
   3064   1.60  augustss 
   3065   1.60  augustss 	/* XXX should check inuse here */
   3066   1.60  augustss 
   3067   1.60  augustss 	/* insert into schedule, */
   3068   1.60  augustss 	ohci_device_isoc_enter(xfer);
   3069   1.60  augustss 
   3070   1.83  augustss 	/* and start if the pipe wasn't running */
   3071   1.60  augustss 	if (!err)
   3072   1.60  augustss 		ohci_device_isoc_start(SIMPLEQ_FIRST(&xfer->pipe->queue));
   3073   1.60  augustss 
   3074   1.60  augustss 	return (err);
   3075   1.60  augustss }
   3076   1.60  augustss 
   3077   1.60  augustss void
   3078   1.91  augustss ohci_device_isoc_enter(usbd_xfer_handle xfer)
   3079   1.60  augustss {
   3080   1.61  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   3081   1.61  augustss 	usbd_device_handle dev = opipe->pipe.device;
   3082   1.61  augustss 	ohci_softc_t *sc = (ohci_softc_t *)dev->bus;
   3083   1.61  augustss 	ohci_soft_ed_t *sed = opipe->sed;
   3084   1.61  augustss 	struct iso *iso = &opipe->u.iso;
   3085   1.61  augustss 	ohci_soft_itd_t *sitd, *nsitd;
   3086   1.83  augustss 	ohci_physaddr_t buf, offs, noffs, bp0;
   3087   1.61  augustss 	int i, ncur, nframes;
   3088   1.61  augustss 	int s;
   3089   1.61  augustss 
   3090   1.83  augustss 	DPRINTFN(1,("ohci_device_isoc_enter: used=%d next=%d xfer=%p "
   3091   1.83  augustss 		    "nframes=%d\n",
   3092   1.83  augustss 		    iso->inuse, iso->next, xfer, xfer->nframes));
   3093   1.83  augustss 
   3094   1.83  augustss 	if (sc->sc_dying)
   3095   1.83  augustss 		return;
   3096   1.83  augustss 
   3097   1.83  augustss 	if (iso->next == -1) {
   3098   1.83  augustss 		/* Not in use yet, schedule it a few frames ahead. */
   3099   1.83  augustss 		iso->next = le32toh(sc->sc_hcca->hcca_frame_number) + 5;
   3100   1.83  augustss 		DPRINTFN(2,("ohci_device_isoc_enter: start next=%d\n",
   3101   1.83  augustss 			    iso->next));
   3102   1.83  augustss 	}
   3103   1.83  augustss 
   3104   1.61  augustss 	sitd = opipe->tail.itd;
   3105   1.61  augustss 	buf = DMAADDR(&xfer->dmabuf);
   3106   1.83  augustss 	bp0 = OHCI_PAGE(buf);
   3107   1.83  augustss 	offs = OHCI_PAGE_OFFSET(buf);
   3108   1.61  augustss 	nframes = xfer->nframes;
   3109   1.83  augustss 	xfer->hcpriv = sitd;
   3110   1.61  augustss 	for (i = ncur = 0; i < nframes; i++, ncur++) {
   3111   1.83  augustss 		noffs = offs + xfer->frlengths[i];
   3112   1.61  augustss 		if (ncur == OHCI_ITD_NOFFSET ||	/* all offsets used */
   3113   1.83  augustss 		    OHCI_PAGE(buf + noffs) > bp0 + OHCI_PAGE_SIZE) { /* too many page crossings */
   3114   1.61  augustss 
   3115   1.83  augustss 			/* Allocate next ITD */
   3116   1.61  augustss 			nsitd = ohci_alloc_sitd(sc);
   3117   1.61  augustss 			if (nsitd == NULL) {
   3118   1.61  augustss 				/* XXX what now? */
   3119   1.83  augustss 				printf("%s: isoc TD alloc failed\n",
   3120   1.83  augustss 				       USBDEVNAME(sc->sc_bus.bdev));
   3121   1.61  augustss 				return;
   3122   1.61  augustss 			}
   3123   1.83  augustss 
   3124   1.83  augustss 			/* Fill current ITD */
   3125   1.76   tsutsui 			sitd->itd.itd_flags = htole32(
   3126   1.61  augustss 				OHCI_ITD_NOCC |
   3127   1.61  augustss 				OHCI_ITD_SET_SF(iso->next) |
   3128   1.83  augustss 				OHCI_ITD_SET_DI(6) | /* delay intr a little */
   3129   1.83  augustss 				OHCI_ITD_SET_FC(ncur));
   3130   1.83  augustss 			sitd->itd.itd_bp0 = htole32(bp0);
   3131   1.83  augustss 			sitd->nextitd = nsitd;
   3132   1.83  augustss 			sitd->itd.itd_nextitd = htole32(nsitd->physaddr);
   3133   1.83  augustss 			sitd->itd.itd_be = htole32(bp0 + offs - 1);
   3134   1.83  augustss 			sitd->xfer = xfer;
   3135   1.83  augustss 			sitd->flags = 0;
   3136   1.83  augustss 
   3137   1.61  augustss 			sitd = nsitd;
   3138   1.61  augustss 			iso->next = iso->next + ncur;
   3139   1.83  augustss 			bp0 = OHCI_PAGE(buf + offs);
   3140   1.61  augustss 			ncur = 0;
   3141   1.61  augustss 		}
   3142   1.83  augustss 		sitd->itd.itd_offset[ncur] = htole16(OHCI_ITD_MK_OFFS(offs));
   3143   1.83  augustss 		offs = noffs;
   3144   1.61  augustss 	}
   3145   1.61  augustss 	nsitd = ohci_alloc_sitd(sc);
   3146   1.61  augustss 	if (nsitd == NULL) {
   3147   1.61  augustss 		/* XXX what now? */
   3148   1.83  augustss 		printf("%s: isoc TD alloc failed\n",
   3149   1.83  augustss 		       USBDEVNAME(sc->sc_bus.bdev));
   3150   1.61  augustss 		return;
   3151   1.61  augustss 	}
   3152   1.83  augustss 	/* Fixup last used ITD */
   3153   1.83  augustss 	sitd->itd.itd_flags = htole32(
   3154   1.61  augustss 		OHCI_ITD_NOCC |
   3155   1.61  augustss 		OHCI_ITD_SET_SF(iso->next) |
   3156   1.61  augustss 		OHCI_ITD_SET_DI(0) |
   3157   1.61  augustss 		OHCI_ITD_SET_FC(ncur));
   3158   1.83  augustss 	sitd->itd.itd_bp0 = htole32(bp0);
   3159   1.83  augustss 	sitd->nextitd = nsitd;
   3160   1.83  augustss 	sitd->itd.itd_nextitd = htole32(nsitd->physaddr);
   3161   1.83  augustss 	sitd->itd.itd_be = htole32(bp0 + offs - 1);
   3162   1.83  augustss 	sitd->xfer = xfer;
   3163   1.83  augustss 	sitd->flags = OHCI_CALL_DONE;
   3164   1.83  augustss 
   3165   1.61  augustss 	iso->next = iso->next + ncur;
   3166   1.83  augustss 	iso->inuse += nframes;
   3167   1.83  augustss 
   3168   1.83  augustss 	xfer->actlen = offs;	/* XXX pretend we did it all */
   3169   1.83  augustss 
   3170   1.83  augustss 	xfer->status = USBD_IN_PROGRESS;
   3171   1.83  augustss 
   3172   1.83  augustss #ifdef OHCI_DEBUG
   3173   1.83  augustss 	if (ohcidebug > 5) {
   3174   1.83  augustss 		DPRINTF(("ohci_device_isoc_enter: frame=%d\n",
   3175   1.83  augustss 			 le32toh(sc->sc_hcca->hcca_frame_number)));
   3176   1.83  augustss 		ohci_dump_itds(xfer->hcpriv);
   3177   1.83  augustss 		ohci_dump_ed(sed);
   3178   1.83  augustss 	}
   3179   1.83  augustss #endif
   3180   1.61  augustss 
   3181   1.83  augustss 	s = splusb();
   3182   1.61  augustss 	opipe->tail.itd = nsitd;
   3183   1.76   tsutsui 	sed->ed.ed_tailp = htole32(nsitd->physaddr);
   3184   1.61  augustss 	splx(s);
   3185   1.83  augustss 
   3186   1.83  augustss #ifdef OHCI_DEBUG
   3187   1.83  augustss 	if (ohcidebug > 5) {
   3188   1.83  augustss 		delay(150000);
   3189   1.83  augustss 		DPRINTF(("ohci_device_isoc_enter: after frame=%d\n",
   3190   1.83  augustss 			 le32toh(sc->sc_hcca->hcca_frame_number)));
   3191   1.83  augustss 		ohci_dump_itds(xfer->hcpriv);
   3192   1.83  augustss 		ohci_dump_ed(sed);
   3193   1.83  augustss 	}
   3194   1.83  augustss #endif
   3195   1.60  augustss }
   3196   1.60  augustss 
   3197   1.60  augustss usbd_status
   3198   1.91  augustss ohci_device_isoc_start(usbd_xfer_handle xfer)
   3199   1.60  augustss {
   3200   1.83  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   3201   1.83  augustss 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
   3202   1.83  augustss 
   3203   1.83  augustss 	DPRINTFN(5,("ohci_device_isoc_start: xfer=%p\n", xfer));
   3204   1.83  augustss 
   3205   1.83  augustss 	if (sc->sc_dying)
   3206   1.83  augustss 		return (USBD_IOERROR);
   3207   1.83  augustss 
   3208   1.83  augustss #ifdef DIAGNOSTIC
   3209   1.83  augustss 	if (xfer->status != USBD_IN_PROGRESS)
   3210   1.83  augustss 		printf("uhci_device_isoc_start: not in progress %p\n", xfer);
   3211   1.83  augustss #endif
   3212   1.83  augustss 
   3213   1.83  augustss 	/* XXX anything to do? */
   3214   1.83  augustss 
   3215   1.83  augustss 	return (USBD_IN_PROGRESS);
   3216   1.60  augustss }
   3217   1.60  augustss 
   3218   1.60  augustss void
   3219   1.91  augustss ohci_device_isoc_abort(usbd_xfer_handle xfer)
   3220   1.60  augustss {
   3221   1.83  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   3222   1.83  augustss 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
   3223   1.83  augustss 	ohci_soft_ed_t *sed;
   3224   1.83  augustss 	ohci_soft_itd_t *sitd;
   3225   1.83  augustss 	int s;
   3226   1.83  augustss 
   3227   1.83  augustss 	s = splusb();
   3228   1.83  augustss 
   3229   1.83  augustss 	DPRINTFN(1,("ohci_device_isoc_abort: xfer=%p\n", xfer));
   3230   1.83  augustss 
   3231   1.83  augustss 	/* Transfer is already done. */
   3232   1.83  augustss 	if (xfer->status != USBD_NOT_STARTED &&
   3233   1.83  augustss 	    xfer->status != USBD_IN_PROGRESS) {
   3234   1.83  augustss 		splx(s);
   3235   1.83  augustss 		printf("ohci_device_isoc_abort: early return\n");
   3236   1.83  augustss 		return;
   3237   1.83  augustss 	}
   3238   1.83  augustss 
   3239   1.83  augustss 	/* Give xfer the requested abort code. */
   3240   1.83  augustss 	xfer->status = USBD_CANCELLED;
   3241   1.83  augustss 
   3242   1.83  augustss 	sed = opipe->sed;
   3243   1.83  augustss 	sed->ed.ed_flags |= htole32(OHCI_ED_SKIP); /* force hardware skip */
   3244   1.83  augustss 
   3245   1.83  augustss 	sitd = xfer->hcpriv;
   3246   1.83  augustss #ifdef DIAGNOSTIC
   3247   1.83  augustss 	if (sitd == NULL) {
   3248  1.102  augustss 		splx(s);
   3249   1.83  augustss 		printf("ohci_device_isoc_abort: hcpriv==0\n");
   3250   1.83  augustss 		return;
   3251   1.83  augustss 	}
   3252   1.83  augustss #endif
   3253   1.83  augustss 	for (; sitd->xfer == xfer; sitd = sitd->nextitd) {
   3254   1.83  augustss #ifdef DIAGNOSTIC
   3255   1.83  augustss 		DPRINTFN(1,("abort sets done sitd=%p\n", sitd));
   3256   1.83  augustss 		sitd->isdone = 1;
   3257   1.83  augustss #endif
   3258   1.83  augustss 	}
   3259   1.83  augustss 
   3260   1.83  augustss 	splx(s);
   3261   1.83  augustss 
   3262   1.83  augustss 	usb_delay_ms(&sc->sc_bus, OHCI_ITD_NOFFSET);
   3263   1.83  augustss 
   3264   1.83  augustss 	s = splusb();
   3265   1.83  augustss 
   3266   1.83  augustss 	/* Run callback. */
   3267   1.83  augustss 	usb_transfer_complete(xfer);
   3268   1.83  augustss 
   3269   1.83  augustss 	sed->ed.ed_headp = htole32(sitd->physaddr); /* unlink TDs */
   3270   1.83  augustss 	sed->ed.ed_flags &= htole32(~OHCI_ED_SKIP); /* remove hardware skip */
   3271   1.83  augustss 
   3272   1.83  augustss 	splx(s);
   3273   1.60  augustss }
   3274   1.60  augustss 
   3275   1.60  augustss void
   3276   1.91  augustss ohci_device_isoc_done(usbd_xfer_handle xfer)
   3277   1.60  augustss {
   3278   1.83  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)xfer->pipe;
   3279   1.83  augustss 	ohci_softc_t *sc = (ohci_softc_t *)opipe->pipe.device->bus;
   3280   1.83  augustss 	ohci_soft_itd_t *sitd, *nsitd;
   3281   1.83  augustss 
   3282   1.83  augustss 	DPRINTFN(1,("ohci_device_isoc_done: xfer=%p\n", xfer));
   3283   1.83  augustss 
   3284   1.83  augustss 	for (sitd = xfer->hcpriv;
   3285   1.83  augustss 	     !(sitd->flags & OHCI_CALL_DONE);
   3286   1.83  augustss 	     sitd = nsitd) {
   3287   1.83  augustss 		nsitd = sitd->nextitd;
   3288   1.83  augustss 		DPRINTFN(1,("ohci_device_isoc_done: free sitd=%p\n", sitd));
   3289   1.83  augustss 		ohci_free_sitd(sc, sitd);
   3290   1.83  augustss 	}
   3291   1.83  augustss 	ohci_free_sitd(sc, sitd);
   3292   1.83  augustss 	xfer->hcpriv = NULL;
   3293   1.60  augustss }
   3294   1.60  augustss 
   3295   1.60  augustss usbd_status
   3296   1.91  augustss ohci_setup_isoc(usbd_pipe_handle pipe)
   3297   1.60  augustss {
   3298   1.60  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   3299   1.83  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   3300   1.60  augustss 	struct iso *iso = &opipe->u.iso;
   3301   1.83  augustss 	int s;
   3302   1.60  augustss 
   3303   1.60  augustss 	iso->next = -1;
   3304   1.60  augustss 	iso->inuse = 0;
   3305   1.60  augustss 
   3306   1.83  augustss 	s = splusb();
   3307   1.83  augustss 	ohci_add_ed(opipe->sed, sc->sc_isoc_head);
   3308   1.83  augustss 	splx(s);
   3309   1.83  augustss 
   3310   1.60  augustss 	return (USBD_NORMAL_COMPLETION);
   3311   1.60  augustss }
   3312   1.60  augustss 
   3313   1.60  augustss void
   3314   1.91  augustss ohci_device_isoc_close(usbd_pipe_handle pipe)
   3315   1.60  augustss {
   3316   1.60  augustss 	struct ohci_pipe *opipe = (struct ohci_pipe *)pipe;
   3317   1.60  augustss 	ohci_softc_t *sc = (ohci_softc_t *)pipe->device->bus;
   3318   1.83  augustss 	int s;
   3319   1.60  augustss 
   3320   1.60  augustss 	DPRINTF(("ohci_device_isoc_close: pipe=%p\n", pipe));
   3321   1.83  augustss 
   3322   1.83  augustss 	s = splusb();
   3323   1.83  augustss 	ohci_rem_ed(opipe->sed, sc->sc_isoc_head);
   3324   1.83  augustss 	splx(s);
   3325   1.60  augustss 	ohci_close_pipe(pipe, sc->sc_isoc_head);
   3326   1.83  augustss #ifdef DIAGNOSTIC
   3327   1.83  augustss 	opipe->tail.itd->isdone = 1;
   3328   1.83  augustss #endif
   3329   1.60  augustss 	ohci_free_sitd(sc, opipe->tail.itd);
   3330    1.1  augustss }
   3331