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