uhci.c revision 1.38
1 /* $NetBSD: uhci.c,v 1.38 1999/08/17 20:59:04 augustss Exp $ */ 2 3 /* 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (augustss (at) carlstedt.se) at 9 * Carlstedt Research & Technology. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * USB Universal Host Controller driver. 42 * Handles e.g. PIIX3 and PIIX4. 43 * 44 * Data sheets: ftp://download.intel.com/design/intarch/datashts/29055002.pdf 45 * ftp://download.intel.com/design/intarch/datashts/29056201.pdf 46 * UHCI spec: http://www.intel.com/design/usb/uhci11d.pdf 47 * USB spec: http://www.usb.org/developers/data/usb11.pdf 48 */ 49 50 #include <sys/param.h> 51 #include <sys/systm.h> 52 #include <sys/kernel.h> 53 #include <sys/malloc.h> 54 #if defined(__NetBSD__) || defined(__OpenBSD__) 55 #include <sys/device.h> 56 #elif defined(__FreeBSD__) 57 #include <sys/module.h> 58 #include <sys/bus.h> 59 #endif 60 #include <sys/proc.h> 61 #include <sys/queue.h> 62 #include <sys/select.h> 63 64 #if defined(__FreeBSD__) 65 #include <machine/bus_pio.h> 66 #endif 67 #include <machine/bus.h> 68 69 #include <dev/usb/usb.h> 70 #include <dev/usb/usbdi.h> 71 #include <dev/usb/usbdivar.h> 72 #include <dev/usb/usb_mem.h> 73 #include <dev/usb/usb_quirks.h> 74 75 #include <dev/usb/uhcireg.h> 76 #include <dev/usb/uhcivar.h> 77 78 #if defined(__FreeBSD__) 79 #include <machine/clock.h> 80 81 #define delay(d) DELAY(d) 82 #endif 83 84 #define MS_TO_TICKS(ms) ((ms) * hz / 1000) 85 86 #if defined(__OpenBSD__) 87 struct cfdriver uhci_cd = { 88 NULL, "uhci", DV_DULL 89 }; 90 #endif 91 92 struct uhci_pipe { 93 struct usbd_pipe pipe; 94 uhci_intr_info_t *iinfo; 95 int nexttoggle; 96 /* Info needed for different pipe kinds. */ 97 union { 98 /* Control pipe */ 99 struct { 100 uhci_soft_qh_t *sqh; 101 usb_dma_t reqdma; 102 usb_dma_t datadma; 103 uhci_soft_td_t *setup, *stat; 104 u_int length; 105 } ctl; 106 /* Interrupt pipe */ 107 struct { 108 usb_dma_t datadma; 109 int npoll; 110 uhci_soft_qh_t **qhs; 111 } intr; 112 /* Bulk pipe */ 113 struct { 114 uhci_soft_qh_t *sqh; 115 usb_dma_t datadma; 116 u_int length; 117 int isread; 118 } bulk; 119 /* Iso pipe */ 120 struct iso { 121 u_int bufsize; 122 u_int nbuf; 123 usb_dma_t *bufs; 124 uhci_soft_td_t **stds; 125 } iso; 126 } u; 127 }; 128 129 /* 130 * The uhci_intr_info free list can be global since they contain 131 * no dma specific data. The other free lists do. 132 */ 133 LIST_HEAD(, uhci_intr_info) uhci_ii_free; 134 135 void uhci_busreset __P((uhci_softc_t *)); 136 void uhci_power __P((int, void *)); 137 usbd_status uhci_run __P((uhci_softc_t *, int run)); 138 uhci_soft_td_t *uhci_alloc_std __P((uhci_softc_t *)); 139 void uhci_free_std __P((uhci_softc_t *, uhci_soft_td_t *)); 140 uhci_soft_qh_t *uhci_alloc_sqh __P((uhci_softc_t *)); 141 void uhci_free_sqh __P((uhci_softc_t *, uhci_soft_qh_t *)); 142 uhci_intr_info_t *uhci_alloc_intr_info __P((uhci_softc_t *)); 143 void uhci_free_intr_info __P((uhci_intr_info_t *ii)); 144 #if 0 145 void uhci_enter_ctl_q __P((uhci_softc_t *, uhci_soft_qh_t *, 146 uhci_intr_info_t *)); 147 void uhci_exit_ctl_q __P((uhci_softc_t *, uhci_soft_qh_t *)); 148 #endif 149 150 void uhci_free_std_chain __P((uhci_softc_t *, 151 uhci_soft_td_t *, uhci_soft_td_t *)); 152 usbd_status uhci_alloc_std_chain __P((struct uhci_pipe *, uhci_softc_t *, 153 int, int, int, usb_dma_t *, 154 uhci_soft_td_t **, 155 uhci_soft_td_t **)); 156 void uhci_timo __P((void *)); 157 void uhci_waitintr __P((uhci_softc_t *, usbd_request_handle)); 158 void uhci_check_intr __P((uhci_softc_t *, uhci_intr_info_t *)); 159 void uhci_idone __P((uhci_intr_info_t *)); 160 void uhci_done __P((uhci_intr_info_t *)); 161 void uhci_abort_req __P((usbd_request_handle, usbd_status status)); 162 void uhci_timeout __P((void *)); 163 void uhci_wakeup_ctrl __P((void *, int, int, void *, int)); 164 void uhci_lock_frames __P((uhci_softc_t *)); 165 void uhci_unlock_frames __P((uhci_softc_t *)); 166 void uhci_add_ctrl __P((uhci_softc_t *, uhci_soft_qh_t *)); 167 void uhci_add_bulk __P((uhci_softc_t *, uhci_soft_qh_t *)); 168 void uhci_remove_ctrl __P((uhci_softc_t *, uhci_soft_qh_t *)); 169 void uhci_remove_bulk __P((uhci_softc_t *, uhci_soft_qh_t *)); 170 int uhci_str __P((usb_string_descriptor_t *, int, char *)); 171 172 void uhci_wakeup_cb __P((usbd_request_handle reqh)); 173 174 usbd_status uhci_device_ctrl_transfer __P((usbd_request_handle)); 175 usbd_status uhci_device_ctrl_start __P((usbd_request_handle)); 176 void uhci_device_ctrl_abort __P((usbd_request_handle)); 177 void uhci_device_ctrl_close __P((usbd_pipe_handle)); 178 usbd_status uhci_device_intr_transfer __P((usbd_request_handle)); 179 usbd_status uhci_device_intr_start __P((usbd_request_handle)); 180 void uhci_device_intr_abort __P((usbd_request_handle)); 181 void uhci_device_intr_close __P((usbd_pipe_handle)); 182 usbd_status uhci_device_bulk_transfer __P((usbd_request_handle)); 183 usbd_status uhci_device_bulk_start __P((usbd_request_handle)); 184 void uhci_device_bulk_abort __P((usbd_request_handle)); 185 void uhci_device_bulk_close __P((usbd_pipe_handle)); 186 usbd_status uhci_device_isoc_transfer __P((usbd_request_handle)); 187 usbd_status uhci_device_isoc_start __P((usbd_request_handle)); 188 void uhci_device_isoc_abort __P((usbd_request_handle)); 189 void uhci_device_isoc_close __P((usbd_pipe_handle)); 190 usbd_status uhci_device_isoc_setbuf __P((usbd_pipe_handle, u_int, u_int)); 191 192 usbd_status uhci_root_ctrl_transfer __P((usbd_request_handle)); 193 usbd_status uhci_root_ctrl_start __P((usbd_request_handle)); 194 void uhci_root_ctrl_abort __P((usbd_request_handle)); 195 void uhci_root_ctrl_close __P((usbd_pipe_handle)); 196 usbd_status uhci_root_intr_transfer __P((usbd_request_handle)); 197 usbd_status uhci_root_intr_start __P((usbd_request_handle)); 198 void uhci_root_intr_abort __P((usbd_request_handle)); 199 void uhci_root_intr_close __P((usbd_pipe_handle)); 200 201 usbd_status uhci_open __P((usbd_pipe_handle)); 202 void uhci_poll __P((struct usbd_bus *)); 203 204 usbd_status uhci_device_request __P((usbd_request_handle reqh)); 205 void uhci_ctrl_done __P((uhci_intr_info_t *ii)); 206 void uhci_bulk_done __P((uhci_intr_info_t *ii)); 207 208 void uhci_add_intr __P((uhci_softc_t *, int, uhci_soft_qh_t *)); 209 void uhci_remove_intr __P((uhci_softc_t *, int, uhci_soft_qh_t *)); 210 usbd_status uhci_device_setintr __P((uhci_softc_t *sc, 211 struct uhci_pipe *pipe, int ival)); 212 void uhci_intr_done __P((uhci_intr_info_t *ii)); 213 void uhci_isoc_done __P((uhci_intr_info_t *ii)); 214 215 void uhci_device_clear_toggle __P((usbd_pipe_handle pipe)); 216 void uhci_noop __P((usbd_pipe_handle pipe)); 217 218 #ifdef USB_DEBUG 219 static void uhci_dumpregs __P((uhci_softc_t *)); 220 void uhci_dump_tds __P((uhci_soft_td_t *)); 221 void uhci_dump_qh __P((uhci_soft_qh_t *)); 222 void uhci_dump __P((void)); 223 void uhci_dump_td __P((uhci_soft_td_t *)); 224 #endif 225 226 #define UWRITE2(sc, r, x) bus_space_write_2((sc)->iot, (sc)->ioh, (r), (x)) 227 #define UWRITE4(sc, r, x) bus_space_write_4((sc)->iot, (sc)->ioh, (r), (x)) 228 #define UREAD1(sc, r) bus_space_read_1((sc)->iot, (sc)->ioh, (r)) 229 #define UREAD2(sc, r) bus_space_read_2((sc)->iot, (sc)->ioh, (r)) 230 #define UREAD4(sc, r) bus_space_read_4((sc)->iot, (sc)->ioh, (r)) 231 232 #define UHCICMD(sc, cmd) UWRITE2(sc, UHCI_CMD, cmd) 233 #define UHCISTS(sc) UREAD2(sc, UHCI_STS) 234 235 #define UHCI_RESET_TIMEOUT 100 /* reset timeout */ 236 237 #define UHCI_CURFRAME(sc) (UREAD2(sc, UHCI_FRNUM) & UHCI_FRNUM_MASK) 238 239 #define UHCI_INTR_ENDPT 1 240 241 struct usbd_methods uhci_root_ctrl_methods = { 242 uhci_root_ctrl_transfer, 243 uhci_root_ctrl_start, 244 uhci_root_ctrl_abort, 245 uhci_root_ctrl_close, 246 uhci_noop, 247 0, 248 }; 249 250 struct usbd_methods uhci_root_intr_methods = { 251 uhci_root_intr_transfer, 252 uhci_root_intr_start, 253 uhci_root_intr_abort, 254 uhci_root_intr_close, 255 uhci_noop, 256 0, 257 }; 258 259 struct usbd_methods uhci_device_ctrl_methods = { 260 uhci_device_ctrl_transfer, 261 uhci_device_ctrl_start, 262 uhci_device_ctrl_abort, 263 uhci_device_ctrl_close, 264 uhci_noop, 265 0, 266 }; 267 268 struct usbd_methods uhci_device_intr_methods = { 269 uhci_device_intr_transfer, 270 uhci_device_intr_start, 271 uhci_device_intr_abort, 272 uhci_device_intr_close, 273 uhci_device_clear_toggle, 274 0, 275 }; 276 277 struct usbd_methods uhci_device_bulk_methods = { 278 uhci_device_bulk_transfer, 279 uhci_device_bulk_start, 280 uhci_device_bulk_abort, 281 uhci_device_bulk_close, 282 uhci_device_clear_toggle, 283 0, 284 }; 285 286 struct usbd_methods uhci_device_isoc_methods = { 287 uhci_device_isoc_transfer, 288 uhci_device_isoc_start, 289 uhci_device_isoc_abort, 290 uhci_device_isoc_close, 291 uhci_noop, 292 uhci_device_isoc_setbuf, 293 }; 294 295 void 296 uhci_busreset(sc) 297 uhci_softc_t *sc; 298 { 299 UHCICMD(sc, UHCI_CMD_GRESET); /* global reset */ 300 usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); /* wait a little */ 301 UHCICMD(sc, 0); /* do nothing */ 302 } 303 304 usbd_status 305 uhci_init(sc) 306 uhci_softc_t *sc; 307 { 308 usbd_status r; 309 int i, j; 310 uhci_soft_qh_t *csqh, *bsqh, *sqh; 311 uhci_soft_td_t *std; 312 313 DPRINTFN(1,("uhci_init: start\n")); 314 315 #if defined(USB_DEBUG) 316 if (uhcidebug > 2) 317 uhci_dumpregs(sc); 318 #endif 319 320 uhci_run(sc, 0); /* stop the controller */ 321 UWRITE2(sc, UHCI_INTR, 0); /* disable interrupts */ 322 323 uhci_busreset(sc); 324 325 /* Allocate and initialize real frame array. */ 326 r = usb_allocmem(sc->sc_dmatag, 327 UHCI_FRAMELIST_COUNT * sizeof(uhci_physaddr_t), 328 UHCI_FRAMELIST_ALIGN, &sc->sc_dma); 329 if (r != USBD_NORMAL_COMPLETION) 330 return (r); 331 sc->sc_pframes = KERNADDR(&sc->sc_dma); 332 UWRITE2(sc, UHCI_FRNUM, 0); /* set frame number to 0 */ 333 UWRITE4(sc, UHCI_FLBASEADDR, DMAADDR(&sc->sc_dma)); /* set frame list*/ 334 335 /* Allocate the dummy QH where bulk traffic will be queued. */ 336 bsqh = uhci_alloc_sqh(sc); 337 if (!bsqh) 338 return (USBD_NOMEM); 339 bsqh->qh->qh_hlink = UHCI_PTR_T; /* end of QH chain */ 340 bsqh->qh->qh_elink = UHCI_PTR_T; 341 sc->sc_bulk_start = sc->sc_bulk_end = bsqh; 342 343 /* Allocate the dummy QH where control traffic will be queued. */ 344 csqh = uhci_alloc_sqh(sc); 345 if (!csqh) 346 return (USBD_NOMEM); 347 csqh->qh->hlink = bsqh; 348 csqh->qh->qh_hlink = bsqh->physaddr | UHCI_PTR_Q; 349 csqh->qh->qh_elink = UHCI_PTR_T; 350 sc->sc_ctl_start = sc->sc_ctl_end = csqh; 351 352 /* 353 * Make all (virtual) frame list pointers point to the interrupt 354 * queue heads and the interrupt queue heads at the control 355 * queue head and point the physical frame list to the virtual. 356 */ 357 for(i = 0; i < UHCI_VFRAMELIST_COUNT; i++) { 358 std = uhci_alloc_std(sc); 359 sqh = uhci_alloc_sqh(sc); 360 if (!std || !sqh) 361 return (USBD_NOMEM); 362 std->td->link.sqh = sqh; 363 std->td->td_link = sqh->physaddr | UHCI_PTR_Q; 364 std->td->td_status = UHCI_TD_IOS; /* iso, inactive */ 365 std->td->td_token = 0; 366 std->td->td_buffer = 0; 367 sqh->qh->hlink = csqh; 368 sqh->qh->qh_hlink = csqh->physaddr | UHCI_PTR_Q; 369 sqh->qh->elink = 0; 370 sqh->qh->qh_elink = UHCI_PTR_T; 371 sc->sc_vframes[i].htd = std; 372 sc->sc_vframes[i].etd = std; 373 sc->sc_vframes[i].hqh = sqh; 374 sc->sc_vframes[i].eqh = sqh; 375 for (j = i; 376 j < UHCI_FRAMELIST_COUNT; 377 j += UHCI_VFRAMELIST_COUNT) 378 sc->sc_pframes[j] = std->physaddr; 379 } 380 381 LIST_INIT(&sc->sc_intrhead); 382 383 /* Set up the bus struct. */ 384 sc->sc_bus.open_pipe = uhci_open; 385 sc->sc_bus.pipe_size = sizeof(struct uhci_pipe); 386 sc->sc_bus.do_poll = uhci_poll; 387 388 sc->sc_suspend = PWR_RESUME; 389 powerhook_establish(uhci_power, sc); 390 391 DPRINTFN(1,("uhci_init: enabling\n")); 392 UWRITE2(sc, UHCI_INTR, UHCI_INTR_TOCRCIE | UHCI_INTR_RIE | 393 UHCI_INTR_IOCE | UHCI_INTR_SPIE); /* enable interrupts */ 394 395 return (uhci_run(sc, 1)); /* and here we go... */ 396 } 397 398 #if !defined(__OpenBSD__) 399 /* 400 * Handle suspend/resume. 401 * 402 * Must use delay() here since we are called from an interrupt 403 * context, but since we are close to being inactive anyway 404 * it doesn't matter. 405 */ 406 void 407 uhci_power(why, v) 408 int why; 409 void *v; 410 { 411 uhci_softc_t *sc = v; 412 int cmd; 413 int s; 414 415 s = splusb(); 416 cmd = UREAD2(sc, UHCI_CMD); 417 418 DPRINTF(("uhci_power: sc=%p, why=%d (was %d), cmd=0x%x\n", 419 sc, why, sc->sc_suspend, cmd)); 420 421 if (why != PWR_RESUME) { 422 #if defined(USB_DEBUG) 423 if (uhcidebug > 2) 424 uhci_dumpregs(sc); 425 #endif 426 if (sc->sc_has_timo) 427 usb_untimeout(uhci_timo, sc->sc_has_timo, 428 sc->sc_has_timo->timo_handle); 429 uhci_run(sc, 0); /* stop the controller */ 430 UHCICMD(sc, cmd | UHCI_CMD_EGSM); /* enter global suspend */ 431 delay(USB_RESUME_WAIT * 1000); 432 sc->sc_suspend = why; 433 DPRINTF(("uhci_power: cmd=0x%x\n", UREAD2(sc, UHCI_CMD))); 434 } else { 435 /* 436 * XXX We should really do much more here in case the 437 * controller registers have been lost and BIOS has 438 * not restored them. 439 */ 440 sc->sc_suspend = why; 441 if (cmd & UHCI_CMD_RS) 442 uhci_run(sc, 0); /* in case BIOS has started it */ 443 UHCICMD(sc, cmd | UHCI_CMD_FGR); /* force global resume */ 444 delay(USB_RESUME_DELAY * 1000); 445 UHCICMD(sc, cmd & ~UHCI_CMD_EGSM); /* back to normal */ 446 UWRITE2(sc, UHCI_INTR, UHCI_INTR_TOCRCIE | UHCI_INTR_RIE | 447 UHCI_INTR_IOCE | UHCI_INTR_SPIE); /* re-enable intrs */ 448 uhci_run(sc, 1); /* and start traffic again */ 449 delay(USB_RESUME_RECOVERY * 1000); 450 if (sc->sc_has_timo) 451 usb_timeout(uhci_timo, sc->sc_has_timo, 452 sc->sc_ival, sc->sc_has_timo->timo_handle); 453 #if defined(USB_DEBUG) 454 if (uhcidebug > 2) 455 uhci_dumpregs(sc); 456 #endif 457 } 458 splx(s); 459 } 460 #endif /* !defined(__OpenBSD__) */ 461 462 #ifdef USB_DEBUG 463 static void 464 uhci_dumpregs(sc) 465 uhci_softc_t *sc; 466 { 467 printf("%s regs: cmd=%04x, sts=%04x, intr=%04x, frnum=%04x, " 468 "flbase=%08x, sof=%04x, portsc1=%04x, portsc2=%04x\n", 469 USBDEVNAME(sc->sc_bus.bdev), 470 UREAD2(sc, UHCI_CMD), 471 UREAD2(sc, UHCI_STS), 472 UREAD2(sc, UHCI_INTR), 473 UREAD2(sc, UHCI_FRNUM), 474 UREAD4(sc, UHCI_FLBASEADDR), 475 UREAD1(sc, UHCI_SOF), 476 UREAD2(sc, UHCI_PORTSC1), 477 UREAD2(sc, UHCI_PORTSC2)); 478 } 479 480 int uhci_longtd = 1; 481 482 void 483 uhci_dump_td(p) 484 uhci_soft_td_t *p; 485 { 486 printf("TD(%p) at %08lx = link=0x%08lx status=0x%08lx " 487 "token=0x%08lx buffer=0x%08lx\n", 488 p, (long)p->physaddr, 489 (long)p->td->td_link, 490 (long)p->td->td_status, 491 (long)p->td->td_token, 492 (long)p->td->td_buffer); 493 if (uhci_longtd) 494 printf(" %b %b,errcnt=%d,actlen=%d pid=%02x,addr=%d,endpt=%d," 495 "D=%d,maxlen=%d\n", 496 (int)p->td->td_link, 497 "\20\1T\2Q\3VF", 498 (int)p->td->td_status, 499 "\20\22BITSTUFF\23CRCTO\24NAK\25BABBLE\26DBUFFER\27" 500 "STALLED\30ACTIVE\31IOC\32ISO\33LS\36SPD", 501 UHCI_TD_GET_ERRCNT(p->td->td_status), 502 UHCI_TD_GET_ACTLEN(p->td->td_status), 503 UHCI_TD_GET_PID(p->td->td_token), 504 UHCI_TD_GET_DEVADDR(p->td->td_token), 505 UHCI_TD_GET_ENDPT(p->td->td_token), 506 UHCI_TD_GET_DT(p->td->td_token), 507 UHCI_TD_GET_MAXLEN(p->td->td_token)); 508 } 509 510 void 511 uhci_dump_qh(p) 512 uhci_soft_qh_t *p; 513 { 514 printf("QH(%p) at %08x: hlink=%08x elink=%08x\n", p, (int)p->physaddr, 515 p->qh->qh_hlink, p->qh->qh_elink); 516 } 517 518 519 #if 0 520 void 521 uhci_dump() 522 { 523 uhci_softc_t *sc = uhci; 524 525 uhci_dumpregs(sc); 526 printf("intrs=%d\n", sc->sc_intrs); 527 printf("framelist[i].link = %08x\n", sc->sc_framelist[0].link); 528 uhci_dump_qh(sc->sc_ctl_start->qh->hlink); 529 } 530 #endif 531 532 void 533 uhci_dump_tds(std) 534 uhci_soft_td_t *std; 535 { 536 uhci_soft_td_t *p; 537 538 for(p = std; p; p = p->td->link.std) 539 uhci_dump_td(p); 540 } 541 #endif 542 543 /* 544 * This routine is executed periodically and simulates interrupts 545 * from the root controller interrupt pipe for port status change. 546 */ 547 void 548 uhci_timo(addr) 549 void *addr; 550 { 551 usbd_request_handle reqh = addr; 552 usbd_pipe_handle pipe = reqh->pipe; 553 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 554 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 555 int s; 556 u_char *p; 557 558 DPRINTFN(15, ("uhci_timo\n")); 559 560 p = KERNADDR(&upipe->u.intr.datadma); 561 p[0] = 0; 562 if (UREAD2(sc, UHCI_PORTSC1) & (UHCI_PORTSC_CSC|UHCI_PORTSC_OCIC)) 563 p[0] |= 1<<1; 564 if (UREAD2(sc, UHCI_PORTSC2) & (UHCI_PORTSC_CSC|UHCI_PORTSC_OCIC)) 565 p[0] |= 1<<2; 566 s = splusb(); 567 if (!reqh->pipe->repeat) 568 SIMPLEQ_REMOVE_HEAD(&pipe->queue, reqh, next); 569 if (p[0] != 0) { 570 reqh->actlen = 1; 571 reqh->status = USBD_NORMAL_COMPLETION; 572 reqh->xfercb(reqh); 573 } 574 if (reqh->pipe->repeat) { 575 usb_timeout(uhci_timo, reqh, sc->sc_ival, reqh->timo_handle); 576 } else { 577 usb_freemem(sc->sc_dmatag, &upipe->u.intr.datadma); 578 usb_start_next(reqh->pipe); 579 } 580 splx(s); 581 } 582 583 584 void 585 uhci_lock_frames(sc) 586 uhci_softc_t *sc; 587 { 588 int s = splusb(); 589 while (sc->sc_vflock) { 590 sc->sc_vflock |= UHCI_WANT_LOCK; 591 tsleep(&sc->sc_vflock, PRIBIO, "uhcqhl", 0); 592 } 593 sc->sc_vflock = UHCI_HAS_LOCK; 594 splx(s); 595 } 596 597 void 598 uhci_unlock_frames(sc) 599 uhci_softc_t *sc; 600 { 601 int s = splusb(); 602 sc->sc_vflock &= ~UHCI_HAS_LOCK; 603 if (sc->sc_vflock & UHCI_WANT_LOCK) 604 wakeup(&sc->sc_vflock); 605 splx(s); 606 } 607 608 /* 609 * Allocate an interrupt information struct. A free list is kept 610 * for fast allocation. 611 */ 612 uhci_intr_info_t * 613 uhci_alloc_intr_info(sc) 614 uhci_softc_t *sc; 615 { 616 uhci_intr_info_t *ii; 617 618 ii = LIST_FIRST(&uhci_ii_free); 619 if (ii) 620 LIST_REMOVE(ii, list); 621 else { 622 ii = malloc(sizeof(uhci_intr_info_t), M_USBHC, M_NOWAIT); 623 } 624 ii->sc = sc; 625 return ii; 626 } 627 628 void 629 uhci_free_intr_info(ii) 630 uhci_intr_info_t *ii; 631 { 632 LIST_INSERT_HEAD(&uhci_ii_free, ii, list); /* and put on free list */ 633 } 634 635 /* Add control QH, called at splusb(). */ 636 void 637 uhci_add_ctrl(sc, sqh) 638 uhci_softc_t *sc; 639 uhci_soft_qh_t *sqh; 640 { 641 uhci_qh_t *eqh; 642 643 DPRINTFN(10, ("uhci_add_ctrl: sqh=%p\n", sqh)); 644 eqh = sc->sc_ctl_end->qh; 645 sqh->qh->hlink = eqh->hlink; 646 sqh->qh->qh_hlink = eqh->qh_hlink; 647 eqh->hlink = sqh; 648 eqh->qh_hlink = sqh->physaddr | UHCI_PTR_Q; 649 sc->sc_ctl_end = sqh; 650 } 651 652 /* Remove control QH, called at splusb(). */ 653 void 654 uhci_remove_ctrl(sc, sqh) 655 uhci_softc_t *sc; 656 uhci_soft_qh_t *sqh; 657 { 658 uhci_soft_qh_t *pqh; 659 660 DPRINTFN(10, ("uhci_remove_ctrl: sqh=%p\n", sqh)); 661 for (pqh = sc->sc_ctl_start; pqh->qh->hlink != sqh; pqh=pqh->qh->hlink) 662 #if defined(DIAGNOSTIC) || defined(USB_DEBUG) 663 if (pqh->qh->qh_hlink & UHCI_PTR_T) { 664 printf("uhci_remove_ctrl: QH not found\n"); 665 return; 666 } 667 #else 668 ; 669 #endif 670 pqh->qh->hlink = sqh->qh->hlink; 671 pqh->qh->qh_hlink = sqh->qh->qh_hlink; 672 if (sc->sc_ctl_end == sqh) 673 sc->sc_ctl_end = pqh; 674 } 675 676 /* Add bulk QH, called at splusb(). */ 677 void 678 uhci_add_bulk(sc, sqh) 679 uhci_softc_t *sc; 680 uhci_soft_qh_t *sqh; 681 { 682 uhci_qh_t *eqh; 683 684 DPRINTFN(10, ("uhci_add_bulk: sqh=%p\n", sqh)); 685 eqh = sc->sc_bulk_end->qh; 686 sqh->qh->hlink = eqh->hlink; 687 sqh->qh->qh_hlink = eqh->qh_hlink; 688 eqh->hlink = sqh; 689 eqh->qh_hlink = sqh->physaddr | UHCI_PTR_Q; 690 sc->sc_bulk_end = sqh; 691 } 692 693 /* Remove bulk QH, called at splusb(). */ 694 void 695 uhci_remove_bulk(sc, sqh) 696 uhci_softc_t *sc; 697 uhci_soft_qh_t *sqh; 698 { 699 uhci_soft_qh_t *pqh; 700 701 DPRINTFN(10, ("uhci_remove_bulk: sqh=%p\n", sqh)); 702 for (pqh = sc->sc_bulk_start; 703 pqh->qh->hlink != sqh; 704 pqh = pqh->qh->hlink) 705 #if defined(DIAGNOSTIC) || defined(USB_DEBUG) 706 if (pqh->qh->qh_hlink & UHCI_PTR_T) { 707 printf("uhci_remove_bulk: QH not found\n"); 708 return; 709 } 710 #else 711 ; 712 #endif 713 pqh->qh->hlink = sqh->qh->hlink; 714 pqh->qh->qh_hlink = sqh->qh->qh_hlink; 715 if (sc->sc_bulk_end == sqh) 716 sc->sc_bulk_end = pqh; 717 } 718 719 int 720 uhci_intr(p) 721 void *p; 722 { 723 uhci_softc_t *sc = p; 724 int status, ret; 725 uhci_intr_info_t *ii; 726 727 sc->sc_intrs++; 728 #if defined(USB_DEBUG) 729 if (uhcidebug > 9) { 730 printf("uhci_intr %p\n", sc); 731 uhci_dumpregs(sc); 732 } 733 #endif 734 status = UREAD2(sc, UHCI_STS); 735 #if defined(DIAGNOSTIC) && !defined(__OpenBSD__) 736 if (sc->sc_suspend != PWR_RESUME) 737 printf("uhci_intr: suspended sts=0x%x\n", status); 738 #endif 739 ret = 0; 740 if (status & UHCI_STS_USBINT) { 741 UWRITE2(sc, UHCI_STS, UHCI_STS_USBINT); /* acknowledge */ 742 ret = 1; 743 } 744 if (status & UHCI_STS_USBEI) { 745 UWRITE2(sc, UHCI_STS, UHCI_STS_USBEI); /* acknowledge */ 746 ret = 1; 747 } 748 if (status & UHCI_STS_RD) { 749 UWRITE2(sc, UHCI_STS, UHCI_STS_RD); /* acknowledge */ 750 printf("%s: resume detect\n", USBDEVNAME(sc->sc_bus.bdev)); 751 ret = 1; 752 } 753 if (status & UHCI_STS_HSE) { 754 UWRITE2(sc, UHCI_STS, UHCI_STS_HSE); /* acknowledge */ 755 printf("%s: Host System Error\n", USBDEVNAME(sc->sc_bus.bdev)); 756 ret = 1; 757 } 758 if (status & UHCI_STS_HCPE) { 759 UWRITE2(sc, UHCI_STS, UHCI_STS_HCPE); /* acknowledge */ 760 printf("%s: Host System Error\n", USBDEVNAME(sc->sc_bus.bdev)); 761 ret = 1; 762 } 763 if (status & UHCI_STS_HCH) 764 printf("%s: controller halted\n", USBDEVNAME(sc->sc_bus.bdev)); 765 if (!ret) 766 return 0; 767 768 /* 769 * Interrupts on UHCI really suck. When the host controller 770 * interrupts because a transfer is completed there is no 771 * way of knowing which transfer it was. You can scan down 772 * the TDs and QHs of the previous frame to limit the search, 773 * but that assumes that the interrupt was not delayed by more 774 * than 1 ms, which may not always be true (e.g. after debug 775 * output on a slow console). 776 * We scan all interrupt descriptors to see if any have 777 * completed. 778 */ 779 for (ii = LIST_FIRST(&sc->sc_intrhead); ii; ii = LIST_NEXT(ii, list)) 780 uhci_check_intr(sc, ii); 781 782 DPRINTFN(10, ("uhci_intr: exit\n")); 783 return 1; 784 } 785 786 /* Check for an interrupt. */ 787 void 788 uhci_check_intr(sc, ii) 789 uhci_softc_t *sc; 790 uhci_intr_info_t *ii; 791 { 792 struct uhci_pipe *upipe; 793 uhci_soft_td_t *std, *lstd; 794 u_int32_t status; 795 796 DPRINTFN(15, ("uhci_check_intr: ii=%p\n", ii)); 797 #ifdef DIAGNOSTIC 798 if (!ii) { 799 printf("uhci_check_intr: no ii? %p\n", ii); 800 return; 801 } 802 #endif 803 if (!ii->stdstart) 804 return; 805 lstd = ii->stdend; 806 #ifdef DIAGNOSTIC 807 if (!lstd) { 808 printf("uhci_check_intr: std==0\n"); 809 return; 810 } 811 #endif 812 /* 813 * If the last TD is still active we need to check whether there 814 * is a an error somewhere in the middle, or whether there was a 815 * short packet (SPD and not ACTIVE). 816 */ 817 if (lstd->td->td_status & UHCI_TD_ACTIVE) { 818 DPRINTFN(15, ("uhci_check_intr: active ii=%p\n", ii)); 819 for (std = ii->stdstart; std != lstd; std = std->td->link.std){ 820 status = std->td->td_status; 821 if ((status & UHCI_TD_STALLED) || 822 (status & (UHCI_TD_SPD | UHCI_TD_ACTIVE)) == 823 UHCI_TD_SPD) 824 goto done; 825 } 826 DPRINTFN(15, ("uhci_check_intr: ii=%p std=%p still active\n", 827 ii, ii->stdstart)); 828 return; 829 } 830 done: 831 usb_untimeout(uhci_timeout, ii, ii->timeout_handle); 832 upipe = (struct uhci_pipe *)ii->reqh->pipe; 833 uhci_idone(ii); 834 } 835 836 void 837 uhci_idone(ii) 838 uhci_intr_info_t *ii; 839 { 840 usbd_request_handle reqh = ii->reqh; 841 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 842 uhci_soft_td_t *std; 843 u_int32_t status; 844 int actlen; 845 846 #ifdef USB_DEBUG 847 DPRINTFN(10, ("uhci_idone: ii=%p ready\n", ii)); 848 if (uhcidebug > 10) 849 uhci_dump_tds(ii->stdstart); 850 #endif 851 852 if (reqh->status == USBD_CANCELLED || 853 reqh->status == USBD_TIMEOUT) { 854 DPRINTF(("uhci_idone: aborted reqh=%p\n", reqh)); 855 return; 856 } 857 858 #ifdef DIAGNOSTIC 859 { 860 int s = splhigh(); 861 if (ii->isdone) { 862 splx(s); 863 printf("uhci_idone: ii=%p is done!\n", ii); 864 return; 865 } 866 ii->isdone = 1; 867 splx(s); 868 } 869 #endif 870 871 /* The transfer is done, compute actual length and status. */ 872 /* XXX Is this correct for control xfers? */ 873 actlen = 0; 874 for (std = ii->stdstart; std; std = std->td->link.std) { 875 status = std->td->td_status; 876 if (status & UHCI_TD_ACTIVE) 877 break; 878 if (UHCI_TD_GET_PID(std->td->td_token) != UHCI_TD_PID_SETUP) 879 actlen += UHCI_TD_GET_ACTLEN(status); 880 } 881 /* If there are left over TDs we need to update the toggle. */ 882 if (std) 883 upipe->nexttoggle = UHCI_TD_GET_DT(std->td->td_token); 884 885 status &= UHCI_TD_ERROR; 886 DPRINTFN(10, ("uhci_check_intr: actlen=%d, status=0x%x\n", 887 actlen, status)); 888 reqh->actlen = actlen; 889 if (status != 0) { 890 DPRINTFN(-1+((status&UHCI_TD_STALLED)!=0), 891 ("uhci_idone: error, addr=%d, endpt=0x%02x, " 892 "status 0x%b\n", 893 reqh->pipe->device->address, 894 reqh->pipe->endpoint->edesc->bEndpointAddress, 895 (int)status, 896 "\20\22BITSTUFF\23CRCTO\24NAK\25BABBLE\26DBUFFER\27" 897 "STALLED\30ACTIVE")); 898 if (status == UHCI_TD_STALLED) 899 reqh->status = USBD_STALLED; 900 else 901 reqh->status = USBD_IOERROR; /* more info XXX */ 902 } else { 903 reqh->status = USBD_NORMAL_COMPLETION; 904 } 905 906 uhci_done(ii); 907 if (ii->reqh->pipe->intrreqh != ii->reqh) 908 usb_start_next(ii->reqh->pipe); 909 } 910 911 void 912 uhci_done(ii) 913 uhci_intr_info_t *ii; 914 { 915 usbd_request_handle reqh = ii->reqh; 916 usbd_pipe_handle pipe = reqh->pipe; 917 918 DPRINTFN(5, ("uhci_ii_finish: calling handler ii=%p\n", ii)); 919 920 switch (pipe->endpoint->edesc->bmAttributes & UE_XFERTYPE) { 921 case UE_CONTROL: 922 uhci_ctrl_done(ii); 923 break; 924 case UE_ISOCHRONOUS: 925 uhci_isoc_done(ii); 926 break; 927 case UE_BULK: 928 uhci_bulk_done(ii); 929 break; 930 case UE_INTERRUPT: 931 uhci_intr_done(ii); 932 break; 933 } 934 935 /* Remove request from queue. */ 936 SIMPLEQ_REMOVE_HEAD(&pipe->queue, reqh, next); 937 938 /* And finally execute callback. */ 939 reqh->xfercb(reqh); 940 } 941 942 /* 943 * Called when a request does not complete. 944 */ 945 void 946 uhci_timeout(addr) 947 void *addr; 948 { 949 uhci_intr_info_t *ii = addr; 950 951 DPRINTF(("uhci_timeout: ii=%p\n", ii)); 952 uhci_abort_req(ii->reqh, USBD_TIMEOUT); 953 } 954 955 /* 956 * Wait here until controller claims to have an interrupt. 957 * Then call uhci_intr and return. Use timeout to avoid waiting 958 * too long. 959 * Only used during boot when interrupts are not enabled yet. 960 */ 961 void 962 uhci_waitintr(sc, reqh) 963 uhci_softc_t *sc; 964 usbd_request_handle reqh; 965 { 966 int timo = reqh->timeout; 967 uhci_intr_info_t *ii; 968 969 DPRINTFN(10,("uhci_waitintr: timeout = %dms\n", timo)); 970 971 reqh->status = USBD_IN_PROGRESS; 972 for (; timo >= 0; timo--) { 973 usb_delay_ms(&sc->sc_bus, 1); 974 DPRINTFN(20,("uhci_waitintr: 0x%04x\n", UREAD2(sc, UHCI_STS))); 975 if (UREAD2(sc, UHCI_STS) & UHCI_STS_USBINT) { 976 uhci_intr(sc); 977 if (reqh->status != USBD_IN_PROGRESS) 978 return; 979 } 980 } 981 982 /* Timeout */ 983 DPRINTF(("uhci_waitintr: timeout\n")); 984 for (ii = LIST_FIRST(&sc->sc_intrhead); 985 ii && ii->reqh != reqh; 986 ii = LIST_NEXT(ii, list)) 987 ; 988 if (ii) 989 uhci_idone(ii); 990 else 991 panic("uhci_waitintr: lost intr_info\n"); 992 } 993 994 void 995 uhci_poll(bus) 996 struct usbd_bus *bus; 997 { 998 uhci_softc_t *sc = (uhci_softc_t *)bus; 999 1000 if (UREAD2(sc, UHCI_STS) & UHCI_STS_USBINT) 1001 uhci_intr(sc); 1002 } 1003 1004 #if 0 1005 void 1006 uhci_reset(p) 1007 void *p; 1008 { 1009 uhci_softc_t *sc = p; 1010 int n; 1011 1012 UHCICMD(sc, UHCI_CMD_HCRESET); 1013 /* The reset bit goes low when the controller is done. */ 1014 for (n = 0; n < UHCI_RESET_TIMEOUT && 1015 (UREAD2(sc, UHCI_CMD) & UHCI_CMD_HCRESET); n++) 1016 delay(100); 1017 if (n >= UHCI_RESET_TIMEOUT) 1018 printf("%s: controller did not reset\n", 1019 USBDEVNAME(sc->sc_bus.bdev)); 1020 } 1021 #endif 1022 1023 usbd_status 1024 uhci_run(sc, run) 1025 uhci_softc_t *sc; 1026 int run; 1027 { 1028 int s, n, running; 1029 1030 run = run != 0; 1031 s = splusb(); 1032 DPRINTF(("uhci_run: setting run=%d\n", run)); 1033 UHCICMD(sc, run ? UHCI_CMD_RS : 0); 1034 for(n = 0; n < 10; n++) { 1035 running = !(UREAD2(sc, UHCI_STS) & UHCI_STS_HCH); 1036 /* return when we've entered the state we want */ 1037 if (run == running) { 1038 splx(s); 1039 DPRINTF(("uhci_run: done cmd=0x%x sts=0x%x\n", 1040 UREAD2(sc, UHCI_CMD), UREAD2(sc, UHCI_STS))); 1041 return (USBD_NORMAL_COMPLETION); 1042 } 1043 usb_delay_ms(&sc->sc_bus, 1); 1044 } 1045 splx(s); 1046 printf("%s: cannot %s\n", USBDEVNAME(sc->sc_bus.bdev), 1047 run ? "start" : "stop"); 1048 return (USBD_IOERROR); 1049 } 1050 1051 /* 1052 * Memory management routines. 1053 * uhci_alloc_std allocates TDs 1054 * uhci_alloc_sqh allocates QHs 1055 * These two routines do their own free list management, 1056 * partly for speed, partly because allocating DMAable memory 1057 * has page size granularaity so much memory would be wasted if 1058 * only one TD/QH (32 bytes) was placed in each allocated chunk. 1059 */ 1060 1061 uhci_soft_td_t * 1062 uhci_alloc_std(sc) 1063 uhci_softc_t *sc; 1064 { 1065 uhci_soft_td_t *std; 1066 usbd_status r; 1067 int i; 1068 usb_dma_t dma; 1069 1070 if (!sc->sc_freetds) { 1071 DPRINTFN(2,("uhci_alloc_std: allocating chunk\n")); 1072 std = malloc(sizeof(uhci_soft_td_t) * UHCI_TD_CHUNK, 1073 M_USBHC, M_NOWAIT); 1074 if (!std) 1075 return (0); 1076 r = usb_allocmem(sc->sc_dmatag, UHCI_TD_SIZE * UHCI_TD_CHUNK, 1077 UHCI_TD_ALIGN, &dma); 1078 if (r != USBD_NORMAL_COMPLETION) { 1079 free(std, M_USBHC); 1080 return (0); 1081 } 1082 for(i = 0; i < UHCI_TD_CHUNK; i++, std++) { 1083 std->physaddr = DMAADDR(&dma) + i * UHCI_TD_SIZE; 1084 std->td = (uhci_td_t *) 1085 ((char *)KERNADDR(&dma) + i * UHCI_TD_SIZE); 1086 std->td->link.std = sc->sc_freetds; 1087 sc->sc_freetds = std; 1088 } 1089 } 1090 std = sc->sc_freetds; 1091 sc->sc_freetds = std->td->link.std; 1092 memset(std->td, 0, UHCI_TD_SIZE); 1093 return std; 1094 } 1095 1096 void 1097 uhci_free_std(sc, std) 1098 uhci_softc_t *sc; 1099 uhci_soft_td_t *std; 1100 { 1101 #ifdef DIAGNOSTIC 1102 #define TD_IS_FREE 0x12345678 1103 if (std->td->td_token == TD_IS_FREE) { 1104 printf("uhci_free_std: freeing free TD %p\n", std); 1105 return; 1106 } 1107 std->td->td_token = TD_IS_FREE; 1108 #endif 1109 std->td->link.std = sc->sc_freetds; 1110 sc->sc_freetds = std; 1111 } 1112 1113 uhci_soft_qh_t * 1114 uhci_alloc_sqh(sc) 1115 uhci_softc_t *sc; 1116 { 1117 uhci_soft_qh_t *sqh; 1118 usbd_status r; 1119 int i, offs; 1120 usb_dma_t dma; 1121 1122 if (!sc->sc_freeqhs) { 1123 DPRINTFN(2, ("uhci_alloc_sqh: allocating chunk\n")); 1124 sqh = malloc(sizeof(uhci_soft_qh_t) * UHCI_QH_CHUNK, 1125 M_USBHC, M_NOWAIT); 1126 if (!sqh) 1127 return 0; 1128 r = usb_allocmem(sc->sc_dmatag, UHCI_QH_SIZE * UHCI_QH_CHUNK, 1129 UHCI_QH_ALIGN, &dma); 1130 if (r != USBD_NORMAL_COMPLETION) { 1131 free(sqh, M_USBHC); 1132 return 0; 1133 } 1134 for(i = 0; i < UHCI_QH_CHUNK; i++, sqh++) { 1135 offs = i * UHCI_QH_SIZE; 1136 sqh->physaddr = DMAADDR(&dma) + offs; 1137 sqh->qh = (uhci_qh_t *) 1138 ((char *)KERNADDR(&dma) + offs); 1139 sqh->qh->hlink = sc->sc_freeqhs; 1140 sc->sc_freeqhs = sqh; 1141 } 1142 } 1143 sqh = sc->sc_freeqhs; 1144 sc->sc_freeqhs = sqh->qh->hlink; 1145 memset(sqh->qh, 0, UHCI_QH_SIZE); 1146 return (sqh); 1147 } 1148 1149 void 1150 uhci_free_sqh(sc, sqh) 1151 uhci_softc_t *sc; 1152 uhci_soft_qh_t *sqh; 1153 { 1154 sqh->qh->hlink = sc->sc_freeqhs; 1155 sc->sc_freeqhs = sqh; 1156 } 1157 1158 #if 0 1159 /* 1160 * Enter a list of transfers onto a control queue. 1161 * Called at splusb() 1162 */ 1163 void 1164 uhci_enter_ctl_q(sc, sqh, ii) 1165 uhci_softc_t *sc; 1166 uhci_soft_qh_t *sqh; 1167 uhci_intr_info_t *ii; 1168 { 1169 DPRINTFN(5, ("uhci_enter_ctl_q: sqh=%p\n", sqh)); 1170 1171 } 1172 #endif 1173 1174 void 1175 uhci_free_std_chain(sc, std, stdend) 1176 uhci_softc_t *sc; 1177 uhci_soft_td_t *std; 1178 uhci_soft_td_t *stdend; 1179 { 1180 uhci_soft_td_t *p; 1181 1182 for (; std != stdend; std = p) { 1183 p = std->td->link.std; 1184 uhci_free_std(sc, std); 1185 } 1186 } 1187 1188 usbd_status 1189 uhci_alloc_std_chain(upipe, sc, len, rd, shortok, dma, sp, ep) 1190 struct uhci_pipe *upipe; 1191 uhci_softc_t *sc; 1192 int len, rd, shortok; 1193 usb_dma_t *dma; 1194 uhci_soft_td_t **sp, **ep; 1195 { 1196 uhci_soft_td_t *p, *lastp; 1197 uhci_physaddr_t lastlink; 1198 int i, ntd, l, tog, maxp; 1199 u_int32_t status; 1200 int addr = upipe->pipe.device->address; 1201 int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress; 1202 1203 DPRINTFN(8, ("uhci_alloc_std_chain: addr=%d endpt=%d len=%d ls=%d " 1204 "shortok=%d\n", addr, UE_GET_ADDR(endpt), len, 1205 upipe->pipe.device->lowspeed, shortok)); 1206 if (len == 0) { 1207 *sp = *ep = 0; 1208 DPRINTFN(-1,("uhci_alloc_std_chain: len=0\n")); 1209 return (USBD_NORMAL_COMPLETION); 1210 } 1211 maxp = UGETW(upipe->pipe.endpoint->edesc->wMaxPacketSize); 1212 if (maxp == 0) { 1213 printf("uhci_alloc_std_chain: maxp=0\n"); 1214 return (USBD_INVAL); 1215 } 1216 ntd = (len + maxp - 1) / maxp; 1217 tog = upipe->nexttoggle; 1218 if (ntd % 2 == 0) 1219 tog ^= 1; 1220 upipe->nexttoggle = tog ^ 1; 1221 lastp = 0; 1222 lastlink = UHCI_PTR_T; 1223 ntd--; 1224 status = UHCI_TD_ZERO_ACTLEN(UHCI_TD_SET_ERRCNT(3) | UHCI_TD_ACTIVE); 1225 if (upipe->pipe.device->lowspeed) 1226 status |= UHCI_TD_LS; 1227 if (shortok) 1228 status |= UHCI_TD_SPD; 1229 for (i = ntd; i >= 0; i--) { 1230 p = uhci_alloc_std(sc); 1231 if (!p) { 1232 uhci_free_std_chain(sc, lastp, 0); 1233 return (USBD_NOMEM); 1234 } 1235 p->td->link.std = lastp; 1236 p->td->td_link = lastlink; 1237 lastp = p; 1238 lastlink = p->physaddr; 1239 p->td->td_status = status; 1240 if (i == ntd) { 1241 /* last TD */ 1242 l = len % maxp; 1243 if (l == 0) l = maxp; 1244 *ep = p; 1245 } else 1246 l = maxp; 1247 p->td->td_token = 1248 rd ? UHCI_TD_IN (l, endpt, addr, tog) : 1249 UHCI_TD_OUT(l, endpt, addr, tog); 1250 p->td->td_buffer = DMAADDR(dma) + i * maxp; 1251 tog ^= 1; 1252 } 1253 *sp = lastp; 1254 DPRINTFN(10, ("uhci_alloc_std_chain: nexttog=%d\n", 1255 upipe->nexttoggle)); 1256 return (USBD_NORMAL_COMPLETION); 1257 } 1258 1259 void 1260 uhci_device_clear_toggle(pipe) 1261 usbd_pipe_handle pipe; 1262 { 1263 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1264 upipe->nexttoggle = 0; 1265 } 1266 1267 void 1268 uhci_noop(pipe) 1269 usbd_pipe_handle pipe; 1270 { 1271 } 1272 1273 usbd_status 1274 uhci_device_bulk_transfer(reqh) 1275 usbd_request_handle reqh; 1276 { 1277 int s; 1278 usbd_status r; 1279 1280 s = splusb(); 1281 r = usb_insert_transfer(reqh); 1282 splx(s); 1283 if (r != USBD_NORMAL_COMPLETION) 1284 return (r); 1285 else 1286 return (uhci_device_bulk_start(reqh)); 1287 } 1288 1289 usbd_status 1290 uhci_device_bulk_start(reqh) 1291 usbd_request_handle reqh; 1292 { 1293 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1294 usbd_device_handle dev = upipe->pipe.device; 1295 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1296 uhci_intr_info_t *ii = upipe->iinfo; 1297 uhci_soft_td_t *xfer, *xferend; 1298 uhci_soft_qh_t *sqh; 1299 usb_dma_t *dmap; 1300 usbd_status r; 1301 int len, isread; 1302 int s; 1303 1304 DPRINTFN(3, ("uhci_device_bulk_transfer: reqh=%p buf=%p len=%d " 1305 "flags=%d\n", 1306 reqh, reqh->buffer, reqh->length, reqh->flags)); 1307 1308 if (reqh->isreq) 1309 panic("uhci_device_bulk_transfer: a request\n"); 1310 1311 len = reqh->length; 1312 dmap = &upipe->u.bulk.datadma; 1313 isread = reqh->pipe->endpoint->edesc->bEndpointAddress & UE_IN; 1314 sqh = upipe->u.bulk.sqh; 1315 1316 upipe->u.bulk.isread = isread; 1317 upipe->u.bulk.length = len; 1318 1319 r = usb_allocmem(sc->sc_dmatag, len, 0, dmap); 1320 if (r != USBD_NORMAL_COMPLETION) 1321 goto ret1; 1322 r = uhci_alloc_std_chain(upipe, sc, len, isread, 1323 reqh->flags & USBD_SHORT_XFER_OK, 1324 dmap, &xfer, &xferend); 1325 if (r != USBD_NORMAL_COMPLETION) 1326 goto ret2; 1327 xferend->td->td_status |= UHCI_TD_IOC; 1328 1329 if (!isread && len != 0) 1330 memcpy(KERNADDR(dmap), reqh->buffer, len); 1331 1332 #ifdef USB_DEBUG 1333 if (uhcidebug > 8) { 1334 printf("uhci_device_bulk_transfer: xfer(1)\n"); 1335 uhci_dump_tds(xfer); 1336 } 1337 #endif 1338 1339 /* Set up interrupt info. */ 1340 ii->reqh = reqh; 1341 ii->stdstart = xfer; 1342 ii->stdend = xferend; 1343 #ifdef DIAGNOSTIC 1344 ii->isdone = 0; 1345 #endif 1346 1347 sqh->qh->elink = xfer; 1348 sqh->qh->qh_elink = xfer->physaddr; 1349 sqh->intr_info = ii; 1350 1351 s = splusb(); 1352 uhci_add_bulk(sc, sqh); 1353 LIST_INSERT_HEAD(&sc->sc_intrhead, ii, list); 1354 1355 if (reqh->timeout && !sc->sc_bus.use_polling) { 1356 usb_timeout(uhci_timeout, ii, 1357 MS_TO_TICKS(reqh->timeout), ii->timeout_handle); 1358 } 1359 splx(s); 1360 1361 #ifdef USB_DEBUG 1362 if (uhcidebug > 10) { 1363 printf("uhci_device_bulk_transfer: xfer(2)\n"); 1364 uhci_dump_tds(xfer); 1365 } 1366 #endif 1367 1368 if (sc->sc_bus.use_polling) 1369 uhci_waitintr(sc, reqh); 1370 1371 return (USBD_IN_PROGRESS); 1372 1373 ret2: 1374 if (len != 0) 1375 usb_freemem(sc->sc_dmatag, dmap); 1376 ret1: 1377 return (r); 1378 } 1379 1380 /* Abort a device bulk request. */ 1381 void 1382 uhci_device_bulk_abort(reqh) 1383 usbd_request_handle reqh; 1384 { 1385 DPRINTF(("uhci_device_bulk_abort:\n")); 1386 uhci_abort_req(reqh, USBD_CANCELLED); 1387 } 1388 1389 void 1390 uhci_abort_req(reqh, status) 1391 usbd_request_handle reqh; 1392 usbd_status status; 1393 { 1394 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1395 uhci_intr_info_t *ii = upipe->iinfo; 1396 uhci_soft_td_t *std; 1397 int s; 1398 1399 /* Make interrupt routine ignore it, */ 1400 reqh->status = USBD_CANCELLED; 1401 1402 /* make hardware ignore it, */ 1403 for (std = ii->stdstart; std != 0; std = std->td->link.std) 1404 std->td->td_status &= ~UHCI_TD_ACTIVE; 1405 /* make sure hardware has completed, */ 1406 usb_delay_ms(reqh->pipe->device->bus, 1); 1407 1408 /* and call final part of interrupt handler. */ 1409 s = splusb(); 1410 uhci_done(ii); 1411 splx(s); 1412 } 1413 1414 /* Close a device bulk pipe. */ 1415 void 1416 uhci_device_bulk_close(pipe) 1417 usbd_pipe_handle pipe; 1418 { 1419 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1420 usbd_device_handle dev = upipe->pipe.device; 1421 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1422 1423 uhci_free_sqh(sc, upipe->u.bulk.sqh); 1424 uhci_free_intr_info(upipe->iinfo); 1425 /* XXX free other resources */ 1426 } 1427 1428 usbd_status 1429 uhci_device_ctrl_transfer(reqh) 1430 usbd_request_handle reqh; 1431 { 1432 int s; 1433 usbd_status r; 1434 1435 s = splusb(); 1436 r = usb_insert_transfer(reqh); 1437 splx(s); 1438 if (r != USBD_NORMAL_COMPLETION) 1439 return (r); 1440 else 1441 return (uhci_device_ctrl_start(reqh)); 1442 } 1443 1444 usbd_status 1445 uhci_device_ctrl_start(reqh) 1446 usbd_request_handle reqh; 1447 { 1448 uhci_softc_t *sc = (uhci_softc_t *)reqh->pipe->device->bus; 1449 usbd_status r; 1450 1451 if (!reqh->isreq) 1452 panic("uhci_device_ctrl_transfer: not a request\n"); 1453 1454 r = uhci_device_request(reqh); 1455 if (r != USBD_NORMAL_COMPLETION) 1456 return (r); 1457 1458 if (sc->sc_bus.use_polling) 1459 uhci_waitintr(sc, reqh); 1460 return (USBD_IN_PROGRESS); 1461 } 1462 1463 usbd_status 1464 uhci_device_intr_transfer(reqh) 1465 usbd_request_handle reqh; 1466 { 1467 int s; 1468 usbd_status r; 1469 1470 s = splusb(); 1471 r = usb_insert_transfer(reqh); 1472 splx(s); 1473 if (r != USBD_NORMAL_COMPLETION) 1474 return (r); 1475 else 1476 return (uhci_device_intr_start(reqh)); 1477 } 1478 1479 usbd_status 1480 uhci_device_intr_start(reqh) 1481 usbd_request_handle reqh; 1482 { 1483 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1484 usbd_device_handle dev = upipe->pipe.device; 1485 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1486 uhci_intr_info_t *ii = upipe->iinfo; 1487 uhci_soft_td_t *xfer, *xferend; 1488 uhci_soft_qh_t *sqh; 1489 usb_dma_t *dmap; 1490 usbd_status r; 1491 int len, i; 1492 int s; 1493 1494 DPRINTFN(3, ("uhci_device_intr_transfer: reqh=%p buf=%p len=%d " 1495 "flags=%d\n", 1496 reqh, reqh->buffer, reqh->length, reqh->flags)); 1497 1498 if (reqh->isreq) 1499 panic("uhci_device_intr_transfer: a request\n"); 1500 1501 len = reqh->length; 1502 dmap = &upipe->u.intr.datadma; 1503 if (len == 0) 1504 return (USBD_INVAL); /* XXX should it be? */ 1505 1506 r = usb_allocmem(sc->sc_dmatag, len, 0, dmap); 1507 if (r != USBD_NORMAL_COMPLETION) 1508 goto ret1; 1509 r = uhci_alloc_std_chain(upipe, sc, len, 1, 1510 reqh->flags & USBD_SHORT_XFER_OK, 1511 dmap, &xfer, &xferend); 1512 if (r != USBD_NORMAL_COMPLETION) 1513 goto ret2; 1514 xferend->td->td_status |= UHCI_TD_IOC; 1515 1516 #ifdef USB_DEBUG 1517 if (uhcidebug > 10) { 1518 printf("uhci_device_intr_transfer: xfer(1)\n"); 1519 uhci_dump_tds(xfer); 1520 uhci_dump_qh(upipe->u.intr.qhs[0]); 1521 } 1522 #endif 1523 1524 s = splusb(); 1525 /* Set up interrupt info. */ 1526 ii->reqh = reqh; 1527 ii->stdstart = xfer; 1528 ii->stdend = xferend; 1529 #ifdef DIAGNOSTIC 1530 ii->isdone = 0; 1531 #endif 1532 1533 DPRINTFN(10,("uhci_device_intr_transfer: qhs[0]=%p\n", 1534 upipe->u.intr.qhs[0])); 1535 for (i = 0; i < upipe->u.intr.npoll; i++) { 1536 sqh = upipe->u.intr.qhs[i]; 1537 sqh->qh->elink = xfer; 1538 sqh->qh->qh_elink = xfer->physaddr; 1539 } 1540 splx(s); 1541 1542 #ifdef USB_DEBUG 1543 if (uhcidebug > 10) { 1544 printf("uhci_device_intr_transfer: xfer(2)\n"); 1545 uhci_dump_tds(xfer); 1546 uhci_dump_qh(upipe->u.intr.qhs[0]); 1547 } 1548 #endif 1549 1550 return (USBD_IN_PROGRESS); 1551 1552 ret2: 1553 if (len != 0) 1554 usb_freemem(sc->sc_dmatag, dmap); 1555 ret1: 1556 return (r); 1557 } 1558 1559 /* Abort a device control request. */ 1560 void 1561 uhci_device_ctrl_abort(reqh) 1562 usbd_request_handle reqh; 1563 { 1564 DPRINTF(("uhci_device_ctrl_abort:\n")); 1565 uhci_abort_req(reqh, USBD_CANCELLED); 1566 } 1567 1568 /* Close a device control pipe. */ 1569 void 1570 uhci_device_ctrl_close(pipe) 1571 usbd_pipe_handle pipe; 1572 { 1573 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1574 1575 uhci_free_intr_info(upipe->iinfo); 1576 /* XXX free other resources */ 1577 } 1578 1579 /* Abort a device interrupt request. */ 1580 void 1581 uhci_device_intr_abort(reqh) 1582 usbd_request_handle reqh; 1583 { 1584 DPRINTFN(1,("uhci_device_intr_abort: reqh=%p\n", reqh)); 1585 if (reqh->pipe->intrreqh == reqh) { 1586 DPRINTFN(1,("uhci_device_intr_abort: remove\n")); 1587 reqh->pipe->intrreqh = 0; 1588 } 1589 uhci_abort_req(reqh, USBD_CANCELLED); 1590 } 1591 1592 /* Close a device interrupt pipe. */ 1593 void 1594 uhci_device_intr_close(pipe) 1595 usbd_pipe_handle pipe; 1596 { 1597 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1598 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 1599 int i, s, npoll; 1600 1601 upipe->iinfo->stdstart = 0; /* inactive */ 1602 1603 /* Unlink descriptors from controller data structures. */ 1604 npoll = upipe->u.intr.npoll; 1605 uhci_lock_frames(sc); 1606 for (i = 0; i < npoll; i++) 1607 uhci_remove_intr(sc, upipe->u.intr.qhs[i]->pos, 1608 upipe->u.intr.qhs[i]); 1609 uhci_unlock_frames(sc); 1610 1611 /* 1612 * We now have to wait for any activity on the physical 1613 * descriptors to stop. 1614 */ 1615 usb_delay_ms(&sc->sc_bus, 2); 1616 1617 for(i = 0; i < npoll; i++) 1618 uhci_free_sqh(sc, upipe->u.intr.qhs[i]); 1619 free(upipe->u.intr.qhs, M_USBHC); 1620 1621 s = splusb(); 1622 LIST_REMOVE(upipe->iinfo, list); /* remove from active list */ 1623 splx(s); 1624 uhci_free_intr_info(upipe->iinfo); 1625 1626 /* XXX free other resources */ 1627 } 1628 1629 usbd_status 1630 uhci_device_request(reqh) 1631 usbd_request_handle reqh; 1632 { 1633 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1634 usb_device_request_t *req = &reqh->request; 1635 usbd_device_handle dev = upipe->pipe.device; 1636 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1637 int addr = dev->address; 1638 int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress; 1639 uhci_intr_info_t *ii = upipe->iinfo; 1640 uhci_soft_td_t *setup, *xfer, *stat, *next, *xferend; 1641 uhci_soft_qh_t *sqh; 1642 usb_dma_t *dmap; 1643 int len; 1644 u_int32_t ls; 1645 usbd_status r; 1646 int isread; 1647 int s; 1648 1649 DPRINTFN(3,("uhci_device_control type=0x%02x, request=0x%02x, " 1650 "wValue=0x%04x, wIndex=0x%04x len=%d, addr=%d, endpt=%d\n", 1651 req->bmRequestType, req->bRequest, UGETW(req->wValue), 1652 UGETW(req->wIndex), UGETW(req->wLength), 1653 addr, endpt)); 1654 1655 ls = dev->lowspeed ? UHCI_TD_LS : 0; 1656 isread = req->bmRequestType & UT_READ; 1657 len = UGETW(req->wLength); 1658 1659 setup = upipe->u.ctl.setup; 1660 stat = upipe->u.ctl.stat; 1661 sqh = upipe->u.ctl.sqh; 1662 dmap = &upipe->u.ctl.datadma; 1663 1664 /* Set up data transaction */ 1665 if (len != 0) { 1666 r = usb_allocmem(sc->sc_dmatag, len, 0, dmap); 1667 if (r != USBD_NORMAL_COMPLETION) 1668 goto ret1; 1669 upipe->nexttoggle = 1; 1670 r = uhci_alloc_std_chain(upipe, sc, len, isread, 1671 reqh->flags & USBD_SHORT_XFER_OK, 1672 dmap, &xfer, &xferend); 1673 if (r != USBD_NORMAL_COMPLETION) 1674 goto ret2; 1675 next = xfer; 1676 xferend->td->link.std = stat; 1677 xferend->td->td_link = stat->physaddr; 1678 } else { 1679 next = stat; 1680 } 1681 upipe->u.ctl.length = len; 1682 1683 memcpy(KERNADDR(&upipe->u.ctl.reqdma), req, sizeof *req); 1684 if (!isread && len != 0) 1685 memcpy(KERNADDR(dmap), reqh->buffer, len); 1686 1687 setup->td->link.std = next; 1688 setup->td->td_link = next->physaddr; 1689 setup->td->td_status = UHCI_TD_SET_ERRCNT(2) | ls | UHCI_TD_ACTIVE; 1690 setup->td->td_token = UHCI_TD_SETUP(sizeof *req, endpt, addr); 1691 setup->td->td_buffer = DMAADDR(&upipe->u.ctl.reqdma); 1692 1693 stat->td->link.std = 0; 1694 stat->td->td_link = UHCI_PTR_T; 1695 stat->td->td_status = UHCI_TD_SET_ERRCNT(2) | ls | 1696 UHCI_TD_ACTIVE | UHCI_TD_IOC; 1697 stat->td->td_token = 1698 isread ? UHCI_TD_OUT(0, endpt, addr, 1) : 1699 UHCI_TD_IN (0, endpt, addr, 1); 1700 stat->td->td_buffer = 0; 1701 1702 #ifdef USB_DEBUG 1703 if (uhcidebug > 20) { 1704 printf("uhci_device_request: setup\n"); 1705 uhci_dump_td(setup); 1706 printf("uhci_device_request: stat\n"); 1707 uhci_dump_td(stat); 1708 } 1709 #endif 1710 1711 /* Set up interrupt info. */ 1712 ii->reqh = reqh; 1713 ii->stdstart = setup; 1714 ii->stdend = stat; 1715 #ifdef DIAGNOSTIC 1716 ii->isdone = 0; 1717 #endif 1718 1719 sqh->qh->elink = setup; 1720 sqh->qh->qh_elink = setup->physaddr; 1721 sqh->intr_info = ii; 1722 1723 s = splusb(); 1724 uhci_add_ctrl(sc, sqh); 1725 LIST_INSERT_HEAD(&sc->sc_intrhead, ii, list); 1726 #ifdef USB_DEBUG 1727 if (uhcidebug > 12) { 1728 uhci_soft_td_t *std; 1729 uhci_soft_qh_t *xqh; 1730 uhci_soft_qh_t *sxqh; 1731 int maxqh = 0; 1732 uhci_physaddr_t link; 1733 printf("uhci_enter_ctl_q: follow from [0]\n"); 1734 for (std = sc->sc_vframes[0].htd, link = 0; 1735 (link & UHCI_PTR_Q) == 0; 1736 std = std->td->link.std) { 1737 link = std->td->td_link; 1738 uhci_dump_td(std); 1739 } 1740 for (sxqh = xqh = (uhci_soft_qh_t *)std; 1741 xqh; 1742 xqh = (maxqh++ == 5 || xqh->qh->hlink==sxqh || 1743 xqh->qh->hlink==xqh ? NULL : xqh->qh->hlink)) { 1744 uhci_dump_qh(xqh); 1745 uhci_dump_qh(sxqh); 1746 } 1747 printf("Enqueued QH:\n"); 1748 uhci_dump_qh(sqh); 1749 uhci_dump_tds(sqh->qh->elink); 1750 } 1751 #endif 1752 if (reqh->timeout && !sc->sc_bus.use_polling) { 1753 usb_timeout(uhci_timeout, ii, 1754 MS_TO_TICKS(reqh->timeout), ii->timeout_handle); 1755 } 1756 splx(s); 1757 1758 return (USBD_NORMAL_COMPLETION); 1759 1760 ret2: 1761 if (len != 0) 1762 usb_freemem(sc->sc_dmatag, dmap); 1763 ret1: 1764 return (r); 1765 } 1766 1767 usbd_status 1768 uhci_device_isoc_transfer(reqh) 1769 usbd_request_handle reqh; 1770 { 1771 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1772 #ifdef USB_DEBUG 1773 usbd_device_handle dev = upipe->pipe.device; 1774 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1775 #endif 1776 1777 DPRINTFN(1,("uhci_device_isoc_transfer: sc=%p\n", sc)); 1778 if (upipe->u.iso.bufsize == 0) 1779 return (USBD_INVAL); 1780 1781 /* XXX copy data */ 1782 return (USBD_XXX); 1783 } 1784 1785 usbd_status 1786 uhci_device_isoc_start(reqh) 1787 usbd_request_handle reqh; 1788 { 1789 return (USBD_XXX); 1790 } 1791 1792 void 1793 uhci_device_isoc_abort(reqh) 1794 usbd_request_handle reqh; 1795 { 1796 /* XXX Can't abort this. */ 1797 } 1798 1799 void 1800 uhci_device_isoc_close(pipe) 1801 usbd_pipe_handle pipe; 1802 { 1803 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1804 usbd_device_handle dev = upipe->pipe.device; 1805 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1806 struct iso *iso; 1807 int i; 1808 1809 /* 1810 * Make sure all TDs are marked as inactive. 1811 * Wait for completion. 1812 * Unschedule. 1813 * Deallocate. 1814 */ 1815 iso = &upipe->u.iso; 1816 1817 for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) 1818 iso->stds[i]->td->td_status &= ~UHCI_TD_ACTIVE; 1819 usb_delay_ms(&sc->sc_bus, 2); /* wait for completion */ 1820 1821 uhci_lock_frames(sc); 1822 for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) { 1823 uhci_soft_td_t *std, *vstd; 1824 1825 std = iso->stds[i]; 1826 for (vstd = sc->sc_vframes[i % UHCI_VFRAMELIST_COUNT].htd; 1827 vstd && vstd->td->link.std != std; 1828 vstd = vstd->td->link.std) 1829 ; 1830 if (!vstd) { 1831 /*panic*/ 1832 printf("uhci_device_isoc_close: %p not found\n", std); 1833 uhci_unlock_frames(sc); 1834 return; 1835 } 1836 vstd->td->link = std->td->link; 1837 vstd->td->td_link = std->td->td_link; 1838 uhci_free_std(sc, std); 1839 } 1840 uhci_unlock_frames(sc); 1841 1842 for (i = 0; i < iso->nbuf; i++) 1843 usb_freemem(sc->sc_dmatag, &iso->bufs[i]); 1844 free(iso->stds, M_USBHC); 1845 free(iso->bufs, M_USBHC); 1846 1847 /* XXX what else? */ 1848 } 1849 1850 usbd_status 1851 uhci_device_isoc_setbuf(pipe, bufsize, nbuf) 1852 usbd_pipe_handle pipe; 1853 u_int bufsize; 1854 u_int nbuf; 1855 { 1856 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 1857 usbd_device_handle dev = upipe->pipe.device; 1858 uhci_softc_t *sc = (uhci_softc_t *)dev->bus; 1859 int addr = upipe->pipe.device->address; 1860 int endpt = upipe->pipe.endpoint->edesc->bEndpointAddress; 1861 int rd = upipe->pipe.endpoint->edesc->bEndpointAddress & UE_IN; 1862 struct iso *iso; 1863 int i; 1864 usbd_status r; 1865 1866 /* 1867 * For simplicity the number of buffers must fit nicely in the frame 1868 * list. 1869 */ 1870 if (UHCI_VFRAMELIST_COUNT % nbuf != 0) 1871 return (USBD_INVAL); 1872 1873 iso = &upipe->u.iso; 1874 iso->bufsize = bufsize; 1875 iso->nbuf = nbuf; 1876 1877 /* Allocate memory for buffers. */ 1878 iso->bufs = malloc(nbuf * sizeof(usb_dma_t), M_USBHC, M_WAITOK); 1879 iso->stds = malloc(UHCI_VFRAMELIST_COUNT * sizeof (uhci_soft_td_t *), 1880 M_USBHC, M_WAITOK); 1881 1882 for (i = 0; i < nbuf; i++) { 1883 r = usb_allocmem(sc->sc_dmatag, bufsize, 0, &iso->bufs[i]); 1884 if (r != USBD_NORMAL_COMPLETION) { 1885 nbuf = i; 1886 goto bad1; 1887 } 1888 } 1889 1890 /* Allocate the TDs. */ 1891 for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) { 1892 iso->stds[i] = uhci_alloc_std(sc); 1893 if (iso->stds[i] == 0) 1894 goto bad2; 1895 } 1896 1897 /* XXX check schedule */ 1898 1899 /* XXX interrupts */ 1900 1901 /* Insert TDs into schedule, all marked inactive. */ 1902 uhci_lock_frames(sc); 1903 for (i = 0; i < UHCI_VFRAMELIST_COUNT; i++) { 1904 uhci_soft_td_t *std, *vstd; 1905 1906 std = iso->stds[i]; 1907 std->td->td_status = UHCI_TD_IOS; /* iso, inactive */ 1908 std->td->td_token = 1909 rd ? UHCI_TD_IN (0, endpt, addr, 0) : 1910 UHCI_TD_OUT(0, endpt, addr, 0); 1911 std->td->td_buffer = DMAADDR(&iso->bufs[i % nbuf]); 1912 1913 vstd = sc->sc_vframes[i % UHCI_VFRAMELIST_COUNT].htd; 1914 std->td->link = vstd->td->link; 1915 std->td->td_link = vstd->td->td_link; 1916 vstd->td->link.std = std; 1917 vstd->td->td_link = std->physaddr; 1918 } 1919 uhci_unlock_frames(sc); 1920 1921 return (USBD_NORMAL_COMPLETION); 1922 1923 bad2: 1924 while (--i >= 0) 1925 uhci_free_std(sc, iso->stds[i]); 1926 bad1: 1927 for (i = 0; i < nbuf; i++) 1928 usb_freemem(sc->sc_dmatag, &iso->bufs[i]); 1929 free(iso->stds, M_USBHC); 1930 free(iso->bufs, M_USBHC); 1931 return (USBD_NOMEM); 1932 } 1933 1934 void 1935 uhci_isoc_done(ii) 1936 uhci_intr_info_t *ii; 1937 { 1938 } 1939 1940 void 1941 uhci_intr_done(ii) 1942 uhci_intr_info_t *ii; 1943 { 1944 uhci_softc_t *sc = ii->sc; 1945 usbd_request_handle reqh = ii->reqh; 1946 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 1947 usb_dma_t *dma; 1948 uhci_soft_qh_t *sqh; 1949 int i, npoll; 1950 1951 DPRINTFN(5, ("uhci_intr_done: length=%d\n", reqh->actlen)); 1952 1953 dma = &upipe->u.intr.datadma; 1954 memcpy(reqh->buffer, KERNADDR(dma), reqh->actlen); 1955 npoll = upipe->u.intr.npoll; 1956 for(i = 0; i < npoll; i++) { 1957 sqh = upipe->u.intr.qhs[i]; 1958 sqh->qh->elink = 0; 1959 sqh->qh->qh_elink = UHCI_PTR_T; 1960 } 1961 uhci_free_std_chain(sc, ii->stdstart, 0); 1962 1963 /* XXX Wasteful. */ 1964 if (reqh->pipe->repeat) { 1965 uhci_soft_td_t *xfer, *xferend; 1966 1967 /* This alloc cannot fail since we freed the chain above. */ 1968 uhci_alloc_std_chain(upipe, sc, reqh->length, 1, 1969 reqh->flags & USBD_SHORT_XFER_OK, 1970 dma, &xfer, &xferend); 1971 xferend->td->td_status |= UHCI_TD_IOC; 1972 1973 #ifdef USB_DEBUG 1974 if (uhcidebug > 10) { 1975 printf("uhci_device_intr_done: xfer(1)\n"); 1976 uhci_dump_tds(xfer); 1977 uhci_dump_qh(upipe->u.intr.qhs[0]); 1978 } 1979 #endif 1980 1981 ii->stdstart = xfer; 1982 ii->stdend = xferend; 1983 #ifdef DIAGNOSTIC 1984 ii->isdone = 0; 1985 #endif 1986 for (i = 0; i < npoll; i++) { 1987 sqh = upipe->u.intr.qhs[i]; 1988 sqh->qh->elink = xfer; 1989 sqh->qh->qh_elink = xfer->physaddr; 1990 } 1991 } else { 1992 usb_freemem(sc->sc_dmatag, dma); 1993 ii->stdstart = 0; /* mark as inactive */ 1994 } 1995 } 1996 1997 /* Deallocate request data structures */ 1998 void 1999 uhci_ctrl_done(ii) 2000 uhci_intr_info_t *ii; 2001 { 2002 uhci_softc_t *sc = ii->sc; 2003 usbd_request_handle reqh = ii->reqh; 2004 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 2005 u_int len = upipe->u.ctl.length; 2006 usb_dma_t *dma; 2007 uhci_td_t *htd = ii->stdstart->td; 2008 2009 #ifdef DIAGNOSTIC 2010 if (!reqh->isreq) 2011 panic("uhci_ctrl_done: not a request\n"); 2012 #endif 2013 2014 LIST_REMOVE(ii, list); /* remove from active list */ 2015 2016 uhci_remove_ctrl(sc, upipe->u.ctl.sqh); 2017 2018 if (len != 0) { 2019 dma = &upipe->u.ctl.datadma; 2020 if (reqh->request.bmRequestType & UT_READ) 2021 memcpy(reqh->buffer, KERNADDR(dma), len); 2022 uhci_free_std_chain(sc, htd->link.std, ii->stdend); 2023 usb_freemem(sc->sc_dmatag, dma); 2024 } 2025 DPRINTFN(5, ("uhci_ctrl_done: length=%d\n", reqh->actlen)); 2026 } 2027 2028 /* Deallocate request data structures */ 2029 void 2030 uhci_bulk_done(ii) 2031 uhci_intr_info_t *ii; 2032 { 2033 uhci_softc_t *sc = ii->sc; 2034 usbd_request_handle reqh = ii->reqh; 2035 struct uhci_pipe *upipe = (struct uhci_pipe *)reqh->pipe; 2036 u_int datalen = upipe->u.bulk.length; 2037 usb_dma_t *dma; 2038 2039 LIST_REMOVE(ii, list); /* remove from active list */ 2040 2041 uhci_remove_bulk(sc, upipe->u.bulk.sqh); 2042 2043 /* copy the data from dma memory to userland storage */ 2044 dma = &upipe->u.bulk.datadma; 2045 if (upipe->u.bulk.isread) 2046 memcpy(reqh->buffer, KERNADDR(dma), datalen); 2047 uhci_free_std_chain(sc, ii->stdstart, 0); 2048 usb_freemem(sc->sc_dmatag, dma); 2049 2050 DPRINTFN(4, ("uhci_bulk_done: length=%d\n", reqh->actlen)); 2051 } 2052 2053 /* Add interrupt QH, called with vflock. */ 2054 void 2055 uhci_add_intr(sc, n, sqh) 2056 uhci_softc_t *sc; 2057 int n; 2058 uhci_soft_qh_t *sqh; 2059 { 2060 struct uhci_vframe *vf = &sc->sc_vframes[n]; 2061 uhci_qh_t *eqh; 2062 2063 DPRINTFN(4, ("uhci_add_intr: n=%d sqh=%p\n", n, sqh)); 2064 eqh = vf->eqh->qh; 2065 sqh->qh->hlink = eqh->hlink; 2066 sqh->qh->qh_hlink = eqh->qh_hlink; 2067 eqh->hlink = sqh; 2068 eqh->qh_hlink = sqh->physaddr | UHCI_PTR_Q; 2069 vf->eqh = sqh; 2070 vf->bandwidth++; 2071 } 2072 2073 /* Remove interrupt QH, called with vflock. */ 2074 void 2075 uhci_remove_intr(sc, n, sqh) 2076 uhci_softc_t *sc; 2077 int n; 2078 uhci_soft_qh_t *sqh; 2079 { 2080 struct uhci_vframe *vf = &sc->sc_vframes[n]; 2081 uhci_soft_qh_t *pqh; 2082 2083 DPRINTFN(4, ("uhci_remove_intr: n=%d sqh=%p\n", n, sqh)); 2084 2085 for (pqh = vf->hqh; pqh->qh->hlink != sqh; pqh = pqh->qh->hlink) 2086 #if defined(DIAGNOSTIC) || defined(USB_DEBUG) 2087 if (pqh->qh->qh_hlink & UHCI_PTR_T) { 2088 printf("uhci_remove_intr: QH not found\n"); 2089 return; 2090 } 2091 #else 2092 ; 2093 #endif 2094 pqh->qh->hlink = sqh->qh->hlink; 2095 pqh->qh->qh_hlink = sqh->qh->qh_hlink; 2096 if (vf->eqh == sqh) 2097 vf->eqh = pqh; 2098 vf->bandwidth--; 2099 } 2100 2101 usbd_status 2102 uhci_device_setintr(sc, upipe, ival) 2103 uhci_softc_t *sc; 2104 struct uhci_pipe *upipe; 2105 int ival; 2106 { 2107 uhci_soft_qh_t *sqh; 2108 int i, npoll, s; 2109 u_int bestbw, bw, bestoffs, offs; 2110 2111 DPRINTFN(2, ("uhci_setintr: pipe=%p\n", upipe)); 2112 if (ival == 0) { 2113 printf("uhci_setintr: 0 interval\n"); 2114 return (USBD_INVAL); 2115 } 2116 2117 if (ival > UHCI_VFRAMELIST_COUNT) 2118 ival = UHCI_VFRAMELIST_COUNT; 2119 npoll = (UHCI_VFRAMELIST_COUNT + ival - 1) / ival; 2120 DPRINTFN(2, ("uhci_setintr: ival=%d npoll=%d\n", ival, npoll)); 2121 2122 upipe->u.intr.npoll = npoll; 2123 upipe->u.intr.qhs = 2124 malloc(npoll * sizeof(uhci_soft_qh_t *), M_USBHC, M_WAITOK); 2125 2126 /* 2127 * Figure out which offset in the schedule that has most 2128 * bandwidth left over. 2129 */ 2130 #define MOD(i) ((i) & (UHCI_VFRAMELIST_COUNT-1)) 2131 for (bestoffs = offs = 0, bestbw = ~0; offs < ival; offs++) { 2132 for (bw = i = 0; i < npoll; i++) 2133 bw += sc->sc_vframes[MOD(i * ival + offs)].bandwidth; 2134 if (bw < bestbw) { 2135 bestbw = bw; 2136 bestoffs = offs; 2137 } 2138 } 2139 DPRINTFN(1, ("uhci_setintr: bw=%d offs=%d\n", bestbw, bestoffs)); 2140 2141 upipe->iinfo->stdstart = 0; 2142 for(i = 0; i < npoll; i++) { 2143 upipe->u.intr.qhs[i] = sqh = uhci_alloc_sqh(sc); 2144 sqh->qh->elink = 0; 2145 sqh->qh->qh_elink = UHCI_PTR_T; 2146 sqh->pos = MOD(i * ival + bestoffs); 2147 sqh->intr_info = upipe->iinfo; 2148 } 2149 #undef MOD 2150 2151 s = splusb(); 2152 LIST_INSERT_HEAD(&sc->sc_intrhead, upipe->iinfo, list); 2153 splx(s); 2154 2155 uhci_lock_frames(sc); 2156 /* Enter QHs into the controller data structures. */ 2157 for(i = 0; i < npoll; i++) 2158 uhci_add_intr(sc, upipe->u.intr.qhs[i]->pos, 2159 upipe->u.intr.qhs[i]); 2160 uhci_unlock_frames(sc); 2161 2162 DPRINTFN(5, ("uhci_setintr: returns %p\n", upipe)); 2163 return (USBD_NORMAL_COMPLETION); 2164 } 2165 2166 /* Open a new pipe. */ 2167 usbd_status 2168 uhci_open(pipe) 2169 usbd_pipe_handle pipe; 2170 { 2171 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 2172 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 2173 usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc; 2174 usbd_status r; 2175 2176 DPRINTFN(1, ("uhci_open: pipe=%p, addr=%d, endpt=%d (%d)\n", 2177 pipe, pipe->device->address, 2178 ed->bEndpointAddress, sc->sc_addr)); 2179 if (pipe->device->address == sc->sc_addr) { 2180 switch (ed->bEndpointAddress) { 2181 case USB_CONTROL_ENDPOINT: 2182 pipe->methods = &uhci_root_ctrl_methods; 2183 break; 2184 case UE_IN | UHCI_INTR_ENDPT: 2185 pipe->methods = &uhci_root_intr_methods; 2186 break; 2187 default: 2188 return (USBD_INVAL); 2189 } 2190 } else { 2191 upipe->iinfo = uhci_alloc_intr_info(sc); 2192 if (upipe->iinfo == 0) 2193 return (USBD_NOMEM); 2194 switch (ed->bmAttributes & UE_XFERTYPE) { 2195 case UE_CONTROL: 2196 pipe->methods = &uhci_device_ctrl_methods; 2197 upipe->u.ctl.sqh = uhci_alloc_sqh(sc); 2198 if (upipe->u.ctl.sqh == 0) 2199 goto bad; 2200 upipe->u.ctl.setup = uhci_alloc_std(sc); 2201 if (upipe->u.ctl.setup == 0) { 2202 uhci_free_sqh(sc, upipe->u.ctl.sqh); 2203 goto bad; 2204 } 2205 upipe->u.ctl.stat = uhci_alloc_std(sc); 2206 if (upipe->u.ctl.stat == 0) { 2207 uhci_free_sqh(sc, upipe->u.ctl.sqh); 2208 uhci_free_std(sc, upipe->u.ctl.setup); 2209 goto bad; 2210 } 2211 r = usb_allocmem(sc->sc_dmatag, 2212 sizeof(usb_device_request_t), 2213 0, &upipe->u.ctl.reqdma); 2214 if (r != USBD_NORMAL_COMPLETION) { 2215 uhci_free_sqh(sc, upipe->u.ctl.sqh); 2216 uhci_free_std(sc, upipe->u.ctl.setup); 2217 uhci_free_std(sc, upipe->u.ctl.stat); 2218 goto bad; 2219 } 2220 break; 2221 case UE_INTERRUPT: 2222 pipe->methods = &uhci_device_intr_methods; 2223 return (uhci_device_setintr(sc, upipe, ed->bInterval)); 2224 case UE_ISOCHRONOUS: 2225 pipe->methods = &uhci_device_isoc_methods; 2226 upipe->u.iso.nbuf = 0; 2227 return (USBD_NORMAL_COMPLETION); 2228 case UE_BULK: 2229 pipe->methods = &uhci_device_bulk_methods; 2230 upipe->u.bulk.sqh = uhci_alloc_sqh(sc); 2231 if (upipe->u.bulk.sqh == 0) 2232 goto bad; 2233 break; 2234 } 2235 } 2236 return (USBD_NORMAL_COMPLETION); 2237 2238 bad: 2239 uhci_free_intr_info(upipe->iinfo); 2240 return (USBD_NOMEM); 2241 } 2242 2243 /* 2244 * Data structures and routines to emulate the root hub. 2245 */ 2246 usb_device_descriptor_t uhci_devd = { 2247 USB_DEVICE_DESCRIPTOR_SIZE, 2248 UDESC_DEVICE, /* type */ 2249 {0x00, 0x01}, /* USB version */ 2250 UCLASS_HUB, /* class */ 2251 USUBCLASS_HUB, /* subclass */ 2252 0, /* protocol */ 2253 64, /* max packet */ 2254 {0},{0},{0x00,0x01}, /* device id */ 2255 1,2,0, /* string indicies */ 2256 1 /* # of configurations */ 2257 }; 2258 2259 usb_config_descriptor_t uhci_confd = { 2260 USB_CONFIG_DESCRIPTOR_SIZE, 2261 UDESC_CONFIG, 2262 {USB_CONFIG_DESCRIPTOR_SIZE + 2263 USB_INTERFACE_DESCRIPTOR_SIZE + 2264 USB_ENDPOINT_DESCRIPTOR_SIZE}, 2265 1, 2266 1, 2267 0, 2268 UC_SELF_POWERED, 2269 0 /* max power */ 2270 }; 2271 2272 usb_interface_descriptor_t uhci_ifcd = { 2273 USB_INTERFACE_DESCRIPTOR_SIZE, 2274 UDESC_INTERFACE, 2275 0, 2276 0, 2277 1, 2278 UCLASS_HUB, 2279 USUBCLASS_HUB, 2280 0, 2281 0 2282 }; 2283 2284 usb_endpoint_descriptor_t uhci_endpd = { 2285 USB_ENDPOINT_DESCRIPTOR_SIZE, 2286 UDESC_ENDPOINT, 2287 UE_IN | UHCI_INTR_ENDPT, 2288 UE_INTERRUPT, 2289 {8}, 2290 255 2291 }; 2292 2293 usb_hub_descriptor_t uhci_hubd_piix = { 2294 USB_HUB_DESCRIPTOR_SIZE, 2295 UDESC_HUB, 2296 2, 2297 { UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL, 0 }, 2298 50, /* power on to power good */ 2299 0, 2300 { 0x00 }, /* both ports are removable */ 2301 }; 2302 2303 int 2304 uhci_str(p, l, s) 2305 usb_string_descriptor_t *p; 2306 int l; 2307 char *s; 2308 { 2309 int i; 2310 2311 if (l == 0) 2312 return (0); 2313 p->bLength = 2 * strlen(s) + 2; 2314 if (l == 1) 2315 return (1); 2316 p->bDescriptorType = UDESC_STRING; 2317 l -= 2; 2318 for (i = 0; s[i] && l > 1; i++, l -= 2) 2319 USETW2(p->bString[i], 0, s[i]); 2320 return (2*i+2); 2321 } 2322 2323 /* 2324 * Simulate a hardware hub by handling all the necessary requests. 2325 */ 2326 usbd_status 2327 uhci_root_ctrl_transfer(reqh) 2328 usbd_request_handle reqh; 2329 { 2330 int s; 2331 usbd_status r; 2332 2333 s = splusb(); 2334 r = usb_insert_transfer(reqh); 2335 splx(s); 2336 if (r != USBD_NORMAL_COMPLETION) 2337 return (r); 2338 else 2339 return (uhci_root_ctrl_start(reqh)); 2340 } 2341 2342 usbd_status 2343 uhci_root_ctrl_start(reqh) 2344 usbd_request_handle reqh; 2345 { 2346 uhci_softc_t *sc = (uhci_softc_t *)reqh->pipe->device->bus; 2347 usb_device_request_t *req; 2348 void *buf; 2349 int port, x; 2350 int len, value, index, status, change, l, totlen = 0; 2351 usb_port_status_t ps; 2352 usbd_status r; 2353 2354 if (!reqh->isreq) 2355 panic("uhci_root_ctrl_transfer: not a request\n"); 2356 req = &reqh->request; 2357 buf = reqh->buffer; 2358 2359 DPRINTFN(2,("uhci_root_ctrl_control type=0x%02x request=%02x\n", 2360 req->bmRequestType, req->bRequest)); 2361 2362 len = UGETW(req->wLength); 2363 value = UGETW(req->wValue); 2364 index = UGETW(req->wIndex); 2365 #define C(x,y) ((x) | ((y) << 8)) 2366 switch(C(req->bRequest, req->bmRequestType)) { 2367 case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): 2368 case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): 2369 case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): 2370 /* 2371 * DEVICE_REMOTE_WAKEUP and ENDPOINT_HALT are no-ops 2372 * for the integrated root hub. 2373 */ 2374 break; 2375 case C(UR_GET_CONFIG, UT_READ_DEVICE): 2376 if (len > 0) { 2377 *(u_int8_t *)buf = sc->sc_conf; 2378 totlen = 1; 2379 } 2380 break; 2381 case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): 2382 DPRINTFN(2,("uhci_root_ctrl_control wValue=0x%04x\n", value)); 2383 switch(value >> 8) { 2384 case UDESC_DEVICE: 2385 if ((value & 0xff) != 0) { 2386 r = USBD_IOERROR; 2387 goto ret; 2388 } 2389 totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE); 2390 USETW(uhci_devd.idVendor, sc->sc_id_vendor); 2391 memcpy(buf, &uhci_devd, l); 2392 break; 2393 case UDESC_CONFIG: 2394 if ((value & 0xff) != 0) { 2395 r = USBD_IOERROR; 2396 goto ret; 2397 } 2398 totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE); 2399 memcpy(buf, &uhci_confd, l); 2400 buf = (char *)buf + l; 2401 len -= l; 2402 l = min(len, USB_INTERFACE_DESCRIPTOR_SIZE); 2403 totlen += l; 2404 memcpy(buf, &uhci_ifcd, l); 2405 buf = (char *)buf + l; 2406 len -= l; 2407 l = min(len, USB_ENDPOINT_DESCRIPTOR_SIZE); 2408 totlen += l; 2409 memcpy(buf, &uhci_endpd, l); 2410 break; 2411 case UDESC_STRING: 2412 if (len == 0) 2413 break; 2414 *(u_int8_t *)buf = 0; 2415 totlen = 1; 2416 switch (value & 0xff) { 2417 case 1: /* Vendor */ 2418 totlen = uhci_str(buf, len, sc->sc_vendor); 2419 break; 2420 case 2: /* Product */ 2421 totlen = uhci_str(buf, len, "UHCI root hub"); 2422 break; 2423 } 2424 break; 2425 default: 2426 r = USBD_IOERROR; 2427 goto ret; 2428 } 2429 break; 2430 case C(UR_GET_INTERFACE, UT_READ_INTERFACE): 2431 if (len > 0) { 2432 *(u_int8_t *)buf = 0; 2433 totlen = 1; 2434 } 2435 break; 2436 case C(UR_GET_STATUS, UT_READ_DEVICE): 2437 if (len > 1) { 2438 USETW(((usb_status_t *)buf)->wStatus,UDS_SELF_POWERED); 2439 totlen = 2; 2440 } 2441 break; 2442 case C(UR_GET_STATUS, UT_READ_INTERFACE): 2443 case C(UR_GET_STATUS, UT_READ_ENDPOINT): 2444 if (len > 1) { 2445 USETW(((usb_status_t *)buf)->wStatus, 0); 2446 totlen = 2; 2447 } 2448 break; 2449 case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): 2450 if (value >= USB_MAX_DEVICES) { 2451 r = USBD_IOERROR; 2452 goto ret; 2453 } 2454 sc->sc_addr = value; 2455 break; 2456 case C(UR_SET_CONFIG, UT_WRITE_DEVICE): 2457 if (value != 0 && value != 1) { 2458 r = USBD_IOERROR; 2459 goto ret; 2460 } 2461 sc->sc_conf = value; 2462 break; 2463 case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): 2464 break; 2465 case C(UR_SET_FEATURE, UT_WRITE_DEVICE): 2466 case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): 2467 case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): 2468 r = USBD_IOERROR; 2469 goto ret; 2470 case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): 2471 break; 2472 case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): 2473 break; 2474 /* Hub requests */ 2475 case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): 2476 break; 2477 case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): 2478 DPRINTFN(3, ("uhci_root_ctrl_control: UR_CLEAR_PORT_FEATURE " 2479 "port=%d feature=%d\n", 2480 index, value)); 2481 if (index == 1) 2482 port = UHCI_PORTSC1; 2483 else if (index == 2) 2484 port = UHCI_PORTSC2; 2485 else { 2486 r = USBD_IOERROR; 2487 goto ret; 2488 } 2489 switch(value) { 2490 case UHF_PORT_ENABLE: 2491 x = UREAD2(sc, port); 2492 UWRITE2(sc, port, x & ~UHCI_PORTSC_PE); 2493 break; 2494 case UHF_PORT_SUSPEND: 2495 x = UREAD2(sc, port); 2496 UWRITE2(sc, port, x & ~UHCI_PORTSC_SUSP); 2497 break; 2498 case UHF_PORT_RESET: 2499 x = UREAD2(sc, port); 2500 UWRITE2(sc, port, x & ~UHCI_PORTSC_PR); 2501 break; 2502 case UHF_C_PORT_CONNECTION: 2503 x = UREAD2(sc, port); 2504 UWRITE2(sc, port, x | UHCI_PORTSC_CSC); 2505 break; 2506 case UHF_C_PORT_ENABLE: 2507 x = UREAD2(sc, port); 2508 UWRITE2(sc, port, x | UHCI_PORTSC_POEDC); 2509 break; 2510 case UHF_C_PORT_OVER_CURRENT: 2511 x = UREAD2(sc, port); 2512 UWRITE2(sc, port, x | UHCI_PORTSC_OCIC); 2513 break; 2514 case UHF_C_PORT_RESET: 2515 sc->sc_isreset = 0; 2516 r = USBD_NORMAL_COMPLETION; 2517 goto ret; 2518 case UHF_PORT_CONNECTION: 2519 case UHF_PORT_OVER_CURRENT: 2520 case UHF_PORT_POWER: 2521 case UHF_PORT_LOW_SPEED: 2522 case UHF_C_PORT_SUSPEND: 2523 default: 2524 r = USBD_IOERROR; 2525 goto ret; 2526 } 2527 break; 2528 case C(UR_GET_BUS_STATE, UT_READ_CLASS_OTHER): 2529 if (index == 1) 2530 port = UHCI_PORTSC1; 2531 else if (index == 2) 2532 port = UHCI_PORTSC2; 2533 else { 2534 r = USBD_IOERROR; 2535 goto ret; 2536 } 2537 if (len > 0) { 2538 *(u_int8_t *)buf = 2539 (UREAD2(sc, port) & UHCI_PORTSC_LS) >> 2540 UHCI_PORTSC_LS_SHIFT; 2541 totlen = 1; 2542 } 2543 break; 2544 case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): 2545 if (value != 0) { 2546 r = USBD_IOERROR; 2547 goto ret; 2548 } 2549 l = min(len, USB_HUB_DESCRIPTOR_SIZE); 2550 totlen = l; 2551 memcpy(buf, &uhci_hubd_piix, l); 2552 break; 2553 case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): 2554 if (len != 4) { 2555 r = USBD_IOERROR; 2556 goto ret; 2557 } 2558 memset(buf, 0, len); 2559 totlen = len; 2560 break; 2561 case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): 2562 if (index == 1) 2563 port = UHCI_PORTSC1; 2564 else if (index == 2) 2565 port = UHCI_PORTSC2; 2566 else { 2567 r = USBD_IOERROR; 2568 goto ret; 2569 } 2570 if (len != 4) { 2571 r = USBD_IOERROR; 2572 goto ret; 2573 } 2574 x = UREAD2(sc, port); 2575 status = change = 0; 2576 if (x & UHCI_PORTSC_CCS ) 2577 status |= UPS_CURRENT_CONNECT_STATUS; 2578 if (x & UHCI_PORTSC_CSC ) 2579 change |= UPS_C_CONNECT_STATUS; 2580 if (x & UHCI_PORTSC_PE ) 2581 status |= UPS_PORT_ENABLED; 2582 if (x & UHCI_PORTSC_POEDC) 2583 change |= UPS_C_PORT_ENABLED; 2584 if (x & UHCI_PORTSC_OCI ) 2585 status |= UPS_OVERCURRENT_INDICATOR; 2586 if (x & UHCI_PORTSC_OCIC ) 2587 change |= UPS_C_OVERCURRENT_INDICATOR; 2588 if (x & UHCI_PORTSC_SUSP ) 2589 status |= UPS_SUSPEND; 2590 if (x & UHCI_PORTSC_LSDA ) 2591 status |= UPS_LOW_SPEED; 2592 status |= UPS_PORT_POWER; 2593 if (sc->sc_isreset) 2594 change |= UPS_C_PORT_RESET; 2595 USETW(ps.wPortStatus, status); 2596 USETW(ps.wPortChange, change); 2597 l = min(len, sizeof ps); 2598 memcpy(buf, &ps, l); 2599 totlen = l; 2600 break; 2601 case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): 2602 r = USBD_IOERROR; 2603 goto ret; 2604 case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): 2605 break; 2606 case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): 2607 if (index == 1) 2608 port = UHCI_PORTSC1; 2609 else if (index == 2) 2610 port = UHCI_PORTSC2; 2611 else { 2612 r = USBD_IOERROR; 2613 goto ret; 2614 } 2615 switch(value) { 2616 case UHF_PORT_ENABLE: 2617 x = UREAD2(sc, port); 2618 UWRITE2(sc, port, x | UHCI_PORTSC_PE); 2619 break; 2620 case UHF_PORT_SUSPEND: 2621 x = UREAD2(sc, port); 2622 UWRITE2(sc, port, x | UHCI_PORTSC_SUSP); 2623 break; 2624 case UHF_PORT_RESET: 2625 x = UREAD2(sc, port); 2626 UWRITE2(sc, port, x | UHCI_PORTSC_PR); 2627 usb_delay_ms(&sc->sc_bus, 10); 2628 UWRITE2(sc, port, x & ~UHCI_PORTSC_PR); 2629 delay(100); 2630 x = UREAD2(sc, port); 2631 UWRITE2(sc, port, x | UHCI_PORTSC_PE); 2632 delay(100); 2633 DPRINTFN(3,("uhci port %d reset, status = 0x%04x\n", 2634 index, UREAD2(sc, port))); 2635 sc->sc_isreset = 1; 2636 break; 2637 case UHF_C_PORT_CONNECTION: 2638 case UHF_C_PORT_ENABLE: 2639 case UHF_C_PORT_OVER_CURRENT: 2640 case UHF_PORT_CONNECTION: 2641 case UHF_PORT_OVER_CURRENT: 2642 case UHF_PORT_POWER: 2643 case UHF_PORT_LOW_SPEED: 2644 case UHF_C_PORT_SUSPEND: 2645 case UHF_C_PORT_RESET: 2646 default: 2647 r = USBD_IOERROR; 2648 goto ret; 2649 } 2650 break; 2651 default: 2652 r = USBD_IOERROR; 2653 goto ret; 2654 } 2655 reqh->actlen = totlen; 2656 r = USBD_NORMAL_COMPLETION; 2657 ret: 2658 SIMPLEQ_REMOVE_HEAD(&reqh->pipe->queue, reqh, next); 2659 reqh->status = r; 2660 reqh->xfercb(reqh); 2661 usb_start_next(reqh->pipe); 2662 return (USBD_IN_PROGRESS); 2663 } 2664 2665 /* Abort a root control request. */ 2666 void 2667 uhci_root_ctrl_abort(reqh) 2668 usbd_request_handle reqh; 2669 { 2670 /* Nothing to do, all transfers are syncronous. */ 2671 } 2672 2673 /* Close the root pipe. */ 2674 void 2675 uhci_root_ctrl_close(pipe) 2676 usbd_pipe_handle pipe; 2677 { 2678 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 2679 2680 sc->sc_has_timo = 0; 2681 DPRINTF(("uhci_root_ctrl_close\n")); 2682 } 2683 2684 /* Abort a root interrupt request. */ 2685 void 2686 uhci_root_intr_abort(reqh) 2687 usbd_request_handle reqh; 2688 { 2689 uhci_softc_t *sc = (uhci_softc_t *)reqh->pipe->device->bus; 2690 2691 usb_untimeout(uhci_timo, reqh, reqh->timo_handle); 2692 sc->sc_has_timo = 0; 2693 } 2694 2695 usbd_status 2696 uhci_root_intr_transfer(reqh) 2697 usbd_request_handle reqh; 2698 { 2699 int s; 2700 usbd_status r; 2701 2702 s = splusb(); 2703 r = usb_insert_transfer(reqh); 2704 splx(s); 2705 if (r != USBD_NORMAL_COMPLETION) 2706 return (r); 2707 else 2708 return (uhci_root_intr_start(reqh)); 2709 } 2710 2711 /* Start a transfer on the root interrupt pipe */ 2712 usbd_status 2713 uhci_root_intr_start(reqh) 2714 usbd_request_handle reqh; 2715 { 2716 usbd_pipe_handle pipe = reqh->pipe; 2717 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 2718 struct uhci_pipe *upipe = (struct uhci_pipe *)pipe; 2719 usb_dma_t *dmap; 2720 usbd_status r; 2721 int len; 2722 2723 DPRINTFN(3, ("uhci_root_intr_transfer: reqh=%p buf=%p len=%d " 2724 "flags=%d\n", 2725 reqh, reqh->buffer, reqh->length, reqh->flags)); 2726 2727 len = reqh->length; 2728 dmap = &upipe->u.intr.datadma; 2729 if (len == 0) 2730 return (USBD_INVAL); /* XXX should it be? */ 2731 2732 r = usb_allocmem(sc->sc_dmatag, len, 0, dmap); 2733 if (r != USBD_NORMAL_COMPLETION) 2734 return (r); 2735 2736 sc->sc_ival = MS_TO_TICKS(reqh->pipe->endpoint->edesc->bInterval); 2737 usb_timeout(uhci_timo, reqh, sc->sc_ival, reqh->timo_handle); 2738 sc->sc_has_timo = reqh; 2739 return (USBD_IN_PROGRESS); 2740 } 2741 2742 /* Close the root interrupt pipe. */ 2743 void 2744 uhci_root_intr_close(pipe) 2745 usbd_pipe_handle pipe; 2746 { 2747 uhci_softc_t *sc = (uhci_softc_t *)pipe->device->bus; 2748 2749 usb_untimeout(uhci_timo, pipe->intrreqh, pipe->intrreqh->timo_handle); 2750 sc->sc_has_timo = 0; 2751 DPRINTF(("uhci_root_intr_close\n")); 2752 } 2753 2754
Indexes created Tue Sep 23 14:10:03 GMT 2025