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         ehci_port_power(ehci, 0);
  94
  95         return retval;
  96 }
  97
  98
  99 /* configure so an HC device and id are always provided
 100  * always called with process context; sleeping is OK
 101  */
 102
 103 static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
 104 {
 105         struct resource *res;
 106         struct platform_device *pdev = &dev->dev;
 107         u32 res_len;
 108         int retval;
 109
 110         /* MAB register space */
 111         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 112         if (res == NULL)
 113                 return -ENOMEM;
 114         res_len = resource_size(res);
 115         if (!request_mem_region(res->start, res_len, "mab regs"))
 116                 return -EBUSY;
 117
 118         dev->mab_regs = ioremap_nocache(res->start, res_len);
 119         if (dev->mab_regs == NULL) {
 120                 retval = -ENOMEM;
 121                 goto err1;
 122         }
 123
 124         /* MSP USB register space */
 125         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 126         if (res == NULL) {
 127                 retval = -ENOMEM;
 128                 goto err2;
 129         }
 130         res_len = resource_size(res);
 131         if (!request_mem_region(res->start, res_len, "usbid regs")) {
 132                 retval = -EBUSY;
 133                 goto err2;
 134         }
 135         dev->usbid_regs = ioremap_nocache(res->start, res_len);
 136         if (dev->usbid_regs == NULL) {
 137                 retval = -ENOMEM;
 138                 goto err3;
 139         }
 140
 141         return 0;
 142 err3:
 143         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 144         res_len = resource_size(res);
 145         release_mem_region(res->start, res_len);
 146 err2:
 147         iounmap(dev->mab_regs);
 148 err1:
 149         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 150         res_len = resource_size(res);
 151         release_mem_region(res->start, res_len);
 152         dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
 153         return retval;
 154 }
 155
 156 /**
 157  * usb_hcd_msp_probe - initialize PMC MSP-based HCDs
 158  * Context: !in_interrupt()
 159  *
 160  * Allocates basic resources for this USB host controller, and
 161  * then invokes the start() method for the HCD associated with it
 162  * through the hotplug entry's driver_data.
 163  *
 164  */
 165 int usb_hcd_msp_probe(const struct hc_driver *driver,
 166                           struct platform_device *dev)
 167 {
 168         int retval;
 169         struct usb_hcd *hcd;
 170         struct resource *res;
 171         struct ehci_hcd         *ehci ;
 172
 173         hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
 174         if (!hcd)
 175                 return -ENOMEM;
 176
 177         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 178         if (res == NULL) {
 179                 pr_debug("No IOMEM resource info for %s.\n", dev->name);
 180                 retval = -ENOMEM;
 181                 goto err1;
 182         }
 183         hcd->rsrc_start = res->start;
 184         hcd->rsrc_len = resource_size(res);
 185         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
 186                 retval = -EBUSY;
 187                 goto err1;
 188         }
 189         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 190         if (!hcd->regs) {
 191                 pr_debug("ioremap failed");
 192                 retval = -ENOMEM;
 193                 goto err2;
 194         }
 195
 196         res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
 197         if (res == NULL) {
 198                 dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
 199                 retval = -ENOMEM;
 200                 goto err3;
 201         }
 202
 203         /* Map non-EHCI register spaces */
 204         retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
 205         if (retval != 0)
 206                 goto err3;
 207
 208         ehci = hcd_to_ehci(hcd);
 209         ehci->big_endian_mmio = 1;
 210         ehci->big_endian_desc = 1;
 211
 212
 213         retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
 214         if (retval == 0)
 215                 return 0;
 216
 217         usb_remove_hcd(hcd);
 218 err3:
 219         iounmap(hcd->regs);
 220 err2:
 221         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 222 err1:
 223         usb_put_hcd(hcd);
 224
 225         return retval;
 226 }
 227
 228
 229
 230 /**
 231  * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
 232  * @dev: USB Host Controller being removed
 233  * Context: !in_interrupt()
 234  *
 235  * Reverses the effect of usb_hcd_msp_probe(), first invoking
 236  * the HCD's stop() method.  It is always called from a thread
 237  * context, normally "rmmod", "apmd", or something similar.
 238  *
 239  * may be called without controller electrically present
 240  * may be called with controller, bus, and devices active
 241  */
 242 void usb_hcd_msp_remove(struct usb_hcd *hcd, struct platform_device *dev)
 243 {
 244         usb_remove_hcd(hcd);
 245         iounmap(hcd->regs);
 246         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 247         usb_put_hcd(hcd);
 248 }
 249
 250 #ifdef CONFIG_MSP_HAS_DUAL_USB
 251 /*
 252  * Wrapper around the main ehci_irq.  Since both USB host controllers are
 253  * sharing the same IRQ, need to first determine whether we're the intended
 254  * recipient of this interrupt.
 255  */
 256 static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
 257 {
 258         u32 int_src;
 259         struct device *dev = hcd->self.controller;
 260         struct platform_device *pdev;
 261         struct mspusb_device *mdev;
 262         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 263         /* need to reverse-map a couple of containers to get our device */
 264         pdev = to_platform_device(dev);
 265         mdev = to_mspusb_device(pdev);
 266
 267         /* Check to see if this interrupt is for this host controller */
 268         int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
 269         if (int_src & (1 << pdev->id))
 270                 return ehci_irq(hcd);
 271
 272         /* Not for this device */
 273         return IRQ_NONE;
 274 }
 275 #endif /* DUAL_USB */
 276
 277 static const struct hc_driver ehci_msp_hc_driver = {
 278         .description =          hcd_name,
 279         .product_desc =         "PMC MSP EHCI",
 280         .hcd_priv_size =        sizeof(struct ehci_hcd),
 281
 282         /*
 283          * generic hardware linkage
 284          */
 285 #ifdef CONFIG_MSP_HAS_DUAL_USB
 286         .irq =                  ehci_msp_irq,
 287 #else
 288         .irq =                  ehci_irq,
 289 #endif
 290         .flags =                HCD_MEMORY | HCD_USB2,
 291
 292         /*
 293          * basic lifecycle operations
 294          */
 295         .reset =                ehci_msp_setup,
 296         .start =                ehci_run,
 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 };