Changeset 717 for GPL/trunk/alsa-kernel/pci/hda

Timestamp:

Aug 7, 2022, 6:11:12 PM (3 years ago)

Author:

David Azarewicz

Message:

Merge changes from next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• alsa-kernel/pci/hda/hda_auto_parser.c (modified) (7 diffs)
• alsa-kernel/pci/hda/hda_bind.c (modified) (5 diffs)
• alsa-kernel/pci/hda/hda_codec.c (modified) (9 diffs)
• alsa-kernel/pci/hda/hda_controller.c (modified) (6 diffs)
• alsa-kernel/pci/hda/hda_controller.h (modified) (3 diffs)
• alsa-kernel/pci/hda/hda_generic.c (modified) (5 diffs)
• alsa-kernel/pci/hda/hda_generic.h (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_intel.c (modified) (25 diffs)
• alsa-kernel/pci/hda/hda_intel.h (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_local.h (modified) (4 diffs)
• alsa-kernel/pci/hda/patch_analog.c (modified) (3 diffs)
• alsa-kernel/pci/hda/patch_ca0132.c (modified) (3 diffs)
• alsa-kernel/pci/hda/patch_cirrus.c (modified) (6 diffs)
• alsa-kernel/pci/hda/patch_conexant.c (modified) (6 diffs)
• alsa-kernel/pci/hda/patch_hdmi.c (modified) (12 diffs)
• alsa-kernel/pci/hda/patch_realtek.c (modified) (80 diffs)
• alsa-kernel/pci/hda/patch_sigmatel.c (modified) (3 diffs)
• alsa-kernel/pci/hda/patch_via.c (modified) (1 diff)

GPL/trunk/alsa-kernel/pci/hda/hda_auto_parser.c

@@ -828 +828 @@
 }
 
-static void apply_fixup(struct hda_codec *codec, int id, int action, int depth)
+void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth)
 {
         const char *modelname = codec->fixup_name;
@@ -838 +838 @@
                         break;
                 if (fix->chained_before)
-                        apply_fixup(codec, fix->chain_id, action, depth + 1);
+                        __snd_hda_apply_fixup(codec, fix->chain_id, action, depth + 1);
 
                 switch (fix->type) {
@@ -879 +879 @@
         }
 }
+EXPORT_SYMBOL_GPL(__snd_hda_apply_fixup);
 
 /**
@@ -888 +889 @@
 {
         if (codec->fixup_list)
-                apply_fixup(codec, codec->fixup_id, action, 0);
+                __snd_hda_apply_fixup(codec, codec->fixup_id, action, 0);
 }
 EXPORT_SYMBOL_GPL(snd_hda_apply_fixup);
@@ -976 +977 @@
  *
  * The function tries to find the matching model name at first, if given.
+ * If the model string contains the SSID alias, try to look up with the given
+ * alias ID.
  * If nothing matched, try to look up the PCI SSID.
  * If still nothing matched, try to look up the codec SSID.
@@ -987 +990 @@
         int id = HDA_FIXUP_ID_NOT_SET;
         const char *name = NULL;
+        const char *type = NULL;
+        unsigned int vendor, device;
 
         if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
@@ -993 +998 @@
         /* when model=nofixup is given, don't pick up any fixups */
         if (codec->modelname && !strcmp(codec->modelname, "nofixup")) {
-                codec->fixup_list = NULL;
-                codec->fixup_name = NULL;
-                codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
+                id = HDA_FIXUP_ID_NO_FIXUP;
+                fixlist = NULL;
                 codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
                           codec->core.chip_name);
-                return;
-        }
-
+                goto found;
+        }
+
+        /* match with the model name string */
         if (codec->modelname && models) {
                 while (models->name) {
                         if (!strcmp(codec->modelname, models->name)) {
-                                codec->fixup_id = models->id;
-                                codec->fixup_name = models->name;
-                                codec->fixup_list = fixlist;
+                                id = models->id;
+                                name = models->name;
                                 codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
                                           codec->core.chip_name, codec->fixup_name);
-                                return;
+                                goto found;
                         }
                         models++;
                 }
         }
-        if (quirk) {
-                q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
+
+        if (!quirk)
+                return;
+
+        /* match with the SSID alias given by the model string "XXXX:YYYY" */
+        if (codec->modelname &&
+            sscanf(codec->modelname, "%04x:%04x", &vendor, &device) == 2) {
+                q = snd_pci_quirk_lookup_id(vendor, device, quirk);
                 if (q) {
-                        id = q->value;
+                        type = "alias SSID";
+                        goto found_device;
+                }
+        }
+
+        /* match with the PCI SSID */
+        q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
+        if (q) {
+                type = "PCI SSID";
+                goto found_device;
+        }
+
+        /* match with the codec SSID */
+        q = snd_pci_quirk_lookup_id(codec->core.subsystem_id >> 16,
+                                    codec->core.subsystem_id & 0xffff,
+                                    quirk);
+        if (q) {
+                type = "codec SSID";
+                goto found_device;
+        }
+
+        return; /* no matching */
+
+ found_device:
+        id = q->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
-                        name = q->name;
-                        codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
-                                  codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
+        name = q->name;
 #endif
-                }
-        }
-        if (id < 0 && quirk) {
-                for (q = quirk; q->subvendor || q->subdevice; q++) {
-                        unsigned int vendorid =
-                                q->subdevice | (q->subvendor << 16);
-                        unsigned int mask = 0xffff0000 | q->subdevice_mask;
-                        if ((codec->core.subsystem_id & mask) == (vendorid & mask)) {
-                                id = q->value;
-#ifdef CONFIG_SND_DEBUG_VERBOSE
-                                name = q->name;
-                                codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
-                                          codec->core.chip_name, name);
-#endif
-                                break;
-                        }
-                }
-        }
-
+        codec_dbg(codec, "%s: picked fixup %s for %s %04x:%04x\n",
+                  codec->core.chip_name, name ? name : "",
+                  type, q->subvendor, q->subdevice);
+ found:
         codec->fixup_id = id;
-        if (id >= 0) {
-                codec->fixup_list = fixlist;
-                codec->fixup_name = name;
-        }
+        codec->fixup_list = fixlist;
+        codec->fixup_name = name;
 }
 EXPORT_SYMBOL_GPL(snd_hda_pick_fixup);

GPL/trunk/alsa-kernel/pci/hda/hda_bind.c

@@ -159 +159 @@
         }
 
+        refcount_dec(&codec->pcm_ref);
+        snd_hda_codec_disconnect_pcms(codec);
+        wait_event(codec->remove_sleep, !refcount_read(&codec->pcm_ref));
+        snd_power_sync_ref(codec->bus->card);
+
         if (codec->patch_ops.free)
                 codec->patch_ops.free(codec);
@@ -168 +173 @@
 static void hda_codec_driver_shutdown(struct device *dev)
 {
-        struct hda_codec *codec = dev_to_hda_codec(dev);
-
-        if (!pm_runtime_suspended(dev)) {
-                if (codec->patch_ops.reboot_notify)
-                        codec->patch_ops.reboot_notify(codec);
-                snd_hda_codec_display_power(codec, false);
-        }
+        snd_hda_codec_shutdown(dev_to_hda_codec(dev));
 }
 
@@ -309 +308 @@
         int err;
 
+        if (codec->configured)
+                return 0;
+
         if (is_generic_config(codec))
                 codec->probe_id = HDA_CODEC_ID_GENERIC;
@@ -314 +316 @@
                 codec->probe_id = 0;
 
-        err = snd_hdac_device_register(&codec->core);
-        if (err < 0)
-                return err;
+        if (!device_is_registered(&codec->core.dev)) {
+                err = snd_hdac_device_register(&codec->core);
+                if (err < 0)
+                        return err;
+        }
 
         if (!codec->preset)
@@ -323 +327 @@
                 err = codec_bind_generic(codec);
                 if (err < 0) {
-                        codec_err(codec, "Unable to bind the codec\n");
-                        goto error;
+                        codec_dbg(codec, "Unable to bind the codec\n");
+                        return err;
                 }
         }
 
-        return 0;
-
- error:
-        snd_hdac_device_unregister(&codec->core);
-        return err;
+        codec->configured = 1;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_configure);

GPL/trunk/alsa-kernel/pci/hda/hda_codec.c

@@ -712 +712 @@
  * PCM device
  */
-static void release_pcm(struct kref *kref)
-{
-        struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
-#ifndef TARGET_OS2
-/* don't do this on OS/2 - results in the device being free'd and can't be re-opened */
-        if (pcm->pcm)
-                snd_device_free(pcm->codec->card, pcm->pcm);
-#endif
-        clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
-        kfree(pcm->name);
-        kfree(pcm);
-}
 
 void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
 {
-        kref_put(&pcm->kref, release_pcm);
+        if (refcount_dec_and_test(&pcm->codec->pcm_ref))
+                wake_up(&pcm->codec->remove_sleep);
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
@@ -742 +731 @@
 
         pcm->codec = codec;
-        kref_init(&pcm->kref);
         va_start(args, fmt);
         pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
@@ -752 +740 @@
 
         list_add_tail(&pcm->list, &codec->pcm_list_head);
+        refcount_inc(&codec->pcm_ref);
         return pcm;
 }
@@ -759 +748 @@
  * codec destructor
  */
-static void codec_release_pcms(struct hda_codec *codec)
-{
-        struct hda_pcm *pcm, *n;
-
-        list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list, struct hda_pcm) {
-                list_del_init(&pcm->list);
+void snd_hda_codec_disconnect_pcms(struct hda_codec *codec)
+{
+        struct hda_pcm *pcm;
+
+        list_for_each_entry(pcm, &codec->pcm_list_head, list, struct hda_pcm) {
+                if (pcm->disconnected)
+                        continue;
                 if (pcm->pcm)
                         snd_device_disconnect(codec->card, pcm->pcm);
                 snd_hda_codec_pcm_put(pcm);
+                pcm->disconnected = 1;
+        }
+}
+
+static void codec_release_pcms(struct hda_codec *codec)
+{
+        struct hda_pcm *pcm, *n;
+
+        list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list, struct hda_pcm) {
+                list_del(&pcm->list);
+#ifndef TARGET_OS2
+                /* don't do this on OS/2 - results in the device being free'd and can't be re-opened */
+                if (pcm->pcm)
+                        snd_device_free(pcm->codec->card, pcm->pcm);
+#endif
+                clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
+                kfree(pcm->name);
+                kfree(pcm);
         }
 }
@@ -780 +788 @@
         }
 
+        snd_hda_codec_disconnect_pcms(codec);
         cancel_delayed_work_sync(&codec->jackpoll_work);
         if (!codec->in_freeing)
@@ -802 +811 @@
         remove_conn_list(codec);
         snd_hdac_regmap_exit(&codec->core);
+        codec->configured = 0;
+        refcount_set(&codec->pcm_ref, 1); /* reset refcount */
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup_for_unbind);
@@ -968 +979 @@
         INIT_LIST_HEAD(&codec->conn_list);
         INIT_LIST_HEAD(&codec->pcm_list_head);
+        refcount_set(&codec->pcm_ref, 1);
+        init_waitqueue_head(&codec->remove_sleep);
 
         INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
@@ -1737 +1750 @@
         int i;
         struct hda_nid_item *items = codec->mixers.list;
+
+        down_write(&codec->card->controls_rwsem);
         for (i = 0; i < codec->mixers.used; i++)
                 snd_ctl_remove(codec->card, items[i].kctl);
+        up_write(&codec->card->controls_rwsem);
         snd_array_free(&codec->mixers);
         snd_array_free(&codec->nids);
@@ -2998 +3014 @@
                            NULL)
 };
+
+/* suspend the codec at shutdown; called from driver's shutdown callback */
+void snd_hda_codec_shutdown(struct hda_codec *codec)
+{
+        struct hda_pcm *cpcm;
+
+        /* Skip the shutdown if codec is not registered */
+        if (!codec->registered)
+                return;
+
+        list_for_each_entry(cpcm, &codec->pcm_list_head, list, struct hda_pcm)
+                snd_pcm_suspend_all(cpcm->pcm);
+
+        pm_runtime_force_suspend(hda_codec_dev(codec));
+        pm_runtime_disable(hda_codec_dev(codec));
+}
 
 /*

GPL/trunk/alsa-kernel/pci/hda/hda_controller.c

@@ -26 +26 @@
 #include <sound/initval.h>
 #include "hda_controller.h"
+#include "hda_local.h"
 
 #ifndef TARGET_OS2
@@ -523 +524 @@
 
                 nsec = timecounter_read(&azx_dev->core.tc);
-                nsec = div_u64(nsec, 3); /* can be optimized */
                 if (audio_tstamp_config->report_delay)
                         nsec = azx_adjust_codec_delay(substream, nsec);
@@ -690 +690 @@
 }
 
-#ifndef TARGET_OS2
-static int azx_pcm_mmap(struct snd_pcm_substream *substream,
-                        struct vm_area_struct *area)
-{
-        struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
-        struct azx *chip = apcm->chip;
-        if (chip->ops->pcm_mmap_prepare)
-                chip->ops->pcm_mmap_prepare(substream, area);
-        return snd_pcm_lib_default_mmap(substream, area);
-}
-#else
-#define azx_pcm_mmap    NULL
-#endif
-
 static const struct snd_pcm_ops azx_pcm_ops = {
         .open = azx_pcm_open,
@@ -713 +699 @@
         .pointer = azx_pcm_pointer,
         .get_time_info =  azx_get_time_info,
-        .mmap = azx_pcm_mmap,
 };
 
@@ -778 +763 @@
                 size = MAX_PREALLOC_SIZE;
         if (chip->uc_buffer)
-                type = SNDRV_DMA_TYPE_DEV_UC_SG;
+                type = SNDRV_DMA_TYPE_DEV_WC_SG;
         snd_pcm_set_managed_buffer_all(pcm, type, chip->card->dev,
                                        size, MAX_PREALLOC_SIZE);
@@ -1293 +1278 @@
 {
         struct hda_codec *codec, *next;
-
-        /* use _safe version here since snd_hda_codec_configure() deregisters
-         * the device upon error and deletes itself from the bus list.
-         */
-        list_for_each_codec_safe(codec, next, &chip->bus) {
-                snd_hda_codec_configure(codec);
-        }
-
-        if (!azx_bus(chip)->num_codecs)
-                return -ENODEV;
-        return 0;
+        int success = 0;
+
+        list_for_each_codec(codec, &chip->bus) {
+                if (!snd_hda_codec_configure(codec))
+                        success++;
+        }
+
+        if (success) {
+                /* unregister failed codecs if any codec has been probed */
+                list_for_each_codec_safe(codec, next, &chip->bus) {
+                        if (!codec->configured) {
+                                codec_err(codec, "Unable to configure, disabling\n");
+                                snd_hdac_device_unregister(&codec->core);
+                        }
+                }
+        }
+
+        return success ? 0 : -ENODEV;
 }
 EXPORT_SYMBOL_GPL(azx_codec_configure);

GPL/trunk/alsa-kernel/pci/hda/hda_controller.h

@@ -42 +42 @@
 #define AZX_DCAPS_COUNT_LPIB_DELAY  (1 << 25)   /* Take LPIB as delay */
 #define AZX_DCAPS_PM_RUNTIME    (1 << 26)       /* runtime PM support */
-/* 27 unused */
+#define AZX_DCAPS_RETRY_PROBE   (1 << 27)       /* retry probe if no codec is configured */
 #define AZX_DCAPS_CORBRP_SELF_CLEAR (1 << 28)   /* CORBRP clears itself after reset */
 #define AZX_DCAPS_NO_MSI64      (1 << 29)       /* Stick to 32-bit MSIs */
@@ -75 +75 @@
         /* Disable msi if supported, PCI only */
         int (*disable_msi_reset_irq)(struct azx *);
-        void (*pcm_mmap_prepare)(struct snd_pcm_substream *substream,
-                                 struct vm_area_struct *area);
         /* Check if current position is acceptable */
         int (*position_check)(struct azx *chip, struct azx_dev *azx_dev);
@@ -142 +140 @@
         unsigned int uc_buffer:1; /* non-cached pages for stream buffers */
         unsigned int align_buffer_size:1;
-        unsigned int region_requested:1;
         unsigned int disabled:1; /* disabled by vga_switcheroo */
         unsigned int pm_prepared:1;

GPL/trunk/alsa-kernel/pci/hda/hda_generic.c

@@ -95 +95 @@
         snd_array_free(&spec->paths);
         snd_array_free(&spec->loopback_list);
+#ifdef CONFIG_SND_HDA_GENERIC_LEDS
+        if (spec->led_cdevs[LED_AUDIO_MUTE])
+                led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);
+        if (spec->led_cdevs[LED_AUDIO_MICMUTE])
+                led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);
+#endif
 }
 
@@ -3934 +3940 @@
                                 bool micmute)
 {
+        struct hda_gen_spec *spec = codec->spec;
         struct led_classdev *cdev;
+        int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;
+        int err;
 
         cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);
@@ -3944 +3953 @@
         cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";
         cdev->brightness_set_blocking = callback;
-        cdev->brightness = ledtrig_audio_get(micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE);
+        cdev->brightness = ledtrig_audio_get(idx);
         cdev->flags = LED_CORE_SUSPENDRESUME;
 
-        return devm_led_classdev_register(&codec->core.dev, cdev);
+        err = led_classdev_register(&codec->core.dev, cdev);
+        if (err < 0)
+                return err;
+        spec->led_cdevs[idx] = cdev;
+        return 0;
 }
 
@@ -6016 +6029 @@
 EXPORT_SYMBOL_GPL(snd_hda_gen_free);
 
-/**
- * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting
- * @codec: the HDA codec
- *
- * This can be put as patch_ops reboot_notify function.
- */
-void snd_hda_gen_reboot_notify(struct hda_codec *codec)
-{
-        /* Make the codec enter D3 to avoid spurious noises from the internal
-         * speaker during (and after) reboot
-         */
-        snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
-        snd_hda_codec_write(codec, codec->core.afg, 0,
-                            AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
-        msleep(10);
-}
-EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify);
-
 #ifdef CONFIG_PM
 /**
@@ -6061 +6056 @@
         .free = snd_hda_gen_free,
         .unsol_event = snd_hda_jack_unsol_event,
-        .reboot_notify = snd_hda_gen_reboot_notify,
 #ifdef CONFIG_PM
         .check_power_status = snd_hda_gen_check_power_status,

GPL/trunk/alsa-kernel/pci/hda/hda_generic.h

@@ -295 +295 @@
         void (*mic_autoswitch_hook)(struct hda_codec *codec,
                                     struct hda_jack_callback *cb);
+
+        /* leds */
+        struct led_classdev *led_cdevs[NUM_AUDIO_LEDS];
 };
 
@@ -325 +328 @@
 int snd_hda_gen_build_controls(struct hda_codec *codec);
 int snd_hda_gen_build_pcms(struct hda_codec *codec);
-void snd_hda_gen_reboot_notify(struct hda_codec *codec);
 
 /* standard jack event callbacks */

GPL/trunk/alsa-kernel/pci/hda/hda_intel.c

@@ -326 +326 @@
 #define AZX_DCAPS_PRESET_AMD_SB \
         (AZX_DCAPS_NO_TCSEL | AZX_DCAPS_AMD_WORKAROUND |\
-         AZX_DCAPS_SNOOP_TYPE(ATI) | AZX_DCAPS_PM_RUNTIME)
+         AZX_DCAPS_SNOOP_TYPE(ATI) | AZX_DCAPS_PM_RUNTIME |\
+         AZX_DCAPS_RETRY_PROBE)
 
 /* quirks for Nvidia */
@@ -353 +354 @@
                                         ((pci)->device == 0x0d0c) || \
                                         ((pci)->device == 0x160c) || \
-                                        ((pci)->device == 0x490d))
+                                        ((pci)->device == 0x490d) || \
+                                        ((pci)->device == 0x4f90) || \
+                                        ((pci)->device == 0x4f91) || \
+                                        ((pci)->device == 0x4f92))
 
 #define IS_BXT(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x5a98)
@@ -656 +660 @@
  * data is processed.  So, we need to process it afterwords in a
  * workqueue.
+ *
+ * Returns 1 if OK to proceed, 0 for delay handling, -1 for skipping update
  */
 static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
 {
         struct snd_pcm_substream *substream = azx_dev->core.substream;
+        struct snd_pcm_runtime *runtime = substream->runtime;
         int stream = substream->stream;
         u32 wallclk;
         unsigned int pos;
+        snd_pcm_uframes_t hwptr, target;
 
         wallclk = azx_readl(chip, WALLCLK) - azx_dev->core.start_wallclk;
@@ -706 +714 @@
                 return chip->bdl_pos_adj ? 0 : -1;
         azx_dev->core.start_wallclk += wallclk;
+
+        if (azx_dev->core.no_period_wakeup)
+                return 1; /* OK, no need to check period boundary */
+
+        if (runtime->hw_ptr_base != runtime->hw_ptr_interrupt)
+                return 1; /* OK, already in hwptr updating process */
+
+        /* check whether the period gets really elapsed */
+        pos = bytes_to_frames(runtime, pos);
+        hwptr = runtime->hw_ptr_base + pos;
+        if (hwptr < runtime->status->hw_ptr)
+                hwptr += runtime->buffer_size;
+        target = runtime->hw_ptr_interrupt + runtime->period_size;
+        if (hwptr < target) {
+                /* too early wakeup, process it later */
+                return chip->bdl_pos_adj ? 0 : -1;
+        }
+
         return 1; /* OK, it's fine */
 }
@@ -882 +908 @@
         /* just read back the calculated value in the above */
         return substream->runtime->delay;
-}
-
-static unsigned int azx_skl_get_dpib_pos(struct azx *chip,
-                                         struct azx_dev *azx_dev)
-{
-        return _snd_hdac_chip_readl(azx_bus(chip),
-                                    AZX_REG_VS_SDXDPIB_XBASE +
-                                    (AZX_REG_VS_SDXDPIB_XINTERVAL *
-                                     azx_dev->core.index));
-}
-
-/* get the current DMA position with correction on SKL+ chips */
-static unsigned int azx_get_pos_skl(struct azx *chip, struct azx_dev *azx_dev)
-{
-        /* DPIB register gives a more accurate position for playback */
-        if (azx_dev->core.substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                return azx_skl_get_dpib_pos(chip, azx_dev);
-
-        /* For capture, we need to read posbuf, but it requires a delay
-         * for the possible boundary overlap; the read of DPIB fetches the
-         * actual posbuf
-         */
-        udelay(20);
-        azx_skl_get_dpib_pos(chip, azx_dev);
-        return azx_get_pos_posbuf(chip, azx_dev);
 }
 
@@ -1407 +1408 @@
         if (bus->irq >= 0)
                 free_irq(bus->irq, (void*)chip);
-        if (chip->msi)
-                pci_disable_msi(chip->pci);
-#ifdef TARGET_OS2
-        iounmap((void *)bus->remap_addr);
-#else
-        iounmap(bus->remap_addr);
-#endif
 
         azx_free_stream_pages(chip);
@@ -1419 +1413 @@
         snd_hdac_bus_exit(bus);
 
-        if (chip->region_requested)
-                pci_release_regions(chip->pci);
-
-        pci_disable_device(chip->pci);
 #ifdef CONFIG_SND_HDA_PATCH_LOADER
         release_firmware(chip->fw);
@@ -1617 +1607 @@
                 [POS_FIX_VIACOMBO] = azx_via_get_position,
                 [POS_FIX_COMBO] = azx_get_pos_lpib,
-                [POS_FIX_SKL] = azx_get_pos_skl,
+                [POS_FIX_SKL] = azx_get_pos_posbuf,
                 [POS_FIX_FIFO] = azx_get_pos_fifo,
         };
@@ -1655 +1645 @@
         SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
         SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
+        SND_PCI_QUIRK(0x1558, 0x0351, "Schenker Dock 15", 0x105),
         /* WinFast VP200 H (Teradici) user reported broken communication */
         SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
@@ -1768 +1759 @@
 static void azx_probe_work(struct work_struct *work)
 {
-        struct hda_intel *hda = container_of(work, struct hda_intel, probe_work);
+        struct hda_intel *hda = container_of(work, struct hda_intel, probe_work.work);
         azx_probe_continue(&hda->chip);
 }
@@ -1820 +1811 @@
         hda = kzalloc(sizeof(*hda), GFP_KERNEL);
 #endif
-        if (!hda) {
-                pci_disable_device(pci);
-                return -ENOMEM;
-        }
+        if (!hda)
+                return -ENOMEM;
 
         chip = &hda->chip;
@@ -1844 +1833 @@
         assign_position_fix(chip, check_position_fix(chip, position_fix[dev]));
 
-        check_probe_mask(chip, dev);
-
         if (single_cmd < 0) /* allow fallback to single_cmd at errors */
                 chip->fallback_to_single_cmd = 1;
@@ -1859 +1846 @@
 
         err = azx_bus_init(chip, model[dev]);
-        if (err < 0) {
-                pci_disable_device(pci);
+        if (err < 0)
                 return err;
-        }
 
         /* use the non-cached pages in non-snoop mode */
         if (!azx_snoop(chip))
-                azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_UC;
+                azx_bus(chip)->dma_type = SNDRV_DMA_TYPE_DEV_WC;
 
         if (chip->driver_type == AZX_DRIVER_NVIDIA) {
@@ -1872 +1857 @@
                 chip->bus.core.needs_damn_long_delay = 1;
         }
+
+        check_probe_mask(chip, dev);
 
         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
@@ -1881 +1868 @@
 
         /* continue probing in work context as may trigger request module */
-        INIT_WORK(&hda->probe_work, azx_probe_work);
+        INIT_DELAYED_WORK(&hda->probe_work, azx_probe_work);
 
         *rchip = chip;
@@ -1908 +1895 @@
 #endif
 
+#ifndef TARGET_OS2
+        err = pcim_iomap_regions(pci, 1 << 0, "ICH HD audio");
+#else
         err = pci_request_regions(pci, "ICH HD audio");
+#endif
         if (err < 0)
                 return err;
-        chip->region_requested = 1;
 
         bus->addr = pci_resource_start(pci, 0);
+#ifndef TARGET_OS2
+        bus->remap_addr = pcim_iomap_table(pci)[0];
+#else
         bus->remap_addr = pci_ioremap_bar(pci, 0);
-        if (bus->remap_addr == NULL) {
-                dev_err(card->dev, "ioremap error\n");
-                return -ENXIO;
-        }
-
+#endif
         if (chip->driver_type == AZX_DRIVER_SKL)
                 snd_hdac_bus_parse_capabilities(bus);
@@ -2101 +2090 @@
 }
 
-static void pcm_mmap_prepare(struct snd_pcm_substream *substream,
-                             struct vm_area_struct *area)
-{
-#ifdef CONFIG_X86
-        struct azx_pcm *apcm = snd_pcm_substream_chip(substream);
-        struct azx *chip = apcm->chip;
-        if (chip->uc_buffer)
-                area->vm_page_prot = pgprot_writecombine(area->vm_page_prot);
-#endif
-}
-
 /* Denylist for skipping the whole probe:
  * some HD-audio PCI entries are exposed without any codecs, and such devices
@@ -2125 +2103 @@
 static const struct hda_controller_ops pci_hda_ops = {
         .disable_msi_reset_irq = disable_msi_reset_irq,
-        .pcm_mmap_prepare = pcm_mmap_prepare,
         .position_check = azx_position_check,
 };
@@ -2219 +2196 @@
 #else
         if (schedule_probe)
-                schedule_work(&hda->probe_work);
+                schedule_delayed_work(&hda->probe_work, 0);
 #endif
 
@@ -2306 +2283 @@
         int err;
 
+        if (chip->disabled || hda->init_failed)
+                return -EIO;
+        if (hda->probe_retry)
+                goto probe_retry;
+
         to_hda_bus(bus)->bus_probing = 1;
         hda->probe_continued = 1;
@@ -2367 +2349 @@
         }
 #endif
+
+ probe_retry:
         if (bus->codec_mask && !(probe_only[dev] & 1)) {
                 err = azx_codec_configure(chip);
-                if (err < 0)
+                if (err) {
+                        if ((chip->driver_caps & AZX_DCAPS_RETRY_PROBE) &&
+                            ++hda->probe_retry < 60) {
+                                schedule_delayed_work(&hda->probe_work,
+                                                      msecs_to_jiffies(1000));
+                                return 0; /* keep things up */
+                        }
+                        dev_err(chip->card->dev, "Cannot probe codecs, giving up\n");
                         goto out_free;
+                }
         }
 
@@ -2392 +2384 @@
 out_free:
         if (err < 0) {
-                azx_free(chip);
+                pci_set_drvdata(pci, NULL);
+                snd_card_free(chip->card);
                 return err;
         }
@@ -2400 +2393 @@
         complete_all(&hda->probe_wait);
         to_hda_bus(bus)->bus_probing = 0;
+        hda->probe_retry = 0;
         return 0;
 }
@@ -2425 +2419 @@
                  */
                 device_unlock(&pci->dev);
-                cancel_work_sync(&hda->probe_work);
+                cancel_delayed_work_sync(&hda->probe_work);
                 device_lock(&pci->dev);
 
@@ -2534 +2528 @@
         /* DG1 */
         { PCI_DEVICE(0x8086, 0x490d),
+          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+        /* DG2 */
+        { PCI_DEVICE(0x8086, 0x4f90),
+          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+        { PCI_DEVICE(0x8086, 0x4f91),
+          .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+        { PCI_DEVICE(0x8086, 0x4f92),
           .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
         /* Alderlake-S */

GPL/trunk/alsa-kernel/pci/hda/hda_intel.h

@@ -15 +15 @@
         /* sync probing */
         struct completion probe_wait;
-        struct work_struct probe_work;
+        struct delayed_work probe_work;
 
         /* card list (for power_save trigger) */
@@ -31 +31 @@
 
         bool need_i915_power:1; /* the hda controller needs i915 power */
+
+        int probe_retry;        /* being probe-retry */
 };
 

GPL/trunk/alsa-kernel/pci/hda/hda_local.h

@@ -138 +138 @@
 void snd_hda_codec_register(struct hda_codec *codec);
 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec);
+void snd_hda_codec_disconnect_pcms(struct hda_codec *codec);
 
 #define snd_hda_regmap_sync(codec)      snd_hdac_regmap_sync(&(codec)->core)
@@ -364 +365 @@
                            const struct hda_pintbl *cfg);
 void snd_hda_apply_fixup(struct hda_codec *codec, int action);
+void __snd_hda_apply_fixup(struct hda_codec *codec, int id, int action, int depth);
 void snd_hda_pick_fixup(struct hda_codec *codec,
                         const struct hda_model_fixup *models,
@@ -453 +455 @@
         for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)
 
+/* Set the codec power_state flag to indicate to allow unsol event handling;
+ * see hda_codec_unsol_event() in hda_bind.c.  Calling this might confuse the
+ * state tracking, so use with care.
+ */
+static inline void snd_hda_codec_allow_unsol_events(struct hda_codec *codec)
+{
+        codec->core.dev.power.power_state = PMSG_ON;
+}
+
 /*
  * get widget capabilities
@@ -629 +640 @@
                                              hda_nid_t nid,
                                              unsigned int power_state);
+
+void snd_hda_codec_shutdown(struct hda_codec *codec);
 
 /*

GPL/trunk/alsa-kernel/pci/hda/patch_analog.c

@@ -76 +76 @@
 #endif
 
-
+#ifdef CONFIG_PM
 static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
                                 hda_nid_t hp)
@@ -116 +116 @@
 }
 
-static void ad198x_shutup(struct hda_codec *codec)
+static int ad198x_suspend(struct hda_codec *codec)
 {
         snd_hda_shutup_pins(codec);
         ad198x_power_eapd(codec);
-}
-
-#ifdef CONFIG_PM
-static int ad198x_suspend(struct hda_codec *codec)
-{
-        ad198x_shutup(codec);
         return 0;
 }
@@ -172 +166 @@
         .suspend = ad198x_suspend,
 #endif
-        .reboot_notify = ad198x_shutup,
 };
 

GPL/trunk/alsa-kernel/pci/hda/patch_ca0132.c

@@ -2276 +2276 @@
 {
         struct ca0132_spec *spec = codec->spec;
-        int status = -1;
+        int status;
         unsigned int scp_send_size = 0;
         unsigned int total_size;
@@ -9782 +9782 @@
 }
 
-static void ca0132_reboot_notify(struct hda_codec *codec)
-{
-        codec->patch_ops.free(codec);
-}
-
 #ifdef CONFIG_PM
 static int ca0132_suspend(struct hda_codec *codec)
@@ -9806 +9801 @@
         .suspend = ca0132_suspend,
 #endif
-        .reboot_notify = ca0132_reboot_notify,
 };
 

GPL/trunk/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>
@@ -26 +25 @@
  */
 
-#define CS42L42_HP_CH     (2U)
-#define CS42L42_HS_MIC_CH (1U)
-
 struct cs_spec {
         struct hda_gen_spec gen;
@@ -47 +43 @@
         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);
 };
 
@@ -570 +554 @@
                 .chain_id = CS420X_GPIO_13,
         },
-#ifdef TARGET_OS2xxx
+#ifndef TARGET_OS2
         [CS420X_MBP81] = {
                 .type = HDA_FIXUP_VERBS,
@@ -1246 +1230 @@
 }
 
-/* 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;
-}
-
 /*
  * patch entries
@@ -2312 +1239 @@
         HDA_CODEC_ENTRY(0x10134210, "CS4210", patch_cs4210),
         HDA_CODEC_ENTRY(0x10134213, "CS4213", patch_cs4213),
-        HDA_CODEC_ENTRY(0x10138409, "CS8409", patch_cs8409),
         {0} /* terminator */
 };

GPL/trunk/alsa-kernel/pci/hda/patch_conexant.c

@@ -184 +184 @@
 }
 
-static void cx_auto_reboot_notify(struct hda_codec *codec)
+static void cx_auto_shutdown(struct hda_codec *codec)
 {
         struct conexant_spec *spec = codec->spec;
@@ -191 +191 @@
            from the internal speaker during (and after) reboot */
         cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);
-        snd_hda_gen_reboot_notify(codec);
 }
 
 static void cx_auto_free(struct hda_codec *codec)
 {
-        cx_auto_reboot_notify(codec);
+        cx_auto_shutdown(codec);
         snd_hda_gen_free(codec);
 }
+
+#ifdef CONFIG_PM
+static int cx_auto_suspend(struct hda_codec *codec)
+{
+        cx_auto_shutdown(codec);
+        return 0;
+}
+#endif
 
 static const struct hda_codec_ops cx_auto_patch_ops = {
@@ -204 +211 @@
         .build_pcms = snd_hda_gen_build_pcms,
         .init = cx_auto_init,
-        .reboot_notify = cx_auto_reboot_notify,
         .free = cx_auto_free,
         .unsol_event = snd_hda_jack_unsol_event,
 #ifdef CONFIG_PM
+        .suspend = cx_auto_suspend,
         .check_power_status = snd_hda_gen_check_power_status,
 #endif
@@ -998 +1005 @@
         SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x82b4, "HP ProDesk 600 G3", CXT_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO),
         SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO),
@@ -1106 +1114 @@
                                    cxt5051_fixups, cxt_fixups);
                 break;
+        case 0x14f15098:
+                codec->pin_amp_workaround = 1;
+                spec->gen.mixer_nid = 0x22;
+                spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
+                snd_hda_pick_fixup(codec, cxt5066_fixup_models,
+                                   cxt5066_fixups, cxt_fixups);
+                break;
         case 0x14f150f2:
                 codec->power_save_node = 1;
@@ -1126 +1141 @@
                 goto error;
 
-        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
+        err = cx_auto_parse_beep(codec);
         if (err < 0)
                 goto error;
 
-        err = cx_auto_parse_beep(codec);
+        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
         if (err < 0)
                 goto error;

GPL/trunk/alsa-kernel/pci/hda/patch_hdmi.c

@@ -59 +59 @@
 module_param(enable_silent_stream, bool, 0644);
 MODULE_PARM_DESC(enable_silent_stream, "Enable Silent Stream for HDMI devices");
+
+static bool enable_all_pins;
+module_param(enable_all_pins, bool, 0444);
+MODULE_PARM_DESC(enable_all_pins, "Forcibly enable all pins");
 
 struct hdmi_spec_per_cvt {
@@ -1396 +1400 @@
  last_try:
         /* the last try; check the empty slots in pins */
-        for (i = 0; i < spec->num_nids; i++) {
+        for (i = 0; i < spec->pcm_used; i++) {
                 if (!test_bit(i, &spec->pcm_bitmap))
                         return i;
@@ -1626 +1630 @@
         struct hdmi_spec *spec = codec->spec;
         struct hdmi_eld *eld = &spec->temp_eld;
+        struct device *dev = hda_codec_dev(codec);
         hda_nid_t pin_nid = per_pin->pin_nid;
         int dev_id = per_pin->dev_id;
@@ -1639 +1644 @@
         int ret;
 
+#ifdef  CONFIG_PM
+        if (dev->power.runtime_status == RPM_SUSPENDING)
+                return;
+#endif
+
         ret = snd_hda_power_up_pm(codec);
-        if (ret < 0 && pm_runtime_suspended(hda_codec_dev(codec)))
+        if (ret < 0 && pm_runtime_suspended(dev))
                 goto out;
 
@@ -1972 +1982 @@
         }
 
+        if (enable_all_pins)
+                spec->force_connect = true;
+
         q = snd_pci_quirk_lookup(codec->bus->pci, force_connect_list);
 
@@ -2269 +2282 @@
          */
 
-        if (codec->mst_no_extra_pcms)
+        if (spec->dyn_pcm_no_legacy && codec->mst_no_extra_pcms)
+                pcm_num = spec->num_cvts;
+        else if (codec->mst_no_extra_pcms)
                 pcm_num = spec->num_nids;
         else
@@ -2965 +2980 @@
 /* Intel Haswell and onwards; audio component with eld notifier */
 static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid,
-                                 const int *port_map, int port_num, int dev_num)
+                                 const int *port_map, int port_num, int dev_num,
+                                 bool send_silent_stream)
 {
         struct hdmi_spec *spec;
@@ -2998 +3014 @@
          * module param or Kconfig option
          */
-        if (enable_silent_stream)
+        if (send_silent_stream)
                 spec->send_silent_stream = true;
 
@@ -3006 +3022 @@
 static int patch_i915_hsw_hdmi(struct hda_codec *codec)
 {
-        return intel_hsw_common_init(codec, 0x08, NULL, 0, 3);
+        return intel_hsw_common_init(codec, 0x08, NULL, 0, 3,
+                                     enable_silent_stream);
 }
 
 static int patch_i915_glk_hdmi(struct hda_codec *codec)
 {
-        return intel_hsw_common_init(codec, 0x0b, NULL, 0, 3);
+        /*
+         * Silent stream calls audio component .get_power() from
+         * .pin_eld_notify(). On GLK this will deadlock in i915 due
+         * to the audio vs. CDCLK workaround.
+         */
+        return intel_hsw_common_init(codec, 0x0b, NULL, 0, 3, false);
 }
 
@@ -3022 +3044 @@
         static const int map[] = {0x0, 0x4, 0x6, 0x8, 0xa, 0xb};
 
-        return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 3);
+        return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 3,
+                                     enable_silent_stream);
 }
 
@@ -3034 +3057 @@
         int ret;
 
-        ret = intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4);
+        ret = intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4,
+                                    enable_silent_stream);
         if (!ret) {
                 struct hdmi_spec *spec = codec->spec;
@@ -4398 +4422 @@
 HDA_CODEC_ENTRY(0x80862814, "DG1 HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862815, "Alderlake HDMI",   patch_i915_tgl_hdmi),
-HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862816, "Rocketlake HDMI",  patch_i915_tgl_hdmi),
+HDA_CODEC_ENTRY(0x80862819, "DG2 HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x8086281a, "Jasperlake HDMI",  patch_i915_icl_hdmi),
 HDA_CODEC_ENTRY(0x8086281b, "Elkhartlake HDMI", patch_i915_icl_hdmi),
+HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI",  patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI", patch_i915_byt_hdmi),

GPL/trunk/alsa-kernel/pci/hda/patch_realtek.c

@@ -103 +103 @@
         struct alc_coef_led mute_led_coef;
         struct alc_coef_led mic_led_coef;
+        struct mutex coef_mutex;
 
         hda_nid_t headset_mic_pin;
@@ -115 +116 @@
 #endif
         void (*shutup)(struct hda_codec *codec);
-        void (*reboot_notify)(struct hda_codec *codec);
 
         int init_amp;
@@ -139 +139 @@
  */
 
-static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
-                               unsigned int coef_idx)
+static void coef_mutex_lock(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        snd_hda_power_up_pm(codec);
+        mutex_lock(&spec->coef_mutex);
+}
+
+static void coef_mutex_unlock(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        mutex_unlock(&spec->coef_mutex);
+        snd_hda_power_down_pm(codec);
+}
+
+static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+                                 unsigned int coef_idx)
 {
         unsigned int val;
@@ -149 +165 @@
 }
 
+static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+                               unsigned int coef_idx)
+{
+        unsigned int val;
+
+        coef_mutex_lock(codec);
+        val = __alc_read_coefex_idx(codec, nid, coef_idx);
+        coef_mutex_unlock(codec);
+        return val;
+}
+
 #define alc_read_coef_idx(codec, coef_idx) \
         alc_read_coefex_idx(codec, 0x20, coef_idx)
 
+static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+                                   unsigned int coef_idx, unsigned int coef_val)
+{
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
+        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
+}
+
 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
                                  unsigned int coef_idx, unsigned int coef_val)
 {
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
+        coef_mutex_lock(codec);
+        __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
+        coef_mutex_unlock(codec);
 }
 
 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
+
+static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
+                                    unsigned int coef_idx, unsigned int mask,
+                                    unsigned int bits_set)
+{
+        unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
+
+        if (val != -1)
+                __alc_write_coefex_idx(codec, nid, coef_idx,
+                                       (val & ~mask) | bits_set);
+}
 
 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
@@ -166 +212 @@
                                   unsigned int bits_set)
 {
-        unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
-
-        if (val != -1)
-                alc_write_coefex_idx(codec, nid, coef_idx,
-                                     (val & ~mask) | bits_set);
+        coef_mutex_lock(codec);
+        __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
+        coef_mutex_unlock(codec);
 }
 
@@ -203 +247 @@
                                 const struct coef_fw *fw)
 {
+        coef_mutex_lock(codec);
         for (; fw->nid; fw++) {
                 if (fw->mask == (unsigned short)-1)
-                        alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
+                        __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
                 else
-                        alc_update_coefex_idx(codec, fw->nid, fw->idx,
-                                              fw->mask, fw->val);
-        }
+                        __alc_update_coefex_idx(codec, fw->nid, fw->idx,
+                                                fw->mask, fw->val);
+        }
+        coef_mutex_unlock(codec);
 }
 
@@ -400 +446 @@
         case 0x10ec0255:
         case 0x10ec0256:
+        case 0x19e58326:
         case 0x10ec0257:
         case 0x10ec0282:
@@ -535 +582 @@
 
         switch (codec->core.vendor_id) {
+        case 0x10ec0236:
+        case 0x10ec0256:
+        case 0x19e58326:
         case 0x10ec0283:
         case 0x10ec0286:
@@ -893 +943 @@
 }
 
+#define alc_free        snd_hda_gen_free
+
+#ifdef CONFIG_PM
 static inline void alc_shutup(struct hda_codec *codec)
 {
@@ -906 +959 @@
 }
 
-static void alc_reboot_notify(struct hda_codec *codec)
-{
-        struct alc_spec *spec = codec->spec;
-
-        if (spec && spec->reboot_notify)
-                spec->reboot_notify(codec);
-        else
-                alc_shutup(codec);
-}
-
-#define alc_free        snd_hda_gen_free
-
-#ifdef CONFIG_PM
 static void alc_power_eapd(struct hda_codec *codec)
 {
@@ -932 +972 @@
         return 0;
 }
-#endif
-
-#ifdef CONFIG_PM
+
 static int alc_resume(struct hda_codec *codec)
 {
@@ -961 +999 @@
         .check_power_status = snd_hda_gen_check_power_status,
 #endif
-        .reboot_notify = alc_reboot_notify,
 };
 
@@ -1167 +1204 @@
         codec->forced_resume = 1;
         codec->patch_ops = alc_patch_ops;
+        mutex_init(&spec->coef_mutex);
 
         err = alc_codec_rename_from_preset(codec);
@@ -2295 +2333 @@
         ALC887_FIXUP_BASS_CHMAP,
         ALC1220_FIXUP_GB_DUAL_CODECS,
+        ALC1220_FIXUP_GB_X570,
         ALC1220_FIXUP_CLEVO_P950,
         ALC1220_FIXUP_CLEVO_PB51ED,
@@ -2300 +2339 @@
         ALC887_FIXUP_ASUS_AUDIO,
         ALC887_FIXUP_ASUS_HMIC,
+        ALCS1200A_FIXUP_MIC_VREF,
 };
 
@@ -2480 +2520 @@
                            "Rear-Panel Capture Switch" :
                            "Front-Panel Capture Switch");
+                break;
+        }
+}
+
+static void alc1220_fixup_gb_x570(struct hda_codec *codec,
+                                     const struct hda_fixup *fix,
+                                     int action)
+{
+        static const hda_nid_t conn1[] = { 0x0c };
+        static const struct coef_fw gb_x570_coefs[] = {
+                WRITE_COEF(0x07, 0x03c0),
+                WRITE_COEF(0x1a, 0x01c1),
+                WRITE_COEF(0x1b, 0x0202),
+                WRITE_COEF(0x43, 0x3005),
+                {0}
+        };
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PRE_PROBE:
+                snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
+                snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
+                break;
+        case HDA_FIXUP_ACT_INIT:
+                alc_process_coef_fw(codec, gb_x570_coefs);
                 break;
         }
@@ -2972 +3036 @@
                 .v.func = alc1220_fixup_gb_dual_codecs,
         },
+        [ALC1220_FIXUP_GB_X570] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc1220_fixup_gb_x570,
+        },
         [ALC1220_FIXUP_CLEVO_P950] = {
                 .type = HDA_FIXUP_FUNC,
@@ -3005 +3073 @@
                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
         },
+#ifdef TARGET_OS2xxx
+        [ALCS1200A_FIXUP_MIC_VREF] = {
+                .type = HDA_FIXUP_PINCTLS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x18, PIN_VREF50 }, /* rear mic */
+                        { 0x19, PIN_VREF50 }, /* front mic */
+                        {}
+                }
+        },
+#endif
 };
 
@@ -3042 +3120 @@
         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
+        SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
@@ -3076 +3155 @@
         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
-        SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_CLEVO_P950),
-        SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_CLEVO_P950),
+        SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
+        SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
+        SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
@@ -3094 +3174 @@
         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
-        SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+        SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
@@ -3149 +3234 @@
         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
+        {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
         {0}
@@ -3697 +3783 @@
         ALC269_TYPE_ALC215,
         ALC269_TYPE_ALC225,
+        ALC269_TYPE_ALC245,
         ALC269_TYPE_ALC287,
         ALC269_TYPE_ALC294,
@@ -3734 +3821 @@
         case ALC269_TYPE_ALC215:
         case ALC269_TYPE_ALC225:
+        case ALC269_TYPE_ALC245:
         case ALC269_TYPE_ALC287:
         case ALC269_TYPE_ALC294:
@@ -3803 +3891 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_write_coef_idx(codec, 0x48, 0x0);
                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
@@ -3831 +3920 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_write_coef_idx(codec, 0x48, 0xd011);
                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
@@ -4184 +4274 @@
          * when booting with headset plugged. So skip setting it for the codec alc257
          */
-        if (codec->core.vendor_id != 0x10ec0257)
+        if (codec->core.vendor_id != 0x10ec0236 &&
+            codec->core.vendor_id != 0x10ec0257)
                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
 
@@ -4262 +4353 @@
         bool hp1_pin_sense, hp2_pin_sense;
 
-        if (spec->codec_variant != ALC269_TYPE_ALC287)
+        if (spec->codec_variant != ALC269_TYPE_ALC287 &&
+                spec->codec_variant != ALC269_TYPE_ALC245)
                 /* required only at boot or S3 and S4 resume time */
 #ifndef TARGET_OS2
@@ -5025 +5117 @@
 {
         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
+}
+
+static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
+                                const struct hda_fixup *fix, int action)
+{
+        struct alc_spec *spec = codec->spec;
+
+        if (action == HDA_FIXUP_ACT_PRE_PROBE)
+                spec->micmute_led_polarity = 1;
+        alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
 }
 
@@ -5501 +5603 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_process_coef_fw(codec, coef0256);
                 break;
@@ -5616 +5719 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_write_coef_idx(codec, 0x45, 0xc489);
                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
@@ -5766 +5870 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
                 alc_write_coef_idx(codec, 0x45, 0xc089);
@@ -5865 +5970 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_process_coef_fw(codec, coef0256);
                 break;
@@ -5979 +6085 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_process_coef_fw(codec, coef0256);
                 break;
@@ -6080 +6187 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
                 alc_write_coef_idx(codec, 0x06, 0x6104);
@@ -6376 +6484 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_process_coef_fw(codec, alc256fw);
                 break;
@@ -6466 +6575 @@
 
         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
-                spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
                 codec->power_save_node = 0; /* avoid click noises */
@@ -6980 +7088 @@
         case 0x10ec0255:
         case 0x10ec0256:
+        case 0x19e58326:
                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
@@ -7110 +7219 @@
 #endif /* NOT_USED */
 
+/* GPIO1 = amplifier on/off
+ * GPIO3 = mic mute LED
+ */
+static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
+                                          const struct hda_fixup *fix, int action)
+{
+        static const hda_nid_t conn[] = { 0x02 };
+
+        struct alc_spec *spec = codec->spec;
+        static const struct hda_pintbl pincfgs[] = {
+                { 0x14, 0x90170110 },  /* front/high speakers */
+                { 0x17, 0x90170130 },  /* back/bass speakers */
+                {0}
+        };
+
+        //enable micmute led
+        alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PRE_PROBE:
+                spec->micmute_led_polarity = 1;
+                /* needed for amp of back speakers */
+                spec->gpio_mask |= 0x01;
+                spec->gpio_dir |= 0x01;
+                snd_hda_apply_pincfgs(codec, pincfgs);
+                /* share DAC to have unified volume control */
+                snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
+                snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
+                break;
+        case HDA_FIXUP_ACT_INIT:
+                /* need to toggle GPIO to enable the amp of back speakers */
+                alc_update_gpio_data(codec, 0x01, true);
+                msleep(100);
+                alc_update_gpio_data(codec, 0x01, false);
+                break;
+        }
+}
+
 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
                                           const struct hda_fixup *fix, int action)
@@ -7138 +7285 @@
 }
 
+/* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
+static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
+                                                  const struct hda_fixup *fix,
+                                                  int action)
+{
+        struct alc_spec *spec = codec->spec;
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PRE_PROBE:
+                spec->gen.suppress_auto_mute = 1;
+                break;
+        }
+}
+
 /* for alc295_fixup_hp_top_speakers */
 #include "hp_x360_helper.c"
@@ -7143 +7304 @@
 /* for alc285_fixup_ideapad_s740_coef() */
 #include "ideapad_s740_helper.c"
+
+static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
+        WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
+        WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
+        WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
+        {0}
+};
+
+static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
+                                           const struct hda_fixup *fix,
+                                           int action)
+{
+        /*
+         * A certain other OS sets these coeffs to different values. On at least
+         * one TongFang barebone these settings might survive even a cold
+         * reboot. So to restore a clean slate the values are explicitly reset
+         * to default here. Without this, the external microphone is always in a
+         * plugged-in state, while the internal microphone is always in an
+         * unplugged state, breaking the ability to use the internal microphone.
+         */
+        alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
+}
+
+static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
+        WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
+        WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
+        WRITE_COEF(0x49, 0x0149),
+        {0}
+};
+
+static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
+                                       const struct hda_fixup *fix,
+                                       int action)
+{
+        /*
+         * The audio jack input and output is not detected on the ASRock NUC Box
+         * 1100 series when cold booting without this fix. Warm rebooting from a
+         * certain other OS makes the audio functional, as COEF settings are
+         * preserved in this case. This fix sets these altered COEF values as
+         * the default.
+         */
+        alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
+}
+
+static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
+                                                    const struct hda_fixup *fix,
+                                                    int action)
+{
+        /*
+         * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
+         * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
+         * needs an additional quirk for sound working after suspend and resume.
+         */
+        if (codec->core.vendor_id == 0x10ec0256) {
+                alc_update_coef_idx(codec, 0x10, 1<<9, 0);
+                snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
+        } else {
+                snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
+        }
+}
 
 enum {
@@ -7230 +7451 @@
         ALC280_FIXUP_HP_9480M,
         ALC245_FIXUP_HP_X360_AMP,
+        ALC285_FIXUP_HP_SPECTRE_X360_EB1,
         ALC288_FIXUP_DELL_HEADSET_MODE,
         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
@@ -7256 +7478 @@
         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
         ALC269_FIXUP_ATIV_BOOK_8,
+        ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
         ALC256_FIXUP_ASUS_HEADSET_MODE,
@@ -7317 +7540 @@
         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
+        ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
@@ -7342 +7566 @@
         ALC287_FIXUP_HP_GPIO_LED,
         ALC256_FIXUP_HP_HEADSET_MIC,
+        ALC245_FIXUP_HP_GPIO_LED,
         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
@@ -7355 +7580 @@
         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
-};
+        ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
+        ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
+        ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
+        ALC298_FIXUP_LENOVO_C940_DUET7,
+        ALC287_FIXUP_13S_GEN2_SPEAKERS,
+        ALC256_FIXUP_SET_COEF_DEFAULTS,
+        ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
+        ALC233_FIXUP_NO_AUDIO_JACK,
+        ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
+        ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
+        ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
+};
+
+#ifdef NOT_USED
+/* A special fixup for Lenovo C940 and Yoga Duet 7;
+ * both have the very same PCI SSID, and we need to apply different fixups
+ * depending on the codec ID
+ */
+static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
+                                           const struct hda_fixup *fix,
+                                           int action)
+{
+        int id;
+
+        if (codec->core.vendor_id == 0x10ec0298)
+                id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
+        else
+                id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
+        __snd_hda_apply_fixup(codec, id, action, 0);
+}
+#endif
 
 #ifdef TARGET_OS2
@@ -8248 +8503 @@
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc245_fixup_hp_x360_amp,
+                .chained = true,
+                .chain_id = ALC245_FIXUP_HP_GPIO_LED
         },
         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
@@ -8449 +8706 @@
         },
 #ifdef TARGET_OS2xxx
+        [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
+                        { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE
+        },
         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
                 .type = HDA_FIXUP_PINS,
@@ -8948 +9215 @@
                 },
         },
+        [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
+                .type = HDA_FIXUP_VERBS,
+                .v.verbs = (const struct hda_verb[]) {
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
+                        { }
+                },
+        },
         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
                 .type = HDA_FIXUP_PINS,
@@ -9227 +9502 @@
                 .v.func = alc285_fixup_hp_spectre_x360,
         },
+        [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc285_fixup_hp_spectre_x360_eb1
+        },
         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
                 .type = HDA_FIXUP_FUNC,
@@ -9255 +9534 @@
                 .chained = true,
                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
+        },
+        [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc285_fixup_ideapad_s740_coef,
+                .chained = true,
+                .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
+        },
+        [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc287_fixup_legion_15imhg05_speakers,
+                .chained = true,
+                .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
+        },
+#ifdef TARGET_OS2xxx
+        [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
+                .type = HDA_FIXUP_VERBS,
+                //.v.verbs = legion_15imhg05_coefs,
+                .v.verbs = (const struct hda_verb[]) {
+                         // set left speaker Legion 7i.
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         // set right speaker Legion 7i.
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+                         {}
+                },
+                .chained = true,
+                .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
+        },
+#endif
+        [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc287_fixup_legion_15imhg05_speakers,
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE,
+        },
+#ifdef TARGET_OS2xxx
+        [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
+                .type = HDA_FIXUP_VERBS,
+                .v.verbs = (const struct hda_verb[]) {
+                         // set left speaker Yoga 7i.
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         // set right speaker Yoga 7i.
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+
+                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+                         {}
+                },
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE,
+        },
+        [ALC298_FIXUP_LENOVO_C940_DUET7] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc298_fixup_lenovo_c940_duet7,
+        },
+        [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
+                .type = HDA_FIXUP_VERBS,
+                .v.verbs = (const struct hda_verb[]) {
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
+                        {}
+                },
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE,
+        },
+#endif
+        [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc256_fixup_set_coef_defaults,
+        },
+#ifdef TARGET_OS2xxx
+        [ALC245_FIXUP_HP_GPIO_LED] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc245_fixup_hp_gpio_led,
+        },
+        [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
+        },
+#endif
+        [ALC233_FIXUP_NO_AUDIO_JACK] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc233_fixup_no_audio_jack,
+        },
+        [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc256_fixup_mic_no_presence_and_resume,
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
         },
 };
@@ -9288 +9723 @@
         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, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
         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, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
         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),
         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
+        SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
@@ -9347 +9785 @@
         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
+        SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
+        SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
@@ -9406 +9848 @@
         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
+        SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
@@ -9422 +9865 @@
         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
+        SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
@@ -9428 +9872 @@
         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
+        SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
@@ -9438 +9884 @@
         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
+        SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
+        SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
@@ -9449 +9897 @@
         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
+        SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
@@ -9462 +9912 @@
         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(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x89c3, "HP", ALC285_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
+        SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
+        SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_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),
@@ -9487 +9945 @@
         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
+        SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
@@ -9502 +9961 @@
         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
+        SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
+        SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
@@ -9534 +9995 @@
         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
+        SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
@@ -9550 +10012 @@
         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
@@ -9555 +10019 @@
         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
@@ -9569 +10035 @@
         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
@@ -9580 +10048 @@
         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
-        SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
@@ -9647 +10118 @@
         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, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
+        SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
+        SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
+        SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
@@ -9669 +10150 @@
         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
+        SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
+        SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
@@ -9680 +10163 @@
         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
+        SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
+        SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
+        SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
+        SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
@@ -9860 +10353 @@
         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
         {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"},
+        {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
@@ -9865 +10359 @@
         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
+        {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
+        {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
         {0}
 };
@@ -10463 +10959 @@
         case 0x10ec0236:
         case 0x10ec0256:
+        case 0x19e58326:
                 spec->codec_variant = ALC269_TYPE_ALC256;
                 spec->shutup = alc256_shutup;
@@ -10478 +10975 @@
         case 0x10ec0285:
         case 0x10ec0289:
-                spec->codec_variant = ALC269_TYPE_ALC215;
+                if (alc_get_coef0(codec) & 0x0010)
+                        spec->codec_variant = ALC269_TYPE_ALC245;
+                else
+                        spec->codec_variant = ALC269_TYPE_ALC215;
                 spec->shutup = alc225_shutup;
                 spec->init_hook = alc225_init;
@@ -11020 +11520 @@
                 alc_write_coef_idx(codec, 0x19, 0xa054);
                 break;
+        }
+}
+
+static void alc897_hp_automute_hook(struct hda_codec *codec,
+                                         struct hda_jack_callback *jack)
+{
+        struct alc_spec *spec = codec->spec;
+        int vref;
+
+        snd_hda_gen_hp_automute(codec, jack);
+        vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
+        snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+                            vref);
+}
+
+static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
+                                     const struct hda_fixup *fix, int action)
+{
+        struct alc_spec *spec = codec->spec;
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+                spec->gen.hp_automute_hook = alc897_hp_automute_hook;
         }
 }
@@ -11100 +11621 @@
         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
+        ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
+        ALC668_FIXUP_HEADSET_MIC,
+        ALC668_FIXUP_MIC_DET_COEF,
+        ALC897_FIXUP_LENOVO_HEADSET_MIC,
+        ALC897_FIXUP_HEADSET_MIC_PIN,
+        ALC897_FIXUP_HP_HSMIC_VERB,
 };
 
@@ -11666 +12193 @@
                 .chained = true,
                 .chain_id = ALC662_FIXUP_USI_FUNC
+        },
+        [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x1b, 0x04a1112c },
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC668_FIXUP_HEADSET_MIC
+        },
+#endif
+        [ALC668_FIXUP_HEADSET_MIC] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc269_fixup_headset_mic,
+                .chained = true,
+                .chain_id = ALC668_FIXUP_MIC_DET_COEF
+        },
+#ifdef TARGET_OS2xxx
+        [ALC668_FIXUP_MIC_DET_COEF] = {
+                .type = HDA_FIXUP_VERBS,
+                .v.verbs = (const struct hda_verb[]) {
+                        { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
+                        { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
+                        {}
+                },
+        },
+#endif
+        [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc897_fixup_lenovo_headset_mic,
+        },
+#ifdef TARGET_OS2xxx
+        [ALC897_FIXUP_HEADSET_MIC_PIN] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x1a, 0x03a11050 },
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
+        },
+        [ALC897_FIXUP_HP_HSMIC_VERB] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
+                        { }
+                },
         },
 #endif
@@ -11693 +12267 @@
         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
+        SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
+        SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
+        SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
@@ -11703 +12280 @@
         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
+        SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
@@ -11711 +12289 @@
         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
+        SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
+        SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
+        SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
+        SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
+        SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
@@ -12069 +12652 @@
         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
+        HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
         {0} /* terminator */
 };

GPL/trunk/alsa-kernel/pci/hda/patch_sigmatel.c

@@ -4482 +4482 @@
 }
 
-static void stac_shutup(struct hda_codec *codec)
-{
-        struct sigmatel_spec *spec = codec->spec;
-
-        snd_hda_shutup_pins(codec);
-
-        if (spec->eapd_mask)
-                stac_gpio_set(codec, spec->gpio_mask,
-                                spec->gpio_dir, spec->gpio_data &
-                                ~spec->eapd_mask);
-}
-
 #define stac_free       snd_hda_gen_free
 
@@ -4546 +4534 @@
 static int stac_suspend(struct hda_codec *codec)
 {
-        stac_shutup(codec);
+        struct sigmatel_spec *spec = codec->spec;
+
+        snd_hda_shutup_pins(codec);
+
+        if (spec->eapd_mask)
+                stac_gpio_set(codec, spec->gpio_mask,
+                                spec->gpio_dir, spec->gpio_data &
+                                ~spec->eapd_mask);
+
         return 0;
 }
@@ -4562 +4558 @@
         .suspend = stac_suspend,
 #endif
-        .reboot_notify = stac_shutup,
 };
 

GPL/trunk/alsa-kernel/pci/hda/patch_via.c

@@ -529 +529 @@
                 return err;
 
+        err = auto_parse_beep(codec);
+        if (err < 0)
+                return err;
+
         err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
-        if (err < 0)
-                return err;
-
-        err = auto_parse_beep(codec);
         if (err < 0)
                 return err;