drivers/usb/host/ehci-pmcmsp.c

   1 /*
   2  * PMC MSP EHCI (Host Controller Driver) for USB.
   3  *
   4  * (C) Copyright 2006-2010 PMC-Sierra Inc
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  *
  10  */
  11
  12 /* includes */
  13 #include <linux/platform_device.h>
  14 #include <linux/gpio.h>
  15 #include <linux/usb.h>
  16 #include <msp_usb.h>
  17
  18 /* stream disable*/
  19 #define USB_CTRL_MODE_STREAM_DISABLE    0x10
  20
  21 /* threshold */
  22 #define USB_CTRL_FIFO_THRESH            0x00300000
  23
  24 /* register offset for usb_mode */
  25 #define USB_EHCI_REG_USB_MODE           0x68
  26
  27 /* register offset for usb fifo */
  28 #define USB_EHCI_REG_USB_FIFO           0x24
  29
  30 /* register offset for usb status */
  31 #define USB_EHCI_REG_USB_STATUS         0x44
  32
  33 /* serial/parallel transceiver */
  34 #define USB_EHCI_REG_BIT_STAT_STS       (1<<29)
  35
  36 /* TWI USB0 host device pin */
  37 #define MSP_PIN_USB0_HOST_DEV           49
  38
  39 /* TWI USB1 host device pin */
  40 #define MSP_PIN_USB1_HOST_DEV           50
  41
  42
  43 static void usb_hcd_tdi_set_mode(struct ehci_hcd *ehci)
  44 {
  45         u8 *base;
  46         u8 *statreg;
  47         u8 *fiforeg;
  48         u32 val;
  49         struct ehci_regs *reg_base = ehci->regs;
  50
  51         /* get register base */
  52         base = (u8 *)reg_base + USB_EHCI_REG_USB_MODE;
  53         statreg = (u8 *)reg_base + USB_EHCI_REG_USB_STATUS;
  54         fiforeg = (u8 *)reg_base + USB_EHCI_REG_USB_FIFO;
  55
  56         /* Disable controller mode stream */
  57         val = ehci_readl(ehci, (u32 *)base);
  58         ehci_writel(ehci, (val | USB_CTRL_MODE_STREAM_DISABLE),
  59                         (u32 *)base);
  60
  61         /* clear STS to select parallel transceiver interface */
  62         val = ehci_readl(ehci, (u32 *)statreg);
  63         val = val & ~USB_EHCI_REG_BIT_STAT_STS;
  64         ehci_writel(ehci, val, (u32 *)statreg);
  65
  66         /* write to set the proper fifo threshold */
  67         ehci_writel(ehci, USB_CTRL_FIFO_THRESH, (u32 *)fiforeg);
  68
  69         /* set TWI GPIO USB_HOST_DEV pin high */
  70         gpio_direction_output(MSP_PIN_USB0_HOST_DEV, 1);
  71 #ifdef CONFIG_MSP_HAS_DUAL_USB
  72         gpio_direction_output(MSP_PIN_USB1_HOST_DEV, 1);
  73 #endif
  74 }
  75
  76 /* called during probe() after chip reset completes */
  77 static int ehci_msp_setup(struct usb_hcd *hcd)
  78 {
  79         struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
  80         int                     retval;
  81
  82         ehci->big_endian_mmio = 1;
  83         ehci->big_endian_desc = 1;
  84
  85         ehci->caps = hcd->regs;
  86         hcd->has_tt = 1;
  87
  88         retval = ehci_setup(hcd);
  89         if (retval)
  90                 return retval;
  91
  92         usb_hcd_tdi_set_mode(ehci);
  93
  94         return retval;
  95 }
  96
  97
  98 /* configure so an HC device and id are always provided
  99  * always called with process context; sleeping is OK
 100  */
 101
 102 static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
 103 {
 104         struct resource *res;
 105         struct platform_device *pdev = &dev->dev;
 106         u32 res_len;
 107         int retval;
 108
 109         /* MAB register space */
 110         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 111         if (res == NULL)
 112                 return -ENOMEM;
 113         res_len = resource_size(res);
 114         if (!request_mem_region(res->start, res_len, "mab regs"))
 115                 return -EBUSY;
 116
 117         dev->mab_regs = ioremap_nocache(res->start, res_len);
 118         if (dev->mab_regs == NULL) {
 119                 retval = -ENOMEM;
 120                 goto err1;
 121         }
 122
 123         /* MSP USB register space */
 124         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 125         if (res == NULL) {
 126                 retval = -ENOMEM;
 127                 goto err2;
 128         }
 129         res_len = resource_size(res);
 130         if (!request_mem_region(res->start, res_len, "usbid regs")) {
 131                 retval = -EBUSY;
 132                 goto err2;
 133         }
 134         dev->usbid_regs = ioremap_nocache(res->start, res_len);
 135         if (dev->usbid_regs == NULL) {
 136                 retval = -ENOMEM;
 137                 goto err3;
 138         }
 139
 140         return 0;
 141 err3:
 142         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 143         res_len = resource_size(res);
 144         release_mem_region(res->start, res_len);
 145 err2:
 146         iounmap(dev->mab_regs);
 147 err1:
 148         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 149         res_len = resource_size(res);
 150         release_mem_region(res->start, res_len);
 151         dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
 152         return retval;
 153 }
 154
 155 /**
 156  * usb_hcd_msp_probe - initialize PMC MSP-based HCDs
 157  * Context: !in_interrupt()
 158  *
 159  * Allocates basic resources for this USB host controller, and
 160  * then invokes the start() method for the HCD associated with it
 161  * through the hotplug entry's driver_data.
 162  *
 163  */
 164 int usb_hcd_msp_probe(const struct hc_driver *driver,
 165                           struct platform_device *dev)
 166 {
 167         int retval;
 168         struct usb_hcd *hcd;
 169         struct resource *res;
 170         struct ehci_hcd         *ehci ;
 171
 172         hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
 173         if (!hcd)
 174                 return -ENOMEM;
 175
 176         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 177         if (res == NULL) {
 178                 pr_debug("No IOMEM resource info for %s.\n", dev->name);
 179                 retval = -ENOMEM;
 180                 goto err1;
 181         }
 182         hcd->rsrc_start = res->start;
 183         hcd->rsrc_len = resource_size(res);
 184         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
 185                 retval = -EBUSY;
 186                 goto err1;
 187         }
 188         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 189         if (!hcd->regs) {
 190                 pr_debug("ioremap failed");
 191                 retval = -ENOMEM;
 192                 goto err2;
 193         }
 194
 195         res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
 196         if (res == NULL) {
 197                 dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
 198                 retval = -ENOMEM;
 199                 goto err3;
 200         }
 201
 202         /* Map non-EHCI register spaces */
 203         retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
 204         if (retval != 0)
 205                 goto err3;
 206
 207         ehci = hcd_to_ehci(hcd);
 208         ehci->big_endian_mmio = 1;
 209         ehci->big_endian_desc = 1;
 210
 211
 212         retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
 213         if (retval == 0) {
 214                 device_wakeup_enable(hcd->self.controller);
 215                 return 0;
 216         }
 217
 218         usb_remove_hcd(hcd);
 219 err3:
 220         iounmap(hcd->regs);
 221 err2:
 222         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 223 err1:
 224         usb_put_hcd(hcd);
 225
 226         return retval;
 227 }
 228
 229
 230
 231 /**
 232  * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
 233  * @dev: USB Host Controller being removed
 234  * Context: !in_interrupt()
 235  *
 236  * Reverses the effect of usb_hcd_msp_probe(), first invoking
 237  * the HCD's stop() method.  It is always called from a thread
 238  * context, normally "rmmod", "apmd", or something similar.
 239  *
 240  * may be called without controller electrically present
 241  * may be called with controller, bus, and devices active
 242  */
 243 void usb_hcd_msp_remove(struct usb_hcd *hcd, struct platform_device *dev)
 244 {
 245         usb_remove_hcd(hcd);
 246         iounmap(hcd->regs);
 247         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 248         usb_put_hcd(hcd);
 249 }
 250
 251 #ifdef CONFIG_MSP_HAS_DUAL_USB
 252 /*
 253  * Wrapper around the main ehci_irq.  Since both USB host controllers are
 254  * sharing the same IRQ, need to first determine whether we're the intended
 255  * recipient of this interrupt.
 256  */
 257 static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
 258 {
 259         u32 int_src;
 260         struct device *dev = hcd->self.controller;
 261         struct platform_device *pdev;
 262         struct mspusb_device *mdev;
 263         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 264         /* need to reverse-map a couple of containers to get our device */
 265         pdev = to_platform_device(dev);
 266         mdev = to_mspusb_device(pdev);
 267
 268         /* Check to see if this interrupt is for this host controller */
 269         int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
 270         if (int_src & (1 << pdev->id))
 271                 return ehci_irq(hcd);
 272
 273         /* Not for this device */
 274         return IRQ_NONE;
 275 }
 276 #endif /* DUAL_USB */
 277
 278 static const struct hc_driver ehci_msp_hc_driver = {
 279         .description =          hcd_name,
 280         .product_desc =         "PMC MSP EHCI",
 281         .hcd_priv_size =        sizeof(struct ehci_hcd),
 282
 283         /*
 284          * generic hardware linkage
 285          */
 286 #ifdef CONFIG_MSP_HAS_DUAL_USB
 287         .irq =                  ehci_msp_irq,
 288 #else
 289         .irq =                  ehci_irq,
 290 #endif
 291         .flags =                HCD_MEMORY | HCD_USB2 | HCD_BH,
 292
 293         /*
 294          * basic lifecycle operations
 295          */
 296         .reset                  = ehci_msp_setup,
 297         .shutdown               = ehci_shutdown,
 298         .start                  = ehci_run,
 299         .stop                   = ehci_stop,
 300
 301         /*
 302          * managing i/o requests and associated device resources
 303          */
 304         .urb_enqueue            = ehci_urb_enqueue,
 305         .urb_dequeue            = ehci_urb_dequeue,
 306         .endpoint_disable       = ehci_endpoint_disable,
 307         .endpoint_reset         = ehci_endpoint_reset,
 308
 309         /*
 310          * scheduling support
 311          */
 312         .get_frame_number       = ehci_get_frame,
 313
 314         /*
 315          * root hub support
 316          */
 317         .hub_status_data        = ehci_hub_status_data,
 318         .hub_control            = ehci_hub_control,
 319         .bus_suspend            = ehci_bus_suspend,
 320         .bus_resume             = ehci_bus_resume,
 321         .relinquish_port        = ehci_relinquish_port,
 322         .port_handed_over       = ehci_port_handed_over,
 323
 324         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 325 };
 326
 327 static int ehci_hcd_msp_drv_probe(struct platform_device *pdev)
 328 {
 329         int ret;
 330
 331         pr_debug("In ehci_hcd_msp_drv_probe");
 332
 333         if (usb_disabled())
 334                 return -ENODEV;
 335
 336         gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
 337 #ifdef CONFIG_MSP_HAS_DUAL_USB
 338         gpio_request(MSP_PIN_USB1_HOST_DEV, "USB1_HOST_DEV_GPIO");
 339 #endif
 340
 341         ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);
 342
 343         return ret;
 344 }
 345
 346 static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
 347 {
 348         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 349
 350         usb_hcd_msp_remove(hcd, pdev);
 351
 352         /* free TWI GPIO USB_HOST_DEV pin */
 353         gpio_free(MSP_PIN_USB0_HOST_DEV);
 354 #ifdef CONFIG_MSP_HAS_DUAL_USB
 355         gpio_free(MSP_PIN_USB1_HOST_DEV);
 356 #endif
 357
 358         return 0;
 359 }
 360
 361 MODULE_ALIAS("pmcmsp-ehci");
 362
 363 static struct platform_driver ehci_hcd_msp_driver = {
 364         .probe          = ehci_hcd_msp_drv_probe,
 365         .remove         = ehci_hcd_msp_drv_remove,
 366         .driver         = {
 367                 .name   = "pmcmsp-ehci",
 368                 .owner  = THIS_MODULE,
 369         },
 370 };