1 files changed, 262 insertions, 91 deletions

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index f26e487eca1c..9c27a3a4c4d5 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -243,7 +243,8 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
 {
         unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
         unsigned int res;
-        codec_exec_verb(codec, cmd, &res);
+        if (codec_exec_verb(codec, cmd, &res))
+                return -1;
         return res;
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_read);
@@ -307,63 +308,107 @@ int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
 }
 EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
 
-static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
-                                hda_nid_t *conn_list, int max_conns);
-static bool add_conn_list(struct snd_array *array, hda_nid_t nid);
-static int copy_conn_list(hda_nid_t nid, hda_nid_t *dst, int max_dst,
-                          hda_nid_t *src, int len);
+/* look up the cached results */
+static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
+{
+        int i, len;
+        for (i = 0; i < array->used; ) {
+                hda_nid_t *p = snd_array_elem(array, i);
+                if (nid == *p)
+                        return p;
+                len = p[1];
+                i += len + 2;
+        }
+        return NULL;
+}
 
 /**
- * snd_hda_get_connections - get connection list
+ * snd_hda_get_conn_list - get connection list
  * @codec: the HDA codec
  * @nid: NID to parse
- * @conn_list: connection list array
- * @max_conns: max. number of connections to store
+ * @listp: the pointer to store NID list
  *
  * Parses the connection list of the given widget and stores the list
  * of NIDs.
  *
  * Returns the number of connections, or a negative error code.
  */
-int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
-                             hda_nid_t *conn_list, int max_conns)
+int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
+                          const hda_nid_t **listp)
 {
         struct snd_array *array = &codec->conn_lists;
-        int i, len, old_used;
+        int len, err;
         hda_nid_t list[HDA_MAX_CONNECTIONS];
+        hda_nid_t *p;
+        bool added = false;
 
-        /* look up the cached results */
-        for (i = 0; i < array->used; ) {
-                hda_nid_t *p = snd_array_elem(array, i);
-                len = p[1];
-                if (nid == *p)
-                        return copy_conn_list(nid, conn_list, max_conns,
-                                              p + 2, len);
-                i += len + 2;
+ again:
+        /* if the connection-list is already cached, read it */
+        p = lookup_conn_list(array, nid);
+        if (p) {
+                if (listp)
+                        *listp = p + 2;
+                return p[1];
         }
+        if (snd_BUG_ON(added))
+                return -EINVAL;
 
-        len = _hda_get_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
+        /* read the connection and add to the cache */
+        len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
         if (len < 0)
                 return len;
+        err = snd_hda_override_conn_list(codec, nid, len, list);
+        if (err < 0)
+                return err;
+        added = true;
+        goto again;
+}
+EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
 
-        /* add to the cache */
-        old_used = array->used;
-        if (!add_conn_list(array, nid) || !add_conn_list(array, len))
-                goto error_add;
-        for (i = 0; i < len; i++)
-                if (!add_conn_list(array, list[i]))
-                        goto error_add;
+/**
+ * snd_hda_get_connections - copy connection list
+ * @codec: the HDA codec
+ * @nid: NID to parse
+ * @conn_list: connection list array
+ * @max_conns: max. number of connections to store
+ *
+ * Parses the connection list of the given widget and stores the list
+ * of NIDs.
+ *
+ * Returns the number of connections, or a negative error code.
+ */
+int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
+                             hda_nid_t *conn_list, int max_conns)
+{
+        const hda_nid_t *list;
+        int len = snd_hda_get_conn_list(codec, nid, &list);
 
-        return copy_conn_list(nid, conn_list, max_conns, list, len);
-                
- error_add:
-        array->used = old_used;
-        return -ENOMEM;
+        if (len <= 0)
+                return len;
+        if (len > max_conns) {
+                snd_printk(KERN_ERR "hda_codec: "
+                           "Too many connections %d for NID 0x%x\n",
+                           len, nid);
+                return -EINVAL;
+        }
+        memcpy(conn_list, list, len * sizeof(hda_nid_t));
+        return len;
 }
 EXPORT_SYMBOL_HDA(snd_hda_get_connections);
 
-static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
-                             hda_nid_t *conn_list, int max_conns)
+/**
+ * snd_hda_get_raw_connections - copy connection list without cache
+ * @codec: the HDA codec
+ * @nid: NID to parse
+ * @conn_list: connection list array
+ * @max_conns: max. number of connections to store
+ *
+ * Like snd_hda_get_connections(), copy the connection list but without
+ * checking through the connection-list cache.
+ * Currently called only from hda_proc.c, so not exported.
+ */
+int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
+                                hda_nid_t *conn_list, int max_conns)
 {
         unsigned int parm;
         int i, conn_len, conns;
@@ -376,11 +421,8 @@ static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
 
         wcaps = get_wcaps(codec, nid);
         if (!(wcaps & AC_WCAP_CONN_LIST) &&
-            get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
-                snd_printk(KERN_WARNING "hda_codec: "
-                           "connection list not available for 0x%x\n", nid);
-                return -EINVAL;
-        }
+            get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
+                return 0;
 
         parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
         if (parm & AC_CLIST_LONG) {
@@ -470,18 +512,77 @@ static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
         return true;
 }
 
-static int copy_conn_list(hda_nid_t nid, hda_nid_t *dst, int max_dst,
-                          hda_nid_t *src, int len)
+/**
+ * snd_hda_override_conn_list - add/modify the connection-list to cache
+ * @codec: the HDA codec
+ * @nid: NID to parse
+ * @len: number of connection list entries
+ * @list: the list of connection entries
+ *
+ * Add or modify the given connection-list to the cache.  If the corresponding
+ * cache already exists, invalidate it and append a new one.
+ *
+ * Returns zero or a negative error code.
+ */
+int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
+                               const hda_nid_t *list)
+{
+        struct snd_array *array = &codec->conn_lists;
+        hda_nid_t *p;
+        int i, old_used;
+
+        p = lookup_conn_list(array, nid);
+        if (p)
+                *p = -1; /* invalidate the old entry */
+
+        old_used = array->used;
+        if (!add_conn_list(array, nid) || !add_conn_list(array, len))
+                goto error_add;
+        for (i = 0; i < len; i++)
+                if (!add_conn_list(array, list[i]))
+                        goto error_add;
+        return 0;
+
+ error_add:
+        array->used = old_used;
+        return -ENOMEM;
+}
+EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
+
+/**
+ * snd_hda_get_conn_index - get the connection index of the given NID
+ * @codec: the HDA codec
+ * @mux: NID containing the list
+ * @nid: NID to select
+ * @recursive: 1 when searching NID recursively, otherwise 0
+ *
+ * Parses the connection list of the widget @mux and checks whether the
+ * widget @nid is present.  If it is, return the connection index.
+ * Otherwise it returns -1.
+ */
+int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
+                           hda_nid_t nid, int recursive)
 {
-        if (len > max_dst) {
-                snd_printk(KERN_ERR "hda_codec: "
-                           "Too many connections %d for NID 0x%x\n",
-                           len, nid);
-                return -EINVAL;
+        hda_nid_t conn[HDA_MAX_NUM_INPUTS];
+        int i, nums;
+
+        nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
+        for (i = 0; i < nums; i++)
+                if (conn[i] == nid)
+                        return i;
+        if (!recursive)
+                return -1;
+        if (recursive > 5) {
+                snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
+                return -1;
         }
-        memcpy(dst, src, len * sizeof(hda_nid_t));
-        return len;
+        recursive++;
+        for (i = 0; i < nums; i++)
+                if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
+                        return i;
+        return -1;
 }
+EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
 
 /**
  * snd_hda_queue_unsol_event - add an unsolicited event to queue
@@ -1083,6 +1184,7 @@ static void snd_hda_codec_free(struct hda_codec *codec)
         snd_array_free(&codec->mixers);
         snd_array_free(&codec->nids);
         snd_array_free(&codec->conn_lists);
+        snd_array_free(&codec->spdif_out);
         codec->bus->caddr_tbl[codec->addr] = NULL;
         if (codec->patch_ops.free)
                 codec->patch_ops.free(codec);
@@ -1144,6 +1246,7 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
         snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
         snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
+        snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
         if (codec->bus->modelname) {
                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
                 if (!codec->modelname) {
@@ -2555,11 +2658,13 @@ static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
                                      struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        int idx = kcontrol->private_value;
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
 
-        ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
-        ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
-        ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
-        ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
+        ucontrol->value.iec958.status[0] = spdif->status & 0xff;
+        ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
+        ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
+        ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
 
         return 0;
 }
@@ -2644,23 +2749,23 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
                                      struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        hda_nid_t nid = kcontrol->private_value;
+        int idx = kcontrol->private_value;
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
+        hda_nid_t nid = spdif->nid;
         unsigned short val;
         int change;
 
         mutex_lock(&codec->spdif_mutex);
-        codec->spdif_status = ucontrol->value.iec958.status[0] |
+        spdif->status = ucontrol->value.iec958.status[0] |
                 ((unsigned int)ucontrol->value.iec958.status[1] << 8) |
                 ((unsigned int)ucontrol->value.iec958.status[2] << 16) |
                 ((unsigned int)ucontrol->value.iec958.status[3] << 24);
-        val = convert_from_spdif_status(codec->spdif_status);
-        val |= codec->spdif_ctls & 1;
-        change = codec->spdif_ctls != val;
-        codec->spdif_ctls = val;
-
-        if (change)
+        val = convert_from_spdif_status(spdif->status);
+        val |= spdif->ctls & 1;
+        change = spdif->ctls != val;
+        spdif->ctls = val;
+        if (change && nid != (u16)-1)
                 set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
-
         mutex_unlock(&codec->spdif_mutex);
         return change;
 }
@@ -2671,33 +2776,42 @@ static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
                                         struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        int idx = kcontrol->private_value;
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
 
-        ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
+        ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
         return 0;
 }
 
+static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
+                                  int dig1, int dig2)
+{
+        set_dig_out_convert(codec, nid, dig1, dig2);
+        /* unmute amp switch (if any) */
+        if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
+            (dig1 & AC_DIG1_ENABLE))
+                snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
+                                            HDA_AMP_MUTE, 0);
+}
+
 static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
                                         struct snd_ctl_elem_value *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        hda_nid_t nid = kcontrol->private_value;
+        int idx = kcontrol->private_value;
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
+        hda_nid_t nid = spdif->nid;
         unsigned short val;
         int change;
 
         mutex_lock(&codec->spdif_mutex);
-        val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
+        val = spdif->ctls & ~AC_DIG1_ENABLE;
         if (ucontrol->value.integer.value[0])
                 val |= AC_DIG1_ENABLE;
-        change = codec->spdif_ctls != val;
-        if (change) {
-                codec->spdif_ctls = val;
-                set_dig_out_convert(codec, nid, val & 0xff, -1);
-                /* unmute amp switch (if any) */
-                if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
-                    (val & AC_DIG1_ENABLE))
-                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
-                                                 HDA_AMP_MUTE, 0);
-        }
+        change = spdif->ctls != val;
+        spdif->ctls = val;
+        if (change && nid != (u16)-1)
+                set_spdif_ctls(codec, nid, val & 0xff, -1);
         mutex_unlock(&codec->spdif_mutex);
         return change;
 }
@@ -2744,36 +2858,79 @@ static struct snd_kcontrol_new dig_mixes[] = {
  *
  * Returns 0 if successful, or a negative error code.
  */
-int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
+int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
+                                  hda_nid_t associated_nid,
+                                  hda_nid_t cvt_nid)
 {
         int err;
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_new *dig_mix;
         int idx;
+        struct hda_spdif_out *spdif;
 
         idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
         if (idx < 0) {
                 printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
                 return -EBUSY;
         }
+        spdif = snd_array_new(&codec->spdif_out);
         for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
                 kctl = snd_ctl_new1(dig_mix, codec);
                 if (!kctl)
                         return -ENOMEM;
                 kctl->id.index = idx;
-                kctl->private_value = nid;
-                err = snd_hda_ctl_add(codec, nid, kctl);
+                kctl->private_value = codec->spdif_out.used - 1;
+                err = snd_hda_ctl_add(codec, associated_nid, kctl);
                 if (err < 0)
                         return err;
         }
-        codec->spdif_ctls =
-                snd_hda_codec_read(codec, nid, 0,
-                                   AC_VERB_GET_DIGI_CONVERT_1, 0);
-        codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
+        spdif->nid = cvt_nid;
+        spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
+                                         AC_VERB_GET_DIGI_CONVERT_1, 0);
+        spdif->status = convert_to_spdif_status(spdif->ctls);
         return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
 
+struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
+                                               hda_nid_t nid)
+{
+        int i;
+        for (i = 0; i < codec->spdif_out.used; i++) {
+                struct hda_spdif_out *spdif =
+                                snd_array_elem(&codec->spdif_out, i);
+                if (spdif->nid == nid)
+                        return spdif;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
+
+void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
+{
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
+
+        mutex_lock(&codec->spdif_mutex);
+        spdif->nid = (u16)-1;
+        mutex_unlock(&codec->spdif_mutex);
+}
+EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
+
+void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
+{
+        struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
+        unsigned short val;
+
+        mutex_lock(&codec->spdif_mutex);
+        if (spdif->nid != nid) {
+                spdif->nid = nid;
+                val = spdif->ctls;
+                set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
+        }
+        mutex_unlock(&codec->spdif_mutex);
+}
+EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
+
 /*
  * SPDIF sharing with analog output
  */
@@ -3356,7 +3513,7 @@ static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
  *
  * Returns 0 if successful, otherwise a negative error code.
  */
-static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
+int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
                                 u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
 {
         unsigned int i, val, wcaps;
@@ -3448,6 +3605,7 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
 
         return 0;
 }
+EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
 
 /**
  * snd_hda_is_supported_format - Check the validity of the format
@@ -4177,10 +4335,12 @@ EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
 static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
                                  unsigned int stream_tag, unsigned int format)
 {
+        struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
+
         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
-        if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
+        if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
                 set_dig_out_convert(codec, nid,
-                                    codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
+                                    spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
                                     -1);
         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
         if (codec->slave_dig_outs) {
@@ -4190,9 +4350,9 @@ static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
                                                    format);
         }
         /* turn on again (if needed) */
-        if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
+        if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
                 set_dig_out_convert(codec, nid,
-                                    codec->spdif_ctls & 0xff, -1);
+                                    spdif->ctls & 0xff, -1);
 }
 
 static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
@@ -4348,6 +4508,8 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
 {
         const hda_nid_t *nids = mout->dac_nids;
         int chs = substream->runtime->channels;
+        struct hda_spdif_out *spdif =
+                        snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
         int i;
 
         mutex_lock(&codec->spdif_mutex);
@@ -4356,7 +4518,7 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
                 if (chs == 2 &&
                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
                                                 format) &&
-                    !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
+                    !(spdif->status & IEC958_AES0_NONAUDIO)) {
                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
                         setup_dig_out_stream(codec, mout->dig_out_nid,
                                              stream_tag, format);
@@ -4528,7 +4690,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                 unsigned int wid_caps = get_wcaps(codec, nid);
                 unsigned int wid_type = get_wcaps_type(wid_caps);
                 unsigned int def_conf;
-                short assoc, loc;
+                short assoc, loc, conn, dev;
 
                 /* read all default configuration for pin complex */
                 if (wid_type != AC_WID_PIN)
@@ -4538,10 +4700,19 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                         continue;
 
                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
-                if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
+                conn = get_defcfg_connect(def_conf);
+                if (conn == AC_JACK_PORT_NONE)
                         continue;
                 loc = get_defcfg_location(def_conf);
-                switch (get_defcfg_device(def_conf)) {
+                dev = get_defcfg_device(def_conf);
+
+                /* workaround for buggy BIOS setups */
+                if (dev == AC_JACK_LINE_OUT) {
+                        if (conn == AC_JACK_PORT_FIXED)
+                                dev = AC_JACK_SPEAKER;
+                }
+
+                switch (dev) {
                 case AC_JACK_LINE_OUT:
                         seq = get_defcfg_sequence(def_conf);
                         assoc = get_defcfg_association(def_conf);