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