Changeset 756

Timestamp:

Dec 17, 2022, 8:47:17 AM (3 years ago)

Author:

Paul Smedley

Message:

Update source to linux 6.1

Location:

GPL/branches/uniaud32-exp

Files:

• alsa-kernel/core/memalloc.c (modified) (1 diff)
• alsa-kernel/core/memalloc_local.h (modified) (1 diff)
• alsa-kernel/core/oss/pcm_oss.c (modified) (12 diffs)
• alsa-kernel/core/pcm.c (modified) (4 diffs)
• alsa-kernel/core/pcm_lib.c (modified) (8 diffs)
• alsa-kernel/core/pcm_native.c (modified) (47 diffs)
• alsa-kernel/core/seq/seq_memory.c (modified) (3 diffs)
• alsa-kernel/hda/ext/hdac_ext_bus.c (modified) (1 diff)
• alsa-kernel/hda/ext/hdac_ext_controller.c (modified) (7 diffs)
• alsa-kernel/hda/ext/hdac_ext_stream.c (modified) (8 diffs)
• alsa-kernel/hda/hdac_stream.c (modified) (10 diffs)
• alsa-kernel/hda/hdmi_chmap.c (modified) (1 diff)
• alsa-kernel/include/sound/hda_codec.h (modified) (2 diffs)
• alsa-kernel/include/sound/hda_register.h (modified) (2 diffs)
• alsa-kernel/include/sound/hdaudio.h (modified) (4 diffs)
• alsa-kernel/include/sound/hdaudio_ext.h (modified) (3 diffs)
• alsa-kernel/include/sound/intel-nhlt.h (modified) (2 diffs)
• alsa-kernel/include/sound/memalloc.h (modified) (1 diff)
• alsa-kernel/include/sound/pcm.h (modified) (2 diffs)
• alsa-kernel/include/sound/simple_card_utils.h (modified) (2 diffs)
• alsa-kernel/include/sound/soc-acpi-intel-match.h (modified) (1 diff)
• alsa-kernel/include/sound/soc.h (modified) (10 diffs)
• alsa-kernel/include/sound/sof.h (modified) (2 diffs)
• alsa-kernel/include/sound/version.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/asequencer.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/asoc.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/asound.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/asound_fm.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/compress_offload.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/compress_params.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/emu10k1.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/tlv.h (modified) (1 diff)
• alsa-kernel/pci/hda/hda_codec.c (modified) (3 diffs)
• alsa-kernel/pci/hda/hda_controller.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_eld.c (modified) (2 diffs)
• alsa-kernel/pci/hda/hda_intel.c (modified) (8 diffs)
• alsa-kernel/pci/hda/hda_local.h (modified) (1 diff)
• alsa-kernel/pci/hda/hda_sysfs.c (modified) (1 diff)
• alsa-kernel/pci/hda/patch_ca0132.c (modified) (3 diffs)
• alsa-kernel/pci/hda/patch_hdmi.c (modified) (24 diffs)
• alsa-kernel/pci/hda/patch_realtek.c (modified) (16 diffs)
• include/linux/iopoll.h (added)

GPL/branches/uniaud32-exp/alsa-kernel/core/memalloc.c

@@ -13 +13 @@
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>
+#ifndef TARGET_OS2
+#include <linux/dma-map-ops.h>
+#endif
 #include <linux/genalloc.h>
 #include <linux/highmem.h>

GPL/branches/uniaud32-exp/alsa-kernel/core/memalloc_local.h

@@ -14 +14 @@
 };
 
-#ifdef CONFIG_SND_DMA_SGBUF
-extern const struct snd_malloc_ops snd_dma_sg_ops;
-#endif
-
 #endif /* __MEMALLOC_LOCAL_H */

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

@@ -1251 +1251 @@
         int ret;
         while (1) {
-                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
-                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
+                if (runtime->state == SNDRV_PCM_STATE_XRUN ||
+                    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm,
                                 "pcm_oss: write: recovering from %s\n",
-                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                runtime->state == SNDRV_PCM_STATE_XRUN ?
                                 "XRUN" : "SUSPEND");
 #endif
@@ -1271 +1271 @@
                 /* test, if we can't store new data, because the stream */
                 /* has not been started */
-                if (runtime->status->state == SNDRV_PCM_STATE_PREPARED)
+                if (runtime->state == SNDRV_PCM_STATE_PREPARED)
                         return -EAGAIN;
         }
@@ -1283 +1283 @@
         int ret;
         while (1) {
-                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
-                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
+                if (runtime->state == SNDRV_PCM_STATE_XRUN ||
+                    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm,
                                 "pcm_oss: read: recovering from %s\n",
-                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                runtime->state == SNDRV_PCM_STATE_XRUN ?
                                 "XRUN" : "SUSPEND");
 #endif
@@ -1294 +1294 @@
                         if (ret < 0)
                                 break;
-                } else if (runtime->status->state == SNDRV_PCM_STATE_SETUP) {
+                } else if (runtime->state == SNDRV_PCM_STATE_SETUP) {
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1307 +1307 @@
                 mutex_lock(&runtime->oss.params_lock);
                 if (ret == -EPIPE) {
-                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                        if (runtime->state == SNDRV_PCM_STATE_DRAINING) {
                                 ret = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
                                 if (ret < 0)
@@ -1326 +1326 @@
         int ret;
         while (1) {
-                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
-                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
+                if (runtime->state == SNDRV_PCM_STATE_XRUN ||
+                    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm,
                                 "pcm_oss: writev: recovering from %s\n",
-                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                runtime->state == SNDRV_PCM_STATE_XRUN ?
                                 "XRUN" : "SUSPEND");
 #endif
@@ -1344 +1344 @@
                 /* test, if we can't store new data, because the stream */
                 /* has not been started */
-                if (runtime->status->state == SNDRV_PCM_STATE_PREPARED)
+                if (runtime->state == SNDRV_PCM_STATE_PREPARED)
                         return -EAGAIN;
         }
@@ -1355 +1355 @@
         int ret;
         while (1) {
-                if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
-                    runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
+                if (runtime->state == SNDRV_PCM_STATE_XRUN ||
+                    runtime->state == SNDRV_PCM_STATE_SUSPENDED) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm,
                                 "pcm_oss: readv: recovering from %s\n",
-                                runtime->status->state == SNDRV_PCM_STATE_XRUN ?
+                                runtime->state == SNDRV_PCM_STATE_XRUN ?
                                 "XRUN" : "SUSPEND");
 #endif
@@ -1366 +1366 @@
                         if (ret < 0)
                                 break;
-                } else if (runtime->status->state == SNDRV_PCM_STATE_SETUP) {
+                } else if (runtime->state == SNDRV_PCM_STATE_SETUP) {
                         ret = snd_pcm_oss_prepare(substream);
                         if (ret < 0)
@@ -1649 +1649 @@
                 set_current_state(TASK_INTERRUPTIBLE);
                 snd_pcm_stream_lock_irq(substream);
-                state = runtime->status->state;
+                state = runtime->state;
                 snd_pcm_stream_unlock_irq(substream);
                 if (state != SNDRV_PCM_STATE_RUNNING) {
@@ -2868 +2868 @@
                 poll_wait(file, &runtime->sleep, wait);
                 snd_pcm_stream_lock_irq(psubstream);
-                if (runtime->status->state != SNDRV_PCM_STATE_DRAINING &&
-                    (runtime->status->state != SNDRV_PCM_STATE_RUNNING ||
+                if (runtime->state != SNDRV_PCM_STATE_DRAINING &&
+                    (runtime->state != SNDRV_PCM_STATE_RUNNING ||
                      snd_pcm_oss_playback_ready(psubstream)))
                         mask |= EPOLLOUT | EPOLLWRNORM;
@@ -2879 +2879 @@
                 poll_wait(file, &runtime->sleep, wait);
                 snd_pcm_stream_lock_irq(csubstream);
-                ostate = runtime->status->state;
+                ostate = runtime->state;
                 if (ostate != SNDRV_PCM_STATE_RUNNING ||
                     snd_pcm_oss_capture_ready(csubstream))

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm.c

@@ -391 +391 @@
                 goto unlock;
         }
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
                 goto unlock;
@@ -428 +428 @@
                 goto unlock;
         }
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
                 goto unlock;
@@ -978 +978 @@
         init_waitqueue_head(&runtime->tsleep);
 
-        runtime->status->state = SNDRV_PCM_STATE_OPEN;
+        __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_OPEN);
         mutex_init(&runtime->buffer_mutex);
         atomic_set(&runtime->buffer_accessing, 0);
@@ -1122 +1122 @@
                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
                         /* to be sure, set the state unconditionally */
-                        substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
+                        __snd_pcm_set_state(substream->runtime,
+                                            SNDRV_PCM_STATE_DISCONNECTED);
                         wake_up(&substream->runtime->sleep);
                         wake_up(&substream->runtime->tsleep);

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_lib.c

@@ -212 +212 @@
         if (avail > runtime->avail_max)
                 runtime->avail_max = avail;
-        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+        if (runtime->state == SNDRV_PCM_STATE_DRAINING) {
                 if (avail >= runtime->buffer_size) {
                         snd_pcm_drain_done(substream);
@@ -1948 +1948 @@
                 snd_pcm_stream_lock_irq(substream);
                 set_current_state(TASK_INTERRUPTIBLE);
-                switch (runtime->status->state) {
+                switch (runtime->state) {
                 case SNDRV_PCM_STATE_SUSPENDED:
                         err = -ESTRPIPE;
@@ -2136 +2136 @@
         if (snd_BUG_ON(!substream->ops->copy_user && !runtime->dma_area))
                 return -EINVAL;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         return 0;
@@ -2143 +2143 @@
 static int pcm_accessible_state(struct snd_pcm_runtime *runtime)
 {
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_PREPARED:
         case SNDRV_PCM_STATE_RUNNING:
@@ -2266 +2266 @@
         runtime->twake = runtime->control->avail_min ? runtime->control->avail_min : 1;
 #endif
-        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+        if (runtime->state == SNDRV_PCM_STATE_RUNNING)
                 snd_pcm_update_hw_ptr(substream);
 
@@ -2274 +2274 @@
          */
         if (!is_playback &&
-            runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
+            runtime->state == SNDRV_PCM_STATE_PREPARED &&
             size >= runtime->start_threshold) {
                 err = snd_pcm_start(substream);
@@ -2288 +2288 @@
                 if (!avail) {
                         if (!is_playback &&
-                            runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                            runtime->state == SNDRV_PCM_STATE_DRAINING) {
                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
                                 goto _end_unlock;
@@ -2361 +2361 @@
                 avail -= frames;
                 if (is_playback &&
-                    runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
+                    runtime->state == SNDRV_PCM_STATE_PREPARED &&
                     snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
                         err = snd_pcm_start(substream);

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_native.c

@@ -600 +600 @@
 {
         snd_pcm_stream_lock_irq(substream);
-        if (substream->runtime->status->state != SNDRV_PCM_STATE_DISCONNECTED)
-                substream->runtime->status->state = state;
+        if (substream->runtime->state != SNDRV_PCM_STATE_DISCONNECTED)
+                __snd_pcm_set_state(substream->runtime, state);
         snd_pcm_stream_unlock_irq(substream);
 }
@@ -731 +731 @@
                 return err;
         snd_pcm_stream_lock_irq(substream);
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_OPEN:
         case SNDRV_PCM_STATE_SETUP:
@@ -896 +896 @@
                 return result;
         snd_pcm_stream_lock_irq(substream);
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_SETUP:
         case SNDRV_PCM_STATE_PREPARED:
@@ -927 +927 @@
         runtime = substream->runtime;
         snd_pcm_stream_lock_irq(substream);
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_pcm_stream_unlock_irq(substream);
                 return -EBADFD;
@@ -1020 +1020 @@
                 runtime->audio_tstamp_report.valid = 1;
 
-        status->state = runtime->status->state;
-        status->suspended_state = runtime->status->suspended_state;
+        status->state = runtime->state;
+        status->suspended_state = runtime->suspended_state;
         if (status->state == SNDRV_PCM_STATE_OPEN)
                 goto _end;
@@ -1176 +1176 @@
         runtime = substream->runtime;
         snd_pcm_stream_lock_irq(substream);
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_pcm_stream_unlock_irq(substream);
                 return -EBADFD;
@@ -1439 +1439 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        if (runtime->status->state != SNDRV_PCM_STATE_PREPARED)
+        if (runtime->state != SNDRV_PCM_STATE_PREPARED)
                 return -EBADFD;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
@@ -1472 +1472 @@
         runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) /
                                                             runtime->rate;
-        runtime->status->state = state;
+        __snd_pcm_set_state(runtime, state);
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
@@ -1513 +1513 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         runtime->trigger_master = substream;
@@ -1534 +1534 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        if (runtime->status->state != state) {
+        if (runtime->state != state) {
                 snd_pcm_trigger_tstamp(substream);
-                runtime->status->state = state;
+                __snd_pcm_set_state(runtime, state);
                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSTOP);
         }
@@ -1612 +1612 @@
                 return -ENOSYS;
         if (pause_pushed(state)) {
-                if (runtime->status->state != SNDRV_PCM_STATE_RUNNING)
+                if (runtime->state != SNDRV_PCM_STATE_RUNNING)
                         return -EBADFD;
-        } else if (runtime->status->state != SNDRV_PCM_STATE_PAUSED)
+        } else if (runtime->state != SNDRV_PCM_STATE_PAUSED)
                 return -EBADFD;
         runtime->trigger_master = substream;
@@ -1656 +1656 @@
         snd_pcm_trigger_tstamp(substream);
         if (pause_pushed(state)) {
-                runtime->status->state = SNDRV_PCM_STATE_PAUSED;
+                __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_PAUSED);
                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MPAUSE);
                 wake_up(&runtime->sleep);
                 wake_up(&runtime->tsleep);
         } else {
-                runtime->status->state = SNDRV_PCM_STATE_RUNNING;
+                __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_RUNNING);
                 snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MCONTINUE);
         }
@@ -1696 +1696 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_SUSPENDED:
                 return -EBUSY;
@@ -1727 +1727 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_trigger_tstamp(substream);
-        runtime->status->suspended_state = runtime->status->state;
-        runtime->status->state = SNDRV_PCM_STATE_SUSPENDED;
+        runtime->suspended_state = runtime->state;
+        runtime->status->suspended_state = runtime->suspended_state;
+        __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SUSPENDED);
         snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MSUSPEND);
         wake_up(&runtime->sleep);
@@ -1819 +1820 @@
                 return 0;
         /* DMA not running previously? */
-        if (runtime->status->suspended_state != SNDRV_PCM_STATE_RUNNING &&
-            (runtime->status->suspended_state != SNDRV_PCM_STATE_DRAINING ||
+        if (runtime->suspended_state != SNDRV_PCM_STATE_RUNNING &&
+            (runtime->suspended_state != SNDRV_PCM_STATE_DRAINING ||
              substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
                 return 0;
@@ -1839 +1840 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_trigger_tstamp(substream);
-        runtime->status->state = runtime->status->suspended_state;
+        __snd_pcm_set_state(runtime, runtime->suspended_state);
         snd_pcm_timer_notify(substream, SNDRV_TIMER_EVENT_MRESUME);
 }
@@ -1876 +1877 @@
 
         snd_pcm_stream_lock_irq(substream);
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_XRUN:
                 result = 0;     /* already there */
@@ -1899 +1900 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_RUNNING:
         case SNDRV_PCM_STATE_PREPARED:
@@ -1961 +1962 @@
         int f_flags = (__force int)state;
 
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         if (snd_pcm_running(substream))
@@ -2013 +2014 @@
 
         snd_pcm_stream_lock_irq(substream);
-        switch (substream->runtime->status->state) {
+        switch (substream->runtime->state) {
         case SNDRV_PCM_STATE_PAUSED:
                 snd_pcm_pause(substream, false);
@@ -2037 +2038 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_OPEN:
         case SNDRV_PCM_STATE_DISCONNECTED:
@@ -2052 +2053 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                switch (runtime->status->state) {
+                switch (runtime->state) {
                 case SNDRV_PCM_STATE_PREPARED:
                         /* start playback stream if possible */
@@ -2059 +2060 @@
                                 snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
                         } else {
-                                runtime->status->state = SNDRV_PCM_STATE_SETUP;
+                                __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SETUP);
                         }
                         break;
                 case SNDRV_PCM_STATE_RUNNING:
-                        runtime->status->state = SNDRV_PCM_STATE_DRAINING;
+                        __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_DRAINING);
                         break;
                 case SNDRV_PCM_STATE_XRUN:
-                        runtime->status->state = SNDRV_PCM_STATE_SETUP;
+                        __snd_pcm_set_state(runtime, SNDRV_PCM_STATE_SETUP);
                         break;
                 default:
@@ -2073 +2074 @@
         } else {
                 /* stop running stream */
-                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING) {
+                if (runtime->state == SNDRV_PCM_STATE_RUNNING) {
                         snd_pcm_state_t new_state;
 
@@ -2083 +2084 @@
         }
 
-        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
+        if (runtime->state == SNDRV_PCM_STATE_DRAINING &&
             runtime->trigger_master == substream &&
             (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER))
@@ -2124 +2125 @@
         runtime = substream->runtime;
 
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
 
@@ -2135 +2136 @@
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
-        if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
+        if (runtime->state == SNDRV_PCM_STATE_PAUSED)
                 snd_pcm_pause(substream, false);
 
@@ -2163 +2164 @@
                                 continue;
                         runtime = s->runtime;
-                        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
+                        if (runtime->state == SNDRV_PCM_STATE_DRAINING) {
                                 to_check = runtime;
                                 break;
@@ -2202 +2203 @@
                 }
                 if (tout == 0) {
-                        if (substream->runtime->status->state == SNDRV_PCM_STATE_SUSPENDED)
+                        if (substream->runtime->state == SNDRV_PCM_STATE_SUSPENDED)
                                 result = -ESTRPIPE;
                         else {
@@ -2234 +2235 @@
         runtime = substream->runtime;
 
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
 
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
-        if (runtime->status->state == SNDRV_PCM_STATE_PAUSED)
+        if (runtime->state == SNDRV_PCM_STATE_PAUSED)
                 snd_pcm_pause(substream, false);
 
@@ -2308 +2309 @@
 
         down_write(&snd_pcm_link_rwsem);
-        if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            substream->runtime->status->state != substream1->runtime->status->state ||
+        if (substream->runtime->state == SNDRV_PCM_STATE_OPEN ||
+            substream->runtime->state != substream1->runtime->state ||
             substream->pcm->nonatomic != substream1->pcm->nonatomic) {
                 res = -EBADFD;
@@ -2738 +2739 @@
         snd_pcm_drop(substream);
         if (substream->hw_opened) {
-                if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
+                if (substream->runtime->state != SNDRV_PCM_STATE_OPEN)
                         do_hw_free(substream);
                 substream->ops->close(substream);
@@ -2942 +2943 @@
 static int do_pcm_hwsync(struct snd_pcm_substream *substream)
 {
-        switch (substream->runtime->status->state) {
+        switch (substream->runtime->state) {
         case SNDRV_PCM_STATE_DRAINING:
                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
@@ -3258 +3259 @@
         snd_pcm_sframes_t result;
 
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         if (put_user(0, &_xferi->result))
@@ -3281 +3282 @@
         snd_pcm_sframes_t result;
 
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         if (runtime->channels > 128)
@@ -3345 +3346 @@
                 return -ENXIO;
 
-        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
 
@@ -3476 +3477 @@
         snd_pcm_sframes_t result;
         
-        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
 
@@ -3521 +3522 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         if (!frame_aligned(runtime, count))
@@ -3546 +3547 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         if (!frame_aligned(runtime, count))
@@ -3577 +3578 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         if (!iter_is_iovec(to))
@@ -3614 +3615 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN ||
-            runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN ||
+            runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         if (!iter_is_iovec(from))
@@ -3654 +3655 @@
 
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return ok | EPOLLERR;
 
@@ -3662 +3663 @@
         snd_pcm_stream_lock_irq(substream);
         avail = snd_pcm_avail(substream);
-        switch (runtime->status->state) {
+        switch (runtime->state) {
         case SNDRV_PCM_STATE_RUNNING:
         case SNDRV_PCM_STATE_PREPARED:
@@ -3728 +3729 @@
         area->vm_private_data = substream;
         area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        area->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
         return 0;
 }
@@ -3935 +3937 @@
         }
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
+        if (runtime->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
@@ -3972 +3974 @@
         if (PCM_RUNTIME_CHECK(substream))
                 return -ENXIO;
-        if (substream->runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (substream->runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
 
@@ -4011 +4013 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        if (runtime->status->state == SNDRV_PCM_STATE_DISCONNECTED)
+        if (runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
         return snd_fasync_helper(fd, file, on, &runtime->fasync);

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_memory.c

@@ -114 +114 @@
  */
 
-static int seq_copy_in_kernel(char **bufptr, const void *src, int size)
-{
+static int seq_copy_in_kernel(void *ptr, void *src, int size)
+{
+        char **bufptr = ptr;
+
         memcpy(*bufptr, src, size);
         *bufptr += size;
@@ -121 +123 @@
 }
 
-static int seq_copy_in_user(char __user **bufptr, const void *src, int size)
-{
+static int seq_copy_in_user(void *ptr, void *src, int size)
+{
+        char __user **bufptr = ptr;
+
         if (copy_to_user(*bufptr, src, size))
                 return -EFAULT;
@@ -152 +156 @@
         }
         err = snd_seq_dump_var_event(event,
-                                     in_kernel ? (snd_seq_dump_func_t)seq_copy_in_kernel :
-                                     (snd_seq_dump_func_t)seq_copy_in_user,
+                                     in_kernel ? seq_copy_in_kernel : seq_copy_in_user,
                                      &buf);
         return err < 0 ? err : newlen;

GPL/branches/uniaud32-exp/alsa-kernel/hda/ext/hdac_ext_bus.c

@@ -60 +60 @@
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_exit);
-
-static void default_release(struct device *dev)
-{
-        snd_hdac_ext_bus_device_exit(dev_to_hdac_dev(dev));
-}
-
-/**
- * snd_hdac_ext_bus_device_init - initialize the HDA extended codec base device
- * @bus: hdac bus to attach to
- * @addr: codec address
- * @hdev: hdac device to init
- * @type: codec type (HDAC_DEV_*) to use for this device
- *
- * Returns zero for success or a negative error code.
- */
-int snd_hdac_ext_bus_device_init(struct hdac_bus *bus, int addr,
-                                 struct hdac_device *hdev, int type)
-{
-        char name[15];
-        int ret;
-
-        hdev->bus = bus;
-
-        snprintf(name, sizeof(name), "ehdaudio%dD%d", bus->idx, addr);
-
-        ret  = snd_hdac_device_init(hdev, bus, name, addr);
-        if (ret < 0) {
-                dev_err(bus->dev, "device init failed for hdac device\n");
-                return ret;
-        }
-        hdev->type = type;
-        hdev->dev.release = default_release;
-
-        ret = snd_hdac_device_register(hdev);
-        if (ret) {
-                dev_err(bus->dev, "failed to register hdac device\n");
-                snd_hdac_ext_bus_device_exit(hdev);
-                return ret;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_device_init);
-
-/**
- * snd_hdac_ext_bus_device_exit - clean up a HD-audio extended codec base device
- * @hdev: hdac device to clean up
- */
-void snd_hdac_ext_bus_device_exit(struct hdac_device *hdev)
-{
-        snd_hdac_device_exit(hdev);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_device_exit);
 
 /**

GPL/branches/uniaud32-exp/alsa-kernel/hda/ext/hdac_ext_controller.c

@@ -171 +171 @@
         int timeout;
         u32 val;
-        int mask = (1 << AZX_MLCTL_CPA_SHIFT);
+        int mask = (1 << AZX_ML_LCTL_CPA_SHIFT);
 
         udelay(3);
@@ -179 +179 @@
                 val = readl(link->ml_addr + AZX_REG_ML_LCTL);
                 if (enable) {
-                        if (((val & mask) >> AZX_MLCTL_CPA_SHIFT))
+                        if (((val & mask) >> AZX_ML_LCTL_CPA_SHIFT))
                                 return 0;
                 } else {
-                        if (!((val & mask) >> AZX_MLCTL_CPA_SHIFT))
+                        if (!((val & mask) >> AZX_ML_LCTL_CPA_SHIFT))
                                 return 0;
                 }
@@ -198 +198 @@
 {
         snd_hdac_updatel(link->ml_addr, AZX_REG_ML_LCTL,
-                         AZX_MLCTL_SPA, AZX_MLCTL_SPA);
+                         AZX_ML_LCTL_SPA, AZX_ML_LCTL_SPA);
 
         return check_hdac_link_power_active(link, true);
@@ -210 +210 @@
 int snd_hdac_ext_bus_link_power_down(struct hdac_ext_link *link)
 {
-        snd_hdac_updatel(link->ml_addr, AZX_REG_ML_LCTL, AZX_MLCTL_SPA, 0);
+        snd_hdac_updatel(link->ml_addr, AZX_REG_ML_LCTL, AZX_ML_LCTL_SPA, 0);
 
         return check_hdac_link_power_active(link, false);
@@ -227 +227 @@
         list_for_each_entry(hlink, &bus->hlink_list, list) {
                 snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL,
-                                 AZX_MLCTL_SPA, AZX_MLCTL_SPA);
+                                 AZX_ML_LCTL_SPA, AZX_ML_LCTL_SPA);
                 ret = check_hdac_link_power_active(hlink, true);
                 if (ret < 0)
@@ -248 +248 @@
         list_for_each_entry(hlink, &bus->hlink_list, list) {
                 snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL,
-                                 AZX_MLCTL_SPA, 0);
+                                 AZX_ML_LCTL_SPA, 0);
                 ret = check_hdac_link_power_active(hlink, false);
                 if (ret < 0)
@@ -282 +282 @@
                  */
                 snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV,
-                                 ML_LOSIDV_STREAM_MASK, 0);
+                                 AZX_ML_LOSIDV_STREAM_MASK, 0);
                 /*
                  *  wait for 521usec for codec to report status

GPL/branches/uniaud32-exp/alsa-kernel/hda/ext/hdac_ext_stream.c

@@ -27 +27 @@
  * invoke hdac stream initialization routine
  */
-void snd_hdac_ext_stream_init(struct hdac_bus *bus,
-                              struct hdac_ext_stream *hext_stream,
-                              int idx, int direction, int tag)
+static void snd_hdac_ext_stream_init(struct hdac_bus *bus,
+                                     struct hdac_ext_stream *hext_stream,
+                                     int idx, int direction, int tag)
 {
         if (bus->ppcap) {
@@ -57 +57 @@
         snd_hdac_stream_init(bus, &hext_stream->hstream, idx, direction, tag);
 }
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init);
 
 /**
@@ -89 +88 @@
 
 /**
- * snd_hdac_stream_free_all - free hdac extended stream objects
- *
- * @bus: HD-audio core bus
- */
-void snd_hdac_stream_free_all(struct hdac_bus *bus)
+ * snd_hdac_ext_stream_free_all - free hdac extended stream objects
+ *
+ * @bus: HD-audio core bus
+ */
+void snd_hdac_ext_stream_free_all(struct hdac_bus *bus)
 {
         struct hdac_stream *s, *_s;
@@ -105 +104 @@
         }
 }
-EXPORT_SYMBOL_GPL(snd_hdac_stream_free_all);
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_free_all);
 
 void snd_hdac_ext_stream_decouple_locked(struct hdac_bus *bus,
@@ -269 +268 @@
                         continue;
 
-                /* check if decoupled stream and not in use is available */
-                if (hext_stream->decoupled && !hext_stream->link_locked) {
+                /* check if link stream is available */
+                if (!hext_stream->link_locked) {
                         res = hext_stream;
                         break;
                 }
 
-                if (!hext_stream->link_locked) {
-                        snd_hdac_ext_stream_decouple_locked(bus, hext_stream, true);
-                        res = hext_stream;
-                        break;
-                }
         }
         if (res) {
+                snd_hdac_ext_stream_decouple_locked(bus, res, true);
                 res->link_locked = 1;
                 res->link_substream = substream;
@@ -310 +305 @@
 
                 if (!hstream->opened) {
-                        if (!hext_stream->decoupled)
-                                snd_hdac_ext_stream_decouple_locked(bus, hext_stream, true);
                         res = hext_stream;
                         break;
@@ -317 +310 @@
         }
         if (res) {
+                snd_hdac_ext_stream_decouple_locked(bus, res, true);
                 res->hstream.opened = 1;
                 res->hstream.running = 0;
@@ -389 +383 @@
         case HDAC_EXT_STREAM_TYPE_HOST:
                 spin_lock_irq(&bus->reg_lock);
-                if (hext_stream->decoupled && !hext_stream->link_locked)
+                /* couple link only if not in use */
+                if (!hext_stream->link_locked)
                         snd_hdac_ext_stream_decouple_locked(bus, hext_stream, false);
+                snd_hdac_stream_release_locked(&hext_stream->hstream);
                 spin_unlock_irq(&bus->reg_lock);
-                snd_hdac_stream_release(&hext_stream->hstream);
                 break;
 
         case HDAC_EXT_STREAM_TYPE_LINK:
                 spin_lock_irq(&bus->reg_lock);
-                if (hext_stream->decoupled && !hext_stream->hstream.opened)
+                /* couple host only if not in use */
+                if (!hext_stream->hstream.opened)
                         snd_hdac_ext_stream_decouple_locked(bus, hext_stream, false);
                 hext_stream->link_locked = 0;

GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_stream.c

@@ -19 +19 @@
 #endif
 
+/*
+ * the hdac_stream library is intended to be used with the following
+ * transitions. The states are not formally defined in the code but loosely
+ * inspired by boolean variables. Note that the 'prepared' field is not used
+ * in this library but by the callers during the hw_params/prepare transitions
+ *
+ *                         |
+ *      stream_init()      |
+ *                         v
+ *                      +--+-------+
+ *                      |  unused  |
+ *                      +--+----+--+
+ *                         |    ^
+ *      stream_assign()    |    |    stream_release()
+ *                         v    |
+ *                      +--+----+--+
+ *                      |  opened  |
+ *                      +--+----+--+
+ *                         |    ^
+ *      stream_reset()     |    |
+ *      stream_setup()     |    |    stream_cleanup()
+ *                         v    |
+ *                      +--+----+--+
+ *                      | prepared |
+ *                      +--+----+--+
+ *                         |    ^
+ *      stream_start()     |    |    stream_stop()
+ *                         v    |
+ *                      +--+----+--+
+ *                      |  running |
+ *                      +----------+
+ */
+
 /**
  * snd_hdac_get_stream_stripe_ctl - get stripe control value
@@ -118 +151 @@
 
 /**
- * snd_hdac_stream_clear - stop a stream DMA
+ * snd_hdac_stream_clear - helper to clear stream registers and stop DMA transfers
  * @azx_dev: HD-audio core stream to stop
  */
-void snd_hdac_stream_clear(struct hdac_stream *azx_dev)
+static void snd_hdac_stream_clear(struct hdac_stream *azx_dev)
 {
         snd_hdac_stream_updateb(azx_dev, SD_CTL,
@@ -130 +163 @@
         azx_dev->running = false;
 }
-EXPORT_SYMBOL_GPL(snd_hdac_stream_clear);
 
 /**
@@ -149 +181 @@
 
 /**
+ * snd_hdac_stop_streams - stop all streams
+ * @bus: HD-audio core bus
+ */
+void snd_hdac_stop_streams(struct hdac_bus *bus)
+{
+        struct hdac_stream *stream;
+
+        list_for_each_entry(stream, &bus->stream_list, list, struct hdac_stream)
+                snd_hdac_stream_stop(stream);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stop_streams);
+
+/**
  * snd_hdac_stop_streams_and_chip - stop all streams and chip if running
  * @bus: HD-audio core bus
@@ -154 +199 @@
 void snd_hdac_stop_streams_and_chip(struct hdac_bus *bus)
 {
-        struct hdac_stream *stream;
-
         if (bus->chip_init) {
-                list_for_each_entry(stream, &bus->stream_list, list, struct hdac_stream)
-                        snd_hdac_stream_stop(stream);
+                snd_hdac_stop_streams(bus);
                 snd_hdac_bus_stop_chip(bus);
         }
@@ -171 +213 @@
 {
         unsigned char val;
+#ifdef TARGET_OS2
         int timeout;
+#endif
         int dma_run_state;
 
@@ -179 +223 @@
 
         snd_hdac_stream_updateb(azx_dev, SD_CTL, 0, SD_CTL_STREAM_RESET);
+
+#ifndef TARGET_OS2
+        /* wait for hardware to report that the stream entered reset */
+        snd_hdac_stream_readb_poll(azx_dev, SD_CTL, val, (val & SD_CTL_STREAM_RESET), 3, 300);
+#else
         udelay(3);
         timeout = 300;
@@ -187 +236 @@
                         break;
         } while (--timeout);
-
+#endif
         if (azx_dev->bus->dma_stop_delay && dma_run_state)
                 udelay(azx_dev->bus->dma_stop_delay);
 
-        val &= ~SD_CTL_STREAM_RESET;
-        snd_hdac_stream_writeb(azx_dev, SD_CTL, val);
+        snd_hdac_stream_updateb(azx_dev, SD_CTL, SD_CTL_STREAM_RESET, 0);
+
+#ifndef TARGET_OS2
+        /* wait for hardware to report that the stream is out of reset */
+        snd_hdac_stream_readb_poll(azx_dev, SD_CTL, val, !(val & SD_CTL_STREAM_RESET), 3, 300);
+#else
         udelay(3);
 
@@ -203 +256 @@
                         break;
         } while (--timeout);
-
+#endif
         /* reset first position - may not be synced with hw at this time */
         if (azx_dev->posbuf)
@@ -343 +396 @@
 
 /**
- * snd_hdac_stream_release - release the assigned stream
+ * snd_hdac_stream_release_locked - release the assigned stream
  * @azx_dev: HD-audio core stream to release
  *
  * Release the stream that has been assigned by snd_hdac_stream_assign().
- */
-void snd_hdac_stream_release(struct hdac_stream *azx_dev)
-{
-        struct hdac_bus *bus = azx_dev->bus;
-
-        spin_lock_irq(&bus->reg_lock);
+ * The bus->reg_lock needs to be taken at a higher level
+ */
+void snd_hdac_stream_release_locked(struct hdac_stream *azx_dev)
+{
         azx_dev->opened = 0;
         azx_dev->running = 0;
         azx_dev->substream = NULL;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_release_locked);
+
+/**
+ * snd_hdac_stream_release - release the assigned stream
+ * @azx_dev: HD-audio core stream to release
+ *
+ * Release the stream that has been assigned by snd_hdac_stream_assign().
+ */
+void snd_hdac_stream_release(struct hdac_stream *azx_dev)
+{
+        struct hdac_bus *bus = azx_dev->bus;
+
+        spin_lock_irq(&bus->reg_lock);
+        snd_hdac_stream_release_locked(azx_dev);
         spin_unlock_irq(&bus->reg_lock);
 }

GPL/branches/uniaud32-exp/alsa-kernel/hda/hdmi_chmap.c

@@ -782 +782 @@
         if (!substream || !substream->runtime)
                 return 0; /* just for avoiding error from alsactl restore */
-        switch (substream->runtime->status->state) {
+        switch (substream->runtime->state) {
         case SNDRV_PCM_STATE_OPEN:
         case SNDRV_PCM_STATE_SETUP:

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hda_codec.h

@@ -259 +259 @@
         unsigned int relaxed_resume:1;  /* don't resume forcibly for jack */
         unsigned int forced_resume:1; /* forced resume for jack */
-        unsigned int mst_no_extra_pcms:1; /* no backup PCMs for DP-MST */
 
 #ifdef CONFIG_PM
@@ -294 +293 @@
 #define hda_codec_dev(_dev)     (&(_dev)->core.dev)
 
-#define hdac_to_hda_priv(_hdac) \
-                        container_of(_hdac, struct hdac_hda_priv, codec.core)
 #define hdac_to_hda_codec(_hdac) container_of(_hdac, struct hda_codec, core)
 

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

@@ -261 +261 @@
 #define AZX_REG_ML_LCAP                 0x00
 #define AZX_REG_ML_LCTL                 0x04
+
+#define AZX_ML_LCTL_CPA                 BIT(23)
+#define AZX_ML_LCTL_CPA_SHIFT           23
+#define AZX_ML_LCTL_SPA                 BIT(16)
+#define AZX_ML_LCTL_SPA_SHIFT           16
+#define AZX_ML_LCTL_SCF                 GENMASK(3, 0)
+
 #define AZX_REG_ML_LOSIDV               0x08
+
+/* bit0 is reserved, with BIT(1) mapping to stream1 */
+#define AZX_ML_LOSIDV_STREAM_MASK       0xFFFE
+
 #define AZX_REG_ML_LSDIID               0x0C
 #define AZX_REG_ML_LPSOO                0x10
@@ -268 +279 @@
 #define AZX_REG_ML_LOUTPAY              0x20
 #define AZX_REG_ML_LINPAY               0x30
-
-/* bit0 is reserved, with BIT(1) mapping to stream1 */
-#define ML_LOSIDV_STREAM_MASK           0xFFFE
-
-#define ML_LCTL_SCF_MASK                        0xF
-#define AZX_MLCTL_SPA                           (0x1 << 16)
-#define AZX_MLCTL_CPA                           (0x1 << 23)
-#define AZX_MLCTL_SPA_SHIFT                     16
-#define AZX_MLCTL_CPA_SHIFT                     23
 
 /* registers for DMA Resume Capability Structure */

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hdaudio.h

@@ -11 +11 @@
 #include <linux/io.h>
 #include <linux/io-64-nonatomic-lo-hi.h>
+#include <linux/iopoll.h>
 #include <linux/pm_runtime.h>
 #include <linux/timecounter.h>
@@ -565 +566 @@
 struct hdac_stream *snd_hdac_stream_assign(struct hdac_bus *bus,
                                            struct snd_pcm_substream *substream);
+void snd_hdac_stream_release_locked(struct hdac_stream *azx_dev);
 void snd_hdac_stream_release(struct hdac_stream *azx_dev);
 struct hdac_stream *snd_hdac_get_stream(struct hdac_bus *bus,
@@ -575 +577 @@
                                 unsigned int format_val);
 void snd_hdac_stream_start(struct hdac_stream *azx_dev, bool fresh_start);
-void snd_hdac_stream_clear(struct hdac_stream *azx_dev);
 void snd_hdac_stream_stop(struct hdac_stream *azx_dev);
+void snd_hdac_stop_streams(struct hdac_bus *bus);
 void snd_hdac_stop_streams_and_chip(struct hdac_bus *bus);
 void snd_hdac_stream_reset(struct hdac_stream *azx_dev);
@@ -604 +606 @@
 #define snd_hdac_stream_readb(dev, reg) \
         snd_hdac_reg_readb((dev)->bus, (dev)->sd_addr + AZX_REG_ ## reg)
+#define snd_hdac_stream_readb_poll(dev, reg, val, cond, delay_us, timeout_us) \
+        read_poll_timeout_atomic(snd_hdac_reg_readb, val, cond, delay_us, timeout_us, \
+                                 false, (dev)->bus, (dev)->sd_addr + AZX_REG_ ## reg)
+#define snd_hdac_stream_readl_poll(dev, reg, val, cond, delay_us, timeout_us) \
+        read_poll_timeout_atomic(snd_hdac_reg_readl, val, cond, delay_us, timeout_us, \
+                                 false, (dev)->bus, (dev)->sd_addr + AZX_REG_ ## reg)
 
 /* update a register, pass without AZX_REG_ prefix */

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hdaudio_ext.h

@@ -12 +12 @@
 
 void snd_hdac_ext_bus_exit(struct hdac_bus *bus);
-int snd_hdac_ext_bus_device_init(struct hdac_bus *bus, int addr,
-                                struct hdac_device *hdev, int type);
-void snd_hdac_ext_bus_device_exit(struct hdac_device *hdev);
 void snd_hdac_ext_bus_device_remove(struct hdac_bus *bus);
 
@@ -81 +78 @@
         container_of(s, struct hdac_ext_stream, hstream)
 
-void snd_hdac_ext_stream_init(struct hdac_bus *bus,
-                              struct hdac_ext_stream *hext_stream, int idx,
-                              int direction, int tag);
 int snd_hdac_ext_stream_init_all(struct hdac_bus *bus, int start_idx,
                                  int num_stream, int dir);
-void snd_hdac_stream_free_all(struct hdac_bus *bus);
+void snd_hdac_ext_stream_free_all(struct hdac_bus *bus);
 void snd_hdac_link_free_all(struct hdac_bus *bus);
 struct hdac_ext_stream *snd_hdac_ext_stream_assign(struct hdac_bus *bus,
@@ -189 +183 @@
         readq_poll_timeout((chip)->dsp_ba + (reg), val, cond, \
                            delay_us, timeout_us)
-#define snd_hdac_stream_readb_poll(strm, reg, val, cond, delay_us, timeout_us) \
-        readb_poll_timeout((strm)->sd_addr + AZX_REG_ ## reg, val, cond, \
-                           delay_us, timeout_us)
-#define snd_hdac_stream_readl_poll(strm, reg, val, cond, delay_us, timeout_us) \
-        readl_poll_timeout((strm)->sd_addr + AZX_REG_ ## reg, val, cond, \
-                           delay_us, timeout_us)
 
 struct hdac_ext_device;

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/intel-nhlt.h

@@ -137 +137 @@
 int intel_nhlt_ssp_endpoint_mask(struct nhlt_acpi_table *nhlt, u8 device_type);
 
+int intel_nhlt_ssp_mclk_mask(struct nhlt_acpi_table *nhlt, int ssp_num);
+
 struct nhlt_specific_cfg *
 intel_nhlt_get_endpoint_blob(struct device *dev, struct nhlt_acpi_table *nhlt,
@@ -170 +172 @@
 }
 
+static inline int intel_nhlt_ssp_mclk_mask(struct nhlt_acpi_table *nhlt, int ssp_num)
+{
+        return 0;
+}
+
 static inline struct nhlt_specific_cfg *
 intel_nhlt_get_endpoint_blob(struct device *dev, struct nhlt_acpi_table *nhlt,

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/memalloc.h

@@ -26 +26 @@
         struct device *dev;             /* generic device */
 };
-
-#define snd_dma_continuous_data(x)      ((struct device *)(__force unsigned long)(x))
-
 
 /*

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/pcm.h

@@ -347 +347 @@
 struct snd_pcm_runtime {
         /* -- Status -- */
+        snd_pcm_state_t state;          /* stream state */
+        snd_pcm_state_t suspended_state; /* suspended stream state */
         struct snd_pcm_substream *trigger_master;
         struct timespec64 trigger_tstamp;       /* trigger timestamp */
@@ -686 +688 @@
 static inline int snd_pcm_running(struct snd_pcm_substream *substream)
 {
-        return (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING ||
-                (substream->runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
+        return (substream->runtime->state == SNDRV_PCM_STATE_RUNNING ||
+                (substream->runtime->state == SNDRV_PCM_STATE_DRAINING &&
                  substream->stream == SNDRV_PCM_STREAM_PLAYBACK));
+}
+
+/**
+ * __snd_pcm_set_state - Change the current PCM state
+ * @runtime: PCM runtime to set
+ * @state: the current state to set
+ *
+ * Call within the stream lock
+ */
+static inline void __snd_pcm_set_state(struct snd_pcm_runtime *runtime,
+                                       snd_pcm_state_t state)
+{
+        runtime->state = state;
+        runtime->status->state = state; /* copy for mmap */
 }
 

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

@@ -40 +40 @@
         u32 convert_rate;
         u32 convert_channels;
+        const char *convert_sample_format;
 };
 
@@ -177 +178 @@
 void asoc_simple_parse_convert(struct device_node *np, char *prefix,
                                struct asoc_simple_data *data);
+bool asoc_simple_is_convert_required(const struct asoc_simple_data *data);
 
 int asoc_simple_parse_routing(struct snd_soc_card *card,

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-acpi-intel-match.h

@@ -15 +15 @@
  * pdata or machine ops
  */
-extern struct snd_soc_acpi_mach snd_soc_acpi_intel_haswell_machines[];
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_broadwell_machines[];
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_baytrail_machines[];

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

@@ -32 +32 @@
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xreg, .rreg = xreg, .shift = shift_left, \
-        .rshift = shift_right, .max = xmax, .platform_max = xmax, \
+        .rshift = shift_right, .max = xmax, \
         .invert = xinvert, .autodisable = xautodisable})
 #define SOC_DOUBLE_S_VALUE(xreg, shift_left, shift_right, xmin, xmax, xsign_bit, xinvert, xautodisable) \
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xreg, .rreg = xreg, .shift = shift_left, \
-        .rshift = shift_right, .min = xmin, .max = xmax, .platform_max = xmax, \
+        .rshift = shift_right, .min = xmin, .max = xmax, \
         .sign_bit = xsign_bit, .invert = xinvert, .autodisable = xautodisable})
 #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert, xautodisable) \
@@ -43 +43 @@
 #define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
         ((unsigned long)&(struct soc_mixer_control) \
-        {.reg = xreg, .max = xmax, .platform_max = xmax, .invert = xinvert})
+        {.reg = xreg, .max = xmax, .invert = xinvert})
 #define SOC_DOUBLE_R_VALUE(xlreg, xrreg, xshift, xmax, xinvert) \
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
-        .max = xmax, .platform_max = xmax, .invert = xinvert})
+        .max = xmax, .invert = xinvert})
 #define SOC_DOUBLE_R_S_VALUE(xlreg, xrreg, xshift, xmin, xmax, xsign_bit, xinvert) \
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
-        .max = xmax, .min = xmin, .platform_max = xmax, .sign_bit = xsign_bit, \
+        .max = xmax, .min = xmin, .sign_bit = xsign_bit, \
         .invert = xinvert})
 #define SOC_DOUBLE_R_RANGE_VALUE(xlreg, xrreg, xshift, xmin, xmax, xinvert) \
         ((unsigned long)&(struct soc_mixer_control) \
         {.reg = xlreg, .rreg = xrreg, .shift = xshift, .rshift = xshift, \
-        .min = xmin, .max = xmax, .platform_max = xmax, .invert = xinvert})
+        .min = xmin, .max = xmax, .invert = xinvert})
 #define SOC_SINGLE(xname, reg, shift, max, invert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
@@ -69 +69 @@
                 {.reg = xreg, .rreg = xreg, .shift = xshift, \
                  .rshift = xshift,  .min = xmin, .max = xmax, \
-                 .platform_max = xmax, .invert = xinvert} }
+                 .invert = xinvert} }
 #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
@@ -100 +100 @@
                 {.reg = xreg, .rreg = xreg, .shift = xshift, \
                  .rshift = xshift, .min = xmin, .max = xmax, \
-                 .platform_max = xmax, .invert = xinvert} }
+                 .invert = xinvert} }
 #define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
@@ -200 +200 @@
         .private_value = (unsigned long)&(struct soc_mixer_control) \
         {.reg = xreg, .rreg = xreg,  \
-         .min = xmin, .max = xmax, .platform_max = xmax, \
+         .min = xmin, .max = xmax, \
         .sign_bit = 7,} }
 #define SOC_DOUBLE_S8_TLV(xname, xreg, xmin, xmax, tlv_array) \
@@ -274 +274 @@
                 {.reg = xreg, .rreg = xreg, .shift = xshift, \
                  .rshift = xshift, .min = xmin, .max = xmax, \
-                 .platform_max = xmax, .invert = xinvert} }
+                 .invert = xinvert} }
 #define SOC_DOUBLE_EXT_TLV(xname, xreg, shift_left, shift_right, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
@@ -1063 +1063 @@
 
         /* Dynamic PCM BE runtime data */
-        struct snd_soc_dpcm_runtime dpcm[2];
+        struct snd_soc_dpcm_runtime dpcm[SNDRV_PCM_STREAM_LAST + 1];
+        struct snd_soc_dapm_widget *c2c_widget[SNDRV_PCM_STREAM_LAST + 1];
 
         long pmdown_time;
@@ -1079 +1080 @@
          */
         struct snd_soc_dai **dais;
-        unsigned int num_codecs;
-        unsigned int num_cpus;
-
-        struct snd_soc_dapm_widget *playback_widget;
-        struct snd_soc_dapm_widget *capture_widget;
 
         struct delayed_work delayed_work;
@@ -1109 +1105 @@
 /* see soc_new_pcm_runtime()  */
 #define asoc_rtd_to_cpu(rtd, n)   (rtd)->dais[n]
-#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->num_cpus]
+#define asoc_rtd_to_codec(rtd, n) (rtd)->dais[n + (rtd)->dai_link->num_cpus]
 #define asoc_substream_to_rtd(substream) \
         (struct snd_soc_pcm_runtime *)snd_pcm_substream_chip(substream)
@@ -1119 +1115 @@
 #define for_each_rtd_cpu_dais(rtd, i, dai)                              \
         for ((i) = 0;                                                   \
-             ((i) < rtd->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
+             ((i) < rtd->dai_link->num_cpus) && ((dai) = asoc_rtd_to_cpu(rtd, i)); \
              (i)++)
 #define for_each_rtd_codec_dais(rtd, i, dai)                            \
         for ((i) = 0;                                                   \
-             ((i) < rtd->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
+             ((i) < rtd->dai_link->num_codecs) && ((dai) = asoc_rtd_to_codec(rtd, i)); \
              (i)++)
 #define for_each_rtd_dais(rtd, i, dai)                                  \
         for ((i) = 0;                                                   \
-             ((i) < (rtd)->num_cpus + (rtd)->num_codecs) &&             \
+             ((i) < (rtd)->dai_link->num_cpus + (rtd)->dai_link->num_codecs) && \
                      ((dai) = (rtd)->dais[i]);                          \
              (i)++)

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

@@ -90 +90 @@
         struct platform_device *pdev_mach;
         const struct snd_soc_acpi_mach *machine;
+        const struct snd_sof_of_mach *of_machine;
 
         void *hw_pdata;
@@ -103 +104 @@
         /* list of machines using this configuration */
         struct snd_soc_acpi_mach *machines;
+        struct snd_sof_of_mach *of_machines;
 
         /* alternate list of machines using this configuration */

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

@@ -1 +1 @@
 /* include/version.h */
-#define CONFIG_SND_VERSION "6.0.7"
+#define CONFIG_SND_VERSION "6.1.0"
 #define CONFIG_SND_DATE ""

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asequencer.h

@@ -4 +4 @@
  *  Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
  *            (c) 1998-1999 by Jaroslav Kysela <perex@perex.cz>
- *
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 #ifndef _UAPI__SOUND_ASEQUENCER_H

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asoc.h

@@ -5 +5 @@
  * Copyright (C) 2012 Texas Instruments Inc.
  * Copyright (C) 2015 Intel Corporation.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  *
  * Simple file API to load FW that includes mixers, coefficients, DAPM graphs,

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asound.h

@@ -4 +4 @@
  *  Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,
  *                             Abramo Bagnara <abramo@alsa-project.org>
- *
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asound_fm.h

@@ -11 +11 @@
  *
  *  Direct FM control
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/compress_offload.h

@@ -6 +6 @@
  *  Authors:    Vinod Koul <vinod.koul@linux.intel.com>
  *              Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
- *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
  */
 #ifndef __COMPRESS_OFFLOAD_H

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/compress_params.h

@@ -8 +8 @@
  *              Vinod Koul <vinod.koul@linux.intel.com>
  *
- *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * The definitions in this file are derived from the OpenMAX AL version 1.1
- * and OpenMAX IL v 1.1.2 header files which contain the copyright notice below.
+ * and OpenMAX IL v 1.1.2 header files which contain the copyright notice below
+ * and are licensed under the MIT license.
  *
  * Copyright (c) 2007-2010 The Khronos Group Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and/or associated documentation files (the
- * "Materials "), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
  */
 #ifndef __SND_COMPRESS_PARAMS_H

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/emu10k1.h

@@ -4 +4 @@
  *                   Creative Labs, Inc.
  *  Definitions for EMU10K1 (SB Live!) chips
- *
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 #ifndef _UAPI__SOUND_EMU10K1_H

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/tlv.h

@@ -1 +1 @@
 /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-/*
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- */
 
 #ifndef __UAPI_SOUND_TLV_H

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

@@ -896 +896 @@
         kfree(codec->modelname);
         kfree(codec->wcaps);
-
-        /*
-         * In the case of ASoC HD-audio, hda_codec is device managed.
-         * It will be freed when the ASoC device is removed.
-         */
-        if (codec->core.type == HDA_DEV_LEGACY)
-                kfree(codec);
+        kfree(codec);
 }
 
@@ -944 +938 @@
 
         codec->bus = bus;
-        codec->core.type = HDA_DEV_LEGACY;
-
-        return codec;
-}
-EXPORT_SYMBOL_GPL(snd_hda_codec_device_init);
-
-/**
- * snd_hda_codec_new - create a HDA codec
- * @bus: the bus to assign
- * @card: card for this codec
- * @codec_addr: the codec address
- * @codecp: the pointer to store the generated codec
- *
- * Returns 0 if successful, or a negative error code.
- */
-int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
-                      unsigned int codec_addr, struct hda_codec **codecp)
-{
-        struct hda_codec *codec;
-        int ret;
-
-        codec = snd_hda_codec_device_init(bus, codec_addr, "hdaudioC%dD%d",
-                                          card->number, codec_addr);
-        if (IS_ERR(codec))
-                return PTR_ERR(codec);
-        *codecp = codec;
-
-        ret = snd_hda_codec_device_new(bus, card, codec_addr, *codecp, true);
-        if (ret)
-                put_device(hda_codec_dev(*codecp));
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(snd_hda_codec_new);
-
-int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
-                        unsigned int codec_addr, struct hda_codec *codec,
-                        bool snddev_managed)
-{
-        char component[31];
-        hda_nid_t fg;
-        int err;
-        static const struct snd_device_ops dev_ops = {
-                .dev_register = snd_hda_codec_dev_register,
-                .dev_free = snd_hda_codec_dev_free,
-        };
-
-        dev_dbg(card->dev, "%s: entry\n", __func__);
-
-        if (snd_BUG_ON(!bus))
-                return -EINVAL;
-        if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
-                return -EINVAL;
-
+        codec->depop_delay = -1;
+        codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
         codec->core.dev.release = snd_hda_codec_dev_release;
         codec->core.exec_verb = codec_exec_verb;
-
-        codec->card = card;
-        codec->addr = codec_addr;
+        codec->core.type = HDA_DEV_LEGACY;
+
         mutex_init(&codec->spdif_mutex);
         mutex_init(&codec->control_mutex);
@@ -1015 +956 @@
         INIT_LIST_HEAD(&codec->conn_list);
         INIT_LIST_HEAD(&codec->pcm_list_head);
+        INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
         refcount_set(&codec->pcm_ref, 1);
         init_waitqueue_head(&codec->remove_sleep);
 
-        INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
-        codec->depop_delay = -1;
-        codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
+        return codec;
+}
+EXPORT_SYMBOL_GPL(snd_hda_codec_device_init);
+
+/**
+ * snd_hda_codec_new - create a HDA codec
+ * @bus: the bus to assign
+ * @card: card for this codec
+ * @codec_addr: the codec address
+ * @codecp: the pointer to store the generated codec
+ *
+ * Returns 0 if successful, or a negative error code.
+ */
+int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
+                      unsigned int codec_addr, struct hda_codec **codecp)
+{
+        struct hda_codec *codec;
+        int ret;
+
+        codec = snd_hda_codec_device_init(bus, codec_addr, "hdaudioC%dD%d",
+                                          card->number, codec_addr);
+        if (IS_ERR(codec))
+                return PTR_ERR(codec);
+        *codecp = codec;
+
+        ret = snd_hda_codec_device_new(bus, card, codec_addr, *codecp, true);
+        if (ret)
+                put_device(hda_codec_dev(*codecp));
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_hda_codec_new);
+
+int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
+                        unsigned int codec_addr, struct hda_codec *codec,
+                        bool snddev_managed)
+{
+        char component[31];
+        hda_nid_t fg;
+        int err;
+        static const struct snd_device_ops dev_ops = {
+                .dev_register = snd_hda_codec_dev_register,
+                .dev_free = snd_hda_codec_dev_free,
+        };
+
+        dev_dbg(card->dev, "%s: entry\n", __func__);
+
+        if (snd_BUG_ON(!bus))
+                return -EINVAL;
+        if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
+                return -EINVAL;
+
+        codec->card = card;
+        codec->addr = codec_addr;
 
 #ifdef CONFIG_PM

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_controller.c

@@ -1058 +1058 @@
 {
         struct hdac_bus *bus = azx_bus(chip);
-        struct hdac_stream *s;
-
-        list_for_each_entry(s, &bus->stream_list, list, struct hdac_stream)
-                snd_hdac_stream_stop(s);
+
+        snd_hdac_stop_streams(bus);
 }
 EXPORT_SYMBOL_GPL(azx_stop_all_streams);

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_eld.c

@@ -451 +451 @@
 
 void snd_hdmi_print_eld_info(struct hdmi_eld *eld,
-                             struct snd_info_buffer *buffer)
+                             struct snd_info_buffer *buffer,
+                             hda_nid_t pin_nid, int dev_id, hda_nid_t cvt_nid)
 {
         struct parsed_hdmi_eld *e = &eld->info;
@@ -510 +511 @@
         snd_iprintf(buffer, "monitor_present\t\t%d\n", eld->monitor_present);
         snd_iprintf(buffer, "eld_valid\t\t%d\n", eld->eld_valid);
+        snd_iprintf(buffer, "codec_pin_nid\t\t0x%x\n", pin_nid);
+        snd_iprintf(buffer, "codec_dev_id\t\t0x%x\n", dev_id);
+        snd_iprintf(buffer, "codec_cvt_nid\t\t0x%x\n", cvt_nid);
         if (!eld->eld_valid)
                 return;

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_intel.c

@@ -97 +97 @@
 #define INTEL_SCH_HDA_DEVC_NOSNOOP       (0x1<<11)
 
-/* Define VIA HD Audio Device ID*/
-#define VIA_HDAC_DEVICE_ID              0x3288
-
 /* max number of SDs */
 /* ICH, ATI and VIA have 4 playback and 4 capture */
@@ -112 +109 @@
 #define ATIHDMI_NUM_CAPTURE     0
 #define ATIHDMI_NUM_PLAYBACK    8
-
-/* TERA has 4 playback and 3 capture */
-#define TERA_NUM_CAPTURE        3
-#define TERA_NUM_PLAYBACK       4
 
 
@@ -511 +504 @@
 
         /*
-         * the codecs are sharing the first link setting by default
-         * If other links are enabled for stream, they need similar fix
+         * Changes to LCTL.SCF are only needed for the first multi-link dealing
+         * with external codecs
          */
         val = readl(bus->mlcap + AZX_ML_BASE + AZX_REG_ML_LCTL);
-        val &= ~AZX_MLCTL_SPA;
-        val |= state << AZX_MLCTL_SPA_SHIFT;
+        val &= ~AZX_ML_LCTL_SPA;
+        val |= state << AZX_ML_LCTL_SPA_SHIFT;
         writel(val, bus->mlcap + AZX_ML_BASE + AZX_REG_ML_LCTL);
         /* wait for CPA */
@@ -522 +515 @@
         while (timeout) {
                 if (((readl(bus->mlcap + AZX_ML_BASE + AZX_REG_ML_LCTL)) &
-                    AZX_MLCTL_CPA) == (state << AZX_MLCTL_CPA_SHIFT))
+                    AZX_ML_LCTL_CPA) == (state << AZX_ML_LCTL_CPA_SHIFT))
                         return 0;
                 timeout--;
@@ -539 +532 @@
         /* 0. check lctl register value is correct or not */
         val = readl(bus->mlcap + AZX_ML_BASE + AZX_REG_ML_LCTL);
-        /* if SCF is already set, let's use it */
-        if ((val & ML_LCTL_SCF_MASK) != 0)
+        /* only perform additional configurations if the SCF is initially based on 6MHz */
+        if ((val & AZX_ML_LCTL_SCF) != 0)
                 return;
 
@@ -547 +540 @@
          * Any deviation may result in undefined behavior.
          */
-        if (((val & AZX_MLCTL_SPA) >> AZX_MLCTL_SPA_SHIFT) !=
-                ((val & AZX_MLCTL_CPA) >> AZX_MLCTL_CPA_SHIFT))
+        if (((val & AZX_ML_LCTL_SPA) >> AZX_ML_LCTL_SPA_SHIFT) !=
+                ((val & AZX_ML_LCTL_CPA) >> AZX_ML_LCTL_CPA_SHIFT))
                 return;
 
@@ -557 +550 @@
                 goto set_spa;
 
-        /* 2. update SCF to select a properly audio clock*/
-        val &= ~ML_LCTL_SCF_MASK;
+        /* 2. update SCF to select an audio clock different from 6MHz */
+        val &= ~AZX_ML_LCTL_SCF;
         val |= intel_get_lctl_scf(chip);
         writel(val, bus->mlcap + AZX_ML_BASE + AZX_REG_ML_LCTL);
@@ -2770 +2763 @@
           .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS |
           AZX_DCAPS_PM_RUNTIME },
+        { PCI_DEVICE(0x1002, 0xab30),
+          .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS |
+          AZX_DCAPS_PM_RUNTIME },
         { PCI_DEVICE(0x1002, 0xab38),
           .driver_data = AZX_DRIVER_ATIHDMI_NS | AZX_DCAPS_PRESET_ATI_HDMI_NS |

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

@@ -727 +727 @@
 #ifdef CONFIG_SND_PROC_FS
 void snd_hdmi_print_eld_info(struct hdmi_eld *eld,
-                             struct snd_info_buffer *buffer);
+                             struct snd_info_buffer *buffer,
+                             hda_nid_t pin_nid, int dev_id, hda_nid_t cvt_nid);
 void snd_hdmi_write_eld_info(struct hdmi_eld *eld,
                              struct snd_info_buffer *buffer);

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_sysfs.c

@@ -375 +375 @@
         return pin_configs_show(codec, &codec->user_pins, buf);
 }
-
-#define MAX_PIN_CONFIGS         32
 
 static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)

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

@@ -1312 +1312 @@
         SND_PCI_QUIRK(0x1458, 0xA036, "Gigabyte GA-Z170X-Gaming 7", QUIRK_R3DI),
         SND_PCI_QUIRK(0x3842, 0x1038, "EVGA X99 Classified", QUIRK_R3DI),
+        SND_PCI_QUIRK(0x3842, 0x1055, "EVGA Z390 DARK", QUIRK_R3DI),
         SND_PCI_QUIRK(0x1102, 0x0013, "Recon3D", QUIRK_R3D),
         SND_PCI_QUIRK(0x1102, 0x0018, "Recon3D", QUIRK_R3D),
@@ -2968 +2969 @@
                         unsigned int *port_map)
 {
-        int status;
         unsigned int num_chans;
 
@@ -2982 +2982 @@
         num_chans = get_hdafmt_chs(fmt) + 1;
 
-        status = dsp_allocate_ports(codec, num_chans, rate_multi, port_map);
-
-        return status;
+        return dsp_allocate_ports(codec, num_chans, rate_multi, port_map);
 }
 

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

@@ -164 +164 @@
         int dev_num;
         struct snd_array pins; /* struct hdmi_spec_per_pin */
-        struct hdmi_pcm pcm_rec[16];
+        struct hdmi_pcm pcm_rec[8];
         struct mutex pcm_lock;
         struct mutex bind_lock; /* for audio component binding */
@@ -180 +180 @@
 
         bool dyn_pin_out;
-        bool dyn_pcm_assign;
-        bool dyn_pcm_no_legacy;
         /* hdmi interrupt trigger control flag for Nvidia codec */
         bool hdmi_intr_trig_ctrl;
@@ -245 +243 @@
         struct hdmi_audio_infoframe hdmi;
         struct dp_audio_infoframe dp;
+#ifndef TARGET_OS2
+        DECLARE_FLEX_ARRAY(u8, bytes);
+#else
         u8 bytes[1];
+#endif
 };
 
@@ -509 +511 @@
 
         mutex_lock(&per_pin->lock);
-        snd_hdmi_print_eld_info(&per_pin->sink_eld, buffer);
+        snd_hdmi_print_eld_info(&per_pin->sink_eld, buffer, per_pin->pin_nid,
+                                per_pin->dev_id, per_pin->cvt_nid);
         mutex_unlock(&per_pin->lock);
 }
@@ -1200 +1203 @@
 }
 
-/* called in hdmi_pcm_open when no pin is assigned to the PCM
- * in dyn_pcm_assign mode.
- */
+/* called in hdmi_pcm_open when no pin is assigned to the PCM */
 static int hdmi_pcm_open_no_pin(struct hda_pcm_stream *hinfo,
                          struct hda_codec *codec,
@@ -1270 +1271 @@
         mutex_lock(&spec->pcm_lock);
         pin_idx = hinfo_to_pin_index(codec, hinfo);
-        if (!spec->dyn_pcm_assign) {
-                if (snd_BUG_ON(pin_idx < 0)) {
-                        err = -EINVAL;
-                        goto unlock;
-                }
-        } else {
-                /* no pin is assigned to the PCM
-                 * PA need pcm open successfully when probe
-                 */
-                if (pin_idx < 0) {
-                        err = hdmi_pcm_open_no_pin(hinfo, codec, substream);
-                        goto unlock;
-                }
+        /* no pin is assigned to the PCM
+         * PA need pcm open successfully when probe
+         */
+        if (pin_idx < 0) {
+                err = hdmi_pcm_open_no_pin(hinfo, codec, substream);
+                goto unlock;
         }
 
@@ -1387 +1381 @@
         int i;
 
-        /* on the new machines, try to assign the pcm slot dynamically,
-         * not use the preferred fixed map (legacy way) anymore.
-         */
-        if (spec->dyn_pcm_no_legacy)
-                goto last_try;
-
-        /*
-         * generic_hdmi_build_pcms() may allocate extra PCMs on some
-         * platforms (with maximum of 'num_nids + dev_num - 1')
-         *
-         * The per_pin of pin_nid_idx=n and dev_id=m prefers to get pcm-n
-         * if m==0. This guarantees that dynamic pcm assignments are compatible
-         * with the legacy static per_pin-pcm assignment that existed in the
-         * days before DP-MST.
-         *
-         * Intel DP-MST prefers this legacy behavior for compatibility, too.
-         *
-         * per_pin of m!=0 prefers to get pcm=(num_nids + (m - 1)).
-         */
-
-        if (per_pin->dev_id == 0 || spec->intel_hsw_fixup) {
-                if (!test_bit(per_pin->pin_nid_idx, &spec->pcm_bitmap))
-                        return per_pin->pin_nid_idx;
-        } else {
-                i = spec->num_nids + (per_pin->dev_id - 1);
-                if (i < spec->pcm_used && !(test_bit(i, &spec->pcm_bitmap)))
-                        return i;
-        }
-
-        /* have a second try; check the area over num_nids */
-        for (i = spec->num_nids; i < spec->pcm_used; i++) {
-                if (!test_bit(i, &spec->pcm_bitmap))
-                        return i;
-        }
-
- last_try:
-        /* the last try; check the empty slots in pins */
         for (i = 0; i < spec->pcm_used; i++) {
                 if (!test_bit(i, &spec->pcm_bitmap))
@@ -1485 +1442 @@
         bool non_pcm;
 
-        if (per_pin->pcm_idx >= 0 && per_pin->pcm_idx < spec->pcm_used)
-                pcm = get_pcm_rec(spec, per_pin->pcm_idx);
-        else
+        if (per_pin->pcm_idx < 0 || per_pin->pcm_idx >= spec->pcm_used)
                 return;
+        pcm = get_pcm_rec(spec, per_pin->pcm_idx);
         if (!pcm->pcm)
                 return;
@@ -1586 +1542 @@
         pcm_jack = pin_idx_to_pcm_jack(codec, per_pin);
 
-        if (spec->dyn_pcm_assign) {
-                if (eld->eld_valid) {
-                        hdmi_attach_hda_pcm(spec, per_pin);
-                        hdmi_pcm_setup_pin(spec, per_pin);
-                } else {
-                        hdmi_pcm_reset_pin(spec, per_pin);
-                        hdmi_detach_hda_pcm(spec, per_pin);
-                }
+        if (eld->eld_valid) {
+                hdmi_attach_hda_pcm(spec, per_pin);
+                hdmi_pcm_setup_pin(spec, per_pin);
+        } else {
+                hdmi_pcm_reset_pin(spec, per_pin);
+                hdmi_detach_hda_pcm(spec, per_pin);
         }
         /* if pcm_idx == -1, it means this is in monitor connection event
@@ -1955 +1909 @@
                  */
                 dev_num = spec->dev_num;
-        } else if (spec->dyn_pcm_assign && codec->dp_mst) {
+        } else if (codec->dp_mst) {
                 dev_num = snd_hda_get_num_devices(codec, pin_nid) + 1;
                 /*
@@ -1980 +1934 @@
                         return -ENOMEM;
 
-                if (spec->dyn_pcm_assign) {
-                        per_pin->pcm = NULL;
-                        per_pin->pcm_idx = -1;
-                } else {
-                        per_pin->pcm = get_hdmi_pcm(spec, pin_idx);
-                        per_pin->pcm_idx = pin_idx;
-                }
+                per_pin->pcm = NULL;
+                per_pin->pcm_idx = -1;
                 per_pin->pin_nid = pin_nid;
                 per_pin->pin_nid_idx = spec->num_nids;
@@ -1995 +1944 @@
                 if (err < 0)
                         return err;
+                if (!is_jack_detectable(codec, pin_nid))
+                        codec_warn(codec, "HDMI: pin NID 0x%x - jack not detectable\n", pin_nid);
                 spec->num_pins++;
         }
@@ -2142 +2093 @@
         mutex_lock(&spec->pcm_lock);
         pin_idx = hinfo_to_pin_index(codec, hinfo);
-        if (spec->dyn_pcm_assign && pin_idx < 0) {
-                /* when dyn_pcm_assign and pcm is not bound to a pin
-                 * skip pin setup and return 0 to make audio playback
-                 * be ongoing
+        if (pin_idx < 0) {
+                /* when pcm is not bound to a pin skip pin setup and return 0
+                 * to make audio playback be ongoing
                  */
                 pin_cvt_fixup(codec, NULL, cvt_nid);
@@ -2248 +2198 @@
                 clear_bit(pcm_idx, &spec->pcm_in_use);
                 pin_idx = hinfo_to_pin_index(codec, hinfo);
-                if (spec->dyn_pcm_assign && pin_idx < 0)
+                if (pin_idx < 0)
                         goto unlock;
 
@@ -2346 +2296 @@
         int idx, pcm_num;
 
-        /*
-         * for non-mst mode, pcm number is the same as before
-         * for DP MST mode without extra PCM, pcm number is same
-         * for DP MST mode with extra PCMs, pcm number is
-         *  (nid number + dev_num - 1)
-         * dev_num is the device entry number in a pin
-         */
-
-        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
-                pcm_num = spec->num_nids + spec->dev_num - 1;
-
+        /* limit the PCM devices to the codec converters */
+        pcm_num = spec->num_cvts;
         codec_dbg(codec, "hdmi: pcm_num set to %d\n", pcm_num);
 
@@ -2379 +2316 @@
                 pstr->substreams = 1;
                 pstr->ops = generic_ops;
-                /* pcm number is less than 16 */
-                if (spec->pcm_used >= 16)
+                /* pcm number is less than pcm_rec array size */
+                if (spec->pcm_used >= ARRAY_SIZE(spec->pcm_rec))
                         break;
                 /* other pstr fields are set in open */
@@ -2399 +2336 @@
         char hdmi_str[32] = "HDMI/DP";
         struct hdmi_spec *spec = codec->spec;
-        struct hdmi_spec_per_pin *per_pin = get_pin(spec, pcm_idx);
         struct snd_jack *jack;
         int pcmdev = get_pcm_rec(spec, pcm_idx)->device;
@@ -2406 +2342 @@
         if (pcmdev > 0)
                 sprintf(hdmi_str + strlen(hdmi_str), ",pcm=%d", pcmdev);
-        if (!spec->dyn_pcm_assign &&
-            !is_jack_detectable(codec, per_pin->pin_nid))
-                strncat(hdmi_str, " Phantom",
-                        sizeof(hdmi_str) - strlen(hdmi_str) - 1);
 
         err = snd_jack_new(codec->card, hdmi_str, SND_JACK_AVOUT, &jack,
@@ -2442 +2374 @@
                  * pin will be bound when monitor is connected
                  */
-                if (spec->dyn_pcm_assign)
-                        err = snd_hda_create_dig_out_ctls(codec,
+                err = snd_hda_create_dig_out_ctls(codec,
                                           0, spec->cvt_nids[0],
                                           HDA_PCM_TYPE_HDMI);
-                else {
-                        struct hdmi_spec_per_pin *per_pin =
-                                get_pin(spec, pcm_idx);
-                        err = snd_hda_create_dig_out_ctls(codec,
-                                                  per_pin->pin_nid,
-                                                  per_pin->mux_nids[0],
-                                                  HDA_PCM_TYPE_HDMI);
-                }
                 if (err < 0)
                         return err;
@@ -2573 +2496 @@
                 if (spec->pcm_rec[pcm_idx].jack == NULL)
                         continue;
-                if (spec->dyn_pcm_assign)
-                        snd_device_free(codec->card,
-                                        spec->pcm_rec[pcm_idx].jack);
-                else
-                        spec->pcm_rec[pcm_idx].jack = NULL;
+                snd_device_free(codec->card, spec->pcm_rec[pcm_idx].jack);
         }
 
@@ -3055 +2974 @@
         spec = codec->spec;
         codec->dp_mst = true;
-        spec->dyn_pcm_assign = true;
         spec->vendor_nid = vendor_nid;
         spec->port_map = port_map;
@@ -3119 +3037 @@
          */
         static const int map[] = {0x4, 0x6, 0x8, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
-        int ret;
-
-        ret = intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4,
-                                    enable_silent_stream);
-        if (!ret) {
-                struct hdmi_spec *spec = codec->spec;
-
-                spec->dyn_pcm_no_legacy = true;
-        }
-
-        return ret;
+
+        return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map), 4,
+                                     enable_silent_stream);
 }
 
@@ -3769 +3679 @@
 
         spec = codec->spec;
-        spec->dyn_pcm_assign = true;
 
         err = hdmi_parse_codec(codec);
@@ -4049 +3958 @@
 
         codec->dp_mst = true;
-        codec->mst_no_extra_pcms = true;
         spec = codec->spec;
         spec->dyn_pin_out = true;
-        spec->dyn_pcm_assign = true;
         spec->hdmi_intr_trig_ctrl = true;
 

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

@@ -19 +19 @@
 #include <linux/input.h>
 #include <linux/leds.h>
+#include <linux/ctype.h>
 #include <sound/core.h>
 #include <sound/jack.h>
@@ -3755 +3756 @@
         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 
-        for (i = 0; i < HDA_MAX_COMPONENTS; i++)
-                if (spec->comps[i].resume_hook)
-                        spec->comps[i].resume_hook(spec->comps[i].dev);
-
         return 0;
 
@@ -4680 +4677 @@
 {
         //NOT_USED struct alc_spec *spec = codec->spec;
-        int i;
 
 #ifndef TARGET_OS2
@@ -4686 +4682 @@
                 alc5505_dsp_suspend(codec);
 
-        for (i = 0; i < HDA_MAX_COMPONENTS; i++)
-                if (spec->comps[i].suspend_hook)
-                        spec->comps[i].suspend_hook(spec->comps[i].dev);
 #endif
         return alc_suspend(codec);
@@ -4696 +4689 @@
 {
         struct alc_spec *spec = codec->spec;
-        int i;
 
         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
@@ -7364 +7356 @@
         struct hda_codec *cdc = dev_to_hda_codec(dev);
         struct alc_spec *spec = cdc->spec;
-        int ret, i;
-
-        ret = component_bind_all(dev, spec->comps);
-        if (ret)
-                return ret;
-
-        if (snd_hdac_is_power_on(&cdc->core)) {
-                codec_dbg(cdc, "Resuming after bind.\n");
-                for (i = 0; i < HDA_MAX_COMPONENTS; i++)
-                        if (spec->comps[i].resume_hook)
-                                spec->comps[i].resume_hook(spec->comps[i].dev);
-        }
-
-        return 0;
+
+        return component_bind_all(dev, spec->comps);
 }
 
@@ -7405 +7385 @@
 }
 
+struct cs35l41_dev_name {
+        const char *bus;
+        const char *hid;
+        int index;
+};
+
+/* match the device name in a slightly relaxed manner */
+static int comp_match_cs35l41_dev_name(struct device *dev, void *data)
+{
+        struct cs35l41_dev_name *p = data;
+        const char *d = dev_name(dev);
+        int n = strlen(p->bus);
+        char tmp[32];
+
+        /* check the bus name */
+        if (strncmp(d, p->bus, n))
+                return 0;
+        /* skip the bus number */
+        if (isdigit(d[n]))
+                n++;
+        /* the rest must be exact matching */
+        snprintf(tmp, sizeof(tmp), "-%s:00-cs35l41-hda.%d", p->hid, p->index);
+        return !strcmp(d + n, tmp);
+}
+
 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
                                   const char *hid, int count)
@@ -7410 +7415 @@
         struct device *dev = hda_codec_dev(cdc);
         struct alc_spec *spec = cdc->spec;
-        char *name;
+        struct cs35l41_dev_name *rec;
         int ret, i;
 
@@ -7416 +7421 @@
         case HDA_FIXUP_ACT_PRE_PROBE:
                 for (i = 0; i < count; i++) {
-                        name = devm_kasprintf(dev, GFP_KERNEL,
-                                              "%s-%s:00-cs35l41-hda.%d", bus, hid, i);
-                        if (!name)
+                        rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
+                        if (!rec)
                                 return;
+                        rec->bus = bus;
+                        rec->hid = hid;
+                        rec->index = i;
                         spec->comps[i].codec = cdc;
-                        component_match_add(dev, &spec->match, component_compare_dev_name, name);
+                        component_match_add(dev, &spec->match,
+                                            comp_match_cs35l41_dev_name, rec);
                 }
                 ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
@@ -7439 +7447 @@
 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
 {
-        cs35l41_generic_fixup(codec, action, "spi0", "CSC3551", 2);
-}
-
-static void cs35l41_fixup_spi1_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
-{
-        cs35l41_generic_fixup(codec, action, "spi1", "CSC3551", 2);
+        cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 2);
 }
 
 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
 {
-        cs35l41_generic_fixup(codec, action, "spi0", "CSC3551", 4);
+        cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 4);
 }
 
@@ -7838 +7841 @@
         ALC245_FIXUP_CS35L41_SPI_2,
         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
-        ALC245_FIXUP_CS35L41_SPI1_2,
-        ALC245_FIXUP_CS35L41_SPI1_2_HP_GPIO_LED,
         ALC245_FIXUP_CS35L41_SPI_4,
         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
@@ -10007 +10008 @@
                 .type = HDA_FIXUP_FUNC,
                 .v.func = cs35l41_fixup_spi_two,
-                .chained = true,
-                .chain_id = ALC285_FIXUP_HP_GPIO_LED,
-        },
-        [ALC245_FIXUP_CS35L41_SPI1_2] = {
-                .type = HDA_FIXUP_FUNC,
-                .v.func = cs35l41_fixup_spi1_two,
-        },
-        [ALC245_FIXUP_CS35L41_SPI1_2_HP_GPIO_LED] = {
-                .type = HDA_FIXUP_FUNC,
-                .v.func = cs35l41_fixup_spi1_two,
                 .chained = true,
                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
@@ -10387 +10378 @@
         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(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI1_2_HP_GPIO_LED),
+         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
@@ -10440 +10431 @@
         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
+        SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
@@ -10471 +10463 @@
         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
+        SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
+        SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
@@ -10644 +10638 @@
         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(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),