[PATCH 6/6] ucm: Add support for "JackHWMute"

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



"JackHWMute" is a UCM device value that, if set, indicates that the
jack of the device mutes some other device at the hardware or driver
level. A common example would be a headphone jack that mutes built-in
speakers. PulseAudio should show such auto-muted devices as
unavailable.

Previously there was only a simple relationship: each UCM device was
related to one jack and vice versa. Now each device is still related
to exactly one jack, but each jack can be related to two devices: one
that the jack enables, and one that the jack disables (mutes).

The patch adds pa_alsa_jack_set_plugged_in() to encapsulate the logic
of marking the appropriate ports available/unavailable.
pa_alsa_jack_set_plugged_in() propagates the status to UCM devices,
and the devices propagate the status further to ports. Previously the
logic of mapping jack status to port availability was done by
module-alsa-card.c, which I think is not the right place, so I didn't
want to add the UCM "mute jack" logic there.
---
 src/modules/alsa/alsa-mixer.c       |  15 ++
 src/modules/alsa/alsa-mixer.h       |  14 ++
 src/modules/alsa/alsa-ucm.c         | 286 +++++++++++++++++++++++++++++++++++-
 src/modules/alsa/alsa-ucm.h         |  37 +++++
 src/modules/alsa/module-alsa-card.c |  18 ++-
 src/pulsecore/device-port.c         |  14 +-
 6 files changed, 362 insertions(+), 22 deletions(-)

diff --git a/src/modules/alsa/alsa-mixer.c b/src/modules/alsa/alsa-mixer.c
index 2fe2ae4..423832f 100644
--- a/src/modules/alsa/alsa-mixer.c
+++ b/src/modules/alsa/alsa-mixer.c
@@ -2768,6 +2768,21 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, bool ignore_dB) {
     return 0;
 }
 
+void pa_alsa_jack_set_plugged_in(pa_alsa_jack *jack, bool plugged_in) {
+    pa_assert(jack);
+
+    if (plugged_in == jack->plugged_in)
+        return;
+
+    jack->plugged_in = plugged_in;
+
+    if (jack->device)
+        pa_alsa_ucm_device_set_available(jack->device, plugged_in);
+
+    if (jack->hw_mute)
+        pa_alsa_ucm_device_set_available(jack->hw_mute, !plugged_in);
+}
+
 void pa_alsa_setting_dump(pa_alsa_setting *s) {
     pa_assert(s);
 
diff --git a/src/modules/alsa/alsa-mixer.h b/src/modules/alsa/alsa-mixer.h
index ec39fab..dad1ea2 100644
--- a/src/modules/alsa/alsa-mixer.h
+++ b/src/modules/alsa/alsa-mixer.h
@@ -168,8 +168,22 @@ struct pa_alsa_jack {
     pa_alsa_required_t required;
     pa_alsa_required_t required_any;
     pa_alsa_required_t required_absent;
+
+    /* UCM specific: this is the "owner" device of this jack. When the jack is
+     * plugged in, the device referenced here gets marked as available, and
+     * when the jack is unplugged, the device gets marked as unavailable. */
+    pa_alsa_ucm_device *device;
+
+    /* UCM specific: if this is non-NULL, then the referenced device gets muted
+     * by the hardware (or driver) when this jack is plugged in. The muting can't
+     * be overridden by PulseAudio, so the device gets marked as
+     * unavailable (so if a device is referenced by this field, the effect is
+     * inverse to being referenced by the "device" field). */
+    pa_alsa_ucm_device *hw_mute;
 };
 
+void pa_alsa_jack_set_plugged_in(pa_alsa_jack *jack, bool plugged_in);
+
 /* A path wraps a series of elements into a single entity which can be
  * used to control it as if it had a single volume slider, a single
  * mute switch and a single list of selectable options. */
diff --git a/src/modules/alsa/alsa-ucm.c b/src/modules/alsa/alsa-ucm.c
index ef6adcd..061b8f7 100644
--- a/src/modules/alsa/alsa-ucm.c
+++ b/src/modules/alsa/alsa-ucm.c
@@ -66,6 +66,17 @@
 
 #ifdef HAVE_ALSA_UCM
 
+static void device_set_mute_jack(pa_alsa_ucm_device *device, pa_alsa_jack *jack);
+
+struct port {
+    pa_alsa_ucm_config *ucm;
+    pa_device_port *core_port;
+
+    /* Usually a port is associated with only one device, but ports can also be
+     * a combination of several devices. */
+    pa_dynarray *devices; /* pa_alsa_ucm_device */
+};
+
 struct ucm_items {
     const char *id;
     const char *property;
@@ -91,6 +102,7 @@ static struct ucm_items item[] = {
     {"CaptureChannels", PA_ALSA_PROP_UCM_CAPTURE_CHANNELS},
     {"TQ", PA_ALSA_PROP_UCM_QOS},
     {"JackControl", PA_ALSA_PROP_UCM_JACK_CONTROL},
+    {"JackHWMute", PA_ALSA_PROP_UCM_JACK_HW_MUTE},
     {NULL, NULL},
 };
 
@@ -394,9 +406,12 @@ static int ucm_get_devices(pa_alsa_ucm_verb *verb, snd_use_case_mgr_t *uc_mgr) {
     for (i = 0; i < num_dev; i += 2) {
         pa_alsa_ucm_device *d = pa_xnew0(pa_alsa_ucm_device, 1);
 
+        d->verb = verb;
         d->proplist = pa_proplist_new();
         pa_proplist_sets(d->proplist, PA_ALSA_PROP_UCM_NAME, pa_strnull(dev_list[i]));
         pa_proplist_sets(d->proplist, PA_ALSA_PROP_UCM_DESCRIPTION, pa_strna(dev_list[i + 1]));
+        d->ports = pa_dynarray_new(NULL);
+        d->available = true;
 
         PA_LLIST_PREPEND(pa_alsa_ucm_device, verb->devices, d);
     }
@@ -553,6 +568,8 @@ int pa_alsa_ucm_query_profiles(pa_alsa_ucm_config *ucm, int card_index) {
     const char **verb_list;
     int num_verbs, i, err = 0;
 
+    ucm->ports = pa_dynarray_new(NULL);
+
     /* is UCM available for this card ? */
     err = snd_card_get_name(card_index, &card_name);
     if (err < 0) {
@@ -670,6 +687,67 @@ static int pa_alsa_ucm_device_cmp(const void *a, const void *b) {
     return strcmp(pa_proplist_gets(d1->proplist, PA_ALSA_PROP_UCM_NAME), pa_proplist_gets(d2->proplist, PA_ALSA_PROP_UCM_NAME));
 }
 
+static void device_add_port(pa_alsa_ucm_device *device, struct port *port) {
+    pa_assert(device);
+    pa_assert(port);
+
+    pa_dynarray_append(device->ports, port);
+}
+
+static void device_remove_port(pa_alsa_ucm_device *device, struct port *port) {
+    pa_assert(device);
+    pa_assert(port);
+
+    pa_dynarray_remove_by_data(device->ports, port);
+}
+
+static struct port *port_new(pa_alsa_ucm_config *ucm, pa_device_port *core_port, pa_alsa_ucm_device **devices,
+                             unsigned n_devices) {
+    struct port *port;
+    unsigned i;
+    pa_available_t available = PA_AVAILABLE_YES;
+
+    pa_assert(ucm);
+    pa_assert(core_port);
+    pa_assert(devices);
+
+    port = pa_xnew0(struct port, 1);
+    port->ucm = ucm;
+    port->core_port = core_port;
+    port->devices = pa_dynarray_new(NULL);
+
+    for (i = 0; i < n_devices; i++) {
+        device_add_port(devices[i], port);
+        pa_dynarray_append(port->devices, devices[i]);
+
+        if (!devices[i]->available)
+            available = PA_AVAILABLE_NO;
+    }
+
+    pa_device_port_set_available(core_port, available);
+
+    pa_dynarray_append(ucm->ports, port);
+
+    return port;
+}
+
+static void port_free(struct port *port) {
+    pa_assert(port);
+
+    pa_dynarray_remove_by_data(port->ucm->ports, port);
+
+    if (port->devices) {
+        pa_alsa_ucm_device *device;
+
+        while ((device = pa_dynarray_steal_last(port->devices)))
+            device_remove_port(device, port);
+
+        pa_dynarray_free(port->devices);
+    }
+
+    pa_xfree(port);
+}
+
 static void ucm_add_port_combination(
         pa_hashmap *hash,
         pa_alsa_ucm_mapping_context *context,
@@ -688,6 +766,9 @@ static void ucm_add_port_combination(
     const char *dev_name;
     const char *direction;
     pa_alsa_ucm_device *sorted[num], *dev;
+    pa_alsa_ucm_config *ucm;
+
+    ucm = context->ucm;
 
     for (i = 0; i < num; i++)
         sorted[i] = pdevices[i];
@@ -735,16 +816,21 @@ static void ucm_add_port_combination(
 
     port = pa_hashmap_get(ports, name);
     if (!port) {
+        struct port *ucm_port;
+
         pa_device_port_new_data port_data;
 
         pa_device_port_new_data_init(&port_data);
         pa_device_port_new_data_set_name(&port_data, name);
         pa_device_port_new_data_set_description(&port_data, desc);
         pa_device_port_new_data_set_direction(&port_data, is_sink ? PA_DIRECTION_OUTPUT : PA_DIRECTION_INPUT);
+        pa_device_port_new_data_set_available(&port_data, PA_AVAILABLE_YES);
 
-        port = pa_device_port_new(core, &port_data, 0);
+        port = pa_device_port_new(core, &port_data, sizeof(struct port *));
         pa_device_port_new_data_done(&port_data);
-        pa_assert(port);
+
+        ucm_port = port_new(ucm, port, pdevices, num);
+        *((struct port **) PA_DEVICE_PORT_DATA(port)) = ucm_port;
 
         pa_hashmap_put(ports, port->name, port);
         pa_log_debug("Add port %s: %s", port->name, port->description);
@@ -1263,16 +1349,67 @@ static int ucm_create_mapping(
     return ret;
 }
 
-static pa_alsa_jack* ucm_get_jack(pa_alsa_ucm_config *ucm, pa_alsa_ucm_device *device, const char *pre_tag) {
+static void device_set_output_jack(pa_alsa_ucm_device *device, pa_alsa_jack *jack) {
+    pa_assert(device);
+    pa_assert(!jack || !device->mute_jack);
+
+    if (jack == device->output_jack)
+        return;
+
+    device->output_jack = jack;
+
+    if (jack)
+        pa_alsa_ucm_device_set_available(device, jack->plugged_in);
+    else
+        pa_alsa_ucm_device_set_available(device, true);
+}
+
+static void device_set_input_jack(pa_alsa_ucm_device *device, pa_alsa_jack *jack) {
+    pa_assert(device);
+    pa_assert(!jack || !device->mute_jack);
+
+    if (jack == device->input_jack)
+        return;
+
+    device->input_jack = jack;
+
+    if (jack)
+        pa_alsa_ucm_device_set_available(device, jack->plugged_in);
+    else
+        pa_alsa_ucm_device_set_available(device, true);
+}
+
+static void device_set_mute_jack(pa_alsa_ucm_device *device, pa_alsa_jack *jack) {
+    pa_assert(device);
+    pa_assert(!jack || !device->output_jack);
+    pa_assert(!jack || !device->input_jack);
+
+    if (jack == device->mute_jack)
+        return;
+
+    device->mute_jack = jack;
+
+    if (jack)
+        pa_alsa_ucm_device_set_available(device, !jack->plugged_in);
+    else
+        pa_alsa_ucm_device_set_available(device, true);
+}
+
+static pa_alsa_jack* ucm_get_jack(pa_alsa_ucm_config *ucm, pa_alsa_ucm_device *device, const char *pre_tag, bool implicit) {
+    const char *jack_control;
     pa_alsa_jack *j;
     const char *device_name;
     char *name;
-    const char *jack_control;
+    const char *jack_hw_mute;
 
     pa_assert(ucm);
     pa_assert(device);
     pa_assert(pre_tag);
 
+    jack_control = pa_proplist_gets(device->proplist, PA_ALSA_PROP_UCM_JACK_CONTROL);
+    if (!jack_control && !implicit)
+        return NULL;
+
     device_name = pa_proplist_gets(device->proplist, PA_ALSA_PROP_UCM_NAME);
     name = pa_sprintf_malloc("%s%s", pre_tag, device_name);
 
@@ -1281,6 +1418,7 @@ static pa_alsa_jack* ucm_get_jack(pa_alsa_ucm_config *ucm, pa_alsa_ucm_device *d
             goto out;
 
     j = pa_xnew0(pa_alsa_jack, 1);
+    j->device = device;
     j->state_unplugged = PA_AVAILABLE_NO;
     j->state_plugged = PA_AVAILABLE_YES;
     j->name = pa_xstrdup(name);
@@ -1288,9 +1426,38 @@ static pa_alsa_jack* ucm_get_jack(pa_alsa_ucm_config *ucm, pa_alsa_ucm_device *d
     jack_control = pa_proplist_gets(device->proplist, PA_ALSA_PROP_UCM_JACK_CONTROL);
     if (jack_control)
         j->alsa_name = pa_xstrdup(jack_control);
-    else
+    else if (implicit)
         j->alsa_name = pa_sprintf_malloc("%s Jack", device_name);
 
+    jack_hw_mute = pa_proplist_gets(device->proplist, PA_ALSA_PROP_UCM_JACK_HW_MUTE);
+    if (jack_hw_mute) {
+        pa_alsa_ucm_device *device2;
+        bool device_found = false;
+
+        PA_LLIST_FOREACH(device2, device->verb->devices) {
+            const char *device2_name;
+
+            device2_name = pa_proplist_gets(device2->proplist, PA_ALSA_PROP_UCM_NAME);
+
+            if (pa_streq(device2_name, jack_hw_mute)) {
+                device_found = true;
+
+                if (!device2->output_jack && !device2->input_jack) {
+                    j->hw_mute = device2;
+                    device_set_mute_jack(device2, j);
+                } else {
+                    pa_log("[%s] Ignoring \"JackHWMute\", because device availability is already governed by jack \"%s\".",
+                           device2_name, device2->output_jack ? device2->output_jack->name : device2->input_jack->name);
+                }
+
+                break;
+            }
+        }
+
+        if (!device_found)
+            pa_log("[%s] JackHWMute references unknown device: %s", device_name, jack_hw_mute);
+    }
+
     PA_LLIST_PREPEND(pa_alsa_jack, ucm->jacks, j);
 
 out:
@@ -1349,7 +1516,12 @@ static int ucm_create_profile(
     if (verb_info[i].id == NULL)
         p->priority = 1000;
 
+    /* Get jacks for devices (and also associate the device with mappings). No
+     * implicit jacks are allowed (that is, if "JackControl" is not set, a jack
+     * will not be created). */
     PA_LLIST_FOREACH(dev, verb->devices) {
+        pa_alsa_jack *jack;
+
         name = pa_proplist_gets(dev->proplist, PA_ALSA_PROP_UCM_NAME);
 
         sink = pa_proplist_gets(dev->proplist, PA_ALSA_PROP_UCM_SINK);
@@ -1358,9 +1530,57 @@ static int ucm_create_profile(
         ucm_create_mapping(ucm, ps, p, dev, verb_name, name, sink, source);
 
         if (sink)
-            dev->output_jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_OUTPUT);
+            jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_OUTPUT, false);
+
+        if (source)
+            jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_INPUT, false);
+
+        if (jack) {
+            if (dev->mute_jack) {
+                pa_log("[%s] Overriding \"JackHWMute\", because \"JackControl\" is set and takes precedence.", name);
+                device_set_mute_jack(dev, NULL);
+            }
+        }
+
+        if (sink)
+            device_set_output_jack(dev, jack);
+
         if (source)
-            dev->input_jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_INPUT);
+            device_set_input_jack(dev, jack);
+    }
+
+    /* Now go over the device list again and get implicit jacks for devices
+     * that don't have "JackControl" set nor are referenced by any other
+     * device's "JackHWMute". "Implicit" means that the kcontrol name is not
+     * explicitly configured; instead, we generate the kcontrol name from the
+     * device name.
+     *
+     * We need a separate loop instead of creating the implicit jacks in the
+     * same loop as the other jacks, because the full set of mute jack
+     * relationships isn't known before we have iterated over all devices,
+     * and the relationships need to be known before creating the implicit
+     * jacks, since otherwise the implicit jacks could override the mute jacks,
+     * which we don't want. */
+    PA_LLIST_FOREACH(dev, verb->devices) {
+        pa_alsa_jack *jack;
+
+        if (dev->output_jack || dev->input_jack || dev->mute_jack)
+            continue;
+
+        name = pa_proplist_gets(dev->proplist, PA_ALSA_PROP_UCM_NAME);
+
+        sink = pa_proplist_gets(dev->proplist, PA_ALSA_PROP_UCM_SINK);
+        source = pa_proplist_gets(dev->proplist, PA_ALSA_PROP_UCM_SOURCE);
+
+        if (sink) {
+            jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_OUTPUT, true);
+            device_set_output_jack(dev, jack);
+        }
+
+        if (source) {
+            jack = ucm_get_jack(ucm, dev, PA_UCM_PRE_TAG_INPUT, true);
+            device_set_input_jack(dev, jack);
+        }
     }
 
     /* Now find modifiers that have their own PlaybackPCM and create
@@ -1451,7 +1671,10 @@ static void ucm_mapping_jack_probe(pa_alsa_mapping *m) {
     PA_IDXSET_FOREACH(dev, context->ucm_devices, idx) {
         pa_alsa_jack *jack;
         jack = m->direction == PA_ALSA_DIRECTION_OUTPUT ? dev->output_jack : dev->input_jack;
-        pa_assert (jack);
+
+        if (!jack)
+            continue;
+
         jack->has_control = pa_alsa_mixer_find(mixer_handle, jack->alsa_name, 0) != NULL;
         pa_log_info("UCM jack %s has_control=%d", jack->name, jack->has_control);
     }
@@ -1565,6 +1788,12 @@ static void free_verb(pa_alsa_ucm_verb *verb) {
 
     PA_LLIST_FOREACH_SAFE(di, dn, verb->devices) {
         PA_LLIST_REMOVE(pa_alsa_ucm_device, verb->devices, di);
+
+        if (di->ports) {
+            pa_assert(pa_dynarray_size(di->ports) == 0);
+            pa_dynarray_free(di->ports);
+        }
+
         pa_proplist_free(di->proplist);
         if (di->conflicting_devices)
             pa_idxset_free(di->conflicting_devices, NULL);
@@ -1591,6 +1820,15 @@ void pa_alsa_ucm_free(pa_alsa_ucm_config *ucm) {
     pa_alsa_ucm_verb *vi, *vn;
     pa_alsa_jack *ji, *jn;
 
+    if (ucm->ports) {
+        struct port *port;
+
+        while ((port = pa_dynarray_last(ucm->ports)))
+            port_free(port);
+
+        pa_dynarray_free(ucm->ports);
+    }
+
     PA_LLIST_FOREACH_SAFE(vi, vn, ucm->verbs) {
         PA_LLIST_REMOVE(pa_alsa_ucm_verb, ucm->verbs, vi);
         free_verb(vi);
@@ -1685,6 +1923,35 @@ void pa_alsa_ucm_roled_stream_end(pa_alsa_ucm_config *ucm, const char *role, pa_
     }
 }
 
+void pa_alsa_ucm_device_set_available(pa_alsa_ucm_device *device, bool available) {
+    struct port *port;
+    unsigned idx;
+
+    pa_assert(device);
+
+    if (available == device->available)
+        return;
+
+    device->available = available;
+
+    PA_DYNARRAY_FOREACH(port, device->ports, idx) {
+        pa_alsa_ucm_device *device2;
+        unsigned idx2;
+        pa_available_t port_available = PA_AVAILABLE_YES;
+
+        /* If there are any devices associated with the port that are
+         * unavailable, then the port is considered unavailable. */
+        PA_DYNARRAY_FOREACH(device2, port->devices, idx2) {
+            if (!device2->available) {
+                port_available = PA_AVAILABLE_NO;
+                break;
+            }
+        }
+
+        pa_device_port_set_available(port->core_port, port_available);
+    }
+}
+
 #else /* HAVE_ALSA_UCM */
 
 /* Dummy functions for systems without UCM support */
@@ -1739,4 +2006,7 @@ void pa_alsa_ucm_roled_stream_begin(pa_alsa_ucm_config *ucm, const char *role, p
 void pa_alsa_ucm_roled_stream_end(pa_alsa_ucm_config *ucm, const char *role, pa_direction_t dir) {
 }
 
+void pa_alsa_ucm_device_set_available(pa_alsa_ucm_device *device, bool available) {
+}
+
 #endif
diff --git a/src/modules/alsa/alsa-ucm.h b/src/modules/alsa/alsa-ucm.h
index a8c8090..1d76889 100644
--- a/src/modules/alsa/alsa-ucm.h
+++ b/src/modules/alsa/alsa-ucm.h
@@ -30,6 +30,8 @@ typedef void snd_use_case_mgr_t;
 
 #include "alsa-mixer.h"
 
+#include <pulsecore/dynarray.h>
+
 /** For devices: List of verbs, devices or modifiers available */
 #define PA_ALSA_PROP_UCM_NAME                       "alsa.ucm.name"
 
@@ -87,6 +89,9 @@ typedef void snd_use_case_mgr_t;
 /* Corresponds to the "JackControl" UCM value. */
 #define PA_ALSA_PROP_UCM_JACK_CONTROL               "alsa.ucm.jack_control"
 
+/* Corresponds to the "JackHWMute" UCM value. */
+#define PA_ALSA_PROP_UCM_JACK_HW_MUTE               "alsa.ucm.jack_hw_mute"
+
 typedef struct pa_alsa_ucm_verb pa_alsa_ucm_verb;
 typedef struct pa_alsa_ucm_modifier pa_alsa_ucm_modifier;
 typedef struct pa_alsa_ucm_device pa_alsa_ucm_device;
@@ -122,7 +127,15 @@ void pa_alsa_ucm_roled_stream_end(pa_alsa_ucm_config *ucm, const char *role, pa_
 
 /* UCM - Use Case Manager is available on some audio cards */
 
+struct pa_alsa_ucm_port {
+    pa_device_port *core_port;
+    pa_dynarray *devices; /* pa_alsa_ucm_device */
+    bool available;
+};
+
 struct pa_alsa_ucm_device {
+    pa_alsa_ucm_verb *verb;
+
     PA_LLIST_FIELDS(pa_alsa_ucm_device);
 
     pa_proplist *proplist;
@@ -142,10 +155,33 @@ struct pa_alsa_ucm_device {
     pa_idxset *conflicting_devices;
     pa_idxset *supported_devices;
 
+    pa_dynarray *ports; /* pa_alsa_ucm_port */
+
+    /* These jacks are owned by this device. When these jacks are plugged in,
+     * the device is marked as available, and when these jacks are unplugged,
+     * the device is marked as unavailable. Not all devices have jacks
+     * associated with them; those devices are always marked as available.
+     *
+     * XXX: It's probably pointless to have separate jacks for input and
+     * output. Both jack objects will anyway reference the same alsa
+     * kcontrol, so they will always have the same state. */
     pa_alsa_jack *input_jack;
     pa_alsa_jack *output_jack;
+
+    /* The "mute jack" is owned by some other device. The mute jack makes this
+     * device unavailable when it's plugged in. A device can't have both a
+     * "normal" jack (meaning the output_jack or input_jack field) and a mute
+     * jack, because there would be ambiguity about which jack is controlling
+     * the device availability. If the configuration tries to set both types of
+     * jacks for one device, the normal jack has precedence and mute_jack gets
+     * set to NULL. */
+    pa_alsa_jack *mute_jack;
+
+    bool available;
 };
 
+void pa_alsa_ucm_device_set_available(pa_alsa_ucm_device *device, bool available);
+
 struct pa_alsa_ucm_modifier {
     PA_LLIST_FIELDS(pa_alsa_ucm_modifier);
 
@@ -185,6 +221,7 @@ struct pa_alsa_ucm_config {
 
     PA_LLIST_HEAD(pa_alsa_ucm_verb, verbs);
     PA_LLIST_HEAD(pa_alsa_jack, jacks);
+    pa_dynarray *ports; /* struct port */
 };
 
 struct pa_alsa_ucm_mapping_context {
diff --git a/src/modules/alsa/module-alsa-card.c b/src/modules/alsa/module-alsa-card.c
index a7fec04..7ac750f 100644
--- a/src/modules/alsa/module-alsa-card.c
+++ b/src/modules/alsa/module-alsa-card.c
@@ -384,16 +384,18 @@ static int report_jack_state(snd_mixer_elem_t *melem, unsigned int mask) {
 
     PA_HASHMAP_FOREACH(jack, u->jacks, state)
         if (jack->melem == melem) {
-            jack->plugged_in = plugged_in;
+            pa_alsa_jack_set_plugged_in(jack, plugged_in);
+
             if (u->use_ucm) {
-                pa_assert(u->card->ports);
-                port = pa_hashmap_get(u->card->ports, jack->name);
-                pa_assert(port);
-            }
-            else {
-                pa_assert(jack->path);
-                pa_assert_se(port = jack->path->port);
+                /* 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(jack->path);
+            pa_assert_se(port = jack->path->port);
             report_port_state(port, u);
         }
     return 0;
diff --git a/src/pulsecore/device-port.c b/src/pulsecore/device-port.c
index cfe2a80..906ab1f 100644
--- a/src/pulsecore/device-port.c
+++ b/src/pulsecore/device-port.c
@@ -66,8 +66,6 @@ void pa_device_port_new_data_done(pa_device_port_new_data *data) {
 }
 
 void pa_device_port_set_available(pa_device_port *p, pa_available_t status) {
-    pa_core *core;
-
     pa_assert(p);
 
     if (p->available == status)
@@ -80,10 +78,14 @@ void pa_device_port_set_available(pa_device_port *p, pa_available_t status) {
        status == PA_AVAILABLE_NO ? "no" : "unknown");
 
     /* Post subscriptions to the card which owns us */
-    pa_assert_se(core = p->core);
-    pa_subscription_post(core, PA_SUBSCRIPTION_EVENT_CARD|PA_SUBSCRIPTION_EVENT_CHANGE, p->card->index);
-
-    pa_hook_fire(&core->hooks[PA_CORE_HOOK_PORT_AVAILABLE_CHANGED], p);
+    /* XXX: We need to check p->card, because this function may be called
+     * before the card object has been created. The card object should probably
+     * be created before port objects, and then p->card could be non-NULL for
+     * the whole lifecycle of pa_device_port. */
+    if (p->card) {
+        pa_subscription_post(p->core, PA_SUBSCRIPTION_EVENT_CARD|PA_SUBSCRIPTION_EVENT_CHANGE, p->card->index);
+        pa_hook_fire(&p->core->hooks[PA_CORE_HOOK_PORT_AVAILABLE_CHANGED], p);
+    }
 }
 
 static void device_port_free(pa_object *o) {
-- 
1.9.3



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux