drivers/usb/chipidea/usbmisc_imx.c

   1 /*
   2  * Copyright 2012-2013 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/err.h>
  15 #include <linux/io.h>
  16 #include <linux/delay.h>
  17
  18 #include "ci_hdrc_imx.h"
  19
  20 #define MX25_USB_PHY_CTRL_OFFSET        0x08
  21 #define MX25_BM_EXTERNAL_VBUS_DIVIDER   BIT(23)
  22
  23 #define MX25_EHCI_INTERFACE_SINGLE_UNI  (2 << 0)
  24 #define MX25_EHCI_INTERFACE_DIFF_UNI    (0 << 0)
  25 #define MX25_EHCI_INTERFACE_MASK        (0xf)
  26
  27 #define MX25_OTG_SIC_SHIFT              29
  28 #define MX25_OTG_SIC_MASK               (0x3 << MX25_OTG_SIC_SHIFT)
  29 #define MX25_OTG_PM_BIT                 BIT(24)
  30 #define MX25_OTG_PP_BIT                 BIT(11)
  31 #define MX25_OTG_OCPOL_BIT              BIT(3)
  32
  33 #define MX25_H1_SIC_SHIFT               21
  34 #define MX25_H1_SIC_MASK                (0x3 << MX25_H1_SIC_SHIFT)
  35 #define MX25_H1_PP_BIT                  BIT(18)
  36 #define MX25_H1_PM_BIT                  BIT(16)
  37 #define MX25_H1_IPPUE_UP_BIT            BIT(7)
  38 #define MX25_H1_IPPUE_DOWN_BIT          BIT(6)
  39 #define MX25_H1_TLL_BIT                 BIT(5)
  40 #define MX25_H1_USBTE_BIT               BIT(4)
  41 #define MX25_H1_OCPOL_BIT               BIT(2)
  42
  43 #define MX27_H1_PM_BIT                  BIT(8)
  44 #define MX27_H2_PM_BIT                  BIT(16)
  45 #define MX27_OTG_PM_BIT                 BIT(24)
  46
  47 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
  48 #define MX53_USB_OTG_PHY_CTRL_1_OFFSET  0x0c
  49 #define MX53_USB_UH2_CTRL_OFFSET        0x14
  50 #define MX53_USB_UH3_CTRL_OFFSET        0x18
  51 #define MX53_BM_OVER_CUR_DIS_H1         BIT(5)
  52 #define MX53_BM_OVER_CUR_DIS_OTG        BIT(8)
  53 #define MX53_BM_OVER_CUR_DIS_UHx        BIT(30)
  54 #define MX53_USB_PHYCTRL1_PLLDIV_MASK   0x3
  55 #define MX53_USB_PLL_DIV_24_MHZ         0x01
  56
  57 #define MX6_BM_OVER_CUR_DIS             BIT(7)
  58
  59 struct usbmisc_ops {
  60         /* It's called once when probe a usb device */
  61         int (*init)(struct imx_usbmisc_data *data);
  62         /* It's called once after adding a usb device */
  63         int (*post)(struct imx_usbmisc_data *data);
  64 };
  65
  66 struct imx_usbmisc {
  67         void __iomem *base;
  68         spinlock_t lock;
  69         const struct usbmisc_ops *ops;
  70 };
  71
  72 static struct imx_usbmisc *usbmisc;
  73
  74 static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
  75 {
  76         unsigned long flags;
  77         u32 val = 0;
  78
  79         if (data->index > 1)
  80                 return -EINVAL;
  81
  82         spin_lock_irqsave(&usbmisc->lock, flags);
  83         switch (data->index) {
  84         case 0:
  85                 val = readl(usbmisc->base);
  86                 val &= ~(MX25_OTG_SIC_MASK | MX25_OTG_PP_BIT);
  87                 val |= (MX25_EHCI_INTERFACE_DIFF_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_OTG_SIC_SHIFT;
  88                 val |= (MX25_OTG_PM_BIT | MX25_OTG_OCPOL_BIT);
  89                 writel(val, usbmisc->base);
  90                 break;
  91         case 1:
  92                 val = readl(usbmisc->base);
  93                 val &= ~(MX25_H1_SIC_MASK | MX25_H1_PP_BIT |  MX25_H1_IPPUE_UP_BIT);
  94                 val |= (MX25_EHCI_INTERFACE_SINGLE_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_H1_SIC_SHIFT;
  95                 val |= (MX25_H1_PM_BIT | MX25_H1_OCPOL_BIT | MX25_H1_TLL_BIT |
  96                         MX25_H1_USBTE_BIT | MX25_H1_IPPUE_DOWN_BIT);
  97
  98                 writel(val, usbmisc->base);
  99
 100                 break;
 101         }
 102         spin_unlock_irqrestore(&usbmisc->lock, flags);
 103
 104         return 0;
 105 }
 106
 107 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 108 {
 109         void __iomem *reg;
 110         unsigned long flags;
 111         u32 val;
 112
 113         if (data->index > 2)
 114                 return -EINVAL;
 115
 116         reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET;
 117
 118         if (data->evdo) {
 119                 spin_lock_irqsave(&usbmisc->lock, flags);
 120                 val = readl(reg);
 121                 writel(val | MX25_BM_EXTERNAL_VBUS_DIVIDER, reg);
 122                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 123                 usleep_range(5000, 10000); /* needed to stabilize voltage */
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
 130 {
 131         unsigned long flags;
 132         u32 val;
 133
 134         switch (data->index) {
 135         case 0:
 136                 val = MX27_OTG_PM_BIT;
 137                 break;
 138         case 1:
 139                 val = MX27_H1_PM_BIT;
 140                 break;
 141         case 2:
 142                 val = MX27_H2_PM_BIT;
 143                 break;
 144         default:
 145                 return -EINVAL;
 146         };
 147
 148         spin_lock_irqsave(&usbmisc->lock, flags);
 149         if (data->disable_oc)
 150                 val = readl(usbmisc->base) | val;
 151         else
 152                 val = readl(usbmisc->base) & ~val;
 153         writel(val, usbmisc->base);
 154         spin_unlock_irqrestore(&usbmisc->lock, flags);
 155
 156         return 0;
 157 }
 158
 159 static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
 160 {
 161         void __iomem *reg = NULL;
 162         unsigned long flags;
 163         u32 val = 0;
 164
 165         if (data->index > 3)
 166                 return -EINVAL;
 167
 168         /* Select a 24 MHz reference clock for the PHY  */
 169         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET;
 170         val = readl(reg);
 171         val &= ~MX53_USB_PHYCTRL1_PLLDIV_MASK;
 172         val |= MX53_USB_PLL_DIV_24_MHZ;
 173         writel(val, usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
 174
 175         if (data->disable_oc) {
 176                 spin_lock_irqsave(&usbmisc->lock, flags);
 177                 switch (data->index) {
 178                 case 0:
 179                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
 180                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG;
 181                         break;
 182                 case 1:
 183                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
 184                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1;
 185                         break;
 186                 case 2:
 187                         reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
 188                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
 189                         break;
 190                 case 3:
 191                         reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
 192                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
 193                         break;
 194                 }
 195                 if (reg && val)
 196                         writel(val, reg);
 197                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 198         }
 199
 200         return 0;
 201 }
 202
 203 static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 204 {
 205         unsigned long flags;
 206         u32 reg;
 207
 208         if (data->index > 3)
 209                 return -EINVAL;
 210
 211         if (data->disable_oc) {
 212                 spin_lock_irqsave(&usbmisc->lock, flags);
 213                 reg = readl(usbmisc->base + data->index * 4);
 214                 writel(reg | MX6_BM_OVER_CUR_DIS,
 215                         usbmisc->base + data->index * 4);
 216                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 217         }
 218
 219         return 0;
 220 }
 221
 222 static const struct usbmisc_ops imx25_usbmisc_ops = {
 223         .init = usbmisc_imx25_init,
 224         .post = usbmisc_imx25_post,
 225 };
 226
 227 static const struct usbmisc_ops imx27_usbmisc_ops = {
 228         .init = usbmisc_imx27_init,
 229 };
 230
 231 static const struct usbmisc_ops imx53_usbmisc_ops = {
 232         .init = usbmisc_imx53_init,
 233 };
 234
 235 static const struct usbmisc_ops imx6q_usbmisc_ops = {
 236         .init = usbmisc_imx6q_init,
 237 };
 238
 239 int imx_usbmisc_init(struct imx_usbmisc_data *data)
 240 {
 241         if (!usbmisc)
 242                 return -EPROBE_DEFER;
 243         if (!usbmisc->ops->init)
 244                 return 0;
 245         return usbmisc->ops->init(data);
 246 }
 247 EXPORT_SYMBOL_GPL(imx_usbmisc_init);
 248
 249 int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
 250 {
 251         if (!usbmisc)
 252                 return -EPROBE_DEFER;
 253         if (!usbmisc->ops->post)
 254                 return 0;
 255         return usbmisc->ops->post(data);
 256 }
 257 EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);
 258
 259 static const struct of_device_id usbmisc_imx_dt_ids[] = {
 260         {
 261                 .compatible = "fsl,imx25-usbmisc",
 262                 .data = &imx25_usbmisc_ops,
 263         },
 264         {
 265                 .compatible = "fsl,imx35-usbmisc",
 266                 .data = &imx25_usbmisc_ops,
 267         },
 268         {
 269                 .compatible = "fsl,imx27-usbmisc",
 270                 .data = &imx27_usbmisc_ops,
 271         },
 272         {
 273                 .compatible = "fsl,imx51-usbmisc",
 274                 .data = &imx53_usbmisc_ops,
 275         },
 276         {
 277                 .compatible = "fsl,imx53-usbmisc",
 278                 .data = &imx53_usbmisc_ops,
 279         },
 280         {
 281                 .compatible = "fsl,imx6q-usbmisc",
 282                 .data = &imx6q_usbmisc_ops,
 283         },
 284         { /* sentinel */ }
 285 };
 286 MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
 287
 288 static int usbmisc_imx_probe(struct platform_device *pdev)
 289 {
 290         struct resource *res;
 291         struct imx_usbmisc *data;
 292         struct of_device_id *tmp_dev;
 293
 294         if (usbmisc)
 295                 return -EBUSY;
 296
 297         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 298         if (!data)
 299                 return -ENOMEM;
 300
 301         spin_lock_init(&data->lock);
 302
 303         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 304         data->base = devm_ioremap_resource(&pdev->dev, res);
 305         if (IS_ERR(data->base))
 306                 return PTR_ERR(data->base);
 307
 308         tmp_dev = (struct of_device_id *)
 309                 of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
 310         data->ops = (const struct usbmisc_ops *)tmp_dev->data;
 311         usbmisc = data;
 312
 313         return 0;
 314 }
 315
 316 static int usbmisc_imx_remove(struct platform_device *pdev)
 317 {
 318         usbmisc = NULL;
 319         return 0;
 320 }
 321
 322 static struct platform_driver usbmisc_imx_driver = {
 323         .probe = usbmisc_imx_probe,
 324         .remove = usbmisc_imx_remove,
 325         .driver = {
 326                 .name = "usbmisc_imx",
 327                 .owner = THIS_MODULE,
 328                 .of_match_table = usbmisc_imx_dt_ids,
 329          },
 330 };
 331
 332 module_platform_driver(usbmisc_imx_driver);
 333
 334 MODULE_ALIAS("platform:usbmisc-imx");
 335 MODULE_LICENSE("GPL v2");
 336 MODULE_DESCRIPTION("driver for imx usb non-core registers");
 337 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");