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