From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pg1-f170.google.com (mail-pg1-f170.google.com [209.85.215.170]) (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 07D3630F539 for ; Wed, 15 Oct 2025 19:26:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556397; cv=none; b=L1BzNS1HUKz17BjLgBYh/EwO3DYUyJd0dickoIdVKoDaaKykhgkjFPP9ULg/DN4fTADix6oVVh+dBLgCmuYFHkyGfgzVikN7E5JlkL7jKy3VqRwms9RYIS9CVWtyYm/Qf795HzY9QiH5nh6PKt69q/Bq1W29O6nMyG/TSNPCQS4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556397; c=relaxed/simple; bh=BdsJ2sEqN6rODDSWveW3Do2KQsZ9ykXTS6FV9Hcz5/Y=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=OOky+XfYx1zizkrVMx0Zi646MfaI9KbSWJj7hhPuc9soIyL5fp5NHY/NIAagzvNzAiz5jp9x1fnRc2Z+LKV8o6S5v6g+hTEGFNn+z4TIjWh0zqmQwzrAhNowy3sFDhzr/tKqKosnGjJW5noAKE493aVR85T9TldFqxmNaifbpAA= 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=R7b9BiaC; arc=none smtp.client-ip=209.85.215.170 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="R7b9BiaC" Received: by mail-pg1-f170.google.com with SMTP id 41be03b00d2f7-b551350adfaso5703010a12.3 for ; Wed, 15 Oct 2025 12:26:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556395; x=1761161195; 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=DzeiqeSx2hP+uCSg6LMRTweWgMxjeUkFjtP3zeTP43k=; b=R7b9BiaCRAXucLHJvD8ePybVAtvtYJLNXS+XRzmBe6aGxnkdHATgjNq1KyecQ0OGvn 3mGKXSpS5cMt12MSVBywXMwatbUXubKXWIBfPUY4VI7LPW7r3hscu4Nhkofq6SJ4scSi 5tsewx/KiCxUS93W/6T8mUeeNQfK0eMKsXITU7tA+j/aYv6i5EwFbB13SwdJgrFMgRTp BgLdCy72Yz426AbXl7X/CvhwSsbV5m0GiPQl/qAaV8ybn7NBnZs9+0P7XuoneanW+Zmp 6cNOYc2AYg7/W9pHu1KQ0MEmG9yHnXlMMoAnYVWIuR8+xDaI/AyoErmm4saTPRuj4VZi jfRw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556395; x=1761161195; 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=DzeiqeSx2hP+uCSg6LMRTweWgMxjeUkFjtP3zeTP43k=; b=NcYa+ptUdWwyXoX3N1LyK+RskCXUrRon8aaDWHd8Poyn2hD4RpMvkD4Ws87zFTAch8 q6m6uXbs1Xd0sMJ66pC+sSD1dAAEgGf1hSQtOMeeDr1FXVvR4vlOXOhYvfI0kncZytyC 3yo7RM/L2OKM0oNLqpquQ44OjrFlOVr/cTdy0quAkb3Jk30GSt877n9KrlyfXZ2xBiEw ajelAWywfO1QXmDOhB9rW9ygdKiFHHCxaaL92/BPaM4qF44oLrwv1kU0vMgaI6ocTmh2 bLlHwKVwH6HLLnmjIkXFihpl7Qr9FrXZ7TDcnjCbvzRyDxPj2R4cWe9rBk7VvlcV5Nw1 HpIw== X-Forwarded-Encrypted: i=1; AJvYcCWnN2SZYsGaaJ/cpNgymUQx9WxUfH6FYfPZReGhx/rZCuowxV7iLzUwNLvjPDYhog0eJ2a7P6vkUvdYUkY=@vger.kernel.org X-Gm-Message-State: AOJu0YzzXG2smdvRJWAwrO7IJn0NU81ekoz1TFfkhAyt9NR48O24Sp9+ eSrD7ocWQ0CN0ssJgIjWdAlzWRQU1XDPWc5g+R++lfYwHL16inmBDAhP X-Gm-Gg: ASbGnctj2ZFCSVZoz9yzZ1Mz/IkTJ915W87hvkcKEDBLg+L3SedRrGAz85ROQ+P0nqB HVrzlNqBx/hRSvGRa073VINYyixdmh9cX09W7z0hUmBmHbIeKhhb4Vo/bKzYEif1iJVVfXay51J hfpSbOTKZ0a2pXme41mVfYDKhNW9faA/tM8CkmMmJb6m3QNwkMCbX32xtVAaEERQwKZDL4vLwXC 499VV/VobQStl1B337zRVZJEYjh52RB3AmmNxQED+FDUGIbvbo83uCxC3pkwwV87/pJXDPzddbN 3FuUFQLGvxwccReFfjDBGpmnzCcLlqq7m1G64IFh1q+GTSJfHNsHQKoHpUWRZ73Yz+dMl+ETPWW vK1ajzUFyxNKLAZLj6W87IAIr1QLUjNs5MO8jhr82n71r0hb2FQtPTDxJsAET3fagbuEbFrC+uj 3+EnMx/YdmuNyhoc3HwFuSqQ== X-Google-Smtp-Source: AGHT+IF40uLj5O1VNn/1ilvror5cZrwViGxizn9s293CQe+Duobh8kb93icrEIO0yMNIwwVc30gkmg== X-Received: by 2002:a17:903:3c6e:b0:26b:3aab:f6b8 with SMTP id d9443c01a7336-2902741ce06mr353175745ad.58.1760556395165; Wed, 15 Oct 2025 12:26:35 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.26.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:26:34 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 v11 1/7] clk: renesas: rzv2h-cpg: Add instance field to struct pll Date: Wed, 15 Oct 2025 20:26:05 +0100 Message-ID: <20251015192611.241920-2-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 a two-bit "instance" member to struct pll and extend the PLL_PACK() macro to accept an instance parameter. Initialize all existing PLL definitions with instance 0 to preserve legacy behavior. This change enables support for SoCs with multiple PLL instances (for example, RZ/G3E we have two PLL DSIs). Signed-off-by: Lad Prabhakar Reviewed-by: Biju Das Reviewed-by: Geert Uytterhoeven --- v10->v11: - No changes. v9->v10: - No changes. v8->v9: - No changes. v7->v8: - Added reviewed-by tags from Geert and Biju v6->v7: - New patch --- drivers/clk/renesas/rzv2h-cpg.h | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/drivers/clk/renesas/rzv2h-cpg.h b/drivers/clk/renesas/rzv2h-cp= g.h index e020d9624dfd..fe6ab8e3cc6e 100644 --- a/drivers/clk/renesas/rzv2h-cpg.h +++ b/drivers/clk/renesas/rzv2h-cpg.h @@ -16,20 +16,23 @@ * * @offset: STBY register offset * @has_clkn: Flag to indicate if CLK1/2 are accessible or not + * @instance: PLL instance number */ struct pll { unsigned int offset:9; unsigned int has_clkn:1; + unsigned int instance:2; }; =20 -#define PLL_PACK(_offset, _has_clkn) \ +#define PLL_PACK(_offset, _has_clkn, _instance) \ ((struct pll){ \ .offset =3D _offset, \ - .has_clkn =3D _has_clkn \ + .has_clkn =3D _has_clkn, \ + .instance =3D _instance \ }) =20 -#define PLLCA55 PLL_PACK(0x60, 1) -#define PLLGPU PLL_PACK(0x120, 1) +#define PLLCA55 PLL_PACK(0x60, 1, 0) +#define PLLGPU PLL_PACK(0x120, 1, 0) =20 /** * struct ddiv - Structure for dynamic switching divider --=20 2.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pg1-f175.google.com (mail-pg1-f175.google.com [209.85.215.175]) (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 3C8D4305E1D for ; Wed, 15 Oct 2025 19:26:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556407; cv=none; b=d70D50CO+QXQcm6AecLydRNFQb985zIt7AC4ECo7lYO9eZJIGVn03w05AuDo+VcfXyOfdzd6IZdgsVzl2riu7bDoVnSKHcbWRWCKTrYDHOCcKMdjnAOueptjIDSql89Ygcm4brcAFM8cqUttnWMg83xEBDGDVtznOElQeSQuHN0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556407; c=relaxed/simple; bh=x+ZmUnRQ5rJ25UqRzHPT94vrQV/R+L+XBIFkmy2P01w=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=kqOyIEIyARK9PAD8p3tetCnrDqIOWs5OjIs7z7jBMvi8bLBeUZ1K6hXM0pVMdI5s1im7WXvq8l0I3vw7BiXvt0aogAzp94PuY2KUCiJxu67abl5cXUGMlSKYTYI//AT9sUNoefwwifUQGtTyVciqqH6aaqvvd180E7w9ESoOzgA= 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=eO1YonPJ; arc=none smtp.client-ip=209.85.215.175 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="eO1YonPJ" Received: by mail-pg1-f175.google.com with SMTP id 41be03b00d2f7-b6329b6e3b0so960528a12.1 for ; Wed, 15 Oct 2025 12:26:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556405; x=1761161205; 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=pVdIIHRjhsjhdHyUNhjH9+nTwNCLTUx5F36M27h4XtI=; b=eO1YonPJfvS+GPEAS1euEuKC1VKLDrAnQrQ5WBOmAl2/jB8ixMniKy8OIPnWA4apYC hIshdSMSLgu6m8yoz8ZcHlc87BD/FUNsVSD/YwqYrWig/9YIA3EZJvnBR9EzO6LMXdzH TaPuQ0r5nVWJtKmoGui+8MPCCIjgCAull1ybLBxvmej7JatoXtPTU65wTFFda9qFam2y d9mCzi4GN00q67yOkplPImWZOruoV828IsxdWe3j4MnHoH60oSrXMU0HxxvFHfeTZtQo qsQigfWULaNc/ZgrFT/8dBw+NxKu1Uvbbt28Lg4Tdudyk6p0UrPTQO0OowzBapBHdxJf Gw+Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556405; x=1761161205; 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=pVdIIHRjhsjhdHyUNhjH9+nTwNCLTUx5F36M27h4XtI=; b=vLY0mvrLpccmfAer0cXePLeJ6s/s4hIPfk87UizwAg0IHLXZY11CNv8waLRUPhHY7o ggSEIpxbIZhcrBmTwYINeNz+XEO0uq1PokhcTpPkrVm4qRDOC8/vvse1gSddvnPzYIwq CPKsejdq7hi0orn/vcHiB5EelYMMRkYJkuqzq2pNdYS89ahaEIEnjigcvhUpnyQOJMGZ Kb92yq+eCWsdrM/qlD8MjvYlQuMrc1rezSFvbRl1v9GVSp4Qmfh+yrl+Gyhk7aHiu5Cq LAbjGOd8jCdTeqV384E97Ly4RcyvTY1esLcXulp00eVkbBoAcfQ4Y9lbj+IwNu3v0tDn YZAQ== X-Forwarded-Encrypted: i=1; AJvYcCX3Tc0lkwsfOzGXjvMD6CnzULM37PnDebsHEiiBmcUEb7j7fRUcN6aXojHEWhNscXaeXt3E4JP/HFpSI+E=@vger.kernel.org X-Gm-Message-State: AOJu0YyZXxT45R8i5ssqoJdKNpYvCFqQO7h9y1BHGnuFg714rvnzCQEF N+1X4SzTefhlmOTlhcE41BK+w/U7TMlns6akCUKGVC9zYmDyCPUF2jBr X-Gm-Gg: ASbGncs7eYt7Xmnt0c5rfjDk/TIQKu38bLXH7qBNVye4FpcDSfTydhK/yCajlLeMzAL NHAhTC6M+GcOTTYrhO/JBnoiuulaRMLQe7uBQ1v//thl2aOWC/WGXhUJvd1rZgIQsaUdw8dZEqe ER/neydHDlyhq6Nqw/784vK34iwG3UX+31nyIgEYXWXsr02khsShkp6beNhslWtISSKRQB1fg6H onJEpl2+kKjZfO6VAhxmpikOba6zPc6WclxVD6xPLJ8ecfnlDZ2Maq21ui9v2YE/DA8l85OWmy3 akfYgCrcWKHJuiBoLJxktWVjNbB+wL7KmK6p7JyGm/rTZtlSzejOSsm87bPFovj/139ss2srJmx nxPN5210bl3Uk78/l++Rrher28rcFBkoJsBLhXVLekA66q/9MBmcU6dAM3RKco5GA4Wym2QJlPH l4zpOm1qXxft+9d9A8F9RrrA== X-Google-Smtp-Source: AGHT+IF8rWJttxUtF2GuEZ7phZVM28kjaWV2XPPnFipU1q3jMXIrc6ZJZA0GsIhMSL21BS4p4TDQyg== X-Received: by 2002:a17:903:350c:b0:26a:6d5a:944e with SMTP id d9443c01a7336-29091b4a521mr10160085ad.24.1760556405421; Wed, 15 Oct 2025 12:26:45 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.26.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:26:44 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 , Tomi Valkeinen Subject: [PATCH v11 2/7] clk: renesas: rzv2h-cpg: Use GENMASK for PLL fields Date: Wed, 15 Oct 2025 20:26:06 +0100 Message-ID: <20251015192611.241920-3-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 Replace the older FIELD_GET-wrapping helper macros with plain GENMASK definitions for the PLL CLK1/CLK2 field masks (CPG_PLL_CLK1_KDIV, CPG_PLL_CLK1_MDIV, CPG_PLL_CLK1_PDIV and CPG_PLL_CLK2_SDIV). Update rzv2h_cpg_pll_clk_recalc_rate() to explicitly extract those fields with FIELD_GET and cast the KDIV extraction to s16 to ensure proper sign extension when computing the PLL output rate. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar Acked-by: Tomi Valkeinen Reviewed-by: Geert Uytterhoeven --- v10->v11: - New patch, split up from patch 3/7 - Added Acked-by tag from Tomi - Added Reviewed-by tag from Geert --- drivers/clk/renesas/rzv2h-cpg.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/drivers/clk/renesas/rzv2h-cpg.c b/drivers/clk/renesas/rzv2h-cp= g.c index ff688dc88ba3..9c4c5dfd5593 100644 --- a/drivers/clk/renesas/rzv2h-cpg.c +++ b/drivers/clk/renesas/rzv2h-cpg.c @@ -49,11 +49,11 @@ #define CPG_PLL_STBY_RESETB BIT(0) #define CPG_PLL_STBY_RESETB_WEN BIT(16) #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)) -#define CPG_PLL_CLK1_PDIV(x) FIELD_GET(GENMASK(5, 0), (x)) +#define CPG_PLL_CLK1_KDIV GENMASK(31, 16) +#define CPG_PLL_CLK1_MDIV GENMASK(15, 6) +#define CPG_PLL_CLK1_PDIV GENMASK(5, 0) #define CPG_PLL_CLK2(x) ((x) + 0x008) -#define CPG_PLL_CLK2_SDIV(x) FIELD_GET(GENMASK(2, 0), (x)) +#define CPG_PLL_CLK2_SDIV GENMASK(2, 0) #define CPG_PLL_MON(x) ((x) + 0x010) #define CPG_PLL_MON_RESETB BIT(0) #define CPG_PLL_MON_LOCK BIT(4) @@ -231,10 +231,11 @@ static unsigned long rzv2h_cpg_pll_clk_recalc_rate(st= ruct clk_hw *hw, clk1 =3D readl(priv->base + CPG_PLL_CLK1(pll.offset)); clk2 =3D readl(priv->base + CPG_PLL_CLK2(pll.offset)); =20 - rate =3D mul_u64_u32_shr(parent_rate, (CPG_PLL_CLK1_MDIV(clk1) << 16) + - CPG_PLL_CLK1_KDIV(clk1), 16 + CPG_PLL_CLK2_SDIV(clk2)); + rate =3D mul_u64_u32_shr(parent_rate, (FIELD_GET(CPG_PLL_CLK1_MDIV, clk1)= << 16) + + (s16)FIELD_GET(CPG_PLL_CLK1_KDIV, clk1), + 16 + FIELD_GET(CPG_PLL_CLK2_SDIV, clk2)); =20 - return DIV_ROUND_CLOSEST_ULL(rate, CPG_PLL_CLK1_PDIV(clk1)); + return DIV_ROUND_CLOSEST_ULL(rate, FIELD_GET(CPG_PLL_CLK1_PDIV, clk1)); } =20 static const struct clk_ops rzv2h_cpg_pll_ops =3D { --=20 2.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pg1-f178.google.com (mail-pg1-f178.google.com [209.85.215.178]) (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 8190030F926 for ; Wed, 15 Oct 2025 19:26:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556418; cv=none; b=AjrfJcACym/pRRyvDkNQonbfYy7CFsfNa7ew2eHP2CBwI9Tb75qjb6ks3Y9p3KKsGA3VC3tBlLkEDFlPeShcSqFBmoH0Q/UiBCTBtgHXorlFk+2/gME2R7mFtWtcv+DYbeuOXX85KZnbN3xy9jxLhw+SdteDkCqu48VGRhfRYmU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556418; c=relaxed/simple; bh=ZFelrYjpGv3KSrHVhlDrZjfuJISlez7yBlhdtxTHT/E=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=LZUpTPteOU+JfgT0Tvhhxg3WTY+69BWFUv2tSVPwM6CsZp78H5bbBxDrFMKRnFl/J8XGljVakZISB3RvRXxTAAO2z8HMbbxtoMAu+e58Y7JW20ki+kFIDrBF3Vd6LcIv/i/mBKpbchT5Qr2vO+dq5BSzC+9xL850eAXIj51ROKo= 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=ZlHhGQXK; arc=none smtp.client-ip=209.85.215.178 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="ZlHhGQXK" Received: by mail-pg1-f178.google.com with SMTP id 41be03b00d2f7-b5507d3ccd8so5820573a12.0 for ; Wed, 15 Oct 2025 12:26:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556415; x=1761161215; 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=2nwfs3kwk3/QA3E/2uCZgw+iuyonqlTLNeALM9x3qYc=; b=ZlHhGQXKmgNhAZAJa6A+g7T/80/167U+RI3qFDmTUJCQknINI0BUGCJLRMSV0o5ZeW iqJV0HQlHECYXD1ycBiKf8/CmsHWhFjpkTst53dtmBdLFFtopqqHRgNPE/r+QxNs4Ud9 kZzfmz9whrmCeiaM+FW9h4ntC1u8fKpAycA1Yu42P4/Pey45sAqfhTJchgYkpEGXihrE iSdWm/3parBO9/HwDkqepv/hz7moF4zN0hwSedwE6lZ5fDuW7vDsxWxA28Jl5haFukTf JKf9IPPE1E6OsTuqOmsMIycjQnwzn62Ed0YoBphObBUdvdPWGj/EPt0SZfnyh6Q55fFf mp2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556415; x=1761161215; 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=2nwfs3kwk3/QA3E/2uCZgw+iuyonqlTLNeALM9x3qYc=; b=J4Ov7QN678WlD3gwBjxG+5DozCxaNOofqj4jRbc+GVyN0kKp55PS/uECi5i9Py8MU6 0rZANAW0WqO/ZTde03xFL39l1KyJySQp9Q6FasXh8ZxkPqqrzpXSWuY2QCvdL+/RGi/q xbmjxqNwwwKi0sr6JzgGwi4WYiIgpLQ6Rgk5zXaJcSynMbIEcN/AsQkMmRurswKRsuOI OkysghSdOmqv6OD69Dv1LM1YAbzt39/cqBl21W/Dz+TvrQuzytUIn1uPtTbeVD7sX/er wDmUKa9JDvsS/0ZcXeUS8t8QeH8y5TYdDAWvncpJbK4c0urVALa4CcAlo0YqlYfTYnm6 Qf6g== X-Forwarded-Encrypted: i=1; AJvYcCWCaDqL9X6JOKRLB3yUdy9azFISXx27JTvku+rEsH8lpdMTS7J6u/COWUU1rSUFA74h+luqJvuqRaJreBM=@vger.kernel.org X-Gm-Message-State: AOJu0YzY8tGmM1ER0OJhigrXVX8/ikrAkOxb0uuuBXKFTDX9ZQB8WhFf KSxhfWG/fHBPe5EY1rWEY7lcEDV+iSY70TZI8dKbLAQ48UjMCnlLnoPC X-Gm-Gg: ASbGnctYnLoX35uSDpyD6SgTP3YFiQTaklVxu2pj680apifzr14mHiEh1JtgTwxWKHf j+0RlsQ7HZIEMM8k6Zph0G7dtUFxM3FICXBRY5M2IZ3TO+Ttu/3/oJDK/nNYrXfFzM2FylQj8MX XPkKyVlZQcF8VQj4qEBYgRsjl5Taiird6fp+kPvE2NA/q1AbmWZ33FjXlQkADk+Lwxgmwb5qn7E NbHsSIleYo6OVunfcqr8Lol+D+88QqrhLWKQy0A9hrDZuEMT6OypSK8XgMfZZzpd6FIQHq9+5jn 5lG3wckKhSAemJ17b2KLKcE9sDVpvTYQQSsp69laNhDWoLwGvn5/kTS9OOIFpv+FE26WEQvHiLq 04VoURjOufcJ/VwAdORbKPnj2KIitAa4KmLrkDdrFPekNE/Tu13PlbV+Evi/xDS0k9cDYroZCsK tq/i0Nsr+l7pTH9KKICM1BYnA5+xRDGu0Q X-Google-Smtp-Source: AGHT+IGGz0/I/nL0eYN76IcdSFqhmPe/ym4t+Z4JeYRO1hEFKAkdhxvS8pLI4y7W9kT+oSDcNSh7aA== X-Received: by 2002:a17:903:1ac8:b0:26f:f489:bba6 with SMTP id d9443c01a7336-290272f5913mr344016275ad.50.1760556414549; Wed, 15 Oct 2025 12:26:54 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.26.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:26:53 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 , Tomi Valkeinen Subject: [PATCH v11 3/7] clk: renesas: rzv2h-cpg: Add support for DSI clocks Date: Wed, 15 Oct 2025 20:26:07 +0100 Message-ID: <20251015192611.241920-4-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 its post-dividers in the RZ/V2H CPG driver and export helper APIs for use by the DSI driver. Introduce per-PLL-DSI state in the CPG private structure and provide a set of helper functions that find valid PLL parameter combinations for a requested frequency. The new helpers are rzv2h_get_pll_pars(), rzv2h_get_pll_div_pars(), rzv2h_get_pll_divs_pars() and rzv2h_get_pll_dtable_pars() and they are exported in the "RZV2H_CPG" namespace for use by other consumers (notably the DSI driver). These helpers perform iterative searches over PLL parameters (M, K, P, S) and optional post-dividers and return the best match (or an exact match when possible). Move PLL/CLK related limits and parameter types into the shared include (include/linux/clk/renesas.h) by adding struct rzv2h_pll_limits, struct rzv2h_pll_pars and struct rzv2h_pll_div_pars plus the RZV2H_CPG_PLL_DSI_LIMITS() helper macro to define DSI PLL limits. This change centralises the PLLDSI algorithms so the CPG and DSI drivers compute PLL parameters consistently and allows the DSI driver to accurately request rates and program its PLL. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar Acked-by: Tomi Valkeinen Reviewed-by: Geert Uytterhoeven --- v10->v11: - Dropped GENMASK changes into separate patch - Updated rzv2h_cpg_plldsi_div_determine_rate() while iterating over the divider table - Added Acked-by tag from Tomi - Added Reviewed-by tag from Geert v9->v10: - Dropped rzv2h_get_pll_div_pars() helper and opencoded instead. - Dropped rzv2h_get_pll_dtable_pars() helper and opencoded instead. - Added dummy helpers rzv2h_get_pll_pars() and rzv2h_get_pll_divs_pars() in renesas.h for !CONFIG_CLK_RZV2H case. - Updated commit message. v8->v9: - Dropped `renesas-rzv2h-cpg-pll.h` header and merged into `renesas.h` - Exported the symbols for PLL calculation apis - Updated commit message - Dropped reviewed-by tags due to above changes v7->v8: - Dropped rzv2h_get_pll_dsi_info() helper and opencoded instead. - Dropped is_plldsi parameter from rzv2h_cpg_pll_clk_register() v6->v7: - Made struct rzv2h_pll_limits more modular also added Ffout limits - Made the alogirithm modular and also added apis based on the needs for lvds and dpi v5->v6: - Renamed CPG_PLL_STBY_SSCGEN_WEN to CPG_PLL_STBY_SSC_EN_WEN - Updated CPG_PLL_CLK1_DIV_K, CPG_PLL_CLK1_DIV_M, and CPG_PLL_CLK1_DIV_P macros to use GENMASK - Updated req->rate in rzv2h_cpg_plldsi_div_determine_rate() - Dropped the cast in rzv2h_cpg_plldsi_div_set_rate() - Dropped rzv2h_cpg_plldsi_round_rate() and implemented rzv2h_cpg_plldsi_determine_rate() instead - Made use of FIELD_PREP() - Moved CPG_CSDIV1 macro in patch 2/4 - Dropped two_pow_s in rzv2h_dsi_get_pll_parameters_values() - Used mul_u32_u32() while calculating output_m and output_k_range - Used div_s64() instead of div64_s64() while calculating pll_k - Used mul_u32_u32() while calculating fvco and fvco checks - Rounded the final output using DIV_U64_ROUND_CLOSEST() 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 | 497 ++++++++++++++++++++++++++++++++ drivers/clk/renesas/rzv2h-cpg.h | 19 +- include/linux/clk/renesas.h | 145 ++++++++++ 3 files changed, 659 insertions(+), 2 deletions(-) diff --git a/drivers/clk/renesas/rzv2h-cpg.c b/drivers/clk/renesas/rzv2h-cp= g.c index 9c4c5dfd5593..3f6299b9fec0 100644 --- a/drivers/clk/renesas/rzv2h-cpg.c +++ b/drivers/clk/renesas/rzv2h-cpg.c @@ -14,9 +14,14 @@ #include #include #include +#include #include #include #include +#include +#include +#include +#include #include #include #include @@ -26,6 +31,7 @@ #include #include #include +#include =20 #include =20 @@ -47,7 +53,9 @@ =20 #define CPG_PLL_STBY(x) ((x)) #define CPG_PLL_STBY_RESETB BIT(0) +#define CPG_PLL_STBY_SSC_EN BIT(2) #define CPG_PLL_STBY_RESETB_WEN BIT(16) +#define CPG_PLL_STBY_SSC_EN_WEN BIT(18) #define CPG_PLL_CLK1(x) ((x) + 0x004) #define CPG_PLL_CLK1_KDIV GENMASK(31, 16) #define CPG_PLL_CLK1_MDIV GENMASK(15, 6) @@ -65,6 +73,22 @@ =20 #define CPG_CLKSTATUS0 (0x700) =20 +/* On RZ/G3E SoC we have two DSI PLLs */ +#define MAX_CPG_DSI_PLL 2 + +/** + * struct rzv2h_pll_dsi_info - PLL DSI information, holds the limits and p= arameters + * + * @pll_dsi_limits: PLL DSI parameters limits + * @pll_dsi_parameters: Calculated PLL DSI parameters + * @req_pll_dsi_rate: Requested PLL DSI rate + */ +struct rzv2h_pll_dsi_info { + const struct rzv2h_pll_limits *pll_dsi_limits; + struct rzv2h_pll_div_pars pll_dsi_parameters; + unsigned long req_pll_dsi_rate; +}; + /** * struct rzv2h_cpg_priv - Clock Pulse Generator Private Data * @@ -80,6 +104,7 @@ * @ff_mod_status_ops: Fixed Factor Module Status Clock operations * @mstop_count: Array of mstop values * @rcdev: Reset controller entity + * @pll_dsi_info: Array of PLL DSI information, holds the limits and param= eters */ struct rzv2h_cpg_priv { struct device *dev; @@ -98,6 +123,8 @@ struct rzv2h_cpg_priv { atomic_t *mstop_count; =20 struct reset_controller_dev rcdev; + + struct rzv2h_pll_dsi_info pll_dsi_info[MAX_CPG_DSI_PLL]; }; =20 #define rcdev_to_priv(x) container_of(x, struct rzv2h_cpg_priv, rcdev) @@ -168,6 +195,460 @@ struct rzv2h_ff_mod_status_clk { #define to_rzv2h_ff_mod_status_clk(_hw) \ container_of(_hw, struct rzv2h_ff_mod_status_clk, fix.hw) =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) + +#define RZ_V2H_OSC_CLK_IN_MEGA (24 * MEGA) +#define RZV2H_MAX_DIV_TABLES (16) + +/** + * rzv2h_get_pll_pars - Finds the best combination of PLL parameters + * for a given frequency. + * + * @limits: Pointer to the structure containing the limits for the PLL par= ameters + * @pars: Pointer to the structure where the best calculated PLL parameter= s values + * will be stored + * @freq_millihz: Target output frequency in millihertz + * + * This function calculates the best set of PLL parameters (M, K, P, S) to= achieve + * the desired frequency. + * There is no direct formula to calculate the PLL parameters, as it's an = open + * system of equations, therefore this function uses an iterative approach= to + * determine the best solution. The best solution is one that minimizes th= e error + * (desired frequency - actual frequency). + * + * Return: true if a valid set of parameters values is found, false otherw= ise. + */ +bool rzv2h_get_pll_pars(const struct rzv2h_pll_limits *limits, + struct rzv2h_pll_pars *pars, u64 freq_millihz) +{ + u64 fout_min_millihz =3D mul_u32_u32(limits->fout.min, MILLI); + u64 fout_max_millihz =3D mul_u32_u32(limits->fout.max, MILLI); + struct rzv2h_pll_pars p, best; + + if (freq_millihz > fout_max_millihz || + freq_millihz < fout_min_millihz) + return false; + + /* Initialize best error to maximum possible value */ + best.error_millihz =3D S64_MAX; + + for (p.p =3D limits->p.min; p.p <=3D limits->p.max; p.p++) { + u32 fref =3D RZ_V2H_OSC_CLK_IN_MEGA / p.p; + u16 divider; + + for (divider =3D 1 << limits->s.min, p.s =3D limits->s.min; + p.s <=3D limits->s.max; p.s++, divider <<=3D 1) { + 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 PLL + divider + * is calculated as follows: + * + * With: + * Freq =3D 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) + * =3D ((pll_m + (pll_k / 65536)) * Ffref) / 2^(pll_s) + * =3D (pll_m * Ffref) / 2^(pll_s) + ((pll_k / 65536) * Ffref) / = 2^(pll_s) + * =3D output_m + output_k + * + * Every parameter has been determined at this + * point, but pll_k. + * + * Considering that: + * limits->k.min <=3D pll_k <=3D limits->k.max + * Then: + * -0.5 <=3D (pll_k / 65536) < 0.5 + * Therefore: + * -Ffref / (2 * 2^(pll_s)) <=3D output_k < Ffref / (2 * 2^(pll_s)) + */ + + /* Compute output M component (in mHz) */ + output_m =3D DIV_ROUND_CLOSEST_ULL(mul_u32_u32(p.m, fref) * MILLI, + divider); + /* Compute range for output K (in mHz) */ + output_k_range =3D DIV_ROUND_CLOSEST_ULL(mul_u32_u32(fref, MILLI), + 2 * divider); + /* + * 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) / 2^(pll_s) + * Therefore: + * pll_k =3D (output_k * 65536 * 2^(pll_s)) / Ffref + */ + output_k =3D freq_millihz - output_m; + pll_k =3D div_s64(output_k * 65536ULL * divider, + fref); + pll_k =3D DIV_S64_ROUND_CLOSEST(pll_k, MILLI); + + /* 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 mul_u32_u32(p.m * 65536 + p.k, fref); + if (fvco < mul_u32_u32(limits->fvco.min, 65536) || + fvco > mul_u32_u32(limits->fvco.max, 65536)) + continue; + + /* PLL_M component of (output * 65536 * PLL_P) */ + output =3D mul_u32_u32(p.m * 65536, RZ_V2H_OSC_CLK_IN_MEGA); + /* PLL_K component of (output * 65536 * PLL_P) */ + output +=3D p.k * RZ_V2H_OSC_CLK_IN_MEGA; + /* Make it in mHz */ + output *=3D MILLI; + output =3D DIV_U64_ROUND_CLOSEST(output, 65536 * p.p * divider); + + /* Check output frequency against limits */ + if (output < fout_min_millihz || + output > fout_max_millihz) + continue; + + 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; +} +EXPORT_SYMBOL_NS_GPL(rzv2h_get_pll_pars, "RZV2H_CPG"); + +/* + * rzv2h_get_pll_divs_pars - 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 + * @pars: Pointer to the structure where the best calculated PLL parameter= s and + * divider values will be stored + * @table: Pointer to the array of valid divider values + * @table_size: Size of the divider values array + * @freq_millihz: Target output frequency in millihertz + * + * This function calculates the best set of PLL parameters (M, K, P, S) an= d divider + * value to achieve the desired frequency. See rzv2h_get_pll_pars() for mo= re details + * on how the PLL parameters are calculated. + * + * freq_millihz is the desired frequency generated by the PLL followed by a + * a gear. + */ +bool rzv2h_get_pll_divs_pars(const struct rzv2h_pll_limits *limits, + struct rzv2h_pll_div_pars *pars, + const u8 *table, u8 table_size, u64 freq_millihz) +{ + struct rzv2h_pll_div_pars p, best; + + best.div.error_millihz =3D S64_MAX; + p.div.error_millihz =3D S64_MAX; + for (unsigned int i =3D 0; i < table_size; i++) { + if (!rzv2h_get_pll_pars(limits, &p.pll, freq_millihz * table[i])) + continue; + + p.div.divider_value =3D table[i]; + p.div.freq_millihz =3D DIV_U64_ROUND_CLOSEST(p.pll.freq_millihz, table[i= ]); + p.div.error_millihz =3D freq_millihz - p.div.freq_millihz; + + if (p.div.error_millihz =3D=3D 0) { + *pars =3D p; + return true; + } + + if (abs(best.div.error_millihz) > abs(p.div.error_millihz)) + best =3D p; + } + + if (best.div.error_millihz =3D=3D S64_MAX) + return false; + + *pars =3D best; + return true; +} +EXPORT_SYMBOL_NS_GPL(rzv2h_get_pll_divs_pars, "RZV2H_CPG"); + +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 pll_clk *pll_clk =3D to_pll(clk_hw_get_parent(hw)); + struct rzv2h_cpg_priv *priv =3D dsi_div->priv; + u8 table[RZV2H_MAX_DIV_TABLES] =3D { 0 }; + struct rzv2h_pll_div_pars *dsi_params; + struct rzv2h_pll_dsi_info *dsi_info; + const struct clk_div_table *div; + unsigned int i =3D 0; + u64 rate_millihz; + + dsi_info =3D &priv->pll_dsi_info[pll_clk->pll.instance]; + dsi_params =3D &dsi_info->pll_dsi_parameters; + + rate_millihz =3D mul_u32_u32(req->rate, MILLI); + if (rate_millihz =3D=3D dsi_params->div.error_millihz + dsi_params->div.f= req_millihz) + goto exit_determine_rate; + + for (div =3D dsi_div->dtable; div->div; div++) { + if (i >=3D RZV2H_MAX_DIV_TABLES) + return -EINVAL; + table[i++] =3D div->div; + } + + if (!rzv2h_get_pll_divs_pars(dsi_info->pll_dsi_limits, dsi_params, table,= i, + rate_millihz)) { + dev_err(priv->dev, "failed to determine rate for req->rate: %lu\n", + req->rate); + return -EINVAL; + } + +exit_determine_rate: + req->rate =3D DIV_ROUND_CLOSEST_ULL(dsi_params->div.freq_millihz, MILLI); + req->best_parent_rate =3D req->rate * dsi_params->div.divider_value; + dsi_info->req_pll_dsi_rate =3D req->best_parent_rate; + + 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 pll_clk *pll_clk =3D to_pll(clk_hw_get_parent(hw)); + struct rzv2h_cpg_priv *priv =3D dsi_div->priv; + struct rzv2h_pll_div_pars *dsi_params; + struct rzv2h_pll_dsi_info *dsi_info; + struct ddiv ddiv =3D dsi_div->ddiv; + const struct clk_div_table *clkt; + bool divider_found =3D false; + u32 val, shift; + + dsi_info =3D &priv->pll_dsi_info[pll_clk->pll.instance]; + dsi_params =3D &dsi_info->pll_dsi_parameters; + + for (clkt =3D dsi_div->dtable; clkt->div; clkt++) { + if (clkt->div =3D=3D dsi_params->div.divider_value) { + divider_found =3D true; + break; + } + } + + if (!divider_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 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 int rzv2h_cpg_plldsi_determine_rate(struct clk_hw *hw, + struct clk_rate_request *req) +{ + struct pll_clk *pll_clk =3D to_pll(hw); + struct rzv2h_cpg_priv *priv =3D pll_clk->priv; + struct rzv2h_pll_dsi_info *dsi_info; + u64 rate_millihz; + + dsi_info =3D &priv->pll_dsi_info[pll_clk->pll.instance]; + /* check if the divider has already invoked the algorithm */ + if (req->rate =3D=3D dsi_info->req_pll_dsi_rate) + return 0; + + /* If the req->rate doesn't match we do the calculation assuming there is= no divider */ + rate_millihz =3D mul_u32_u32(req->rate, MILLI); + if (!rzv2h_get_pll_pars(dsi_info->pll_dsi_limits, + &dsi_info->pll_dsi_parameters.pll, rate_millihz)) { + dev_err(priv->dev, + "failed to determine rate for req->rate: %lu\n", + req->rate); + return -EINVAL; + } + + req->rate =3D DIV_ROUND_CLOSEST_ULL(dsi_info->pll_dsi_parameters.pll.freq= _millihz, MILLI); + dsi_info->req_pll_dsi_rate =3D req->rate; + + return 0; +} + +static int rzv2h_cpg_pll_set_rate(struct pll_clk *pll_clk, + struct rzv2h_pll_pars *params, + bool ssc_disable) +{ + struct rzv2h_cpg_priv *priv =3D pll_clk->priv; + u16 offset =3D pll_clk->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; + } + + /* Output clock setting 1 */ + writel(FIELD_PREP(CPG_PLL_CLK1_KDIV, (u16)params->k) | + FIELD_PREP(CPG_PLL_CLK1_MDIV, params->m) | + FIELD_PREP(CPG_PLL_CLK1_PDIV, params->p), + priv->base + CPG_PLL_CLK1(offset)); + + /* Output clock setting 2 */ + val =3D readl(priv->base + CPG_PLL_CLK2(offset)); + writel((val & ~CPG_PLL_CLK2_SDIV) | FIELD_PREP(CPG_PLL_CLK2_SDIV, params-= >s), + priv->base + CPG_PLL_CLK2(offset)); + + /* Put PLL to normal mode */ + if (ssc_disable) + val =3D CPG_PLL_STBY_SSC_EN_WEN; + else + val =3D CPG_PLL_STBY_SSC_EN_WEN | CPG_PLL_STBY_SSC_EN; + writel(val | 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 int rzv2h_cpg_plldsi_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + struct pll_clk *pll_clk =3D to_pll(hw); + struct rzv2h_pll_dsi_info *dsi_info; + struct rzv2h_cpg_priv *priv =3D pll_clk->priv; + + dsi_info =3D &priv->pll_dsi_info[pll_clk->pll.instance]; + + return rzv2h_cpg_pll_set_rate(pll_clk, &dsi_info->pll_dsi_parameters.pll,= true); +} + static int rzv2h_cpg_pll_clk_is_enabled(struct clk_hw *hw) { struct pll_clk *pll_clk =3D to_pll(hw); @@ -238,6 +719,12 @@ static unsigned long rzv2h_cpg_pll_clk_recalc_rate(str= uct clk_hw *hw, return DIV_ROUND_CLOSEST_ULL(rate, FIELD_GET(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, + .determine_rate =3D rzv2h_cpg_plldsi_determine_rate, + .set_rate =3D rzv2h_cpg_plldsi_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, @@ -264,6 +751,10 @@ rzv2h_cpg_pll_clk_register(const struct cpg_core_clk *= core, if (!pll_clk) return ERR_PTR(-ENOMEM); =20 + if (core->type =3D=3D CLK_TYPE_PLLDSI) + priv->pll_dsi_info[core->cfg.pll.instance].pll_dsi_limits =3D + core->cfg.pll.limits; + parent_name =3D __clk_get_name(parent); init.name =3D core->name; init.ops =3D ops; @@ -588,6 +1079,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); + break; + case CLK_TYPE_PLLDSI_DIV: + clk =3D rzv2h_cpg_plldsi_div_clk_register(core, priv); + break; default: goto fail; } diff --git a/drivers/clk/renesas/rzv2h-cpg.h b/drivers/clk/renesas/rzv2h-cp= g.h index fe6ab8e3cc6e..f7b4e4785d0f 100644 --- a/drivers/clk/renesas/rzv2h-cpg.h +++ b/drivers/clk/renesas/rzv2h-cpg.h @@ -22,15 +22,20 @@ struct pll { unsigned int offset:9; unsigned int has_clkn:1; unsigned int instance:2; + const struct rzv2h_pll_limits *limits; }; =20 -#define PLL_PACK(_offset, _has_clkn, _instance) \ +#define PLL_PACK_LIMITS(_offset, _has_clkn, _instance, _limits) \ ((struct pll){ \ .offset =3D _offset, \ .has_clkn =3D _has_clkn, \ - .instance =3D _instance \ + .instance =3D _instance, \ + .limits =3D _limits \ }) =20 +#define PLL_PACK(_offset, _has_clkn, _instance) \ + PLL_PACK_LIMITS(_offset, _has_clkn, _instance, NULL) + #define PLLCA55 PLL_PACK(0x60, 1, 0) #define PLLGPU PLL_PACK(0x120, 1, 0) =20 @@ -193,6 +198,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...) \ @@ -223,6 +230,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 diff --git a/include/linux/clk/renesas.h b/include/linux/clk/renesas.h index 0ebbe2f0b45e..69d8159deee3 100644 --- a/include/linux/clk/renesas.h +++ b/include/linux/clk/renesas.h @@ -10,7 +10,9 @@ #ifndef __LINUX_CLK_RENESAS_H_ #define __LINUX_CLK_RENESAS_H_ =20 +#include #include +#include =20 struct device; struct device_node; @@ -32,4 +34,147 @@ void cpg_mssr_detach_dev(struct generic_pm_domain *unus= ed, struct device *dev); #define cpg_mssr_attach_dev NULL #define cpg_mssr_detach_dev NULL #endif + +/** + * struct rzv2h_pll_limits - PLL parameter constraints + * + * This structure defines the minimum and maximum allowed values for + * various parameters used to configure a PLL. These limits ensure + * the PLL operates within valid and stable ranges. + * + * @fout: Output frequency range (in MHz) + * @fout.min: Minimum allowed output frequency + * @fout.max: Maximum allowed output frequency + * + * @fvco: PLL oscillation frequency range (in MHz) + * @fvco.min: Minimum allowed VCO frequency + * @fvco.max: Maximum allowed VCO frequency + * + * @m: Main-divider range + * @m.min: Minimum main-divider value + * @m.max: Maximum main-divider value + * + * @p: Pre-divider range + * @p.min: Minimum pre-divider value + * @p.max: Maximum pre-divider value + * + * @s: Divider range + * @s.min: Minimum divider value + * @s.max: Maximum divider value + * + * @k: Delta-sigma modulator range (signed) + * @k.min: Minimum delta-sigma value + * @k.max: Maximum delta-sigma value + */ +struct rzv2h_pll_limits { + struct { + u32 min; + u32 max; + } fout; + + 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 rzv2h_pll_pars - PLL configuration parameters + * + * This structure contains the configuration parameters for the + * Phase-Locked Loop (PLL), used to achieve a specific output frequency. + * + * @m: Main divider value + * @p: Pre-divider value + * @s: Output divider value + * @k: Delta-sigma modulation value + * @freq_millihz: Calculated PLL output frequency in millihertz + * @error_millihz: Frequency error from target in millihertz (signed) + */ +struct rzv2h_pll_pars { + u16 m; + u8 p; + u8 s; + s16 k; + u64 freq_millihz; + s64 error_millihz; +}; + +/** + * struct rzv2h_pll_div_pars - PLL parameters with post-divider + * + * This structure is used for PLLs that include an additional post-divider + * stage after the main PLL block. It contains both the PLL configuration + * parameters and the resulting frequency/error values after the divider. + * + * @pll: Main PLL configuration parameters (see struct rzv2h_pll_pars) + * + * @div: Post-divider configuration and result + * @div.divider_value: Divider applied to the PLL output + * @div.freq_millihz: Output frequency after divider in millihertz + * @div.error_millihz: Frequency error from target in millihertz (signed) + */ +struct rzv2h_pll_div_pars { + struct rzv2h_pll_pars pll; + struct { + u8 divider_value; + u64 freq_millihz; + s64 error_millihz; + } div; +}; + +#define RZV2H_CPG_PLL_DSI_LIMITS(name) \ + static const struct rzv2h_pll_limits (name) =3D { \ + .fout =3D { .min =3D 25 * MEGA, .max =3D 375 * MEGA }, \ + .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 }, \ + } \ + +#ifdef CONFIG_CLK_RZV2H +bool rzv2h_get_pll_pars(const struct rzv2h_pll_limits *limits, + struct rzv2h_pll_pars *pars, u64 freq_millihz); + +bool rzv2h_get_pll_divs_pars(const struct rzv2h_pll_limits *limits, + struct rzv2h_pll_div_pars *pars, + const u8 *table, u8 table_size, u64 freq_millihz); +#else +static inline bool rzv2h_get_pll_pars(const struct rzv2h_pll_limits *limit= s, + struct rzv2h_pll_pars *pars, + u64 freq_millihz) +{ + return false; +} + +static inline bool rzv2h_get_pll_divs_pars(const struct rzv2h_pll_limits *= limits, + struct rzv2h_pll_div_pars *pars, + const u8 *table, u8 table_size, + u64 freq_millihz) +{ + return false; +} +#endif + #endif --=20 2.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pg1-f182.google.com (mail-pg1-f182.google.com [209.85.215.182]) (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 DEDC730F933 for ; Wed, 15 Oct 2025 19:27:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556426; cv=none; b=ZDWSpH8pqCEOEvhdBzTWP9P0AJYP1AWOTxFXDXB2DTtSMCZLC+hbjGyZQXwuwdNTjx27T4NkpZpTQv1tdMk6+oHdNyqJ84mdqXTvhWc9hKV6OgTZkmnqtjOX9Hp1uIIvXhoBVnY491Xc8xZScUrlyCaIIXZAHn3VL7+hI5IQD38= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556426; c=relaxed/simple; bh=jOWwqc4xlkC9nJNxXLYdhTXHl/NbJIq8hbO4w0ednNg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=M8sG1dExX9GtaEG+58AC/NTr6NeOOSwjCk4y7QvcdTUALwaCM/7x2g/Z/zfod0BpuXnJcctktaAcl0gsN0XVc6sd5lz+7kxuOclnXqFspRcaBkDZ7y9TisKZ25ZMDhslQDxtY8RtJzN6jG6n180g+g43DfBXFH2iZzrtJsTlRYs= 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=bLE4kqu9; arc=none smtp.client-ip=209.85.215.182 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="bLE4kqu9" Received: by mail-pg1-f182.google.com with SMTP id 41be03b00d2f7-b63148d25c3so959427a12.1 for ; Wed, 15 Oct 2025 12:27:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556424; x=1761161224; 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=I7v9pHDAeOAq+Vk7Oo2eA1ARB6UJBIXPWUcJvji7JLc=; b=bLE4kqu9lWWoL+XBxIEx7+MwrbqOLAne0hSsDI4ji0v/xUqniZIfNk1JV0VTLqKRCC /QLJoEs7j87oAIkvlI7PgoN35WFk3jVQFbFgIkmX48fROaIoYKXhGm4UWziEmyBaGtAe JN8FzYfYXagSNdSLx1gdzAKyG3d/rfH/fUBO3EWq5ktHYzU6yIcXZ5mKxg/LZE/zQlK6 ORcI0zTcmW5yCf4bdny7TW6MUoMDLPm0+VjYNhRsragg+Qr18v7oAxecQovj/OYxL2kb O1asSSACQlrR9AE+g9UqOJvZlxIJs62uaFqvh0uDLiNvTiOzs9FqMGyFy1llmhnaNRyI 57CQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556424; x=1761161224; 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=I7v9pHDAeOAq+Vk7Oo2eA1ARB6UJBIXPWUcJvji7JLc=; b=uItTsTyurUUHAjClCtgvPaUeG3b+32fo4hJOmXJ7SgolWahA7Gui/gWMXaS7N1JBQG 2ADCmOXA2e6bZbzYFOC7J21piiyKJzT9RFQ6iGjFJdLSUefR2E1tq3y7dX3cuXqghXW5 xgUipFsfV+9ONfGERelpzoo29dSY6QVbzUC+uef2j2fPV25lV2Z+sCaK+eN3rPlzk5MW uYIgivuGtDd7+kNBNTdFkklkS6Cd4eJooNxYgHYP5syc2wxum6SITW/Qakr6PAV7tlfK IJmutC148yjQD8fkiTkBiPjKe/bLnjZwei/+UiTBEjXfFEyqvNlgjTnIRsfiwFcvk5me Aaxg== X-Forwarded-Encrypted: i=1; AJvYcCWiCtihWDfIgNsDNh2FA0vkXBz6q52cDRzguj0hOLg+v8PPLpM8KNsm/fJp3UbBry5llTJVIqQk9iaV6rw=@vger.kernel.org X-Gm-Message-State: AOJu0Yw7IocbGfyaebCVmWaZyuKsni4f2xrETJuhyppNbky0DjT+2s4o ZmGFcGUyZ9Oz1DO+G9SP1EDheup36ccSDxQUyO9p+CcMHNFW7xdy1SQP X-Gm-Gg: ASbGncs0lTF7sjm4SEnCgKAShyhfeHxP2NFJ627CjDqVTUNrbsqi40KQd8bR3KOxnkp gmp9JLdLU8QPPWlO4u3bOIODs0EvXn8rtR83bqlRg00yR1uM5imsXqsm2Rwd+4QWP8noJU8Xhkv lcUbiPFHgX7GEBPUq20J9Jb8jnRJm4pNRzfpMjqoiQ+ZqpBWORMOodXumRvvXFhVEh1RNG30WSA SGsYau/BNGgv2sxNegl7MKugdFFEQFFwCvCa4h+tUALs8j3Wde2jMc1WKOvvCt08ReYtO4ZAjJT 87mHrsJWa5RnlDNPRiMrYfOF2M9grBeaZ9bIKWXDuaoFh6SNDh7kHVFYZze3peEYbXEoY6hlfLL ubIcyRLMr985Hfv2DnptWPMpgmzTHv3laLqZrSpX+a2T06ROMllLVDOyb+G3b8YaaRPRGhgHq+C K3fwiz4PR+no/btCOG7zAz0HSfDTpnZBvG X-Google-Smtp-Source: AGHT+IHQZrSW7Bt7HEErdGXPJT7s1c8sc+ySvpTq2gcFKcHOQHcXAay/lKlxZ4wtY6mhHEwLa9O0Tw== X-Received: by 2002:a17:902:ccc2:b0:288:5ce8:ea74 with SMTP id d9443c01a7336-290919d5364mr14751325ad.3.1760556424104; Wed, 15 Oct 2025 12:27:04 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.26.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:27:03 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 v11 4/7] clk: renesas: r9a09g057: Add clock and reset entries for DSI and LCDC Date: Wed, 15 Oct 2025 20:26:08 +0100 Message-ID: <20251015192611.241920-5-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 Reviewed-by: Biju Das Reviewed-by: Geert Uytterhoeven --- v10->v11: - No changes. v9->v10: - No changes. v8->v9: - Updated to use renesas.h v7->v8: - Added reviewed-by tags from Geert and Biju v6->v7: - Dropped passing plldsi_limits v5->v6: - Renamed CLK_DIV_PLLETH_LPCLK to CLK_CDIV4_PLLETH_LPCLK - Renamed CLK_CSDIV_PLLETH_LPCLK to CLK_PLLETH_LPCLK_GEAR - Renamed CLK_PLLDSI_SDIV2 to CLK_PLLDSI_GEAR - Renamed plldsi_sdiv2 to plldsi_gear 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 | 62 +++++++++++++++++++++++++++++ drivers/clk/renesas/rzv2h-cpg.h | 3 ++ 2 files changed, 65 insertions(+) diff --git a/drivers/clk/renesas/r9a09g057-cpg.c b/drivers/clk/renesas/r9a0= 9g057-cpg.c index c9c117c6782c..4d63eaad2365 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 */ @@ -64,6 +66,9 @@ enum clk_ids { CLK_SMUX2_GBE0_RXCLK, CLK_SMUX2_GBE1_TXCLK, CLK_SMUX2_GBE1_RXCLK, + CLK_CDIV4_PLLETH_LPCLK, + CLK_PLLETH_LPCLK_GEAR, + CLK_PLLDSI_GEAR, CLK_PLLGPU_GEAR, =20 /* Module Clocks */ @@ -92,6 +97,26 @@ static const struct clk_div_table dtable_2_16[] =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}, @@ -108,6 +133,17 @@ 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}, +}; + +RZV2H_CPG_PLL_DSI_LIMITS(rzv2h_cpg_pll_dsi_limits); +#define PLLDSI PLL_PACK_LIMITS(0xc0, 1, 0, &rzv2h_cpg_pll_dsi_limits) + /* 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" }; @@ -129,6 +165,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 */ @@ -170,6 +207,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_CDIV4_PLLETH_LPCLK, CLK_PLLETH, 1, 4= ), + DEF_CSDIV(".plleth_lpclk_gear", CLK_PLLETH_LPCLK_GEAR, CLK_CDIV4_PLLETH_L= PCLK, + CSDIV0_DIVCTL2, dtable_16_128), + + DEF_PLLDSI_DIV(".plldsi_gear", CLK_PLLDSI_GEAR, CLK_PLLDSI, + CSDIV1_DIVCTL2, dtable_2_32), =20 DEF_DDIV(".pllgpu_gear", CLK_PLLGPU_GEAR, CLK_PLLGPU, CDDIV3_DIVCTL1, dta= ble_2_64), =20 @@ -381,6 +424,22 @@ static const struct rzv2h_mod_clk r9a09g057_mod_clks[]= __initconst =3D { BUS_MSTOP(9, BIT(9))), DEF_MOD("isp_0_isp_sclk", CLK_PLLVDO_ISP, 14, 5, 7, 5, BUS_MSTOP(9, BIT(9))), + 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_GEAR, 14, 10, 7, 10, + BUS_MSTOP(9, BIT(14) | BIT(15))), + DEF_MOD("dsi_0_lpclk", CLK_PLLETH_LPCLK_GEAR, 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_GEAR, 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, @@ -456,6 +515,9 @@ static const struct rzv2h_reset r9a09g057_resets[] __in= itconst =3D { DEF_RST(13, 2, 6, 3), /* ISP_0_REG_ARESETN */ DEF_RST(13, 3, 6, 4), /* ISP_0_ISP_SRESETN */ DEF_RST(13, 4, 6, 5), /* ISP_0_PRESETN */ + 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 */ diff --git a/drivers/clk/renesas/rzv2h-cpg.h b/drivers/clk/renesas/rzv2h-cp= g.h index f7b4e4785d0f..dc957bdaf5e9 100644 --- a/drivers/clk/renesas/rzv2h-cpg.h +++ b/drivers/clk/renesas/rzv2h-cpg.h @@ -127,6 +127,7 @@ struct fixed_mod_conf { #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) @@ -144,7 +145,9 @@ struct fixed_mod_conf { =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 CSDIV0_DIVCTL3 DDIV_PACK_NO_RMW(CPG_CSDIV0, 12, 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.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pl1-f179.google.com (mail-pl1-f179.google.com [209.85.214.179]) (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 73E5C30FC16 for ; Wed, 15 Oct 2025 19:27:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556436; cv=none; b=TMHOEDntliXW6NZl/VkLdr+GL07nFtWnbAPo86slXl5Tf0Gh02ZRLfeSb+cuh4uWYH5TSWuZ9aFMYwFHBznb+0ssVQu1SZWet+x3HiRusMnkbik7TDFn4Jpwktn2XnXkDUmR63JK75jVnO3jJEiMKbpn7T4TgJVUd2x/5xok3Lk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556436; c=relaxed/simple; bh=RTqcRA9Wm9Ehn4pJC+oPp3/yQh3Us97qd4vkt5bR6ts=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=jEaDblUjf328UlIaMuMiVoMEpYqi7hM44AE8uOO5ZejAPq/VCteNDuiVBFCW/IJP2JkAi57lkh8xmhwB0gde6nWjwojL6KNgIytvBfUi6AgYPC67UBw7KG1v83rgqy5CNLxyLrjyjcCJyYbWvM6xx+KuC/y2vx2ZXJkGO7SAKuc= 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=kKlkRS8q; arc=none smtp.client-ip=209.85.214.179 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="kKlkRS8q" Received: by mail-pl1-f179.google.com with SMTP id d9443c01a7336-271d1305ad7so109421975ad.2 for ; Wed, 15 Oct 2025 12:27:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556434; x=1761161234; 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=aCB83fna0UrFuRZ7ssCh3d7w5oMcQfF2kPoFGBoLlaM=; b=kKlkRS8qm8M6VIxxWIS4OBE1/MwVDvAPtFO7Qv/nf60rV2yf2Bhm2/vNfX/vizSWJN Z0cDq+GVPz6Lb+ABj6iLMUTYDLdEjSvixldBHiZQNK99+cfpRCspFua0HQWhffg60EyZ Mz8euKfYzv5cTlWrjT9kQR6jQSPVcTiqfyLVPq9b+OxTTsDgURmbJEzN+wzBwQaIK0W7 Y3O0Cl9o5DonjaeJZnCPMhQqm2HRgbBdOylNGihDJ7FtEj8W6rQvPNQu72YtALeukfW8 IyMDos02v1NVY8StqafRznQVQKLOjLPEw4K+AMuKVhoh1+x1dgICWsXvEmPcccNehsUr pnNQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556434; x=1761161234; 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=aCB83fna0UrFuRZ7ssCh3d7w5oMcQfF2kPoFGBoLlaM=; b=B0Pz+gh84Htj30JubMB/p2bucQAqIySrhPS4CLZYJfmf35GrJkPxS5yClMCtquwI3W reUYcNMlcuJlwUTZka1tHoTrWrmnFZuJS/JHh9t5bSP3UPfpnKVghtJbg6Y4dyOU0Xki TldlWjT+5YW8IzW3Ah51PnoriP8rOr9MMJuWvn42iBkE1XrTDR25nmb1DzWGF0ZCuNDr A8VBpUvshdOkmsVwIPxmqZlXAOLNpnzPtJG5+zdd3UeB/z9Ux7tgTAtut/B/MRlUHnAY bmCF62k7+bp4xlLKg3QDqjveHthFXvFNqo193WRhKZFHgB7b5kRqtdUVjOsoZ11FySS/ t9Lw== X-Forwarded-Encrypted: i=1; AJvYcCVuENQbuOqtFjMivfAeOl3r1ShULWKdwesePHqdMHeZqJj8Sn9quhnLbu5NODzpZTWBru4IDtl8eUbAps0=@vger.kernel.org X-Gm-Message-State: AOJu0YxZR1E1yfoalyAxF3C0MvresWTgjHzGWsS0zukrfKTtwIZ5vgld zHuxFfvskUDwoiyG+DVKQYEUIBBphyE1M6oVSFYDrrgTEK0CZvXSsuDN X-Gm-Gg: ASbGncsJK9bBSUPKpjgM3AONFgmZIbjj1aqae3X0swFOTFd3/x7XxP5M7DcsenjdAD7 CL1vApQfU8pliV5+woaE71g08ZM03PekaRFvwLYU9znCOd1KvQvjJdeGjxunZG/PiPGQ7c9+X1g oF2MuzU1v/auGQBqKHuGCaF2wOQpWju6DJhqbpaxczkgSWSzBvd3BUeBJY/4NIKNa41PMrHQzy9 1oXa+cGf1K7yf0zq47hEk6kjUPKu76yAnrAOQ96b2VJmOGDc+4nR5f19Of7G0YLpiAkPKuepsuE 87rN+kDhhUKNueNt369cInyT2+iKDL8FGhX5x5bZxhYMZH8pshVh2MGRRMApi7icl3Q14r8ENei N1U4vp3q69kgZ8y4swDuD9UhL+Y1pVRsMJbJLwzXQDyGCL4i3zEptWWBVwm0MAdNVkEDp/2V/Gb dH2kvamzE6pT8B/XpdQ4yoUuXJqSh2Gqzo X-Google-Smtp-Source: AGHT+IFBgcljKCUXYZa2r8bWo1W2hIkTIBOP8HAHsSx3FOmKt9OEFyrfwCEZRDkEtZrlv6h4/llC3A== X-Received: by 2002:a17:903:1b2e:b0:27b:472e:3a22 with SMTP id d9443c01a7336-2902741cd22mr376111055ad.56.1760556433713; Wed, 15 Oct 2025 12:27:13 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.27.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:27:12 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 , Tomi Valkeinen Subject: [PATCH v11 5/7] dt-bindings: display: bridge: renesas,dsi: Document RZ/V2H(P) and RZ/V2N Date: Wed, 15 Oct 2025 20:26:09 +0100 Message-ID: <20251015192611.241920-6-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 the compatible string "renesas,r9a09g057-mipi-dsi" for the Renesas RZ/V2H(P) (R9A09G057) SoC. While the MIPI DSI LINK registers are shared with the RZ/G2L SoC, the D-PHY register layout differs. Additionally, the RZ/V2H(P) uses only two resets compared to three on RZ/G2L, and requires five clocks instead of six. To reflect these hardware differences, update the binding schema to support the reduced clock and reset requirements for RZ/V2H(P). Since the RZ/V2N (R9A09G056) SoC integrates an identical DSI IP to RZ/V2H(P), the same "renesas,r9a09g057-mipi-dsi" compatible string is reused for RZ/V2N. Signed-off-by: Lad Prabhakar Reviewed-by: Krzysztof Kozlowski Reviewed-by: Geert Uytterhoeven Reviewed-by: Tomi Valkeinen --- v10->v11: - No changes. v9->v10: - No changes. v8->v9: - No changes v7->v8: - Added reviewed-by tags from Geert and Tomi v6->v7: - Renamed pllclk to pllrefclk - Preserved the reviewed by tag from Geert and Krzysztof v5->v6: - Preserved the sort order (by part number). - Added reviewed tag from Geert. 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 | 120 +++++++++++++----- 1 file changed, 91 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 5a99d9b9635e..c20625b8425e 100644 --- a/Documentation/devicetree/bindings/display/bridge/renesas,dsi.yaml +++ b/Documentation/devicetree/bindings/display/bridge/renesas,dsi.yaml @@ -14,16 +14,21 @@ 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: + - items: + - enum: + - renesas,r9a07g044-mipi-dsi # RZ/G2{L,LC} + - renesas,r9a07g054-mipi-dsi # RZ/V2L + - const: renesas,rzg2l-mipi-dsi + + - items: + - const: renesas,r9a09g056-mipi-dsi # RZ/V2N + - const: renesas,r9a09g057-mipi-dsi + - 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) =20 reg: maxItems: 1 @@ -49,34 +54,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 reference 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: pllrefclk + - 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 +157,41 @@ required: =20 unevaluatedProperties: 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.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pl1-f180.google.com (mail-pl1-f180.google.com [209.85.214.180]) (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 48320324B1D for ; Wed, 15 Oct 2025 19:27:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556445; cv=none; b=RKJ99fOXXg2foVgXpnTeye2Mtb6KQMwCEeNBxFRNkftIk64f4cBe5rpz2mWlmJFSXMXPtATabyA1H81xm8VgEMTHcYaoHFfA42PMD3hY12gOzX+EcUvPZNkGobGb+yGYPB8tR5DVm6NIrWi48Jr0tA4MvzVACz3bE8A3eaTkFis= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556445; c=relaxed/simple; bh=NTjuf7bfo6RX2CGL8a/iTDj7lfSodD8ZOOLQqrbK1B4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IA/JtvKeDTn6svC/WlbHmzqg1feefhYZt3ImAe81xal5ugM15+YpsaDtWayHKcUE9oW3mOKcTCJH42PMIi9WZ1b0WY41I9Da7idNDUGaOZt3f3bj2EwUR6Hd9uzKqSKFGnadUkR0d+KNbD+6yCBnvrAlzRLRcGFKP8EuPLFIi14= 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=GJVWslYf; arc=none smtp.client-ip=209.85.214.180 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="GJVWslYf" Received: by mail-pl1-f180.google.com with SMTP id d9443c01a7336-2681660d604so75469335ad.0 for ; Wed, 15 Oct 2025 12:27:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556443; x=1761161243; 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=Pom1z8x6b2wC6BQNMaEH7yl2novyBrsq9B9vL+Qq3dc=; b=GJVWslYfUnLtBSJnQ6opFTStZaxyNXN4YWeHSuKg9u9ilJ5S3pdhkpE0RgG5edyLWm Evmg8jvtgsTGmni3v7JxhsBNFdiOPuQfhp6IVSD6vvwuQkm/kHtJCEnbyXJrgVZfba3b m/Pn3j8oIu25NLS6TdF3NQ+OhO+CIg7YagXQ0JXX39liR6jnS3/f8aI2K5FDt9A1pPGO bhCKRum8Ti/jQBlX5y16NFFhB+Zbktn3uN7b0dZgfVZgLbfO3w5yh7RUAzE/KbS0ZNfd 4ljcvIM4fQbHnqHpfJ4d2v4dzYgpM4eVGHIyfo/7RqcjGqUgZHFUAGumhIDuk0Xx6rfV 7AXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556443; x=1761161243; 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=Pom1z8x6b2wC6BQNMaEH7yl2novyBrsq9B9vL+Qq3dc=; b=La1hKcFtGVQS49Hq75FHqvGmAv1cBcn8cdYID3hFbX5Nqek51/0169ox/EOLuMThJE ovwjg/AuamjS03rlFCkZy0yyNigO8ETayvAaD/+J8ezMGfuYFrA1DOqRUIwasdifPwAY jsvIevWRNVMr4k4qjL7g9sl9TZcmVC3YWxguKUc+uDUNdd3DYeeosm8a6hK8Vl0FUrV1 CUX0RKB2iML3TYjj4nRtY26dd9jgyZgbbAqfcgfVZ0vhOwIdaxi2CWr0M3SZo4AqXmVH JK+FVFiUMIhCeXRUOhB37k3xZhjHfyAhMqcB+yZM6Npt4CcSP0mY+aXIXCZg9w7YS3Hr zGGA== X-Forwarded-Encrypted: i=1; AJvYcCWmepBGzzNRM7HRvUxrLW0vS8rZeX4oUzIhnhKemepTKO4vChF1FhkLNBskll/7ahPQBnBENYw6p8Ge0Qg=@vger.kernel.org X-Gm-Message-State: AOJu0YzQuFAkj5IzlohFVclTzbOoy/QfC0xzl81Zu52qrcu4bKjwna8Z SNngSjjG+swc6CkBkrpio2pJLu/DetPmLciv22m4P5p1mL+DOq09LW1W X-Gm-Gg: ASbGncucqD31WahquOfP+jY1KMn2Tj7zHpMSErV24SLIpdO+7orp25x/hDtg9WzwCfj llasBswt9MuY4yoseSME3d9+5rs++SYGWy1j87Z0N1oXzcRLO3vPtMN/NcBRFT5fWKpbPWKWnFQ bd9awRw+/z5IIM3Zw6myrifbYiYpUNz1geHuNkJCGYFgwTvF4fYPltrqL8q6wisGTjP1oXhH5+4 qbijuZavjF9W+YTnZQvsS1TMn8LjNJm0z4JYN8/jN4ParlCx4ptIl1U0GtwBLZ0g9XZL/3KWpFf yNpgQvRVMcQCXdtPbWdGWG3+ovPruiEWqIMvjxH2WGqRgrTWcDEeSqggbfMeutCSLDxbCbaVKxD 5zQSdr2fKHmb16QCakLDaziq34DdSTIp7f/WntGSH4WdM257a+SVRFAZc/SCWImTijobMOKt7QR zw/K0XJfV3GWKq2bq2wITLZi2+qPweF7HF X-Google-Smtp-Source: AGHT+IEUBZvmZ7j5CmyPSsiuBgYRCtqbKU9tc4v6VxZf7CqxDQDbwQYqkXWhISDpFwWeOwm+SJbo/w== X-Received: by 2002:a17:902:ef10:b0:271:5bde:697e with SMTP id d9443c01a7336-29027213340mr393885805ad.3.1760556442627; Wed, 15 Oct 2025 12:27:22 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.27.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:27:22 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 , Tomi Valkeinen Subject: [PATCH v11 6/7] drm: renesas: rz-du: mipi_dsi: Add LPCLK clock support Date: Wed, 15 Oct 2025 20:26:10 +0100 Message-ID: <20251015192611.241920-7-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 LPCLK clock handling to the RZ/G2L MIPI DSI driver to support proper DSI timing parameter configuration on RZ/V2H SoCs. While lpclk is present on both RZ/G2L and RZ/V2H SoCs, the RZ/V2H SoC specifically uses the lpclk rate to configure the DSI timing parameter ULPSEXIT. Introduce a new lpclk field in the rzg2l_mipi_dsi structure and acquire the "lpclk" clock during probe to enable lpclk rate-based timing calculations on RZ/V2H while maintaining compatibility with RZ/G2L. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar Reviewed-by: Biju Das Reviewed-by: Tomi Valkeinen --- v10->v11: - No changes. v9->v10: - No changes. v8->v9: - Added reviewed-by tag from Tomi v7->v8: - Updated commit message - Switched to use devm_clk_get() instead of devm_clk_get_optional() as lpclk clock is available on all SoCs. v6->v7: - New patch Note, this patch was previously part of series [0]. [0] https://lore.kernel.org/all/20250609225630.502888-1-prabhakar.mahadev-l= ad.rj@bp.renesas.com/ --- drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c | 5 +++++ 1 file changed, 5 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 3b52dfc0ea1e..bb03b49b1e85 100644 --- a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c +++ b/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c @@ -68,6 +68,7 @@ struct rzg2l_mipi_dsi { struct drm_bridge *next_bridge; =20 struct clk *vclk; + struct clk *lpclk; =20 enum mipi_dsi_pixel_format format; unsigned int num_data_lanes; @@ -979,6 +980,10 @@ static int rzg2l_mipi_dsi_probe(struct platform_device= *pdev) if (IS_ERR(dsi->vclk)) return PTR_ERR(dsi->vclk); =20 + dsi->lpclk =3D devm_clk_get(dsi->dev, "lpclk"); + if (IS_ERR(dsi->lpclk)) + return PTR_ERR(dsi->lpclk); + dsi->rstc =3D devm_reset_control_get_optional_exclusive(dsi->dev, "rst"); if (IS_ERR(dsi->rstc)) return dev_err_probe(dsi->dev, PTR_ERR(dsi->rstc), --=20 2.43.0 From nobody Tue Dec 16 07:27:37 2025 Received: from mail-pl1-f170.google.com (mail-pl1-f170.google.com [209.85.214.170]) (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 EF69E30FF3C for ; Wed, 15 Oct 2025 19:27:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556456; cv=none; b=ZiIxmG0Co3yAf6KdNnDpLWjzwcSGhTiEyw1pG4uzr1NohBTao4NTpZJo08SmNfmrFELG2FDPoNdSo2YmsGwajuVgiJt64iBG1wagi/hlQPxvNxgCLCm6Jzp7Hsjly4tDycyoEwR6MfMsmZDACRzfT2fyADDg7hQjXpqTkbzfx+c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760556456; c=relaxed/simple; bh=8u7nhUiv5K/MBE56uTam+cSyXrFFugM69KQXdbqsl7c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KIpUQlWGtGCi5GlflkR+zAD1H8NB79JlrkFFiCfH3yVo62AjI7F9ZKIVnWCQoIz2n1+aZVdXe/2Uzfva08Tb56Ek8XlKGdiJMY+UP9vtuEjGqmlNqEfBWleWCQyzCxVjshazmcvTaKwifeysDfAaTb77qS9P2PrnQUTsd6f/zqg= 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=hJ62ulcU; arc=none smtp.client-ip=209.85.214.170 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="hJ62ulcU" Received: by mail-pl1-f170.google.com with SMTP id d9443c01a7336-2681660d604so75470655ad.0 for ; Wed, 15 Oct 2025 12:27:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1760556452; x=1761161252; 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=ubI79ySD8UP2fY7i/3+k2IDdSEwO66wtKTV1JmVbwek=; b=hJ62ulcUvdNPgJsia8Idm2ePCn1oDAFzbhMFEeurSREQw11tXHf5/CvY8l5jS72Oqi TowmthY16KaW+8N9Xi6y+fXLHFndBNtctG8qq1N3hIwvthSLgiJoBdp0jbWHE4Etk/Jd i/3zflcWrsmL0WunDBHGBZ3sFZl/zptpFD8ZXNVU2I8HqbcDXdw2nWL+TyO1zt78duGE 7HYFVewg5gHELD+eiiIkQ1b9QW45C/O5VK5CgZv0QoV3z2OSpJLCakkHf+xelX9Tg5c9 1zT9SQaD7etmZTyZkrUv8LrEvQy2lcS5PEnffTXtxcx2j95Tx6suhVr1GILDarytYe3N QKIA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1760556452; x=1761161252; 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=ubI79ySD8UP2fY7i/3+k2IDdSEwO66wtKTV1JmVbwek=; b=YoO1d7bF0Cuh61iR0zU05rBgKDzLAoXF7wsUP3UoUjGfgqNiZqO9PfjDAiL3fQ63RV uZdd5BO4KT7GL3NfvXZB6JegH8W9BUTKb0x640/Awv6BtfvafCbo/424Npc6Bcmwmi+t o1LTubw4fdqm+/WD5PTvDVMl9vUqf9ohdS8fYs87LK60cmFm0T4oKkPFHkJCh03pM3Vc Wx9teJ0EQYg/vyocaxCwmJ2sihXaZuhw71N1gRAsWuVmwV178jAwnIS7r65WQG0Ye2VN 0LWHcR7eFAzWWxxglIStc5xTheJbCSkukXnvV4D/d4Ab0371utfX9RJbDNct7YLMJlVl P1yw== X-Forwarded-Encrypted: i=1; AJvYcCX7oc1lnEtVIP+lIsRk3DIZiPc7rColwD09sSmbuxQ622hMwo3qSFESTPo0ejF14wsFwvEO4Ls8J1quRoY=@vger.kernel.org X-Gm-Message-State: AOJu0YygsPReQ+uUoZUzmjW+Jfo1biOIH9UsZFbGG4OQ7CBdfHV0A74I tww4GCz6Cuj0rp2I+hDXj4QuILmHN28Lfx/KHxwtAUAa60PBsvKS4FAx X-Gm-Gg: ASbGnctxQT88sDK7zefma3mBkGkdEpMIjzIU0KnJi0EyCzwD7ZnTxCOzjAQfpOimO41 +4Cu4wmLngUUok7o0zxpuraxGDfAqzOR5mp3MB7OFifGvG4/0GpFU0aNfTdd2q765mKgwCpUL/o 4cfNdptwyLnJdiRnlhm+RAsTGwM+3x1rRLhTIIDR4hr8pJJV7zpMfG77llwyXxe8ogHYd/3fAld jT627JeQRQnEN6qx68nJzZ3oEid6uEF5WeZoNJsEHZJA5OP15EzN9fp4a6fNepsTagyIddv0XmB Ai6hWs8bMNrN2uA2Cvwu6h/0GGpBpLKk4mf4U0qc8p/ButPl6a81LUv7MiyV3kMeDcivg/VovX8 zTXGX5o5bRM99BJsheq5YCTcNngRZ8XgC+/QqrgDcIFTAztT1dswjl/1/W4MIW4y/SrA4UyCoQP VSY4e7vdvi/lkY6sxG5/rAcNpMe8TYNRg/ X-Google-Smtp-Source: AGHT+IFJqA9BacA3NFTHtkW9dLLKPK/CbOWGM4GkY/+778t79TfXwqNlsVn4k8TFmt/gv5jw3ka3ZA== X-Received: by 2002:a17:903:2351:b0:269:a23e:9fd7 with SMTP id d9443c01a7336-29027262689mr435879645ad.26.1760556451917; Wed, 15 Oct 2025 12:27:31 -0700 (PDT) Received: from iku.. ([2401:4900:1c07:c7d3:f449:63fb:7005:808e]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-290993102c9sm4427005ad.24.2025.10.15.12.27.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Oct 2025 12:27:31 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Geert Uytterhoeven , Andrzej Hajda , Neil Armstrong , Robert Foss , Laurent Pinchart , Jonas Karlman , Jernej Skrabec , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , Rob Herring , Krzysztof Kozlowski , Conor Dooley , 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 , Tomi Valkeinen Subject: [PATCH v11 7/7] drm: renesas: rz-du: mipi_dsi: Add support for RZ/V2H(P) SoC Date: Wed, 15 Oct 2025 20:26:11 +0100 Message-ID: <20251015192611.241920-8-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251015192611.241920-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20251015192611.241920-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 MIPI DSI support for the Renesas RZ/V2H(P) SoC. Compared to the RZ/G2L family, the RZ/V2H(P) requires dedicated D-PHY PLL programming, different clock configuration, and additional timing parameter handling. The driver introduces lookup tables and helpers for D-PHY timings (TCLK*, THS*, TLPX, and ULPS exit) as specified in the RZ/V2H(P) hardware manual. ULPS exit timing depends on the LPCLK rate and is now handled explicitly. The implementation also adds support for 16 bpp RGB format, updates the clock setup path to use the RZ/V2H PLL divider limits, and provides new .dphy_init, .dphy_conf_clks, and .dphy_startup_late_init callbacks to match the RZ/V2H sequence. With these changes, the RZ/V2H(P) can operate the MIPI DSI interface in compliance with its hardware specification while retaining support for existing RZ/G2L platforms. Co-developed-by: Fabrizio Castro Signed-off-by: Fabrizio Castro Signed-off-by: Lad Prabhakar Reviewed-by: Tomi Valkeinen --- v10->v11: - Dropped Kconfig change to select CLK_RZV2H v9->v10: - Dropped Kconfig change to select CLK_RZV2H v8->v9: - Updated Kconfig to select CLK_RZV2H - Updated to use renesas.h - Added reviewed-by tag from Tomi v7->v8: - Updated commit message - Simplified check in rzv2h_mipi_dsi_dphy_init() for PLL parameters - Renamed start_index member to base_value in struct rzv2h_mipi_dsi_timings - Added comments in the code for DSI arrays and their usage - Added comments in the code for sleeps v6->v7: - Used the new apis for calculating the PLLDSI parameters in the DSI driver. v5->v6: - Made use of GENMASK() macro for PLLCLKSET0R_PLL_*, PHYTCLKSETR_* and PHYTHSSETR_* macros. - Replaced 10000000UL with 10 * MEGA - Renamed mode_freq_hz to mode_freq_khz in rzv2h_dsi_mode_calc - Replaced `i -=3D 1;` with `i--;` - Renamed RZV2H_MIPI_DPHY_FOUT_MIN_IN_MEGA to RZV2H_MIPI_DPHY_FOUT_MIN_IN_MHZ and RZV2H_MIPI_DPHY_FOUT_MAX_IN_MEGA to RZV2H_MIPI_DPHY_FOUT_MAX_IN_MHZ. 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 rzv2h_info --- .../gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c | 448 ++++++++++++++++++ .../drm/renesas/rz-du/rzg2l_mipi_dsi_regs.h | 34 ++ 2 files changed, 482 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 bb03b49b1e85..5edd45424562 100644 --- a/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c +++ b/drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c @@ -7,6 +7,7 @@ =20 #include #include +#include #include #include #include @@ -32,6 +33,8 @@ =20 #include "rzg2l_mipi_dsi_regs.h" =20 +MODULE_IMPORT_NS("RZV2H_CPG"); + #define RZG2L_DCS_BUF_SIZE 128 /* Maximum DCS buffer size in external memo= ry. */ =20 #define RZ_MIPI_DSI_FEATURE_16BPP BIT(0) @@ -46,6 +49,11 @@ struct rzg2l_mipi_dsi_hw_info { u64 *hsfreq_millihz); unsigned int (*dphy_mode_clk_check)(struct rzg2l_mipi_dsi *dsi, unsigned long mode_freq); + struct { + const struct rzv2h_pll_limits **limits; + const u8 *table; + const u8 table_size; + } cpg_plldsi; u32 phy_reg_offset; u32 link_reg_offset; unsigned long min_dclk; @@ -53,6 +61,11 @@ struct rzg2l_mipi_dsi_hw_info { u8 features; }; =20 +struct rzv2h_dsi_mode_calc { + unsigned long mode_freq_khz; + struct rzv2h_pll_pars dsi_parameters; +}; + struct rzg2l_mipi_dsi { struct device *dev; void __iomem *mmio; @@ -75,11 +88,22 @@ struct rzg2l_mipi_dsi { unsigned int lanes; unsigned long mode_flags; =20 + struct rzv2h_dsi_mode_calc mode_calc; + /* DCS buffer pointers when using external memory. */ dma_addr_t dcs_buf_phys; u8 *dcs_buf_virt; }; =20 +static const struct rzv2h_pll_limits rzv2h_plldsi_div_limits =3D { + .fout =3D { .min =3D 80 * MEGA, .max =3D 1500 * MEGA }, + .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 }, +}; + static inline struct rzg2l_mipi_dsi * bridge_to_rzg2l_mipi_dsi(struct drm_bridge *bridge) { @@ -194,6 +218,237 @@ static const struct rzg2l_mipi_dsi_timings rzg2l_mipi= _dsi_global_timings[] =3D { }, }; =20 +/** + * struct rzv2h_mipi_dsi_timings - Timing parameter table structure + * + * @hsfreq: Pointer to frequency threshold array + * @len: Number of entries in the hsfreq array + * @base_value: Base register value offset for this timing parameter + * + * Each timing parameter (TCLK*, THS*, etc.) has its own table with + * frequency thresholds and corresponding base register values. + */ +struct rzv2h_mipi_dsi_timings { + const u8 *hsfreq; + u8 len; + u8 base_value; +}; + +/* + * enum rzv2h_dsi_timing_idx - MIPI DSI timing parameter indices + * + * These enums correspond to different MIPI DSI PHY timing parameters. + */ +enum rzv2h_dsi_timing_idx { + TCLKPRPRCTL, + TCLKZEROCTL, + TCLKPOSTCTL, + TCLKTRAILCTL, + THSPRPRCTL, + THSZEROCTL, + THSTRAILCTL, + TLPXCTL, + THSEXITCTL, +}; + +/* + * RZ/V2H(P) Frequency threshold lookup tables for D-PHY timing parameters + * + * - Each array contains frequency thresholds (in units of 10 Mbps), + * taken directly from the table 9.5-4 hardware manual. + * - These thresholds define the frequency ranges for which timing + * register values must be programmed. + * - The actual register value is calculated in + * rzv2h_dphy_find_timings_val(): + * + * register_value =3D timings->base_value + table_index + * + * Example (TCLKPRPRCTL, from HW manual): + * 0-150 Mbps -> index 0 -> register_value =3D base + 0 =3D 0 + 0 =3D 0 + * 151-260 Mbps -> index 1 -> register_value =3D base + 1 =3D 0 + 1 =3D 1 + * 261-370 Mbps -> index 2 -> register_value =3D base + 2 =3D 0 + 2 =3D 2 + * + * Each of the following arrays corresponds to a specific timing + * parameter (TCLKPRPRCTL, TCLKZEROCTL, TCLKPOSTCTL, etc.). + */ +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, +}; + +/* + * rzv2h_dsi_timings_tables - main timing parameter lookup table + * Maps timing parameter enum to its frequency table, array length and + * base register offset value. + */ +static const struct rzv2h_mipi_dsi_timings rzv2h_dsi_timings_tables[] =3D { + [TCLKPRPRCTL] =3D { + .hsfreq =3D tclkprprctl, + .len =3D ARRAY_SIZE(tclkprprctl), + .base_value =3D 0, + }, + [TCLKZEROCTL] =3D { + .hsfreq =3D tclkzeroctl, + .len =3D ARRAY_SIZE(tclkzeroctl), + .base_value =3D 2, + }, + [TCLKPOSTCTL] =3D { + .hsfreq =3D tclkpostctl, + .len =3D ARRAY_SIZE(tclkpostctl), + .base_value =3D 6, + }, + [TCLKTRAILCTL] =3D { + .hsfreq =3D tclktrailctl, + .len =3D ARRAY_SIZE(tclktrailctl), + .base_value =3D 1, + }, + [THSPRPRCTL] =3D { + .hsfreq =3D thsprprctl, + .len =3D ARRAY_SIZE(thsprprctl), + .base_value =3D 0, + }, + [THSZEROCTL] =3D { + .hsfreq =3D thszeroctl, + .len =3D ARRAY_SIZE(thszeroctl), + .base_value =3D 0, + }, + [THSTRAILCTL] =3D { + .hsfreq =3D thstrailctl, + .len =3D ARRAY_SIZE(thstrailctl), + .base_value =3D 3, + }, + [TLPXCTL] =3D { + .hsfreq =3D tlpxctl, + .len =3D ARRAY_SIZE(tlpxctl), + .base_value =3D 0, + }, + [THSEXITCTL] =3D { + .hsfreq =3D thsexitctl, + .len =3D ARRAY_SIZE(thsexitctl), + .base_value =3D 1, + }, +}; + +/** + * rzv2h_dphy_find_ulpsexit - Find ULP Exit timing value based on frequency + * The function maps frequency ranges to ULP exit timing values. + * Thresholds in the local hsfreq[] are expressed in Hz already. + * + * @freq: Input frequency in Hz + * + * Return: ULP exit timing value + */ +static u16 rzv2h_dphy_find_ulpsexit(unsigned long freq) +{ + /* Frequency thresholds in Hz for ULP exit timing selection */ + static const unsigned long hsfreq[] =3D { + 1953125UL, + 3906250UL, + 7812500UL, + 15625000UL, + }; + /* Corresponding ULP exit timing values for each frequency range */ + static const u16 ulpsexit[] =3D {49, 98, 195, 391}; + unsigned int i; + + /* Find the appropriate frequency range */ + for (i =3D 0; i < ARRAY_SIZE(hsfreq); i++) { + if (freq <=3D hsfreq[i]) + break; + } + + /* If frequency exceeds all thresholds, use the highest range */ + if (i =3D=3D ARRAY_SIZE(hsfreq)) + i--; + + return ulpsexit[i]; +} + +/** + * rzv2h_dphy_find_timings_val - Find timing parameter value from lookup t= ables + * @freq: Input frequency in Hz + * @index: Index to select timing parameter table (see enum rzv2h_dsi_timi= ng_idx) + * + * Selects the timing table for the requested parameter, finds the + * frequency range entry and returns the register value to program: + * + * register_value =3D timings->base_value + table_index + * + * Note: frequency table entries are stored as small integers (units of 10= ): + * threshold_in_hz =3D (unsigned long)table_entry * 10 * MEGA + * + * Return: timing register value to be programmed into hardware + */ +static u16 rzv2h_dphy_find_timings_val(unsigned long freq, u8 index) +{ + const struct rzv2h_mipi_dsi_timings *timings; + u16 i; + + /* Get the timing table structure for the requested parameter */ + timings =3D &rzv2h_dsi_timings_tables[index]; + + /* + * Search through frequency table to find appropriate range + * timings->hsfreq[i] contains frequency values from HW manual + * Convert to Hz by multiplying by 10 * MEGA. + */ + for (i =3D 0; i < timings->len; i++) { + unsigned long hsfreq =3D timings->hsfreq[i] * 10 * MEGA; + + if (freq <=3D hsfreq) + break; + } + + /* If frequency exceeds table range, use the last entry */ + if (i =3D=3D timings->len) + i--; + + /* + * Calculate final register value: + * - timings->base_value: base value for this timing parameter + * - i: index into frequency table (0-based) + * Combined they give the exact register value to program + */ + return timings->base_value + 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); @@ -318,6 +573,169 @@ 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) +{ + u64 hsfreq_millihz, mode_freq_hz, mode_freq_millihz; + struct rzv2h_pll_div_pars cpg_dsi_parameters; + struct rzv2h_pll_pars dsi_parameters; + bool parameters_found; + unsigned int bpp; + + bpp =3D mipi_dsi_pixel_format_to_bpp(dsi->format); + mode_freq_hz =3D mul_u32_u32(mode_freq, KILO); + mode_freq_millihz =3D mode_freq_hz * MILLI; + parameters_found =3D + rzv2h_get_pll_divs_pars(dsi->info->cpg_plldsi.limits[0], + &cpg_dsi_parameters, + dsi->info->cpg_plldsi.table, + dsi->info->cpg_plldsi.table_size, + mode_freq_millihz); + if (!parameters_found) + return MODE_CLOCK_RANGE; + + hsfreq_millihz =3D DIV_ROUND_CLOSEST_ULL(cpg_dsi_parameters.div.freq_mill= ihz * bpp, + dsi->lanes); + parameters_found =3D rzv2h_get_pll_pars(&rzv2h_plldsi_div_limits, + &dsi_parameters, hsfreq_millihz); + if (!parameters_found) + return MODE_CLOCK_RANGE; + + if (abs(dsi_parameters.error_millihz) >=3D 500) + return MODE_CLOCK_RANGE; + + memcpy(&dsi->mode_calc.dsi_parameters, &dsi_parameters, sizeof(dsi_parame= ters)); + dsi->mode_calc.mode_freq_khz =3D mode_freq; + + return MODE_OK; +} + +static int rzv2h_dphy_conf_clks(struct rzg2l_mipi_dsi *dsi, unsigned long = mode_freq, + u64 *hsfreq_millihz) +{ + struct rzv2h_pll_pars *dsi_parameters =3D &dsi->mode_calc.dsi_parameters; + unsigned long status; + + if (dsi->mode_calc.mode_freq_khz !=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; + } + } + + *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_pll_pars *dsi_parameters =3D &dsi->mode_calc.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 hsfreq_millihz && + !rzv2h_get_pll_pars(&rzv2h_plldsi_div_limits, dsi_parameters, + hsfreq_millihz)) { + dev_err(dsi->dev, "No PLL parameters found for HSFREQ %lluHz\n", hsfreq); + return -EINVAL; + } + + 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 FIELD_PREP(PHYTCLKSETR_TCLKTRAILCTL, dphy_timings.tclk_tr= ail) | + FIELD_PREP(PHYTCLKSETR_TCLKPOSTCTL, dphy_timings.tclk_post) | + FIELD_PREP(PHYTCLKSETR_TCLKZEROCTL, dphy_timings.tclk_zero) | + FIELD_PREP(PHYTCLKSETR_TCLKPRPRCTL, dphy_timings.tclk_prepare); + phythssetr =3D FIELD_PREP(PHYTHSSETR_THSEXITCTL, dphy_timings.ths_exit) | + FIELD_PREP(PHYTHSSETR_THSTRAILCTL, dphy_timings.ths_trail) | + FIELD_PREP(PHYTHSSETR_THSZEROCTL, dphy_timings.ths_zero) | + FIELD_PREP(PHYTHSSETR_THSPRPRCTL, dphy_timings.ths_prepare); + phytlpxsetr =3D rzg2l_mipi_dsi_phy_read(dsi, PHYTLPXSETR) & ~PHYTLPXSETR_= TLPXCTL; + phytlpxsetr |=3D FIELD_PREP(PHYTLPXSETR_TLPXCTL, dphy_timings.tlpx); + phycr =3D rzg2l_mipi_dsi_phy_read(dsi, PHYCR) & ~GENMASK(9, 0); + phycr |=3D FIELD_PREP(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, + FIELD_PREP(PLLCLKSET0R_PLL_S, dsi_parameters->s) | + FIELD_PREP(PLLCLKSET0R_PLL_P, dsi_parameters->p) | + FIELD_PREP(PLLCLKSET0R_PLL_M, dsi_parameters->m)); + rzg2l_mipi_dsi_phy_write(dsi, PLLCLKSET1R, + FIELD_PREP(PLLCLKSET1R_PLL_K, dsi_parameters->k)); + + /* + * From RZ/V2H HW manual (Rev.1.20) section 9.5.3 Operation, + * (C) After write to D-PHY registers we need to wait for more than 1 x tp + * + * tp =3D 1 / (PLLREFCLK / PLLCLKSET0R.PLL_P) + * PLLREFCLK =3D 24MHz + * PLLCLKSET0R.PLL_P =3D {1, 2, 3, 4} + * + * To handle all the cases lets use PLLCLKSET0R.PLL_P =3D 4 + * tp =3D 1 / (24MHz / 4) =3D 1 / 6MHz =3D 166.67ns + */ + ndelay(200); + + rzg2l_mipi_dsi_phy_write(dsi, PLLENR, PLLENR_PLLEN); + /* + * From RZ/V2H HW manual (Rev.1.20) section 9.5.3 Operation, + * (D) After write to PLLENR.PLLEN we need to wait for more than 3000 x tp + * + * 3000 x tp =3D 3000 x 0.16667 ns =3D 500.01 microseconds + */ + usleep_range(510, 520); + + return 0; +} + +static void rzv2h_mipi_dsi_dphy_startup_late_init(struct rzg2l_mipi_dsi *d= si) +{ + /* + * From RZ/V2H HW manual (Rev.1.20) section 9.5.3 Operation, + * (E) After write to TXSETR we need to wait for more than 200 microsecon= ds + * and then write to PHYRSTR + */ + usleep_range(210, 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) { @@ -430,6 +848,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) && @@ -1056,6 +1477,32 @@ static void rzg2l_mipi_dsi_remove(struct platform_de= vice *pdev) pm_runtime_disable(&pdev->dev); } =20 +RZV2H_CPG_PLL_DSI_LIMITS(rzv2h_cpg_pll_dsi_limits); + +static const struct rzv2h_pll_limits *rzv2h_plldsi_limits[] =3D { + &rzv2h_cpg_pll_dsi_limits, +}; + +static const u8 rzv2h_cpg_div_table[] =3D { + 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, +}; + +static const struct rzg2l_mipi_dsi_hw_info rzv2h_mipi_dsi_info =3D { + .dphy_init =3D rzv2h_mipi_dsi_dphy_init, + .dphy_startup_late_init =3D rzv2h_mipi_dsi_dphy_startup_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_plldsi.limits =3D rzv2h_plldsi_limits, + .cpg_plldsi.table =3D rzv2h_cpg_div_table, + .cpg_plldsi.table_size =3D ARRAY_SIZE(rzv2h_cpg_div_table), + .phy_reg_offset =3D 0x10000, + .link_reg_offset =3D 0, + .min_dclk =3D 5440, + .max_dclk =3D 187500, + .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, @@ -1066,6 +1513,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 d8082a87d874..2bef20566648 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 GENMASK(2, 0) +#define PLLCLKSET0R_PLL_P GENMASK(13, 8) +#define PLLCLKSET0R_PLL_M GENMASK(25, 16) + +#define PLLCLKSET1R 0x014 +#define PLLCLKSET1R_PLL_K GENMASK(15, 0) + +#define PHYTCLKSETR 0x020 +#define PHYTCLKSETR_TCLKTRAILCTL GENMASK(7, 0) +#define PHYTCLKSETR_TCLKPOSTCTL GENMASK(15, 8) +#define PHYTCLKSETR_TCLKZEROCTL GENMASK(23, 16) +#define PHYTCLKSETR_TCLKPRPRCTL GENMASK(31, 24) + +#define PHYTHSSETR 0x024 +#define PHYTHSSETR_THSEXITCTL GENMASK(7, 0) +#define PHYTHSSETR_THSTRAILCTL GENMASK(15, 8) +#define PHYTHSSETR_THSZEROCTL GENMASK(23, 16) +#define PHYTHSSETR_THSPRPRCTL GENMASK(31, 24) + +#define PHYTLPXSETR 0x028 +#define PHYTLPXSETR_TLPXCTL GENMASK(7, 0) + +#define PHYCR 0x030 +#define PHYCR_ULPSEXIT GENMASK(9, 0) + /* --------------------------------------------------------*/ =20 /* Link Status Register */ @@ -130,6 +163,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.43.0