Merge "Revert "ALSA: PCM: volume API implementation"" (a25b0313) · Commits · e / devices / android_kernel_fairphone_FP5

include/sound/pcm.h

+0 −55

Original line number	Diff line number	Diff line
		@@ -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)

sound/core/pcm.c

+0 −10

Original line number	Diff line number	Diff line
		@@ -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)

sound/core/pcm_lib.c

+0 −190

Original line number	Diff line number	Diff line
		@@ -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