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