1 /* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 5 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net> 6 * (C) Copyright 2002 Hewlett-Packard Company 7 * 8 * SA1111 Bus Glue 9 * 10 * Written by Christopher Hoover <ch@hpl.hp.com> 11 * Based on fragments of previous driver by Russell King et al. 12 * 13 * This file is licenced under the GPL. 14 */ 15 16 #include <asm/mach-types.h> 17 #include <asm/hardware/sa1111.h> 18 19 #ifndef CONFIG_SA1111 20 #error "This file is SA-1111 bus glue. CONFIG_SA1111 must be defined." 21 #endif 22 23 #define USB_STATUS 0x0118 24 #define USB_RESET 0x011c 25 #define USB_IRQTEST 0x0120 26 27 #define USB_RESET_FORCEIFRESET (1 << 0) 28 #define USB_RESET_FORCEHCRESET (1 << 1) 29 #define USB_RESET_CLKGENRESET (1 << 2) 30 #define USB_RESET_SIMSCALEDOWN (1 << 3) 31 #define USB_RESET_USBINTTEST (1 << 4) 32 #define USB_RESET_SLEEPSTBYEN (1 << 5) 33 #define USB_RESET_PWRSENSELOW (1 << 6) 34 #define USB_RESET_PWRCTRLLOW (1 << 7) 35 36 #define USB_STATUS_IRQHCIRMTWKUP (1 << 7) 37 #define USB_STATUS_IRQHCIBUFFACC (1 << 8) 38 #define USB_STATUS_NIRQHCIM (1 << 9) 39 #define USB_STATUS_NHCIMFCLR (1 << 10) 40 #define USB_STATUS_USBPWRSENSE (1 << 11) 41 42 #if 0 43 static void dump_hci_status(struct usb_hcd *hcd, const char *label) 44 { 45 unsigned long status = sa1111_readl(hcd->regs + USB_STATUS); 46 47 printk(KERN_DEBUG "%s USB_STATUS = { %s%s%s%s%s}\n", label, 48 ((status & USB_STATUS_IRQHCIRMTWKUP) ? "IRQHCIRMTWKUP " : ""), 49 ((status & USB_STATUS_IRQHCIBUFFACC) ? "IRQHCIBUFFACC " : ""), 50 ((status & USB_STATUS_NIRQHCIM) ? "" : "IRQHCIM "), 51 ((status & USB_STATUS_NHCIMFCLR) ? "" : "HCIMFCLR "), 52 ((status & USB_STATUS_USBPWRSENSE) ? "USBPWRSENSE " : "")); 53 } 54 #endif 55 56 static int ohci_sa1111_reset(struct usb_hcd *hcd) 57 { 58 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 59 60 ohci_hcd_init(ohci); 61 return ohci_init(ohci); 62 } 63 64 static int ohci_sa1111_start(struct usb_hcd *hcd) 65 { 66 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 67 int ret; 68 69 ret = ohci_run(ohci); 70 if (ret < 0) { 71 ohci_err(ohci, "can't start\n"); 72 ohci_stop(hcd); 73 } 74 return ret; 75 } 76 77 static const struct hc_driver ohci_sa1111_hc_driver = { 78 .description = hcd_name, 79 .product_desc = "SA-1111 OHCI", 80 .hcd_priv_size = sizeof(struct ohci_hcd), 81 82 /* 83 * generic hardware linkage 84 */ 85 .irq = ohci_irq, 86 .flags = HCD_USB11 | HCD_MEMORY, 87 88 /* 89 * basic lifecycle operations 90 */ 91 .reset = ohci_sa1111_reset, 92 .start = ohci_sa1111_start, 93 .stop = ohci_stop, 94 .shutdown = ohci_shutdown, 95 96 /* 97 * managing i/o requests and associated device resources 98 */ 99 .urb_enqueue = ohci_urb_enqueue, 100 .urb_dequeue = ohci_urb_dequeue, 101 .endpoint_disable = ohci_endpoint_disable, 102 103 /* 104 * scheduling support 105 */ 106 .get_frame_number = ohci_get_frame, 107 108 /* 109 * root hub support 110 */ 111 .hub_status_data = ohci_hub_status_data, 112 .hub_control = ohci_hub_control, 113 #ifdef CONFIG_PM 114 .bus_suspend = ohci_bus_suspend, 115 .bus_resume = ohci_bus_resume, 116 #endif 117 .start_port_reset = ohci_start_port_reset, 118 }; 119 120 static int sa1111_start_hc(struct sa1111_dev *dev) 121 { 122 unsigned int usb_rst = 0; 123 int ret; 124 125 dev_dbg(&dev->dev, "starting SA-1111 OHCI USB Controller\n"); 126 127 if (machine_is_xp860() || 128 machine_is_assabet() || 129 machine_is_pfs168() || 130 machine_is_badge4()) 131 usb_rst = USB_RESET_PWRSENSELOW | USB_RESET_PWRCTRLLOW; 132 133 /* 134 * Configure the power sense and control lines. Place the USB 135 * host controller in reset. 136 */ 137 sa1111_writel(usb_rst | USB_RESET_FORCEIFRESET | USB_RESET_FORCEHCRESET, 138 dev->mapbase + USB_RESET); 139 140 /* 141 * Now, carefully enable the USB clock, and take 142 * the USB host controller out of reset. 143 */ 144 ret = sa1111_enable_device(dev); 145 if (ret == 0) { 146 udelay(11); 147 sa1111_writel(usb_rst, dev->mapbase + USB_RESET); 148 } 149 150 return ret; 151 } 152 153 static void sa1111_stop_hc(struct sa1111_dev *dev) 154 { 155 unsigned int usb_rst; 156 157 dev_dbg(&dev->dev, "stopping SA-1111 OHCI USB Controller\n"); 158 159 /* 160 * Put the USB host controller into reset. 161 */ 162 usb_rst = sa1111_readl(dev->mapbase + USB_RESET); 163 sa1111_writel(usb_rst | USB_RESET_FORCEIFRESET | USB_RESET_FORCEHCRESET, 164 dev->mapbase + USB_RESET); 165 166 /* 167 * Stop the USB clock. 168 */ 169 sa1111_disable_device(dev); 170 } 171 172 /** 173 * ohci_hcd_sa1111_probe - initialize SA-1111-based HCDs 174 * 175 * Allocates basic resources for this USB host controller, and 176 * then invokes the start() method for the HCD associated with it. 177 */ 178 static int ohci_hcd_sa1111_probe(struct sa1111_dev *dev) 179 { 180 struct usb_hcd *hcd; 181 int ret; 182 183 if (usb_disabled()) 184 return -ENODEV; 185 186 /* 187 * We don't call dma_set_mask_and_coherent() here because the 188 * DMA mask has already been appropraitely setup by the core 189 * SA-1111 bus code (which includes bug workarounds.) 190 */ 191 192 hcd = usb_create_hcd(&ohci_sa1111_hc_driver, &dev->dev, "sa1111"); 193 if (!hcd) 194 return -ENOMEM; 195 196 hcd->rsrc_start = dev->res.start; 197 hcd->rsrc_len = resource_size(&dev->res); 198 199 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 200 dev_dbg(&dev->dev, "request_mem_region failed\n"); 201 ret = -EBUSY; 202 goto err1; 203 } 204 205 hcd->regs = dev->mapbase; 206 207 ret = sa1111_start_hc(dev); 208 if (ret) 209 goto err2; 210 211 ret = usb_add_hcd(hcd, dev->irq[1], 0); 212 if (ret == 0) { 213 device_wakeup_enable(hcd->self.controller); 214 return ret; 215 } 216 217 sa1111_stop_hc(dev); 218 err2: 219 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 220 err1: 221 usb_put_hcd(hcd); 222 return ret; 223 } 224 225 /** 226 * ohci_hcd_sa1111_remove - shutdown processing for SA-1111-based HCDs 227 * @dev: USB Host Controller being removed 228 * 229 * Reverses the effect of ohci_hcd_sa1111_probe(), first invoking 230 * the HCD's stop() method. 231 */ 232 static int ohci_hcd_sa1111_remove(struct sa1111_dev *dev) 233 { 234 struct usb_hcd *hcd = sa1111_get_drvdata(dev); 235 236 usb_remove_hcd(hcd); 237 sa1111_stop_hc(dev); 238 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 239 usb_put_hcd(hcd); 240 241 return 0; 242 } 243 244 static void ohci_hcd_sa1111_shutdown(struct sa1111_dev *dev) 245 { 246 struct usb_hcd *hcd = sa1111_get_drvdata(dev); 247 248 if (test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { 249 hcd->driver->shutdown(hcd); 250 sa1111_stop_hc(dev); 251 } 252 } 253 254 static struct sa1111_driver ohci_hcd_sa1111_driver = { 255 .drv = { 256 .name = "sa1111-ohci", 257 .owner = THIS_MODULE, 258 }, 259 .devid = SA1111_DEVID_USB, 260 .probe = ohci_hcd_sa1111_probe, 261 .remove = ohci_hcd_sa1111_remove, 262 .shutdown = ohci_hcd_sa1111_shutdown, 263 }; 264