drivers/usb/host/bcma-hcd.c

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