lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Revert "ALSA: PCM: volume API implementation""

Browse Source
This commit is contained in:
qctecmdr 2020-06-24 10:04:12 -07:00 committed by Gerrit - the friendly Code Review server
commit a25b03139e
3 changed files with 0 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
include/sound/pcm.h
View File

@ -511,10 +511,6 @@ struct snd_pcm_str {
#endif
#endif
struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
#ifdef CONFIG_AUDIO_QGKI
struct snd_kcontrol *vol_kctl; /* volume controls */
struct snd_kcontrol *usr_kctl; /* user controls */
#endif
struct device dev;
};
@ -1431,57 +1427,6 @@ static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)
return 1ULL << (__force int) pcm_format;
}
#ifdef CONFIG_AUDIO_QGKI
#define SND_PCM_ADD_VOLUME_CTL 1
#define SND_PCM_ADD_USR_CTL 1
/*
* PCM Volume control API
*/
/* array element of volume */
struct snd_pcm_volume_elem {
int volume;
};
/* pp information; retrieved via snd_kcontrol_chip() */
struct snd_pcm_volume {
struct snd_pcm *pcm; /* assigned PCM instance */
int stream; /* PLAYBACK or CAPTURE */
struct snd_kcontrol *kctl;
const struct snd_pcm_volume_elem *volume;
int max_length;
void *private_data; /* optional: private data pointer */
};
int snd_pcm_add_volume_ctls(struct snd_pcm *pcm, int stream,
const struct snd_pcm_volume_elem *volume,
int max_length,
unsigned long private_value,
struct snd_pcm_volume **info_ret);
/*
* PCM User control API
*/
/* array element of usr elem */
struct snd_pcm_usr_elem {
int val[128];
};
/* pp information; retrieved via snd_kcontrol_chip() */
struct snd_pcm_usr {
struct snd_pcm *pcm; /* assigned PCM instance */
int stream; /* PLAYBACK or CAPTURE */
struct snd_kcontrol *kctl;
const struct snd_pcm_usr_elem *usr;
int max_length;
void *private_data; /* optional: private data pointer */
};
int snd_pcm_add_usr_ctls(struct snd_pcm *pcm, int stream,
const struct snd_pcm_usr_elem *usr,
int max_length, int max_control_str_len,
unsigned long private_value,
struct snd_pcm_usr **info_ret);
#endif
/* printk helpers */
#define pcm_err(pcm, fmt, args...) \
dev_err((pcm)->card->dev, fmt, ##args)

10
sound/core/pcm.c
View File

@ -816,16 +816,6 @@ static void free_chmap(struct snd_pcm_str *pstr)
snd_ctl_remove(pstr->pcm->card, pstr->chmap_kctl);
pstr->chmap_kctl = NULL;
}
#ifdef CONFIG_AUDIO_QGKI
if (pstr->vol_kctl) {
snd_ctl_remove(pstr->pcm->card, pstr->vol_kctl);
pstr->vol_kctl = NULL;
}
if (pstr->usr_kctl) {
snd_ctl_remove(pstr->pcm->card, pstr->usr_kctl);
pstr->usr_kctl = NULL;
}
#endif
}
static void snd_pcm_free_stream(struct snd_pcm_str * pstr)

190
sound/core/pcm_lib.c
View File

@ -30,11 +30,6 @@
#define trace_applptr(substream, prev, curr)
#endif
#ifdef CONFIG_AUDIO_QGKI
#define STRING_LENGTH_OF_INT 12
#define MAX_USR_CTRL_CNT 128
#endif
static int fill_silence_frames(struct snd_pcm_substream *substream,
snd_pcm_uframes_t off, snd_pcm_uframes_t frames);
@ -2412,26 +2407,6 @@ static void pcm_chmap_ctl_private_free(struct snd_kcontrol *kcontrol)
kfree(info);
}
#ifdef CONFIG_AUDIO_QGKI
static int pcm_volume_ctl_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 0x2000;
return 0;
}
static void pcm_volume_ctl_private_free(struct snd_kcontrol *kcontrol)
{
struct snd_pcm_volume *info = snd_kcontrol_chip(kcontrol);
info->pcm->streams[info->stream].vol_kctl = NULL;
kfree(info);
}
#endif
/**
* snd_pcm_add_chmap_ctls - create channel-mapping control elements
* @pcm: the assigned PCM instance
@ -2493,168 +2468,3 @@ int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream,
return 0;
}
EXPORT_SYMBOL_GPL(snd_pcm_add_chmap_ctls);
#ifdef CONFIG_AUDIO_QGKI
/**
* snd_pcm_add_volume_ctls - create volume control elements
* @pcm: the assigned PCM instance
* @stream: stream direction
* @max_length: the max length of the volume parameter of stream
* @private_value: the value passed to each kcontrol's private_value field
* @info_ret: store struct snd_pcm_volume instance if non-NULL
*
* Create volume control elements assigned to the given PCM stream(s).
* Returns zero if succeed, or a negative error value.
*/
int snd_pcm_add_volume_ctls(struct snd_pcm *pcm, int stream,
const struct snd_pcm_volume_elem *volume,
int max_length,
unsigned long private_value,
struct snd_pcm_volume **info_ret)
{
struct snd_pcm_volume *info;
struct snd_kcontrol_new knew = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
SNDRV_CTL_ELEM_ACCESS_READWRITE,
.info = pcm_volume_ctl_info,
};
int err;
int size;
info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->pcm = pcm;
info->stream = stream;
info->volume = volume;
info->max_length = max_length;
size = sizeof("Playback ") + sizeof(" Volume") +
STRING_LENGTH_OF_INT*sizeof(char) + 1;
knew.name = kzalloc(size, GFP_KERNEL);
if (!knew.name) {
kfree(info);
return -ENOMEM;
}
if (stream == SNDRV_PCM_STREAM_PLAYBACK)
snprintf((char *)knew.name, size, "%s %d %s",
"Playback", pcm->device, "Volume");
else
snprintf((char *)knew.name, size, "%s %d %s",
"Capture", pcm->device, "Volume");
knew.device = pcm->device;
knew.count = pcm->streams[stream].substream_count;
knew.private_value = private_value;
info->kctl = snd_ctl_new1(&knew, info);
if (!info->kctl) {
kfree(info);
kfree(knew.name);
return -ENOMEM;
}
info->kctl->private_free = pcm_volume_ctl_private_free;
err = snd_ctl_add(pcm->card, info->kctl);
if (err < 0) {
kfree(info);
kfree(knew.name);
return -ENOMEM;
}
pcm->streams[stream].vol_kctl = info->kctl;
if (info_ret)
*info_ret = info;
kfree(knew.name);
return 0;
}
EXPORT_SYMBOL(snd_pcm_add_volume_ctls);
static int pcm_usr_ctl_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = MAX_USR_CTRL_CNT;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = INT_MAX;
return 0;
}
static void pcm_usr_ctl_private_free(struct snd_kcontrol *kcontrol)
{
struct snd_pcm_usr *info = snd_kcontrol_chip(kcontrol);
info->pcm->streams[info->stream].usr_kctl = NULL;
kfree(info);
}
/**
* snd_pcm_add_usr_ctls - create user control elements
* @pcm: the assigned PCM instance
* @stream: stream direction
* @max_length: the max length of the user parameter of stream
* @private_value: the value passed to each kcontrol's private_value field
* @info_ret: store struct snd_pcm_usr instance if non-NULL
*
* Create usr control elements assigned to the given PCM stream(s).
* Returns zero if succeed, or a negative error value.
*/
int snd_pcm_add_usr_ctls(struct snd_pcm *pcm, int stream,
const struct snd_pcm_usr_elem *usr,
int max_length, int max_kctrl_str_len,
unsigned long private_value,
struct snd_pcm_usr **info_ret)
{
struct snd_pcm_usr *info;
struct snd_kcontrol_new knew = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
.info = pcm_usr_ctl_info,
};
int err;
char *buf;
info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->pcm = pcm;
info->stream = stream;
info->usr = usr;
info->max_length = max_length;
buf = kzalloc(max_kctrl_str_len, GFP_KERNEL);
if (!buf) {
pr_err("%s: buffer allocation failed\n", __func__);
kfree(info);
return -ENOMEM;
}
knew.name = buf;
if (stream == SNDRV_PCM_STREAM_PLAYBACK)
snprintf(buf, max_kctrl_str_len, "%s %d %s",
"Playback", pcm->device, "User kcontrol");
else
snprintf(buf, max_kctrl_str_len, "%s %d %s",
"Capture", pcm->device, "User kcontrol");
knew.device = pcm->device;
knew.count = pcm->streams[stream].substream_count;
knew.private_value = private_value;
info->kctl = snd_ctl_new1(&knew, info);
if (!info->kctl) {
kfree(info);
kfree(knew.name);
pr_err("%s: snd_ctl_new failed\n", __func__);
return -ENOMEM;
}
info->kctl->private_free = pcm_usr_ctl_private_free;
err = snd_ctl_add(pcm->card, info->kctl);
if (err < 0) {
kfree(info);
kfree(knew.name);
pr_err("%s: snd_ctl_add failed:%d\n", __func__,
err);
return -ENOMEM;
}
pcm->streams[stream].usr_kctl = info->kctl;
if (info_ret)
*info_ret = info;
kfree(knew.name);
return 0;
}
EXPORT_SYMBOL(snd_pcm_add_usr_ctls);
#endif