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 .hub_irq_enable = ohci_rhsc_enable, 265 #ifdef CONFIG_PM 266 .bus_suspend = ohci_bus_suspend, 267 .bus_resume = ohci_bus_resume, 268 #endif 269 .start_port_reset = ohci_start_port_reset, 270 }; 271 272 /*-------------------------------------------------------------------------*/ 273 274 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) 275 { 276 struct at91_usbh_data *pdata = pdev->dev.platform_data; 277 int i; 278 279 if (pdata) { 280 /* REVISIT make the driver support per-port power switching, 281 * and also overcurrent detection. Here we assume the ports 282 * are always powered while this driver is active, and use 283 * active-low power switches. 284 */ 285 for (i = 0; i < pdata->ports; i++) { 286 if (pdata->vbus_pin[i] <= 0) 287 continue; 288 gpio_request(pdata->vbus_pin[i], "ohci_vbus"); 289 gpio_direction_output(pdata->vbus_pin[i], 0); 290 } 291 } 292 293 device_init_wakeup(&pdev->dev, 1); 294 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); 295 } 296 297 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) 298 { 299 struct at91_usbh_data *pdata = pdev->dev.platform_data; 300 int i; 301 302 if (pdata) { 303 for (i = 0; i < pdata->ports; i++) { 304 if (pdata->vbus_pin[i] <= 0) 305 continue; 306 gpio_direction_output(pdata->vbus_pin[i], 1); 307 gpio_free(pdata->vbus_pin[i]); 308 } 309 } 310 311 device_init_wakeup(&pdev->dev, 0); 312 return usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev); 313 } 314 315 #ifdef CONFIG_PM 316 317 static int 318 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg) 319 { 320 struct usb_hcd *hcd = platform_get_drvdata(pdev); 321 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 322 323 if (device_may_wakeup(&pdev->dev)) 324 enable_irq_wake(hcd->irq); 325 326 /* 327 * The integrated transceivers seem unable to notice disconnect, 328 * reconnect, or wakeup without the 48 MHz clock active. so for 329 * correctness, always discard connection state (using reset). 330 * 331 * REVISIT: some boards will be able to turn VBUS off... 332 */ 333 if (at91_suspend_entering_slow_clock()) { 334 ohci_usb_reset (ohci); 335 at91_stop_clock(); 336 } 337 338 return 0; 339 } 340 341 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev) 342 { 343 struct usb_hcd *hcd = platform_get_drvdata(pdev); 344 345 if (device_may_wakeup(&pdev->dev)) 346 disable_irq_wake(hcd->irq); 347 348 if (!clocked) 349 at91_start_clock(); 350 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("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 372