From patchwork Thu Mar 2 01:38:17 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stephen Boyd X-Patchwork-Id: 13156629 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 38FC3C678D4 for ; Thu, 2 Mar 2023 01:38:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229750AbjCBBin (ORCPT ); Wed, 1 Mar 2023 20:38:43 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40440 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229471AbjCBBif (ORCPT ); Wed, 1 Mar 2023 20:38:35 -0500 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4506512BD7; Wed, 1 Mar 2023 17:38:28 -0800 (PST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 9D6876153E; Thu, 2 Mar 2023 01:38:27 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 625B0C433D2; Thu, 2 Mar 2023 01:38:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1677721107; bh=fvPrCAyBkgnxgijN1lTuag/4in6rKiEGnEPO+gbwEs4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=i8zopeNC1in3w5XGUJKY/LXKlzK5BRSdMPry4rWNbnjNE84GWR1xF+RINEeejLejd gKJpd8LdNs0TePE9fGcx70fY9XJ9a1rnTqoXELutE5T7dWUUu0TvXclZsGcJKLA9Ta TnaxwHXeO/1BPtBl6s09cfKsPnLL8/Qxj6LP+ZweOmzZPczLC4+iFKN4d6MB6t2ebM XlyovDX82U6lPSCyKUlkFXAD6OHJcEi7K4N64x81/QZvn8Jn0WIlq4kosMjwoNMe3M OV9ydVXq2h7mGhu/mlZ4GkHAYKEQSp5u/n9pe41izH+Ewj/iiX9TOcCMlYBIWrIxyC X6lYxry87mTrw== From: Stephen Boyd To: Michael Turquette , Stephen Boyd Cc: linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org, patches@lists.linux.dev, Brendan Higgins , David Gow , Greg Kroah-Hartman , "Rafael J . Wysocki" , Richard Weinberger , Anton Ivanov , Johannes Berg , Vincent Whitchurch , Rob Herring , Frank Rowand , Christian Marangi , Krzysztof Kozlowski , devicetree@vger.kernel.org, linux-um@lists.infradead.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com Subject: [PATCH 4/8] clk: Add test managed clk provider/consumer APIs Date: Wed, 1 Mar 2023 17:38:17 -0800 Message-Id: <20230302013822.1808711-5-sboyd@kernel.org> X-Mailer: git-send-email 2.39.2.722.g9855ee24e9-goog In-Reply-To: <20230302013822.1808711-1-sboyd@kernel.org> References: <20230302013822.1808711-1-sboyd@kernel.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kselftest@vger.kernel.org Unit tests are more ergonomic and simpler to understand if they don't have to hoist a bunch of code into the test harness init and exit functions. Add some test managed wrappers for the clk APIs so that clk unit tests can write more code in the actual test and less code in the harness. Only add APIs that are used for now. More wrappers can be added in the future as necessary. Cc: Brendan Higgins Cc: David Gow Signed-off-by: Stephen Boyd --- drivers/clk/Makefile | 5 + drivers/clk/clk-kunit.c | 204 ++++++++++++++++++++++++++++++++++++++++ drivers/clk/clk-kunit.h | 28 ++++++ 3 files changed, 237 insertions(+) create mode 100644 drivers/clk/clk-kunit.c create mode 100644 drivers/clk/clk-kunit.h diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile index e3ca0d058a25..7efce649b0d3 100644 --- a/drivers/clk/Makefile +++ b/drivers/clk/Makefile @@ -17,6 +17,11 @@ ifeq ($(CONFIG_OF), y) obj-$(CONFIG_COMMON_CLK) += clk-conf.o endif +# KUnit specific helpers +ifeq ($(CONFIG_COMMON_CLK), y) +obj-$(CONFIG_KUNIT) += clk-kunit.o +endif + # hardware specific clock types # please keep this section sorted lexicographically by file path name obj-$(CONFIG_COMMON_CLK_APPLE_NCO) += clk-apple-nco.o diff --git a/drivers/clk/clk-kunit.c b/drivers/clk/clk-kunit.c new file mode 100644 index 000000000000..78d85b3a7a4a --- /dev/null +++ b/drivers/clk/clk-kunit.c @@ -0,0 +1,204 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit helpers for clk tests + */ +#include +#include +#include +#include +#include + +#include + +#include "clk-kunit.h" + +static void kunit_clk_disable_unprepare(struct kunit_resource *res) +{ + struct clk *clk = res->data; + + clk_disable_unprepare(clk); +} + +/** + * kunit_clk_prepare_enable() - Test managed clk_prepare_enable() + * @test: The test context + * @clk: clk to prepare and enable + * + * Returns: 0 on success, or negative errno on failure. + */ +int kunit_clk_prepare_enable(struct kunit *test, struct clk *clk) +{ + if (!kunit_alloc_resource(test, NULL, kunit_clk_disable_unprepare, + GFP_KERNEL, clk)) + return -EINVAL; + + return clk_prepare_enable(clk); +} +EXPORT_SYMBOL_GPL(kunit_clk_prepare_enable); + +static void kunit_clk_put(struct kunit_resource *res) +{ + struct clk *clk = res->data; + + clk_put(clk); +} + +/** + * kunit_clk_get() - Test managed clk_get() + * @test: The test context + * @dev: device for clock "consumer" + * @id: clock consumer ID + * + * Returns: new clk consumer or ERR_PTR on failure + */ +struct clk * +kunit_clk_get(struct kunit *test, struct device *dev, const char *con_id) +{ + struct clk *clk; + + clk = clk_get(dev, con_id); + if (IS_ERR(clk)) + return clk; + + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { + clk_put(clk); + return ERR_PTR(-EINVAL); + } + + return clk; +} +EXPORT_SYMBOL_GPL(kunit_clk_get); + +/** + * kunit_of_clk_get() - Test managed of_clk_get() + * @test: The test context + * @np: device_node for clock "consumer" + * @index: index in 'clocks' property of @np + * + * Returns: new clk consumer or ERR_PTR on failure + */ +struct clk * +kunit_of_clk_get(struct kunit *test, struct device_node *np, int index) +{ + struct clk *clk; + + clk = of_clk_get(np, index); + if (IS_ERR(clk)) + return clk; + + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { + clk_put(clk); + return ERR_PTR(-EINVAL); + } + + return clk; +} +EXPORT_SYMBOL_GPL(kunit_of_clk_get); + +/** + * kunit_clk_hw_get_clk() - Test managed clk_hw_get_clk() + * @test: The test context + * @hw: clk_hw associated with the clk being consumed + * @con_id: connection ID string on device + * + * Returns: new clk consumer or ERR_PTR on failure + */ +struct clk * +kunit_clk_hw_get_clk(struct kunit *test, struct clk_hw *hw, const char *con_id) +{ + struct clk *clk; + + clk = clk_hw_get_clk(hw, con_id); + if (IS_ERR(clk)) + return clk; + + if (!kunit_alloc_resource(test, NULL, kunit_clk_put, GFP_KERNEL, clk)) { + clk_put(clk); + return ERR_PTR(-EINVAL); + } + + return clk; +} +EXPORT_SYMBOL_GPL(kunit_clk_hw_get_clk); + +/** + * kunit_clk_hw_get_clk_prepared_enabled() - Test managed clk_hw_get_clk() + clk_prepare_enable() + * @test: The test context + * @hw: clk_hw associated with the clk being consumed + * @con_id: connection ID string on device + * + * Returns: new clk consumer that is prepared and enabled or ERR_PTR on failure + */ +struct clk * +kunit_clk_hw_get_clk_prepared_enabled(struct kunit *test, struct clk_hw *hw, + const char *con_id) +{ + int ret; + struct clk *clk; + + clk = kunit_clk_hw_get_clk(test, hw, con_id); + if (IS_ERR(clk)) + return clk; + + ret = kunit_clk_prepare_enable(test, clk); + if (ret) + return ERR_PTR(ret); + + return clk; +} +EXPORT_SYMBOL_GPL(kunit_clk_hw_get_clk_prepared_enabled); + +static void kunit_clk_hw_unregister(struct kunit_resource *res) +{ + struct clk_hw *hw = res->data; + + clk_hw_unregister(hw); +} + +/** + * kunit_clk_hw_register() - Test managed clk_hw_register() + * @test: The test context + * @dev: device that is registering this clock + * @hw: link to hardware-specific clock data + * + * Returns: 0 on success or a negative errno value on failure + */ +int kunit_clk_hw_register(struct kunit *test, struct device *dev, struct clk_hw *hw) +{ + int ret; + + ret = clk_hw_register(dev, hw); + if (ret) + return ret; + + if (!kunit_alloc_resource(test, NULL, kunit_clk_hw_unregister, GFP_KERNEL, hw)) { + clk_hw_unregister(hw); + return -EINVAL; + } + + return 0; +} + +/** + * kunit_of_clk_hw_register() - Test managed of_clk_hw_register() + * @test: The test context + * @node: device_node of device that is registering this clock + * @hw: link to hardware-specific clock data + * + * Returns: 0 on success or a negative errno value on failure + */ +int kunit_of_clk_hw_register(struct kunit *test, struct device_node *node, struct clk_hw *hw) +{ + int ret; + + ret = of_clk_hw_register(node, hw); + if (ret) + return ret; + + if (!kunit_alloc_resource(test, NULL, kunit_clk_hw_unregister, GFP_KERNEL, hw)) { + clk_hw_unregister(hw); + return -EINVAL; + } + + return 0; +} diff --git a/drivers/clk/clk-kunit.h b/drivers/clk/clk-kunit.h new file mode 100644 index 000000000000..153597d69269 --- /dev/null +++ b/drivers/clk/clk-kunit.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _CLK_KUNIT_H +#define _CLK_KUNIT_H + +struct clk; +struct clk_hw; +struct device; +struct device_node; +struct kunit; + +struct clk * +kunit_clk_get(struct kunit *test, struct device *dev, const char *con_id); +struct clk * +kunit_of_clk_get(struct kunit *test, struct device_node *np, int index); + +struct clk * +kunit_clk_hw_get_clk(struct kunit *test, struct clk_hw *hw, const char *con_id); +struct clk * +kunit_clk_hw_get_clk_prepared_enabled(struct kunit *test, struct clk_hw *hw, + const char *con_id); + +int kunit_clk_prepare_enable(struct kunit *test, struct clk *clk); + +int kunit_clk_hw_register(struct kunit *test, struct device *dev, struct clk_hw *hw); +int kunit_of_clk_hw_register(struct kunit *test, struct device_node *node, + struct clk_hw *hw); + +#endif