From patchwork Mon Nov 17 22:41:37 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Bresticker X-Patchwork-Id: 5324161 Return-Path: X-Original-To: patchwork-linux-arm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 0CE4B9F472 for ; Mon, 17 Nov 2014 22:47:41 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 2A8582010C for ; Mon, 17 Nov 2014 22:47:38 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 528612012F for ; Mon, 17 Nov 2014 22:47:34 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1XqV2M-0005eL-GJ; Mon, 17 Nov 2014 22:44:46 +0000 Received: from mail-yh0-f73.google.com ([209.85.213.73]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1XqUzq-0003d4-VM for linux-arm-kernel@lists.infradead.org; Mon, 17 Nov 2014 22:42:21 +0000 Received: by mail-yh0-f73.google.com with SMTP id f10so643914yha.0 for ; Mon, 17 Nov 2014 14:41:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=iGF0KXrfSjfUg0pmOo9V2teCIgdPCDh+mhIx9OUdPc4=; b=SfX3ZVHwklqx/nhu7wZfRhug8FPz+12/V12iC6ix2sHVI7W6ayTfbHTJt95xaFWv6M QIdwOBBXkYYt6BQkmD3FC5VDO3Y3k88+lHHQgNY8fTE9gUI4qbutuaPyCYteSerDEl5S pQeoQbCUfXbR/31Vx/jLdevOVmwXBPADjW3ArRaltSX+unU+FZEM7FIUTCh5bmYBOzRD feH16O4+is2lky41BNhcxo7uOomZKmiIZLkB3Nkz3evRctp9TDY6CqgyYS9hliJSPBGv 2Q9zC52/wcztbHRkBZcYdpQXt9d4Nt0EzOLk1uXJXNIFAEqvgPcpTDNM8kDjd16uOC2P 0qHA== X-Gm-Message-State: ALoCoQlmqCffmjA9lUjdXMCSa07ktDCjU/qburw67DXw6341A2HAhs5561DbpkWEfNWj/cKq3gmR X-Received: by 10.236.39.9 with SMTP id c9mr69991791yhb.41.1416264109492; Mon, 17 Nov 2014 14:41:49 -0800 (PST) Received: from corpmail-nozzle1-1.hot.corp.google.com ([100.108.1.104]) by gmr-mx.google.com with ESMTPS id u7si9064296qcz.3.2014.11.17.14.41.47 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 17 Nov 2014 14:41:49 -0800 (PST) Received: from abrestic.mtv.corp.google.com ([172.22.65.70]) by corpmail-nozzle1-1.hot.corp.google.com with ESMTP id w4NKFbJp.1; Mon, 17 Nov 2014 14:41:49 -0800 Received: by abrestic.mtv.corp.google.com (Postfix, from userid 137652) id 1C934220DEC; Mon, 17 Nov 2014 14:41:47 -0800 (PST) From: Andrew Bresticker To: Stephen Warren , Thierry Reding , Alexandre Courbot , linux-tegra@vger.kernel.org Subject: [PATCH V5 07/12] pinctrl: tegra-xusb: Add USB PHY support Date: Mon, 17 Nov 2014 14:41:37 -0800 Message-Id: <1416264102-1323-8-git-send-email-abrestic@chromium.org> X-Mailer: git-send-email 2.1.0.rc2.206.gedb03e5 In-Reply-To: <1416264102-1323-1-git-send-email-abrestic@chromium.org> References: <1416264102-1323-1-git-send-email-abrestic@chromium.org> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20141117_144211_337013_E28360B7 X-CRM114-Status: GOOD ( 19.16 ) X-Spam-Score: -0.7 (/) Cc: Mark Rutland , devicetree@vger.kernel.org, linux-usb@vger.kernel.org, Russell King , Mathias Nyman , Pawel Moll , Ian Campbell , Andrew Bresticker , Greg Kroah-Hartman , Linus Walleij , Jassi Brar , linux-kernel@vger.kernel.org, Kishon Vijay Abraham I , Olof Johansson , Rob Herring , Alan Stern , linux-arm-kernel@lists.infradead.org, Kumar Gala , Grant Likely , Arnd Bergmann X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.18-1 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP In addition to the PCIe and SATA PHYs, the XUSB pad controller also supports 3 UTMI, 2 HSIC, and 2 USB3 PHYs. Each USB3 PHY uses a single PCIe or SATA lane and is mapped to one of the three UTMI ports. The xHCI controller will also send messages intended for the PHY driver, so request and listen for messages on the mailbox's PHY channel. Signed-off-by: Andrew Bresticker Acked-by: Linus Walleij Reviewed-by: Stephen Warren --- Changes from v4: - Disabled USB support on missing mailbox channel instead of failing to probe. - Made usb3-port a pinconfig property. - Addressed review comments from Thierry. No changes from v3. Changes from v2: - Added support for nvidia,otg-hs-curr-level-offset property. - Moved mailbox request handling to workqueue. - Added filtering out of non-PHY mailbox messages. - Dropped "-otg" from VBUS supplies. Changes from v1: - Updated to use common mailbox API. - Added SATA PHY enable sequence for USB3 ports using the SATA lane. - Made USB3 port-to-lane mappins a top-level binding rather than a pinconfig binding. --- drivers/pinctrl/Kconfig | 1 + drivers/pinctrl/pinctrl-tegra-xusb.c | 1262 +++++++++++++++++++++++++++++++++- include/soc/tegra/xusb.h | 7 + 3 files changed, 1254 insertions(+), 16 deletions(-) diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig index c6a66de..b2a96f3 100644 --- a/drivers/pinctrl/Kconfig +++ b/drivers/pinctrl/Kconfig @@ -160,6 +160,7 @@ config PINCTRL_TEGRA124 config PINCTRL_TEGRA_XUSB def_bool y if ARCH_TEGRA + depends on MAILBOX select GENERIC_PHY select PINCONF select PINMUX diff --git a/drivers/pinctrl/pinctrl-tegra-xusb.c b/drivers/pinctrl/pinctrl-tegra-xusb.c index 1631ec9..37ad84e 100644 --- a/drivers/pinctrl/pinctrl-tegra-xusb.c +++ b/drivers/pinctrl/pinctrl-tegra-xusb.c @@ -13,23 +13,54 @@ #include #include +#include #include #include #include #include #include #include +#include #include +#include + +#include +#include #include #include "core.h" #include "pinctrl-utils.h" +#define FUSE_SKU_CALIB_HS_CURR_LEVEL_PADX_SHIFT(x) ((x) ? 15 : 0) +#define FUSE_SKU_CALIB_HS_CURR_LEVEL_PAD_MASK 0x3f +#define FUSE_SKU_CALIB_HS_IREF_CAP_SHIFT 13 +#define FUSE_SKU_CALIB_HS_IREF_CAP_MASK 0x3 +#define FUSE_SKU_CALIB_HS_SQUELCH_LEVEL_SHIFT 11 +#define FUSE_SKU_CALIB_HS_SQUELCH_LEVEL_MASK 0x3 +#define FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_SHIFT 7 +#define FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_MASK 0xf + +#define XUSB_PADCTL_USB2_PORT_CAP 0x008 +#define XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_SHIFT(x) ((x) * 4) +#define XUSB_PADCTL_USB2_PORT_CAP_PORT_CAP_MASK 0x3 +#define XUSB_PADCTL_USB2_PORT_CAP_DISABLED 0x0 +#define XUSB_PADCTL_USB2_PORT_CAP_HOST 0x1 +#define XUSB_PADCTL_USB2_PORT_CAP_DEVICE 0x2 +#define XUSB_PADCTL_USB2_PORT_CAP_OTG 0x3 + +#define XUSB_PADCTL_SS_PORT_MAP 0x014 +#define XUSB_PADCTL_SS_PORT_MAP_PORTX_SHIFT(x) ((x) * 4) +#define XUSB_PADCTL_SS_PORT_MAP_PORT_MASK 0x7 + #define XUSB_PADCTL_ELPG_PROGRAM 0x01c #define XUSB_PADCTL_ELPG_PROGRAM_AUX_MUX_LP0_VCORE_DOWN (1 << 26) #define XUSB_PADCTL_ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN_EARLY (1 << 25) #define XUSB_PADCTL_ELPG_PROGRAM_AUX_MUX_LP0_CLAMP_EN (1 << 24) +#define XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_VCORE_DOWN(x) (1 << (18 + (x) * 4)) +#define XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN_EARLY(x) \ + (1 << (17 + (x) * 4)) +#define XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN(x) (1 << (16 + (x) * 4)) #define XUSB_PADCTL_IOPHY_PLL_P0_CTL1 0x040 #define XUSB_PADCTL_IOPHY_PLL_P0_CTL1_PLL0_LOCKDET (1 << 19) @@ -41,17 +72,136 @@ #define XUSB_PADCTL_IOPHY_PLL_P0_CTL2_TXCLKREF_EN (1 << 5) #define XUSB_PADCTL_IOPHY_PLL_P0_CTL2_TXCLKREF_SEL (1 << 4) +#define XUSB_PADCTL_IOPHY_USB3_PADX_CTL2(x) (0x058 + (x) * 4) +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_CDR_CNTL_SHIFT 24 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_CDR_CNTL_MASK 0xff +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_SHIFT 16 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_MASK 0x3f +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_SHIFT 8 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_MASK 0x3f +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_SHIFT 8 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_MASK 0xffff +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_WANDER_SHIFT 4 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_WANDER_MASK 0x7 + +#define XUSB_PADCTL_IOPHY_USB3_PADX_CTL4(x) (0x068 + (x) * 4) +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_SHIFT 24 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_MASK 0x1f +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_SHIFT 16 +#define XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_MASK 0x7f + +#define XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL2(x) ((x) < 2 ? 0x078 + (x) * 4 : \ + 0x0f8 + (x) * 4) +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL2_SPARE_IN_SHIFT 28 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL2_SPARE_IN_MASK 0x3 + +#define XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL5(x) ((x) < 2 ? 0x090 + (x) * 4 : \ + 0x11c + (x) * 4) +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL5_RX_QEYE_EN (1 << 8) + +#define XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL6(x) ((x) < 2 ? 0x098 + (x) * 4 : \ + 0x128 + (x) * 4) +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SHIFT 24 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_G_Z_MASK 0x3f +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_TAP_MASK 0x1f +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_AMP_MASK 0x7f +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT 16 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK 0xff +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_G_Z 0x21 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_TAP 0x32 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_AMP 0x33 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_CTLE_Z 0x48 +#define XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_LATCH_G_Z 0xa1 + +#define XUSB_PADCTL_USB2_OTG_PADX_CTL0(x) (0x0a0 + (x) * 4) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD_ZI (1 << 21) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD2 (1 << 20) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD (1 << 19) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_LS_RSLEW_SHIFT 14 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_LS_RSLEW_MASK 0x3 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_SLEW_SHIFT 6 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_SLEW_MASK 0x3f +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT 0 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_MASK 0x3f + +#define XUSB_PADCTL_USB2_OTG_PADX_CTL1(x) (0x0ac + (x) * 4) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_HS_IREF_CAP_SHIFT 9 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_HS_IREF_CAP_MASK 0x3 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT 3 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_MASK 0x7 +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DR (1 << 2) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DISC_FORCE_POWERUP (1 << 1) +#define XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_CHRP_FORCE_POWERUP (1 << 0) + +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0 0x0b8 +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD (1 << 12) +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT 2 +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_MASK 0x7 +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT 0 +#define XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_MASK 0x3 + +#define XUSB_PADCTL_HSIC_PADX_CTL0(x) (0x0c0 + (x) * 4) +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_SHIFT 12 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_MASK 0x7 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_SHIFT 8 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_MASK 0x7 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_SHIFT 4 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_MASK 0x7 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_SHIFT 0 +#define XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_MASK 0x7 + +#define XUSB_PADCTL_HSIC_PADX_CTL1(x) (0x0c8 + (x) * 4) +#define XUSB_PADCTL_HSIC_PAD_CTL1_RPU_STROBE (1 << 10) +#define XUSB_PADCTL_HSIC_PAD_CTL1_RPU_DATA (1 << 9) +#define XUSB_PADCTL_HSIC_PAD_CTL1_RPD_STROBE (1 << 8) +#define XUSB_PADCTL_HSIC_PAD_CTL1_RPD_DATA (1 << 7) +#define XUSB_PADCTL_HSIC_PAD_CTL1_PD_ZI (1 << 5) +#define XUSB_PADCTL_HSIC_PAD_CTL1_PD_RX (1 << 4) +#define XUSB_PADCTL_HSIC_PAD_CTL1_PD_TRX (1 << 3) +#define XUSB_PADCTL_HSIC_PAD_CTL1_PD_TX (1 << 2) +#define XUSB_PADCTL_HSIC_PAD_CTL1_AUTO_TERM_EN (1 << 0) + +#define XUSB_PADCTL_HSIC_PADX_CTL2(x) (0x0d0 + (x) * 4) +#define XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT 4 +#define XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK 0x7 +#define XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT 0 +#define XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK 0x7 + +#define XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL 0x0e0 +#define XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL_STRB_TRIM_MASK 0x1f + #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1 0x138 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL1_LOCKDET (1 << 27) #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL1_MODE (1 << 24) +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL0_REFCLK_NDIV_SHIFT 20 +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL0_REFCLK_NDIV_MASK 0x3 #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL_PWR_OVRD (1 << 3) #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL_RST (1 << 1) #define XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL_IDDQ (1 << 0) +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2 0x13c +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL1_CP_CNTL_SHIFT 20 +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL1_CP_CNTL_MASK 0xf +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL0_CP_CNTL_SHIFT 16 +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL0_CP_CNTL_MASK 0xf +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_TCLKOUT_EN (1 << 12) +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_TXCLKREF_SEL (1 << 4) +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_XDIGCLK_SEL_SHIFT 0 +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL2_XDIGCLK_SEL_MASK 0x7 + +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL3 0x140 +#define XUSB_PADCTL_IOPHY_PLL_S0_CTL3_RCAL_BYPASS (1 << 7) + #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1 0x148 #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1_IDDQ_OVRD (1 << 1) #define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL1_IDDQ (1 << 0) +#define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL2 0x14c + +#define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL5 0x158 + +#define XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL6 0x15c + struct tegra_xusb_padctl_function { const char *name; const char * const *groups; @@ -72,6 +222,16 @@ struct tegra_xusb_padctl_soc { const struct tegra_xusb_padctl_lane *lanes; unsigned int num_lanes; + + u32 rx_wander; + u32 rx_eq; + u32 cdr_cntl; + u32 dfe_cntl; + u32 hs_slew; + u32 ls_rslew[TEGRA_XUSB_UTMI_PHYS]; + u32 hs_discon_level; + u32 spare_in; + unsigned int hsic_port_offset; }; struct tegra_xusb_padctl_lane { @@ -86,6 +246,22 @@ struct tegra_xusb_padctl_lane { unsigned int num_funcs; }; +struct tegra_xusb_fuse_calibration { + u32 hs_curr_level[TEGRA_XUSB_UTMI_PHYS]; + u32 hs_iref_cap; + u32 hs_term_range_adj; + u32 hs_squelch_level; +}; + +struct tegra_xusb_usb3_port { + unsigned int lane; + bool context_saved; + u32 tap1_val; + u32 amp_val; + u32 ctle_z_val; + u32 ctle_g_val; +}; + struct tegra_xusb_padctl { struct device *dev; void __iomem *regs; @@ -93,13 +269,25 @@ struct tegra_xusb_padctl { struct reset_control *rst; const struct tegra_xusb_padctl_soc *soc; + struct tegra_xusb_fuse_calibration calib; struct pinctrl_dev *pinctrl; struct pinctrl_desc desc; struct phy_provider *provider; - struct phy *phys[2]; + struct phy *phys[TEGRA_XUSB_NUM_PHYS]; unsigned int enable; + + struct work_struct mbox_req_work; + struct tegra_xusb_mbox_msg mbox_req; + struct mbox_client mbox_client; + struct mbox_chan *mbox_chan; + + struct tegra_xusb_usb3_port usb3_ports[TEGRA_XUSB_USB3_PHYS]; + unsigned int utmi_enable; + unsigned int hs_curr_level_offset[TEGRA_XUSB_UTMI_PHYS]; + struct regulator *vbus[TEGRA_XUSB_UTMI_PHYS]; + struct regulator *vddio_hsic; }; static inline void padctl_writel(struct tegra_xusb_padctl *padctl, u32 value, @@ -114,6 +302,53 @@ static inline u32 padctl_readl(struct tegra_xusb_padctl *padctl, return readl(padctl->regs + offset); } +static inline struct tegra_xusb_padctl * +mbox_work_to_padctl(struct work_struct *work) +{ + return container_of(work, struct tegra_xusb_padctl, mbox_req_work); +} + +#define PIN_OTG_0 0 +#define PIN_OTG_1 1 +#define PIN_OTG_2 2 +#define PIN_ULPI_0 3 +#define PIN_HSIC_0 4 +#define PIN_HSIC_1 5 +#define PIN_PCIE_0 6 +#define PIN_PCIE_1 7 +#define PIN_PCIE_2 8 +#define PIN_PCIE_3 9 +#define PIN_PCIE_4 10 +#define PIN_SATA_0 11 + +static inline bool lane_is_otg(unsigned int lane) +{ + return lane >= PIN_OTG_0 && lane <= PIN_OTG_2; +} + +static inline bool lane_is_hsic(unsigned int lane) +{ + return lane >= PIN_HSIC_0 && lane <= PIN_HSIC_1; +} + +static inline bool lane_is_pcie_or_sata(unsigned int lane) +{ + return lane >= PIN_PCIE_0 && lane <= PIN_SATA_0; +} + +static int lane_to_usb3_port(struct tegra_xusb_padctl *padctl, + unsigned int lane) +{ + unsigned int i; + + for (i = 0; i < TEGRA_XUSB_USB3_PHYS; i++) { + if (padctl->usb3_ports[i].lane == lane) + return i; + } + + return -EINVAL; +} + static int tegra_xusb_padctl_get_groups_count(struct pinctrl_dev *pinctrl) { struct tegra_xusb_padctl *padctl = pinctrl_dev_get_drvdata(pinctrl); @@ -131,6 +366,17 @@ static const char *tegra_xusb_padctl_get_group_name(struct pinctrl_dev *pinctrl, enum tegra_xusb_padctl_param { TEGRA_XUSB_PADCTL_IDDQ, + TEGRA_XUSB_PADCTL_USB3_PORT, + TEGRA_XUSB_PADCTL_USB2_PORT, + TEGRA_XUSB_PADCTL_HSIC_STROBE_TRIM, + TEGRA_XUSB_PADCTL_HSIC_RX_STROBE_TRIM, + TEGRA_XUSB_PADCTL_HSIC_RX_DATA_TRIM, + TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEN, + TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEP, + TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWN, + TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWP, + TEGRA_XUSB_PADCTL_HSIC_AUTO_TERM, + TEGRA_XUSB_PADCTL_OTG_HS_CURR_LEVEL_OFFSET, }; static const struct tegra_xusb_padctl_property { @@ -138,6 +384,18 @@ static const struct tegra_xusb_padctl_property { enum tegra_xusb_padctl_param param; } properties[] = { { "nvidia,iddq", TEGRA_XUSB_PADCTL_IDDQ }, + { "nvidia,usb3-port", TEGRA_XUSB_PADCTL_USB3_PORT }, + { "nvidia,usb2-port", TEGRA_XUSB_PADCTL_USB2_PORT }, + { "nvidia,hsic-strobe-trim", TEGRA_XUSB_PADCTL_HSIC_STROBE_TRIM }, + { "nvidia,hsic-rx-strobe-trim", TEGRA_XUSB_PADCTL_HSIC_RX_STROBE_TRIM }, + { "nvidia,hsic-rx-data-trim", TEGRA_XUSB_PADCTL_HSIC_RX_DATA_TRIM }, + { "nvidia,hsic-tx-rtune-n", TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEN }, + { "nvidia,hsic-tx-rtune-p", TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEP }, + { "nvidia,hsic-tx-rslew-n", TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWN }, + { "nvidia,hsic-tx-rslew-p", TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWP }, + { "nvidia,hsic-auto-term", TEGRA_XUSB_PADCTL_HSIC_AUTO_TERM }, + { "nvidia,otg-hs-curr-level-offset", + TEGRA_XUSB_PADCTL_OTG_HS_CURR_LEVEL_OFFSET }, }; #define TEGRA_XUSB_PADCTL_PACK(param, value) ((param) << 16 | (value)) @@ -322,6 +580,7 @@ static int tegra_xusb_padctl_pinconf_group_get(struct pinctrl_dev *pinctrl, const struct tegra_xusb_padctl_lane *lane; enum tegra_xusb_padctl_param param; u32 value; + int port; param = TEGRA_XUSB_PADCTL_UNPACK_PARAM(*config); lane = &padctl->soc->lanes[group]; @@ -338,8 +597,136 @@ static int tegra_xusb_padctl_pinconf_group_get(struct pinctrl_dev *pinctrl, value = 0; else value = 1; + break; - *config = TEGRA_XUSB_PADCTL_PACK(param, value); + case TEGRA_XUSB_PADCTL_USB3_PORT: + value = lane_to_usb3_port(padctl, group); + if (value < 0) { + dev_err(padctl->dev, + "Pin %d not mapped to USB3 port\n", group); + return -EINVAL; + } + break; + + case TEGRA_XUSB_PADCTL_USB2_PORT: + port = lane_to_usb3_port(padctl, group); + if (port < 0) { + dev_err(padctl->dev, + "Pin %d not mapped to USB3 port\n", group); + return -EINVAL; + } + + value = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_MAP) >> + XUSB_PADCTL_SS_PORT_MAP_PORTX_SHIFT(port); + value &= XUSB_PADCTL_SS_PORT_MAP_PORT_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_STROBE_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + value = padctl_readl(padctl, + XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL); + value &= XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL_STRB_TRIM_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_RX_STROBE_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL2(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_RX_DATA_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL2(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEN: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEP: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWN: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWP: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL0(port)) >> + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_SHIFT; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_MASK; + break; + + case TEGRA_XUSB_PADCTL_HSIC_AUTO_TERM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + if (value & XUSB_PADCTL_HSIC_PAD_CTL1_AUTO_TERM_EN) + value = 1; + else + value = 0; + break; + + case TEGRA_XUSB_PADCTL_OTG_HS_CURR_LEVEL_OFFSET: + if (!lane_is_otg(group)) { + dev_err(padctl->dev, "Pin %d is not an OTG pad\n", + group); + return -EINVAL; + } + + port = group - PIN_OTG_0; + value = padctl->hs_curr_level_offset[port]; break; default: @@ -348,6 +735,7 @@ static int tegra_xusb_padctl_pinconf_group_get(struct pinctrl_dev *pinctrl, return -ENOTSUPP; } + *config = TEGRA_XUSB_PADCTL_PACK(param, value); return 0; } @@ -362,6 +750,7 @@ static int tegra_xusb_padctl_pinconf_group_set(struct pinctrl_dev *pinctrl, unsigned long value; unsigned int i; u32 regval; + int port; lane = &padctl->soc->lanes[group]; @@ -385,6 +774,206 @@ static int tegra_xusb_padctl_pinconf_group_set(struct pinctrl_dev *pinctrl, padctl_writel(padctl, regval, lane->offset); break; + case TEGRA_XUSB_PADCTL_USB3_PORT: + if (value >= TEGRA_XUSB_USB3_PHYS) { + dev_err(padctl->dev, "Invalid USB3 port: %lu\n", + value); + return -EINVAL; + } + if (!lane_is_pcie_or_sata(group)) { + dev_err(padctl->dev, + "USB3 port not applicable for pin %d\n", + group); + return -EINVAL; + } + + padctl->usb3_ports[value].lane = group; + break; + + case TEGRA_XUSB_PADCTL_USB2_PORT: + if (value >= TEGRA_XUSB_UTMI_PHYS) { + dev_err(padctl->dev, "Invalid USB2 port: %lu\n", + value); + return -EINVAL; + } + if (!lane_is_pcie_or_sata(group)) { + dev_err(padctl->dev, + "USB2 port not applicable for pin %d\n", + group); + return -EINVAL; + } + port = lane_to_usb3_port(padctl, group); + if (port < 0) { + dev_err(padctl->dev, + "Pin %d not mapped to USB3 port\n", + group); + return -EINVAL; + } + + regval = padctl_readl(padctl, XUSB_PADCTL_SS_PORT_MAP); + regval &= ~(XUSB_PADCTL_SS_PORT_MAP_PORT_MASK << + XUSB_PADCTL_SS_PORT_MAP_PORTX_SHIFT(port)); + regval |= value << + XUSB_PADCTL_SS_PORT_MAP_PORTX_SHIFT(port); + padctl_writel(padctl, regval, XUSB_PADCTL_SS_PORT_MAP); + break; + + case TEGRA_XUSB_PADCTL_HSIC_STROBE_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + value &= XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL_STRB_TRIM_MASK; + padctl_writel(padctl, value, + XUSB_PADCTL_HSIC_STRB_TRIM_CONTROL); + break; + + case TEGRA_XUSB_PADCTL_HSIC_RX_STROBE_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL2(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_MASK << + XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL2_RX_STROBE_TRIM_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL2(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_RX_DATA_TRIM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL2(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_MASK << + XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL2_RX_DATA_TRIM_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL2(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEN: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_MASK << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEN_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RTUNEP: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_MASK << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RTUNEP_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWN: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_MASK << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWN_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_TX_RSLEWP: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + value &= XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_MASK; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + regval &= ~(XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_MASK << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_SHIFT); + regval |= value << + XUSB_PADCTL_HSIC_PAD_CTL0_TX_RSLEWP_SHIFT; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL0(port)); + break; + + case TEGRA_XUSB_PADCTL_HSIC_AUTO_TERM: + if (!lane_is_hsic(group)) { + dev_err(padctl->dev, "Pin %d not an HSIC\n", + group); + return -EINVAL; + } + + port = group - PIN_HSIC_0; + regval = padctl_readl(padctl, + XUSB_PADCTL_HSIC_PADX_CTL1(port)); + if (!value) + regval &= ~XUSB_PADCTL_HSIC_PAD_CTL1_AUTO_TERM_EN; + else + regval |= XUSB_PADCTL_HSIC_PAD_CTL1_AUTO_TERM_EN; + padctl_writel(padctl, regval, + XUSB_PADCTL_HSIC_PADX_CTL1(port)); + break; + + case TEGRA_XUSB_PADCTL_OTG_HS_CURR_LEVEL_OFFSET: + if (!lane_is_otg(group)) { + dev_err(padctl->dev, + "Pin %d is not an OTG pad\n", group); + return -EINVAL; + } + + port = group - PIN_OTG_0; + value &= XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_MASK; + padctl->hs_curr_level_offset[port] = value; + break; + default: dev_err(padctl->dev, "invalid configuration parameter: %04x\n", @@ -671,6 +1260,548 @@ static const struct phy_ops sata_phy_ops = { .owner = THIS_MODULE, }; +static int usb3_phy_to_port(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + unsigned int i; + + for (i = 0; i < TEGRA_XUSB_USB3_PHYS; i++) { + if (phy == padctl->phys[TEGRA_XUSB_PADCTL_USB3_P0 + i]) + return i; + } + WARN_ON(1); + + return -EINVAL; +} + +static int usb3_phy_power_on(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = usb3_phy_to_port(phy); + unsigned int lane; + u32 value, offset; + + if (port < 0) + return port; + + lane = padctl->usb3_ports[port].lane; + if (!lane_is_pcie_or_sata(lane)) { + dev_err(padctl->dev, "USB3 PHY %d mapped to invalid lane: %d\n", + port, lane); + return -EINVAL; + } + + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_USB3_PADX_CTL2(port)); + value &= ~((XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_WANDER_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_WANDER_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_CDR_CNTL_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_CDR_CNTL_SHIFT)); + value |= (padctl->soc->rx_wander << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_WANDER_SHIFT) | + (padctl->soc->cdr_cntl << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_CDR_CNTL_SHIFT) | + (padctl->soc->rx_eq << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_SHIFT); + if (padctl->usb3_ports[port].context_saved) { + value &= ~((XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_SHIFT)); + value |= (padctl->usb3_ports[port].ctle_g_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_SHIFT) | + (padctl->usb3_ports[port].ctle_z_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_SHIFT); + } + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_USB3_PADX_CTL2(port)); + + value = padctl->soc->dfe_cntl; + if (padctl->usb3_ports[port].context_saved) { + value &= ~((XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_SHIFT)); + value |= (padctl->usb3_ports[port].tap1_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_SHIFT) | + (padctl->usb3_ports[port].amp_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_SHIFT); + } + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_USB3_PADX_CTL4(port)); + + offset = (lane == PIN_SATA_0) ? + XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL2 : + XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL2(lane - PIN_PCIE_0); + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL2_SPARE_IN_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL2_SPARE_IN_SHIFT); + value |= padctl->soc->spare_in << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL2_SPARE_IN_SHIFT; + padctl_writel(padctl, value, offset); + + offset = (lane == PIN_SATA_0) ? + XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL5 : + XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL5(lane - PIN_PCIE_0); + value = padctl_readl(padctl, offset); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL5_RX_QEYE_EN; + padctl_writel(padctl, value, offset); + + /* Enable SATA PHY when SATA lane is used */ + if (lane == PIN_SATA_0) { + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_PLL_S0_CTL1); + value &= ~(XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL0_REFCLK_NDIV_MASK << + XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL0_REFCLK_NDIV_SHIFT); + value |= 0x2 << + XUSB_PADCTL_IOPHY_PLL_S0_CTL1_PLL0_REFCLK_NDIV_SHIFT; + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_PLL_S0_CTL1); + + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_PLL_S0_CTL2); + value &= ~((XUSB_PADCTL_IOPHY_PLL_S0_CTL2_XDIGCLK_SEL_MASK << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_XDIGCLK_SEL_SHIFT) | + (XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL1_CP_CNTL_MASK << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL1_CP_CNTL_SHIFT) | + (XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL0_CP_CNTL_MASK << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL0_CP_CNTL_SHIFT) | + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_TCLKOUT_EN); + value |= (0x7 << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_XDIGCLK_SEL_SHIFT) | + (0x8 << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL1_CP_CNTL_SHIFT) | + (0x8 << + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_PLL0_CP_CNTL_SHIFT) | + XUSB_PADCTL_IOPHY_PLL_S0_CTL2_TXCLKREF_SEL; + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_PLL_S0_CTL2); + + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_PLL_S0_CTL3); + value &= ~XUSB_PADCTL_IOPHY_PLL_S0_CTL3_RCAL_BYPASS; + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_PLL_S0_CTL3); + } + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value &= ~XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN_EARLY(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + usleep_range(100, 200); + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value &= ~XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN_EARLY(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value &= ~XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_VCORE_DOWN(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + return 0; +} + +static int usb3_phy_power_off(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = usb3_phy_to_port(phy); + u32 value; + + if (port < 0) + return port; + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value |= XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN_EARLY(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + usleep_range(100, 200); + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value |= XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_CLAMP_EN_EARLY(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + usleep_range(250, 350); + + value = padctl_readl(padctl, XUSB_PADCTL_ELPG_PROGRAM); + value |= XUSB_PADCTL_ELPG_PROGRAM_SSPX_ELPG_VCORE_DOWN(port); + padctl_writel(padctl, value, XUSB_PADCTL_ELPG_PROGRAM); + + return 0; +} + +static int usb3_phy_save_context(struct tegra_xusb_padctl *padctl, + unsigned int port) +{ + unsigned int lane = padctl->usb3_ports[port].lane; + u32 value, offset; + + if (port >= TEGRA_XUSB_USB3_PHYS) + return -EINVAL; + + padctl->usb3_ports[port].context_saved = true; + + offset = (lane == PIN_SATA_0) ? + XUSB_PADCTL_IOPHY_MISC_PAD_S0_CTL6 : + XUSB_PADCTL_IOPHY_MISC_PAD_PX_CTL6(lane - PIN_PCIE_0); + + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_TAP << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT; + padctl_writel(padctl, value, offset); + + value = padctl_readl(padctl, offset) >> + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SHIFT; + padctl->usb3_ports[port].tap1_val = value & + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_TAP_MASK; + + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_AMP << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT; + padctl_writel(padctl, value, offset); + + value = padctl_readl(padctl, offset) >> + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SHIFT; + padctl->usb3_ports[port].amp_val = value & + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_AMP_MASK; + + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_USB3_PADX_CTL4(port)); + value &= ~((XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_SHIFT)); + value |= (padctl->usb3_ports[port].tap1_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_TAP_SHIFT) | + (padctl->usb3_ports[port].amp_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL4_DFE_CNTL_AMP_SHIFT); + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_USB3_PADX_CTL4(port)); + + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_LATCH_G_Z << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT; + padctl_writel(padctl, value, offset); + + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_G_Z << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT; + padctl_writel(padctl, value, offset); + + value = padctl_readl(padctl, offset) >> + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SHIFT; + padctl->usb3_ports[port].ctle_g_val = value & + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_G_Z_MASK; + + value = padctl_readl(padctl, offset); + value &= ~(XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_MASK << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT); + value |= XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_CTLE_Z << + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SEL_SHIFT; + padctl_writel(padctl, value, offset); + + value = padctl_readl(padctl, offset) >> + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_SHIFT; + padctl->usb3_ports[port].ctle_z_val = value & + XUSB_PADCTL_IOPHY_MISC_PAD_CTL6_MISC_OUT_G_Z_MASK; + + value = padctl_readl(padctl, XUSB_PADCTL_IOPHY_USB3_PADX_CTL2(port)); + value &= ~((XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_SHIFT) | + (XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_MASK << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_SHIFT)); + value |= (padctl->usb3_ports[port].ctle_g_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_G_SHIFT) | + (padctl->usb3_ports[port].ctle_z_val << + XUSB_PADCTL_IOPHY_USB3_PAD_CTL2_RX_EQ_Z_SHIFT); + padctl_writel(padctl, value, XUSB_PADCTL_IOPHY_USB3_PADX_CTL2(port)); + + return 0; +} + +static const struct phy_ops usb3_phy_ops = { + .init = tegra_xusb_phy_init, + .exit = tegra_xusb_phy_exit, + .power_on = usb3_phy_power_on, + .power_off = usb3_phy_power_off, + .owner = THIS_MODULE, +}; + +static int utmi_phy_to_port(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + unsigned int i; + + for (i = 0; i < TEGRA_XUSB_UTMI_PHYS; i++) { + if (phy == padctl->phys[TEGRA_XUSB_PADCTL_UTMI_P0 + i]) + return i; + } + WARN_ON(1); + + return -EINVAL; +} + +static int utmi_phy_power_on(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = utmi_phy_to_port(phy); + int err; + u32 value; + + if (port < 0) + return port; + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + value &= ~((XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_MASK << + XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT) | + (XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_MASK << + XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT)); + value |= (padctl->calib.hs_squelch_level << + XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_SQUELCH_LEVEL_SHIFT) | + (padctl->soc->hs_discon_level << + XUSB_PADCTL_USB2_BIAS_PAD_CTL0_HS_DISCON_LEVEL_SHIFT); + padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_PORT_CAP); + value &= ~(XUSB_PADCTL_USB2_PORT_CAP_PORT_CAP_MASK << + XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_SHIFT(port)); + value |= XUSB_PADCTL_USB2_PORT_CAP_HOST << + XUSB_PADCTL_USB2_PORT_CAP_PORTX_CAP_SHIFT(port); + padctl_writel(padctl, value, XUSB_PADCTL_USB2_PORT_CAP); + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL0(port)); + value &= ~((XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_MASK << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT) | + (XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_SLEW_MASK << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_SLEW_SHIFT) | + (XUSB_PADCTL_USB2_OTG_PAD_CTL0_LS_RSLEW_MASK << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_LS_RSLEW_SHIFT) | + XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD | + XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD2 | + XUSB_PADCTL_USB2_OTG_PAD_CTL0_PD_ZI); + value |= (padctl->calib.hs_curr_level[port] + + padctl->hs_curr_level_offset[port]) << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_CURR_LEVEL_SHIFT; + value |= padctl->soc->hs_slew << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_HS_SLEW_SHIFT; + value |= padctl->soc->ls_rslew[port] << + XUSB_PADCTL_USB2_OTG_PAD_CTL0_LS_RSLEW_SHIFT; + padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL0(port)); + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_OTG_PADX_CTL1(port)); + value &= ~((XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_MASK << + XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT) | + (XUSB_PADCTL_USB2_OTG_PAD_CTL1_HS_IREF_CAP_MASK << + XUSB_PADCTL_USB2_OTG_PAD_CTL1_HS_IREF_CAP_SHIFT) | + XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DR | + XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_CHRP_FORCE_POWERUP | + XUSB_PADCTL_USB2_OTG_PAD_CTL1_PD_DISC_FORCE_POWERUP); + value |= (padctl->calib.hs_term_range_adj << + XUSB_PADCTL_USB2_OTG_PAD_CTL1_TERM_RANGE_ADJ_SHIFT) | + (padctl->calib.hs_iref_cap << + XUSB_PADCTL_USB2_OTG_PAD_CTL1_HS_IREF_CAP_SHIFT); + padctl_writel(padctl, value, XUSB_PADCTL_USB2_OTG_PADX_CTL1(port)); + + err = regulator_enable(padctl->vbus[port]); + if (err) + return err; + + mutex_lock(&padctl->lock); + + if (padctl->utmi_enable++ > 0) + goto out; + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + value &= ~XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD; + padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + +out: + mutex_unlock(&padctl->lock); + return 0; +} + +static int utmi_phy_power_off(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = utmi_phy_to_port(phy); + u32 value; + + if (port < 0) + return port; + + regulator_disable(padctl->vbus[port]); + + mutex_lock(&padctl->lock); + + if (WARN_ON(padctl->utmi_enable == 0)) + goto out; + + if (--padctl->utmi_enable > 0) + goto out; + + value = padctl_readl(padctl, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + value |= XUSB_PADCTL_USB2_BIAS_PAD_CTL0_PD; + padctl_writel(padctl, value, XUSB_PADCTL_USB2_BIAS_PAD_CTL0); + +out: + mutex_unlock(&padctl->lock); + return 0; +} + +static const struct phy_ops utmi_phy_ops = { + .init = tegra_xusb_phy_init, + .exit = tegra_xusb_phy_exit, + .power_on = utmi_phy_power_on, + .power_off = utmi_phy_power_off, + .owner = THIS_MODULE, +}; + +static int hsic_phy_to_port(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + unsigned int i; + + for (i = 0; i < TEGRA_XUSB_HSIC_PHYS; i++) { + if (phy == padctl->phys[TEGRA_XUSB_PADCTL_HSIC_P0 + i]) + return i; + } + WARN_ON(1); + + return -EINVAL; +} + +static int hsic_phy_power_on(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = hsic_phy_to_port(phy); + int err; + u32 value; + + if (port < 0) + return port; + + err = regulator_enable(padctl->vddio_hsic); + if (err) + return err; + + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + value &= ~(XUSB_PADCTL_HSIC_PAD_CTL1_RPD_STROBE | + XUSB_PADCTL_HSIC_PAD_CTL1_RPU_DATA | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_RX | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_ZI | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_TRX | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_TX); + value |= XUSB_PADCTL_HSIC_PAD_CTL1_RPD_DATA | + XUSB_PADCTL_HSIC_PAD_CTL1_RPU_STROBE; + padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + + return 0; +} + +static int hsic_phy_power_off(struct phy *phy) +{ + struct tegra_xusb_padctl *padctl = phy_get_drvdata(phy); + int port = hsic_phy_to_port(phy); + u32 value; + + if (port < 0) + return port; + + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + value |= XUSB_PADCTL_HSIC_PAD_CTL1_PD_RX | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_ZI | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_TRX | + XUSB_PADCTL_HSIC_PAD_CTL1_PD_TX; + padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + + regulator_disable(padctl->vddio_hsic); + + return 0; +} + +static void hsic_phy_set_idle(struct tegra_xusb_padctl *padctl, + unsigned int port, bool idle) +{ + u32 value; + + value = padctl_readl(padctl, XUSB_PADCTL_HSIC_PADX_CTL1(port)); + if (idle) + value |= XUSB_PADCTL_HSIC_PAD_CTL1_RPD_DATA | + XUSB_PADCTL_HSIC_PAD_CTL1_RPU_STROBE; + else + value &= ~(XUSB_PADCTL_HSIC_PAD_CTL1_RPD_DATA | + XUSB_PADCTL_HSIC_PAD_CTL1_RPU_STROBE); + padctl_writel(padctl, value, XUSB_PADCTL_HSIC_PADX_CTL1(port)); +} + +static const struct phy_ops hsic_phy_ops = { + .init = tegra_xusb_phy_init, + .exit = tegra_xusb_phy_exit, + .power_on = hsic_phy_power_on, + .power_off = hsic_phy_power_off, + .owner = THIS_MODULE, +}; + +static void tegra_xusb_phy_mbox_work(struct work_struct *work) +{ + struct tegra_xusb_padctl *padctl = mbox_work_to_padctl(work); + struct tegra_xusb_mbox_msg *msg = &padctl->mbox_req; + struct tegra_xusb_mbox_msg resp; + unsigned int i; + u32 ports; + + resp.cmd = 0; + switch (msg->cmd) { + case MBOX_CMD_SAVE_DFE_CTLE_CTX: + resp.data = msg->data; + if (usb3_phy_save_context(padctl, msg->data) < 0) + resp.cmd = MBOX_CMD_NAK; + else + resp.cmd = MBOX_CMD_ACK; + break; + case MBOX_CMD_START_HSIC_IDLE: + case MBOX_CMD_STOP_HSIC_IDLE: + ports = msg->data >> (padctl->soc->hsic_port_offset + 1); + resp.data = msg->data; + resp.cmd = MBOX_CMD_ACK; + for (i = 0; i < TEGRA_XUSB_HSIC_PHYS; i++) { + if (!(ports & BIT(i))) + continue; + if (msg->cmd == MBOX_CMD_START_HSIC_IDLE) + hsic_phy_set_idle(padctl, i, true); + else + hsic_phy_set_idle(padctl, i, false); + } + break; + default: + break; + } + + if (resp.cmd) + mbox_send_message(padctl->mbox_chan, &resp); +} + +static bool is_phy_mbox_message(u32 cmd) +{ + switch (cmd) { + case MBOX_CMD_SAVE_DFE_CTLE_CTX: + case MBOX_CMD_START_HSIC_IDLE: + case MBOX_CMD_STOP_HSIC_IDLE: + return true; + default: + return false; + } +} + +static void tegra_xusb_phy_mbox_rx(struct mbox_client *cl, void *data) +{ + struct tegra_xusb_padctl *padctl = dev_get_drvdata(cl->dev); + struct tegra_xusb_mbox_msg *msg = data; + + if (is_phy_mbox_message(msg->cmd)) { + padctl->mbox_req = *msg; + schedule_work(&padctl->mbox_req_work); + } +} + static struct phy *tegra_xusb_padctl_xlate(struct device *dev, struct of_phandle_args *args) { @@ -680,25 +1811,12 @@ static struct phy *tegra_xusb_padctl_xlate(struct device *dev, if (args->args_count <= 0) return ERR_PTR(-EINVAL); - if (index >= ARRAY_SIZE(padctl->phys)) + if (index >= ARRAY_SIZE(padctl->phys) && !padctl->phys[index]) return ERR_PTR(-EINVAL); return padctl->phys[index]; } -#define PIN_OTG_0 0 -#define PIN_OTG_1 1 -#define PIN_OTG_2 2 -#define PIN_ULPI_0 3 -#define PIN_HSIC_0 4 -#define PIN_HSIC_1 5 -#define PIN_PCIE_0 6 -#define PIN_PCIE_1 7 -#define PIN_PCIE_2 8 -#define PIN_PCIE_3 9 -#define PIN_PCIE_4 10 -#define PIN_SATA_0 11 - static const struct pinctrl_pin_desc tegra124_pins[] = { PINCTRL_PIN(PIN_OTG_0, "otg-0"), PINCTRL_PIN(PIN_OTG_1, "otg-1"), @@ -856,6 +1974,15 @@ static const struct tegra_xusb_padctl_soc tegra124_soc = { .functions = tegra124_functions, .num_lanes = ARRAY_SIZE(tegra124_lanes), .lanes = tegra124_lanes, + .rx_wander = 0xf, + .rx_eq = 0xf070, + .cdr_cntl = 0x24, + .dfe_cntl = 0x002008ee, + .hs_slew = 0xe, + .ls_rslew = {0x3, 0x0, 0x0}, + .hs_discon_level = 0x5, + .spare_in = 0x1, + .hsic_port_offset = 6, }; static const struct of_device_id tegra_xusb_padctl_of_match[] = { @@ -864,6 +1991,80 @@ static const struct of_device_id tegra_xusb_padctl_of_match[] = { }; MODULE_DEVICE_TABLE(of, tegra_xusb_padctl_of_match); +static int tegra_xusb_read_fuse_calibration(struct tegra_xusb_padctl *padctl) +{ + unsigned int i; + int err; + u32 value; + + err = tegra_fuse_readl(TEGRA_FUSE_SKU_CALIB_0, &value); + if (err < 0) + return err; + + for (i = 0; i < TEGRA_XUSB_UTMI_PHYS; i++) { + padctl->calib.hs_curr_level[i] = + (value >> FUSE_SKU_CALIB_HS_CURR_LEVEL_PADX_SHIFT(i)) & + FUSE_SKU_CALIB_HS_CURR_LEVEL_PAD_MASK; + } + padctl->calib.hs_iref_cap = + (value >> FUSE_SKU_CALIB_HS_IREF_CAP_SHIFT) & + FUSE_SKU_CALIB_HS_IREF_CAP_MASK; + padctl->calib.hs_term_range_adj = + (value >> FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_SHIFT) & + FUSE_SKU_CALIB_HS_TERM_RANGE_ADJ_MASK; + padctl->calib.hs_squelch_level = + (value >> FUSE_SKU_CALIB_HS_SQUELCH_LEVEL_SHIFT) & + FUSE_SKU_CALIB_HS_SQUELCH_LEVEL_MASK; + + return 0; +} + +static int tegra_xusb_setup_usb(struct tegra_xusb_padctl *padctl) +{ + struct phy *phy; + unsigned int i; + + for (i = 0; i < TEGRA_XUSB_USB3_PHYS; i++) { + phy = devm_phy_create(padctl->dev, NULL, &usb3_phy_ops, NULL); + if (IS_ERR(phy)) + return PTR_ERR(phy); + + padctl->phys[TEGRA_XUSB_PADCTL_USB3_P0 + i] = phy; + phy_set_drvdata(phy, padctl); + } + + for (i = 0; i < TEGRA_XUSB_UTMI_PHYS; i++) { + char reg_name[sizeof("vbus-N")]; + + sprintf(reg_name, "vbus-%d", i); + padctl->vbus[i] = devm_regulator_get(padctl->dev, reg_name); + if (IS_ERR(padctl->vbus[i])) + return PTR_ERR(padctl->vbus[i]); + + phy = devm_phy_create(padctl->dev, NULL, &utmi_phy_ops, NULL); + if (IS_ERR(phy)) + return PTR_ERR(phy); + + padctl->phys[TEGRA_XUSB_PADCTL_UTMI_P0 + i] = phy; + phy_set_drvdata(phy, padctl); + } + + padctl->vddio_hsic = devm_regulator_get(padctl->dev, "vddio-hsic"); + if (IS_ERR(padctl->vddio_hsic)) + return PTR_ERR(padctl->vddio_hsic); + + for (i = 0; i < TEGRA_XUSB_HSIC_PHYS; i++) { + phy = devm_phy_create(padctl->dev, NULL, &hsic_phy_ops, NULL); + if (IS_ERR(phy)) + return PTR_ERR(phy); + + padctl->phys[TEGRA_XUSB_PADCTL_HSIC_P0 + i] = phy; + phy_set_drvdata(phy, padctl); + } + + return 0; +} + static int tegra_xusb_padctl_probe(struct platform_device *pdev) { struct tegra_xusb_padctl *padctl; @@ -888,6 +2089,10 @@ static int tegra_xusb_padctl_probe(struct platform_device *pdev) if (IS_ERR(padctl->regs)) return PTR_ERR(padctl->regs); + err = tegra_xusb_read_fuse_calibration(padctl); + if (err < 0) + return err; + padctl->rst = devm_reset_control_get(&pdev->dev, NULL); if (IS_ERR(padctl->rst)) return PTR_ERR(padctl->rst); @@ -928,6 +2133,26 @@ static int tegra_xusb_padctl_probe(struct platform_device *pdev) padctl->phys[TEGRA_XUSB_PADCTL_SATA] = phy; phy_set_drvdata(phy, padctl); + INIT_WORK(&padctl->mbox_req_work, tegra_xusb_phy_mbox_work); + padctl->mbox_client.dev = &pdev->dev; + padctl->mbox_client.tx_block = true; + padctl->mbox_client.tx_tout = 0; + padctl->mbox_client.rx_callback = tegra_xusb_phy_mbox_rx; + padctl->mbox_chan = mbox_request_channel(&padctl->mbox_client, 0); + if (IS_ERR(padctl->mbox_chan)) { + err = PTR_ERR(padctl->mbox_chan); + if (err == -EPROBE_DEFER) { + goto unregister; + } else { + dev_warn(&pdev->dev, + "failed to get mailbox, USB support disabled"); + } + } else { + err = tegra_xusb_setup_usb(padctl); + if (err) + goto unregister; + } + padctl->provider = devm_of_phy_provider_register(&pdev->dev, tegra_xusb_padctl_xlate); if (IS_ERR(padctl->provider)) { @@ -950,6 +2175,11 @@ static int tegra_xusb_padctl_remove(struct platform_device *pdev) struct tegra_xusb_padctl *padctl = platform_get_drvdata(pdev); int err; + if (!IS_ERR(padctl->mbox_chan)) { + cancel_work_sync(&padctl->mbox_req_work); + mbox_free_channel(padctl->mbox_chan); + } + pinctrl_unregister(padctl->pinctrl); err = reset_control_assert(padctl->rst); diff --git a/include/soc/tegra/xusb.h b/include/soc/tegra/xusb.h index 5ce5e12..0136dc1 100644 --- a/include/soc/tegra/xusb.h +++ b/include/soc/tegra/xusb.h @@ -10,6 +10,13 @@ #ifndef __SOC_TEGRA_XUSB_H__ #define __SOC_TEGRA_XUSB_H__ +#define TEGRA_XUSB_USB3_PHYS 2 +#define TEGRA_XUSB_UTMI_PHYS 3 +#define TEGRA_XUSB_HSIC_PHYS 2 +#define TEGRA_XUSB_NUM_USB_PHYS (TEGRA_XUSB_USB3_PHYS + TEGRA_XUSB_UTMI_PHYS + \ + TEGRA_XUSB_HSIC_PHYS) +#define TEGRA_XUSB_NUM_PHYS (TEGRA_XUSB_NUM_USB_PHYS + 2) /* + SATA & PCIe */ + /* Command requests from the firmware */ enum tegra_xusb_mbox_cmd { MBOX_CMD_MSG_ENABLED = 1,