drivers/usb/chipidea/usbmisc_imx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2012 Freescale Semiconductor, Inc.
   4  */
   5
   6 #include <linux/module.h>
   7 #include <linux/of_platform.h>
   8 #include <linux/err.h>
   9 #include <linux/io.h>
  10 #include <linux/delay.h>
  11 #include <linux/usb/otg.h>
  12
  13 #include "ci_hdrc_imx.h"
  14
  15 #define MX25_USB_PHY_CTRL_OFFSET        0x08
  16 #define MX25_BM_EXTERNAL_VBUS_DIVIDER   BIT(23)
  17
  18 #define MX25_EHCI_INTERFACE_SINGLE_UNI  (2 << 0)
  19 #define MX25_EHCI_INTERFACE_DIFF_UNI    (0 << 0)
  20 #define MX25_EHCI_INTERFACE_MASK        (0xf)
  21
  22 #define MX25_OTG_SIC_SHIFT              29
  23 #define MX25_OTG_SIC_MASK               (0x3 << MX25_OTG_SIC_SHIFT)
  24 #define MX25_OTG_PM_BIT                 BIT(24)
  25 #define MX25_OTG_PP_BIT                 BIT(11)
  26 #define MX25_OTG_OCPOL_BIT              BIT(3)
  27
  28 #define MX25_H1_SIC_SHIFT               21
  29 #define MX25_H1_SIC_MASK                (0x3 << MX25_H1_SIC_SHIFT)
  30 #define MX25_H1_PP_BIT                  BIT(18)
  31 #define MX25_H1_PM_BIT                  BIT(16)
  32 #define MX25_H1_IPPUE_UP_BIT            BIT(7)
  33 #define MX25_H1_IPPUE_DOWN_BIT          BIT(6)
  34 #define MX25_H1_TLL_BIT                 BIT(5)
  35 #define MX25_H1_USBTE_BIT               BIT(4)
  36 #define MX25_H1_OCPOL_BIT               BIT(2)
  37
  38 #define MX27_H1_PM_BIT                  BIT(8)
  39 #define MX27_H2_PM_BIT                  BIT(16)
  40 #define MX27_OTG_PM_BIT                 BIT(24)
  41
  42 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
  43 #define MX53_USB_OTG_PHY_CTRL_1_OFFSET  0x0c
  44 #define MX53_USB_CTRL_1_OFFSET          0x10
  45 #define MX53_USB_CTRL_1_H2_XCVR_CLK_SEL_MASK (0x11 << 2)
  46 #define MX53_USB_CTRL_1_H2_XCVR_CLK_SEL_ULPI BIT(2)
  47 #define MX53_USB_CTRL_1_H3_XCVR_CLK_SEL_MASK (0x11 << 6)
  48 #define MX53_USB_CTRL_1_H3_XCVR_CLK_SEL_ULPI BIT(6)
  49 #define MX53_USB_UH2_CTRL_OFFSET        0x14
  50 #define MX53_USB_UH3_CTRL_OFFSET        0x18
  51 #define MX53_USB_CLKONOFF_CTRL_OFFSET   0x24
  52 #define MX53_USB_CLKONOFF_CTRL_H2_INT60CKOFF BIT(21)
  53 #define MX53_USB_CLKONOFF_CTRL_H3_INT60CKOFF BIT(22)
  54 #define MX53_BM_OVER_CUR_DIS_H1         BIT(5)
  55 #define MX53_BM_OVER_CUR_DIS_OTG        BIT(8)
  56 #define MX53_BM_OVER_CUR_DIS_UHx        BIT(30)
  57 #define MX53_USB_CTRL_1_UH2_ULPI_EN     BIT(26)
  58 #define MX53_USB_CTRL_1_UH3_ULPI_EN     BIT(27)
  59 #define MX53_USB_UHx_CTRL_WAKE_UP_EN    BIT(7)
  60 #define MX53_USB_UHx_CTRL_ULPI_INT_EN   BIT(8)
  61 #define MX53_USB_PHYCTRL1_PLLDIV_MASK   0x3
  62 #define MX53_USB_PLL_DIV_24_MHZ         0x01
  63
  64 #define MX6_BM_NON_BURST_SETTING        BIT(1)
  65 #define MX6_BM_OVER_CUR_DIS             BIT(7)
  66 #define MX6_BM_OVER_CUR_POLARITY        BIT(8)
  67 #define MX6_BM_PWR_POLARITY             BIT(9)
  68 #define MX6_BM_WAKEUP_ENABLE            BIT(10)
  69 #define MX6_BM_UTMI_ON_CLOCK            BIT(13)
  70 #define MX6_BM_ID_WAKEUP                BIT(16)
  71 #define MX6_BM_VBUS_WAKEUP              BIT(17)
  72 #define MX6SX_BM_DPDM_WAKEUP_EN         BIT(29)
  73 #define MX6_BM_WAKEUP_INTR              BIT(31)
  74
  75 #define MX6_USB_HSIC_CTRL_OFFSET        0x10
  76 /* Send resume signal without 480Mhz PHY clock */
  77 #define MX6SX_BM_HSIC_AUTO_RESUME       BIT(23)
  78 /* set before portsc.suspendM = 1 */
  79 #define MX6_BM_HSIC_DEV_CONN            BIT(21)
  80 /* HSIC enable */
  81 #define MX6_BM_HSIC_EN                  BIT(12)
  82 /* Force HSIC module 480M clock on, even when in Host is in suspend mode */
  83 #define MX6_BM_HSIC_CLK_ON              BIT(11)
  84
  85 #define MX6_USB_OTG1_PHY_CTRL           0x18
  86 /* For imx6dql, it is host-only controller, for later imx6, it is otg's */
  87 #define MX6_USB_OTG2_PHY_CTRL           0x1c
  88 #define MX6SX_USB_VBUS_WAKEUP_SOURCE(v) (v << 8)
  89 #define MX6SX_USB_VBUS_WAKEUP_SOURCE_VBUS       MX6SX_USB_VBUS_WAKEUP_SOURCE(0)
  90 #define MX6SX_USB_VBUS_WAKEUP_SOURCE_AVALID     MX6SX_USB_VBUS_WAKEUP_SOURCE(1)
  91 #define MX6SX_USB_VBUS_WAKEUP_SOURCE_BVALID     MX6SX_USB_VBUS_WAKEUP_SOURCE(2)
  92 #define MX6SX_USB_VBUS_WAKEUP_SOURCE_SESS_END   MX6SX_USB_VBUS_WAKEUP_SOURCE(3)
  93
  94 #define VF610_OVER_CUR_DIS              BIT(7)
  95
  96 #define MX7D_USBNC_USB_CTRL2            0x4
  97 #define MX7D_USB_VBUS_WAKEUP_SOURCE_MASK        0x3
  98 #define MX7D_USB_VBUS_WAKEUP_SOURCE(v)          (v << 0)
  99 #define MX7D_USB_VBUS_WAKEUP_SOURCE_VBUS        MX7D_USB_VBUS_WAKEUP_SOURCE(0)
 100 #define MX7D_USB_VBUS_WAKEUP_SOURCE_AVALID      MX7D_USB_VBUS_WAKEUP_SOURCE(1)
 101 #define MX7D_USB_VBUS_WAKEUP_SOURCE_BVALID      MX7D_USB_VBUS_WAKEUP_SOURCE(2)
 102 #define MX7D_USB_VBUS_WAKEUP_SOURCE_SESS_END    MX7D_USB_VBUS_WAKEUP_SOURCE(3)
 103 #define MX7D_USBNC_AUTO_RESUME                          BIT(2)
 104 /* The default DM/DP value is pull-down */
 105 #define MX7D_USBNC_USB_CTRL2_OPMODE(v)                  (v << 6)
 106 #define MX7D_USBNC_USB_CTRL2_OPMODE_NON_DRIVING MX7D_USBNC_USB_CTRL2_OPMODE(1)
 107 #define MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_MASK       (BIT(7) | BIT(6))
 108 #define MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_EN         BIT(8)
 109 #define MX7D_USBNC_USB_CTRL2_DP_OVERRIDE_VAL            BIT(12)
 110 #define MX7D_USBNC_USB_CTRL2_DP_OVERRIDE_EN             BIT(13)
 111 #define MX7D_USBNC_USB_CTRL2_DM_OVERRIDE_VAL            BIT(14)
 112 #define MX7D_USBNC_USB_CTRL2_DM_OVERRIDE_EN             BIT(15)
 113 #define MX7D_USBNC_USB_CTRL2_DP_DM_MASK                 (BIT(12) | BIT(13) | \
 114                                                         BIT(14) | BIT(15))
 115
 116 #define MX7D_USB_OTG_PHY_CFG1           0x30
 117 #define MX7D_USB_OTG_PHY_CFG2_CHRG_CHRGSEL      BIT(0)
 118 #define MX7D_USB_OTG_PHY_CFG2_CHRG_VDATDETENB0  BIT(1)
 119 #define MX7D_USB_OTG_PHY_CFG2_CHRG_VDATSRCENB0  BIT(2)
 120 #define MX7D_USB_OTG_PHY_CFG2_CHRG_DCDENB       BIT(3)
 121 #define MX7D_USB_OTG_PHY_CFG2_DRVVBUS0          BIT(16)
 122
 123 #define MX7D_USB_OTG_PHY_CFG2           0x34
 124
 125 #define MX7D_USB_OTG_PHY_STATUS         0x3c
 126 #define MX7D_USB_OTG_PHY_STATUS_LINE_STATE0     BIT(0)
 127 #define MX7D_USB_OTG_PHY_STATUS_LINE_STATE1     BIT(1)
 128 #define MX7D_USB_OTG_PHY_STATUS_VBUS_VLD        BIT(3)
 129 #define MX7D_USB_OTG_PHY_STATUS_CHRGDET         BIT(29)
 130
 131 #define MX7D_USB_OTG_PHY_CFG1           0x30
 132 #define TXPREEMPAMPTUNE0_BIT            28
 133 #define TXPREEMPAMPTUNE0_MASK           (3 << 28)
 134 #define TXVREFTUNE0_BIT                 20
 135 #define TXVREFTUNE0_MASK                (0xf << 20)
 136
 137 #define MX6_USB_OTG_WAKEUP_BITS (MX6_BM_WAKEUP_ENABLE | MX6_BM_VBUS_WAKEUP | \
 138                                  MX6_BM_ID_WAKEUP)
 139
 140 struct usbmisc_ops {
 141         /* It's called once when probe a usb device */
 142         int (*init)(struct imx_usbmisc_data *data);
 143         /* It's called once after adding a usb device */
 144         int (*post)(struct imx_usbmisc_data *data);
 145         /* It's called when we need to enable/disable usb wakeup */
 146         int (*set_wakeup)(struct imx_usbmisc_data *data, bool enabled);
 147         /* It's called before setting portsc.suspendM */
 148         int (*hsic_set_connect)(struct imx_usbmisc_data *data);
 149         /* It's called during suspend/resume */
 150         int (*hsic_set_clk)(struct imx_usbmisc_data *data, bool enabled);
 151         /* usb charger detection */
 152         int (*charger_detection)(struct imx_usbmisc_data *data);
 153 };
 154
 155 struct imx_usbmisc {
 156         void __iomem *base;
 157         spinlock_t lock;
 158         const struct usbmisc_ops *ops;
 159 };
 160
 161 static inline bool is_imx53_usbmisc(struct imx_usbmisc_data *data);
 162
 163 static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
 164 {
 165         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 166         unsigned long flags;
 167         u32 val = 0;
 168
 169         if (data->index > 1)
 170                 return -EINVAL;
 171
 172         spin_lock_irqsave(&usbmisc->lock, flags);
 173         switch (data->index) {
 174         case 0:
 175                 val = readl(usbmisc->base);
 176                 val &= ~(MX25_OTG_SIC_MASK | MX25_OTG_PP_BIT);
 177                 val |= (MX25_EHCI_INTERFACE_DIFF_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_OTG_SIC_SHIFT;
 178                 val |= (MX25_OTG_PM_BIT | MX25_OTG_OCPOL_BIT);
 179
 180                 /*
 181                  * If the polarity is not configured assume active high for
 182                  * historical reasons.
 183                  */
 184                 if (data->oc_pol_configured && data->oc_pol_active_low)
 185                         val &= ~MX25_OTG_OCPOL_BIT;
 186
 187                 writel(val, usbmisc->base);
 188                 break;
 189         case 1:
 190                 val = readl(usbmisc->base);
 191                 val &= ~(MX25_H1_SIC_MASK | MX25_H1_PP_BIT |  MX25_H1_IPPUE_UP_BIT);
 192                 val |= (MX25_EHCI_INTERFACE_SINGLE_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_H1_SIC_SHIFT;
 193                 val |= (MX25_H1_PM_BIT | MX25_H1_OCPOL_BIT | MX25_H1_TLL_BIT |
 194                         MX25_H1_USBTE_BIT | MX25_H1_IPPUE_DOWN_BIT);
 195
 196                 /*
 197                  * If the polarity is not configured assume active high for
 198                  * historical reasons.
 199                  */
 200                 if (data->oc_pol_configured && data->oc_pol_active_low)
 201                         val &= ~MX25_H1_OCPOL_BIT;
 202
 203                 writel(val, usbmisc->base);
 204
 205                 break;
 206         }
 207         spin_unlock_irqrestore(&usbmisc->lock, flags);
 208
 209         return 0;
 210 }
 211
 212 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 213 {
 214         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 215         void __iomem *reg;
 216         unsigned long flags;
 217         u32 val;
 218
 219         if (data->index > 2)
 220                 return -EINVAL;
 221
 222         if (data->index)
 223                 return 0;
 224
 225         spin_lock_irqsave(&usbmisc->lock, flags);
 226         reg = usbmisc->base + MX25_USB_PHY_CTRL_OFFSET;
 227         val = readl(reg);
 228
 229         if (data->evdo)
 230                 val |= MX25_BM_EXTERNAL_VBUS_DIVIDER;
 231         else
 232                 val &= ~MX25_BM_EXTERNAL_VBUS_DIVIDER;
 233
 234         writel(val, reg);
 235         spin_unlock_irqrestore(&usbmisc->lock, flags);
 236         usleep_range(5000, 10000); /* needed to stabilize voltage */
 237
 238         return 0;
 239 }
 240
 241 static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
 242 {
 243         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 244         unsigned long flags;
 245         u32 val;
 246
 247         switch (data->index) {
 248         case 0:
 249                 val = MX27_OTG_PM_BIT;
 250                 break;
 251         case 1:
 252                 val = MX27_H1_PM_BIT;
 253                 break;
 254         case 2:
 255                 val = MX27_H2_PM_BIT;
 256                 break;
 257         default:
 258                 return -EINVAL;
 259         }
 260
 261         spin_lock_irqsave(&usbmisc->lock, flags);
 262         if (data->disable_oc)
 263                 val = readl(usbmisc->base) | val;
 264         else
 265                 val = readl(usbmisc->base) & ~val;
 266         writel(val, usbmisc->base);
 267         spin_unlock_irqrestore(&usbmisc->lock, flags);
 268
 269         return 0;
 270 }
 271
 272 static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
 273 {
 274         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 275         void __iomem *reg = NULL;
 276         unsigned long flags;
 277         u32 val = 0;
 278
 279         if (data->index > 3)
 280                 return -EINVAL;
 281
 282         /* Select a 24 MHz reference clock for the PHY  */
 283         val = readl(usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
 284         val &= ~MX53_USB_PHYCTRL1_PLLDIV_MASK;
 285         val |= MX53_USB_PLL_DIV_24_MHZ;
 286         writel(val, usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
 287
 288         spin_lock_irqsave(&usbmisc->lock, flags);
 289
 290         switch (data->index) {
 291         case 0:
 292                 if (data->disable_oc) {
 293                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
 294                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_OTG;
 295                         writel(val, reg);
 296                 }
 297                 break;
 298         case 1:
 299                 if (data->disable_oc) {
 300                         reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_0_OFFSET;
 301                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_H1;
 302                         writel(val, reg);
 303                 }
 304                 break;
 305         case 2:
 306                 if (data->ulpi) {
 307                         /* set USBH2 into ULPI-mode. */
 308                         reg = usbmisc->base + MX53_USB_CTRL_1_OFFSET;
 309                         val = readl(reg) | MX53_USB_CTRL_1_UH2_ULPI_EN;
 310                         /* select ULPI clock */
 311                         val &= ~MX53_USB_CTRL_1_H2_XCVR_CLK_SEL_MASK;
 312                         val |= MX53_USB_CTRL_1_H2_XCVR_CLK_SEL_ULPI;
 313                         writel(val, reg);
 314                         /* Set interrupt wake up enable */
 315                         reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
 316                         val = readl(reg) | MX53_USB_UHx_CTRL_WAKE_UP_EN
 317                                 | MX53_USB_UHx_CTRL_ULPI_INT_EN;
 318                         writel(val, reg);
 319                         if (is_imx53_usbmisc(data)) {
 320                                 /* Disable internal 60Mhz clock */
 321                                 reg = usbmisc->base +
 322                                         MX53_USB_CLKONOFF_CTRL_OFFSET;
 323                                 val = readl(reg) |
 324                                         MX53_USB_CLKONOFF_CTRL_H2_INT60CKOFF;
 325                                 writel(val, reg);
 326                         }
 327
 328                 }
 329                 if (data->disable_oc) {
 330                         reg = usbmisc->base + MX53_USB_UH2_CTRL_OFFSET;
 331                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
 332                         writel(val, reg);
 333                 }
 334                 break;
 335         case 3:
 336                 if (data->ulpi) {
 337                         /* set USBH3 into ULPI-mode. */
 338                         reg = usbmisc->base + MX53_USB_CTRL_1_OFFSET;
 339                         val = readl(reg) | MX53_USB_CTRL_1_UH3_ULPI_EN;
 340                         /* select ULPI clock */
 341                         val &= ~MX53_USB_CTRL_1_H3_XCVR_CLK_SEL_MASK;
 342                         val |= MX53_USB_CTRL_1_H3_XCVR_CLK_SEL_ULPI;
 343                         writel(val, reg);
 344                         /* Set interrupt wake up enable */
 345                         reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
 346                         val = readl(reg) | MX53_USB_UHx_CTRL_WAKE_UP_EN
 347                                 | MX53_USB_UHx_CTRL_ULPI_INT_EN;
 348                         writel(val, reg);
 349
 350                         if (is_imx53_usbmisc(data)) {
 351                                 /* Disable internal 60Mhz clock */
 352                                 reg = usbmisc->base +
 353                                         MX53_USB_CLKONOFF_CTRL_OFFSET;
 354                                 val = readl(reg) |
 355                                         MX53_USB_CLKONOFF_CTRL_H3_INT60CKOFF;
 356                                 writel(val, reg);
 357                         }
 358                 }
 359                 if (data->disable_oc) {
 360                         reg = usbmisc->base + MX53_USB_UH3_CTRL_OFFSET;
 361                         val = readl(reg) | MX53_BM_OVER_CUR_DIS_UHx;
 362                         writel(val, reg);
 363                 }
 364                 break;
 365         }
 366
 367         spin_unlock_irqrestore(&usbmisc->lock, flags);
 368
 369         return 0;
 370 }
 371
 372 static u32 usbmisc_wakeup_setting(struct imx_usbmisc_data *data)
 373 {
 374         u32 wakeup_setting = MX6_USB_OTG_WAKEUP_BITS;
 375
 376         if (data->ext_id || data->available_role != USB_DR_MODE_OTG)
 377                 wakeup_setting &= ~MX6_BM_ID_WAKEUP;
 378
 379         if (data->ext_vbus || data->available_role == USB_DR_MODE_HOST)
 380                 wakeup_setting &= ~MX6_BM_VBUS_WAKEUP;
 381
 382         return wakeup_setting;
 383 }
 384
 385 static int usbmisc_imx6q_set_wakeup
 386         (struct imx_usbmisc_data *data, bool enabled)
 387 {
 388         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 389         unsigned long flags;
 390         u32 val;
 391         int ret = 0;
 392
 393         if (data->index > 3)
 394                 return -EINVAL;
 395
 396         spin_lock_irqsave(&usbmisc->lock, flags);
 397         val = readl(usbmisc->base + data->index * 4);
 398         if (enabled) {
 399                 val &= ~MX6_USB_OTG_WAKEUP_BITS;
 400                 val |= usbmisc_wakeup_setting(data);
 401         } else {
 402                 if (val & MX6_BM_WAKEUP_INTR)
 403                         pr_debug("wakeup int at ci_hdrc.%d\n", data->index);
 404                 val &= ~MX6_USB_OTG_WAKEUP_BITS;
 405         }
 406         writel(val, usbmisc->base + data->index * 4);
 407         spin_unlock_irqrestore(&usbmisc->lock, flags);
 408
 409         return ret;
 410 }
 411
 412 static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 413 {
 414         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 415         unsigned long flags;
 416         u32 reg;
 417
 418         if (data->index > 3)
 419                 return -EINVAL;
 420
 421         spin_lock_irqsave(&usbmisc->lock, flags);
 422
 423         reg = readl(usbmisc->base + data->index * 4);
 424         if (data->disable_oc) {
 425                 reg |= MX6_BM_OVER_CUR_DIS;
 426         } else {
 427                 reg &= ~MX6_BM_OVER_CUR_DIS;
 428
 429                 /*
 430                  * If the polarity is not configured keep it as setup by the
 431                  * bootloader.
 432                  */
 433                 if (data->oc_pol_configured && data->oc_pol_active_low)
 434                         reg |= MX6_BM_OVER_CUR_POLARITY;
 435                 else if (data->oc_pol_configured)
 436                         reg &= ~MX6_BM_OVER_CUR_POLARITY;
 437         }
 438         /* If the polarity is not set keep it as setup by the bootlader */
 439         if (data->pwr_pol == 1)
 440                 reg |= MX6_BM_PWR_POLARITY;
 441         writel(reg, usbmisc->base + data->index * 4);
 442
 443         /* SoC non-burst setting */
 444         reg = readl(usbmisc->base + data->index * 4);
 445         writel(reg | MX6_BM_NON_BURST_SETTING,
 446                         usbmisc->base + data->index * 4);
 447
 448         /* For HSIC controller */
 449         if (data->hsic) {
 450                 reg = readl(usbmisc->base + data->index * 4);
 451                 writel(reg | MX6_BM_UTMI_ON_CLOCK,
 452                         usbmisc->base + data->index * 4);
 453                 reg = readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET
 454                         + (data->index - 2) * 4);
 455                 reg |= MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON;
 456                 writel(reg, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET
 457                         + (data->index - 2) * 4);
 458         }
 459
 460         spin_unlock_irqrestore(&usbmisc->lock, flags);
 461
 462         usbmisc_imx6q_set_wakeup(data, false);
 463
 464         return 0;
 465 }
 466
 467 static int usbmisc_imx6_hsic_get_reg_offset(struct imx_usbmisc_data *data)
 468 {
 469         int offset, ret = 0;
 470
 471         if (data->index == 2 || data->index == 3) {
 472                 offset = (data->index - 2) * 4;
 473         } else if (data->index == 0) {
 474                 /*
 475                  * For SoCs like i.MX7D and later, each USB controller has
 476                  * its own non-core register region. For SoCs before i.MX7D,
 477                  * the first two USB controllers are non-HSIC controllers.
 478                  */
 479                 offset = 0;
 480         } else {
 481                 dev_err(data->dev, "index is error for usbmisc\n");
 482                 ret = -EINVAL;
 483         }
 484
 485         return ret ? ret : offset;
 486 }
 487
 488 static int usbmisc_imx6_hsic_set_connect(struct imx_usbmisc_data *data)
 489 {
 490         unsigned long flags;
 491         u32 val;
 492         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 493         int offset;
 494
 495         spin_lock_irqsave(&usbmisc->lock, flags);
 496         offset = usbmisc_imx6_hsic_get_reg_offset(data);
 497         if (offset < 0) {
 498                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 499                 return offset;
 500         }
 501
 502         val = readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset);
 503         if (!(val & MX6_BM_HSIC_DEV_CONN))
 504                 writel(val | MX6_BM_HSIC_DEV_CONN,
 505                         usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset);
 506
 507         spin_unlock_irqrestore(&usbmisc->lock, flags);
 508
 509         return 0;
 510 }
 511
 512 static int usbmisc_imx6_hsic_set_clk(struct imx_usbmisc_data *data, bool on)
 513 {
 514         unsigned long flags;
 515         u32 val;
 516         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 517         int offset;
 518
 519         spin_lock_irqsave(&usbmisc->lock, flags);
 520         offset = usbmisc_imx6_hsic_get_reg_offset(data);
 521         if (offset < 0) {
 522                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 523                 return offset;
 524         }
 525
 526         val = readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset);
 527         val |= MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON;
 528         if (on)
 529                 val |= MX6_BM_HSIC_CLK_ON;
 530         else
 531                 val &= ~MX6_BM_HSIC_CLK_ON;
 532
 533         writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET + offset);
 534         spin_unlock_irqrestore(&usbmisc->lock, flags);
 535
 536         return 0;
 537 }
 538
 539
 540 static int usbmisc_imx6sx_init(struct imx_usbmisc_data *data)
 541 {
 542         void __iomem *reg = NULL;
 543         unsigned long flags;
 544         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 545         u32 val;
 546
 547         usbmisc_imx6q_init(data);
 548
 549         if (data->index == 0 || data->index == 1) {
 550                 reg = usbmisc->base + MX6_USB_OTG1_PHY_CTRL + data->index * 4;
 551                 spin_lock_irqsave(&usbmisc->lock, flags);
 552                 /* Set vbus wakeup source as bvalid */
 553                 val = readl(reg);
 554                 writel(val | MX6SX_USB_VBUS_WAKEUP_SOURCE_BVALID, reg);
 555                 /*
 556                  * Disable dp/dm wakeup in device mode when vbus is
 557                  * not there.
 558                  */
 559                 val = readl(usbmisc->base + data->index * 4);
 560                 writel(val & ~MX6SX_BM_DPDM_WAKEUP_EN,
 561                         usbmisc->base + data->index * 4);
 562                 spin_unlock_irqrestore(&usbmisc->lock, flags);
 563         }
 564
 565         /* For HSIC controller */
 566         if (data->hsic) {
 567                 val = readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET);
 568                 val |= MX6SX_BM_HSIC_AUTO_RESUME;
 569                 writel(val, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET);
 570         }
 571
 572         return 0;
 573 }
 574
 575 static int usbmisc_vf610_init(struct imx_usbmisc_data *data)
 576 {
 577         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 578         u32 reg;
 579
 580         /*
 581          * Vybrid only has one misc register set, but in two different
 582          * areas. These is reflected in two instances of this driver.
 583          */
 584         if (data->index >= 1)
 585                 return -EINVAL;
 586
 587         if (data->disable_oc) {
 588                 reg = readl(usbmisc->base);
 589                 writel(reg | VF610_OVER_CUR_DIS, usbmisc->base);
 590         }
 591
 592         return 0;
 593 }
 594
 595 static int usbmisc_imx7d_set_wakeup
 596         (struct imx_usbmisc_data *data, bool enabled)
 597 {
 598         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 599         unsigned long flags;
 600         u32 val;
 601
 602         spin_lock_irqsave(&usbmisc->lock, flags);
 603         val = readl(usbmisc->base);
 604         if (enabled) {
 605                 val &= ~MX6_USB_OTG_WAKEUP_BITS;
 606                 val |= usbmisc_wakeup_setting(data);
 607                 writel(val, usbmisc->base);
 608         } else {
 609                 if (val & MX6_BM_WAKEUP_INTR)
 610                         dev_dbg(data->dev, "wakeup int\n");
 611                 writel(val & ~MX6_USB_OTG_WAKEUP_BITS, usbmisc->base);
 612         }
 613         spin_unlock_irqrestore(&usbmisc->lock, flags);
 614
 615         return 0;
 616 }
 617
 618 static int usbmisc_imx7d_init(struct imx_usbmisc_data *data)
 619 {
 620         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 621         unsigned long flags;
 622         u32 reg;
 623
 624         if (data->index >= 1)
 625                 return -EINVAL;
 626
 627         spin_lock_irqsave(&usbmisc->lock, flags);
 628         reg = readl(usbmisc->base);
 629         if (data->disable_oc) {
 630                 reg |= MX6_BM_OVER_CUR_DIS;
 631         } else {
 632                 reg &= ~MX6_BM_OVER_CUR_DIS;
 633
 634                 /*
 635                  * If the polarity is not configured keep it as setup by the
 636                  * bootloader.
 637                  */
 638                 if (data->oc_pol_configured && data->oc_pol_active_low)
 639                         reg |= MX6_BM_OVER_CUR_POLARITY;
 640                 else if (data->oc_pol_configured)
 641                         reg &= ~MX6_BM_OVER_CUR_POLARITY;
 642         }
 643         /* If the polarity is not set keep it as setup by the bootlader */
 644         if (data->pwr_pol == 1)
 645                 reg |= MX6_BM_PWR_POLARITY;
 646         writel(reg, usbmisc->base);
 647
 648         /* SoC non-burst setting */
 649         reg = readl(usbmisc->base);
 650         writel(reg | MX6_BM_NON_BURST_SETTING, usbmisc->base);
 651
 652         if (!data->hsic) {
 653                 reg = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 654                 reg &= ~MX7D_USB_VBUS_WAKEUP_SOURCE_MASK;
 655                 writel(reg | MX7D_USB_VBUS_WAKEUP_SOURCE_BVALID
 656                         | MX7D_USBNC_AUTO_RESUME,
 657                         usbmisc->base + MX7D_USBNC_USB_CTRL2);
 658                 /* PHY tuning for signal quality */
 659                 reg = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG1);
 660                 if (data->emp_curr_control && data->emp_curr_control <=
 661                         (TXPREEMPAMPTUNE0_MASK >> TXPREEMPAMPTUNE0_BIT)) {
 662                         reg &= ~TXPREEMPAMPTUNE0_MASK;
 663                         reg |= (data->emp_curr_control << TXPREEMPAMPTUNE0_BIT);
 664                 }
 665
 666                 if (data->dc_vol_level_adjust && data->dc_vol_level_adjust <=
 667                         (TXVREFTUNE0_MASK >> TXVREFTUNE0_BIT)) {
 668                         reg &= ~TXVREFTUNE0_MASK;
 669                         reg |= (data->dc_vol_level_adjust << TXVREFTUNE0_BIT);
 670                 }
 671
 672                 writel(reg, usbmisc->base + MX7D_USB_OTG_PHY_CFG1);
 673         }
 674
 675         spin_unlock_irqrestore(&usbmisc->lock, flags);
 676
 677         usbmisc_imx7d_set_wakeup(data, false);
 678
 679         return 0;
 680 }
 681
 682 static int imx7d_charger_secondary_detection(struct imx_usbmisc_data *data)
 683 {
 684         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 685         struct usb_phy *usb_phy = data->usb_phy;
 686         int val;
 687         unsigned long flags;
 688
 689         /* VDM_SRC is connected to D- and IDP_SINK is connected to D+ */
 690         spin_lock_irqsave(&usbmisc->lock, flags);
 691         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 692         writel(val | MX7D_USB_OTG_PHY_CFG2_CHRG_VDATSRCENB0 |
 693                         MX7D_USB_OTG_PHY_CFG2_CHRG_VDATDETENB0 |
 694                         MX7D_USB_OTG_PHY_CFG2_CHRG_CHRGSEL,
 695                                 usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 696         spin_unlock_irqrestore(&usbmisc->lock, flags);
 697
 698         usleep_range(1000, 2000);
 699
 700         /*
 701          * Per BC 1.2, check voltage of D+:
 702          * DCP: if greater than VDAT_REF;
 703          * CDP: if less than VDAT_REF.
 704          */
 705         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_STATUS);
 706         if (val & MX7D_USB_OTG_PHY_STATUS_CHRGDET) {
 707                 dev_dbg(data->dev, "It is a dedicate charging port\n");
 708                 usb_phy->chg_type = DCP_TYPE;
 709         } else {
 710                 dev_dbg(data->dev, "It is a charging downstream port\n");
 711                 usb_phy->chg_type = CDP_TYPE;
 712         }
 713
 714         return 0;
 715 }
 716
 717 static void imx7_disable_charger_detector(struct imx_usbmisc_data *data)
 718 {
 719         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 720         unsigned long flags;
 721         u32 val;
 722
 723         spin_lock_irqsave(&usbmisc->lock, flags);
 724         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 725         val &= ~(MX7D_USB_OTG_PHY_CFG2_CHRG_DCDENB |
 726                         MX7D_USB_OTG_PHY_CFG2_CHRG_VDATSRCENB0 |
 727                         MX7D_USB_OTG_PHY_CFG2_CHRG_VDATDETENB0 |
 728                         MX7D_USB_OTG_PHY_CFG2_CHRG_CHRGSEL);
 729         writel(val, usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 730
 731         /* Set OPMODE to be 2'b00 and disable its override */
 732         val = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 733         val &= ~MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_MASK;
 734         writel(val, usbmisc->base + MX7D_USBNC_USB_CTRL2);
 735
 736         val = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 737         writel(val & ~MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_EN,
 738                         usbmisc->base + MX7D_USBNC_USB_CTRL2);
 739         spin_unlock_irqrestore(&usbmisc->lock, flags);
 740 }
 741
 742 static int imx7d_charger_data_contact_detect(struct imx_usbmisc_data *data)
 743 {
 744         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 745         unsigned long flags;
 746         u32 val;
 747         int i, data_pin_contact_count = 0;
 748
 749         /* Enable Data Contact Detect (DCD) per the USB BC 1.2 */
 750         spin_lock_irqsave(&usbmisc->lock, flags);
 751         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 752         writel(val | MX7D_USB_OTG_PHY_CFG2_CHRG_DCDENB,
 753                         usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 754         spin_unlock_irqrestore(&usbmisc->lock, flags);
 755
 756         for (i = 0; i < 100; i = i + 1) {
 757                 val = readl(usbmisc->base + MX7D_USB_OTG_PHY_STATUS);
 758                 if (!(val & MX7D_USB_OTG_PHY_STATUS_LINE_STATE0)) {
 759                         if (data_pin_contact_count++ > 5)
 760                                 /* Data pin makes contact */
 761                                 break;
 762                         usleep_range(5000, 10000);
 763                 } else {
 764                         data_pin_contact_count = 0;
 765                         usleep_range(5000, 6000);
 766                 }
 767         }
 768
 769         /* Disable DCD after finished data contact check */
 770         spin_lock_irqsave(&usbmisc->lock, flags);
 771         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 772         writel(val & ~MX7D_USB_OTG_PHY_CFG2_CHRG_DCDENB,
 773                         usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 774         spin_unlock_irqrestore(&usbmisc->lock, flags);
 775
 776         if (i == 100) {
 777                 dev_err(data->dev,
 778                         "VBUS is coming from a dedicated power supply.\n");
 779                 return -ENXIO;
 780         }
 781
 782         return 0;
 783 }
 784
 785 static int imx7d_charger_primary_detection(struct imx_usbmisc_data *data)
 786 {
 787         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 788         struct usb_phy *usb_phy = data->usb_phy;
 789         unsigned long flags;
 790         u32 val;
 791
 792         /* VDP_SRC is connected to D+ and IDM_SINK is connected to D- */
 793         spin_lock_irqsave(&usbmisc->lock, flags);
 794         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 795         val &= ~MX7D_USB_OTG_PHY_CFG2_CHRG_CHRGSEL;
 796         writel(val | MX7D_USB_OTG_PHY_CFG2_CHRG_VDATSRCENB0 |
 797                         MX7D_USB_OTG_PHY_CFG2_CHRG_VDATDETENB0,
 798                                 usbmisc->base + MX7D_USB_OTG_PHY_CFG2);
 799         spin_unlock_irqrestore(&usbmisc->lock, flags);
 800
 801         usleep_range(1000, 2000);
 802
 803         /* Check if D- is less than VDAT_REF to determine an SDP per BC 1.2 */
 804         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_STATUS);
 805         if (!(val & MX7D_USB_OTG_PHY_STATUS_CHRGDET)) {
 806                 dev_dbg(data->dev, "It is a standard downstream port\n");
 807                 usb_phy->chg_type = SDP_TYPE;
 808         }
 809
 810         return 0;
 811 }
 812
 813 /*
 814  * Whole charger detection process:
 815  * 1. OPMODE override to be non-driving
 816  * 2. Data contact check
 817  * 3. Primary detection
 818  * 4. Secondary detection
 819  * 5. Disable charger detection
 820  */
 821 static int imx7d_charger_detection(struct imx_usbmisc_data *data)
 822 {
 823         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 824         struct usb_phy *usb_phy = data->usb_phy;
 825         unsigned long flags;
 826         u32 val;
 827         int ret;
 828
 829         /* Check if vbus is valid */
 830         val = readl(usbmisc->base + MX7D_USB_OTG_PHY_STATUS);
 831         if (!(val & MX7D_USB_OTG_PHY_STATUS_VBUS_VLD)) {
 832                 dev_err(data->dev, "vbus is error\n");
 833                 return -EINVAL;
 834         }
 835
 836         /*
 837          * Keep OPMODE to be non-driving mode during the whole
 838          * charger detection process.
 839          */
 840         spin_lock_irqsave(&usbmisc->lock, flags);
 841         val = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 842         val &= ~MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_MASK;
 843         val |= MX7D_USBNC_USB_CTRL2_OPMODE_NON_DRIVING;
 844         writel(val, usbmisc->base + MX7D_USBNC_USB_CTRL2);
 845
 846         val = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 847         writel(val | MX7D_USBNC_USB_CTRL2_OPMODE_OVERRIDE_EN,
 848                         usbmisc->base + MX7D_USBNC_USB_CTRL2);
 849         spin_unlock_irqrestore(&usbmisc->lock, flags);
 850
 851         ret = imx7d_charger_data_contact_detect(data);
 852         if (ret)
 853                 return ret;
 854
 855         ret = imx7d_charger_primary_detection(data);
 856         if (!ret && usb_phy->chg_type != SDP_TYPE)
 857                 ret = imx7d_charger_secondary_detection(data);
 858
 859         imx7_disable_charger_detector(data);
 860
 861         return ret;
 862 }
 863
 864 static int usbmisc_imx7ulp_init(struct imx_usbmisc_data *data)
 865 {
 866         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 867         unsigned long flags;
 868         u32 reg;
 869
 870         if (data->index >= 1)
 871                 return -EINVAL;
 872
 873         spin_lock_irqsave(&usbmisc->lock, flags);
 874         reg = readl(usbmisc->base);
 875         if (data->disable_oc) {
 876                 reg |= MX6_BM_OVER_CUR_DIS;
 877         } else {
 878                 reg &= ~MX6_BM_OVER_CUR_DIS;
 879
 880                 /*
 881                  * If the polarity is not configured keep it as setup by the
 882                  * bootloader.
 883                  */
 884                 if (data->oc_pol_configured && data->oc_pol_active_low)
 885                         reg |= MX6_BM_OVER_CUR_POLARITY;
 886                 else if (data->oc_pol_configured)
 887                         reg &= ~MX6_BM_OVER_CUR_POLARITY;
 888         }
 889         /* If the polarity is not set keep it as setup by the bootlader */
 890         if (data->pwr_pol == 1)
 891                 reg |= MX6_BM_PWR_POLARITY;
 892
 893         writel(reg, usbmisc->base);
 894
 895         /* SoC non-burst setting */
 896         reg = readl(usbmisc->base);
 897         writel(reg | MX6_BM_NON_BURST_SETTING, usbmisc->base);
 898
 899         if (data->hsic) {
 900                 reg = readl(usbmisc->base);
 901                 writel(reg | MX6_BM_UTMI_ON_CLOCK, usbmisc->base);
 902
 903                 reg = readl(usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET);
 904                 reg |= MX6_BM_HSIC_EN | MX6_BM_HSIC_CLK_ON;
 905                 writel(reg, usbmisc->base + MX6_USB_HSIC_CTRL_OFFSET);
 906
 907                 /*
 908                  * For non-HSIC controller, the autoresume is enabled
 909                  * at MXS PHY driver (usbphy_ctrl bit18).
 910                  */
 911                 reg = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 912                 writel(reg | MX7D_USBNC_AUTO_RESUME,
 913                         usbmisc->base + MX7D_USBNC_USB_CTRL2);
 914         } else {
 915                 reg = readl(usbmisc->base + MX7D_USBNC_USB_CTRL2);
 916                 reg &= ~MX7D_USB_VBUS_WAKEUP_SOURCE_MASK;
 917                 writel(reg | MX7D_USB_VBUS_WAKEUP_SOURCE_BVALID,
 918                          usbmisc->base + MX7D_USBNC_USB_CTRL2);
 919         }
 920
 921         spin_unlock_irqrestore(&usbmisc->lock, flags);
 922
 923         usbmisc_imx7d_set_wakeup(data, false);
 924
 925         return 0;
 926 }
 927
 928 static const struct usbmisc_ops imx25_usbmisc_ops = {
 929         .init = usbmisc_imx25_init,
 930         .post = usbmisc_imx25_post,
 931 };
 932
 933 static const struct usbmisc_ops imx27_usbmisc_ops = {
 934         .init = usbmisc_imx27_init,
 935 };
 936
 937 static const struct usbmisc_ops imx51_usbmisc_ops = {
 938         .init = usbmisc_imx53_init,
 939 };
 940
 941 static const struct usbmisc_ops imx53_usbmisc_ops = {
 942         .init = usbmisc_imx53_init,
 943 };
 944
 945 static const struct usbmisc_ops imx6q_usbmisc_ops = {
 946         .set_wakeup = usbmisc_imx6q_set_wakeup,
 947         .init = usbmisc_imx6q_init,
 948         .hsic_set_connect = usbmisc_imx6_hsic_set_connect,
 949         .hsic_set_clk   = usbmisc_imx6_hsic_set_clk,
 950 };
 951
 952 static const struct usbmisc_ops vf610_usbmisc_ops = {
 953         .init = usbmisc_vf610_init,
 954 };
 955
 956 static const struct usbmisc_ops imx6sx_usbmisc_ops = {
 957         .set_wakeup = usbmisc_imx6q_set_wakeup,
 958         .init = usbmisc_imx6sx_init,
 959         .hsic_set_connect = usbmisc_imx6_hsic_set_connect,
 960         .hsic_set_clk = usbmisc_imx6_hsic_set_clk,
 961 };
 962
 963 static const struct usbmisc_ops imx7d_usbmisc_ops = {
 964         .init = usbmisc_imx7d_init,
 965         .set_wakeup = usbmisc_imx7d_set_wakeup,
 966         .charger_detection = imx7d_charger_detection,
 967 };
 968
 969 static const struct usbmisc_ops imx7ulp_usbmisc_ops = {
 970         .init = usbmisc_imx7ulp_init,
 971         .set_wakeup = usbmisc_imx7d_set_wakeup,
 972         .hsic_set_connect = usbmisc_imx6_hsic_set_connect,
 973         .hsic_set_clk = usbmisc_imx6_hsic_set_clk,
 974 };
 975
 976 static inline bool is_imx53_usbmisc(struct imx_usbmisc_data *data)
 977 {
 978         struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
 979
 980         return usbmisc->ops == &imx53_usbmisc_ops;
 981 }
 982
 983 int imx_usbmisc_init(struct imx_usbmisc_data *data)
 984 {
 985         struct imx_usbmisc *usbmisc;
 986
 987         if (!data)
 988                 return 0;
 989
 990         usbmisc = dev_get_drvdata(data->dev);
 991         if (!usbmisc->ops->init)
 992                 return 0;
 993         return usbmisc->ops->init(data);
 994 }
 995 EXPORT_SYMBOL_GPL(imx_usbmisc_init);
 996
 997 int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
 998 {
 999         struct imx_usbmisc *usbmisc;
1000
1001         if (!data)
1002                 return 0;
1003
1004         usbmisc = dev_get_drvdata(data->dev);
1005         if (!usbmisc->ops->post)
1006                 return 0;
1007         return usbmisc->ops->post(data);
1008 }
1009 EXPORT_SYMBOL_GPL(imx_usbmisc_init_post);
1010
1011 int imx_usbmisc_set_wakeup(struct imx_usbmisc_data *data, bool enabled)
1012 {
1013         struct imx_usbmisc *usbmisc;
1014
1015         if (!data)
1016                 return 0;
1017
1018         usbmisc = dev_get_drvdata(data->dev);
1019         if (!usbmisc->ops->set_wakeup)
1020                 return 0;
1021         return usbmisc->ops->set_wakeup(data, enabled);
1022 }
1023 EXPORT_SYMBOL_GPL(imx_usbmisc_set_wakeup);
1024
1025 int imx_usbmisc_hsic_set_connect(struct imx_usbmisc_data *data)
1026 {
1027         struct imx_usbmisc *usbmisc;
1028
1029         if (!data)
1030                 return 0;
1031
1032         usbmisc = dev_get_drvdata(data->dev);
1033         if (!usbmisc->ops->hsic_set_connect || !data->hsic)
1034                 return 0;
1035         return usbmisc->ops->hsic_set_connect(data);
1036 }
1037 EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_connect);
1038
1039 int imx_usbmisc_hsic_set_clk(struct imx_usbmisc_data *data, bool on)
1040 {
1041         struct imx_usbmisc *usbmisc;
1042
1043         if (!data)
1044                 return 0;
1045
1046         usbmisc = dev_get_drvdata(data->dev);
1047         if (!usbmisc->ops->hsic_set_clk || !data->hsic)
1048                 return 0;
1049         return usbmisc->ops->hsic_set_clk(data, on);
1050 }
1051 EXPORT_SYMBOL_GPL(imx_usbmisc_hsic_set_clk);
1052
1053 int imx_usbmisc_charger_detection(struct imx_usbmisc_data *data, bool connect)
1054 {
1055         struct imx_usbmisc *usbmisc;
1056         struct usb_phy *usb_phy;
1057         int ret = 0;
1058
1059         if (!data)
1060                 return -EINVAL;
1061
1062         usbmisc = dev_get_drvdata(data->dev);
1063         usb_phy = data->usb_phy;
1064         if (!usbmisc->ops->charger_detection)
1065                 return -ENOTSUPP;
1066
1067         if (connect) {
1068                 ret = usbmisc->ops->charger_detection(data);
1069                 if (ret) {
1070                         dev_err(data->dev,
1071                                         "Error occurs during detection: %d\n",
1072                                         ret);
1073                         usb_phy->chg_state = USB_CHARGER_ABSENT;
1074                 } else {
1075                         usb_phy->chg_state = USB_CHARGER_PRESENT;
1076                 }
1077         } else {
1078                 usb_phy->chg_state = USB_CHARGER_ABSENT;
1079                 usb_phy->chg_type = UNKNOWN_TYPE;
1080         }
1081         return ret;
1082 }
1083 EXPORT_SYMBOL_GPL(imx_usbmisc_charger_detection);
1084
1085 static const struct of_device_id usbmisc_imx_dt_ids[] = {
1086         {
1087                 .compatible = "fsl,imx25-usbmisc",
1088                 .data = &imx25_usbmisc_ops,
1089         },
1090         {
1091                 .compatible = "fsl,imx35-usbmisc",
1092                 .data = &imx25_usbmisc_ops,
1093         },
1094         {
1095                 .compatible = "fsl,imx27-usbmisc",
1096                 .data = &imx27_usbmisc_ops,
1097         },
1098         {
1099                 .compatible = "fsl,imx51-usbmisc",
1100                 .data = &imx51_usbmisc_ops,
1101         },
1102         {
1103                 .compatible = "fsl,imx53-usbmisc",
1104                 .data = &imx53_usbmisc_ops,
1105         },
1106         {
1107                 .compatible = "fsl,imx6q-usbmisc",
1108                 .data = &imx6q_usbmisc_ops,
1109         },
1110         {
1111                 .compatible = "fsl,vf610-usbmisc",
1112                 .data = &vf610_usbmisc_ops,
1113         },
1114         {
1115                 .compatible = "fsl,imx6sx-usbmisc",
1116                 .data = &imx6sx_usbmisc_ops,
1117         },
1118         {
1119                 .compatible = "fsl,imx6ul-usbmisc",
1120                 .data = &imx6sx_usbmisc_ops,
1121         },
1122         {
1123                 .compatible = "fsl,imx7d-usbmisc",
1124                 .data = &imx7d_usbmisc_ops,
1125         },
1126         {
1127                 .compatible = "fsl,imx7ulp-usbmisc",
1128                 .data = &imx7ulp_usbmisc_ops,
1129         },
1130         { /* sentinel */ }
1131 };
1132 MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
1133
1134 static int usbmisc_imx_probe(struct platform_device *pdev)
1135 {
1136         struct imx_usbmisc *data;
1137
1138         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
1139         if (!data)
1140                 return -ENOMEM;
1141
1142         spin_lock_init(&data->lock);
1143
1144         data->base = devm_platform_ioremap_resource(pdev, 0);
1145         if (IS_ERR(data->base))
1146                 return PTR_ERR(data->base);
1147
1148         data->ops = of_device_get_match_data(&pdev->dev);
1149         platform_set_drvdata(pdev, data);
1150
1151         return 0;
1152 }
1153
1154 static int usbmisc_imx_remove(struct platform_device *pdev)
1155 {
1156         return 0;
1157 }
1158
1159 static struct platform_driver usbmisc_imx_driver = {
1160         .probe = usbmisc_imx_probe,
1161         .remove = usbmisc_imx_remove,
1162         .driver = {
1163                 .name = "usbmisc_imx",
1164                 .of_match_table = usbmisc_imx_dt_ids,
1165          },
1166 };
1167
1168 module_platform_driver(usbmisc_imx_driver);
1169
1170 MODULE_ALIAS("platform:usbmisc-imx");
1171 MODULE_LICENSE("GPL");
1172 MODULE_DESCRIPTION("driver for imx usb non-core registers");
1173 MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");