drivers/usb/host/ehci-brcm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020, Broadcom */
   3
   4 #include <linux/clk.h>
   5 #include <linux/dma-mapping.h>
   6 #include <linux/err.h>
   7 #include <linux/kernel.h>
   8 #include <linux/io.h>
   9 #include <linux/module.h>
  10 #include <linux/platform_device.h>
  11 #include <linux/usb.h>
  12 #include <linux/usb/hcd.h>
  13 #include <linux/iopoll.h>
  14
  15 #include "ehci.h"
  16
  17 #define hcd_to_ehci_priv(h) ((struct brcm_priv *)hcd_to_ehci(h)->priv)
  18
  19 struct brcm_priv {
  20         struct clk *clk;
  21 };
  22
  23 /*
  24  * ehci_brcm_wait_for_sof
  25  * Wait for start of next microframe, then wait extra delay microseconds
  26  */
  27 static inline void ehci_brcm_wait_for_sof(struct ehci_hcd *ehci, u32 delay)
  28 {
  29         u32 frame_idx = ehci_readl(ehci, &ehci->regs->frame_index);
  30         u32 val;
  31         int res;
  32
  33         /* Wait for next microframe (every 125 usecs) */
  34         res = readl_relaxed_poll_timeout(&ehci->regs->frame_index, val,
  35                                          val != frame_idx, 1, 130);
  36         if (res)
  37                 ehci_err(ehci, "Error waiting for SOF\n");
  38         udelay(delay);
  39 }
  40
  41 /*
  42  * ehci_brcm_hub_control
  43  * The EHCI controller has a bug where it can violate the SOF
  44  * interval between the first two SOF's transmitted after resume
  45  * if the resume occurs near the end of the microframe. This causees
  46  * the controller to detect babble on the suspended port and
  47  * will eventually cause the controller to reset the port.
  48  * The fix is to Intercept the echi-hcd request to complete RESUME and
  49  * align it to the start of the next microframe.
  50  * See SWLINUX-1909 for more details
  51  */
  52 static int ehci_brcm_hub_control(
  53         struct usb_hcd  *hcd,
  54         u16             typeReq,
  55         u16             wValue,
  56         u16             wIndex,
  57         char            *buf,
  58         u16             wLength)
  59 {
  60         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
  61         int             ports = HCS_N_PORTS(ehci->hcs_params);
  62         u32 __iomem     *status_reg;
  63         unsigned long flags;
  64         int retval, irq_disabled = 0;
  65
  66         status_reg = &ehci->regs->port_status[(wIndex & 0xff) - 1];
  67
  68         /*
  69          * RESUME is cleared when GetPortStatus() is called 20ms after start
  70          * of RESUME
  71          */
  72         if ((typeReq == GetPortStatus) &&
  73             (wIndex && wIndex <= ports) &&
  74             ehci->reset_done[wIndex-1] &&
  75             time_after_eq(jiffies, ehci->reset_done[wIndex-1]) &&
  76             (ehci_readl(ehci, status_reg) & PORT_RESUME)) {
  77
  78                 /*
  79                  * to make sure we are not interrupted until RESUME bit
  80                  * is cleared, disable interrupts on current CPU
  81                  */
  82                 ehci_dbg(ehci, "SOF alignment workaround\n");
  83                 irq_disabled = 1;
  84                 local_irq_save(flags);
  85                 ehci_brcm_wait_for_sof(ehci, 5);
  86         }
  87         retval = ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
  88         if (irq_disabled)
  89                 local_irq_restore(flags);
  90         return retval;
  91 }
  92
  93 static int ehci_brcm_reset(struct usb_hcd *hcd)
  94 {
  95         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
  96         int len;
  97
  98         ehci->big_endian_mmio = 1;
  99
 100         ehci->caps = (void __iomem *)hcd->regs;
 101         len = HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 102         ehci->regs = (void __iomem *)(hcd->regs + len);
 103
 104         /* This fixes the lockup during reboot due to prior interrupts */
 105         ehci_writel(ehci, CMD_RESET, &ehci->regs->command);
 106         mdelay(10);
 107
 108         /*
 109          * SWLINUX-1705: Avoid OUT packet underflows during high memory
 110          *   bus usage
 111          */
 112         ehci_writel(ehci, 0x00800040, &ehci->regs->brcm_insnreg[1]);
 113         ehci_writel(ehci, 0x00000001, &ehci->regs->brcm_insnreg[3]);
 114
 115         return ehci_setup(hcd);
 116 }
 117
 118 static struct hc_driver __read_mostly ehci_brcm_hc_driver;
 119
 120 static const struct ehci_driver_overrides brcm_overrides __initconst = {
 121         .reset = ehci_brcm_reset,
 122         .extra_priv_size = sizeof(struct brcm_priv),
 123 };
 124
 125 static int ehci_brcm_probe(struct platform_device *pdev)
 126 {
 127         struct device *dev = &pdev->dev;
 128         struct resource *res_mem;
 129         struct brcm_priv *priv;
 130         struct usb_hcd *hcd;
 131         int irq;
 132         int err;
 133
 134         err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 135         if (err)
 136                 return err;
 137
 138         irq = platform_get_irq(pdev, 0);
 139         if (irq <= 0)
 140                 return irq ? irq : -EINVAL;
 141
 142         /* Hook the hub control routine to work around a bug */
 143         ehci_brcm_hc_driver.hub_control = ehci_brcm_hub_control;
 144
 145         /* initialize hcd */
 146         hcd = usb_create_hcd(&ehci_brcm_hc_driver, dev, dev_name(dev));
 147         if (!hcd)
 148                 return -ENOMEM;
 149
 150         platform_set_drvdata(pdev, hcd);
 151         priv = hcd_to_ehci_priv(hcd);
 152
 153         priv->clk = devm_clk_get_optional(dev, NULL);
 154         if (IS_ERR(priv->clk)) {
 155                 err = PTR_ERR(priv->clk);
 156                 goto err_hcd;
 157         }
 158
 159         err = clk_prepare_enable(priv->clk);
 160         if (err)
 161                 goto err_hcd;
 162
 163         hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res_mem);
 164         if (IS_ERR(hcd->regs)) {
 165                 err = PTR_ERR(hcd->regs);
 166                 goto err_clk;
 167         }
 168         hcd->rsrc_start = res_mem->start;
 169         hcd->rsrc_len = resource_size(res_mem);
 170         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 171         if (err)
 172                 goto err_clk;
 173
 174         device_wakeup_enable(hcd->self.controller);
 175         device_enable_async_suspend(hcd->self.controller);
 176
 177         return 0;
 178
 179 err_clk:
 180         clk_disable_unprepare(priv->clk);
 181 err_hcd:
 182         usb_put_hcd(hcd);
 183
 184         return err;
 185 }
 186
 187 static int ehci_brcm_remove(struct platform_device *dev)
 188 {
 189         struct usb_hcd *hcd = platform_get_drvdata(dev);
 190         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 191
 192         usb_remove_hcd(hcd);
 193         clk_disable_unprepare(priv->clk);
 194         usb_put_hcd(hcd);
 195         return 0;
 196 }
 197
 198 static int __maybe_unused ehci_brcm_suspend(struct device *dev)
 199 {
 200         int ret;
 201         struct usb_hcd *hcd = dev_get_drvdata(dev);
 202         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 203         bool do_wakeup = device_may_wakeup(dev);
 204
 205         ret = ehci_suspend(hcd, do_wakeup);
 206         if (ret)
 207                 return ret;
 208         clk_disable_unprepare(priv->clk);
 209         return 0;
 210 }
 211
 212 static int __maybe_unused ehci_brcm_resume(struct device *dev)
 213 {
 214         struct usb_hcd *hcd = dev_get_drvdata(dev);
 215         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 216         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 217         int err;
 218
 219         err = clk_prepare_enable(priv->clk);
 220         if (err)
 221                 return err;
 222         /*
 223          * SWLINUX-1705: Avoid OUT packet underflows during high memory
 224          *   bus usage
 225          */
 226         ehci_writel(ehci, 0x00800040, &ehci->regs->brcm_insnreg[1]);
 227         ehci_writel(ehci, 0x00000001, &ehci->regs->brcm_insnreg[3]);
 228
 229         ehci_resume(hcd, false);
 230
 231         pm_runtime_disable(dev);
 232         pm_runtime_set_active(dev);
 233         pm_runtime_enable(dev);
 234
 235         return 0;
 236 }
 237
 238 static SIMPLE_DEV_PM_OPS(ehci_brcm_pm_ops, ehci_brcm_suspend,
 239                 ehci_brcm_resume);
 240
 241 static const struct of_device_id brcm_ehci_of_match[] = {
 242         { .compatible = "brcm,ehci-brcm-v2", },
 243         { .compatible = "brcm,bcm7445-ehci", },
 244         {}
 245 };
 246
 247 static struct platform_driver ehci_brcm_driver = {
 248         .probe          = ehci_brcm_probe,
 249         .remove         = ehci_brcm_remove,
 250         .shutdown       = usb_hcd_platform_shutdown,
 251         .driver         = {
 252                 .name   = "ehci-brcm",
 253                 .pm     = &ehci_brcm_pm_ops,
 254                 .of_match_table = brcm_ehci_of_match,
 255         }
 256 };
 257
 258 static int __init ehci_brcm_init(void)
 259 {
 260         if (usb_disabled())
 261                 return -ENODEV;
 262
 263         ehci_init_driver(&ehci_brcm_hc_driver, &brcm_overrides);
 264         return platform_driver_register(&ehci_brcm_driver);
 265 }
 266 module_init(ehci_brcm_init);
 267
 268 static void __exit ehci_brcm_exit(void)
 269 {
 270         platform_driver_unregister(&ehci_brcm_driver);
 271 }
 272 module_exit(ehci_brcm_exit);
 273
 274 MODULE_ALIAS("platform:ehci-brcm");
 275 MODULE_DESCRIPTION("EHCI Broadcom STB driver");
 276 MODULE_AUTHOR("Al Cooper");
 277 MODULE_LICENSE("GPL");