drivers/usb/host/ohci-st.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ST OHCI driver
   4  *
   5  * Copyright (C) 2014 STMicroelectronics – All Rights Reserved
   6  *
   7  * Author: Peter Griffin <peter.griffin@linaro.org>
   8  *
   9  * Derived from ohci-platform.c
  10  */
  11
  12 #include <linux/clk.h>
  13 #include <linux/dma-mapping.h>
  14 #include <linux/hrtimer.h>
  15 #include <linux/io.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/err.h>
  19 #include <linux/phy/phy.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/reset.h>
  22 #include <linux/usb/ohci_pdriver.h>
  23 #include <linux/usb.h>
  24 #include <linux/usb/hcd.h>
  25
  26 #include "ohci.h"
  27
  28 #define USB_MAX_CLKS 3
  29
  30 struct st_ohci_platform_priv {
  31         struct clk *clks[USB_MAX_CLKS];
  32         struct clk *clk48;
  33         struct reset_control *rst;
  34         struct reset_control *pwr;
  35         struct phy *phy;
  36 };
  37
  38 #define DRIVER_DESC "OHCI STMicroelectronics driver"
  39
  40 #define hcd_to_ohci_priv(h) \
  41         ((struct st_ohci_platform_priv *)hcd_to_ohci(h)->priv)
  42
  43 static const char hcd_name[] = "ohci-st";
  44
  45 static int st_ohci_platform_power_on(struct platform_device *dev)
  46 {
  47         struct usb_hcd *hcd = platform_get_drvdata(dev);
  48         struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
  49         int clk, ret;
  50
  51         ret = reset_control_deassert(priv->pwr);
  52         if (ret)
  53                 return ret;
  54
  55         ret = reset_control_deassert(priv->rst);
  56         if (ret)
  57                 goto err_assert_power;
  58
  59         /* some SoCs don't have a dedicated 48Mhz clock, but those that do
  60            need the rate to be explicitly set */
  61         if (priv->clk48) {
  62                 ret = clk_set_rate(priv->clk48, 48000000);
  63                 if (ret)
  64                         goto err_assert_reset;
  65         }
  66
  67         for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++) {
  68                 ret = clk_prepare_enable(priv->clks[clk]);
  69                 if (ret)
  70                         goto err_disable_clks;
  71         }
  72
  73         ret = phy_init(priv->phy);
  74         if (ret)
  75                 goto err_disable_clks;
  76
  77         ret = phy_power_on(priv->phy);
  78         if (ret)
  79                 goto err_exit_phy;
  80
  81         return 0;
  82
  83 err_exit_phy:
  84         phy_exit(priv->phy);
  85 err_disable_clks:
  86         while (--clk >= 0)
  87                 clk_disable_unprepare(priv->clks[clk]);
  88 err_assert_reset:
  89         reset_control_assert(priv->rst);
  90 err_assert_power:
  91         reset_control_assert(priv->pwr);
  92
  93         return ret;
  94 }
  95
  96 static void st_ohci_platform_power_off(struct platform_device *dev)
  97 {
  98         struct usb_hcd *hcd = platform_get_drvdata(dev);
  99         struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
 100
 101         int clk;
 102
 103         reset_control_assert(priv->pwr);
 104
 105         reset_control_assert(priv->rst);
 106
 107         phy_power_off(priv->phy);
 108
 109         phy_exit(priv->phy);
 110
 111         for (clk = USB_MAX_CLKS - 1; clk >= 0; clk--)
 112                 if (priv->clks[clk])
 113                         clk_disable_unprepare(priv->clks[clk]);
 114 }
 115
 116 static struct hc_driver __read_mostly ohci_platform_hc_driver;
 117
 118 static const struct ohci_driver_overrides platform_overrides __initconst = {
 119         .product_desc =         "ST OHCI controller",
 120         .extra_priv_size =      sizeof(struct st_ohci_platform_priv),
 121 };
 122
 123 static struct usb_ohci_pdata ohci_platform_defaults = {
 124         .power_on =             st_ohci_platform_power_on,
 125         .power_suspend =        st_ohci_platform_power_off,
 126         .power_off =            st_ohci_platform_power_off,
 127 };
 128
 129 static int st_ohci_platform_probe(struct platform_device *dev)
 130 {
 131         struct usb_hcd *hcd;
 132         struct resource *res_mem;
 133         struct usb_ohci_pdata *pdata = &ohci_platform_defaults;
 134         struct st_ohci_platform_priv *priv;
 135         struct ohci_hcd *ohci;
 136         int err, irq, clk = 0;
 137
 138         if (usb_disabled())
 139                 return -ENODEV;
 140
 141         irq = platform_get_irq(dev, 0);
 142         if (irq < 0) {
 143                 dev_err(&dev->dev, "no irq provided");
 144                 return irq;
 145         }
 146
 147         res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
 148         if (!res_mem) {
 149                 dev_err(&dev->dev, "no memory resource provided");
 150                 return -ENXIO;
 151         }
 152
 153         hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
 154                         dev_name(&dev->dev));
 155         if (!hcd)
 156                 return -ENOMEM;
 157
 158         platform_set_drvdata(dev, hcd);
 159         dev->dev.platform_data = pdata;
 160         priv = hcd_to_ohci_priv(hcd);
 161         ohci = hcd_to_ohci(hcd);
 162
 163         priv->phy = devm_phy_get(&dev->dev, "usb");
 164         if (IS_ERR(priv->phy)) {
 165                 err = PTR_ERR(priv->phy);
 166                 goto err_put_hcd;
 167         }
 168
 169         for (clk = 0; clk < USB_MAX_CLKS; clk++) {
 170                 priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
 171                 if (IS_ERR(priv->clks[clk])) {
 172                         err = PTR_ERR(priv->clks[clk]);
 173                         if (err == -EPROBE_DEFER)
 174                                 goto err_put_clks;
 175                         priv->clks[clk] = NULL;
 176                         break;
 177                 }
 178         }
 179
 180         /* some SoCs don't have a dedicated 48Mhz clock, but those that
 181            do need the rate to be explicitly set */
 182         priv->clk48 = devm_clk_get(&dev->dev, "clk48");
 183         if (IS_ERR(priv->clk48)) {
 184                 dev_info(&dev->dev, "48MHz clk not found\n");
 185                 priv->clk48 = NULL;
 186         }
 187
 188         priv->pwr =
 189                 devm_reset_control_get_optional_shared(&dev->dev, "power");
 190         if (IS_ERR(priv->pwr)) {
 191                 err = PTR_ERR(priv->pwr);
 192                 goto err_put_clks;
 193         }
 194
 195         priv->rst =
 196                 devm_reset_control_get_optional_shared(&dev->dev, "softreset");
 197         if (IS_ERR(priv->rst)) {
 198                 err = PTR_ERR(priv->rst);
 199                 goto err_put_clks;
 200         }
 201
 202         if (pdata->power_on) {
 203                 err = pdata->power_on(dev);
 204                 if (err < 0)
 205                         goto err_power;
 206         }
 207
 208         hcd->rsrc_start = res_mem->start;
 209         hcd->rsrc_len = resource_size(res_mem);
 210
 211         hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
 212         if (IS_ERR(hcd->regs)) {
 213                 err = PTR_ERR(hcd->regs);
 214                 goto err_power;
 215         }
 216         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 217         if (err)
 218                 goto err_power;
 219
 220         device_wakeup_enable(hcd->self.controller);
 221
 222         platform_set_drvdata(dev, hcd);
 223
 224         return err;
 225
 226 err_power:
 227         if (pdata->power_off)
 228                 pdata->power_off(dev);
 229
 230 err_put_clks:
 231         while (--clk >= 0)
 232                 clk_put(priv->clks[clk]);
 233 err_put_hcd:
 234         if (pdata == &ohci_platform_defaults)
 235                 dev->dev.platform_data = NULL;
 236
 237         usb_put_hcd(hcd);
 238
 239         return err;
 240 }
 241
 242 static int st_ohci_platform_remove(struct platform_device *dev)
 243 {
 244         struct usb_hcd *hcd = platform_get_drvdata(dev);
 245         struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
 246         struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
 247         int clk;
 248
 249         usb_remove_hcd(hcd);
 250
 251         if (pdata->power_off)
 252                 pdata->power_off(dev);
 253
 254
 255         for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++)
 256                 clk_put(priv->clks[clk]);
 257
 258         usb_put_hcd(hcd);
 259
 260         if (pdata == &ohci_platform_defaults)
 261                 dev->dev.platform_data = NULL;
 262
 263         return 0;
 264 }
 265
 266 #ifdef CONFIG_PM_SLEEP
 267
 268 static int st_ohci_suspend(struct device *dev)
 269 {
 270         struct usb_hcd *hcd = dev_get_drvdata(dev);
 271         struct usb_ohci_pdata *pdata = dev->platform_data;
 272         struct platform_device *pdev = to_platform_device(dev);
 273         bool do_wakeup = device_may_wakeup(dev);
 274         int ret;
 275
 276         ret = ohci_suspend(hcd, do_wakeup);
 277         if (ret)
 278                 return ret;
 279
 280         if (pdata->power_suspend)
 281                 pdata->power_suspend(pdev);
 282
 283         return ret;
 284 }
 285
 286 static int st_ohci_resume(struct device *dev)
 287 {
 288         struct usb_hcd *hcd = dev_get_drvdata(dev);
 289         struct usb_ohci_pdata *pdata = dev_get_platdata(dev);
 290         struct platform_device *pdev = to_platform_device(dev);
 291         int err;
 292
 293         if (pdata->power_on) {
 294                 err = pdata->power_on(pdev);
 295                 if (err < 0)
 296                         return err;
 297         }
 298
 299         ohci_resume(hcd, false);
 300         return 0;
 301 }
 302
 303 static SIMPLE_DEV_PM_OPS(st_ohci_pm_ops, st_ohci_suspend, st_ohci_resume);
 304
 305 #endif /* CONFIG_PM_SLEEP */
 306
 307 static const struct of_device_id st_ohci_platform_ids[] = {
 308         { .compatible = "st,st-ohci-300x", },
 309         { /* sentinel */ }
 310 };
 311 MODULE_DEVICE_TABLE(of, st_ohci_platform_ids);
 312
 313 static struct platform_driver ohci_platform_driver = {
 314         .probe          = st_ohci_platform_probe,
 315         .remove         = st_ohci_platform_remove,
 316         .shutdown       = usb_hcd_platform_shutdown,
 317         .driver         = {
 318                 .name   = "st-ohci",
 319 #ifdef CONFIG_PM_SLEEP
 320                 .pm     = &st_ohci_pm_ops,
 321 #endif
 322                 .of_match_table = st_ohci_platform_ids,
 323         }
 324 };
 325
 326 static int __init ohci_platform_init(void)
 327 {
 328         if (usb_disabled())
 329                 return -ENODEV;
 330
 331         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 332
 333         ohci_init_driver(&ohci_platform_hc_driver, &platform_overrides);
 334         return platform_driver_register(&ohci_platform_driver);
 335 }
 336 module_init(ohci_platform_init);
 337
 338 static void __exit ohci_platform_cleanup(void)
 339 {
 340         platform_driver_unregister(&ohci_platform_driver);
 341 }
 342 module_exit(ohci_platform_cleanup);
 343
 344 MODULE_DESCRIPTION(DRIVER_DESC);
 345 MODULE_AUTHOR("Peter Griffin <peter.griffin@linaro.org>");
 346 MODULE_LICENSE("GPL");