drivers/usb/host/ohci-exynos.c

   1 /*
   2  * SAMSUNG EXYNOS USB HOST OHCI Controller
   3  *
   4  * Copyright (C) 2011 Samsung Electronics Co.Ltd
   5  * Author: Jingoo Han <jg1.han@samsung.com>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  *
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/platform_data/usb-ohci-exynos.h>
  18 #include <linux/usb/phy.h>
  19 #include <linux/usb/samsung_usb_phy.h>
  20
  21 struct exynos_ohci_hcd {
  22         struct device *dev;
  23         struct usb_hcd *hcd;
  24         struct clk *clk;
  25         struct usb_phy *phy;
  26         struct usb_otg *otg;
  27         struct exynos4_ohci_platdata *pdata;
  28 };
  29
  30 static void exynos_ohci_phy_enable(struct exynos_ohci_hcd *exynos_ohci)
  31 {
  32         struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
  33
  34         if (exynos_ohci->phy)
  35                 usb_phy_init(exynos_ohci->phy);
  36         else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_init)
  37                 exynos_ohci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
  38 }
  39
  40 static void exynos_ohci_phy_disable(struct exynos_ohci_hcd *exynos_ohci)
  41 {
  42         struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
  43
  44         if (exynos_ohci->phy)
  45                 usb_phy_shutdown(exynos_ohci->phy);
  46         else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_exit)
  47                 exynos_ohci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
  48 }
  49
  50 static int ohci_exynos_reset(struct usb_hcd *hcd)
  51 {
  52         return ohci_init(hcd_to_ohci(hcd));
  53 }
  54
  55 static int ohci_exynos_start(struct usb_hcd *hcd)
  56 {
  57         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
  58         int ret;
  59
  60         ohci_dbg(ohci, "ohci_exynos_start, ohci:%p", ohci);
  61
  62         ret = ohci_run(ohci);
  63         if (ret < 0) {
  64                 dev_err(hcd->self.controller, "can't start %s\n",
  65                         hcd->self.bus_name);
  66                 ohci_stop(hcd);
  67                 return ret;
  68         }
  69
  70         return 0;
  71 }
  72
  73 static const struct hc_driver exynos_ohci_hc_driver = {
  74         .description            = hcd_name,
  75         .product_desc           = "EXYNOS OHCI Host Controller",
  76         .hcd_priv_size          = sizeof(struct ohci_hcd),
  77
  78         .irq                    = ohci_irq,
  79         .flags                  = HCD_MEMORY|HCD_USB11,
  80
  81         .reset                  = ohci_exynos_reset,
  82         .start                  = ohci_exynos_start,
  83         .stop                   = ohci_stop,
  84         .shutdown               = ohci_shutdown,
  85
  86         .get_frame_number       = ohci_get_frame,
  87
  88         .urb_enqueue            = ohci_urb_enqueue,
  89         .urb_dequeue            = ohci_urb_dequeue,
  90         .endpoint_disable       = ohci_endpoint_disable,
  91
  92         .hub_status_data        = ohci_hub_status_data,
  93         .hub_control            = ohci_hub_control,
  94 #ifdef  CONFIG_PM
  95         .bus_suspend            = ohci_bus_suspend,
  96         .bus_resume             = ohci_bus_resume,
  97 #endif
  98         .start_port_reset       = ohci_start_port_reset,
  99 };
 100
 101 static u64 ohci_exynos_dma_mask = DMA_BIT_MASK(32);
 102
 103 static int exynos_ohci_probe(struct platform_device *pdev)
 104 {
 105         struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
 106         struct exynos_ohci_hcd *exynos_ohci;
 107         struct usb_hcd *hcd;
 108         struct ohci_hcd *ohci;
 109         struct resource *res;
 110         struct usb_phy *phy;
 111         int irq;
 112         int err;
 113
 114         /*
 115          * Right now device-tree probed devices don't get dma_mask set.
 116          * Since shared usb code relies on it, set it here for now.
 117          * Once we move to full device tree support this will vanish off.
 118          */
 119         if (!pdev->dev.dma_mask)
 120                 pdev->dev.dma_mask = &ohci_exynos_dma_mask;
 121         if (!pdev->dev.coherent_dma_mask)
 122                 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 123
 124         exynos_ohci = devm_kzalloc(&pdev->dev, sizeof(struct exynos_ohci_hcd),
 125                                         GFP_KERNEL);
 126         if (!exynos_ohci)
 127                 return -ENOMEM;
 128
 129         if (of_device_is_compatible(pdev->dev.of_node,
 130                                         "samsung,exynos5440-ohci"))
 131                 goto skip_phy;
 132
 133         phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
 134         if (IS_ERR(phy)) {
 135                 /* Fallback to pdata */
 136                 if (!pdata) {
 137                         dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
 138                         return -EPROBE_DEFER;
 139                 } else {
 140                         exynos_ohci->pdata = pdata;
 141                 }
 142         } else {
 143                 exynos_ohci->phy = phy;
 144                 exynos_ohci->otg = phy->otg;
 145         }
 146
 147 skip_phy:
 148
 149         exynos_ohci->dev = &pdev->dev;
 150
 151         hcd = usb_create_hcd(&exynos_ohci_hc_driver, &pdev->dev,
 152                                         dev_name(&pdev->dev));
 153         if (!hcd) {
 154                 dev_err(&pdev->dev, "Unable to create HCD\n");
 155                 return -ENOMEM;
 156         }
 157
 158         exynos_ohci->hcd = hcd;
 159         exynos_ohci->clk = devm_clk_get(&pdev->dev, "usbhost");
 160
 161         if (IS_ERR(exynos_ohci->clk)) {
 162                 dev_err(&pdev->dev, "Failed to get usbhost clock\n");
 163                 err = PTR_ERR(exynos_ohci->clk);
 164                 goto fail_clk;
 165         }
 166
 167         err = clk_prepare_enable(exynos_ohci->clk);
 168         if (err)
 169                 goto fail_clk;
 170
 171         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 172         if (!res) {
 173                 dev_err(&pdev->dev, "Failed to get I/O memory\n");
 174                 err = -ENXIO;
 175                 goto fail_io;
 176         }
 177
 178         hcd->rsrc_start = res->start;
 179         hcd->rsrc_len = resource_size(res);
 180         hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
 181         if (!hcd->regs) {
 182                 dev_err(&pdev->dev, "Failed to remap I/O memory\n");
 183                 err = -ENOMEM;
 184                 goto fail_io;
 185         }
 186
 187         irq = platform_get_irq(pdev, 0);
 188         if (!irq) {
 189                 dev_err(&pdev->dev, "Failed to get IRQ\n");
 190                 err = -ENODEV;
 191                 goto fail_io;
 192         }
 193
 194         if (exynos_ohci->otg)
 195                 exynos_ohci->otg->set_host(exynos_ohci->otg,
 196                                         &exynos_ohci->hcd->self);
 197
 198         exynos_ohci_phy_enable(exynos_ohci);
 199
 200         ohci = hcd_to_ohci(hcd);
 201         ohci_hcd_init(ohci);
 202
 203         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 204         if (err) {
 205                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
 206                 goto fail_add_hcd;
 207         }
 208
 209         platform_set_drvdata(pdev, exynos_ohci);
 210
 211         return 0;
 212
 213 fail_add_hcd:
 214         exynos_ohci_phy_disable(exynos_ohci);
 215 fail_io:
 216         clk_disable_unprepare(exynos_ohci->clk);
 217 fail_clk:
 218         usb_put_hcd(hcd);
 219         return err;
 220 }
 221
 222 static int exynos_ohci_remove(struct platform_device *pdev)
 223 {
 224         struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
 225         struct usb_hcd *hcd = exynos_ohci->hcd;
 226
 227         usb_remove_hcd(hcd);
 228
 229         if (exynos_ohci->otg)
 230                 exynos_ohci->otg->set_host(exynos_ohci->otg,
 231                                         &exynos_ohci->hcd->self);
 232
 233         exynos_ohci_phy_disable(exynos_ohci);
 234
 235         clk_disable_unprepare(exynos_ohci->clk);
 236
 237         usb_put_hcd(hcd);
 238
 239         return 0;
 240 }
 241
 242 static void exynos_ohci_shutdown(struct platform_device *pdev)
 243 {
 244         struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
 245         struct usb_hcd *hcd = exynos_ohci->hcd;
 246
 247         if (hcd->driver->shutdown)
 248                 hcd->driver->shutdown(hcd);
 249 }
 250
 251 #ifdef CONFIG_PM
 252 static int exynos_ohci_suspend(struct device *dev)
 253 {
 254         struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
 255         struct usb_hcd *hcd = exynos_ohci->hcd;
 256         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 257         unsigned long flags;
 258         int rc = 0;
 259
 260         /*
 261          * Root hub was already suspended. Disable irq emission and
 262          * mark HW unaccessible, bail out if RH has been resumed. Use
 263          * the spinlock to properly synchronize with possible pending
 264          * RH suspend or resume activity.
 265          */
 266         spin_lock_irqsave(&ohci->lock, flags);
 267         if (ohci->rh_state != OHCI_RH_SUSPENDED &&
 268                         ohci->rh_state != OHCI_RH_HALTED) {
 269                 rc = -EINVAL;
 270                 goto fail;
 271         }
 272
 273         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 274
 275         if (exynos_ohci->otg)
 276                 exynos_ohci->otg->set_host(exynos_ohci->otg,
 277                                         &exynos_ohci->hcd->self);
 278
 279         exynos_ohci_phy_disable(exynos_ohci);
 280
 281         clk_disable_unprepare(exynos_ohci->clk);
 282
 283 fail:
 284         spin_unlock_irqrestore(&ohci->lock, flags);
 285
 286         return rc;
 287 }
 288
 289 static int exynos_ohci_resume(struct device *dev)
 290 {
 291         struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
 292         struct usb_hcd *hcd = exynos_ohci->hcd;
 293
 294         clk_prepare_enable(exynos_ohci->clk);
 295
 296         if (exynos_ohci->otg)
 297                 exynos_ohci->otg->set_host(exynos_ohci->otg,
 298                                         &exynos_ohci->hcd->self);
 299
 300         exynos_ohci_phy_enable(exynos_ohci);
 301
 302         ohci_resume(hcd, false);
 303
 304         return 0;
 305 }
 306 #else
 307 #define exynos_ohci_suspend     NULL
 308 #define exynos_ohci_resume      NULL
 309 #endif
 310
 311 static const struct dev_pm_ops exynos_ohci_pm_ops = {
 312         .suspend        = exynos_ohci_suspend,
 313         .resume         = exynos_ohci_resume,
 314 };
 315
 316 #ifdef CONFIG_OF
 317 static const struct of_device_id exynos_ohci_match[] = {
 318         { .compatible = "samsung,exynos4210-ohci" },
 319         { .compatible = "samsung,exynos5440-ohci" },
 320         {},
 321 };
 322 MODULE_DEVICE_TABLE(of, exynos_ohci_match);
 323 #endif
 324
 325 static struct platform_driver exynos_ohci_driver = {
 326         .probe          = exynos_ohci_probe,
 327         .remove         = exynos_ohci_remove,
 328         .shutdown       = exynos_ohci_shutdown,
 329         .driver = {
 330                 .name   = "exynos-ohci",
 331                 .owner  = THIS_MODULE,
 332                 .pm     = &exynos_ohci_pm_ops,
 333                 .of_match_table = of_match_ptr(exynos_ohci_match),
 334         }
 335 };
 336
 337 MODULE_ALIAS("platform:exynos-ohci");
 338 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");