From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 24824CDB46F for ; Mon, 22 Jun 2026 17:52:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:Message-ID: Mime-Version:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To: References:List-Owner; bh=CIjhY0Rl77YQVB0HbQ5yGQLXqtsk5iyauSRQw+OA7rA=; b=auQ 4ejqLtHMp2EjRmrh3OgMFqh56rqPXpXXt4TyifsSWEu+wducgilt4rr84+DrgdYhn4kbnFMBdi+Kv NxMJANyaXDej/UCNZjORBRvJS5tZTomptkxvRxO7W5YVzdBl4yuwhM/f9xh+wuAOjqXxgM+ZZ+h21 6VQyaabdH19qUCZXem2ATtNm+s4ACfZloZsmX7I/00vCUd7Miki8lBIlx1CX0GzTMesFZYWR3Eugs e02g7j6ciudxF0s0AUeWWYTGSPb0pSSD83XAkQl7RvD+RXA7xj0bdO0U7g5JkxP5VItXuFZj9ggRv rih0OibYhjWflntjqx3MRcvwPPB+j5g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wbipL-00000005HFj-2Y5r; Mon, 22 Jun 2026 17:52:55 +0000 Received: from mail-pg1-x54a.google.com ([2607:f8b0:4864:20::54a]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wbipI-00000005HEf-2ctA for linux-phy@lists.infradead.org; Mon, 22 Jun 2026 17:52:53 +0000 Received: by mail-pg1-x54a.google.com with SMTP id 41be03b00d2f7-c8924f4d0a4so6236477a12.2 for ; Mon, 22 Jun 2026 10:52:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1782150771; x=1782755571; darn=lists.infradead.org; h=cc:to:from:subject:message-id:mime-version:date:from:to:cc:subject :date:message-id:reply-to; bh=MF5blZe6yethduuErTuBdBQIHtFwLftpZWIx/t5Jxzg=; b=WVM6C5csbO6DSLakA7eH+Pelvy8ATmWtfwftJdtki5w2Z/3PF4EbRlmfGdm/0GXTcf CAyvH9txG85M0eal2aS6PYtppPKJU+FtU5z7Rh/r3wNUAVmugZgtTLT04jVhKW/ZFrd1 TKY+4WPSzu+QBz7D2ajKf4lX0VkLBUrYFiUKITwjmWz3hES6Qj5rXZKOn64W+tz/JdSW P9m3LSQ2VyAuiuOy+6waVLko4s0ed3JV//k5dLQAcktOFClVtdKCSg77fpcJDYtGDrB8 ToM0s1TzCkrt1R8zdAL/V2RJsYq0VlmRnbQTJ7ItXF9i+BVmav6LgnK59PKLgOOPd8kT 3RbQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1782150771; x=1782755571; h=cc:to:from:subject:message-id:mime-version:date:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=MF5blZe6yethduuErTuBdBQIHtFwLftpZWIx/t5Jxzg=; b=md3dOUX2P8JfjHO0F/NmDpKHGJ+aPBYjc5uN7ff7bjBQ8k77EMrmPnP2B+hRbZjIdY 63XpRPyhFh8OoVXqvv4DhUnxDM1juxUf5qO2lbYQgZgi2QEvw7wCco4o5Q55sopLC5Sa Apa7fjl5hDWGBIaD8JV3bWGaPIN6b9Iu57lBHHSj3iOeGzwEUJ1urTFM9OoZrrLFrrY+ wP9AW6z5yJOr5ojI0iLbYWVppWhADIprJUs1/K3NOzJBcGAmJA4tvGP51GIew9CISwCa cSzBA8nRgDpBf4DqEHRPJbusgsjUg6odYDifoCp7F5Wzf43lngdck06AJvAsgQvPDg9V Q9Yw== X-Forwarded-Encrypted: i=1; AFNElJ/Zj7I+prD2FIR8W6zR0fD5FqK5yxEdI3yYqFtsiYs5E54RVtZq7H/EKSBXtVROKYjOepXen9U06U4=@lists.infradead.org X-Gm-Message-State: AOJu0YyyA7olNN/Q24BV8/pwLHl2K78M9QacnwTW5rR8C96YeY5WlwKU FoD3dbFHHhaJ9z4uO/VQgWSjW1KpJ6YsbkxsJlrs3g9Zd9Yce03bDpVh6wlFPC2KopyGyighkvm aK0mxs8tJ80Fms6UQUQ== X-Received: from pgmc33.prod.google.com ([2002:a63:1c61:0:b0:c88:9458:e8e7]) (user=rdbabiera job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a21:6e03:b0:3b4:8a40:85f0 with SMTP id adf61e73a8af0-3bb32d17839mr17840563637.18.1782150770888; Mon, 22 Jun 2026 10:52:50 -0700 (PDT) Date: Mon, 22 Jun 2026 17:52:41 +0000 Mime-Version: 1.0 X-Developer-Key: i=rdbabiera@google.com; a=openpgp; fpr=0B74D21BCA57BD40083A73A0DB00FC8CD80B20A1 X-Developer-Signature: v=1; a=openpgp-sha256; l=16808; i=rdbabiera@google.com; h=from:subject; bh=e0sokG7tPQZOzbPObkIJmC3MSQtKrPS9S02int/mCOg=; b=owGbwMvMwCV2m+FPzw1uhYWMp9WSGLIsyzLM9vs/rTk56f5Sjh3MLS4H1Xhz3hb/cd1dtbrtX ZWSYtrvjlIWBjEuBlkxRRbukkvSp8L3OnBYFS+AmcPKBDKEgYtTACZytJvhf0DgZBWd2FNlJwMa XR/JnudImap17s6nMtHafUsm5Fxbv5fhf+V+ztZOtbfrtWxalVMlgqQjVGac+xkYebGcU/XBp4t eTAA= X-Mailer: git-send-email 2.55.0.rc0.786.g65d90a0328-goog Message-ID: <20260622175240.2469937-2-rdbabiera@google.com> Subject: [PATCH v2] phy: Add USB3 PHY support to Google Tensor SoC USB PHY driver From: RD Babiera To: vkoul@kernel.org, peter.griffin@linaro.org, andre.draszik@linaro.org, tudor.ambarus@linaro.org, p.zabel@pengutronix.de, neil.armstrong@linaro.org Cc: badhri@google.com, linux-arm-kernel@lists.infradead.org, linux-samsung-soc@vger.kernel.org, linux-phy@lists.infradead.org, linux-kernel@vger.kernel.org, RD Babiera X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260622_105252_725825_AB4BE4A1 X-CRM114-Status: GOOD ( 23.12 ) X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org Add USB3 PHY support for the Google Tensor G5 USB PHY driver. This patch adds functionality for the usb3_tca register, usb3 clock, and usb3 reset as defined in google,lga-usb-phy.yaml. Kconfig now lists USB SuperSpeed support. Refactor the probe sequence to initialize the USB2 and USB3 PHYs, and then initialize clocks and resets for both PHYs afterwards. Refactor set_vbus_valid to reduce duplicated code. Implement USB3 phy_ops for phy_init, phy_exit, and phy_power_on. combo_phy_state enum is added to track PHY bringup state across PHY API calls. Signed-off-by: RD Babiera --- Changes since v1: * Removed mix of goto-based and scope-based cleanup from usb3 phy_init * Removed unused usb3_core resource from probe * Added combo_phy_state enum to interally track ComboPHY bringup state to allow google_usb_set_orientation() to change TCA orientation. * Modify Kconfig documentation to reflect SuperSpeed support --- drivers/phy/Kconfig | 2 +- drivers/phy/phy-google-usb.c | 379 +++++++++++++++++++++++++++++++---- 2 files changed, 346 insertions(+), 35 deletions(-) diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig index 19f3b7d12b7d..d2d401129af7 100644 --- a/drivers/phy/Kconfig +++ b/drivers/phy/Kconfig @@ -100,7 +100,7 @@ config PHY_GOOGLE_USB the G5 generation (Laguna). This driver provides the PHY interfaces to interact with the SNPS eUSB2 and USB 3.2/DisplayPort Combo PHY, both of which are integrated with the DWC3 USB DRD controller. - This driver currently supports USB high-speed. + This driver currently supports USB high-speed and SuperSpeed. config USB_LGM_PHY tristate "INTEL Lightning Mountain USB PHY Driver" diff --git a/drivers/phy/phy-google-usb.c b/drivers/phy/phy-google-usb.c index ab20bc20f19e..c6f4d8283e7c 100644 --- a/drivers/phy/phy-google-usb.c +++ b/drivers/phy/phy-google-usb.c @@ -20,6 +20,7 @@ #include #include +/* USB_CFG_CSR */ #define USBCS_USB2PHY_CFG19_OFFSET 0x0 #define USBCS_USB2PHY_CFG19_PHY_CFG_PLL_FB_DIV GENMASK(19, 8) @@ -28,11 +29,41 @@ #define USBCS_USB2PHY_CFG21_REF_FREQ_SEL GENMASK(15, 13) #define USBCS_USB2PHY_CFG21_PHY_TX_DIG_BYPASS_SEL BIT(19) +/* USBDP_TOP */ #define USBCS_PHY_CFG1_OFFSET 0x28 +#define USBCS_PHY_CFG1_PHY0_MPLLA_SSC_EN BIT(1) +#define USBCS_PHY_CFG1_PHY0_SRAM_BYPASS_MODE GENMASK(11, 10) +#define SRAM_BYPASS_MODE_BYPASS_FIRMWARE BIT(0) +#define SRAM_BYPASS_MODE_BYPASS_CONTEXT BIT(1) #define USBCS_PHY_CFG1_SYS_VBUSVALID BIT(17) +#define USBDP_TOP_CFG_REG_OFFSET 0x44 +#define USBDP_TOP_CFG_REG_PMGT_REF_CLK_REQ_N BIT(0) + +#define PHY_POWER_CONFIG_REG1_OFFSET 0x48 +#define PHY_POWER_CONFIG_REG1_PG_MODE_EN BIT(1) +#define PHY_POWER_CONFIG_REG1_UPCS_PIPE_CONFIG GENMASK(31, 14) +#define UPCS_PIPE_CONFIG_ISO_CPM BIT(5) +#define UPCS_PIPE_CONFIG_PG_MODE_STATIC BIT(6) +#define UPCS_PIPE_CONFIG_LANE_RESET_NO_PG_EXIT BIT(9) + +/* USB3_TCA */ +#define TCA_INTR_STS_OFFSET 0x8 +#define TCA_INTR_STS_XA_ACT_EVT BIT(0) +#define TCA_TCPC_OFFSET 0x14 +#define TCA_TCPC_MUX_CONTROL GENMASK(2, 0) +#define TCA_TCPC_MUX_CONTROL_USB_ONLY 0x1 +#define TCA_TCPC_CONNECTOR_ORIENTATION BIT(3) +#define TCA_TCPC_VALID BIT(4) +#define TCA_PSTATE_0_OFFSET 0x50 +#define TCA_PSTATE_0_UPCS_LANE0_PHYSTATUS BIT(8) + +#define GPHY_TCA_DELAY_US 10 +#define GPHY_TCA_TIMEOUT_US 2500000 + enum google_usb_phy_id { GOOGLE_USB2_PHY, + GOOGLE_USB3_PHY, GOOGLE_USB_PHY_NUM, }; @@ -46,34 +77,152 @@ struct google_usb_phy_instance { struct reset_control_bulk_data *rsts; }; +struct google_usb_phy_config { + const char * const *clk_names; + unsigned int num_clks; + const char * const *rst_names; + unsigned int num_rsts; +}; + +static const char * const u2phy_clk_names[] = { + "usb2", + "usb2_apb", +}; +static const char * const u3phy_clk_names[] = { + "usb3" +}; +static const char * const u2phy_rst_names[] = { + "usb2", + "usb2_apb", +}; +static const char * const u3phy_rst_names[] = { + "usb3" +}; + +static const struct google_usb_phy_config phy_configs[GOOGLE_USB_PHY_NUM] = { + [GOOGLE_USB2_PHY] = { + .clk_names = u2phy_clk_names, + .num_clks = ARRAY_SIZE(u2phy_clk_names), + .rst_names = u2phy_rst_names, + .num_rsts = ARRAY_SIZE(u2phy_rst_names), + }, + [GOOGLE_USB3_PHY] = { + .clk_names = u3phy_clk_names, + .num_clks = ARRAY_SIZE(u3phy_clk_names), + .rst_names = u3phy_rst_names, + .num_rsts = ARRAY_SIZE(u3phy_rst_names), + }, +}; + +/* + * combo_phy_state + * COMBO_PHY_IDLE: The ComboPHY has been torn down and USB3 has not completed + * bringup + * COMBO_PHY_INIT_DONE: The ComboPHY bringup sequence is complete. + * COMBO_PHY_TCA_READY: The PoR => NC transition is complete, and the TCA can be + * moved into USB. + */ +enum combo_phy_state { + COMBO_PHY_IDLE, + COMBO_PHY_INIT_DONE, + COMBO_PHY_TCA_READY, +}; + struct google_usb_phy { struct device *dev; struct regmap *usb_cfg_regmap; unsigned int usb2_cfg_offset; void __iomem *usbdp_top_base; + void __iomem *usb3_tca_base; struct google_usb_phy_instance *insts; /* * Protect phy registers from concurrent access, specifically via - * google_usb_set_orientation callback. + * google_usb_set_orientation callback. phy_mutex also protects + * concurrent access to phy_state. */ struct mutex phy_mutex; struct typec_switch_dev *sw; enum typec_orientation orientation; + enum combo_phy_state phy_state; }; static void set_vbus_valid(struct google_usb_phy *gphy) { u32 reg; - if (gphy->orientation == TYPEC_ORIENTATION_NONE) { - reg = readl(gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + reg = readl(gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + if (gphy->orientation == TYPEC_ORIENTATION_NONE) reg &= ~USBCS_PHY_CFG1_SYS_VBUSVALID; - writel(reg, gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); - } else { - reg = readl(gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + else reg |= USBCS_PHY_CFG1_SYS_VBUSVALID; - writel(reg, gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); - } + writel(reg, gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); +} + +static void set_sram_bypass(struct google_usb_phy *gphy, u32 bypass) +{ + u32 reg; + + reg = readl(gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + reg &= ~USBCS_PHY_CFG1_PHY0_SRAM_BYPASS_MODE; + reg |= FIELD_PREP(USBCS_PHY_CFG1_PHY0_SRAM_BYPASS_MODE, bypass); + writel(reg, gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); +} + +static void set_pmgt_ref_clk_req_n(struct google_usb_phy *gphy, bool resume) +{ + u32 reg; + + reg = readl(gphy->usbdp_top_base + USBDP_TOP_CFG_REG_OFFSET); + if (resume) + reg |= USBDP_TOP_CFG_REG_PMGT_REF_CLK_REQ_N; + else + reg &= ~USBDP_TOP_CFG_REG_PMGT_REF_CLK_REQ_N; + writel(reg, gphy->usbdp_top_base + USBDP_TOP_CFG_REG_OFFSET); +} + +static int wait_tca_xa_ack(struct google_usb_phy *gphy) +{ + int ret; + u32 reg; + + ret = readl_poll_timeout(gphy->usb3_tca_base + TCA_INTR_STS_OFFSET, + reg, !!(reg & TCA_INTR_STS_XA_ACT_EVT), + GPHY_TCA_DELAY_US, GPHY_TCA_TIMEOUT_US); + if (ret) + dev_err(gphy->dev, "tca xa_ack timeout, ret=%d", ret); + + return ret; +} + +static int program_tca_locked(struct google_usb_phy *gphy) + __must_hold(&gphy->phy_mutex) +{ + int ret; + u32 reg; + + reg = readl(gphy->usb3_tca_base + TCA_INTR_STS_OFFSET); + writel(reg, gphy->usb3_tca_base + TCA_INTR_STS_OFFSET); + + reg = readl(gphy->usb3_tca_base + TCA_TCPC_OFFSET); + reg &= ~TCA_TCPC_MUX_CONTROL; + reg |= FIELD_PREP(TCA_TCPC_MUX_CONTROL, TCA_TCPC_MUX_CONTROL_USB_ONLY); + if (gphy->orientation == TYPEC_ORIENTATION_REVERSE) + reg |= TCA_TCPC_CONNECTOR_ORIENTATION; + else + reg &= ~TCA_TCPC_CONNECTOR_ORIENTATION; + reg |= TCA_TCPC_VALID; + writel(reg, gphy->usb3_tca_base + TCA_TCPC_OFFSET); + + ret = wait_tca_xa_ack(gphy); + dev_dbg(gphy->dev, "TCA switch %s, mux %lu, orientation %s", + ret ? "failed" : "success", + FIELD_GET(TCA_TCPC_MUX_CONTROL, reg), + FIELD_GET(TCA_TCPC_CONNECTOR_ORIENTATION, reg) ? "reverse" : "normal"); + + reg = readl(gphy->usb3_tca_base + TCA_INTR_STS_OFFSET); + writel(reg, gphy->usb3_tca_base + TCA_INTR_STS_OFFSET); + + return ret; } static int google_usb_set_orientation(struct typec_switch_dev *sw, @@ -92,6 +241,9 @@ static int google_usb_set_orientation(struct typec_switch_dev *sw, set_vbus_valid(gphy); + if (gphy->phy_state == COMBO_PHY_TCA_READY && orientation != TYPEC_ORIENTATION_NONE) + return program_tca_locked(gphy); + return 0; } @@ -161,6 +313,118 @@ static const struct phy_ops google_usb2_phy_ops = { .exit = google_usb2_phy_exit, }; +static int google_usb3_phy_init(struct phy *_phy) +{ + struct google_usb_phy_instance *inst = phy_get_drvdata(_phy); + struct google_usb_phy *gphy = inst->parent; + int ret = 0; + u32 reg; + + dev_dbg(gphy->dev, "initializing usb3 phy\n"); + + guard(mutex)(&gphy->phy_mutex); + + if (gphy->phy_state != COMBO_PHY_IDLE) { + dev_warn(gphy->dev, "usb3 phy init called when combo phy state is not idle"); + return 0; + } + + reg = readl(gphy->usbdp_top_base + PHY_POWER_CONFIG_REG1_OFFSET); + reg |= PHY_POWER_CONFIG_REG1_PG_MODE_EN; + reg &= ~PHY_POWER_CONFIG_REG1_UPCS_PIPE_CONFIG; + reg |= FIELD_PREP(PHY_POWER_CONFIG_REG1_UPCS_PIPE_CONFIG, + (UPCS_PIPE_CONFIG_ISO_CPM | + UPCS_PIPE_CONFIG_PG_MODE_STATIC | + UPCS_PIPE_CONFIG_LANE_RESET_NO_PG_EXIT)); + writel(reg, gphy->usbdp_top_base + PHY_POWER_CONFIG_REG1_OFFSET); + + set_vbus_valid(gphy); + + reg = readl(gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + reg |= USBCS_PHY_CFG1_PHY0_MPLLA_SSC_EN; + writel(reg, gphy->usbdp_top_base + USBCS_PHY_CFG1_OFFSET); + + set_sram_bypass(gphy, SRAM_BYPASS_MODE_BYPASS_FIRMWARE | + SRAM_BYPASS_MODE_BYPASS_CONTEXT); + set_pmgt_ref_clk_req_n(gphy, true); + + ret = clk_bulk_prepare_enable(inst->num_clks, inst->clks); + if (ret) + return ret; + + ret = reset_control_bulk_deassert(inst->num_rsts, inst->rsts); + if (ret) { + clk_bulk_disable_unprepare(inst->num_clks, inst->clks); + return ret; + } + + ret = readl_poll_timeout(gphy->usb3_tca_base + TCA_PSTATE_0_OFFSET, + reg, !(reg & TCA_PSTATE_0_UPCS_LANE0_PHYSTATUS), + GPHY_TCA_DELAY_US, GPHY_TCA_TIMEOUT_US); + if (ret) { + dev_err(gphy->dev, "wait for lane0 phystatus timed out"); + reset_control_bulk_assert(inst->num_rsts, inst->rsts); + clk_bulk_disable_unprepare(inst->num_clks, inst->clks); + return ret; + } + + gphy->phy_state = COMBO_PHY_INIT_DONE; + + return 0; +} + +static int google_usb3_phy_exit(struct phy *_phy) +{ + struct google_usb_phy_instance *inst = phy_get_drvdata(_phy); + struct google_usb_phy *gphy = inst->parent; + + dev_dbg(gphy->dev, "exiting usb3 phy\n"); + + guard(mutex)(&gphy->phy_mutex); + + set_pmgt_ref_clk_req_n(gphy, false); + reset_control_bulk_assert(inst->num_rsts, inst->rsts); + clk_bulk_disable_unprepare(inst->num_clks, inst->clks); + + gphy->phy_state = COMBO_PHY_IDLE; + + return 0; +} + +static int google_usb3_phy_power_on(struct phy *_phy) +{ + struct google_usb_phy_instance *inst = phy_get_drvdata(_phy); + struct google_usb_phy *gphy = inst->parent; + int ret; + + dev_dbg(gphy->dev, "power on usb3 phy\n"); + + guard(mutex)(&gphy->phy_mutex); + + if (gphy->phy_state == COMBO_PHY_TCA_READY) { + dev_warn(gphy->dev, "usb3 phy already powered on"); + return 0; + } + + ret = wait_tca_xa_ack(gphy); + if (ret) { + dev_err(gphy->dev, "PoR->NC transition timeout"); + return ret; + } + + gphy->phy_state = COMBO_PHY_TCA_READY; + + ret = program_tca_locked(gphy); + + return ret; +} + +static const struct phy_ops google_usb3_phy_ops = { + .init = google_usb3_phy_init, + .exit = google_usb3_phy_exit, + .power_on = google_usb3_phy_power_on, +}; + static struct phy *google_usb_phy_xlate(struct device *dev, const struct of_phandle_args *args) { @@ -173,14 +437,61 @@ static struct phy *google_usb_phy_xlate(struct device *dev, return gphy->insts[args->args[0]].phy; } +static int google_usb_phy_parse_clocks(struct google_usb_phy *gphy) +{ + struct device *dev = gphy->dev; + int id, i, ret; + + for (id = 0; id < GOOGLE_USB_PHY_NUM; id++) { + const struct google_usb_phy_config *cfg = &phy_configs[id]; + struct google_usb_phy_instance *inst = &gphy->insts[id]; + + inst->num_clks = cfg->num_clks; + inst->clks = devm_kcalloc(dev, inst->num_clks, sizeof(*inst->clks), GFP_KERNEL); + if (!inst->clks) + return -ENOMEM; + + for (i = 0; i < inst->num_clks; i++) + inst->clks[i].id = cfg->clk_names[i]; + + ret = devm_clk_bulk_get(dev, inst->num_clks, inst->clks); + if (ret) + return dev_err_probe(dev, ret, "failed to get phy%d clks\n", id); + } + + return 0; +} + +static int google_usb_phy_parse_resets(struct google_usb_phy *gphy) +{ + struct device *dev = gphy->dev; + int id, i, ret; + + for (id = 0; id < GOOGLE_USB_PHY_NUM; id++) { + const struct google_usb_phy_config *cfg = &phy_configs[id]; + struct google_usb_phy_instance *inst = &gphy->insts[id]; + + inst->num_rsts = cfg->num_rsts; + inst->rsts = devm_kcalloc(dev, inst->num_rsts, sizeof(*inst->rsts), GFP_KERNEL); + if (!inst->rsts) + return -ENOMEM; + + for (i = 0; i < inst->num_rsts; i++) + inst->rsts[i].id = cfg->rst_names[i]; + ret = devm_reset_control_bulk_get_exclusive(dev, inst->num_rsts, inst->rsts); + if (ret) + return dev_err_probe(dev, ret, "failed to get phy%d resets\n", id); + } + + return 0; +} + static int google_usb_phy_probe(struct platform_device *pdev) { struct typec_switch_desc sw_desc = { }; - struct google_usb_phy_instance *inst; struct phy_provider *phy_provider; struct device *dev = &pdev->dev; struct google_usb_phy *gphy; - struct phy *phy; u32 args[1]; int ret; @@ -212,39 +523,39 @@ static int google_usb_phy_probe(struct platform_device *pdev) return dev_err_probe(dev, PTR_ERR(gphy->usbdp_top_base), "invalid usbdp top\n"); + gphy->usb3_tca_base = devm_platform_ioremap_resource_byname(pdev, + "usb3_tca"); + if (IS_ERR(gphy->usb3_tca_base)) + return dev_err_probe(dev, PTR_ERR(gphy->usb3_tca_base), + "invalid usb3 tca\n"); + gphy->insts = devm_kcalloc(dev, GOOGLE_USB_PHY_NUM, sizeof(*gphy->insts), GFP_KERNEL); if (!gphy->insts) return -ENOMEM; - inst = &gphy->insts[GOOGLE_USB2_PHY]; - inst->parent = gphy; - inst->index = GOOGLE_USB2_PHY; - phy = devm_phy_create(dev, NULL, &google_usb2_phy_ops); - if (IS_ERR(phy)) - return dev_err_probe(dev, PTR_ERR(phy), + gphy->insts[GOOGLE_USB2_PHY].phy = devm_phy_create(dev, NULL, &google_usb2_phy_ops); + gphy->insts[GOOGLE_USB2_PHY].index = GOOGLE_USB2_PHY; + gphy->insts[GOOGLE_USB2_PHY].parent = gphy; + if (IS_ERR(gphy->insts[GOOGLE_USB2_PHY].phy)) + return dev_err_probe(dev, PTR_ERR(gphy->insts[GOOGLE_USB2_PHY].phy), "failed to create usb2 phy instance\n"); - inst->phy = phy; - phy_set_drvdata(phy, inst); + phy_set_drvdata(gphy->insts[GOOGLE_USB2_PHY].phy, &gphy->insts[GOOGLE_USB2_PHY]); - inst->num_clks = 2; - inst->clks = devm_kcalloc(dev, inst->num_clks, sizeof(*inst->clks), GFP_KERNEL); - if (!inst->clks) - return -ENOMEM; - inst->clks[0].id = "usb2"; - inst->clks[1].id = "usb2_apb"; - ret = devm_clk_bulk_get(dev, inst->num_clks, inst->clks); + gphy->insts[GOOGLE_USB3_PHY].phy = devm_phy_create(dev, NULL, &google_usb3_phy_ops); + gphy->insts[GOOGLE_USB3_PHY].index = GOOGLE_USB3_PHY; + gphy->insts[GOOGLE_USB3_PHY].parent = gphy; + if (IS_ERR(gphy->insts[GOOGLE_USB3_PHY].phy)) + return dev_err_probe(dev, PTR_ERR(gphy->insts[GOOGLE_USB3_PHY].phy), + "failed to create usb3 phy instance\n"); + phy_set_drvdata(gphy->insts[GOOGLE_USB3_PHY].phy, &gphy->insts[GOOGLE_USB3_PHY]); + + ret = google_usb_phy_parse_clocks(gphy); if (ret) - return dev_err_probe(dev, ret, "failed to get u2 phy clks\n"); + return ret; - inst->num_rsts = 2; - inst->rsts = devm_kcalloc(dev, inst->num_rsts, sizeof(*inst->rsts), GFP_KERNEL); - if (!inst->rsts) - return -ENOMEM; - inst->rsts[0].id = "usb2"; - inst->rsts[1].id = "usb2_apb"; - ret = devm_reset_control_bulk_get_exclusive(dev, inst->num_rsts, inst->rsts); + ret = google_usb_phy_parse_resets(gphy); if (ret) - return dev_err_probe(dev, ret, "failed to get u2 phy resets\n"); + return ret; phy_provider = devm_of_phy_provider_register(dev, google_usb_phy_xlate); if (IS_ERR(phy_provider)) base-commit: 2ace2e949979b82f82f12dd76d7c5a6145246ca3 -- 2.55.0.rc0.786.g65d90a0328-goog -- linux-phy mailing list linux-phy@lists.infradead.org https://lists.infradead.org/mailman/listinfo/linux-phy