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 }
  72
  73 /* called during probe() after chip reset completes */
  74 static int ehci_msp_setup(struct usb_hcd *hcd)
  75 {
  76         struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
  77         int                     retval;
  78
  79         ehci->big_endian_mmio = 1;
  80         ehci->big_endian_desc = 1;
  81
  82         ehci->caps = hcd->regs;
  83         hcd->has_tt = 1;
  84
  85         retval = ehci_setup(hcd);
  86         if (retval)
  87                 return retval;
  88
  89         usb_hcd_tdi_set_mode(ehci);
  90
  91         return retval;
  92 }
  93
  94
  95 /* configure so an HC device and id are always provided
  96  * always called with process context; sleeping is OK
  97  */
  98
  99 static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
 100 {
 101         struct resource *res;
 102         struct platform_device *pdev = &dev->dev;
 103         u32 res_len;
 104         int retval;
 105
 106         /* MAB register space */
 107         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 108         if (res == NULL)
 109                 return -ENOMEM;
 110         res_len = resource_size(res);
 111         if (!request_mem_region(res->start, res_len, "mab regs"))
 112                 return -EBUSY;
 113
 114         dev->mab_regs = ioremap_nocache(res->start, res_len);
 115         if (dev->mab_regs == NULL) {
 116                 retval = -ENOMEM;
 117                 goto err1;
 118         }
 119
 120         /* MSP USB register space */
 121         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 122         if (res == NULL) {
 123                 retval = -ENOMEM;
 124                 goto err2;
 125         }
 126         res_len = resource_size(res);
 127         if (!request_mem_region(res->start, res_len, "usbid regs")) {
 128                 retval = -EBUSY;
 129                 goto err2;
 130         }
 131         dev->usbid_regs = ioremap_nocache(res->start, res_len);
 132         if (dev->usbid_regs == NULL) {
 133                 retval = -ENOMEM;
 134                 goto err3;
 135         }
 136
 137         return 0;
 138 err3:
 139         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
 140         res_len = resource_size(res);
 141         release_mem_region(res->start, res_len);
 142 err2:
 143         iounmap(dev->mab_regs);
 144 err1:
 145         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 146         res_len = resource_size(res);
 147         release_mem_region(res->start, res_len);
 148         dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
 149         return retval;
 150 }
 151
 152 /**
 153  * usb_hcd_msp_probe - initialize PMC MSP-based HCDs
 154  * Context: !in_interrupt()
 155  *
 156  * Allocates basic resources for this USB host controller, and
 157  * then invokes the start() method for the HCD associated with it
 158  * through the hotplug entry's driver_data.
 159  *
 160  */
 161 int usb_hcd_msp_probe(const struct hc_driver *driver,
 162                           struct platform_device *dev)
 163 {
 164         int retval;
 165         struct usb_hcd *hcd;
 166         struct resource *res;
 167         struct ehci_hcd         *ehci ;
 168
 169         hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
 170         if (!hcd)
 171                 return -ENOMEM;
 172
 173         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 174         if (res == NULL) {
 175                 pr_debug("No IOMEM resource info for %s.\n", dev->name);
 176                 retval = -ENOMEM;
 177                 goto err1;
 178         }
 179         hcd->rsrc_start = res->start;
 180         hcd->rsrc_len = resource_size(res);
 181         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
 182                 retval = -EBUSY;
 183                 goto err1;
 184         }
 185         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 186         if (!hcd->regs) {
 187                 pr_debug("ioremap failed");
 188                 retval = -ENOMEM;
 189                 goto err2;
 190         }
 191
 192         res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
 193         if (res == NULL) {
 194                 dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
 195                 retval = -ENOMEM;
 196                 goto err3;
 197         }
 198
 199         /* Map non-EHCI register spaces */
 200         retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
 201         if (retval != 0)
 202                 goto err3;
 203
 204         ehci = hcd_to_ehci(hcd);
 205         ehci->big_endian_mmio = 1;
 206         ehci->big_endian_desc = 1;
 207
 208
 209         retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
 210         if (retval == 0) {
 211                 device_wakeup_enable(hcd->self.controller);
 212                 return 0;
 213         }
 214
 215         usb_remove_hcd(hcd);
 216 err3:
 217         iounmap(hcd->regs);
 218 err2:
 219         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 220 err1:
 221         usb_put_hcd(hcd);
 222
 223         return retval;
 224 }
 225
 226
 227
 228 /**
 229  * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
 230  * @dev: USB Host Controller being removed
 231  * Context: !in_interrupt()
 232  *
 233  * Reverses the effect of usb_hcd_msp_probe(), first invoking
 234  * the HCD's stop() method.  It is always called from a thread
 235  * context, normally "rmmod", "apmd", or something similar.
 236  *
 237  * may be called without controller electrically present
 238  * may be called with controller, bus, and devices active
 239  */
 240 void usb_hcd_msp_remove(struct usb_hcd *hcd, struct platform_device *dev)
 241 {
 242         usb_remove_hcd(hcd);
 243         iounmap(hcd->regs);
 244         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 245         usb_put_hcd(hcd);
 246 }
 247
 248 static const struct hc_driver ehci_msp_hc_driver = {
 249         .description =          hcd_name,
 250         .product_desc =         "PMC MSP EHCI",
 251         .hcd_priv_size =        sizeof(struct ehci_hcd),
 252
 253         /*
 254          * generic hardware linkage
 255          */
 256         .irq =                  ehci_irq,
 257         .flags =                HCD_MEMORY | HCD_USB2 | HCD_BH,
 258
 259         /*
 260          * basic lifecycle operations
 261          */
 262         .reset                  = ehci_msp_setup,
 263         .shutdown               = ehci_shutdown,
 264         .start                  = ehci_run,
 265         .stop                   = ehci_stop,
 266
 267         /*
 268          * managing i/o requests and associated device resources
 269          */
 270         .urb_enqueue            = ehci_urb_enqueue,
 271         .urb_dequeue            = ehci_urb_dequeue,
 272         .endpoint_disable       = ehci_endpoint_disable,
 273         .endpoint_reset         = ehci_endpoint_reset,
 274
 275         /*
 276          * scheduling support
 277          */
 278         .get_frame_number       = ehci_get_frame,
 279
 280         /*
 281          * root hub support
 282          */
 283         .hub_status_data        = ehci_hub_status_data,
 284         .hub_control            = ehci_hub_control,
 285         .bus_suspend            = ehci_bus_suspend,
 286         .bus_resume             = ehci_bus_resume,
 287         .relinquish_port        = ehci_relinquish_port,
 288         .port_handed_over       = ehci_port_handed_over,
 289
 290         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 291 };
 292
 293 static int ehci_hcd_msp_drv_probe(struct platform_device *pdev)
 294 {
 295         int ret;
 296
 297         pr_debug("In ehci_hcd_msp_drv_probe");
 298
 299         if (usb_disabled())
 300                 return -ENODEV;
 301
 302         gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
 303
 304         ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);
 305
 306         return ret;
 307 }
 308
 309 static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
 310 {
 311         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 312
 313         usb_hcd_msp_remove(hcd, pdev);
 314
 315         /* free TWI GPIO USB_HOST_DEV pin */
 316         gpio_free(MSP_PIN_USB0_HOST_DEV);
 317
 318         return 0;
 319 }
 320
 321 MODULE_ALIAS("pmcmsp-ehci");
 322
 323 static struct platform_driver ehci_hcd_msp_driver = {
 324         .probe          = ehci_hcd_msp_drv_probe,
 325         .remove         = ehci_hcd_msp_drv_remove,
 326         .driver         = {
 327                 .name   = "pmcmsp-ehci",
 328         },
 329 };