1 /* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * Copyright (C) 2004 SAN People (Pty) Ltd. 5 * Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org> 6 * 7 * AT91 Bus Glue 8 * 9 * Based on fragments of 2.4 driver by Rick Bronson. 10 * Based on ohci-omap.c 11 * 12 * This file is licenced under the GPL. 13 */ 14 15 #include <linux/clk.h> 16 #include <linux/platform_device.h> 17 18 #include <asm/mach-types.h> 19 #include <asm/hardware.h> 20 #include <asm/gpio.h> 21 22 #include <asm/arch/board.h> 23 #include <asm/arch/cpu.h> 24 25 #ifndef CONFIG_ARCH_AT91 26 #error "CONFIG_ARCH_AT91 must be defined." 27 #endif 28 29 /* interface and function clocks; sometimes also an AHB clock */ 30 static struct clk *iclk, *fclk, *hclk; 31 static int clocked; 32 33 extern int usb_disabled(void); 34 35 /*-------------------------------------------------------------------------*/ 36 37 static void at91_start_clock(void) 38 { 39 if (cpu_is_at91sam9261()) 40 clk_enable(hclk); 41 clk_enable(iclk); 42 clk_enable(fclk); 43 clocked = 1; 44 } 45 46 static void at91_stop_clock(void) 47 { 48 clk_disable(fclk); 49 clk_disable(iclk); 50 if (cpu_is_at91sam9261()) 51 clk_disable(hclk); 52 clocked = 0; 53 } 54 55 static void at91_start_hc(struct platform_device *pdev) 56 { 57 struct usb_hcd *hcd = platform_get_drvdata(pdev); 58 struct ohci_regs __iomem *regs = hcd->regs; 59 60 dev_dbg(&pdev->dev, "start\n"); 61 62 /* 63 * Start the USB clocks. 64 */ 65 at91_start_clock(); 66 67 /* 68 * The USB host controller must remain in reset. 69 */ 70 writel(0, ®s->control); 71 } 72 73 static void at91_stop_hc(struct platform_device *pdev) 74 { 75 struct usb_hcd *hcd = platform_get_drvdata(pdev); 76 struct ohci_regs __iomem *regs = hcd->regs; 77 78 dev_dbg(&pdev->dev, "stop\n"); 79 80 /* 81 * Put the USB host controller into reset. 82 */ 83 writel(0, ®s->control); 84 85 /* 86 * Stop the USB clocks. 87 */ 88 at91_stop_clock(); 89 } 90 91 92 /*-------------------------------------------------------------------------*/ 93 94 static int usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *); 95 96 /* configure so an HC device and id are always provided */ 97 /* always called with process context; sleeping is OK */ 98 99 100 /** 101 * usb_hcd_at91_probe - initialize AT91-based HCDs 102 * Context: !in_interrupt() 103 * 104 * Allocates basic resources for this USB host controller, and 105 * then invokes the start() method for the HCD associated with it 106 * through the hotplug entry's driver_data. 107 */ 108 static int usb_hcd_at91_probe(const struct hc_driver *driver, 109 struct platform_device *pdev) 110 { 111 int retval; 112 struct usb_hcd *hcd = NULL; 113 114 if (pdev->num_resources != 2) { 115 pr_debug("hcd probe: invalid num_resources"); 116 return -ENODEV; 117 } 118 119 if ((pdev->resource[0].flags != IORESOURCE_MEM) 120 || (pdev->resource[1].flags != IORESOURCE_IRQ)) { 121 pr_debug("hcd probe: invalid resource type\n"); 122 return -ENODEV; 123 } 124 125 hcd = usb_create_hcd(driver, &pdev->dev, "at91"); 126 if (!hcd) 127 return -ENOMEM; 128 hcd->rsrc_start = pdev->resource[0].start; 129 hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1; 130 131 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 132 pr_debug("request_mem_region failed\n"); 133 retval = -EBUSY; 134 goto err1; 135 } 136 137 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 138 if (!hcd->regs) { 139 pr_debug("ioremap failed\n"); 140 retval = -EIO; 141 goto err2; 142 } 143 144 iclk = clk_get(&pdev->dev, "ohci_clk"); 145 fclk = clk_get(&pdev->dev, "uhpck"); 146 if (cpu_is_at91sam9261()) 147 hclk = clk_get(&pdev->dev, "hck0"); 148 149 at91_start_hc(pdev); 150 ohci_hcd_init(hcd_to_ohci(hcd)); 151 152 retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED); 153 if (retval == 0) 154 return retval; 155 156 /* Error handling */ 157 at91_stop_hc(pdev); 158 159 if (cpu_is_at91sam9261()) 160 clk_put(hclk); 161 clk_put(fclk); 162 clk_put(iclk); 163 164 iounmap(hcd->regs); 165 166 err2: 167 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 168 169 err1: 170 usb_put_hcd(hcd); 171 return retval; 172 } 173 174 175 /* may be called with controller, bus, and devices active */ 176 177 /** 178 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs 179 * @dev: USB Host Controller being removed 180 * Context: !in_interrupt() 181 * 182 * Reverses the effect of usb_hcd_at91_probe(), first invoking 183 * the HCD's stop() method. It is always called from a thread 184 * context, "rmmod" or something similar. 185 * 186 */ 187 static int usb_hcd_at91_remove(struct usb_hcd *hcd, 188 struct platform_device *pdev) 189 { 190 usb_remove_hcd(hcd); 191 at91_stop_hc(pdev); 192 iounmap(hcd->regs); 193 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 194 195 if (cpu_is_at91sam9261()) 196 clk_put(hclk); 197 clk_put(fclk); 198 clk_put(iclk); 199 fclk = iclk = hclk = NULL; 200 201 dev_set_drvdata(&pdev->dev, NULL); 202 return 0; 203 } 204 205 /*-------------------------------------------------------------------------*/ 206 207 static int __devinit 208 ohci_at91_start (struct usb_hcd *hcd) 209 { 210 struct at91_usbh_data *board = hcd->self.controller->platform_data; 211 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 212 int ret; 213 214 if ((ret = ohci_init(ohci)) < 0) 215 return ret; 216 217 ohci->num_ports = board->ports; 218 219 if ((ret = ohci_run(ohci)) < 0) { 220 err("can't start %s", hcd->self.bus_name); 221 ohci_stop(hcd); 222 return ret; 223 } 224 return 0; 225 } 226 227 /*-------------------------------------------------------------------------*/ 228 229 static const struct hc_driver ohci_at91_hc_driver = { 230 .description = hcd_name, 231 .product_desc = "AT91 OHCI", 232 .hcd_priv_size = sizeof(struct ohci_hcd), 233 234 /* 235 * generic hardware linkage 236 */ 237 .irq = ohci_irq, 238 .flags = HCD_USB11 | HCD_MEMORY, 239 240 /* 241 * basic lifecycle operations 242 */ 243 .start = ohci_at91_start, 244 .stop = ohci_stop, 245 .shutdown = ohci_shutdown, 246 247 /* 248 * managing i/o requests and associated device resources 249 */ 250 .urb_enqueue = ohci_urb_enqueue, 251 .urb_dequeue = ohci_urb_dequeue, 252 .endpoint_disable = ohci_endpoint_disable, 253 254 /* 255 * scheduling support 256 */ 257 .get_frame_number = ohci_get_frame, 258 259 /* 260 * root hub support 261 */ 262 .hub_status_data = ohci_hub_status_data, 263 .hub_control = ohci_hub_control, 264 #ifdef CONFIG_PM 265 .bus_suspend = ohci_bus_suspend, 266 .bus_resume = ohci_bus_resume, 267 #endif 268 .start_port_reset = ohci_start_port_reset, 269 }; 270 271 /*-------------------------------------------------------------------------*/ 272 273 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) 274 { 275 struct at91_usbh_data *pdata = pdev->dev.platform_data; 276 int i; 277 278 if (pdata) { 279 /* REVISIT make the driver support per-port power switching, 280 * and also overcurrent detection. Here we assume the ports 281 * are always powered while this driver is active, and use 282 * active-low power switches. 283 */ 284 for (i = 0; i < pdata->ports; i++) { 285 if (pdata->vbus_pin[i] <= 0) 286 continue; 287 gpio_request(pdata->vbus_pin[i], "ohci_vbus"); 288 gpio_direction_output(pdata->vbus_pin[i], 0); 289 } 290 } 291 292 device_init_wakeup(&pdev->dev, 1); 293 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); 294 } 295 296 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) 297 { 298 struct at91_usbh_data *pdata = pdev->dev.platform_data; 299 int i; 300 301 if (pdata) { 302 for (i = 0; i < pdata->ports; i++) { 303 if (pdata->vbus_pin[i] <= 0) 304 continue; 305 gpio_direction_output(pdata->vbus_pin[i], 1); 306 gpio_free(pdata->vbus_pin[i]); 307 } 308 } 309 310 device_init_wakeup(&pdev->dev, 0); 311 return usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev); 312 } 313 314 #ifdef CONFIG_PM 315 316 static int 317 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg) 318 { 319 struct usb_hcd *hcd = platform_get_drvdata(pdev); 320 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 321 322 if (device_may_wakeup(&pdev->dev)) 323 enable_irq_wake(hcd->irq); 324 325 /* 326 * The integrated transceivers seem unable to notice disconnect, 327 * reconnect, or wakeup without the 48 MHz clock active. so for 328 * correctness, always discard connection state (using reset). 329 * 330 * REVISIT: some boards will be able to turn VBUS off... 331 */ 332 if (at91_suspend_entering_slow_clock()) { 333 ohci_usb_reset (ohci); 334 at91_stop_clock(); 335 } 336 337 return 0; 338 } 339 340 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev) 341 { 342 struct usb_hcd *hcd = platform_get_drvdata(pdev); 343 344 if (device_may_wakeup(&pdev->dev)) 345 disable_irq_wake(hcd->irq); 346 347 if (!clocked) 348 at91_start_clock(); 349 350 ohci_finish_controller_resume(hcd); 351 return 0; 352 } 353 #else 354 #define ohci_hcd_at91_drv_suspend NULL 355 #define ohci_hcd_at91_drv_resume NULL 356 #endif 357 358 MODULE_ALIAS("platform:at91_ohci"); 359 360 static struct platform_driver ohci_hcd_at91_driver = { 361 .probe = ohci_hcd_at91_drv_probe, 362 .remove = ohci_hcd_at91_drv_remove, 363 .shutdown = usb_hcd_platform_shutdown, 364 .suspend = ohci_hcd_at91_drv_suspend, 365 .resume = ohci_hcd_at91_drv_resume, 366 .driver = { 367 .name = "at91_ohci", 368 .owner = THIS_MODULE, 369 }, 370 }; 371