drivers/usb/host/ehci-au1xxx.c

   1 /*
   2  * EHCI HCD (Host Controller Driver) for USB.
   3  *
   4  * Bus Glue for AMD Alchemy Au1xxx
   5  *
   6  * Based on "ohci-au1xxx.c" by Matt Porter <mporter@kernel.crashing.org>
   7  *
   8  * Modified for AMD Alchemy Au1200 EHC
   9  *  by K.Boge <karsten.boge@amd.com>
  10  *
  11  * This file is licenced under the GPL.
  12  */
  13
  14 #include <linux/platform_device.h>
  15 #include <asm/mach-au1x00/au1000.h>
  16
  17
  18 extern int usb_disabled(void);
  19
  20 static int au1xxx_ehci_setup(struct usb_hcd *hcd)
  21 {
  22         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
  23         int ret;
  24
  25         ehci->caps = hcd->regs;
  26         ret = ehci_setup(hcd);
  27
  28         ehci->need_io_watchdog = 0;
  29         return ret;
  30 }
  31
  32 static const struct hc_driver ehci_au1xxx_hc_driver = {
  33         .description            = hcd_name,
  34         .product_desc           = "Au1xxx EHCI",
  35         .hcd_priv_size          = sizeof(struct ehci_hcd),
  36
  37         /*
  38          * generic hardware linkage
  39          */
  40         .irq                    = ehci_irq,
  41         .flags                  = HCD_MEMORY | HCD_USB2,
  42
  43         /*
  44          * basic lifecycle operations
  45          *
  46          * FIXME -- ehci_init() doesn't do enough here.
  47          * See ehci-ppc-soc for a complete implementation.
  48          */
  49         .reset                  = au1xxx_ehci_setup,
  50         .start                  = ehci_run,
  51         .stop                   = ehci_stop,
  52         .shutdown               = ehci_shutdown,
  53
  54         /*
  55          * managing i/o requests and associated device resources
  56          */
  57         .urb_enqueue            = ehci_urb_enqueue,
  58         .urb_dequeue            = ehci_urb_dequeue,
  59         .endpoint_disable       = ehci_endpoint_disable,
  60         .endpoint_reset         = ehci_endpoint_reset,
  61
  62         /*
  63          * scheduling support
  64          */
  65         .get_frame_number       = ehci_get_frame,
  66
  67         /*
  68          * root hub support
  69          */
  70         .hub_status_data        = ehci_hub_status_data,
  71         .hub_control            = ehci_hub_control,
  72         .bus_suspend            = ehci_bus_suspend,
  73         .bus_resume             = ehci_bus_resume,
  74         .relinquish_port        = ehci_relinquish_port,
  75         .port_handed_over       = ehci_port_handed_over,
  76
  77         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
  78 };
  79
  80 static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
  81 {
  82         struct usb_hcd *hcd;
  83         struct resource *res;
  84         int ret;
  85
  86         if (usb_disabled())
  87                 return -ENODEV;
  88
  89         if (pdev->resource[1].flags != IORESOURCE_IRQ) {
  90                 pr_debug("resource[1] is not IORESOURCE_IRQ");
  91                 return -ENOMEM;
  92         }
  93         hcd = usb_create_hcd(&ehci_au1xxx_hc_driver, &pdev->dev, "Au1xxx");
  94         if (!hcd)
  95                 return -ENOMEM;
  96
  97         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  98         hcd->rsrc_start = res->start;
  99         hcd->rsrc_len = resource_size(res);
 100
 101         hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
 102         if (!hcd->regs) {
 103                 pr_debug("devm_request_and_ioremap failed");
 104                 ret = -ENOMEM;
 105                 goto err1;
 106         }
 107
 108         if (alchemy_usb_control(ALCHEMY_USB_EHCI0, 1)) {
 109                 printk(KERN_INFO "%s: controller init failed!\n", pdev->name);
 110                 ret = -ENODEV;
 111                 goto err1;
 112         }
 113
 114         ret = usb_add_hcd(hcd, pdev->resource[1].start,
 115                           IRQF_SHARED);
 116         if (ret == 0) {
 117                 platform_set_drvdata(pdev, hcd);
 118                 return ret;
 119         }
 120
 121         alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
 122 err1:
 123         usb_put_hcd(hcd);
 124         return ret;
 125 }
 126
 127 static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 128 {
 129         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 130
 131         usb_remove_hcd(hcd);
 132         alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
 133         usb_put_hcd(hcd);
 134         platform_set_drvdata(pdev, NULL);
 135
 136         return 0;
 137 }
 138
 139 #ifdef CONFIG_PM
 140 static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
 141 {
 142         struct usb_hcd *hcd = dev_get_drvdata(dev);
 143         bool do_wakeup = device_may_wakeup(dev);
 144         int rc;
 145
 146         rc = ehci_suspend(hcd, do_wakeup);
 147         alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
 148
 149         return rc;
 150 }
 151
 152 static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
 153 {
 154         struct usb_hcd *hcd = dev_get_drvdata(dev);
 155
 156         alchemy_usb_control(ALCHEMY_USB_EHCI0, 1);
 157         ehci_resume(hcd, false);
 158
 159         return 0;
 160 }
 161
 162 static const struct dev_pm_ops au1xxx_ehci_pmops = {
 163         .suspend        = ehci_hcd_au1xxx_drv_suspend,
 164         .resume         = ehci_hcd_au1xxx_drv_resume,
 165 };
 166
 167 #define AU1XXX_EHCI_PMOPS &au1xxx_ehci_pmops
 168
 169 #else
 170 #define AU1XXX_EHCI_PMOPS NULL
 171 #endif
 172
 173 static struct platform_driver ehci_hcd_au1xxx_driver = {
 174         .probe          = ehci_hcd_au1xxx_drv_probe,
 175         .remove         = ehci_hcd_au1xxx_drv_remove,
 176         .shutdown       = usb_hcd_platform_shutdown,
 177         .driver = {
 178                 .name   = "au1xxx-ehci",
 179                 .owner  = THIS_MODULE,
 180                 .pm     = AU1XXX_EHCI_PMOPS,
 181         }
 182 };
 183
 184 MODULE_ALIAS("platform:au1xxx-ehci");