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 * port_status[0x0f] = Broadcom-proprietary USB_EHCI_INSNREG00 @ 0x90 112 */ 113 ehci_writel(ehci, 0x00800040, &ehci->regs->port_status[0x10]); 114 ehci_writel(ehci, 0x00000001, &ehci->regs->port_status[0x12]); 115 116 return ehci_setup(hcd); 117 } 118 119 static struct hc_driver __read_mostly ehci_brcm_hc_driver; 120 121 static const struct ehci_driver_overrides brcm_overrides __initconst = { 122 .reset = ehci_brcm_reset, 123 .extra_priv_size = sizeof(struct brcm_priv), 124 }; 125 126 static int ehci_brcm_probe(struct platform_device *pdev) 127 { 128 struct device *dev = &pdev->dev; 129 struct resource *res_mem; 130 struct brcm_priv *priv; 131 struct usb_hcd *hcd; 132 int irq; 133 int err; 134 135 err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); 136 if (err) 137 return err; 138 139 irq = platform_get_irq(pdev, 0); 140 if (irq <= 0) 141 return irq ? irq : -EINVAL; 142 143 /* Hook the hub control routine to work around a bug */ 144 ehci_brcm_hc_driver.hub_control = ehci_brcm_hub_control; 145 146 /* initialize hcd */ 147 hcd = usb_create_hcd(&ehci_brcm_hc_driver, dev, dev_name(dev)); 148 if (!hcd) 149 return -ENOMEM; 150 151 platform_set_drvdata(pdev, hcd); 152 priv = hcd_to_ehci_priv(hcd); 153 154 priv->clk = devm_clk_get_optional(dev, NULL); 155 if (IS_ERR(priv->clk)) { 156 err = PTR_ERR(priv->clk); 157 goto err_hcd; 158 } 159 160 err = clk_prepare_enable(priv->clk); 161 if (err) 162 goto err_hcd; 163 164 hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res_mem); 165 if (IS_ERR(hcd->regs)) { 166 err = PTR_ERR(hcd->regs); 167 goto err_clk; 168 } 169 hcd->rsrc_start = res_mem->start; 170 hcd->rsrc_len = resource_size(res_mem); 171 err = usb_add_hcd(hcd, irq, IRQF_SHARED); 172 if (err) 173 goto err_clk; 174 175 device_wakeup_enable(hcd->self.controller); 176 device_enable_async_suspend(hcd->self.controller); 177 178 return 0; 179 180 err_clk: 181 clk_disable_unprepare(priv->clk); 182 err_hcd: 183 usb_put_hcd(hcd); 184 185 return err; 186 } 187 188 static int ehci_brcm_remove(struct platform_device *dev) 189 { 190 struct usb_hcd *hcd = platform_get_drvdata(dev); 191 struct brcm_priv *priv = hcd_to_ehci_priv(hcd); 192 193 usb_remove_hcd(hcd); 194 clk_disable_unprepare(priv->clk); 195 usb_put_hcd(hcd); 196 return 0; 197 } 198 199 static int __maybe_unused ehci_brcm_suspend(struct device *dev) 200 { 201 int ret; 202 struct usb_hcd *hcd = dev_get_drvdata(dev); 203 struct brcm_priv *priv = hcd_to_ehci_priv(hcd); 204 bool do_wakeup = device_may_wakeup(dev); 205 206 ret = ehci_suspend(hcd, do_wakeup); 207 if (ret) 208 return ret; 209 clk_disable_unprepare(priv->clk); 210 return 0; 211 } 212 213 static int __maybe_unused ehci_brcm_resume(struct device *dev) 214 { 215 struct usb_hcd *hcd = dev_get_drvdata(dev); 216 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 217 struct brcm_priv *priv = hcd_to_ehci_priv(hcd); 218 int err; 219 220 err = clk_prepare_enable(priv->clk); 221 if (err) 222 return err; 223 /* 224 * SWLINUX-1705: Avoid OUT packet underflows during high memory 225 * bus usage 226 * port_status[0x0f] = Broadcom-proprietary USB_EHCI_INSNREG00 227 * @ 0x90 228 */ 229 ehci_writel(ehci, 0x00800040, &ehci->regs->port_status[0x10]); 230 ehci_writel(ehci, 0x00000001, &ehci->regs->port_status[0x12]); 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 = 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"); 281