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"); 278