USB: EHCI: Add a generic platform device driver

This adds a generic driver for platform devices. It works like the PCI
driver and is based on it. This is for devices which do not have an own
bus but their EHCI controller works like a PCI controller. It will be
used for the Broadcom bcma and ssb USB EHCI controller.

Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 198 insertions, 0 deletions

diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
new file mode 100644
index 000000000000..d238b4e24bb6
--- /dev/null
+++ b/drivers/usb/host/ehci-platform.c
@@ -0,0 +1,198 @@
+/*
+ * Generic platform ehci driver
+ *
+ * Copyright 2007 Steven Brown <sbrown@cortland.com>
+ * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
+ *
+ * Derived from the ohci-ssb driver
+ * Copyright 2007 Michael Buesch <m@bues.ch>
+ *
+ * Derived from the EHCI-PCI driver
+ * Copyright (c) 2000-2004 by David Brownell
+ *
+ * Derived from the ohci-pci driver
+ * Copyright 1999 Roman Weissgaerber
+ * Copyright 2000-2002 David Brownell
+ * Copyright 1999 Linus Torvalds
+ * Copyright 1999 Gregory P. Smith
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+#include <linux/platform_device.h>
+#include <linux/usb/ehci_pdriver.h>
+
+static int ehci_platform_reset(struct usb_hcd *hcd)
+{
+        struct platform_device *pdev = to_platform_device(hcd->self.controller);
+        struct usb_ehci_pdata *pdata = pdev->dev.platform_data;
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+
+        hcd->has_tt = pdata->has_tt;
+        ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
+        ehci->big_endian_desc = pdata->big_endian_desc;
+        ehci->big_endian_mmio = pdata->big_endian_mmio;
+
+        ehci->caps = hcd->regs + pdata->caps_offset;
+        retval = ehci_setup(hcd);
+        if (retval)
+                return retval;
+
+        if (pdata->port_power_on)
+                ehci_port_power(ehci, 1);
+        if (pdata->port_power_off)
+                ehci_port_power(ehci, 0);
+
+        return 0;
+}
+
+static const struct hc_driver ehci_platform_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Generic Platform EHCI Controller",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        .reset                  = ehci_platform_reset,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
+
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
+        .endpoint_reset         = ehci_endpoint_reset,
+
+        .get_frame_number       = ehci_get_frame,
+
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+#if defined(CONFIG_PM)
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+#endif
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+
+        .update_device          = ehci_update_device,
+
+        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
+};
+
+static int __devinit ehci_platform_probe(struct platform_device *dev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res_mem;
+        int irq;
+        int err = -ENOMEM;
+
+        BUG_ON(!dev->dev.platform_data);
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
+                pr_err("no irq provieded");
+                return irq;
+        }
+        res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res_mem) {
+                pr_err("no memory recourse provieded");
+                return -ENXIO;
+        }
+
+        hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
+                             dev_name(&dev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = res_mem->start;
+        hcd->rsrc_len = resource_size(res_mem);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_err("controller already in use");
+                err = -EBUSY;
+                goto err_put_hcd;
+        }
+
+        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs)
+                goto err_release_region;
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (err)
+                goto err_iounmap;
+
+        platform_set_drvdata(dev, hcd);
+
+        return err;
+
+err_iounmap:
+        iounmap(hcd->regs);
+err_release_region:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_put_hcd:
+        usb_put_hcd(hcd);
+        return err;
+}
+
+static int __devexit ehci_platform_remove(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static int ehci_platform_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        bool wakeup = device_may_wakeup(dev);
+
+        ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd), wakeup);
+        return 0;
+}
+
+static int ehci_platform_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        ehci_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));
+        return 0;
+}
+
+#else /* !CONFIG_PM */
+#define ehci_platform_suspend   NULL
+#define ehci_platform_resume    NULL
+#endif /* CONFIG_PM */
+
+static const struct platform_device_id ehci_platform_table[] = {
+        { "ehci-platform", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(platform, ehci_platform_table);
+
+static const struct dev_pm_ops ehci_platform_pm_ops = {
+        .suspend        = ehci_platform_suspend,
+        .resume         = ehci_platform_resume,
+};
+
+static struct platform_driver ehci_platform_driver = {
+        .id_table       = ehci_platform_table,
+        .probe          = ehci_platform_probe,
+        .remove         = __devexit_p(ehci_platform_remove),
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "ehci-platform",
+                .pm     = &ehci_platform_pm_ops,
+        }
+};