Changeset 694

Timestamp:

Aug 15, 2021, 1:07:08 AM (4 years ago)

Author:

Paul Smedley

Message:

Update linux source to 5.13.10

Location:

GPL/branches/uniaud32-next

Files:

• alsa-kernel/core/control.c (modified) (36 diffs)
• alsa-kernel/core/oss/pcm_oss.c (modified) (1 diff)
• alsa-kernel/core/pcm_memory.c (modified) (3 diffs)
• alsa-kernel/core/pcm_native.c (modified) (4 diffs)
• alsa-kernel/core/seq/seq_ports.c (modified) (5 diffs)
• alsa-kernel/core/seq_device.c (modified) (1 diff)
• alsa-kernel/hda/hdac_stream.c (modified) (1 diff)
• alsa-kernel/include/sound/control.h (modified) (7 diffs)
• alsa-kernel/include/sound/core.h (modified) (1 diff)
• alsa-kernel/include/sound/hda_register.h (modified) (1 diff)
• alsa-kernel/include/sound/simple_card_utils.h (modified) (12 diffs)
• alsa-kernel/include/sound/soc-acpi.h (modified) (2 diffs)
• alsa-kernel/include/sound/soc-component.h (modified) (5 diffs)
• alsa-kernel/include/sound/soc-dai.h (modified) (1 diff)
• alsa-kernel/include/sound/soc-dpcm.h (modified) (2 diffs)
• alsa-kernel/include/sound/soc.h (modified) (4 diffs)
• alsa-kernel/include/sound/sof.h (modified) (1 diff)
• alsa-kernel/include/sound/version.h (modified) (1 diff)
• alsa-kernel/isa/sb/sb16_csp.c (modified) (4 diffs)
• alsa-kernel/isa/sb/sb8.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_auto_parser.h (modified) (1 diff)
• alsa-kernel/pci/hda/hda_codec.c (modified) (5 diffs)
• alsa-kernel/pci/hda/hda_generic.c (modified) (12 diffs)
• alsa-kernel/pci/hda/hda_generic.h (modified) (3 diffs)
• alsa-kernel/pci/hda/hda_jack.c (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_jack.h (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_local.h (modified) (4 diffs)
• alsa-kernel/pci/hda/patch_ca0132.c (modified) (1 diff)
• alsa-kernel/pci/hda/patch_cirrus.c (modified) (23 diffs)
• alsa-kernel/pci/hda/patch_hdmi.c (modified) (1 diff)
• alsa-kernel/pci/hda/patch_realtek.c (modified) (9 diffs)
• alsa-kernel/pci/hda/patch_sigmatel.c (modified) (2 diffs)
• alsa-kernel/pci/hda/thinkpad_helper.c (modified) (1 diff)
• include/linux/kmod.h (modified) (1 diff)
• include/linux/moduleparam.h (modified) (1 diff)
• include/linux/rwsem.h (modified) (1 diff)
• include/linux/slab.h (modified) (1 diff)

GPL/branches/uniaud32-next/alsa-kernel/core/control.c ¶

@@ -8 +8 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
@@ -19 +20 @@
 #include <sound/control.h>
 
-/* max number of user-defined controls */
-#define MAX_USER_CONTROLS       32
+// Max allocation size for user controls.
+static int max_user_ctl_alloc_size = 8 * 1024 * 1024;
+module_param_named(max_user_ctl_alloc_size, max_user_ctl_alloc_size, int, 0444);
+MODULE_PARM_DESC(max_user_ctl_alloc_size, "Max allocation size for user controls");
+
 #define MAX_CONTROL_COUNT       1028
 
@@ -31 +35 @@
 
 static DECLARE_RWSEM(snd_ioctl_rwsem);
+static DECLARE_RWSEM(snd_ctl_layer_rwsem);
 static LIST_HEAD(snd_control_ioctls);
 #ifdef CONFIG_COMPAT
 static LIST_HEAD(snd_control_compat_ioctls);
 #endif
+static struct snd_ctl_layer_ops *snd_ctl_layer;
 
 static int snd_ctl_open(struct inode *inode, struct file *file)
@@ -185 +191 @@
 
 /**
+ * snd_ctl_notify_one - Send notification to user-space for a control change
+ * @card: the card to send notification
+ * @mask: the event mask, SNDRV_CTL_EVENT_*
+ * @kctl: the pointer with the control instance
+ * @ioff: the additional offset to the control index
+ *
+ * This function calls snd_ctl_notify() and does additional jobs
+ * like LED state changes.
+ */
+void snd_ctl_notify_one(struct snd_card *card, unsigned int mask,
+                        struct snd_kcontrol *kctl, unsigned int ioff)
+{
+        struct snd_ctl_elem_id id = kctl->id;
+        struct snd_ctl_layer_ops *lops;
+
+        id.index += ioff;
+        id.numid += ioff;
+        snd_ctl_notify(card, mask, &id);
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                lops->lnotify(card, mask, kctl, ioff);
+        up_read(&snd_ctl_layer_rwsem);
+}
+EXPORT_SYMBOL(snd_ctl_notify_one);
+
+/**
  * snd_ctl_new - create a new control instance with some elements
  * @kctl: the pointer to store new control instance
@@ -263 +295 @@
                    SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND |
                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK |
+                   SNDRV_CTL_ELEM_ACCESS_LED_MASK |
                    SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK);
 
@@ -355 +388 @@
         struct snd_ctl_elem_id id;
         unsigned int idx;
-        unsigned int count;
         struct snd_kcontrol *old;
         int err;
@@ -389 +421 @@
         card->last_numid += kcontrol->count;
 
-        id = kcontrol->id;
-        count = kcontrol->count;
-        for (idx = 0; idx < count; idx++, id.index++, id.numid++)
-                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_ADD, &id);
+        for (idx = 0; idx < kcontrol->count; idx++)
+                snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_ADD, kcontrol, idx);
 
         return 0;
@@ -475 +505 @@
 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 {
-        struct snd_ctl_elem_id id;
         unsigned int idx;
 
@@ -482 +511 @@
         list_del(&kcontrol->list);
         card->controls_count -= kcontrol->count;
-        id = kcontrol->id;
-        for (idx = 0; idx < kcontrol->count; idx++, id.index++, id.numid++)
-                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_REMOVE, &id);
+        for (idx = 0; idx < kcontrol->count; idx++)
+                snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_REMOVE, kcontrol, idx);
         snd_ctl_free_one(kcontrol);
         return 0;
@@ -550 +578 @@
                 }
         ret = snd_ctl_remove(card, kctl);
-        if (ret < 0)
-                goto error;
-        card->user_ctl_count--;
 error:
         up_write(&card->controls_rwsem);
@@ -597 +622 @@
         }
         snd_ctl_build_ioff(id, kctl, index_offset);
-        ret = 1;
+        downgrade_write(&card->controls_rwsem);
+        snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_INFO, kctl, index_offset);
+        up_read(&card->controls_rwsem);
+        return 1;
+
  unlock:
         up_write(&card->controls_rwsem);
-        if (ret > 0)
-                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, id);
         return ret;
 }
@@ -1035 +1062 @@
                 return result;
         /* drop internal access flags */
-        info.access &= ~SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK;
+        info.access &= ~(SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK|
+                         SNDRV_CTL_ELEM_ACCESS_LED_MASK);
         if (copy_to_user(_info, &info, sizeof(info)))
                 return -EFAULT;
@@ -1123 +1151 @@
         int result;
 
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &control->id);
-        if (kctl == NULL)
+        if (kctl == NULL) {
+                up_write(&card->controls_rwsem);
                 return -ENOENT;
+        }
 
         index_offset = snd_ctl_get_ioff(kctl, &control->id);
@@ -1131 +1162 @@
         if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_WRITE) || kctl->put == NULL ||
             (file && vd->owner && vd->owner != file)) {
+                up_write(&card->controls_rwsem);
                 return -EPERM;
         }
@@ -1136 +1168 @@
         snd_ctl_build_ioff(&control->id, kctl, index_offset);
         result = kctl->put(kctl, control);
-        if (result < 0)
+        if (result < 0) {
+                up_write(&card->controls_rwsem);
                 return result;
+        }
 
         if (result > 0) {
-                struct snd_ctl_elem_id id = control->id;
-                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &id);
+                downgrade_write(&card->controls_rwsem);
+                snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_VALUE, kctl, index_offset);
+                up_read(&card->controls_rwsem);
+        } else {
+                up_write(&card->controls_rwsem);
         }
 
@@ -1163 +1200 @@
                 goto error;
 
-        down_write(&card->controls_rwsem);
         result = snd_ctl_elem_write(card, file, control);
-        up_write(&card->controls_rwsem);
         if (result < 0)
                 goto error;
@@ -1244 +1279 @@
 };
 
+// check whether the addition (in bytes) of user ctl element may overflow the limit.
+static bool check_user_elem_overflow(struct snd_card *card, ssize_t add)
+{
+        return (ssize_t)card->user_ctl_alloc_size + add > max_user_ctl_alloc_size;
+}
+
 static int snd_ctl_elem_user_info(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_info *uinfo)
@@ -1309 +1350 @@
 }
 
+/* called in controls_rwsem write lock */
 static int replace_user_tlv(struct snd_kcontrol *kctl, unsigned int __user *buf,
                             unsigned int size)
@@ -1314 +1356 @@
         struct user_element *ue = kctl->private_data;
         unsigned int *container;
-        struct snd_ctl_elem_id id;
         unsigned int mask = 0;
         int i;
@@ -1321 +1362 @@
         if (size > 1024 * 128)  /* sane value */
                 return -EINVAL;
+
+        // does the TLV size change cause overflow?
+        if (check_user_elem_overflow(ue->card, (ssize_t)(size - ue->tlv_data_size)))
+                return -ENOMEM;
 
         container = vmemdup_user(buf, size);
@@ -1339 +1384 @@
                         kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
                 mask = SNDRV_CTL_EVENT_MASK_INFO;
-        }
-
-        kvfree(ue->tlv_data);
+        } else {
+                ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
+                ue->tlv_data_size = 0;
+                kvfree(ue->tlv_data);
+        }
+
         ue->tlv_data = container;
         ue->tlv_data_size = size;
+        // decremented at private_free.
+        ue->card->user_ctl_alloc_size += size;
 
         mask |= SNDRV_CTL_EVENT_MASK_TLV;
-        for (i = 0; i < kctl->count; ++i) {
-                snd_ctl_build_ioff(&id, kctl, i);
-                snd_ctl_notify(ue->card, mask, &id);
-        }
+        for (i = 0; i < kctl->count; ++i)
+                snd_ctl_notify_one(ue->card, mask, kctl, i);
 
         return change;
@@ -1380 +1428 @@
 }
 
+/* called in controls_rwsem write lock */
 static int snd_ctl_elem_init_enum_names(struct user_element *ue)
 {
@@ -1388 +1437 @@
 uintptr_t user_ptrval = ue->info.value.enumerated.names_ptr;
 
-        if (ue->info.value.enumerated.names_length > 64 * 1024)
+        buf_len = ue->info.value.enumerated.names_length;
+        if (buf_len > 64 * 1024)
                 return -EINVAL;
 
-        names = vmemdup_user((const void __user *)user_ptrval,
-                ue->info.value.enumerated.names_length);
+        if (check_user_elem_overflow(ue->card, buf_len))
+                return -ENOMEM;
+        names = vmemdup_user((const void __user *)user_ptrval, buf_len);
         if (IS_ERR(names))
                 return PTR_ERR(names);
 
         /* check that there are enough valid names */
-        buf_len = ue->info.value.enumerated.names_length;
         p = names;
         for (i = 0; i < ue->info.value.enumerated.items; ++i) {
@@ -1411 +1461 @@
         ue->priv_data = names;
         ue->info.value.enumerated.names_ptr = 0;
-
-        return 0;
+        // increment the allocation size; decremented again at private_free.
+        ue->card->user_ctl_alloc_size += ue->info.value.enumerated.names_length;
+
+        return 0;
+}
+
+static size_t compute_user_elem_size(size_t size, unsigned int count)
+{
+        return sizeof(struct user_element) + size * count;
 }
 
@@ -1418 +1475 @@
 {
         struct user_element *ue = kcontrol->private_data;
+
+        // decrement the allocation size.
+        ue->card->user_ctl_alloc_size -= compute_user_elem_size(ue->elem_data_size, kcontrol->count);
+        ue->card->user_ctl_alloc_size -= ue->tlv_data_size;
+        if (ue->priv_data)
+                ue->card->user_ctl_alloc_size -= ue->info.value.enumerated.names_length;
 
         kvfree(ue->tlv_data);
@@ -1432 +1495 @@
         unsigned int access;
         long private_size;
+        size_t alloc_size;
         struct user_element *ue;
         unsigned int offset;
@@ -1448 +1512 @@
                         return err;
         }
-
-        /*
-         * The number of userspace controls are counted control by control,
-         * not element by element.
-         */
-        if (card->user_ctl_count + 1 > MAX_USER_CONTROLS)
-                return -ENOMEM;
 
         /* Check the number of elements for this userspace control. */
@@ -1486 +1543 @@
                 return -EINVAL;
         private_size = value_sizes[info->type] * info->count;
+        alloc_size = compute_user_elem_size(private_size, count);
+
+        down_write(&card->controls_rwsem);
+        if (check_user_elem_overflow(card, alloc_size)) {
+                err = -ENOMEM;
+                goto unlock;
+        }
 
         /*
@@ -1495 +1559 @@
         err = snd_ctl_new(&kctl, count, access, file);
         if (err < 0)
-                return err;
+                goto unlock;
         memcpy(&kctl->id, &info->id, sizeof(kctl->id));
-        kctl->private_data = kzalloc(sizeof(struct user_element) + private_size * count,
-                                     GFP_KERNEL);
-        if (kctl->private_data == NULL) {
+        ue = kzalloc(alloc_size, GFP_KERNEL);
+        if (!ue) {
                 kfree(kctl);
-                return -ENOMEM;
-        }
+                err = -ENOMEM;
+                goto unlock;
+        }
+        kctl->private_data = ue;
         kctl->private_free = snd_ctl_elem_user_free;
 
+        // increment the allocated size; decremented again at private_free.
+        card->user_ctl_alloc_size += alloc_size;
+
         /* Set private data for this userspace control. */
-        ue = (struct user_element *)kctl->private_data;
         ue->card = card;
         ue->info = *info;
@@ -1516 +1583 @@
                 if (err < 0) {
                         snd_ctl_free_one(kctl);
-                        return err;
+                        goto unlock;
                 }
         }
@@ -1533 +1600 @@
 
         /* This function manage to free the instance on failure. */
-        down_write(&card->controls_rwsem);
         err = __snd_ctl_add_replace(card, kctl, CTL_ADD_EXCLUSIVE);
         if (err < 0) {
@@ -1548 +1614 @@
          * which locks the element.
          */
-
-        card->user_ctl_count++;
-
  unlock:
         up_write(&card->controls_rwsem);
@@ -1990 +2053 @@
 
 /*
+ * control layers (audio LED etc.)
+ */
+
+/**
+ * snd_ctl_request_layer - request to use the layer
+ * @module_name: Name of the kernel module (NULL == build-in)
+ *
+ * Return an error code when the module cannot be loaded.
+ */
+int snd_ctl_request_layer(const char *module_name)
+{
+        struct snd_ctl_layer_ops *lops;
+
+        if (module_name == NULL)
+                return 0;
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                if (strcmp(lops->module_name, module_name) == 0)
+                        break;
+        up_read(&snd_ctl_layer_rwsem);
+        if (lops)
+                return 0;
+        return request_module(module_name);
+}
+EXPORT_SYMBOL_GPL(snd_ctl_request_layer);
+
+/**
+ * snd_ctl_register_layer - register new control layer
+ * @lops: operation structure
+ *
+ * The new layer can track all control elements and do additional
+ * operations on top (like audio LED handling).
+ */
+void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops)
+{
+        struct snd_card *card;
+        int card_number;
+
+        down_write(&snd_ctl_layer_rwsem);
+        lops->next = snd_ctl_layer;
+        snd_ctl_layer = lops;
+        up_write(&snd_ctl_layer_rwsem);
+        for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
+                card = snd_card_ref(card_number);
+                if (card) {
+                        down_read(&card->controls_rwsem);
+                        lops->lregister(card);
+                        up_read(&card->controls_rwsem);
+                        snd_card_unref(card);
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(snd_ctl_register_layer);
+
+/**
+ * snd_ctl_disconnect_layer - disconnect control layer
+ * @lops: operation structure
+ *
+ * It is expected that the information about tracked cards
+ * is freed before this call (the disconnect callback is
+ * not called here).
+ */
+void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops)
+{
+        struct snd_ctl_layer_ops *lops2, *prev_lops2;
+
+        down_write(&snd_ctl_layer_rwsem);
+        for (lops2 = snd_ctl_layer, prev_lops2 = NULL; lops2; lops2 = lops2->next) {
+                if (lops2 == lops) {
+                        if (!prev_lops2)
+                                snd_ctl_layer = lops->next;
+                        else
+                                prev_lops2->next = lops->next;
+                        break;
+                }
+                prev_lops2 = lops2;
+        }
+        up_write(&snd_ctl_layer_rwsem);
+}
+EXPORT_SYMBOL_GPL(snd_ctl_disconnect_layer);
+
+/*
  *  INIT PART
  */
@@ -2012 +2157 @@
 {
         struct snd_card *card = device->device_data;
-
-        return snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
-                                   &snd_ctl_f_ops, card, &card->ctl_dev);
+        struct snd_ctl_layer_ops *lops;
+        int err;
+
+        err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
+                                  &snd_ctl_f_ops, card, &card->ctl_dev);
+        if (err < 0)
+                return err;
+        down_read(&card->controls_rwsem);
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                lops->lregister(card);
+        up_read(&snd_ctl_layer_rwsem);
+        up_read(&card->controls_rwsem);
+        return 0;
 }
 
@@ -2024 +2180 @@
         struct snd_card *card = device->device_data;
         struct snd_ctl_file *ctl;
+        struct snd_ctl_layer_ops *lops;
         unsigned long flags;
 
@@ -2032 +2189 @@
         }
         read_unlock_irqrestore(&card->ctl_files_rwlock, flags);
+
+        down_read(&card->controls_rwsem);
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                lops->ldisconnect(card);
+        up_read(&snd_ctl_layer_rwsem);
+        up_read(&card->controls_rwsem);
 
         return snd_unregister_device(&card->ctl_dev);

GPL/branches/uniaud32-next/alsa-kernel/core/oss/pcm_oss.c ¶

@@ -3085 +3085 @@
 }
 #else /* !CONFIG_SND_VERBOSE_PROCFS */
-#define snd_pcm_oss_proc_init(pcm)
-#define snd_pcm_oss_proc_done(pcm)
+static inline void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
+{
+}
+static inline void snd_pcm_oss_proc_done(struct snd_pcm *pcm)
+{
+}
 #endif /* CONFIG_SND_VERBOSE_PROCFS */
 

GPL/branches/uniaud32-next/alsa-kernel/core/pcm_memory.c ¶

@@ -177 +177 @@
                                            size, &new_dmab) < 0) {
                                 buffer->error = -ENOMEM;
+                                pr_debug("ALSA pcmC%dD%d%c,%d:%s: cannot preallocate for size %zu\n",
+                                         substream->pcm->card->number, substream->pcm->device,
+                                         substream->stream ? 'c' : 'p', substream->number,
+                                         substream->pcm->name, size);
                                 return;
                         }
@@ -211 +215 @@
 
 #else /* !CONFIG_SND_VERBOSE_PROCFS */
-#define preallocate_info_init(s)
+static inline void preallocate_info_init(struct snd_pcm_substream *substream)
+{
+}
 #endif /* CONFIG_SND_VERBOSE_PROCFS */
 
@@ -401 +407 @@
                                    size, dmab) < 0) {
                         kfree(dmab);
+                        pr_debug("ALSA pcmC%dD%d%c,%d:%s: cannot preallocate for size %zu\n",
+                                 substream->pcm->card->number, substream->pcm->device,
+                                 substream->stream ? 'c' : 'p', substream->number,
+                                 substream->pcm->name, size);
                         return -ENOMEM;
                 }

GPL/branches/uniaud32-next/alsa-kernel/core/pcm_native.c ¶

@@ -251 +251 @@
                 return false;
 
-        if (substream->ops->mmap ||
-            (substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_DEV &&
-             substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_DEV_UC))
+        if (substream->ops->mmap || substream->ops->page)
                 return true;
 
-        return dma_can_mmap(substream->dma_buffer.dev.dev);
+        switch (substream->dma_buffer.dev.type) {
+        case SNDRV_DMA_TYPE_UNKNOWN:
+                return false;
+        case SNDRV_DMA_TYPE_CONTINUOUS:
+        case SNDRV_DMA_TYPE_VMALLOC:
+                return true;
+        default:
+                return dma_can_mmap(substream->dma_buffer.dev.dev);
+        }
 }
 
@@ -1451 +1457 @@
                 substream->runtime->stop_operating = true;
         }
-        return 0; /* unconditonally stop all substreams */
+        return 0; /* unconditionally stop all substreams */
 }
 
@@ -1495 +1501 @@
  * Unlike snd_pcm_stop(), this affects only the given stream.
  *
- * Return: Zero if succesful, or a negative error code.
+ * Return: Zero if successful, or a negative error code.
  */
 int snd_pcm_drain_done(struct snd_pcm_substream *substream)
@@ -3101 +3107 @@
         snd_pcm_stream_lock_irq(substream);
         /* FIXME: we should consider the boundary for the sync from app */
-        if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
-                control->appl_ptr = scontrol.appl_ptr;
-        else
+        if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) {
+                err = pcm_lib_apply_appl_ptr(substream,
+                                scontrol.appl_ptr);
+                if (err < 0) {
+                        snd_pcm_stream_unlock_irq(substream);
+                        return err;
+                }
+        } else
                 scontrol.appl_ptr = control->appl_ptr % boundary;
         if (!(sflags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN))

GPL/branches/uniaud32-next/alsa-kernel/core/seq/seq_ports.c ¶

@@ -515 +515 @@
 }
 
-static void delete_and_unsubscribe_port(struct snd_seq_client *client,
-                                        struct snd_seq_client_port *port,
-                                        struct snd_seq_subscribers *subs,
-                                        bool is_src, bool ack)
+/* called with grp->list_mutex held */
+static void __delete_and_unsubscribe_port(struct snd_seq_client *client,
+                                          struct snd_seq_client_port *port,
+                                          struct snd_seq_subscribers *subs,
+                                          bool is_src, bool ack)
 {
         struct snd_seq_port_subs_info *grp;
@@ -526 +527 @@
         grp = is_src ? &port->c_src : &port->c_dest;
         list = is_src ? &subs->src_list : &subs->dest_list;
-        down_write(&grp->list_mutex);
         write_lock_irq(&grp->list_lock);
         empty = list_empty(list);
@@ -536 +536 @@
         if (!empty)
                 unsubscribe_port(client, port, grp, &subs->info, ack);
+}
+
+static void delete_and_unsubscribe_port(struct snd_seq_client *client,
+                                        struct snd_seq_client_port *port,
+                                        struct snd_seq_subscribers *subs,
+                                        bool is_src, bool ack)
+{
+        struct snd_seq_port_subs_info *grp;
+
+        grp = is_src ? &port->c_src : &port->c_dest;
+        down_write(&grp->list_mutex);
+        __delete_and_unsubscribe_port(client, port, subs, is_src, ack);
         up_write(&grp->list_mutex);
 }
@@ -591 +603 @@
                             struct snd_seq_port_subscribe *info)
 {
-        struct snd_seq_port_subs_info *src = &src_port->c_src;
+        struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
         struct snd_seq_subscribers *subs;
         int err = -ENOENT;
 
-        down_write(&src->list_mutex);
+        /* always start from deleting the dest port for avoiding concurrent
+         * deletions
+         */
+        down_write(&dest->list_mutex);
         /* look for the connection */
-        list_for_each_entry(subs, &src->list_head, src_list, struct snd_seq_subscribers) {
+        list_for_each_entry(subs, &dest->list_head, dest_list, struct snd_seq_subscribers) {
                 if (match_subs_info(info, &subs->info)) {
-                        atomic_dec(&subs->ref_count); /* mark as not ready */
+                        __delete_and_unsubscribe_port(dest_client, dest_port,
+                                                      subs, false,
+                                                      connector->number != dest_client->number);
                         err = 0;
                         break;
                 }
         }
-        up_write(&src->list_mutex);
+        up_write(&dest->list_mutex);
         if (err < 0)
                 return err;
@@ -610 +627 @@
         delete_and_unsubscribe_port(src_client, src_port, subs, true,
                                     connector->number != src_client->number);
-        delete_and_unsubscribe_port(dest_client, dest_port, subs, false,
-                                    connector->number != dest_client->number);
         kfree(subs);
         return 0;

GPL/branches/uniaud32-next/alsa-kernel/core/seq_device.c ¶

@@ -134 +134 @@
 }
 EXPORT_SYMBOL(snd_seq_device_load_drivers);
-#define cancel_autoload_drivers()       cancel_work_sync(&autoload_work)
+
+static inline void cancel_autoload_drivers(void)
+{
+        cancel_work_sync(&autoload_work);
+}
 #else
-#define queue_autoload_drivers() /* NOP */
-#define cancel_autoload_drivers() /* NOP */
+static inline void queue_autoload_drivers(void)
+{
+}
+
+static inline void cancel_autoload_drivers(void)
+{
+}
 #endif
 

GPL/branches/uniaud32-next/alsa-kernel/hda/hdac_stream.c ¶

@@ -624 +624 @@
 
 /**
- * snd_hdac_stream_sync - sync with start/strop trigger operation
+ * snd_hdac_stream_sync - sync with start/stop trigger operation
  * @azx_dev: HD-audio core stream (master stream)
  * @start: true = start, false = stop

GPL/branches/uniaud32-next/alsa-kernel/include/sound/control.h ¶

@@ -25 +25 @@
 /* internal flag for skipping validations */
 #ifdef CONFIG_SND_CTL_VALIDATION
-#define SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK        (1 << 27)
+#define SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK        (1 << 24)
 #define snd_ctl_skip_validation(info) \
         ((info)->access & SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK)
@@ -32 +32 @@
 #define snd_ctl_skip_validation(info)           true
 #endif
+
+/* kernel only - LED bits */
+#define SNDRV_CTL_ELEM_ACCESS_LED_SHIFT         25
+#define SNDRV_CTL_ELEM_ACCESS_LED_MASK          (7<<25) /* kernel three bits - LED group */
+#define SNDRV_CTL_ELEM_ACCESS_SPK_LED           (1<<25) /* kernel speaker (output) LED flag */
+#define SNDRV_CTL_ELEM_ACCESS_MIC_LED           (2<<25) /* kernel microphone (input) LED flag */
 
 enum {
@@ -109 +115 @@
 };
 
+struct snd_ctl_layer_ops {
+        struct snd_ctl_layer_ops *next;
+        const char *module_name;
+        void (*lregister)(struct snd_card *card);
+        void (*ldisconnect)(struct snd_card *card);
+        void (*lnotify)(struct snd_card *card, unsigned int mask, struct snd_kcontrol *kctl, unsigned int ioff);
+};
+
 #define snd_ctl_file(n) list_entry(n, struct snd_ctl_file, list)
 
@@ -116 +130 @@
 
 void snd_ctl_notify(struct snd_card * card, unsigned int mask, struct snd_ctl_elem_id * id);
+void snd_ctl_notify_one(struct snd_card * card, unsigned int mask, struct snd_kcontrol * kctl, unsigned int ioff);
 
 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new * kcontrolnew, void * private_data);
@@ -124 +139 @@
 int snd_ctl_remove_id(struct snd_card * card, struct snd_ctl_elem_id *id);
 int snd_ctl_rename_id(struct snd_card * card, struct snd_ctl_elem_id *src_id, struct snd_ctl_elem_id *dst_id);
-int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id,
-                        int active);
+int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id, int active);
 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card * card, unsigned int numid);
 struct snd_kcontrol *snd_ctl_find_id(struct snd_card * card, struct snd_ctl_elem_id *id);
@@ -140 +154 @@
 #define snd_ctl_unregister_ioctl_compat(fcn)
 #endif
+
+int snd_ctl_request_layer(const char *module_name);
+void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops);
+void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops);
 
 int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type);
@@ -255 +273 @@
 
 /*
+ * Control LED trigger layer
+ */
+#define SND_CTL_LAYER_MODULE_LED        "snd-ctl-led"
+
+#if IS_MODULE(CONFIG_SND_CTL_LED)
+static inline int snd_ctl_led_request(void) { return snd_ctl_request_layer(SND_CTL_LAYER_MODULE_LED); }
+#else
+static inline int snd_ctl_led_request(void) { return 0; }
+#endif
+
+/*
  * Helper functions for jack-detection controls
  */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/core.h ¶

@@ -104 +104 @@
         rwlock_t ctl_files_rwlock;      /* ctl_files list lock */
         int controls_count;             /* count of all controls */
-        int user_ctl_count;             /* count of all user controls */
+        size_t user_ctl_alloc_size;     // current memory allocation by user controls.
         struct list_head controls;      /* all controls for this card */
         struct list_head ctl_files;     /* active control files */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/hda_register.h ¶

@@ -141 +141 @@
 #define AZX_MAX_BDL_ENTRIES     (BDL_SIZE / 16)
 #define AZX_MAX_FRAG            32
-/* max buffer size - no h/w limit, you can increase as you like */
-#define AZX_MAX_BUF_SIZE        (1024*1024*1024)
+/*
+ * max buffer size - artificial 4MB limit per stream to avoid big allocations
+ * In theory it can be really big, but as it is per stream on systems with many streams memory could
+ * be quickly saturated if userspace requests maximum buffer size for each of them.
+ */
+#define AZX_MAX_BUF_SIZE        (4*1024*1024)
 
 /* RIRB int mask: overrun[2], response[0] */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/simple_card_utils.h ¶

@@ -39 +39 @@
 };
 
+struct prop_nums {
+        int cpus;
+        int codecs;
+        int platforms;
+};
+
 struct asoc_simple_priv {
         struct snd_soc_card snd_card;
@@ -44 +50 @@
                 struct asoc_simple_dai *cpu_dai;
                 struct asoc_simple_dai *codec_dai;
-                struct snd_soc_dai_link_component cpus;   /* single cpu */
-                struct snd_soc_dai_link_component codecs; /* single codec */
-                struct snd_soc_dai_link_component platforms;
+                struct snd_soc_dai_link_component *cpus;
+                struct snd_soc_dai_link_component *codecs;
+                struct snd_soc_dai_link_component *platforms;
                 struct asoc_simple_data adata;
                 struct snd_soc_codec_conf *codec_conf;
+                struct prop_nums num;
                 unsigned int mclk_fs;
         } *dai_props;
@@ -55 +62 @@
         struct snd_soc_dai_link *dai_link;
         struct asoc_simple_dai *dais;
+        struct snd_soc_dai_link_component *dlcs;
+        struct snd_soc_dai_link_component dummy;
         struct snd_soc_codec_conf *codec_conf;
         struct gpio_desc *pa_gpio;
@@ -66 +75 @@
 #define simple_priv_to_link(priv, i)    (simple_priv_to_card(priv)->dai_link + (i))
 
+#define simple_props_to_dlc_cpu(props, i)       ((props)->cpus + i)
+#define simple_props_to_dlc_codec(props, i)     ((props)->codecs + i)
+#define simple_props_to_dlc_platform(props, i)  ((props)->platforms + i)
+
+#define simple_props_to_dai_cpu(props, i)       ((props)->cpu_dai + i)
+#define simple_props_to_dai_codec(props, i)     ((props)->codec_dai + i)
+#define simple_props_to_codec_conf(props, i)    ((props)->codec_conf + i)
+
+#define for_each_prop_dlc_cpus(props, i, cpu)                           \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.cpus) &&                               \
+                     ((cpu) = simple_props_to_dlc_cpu(props, i));       \
+             (i)++)
+#define for_each_prop_dlc_codecs(props, i, codec)                       \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.codecs) &&                             \
+                     ((codec) = simple_props_to_dlc_codec(props, i));   \
+             (i)++)
+#define for_each_prop_dlc_platforms(props, i, platform)                 \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.platforms) &&                          \
+                     ((platform) = simple_props_to_dlc_platform(props, i)); \
+             (i)++)
+#define for_each_prop_codec_conf(props, i, conf)                        \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.codecs) &&                             \
+                     (props)->codec_conf &&                             \
+                     ((conf) = simple_props_to_codec_conf(props, i));   \
+             (i)++)
+
+#define for_each_prop_dai_cpu(props, i, cpu)                            \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.cpus) &&                               \
+                     ((cpu) = simple_props_to_dai_cpu(props, i));       \
+             (i)++)
+#define for_each_prop_dai_codec(props, i, codec)                        \
+        for ((i) = 0;                                                   \
+             ((i) < (props)->num.codecs) &&                             \
+                     ((codec) = simple_props_to_dai_codec(props, i));   \
+             (i)++)
+
+#define SNDRV_MAX_LINKS 128
+
 struct link_info {
-        int dais; /* number of dai  */
         int link; /* number of link */
-        int conf; /* number of codec_conf */
         int cpu;  /* turn for CPU / Codec */
+        struct prop_nums num[SNDRV_MAX_LINKS];
 };
 
@@ -85 +136 @@
                                 char *prefix);
 
-#define asoc_simple_parse_clk_cpu(dev, node, dai_link, simple_dai)              \
-        asoc_simple_parse_clk(dev, node, simple_dai, dai_link->cpus)
-#define asoc_simple_parse_clk_codec(dev, node, dai_link, simple_dai)    \
-        asoc_simple_parse_clk(dev, node, simple_dai, dai_link->codecs)
 int asoc_simple_parse_clk(struct device *dev,
                           struct device_node *node,
@@ -101 +148 @@
                                    struct snd_pcm_hw_params *params);
 
-#define asoc_simple_parse_cpu(node, dai_link, is_single_link)   \
-        asoc_simple_parse_dai(node, dai_link->cpus, is_single_link)
-#define asoc_simple_parse_codec(node, dai_link) \
-        asoc_simple_parse_dai(node, dai_link->codecs, NULL)
-#define asoc_simple_parse_platform(node, dai_link)      \
-        asoc_simple_parse_dai(node, dai_link->platforms, NULL)
-
 #define asoc_simple_parse_tdm(np, dai)                  \
         snd_soc_of_parse_tdm_slot(np,   &(dai)->tx_slot_mask,   \
@@ -114 +154 @@
                                         &(dai)->slot_width);
 
-void asoc_simple_canonicalize_platform(struct snd_soc_dai_link *dai_link);
-void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link *dai_link,
-                                      int is_single_links);
+void asoc_simple_canonicalize_platform(struct snd_soc_dai_link_component *platforms,
+                                       struct snd_soc_dai_link_component *cpus);
+void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link_component *cpus,
+                                  int is_single_links);
 
 int asoc_simple_clean_reference(struct snd_soc_card *card);
@@ -122 +163 @@
 void asoc_simple_convert_fixup(struct asoc_simple_data *data,
                                       struct snd_pcm_hw_params *params);
-void asoc_simple_parse_convert(struct device *dev,
-                               struct device_node *np, char *prefix,
+void asoc_simple_parse_convert(struct device_node *np, char *prefix,
                                struct asoc_simple_data *data);
 
@@ -138 +178 @@
 int asoc_simple_init_priv(struct asoc_simple_priv *priv,
                                struct link_info *li);
+int asoc_simple_remove(struct platform_device *pdev);
+
+int asoc_graph_card_probe(struct snd_soc_card *card);
 
 #ifdef DEBUG
@@ -153 +196 @@
                 dev_dbg(dev, "%s dai name = %s\n",
                         name, dai->name);
-        if (dai->sysclk)
-                dev_dbg(dev, "%s sysclk = %d\n",
-                        name, dai->sysclk);
-
-        dev_dbg(dev, "%s direction = %s\n",
-                name, dai->clk_direction ? "OUT" : "IN");
 
         if (dai->slots)
@@ -170 +207 @@
         if (dai->clk)
                 dev_dbg(dev, "%s clk %luHz\n", name, clk_get_rate(dai->clk));
+        if (dai->sysclk)
+                dev_dbg(dev, "%s sysclk = %dHz\n",
+                        name, dai->sysclk);
+        if (dai->clk || dai->sysclk)
+                dev_dbg(dev, "%s direction = %s\n",
+                        name, dai->clk_direction ? "OUT" : "IN");
 }
 
@@ -185 +228 @@
                 struct simple_dai_props *props = simple_priv_to_props(priv, i);
                 struct snd_soc_dai_link *link = simple_priv_to_link(priv, i);
+                struct asoc_simple_dai *dai;
+                struct snd_soc_codec_conf *cnf;
+                int j;
 
                 dev_dbg(dev, "DAI%d\n", i);
 
-                asoc_simple_debug_dai(priv, "cpu", props->cpu_dai);
-                asoc_simple_debug_dai(priv, "codec", props->codec_dai);
+                dev_dbg(dev, "cpu num = %d\n", link->num_cpus);
+                for_each_prop_dai_cpu(props, j, dai)
+                        asoc_simple_debug_dai(priv, "cpu", dai);
+                dev_dbg(dev, "codec num = %d\n", link->num_codecs);
+                for_each_prop_dai_codec(props, j, dai)
+                        asoc_simple_debug_dai(priv, "codec", dai);
 
                 if (link->name)
                         dev_dbg(dev, "dai name = %s\n", link->name);
-
-                dev_dbg(dev, "dai format = %04x\n", link->dai_fmt);
-
+                if (link->dai_fmt)
+                        dev_dbg(dev, "dai format = %04x\n", link->dai_fmt);
                 if (props->adata.convert_rate)
-                        dev_dbg(dev, "convert_rate = %d\n",
-                                props->adata.convert_rate);
+                        dev_dbg(dev, "convert_rate = %d\n", props->adata.convert_rate);
                 if (props->adata.convert_channels)
-                        dev_dbg(dev, "convert_channels = %d\n",
-                                props->adata.convert_channels);
-                if (props->codec_conf && props->codec_conf->name_prefix)
-                        dev_dbg(dev, "name prefix = %s\n",
-                                props->codec_conf->name_prefix);
+                        dev_dbg(dev, "convert_channels = %d\n", props->adata.convert_channels);
+                for_each_prop_codec_conf(props, j, cnf)
+                        if (cnf->name_prefix)
+                                dev_dbg(dev, "name prefix = %s\n", cnf->name_prefix);
                 if (props->mclk_fs)
-                        dev_dbg(dev, "mclk-fs = %d\n",
-                                props->mclk_fs);
+                        dev_dbg(dev, "mclk-fs = %d\n", props->mclk_fs);
         }
 }

GPL/branches/uniaud32-next/alsa-kernel/include/sound/soc-acpi.h ¶

@@ -64 +64 @@
  * @link_mask: links enabled on the board
  * @links: array of link _ADR descriptors, null terminated
+ * @num_dai_drivers: number of elements in @dai_drivers
+ * @dai_drivers: pointer to dai_drivers, used e.g. in nocodec mode
  */
 struct snd_soc_acpi_mach_params {
@@ -73 +75 @@
         u32 link_mask;
         const struct snd_soc_acpi_link_adr *links;
+        u32 num_dai_drivers;
+        struct snd_soc_dai_driver *dai_drivers;
 };
 

GPL/branches/uniaud32-next/alsa-kernel/include/sound/soc-component.h ¶

@@ -102 +102 @@
         /* DT */
         int (*of_xlate_dai_name)(struct snd_soc_component *component,
-                                 struct of_phandle_args *args,
+                                 const struct of_phandle_args *args,
                                  const char **dai_name);
         int (*of_xlate_dai_id)(struct snd_soc_component *comment,
@@ -147 +147 @@
                     struct snd_pcm_substream *substream,
                     struct vm_area_struct *vma);
+        int (*ack)(struct snd_soc_component *component,
+                   struct snd_pcm_substream *substream);
 
         const struct snd_compress_ops *compress_ops;
@@ -337 +339 @@
                                struct snd_soc_aux_dev *aux);
 int snd_soc_component_init(struct snd_soc_component *component);
+int snd_soc_component_is_dummy(struct snd_soc_component *component);
 
 /* component IO */
@@ -451 +454 @@
                                       struct device_node *ep);
 int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component,
-                                        struct of_phandle_args *args,
+                                        const struct of_phandle_args *args,
                                         const char **dai_name);
 int snd_soc_component_compr_open(struct snd_compr_stream *cstream);
@@ -499 +502 @@
 void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd,
                                           void *stream, int rollback);
+int snd_soc_pcm_component_ack(struct snd_pcm_substream *substream);
 
 #endif /* __SOC_COMPONENT_H */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/soc-dai.h ¶

@@ -82 +82 @@
 #define SND_SOC_DAIFMT_CBC_CFP          (2 << 12) /* codec clk consumer & frame provider */
 #define SND_SOC_DAIFMT_CBP_CFC          (3 << 12) /* codec clk provider & frame consumer */
-#define SND_SOC_DAIFMT_CBC_CFC          (4 << 12) /* codec clk consumer & frame follower */
+#define SND_SOC_DAIFMT_CBC_CFC          (4 << 12) /* codec clk consumer & frame consumer */
 
 /* previous definitions kept for backwards-compatibility, do not use in new contributions */

GPL/branches/uniaud32-next/alsa-kernel/include/sound/soc-dpcm.h ¶

@@ -150 +150 @@
         int stream, struct snd_soc_dapm_widget_list **list, int new);
 int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream);
-int dpcm_be_dai_shutdown(struct snd_soc_pcm_runtime *fe, int stream);
+void dpcm_be_dai_stop(struct snd_soc_pcm_runtime *fe, int stream,
+                      int do_hw_free, struct snd_soc_dpcm *last);
 void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream);
 void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream);
-int dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream);
+void dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream);
 int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int tream);
 int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream, int cmd);
@@ -160 +161 @@
         int event);
 
+#define dpcm_be_dai_startup_rollback(fe, stream, last)  \
+                                                dpcm_be_dai_stop(fe, stream, 0, last)
+#define dpcm_be_dai_startup_unwind(fe, stream)  dpcm_be_dai_stop(fe, stream, 0, NULL)
+#define dpcm_be_dai_shutdown(fe, stream)        dpcm_be_dai_stop(fe, stream, 1, NULL)
+
 #endif

GPL/branches/uniaud32-next/alsa-kernel/include/sound/soc.h ¶

@@ -713 +713 @@
         unsigned int ignore:1;
 
+        /* This flag will reorder stop sequence. By enabling this flag
+         * DMA controller stop sequence will be invoked first followed by
+         * CPU DAI driver stop sequence
+         */
+        unsigned int stop_dma_first:1;
+
 #ifdef CONFIG_SND_SOC_TOPOLOGY
         struct snd_soc_dobj dobj; /* For topology */
 #endif
 };
+
+static inline struct snd_soc_dai_link_component*
+asoc_link_to_cpu(struct snd_soc_dai_link *link, int n) {
+        return &(link)->cpus[n];
+}
+
+static inline struct snd_soc_dai_link_component*
+asoc_link_to_codec(struct snd_soc_dai_link *link, int n) {
+        return &(link)->codecs[n];
+}
+
+static inline struct snd_soc_dai_link_component*
+asoc_link_to_platform(struct snd_soc_dai_link *link, int n) {
+        return &(link)->platforms[n];
+}
+
 #define for_each_link_codecs(link, i, codec)                            \
         for ((i) = 0;                                                   \
-             ((i) < link->num_codecs) && ((codec) = &link->codecs[i]);  \
+             ((i) < link->num_codecs) &&                                \
+                     ((codec) = asoc_link_to_codec(link, i));           \
              (i)++)
 
@@ -725 +748 @@
         for ((i) = 0;                                                   \
              ((i) < link->num_platforms) &&                             \
-             ((platform) = &link->platforms[i]);                        \
+                     ((platform) = asoc_link_to_platform(link, i));     \
              (i)++)
 
 #define for_each_link_cpus(link, i, cpu)                                \
         for ((i) = 0;                                                   \
-             ((i) < link->num_cpus) && ((cpu) = &link->cpus[i]);        \
+             ((i) < link->num_cpus) &&                                  \
+                     ((cpu) = asoc_link_to_cpu(link, i));               \
              (i)++)
 
@@ -1220 +1244 @@
                                      struct device_node **framemaster);
 int snd_soc_get_dai_id(struct device_node *ep);
-int snd_soc_get_dai_name(struct of_phandle_args *args,
+int snd_soc_get_dai_name(const struct of_phandle_args *args,
                          const char **dai_name);
 int snd_soc_of_get_dai_name(struct device_node *of_node,
@@ -1263 +1287 @@
         /* set platform name for each dailink */
         for_each_card_prelinks(card, i, dai_link) {
+                /* only single platform is supported for now */
+                if (dai_link->num_platforms != 1)
+                        return -EINVAL;
+
+                if (!dai_link->platforms)
+                        return -EINVAL;
+
                 name = devm_kstrdup(card->dev, platform_name, GFP_KERNEL);
                 if (!name)
                         return -ENOMEM;
 
-                if (!dai_link->platforms)
-                        return -EINVAL;
-
                 /* only single platform is supported for now */
                 dai_link->platforms->name = name;

GPL/branches/uniaud32-next/alsa-kernel/include/sound/sof.h ¶

@@ -101 +101 @@
 };
 
-int sof_nocodec_setup(struct device *dev, const struct snd_sof_dsp_ops *ops,
-                      int (*pcm_dai_link_fixup)(struct snd_soc_pcm_runtime *rtd,
-                                                struct snd_pcm_hw_params *params));
+int sof_dai_get_mclk(struct snd_soc_pcm_runtime *rtd);
 
 #endif

GPL/branches/uniaud32-next/alsa-kernel/include/sound/version.h ¶

@@ -1 +1 @@
 /* include/version.h */
-#define CONFIG_SND_VERSION "5.12.19"
+#define CONFIG_SND_VERSION "5.13.10"
 #define CONFIG_SND_DATE ""

GPL/branches/uniaud32-next/alsa-kernel/isa/sb/sb16_csp.c ¶

@@ -816 +816 @@
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV, mixL & 0x7);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV + 1, mixR & 0x7);
+        spin_unlock_irqrestore(&p->chip->mixer_lock, flags);
 
         spin_lock(&p->chip->reg_lock);
@@ -855 +856 @@
 
         /* restore PCM volume */
+        spin_lock_irqsave(&p->chip->mixer_lock, flags);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV, mixL);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV + 1, mixR);
@@ -880 +882 @@
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV, mixL & 0x7);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV + 1, mixR & 0x7);
+        spin_unlock_irqrestore(&p->chip->mixer_lock, flags);
 
         spin_lock(&p->chip->reg_lock);
@@ -894 +897 @@
 
         /* restore PCM volume */
+        spin_lock_irqsave(&p->chip->mixer_lock, flags);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV, mixL);
         snd_sbmixer_write(p->chip, SB_DSP4_PCM_DEV + 1, mixR);

GPL/branches/uniaud32-next/alsa-kernel/isa/sb/sb8.c ¶

@@ -94 +94 @@
         card->private_free = snd_sb8_free;
 
-        /* block the 0x388 port to avoid PnP conflicts */
+        /*
+         * Block the 0x388 port to avoid PnP conflicts.
+         * No need to check this value after request_region,
+         * as we never do anything with it.
+         */
         acard->fm_res = request_region(0x388, 4, "SoundBlaster FM");
 

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_auto_parser.h ¶

@@ -28 +28 @@
 
 #define AUTO_CFG_MAX_OUTS       HDA_MAX_OUTS
-#define AUTO_CFG_MAX_INS        8
+#define AUTO_CFG_MAX_INS        18
 
 struct auto_pin_cfg_item {

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_codec.c ¶

@@ -1950 +1950 @@
  * @suffix: suffix string to each follower name (optional)
  * @init_follower_vol: initialize followers to unmute/0dB
+ * @access: kcontrol access rights
  * @ctl_ret: store the vmaster kcontrol in return
  *
@@ -1964 +1965 @@
                           unsigned int *tlv, const char * const *followers,
                           const char *suffix, bool init_follower_vol,
-                          struct snd_kcontrol **ctl_ret)
+                          unsigned int access, struct snd_kcontrol **ctl_ret)
 {
         struct snd_kcontrol *kctl;
@@ -1980 +1981 @@
         if (!kctl)
                 return -ENOMEM;
+        kctl->vd[0].access |= access;
         err = snd_hda_ctl_add(codec, 0, kctl);
         if (err < 0)
@@ -2011 +2013 @@
 EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
 
-/*
- * mute-LED control using vmaster
- */
-static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
-                                  struct snd_ctl_elem_info *uinfo)
-{
-        static const char * const texts[] = {
-                "On", "Off", "Follow Master"
-        };
-
-        return snd_ctl_enum_info(uinfo, 1, 3, texts);
-}
-
-static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
-        ucontrol->value.enumerated.item[0] = hook->mute_mode;
-        return 0;
-}
-
-static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
-        unsigned int old_mode = hook->mute_mode;
-
-        hook->mute_mode = ucontrol->value.enumerated.item[0];
-        if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
-                hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
-        if (old_mode == hook->mute_mode)
-                return 0;
-        snd_hda_sync_vmaster_hook(hook);
-        return 1;
-}
-
-static const struct snd_kcontrol_new vmaster_mute_mode = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Mute-LED Mode",
-        .info = vmaster_mute_mode_info,
-        .get = vmaster_mute_mode_get,
-        .put = vmaster_mute_mode_put,
-};
-
 /* meta hook to call each driver's vmaster hook */
 static void vmaster_hook(void *private_data, int enabled)
@@ -2060 +2018 @@
         struct hda_vmaster_mute_hook *hook = private_data;
 
-        if (hook->mute_mode != HDA_VMUTE_FOLLOW_MASTER)
-                enabled = hook->mute_mode;
         hook->hook(hook->codec, enabled);
 }
 
 /**
- * snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
+ * snd_hda_add_vmaster_hook - Add a vmaster hw specific hook
  * @codec: the HDA codec
  * @hook: the vmaster hook object
- * @expose_enum_ctl: flag to create an enum ctl
- *
- * Add a mute-LED hook with the given vmaster switch kctl.
- * When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
- * created and associated with the given hook.
+ *
+ * Add a hw specific hook (like EAPD) with the given vmaster switch kctl.
  */
 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
-                             struct hda_vmaster_mute_hook *hook,
-                             bool expose_enum_ctl)
-{
-        struct snd_kcontrol *kctl;
-
+                             struct hda_vmaster_mute_hook *hook)
+{
         if (!hook->hook || !hook->sw_kctl)
                 return 0;
         hook->codec = codec;
-        hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
         snd_ctl_add_vmaster_hook(hook->sw_kctl, vmaster_hook, hook);
-        if (!expose_enum_ctl)
-                return 0;
-        kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
-        if (!kctl)
-                return -ENOMEM;
-        return snd_hda_ctl_add(codec, 0, kctl);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_generic.c ¶

@@ -985 +985 @@
         if (get_amp_nid_(val))
                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
+        if (knew->access == 0)
+                knew->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
         knew->private_value = val;
         return knew;
@@ -3530 +3532 @@
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Capture Switch",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
         .info = cap_sw_info,
         .get = cap_sw_get,
@@ -3636 +3639 @@
         if (!knew)
                 return -ENOMEM;
-        if (is_switch)
+        if (is_switch) {
                 knew->put = cap_single_sw_put;
+                if (spec->mic_mute_led)
+                        knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
+        }
         if (!inv_dmic)
                 return 0;
@@ -3652 +3658 @@
         if (!knew)
                 return -ENOMEM;
-        if (is_switch)
+        if (is_switch) {
                 knew->put = cap_single_sw_put;
+                if (spec->mic_mute_led)
+                        knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
+        }
         return 0;
 }
@@ -3694 +3703 @@
                 knew->private_value = sw_ctl;
                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
+                if (spec->mic_mute_led)
+                        knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;
         }
         return 0;
@@ -3935 +3946 @@
 }
 
-static void vmaster_update_mute_led(void *private_data, int enabled)
-{
-        ledtrig_audio_set(LED_AUDIO_MUTE, enabled ? LED_OFF : LED_ON);
-}
-
 /**
  * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED
@@ -3963 +3969 @@
                 codec_err(codec, "vmaster hook already present before cdev!\n");
 
-        spec->vmaster_mute.hook = vmaster_update_mute_led;
-        spec->vmaster_mute_enum = 1;
+        spec->vmaster_mute_led = 1;
         return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);
-
-/*
- * mic mute LED hook helpers
- */
-enum {
-        MICMUTE_LED_ON,
-        MICMUTE_LED_OFF,
-        MICMUTE_LED_FOLLOW_CAPTURE,
-        MICMUTE_LED_FOLLOW_MUTE,
-};
-
-static void call_micmute_led_update(struct hda_codec *codec)
-{
-        struct hda_gen_spec *spec = codec->spec;
-        unsigned int val;
-
-        switch (spec->micmute_led.led_mode) {
-        case MICMUTE_LED_ON:
-                val = 1;
-                break;
-        case MICMUTE_LED_OFF:
-                val = 0;
-                break;
-        case MICMUTE_LED_FOLLOW_CAPTURE:
-                val = !!spec->micmute_led.capture;
-                break;
-        case MICMUTE_LED_FOLLOW_MUTE:
-        default:
-                val = !spec->micmute_led.capture;
-                break;
-        }
-
-        if (val == spec->micmute_led.led_value)
-                return;
-        spec->micmute_led.led_value = val;
-        ledtrig_audio_set(LED_AUDIO_MICMUTE,
-                          spec->micmute_led.led_value ? LED_ON : LED_OFF);
-}
-
-static void update_micmute_led(struct hda_codec *codec,
-                               struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_gen_spec *spec = codec->spec;
-        unsigned int mask;
-
-        if (spec->micmute_led.old_hook)
-                spec->micmute_led.old_hook(codec, kcontrol, ucontrol);
-
-        if (!ucontrol)
-                return;
-        mask = 1U << snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
-        if (!strcmp("Capture Switch", ucontrol->id.name)) {
-                /* TODO: How do I verify if it's a mono or stereo here? */
-                if (ucontrol->value.integer.value[0] ||
-                    ucontrol->value.integer.value[1])
-                        spec->micmute_led.capture |= mask;
-                else
-                        spec->micmute_led.capture &= ~mask;
-                call_micmute_led_update(codec);
-        }
-}
-
-static int micmute_led_mode_info(struct snd_kcontrol *kcontrol,
-                                 struct snd_ctl_elem_info *uinfo)
-{
-        static const char * const texts[] = {
-                "On", "Off", "Follow Capture", "Follow Mute",
-        };
-
-        return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
-}
-
-static int micmute_led_mode_get(struct snd_kcontrol *kcontrol,
-                                struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct hda_gen_spec *spec = codec->spec;
-
-        ucontrol->value.enumerated.item[0] = spec->micmute_led.led_mode;
-        return 0;
-}
-
-static int micmute_led_mode_put(struct snd_kcontrol *kcontrol,
-                                struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct hda_gen_spec *spec = codec->spec;
-        unsigned int mode;
-
-        mode = ucontrol->value.enumerated.item[0];
-        if (mode > MICMUTE_LED_FOLLOW_MUTE)
-                mode = MICMUTE_LED_FOLLOW_MUTE;
-        if (mode == spec->micmute_led.led_mode)
-                return 0;
-        spec->micmute_led.led_mode = mode;
-        call_micmute_led_update(codec);
-        return 1;
-}
-
-static const struct snd_kcontrol_new micmute_led_mode_ctl = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Mic Mute-LED Mode",
-        .info = micmute_led_mode_info,
-        .get = micmute_led_mode_get,
-        .put = micmute_led_mode_put,
-};
-
-/* Set up the capture sync hook for controlling the mic-mute LED */
-static int add_micmute_led_hook(struct hda_codec *codec)
-{
-        struct hda_gen_spec *spec = codec->spec;
-
-        spec->micmute_led.led_mode = MICMUTE_LED_FOLLOW_MUTE;
-        spec->micmute_led.capture = 0;
-        spec->micmute_led.led_value = -1;
-        spec->micmute_led.old_hook = spec->cap_sync_hook;
-        spec->cap_sync_hook = update_micmute_led;
-        if (!snd_hda_gen_add_kctl(spec, NULL, &micmute_led_mode_ctl))
-                return -ENOMEM;
-        return 0;
-}
 
 /**
@@ -4109 +3992 @@
                                                      enum led_brightness))
 {
+        struct hda_gen_spec *spec = codec->spec;
         int err;
 
@@ -4119 +4003 @@
         }
 
-        return add_micmute_led_hook(codec);
+        spec->mic_mute_led = 1;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);
@@ -5078 +4963 @@
         parse_user_hints(codec);
 
+        if (spec->vmaster_mute_led || spec->mic_mute_led)
+                snd_ctl_led_request();
+
         if (spec->mixer_nid && !spec->mixer_merge_nid)
                 spec->mixer_merge_nid = spec->mixer_nid;
@@ -5309 +5197 @@
                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
                                           spec->vmaster_tlv, follower_pfxs,
-                                          "Playback Volume");
+                                          "Playback Volume", 0);
                 if (err < 0)
                         return err;
@@ -5317 +5205 @@
                 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
                                             NULL, follower_pfxs,
-                                            "Playback Switch",
-                                            true, &spec->vmaster_mute.sw_kctl);
+                                            "Playback Switch", true,
+                                            spec->vmaster_mute_led ?
+                                                SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,
+                                            &spec->vmaster_mute.sw_kctl);
                 if (err < 0)
                         return err;
                 if (spec->vmaster_mute.hook) {
-                        snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute,
-                                                 spec->vmaster_mute_enum);
+                        snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);
                         snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
                 }

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_generic.h ¶

@@ -84 +84 @@
 extern const struct badness_table hda_main_out_badness;
 extern const struct badness_table hda_extra_out_badness;
-
-struct hda_micmute_hook {
-        unsigned int led_mode;
-        unsigned int capture;
-        unsigned int led_value;
-        void (*old_hook)(struct hda_codec *codec,
-                         struct snd_kcontrol *kcontrol,
-                         struct snd_ctl_elem_value *ucontrol);
-};
 
 struct hda_gen_spec {
@@ -230 +221 @@
         unsigned int own_eapd_ctl:1; /* set EAPD by own function */
         unsigned int keep_eapd_on:1; /* don't turn off EAPD automatically */
-        unsigned int vmaster_mute_enum:1; /* add vmaster mute mode enum */
+        unsigned int vmaster_mute_led:1; /* add SPK-LED flag to vmaster mute switch */
+        unsigned int mic_mute_led:1; /* add MIC-LED flag to capture mute switch */
         unsigned int indep_hp:1; /* independent HP supported */
         unsigned int prefer_hp_amp:1; /* enable HP amp for speaker if any */
@@ -285 +277 @@
                               struct snd_kcontrol *kcontrol,
                               struct snd_ctl_elem_value *ucontrol);
-
-        /* mic mute LED hook; called via cap_sync_hook */
-        struct hda_micmute_hook micmute_led;
 
         /* PCM hooks */

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_jack.c ¶

@@ -388 +388 @@
 }
 EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
+
+/**
+ * snd_hda_jack_bind_keymap - bind keys generated from one NID to another jack.
+ * @codec: the HDA codec
+ * @key_nid: key event is generated by this pin NID
+ * @keymap: map of key type and key code
+ * @jack_nid: key reports to the jack of this pin NID
+ *
+ * This function is used in the case of key is generated from one NID while is
+ * reported to the jack of another NID.
+ */
+int snd_hda_jack_bind_keymap(struct hda_codec *codec, hda_nid_t key_nid,
+                             const struct hda_jack_keymap *keymap,
+                             hda_nid_t jack_nid)
+{
+        const struct hda_jack_keymap *map;
+        struct hda_jack_tbl *key_gen = snd_hda_jack_tbl_get(codec, key_nid);
+        struct hda_jack_tbl *report_to = snd_hda_jack_tbl_get(codec, jack_nid);
+
+        WARN_ON(codec->dp_mst);
+
+        if (!key_gen || !report_to || !report_to->jack)
+                return -EINVAL;
+
+        key_gen->key_report_jack = jack_nid;
+
+        if (keymap)
+                for (map = keymap; map->type; map++)
+                        snd_jack_set_key(report_to->jack, map->type, map->key);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hda_jack_bind_keymap);
+
+/**
+ * snd_hda_jack_set_button_state - report button event to the hda_jack_tbl button_state.
+ * @codec: the HDA codec
+ * @jack_nid: the button event reports to the jack_tbl of this NID
+ * @button_state: the button event captured by codec
+ *
+ * Codec driver calls this function to report the button event.
+ */
+void snd_hda_jack_set_button_state(struct hda_codec *codec, hda_nid_t jack_nid,
+                                   int button_state)
+{
+        struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, jack_nid);
+
+        if (!jack)
+                return;
+
+        if (jack->key_report_jack) {
+                struct hda_jack_tbl *report_to =
+                        snd_hda_jack_tbl_get(codec, jack->key_report_jack);
+
+                if (report_to) {
+                        report_to->button_state = button_state;
+                        return;
+                }
+        }
+
+        jack->button_state = button_state;
+}
+EXPORT_SYMBOL_GPL(snd_hda_jack_set_button_state);
 
 /**
@@ -652 +715 @@
         if (!event)
                 return;
-        event->jack_dirty = 1;
+
+        if (event->key_report_jack) {
+                struct hda_jack_tbl *report_to =
+                        snd_hda_jack_tbl_get_mst(codec, event->key_report_jack,
+                                                 event->dev_id);
+                if (report_to)
+                        report_to->jack_dirty = 1;
+        } else
+                event->jack_dirty = 1;
 
         call_jack_callback(codec, res, event);

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_jack.h ¶

@@ -41 +41 @@
         hda_nid_t gating_jack;          /* valid when gating jack plugged */
         hda_nid_t gated_jack;           /* gated is dependent on this jack */
+        hda_nid_t key_report_jack;      /* key reports to this jack */
         int type;
         int button_state;
@@ -99 +100 @@
 int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,
                                  hda_nid_t gating_nid);
+
+int snd_hda_jack_bind_keymap(struct hda_codec *codec, hda_nid_t key_nid,
+                             const struct hda_jack_keymap *keymap,
+                             hda_nid_t jack_nid);
+
+void snd_hda_jack_set_button_state(struct hda_codec *codec, hda_nid_t jack_nid,
+                                   int button_state);
 
 u32 snd_hda_jack_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id);

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_local.h ¶

@@ -132 +132 @@
                           unsigned int *tlv, const char * const *followers,
                           const char *suffix, bool init_follower_vol,
-                          struct snd_kcontrol **ctl_ret);
-#define snd_hda_add_vmaster(codec, name, tlv, followers, suffix) \
-        __snd_hda_add_vmaster(codec, name, tlv, followers, suffix, true, NULL)
+                          unsigned int access, struct snd_kcontrol **ctl_ret);
+#define snd_hda_add_vmaster(codec, name, tlv, followers, suffix, access) \
+        __snd_hda_add_vmaster(codec, name, tlv, followers, suffix, true, access, NULL)
 int snd_hda_codec_reset(struct hda_codec *codec);
 void snd_hda_codec_register(struct hda_codec *codec);
@@ -140 +140 @@
 
 #define snd_hda_regmap_sync(codec)      snd_hdac_regmap_sync(&(codec)->core)
-
-enum {
-        HDA_VMUTE_OFF,
-        HDA_VMUTE_ON,
-        HDA_VMUTE_FOLLOW_MASTER,
-};
 
 struct hda_vmaster_mute_hook {
@@ -154 +148 @@
         void (*hook)(void *, int);
         /* below are initialized automatically */
-        unsigned int mute_mode; /* HDA_VMUTE_XXX */
         struct hda_codec *codec;
 };
 
 int snd_hda_add_vmaster_hook(struct hda_codec *codec,
-                             struct hda_vmaster_mute_hook *hook,
-                             bool expose_enum_ctl);
+                             struct hda_vmaster_mute_hook *hook);
 void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook);
 
@@ -181 +173 @@
  * input MUX helper
  */
-#define HDA_MAX_NUM_INPUTS      16
+#define HDA_MAX_NUM_INPUTS      36
 struct hda_input_mux_item {
         char label[32];

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_ca0132.c ¶

@@ -7137 +7137 @@
                 snd_hda_add_vmaster(codec, "Master Playback Volume",
                                         spec->tlv, ca0132_alt_follower_pfxs,
-                                        "Playback Volume");
+                                        "Playback Volume", 0);
                 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
                                             NULL, ca0132_alt_follower_pfxs,
                                             "Playback Switch",
-                                            true, &spec->vmaster_mute.sw_kctl);
+                                            true, 0, &spec->vmaster_mute.sw_kctl);
                 if (err < 0)
                         return err;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_cirrus.c ¶

@@ -10 +10 @@
 #include <linux/module.h>
 #include <sound/core.h>
+#include <linux/mutex.h>
+#include <linux/pci.h>
 #include <sound/tlv.h>
 #include <sound/hda_codec.h>
@@ -24 +26 @@
  */
 
+#define CS42L42_HP_CH     (2U)
+#define CS42L42_HS_MIC_CH (1U)
+
 struct cs_spec {
         struct hda_gen_spec gen;
@@ -42 +47 @@
         int (*spdif_sw_put)(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol);
+
+        unsigned int cs42l42_hp_jack_in:1;
+        unsigned int cs42l42_mic_jack_in:1;
+        unsigned int cs42l42_volume_init:1;
+        char cs42l42_hp_volume[CS42L42_HP_CH];
+        char cs42l42_hs_mic_volume[CS42L42_HS_MIC_CH];
+
+        struct mutex cs8409_i2c_mux;
+
+        /* verb exec op override */
+        int (*exec_verb)(struct hdac_device *dev, unsigned int cmd,
+                                 unsigned int flags, unsigned int *res);
 };
 
@@ -115 +132 @@
  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
-*/
+ */
 #define CS4210_DAC_NID          0x02
 #define CS4210_ADC_NID          0x03
@@ -134 +151 @@
 {
         struct cs_spec *spec = codec->spec;
+
         snd_hda_codec_write(codec, spec->vendor_nid, 0,
                             AC_VERB_SET_COEF_INDEX, idx);
@@ -144 +162 @@
 {
         struct cs_spec *spec = codec->spec;
+
         snd_hda_codec_write(codec, spec->vendor_nid, 0,
                             AC_VERB_SET_COEF_INDEX, idx);
@@ -180 +199 @@
 {
         unsigned int val;
+
         val = snd_hda_codec_get_pincfg(codec, nid);
         return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
@@ -198 +218 @@
                                          * No effect if SPDIF_OUT2 is
                                          * selected in IDX_SPDIF_CTL.
-                                        */
+                                         */
 
                 cs_vendor_coef_set(codec, IDX_BEEP_CFG, coef);
@@ -272 +292 @@
         {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
         {0x11, AC_VERB_SET_PROC_STATE, 0x00},
-
-#if 0 /* Don't to set to D3 as we are in power-up sequence */
-        {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
-        {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
-        /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
-#endif
-
         {0} /* terminator */
 };
@@ -366 +379 @@
         if (spec->gen.dyn_adc_switch) {
                 unsigned int done = 0;
+
                 for (i = 0; i < spec->gen.input_mux.num_items; i++) {
                         int idx = spec->gen.dyn_adc_idx[i];
+
                         if (done & (1 << idx))
                                 continue;
@@ -501 +516 @@
         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
                 struct cs_spec *spec = codec->spec;
+
                 spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
@@ -513 +529 @@
         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
                 struct cs_spec *spec = codec->spec;
+
                 spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
@@ -659 +676 @@
         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
                 struct cs_spec *spec = codec->spec;
+
                 spec->gpio_eapd_hp = 0;
                 spec->gpio_eapd_speaker = 1;
@@ -813 +831 @@
  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
-*/
+ */
 
 /* CS4210 board names */
@@ -856 +874 @@
 {
         struct cs_spec *spec = codec->spec;
+
         if (action == HDA_FIXUP_ACT_PRE_PROBE)
                 spec->sense_b = 1;
@@ -881 +900 @@
         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
         /*
-            Disable Coefficient Index Auto-Increment(DAI)=1,
-            PDREF=0
-        */
+         *  Disable Coefficient Index Auto-Increment(DAI)=1,
+         *  PDREF=0
+         */
         {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
 
@@ -970 +989 @@
         coef &= ~0x0003;
         coef |= (vol & 0x0003);
-        if (original_coef == coef)
-                return 0;
-        else {
+        if (original_coef != coef) {
                 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
                 return 1;
         }
+
+        return 0;
 }
 
@@ -1014 +1033 @@
 
                 /*
-                    GPIO or SENSE_B forced - disconnect the DMIC pin.
-                */
+                 *  GPIO or SENSE_B forced - disconnect the DMIC pin.
+                 */
                 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
                 def_conf &= ~AC_DEFCFG_PORT_CONN;
@@ -1054 +1073 @@
         for (i = 0; i < cfg->dig_outs; i++) {
                 hda_nid_t nid = cfg->dig_out_pins[i];
+
                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
                         spec->spdif_detect = 1;
@@ -1132 +1152 @@
 #ifdef CONFIG_PM
 /*
-        Manage PDREF, when transitioning to D3hot
-        (DAC,ADC) -> D3, PDREF=1, AFG->D3
-*/
+ *      Manage PDREF, when transitioning to D3hot
+ *      (DAC,ADC) -> D3, PDREF=1, AFG->D3
+ */
 static int cs421x_suspend(struct hda_codec *codec)
 {
@@ -1185 +1205 @@
 
         /*
-            Update the GPIO/DMIC/SENSE_B pinmux before the configuration
-            is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
-            is disabled.
-        */
+         *  Update the GPIO/DMIC/SENSE_B pinmux before the configuration
+         *   is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
+         *   is disabled.
+         */
         cs4210_pinmux_init(codec);
 
@@ -1226 +1246 @@
 }
 
+/* Cirrus Logic CS8409 HDA bridge with
+ * companion codec CS42L42
+ */
+#define CS8409_VENDOR_NID 0x47
+
+#define CS8409_CS42L42_HP_PIN_NID       0x24
+#define CS8409_CS42L42_SPK_PIN_NID      0x2c
+#define CS8409_CS42L42_AMIC_PIN_NID     0x34
+#define CS8409_CS42L42_DMIC_PIN_NID     0x44
+#define CS8409_CS42L42_DMIC_ADC_PIN_NID 0x22
+
+#define CS42L42_HSDET_AUTO_DONE 0x02
+#define CS42L42_HSTYPE_MASK             0x03
+
+#define CS42L42_JACK_INSERTED   0x0C
+#define CS42L42_JACK_REMOVED    0x00
+
+#define GPIO3_INT (1 << 3)
+#define GPIO4_INT (1 << 4)
+#define GPIO5_INT (1 << 5)
+
+#define CS42L42_I2C_ADDR        (0x48 << 1)
+
+#define CIR_I2C_ADDR    0x0059
+#define CIR_I2C_DATA    0x005A
+#define CIR_I2C_CTRL    0x005B
+#define CIR_I2C_STATUS  0x005C
+#define CIR_I2C_QWRITE  0x005D
+#define CIR_I2C_QREAD   0x005E
+
+#define CS8409_CS42L42_HP_VOL_REAL_MIN   (-63)
+#define CS8409_CS42L42_HP_VOL_REAL_MAX   (0)
+#define CS8409_CS42L42_AMIC_VOL_REAL_MIN (-97)
+#define CS8409_CS42L42_AMIC_VOL_REAL_MAX (12)
+#define CS8409_CS42L42_REG_HS_VOLUME_CHA (0x2301)
+#define CS8409_CS42L42_REG_HS_VOLUME_CHB (0x2303)
+#define CS8409_CS42L42_REG_AMIC_VOLUME   (0x1D03)
+
+struct cs8409_i2c_param {
+        unsigned int addr;
+        unsigned int reg;
+};
+
+struct cs8409_cir_param {
+        unsigned int nid;
+        unsigned int cir;
+        unsigned int coeff;
+};
+
+enum {
+        CS8409_BULLSEYE,
+        CS8409_WARLOCK,
+        CS8409_CYBORG,
+        CS8409_FIXUPS,
+};
+
+static void cs8409_cs42l42_fixups(struct hda_codec *codec,
+                                    const struct hda_fixup *fix, int action);
+static int cs8409_cs42l42_exec_verb(struct hdac_device *dev,
+                unsigned int cmd, unsigned int flags, unsigned int *res);
+
+/* Dell Inspiron models with cs8409/cs42l42 */
+static const struct hda_model_fixup cs8409_models[] = {
+        { .id = CS8409_BULLSEYE, .name = "bullseye" },
+        { .id = CS8409_WARLOCK, .name = "warlock" },
+        { .id = CS8409_CYBORG, .name = "cyborg" },
+        {0}
+};
+
+/* Dell Inspiron platforms
+ * with cs8409 bridge and cs42l42 codec
+ */
+static const struct snd_pci_quirk cs8409_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x1028, 0x0A11, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A12, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A23, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A24, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A25, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A29, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A2A, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0A2B, "Bullseye", CS8409_BULLSEYE),
+        SND_PCI_QUIRK(0x1028, 0x0AB0, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AB2, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AB1, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AB3, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AB4, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AB5, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AD9, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0ADA, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0ADB, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0ADC, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AF4, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0AF5, "Warlock", CS8409_WARLOCK),
+        SND_PCI_QUIRK(0x1028, 0x0A77, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A78, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A79, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A7A, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A7D, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A7E, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A7F, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0A80, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0ADF, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AE0, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AE1, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AE2, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AE9, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AEA, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AEB, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AEC, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AED, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AEE, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AEF, "Cyborg", CS8409_CYBORG),
+        SND_PCI_QUIRK(0x1028, 0x0AF0, "Cyborg", CS8409_CYBORG),
+        {0} /* terminator */
+};
+
+static const struct hda_verb cs8409_cs42l42_init_verbs[] = {
+        { 0x01, AC_VERB_SET_GPIO_WAKE_MASK, 0x0018 }, /* WAKE from GPIO 3,4 */
+        { 0x47, AC_VERB_SET_PROC_STATE, 0x0001 },     /* Enable VPW processing  */
+        { 0x47, AC_VERB_SET_COEF_INDEX, 0x0002 },     /* Configure GPIO 6,7 */
+        { 0x47, AC_VERB_SET_PROC_COEF,  0x0080 },     /* I2C mode */
+        { 0x47, AC_VERB_SET_COEF_INDEX, 0x005b },     /* Set I2C bus speed */
+        { 0x47, AC_VERB_SET_PROC_COEF,  0x0200 },     /* 100kHz I2C_STO = 2 */
+        {0} /* terminator */
+};
+
+static const struct hda_pintbl cs8409_cs42l42_pincfgs[] = {
+        { 0x24, 0x042120f0 }, /* ASP-1-TX */
+        { 0x34, 0x04a12050 }, /* ASP-1-RX */
+        { 0x2c, 0x901000f0 }, /* ASP-2-TX */
+        { 0x44, 0x90a00090 }, /* DMIC-1 */
+        {0} /* terminator */
+};
+
+static const struct hda_fixup cs8409_fixups[] = {
+        [CS8409_BULLSEYE] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = cs8409_cs42l42_pincfgs,
+                .chained = true,
+                .chain_id = CS8409_FIXUPS,
+        },
+        [CS8409_WARLOCK] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = cs8409_cs42l42_pincfgs,
+                .chained = true,
+                .chain_id = CS8409_FIXUPS,
+        },
+        [CS8409_CYBORG] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = cs8409_cs42l42_pincfgs,
+                .chained = true,
+                .chain_id = CS8409_FIXUPS,
+        },
+        [CS8409_FIXUPS] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = cs8409_cs42l42_fixups,
+        },
+};
+
+/* Vendor specific HW configuration for CS42L42 */
+static const struct cs8409_i2c_param cs42l42_init_reg_seq[] = {
+        { 0x1010, 0xB0 },
+        { 0x1D01, 0x00 },
+        { 0x1D02, 0x06 },
+        { 0x1D03, 0x00 },
+        { 0x1107, 0x01 },
+        { 0x1009, 0x02 },
+        { 0x1007, 0x03 },
+        { 0x1201, 0x00 },
+        { 0x1208, 0x13 },
+        { 0x1205, 0xFF },
+        { 0x1206, 0x00 },
+        { 0x1207, 0x20 },
+        { 0x1202, 0x0D },
+        { 0x2A02, 0x02 },
+        { 0x2A03, 0x00 },
+        { 0x2A04, 0x00 },
+        { 0x2A05, 0x02 },
+        { 0x2A06, 0x00 },
+        { 0x2A07, 0x20 },
+        { 0x2A08, 0x02 },
+        { 0x2A09, 0x00 },
+        { 0x2A0A, 0x80 },
+        { 0x2A0B, 0x02 },
+        { 0x2A0C, 0x00 },
+        { 0x2A0D, 0xA0 },
+        { 0x2A01, 0x0C },
+        { 0x2902, 0x01 },
+        { 0x2903, 0x02 },
+        { 0x2904, 0x00 },
+        { 0x2905, 0x00 },
+        { 0x2901, 0x01 },
+        { 0x1101, 0x0A },
+        { 0x1102, 0x84 },
+        { 0x2301, 0x00 },
+        { 0x2303, 0x00 },
+        { 0x2302, 0x3f },
+        { 0x2001, 0x03 },
+        { 0x1B75, 0xB6 },
+        { 0x1B73, 0xC2 },
+        { 0x1129, 0x01 },
+        { 0x1121, 0xF3 },
+        { 0x1103, 0x20 },
+        { 0x1105, 0x00 },
+        { 0x1112, 0xC0 },
+        { 0x1113, 0x80 },
+        { 0x1C03, 0xC0 },
+        { 0x1105, 0x00 },
+        { 0x1112, 0xC0 },
+        { 0x1101, 0x02 },
+        {0} /* Terminator */
+};
+
+/* Vendor specific hw configuration for CS8409 */
+static const struct cs8409_cir_param cs8409_cs42l42_hw_cfg[] = {
+        { 0x47, 0x00, 0xb008 }, /* +PLL1/2_EN, +I2C_EN */
+        { 0x47, 0x01, 0x0002 }, /* ASP1/2_EN=0, ASP1_STP=1 */
+        { 0x47, 0x02, 0x0a80 }, /* ASP1/2_BUS_IDLE=10, +GPIO_I2C */
+        { 0x47, 0x19, 0x0800 }, /* ASP1.A: TX.LAP=0, TX.LSZ=24 bits, TX.LCS=0 */
+        { 0x47, 0x1a, 0x0820 }, /* ASP1.A: TX.RAP=0, TX.RSZ=24 bits, TX.RCS=32 */
+        { 0x47, 0x29, 0x0800 }, /* ASP2.A: TX.LAP=0, TX.LSZ=24 bits, TX.LCS=0 */
+        { 0x47, 0x2a, 0x2800 }, /* ASP2.A: TX.RAP=1, TX.RSZ=24 bits, TX.RCS=0 */
+        { 0x47, 0x39, 0x0800 }, /* ASP1.A: RX.LAP=0, RX.LSZ=24 bits, RX.LCS=0 */
+        { 0x47, 0x3a, 0x0800 }, /* ASP1.A: RX.RAP=0, RX.RSZ=24 bits, RX.RCS=0 */
+        { 0x47, 0x03, 0x8000 }, /* ASP1: LCHI = 00h */
+        { 0x47, 0x04, 0x28ff }, /* ASP1: MC/SC_SRCSEL=PLL1, LCPR=FFh */
+        { 0x47, 0x05, 0x0062 }, /* ASP1: MCEN=0, FSD=011, SCPOL_IN/OUT=0, SCDIV=1:4 */
+        { 0x47, 0x06, 0x801f }, /* ASP2: LCHI=1Fh */
+        { 0x47, 0x07, 0x283f }, /* ASP2: MC/SC_SRCSEL=PLL1, LCPR=3Fh */
+        { 0x47, 0x08, 0x805c }, /* ASP2: 5050=1, MCEN=0, FSD=010, SCPOL_IN/OUT=1, SCDIV=1:16 */
+        { 0x47, 0x09, 0x0023 }, /* DMIC1_MO=10b, DMIC1/2_SR=1 */
+        { 0x47, 0x0a, 0x0000 }, /* ASP1/2_BEEP=0 */
+        { 0x47, 0x01, 0x0062 }, /* ASP1/2_EN=1, ASP1_STP=1 */
+        { 0x47, 0x00, 0x9008 }, /* -PLL2_EN */
+        { 0x47, 0x68, 0x0000 }, /* TX2.A: pre-scale att.=0 dB */
+        { 0x47, 0x82, 0xfc03 }, /* ASP1/2_xxx_EN=1, ASP1/2_MCLK_EN=0, DMIC1_SCL_EN=1 */
+        { 0x47, 0xc0, 0x9999 }, /* test mode on */
+        { 0x47, 0xc5, 0x0000 }, /* GPIO hysteresis = 30 us */
+        { 0x47, 0xc0, 0x0000 }, /* test mode off */
+        {0} /* Terminator */
+};
+
+static const struct cs8409_cir_param cs8409_cs42l42_bullseye_atn[] = {
+        { 0x47, 0x65, 0x4000 }, /* EQ_SEL=1, EQ1/2_EN=0 */
+        { 0x47, 0x64, 0x4000 }, /* +EQ_ACC */
+        { 0x47, 0x65, 0x4010 }, /* +EQ2_EN */
+        { 0x47, 0x63, 0x0647 }, /* EQ_DATA_HI=0x0647 */
+        { 0x47, 0x64, 0xc0c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=0, EQ_DATA_LO=0x67 */
+        { 0x47, 0x63, 0x0647 }, /* EQ_DATA_HI=0x0647 */
+        { 0x47, 0x64, 0xc1c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=1, EQ_DATA_LO=0x67 */
+        { 0x47, 0x63, 0xf370 }, /* EQ_DATA_HI=0xf370 */
+        { 0x47, 0x64, 0xc271 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=2, EQ_DATA_LO=0x71 */
+        { 0x47, 0x63, 0x1ef8 }, /* EQ_DATA_HI=0x1ef8 */
+        { 0x47, 0x64, 0xc348 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=3, EQ_DATA_LO=0x48 */
+        { 0x47, 0x63, 0xc110 }, /* EQ_DATA_HI=0xc110 */
+        { 0x47, 0x64, 0xc45a }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=4, EQ_DATA_LO=0x5a */
+        { 0x47, 0x63, 0x1f29 }, /* EQ_DATA_HI=0x1f29 */
+        { 0x47, 0x64, 0xc574 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=5, EQ_DATA_LO=0x74 */
+        { 0x47, 0x63, 0x1d7a }, /* EQ_DATA_HI=0x1d7a */
+        { 0x47, 0x64, 0xc653 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=6, EQ_DATA_LO=0x53 */
+        { 0x47, 0x63, 0xc38c }, /* EQ_DATA_HI=0xc38c */
+        { 0x47, 0x64, 0xc714 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=7, EQ_DATA_LO=0x14 */
+        { 0x47, 0x63, 0x1ca3 }, /* EQ_DATA_HI=0x1ca3 */
+        { 0x47, 0x64, 0xc8c7 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=8, EQ_DATA_LO=0xc7 */
+        { 0x47, 0x63, 0xc38c }, /* EQ_DATA_HI=0xc38c */
+        { 0x47, 0x64, 0xc914 }, /* +EQ_WRT, +EQ_ACC, EQ_ADR=9, EQ_DATA_LO=0x14 */
+        { 0x47, 0x64, 0x0000 }, /* -EQ_ACC, -EQ_WRT */
+        {0} /* Terminator */
+};
+
+/**
+ * cs8409_enable_i2c_clock - Enable I2C clocks
+ * @codec: the codec instance
+ * @enable: Enable or disable I2C clocks
+ *
+ * Enable or Disable I2C clocks.
+ */
+static void cs8409_enable_i2c_clock(struct hda_codec *codec, unsigned int enable)
+{
+        unsigned int retval;
+        unsigned int newval;
+
+        retval = cs_vendor_coef_get(codec, 0x0);
+        newval = (enable) ? (retval | 0x8) : (retval & 0xfffffff7);
+        cs_vendor_coef_set(codec, 0x0, newval);
+}
+
+/**
+ * cs8409_i2c_wait_complete - Wait for I2C transaction
+ * @codec: the codec instance
+ *
+ * Wait for I2C transaction to complete.
+ * Return -1 if transaction wait times out.
+ */
+static int cs8409_i2c_wait_complete(struct hda_codec *codec)
+{
+        int repeat = 5;
+        unsigned int retval;
+
+        do {
+                retval = cs_vendor_coef_get(codec, CIR_I2C_STATUS);
+                if ((retval & 0x18) != 0x18) {
+                        usleep_range(2000, 4000);
+                        --repeat;
+                } else
+                        return 0;
+
+        } while (repeat);
+
+        return -1;
+}
+
+/**
+ * cs8409_i2c_read - CS8409 I2C Read.
+ * @codec: the codec instance
+ * @i2c_address: I2C Address
+ * @i2c_reg: Register to read
+ * @paged: Is a paged transaction
+ *
+ * CS8409 I2C Read.
+ * Returns negative on error, otherwise returns read value in bits 0-7.
+ */
+static int cs8409_i2c_read(struct hda_codec *codec,
+                unsigned int i2c_address,
+                unsigned int i2c_reg,
+                unsigned int paged)
+{
+        unsigned int i2c_reg_data;
+        unsigned int read_data;
+
+        cs8409_enable_i2c_clock(codec, 1);
+        cs_vendor_coef_set(codec, CIR_I2C_ADDR, i2c_address);
+
+        if (paged) {
+                cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg >> 8);
+                if (cs8409_i2c_wait_complete(codec) < 0) {
+                        codec_err(codec,
+                                "%s() Paged Transaction Failed 0x%02x : 0x%04x\n",
+                                __func__, i2c_address, i2c_reg);
+                        return -EIO;
+                }
+        }
+
+        i2c_reg_data = (i2c_reg << 8) & 0x0ffff;
+        cs_vendor_coef_set(codec, CIR_I2C_QREAD, i2c_reg_data);
+        if (cs8409_i2c_wait_complete(codec) < 0) {
+                codec_err(codec, "%s() Transaction Failed 0x%02x : 0x%04x\n",
+                        __func__, i2c_address, i2c_reg);
+                return -EIO;
+        }
+
+        /* Register in bits 15-8 and the data in 7-0 */
+        read_data = cs_vendor_coef_get(codec, CIR_I2C_QREAD);
+
+        cs8409_enable_i2c_clock(codec, 0);
+
+        return read_data & 0x0ff;
+}
+
+/**
+ * cs8409_i2c_write - CS8409 I2C Write.
+ * @codec: the codec instance
+ * @i2c_address: I2C Address
+ * @i2c_reg: Register to write to
+ * @i2c_data: Data to write
+ * @paged: Is a paged transaction
+ *
+ * CS8409 I2C Write.
+ * Returns negative on error, otherwise returns 0.
+ */
+static int cs8409_i2c_write(struct hda_codec *codec,
+                unsigned int i2c_address, unsigned int i2c_reg,
+                unsigned int i2c_data,
+                unsigned int paged)
+{
+        unsigned int i2c_reg_data;
+
+        cs8409_enable_i2c_clock(codec, 1);
+        cs_vendor_coef_set(codec, CIR_I2C_ADDR, i2c_address);
+
+        if (paged) {
+                cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg >> 8);
+                if (cs8409_i2c_wait_complete(codec) < 0) {
+                        codec_err(codec,
+                                "%s() Paged Transaction Failed 0x%02x : 0x%04x\n",
+                                __func__, i2c_address, i2c_reg);
+                        return -EIO;
+                }
+        }
+
+        i2c_reg_data = ((i2c_reg << 8) & 0x0ff00) | (i2c_data & 0x0ff);
+        cs_vendor_coef_set(codec, CIR_I2C_QWRITE, i2c_reg_data);
+
+        if (cs8409_i2c_wait_complete(codec) < 0) {
+                codec_err(codec, "%s() Transaction Failed 0x%02x : 0x%04x\n",
+                        __func__, i2c_address, i2c_reg);
+                return -EIO;
+        }
+
+        cs8409_enable_i2c_clock(codec, 0);
+
+        return 0;
+}
+
+static int cs8409_cs42l42_volume_info(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_info *uinfo)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        u16 nid = get_amp_nid(kcontrol);
+        u8 chs = get_amp_channels(kcontrol);
+
+        codec_dbg(codec, "%s() nid: %d\n", __func__, nid);
+        switch (nid) {
+        case CS8409_CS42L42_HP_PIN_NID:
+                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+                uinfo->count = chs == 3 ? 2 : 1;
+                uinfo->value.integer.min = CS8409_CS42L42_HP_VOL_REAL_MIN;
+                uinfo->value.integer.max = CS8409_CS42L42_HP_VOL_REAL_MAX;
+                break;
+        case CS8409_CS42L42_AMIC_PIN_NID:
+                uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+                uinfo->count = chs == 3 ? 2 : 1;
+                uinfo->value.integer.min = CS8409_CS42L42_AMIC_VOL_REAL_MIN;
+                uinfo->value.integer.max = CS8409_CS42L42_AMIC_VOL_REAL_MAX;
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
+
+static void cs8409_cs42l42_update_volume(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+        int data;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+        data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_HS_VOLUME_CHA, 1);
+        if (data >= 0)
+                spec->cs42l42_hp_volume[0] = -data;
+        else
+                spec->cs42l42_hp_volume[0] = CS8409_CS42L42_HP_VOL_REAL_MIN;
+        data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_HS_VOLUME_CHB, 1);
+        if (data >= 0)
+                spec->cs42l42_hp_volume[1] = -data;
+        else
+                spec->cs42l42_hp_volume[1] = CS8409_CS42L42_HP_VOL_REAL_MIN;
+        data = cs8409_i2c_read(codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_AMIC_VOLUME, 1);
+        if (data >= 0)
+                spec->cs42l42_hs_mic_volume[0] = -data;
+        else
+                spec->cs42l42_hs_mic_volume[0] = CS8409_CS42L42_AMIC_VOL_REAL_MIN;
+        mutex_unlock(&spec->cs8409_i2c_mux);
+        spec->cs42l42_volume_init = 1;
+}
+
+static int cs8409_cs42l42_volume_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs_spec *spec = codec->spec;
+        hda_nid_t nid = get_amp_nid(kcontrol);
+        int chs = get_amp_channels(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+
+        if (!spec->cs42l42_volume_init) {
+                snd_hda_power_up(codec);
+                cs8409_cs42l42_update_volume(codec);
+                snd_hda_power_down(codec);
+        }
+        switch (nid) {
+        case CS8409_CS42L42_HP_PIN_NID:
+                if (chs & BIT(0))
+                        *valp++ = spec->cs42l42_hp_volume[0];
+                if (chs & BIT(1))
+                        *valp++ = spec->cs42l42_hp_volume[1];
+                break;
+        case CS8409_CS42L42_AMIC_PIN_NID:
+                if (chs & BIT(0))
+                        *valp++ = spec->cs42l42_hs_mic_volume[0];
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
+
+static int cs8409_cs42l42_volume_put(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct cs_spec *spec = codec->spec;
+        hda_nid_t nid = get_amp_nid(kcontrol);
+        int chs = get_amp_channels(kcontrol);
+        long *valp = ucontrol->value.integer.value;
+        int change = 0;
+        char vol;
+
+        snd_hda_power_up(codec);
+        switch (nid) {
+        case CS8409_CS42L42_HP_PIN_NID:
+                mutex_lock(&spec->cs8409_i2c_mux);
+                if (chs & BIT(0)) {
+                        vol = -(*valp);
+                        change = cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_HS_VOLUME_CHA, vol, 1);
+                        valp++;
+                }
+                if (chs & BIT(1)) {
+                        vol = -(*valp);
+                        change |= cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_HS_VOLUME_CHB, vol, 1);
+                }
+                mutex_unlock(&spec->cs8409_i2c_mux);
+                break;
+        case CS8409_CS42L42_AMIC_PIN_NID:
+                mutex_lock(&spec->cs8409_i2c_mux);
+                if (chs & BIT(0)) {
+                        change = cs8409_i2c_write(
+                                codec, CS42L42_I2C_ADDR,
+                                CS8409_CS42L42_REG_AMIC_VOLUME, (char)*valp, 1);
+                        valp++;
+                }
+                mutex_unlock(&spec->cs8409_i2c_mux);
+                break;
+        default:
+                break;
+        }
+        cs8409_cs42l42_update_volume(codec);
+        snd_hda_power_down(codec);
+        return change;
+}
+
+static const DECLARE_TLV_DB_SCALE(
+        cs8409_cs42l42_hp_db_scale,
+        CS8409_CS42L42_HP_VOL_REAL_MIN * 100, 100, 1);
+
+static const DECLARE_TLV_DB_SCALE(
+        cs8409_cs42l42_amic_db_scale,
+        CS8409_CS42L42_AMIC_VOL_REAL_MIN * 100, 100, 1);
+
+static const struct snd_kcontrol_new cs8409_cs42l42_hp_volume_mixer = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .index = 0,
+        .name = "Headphone Playback Volume",
+        .subdevice = (HDA_SUBDEV_AMP_FLAG | HDA_SUBDEV_NID_FLAG),
+        .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE
+                         | SNDRV_CTL_ELEM_ACCESS_TLV_READ),
+        .info = cs8409_cs42l42_volume_info,
+        .get = cs8409_cs42l42_volume_get,
+        .put = cs8409_cs42l42_volume_put,
+        .tlv = { .p = cs8409_cs42l42_hp_db_scale },
+        .private_value = HDA_COMPOSE_AMP_VAL(
+                CS8409_CS42L42_HP_PIN_NID, 3, 0, HDA_OUTPUT)
+                | HDA_AMP_VAL_MIN_MUTE
+};
+
+static const struct snd_kcontrol_new cs8409_cs42l42_amic_volume_mixer = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .index = 0,
+        .name = "Mic Capture Volume",
+        .subdevice = (HDA_SUBDEV_AMP_FLAG | HDA_SUBDEV_NID_FLAG),
+        .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE
+                         | SNDRV_CTL_ELEM_ACCESS_TLV_READ),
+        .info = cs8409_cs42l42_volume_info,
+        .get = cs8409_cs42l42_volume_get,
+        .put = cs8409_cs42l42_volume_put,
+        .tlv = { .p = cs8409_cs42l42_amic_db_scale },
+        .private_value = HDA_COMPOSE_AMP_VAL(
+                CS8409_CS42L42_AMIC_PIN_NID, 1, 0, HDA_INPUT)
+                | HDA_AMP_VAL_MIN_MUTE
+};
+
+/* Assert/release RTS# line to CS42L42 */
+static void cs8409_cs42l42_reset(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+
+        /* Assert RTS# line */
+        snd_hda_codec_write(codec,
+                        codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, 0);
+        /* wait ~10ms */
+        usleep_range(10000, 15000);
+        /* Release RTS# line */
+        snd_hda_codec_write(codec,
+                        codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, GPIO5_INT);
+        /* wait ~10ms */
+        usleep_range(10000, 15000);
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+
+        /* Clear interrupts, by reading interrupt status registers */
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1309, 1);
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130A, 1);
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130F, 1);
+
+        mutex_unlock(&spec->cs8409_i2c_mux);
+
+}
+
+/* Configure CS42L42 slave codec for jack autodetect */
+static void cs8409_cs42l42_enable_jack_detect(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+
+        /* Set TIP_SENSE_EN for analog front-end of tip sense. */
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b70, 0x0020, 1);
+        /* Clear WAKE# */
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b71, 0x0001, 1);
+        /* Wait ~2.5ms */
+        usleep_range(2500, 3000);
+        /* Set mode WAKE# output follows the combination logic directly */
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b71, 0x0020, 1);
+        /* Clear interrupts status */
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130f, 1);
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b7b, 1);
+        /* Enable interrupt */
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1320, 0x03, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b79, 0x00, 1);
+
+        mutex_unlock(&spec->cs8409_i2c_mux);
+}
+
+/* Enable and run CS42L42 slave codec jack auto detect */
+static void cs8409_cs42l42_run_jack_detect(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+
+        /* Clear interrupts */
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b77, 1);
+
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1102, 0x87, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1f06, 0x86, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1b74, 0x07, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x131b, 0x01, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1120, 0x80, 1);
+        /* Wait ~110ms*/
+        usleep_range(110000, 200000);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x111f, 0x77, 1);
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1120, 0xc0, 1);
+        /* Wait ~10ms */
+        usleep_range(10000, 25000);
+
+        mutex_unlock(&spec->cs8409_i2c_mux);
+
+}
+
+static void cs8409_cs42l42_reg_setup(struct hda_codec *codec)
+{
+        const struct cs8409_i2c_param *seq = cs42l42_init_reg_seq;
+        struct cs_spec *spec = codec->spec;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+
+        for (; seq->addr; seq++)
+                cs8409_i2c_write(codec, CS42L42_I2C_ADDR, seq->addr, seq->reg, 1);
+
+        mutex_unlock(&spec->cs8409_i2c_mux);
+
+}
+
+/*
+ * In the case of CS8409 we do not have unsolicited events from NID's 0x24
+ * and 0x34 where hs mic and hp are connected. Companion codec CS42L42 will
+ * generate interrupt via gpio 4 to notify jack events. We have to overwrite
+ * generic snd_hda_jack_unsol_event(), read CS42L42 jack detect status registers
+ * and then notify status via generic snd_hda_jack_unsol_event() call.
+ */
+static void cs8409_jack_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        struct cs_spec *spec = codec->spec;
+        int status_changed = 0;
+        int reg_cdc_status;
+        int reg_hs_status;
+        int reg_ts_status;
+        int type;
+        struct hda_jack_tbl *jk;
+
+        /* jack_unsol_event() will be called every time gpio line changing state.
+         * In this case gpio4 line goes up as a result of reading interrupt status
+         * registers in previous cs8409_jack_unsol_event() call.
+         * We don't need to handle this event, ignoring...
+         */
+        if ((res & (1 << 4)))
+                return;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+
+        /* Read jack detect status registers */
+        reg_cdc_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1308, 1);
+        reg_hs_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1124, 1);
+        reg_ts_status = cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x130f, 1);
+
+        /* Clear interrupts, by reading interrupt status registers */
+        cs8409_i2c_read(codec, CS42L42_I2C_ADDR, 0x1b7b, 1);
+
+        mutex_unlock(&spec->cs8409_i2c_mux);
+
+        /* If status values are < 0, read error has occurred. */
+        if (reg_cdc_status < 0 || reg_hs_status < 0 || reg_ts_status < 0)
+                return;
+
+        /* HSDET_AUTO_DONE */
+        if (reg_cdc_status & CS42L42_HSDET_AUTO_DONE) {
+
+                type = ((reg_hs_status & CS42L42_HSTYPE_MASK) + 1);
+                /* CS42L42 reports optical jack as type 4
+                 * We don't handle optical jack
+                 */
+                if (type != 4) {
+                        if (!spec->cs42l42_hp_jack_in) {
+                                status_changed = 1;
+                                spec->cs42l42_hp_jack_in = 1;
+                        }
+                        /* type = 3 has no mic */
+                        if ((!spec->cs42l42_mic_jack_in) && (type != 3)) {
+                                status_changed = 1;
+                                spec->cs42l42_mic_jack_in = 1;
+                        }
+                } else {
+                        if (spec->cs42l42_hp_jack_in || spec->cs42l42_mic_jack_in) {
+                                status_changed = 1;
+                                spec->cs42l42_hp_jack_in = 0;
+                                spec->cs42l42_mic_jack_in = 0;
+                        }
+                }
+
+        } else {
+                /* TIP_SENSE INSERT/REMOVE */
+                switch (reg_ts_status) {
+                case CS42L42_JACK_INSERTED:
+                        cs8409_cs42l42_run_jack_detect(codec);
+                        break;
+
+                case CS42L42_JACK_REMOVED:
+                        if (spec->cs42l42_hp_jack_in || spec->cs42l42_mic_jack_in) {
+                                status_changed = 1;
+                                spec->cs42l42_hp_jack_in = 0;
+                                spec->cs42l42_mic_jack_in = 0;
+                        }
+                        break;
+
+                default:
+                        /* jack in transition */
+                        status_changed = 0;
+                        break;
+                }
+        }
+
+        if (status_changed) {
+
+                snd_hda_set_pin_ctl(codec, CS8409_CS42L42_SPK_PIN_NID,
+                                spec->cs42l42_hp_jack_in ? 0 : PIN_OUT);
+
+                /* Report jack*/
+                jk = snd_hda_jack_tbl_get_mst(codec, CS8409_CS42L42_HP_PIN_NID, 0);
+                if (jk) {
+                        snd_hda_jack_unsol_event(codec,
+                                (jk->tag << AC_UNSOL_RES_TAG_SHIFT) & AC_UNSOL_RES_TAG);
+                }
+                /* Report jack*/
+                jk = snd_hda_jack_tbl_get_mst(codec, CS8409_CS42L42_AMIC_PIN_NID, 0);
+                if (jk) {
+                        snd_hda_jack_unsol_event(codec,
+                                (jk->tag << AC_UNSOL_RES_TAG_SHIFT) & AC_UNSOL_RES_TAG);
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+/* Manage PDREF, when transition to D3hot */
+static int cs8409_suspend(struct hda_codec *codec)
+{
+        struct cs_spec *spec = codec->spec;
+
+        mutex_lock(&spec->cs8409_i2c_mux);
+        /* Power down CS42L42 ASP/EQ/MIX/HP */
+        cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x1101, 0xfe, 1);
+        mutex_unlock(&spec->cs8409_i2c_mux);
+        /* Assert CS42L42 RTS# line */
+        snd_hda_codec_write(codec,
+                        codec->core.afg, 0, AC_VERB_SET_GPIO_DATA, 0);
+
+        snd_hda_shutup_pins(codec);
+
+        return 0;
+}
+#endif
+
+/* Enable/Disable Unsolicited Response for gpio(s) 3,4 */
+static void cs8409_enable_ur(struct hda_codec *codec, int flag)
+{
+        /* GPIO4 INT# and GPIO3 WAKE# */
+        snd_hda_codec_write(codec, codec->core.afg,
+                        0, AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK,
+                        flag ? (GPIO3_INT | GPIO4_INT) : 0);
+
+        snd_hda_codec_write(codec, codec->core.afg,
+                        0, AC_VERB_SET_UNSOLICITED_ENABLE,
+                        flag ? AC_UNSOL_ENABLED : 0);
+
+}
+
+/* Vendor specific HW configuration
+ * PLL, ASP, I2C, SPI, GPIOs, DMIC etc...
+ */
+static void cs8409_cs42l42_hw_init(struct hda_codec *codec)
+{
+        const struct cs8409_cir_param *seq = cs8409_cs42l42_hw_cfg;
+        const struct cs8409_cir_param *seq_bullseye = cs8409_cs42l42_bullseye_atn;
+        struct cs_spec *spec = codec->spec;
+
+        if (spec->gpio_mask) {
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
+                                    spec->gpio_mask);
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
+                                    spec->gpio_dir);
+                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
+                                    spec->gpio_data);
+        }
+
+        for (; seq->nid; seq++)
+                cs_vendor_coef_set(codec, seq->cir, seq->coeff);
+
+        if (codec->fixup_id == CS8409_BULLSEYE)
+                for (; seq_bullseye->nid; seq_bullseye++)
+                        cs_vendor_coef_set(codec, seq_bullseye->cir, seq_bullseye->coeff);
+
+        /* Disable Unsolicited Response during boot */
+        cs8409_enable_ur(codec, 0);
+
+        /* Reset CS42L42 */
+        cs8409_cs42l42_reset(codec);
+
+        /* Initialise CS42L42 companion codec */
+        cs8409_cs42l42_reg_setup(codec);
+
+        if (codec->fixup_id == CS8409_WARLOCK ||
+                        codec->fixup_id == CS8409_CYBORG) {
+                /* FULL_SCALE_VOL = 0 for Warlock / Cyborg */
+                mutex_lock(&spec->cs8409_i2c_mux);
+                cs8409_i2c_write(codec, CS42L42_I2C_ADDR, 0x2001, 0x01, 1);
+                mutex_unlock(&spec->cs8409_i2c_mux);
+                /* DMIC1_MO=00b, DMIC1/2_SR=1 */
+                cs_vendor_coef_set(codec, 0x09, 0x0003);
+        }
+
+        /* Restore Volumes after Resume */
+        if (spec->cs42l42_volume_init) {
+                mutex_lock(&spec->cs8409_i2c_mux);
+                cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
+                                        CS8409_CS42L42_REG_HS_VOLUME_CHA,
+                                        -spec->cs42l42_hp_volume[0],
+                                        1);
+                cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
+                                        CS8409_CS42L42_REG_HS_VOLUME_CHB,
+                                        -spec->cs42l42_hp_volume[1],
+                                        1);
+                cs8409_i2c_write(codec, CS42L42_I2C_ADDR,
+                                        CS8409_CS42L42_REG_AMIC_VOLUME,
+                                        spec->cs42l42_hs_mic_volume[0],
+                                        1);
+                mutex_unlock(&spec->cs8409_i2c_mux);
+        }
+
+        cs8409_cs42l42_update_volume(codec);
+
+        cs8409_cs42l42_enable_jack_detect(codec);
+
+        /* Enable Unsolicited Response */
+        cs8409_enable_ur(codec, 1);
+}
+
+static int cs8409_cs42l42_init(struct hda_codec *codec)
+{
+        int ret = snd_hda_gen_init(codec);
+
+        if (!ret)
+                snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
+
+        return ret;
+}
+
+static const struct hda_codec_ops cs8409_cs42l42_patch_ops = {
+        .build_controls = cs_build_controls,
+        .build_pcms = snd_hda_gen_build_pcms,
+        .init = cs8409_cs42l42_init,
+        .free = cs_free,
+        .unsol_event = cs8409_jack_unsol_event,
+#ifdef CONFIG_PM
+        .suspend = cs8409_suspend,
+#endif
+};
+
+static void cs8409_cs42l42_fixups(struct hda_codec *codec,
+                                    const struct hda_fixup *fix, int action)
+{
+        struct cs_spec *spec = codec->spec;
+        int caps;
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PRE_PROBE:
+                snd_hda_add_verbs(codec, cs8409_cs42l42_init_verbs);
+                /* verb exec op override */
+                spec->exec_verb = codec->core.exec_verb;
+                codec->core.exec_verb = cs8409_cs42l42_exec_verb;
+
+                mutex_init(&spec->cs8409_i2c_mux);
+
+                codec->patch_ops = cs8409_cs42l42_patch_ops;
+
+                spec->gen.suppress_auto_mute = 1;
+                spec->gen.no_primary_hp = 1;
+                spec->gen.suppress_vmaster = 1;
+
+                /* GPIO 5 out, 3,4 in */
+                spec->gpio_dir = GPIO5_INT;
+                spec->gpio_data = 0;
+                spec->gpio_mask = 0x03f;
+
+                spec->cs42l42_hp_jack_in = 0;
+                spec->cs42l42_mic_jack_in = 0;
+
+                /* Basic initial sequence for specific hw configuration */
+                snd_hda_sequence_write(codec, cs8409_cs42l42_init_verbs);
+
+                /* CS8409 is simple HDA bridge and intended to be used with a remote
+                 * companion codec. Most of input/output PIN(s) have only basic
+                 * capabilities. NID(s) 0x24 and 0x34 have only OUTC and INC
+                 * capabilities and no presence detect capable (PDC) and call to
+                 * snd_hda_gen_build_controls() will mark them as non detectable
+                 * phantom jacks. However, in this configuration companion codec
+                 * CS42L42 is connected to these pins and it has jack detect
+                 * capabilities. We have to override pin capabilities,
+                 * otherwise they will not be created as input devices.
+                 */
+                caps = snd_hdac_read_parm(&codec->core, CS8409_CS42L42_HP_PIN_NID,
+                                AC_PAR_PIN_CAP);
+                if (caps >= 0)
+                        snd_hdac_override_parm(&codec->core,
+                                CS8409_CS42L42_HP_PIN_NID, AC_PAR_PIN_CAP,
+                                (caps | (AC_PINCAP_IMP_SENSE | AC_PINCAP_PRES_DETECT)));
+
+                caps = snd_hdac_read_parm(&codec->core, CS8409_CS42L42_AMIC_PIN_NID,
+                                AC_PAR_PIN_CAP);
+                if (caps >= 0)
+                        snd_hdac_override_parm(&codec->core,
+                                CS8409_CS42L42_AMIC_PIN_NID, AC_PAR_PIN_CAP,
+                                (caps | (AC_PINCAP_IMP_SENSE | AC_PINCAP_PRES_DETECT)));
+
+                snd_hda_override_wcaps(codec, CS8409_CS42L42_HP_PIN_NID,
+                        (get_wcaps(codec, CS8409_CS42L42_HP_PIN_NID) | AC_WCAP_UNSOL_CAP));
+
+                snd_hda_override_wcaps(codec, CS8409_CS42L42_AMIC_PIN_NID,
+                        (get_wcaps(codec, CS8409_CS42L42_AMIC_PIN_NID) | AC_WCAP_UNSOL_CAP));
+                break;
+        case HDA_FIXUP_ACT_PROBE:
+
+                /* Set initial DMIC volume to -26 dB */
+                snd_hda_codec_amp_init_stereo(codec, CS8409_CS42L42_DMIC_ADC_PIN_NID,
+                                HDA_INPUT, 0, 0xff, 0x19);
+                snd_hda_gen_add_kctl(&spec->gen,
+                        NULL, &cs8409_cs42l42_hp_volume_mixer);
+                snd_hda_gen_add_kctl(&spec->gen,
+                        NULL, &cs8409_cs42l42_amic_volume_mixer);
+                cs8409_cs42l42_hw_init(codec);
+                snd_hda_codec_set_name(codec, "CS8409/CS42L42");
+                break;
+        case HDA_FIXUP_ACT_INIT:
+                cs8409_cs42l42_hw_init(codec);
+                fallthrough;
+        case HDA_FIXUP_ACT_BUILD:
+                /* Run jack auto detect first time on boot
+                 * after controls have been added, to check if jack has
+                 * been already plugged in.
+                 * Run immediately after init.
+                 */
+                cs8409_cs42l42_run_jack_detect(codec);
+                usleep_range(100000, 150000);
+                break;
+        default:
+                break;
+        }
+}
+
+static int cs8409_cs42l42_exec_verb(struct hdac_device *dev,
+                unsigned int cmd, unsigned int flags, unsigned int *res)
+{
+        struct hda_codec *codec = container_of(dev, struct hda_codec, core);
+        struct cs_spec *spec = codec->spec;
+
+        unsigned int nid = ((cmd >> 20) & 0x07f);
+        unsigned int verb = ((cmd >> 8) & 0x0fff);
+
+        /* CS8409 pins have no AC_PINSENSE_PRESENCE
+         * capabilities. We have to intercept 2 calls for pins 0x24 and 0x34
+         * and return correct pin sense values for read_pin_sense() call from
+         * hda_jack based on CS42L42 jack detect status.
+         */
+        switch (nid) {
+        case CS8409_CS42L42_HP_PIN_NID:
+                if (verb == AC_VERB_GET_PIN_SENSE) {
+                        *res = (spec->cs42l42_hp_jack_in) ? AC_PINSENSE_PRESENCE : 0;
+                        return 0;
+                }
+                break;
+
+        case CS8409_CS42L42_AMIC_PIN_NID:
+                if (verb == AC_VERB_GET_PIN_SENSE) {
+                        *res = (spec->cs42l42_mic_jack_in) ? AC_PINSENSE_PRESENCE : 0;
+                        return 0;
+                }
+                break;
+
+        default:
+                break;
+        }
+
+        return spec->exec_verb(dev, cmd, flags, res);
+}
+
+static int patch_cs8409(struct hda_codec *codec)
+{
+        int err;
+
+        if (!cs_alloc_spec(codec, CS8409_VENDOR_NID))
+                return -ENOMEM;
+
+        snd_hda_pick_fixup(codec,
+                        cs8409_models, cs8409_fixup_tbl, cs8409_fixups);
+
+        codec_dbg(codec, "Picked ID=%d, VID=%08x, DEV=%08x\n",
+                        codec->fixup_id,
+                        codec->bus->pci->subsystem_vendor,
+                        codec->bus->pci->subsystem_device);
+
+        snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
+
+        err = cs_parse_auto_config(codec);
+        if (err < 0) {
+                cs_free(codec);
+                return err;
+        }
+
+        snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
+        return 0;
+}
 
 /*
@@ -1236 +2312 @@
         HDA_CODEC_ENTRY(0x10134210, "CS4210", patch_cs4210),
         HDA_CODEC_ENTRY(0x10134213, "CS4213", patch_cs4213),
+        HDA_CODEC_ENTRY(0x10138409, "CS8409", patch_cs8409),
         {0} /* terminator */
 };

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_hdmi.c ¶

@@ -1948 +1948 @@
         SND_PCI_QUIRK(0x103c, 0x870f, "HP", 1),
         SND_PCI_QUIRK(0x103c, 0x871a, "HP", 1),
+        SND_PCI_QUIRK(0x1462, 0xec94, "MS-7C94", 1),
         {}
 };

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_realtek.c ¶

@@ -299 +299 @@
 {
 #ifdef CONFIG_SND_HDA_GENERIC_LEDS
-        if (action == HDA_FIXUP_ACT_PROBE)
+        if (action == HDA_FIXUP_ACT_PRE_PROBE)
                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 #endif
@@ -3776 +3776 @@
                 report |= SND_JACK_BTN_3;
 
-        jack->jack->button_state = report;
+        snd_hda_jack_set_button_state(codec, jack->nid, report);
 }
 
@@ -3839 +3839 @@
 {
         struct alc_spec *spec = codec->spec;
+        hda_nid_t hp_pin;
 
         switch (action) {
@@ -3845 +3846 @@
                 snd_hda_jack_detect_enable_callback(codec, 0x55,
                                                     alc_headset_btn_callback);
-                snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
-                                      SND_JACK_HEADSET, alc_headset_btn_keymap);
-                break;
-        case HDA_FIXUP_ACT_INIT:
+                break;
+        case HDA_FIXUP_ACT_BUILD:
+                hp_pin = alc_get_hp_pin(spec);
+                if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
+                                                        alc_headset_btn_keymap,
+                                                        hp_pin))
+                        snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
+                                              false, SND_JACK_HEADSET,
+                                              alc_headset_btn_keymap);
+
                 alc_enable_headset_jack_key(codec);
                 break;
@@ -7275 +7282 @@
         ALC256_FIXUP_ACER_HEADSET_MIC,
         ALC285_FIXUP_IDEAPAD_S740_COEF,
+        ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
         ALC295_FIXUP_ASUS_DACS,
         ALC295_FIXUP_HP_OMEN,
@@ -9116 +9124 @@
                 .chained = true,
                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
+        },
+        [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc269_fixup_limit_int_mic_boost,
+                .chained = true,
+                .chain_id = ALC285_FIXUP_HP_MUTE_LED,
         },
         [ALC295_FIXUP_ASUS_DACS] = {
@@ -9202 +9216 @@
         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
+        SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
+        SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
@@ -9369 +9385 @@
         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
+        SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
+        SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
@@ -9552 +9570 @@
         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
+        SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940", ALC298_FIXUP_LENOVO_SPK_VOLUME),
         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/patch_sigmatel.c ¶

@@ -4379 +4379 @@
         spec->gen.automute_hook = stac_update_outputs;
 
+#ifndef TARGET_OS2
+        if (spec->gpio_led)
+                snd_hda_gen_add_mute_led_cdev(codec, stac_vmaster_hook);
+#endif
         err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
         if (err < 0)
@@ -4420 +4424 @@
 #endif
 
-#ifdef CONFIG_SND_HDA_GENERIC_LEDS
-        if (spec->gpio_led)
-                snd_hda_gen_add_mute_led_cdev(codec, stac_vmaster_hook);
-#endif
         if (spec->aloopback_ctl &&
             snd_hda_get_bool_hint(codec, "loopback") == 1) {

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/thinkpad_helper.c ¶

@@ -19 +19 @@
                                     const struct hda_fixup *fix, int action)
 {
-        if (action == HDA_FIXUP_ACT_PROBE) {
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
                 if (!is_thinkpad(codec))
                         return;

GPL/branches/uniaud32-next/include/linux/kmod.h ¶

@@ -3 +3 @@
 #ifndef _LINUX_KMOD_H
 #define _LINUX_KMOD_H
+#include <asm/errno.h>
+static inline int request_module(const char *name, ...) { return -ENOSYS; }
 
 #endif /* _LINUX_KMOD_H */

GPL/branches/uniaud32-next/include/linux/moduleparam.h ¶

@@ -62 +62 @@
    ulong, charp, bool or invbool, or XXX if you define param_get_XXX,
    param_set_XXX and param_check_XXX. */
-#define module_param_named(name, value, type, perm)                        \
-        param_check_##type(name, &(value));                                \
-        module_param_call(name, param_set_##type, param_get_##type, &value, perm)
+#define module_param_named(name, value, type, perm)
 
 #ifndef TARGET_OS2

GPL/branches/uniaud32-next/include/linux/rwsem.h ¶

@@ -14 +14 @@
 #define up_read(x) up(x)
 #define up_write(x) up(x)
+#define downgrade_write
 
 static inline int down_write_trylock(struct rw_semaphore *sem) {return 0;}

GPL/branches/uniaud32-next/include/linux/slab.h ¶

@@ -116 +116 @@
 krealloc_array(void *p, size_t new_n, size_t new_size, gfp_t flags)
 {
-        size_t bytes;
+//      size_t bytes;
 
 //      if (check_mul_overflow(new_n, new_size, &bytes))
 //              return NULL;
 
-        return krealloc(p, bytes, flags);
+        return krealloc(p, new_n*new_size, flags);
 }