drivers/usb/dwc3/dwc3-imx8mp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * dwc3-imx8mp.c - NXP imx8mp Specific Glue layer
   4  *
   5  * Copyright (c) 2020 NXP.
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/io.h>
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/of_platform.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/pm_runtime.h>
  16
  17 #include "core.h"
  18
  19 /* USB wakeup registers */
  20 #define USB_WAKEUP_CTRL                 0x00
  21
  22 /* Global wakeup interrupt enable, also used to clear interrupt */
  23 #define USB_WAKEUP_EN                   BIT(31)
  24 /* Wakeup from connect or disconnect, only for superspeed */
  25 #define USB_WAKEUP_SS_CONN              BIT(5)
  26 /* 0 select vbus_valid, 1 select sessvld */
  27 #define USB_WAKEUP_VBUS_SRC_SESS_VAL    BIT(4)
  28 /* Enable signal for wake up from u3 state */
  29 #define USB_WAKEUP_U3_EN                BIT(3)
  30 /* Enable signal for wake up from id change */
  31 #define USB_WAKEUP_ID_EN                BIT(2)
  32 /* Enable signal for wake up from vbus change */
  33 #define USB_WAKEUP_VBUS_EN              BIT(1)
  34 /* Enable signal for wake up from dp/dm change */
  35 #define USB_WAKEUP_DPDM_EN              BIT(0)
  36
  37 #define USB_WAKEUP_EN_MASK              GENMASK(5, 0)
  38
  39 struct dwc3_imx8mp {
  40         struct device                   *dev;
  41         struct platform_device          *dwc3;
  42         void __iomem                    *glue_base;
  43         struct clk                      *hsio_clk;
  44         struct clk                      *suspend_clk;
  45         int                             irq;
  46         bool                            pm_suspended;
  47         bool                            wakeup_pending;
  48 };
  49
  50 static void dwc3_imx8mp_wakeup_enable(struct dwc3_imx8mp *dwc3_imx)
  51 {
  52         struct dwc3     *dwc3 = platform_get_drvdata(dwc3_imx->dwc3);
  53         u32             val;
  54
  55         if (!dwc3)
  56                 return;
  57
  58         val = readl(dwc3_imx->glue_base + USB_WAKEUP_CTRL);
  59
  60         if ((dwc3->current_dr_role == DWC3_GCTL_PRTCAP_HOST) && dwc3->xhci)
  61                 val |= USB_WAKEUP_EN | USB_WAKEUP_SS_CONN |
  62                        USB_WAKEUP_U3_EN | USB_WAKEUP_DPDM_EN;
  63         else if (dwc3->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE)
  64                 val |= USB_WAKEUP_EN | USB_WAKEUP_VBUS_EN |
  65                        USB_WAKEUP_VBUS_SRC_SESS_VAL;
  66
  67         writel(val, dwc3_imx->glue_base + USB_WAKEUP_CTRL);
  68 }
  69
  70 static void dwc3_imx8mp_wakeup_disable(struct dwc3_imx8mp *dwc3_imx)
  71 {
  72         u32 val;
  73
  74         val = readl(dwc3_imx->glue_base + USB_WAKEUP_CTRL);
  75         val &= ~(USB_WAKEUP_EN | USB_WAKEUP_EN_MASK);
  76         writel(val, dwc3_imx->glue_base + USB_WAKEUP_CTRL);
  77 }
  78
  79 static irqreturn_t dwc3_imx8mp_interrupt(int irq, void *_dwc3_imx)
  80 {
  81         struct dwc3_imx8mp      *dwc3_imx = _dwc3_imx;
  82         struct dwc3             *dwc = platform_get_drvdata(dwc3_imx->dwc3);
  83
  84         if (!dwc3_imx->pm_suspended)
  85                 return IRQ_HANDLED;
  86
  87         disable_irq_nosync(dwc3_imx->irq);
  88         dwc3_imx->wakeup_pending = true;
  89
  90         if ((dwc->current_dr_role == DWC3_GCTL_PRTCAP_HOST) && dwc->xhci)
  91                 pm_runtime_resume(&dwc->xhci->dev);
  92         else if (dwc->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE)
  93                 pm_runtime_get(dwc->dev);
  94
  95         return IRQ_HANDLED;
  96 }
  97
  98 static int dwc3_imx8mp_probe(struct platform_device *pdev)
  99 {
 100         struct device           *dev = &pdev->dev;
 101         struct device_node      *dwc3_np, *node = dev->of_node;
 102         struct dwc3_imx8mp      *dwc3_imx;
 103         int                     err, irq;
 104
 105         if (!node) {
 106                 dev_err(dev, "device node not found\n");
 107                 return -EINVAL;
 108         }
 109
 110         dwc3_imx = devm_kzalloc(dev, sizeof(*dwc3_imx), GFP_KERNEL);
 111         if (!dwc3_imx)
 112                 return -ENOMEM;
 113
 114         platform_set_drvdata(pdev, dwc3_imx);
 115
 116         dwc3_imx->dev = dev;
 117
 118         dwc3_imx->glue_base = devm_platform_ioremap_resource(pdev, 0);
 119         if (IS_ERR(dwc3_imx->glue_base))
 120                 return PTR_ERR(dwc3_imx->glue_base);
 121
 122         dwc3_imx->hsio_clk = devm_clk_get(dev, "hsio");
 123         if (IS_ERR(dwc3_imx->hsio_clk)) {
 124                 err = PTR_ERR(dwc3_imx->hsio_clk);
 125                 dev_err(dev, "Failed to get hsio clk, err=%d\n", err);
 126                 return err;
 127         }
 128
 129         err = clk_prepare_enable(dwc3_imx->hsio_clk);
 130         if (err) {
 131                 dev_err(dev, "Failed to enable hsio clk, err=%d\n", err);
 132                 return err;
 133         }
 134
 135         dwc3_imx->suspend_clk = devm_clk_get(dev, "suspend");
 136         if (IS_ERR(dwc3_imx->suspend_clk)) {
 137                 err = PTR_ERR(dwc3_imx->suspend_clk);
 138                 dev_err(dev, "Failed to get suspend clk, err=%d\n", err);
 139                 goto disable_hsio_clk;
 140         }
 141
 142         err = clk_prepare_enable(dwc3_imx->suspend_clk);
 143         if (err) {
 144                 dev_err(dev, "Failed to enable suspend clk, err=%d\n", err);
 145                 goto disable_hsio_clk;
 146         }
 147
 148         irq = platform_get_irq(pdev, 0);
 149         if (irq < 0) {
 150                 err = irq;
 151                 goto disable_clks;
 152         }
 153         dwc3_imx->irq = irq;
 154
 155         err = devm_request_threaded_irq(dev, irq, NULL, dwc3_imx8mp_interrupt,
 156                                         IRQF_ONESHOT, dev_name(dev), dwc3_imx);
 157         if (err) {
 158                 dev_err(dev, "failed to request IRQ #%d --> %d\n", irq, err);
 159                 goto disable_clks;
 160         }
 161
 162         pm_runtime_set_active(dev);
 163         pm_runtime_enable(dev);
 164         err = pm_runtime_get_sync(dev);
 165         if (err < 0)
 166                 goto disable_rpm;
 167
 168         dwc3_np = of_get_child_by_name(node, "dwc3");
 169         if (!dwc3_np) {
 170                 dev_err(dev, "failed to find dwc3 core child\n");
 171                 goto disable_rpm;
 172         }
 173
 174         err = of_platform_populate(node, NULL, NULL, dev);
 175         if (err) {
 176                 dev_err(&pdev->dev, "failed to create dwc3 core\n");
 177                 goto err_node_put;
 178         }
 179
 180         dwc3_imx->dwc3 = of_find_device_by_node(dwc3_np);
 181         if (!dwc3_imx->dwc3) {
 182                 dev_err(dev, "failed to get dwc3 platform device\n");
 183                 err = -ENODEV;
 184                 goto depopulate;
 185         }
 186         of_node_put(dwc3_np);
 187
 188         device_set_wakeup_capable(dev, true);
 189         pm_runtime_put(dev);
 190
 191         return 0;
 192
 193 depopulate:
 194         of_platform_depopulate(dev);
 195 err_node_put:
 196         of_node_put(dwc3_np);
 197 disable_rpm:
 198         pm_runtime_disable(dev);
 199         pm_runtime_put_noidle(dev);
 200 disable_clks:
 201         clk_disable_unprepare(dwc3_imx->suspend_clk);
 202 disable_hsio_clk:
 203         clk_disable_unprepare(dwc3_imx->hsio_clk);
 204
 205         return err;
 206 }
 207
 208 static int dwc3_imx8mp_remove(struct platform_device *pdev)
 209 {
 210         struct dwc3_imx8mp *dwc3_imx = platform_get_drvdata(pdev);
 211         struct device *dev = &pdev->dev;
 212
 213         pm_runtime_get_sync(dev);
 214         of_platform_depopulate(dev);
 215
 216         clk_disable_unprepare(dwc3_imx->suspend_clk);
 217         clk_disable_unprepare(dwc3_imx->hsio_clk);
 218
 219         pm_runtime_disable(dev);
 220         pm_runtime_put_noidle(dev);
 221         platform_set_drvdata(pdev, NULL);
 222
 223         return 0;
 224 }
 225
 226 static int __maybe_unused dwc3_imx8mp_suspend(struct dwc3_imx8mp *dwc3_imx,
 227                                               pm_message_t msg)
 228 {
 229         if (dwc3_imx->pm_suspended)
 230                 return 0;
 231
 232         /* Wakeup enable */
 233         if (PMSG_IS_AUTO(msg) || device_may_wakeup(dwc3_imx->dev))
 234                 dwc3_imx8mp_wakeup_enable(dwc3_imx);
 235
 236         dwc3_imx->pm_suspended = true;
 237
 238         return 0;
 239 }
 240
 241 static int __maybe_unused dwc3_imx8mp_resume(struct dwc3_imx8mp *dwc3_imx,
 242                                              pm_message_t msg)
 243 {
 244         struct dwc3     *dwc = platform_get_drvdata(dwc3_imx->dwc3);
 245         int ret = 0;
 246
 247         if (!dwc3_imx->pm_suspended)
 248                 return 0;
 249
 250         /* Wakeup disable */
 251         dwc3_imx8mp_wakeup_disable(dwc3_imx);
 252         dwc3_imx->pm_suspended = false;
 253
 254         if (dwc3_imx->wakeup_pending) {
 255                 dwc3_imx->wakeup_pending = false;
 256                 if (dwc->current_dr_role == DWC3_GCTL_PRTCAP_DEVICE) {
 257                         pm_runtime_mark_last_busy(dwc->dev);
 258                         pm_runtime_put_autosuspend(dwc->dev);
 259                 } else {
 260                         /*
 261                          * Add wait for xhci switch from suspend
 262                          * clock to normal clock to detect connection.
 263                          */
 264                         usleep_range(9000, 10000);
 265                 }
 266                 enable_irq(dwc3_imx->irq);
 267         }
 268
 269         return ret;
 270 }
 271
 272 static int __maybe_unused dwc3_imx8mp_pm_suspend(struct device *dev)
 273 {
 274         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
 275         int ret;
 276
 277         ret = dwc3_imx8mp_suspend(dwc3_imx, PMSG_SUSPEND);
 278
 279         if (device_may_wakeup(dwc3_imx->dev))
 280                 enable_irq_wake(dwc3_imx->irq);
 281         else
 282                 clk_disable_unprepare(dwc3_imx->suspend_clk);
 283
 284         clk_disable_unprepare(dwc3_imx->hsio_clk);
 285         dev_dbg(dev, "dwc3 imx8mp pm suspend.\n");
 286
 287         return ret;
 288 }
 289
 290 static int __maybe_unused dwc3_imx8mp_pm_resume(struct device *dev)
 291 {
 292         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
 293         int ret;
 294
 295         if (device_may_wakeup(dwc3_imx->dev)) {
 296                 disable_irq_wake(dwc3_imx->irq);
 297         } else {
 298                 ret = clk_prepare_enable(dwc3_imx->suspend_clk);
 299                 if (ret)
 300                         return ret;
 301         }
 302
 303         ret = clk_prepare_enable(dwc3_imx->hsio_clk);
 304         if (ret)
 305                 return ret;
 306
 307         ret = dwc3_imx8mp_resume(dwc3_imx, PMSG_RESUME);
 308
 309         pm_runtime_disable(dev);
 310         pm_runtime_set_active(dev);
 311         pm_runtime_enable(dev);
 312
 313         dev_dbg(dev, "dwc3 imx8mp pm resume.\n");
 314
 315         return ret;
 316 }
 317
 318 static int __maybe_unused dwc3_imx8mp_runtime_suspend(struct device *dev)
 319 {
 320         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
 321
 322         dev_dbg(dev, "dwc3 imx8mp runtime suspend.\n");
 323
 324         return dwc3_imx8mp_suspend(dwc3_imx, PMSG_AUTO_SUSPEND);
 325 }
 326
 327 static int __maybe_unused dwc3_imx8mp_runtime_resume(struct device *dev)
 328 {
 329         struct dwc3_imx8mp *dwc3_imx = dev_get_drvdata(dev);
 330
 331         dev_dbg(dev, "dwc3 imx8mp runtime resume.\n");
 332
 333         return dwc3_imx8mp_resume(dwc3_imx, PMSG_AUTO_RESUME);
 334 }
 335
 336 static const struct dev_pm_ops dwc3_imx8mp_dev_pm_ops = {
 337         SET_SYSTEM_SLEEP_PM_OPS(dwc3_imx8mp_pm_suspend, dwc3_imx8mp_pm_resume)
 338         SET_RUNTIME_PM_OPS(dwc3_imx8mp_runtime_suspend,
 339                            dwc3_imx8mp_runtime_resume, NULL)
 340 };
 341
 342 static const struct of_device_id dwc3_imx8mp_of_match[] = {
 343         { .compatible = "fsl,imx8mp-dwc3", },
 344         {},
 345 };
 346 MODULE_DEVICE_TABLE(of, dwc3_imx8mp_of_match);
 347
 348 static struct platform_driver dwc3_imx8mp_driver = {
 349         .probe          = dwc3_imx8mp_probe,
 350         .remove         = dwc3_imx8mp_remove,
 351         .driver         = {
 352                 .name   = "imx8mp-dwc3",
 353                 .pm     = &dwc3_imx8mp_dev_pm_ops,
 354                 .of_match_table = dwc3_imx8mp_of_match,
 355         },
 356 };
 357
 358 module_platform_driver(dwc3_imx8mp_driver);
 359
 360 MODULE_ALIAS("platform:imx8mp-dwc3");
 361 MODULE_AUTHOR("jun.li@nxp.com");
 362 MODULE_LICENSE("GPL v2");
 363 MODULE_DESCRIPTION("DesignWare USB3 imx8mp Glue Layer");