From nobody Mon Feb 9 15:10:54 2026 Received: from mail-pl1-f182.google.com (mail-pl1-f182.google.com [209.85.214.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 26E7C23D294 for ; Thu, 24 Apr 2025 10:37:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745491047; cv=none; b=b9iiHjCIv9jblLndLfh6QpEA2kqPcMJqiWduAZoSyhemwplejVi+YA3PCMqBSrx1wabZ9PMVbLcb1gEhLRqarULrrezmmgMB69gVcTRovhe7lyd6SoXkoVTDqHCi0v9IpCsviPygr1xZWWKKujHBbezWTZ0BzOQWPMgaaNOFT+I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745491047; c=relaxed/simple; bh=TmOGFV0w7v62MJ6x8MwidOrdpKY+8DJsmTGwPxqGrNo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=DYJv7VnB2RSP2FMB3+c61EX0fgViCLEUFWa/Hmqzl6iE5ium0ZYYbJOdiewuZwIKwl7aSOIX60kKy01NDAaYEXtFrES1ReqXdf5CkQtwMBsQTvrI24tpwlCIh6vEbvheFSQsExRYLtZbbUQC04YvfEGOLQkwH8W3YJEtj975csg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org; spf=pass smtp.mailfrom=linaro.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b=Vp2ggoii; arc=none smtp.client-ip=209.85.214.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linaro.org Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linaro.org Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="Vp2ggoii" Received: by mail-pl1-f182.google.com with SMTP id d9443c01a7336-22d95f0dda4so12371765ad.2 for ; Thu, 24 Apr 2025 03:37:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1745491044; x=1746095844; 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=iBwTEXhNABTCQyq0u1UG76AK2UVABOzq6NwLkHUAp5g=; b=Vp2ggoiivVf0XCFeNd31Q4L7yILXFVinhCqydSUDyl5zachVO/GIusHto53YTjd8bE 5qLMnP40afg9Fe3jABFM+j9xJgZV1LUi/voiyBxJgPA2D0uvAOLhUYnAZ4xJIGAMIaJw gN45pvxF1Sfx7Ub0ZpwQ5j09C/X+B01oQzk7R0ozVtzKIUU3M/TQOcSyG026mZyRp7cX ZRScYjMafxaoUHP3R8HPdqY+51RjTlL1zaQDhdOYMe3aQoRvsMbAKawh6hPO721DJGzZ qwlXiAjmffr8P/M3E1/Bk6S2q6vCsRWsfVBB0vXSefWLyw4fc6r1qw8bMTETeLqyqXau zvSA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745491044; x=1746095844; 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=iBwTEXhNABTCQyq0u1UG76AK2UVABOzq6NwLkHUAp5g=; b=cUNSEO/EEcjLvcmU+bPb3M58CmhYv7pTRQgGjk/Q279MEuusSUzvqsEe8Yc8uw4sop r80d1BdrjBqOnP4+HghwfypZ4JaSYEYq+gYhJT81g0il6BcN4CuIwwnoLFajYG90xbr6 c1dwZwnEWnUHLt+Zo0kyUeqRtQ/5ITadWkpVKpF/XVvd7OqwQHRkrzO6HfzDykq7PUBy RaeoGNtZZlm52U8t3dq9GwSGcSrQYViAqjkT4IswKRbDMREz5OTgxp4dpFBjdoO0sgjj efidnRmhB/+2KNtGOBh5yiN3Uxz9A7/p2ySdOQ00pIoFVdDUZyihW9hnnKXKCDjCAEy+ eg5w== X-Forwarded-Encrypted: i=1; AJvYcCU25+qGHRAu1lp35s0SYzClPn3JD2IICuwu4lWGnQU62i9lAaj/xrCBI1G3RqDXvV20oNiJuRvxuRs1lVo=@vger.kernel.org X-Gm-Message-State: AOJu0YwWu1lV4rojqlSl3GKXSghm/bf/M2R7qQCobXMBkyJcEeeYlLr4 gp6r7Fv43fhebYxWF7A2rAPI1IaLXX7PnA7z2xrWOmxlAz7bEKx3r/7GZWXIupw= X-Gm-Gg: ASbGnctd1rLlvMXFbQdUTAVYWriLMGa95Jc/EfASc2TVkxrfUUJ2j3KEaULtAaScuUa uKmNvSY3V70VvYAwH4wZB7W4vfAgnJw0/7BsAuZYxDBmzxgTPFv4gUoHBNHOgvNbbmTGCb1rRhS mvzYhfTQTFyUi+q+kR+QdIuW1kKmH1PRnGpmWdkaVpuN5s8q5aD24SXEaWBEz6VjYrHbPrywSI5 dILpWOlwPVv+8vsT8aY6ttQ1iXRsxugmKqhtsFQVmVX0Iijae6u9QjA05IxvAzQFv3bgO7lzyo+ sAXS1X9aVpliLPdvlnX1+CFGg6LU8D7Cxxj08/DlZlq8KoLrUOTw X-Google-Smtp-Source: AGHT+IFsvSHzdGeWlWocErZ1QgNQTv5wJHcxn0cYwaK4A27pHPX0GIC28/2OjZnhyv7cYx3YbtgU6Q== X-Received: by 2002:a17:902:d2ce:b0:21b:d105:26b8 with SMTP id d9443c01a7336-22db3bb1e1cmr24994525ad.7.1745491044394; Thu, 24 Apr 2025 03:37:24 -0700 (PDT) Received: from localhost ([122.172.83.32]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-22db50e7681sm9868985ad.119.2025.04.24.03.37.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 24 Apr 2025 03:37:23 -0700 (PDT) From: Viresh Kumar To: Viresh Kumar , Nishanth Menon , Stephen Boyd Cc: Viresh Kumar , linux-pm@vger.kernel.org, Vincent Guittot , "Rafael J. Wysocki" , linux-kernel@vger.kernel.org Subject: [PATCH 6/6] OPP: Use mutex locking guards Date: Thu, 24 Apr 2025 16:06:49 +0530 Message-Id: X-Mailer: git-send-email 2.31.1.272.g89b43f80a514 In-Reply-To: References: 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" Use mutex locking guard in the OPP core. No intentional functional impact. Signed-off-by: Viresh Kumar --- drivers/opp/core.c | 201 ++++++++++++++++++--------------------------- drivers/opp/cpu.c | 3 +- drivers/opp/of.c | 65 ++++++--------- 3 files changed, 105 insertions(+), 164 deletions(-) diff --git a/drivers/opp/core.c b/drivers/opp/core.c index 87d27132cd87..fc9874946453 100644 --- a/drivers/opp/core.c +++ b/drivers/opp/core.c @@ -40,17 +40,14 @@ static DEFINE_XARRAY_ALLOC1(opp_configs); static bool _find_opp_dev(const struct device *dev, struct opp_table *opp_= table) { struct opp_device *opp_dev; - bool found =3D false; =20 - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); + list_for_each_entry(opp_dev, &opp_table->dev_list, node) - if (opp_dev->dev =3D=3D dev) { - found =3D true; - break; - } + if (opp_dev->dev =3D=3D dev) + return true; =20 - mutex_unlock(&opp_table->lock); - return found; + return false; } =20 static struct opp_table *_find_opp_table_unlocked(struct device *dev) @@ -78,18 +75,13 @@ static struct opp_table *_find_opp_table_unlocked(struc= t device *dev) */ struct opp_table *_find_opp_table(struct device *dev) { - struct opp_table *opp_table; - if (IS_ERR_OR_NULL(dev)) { pr_err("%s: Invalid parameters\n", __func__); return ERR_PTR(-EINVAL); } =20 - mutex_lock(&opp_table_lock); - opp_table =3D _find_opp_table_unlocked(dev); - mutex_unlock(&opp_table_lock); - - return opp_table; + guard(mutex)(&opp_table_lock); + return _find_opp_table_unlocked(dev); } =20 /* @@ -359,25 +351,23 @@ unsigned long dev_pm_opp_get_max_volt_latency(struct = device *dev) if (!uV) return 0; =20 - mutex_lock(&opp_table->lock); - - for (i =3D 0; i < count; i++) { - uV[i].min =3D ~0; - uV[i].max =3D 0; + scoped_guard(mutex, &opp_table->lock) { + for (i =3D 0; i < count; i++) { + uV[i].min =3D ~0; + uV[i].max =3D 0; =20 - list_for_each_entry(opp, &opp_table->opp_list, node) { - if (!opp->available) - continue; + list_for_each_entry(opp, &opp_table->opp_list, node) { + if (!opp->available) + continue; =20 - if (opp->supplies[i].u_volt_min < uV[i].min) - uV[i].min =3D opp->supplies[i].u_volt_min; - if (opp->supplies[i].u_volt_max > uV[i].max) - uV[i].max =3D opp->supplies[i].u_volt_max; + if (opp->supplies[i].u_volt_min < uV[i].min) + uV[i].min =3D opp->supplies[i].u_volt_min; + if (opp->supplies[i].u_volt_max > uV[i].max) + uV[i].max =3D opp->supplies[i].u_volt_max; + } } } =20 - mutex_unlock(&opp_table->lock); - /* * The caller needs to ensure that opp_table (and hence the regulator) * isn't freed, while we are executing this routine. @@ -438,15 +428,13 @@ int _get_opp_count(struct opp_table *opp_table) struct dev_pm_opp *opp; int count =3D 0; =20 - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); =20 list_for_each_entry(opp, &opp_table->opp_list, node) { if (opp->available) count++; } =20 - mutex_unlock(&opp_table->lock); - return count; } =20 @@ -535,7 +523,7 @@ static struct dev_pm_opp *_opp_table_find_key(struct op= p_table *opp_table, if (assert && !assert(opp_table, index)) return ERR_PTR(-EINVAL); =20 - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); =20 list_for_each_entry(temp_opp, &opp_table->opp_list, node) { if (temp_opp->available =3D=3D available) { @@ -550,8 +538,6 @@ static struct dev_pm_opp *_opp_table_find_key(struct op= p_table *opp_table, dev_pm_opp_get(opp); } =20 - mutex_unlock(&opp_table->lock); - return opp; } =20 @@ -1166,10 +1152,9 @@ static void _find_current_opp(struct device *dev, st= ruct opp_table *opp_table) * make special checks to validate current_opp. */ if (IS_ERR(opp)) { - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); opp =3D dev_pm_opp_get(list_first_entry(&opp_table->opp_list, struct dev_pm_opp, node)); - mutex_unlock(&opp_table->lock); } =20 opp_table->current_opp =3D opp; @@ -1426,9 +1411,8 @@ struct opp_device *_add_opp_dev(const struct device *= dev, /* Initialize opp-dev */ opp_dev->dev =3D dev; =20 - mutex_lock(&opp_table->lock); - list_add(&opp_dev->node, &opp_table->dev_list); - mutex_unlock(&opp_table->lock); + scoped_guard(mutex, &opp_table->lock) + list_add(&opp_dev->node, &opp_table->dev_list); =20 /* Create debugfs entries for the opp_table */ opp_debug_register(opp_dev, opp_table); @@ -1721,17 +1705,15 @@ void dev_pm_opp_remove(struct device *dev, unsigned= long freq) if (!assert_single_clk(opp_table, 0)) return; =20 - mutex_lock(&opp_table->lock); - - list_for_each_entry(iter, &opp_table->opp_list, node) { - if (iter->rates[0] =3D=3D freq) { - opp =3D iter; - break; + scoped_guard(mutex, &opp_table->lock) { + list_for_each_entry(iter, &opp_table->opp_list, node) { + if (iter->rates[0] =3D=3D freq) { + opp =3D iter; + break; + } } } =20 - mutex_unlock(&opp_table->lock); - if (opp) { dev_pm_opp_put(opp); =20 @@ -1747,22 +1729,20 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_remove); static struct dev_pm_opp *_opp_get_next(struct opp_table *opp_table, bool dynamic) { - struct dev_pm_opp *opp =3D NULL, *temp; + struct dev_pm_opp *opp; =20 - mutex_lock(&opp_table->lock); - list_for_each_entry(temp, &opp_table->opp_list, node) { + guard(mutex)(&opp_table->lock); + + list_for_each_entry(opp, &opp_table->opp_list, node) { /* * Refcount must be dropped only once for each OPP by OPP core, * do that with help of "removed" flag. */ - if (!temp->removed && dynamic =3D=3D temp->dynamic) { - opp =3D temp; - break; - } + if (!opp->removed && dynamic =3D=3D opp->dynamic) + return opp; } =20 - mutex_unlock(&opp_table->lock); - return opp; + return NULL; } =20 /* @@ -1786,20 +1766,14 @@ static void _opp_remove_all(struct opp_table *opp_t= able, bool dynamic) =20 bool _opp_remove_all_static(struct opp_table *opp_table) { - mutex_lock(&opp_table->lock); - - if (!opp_table->parsed_static_opps) { - mutex_unlock(&opp_table->lock); - return false; - } + scoped_guard(mutex, &opp_table->lock) { + if (!opp_table->parsed_static_opps) + return false; =20 - if (--opp_table->parsed_static_opps) { - mutex_unlock(&opp_table->lock); - return true; + if (--opp_table->parsed_static_opps) + return true; } =20 - mutex_unlock(&opp_table->lock); - _opp_remove_all(opp_table, false); return true; } @@ -2003,17 +1977,15 @@ int _opp_add(struct device *dev, struct dev_pm_opp = *new_opp, struct list_head *head; int ret; =20 - mutex_lock(&opp_table->lock); - head =3D &opp_table->opp_list; + scoped_guard(mutex, &opp_table->lock) { + head =3D &opp_table->opp_list; =20 - ret =3D _opp_is_duplicate(dev, new_opp, opp_table, &head); - if (ret) { - mutex_unlock(&opp_table->lock); - return ret; - } + ret =3D _opp_is_duplicate(dev, new_opp, opp_table, &head); + if (ret) + return ret; =20 - list_add(&new_opp->node, head); - mutex_unlock(&opp_table->lock); + list_add(&new_opp->node, head); + } =20 new_opp->opp_table =3D opp_table; kref_init(&new_opp->kref); @@ -2660,17 +2632,16 @@ struct dev_pm_opp *dev_pm_opp_xlate_required_opp(st= ruct opp_table *src_table, return ERR_PTR(-EBUSY); =20 for (i =3D 0; i < src_table->required_opp_count; i++) { - if (src_table->required_opp_tables[i] =3D=3D dst_table) { - mutex_lock(&src_table->lock); + if (src_table->required_opp_tables[i] !=3D dst_table) + continue; =20 + scoped_guard(mutex, &src_table->lock) { list_for_each_entry(opp, &src_table->opp_list, node) { if (opp =3D=3D src_opp) { dest_opp =3D dev_pm_opp_get(opp->required_opps[i]); break; } } - - mutex_unlock(&src_table->lock); break; } } @@ -2702,7 +2673,6 @@ int dev_pm_opp_xlate_performance_state(struct opp_tab= le *src_table, unsigned int pstate) { struct dev_pm_opp *opp; - int dest_pstate =3D -EINVAL; int i; =20 /* @@ -2736,22 +2706,17 @@ int dev_pm_opp_xlate_performance_state(struct opp_t= able *src_table, return -EINVAL; } =20 - mutex_lock(&src_table->lock); + guard(mutex)(&src_table->lock); =20 list_for_each_entry(opp, &src_table->opp_list, node) { - if (opp->level =3D=3D pstate) { - dest_pstate =3D opp->required_opps[i]->level; - goto unlock; - } + if (opp->level =3D=3D pstate) + return opp->required_opps[i]->level; } =20 pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__, src_table, dst_table); =20 -unlock: - mutex_unlock(&src_table->lock); - - return dest_pstate; + return -EINVAL; } =20 /** @@ -2820,26 +2785,22 @@ static int _opp_set_availability(struct device *dev= , unsigned long freq, if (!assert_single_clk(opp_table, 0)) return -EINVAL; =20 - mutex_lock(&opp_table->lock); + scoped_guard(mutex, &opp_table->lock) { + /* Do we have the frequency? */ + list_for_each_entry(tmp_opp, &opp_table->opp_list, node) { + if (tmp_opp->rates[0] =3D=3D freq) { + opp =3D dev_pm_opp_get(tmp_opp); =20 - /* Do we have the frequency? */ - list_for_each_entry(tmp_opp, &opp_table->opp_list, node) { - if (tmp_opp->rates[0] =3D=3D freq) { - opp =3D dev_pm_opp_get(tmp_opp); + /* Is update really needed? */ + if (opp->available =3D=3D availability_req) + return 0; =20 - /* Is update really needed? */ - if (opp->available =3D=3D availability_req) { - mutex_unlock(&opp_table->lock); - return 0; + opp->available =3D availability_req; + break; } - - opp->available =3D availability_req; - break; } } =20 - mutex_unlock(&opp_table->lock); - if (IS_ERR(opp)) return PTR_ERR(opp); =20 @@ -2886,29 +2847,25 @@ int dev_pm_opp_adjust_voltage(struct device *dev, u= nsigned long freq, if (!assert_single_clk(opp_table, 0)) return -EINVAL; =20 - mutex_lock(&opp_table->lock); - - /* Do we have the frequency? */ - list_for_each_entry(tmp_opp, &opp_table->opp_list, node) { - if (tmp_opp->rates[0] =3D=3D freq) { - opp =3D dev_pm_opp_get(tmp_opp); + scoped_guard(mutex, &opp_table->lock) { + /* Do we have the frequency? */ + list_for_each_entry(tmp_opp, &opp_table->opp_list, node) { + if (tmp_opp->rates[0] =3D=3D freq) { + opp =3D dev_pm_opp_get(tmp_opp); =20 - /* Is update really needed? */ - if (opp->supplies->u_volt =3D=3D u_volt) { - mutex_unlock(&opp_table->lock); - return 0; - } + /* Is update really needed? */ + if (opp->supplies->u_volt =3D=3D u_volt) + return 0; =20 - opp->supplies->u_volt =3D u_volt; - opp->supplies->u_volt_min =3D u_volt_min; - opp->supplies->u_volt_max =3D u_volt_max; + opp->supplies->u_volt =3D u_volt; + opp->supplies->u_volt_min =3D u_volt_min; + opp->supplies->u_volt_max =3D u_volt_max; =20 - break; + break; + } } } =20 - mutex_unlock(&opp_table->lock); - if (IS_ERR(opp)) return PTR_ERR(opp); =20 diff --git a/drivers/opp/cpu.c b/drivers/opp/cpu.c index 330a1753fb22..97989d4fe336 100644 --- a/drivers/opp/cpu.c +++ b/drivers/opp/cpu.c @@ -214,10 +214,9 @@ int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev= , struct cpumask *cpumask) cpumask_clear(cpumask); =20 if (opp_table->shared_opp =3D=3D OPP_TABLE_ACCESS_SHARED) { - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); list_for_each_entry(opp_dev, &opp_table->dev_list, node) cpumask_set_cpu(opp_dev->dev->id, cpumask); - mutex_unlock(&opp_table->lock); } else { cpumask_set_cpu(cpu_dev->id, cpumask); } diff --git a/drivers/opp/of.c b/drivers/opp/of.c index 54109e813d4f..505d79821584 100644 --- a/drivers/opp/of.c +++ b/drivers/opp/of.c @@ -76,18 +76,13 @@ static struct dev_pm_opp *_find_opp_of_np(struct opp_ta= ble *opp_table, { struct dev_pm_opp *opp; =20 - mutex_lock(&opp_table->lock); + guard(mutex)(&opp_table->lock); =20 list_for_each_entry(opp, &opp_table->opp_list, node) { - if (opp->np =3D=3D opp_np) { - dev_pm_opp_get(opp); - mutex_unlock(&opp_table->lock); - return opp; - } + if (opp->np =3D=3D opp_np) + return dev_pm_opp_get(opp); } =20 - mutex_unlock(&opp_table->lock); - return NULL; } =20 @@ -105,19 +100,15 @@ static struct opp_table *_find_table_of_opp_np(struct= device_node *opp_np) =20 opp_table_np =3D of_get_parent(opp_np); if (!opp_table_np) - goto err; + return ERR_PTR(-ENODEV); + + guard(mutex)(&opp_table_lock); =20 - mutex_lock(&opp_table_lock); list_for_each_entry(opp_table, &opp_tables, node) { - if (opp_table_np =3D=3D opp_table->np) { - dev_pm_opp_get_opp_table_ref(opp_table); - mutex_unlock(&opp_table_lock); - return opp_table; - } + if (opp_table_np =3D=3D opp_table->np) + return dev_pm_opp_get_opp_table_ref(opp_table); } - mutex_unlock(&opp_table_lock); =20 -err: return ERR_PTR(-ENODEV); } =20 @@ -142,9 +133,8 @@ static void _opp_table_free_required_tables(struct opp_= table *opp_table) opp_table->required_opp_count =3D 0; opp_table->required_opp_tables =3D NULL; =20 - mutex_lock(&opp_table_lock); + guard(mutex)(&opp_table_lock); list_del(&opp_table->lazy); - mutex_unlock(&opp_table_lock); } =20 /* @@ -201,9 +191,8 @@ static void _opp_table_alloc_required_tables(struct opp= _table *opp_table, * The OPP table is not held while allocating the table, take it * now to avoid corruption to the lazy_opp_tables list. */ - mutex_lock(&opp_table_lock); + guard(mutex)(&opp_table_lock); list_add(&opp_table->lazy, &lazy_opp_tables); - mutex_unlock(&opp_table_lock); } } =20 @@ -357,7 +346,7 @@ static void lazy_link_required_opp_table(struct opp_tab= le *new_table) struct dev_pm_opp *opp; int i, ret; =20 - mutex_lock(&opp_table_lock); + guard(mutex)(&opp_table_lock); =20 list_for_each_entry_safe(opp_table, temp, &lazy_opp_tables, lazy) { struct device_node *opp_np __free(device_node); @@ -408,8 +397,6 @@ static void lazy_link_required_opp_table(struct opp_tab= le *new_table) _required_opps_available(opp, opp_table->required_opp_count); } } - - mutex_unlock(&opp_table_lock); } =20 static int _bandwidth_supported(struct device *dev, struct opp_table *opp_= table) @@ -970,15 +957,14 @@ static int _of_add_opp_table_v2(struct device *dev, s= truct opp_table *opp_table) struct dev_pm_opp *opp; =20 /* OPP table is already initialized for the device */ - mutex_lock(&opp_table->lock); - if (opp_table->parsed_static_opps) { - opp_table->parsed_static_opps++; - mutex_unlock(&opp_table->lock); - return 0; - } + scoped_guard(mutex, &opp_table->lock) { + if (opp_table->parsed_static_opps) { + opp_table->parsed_static_opps++; + return 0; + } =20 - opp_table->parsed_static_opps =3D 1; - mutex_unlock(&opp_table->lock); + opp_table->parsed_static_opps =3D 1; + } =20 /* We have opp-table node now, iterate over it and add OPPs */ for_each_available_child_of_node(opp_table->np, np) { @@ -1018,15 +1004,14 @@ static int _of_add_opp_table_v1(struct device *dev,= struct opp_table *opp_table) const __be32 *val; int nr, ret =3D 0; =20 - mutex_lock(&opp_table->lock); - if (opp_table->parsed_static_opps) { - opp_table->parsed_static_opps++; - mutex_unlock(&opp_table->lock); - return 0; - } + scoped_guard(mutex, &opp_table->lock) { + if (opp_table->parsed_static_opps) { + opp_table->parsed_static_opps++; + return 0; + } =20 - opp_table->parsed_static_opps =3D 1; - mutex_unlock(&opp_table->lock); + opp_table->parsed_static_opps =3D 1; + } =20 prop =3D of_find_property(dev->of_node, "operating-points", NULL); if (!prop) { --=20 2.31.1.272.g89b43f80a514