diff -u usb.orig/ohci.c usb/ohci.c --- usb.orig/ohci.c Tue Sep 9 02:56:49 2003 +++ usb/ohci.c Tue Sep 9 03:05:42 2003 @@ -1020,7 +1020,7 @@ DPRINTF(("ohci_shutdown: stopping the HC\n")); OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); } - +#endif /* * Handle suspend/resume. * @@ -1028,6 +1028,141 @@ * called from an intterupt context. This is all right since we * are almost suspended anyway. */ +usbd_status +ohci_resume(struct ohci_softc *sc) +{ + int s; + u_int32_t ctl, ival, hcr, fm, per, rev, desca; + + DPRINTF(("ohci_resume: start\n")); +#if defined(__OpenBSD__) + printf(","); +#else + printf("%s:", USBDEVNAME(sc->sc_bus.bdev)); +#endif + rev = OREAD4(sc, OHCI_REVISION); + printf(" OHCI version %d.%d%s\n", OHCI_REV_HI(rev), OHCI_REV_LO(rev), + OHCI_REV_LEGACY(rev) ? ", legacy support" : ""); + printf("ohci_resume: controller state: "); + switch(OREAD4(sc, OHCI_CONTROL) & OHCI_HCFS_MASK) { + case OHCI_HCFS_SUSPEND: + printf("SUSPEND"); + break; + case OHCI_HCFS_RESUME: + printf("RESUME"); + break; + case OHCI_HCFS_RESET: + printf("RESET"); + break; + case OHCI_HCFS_OPERATIONAL: + printf("OPERATIONAL"); + break; + } + printf("\n"); + s = splhardusb(); + /* The controller only responds to resume or reset writes at this point, so lets resume */ + /* We are only supposed to enter resume state from a suspend state. Should we check? */ + OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESUME); + usb_delay_ms(&sc->sc_bus, USB_RESUME_DELAY); + /* check if the controller has resumed */ + ctl = OREAD4(sc, OHCI_CONTROL); + if((ctl & OHCI_HCFS_RESUME) == OHCI_HCFS_RESUME) { + printf("ohci_resume: Controller resumed.\n"); + } else { + /* panic or abort? */ + printf("ohci_resume: ??? Controller not resumeded!\n"); + printf("ohci_resume: OHCI_CONTROL: 0x%x\n",ctl); + } + +#ifdef USB_DEBUG + ohci_dumpregs(sc); +#endif + + /* reset or controller may not start */ + OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); + usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); + + /* spec says save frame interrupt value, reset, then restore */ + ival = OHCI_GET_IVAL(OREAD4(sc, OHCI_FM_INTERVAL)); + OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_HCR); /* Reset HC */ + usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); +/* OWRITE4(sc, OHCI_FM_INTERVAL, ival);*/ + + /* Some broken BIOSes do not recover these values */ + OWRITE4(sc, OHCI_HCCA, DMAADDR(&sc->sc_hccadma, 0)); + OWRITE4(sc, OHCI_CONTROL_HEAD_ED, sc->sc_ctrl_head->physaddr); + OWRITE4(sc, OHCI_BULK_HEAD_ED, sc->sc_bulk_head->physaddr); + /* disable all interrupts and then switch on all desired interrupts */ + OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS); + OWRITE4(sc, OHCI_INTERRUPT_ENABLE, sc->sc_intre | OHCI_MIE ); + + fm = (OREAD4(sc, OHCI_FM_INTERVAL) & OHCI_FIT) ^ OHCI_FIT; + fm |= OHCI_FSMPS(ival) | ival; + OWRITE4(sc, OHCI_FM_INTERVAL, fm); + per = OHCI_PERIODIC(ival); + OWRITE4(sc, OHCI_PERIODIC_START, per); + printf("ohci_resume: fm=0x%x per=0x%x\n",fm,per); + + /* start controller */ + ctl = sc->sc_control; + OWRITE4(sc, OHCI_CONTROL, ctl); + usb_delay_ms(&sc->sc_bus, USB_RESUME_RECOVERY); + + /* power up ports */ + OWRITE4(sc, OHCI_RH_STATUS, OHCI_LPSC); + usb_delay_ms(&sc->sc_bus, OHCI_ENABLE_POWER_DELAY); + splx(s); +#ifdef USB_DEBUG + ohci_dumpregs(sc); +#endif + + return (USBD_NORMAL_COMPLETION); +} + +usbd_status +ohci_suspend(struct ohci_softc *sc) +{ + u_int32_t ctl,i; + int s; + +#ifdef USB_DEBUG + ohci_dumpregs(sc); +#endif + /* + * Preserve register values, in case that APM BIOS + * does not recover them. + */ + sc->sc_control = OREAD4(sc, OHCI_CONTROL); + sc->sc_intre = OREAD4(sc, OHCI_INTERRUPT_ENABLE); +/* sc->sc_port1 = OREAD4(sc, OHCI_RH_PORT_STATUS(1)); + sc->sc_port2 = OREAD4(sc, OHCI_RH_PORT_STATUS(2));*/ + s = splhardusb(); + /* disable interrupts */ + OWRITE4(sc, OHCI_INTERRUPT_DISABLE, OHCI_ALL_INTRS); + splx(s); + /* */ +/* sc->sc_fmrem = OREAD4(sc, OHCI_FM_REMAINING); + sc->sc_fmnum = OREAD4(sc, OHCI_FM_NUMBER);*/ + /* Reset to stop processing frames or the controller might not suspend */ + OWRITE4(sc, OHCI_CONTROL, OHCI_HCFS_RESET); + usb_delay_ms(&sc->sc_bus, USB_BUS_RESET_DELAY); + /* now suspend */ + ctl = OHCI_HCFS_SUSPEND; + OWRITE4(sc, OHCI_CONTROL, ctl); + usb_delay_ms(&sc->sc_bus, USB_RESUME_WAIT); + /* check if the controller is suspended */ + ctl = OREAD4(sc, OHCI_CONTROL); + if((ctl & OHCI_HCFS_SUSPEND) == OHCI_HCFS_SUSPEND) { + printf("ohci_suspend: Controller suspended.\n"); + } else { + /* panic or abort? */ + printf("ohci_suspend: ??? Controller not suspended!\n"); + printf("ohci_suspend: OHCI_CONTROL: 0x%x\n",ctl); + } + return (USBD_NORMAL_COMPLETION); +} + +#if defined(__NetBSD__) || defined(__OpenBSD__) void ohci_power(int why, void *v) { diff -u usb.orig/ohci_pci.c usb/ohci_pci.c --- usb.orig/ohci_pci.c Tue Sep 9 02:56:49 2003 +++ usb/ohci_pci.c Tue Sep 9 03:03:33 2003 @@ -304,11 +304,42 @@ return 0; } +/* implement suspend and resume */ +static int +ohci_pci_suspend(device_t self) +{ + int err; + ohci_softc_t *sc = device_get_softc(self); + err = bus_generic_suspend(self); + if (err) + return err; + ohci_suspend(sc); + return 0; +} + +static int +ohci_pci_resume(device_t self) +{ + ohci_softc_t *sc = device_get_softc(self); + device_printf(self, "ohci_pci_resume: power_state = 0x%08x\n", + pci_get_powerstate(self)); + pci_set_powerstate(self, PCI_POWERSTATE_D0); + if(ohci_resume(sc) != USBD_NORMAL_COMPLETION) { + return ENXIO; + } + bus_generic_resume(self); + + return 0; +} + static device_method_t ohci_methods[] = { /* Device interface */ DEVMETHOD(device_probe, ohci_pci_probe), DEVMETHOD(device_attach, ohci_pci_attach), - DEVMETHOD(device_shutdown, bus_generic_shutdown), + DEVMETHOD(device_detach, bus_generic_detach), + DEVMETHOD(device_suspend, ohci_pci_suspend), + DEVMETHOD(device_resume, ohci_pci_resume), + DEVMETHOD(device_shutdown, bus_generic_shutdown), /* Bus interface */ DEVMETHOD(bus_print_child, bus_generic_print_child), diff -u usb.orig/ohcivar.h usb/ohcivar.h --- usb.orig/ohcivar.h Tue Sep 9 02:56:49 2003 +++ usb/ohcivar.h Tue Sep 9 03:03:33 2003 @@ -158,6 +158,8 @@ #define OXFER(xfer) ((struct ohci_xfer *)(xfer)) usbd_status ohci_init(ohci_softc_t *); +usbd_status ohci_suspend(ohci_softc_t *); +usbd_status ohci_resume(ohci_softc_t *); int ohci_intr(void *); #if defined(__NetBSD__) || defined(__OpenBSD__) int ohci_detach(ohci_softc_t *, int);