From nobody Mon Jun 8 05:29:12 2026 Received: from mail-wm1-f49.google.com (mail-wm1-f49.google.com [209.85.128.49]) (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 7A22119E839 for ; Tue, 2 Jun 2026 20:02:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780430576; cv=none; b=Lh6jZYx4z7umGz8bobde1Zdu1bsI38dOOn3Rw5c0XEoBrvuqKGKinvsIQHBpaoi+x969XAeVJcJjwPK53D9Hf4qAXvGkVSYxZDKtOqv/squsYxZ5j3g8Jt67B+gx5EG3PIb2W49hU92PNu52iXi5VybfhPUiK+IiRu75fpKUQkA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780430576; c=relaxed/simple; bh=qEW0v6/nvGzSRZeHfxQ28jq/YZnk3jVcEaK30ab4zfw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=omxZPekUcaN3hAkkY7PllvlWicfKeT2xgmHdwVoi3QZKqeQCrKH72Xqd0EeZh3sgrYeAVFVEJOpTxUQ9USBbC6e01akxCxVNMq3P3jQholcMwQqoAzB6ANL6icEbHxctXrGFc2WByl3sN1e8AIi7bQnhjN4dtsDiZ2l+EHSmzms= 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=Z2k43vIL; arc=none smtp.client-ip=209.85.128.49 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="Z2k43vIL" Received: by mail-wm1-f49.google.com with SMTP id 5b1f17b1804b1-49050ff7cbdso110116295e9.2 for ; Tue, 02 Jun 2026 13:02:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780430573; x=1781035373; 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=61aY7fYlScw5imBfjQjSB/wGV9akxixOSlYRWOMq2rk=; b=Z2k43vILoRjdQr8ydkZg2EdNxOIf+r8Kdm+XR97kpO3NZsxQHwW6VCTNTpwrqaIBcK 9NSyqV//utganKE0P1xgeHiBbnVxeT8gm5c8sXQWuS4PF2uH9V3AWdhtqmxHYNppgS7K qK6nMmD0KgaWPucCZMeefKtqG7XvSv6r9JMxL3faoL6deRJd9qZHDmflv+xjyVQYo0kf q9aDiO8qSC6dkFqXYIKawcvC9WeGZXNXALN1YRQ44lFTbXIeuGHqe4jG7PH6mSdCwtZ4 yh/fYE8AO3qS4QFcBKwTNYr15nU/IxQ8WhCaQ/ykghQajimu6YD+HGzqnCCVb6Lm/lOP FzPw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780430573; x=1781035373; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=61aY7fYlScw5imBfjQjSB/wGV9akxixOSlYRWOMq2rk=; b=P8gwYjOKcgdPtZzIvj0SZRZJs7QD+U1hq7Pc8T0rTRxm/k4PZIxs6TzZySEIMkfRM1 jQQDb5hm8SENIhozgvSeZrt3heO82g0vCGumkY3bZBf1JiNzlom4aJi3T5xp4G8nkYpC 9YMAto50nFli9r+tzrdcmHrJ3/3X0xaAkYMP3pWQx0ye7hdC6GNej8Sw+SB/ku+Rg9rT r9hypjc1DVuKt3rs/gFhth2oh17dZVByN8B668JMAnGofEJmN9EqxmqEUTtAuK3ShfaY FksK+y1BKl/Y4xyIr64SGZWUel24h7vuRJo5BqWye6sCguLp3pE/A/DkWj/JMQFYHCKW w38Q== X-Gm-Message-State: AOJu0YxqdqeRsDoUveGnONSlolSmdfYQe5gKJkZuQn3vSWt/nroVuMsc 8At8JrnBphiE5IbF6AWJLDg38x1y0GD3sIWA0p35H4fvr8ZngijOwyKy X-Gm-Gg: Acq92OH8zkUEaEyq6r15FduH66rW/3MrNZrPDnAOxyiRJdqFbEIqNwLHkJeyjCulxti I1+Mnmn9SLXhZabpheN01pYJUI1CDIzIaYG2sVd45OLwG+uaC2EoFOPfqjeTkElFxIPZrGOPuXU lP/jTYsLDEGfoM7FQ2ZCVXFaYfRBIa/olpbAFlUO+dDSET4XMfuJtIIsqvStPD8rb75fZ96ityV V3llnf1iRnLNqib4m2wfb44KOqp8OOOyzCj0TjBv4srq8k7SaD0K3zrtw2/1xU6MhNYYXzv9AD3 14VS5qtny7eDbCQvFflo/i8Xiiq8O59j3JiIOeOP9moTSiQv27Aq5CR5YHDfJY6i5PvRaJVE9kL kOWtFp0PBDJws3J+Z1Bs21noTJDsl9Yxmaskqys00e9DENm3z72wPeRPZsGQWZW91zAKrmY5fsU bozXETzMlMSzcmOOHcgtLYyg1n88RgV2oQy2MoIquZOpN49Eo2T5uVldcCTdxflJTMSGWzMQ8Qg hooLTUabOGmJ6/hYrETjPvE+CAsvu5kc2LXVWSv5+m4ymJ9t5z5UdtF X-Received: by 2002:a05:600c:470e:b0:485:4388:3492 with SMTP id 5b1f17b1804b1-490b5e73d8cmr5158805e9.11.1780430572956; Tue, 02 Jun 2026 13:02:52 -0700 (PDT) Received: from iku.example.org ([2a06:5906:61b:2d00:5ef:9913:4a77:3bcf]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-490b0e823f7sm97978255e9.13.2026.06.02.13.02.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 02 Jun 2026 13:02:52 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Michael Turquette , Stephen Boyd , Brian Masney , Geert Uytterhoeven Cc: linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Prabhakar , Biju Das , Fabrizio Castro , Lad Prabhakar Subject: [PATCH RESEND v5 1/2] clk: divider: Add KUnit tests for clk_divider_bestdiv() ULONG_MAX handling Date: Tue, 2 Jun 2026 21:02:42 +0100 Message-ID: <20260602200243.1806087-2-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260602200243.1806087-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20260602200243.1806087-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 KUnit tests to verify the behaviour of clk_divider_bestdiv() when clk_round_rate() is called with ULONG_MAX, which is the canonical way to probe the maximum rate a clock can produce. Two test cases are introduced: - clk_divider_bestdiv_ulong_max_returns_max_rate: registers a 1 GHz fixed-rate parent driving a table-based divider whose smallest entry is div=3D2 (entries: 2, 4, 8). Calls clk_hw_round_rate(div_hw, ULONG_MAX) and checks the result. - clk_divider_bestdiv_mux_ulong_max_returns_max_rate: places a two-input mux (4 GHz and 2 GHz fixed-rate parents, CLK_SET_RATE_PARENT) ahead of the same table-based divider to verify correct parent selection under ULONG_MAX. Both tests use an explicit clk_div_table with a minimum divider of 2 so that the pre-loop maxdiv clamping in clk_divider_bestdiv(): maxdiv =3D min(ULONG_MAX / rate, maxdiv); clamps maxdiv to 1, causing _next_div() to return 2 on the first iteration and skip the loop body entirely. This makes bestdiv fall back to the maximum divider, returning the minimum rate rather than the maximum. The expected values intentionally reflect the buggy output: - test 1: PARENT_RATE_1GHZ / 8 (minimum rate, not maximum) - test 2: 0 (invalid, loop never populated bestdiv) These will be corrected to PARENT_RATE_1GHZ / 2 and PARENT_RATE_4GHZ / 2 respectively once the fix to clk_divider_bestdiv() is applied. Signed-off-by: Lad Prabhakar Reviewed-by: Brian Masney --- v4->v5: - Made use of KUNIT_DEFINE_ACTION_WRAPPER(). - Added RB tag v3->v4: - Dropped unregister_fixed_rate/unregister_divider/unregister_mux wrapper - Added entry in .kunitconfig file - Fixed reverse christmas tree order in clk_divider_bestdiv_ulong_max_returns_max_rate - Updated MODULE_DESCRIPTION() to be more specific v2->v3: - Added false positive expected values - Updated the commit message - Added dependency on !S390 in Kconfig --- drivers/clk/.kunitconfig | 1 + drivers/clk/Kconfig | 8 ++ drivers/clk/Makefile | 1 + drivers/clk/clk-divider_test.c | 153 +++++++++++++++++++++++++++++++++ 4 files changed, 163 insertions(+) create mode 100644 drivers/clk/clk-divider_test.c diff --git a/drivers/clk/.kunitconfig b/drivers/clk/.kunitconfig index 8a0ea41934a2..ea05b9a28c80 100644 --- a/drivers/clk/.kunitconfig +++ b/drivers/clk/.kunitconfig @@ -4,6 +4,7 @@ CONFIG_OF=3Dy CONFIG_OF_OVERLAY=3Dy CONFIG_COMMON_CLK=3Dy CONFIG_CLK_KUNIT_TEST=3Dy +CONFIG_CLK_DIVIDER_KUNIT_TEST=3Dy CONFIG_CLK_FIXED_RATE_KUNIT_TEST=3Dy CONFIG_CLK_GATE_KUNIT_TEST=3Dy CONFIG_CLK_FD_KUNIT_TEST=3Dy diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig index 1717ce75a907..3d94c7611356 100644 --- a/drivers/clk/Kconfig +++ b/drivers/clk/Kconfig @@ -579,4 +579,12 @@ config CLK_FD_KUNIT_TEST help Kunit test for the clk-fractional-divider type. =20 +config CLK_DIVIDER_KUNIT_TEST + tristate "KUnit tests for clk divider bestdiv" if !KUNIT_ALL_TESTS + depends on KUNIT + depends on !S390 + default KUNIT_ALL_TESTS + help + Kunit test for the clk-divider type. + endif diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index cc108a75a900..c50d20973f03 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -21,6 +21,7 @@ clk-test-y :=3D clk_test.o \ kunit_clk_hw_get_dev_of_node.dtbo.o \ kunit_clk_parent_data_test.dtbo.o obj-$(CONFIG_COMMON_CLK) +=3D clk-divider.o +obj-$(CONFIG_CLK_DIVIDER_KUNIT_TEST) +=3D clk-divider_test.o obj-$(CONFIG_COMMON_CLK) +=3D clk-fixed-factor.o obj-$(CONFIG_COMMON_CLK) +=3D clk-fixed-rate.o obj-$(CONFIG_CLK_FIXED_RATE_KUNIT_TEST) +=3D clk-fixed-rate-test.o diff --git a/drivers/clk/clk-divider_test.c b/drivers/clk/clk-divider_test.c new file mode 100644 index 000000000000..cb56931456b8 --- /dev/null +++ b/drivers/clk/clk-divider_test.c @@ -0,0 +1,153 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit tests for clk_divider_bestdiv() + */ +#include +#include +#include +#include +#include + +#define PARENT_RATE_1GHZ GIGA +#define PARENT_RATE_2GHZ (2 * GIGA) +#define PARENT_RATE_4GHZ (4 * GIGA) + +KUNIT_DEFINE_ACTION_WRAPPER(clk_hw_unregister_fixed_rate_wrapper, + clk_hw_unregister_fixed_rate, struct clk_hw *); +KUNIT_DEFINE_ACTION_WRAPPER(clk_hw_unregister_divider_wrapper, + clk_hw_unregister_divider, struct clk_hw *); +KUNIT_DEFINE_ACTION_WRAPPER(clk_hw_unregister_mux_wrapper, + clk_hw_unregister_mux, struct clk_hw *); + +static const struct clk_div_table bestdiv_table[] =3D { + { .val =3D 0, .div =3D 2 }, + { .val =3D 1, .div =3D 4 }, + { .val =3D 2, .div =3D 8 }, + { /* sentinel */ } +}; + +/* + * Test that clk_round_rate(clk, ULONG_MAX) returns the maximum achievable + * rate for a divider clock. + */ +static void clk_divider_bestdiv_ulong_max_returns_max_rate(struct kunit *t= est) +{ + struct clk_hw *parent_hw, *div_hw; + unsigned long rate; + u32 *fake_reg; + + fake_reg =3D kunit_kzalloc(test, sizeof(*fake_reg), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fake_reg); + + parent_hw =3D clk_hw_register_fixed_rate(NULL, "bestdiv-parent", + NULL, 0, PARENT_RATE_1GHZ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_fixed_rate_wrapper, + parent_hw)); + + div_hw =3D clk_hw_register_divider_table(NULL, "bestdiv-div", + "bestdiv-parent", + CLK_SET_RATE_PARENT, + (void __iomem __force *)fake_reg, + 0, 2, 0, bestdiv_table, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, div_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_divider_wrapper, + div_hw)); + + /* + * ULONG_MAX is the canonical way to probe the maximum rate a clock + * can produce. + */ + rate =3D clk_hw_round_rate(div_hw, ULONG_MAX); + KUNIT_EXPECT_EQ(test, rate, PARENT_RATE_1GHZ / 8); +} + +/* + * Test that clk_round_rate(clk, ULONG_MAX) returns the correct maximum ra= te + * when a mux clock sits between a divider and its parent candidates. + * + * Topology: + * + * [fixed 4 GHz] --\ + * +--> [mux CLK_SET_RATE_PARENT] --> [div {2,4,8} CLK_= SET_RATE_PARENT] + * [fixed 2 GHz] --/ + * + */ +static void clk_divider_bestdiv_mux_ulong_max_returns_max_rate(struct kuni= t *test) +{ + static const char * const mux_parents[] =3D { + "bestdiv-mux-parent-a", + "bestdiv-mux-parent-b", + }; + struct clk_hw *parent_a_hw, *parent_b_hw, *mux_hw, *div_hw; + u32 *fake_reg_mux, *fake_reg_div; + unsigned long rate; + + fake_reg_mux =3D kunit_kzalloc(test, sizeof(*fake_reg_mux), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fake_reg_mux); + + fake_reg_div =3D kunit_kzalloc(test, sizeof(*fake_reg_div), GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fake_reg_div); + + /* Higher-rate parent: the mux should select this for ULONG_MAX. */ + parent_a_hw =3D clk_hw_register_fixed_rate(NULL, "bestdiv-mux-parent-a", + NULL, 0, PARENT_RATE_4GHZ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_a_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_fixed_rate_wrapper, + parent_a_hw)); + + /* Lower-rate parent: should not be selected. */ + parent_b_hw =3D clk_hw_register_fixed_rate(NULL, "bestdiv-mux-parent-b", + NULL, 0, PARENT_RATE_2GHZ); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_b_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_fixed_rate_wrapper, + parent_b_hw)); + + /* + * 1-bit mux register selects between the two parents. + * CLK_SET_RATE_PARENT allows the divider's rate request to + * propagate into clk_mux_determine_rate(). + */ + mux_hw =3D clk_hw_register_mux(NULL, "bestdiv-mux", + mux_parents, ARRAY_SIZE(mux_parents), + CLK_SET_RATE_PARENT, + (void __iomem __force *)fake_reg_mux, + 0, 1, 0, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mux_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_mux_wrapper, + mux_hw)); + + div_hw =3D clk_hw_register_divider_table(NULL, "bestdiv-mux-div", + "bestdiv-mux", + CLK_SET_RATE_PARENT, + (void __iomem __force *)fake_reg_div, + 0, 2, 0, bestdiv_table, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, div_hw); + KUNIT_ASSERT_EQ(test, 0, + kunit_add_action_or_reset(test, clk_hw_unregister_divider_wrapper, + div_hw)); + + rate =3D clk_hw_round_rate(div_hw, ULONG_MAX); + KUNIT_EXPECT_EQ(test, rate, 0); +} + +static struct kunit_case clk_divider_bestdiv_test_cases[] =3D { + KUNIT_CASE(clk_divider_bestdiv_ulong_max_returns_max_rate), + KUNIT_CASE(clk_divider_bestdiv_mux_ulong_max_returns_max_rate), + {} +}; + +static struct kunit_suite clk_divider_bestdiv_test_suite =3D { + .name =3D "clk_divider_bestdiv", + .test_cases =3D clk_divider_bestdiv_test_cases, +}; + +kunit_test_suite(clk_divider_bestdiv_test_suite); + +MODULE_DESCRIPTION("KUnit tests for clk divider"); +MODULE_LICENSE("GPL"); --=20 2.54.0 From nobody Mon Jun 8 05:29:12 2026 Received: from mail-wm1-f41.google.com (mail-wm1-f41.google.com [209.85.128.41]) (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 9BF1431CA4A for ; Tue, 2 Jun 2026 20:02:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780430577; cv=none; b=F+1mULpxYJvhsV49GDJxH3xfDbPzR4Vb7PKnyOQc9LDrYdalsH6W2X6wkMfbddsCbLsPG5YIJI5UyaQN13hUMqJQG0vAyZE0/EBByAXQj7y8C0vEkcn7KObBjHwAny4ljScE/T4tv2adarffTbl95UhxpFPP3xmFZwXEZaf85kE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780430577; c=relaxed/simple; bh=Jfa5R8Hcp8fV8pBHclVi+5b8yBOKxWDa2CZqqB9gSbs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=q7la8WcFkmh9NDWNaogVNSl/paKoA/cyS3x6Jt9534+hmlnOH7CCkr2FF8llH+UbMiR+apgWCg+ks6m2Kz6WHBtlLCSDJrFsGJG/epB9LP5S0+Vq13OfY2QxWnMGtJ9EhEj3jaFIVhidawgt1Cnb9L7nK4kBAO0GCiCJpSmUyBw= 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=dNJdMGhZ; arc=none smtp.client-ip=209.85.128.41 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="dNJdMGhZ" Received: by mail-wm1-f41.google.com with SMTP id 5b1f17b1804b1-4908b92904fso66067715e9.0 for ; Tue, 02 Jun 2026 13:02:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780430574; x=1781035374; 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=VlPgG6RjNCKxvEpnrQ9KQhAPgcHAQDrzTyIKfeGNbKM=; b=dNJdMGhZRE6KpZlfNHwne8yFGnKbG2URukkI5ztwPyeEE9hDkqSkLJW55DY5CseP65 BaNCliD27bQkspCTd+mpKZ+aiCLX6RiEosFJBx3ZXPIh6qbgHzeALPhPdDP7tr726GOs zzLJmERVSZroh1hVKfW0r3/HlNUXKcfplQGNB4G5K7l+8YCuON+m7UaPR02QmeIFG3xT +Vrkcz9JoFDDhR8qmOk223/diDca15AXCKf83XYwBNS4Sqrj9zvjVNP2K/5LdiMAFYj0 Z+k9F+AuBxAJZfM7C1KZqhtYNz/HERSckuEa7oFxms8/3KRvvIdkZZfMJ+/FhDlOGaq+ y18g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780430574; x=1781035374; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=VlPgG6RjNCKxvEpnrQ9KQhAPgcHAQDrzTyIKfeGNbKM=; b=nstYDMu+A+rPl2y6xdy8t5MnBTMMfH2QoIuh4JshW+ALXzRLXBcbf1pDB8hE/0+nAN 2MMDAH47TSyclZqspBiwQdAV32Ej7lNGSrkvbM4jm8bpklWePtdcHvOcngSRtjT+JkxS +HC3hLCMcGZk8CPyznqJf89Uvsm4wTcc4Dq3UdT/snpPjbLkx7AZAzGiv2itPcaGACqO BFnIF6LIvtY4dAFRSjtJxDM9MOR0XOoCmDMxfHQPhUZCimns91zqS/QEEeaXSnEGolk2 wqhgsvK+g/geM28P5iWCJUVffnKSbmpZSH6gkRkBNK3cXfdjhCvzsKXBMOOXov/7ncT3 OVGg== X-Gm-Message-State: AOJu0YwVtdA/IXf7r2E3NbAYaJOkza6qa2jgcSQEtUvwJVbTn8TQPWjZ qkDpcvtsPtwbGHdeYuBUtz8UlWNQT0GU2ROpfxyCMBSSifF8ueVM6jXc X-Gm-Gg: Acq92OE8ubb3jeQLAh+YGDTbn0YQMWU8LIQCYr4wXD0zz5ykjQmXdWS6E94HeAMiiPm j7xrKLV8jA6yYLUhIoJeViUp1Qxp6H+BuG3fsAc3kX52PXqNy+9fNdmZtTMG+CEZA6lbHqmRhqL n9E+gL3c+owYvxnIE8YOWaxnGzUF4qafYwFD2m5lXSMqcPiPW0KGKB12tHfUJc1yRQM0dx+0L8K +kSFoHoMm+1hwUgSPw/2J/61KbL3Uvd6w9/xAPNkbruy7O0J/FH6UO2gRWc8jGbN2Q4XVbO8U6q yJfciv+v5/1S+FoenvndIZsIJaMzv1I46lEScz6KtNQpIxEEzx62cWA1lw7EF3G4IJCN6jk1o3M OeHONX3oOLLg/maJZ0TS1moPq3vWFKGB6cZMAbgvGXs2iTib6VVbleo2Y99DYQ3DGI+T8isAtCJ uzS9ttxFB0ZqFlSY48SgP19NIqpkPP16CiWd14lvW8Ivk5qX1/CVqAjb0Sj9WaWYPQE9xCv9Joo C5U3RCSauaybNDYDD4jjEXXj9SaM/0T2g20D70lrK9snJ4HhLlfgGzO X-Received: by 2002:a05:600c:4e87:b0:490:7dfd:f7c2 with SMTP id 5b1f17b1804b1-490b5ecfe9amr4818515e9.11.1780430573733; Tue, 02 Jun 2026 13:02:53 -0700 (PDT) Received: from iku.example.org ([2a06:5906:61b:2d00:5ef:9913:4a77:3bcf]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-490b0e823f7sm97978255e9.13.2026.06.02.13.02.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 02 Jun 2026 13:02:53 -0700 (PDT) From: Prabhakar X-Google-Original-From: Prabhakar To: Michael Turquette , Stephen Boyd , Brian Masney , Geert Uytterhoeven Cc: linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Prabhakar , Biju Das , Fabrizio Castro , Lad Prabhakar Subject: [PATCH RESEND v5 2/2] clk: divider: Fix clk_divider_bestdiv() returning min rate for large rate requests Date: Tue, 2 Jun 2026 21:02:43 +0100 Message-ID: <20260602200243.1806087-3-prabhakar.mahadev-lad.rj@bp.renesas.com> X-Mailer: git-send-email 2.54.0 In-Reply-To: <20260602200243.1806087-1-prabhakar.mahadev-lad.rj@bp.renesas.com> References: <20260602200243.1806087-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 clk_divider_bestdiv() clamps maxdiv using: maxdiv =3D min(ULONG_MAX / rate, maxdiv); to avoid overflow in rate * i. However, requests like clk_round_rate(clk, ULONG_MAX), which are used to determine the maximum supported rate of a clock, result in maxdiv being clamped to 1. If no valid divider of 1 exists in the table the loop is never entered and bestdiv falls back to the maximum divider with the minimum parent rate, causing clk_round_rate(clk, ULONG_MAX) to incorrectly return the minimum supported rate instead of the maximum. Fix this by removing the pre-loop maxdiv clamping and replacing the unprotected rate * i multiplication with check_mul_overflow(). Guard the exact-match short-circuit with !overflow to prevent a clamped target_parent_rate of ULONG_MAX from falsely matching parent_rate_saved and causing premature loop exit. Break out of the loop after evaluating the first overflowing divider since clk_hw_round_rate(parent, ULONG_MAX) returns a constant for all subsequent iterations, meaning no better candidate can be found, and continuing would cause exponential recursive calls in chained divider clocks. Update the KUnit test expected values to reflect the corrected behaviour: - clk_divider_bestdiv_ulong_max_returns_max_rate: PARENT_RATE_1GHZ / 8 (minimum rate, pre-fix) -> PARENT_RATE_1GHZ / 2 (maximum rate) - clk_divider_bestdiv_mux_ulong_max_returns_max_rate: 0 (invalid, pre-fix) -> PARENT_RATE_4GHZ / 2 (maximum rate with mux selecting the 4 GHz parent and applying the smallest table divider of 2) Signed-off-by: Lad Prabhakar Reviewed-by: Brian Masney --- v4->v5: - No change v3->v4: - No change v2->v3: - Added Rb tag - Added the expected value for the tests - updated the commit message --- drivers/clk/clk-divider.c | 25 +++++++++++++++++-------- drivers/clk/clk-divider_test.c | 4 ++-- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/drivers/clk/clk-divider.c b/drivers/clk/clk-divider.c index b3b485d23ea8..f68216c65d3d 100644 --- a/drivers/clk/clk-divider.c +++ b/drivers/clk/clk-divider.c @@ -15,6 +15,7 @@ #include #include #include +#include =20 /* * DOC: basic adjustable divider clock that cannot gate @@ -301,6 +302,7 @@ static int clk_divider_bestdiv(struct clk_hw *hw, struc= t clk_hw *parent, int i, bestdiv =3D 0; unsigned long parent_rate, best =3D 0, now, maxdiv; unsigned long parent_rate_saved =3D *best_parent_rate; + unsigned long target_parent_rate; =20 if (!rate) rate =3D 1; @@ -315,15 +317,11 @@ static int clk_divider_bestdiv(struct clk_hw *hw, str= uct clk_hw *parent, return bestdiv; } =20 - /* - * The maximum divider we can use without overflowing - * unsigned long in rate * i below - */ - maxdiv =3D min(ULONG_MAX / rate, maxdiv); - for (i =3D _next_div(table, 0, flags); i <=3D maxdiv; i =3D _next_div(table, i, flags)) { - if (rate * i =3D=3D parent_rate_saved) { + bool overflow =3D check_mul_overflow(rate, (unsigned long)i, &target_par= ent_rate); + + if (!overflow && target_parent_rate =3D=3D parent_rate_saved) { /* * It's the most ideal case if the requested rate can be * divided from parent clock without needing to change @@ -332,13 +330,24 @@ static int clk_divider_bestdiv(struct clk_hw *hw, str= uct clk_hw *parent, *best_parent_rate =3D parent_rate_saved; return i; } - parent_rate =3D clk_hw_round_rate(parent, rate * i); + /* + * Clamp target_parent_rate to ULONG_MAX on overflow. The true + * required parent rate exceeds what can be represented, so ask + * the parent for the highest rate it can produce. There is no + * point continuing the loop past this since larger dividers + * only move further from the requested rate. + */ + if (overflow) + target_parent_rate =3D ULONG_MAX; + parent_rate =3D clk_hw_round_rate(parent, target_parent_rate); now =3D DIV_ROUND_UP_ULL((u64)parent_rate, i); if (_is_best_div(rate, now, best, flags)) { bestdiv =3D i; best =3D now; *best_parent_rate =3D parent_rate; } + if (overflow) + break; } =20 if (!bestdiv) { diff --git a/drivers/clk/clk-divider_test.c b/drivers/clk/clk-divider_test.c index cb56931456b8..8ee1614128d0 100644 --- a/drivers/clk/clk-divider_test.c +++ b/drivers/clk/clk-divider_test.c @@ -61,7 +61,7 @@ static void clk_divider_bestdiv_ulong_max_returns_max_rat= e(struct kunit *test) * can produce. */ rate =3D clk_hw_round_rate(div_hw, ULONG_MAX); - KUNIT_EXPECT_EQ(test, rate, PARENT_RATE_1GHZ / 8); + KUNIT_EXPECT_EQ(test, rate, PARENT_RATE_1GHZ / 2); } =20 /* @@ -133,7 +133,7 @@ static void clk_divider_bestdiv_mux_ulong_max_returns_m= ax_rate(struct kunit *tes div_hw)); =20 rate =3D clk_hw_round_rate(div_hw, ULONG_MAX); - KUNIT_EXPECT_EQ(test, rate, 0); + KUNIT_EXPECT_EQ(test, rate, PARENT_RATE_4GHZ / 2); } =20 static struct kunit_case clk_divider_bestdiv_test_cases[] =3D { --=20 2.54.0