1 /* 2 * ehci-omap.c - driver for USBHOST on OMAP3/4 processors 3 * 4 * Bus Glue for the EHCI controllers in OMAP3/4 5 * Tested on several OMAP3 boards, and OMAP4 Pandaboard 6 * 7 * Copyright (C) 2007-2011 Texas Instruments, Inc. 8 * Author: Vikram Pandita <vikram.pandita@ti.com> 9 * Author: Anand Gadiyar <gadiyar@ti.com> 10 * Author: Keshava Munegowda <keshava_mgowda@ti.com> 11 * 12 * Copyright (C) 2009 Nokia Corporation 13 * Contact: Felipe Balbi <felipe.balbi@nokia.com> 14 * 15 * Based on "ehci-fsl.c" and "ehci-au1xxx.c" ehci glue layers 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License as published by 19 * the Free Software Foundation; either version 2 of the License, or 20 * (at your option) any later version. 21 * 22 * This program is distributed in the hope that it will be useful, 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of 24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 * GNU General Public License for more details. 26 * 27 * You should have received a copy of the GNU General Public License 28 * along with this program; if not, write to the Free Software 29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 30 * 31 * TODO (last updated Feb 27, 2010): 32 * - add kernel-doc 33 * - enable AUTOIDLE 34 * - add suspend/resume 35 * - add HSIC and TLL support 36 * - convert to use hwmod and runtime PM 37 */ 38 39 #include <linux/platform_device.h> 40 #include <linux/slab.h> 41 #include <linux/usb/ulpi.h> 42 #include <linux/regulator/consumer.h> 43 #include <linux/pm_runtime.h> 44 #include <linux/gpio.h> 45 #include <linux/clk.h> 46 47 #include <linux/platform_data/usb-omap.h> 48 49 /* EHCI Register Set */ 50 #define EHCI_INSNREG04 (0xA0) 51 #define EHCI_INSNREG04_DISABLE_UNSUSPEND (1 << 5) 52 #define EHCI_INSNREG05_ULPI (0xA4) 53 #define EHCI_INSNREG05_ULPI_CONTROL_SHIFT 31 54 #define EHCI_INSNREG05_ULPI_PORTSEL_SHIFT 24 55 #define EHCI_INSNREG05_ULPI_OPSEL_SHIFT 22 56 #define EHCI_INSNREG05_ULPI_REGADD_SHIFT 16 57 #define EHCI_INSNREG05_ULPI_EXTREGADD_SHIFT 8 58 #define EHCI_INSNREG05_ULPI_WRDATA_SHIFT 0 59 60 /*-------------------------------------------------------------------------*/ 61 62 static const struct hc_driver ehci_omap_hc_driver; 63 64 65 static inline void ehci_write(void __iomem *base, u32 reg, u32 val) 66 { 67 __raw_writel(val, base + reg); 68 } 69 70 static inline u32 ehci_read(void __iomem *base, u32 reg) 71 { 72 return __raw_readl(base + reg); 73 } 74 75 76 static void omap_ehci_soft_phy_reset(struct usb_hcd *hcd, u8 port) 77 { 78 unsigned long timeout = jiffies + msecs_to_jiffies(1000); 79 unsigned reg = 0; 80 81 reg = ULPI_FUNC_CTRL_RESET 82 /* FUNCTION_CTRL_SET register */ 83 | (ULPI_SET(ULPI_FUNC_CTRL) << EHCI_INSNREG05_ULPI_REGADD_SHIFT) 84 /* Write */ 85 | (2 << EHCI_INSNREG05_ULPI_OPSEL_SHIFT) 86 /* PORTn */ 87 | ((port + 1) << EHCI_INSNREG05_ULPI_PORTSEL_SHIFT) 88 /* start ULPI access*/ 89 | (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT); 90 91 ehci_write(hcd->regs, EHCI_INSNREG05_ULPI, reg); 92 93 /* Wait for ULPI access completion */ 94 while ((ehci_read(hcd->regs, EHCI_INSNREG05_ULPI) 95 & (1 << EHCI_INSNREG05_ULPI_CONTROL_SHIFT))) { 96 cpu_relax(); 97 98 if (time_after(jiffies, timeout)) { 99 dev_dbg(hcd->self.controller, 100 "phy reset operation timed out\n"); 101 break; 102 } 103 } 104 } 105 106 static int omap_ehci_init(struct usb_hcd *hcd) 107 { 108 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 109 int rc; 110 struct ehci_hcd_omap_platform_data *pdata; 111 112 pdata = hcd->self.controller->platform_data; 113 114 /* Hold PHYs in reset while initializing EHCI controller */ 115 if (pdata->phy_reset) { 116 if (gpio_is_valid(pdata->reset_gpio_port[0])) 117 gpio_set_value_cansleep(pdata->reset_gpio_port[0], 0); 118 119 if (gpio_is_valid(pdata->reset_gpio_port[1])) 120 gpio_set_value_cansleep(pdata->reset_gpio_port[1], 0); 121 122 /* Hold the PHY in RESET for enough time till DIR is high */ 123 udelay(10); 124 } 125 126 /* Soft reset the PHY using PHY reset command over ULPI */ 127 if (pdata->port_mode[0] == OMAP_EHCI_PORT_MODE_PHY) 128 omap_ehci_soft_phy_reset(hcd, 0); 129 if (pdata->port_mode[1] == OMAP_EHCI_PORT_MODE_PHY) 130 omap_ehci_soft_phy_reset(hcd, 1); 131 132 /* we know this is the memory we want, no need to ioremap again */ 133 ehci->caps = hcd->regs; 134 135 rc = ehci_setup(hcd); 136 137 if (pdata->phy_reset) { 138 /* Hold the PHY in RESET for enough time till 139 * PHY is settled and ready 140 */ 141 udelay(10); 142 143 if (gpio_is_valid(pdata->reset_gpio_port[0])) 144 gpio_set_value_cansleep(pdata->reset_gpio_port[0], 1); 145 146 if (gpio_is_valid(pdata->reset_gpio_port[1])) 147 gpio_set_value_cansleep(pdata->reset_gpio_port[1], 1); 148 } 149 150 return rc; 151 } 152 153 static void disable_put_regulator( 154 struct ehci_hcd_omap_platform_data *pdata) 155 { 156 int i; 157 158 for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) { 159 if (pdata->regulator[i]) { 160 regulator_disable(pdata->regulator[i]); 161 regulator_put(pdata->regulator[i]); 162 } 163 } 164 } 165 166 /* configure so an HC device and id are always provided */ 167 /* always called with process context; sleeping is OK */ 168 169 /** 170 * ehci_hcd_omap_probe - initialize TI-based HCDs 171 * 172 * Allocates basic resources for this USB host controller, and 173 * then invokes the start() method for the HCD associated with it 174 * through the hotplug entry's driver_data. 175 */ 176 static int ehci_hcd_omap_probe(struct platform_device *pdev) 177 { 178 struct device *dev = &pdev->dev; 179 struct ehci_hcd_omap_platform_data *pdata = dev->platform_data; 180 struct resource *res; 181 struct usb_hcd *hcd; 182 void __iomem *regs; 183 int ret = -ENODEV; 184 int irq; 185 int i; 186 char supply[7]; 187 188 if (usb_disabled()) 189 return -ENODEV; 190 191 if (!dev->parent) { 192 dev_err(dev, "Missing parent device\n"); 193 return -ENODEV; 194 } 195 196 irq = platform_get_irq_byname(pdev, "ehci-irq"); 197 if (irq < 0) { 198 dev_err(dev, "EHCI irq failed\n"); 199 return -ENODEV; 200 } 201 202 res = platform_get_resource_byname(pdev, 203 IORESOURCE_MEM, "ehci"); 204 if (!res) { 205 dev_err(dev, "UHH EHCI get resource failed\n"); 206 return -ENODEV; 207 } 208 209 regs = ioremap(res->start, resource_size(res)); 210 if (!regs) { 211 dev_err(dev, "UHH EHCI ioremap failed\n"); 212 return -ENOMEM; 213 } 214 215 hcd = usb_create_hcd(&ehci_omap_hc_driver, dev, 216 dev_name(dev)); 217 if (!hcd) { 218 dev_err(dev, "failed to create hcd with err %d\n", ret); 219 ret = -ENOMEM; 220 goto err_io; 221 } 222 223 hcd->rsrc_start = res->start; 224 hcd->rsrc_len = resource_size(res); 225 hcd->regs = regs; 226 227 /* get ehci regulator and enable */ 228 for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) { 229 if (pdata->port_mode[i] != OMAP_EHCI_PORT_MODE_PHY) { 230 pdata->regulator[i] = NULL; 231 continue; 232 } 233 snprintf(supply, sizeof(supply), "hsusb%d", i); 234 pdata->regulator[i] = regulator_get(dev, supply); 235 if (IS_ERR(pdata->regulator[i])) { 236 pdata->regulator[i] = NULL; 237 dev_dbg(dev, 238 "failed to get ehci port%d regulator\n", i); 239 } else { 240 regulator_enable(pdata->regulator[i]); 241 } 242 } 243 244 pm_runtime_enable(dev); 245 pm_runtime_get_sync(dev); 246 247 /* 248 * An undocumented "feature" in the OMAP3 EHCI controller, 249 * causes suspended ports to be taken out of suspend when 250 * the USBCMD.Run/Stop bit is cleared (for example when 251 * we do ehci_bus_suspend). 252 * This breaks suspend-resume if the root-hub is allowed 253 * to suspend. Writing 1 to this undocumented register bit 254 * disables this feature and restores normal behavior. 255 */ 256 ehci_write(regs, EHCI_INSNREG04, 257 EHCI_INSNREG04_DISABLE_UNSUSPEND); 258 259 ret = usb_add_hcd(hcd, irq, IRQF_SHARED); 260 if (ret) { 261 dev_err(dev, "failed to add hcd with err %d\n", ret); 262 goto err_pm_runtime; 263 } 264 265 266 return 0; 267 268 err_pm_runtime: 269 disable_put_regulator(pdata); 270 pm_runtime_put_sync(dev); 271 usb_put_hcd(hcd); 272 273 err_io: 274 iounmap(regs); 275 return ret; 276 } 277 278 279 /** 280 * ehci_hcd_omap_remove - shutdown processing for EHCI HCDs 281 * @pdev: USB Host Controller being removed 282 * 283 * Reverses the effect of usb_ehci_hcd_omap_probe(), first invoking 284 * the HCD's stop() method. It is always called from a thread 285 * context, normally "rmmod", "apmd", or something similar. 286 */ 287 static int ehci_hcd_omap_remove(struct platform_device *pdev) 288 { 289 struct device *dev = &pdev->dev; 290 struct usb_hcd *hcd = dev_get_drvdata(dev); 291 struct ehci_hcd_omap_platform_data *pdata = dev->platform_data; 292 293 usb_remove_hcd(hcd); 294 disable_put_regulator(dev->platform_data); 295 iounmap(hcd->regs); 296 usb_put_hcd(hcd); 297 298 pm_runtime_put_sync(dev); 299 pm_runtime_disable(dev); 300 301 if (pdata->phy_reset) { 302 if (gpio_is_valid(pdata->reset_gpio_port[0])) 303 gpio_free(pdata->reset_gpio_port[0]); 304 305 if (gpio_is_valid(pdata->reset_gpio_port[1])) 306 gpio_free(pdata->reset_gpio_port[1]); 307 } 308 return 0; 309 } 310 311 static void ehci_hcd_omap_shutdown(struct platform_device *pdev) 312 { 313 struct usb_hcd *hcd = dev_get_drvdata(&pdev->dev); 314 315 if (hcd->driver->shutdown) 316 hcd->driver->shutdown(hcd); 317 } 318 319 static struct platform_driver ehci_hcd_omap_driver = { 320 .probe = ehci_hcd_omap_probe, 321 .remove = ehci_hcd_omap_remove, 322 .shutdown = ehci_hcd_omap_shutdown, 323 /*.suspend = ehci_hcd_omap_suspend, */ 324 /*.resume = ehci_hcd_omap_resume, */ 325 .driver = { 326 .name = "ehci-omap", 327 } 328 }; 329 330 /*-------------------------------------------------------------------------*/ 331 332 static const struct hc_driver ehci_omap_hc_driver = { 333 .description = hcd_name, 334 .product_desc = "OMAP-EHCI Host Controller", 335 .hcd_priv_size = sizeof(struct ehci_hcd), 336 337 /* 338 * generic hardware linkage 339 */ 340 .irq = ehci_irq, 341 .flags = HCD_MEMORY | HCD_USB2, 342 343 /* 344 * basic lifecycle operations 345 */ 346 .reset = omap_ehci_init, 347 .start = ehci_run, 348 .stop = ehci_stop, 349 .shutdown = ehci_shutdown, 350 351 /* 352 * managing i/o requests and associated device resources 353 */ 354 .urb_enqueue = ehci_urb_enqueue, 355 .urb_dequeue = ehci_urb_dequeue, 356 .endpoint_disable = ehci_endpoint_disable, 357 .endpoint_reset = ehci_endpoint_reset, 358 359 /* 360 * scheduling support 361 */ 362 .get_frame_number = ehci_get_frame, 363 364 /* 365 * root hub support 366 */ 367 .hub_status_data = ehci_hub_status_data, 368 .hub_control = ehci_hub_control, 369 .bus_suspend = ehci_bus_suspend, 370 .bus_resume = ehci_bus_resume, 371 372 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 373 }; 374 375 MODULE_ALIAS("platform:omap-ehci"); 376 MODULE_AUTHOR("Texas Instruments, Inc."); 377 MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>"); 378 379