* [PATCH v3 2/8] arm64: dts: agilex5: add SD/eMMC host controller
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-07-24 14:50 ` [PATCH v3 3/8] dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant Tanmay Kathpalia
` (7 subsequent siblings)
8 siblings, 0 replies; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
The Agilex5 HPS includes a Cadence SD6HC that drives either an SD card
or eMMC, depending on the SOCDK daughter card. It uses separate SDMCLK
(CIU) and L4_MP (BIU) clocks, and has three resets for the host
controller, Combo PHY, and SDMMC OCP bridge.
On the SOCDK OOBE card the slot is SD-only: fixed 3.3 V card supply and
a GPIO-selected 3.3 V / 1.8 V I/O supply for UHS-I signalling up to
SDR104.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
Depends on commit ab45ecfab540 ("dt-bindings: reset: altr: add
COMBOPHY_RESET for Agilex5"), which is already in mainline via the
reset tree. It is not yet in mmc/next; apply or merge that commit when
building/testing this patch on top of mmc/next.
.../arm64/boot/dts/intel/socfpga_agilex5.dtsi | 25 ++++++++++++
.../boot/dts/intel/socfpga_agilex5_socdk.dts | 38 ++++++++++++++++++-
2 files changed, 62 insertions(+), 1 deletion(-)
diff --git a/arch/arm64/boot/dts/intel/socfpga_agilex5.dtsi b/arch/arm64/boot/dts/intel/socfpga_agilex5.dtsi
index b06c6d5d60ee..5ccbd7bf2034 100644
--- a/arch/arm64/boot/dts/intel/socfpga_agilex5.dtsi
+++ b/arch/arm64/boot/dts/intel/socfpga_agilex5.dtsi
@@ -300,6 +300,31 @@ portb: gpio-controller@0 {
};
};
+ /*
+ * Shared SD/eMMC controller node. On the SOCDK OOBE daughter-card
+ * this is used for SD card operation; on the SOCDK eMMC daughter-card
+ * it is configured for eMMC.
+ */
+ emmc: mmc@10808000 {
+ compatible = "altr,agilex5-sd6hc", "cdns,sd6hc";
+ reg = <0x10808000 0x1000>;
+ /*
+ * "ciu" (SDMCLK) is listed first so it is selected as the
+ * primary clock by the SDHCI platform layer; the SD6HC PHY
+ * timing calculations are derived from this clock rate.
+ */
+ clocks = <&clkmgr AGILEX5_SDMCLK>, <&clkmgr AGILEX5_L4_MP_CLK>;
+ clock-names = "ciu", "biu";
+ dma-coherent;
+ interrupts = <GIC_SPI 96 IRQ_TYPE_LEVEL_HIGH>;
+ iommus = <&smmu 5>;
+ resets = <&rst SDMMC_RESET>, <&rst COMBOPHY_RESET>,
+ <&rst SDMMC_OCP_RESET>;
+ reset-names = "sdhc-reset", "combophy", "sdmmc-ocp";
+
+ status = "disabled";
+ };
+
nand: nand-controller@10b80000 {
compatible = "cdns,hp-nfc";
reg = <0x10b80000 0x10000>,
diff --git a/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk.dts b/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk.dts
index 57d3c5807c65..f37038066922 100644
--- a/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk.dts
+++ b/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk.dts
@@ -36,9 +36,37 @@ memory@80000000 {
/* We expect the bootloader to fill in the reg */
reg = <0x0 0x80000000 0x0 0x0>;
};
+
+ vqmmc_io_reg: regulator-1p8v {
+ compatible = "regulator-gpio";
+ gpios = <&portb 3 GPIO_ACTIVE_HIGH>;
+ gpios-states = <0>;
+ regulator-max-microvolt = <3300000>;
+ regulator-min-microvolt = <1800000>;
+ regulator-name = "vqmmc-io";
+ states = <1800000 0x1>,
+ <3300000 0x0>;
+ };
+
+ vmmc_reg: regulator-fixed-3p3v {
+ compatible = "regulator-fixed";
+ regulator-always-on;
+ regulator-max-microvolt = <3300000>;
+ regulator-min-microvolt = <3300000>;
+ regulator-name = "vcc-sd";
+ };
};
-&gpio0 {
+&emmc {
+ bus-width = <4>;
+ cap-sd-highspeed;
+ disable-wp;
+ max-frequency = <200000000>;
+ no-mmc;
+ sd-uhs-sdr104;
+ vmmc-supply = <&vmmc_reg>;
+ vqmmc-supply = <&vqmmc_io_reg>;
+
status = "okay";
};
@@ -59,6 +87,10 @@ emac2_phy0: ethernet-phy@0 {
};
};
+&gpio0 {
+ status = "okay";
+};
+
&gpio1 {
status = "okay";
};
@@ -100,6 +132,10 @@ root: partition@4200000 {
};
};
+&smmu {
+ status = "okay";
+};
+
&uart0 {
status = "okay";
};
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* [PATCH v3 3/8] dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
2026-07-24 14:50 ` [PATCH v3 2/8] arm64: dts: agilex5: add SD/eMMC host controller Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-07-24 16:51 ` Conor Dooley
2026-07-24 14:50 ` [PATCH v3 4/8] arm64: dts: agilex5: add SOCDK eMMC daughter board Tanmay Kathpalia
` (6 subsequent siblings)
8 siblings, 1 reply; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
Document the Agilex5 SoCDK with the eMMC daughter card, which uses the
shared HPS SD/eMMC host for onboard eMMC instead of an SD slot.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
Documentation/devicetree/bindings/arm/altera.yaml | 1 +
1 file changed, 1 insertion(+)
diff --git a/Documentation/devicetree/bindings/arm/altera.yaml b/Documentation/devicetree/bindings/arm/altera.yaml
index 0b418d9d60db..ce3a8c1679e5 100644
--- a/Documentation/devicetree/bindings/arm/altera.yaml
+++ b/Documentation/devicetree/bindings/arm/altera.yaml
@@ -112,6 +112,7 @@ properties:
- intel,socfpga-agilex5-socdk
- intel,socfpga-agilex5-socdk-013b
- intel,socfpga-agilex5-socdk-debug
+ - intel,socfpga-agilex5-socdk-emmc
- intel,socfpga-agilex5-socdk-modular
- intel,socfpga-agilex5-socdk-nand
- const: intel,socfpga-agilex5
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [PATCH v3 3/8] dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant
2026-07-24 14:50 ` [PATCH v3 3/8] dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant Tanmay Kathpalia
@ 2026-07-24 16:51 ` Conor Dooley
0 siblings, 0 replies; 17+ messages in thread
From: Conor Dooley @ 2026-07-24 16:51 UTC (permalink / raw)
To: Tanmay Kathpalia
Cc: linux-mmc, ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen,
p.zabel, devicetree, linux-kernel
[-- Attachment #1: Type: text/plain, Size: 75 bytes --]
Acked-by: Conor Dooley <conor.dooley@microchip.com>
pw-bot: not-applicable
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH v3 4/8] arm64: dts: agilex5: add SOCDK eMMC daughter board
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
2026-07-24 14:50 ` [PATCH v3 2/8] arm64: dts: agilex5: add SD/eMMC host controller Tanmay Kathpalia
2026-07-24 14:50 ` [PATCH v3 3/8] dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-07-24 14:50 ` [PATCH v3 5/8] mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork Tanmay Kathpalia
` (5 subsequent siblings)
8 siblings, 0 replies; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
The Agilex5 SoCDK eMMC daughter card wires the shared HPS SD6HC to an
8-bit onboard eMMC with fixed 3.3 V VCC and 1.8 V I/O, supporting HS200
and HS400. The board also brings up GMAC0, I2C, I3C, LEDs, UART, and
the SMMU for DMA.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
arch/arm64/boot/dts/intel/Makefile | 1 +
.../dts/intel/socfpga_agilex5_socdk_emmc.dts | 127 ++++++++++++++++++
2 files changed, 128 insertions(+)
create mode 100644 arch/arm64/boot/dts/intel/socfpga_agilex5_socdk_emmc.dts
diff --git a/arch/arm64/boot/dts/intel/Makefile b/arch/arm64/boot/dts/intel/Makefile
index 088a03b89c99..add2b91f5972 100644
--- a/arch/arm64/boot/dts/intel/Makefile
+++ b/arch/arm64/boot/dts/intel/Makefile
@@ -6,6 +6,7 @@ dtb-$(CONFIG_ARCH_INTEL_SOCFPGA) += socfpga_agilex_n6000.dtb \
socfpga_agilex3_socdk.dtb \
socfpga_agilex5_socdk.dtb \
socfpga_agilex5_socdk_013b.dtb \
+ socfpga_agilex5_socdk_emmc.dtb \
socfpga_agilex5_socdk_modular.dtb \
socfpga_agilex5_socdk_nand.dtb \
socfpga_agilex7m_socdk.dtb \
diff --git a/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk_emmc.dts b/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk_emmc.dts
new file mode 100644
index 000000000000..0ace9f7e0330
--- /dev/null
+++ b/arch/arm64/boot/dts/intel/socfpga_agilex5_socdk_emmc.dts
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2026, Altera Corporation
+ */
+#include "socfpga_agilex5.dtsi"
+
+/ {
+ model = "SoCFPGA Agilex5 SoCDK eMMC daughter board";
+ compatible = "intel,socfpga-agilex5-socdk-emmc", "intel,socfpga-agilex5";
+
+ aliases {
+ ethernet0 = &gmac0;
+ i3c0 = &i3c0;
+ i3c1 = &i3c1;
+ serial0 = &uart0;
+ };
+
+ chosen {
+ stdout-path = "serial0:115200n8";
+ };
+
+ leds {
+ compatible = "gpio-leds";
+
+ led-0 {
+ label = "hps_led0";
+ gpios = <&porta 6 GPIO_ACTIVE_HIGH>;
+ };
+
+ led-1 {
+ label = "hps_led1";
+ gpios = <&porta 7 GPIO_ACTIVE_HIGH>;
+ };
+ };
+
+ memory@80000000 {
+ device_type = "memory";
+ /* Expect the bootloader to fill in the reg */
+ reg = <0x0 0x80000000 0x0 0x0>;
+ };
+
+ vqmmc_io_reg: regulator-fixed-1p8v {
+ compatible = "regulator-fixed";
+ regulator-always-on;
+ regulator-max-microvolt = <1800000>;
+ regulator-min-microvolt = <1800000>;
+ regulator-name = "vqmmc-io";
+ };
+
+ vmmc_reg: regulator-fixed-3p3v {
+ compatible = "regulator-fixed";
+ regulator-always-on;
+ regulator-max-microvolt = <3300000>;
+ regulator-min-microvolt = <3300000>;
+ regulator-name = "vcc-emmc";
+ };
+};
+
+&emmc {
+ bus-width = <8>;
+ cap-mmc-highspeed;
+ disable-wp;
+ max-frequency = <200000000>;
+ mmc-hs200-1_8v;
+ mmc-hs400-1_8v;
+ no-sd;
+ no-sdio;
+ non-removable;
+ vmmc-supply = <&vmmc_reg>;
+ vqmmc-supply = <&vqmmc_io_reg>;
+
+ status = "okay";
+};
+
+&gmac0 {
+ max-frame-size = <9000>;
+ phy-handle = <&emac0_phy0>;
+ phy-mode = "rgmii"; /* TX/RX clock delays provided by Agilex5 I/O hardware */
+
+ status = "okay";
+
+ mdio0 {
+ compatible = "snps,dwmac-mdio";
+ #address-cells = <1>;
+ #size-cells = <0>;
+
+ emac0_phy0: ethernet-phy@0 {
+ reg = <0>;
+ };
+ };
+};
+
+&gpio0 {
+ status = "okay";
+};
+
+&gpio1 {
+ status = "okay";
+};
+
+&i2c0 {
+ status = "okay";
+};
+
+&i3c0 {
+ status = "okay";
+};
+
+&i3c1 {
+ status = "okay";
+};
+
+&osc1 {
+ clock-frequency = <25000000>;
+};
+
+&smmu {
+ status = "okay";
+};
+
+&uart0 {
+ status = "okay";
+};
+
+&watchdog0 {
+ status = "okay";
+};
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* [PATCH v3 5/8] mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (2 preceding siblings ...)
2026-07-24 14:50 ` [PATCH v3 4/8] arm64: dts: agilex5: add SOCDK eMMC daughter board Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-08-07 12:14 ` Adrian Hunter
2026-07-24 14:50 ` [PATCH v3 6/8] mmc: sdhci-cadence: refactor driver structure for V6 controller support Tanmay Kathpalia
` (4 subsequent siblings)
8 siblings, 1 reply; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
SD4HC PHY helpers and the default ops/drv_data are not marked as
version-specific, so it is unclear what is shared versus SD4HC-only
ahead of SD6HC support.
Rename those symbols with a cdns4 prefix to separate the SD4HC paths
from the shared driver core and avoid clashes when SD6HC is added.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
drivers/mmc/host/sdhci-cadence.c | 55 +++++++++++++++-----------------
1 file changed, 26 insertions(+), 29 deletions(-)
diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence.c
index 435603c8c00b..8a6ef6d9d1dd 100644
--- a/drivers/mmc/host/sdhci-cadence.c
+++ b/drivers/mmc/host/sdhci-cadence.c
@@ -78,7 +78,7 @@
*/
#define SDHCI_CDNS_MAX_TUNING_LOOP 40
-struct sdhci_cdns_phy_param {
+struct sdhci_cdns4_phy_param {
u8 addr;
u8 data;
};
@@ -91,10 +91,10 @@ struct sdhci_cdns_priv {
void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
struct reset_control *rst_hw;
unsigned int nr_phy_params;
- struct sdhci_cdns_phy_param phy_params[];
+ struct sdhci_cdns4_phy_param phy_params[];
};
-struct sdhci_cdns_phy_cfg {
+struct sdhci_cdns4_phy_cfg {
const char *property;
u8 addr;
};
@@ -104,7 +104,7 @@ struct sdhci_cdns_drv_data {
const struct sdhci_pltfm_data pltfm_data;
};
-static const struct sdhci_cdns_phy_cfg sdhci_cdns_phy_cfgs[] = {
+static const struct sdhci_cdns4_phy_cfg sdhci_cdns4_phy_cfgs[] = {
{ "cdns,phy-input-delay-sd-highspeed", SDHCI_CDNS_PHY_DLY_SD_HS, },
{ "cdns,phy-input-delay-legacy", SDHCI_CDNS_PHY_DLY_SD_DEFAULT, },
{ "cdns,phy-input-delay-sd-uhs-sdr12", SDHCI_CDNS_PHY_DLY_UHS_SDR12, },
@@ -124,8 +124,7 @@ static inline void cdns_writel(struct sdhci_cdns_priv *priv, u32 val,
writel(val, reg);
}
-static int sdhci_cdns_write_phy_reg(struct sdhci_cdns_priv *priv,
- u8 addr, u8 data)
+static int sdhci_cdns4_write_phy_reg(struct sdhci_cdns_priv *priv, u8 addr, u8 data)
{
void __iomem *reg = priv->hrs_addr + SDHCI_CDNS_HRS04;
u32 tmp;
@@ -156,44 +155,42 @@ static int sdhci_cdns_write_phy_reg(struct sdhci_cdns_priv *priv,
return ret;
}
-static unsigned int sdhci_cdns_phy_param_count(struct device_node *np)
+static unsigned int sdhci_cdns4_phy_param_count(struct device_node *np)
{
unsigned int count = 0;
int i;
- for (i = 0; i < ARRAY_SIZE(sdhci_cdns_phy_cfgs); i++)
- if (of_property_present(np, sdhci_cdns_phy_cfgs[i].property))
+ for (i = 0; i < ARRAY_SIZE(sdhci_cdns4_phy_cfgs); i++)
+ if (of_property_present(np, sdhci_cdns4_phy_cfgs[i].property))
count++;
return count;
}
-static void sdhci_cdns_phy_param_parse(struct device_node *np,
- struct sdhci_cdns_priv *priv)
+static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns_priv *priv)
{
- struct sdhci_cdns_phy_param *p = priv->phy_params;
+ struct sdhci_cdns4_phy_param *p = priv->phy_params;
u32 val;
int ret, i;
- for (i = 0; i < ARRAY_SIZE(sdhci_cdns_phy_cfgs); i++) {
- ret = of_property_read_u32(np, sdhci_cdns_phy_cfgs[i].property,
- &val);
+ for (i = 0; i < ARRAY_SIZE(sdhci_cdns4_phy_cfgs); i++) {
+ ret = of_property_read_u32(np, sdhci_cdns4_phy_cfgs[i].property, &val);
if (ret)
continue;
- p->addr = sdhci_cdns_phy_cfgs[i].addr;
+ p->addr = sdhci_cdns4_phy_cfgs[i].addr;
p->data = val;
p++;
}
}
-static int sdhci_cdns_phy_init(struct sdhci_cdns_priv *priv)
+static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
{
int ret, i;
for (i = 0; i < priv->nr_phy_params; i++) {
- ret = sdhci_cdns_write_phy_reg(priv, priv->phy_params[i].addr,
- priv->phy_params[i].data);
+ ret = sdhci_cdns4_write_phy_reg(priv, priv->phy_params[i].addr,
+ priv->phy_params[i].data);
if (ret)
return ret;
}
@@ -470,7 +467,7 @@ static int elba_drv_init(struct platform_device *pdev)
return 0;
}
-static const struct sdhci_ops sdhci_cdns_ops = {
+static const struct sdhci_ops sdhci_cdns4_ops = {
.set_clock = sdhci_set_clock,
.get_timeout_clock = sdhci_cdns_get_timeout_clock,
.set_bus_width = sdhci_set_bus_width,
@@ -481,7 +478,7 @@ static const struct sdhci_ops sdhci_cdns_ops = {
static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
.pltfm_data = {
- .ops = &sdhci_cdns_ops,
+ .ops = &sdhci_cdns4_ops,
.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
},
};
@@ -495,14 +492,14 @@ static const struct sdhci_cdns_drv_data sdhci_elba_drv_data = {
static const struct sdhci_cdns_drv_data sdhci_eyeq_drv_data = {
.pltfm_data = {
- .ops = &sdhci_cdns_ops,
+ .ops = &sdhci_cdns4_ops,
.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
},
};
-static const struct sdhci_cdns_drv_data sdhci_cdns_drv_data = {
+static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
.pltfm_data = {
- .ops = &sdhci_cdns_ops,
+ .ops = &sdhci_cdns4_ops,
},
};
@@ -560,9 +557,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
data = of_device_get_match_data(dev);
if (!data)
- data = &sdhci_cdns_drv_data;
+ data = &sdhci_cdns4_drv_data;
- nr_phy_params = sdhci_cdns_phy_param_count(dev->of_node);
+ nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
host = sdhci_pltfm_init(pdev, &data->pltfm_data,
struct_size(priv, phy_params, nr_phy_params));
if (IS_ERR(host))
@@ -593,9 +590,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
if (ret)
return ret;
- sdhci_cdns_phy_param_parse(dev->of_node, priv);
+ sdhci_cdns4_phy_param_parse(dev->of_node, priv);
- ret = sdhci_cdns_phy_init(priv);
+ ret = sdhci_cdns4_phy_init(priv);
if (ret)
return ret;
@@ -622,7 +619,7 @@ static int sdhci_cdns_resume(struct device *dev)
if (ret)
return ret;
- ret = sdhci_cdns_phy_init(priv);
+ ret = sdhci_cdns4_phy_init(priv);
if (ret)
goto disable_clk;
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [PATCH v3 5/8] mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork
2026-07-24 14:50 ` [PATCH v3 5/8] mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork Tanmay Kathpalia
@ 2026-08-07 12:14 ` Adrian Hunter
0 siblings, 0 replies; 17+ messages in thread
From: Adrian Hunter @ 2026-08-07 12:14 UTC (permalink / raw)
To: Tanmay Kathpalia, linux-mmc
Cc: ulfh, krzk+dt, robh, conor+dt, dinguyen, p.zabel, devicetree,
linux-kernel
On 24/07/2026 17:50, Tanmay Kathpalia wrote:
> SD4HC PHY helpers and the default ops/drv_data are not marked as
> version-specific, so it is unclear what is shared versus SD4HC-only
> ahead of SD6HC support.
>
> Rename those symbols with a cdns4 prefix to separate the SD4HC paths
> from the shared driver core and avoid clashes when SD6HC is added.
>
> Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
Acked-by: Adrian Hunter <adrian.hunter@intel.com>
> ---
> drivers/mmc/host/sdhci-cadence.c | 55 +++++++++++++++-----------------
> 1 file changed, 26 insertions(+), 29 deletions(-)
>
> diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence.c
> index 435603c8c00b..8a6ef6d9d1dd 100644
> --- a/drivers/mmc/host/sdhci-cadence.c
> +++ b/drivers/mmc/host/sdhci-cadence.c
> @@ -78,7 +78,7 @@
> */
> #define SDHCI_CDNS_MAX_TUNING_LOOP 40
>
> -struct sdhci_cdns_phy_param {
> +struct sdhci_cdns4_phy_param {
> u8 addr;
> u8 data;
> };
> @@ -91,10 +91,10 @@ struct sdhci_cdns_priv {
> void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
> struct reset_control *rst_hw;
> unsigned int nr_phy_params;
> - struct sdhci_cdns_phy_param phy_params[];
> + struct sdhci_cdns4_phy_param phy_params[];
> };
>
> -struct sdhci_cdns_phy_cfg {
> +struct sdhci_cdns4_phy_cfg {
> const char *property;
> u8 addr;
> };
> @@ -104,7 +104,7 @@ struct sdhci_cdns_drv_data {
> const struct sdhci_pltfm_data pltfm_data;
> };
>
> -static const struct sdhci_cdns_phy_cfg sdhci_cdns_phy_cfgs[] = {
> +static const struct sdhci_cdns4_phy_cfg sdhci_cdns4_phy_cfgs[] = {
> { "cdns,phy-input-delay-sd-highspeed", SDHCI_CDNS_PHY_DLY_SD_HS, },
> { "cdns,phy-input-delay-legacy", SDHCI_CDNS_PHY_DLY_SD_DEFAULT, },
> { "cdns,phy-input-delay-sd-uhs-sdr12", SDHCI_CDNS_PHY_DLY_UHS_SDR12, },
> @@ -124,8 +124,7 @@ static inline void cdns_writel(struct sdhci_cdns_priv *priv, u32 val,
> writel(val, reg);
> }
>
> -static int sdhci_cdns_write_phy_reg(struct sdhci_cdns_priv *priv,
> - u8 addr, u8 data)
> +static int sdhci_cdns4_write_phy_reg(struct sdhci_cdns_priv *priv, u8 addr, u8 data)
> {
> void __iomem *reg = priv->hrs_addr + SDHCI_CDNS_HRS04;
> u32 tmp;
> @@ -156,44 +155,42 @@ static int sdhci_cdns_write_phy_reg(struct sdhci_cdns_priv *priv,
> return ret;
> }
>
> -static unsigned int sdhci_cdns_phy_param_count(struct device_node *np)
> +static unsigned int sdhci_cdns4_phy_param_count(struct device_node *np)
> {
> unsigned int count = 0;
> int i;
>
> - for (i = 0; i < ARRAY_SIZE(sdhci_cdns_phy_cfgs); i++)
> - if (of_property_present(np, sdhci_cdns_phy_cfgs[i].property))
> + for (i = 0; i < ARRAY_SIZE(sdhci_cdns4_phy_cfgs); i++)
> + if (of_property_present(np, sdhci_cdns4_phy_cfgs[i].property))
> count++;
>
> return count;
> }
>
> -static void sdhci_cdns_phy_param_parse(struct device_node *np,
> - struct sdhci_cdns_priv *priv)
> +static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns_priv *priv)
> {
> - struct sdhci_cdns_phy_param *p = priv->phy_params;
> + struct sdhci_cdns4_phy_param *p = priv->phy_params;
> u32 val;
> int ret, i;
>
> - for (i = 0; i < ARRAY_SIZE(sdhci_cdns_phy_cfgs); i++) {
> - ret = of_property_read_u32(np, sdhci_cdns_phy_cfgs[i].property,
> - &val);
> + for (i = 0; i < ARRAY_SIZE(sdhci_cdns4_phy_cfgs); i++) {
> + ret = of_property_read_u32(np, sdhci_cdns4_phy_cfgs[i].property, &val);
> if (ret)
> continue;
>
> - p->addr = sdhci_cdns_phy_cfgs[i].addr;
> + p->addr = sdhci_cdns4_phy_cfgs[i].addr;
> p->data = val;
> p++;
> }
> }
>
> -static int sdhci_cdns_phy_init(struct sdhci_cdns_priv *priv)
> +static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
> {
> int ret, i;
>
> for (i = 0; i < priv->nr_phy_params; i++) {
> - ret = sdhci_cdns_write_phy_reg(priv, priv->phy_params[i].addr,
> - priv->phy_params[i].data);
> + ret = sdhci_cdns4_write_phy_reg(priv, priv->phy_params[i].addr,
> + priv->phy_params[i].data);
> if (ret)
> return ret;
> }
> @@ -470,7 +467,7 @@ static int elba_drv_init(struct platform_device *pdev)
> return 0;
> }
>
> -static const struct sdhci_ops sdhci_cdns_ops = {
> +static const struct sdhci_ops sdhci_cdns4_ops = {
> .set_clock = sdhci_set_clock,
> .get_timeout_clock = sdhci_cdns_get_timeout_clock,
> .set_bus_width = sdhci_set_bus_width,
> @@ -481,7 +478,7 @@ static const struct sdhci_ops sdhci_cdns_ops = {
>
> static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
> .pltfm_data = {
> - .ops = &sdhci_cdns_ops,
> + .ops = &sdhci_cdns4_ops,
> .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
> },
> };
> @@ -495,14 +492,14 @@ static const struct sdhci_cdns_drv_data sdhci_elba_drv_data = {
>
> static const struct sdhci_cdns_drv_data sdhci_eyeq_drv_data = {
> .pltfm_data = {
> - .ops = &sdhci_cdns_ops,
> + .ops = &sdhci_cdns4_ops,
> .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
> },
> };
>
> -static const struct sdhci_cdns_drv_data sdhci_cdns_drv_data = {
> +static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
> .pltfm_data = {
> - .ops = &sdhci_cdns_ops,
> + .ops = &sdhci_cdns4_ops,
> },
> };
>
> @@ -560,9 +557,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
>
> data = of_device_get_match_data(dev);
> if (!data)
> - data = &sdhci_cdns_drv_data;
> + data = &sdhci_cdns4_drv_data;
>
> - nr_phy_params = sdhci_cdns_phy_param_count(dev->of_node);
> + nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
> host = sdhci_pltfm_init(pdev, &data->pltfm_data,
> struct_size(priv, phy_params, nr_phy_params));
> if (IS_ERR(host))
> @@ -593,9 +590,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> if (ret)
> return ret;
>
> - sdhci_cdns_phy_param_parse(dev->of_node, priv);
> + sdhci_cdns4_phy_param_parse(dev->of_node, priv);
>
> - ret = sdhci_cdns_phy_init(priv);
> + ret = sdhci_cdns4_phy_init(priv);
> if (ret)
> return ret;
>
> @@ -622,7 +619,7 @@ static int sdhci_cdns_resume(struct device *dev)
> if (ret)
> return ret;
>
> - ret = sdhci_cdns_phy_init(priv);
> + ret = sdhci_cdns4_phy_init(priv);
> if (ret)
> goto disable_clk;
>
^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH v3 6/8] mmc: sdhci-cadence: refactor driver structure for V6 controller support
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (3 preceding siblings ...)
2026-07-24 14:50 ` [PATCH v3 5/8] mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-08-07 12:15 ` Adrian Hunter
2026-07-24 14:50 ` [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support Tanmay Kathpalia
` (3 subsequent siblings)
8 siblings, 1 reply; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
Refactor the sdhci-cadence driver in preparation for adding SD6HC (V6
controller) support. Separate PHY parameter handling into a dedicated
sdhci_cdns4_phy structure and move PHY initialization logic into a
dedicated sdhci_cdns4_phy_probe() function. This allows different
controller versions to manage their PHY configurations independently
while keeping shared logic in the main driver.
Each compatible entry now carries its own driver data, so drop the
silent fallback to sdhci_cdns4_drv_data and return an error if platform
data is missing.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
drivers/mmc/host/sdhci-cadence.c | 54 ++++++++++++++++++++++----------
1 file changed, 37 insertions(+), 17 deletions(-)
diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence.c
index 8a6ef6d9d1dd..1fb23051a047 100644
--- a/drivers/mmc/host/sdhci-cadence.c
+++ b/drivers/mmc/host/sdhci-cadence.c
@@ -83,6 +83,11 @@ struct sdhci_cdns4_phy_param {
u8 data;
};
+struct sdhci_cdns4_phy {
+ unsigned int nr_phy_params;
+ struct sdhci_cdns4_phy_param phy_params[];
+};
+
struct sdhci_cdns_priv {
void __iomem *hrs_addr;
void __iomem *ctl_addr; /* write control */
@@ -90,8 +95,7 @@ struct sdhci_cdns_priv {
bool enhanced_strobe;
void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
struct reset_control *rst_hw;
- unsigned int nr_phy_params;
- struct sdhci_cdns4_phy_param phy_params[];
+ struct sdhci_cdns4_phy *phy;
};
struct sdhci_cdns4_phy_cfg {
@@ -167,9 +171,9 @@ static unsigned int sdhci_cdns4_phy_param_count(struct device_node *np)
return count;
}
-static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns_priv *priv)
+static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns4_phy *phy)
{
- struct sdhci_cdns4_phy_param *p = priv->phy_params;
+ struct sdhci_cdns4_phy_param *p = phy->phy_params;
u32 val;
int ret, i;
@@ -186,11 +190,12 @@ static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdn
static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
{
+ struct sdhci_cdns4_phy *phy = priv->phy;
int ret, i;
- for (i = 0; i < priv->nr_phy_params; i++) {
- ret = sdhci_cdns4_write_phy_reg(priv, priv->phy_params[i].addr,
- priv->phy_params[i].data);
+ for (i = 0; i < phy->nr_phy_params; i++) {
+ ret = sdhci_cdns4_write_phy_reg(priv, phy->phy_params[i].addr,
+ phy->phy_params[i].data);
if (ret)
return ret;
}
@@ -539,6 +544,24 @@ static void sdhci_cdns_mmc_hw_reset(struct mmc_host *mmc)
usleep_range(300, 1000);
}
+static int sdhci_cdns4_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv)
+{
+ struct device *dev = &pdev->dev;
+ struct sdhci_cdns4_phy *phy;
+ unsigned int nr_phy_params;
+
+ nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
+ phy = devm_kzalloc(dev, struct_size(phy, phy_params, nr_phy_params), GFP_KERNEL);
+ if (!phy)
+ return -ENOMEM;
+
+ phy->nr_phy_params = nr_phy_params;
+ sdhci_cdns4_phy_param_parse(dev->of_node, phy);
+ priv->phy = phy;
+
+ return sdhci_cdns4_phy_init(priv);
+}
+
static int sdhci_cdns_probe(struct platform_device *pdev)
{
struct sdhci_host *host;
@@ -546,7 +569,6 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_cdns_priv *priv;
struct clk *clk;
- unsigned int nr_phy_params;
int ret;
struct device *dev = &pdev->dev;
static const u16 version = SDHCI_SPEC_400 << SDHCI_SPEC_VER_SHIFT;
@@ -557,11 +579,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
data = of_device_get_match_data(dev);
if (!data)
- data = &sdhci_cdns4_drv_data;
+ return dev_err_probe(dev, -EINVAL, "missing platform driver data\n");
- nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
- host = sdhci_pltfm_init(pdev, &data->pltfm_data,
- struct_size(priv, phy_params, nr_phy_params));
+ host = sdhci_pltfm_init(pdev, &data->pltfm_data, sizeof(*priv));
if (IS_ERR(host))
return PTR_ERR(host);
@@ -569,7 +589,6 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
pltfm_host->clk = clk;
priv = sdhci_pltfm_priv(pltfm_host);
- priv->nr_phy_params = nr_phy_params;
priv->hrs_addr = host->ioaddr;
priv->enhanced_strobe = false;
priv->priv_writel = cdns_writel;
@@ -590,9 +609,7 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
if (ret)
return ret;
- sdhci_cdns4_phy_param_parse(dev->of_node, priv);
-
- ret = sdhci_cdns4_phy_init(priv);
+ ret = sdhci_cdns4_phy_probe(pdev, priv);
if (ret)
return ret;
@@ -650,7 +667,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
.compatible = "mobileye,eyeq-sd4hc",
.data = &sdhci_eyeq_drv_data,
},
- { .compatible = "cdns,sd4hc" },
+ {
+ .compatible = "cdns,sd4hc",
+ .data = &sdhci_cdns4_drv_data,
+ },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, sdhci_cdns_match);
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [PATCH v3 6/8] mmc: sdhci-cadence: refactor driver structure for V6 controller support
2026-07-24 14:50 ` [PATCH v3 6/8] mmc: sdhci-cadence: refactor driver structure for V6 controller support Tanmay Kathpalia
@ 2026-08-07 12:15 ` Adrian Hunter
0 siblings, 0 replies; 17+ messages in thread
From: Adrian Hunter @ 2026-08-07 12:15 UTC (permalink / raw)
To: Tanmay Kathpalia, linux-mmc
Cc: ulfh, krzk+dt, robh, conor+dt, dinguyen, p.zabel, devicetree,
linux-kernel
On 24/07/2026 17:50, Tanmay Kathpalia wrote:
> Refactor the sdhci-cadence driver in preparation for adding SD6HC (V6
> controller) support. Separate PHY parameter handling into a dedicated
> sdhci_cdns4_phy structure and move PHY initialization logic into a
> dedicated sdhci_cdns4_phy_probe() function. This allows different
> controller versions to manage their PHY configurations independently
> while keeping shared logic in the main driver.
>
> Each compatible entry now carries its own driver data, so drop the
> silent fallback to sdhci_cdns4_drv_data and return an error if platform
> data is missing.
>
> Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
Acked-by: Adrian Hunter <adrian.hunter@intel.com>
> ---
> drivers/mmc/host/sdhci-cadence.c | 54 ++++++++++++++++++++++----------
> 1 file changed, 37 insertions(+), 17 deletions(-)
>
> diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence.c
> index 8a6ef6d9d1dd..1fb23051a047 100644
> --- a/drivers/mmc/host/sdhci-cadence.c
> +++ b/drivers/mmc/host/sdhci-cadence.c
> @@ -83,6 +83,11 @@ struct sdhci_cdns4_phy_param {
> u8 data;
> };
>
> +struct sdhci_cdns4_phy {
> + unsigned int nr_phy_params;
> + struct sdhci_cdns4_phy_param phy_params[];
> +};
> +
> struct sdhci_cdns_priv {
> void __iomem *hrs_addr;
> void __iomem *ctl_addr; /* write control */
> @@ -90,8 +95,7 @@ struct sdhci_cdns_priv {
> bool enhanced_strobe;
> void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
> struct reset_control *rst_hw;
> - unsigned int nr_phy_params;
> - struct sdhci_cdns4_phy_param phy_params[];
> + struct sdhci_cdns4_phy *phy;
> };
>
> struct sdhci_cdns4_phy_cfg {
> @@ -167,9 +171,9 @@ static unsigned int sdhci_cdns4_phy_param_count(struct device_node *np)
> return count;
> }
>
> -static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns_priv *priv)
> +static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdns4_phy *phy)
> {
> - struct sdhci_cdns4_phy_param *p = priv->phy_params;
> + struct sdhci_cdns4_phy_param *p = phy->phy_params;
> u32 val;
> int ret, i;
>
> @@ -186,11 +190,12 @@ static void sdhci_cdns4_phy_param_parse(struct device_node *np, struct sdhci_cdn
>
> static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
> {
> + struct sdhci_cdns4_phy *phy = priv->phy;
> int ret, i;
>
> - for (i = 0; i < priv->nr_phy_params; i++) {
> - ret = sdhci_cdns4_write_phy_reg(priv, priv->phy_params[i].addr,
> - priv->phy_params[i].data);
> + for (i = 0; i < phy->nr_phy_params; i++) {
> + ret = sdhci_cdns4_write_phy_reg(priv, phy->phy_params[i].addr,
> + phy->phy_params[i].data);
> if (ret)
> return ret;
> }
> @@ -539,6 +544,24 @@ static void sdhci_cdns_mmc_hw_reset(struct mmc_host *mmc)
> usleep_range(300, 1000);
> }
>
> +static int sdhci_cdns4_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv)
> +{
> + struct device *dev = &pdev->dev;
> + struct sdhci_cdns4_phy *phy;
> + unsigned int nr_phy_params;
> +
> + nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
> + phy = devm_kzalloc(dev, struct_size(phy, phy_params, nr_phy_params), GFP_KERNEL);
> + if (!phy)
> + return -ENOMEM;
> +
> + phy->nr_phy_params = nr_phy_params;
> + sdhci_cdns4_phy_param_parse(dev->of_node, phy);
> + priv->phy = phy;
> +
> + return sdhci_cdns4_phy_init(priv);
> +}
> +
> static int sdhci_cdns_probe(struct platform_device *pdev)
> {
> struct sdhci_host *host;
> @@ -546,7 +569,6 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> struct sdhci_pltfm_host *pltfm_host;
> struct sdhci_cdns_priv *priv;
> struct clk *clk;
> - unsigned int nr_phy_params;
> int ret;
> struct device *dev = &pdev->dev;
> static const u16 version = SDHCI_SPEC_400 << SDHCI_SPEC_VER_SHIFT;
> @@ -557,11 +579,9 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
>
> data = of_device_get_match_data(dev);
> if (!data)
> - data = &sdhci_cdns4_drv_data;
> + return dev_err_probe(dev, -EINVAL, "missing platform driver data\n");
>
> - nr_phy_params = sdhci_cdns4_phy_param_count(dev->of_node);
> - host = sdhci_pltfm_init(pdev, &data->pltfm_data,
> - struct_size(priv, phy_params, nr_phy_params));
> + host = sdhci_pltfm_init(pdev, &data->pltfm_data, sizeof(*priv));
> if (IS_ERR(host))
> return PTR_ERR(host);
>
> @@ -569,7 +589,6 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> pltfm_host->clk = clk;
>
> priv = sdhci_pltfm_priv(pltfm_host);
> - priv->nr_phy_params = nr_phy_params;
> priv->hrs_addr = host->ioaddr;
> priv->enhanced_strobe = false;
> priv->priv_writel = cdns_writel;
> @@ -590,9 +609,7 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> if (ret)
> return ret;
>
> - sdhci_cdns4_phy_param_parse(dev->of_node, priv);
> -
> - ret = sdhci_cdns4_phy_init(priv);
> + ret = sdhci_cdns4_phy_probe(pdev, priv);
> if (ret)
> return ret;
>
> @@ -650,7 +667,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
> .compatible = "mobileye,eyeq-sd4hc",
> .data = &sdhci_eyeq_drv_data,
> },
> - { .compatible = "cdns,sd4hc" },
> + {
> + .compatible = "cdns,sd4hc",
> + .data = &sdhci_cdns4_drv_data,
> + },
> { /* sentinel */ }
> };
> MODULE_DEVICE_TABLE(of, sdhci_cdns_match);
^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (4 preceding siblings ...)
2026-07-24 14:50 ` [PATCH v3 6/8] mmc: sdhci-cadence: refactor driver structure for V6 controller support Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-07-24 15:20 ` sashiko-bot
2026-08-07 12:40 ` Adrian Hunter
2026-07-24 14:50 ` [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 " Tanmay Kathpalia
` (2 subsequent siblings)
8 siblings, 2 replies; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
The Cadence SD6HC is a sixth-generation SD/SDIO/eMMC host controller
with an integrated combo-PHY. PHY timing depends on the active speed
mode, the SD clock period, and board-level IO-cell and DLL delay-
element characteristics.
SD6HC provides separate card-interface (CIU) and bus-interface (BIU)
clocks, and asserts eMMC hardware reset through an internal controller
register rather than an external RST_n line. The "cdns,sd6hc" compatible
string identifies this IP in device tree.
Split the existing driver into sdhci-cadence-core.c and
sdhci-cadence-phy-v6.c, and add sdhci-cadence.h for shared private
state.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
MAINTAINERS | 7 +
drivers/mmc/host/Makefile | 1 +
.../{sdhci-cadence.c => sdhci-cadence-core.c} | 122 ++-
drivers/mmc/host/sdhci-cadence-phy-v6.c | 929 ++++++++++++++++++
drivers/mmc/host/sdhci-cadence.h | 111 +++
5 files changed, 1130 insertions(+), 40 deletions(-)
rename drivers/mmc/host/{sdhci-cadence.c => sdhci-cadence-core.c} (86%)
create mode 100644 drivers/mmc/host/sdhci-cadence-phy-v6.c
create mode 100644 drivers/mmc/host/sdhci-cadence.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 6a0996faa091..58267c681780 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -24407,6 +24407,13 @@ L: linux-mmc@vger.kernel.org
S: Maintained
F: drivers/mmc/host/sdhci-brcmstb*
+SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) CADENCE DRIVER
+M: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
+L: linux-mmc@vger.kernel.org
+S: Supported
+F: Documentation/devicetree/bindings/mmc/cdns,sd6hc.yaml
+F: drivers/mmc/host/sdhci-cadence*
+
SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) DRIVER
M: Adrian Hunter <adrian.hunter@intel.com>
L: linux-mmc@vger.kernel.org
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index ee412e6b84d6..799ce7ad43d5 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -80,6 +80,7 @@ obj-$(CONFIG_MMC_REALTEK_USB) += rtsx_usb_sdmmc.o
obj-$(CONFIG_MMC_SDHCI_PLTFM) += sdhci-pltfm.o
obj-$(CONFIG_MMC_SDHCI_CADENCE) += sdhci-cadence.o
+sdhci-cadence-y += sdhci-cadence-core.o sdhci-cadence-phy-v6.o
obj-$(CONFIG_MMC_SDHCI_ESDHC_MCF) += sdhci-esdhc-mcf.o
obj-$(CONFIG_MMC_SDHCI_ESDHC_IMX) += sdhci-esdhc-imx.o
obj-$(CONFIG_MMC_SDHCI_DOVE) += sdhci-dove.o
diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence-core.c
similarity index 86%
rename from drivers/mmc/host/sdhci-cadence.c
rename to drivers/mmc/host/sdhci-cadence-core.c
index 1fb23051a047..18846acc0b11 100644
--- a/drivers/mmc/host/sdhci-cadence.c
+++ b/drivers/mmc/host/sdhci-cadence-core.c
@@ -2,6 +2,7 @@
/*
* Copyright (C) 2016 Socionext Inc.
* Author: Masahiro Yamada <yamada.masahiro@socionext.com>
+ * Copyright (C) 2026 Altera Corporation
*/
#include <linux/bitfield.h>
@@ -14,10 +15,10 @@
#include <linux/platform_device.h>
#include <linux/reset.h>
-#include "sdhci-pltfm.h"
+#include "sdhci-cadence.h"
/* HRS - Host Register Set (specific to Cadence) */
-#define SDHCI_CDNS_HRS04 0x10 /* PHY access port */
+/* HRS04 (PHY access) bitfields (SD4HC) */
#define SDHCI_CDNS_HRS04_ACK BIT(26)
#define SDHCI_CDNS_HRS04_RD BIT(25)
#define SDHCI_CDNS_HRS04_WR BIT(24)
@@ -71,13 +72,6 @@
#define SDHCI_CDNS_PHY_DLY_HSMMC 0x0c
#define SDHCI_CDNS_PHY_DLY_STROBE 0x0d
-/*
- * The tuned val register is 6 bit-wide, but not the whole of the range is
- * available. The range 0-42 seems to be available (then 43 wraps around to 0)
- * but I am not quite sure if it is official. Use only 0 to 39 for safety.
- */
-#define SDHCI_CDNS_MAX_TUNING_LOOP 40
-
struct sdhci_cdns4_phy_param {
u8 addr;
u8 data;
@@ -88,16 +82,6 @@ struct sdhci_cdns4_phy {
struct sdhci_cdns4_phy_param phy_params[];
};
-struct sdhci_cdns_priv {
- void __iomem *hrs_addr;
- void __iomem *ctl_addr; /* write control */
- spinlock_t wrlock; /* write lock */
- bool enhanced_strobe;
- void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
- struct reset_control *rst_hw;
- struct sdhci_cdns4_phy *phy;
-};
-
struct sdhci_cdns4_phy_cfg {
const char *property;
u8 addr;
@@ -203,13 +187,6 @@ static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
return 0;
}
-static void *sdhci_cdns_priv(struct sdhci_host *host)
-{
- struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
-
- return sdhci_pltfm_priv(pltfm_host);
-}
-
static unsigned int sdhci_cdns_get_timeout_clock(struct sdhci_host *host)
{
/*
@@ -245,6 +222,9 @@ static int sdhci_cdns_set_tune_val(struct sdhci_host *host, unsigned int val)
u32 tmp;
int i, ret;
+ if (host->version >= SDHCI_SPEC_420)
+ return sdhci_cdns6_set_tune_val(host, val);
+
if (WARN_ON(!FIELD_FIT(SDHCI_CDNS_HRS06_TUNE, val)))
return -EINVAL;
@@ -325,8 +305,10 @@ static int sdhci_cdns_execute_tuning(struct sdhci_host *host, u32 opcode)
* The delay is set by probe, based on the DT properties.
*/
if (host->timing != MMC_TIMING_MMC_HS200 &&
- host->timing != MMC_TIMING_UHS_SDR104)
+ host->timing != MMC_TIMING_UHS_SDR104) {
+ dev_dbg(mmc_dev(host->mmc), "Tuning skipped (timing: %d)\n", host->timing);
return 0;
+ }
for (i = 0; i < SDHCI_CDNS_MAX_TUNING_LOOP; i++) {
if (sdhci_cdns_set_tune_val(host, i) ||
@@ -350,6 +332,10 @@ static int sdhci_cdns_execute_tuning(struct sdhci_host *host, u32 opcode)
if (ret)
return ret;
+ /* Block gap tuning is only required for SD4HC, not for SD6HC */
+ if (host->version >= SDHCI_SPEC_420)
+ return 0;
+
return sdhci_cdns_tune_blkgap(host->mmc);
}
@@ -385,6 +371,10 @@ static void sdhci_cdns_set_uhs_signaling(struct sdhci_host *host,
/* For SD, fall back to the default handler */
if (mode == SDHCI_CDNS_HRS06_MODE_SD)
sdhci_set_uhs_signaling(host, timing);
+
+ /* For host controller V6, set SDHCI and PHY registers for UHS signaling */
+ if (host->version >= SDHCI_SPEC_420)
+ sdhci_cdns6_set_uhs_signaling(host, timing);
}
/* Elba control register bits [6:3] are byte-lane enables */
@@ -481,6 +471,16 @@ static const struct sdhci_ops sdhci_cdns4_ops = {
.set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
};
+static const struct sdhci_ops sdhci_cdns6_ops = {
+ .set_clock = sdhci_set_clock,
+ .get_timeout_clock = sdhci_cdns_get_timeout_clock,
+ .set_bus_width = sdhci_set_bus_width,
+ .reset = sdhci_reset,
+ .platform_execute_tuning = sdhci_cdns_execute_tuning,
+ .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
+ .hw_reset = sdhci_cdns6_hw_reset,
+};
+
static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
.pltfm_data = {
.ops = &sdhci_cdns4_ops,
@@ -508,6 +508,12 @@ static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
},
};
+static const struct sdhci_cdns_drv_data sdhci_cdns6_drv_data = {
+ .pltfm_data = {
+ .ops = &sdhci_cdns6_ops,
+ },
+};
+
static void sdhci_cdns_hs400_enhanced_strobe(struct mmc_host *mmc,
struct mmc_ios *ios)
{
@@ -526,6 +532,10 @@ static void sdhci_cdns_hs400_enhanced_strobe(struct mmc_host *mmc,
if (mode == SDHCI_CDNS_HRS06_MODE_MMC_HS400ES && !ios->enhanced_strobe)
sdhci_cdns_set_emmc_mode(priv,
SDHCI_CDNS_HRS06_MODE_MMC_HS400);
+
+ /* SD6HC PHY timing depends on enhanced-strobe; recompute register values */
+ if (host->version >= SDHCI_SPEC_420)
+ sdhci_cdns6_set_uhs_signaling(host, MMC_TIMING_MMC_HS400);
}
static void sdhci_cdns_mmc_hw_reset(struct mmc_host *mmc)
@@ -569,6 +579,7 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_cdns_priv *priv;
struct clk *clk;
+ struct clk *biu_clk;
int ret;
struct device *dev = &pdev->dev;
static const u16 version = SDHCI_SPEC_400 << SDHCI_SPEC_VER_SHIFT;
@@ -577,6 +588,13 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
if (IS_ERR(clk))
return PTR_ERR(clk);
+ /* SD6HC requires a second clock, "biu", for the bus interface unit. */
+ if (of_device_is_compatible(dev->of_node, "cdns,sd6hc")) {
+ biu_clk = devm_clk_get_enabled(dev, "biu");
+ if (IS_ERR(biu_clk))
+ return dev_err_probe(dev, PTR_ERR(biu_clk), "failed to enable biu clock\n");
+ }
+
data = of_device_get_match_data(dev);
if (!data)
return dev_err_probe(dev, -EINVAL, "missing platform driver data\n");
@@ -601,30 +619,46 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
return ret;
}
sdhci_enable_v4_mode(host);
- __sdhci_read_caps(host, &version, NULL, NULL);
-
sdhci_get_of_property(pdev);
ret = mmc_of_parse(host->mmc);
if (ret)
return ret;
- ret = sdhci_cdns4_phy_probe(pdev, priv);
- if (ret)
- return ret;
+ /*
+ * For SD4HC, read capabilities with fixed version override and set up
+ * the optional eMMC card RST_n reset control.
+ * For SD6HC, sdhci_add_host() will automatically read capabilities
+ * and version from the host controller registers.
+ */
+ if (of_device_is_compatible(dev->of_node, "cdns,sd4hc")) {
+ __sdhci_read_caps(host, &version, NULL, NULL);
+ ret = sdhci_cdns4_phy_probe(pdev, priv);
+ if (ret)
+ return ret;
- if (host->mmc->caps & MMC_CAP_HW_RESET) {
- priv->rst_hw = devm_reset_control_get_optional_exclusive(dev, NULL);
- if (IS_ERR(priv->rst_hw))
- return dev_err_probe(mmc_dev(host->mmc), PTR_ERR(priv->rst_hw),
- "reset controller error\n");
- if (priv->rst_hw)
- host->mmc_host_ops.card_hw_reset = sdhci_cdns_mmc_hw_reset;
+ if (host->mmc->caps & MMC_CAP_HW_RESET) {
+ priv->rst_hw = devm_reset_control_get_optional_exclusive(dev, NULL);
+ if (IS_ERR(priv->rst_hw))
+ return dev_err_probe(mmc_dev(host->mmc), PTR_ERR(priv->rst_hw),
+ "reset controller error\n");
+ if (priv->rst_hw)
+ host->mmc_host_ops.card_hw_reset = sdhci_cdns_mmc_hw_reset;
+ }
+ } else {
+ ret = sdhci_cdns6_phy_probe(pdev, priv);
+ if (ret)
+ return ret;
}
return sdhci_add_host(host);
}
+/*
+ * Only the CIU clock is gated on suspend. The SD6HC "biu" clock is not
+ * toggled here as it may be a shared bus clock; a dedicated biu clock
+ * would need explicit PM gating added here.
+ */
static int sdhci_cdns_resume(struct device *dev)
{
struct sdhci_host *host = dev_get_drvdata(dev);
@@ -636,7 +670,11 @@ static int sdhci_cdns_resume(struct device *dev)
if (ret)
return ret;
- ret = sdhci_cdns4_phy_init(priv);
+ if (host->version >= SDHCI_SPEC_420)
+ ret = sdhci_cdns6_phy_init(priv);
+ else
+ ret = sdhci_cdns4_phy_init(priv);
+
if (ret)
goto disable_clk;
@@ -671,6 +709,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
.compatible = "cdns,sd4hc",
.data = &sdhci_cdns4_drv_data,
},
+ {
+ .compatible = "cdns,sd6hc",
+ .data = &sdhci_cdns6_drv_data,
+ },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, sdhci_cdns_match);
diff --git a/drivers/mmc/host/sdhci-cadence-phy-v6.c b/drivers/mmc/host/sdhci-cadence-phy-v6.c
new file mode 100644
index 000000000000..2d7972948a45
--- /dev/null
+++ b/drivers/mmc/host/sdhci-cadence-phy-v6.c
@@ -0,0 +1,929 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * PHY and host controller support for Cadence SD6HC SDHCI
+ *
+ * This file provides support for Cadence's sixth-generation SDHCI controller (SD6HC).
+ * Implements PHY initialization, DLL management, per-speed-mode timing calculations,
+ * and host controller register programming for the SD6HC integrated combo-PHY.
+ *
+ * Copyright (C) 2026 Altera Corporation
+ * Author: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bits.h>
+#include <linux/iopoll.h>
+#include <linux/of.h>
+
+#include "sdhci-cadence.h"
+
+/* IO Delay Information */
+#define SDHCI_CDNS_HRS07 0x1c
+#define SDHCI_CDNS_HRS07_RW_COMPENSATE GENMASK(20, 16)
+#define SDHCI_CDNS_HRS07_IDELAY_VAL GENMASK(4, 0)
+
+/* PHY Control and Status */
+#define SDHCI_CDNS_HRS09 0x24
+#define SDHCI_CDNS_HRS09_RDDATA_EN BIT(16)
+#define SDHCI_CDNS_HRS09_RDCMD_EN BIT(15)
+#define SDHCI_CDNS_HRS09_EXTENDED_WR_MODE BIT(3)
+#define SDHCI_CDNS_HRS09_EXTENDED_RD_MODE BIT(2)
+#define SDHCI_CDNS_HRS09_PHY_INIT_COMPLETE BIT(1)
+#define SDHCI_CDNS_HRS09_PHY_SW_RESET BIT(0)
+
+/* SDCLK start point adjustment */
+#define SDHCI_CDNS_HRS10 0x28
+#define SDHCI_CDNS_HRS10_HCSDCLKADJ GENMASK(19, 16)
+
+/* eMMC Control */
+#define SDHCI_CDNS_HRS11 0x2c
+#define SDHCI_CDNS_HRS11_EMMC_RST BIT(0) /* eMMC reset */
+
+/* CMD/DAT output delay */
+#define SDHCI_CDNS_HRS16 0x40
+#define SDHCI_CDNS_HRS16_WRDATA1_SDCLK_DLY GENMASK(31, 28)
+#define SDHCI_CDNS_HRS16_WRDATA0_SDCLK_DLY GENMASK(27, 24)
+#define SDHCI_CDNS_HRS16_WRCMD1_SDCLK_DLY GENMASK(23, 20)
+#define SDHCI_CDNS_HRS16_WRCMD0_SDCLK_DLY GENMASK(19, 16)
+#define SDHCI_CDNS_HRS16_WRDATA1_DLY GENMASK(15, 12)
+#define SDHCI_CDNS_HRS16_WRDATA0_DLY GENMASK(11, 8)
+#define SDHCI_CDNS_HRS16_WRCMD1_DLY GENMASK(7, 4)
+#define SDHCI_CDNS_HRS16_WRCMD0_DLY GENMASK(3, 0)
+
+/* PHY Special Function Registers */
+/* DQ timing */
+#define SDHCI_CDNS6_PHY_DQ_TIMING_REG 0x2000
+#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_ALWAYS_ON BIT(31)
+#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END GENMASK(29, 27)
+#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START GENMASK(26, 24)
+#define SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END GENMASK(2, 0)
+
+/* DQS timing */
+#define SDHCI_CDNS6_PHY_DQS_TIMING_REG 0x2004
+#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_EXT_LPBK_DQS BIT(22)
+#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_LPBK_DQS BIT(21)
+#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS BIT(20)
+#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD BIT(19)
+
+/* Gate and loopback control */
+#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG 0x2008
+#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_SYNC_METHOD BIT(31)
+#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL GENMASK(24, 19)
+#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_UNDERRUN_SUPPRESS BIT(18)
+#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_GATE_CFG_ALWAYS_ON BIT(6)
+
+/* Master DLL logic */
+#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_REG 0x200c
+#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_BYPASS_MODE BIT(23)
+#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_PHASE_DETECT_SEL GENMASK(22, 20)
+#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_LOCK_NUM GENMASK(18, 16)
+#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_START_POINT GENMASK(7, 0)
+
+/* Slave DLL logic */
+#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_REG 0x2010
+#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_CMD_DELAY GENMASK(31, 24)
+#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WRDQS_DELAY GENMASK(23, 16)
+#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WR_DELAY GENMASK(15, 8)
+#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_DELAY GENMASK(7, 0)
+
+/* Global control settings */
+#define SDHCI_CDNS6_PHY_CTRL_REG 0x2080
+#define SDHCI_CDNS6_PHY_CTRL_PHONY_DQS_TIMING GENMASK(9, 4)
+
+/* Default PHY settings */
+#define SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY 2500
+#define SDHCI_CDNS6_PHY_DEFAULT_DELAY_ELEMENT 24
+#define SDHCI_CDNS6_PHY_DEFAULT_RD_DEL_SEL 52
+#define SDHCI_CDNS6_PHY_DEFAULT_DLL_START 4
+#define SDHCI_CDNS6_PHY_DEFAULT_PHASE_DETECT_SEL 2
+#define SDHCI_CDNS6_PHY_DEFAULT_DLL_LOCK_NUM 0
+#define SDHCI_CDNS6_PHY_DEFAULT_DATA_SELECT_OE_END 1
+
+/* Scale tuning tap (0..39) to 8-bit PHY DLL delay field (0..255) */
+#define SDHCI_CDNS6_PHY_DLL_FIELD_SIZE 256
+
+struct sdhci_cdns6_phy {
+ /*
+ * Mode-specific timing constraints (in picoseconds)
+ * These define valid output windows per SD/eMMC spec
+ */
+ u32 t_cmd_output_min;
+ u32 t_cmd_output_max;
+ u32 t_dat_output_min;
+ u32 t_dat_output_max;
+
+ /*
+ * PHY delay configuration (in picoseconds)
+ * Derived from clock period and board-level IO cell delays
+ */
+ u32 phy_sdclk_delay;
+ u32 phy_cmd_o_delay;
+ u32 phy_dat_o_delay;
+ u32 iocell_input_delay;
+ u32 iocell_output_delay;
+ /* Configured delay element (ps); preserved across clock changes */
+ u32 delay_element_org;
+ /* Active delay element (ps); doubled when one SDMCLK requires > 256 steps */
+ u32 delay_element;
+
+ /* PHY_DLL_SLAVE_CTRL register fields */
+ u8 cp_read_dqs_cmd_delay; /* bits [31:24] */
+ u8 cp_clk_wrdqs_delay; /* bits [23:16] */
+ u8 cp_clk_wr_delay; /* bits [15:8] */
+ u8 cp_read_dqs_delay; /* bits [7:0] */
+
+ /* PHY_DLL_MASTER_CTRL register fields */
+ bool cp_dll_bypass_mode; /* bit [23] */
+
+ /* PHY_DQ_TIMING register fields */
+ u8 cp_io_mask_end; /* bits [29:27] */
+ u8 cp_io_mask_start; /* bits [26:24] */
+
+ /* PHY_DQS_TIMING register fields */
+ bool cp_use_phony_dqs; /* bit [20] */
+ bool cp_use_phony_dqs_cmd; /* bit [19] */
+
+ /* HRS07 register - IO delay Information */
+ u8 sdhc_rw_compensate; /* bits [20:16] */
+ u8 sdhc_idelay_val; /* bits [4:0] */
+
+ /* HRS09 register - PHY control and Status */
+ bool sdhc_extended_wr_mode; /* bit [3] */
+ bool sdhc_extended_rd_mode; /* bit [2] */
+
+ /* HRS10 register - SDCLK start point adjustment */
+ u8 sdhc_hcsdclkadj; /* bits [19:16] */
+
+ /* HRS16 register fields - CMD/DAT output delay control */
+ u8 sdhc_wrdata1_sdclk_dly; /* bits [31:28] */
+ u8 sdhc_wrdata0_sdclk_dly; /* bits [27:24] */
+ u8 sdhc_wrcmd1_sdclk_dly; /* bits [23:20] */
+ u8 sdhc_wrcmd0_sdclk_dly; /* bits [19:16] */
+ u8 sdhc_wrdata1_dly; /* bits [15:12] */
+ u8 sdhc_wrdata0_dly; /* bits [11:8] */
+ u8 sdhc_wrcmd1_dly; /* bits [7:4] */
+ u8 sdhc_wrcmd0_dly; /* bits [3:0] */
+
+ /* DLL calculation intermediate values, used during PHY timing calculations */
+ u32 t_sdmclk_calc; /* DLL-quantized SDMCLK period */
+ u32 dll_max_value; /* DLL delay field ceiling */
+
+ /* Tuning value for HS200/HS400 modes */
+ u8 hs200_tune_val;
+
+ /* Clock periods (in picoseconds) */
+ u32 t_sdmclk; /* Master clock period */
+ u32 t_sdclk; /* SD card clock period */
+
+ /* Current operating state */
+ bool strobe_cmd; /* Enhanced strobe for CMD line */
+ unsigned int mode; /* Current MMC_TIMING_* mode */
+};
+
+/**
+ * init_ds() - Initialize PHY timing for Default Speed mode (25 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_ds(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 5000;
+ phy->t_cmd_output_max = t_sdclk - 5000;
+ phy->t_dat_output_min = 5000;
+ phy->t_dat_output_max = t_sdclk - 5000;
+}
+
+/**
+ * init_hs() - Initialize PHY timing for High Speed mode (50 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_hs(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 2000;
+ phy->t_cmd_output_max = t_sdclk - 6000;
+ phy->t_dat_output_min = 2000;
+ phy->t_dat_output_max = t_sdclk - 6000;
+}
+
+/**
+ * init_uhs_sdr12() - Initialize PHY timing for UHS SDR12 mode (25 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_uhs_sdr12(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 3000;
+}
+
+/**
+ * init_uhs_sdr25() - Initialize PHY timing for UHS SDR25 mode (50 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_uhs_sdr25(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 3000;
+}
+
+/**
+ * init_uhs_sdr50() - Initialize PHY timing for UHS SDR50 mode (100 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_uhs_sdr50(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 3000;
+}
+
+/**
+ * init_uhs_sdr104() - Initialize PHY timing for UHS SDR104 mode (200 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_uhs_sdr104(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 1400;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 1400;
+}
+
+/**
+ * init_uhs_ddr50() - Initialize PHY timing for UHS DDR50 mode (50 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_uhs_ddr50(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 3000;
+}
+
+/**
+ * init_emmc_sdr() - Initialize PHY timing for eMMC legacy/SDR mode.
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_emmc_sdr(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 3000;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 3000;
+ phy->t_dat_output_max = t_sdclk - 3000;
+}
+
+/**
+ * init_emmc_ddr() - Initialize PHY timing for eMMC DDR52 mode.
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_emmc_ddr(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 3000;
+ phy->t_cmd_output_max = t_sdclk - 3000;
+ phy->t_dat_output_min = 2500;
+ phy->t_dat_output_max = t_sdclk - 2500;
+}
+
+/**
+ * init_emmc_hs200() - Initialize PHY timing for eMMC HS200 mode (200 MHz).
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_emmc_hs200(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 1400;
+ phy->t_dat_output_min = 800;
+ phy->t_dat_output_max = t_sdclk - 1400;
+}
+
+/**
+ * init_emmc_hs400() - Initialize PHY timing for eMMC HS400/HS400ES mode.
+ * @phy: Pointer to SD6HC PHY state.
+ * @t_sdclk: SD clock period in picoseconds.
+ */
+static void init_emmc_hs400(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
+{
+ phy->t_cmd_output_min = 800;
+ phy->t_cmd_output_max = t_sdclk - 1400;
+ phy->t_dat_output_min = 400;
+ phy->t_dat_output_max = t_sdclk - 400;
+}
+
+/*
+ * init_timings - PHY timing initializers indexed by MMC_TIMING_* value.
+ *
+ * Each entry corresponds to a MMC_TIMING_* constant and sets the appropriate cmd/dat
+ * output timing windows in the PHY state struct.
+ */
+static void (* const init_timings[])(struct sdhci_cdns6_phy *, u32) = {
+ [MMC_TIMING_LEGACY] = init_ds,
+ [MMC_TIMING_MMC_HS] = init_emmc_sdr,
+ [MMC_TIMING_SD_HS] = init_hs,
+ [MMC_TIMING_UHS_SDR12] = init_uhs_sdr12,
+ [MMC_TIMING_UHS_SDR25] = init_uhs_sdr25,
+ [MMC_TIMING_UHS_SDR50] = init_uhs_sdr50,
+ [MMC_TIMING_UHS_SDR104] = init_uhs_sdr104,
+ [MMC_TIMING_UHS_DDR50] = init_uhs_ddr50,
+ [MMC_TIMING_MMC_DDR52] = init_emmc_ddr,
+ [MMC_TIMING_MMC_HS200] = init_emmc_hs200,
+ [MMC_TIMING_MMC_HS400] = init_emmc_hs400,
+};
+
+static unsigned int sdhci_cdns6_read_phy_reg(struct sdhci_cdns_priv *priv, const u32 address)
+{
+ writel(address, priv->hrs_addr + SDHCI_CDNS_HRS04);
+ return readl(priv->hrs_addr + SDHCI_CDNS_HRS05);
+}
+
+static void sdhci_cdns6_write_phy_reg(struct sdhci_cdns_priv *priv, const u32 address,
+ const u32 value)
+{
+ writel(address, priv->hrs_addr + SDHCI_CDNS_HRS04);
+ writel(value, priv->hrs_addr + SDHCI_CDNS_HRS05);
+}
+
+static int sdhci_cdns6_phy_lock_dll(struct sdhci_cdns6_phy *phy)
+{
+ u32 delay_element = phy->delay_element_org;
+ u32 delay_elements_in_sdmclk;
+
+ delay_elements_in_sdmclk = DIV_ROUND_UP(phy->t_sdmclk, delay_element);
+ if (delay_elements_in_sdmclk > 256) {
+ delay_element *= 2;
+ delay_elements_in_sdmclk = DIV_ROUND_UP(phy->t_sdmclk, delay_element);
+
+ if (delay_elements_in_sdmclk > 256)
+ return -EINVAL;
+
+ phy->dll_max_value = 127;
+ } else {
+ phy->dll_max_value = 255;
+ }
+
+ phy->t_sdmclk_calc = delay_element * delay_elements_in_sdmclk;
+ phy->delay_element = delay_element;
+ phy->cp_dll_bypass_mode = false;
+
+ return 0;
+}
+
+static void sdhci_cdns6_phy_dll_bypass(struct sdhci_cdns6_phy *phy)
+{
+ phy->dll_max_value = 256;
+ phy->cp_dll_bypass_mode = true;
+}
+
+static void sdhci_cdns6_phy_configure_dll(struct sdhci_cdns6_phy *phy)
+{
+ if (!phy->sdhc_extended_wr_mode) {
+ if (sdhci_cdns6_phy_lock_dll(phy) == 0)
+ return;
+ }
+ sdhci_cdns6_phy_dll_bypass(phy);
+}
+
+static void sdhci_cdns6_phy_calc_out(struct sdhci_cdns6_phy *phy, bool cmd_not_dat)
+{
+ u32 wr0_dly = 0, wr1_dly = 0, output_min, output_max, phy_o_delay,
+ clk_wr_delay = 0, wr0_sdclk_dly = 0, wr1_sdclk_dly = 0;
+ bool ddr = (phy->mode == MMC_TIMING_UHS_DDR50) || (phy->mode == MMC_TIMING_MMC_DDR52) ||
+ (phy->mode == MMC_TIMING_MMC_HS400);
+ bool data_ddr = ddr && !cmd_not_dat;
+ int t;
+
+ if (cmd_not_dat) {
+ output_min = phy->t_cmd_output_min;
+ output_max = phy->t_cmd_output_max;
+ phy_o_delay = phy->phy_cmd_o_delay;
+ } else {
+ output_min = phy->t_dat_output_min;
+ output_max = phy->t_dat_output_max;
+ phy_o_delay = phy->phy_dat_o_delay;
+ }
+
+ if (data_ddr) {
+ wr0_sdclk_dly = 1;
+ wr1_sdclk_dly = 1;
+ }
+
+ t = phy_o_delay - phy->phy_sdclk_delay - output_min;
+ if (t < 0 && phy->sdhc_extended_wr_mode) {
+ u32 n_half_cycle = DIV_ROUND_UP(-t * 2, phy->t_sdmclk);
+
+ wr0_dly = (n_half_cycle + 1) / 2;
+ if (data_ddr)
+ wr1_dly = (n_half_cycle + 1) / 2;
+ else
+ wr1_dly = (n_half_cycle + 1) % 2 + wr0_dly - 1;
+ }
+
+ if (!phy->sdhc_extended_wr_mode) {
+ u32 out_hold, out_setup, out_hold_margin;
+ u32 n;
+
+ if (!data_ddr)
+ wr0_dly = 1;
+
+ out_setup = output_max;
+ out_hold = output_min;
+ out_hold_margin = DIV_ROUND_UP(out_setup - out_hold, 4);
+ out_hold += out_hold_margin;
+
+ if (!phy->cp_dll_bypass_mode)
+ n = DIV_ROUND_UP(256 * out_hold, phy->t_sdmclk_calc);
+ else
+ n = DIV_ROUND_UP(out_hold, phy->delay_element) - 1;
+
+ if (n <= phy->dll_max_value)
+ clk_wr_delay = n;
+ else
+ clk_wr_delay = 255;
+ } else {
+ /* sdhc_extended_wr_mode set => PHY IO cell work in SDR mode */
+ clk_wr_delay = 0;
+ }
+
+ if (cmd_not_dat) {
+ phy->sdhc_wrcmd0_dly = wr0_dly;
+ phy->sdhc_wrcmd1_dly = wr1_dly;
+ phy->cp_clk_wrdqs_delay = clk_wr_delay;
+ phy->sdhc_wrcmd0_sdclk_dly = wr0_sdclk_dly;
+ phy->sdhc_wrcmd1_sdclk_dly = wr1_sdclk_dly;
+ } else {
+ phy->sdhc_wrdata0_dly = wr0_dly;
+ phy->sdhc_wrdata1_dly = wr1_dly;
+ phy->cp_clk_wr_delay = clk_wr_delay;
+ phy->sdhc_wrdata0_sdclk_dly = wr0_sdclk_dly;
+ phy->sdhc_wrdata1_sdclk_dly = wr1_sdclk_dly;
+ }
+}
+
+static void sdhci_cdns6_phy_calc_cmd_out(struct sdhci_cdns6_phy *phy)
+{
+ sdhci_cdns6_phy_calc_out(phy, true);
+}
+
+static void sdhci_cdns6_phy_calc_cmd_in(struct sdhci_cdns6_phy *phy)
+{
+ phy->cp_io_mask_end = ((phy->iocell_output_delay + phy->iocell_input_delay) * 2) /
+ phy->t_sdmclk;
+
+ /* cp_io_mask_end is a 3-bit field, clamp to max value of 7 */
+ phy->cp_io_mask_end = min_t(u8, phy->cp_io_mask_end, 7);
+
+ if (phy->strobe_cmd && phy->cp_io_mask_end > 0)
+ phy->cp_io_mask_end--;
+
+ if (phy->strobe_cmd) {
+ phy->cp_use_phony_dqs_cmd = false;
+ phy->cp_read_dqs_cmd_delay = 64;
+ } else {
+ phy->cp_use_phony_dqs_cmd = true;
+ phy->cp_read_dqs_cmd_delay = 0;
+ }
+
+ if ((phy->mode == MMC_TIMING_MMC_HS400 && !phy->strobe_cmd) ||
+ phy->mode == MMC_TIMING_MMC_HS200)
+ phy->cp_read_dqs_cmd_delay = phy->hs200_tune_val;
+}
+
+static void sdhci_cdns6_phy_calc_dat_in(struct sdhci_cdns6_phy *phy)
+{
+ u32 hcsdclkadj = 0;
+ bool strobe_dat = (phy->mode == MMC_TIMING_MMC_HS400);
+
+ if (strobe_dat) {
+ phy->cp_use_phony_dqs = false;
+ phy->cp_read_dqs_delay = 64;
+ } else {
+ phy->cp_use_phony_dqs = true;
+ phy->cp_read_dqs_delay = 0;
+ }
+
+ if (phy->mode == MMC_TIMING_MMC_HS200)
+ phy->cp_read_dqs_delay = phy->hs200_tune_val;
+
+ if (strobe_dat) {
+ /* dqs loopback input via IO cell */
+ hcsdclkadj += phy->iocell_input_delay;
+ /* dfi_dqs_in: mem_dqs -> clean_dqs_mod; delay of hic_dll_dqs_nand2 */
+ hcsdclkadj += phy->delay_element / 2;
+ /* delay line */
+ hcsdclkadj += phy->t_sdclk / 2;
+ /* PHY FIFO write pointer */
+ hcsdclkadj += phy->t_sdclk / 2 + phy->delay_element;
+ /* 1st synchronizer */
+ hcsdclkadj += DIV_ROUND_UP(hcsdclkadj, phy->t_sdmclk) * phy->t_sdmclk - hcsdclkadj;
+ /*
+ * 2nd synchronizer + PHY FIFO read pointer + PHY rddata
+ * + PHY rddata registered, + FIFO 1st ciu_en
+ */
+ hcsdclkadj += 5 * phy->t_sdmclk;
+ /* FIFO 2nd ciu_en */
+ hcsdclkadj += phy->t_sdclk;
+ hcsdclkadj /= phy->t_sdclk;
+ } else {
+ u32 n;
+
+ /* rebar PHY delay */
+ hcsdclkadj += 2 * phy->t_sdmclk;
+ /* rebar output via IO cell */
+ hcsdclkadj += phy->iocell_output_delay;
+ /* dqs loopback input via IO cell */
+ hcsdclkadj += phy->iocell_input_delay;
+ /* dfi_dqs_in: mem_dqs -> clean_dqs_mod delay of hic_dll_dqs_nand2 */
+ hcsdclkadj += phy->delay_element / 2;
+ /* dll: one delay element between SIGI_0 and SIGO_0 */
+ hcsdclkadj += phy->delay_element;
+ /* dfi_dqs_in: mem_dqs_delayed -> clk_dqs delay of hic_dll_dqs_nand2 */
+ hcsdclkadj += phy->delay_element / 2;
+ /* deskew DLL: clk_dqs -> clk_dqN: one delay element */
+ hcsdclkadj += phy->delay_element;
+
+ if (phy->t_sdclk == phy->t_sdmclk)
+ n = (hcsdclkadj - 2 * phy->t_sdmclk) / phy->t_sdclk;
+ else
+ n = hcsdclkadj / phy->t_sdclk;
+
+ /* phase shift within one t_sdclk clock cycle caused by rebar - lbk dqs delay */
+ hcsdclkadj = hcsdclkadj % phy->t_sdclk;
+ /* PHY FIFO write pointer */
+ hcsdclkadj += phy->t_sdclk / 2;
+ /* 1st synchronizer */
+ hcsdclkadj += DIV_ROUND_UP(hcsdclkadj, phy->t_sdmclk) * phy->t_sdmclk - hcsdclkadj;
+ /*
+ * 2nd synchronizer + PHY FIFO read pointer + PHY rddata + PHY rddata registered
+ */
+ hcsdclkadj += 4 * phy->t_sdmclk;
+
+ if ((phy->t_sdclk / phy->t_sdmclk) > 1) {
+ u32 tmp1, tmp2;
+
+ tmp1 = hcsdclkadj;
+ tmp2 = (hcsdclkadj / phy->t_sdclk) * phy->t_sdclk + phy->t_sdclk -
+ phy->t_sdmclk;
+ if (tmp1 == tmp2)
+ tmp2 += phy->t_sdclk;
+
+ /* FIFO aligns to clock cycle before ciu_en */
+ hcsdclkadj += tmp2 - tmp1;
+ }
+
+ /* FIFO 1st ciu_en */
+ hcsdclkadj += phy->t_sdmclk;
+ /* FIFO 2nd ciu_en */
+ hcsdclkadj += phy->t_sdclk;
+ hcsdclkadj /= phy->t_sdclk;
+ hcsdclkadj += n;
+
+ if ((phy->t_sdclk / phy->t_sdmclk) >= 2) {
+ if (phy->mode == MMC_TIMING_UHS_DDR50 || phy->mode == MMC_TIMING_MMC_DDR52)
+ hcsdclkadj -= 2;
+ else
+ hcsdclkadj -= 1;
+ } else if ((phy->t_sdclk / phy->t_sdmclk) == 1) {
+ hcsdclkadj += 2;
+ }
+
+ if (phy->mode == MMC_TIMING_UHS_SDR104 || phy->mode == MMC_TIMING_MMC_HS200)
+ hcsdclkadj -= 1;
+ }
+
+ /* hcsdclkadj is a 4-bit field, clamp to max value of 15 */
+ if (hcsdclkadj > 15)
+ hcsdclkadj = 15;
+
+ phy->sdhc_hcsdclkadj = hcsdclkadj;
+}
+
+static void sdhci_cdns6_phy_calc_dat_out(struct sdhci_cdns6_phy *phy)
+{
+ sdhci_cdns6_phy_calc_out(phy, false);
+}
+
+static void sdhci_cdns6_phy_calc_io(struct sdhci_cdns6_phy *phy)
+{
+ u32 rw_compensate;
+
+ rw_compensate = ((phy->iocell_input_delay + phy->iocell_output_delay) / phy->t_sdmclk) +
+ phy->sdhc_wrdata0_dly + 5 + 3;
+
+ phy->sdhc_idelay_val = (2 * phy->iocell_input_delay) / phy->t_sdmclk;
+
+ phy->cp_io_mask_start = 0;
+ if (phy->t_sdclk == phy->t_sdmclk && rw_compensate > 10)
+ phy->cp_io_mask_start = 2 * (rw_compensate - 10);
+
+ if (phy->mode == MMC_TIMING_UHS_SDR104)
+ phy->cp_io_mask_start++;
+
+ if (phy->t_sdclk == phy->t_sdmclk && phy->mode == MMC_TIMING_UHS_SDR50)
+ phy->cp_io_mask_start++;
+
+ /* cp_io_mask_start is a 3-bit field, clamp to max value of 7 */
+ phy->cp_io_mask_start = min_t(u8, phy->cp_io_mask_start, 7);
+
+ phy->sdhc_rw_compensate = rw_compensate;
+}
+
+static void sdhci_cdns6_phy_calc_settings(struct sdhci_cdns6_phy *phy)
+{
+ sdhci_cdns6_phy_calc_cmd_out(phy);
+ sdhci_cdns6_phy_calc_cmd_in(phy);
+ sdhci_cdns6_phy_calc_dat_out(phy);
+ sdhci_cdns6_phy_calc_dat_in(phy);
+ sdhci_cdns6_phy_calc_io(phy);
+}
+
+static int sdhci_cdns6_dll_reset(struct sdhci_cdns_priv *priv, bool reset)
+{
+ u32 reg;
+ int ret = 0;
+
+ reg = readl(priv->hrs_addr + SDHCI_CDNS_HRS09);
+ if (reset)
+ reg &= ~SDHCI_CDNS_HRS09_PHY_SW_RESET;
+ else
+ reg |= SDHCI_CDNS_HRS09_PHY_SW_RESET;
+
+ writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS09);
+
+ /* After releasing PHY from reset, wait until PHY_INIT_COMPLETE is set within 3000us */
+ if (!reset) {
+ ret = readl_poll_timeout(priv->hrs_addr + SDHCI_CDNS_HRS09, reg, (reg &
+ SDHCI_CDNS_HRS09_PHY_INIT_COMPLETE), 0, 3000);
+ }
+
+ return ret;
+}
+
+int sdhci_cdns6_phy_init(struct sdhci_cdns_priv *priv)
+{
+ struct sdhci_cdns6_phy *phy = priv->phy;
+ u32 reg;
+ int ret;
+
+ sdhci_cdns6_dll_reset(priv, true);
+
+ reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_DQS_TIMING_REG);
+ reg &= ~SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS;
+ reg &= ~SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD;
+ reg |= SDHCI_CDNS6_PHY_DQS_TIMING_USE_EXT_LPBK_DQS;
+ reg |= SDHCI_CDNS6_PHY_DQS_TIMING_USE_LPBK_DQS;
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS, phy->cp_use_phony_dqs);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD, phy->cp_use_phony_dqs_cmd);
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DQS_TIMING_REG, reg);
+
+ reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG);
+ reg &= ~SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL;
+ reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_UNDERRUN_SUPPRESS;
+ reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_GATE_CFG_ALWAYS_ON;
+ reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_SYNC_METHOD;
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL,
+ SDHCI_CDNS6_PHY_DEFAULT_RD_DEL_SEL);
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG, reg);
+
+ reg = FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_BYPASS_MODE, phy->cp_dll_bypass_mode);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_PHASE_DETECT_SEL,
+ SDHCI_CDNS6_PHY_DEFAULT_PHASE_DETECT_SEL);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_LOCK_NUM,
+ SDHCI_CDNS6_PHY_DEFAULT_DLL_LOCK_NUM);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_START_POINT,
+ SDHCI_CDNS6_PHY_DEFAULT_DLL_START);
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_REG, reg);
+
+ reg = FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_CMD_DELAY,
+ phy->cp_read_dqs_cmd_delay);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WRDQS_DELAY, phy->cp_clk_wrdqs_delay);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WR_DELAY, phy->cp_clk_wr_delay);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_DELAY, phy->cp_read_dqs_delay);
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_REG, reg);
+
+ reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_CTRL_REG);
+ reg &= ~SDHCI_CDNS6_PHY_CTRL_PHONY_DQS_TIMING;
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_CTRL_REG, reg);
+
+ /*
+ * Ensure all preceding PHY register writes complete and reach the controller before
+ * releasing the PHY from reset. Without this, SDR104 has been observed to fail
+ * intermittently on some boards.
+ */
+ wmb();
+
+ ret = sdhci_cdns6_dll_reset(priv, false);
+ if (ret)
+ return ret;
+
+ reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_DQ_TIMING_REG);
+ reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_ALWAYS_ON;
+ reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END;
+ reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START;
+ reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END;
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END, phy->cp_io_mask_end);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START, phy->cp_io_mask_start);
+ reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END,
+ SDHCI_CDNS6_PHY_DEFAULT_DATA_SELECT_OE_END);
+ sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DQ_TIMING_REG, reg);
+
+ /* Ensure DQ timing programming is visible before HRS09 follow-up writes */
+ wmb();
+
+ reg = readl(priv->hrs_addr + SDHCI_CDNS_HRS09);
+ if (phy->sdhc_extended_wr_mode)
+ reg |= SDHCI_CDNS_HRS09_EXTENDED_WR_MODE;
+ else
+ reg &= ~SDHCI_CDNS_HRS09_EXTENDED_WR_MODE;
+
+ if (phy->sdhc_extended_rd_mode)
+ reg |= SDHCI_CDNS_HRS09_EXTENDED_RD_MODE;
+ else
+ reg &= ~SDHCI_CDNS_HRS09_EXTENDED_RD_MODE;
+
+ reg |= SDHCI_CDNS_HRS09_RDDATA_EN;
+ reg |= SDHCI_CDNS_HRS09_RDCMD_EN;
+ writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS09);
+
+ reg = FIELD_PREP(SDHCI_CDNS_HRS10_HCSDCLKADJ, phy->sdhc_hcsdclkadj);
+ writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS10);
+
+ reg = FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA1_SDCLK_DLY, phy->sdhc_wrdata1_sdclk_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA0_SDCLK_DLY, phy->sdhc_wrdata0_sdclk_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD1_SDCLK_DLY, phy->sdhc_wrcmd1_sdclk_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD0_SDCLK_DLY, phy->sdhc_wrcmd0_sdclk_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA1_DLY, phy->sdhc_wrdata1_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA0_DLY, phy->sdhc_wrdata0_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD1_DLY, phy->sdhc_wrcmd1_dly);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD0_DLY, phy->sdhc_wrcmd0_dly);
+ writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS16);
+
+ reg = FIELD_PREP(SDHCI_CDNS_HRS07_RW_COMPENSATE, phy->sdhc_rw_compensate);
+ reg |= FIELD_PREP(SDHCI_CDNS_HRS07_IDELAY_VAL, phy->sdhc_idelay_val);
+ writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS07);
+
+ /* Allow 5 to 5.5 ms for clock and PHY signals to stabilize after configuration */
+ usleep_range(5000, 5500);
+
+ return 0;
+}
+
+int sdhci_cdns6_set_tune_val(struct sdhci_host *host, unsigned int val)
+{
+ struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
+ struct sdhci_cdns6_phy *phy = priv->phy;
+ u32 tuneval;
+
+ /*
+ * Scale tuning tap (val in [0, SDHCI_CDNS_MAX_TUNING_LOOP-1]) to the
+ * 8-bit PHY DLL slave delay field [0, 255]. With MAX_TUNING_LOOP=40
+ * and FIELD_SIZE=256, the result fits in 8 bits.
+ *
+ * Updating the DLL slave delays also requires a PHY DLL reset cycle,
+ * so reuse the full phy_init() sequence rather than a register poke.
+ */
+ tuneval = (val * SDHCI_CDNS6_PHY_DLL_FIELD_SIZE) / SDHCI_CDNS_MAX_TUNING_LOOP;
+
+ phy->hs200_tune_val = tuneval;
+ phy->cp_read_dqs_cmd_delay = tuneval;
+ phy->cp_read_dqs_delay = tuneval;
+
+ return sdhci_cdns6_phy_init(priv);
+}
+
+static int sdhci_cdns6_phy_update_timings(struct sdhci_host *host)
+{
+ struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
+ struct sdhci_cdns6_phy *phy = priv->phy;
+ u32 t_sdmclk = phy->t_sdmclk;
+
+ /* Validate mode is within supported range */
+ if (phy->mode >= ARRAY_SIZE(init_timings))
+ return -EINVAL;
+
+ /* initialize input */
+ init_timings[phy->mode](phy, phy->t_sdclk);
+
+ phy->strobe_cmd = false;
+
+ if (priv->enhanced_strobe)
+ phy->strobe_cmd = true;
+
+ phy->phy_sdclk_delay = 2 * t_sdmclk;
+
+ /*
+ * CMD and DAT output delays are currently identical, but kept separate to allow
+ * independent tuning for specific modes (e.g., HS400) or board-specific optimizations
+ * in the future.
+ */
+ phy->phy_cmd_o_delay = 2 * t_sdmclk + t_sdmclk / 2;
+ phy->phy_dat_o_delay = 2 * t_sdmclk + t_sdmclk / 2;
+
+ if (phy->t_sdclk == phy->t_sdmclk) {
+ phy->sdhc_extended_wr_mode = false;
+ phy->sdhc_extended_rd_mode = false;
+ } else {
+ phy->sdhc_extended_wr_mode = true;
+ phy->sdhc_extended_rd_mode = true;
+ }
+
+ sdhci_cdns6_phy_configure_dll(phy);
+ sdhci_cdns6_phy_calc_settings(phy);
+
+ return 0;
+}
+
+int sdhci_cdns6_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv)
+{
+ struct device *dev = &pdev->dev;
+ struct sdhci_host *host = dev_get_drvdata(dev);
+ struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+ struct sdhci_cdns6_phy *phy;
+ unsigned long val;
+ int ret;
+
+ phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
+ if (!phy)
+ return -ENOMEM;
+
+ val = clk_get_rate(pltfm_host->clk);
+ if (!val)
+ return dev_err_probe(dev, -EINVAL, "failed to get controller clock rate\n");
+
+ phy->t_sdmclk = DIV_ROUND_DOWN_ULL(1000000000000ULL, val);
+
+ /*
+ * Optional board-level PHY timing properties. When omitted, use the
+ * Cadence-recommended defaults (2500 ps IO-cell delays, 24 ps DLL
+ * delay element) that are valid for typical SoC packaging.
+ */
+ ret = of_property_read_u32(dev->of_node, "cdns,iocell-input-delay-ps",
+ &phy->iocell_input_delay);
+ if (ret)
+ phy->iocell_input_delay = SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY;
+
+ ret = of_property_read_u32(dev->of_node, "cdns,iocell-output-delay-ps",
+ &phy->iocell_output_delay);
+ if (ret)
+ phy->iocell_output_delay = SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY;
+
+ ret = of_property_read_u32(dev->of_node, "cdns,delay-element-ps", &phy->delay_element);
+ if (ret)
+ phy->delay_element = SDHCI_CDNS6_PHY_DEFAULT_DELAY_ELEMENT;
+
+ phy->delay_element_org = phy->delay_element;
+
+ priv->phy = phy;
+
+ return 0;
+}
+
+void sdhci_cdns6_set_uhs_signaling(struct sdhci_host *host, unsigned int timing)
+{
+ struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
+ struct sdhci_cdns6_phy *phy = priv->phy;
+ int ret;
+
+ /* Clock may be 0 during initial ios setup; skip PHY update */
+ if (!host->mmc->ios.clock)
+ return;
+
+ phy->t_sdclk = DIV_ROUND_DOWN_ULL(1000000000000ULL, host->mmc->ios.clock);
+ phy->mode = timing;
+
+ ret = sdhci_cdns6_phy_update_timings(host);
+ if (ret) {
+ dev_warn(mmc_dev(host->mmc), "%s: update timings failed: %d\n", __func__, ret);
+ return;
+ }
+
+ ret = sdhci_cdns6_phy_init(priv);
+ if (ret)
+ dev_warn(mmc_dev(host->mmc), "%s: phy init failed: %d\n", __func__, ret);
+}
+
+void sdhci_cdns6_hw_reset(struct sdhci_host *host)
+{
+ struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
+ void __iomem *reg;
+
+ reg = priv->hrs_addr + SDHCI_CDNS_HRS11;
+ writel(SDHCI_CDNS_HRS11_EMMC_RST, reg);
+ /* eMMC HW reset assertion: spec requires >= 1us, give margin */
+ usleep_range(10, 20);
+ writel(0, reg);
+ /* For eMMC, minimum is 200us but give it 300us for good measure */
+ usleep_range(300, 1000);
+}
diff --git a/drivers/mmc/host/sdhci-cadence.h b/drivers/mmc/host/sdhci-cadence.h
new file mode 100644
index 000000000000..9affd9f4ede8
--- /dev/null
+++ b/drivers/mmc/host/sdhci-cadence.h
@@ -0,0 +1,111 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2026 Altera Corporation
+ * Author: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
+ *
+ * Cadence SD/SDIO/eMMC Host Controller driver - common header
+ * Shared definitions and structures for the Cadence SDHCI driver.
+ * Contains private data and declarations for SD6HC-specific functions
+ * called by the main driver in sdhci-cadence-core.c.
+ */
+
+#ifndef _MMC_HOST_SDHCI_CADENCE_H
+#define _MMC_HOST_SDHCI_CADENCE_H
+
+#include <linux/compiler.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include "sdhci-pltfm.h"
+
+struct reset_control;
+
+/* HRS - Host Register Set (specific to Cadence) */
+#define SDHCI_CDNS_HRS04 0x10 /* PHY access: address port */
+#define SDHCI_CDNS_HRS05 0x14 /* PHY access: data port */
+
+/*
+ * The tuned val register is 6 bit-wide, but not the whole of the range is
+ * available. The range 0-42 seems to be available (then 43 wraps around to 0)
+ * but I am not quite sure if it is official. Use only 0 to 39 for safety.
+ */
+#define SDHCI_CDNS_MAX_TUNING_LOOP 40
+
+/**
+ * struct sdhci_cdns_priv - Cadence SDHCI private controller data
+ * @hrs_addr: Base address of Cadence Host Register Set (HRS) registers.
+ * @ctl_addr: Base address for write control registers.
+ * Used only for "amd,pensando-elba-sd4hc" compatible controllers to enable
+ * byte-lane writes.
+ * @wrlock: Spinlock for protecting register writes (Elba only).
+ * @enhanced_strobe: Flag indicating if Enhanced Strobe (HS400ES) is enabled.
+ * @priv_writel: Optional SoC-specific write function for register access.
+ * Used for Elba to ensure correct byte-lane enable.
+ * @rst_hw: Hardware reset control for the eMMC card RST_n pin (SD4HC only).
+ * @phy: Opaque pointer to variant-specific PHY data.
+ * For SD4HC: points to struct sdhci_cdns4_phy.
+ * For SD6HC: points to struct sdhci_cdns6_phy.
+ */
+struct sdhci_cdns_priv {
+ void __iomem *hrs_addr;
+ void __iomem *ctl_addr; /* write control */
+ spinlock_t wrlock; /* write lock */
+ bool enhanced_strobe;
+ void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
+ struct reset_control *rst_hw;
+ void *phy;
+};
+
+/**
+ * sdhci_cdns_priv - Helper to retrieve Cadence private data from sdhci_host
+ * @host: Pointer to struct sdhci_host.
+ *
+ * Return: Pointer to struct sdhci_cdns_priv.
+ */
+static inline void *sdhci_cdns_priv(struct sdhci_host *host)
+{
+ struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+
+ return sdhci_pltfm_priv(pltfm_host);
+}
+
+/**
+ * sdhci_cdns6_set_uhs_signaling - Program PHY registers for a specific timing mode.
+ * @host: Pointer to struct sdhci_host.
+ * @timing: MMC timing mode (MMC_TIMING_*).
+ */
+void sdhci_cdns6_set_uhs_signaling(struct sdhci_host *host, unsigned int timing);
+
+/**
+ * sdhci_cdns6_set_tune_val - Set the PHY tuning value.
+ * @host: Pointer to struct sdhci_host.
+ * @val: Tuning value to program.
+ *
+ * Return: 0 on success, -ETIMEDOUT if PHY initialization times out.
+ */
+int sdhci_cdns6_set_tune_val(struct sdhci_host *host, unsigned int val);
+
+/**
+ * sdhci_cdns6_phy_probe - Probe and initialize Cadence SD6HC PHY parameters
+ * @pdev: Platform device pointer
+ * @priv: Pointer to Cadence private data structure
+ *
+ * Return: 0 on success or a negative error code.
+ */
+int sdhci_cdns6_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv);
+
+/**
+ * sdhci_cdns6_hw_reset - Perform hardware reset of the Cadence SDHCI controller.
+ * @host: Pointer to struct sdhci_host.
+ */
+void sdhci_cdns6_hw_reset(struct sdhci_host *host);
+
+/**
+ * sdhci_cdns6_phy_init - Initialize the SD6HC PHY with current settings.
+ * @priv: Pointer to Cadence private data structure.
+ *
+ * Return: 0 on success, -ETIMEDOUT if PHY initialization times out.
+ */
+int sdhci_cdns6_phy_init(struct sdhci_cdns_priv *priv);
+
+#endif /* _MMC_HOST_SDHCI_CADENCE_H */
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support
2026-07-24 14:50 ` [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support Tanmay Kathpalia
@ 2026-07-24 15:20 ` sashiko-bot
2026-08-07 12:40 ` Adrian Hunter
1 sibling, 0 replies; 17+ messages in thread
From: sashiko-bot @ 2026-07-24 15:20 UTC (permalink / raw)
To: Tanmay Kathpalia; +Cc: robh, conor+dt, devicetree
Thank you for your contribution! Sashiko AI review found 7 potential issue(s) to consider:
- [High] SD6HC PHY timing calculations use the requested clock frequency instead of the actual physical hardware clock.
- [High] SD6HC PHY remains uninitialized during initial MMC card discovery at 400kHz.
- [High] Unvalidated `cdns,delay-element-ps` device tree property leads to multiple division-by-zero kernel panics.
- [High] The Agilex5 platform initialization logic is unreachable dead code due to a missing match table entry.
- [High] `clk_wr_delay` is incorrectly hardcoded to 255 when the required delay exceeds the DLL's maximum limit.
- [Medium] SD6HC PHY code bypasses the driver's established abstraction for accessing Host Register Set (HRS) registers.
- [Medium] `wmb()` is incorrectly used as a mechanism to flush posted MMIO writes to the hardware.
--
--- Patch [7]: [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support ---
commit 61309bb2c01b2db2af64956b37f9af9f380deea8
Author: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
mmc: sdhci-cadence: add Cadence SD6HC support
This commit introduces support for the Cadence sixth-generation SD/SDIO/eMMC
host controller (SD6HC) with an integrated combo-PHY. It splits the existing
driver into core and PHY-specific files, adding new configuration, timing,
and DLL logic.
> diff --git a/drivers/mmc/host/sdhci-cadence-core.c b/drivers/mmc/host/sdhci-cadence-core.c
> --- a/drivers/mmc/host/sdhci-cadence-core.c
> +++ b/drivers/mmc/host/sdhci-cadence-core.c
[ ... ]
> @@ -481,6 +471,16 @@ static const struct sdhci_ops sdhci_cdns4_ops = {
> .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
> };
>
> +static const struct sdhci_ops sdhci_cdns6_ops = {
> + .set_clock = sdhci_set_clock,
[Severity: High]
Might this leave the SD6HC PHY uninitialized during initial MMC card
discovery at 400kHz?
During power-up, the clock transitions from 0 to 400kHz while remaining in
MMC_TIMING_LEGACY. The core MMC sdhci_set_ios() optimizes clock enabling by
returning early if the timing mode does not change. Because this only hooks
set_uhs_signaling to program the PHY, it looks like it will get bypassed
when only the frequency changes. Does the driver need a custom set_clock
callback to intercept pure frequency changes and initialize the PHY?
> + .get_timeout_clock = sdhci_cdns_get_timeout_clock,
> + .set_bus_width = sdhci_set_bus_width,
> + .reset = sdhci_reset,
> + .platform_execute_tuning = sdhci_cdns_execute_tuning,
> + .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
> + .hw_reset = sdhci_cdns6_hw_reset,
> +};
[ ... ]
> @@ -671,6 +709,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
> .compatible = "cdns,sd4hc",
> .data = &sdhci_cdns4_drv_data,
> },
> + {
> + .compatible = "cdns,sd6hc",
> + .data = &sdhci_cdns6_drv_data,
> + },
> { /* sentinel */ }
> };
[Severity: High]
Is the altr,agilex5-sd6hc compatible string missing from this match table?
Looking at the driver sources, there is an sdhci_cdns6_agilex5_init()
function that asserts and deasserts specific sdhc, combophy, and ocp resets
for the Altera Agilex5. Without a match entry hooking up this initialization
logic, the driver falls back to the generic cdns,sd6hc match data, making
the Agilex5 reset sequence unreachable dead code.
> diff --git a/drivers/mmc/host/sdhci-cadence-phy-v6.c b/drivers/mmc/host/sdhci-cadence-phy-v6.c
> --- /dev/null
> +++ b/drivers/mmc/host/sdhci-cadence-phy-v6.c
[ ... ]
> +static void sdhci_cdns6_write_phy_reg(struct sdhci_cdns_priv *priv, const u32 address,
> + const u32 value)
> +{
> + writel(address, priv->hrs_addr + SDHCI_CDNS_HRS04);
> + writel(value, priv->hrs_addr + SDHCI_CDNS_HRS05);
> +}
[Severity: Medium]
Will using direct writel() bypass the established priv->priv_writel()
abstraction?
The core sdhci-cadence architecture uses priv->priv_writel() to support
hardware like the Pensando Elba SoC, which requires custom byte-lane enable
writes. Using writel() directly for Host Register Set (HRS) access here
could cause silent hardware programming failures if SoCs with similar quirks
incorporate the SD6HC IP.
[ ... ]
> + if (!phy->sdhc_extended_wr_mode) {
> + u32 out_hold, out_setup, out_hold_margin;
> + u32 n;
> +
> + if (!data_ddr)
> + wr0_dly = 1;
> +
> + out_setup = output_max;
> + out_hold = output_min;
> + out_hold_margin = DIV_ROUND_UP(out_setup - out_hold, 4);
> + out_hold += out_hold_margin;
> +
> + if (!phy->cp_dll_bypass_mode)
> + n = DIV_ROUND_UP(256 * out_hold, phy->t_sdmclk_calc);
> + else
> + n = DIV_ROUND_UP(out_hold, phy->delay_element) - 1;
> +
> + if (n <= phy->dll_max_value)
> + clk_wr_delay = n;
> + else
> + clk_wr_delay = 255;
[Severity: High]
Should this assignment clamp to phy->dll_max_value instead of hardcoding 255?
In sdhci_cdns6_phy_lock_dll(), phy->dll_max_value is explicitly restricted to
127 when delay elements are doubled. If n exceeds 127 in that scenario, writing
255 here violates the maximum allowable tap index, potentially causing
unpredictable wraparound or breakage of hardware timing on slow clocks.
[ ... ]
> + /*
> + * Ensure all preceding PHY register writes complete and reach the controller before
> + * releasing the PHY from reset. Without this, SDR104 has been observed to fail
> + * intermittently on some boards.
> + */
> + wmb();
[Severity: Medium]
Does a wmb() actually flush posted MMIO writes to the hardware here?
A wmb() only orders CPU instructions; it does not flush posted write buffers
on interconnect buses like PCIe or AXI. If the intent is to guarantee MMIO
writes have settled before the PHY is taken out of reset, a dummy readl()
to the same device is usually required to prevent intermittent device failures.
[ ... ]
> + ret = of_property_read_u32(dev->of_node, "cdns,delay-element-ps", &phy->delay_element);
> + if (ret)
> + phy->delay_element = SDHCI_CDNS6_PHY_DEFAULT_DELAY_ELEMENT;
> +
> + phy->delay_element_org = phy->delay_element;
[Severity: High]
Could this cause a division-by-zero kernel panic if the device tree explicitly
provides a 0 value for the delay element?
The property is read without validating that it is non-zero. Later, in
sdhci_cdns6_phy_lock_dll(), phy->delay_element is used as a divisor in the
DIV_ROUND_UP(phy->t_sdmclk, delay_element) macro. A malformed device tree
could trivially trigger this crash on probe.
[ ... ]
> +void sdhci_cdns6_set_uhs_signaling(struct sdhci_host *host, unsigned int timing)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + struct sdhci_cdns6_phy *phy = priv->phy;
> + int ret;
> +
> + /* Clock may be 0 during initial ios setup; skip PHY update */
> + if (!host->mmc->ios.clock)
> + return;
> +
> + phy->t_sdclk = DIV_ROUND_DOWN_ULL(1000000000000ULL, host->mmc->ios.clock);
[Severity: High]
Can this lead to PHY timing mismatches by using the requested ios.clock instead
of the actual physical hardware clock?
The host->mmc->ios.clock field contains the requested target frequency. However,
the SDHCI controller can only output discrete frequencies based on its internal
integer dividers, which is tracked in host->mmc->actual_clock. If the requested
clock doesn't perfectly match a divider step, the PHY will be programmed for a
frequency the bus isn't actually running at, potentially causing data corruption.
> + phy->mode = timing;
> +
> + ret = sdhci_cdns6_phy_update_timings(host);
[ ... ]
> +void sdhci_cdns6_hw_reset(struct sdhci_host *host)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + void __iomem *reg;
> +
> + reg = priv->hrs_addr + SDHCI_CDNS_HRS11;
> + writel(SDHCI_CDNS_HRS11_EMMC_RST, reg);
[Severity: Medium]
Does this direct writel() skip the priv->priv_writel() abstraction as well?
Just like in sdhci_cdns6_write_phy_reg(), using writel() directly bypasses
the established abstraction and breaks variants that rely on custom byte-lane
writes for hardware reset.
> + /* eMMC HW reset assertion: spec requires >= 1us, give margin */
> + usleep_range(10, 20);
--
Sashiko AI review · https://sashiko.dev/#/patchset/20260724145009.7456-1-tanmay.kathpalia@altera.com?part=7
^ permalink raw reply [flat|nested] 17+ messages in thread* Re: [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support
2026-07-24 14:50 ` [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support Tanmay Kathpalia
2026-07-24 15:20 ` sashiko-bot
@ 2026-08-07 12:40 ` Adrian Hunter
1 sibling, 0 replies; 17+ messages in thread
From: Adrian Hunter @ 2026-08-07 12:40 UTC (permalink / raw)
To: Tanmay Kathpalia, linux-mmc
Cc: ulfh, krzk+dt, robh, conor+dt, dinguyen, p.zabel, devicetree,
linux-kernel
On 24/07/2026 17:50, Tanmay Kathpalia wrote:
> The Cadence SD6HC is a sixth-generation SD/SDIO/eMMC host controller
> with an integrated combo-PHY. PHY timing depends on the active speed
> mode, the SD clock period, and board-level IO-cell and DLL delay-
> element characteristics.
>
> SD6HC provides separate card-interface (CIU) and bus-interface (BIU)
> clocks, and asserts eMMC hardware reset through an internal controller
> register rather than an external RST_n line. The "cdns,sd6hc" compatible
> string identifies this IP in device tree.
>
> Split the existing driver into sdhci-cadence-core.c and
> sdhci-cadence-phy-v6.c, and add sdhci-cadence.h for shared private
> state.
>
> Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
There are a couple of comments below. Otherwise:
Acked-by: Adrian Hunter <adrian.hunter@intel.com>
> ---
> MAINTAINERS | 7 +
> drivers/mmc/host/Makefile | 1 +
> .../{sdhci-cadence.c => sdhci-cadence-core.c} | 122 ++-
> drivers/mmc/host/sdhci-cadence-phy-v6.c | 929 ++++++++++++++++++
> drivers/mmc/host/sdhci-cadence.h | 111 +++
> 5 files changed, 1130 insertions(+), 40 deletions(-)
> rename drivers/mmc/host/{sdhci-cadence.c => sdhci-cadence-core.c} (86%)
> create mode 100644 drivers/mmc/host/sdhci-cadence-phy-v6.c
> create mode 100644 drivers/mmc/host/sdhci-cadence.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 6a0996faa091..58267c681780 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -24407,6 +24407,13 @@ L: linux-mmc@vger.kernel.org
> S: Maintained
> F: drivers/mmc/host/sdhci-brcmstb*
>
> +SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) CADENCE DRIVER
> +M: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
> +L: linux-mmc@vger.kernel.org
> +S: Supported
> +F: Documentation/devicetree/bindings/mmc/cdns,sd6hc.yaml
> +F: drivers/mmc/host/sdhci-cadence*
> +
> SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) DRIVER
> M: Adrian Hunter <adrian.hunter@intel.com>
> L: linux-mmc@vger.kernel.org
> diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
> index ee412e6b84d6..799ce7ad43d5 100644
> --- a/drivers/mmc/host/Makefile
> +++ b/drivers/mmc/host/Makefile
> @@ -80,6 +80,7 @@ obj-$(CONFIG_MMC_REALTEK_USB) += rtsx_usb_sdmmc.o
>
> obj-$(CONFIG_MMC_SDHCI_PLTFM) += sdhci-pltfm.o
> obj-$(CONFIG_MMC_SDHCI_CADENCE) += sdhci-cadence.o
> +sdhci-cadence-y += sdhci-cadence-core.o sdhci-cadence-phy-v6.o
> obj-$(CONFIG_MMC_SDHCI_ESDHC_MCF) += sdhci-esdhc-mcf.o
> obj-$(CONFIG_MMC_SDHCI_ESDHC_IMX) += sdhci-esdhc-imx.o
> obj-$(CONFIG_MMC_SDHCI_DOVE) += sdhci-dove.o
> diff --git a/drivers/mmc/host/sdhci-cadence.c b/drivers/mmc/host/sdhci-cadence-core.c
> similarity index 86%
> rename from drivers/mmc/host/sdhci-cadence.c
> rename to drivers/mmc/host/sdhci-cadence-core.c
> index 1fb23051a047..18846acc0b11 100644
> --- a/drivers/mmc/host/sdhci-cadence.c
> +++ b/drivers/mmc/host/sdhci-cadence-core.c
> @@ -2,6 +2,7 @@
> /*
> * Copyright (C) 2016 Socionext Inc.
> * Author: Masahiro Yamada <yamada.masahiro@socionext.com>
> + * Copyright (C) 2026 Altera Corporation
> */
>
> #include <linux/bitfield.h>
> @@ -14,10 +15,10 @@
> #include <linux/platform_device.h>
> #include <linux/reset.h>
>
> -#include "sdhci-pltfm.h"
> +#include "sdhci-cadence.h"
>
> /* HRS - Host Register Set (specific to Cadence) */
> -#define SDHCI_CDNS_HRS04 0x10 /* PHY access port */
> +/* HRS04 (PHY access) bitfields (SD4HC) */
> #define SDHCI_CDNS_HRS04_ACK BIT(26)
> #define SDHCI_CDNS_HRS04_RD BIT(25)
> #define SDHCI_CDNS_HRS04_WR BIT(24)
> @@ -71,13 +72,6 @@
> #define SDHCI_CDNS_PHY_DLY_HSMMC 0x0c
> #define SDHCI_CDNS_PHY_DLY_STROBE 0x0d
>
> -/*
> - * The tuned val register is 6 bit-wide, but not the whole of the range is
> - * available. The range 0-42 seems to be available (then 43 wraps around to 0)
> - * but I am not quite sure if it is official. Use only 0 to 39 for safety.
> - */
> -#define SDHCI_CDNS_MAX_TUNING_LOOP 40
> -
> struct sdhci_cdns4_phy_param {
> u8 addr;
> u8 data;
> @@ -88,16 +82,6 @@ struct sdhci_cdns4_phy {
> struct sdhci_cdns4_phy_param phy_params[];
> };
>
> -struct sdhci_cdns_priv {
> - void __iomem *hrs_addr;
> - void __iomem *ctl_addr; /* write control */
> - spinlock_t wrlock; /* write lock */
> - bool enhanced_strobe;
> - void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
> - struct reset_control *rst_hw;
> - struct sdhci_cdns4_phy *phy;
> -};
> -
> struct sdhci_cdns4_phy_cfg {
> const char *property;
> u8 addr;
> @@ -203,13 +187,6 @@ static int sdhci_cdns4_phy_init(struct sdhci_cdns_priv *priv)
> return 0;
> }
>
> -static void *sdhci_cdns_priv(struct sdhci_host *host)
> -{
> - struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
> -
> - return sdhci_pltfm_priv(pltfm_host);
> -}
> -
> static unsigned int sdhci_cdns_get_timeout_clock(struct sdhci_host *host)
> {
> /*
> @@ -245,6 +222,9 @@ static int sdhci_cdns_set_tune_val(struct sdhci_host *host, unsigned int val)
> u32 tmp;
> int i, ret;
>
> + if (host->version >= SDHCI_SPEC_420)
> + return sdhci_cdns6_set_tune_val(host, val);
> +
> if (WARN_ON(!FIELD_FIT(SDHCI_CDNS_HRS06_TUNE, val)))
> return -EINVAL;
>
> @@ -325,8 +305,10 @@ static int sdhci_cdns_execute_tuning(struct sdhci_host *host, u32 opcode)
> * The delay is set by probe, based on the DT properties.
> */
> if (host->timing != MMC_TIMING_MMC_HS200 &&
> - host->timing != MMC_TIMING_UHS_SDR104)
> + host->timing != MMC_TIMING_UHS_SDR104) {
> + dev_dbg(mmc_dev(host->mmc), "Tuning skipped (timing: %d)\n", host->timing);
> return 0;
> + }
>
> for (i = 0; i < SDHCI_CDNS_MAX_TUNING_LOOP; i++) {
> if (sdhci_cdns_set_tune_val(host, i) ||
> @@ -350,6 +332,10 @@ static int sdhci_cdns_execute_tuning(struct sdhci_host *host, u32 opcode)
> if (ret)
> return ret;
>
> + /* Block gap tuning is only required for SD4HC, not for SD6HC */
> + if (host->version >= SDHCI_SPEC_420)
> + return 0;
> +
> return sdhci_cdns_tune_blkgap(host->mmc);
> }
>
> @@ -385,6 +371,10 @@ static void sdhci_cdns_set_uhs_signaling(struct sdhci_host *host,
> /* For SD, fall back to the default handler */
> if (mode == SDHCI_CDNS_HRS06_MODE_SD)
> sdhci_set_uhs_signaling(host, timing);
> +
> + /* For host controller V6, set SDHCI and PHY registers for UHS signaling */
> + if (host->version >= SDHCI_SPEC_420)
> + sdhci_cdns6_set_uhs_signaling(host, timing);
> }
>
> /* Elba control register bits [6:3] are byte-lane enables */
> @@ -481,6 +471,16 @@ static const struct sdhci_ops sdhci_cdns4_ops = {
> .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
> };
>
> +static const struct sdhci_ops sdhci_cdns6_ops = {
> + .set_clock = sdhci_set_clock,
> + .get_timeout_clock = sdhci_cdns_get_timeout_clock,
> + .set_bus_width = sdhci_set_bus_width,
> + .reset = sdhci_reset,
> + .platform_execute_tuning = sdhci_cdns_execute_tuning,
> + .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
> + .hw_reset = sdhci_cdns6_hw_reset,
> +};
> +
> static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
> .pltfm_data = {
> .ops = &sdhci_cdns4_ops,
> @@ -508,6 +508,12 @@ static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
> },
> };
>
> +static const struct sdhci_cdns_drv_data sdhci_cdns6_drv_data = {
> + .pltfm_data = {
> + .ops = &sdhci_cdns6_ops,
> + },
> +};
> +
> static void sdhci_cdns_hs400_enhanced_strobe(struct mmc_host *mmc,
> struct mmc_ios *ios)
> {
> @@ -526,6 +532,10 @@ static void sdhci_cdns_hs400_enhanced_strobe(struct mmc_host *mmc,
> if (mode == SDHCI_CDNS_HRS06_MODE_MMC_HS400ES && !ios->enhanced_strobe)
> sdhci_cdns_set_emmc_mode(priv,
> SDHCI_CDNS_HRS06_MODE_MMC_HS400);
> +
> + /* SD6HC PHY timing depends on enhanced-strobe; recompute register values */
> + if (host->version >= SDHCI_SPEC_420)
> + sdhci_cdns6_set_uhs_signaling(host, MMC_TIMING_MMC_HS400);
The ->hs400_enhanced_strobe() callback is used to turn enhanced
strobe on and off e.g. called by mmc_set_initial_state() to turn
it off when the timing is MMC_TIMING_LEGACY, so the mode setting
here looks wrong.
> }
>
> static void sdhci_cdns_mmc_hw_reset(struct mmc_host *mmc)
> @@ -569,6 +579,7 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> struct sdhci_pltfm_host *pltfm_host;
> struct sdhci_cdns_priv *priv;
> struct clk *clk;
> + struct clk *biu_clk;
> int ret;
> struct device *dev = &pdev->dev;
> static const u16 version = SDHCI_SPEC_400 << SDHCI_SPEC_VER_SHIFT;
> @@ -577,6 +588,13 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> if (IS_ERR(clk))
> return PTR_ERR(clk);
>
> + /* SD6HC requires a second clock, "biu", for the bus interface unit. */
> + if (of_device_is_compatible(dev->of_node, "cdns,sd6hc")) {
> + biu_clk = devm_clk_get_enabled(dev, "biu");
> + if (IS_ERR(biu_clk))
> + return dev_err_probe(dev, PTR_ERR(biu_clk), "failed to enable biu clock\n");
> + }
> +
> data = of_device_get_match_data(dev);
> if (!data)
> return dev_err_probe(dev, -EINVAL, "missing platform driver data\n");
> @@ -601,30 +619,46 @@ static int sdhci_cdns_probe(struct platform_device *pdev)
> return ret;
> }
> sdhci_enable_v4_mode(host);
> - __sdhci_read_caps(host, &version, NULL, NULL);
> -
> sdhci_get_of_property(pdev);
>
> ret = mmc_of_parse(host->mmc);
> if (ret)
> return ret;
>
> - ret = sdhci_cdns4_phy_probe(pdev, priv);
> - if (ret)
> - return ret;
> + /*
> + * For SD4HC, read capabilities with fixed version override and set up
> + * the optional eMMC card RST_n reset control.
> + * For SD6HC, sdhci_add_host() will automatically read capabilities
> + * and version from the host controller registers.
> + */
> + if (of_device_is_compatible(dev->of_node, "cdns,sd4hc")) {
> + __sdhci_read_caps(host, &version, NULL, NULL);
> + ret = sdhci_cdns4_phy_probe(pdev, priv);
> + if (ret)
> + return ret;
>
> - if (host->mmc->caps & MMC_CAP_HW_RESET) {
> - priv->rst_hw = devm_reset_control_get_optional_exclusive(dev, NULL);
> - if (IS_ERR(priv->rst_hw))
> - return dev_err_probe(mmc_dev(host->mmc), PTR_ERR(priv->rst_hw),
> - "reset controller error\n");
> - if (priv->rst_hw)
> - host->mmc_host_ops.card_hw_reset = sdhci_cdns_mmc_hw_reset;
> + if (host->mmc->caps & MMC_CAP_HW_RESET) {
> + priv->rst_hw = devm_reset_control_get_optional_exclusive(dev, NULL);
> + if (IS_ERR(priv->rst_hw))
> + return dev_err_probe(mmc_dev(host->mmc), PTR_ERR(priv->rst_hw),
> + "reset controller error\n");
> + if (priv->rst_hw)
> + host->mmc_host_ops.card_hw_reset = sdhci_cdns_mmc_hw_reset;
> + }
> + } else {
> + ret = sdhci_cdns6_phy_probe(pdev, priv);
> + if (ret)
> + return ret;
> }
>
> return sdhci_add_host(host);
> }
>
> +/*
> + * Only the CIU clock is gated on suspend. The SD6HC "biu" clock is not
> + * toggled here as it may be a shared bus clock; a dedicated biu clock
> + * would need explicit PM gating added here.
> + */
> static int sdhci_cdns_resume(struct device *dev)
> {
> struct sdhci_host *host = dev_get_drvdata(dev);
> @@ -636,7 +670,11 @@ static int sdhci_cdns_resume(struct device *dev)
> if (ret)
> return ret;
>
> - ret = sdhci_cdns4_phy_init(priv);
> + if (host->version >= SDHCI_SPEC_420)
> + ret = sdhci_cdns6_phy_init(priv);
> + else
> + ret = sdhci_cdns4_phy_init(priv);
> +
> if (ret)
> goto disable_clk;
>
> @@ -671,6 +709,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
> .compatible = "cdns,sd4hc",
> .data = &sdhci_cdns4_drv_data,
> },
> + {
> + .compatible = "cdns,sd6hc",
> + .data = &sdhci_cdns6_drv_data,
> + },
> { /* sentinel */ }
> };
> MODULE_DEVICE_TABLE(of, sdhci_cdns_match);
> diff --git a/drivers/mmc/host/sdhci-cadence-phy-v6.c b/drivers/mmc/host/sdhci-cadence-phy-v6.c
> new file mode 100644
> index 000000000000..2d7972948a45
> --- /dev/null
> +++ b/drivers/mmc/host/sdhci-cadence-phy-v6.c
> @@ -0,0 +1,929 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * PHY and host controller support for Cadence SD6HC SDHCI
> + *
> + * This file provides support for Cadence's sixth-generation SDHCI controller (SD6HC).
> + * Implements PHY initialization, DLL management, per-speed-mode timing calculations,
> + * and host controller register programming for the SD6HC integrated combo-PHY.
> + *
> + * Copyright (C) 2026 Altera Corporation
> + * Author: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
> + */
> +
> +#include <linux/bitfield.h>
> +#include <linux/bits.h>
> +#include <linux/iopoll.h>
> +#include <linux/of.h>
> +
> +#include "sdhci-cadence.h"
> +
> +/* IO Delay Information */
> +#define SDHCI_CDNS_HRS07 0x1c
> +#define SDHCI_CDNS_HRS07_RW_COMPENSATE GENMASK(20, 16)
> +#define SDHCI_CDNS_HRS07_IDELAY_VAL GENMASK(4, 0)
> +
> +/* PHY Control and Status */
> +#define SDHCI_CDNS_HRS09 0x24
> +#define SDHCI_CDNS_HRS09_RDDATA_EN BIT(16)
> +#define SDHCI_CDNS_HRS09_RDCMD_EN BIT(15)
> +#define SDHCI_CDNS_HRS09_EXTENDED_WR_MODE BIT(3)
> +#define SDHCI_CDNS_HRS09_EXTENDED_RD_MODE BIT(2)
> +#define SDHCI_CDNS_HRS09_PHY_INIT_COMPLETE BIT(1)
> +#define SDHCI_CDNS_HRS09_PHY_SW_RESET BIT(0)
> +
> +/* SDCLK start point adjustment */
> +#define SDHCI_CDNS_HRS10 0x28
> +#define SDHCI_CDNS_HRS10_HCSDCLKADJ GENMASK(19, 16)
> +
> +/* eMMC Control */
> +#define SDHCI_CDNS_HRS11 0x2c
> +#define SDHCI_CDNS_HRS11_EMMC_RST BIT(0) /* eMMC reset */
> +
> +/* CMD/DAT output delay */
> +#define SDHCI_CDNS_HRS16 0x40
> +#define SDHCI_CDNS_HRS16_WRDATA1_SDCLK_DLY GENMASK(31, 28)
> +#define SDHCI_CDNS_HRS16_WRDATA0_SDCLK_DLY GENMASK(27, 24)
> +#define SDHCI_CDNS_HRS16_WRCMD1_SDCLK_DLY GENMASK(23, 20)
> +#define SDHCI_CDNS_HRS16_WRCMD0_SDCLK_DLY GENMASK(19, 16)
> +#define SDHCI_CDNS_HRS16_WRDATA1_DLY GENMASK(15, 12)
> +#define SDHCI_CDNS_HRS16_WRDATA0_DLY GENMASK(11, 8)
> +#define SDHCI_CDNS_HRS16_WRCMD1_DLY GENMASK(7, 4)
> +#define SDHCI_CDNS_HRS16_WRCMD0_DLY GENMASK(3, 0)
> +
> +/* PHY Special Function Registers */
> +/* DQ timing */
> +#define SDHCI_CDNS6_PHY_DQ_TIMING_REG 0x2000
> +#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_ALWAYS_ON BIT(31)
> +#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END GENMASK(29, 27)
> +#define SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START GENMASK(26, 24)
> +#define SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END GENMASK(2, 0)
> +
> +/* DQS timing */
> +#define SDHCI_CDNS6_PHY_DQS_TIMING_REG 0x2004
> +#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_EXT_LPBK_DQS BIT(22)
> +#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_LPBK_DQS BIT(21)
> +#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS BIT(20)
> +#define SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD BIT(19)
> +
> +/* Gate and loopback control */
> +#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG 0x2008
> +#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_SYNC_METHOD BIT(31)
> +#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL GENMASK(24, 19)
> +#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_UNDERRUN_SUPPRESS BIT(18)
> +#define SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_GATE_CFG_ALWAYS_ON BIT(6)
> +
> +/* Master DLL logic */
> +#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_REG 0x200c
> +#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_BYPASS_MODE BIT(23)
> +#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_PHASE_DETECT_SEL GENMASK(22, 20)
> +#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_LOCK_NUM GENMASK(18, 16)
> +#define SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_START_POINT GENMASK(7, 0)
> +
> +/* Slave DLL logic */
> +#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_REG 0x2010
> +#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_CMD_DELAY GENMASK(31, 24)
> +#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WRDQS_DELAY GENMASK(23, 16)
> +#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WR_DELAY GENMASK(15, 8)
> +#define SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_DELAY GENMASK(7, 0)
> +
> +/* Global control settings */
> +#define SDHCI_CDNS6_PHY_CTRL_REG 0x2080
> +#define SDHCI_CDNS6_PHY_CTRL_PHONY_DQS_TIMING GENMASK(9, 4)
> +
> +/* Default PHY settings */
> +#define SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY 2500
> +#define SDHCI_CDNS6_PHY_DEFAULT_DELAY_ELEMENT 24
> +#define SDHCI_CDNS6_PHY_DEFAULT_RD_DEL_SEL 52
> +#define SDHCI_CDNS6_PHY_DEFAULT_DLL_START 4
> +#define SDHCI_CDNS6_PHY_DEFAULT_PHASE_DETECT_SEL 2
> +#define SDHCI_CDNS6_PHY_DEFAULT_DLL_LOCK_NUM 0
> +#define SDHCI_CDNS6_PHY_DEFAULT_DATA_SELECT_OE_END 1
> +
> +/* Scale tuning tap (0..39) to 8-bit PHY DLL delay field (0..255) */
> +#define SDHCI_CDNS6_PHY_DLL_FIELD_SIZE 256
> +
> +struct sdhci_cdns6_phy {
> + /*
> + * Mode-specific timing constraints (in picoseconds)
> + * These define valid output windows per SD/eMMC spec
> + */
> + u32 t_cmd_output_min;
> + u32 t_cmd_output_max;
> + u32 t_dat_output_min;
> + u32 t_dat_output_max;
> +
> + /*
> + * PHY delay configuration (in picoseconds)
> + * Derived from clock period and board-level IO cell delays
> + */
> + u32 phy_sdclk_delay;
> + u32 phy_cmd_o_delay;
> + u32 phy_dat_o_delay;
> + u32 iocell_input_delay;
> + u32 iocell_output_delay;
> + /* Configured delay element (ps); preserved across clock changes */
> + u32 delay_element_org;
> + /* Active delay element (ps); doubled when one SDMCLK requires > 256 steps */
> + u32 delay_element;
> +
> + /* PHY_DLL_SLAVE_CTRL register fields */
> + u8 cp_read_dqs_cmd_delay; /* bits [31:24] */
> + u8 cp_clk_wrdqs_delay; /* bits [23:16] */
> + u8 cp_clk_wr_delay; /* bits [15:8] */
> + u8 cp_read_dqs_delay; /* bits [7:0] */
> +
> + /* PHY_DLL_MASTER_CTRL register fields */
> + bool cp_dll_bypass_mode; /* bit [23] */
> +
> + /* PHY_DQ_TIMING register fields */
> + u8 cp_io_mask_end; /* bits [29:27] */
> + u8 cp_io_mask_start; /* bits [26:24] */
> +
> + /* PHY_DQS_TIMING register fields */
> + bool cp_use_phony_dqs; /* bit [20] */
> + bool cp_use_phony_dqs_cmd; /* bit [19] */
> +
> + /* HRS07 register - IO delay Information */
> + u8 sdhc_rw_compensate; /* bits [20:16] */
> + u8 sdhc_idelay_val; /* bits [4:0] */
> +
> + /* HRS09 register - PHY control and Status */
> + bool sdhc_extended_wr_mode; /* bit [3] */
> + bool sdhc_extended_rd_mode; /* bit [2] */
> +
> + /* HRS10 register - SDCLK start point adjustment */
> + u8 sdhc_hcsdclkadj; /* bits [19:16] */
> +
> + /* HRS16 register fields - CMD/DAT output delay control */
> + u8 sdhc_wrdata1_sdclk_dly; /* bits [31:28] */
> + u8 sdhc_wrdata0_sdclk_dly; /* bits [27:24] */
> + u8 sdhc_wrcmd1_sdclk_dly; /* bits [23:20] */
> + u8 sdhc_wrcmd0_sdclk_dly; /* bits [19:16] */
> + u8 sdhc_wrdata1_dly; /* bits [15:12] */
> + u8 sdhc_wrdata0_dly; /* bits [11:8] */
> + u8 sdhc_wrcmd1_dly; /* bits [7:4] */
> + u8 sdhc_wrcmd0_dly; /* bits [3:0] */
> +
> + /* DLL calculation intermediate values, used during PHY timing calculations */
> + u32 t_sdmclk_calc; /* DLL-quantized SDMCLK period */
> + u32 dll_max_value; /* DLL delay field ceiling */
> +
> + /* Tuning value for HS200/HS400 modes */
> + u8 hs200_tune_val;
> +
> + /* Clock periods (in picoseconds) */
> + u32 t_sdmclk; /* Master clock period */
> + u32 t_sdclk; /* SD card clock period */
> +
> + /* Current operating state */
> + bool strobe_cmd; /* Enhanced strobe for CMD line */
> + unsigned int mode; /* Current MMC_TIMING_* mode */
> +};
> +
> +/**
> + * init_ds() - Initialize PHY timing for Default Speed mode (25 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_ds(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 5000;
> + phy->t_cmd_output_max = t_sdclk - 5000;
> + phy->t_dat_output_min = 5000;
> + phy->t_dat_output_max = t_sdclk - 5000;
> +}
> +
> +/**
> + * init_hs() - Initialize PHY timing for High Speed mode (50 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_hs(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 2000;
> + phy->t_cmd_output_max = t_sdclk - 6000;
> + phy->t_dat_output_min = 2000;
> + phy->t_dat_output_max = t_sdclk - 6000;
> +}
> +
> +/**
> + * init_uhs_sdr12() - Initialize PHY timing for UHS SDR12 mode (25 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_uhs_sdr12(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 3000;
> +}
> +
> +/**
> + * init_uhs_sdr25() - Initialize PHY timing for UHS SDR25 mode (50 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_uhs_sdr25(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 3000;
> +}
> +
> +/**
> + * init_uhs_sdr50() - Initialize PHY timing for UHS SDR50 mode (100 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_uhs_sdr50(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 3000;
> +}
> +
> +/**
> + * init_uhs_sdr104() - Initialize PHY timing for UHS SDR104 mode (200 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_uhs_sdr104(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 1400;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 1400;
> +}
> +
> +/**
> + * init_uhs_ddr50() - Initialize PHY timing for UHS DDR50 mode (50 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_uhs_ddr50(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 3000;
> +}
> +
> +/**
> + * init_emmc_sdr() - Initialize PHY timing for eMMC legacy/SDR mode.
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_emmc_sdr(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 3000;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 3000;
> + phy->t_dat_output_max = t_sdclk - 3000;
> +}
> +
> +/**
> + * init_emmc_ddr() - Initialize PHY timing for eMMC DDR52 mode.
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_emmc_ddr(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 3000;
> + phy->t_cmd_output_max = t_sdclk - 3000;
> + phy->t_dat_output_min = 2500;
> + phy->t_dat_output_max = t_sdclk - 2500;
> +}
> +
> +/**
> + * init_emmc_hs200() - Initialize PHY timing for eMMC HS200 mode (200 MHz).
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_emmc_hs200(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 1400;
> + phy->t_dat_output_min = 800;
> + phy->t_dat_output_max = t_sdclk - 1400;
> +}
> +
> +/**
> + * init_emmc_hs400() - Initialize PHY timing for eMMC HS400/HS400ES mode.
> + * @phy: Pointer to SD6HC PHY state.
> + * @t_sdclk: SD clock period in picoseconds.
> + */
> +static void init_emmc_hs400(struct sdhci_cdns6_phy *phy, u32 t_sdclk)
> +{
> + phy->t_cmd_output_min = 800;
> + phy->t_cmd_output_max = t_sdclk - 1400;
> + phy->t_dat_output_min = 400;
> + phy->t_dat_output_max = t_sdclk - 400;
> +}
> +
> +/*
> + * init_timings - PHY timing initializers indexed by MMC_TIMING_* value.
> + *
> + * Each entry corresponds to a MMC_TIMING_* constant and sets the appropriate cmd/dat
> + * output timing windows in the PHY state struct.
> + */
> +static void (* const init_timings[])(struct sdhci_cdns6_phy *, u32) = {
> + [MMC_TIMING_LEGACY] = init_ds,
> + [MMC_TIMING_MMC_HS] = init_emmc_sdr,
> + [MMC_TIMING_SD_HS] = init_hs,
> + [MMC_TIMING_UHS_SDR12] = init_uhs_sdr12,
> + [MMC_TIMING_UHS_SDR25] = init_uhs_sdr25,
> + [MMC_TIMING_UHS_SDR50] = init_uhs_sdr50,
> + [MMC_TIMING_UHS_SDR104] = init_uhs_sdr104,
> + [MMC_TIMING_UHS_DDR50] = init_uhs_ddr50,
> + [MMC_TIMING_MMC_DDR52] = init_emmc_ddr,
> + [MMC_TIMING_MMC_HS200] = init_emmc_hs200,
> + [MMC_TIMING_MMC_HS400] = init_emmc_hs400,
> +};
> +
> +static unsigned int sdhci_cdns6_read_phy_reg(struct sdhci_cdns_priv *priv, const u32 address)
> +{
> + writel(address, priv->hrs_addr + SDHCI_CDNS_HRS04);
> + return readl(priv->hrs_addr + SDHCI_CDNS_HRS05);
> +}
> +
> +static void sdhci_cdns6_write_phy_reg(struct sdhci_cdns_priv *priv, const u32 address,
> + const u32 value)
> +{
> + writel(address, priv->hrs_addr + SDHCI_CDNS_HRS04);
> + writel(value, priv->hrs_addr + SDHCI_CDNS_HRS05);
> +}
> +
> +static int sdhci_cdns6_phy_lock_dll(struct sdhci_cdns6_phy *phy)
> +{
> + u32 delay_element = phy->delay_element_org;
> + u32 delay_elements_in_sdmclk;
> +
> + delay_elements_in_sdmclk = DIV_ROUND_UP(phy->t_sdmclk, delay_element);
> + if (delay_elements_in_sdmclk > 256) {
> + delay_element *= 2;
> + delay_elements_in_sdmclk = DIV_ROUND_UP(phy->t_sdmclk, delay_element);
> +
> + if (delay_elements_in_sdmclk > 256)
> + return -EINVAL;
> +
> + phy->dll_max_value = 127;
> + } else {
> + phy->dll_max_value = 255;
> + }
> +
> + phy->t_sdmclk_calc = delay_element * delay_elements_in_sdmclk;
> + phy->delay_element = delay_element;
> + phy->cp_dll_bypass_mode = false;
> +
> + return 0;
> +}
> +
> +static void sdhci_cdns6_phy_dll_bypass(struct sdhci_cdns6_phy *phy)
> +{
> + phy->dll_max_value = 256;
> + phy->cp_dll_bypass_mode = true;
> +}
> +
> +static void sdhci_cdns6_phy_configure_dll(struct sdhci_cdns6_phy *phy)
> +{
> + if (!phy->sdhc_extended_wr_mode) {
> + if (sdhci_cdns6_phy_lock_dll(phy) == 0)
> + return;
> + }
> + sdhci_cdns6_phy_dll_bypass(phy);
> +}
> +
> +static void sdhci_cdns6_phy_calc_out(struct sdhci_cdns6_phy *phy, bool cmd_not_dat)
> +{
> + u32 wr0_dly = 0, wr1_dly = 0, output_min, output_max, phy_o_delay,
> + clk_wr_delay = 0, wr0_sdclk_dly = 0, wr1_sdclk_dly = 0;
> + bool ddr = (phy->mode == MMC_TIMING_UHS_DDR50) || (phy->mode == MMC_TIMING_MMC_DDR52) ||
> + (phy->mode == MMC_TIMING_MMC_HS400);
> + bool data_ddr = ddr && !cmd_not_dat;
> + int t;
> +
> + if (cmd_not_dat) {
> + output_min = phy->t_cmd_output_min;
> + output_max = phy->t_cmd_output_max;
> + phy_o_delay = phy->phy_cmd_o_delay;
> + } else {
> + output_min = phy->t_dat_output_min;
> + output_max = phy->t_dat_output_max;
> + phy_o_delay = phy->phy_dat_o_delay;
> + }
> +
> + if (data_ddr) {
> + wr0_sdclk_dly = 1;
> + wr1_sdclk_dly = 1;
> + }
> +
> + t = phy_o_delay - phy->phy_sdclk_delay - output_min;
> + if (t < 0 && phy->sdhc_extended_wr_mode) {
> + u32 n_half_cycle = DIV_ROUND_UP(-t * 2, phy->t_sdmclk);
> +
> + wr0_dly = (n_half_cycle + 1) / 2;
> + if (data_ddr)
> + wr1_dly = (n_half_cycle + 1) / 2;
> + else
> + wr1_dly = (n_half_cycle + 1) % 2 + wr0_dly - 1;
> + }
> +
> + if (!phy->sdhc_extended_wr_mode) {
> + u32 out_hold, out_setup, out_hold_margin;
> + u32 n;
> +
> + if (!data_ddr)
> + wr0_dly = 1;
> +
> + out_setup = output_max;
> + out_hold = output_min;
> + out_hold_margin = DIV_ROUND_UP(out_setup - out_hold, 4);
> + out_hold += out_hold_margin;
> +
> + if (!phy->cp_dll_bypass_mode)
> + n = DIV_ROUND_UP(256 * out_hold, phy->t_sdmclk_calc);
> + else
> + n = DIV_ROUND_UP(out_hold, phy->delay_element) - 1;
> +
> + if (n <= phy->dll_max_value)
> + clk_wr_delay = n;
> + else
> + clk_wr_delay = 255;
> + } else {
> + /* sdhc_extended_wr_mode set => PHY IO cell work in SDR mode */
> + clk_wr_delay = 0;
> + }
> +
> + if (cmd_not_dat) {
> + phy->sdhc_wrcmd0_dly = wr0_dly;
> + phy->sdhc_wrcmd1_dly = wr1_dly;
> + phy->cp_clk_wrdqs_delay = clk_wr_delay;
> + phy->sdhc_wrcmd0_sdclk_dly = wr0_sdclk_dly;
> + phy->sdhc_wrcmd1_sdclk_dly = wr1_sdclk_dly;
> + } else {
> + phy->sdhc_wrdata0_dly = wr0_dly;
> + phy->sdhc_wrdata1_dly = wr1_dly;
> + phy->cp_clk_wr_delay = clk_wr_delay;
> + phy->sdhc_wrdata0_sdclk_dly = wr0_sdclk_dly;
> + phy->sdhc_wrdata1_sdclk_dly = wr1_sdclk_dly;
> + }
> +}
> +
> +static void sdhci_cdns6_phy_calc_cmd_out(struct sdhci_cdns6_phy *phy)
> +{
> + sdhci_cdns6_phy_calc_out(phy, true);
> +}
> +
> +static void sdhci_cdns6_phy_calc_cmd_in(struct sdhci_cdns6_phy *phy)
> +{
> + phy->cp_io_mask_end = ((phy->iocell_output_delay + phy->iocell_input_delay) * 2) /
> + phy->t_sdmclk;
> +
> + /* cp_io_mask_end is a 3-bit field, clamp to max value of 7 */
> + phy->cp_io_mask_end = min_t(u8, phy->cp_io_mask_end, 7);
> +
> + if (phy->strobe_cmd && phy->cp_io_mask_end > 0)
> + phy->cp_io_mask_end--;
> +
> + if (phy->strobe_cmd) {
> + phy->cp_use_phony_dqs_cmd = false;
> + phy->cp_read_dqs_cmd_delay = 64;
> + } else {
> + phy->cp_use_phony_dqs_cmd = true;
> + phy->cp_read_dqs_cmd_delay = 0;
> + }
> +
> + if ((phy->mode == MMC_TIMING_MMC_HS400 && !phy->strobe_cmd) ||
> + phy->mode == MMC_TIMING_MMC_HS200)
> + phy->cp_read_dqs_cmd_delay = phy->hs200_tune_val;
> +}
> +
> +static void sdhci_cdns6_phy_calc_dat_in(struct sdhci_cdns6_phy *phy)
> +{
> + u32 hcsdclkadj = 0;
> + bool strobe_dat = (phy->mode == MMC_TIMING_MMC_HS400);
> +
> + if (strobe_dat) {
> + phy->cp_use_phony_dqs = false;
> + phy->cp_read_dqs_delay = 64;
> + } else {
> + phy->cp_use_phony_dqs = true;
> + phy->cp_read_dqs_delay = 0;
> + }
> +
> + if (phy->mode == MMC_TIMING_MMC_HS200)
> + phy->cp_read_dqs_delay = phy->hs200_tune_val;
> +
> + if (strobe_dat) {
> + /* dqs loopback input via IO cell */
> + hcsdclkadj += phy->iocell_input_delay;
> + /* dfi_dqs_in: mem_dqs -> clean_dqs_mod; delay of hic_dll_dqs_nand2 */
> + hcsdclkadj += phy->delay_element / 2;
> + /* delay line */
> + hcsdclkadj += phy->t_sdclk / 2;
> + /* PHY FIFO write pointer */
> + hcsdclkadj += phy->t_sdclk / 2 + phy->delay_element;
> + /* 1st synchronizer */
> + hcsdclkadj += DIV_ROUND_UP(hcsdclkadj, phy->t_sdmclk) * phy->t_sdmclk - hcsdclkadj;
> + /*
> + * 2nd synchronizer + PHY FIFO read pointer + PHY rddata
> + * + PHY rddata registered, + FIFO 1st ciu_en
> + */
> + hcsdclkadj += 5 * phy->t_sdmclk;
> + /* FIFO 2nd ciu_en */
> + hcsdclkadj += phy->t_sdclk;
> + hcsdclkadj /= phy->t_sdclk;
> + } else {
> + u32 n;
> +
> + /* rebar PHY delay */
> + hcsdclkadj += 2 * phy->t_sdmclk;
> + /* rebar output via IO cell */
> + hcsdclkadj += phy->iocell_output_delay;
> + /* dqs loopback input via IO cell */
> + hcsdclkadj += phy->iocell_input_delay;
> + /* dfi_dqs_in: mem_dqs -> clean_dqs_mod delay of hic_dll_dqs_nand2 */
> + hcsdclkadj += phy->delay_element / 2;
> + /* dll: one delay element between SIGI_0 and SIGO_0 */
> + hcsdclkadj += phy->delay_element;
> + /* dfi_dqs_in: mem_dqs_delayed -> clk_dqs delay of hic_dll_dqs_nand2 */
> + hcsdclkadj += phy->delay_element / 2;
> + /* deskew DLL: clk_dqs -> clk_dqN: one delay element */
> + hcsdclkadj += phy->delay_element;
> +
> + if (phy->t_sdclk == phy->t_sdmclk)
> + n = (hcsdclkadj - 2 * phy->t_sdmclk) / phy->t_sdclk;
> + else
> + n = hcsdclkadj / phy->t_sdclk;
> +
> + /* phase shift within one t_sdclk clock cycle caused by rebar - lbk dqs delay */
> + hcsdclkadj = hcsdclkadj % phy->t_sdclk;
> + /* PHY FIFO write pointer */
> + hcsdclkadj += phy->t_sdclk / 2;
> + /* 1st synchronizer */
> + hcsdclkadj += DIV_ROUND_UP(hcsdclkadj, phy->t_sdmclk) * phy->t_sdmclk - hcsdclkadj;
> + /*
> + * 2nd synchronizer + PHY FIFO read pointer + PHY rddata + PHY rddata registered
> + */
> + hcsdclkadj += 4 * phy->t_sdmclk;
> +
> + if ((phy->t_sdclk / phy->t_sdmclk) > 1) {
> + u32 tmp1, tmp2;
> +
> + tmp1 = hcsdclkadj;
> + tmp2 = (hcsdclkadj / phy->t_sdclk) * phy->t_sdclk + phy->t_sdclk -
> + phy->t_sdmclk;
> + if (tmp1 == tmp2)
> + tmp2 += phy->t_sdclk;
> +
> + /* FIFO aligns to clock cycle before ciu_en */
> + hcsdclkadj += tmp2 - tmp1;
> + }
> +
> + /* FIFO 1st ciu_en */
> + hcsdclkadj += phy->t_sdmclk;
> + /* FIFO 2nd ciu_en */
> + hcsdclkadj += phy->t_sdclk;
> + hcsdclkadj /= phy->t_sdclk;
> + hcsdclkadj += n;
> +
> + if ((phy->t_sdclk / phy->t_sdmclk) >= 2) {
> + if (phy->mode == MMC_TIMING_UHS_DDR50 || phy->mode == MMC_TIMING_MMC_DDR52)
> + hcsdclkadj -= 2;
> + else
> + hcsdclkadj -= 1;
> + } else if ((phy->t_sdclk / phy->t_sdmclk) == 1) {
> + hcsdclkadj += 2;
> + }
> +
> + if (phy->mode == MMC_TIMING_UHS_SDR104 || phy->mode == MMC_TIMING_MMC_HS200)
> + hcsdclkadj -= 1;
> + }
> +
> + /* hcsdclkadj is a 4-bit field, clamp to max value of 15 */
> + if (hcsdclkadj > 15)
> + hcsdclkadj = 15;
> +
> + phy->sdhc_hcsdclkadj = hcsdclkadj;
> +}
> +
> +static void sdhci_cdns6_phy_calc_dat_out(struct sdhci_cdns6_phy *phy)
> +{
> + sdhci_cdns6_phy_calc_out(phy, false);
> +}
> +
> +static void sdhci_cdns6_phy_calc_io(struct sdhci_cdns6_phy *phy)
> +{
> + u32 rw_compensate;
> +
> + rw_compensate = ((phy->iocell_input_delay + phy->iocell_output_delay) / phy->t_sdmclk) +
> + phy->sdhc_wrdata0_dly + 5 + 3;
> +
> + phy->sdhc_idelay_val = (2 * phy->iocell_input_delay) / phy->t_sdmclk;
> +
> + phy->cp_io_mask_start = 0;
> + if (phy->t_sdclk == phy->t_sdmclk && rw_compensate > 10)
> + phy->cp_io_mask_start = 2 * (rw_compensate - 10);
> +
> + if (phy->mode == MMC_TIMING_UHS_SDR104)
> + phy->cp_io_mask_start++;
> +
> + if (phy->t_sdclk == phy->t_sdmclk && phy->mode == MMC_TIMING_UHS_SDR50)
> + phy->cp_io_mask_start++;
> +
> + /* cp_io_mask_start is a 3-bit field, clamp to max value of 7 */
> + phy->cp_io_mask_start = min_t(u8, phy->cp_io_mask_start, 7);
> +
> + phy->sdhc_rw_compensate = rw_compensate;
> +}
> +
> +static void sdhci_cdns6_phy_calc_settings(struct sdhci_cdns6_phy *phy)
> +{
> + sdhci_cdns6_phy_calc_cmd_out(phy);
> + sdhci_cdns6_phy_calc_cmd_in(phy);
> + sdhci_cdns6_phy_calc_dat_out(phy);
> + sdhci_cdns6_phy_calc_dat_in(phy);
> + sdhci_cdns6_phy_calc_io(phy);
> +}
> +
> +static int sdhci_cdns6_dll_reset(struct sdhci_cdns_priv *priv, bool reset)
> +{
> + u32 reg;
> + int ret = 0;
> +
> + reg = readl(priv->hrs_addr + SDHCI_CDNS_HRS09);
> + if (reset)
> + reg &= ~SDHCI_CDNS_HRS09_PHY_SW_RESET;
> + else
> + reg |= SDHCI_CDNS_HRS09_PHY_SW_RESET;
> +
> + writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS09);
> +
> + /* After releasing PHY from reset, wait until PHY_INIT_COMPLETE is set within 3000us */
> + if (!reset) {
> + ret = readl_poll_timeout(priv->hrs_addr + SDHCI_CDNS_HRS09, reg, (reg &
> + SDHCI_CDNS_HRS09_PHY_INIT_COMPLETE), 0, 3000);
> + }
> +
> + return ret;
> +}
> +
> +int sdhci_cdns6_phy_init(struct sdhci_cdns_priv *priv)
> +{
> + struct sdhci_cdns6_phy *phy = priv->phy;
> + u32 reg;
> + int ret;
> +
> + sdhci_cdns6_dll_reset(priv, true);
> +
> + reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_DQS_TIMING_REG);
> + reg &= ~SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS;
> + reg &= ~SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD;
> + reg |= SDHCI_CDNS6_PHY_DQS_TIMING_USE_EXT_LPBK_DQS;
> + reg |= SDHCI_CDNS6_PHY_DQS_TIMING_USE_LPBK_DQS;
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS, phy->cp_use_phony_dqs);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQS_TIMING_USE_PHONY_DQS_CMD, phy->cp_use_phony_dqs_cmd);
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DQS_TIMING_REG, reg);
> +
> + reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG);
> + reg &= ~SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL;
> + reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_UNDERRUN_SUPPRESS;
> + reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_GATE_CFG_ALWAYS_ON;
> + reg |= SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_SYNC_METHOD;
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_RD_DEL_SEL,
> + SDHCI_CDNS6_PHY_DEFAULT_RD_DEL_SEL);
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_GATE_LPBK_CTRL_REG, reg);
> +
> + reg = FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_BYPASS_MODE, phy->cp_dll_bypass_mode);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_PHASE_DETECT_SEL,
> + SDHCI_CDNS6_PHY_DEFAULT_PHASE_DETECT_SEL);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_LOCK_NUM,
> + SDHCI_CDNS6_PHY_DEFAULT_DLL_LOCK_NUM);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_DLL_START_POINT,
> + SDHCI_CDNS6_PHY_DEFAULT_DLL_START);
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DLL_MASTER_CTRL_REG, reg);
> +
> + reg = FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_CMD_DELAY,
> + phy->cp_read_dqs_cmd_delay);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WRDQS_DELAY, phy->cp_clk_wrdqs_delay);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_CLK_WR_DELAY, phy->cp_clk_wr_delay);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_READ_DQS_DELAY, phy->cp_read_dqs_delay);
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DLL_SLAVE_CTRL_REG, reg);
> +
> + reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_CTRL_REG);
> + reg &= ~SDHCI_CDNS6_PHY_CTRL_PHONY_DQS_TIMING;
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_CTRL_REG, reg);
> +
> + /*
> + * Ensure all preceding PHY register writes complete and reach the controller before
> + * releasing the PHY from reset. Without this, SDR104 has been observed to fail
> + * intermittently on some boards.
> + */
> + wmb();
> +
> + ret = sdhci_cdns6_dll_reset(priv, false);
> + if (ret)
> + return ret;
> +
> + reg = sdhci_cdns6_read_phy_reg(priv, SDHCI_CDNS6_PHY_DQ_TIMING_REG);
> + reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_ALWAYS_ON;
> + reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END;
> + reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START;
> + reg &= ~SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END;
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_END, phy->cp_io_mask_end);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_IO_MASK_START, phy->cp_io_mask_start);
> + reg |= FIELD_PREP(SDHCI_CDNS6_PHY_DQ_TIMING_DATA_SELECT_OE_END,
> + SDHCI_CDNS6_PHY_DEFAULT_DATA_SELECT_OE_END);
> + sdhci_cdns6_write_phy_reg(priv, SDHCI_CDNS6_PHY_DQ_TIMING_REG, reg);
> +
> + /* Ensure DQ timing programming is visible before HRS09 follow-up writes */
> + wmb();
> +
> + reg = readl(priv->hrs_addr + SDHCI_CDNS_HRS09);
> + if (phy->sdhc_extended_wr_mode)
> + reg |= SDHCI_CDNS_HRS09_EXTENDED_WR_MODE;
> + else
> + reg &= ~SDHCI_CDNS_HRS09_EXTENDED_WR_MODE;
> +
> + if (phy->sdhc_extended_rd_mode)
> + reg |= SDHCI_CDNS_HRS09_EXTENDED_RD_MODE;
> + else
> + reg &= ~SDHCI_CDNS_HRS09_EXTENDED_RD_MODE;
> +
> + reg |= SDHCI_CDNS_HRS09_RDDATA_EN;
> + reg |= SDHCI_CDNS_HRS09_RDCMD_EN;
> + writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS09);
> +
> + reg = FIELD_PREP(SDHCI_CDNS_HRS10_HCSDCLKADJ, phy->sdhc_hcsdclkadj);
> + writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS10);
> +
> + reg = FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA1_SDCLK_DLY, phy->sdhc_wrdata1_sdclk_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA0_SDCLK_DLY, phy->sdhc_wrdata0_sdclk_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD1_SDCLK_DLY, phy->sdhc_wrcmd1_sdclk_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD0_SDCLK_DLY, phy->sdhc_wrcmd0_sdclk_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA1_DLY, phy->sdhc_wrdata1_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRDATA0_DLY, phy->sdhc_wrdata0_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD1_DLY, phy->sdhc_wrcmd1_dly);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS16_WRCMD0_DLY, phy->sdhc_wrcmd0_dly);
> + writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS16);
> +
> + reg = FIELD_PREP(SDHCI_CDNS_HRS07_RW_COMPENSATE, phy->sdhc_rw_compensate);
> + reg |= FIELD_PREP(SDHCI_CDNS_HRS07_IDELAY_VAL, phy->sdhc_idelay_val);
> + writel(reg, priv->hrs_addr + SDHCI_CDNS_HRS07);
> +
> + /* Allow 5 to 5.5 ms for clock and PHY signals to stabilize after configuration */
> + usleep_range(5000, 5500);
> +
> + return 0;
> +}
> +
> +int sdhci_cdns6_set_tune_val(struct sdhci_host *host, unsigned int val)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + struct sdhci_cdns6_phy *phy = priv->phy;
> + u32 tuneval;
> +
> + /*
> + * Scale tuning tap (val in [0, SDHCI_CDNS_MAX_TUNING_LOOP-1]) to the
> + * 8-bit PHY DLL slave delay field [0, 255]. With MAX_TUNING_LOOP=40
> + * and FIELD_SIZE=256, the result fits in 8 bits.
> + *
> + * Updating the DLL slave delays also requires a PHY DLL reset cycle,
> + * so reuse the full phy_init() sequence rather than a register poke.
> + */
> + tuneval = (val * SDHCI_CDNS6_PHY_DLL_FIELD_SIZE) / SDHCI_CDNS_MAX_TUNING_LOOP;
> +
> + phy->hs200_tune_val = tuneval;
> + phy->cp_read_dqs_cmd_delay = tuneval;
> + phy->cp_read_dqs_delay = tuneval;
> +
> + return sdhci_cdns6_phy_init(priv);
> +}
> +
> +static int sdhci_cdns6_phy_update_timings(struct sdhci_host *host)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + struct sdhci_cdns6_phy *phy = priv->phy;
> + u32 t_sdmclk = phy->t_sdmclk;
> +
> + /* Validate mode is within supported range */
> + if (phy->mode >= ARRAY_SIZE(init_timings))
> + return -EINVAL;
> +
> + /* initialize input */
> + init_timings[phy->mode](phy, phy->t_sdclk);
> +
> + phy->strobe_cmd = false;
> +
> + if (priv->enhanced_strobe)
> + phy->strobe_cmd = true;
> +
> + phy->phy_sdclk_delay = 2 * t_sdmclk;
> +
> + /*
> + * CMD and DAT output delays are currently identical, but kept separate to allow
> + * independent tuning for specific modes (e.g., HS400) or board-specific optimizations
> + * in the future.
> + */
> + phy->phy_cmd_o_delay = 2 * t_sdmclk + t_sdmclk / 2;
> + phy->phy_dat_o_delay = 2 * t_sdmclk + t_sdmclk / 2;
> +
> + if (phy->t_sdclk == phy->t_sdmclk) {
> + phy->sdhc_extended_wr_mode = false;
> + phy->sdhc_extended_rd_mode = false;
> + } else {
> + phy->sdhc_extended_wr_mode = true;
> + phy->sdhc_extended_rd_mode = true;
> + }
> +
> + sdhci_cdns6_phy_configure_dll(phy);
> + sdhci_cdns6_phy_calc_settings(phy);
> +
> + return 0;
> +}
> +
> +int sdhci_cdns6_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv)
> +{
> + struct device *dev = &pdev->dev;
> + struct sdhci_host *host = dev_get_drvdata(dev);
> + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
> + struct sdhci_cdns6_phy *phy;
> + unsigned long val;
> + int ret;
> +
> + phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
> + if (!phy)
> + return -ENOMEM;
> +
> + val = clk_get_rate(pltfm_host->clk);
> + if (!val)
> + return dev_err_probe(dev, -EINVAL, "failed to get controller clock rate\n");
> +
> + phy->t_sdmclk = DIV_ROUND_DOWN_ULL(1000000000000ULL, val);
> +
> + /*
> + * Optional board-level PHY timing properties. When omitted, use the
> + * Cadence-recommended defaults (2500 ps IO-cell delays, 24 ps DLL
> + * delay element) that are valid for typical SoC packaging.
> + */
> + ret = of_property_read_u32(dev->of_node, "cdns,iocell-input-delay-ps",
> + &phy->iocell_input_delay);
> + if (ret)
> + phy->iocell_input_delay = SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY;
> +
> + ret = of_property_read_u32(dev->of_node, "cdns,iocell-output-delay-ps",
> + &phy->iocell_output_delay);
> + if (ret)
> + phy->iocell_output_delay = SDHCI_CDNS6_PHY_DEFAULT_IOCELL_DELAY;
> +
> + ret = of_property_read_u32(dev->of_node, "cdns,delay-element-ps", &phy->delay_element);
> + if (ret)
> + phy->delay_element = SDHCI_CDNS6_PHY_DEFAULT_DELAY_ELEMENT;
> +
> + phy->delay_element_org = phy->delay_element;
> +
> + priv->phy = phy;
> +
> + return 0;
> +}
> +
> +void sdhci_cdns6_set_uhs_signaling(struct sdhci_host *host, unsigned int timing)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + struct sdhci_cdns6_phy *phy = priv->phy;
> + int ret;
> +
> + /* Clock may be 0 during initial ios setup; skip PHY update */
> + if (!host->mmc->ios.clock)
> + return;
> +
> + phy->t_sdclk = DIV_ROUND_DOWN_ULL(1000000000000ULL, host->mmc->ios.clock);
Sashiko questioned this: Isn't mmc->actual_clock here better than host->mmc->ios.clock?
Refer:
https://sashiko.dev/#/patchset/20260724150039.23387-1-tanmay.kathpalia%40altera.com
> + phy->mode = timing;
> +
> + ret = sdhci_cdns6_phy_update_timings(host);
> + if (ret) {
> + dev_warn(mmc_dev(host->mmc), "%s: update timings failed: %d\n", __func__, ret);
> + return;
> + }
> +
> + ret = sdhci_cdns6_phy_init(priv);
> + if (ret)
> + dev_warn(mmc_dev(host->mmc), "%s: phy init failed: %d\n", __func__, ret);
> +}
> +
> +void sdhci_cdns6_hw_reset(struct sdhci_host *host)
> +{
> + struct sdhci_cdns_priv *priv = sdhci_cdns_priv(host);
> + void __iomem *reg;
> +
> + reg = priv->hrs_addr + SDHCI_CDNS_HRS11;
> + writel(SDHCI_CDNS_HRS11_EMMC_RST, reg);
> + /* eMMC HW reset assertion: spec requires >= 1us, give margin */
> + usleep_range(10, 20);
> + writel(0, reg);
> + /* For eMMC, minimum is 200us but give it 300us for good measure */
> + usleep_range(300, 1000);
> +}
> diff --git a/drivers/mmc/host/sdhci-cadence.h b/drivers/mmc/host/sdhci-cadence.h
> new file mode 100644
> index 000000000000..9affd9f4ede8
> --- /dev/null
> +++ b/drivers/mmc/host/sdhci-cadence.h
> @@ -0,0 +1,111 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later */
> +/*
> + * Copyright (C) 2026 Altera Corporation
> + * Author: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
> + *
> + * Cadence SD/SDIO/eMMC Host Controller driver - common header
> + * Shared definitions and structures for the Cadence SDHCI driver.
> + * Contains private data and declarations for SD6HC-specific functions
> + * called by the main driver in sdhci-cadence-core.c.
> + */
> +
> +#ifndef _MMC_HOST_SDHCI_CADENCE_H
> +#define _MMC_HOST_SDHCI_CADENCE_H
> +
> +#include <linux/compiler.h>
> +#include <linux/spinlock.h>
> +#include <linux/types.h>
> +
> +#include "sdhci-pltfm.h"
> +
> +struct reset_control;
> +
> +/* HRS - Host Register Set (specific to Cadence) */
> +#define SDHCI_CDNS_HRS04 0x10 /* PHY access: address port */
> +#define SDHCI_CDNS_HRS05 0x14 /* PHY access: data port */
> +
> +/*
> + * The tuned val register is 6 bit-wide, but not the whole of the range is
> + * available. The range 0-42 seems to be available (then 43 wraps around to 0)
> + * but I am not quite sure if it is official. Use only 0 to 39 for safety.
> + */
> +#define SDHCI_CDNS_MAX_TUNING_LOOP 40
> +
> +/**
> + * struct sdhci_cdns_priv - Cadence SDHCI private controller data
> + * @hrs_addr: Base address of Cadence Host Register Set (HRS) registers.
> + * @ctl_addr: Base address for write control registers.
> + * Used only for "amd,pensando-elba-sd4hc" compatible controllers to enable
> + * byte-lane writes.
> + * @wrlock: Spinlock for protecting register writes (Elba only).
> + * @enhanced_strobe: Flag indicating if Enhanced Strobe (HS400ES) is enabled.
> + * @priv_writel: Optional SoC-specific write function for register access.
> + * Used for Elba to ensure correct byte-lane enable.
> + * @rst_hw: Hardware reset control for the eMMC card RST_n pin (SD4HC only).
> + * @phy: Opaque pointer to variant-specific PHY data.
> + * For SD4HC: points to struct sdhci_cdns4_phy.
> + * For SD6HC: points to struct sdhci_cdns6_phy.
> + */
> +struct sdhci_cdns_priv {
> + void __iomem *hrs_addr;
> + void __iomem *ctl_addr; /* write control */
> + spinlock_t wrlock; /* write lock */
> + bool enhanced_strobe;
> + void (*priv_writel)(struct sdhci_cdns_priv *priv, u32 val, void __iomem *reg);
> + struct reset_control *rst_hw;
> + void *phy;
> +};
> +
> +/**
> + * sdhci_cdns_priv - Helper to retrieve Cadence private data from sdhci_host
> + * @host: Pointer to struct sdhci_host.
> + *
> + * Return: Pointer to struct sdhci_cdns_priv.
> + */
> +static inline void *sdhci_cdns_priv(struct sdhci_host *host)
> +{
> + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
> +
> + return sdhci_pltfm_priv(pltfm_host);
> +}
> +
> +/**
> + * sdhci_cdns6_set_uhs_signaling - Program PHY registers for a specific timing mode.
> + * @host: Pointer to struct sdhci_host.
> + * @timing: MMC timing mode (MMC_TIMING_*).
> + */
> +void sdhci_cdns6_set_uhs_signaling(struct sdhci_host *host, unsigned int timing);
> +
> +/**
> + * sdhci_cdns6_set_tune_val - Set the PHY tuning value.
> + * @host: Pointer to struct sdhci_host.
> + * @val: Tuning value to program.
> + *
> + * Return: 0 on success, -ETIMEDOUT if PHY initialization times out.
> + */
> +int sdhci_cdns6_set_tune_val(struct sdhci_host *host, unsigned int val);
> +
> +/**
> + * sdhci_cdns6_phy_probe - Probe and initialize Cadence SD6HC PHY parameters
> + * @pdev: Platform device pointer
> + * @priv: Pointer to Cadence private data structure
> + *
> + * Return: 0 on success or a negative error code.
> + */
> +int sdhci_cdns6_phy_probe(struct platform_device *pdev, struct sdhci_cdns_priv *priv);
> +
> +/**
> + * sdhci_cdns6_hw_reset - Perform hardware reset of the Cadence SDHCI controller.
> + * @host: Pointer to struct sdhci_host.
> + */
> +void sdhci_cdns6_hw_reset(struct sdhci_host *host);
> +
> +/**
> + * sdhci_cdns6_phy_init - Initialize the SD6HC PHY with current settings.
> + * @priv: Pointer to Cadence private data structure.
> + *
> + * Return: 0 on success, -ETIMEDOUT if PHY initialization times out.
> + */
> +int sdhci_cdns6_phy_init(struct sdhci_cdns_priv *priv);
> +
> +#endif /* _MMC_HOST_SDHCI_CADENCE_H */
^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 SD6HC support
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (5 preceding siblings ...)
2026-07-24 14:50 ` [PATCH v3 7/8] mmc: sdhci-cadence: add Cadence SD6HC support Tanmay Kathpalia
@ 2026-07-24 14:50 ` Tanmay Kathpalia
2026-07-27 7:19 ` Philipp Zabel
2026-08-07 13:08 ` Adrian Hunter
2026-07-24 15:00 ` [PATCH v3 0/8] mmc: sdhci-cadence: add SD6HC support and Agilex5 enablement Tanmay Kathpalia
2026-07-28 7:49 ` [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Krzysztof Kozlowski
8 siblings, 2 replies; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 14:50 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree, Tanmay Kathpalia, linux-kernel
The Altera Agilex5 SoC integrates a Cadence SD6HC controller that needs
platform-specific configuration to operate correctly.
The SoC requires three named resets: "sdhc-reset", "combophy", and
"sdmmc-ocp". All three are exclusive and must be asserted together before
being released, so the SDHCI, SoftPHY, and OCP/AXI clock domains cross the
reset boundary simultaneously. SoftPHY is shared with NAND at the SoC
level, but only one of SDMMC or NAND is enabled on a given board.
The IOMMU maps DMA addresses within a 40-bit physical address space, so
the DMA mask is capped at 40 bits to prevent allocation beyond the
controller's reach.
The silicon requires the MULTIBLOCK_READ_ACMD12, CAP_CLOCK_BASE_BROKEN,
PRESET_VALUE_BROKEN, and ACMD23_BROKEN quirks. Since
CAP_CLOCK_BASE_BROKEN prevents reading the base clock from the
capabilities register, the maximum clock is supplied from the platform
clock instead.
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
drivers/mmc/host/sdhci-cadence-core.c | 113 ++++++++++++++++++++++++++
1 file changed, 113 insertions(+)
diff --git a/drivers/mmc/host/sdhci-cadence-core.c b/drivers/mmc/host/sdhci-cadence-core.c
index 18846acc0b11..24130655a385 100644
--- a/drivers/mmc/host/sdhci-cadence-core.c
+++ b/drivers/mmc/host/sdhci-cadence-core.c
@@ -7,6 +7,7 @@
#include <linux/bitfield.h>
#include <linux/bits.h>
+#include <linux/dma-mapping.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/mmc/host.h>
@@ -90,6 +91,7 @@ struct sdhci_cdns4_phy_cfg {
struct sdhci_cdns_drv_data {
int (*init)(struct platform_device *pdev);
const struct sdhci_pltfm_data pltfm_data;
+ u64 dma_mask;
};
static const struct sdhci_cdns4_phy_cfg sdhci_cdns4_phy_cfgs[] = {
@@ -196,6 +198,23 @@ static unsigned int sdhci_cdns_get_timeout_clock(struct sdhci_host *host)
return host->max_clk;
}
+static int sdhci_cdns_set_dma_mask(struct sdhci_host *host)
+{
+ const struct sdhci_cdns_drv_data *data;
+ struct device *dev = mmc_dev(host->mmc);
+ int ret;
+
+ data = of_device_get_match_data(dev);
+ if (!data || !data->dma_mask)
+ return 0;
+
+ ret = dma_set_mask_and_coherent(dev, data->dma_mask);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to set DMA mask\n");
+
+ return 0;
+}
+
static void sdhci_cdns_set_emmc_mode(struct sdhci_cdns_priv *priv, u32 mode)
{
u32 tmp;
@@ -462,6 +481,72 @@ static int elba_drv_init(struct platform_device *pdev)
return 0;
}
+static int sdhci_cdns6_agilex5_init(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct reset_control *rst_sdhc;
+ struct reset_control *rst_combophy;
+ struct reset_control *rst_ocp;
+ int ret;
+
+ /*
+ * Assert SDHCI, SoftPHY (combophy), and SDMMC OCP/AXI resets together
+ * so their active periods overlap before all domains are released.
+ * SoftPHY is shared with NAND, but only one of SDMMC
+ * or NAND is enabled on a given board.
+ */
+ rst_sdhc = devm_reset_control_get_exclusive(dev, "sdhc-reset");
+ if (IS_ERR(rst_sdhc))
+ return dev_err_probe(dev, PTR_ERR(rst_sdhc), "failed to get sdhc-reset\n");
+
+ rst_combophy = devm_reset_control_get_exclusive(dev, "combophy");
+ if (IS_ERR(rst_combophy))
+ return dev_err_probe(dev, PTR_ERR(rst_combophy), "failed to get combophy reset\n");
+
+ rst_ocp = devm_reset_control_get_exclusive(dev, "sdmmc-ocp");
+ if (IS_ERR(rst_ocp))
+ return dev_err_probe(dev, PTR_ERR(rst_ocp), "failed to get sdmmc-ocp reset\n");
+
+ ret = reset_control_assert(rst_sdhc);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to assert sdhc-reset\n");
+
+ ret = reset_control_assert(rst_combophy);
+ if (ret) {
+ reset_control_deassert(rst_sdhc);
+ return dev_err_probe(dev, ret, "failed to assert combophy reset\n");
+ }
+
+ ret = reset_control_assert(rst_ocp);
+ if (ret) {
+ reset_control_deassert(rst_combophy);
+ reset_control_deassert(rst_sdhc);
+ return dev_err_probe(dev, ret, "failed to assert sdmmc-ocp reset\n");
+ }
+
+ /* Hold resets asserted long enough for all clock domains to capture. */
+ usleep_range(10, 20);
+
+ ret = reset_control_deassert(rst_sdhc);
+ if (ret) {
+ reset_control_deassert(rst_combophy);
+ reset_control_deassert(rst_ocp);
+ return dev_err_probe(dev, ret, "failed to deassert sdhc-reset\n");
+ }
+
+ ret = reset_control_deassert(rst_combophy);
+ if (ret) {
+ reset_control_deassert(rst_ocp);
+ return dev_err_probe(dev, ret, "failed to deassert combophy reset\n");
+ }
+
+ ret = reset_control_deassert(rst_ocp);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to deassert sdmmc-ocp reset\n");
+
+ return 0;
+}
+
static const struct sdhci_ops sdhci_cdns4_ops = {
.set_clock = sdhci_set_clock,
.get_timeout_clock = sdhci_cdns_get_timeout_clock,
@@ -481,6 +566,18 @@ static const struct sdhci_ops sdhci_cdns6_ops = {
.hw_reset = sdhci_cdns6_hw_reset,
};
+static const struct sdhci_ops sdhci_cdns6_agilex5_ops = {
+ .set_clock = sdhci_set_clock,
+ .get_max_clock = sdhci_pltfm_clk_get_max_clock,
+ .get_timeout_clock = sdhci_cdns_get_timeout_clock,
+ .set_bus_width = sdhci_set_bus_width,
+ .reset = sdhci_reset,
+ .platform_execute_tuning = sdhci_cdns_execute_tuning,
+ .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
+ .hw_reset = sdhci_cdns6_hw_reset,
+ .set_dma_mask = sdhci_cdns_set_dma_mask,
+};
+
static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
.pltfm_data = {
.ops = &sdhci_cdns4_ops,
@@ -508,6 +605,18 @@ static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
},
};
+static const struct sdhci_cdns_drv_data sdhci_cdns6_agilex5_drv_data = {
+ .init = sdhci_cdns6_agilex5_init,
+ .pltfm_data = {
+ .ops = &sdhci_cdns6_agilex5_ops,
+ .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN |
+ SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12,
+ .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
+ SDHCI_QUIRK2_ACMD23_BROKEN,
+ },
+ .dma_mask = DMA_BIT_MASK(40),
+};
+
static const struct sdhci_cdns_drv_data sdhci_cdns6_drv_data = {
.pltfm_data = {
.ops = &sdhci_cdns6_ops,
@@ -709,6 +818,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
.compatible = "cdns,sd4hc",
.data = &sdhci_cdns4_drv_data,
},
+ {
+ .compatible = "altr,agilex5-sd6hc",
+ .data = &sdhci_cdns6_agilex5_drv_data,
+ },
{
.compatible = "cdns,sd6hc",
.data = &sdhci_cdns6_drv_data,
--
2.43.7
^ permalink raw reply related [flat|nested] 17+ messages in thread* Re: [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 SD6HC support
2026-07-24 14:50 ` [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 " Tanmay Kathpalia
@ 2026-07-27 7:19 ` Philipp Zabel
2026-08-07 13:08 ` Adrian Hunter
1 sibling, 0 replies; 17+ messages in thread
From: Philipp Zabel @ 2026-07-27 7:19 UTC (permalink / raw)
To: Tanmay Kathpalia, linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen,
devicetree, linux-kernel
On Fr, 2026-07-24 at 07:50 -0700, Tanmay Kathpalia wrote:
> The Altera Agilex5 SoC integrates a Cadence SD6HC controller that needs
> platform-specific configuration to operate correctly.
>
> The SoC requires three named resets: "sdhc-reset", "combophy", and
> "sdmmc-ocp". All three are exclusive and must be asserted together before
> being released, so the SDHCI, SoftPHY, and OCP/AXI clock domains cross the
> reset boundary simultaneously. SoftPHY is shared with NAND at the SoC
> level, but only one of SDMMC or NAND is enabled on a given board.
>
> The IOMMU maps DMA addresses within a 40-bit physical address space, so
> the DMA mask is capped at 40 bits to prevent allocation beyond the
> controller's reach.
>
> The silicon requires the MULTIBLOCK_READ_ACMD12, CAP_CLOCK_BASE_BROKEN,
> PRESET_VALUE_BROKEN, and ACMD23_BROKEN quirks. Since
> CAP_CLOCK_BASE_BROKEN prevents reading the base clock from the
> capabilities register, the maximum clock is supplied from the platform
> clock instead.
>
> Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
> ---
> drivers/mmc/host/sdhci-cadence-core.c | 113 ++++++++++++++++++++++++++
> 1 file changed, 113 insertions(+)
>
> diff --git a/drivers/mmc/host/sdhci-cadence-core.c b/drivers/mmc/host/sdhci-cadence-core.c
> index 18846acc0b11..24130655a385 100644
> --- a/drivers/mmc/host/sdhci-cadence-core.c
> +++ b/drivers/mmc/host/sdhci-cadence-core.c
[...]
> @@ -462,6 +481,72 @@ static int elba_drv_init(struct platform_device *pdev)
> return 0;
> }
>
> +static int sdhci_cdns6_agilex5_init(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct reset_control *rst_sdhc;
> + struct reset_control *rst_combophy;
> + struct reset_control *rst_ocp;
> + int ret;
> +
> + /*
> + * Assert SDHCI, SoftPHY (combophy), and SDMMC OCP/AXI resets together
> + * so their active periods overlap before all domains are released.
> + * SoftPHY is shared with NAND, but only one of SDMMC
> + * or NAND is enabled on a given board.
> + */
> + rst_sdhc = devm_reset_control_get_exclusive(dev, "sdhc-reset");
> + if (IS_ERR(rst_sdhc))
> + return dev_err_probe(dev, PTR_ERR(rst_sdhc), "failed to get sdhc-reset\n");
> +
> + rst_combophy = devm_reset_control_get_exclusive(dev, "combophy");
> + if (IS_ERR(rst_combophy))
> + return dev_err_probe(dev, PTR_ERR(rst_combophy), "failed to get combophy reset\n");
> +
> + rst_ocp = devm_reset_control_get_exclusive(dev, "sdmmc-ocp");
> + if (IS_ERR(rst_ocp))
> + return dev_err_probe(dev, PTR_ERR(rst_ocp), "failed to get sdmmc-ocp reset\n");
This looks like it could be simplified with
devm_reset_control_bulk_get_exclusive().
regards
Philipp
^ permalink raw reply [flat|nested] 17+ messages in thread* Re: [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 SD6HC support
2026-07-24 14:50 ` [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 " Tanmay Kathpalia
2026-07-27 7:19 ` Philipp Zabel
@ 2026-08-07 13:08 ` Adrian Hunter
1 sibling, 0 replies; 17+ messages in thread
From: Adrian Hunter @ 2026-08-07 13:08 UTC (permalink / raw)
To: Tanmay Kathpalia, linux-mmc
Cc: ulfh, krzk+dt, robh, conor+dt, dinguyen, p.zabel, devicetree,
linux-kernel
On 24/07/2026 17:50, Tanmay Kathpalia wrote:
> The Altera Agilex5 SoC integrates a Cadence SD6HC controller that needs
> platform-specific configuration to operate correctly.
>
> The SoC requires three named resets: "sdhc-reset", "combophy", and
> "sdmmc-ocp". All three are exclusive and must be asserted together before
> being released, so the SDHCI, SoftPHY, and OCP/AXI clock domains cross the
> reset boundary simultaneously. SoftPHY is shared with NAND at the SoC
> level, but only one of SDMMC or NAND is enabled on a given board.
>
> The IOMMU maps DMA addresses within a 40-bit physical address space, so
> the DMA mask is capped at 40 bits to prevent allocation beyond the
> controller's reach.
>
> The silicon requires the MULTIBLOCK_READ_ACMD12, CAP_CLOCK_BASE_BROKEN,
> PRESET_VALUE_BROKEN, and ACMD23_BROKEN quirks. Since
> CAP_CLOCK_BASE_BROKEN prevents reading the base clock from the
> capabilities register, the maximum clock is supplied from the platform
> clock instead.
>
> Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
Acked-by: Adrian Hunter <adrian.hunter@intel.com>
> ---
> drivers/mmc/host/sdhci-cadence-core.c | 113 ++++++++++++++++++++++++++
> 1 file changed, 113 insertions(+)
>
> diff --git a/drivers/mmc/host/sdhci-cadence-core.c b/drivers/mmc/host/sdhci-cadence-core.c
> index 18846acc0b11..24130655a385 100644
> --- a/drivers/mmc/host/sdhci-cadence-core.c
> +++ b/drivers/mmc/host/sdhci-cadence-core.c
> @@ -7,6 +7,7 @@
>
> #include <linux/bitfield.h>
> #include <linux/bits.h>
> +#include <linux/dma-mapping.h>
> #include <linux/iopoll.h>
> #include <linux/module.h>
> #include <linux/mmc/host.h>
> @@ -90,6 +91,7 @@ struct sdhci_cdns4_phy_cfg {
> struct sdhci_cdns_drv_data {
> int (*init)(struct platform_device *pdev);
> const struct sdhci_pltfm_data pltfm_data;
> + u64 dma_mask;
> };
>
> static const struct sdhci_cdns4_phy_cfg sdhci_cdns4_phy_cfgs[] = {
> @@ -196,6 +198,23 @@ static unsigned int sdhci_cdns_get_timeout_clock(struct sdhci_host *host)
> return host->max_clk;
> }
>
> +static int sdhci_cdns_set_dma_mask(struct sdhci_host *host)
> +{
> + const struct sdhci_cdns_drv_data *data;
> + struct device *dev = mmc_dev(host->mmc);
> + int ret;
> +
> + data = of_device_get_match_data(dev);
> + if (!data || !data->dma_mask)
> + return 0;
> +
> + ret = dma_set_mask_and_coherent(dev, data->dma_mask);
> + if (ret)
> + return dev_err_probe(dev, ret, "failed to set DMA mask\n");
> +
> + return 0;
> +}
> +
> static void sdhci_cdns_set_emmc_mode(struct sdhci_cdns_priv *priv, u32 mode)
> {
> u32 tmp;
> @@ -462,6 +481,72 @@ static int elba_drv_init(struct platform_device *pdev)
> return 0;
> }
>
> +static int sdhci_cdns6_agilex5_init(struct platform_device *pdev)
> +{
> + struct device *dev = &pdev->dev;
> + struct reset_control *rst_sdhc;
> + struct reset_control *rst_combophy;
> + struct reset_control *rst_ocp;
> + int ret;
> +
> + /*
> + * Assert SDHCI, SoftPHY (combophy), and SDMMC OCP/AXI resets together
> + * so their active periods overlap before all domains are released.
> + * SoftPHY is shared with NAND, but only one of SDMMC
> + * or NAND is enabled on a given board.
> + */
> + rst_sdhc = devm_reset_control_get_exclusive(dev, "sdhc-reset");
> + if (IS_ERR(rst_sdhc))
> + return dev_err_probe(dev, PTR_ERR(rst_sdhc), "failed to get sdhc-reset\n");
> +
> + rst_combophy = devm_reset_control_get_exclusive(dev, "combophy");
> + if (IS_ERR(rst_combophy))
> + return dev_err_probe(dev, PTR_ERR(rst_combophy), "failed to get combophy reset\n");
> +
> + rst_ocp = devm_reset_control_get_exclusive(dev, "sdmmc-ocp");
> + if (IS_ERR(rst_ocp))
> + return dev_err_probe(dev, PTR_ERR(rst_ocp), "failed to get sdmmc-ocp reset\n");
> +
> + ret = reset_control_assert(rst_sdhc);
> + if (ret)
> + return dev_err_probe(dev, ret, "failed to assert sdhc-reset\n");
> +
> + ret = reset_control_assert(rst_combophy);
> + if (ret) {
> + reset_control_deassert(rst_sdhc);
> + return dev_err_probe(dev, ret, "failed to assert combophy reset\n");
> + }
> +
> + ret = reset_control_assert(rst_ocp);
> + if (ret) {
> + reset_control_deassert(rst_combophy);
> + reset_control_deassert(rst_sdhc);
> + return dev_err_probe(dev, ret, "failed to assert sdmmc-ocp reset\n");
> + }
> +
> + /* Hold resets asserted long enough for all clock domains to capture. */
> + usleep_range(10, 20);
> +
> + ret = reset_control_deassert(rst_sdhc);
> + if (ret) {
> + reset_control_deassert(rst_combophy);
> + reset_control_deassert(rst_ocp);
> + return dev_err_probe(dev, ret, "failed to deassert sdhc-reset\n");
> + }
> +
> + ret = reset_control_deassert(rst_combophy);
> + if (ret) {
> + reset_control_deassert(rst_ocp);
> + return dev_err_probe(dev, ret, "failed to deassert combophy reset\n");
> + }
> +
> + ret = reset_control_deassert(rst_ocp);
> + if (ret)
> + return dev_err_probe(dev, ret, "failed to deassert sdmmc-ocp reset\n");
> +
> + return 0;
> +}
> +
> static const struct sdhci_ops sdhci_cdns4_ops = {
> .set_clock = sdhci_set_clock,
> .get_timeout_clock = sdhci_cdns_get_timeout_clock,
> @@ -481,6 +566,18 @@ static const struct sdhci_ops sdhci_cdns6_ops = {
> .hw_reset = sdhci_cdns6_hw_reset,
> };
>
> +static const struct sdhci_ops sdhci_cdns6_agilex5_ops = {
> + .set_clock = sdhci_set_clock,
> + .get_max_clock = sdhci_pltfm_clk_get_max_clock,
> + .get_timeout_clock = sdhci_cdns_get_timeout_clock,
> + .set_bus_width = sdhci_set_bus_width,
> + .reset = sdhci_reset,
> + .platform_execute_tuning = sdhci_cdns_execute_tuning,
> + .set_uhs_signaling = sdhci_cdns_set_uhs_signaling,
> + .hw_reset = sdhci_cdns6_hw_reset,
> + .set_dma_mask = sdhci_cdns_set_dma_mask,
> +};
> +
> static const struct sdhci_cdns_drv_data sdhci_cdns_uniphier_drv_data = {
> .pltfm_data = {
> .ops = &sdhci_cdns4_ops,
> @@ -508,6 +605,18 @@ static const struct sdhci_cdns_drv_data sdhci_cdns4_drv_data = {
> },
> };
>
> +static const struct sdhci_cdns_drv_data sdhci_cdns6_agilex5_drv_data = {
> + .init = sdhci_cdns6_agilex5_init,
> + .pltfm_data = {
> + .ops = &sdhci_cdns6_agilex5_ops,
> + .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN |
> + SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12,
> + .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
> + SDHCI_QUIRK2_ACMD23_BROKEN,
> + },
> + .dma_mask = DMA_BIT_MASK(40),
> +};
> +
> static const struct sdhci_cdns_drv_data sdhci_cdns6_drv_data = {
> .pltfm_data = {
> .ops = &sdhci_cdns6_ops,
> @@ -709,6 +818,10 @@ static const struct of_device_id sdhci_cdns_match[] = {
> .compatible = "cdns,sd4hc",
> .data = &sdhci_cdns4_drv_data,
> },
> + {
> + .compatible = "altr,agilex5-sd6hc",
> + .data = &sdhci_cdns6_agilex5_drv_data,
> + },
> {
> .compatible = "cdns,sd6hc",
> .data = &sdhci_cdns6_drv_data,
^ permalink raw reply [flat|nested] 17+ messages in thread
* [PATCH v3 0/8] mmc: sdhci-cadence: add SD6HC support and Agilex5 enablement
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (6 preceding siblings ...)
2026-07-24 14:50 ` [PATCH v3 8/8] mmc: sdhci-cadence: add Altera Agilex5 " Tanmay Kathpalia
@ 2026-07-24 15:00 ` Tanmay Kathpalia
2026-07-28 7:49 ` [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Krzysztof Kozlowski
8 siblings, 0 replies; 17+ messages in thread
From: Tanmay Kathpalia @ 2026-07-24 15:00 UTC (permalink / raw)
To: linux-mmc
Cc: ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen, p.zabel,
devicetree
This series adds support for the Cadence SD6HC (sixth-generation) SDHCI
controller and enables it on Altera Agilex5 SoCs.
The SD6HC PHY architecture differs substantially from the SD4HC: it
requires dedicated per-speed-mode IO cell timing parameters and a
DLL-based delay line to achieve correct signal margins across all speed
grades from Default Speed through HS400. These are programmed through a
new sdhci-cadence-phy-v6.c file; shared driver infrastructure lives in
sdhci-cadence-core.c.
Note: this series depends on commit ab45ecfab540 ("dt-bindings: reset:
altr: add COMBOPHY_RESET for Agilex5"), which is already in mainline via
the reset tree. It is not yet in mmc/next; apply or merge that commit
when building/testing this series on top of mmc/next. The previous v1/v2
reset binding patch is therefore omitted from this series.
Patch 1: DT binding
Adds a dedicated cdns,sd6hc.yaml binding with SD6HC compatible strings,
clock/reset/IOMMU constraints, and PHY timing properties.
Patches 2-4: Device tree
Patch 2 adds the SD6HC controller node to the Agilex5 SoC DTSI and
enables SD card operation (4-bit, SDR104, 200 MHz) on the SOCDK board
with GPIO-switched IO-voltage regulation.
Patch 3 registers the intel,socfpga-agilex5-socdk-emmc board variant
in the arm/altera binding.
Patch 4 adds socfpga_agilex5_socdk_emmc.dts for eMMC-only operation
(8-bit, HS200/HS400, 1.8 V IO, 200 MHz).
Patches 5-8: Driver
Patch 5 renames SD4HC-specific functions and structures with a "cdns4"
prefix to separate them from shared driver paths.
Patch 6 encapsulates SD4HC PHY probing in sdhci_cdns4_phy_probe() and
makes every of_device_id entry carry explicit platform data, removing
the silent fallback.
Patch 7 introduces the SD6HC PHY driver (sdhci-cadence-phy-v6.c): DLL
lock/bypass, per-speed-mode IO cell timing, tuning, and HW reset. The
common driver core selects between v4 and v6 PHY operations based on
the SDHCI specification version reported by the controller.
Patch 8 adds the Agilex5 platform overlay under altr,agilex5-sd6hc:
40-bit DMA mask for the SMMU address space, quirks for
CAP_CLOCK_BASE_BROKEN, PRESET_VALUE_BROKEN, ACMD23_BROKEN and
MULTIBLOCK_READ_ACMD12, .get_max_clock set to
sdhci_pltfm_clk_get_max_clock, and an init hook that asserts and
deasserts the three named resets together.
Tested on Agilex5 SOCDK:
- SD card: Default Speed, High Speed, SDR25, SDR50, SDR104
- eMMC daughter board: HS200, HS400
Signed-off-by: Tanmay Kathpalia <tanmay.kathpalia@altera.com>
---
Changes in v3:
[bindings]
- Drop the COMBOPHY_RESET binding patch; it is already in mainline as
commit ab45ecfab540 via the reset tree.
- Split SD6HC into a dedicated cdns,sd6hc.yaml binding instead of
extending cdns,sdhci.yaml (Krzysztof).
- Rename PHY timing properties with standard unit suffixes:
cdns,iocell-*-delay-ps and cdns,delay-element-ps (Krzysztof).
- Define clock-names and reset-names in the SD6HC binding, and keep
iommus / dma-coherent at the top level (Krzysztof).
- Rewrite binding/driver commit messages to describe the hardware
rather than restating the diff (Krzysztof).
- Fix alphabetical order of the SOCDK eMMC board compatible in
altera.yaml, and retitle the patch as dt-bindings: arm: altera
(Krzysztof).
[drivers]
- Trim sdhci-cadence.h to include only what it uses (types.h,
compiler.h, spinlock.h, sdhci-pltfm.h) and keep direct includes in
the .c files that need them (Adrian) (patch 7).
- Pulse combophy with sdhc-reset and sdmmc-ocp (exclusive assert /
deassert together). SoftPHY is shared with NAND at the SoC level,
but only one of SDMMC or NAND is enabled on a given board
(replaces shared_deasserted-only handling from v2) (patch 8).
- Keep #include <linux/iopoll.h> when adding dma-mapping.h (patch 8).
- Unwrap dev_err_probe() lines that already fit in 100 columns
(Adrian) (patch 8).
Link V2: https://lore.kernel.org/linux-mmc/20260627201457.12318-1-tanmay.kathpalia@altera.com/
Link V1: https://lore.kernel.org/linux-mmc/20260511202132.5597-1-tanmay.kathpalia@altera.com/
Tanmay Kathpalia (8):
dt-bindings: mmc: add Cadence SD6HC binding
arm64: dts: agilex5: add SD/eMMC host controller
dt-bindings: arm: altera: add Agilex5 SOCDK eMMC board variant
arm64: dts: agilex5: add SOCDK eMMC daughter board
mmc: sdhci-cadence: rename SD4HC symbols for SD6HC groundwork
mmc: sdhci-cadence: refactor driver structure for V6 controller
support
mmc: sdhci-cadence: add Cadence SD6HC support
mmc: sdhci-cadence: add Altera Agilex5 SD6HC support
.../devicetree/bindings/arm/altera.yaml | 1 +
.../devicetree/bindings/mmc/cdns,sd6hc.yaml | 114 +++
MAINTAINERS | 7 +
arch/arm64/boot/dts/intel/Makefile | 1 +
.../arm64/boot/dts/intel/socfpga_agilex5.dtsi | 25 +
.../boot/dts/intel/socfpga_agilex5_socdk.dts | 38 +-
.../dts/intel/socfpga_agilex5_socdk_emmc.dts | 127 +++
drivers/mmc/host/Makefile | 1 +
.../{sdhci-cadence.c => sdhci-cadence-core.c} | 314 ++++--
drivers/mmc/host/sdhci-cadence-phy-v6.c | 929 ++++++++++++++++++
drivers/mmc/host/sdhci-cadence.h | 111 +++
11 files changed, 1596 insertions(+), 72 deletions(-)
create mode 100644 Documentation/devicetree/bindings/mmc/cdns,sd6hc.yaml
create mode 100644 arch/arm64/boot/dts/intel/socfpga_agilex5_socdk_emmc.dts
rename drivers/mmc/host/{sdhci-cadence.c => sdhci-cadence-core.c} (65%)
create mode 100644 drivers/mmc/host/sdhci-cadence-phy-v6.c
create mode 100644 drivers/mmc/host/sdhci-cadence.h
--
2.43.7
^ permalink raw reply [flat|nested] 17+ messages in thread* Re: [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding
2026-07-24 14:50 [PATCH v3 1/8] dt-bindings: mmc: add Cadence SD6HC binding Tanmay Kathpalia
` (7 preceding siblings ...)
2026-07-24 15:00 ` [PATCH v3 0/8] mmc: sdhci-cadence: add SD6HC support and Agilex5 enablement Tanmay Kathpalia
@ 2026-07-28 7:49 ` Krzysztof Kozlowski
8 siblings, 0 replies; 17+ messages in thread
From: Krzysztof Kozlowski @ 2026-07-28 7:49 UTC (permalink / raw)
To: Tanmay Kathpalia
Cc: linux-mmc, ulfh, adrian.hunter, krzk+dt, robh, conor+dt, dinguyen,
p.zabel, devicetree, linux-kernel
On Fri, Jul 24, 2026 at 07:50:00AM -0700, Tanmay Kathpalia wrote:
> +description:
> + Cadence SD6HC is a sixth-generation SD/SDIO/eMMC host controller with an
> + interface to a Cadence Combo PHY. The controller has separate card interface
> + and bus interface clock domains.
> +
> +properties:
> + compatible:
> + items:
> + - const: altr,agilex5-sd6hc
> + - const: cdns,sd6hc
> +
> + reg:
> + maxItems: 1
> +
> + interrupts:
> + maxItems: 1
> +
> + clocks:
> + items:
> + - description: card interface unit (CIU / SDMCLK) clock
> + - description: bus interface unit (BIU) clock
> +
> + clock-names:
> + items:
> + - const: ciu
> + - const: biu
> +
> + resets:
> + minItems: 1
Drop
> + maxItems: 3
> +
> + reset-names:
> + minItems: 1
> + maxItems: 3
Drop both and list items. And then drop that "if:then:" block.
Case of 1 item is simply impossible.
> +
> + iommus:
> + maxItems: 1
> +
> + dma-coherent: true
> +
> + cdns,iocell-input-delay-ps:
> + description:
> + Input delay across the IO cells, used for SD6HC PHY timing calculations.
> + minimum: 0
> + maximum: 20000
> +
> + cdns,iocell-output-delay-ps:
> + description:
> + Output delay across the IO cells, used for SD6HC PHY timing calculations.
> + minimum: 0
> + maximum: 20000
> +
> + cdns,delay-element-ps:
> + description:
> + DLL delay element size, used for SD6HC PHY timing calculations.
> + minimum: 1
> + maximum: 1000
> +
> +required:
> + - compatible
> + - reg
> + - interrupts
> + - clocks
> + - clock-names
resets and reset-names should be required
> +
> +allOf:
> + - $ref: sdhci-common.yaml#
> + - if:
> + properties:
> + compatible:
> + contains:
> + const: altr,agilex5-sd6hc
Best regards,
Krzysztof
^ permalink raw reply [flat|nested] 17+ messages in thread