1 /* 2 * Broadcom specific Advanced Microcontroller Bus 3 * Broadcom USB-core driver (BCMA bus glue) 4 * 5 * Copyright 2011-2012 Hauke Mehrtens <hauke@hauke-m.de> 6 * 7 * Based on ssb-ohci driver 8 * Copyright 2007 Michael Buesch <m@bues.ch> 9 * 10 * Derived from the OHCI-PCI driver 11 * Copyright 1999 Roman Weissgaerber 12 * Copyright 2000-2002 David Brownell 13 * Copyright 1999 Linus Torvalds 14 * Copyright 1999 Gregory P. Smith 15 * 16 * Derived from the USBcore related parts of Broadcom-SB 17 * Copyright 2005-2011 Broadcom Corporation 18 * 19 * Licensed under the GNU/GPL. See COPYING for details. 20 */ 21 #include <linux/bcma/bcma.h> 22 #include <linux/delay.h> 23 #include <linux/platform_device.h> 24 #include <linux/module.h> 25 #include <linux/slab.h> 26 #include <linux/usb/ehci_pdriver.h> 27 #include <linux/usb/ohci_pdriver.h> 28 29 MODULE_AUTHOR("Hauke Mehrtens"); 30 MODULE_DESCRIPTION("Common USB driver for BCMA Bus"); 31 MODULE_LICENSE("GPL"); 32 33 struct bcma_hcd_device { 34 struct platform_device *ehci_dev; 35 struct platform_device *ohci_dev; 36 }; 37 38 /* Wait for bitmask in a register to get set or cleared. 39 * timeout is in units of ten-microseconds. 40 */ 41 static int bcma_wait_bits(struct bcma_device *dev, u16 reg, u32 bitmask, 42 int timeout) 43 { 44 int i; 45 u32 val; 46 47 for (i = 0; i < timeout; i++) { 48 val = bcma_read32(dev, reg); 49 if ((val & bitmask) == bitmask) 50 return 0; 51 udelay(10); 52 } 53 54 return -ETIMEDOUT; 55 } 56 57 static void bcma_hcd_4716wa(struct bcma_device *dev) 58 { 59 #ifdef CONFIG_BCMA_DRIVER_MIPS 60 /* Work around for 4716 failures. */ 61 if (dev->bus->chipinfo.id == 0x4716) { 62 u32 tmp; 63 64 tmp = bcma_cpu_clock(&dev->bus->drv_mips); 65 if (tmp >= 480000000) 66 tmp = 0x1846b; /* set CDR to 0x11(fast) */ 67 else if (tmp == 453000000) 68 tmp = 0x1046b; /* set CDR to 0x10(slow) */ 69 else 70 tmp = 0; 71 72 /* Change Shim mdio control reg to fix host not acking at 73 * high frequencies 74 */ 75 if (tmp) { 76 bcma_write32(dev, 0x524, 0x1); /* write sel to enable */ 77 udelay(500); 78 79 bcma_write32(dev, 0x524, tmp); 80 udelay(500); 81 bcma_write32(dev, 0x524, 0x4ab); 82 udelay(500); 83 bcma_read32(dev, 0x528); 84 bcma_write32(dev, 0x528, 0x80000000); 85 } 86 } 87 #endif /* CONFIG_BCMA_DRIVER_MIPS */ 88 } 89 90 /* based on arch/mips/brcm-boards/bcm947xx/pcibios.c */ 91 static void bcma_hcd_init_chip(struct bcma_device *dev) 92 { 93 u32 tmp; 94 95 /* 96 * USB 2.0 special considerations: 97 * 98 * 1. Since the core supports both OHCI and EHCI functions, it must 99 * only be reset once. 100 * 101 * 2. In addition to the standard SI reset sequence, the Host Control 102 * Register must be programmed to bring the USB core and various 103 * phy components out of reset. 104 */ 105 if (!bcma_core_is_enabled(dev)) { 106 bcma_core_enable(dev, 0); 107 mdelay(10); 108 if (dev->id.rev >= 5) { 109 /* Enable Misc PLL */ 110 tmp = bcma_read32(dev, 0x1e0); 111 tmp |= 0x100; 112 bcma_write32(dev, 0x1e0, tmp); 113 if (bcma_wait_bits(dev, 0x1e0, 1 << 24, 100)) 114 printk(KERN_EMERG "Failed to enable misc PPL!\n"); 115 116 /* Take out of resets */ 117 bcma_write32(dev, 0x200, 0x4ff); 118 udelay(25); 119 bcma_write32(dev, 0x200, 0x6ff); 120 udelay(25); 121 122 /* Make sure digital and AFE are locked in USB PHY */ 123 bcma_write32(dev, 0x524, 0x6b); 124 udelay(50); 125 tmp = bcma_read32(dev, 0x524); 126 udelay(50); 127 bcma_write32(dev, 0x524, 0xab); 128 udelay(50); 129 tmp = bcma_read32(dev, 0x524); 130 udelay(50); 131 bcma_write32(dev, 0x524, 0x2b); 132 udelay(50); 133 tmp = bcma_read32(dev, 0x524); 134 udelay(50); 135 bcma_write32(dev, 0x524, 0x10ab); 136 udelay(50); 137 tmp = bcma_read32(dev, 0x524); 138 139 if (bcma_wait_bits(dev, 0x528, 0xc000, 10000)) { 140 tmp = bcma_read32(dev, 0x528); 141 printk(KERN_EMERG 142 "USB20H mdio_rddata 0x%08x\n", tmp); 143 } 144 bcma_write32(dev, 0x528, 0x80000000); 145 tmp = bcma_read32(dev, 0x314); 146 udelay(265); 147 bcma_write32(dev, 0x200, 0x7ff); 148 udelay(10); 149 150 /* Take USB and HSIC out of non-driving modes */ 151 bcma_write32(dev, 0x510, 0); 152 } else { 153 bcma_write32(dev, 0x200, 0x7ff); 154 155 udelay(1); 156 } 157 158 bcma_hcd_4716wa(dev); 159 } 160 } 161 162 static const struct usb_ehci_pdata ehci_pdata = { 163 }; 164 165 static const struct usb_ohci_pdata ohci_pdata = { 166 }; 167 168 static struct platform_device *bcma_hcd_create_pdev(struct bcma_device *dev, bool ohci, u32 addr) 169 { 170 struct platform_device *hci_dev; 171 struct resource hci_res[2]; 172 int ret = -ENOMEM; 173 174 memset(hci_res, 0, sizeof(hci_res)); 175 176 hci_res[0].start = addr; 177 hci_res[0].end = hci_res[0].start + 0x1000 - 1; 178 hci_res[0].flags = IORESOURCE_MEM; 179 180 hci_res[1].start = dev->irq; 181 hci_res[1].flags = IORESOURCE_IRQ; 182 183 hci_dev = platform_device_alloc(ohci ? "ohci-platform" : 184 "ehci-platform" , 0); 185 if (!hci_dev) 186 return NULL; 187 188 hci_dev->dev.parent = &dev->dev; 189 hci_dev->dev.dma_mask = &hci_dev->dev.coherent_dma_mask; 190 191 ret = platform_device_add_resources(hci_dev, hci_res, 192 ARRAY_SIZE(hci_res)); 193 if (ret) 194 goto err_alloc; 195 if (ohci) 196 ret = platform_device_add_data(hci_dev, &ohci_pdata, 197 sizeof(ohci_pdata)); 198 else 199 ret = platform_device_add_data(hci_dev, &ehci_pdata, 200 sizeof(ehci_pdata)); 201 if (ret) 202 goto err_alloc; 203 ret = platform_device_add(hci_dev); 204 if (ret) 205 goto err_alloc; 206 207 return hci_dev; 208 209 err_alloc: 210 platform_device_put(hci_dev); 211 return ERR_PTR(ret); 212 } 213 214 static int bcma_hcd_probe(struct bcma_device *dev) 215 { 216 int err; 217 u16 chipid_top; 218 u32 ohci_addr; 219 struct bcma_hcd_device *usb_dev; 220 struct bcma_chipinfo *chipinfo; 221 222 chipinfo = &dev->bus->chipinfo; 223 /* USBcores are only connected on embedded devices. */ 224 chipid_top = (chipinfo->id & 0xFF00); 225 if (chipid_top != 0x4700 && chipid_top != 0x5300) 226 return -ENODEV; 227 228 /* TODO: Probably need checks here; is the core connected? */ 229 230 if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) || 231 dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32))) 232 return -EOPNOTSUPP; 233 234 usb_dev = kzalloc(sizeof(struct bcma_hcd_device), GFP_KERNEL); 235 if (!usb_dev) 236 return -ENOMEM; 237 238 bcma_hcd_init_chip(dev); 239 240 /* In AI chips EHCI is addrspace 0, OHCI is 1 */ 241 ohci_addr = dev->addr1; 242 if ((chipinfo->id == 0x5357 || chipinfo->id == 0x4749) 243 && chipinfo->rev == 0) 244 ohci_addr = 0x18009000; 245 246 usb_dev->ohci_dev = bcma_hcd_create_pdev(dev, true, ohci_addr); 247 if (IS_ERR(usb_dev->ohci_dev)) { 248 err = PTR_ERR(usb_dev->ohci_dev); 249 goto err_free_usb_dev; 250 } 251 252 usb_dev->ehci_dev = bcma_hcd_create_pdev(dev, false, dev->addr); 253 if (IS_ERR(usb_dev->ehci_dev)) { 254 err = PTR_ERR(usb_dev->ehci_dev); 255 goto err_unregister_ohci_dev; 256 } 257 258 bcma_set_drvdata(dev, usb_dev); 259 return 0; 260 261 err_unregister_ohci_dev: 262 platform_device_unregister(usb_dev->ohci_dev); 263 err_free_usb_dev: 264 kfree(usb_dev); 265 return err; 266 } 267 268 static void bcma_hcd_remove(struct bcma_device *dev) 269 { 270 struct bcma_hcd_device *usb_dev = bcma_get_drvdata(dev); 271 struct platform_device *ohci_dev = usb_dev->ohci_dev; 272 struct platform_device *ehci_dev = usb_dev->ehci_dev; 273 274 if (ohci_dev) 275 platform_device_unregister(ohci_dev); 276 if (ehci_dev) 277 platform_device_unregister(ehci_dev); 278 279 bcma_core_disable(dev, 0); 280 } 281 282 static void bcma_hcd_shutdown(struct bcma_device *dev) 283 { 284 bcma_core_disable(dev, 0); 285 } 286 287 #ifdef CONFIG_PM 288 289 static int bcma_hcd_suspend(struct bcma_device *dev) 290 { 291 bcma_core_disable(dev, 0); 292 293 return 0; 294 } 295 296 static int bcma_hcd_resume(struct bcma_device *dev) 297 { 298 bcma_core_enable(dev, 0); 299 300 return 0; 301 } 302 303 #else /* !CONFIG_PM */ 304 #define bcma_hcd_suspend NULL 305 #define bcma_hcd_resume NULL 306 #endif /* CONFIG_PM */ 307 308 static const struct bcma_device_id bcma_hcd_table[] = { 309 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_USB20_HOST, BCMA_ANY_REV, BCMA_ANY_CLASS), 310 BCMA_CORETABLE_END 311 }; 312 MODULE_DEVICE_TABLE(bcma, bcma_hcd_table); 313 314 static struct bcma_driver bcma_hcd_driver = { 315 .name = KBUILD_MODNAME, 316 .id_table = bcma_hcd_table, 317 .probe = bcma_hcd_probe, 318 .remove = bcma_hcd_remove, 319 .shutdown = bcma_hcd_shutdown, 320 .suspend = bcma_hcd_suspend, 321 .resume = bcma_hcd_resume, 322 }; 323 324 static int __init bcma_hcd_init(void) 325 { 326 return bcma_driver_register(&bcma_hcd_driver); 327 } 328 module_init(bcma_hcd_init); 329 330 static void __exit bcma_hcd_exit(void) 331 { 332 bcma_driver_unregister(&bcma_hcd_driver); 333 } 334 module_exit(bcma_hcd_exit); 335