drivers/usb/host/ohci-spear.c

   1 /*
   2 * OHCI HCD (Host Controller Driver) for USB.
   3 *
   4 * Copyright (C) 2010 ST Microelectronics.
   5 * Deepak Sikri<deepak.sikri@st.com>
   6 *
   7 * Based on various ohci-*.c drivers
   8 *
   9 * This file is licensed under the terms of the GNU General Public
  10 * License version 2. This program is licensed "as is" without any
  11 * warranty of any kind, whether express or implied.
  12 */
  13
  14 #include <linux/signal.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/clk.h>
  17 #include <linux/of.h>
  18
  19 struct spear_ohci {
  20         struct ohci_hcd ohci;
  21         struct clk *clk;
  22 };
  23
  24 #define to_spear_ohci(hcd)      (struct spear_ohci *)hcd_to_ohci(hcd)
  25
  26 static void spear_start_ohci(struct spear_ohci *ohci)
  27 {
  28         clk_prepare_enable(ohci->clk);
  29 }
  30
  31 static void spear_stop_ohci(struct spear_ohci *ohci)
  32 {
  33         clk_disable_unprepare(ohci->clk);
  34 }
  35
  36 static int ohci_spear_start(struct usb_hcd *hcd)
  37 {
  38         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
  39         int ret;
  40
  41         ret = ohci_init(ohci);
  42         if (ret < 0)
  43                 return ret;
  44         ohci->regs = hcd->regs;
  45
  46         ret = ohci_run(ohci);
  47         if (ret < 0) {
  48                 dev_err(hcd->self.controller, "can't start\n");
  49                 ohci_stop(hcd);
  50                 return ret;
  51         }
  52
  53         create_debug_files(ohci);
  54
  55 #ifdef DEBUG
  56         ohci_dump(ohci, 1);
  57 #endif
  58         return 0;
  59 }
  60
  61 static const struct hc_driver ohci_spear_hc_driver = {
  62         .description            = hcd_name,
  63         .product_desc           = "SPEAr OHCI",
  64         .hcd_priv_size          = sizeof(struct spear_ohci),
  65
  66         /* generic hardware linkage */
  67         .irq                    = ohci_irq,
  68         .flags                  = HCD_USB11 | HCD_MEMORY,
  69
  70         /* basic lifecycle operations */
  71         .start                  = ohci_spear_start,
  72         .stop                   = ohci_stop,
  73         .shutdown               = ohci_shutdown,
  74 #ifdef  CONFIG_PM
  75         .bus_suspend            = ohci_bus_suspend,
  76         .bus_resume             = ohci_bus_resume,
  77 #endif
  78
  79         /* managing i/o requests and associated device resources */
  80         .urb_enqueue            = ohci_urb_enqueue,
  81         .urb_dequeue            = ohci_urb_dequeue,
  82         .endpoint_disable       = ohci_endpoint_disable,
  83
  84         /* scheduling support */
  85         .get_frame_number       = ohci_get_frame,
  86
  87         /* root hub support */
  88         .hub_status_data        = ohci_hub_status_data,
  89         .hub_control            = ohci_hub_control,
  90
  91         .start_port_reset       = ohci_start_port_reset,
  92 };
  93
  94 static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
  95 {
  96         const struct hc_driver *driver = &ohci_spear_hc_driver;
  97         struct usb_hcd *hcd = NULL;
  98         struct clk *usbh_clk;
  99         struct spear_ohci *ohci_p;
 100         struct resource *res;
 101         int retval, irq;
 102
 103         irq = platform_get_irq(pdev, 0);
 104         if (irq < 0) {
 105                 retval = irq;
 106                 goto fail;
 107         }
 108
 109         /*
 110          * Right now device-tree probed devices don't get dma_mask set.
 111          * Since shared usb code relies on it, set it here for now.
 112          * Once we have dma capability bindings this can go away.
 113          */
 114         retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 115         if (retval)
 116                 goto fail;
 117
 118         usbh_clk = devm_clk_get(&pdev->dev, NULL);
 119         if (IS_ERR(usbh_clk)) {
 120                 dev_err(&pdev->dev, "Error getting interface clock\n");
 121                 retval = PTR_ERR(usbh_clk);
 122                 goto fail;
 123         }
 124
 125         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
 126         if (!hcd) {
 127                 retval = -ENOMEM;
 128                 goto fail;
 129         }
 130
 131         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 132         if (!res) {
 133                 retval = -ENODEV;
 134                 goto err_put_hcd;
 135         }
 136
 137         hcd->rsrc_start = pdev->resource[0].start;
 138         hcd->rsrc_len = resource_size(res);
 139         if (!devm_request_mem_region(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len,
 140                                 hcd_name)) {
 141                 dev_dbg(&pdev->dev, "request_mem_region failed\n");
 142                 retval = -EBUSY;
 143                 goto err_put_hcd;
 144         }
 145
 146         hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
 147         if (!hcd->regs) {
 148                 dev_dbg(&pdev->dev, "ioremap failed\n");
 149                 retval = -ENOMEM;
 150                 goto err_put_hcd;
 151         }
 152
 153         ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd);
 154         ohci_p->clk = usbh_clk;
 155         spear_start_ohci(ohci_p);
 156         ohci_hcd_init(hcd_to_ohci(hcd));
 157
 158         retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0);
 159         if (retval == 0)
 160                 return retval;
 161
 162         spear_stop_ohci(ohci_p);
 163 err_put_hcd:
 164         usb_put_hcd(hcd);
 165 fail:
 166         dev_err(&pdev->dev, "init fail, %d\n", retval);
 167
 168         return retval;
 169 }
 170
 171 static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)
 172 {
 173         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 174         struct spear_ohci *ohci_p = to_spear_ohci(hcd);
 175
 176         usb_remove_hcd(hcd);
 177         if (ohci_p->clk)
 178                 spear_stop_ohci(ohci_p);
 179
 180         usb_put_hcd(hcd);
 181         return 0;
 182 }
 183
 184 #if defined(CONFIG_PM)
 185 static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
 186                 pm_message_t message)
 187 {
 188         struct usb_hcd *hcd = platform_get_drvdata(dev);
 189         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 190         struct spear_ohci *ohci_p = to_spear_ohci(hcd);
 191
 192         if (time_before(jiffies, ohci->next_statechange))
 193                 msleep(5);
 194         ohci->next_statechange = jiffies;
 195
 196         spear_stop_ohci(ohci_p);
 197         return 0;
 198 }
 199
 200 static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
 201 {
 202         struct usb_hcd *hcd = platform_get_drvdata(dev);
 203         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 204         struct spear_ohci *ohci_p = to_spear_ohci(hcd);
 205
 206         if (time_before(jiffies, ohci->next_statechange))
 207                 msleep(5);
 208         ohci->next_statechange = jiffies;
 209
 210         spear_start_ohci(ohci_p);
 211         ohci_resume(hcd, false);
 212         return 0;
 213 }
 214 #endif
 215
 216 static struct of_device_id spear_ohci_id_table[] = {
 217         { .compatible = "st,spear600-ohci", },
 218         { },
 219 };
 220
 221 /* Driver definition to register with the platform bus */
 222 static struct platform_driver spear_ohci_hcd_driver = {
 223         .probe =        spear_ohci_hcd_drv_probe,
 224         .remove =       spear_ohci_hcd_drv_remove,
 225 #ifdef CONFIG_PM
 226         .suspend =      spear_ohci_hcd_drv_suspend,
 227         .resume =       spear_ohci_hcd_drv_resume,
 228 #endif
 229         .driver = {
 230                 .owner = THIS_MODULE,
 231                 .name = "spear-ohci",
 232                 .of_match_table = spear_ohci_id_table,
 233         },
 234 };
 235
 236 MODULE_ALIAS("platform:spear-ohci");