From patchwork Tue Apr 3 09:40:50 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894487 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="lnzvD02n"; dkim-atps=neutral Received: from lists.denx.de (dione.denx.de [81.169.180.215]) by ozlabs.org (Postfix) with ESMTP id 40Fkdh5BK7z9s1p for ; Tue, 3 Apr 2018 19:42:16 +1000 (AEST) Received: by lists.denx.de (Postfix, from userid 105) id 14459C21EBE; Tue, 3 Apr 2018 09:41:20 +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_H3, RCVD_IN_MSPIKE_WL, 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 6B272C21EB4; Tue, 3 Apr 2018 09:41:06 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id EFB8BC21EA2; Tue, 3 Apr 2018 09:41:03 +0000 (UTC) Received: from mail-wm0-f68.google.com (mail-wm0-f68.google.com [74.125.82.68]) by lists.denx.de (Postfix) with ESMTPS id 69F2BC21C50 for ; Tue, 3 Apr 2018 09:40:57 +0000 (UTC) Received: by mail-wm0-f68.google.com with SMTP id r191so1455233wmg.4 for ; Tue, 03 Apr 2018 02:40:57 -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=qvrlfQxk5Py5B881p3oNwNZJloj3kOs2OP2QmWJ/LMA=; b=lnzvD02nigK5kEkVUyMMW766t1WaOewGOOXPLTuDnbCLFjtICSv7TM9BUhrCYTiSdE pcRNA9suTevHpVNUQI/whno8Hq+RBISPs31EimzIIpQTt8sOs9lbW2wNPLgkRsAS8MSH BLiI2/zNZ4Gp9WG6lD8qFQ5F0/8GcVq0NvH+BAoKtWOkqRC+k5Dk1HGK4qpS3pMUJqnl QFRwRjxX8u1GXQXwdMpZMy4cr3SdwmMDuGRphAk3NYWpHaMjPlimXgtfO2h7qlfz0GlB IBPAe2MSM/KndG2CSRpDBbp6WIKN6aSbl1uYd0ORMJBULOso20TkIilFjKXKTTLYkWBc a3gg== 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=qvrlfQxk5Py5B881p3oNwNZJloj3kOs2OP2QmWJ/LMA=; b=ebfuhMFmtc9WkEZC1bN5Ei3rcGkQRU2YXGrx8xrRK7+NBteRWG+X0SzJIo692bFSAq 7vFZf5OJCtqsWb+76hW2M/D0fRTVf2Tq6P2Gs5zKHaFSjTx6rgTIrZ0UQA4mOSGe2bQo cmZAGs2xkdosCN8LhsjtslD4OY3qaVHPFqcEv0FPelmR9fXyMSaiMS9xYGVRjk6mRbHz 14AEWRAZu036I4SsXyx2sBPBPdCRB6yOOL1WKJfLXFkgi4Gbd58PADig7B2Rn0N0ALWq KT035Sf83M6lkVbrLTNK67EvdMiGuXuQHzYGORH9O9fFuPUvhYzwnLmY4g+iyeti927K TXXQ== X-Gm-Message-State: ALQs6tA/1/tW3r3ca826B1UrDoFCBvQ8Xi1IB4OxAMuFCwrKInQ9Bj82 7EDeNU1XeaMppmSTbQ+P6TJKgw== X-Google-Smtp-Source: AIpwx48UKM1ZA2Si2504eVwznFkZILv0gf0b/aiKq1ytLh89Xz3BK3yrJPkNvFLGocJy7Zh3sQ4anA== X-Received: by 10.28.137.204 with SMTP id l195mr3122884wmd.141.1522748456821; Tue, 03 Apr 2018 02:40:56 -0700 (PDT) Received: from bender.baylibre.local ([90.63.244.31]) by smtp.gmail.com with ESMTPSA id k35sm1929582wre.55.2018.04.03.02.40.55 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 03 Apr 2018 02:40:55 -0700 (PDT) From: Neil Armstrong To: sjg@chromium.org, u-boot@lists.denx.de Date: Tue, 3 Apr 2018 11:40:50 +0200 Message-Id: <1522748451-21209-2-git-send-email-narmstrong@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522748451-21209-1-git-send-email-narmstrong@baylibre.com> References: <1522748451-21209-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] reset: Add get/assert/deassert/release for bulk of reset signals 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 reset API in order to get/deassert/ assert/release a group of reset signals associated with a device. This bulk API will avoid adding a copy of the same code to manage a group of reset signals in drivers. Signed-off-by: Neil Armstrong Reviewed-by: Simon Glass --- drivers/reset/reset-uclass.c | 60 +++++++++++++++++++++++++++ include/reset.h | 99 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 159 insertions(+) diff --git a/drivers/reset/reset-uclass.c b/drivers/reset/reset-uclass.c index 307a297..9a5c9c9 100644 --- a/drivers/reset/reset-uclass.c +++ b/drivers/reset/reset-uclass.c @@ -81,6 +81,40 @@ int reset_get_by_index(struct udevice *dev, int index, return 0; } +int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk) +{ + int i, ret, err, count; + + bulk->count = 0; + + count = dev_count_phandle_with_args(dev, "resets", "#reset-cells"); + if (!count) + return 0; + + bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl), + GFP_KERNEL); + if (!bulk->resets) + return -ENOMEM; + + for (i = 0; i < count; i++) { + ret = reset_get_by_index(dev, i, &bulk->resets[i]); + if (ret < 0) + goto bulk_get_err; + + ++bulk->count; + } + + return 0; + +bulk_get_err: + err = reset_release_all(bulk->resets, bulk->count); + if (err) + debug("%s: could release all resets for %p\n", + __func__, dev); + + return ret; +} + int reset_get_by_name(struct udevice *dev, const char *name, struct reset_ctl *reset_ctl) { @@ -126,6 +160,19 @@ int reset_assert(struct reset_ctl *reset_ctl) return ops->rst_assert(reset_ctl); } +int reset_assert_bulk(struct reset_ctl_bulk *bulk) +{ + int i, ret; + + for (i = 0; i < bulk->count; i++) { + ret = reset_assert(&bulk->resets[i]); + if (ret < 0) + return ret; + } + + return 0; +} + int reset_deassert(struct reset_ctl *reset_ctl) { struct reset_ops *ops = reset_dev_ops(reset_ctl->dev); @@ -135,6 +182,19 @@ int reset_deassert(struct reset_ctl *reset_ctl) return ops->rst_deassert(reset_ctl); } +int reset_deassert_bulk(struct reset_ctl_bulk *bulk) +{ + int i, ret; + + for (i = 0; i < bulk->count; i++) { + ret = reset_deassert(&bulk->resets[i]); + if (ret < 0) + return ret; + } + + return 0; +} + int reset_release_all(struct reset_ctl *reset_ctl, int count) { int i, ret; diff --git a/include/reset.h b/include/reset.h index 7185ade..d38f176 100644 --- a/include/reset.h +++ b/include/reset.h @@ -60,6 +60,24 @@ struct reset_ctl { unsigned long id; }; +/** + * struct reset_ctl_bulk - A handle to (allowing control of) a bulk of reset + * signals. + * + * Clients provide storage for the reset control bulk. The content of the + * structure is managed solely by the reset API. A reset control bulk struct is + * initialized by "get"ing the reset control bulk struct. + * The reset control bulk struct is passed to all other bulk reset APIs to apply + * the API to all the reset signals in the bulk struct. + * + * @resets: An array of reset signal handles handles. + * @count: The number of reset signal handles in the reset array. + */ +struct reset_ctl_bulk { + struct reset_ctl *resets; + unsigned int count; +}; + #ifdef CONFIG_DM_RESET /** * reset_get_by_index - Get/request a reset signal by integer index. @@ -81,6 +99,22 @@ int reset_get_by_index(struct udevice *dev, int index, struct reset_ctl *reset_ctl); /** + * reset_get_bulk - Get/request all reset signals of a device. + * + * This looks up and requests all reset signals of the client device; each + * device is assumed to have n reset signals associated with it somehow, + * and this function finds and requests all of them in a separate structure. + * The mapping of client device reset signals indices to provider reset signals + * may be via device-tree properties, board-provided mapping tables, or some + * other mechanism. + * + * @dev: The client device. + * @bulk A pointer to a reset control bulk struct to initialize. + * @return 0 if OK, or a negative error code. + */ +int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk); + +/** * reset_get_by_name - Get/request a reset signal by name. * * This looks up and requests a reset signal. The name is relative to the @@ -132,6 +166,21 @@ int reset_free(struct reset_ctl *reset_ctl); int reset_assert(struct reset_ctl *reset_ctl); /** + * reset_assert_bulk - Assert all reset signals in a reset control bulk struct. + * + * This function will assert the specified reset signals in a reset control + * bulk struct, thus resetting the affected HW module(s). Depending on the + * reset controller hardware, the reset signals will either stay asserted + * until reset_deassert_bulk() is called, or the hardware may autonomously + * clear the reset signals itself. + * + * @bulk: A reset control bulk struct that was previously successfully + * requested by reset_get_bulk(). + * @return 0 if OK, or a negative error code. + */ +int reset_assert_bulk(struct reset_ctl_bulk *bulk); + +/** * reset_deassert - Deassert a reset signal. * * This function will deassert the specified reset signal, thus releasing the @@ -145,6 +194,20 @@ int reset_assert(struct reset_ctl *reset_ctl); int reset_deassert(struct reset_ctl *reset_ctl); /** + * reset_deassert_bulk - Deassert all reset signals in a reset control bulk + * struct. + * + * This function will deassert the specified reset signals in a reset control + * bulk struct, thus releasing the affected HW modules() from reset, and + * allowing them to continue normal operation. + * + * @bulk: A reset control bulk struct that was previously successfully + * requested by reset_get_bulk(). + * @return 0 if OK, or a negative error code. + */ +int reset_deassert_bulk(struct reset_ctl_bulk *bulk); + +/** * reset_release_all - Assert/Free an array of previously requested resets. * * For each reset contained in the reset array, this function will check if @@ -156,6 +219,23 @@ int reset_deassert(struct reset_ctl *reset_ctl); * @return 0 if OK, or a negative error code. */ int reset_release_all(struct reset_ctl *reset_ctl, int count); + +/** + * reset_release_bulk - Assert/Free an array of previously requested reset + * signals in a reset control bulk struct. + * + * For each reset contained in the reset control bulk struct, this function + * will check if reset has been previously requested and then will assert + * and free it. + * + * @bulk: A reset control bulk struct that was previously successfully + * requested by reset_get_bulk(). + * @return 0 if OK, or a negative error code. + */ +static inline int reset_release_bulk(struct reset_ctl_bulk *bulk) +{ + return reset_release_all(bulk->resets, bulk->count); +} #else static inline int reset_get_by_index(struct udevice *dev, int index, struct reset_ctl *reset_ctl) @@ -163,6 +243,11 @@ static inline int reset_get_by_index(struct udevice *dev, int index, return -ENOTSUPP; } +static inline int reset_get_bulk(struct udevice *dev, struct clk_bulk *bulk) +{ + return -ENOTSUPP; +} + static inline int reset_get_by_name(struct udevice *dev, const char *name, struct reset_ctl *reset_ctl) { @@ -179,16 +264,30 @@ static inline int reset_assert(struct reset_ctl *reset_ctl) return 0; } +static inline int reset_assert_bulk(struct reset_ctl_bulk *bulk) +{ + return 0; +} + static inline int reset_deassert(struct reset_ctl *reset_ctl) { return 0; } +static inline int reset_deassert_bulk(struct reset_ctl_bulk *bulk) +{ + return 0; +} + static inline int reset_release_all(struct reset_ctl *reset_ctl, int count) { return 0; } +static inline int reset_release_bulk(struct clk_bulk *bulk) +{ + return 0; +} #endif #endif From patchwork Tue Apr 3 09:40:51 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Neil Armstrong X-Patchwork-Id: 894486 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="qJA2bLd0"; dkim-atps=neutral Received: from lists.denx.de (dione.denx.de [81.169.180.215]) by ozlabs.org (Postfix) with ESMTP id 40FkdY5qMZz9s1p for ; Tue, 3 Apr 2018 19:42:09 +1000 (AEST) Received: by lists.denx.de (Postfix, from userid 105) id 7EBE3C21EE5; Tue, 3 Apr 2018 09:41: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_H3, RCVD_IN_MSPIKE_WL, 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 C347AC21CB1; Tue, 3 Apr 2018 09:41:16 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id 8D440C21EA2; Tue, 3 Apr 2018 09:41:04 +0000 (UTC) Received: from mail-wm0-f66.google.com (mail-wm0-f66.google.com [74.125.82.66]) by lists.denx.de (Postfix) with ESMTPS id 9907FC21EBE for ; Tue, 3 Apr 2018 09:40:58 +0000 (UTC) Received: by mail-wm0-f66.google.com with SMTP id f125so33652558wme.4 for ; Tue, 03 Apr 2018 02:40:58 -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=gaGObHtQBKxl/2x2Jmi5JCqivYH9jvom9NEJus5fZgM=; b=qJA2bLd0EoNq5GEAzTPKek12PoT37sc0zqZAgPe1QAMbD4GLdqAG6MzWOG4K4Uz5Pb n7Dr96MSTAzQKBCQsAXWMd0bKS1LEGgol3TstmCnyK0R03knT6Jg0O8giLccdqcUvBHm lByyB5qMDwOEuYPKo91ORUTPyJOMl2HsLjSz/Mkuqe+98+epWJcSwLR25OjY43VlfiBe ZAJPwBatZd2S2aqgXZEHPae+EcmKlDEjFhvq12Nq1RkkMxBUxIV3t3lM6ZEF1KItHA6r bDROvSlV0462SgW2szkXhqyfGbGxbVFeW8sIGWKezcFqweQOboIlMoGDIwmneaLr8KXy ZcxQ== 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=gaGObHtQBKxl/2x2Jmi5JCqivYH9jvom9NEJus5fZgM=; b=VwSrLSBXrBmgZMUWm/DV62eQ0OzeKR8Hf6aW8VHrX5AKZtixyzWIklK4rlaDWcZMQe vRDmvfsYp22siKZsL6DUUSnGkiPmL0jDwb9ZJPLs+JLsVSlpLovJFHa/0Ve8xHBBb+Do raKM7DkojK39Ns1pmRnKHDJcY8tY8wFu06V6BkK0oEt3AFl0IjPcKqVNlVzg4WYPsgFO ZmZIK8V4SiXcGddZoSfcY2wY82RFC/54qAU85JK1YR7iWXH8gWX+5isuK24YKpa5KAUK BF6S0N3culOn0WDIL4pCCw0z3GDlDAkbFcznsuNocgOAbs35hNOjIxD52Rpckv4jNQkR xtTg== X-Gm-Message-State: AElRT7GGgMHnJL3S+76s78oHDG4VXb89+20e3dBIZDB2KQonLcVrN2E4 a7yAKTgmo9n2NydOK8YvNo27UdPAaXc= X-Google-Smtp-Source: AIpwx49P0LFLtL10aC/vpP5McMJWpTZm7SFge3lOMsLwBRzMYSVkpX44gWiqTQfhLTaD4UPIqH2obw== X-Received: by 10.28.167.204 with SMTP id q195mr3373779wme.48.1522748458128; Tue, 03 Apr 2018 02:40:58 -0700 (PDT) Received: from bender.baylibre.local ([90.63.244.31]) by smtp.gmail.com with ESMTPSA id k35sm1929582wre.55.2018.04.03.02.40.56 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 03 Apr 2018 02:40:57 -0700 (PDT) From: Neil Armstrong To: sjg@chromium.org, u-boot@lists.denx.de Date: Tue, 3 Apr 2018 11:40:51 +0200 Message-Id: <1522748451-21209-3-git-send-email-narmstrong@baylibre.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1522748451-21209-1-git-send-email-narmstrong@baylibre.com> References: <1522748451-21209-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] reset: 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 reset API tests for the sandbox test suite. Unlike the main test, it also check the "other" reset signal using the bulk API and checks if the resets are correctly asserted/deasserted. To allow the bulk API to work, and avoid changing the DT, the number of resets of the sandbox reset controller has been bumped to 101 for the "other" reset line to be valid. Signed-off-by: Neil Armstrong Reviewed-by: Simon Glass --- arch/sandbox/include/asm/reset.h | 4 ++++ drivers/reset/sandbox-reset-test.c | 29 +++++++++++++++++++++++++++++ drivers/reset/sandbox-reset.c | 2 +- test/dm/reset.c | 33 +++++++++++++++++++++++++++++++++ 4 files changed, 67 insertions(+), 1 deletion(-) diff --git a/arch/sandbox/include/asm/reset.h b/arch/sandbox/include/asm/reset.h index 7146aa5..0cd7702 100644 --- a/arch/sandbox/include/asm/reset.h +++ b/arch/sandbox/include/asm/reset.h @@ -14,8 +14,12 @@ struct udevice; int sandbox_reset_query(struct udevice *dev, unsigned long id); int sandbox_reset_test_get(struct udevice *dev); +int sandbox_reset_test_get_bulk(struct udevice *dev); int sandbox_reset_test_assert(struct udevice *dev); +int sandbox_reset_test_assert_bulk(struct udevice *dev); int sandbox_reset_test_deassert(struct udevice *dev); +int sandbox_reset_test_deassert_bulk(struct udevice *dev); int sandbox_reset_test_free(struct udevice *dev); +int sandbox_reset_test_release_bulk(struct udevice *dev); #endif diff --git a/drivers/reset/sandbox-reset-test.c b/drivers/reset/sandbox-reset-test.c index e37d6c9..f0ceaa0 100644 --- a/drivers/reset/sandbox-reset-test.c +++ b/drivers/reset/sandbox-reset-test.c @@ -12,6 +12,7 @@ struct sandbox_reset_test { struct reset_ctl ctl; + struct reset_ctl_bulk bulk; }; int sandbox_reset_test_get(struct udevice *dev) @@ -21,6 +22,13 @@ int sandbox_reset_test_get(struct udevice *dev) return reset_get_by_name(dev, "test", &sbrt->ctl); } +int sandbox_reset_test_get_bulk(struct udevice *dev) +{ + struct sandbox_reset_test *sbrt = dev_get_priv(dev); + + return reset_get_bulk(dev, &sbrt->bulk); +} + int sandbox_reset_test_assert(struct udevice *dev) { struct sandbox_reset_test *sbrt = dev_get_priv(dev); @@ -28,6 +36,13 @@ int sandbox_reset_test_assert(struct udevice *dev) return reset_assert(&sbrt->ctl); } +int sandbox_reset_test_assert_bulk(struct udevice *dev) +{ + struct sandbox_reset_test *sbrt = dev_get_priv(dev); + + return reset_assert_bulk(&sbrt->bulk); +} + int sandbox_reset_test_deassert(struct udevice *dev) { struct sandbox_reset_test *sbrt = dev_get_priv(dev); @@ -35,6 +50,13 @@ int sandbox_reset_test_deassert(struct udevice *dev) return reset_deassert(&sbrt->ctl); } +int sandbox_reset_test_deassert_bulk(struct udevice *dev) +{ + struct sandbox_reset_test *sbrt = dev_get_priv(dev); + + return reset_deassert_bulk(&sbrt->bulk); +} + int sandbox_reset_test_free(struct udevice *dev) { struct sandbox_reset_test *sbrt = dev_get_priv(dev); @@ -42,6 +64,13 @@ int sandbox_reset_test_free(struct udevice *dev) return reset_free(&sbrt->ctl); } +int sandbox_reset_test_release_bulk(struct udevice *dev) +{ + struct sandbox_reset_test *sbrt = dev_get_priv(dev); + + return reset_release_bulk(&sbrt->bulk); +} + static const struct udevice_id sandbox_reset_test_ids[] = { { .compatible = "sandbox,reset-ctl-test" }, { } diff --git a/drivers/reset/sandbox-reset.c b/drivers/reset/sandbox-reset.c index 4258af5..c310749 100644 --- a/drivers/reset/sandbox-reset.c +++ b/drivers/reset/sandbox-reset.c @@ -10,7 +10,7 @@ #include #include -#define SANDBOX_RESET_SIGNALS 3 +#define SANDBOX_RESET_SIGNALS 101 struct sandbox_reset_signal { bool asserted; diff --git a/test/dm/reset.c b/test/dm/reset.c index 0ae8031..8dc0023 100644 --- a/test/dm/reset.c +++ b/test/dm/reset.c @@ -13,6 +13,9 @@ /* This must match the specifier for mbox-names="test" in the DT node */ #define TEST_RESET_ID 2 +/* This is the other reset phandle specifier handled by bulk */ +#define OTHER_RESET_ID 2 + static int dm_test_reset(struct unit_test_state *uts) { struct udevice *dev_reset; @@ -37,3 +40,33 @@ static int dm_test_reset(struct unit_test_state *uts) return 0; } DM_TEST(dm_test_reset, DM_TESTF_SCAN_FDT); + +static int dm_test_reset_bulk(struct unit_test_state *uts) +{ + struct udevice *dev_reset; + struct udevice *dev_test; + + ut_assertok(uclass_get_device_by_name(UCLASS_RESET, "reset-ctl", + &dev_reset)); + ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID)); + ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); + + ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "reset-ctl-test", + &dev_test)); + ut_assertok(sandbox_reset_test_get_bulk(dev_test)); + + ut_assertok(sandbox_reset_test_assert_bulk(dev_test)); + ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID)); + ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); + + ut_assertok(sandbox_reset_test_deassert_bulk(dev_test)); + ut_asserteq(0, sandbox_reset_query(dev_reset, TEST_RESET_ID)); + ut_asserteq(0, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); + + ut_assertok(sandbox_reset_test_release_bulk(dev_test)); + ut_asserteq(1, sandbox_reset_query(dev_reset, TEST_RESET_ID)); + ut_asserteq(1, sandbox_reset_query(dev_reset, OTHER_RESET_ID)); + + return 0; +} +DM_TEST(dm_test_reset_bulk, DM_TESTF_SCAN_FDT);