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 __devinit 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 __devinit 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 * __devinit 169 bcma_hcd_create_pdev(struct bcma_device *dev, bool ohci, u32 addr) 170 { 171 struct platform_device *hci_dev; 172 struct resource hci_res[2]; 173 int ret = -ENOMEM; 174 175 memset(hci_res, 0, sizeof(hci_res)); 176 177 hci_res[0].start = addr; 178 hci_res[0].end = hci_res[0].start + 0x1000 - 1; 179 hci_res[0].flags = IORESOURCE_MEM; 180 181 hci_res[1].start = dev->irq; 182 hci_res[1].flags = IORESOURCE_IRQ; 183 184 hci_dev = platform_device_alloc(ohci ? "ohci-platform" : 185 "ehci-platform" , 0); 186 if (!hci_dev) 187 return NULL; 188 189 hci_dev->dev.parent = &dev->dev; 190 hci_dev->dev.dma_mask = &hci_dev->dev.coherent_dma_mask; 191 192 ret = platform_device_add_resources(hci_dev, hci_res, 193 ARRAY_SIZE(hci_res)); 194 if (ret) 195 goto err_alloc; 196 if (ohci) 197 ret = platform_device_add_data(hci_dev, &ohci_pdata, 198 sizeof(ohci_pdata)); 199 else 200 ret = platform_device_add_data(hci_dev, &ehci_pdata, 201 sizeof(ehci_pdata)); 202 if (ret) 203 goto err_alloc; 204 ret = platform_device_add(hci_dev); 205 if (ret) 206 goto err_alloc; 207 208 return hci_dev; 209 210 err_alloc: 211 platform_device_put(hci_dev); 212 return ERR_PTR(ret); 213 } 214 215 static int __devinit bcma_hcd_probe(struct bcma_device *dev) 216 { 217 int err; 218 u16 chipid_top; 219 u32 ohci_addr; 220 struct bcma_hcd_device *usb_dev; 221 struct bcma_chipinfo *chipinfo; 222 223 chipinfo = &dev->bus->chipinfo; 224 /* USBcores are only connected on embedded devices. */ 225 chipid_top = (chipinfo->id & 0xFF00); 226 if (chipid_top != 0x4700 && chipid_top != 0x5300) 227 return -ENODEV; 228 229 /* TODO: Probably need checks here; is the core connected? */ 230 231 if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) || 232 dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32))) 233 return -EOPNOTSUPP; 234 235 usb_dev = kzalloc(sizeof(struct bcma_hcd_device), GFP_KERNEL); 236 if (!usb_dev) 237 return -ENOMEM; 238 239 bcma_hcd_init_chip(dev); 240 241 /* In AI chips EHCI is addrspace 0, OHCI is 1 */ 242 ohci_addr = dev->addr1; 243 if ((chipinfo->id == 0x5357 || chipinfo->id == 0x4749) 244 && chipinfo->rev == 0) 245 ohci_addr = 0x18009000; 246 247 usb_dev->ohci_dev = bcma_hcd_create_pdev(dev, true, ohci_addr); 248 if (IS_ERR(usb_dev->ohci_dev)) { 249 err = PTR_ERR(usb_dev->ohci_dev); 250 goto err_free_usb_dev; 251 } 252 253 usb_dev->ehci_dev = bcma_hcd_create_pdev(dev, false, dev->addr); 254 if (IS_ERR(usb_dev->ehci_dev)) { 255 err = PTR_ERR(usb_dev->ehci_dev); 256 goto err_unregister_ohci_dev; 257 } 258 259 bcma_set_drvdata(dev, usb_dev); 260 return 0; 261 262 err_unregister_ohci_dev: 263 platform_device_unregister(usb_dev->ohci_dev); 264 err_free_usb_dev: 265 kfree(usb_dev); 266 return err; 267 } 268 269 static void __devexit bcma_hcd_remove(struct bcma_device *dev) 270 { 271 struct bcma_hcd_device *usb_dev = bcma_get_drvdata(dev); 272 struct platform_device *ohci_dev = usb_dev->ohci_dev; 273 struct platform_device *ehci_dev = usb_dev->ehci_dev; 274 275 if (ohci_dev) 276 platform_device_unregister(ohci_dev); 277 if (ehci_dev) 278 platform_device_unregister(ehci_dev); 279 280 bcma_core_disable(dev, 0); 281 } 282 283 static void bcma_hcd_shutdown(struct bcma_device *dev) 284 { 285 bcma_core_disable(dev, 0); 286 } 287 288 #ifdef CONFIG_PM 289 290 static int bcma_hcd_suspend(struct bcma_device *dev) 291 { 292 bcma_core_disable(dev, 0); 293 294 return 0; 295 } 296 297 static int bcma_hcd_resume(struct bcma_device *dev) 298 { 299 bcma_core_enable(dev, 0); 300 301 return 0; 302 } 303 304 #else /* !CONFIG_PM */ 305 #define bcma_hcd_suspend NULL 306 #define bcma_hcd_resume NULL 307 #endif /* CONFIG_PM */ 308 309 static const struct bcma_device_id bcma_hcd_table[] __devinitconst = { 310 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_USB20_HOST, BCMA_ANY_REV, BCMA_ANY_CLASS), 311 BCMA_CORETABLE_END 312 }; 313 MODULE_DEVICE_TABLE(bcma, bcma_hcd_table); 314 315 static struct bcma_driver bcma_hcd_driver = { 316 .name = KBUILD_MODNAME, 317 .id_table = bcma_hcd_table, 318 .probe = bcma_hcd_probe, 319 .remove = __devexit_p(bcma_hcd_remove), 320 .shutdown = bcma_hcd_shutdown, 321 .suspend = bcma_hcd_suspend, 322 .resume = bcma_hcd_resume, 323 }; 324 325 static int __init bcma_hcd_init(void) 326 { 327 return bcma_driver_register(&bcma_hcd_driver); 328 } 329 module_init(bcma_hcd_init); 330 331 static void __exit bcma_hcd_exit(void) 332 { 333 bcma_driver_unregister(&bcma_hcd_driver); 334 } 335 module_exit(bcma_hcd_exit); 336