From nobody Mon Feb 9 14:59:27 2026 Received: from mail-wr1-f42.google.com (mail-wr1-f42.google.com [209.85.221.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BEA4780B; Mon, 12 May 2025 18:43:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075392; cv=none; b=MVwd7ReMa3sT0YHmPsRmeAlW/jwsj5J0U6z05c8Jnato3lcxVoN4neuJxukNBioEIg1Np0mJQPyusp/IQCixgdGv9FvfJkLMKenKJ+1S19hw2F6xK7yNxjc+e1gx0s7eNBvkZTmAk9Jz8MvvyBXlBBItrJlY1umq6Op33mgqkoM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075392; c=relaxed/simple; bh=ENPbWpfKMnDNfZThnPgHE3IguXqvykmQDmmL5rbTJ9g=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Op4k38HVeZC1adr/OdjhxUvC5+c4ShFuv+7jSWovkKl/7LXURX0KoeHwnwF2hr7+Bo/H+AUc4HLroVVUyICcHyaL4ZpHUhfECq3jDfrTGuEd48HHQzrwWDJgAtrquJslzY4CB5VCGta6BuRdz0y6Xduz836TFHAxjnpfaPhjiSw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=nOLzoz7c; arc=none smtp.client-ip=209.85.221.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="nOLzoz7c" Received: by mail-wr1-f42.google.com with SMTP id ffacd0b85a97d-3a1f9791a4dso1875222f8f.0; Mon, 12 May 2025 11:43:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1747075388; x=1747680188; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=hXYpvp8bu0kNjsoGrk4VNL5yVynpTuRi3myutNNgdho=; b=nOLzoz7cRpJJ3Xw9ZCD0pT7XL4E5YDKYKUBGFYZrkQm5nT2J8qKGNSB99/2E+9DacD hTYDJFG+F91cIn2qbxHaoc/NOxFUyM8aNK3pyCIULO0kgp6ImUGidrM4+/R0E9ME0io7 D48BM43n0VLThP5hq2gqbDEDU1qZONwPi87zj3ixx+KBZ/H8qkGAaDBoehRNfc8zsbvt kOu7HSP0P1dbPqWYDNhvWjkY/mkmvMvdXCmwo/Z41y0USRMBVUwjEXuj01xBgwzQCZWd oGUFoNCFgXIx82wp3ajYoAT0AHs0wsSRFyEFIWChh464HTRFz64HHbPmHbnnVLCS5ivD dgGQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747075388; x=1747680188; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=hXYpvp8bu0kNjsoGrk4VNL5yVynpTuRi3myutNNgdho=; b=crjVlghaTVZPpEI7h0vNb/p4DRLpvL0ceXIK3En8z5T91xyZWgkCIBZw1eMCNcWj3n P6JsCXiWaAZETYlqMzfHlNt+4yh/NThFrUnrkE/4A0bWlUeIMqoCmBvdO9OTHAr5A5o6 sS2o01CIgcFcjNTXIyFB7DGr0ABkMVVB1He/mt5epJNgvO66CH8+iqtxp4blD16qYGEp orL6VVciinF2mvxtHofRRVdqzcvBDiR4IREGjxTqq02uMyfZdGpXSmSkYzIi7cfOfSVm bPl+Ttzl4njcTcGAroicZOeAKUYwmhtLnPkI7voj6X9tKXL1/D483p6uG/bx+0e16Os0 /rQw== X-Forwarded-Encrypted: i=1; AJvYcCUEp48IndA3k0UTHxnhpofWLHXUD9zzB1qfWyHwbhoyLM26dkQ6eJDf3V60uIGbiTS7jJ6qjeM8nfM+@vger.kernel.org, AJvYcCX+nG29+TSpM67mOviRqOA8MW0xZzGpRdlllJAtUaxBEbaXnyddO6HzLvvX88ZElhA7W+rG8ZaqKTbr7obyn3Gb5Gw=@vger.kernel.org, AJvYcCXNeulfd4C4U2Ounk0vWTlBSr2MPsPyAomnbUIUAEeJc7QyQO1E3/zgH/nXmjmCc1sG4zbZz5YDTFR1XWBc@vger.kernel.org, AJvYcCXVwEvJ3bD3ZzUUVj1S84YJMSfUfhbT+t9svmsyessyh9m3JcA8VOQL0MPYRMmiPJ5SNa8LY7ykvjOR@vger.kernel.org X-Gm-Message-State: AOJu0YzqJ20AxS9ygd/Y4NLwT7VW8vuvtOQzWqoZnyHNTLaVb42VitUi zZWxVb7Pvscbj8uXgk7QUdpcMSdW7YgOk24f+G+kPNphOCVo8p5m X-Gm-Gg: ASbGncvZD0guafqvm04v2UU3X16/V6Zucjl9Hrb+8bmfRsaAFjmHM8IWQXFvmHyStwa +2s+b16aTmN0bHv6fU7/3o0qK/0KP+kCidbgYnh8DCPhmb6W+N9jYTZEKfa+Fq7GLIWhUClrUsm AByRzEaZmLWqySWsV7i67ofQgjGM3kJPOk9dwp6cUdKSFcjLCbhh/c9MEdE0C9Y6g+fiQjXkSMx wo4fKp+y9HyAJrBsJxynA33btaBSQvV6waZQoIEQYX2oVJd/RNOmKoO8Rci8vMLZdAOqCXUtg+v wtaEfjcebJ4MExbSBGQMp/cEU0nMmcrXar2kvTlR0IIdheWAxRJCY5VaX/D9bOguW8hQcc9Pke/ n X-Google-Smtp-Source: AGHT+IGXr2agVAOptr74sBgXtYxqUxC84pdVtk8XhUbAenJbT8DEoNK0m2D2ZVS0uRMjGYXPiT0jyg== X-Received: by 2002:a05:6000:1842:b0:3a2:45f:7c3 with SMTP id ffacd0b85a97d-3a2045f0814mr6334906f8f.57.1747075387722; Mon, 12 May 2025 11:43:07 -0700 (PDT) Received: from iku.Home ([2a06:5906:61b:2d00:581b:951a:bc46:a124]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a1f57ddd53sm13309203f8f.1.2025.05.12.11.43.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 12 May 2025 11:43:06 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , David Airlie , Simona Vetter , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Geert Uytterhoeven , Michael Turquette , Stephen Boyd , Biju Das , Magnus Damm Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-renesas-soc@vger.kernel.org, linux-clk@vger.kernel.org, Prabhakar , Fabrizio Castro , Lad Prabhakar Subject: [PATCH v5 1/4] clk: renesas: rzv2h-cpg: Add support for DSI clocks Date: Mon, 12 May 2025 19:42:59 +0100 Message-ID: <20250512184302.241417-2-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Lad Prabhakar Add support for PLLDSI and PLLDSI divider clocks. Introduce the `renesas-rzv2h-dsi.h` header to centralize and share PLLDSI-related data structures, limits, and algorithms between the RZ/V2H CPG and DSI drivers. The DSI PLL is functionally similar to the CPG's PLLDSI, but has slightly different parameter limits and omits the programmable divider present in CPG. To ensure precise frequency calculations-especially for milliHz-level accuracy needed by the DSI driver-the shared algorithm allows both drivers to compute PLL parameters consistently using the same logic and input clock. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar --- v4->v5: - No changes v3->v4: - Corrected parameter name in rzv2h_dsi_get_pll_parameters_values() description freq_millihz v2->v3: - Update the commit message to clarify the purpose of `renesas-rzv2h-dsi.h` header - Used mul_u32_u32() in rzv2h_cpg_plldsi_div_determine_rate() - Replaced *_mhz to *_millihz for clarity - Updated u64->u32 for fvco limits - Initialized the members in declaration order for RZV2H_CPG_PLL_DSI_LIMITS() macro - Used clk_div_mask() in rzv2h_cpg_plldsi_div_recalc_rate() - Replaced `unsigned long long` with u64 - Dropped rzv2h_cpg_plldsi_clk_recalc_rate() and reused rzv2h_cpg_pll_clk_recalc_rate() instead - In rzv2h_cpg_plldsi_div_set_rate() followed the same style of RMW-operation as done in the other functions - Renamed rzv2h_cpg_plldsi_set_rate() to rzv2h_cpg_pll_set_rate() - Dropped rzv2h_cpg_plldsi_clk_register() and reused rzv2h_cpg_pll_clk_register() instead - Added a gaurd in renesas-rzv2h-dsi.h header v1->v2: - No changes --- drivers/clk/renesas/rzv2h-cpg.c | 237 +++++++++++++++++++++++++- drivers/clk/renesas/rzv2h-cpg.h | 14 ++ include/linux/clk/renesas-rzv2h-dsi.h | 211 +++++++++++++++++++++++ 3 files changed, 460 insertions(+), 2 deletions(-) create mode 100644 include/linux/clk/renesas-rzv2h-dsi.h diff --git a/drivers/clk/renesas/rzv2h-cpg.c b/drivers/clk/renesas/rzv2h-cp= g.c index 882e301c2d1b..ccf6a664e71d 100644 --- a/drivers/clk/renesas/rzv2h-cpg.c +++ b/drivers/clk/renesas/rzv2h-cpg.c @@ -14,9 +14,13 @@ #include #include #include +#include #include #include #include +#include +#include +#include #include #include #include @@ -26,6 +30,7 @@ #include #include #include +#include =20 #include =20 @@ -48,6 +53,7 @@ #define CPG_PLL_STBY(x) ((x)) #define CPG_PLL_STBY_RESETB BIT(0) #define CPG_PLL_STBY_RESETB_WEN BIT(16) +#define CPG_PLL_STBY_SSCGEN_WEN BIT(18) #define CPG_PLL_CLK1(x) ((x) + 0x004) #define CPG_PLL_CLK1_KDIV(x) ((s16)FIELD_GET(GENMASK(31, 16), (x))) #define CPG_PLL_CLK1_MDIV(x) FIELD_GET(GENMASK(15, 6), (x)) @@ -79,6 +85,8 @@ * @last_dt_core_clk: ID of the last Core Clock exported to DT * @mstop_count: Array of mstop values * @rcdev: Reset controller entity + * @dsi_limits: PLL DSI parameters limits + * @plldsi_div_parameters: PLL DSI and divider parameters configuration */ struct rzv2h_cpg_priv { struct device *dev; @@ -95,6 +103,9 @@ struct rzv2h_cpg_priv { atomic_t *mstop_count; =20 struct reset_controller_dev rcdev; + + const struct rzv2h_pll_div_limits *dsi_limits; + struct rzv2h_plldsi_parameters plldsi_div_parameters; }; =20 #define rcdev_to_priv(x) container_of(x, struct rzv2h_cpg_priv, rcdev) @@ -150,6 +161,24 @@ struct ddiv_clk { =20 #define to_ddiv_clock(_div) container_of(_div, struct ddiv_clk, div) =20 +/** + * struct rzv2h_plldsi_div_clk - PLL DSI DDIV clock + * + * @dtable: divider table + * @priv: CPG private data + * @hw: divider clk + * @ddiv: divider configuration + */ +struct rzv2h_plldsi_div_clk { + const struct clk_div_table *dtable; + struct rzv2h_cpg_priv *priv; + struct clk_hw hw; + struct ddiv ddiv; +}; + +#define to_plldsi_div_clk(_hw) \ + container_of(_hw, struct rzv2h_plldsi_div_clk, hw) + static int rzv2h_cpg_pll_clk_is_enabled(struct clk_hw *hw) { struct pll_clk *pll_clk =3D to_pll(hw); @@ -198,6 +227,188 @@ static int rzv2h_cpg_pll_clk_enable(struct clk_hw *hw) return ret; } =20 +static unsigned long rzv2h_cpg_plldsi_div_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + struct rzv2h_plldsi_div_clk *dsi_div =3D to_plldsi_div_clk(hw); + struct rzv2h_cpg_priv *priv =3D dsi_div->priv; + struct ddiv ddiv =3D dsi_div->ddiv; + u32 div; + + div =3D readl(priv->base + ddiv.offset); + div >>=3D ddiv.shift; + div &=3D clk_div_mask(ddiv.width); + div =3D dsi_div->dtable[div].div; + + return DIV_ROUND_CLOSEST_ULL(parent_rate, div); +} + +static int rzv2h_cpg_plldsi_div_determine_rate(struct clk_hw *hw, + struct clk_rate_request *req) +{ + struct rzv2h_plldsi_div_clk *dsi_div =3D to_plldsi_div_clk(hw); + struct rzv2h_cpg_priv *priv =3D dsi_div->priv; + struct rzv2h_plldsi_parameters *dsi_dividers =3D &priv->plldsi_div_parame= ters; + u64 rate_millihz; + + /* + * Adjust the requested clock rate (`req->rate`) to ensure it falls within + * the supported range of 5.44 MHz to 187.5 MHz. + */ + req->rate =3D clamp(req->rate, 5440000UL, 187500000UL); + + rate_millihz =3D mul_u32_u32(req->rate, MILLI); + if (rate_millihz =3D=3D dsi_dividers->error_millihz + dsi_dividers->freq_= millihz) + goto exit_determine_rate; + + if (!rzv2h_dsi_get_pll_parameters_values(priv->dsi_limits, + dsi_dividers, rate_millihz)) { + dev_err(priv->dev, + "failed to determine rate for req->rate: %lu\n", + req->rate); + return -EINVAL; + } + +exit_determine_rate: + req->best_parent_rate =3D req->rate * dsi_dividers->csdiv; + + return 0; +}; + +static int rzv2h_cpg_plldsi_div_set_rate(struct clk_hw *hw, + unsigned long rate, + unsigned long parent_rate) +{ + struct rzv2h_plldsi_div_clk *dsi_div =3D to_plldsi_div_clk(hw); + struct rzv2h_cpg_priv *priv =3D dsi_div->priv; + struct rzv2h_plldsi_parameters *dsi_dividers =3D &priv->plldsi_div_parame= ters; + struct ddiv ddiv =3D dsi_div->ddiv; + const struct clk_div_table *clkt; + bool div_found =3D false; + u32 val, shift, div; + + div =3D dsi_dividers->csdiv; + for (clkt =3D dsi_div->dtable; clkt->div; clkt++) { + if (clkt->div =3D=3D div) { + div_found =3D true; + break; + } + } + + if (!div_found) + return -EINVAL; + + shift =3D ddiv.shift; + val =3D readl(priv->base + ddiv.offset) | DDIV_DIVCTL_WEN(shift); + val &=3D ~(clk_div_mask(ddiv.width) << shift); + val |=3D (u32)clkt->val << shift; + writel(val, priv->base + ddiv.offset); + + return 0; +}; + +static const struct clk_ops rzv2h_cpg_plldsi_div_ops =3D { + .recalc_rate =3D rzv2h_cpg_plldsi_div_recalc_rate, + .determine_rate =3D rzv2h_cpg_plldsi_div_determine_rate, + .set_rate =3D rzv2h_cpg_plldsi_div_set_rate, +}; + +static struct clk * __init +rzv2h_cpg_plldsi_div_clk_register(const struct cpg_core_clk *core, + struct rzv2h_cpg_priv *priv) +{ + struct rzv2h_plldsi_div_clk *clk_hw_data; + struct clk **clks =3D priv->clks; + struct clk_init_data init; + const struct clk *parent; + const char *parent_name; + struct clk_hw *clk_hw; + int ret; + + parent =3D clks[core->parent]; + if (IS_ERR(parent)) + return ERR_CAST(parent); + + clk_hw_data =3D devm_kzalloc(priv->dev, sizeof(*clk_hw_data), GFP_KERNEL); + if (!clk_hw_data) + return ERR_PTR(-ENOMEM); + + clk_hw_data->priv =3D priv; + clk_hw_data->ddiv =3D core->cfg.ddiv; + clk_hw_data->dtable =3D core->dtable; + + parent_name =3D __clk_get_name(parent); + init.name =3D core->name; + init.ops =3D &rzv2h_cpg_plldsi_div_ops; + init.flags =3D core->flag; + init.parent_names =3D &parent_name; + init.num_parents =3D 1; + + clk_hw =3D &clk_hw_data->hw; + clk_hw->init =3D &init; + + ret =3D devm_clk_hw_register(priv->dev, clk_hw); + if (ret) + return ERR_PTR(ret); + + return clk_hw->clk; +} + +static long rzv2h_cpg_plldsi_round_rate(struct clk_hw *hw, + unsigned long rate, + unsigned long *parent_rate) +{ + return clamp(rate, 25000000UL, 375000000UL); +} + +static int rzv2h_cpg_pll_set_rate(struct clk_hw *hw, + unsigned long rate, + unsigned long parent_rate) +{ + struct pll_clk *pll_clk =3D to_pll(hw); + struct rzv2h_cpg_priv *priv =3D pll_clk->priv; + struct rzv2h_plldsi_parameters *dsi_dividers; + struct pll pll =3D pll_clk->pll; + u16 offset =3D pll.offset; + u32 val; + int ret; + + /* Put PLL into standby mode */ + writel(CPG_PLL_STBY_RESETB_WEN, priv->base + CPG_PLL_STBY(offset)); + ret =3D readl_poll_timeout_atomic(priv->base + CPG_PLL_MON(offset), + val, !(val & CPG_PLL_MON_LOCK), + 100, 2000); + if (ret) { + dev_err(priv->dev, "Failed to put PLLDSI into standby mode"); + return ret; + } + + dsi_dividers =3D &priv->plldsi_div_parameters; + /* Output clock setting 1 */ + writel((dsi_dividers->k << 16) | (dsi_dividers->m << 6) | (dsi_dividers->= p), + priv->base + CPG_PLL_CLK1(offset)); + + /* Output clock setting 2 */ + val =3D readl(priv->base + CPG_PLL_CLK2(offset)); + writel((val & ~GENMASK(2, 0)) | dsi_dividers->s, + priv->base + CPG_PLL_CLK2(offset)); + + /* Put PLL to normal mode */ + writel(CPG_PLL_STBY_RESETB_WEN | CPG_PLL_STBY_RESETB, + priv->base + CPG_PLL_STBY(offset)); + + /* PLL normal mode transition, output clock stability check */ + ret =3D readl_poll_timeout_atomic(priv->base + CPG_PLL_MON(offset), + val, (val & CPG_PLL_MON_LOCK), + 100, 2000); + if (ret) { + dev_err(priv->dev, "Failed to put PLLDSI into normal mode"); + return ret; + } + + return 0; +}; + static unsigned long rzv2h_cpg_pll_clk_recalc_rate(struct clk_hw *hw, unsigned long parent_rate) { @@ -219,6 +430,12 @@ static unsigned long rzv2h_cpg_pll_clk_recalc_rate(str= uct clk_hw *hw, return DIV_ROUND_CLOSEST_ULL(rate, CPG_PLL_CLK1_PDIV(clk1)); } =20 +static const struct clk_ops rzv2h_cpg_plldsi_ops =3D { + .recalc_rate =3D rzv2h_cpg_pll_clk_recalc_rate, + .round_rate =3D rzv2h_cpg_plldsi_round_rate, + .set_rate =3D rzv2h_cpg_pll_set_rate, +}; + static const struct clk_ops rzv2h_cpg_pll_ops =3D { .is_enabled =3D rzv2h_cpg_pll_clk_is_enabled, .enable =3D rzv2h_cpg_pll_clk_enable, @@ -228,7 +445,8 @@ static const struct clk_ops rzv2h_cpg_pll_ops =3D { static struct clk * __init rzv2h_cpg_pll_clk_register(const struct cpg_core_clk *core, struct rzv2h_cpg_priv *priv, - const struct clk_ops *ops) + const struct clk_ops *ops, + bool turn_on) { void __iomem *base =3D priv->base; struct device *dev =3D priv->dev; @@ -258,6 +476,13 @@ rzv2h_cpg_pll_clk_register(const struct cpg_core_clk *= core, pll_clk->base =3D base; pll_clk->priv =3D priv; =20 + if (turn_on) { + /* Disable SSC and turn on PLL clock when init */ + writel(CPG_PLL_STBY_RESETB_WEN | CPG_PLL_STBY_RESETB | + CPG_PLL_STBY_SSCGEN_WEN, + base + CPG_PLL_STBY(pll_clk->pll.offset)); + } + ret =3D devm_clk_hw_register(dev, &pll_clk->hw); if (ret) return ERR_PTR(ret); @@ -499,7 +724,7 @@ rzv2h_cpg_register_core_clk(const struct cpg_core_clk *= core, clk =3D clk_hw->clk; break; case CLK_TYPE_PLL: - clk =3D rzv2h_cpg_pll_clk_register(core, priv, &rzv2h_cpg_pll_ops); + clk =3D rzv2h_cpg_pll_clk_register(core, priv, &rzv2h_cpg_pll_ops, false= ); break; case CLK_TYPE_DDIV: clk =3D rzv2h_cpg_ddiv_clk_register(core, priv); @@ -507,6 +732,12 @@ rzv2h_cpg_register_core_clk(const struct cpg_core_clk = *core, case CLK_TYPE_SMUX: clk =3D rzv2h_cpg_mux_clk_register(core, priv); break; + case CLK_TYPE_PLLDSI: + clk =3D rzv2h_cpg_pll_clk_register(core, priv, &rzv2h_cpg_plldsi_ops, tr= ue); + break; + case CLK_TYPE_PLLDSI_DIV: + clk =3D rzv2h_cpg_plldsi_div_clk_register(core, priv); + break; default: goto fail; } @@ -1043,6 +1274,8 @@ static int __init rzv2h_cpg_probe(struct platform_dev= ice *pdev) priv->last_dt_core_clk =3D info->last_dt_core_clk; priv->num_resets =3D info->num_resets; =20 + priv->dsi_limits =3D info->plldsi_limits; + for (i =3D 0; i < nclks; i++) clks[i] =3D ERR_PTR(-ENOENT); =20 diff --git a/drivers/clk/renesas/rzv2h-cpg.h b/drivers/clk/renesas/rzv2h-cp= g.h index cd6bcd4f2901..6f662fa86ac4 100644 --- a/drivers/clk/renesas/rzv2h-cpg.h +++ b/drivers/clk/renesas/rzv2h-cpg.h @@ -100,6 +100,7 @@ struct smuxed { #define CPG_CDDIV3 (0x40C) #define CPG_CDDIV4 (0x410) #define CPG_CSDIV0 (0x500) +#define CPG_CSDIV1 (0x504) =20 #define CDDIV0_DIVCTL1 DDIV_PACK(CPG_CDDIV0, 4, 3, 1) #define CDDIV0_DIVCTL2 DDIV_PACK(CPG_CDDIV0, 8, 3, 2) @@ -168,6 +169,8 @@ enum clk_types { CLK_TYPE_PLL, CLK_TYPE_DDIV, /* Dynamic Switching Divider */ CLK_TYPE_SMUX, /* Static Mux */ + CLK_TYPE_PLLDSI, /* PLLDSI */ + CLK_TYPE_PLLDSI_DIV, /* PLLDSI divider */ }; =20 #define DEF_TYPE(_name, _id, _type...) \ @@ -195,6 +198,14 @@ enum clk_types { .num_parents =3D ARRAY_SIZE(_parent_names), \ .flag =3D CLK_SET_RATE_PARENT, \ .mux_flags =3D CLK_MUX_HIWORD_MASK) +#define DEF_PLLDSI(_name, _id, _parent, _pll_packed) \ + DEF_TYPE(_name, _id, CLK_TYPE_PLLDSI, .parent =3D _parent, .cfg.pll =3D _= pll_packed) +#define DEF_PLLDSI_DIV(_name, _id, _parent, _ddiv_packed, _dtable) \ + DEF_TYPE(_name, _id, CLK_TYPE_PLLDSI_DIV, \ + .cfg.ddiv =3D _ddiv_packed, \ + .dtable =3D _dtable, \ + .parent =3D _parent, \ + .flag =3D CLK_SET_RATE_PARENT) =20 /** * struct rzv2h_mod_clk - Module Clocks definitions @@ -295,6 +306,7 @@ struct rzv2h_reset { * * @num_mstop_bits: Maximum number of MSTOP bits supported, equivalent to = the * number of CPG_BUS_m_MSTOP registers multiplied by 16. + * @plldsi_limits: PLL DSI parameters limits */ struct rzv2h_cpg_info { /* Core Clocks */ @@ -313,6 +325,8 @@ struct rzv2h_cpg_info { unsigned int num_resets; =20 unsigned int num_mstop_bits; + + const struct rzv2h_pll_div_limits *plldsi_limits; }; =20 extern const struct rzv2h_cpg_info r9a09g047_cpg_info; diff --git a/include/linux/clk/renesas-rzv2h-dsi.h b/include/linux/clk/rene= sas-rzv2h-dsi.h new file mode 100644 index 000000000000..faecb5d49c20 --- /dev/null +++ b/include/linux/clk/renesas-rzv2h-dsi.h @@ -0,0 +1,211 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Renesas RZ/V2H(P) DSI CPG helper + * + * Copyright (C) 2025 Renesas Electronics Corp. + */ +#ifndef __RENESAS_RZV2H_DSI_H__ +#define __RENESAS_RZV2H_DSI_H__ + +#include +#include +#include +#include + +#define OSC_CLK_IN_MEGA (24 * MEGA) + +struct rzv2h_pll_div_limits { + struct { + u32 min; + u32 max; + } fvco; + + struct { + u16 min; + u16 max; + } m; + + struct { + u8 min; + u8 max; + } p; + + struct { + u8 min; + u8 max; + } s; + + struct { + s16 min; + s16 max; + } k; + + struct { + u8 min; + u8 max; + } csdiv; +}; + +struct rzv2h_plldsi_parameters { + u64 freq_millihz; + s64 error_millihz; + u16 m; + s16 k; + u8 csdiv; + u8 p; + u8 s; +}; + +#define RZV2H_CPG_PLL_DSI_LIMITS(name) \ + static const struct rzv2h_pll_div_limits (name) =3D { \ + .fvco =3D { .min =3D 1600 * MEGA, .max =3D 3200 * MEGA }, \ + .m =3D { .min =3D 64, .max =3D 533 }, \ + .p =3D { .min =3D 1, .max =3D 4 }, \ + .s =3D { .min =3D 0, .max =3D 6 }, \ + .k =3D { .min =3D -32768, .max =3D 32767 }, \ + .csdiv =3D { .min =3D 2, .max =3D 32 }, \ + } \ + +/** + * rzv2h_dsi_get_pll_parameters_values - Finds the best combination of PLL= parameters + * and divider value for a given frequency. + * + * @limits: Pointer to the structure containing the limits for the PLL par= ameters and + * divider values + * @pars: Pointer to the structure where the best calculated PLL parameter= s and divider + * values will be stored + * @freq_millihz: Target output frequency in millihertz + * + * This function calculates the best set of PLL parameters (M, K, P, S) an= d divider + * value (CSDIV) to achieve the desired frequency. + * There is no direct formula to calculate the PLL parameters and the divi= der value, + * as it's an open system of equations, therefore this function uses an it= erative + * approach to determine the best solution. The best solution is one that = minimizes + * the error (desired frequency - actual frequency). + * + * Return: true if a valid set of divider values is found, false otherwise. + */ +static __maybe_unused bool +rzv2h_dsi_get_pll_parameters_values(const struct rzv2h_pll_div_limits *lim= its, + struct rzv2h_plldsi_parameters *pars, + u64 freq_millihz) +{ + struct rzv2h_plldsi_parameters p, best; + + /* Initialize best error to maximum possible value */ + best.error_millihz =3D S64_MAX; + + for (p.csdiv =3D limits->csdiv.min; p.csdiv <=3D limits->csdiv.max; p.csd= iv +=3D 2) { + for (p.p =3D limits->p.min; p.p <=3D limits->p.max; p.p++) { + u32 fref =3D OSC_CLK_IN_MEGA / p.p; + + for (p.s =3D limits->s.min; p.s <=3D limits->s.max; p.s++) { + u16 two_pow_s =3D 1 << p.s; + u16 divider =3D two_pow_s * p.csdiv; + + for (p.m =3D limits->m.min; p.m <=3D limits->m.max; p.m++) { + u64 output_m, output_k_range; + s64 pll_k, output_k; + u64 fvco, output; + + /* + * The frequency generated by the combination of the + * PLL + divider is calculated as follows: + * + * Freq =3D Ffout / csdiv + * + * With: + * Ffout =3D Ffvco / 2^(pll_s) + * Ffvco =3D (pll_m + (pll_k / 65536)) * Ffref + * Ffref =3D 24MHz / pll_p + * + * Freq can also be rewritten as: + * Freq =3D Ffvco / (2^(pll_s) * csdiv)) + * =3D Ffvco / divider + * =3D (pll_m * Ffref) / divider + ((pll_k / 65536) * Ffref) / d= ivider + * =3D output_m + output_k + * + * Every parameter has been determined at this point, but pll_k. + * Considering that: + * -32768 <=3D pll_k <=3D 32767 + * Then: + * -0.5 <=3D (pll_k / 65536) < 0.5 + * Therefore: + * -Ffref / (2 * divider) <=3D output_k < Ffref / (2 * divider) + */ + + /* Compute output M component (in mHz) */ + output_m =3D DIV_ROUND_CLOSEST_ULL(p.m * fref * 1000ULL, + divider); + /* Compute range for output K (in mHz) */ + output_k_range =3D DIV_ROUND_CLOSEST_ULL(fref * 1000ULL, + divider * 2); + /* + * No point in continuing if we can't achieve the + * desired frequency + */ + if (freq_millihz < (output_m - output_k_range) || + freq_millihz >=3D (output_m + output_k_range)) + continue; + + /* + * Compute the K component + * + * Since: + * Freq =3D output_m + output_k + * Then: + * output_k =3D Freq - output_m + * =3D ((pll_k / 65536) * Ffref) / divider + * Therefore: + * pll_k =3D (output_k * 65536 * divider) / Ffref + */ + output_k =3D freq_millihz - output_m; + pll_k =3D div64_s64(output_k * 65536ULL * divider, fref); + pll_k =3D DIV_S64_ROUND_CLOSEST(pll_k, 1000); + + /* Validate K value within allowed limits */ + if (pll_k < limits->k.min || pll_k > limits->k.max) + continue; + + p.k =3D pll_k; + + /* Compute (Ffvco * 65536) */ + fvco =3D ((p.m * 65536ULL) + p.k) * fref; + if ((fvco < (limits->fvco.min * 65536ULL)) || + (fvco > (limits->fvco.max * 65536ULL))) + continue; + + /* PLL_M component of (output * 65536 * PLL_P) */ + output =3D p.m * 65536ULL * OSC_CLK_IN_MEGA; + /* PLL_K component of (output * 65536 * PLL_P) */ + output +=3D p.k * OSC_CLK_IN_MEGA; + /* Make it in mHz */ + output *=3D 1000ULL; + output /=3D 65536ULL * p.p * divider; + + p.error_millihz =3D freq_millihz - output; + p.freq_millihz =3D output; + + /* If an exact match is found, return immediately */ + if (p.error_millihz =3D=3D 0) { + *pars =3D p; + return true; + } + + /* Update best match if error is smaller */ + if (abs(best.error_millihz) > abs(p.error_millihz)) + best =3D p; + } + } + } + } + + /* If no valid parameters were found, return false */ + if (best.error_millihz =3D=3D S64_MAX) + return false; + + *pars =3D best; + return true; +} + +#endif /* __RENESAS_RZV2H_DSI_H__ */ --=20 2.49.0 From nobody Mon Feb 9 14:59:27 2026 Received: from mail-wr1-f44.google.com (mail-wr1-f44.google.com [209.85.221.44]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D9163296D2E; Mon, 12 May 2025 18:43:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.44 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075392; cv=none; b=DPSMy/8MGKP8aWcf0wUasjV/LMh/1kV4HXvuLPSuXp0uZZEl8e3X1Md37e1L+RVFDy/ao9Z1cWaupbox4OAmWMNnIsJZQ80lBwgP+8Clbn1S2lnnzC5Kc4u4PWbjhFm4kHVHWB6DqxrF38d9N5BObLH7HjONNSrLWymOD5+zuSw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075392; c=relaxed/simple; bh=lY5aLtCni7q6rIgVuqoKqLTTUjk3cpznh3nx6uOaBww=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mTcYko6Ux2dgL8GXKmbGiJAGgOC08WMKweuqhe4Gpjj/7HC0uwqT5kPNQRqThIZBHlLsA7v4GpAM/+S061ItYJ7/vWTiTCKzwX9jMSW+yM0u6Bp5IdTvXEuV/zzxHUs64diMg/jMKptQb3CDc/iVnnksCmjm50UddTIJNlMta/g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=T9fjwkGE; arc=none smtp.client-ip=209.85.221.44 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="T9fjwkGE" Received: by mail-wr1-f44.google.com with SMTP id ffacd0b85a97d-3a1d8c09683so2656402f8f.0; Mon, 12 May 2025 11:43:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1747075389; x=1747680189; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=azMvcNcz3TPSpcIeI7nA8x1lWHBnDiML7/XRfEHnVf0=; b=T9fjwkGEH3ks2PQh8IU3F2r7R4R6zaAtM4V+r8UsWAWN5y2Bx6cru0CjAaUoVpCoM+ 3C2e1ygkaPACVgj9BFeax3QjDGY0RpWjk00Jcp4Wa+P31F3Fwf109FyiVvxDSoNLxJ9x g8h6Sq0LR95r1zi9v7EAhtEINXjY9pIDp8ZMRAA6GX7piYHaL0utRMrqhJb9od7p5Onr pKcNsp+cQ9G17IYl0VbIV4JFJivWH4WWXd4hqg7VgoHbpn2dEUYaqKUeejSnzYbFDe5z 97aJ7AFdSF/0+abEIbfGIMoJd/KI9urLu6A07y3UwRtQpb7Gb6rG69QrI+UKdZ9JvO2N MZHg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747075389; x=1747680189; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=azMvcNcz3TPSpcIeI7nA8x1lWHBnDiML7/XRfEHnVf0=; b=h5pq/0txNlf2mbOwAzMXiMzq3UPknFsrBU+EMkMuUekR5IfAf4gykdL2WdSdBHLp73 49QmISNQrBvk3ptxU0BWNg/wZjTZyxWSkpbjs9wyT82UY8O/Pjmo2EgO1Kr2ALMzCWMp T6VYzvkfJz8cRRm6jOuhaDQLt/TqGVyQV6US/+z2cWCgj0W81Cz6D43Ks/R0LMveRuOl 4XWlGniqlux/7fGLgnmLSoSh6LCtz43CvNBhQO1nkx8192OcliK6mui3MKdWviD1/472 65NfBCXnlkpdKBPD7eQRvlEF1359VcvRBOXEVM1apGmXOzF7tvUck7Ik/45Eeg/Dq9V2 uqXA== X-Forwarded-Encrypted: i=1; AJvYcCU6bril4NoyjmBCXOmTIsb8T4MkC7dTImLK5NA04oak5pyqLcUlQw7eYIEy5/vI8lr3eWnLrTRGPIZsMsoK5sl6/j0=@vger.kernel.org, AJvYcCUzN/vVlsinUNk58EF4aq9BplrwFD8+q58JeqXcjdL1RQY89bhbLRjZ2e5PIGqp53aMShE5DqB8ATDB@vger.kernel.org, AJvYcCVnr/Bi3xrGWpKp2c80cRzkMcwX07FQxkOB7QDBEmKW/BSlzODgILYMHr4lsxiTdCfCsUQioOPmIZj3@vger.kernel.org, AJvYcCWLPYs8AmfVmteebgkf6KD9eSxb5hvj5rMngfk9ascu3kGyRna1adZv+itsSJmXnF8kdAhgTo56nH6ZJO3B@vger.kernel.org X-Gm-Message-State: AOJu0Yx1v4rkWbUpp4v3a3cht3Os57ZruKEZfre+MaWddH1yPpoQ9SwA lxxxz6O0kXL48vBD2/93j6ajOYHh3q0NW7qvwdShsIpXGTX4KYl1 X-Gm-Gg: ASbGncvughurNv+sNLFAM4jriYOoHndNv97yPOOY9IN0vkc7PqelCPPGBQp0s+/JpN6 gWf9zh5ZUMiag+f6G6zRTmleNBcE1kAZ6cBWgnDDc8yH48Wi7lCz6CIRJcMB5Q4Q0WXTeyW13B9 3Uc4qLQpdvezgzsFBQdJCrxymlr2KAAs1xhPul4jkOrnxgv4G7AQI1FKKfygUY7lBnA0RpbE7O9 Y05Gh4ehBKBE5GF/H1cDsIBQI/QhQiK7JcHqyR9918p+ocwmk675mkQYvlF5yCR4UfLqvU9QA04 cDWrzMqyYztYdMdwD2bt8orwyP8SFWwEmpJV9IV97BlsAlvwyfNaMPh7F3XIcJ/VdYOQFJu2koY i X-Google-Smtp-Source: AGHT+IGFClg3IwDwx4DURAlaVvKP/mmEHxfypUn+RQTuJTpjwIaYcxr0sukduLrQJznf3IjTHsg3cQ== X-Received: by 2002:adf:e647:0:b0:3a1:f78a:42f7 with SMTP id ffacd0b85a97d-3a1f78a49dfmr9352353f8f.32.1747075388933; Mon, 12 May 2025 11:43:08 -0700 (PDT) Received: from iku.Home ([2a06:5906:61b:2d00:581b:951a:bc46:a124]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a1f57ddd53sm13309203f8f.1.2025.05.12.11.43.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 12 May 2025 11:43:08 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , David Airlie , Simona Vetter , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Geert Uytterhoeven , Michael Turquette , Stephen Boyd , Biju Das , Magnus Damm Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-renesas-soc@vger.kernel.org, linux-clk@vger.kernel.org, Prabhakar , Fabrizio Castro , Lad Prabhakar Subject: [PATCH v5 2/4] clk: renesas: r9a09g057: Add clock and reset entries for DSI and LCDC Date: Mon, 12 May 2025 19:43:00 +0100 Message-ID: <20250512184302.241417-3-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Lad Prabhakar Add clock and reset entries for the DSI and LCDC peripherals. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar --- v4->v5: - No changes v3->v4: - No changes v2->v3: - Reverted CSDIV0_DIVCTL2() to use DDIV_PACK() - Renamed plleth_lpclk_div4 -> cdiv4_plleth_lpclk - Renamed plleth_lpclk -> plleth_lpclk_gear v1->v2: - Changed CSDIV0_DIVCTL2 to the NO_RMW --- drivers/clk/renesas/r9a09g057-cpg.c | 63 +++++++++++++++++++++++++++++ drivers/clk/renesas/rzv2h-cpg.h | 3 ++ 2 files changed, 66 insertions(+) diff --git a/drivers/clk/renesas/r9a09g057-cpg.c b/drivers/clk/renesas/r9a0= 9g057-cpg.c index da908e820950..a79b67181f11 100644 --- a/drivers/clk/renesas/r9a09g057-cpg.c +++ b/drivers/clk/renesas/r9a09g057-cpg.c @@ -6,6 +6,7 @@ */ =20 #include +#include #include #include #include @@ -30,6 +31,7 @@ enum clk_ids { CLK_PLLCA55, CLK_PLLVDO, CLK_PLLETH, + CLK_PLLDSI, CLK_PLLGPU, =20 /* Internal Core Clocks */ @@ -58,6 +60,9 @@ enum clk_ids { CLK_SMUX2_GBE0_RXCLK, CLK_SMUX2_GBE1_TXCLK, CLK_SMUX2_GBE1_RXCLK, + CLK_DIV_PLLETH_LPCLK, + CLK_CSDIV_PLLETH_LPCLK, + CLK_PLLDSI_SDIV2, CLK_PLLGPU_GEAR, =20 /* Module Clocks */ @@ -78,6 +83,26 @@ static const struct clk_div_table dtable_2_4[] =3D { {0, 0}, }; =20 +static const struct clk_div_table dtable_2_32[] =3D { + {0, 2}, + {1, 4}, + {2, 6}, + {3, 8}, + {4, 10}, + {5, 12}, + {6, 14}, + {7, 16}, + {8, 18}, + {9, 20}, + {10, 22}, + {11, 24}, + {12, 26}, + {13, 28}, + {14, 30}, + {15, 32}, + {0, 0}, +}; + static const struct clk_div_table dtable_2_64[] =3D { {0, 2}, {1, 4}, @@ -94,6 +119,14 @@ static const struct clk_div_table dtable_2_100[] =3D { {0, 0}, }; =20 +static const struct clk_div_table dtable_16_128[] =3D { + {0, 16}, + {1, 32}, + {2, 64}, + {3, 128}, + {0, 0}, +}; + /* Mux clock tables */ static const char * const smux2_gbe0_rxclk[] =3D { ".plleth_gbe0", "et0_rx= clk" }; static const char * const smux2_gbe0_txclk[] =3D { ".plleth_gbe0", "et0_tx= clk" }; @@ -113,6 +146,7 @@ static const struct cpg_core_clk r9a09g057_core_clks[] = __initconst =3D { DEF_PLL(".pllca55", CLK_PLLCA55, CLK_QEXTAL, PLLCA55), DEF_FIXED(".pllvdo", CLK_PLLVDO, CLK_QEXTAL, 105, 2), DEF_FIXED(".plleth", CLK_PLLETH, CLK_QEXTAL, 125, 3), + DEF_PLLDSI(".plldsi", CLK_PLLDSI, CLK_QEXTAL, PLLDSI), DEF_PLL(".pllgpu", CLK_PLLGPU, CLK_QEXTAL, PLLGPU), =20 /* Internal Core Clocks */ @@ -148,6 +182,12 @@ static const struct cpg_core_clk r9a09g057_core_clks[]= __initconst =3D { DEF_SMUX(".smux2_gbe0_rxclk", CLK_SMUX2_GBE0_RXCLK, SSEL0_SELCTL3, smux2_= gbe0_rxclk), DEF_SMUX(".smux2_gbe1_txclk", CLK_SMUX2_GBE1_TXCLK, SSEL1_SELCTL0, smux2_= gbe1_txclk), DEF_SMUX(".smux2_gbe1_rxclk", CLK_SMUX2_GBE1_RXCLK, SSEL1_SELCTL1, smux2_= gbe1_rxclk), + DEF_FIXED(".cdiv4_plleth_lpclk", CLK_DIV_PLLETH_LPCLK, CLK_PLLETH, 1, 4), + DEF_CSDIV(".plleth_lpclk_gear", CLK_CSDIV_PLLETH_LPCLK, CLK_DIV_PLLETH_LP= CLK, + CSDIV0_DIVCTL2, dtable_16_128), + + DEF_PLLDSI_DIV(".plldsi_sdiv2", CLK_PLLDSI_SDIV2, CLK_PLLDSI, + CSDIV1_DIVCTL2, dtable_2_32), =20 DEF_DDIV(".pllgpu_gear", CLK_PLLGPU_GEAR, CLK_PLLGPU, CDDIV3_DIVCTL1, dta= ble_2_64), =20 @@ -319,6 +359,22 @@ static const struct rzv2h_mod_clk r9a09g057_mod_clks[]= __initconst =3D { BUS_MSTOP(9, BIT(7))), DEF_MOD("cru_3_pclk", CLK_PLLDTY_DIV16, 13, 13, 6, 29, BUS_MSTOP(9, BIT(7))), + DEF_MOD("dsi_0_pclk", CLK_PLLDTY_DIV16, 14, 8, 7, 8, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("dsi_0_aclk", CLK_PLLDTY_ACPU_DIV2, 14, 9, 7, 9, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("dsi_0_vclk1", CLK_PLLDSI_SDIV2, 14, 10, 7, 10, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("dsi_0_lpclk", CLK_CSDIV_PLLETH_LPCLK, 14, 11, 7, 11, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("dsi_0_pllref_clk", CLK_QEXTAL, 14, 12, 7, 12, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("lcdc_0_clk_a", CLK_PLLDTY_ACPU_DIV2, 14, 13, 7, 13, + BUS_MSTOP(10, BIT(1) | BIT(2) | BIT(3))), + DEF_MOD("lcdc_0_clk_p", CLK_PLLDTY_DIV16, 14, 14, 7, 14, + BUS_MSTOP(10, BIT(1) | BIT(2) | BIT(3))), + DEF_MOD("lcdc_0_clk_d", CLK_PLLDSI_SDIV2, 14, 15, 7, 15, + BUS_MSTOP(10, BIT(1) | BIT(2) | BIT(3))), DEF_MOD("gpu_0_clk", CLK_PLLGPU_GEAR, 15, 0, 7, 16, BUS_MSTOP(3, BIT(4))), DEF_MOD("gpu_0_axi_clk", CLK_PLLDTY_ACPU_DIV2, 15, 1, 7, 17, @@ -380,11 +436,16 @@ static const struct rzv2h_reset r9a09g057_resets[] __= initconst =3D { DEF_RST(12, 14, 5, 31), /* CRU_3_PRESETN */ DEF_RST(12, 15, 6, 0), /* CRU_3_ARESETN */ DEF_RST(13, 0, 6, 1), /* CRU_3_S_RESETN */ + DEF_RST(13, 7, 6, 8), /* DSI_0_PRESETN */ + DEF_RST(13, 8, 6, 9), /* DSI_0_ARESETN */ + DEF_RST(13, 12, 6, 13), /* LCDC_0_RESET_N */ DEF_RST(13, 13, 6, 14), /* GPU_0_RESETN */ DEF_RST(13, 14, 6, 15), /* GPU_0_AXI_RESETN */ DEF_RST(13, 15, 6, 16), /* GPU_0_ACE_RESETN */ }; =20 +RZV2H_CPG_PLL_DSI_LIMITS(rzv2h_cpg_pll_dsi_limits); + const struct rzv2h_cpg_info r9a09g057_cpg_info __initconst =3D { /* Core Clocks */ .core_clks =3D r9a09g057_core_clks, @@ -402,4 +463,6 @@ const struct rzv2h_cpg_info r9a09g057_cpg_info __initco= nst =3D { .num_resets =3D ARRAY_SIZE(r9a09g057_resets), =20 .num_mstop_bits =3D 192, + + .plldsi_limits =3D &rzv2h_cpg_pll_dsi_limits, }; diff --git a/drivers/clk/renesas/rzv2h-cpg.h b/drivers/clk/renesas/rzv2h-cp= g.h index 6f662fa86ac4..e7570db1ccf5 100644 --- a/drivers/clk/renesas/rzv2h-cpg.h +++ b/drivers/clk/renesas/rzv2h-cpg.h @@ -28,6 +28,7 @@ struct pll { }) =20 #define PLLCA55 PLL_PACK(0x60, 1) +#define PLLDSI PLL_PACK(0xc0, 1) #define PLLGPU PLL_PACK(0x120, 1) =20 /** @@ -122,6 +123,8 @@ struct smuxed { =20 #define CSDIV0_DIVCTL0 DDIV_PACK(CPG_CSDIV0, 0, 2, CSDIV_NO_MON) #define CSDIV0_DIVCTL1 DDIV_PACK(CPG_CSDIV0, 4, 2, CSDIV_NO_MON) +#define CSDIV0_DIVCTL2 DDIV_PACK(CPG_CSDIV0, 8, 2, CSDIV_NO_MON) +#define CSDIV1_DIVCTL2 DDIV_PACK(CPG_CSDIV1, 8, 4, CSDIV_NO_MON) =20 #define SSEL0_SELCTL2 SMUX_PACK(CPG_SSEL0, 8, 1) #define SSEL0_SELCTL3 SMUX_PACK(CPG_SSEL0, 12, 1) --=20 2.49.0 From nobody Mon Feb 9 14:59:27 2026 Received: from mail-wr1-f53.google.com (mail-wr1-f53.google.com [209.85.221.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 89CFC296FBA; Mon, 12 May 2025 18:43:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075394; cv=none; b=LSgWUzC1lFnCGnNMl7KQHaYkxgXX8MdQZaXtlLZHc8YNSv3BAV5b0+NBmC77SbzfPXn2TONGjsHgZ3RhRvG4dY8dlyB4xEYaP2Pe6XvAs7RpGEpJB8ojlS9jPxXOLrSIP8tJ3osKYvNDslrbLfDgaTveqn5eI1yGLXpYPlyAReI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075394; c=relaxed/simple; bh=ZqUapxjat4NVLHNKyOXq/tIgM0UFPoSITTlLAeX7Wpk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=GRvzk5Mfha7ELZqh0szeJ3thj1SmhMUrLJp/HpsrSqIiMa54e1O496MD4500tUNsitQeBalYjsRZqr2WqTYjN00X7EVLnvzbjRS/CY5+4CnvSOyvfFHtKLqoOBiMwSjPEwjbXOp/MtoQxK8xNuKSJE7Ogs4/icrmBZlAcWDJF28= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=FJpo5YFC; arc=none smtp.client-ip=209.85.221.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="FJpo5YFC" Received: by mail-wr1-f53.google.com with SMTP id ffacd0b85a97d-3a1d8c09683so2656425f8f.0; Mon, 12 May 2025 11:43:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1747075391; x=1747680191; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=kd8ToXBYqgNmbVcyeLHk5NPIyHmj3DKveR0qgHKffVY=; b=FJpo5YFCrZZhkN/svAmwR15978eCAtdR1gSV3Pc+44idy1SH46EE6if/BxU4P+87aT akUVwE/b+3yOAWZ/icM3AAQgTXLKksISpZ/kAo4tF1TGsuqyIVW79IBLhQVoi9j6GKDF lmIAZ8g+Fef7IUC8/ZQTzV9U46I0hEpUKBlTOCek38nknuSo6F24jioIOhpR8k0vaTq6 ogXoxXRiP7iOZOaxUmVVaEvhB+RDS/lyZvMGLRiEnXN2AxCLFZmxzKOiMcuhLm6L6iBy vRu9uixO/VkFVOKJGmODBhbgHrPmlYn9fg/uJVdDm78F/D9RAdzZxyb9hyc3Fb7UFN9b plmQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747075391; x=1747680191; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=kd8ToXBYqgNmbVcyeLHk5NPIyHmj3DKveR0qgHKffVY=; b=PmrT/Ya2LGfCXYG27EE1qh4gEfopfh3JgDRwCrIYoLCMGYhE4lAXPimEluqIj6zezL YnWia0+tGAXouH7sDbDgpMtyqkXim06cgL/468bTyCff14qTusJCPTXmddpyQM2o5wKV QxBn6Fh6TdBg1NhMlG8bon+5KJLfWtGuXrnc9OdD6ZIkH3mgCS1q3oduaZnHUmB3IPs9 r/Z5nSv7jwAX6/HwNUYDQ7WGslx+lxh34/rl+acd72jJoBdU6hW82dbcKR6lN4wor8RL ECSDmZ50VpuiqVlIFMBWsaBxydszrT6w+oMUPQwoLsFca16ygqS4feYHnymyfwsFx21e vBpg== X-Forwarded-Encrypted: i=1; AJvYcCU3VHnCYLBlo653Ggd+W2bocf7m5RMWX1e+399YAZ+WUxQgkqAHdN0CaFuxzmpe8bycLtS4ViC3Bw+L@vger.kernel.org, AJvYcCUCHuXekbsZT5tC8yqisecWUbSzBthPEc+d2ZoMAIoclV3QEYmjKlY+thMytQIOlnj0gwh2iegI+TK5@vger.kernel.org, AJvYcCWp3ccOFBW1/U5tL7f2S9eBF5zcQA9nerfKYAoGhE47WI+bH4UJBP1Lz5oDIfzIyJgfsyMCNln4yrodNRPBx1lkwDg=@vger.kernel.org, AJvYcCXQoL9/gLqjhhL6VruZQcls5jPcDV7YxDsCj26elcsixOrZ2pjzCScyl/rwYGP8Y7O68UZaCK4Fwla79v2S@vger.kernel.org X-Gm-Message-State: AOJu0Yy9qJd+2p1DjK05SygGeolHpbgOuyGqNIjrm8zIz1u+ID8VWpNc TXX1olFtn26e0SblwQpkII7MVVbdiamIKsQZmzMhQH0aCsfLDqCf X-Gm-Gg: ASbGnctO+5qrXpHW9LIVzGqiAqjm9IsjESvKgNVI37f2pBFixQ/gc6giUWo+qWGegM+ 7kOb15RlJIavbShCTm6N69uOIf9ub8qIrP7l3Y+16Es9yd5FRn/+UGezNxCDlG7+eXw+mK8b8gc uJOY437IjBv+ncvKVrEJk5STl/i9Zf7PCcLkQyV2rROoY9LELa5Q9mIW4RyUzfUF3K2inh29ley 5wCltSn/r82F11yUYIwonMUJyb4Ut13j9KZvoDeeSFv97mMXgQcSHP/Szm59gFZkEljvgSWbSFc nLFyaaqArQnJTDMvOBbLWxAAcXKlNoLmLXOYVQ8z+MEmbiPOLrnKeqUln//4taEuILp0evrin+O A X-Google-Smtp-Source: AGHT+IGI/+dH/CdURfxD6W7eKPlxKN1PN9yE2+rZsr9QKCyZcAYXw2DqE75q2i4hHMhdjtyzGe26ew== X-Received: by 2002:a05:6000:1868:b0:3a0:b392:c2f with SMTP id ffacd0b85a97d-3a1f648782cmr10654178f8f.44.1747075390143; Mon, 12 May 2025 11:43:10 -0700 (PDT) Received: from iku.Home ([2a06:5906:61b:2d00:581b:951a:bc46:a124]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a1f57ddd53sm13309203f8f.1.2025.05.12.11.43.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 12 May 2025 11:43:09 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , David Airlie , Simona Vetter , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Geert Uytterhoeven , Michael Turquette , Stephen Boyd , Biju Das , Magnus Damm Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-renesas-soc@vger.kernel.org, linux-clk@vger.kernel.org, Prabhakar , Fabrizio Castro , Lad Prabhakar , Krzysztof Kozlowski Subject: [PATCH v5 3/4] dt-bindings: display: bridge: renesas,dsi: Add support for RZ/V2H(P) SoC Date: Mon, 12 May 2025 19:43:01 +0100 Message-ID: <20250512184302.241417-4-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Lad Prabhakar The MIPI DSI interface on the RZ/V2H(P) SoC is nearly identical to that of the RZ/G2L SoC. While the LINK registers are the same for both SoCs, the D-PHY registers differ. Additionally, the number of resets for DSI on RZ/V2H(P) is two compared to three on the RZ/G2L. To accommodate these differences, a SoC-specific `renesas,r9a09g057-mipi-dsi` compatible string has been added for the RZ/V2H(P) SoC. Signed-off-by: Lad Prabhakar Reviewed-by: Krzysztof Kozlowski Reviewed-by: Geert Uytterhoeven --- v4->v5: - No changes v3->v4: - No changes v2->v3: - Collected reviewed tag from Krzysztof v1->v2: - Kept the sort order for schema validation - Added `port@1: false` for RZ/V2H(P) SoC --- .../bindings/display/bridge/renesas,dsi.yaml | 116 +++++++++++++----- 1 file changed, 87 insertions(+), 29 deletions(-) diff --git a/Documentation/devicetree/bindings/display/bridge/renesas,dsi.y= aml b/Documentation/devicetree/bindings/display/bridge/renesas,dsi.yaml index e08c24633926..5980df2b389b 100644 --- a/Documentation/devicetree/bindings/display/bridge/renesas,dsi.yaml +++ b/Documentation/devicetree/bindings/display/bridge/renesas,dsi.yaml @@ -14,16 +14,17 @@ description: | RZ/G2L alike family of SoC's. The encoder can operate in DSI mode, with up to four data lanes. =20 -allOf: - - $ref: /schemas/display/dsi-controller.yaml# - properties: compatible: - items: + oneOf: - enum: - - renesas,r9a07g044-mipi-dsi # RZ/G2{L,LC} - - renesas,r9a07g054-mipi-dsi # RZ/V2L - - const: renesas,rzg2l-mipi-dsi + - renesas,r9a09g057-mipi-dsi # RZ/V2H(P) + + - items: + - enum: + - renesas,r9a07g044-mipi-dsi # RZ/G2{L,LC} + - renesas,r9a07g054-mipi-dsi # RZ/V2L + - const: renesas,rzg2l-mipi-dsi =20 reg: maxItems: 1 @@ -49,34 +50,56 @@ properties: - const: debug =20 clocks: - items: - - description: DSI D-PHY PLL multiplied clock - - description: DSI D-PHY system clock - - description: DSI AXI bus clock - - description: DSI Register access clock - - description: DSI Video clock - - description: DSI D-PHY Escape mode transmit clock + oneOf: + - items: + - description: DSI D-PHY PLL multiplied clock + - description: DSI D-PHY system clock + - description: DSI AXI bus clock + - description: DSI Register access clock + - description: DSI Video clock + - description: DSI D-PHY Escape mode transmit clock + - items: + - description: DSI D-PHY PLL multiplied clock + - description: DSI AXI bus clock + - description: DSI Register access clock + - description: DSI Video clock + - description: DSI D-PHY Escape mode transmit clock =20 clock-names: - items: - - const: pllclk - - const: sysclk - - const: aclk - - const: pclk - - const: vclk - - const: lpclk + oneOf: + - items: + - const: pllclk + - const: sysclk + - const: aclk + - const: pclk + - const: vclk + - const: lpclk + - items: + - const: pllclk + - const: aclk + - const: pclk + - const: vclk + - const: lpclk =20 resets: - items: - - description: MIPI_DSI_CMN_RSTB - - description: MIPI_DSI_ARESET_N - - description: MIPI_DSI_PRESET_N + oneOf: + - items: + - description: MIPI_DSI_CMN_RSTB + - description: MIPI_DSI_ARESET_N + - description: MIPI_DSI_PRESET_N + - items: + - description: MIPI_DSI_ARESET_N + - description: MIPI_DSI_PRESET_N =20 reset-names: - items: - - const: rst - - const: arst - - const: prst + oneOf: + - items: + - const: rst + - const: arst + - const: prst + - items: + - const: arst + - const: prst =20 power-domains: maxItems: 1 @@ -130,6 +153,41 @@ required: =20 additionalProperties: false =20 +allOf: + - $ref: ../dsi-controller.yaml# + + - if: + properties: + compatible: + contains: + const: renesas,r9a09g057-mipi-dsi + then: + properties: + clocks: + maxItems: 5 + + clock-names: + maxItems: 5 + + resets: + maxItems: 2 + + reset-names: + maxItems: 2 + else: + properties: + clocks: + minItems: 6 + + clock-names: + minItems: 6 + + resets: + minItems: 3 + + reset-names: + minItems: 3 + examples: - | #include --=20 2.49.0 From nobody Mon Feb 9 14:59:27 2026 Received: from mail-lf1-f51.google.com (mail-lf1-f51.google.com [209.85.167.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5CB48296D2D; Mon, 12 May 2025 18:43:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075407; cv=none; b=FPEcDhZfWvK/ju6G1WaSMZ06mrTZVquNEpEk+3WaoTE2Eie+sEsGAxObJzV+lQlxtCdxU0nOg+IBy5WjwaQKQ0CmDftWE5Fn4mx6WvmkE56fDTOqnIP6xA2ydKcbFRDa62V+9C6fc7P1cTQcTb1Vt4x+x9zJCAQk6CMtxrBpYxo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747075407; c=relaxed/simple; bh=iOWhQ1gfIdlOqCEvGbmppRbaWSJzvSygM3HH55B0M5w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Y79rtr0SJ7NpddtmCNzJpcU3n8zMaUPm9l5if/twmj+9jAE6GKrOTIorru4xAIxC5mR+n4vUlGJ5ax94XtG8tnj9JcBbBK9yMehmSQH8Mpvpn4yEbPm0fYudv8lTVRXgQadUmee4gQja8C/MiQLyunbplDHebmO58xz6exz2qMU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=c0Qp5Fos; arc=none smtp.client-ip=209.85.167.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="c0Qp5Fos" Received: by mail-lf1-f51.google.com with SMTP id 2adb3069b0e04-54fd1650b83so2213577e87.2; Mon, 12 May 2025 11:43:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1747075403; x=1747680203; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=OKN8O9g4YT4hx1/KMQXIaxSmewpafidGEe6qa7pXTXw=; b=c0Qp5FospCsV6cXRMyxFboxbO/RLENs2b0ahc8wh9xBA5VCiFASdOOAcLOPbPxZ8Y3 hswGSFtbUxSKb1SjkFoRvYnnLXsKFb8MI21s2FY91Ht04Ym9LNQk1SJDKfGG+4u9F42U ePpgz8HHWrJNkIgGLTewoWc7o7KbVrCXoNG3GFcxSV4kuwVu9M6EQtems3DQSW42m7p2 yy4v/722GAOEOBVHsMnMU4v0A0c5niYRUgCWkehbg+77SSRmeX+aKTuniqB/ytXXbS83 EtNEbA8j1UQx9TnWbjStPQIJmF/E9m8bWIv0MJiV1IDSFidrBK7sFzx+MOfL6A6waJLJ U7Jw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747075403; x=1747680203; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=OKN8O9g4YT4hx1/KMQXIaxSmewpafidGEe6qa7pXTXw=; b=JplP9bzIj9y1JHvZltO6v90wiIL6czgO7z3F06Y5MqklpyeCdXbKBoSfR/6kBNcDc2 ifneb5laO99MlG8IBiqcgqUkDkwF+ZAha+gJu7bpLrlMYv/ERmsdHU2cTECrute2quBJ vdHfMfzfQpu2DUg0NLaevjyYNV/PgyzOQImelwMjpLDmWvPfa6UE6t4umGH5TpLFMM7D N37ay/FA6TwMQPtqiwcHaWiWHYh6ET7t+T8w4/7vPdLdTRewr4TKNB7g8KGIVoFjyg6N 1raGwpinEz5JYhQ6kbLjcvq6rMxGyippF8PYayFhgTNrUrM6e9679k4RoRxPfv4fw/2y YogA== X-Forwarded-Encrypted: i=1; AJvYcCVXmIlkQBlqK/2sxQW3XHJilDudR5y30GoeQW5CKm9O4h53i6snCr4E1T1DvGRXtf1J/0mMNXswk1naSIy2@vger.kernel.org, AJvYcCVtGGMEJLp1yF91IY/rEVHF6e1UvVmNEWtoMMZQGU+zNquM0683MbmBF+JOmpeghDFQpkeHnC+uFYos@vger.kernel.org, AJvYcCVytxFR11Gyq2W8yXhJf66krv8nqz8Js/ehwl0K3s9m4isntuxqFtZKQkA44QgAFo1eRuFn6rz52MVkxlBQYDf9R0I=@vger.kernel.org, AJvYcCXZL494fgvCzhYxC4MmNNrgLuL1TY0zDK8C2PmIHVmlAc8pqF/fQu4h6+vchQYCCFUqirQDL0HxwzR2@vger.kernel.org X-Gm-Message-State: AOJu0YyxHrfRFMxcIudXl5zQbS5+irIoyyMzyglGV9DprmYCJWZRNPU0 bnPGie3g4fA6L5Eq5EWo3xL+ecf0INhTSrxvNrhf1jC39bl8hQY/cFZeo7Yp X-Gm-Gg: ASbGncs+0K4a0gUVSNZnZPd2JDQ6GdOIqvl3ffCxcEMH7nPXHX0xdY6NJK2bhjLz08a 3856/RjL7O073g6Ffw2Crv8Jry/eptybjXxkOyf/tRZ2mPudqzqjAmr7woBWdTM3vtPKAk+6Z0P mPMOvSkizMBmAcmhSyFnuuqwRPt9ti72ZQ+rRbVhzj/wfTj6EZpgOJwtkkjzYrkjkKQB03ZuFhz 4NtdKY/Hxf+nXjS7XgmShKHUwcu9Bm3T7sRwcQ9sbK/99N7JzNlsFZ+wjxW19rXp5hyG8wL4/JR wcth2mLef/A7MMS828bLdQvCX509Z+N7x8n43p+RR/0o5ysAyuZqgFfUL7zfB02jdKftFMgmxHw P X-Google-Smtp-Source: AGHT+IHP5VBb4/ngcpbVzd5zX4uP65N8d3GjMzcV4+K5Ke+rrGU7rsqRtzmjGf1vpugQ2K4XlLKcxQ== X-Received: by 2002:a05:6000:4006:b0:39e:f9e8:d07d with SMTP id ffacd0b85a97d-3a1f6437e6emr11973762f8f.20.1747075392260; Mon, 12 May 2025 11:43:12 -0700 (PDT) Received: from iku.Home ([2a06:5906:61b:2d00:581b:951a:bc46:a124]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-3a1f57ddd53sm13309203f8f.1.2025.05.12.11.43.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 12 May 2025 11:43:11 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , David Airlie , Simona Vetter , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Geert Uytterhoeven , Michael Turquette , Stephen Boyd , Biju Das , Magnus Damm Cc: dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-renesas-soc@vger.kernel.org, linux-clk@vger.kernel.org, Prabhakar , Fabrizio Castro , Lad Prabhakar Subject: [PATCH v5 4/4] drm: renesas: rz-du: mipi_dsi: Add support for RZ/V2H(P) SoC Date: Mon, 12 May 2025 19:43:02 +0100 Message-ID: <20250512184302.241417-5-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20250512184302.241417-1-prabhakar.mahadev-lad.rj@bp.renesas.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Lad Prabhakar Add DSI support for Renesas RZ/V2H(P) SoC. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar --- v4->v5: - No changes v3->v4 - In rzv2h_dphy_find_ulpsexit() made the array static const. v2->v3: - Simplifed V2H DSI timings array to save space - Switched to use fsleep() instead of udelay() v1->v2: - Dropped unused macros - Added missing LPCLK flag to rzvv2h info --- .../gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c | 343 ++++++++++++++++++ .../drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h | 34 ++ 2 files changed, 377 insertions(+) diff --git a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c b/drivers/gpu/d= rm/renesas/rz-du/rzg2l_mipi_dsi.c index 98d2f30ae79d..db662d6d85c8 100644 --- a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c +++ b/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c @@ -5,6 +5,7 @@ * Copyright (C) 2022 Renesas Electronics Corporation */ #include +#include #include #include #include @@ -30,6 +31,9 @@ =20 #define RZ_MIPI_DSI_FEATURE_16BPP BIT(0) =20 +#define RZV2H_MIPI_DPHY_FOUT_MIN_IN_MEGA (80 * MEGA) +#define RZV2H_MIPI_DPHY_FOUT_MAX_IN_MEGA (1500 * MEGA) + struct rzg2l_mipi_dsi; =20 struct rzg2l_mipi_dsi_hw_info { @@ -40,6 +44,7 @@ struct rzg2l_mipi_dsi_hw_info { u64 *hsfreq_millihz); unsigned int (*dphy_mode_clk_check)(struct rzg2l_mipi_dsi *dsi, unsigned long mode_freq); + const struct rzv2h_pll_div_limits *cpg_dsi_limits; u32 phy_reg_offset; u32 link_reg_offset; unsigned long max_dclk; @@ -47,6 +52,11 @@ struct rzg2l_mipi_dsi_hw_info { u8 features; }; =20 +struct rzv2h_dsi_mode_calc { + unsigned long mode_freq; + u64 mode_freq_hz; +}; + struct rzg2l_mipi_dsi { struct device *dev; void __iomem *mmio; @@ -68,6 +78,18 @@ struct rzg2l_mipi_dsi { unsigned int num_data_lanes; unsigned int lanes; unsigned long mode_flags; + + struct rzv2h_dsi_mode_calc mode_calc; + struct rzv2h_plldsi_parameters dsi_parameters; +}; + +static const struct rzv2h_pll_div_limits rzv2h_plldsi_div_limits =3D { + .fvco =3D { .min =3D 1050 * MEGA, .max =3D 2100 * MEGA }, + .m =3D { .min =3D 64, .max =3D 1023 }, + .p =3D { .min =3D 1, .max =3D 4 }, + .s =3D { .min =3D 0, .max =3D 5 }, + .k =3D { .min =3D -32768, .max =3D 32767 }, + .csdiv =3D { .min =3D 1, .max =3D 1 }, }; =20 static inline struct rzg2l_mipi_dsi * @@ -184,6 +206,155 @@ static const struct rzg2l_mipi_dsi_timings rzg2l_mipi= _dsi_global_timings[] =3D { }, }; =20 +struct rzv2h_mipi_dsi_timings { + const u8 *hsfreq; + u8 len; + u8 start_index; +}; + +enum { + TCLKPRPRCTL, + TCLKZEROCTL, + TCLKPOSTCTL, + TCLKTRAILCTL, + THSPRPRCTL, + THSZEROCTL, + THSTRAILCTL, + TLPXCTL, + THSEXITCTL, +}; + +static const u8 tclkprprctl[] =3D { + 15, 26, 37, 47, 58, 69, 79, 90, 101, 111, 122, 133, 143, 150, +}; + +static const u8 tclkzeroctl[] =3D { + 9, 11, 13, 15, 18, 21, 23, 24, 25, 27, 29, 31, 34, 36, 38, + 41, 43, 45, 47, 50, 52, 54, 57, 59, 61, 63, 66, 68, 70, 73, + 75, 77, 79, 82, 84, 86, 89, 91, 93, 95, 98, 100, 102, 105, + 107, 109, 111, 114, 116, 118, 121, 123, 125, 127, 130, 132, + 134, 137, 139, 141, 143, 146, 148, 150, +}; + +static const u8 tclkpostctl[] =3D { + 8, 21, 34, 48, 61, 74, 88, 101, 114, 128, 141, 150, +}; + +static const u8 tclktrailctl[] =3D { + 14, 25, 37, 48, 59, 71, 82, 94, 105, 117, 128, 139, 150, +}; + +static const u8 thsprprctl[] =3D { + 11, 19, 29, 40, 50, 61, 72, 82, 93, 103, 114, 125, 135, 146, 150, +}; + +static const u8 thszeroctl[] =3D { + 18, 24, 29, 35, 40, 46, 51, 57, 62, 68, 73, 79, 84, 90, + 95, 101, 106, 112, 117, 123, 128, 134, 139, 145, 150, +}; + +static const u8 thstrailctl[] =3D { + 10, 21, 32, 42, 53, 64, 75, 85, 96, 107, 118, 128, 139, 150, +}; + +static const u8 tlpxctl[] =3D { + 13, 26, 39, 53, 66, 79, 93, 106, 119, 133, 146, 150, +}; + +static const u8 thsexitctl[] =3D { + 15, 23, 31, 39, 47, 55, 63, 71, 79, 87, + 95, 103, 111, 119, 127, 135, 143, 150, +}; + +static const struct rzv2h_mipi_dsi_timings rzv2h_dsi_timings_tables[] =3D { + [TCLKPRPRCTL] =3D { + .hsfreq =3D tclkprprctl, + .len =3D ARRAY_SIZE(tclkprprctl), + .start_index =3D 0, + }, + [TCLKZEROCTL] =3D { + .hsfreq =3D tclkzeroctl, + .len =3D ARRAY_SIZE(tclkzeroctl), + .start_index =3D 2, + }, + [TCLKPOSTCTL] =3D { + .hsfreq =3D tclkpostctl, + .len =3D ARRAY_SIZE(tclkpostctl), + .start_index =3D 6, + }, + [TCLKTRAILCTL] =3D { + .hsfreq =3D tclktrailctl, + .len =3D ARRAY_SIZE(tclktrailctl), + .start_index =3D 1, + }, + [THSPRPRCTL] =3D { + .hsfreq =3D thsprprctl, + .len =3D ARRAY_SIZE(thsprprctl), + .start_index =3D 0, + }, + [THSZEROCTL] =3D { + .hsfreq =3D thszeroctl, + .len =3D ARRAY_SIZE(thszeroctl), + .start_index =3D 0, + }, + [THSTRAILCTL] =3D { + .hsfreq =3D thstrailctl, + .len =3D ARRAY_SIZE(thstrailctl), + .start_index =3D 3, + }, + [TLPXCTL] =3D { + .hsfreq =3D tlpxctl, + .len =3D ARRAY_SIZE(tlpxctl), + .start_index =3D 0, + }, + [THSEXITCTL] =3D { + .hsfreq =3D thsexitctl, + .len =3D ARRAY_SIZE(thsexitctl), + .start_index =3D 1, + }, +}; + +static u16 rzv2h_dphy_find_ulpsexit(unsigned long freq) +{ + static const unsigned long hsfreq[] =3D { + 1953125UL, + 3906250UL, + 7812500UL, + 15625000UL, + }; + static const u16 ulpsexit[] =3D {49, 98, 195, 391}; + unsigned int i; + + for (i =3D 0; i < ARRAY_SIZE(hsfreq); i++) { + if (freq <=3D hsfreq[i]) + break; + } + + if (i =3D=3D ARRAY_SIZE(hsfreq)) + i -=3D 1; + + return ulpsexit[i]; +} + +static u16 rzv2h_dphy_find_timings_val(unsigned long freq, u8 index) +{ + const struct rzv2h_mipi_dsi_timings *timings; + u16 i; + + timings =3D &rzv2h_dsi_timings_tables[index]; + for (i =3D 0; i < timings->len; i++) { + unsigned long hsfreq =3D timings->hsfreq[i] * 10000000UL; + + if (freq <=3D hsfreq) + break; + } + + if (i =3D=3D timings->len) + i -=3D 1; + + return timings->start_index + i; +}; + static void rzg2l_mipi_dsi_phy_write(struct rzg2l_mipi_dsi *dsi, u32 reg, = u32 data) { iowrite32(data, dsi->mmio + dsi->info->phy_reg_offset + reg); @@ -308,6 +479,158 @@ static int rzg2l_dphy_conf_clks(struct rzg2l_mipi_dsi= *dsi, unsigned long mode_f return 0; } =20 +static unsigned int rzv2h_dphy_mode_clk_check(struct rzg2l_mipi_dsi *dsi, + unsigned long mode_freq) +{ + struct rzv2h_plldsi_parameters *dsi_parameters =3D &dsi->dsi_parameters; + u64 hsfreq_millihz, mode_freq_hz, mode_freq_millihz; + struct rzv2h_plldsi_parameters cpg_dsi_parameters; + unsigned int bpp, i; + + bpp =3D mipi_dsi_pixel_format_to_bpp(dsi->format); + + for (i =3D 0; i < 10; i +=3D 1) { + unsigned long hsfreq; + bool parameters_found; + + mode_freq_hz =3D mode_freq * MILLI + i; + mode_freq_millihz =3D mode_freq_hz * MILLI * 1ULL; + parameters_found =3D rzv2h_dsi_get_pll_parameters_values(dsi->info->cpg_= dsi_limits, + &cpg_dsi_parameters, + mode_freq_millihz); + if (!parameters_found) + continue; + + hsfreq_millihz =3D DIV_ROUND_CLOSEST_ULL(cpg_dsi_parameters.freq_millihz= * bpp, + dsi->lanes); + parameters_found =3D rzv2h_dsi_get_pll_parameters_values(&rzv2h_plldsi_d= iv_limits, + dsi_parameters, + hsfreq_millihz); + if (!parameters_found) + continue; + + if (abs(dsi_parameters->error_millihz) >=3D 500) + continue; + + hsfreq =3D DIV_ROUND_CLOSEST_ULL(hsfreq_millihz, MILLI); + if (hsfreq >=3D RZV2H_MIPI_DPHY_FOUT_MIN_IN_MEGA && + hsfreq <=3D RZV2H_MIPI_DPHY_FOUT_MAX_IN_MEGA) { + dsi->mode_calc.mode_freq_hz =3D mode_freq_hz; + dsi->mode_calc.mode_freq =3D mode_freq; + return MODE_OK; + } + } + + return MODE_CLOCK_RANGE; +} + +static int rzv2h_dphy_conf_clks(struct rzg2l_mipi_dsi *dsi, unsigned long = mode_freq, + u64 *hsfreq_millihz) +{ + struct rzv2h_plldsi_parameters *dsi_parameters =3D &dsi->dsi_parameters; + unsigned long status; + + if (dsi->mode_calc.mode_freq !=3D mode_freq) { + status =3D rzv2h_dphy_mode_clk_check(dsi, mode_freq); + if (status !=3D MODE_OK) { + dev_err(dsi->dev, "No PLL parameters found for mode clk %lu\n", + mode_freq); + return -EINVAL; + } + } + + clk_set_rate(dsi->vclk, dsi->mode_calc.mode_freq_hz); + *hsfreq_millihz =3D dsi_parameters->freq_millihz; + + return 0; +} + +static int rzv2h_mipi_dsi_dphy_init(struct rzg2l_mipi_dsi *dsi, + u64 hsfreq_millihz) +{ + struct rzv2h_plldsi_parameters *dsi_parameters =3D &dsi->dsi_parameters; + unsigned long lpclk_rate =3D clk_get_rate(dsi->lpclk); + u32 phytclksetr, phythssetr, phytlpxsetr, phycr; + struct rzg2l_mipi_dsi_timings dphy_timings; + u16 ulpsexit; + u64 hsfreq; + + hsfreq =3D DIV_ROUND_CLOSEST_ULL(hsfreq_millihz, MILLI); + + if (dsi_parameters->freq_millihz =3D=3D hsfreq_millihz) + goto parameters_found; + + if (rzv2h_dsi_get_pll_parameters_values(&rzv2h_plldsi_div_limits, + dsi_parameters, hsfreq_millihz)) + goto parameters_found; + + dev_err(dsi->dev, "No PLL parameters found for HSFREQ %lluHz\n", hsfreq); + return -EINVAL; + +parameters_found: + dphy_timings.tclk_trail =3D + rzv2h_dphy_find_timings_val(hsfreq, TCLKTRAILCTL); + dphy_timings.tclk_post =3D + rzv2h_dphy_find_timings_val(hsfreq, TCLKPOSTCTL); + dphy_timings.tclk_zero =3D + rzv2h_dphy_find_timings_val(hsfreq, TCLKZEROCTL); + dphy_timings.tclk_prepare =3D + rzv2h_dphy_find_timings_val(hsfreq, TCLKPRPRCTL); + dphy_timings.ths_exit =3D + rzv2h_dphy_find_timings_val(hsfreq, THSEXITCTL); + dphy_timings.ths_trail =3D + rzv2h_dphy_find_timings_val(hsfreq, THSTRAILCTL); + dphy_timings.ths_zero =3D + rzv2h_dphy_find_timings_val(hsfreq, THSZEROCTL); + dphy_timings.ths_prepare =3D + rzv2h_dphy_find_timings_val(hsfreq, THSPRPRCTL); + dphy_timings.tlpx =3D + rzv2h_dphy_find_timings_val(hsfreq, TLPXCTL); + ulpsexit =3D rzv2h_dphy_find_ulpsexit(lpclk_rate); + + phytclksetr =3D PHYTCLKSETR_TCLKTRAILCTL(dphy_timings.tclk_trail) | + PHYTCLKSETR_TCLKPOSTCTL(dphy_timings.tclk_post) | + PHYTCLKSETR_TCLKZEROCTL(dphy_timings.tclk_zero) | + PHYTCLKSETR_TCLKPRPRCTL(dphy_timings.tclk_prepare); + phythssetr =3D PHYTHSSETR_THSEXITCTL(dphy_timings.ths_exit) | + PHYTHSSETR_THSTRAILCTL(dphy_timings.ths_trail) | + PHYTHSSETR_THSZEROCTL(dphy_timings.ths_zero) | + PHYTHSSETR_THSPRPRCTL(dphy_timings.ths_prepare); + phytlpxsetr =3D rzg2l_mipi_dsi_phy_read(dsi, PHYTLPXSETR) & ~GENMASK(7, 0= ); + phytlpxsetr |=3D PHYTLPXSETR_TLPXCTL(dphy_timings.tlpx); + phycr =3D rzg2l_mipi_dsi_phy_read(dsi, PHYCR) & ~GENMASK(9, 0); + phycr |=3D PHYCR_ULPSEXIT(ulpsexit); + + /* Setting all D-PHY Timings Registers */ + rzg2l_mipi_dsi_phy_write(dsi, PHYTCLKSETR, phytclksetr); + rzg2l_mipi_dsi_phy_write(dsi, PHYTHSSETR, phythssetr); + rzg2l_mipi_dsi_phy_write(dsi, PHYTLPXSETR, phytlpxsetr); + rzg2l_mipi_dsi_phy_write(dsi, PHYCR, phycr); + + rzg2l_mipi_dsi_phy_write(dsi, PLLCLKSET0R, + PLLCLKSET0R_PLL_S(dsi_parameters->s) | + PLLCLKSET0R_PLL_P(dsi_parameters->p) | + PLLCLKSET0R_PLL_M(dsi_parameters->m)); + rzg2l_mipi_dsi_phy_write(dsi, PLLCLKSET1R, PLLCLKSET1R_PLL_K(dsi_paramete= rs->k)); + fsleep(20); + + rzg2l_mipi_dsi_phy_write(dsi, PLLENR, PLLENR_PLLEN); + fsleep(500); + + return 0; +} + +static void rzv2h_mipi_dsi_dphy_late_init(struct rzg2l_mipi_dsi *dsi) +{ + fsleep(220); + rzg2l_mipi_dsi_phy_write(dsi, PHYRSTR, PHYRSTR_PHYMRSTN); +} + +static void rzv2h_mipi_dsi_dphy_exit(struct rzg2l_mipi_dsi *dsi) +{ + rzg2l_mipi_dsi_phy_write(dsi, PLLENR, 0); +} + static int rzg2l_mipi_dsi_startup(struct rzg2l_mipi_dsi *dsi, const struct drm_display_mode *mode) { @@ -410,6 +733,9 @@ static void rzg2l_mipi_dsi_set_display_timing(struct rz= g2l_mipi_dsi *dsi, case 18: vich1ppsetr =3D VICH1PPSETR_DT_RGB18; break; + case 16: + vich1ppsetr =3D VICH1PPSETR_DT_RGB16; + break; } =20 if ((dsi->mode_flags & MIPI_DSI_MODE_VIDEO_SYNC_PULSE) && @@ -861,6 +1187,22 @@ static void rzg2l_mipi_dsi_remove(struct platform_dev= ice *pdev) pm_runtime_disable(&pdev->dev); } =20 +RZV2H_CPG_PLL_DSI_LIMITS(rzv2h_cpg_pll_dsi_limits); + +static const struct rzg2l_mipi_dsi_hw_info rzv2h_mipi_dsi_info =3D { + .dphy_init =3D rzv2h_mipi_dsi_dphy_init, + .dphy_late_init =3D rzv2h_mipi_dsi_dphy_late_init, + .dphy_exit =3D rzv2h_mipi_dsi_dphy_exit, + .dphy_mode_clk_check =3D rzv2h_dphy_mode_clk_check, + .dphy_conf_clks =3D rzv2h_dphy_conf_clks, + .cpg_dsi_limits =3D &rzv2h_cpg_pll_dsi_limits, + .phy_reg_offset =3D 0x10000, + .link_reg_offset =3D 0, + .max_dclk =3D 187500, + .min_dclk =3D 5440, + .features =3D RZ_MIPI_DSI_FEATURE_16BPP, +}; + static const struct rzg2l_mipi_dsi_hw_info rzg2l_mipi_dsi_info =3D { .dphy_init =3D rzg2l_mipi_dsi_dphy_init, .dphy_exit =3D rzg2l_mipi_dsi_dphy_exit, @@ -871,6 +1213,7 @@ static const struct rzg2l_mipi_dsi_hw_info rzg2l_mipi_= dsi_info =3D { }; =20 static const struct of_device_id rzg2l_mipi_dsi_of_table[] =3D { + { .compatible =3D "renesas,r9a09g057-mipi-dsi", .data =3D &rzv2h_mipi_dsi= _info, }, { .compatible =3D "renesas,rzg2l-mipi-dsi", .data =3D &rzg2l_mipi_dsi_inf= o, }, { /* sentinel */ } }; diff --git a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h b/drivers/= gpu/drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h index 16efe4dc59f4..68165395d61c 100644 --- a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h +++ b/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h @@ -40,6 +40,39 @@ #define DSIDPHYTIM3_THS_TRAIL(x) ((x) << 8) #define DSIDPHYTIM3_THS_ZERO(x) ((x) << 0) =20 +/* RZ/V2H DPHY Registers */ +#define PLLENR 0x000 +#define PLLENR_PLLEN BIT(0) + +#define PHYRSTR 0x004 +#define PHYRSTR_PHYMRSTN BIT(0) + +#define PLLCLKSET0R 0x010 +#define PLLCLKSET0R_PLL_S(x) ((x) << 0) +#define PLLCLKSET0R_PLL_P(x) ((x) << 8) +#define PLLCLKSET0R_PLL_M(x) ((x) << 16) + +#define PLLCLKSET1R 0x014 +#define PLLCLKSET1R_PLL_K(x) ((x) << 0) + +#define PHYTCLKSETR 0x020 +#define PHYTCLKSETR_TCLKTRAILCTL(x) ((x) << 0) +#define PHYTCLKSETR_TCLKPOSTCTL(x) ((x) << 8) +#define PHYTCLKSETR_TCLKZEROCTL(x) ((x) << 16) +#define PHYTCLKSETR_TCLKPRPRCTL(x) ((x) << 24) + +#define PHYTHSSETR 0x024 +#define PHYTHSSETR_THSEXITCTL(x) ((x) << 0) +#define PHYTHSSETR_THSTRAILCTL(x) ((x) << 8) +#define PHYTHSSETR_THSZEROCTL(x) ((x) << 16) +#define PHYTHSSETR_THSPRPRCTL(x) ((x) << 24) + +#define PHYTLPXSETR 0x028 +#define PHYTLPXSETR_TLPXCTL(x) ((x) << 0) + +#define PHYCR 0x030 +#define PHYCR_ULPSEXIT(x) ((x) << 0) + /* --------------------------------------------------------*/ =20 /* Link Status Register */ @@ -116,6 +149,7 @@ =20 /* Video-Input Channel 1 Pixel Packet Set Register */ #define VICH1PPSETR 0x420 +#define VICH1PPSETR_DT_RGB16 (0x0e << 16) #define VICH1PPSETR_DT_RGB18 (0x1e << 16) #define VICH1PPSETR_DT_RGB18_LS (0x2e << 16) #define VICH1PPSETR_DT_RGB24 (0x3e << 16) --=20 2.49.0