drivers/usb/cdns3/cdns3-plat.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence USBSS DRD Driver.
   4  *
   5  * Copyright (C) 2018-2020 Cadence.
   6  * Copyright (C) 2017-2018 NXP
   7  * Copyright (C) 2019 Texas Instruments
   8  *
   9  *
  10  * Author: Peter Chen <peter.chen@nxp.com>
  11  *         Pawel Laszczak <pawell@cadence.com>
  12  *         Roger Quadros <rogerq@ti.com>
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/irq.h>
  17 #include <linux/kernel.h>
  18 #include <linux/of.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/pm_runtime.h>
  21
  22 #include "core.h"
  23 #include "gadget-export.h"
  24 #include "drd.h"
  25
  26 static int set_phy_power_on(struct cdns *cdns)
  27 {
  28         int ret;
  29
  30         ret = phy_power_on(cdns->usb2_phy);
  31         if (ret)
  32                 return ret;
  33
  34         ret = phy_power_on(cdns->usb3_phy);
  35         if (ret)
  36                 phy_power_off(cdns->usb2_phy);
  37
  38         return ret;
  39 }
  40
  41 static void set_phy_power_off(struct cdns *cdns)
  42 {
  43         phy_power_off(cdns->usb3_phy);
  44         phy_power_off(cdns->usb2_phy);
  45 }
  46
  47 /**
  48  * cdns3_plat_probe - probe for cdns3 core device
  49  * @pdev: Pointer to cdns3 core platform device
  50  *
  51  * Returns 0 on success otherwise negative errno
  52  */
  53 static int cdns3_plat_probe(struct platform_device *pdev)
  54 {
  55         struct device *dev = &pdev->dev;
  56         struct resource *res;
  57         struct cdns *cdns;
  58         void __iomem *regs;
  59         int ret;
  60
  61         cdns = devm_kzalloc(dev, sizeof(*cdns), GFP_KERNEL);
  62         if (!cdns)
  63                 return -ENOMEM;
  64
  65         cdns->dev = dev;
  66         cdns->pdata = dev_get_platdata(dev);
  67
  68         platform_set_drvdata(pdev, cdns);
  69
  70         ret = platform_get_irq_byname(pdev, "host");
  71         if (ret < 0)
  72                 return ret;
  73
  74         cdns->xhci_res[0].start = ret;
  75         cdns->xhci_res[0].end = ret;
  76         cdns->xhci_res[0].flags = IORESOURCE_IRQ | irq_get_trigger_type(ret);
  77         cdns->xhci_res[0].name = "host";
  78
  79         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "xhci");
  80         if (!res) {
  81                 dev_err(dev, "couldn't get xhci resource\n");
  82                 return -ENXIO;
  83         }
  84
  85         cdns->xhci_res[1] = *res;
  86
  87         cdns->dev_irq = platform_get_irq_byname(pdev, "peripheral");
  88
  89         if (cdns->dev_irq < 0)
  90                 return dev_err_probe(dev, cdns->dev_irq,
  91                                      "Failed to get peripheral IRQ\n");
  92
  93         regs = devm_platform_ioremap_resource_byname(pdev, "dev");
  94         if (IS_ERR(regs))
  95                 return dev_err_probe(dev, PTR_ERR(regs),
  96                                      "Failed to get dev base\n");
  97
  98         cdns->dev_regs  = regs;
  99
 100         cdns->otg_irq = platform_get_irq_byname(pdev, "otg");
 101         if (cdns->otg_irq < 0)
 102                 return dev_err_probe(dev, cdns->otg_irq,
 103                                      "Failed to get otg IRQ\n");
 104
 105         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "otg");
 106         if (!res) {
 107                 dev_err(dev, "couldn't get otg resource\n");
 108                 return -ENXIO;
 109         }
 110
 111         cdns->phyrst_a_enable = device_property_read_bool(dev, "cdns,phyrst-a-enable");
 112
 113         cdns->otg_res = *res;
 114
 115         cdns->wakeup_irq = platform_get_irq_byname_optional(pdev, "wakeup");
 116         if (cdns->wakeup_irq == -EPROBE_DEFER)
 117                 return cdns->wakeup_irq;
 118
 119         if (cdns->wakeup_irq < 0) {
 120                 dev_dbg(dev, "couldn't get wakeup irq\n");
 121                 cdns->wakeup_irq = 0x0;
 122         }
 123
 124         cdns->usb2_phy = devm_phy_optional_get(dev, "cdns3,usb2-phy");
 125         if (IS_ERR(cdns->usb2_phy))
 126                 return dev_err_probe(dev, PTR_ERR(cdns->usb2_phy),
 127                                      "Failed to get cdn3,usb2-phy\n");
 128
 129         ret = phy_init(cdns->usb2_phy);
 130         if (ret)
 131                 return ret;
 132
 133         cdns->usb3_phy = devm_phy_optional_get(dev, "cdns3,usb3-phy");
 134         if (IS_ERR(cdns->usb3_phy))
 135                 return dev_err_probe(dev, PTR_ERR(cdns->usb3_phy),
 136                                      "Failed to get cdn3,usb3-phy\n");
 137
 138         ret = phy_init(cdns->usb3_phy);
 139         if (ret)
 140                 goto err_phy3_init;
 141
 142         ret = set_phy_power_on(cdns);
 143         if (ret)
 144                 goto err_phy_power_on;
 145
 146         cdns->gadget_init = cdns3_gadget_init;
 147
 148         ret = cdns_init(cdns);
 149         if (ret)
 150                 goto err_cdns_init;
 151
 152         device_set_wakeup_capable(dev, true);
 153         pm_runtime_set_active(dev);
 154         pm_runtime_enable(dev);
 155         if (!(cdns->pdata && (cdns->pdata->quirks & CDNS3_DEFAULT_PM_RUNTIME_ALLOW)))
 156                 pm_runtime_forbid(dev);
 157
 158         /*
 159          * The controller needs less time between bus and controller suspend,
 160          * and we also needs a small delay to avoid frequently entering low
 161          * power mode.
 162          */
 163         pm_runtime_set_autosuspend_delay(dev, 20);
 164         pm_runtime_mark_last_busy(dev);
 165         pm_runtime_use_autosuspend(dev);
 166
 167         return 0;
 168
 169 err_cdns_init:
 170         set_phy_power_off(cdns);
 171 err_phy_power_on:
 172         phy_exit(cdns->usb3_phy);
 173 err_phy3_init:
 174         phy_exit(cdns->usb2_phy);
 175
 176         return ret;
 177 }
 178
 179 /**
 180  * cdns3_plat_remove() - unbind drd driver and clean up
 181  * @pdev: Pointer to Linux platform device
 182  *
 183  * Returns 0 on success otherwise negative errno
 184  */
 185 static void cdns3_plat_remove(struct platform_device *pdev)
 186 {
 187         struct cdns *cdns = platform_get_drvdata(pdev);
 188         struct device *dev = cdns->dev;
 189
 190         pm_runtime_get_sync(dev);
 191         pm_runtime_disable(dev);
 192         pm_runtime_put_noidle(dev);
 193         cdns_remove(cdns);
 194         set_phy_power_off(cdns);
 195         phy_exit(cdns->usb2_phy);
 196         phy_exit(cdns->usb3_phy);
 197 }
 198
 199 #ifdef CONFIG_PM
 200
 201 static int cdns3_set_platform_suspend(struct device *dev,
 202                                       bool suspend, bool wakeup)
 203 {
 204         struct cdns *cdns = dev_get_drvdata(dev);
 205         int ret = 0;
 206
 207         if (cdns->pdata && cdns->pdata->platform_suspend)
 208                 ret = cdns->pdata->platform_suspend(dev, suspend, wakeup);
 209
 210         return ret;
 211 }
 212
 213 static int cdns3_controller_suspend(struct device *dev, pm_message_t msg)
 214 {
 215         struct cdns *cdns = dev_get_drvdata(dev);
 216         bool wakeup;
 217         unsigned long flags;
 218
 219         if (cdns->in_lpm)
 220                 return 0;
 221
 222         if (PMSG_IS_AUTO(msg))
 223                 wakeup = true;
 224         else
 225                 wakeup = device_may_wakeup(dev);
 226
 227         cdns3_set_platform_suspend(cdns->dev, true, wakeup);
 228         set_phy_power_off(cdns);
 229         spin_lock_irqsave(&cdns->lock, flags);
 230         cdns->in_lpm = true;
 231         spin_unlock_irqrestore(&cdns->lock, flags);
 232         dev_dbg(cdns->dev, "%s ends\n", __func__);
 233
 234         return 0;
 235 }
 236
 237 static int cdns3_controller_resume(struct device *dev, pm_message_t msg)
 238 {
 239         struct cdns *cdns = dev_get_drvdata(dev);
 240         int ret;
 241         unsigned long flags;
 242
 243         if (!cdns->in_lpm)
 244                 return 0;
 245
 246         if (cdns_power_is_lost(cdns)) {
 247                 phy_exit(cdns->usb2_phy);
 248                 ret = phy_init(cdns->usb2_phy);
 249                 if (ret)
 250                         return ret;
 251
 252                 phy_exit(cdns->usb3_phy);
 253                 ret = phy_init(cdns->usb3_phy);
 254                 if (ret)
 255                         return ret;
 256         }
 257
 258         ret = set_phy_power_on(cdns);
 259         if (ret)
 260                 return ret;
 261
 262         cdns3_set_platform_suspend(cdns->dev, false, false);
 263
 264         spin_lock_irqsave(&cdns->lock, flags);
 265         cdns_resume(cdns);
 266         cdns->in_lpm = false;
 267         spin_unlock_irqrestore(&cdns->lock, flags);
 268         cdns_set_active(cdns, !PMSG_IS_AUTO(msg));
 269         if (cdns->wakeup_pending) {
 270                 cdns->wakeup_pending = false;
 271                 enable_irq(cdns->wakeup_irq);
 272         }
 273         dev_dbg(cdns->dev, "%s ends\n", __func__);
 274
 275         return ret;
 276 }
 277
 278 static int cdns3_plat_runtime_suspend(struct device *dev)
 279 {
 280         return cdns3_controller_suspend(dev, PMSG_AUTO_SUSPEND);
 281 }
 282
 283 static int cdns3_plat_runtime_resume(struct device *dev)
 284 {
 285         return cdns3_controller_resume(dev, PMSG_AUTO_RESUME);
 286 }
 287
 288 #ifdef CONFIG_PM_SLEEP
 289
 290 static int cdns3_plat_suspend(struct device *dev)
 291 {
 292         struct cdns *cdns = dev_get_drvdata(dev);
 293         int ret;
 294
 295         cdns_suspend(cdns);
 296
 297         ret = cdns3_controller_suspend(dev, PMSG_SUSPEND);
 298         if (ret)
 299                 return ret;
 300
 301         if (device_may_wakeup(dev) && cdns->wakeup_irq)
 302                 enable_irq_wake(cdns->wakeup_irq);
 303
 304         return ret;
 305 }
 306
 307 static int cdns3_plat_resume(struct device *dev)
 308 {
 309         return cdns3_controller_resume(dev, PMSG_RESUME);
 310 }
 311 #endif /* CONFIG_PM_SLEEP */
 312 #endif /* CONFIG_PM */
 313
 314 static const struct dev_pm_ops cdns3_pm_ops = {
 315         SET_SYSTEM_SLEEP_PM_OPS(cdns3_plat_suspend, cdns3_plat_resume)
 316         SET_RUNTIME_PM_OPS(cdns3_plat_runtime_suspend,
 317                            cdns3_plat_runtime_resume, NULL)
 318 };
 319
 320 #ifdef CONFIG_OF
 321 static const struct of_device_id of_cdns3_match[] = {
 322         { .compatible = "cdns,usb3" },
 323         { },
 324 };
 325 MODULE_DEVICE_TABLE(of, of_cdns3_match);
 326 #endif
 327
 328 static struct platform_driver cdns3_driver = {
 329         .probe          = cdns3_plat_probe,
 330         .remove         = cdns3_plat_remove,
 331         .driver         = {
 332                 .name   = "cdns-usb3",
 333                 .of_match_table = of_match_ptr(of_cdns3_match),
 334                 .pm     = &cdns3_pm_ops,
 335         },
 336 };
 337
 338 module_platform_driver(cdns3_driver);
 339
 340 MODULE_ALIAS("platform:cdns3");
 341 MODULE_AUTHOR("Pawel Laszczak <pawell@cadence.com>");
 342 MODULE_LICENSE("GPL v2");
 343 MODULE_DESCRIPTION("Cadence USB3 DRD Controller Driver");