drivers/usb/chipidea/usbmisc_imx.c

   1 /*
   2  * Copyright 2012 Freescale Semiconductor, Inc.
   3  *
   4  * The code contained herein is licensed under the GNU General Public
   5  * License. You may obtain a copy of the GNU General Public License
   6  * Version 2 or later at the following locations:
   7  *
   8  * http://www.opensource.org/licenses/gpl-license.html
   9  * http://www.gnu.org/copyleft/gpl.html
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/of_platform.h>
  14 #include <linux/clk.h>
  15 #include <linux/err.h>
  16 #include <linux/io.h>
  17
  18 #include "ci13xxx_imx.h"
  19
  20 #define USB_DEV_MAX 4
  21
  22 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
  23 #define MX53_USB_UH2_CTRL_OFFSET        0x14
  24 #define MX53_USB_UH3_CTRL_OFFSET        0x18
  25 #define MX53_BM_OVER_CUR_DIS_H1         BIT(5)
  26 #define MX53_BM_OVER_CUR_DIS_OTG        BIT(8)
  27 #define MX53_BM_OVER_CUR_DIS_UHx        BIT(30)
  28
  29 #define MX6_BM_OVER_CUR_DIS             BIT(7)
  30
  31 struct imx_usbmisc {
  32         void __iomem *base;
  33         spinlock_t lock;
  34         struct clk *clk;
  35         struct usbmisc_usb_device usbdev[USB_DEV_MAX];
  36         const struct usbmisc_ops *ops;
  37 };
  38
  39 static struct imx_usbmisc *usbmisc;
  40
  41 static struct usbmisc_usb_device *get_usbdev(struct device *dev)
  42 {
  43         int i, ret;
  44
  45         for (i = 0; i < USB_DEV_MAX; i++) {
  46                 if (usbmisc->usbdev[i].dev == dev)
  47                         return &usbmisc->usbdev[i];
  48                 else if (!usbmisc->usbdev[i].dev)
  49                         break;
  50         }
  51
  52         if (i >= USB_DEV_MAX)
  53                 return ERR_PTR(-EBUSY);
  54
  55         ret = usbmisc_get_init_data(dev, &usbmisc->usbdev[i]);
  56         if (ret)
  57                 return ERR_PTR(ret);
  58
  59         return &usbmisc->usbdev[i];
  60 }
  61
  62 static int usbmisc_imx53_init(struct device *dev)
  63 {
  64         struct usbmisc_usb_device *usbdev;
  65         void __iomem *reg = NULL;
  66         unsigned long flags;
  67         u32 val = 0;
  68
  69         usbdev = get_usbdev(dev);
  70         if (IS_ERR(usbdev))
  71                 return PTR_ERR(usbdev);
  72
  73         if (usbdev->disable_oc) {
  74                 spin_lock_irqsave(&usbmisc->lock, flags);
  75                 switch (usbdev->index) {
  76                 case 0:
  77                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
  78                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG;
  79                         break;
  80                 case 1:
  81                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
  82                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1;
  83                         break;
  84                 case 2:
  85                         reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
  86                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
  87                         break;
  88                 case 3:
  89                         reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
  90                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
  91                         break;
  92                 }
  93                 if (reg && val)
  94                         writel(val, reg);
  95                 spin_unlock_irqrestore(&usbmisc->lock, flags);
  96         }
  97
  98         return 0;
  99 }
 100
 101 static int usbmisc_imx6q_init(struct device *dev)
 102 {
 103
 104         struct usbmisc_usb_device *usbdev;
 105         unsigned long flags;
 106         u32 reg;
 107
 108         usbdev = get_usbdev(dev);
 109         if (IS_ERR(usbdev))
 110                 return PTR_ERR(usbdev);
 111
 112         if (usbdev->disable_oc) {
 113                 spin_lock_irqsave(&usbmisc->lock, flags);
 114                 reg = readl(usbmisc->base + usbdev->index * 4);
 115                 writel(reg | MX6_BM_OVER_CUR_DIS,
 116                         usbmisc->base + usbdev->index * 4);
 117                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 118         }
 119
 120         return 0;
 121 }
 122
 123 static const struct usbmisc_ops imx53_usbmisc_ops = {
 124         .init = usbmisc_imx53_init,
 125 };
 126
 127 static const struct usbmisc_ops imx6q_usbmisc_ops = {
 128         .init = usbmisc_imx6q_init,
 129 };
 130
 131 static const struct of_device_id usbmisc_imx_dt_ids[] = {
 132         {
 133                 .compatible = "fsl,imx53-usbmisc",
 134                 .data = &imx53_usbmisc_ops,
 135         },
 136         {
 137                 .compatible = "fsl,imx6q-usbmisc",
 138                 .data = &imx6q_usbmisc_ops,
 139         },
 140         { /* sentinel */ }
 141 };
 142
 143 static int usbmisc_imx_probe(struct platform_device *pdev)
 144 {
 145         struct resource *res;
 146         struct imx_usbmisc *data;
 147         int ret;
 148         struct of_device_id *tmp_dev;
 149
 150         if (usbmisc)
 151                 return -EBUSY;
 152
 153         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 154         if (!data)
 155                 return -ENOMEM;
 156
 157         spin_lock_init(&data->lock);
 158
 159         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 160         data->base = devm_ioremap_resource(&pdev->dev, res);
 161         if (IS_ERR(data->base))
 162                 return PTR_ERR(data->base);
 163
 164         data->clk = devm_clk_get(&pdev->dev, NULL);
 165         if (IS_ERR(data->clk)) {
 166                 dev_err(&pdev->dev,
 167                         "failed to get clock, err=%ld\n", PTR_ERR(data->clk));
 168                 return PTR_ERR(data->clk);
 169         }
 170
 171         ret = clk_prepare_enable(data->clk);
 172         if (ret) {
 173                 dev_err(&pdev->dev,
 174                         "clk_prepare_enable failed, err=%d\n", ret);
 175                 return ret;
 176         }
 177
 178         tmp_dev = (struct of_device_id *)
 179                 of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
 180         data->ops = (const struct usbmisc_ops *)tmp_dev->data;
 181         usbmisc = data;
 182         ret = usbmisc_set_ops(data->ops);
 183         if (ret) {
 184                 usbmisc = NULL;
 185                 clk_disable_unprepare(data->clk);
 186                 return ret;
 187         }
 188
 189         return 0;
 190 }
 191
 192 static int usbmisc_imx_remove(struct platform_device *pdev)
 193 {
 194         usbmisc_unset_ops(usbmisc->ops);
 195         clk_disable_unprepare(usbmisc->clk);
 196         usbmisc = NULL;
 197         return 0;
 198 }
 199
 200 static struct platform_driver usbmisc_imx_driver = {
 201         .probe = usbmisc_imx_probe,
 202         .remove = usbmisc_imx_remove,
 203         .driver = {
 204                 .name = "usbmisc_imx",
 205                 .owner = THIS_MODULE,
 206                 .of_match_table = usbmisc_imx_dt_ids,
 207          },
 208 };
 209
 210 int usbmisc_imx_drv_init(void)
 211 {
 212         return platform_driver_register(&usbmisc_imx_driver);
 213 }
 214 subsys_initcall(usbmisc_imx_drv_init);
 215
 216 void usbmisc_imx_drv_exit(void)
 217 {
 218         platform_driver_unregister(&usbmisc_imx_driver);
 219 }
 220 module_exit(usbmisc_imx_drv_exit);
 221
 222 MODULE_ALIAS("platform:usbmisc-imx");
 223 MODULE_LICENSE("GPL v2");
 224 MODULE_DESCRIPTION("driver for imx usb non-core registers");
 225 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");