Merge tag 'drm-for-v4.11-less-shouty' of git://people.freedesktop.org/~airlied/linux

Pull drm updates from Dave Airlie:
 "This is the main drm pull request for v4.11.

  Nothing too major, the tinydrm and mmu-less support should make
  writing smaller drivers easier for some of the simpler platforms, and
  there are a bunch of documentation updates.

  Intel grew displayport MST audio support which is hopefully useful to
  people, and FBC is on by default for GEN9+ (so people know where to
  look for regressions). AMDGPU has a lot of fixes that would like new
  firmware files installed for some GPUs.

  Other than that it's pretty scattered all over.

  I may have a follow up pull request as I know BenH has a bunch of AST
  rework and fixes and I'd like to get those in once they've been tested
  by AST, and I've got at least one pull request I'm just trying to get
  the author to fix up.

  Core:
   - drm_mm reworked
   - Connector list locking and iterators
   - Documentation updates
   - Format handling rework
   - MMU-less support for fbdev helpers
   - drm_crtc_from_index helper
   - Core CRC API
   - Remove drm_framebuffer_unregister_private
   - Debugfs cleanup
   - EDID/Infoframe fixes
   - Release callback
   - Tinydrm support (smaller drivers for simple hw)

  panel:
   - Add support for some new simple panels

  i915:
   - FBC by default for gen9+
   - Shared dpll cleanups and docs
   - GEN8 powerdomain cleanup
   - DMC support on GLK
   - DP MST audio support
   - HuC loading support
   - GVT init ordering fixes
   - GVT IOMMU workaround fix

  amdgpu/radeon:
   - Power/clockgating improvements
   - Preliminary SR-IOV support
   - TTM buffer priority and eviction fixes
   - SI DPM quirks removed due to firmware fixes
   - Powerplay improvements
   - VCE/UVD powergating fixes
   - Cleanup SI GFX code to match CI/VI
   - Support for > 2 displays on 3/5 crtc asics
   - SI headless fixes

  nouveau:
   - Rework securre boot code in prep for GP10x secure boot
   - Channel recovery improvements
   - Initial power budget code
   - MMU rework preperation

  vmwgfx:
   - Bunch of fixes and cleanups

  exynos:
   - Runtime PM support for MIC driver
   - Cleanups to use atomic helpers
   - UHD Support for TM2/TM2E boards
   - Trigger mode fix for Rinato board

  etnaviv:
   - Shader performance fix
   - Command stream validator fixes
   - Command buffer suballocator

  rockchip:
   - CDN DisplayPort support
   - IOMMU support for arm64 platform

  imx-drm:
   - Fix i.MX5 TV encoder probing
   - Remove lower fb size limits

  msm:
   - Support for HW cursor on MDP5 devices
   - DSI encoder cleanup
   - GPU DT bindings cleanup

  sti:
   - stih410 cleanups
   - Create fbdev at binding
   - HQVDP fixes
   - Remove stih416 chip functionality
   - DVI/HDMI mode selection fixes
   - FPS statistic reporting

  omapdrm:
   - IRQ code cleanup

  dwi-hdmi bridge:
   - Cleanups and fixes

  adv-bridge:
   - Updates for nexus

  sii8520 bridge:
   - Add interlace mode support
   - Rework HDMI and lots of fixes

  qxl:
   - probing/teardown cleanups

  ZTE drm:
   - HDMI audio via SPDIF interface
   - Video Layer overlay plane support
   - Add TV encoder output device

  atmel-hlcdc:
   - Rework fbdev creation logic

  tegra:
   - OF node fix

  fsl-dcu:
   - Minor fixes

  mali-dp:
   - Assorted fixes

  sunxi:
   - Minor fix"

[ This was the "fixed" pull, that still had build warnings due to people
  not even having build tested the result. I'm not a happy camper

  I've fixed the things I noticed up in this merge.      - Linus ]

* tag 'drm-for-v4.11-less-shouty' of git://people.freedesktop.org/~airlied/linux: (1177 commits)
  lib/Kconfig: make PRIME_NUMBERS not user selectable
  drm/tinydrm: helpers: Properly fix backlight dependency
  drm/tinydrm: mipi-dbi: Fix field width specifier warning
  drm/tinydrm: mipi-dbi: Silence: ‘cmd’ may be used uninitialized
  drm/sti: fix build warnings in sti_drv.c and sti_vtg.c files
  drm/amd/powerplay: fix PSI feature on Polars12
  drm/amdgpu: refuse to reserve io mem for split VRAM buffers
  drm/ttm: fix use-after-free races in vm fault handling
  drm/tinydrm: Add support for Multi-Inno MI0283QT display
  dt-bindings: Add Multi-Inno MI0283QT binding
  dt-bindings: display/panel: Add common rotation property
  of: Add vendor prefix for Multi-Inno
  drm/tinydrm: Add MIPI DBI support
  drm/tinydrm: Add helper functions
  drm: Add DRM support for tiny LCD displays
  drm/amd/amdgpu: post card if there is real hw resetting performed
  drm/nouveau/tmr: provide backtrace when a timeout is hit
  drm/nouveau/pci/g92: Fix rearm
  drm/nouveau/drm/therm/fan: add a fallback if no fan control is specified in the vbios
  drm/nouveau/hwmon: expose power_max and power_crit
  ..

3 files changed, 268 insertions, 56 deletions

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 9913be8532ab..8fd745cb3f36 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -311,9 +311,15 @@ int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
 }
 EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
 
-
-/* return DEVLIST_LEN parameter of the given widget */
-static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
+/**
+ * snd_hda_get_num_devices - get DEVLIST_LEN parameter of the given widget
+ *  @codec: the HDA codec
+ *  @nid: NID of the pin to parse
+ *
+ * Get the device entry number on the given widget. This is a feature of
+ * DP MST audio. Each pin can have several device entries in it.
+ */
+unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid)
 {
         unsigned int wcaps = get_wcaps(codec, nid);
         unsigned int parm;
@@ -327,6 +333,7 @@ static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
                 parm = 0;
         return parm & AC_DEV_LIST_LEN_MASK;
 }
+EXPORT_SYMBOL_GPL(snd_hda_get_num_devices);
 
 /**
  * snd_hda_get_devices - copy device list without cache
@@ -344,7 +351,7 @@ int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
         unsigned int parm;
         int i, dev_len, devices;
 
-        parm = get_num_devices(codec, nid);
+        parm = snd_hda_get_num_devices(codec, nid);
         if (!parm)      /* not multi-stream capable */
                 return 0;
 
@@ -368,6 +375,63 @@ int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
         return devices;
 }
 
+/**
+ * snd_hda_get_dev_select - get device entry select on the pin
+ * @codec: the HDA codec
+ * @nid: NID of the pin to get device entry select
+ *
+ * Get the devcie entry select on the pin. Return the device entry
+ * id selected on the pin. Return 0 means the first device entry
+ * is selected or MST is not supported.
+ */
+int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid)
+{
+        /* not support dp_mst will always return 0, using first dev_entry */
+        if (!codec->dp_mst)
+                return 0;
+
+        return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_DEVICE_SEL, 0);
+}
+EXPORT_SYMBOL_GPL(snd_hda_get_dev_select);
+
+/**
+ * snd_hda_set_dev_select - set device entry select on the pin
+ * @codec: the HDA codec
+ * @nid: NID of the pin to set device entry select
+ * @dev_id: device entry id to be set
+ *
+ * Set the device entry select on the pin nid.
+ */
+int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id)
+{
+        int ret, num_devices;
+
+        /* not support dp_mst will always return 0, using first dev_entry */
+        if (!codec->dp_mst)
+                return 0;
+
+        /* AC_PAR_DEVLIST_LEN is 0 based. */
+        num_devices = snd_hda_get_num_devices(codec, nid) + 1;
+        /* If Device List Length is 0 (num_device = 1),
+         * the pin is not multi stream capable.
+         * Do nothing in this case.
+         */
+        if (num_devices == 1)
+                return 0;
+
+        /* Behavior of setting index being equal to or greater than
+         * Device List Length is not predictable
+         */
+        if (num_devices <= dev_id)
+                return -EINVAL;
+
+        ret = snd_hda_codec_write(codec, nid, 0,
+                        AC_VERB_SET_DEVICE_SEL, dev_id);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(snd_hda_set_dev_select);
+
 /*
  * read widget caps for each widget and store in cache
  */
@@ -403,6 +467,10 @@ static int read_pin_defaults(struct hda_codec *codec)
                 pin->nid = nid;
                 pin->cfg = snd_hda_codec_read(codec, nid, 0,
                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
+                /*
+                 * all device entries are the same widget control so far
+                 * fixme: if any codec is different, need fix here
+                 */
                 pin->ctrl = snd_hda_codec_read(codec, nid, 0,
                                                AC_VERB_GET_PIN_WIDGET_CONTROL,
                                                0);
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 373fcad840ea..f17f25245e52 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -347,8 +347,11 @@ int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums,
                           const hda_nid_t *list);
 int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
                            hda_nid_t nid, int recursive);
+unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid);
 int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
                         u8 *dev_list, int max_devices);
+int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid);
+int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id);
 
 struct hda_verb {
         hda_nid_t nid;
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 3fc201c3b95a..fd5efa72a68b 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -76,6 +76,7 @@ struct hdmi_spec_per_cvt {
 
 struct hdmi_spec_per_pin {
         hda_nid_t pin_nid;
+        int dev_id;
         /* pin idx, different device entries on the same pin use the same idx */
         int pin_nid_idx;
         int num_mux_nids;
@@ -130,7 +131,23 @@ struct hdmi_spec {
         struct snd_array cvts; /* struct hdmi_spec_per_cvt */
         hda_nid_t cvt_nids[4]; /* only for haswell fix */
 
+        /*
+         * num_pins is the number of virtual pins
+         * for example, there are 3 pins, and each pin
+         * has 4 device entries, then the num_pins is 12
+         */
         int num_pins;
+        /*
+         * num_nids is the number of real pins
+         * In the above example, num_nids is 3
+         */
+        int num_nids;
+        /*
+         * dev_num is the number of device entries
+         * on each pin.
+         * In the above example, dev_num is 4
+         */
+        int dev_num;
         struct snd_array pins; /* struct hdmi_spec_per_pin */
         struct hdmi_pcm pcm_rec[16];
         struct mutex pcm_lock;
@@ -217,14 +234,26 @@ union audio_infoframe {
 /* obtain hda_pcm object assigned to idx */
 #define get_pcm_rec(spec, idx)  (get_hdmi_pcm(spec, idx)->pcm)
 
-static int pin_nid_to_pin_index(struct hda_codec *codec, hda_nid_t pin_nid)
+static int pin_id_to_pin_index(struct hda_codec *codec,
+                               hda_nid_t pin_nid, int dev_id)
 {
         struct hdmi_spec *spec = codec->spec;
         int pin_idx;
+        struct hdmi_spec_per_pin *per_pin;
+
+        /*
+         * (dev_id == -1) means it is NON-MST pin
+         * return the first virtual pin on this port
+         */
+        if (dev_id == -1)
+                dev_id = 0;
 
-        for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++)
-                if (get_pin(spec, pin_idx)->pin_nid == pin_nid)
+        for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
+                per_pin = get_pin(spec, pin_idx);
+                if ((per_pin->pin_nid == pin_nid) &&
+                        (per_pin->dev_id == dev_id))
                         return pin_idx;
+        }
 
         codec_warn(codec, "HDMI: pin nid %d not registered\n", pin_nid);
         return -EINVAL;
@@ -724,10 +753,11 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
 
 static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll);
 
-static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid)
+static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid,
+                                      int dev_id)
 {
         struct hdmi_spec *spec = codec->spec;
-        int pin_idx = pin_nid_to_pin_index(codec, nid);
+        int pin_idx = pin_id_to_pin_index(codec, nid, dev_id);
 
         if (pin_idx < 0)
                 return;
@@ -738,7 +768,8 @@ static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid)
 static void jack_callback(struct hda_codec *codec,
                           struct hda_jack_callback *jack)
 {
-        check_presence_and_report(codec, jack->nid);
+        /* hda_jack don't support DP MST */
+        check_presence_and_report(codec, jack->nid, 0);
 }
 
 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
@@ -747,6 +778,12 @@ static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
         struct hda_jack_tbl *jack;
         int dev_entry = (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;
 
+        /*
+         * assume DP MST uses dyn_pcm_assign and acomp and
+         * never comes here
+         * if DP MST supports unsol event, below code need
+         * consider dev_entry
+         */
         jack = snd_hda_jack_tbl_get_from_tag(codec, tag);
         if (!jack)
                 return;
@@ -757,7 +794,8 @@ static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
                 codec->addr, jack->nid, dev_entry, !!(res & AC_UNSOL_RES_IA),
                 !!(res & AC_UNSOL_RES_PD), !!(res & AC_UNSOL_RES_ELDV));
 
-        check_presence_and_report(codec, jack->nid);
+        /* hda_jack don't support DP MST */
+        check_presence_and_report(codec, jack->nid, 0);
 }
 
 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
@@ -970,28 +1008,60 @@ static int intel_cvt_id_to_mux_idx(struct hdmi_spec *spec,
  * by any other pins.
  */
 static void intel_not_share_assigned_cvt(struct hda_codec *codec,
-                        hda_nid_t pin_nid, int mux_idx)
+                                         hda_nid_t pin_nid,
+                                         int dev_id, int mux_idx)
 {
         struct hdmi_spec *spec = codec->spec;
         hda_nid_t nid;
         int cvt_idx, curr;
         struct hdmi_spec_per_cvt *per_cvt;
+        struct hdmi_spec_per_pin *per_pin;
+        int pin_idx;
+
+        /* configure the pins connections */
+        for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
+                int dev_id_saved;
+                int dev_num;
 
-        /* configure all pins, including "no physical connection" ones */
-        for_each_hda_codec_node(nid, codec) {
-                unsigned int wid_caps = get_wcaps(codec, nid);
-                unsigned int wid_type = get_wcaps_type(wid_caps);
+                per_pin = get_pin(spec, pin_idx);
+                /*
+                 * pin not connected to monitor
+                 * no need to operate on it
+                 */
+                if (!per_pin->pcm)
+                        continue;
 
-                if (wid_type != AC_WID_PIN)
+                if ((per_pin->pin_nid == pin_nid) &&
+                        (per_pin->dev_id == dev_id))
                         continue;
 
-                if (nid == pin_nid)
+                /*
+                 * if per_pin->dev_id >= dev_num,
+                 * snd_hda_get_dev_select() will fail,
+                 * and the following operation is unpredictable.
+                 * So skip this situation.
+                 */
+                dev_num = snd_hda_get_num_devices(codec, per_pin->pin_nid) + 1;
+                if (per_pin->dev_id >= dev_num)
                         continue;
 
+                nid = per_pin->pin_nid;
+
+                /*
+                 * Calling this function should not impact
+                 * on the device entry selection
+                 * So let's save the dev id for each pin,
+                 * and restore it when return
+                 */
+                dev_id_saved = snd_hda_get_dev_select(codec, nid);
+                snd_hda_set_dev_select(codec, nid, per_pin->dev_id);
                 curr = snd_hda_codec_read(codec, nid, 0,
                                           AC_VERB_GET_CONNECT_SEL, 0);
-                if (curr != mux_idx)
+                if (curr != mux_idx) {
+                        snd_hda_set_dev_select(codec, nid, dev_id_saved);
                         continue;
+                }
+
 
                 /* choose an unassigned converter. The conveters in the
                  * connection list are in the same order as in the codec.
@@ -1008,12 +1078,13 @@ static void intel_not_share_assigned_cvt(struct hda_codec *codec,
                                 break;
                         }
                 }
+                snd_hda_set_dev_select(codec, nid, dev_id_saved);
         }
 }
 
 /* A wrapper of intel_not_share_asigned_cvt() */
 static void intel_not_share_assigned_cvt_nid(struct hda_codec *codec,
-                        hda_nid_t pin_nid, hda_nid_t cvt_nid)
+                        hda_nid_t pin_nid, int dev_id, hda_nid_t cvt_nid)
 {
         int mux_idx;
         struct hdmi_spec *spec = codec->spec;
@@ -1025,7 +1096,7 @@ static void intel_not_share_assigned_cvt_nid(struct hda_codec *codec,
          */
         mux_idx = intel_cvt_id_to_mux_idx(spec, cvt_nid);
         if (mux_idx >= 0)
-                intel_not_share_assigned_cvt(codec, pin_nid, mux_idx);
+                intel_not_share_assigned_cvt(codec, pin_nid, dev_id, mux_idx);
 }
 
 /* skeleton caller of pin_cvt_fixup ops */
@@ -1140,6 +1211,7 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
         per_pin->cvt_nid = per_cvt->cvt_nid;
         hinfo->nid = per_cvt->cvt_nid;
 
+        snd_hda_set_dev_select(codec, per_pin->pin_nid, per_pin->dev_id);
         snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
                             AC_VERB_SET_CONNECT_SEL,
                             per_pin->mux_idx);
@@ -1198,6 +1270,7 @@ static int hdmi_read_pin_conn(struct hda_codec *codec, int pin_idx)
                 return -EINVAL;
         }
 
+        /* all the device entries on the same pin have the same conn list */
         per_pin->num_mux_nids = snd_hda_get_connections(codec, pin_nid,
                                                         per_pin->mux_nids,
                                                         HDA_MAX_CONNECTIONS);
@@ -1215,13 +1288,13 @@ static int hdmi_find_pcm_slot(struct hdmi_spec *spec,
                 return per_pin->pin_nid_idx;
 
         /* have a second try; check the "reserved area" over num_pins */
-        for (i = spec->num_pins; i < spec->pcm_used; i++) {
+        for (i = spec->num_nids; i < spec->pcm_used; i++) {
                 if (!test_bit(i, &spec->pcm_bitmap))
                         return i;
         }
 
         /* the last try; check the empty slots in pins */
-        for (i = 0; i < spec->num_pins; i++) {
+        for (i = 0; i < spec->num_nids; i++) {
                 if (!test_bit(i, &spec->pcm_bitmap))
                         return i;
         }
@@ -1296,10 +1369,13 @@ static void hdmi_pcm_setup_pin(struct hdmi_spec *spec,
         per_pin->cvt_nid = hinfo->nid;
 
         mux_idx = hdmi_get_pin_cvt_mux(spec, per_pin, hinfo->nid);
-        if (mux_idx < per_pin->num_mux_nids)
+        if (mux_idx < per_pin->num_mux_nids) {
+                snd_hda_set_dev_select(codec, per_pin->pin_nid,
+                                   per_pin->dev_id);
                 snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
                                 AC_VERB_SET_CONNECT_SEL,
                                 mux_idx);
+        }
         snd_hda_spdif_ctls_assign(codec, per_pin->pcm_idx, hinfo->nid);
 
         non_pcm = check_non_pcm_per_cvt(codec, hinfo->nid);
@@ -1467,6 +1543,11 @@ static struct snd_jack *pin_idx_to_jack(struct hda_codec *codec,
         if (per_pin->pcm_idx >= 0 && spec->dyn_pcm_assign)
                 jack = spec->pcm_rec[per_pin->pcm_idx].jack;
         else if (!spec->dyn_pcm_assign) {
+                /*
+                 * jack tbl doesn't support DP MST
+                 * DP MST will use dyn_pcm_assign,
+                 * so DP MST will never come here
+                 */
                 jack_tbl = snd_hda_jack_tbl_get(codec, per_pin->pin_nid);
                 if (jack_tbl)
                         jack = jack_tbl->jack;
@@ -1485,9 +1566,9 @@ static void sync_eld_via_acomp(struct hda_codec *codec,
 
         mutex_lock(&per_pin->lock);
         eld->monitor_present = false;
-        size = snd_hdac_acomp_get_eld(&codec->core, per_pin->pin_nid, -1,
-                                      &eld->monitor_present, eld->eld_buffer,
-                                      ELD_MAX_SIZE);
+        size = snd_hdac_acomp_get_eld(&codec->core, per_pin->pin_nid,
+                                      per_pin->dev_id, &eld->monitor_present,
+                                      eld->eld_buffer, ELD_MAX_SIZE);
         if (size > 0) {
                 size = min(size, ELD_MAX_SIZE);
                 if (snd_hdmi_parse_eld(codec, &eld->info,
@@ -1565,38 +1646,81 @@ static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
         int pin_idx;
         struct hdmi_spec_per_pin *per_pin;
         int err;
+        int dev_num, i;
 
         caps = snd_hda_query_pin_caps(codec, pin_nid);
         if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
                 return 0;
 
+        /*
+         * For DP MST audio, Configuration Default is the same for
+         * all device entries on the same pin
+         */
         config = snd_hda_codec_get_pincfg(codec, pin_nid);
         if (get_defcfg_connect(config) == AC_JACK_PORT_NONE)
                 return 0;
 
-        if (is_haswell_plus(codec))
-                intel_haswell_fixup_connect_list(codec, pin_nid);
-
-        pin_idx = spec->num_pins;
-        per_pin = snd_array_new(&spec->pins);
-        if (!per_pin)
-                return -ENOMEM;
-
-        per_pin->pin_nid = pin_nid;
-        per_pin->non_pcm = false;
-        if (spec->dyn_pcm_assign)
-                per_pin->pcm_idx = -1;
-        else {
-                per_pin->pcm = get_hdmi_pcm(spec, pin_idx);
-                per_pin->pcm_idx = pin_idx;
+        /*
+         * To simplify the implementation, malloc all
+         * the virtual pins in the initialization statically
+         */
+        if (is_haswell_plus(codec)) {
+                /*
+                 * On Intel platforms, device entries number is
+                 * changed dynamically. If there is a DP MST
+                 * hub connected, the device entries number is 3.
+                 * Otherwise, it is 1.
+                 * Here we manually set dev_num to 3, so that
+                 * we can initialize all the device entries when
+                 * bootup statically.
+                 */
+                dev_num = 3;
+                spec->dev_num = 3;
+        } else if (spec->dyn_pcm_assign && codec->dp_mst) {
+                dev_num = snd_hda_get_num_devices(codec, pin_nid) + 1;
+                /*
+                 * spec->dev_num is the maxinum number of device entries
+                 * among all the pins
+                 */
+                spec->dev_num = (spec->dev_num > dev_num) ?
+                        spec->dev_num : dev_num;
+        } else {
+                /*
+                 * If the platform doesn't support DP MST,
+                 * manually set dev_num to 1. This means
+                 * the pin has only one device entry.
+                 */
+                dev_num = 1;
+                spec->dev_num = 1;
         }
-        per_pin->pin_nid_idx = pin_idx;
 
-        err = hdmi_read_pin_conn(codec, pin_idx);
-        if (err < 0)
-                return err;
+        for (i = 0; i < dev_num; i++) {
+                pin_idx = spec->num_pins;
+                per_pin = snd_array_new(&spec->pins);
 
-        spec->num_pins++;
+                if (!per_pin)
+                        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->pin_nid = pin_nid;
+                per_pin->pin_nid_idx = spec->num_nids;
+                per_pin->dev_id = i;
+                per_pin->non_pcm = false;
+                snd_hda_set_dev_select(codec, pin_nid, i);
+                if (is_haswell_plus(codec))
+                        intel_haswell_fixup_connect_list(codec, pin_nid);
+                err = hdmi_read_pin_conn(codec, pin_idx);
+                if (err < 0)
+                        return err;
+                spec->num_pins++;
+        }
+        spec->num_nids++;
 
         return 0;
 }
@@ -1744,7 +1868,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
         /* Call sync_audio_rate to set the N/CTS/M manually if necessary */
         /* Todo: add DP1.2 MST audio support later */
         if (codec_has_acomp(codec))
-                snd_hdac_sync_audio_rate(&codec->core, pin_nid, -1,
+                snd_hdac_sync_audio_rate(&codec->core, pin_nid, per_pin->dev_id,
                                          runtime->rate);
 
         non_pcm = check_non_pcm_per_cvt(codec, cvt_nid);
@@ -1762,6 +1886,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
                                     pinctl | PIN_OUT);
         }
 
+        /* snd_hda_set_dev_select() has been called before */
         err = spec->ops.setup_stream(codec, cvt_nid, pin_nid,
                                  stream_tag, format);
         mutex_unlock(&spec->pcm_lock);
@@ -1897,17 +2022,23 @@ static bool is_hdmi_pcm_attached(struct hdac_device *hdac, int pcm_idx)
 static int generic_hdmi_build_pcms(struct hda_codec *codec)
 {
         struct hdmi_spec *spec = codec->spec;
-        int pin_idx;
+        int idx;
 
-        for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
+        /*
+         * for non-mst mode, pcm number is the same as before
+         * for DP MST mode, pcm number is (nid number + dev_num - 1)
+         *  dev_num is the device entry number in a pin
+         *
+         */
+        for (idx = 0; idx < spec->num_nids + spec->dev_num - 1; idx++) {
                 struct hda_pcm *info;
                 struct hda_pcm_stream *pstr;
 
-                info = snd_hda_codec_pcm_new(codec, "HDMI %d", pin_idx);
+                info = snd_hda_codec_pcm_new(codec, "HDMI %d", idx);
                 if (!info)
                         return -ENOMEM;
 
-                spec->pcm_rec[pin_idx].pcm = info;
+                spec->pcm_rec[idx].pcm = info;
                 spec->pcm_used++;
                 info->pcm_type = HDA_PCM_TYPE_HDMI;
                 info->own_chmap = true;
@@ -1915,6 +2046,9 @@ static int generic_hdmi_build_pcms(struct hda_codec *codec)
                 pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
                 pstr->substreams = 1;
                 pstr->ops = generic_ops;
+                /* pcm number is less than 16 */
+                if (spec->pcm_used >= 16)
+                        break;
                 /* other pstr fields are set in open */
         }
 
@@ -2070,7 +2204,9 @@ static int generic_hdmi_init(struct hda_codec *codec)
         for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
                 struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
                 hda_nid_t pin_nid = per_pin->pin_nid;
+                int dev_id = per_pin->dev_id;
 
+                snd_hda_set_dev_select(codec, pin_nid, dev_id);
                 hdmi_init_pin(codec, pin_nid);
                 if (!codec_has_acomp(codec))
                         snd_hda_jack_detect_enable_callback(codec, pin_nid,
@@ -2178,6 +2314,7 @@ static int alloc_generic_hdmi(struct hda_codec *codec)
                 return -ENOMEM;
 
         spec->ops = generic_standard_hdmi_ops;
+        spec->dev_num = 1;      /* initialize to 1 */
         mutex_init(&spec->pcm_lock);
         snd_hdac_register_chmap_ops(&codec->core, &spec->chmap);
 
@@ -2295,6 +2432,7 @@ static void intel_pin_eld_notify(void *audio_ptr, int port, int pipe)
 {
         struct hda_codec *codec = audio_ptr;
         int pin_nid;
+        int dev_id = pipe;
 
         /* we assume only from port-B to port-D */
         if (port < 1 || port > 3)
@@ -2321,7 +2459,7 @@ static void intel_pin_eld_notify(void *audio_ptr, int port, int pipe)
                 return;
 
         snd_hdac_i915_set_bclk(&codec->bus->core);
-        check_presence_and_report(codec, pin_nid);
+        check_presence_and_report(codec, pin_nid, dev_id);
 }
 
 /* register i915 component pin_eld_notify callback */
@@ -2354,11 +2492,13 @@ static void i915_pin_cvt_fixup(struct hda_codec *codec,
                                hda_nid_t cvt_nid)
 {
         if (per_pin) {
+                snd_hda_set_dev_select(codec, per_pin->pin_nid,
+                               per_pin->dev_id);
                 intel_verify_pin_cvt_connect(codec, per_pin);
                 intel_not_share_assigned_cvt(codec, per_pin->pin_nid,
-                                             per_pin->mux_idx);
+                                     per_pin->dev_id, per_pin->mux_idx);
         } else {
-                intel_not_share_assigned_cvt_nid(codec, 0, cvt_nid);
+                intel_not_share_assigned_cvt_nid(codec, 0, 0, cvt_nid);
         }
 }
 
@@ -2378,6 +2518,8 @@ static int patch_i915_hsw_hdmi(struct hda_codec *codec)
         if (err < 0)
                 return err;
         spec = codec->spec;
+        codec->dp_mst = true;
+        spec->dyn_pcm_assign = true;
 
         intel_haswell_enable_all_pins(codec, true);
         intel_haswell_fixup_enable_dp12(codec);
@@ -2389,7 +2531,6 @@ static int patch_i915_hsw_hdmi(struct hda_codec *codec)
                 codec->core.link_power_control = 1;
 
         codec->patch_ops.set_power_state = haswell_set_power_state;
-        codec->dp_mst = true;
         codec->depop_delay = 0;
         codec->auto_runtime_pm = 1;