Changeset 772 for GPL/trunk/alsa-kernel/hda

Timestamp:

Apr 19, 2025, 8:08:37 PM (7 months ago)

Author:

David Azarewicz

Message:

Merge in changes from 6.6-LTS branch.
Fixed additional 25+ problems.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• alsa-kernel/hda/Makefile (modified) (1 diff)
• alsa-kernel/hda/ext/hdac_ext_bus.c (modified) (1 diff)
• alsa-kernel/hda/ext/hdac_ext_controller.c (modified) (16 diffs)
• alsa-kernel/hda/ext/hdac_ext_stream.c (modified) (17 diffs)
• alsa-kernel/hda/hdac_bus.c (modified) (1 diff)
• alsa-kernel/hda/hdac_component.c (copied) (copied from GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_component.c ) (1 diff)
• alsa-kernel/hda/hdac_controller.c (modified) (3 diffs)
• alsa-kernel/hda/hdac_device.c (modified) (3 diffs)
• alsa-kernel/hda/hdac_i915.c (copied) (copied from GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_i915.c )
• alsa-kernel/hda/hdac_regmap.c (modified) (4 diffs)
• alsa-kernel/hda/hdac_stream.c (modified) (25 diffs)
• alsa-kernel/hda/hdmi_chmap.c (modified) (3 diffs)
• alsa-kernel/hda/trace.h (modified) (3 diffs)

GPL/trunk/alsa-kernel/hda/Makefile

@@ -13 +13 @@
 #
 #===================================================================
-FILES = hdac_device.obj array.obj hdac_stream.obj hdac_controller.obj hdac_bus.obj hda_bus_type.obj hdac_regmap.obj hdmi_chmap.obj
+FILES = hdac_device.obj array.obj hdac_stream.obj hdac_controller.obj hdac_bus.obj hda_bus_type.obj hdac_regmap.obj hdmi_chmap.obj hdac_component.obj 
+# hdac_i915.obj
 
 TARGET = hdac

GPL/trunk/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/trunk/alsa-kernel/hda/ext/hdac_ext_controller.c

@@ -14 +14 @@
 #include <sound/hda_register.h>
 #include <sound/hdaudio_ext.h>
-
-/*
- * maximum HDAC capablities we should parse to avoid endless looping:
- * currently we have 4 extended caps, so this is future proof for now.
- * extend when this limit is seen meeting in real HW
- */
-#define HDAC_MAX_CAPS 10
 
 /*
@@ -116 +109 @@
 
 /**
- * snd_hdac_link_free_all- free hdac extended link objects
- *
- * @bus: the pointer to HDAC bus object
- */
-
-void snd_hdac_link_free_all(struct hdac_bus *bus)
-{
-        struct hdac_ext_link *l;
+ * snd_hdac_ext_link_free_all- free hdac extended link objects
+ *
+ * @bus: the pointer to HDAC bus object
+ */
+
+void snd_hdac_ext_link_free_all(struct hdac_bus *bus)
+{
+        struct hdac_ext_link *hlink;
 
         while (!list_empty(&bus->hlink_list)) {
-                l = list_first_entry(&bus->hlink_list, struct hdac_ext_link, list);
-                list_del(&l->list);
-                kfree(l);
-        }
-}
-EXPORT_SYMBOL_GPL(snd_hdac_link_free_all);
-
-/**
- * snd_hdac_ext_bus_get_link - get link based on codec name
+                hlink = list_first_entry(&bus->hlink_list, struct hdac_ext_link, list);
+                list_del(&hlink->list);
+                kfree(hlink);
+        }
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_link_free_all);
+
+/**
+ * snd_hdac_ext_bus_get_hlink_by_addr - get hlink at specified address
+ * @bus: hlink's parent bus device
+ * @addr: codec device address
+ *
+ * Returns hlink object or NULL if matching hlink is not found.
+ */
+struct hdac_ext_link *snd_hdac_ext_bus_get_hlink_by_addr(struct hdac_bus *bus, int addr)
+{
+        struct hdac_ext_link *hlink;
+
+        list_for_each_entry(hlink, &bus->hlink_list, list)
+                if (hlink->lsdiid & (0x1 << addr))
+                        return hlink;
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_hlink_by_addr);
+
+/**
+ * snd_hdac_ext_bus_get_hlink_by_name - get hlink based on codec name
  * @bus: the pointer to HDAC bus object
  * @codec_name: codec name
  */
-struct hdac_ext_link *snd_hdac_ext_bus_get_link(struct hdac_bus *bus,
-                                                 const char *codec_name)
-{
-        int i;
-        struct hdac_ext_link *hlink = NULL;
+struct hdac_ext_link *snd_hdac_ext_bus_get_hlink_by_name(struct hdac_bus *bus,
+                                                         const char *codec_name)
+{
         int bus_idx, addr;
 
@@ -152 +161 @@
                 return NULL;
 
-        list_for_each_entry(hlink, &bus->hlink_list, list) {
-                for (i = 0; i < HDA_MAX_CODECS; i++) {
-                        if (hlink->lsdiid & (0x1 << addr))
-                                return hlink;
-                }
-        }
-
-        return NULL;
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_link);
-
-static int check_hdac_link_power_active(struct hdac_ext_link *link, bool enable)
+        return snd_hdac_ext_bus_get_hlink_by_addr(bus, addr);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_get_hlink_by_name);
+
+static int check_hdac_link_power_active(struct hdac_ext_link *hlink, bool enable)
 {
         int timeout;
         u32 val;
-        int mask = (1 << AZX_MLCTL_CPA_SHIFT);
+        int mask = (1 << AZX_ML_LCTL_CPA_SHIFT);
 
         udelay(3);
@@ -173 +175 @@
 
         do {
-                val = readl(link->ml_addr + AZX_REG_ML_LCTL);
+                val = readl(hlink->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;
                 }
@@ -189 +191 @@
 /**
  * snd_hdac_ext_bus_link_power_up -power up hda link
- * @link: HD-audio extended link
- */
-int snd_hdac_ext_bus_link_power_up(struct hdac_ext_link *link)
-{
-        snd_hdac_updatel(link->ml_addr, AZX_REG_ML_LCTL,
-                         AZX_MLCTL_SPA, AZX_MLCTL_SPA);
-
-        return check_hdac_link_power_active(link, true);
+ * @hlink: HD-audio extended link
+ */
+int snd_hdac_ext_bus_link_power_up(struct hdac_ext_link *hlink)
+{
+        snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL,
+                         AZX_ML_LCTL_SPA, AZX_ML_LCTL_SPA);
+
+        return check_hdac_link_power_active(hlink, true);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_up);
@@ -202 +204 @@
 /**
  * snd_hdac_ext_bus_link_power_down -power down hda link
- * @link: HD-audio extended link
- */
-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);
-
-        return check_hdac_link_power_active(link, false);
+ * @hlink: HD-audio extended link
+ */
+int snd_hdac_ext_bus_link_power_down(struct hdac_ext_link *hlink)
+{
+        snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL, AZX_ML_LCTL_SPA, 0);
+
+        return check_hdac_link_power_active(hlink, false);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_down);
@@ -222 +224 @@
 
         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);
-                ret = check_hdac_link_power_active(hlink, true);
+                ret = snd_hdac_ext_bus_link_power_up(hlink);
                 if (ret < 0)
                         return ret;
@@ -243 +243 @@
 
         list_for_each_entry(hlink, &bus->hlink_list, list) {
-                snd_hdac_updatel(hlink->ml_addr, AZX_REG_ML_LCTL,
-                                 AZX_MLCTL_SPA, 0);
-                ret = check_hdac_link_power_active(hlink, false);
+                ret = snd_hdac_ext_bus_link_power_down(hlink);
                 if (ret < 0)
                         return ret;
@@ -254 +252 @@
 EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_power_down_all);
 
+/**
+ * snd_hdac_ext_bus_link_set_stream_id - maps stream id to link output
+ * @link: HD-audio ext link to set up
+ * @stream: stream id
+ */
+void snd_hdac_ext_bus_link_set_stream_id(struct hdac_ext_link *link,
+                                         int stream)
+{
+        snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 1 << stream);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_set_stream_id);
+
+/**
+ * snd_hdac_ext_bus_link_clear_stream_id - maps stream id to link output
+ * @link: HD-audio ext link to set up
+ * @stream: stream id
+ */
+void snd_hdac_ext_bus_link_clear_stream_id(struct hdac_ext_link *link,
+                                           int stream)
+{
+        snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 0);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_bus_link_clear_stream_id);
+
 int snd_hdac_ext_bus_link_get(struct hdac_bus *bus,
-                                struct hdac_ext_link *link)
+                                struct hdac_ext_link *hlink)
 {
         unsigned long codec_mask;
@@ -266 +288 @@
          * as well, also check the dma status and trigger that
          */
-        if (++link->ref_count == 1) {
+        if (++hlink->ref_count == 1) {
                 if (!bus->cmd_dma_state) {
                         snd_hdac_bus_init_cmd_io(bus);
@@ -272 +294 @@
                 }
 
-                ret = snd_hdac_ext_bus_link_power_up(link);
+                ret = snd_hdac_ext_bus_link_power_up(hlink);
 
                 /*
                  * clear the register to invalidate all the output streams
                  */
-                snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV,
-                                 ML_LOSIDV_STREAM_MASK, 0);
+                snd_hdac_updatew(hlink->ml_addr, AZX_REG_ML_LOSIDV,
+                                 AZX_ML_LOSIDV_STREAM_MASK, 0);
                 /*
                  *  wait for 521usec for codec to report status
@@ -297 +319 @@
 
 int snd_hdac_ext_bus_link_put(struct hdac_bus *bus,
-                                struct hdac_ext_link *link)
+                              struct hdac_ext_link *hlink)
 {
         int ret = 0;
-        struct hdac_ext_link *hlink;
+        struct hdac_ext_link *hlink_tmp;
         bool link_up = false;
 
@@ -309 +331 @@
          * so power down this link as well
          */
-        if (--link->ref_count == 0) {
-                ret = snd_hdac_ext_bus_link_power_down(link);
+        if (--hlink->ref_count == 0) {
+                ret = snd_hdac_ext_bus_link_power_down(hlink);
 
                 /*
@@ -316 +338 @@
                  * cmd dma as well
                  */
-                list_for_each_entry(hlink, &bus->hlink_list, list) {
-                        if (hlink->ref_count) {
+                list_for_each_entry(hlink_tmp, &bus->hlink_list, list) {
+                        if (hlink_tmp->ref_count) {
                                 link_up = true;
                                 break;
@@ -338 +360 @@
         const char *devname = dev_name(&codec->dev);
         struct hdac_ext_link *hlink =
-                snd_hdac_ext_bus_get_link(codec->bus, devname);
+                snd_hdac_ext_bus_get_hlink_by_name(codec->bus, devname);
 
         if (hlink)
@@ -348 +370 @@
         const char *devname = dev_name(&codec->dev);
         struct hdac_ext_link *hlink =
-                snd_hdac_ext_bus_get_link(codec->bus, devname);
+                snd_hdac_ext_bus_get_hlink_by_name(codec->bus, devname);
 
         if (hlink)

GPL/trunk/alsa-kernel/hda/ext/hdac_ext_stream.c

@@ -15 +15 @@
 #include <sound/hda_register.h>
 #include <sound/hdaudio_ext.h>
+#include <sound/compress_driver.h>
 
 /**
  * snd_hdac_ext_stream_init - initialize each stream (aka device)
  * @bus: HD-audio core bus
- * @stream: HD-audio ext core stream object to initialize
+ * @hext_stream: HD-audio ext core stream object to initialize
  * @idx: stream index number
  * @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE)
@@ -27 +28 @@
  * invoke hdac stream initialization routine
  */
-void snd_hdac_ext_stream_init(struct hdac_bus *bus,
-                                struct hdac_ext_stream *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) {
-                stream->pphc_addr = bus->ppcap + AZX_PPHC_BASE +
+                hext_stream->pphc_addr = bus->ppcap + AZX_PPHC_BASE +
                                 AZX_PPHC_INTERVAL * idx;
 
-                stream->pplc_addr = bus->ppcap + AZX_PPLC_BASE +
+                hext_stream->pplc_addr = bus->ppcap + AZX_PPLC_BASE +
                                 AZX_PPLC_MULTI * bus->num_streams +
                                 AZX_PPLC_INTERVAL * idx;
         }
 
-        if (bus->spbcap) {
-                stream->spib_addr = bus->spbcap + AZX_SPB_BASE +
-                                        AZX_SPB_INTERVAL * idx +
-                                        AZX_SPB_SPIB;
-
-                stream->fifo_addr = bus->spbcap + AZX_SPB_BASE +
-                                        AZX_SPB_INTERVAL * idx +
-                                        AZX_SPB_MAXFIFO;
-        }
-
-        if (bus->drsmcap)
-                stream->dpibr_addr = bus->drsmcap + AZX_DRSM_BASE +
-                                        AZX_DRSM_INTERVAL * idx;
-
-        stream->decoupled = false;
-        snd_hdac_stream_init(bus, &stream->hstream, idx, direction, tag);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init);
+        hext_stream->decoupled = false;
+        snd_hdac_stream_init(bus, &hext_stream->hstream, idx, direction, tag);
+}
 
 /**
@@ -68 +54 @@
  */
 int snd_hdac_ext_stream_init_all(struct hdac_bus *bus, int start_idx,
-                int num_stream, int dir)
+                                 int num_stream, int dir)
 {
         int stream_tag = 0;
@@ -74 +60 @@
 
         for (i = 0; i < num_stream; i++) {
-                struct hdac_ext_stream *stream =
-                                kzalloc(sizeof(*stream), GFP_KERNEL);
-                if (!stream)
+                struct hdac_ext_stream *hext_stream =
+                                kzalloc(sizeof(*hext_stream), GFP_KERNEL);
+                if (!hext_stream)
                         return -ENOMEM;
                 tag = ++stream_tag;
-                snd_hdac_ext_stream_init(bus, stream, idx, dir, tag);
+                snd_hdac_ext_stream_init(bus, hext_stream, idx, dir, tag);
                 idx++;
         }
@@ -89 +75 @@
 
 /**
- * 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;
-        struct hdac_ext_stream *stream;
+        struct hdac_ext_stream *hext_stream;
 
         list_for_each_entry_safe(s, _s, &bus->stream_list, list) {
-                stream = stream_to_hdac_ext_stream(s);
-                snd_hdac_ext_stream_decouple(bus, stream, false);
+                hext_stream = stream_to_hdac_ext_stream(s);
+                snd_hdac_ext_stream_decouple(bus, hext_stream, false);
                 list_del(&s->list);
-                kfree(stream);
-        }
-}
-EXPORT_SYMBOL_GPL(snd_hdac_stream_free_all);
+                kfree(hext_stream);
+        }
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_free_all);
 
 void snd_hdac_ext_stream_decouple_locked(struct hdac_bus *bus,
-                                         struct hdac_ext_stream *stream,
+                                         struct hdac_ext_stream *hext_stream,
                                          bool decouple)
 {
-        struct hdac_stream *hstream = &stream->hstream;
+        struct hdac_stream *hstream = &hext_stream->hstream;
         u32 val;
         int mask = AZX_PPCTL_PROCEN(hstream->index);
@@ -122 +108 @@
                 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL, mask, 0);
 
-        stream->decoupled = decouple;
+        hext_stream->decoupled = decouple;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple_locked);
@@ -129 +115 @@
  * snd_hdac_ext_stream_decouple - decouple the hdac stream
  * @bus: HD-audio core bus
- * @stream: HD-audio ext core stream object to initialize
+ * @hext_stream: HD-audio ext core stream object to initialize
  * @decouple: flag to decouple
  */
 void snd_hdac_ext_stream_decouple(struct hdac_bus *bus,
-                                  struct hdac_ext_stream *stream, bool decouple)
+                                  struct hdac_ext_stream *hext_stream, bool decouple)
 {
         spin_lock_irq(&bus->reg_lock);
-        snd_hdac_ext_stream_decouple_locked(bus, stream, decouple);
+        snd_hdac_ext_stream_decouple_locked(bus, hext_stream, decouple);
         spin_unlock_irq(&bus->reg_lock);
 }
@@ -142 +128 @@
 
 /**
- * snd_hdac_ext_link_stream_start - start a stream
- * @stream: HD-audio ext core stream to start
- */
-void snd_hdac_ext_link_stream_start(struct hdac_ext_stream *stream)
-{
-        snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL,
+ * snd_hdac_ext_stream_start - start a stream
+ * @hext_stream: HD-audio ext core stream to start
+ */
+void snd_hdac_ext_stream_start(struct hdac_ext_stream *hext_stream)
+{
+        snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL,
                          AZX_PPLCCTL_RUN, AZX_PPLCCTL_RUN);
 }
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_start);
-
-/**
- * snd_hdac_ext_link_stream_clear - stop a stream DMA
- * @stream: HD-audio ext core stream to stop
- */
-void snd_hdac_ext_link_stream_clear(struct hdac_ext_stream *stream)
-{
-        snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL, AZX_PPLCCTL_RUN, 0);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_clear);
-
-/**
- * snd_hdac_ext_link_stream_reset - reset a stream
- * @stream: HD-audio ext core stream to reset
- */
-void snd_hdac_ext_link_stream_reset(struct hdac_ext_stream *stream)
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_start);
+
+/**
+ * snd_hdac_ext_stream_clear - stop a stream DMA
+ * @hext_stream: HD-audio ext core stream to stop
+ */
+void snd_hdac_ext_stream_clear(struct hdac_ext_stream *hext_stream)
+{
+        snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL, AZX_PPLCCTL_RUN, 0);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_clear);
+
+/**
+ * snd_hdac_ext_stream_reset - reset a stream
+ * @hext_stream: HD-audio ext core stream to reset
+ */
+void snd_hdac_ext_stream_reset(struct hdac_ext_stream *hext_stream)
 {
         unsigned char val;
         int timeout;
 
-        snd_hdac_ext_link_stream_clear(stream);
-
-        snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL,
+        snd_hdac_ext_stream_clear(hext_stream);
+
+        snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL,
                          AZX_PPLCCTL_STRST, AZX_PPLCCTL_STRST);
         udelay(3);
         timeout = 50;
         do {
-                val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) &
+                val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL) &
                                 AZX_PPLCCTL_STRST;
                 if (val)
@@ -185 +171 @@
         } while (--timeout);
         val &= ~AZX_PPLCCTL_STRST;
-        writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);
+        writel(val, hext_stream->pplc_addr + AZX_REG_PPLCCTL);
         udelay(3);
 
@@ -191 +177 @@
         /* waiting for hardware to report that the stream is out of reset */
         do {
-                val = readl(stream->pplc_addr + AZX_REG_PPLCCTL) & AZX_PPLCCTL_STRST;
+                val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL) & AZX_PPLCCTL_STRST;
                 if (!val)
                         break;
@@ -198 +184 @@
 
 }
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_reset);
-
-/**
- * snd_hdac_ext_link_stream_setup -  set up the SD for streaming
- * @stream: HD-audio ext core stream to set up
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_reset);
+
+/**
+ * snd_hdac_ext_stream_setup -  set up the SD for streaming
+ * @hext_stream: HD-audio ext core stream to set up
  * @fmt: stream format
  */
-int snd_hdac_ext_link_stream_setup(struct hdac_ext_stream *stream, int fmt)
-{
-        struct hdac_stream *hstream = &stream->hstream;
+int snd_hdac_ext_stream_setup(struct hdac_ext_stream *hext_stream, int fmt)
+{
+        struct hdac_stream *hstream = &hext_stream->hstream;
         unsigned int val;
 
         /* make sure the run bit is zero for SD */
-        snd_hdac_ext_link_stream_clear(stream);
+        snd_hdac_ext_stream_clear(hext_stream);
         /* program the stream_tag */
-        val = readl(stream->pplc_addr + AZX_REG_PPLCCTL);
+        val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL);
         val = (val & ~AZX_PPLCCTL_STRM_MASK) |
                 (hstream->stream_tag << AZX_PPLCCTL_STRM_SHIFT);
-        writel(val, stream->pplc_addr + AZX_REG_PPLCCTL);
+        writel(val, hext_stream->pplc_addr + AZX_REG_PPLCCTL);
 
         /* program the stream format */
-        writew(fmt, stream->pplc_addr + AZX_REG_PPLCFMT);
+        writew(fmt, hext_stream->pplc_addr + AZX_REG_PPLCFMT);
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_stream_setup);
-
-/**
- * snd_hdac_ext_link_set_stream_id - maps stream id to link output
- * @link: HD-audio ext link to set up
- * @stream: stream id
- */
-void snd_hdac_ext_link_set_stream_id(struct hdac_ext_link *link,
-                                 int stream)
-{
-        snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 1 << stream);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_set_stream_id);
-
-/**
- * snd_hdac_ext_link_clear_stream_id - maps stream id to link output
- * @link: HD-audio ext link to set up
- * @stream: stream id
- */
-void snd_hdac_ext_link_clear_stream_id(struct hdac_ext_link *link,
-                                 int stream)
-{
-        snd_hdac_updatew(link->ml_addr, AZX_REG_ML_LOSIDV, (1 << stream), 0);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_link_clear_stream_id);
+EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_setup);
 
 static struct hdac_ext_stream *
-hdac_ext_link_stream_assign(struct hdac_bus *bus,
+hdac_ext_link_dma_stream_assign(struct hdac_bus *bus,
                                 struct snd_pcm_substream *substream)
 {
         struct hdac_ext_stream *res = NULL;
-        struct hdac_stream *stream = NULL;
+        struct hdac_stream *hstream = NULL;
 
         if (!bus->ppcap) {
@@ -262 +224 @@
 
         spin_lock_irq(&bus->reg_lock);
-        list_for_each_entry(stream, &bus->stream_list, list) {
-                struct hdac_ext_stream *hstream = container_of(stream,
-                                                struct hdac_ext_stream,
-                                                hstream);
-                if (stream->direction != substream->stream)
+        list_for_each_entry(hstream, &bus->stream_list, list) {
+                struct hdac_ext_stream *hext_stream = container_of(hstream,
+                                                                 struct hdac_ext_stream,
+                                                                 hstream);
+                if (hstream->direction != substream->stream)
                         continue;
 
-                /* check if decoupled stream and not in use is available */
-                if (hstream->decoupled && !hstream->link_locked) {
-                        res = hstream;
+                /* check if link stream is available */
+                if (!hext_stream->link_locked) {
+                        res = hext_stream;
                         break;
                 }
 
-                if (!hstream->link_locked) {
-                        snd_hdac_ext_stream_decouple_locked(bus, hstream, true);
-                        res = hstream;
-                        break;
-                }
         }
         if (res) {
+                snd_hdac_ext_stream_decouple_locked(bus, res, true);
                 res->link_locked = 1;
                 res->link_substream = substream;
@@ -290 +248 @@
 
 static struct hdac_ext_stream *
-hdac_ext_host_stream_assign(struct hdac_bus *bus,
+hdac_ext_host_dma_stream_assign(struct hdac_bus *bus,
                                 struct snd_pcm_substream *substream)
 {
         struct hdac_ext_stream *res = NULL;
-        struct hdac_stream *stream = NULL;
+        struct hdac_stream *hstream = NULL;
 
         if (!bus->ppcap) {
@@ -302 +260 @@
 
         spin_lock_irq(&bus->reg_lock);
-        list_for_each_entry(stream, &bus->stream_list, list) {
-                struct hdac_ext_stream *hstream = container_of(stream,
-                                                struct hdac_ext_stream,
-                                                hstream);
-                if (stream->direction != substream->stream)
+        list_for_each_entry(hstream, &bus->stream_list, list) {
+                struct hdac_ext_stream *hext_stream = container_of(hstream,
+                                                                 struct hdac_ext_stream,
+                                                                 hstream);
+                if (hstream->direction != substream->stream)
                         continue;
 
-                if (!stream->opened) {
-                        if (!hstream->decoupled)
-                                snd_hdac_ext_stream_decouple_locked(bus, hstream, true);
-                        res = hstream;
+                if (!hstream->opened) {
+                        res = hext_stream;
                         break;
                 }
         }
         if (res) {
+                snd_hdac_ext_stream_decouple_locked(bus, res, true);
                 res->hstream.opened = 1;
                 res->hstream.running = 0;
@@ -347 +304 @@
                                            int type)
 {
-        struct hdac_ext_stream *hstream = NULL;
-        struct hdac_stream *stream = NULL;
+        struct hdac_ext_stream *hext_stream = NULL;
+        struct hdac_stream *hstream = NULL;
 
         switch (type) {
         case HDAC_EXT_STREAM_TYPE_COUPLED:
-                stream = snd_hdac_stream_assign(bus, substream);
-                if (stream)
-                        hstream = container_of(stream,
-                                        struct hdac_ext_stream, hstream);
-                return hstream;
+                hstream = snd_hdac_stream_assign(bus, substream);
+                if (hstream)
+                        hext_stream = container_of(hstream,
+                                                   struct hdac_ext_stream,
+                                                   hstream);
+                return hext_stream;
 
         case HDAC_EXT_STREAM_TYPE_HOST:
-                return hdac_ext_host_stream_assign(bus, substream);
+                return hdac_ext_host_dma_stream_assign(bus, substream);
 
         case HDAC_EXT_STREAM_TYPE_LINK:
-                return hdac_ext_link_stream_assign(bus, substream);
+                return hdac_ext_link_dma_stream_assign(bus, substream);
 
         default:
@@ -372 +330 @@
 /**
  * snd_hdac_ext_stream_release - release the assigned stream
- * @stream: HD-audio ext core stream to release
+ * @hext_stream: HD-audio ext core stream to release
  * @type: type of stream (coupled, host or link stream)
  *
  * Release the stream that has been assigned by snd_hdac_ext_stream_assign().
  */
-void snd_hdac_ext_stream_release(struct hdac_ext_stream *stream, int type)
-{
-        struct hdac_bus *bus = stream->hstream.bus;
+void snd_hdac_ext_stream_release(struct hdac_ext_stream *hext_stream, int type)
+{
+        struct hdac_bus *bus = hext_stream->hstream.bus;
 
         switch (type) {
         case HDAC_EXT_STREAM_TYPE_COUPLED:
-                snd_hdac_stream_release(&stream->hstream);
+                snd_hdac_stream_release(&hext_stream->hstream);
                 break;
 
         case HDAC_EXT_STREAM_TYPE_HOST:
                 spin_lock_irq(&bus->reg_lock);
-                if (stream->decoupled && !stream->link_locked)
-                        snd_hdac_ext_stream_decouple_locked(bus, stream, false);
+                /* 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(&stream->hstream);
                 break;
 
         case HDAC_EXT_STREAM_TYPE_LINK:
                 spin_lock_irq(&bus->reg_lock);
-                if (stream->decoupled && !stream->hstream.opened)
-                        snd_hdac_ext_stream_decouple_locked(bus, stream, false);
-                stream->link_locked = 0;
-                stream->link_substream = NULL;
+                /* 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;
+                hext_stream->link_substream = NULL;
                 spin_unlock_irq(&bus->reg_lock);
                 break;
@@ -411 +371 @@
 
 /**
- * snd_hdac_ext_stream_spbcap_enable - enable SPIB for a stream
- * @bus: HD-audio core bus
- * @enable: flag to enable/disable SPIB
- * @index: stream index for which SPIB need to be enabled
- */
-void snd_hdac_ext_stream_spbcap_enable(struct hdac_bus *bus,
-                                 bool enable, int index)
-{
-        u32 mask = 0;
-
-        if (!bus->spbcap) {
-                dev_err(bus->dev, "Address of SPB capability is NULL\n");
-                return;
-        }
-
-        mask |= (1 << index);
-
-        if (enable)
-                snd_hdac_updatel(bus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, mask);
-        else
-                snd_hdac_updatel(bus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, 0);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_spbcap_enable);
-
-/**
- * snd_hdac_ext_stream_set_spib - sets the spib value of a stream
- * @bus: HD-audio core bus
- * @stream: hdac_ext_stream
- * @value: spib value to set
- */
-int snd_hdac_ext_stream_set_spib(struct hdac_bus *bus,
-                                 struct hdac_ext_stream *stream, u32 value)
-{
-
-        if (!bus->spbcap) {
-                dev_err(bus->dev, "Address of SPB capability is NULL\n");
-                return -EINVAL;
-        }
-
-        writel(value, stream->spib_addr);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_set_spib);
-
-/**
- * snd_hdac_ext_stream_get_spbmaxfifo - gets the spib value of a stream
- * @bus: HD-audio core bus
- * @stream: hdac_ext_stream
- *
- * Return maxfifo for the stream
- */
-int snd_hdac_ext_stream_get_spbmaxfifo(struct hdac_bus *bus,
-                                 struct hdac_ext_stream *stream)
-{
-
-        if (!bus->spbcap) {
-                dev_err(bus->dev, "Address of SPB capability is NULL\n");
-                return -EINVAL;
-        }
-
-        return readl(stream->fifo_addr);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_get_spbmaxfifo);
-
-
-/**
- * snd_hdac_ext_stop_streams - stop all stream if running
- * @bus: HD-audio core bus
- */
-void snd_hdac_ext_stop_streams(struct hdac_bus *bus)
-{
-        struct hdac_stream *stream;
-
-        if (bus->chip_init) {
-                list_for_each_entry(stream, &bus->stream_list, list)
-                        snd_hdac_stream_stop(stream);
-                snd_hdac_bus_stop_chip(bus);
-        }
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stop_streams);
-
-/**
- * snd_hdac_ext_stream_drsm_enable - enable DMA resume for a stream
- * @bus: HD-audio core bus
- * @enable: flag to enable/disable DRSM
- * @index: stream index for which DRSM need to be enabled
- */
-void snd_hdac_ext_stream_drsm_enable(struct hdac_bus *bus,
-                                bool enable, int index)
-{
-        u32 mask = 0;
-
-        if (!bus->drsmcap) {
-                dev_err(bus->dev, "Address of DRSM capability is NULL\n");
-                return;
-        }
-
-        mask |= (1 << index);
-
-        if (enable)
-                snd_hdac_updatel(bus->drsmcap, AZX_REG_DRSM_CTL, mask, mask);
-        else
-                snd_hdac_updatel(bus->drsmcap, AZX_REG_DRSM_CTL, mask, 0);
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_drsm_enable);
-
-/**
- * snd_hdac_ext_stream_set_dpibr - sets the dpibr value of a stream
- * @bus: HD-audio core bus
- * @stream: hdac_ext_stream
- * @value: dpib value to set
- */
-int snd_hdac_ext_stream_set_dpibr(struct hdac_bus *bus,
-                                 struct hdac_ext_stream *stream, u32 value)
-{
-
-        if (!bus->drsmcap) {
-                dev_err(bus->dev, "Address of DRSM capability is NULL\n");
-                return -EINVAL;
-        }
-
-        writel(value, stream->dpibr_addr);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_set_dpibr);
-
-/**
- * snd_hdac_ext_stream_set_lpib - sets the lpib value of a stream
- * @stream: hdac_ext_stream
- * @value: lpib value to set
- */
-int snd_hdac_ext_stream_set_lpib(struct hdac_ext_stream *stream, u32 value)
-{
-        snd_hdac_stream_writel(&stream->hstream, SD_LPIB, value);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_set_lpib);
+ * snd_hdac_ext_cstream_assign - assign a host stream for compress
+ * @bus: HD-audio core bus
+ * @cstream: Compress stream to assign
+ *
+ * Assign an unused host stream for the given compress stream.
+ * If no stream is free, NULL is returned. Stream is decoupled
+ * before assignment.
+ */
+struct hdac_ext_stream *snd_hdac_ext_cstream_assign(struct hdac_bus *bus,
+                                                    struct snd_compr_stream *cstream)
+{
+        struct hdac_ext_stream *res = NULL;
+        struct hdac_stream *hstream;
+
+        spin_lock_irq(&bus->reg_lock);
+        list_for_each_entry(hstream, &bus->stream_list, list) {
+                struct hdac_ext_stream *hext_stream = stream_to_hdac_ext_stream(hstream);
+
+                if (hstream->direction != cstream->direction)
+                        continue;
+
+                if (!hstream->opened) {
+                        res = hext_stream;
+                        break;
+                }
+        }
+
+        if (res) {
+                snd_hdac_ext_stream_decouple_locked(bus, res, true);
+                res->hstream.opened = 1;
+                res->hstream.running = 0;
+                res->hstream.cstream = cstream;
+        }
+        spin_unlock_irq(&bus->reg_lock);
+
+        return res;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_ext_cstream_assign);

GPL/trunk/alsa-kernel/hda/hdac_bus.c

@@ -194 +194 @@
                         continue;
                 codec = bus->caddr_tbl[caddr & 0x0f];
-                if (!codec || !codec->dev.driver)
+                if (!codec || !codec->registered)
                         continue;
                 spin_unlock_irq(&bus->reg_lock);

GPL/trunk/alsa-kernel/hda/hdac_component.c

@@ -194 +194 @@
                 return ret;
 
+  #ifndef TARGET_OS2
         if (WARN_ON(!(acomp->dev && acomp->ops))) {
                 ret = -EINVAL;
                 goto out_unbind;
         }
+        #endif
 
         /* pin the module to avoid dynamic unbinding, but only if given */

GPL/trunk/alsa-kernel/hda/hdac_controller.c

@@ -80 +80 @@
         snd_hdac_chip_writew(bus, RINTCNT, 1);
         /* enable rirb dma and response irq */
-        snd_hdac_chip_writeb(bus, RIRBCTL, AZX_RBCTL_DMA_EN | AZX_RBCTL_IRQ_EN);
+        if (bus->not_use_interrupts)
+                snd_hdac_chip_writeb(bus, RIRBCTL, AZX_RBCTL_DMA_EN);
+        else
+                snd_hdac_chip_writeb(bus, RIRBCTL, AZX_RBCTL_DMA_EN | AZX_RBCTL_IRQ_EN);
         /* Accept unsolicited responses */
         snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_UNSOL, AZX_GCTL_UNSOL);
@@ -481 +484 @@
                 snd_hdac_stream_updateb(azx_dev, SD_CTL, SD_INT_MASK, 0);
 
-        /* disable SIE for all streams */
-        snd_hdac_chip_writeb(bus, INTCTL, 0);
-
-        /* disable controller CIE and GIE */
-        snd_hdac_chip_updatel(bus, INTCTL, AZX_INT_CTRL_EN | AZX_INT_GLOBAL_EN, 0);
+        /* disable SIE for all streams & disable controller CIE and GIE */
+        snd_hdac_chip_writel(bus, INTCTL, 0);
 }
 
@@ -588 +588 @@
                         snd_hdac_stream_writeb(azx_dev, SD_STS, SD_INT_MASK);
                         handled |= 1 << azx_dev->index;
-                        if (!azx_dev->substream || !azx_dev->running ||
-                            !(sd_status & SD_INT_COMPLETE))
+                        if ((!azx_dev->substream && !azx_dev->cstream) ||
+                            !azx_dev->running || !(sd_status & SD_INT_COMPLETE))
                                 continue;
                         if (ack)

GPL/trunk/alsa-kernel/hda/hdac_device.c

@@ -212 +212 @@
  * Returns the size of string, like snprintf(), or a negative error code.
  */
-int snd_hdac_codec_modalias(struct hdac_device *codec, char *buf, size_t size)
+int snd_hdac_codec_modalias(const struct hdac_device *codec, char *buf, size_t size)
 {
         return scnprintf(buf, size, "hdaudio:v%08Xr%08Xa%02X\n",
@@ -623 +623 @@
 #if 0 //fixme
         if (!atomic_inc_not_zero(&codec->in_pm)) {
-                int ret = pm_runtime_get_if_in_use(&codec->dev);
+                int ret = pm_runtime_get_if_active(&codec->dev, true);
                 if (!ret)
                         return -1;
@@ -660 +660 @@
 
 static const struct hda_vendor_id hda_vendor_ids[] = {
+        { 0x0014, "Loongson" },
         { 0x1002, "ATI" },
         { 0x1013, "Cirrus Logic" },

GPL/trunk/alsa-kernel/hda/hdac_regmap.c

@@ -18 +18 @@
 #include <linux/export.h>
 #include <linux/pm.h>
-#include <linux/pm_runtime.h>
 #include <sound/core.h>
 #include <sound/hdaudio.h>
@@ -359 +358 @@
         .readable_reg = hda_readable_reg,
         .volatile_reg = hda_volatile_reg,
+#ifndef TARGET_OS2
+        .cache_type = REGCACHE_MAPLE,
+#else
         .cache_type = REGCACHE_RBTREE,
+#endif
         .reg_read = hda_reg_read,
         .reg_write = hda_reg_write,
@@ -570 +573 @@
                                unsigned int mask, unsigned int val)
 {
+#ifndef TARGET_OS2
+        int err = 0;
+#else
         unsigned int orig;
         int err;
-
+#endif
         if (!codec->regmap)
                 return reg_raw_update(codec, reg, mask, val);
 
         mutex_lock(&codec->regmap_lock);
+#ifndef TARGET_OS2
+        /* Discard any updates to already initialised registers. */
+        if (!regcache_reg_cached(codec->regmap, reg))
+#else
         regcache_cache_only(codec->regmap, true);
         err = regmap_read(codec->regmap, reg, &orig);
         regcache_cache_only(codec->regmap, false);
         if (err < 0)
+#endif
                 err = regmap_update_bits(codec->regmap, reg, mask, val);
         mutex_unlock(&codec->regmap_lock);
@@ -614 +625 @@
 void snd_hdac_regmap_sync(struct hdac_device *codec)
 {
-        if (codec->regmap) {
-                mutex_lock(&codec->regmap_lock);
+        mutex_lock(&codec->regmap_lock);
+        if (codec->regmap)
                 regcache_sync(codec->regmap);
-                mutex_unlock(&codec->regmap_lock);
-        }
+        mutex_unlock(&codec->regmap_lock);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_regmap_sync);

GPL/trunk/alsa-kernel/hda/hdac_stream.c

@@ -8 +8 @@
 #include <linux/export.h>
 #include <linux/clocksource.h>
+#include <sound/compress_driver.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -19 +20 @@
 #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
@@ -76 +110 @@
         snd_hdac_dsp_lock_init(azx_dev);
         list_add_tail(&azx_dev->list, &bus->stream_list);
+
+        if (bus->spbcap) {
+                azx_dev->spib_addr = (void*)bus->spbcap + AZX_SPB_BASE +
+                                        AZX_SPB_INTERVAL * idx +
+                                        AZX_SPB_SPIB;
+
+                azx_dev->fifo_addr = (void*)bus->spbcap + AZX_SPB_BASE +
+                                        AZX_SPB_INTERVAL * idx +
+                                        AZX_SPB_MAXFIFO;
+        }
+
+        if (bus->drsmcap)
+                azx_dev->dpibr_addr = (void*)bus->drsmcap + AZX_DRSM_BASE +
+                                        AZX_DRSM_INTERVAL * idx;
 }
 EXPORT_SYMBOL_GPL(snd_hdac_stream_init);
@@ -82 +130 @@
  * snd_hdac_stream_start - start a stream
  * @azx_dev: HD-audio core stream to start
- * @fresh_start: false = wallclock timestamp relative to period wallclock
  *
  * Start a stream, set start_wallclk and set the running flag.
  */
-void snd_hdac_stream_start(struct hdac_stream *azx_dev, bool fresh_start)
+void snd_hdac_stream_start(struct hdac_stream *azx_dev)
 {
         struct hdac_bus *bus = azx_dev->bus;
@@ -94 +141 @@
 
         azx_dev->start_wallclk = snd_hdac_chip_readl(bus, WALLCLK);
-        if (!fresh_start)
-                azx_dev->start_wallclk -= azx_dev->period_wallclk;
 
         /* enable SIE */
@@ -111 +156 @@
         }
         /* set DMA start and interrupt mask */
-        snd_hdac_stream_updateb(azx_dev, SD_CTL,
+        if (bus->access_sdnctl_in_dword)
+                snd_hdac_stream_updatel(azx_dev, SD_CTL,
+                                0, SD_CTL_DMA_START | SD_INT_MASK);
+        else
+                snd_hdac_stream_updateb(azx_dev, SD_CTL,
                                 0, SD_CTL_DMA_START | SD_INT_MASK);
         azx_dev->running = true;
@@ -118 +167 @@
 
 /**
- * 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 +179 @@
         azx_dev->running = false;
 }
-EXPORT_SYMBOL_GPL(snd_hdac_stream_clear);
 
 /**
@@ -149 +197 @@
 
 /**
+ * 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
+ */
+void snd_hdac_stop_streams_and_chip(struct hdac_bus *bus)
+{
+        if (bus->chip_init) {
+                snd_hdac_stop_streams(bus);
+                snd_hdac_bus_stop_chip(bus);
+        }
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stop_streams_and_chip);
+
+/**
  * snd_hdac_stream_reset - reset a stream
  * @azx_dev: HD-audio core stream to reset
@@ -155 +229 @@
 {
         unsigned char val;
+#ifdef TARGET_OS2
         int timeout;
+#endif
         int dma_run_state;
 
@@ -163 +239 @@
 
         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;
@@ -171 +252 @@
                         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);
 
@@ -187 +272 @@
                         break;
         } while (--timeout);
-
+#endif
         /* reset first position - may not be synced with hw at this time */
         if (azx_dev->posbuf)
@@ -299 +384 @@
 
         /* make a non-zero unique key for the substream */
-        int key = (substream->pcm->device << 16) | (substream->number << 2) |
-                (substream->stream + 1);
+        int key = (substream->number << 2) | (substream->stream + 1);
+
+        if (substream->pcm)
+                key |= (substream->pcm->device << 16);
 
         spin_lock_irq(&bus->reg_lock);
@@ -327 +414 @@
 
 /**
- * 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);
 }
@@ -421 +521 @@
         struct hdac_bus *bus = azx_dev->bus;
         struct snd_pcm_substream *substream = azx_dev->substream;
-        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_compr_stream *cstream = azx_dev->cstream;
+        struct snd_pcm_runtime *runtime = NULL;
+        struct snd_dma_buffer *dmab;
         __le32 *bdl;
         int i, ofs, periods, period_bytes;
         int pos_adj, pos_align;
+
+        if (substream) {
+                runtime = substream->runtime;
+                dmab = snd_pcm_get_dma_buf(substream);
+        } else if (cstream) {
+                dmab = snd_pcm_get_dma_buf(cstream);
+        } else {
+                WARN(1, "No substream or cstream assigned\n");
+                return -EINVAL;
+        }
 
         /* reset BDL address */
@@ -439 +551 @@
 
         pos_adj = bus->bdl_pos_adj;
-        if (!azx_dev->no_period_wakeup && pos_adj > 0) {
+        if (runtime && !azx_dev->no_period_wakeup && pos_adj > 0) {
                 pos_align = pos_adj;
                 pos_adj = DIV_ROUND_UP(pos_adj * runtime->rate, 48000);
@@ -452 +564 @@
                         pos_adj = 0;
                 } else {
-                        ofs = setup_bdle(bus, snd_pcm_get_dma_buf(substream),
-                                         azx_dev,
+                        ofs = setup_bdle(bus, dmab, azx_dev,
                                          &bdl, ofs, pos_adj, true);
                         if (ofs < 0)
@@ -463 +574 @@
         for (i = 0; i < periods; i++) {
                 if (i == periods - 1 && pos_adj)
-                        ofs = setup_bdle(bus, snd_pcm_get_dma_buf(substream),
-                                         azx_dev, &bdl, ofs,
-                                         period_bytes - pos_adj, 0);
+                        ofs = setup_bdle(bus, dmab, azx_dev,
+                                         &bdl, ofs, period_bytes - pos_adj, 0);
                 else
-                        ofs = setup_bdle(bus, snd_pcm_get_dma_buf(substream),
-                                         azx_dev, &bdl, ofs,
-                                         period_bytes,
+                        ofs = setup_bdle(bus, dmab, azx_dev,
+                                         &bdl, ofs, period_bytes,
                                          !azx_dev->no_period_wakeup);
                 if (ofs < 0)
@@ -494 +603 @@
                                  unsigned int format_val)
 {
-
+        struct snd_pcm_substream *substream = azx_dev->substream;
+        struct snd_compr_stream *cstream = azx_dev->cstream;
         unsigned int bufsize, period_bytes;
-        struct snd_pcm_substream *substream = azx_dev->substream;
-        struct snd_pcm_runtime *runtime;
+        unsigned int no_period_wakeup;
         int err;
 
-        if (!substream)
+        if (substream) {
+                bufsize = snd_pcm_lib_buffer_bytes(substream);
+                period_bytes = snd_pcm_lib_period_bytes(substream);
+                no_period_wakeup = substream->runtime->no_period_wakeup;
+        } else if (cstream) {
+                bufsize = cstream->runtime->buffer_size;
+                period_bytes = cstream->runtime->fragment_size;
+                no_period_wakeup = 0;
+        } else {
                 return -EINVAL;
-        runtime = substream->runtime;
-        bufsize = snd_pcm_lib_buffer_bytes(substream);
-        period_bytes = snd_pcm_lib_period_bytes(substream);
+        }
 
         if (bufsize != azx_dev->bufsize ||
             period_bytes != azx_dev->period_bytes ||
             format_val != azx_dev->format_val ||
-            runtime->no_period_wakeup != azx_dev->no_period_wakeup) {
+            no_period_wakeup != azx_dev->no_period_wakeup) {
                 azx_dev->bufsize = bufsize;
                 azx_dev->period_bytes = period_bytes;
                 azx_dev->format_val = format_val;
-                azx_dev->no_period_wakeup = runtime->no_period_wakeup;
+                azx_dev->no_period_wakeup = no_period_wakeup;
                 err = snd_hdac_stream_setup_periods(azx_dev);
                 if (err < 0)
@@ -589 +704 @@
         bool inited = false;
         u64 cycle_last = 0;
-        int i = 0;
 
         list_for_each_entry(s, &bus->stream_list, list, struct hdac_stream) {
-                if (streams & (1 << i)) {
+                if ((streams & (1 << s->index))) {
                         azx_timecounter_init(s, inited, cycle_last);
                         if (!inited) {
@@ -599 +713 @@
                         }
                 }
-                i++;
         }
 
@@ -644 +757 @@
 {
         struct hdac_bus *bus = azx_dev->bus;
-        int i, nwait, timeout;
+        int nwait, timeout;
         struct hdac_stream *s;
 
         for (timeout = 5000; timeout; timeout--) {
                 nwait = 0;
-                i = 0;
                 list_for_each_entry(s, &bus->stream_list, list, struct hdac_stream) {
-                        if (!(streams & (1 << i++)))
+                        if (!(streams & (1 << s->index)))
                                 continue;
 
@@ -680 +792 @@
 EXPORT_SYMBOL_GPL(snd_hdac_stream_sync);
 
+/**
+ * snd_hdac_stream_spbcap_enable - enable SPIB for a stream
+ * @bus: HD-audio core bus
+ * @enable: flag to enable/disable SPIB
+ * @index: stream index for which SPIB need to be enabled
+ */
+void snd_hdac_stream_spbcap_enable(struct hdac_bus *bus,
+                                   bool enable, int index)
+{
+        u32 mask = 0;
+
+        if (!bus->spbcap) {
+                dev_err(bus->dev, "Address of SPB capability is NULL\n");
+                return;
+        }
+
+        mask |= (1 << index);
+
+        if (enable)
+                snd_hdac_updatel(bus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, mask);
+        else
+                snd_hdac_updatel(bus->spbcap, AZX_REG_SPB_SPBFCCTL, mask, 0);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_spbcap_enable);
+
+/**
+ * snd_hdac_stream_set_spib - sets the spib value of a stream
+ * @bus: HD-audio core bus
+ * @azx_dev: hdac_stream
+ * @value: spib value to set
+ */
+int snd_hdac_stream_set_spib(struct hdac_bus *bus,
+                             struct hdac_stream *azx_dev, u32 value)
+{
+        if (!bus->spbcap) {
+                dev_err(bus->dev, "Address of SPB capability is NULL\n");
+                return -EINVAL;
+        }
+
+        writel(value, azx_dev->spib_addr);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_set_spib);
+
+/**
+ * snd_hdac_stream_get_spbmaxfifo - gets the spib value of a stream
+ * @bus: HD-audio core bus
+ * @azx_dev: hdac_stream
+ *
+ * Return maxfifo for the stream
+ */
+int snd_hdac_stream_get_spbmaxfifo(struct hdac_bus *bus,
+                                   struct hdac_stream *azx_dev)
+{
+        if (!bus->spbcap) {
+                dev_err(bus->dev, "Address of SPB capability is NULL\n");
+                return -EINVAL;
+        }
+
+        return readl(azx_dev->fifo_addr);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_get_spbmaxfifo);
+
+/**
+ * snd_hdac_stream_drsm_enable - enable DMA resume for a stream
+ * @bus: HD-audio core bus
+ * @enable: flag to enable/disable DRSM
+ * @index: stream index for which DRSM need to be enabled
+ */
+void snd_hdac_stream_drsm_enable(struct hdac_bus *bus,
+                                 bool enable, int index)
+{
+        u32 mask = 0;
+
+        if (!bus->drsmcap) {
+                dev_err(bus->dev, "Address of DRSM capability is NULL\n");
+                return;
+        }
+
+        mask |= (1 << index);
+
+        if (enable)
+                snd_hdac_updatel(bus->drsmcap, AZX_REG_DRSM_CTL, mask, mask);
+        else
+                snd_hdac_updatel(bus->drsmcap, AZX_REG_DRSM_CTL, mask, 0);
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_drsm_enable);
+
+#ifndef TARGET_OS2
+/*
+ * snd_hdac_stream_wait_drsm - wait for HW to clear RSM for a stream
+ * @azx_dev: HD-audio core stream to await RSM for
+ *
+ * Returns 0 on success and -ETIMEDOUT upon a timeout.
+ */
+int snd_hdac_stream_wait_drsm(struct hdac_stream *azx_dev)
+{
+        struct hdac_bus *bus = azx_dev->bus;
+        u32 mask, reg;
+        int ret;
+
+        mask = 1 << azx_dev->index;
+
+        ret = read_poll_timeout(snd_hdac_reg_readl, reg, !(reg & mask), 250, 2000, false, bus,
+                                bus->drsmcap + AZX_REG_DRSM_CTL);
+        if (ret)
+                dev_dbg(bus->dev, "polling RSM 0x%08x failed: %d\n", mask, ret);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_wait_drsm);
+#endif
+
+/**
+ * snd_hdac_stream_set_dpibr - sets the dpibr value of a stream
+ * @bus: HD-audio core bus
+ * @azx_dev: hdac_stream
+ * @value: dpib value to set
+ */
+int snd_hdac_stream_set_dpibr(struct hdac_bus *bus,
+                              struct hdac_stream *azx_dev, u32 value)
+{
+        if (!bus->drsmcap) {
+                dev_err(bus->dev, "Address of DRSM capability is NULL\n");
+                return -EINVAL;
+        }
+
+        writel(value, azx_dev->dpibr_addr);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_set_dpibr);
+
+/**
+ * snd_hdac_stream_set_lpib - sets the lpib value of a stream
+ * @azx_dev: hdac_stream
+ * @value: lpib value to set
+ */
+int snd_hdac_stream_set_lpib(struct hdac_stream *azx_dev, u32 value)
+{
+        snd_hdac_stream_writel(azx_dev, SD_LPIB, value);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_hdac_stream_set_lpib);
+
 #ifdef CONFIG_SND_HDA_DSP_LOADER
 /**
@@ -754 +1012 @@
 {
         if (start)
-                snd_hdac_stream_start(azx_dev, true);
+                snd_hdac_stream_start(azx_dev);
         else
                 snd_hdac_stream_stop(azx_dev);

GPL/trunk/alsa-kernel/hda/hdmi_chmap.c

@@ -761 +761 @@
 }
 
+/* a simple sanity check for input values to chmap kcontrol */
+static int chmap_value_check(struct hdac_chmap *hchmap,
+                             const struct snd_ctl_elem_value *ucontrol)
+{
+        int i;
+
+        for (i = 0; i < hchmap->channels_max; i++) {
+                if (ucontrol->value.integer.value[i] < 0 ||
+                    ucontrol->value.integer.value[i] > SNDRV_CHMAP_LAST)
+                        return -EINVAL;
+        }
+        return 0;
+}
+
 static int hdmi_chmap_ctl_put(struct snd_kcontrol *kcontrol,
                               struct snd_ctl_elem_value *ucontrol)
@@ -772 +786 @@
         int i, err, ca, prepared = 0;
 
+        err = chmap_value_check(hchmap, ucontrol);
+        if (err < 0)
+                return err;
+
         /* No monitor is connected in dyn_pcm_assign.
          * It's invalid to setup the chmap
@@ -782 +800 @@
         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/trunk/alsa-kernel/hda/trace.h

@@ -20 +20 @@
         TP_PROTO(struct hdac_bus *bus, unsigned int cmd),
         TP_ARGS(bus, cmd),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, cmd)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] val=0x%08x",
-                         dev_name((bus)->dev), (cmd) >> 28, cmd);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->cmd = cmd;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] val=0x%08x", __get_str(name), __entry->cmd >> 28, __entry->cmd)
 );
 
@@ -32 +34 @@
         TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res),
         TP_ARGS(bus, addr, res),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, addr)
+                __field(u32, res)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] val=0x%08x",
-                         dev_name((bus)->dev), addr, res);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->addr = addr;
+                __entry->res = res;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] val=0x%08x", __get_str(name), __entry->addr, __entry->res)
 );
 
@@ -44 +50 @@
         TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex),
         TP_ARGS(bus, res, res_ex),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, res)
+                __field(u32, res_ex)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] res=0x%08x, res_ex=0x%08x",
-                         dev_name((bus)->dev), res_ex & 0x0f, res, res_ex);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->res = res;
+                __entry->res_ex = res_ex;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] res=0x%08x, res_ex=0x%08x", __get_str(name),
+                  __entry->res_ex & 0x0f, __entry->res, __entry->res_ex)
 );