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 MX6_BM_OVER_CUR_DIS             BIT(7)
  23
  24 struct imx_usbmisc {
  25         void __iomem *base;
  26         spinlock_t lock;
  27         struct clk *clk;
  28         struct usbmisc_usb_device usbdev[USB_DEV_MAX];
  29         const struct usbmisc_ops *ops;
  30 };
  31
  32 static struct imx_usbmisc *usbmisc;
  33
  34 static struct usbmisc_usb_device *get_usbdev(struct device *dev)
  35 {
  36         int i, ret;
  37
  38         for (i = 0; i < USB_DEV_MAX; i++) {
  39                 if (usbmisc->usbdev[i].dev == dev)
  40                         return &usbmisc->usbdev[i];
  41                 else if (!usbmisc->usbdev[i].dev)
  42                         break;
  43         }
  44
  45         if (i >= USB_DEV_MAX)
  46                 return ERR_PTR(-EBUSY);
  47
  48         ret = usbmisc_get_init_data(dev, &usbmisc->usbdev[i]);
  49         if (ret)
  50                 return ERR_PTR(ret);
  51
  52         return &usbmisc->usbdev[i];
  53 }
  54
  55 static int usbmisc_imx6q_init(struct device *dev)
  56 {
  57
  58         struct usbmisc_usb_device *usbdev;
  59         unsigned long flags;
  60         u32 reg;
  61
  62         usbdev = get_usbdev(dev);
  63         if (IS_ERR(usbdev))
  64                 return PTR_ERR(usbdev);
  65
  66         if (usbdev->disable_oc) {
  67                 spin_lock_irqsave(&usbmisc->lock, flags);
  68                 reg = readl(usbmisc->base + usbdev->index * 4);
  69                 writel(reg | MX6_BM_OVER_CUR_DIS,
  70                         usbmisc->base + usbdev->index * 4);
  71                 spin_unlock_irqrestore(&usbmisc->lock, flags);
  72         }
  73
  74         return 0;
  75 }
  76
  77 static const struct usbmisc_ops imx6q_usbmisc_ops = {
  78         .init = usbmisc_imx6q_init,
  79 };
  80
  81 static const struct of_device_id usbmisc_imx_dt_ids[] = {
  82         {
  83                 .compatible = "fsl,imx6q-usbmisc",
  84                 .data = &imx6q_usbmisc_ops,
  85         },
  86         { /* sentinel */ }
  87 };
  88
  89 static int usbmisc_imx_probe(struct platform_device *pdev)
  90 {
  91         struct resource *res;
  92         struct imx_usbmisc *data;
  93         int ret;
  94         struct of_device_id *tmp_dev;
  95
  96         if (usbmisc)
  97                 return -EBUSY;
  98
  99         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 100         if (!data)
 101                 return -ENOMEM;
 102
 103         spin_lock_init(&data->lock);
 104
 105         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 106         data->base = devm_ioremap_resource(&pdev->dev, res);
 107         if (IS_ERR(data->base))
 108                 return PTR_ERR(data->base);
 109
 110         data->clk = devm_clk_get(&pdev->dev, NULL);
 111         if (IS_ERR(data->clk)) {
 112                 dev_err(&pdev->dev,
 113                         "failed to get clock, err=%ld\n", PTR_ERR(data->clk));
 114                 return PTR_ERR(data->clk);
 115         }
 116
 117         ret = clk_prepare_enable(data->clk);
 118         if (ret) {
 119                 dev_err(&pdev->dev,
 120                         "clk_prepare_enable failed, err=%d\n", ret);
 121                 return ret;
 122         }
 123
 124         tmp_dev = (struct of_device_id *)
 125                 of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
 126         data->ops = (const struct usbmisc_ops *)tmp_dev->data;
 127         usbmisc = data;
 128         ret = usbmisc_set_ops(data->ops);
 129         if (ret) {
 130                 usbmisc = NULL;
 131                 clk_disable_unprepare(data->clk);
 132                 return ret;
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int usbmisc_imx_remove(struct platform_device *pdev)
 139 {
 140         usbmisc_unset_ops(usbmisc->ops);
 141         clk_disable_unprepare(usbmisc->clk);
 142         usbmisc = NULL;
 143         return 0;
 144 }
 145
 146 static struct platform_driver usbmisc_imx_driver = {
 147         .probe = usbmisc_imx_probe,
 148         .remove = usbmisc_imx_remove,
 149         .driver = {
 150                 .name = "usbmisc_imx",
 151                 .owner = THIS_MODULE,
 152                 .of_match_table = usbmisc_imx_dt_ids,
 153          },
 154 };
 155
 156 int usbmisc_imx_drv_init(void)
 157 {
 158         return platform_driver_register(&usbmisc_imx_driver);
 159 }
 160 subsys_initcall(usbmisc_imx_drv_init);
 161
 162 void usbmisc_imx_drv_exit(void)
 163 {
 164         platform_driver_unregister(&usbmisc_imx_driver);
 165 }
 166 module_exit(usbmisc_imx_drv_exit);
 167
 168 MODULE_ALIAS("platform:usbmisc-imx");
 169 MODULE_LICENSE("GPL v2");
 170 MODULE_DESCRIPTION("driver for imx usb non-core registers");
 171 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");