From patchwork Tue Apr 3 09:44:18 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894490 X-Patchwork-Delegate: trini@ti.com Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=lists.denx.de (client-ip=81.169.180.215; helo=lists.denx.de; envelope-from=u-boot-bounces@lists.denx.de; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=baylibre-com.20150623.gappssmtp.com header.i=@baylibre-com.20150623.gappssmtp.com header.b="HFfSiJZG"; dkim-atps=neutral Received: from lists.denx.de (dione.denx.de [81.169.180.215]) by ozlabs.org (Postfix) with ESMTP id 40Fkk646cFz9s1p for ; Tue, 3 Apr 2018 19:46:05 +1000 (AEST) Received: by lists.denx.de (Postfix, from userid 105) id 3D082C21DFA; Tue, 3 Apr 2018 09:44:43 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on lists.denx.de X-Spam-Level: X-Spam-Status: No, score=0.0 required=5.0 tests=RCVD_IN_MSPIKE_H2, T_DKIM_INVALID autolearn=unavailable autolearn_force=no version=3.4.0 Received: from lists.denx.de (localhost [IPv6:::1]) by lists.denx.de (Postfix) with ESMTP id C1B44C21E39; Tue, 3 Apr 2018 09:44:26 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id 873AAC21EC2; Tue, 3 Apr 2018 09:44:24 +0000 (UTC) Received: from mail-wr0-f196.google.com (mail-wr0-f196.google.com [209.85.128.196]) by lists.denx.de (Postfix) with ESMTPS id 7D313C21C50 for ; Tue, 3 Apr 2018 09:44:23 +0000 (UTC) Received: by mail-wr0-f196.google.com with SMTP id d17so2549453wre.1 for ; Tue, 03 Apr 2018 02:44:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=qQMYIUk5WWmwJic7Er04/VpYVJfJ7mVR3AweEjjKe8Y=; b=HFfSiJZGvuIR0MUoSGRQ/5qv3UYFAImRDzUZ0F+ivPAbt851CESl36wMSWi4g85Srg h8BXue5hQLtqtWb6OaQ5TL+7ikjbUcJeLOD3dvJq90TUHuUVqfhBt1lTdhvkvH2zucBS 58QEu3cOJb4+ZPoz+jViKxC7KnddObmcL5VUbBZ8FCRhyjroOcI3zifo0BjMJmgRbBNN woZ0Zia2dUBt/0P/U9TuvZp+URUdi94XeiHIQTlXc6ZKhaaRs5cHvQwum59e+qATq1A3 bUFN1GIFAD71/2A6wQ03HZ/IiCyALNOU8FzBe4jZX6adKE1+uSKY6vveHgS+bHQvJRgP 4HdA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=qQMYIUk5WWmwJic7Er04/VpYVJfJ7mVR3AweEjjKe8Y=; b=LZRtJc9QKtnzo1Zm1TddSzU0ckTFToU7rBi/BN3AYcdYpTOzpcu35bfe9/D75YuxX+ 6H28UOo9fovAWQogA2D/9Ie5wpP7eNm+pRaagLzCQHnljoeHY+aawiPycfOJ2RsFT7mK 9cTlqodLWkADAvZ6LTdbLEr2e8TL74o9pu1fAT/SebQhvl+G31gFM4epBrkIhRIsSdfN B4Uz1JjeyChGtTepCMriA3rW0+YtBF7tHs+DP+Wn6OD4uwJcss+VsyzRsoJqGMREg78v fas8CDoze/cOruKy2Ze2IwRIVosSFFYgdK6NGC5vrstYJ8CQrf3VRBxeIn8ANftZnGXy 2OKg== X-Gm-Message-State: AElRT7HMuXOpl66B7GORjHYS040yp6l9PMBaj3a8z5xG8J4STBr7hJqR 1Fa1J4M2lXRzVNUxf9hsPkkp0g== X-Google-Smtp-Source: AIpwx48lxUHE2EJX1gQV5QNf58uAqWTVdMP+SoPRLJuG9JA8GbKvt93tjCeW+pX8Z1MtaL6loOsWdQ== X-Received: by 10.223.128.98 with SMTP id 89mr9100562wrk.141.1522748662957; Tue, 03 Apr 2018 02:44:22 -0700 (PDT) Received: from bender.baylibre.local ([90.63.244.31]) by smtp.gmail.com with ESMTPSA id q21sm1513565wra.24.2018.04.03.02.44.21 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 03 Apr 2018 02:44:22 -0700 (PDT) From: Neil Armstrong To: sjg@chromium.org, u-boot@lists.denx.de Date: Tue, 3 Apr 2018 11:44:18 +0200 Message-Id: <1522748659-21622-2-git-send-email-narmstrong@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522748659-21622-1-git-send-email-narmstrong@baylibre.com> References: <1522748659-21622-1-git-send-email-narmstrong@baylibre.com> Cc: marex@denx.de, linux-amlogic@lists.infradead.org Subject: [U-Boot] [PATCH v2 u-boot 1/2] clk: Add get/enable/disable/release for a bulk of clocks X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.18 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" This patch adds a "bulk" API to the clock API in order to get/enable/disable /release a group of clocks associated with a device. This bulk API will avoid adding a copy of the same code to manage a group of clocks in drivers. Signed-off-by: Neil Armstrong Reviewed-by: Simon Glass --- drivers/clk/clk-uclass.c | 59 +++++++++++++++++++++++++++++++++++++++ include/clk.h | 72 +++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 130 insertions(+), 1 deletion(-) diff --git a/drivers/clk/clk-uclass.c b/drivers/clk/clk-uclass.c index ad76379..6e99b3b 100644 --- a/drivers/clk/clk-uclass.c +++ b/drivers/clk/clk-uclass.c @@ -104,6 +104,39 @@ int clk_get_by_index(struct udevice *dev, int index, struct clk *clk) return clk_get_by_indexed_prop(dev, "clocks", index, clk); } +int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk) +{ + int i, ret, err, count; + + bulk->count = 0; + + count = dev_count_phandle_with_args(dev, "clocks", "#clock-cells"); + if (!count) + return 0; + + bulk->clks = devm_kcalloc(dev, count, sizeof(struct clk), GFP_KERNEL); + if (!bulk->clks) + return -ENOMEM; + + for (i = 0; i < count; i++) { + ret = clk_get_by_index(dev, i, &bulk->clks[i]); + if (ret < 0) + goto bulk_get_err; + + ++bulk->count; + } + + return 0; + +bulk_get_err: + err = clk_release_all(bulk->clks, bulk->count); + if (err) + debug("%s: could release all clocks for %p\n", + __func__, dev); + + return ret; +} + static int clk_set_default_parents(struct udevice *dev) { struct clk clk, parent_clk; @@ -336,6 +369,19 @@ int clk_enable(struct clk *clk) return ops->enable(clk); } +int clk_enable_bulk(struct clk_bulk *bulk) +{ + int i, ret; + + for (i = 0; i < bulk->count; i++) { + ret = clk_enable(&bulk->clks[i]); + if (ret < 0 && ret != -ENOSYS) + return ret; + } + + return 0; +} + int clk_disable(struct clk *clk) { const struct clk_ops *ops = clk_dev_ops(clk->dev); @@ -348,6 +394,19 @@ int clk_disable(struct clk *clk) return ops->disable(clk); } +int clk_disable_bulk(struct clk_bulk *bulk) +{ + int i, ret; + + for (i = 0; i < bulk->count; i++) { + ret = clk_disable(&bulk->clks[i]); + if (ret < 0 && ret != -ENOSYS) + return ret; + } + + return 0; +} + UCLASS_DRIVER(clk) = { .id = UCLASS_CLK, .name = "clk", diff --git a/include/clk.h b/include/clk.h index a7d95d3..b3a9fce 100644 --- a/include/clk.h +++ b/include/clk.h @@ -60,6 +60,23 @@ struct clk { unsigned long id; }; +/** + * struct clk_bulk - A handle to (allowing control of) a bulk of clocks. + * + * Clients provide storage for the clock bulk. The content of the structure is + * managed solely by the clock API. A clock bulk struct is + * initialized by "get"ing the clock bulk struct. + * The clock bulk struct is passed to all other bulk clock APIs to apply + * the API to all the clock in the bulk struct. + * + * @clks: An array of clock handles. + * @count: The number of clock handles in the clks array. + */ +struct clk_bulk { + struct clk *clks; + unsigned int count; +}; + #if CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(CLK) struct phandle_1_arg; int clk_get_by_index_platdata(struct udevice *dev, int index, @@ -83,6 +100,21 @@ int clk_get_by_index_platdata(struct udevice *dev, int index, int clk_get_by_index(struct udevice *dev, int index, struct clk *clk); /** + * clock_get_bulk - Get/request all clocks of a device. + * + * This looks up and requests all clocks of the client device; each device is + * assumed to have n clocks associated with it somehow, and this function finds + * and requests all of them in a separate structure. The mapping of client + * device clock indices to provider clocks may be via device-tree properties, + * board-provided mapping tables, or some other mechanism. + * + * @dev: The client device. + * @bulk A pointer to a clock bulk struct to initialize. + * @return 0 if OK, or a negative error code. + */ +int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk); + +/** * clock_get_by_name - Get/request a clock by name. * * This looks up and requests a clock. The name is relative to the client @@ -120,6 +152,11 @@ static inline int clk_get_by_index(struct udevice *dev, int index, return -ENOSYS; } +static inline int clk_get_bulk(struct udevice *dev, struct clk_bulk *bulk) +{ + return -ENOSYS; +} + static inline int clk_get_by_name(struct udevice *dev, const char *name, struct clk *clk) { @@ -130,7 +167,6 @@ static inline int clk_release_all(struct clk *clk, int count) { return -ENOSYS; } - #endif #if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) && \ @@ -151,6 +187,22 @@ static inline int clk_set_defaults(struct udevice *dev) #endif /** + * clk_release_bulk() - Disable (turn off)/Free an array of previously + * requested clocks in a clock bulk struct. + * + * For each clock contained in the clock bulk struct, this function will check + * if clock has been previously requested and then will disable and free it. + * + * @clk: A clock bulk struct that was previously successfully + * requested by clk_get_bulk(). + * @return zero on success, or -ve error code. + */ +static inline int clk_release_bulk(struct clk_bulk *bulk) +{ + return clk_release_all(bulk->clks, bulk->count); +} + +/** * clk_request - Request a clock by provider-specific ID. * * This requests a clock using a provider-specific ID. Generally, this function @@ -215,6 +267,15 @@ int clk_set_parent(struct clk *clk, struct clk *parent); int clk_enable(struct clk *clk); /** + * clk_enable_bulk() - Enable (turn on) all clocks in a clock bulk struct. + * + * @bulk: A clock bulk struct that was previously successfully requested + * by clk_get_bulk(). + * @return zero on success, or -ve error code. + */ +int clk_enable_bulk(struct clk_bulk *bulk); + +/** * clk_disable() - Disable (turn off) a clock. * * @clk: A clock struct that was previously successfully requested by @@ -223,6 +284,15 @@ int clk_enable(struct clk *clk); */ int clk_disable(struct clk *clk); +/** + * clk_disable_bulk() - Disable (turn off) all clocks in a clock bulk struct. + * + * @bulk: A clock bulk struct that was previously successfully requested + * by clk_get_bulk(). + * @return zero on success, or -ve error code. + */ +int clk_disable_bulk(struct clk_bulk *bulk); + int soc_clk_dump(void); #endif From patchwork Tue Apr 3 09:44:19 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894489 X-Patchwork-Delegate: trini@ti.com Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=lists.denx.de (client-ip=81.169.180.215; helo=lists.denx.de; envelope-from=u-boot-bounces@lists.denx.de; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=baylibre-com.20150623.gappssmtp.com header.i=@baylibre-com.20150623.gappssmtp.com header.b="iw20b7H1"; dkim-atps=neutral Received: from lists.denx.de (dione.denx.de [81.169.180.215]) by ozlabs.org (Postfix) with ESMTP id 40Fkjn3Bn6z9s1p for ; Tue, 3 Apr 2018 19:45:49 +1000 (AEST) Received: by lists.denx.de (Postfix, from userid 105) id D012EC21EBB; Tue, 3 Apr 2018 09:45:04 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on lists.denx.de X-Spam-Level: X-Spam-Status: No, score=0.0 required=5.0 tests=RCVD_IN_MSPIKE_H2, T_DKIM_INVALID autolearn=unavailable autolearn_force=no version=3.4.0 Received: from lists.denx.de (localhost [IPv6:::1]) by lists.denx.de (Postfix) with ESMTP id A0B33C21EEB; Tue, 3 Apr 2018 09:44:34 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id 391DAC21EC2; Tue, 3 Apr 2018 09:44:28 +0000 (UTC) Received: from mail-wr0-f196.google.com (mail-wr0-f196.google.com [209.85.128.196]) by lists.denx.de (Postfix) with ESMTPS id C3E37C21EB4 for ; Tue, 3 Apr 2018 09:44:24 +0000 (UTC) Received: by mail-wr0-f196.google.com with SMTP id p53so17933948wrc.10 for ; Tue, 03 Apr 2018 02:44:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=jyZhu70z7uWWqGsRkEV3e8axMmJVKuZNk5wOK3Ii1xc=; b=iw20b7H1UIMLfAw7yiZM1zFOrO5Xdb7fguFCrqBFwdEpjtbFl0N6eiIeBOHGHnoPfF zOqgJFRpDOcgGOwho9sAsDMGAeVs2pR1tOlqgakgYD7P9m1B9FlfwnFi4sE1c/jt5Vl8 GhtREY9Nq4BNwuOiWtsib6jBTYgCfUyj4VNCx8IQL0cB4ahxWeWwl//DfyV1VsGzJ0T/ jfgrxOBHRlbgiUxGtGVkdIE/99IaPcdJtScrH9mUKyDwVp2DMUYzHYWtpZPcsXoR6A7j AX3PhprKrQVS2IjZ+fMb6yxlDdhomlzwbF+9irY2UBJT5iZlkU35aYzPGFS1WoxasQCK kiUA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=jyZhu70z7uWWqGsRkEV3e8axMmJVKuZNk5wOK3Ii1xc=; b=TAJYPIa8kYCiVu6Paf18RsUe2MFkE0ghwd3I/Ggxpp89ICcUXMfNOBRAPkcSRWF9Uw p5l5mzRGeP//grWnudkyuy+xgPdkx9RwLuqdrEmQ0KFEndBdvW72S1rn5VnqmG/+eZJH hECzcRE4ZDgGEj7+r1v7fIX+KPSZFXB82dYo/3JkP6OD7AnsrL+4R1+JrC9LYkwlXVm0 h6HS5hiWHbMDDArrSVQU+JsNrDv3YKyr+DN0z06YECqKajb9fSfOG5Z5PswUTxC8OUEP lUIaT3meUNoWsr/VutZGu9m4Vq903keQc78DKlStB2sSBIdswH54rD36i9K2bjVH/vbR ZiUQ== X-Gm-Message-State: AElRT7EVJfuAPglKVeIvIMAicp4wYJT7efQCBHdfEYWNwu9IvHxoFEIP 4wsGNQgKUPI27WRfpv1WePrSIw== X-Google-Smtp-Source: AIpwx48bXaiWxBKIkdP79L3WNV9EP4XXBbgD2elP2wLiGj3ya0O7Ax8r+bW8Z3U0Ozfwboa9t25ysA== X-Received: by 10.223.189.14 with SMTP id j14mr10299774wrh.138.1522748664314; Tue, 03 Apr 2018 02:44:24 -0700 (PDT) Received: from bender.baylibre.local ([90.63.244.31]) by smtp.gmail.com with ESMTPSA id q21sm1513565wra.24.2018.04.03.02.44.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 03 Apr 2018 02:44:23 -0700 (PDT) From: Neil Armstrong To: sjg@chromium.org, u-boot@lists.denx.de Date: Tue, 3 Apr 2018 11:44:19 +0200 Message-Id: <1522748659-21622-3-git-send-email-narmstrong@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522748659-21622-1-git-send-email-narmstrong@baylibre.com> References: <1522748659-21622-1-git-send-email-narmstrong@baylibre.com> Cc: marex@denx.de, linux-amlogic@lists.infradead.org Subject: [U-Boot] [PATCH v2 u-boot 2/2] clk: add sandbox test for bulk API X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.18 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" This patch adds the bulk clock API tests for the sandbox test suite. It's very similar to the main test but only uses the _bulk() API and checks if the clocks are correctly enabled/disabled. Signed-off-by: Neil Armstrong Reviewed-by: Simon Glass --- arch/sandbox/include/asm/clk.h | 32 ++++++++++++++++++++++++++++++++ drivers/clk/clk_sandbox_test.c | 29 +++++++++++++++++++++++++++++ test/dm/clk.c | 38 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+) diff --git a/arch/sandbox/include/asm/clk.h b/arch/sandbox/include/asm/clk.h index 9dc6c81..01b5ba4 100644 --- a/arch/sandbox/include/asm/clk.h +++ b/arch/sandbox/include/asm/clk.h @@ -64,6 +64,14 @@ int sandbox_clk_query_enable(struct udevice *dev, int id); */ int sandbox_clk_test_get(struct udevice *dev); /** + * sandbox_clk_test_get_bulk - Ask the sandbox clock test device to request its + * clocks with the bulk clk API. + * + * @dev: The sandbox clock test (client) devivce. + * @return: 0 if OK, or a negative error code. + */ +int sandbox_clk_test_get_bulk(struct udevice *dev); +/** * sandbox_clk_test_get_rate - Ask the sandbox clock test device to query a * clock's rate. * @@ -91,6 +99,14 @@ ulong sandbox_clk_test_set_rate(struct udevice *dev, int id, ulong rate); */ int sandbox_clk_test_enable(struct udevice *dev, int id); /** + * sandbox_clk_test_enable_bulk - Ask the sandbox clock test device to enable + * all clocks in it's clock bulk struct. + * + * @dev: The sandbox clock test (client) devivce. + * @return: 0 if OK, or a negative error code. + */ +int sandbox_clk_test_enable_bulk(struct udevice *dev); +/** * sandbox_clk_test_disable - Ask the sandbox clock test device to disable a * clock. * @@ -100,6 +116,14 @@ int sandbox_clk_test_enable(struct udevice *dev, int id); */ int sandbox_clk_test_disable(struct udevice *dev, int id); /** + * sandbox_clk_test_disable_bulk - Ask the sandbox clock test device to disable + * all clocks in it's clock bulk struct. + * + * @dev: The sandbox clock test (client) devivce. + * @return: 0 if OK, or a negative error code. + */ +int sandbox_clk_test_disable_bulk(struct udevice *dev); +/** * sandbox_clk_test_free - Ask the sandbox clock test device to free its * clocks. * @@ -107,5 +131,13 @@ int sandbox_clk_test_disable(struct udevice *dev, int id); * @return: 0 if OK, or a negative error code. */ int sandbox_clk_test_free(struct udevice *dev); +/** + * sandbox_clk_test_release_bulk - Ask the sandbox clock test device to release + * all clocks in it's clock bulk struct. + * + * @dev: The sandbox clock test (client) devivce. + * @return: 0 if OK, or a negative error code. + */ +int sandbox_clk_test_release_bulk(struct udevice *dev); #endif diff --git a/drivers/clk/clk_sandbox_test.c b/drivers/clk/clk_sandbox_test.c index 999100d..d089881 100644 --- a/drivers/clk/clk_sandbox_test.c +++ b/drivers/clk/clk_sandbox_test.c @@ -11,6 +11,7 @@ struct sandbox_clk_test { struct clk clks[SANDBOX_CLK_TEST_ID_COUNT]; + struct clk_bulk bulk; }; static const char * const sandbox_clk_test_names[] = { @@ -34,6 +35,13 @@ int sandbox_clk_test_get(struct udevice *dev) return 0; } +int sandbox_clk_test_get_bulk(struct udevice *dev) +{ + struct sandbox_clk_test *sbct = dev_get_priv(dev); + + return clk_get_bulk(dev, &sbct->bulk); +} + ulong sandbox_clk_test_get_rate(struct udevice *dev, int id) { struct sandbox_clk_test *sbct = dev_get_priv(dev); @@ -64,6 +72,13 @@ int sandbox_clk_test_enable(struct udevice *dev, int id) return clk_enable(&sbct->clks[id]); } +int sandbox_clk_test_enable_bulk(struct udevice *dev) +{ + struct sandbox_clk_test *sbct = dev_get_priv(dev); + + return clk_enable_bulk(&sbct->bulk); +} + int sandbox_clk_test_disable(struct udevice *dev, int id) { struct sandbox_clk_test *sbct = dev_get_priv(dev); @@ -74,6 +89,13 @@ int sandbox_clk_test_disable(struct udevice *dev, int id) return clk_disable(&sbct->clks[id]); } +int sandbox_clk_test_disable_bulk(struct udevice *dev) +{ + struct sandbox_clk_test *sbct = dev_get_priv(dev); + + return clk_disable_bulk(&sbct->bulk); +} + int sandbox_clk_test_free(struct udevice *dev) { struct sandbox_clk_test *sbct = dev_get_priv(dev); @@ -88,6 +110,13 @@ int sandbox_clk_test_free(struct udevice *dev) return 0; } +int sandbox_clk_test_release_bulk(struct udevice *dev) +{ + struct sandbox_clk_test *sbct = dev_get_priv(dev); + + return clk_release_bulk(&sbct->bulk); +} + static const struct udevice_id sandbox_clk_test_ids[] = { { .compatible = "sandbox,clk-test" }, { } diff --git a/test/dm/clk.c b/test/dm/clk.c index 712a1e6..95716f8 100644 --- a/test/dm/clk.c +++ b/test/dm/clk.c @@ -101,3 +101,41 @@ static int dm_test_clk(struct unit_test_state *uts) return 0; } DM_TEST(dm_test_clk, DM_TESTF_SCAN_FDT); + +static int dm_test_clk_bulk(struct unit_test_state *uts) +{ + struct udevice *dev_clk, *dev_test; + ulong rate; + + ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox", + &dev_clk)); + ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test", + &dev_test)); + ut_assertok(sandbox_clk_test_get_bulk(dev_test)); + + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); + + /* Fixed clock does not support enable, thus should not fail */ + ut_assertok(sandbox_clk_test_enable_bulk(dev_test)); + ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); + ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); + + /* Fixed clock does not support disable, thus should not fail */ + ut_assertok(sandbox_clk_test_disable_bulk(dev_test)); + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); + + /* Fixed clock does not support enable, thus should not fail */ + ut_assertok(sandbox_clk_test_enable_bulk(dev_test)); + ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); + ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); + + /* Fixed clock does not support disable, thus should not fail */ + ut_assertok(sandbox_clk_test_release_bulk(dev_test)); + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI)); + ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C)); + + return 0; +} +DM_TEST(dm_test_clk_bulk, DM_TESTF_SCAN_FDT);