1 // SPDX-License-Identifier: GPL-1.0+ 2 /* 3 * OHCI HCD (Host Controller Driver) for USB. 4 * 5 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 6 * (C) Copyright 2000-2005 David Brownell 7 * (C) Copyright 2002 Hewlett-Packard Company 8 * 9 * OMAP Bus Glue 10 * 11 * Modified for OMAP by Tony Lindgren <tony@atomide.com> 12 * Based on the 2.4 OMAP OHCI driver originally done by MontaVista Software Inc. 13 * and on ohci-sa1111.c by Christopher Hoover <ch@hpl.hp.com> 14 * 15 * This file is licenced under the GPL. 16 */ 17 18 #include <linux/clk.h> 19 #include <linux/dma-mapping.h> 20 #include <linux/err.h> 21 #include <linux/gpio/consumer.h> 22 #include <linux/io.h> 23 #include <linux/jiffies.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/usb/otg.h> 27 #include <linux/platform_device.h> 28 #include <linux/platform_data/usb-omap1.h> 29 #include <linux/soc/ti/omap1-usb.h> 30 #include <linux/soc/ti/omap1-mux.h> 31 #include <linux/soc/ti/omap1-soc.h> 32 #include <linux/soc/ti/omap1-io.h> 33 #include <linux/signal.h> 34 #include <linux/usb.h> 35 #include <linux/usb/hcd.h> 36 37 #include "ohci.h" 38 39 #include <asm/io.h> 40 #include <asm/mach-types.h> 41 42 #define DRIVER_DESC "OHCI OMAP driver" 43 44 struct ohci_omap_priv { 45 struct clk *usb_host_ck; 46 struct clk *usb_dc_ck; 47 struct gpio_desc *power; 48 struct gpio_desc *overcurrent; 49 }; 50 51 static const char hcd_name[] = "ohci-omap"; 52 static struct hc_driver __read_mostly ohci_omap_hc_driver; 53 54 #define hcd_to_ohci_omap_priv(h) \ 55 ((struct ohci_omap_priv *)hcd_to_ohci(h)->priv) 56 57 static void omap_ohci_clock_power(struct ohci_omap_priv *priv, int on) 58 { 59 if (on) { 60 clk_enable(priv->usb_dc_ck); 61 clk_enable(priv->usb_host_ck); 62 /* guesstimate for T5 == 1x 32K clock + APLL lock time */ 63 udelay(100); 64 } else { 65 clk_disable(priv->usb_host_ck); 66 clk_disable(priv->usb_dc_ck); 67 } 68 } 69 70 #ifdef CONFIG_USB_OTG 71 72 static void start_hnp(struct ohci_hcd *ohci) 73 { 74 struct usb_hcd *hcd = ohci_to_hcd(ohci); 75 const unsigned port = hcd->self.otg_port - 1; 76 unsigned long flags; 77 u32 l; 78 79 otg_start_hnp(hcd->usb_phy->otg); 80 81 local_irq_save(flags); 82 hcd->usb_phy->otg->state = OTG_STATE_A_SUSPEND; 83 writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]); 84 l = omap_readl(OTG_CTRL); 85 l &= ~OTG_A_BUSREQ; 86 omap_writel(l, OTG_CTRL); 87 local_irq_restore(flags); 88 } 89 90 #endif 91 92 /*-------------------------------------------------------------------------*/ 93 94 static int ohci_omap_reset(struct usb_hcd *hcd) 95 { 96 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 97 struct omap_usb_config *config = dev_get_platdata(hcd->self.controller); 98 struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd); 99 int need_transceiver = (config->otg != 0); 100 int ret; 101 102 dev_dbg(hcd->self.controller, "starting USB Controller\n"); 103 104 if (config->otg) { 105 hcd->self.otg_port = config->otg; 106 /* default/minimum OTG power budget: 8 mA */ 107 hcd->power_budget = 8; 108 } 109 110 /* boards can use OTG transceivers in non-OTG modes */ 111 need_transceiver = need_transceiver 112 || machine_is_omap_h2() || machine_is_omap_h3(); 113 114 /* XXX OMAP16xx only */ 115 if (config->ocpi_enable) 116 config->ocpi_enable(); 117 118 #ifdef CONFIG_USB_OTG 119 if (need_transceiver) { 120 hcd->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2); 121 if (!IS_ERR_OR_NULL(hcd->usb_phy)) { 122 int status = otg_set_host(hcd->usb_phy->otg, 123 &ohci_to_hcd(ohci)->self); 124 dev_dbg(hcd->self.controller, "init %s phy, status %d\n", 125 hcd->usb_phy->label, status); 126 if (status) { 127 usb_put_phy(hcd->usb_phy); 128 return status; 129 } 130 } else { 131 return -EPROBE_DEFER; 132 } 133 hcd->skip_phy_initialization = 1; 134 ohci->start_hnp = start_hnp; 135 } 136 #endif 137 138 omap_ohci_clock_power(priv, 1); 139 140 if (config->lb_reset) 141 config->lb_reset(); 142 143 ret = ohci_setup(hcd); 144 if (ret < 0) 145 return ret; 146 147 if (config->otg || config->rwc) { 148 ohci->hc_control = OHCI_CTRL_RWC; 149 writel(OHCI_CTRL_RWC, &ohci->regs->control); 150 } 151 152 /* board-specific power switching and overcurrent support */ 153 if (machine_is_omap_osk() || machine_is_omap_innovator()) { 154 u32 rh = roothub_a (ohci); 155 156 /* power switching (ganged by default) */ 157 rh &= ~RH_A_NPS; 158 159 /* TPS2045 switch for internal transceiver (port 1) */ 160 if (machine_is_omap_osk()) { 161 ohci_to_hcd(ohci)->power_budget = 250; 162 163 rh &= ~RH_A_NOCP; 164 165 /* gpio9 for overcurrent detction */ 166 omap_cfg_reg(W8_1610_GPIO9); 167 168 /* for paranoia's sake: disable USB.PUEN */ 169 omap_cfg_reg(W4_USB_HIGHZ); 170 } 171 ohci_writel(ohci, rh, &ohci->regs->roothub.a); 172 ohci->flags &= ~OHCI_QUIRK_HUB_POWER; 173 } else if (machine_is_nokia770()) { 174 /* We require a self-powered hub, which should have 175 * plenty of power. */ 176 ohci_to_hcd(ohci)->power_budget = 0; 177 } 178 179 /* FIXME hub_wq hub requests should manage power switching */ 180 if (config->transceiver_power) 181 return config->transceiver_power(1); 182 183 if (priv->power) 184 gpiod_set_value_cansleep(priv->power, 0); 185 186 /* board init will have already handled HMC and mux setup. 187 * any external transceiver should already be initialized 188 * too, so all configured ports use the right signaling now. 189 */ 190 191 return 0; 192 } 193 194 /*-------------------------------------------------------------------------*/ 195 196 /** 197 * ohci_hcd_omap_probe - initialize OMAP-based HCDs 198 * @pdev: USB controller to probe 199 * 200 * Context: task context, might sleep 201 * 202 * Allocates basic resources for this USB host controller, and 203 * then invokes the start() method for the HCD associated with it 204 * through the hotplug entry's driver_data. 205 */ 206 static int ohci_hcd_omap_probe(struct platform_device *pdev) 207 { 208 int retval, irq; 209 struct usb_hcd *hcd = 0; 210 struct ohci_omap_priv *priv; 211 212 if (pdev->num_resources != 2) { 213 dev_err(&pdev->dev, "invalid num_resources: %i\n", 214 pdev->num_resources); 215 return -ENODEV; 216 } 217 218 if (pdev->resource[0].flags != IORESOURCE_MEM 219 || pdev->resource[1].flags != IORESOURCE_IRQ) { 220 dev_err(&pdev->dev, "invalid resource type\n"); 221 return -ENODEV; 222 } 223 224 hcd = usb_create_hcd(&ohci_omap_hc_driver, &pdev->dev, 225 dev_name(&pdev->dev)); 226 if (!hcd) 227 return -ENOMEM; 228 229 hcd->rsrc_start = pdev->resource[0].start; 230 hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1; 231 priv = hcd_to_ohci_omap_priv(hcd); 232 233 /* Obtain two optional GPIO lines */ 234 priv->power = devm_gpiod_get_optional(&pdev->dev, "power", GPIOD_ASIS); 235 if (IS_ERR(priv->power)) { 236 retval = PTR_ERR(priv->power); 237 goto err_put_hcd; 238 } 239 if (priv->power) 240 gpiod_set_consumer_name(priv->power, "OHCI power"); 241 242 /* 243 * This "overcurrent" GPIO line isn't really used in the code, 244 * but has a designated hardware function. 245 * TODO: implement proper overcurrent handling. 246 */ 247 priv->overcurrent = devm_gpiod_get_optional(&pdev->dev, "overcurrent", 248 GPIOD_IN); 249 if (IS_ERR(priv->overcurrent)) { 250 retval = PTR_ERR(priv->overcurrent); 251 goto err_put_hcd; 252 } 253 if (priv->overcurrent) 254 gpiod_set_consumer_name(priv->overcurrent, "OHCI overcurrent"); 255 256 priv->usb_host_ck = clk_get(&pdev->dev, "usb_hhc_ck"); 257 if (IS_ERR(priv->usb_host_ck)) { 258 retval = PTR_ERR(priv->usb_host_ck); 259 goto err_put_hcd; 260 } 261 262 retval = clk_prepare(priv->usb_host_ck); 263 if (retval) 264 goto err_put_host_ck; 265 266 if (!cpu_is_omap15xx()) 267 priv->usb_dc_ck = clk_get(&pdev->dev, "usb_dc_ck"); 268 else 269 priv->usb_dc_ck = clk_get(&pdev->dev, "lb_ck"); 270 271 if (IS_ERR(priv->usb_dc_ck)) { 272 retval = PTR_ERR(priv->usb_dc_ck); 273 goto err_unprepare_host_ck; 274 } 275 276 retval = clk_prepare(priv->usb_dc_ck); 277 if (retval) 278 goto err_put_dc_ck; 279 280 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 281 dev_dbg(&pdev->dev, "request_mem_region failed\n"); 282 retval = -EBUSY; 283 goto err_unprepare_dc_ck; 284 } 285 286 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 287 if (!hcd->regs) { 288 dev_err(&pdev->dev, "can't ioremap OHCI HCD\n"); 289 retval = -ENOMEM; 290 goto err2; 291 } 292 293 irq = platform_get_irq(pdev, 0); 294 if (irq < 0) { 295 retval = irq; 296 goto err3; 297 } 298 retval = usb_add_hcd(hcd, irq, 0); 299 if (retval) 300 goto err3; 301 302 device_wakeup_enable(hcd->self.controller); 303 return 0; 304 err3: 305 iounmap(hcd->regs); 306 err2: 307 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 308 err_unprepare_dc_ck: 309 clk_unprepare(priv->usb_dc_ck); 310 err_put_dc_ck: 311 clk_put(priv->usb_dc_ck); 312 err_unprepare_host_ck: 313 clk_unprepare(priv->usb_host_ck); 314 err_put_host_ck: 315 clk_put(priv->usb_host_ck); 316 err_put_hcd: 317 usb_put_hcd(hcd); 318 return retval; 319 } 320 321 322 /* may be called with controller, bus, and devices active */ 323 324 /** 325 * ohci_hcd_omap_remove - shutdown processing for OMAP-based HCDs 326 * @pdev: USB Host Controller being removed 327 * 328 * Context: task context, might sleep 329 * 330 * Reverses the effect of ohci_hcd_omap_probe(), first invoking 331 * the HCD's stop() method. It is always called from a thread 332 * context, normally "rmmod", "apmd", or something similar. 333 */ 334 static int ohci_hcd_omap_remove(struct platform_device *pdev) 335 { 336 struct usb_hcd *hcd = platform_get_drvdata(pdev); 337 struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd); 338 339 dev_dbg(hcd->self.controller, "stopping USB Controller\n"); 340 usb_remove_hcd(hcd); 341 omap_ohci_clock_power(priv, 0); 342 if (!IS_ERR_OR_NULL(hcd->usb_phy)) { 343 (void) otg_set_host(hcd->usb_phy->otg, 0); 344 usb_put_phy(hcd->usb_phy); 345 } 346 iounmap(hcd->regs); 347 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 348 clk_unprepare(priv->usb_dc_ck); 349 clk_put(priv->usb_dc_ck); 350 clk_unprepare(priv->usb_host_ck); 351 clk_put(priv->usb_host_ck); 352 usb_put_hcd(hcd); 353 return 0; 354 } 355 356 /*-------------------------------------------------------------------------*/ 357 358 #ifdef CONFIG_PM 359 360 static int ohci_omap_suspend(struct platform_device *pdev, pm_message_t message) 361 { 362 struct usb_hcd *hcd = platform_get_drvdata(pdev); 363 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 364 struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd); 365 bool do_wakeup = device_may_wakeup(&pdev->dev); 366 int ret; 367 368 if (time_before(jiffies, ohci->next_statechange)) 369 msleep(5); 370 ohci->next_statechange = jiffies; 371 372 ret = ohci_suspend(hcd, do_wakeup); 373 if (ret) 374 return ret; 375 376 omap_ohci_clock_power(priv, 0); 377 return ret; 378 } 379 380 static int ohci_omap_resume(struct platform_device *dev) 381 { 382 struct usb_hcd *hcd = platform_get_drvdata(dev); 383 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 384 struct ohci_omap_priv *priv = hcd_to_ohci_omap_priv(hcd); 385 386 if (time_before(jiffies, ohci->next_statechange)) 387 msleep(5); 388 ohci->next_statechange = jiffies; 389 390 omap_ohci_clock_power(priv, 1); 391 ohci_resume(hcd, false); 392 return 0; 393 } 394 395 #endif 396 397 /*-------------------------------------------------------------------------*/ 398 399 /* 400 * Driver definition to register with the OMAP bus 401 */ 402 static struct platform_driver ohci_hcd_omap_driver = { 403 .probe = ohci_hcd_omap_probe, 404 .remove = ohci_hcd_omap_remove, 405 .shutdown = usb_hcd_platform_shutdown, 406 #ifdef CONFIG_PM 407 .suspend = ohci_omap_suspend, 408 .resume = ohci_omap_resume, 409 #endif 410 .driver = { 411 .name = "ohci", 412 }, 413 }; 414 415 static const struct ohci_driver_overrides omap_overrides __initconst = { 416 .product_desc = "OMAP OHCI", 417 .reset = ohci_omap_reset, 418 .extra_priv_size = sizeof(struct ohci_omap_priv), 419 }; 420 421 static int __init ohci_omap_init(void) 422 { 423 if (usb_disabled()) 424 return -ENODEV; 425 426 ohci_init_driver(&ohci_omap_hc_driver, &omap_overrides); 427 return platform_driver_register(&ohci_hcd_omap_driver); 428 } 429 module_init(ohci_omap_init); 430 431 static void __exit ohci_omap_cleanup(void) 432 { 433 platform_driver_unregister(&ohci_hcd_omap_driver); 434 } 435 module_exit(ohci_omap_cleanup); 436 437 MODULE_DESCRIPTION(DRIVER_DESC); 438 MODULE_ALIAS("platform:ohci"); 439 MODULE_LICENSE("GPL"); 440