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         u32 temp;
  66
  67         temp = (wIndex & 0xff) - 1;
  68         if (temp >= HCS_N_PORTS_MAX)    /* Avoid index-out-of-bounds warning */
  69                 temp = 0;
  70         status_reg = &ehci->regs->port_status[temp];
  71
  72         /*
  73          * RESUME is cleared when GetPortStatus() is called 20ms after start
  74          * of RESUME
  75          */
  76         if ((typeReq == GetPortStatus) &&
  77             (wIndex && wIndex <= ports) &&
  78             ehci->reset_done[wIndex-1] &&
  79             time_after_eq(jiffies, ehci->reset_done[wIndex-1]) &&
  80             (ehci_readl(ehci, status_reg) & PORT_RESUME)) {
  81
  82                 /*
  83                  * to make sure we are not interrupted until RESUME bit
  84                  * is cleared, disable interrupts on current CPU
  85                  */
  86                 ehci_dbg(ehci, "SOF alignment workaround\n");
  87                 irq_disabled = 1;
  88                 local_irq_save(flags);
  89                 ehci_brcm_wait_for_sof(ehci, 5);
  90         }
  91         retval = ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
  92         if (irq_disabled)
  93                 local_irq_restore(flags);
  94         return retval;
  95 }
  96
  97 static int ehci_brcm_reset(struct usb_hcd *hcd)
  98 {
  99         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 100         int len;
 101
 102         ehci->big_endian_mmio = 1;
 103
 104         ehci->caps = (void __iomem *)hcd->regs;
 105         len = HC_LENGTH(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase));
 106         ehci->regs = (void __iomem *)(hcd->regs + len);
 107
 108         /* This fixes the lockup during reboot due to prior interrupts */
 109         ehci_writel(ehci, CMD_RESET, &ehci->regs->command);
 110         mdelay(10);
 111
 112         /*
 113          * SWLINUX-1705: Avoid OUT packet underflows during high memory
 114          *   bus usage
 115          */
 116         ehci_writel(ehci, 0x00800040, &ehci->regs->brcm_insnreg[1]);
 117         ehci_writel(ehci, 0x00000001, &ehci->regs->brcm_insnreg[3]);
 118
 119         return ehci_setup(hcd);
 120 }
 121
 122 static struct hc_driver __read_mostly ehci_brcm_hc_driver;
 123
 124 static const struct ehci_driver_overrides brcm_overrides __initconst = {
 125         .reset = ehci_brcm_reset,
 126         .extra_priv_size = sizeof(struct brcm_priv),
 127 };
 128
 129 static int ehci_brcm_probe(struct platform_device *pdev)
 130 {
 131         struct device *dev = &pdev->dev;
 132         struct resource *res_mem;
 133         struct brcm_priv *priv;
 134         struct usb_hcd *hcd;
 135         int irq;
 136         int err;
 137
 138         err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
 139         if (err)
 140                 return err;
 141
 142         irq = platform_get_irq(pdev, 0);
 143         if (irq < 0)
 144                 return irq;
 145
 146         /* Hook the hub control routine to work around a bug */
 147         ehci_brcm_hc_driver.hub_control = ehci_brcm_hub_control;
 148
 149         /* initialize hcd */
 150         hcd = usb_create_hcd(&ehci_brcm_hc_driver, dev, dev_name(dev));
 151         if (!hcd)
 152                 return -ENOMEM;
 153
 154         platform_set_drvdata(pdev, hcd);
 155         priv = hcd_to_ehci_priv(hcd);
 156
 157         priv->clk = devm_clk_get_optional(dev, NULL);
 158         if (IS_ERR(priv->clk)) {
 159                 err = PTR_ERR(priv->clk);
 160                 goto err_hcd;
 161         }
 162
 163         err = clk_prepare_enable(priv->clk);
 164         if (err)
 165                 goto err_hcd;
 166
 167         hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res_mem);
 168         if (IS_ERR(hcd->regs)) {
 169                 err = PTR_ERR(hcd->regs);
 170                 goto err_clk;
 171         }
 172         hcd->rsrc_start = res_mem->start;
 173         hcd->rsrc_len = resource_size(res_mem);
 174         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 175         if (err)
 176                 goto err_clk;
 177
 178         device_wakeup_enable(hcd->self.controller);
 179         device_enable_async_suspend(hcd->self.controller);
 180
 181         return 0;
 182
 183 err_clk:
 184         clk_disable_unprepare(priv->clk);
 185 err_hcd:
 186         usb_put_hcd(hcd);
 187
 188         return err;
 189 }
 190
 191 static void ehci_brcm_remove(struct platform_device *dev)
 192 {
 193         struct usb_hcd *hcd = platform_get_drvdata(dev);
 194         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 195
 196         usb_remove_hcd(hcd);
 197         clk_disable_unprepare(priv->clk);
 198         usb_put_hcd(hcd);
 199 }
 200
 201 static int __maybe_unused ehci_brcm_suspend(struct device *dev)
 202 {
 203         int ret;
 204         struct usb_hcd *hcd = dev_get_drvdata(dev);
 205         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 206         bool do_wakeup = device_may_wakeup(dev);
 207
 208         ret = ehci_suspend(hcd, do_wakeup);
 209         if (ret)
 210                 return ret;
 211         clk_disable_unprepare(priv->clk);
 212         return 0;
 213 }
 214
 215 static int __maybe_unused ehci_brcm_resume(struct device *dev)
 216 {
 217         struct usb_hcd *hcd = dev_get_drvdata(dev);
 218         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 219         struct brcm_priv *priv = hcd_to_ehci_priv(hcd);
 220         int err;
 221
 222         err = clk_prepare_enable(priv->clk);
 223         if (err)
 224                 return err;
 225         /*
 226          * SWLINUX-1705: Avoid OUT packet underflows during high memory
 227          *   bus usage
 228          */
 229         ehci_writel(ehci, 0x00800040, &ehci->regs->brcm_insnreg[1]);
 230         ehci_writel(ehci, 0x00000001, &ehci->regs->brcm_insnreg[3]);
 231
 232         ehci_resume(hcd, false);
 233
 234         pm_runtime_disable(dev);
 235         pm_runtime_set_active(dev);
 236         pm_runtime_enable(dev);
 237
 238         return 0;
 239 }
 240
 241 static SIMPLE_DEV_PM_OPS(ehci_brcm_pm_ops, ehci_brcm_suspend,
 242                 ehci_brcm_resume);
 243
 244 static const struct of_device_id brcm_ehci_of_match[] = {
 245         { .compatible = "brcm,ehci-brcm-v2", },
 246         { .compatible = "brcm,bcm7445-ehci", },
 247         {}
 248 };
 249
 250 static struct platform_driver ehci_brcm_driver = {
 251         .probe          = ehci_brcm_probe,
 252         .remove_new     = ehci_brcm_remove,
 253         .shutdown       = usb_hcd_platform_shutdown,
 254         .driver         = {
 255                 .name   = "ehci-brcm",
 256                 .pm     = &ehci_brcm_pm_ops,
 257                 .of_match_table = brcm_ehci_of_match,
 258         }
 259 };
 260
 261 static int __init ehci_brcm_init(void)
 262 {
 263         if (usb_disabled())
 264                 return -ENODEV;
 265
 266         ehci_init_driver(&ehci_brcm_hc_driver, &brcm_overrides);
 267         return platform_driver_register(&ehci_brcm_driver);
 268 }
 269 module_init(ehci_brcm_init);
 270
 271 static void __exit ehci_brcm_exit(void)
 272 {
 273         platform_driver_unregister(&ehci_brcm_driver);
 274 }
 275 module_exit(ehci_brcm_exit);
 276
 277 MODULE_ALIAS("platform:ehci-brcm");
 278 MODULE_DESCRIPTION("EHCI Broadcom STB driver");
 279 MODULE_AUTHOR("Al Cooper");
 280 MODULE_LICENSE("GPL");