[PATCH 2/2] phy: sprd: Add Spreadtrum usb20 hsphy driver
From: Pu Li
Date: Wed Nov 01 2023 - 01:46:00 EST
Add Spreadtrum platform USB20 HSPHY driver support. This driver
takes care of all the PHY functionality, normally paired with
DesignWare USB20 (DRD) Controller or Spreadtrum musb phy (DRD )controller.
Signed-off-by: Pu Li <pu.li@xxxxxxxxxx>
---
drivers/phy/Kconfig | 1 +
drivers/phy/Makefile | 1 +
drivers/phy/sprd/Kconfig | 14 +
drivers/phy/sprd/Makefile | 6 +
drivers/phy/sprd/phy-sprd-usb20-hs.c | 1324 ++++++++++++++++++++++++++
drivers/phy/sprd/phy-sprd-usb20-hs.h | 525 ++++++++++
6 files changed, 1871 insertions(+)
create mode 100644 drivers/phy/sprd/Kconfig
create mode 100644 drivers/phy/sprd/Makefile
create mode 100644 drivers/phy/sprd/phy-sprd-usb20-hs.c
create mode 100644 drivers/phy/sprd/phy-sprd-usb20-hs.h
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index d1670bbe6d6b..309eb623f8b3 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -92,6 +92,7 @@ source "drivers/phy/renesas/Kconfig"
source "drivers/phy/rockchip/Kconfig"
source "drivers/phy/samsung/Kconfig"
source "drivers/phy/socionext/Kconfig"
+source "drivers/phy/sprd/Kconfig"
source "drivers/phy/st/Kconfig"
source "drivers/phy/starfive/Kconfig"
source "drivers/phy/sunplus/Kconfig"
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index 868a220ed0f6..d83cb5917d08 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -31,6 +31,7 @@ obj-y += allwinner/ \
rockchip/ \
samsung/ \
socionext/ \
+ sprd/ \
st/ \
starfive/ \
sunplus/ \
diff --git a/drivers/phy/sprd/Kconfig b/drivers/phy/sprd/Kconfig
new file mode 100644
index 000000000000..c43884012ef8
--- /dev/null
+++ b/drivers/phy/sprd/Kconfig
@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Phy drivers for Spreadtrum platforms
+#
+
+config SPRD_USB20_HSPHY
+ tristate "Spreadtrum USB20 HSPHY Driver"
+ select USB_PHY
+ depends on ARCH_SPRD || COMPILE_TEST
+ help
+ Enable this to support the SPRD USB20 High Speed PHY that is part of SOC.
+ This driver takes care of all the PHY functionality,
+ normally paired with DesignWare USB20 (DRD) Controller or
+ Spreadtrum musb phy (DRD )controller.
diff --git a/drivers/phy/sprd/Makefile b/drivers/phy/sprd/Makefile
new file mode 100644
index 000000000000..b102f3515d47
--- /dev/null
+++ b/drivers/phy/sprd/Makefile
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Makefile for physical layer drivers
+#
+
+obj-$(CONFIG_SPRD_USB20_HSPHY) += phy-sprd-usb20-hs.o
diff --git a/drivers/phy/sprd/phy-sprd-usb20-hs.c b/drivers/phy/sprd/phy-sprd-usb20-hs.c
new file mode 100644
index 000000000000..8262a745fc74
--- /dev/null
+++ b/drivers/phy/sprd/phy-sprd-usb20-hs.c
@@ -0,0 +1,1324 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright 2020-2023 Unisoc Inc.
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/iio/consumer.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/usb/otg.h>
+#include <uapi/linux/usb/charger.h>
+
+#include "phy-sprd-usb20-hs.h"
+
+static const struct sprd_hsphy_cfg *phy_cfg;
+
+/* phy_v1 cfg ops */
+static void phy_v1_usb_enable_ctrl(struct sprd_hsphy *phy, int on) {}
+
+static void phy_v1_usb_phy_power_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, reg);
+
+ if (phy_cfg->owner == PIKE2) {
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg &= ~0x1;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ }
+ } else if (on == CTRL1) {
+ if (phy_cfg->owner == PIKE2) {
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg |= 0x1;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ }
+
+ msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, 0);
+ } else if (on == CTRL2) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, reg);
+ }
+}
+
+static void phy_v1_usb_vbus_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg;
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+ if (on) {
+ reg |= (phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_EXT] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_PHYREG]);
+ } else {
+ reg &= ~(phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_EXT] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_PHYREG]);
+ }
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+}
+
+static void phy_v1_utmi_width_sel(struct sprd_hsphy *phy)
+{
+ u32 reg;
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+ reg &= ~(phy_cfg->masks[MASK_AP_AHB_UTMI_WIDTH_SEL] |
+ phy_cfg->masks[MASK_AP_AHB_USB2_DATABUS16_8]);
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+}
+
+static void phy_v1_reset_core(struct sprd_hsphy *phy)
+{
+ u32 reg;
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_AHB_RST]);
+ reg = phy_cfg->masks[MASK_AP_AHB_OTG_PHY_SOFT_RST] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_UTMI_SOFT_RST] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_SOFT_RST];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_AHB_RST] + 0x1000);
+
+ usleep_range(20000, 30000);
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_AHB_RST] + 0x2000);
+}
+
+static int phy_v1_set_mode(struct sprd_hsphy *phy, int on)
+{
+ u32 reg;
+
+ if (on) {
+ reg = phy->host_otg_ctrl0;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg = phy->host_otg_ctrl1;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+ reg &= ~phy_cfg->masks[MASK_AP_AHB_USB2_PHY_IDDIG];
+ reg |= phy_cfg->masks[MASK_AP_AHB_OTG_DPPULLDOWN] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_DMPULLDOWN];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg |= 0x200;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ phy->is_host = true;
+ } else {
+ reg = phy->device_otg_ctrl0;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg = phy->device_otg_ctrl1;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+ reg |= phy_cfg->masks[MASK_AP_AHB_USB2_PHY_IDDIG];
+ reg &= ~(phy_cfg->masks[MASK_AP_AHB_OTG_DPPULLDOWN] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_DMPULLDOWN]);
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ reg &= ~0x200;
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ phy->is_host = false;
+ }
+ return 0;
+}
+
+static const struct sprd_hsphy_cfg_ops phy_v1_cfg_ops = {
+ .usb_enable_ctrl = phy_v1_usb_enable_ctrl,
+ .usb_phy_power_ctrl = phy_v1_usb_phy_power_ctrl,
+ .usb_vbus_ctrl = phy_v1_usb_vbus_ctrl,
+ .utmi_width_sel = phy_v1_utmi_width_sel,
+ .reset_core = phy_v1_reset_core,
+ .set_mode = phy_v1_set_mode,
+};
+
+/* phy_v2 cfg ops */
+static void phy_v2_usb_enable_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ msk = phy_cfg->masks[MASK_AON_APB_OTG_REF_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB2], msk, 0);
+ } else if (on == CTRL1) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_OTG_REF_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB2], msk, reg);
+ } else if (on == CTRL2) {
+ reg = msk = phy_cfg->masks[MASK_AP_AHB_OTG_EB];
+ regmap_update_bits(phy->ap_ahb, phy_cfg->regs[REG_AP_AHB_AHB_EB], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_AON_APB_ANLG_APB_EB] |
+ phy_cfg->masks[MASK_AON_APB_ANLG_EB] |
+ phy_cfg->masks[MASK_AON_APB_OTG_REF_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB2], msk, reg);
+ }
+}
+
+static void phy_v2_usb_phy_power_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB_ISO_SW_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, reg);
+ usleep_range(10000, 15000);
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, reg);
+ } else if (on == CTRL1) {
+ msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S] |
+ phy_cfg->masks[MASK_AON_APB_USB_ISO_SW_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, 0);
+ } else if (on == CTRL2) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_USB_PHY_PD_S];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_PWR_CTRL], msk, reg);
+ }
+}
+
+static void phy_v2_usb_vbus_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on) {
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+ reg |= phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_PHYREG];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_VBUSVLDEXT];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+ } else {
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+ reg &= ~phy_cfg->masks[MASK_AP_AHB_OTG_VBUS_VALID_PHYREG];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TEST]);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_VBUSVLDEXT];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, 0);
+ }
+}
+
+static void phy_v2_utmi_width_sel(struct sprd_hsphy *phy)
+{
+ u32 reg, msk;
+
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DATABUS16_8];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+ reg |= phy_cfg->masks[MASK_AP_AHB_UTMI_WIDTH_SEL];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_CTRL]);
+}
+
+static void phy_v2_reset_core(struct sprd_hsphy *phy)
+{
+ u32 msk1, msk2;
+
+ msk1 = phy_cfg->masks[MASK_AP_AHB_OTG_UTMI_SOFT_RST] |
+ phy_cfg->masks[MASK_AP_AHB_OTG_SOFT_RST];
+ regmap_update_bits(phy->ap_ahb, phy_cfg->regs[REG_AP_AHB_AHB_RST], msk1, msk1);
+ msk2 = phy_cfg->masks[MASK_AON_APB_OTG_PHY_SOFT_RST];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST2], msk2, msk2);
+
+ usleep_range(20000, 30000);
+ regmap_update_bits(phy->ap_ahb, phy_cfg->regs[REG_AP_AHB_AHB_RST], msk1, 0);
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST2], msk2, 0);
+}
+
+static int phy_v2_set_mode(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on) {
+ reg = phy->host_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_UTMIOTG_IDDG];
+ regmap_update_bits(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_IDDG], msk, 0);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, reg);
+
+ msk = 0x200;
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, msk);
+ phy->is_host = true;
+ } else {
+ reg = phy->device_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_UTMIOTG_IDDG];
+ regmap_update_bits(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_IDDG], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, 0);
+
+ msk = 0x200;
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, 0);
+ phy->is_host = false;
+ }
+ return 0;
+}
+
+static const struct sprd_hsphy_cfg_ops phy_v2_cfg_ops = {
+ .usb_enable_ctrl = phy_v2_usb_enable_ctrl,
+ .usb_phy_power_ctrl = phy_v2_usb_phy_power_ctrl,
+ .usb_vbus_ctrl = phy_v2_usb_vbus_ctrl,
+ .utmi_width_sel = phy_v2_utmi_width_sel,
+ .reset_core = phy_v2_reset_core,
+ .set_mode = phy_v2_set_mode,
+};
+
+/* phy_v3 cfg ops */
+static void phy_v3_usb_enable_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN] |
+ phy_cfg->masks[MASK_AON_APB_CGM_DPHY_REF_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_CGM_REG1], msk, 0);
+ } else if (on == CTRL1) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_OTG_UTMI_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB1], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN] |
+ phy_cfg->masks[MASK_AON_APB_CGM_DPHY_REF_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_CGM_REG1], msk, reg);
+ } else if (on == CTRL2) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_OTG_UTMI_EB] |
+ phy_cfg->masks[MASK_AON_APB_ANA_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB1], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN] |
+ phy_cfg->masks[MASK_AON_APB_CGM_DPHY_REF_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_CGM_REG1], msk, reg);
+ }
+}
+
+static void phy_v3_usb_phy_power_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_L] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_S];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_BATTER_PLL], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_ISO_SW], msk, reg);
+ } else if (on == CTRL1) {
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_ISO_SW], msk, 0);
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_L] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_S];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_BATTER_PLL], msk, 0);
+ } else if (on == CTRL2) {
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_L] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_PS_PD_S];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_BATTER_PLL], msk, reg);
+ }
+}
+
+static void phy_v3_usb_vbus_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ msk = phy_cfg->masks[MASK_AON_APB_OTG_VBUS_VALID_PHYREG];
+ reg = on ? msk : 0;
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_OTG_PHY_TEST], msk, reg);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_VBUSVLDEXT];
+ reg = on ? msk : 0;
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+}
+
+static void phy_v3_utmi_width_sel(struct sprd_hsphy *phy)
+{
+ u32 reg, msk;
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_UTMI_WIDTH_SEL];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DATABUS16_8];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+}
+
+static void phy_v3_reset_core(struct sprd_hsphy *phy)
+{
+ u32 reg, msk;
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_OTG_PHY_SOFT_RST] |
+ phy_cfg->masks[MASK_AON_APB_OTG_UTMI_SOFT_RST];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST1], msk, reg);
+
+ usleep_range(20000, 30000);
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST1], msk, 0);
+}
+
+static int phy_v3_set_mode(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on) {
+ reg = phy->host_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ msk = phy_cfg->masks[MASK_AON_APB_USB2_PHY_IDDIG];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, 0);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, reg);
+
+ reg = 0x200;
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_RESERVED];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+ phy->is_host = true;
+ } else {
+ reg = phy->device_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB2_PHY_IDDIG];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, 0);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_RESERVED];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, 0);
+ phy->is_host = false;
+ }
+ return 0;
+}
+
+static const struct sprd_hsphy_cfg_ops phy_v3_cfg_ops = {
+ .usb_enable_ctrl = phy_v3_usb_enable_ctrl,
+ .usb_phy_power_ctrl = phy_v3_usb_phy_power_ctrl,
+ .usb_vbus_ctrl = phy_v3_usb_vbus_ctrl,
+ .utmi_width_sel = phy_v3_utmi_width_sel,
+ .reset_core = phy_v3_reset_core,
+ .set_mode = phy_v3_set_mode,
+};
+
+/* phy_v4 cfg ops */
+static void phy_v4_usb_enable_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ if (phy_cfg->owner == UIS8520)
+ msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN];
+ else
+ msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN] |
+ phy_cfg->masks[MASK_AON_APB_CGM_DPHY_REF_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_CGM_REG1], msk, 0);
+ msk = phy_cfg->masks[MASK_AON_APB_AON_USB2_TOP_EB] |
+ phy_cfg->masks[MASK_AON_APB_OTG_PHY_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB1], msk, 0);
+ } else if (on == CTRL1) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_AON_USB2_TOP_EB] |
+ phy_cfg->masks[MASK_AON_APB_OTG_PHY_EB];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_EB1], msk, reg);
+ if (phy_cfg->owner == UIS8520)
+ reg = msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN];
+ else
+ reg = msk = phy_cfg->masks[MASK_AON_APB_CGM_OTG_REF_EN] |
+ phy_cfg->masks[MASK_AON_APB_CGM_DPHY_REF_EN];
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_CGM_REG1], msk, reg);
+ }
+}
+
+static void phy_v4_usb_phy_power_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on == CTRL0) {
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_AON_SOC_USB_CTRL], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_PHY], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_S];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_MIPI_CSI_POWER_CTRL], msk, reg);
+ } else if (on == CTRL1) {
+ msk = phy_cfg->masks[MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_L] |
+ phy_cfg->masks[MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_S];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_MIPI_CSI_POWER_CTRL], msk, 0);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_PHY], msk, 0);
+ msk = phy_cfg->masks[MASK_AON_APB_USB20_ISO_SW_EN];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_AON_SOC_USB_CTRL], msk, 0);
+ }
+}
+
+static void phy_v4_usb_vbus_ctrl(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ msk = phy_cfg->masks[MASK_AON_APB_OTG_VBUS_VALID_PHYREG];
+ reg = on ? msk : 0;
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_TEST], msk, reg);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_VBUSVLDEXT];
+ reg = on ? msk : 0;
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+}
+
+static void phy_v4_utmi_width_sel(struct sprd_hsphy *phy)
+{
+ u32 reg, msk;
+
+ if (phy_cfg->owner == UIS8520)
+ return;
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_UTMI_WIDTH_SEL];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DATABUS16_8];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+}
+
+static void phy_v4_reset_core(struct sprd_hsphy *phy)
+{
+ u32 reg, msk;
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_OTG_PHY_SOFT_RST] |
+ phy_cfg->masks[MASK_AON_APB_OTG_UTMI_SOFT_RST];
+
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST1], msk, reg);
+
+ usleep_range(20000, 30000);
+ regmap_update_bits(phy->aon_apb, phy_cfg->regs[REG_AON_APB_APB_RST1], msk, 0);
+}
+
+static int phy_v4_set_mode(struct sprd_hsphy *phy, int on)
+{
+ u32 reg, msk;
+
+ if (on) {
+ reg = phy->host_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ msk = phy_cfg->masks[MASK_AON_APB_USB2_PHY_IDDIG];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, 0);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ reg = msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, reg);
+
+ reg = 0x200;
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_RESERVED];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, reg);
+ phy->is_host = true;
+ } else {
+ reg = phy->device_eye_pattern;
+ regmap_write(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING], reg);
+
+ reg = msk = phy_cfg->masks[MASK_AON_APB_USB2_PHY_IDDIG];
+ regmap_update_bits(phy->aon_apb,
+ phy_cfg->regs[REG_AON_APB_OTG_PHY_CTRL], msk, reg);
+
+ reg = msk = phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_REG_SEL_CFG_0], msk, reg);
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_DMPULLDOWN] |
+ phy_cfg->masks[MASK_ANALOG_USB20_USB20_DPPULLDOWN];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL2], msk, 0);
+
+ msk = phy_cfg->masks[MASK_ANALOG_USB20_USB20_RESERVED];
+ regmap_update_bits(phy->analog,
+ phy_cfg->regs[REG_ANALOG_USB20_USB20_UTMI_CTL1], msk, 0);
+ phy->is_host = false;
+ }
+ return 0;
+}
+
+static const struct sprd_hsphy_cfg_ops phy_v4_cfg_ops = {
+ .usb_enable_ctrl = phy_v4_usb_enable_ctrl,
+ .usb_phy_power_ctrl = phy_v4_usb_phy_power_ctrl,
+ .usb_vbus_ctrl = phy_v4_usb_vbus_ctrl,
+ .utmi_width_sel = phy_v4_utmi_width_sel,
+ .reset_core = phy_v4_reset_core,
+ .set_mode = phy_v4_set_mode,
+};
+
+static const struct sprd_hsphy_cfg pike2_phy_cfg = {
+ .regs = pike2_regs_layout,
+ .masks = pike2_masks_layout,
+ .cfg_ops = &phy_v1_cfg_ops,
+ .parameters = phy_pike2_parameters,
+ .phy_version = VERSION1,
+ .owner = PIKE2,
+};
+
+static const struct sprd_hsphy_cfg sharkle_phy_cfg = {
+ .regs = sharkle_regs_layout,
+ .masks = sharkle_masks_layout,
+ .cfg_ops = &phy_v1_cfg_ops,
+ .parameters = phy_sharkle_parameters,
+ .phy_version = VERSION1,
+ .owner = SHARKLE,
+};
+
+static const struct sprd_hsphy_cfg sharkl3_phy_cfg = {
+ .regs = sharkl3_regs_layout,
+ .masks = sharkl3_masks_layout,
+ .cfg_ops = &phy_v2_cfg_ops,
+ .parameters = phy_sharkl3_parameters,
+ .phy_version = VERSION2,
+ .owner = SHARKL3,
+};
+
+static const struct sprd_hsphy_cfg sharkl5_phy_cfg = {
+ .regs = sharkl5_regs_layout,
+ .masks = sharkl5_masks_layout,
+ .cfg_ops = &phy_v3_cfg_ops,
+ .parameters = phy_sharkl5_parameters,
+ .phy_version = VERSION3,
+ .owner = SHARKL5,
+};
+
+static const struct sprd_hsphy_cfg sharkl5pro_phy_cfg = {
+ .regs = sharkl5pro_regs_layout,
+ .masks = sharkl5pro_masks_layout,
+ .cfg_ops = &phy_v3_cfg_ops,
+ .parameters = phy_sharkl5pro_parameters,
+ .phy_version = VERSION3,
+ .owner = SHARKL5PRO,
+};
+
+static const struct sprd_hsphy_cfg qogirl6_phy_cfg = {
+ .regs = qogirl6_regs_layout,
+ .masks = qogirl6_masks_layout,
+ .cfg_ops = &phy_v3_cfg_ops,
+ .parameters = phy_qogirl6_parameters,
+ .phy_version = VERSION3,
+ .owner = QOGIRL6,
+};
+
+static const struct sprd_hsphy_cfg qogirn6lite_phy_cfg = {
+ .regs = qogirn6lite_regs_layout,
+ .masks = qogirn6lite_masks_layout,
+ .cfg_ops = &phy_v4_cfg_ops,
+ .parameters = phy_qogirn6lite_parameters,
+ .phy_version = VERSION4,
+ .owner = QOGIRN6LITE,
+};
+
+static const struct sprd_hsphy_cfg uis8520_phy_cfg = {
+ .regs = uis8520_regs_layout,
+ .masks = uis8520_masks_layout,
+ .cfg_ops = &phy_v4_cfg_ops,
+ .parameters = phy_uis8520_parameters,
+ .phy_version = VERSION4,
+ .owner = UIS8520,
+};
+
+static void sprd_hsphy_charger_detect_work(struct work_struct *work)
+{
+ struct sprd_hsphy *phy = container_of(work, struct sprd_hsphy, work);
+ struct usb_phy *usb_phy = &phy->phy;
+
+ __pm_stay_awake(phy->wake_lock);
+ if (phy->event)
+ usb_phy_set_charger_state(usb_phy, USB_CHARGER_PRESENT);
+ else
+ usb_phy_set_charger_state(usb_phy, USB_CHARGER_ABSENT);
+ __pm_relax(phy->wake_lock);
+}
+
+static int sprd_hsphy_vbus_notify(struct notifier_block *nb,
+ unsigned long event, void *data)
+{
+ struct usb_phy *usb_phy = container_of(nb, struct usb_phy, vbus_nb);
+ struct sprd_hsphy *phy = container_of(usb_phy, struct sprd_hsphy, phy);
+ const struct sprd_hsphy_cfg_ops *cfg_ops = phy_cfg->cfg_ops;
+
+ if (phy->is_host || usb_phy->last_event == USB_EVENT_ID) {
+ dev_info(phy->dev, "USB PHY is host mode\n");
+ return 0;
+ }
+ dev_info(usb_phy->dev, "[%s] enters!\n", __func__);
+
+ pm_wakeup_event(phy->dev, 400);
+
+ if (event)
+ /* usb vbus valid */
+ cfg_ops->usb_vbus_ctrl(phy, CTRL1);
+ else
+ cfg_ops->usb_vbus_ctrl(phy, CTRL0);
+
+ phy->event = event;
+ queue_work(system_unbound_wq, &phy->work);
+
+ return 0;
+}
+
+static int sprd_hostphy_set(struct usb_phy *x, int on)
+{
+ struct sprd_hsphy *phy = container_of(x, struct sprd_hsphy, phy);
+ const struct sprd_hsphy_cfg_ops *cfg_ops = phy_cfg->cfg_ops;
+
+ dev_info(x->dev, "[%s] enters!\n", __func__);
+ return cfg_ops->set_mode(phy, on);
+}
+
+static int sprd_hsphy_init(struct usb_phy *x)
+{
+ struct sprd_hsphy *phy = container_of(x, struct sprd_hsphy, phy);
+ const struct sprd_hsphy_cfg_ops *cfg_ops = phy_cfg->cfg_ops;
+ u32 reg = 0;
+ int ret = 0;
+
+ if (atomic_read(&phy->inited)) {
+ dev_dbg(x->dev, "%s is already inited!\n", __func__);
+ return 0;
+ }
+ dev_info(x->dev, "[%s] enters!\n", __func__);
+
+ /* Turn On VDD */
+ regulator_set_voltage(phy->vdd, phy->vdd_vol, phy->vdd_vol);
+ ret = regulator_enable(phy->vdd);
+ if (ret)
+ return ret;
+
+ /* usb enable */
+ cfg_ops->usb_enable_ctrl(phy, CTRL1);
+
+ /* usb phy power on */
+ cfg_ops->usb_phy_power_ctrl(phy, CTRL1);
+
+ /* Restore PHY tunes */
+ if (phy_cfg->phy_version == VERSION1) {
+ writel_relaxed(phy->phy_tune, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TUNE]);
+ /* USB PHY write register need to delay 2ms~3ms */
+ usleep_range(2000, 3000);
+ }
+
+ /* usb vbus valid */
+ cfg_ops->usb_vbus_ctrl(phy, CTRL1);
+
+ /* for SPRD phy utmi_width sel */
+ cfg_ops->utmi_width_sel(phy);
+
+ /* for SPRD phy sampler sel */
+ if (phy_cfg->phy_version == VERSION1) {
+ reg = readl_relaxed(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+ reg |= phy_cfg->masks[MASK_AP_AHB_USB20_SAMPLER_SEL];
+ writel_relaxed(reg, phy->base + phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+ }
+
+ if (!atomic_read(&phy->reset)) {
+ /* USB PHY write register need to delay 2ms~3ms */
+ if (phy_cfg->phy_version == VERSION1)
+ usleep_range(2000, 3000);
+
+ cfg_ops->reset_core(phy);
+ atomic_set(&phy->reset, 1);
+ }
+
+ atomic_set(&phy->inited, 1);
+ return 0;
+}
+
+static void sprd_hsphy_shutdown(struct usb_phy *x)
+{
+ struct sprd_hsphy *phy = container_of(x, struct sprd_hsphy, phy);
+ const struct sprd_hsphy_cfg_ops *cfg_ops = phy_cfg->cfg_ops;
+
+ if (!atomic_read(&phy->inited)) {
+ dev_info(x->dev, "%s is already shut down\n", __func__);
+ return;
+ }
+ dev_info(x->dev, "[%s] enters!\n", __func__);
+
+ /* usb vbus invalid*/
+ cfg_ops->usb_vbus_ctrl(phy, CTRL0);
+
+ /* usb power down */
+ cfg_ops->usb_phy_power_ctrl(phy, CTRL0);
+
+ /* Backup PHY Tune value */
+ if (phy_cfg->phy_version == VERSION1)
+ phy->phy_tune = readl(phy->base + phy_cfg->regs[REG_AP_AHB_OTG_PHY_TUNE]);
+
+ cfg_ops->usb_enable_ctrl(phy, CTRL0);
+
+ regulator_disable(phy->vdd);
+
+ atomic_set(&phy->inited, 0);
+ atomic_set(&phy->reset, 0);
+}
+
+static ssize_t phy_tune_show(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ return snprintf(buf, PAGE_SIZE, "0x%x\n", phy->phy_tune);
+}
+
+static ssize_t phy_tune_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ if (kstrtouint(buf, 16, &phy->phy_tune) < 0)
+ return -EINVAL;
+
+ return size;
+}
+static DEVICE_ATTR_RW(phy_tune);
+
+static ssize_t vdd_voltage_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ return snprintf(buf, PAGE_SIZE, "%d\n", phy->vdd_vol);
+}
+
+static ssize_t vdd_voltage_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+ u32 vol;
+
+ if (!phy)
+ return -EINVAL;
+
+ if (kstrtouint(buf, 10, &vol) < 0)
+ return -EINVAL;
+
+ if (vol < 1200000 || vol > 3750000) {
+ dev_err(dev, "Invalid voltage value %d\n", vol);
+ return -EINVAL;
+ }
+ phy->vdd_vol = vol;
+
+ return size;
+}
+static DEVICE_ATTR_RW(vdd_voltage);
+
+static ssize_t hsphy_device_eye_pattern_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ return snprintf(buf, PAGE_SIZE, "0x%x\n", phy->device_eye_pattern);
+}
+
+static ssize_t hsphy_device_eye_pattern_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ if (kstrtouint(buf, 16, &phy->device_eye_pattern) < 0)
+ return -EINVAL;
+
+ return size;
+}
+static DEVICE_ATTR_RW(hsphy_device_eye_pattern);
+
+static ssize_t hsphy_host_eye_pattern_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ return snprintf(buf, PAGE_SIZE, "0x%x\n", phy->host_eye_pattern);
+}
+
+static ssize_t hsphy_host_eye_pattern_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t size)
+{
+ struct sprd_hsphy *phy = dev_get_drvdata(dev);
+
+ if (!phy)
+ return -EINVAL;
+
+ if (kstrtouint(buf, 16, &phy->host_eye_pattern) < 0)
+ return -EINVAL;
+
+ return size;
+}
+
+static DEVICE_ATTR_RW(hsphy_host_eye_pattern);
+
+static struct attribute *usb_hsphy_attrs[] = {
+ &dev_attr_phy_tune.attr,
+ &dev_attr_vdd_voltage.attr,
+ &dev_attr_hsphy_device_eye_pattern.attr,
+ &dev_attr_hsphy_host_eye_pattern.attr,
+ NULL
+};
+ATTRIBUTE_GROUPS(usb_hsphy);
+
+static int sprd_eyepatt_tunehsamp_set(struct sprd_hsphy *phy, struct device *dev)
+{
+ int ret = 0;
+ u8 val[2];
+
+ ret = of_property_read_u8_array(dev->of_node, "sprd,hsphy-tunehsamp", val, 2);
+
+ if (ret < 0) {
+ dev_err(dev, "unable to get hsphy-device-tunehsamp\n");
+ return ret;
+ }
+
+ if (phy_cfg->phy_version == VERSION1) {
+ /* device setting */
+ phy->device_otg_ctrl0 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TUNEHSAMP];
+ phy->device_otg_ctrl0 |= (u32)val[0] << phy_cfg->parameters[TUNEHSAMP_SHIFT];
+
+ /* host setting */
+ phy->host_otg_ctrl0 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TUNEHSAMP];
+ phy->host_otg_ctrl0 |= (u32)val[1] << phy_cfg->parameters[TUNEHSAMP_SHIFT];
+
+ } else if (phy_cfg->phy_version == VERSION2 ||
+ phy_cfg->phy_version == VERSION3 ||
+ phy_cfg->phy_version == VERSION4) {
+ /* device setting */
+ phy->device_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TUNEHSAMP];
+ phy->device_eye_pattern |= (u32)val[0] << phy_cfg->parameters[TUNEHSAMP_SHIFT];
+
+ /* host setting */
+ phy->host_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TUNEHSAMP];
+ phy->host_eye_pattern |= (u32)val[1] << phy_cfg->parameters[TUNEHSAMP_SHIFT];
+ }
+
+ return 0;
+}
+
+static int sprd_eyepatt_tuneeq_set(struct sprd_hsphy *phy, struct device *dev)
+{
+ int ret = 0;
+ u8 val[2];
+
+ ret = of_property_read_u8_array(dev->of_node, "sprd,hsphy-tuneeq", val, 2);
+
+ if (ret < 0) {
+ dev_err(dev, "unable to get hsphy-tuneeq\n");
+ return ret;
+ }
+
+ if (phy_cfg->phy_version == VERSION1) {
+ /* device setting */
+ phy->device_otg_ctrl1 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TUNEEQ];
+ phy->device_otg_ctrl1 |= (u32)val[0] << phy_cfg->parameters[TUNEEQ_SHIFT];
+
+ /* host setting */
+ phy->host_otg_ctrl1 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TUNEEQ];
+ phy->host_otg_ctrl1 |= (u32)val[1] << phy_cfg->parameters[TUNEEQ_SHIFT];
+
+ } else if (phy_cfg->phy_version == VERSION2 ||
+ phy_cfg->phy_version == VERSION3 ||
+ phy_cfg->phy_version == VERSION4) {
+ /* device setting */
+ phy->device_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TUNEEQ];
+ phy->device_eye_pattern |= (u32)val[0] << phy_cfg->parameters[TUNEEQ_SHIFT];
+
+ /* host setting */
+ phy->host_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TUNEEQ];
+ phy->host_eye_pattern |= (u32)val[1] << phy_cfg->parameters[TUNEEQ_SHIFT];
+ }
+
+ return 0;
+}
+
+static int sprd_eyepatt_tfregres_set(struct sprd_hsphy *phy, struct device *dev)
+{
+ int ret = 0;
+ u8 val[2];
+
+ ret = of_property_read_u8_array(dev->of_node, "sprd,hsphy-tfregres", val, 2);
+
+ if (ret < 0) {
+ dev_err(dev, "unable to get hsphy-tfregres\n");
+ return ret;
+ }
+
+ if (phy_cfg->phy_version == VERSION1) {
+ /* device setting */
+ phy->device_otg_ctrl1 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TFREGRES];
+ phy->device_otg_ctrl1 |= (u32)val[0] << phy_cfg->parameters[TFREGRES_SHIFT];
+
+ /* host setting */
+ phy->host_otg_ctrl1 &= ~phy_cfg->masks[MASK_AP_AHB_USB20_TFREGRES];
+ phy->host_otg_ctrl1 |= (u32)val[1] << phy_cfg->parameters[TFREGRES_SHIFT];
+ } else if (phy_cfg->phy_version == VERSION2 ||
+ phy_cfg->phy_version == VERSION3 ||
+ phy_cfg->phy_version == VERSION4) {
+ /* device setting */
+ phy->device_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TFREGRES];
+ phy->device_eye_pattern |= (u32)val[0] << phy_cfg->parameters[TFREGRES_SHIFT];
+
+ /* host setting */
+ phy->host_eye_pattern &= ~phy_cfg->masks[MASK_ANALOG_USB20_USB20_TFREGRES];
+ phy->host_eye_pattern |= (u32)val[1] << phy_cfg->parameters[TFREGRES_SHIFT];
+ }
+
+ return 0;
+}
+
+static int sprd_eye_pattern_prepared(struct sprd_hsphy *phy, struct device *dev)
+{
+ int ret = 0;
+
+ if (phy_cfg->phy_version == VERSION1) {
+ /* set default OTG_CTRL */
+ phy->device_otg_ctrl0 = readl_relaxed(phy->base +
+ phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ phy->device_otg_ctrl1 = readl_relaxed(phy->base +
+ phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+
+ phy->host_otg_ctrl0 = readl_relaxed(phy->base +
+ phy_cfg->regs[REG_AP_AHB_OTG_CTRL0]);
+ phy->host_otg_ctrl1 = readl_relaxed(phy->base +
+ phy_cfg->regs[REG_AP_AHB_OTG_CTRL1]);
+ } else if (phy_cfg->phy_version == VERSION2 ||
+ phy_cfg->phy_version == VERSION3 ||
+ phy_cfg->phy_version == VERSION4) {
+ /* set default eyepatt */
+ regmap_read(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING],
+ &phy->device_eye_pattern);
+
+ regmap_read(phy->analog, phy_cfg->regs[REG_ANALOG_USB20_USB20_TRIMMING],
+ &phy->host_eye_pattern);
+ }
+
+ /* set eyepatt tunehsamp */
+ ret |= sprd_eyepatt_tunehsamp_set(phy, dev);
+
+ /* set eyepatt tuneeq */
+ ret |= sprd_eyepatt_tuneeq_set(phy, dev);
+
+ /* set eyepatt tfregres */
+ ret |= sprd_eyepatt_tfregres_set(phy, dev);
+
+ return ret;
+}
+
+static int sprd_hsphy_cali_mode(void)
+{
+ struct device_node *cmdline_node;
+ const char *cmdline, *mode;
+ int ret;
+
+ cmdline_node = of_find_node_by_path("/chosen");
+ ret = of_property_read_string(cmdline_node, "bootargs", &cmdline);
+
+ if (ret) {
+ pr_err("Can't not parse bootargs\n");
+ return 0;
+ }
+
+ mode = strstr(cmdline, "androidboot.mode=cali");
+ if (mode)
+ return 1;
+
+ mode = strstr(cmdline, "sprdboot.mode=cali");
+ if (mode)
+ return 1;
+
+ return 0;
+}
+
+static int sprd_hsphy_probe(struct platform_device *pdev)
+{
+ struct sprd_hsphy *phy;
+ struct resource *res;
+ struct device *dev = &pdev->dev;
+ int ret = 0, calimode = 0;
+ struct usb_otg *otg;
+
+ phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
+ if (!phy)
+ return -ENOMEM;
+
+ otg = devm_kzalloc(dev, sizeof(*otg), GFP_KERNEL);
+ if (!otg)
+ return -ENOMEM;
+
+ /* phy cfg data */
+ phy_cfg = of_device_get_match_data(dev);
+ if (!phy_cfg) {
+ dev_err(dev, "no matching driver data found\n");
+ return -EINVAL;
+ }
+
+ /* set vdd */
+ ret = of_property_read_u32(dev->of_node, "sprd,vdd-voltage",
+ &phy->vdd_vol);
+ if (ret < 0) {
+ dev_err(dev, "unable to read hsphy vdd voltage\n");
+ return ret;
+ }
+
+ calimode = sprd_hsphy_cali_mode();
+ if (calimode) {
+ phy->vdd_vol = phy_cfg->parameters[FULLSPEED_USB33_TUNE];
+ dev_info(dev, "calimode vdd_vol:%d\n", phy->vdd_vol);
+ }
+
+ phy->vdd = devm_regulator_get(dev, "vdd");
+ if (IS_ERR(phy->vdd)) {
+ dev_err(dev, "unable to get hsphy vdd supply\n");
+ return PTR_ERR(phy->vdd);
+ }
+
+ ret = regulator_set_voltage(phy->vdd, phy->vdd_vol, phy->vdd_vol);
+ if (ret < 0) {
+ dev_err(dev, "fail to set hsphy vdd voltage at %dmV\n",
+ phy->vdd_vol);
+ return ret;
+ }
+
+ /* phy tune */
+ if (phy_cfg->phy_version == VERSION1) {
+ ret = of_property_read_u32(dev->of_node, "sprd,tune-value",
+ &phy->phy_tune);
+ if (ret < 0) {
+ dev_err(dev, "unable to read hsphy usb phy tune\n");
+ return ret;
+ }
+ }
+
+ /* phy base */
+ if (phy_cfg->phy_version == VERSION1 ||
+ phy_cfg->phy_version == VERSION2) {
+ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phy_glb_regs");
+ if (!res) {
+ dev_err(dev, "missing USB PHY registers resource\n");
+ return -ENODEV;
+ }
+
+ phy->base = devm_ioremap(dev, res->start, resource_size(res));
+ if (IS_ERR(phy->base)) {
+ dev_err(dev, "unable to get phy base!\n");
+ return PTR_ERR(phy->base);
+ }
+ }
+
+ /* analog & aoapb & apahb regmap */
+ phy->aon_apb = syscon_regmap_lookup_by_phandle(dev->of_node,
+ "sprd,syscon-enable");
+ if (IS_ERR(phy->aon_apb)) {
+ dev_err(dev, "USB aon apb syscon failed!\n");
+ return PTR_ERR(phy->aon_apb);
+ }
+
+ if (phy_cfg->phy_version == VERSION2) {
+ phy->ap_ahb = syscon_regmap_lookup_by_phandle(dev->of_node,
+ "sprd,syscon-apahb");
+ if (IS_ERR(phy->ap_ahb)) {
+ dev_err(dev, "USB apahb syscon failed!\n");
+ return PTR_ERR(phy->ap_ahb);
+ }
+ }
+
+ if (phy_cfg->phy_version != VERSION1) {
+ phy->analog = syscon_regmap_lookup_by_phandle(dev->of_node,
+ "sprd,syscon-ana");
+ if (IS_ERR(phy->analog)) {
+ dev_err(dev, "USB analog syscon failed!\n");
+ return PTR_ERR(phy->analog);
+ }
+ }
+
+ /* prepare eye pattern */
+ ret = sprd_eye_pattern_prepared(phy, dev);
+ if (ret < 0)
+ dev_warn(dev, "sprd_eye_pattern_prepared failed, ret = %d\n", ret);
+
+ /* enable usb module */
+ if (phy_cfg->phy_version == VERSION2 ||
+ phy_cfg->phy_version == VERSION3) {
+ phy_cfg->cfg_ops->usb_enable_ctrl(phy, CTRL2);
+ }
+
+ /* usb phy power down */
+ if (phy_cfg->phy_version != VERSION4)
+ phy_cfg->cfg_ops->usb_phy_power_ctrl(phy, CTRL2);
+
+ phy->dev = dev;
+ phy->phy.dev = dev;
+ phy->phy.label = "sprd-hsphy";
+ phy->phy.otg = otg;
+ phy->phy.init = sprd_hsphy_init;
+ phy->phy.shutdown = sprd_hsphy_shutdown;
+ phy->phy.set_vbus = sprd_hostphy_set;
+ phy->phy.type = USB_PHY_TYPE_USB2;
+ phy->phy.vbus_nb.notifier_call = sprd_hsphy_vbus_notify;
+ otg->usb_phy = &phy->phy;
+
+ device_init_wakeup(phy->dev, true);
+ phy->wake_lock = wakeup_source_register(phy->dev, "sprd-hsphy");
+ if (!phy->wake_lock) {
+ dev_err(dev, "fail to register wakeup lock.\n");
+ return -ENOMEM;
+ }
+ INIT_WORK(&phy->work, sprd_hsphy_charger_detect_work);
+ platform_set_drvdata(pdev, phy);
+
+ ret = usb_add_phy_dev(&phy->phy);
+ if (ret) {
+ dev_err(dev, "fail to add phy\n");
+ return ret;
+ }
+
+ ret = sysfs_create_groups(&dev->kobj, usb_hsphy_groups);
+ if (ret)
+ dev_warn(dev, "failed to create usb hsphy attributes\n");
+
+ if (extcon_get_state(phy->phy.edev, EXTCON_USB) > 0)
+ usb_phy_set_charger_state(&phy->phy, USB_CHARGER_PRESENT);
+
+ dev_info(dev, "sprd usb phy probe ok !\n");
+
+ return ret;
+}
+
+static int sprd_hsphy_remove(struct platform_device *pdev)
+{
+ struct sprd_hsphy *phy = platform_get_drvdata(pdev);
+
+ sysfs_remove_groups(&pdev->dev.kobj, usb_hsphy_groups);
+ usb_remove_phy(&phy->phy);
+ if (regulator_is_enabled(phy->vdd))
+ regulator_disable(phy->vdd);
+
+ return 0;
+}
+
+static const struct of_device_id sprd_hsphy_match[] = {
+ { .compatible = "sprd,pike2-phy", .data = &pike2_phy_cfg,},
+ { .compatible = "sprd,sharkle-phy", .data = &sharkle_phy_cfg,},
+ { .compatible = "sprd,sharkl3-phy", .data = &sharkl3_phy_cfg,},
+ { .compatible = "sprd,sharkl5-phy", .data = &sharkl5_phy_cfg,},
+ { .compatible = "sprd,sharkl5pro-phy", .data = &sharkl5pro_phy_cfg,},
+ { .compatible = "sprd,qogirl6-phy", .data = &qogirl6_phy_cfg,},
+ { .compatible = "sprd,qogirn6lite-phy", .data = &qogirn6lite_phy_cfg,},
+ { .compatible = "sprd,uis8520-phy", .data = &uis8520_phy_cfg,},
+ {},
+};
+MODULE_DEVICE_TABLE(of, sprd_hsphy_match);
+
+static struct platform_driver sprd_hsphy_driver = {
+ .probe = sprd_hsphy_probe,
+ .remove = sprd_hsphy_remove,
+ .driver = {
+ .name = "sprd-hsphy",
+ .of_match_table = sprd_hsphy_match,
+ },
+};
+
+static int __init sprd_hsphy_driver_init(void)
+{
+ return platform_driver_register(&sprd_hsphy_driver);
+}
+
+static void __exit sprd_hsphy_driver_exit(void)
+{
+ platform_driver_unregister(&sprd_hsphy_driver);
+}
+
+late_initcall(sprd_hsphy_driver_init);
+module_exit(sprd_hsphy_driver_exit);
+
+MODULE_ALIAS("platform:spreadtrum-usb20-hsphy");
+MODULE_AUTHOR("Pu Li <lip308226@xxxxxxxxx>");
+MODULE_DESCRIPTION("Spreadtrum USB20 HSPHY driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/phy/sprd/phy-sprd-usb20-hs.h b/drivers/phy/sprd/phy-sprd-usb20-hs.h
new file mode 100644
index 000000000000..897ee5e64482
--- /dev/null
+++ b/drivers/phy/sprd/phy-sprd-usb20-hs.h
@@ -0,0 +1,525 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * phy-sprd-usb20-hs.h - Spreadtrum usb20 phy Glue layer h file
+ *
+ * Copyright 2020-2023 Unisoc Inc.
+ */
+
+#ifndef __SPRD_USB20_HS_H
+#define __SPRD_USB20_HS_H
+
+#include <linux/regmap.h>
+#include <linux/usb/phy.h>
+
+struct sprd_hsphy {
+ struct device *dev;
+ struct usb_phy phy;
+ void __iomem *base;
+ struct regulator *vdd;
+ struct regmap *aon_apb;
+ struct regmap *ap_ahb;
+ struct regmap *analog;
+ struct wakeup_source *wake_lock;
+ struct work_struct work;
+ unsigned long event;
+ u32 vdd_vol;
+ u32 phy_tune;
+ u32 host_eye_pattern;
+ u32 device_eye_pattern;
+ u32 host_otg_ctrl0;
+ u32 device_otg_ctrl0;
+ u32 host_otg_ctrl1;
+ u32 device_otg_ctrl1;
+ atomic_t reset;
+ atomic_t inited;
+ bool is_host;
+};
+
+enum hsphy_parameters {
+ TUNEHSAMP_SHIFT,
+ TUNEEQ_SHIFT,
+ TFREGRES_SHIFT,
+ FULLSPEED_USB33_TUNE,
+};
+
+enum sprd_hsphy_reg_layout {
+ REG_AON_APB_APB_RST1,
+ REG_AON_APB_APB_RST2,
+ REG_AON_APB_APB_EB1,
+ REG_AON_APB_APB_EB2,
+ REG_AON_APB_CGM_REG1,
+ REG_AON_APB_OTG_PHY_TEST,
+ REG_AON_APB_OTG_PHY_CTRL,
+ REG_AON_APB_PWR_CTRL,
+ REG_AON_APB_AON_SOC_USB_CTRL,
+ REG_AON_APB_MIPI_CSI_POWER_CTRL,
+ REG_AP_AHB_AHB_EB,
+ REG_AP_AHB_AHB_RST,
+ REG_AP_AHB_OTG_CTRL0,
+ REG_AP_AHB_OTG_CTRL1,
+ REG_AP_AHB_OTG_PHY_CTRL,
+ REG_AP_AHB_OTG_PHY_TUNE,
+ REG_AP_AHB_OTG_PHY_TEST,
+ REG_ANALOG_USB20_USB20_ISO_SW,
+ REG_ANALOG_USB20_USB20_BATTER_PLL,
+ REG_ANALOG_USB20_USB20_UTMI_CTL1,
+ REG_ANALOG_USB20_USB20_TRIMMING,
+ REG_ANALOG_USB20_USB20_UTMI_CTL2,
+ REG_ANALOG_USB20_REG_SEL_CFG_0,
+ REG_ANALOG_USB20_IDDG,
+ REG_ANALOG_USB20_USB20_PHY,
+};
+
+enum sprd_hsphy_mask_layout {
+ MASK_AON_APB_USB_PHY_PD_S,
+ MASK_AON_APB_USB_PHY_PD_L,
+ MASK_AON_APB_ANLG_APB_EB,
+ MASK_AON_APB_ANLG_EB,
+ MASK_AON_APB_OTG_REF_EB,
+ MASK_AON_APB_ANA_EB,
+ MASK_AON_APB_OTG_UTMI_EB,
+ MASK_AON_APB_AON_USB2_TOP_EB,
+ MASK_AON_APB_OTG_PHY_EB,
+ MASK_AON_APB_CGM_OTG_REF_EN,
+ MASK_AON_APB_CGM_DPHY_REF_EN,
+ MASK_AON_APB_USB_ISO_SW_EN,
+ MASK_AON_APB_OTG_PHY_SOFT_RST,
+ MASK_AON_APB_OTG_UTMI_SOFT_RST,
+ MASK_AON_APB_OTG_VBUS_VALID_PHYREG,
+ MASK_AON_APB_USB2_PHY_IDDIG,
+ MASK_AON_APB_UTMI_WIDTH_SEL,
+ MASK_AON_APB_USB20_CTRL_MUX_REG,
+ MASK_AON_APB_USB20_ISO_SW_EN,
+ MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_S,
+ MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_L,
+ MASK_AP_AHB_OTG_EB,
+ MASK_AP_AHB_OTG_PHY_SOFT_RST,
+ MASK_AP_AHB_OTG_UTMI_SOFT_RST,
+ MASK_AP_AHB_OTG_SOFT_RST,
+ MASK_AP_AHB_USB2_PHY_IDDIG,
+ MASK_AP_AHB_OTG_DPPULLDOWN,
+ MASK_AP_AHB_OTG_DMPULLDOWN,
+ MASK_AP_AHB_OTG_VBUS_VALID_EXT,
+ MASK_AP_AHB_OTG_VBUS_VALID_PHYREG,
+ MASK_AP_AHB_UTMI_WIDTH_SEL,
+ MASK_AP_AHB_USB2_DATABUS16_8,
+ MASK_AP_AHB_USB20_SAMPLER_SEL,
+ MASK_AP_AHB_USB20_TUNEHSAMP,
+ MASK_AP_AHB_USB20_TUNEEQ,
+ MASK_AP_AHB_USB20_TFREGRES,
+ MASK_ANALOG_USB20_USB20_VBUSVLDEXT,
+ MASK_ANALOG_USB20_USB20_DATABUS16_8,
+ MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN,
+ MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN,
+ MASK_ANALOG_USB20_USB20_DMPULLDOWN,
+ MASK_ANALOG_USB20_USB20_DPPULLDOWN,
+ MASK_ANALOG_USB20_UTMIOTG_IDDG,
+ MASK_ANALOG_USB20_USB20_PS_PD_S,
+ MASK_ANALOG_USB20_USB20_PS_PD_L,
+ MASK_ANALOG_USB20_USB20_RESERVED,
+ MASK_ANALOG_USB20_USB20_ISO_SW_EN,
+ MASK_ANALOG_USB20_USB20_TUNEHSAMP,
+ MASK_ANALOG_USB20_USB20_TUNEEQ,
+ MASK_ANALOG_USB20_USB20_TFREGRES,
+};
+
+enum {
+ CTRL0 = 0,
+ CTRL1,
+ CTRL2,
+};
+
+struct sprd_hsphy_cfg_ops {
+ void (*usb_enable_ctrl)(struct sprd_hsphy *phy, int on);
+ void (*usb_phy_power_ctrl)(struct sprd_hsphy *phy, int on);
+ void (*usb_vbus_ctrl)(struct sprd_hsphy *phy, int on);
+ void (*utmi_width_sel)(struct sprd_hsphy *phy);
+ void (*reset_core)(struct sprd_hsphy *phy);
+ int (*set_mode)(struct sprd_hsphy *phy, int on);
+};
+
+enum hsphy_ip_version {
+ VERSION1,
+ VERSION2,
+ VERSION3,
+ VERSION4,
+};
+
+enum hsphy_owner {
+ PIKE2,
+ SHARKLE,
+ SHARKL3,
+ SHARKL5,
+ SHARKL5PRO,
+ QOGIRL6,
+ QOGIRN6LITE,
+ UIS8520,
+};
+
+struct sprd_hsphy_cfg {
+ /* array of registers with different offsets */
+ const unsigned int *regs;
+
+ const unsigned int *masks;
+
+ /* private ops for each SOC */
+ const struct sprd_hsphy_cfg_ops *cfg_ops;
+
+ const unsigned int *parameters;
+
+ enum hsphy_ip_version phy_version;
+
+ enum hsphy_owner owner;
+};
+
+static const unsigned int pike2_regs_layout[] = {
+ [REG_AON_APB_PWR_CTRL] = 0x0024,
+ [REG_AP_AHB_AHB_RST] = 0x0004,
+ [REG_AP_AHB_OTG_CTRL0] = 0x302c,
+ [REG_AP_AHB_OTG_CTRL1] = 0x3030,
+ [REG_AP_AHB_OTG_PHY_CTRL] = 0x3028,
+ [REG_AP_AHB_OTG_PHY_TUNE] = 0x3020,
+ [REG_AP_AHB_OTG_PHY_TEST] = 0x3024,
+};
+
+static const unsigned int sharkle_regs_layout[] = {
+ [REG_AON_APB_PWR_CTRL] = 0x0024,
+ [REG_AP_AHB_AHB_RST] = 0x0004,
+ [REG_AP_AHB_OTG_CTRL0] = 0x302c,
+ [REG_AP_AHB_OTG_CTRL1] = 0x3030,
+ [REG_AP_AHB_OTG_PHY_CTRL] = 0x3028,
+ [REG_AP_AHB_OTG_PHY_TUNE] = 0x3020,
+ [REG_AP_AHB_OTG_PHY_TEST] = 0x3024,
+};
+
+static const unsigned int sharkl3_regs_layout[] = {
+ [REG_AON_APB_APB_RST2] = 0x0130,
+ [REG_AON_APB_APB_EB2] = 0x00b0,
+ [REG_AON_APB_PWR_CTRL] = 0x0024,
+ [REG_AP_AHB_AHB_EB] = 0x0000,
+ [REG_AP_AHB_AHB_RST] = 0x0004,
+ [REG_AP_AHB_OTG_PHY_CTRL] = 0x3028,
+ [REG_AP_AHB_OTG_PHY_TEST] = 0x3024,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x009c,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x00a8,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x00a4,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x00b0,
+ [REG_ANALOG_USB20_IDDG] = 0x00bc,
+};
+
+static const unsigned int sharkl5_regs_layout[] = {
+ [REG_AON_APB_APB_RST1] = 0x0010,
+ [REG_AON_APB_APB_EB1] = 0x0004,
+ [REG_AON_APB_CGM_REG1] = 0x0138,
+ [REG_AON_APB_OTG_PHY_TEST] = 0x0204,
+ [REG_AON_APB_OTG_PHY_CTRL] = 0x0208,
+ [REG_ANALOG_USB20_USB20_ISO_SW] = 0x0070,
+ [REG_ANALOG_USB20_USB20_BATTER_PLL] = 0x005c,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x0058,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x0064,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x0060,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x0074,
+};
+
+static const unsigned int sharkl5pro_regs_layout[] = {
+ [REG_AON_APB_APB_RST1] = 0x0010,
+ [REG_AON_APB_APB_EB1] = 0x0004,
+ [REG_AON_APB_CGM_REG1] = 0x0138,
+ [REG_AON_APB_OTG_PHY_TEST] = 0x0204,
+ [REG_AON_APB_OTG_PHY_CTRL] = 0x0208,
+ [REG_ANALOG_USB20_USB20_ISO_SW] = 0x0070,
+ [REG_ANALOG_USB20_USB20_BATTER_PLL] = 0x005c,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x0058,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x0064,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x0060,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x0074,
+};
+
+static const unsigned int qogirl6_regs_layout[] = {
+ [REG_AON_APB_APB_RST1] = 0x0010,
+ [REG_AON_APB_APB_EB1] = 0x0004,
+ [REG_AON_APB_CGM_REG1] = 0x0138,
+ [REG_AON_APB_OTG_PHY_TEST] = 0x0204,
+ [REG_AON_APB_OTG_PHY_CTRL] = 0x0208,
+ [REG_ANALOG_USB20_USB20_ISO_SW] = 0x001c,
+ [REG_ANALOG_USB20_USB20_BATTER_PLL] = 0x0008,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x0004,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x0010,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x000c,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x0020,
+};
+
+static const unsigned int qogirn6lite_regs_layout[] = {
+ [REG_AON_APB_APB_RST1] = 0x0010,
+ [REG_AON_APB_APB_EB1] = 0x0004,
+ [REG_AON_APB_CGM_REG1] = 0x0138,
+ [REG_AON_APB_OTG_PHY_TEST] = 0x0204,
+ [REG_AON_APB_OTG_PHY_CTRL] = 0x0208,
+ [REG_AON_APB_AON_SOC_USB_CTRL] = 0x0190,
+ [REG_AON_APB_MIPI_CSI_POWER_CTRL] = 0x0350,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x0004,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x0010,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x000c,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x0020,
+ [REG_ANALOG_USB20_USB20_PHY] = 0x001C,
+};
+
+static const unsigned int uis8520_regs_layout[] = {
+ [REG_AON_APB_APB_RST1] = 0x0010,
+ [REG_AON_APB_APB_EB1] = 0x0004,
+ [REG_AON_APB_CGM_REG1] = 0x0138,
+ [REG_AON_APB_OTG_PHY_TEST] = 0x0204,
+ [REG_AON_APB_OTG_PHY_CTRL] = 0x0208,
+ [REG_AON_APB_AON_SOC_USB_CTRL] = 0x0190,
+ [REG_AON_APB_MIPI_CSI_POWER_CTRL] = 0x0350,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL1] = 0x0008,
+ [REG_ANALOG_USB20_USB20_TRIMMING] = 0x0018,
+ [REG_ANALOG_USB20_USB20_UTMI_CTL2] = 0x0010,
+ [REG_ANALOG_USB20_REG_SEL_CFG_0] = 0x0028,
+ [REG_ANALOG_USB20_USB20_PHY] = 0x0024,
+};
+
+static const unsigned int pike2_masks_layout[] = {
+ [MASK_AON_APB_USB_PHY_PD_S] = 0x20000,
+ [MASK_AON_APB_USB_PHY_PD_L] = 0x10000,
+ [MASK_AP_AHB_OTG_PHY_SOFT_RST] = 0x40,
+ [MASK_AP_AHB_OTG_UTMI_SOFT_RST] = 0x20,
+ [MASK_AP_AHB_OTG_SOFT_RST] = 0x10,
+ [MASK_AP_AHB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_AP_AHB_OTG_DPPULLDOWN] = 0x100000,
+ [MASK_AP_AHB_OTG_DMPULLDOWN] = 0x200000,
+ [MASK_AP_AHB_OTG_VBUS_VALID_EXT] = 0x400000,
+ [MASK_AP_AHB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AP_AHB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_AP_AHB_USB2_DATABUS16_8] = 0x20000000,
+ [MASK_AP_AHB_USB20_SAMPLER_SEL] = 0x100000,
+ [MASK_AP_AHB_USB20_TUNEHSAMP] = 0xc0000000,
+ [MASK_AP_AHB_USB20_TUNEEQ] = 0x7,
+ [MASK_AP_AHB_USB20_TFREGRES] = 0x3f00,
+};
+
+static const unsigned int sharkle_masks_layout[] = {
+ [MASK_AON_APB_USB_PHY_PD_S] = 0x20000,
+ [MASK_AON_APB_USB_PHY_PD_L] = 0x10000,
+ [MASK_AP_AHB_OTG_PHY_SOFT_RST] = 0x40,
+ [MASK_AP_AHB_OTG_UTMI_SOFT_RST] = 0x20,
+ [MASK_AP_AHB_OTG_SOFT_RST] = 0x10,
+ [MASK_AP_AHB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_AP_AHB_OTG_DPPULLDOWN] = 0x100000,
+ [MASK_AP_AHB_OTG_DMPULLDOWN] = 0x200000,
+ [MASK_AP_AHB_OTG_VBUS_VALID_EXT] = 0x400000,
+ [MASK_AP_AHB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AP_AHB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_AP_AHB_USB2_DATABUS16_8] = 0x20000000,
+ [MASK_AP_AHB_USB20_SAMPLER_SEL] = 0x100000,
+ [MASK_AP_AHB_USB20_TUNEHSAMP] = 0xc0000000,
+ [MASK_AP_AHB_USB20_TUNEEQ] = 0x7,
+ [MASK_AP_AHB_USB20_TFREGRES] = 0x3f00,
+};
+
+static const unsigned int sharkl3_masks_layout[] = {
+ [MASK_AON_APB_USB_PHY_PD_S] = 0x20000,
+ [MASK_AON_APB_USB_PHY_PD_L] = 0x10000,
+ [MASK_AON_APB_ANLG_APB_EB] = 0x2000,
+ [MASK_AON_APB_ANLG_EB] = 0x800,
+ [MASK_AON_APB_OTG_REF_EB] = 0x4000000,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x8000000,
+ [MASK_AON_APB_USB_ISO_SW_EN] = 0x10000000,
+ [MASK_AP_AHB_OTG_EB] = 0x10,
+ [MASK_AP_AHB_OTG_UTMI_SOFT_RST] = 0x20,
+ [MASK_AP_AHB_OTG_SOFT_RST] = 0x10,
+ [MASK_AP_AHB_OTG_VBUS_VALID_PHYREG] = 0x10000000,
+ [MASK_AP_AHB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_ANALOG_USB20_USB20_DATABUS16_8] = 0x10000000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x1,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x2,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x4,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_UTMIOTG_IDDG] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0x18000000,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x1c,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x7e00000,
+};
+
+static const unsigned int sharkl5_masks_layout[] = {
+ [MASK_AON_APB_ANA_EB] = 0x1000,
+ [MASK_AON_APB_OTG_UTMI_EB] = 0x100,
+ [MASK_AON_APB_CGM_OTG_REF_EN] = 0x1000,
+ [MASK_AON_APB_CGM_DPHY_REF_EN] = 0x400,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x200,
+ [MASK_AON_APB_OTG_UTMI_SOFT_RST] = 0x100,
+ [MASK_AON_APB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AON_APB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_AON_APB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_ANALOG_USB20_USB20_DATABUS16_8] = 0x10000000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x2,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x4,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_S] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_L] = 0x8,
+ [MASK_ANALOG_USB20_USB20_RESERVED] = 0xffff,
+ [MASK_ANALOG_USB20_USB20_ISO_SW_EN] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0x06000000,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x7,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x01f80000,
+};
+
+static const unsigned int sharkl5pro_masks_layout[] = {
+ [MASK_AON_APB_ANA_EB] = 0x1000,
+ [MASK_AON_APB_OTG_UTMI_EB] = 0x100,
+ [MASK_AON_APB_CGM_OTG_REF_EN] = 0x1000,
+ [MASK_AON_APB_CGM_DPHY_REF_EN] = 0x400,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x200,
+ [MASK_AON_APB_OTG_UTMI_SOFT_RST] = 0x100,
+ [MASK_AON_APB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AON_APB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_AON_APB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_ANALOG_USB20_USB20_DATABUS16_8] = 0x10000000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x2,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x4,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_S] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_L] = 0x8,
+ [MASK_ANALOG_USB20_USB20_RESERVED] = 0xffff,
+ [MASK_ANALOG_USB20_USB20_ISO_SW_EN] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0x06000000,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x7,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x01f80000,
+};
+
+static const unsigned int qogirl6_masks_layout[] = {
+ [MASK_AON_APB_ANA_EB] = 0x1000,
+ [MASK_AON_APB_OTG_UTMI_EB] = 0x100,
+ [MASK_AON_APB_CGM_OTG_REF_EN] = 0x1000,
+ [MASK_AON_APB_CGM_DPHY_REF_EN] = 0x400,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x200,
+ [MASK_AON_APB_OTG_UTMI_SOFT_RST] = 0x100,
+ [MASK_AON_APB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AON_APB_UTMI_WIDTH_SEL] = 0x40000000,
+ [MASK_AON_APB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_ANALOG_USB20_USB20_DATABUS16_8] = 0x10000000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x2,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x4,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_S] = 0x10,
+ [MASK_ANALOG_USB20_USB20_PS_PD_L] = 0x8,
+ [MASK_ANALOG_USB20_USB20_RESERVED] = 0xffff,
+ [MASK_ANALOG_USB20_USB20_ISO_SW_EN] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0x06000000,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x7,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x01f80000,
+};
+
+static const unsigned int qogirn6lite_masks_layout[] = {
+ [MASK_AON_APB_AON_USB2_TOP_EB] = 0x0100,
+ [MASK_AON_APB_OTG_PHY_EB] = 0x0200,
+ [MASK_AON_APB_CGM_OTG_REF_EN] = 0x1000,
+ [MASK_AON_APB_CGM_DPHY_REF_EN] = 0x400,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x200,
+ [MASK_AON_APB_OTG_UTMI_SOFT_RST] = 0x100,
+ [MASK_AON_APB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AON_APB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_AON_APB_USB20_CTRL_MUX_REG] = 0x0008,
+ [MASK_AON_APB_USB20_ISO_SW_EN] = 0x0010,
+ [MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_S] = 0x0002,
+ [MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_L] = 0x0001,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x4,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x10,
+ [MASK_ANALOG_USB20_USB20_RESERVED] = 0x0000FFFF,
+ [MASK_ANALOG_USB20_USB20_ISO_SW_EN] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0x06000000,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x7,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x01f80000,
+};
+
+static const unsigned int uis8520_masks_layout[] = {
+ [MASK_AON_APB_AON_USB2_TOP_EB] = 0x0100,
+ [MASK_AON_APB_OTG_PHY_EB] = 0x0200,
+ [MASK_AON_APB_CGM_OTG_REF_EN] = 0x1000,
+ [MASK_AON_APB_OTG_PHY_SOFT_RST] = 0x200,
+ [MASK_AON_APB_OTG_UTMI_SOFT_RST] = 0x100,
+ [MASK_AON_APB_OTG_VBUS_VALID_PHYREG] = 0x1000000,
+ [MASK_AON_APB_USB2_PHY_IDDIG] = 0x8,
+ [MASK_AON_APB_USB20_CTRL_MUX_REG] = 0x0008,
+ [MASK_AON_APB_USB20_ISO_SW_EN] = 0x0010,
+ [MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_S] = 0x0002,
+ [MASK_AON_APB_C2G_ANALOG_USB20_USB20_PS_PD_L] = 0x0001,
+ [MASK_ANALOG_USB20_USB20_VBUSVLDEXT] = 0x10000,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DMPULLDOWN] = 0x4,
+ [MASK_DBG_SEL_ANALOG_USB20_USB20_DPPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DMPULLDOWN] = 0x8,
+ [MASK_ANALOG_USB20_USB20_DPPULLDOWN] = 0x10,
+ [MASK_ANALOG_USB20_USB20_RESERVED] = 0x0000FFFF,
+ [MASK_ANALOG_USB20_USB20_ISO_SW_EN] = 0x1,
+ [MASK_ANALOG_USB20_USB20_TUNEHSAMP] = 0xC0,
+ [MASK_ANALOG_USB20_USB20_TUNEEQ] = 0x7,
+ [MASK_ANALOG_USB20_USB20_TFREGRES] = 0x1F,
+};
+
+static const unsigned int phy_pike2_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 30,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 8,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_sharkle_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 30,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 8,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_sharkl3_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 27,
+ [TUNEEQ_SHIFT] = 2,
+ [TFREGRES_SHIFT] = 21,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_sharkl5_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 25,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 19,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_sharkl5pro_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 25,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 19,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_qogirl6_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 25,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 19,
+ [FULLSPEED_USB33_TUNE] = 2700000,
+};
+
+static const unsigned int phy_qogirn6lite_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 25,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 19,
+ [FULLSPEED_USB33_TUNE] = 3300000,
+};
+
+static const unsigned int phy_uis8520_parameters[] = {
+ [TUNEHSAMP_SHIFT] = 6,
+ [TUNEEQ_SHIFT] = 0,
+ [TFREGRES_SHIFT] = 0,
+ [FULLSPEED_USB33_TUNE] = 3300000,
+};
+
+#endif
--
2.17.1