[PATCH] staging: greybus: change mutexes to guard macros

[PATCH] staging: greybus: change mutexes to guard macros

[Omer PALA]

Convert mutex_lock()/mutex_unlock() pairs to the guard() and
scoped_guard() cleanup helpers where possible. This removes
error-prone goto-based unlock paths and makes it harder to
forget to release a mutex on an early return.

Signed-off-by: Omer PALA <palaomer100@gmail.com>
---
 drivers/staging/greybus/arche-platform.c | 29 +++----
 drivers/staging/greybus/audio_codec.c    | 97 ++++++++++--------------
 drivers/staging/greybus/audio_helper.c   |  3 +-
 drivers/staging/greybus/audio_topology.c | 10 +--
 drivers/staging/greybus/authentication.c | 34 ++++-----
 drivers/staging/greybus/bootrom.c        | 11 ++-
 drivers/staging/greybus/camera.c         | 60 +++++++--------
 drivers/staging/greybus/fw-download.c    | 31 ++++----
 drivers/staging/greybus/fw-management.c  | 38 ++++------
 drivers/staging/greybus/light.c          | 44 +++++------
 drivers/staging/greybus/loopback.c       | 39 +++++-----
 drivers/staging/greybus/power_supply.c   | 42 ++++------
 drivers/staging/greybus/raw.c            | 25 +++---
 drivers/staging/greybus/sdio.c           | 25 +++---
 drivers/staging/greybus/uart.c           | 30 +++-----
 15 files changed, 216 insertions(+), 302 deletions(-)

diff --git a/drivers/staging/greybus/arche-platform.c b/drivers/staging/greybus/arche-platform.c
index de5de59ea..02322fce0 100644
--- a/drivers/staging/greybus/arche-platform.c
+++ b/drivers/staging/greybus/arche-platform.c
@@ -310,20 +310,19 @@ static ssize_t state_store(struct device *dev,
 	struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev);
 	int ret = 0;
 
-	mutex_lock(&arche_pdata->platform_state_mutex);
+	guard(mutex)(&arche_pdata->platform_state_mutex);
 
 	if (sysfs_streq(buf, "off")) {
 		if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF)
-			goto exit;
+			return count;
 
 		/*  If SVC goes down, bring down APB's as well */
 		device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);
 
 		arche_platform_poweroff_seq(arche_pdata);
-
 	} else if (sysfs_streq(buf, "active")) {
 		if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE)
-			goto exit;
+			return count;
 
 		/* First we want to make sure we power off everything
 		 * and then activate back again
@@ -334,16 +333,15 @@ static ssize_t state_store(struct device *dev,
 		arche_platform_wd_irq_en(arche_pdata);
 		ret = arche_platform_coldboot_seq(arche_pdata);
 		if (ret)
-			goto exit;
-
+			return ret;
 	} else if (sysfs_streq(buf, "standby")) {
 		if (arche_pdata->state == ARCHE_PLATFORM_STATE_STANDBY)
-			goto exit;
+			return count;
 
 		dev_warn(arche_pdata->dev, "standby state not supported\n");
 	} else if (sysfs_streq(buf, "fw_flashing")) {
 		if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
-			goto exit;
+			return count;
 
 		/*
 		 * Here we only control SVC.
@@ -356,15 +354,11 @@ static ssize_t state_store(struct device *dev,
 
 		ret = arche_platform_fw_flashing_seq(arche_pdata);
 		if (ret)
-			goto exit;
+			return ret ? ret : count;
 	} else {
 		dev_err(arche_pdata->dev, "unknown state\n");
-		ret = -EINVAL;
+		return -EINVAL;
 	}
-
-exit:
-	mutex_unlock(&arche_pdata->platform_state_mutex);
-	return ret ? ret : count;
 }
 
 static ssize_t state_show(struct device *dev,
@@ -396,7 +390,7 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier,
 			     pm_notifier);
 	int ret = NOTIFY_DONE;
 
-	mutex_lock(&arche_pdata->platform_state_mutex);
+	guard(mutex)(&arche_pdata->platform_state_mutex);
 	switch (pm_event) {
 	case PM_SUSPEND_PREPARE:
 		if (arche_pdata->state != ARCHE_PLATFORM_STATE_ACTIVE) {
@@ -416,7 +410,6 @@ static int arche_platform_pm_notifier(struct notifier_block *notifier,
 	default:
 		break;
 	}
-	mutex_unlock(&arche_pdata->platform_state_mutex);
 
 	return ret;
 }
@@ -530,15 +523,13 @@ static int arche_platform_probe(struct platform_device *pdev)
 
 	/* Explicitly power off if requested */
 	if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) {
-		mutex_lock(&arche_pdata->platform_state_mutex);
+		guard(mutex)(&arche_pdata->platform_state_mutex);
 		ret = arche_platform_coldboot_seq(arche_pdata);
 		if (ret) {
-			mutex_unlock(&arche_pdata->platform_state_mutex);
 			dev_err(dev, "Failed to cold boot svc %d\n", ret);
 			goto err_unregister_pm_notifier;
 		}
 		arche_platform_wd_irq_en(arche_pdata);
-		mutex_unlock(&arche_pdata->platform_state_mutex);
 	}
 
 	dev_info(dev, "Device registered successfully\n");
diff --git a/drivers/staging/greybus/audio_codec.c b/drivers/staging/greybus/audio_codec.c
index 6daa4e706..92d3cd4ae 100644
--- a/drivers/staging/greybus/audio_codec.c
+++ b/drivers/staging/greybus/audio_codec.c
@@ -316,7 +316,7 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec,
 		return -EINVAL;
 	}
 
-	mutex_lock(&codec->lock);
+	guard(mutex)(&codec->lock);
 	if (w->id == snd_soc_dapm_aif_in) {
 		if (enable)
 			ret = gbaudio_module_enable_tx(codec, module, dai_id);
@@ -329,8 +329,6 @@ int gbaudio_module_update(struct gbaudio_codec_info *codec,
 			ret = gbaudio_module_disable_rx(module, dai_id);
 	}
 
-	mutex_unlock(&codec->lock);
-
 	return ret;
 }
 EXPORT_SYMBOL(gbaudio_module_update);
@@ -344,22 +342,19 @@ static int gbcodec_startup(struct snd_pcm_substream *substream,
 	struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 	struct gbaudio_stream_params *params;
 
-	mutex_lock(&codec->lock);
-
-	if (list_empty(&codec->module_list)) {
-		dev_err(codec->dev, "No codec module available\n");
-		mutex_unlock(&codec->lock);
-		return -ENODEV;
-	}
+	scoped_guard(mutex, &codec->lock) {
+		if (list_empty(&codec->module_list)) {
+			dev_err(codec->dev, "No codec module available\n");
+			return -ENODEV;
+		}
 
-	params = find_dai_stream_params(codec, dai->id, substream->stream);
-	if (!params) {
-		dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
-		mutex_unlock(&codec->lock);
-		return -EINVAL;
+		params = find_dai_stream_params(codec, dai->id, substream->stream);
+		if (!params) {
+			dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
+			return -EINVAL;
+		}
+		params->state = GBAUDIO_CODEC_STARTUP;
 	}
-	params->state = GBAUDIO_CODEC_STARTUP;
-	mutex_unlock(&codec->lock);
 	/* to prevent suspend in case of active audio */
 	pm_stay_awake(dai->dev);
 
@@ -372,19 +367,19 @@ static void gbcodec_shutdown(struct snd_pcm_substream *substream,
 	struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 	struct gbaudio_stream_params *params;
 
-	mutex_lock(&codec->lock);
 
-	if (list_empty(&codec->module_list))
-		dev_info(codec->dev, "No codec module available during shutdown\n");
+	scoped_guard(mutex, &codec->lock) {
+		if (list_empty(&codec->module_list))
+			dev_info(codec->dev, "No codec module available during shutdown\n");
 
-	params = find_dai_stream_params(codec, dai->id, substream->stream);
-	if (!params) {
-		dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
-		mutex_unlock(&codec->lock);
-		return;
+		params = find_dai_stream_params(codec, dai->id, substream->stream);
+		if (!params) {
+			dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
+			return;
+		}
+		params->state = GBAUDIO_CODEC_SHUTDOWN;
 	}
-	params->state = GBAUDIO_CODEC_SHUTDOWN;
-	mutex_unlock(&codec->lock);
+
 	pm_relax(dai->dev);
 }
 
@@ -401,11 +396,10 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 	struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
 	struct gbaudio_stream_params *params;
 
-	mutex_lock(&codec->lock);
+	guard(mutex)(&codec->lock);
 
 	if (list_empty(&codec->module_list)) {
 		dev_err(codec->dev, "No codec module available\n");
-		mutex_unlock(&codec->lock);
 		return -ENODEV;
 	}
 
@@ -416,7 +410,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 	if (params_channels(hwparams) != 2) {
 		dev_err(dai->dev, "Invalid channel count:%d\n",
 			params_channels(hwparams));
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 	channels = params_channels(hwparams);
@@ -424,14 +417,12 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 	if (params_rate(hwparams) != 48000) {
 		dev_err(dai->dev, "Invalid sampling rate:%d\n",
 			params_rate(hwparams));
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 	rate = GB_AUDIO_PCM_RATE_48000;
 
 	if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
 		dev_err(dai->dev, "Invalid format:%d\n", params_format(hwparams));
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 	format = GB_AUDIO_PCM_FMT_S16_LE;
@@ -445,21 +436,18 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 
 	if (!data) {
 		dev_err(dai->dev, "DATA connection missing\n");
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 
 	params = find_dai_stream_params(codec, dai->id, substream->stream);
 	if (!params) {
 		dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 
 	bundle = to_gb_bundle(module->dev);
 	ret = gb_pm_runtime_get_sync(bundle);
 	if (ret) {
-		mutex_unlock(&codec->lock);
 		return ret;
 	}
 
@@ -471,7 +459,6 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 		dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
 				    ret);
 		gb_pm_runtime_put_noidle(bundle);
-		mutex_unlock(&codec->lock);
 		return ret;
 	}
 
@@ -488,13 +475,17 @@ static int gbcodec_hw_params(struct snd_pcm_substream *substream,
 	params->channels = channels;
 	params->sig_bits = sig_bits;
 
-	mutex_unlock(&codec->lock);
 	return 0;
 }
 
 static int gbcodec_prepare(struct snd_pcm_substream *substream,
 			   struct snd_soc_dai *dai)
 {
+	/*
+	 * Keep explicit mutex_lock/unlock here instead of guard(mutex)
+	 * to release the lock before calling dev_err_ratelimited() and PM calls.
+	 */
+
 	int ret;
 	struct gbaudio_module_info *module = NULL, *iter;
 	struct gbaudio_data_connection *data;
@@ -572,12 +563,11 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
 	dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
 		stream ? "CAPTURE" : "PLAYBACK");
 
-	mutex_lock(&codec->lock);
+	guard(mutex)(&codec->lock);
 
 	params = find_dai_stream_params(codec, dai->id, stream);
 	if (!params) {
 		dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
-		mutex_unlock(&codec->lock);
 		return -EINVAL;
 	}
 
@@ -589,7 +579,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
 		} else {
 			ret = -ENODEV;
 		}
-		mutex_unlock(&codec->lock);
 		return ret;
 	}
 
@@ -604,14 +593,12 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
 	if (!data) {
 		dev_err(dai->dev, "%s DATA connection missing\n",
 			dai->name);
-		mutex_unlock(&codec->lock);
 		return -ENODEV;
 	}
 
 	bundle = to_gb_bundle(module->dev);
 	ret = gb_pm_runtime_get_sync(bundle);
 	if (ret) {
-		mutex_unlock(&codec->lock);
 		return ret;
 	}
 
@@ -646,7 +633,6 @@ static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
 				    stream ? "Capture" : "Playback", ret);
 
 	gb_pm_runtime_put_noidle(bundle);
-	mutex_unlock(&codec->lock);
 	return ret;
 }
 
@@ -817,19 +803,17 @@ int gbaudio_register_module(struct gbaudio_module_info *module)
 	comp = gbcodec->component;
 	dapm = snd_soc_component_to_dapm(comp);
 
-	mutex_lock(&gbcodec->register_mutex);
+	guard(mutex)(&gbcodec->register_mutex);
 
 	if (module->num_dais) {
 		dev_err(gbcodec->dev,
 			"%d:DAIs not supported via gbcodec driver\n",
 			module->num_dais);
-		mutex_unlock(&gbcodec->register_mutex);
 		return -EINVAL;
 	}
 
 	ret = gbaudio_init_jack(module, comp->card);
 	if (ret) {
-		mutex_unlock(&gbcodec->register_mutex);
 		return ret;
 	}
 
@@ -858,15 +842,14 @@ int gbaudio_register_module(struct gbaudio_module_info *module)
 #endif
 	}
 
-	mutex_lock(&gbcodec->lock);
-	list_add(&module->list, &gbcodec->module_list);
-	mutex_unlock(&gbcodec->lock);
+	scoped_guard(mutex, &gbcodec->lock) {
+		list_add(&module->list, &gbcodec->module_list);
+	}
 
 	if (comp->card->instantiated)
 		ret = snd_soc_dapm_new_widgets(comp->card);
 	dev_dbg(comp->dev, "Registered %s module\n", module->name);
 
-	mutex_unlock(&gbcodec->register_mutex);
 	return ret;
 }
 EXPORT_SYMBOL(gbaudio_register_module);
@@ -939,12 +922,12 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module)
 
 	dev_dbg(comp->dev, "Unregister %s module\n", module->name);
 
-	mutex_lock(&gbcodec->register_mutex);
-	mutex_lock(&gbcodec->lock);
-	gbaudio_codec_cleanup(module);
-	list_del(&module->list);
-	dev_dbg(comp->dev, "Process Unregister %s module\n", module->name);
-	mutex_unlock(&gbcodec->lock);
+	guard(mutex)(&gbcodec->register_mutex);
+	scoped_guard(mutex, &gbcodec->lock) {
+		gbaudio_codec_cleanup(module);
+		list_del(&module->list);
+		dev_dbg(comp->dev, "Process Unregister %s module\n", module->name);
+	}
 
 #ifdef CONFIG_SND_JACK
 	/* free jack devices for this module jack_list */
@@ -991,8 +974,6 @@ void gbaudio_unregister_module(struct gbaudio_module_info *module)
 	}
 
 	dev_dbg(comp->dev, "Unregistered %s module\n", module->name);
-
-	mutex_unlock(&gbcodec->register_mutex);
 }
 EXPORT_SYMBOL(gbaudio_unregister_module);
 
diff --git a/drivers/staging/greybus/audio_helper.c b/drivers/staging/greybus/audio_helper.c
index b4873c6d6..eeb2ca7a5 100644
--- a/drivers/staging/greybus/audio_helper.c
+++ b/drivers/staging/greybus/audio_helper.c
@@ -117,7 +117,7 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm,
 	struct snd_soc_dapm_widget *w, *tmp_w;
 	struct snd_soc_card *card = snd_soc_dapm_to_card(dapm);
 
-	mutex_lock(&card->dapm_mutex);
+	guard(mutex)(&card->dapm_mutex);
 	for (i = 0; i < num; i++) {
 		/* below logic can be optimized to identify widget pointer */
 		w = NULL;
@@ -137,7 +137,6 @@ int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm,
 		widget++;
 		gbaudio_dapm_free_widget(w);
 	}
-	mutex_unlock(&card->dapm_mutex);
 	return 0;
 }
 
diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c
index 76146f91c..295625a48 100644
--- a/drivers/staging/greybus/audio_topology.c
+++ b/drivers/staging/greybus/audio_topology.c
@@ -33,14 +33,12 @@ static struct gbaudio_module_info *find_gb_module(struct gbaudio_codec_info *cod
 
 	dev_dbg(codec->dev, "%s:Find module#%d\n", __func__, dev_id);
 
-	mutex_lock(&codec->lock);
-	list_for_each_entry(module, &codec->module_list, list) {
-		if (module->dev_id == dev_id) {
-			mutex_unlock(&codec->lock);
-			return module;
+	scoped_guard(mutex, &codec->lock) {
+		list_for_each_entry(module, &codec->module_list, list) {
+			if (module->dev_id == dev_id)
+				return module;
 		}
 	}
-	mutex_unlock(&codec->lock);
 	dev_warn(codec->dev, "%s: module#%d missing in codec list\n", name,
 		 dev_id);
 	return NULL;
diff --git a/drivers/staging/greybus/authentication.c b/drivers/staging/greybus/authentication.c
index d8f2cd432..5c0bfc9b0 100644
--- a/drivers/staging/greybus/authentication.c
+++ b/drivers/staging/greybus/authentication.c
@@ -65,20 +65,17 @@ static struct gb_cap *get_cap(struct cdev *cdev)
 {
 	struct gb_cap *cap;
 
-	mutex_lock(&list_mutex);
+	guard(mutex)(&list_mutex);
 
 	list_for_each_entry(cap, &cap_list, node) {
 		if (&cap->cdev == cdev) {
 			kref_get(&cap->kref);
-			goto unlock;
+			return cap;
 		}
 	}
 
 	cap = NULL;
 
-unlock:
-	mutex_unlock(&list_mutex);
-
 	return cap;
 }
 
@@ -276,7 +273,7 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd,
 	 * the connection is getting disconnected, so that we don't start any
 	 * new operations.
 	 */
-	mutex_lock(&cap->mutex);
+	guard(mutex)(&cap->mutex);
 	if (!cap->disabled) {
 		ret = gb_pm_runtime_get_sync(bundle);
 		if (!ret) {
@@ -284,7 +281,6 @@ static long cap_ioctl_unlocked(struct file *file, unsigned int cmd,
 			gb_pm_runtime_put_autosuspend(bundle);
 		}
 	}
-	mutex_unlock(&cap->mutex);
 
 	return ret;
 }
@@ -314,9 +310,9 @@ int gb_cap_connection_init(struct gb_connection *connection)
 	gb_connection_set_data(connection, cap);
 	kref_init(&cap->kref);
 
-	mutex_lock(&list_mutex);
-	list_add(&cap->node, &cap_list);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_add(&cap->node, &cap_list);
+	}
 
 	ret = gb_connection_enable(connection);
 	if (ret)
@@ -353,9 +349,9 @@ int gb_cap_connection_init(struct gb_connection *connection)
 err_connection_disable:
 	gb_connection_disable(connection);
 err_list_del:
-	mutex_lock(&list_mutex);
-	list_del(&cap->node);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_del(&cap->node);
+	}
 
 	put_cap(cap);
 
@@ -379,17 +375,17 @@ void gb_cap_connection_exit(struct gb_connection *connection)
 	 * Disallow any new ioctl operations on the char device and wait for
 	 * existing ones to finish.
 	 */
-	mutex_lock(&cap->mutex);
-	cap->disabled = true;
-	mutex_unlock(&cap->mutex);
+	scoped_guard(mutex, &cap->mutex) {
+		cap->disabled = true;
+	}
 
 	/* All pending greybus operations should have finished by now */
 	gb_connection_disable(cap->connection);
 
 	/* Disallow new users to get access to the cap structure */
-	mutex_lock(&list_mutex);
-	list_del(&cap->node);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_del(&cap->node);
+	}
 
 	/*
 	 * All current users of cap would have taken a reference to it by
diff --git a/drivers/staging/greybus/bootrom.c b/drivers/staging/greybus/bootrom.c
index 83921d90c..923456d6c 100644
--- a/drivers/staging/greybus/bootrom.c
+++ b/drivers/staging/greybus/bootrom.c
@@ -78,9 +78,9 @@ static void gb_bootrom_timedout(struct work_struct *work)
 
 	dev_err(dev, "Timed out waiting for %s from the Module\n", reason);
 
-	mutex_lock(&bootrom->mutex);
-	free_firmware(bootrom);
-	mutex_unlock(&bootrom->mutex);
+	scoped_guard(mutex, &bootrom->mutex) {
+		free_firmware(bootrom);
+	}
 
 	/* TODO: Power-off Module ? */
 }
@@ -240,6 +240,11 @@ static int gb_bootrom_firmware_size_request(struct gb_operation *op)
 
 static int gb_bootrom_get_firmware(struct gb_operation *op)
 {
+	/*
+	 * Keep explicit mutex_lock/unlock here instead of guard(mutex)
+	 * to release the lock before queue_work.
+	 */
+
 	struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
 	const struct firmware *fw;
 	struct gb_bootrom_get_firmware_request *firmware_request;
diff --git a/drivers/staging/greybus/camera.c b/drivers/staging/greybus/camera.c
index 62b55bb28..2edb02a75 100644
--- a/drivers/staging/greybus/camera.c
+++ b/drivers/staging/greybus/camera.c
@@ -490,24 +490,21 @@ static int gb_camera_capabilities(struct gb_camera *gcam,
 	if (ret)
 		return ret;
 
-	mutex_lock(&gcam->mutex);
+	scoped_guard(mutex, &gcam->mutex) {
+		if (!gcam->connection) {
+			ret = -EINVAL;
+			goto done;
+		}
 
-	if (!gcam->connection) {
-		ret = -EINVAL;
-		goto done;
+		ret = gb_camera_operation_sync_flags(gcam->connection,
+						     GB_CAMERA_TYPE_CAPABILITIES,
+						     GB_OPERATION_FLAG_SHORT_RESPONSE,
+						     NULL, 0,
+						     (void *)capabilities, size);
+		if (ret)
+			dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret);
 	}
-
-	ret = gb_camera_operation_sync_flags(gcam->connection,
-					     GB_CAMERA_TYPE_CAPABILITIES,
-					     GB_OPERATION_FLAG_SHORT_RESPONSE,
-					     NULL, 0,
-					     (void *)capabilities, size);
-	if (ret)
-		dev_err(&gcam->bundle->dev, "failed to retrieve capabilities: %d\n", ret);
-
 done:
-	mutex_unlock(&gcam->mutex);
-
 	gb_pm_runtime_put_autosuspend(gcam->bundle);
 
 	return ret;
@@ -519,6 +516,11 @@ static int gb_camera_configure_streams(struct gb_camera *gcam,
 				       struct gb_camera_stream_config *streams,
 				       struct gb_camera_csi_params *csi_params)
 {
+	/*
+	 * Keep explicit mutex_lock/unlock here instead of guard(mutex)
+	 * to release the lock before freeing req and resp.
+	 */
+
 	struct gb_camera_configure_streams_request *req;
 	struct gb_camera_configure_streams_response *resp;
 	unsigned int nstreams = *num_streams;
@@ -668,18 +670,17 @@ static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
 	req->num_frames = cpu_to_le16(num_frames);
 	memcpy(req->settings, settings, settings_size);
 
-	mutex_lock(&gcam->mutex);
+	scoped_guard(mutex, &gcam->mutex) {
+		if (!gcam->connection) {
+			ret = -EINVAL;
+			goto done;
+		}
 
-	if (!gcam->connection) {
-		ret = -EINVAL;
-		goto done;
+		ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
+					req, req_size, NULL, 0);
 	}
 
-	ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
-				req, req_size, NULL, 0);
 done:
-	mutex_unlock(&gcam->mutex);
-
 	kfree(req);
 
 	return ret;
@@ -690,25 +691,21 @@ static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
 	struct gb_camera_flush_response resp;
 	int ret;
 
-	mutex_lock(&gcam->mutex);
+	guard(mutex)(&gcam->mutex);
 
 	if (!gcam->connection) {
-		ret = -EINVAL;
-		goto done;
+		return -EINVAL;
 	}
 
 	ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
 				&resp, sizeof(resp));
 
 	if (ret < 0)
-		goto done;
+		return ret;
 
 	if (request_id)
 		*request_id = le32_to_cpu(resp.request_id);
 
-done:
-	mutex_unlock(&gcam->mutex);
-
 	return ret;
 }
 
@@ -1187,7 +1184,7 @@ static void gb_camera_cleanup(struct gb_camera *gcam)
 {
 	gb_camera_debugfs_cleanup(gcam);
 
-	mutex_lock(&gcam->mutex);
+	guard(mutex)(&gcam->mutex);
 	if (gcam->data_connection) {
 		gb_connection_disable(gcam->data_connection);
 		gb_connection_destroy(gcam->data_connection);
@@ -1199,7 +1196,6 @@ static void gb_camera_cleanup(struct gb_camera *gcam)
 		gb_connection_destroy(gcam->connection);
 		gcam->connection = NULL;
 	}
-	mutex_unlock(&gcam->mutex);
 }
 
 static void gb_camera_release_module(struct kref *ref)
diff --git a/drivers/staging/greybus/fw-download.c b/drivers/staging/greybus/fw-download.c
index a0a683447..a4e2e2361 100644
--- a/drivers/staging/greybus/fw-download.c
+++ b/drivers/staging/greybus/fw-download.c
@@ -93,21 +93,16 @@ static struct fw_request *get_fw_req(struct fw_download *fw_download,
 {
 	struct fw_request *fw_req;
 
-	mutex_lock(&fw_download->mutex);
+	guard(mutex)(&fw_download->mutex);
 
 	list_for_each_entry(fw_req, &fw_download->fw_requests, node) {
 		if (fw_req->firmware_id == firmware_id) {
 			kref_get(&fw_req->kref);
-			goto unlock;
+			return fw_req;
 		}
 	}
 
-	fw_req = NULL;
-
-unlock:
-	mutex_unlock(&fw_download->mutex);
-
-	return fw_req;
+	return NULL;
 }
 
 static void free_firmware(struct fw_download *fw_download,
@@ -117,9 +112,9 @@ static void free_firmware(struct fw_download *fw_download,
 	if (fw_req->disabled)
 		return;
 
-	mutex_lock(&fw_download->mutex);
-	list_del(&fw_req->node);
-	mutex_unlock(&fw_download->mutex);
+	scoped_guard(mutex, &fw_download->mutex) {
+		list_del(&fw_req->node);
+	}
 
 	fw_req->disabled = true;
 	put_fw_req(fw_req);
@@ -197,9 +192,9 @@ static struct fw_request *find_firmware(struct fw_download *fw_download,
 	fw_req->fw_download = fw_download;
 	kref_init(&fw_req->kref);
 
-	mutex_lock(&fw_download->mutex);
-	list_add(&fw_req->node, &fw_download->fw_requests);
-	mutex_unlock(&fw_download->mutex);
+	scoped_guard(mutex, &fw_download->mutex) {
+		list_add(&fw_req->node, &fw_download->fw_requests);
+	}
 
 	/* Timeout, in jiffies, within which firmware should get loaded */
 	req_count = DIV_ROUND_UP(fw_req->fw->size, MIN_FETCH_SIZE);
@@ -448,10 +443,10 @@ void gb_fw_download_connection_exit(struct gb_connection *connection)
 	 * Make sure we have a reference to the pending requests, before they
 	 * are freed from the timeout handler.
 	 */
-	mutex_lock(&fw_download->mutex);
-	list_for_each_entry(fw_req, &fw_download->fw_requests, node)
-		kref_get(&fw_req->kref);
-	mutex_unlock(&fw_download->mutex);
+	scoped_guard(mutex, &fw_download->mutex) {
+		list_for_each_entry(fw_req, &fw_download->fw_requests, node)
+			kref_get(&fw_req->kref);
+	}
 
 	/* Release pending firmware packages */
 	list_for_each_entry_safe(fw_req, tmp, &fw_download->fw_requests, node) {
diff --git a/drivers/staging/greybus/fw-management.c b/drivers/staging/greybus/fw-management.c
index 5d01da6b6..c48bea217 100644
--- a/drivers/staging/greybus/fw-management.c
+++ b/drivers/staging/greybus/fw-management.c
@@ -87,21 +87,16 @@ static struct fw_mgmt *get_fw_mgmt(struct cdev *cdev)
 {
 	struct fw_mgmt *fw_mgmt;
 
-	mutex_lock(&list_mutex);
+	guard(mutex)(&list_mutex);
 
 	list_for_each_entry(fw_mgmt, &fw_mgmt_list, node) {
 		if (&fw_mgmt->cdev == cdev) {
 			kref_get(&fw_mgmt->kref);
-			goto unlock;
+			return fw_mgmt;
 		}
 	}
 
-	fw_mgmt = NULL;
-
-unlock:
-	mutex_unlock(&list_mutex);
-
-	return fw_mgmt;
+	return NULL;
 }
 
 static int fw_mgmt_interface_fw_version_operation(struct fw_mgmt *fw_mgmt,
@@ -533,7 +528,7 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd,
 	 * the connection is getting disconnected, so that we don't start any
 	 * new operations.
 	 */
-	mutex_lock(&fw_mgmt->mutex);
+	guard(mutex)(&fw_mgmt->mutex);
 	if (!fw_mgmt->disabled) {
 		ret = gb_pm_runtime_get_sync(bundle);
 		if (!ret) {
@@ -541,7 +536,6 @@ static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd,
 			gb_pm_runtime_put_autosuspend(bundle);
 		}
 	}
-	mutex_unlock(&fw_mgmt->mutex);
 
 	return ret;
 }
@@ -591,9 +585,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection)
 	mutex_init(&fw_mgmt->mutex);
 	kref_init(&fw_mgmt->kref);
 
-	mutex_lock(&list_mutex);
-	list_add(&fw_mgmt->node, &fw_mgmt_list);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_add(&fw_mgmt->node, &fw_mgmt_list);
+	}
 
 	ret = gb_connection_enable(connection);
 	if (ret)
@@ -631,9 +625,9 @@ int gb_fw_mgmt_connection_init(struct gb_connection *connection)
 err_connection_disable:
 	gb_connection_disable(connection);
 err_list_del:
-	mutex_lock(&list_mutex);
-	list_del(&fw_mgmt->node);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_del(&fw_mgmt->node);
+	}
 
 	put_fw_mgmt(fw_mgmt);
 
@@ -657,17 +651,17 @@ void gb_fw_mgmt_connection_exit(struct gb_connection *connection)
 	 * Disallow any new ioctl operations on the char device and wait for
 	 * existing ones to finish.
 	 */
-	mutex_lock(&fw_mgmt->mutex);
-	fw_mgmt->disabled = true;
-	mutex_unlock(&fw_mgmt->mutex);
+	scoped_guard(mutex, &fw_mgmt->mutex) {
+		fw_mgmt->disabled = true;
+	}
 
 	/* All pending greybus operations should have finished by now */
 	gb_connection_disable(fw_mgmt->connection);
 
 	/* Disallow new users to get access to the fw_mgmt structure */
-	mutex_lock(&list_mutex);
-	list_del(&fw_mgmt->node);
-	mutex_unlock(&list_mutex);
+	scoped_guard(mutex, &list_mutex) {
+		list_del(&fw_mgmt->node);
+	}
 
 	/*
 	 * All current users of fw_mgmt would have taken a reference to it by
diff --git a/drivers/staging/greybus/light.c b/drivers/staging/greybus/light.c
index cab02b5da..83df32aa2 100644
--- a/drivers/staging/greybus/light.c
+++ b/drivers/staging/greybus/light.c
@@ -354,10 +354,10 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel)
 	bool old_active;
 	int ret;
 
-	mutex_lock(&channel->lock);
+	guard(mutex)(&channel->lock);
 	ret = gb_pm_runtime_get_sync(bundle);
 	if (ret < 0)
-		goto out_unlock;
+		return ret;
 
 	old_active = channel->active;
 
@@ -377,7 +377,7 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel)
 
 	/* we need to keep module alive when turning to active state */
 	if (!old_active && channel->active)
-		goto out_unlock;
+		return ret;
 
 	/*
 	 * on the other hand if going to inactive we still hold a reference and
@@ -388,8 +388,6 @@ static int __gb_lights_led_brightness_set(struct gb_channel *channel)
 
 out_pm_put:
 	gb_pm_runtime_put_autosuspend(bundle);
-out_unlock:
-	mutex_unlock(&channel->lock);
 
 	return ret;
 }
@@ -443,10 +441,10 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,
 	if (!delay_on || !delay_off)
 		return -EINVAL;
 
-	mutex_lock(&channel->lock);
+	guard(mutex)(&channel->lock);
 	ret = gb_pm_runtime_get_sync(bundle);
 	if (ret < 0)
-		goto out_unlock;
+		return ret;
 
 	old_active = channel->active;
 
@@ -467,7 +465,7 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,
 
 	/* we need to keep module alive when turning to active state */
 	if (!old_active && channel->active)
-		goto out_unlock;
+		return ret;
 
 	/*
 	 * on the other hand if going to inactive we still hold a reference and
@@ -478,8 +476,6 @@ static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,
 
 out_pm_put:
 	gb_pm_runtime_put_autosuspend(bundle);
-out_unlock:
-	mutex_unlock(&channel->lock);
 
 	return ret;
 }
@@ -1146,15 +1142,14 @@ static int gb_lights_create_all(struct gb_lights *glights)
 	int ret;
 	int i;
 
-	mutex_lock(&glights->lights_lock);
+	guard(mutex)(&glights->lights_lock);
 	ret = gb_lights_get_count(glights);
 	if (ret < 0)
-		goto out;
+		return ret;
 
 	glights->lights = kzalloc_objs(struct gb_light, glights->lights_count);
 	if (!glights->lights) {
-		ret = -ENOMEM;
-		goto out;
+		return -ENOMEM;
 	}
 
 	for (i = 0; i < glights->lights_count; i++) {
@@ -1162,12 +1157,10 @@ static int gb_lights_create_all(struct gb_lights *glights)
 		if (ret < 0) {
 			dev_err(&connection->bundle->dev,
 				"Fail to configure lights device\n");
-			goto out;
+			return ret;
 		}
 	}
 
-out:
-	mutex_unlock(&glights->lights_lock);
 	return ret;
 }
 
@@ -1177,7 +1170,7 @@ static int gb_lights_register_all(struct gb_lights *glights)
 	int ret = 0;
 	int i;
 
-	mutex_lock(&glights->lights_lock);
+	guard(mutex)(&glights->lights_lock);
 	for (i = 0; i < glights->lights_count; i++) {
 		ret = gb_lights_light_register(&glights->lights[i]);
 		if (ret < 0) {
@@ -1187,7 +1180,6 @@ static int gb_lights_register_all(struct gb_lights *glights)
 		}
 	}
 
-	mutex_unlock(&glights->lights_lock);
 	return ret;
 }
 
@@ -1231,14 +1223,14 @@ static int gb_lights_request_handler(struct gb_operation *op)
 	if (event & GB_LIGHTS_LIGHT_CONFIG) {
 		light = &glights->lights[light_id];
 
-		mutex_lock(&glights->lights_lock);
-		gb_lights_light_release(light);
-		ret = gb_lights_light_config(glights, light_id);
-		if (!ret)
-			ret = gb_lights_light_register(light);
-		if (ret < 0)
+		scoped_guard(mutex, &glights->lights_lock) {
 			gb_lights_light_release(light);
-		mutex_unlock(&glights->lights_lock);
+			ret = gb_lights_light_config(glights, light_id);
+			if (!ret)
+				ret = gb_lights_light_register(light);
+			if (ret < 0)
+				gb_lights_light_release(light);
+		}
 	}
 
 	return ret;
diff --git a/drivers/staging/greybus/loopback.c b/drivers/staging/greybus/loopback.c
index 2a623fc2e..2ca6d5c5f 100644
--- a/drivers/staging/greybus/loopback.c
+++ b/drivers/staging/greybus/loopback.c
@@ -406,24 +406,22 @@ static void gb_loopback_async_operation_callback(struct gb_operation *operation)
 	op_async = gb_operation_get_data(operation);
 	gb = op_async->gb;
 
-	mutex_lock(&gb->mutex);
+	scoped_guard(mutex, &gb->mutex) {
+		if (!result && op_async->completion)
+			result = op_async->completion(op_async);
 
-	if (!result && op_async->completion)
-		result = op_async->completion(op_async);
+		if (!result) {
+			gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te);
+		} else {
+			gb->error++;
+			if (result == -ETIMEDOUT)
+				gb->requests_timedout++;
+		}
 
-	if (!result) {
-		gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te);
-	} else {
-		gb->error++;
-		if (result == -ETIMEDOUT)
-			gb->requests_timedout++;
+		gb->iteration_count++;
+		gb_loopback_calculate_stats(gb, result);
 	}
 
-	gb->iteration_count++;
-	gb_loopback_calculate_stats(gb, result);
-
-	mutex_unlock(&gb->mutex);
-
 	dev_dbg(&gb->connection->bundle->dev, "complete operation %d\n",
 		operation->id);
 
@@ -848,7 +846,7 @@ static int gb_loopback_fn(void *data)
 			gb_loopback_async_wait_all(gb);
 
 			/* Mark complete unless user-space has poked us */
-			mutex_lock(&gb->mutex);
+			guard(mutex)(&gb->mutex);
 			if (gb->iteration_count == gb->iteration_max) {
 				gb->type = 0;
 				gb->send_count = 0;
@@ -859,7 +857,6 @@ static int gb_loopback_fn(void *data)
 				dev_dbg(&bundle->dev,
 					"continuing on with new test set\n");
 			}
-			mutex_unlock(&gb->mutex);
 			continue;
 		}
 		size = gb->size;
@@ -919,18 +916,16 @@ static int gb_loopback_dbgfs_latency_show_common(struct seq_file *s,
 	int retval;
 
 	if (kfifo_len(kfifo) == 0) {
-		retval = -EAGAIN;
-		goto done;
+		return -EAGAIN;
 	}
 
-	mutex_lock(mutex);
+	guard(mutex)(mutex);
 	retval = kfifo_out(kfifo, &latency, sizeof(latency));
 	if (retval > 0) {
 		seq_printf(s, "%u", latency);
-		retval = 0;
+		return 0;
 	}
-	mutex_unlock(mutex);
-done:
+
 	return retval;
 }
 
diff --git a/drivers/staging/greybus/power_supply.c b/drivers/staging/greybus/power_supply.c
index 44bd8a72f..5df14315f 100644
--- a/drivers/staging/greybus/power_supply.c
+++ b/drivers/staging/greybus/power_supply.c
@@ -365,7 +365,7 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
 	 * Check gbpsy->pm_acquired to make sure only one pair of 'get_sync'
 	 * and 'put_autosuspend' runtime pm call for state property change.
 	 */
-	mutex_lock(&gbpsy->supply_lock);
+	guard(mutex)(&gbpsy->supply_lock);
 
 	if ((prop->val == GB_POWER_SUPPLY_STATUS_CHARGING) &&
 	    !gbpsy->pm_acquired) {
@@ -385,8 +385,6 @@ static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
 				gbpsy->pm_acquired = false;
 		}
 	}
-
-	mutex_unlock(&gbpsy->supply_lock);
 }
 
 static void check_changed(struct gb_power_supply *gbpsy,
@@ -861,11 +859,11 @@ static void _gb_power_supplies_release(struct gb_power_supplies *supplies)
 	if (!supplies->supply)
 		return;
 
-	mutex_lock(&supplies->supplies_lock);
-	for (i = 0; i < supplies->supplies_count; i++)
-		_gb_power_supply_release(&supplies->supply[i]);
-	kfree(supplies->supply);
-	mutex_unlock(&supplies->supplies_lock);
+	scoped_guard(mutex, &supplies->supplies_lock) {
+		for (i = 0; i < supplies->supplies_count; i++)
+			_gb_power_supply_release(&supplies->supply[i]);
+		kfree(supplies->supply);
+	}
 	kfree(supplies);
 }
 
@@ -935,18 +933,17 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies)
 	int ret;
 	int i;
 
-	mutex_lock(&supplies->supplies_lock);
+	guard(mutex)(&supplies->supplies_lock);
 
 	ret = gb_power_supplies_get_count(supplies);
 	if (ret < 0)
-		goto out;
+		return ret;
 
 	supplies->supply = kzalloc_objs(struct gb_power_supply,
 					supplies->supplies_count);
 
 	if (!supplies->supply) {
-		ret = -ENOMEM;
-		goto out;
+		return -ENOMEM;
 	}
 
 	for (i = 0; i < supplies->supplies_count; i++) {
@@ -954,11 +951,10 @@ static int gb_power_supplies_setup(struct gb_power_supplies *supplies)
 		if (ret < 0) {
 			dev_err(&connection->bundle->dev,
 				"Fail to configure supplies devices\n");
-			goto out;
+			return ret;
 		}
 	}
-out:
-	mutex_unlock(&supplies->supplies_lock);
+
 	return ret;
 }
 
@@ -968,7 +964,7 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies)
 	int ret = 0;
 	int i;
 
-	mutex_lock(&supplies->supplies_lock);
+	guard(mutex)(&supplies->supplies_lock);
 
 	for (i = 0; i < supplies->supplies_count; i++) {
 		ret = gb_power_supply_enable(&supplies->supply[i]);
@@ -979,7 +975,6 @@ static int gb_power_supplies_register(struct gb_power_supplies *supplies)
 		}
 	}
 
-	mutex_unlock(&supplies->supplies_lock);
 	return ret;
 }
 
@@ -992,7 +987,6 @@ static int gb_supplies_request_handler(struct gb_operation *op)
 	struct gb_power_supply_event_request *payload;
 	u8 psy_id;
 	u8 event;
-	int ret = 0;
 
 	if (op->type != GB_POWER_SUPPLY_TYPE_EVENT) {
 		dev_err(&connection->bundle->dev,
@@ -1011,14 +1005,13 @@ static int gb_supplies_request_handler(struct gb_operation *op)
 
 	payload = request->payload;
 	psy_id = payload->psy_id;
-	mutex_lock(&supplies->supplies_lock);
+	guard(mutex)(&supplies->supplies_lock);
 	if (psy_id >= supplies->supplies_count ||
 	    !supplies->supply[psy_id].registered) {
 		dev_err(&connection->bundle->dev,
 			"Event received for unconfigured power_supply id: %d\n",
 			psy_id);
-		ret = -EINVAL;
-		goto out_unlock;
+		return -EINVAL;
 	}
 
 	event = payload->event;
@@ -1028,8 +1021,7 @@ static int gb_supplies_request_handler(struct gb_operation *op)
 	 */
 	gbpsy = &supplies->supply[psy_id];
 	if (!gbpsy->update_interval) {
-		ret = -ESHUTDOWN;
-		goto out_unlock;
+		return -ESHUTDOWN;
 	}
 
 	if (event & GB_POWER_SUPPLY_UPDATE) {
@@ -1042,9 +1034,7 @@ static int gb_supplies_request_handler(struct gb_operation *op)
 		gb_power_supply_status_update(gbpsy);
 	}
 
-out_unlock:
-	mutex_unlock(&supplies->supplies_lock);
-	return ret;
+	return 0;
 }
 
 static int gb_power_supply_probe(struct gb_bundle *bundle,
diff --git a/drivers/staging/greybus/raw.c b/drivers/staging/greybus/raw.c
index 4f1b3f4db..b280b5b75 100644
--- a/drivers/staging/greybus/raw.c
+++ b/drivers/staging/greybus/raw.c
@@ -246,12 +246,12 @@ static void gb_raw_disconnect(struct gb_bundle *bundle)
 	gb_connection_disable(connection);
 	gb_connection_destroy(connection);
 
-	mutex_lock(&raw->list_lock);
-	list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {
-		list_del(&raw_data->entry);
-		kfree(raw_data);
+	scoped_guard(mutex, &raw->list_lock) {
+		list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {
+			list_del(&raw_data->entry);
+			kfree(raw_data);
+		}
 	}
-	mutex_unlock(&raw->list_lock);
 	put_device(&raw->dev);
 }
 
@@ -310,19 +310,16 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count,
 	int retval = 0;
 	struct raw_data *raw_data;
 
-	mutex_lock(&raw->list_lock);
+	guard(mutex)(&raw->list_lock);
 	if (list_empty(&raw->list))
-		goto exit;
+		return 0;
 
 	raw_data = list_first_entry(&raw->list, struct raw_data, entry);
-	if (raw_data->len > count) {
-		retval = -ENOSPC;
-		goto exit;
-	}
+	if (raw_data->len > count)
+		return -ENOSPC;
 
 	if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) {
-		retval = -EFAULT;
-		goto exit;
+		return -EFAULT;
 	}
 
 	list_del(&raw_data->entry);
@@ -330,8 +327,6 @@ static ssize_t raw_read(struct file *file, char __user *buf, size_t count,
 	retval = raw_data->len;
 	kfree(raw_data);
 
-exit:
-	mutex_unlock(&raw->list_lock);
 	return retval;
 }
 
diff --git a/drivers/staging/greybus/sdio.c b/drivers/staging/greybus/sdio.c
index 3952f3d22..316aaeb15 100644
--- a/drivers/staging/greybus/sdio.c
+++ b/drivers/staging/greybus/sdio.c
@@ -597,7 +597,7 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 	u8 drv_type;
 	u32 vdd = 0;
 
-	mutex_lock(&host->lock);
+	guard(mutex)(&host->lock);
 	request.clock = cpu_to_le32(ios->clock);
 
 	if (ios->vdd)
@@ -710,24 +710,19 @@ static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
 	ret = gb_sdio_set_ios(host, &request);
 	if (ret < 0)
-		goto out;
+		return;
 
 	memcpy(&mmc->ios, ios, sizeof(mmc->ios));
-
-out:
-	mutex_unlock(&host->lock);
 }
 
 static int gb_mmc_get_ro(struct mmc_host *mmc)
 {
 	struct gb_sdio_host *host = mmc_priv(mmc);
 
-	mutex_lock(&host->lock);
+	guard(mutex)(&host->lock);
 	if (host->removed) {
-		mutex_unlock(&host->lock);
 		return -ESHUTDOWN;
 	}
-	mutex_unlock(&host->lock);
 
 	return host->read_only;
 }
@@ -736,12 +731,10 @@ static int gb_mmc_get_cd(struct mmc_host *mmc)
 {
 	struct gb_sdio_host *host = mmc_priv(mmc);
 
-	mutex_lock(&host->lock);
+	guard(mutex)(&host->lock);
 	if (host->removed) {
-		mutex_unlock(&host->lock);
 		return -ESHUTDOWN;
 	}
-	mutex_unlock(&host->lock);
 
 	return host->card_present;
 }
@@ -852,11 +845,11 @@ static void gb_sdio_remove(struct gbphy_device *gbphy_dev)
 	if (ret)
 		gbphy_runtime_get_noresume(gbphy_dev);
 
-	mutex_lock(&host->lock);
-	host->removed = true;
-	mmc = host->mmc;
-	gb_connection_set_data(connection, NULL);
-	mutex_unlock(&host->lock);
+	scoped_guard(mutex, &host->lock) {
+		host->removed = true;
+		mmc = host->mmc;
+		gb_connection_set_data(connection, NULL);
+	}
 
 	destroy_workqueue(host->mrq_workqueue);
 	gb_connection_disable_rx(connection);
diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c
index 24b4dab06..e1aa12966 100644
--- a/drivers/staging/greybus/uart.c
+++ b/drivers/staging/greybus/uart.c
@@ -341,19 +341,16 @@ static struct gb_tty *get_gb_by_minor(unsigned int minor)
 {
 	struct gb_tty *gb_tty;
 
-	mutex_lock(&table_lock);
+	guard(mutex)(&table_lock);
 	gb_tty = idr_find(&tty_minors, minor);
 	if (gb_tty) {
-		mutex_lock(&gb_tty->mutex);
+		guard(mutex)(&gb_tty->mutex);
 		if (gb_tty->disconnected) {
-			mutex_unlock(&gb_tty->mutex);
 			gb_tty = NULL;
 		} else {
 			tty_port_get(&gb_tty->port);
-			mutex_unlock(&gb_tty->mutex);
 		}
 	}
-	mutex_unlock(&table_lock);
 	return gb_tty;
 }
 
@@ -361,9 +358,9 @@ static int alloc_minor(struct gb_tty *gb_tty)
 {
 	int minor;
 
-	mutex_lock(&table_lock);
-	minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
-	mutex_unlock(&table_lock);
+	scoped_guard(mutex, &table_lock) {
+		minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
+	}
 	if (minor >= 0)
 		gb_tty->minor = minor;
 	return minor;
@@ -374,9 +371,8 @@ static void release_minor(struct gb_tty *gb_tty)
 	int minor = gb_tty->minor;
 
 	gb_tty->minor = 0;	/* Maybe should use an invalid value instead */
-	mutex_lock(&table_lock);
+	guard(mutex)(&table_lock);
 	idr_remove(&tty_minors, minor);
-	mutex_unlock(&table_lock);
 }
 
 static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty)
@@ -596,13 +592,12 @@ static int get_serial_info(struct tty_struct *tty,
 	struct gb_tty *gb_tty = tty->driver_data;
 
 	ss->line = gb_tty->minor;
-	mutex_lock(&gb_tty->port.mutex);
+	guard(mutex)(&gb_tty->port.mutex);
 	ss->close_delay = jiffies_to_msecs(gb_tty->port.close_delay) / 10;
 	ss->closing_wait =
 		gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 		ASYNC_CLOSING_WAIT_NONE :
 		jiffies_to_msecs(gb_tty->port.closing_wait) / 10;
-	mutex_unlock(&gb_tty->port.mutex);
 
 	return 0;
 }
@@ -620,7 +615,7 @@ static int set_serial_info(struct tty_struct *tty,
 			ASYNC_CLOSING_WAIT_NONE :
 			msecs_to_jiffies(ss->closing_wait * 10);
 
-	mutex_lock(&gb_tty->port.mutex);
+	guard(mutex)(&gb_tty->port.mutex);
 	if (!capable(CAP_SYS_ADMIN)) {
 		if ((close_delay != gb_tty->port.close_delay) ||
 		    (closing_wait != gb_tty->port.closing_wait))
@@ -629,7 +624,6 @@ static int set_serial_info(struct tty_struct *tty,
 		gb_tty->port.close_delay = close_delay;
 		gb_tty->port.closing_wait = closing_wait;
 	}
-	mutex_unlock(&gb_tty->port.mutex);
 	return retval;
 }
 
@@ -926,11 +920,11 @@ static void gb_uart_remove(struct gbphy_device *gbphy_dev)
 	if (ret)
 		gbphy_runtime_get_noresume(gbphy_dev);
 
-	mutex_lock(&gb_tty->mutex);
-	gb_tty->disconnected = true;
+	scoped_guard(mutex, &gb_tty->mutex) {
+		gb_tty->disconnected = true;
 
-	wake_up_all(&gb_tty->wioctl);
-	mutex_unlock(&gb_tty->mutex);
+		wake_up_all(&gb_tty->wioctl);
+	}
 
 	tty_port_tty_vhangup(&gb_tty->port);
 
-- 
2.55.0

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Greg Kroah-Hartman]

On Sun, Sep 20, 2026 at 12:40:54PM +0300, Omer PALA wrote:
> Convert mutex_lock()/mutex_unlock() pairs to the guard() and
> scoped_guard() cleanup helpers where possible. This removes
> error-prone goto-based unlock paths and makes it harder to
> forget to release a mutex on an early return.
> 
> Signed-off-by: Omer PALA <palaomer100@gmail.com>

Did you miss the review comments I made for the previous patch like this
a few hours ago:
	https://lore.kernel.org/all/2026092014-despair-secular-d579@gregkh/
?

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Omer PALA]

Hi Greg,

I thought someone (not you) can allow this.

I want to contribute kernel but i dont know what should i do.

I wrote 3 devicetree schemas, 2 performance fixes, 2 mutex/spinlock
fixes and 1 syntax fix.

All of my work got NAK.

Can you explain me what should i do?

Best Regards,
Omer PALA

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Bradley Morgan]

On 20 September 2026 11:37:00 BST, Omer PALA <palaomer100@gmail.com> wrote:
>Hi Greg,
>
>I thought someone (not you) can allow this.
>
>I want to contribute kernel but i dont know what should i do.
>
>I wrote 3 devicetree schemas, 2 performance fixes, 2 mutex/spinlock
>fixes and 1 syntax fix.
>
>All of my work got NAK.
>
>Can you explain me what should i do?
>
>Best Regards,
>Omer PALA

Hi, I don't tend to jump into staging threads, because well I don't do
staging and all that, but I'm sure I can help you here.

From me looking in archives, you tend to use AI tools, which isn't allowed
in staging as of right now.

Staging is a learners playground, not a AI bot bug report thing.

If you need any help you can contact me off list any time you need it, I
do need to start mentoring people....

>
>

--- Thanks!
"I'm not a very positive person" - Linus torvalds

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Greg Kroah-Hartman]

On Sun, Sep 20, 2026 at 01:37:00PM +0300, Omer PALA wrote:
> Hi Greg,
> 
> I thought someone (not you) can allow this.
> 
> I want to contribute kernel but i dont know what should i do.
> 
> I wrote 3 devicetree schemas, 2 performance fixes, 2 mutex/spinlock
> fixes and 1 syntax fix.
> 
> All of my work got NAK.
> 
> Can you explain me what should i do?

Try to contribute "normal" coding style cleanups for staging drivers,
ones that you know will be correct (because you can verify them), and
NOT used with any LLM tool.

thanks,

greg k-h

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Krzysztof Kozlowski]

On 20/09/2026 12:37, Omer PALA wrote:
> Hi Greg,
> 
> I thought someone (not you) can allow this.

So you received feedback from Greg, but tried on different part, hoping
this time it will get accepted?

This looks similar to you previous approaches, e.g. for DT bindings,
where you received comments and repeated the same thing immediately.
Three or four time.

> 
> I want to contribute kernel but i dont know what should i do.

I suggest spend some time to actually read the archives when people
point it.


> 
> I wrote 3 devicetree schemas, 2 performance fixes, 2 mutex/spinlock
> fixes and 1 syntax fix.
> 
> All of my work got NAK.

One was pure AI slop, so what did you expect exactly? In all channels,
fediverse, some technological news, open source projects complain about
sent slop, they reject it and treat it as one of biggest time wasting
thing contributor could do. It is not like we hide it, right? Actually
opposite, everywhere we scream - don't send vibe coded stuff. And for
learning or beginning this is even unacceptable waste of your time,
because you will learn nothing. I was raising it for GSoC for example
more than once and it is documented in their rules.

> 
> Can you explain me what should i do?

One idea would be to read more before you actually contribute.


Best regards,
Krzysztof

Re: [PATCH] staging: greybus: change mutexes to guard macros

[Krzysztof Kozlowski]

On 20/09/2026 15:22, Krzysztof Kozlowski wrote:
> On 20/09/2026 12:37, Omer PALA wrote:
>> Hi Greg,
>>
>> I thought someone (not you) can allow this.
> 
> So you received feedback from Greg, but tried on different part, hoping
> this time it will get accepted?
> 
> This looks similar to you previous approaches, e.g. for DT bindings,
> where you received comments and repeated the same thing immediately.
> Three or four time.
> 
>>
>> I want to contribute kernel but i dont know what should i do.
> 
> I suggest spend some time to actually read the archives when people
> point it.
> 
> 
>>
>> I wrote 3 devicetree schemas, 2 performance fixes, 2 mutex/spinlock
>> fixes and 1 syntax fix.
>>
>> All of my work got NAK.
> 
> One was pure AI slop, so what did you expect exactly? In all channels,
> fediverse, some technological news, open source projects complain about
> sent slop, they reject it and treat it as one of biggest time wasting
> thing contributor could do. It is not like we hide it, right? Actually
> opposite, everywhere we scream - don't send vibe coded stuff. And for
> learning or beginning this is even unacceptable waste of your time,
> because you will learn nothing. I was raising it for GSoC for example
> more than once and it is documented in their rules.
> 
>>
>> Can you explain me what should i do?
> 
> One idea would be to read more before you actually contribute.

... and if you even asked your AI like I did now:
"how linux kernel developers look at LLM contributions from beginners?"
I got:

"Linux kernel developers view unverified AI-generated code from
beginners with heavy skepticism and frustration due to a massive influx
of low-quality submissions that overwhelm maintainers."


"Rejection of AI "slop": "

"Staging area bans: Certain high-traffic areas prone to beginner
contributions, such as the kernel's staging drivers (drivers/staging/),
have implemented strict policies forbidding LLM-generated patches ...."

Yet you did exactly what should not be done - were using LLM.

Best regards,
Krzysztof