mirror of
https://github.com/torvalds/linux.git
synced 2026-05-30 18:13:41 +02:00
ALSA: hda/common: Use guard() for mutex locks
Replace the manual mutex lock/unlock pairs with guard(). Only code refactoring, and no behavior change. Signed-off-by: Takashi Iwai <tiwai@suse.de> Link: https://patch.msgid.link/20250827072916.31933-8-tiwai@suse.de
This commit is contained in:
Takashi Iwai
parent
a23160c879
commit
62dd3851d2
|
|
@ -39,13 +39,12 @@ static int call_exec_verb(struct hda_bus *bus, struct hda_codec *codec,
|
|||
int err;
|
||||
|
||||
CLASS(snd_hda_power_pm, pm)(codec);
|
||||
mutex_lock(&bus->core.cmd_mutex);
|
||||
guard(mutex)(&bus->core.cmd_mutex);
|
||||
if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
|
||||
bus->no_response_fallback = 1;
|
||||
err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
|
||||
cmd, res);
|
||||
bus->no_response_fallback = 0;
|
||||
mutex_unlock(&bus->core.cmd_mutex);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -531,11 +530,11 @@ unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
|
|||
#ifdef CONFIG_SND_HDA_RECONFIG
|
||||
{
|
||||
unsigned int cfg = 0;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
pin = look_up_pincfg(codec, &codec->user_pins, nid);
|
||||
if (pin)
|
||||
cfg = pin->cfg;
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
scoped_guard(mutex, &codec->user_mutex) {
|
||||
pin = look_up_pincfg(codec, &codec->user_pins, nid);
|
||||
if (pin)
|
||||
cfg = pin->cfg;
|
||||
}
|
||||
if (cfg)
|
||||
return cfg;
|
||||
}
|
||||
|
|
@ -2179,13 +2178,12 @@ static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
ucontrol->value.iec958.status[0] = spdif->status & 0xff;
|
||||
ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
|
||||
ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
|
||||
ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -2288,7 +2286,7 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
nid = spdif->nid;
|
||||
spdif->status = ucontrol->value.iec958.status[0] |
|
||||
|
|
@ -2301,7 +2299,6 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
|
|||
spdif->ctls = val;
|
||||
if (change && nid != (u16)-1)
|
||||
set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return change;
|
||||
}
|
||||
|
||||
|
|
@ -2316,10 +2313,9 @@ static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -2346,7 +2342,7 @@ static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
nid = spdif->nid;
|
||||
val = spdif->ctls & ~AC_DIG1_ENABLE;
|
||||
|
|
@ -2356,7 +2352,6 @@ static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
|
|||
spdif->ctls = val;
|
||||
if (change && nid != (u16)-1)
|
||||
set_spdif_ctls(codec, nid, val & 0xff, -1);
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return change;
|
||||
}
|
||||
|
||||
|
|
@ -2501,10 +2496,9 @@ void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
spdif->nid = (u16)-1;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
|
||||
|
||||
|
|
@ -2523,14 +2517,13 @@ void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
|
|||
|
||||
if (WARN_ON(codec->spdif_out.used <= idx))
|
||||
return;
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
if (spdif->nid != nid) {
|
||||
spdif->nid = nid;
|
||||
val = spdif->ctls;
|
||||
set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
|
||||
|
||||
|
|
@ -2605,14 +2598,13 @@ static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
|
|||
unsigned int val = !!ucontrol->value.integer.value[0];
|
||||
int change;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
change = codec->spdif_in_enable != val;
|
||||
if (change) {
|
||||
codec->spdif_in_enable = val;
|
||||
snd_hdac_regmap_write(&codec->core, nid,
|
||||
AC_VERB_SET_DIGI_CONVERT_1, val);
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return change;
|
||||
}
|
||||
|
||||
|
|
@ -3182,7 +3174,8 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
|
|||
struct snd_pcm_substream *substream)
|
||||
{
|
||||
int ret;
|
||||
mutex_lock(&codec->bus->prepare_mutex);
|
||||
|
||||
guard(mutex)(&codec->bus->prepare_mutex);
|
||||
if (hinfo->ops.prepare)
|
||||
ret = hinfo->ops.prepare(hinfo, codec, stream, format,
|
||||
substream);
|
||||
|
|
@ -3190,7 +3183,6 @@ int snd_hda_codec_prepare(struct hda_codec *codec,
|
|||
ret = -ENODEV;
|
||||
if (ret >= 0)
|
||||
purify_inactive_streams(codec);
|
||||
mutex_unlock(&codec->bus->prepare_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
|
||||
|
|
@ -3207,10 +3199,9 @@ void snd_hda_codec_cleanup(struct hda_codec *codec,
|
|||
struct hda_pcm_stream *hinfo,
|
||||
struct snd_pcm_substream *substream)
|
||||
{
|
||||
mutex_lock(&codec->bus->prepare_mutex);
|
||||
guard(mutex)(&codec->bus->prepare_mutex);
|
||||
if (hinfo->ops.cleanup)
|
||||
hinfo->ops.cleanup(hinfo, codec, substream);
|
||||
mutex_unlock(&codec->bus->prepare_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
|
||||
|
||||
|
|
@ -3640,12 +3631,11 @@ static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
|
|||
int snd_hda_multi_out_dig_open(struct hda_codec *codec,
|
||||
struct hda_multi_out *mout)
|
||||
{
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
|
||||
/* already opened as analog dup; reset it once */
|
||||
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
||||
mout->dig_out_used = HDA_DIG_EXCLUSIVE;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
|
||||
|
|
@ -3664,9 +3654,8 @@ int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
|
|||
unsigned int format,
|
||||
struct snd_pcm_substream *substream)
|
||||
{
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
|
||||
|
|
@ -3679,9 +3668,8 @@ EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
|
|||
int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
|
||||
struct hda_multi_out *mout)
|
||||
{
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
|
||||
|
|
@ -3694,9 +3682,8 @@ EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
|
|||
int snd_hda_multi_out_dig_close(struct hda_codec *codec,
|
||||
struct hda_multi_out *mout)
|
||||
{
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
mout->dig_out_used = 0;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
|
||||
|
|
@ -3736,7 +3723,7 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
|
|||
NULL,
|
||||
&mout->spdif_maxbps);
|
||||
}
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
if (mout->share_spdif) {
|
||||
if ((runtime->hw.rates & mout->spdif_rates) &&
|
||||
(runtime->hw.formats & mout->spdif_formats)) {
|
||||
|
|
@ -3749,7 +3736,6 @@ int snd_hda_multi_out_analog_open(struct hda_codec *codec,
|
|||
/* FIXME: need notify? */
|
||||
}
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
return snd_pcm_hw_constraint_step(substream->runtime, 0,
|
||||
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
|
||||
|
|
@ -3778,23 +3764,23 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
|
|||
struct hda_spdif_out *spdif;
|
||||
int i;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
|
||||
if (mout->dig_out_nid && mout->share_spdif &&
|
||||
mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
|
||||
if (chs == 2 && spdif != NULL &&
|
||||
snd_hda_is_supported_format(codec, mout->dig_out_nid,
|
||||
format) &&
|
||||
!(spdif->status & IEC958_AES0_NONAUDIO)) {
|
||||
mout->dig_out_used = HDA_DIG_ANALOG_DUP;
|
||||
setup_dig_out_stream(codec, mout->dig_out_nid,
|
||||
stream_tag, format);
|
||||
} else {
|
||||
mout->dig_out_used = 0;
|
||||
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
||||
scoped_guard(mutex, &codec->spdif_mutex) {
|
||||
spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
|
||||
if (mout->dig_out_nid && mout->share_spdif &&
|
||||
mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
|
||||
if (chs == 2 && spdif != NULL &&
|
||||
snd_hda_is_supported_format(codec, mout->dig_out_nid,
|
||||
format) &&
|
||||
!(spdif->status & IEC958_AES0_NONAUDIO)) {
|
||||
mout->dig_out_used = HDA_DIG_ANALOG_DUP;
|
||||
setup_dig_out_stream(codec, mout->dig_out_nid,
|
||||
stream_tag, format);
|
||||
} else {
|
||||
mout->dig_out_used = 0;
|
||||
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
||||
}
|
||||
}
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
|
||||
/* front */
|
||||
snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
|
||||
|
|
@ -3861,12 +3847,11 @@ int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
|
|||
if (mout->extra_out_nid[i])
|
||||
snd_hda_codec_cleanup_stream(codec,
|
||||
mout->extra_out_nid[i]);
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
guard(mutex)(&codec->spdif_mutex);
|
||||
if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
|
||||
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
||||
mout->dig_out_used = 0;
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
|
||||
|
|
|
|||
|
|
@ -96,12 +96,12 @@ static int azx_pcm_close(struct snd_pcm_substream *substream)
|
|||
struct azx_dev *azx_dev = get_azx_dev(substream);
|
||||
|
||||
trace_azx_pcm_close(chip, azx_dev);
|
||||
mutex_lock(&chip->open_mutex);
|
||||
azx_release_device(azx_dev);
|
||||
if (hinfo->ops.close)
|
||||
hinfo->ops.close(hinfo, apcm->codec, substream);
|
||||
snd_hda_power_down(apcm->codec);
|
||||
mutex_unlock(&chip->open_mutex);
|
||||
scoped_guard(mutex, &chip->open_mutex) {
|
||||
azx_release_device(azx_dev);
|
||||
if (hinfo->ops.close)
|
||||
hinfo->ops.close(hinfo, apcm->codec, substream);
|
||||
snd_hda_power_down(apcm->codec);
|
||||
}
|
||||
snd_hda_codec_pcm_put(apcm->info);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1129,12 +1129,12 @@ static int probe_codec(struct azx *chip, int addr)
|
|||
int err;
|
||||
unsigned int res = -1;
|
||||
|
||||
mutex_lock(&bus->cmd_mutex);
|
||||
chip->probing = 1;
|
||||
azx_send_cmd(bus, cmd);
|
||||
err = azx_get_response(bus, addr, &res);
|
||||
chip->probing = 0;
|
||||
mutex_unlock(&bus->cmd_mutex);
|
||||
scoped_guard(mutex, &bus->cmd_mutex) {
|
||||
chip->probing = 1;
|
||||
azx_send_cmd(bus, cmd);
|
||||
err = azx_get_response(bus, addr, &res);
|
||||
chip->probing = 0;
|
||||
}
|
||||
if (err < 0 || res == -1)
|
||||
return -EIO;
|
||||
dev_dbg(chip->card->dev, "codec #%d probed OK\n", addr);
|
||||
|
|
|
|||
|
|
@ -81,12 +81,12 @@ static ssize_t pin_configs_show(struct hda_codec *codec,
|
|||
{
|
||||
const struct hda_pincfg *pin;
|
||||
int i, len = 0;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
snd_array_for_each(list, i, pin) {
|
||||
len += sysfs_emit_at(buf, len, "0x%02x 0x%08x\n",
|
||||
pin->nid, pin->cfg);
|
||||
}
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return len;
|
||||
}
|
||||
|
||||
|
|
@ -215,12 +215,12 @@ static ssize_t init_verbs_show(struct device *dev,
|
|||
struct hda_codec *codec = dev_get_drvdata(dev);
|
||||
const struct hda_verb *v;
|
||||
int i, len = 0;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
snd_array_for_each(&codec->init_verbs, i, v) {
|
||||
len += sysfs_emit_at(buf, len, "0x%02x 0x%03x 0x%04x\n",
|
||||
v->nid, v->verb, v->param);
|
||||
}
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return len;
|
||||
}
|
||||
|
||||
|
|
@ -233,16 +233,13 @@ static int parse_init_verbs(struct hda_codec *codec, const char *buf)
|
|||
return -EINVAL;
|
||||
if (!nid || !verb)
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
v = snd_array_new(&codec->init_verbs);
|
||||
if (!v) {
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
if (!v)
|
||||
return -ENOMEM;
|
||||
}
|
||||
v->nid = nid;
|
||||
v->verb = verb;
|
||||
v->param = param;
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -264,12 +261,12 @@ static ssize_t hints_show(struct device *dev,
|
|||
struct hda_codec *codec = dev_get_drvdata(dev);
|
||||
const struct hda_hint *hint;
|
||||
int i, len = 0;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
snd_array_for_each(&codec->hints, i, hint) {
|
||||
len += sysfs_emit_at(buf, len, "%s = %s\n",
|
||||
hint->key, hint->val);
|
||||
}
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return len;
|
||||
}
|
||||
|
||||
|
|
@ -324,7 +321,7 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
|
|||
val = skip_spaces(val);
|
||||
remove_trail_spaces(key);
|
||||
remove_trail_spaces(val);
|
||||
mutex_lock(&codec->user_mutex);
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
hint = get_hint(codec, key);
|
||||
if (hint) {
|
||||
/* replace */
|
||||
|
|
@ -345,7 +342,6 @@ static int parse_hints(struct hda_codec *codec, const char *buf)
|
|||
err = -ENOMEM;
|
||||
}
|
||||
unlock:
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
if (err)
|
||||
kfree(key);
|
||||
return err;
|
||||
|
|
@ -372,16 +368,14 @@ static ssize_t user_pin_configs_show(struct device *dev,
|
|||
|
||||
static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)
|
||||
{
|
||||
int nid, cfg, err;
|
||||
int nid, cfg;
|
||||
|
||||
if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
|
||||
return -EINVAL;
|
||||
if (!nid)
|
||||
return -EINVAL;
|
||||
mutex_lock(&codec->user_mutex);
|
||||
err = snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return err;
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
return snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
|
||||
}
|
||||
|
||||
static ssize_t user_pin_configs_store(struct device *dev,
|
||||
|
|
@ -429,26 +423,19 @@ EXPORT_SYMBOL_GPL(snd_hda_get_hint);
|
|||
int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
|
||||
{
|
||||
const char *p;
|
||||
int ret;
|
||||
|
||||
mutex_lock(&codec->user_mutex);
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
p = snd_hda_get_hint(codec, key);
|
||||
if (!p || !*p)
|
||||
ret = -ENOENT;
|
||||
else {
|
||||
switch (toupper(*p)) {
|
||||
case 'T': /* true */
|
||||
case 'Y': /* yes */
|
||||
case '1':
|
||||
ret = 1;
|
||||
break;
|
||||
default:
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
return -ENOENT;
|
||||
switch (toupper(*p)) {
|
||||
case 'T': /* true */
|
||||
case 'Y': /* yes */
|
||||
case '1':
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_bool_hint);
|
||||
|
||||
|
|
@ -466,20 +453,17 @@ int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
|
|||
{
|
||||
const char *p;
|
||||
unsigned long val;
|
||||
int ret;
|
||||
|
||||
mutex_lock(&codec->user_mutex);
|
||||
guard(mutex)(&codec->user_mutex);
|
||||
p = snd_hda_get_hint(codec, key);
|
||||
if (!p)
|
||||
ret = -ENOENT;
|
||||
return -ENOENT;
|
||||
else if (kstrtoul(p, 0, &val))
|
||||
ret = -EINVAL;
|
||||
return -EINVAL;
|
||||
else {
|
||||
*valp = val;
|
||||
ret = 0;
|
||||
return 0;
|
||||
}
|
||||
mutex_unlock(&codec->user_mutex);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_hda_get_int_hint);
|
||||
#endif /* CONFIG_SND_HDA_RECONFIG */
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user