Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1983 insertions, 0 deletions

diff --git a/spa/plugins/alsa/acp/acp.c b/spa/plugins/alsa/acp/acp.c
new file mode 100644
index 0000000..f9985b4
--- /dev/null
+++ b/spa/plugins/alsa/acp/acp.c
@@ -0,0 +1,1983 @@
+/* ALSA Card Profile
+ *
+ * Copyright © 2020 Wim Taymans
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "acp.h"
+#include "alsa-mixer.h"
+#include "alsa-ucm.h"
+
+#include <spa/utils/string.h>
+
+int _acp_log_level = 1;
+acp_log_func _acp_log_func;
+void *_acp_log_data;
+
+struct spa_i18n *acp_i18n;
+
+#define DEFAULT_RATE	48000
+
+#define VOLUME_ACCURACY (PA_VOLUME_NORM/100)  /* don't require volume adjustments to be perfectly correct. don't necessarily extend granularity in software unless the differences get greater than this level */
+
+static const uint32_t channel_table[PA_CHANNEL_POSITION_MAX] = {
+	[PA_CHANNEL_POSITION_MONO] = ACP_CHANNEL_MONO,
+
+	[PA_CHANNEL_POSITION_FRONT_LEFT] = ACP_CHANNEL_FL,
+	[PA_CHANNEL_POSITION_FRONT_RIGHT] = ACP_CHANNEL_FR,
+	[PA_CHANNEL_POSITION_FRONT_CENTER] = ACP_CHANNEL_FC,
+
+	[PA_CHANNEL_POSITION_REAR_CENTER] = ACP_CHANNEL_RC,
+	[PA_CHANNEL_POSITION_REAR_LEFT] = ACP_CHANNEL_RL,
+	[PA_CHANNEL_POSITION_REAR_RIGHT] = ACP_CHANNEL_RR,
+
+	[PA_CHANNEL_POSITION_LFE] = ACP_CHANNEL_LFE,
+	[PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = ACP_CHANNEL_FLC,
+	[PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = ACP_CHANNEL_FRC,
+
+	[PA_CHANNEL_POSITION_SIDE_LEFT] = ACP_CHANNEL_SL,
+	[PA_CHANNEL_POSITION_SIDE_RIGHT] = ACP_CHANNEL_SR,
+
+	[PA_CHANNEL_POSITION_AUX0] = ACP_CHANNEL_START_Aux + 0,
+	[PA_CHANNEL_POSITION_AUX1] = ACP_CHANNEL_START_Aux + 1,
+	[PA_CHANNEL_POSITION_AUX2] = ACP_CHANNEL_START_Aux + 2,
+	[PA_CHANNEL_POSITION_AUX3] = ACP_CHANNEL_START_Aux + 3,
+	[PA_CHANNEL_POSITION_AUX4] = ACP_CHANNEL_START_Aux + 4,
+	[PA_CHANNEL_POSITION_AUX5] = ACP_CHANNEL_START_Aux + 5,
+	[PA_CHANNEL_POSITION_AUX6] = ACP_CHANNEL_START_Aux + 6,
+	[PA_CHANNEL_POSITION_AUX7] = ACP_CHANNEL_START_Aux + 7,
+	[PA_CHANNEL_POSITION_AUX8] = ACP_CHANNEL_START_Aux + 8,
+	[PA_CHANNEL_POSITION_AUX9] = ACP_CHANNEL_START_Aux + 9,
+	[PA_CHANNEL_POSITION_AUX10] = ACP_CHANNEL_START_Aux + 10,
+	[PA_CHANNEL_POSITION_AUX11] = ACP_CHANNEL_START_Aux + 11,
+	[PA_CHANNEL_POSITION_AUX12] = ACP_CHANNEL_START_Aux + 12,
+	[PA_CHANNEL_POSITION_AUX13] = ACP_CHANNEL_START_Aux + 13,
+	[PA_CHANNEL_POSITION_AUX14] = ACP_CHANNEL_START_Aux + 14,
+	[PA_CHANNEL_POSITION_AUX15] = ACP_CHANNEL_START_Aux + 15,
+	[PA_CHANNEL_POSITION_AUX16] = ACP_CHANNEL_START_Aux + 16,
+	[PA_CHANNEL_POSITION_AUX17] = ACP_CHANNEL_START_Aux + 17,
+	[PA_CHANNEL_POSITION_AUX18] = ACP_CHANNEL_START_Aux + 18,
+	[PA_CHANNEL_POSITION_AUX19] = ACP_CHANNEL_START_Aux + 19,
+	[PA_CHANNEL_POSITION_AUX20] = ACP_CHANNEL_START_Aux + 20,
+	[PA_CHANNEL_POSITION_AUX21] = ACP_CHANNEL_START_Aux + 21,
+	[PA_CHANNEL_POSITION_AUX22] = ACP_CHANNEL_START_Aux + 22,
+	[PA_CHANNEL_POSITION_AUX23] = ACP_CHANNEL_START_Aux + 23,
+	[PA_CHANNEL_POSITION_AUX24] = ACP_CHANNEL_START_Aux + 24,
+	[PA_CHANNEL_POSITION_AUX25] = ACP_CHANNEL_START_Aux + 25,
+	[PA_CHANNEL_POSITION_AUX26] = ACP_CHANNEL_START_Aux + 26,
+	[PA_CHANNEL_POSITION_AUX27] = ACP_CHANNEL_START_Aux + 27,
+	[PA_CHANNEL_POSITION_AUX28] = ACP_CHANNEL_START_Aux + 28,
+	[PA_CHANNEL_POSITION_AUX29] = ACP_CHANNEL_START_Aux + 29,
+	[PA_CHANNEL_POSITION_AUX30] = ACP_CHANNEL_START_Aux + 30,
+	[PA_CHANNEL_POSITION_AUX31] = ACP_CHANNEL_START_Aux + 31,
+
+	[PA_CHANNEL_POSITION_TOP_CENTER] = ACP_CHANNEL_TC,
+
+	[PA_CHANNEL_POSITION_TOP_FRONT_LEFT] = ACP_CHANNEL_TFL,
+	[PA_CHANNEL_POSITION_TOP_FRONT_RIGHT] = ACP_CHANNEL_TFR,
+	[PA_CHANNEL_POSITION_TOP_FRONT_CENTER] = ACP_CHANNEL_TFC,
+
+	[PA_CHANNEL_POSITION_TOP_REAR_LEFT] = ACP_CHANNEL_TRL,
+	[PA_CHANNEL_POSITION_TOP_REAR_RIGHT] = ACP_CHANNEL_TRR,
+	[PA_CHANNEL_POSITION_TOP_REAR_CENTER] = ACP_CHANNEL_TRC,
+};
+
+static const char *channel_names[] = {
+	[ACP_CHANNEL_UNKNOWN] = "UNK",
+	[ACP_CHANNEL_NA] = "NA",
+	[ACP_CHANNEL_MONO] = "MONO",
+	[ACP_CHANNEL_FL] = "FL",
+	[ACP_CHANNEL_FR] = "FR",
+	[ACP_CHANNEL_FC] = "FC",
+	[ACP_CHANNEL_LFE] = "LFE",
+	[ACP_CHANNEL_SL] = "SL",
+	[ACP_CHANNEL_SR] = "SR",
+	[ACP_CHANNEL_FLC] = "FLC",
+	[ACP_CHANNEL_FRC] = "FRC",
+	[ACP_CHANNEL_RC] = "RC",
+	[ACP_CHANNEL_RL] = "RL",
+	[ACP_CHANNEL_RR] = "RR",
+	[ACP_CHANNEL_TC] = "TC",
+	[ACP_CHANNEL_TFL] = "TFL",
+	[ACP_CHANNEL_TFC] = "TFC",
+	[ACP_CHANNEL_TFR] = "TFR",
+	[ACP_CHANNEL_TRL] = "TRL",
+	[ACP_CHANNEL_TRC] = "TRC",
+	[ACP_CHANNEL_TRR] = "TRR",
+	[ACP_CHANNEL_RLC] = "RLC",
+	[ACP_CHANNEL_RRC] = "RRC",
+	[ACP_CHANNEL_FLW] = "FLW",
+	[ACP_CHANNEL_FRW] = "FRW",
+	[ACP_CHANNEL_LFE2] = "LFE2",
+	[ACP_CHANNEL_FLH] = "FLH",
+	[ACP_CHANNEL_FCH] = "FCH",
+	[ACP_CHANNEL_FRH] = "FRH",
+	[ACP_CHANNEL_TFLC] = "TFLC",
+	[ACP_CHANNEL_TFRC] = "TFRC",
+	[ACP_CHANNEL_TSL] = "TSL",
+	[ACP_CHANNEL_TSR] = "TSR",
+	[ACP_CHANNEL_LLFE] = "LLFE",
+	[ACP_CHANNEL_RLFE] = "RLFE",
+	[ACP_CHANNEL_BC] = "BC",
+	[ACP_CHANNEL_BLC] = "BLC",
+	[ACP_CHANNEL_BRC] = "BRC",
+};
+
+#define ACP_N_ELEMENTS(arr)	(sizeof(arr) / sizeof((arr)[0]))
+
+static inline uint32_t channel_pa2acp(pa_channel_position_t channel)
+{
+	if (channel < 0 || (size_t)channel >= ACP_N_ELEMENTS(channel_table))
+		return ACP_CHANNEL_UNKNOWN;
+	return channel_table[channel];
+}
+
+char *acp_channel_str(char *buf, size_t len, enum acp_channel ch)
+{
+	if (ch >= ACP_CHANNEL_START_Aux && ch <= ACP_CHANNEL_LAST_Aux) {
+		snprintf(buf, len, "AUX%d", ch - ACP_CHANNEL_START_Aux);
+	} else if (ch >= ACP_CHANNEL_UNKNOWN && ch <= ACP_CHANNEL_BRC) {
+		snprintf(buf, len, "%s", channel_names[ch]);
+	} else {
+		snprintf(buf, len, "UNK");
+	}
+	return buf;
+}
+
+
+const char *acp_available_str(enum acp_available status)
+{
+	switch (status) {
+	case ACP_AVAILABLE_UNKNOWN:
+		return "unknown";
+	case ACP_AVAILABLE_NO:
+		return "no";
+	case ACP_AVAILABLE_YES:
+		return "yes";
+	}
+	return "error";
+}
+
+const char *acp_direction_str(enum acp_direction direction)
+{
+	switch (direction) {
+	case ACP_DIRECTION_CAPTURE:
+		return "capture";
+	case ACP_DIRECTION_PLAYBACK:
+		return "playback";
+	}
+	return "error";
+}
+
+static void port_free(void *data)
+{
+	pa_device_port *dp = data;
+	pa_dynarray_clear(&dp->devices);
+	pa_dynarray_clear(&dp->prof);
+	pa_device_port_free(dp);
+}
+
+static void device_free(void *data)
+{
+	pa_alsa_device *dev = data;
+	pa_dynarray_clear(&dev->port_array);
+	pa_proplist_free(dev->proplist);
+	pa_hashmap_free(dev->ports);
+}
+
+static inline void channelmap_to_acp(pa_channel_map *m, uint32_t *map)
+{
+	uint32_t i, j;
+	for (i = 0; i < m->channels; i++) {
+		map[i] = channel_pa2acp(m->map[i]);
+		for (j = 0; j < i; j++) {
+			if (map[i] == map[j])
+				map[i] += 32;
+		}
+
+	}
+}
+
+static void init_device(pa_card *impl, pa_alsa_device *dev, pa_alsa_direction_t direction,
+		pa_alsa_mapping *m, uint32_t index)
+{
+	char **d;
+
+	dev->card = impl;
+	dev->mapping = m;
+	dev->device.index = index;
+	dev->device.name = m->name;
+	dev->device.description = m->description;
+	dev->device.priority = m->priority;
+	dev->device.device_strings = (const char **)m->device_strings;
+	dev->device.format.format_mask = m->sample_spec.format;
+	dev->device.format.rate_mask = m->sample_spec.rate;
+	dev->device.format.channels = m->channel_map.channels;
+	pa_cvolume_reset(&dev->real_volume, dev->device.format.channels);
+	pa_cvolume_reset(&dev->soft_volume, dev->device.format.channels);
+	channelmap_to_acp(&m->channel_map, dev->device.format.map);
+	dev->direction = direction;
+	dev->proplist = pa_proplist_new();
+	pa_proplist_update(dev->proplist, PA_UPDATE_REPLACE, m->proplist);
+	if (direction == PA_ALSA_DIRECTION_OUTPUT) {
+		dev->mixer_path_set = m->output_path_set;
+		dev->pcm_handle = m->output_pcm;
+		dev->device.direction = ACP_DIRECTION_PLAYBACK;
+		pa_proplist_update(dev->proplist, PA_UPDATE_REPLACE, m->output_proplist);
+	} else {
+		dev->mixer_path_set = m->input_path_set;
+		dev->pcm_handle = m->input_pcm;
+		dev->device.direction = ACP_DIRECTION_CAPTURE;
+		pa_proplist_update(dev->proplist, PA_UPDATE_REPLACE, m->input_proplist);
+	}
+	pa_proplist_sets(dev->proplist, PA_PROP_DEVICE_PROFILE_NAME, m->name);
+	pa_proplist_sets(dev->proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, m->description);
+	pa_proplist_setf(dev->proplist, "card.profile.device", "%u", index);
+	pa_proplist_as_dict(dev->proplist, &dev->device.props);
+
+	dev->ports = pa_hashmap_new(pa_idxset_string_hash_func,
+			pa_idxset_string_compare_func);
+	if (m->ucm_context.ucm) {
+		dev->ucm_context = &m->ucm_context;
+		if (impl->ucm.alib_prefix != NULL) {
+			for (d = m->device_strings; *d; d++) {
+				if (pa_startswith(*d, impl->ucm.alib_prefix)) {
+					size_t plen = strlen(impl->ucm.alib_prefix);
+					size_t len = strlen(*d);
+					memmove(*d, (*d) + plen, len - plen + 1);
+					dev->device.flags |= ACP_DEVICE_UCM_DEVICE;
+				}
+			}
+		}
+	}
+	for (d = m->device_strings; *d; d++) {
+		if (pa_startswith(*d, "iec958") ||
+		    pa_startswith(*d, "hdmi"))
+			dev->device.flags |= ACP_DEVICE_IEC958;
+	}
+	pa_dynarray_init(&dev->port_array, NULL);
+}
+
+static int compare_profile(const void *a, const void *b)
+{
+	const pa_hashmap_item *i1 = a;
+	const pa_hashmap_item *i2 = b;
+	const pa_alsa_profile *p1, *p2;
+	if (i1->key == NULL || i2->key == NULL)
+		return 0;
+	p1 = i1->value;
+	p2 = i2->value;
+	if (p1->profile.priority == 0 || p2->profile.priority == 0)
+		return 0;
+	return p2->profile.priority - p1->profile.priority;
+}
+
+static void profile_free(void *data)
+{
+	pa_alsa_profile *ap = data;
+	pa_dynarray_clear(&ap->out.devices);
+	if (ap->profile.flags & ACP_PROFILE_OFF) {
+		free(ap->name);
+		free(ap->description);
+		free(ap);
+	}
+}
+
+static int add_pro_profile(pa_card *impl, uint32_t index)
+{
+	snd_ctl_t *ctl_hndl;
+	int err, dev, count = 0;
+	pa_alsa_profile *ap;
+	pa_alsa_profile_set *ps = impl->profile_set;
+	pa_alsa_mapping *m;
+	char *device;
+	snd_pcm_info_t *pcminfo;
+	pa_sample_spec ss;
+	snd_pcm_uframes_t try_period_size, try_buffer_size;
+
+	ss.format = PA_SAMPLE_S32LE;
+	ss.rate = impl->rate;
+	ss.channels = 64;
+
+	ap = pa_xnew0(pa_alsa_profile, 1);
+	ap->profile_set = ps;
+	ap->profile.name = ap->name = pa_xstrdup("pro-audio");
+	ap->profile.description = ap->description = pa_xstrdup(_("Pro Audio"));
+	ap->profile.available = ACP_AVAILABLE_YES;
+	ap->profile.flags = ACP_PROFILE_PRO;
+	ap->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
+	ap->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
+	pa_hashmap_put(ps->profiles, ap->name, ap);
+
+	ap->output_name = pa_xstrdup("pro-output");
+	ap->input_name = pa_xstrdup("pro-input");
+	ap->priority = 1;
+
+	pa_assert_se(asprintf(&device, "hw:%d", index) >= 0);
+
+	if ((err = snd_ctl_open(&ctl_hndl, device, 0)) < 0) {
+		pa_log_error("can't open control for card %s: %s",
+				device, snd_strerror(err));
+	        free(device);
+		return err;
+	}
+	free(device);
+
+	snd_pcm_info_alloca(&pcminfo);
+
+	dev = -1;
+	while (1) {
+		char desc[128], devstr[128], *name;
+
+		if ((err = snd_ctl_pcm_next_device(ctl_hndl, &dev)) < 0) {
+			pa_log_error("error iterating devices: %s", snd_strerror(err));
+			break;
+		}
+		if (dev < 0)
+			break;
+
+		snd_pcm_info_set_device(pcminfo, dev);
+		snd_pcm_info_set_subdevice(pcminfo, 0);
+
+		snprintf(devstr, sizeof(devstr), "hw:%d,%d", index, dev);
+		if (count++ == 0)
+			snprintf(desc, sizeof(desc), "Pro");
+		else
+			snprintf(desc, sizeof(desc), "Pro %d", dev);
+
+		snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_PLAYBACK);
+		if ((err = snd_ctl_pcm_info(ctl_hndl, pcminfo)) < 0) {
+			if (err != -ENOENT)
+				pa_log_error("error pcm info: %s", snd_strerror(err));
+		}
+		if (err >= 0) {
+			pa_assert_se(asprintf(&name, "Mapping pro-output-%d", dev) >= 0);
+			m = pa_alsa_mapping_get(ps, name);
+			m->description = pa_xstrdup(desc);
+			m->device_strings = pa_split_spaces_strv(devstr);
+
+			try_period_size = 1024;
+			try_buffer_size = 1024 * 64;
+			m->sample_spec = ss;
+
+			if ((m->output_pcm = pa_alsa_open_by_template(m->device_strings,
+							devstr, NULL, &m->sample_spec,
+							&m->channel_map, SND_PCM_STREAM_PLAYBACK,
+							&try_period_size, &try_buffer_size,
+							0, NULL, NULL, false))) {
+				pa_alsa_init_proplist_pcm(NULL, m->output_proplist, m->output_pcm);
+				pa_proplist_setf(m->output_proplist, "clock.name", "api.alsa.%u", index);
+				pa_alsa_close(&m->output_pcm);
+				m->supported = true;
+				pa_channel_map_init_auto(&m->channel_map, m->sample_spec.channels, PA_CHANNEL_MAP_AUX);
+			}
+			pa_idxset_put(ap->output_mappings, m, NULL);
+			free(name);
+		}
+
+		snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_CAPTURE);
+		if ((err = snd_ctl_pcm_info(ctl_hndl, pcminfo)) < 0) {
+			if (err != -ENOENT)
+				pa_log_error("error pcm info: %s", snd_strerror(err));
+		}
+		if (err >= 0) {
+			pa_assert_se(asprintf(&name, "Mapping pro-input-%d", dev) >= 0);
+			m = pa_alsa_mapping_get(ps, name);
+			m->description = pa_xstrdup(desc);
+			m->device_strings = pa_split_spaces_strv(devstr);
+
+			try_period_size = 1024;
+			try_buffer_size = 1024 * 64;
+			m->sample_spec = ss;
+
+			if ((m->input_pcm = pa_alsa_open_by_template(m->device_strings,
+							devstr, NULL, &m->sample_spec,
+							&m->channel_map, SND_PCM_STREAM_CAPTURE,
+							&try_period_size, &try_buffer_size,
+							0, NULL, NULL, false))) {
+				pa_alsa_init_proplist_pcm(NULL, m->input_proplist, m->input_pcm);
+				pa_proplist_setf(m->input_proplist, "clock.name", "api.alsa.%u", index);
+				pa_alsa_close(&m->input_pcm);
+				m->supported = true;
+				pa_channel_map_init_auto(&m->channel_map, m->sample_spec.channels, PA_CHANNEL_MAP_AUX);
+			}
+			pa_idxset_put(ap->input_mappings, m, NULL);
+			free(name);
+		}
+	}
+	snd_ctl_close(ctl_hndl);
+
+	return 0;
+}
+
+
+static void add_profiles(pa_card *impl)
+{
+	pa_alsa_profile *ap;
+	void *state;
+	struct acp_card_profile *cp;
+	pa_device_port *dp;
+	pa_alsa_device *dev;
+	int n_profiles, n_ports, n_devices;
+	uint32_t idx;
+
+	n_devices = 0;
+	pa_dynarray_init(&impl->out.devices, device_free);
+
+	ap = pa_xnew0(pa_alsa_profile, 1);
+	ap->profile.name = ap->name = pa_xstrdup("off");
+	ap->profile.description = ap->description = pa_xstrdup(_("Off"));
+	ap->profile.available = ACP_AVAILABLE_YES;
+	ap->profile.flags = ACP_PROFILE_OFF;
+	pa_hashmap_put(impl->profiles, ap->name, ap);
+
+	add_pro_profile(impl, impl->card.index);
+
+	PA_HASHMAP_FOREACH(ap, impl->profile_set->profiles, state) {
+		pa_alsa_mapping *m;
+
+		cp = &ap->profile;
+		cp->name = ap->name;
+		cp->description = ap->description;
+		cp->priority = ap->priority ? ap->priority : 1;
+
+		pa_dynarray_init(&ap->out.devices, NULL);
+
+		if (ap->output_mappings) {
+			PA_IDXSET_FOREACH(m, ap->output_mappings, idx) {
+				dev = &m->output;
+				if (dev->mapping == NULL) {
+					init_device(impl, dev, PA_ALSA_DIRECTION_OUTPUT, m, n_devices++);
+					pa_dynarray_append(&impl->out.devices, dev);
+				}
+				if (impl->use_ucm) {
+					if (m->ucm_context.ucm_devices) {
+						pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context,
+							true, impl->ports, ap, NULL);
+						pa_alsa_ucm_add_ports(&dev->ports, m->proplist, &m->ucm_context,
+							true, impl, dev->pcm_handle, impl->profile_set->ignore_dB);
+					}
+				}
+				else
+					pa_alsa_path_set_add_ports(m->output_path_set, ap, impl->ports,
+							dev->ports, NULL);
+
+				pa_dynarray_append(&ap->out.devices, dev);
+			}
+		}
+
+		if (ap->input_mappings) {
+			PA_IDXSET_FOREACH(m, ap->input_mappings, idx) {
+				dev = &m->input;
+				if (dev->mapping == NULL) {
+					init_device(impl, dev, PA_ALSA_DIRECTION_INPUT, m, n_devices++);
+					pa_dynarray_append(&impl->out.devices, dev);
+				}
+
+				if (impl->use_ucm) {
+					if (m->ucm_context.ucm_devices) {
+						pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context,
+							false, impl->ports, ap, NULL);
+						pa_alsa_ucm_add_ports(&dev->ports, m->proplist, &m->ucm_context,
+							false, impl, dev->pcm_handle, impl->profile_set->ignore_dB);
+					}
+				} else
+					pa_alsa_path_set_add_ports(m->input_path_set, ap, impl->ports,
+							dev->ports, NULL);
+
+				pa_dynarray_append(&ap->out.devices, dev);
+			}
+		}
+		cp->n_devices = pa_dynarray_size(&ap->out.devices);
+		cp->devices = ap->out.devices.array.data;
+		pa_hashmap_put(impl->profiles, ap->name, cp);
+	}
+
+	pa_dynarray_init(&impl->out.ports, NULL);
+	n_ports = 0;
+	PA_HASHMAP_FOREACH(dp, impl->ports, state) {
+		void *state2;
+		dp->card = impl;
+		dp->port.index = n_ports++;
+		dp->port.priority = dp->priority;
+		pa_dynarray_init(&dp->prof, NULL);
+		pa_dynarray_init(&dp->devices, NULL);
+		n_profiles = 0;
+		PA_HASHMAP_FOREACH(cp, dp->profiles, state2) {
+			pa_dynarray_append(&dp->prof, cp);
+			n_profiles++;
+		}
+		dp->port.n_profiles = n_profiles;
+		dp->port.profiles = dp->prof.array.data;
+
+		pa_proplist_setf(dp->proplist, "card.profile.port", "%u", dp->port.index);
+		pa_proplist_as_dict(dp->proplist, &dp->port.props);
+		pa_dynarray_append(&impl->out.ports, dp);
+	}
+	PA_DYNARRAY_FOREACH(dev, &impl->out.devices, idx) {
+		PA_HASHMAP_FOREACH(dp, dev->ports, state) {
+			pa_dynarray_append(&dev->port_array, dp);
+			pa_dynarray_append(&dp->devices, dev);
+		}
+		dev->device.ports = dev->port_array.array.data;
+		dev->device.n_ports = pa_dynarray_size(&dev->port_array);
+	}
+	PA_HASHMAP_FOREACH(dp, impl->ports, state) {
+		dp->port.devices = dp->devices.array.data;
+		dp->port.n_devices = pa_dynarray_size(&dp->devices);
+	}
+
+	pa_hashmap_sort(impl->profiles, compare_profile);
+
+	n_profiles = 0;
+	pa_dynarray_init(&impl->out.profiles, NULL);
+	PA_HASHMAP_FOREACH(cp, impl->profiles, state) {
+		cp->index = n_profiles++;
+		pa_dynarray_append(&impl->out.profiles, cp);
+	}
+}
+
+static pa_available_t calc_port_state(pa_device_port *p, pa_card *impl)
+{
+	void *state;
+	pa_alsa_jack *jack;
+	pa_available_t pa = PA_AVAILABLE_UNKNOWN;
+	pa_device_port *port;
+
+	PA_HASHMAP_FOREACH(jack, impl->jacks, state) {
+		pa_available_t cpa;
+
+		if (impl->use_ucm)
+			port = pa_hashmap_get(impl->ports, jack->name);
+		else {
+			if (jack->path)
+				port = jack->path->port;
+			else
+				continue;
+		}
+
+		if (p != port)
+			continue;
+
+		cpa = jack->plugged_in ? jack->state_plugged : jack->state_unplugged;
+
+		if (cpa == PA_AVAILABLE_NO) {
+			/* If a plugged-in jack causes the availability to go to NO, it
+			* should override all other availability information (like a
+			* blacklist) so set and bail */
+			if (jack->plugged_in) {
+				pa = cpa;
+				break;
+			}
+
+			/* If the current availability is unknown go the more precise no,
+			* but otherwise don't change state */
+			if (pa == PA_AVAILABLE_UNKNOWN)
+				pa = cpa;
+		} else if (cpa == PA_AVAILABLE_YES) {
+			/* Output is available through at least one jack, so go to that
+			* level of availability. We still need to continue iterating through
+			* the jacks in case a jack is plugged in that forces the state to no
+			*/
+			pa = cpa;
+		}
+	}
+	return pa;
+}
+
+static void profile_set_available(pa_card *impl, uint32_t index,
+		enum acp_available status, bool emit)
+{
+	struct acp_card_profile *p = impl->card.profiles[index];
+	enum acp_available old = p->available;
+
+	if (old != status)
+		pa_log_info("Profile %s available %s -> %s", p->name,
+				acp_available_str(old), acp_available_str(status));
+
+	p->available = status;
+
+	if (emit && impl->events && impl->events->profile_available)
+		impl->events->profile_available(impl->user_data, index,
+				old, status);
+}
+
+struct temp_port_avail {
+	pa_device_port *port;
+	pa_available_t avail;
+};
+
+static int report_jack_state(snd_mixer_elem_t *melem, unsigned int mask)
+{
+	pa_card *impl = snd_mixer_elem_get_callback_private(melem);
+	snd_hctl_elem_t *elem = snd_mixer_elem_get_private(melem);
+	snd_ctl_elem_value_t *elem_value;
+	bool plugged_in, any_input_port_available;
+	void *state;
+	pa_alsa_jack *jack;
+	struct temp_port_avail *tp, *tports;
+	pa_alsa_profile *profile;
+	enum acp_available active_available = ACP_AVAILABLE_UNKNOWN;
+	size_t size;
+
+#if 0
+	/* Changing the jack state may cause a port change, and a port change will
+	 * make the sink or source change the mixer settings. If there are multiple
+	 * users having pulseaudio running, the mixer changes done by inactive
+	 * users may mess up the volume settings for the active users, because when
+	 * the inactive users change the mixer settings, those changes are picked
+	 * up by the active user's pulseaudio instance and the changes are
+	 * interpreted as if the active user changed the settings manually e.g.
+	 * with alsamixer. Even single-user systems suffer from this, because gdm
+	 * runs its own pulseaudio instance.
+	 *
+	 * We rerun this function when being unsuspended to catch up on jack state
+	 * changes */
+	if (u->card->suspend_cause & PA_SUSPEND_SESSION)
+		return 0;
+#endif
+
+	if (mask == SND_CTL_EVENT_MASK_REMOVE)
+		return 0;
+
+	snd_ctl_elem_value_alloca(&elem_value);
+	if (snd_hctl_elem_read(elem, elem_value) < 0) {
+		pa_log_warn("Failed to read jack detection from '%s'", pa_strnull(snd_hctl_elem_get_name(elem)));
+		return 0;
+	}
+
+	plugged_in = !!snd_ctl_elem_value_get_boolean(elem_value, 0);
+
+	pa_log_debug("Jack '%s' is now %s", pa_strnull(snd_hctl_elem_get_name(elem)),
+			plugged_in ? "plugged in" : "unplugged");
+
+	size = sizeof(struct temp_port_avail) * (pa_hashmap_size(impl->jacks)+1);
+	tports = tp = alloca(size);
+	memset(tports, 0, size);
+
+	PA_HASHMAP_FOREACH(jack, impl->jacks, state)
+		if (jack->melem == melem) {
+			pa_alsa_jack_set_plugged_in(jack, plugged_in);
+
+			if (impl->use_ucm) {
+				/* When using UCM, pa_alsa_jack_set_plugged_in() maps the jack
+				 * state to port availability. */
+				continue;
+			}
+
+			/* When not using UCM, we have to do the jack state -> port
+			 * availability mapping ourselves. */
+			pa_assert_se(tp->port = jack->path->port);
+			tp->avail = calc_port_state(tp->port, impl);
+			tp++;
+		}
+
+	/* Report available ports before unavailable ones: in case port 1
+	 * becomes available when port 2 becomes unavailable,
+	 * this prevents an unnecessary switch port 1 -> port 3 -> port 2 */
+
+	for (tp = tports; tp->port; tp++)
+		if (tp->avail != PA_AVAILABLE_NO)
+			pa_device_port_set_available(tp->port, tp->avail);
+	for (tp = tports; tp->port; tp++)
+		if (tp->avail == PA_AVAILABLE_NO)
+			pa_device_port_set_available(tp->port, tp->avail);
+
+	for (tp = tports; tp->port; tp++) {
+		pa_alsa_port_data *data;
+
+		data = PA_DEVICE_PORT_DATA(tp->port);
+
+		if (!data->suspend_when_unavailable)
+			continue;
+
+#if 0
+		pa_sink *sink;
+		uint32_t idx;
+		PA_IDXSET_FOREACH(sink, u->core->sinks, idx) {
+			if (sink->active_port == tp->port)
+				pa_sink_suspend(sink, tp->avail == PA_AVAILABLE_NO, PA_SUSPEND_UNAVAILABLE);
+		}
+#endif
+	}
+
+	/* Update profile availabilities. Ideally we would mark all profiles
+	 * unavailable that contain unavailable devices. We can't currently do that
+	 * in all cases, because if there are multiple sinks in a profile, and the
+	 * profile contains a mix of available and unavailable ports, we don't know
+	 * how the ports are distributed between the different sinks. It's possible
+	 * that some sinks contain only unavailable ports, in which case we should
+	 * mark the profile as unavailable, but it's also possible that all sinks
+	 * contain at least one available port, in which case we should mark the
+	 * profile as available. Until the data structures are improved so that we
+	 * can distinguish between these two cases, we mark the problematic cases
+	 * as available (well, "unknown" to be precise, but there's little
+	 * practical difference).
+	 *
+	 * When all output ports are unavailable, we know that all sinks are
+	 * unavailable, and therefore the profile is marked unavailable as well.
+	 * The same applies to input ports as well, of course.
+	 *
+	 * If there are no output ports at all, but the profile contains at least
+	 * one sink, then the output is considered to be available. */
+	if (impl->card.active_profile_index != ACP_INVALID_INDEX)
+		active_available = impl->card.profiles[impl->card.active_profile_index]->available;
+
+	/* First round - detect, if we have any input port available.
+	   If the hardware can report the state for all I/O jacks, only speakers
+	   may be plugged in. */
+	any_input_port_available = false;
+	PA_HASHMAP_FOREACH(profile, impl->profiles, state) {
+		pa_device_port *port;
+		void *state2;
+
+		if (profile->profile.flags & ACP_PROFILE_OFF)
+			continue;
+
+		PA_HASHMAP_FOREACH(port, impl->ports, state2) {
+			if (!pa_hashmap_get(port->profiles, profile->profile.name))
+				continue;
+
+			if (port->port.direction == ACP_DIRECTION_CAPTURE &&
+			    port->port.available != ACP_AVAILABLE_NO) {
+				any_input_port_available = true;
+				goto input_port_found;
+			}
+		}
+	}
+input_port_found:
+
+	/* Second round */
+	PA_HASHMAP_FOREACH(profile, impl->profiles, state) {
+		pa_device_port *port;
+		void *state2;
+		bool has_input_port = false;
+		bool has_output_port = false;
+		bool found_available_input_port = false;
+		bool found_available_output_port = false;
+		enum acp_available available = ACP_AVAILABLE_UNKNOWN;
+
+		if (profile->profile.flags & ACP_PROFILE_OFF)
+			continue;
+
+		PA_HASHMAP_FOREACH(port, impl->ports, state2) {
+			if (!pa_hashmap_get(port->profiles, profile->profile.name))
+				continue;
+
+			if (port->port.direction == ACP_DIRECTION_CAPTURE) {
+				has_input_port = true;
+				if (port->port.available != ACP_AVAILABLE_NO)
+					found_available_input_port = true;
+			} else {
+				has_output_port = true;
+				if (port->port.available != ACP_AVAILABLE_NO)
+					found_available_output_port = true;
+			}
+		}
+
+		if ((has_input_port && !found_available_input_port) ||
+		    (has_output_port && !found_available_output_port))
+			available = ACP_AVAILABLE_NO;
+
+		if (has_input_port && !has_output_port && found_available_input_port)
+			available = ACP_AVAILABLE_YES;
+		if (has_output_port && (!has_input_port || !any_input_port_available) && found_available_output_port)
+			available = ACP_AVAILABLE_YES;
+		if (has_output_port && has_input_port && found_available_output_port && found_available_input_port)
+			available = ACP_AVAILABLE_YES;
+
+		/* We want to update the active profile's status last, so logic that
+		 * may change the active profile based on profile availability status
+		 * has an updated view of all profiles' availabilities. */
+		if (profile->profile.index == impl->card.active_profile_index)
+			active_available = available;
+		else
+			profile_set_available(impl, profile->profile.index, available, false);
+	}
+
+	if (impl->card.active_profile_index != ACP_INVALID_INDEX)
+		profile_set_available(impl, impl->card.active_profile_index, active_available, true);
+
+	return 0;
+}
+
+static void init_jacks(pa_card *impl)
+{
+	void *state;
+	pa_alsa_path* path;
+	pa_alsa_jack* jack;
+	char buf[64];
+
+	impl->jacks = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
+
+	if (impl->use_ucm) {
+		PA_LLIST_FOREACH(jack, impl->ucm.jacks)
+			if (jack->has_control)
+				pa_hashmap_put(impl->jacks, jack, jack);
+	} else {
+		/* See if we have any jacks */
+		if (impl->profile_set->output_paths)
+			PA_HASHMAP_FOREACH(path, impl->profile_set->output_paths, state)
+				PA_LLIST_FOREACH(jack, path->jacks)
+					if (jack->has_control)
+						pa_hashmap_put(impl->jacks, jack, jack);
+
+		if (impl->profile_set->input_paths)
+			PA_HASHMAP_FOREACH(path, impl->profile_set->input_paths, state)
+				PA_LLIST_FOREACH(jack, path->jacks)
+					if (jack->has_control)
+						pa_hashmap_put(impl->jacks, jack, jack);
+	}
+
+	pa_log_debug("Found %d jacks.", pa_hashmap_size(impl->jacks));
+
+	if (pa_hashmap_size(impl->jacks) == 0)
+		return;
+
+	PA_HASHMAP_FOREACH(jack, impl->jacks, state) {
+		if (!jack->mixer_device_name) {
+			jack->mixer_handle = pa_alsa_open_mixer(impl->ucm.mixers, impl->card.index, false);
+			if (!jack->mixer_handle) {
+				pa_log("Failed to open mixer for card %d for jack detection", impl->card.index);
+				continue;
+			}
+		} else {
+			jack->mixer_handle = pa_alsa_open_mixer_by_name(impl->ucm.mixers, jack->mixer_device_name, false);
+			if (!jack->mixer_handle) {
+				pa_log("Failed to open mixer '%s' for jack detection", jack->mixer_device_name);
+				continue;
+			}
+		}
+
+		pa_alsa_mixer_use_for_poll(impl->ucm.mixers, jack->mixer_handle);
+		jack->melem = pa_alsa_mixer_find_card(jack->mixer_handle, &jack->alsa_id, 0);
+		if (!jack->melem) {
+			pa_alsa_mixer_id_to_string(buf, sizeof(buf), &jack->alsa_id);
+			pa_log_warn("Jack '%s' seems to have disappeared.", buf);
+			pa_alsa_jack_set_has_control(jack, false);
+			continue;
+		}
+		snd_mixer_elem_set_callback(jack->melem, report_jack_state);
+		snd_mixer_elem_set_callback_private(jack->melem, impl);
+		report_jack_state(jack->melem, 0);
+	}
+}
+static pa_device_port* find_port_with_eld_device(pa_card *impl, int device)
+{
+	void *state;
+	pa_device_port *p;
+
+	if (impl->use_ucm) {
+		PA_HASHMAP_FOREACH(p, impl->ports, state) {
+			pa_alsa_ucm_port_data *data = PA_DEVICE_PORT_DATA(p);
+			pa_assert(data->eld_mixer_device_name);
+			if (device == data->eld_device)
+				return p;
+		}
+	} else {
+		PA_HASHMAP_FOREACH(p, impl->ports, state) {
+			pa_alsa_port_data *data = PA_DEVICE_PORT_DATA(p);
+			pa_assert(data->path);
+			if (device == data->path->eld_device)
+				return p;
+		}
+	}
+	return NULL;
+}
+
+static int hdmi_eld_changed(snd_mixer_elem_t *melem, unsigned int mask)
+{
+	pa_card *impl = snd_mixer_elem_get_callback_private(melem);
+	snd_hctl_elem_t *elem = snd_mixer_elem_get_private(melem);
+	int device = snd_hctl_elem_get_device(elem);
+	const char *old_monitor_name;
+	pa_device_port *p;
+	pa_hdmi_eld eld;
+	bool changed = false;
+
+	if (mask == SND_CTL_EVENT_MASK_REMOVE)
+		return 0;
+
+	p = find_port_with_eld_device(impl, device);
+	if (p == NULL) {
+		pa_log_error("Invalid device changed in ALSA: %d", device);
+		return 0;
+	}
+
+	if (pa_alsa_get_hdmi_eld(elem, &eld) < 0)
+		memset(&eld, 0, sizeof(eld));
+
+	old_monitor_name = pa_proplist_gets(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME);
+	if (eld.monitor_name[0] == '\0') {
+		changed |= old_monitor_name != NULL;
+		pa_proplist_unset(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME);
+	} else {
+		changed |= (old_monitor_name == NULL) || (!spa_streq(old_monitor_name, eld.monitor_name));
+		pa_proplist_sets(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME, eld.monitor_name);
+	}
+	pa_proplist_as_dict(p->proplist, &p->port.props);
+
+	if (changed && mask != 0 && impl->events && impl->events->props_changed)
+		impl->events->props_changed(impl->user_data);
+	return 0;
+}
+
+static void init_eld_ctls(pa_card *impl)
+{
+	void *state;
+	pa_device_port *port;
+
+	/* The code in this function expects ports to have a pa_alsa_port_data
+	* struct as their data, but in UCM mode ports don't have any data. Hence,
+	* the ELD controls can't currently be used in UCM mode. */
+	PA_HASHMAP_FOREACH(port, impl->ports, state) {
+		snd_mixer_t *mixer_handle;
+		snd_mixer_elem_t* melem;
+		int device;
+
+		if (impl->use_ucm) {
+			pa_alsa_ucm_port_data *data = PA_DEVICE_PORT_DATA(port);
+			device = data->eld_device;
+			if (device < 0 || !data->eld_mixer_device_name)
+				continue;
+
+			mixer_handle = pa_alsa_open_mixer_by_name(impl->ucm.mixers, data->eld_mixer_device_name, true);
+		} else {
+			pa_alsa_port_data *data = PA_DEVICE_PORT_DATA(port);
+
+			pa_assert(data->path);
+
+			device = data->path->eld_device;
+			if (device < 0)
+				continue;
+
+			mixer_handle = pa_alsa_open_mixer(impl->ucm.mixers, impl->card.index, true);
+		}
+
+		if (!mixer_handle)
+			continue;
+
+		melem = pa_alsa_mixer_find_pcm(mixer_handle, "ELD", device);
+		if (melem) {
+			pa_alsa_mixer_use_for_poll(impl->ucm.mixers, mixer_handle);
+			snd_mixer_elem_set_callback(melem, hdmi_eld_changed);
+			snd_mixer_elem_set_callback_private(melem, impl);
+			hdmi_eld_changed(melem, 0);
+			pa_log_info("ELD device found for port %s (%d).", port->port.name, device);
+		}
+		else
+			pa_log_debug("No ELD device found for port %s (%d).", port->port.name, device);
+	}
+}
+
+uint32_t acp_card_find_best_profile_index(struct acp_card *card, const char *name)
+{
+	uint32_t i;
+	uint32_t best, best2, off;
+	struct acp_card_profile **profiles = card->profiles;
+
+	best = best2 = ACP_INVALID_INDEX;
+	off = 0;
+
+	for (i = 0; i < card->n_profiles; i++) {
+		struct acp_card_profile *p = profiles[i];
+
+		if (name) {
+			if (spa_streq(name, p->name))
+				best = i;
+		} else if (p->flags & ACP_PROFILE_OFF) {
+			off = i;
+		} else if (p->available == ACP_AVAILABLE_YES) {
+			if (best == ACP_INVALID_INDEX || p->priority > profiles[best]->priority)
+				best = i;
+		} else if (p->available != ACP_AVAILABLE_NO) {
+			if (best2 == ACP_INVALID_INDEX || p->priority > profiles[best2]->priority)
+				best2 = i;
+		}
+	}
+	if (best == ACP_INVALID_INDEX)
+		best = best2;
+	if (best == ACP_INVALID_INDEX)
+		best = off;
+	return best;
+}
+
+static void find_mixer(pa_card *impl, pa_alsa_device *dev, const char *element, bool ignore_dB)
+{
+	const char *mdev;
+	pa_alsa_mapping *mapping = dev->mapping;
+
+	if (!mapping && !element)
+		return;
+
+	if (!element && mapping && pa_alsa_path_set_is_empty(dev->mixer_path_set))
+		return;
+
+	mdev = pa_proplist_gets(mapping->proplist, "alsa.mixer_device");
+	if (mdev) {
+		dev->mixer_handle = pa_alsa_open_mixer_by_name(impl->ucm.mixers, mdev, true);
+	} else {
+		dev->mixer_handle = pa_alsa_open_mixer(impl->ucm.mixers, impl->card.index, true);
+	}
+	if (!dev->mixer_handle) {
+		pa_log_info("Failed to find a working mixer device.");
+		return;
+	}
+
+	if (element) {
+		if (!(dev->mixer_path = pa_alsa_path_synthesize(element, dev->direction)))
+			goto fail;
+
+		if (pa_alsa_path_probe(dev->mixer_path, NULL, dev->mixer_handle, ignore_dB) < 0)
+			goto fail;
+
+		pa_log_debug("Probed mixer path %s:", dev->mixer_path->name);
+		pa_alsa_path_dump(dev->mixer_path);
+	}
+	return;
+
+fail:
+	if (dev->mixer_path) {
+		pa_alsa_path_free(dev->mixer_path);
+		dev->mixer_path = NULL;
+	}
+	dev->mixer_handle = NULL;
+}
+
+static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask)
+{
+	pa_alsa_device *dev = snd_mixer_elem_get_callback_private(elem);
+
+	if (mask == SND_CTL_EVENT_MASK_REMOVE)
+		return 0;
+
+	pa_log_info("%p mixer changed %d", dev, mask);
+
+	if (mask & SND_CTL_EVENT_MASK_VALUE) {
+		if (dev->read_volume)
+			dev->read_volume(dev);
+		if (dev->read_mute)
+			dev->read_mute(dev);
+	}
+	return 0;
+}
+
+static int read_volume(pa_alsa_device *dev)
+{
+	pa_card *impl = dev->card;
+	pa_cvolume r;
+	uint32_t i;
+	int res;
+
+	if (!dev->mixer_handle)
+		return 0;
+
+	if ((res = pa_alsa_path_get_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map, &r)) < 0)
+		return res;
+
+	/* Shift down by the base volume, so that 0dB becomes maximum volume */
+	pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
+
+	if (pa_cvolume_equal(&dev->hardware_volume, &r))
+		return 0;
+
+	dev->real_volume = dev->hardware_volume = r;
+
+	pa_log_info("New hardware volume: min:%d max:%d",
+			pa_cvolume_min(&r), pa_cvolume_max(&r));
+
+	for (i = 0; i < r.channels; i++)
+		pa_log_debug("  %d: %d", i, r.values[i]);
+
+	pa_cvolume_reset(&dev->soft_volume, r.channels);
+
+	if (impl->events && impl->events->volume_changed)
+		impl->events->volume_changed(impl->user_data, &dev->device);
+
+	return 0;
+}
+
+static void set_volume(pa_alsa_device *dev, const pa_cvolume *v)
+{
+	pa_cvolume r;
+
+	dev->real_volume = *v;
+
+	if (!dev->mixer_handle)
+		return;
+
+	/* Shift up by the base volume */
+	pa_sw_cvolume_divide_scalar(&r, &dev->real_volume, dev->base_volume);
+
+	if (pa_alsa_path_set_volume(dev->mixer_path, dev->mixer_handle, &dev->mapping->channel_map,
+			&r, false, true) < 0)
+		return;
+
+	/* Shift down by the base volume, so that 0dB becomes maximum volume */
+	pa_sw_cvolume_multiply_scalar(&r, &r, dev->base_volume);
+
+	dev->hardware_volume = r;
+
+	if (dev->mixer_path->has_dB) {
+		pa_cvolume new_soft_volume;
+		bool accurate_enough;
+
+		/* Match exactly what the user requested by software */
+		pa_sw_cvolume_divide(&new_soft_volume, &dev->real_volume, &dev->hardware_volume);
+
+		/* If the adjustment to do in software is only minimal we
+		 * can skip it. That saves us CPU at the expense of a bit of
+		 * accuracy */
+		accurate_enough =
+			(pa_cvolume_min(&new_soft_volume) >= (PA_VOLUME_NORM - VOLUME_ACCURACY)) &&
+			(pa_cvolume_max(&new_soft_volume) <= (PA_VOLUME_NORM + VOLUME_ACCURACY));
+
+		pa_log_debug("Requested volume: %d", pa_cvolume_max(&dev->real_volume));
+		pa_log_debug("Got hardware volume: %d", pa_cvolume_max(&dev->hardware_volume));
+		pa_log_debug("Calculated software volume: %d (accurate-enough=%s)",
+				pa_cvolume_max(&new_soft_volume),
+				pa_yes_no(accurate_enough));
+
+		if (accurate_enough)
+			pa_cvolume_reset(&new_soft_volume, new_soft_volume.channels);
+
+		dev->soft_volume = new_soft_volume;
+	} else {
+		pa_log_debug("Wrote hardware volume: %d", pa_cvolume_max(&r));
+		/* We can't match exactly what the user requested, hence let's
+		 * at least tell the user about it */
+		dev->real_volume = r;
+	}
+}
+
+static int read_mute(pa_alsa_device *dev)
+{
+	pa_card *impl = dev->card;
+	bool mute;
+	int res;
+
+	if (!dev->mixer_handle)
+		return 0;
+
+	if ((res = pa_alsa_path_get_mute(dev->mixer_path, dev->mixer_handle, &mute)) < 0)
+		return res;
+
+	if (mute == dev->muted)
+		return 0;
+
+	dev->muted = mute;
+	pa_log_info("New hardware muted: %d", mute);
+
+	if (impl->events && impl->events->mute_changed)
+		impl->events->mute_changed(impl->user_data, &dev->device);
+
+	return 0;
+}
+
+static void set_mute(pa_alsa_device *dev, bool mute)
+{
+	dev->muted = mute;
+
+	if (!dev->mixer_handle)
+		return;
+
+	pa_alsa_path_set_mute(dev->mixer_path, dev->mixer_handle, mute);
+}
+
+static void mixer_volume_init(pa_card *impl, pa_alsa_device *dev)
+{
+	pa_assert(dev);
+
+	if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_volume) {
+		dev->read_volume = NULL;
+		dev->set_volume = NULL;
+		pa_log_info("Driver does not support hardware volume control, "
+				"falling back to software volume control.");
+		dev->base_volume = PA_VOLUME_NORM;
+		dev->n_volume_steps = PA_VOLUME_NORM+1;
+		dev->device.flags &= ~ACP_DEVICE_HW_VOLUME;
+	} else {
+		dev->read_volume = read_volume;
+		dev->set_volume = set_volume;
+		dev->device.flags |= ACP_DEVICE_HW_VOLUME;
+
+#if 0
+		if (u->mixer_path->has_dB && u->deferred_volume) {
+			pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb);
+			pa_log_info("Successfully enabled deferred volume.");
+		} else
+			pa_sink_set_write_volume_callback(u->sink, NULL);
+#endif
+
+		if (dev->mixer_path->has_dB) {
+			dev->decibel_volume = true;
+			pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.",
+					dev->mixer_path->min_dB, dev->mixer_path->max_dB);
+
+			dev->base_volume = pa_sw_volume_from_dB(-dev->mixer_path->max_dB);
+			dev->n_volume_steps = PA_VOLUME_NORM+1;
+
+			pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(dev->base_volume));
+		} else {
+			dev->decibel_volume = false;
+			pa_log_info("Hardware volume ranges from %li to %li.",
+					dev->mixer_path->min_volume, dev->mixer_path->max_volume);
+			dev->base_volume = PA_VOLUME_NORM;
+			dev->n_volume_steps = dev->mixer_path->max_volume - dev->mixer_path->min_volume + 1;
+		}
+		pa_log_info("Using hardware volume control. Hardware dB scale %s.",
+				dev->mixer_path->has_dB ? "supported" : "not supported");
+	}
+	dev->device.base_volume = pa_sw_volume_to_linear(dev->base_volume);
+	dev->device.volume_step = 1.0f / dev->n_volume_steps;
+
+	if (impl->soft_mixer || !dev->mixer_path || !dev->mixer_path->has_mute) {
+		dev->read_mute = NULL;
+		dev->set_mute = NULL;
+		pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
+		dev->device.flags &= ~ACP_DEVICE_HW_MUTE;
+	} else {
+		dev->read_mute = read_mute;
+		dev->set_mute = set_mute;
+		pa_log_info("Using hardware mute control.");
+		dev->device.flags |= ACP_DEVICE_HW_MUTE;
+	}
+}
+
+
+static int setup_mixer(pa_card *impl, pa_alsa_device *dev, bool ignore_dB)
+{
+	int res;
+	bool need_mixer_callback = false;
+
+	/* This code is before the u->mixer_handle check, because if the UCM
+	* configuration doesn't specify volume or mute controls, u->mixer_handle
+	* will be NULL, but the UCM device enable sequence will still need to be
+	* executed. */
+	if (dev->active_port && dev->ucm_context) {
+		if ((res = pa_alsa_ucm_set_port(dev->ucm_context, dev->active_port,
+					dev->direction == PA_ALSA_DIRECTION_OUTPUT)) < 0)
+			return res;
+	}
+
+	if (!dev->mixer_handle)
+		return 0;
+
+	if (dev->active_port) {
+		if (!impl->use_ucm) {
+			pa_alsa_port_data *data;
+
+			/* We have a list of supported paths, so let's activate the
+			 * one that has been chosen as active */
+			data = PA_DEVICE_PORT_DATA(dev->active_port);
+			dev->mixer_path = data->path;
+
+			pa_alsa_path_select(data->path, data->setting, dev->mixer_handle, dev->muted);
+		} else {
+			pa_alsa_ucm_port_data *data;
+
+			data = PA_DEVICE_PORT_DATA(dev->active_port);
+
+			/* Now activate volume controls, if any */
+			if (data->path) {
+				dev->mixer_path = data->path;
+				pa_alsa_path_select(dev->mixer_path, NULL, dev->mixer_handle, dev->muted);
+			}
+		}
+	} else {
+		if (!dev->mixer_path && dev->mixer_path_set)
+			dev->mixer_path = pa_hashmap_first(dev->mixer_path_set->paths);
+
+		if (dev->mixer_path) {
+			/* Hmm, we have only a single path, then let's activate it */
+			pa_alsa_path_select(dev->mixer_path, dev->mixer_path->settings,
+					dev->mixer_handle, dev->muted);
+		} else
+			return 0;
+	}
+
+	mixer_volume_init(impl, dev);
+
+	/* Will we need to register callbacks? */
+	if (dev->mixer_path_set && dev->mixer_path_set->paths) {
+		pa_alsa_path *p;
+		void *state;
+
+		PA_HASHMAP_FOREACH(p, dev->mixer_path_set->paths, state) {
+			if (p->has_volume || p->has_mute)
+				need_mixer_callback = true;
+		}
+	}
+	else if (dev->mixer_path)
+		need_mixer_callback = dev->mixer_path->has_volume || dev->mixer_path->has_mute;
+
+	if (!impl->soft_mixer && need_mixer_callback) {
+		pa_alsa_mixer_use_for_poll(impl->ucm.mixers, dev->mixer_handle);
+		if (dev->mixer_path_set)
+			pa_alsa_path_set_set_callback(dev->mixer_path_set, dev->mixer_handle, mixer_callback, dev);
+		else
+			pa_alsa_path_set_callback(dev->mixer_path, dev->mixer_handle, mixer_callback, dev);
+	}
+	return 0;
+}
+
+static int device_disable(pa_card *impl, pa_alsa_mapping *mapping, pa_alsa_device *dev)
+{
+	dev->device.flags &= ~ACP_DEVICE_ACTIVE;
+	if (dev->active_port) {
+		dev->active_port->port.flags &= ~ACP_PORT_ACTIVE;
+		dev->active_port = NULL;
+	}
+	return 0;
+}
+
+static int device_enable(pa_card *impl, pa_alsa_mapping *mapping, pa_alsa_device *dev)
+{
+	const char *mod_name;
+	uint32_t i, port_index;
+	int res;
+
+	if (impl->use_ucm &&
+	    (mod_name = pa_proplist_gets(mapping->proplist, PA_ALSA_PROP_UCM_MODIFIER))) {
+		if (snd_use_case_set(impl->ucm.ucm_mgr, "_enamod", mod_name) < 0)
+			pa_log("Failed to enable ucm modifier %s", mod_name);
+		else
+			pa_log_debug("Enabled ucm modifier %s", mod_name);
+	}
+
+	pa_log_info("Device: %s mapping '%s' (%s).", dev->device.description,
+			mapping->description, mapping->name);
+
+	dev->device.flags |= ACP_DEVICE_ACTIVE;
+
+	find_mixer(impl, dev, NULL, impl->ignore_dB);
+
+	/* Synchronize priority values, as it may have changed when setting the profile */
+	for (i = 0; i < impl->card.n_ports; i++) {
+		pa_device_port *p = (pa_device_port *)impl->card.ports[i];
+		p->port.priority = p->priority;
+	}
+
+	if (impl->auto_port)
+		port_index = acp_device_find_best_port_index(&dev->device, NULL);
+	else
+		port_index = ACP_INVALID_INDEX;
+
+	if (port_index == ACP_INVALID_INDEX)
+		dev->active_port = NULL;
+	else
+		dev->active_port = (pa_device_port*)impl->card.ports[port_index];
+
+	if (dev->active_port)
+		dev->active_port->port.flags |= ACP_PORT_ACTIVE;
+
+	if ((res = setup_mixer(impl, dev, impl->ignore_dB)) < 0)
+		return res;
+
+	if (dev->read_volume)
+		dev->read_volume(dev);
+	else {
+		pa_cvolume_reset(&dev->real_volume, dev->device.format.channels);
+		pa_cvolume_reset(&dev->soft_volume, dev->device.format.channels);
+	}
+	if (dev->read_mute)
+		dev->read_mute(dev);
+	else
+		dev->muted = false;
+
+	return 0;
+}
+
+int acp_card_set_profile(struct acp_card *card, uint32_t new_index, uint32_t flags)
+{
+	pa_card *impl = (pa_card *)card;
+	pa_alsa_mapping *am;
+	uint32_t old_index = impl->card.active_profile_index;
+	struct acp_card_profile **profiles = card->profiles;
+	pa_alsa_profile *op, *np;
+	uint32_t idx;
+	int res;
+
+	if (new_index >= card->n_profiles)
+		return -EINVAL;
+
+	op = old_index != ACP_INVALID_INDEX ? (pa_alsa_profile*)profiles[old_index] : NULL;
+	np = (pa_alsa_profile*)profiles[new_index];
+
+	if (op == np)
+		return 0;
+
+	pa_log_info("activate profile: %s (%d)", np->profile.name, new_index);
+
+	if (op && op->output_mappings) {
+		PA_IDXSET_FOREACH(am, op->output_mappings, idx) {
+			if (np->output_mappings &&
+			    pa_idxset_get_by_data(np->output_mappings, am, NULL))
+				continue;
+
+			device_disable(impl, am, &am->output);
+		}
+	}
+	if (op && op->input_mappings) {
+		PA_IDXSET_FOREACH(am, op->input_mappings, idx) {
+			if (np->input_mappings &&
+			    pa_idxset_get_by_data(np->input_mappings, am, NULL))
+				continue;
+
+			device_disable(impl, am, &am->input);
+		}
+	}
+
+	/* if UCM is available for this card then update the verb */
+	if (impl->use_ucm && !(np->profile.flags & ACP_PROFILE_PRO)) {
+		if ((res = pa_alsa_ucm_set_profile(&impl->ucm, impl,
+		    np->profile.flags & ACP_PROFILE_OFF ? NULL : np->profile.name,
+		    op ? op->profile.name : NULL)) < 0) {
+			return res;
+		}
+	}
+
+	if (np->output_mappings) {
+		PA_IDXSET_FOREACH(am, np->output_mappings, idx) {
+			if (impl->use_ucm) {
+				/* Update ports priorities */
+				if (am->ucm_context.ucm_devices) {
+					pa_alsa_ucm_add_ports_combination(am->output.ports, &am->ucm_context,
+						true, impl->ports, np, NULL);
+				}
+			}
+			device_enable(impl, am, &am->output);
+		}
+	}
+
+	if (np->input_mappings) {
+		PA_IDXSET_FOREACH(am, np->input_mappings, idx) {
+			if (impl->use_ucm) {
+				/* Update ports priorities */
+				if (am->ucm_context.ucm_devices) {
+					pa_alsa_ucm_add_ports_combination(am->input.ports, &am->ucm_context,
+						false, impl->ports, np, NULL);
+				}
+			}
+			device_enable(impl, am, &am->input);
+		}
+	}
+	if (op)
+		op->profile.flags &= ~(ACP_PROFILE_ACTIVE | ACP_PROFILE_SAVE);
+	np->profile.flags |= ACP_PROFILE_ACTIVE | flags;
+	impl->card.active_profile_index = new_index;
+
+	if (impl->events && impl->events->profile_changed)
+		impl->events->profile_changed(impl->user_data, old_index,
+				new_index);
+	return 0;
+}
+
+static void prune_singleton_availability_groups(pa_hashmap *ports) {
+    pa_device_port *p;
+    pa_hashmap *group_counts;
+    void *state, *count;
+    const char *group;
+
+    /* Collect groups and erase those that don't have more than 1 path */
+    group_counts = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+
+    PA_HASHMAP_FOREACH(p, ports, state) {
+        if (p->availability_group) {
+            count = pa_hashmap_get(group_counts, p->availability_group);
+            pa_hashmap_remove(group_counts, p->availability_group);
+            pa_hashmap_put(group_counts, p->availability_group, PA_UINT_TO_PTR(PA_PTR_TO_UINT(count) + 1));
+        }
+    }
+
+    /* Now we have an availability_group -> count map, let's drop all groups
+     * that have only one member */
+    PA_HASHMAP_FOREACH_KV(group, count, group_counts, state) {
+        if (count == PA_UINT_TO_PTR(1))
+            pa_hashmap_remove(group_counts, group);
+    }
+
+    PA_HASHMAP_FOREACH(p, ports, state) {
+        if (p->availability_group && !pa_hashmap_get(group_counts, p->availability_group)) {
+            pa_log_debug("Pruned singleton availability group %s from port %s", p->availability_group, p->name);
+            pa_xfree(p->availability_group);
+            p->availability_group = NULL;
+        }
+    }
+
+    pa_hashmap_free(group_counts);
+}
+
+static const char *acp_dict_lookup(const struct acp_dict *dict, const char *key)
+{
+	const struct acp_dict_item *it;
+	acp_dict_for_each(it, dict) {
+		if (spa_streq(key, it->key))
+			return it->value;
+	}
+	return NULL;
+}
+
+struct acp_card *acp_card_new(uint32_t index, const struct acp_dict *props)
+{
+	pa_card *impl;
+	struct acp_card *card;
+	const char *s, *profile_set = NULL, *profile = NULL;
+	char device_id[16];
+	uint32_t profile_index;
+	int res;
+
+	impl = calloc(1, sizeof(*impl));
+	if (impl == NULL)
+		return NULL;
+
+	pa_alsa_refcnt_inc();
+
+	snprintf(device_id, sizeof(device_id), "%d", index);
+
+	impl->proplist = pa_proplist_new_dict(props);
+
+	card = &impl->card;
+	card->index = index;
+	card->active_profile_index = ACP_INVALID_INDEX;
+
+	impl->use_ucm = true;
+	impl->auto_profile = true;
+	impl->auto_port = true;
+	impl->ignore_dB = false;
+	impl->rate = DEFAULT_RATE;
+
+	if (props) {
+		if ((s = acp_dict_lookup(props, "api.alsa.use-ucm")) != NULL)
+			impl->use_ucm = spa_atob(s);
+		if ((s = acp_dict_lookup(props, "api.alsa.soft-mixer")) != NULL)
+			impl->soft_mixer = spa_atob(s);
+		if ((s = acp_dict_lookup(props, "api.alsa.ignore-dB")) != NULL)
+			impl->ignore_dB = spa_atob(s);
+		if ((s = acp_dict_lookup(props, "device.profile-set")) != NULL)
+			profile_set = s;
+		if ((s = acp_dict_lookup(props, "device.profile")) != NULL)
+			profile = s;
+		if ((s = acp_dict_lookup(props, "api.acp.auto-profile")) != NULL)
+			impl->auto_profile = spa_atob(s);
+		if ((s = acp_dict_lookup(props, "api.acp.auto-port")) != NULL)
+			impl->auto_port = spa_atob(s);
+		if ((s = acp_dict_lookup(props, "api.acp.probe-rate")) != NULL)
+			impl->rate = atoi(s);
+	}
+
+	impl->ucm.default_sample_spec.format = PA_SAMPLE_S16NE;
+	impl->ucm.default_sample_spec.rate = impl->rate;
+	impl->ucm.default_sample_spec.channels = 2;
+	pa_channel_map_init_extend(&impl->ucm.default_channel_map,
+			impl->ucm.default_sample_spec.channels, PA_CHANNEL_MAP_ALSA);
+	impl->ucm.default_n_fragments = 4;
+	impl->ucm.default_fragment_size_msec = 25;
+
+	impl->ucm.mixers = pa_hashmap_new_full(pa_idxset_string_hash_func,
+			pa_idxset_string_compare_func,
+			pa_xfree, (pa_free_cb_t) pa_alsa_mixer_free);
+	impl->profiles = pa_hashmap_new_full(pa_idxset_string_hash_func,
+			pa_idxset_string_compare_func, NULL,
+			(pa_free_cb_t) profile_free);
+	impl->ports = pa_hashmap_new_full(pa_idxset_string_hash_func,
+			pa_idxset_string_compare_func, NULL,
+			(pa_free_cb_t) port_free);
+
+	snd_config_update_free_global();
+
+	res = impl->use_ucm ? pa_alsa_ucm_query_profiles(&impl->ucm, card->index) : -1;
+	if (res == -PA_ALSA_ERR_UCM_LINKED) {
+		res = -ENOENT;
+		goto error;
+	}
+	if (res == 0) {
+		pa_log_info("Found UCM profiles");
+		impl->profile_set = pa_alsa_ucm_add_profile_set(&impl->ucm, &impl->ucm.default_channel_map);
+	} else {
+		impl->use_ucm = false;
+		impl->profile_set = pa_alsa_profile_set_new(profile_set, &impl->ucm.default_channel_map);
+	}
+	if (impl->profile_set == NULL) {
+		res = -ENOTSUP;
+		goto error;
+	}
+
+	impl->profile_set->ignore_dB = impl->ignore_dB;
+
+	pa_alsa_profile_set_probe(impl->profile_set, impl->ucm.mixers,
+			device_id,
+			&impl->ucm.default_sample_spec,
+			impl->ucm.default_n_fragments,
+			impl->ucm.default_fragment_size_msec);
+
+	pa_alsa_init_proplist_card(NULL, impl->proplist, impl->card.index);
+	pa_proplist_sets(impl->proplist, PA_PROP_DEVICE_STRING, device_id);
+	pa_alsa_init_description(impl->proplist, NULL);
+
+	add_profiles(impl);
+	prune_singleton_availability_groups(impl->ports);
+
+	card->n_profiles = pa_dynarray_size(&impl->out.profiles);
+	card->profiles = impl->out.profiles.array.data;
+
+	card->n_ports = pa_dynarray_size(&impl->out.ports);
+	card->ports = impl->out.ports.array.data;
+
+	card->n_devices = pa_dynarray_size(&impl->out.devices);
+	card->devices = impl->out.devices.array.data;
+
+	pa_proplist_as_dict(impl->proplist, &card->props);
+
+	init_jacks(impl);
+
+	if (!impl->auto_profile && profile == NULL)
+		profile = "off";
+
+	profile_index = acp_card_find_best_profile_index(&impl->card, profile);
+	acp_card_set_profile(&impl->card, profile_index, 0);
+
+	init_eld_ctls(impl);
+
+	return &impl->card;
+error:
+	pa_alsa_refcnt_dec();
+	free(impl);
+	errno = -res;
+	return NULL;
+}
+
+void acp_card_add_listener(struct acp_card *card,
+		const struct acp_card_events *events, void *user_data)
+{
+	pa_card *impl = (pa_card *)card;
+	impl->events = events;
+	impl->user_data = user_data;
+}
+
+void acp_card_destroy(struct acp_card *card)
+{
+	pa_card *impl = (pa_card *)card;
+	if (impl->profiles)
+		pa_hashmap_free(impl->profiles);
+	if (impl->ports)
+		pa_hashmap_free(impl->ports);
+	pa_dynarray_clear(&impl->out.devices);
+	pa_dynarray_clear(&impl->out.profiles);
+	pa_dynarray_clear(&impl->out.ports);
+	if (impl->ucm.mixers)
+		pa_hashmap_free(impl->ucm.mixers);
+	if (impl->jacks)
+		pa_hashmap_free(impl->jacks);
+	if (impl->profile_set)
+		pa_alsa_profile_set_free(impl->profile_set);
+	pa_alsa_ucm_free(&impl->ucm);
+	pa_proplist_free(impl->proplist);
+	pa_alsa_refcnt_dec();
+	free(impl);
+}
+
+int acp_card_poll_descriptors_count(struct acp_card *card)
+{
+	pa_card *impl = (pa_card *)card;
+	void *state;
+	pa_alsa_mixer *pm;
+	int n, count = 0;
+
+	PA_HASHMAP_FOREACH(pm, impl->ucm.mixers, state) {
+		if (!pm->used_for_poll)
+			continue;
+		n = snd_mixer_poll_descriptors_count(pm->mixer_handle);
+		if (n < 0)
+			return n;
+		count += n;
+	}
+	return count;
+}
+
+int acp_card_poll_descriptors(struct acp_card *card, struct pollfd *pfds, unsigned int space)
+{
+	pa_card *impl = (pa_card *)card;
+	void *state;
+	pa_alsa_mixer *pm;
+	int n, count = 0;
+
+	PA_HASHMAP_FOREACH(pm, impl->ucm.mixers, state) {
+		if (!pm->used_for_poll)
+			continue;
+
+		n = snd_mixer_poll_descriptors(pm->mixer_handle, pfds, space);
+		if (n < 0)
+			return n;
+		if (space >= (unsigned int) n) {
+			count += n;
+			space -= n;
+			pfds += n;
+		} else
+			space = 0;
+	}
+	return count;
+}
+
+int acp_card_poll_descriptors_revents(struct acp_card *card, struct pollfd *pfds,
+		unsigned int nfds, unsigned short *revents)
+{
+	unsigned int idx;
+	unsigned short res;
+	if (nfds == 0)
+		return -EINVAL;
+	res = 0;
+	for (idx = 0; idx < nfds; idx++, pfds++)
+		res |= pfds->revents & (POLLIN|POLLERR|POLLNVAL);
+	*revents = res;
+	return 0;
+}
+
+int acp_card_handle_events(struct acp_card *card)
+{
+	pa_card *impl = (pa_card *)card;
+	void *state;
+	pa_alsa_mixer *pm;
+	int n, count = 0;
+
+	PA_HASHMAP_FOREACH(pm, impl->ucm.mixers, state) {
+		if (!pm->used_for_poll)
+			continue;
+
+		n = snd_mixer_handle_events(pm->mixer_handle);
+		if (n < 0)
+			return n;
+		count += n;
+	}
+	return count;
+}
+
+static void sync_mixer(pa_alsa_device *d, pa_device_port *port)
+{
+	pa_alsa_setting *setting = NULL;
+
+	if (!d->mixer_path)
+		return;
+
+	/* port may be NULL, because if we use a synthesized mixer path, then the
+	 * sink has no ports. */
+	if (port && !d->ucm_context) {
+		pa_alsa_port_data *data;
+		data = PA_DEVICE_PORT_DATA(port);
+		setting = data->setting;
+	}
+
+	if (d->mixer_handle)
+		pa_alsa_path_select(d->mixer_path, setting, d->mixer_handle, d->muted);
+
+	if (d->set_mute)
+		d->set_mute(d, d->muted);
+	if (d->set_volume)
+		d->set_volume(d, &d->real_volume);
+}
+
+
+uint32_t acp_device_find_best_port_index(struct acp_device *dev, const char *name)
+{
+	uint32_t i;
+	uint32_t best, best2, best3;
+	struct acp_port **ports = dev->ports;
+
+	best = best2 = best3 = ACP_INVALID_INDEX;
+
+	for (i = 0; i < dev->n_ports; i++) {
+		struct acp_port *p = ports[i];
+
+		if (name) {
+			if (spa_streq(name, p->name))
+				best = i;
+		} else if (p->available == ACP_AVAILABLE_YES) {
+			if (best == ACP_INVALID_INDEX || p->priority > ports[best]->priority)
+				best = i;
+		} else if (p->available != ACP_AVAILABLE_NO) {
+			if (best2 == ACP_INVALID_INDEX || p->priority > ports[best2]->priority)
+				best2 = i;
+		} else {
+			if (best3 == ACP_INVALID_INDEX || p->priority > ports[best3]->priority)
+				best3 = i;
+		}
+	}
+	if (best == ACP_INVALID_INDEX)
+		best = best2;
+	if (best == ACP_INVALID_INDEX)
+		best = best3;
+	if (best == ACP_INVALID_INDEX)
+		best = 0;
+	if (best < dev->n_ports)
+		return ports[best]->index;
+	else
+		return ACP_INVALID_INDEX;
+}
+
+int acp_device_set_port(struct acp_device *dev, uint32_t port_index, uint32_t flags)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	pa_card *impl = d->card;
+	pa_device_port *p, *old = d->active_port;
+	int res;
+
+	if (port_index >= impl->card.n_ports)
+		return -EINVAL;
+
+	p = (pa_device_port*)impl->card.ports[port_index];
+	if (!pa_hashmap_get(d->ports, p->name))
+		return -EINVAL;
+
+	p->port.flags = ACP_PORT_ACTIVE | flags;
+	if (p == old)
+		return 0;
+	if (old)
+		old->port.flags &= ~(ACP_PORT_ACTIVE | ACP_PORT_SAVE);
+	d->active_port = p;
+
+	if (impl->use_ucm) {
+		pa_alsa_ucm_port_data *data;
+
+		data = PA_DEVICE_PORT_DATA(p);
+		d->mixer_path = data->path;
+		mixer_volume_init(impl, d);
+
+		sync_mixer(d, p);
+		res = pa_alsa_ucm_set_port(d->ucm_context, p,
+					dev->direction == ACP_DIRECTION_PLAYBACK);
+	} else {
+		pa_alsa_port_data *data;
+
+		data = PA_DEVICE_PORT_DATA(p);
+		d->mixer_path = data->path;
+		mixer_volume_init(impl, d);
+
+		sync_mixer(d, p);
+		res = 0;
+#if 0
+		if (data->suspend_when_unavailable && p->available == PA_AVAILABLE_NO)
+			pa_sink_suspend(s, true, PA_SUSPEND_UNAVAILABLE);
+		else
+			pa_sink_suspend(s, false, PA_SUSPEND_UNAVAILABLE);
+#endif
+	}
+	if (impl->events && impl->events->port_changed)
+		impl->events->port_changed(impl->user_data,
+				old ? old->port.index : 0, p->port.index);
+	return res;
+}
+
+int acp_device_set_volume(struct acp_device *dev, const float *volume, uint32_t n_volume)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	pa_card *impl = d->card;
+	uint32_t i;
+	pa_cvolume v, old_volume;
+
+	if (n_volume == 0)
+		return -EINVAL;
+
+	old_volume = d->real_volume;
+
+	v.channels = d->mapping->channel_map.channels;
+	for (i = 0; i < v.channels; i++)
+		v.values[i] = pa_sw_volume_from_linear(volume[i % n_volume]);
+
+	pa_log_info("Set %s volume: min:%d max:%d",
+			d->set_volume ? "hardware" : "software",
+			pa_cvolume_min(&v), pa_cvolume_max(&v));
+
+	for (i = 0; i < v.channels; i++)
+		pa_log_debug("  %d: %d", i, v.values[i]);
+
+	if (d->set_volume) {
+		d->set_volume(d, &v);
+	} else {
+		d->real_volume = v;
+		d->soft_volume = v;
+	}
+	if (!pa_cvolume_equal(&d->real_volume, &old_volume))
+		if (impl->events && impl->events->volume_changed)
+			impl->events->volume_changed(impl->user_data, dev);
+	return 0;
+}
+
+static int get_volume(pa_cvolume *v, float *volume, uint32_t n_volume)
+{
+	uint32_t i;
+	if (v->channels == 0)
+		return -EIO;
+	for (i = 0; i < n_volume; i++)
+		volume[i] = pa_sw_volume_to_linear(v->values[i % v->channels]);
+	return 0;
+}
+
+int acp_device_get_soft_volume(struct acp_device *dev, float *volume, uint32_t n_volume)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	return get_volume(&d->soft_volume, volume, n_volume);
+}
+
+int acp_device_get_volume(struct acp_device *dev, float *volume, uint32_t n_volume)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	return get_volume(&d->real_volume, volume, n_volume);
+}
+
+int acp_device_set_mute(struct acp_device *dev, bool mute)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	pa_card *impl = d->card;
+	bool old_muted = d->muted;
+
+	if (old_muted == mute)
+		return 0;
+
+	pa_log_info("Set %s mute: %d", d->set_mute ? "hardware" : "software", mute);
+
+	if (d->set_mute) {
+		d->set_mute(d, mute);
+	} else  {
+		d->muted = mute;
+	}
+	if (old_muted != mute)
+		if (impl->events && impl->events->mute_changed)
+			impl->events->mute_changed(impl->user_data, dev);
+
+	return 0;
+}
+
+int acp_device_get_mute(struct acp_device *dev, bool *mute)
+{
+	pa_alsa_device *d = (pa_alsa_device*)dev;
+	*mute = d->muted;
+	return 0;
+}
+
+void acp_set_log_func(acp_log_func func, void *data)
+{
+	_acp_log_func = func;
+	_acp_log_data = data;
+}
+void acp_set_log_level(int level)
+{
+	_acp_log_level = level;
+}