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