github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-09 13:44:03 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

ALSA: aloop: Use guard() for mutex locks

Browse Source 
Replace the manual mutex lock/unlock pairs with guard() for code
simplification.

Only code refactoring, and no behavior change.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20250829150026.6379-2-tiwai@suse.de
This commit is contained in:
Takashi Iwai 2025-08-29 17:00:12 +02:00
parent 4b97f8e614
commit ebd9b6c91d
1 changed files with 33 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
sound/drivers/aloop.c
View File

@ -511,13 +511,12 @@ static int loopback_prepare(struct snd_pcm_substream *substream)
dpcm->pcm_salign = salign; dpcm->pcm_salign = salign;
dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size); dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size);
mutex_lock(&dpcm->loopback->cable_lock); guard(mutex)(&dpcm->loopback->cable_lock);
if (!(cable->valid & ~(1 << substream->stream)) || if (!(cable->valid & ~(1 << substream->stream)) ||
(get_setup(dpcm)->notify && (get_setup(dpcm)->notify &&
substream->stream == SNDRV_PCM_STREAM_PLAYBACK)) substream->stream == SNDRV_PCM_STREAM_PLAYBACK))
params_change(substream); params_change(substream);
cable->valid |= 1 << substream->stream; cable->valid |= 1 << substream->stream;
mutex_unlock(&dpcm->loopback->cable_lock);
return 0; return 0;
} }
@ -958,9 +957,8 @@ static int loopback_hw_free(struct snd_pcm_substream *substream)
struct loopback_pcm *dpcm = runtime->private_data; struct loopback_pcm *dpcm = runtime->private_data;
struct loopback_cable *cable = dpcm->cable; struct loopback_cable *cable = dpcm->cable;
mutex_lock(&dpcm->loopback->cable_lock); guard(mutex)(&dpcm->loopback->cable_lock);
cable->valid &= ~(1 << substream->stream); cable->valid &= ~(1 << substream->stream);
mutex_unlock(&dpcm->loopback->cable_lock);
return 0; return 0;
} }
@ -980,10 +978,10 @@ static int rule_format(struct snd_pcm_hw_params *params,
struct snd_mask m; struct snd_mask m;
snd_mask_none(&m); snd_mask_none(&m);
mutex_lock(&dpcm->loopback->cable_lock); scoped_guard(mutex, &dpcm->loopback->cable_lock) {
m.bits[0] = (u_int32_t)cable->hw.formats; m.bits[0] = (u_int32_t)cable->hw.formats;
m.bits[1] = (u_int32_t)(cable->hw.formats >> 32); m.bits[1] = (u_int32_t)(cable->hw.formats >> 32);
mutex_unlock(&dpcm->loopback->cable_lock); }
return snd_mask_refine(hw_param_mask(params, rule->var), &m); return snd_mask_refine(hw_param_mask(params, rule->var), &m);
} }
@ -994,10 +992,10 @@ static int rule_rate(struct snd_pcm_hw_params *params,
struct loopback_cable *cable = dpcm->cable; struct loopback_cable *cable = dpcm->cable;
struct snd_interval t; struct snd_interval t;
mutex_lock(&dpcm->loopback->cable_lock); scoped_guard(mutex, &dpcm->loopback->cable_lock) {
t.min = cable->hw.rate_min; t.min = cable->hw.rate_min;
t.max = cable->hw.rate_max; t.max = cable->hw.rate_max;
mutex_unlock(&dpcm->loopback->cable_lock); }
t.openmin = t.openmax = 0; t.openmin = t.openmax = 0;
t.integer = 0; t.integer = 0;
return snd_interval_refine(hw_param_interval(params, rule->var), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t);
@ -1010,10 +1008,10 @@ static int rule_channels(struct snd_pcm_hw_params *params,
struct loopback_cable *cable = dpcm->cable; struct loopback_cable *cable = dpcm->cable;
struct snd_interval t; struct snd_interval t;
mutex_lock(&dpcm->loopback->cable_lock); scoped_guard(mutex, &dpcm->loopback->cable_lock) {
t.min = cable->hw.channels_min; t.min = cable->hw.channels_min;
t.max = cable->hw.channels_max; t.max = cable->hw.channels_max;
mutex_unlock(&dpcm->loopback->cable_lock); }
t.openmin = t.openmax = 0; t.openmin = t.openmax = 0;
t.integer = 0; t.integer = 0;
return snd_interval_refine(hw_param_interval(params, rule->var), &t); return snd_interval_refine(hw_param_interval(params, rule->var), &t);
@ -1026,10 +1024,10 @@ static int rule_period_bytes(struct snd_pcm_hw_params *params,
struct loopback_cable *cable = dpcm->cable; struct loopback_cable *cable = dpcm->cable;
struct snd_interval t; struct snd_interval t;
mutex_lock(&dpcm->loopback->cable_lock); scoped_guard(mutex, &dpcm->loopback->cable_lock) {
t.min = cable->hw.period_bytes_min; t.min = cable->hw.period_bytes_min;
t.max = cable->hw.period_bytes_max; t.max = cable->hw.period_bytes_max;
mutex_unlock(&dpcm->loopback->cable_lock); }
t.openmin = 0; t.openmin = 0;
t.openmax = 0; t.openmax = 0;
t.integer = 0; t.integer = 0;
@ -1238,12 +1236,10 @@ static int loopback_open(struct snd_pcm_substream *substream)
int err = 0; int err = 0;
int dev = get_cable_index(substream); int dev = get_cable_index(substream);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
if (!dpcm) { if (!dpcm)
err = -ENOMEM; return -ENOMEM;
goto unlock;
}
dpcm->loopback = loopback; dpcm->loopback = loopback;
dpcm->substream = substream; dpcm->substream = substream;
@ -1326,7 +1322,6 @@ static int loopback_open(struct snd_pcm_substream *substream)
free_cable(substream); free_cable(substream);
kfree(dpcm); kfree(dpcm);
} }
mutex_unlock(&loopback->cable_lock);
return err; return err;
} }
@ -1338,9 +1333,8 @@ static int loopback_close(struct snd_pcm_substream *substream)
if (dpcm->cable->ops->close_substream) if (dpcm->cable->ops->close_substream)
err = dpcm->cable->ops->close_substream(dpcm); err = dpcm->cable->ops->close_substream(dpcm);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
free_cable(substream); free_cable(substream);
mutex_unlock(&loopback->cable_lock);
return err; return err;
} }
@ -1391,11 +1385,10 @@ static int loopback_rate_shift_get(struct snd_kcontrol *kcontrol,
{ {
struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback *loopback = snd_kcontrol_chip(kcontrol);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
ucontrol->value.integer.value[0] = ucontrol->value.integer.value[0] =
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].rate_shift; [kcontrol->id.device].rate_shift;
mutex_unlock(&loopback->cable_lock);
return 0; return 0;
} }
@ -1411,14 +1404,13 @@ static int loopback_rate_shift_put(struct snd_kcontrol *kcontrol,
val = 80000; val = 80000;
if (val > 120000) if (val > 120000)
val = 120000; val = 120000;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
if (val != loopback->setup[kcontrol->id.subdevice] if (val != loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].rate_shift) { [kcontrol->id.device].rate_shift) {
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].rate_shift = val; [kcontrol->id.device].rate_shift = val;
change = 1; change = 1;
} }
mutex_unlock(&loopback->cable_lock);
return change; return change;
} }
@ -1427,11 +1419,10 @@ static int loopback_notify_get(struct snd_kcontrol *kcontrol,
{ {
struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback *loopback = snd_kcontrol_chip(kcontrol);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
ucontrol->value.integer.value[0] = ucontrol->value.integer.value[0] =
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].notify; [kcontrol->id.device].notify;
mutex_unlock(&loopback->cable_lock);
return 0; return 0;
} }
@ -1443,14 +1434,13 @@ static int loopback_notify_put(struct snd_kcontrol *kcontrol,
int change = 0; int change = 0;
val = ucontrol->value.integer.value[0] ? 1 : 0; val = ucontrol->value.integer.value[0] ? 1 : 0;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
if (val != loopback->setup[kcontrol->id.subdevice] if (val != loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].notify) { [kcontrol->id.device].notify) {
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].notify = val; [kcontrol->id.device].notify = val;
change = 1; change = 1;
} }
mutex_unlock(&loopback->cable_lock);
return change; return change;
} }
@ -1462,14 +1452,13 @@ static int loopback_active_get(struct snd_kcontrol *kcontrol,
unsigned int val = 0; unsigned int val = 0;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
cable = loopback->cables[kcontrol->id.subdevice][kcontrol->id.device ^ 1]; cable = loopback->cables[kcontrol->id.subdevice][kcontrol->id.device ^ 1];
if (cable != NULL) { if (cable != NULL) {
unsigned int running = cable->running ^ cable->pause; unsigned int running = cable->running ^ cable->pause;
val = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 1 : 0; val = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 1 : 0;
} }
mutex_unlock(&loopback->cable_lock);
ucontrol->value.integer.value[0] = val; ucontrol->value.integer.value[0] = val;
return 0; return 0;
} }
@ -1512,11 +1501,10 @@ static int loopback_rate_get(struct snd_kcontrol *kcontrol,
{ {
struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback *loopback = snd_kcontrol_chip(kcontrol);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
ucontrol->value.integer.value[0] = ucontrol->value.integer.value[0] =
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].rate; [kcontrol->id.device].rate;
mutex_unlock(&loopback->cable_lock);
return 0; return 0;
} }
@ -1536,11 +1524,10 @@ static int loopback_channels_get(struct snd_kcontrol *kcontrol,
{ {
struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback *loopback = snd_kcontrol_chip(kcontrol);
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
ucontrol->value.integer.value[0] = ucontrol->value.integer.value[0] =
loopback->setup[kcontrol->id.subdevice] loopback->setup[kcontrol->id.subdevice]
[kcontrol->id.device].channels; [kcontrol->id.device].channels;
mutex_unlock(&loopback->cable_lock);
return 0; return 0;
} }
@ -1558,12 +1545,11 @@ static int loopback_access_get(struct snd_kcontrol *kcontrol,
struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback *loopback = snd_kcontrol_chip(kcontrol);
snd_pcm_access_t access; snd_pcm_access_t access;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
access = loopback->setup[kcontrol->id.subdevice][kcontrol->id.device].access; access = loopback->setup[kcontrol->id.subdevice][kcontrol->id.device].access;
ucontrol->value.enumerated.item[0] = !is_access_interleaved(access); ucontrol->value.enumerated.item[0] = !is_access_interleaved(access);
mutex_unlock(&loopback->cable_lock);
return 0; return 0;
} }
@ -1731,12 +1717,11 @@ static void print_cable_info(struct snd_info_entry *entry,
struct loopback *loopback = entry->private_data; struct loopback *loopback = entry->private_data;
int sub, num; int sub, num;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
num = entry->name[strlen(entry->name)-1]; num = entry->name[strlen(entry->name)-1];
num = num == '0' ? 0 : 1; num = num == '0' ? 0 : 1;
for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++) for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++)
print_substream_info(buffer, loopback, sub, num); print_substream_info(buffer, loopback, sub, num);
mutex_unlock(&loopback->cable_lock);
} }
static int loopback_cable_proc_new(struct loopback *loopback, int cidx) static int loopback_cable_proc_new(struct loopback *loopback, int cidx)
@ -1765,10 +1750,9 @@ static void print_timer_source_info(struct snd_info_entry *entry,
{ {
struct loopback *loopback = entry->private_data; struct loopback *loopback = entry->private_data;
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
snd_iprintf(buffer, "%s\n", snd_iprintf(buffer, "%s\n",
loopback->timer_source ? loopback->timer_source : ""); loopback->timer_source ? loopback->timer_source : "");
mutex_unlock(&loopback->cable_lock);
} }
static void change_timer_source_info(struct snd_info_entry *entry, static void change_timer_source_info(struct snd_info_entry *entry,
@ -1777,10 +1761,9 @@ static void change_timer_source_info(struct snd_info_entry *entry,
struct loopback *loopback = entry->private_data; struct loopback *loopback = entry->private_data;
char line[64]; char line[64];
mutex_lock(&loopback->cable_lock); guard(mutex)(&loopback->cable_lock);
if (!snd_info_get_line(buffer, line, sizeof(line))) if (!snd_info_get_line(buffer, line, sizeof(line)))
loopback_set_timer_source(loopback, strim(line)); loopback_set_timer_source(loopback, strim(line));
mutex_unlock(&loopback->cable_lock);
} }
static int loopback_timer_source_proc_new(struct loopback *loopback) static int loopback_timer_source_proc_new(struct loopback *loopback)