sound/soc/codecs/hdac_hdmi.c

   1 /*
   2  *  hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
   3  *
   4  *  Copyright (C) 2014-2015 Intel Corp
   5  *  Author: Samreen Nilofer <samreen.nilofer@intel.com>
   6  *          Subhransu S. Prusty <subhransu.s.prusty@intel.com>
   7  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; version 2 of the License.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  19  */
  20 #include <linux/init.h>
  21 #include <linux/delay.h>
  22 #include <linux/module.h>
  23 #include <linux/pm_runtime.h>
  24 #include <linux/hdmi.h>
  25 #include <drm/drm_edid.h>
  26 #include <sound/pcm_params.h>
  27 #include <sound/jack.h>
  28 #include <sound/soc.h>
  29 #include <sound/hdaudio_ext.h>
  30 #include <sound/hda_i915.h>
  31 #include <sound/pcm_drm_eld.h>
  32 #include <sound/hda_chmap.h>
  33 #include "../../hda/local.h"
  34 #include "hdac_hdmi.h"
  35
  36 #define NAME_SIZE       32
  37
  38 #define AMP_OUT_MUTE            0xb080
  39 #define AMP_OUT_UNMUTE          0xb000
  40 #define PIN_OUT                 (AC_PINCTL_OUT_EN)
  41
  42 #define HDA_MAX_CONNECTIONS     32
  43
  44 #define HDA_MAX_CVTS            3
  45 #define HDA_MAX_PORTS           3
  46
  47 #define ELD_MAX_SIZE    256
  48 #define ELD_FIXED_BYTES 20
  49
  50 #define ELD_VER_CEA_861D 2
  51 #define ELD_VER_PARTIAL 31
  52 #define ELD_MAX_MNL     16
  53
  54 struct hdac_hdmi_cvt_params {
  55         unsigned int channels_min;
  56         unsigned int channels_max;
  57         u32 rates;
  58         u64 formats;
  59         unsigned int maxbps;
  60 };
  61
  62 struct hdac_hdmi_cvt {
  63         struct list_head head;
  64         hda_nid_t nid;
  65         const char *name;
  66         struct hdac_hdmi_cvt_params params;
  67 };
  68
  69 /* Currently only spk_alloc, more to be added */
  70 struct hdac_hdmi_parsed_eld {
  71         u8 spk_alloc;
  72 };
  73
  74 struct hdac_hdmi_eld {
  75         bool    monitor_present;
  76         bool    eld_valid;
  77         int     eld_size;
  78         char    eld_buffer[ELD_MAX_SIZE];
  79         struct  hdac_hdmi_parsed_eld info;
  80 };
  81
  82 struct hdac_hdmi_pin {
  83         struct list_head head;
  84         hda_nid_t nid;
  85         bool mst_capable;
  86         struct hdac_hdmi_port *ports;
  87         int num_ports;
  88         struct hdac_ext_device *edev;
  89 };
  90
  91 struct hdac_hdmi_port {
  92         struct list_head head;
  93         int id;
  94         struct hdac_hdmi_pin *pin;
  95         int num_mux_nids;
  96         hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
  97         struct hdac_hdmi_eld eld;
  98         const char *jack_pin;
  99         struct snd_soc_dapm_context *dapm;
 100         const char *output_pin;
 101 };
 102
 103 struct hdac_hdmi_pcm {
 104         struct list_head head;
 105         int pcm_id;
 106         struct list_head port_list;
 107         struct hdac_hdmi_cvt *cvt;
 108         struct snd_soc_jack *jack;
 109         int stream_tag;
 110         int channels;
 111         int format;
 112         bool chmap_set;
 113         unsigned char chmap[8]; /* ALSA API channel-map */
 114         struct mutex lock;
 115         int jack_event;
 116 };
 117
 118 struct hdac_hdmi_dai_port_map {
 119         int dai_id;
 120         struct hdac_hdmi_port *port;
 121         struct hdac_hdmi_cvt *cvt;
 122 };
 123
 124 struct hdac_hdmi_drv_data {
 125         unsigned int vendor_nid;
 126 };
 127
 128 struct hdac_hdmi_priv {
 129         struct hdac_hdmi_dai_port_map dai_map[HDA_MAX_CVTS];
 130         struct list_head pin_list;
 131         struct list_head cvt_list;
 132         struct list_head pcm_list;
 133         int num_pin;
 134         int num_cvt;
 135         int num_ports;
 136         struct mutex pin_mutex;
 137         struct hdac_chmap chmap;
 138         struct hdac_hdmi_drv_data *drv_data;
 139         struct snd_soc_dai_driver *dai_drv;
 140 };
 141
 142 #define hdev_to_hdmi_priv(_hdev) ((to_ehdac_device(_hdev))->private_data)
 143
 144 static struct hdac_hdmi_pcm *
 145 hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv *hdmi,
 146                            struct hdac_hdmi_cvt *cvt)
 147 {
 148         struct hdac_hdmi_pcm *pcm = NULL;
 149
 150         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 151                 if (pcm->cvt == cvt)
 152                         break;
 153         }
 154
 155         return pcm;
 156 }
 157
 158 static void hdac_hdmi_jack_report(struct hdac_hdmi_pcm *pcm,
 159                 struct hdac_hdmi_port *port, bool is_connect)
 160 {
 161         struct hdac_ext_device *edev = port->pin->edev;
 162
 163         if (is_connect)
 164                 snd_soc_dapm_enable_pin(port->dapm, port->jack_pin);
 165         else
 166                 snd_soc_dapm_disable_pin(port->dapm, port->jack_pin);
 167
 168         if (is_connect) {
 169                 /*
 170                  * Report Jack connect event when a device is connected
 171                  * for the first time where same PCM is attached to multiple
 172                  * ports.
 173                  */
 174                 if (pcm->jack_event == 0) {
 175                         dev_dbg(&edev->hdev.dev,
 176                                         "jack report for pcm=%d\n",
 177                                         pcm->pcm_id);
 178                         snd_soc_jack_report(pcm->jack, SND_JACK_AVOUT,
 179                                                 SND_JACK_AVOUT);
 180                 }
 181                 pcm->jack_event++;
 182         } else {
 183                 /*
 184                  * Report Jack disconnect event when a device is disconnected
 185                  * is the only last connected device when same PCM is attached
 186                  * to multiple ports.
 187                  */
 188                 if (pcm->jack_event == 1)
 189                         snd_soc_jack_report(pcm->jack, 0, SND_JACK_AVOUT);
 190                 if (pcm->jack_event > 0)
 191                         pcm->jack_event--;
 192         }
 193
 194         snd_soc_dapm_sync(port->dapm);
 195 }
 196
 197 /* MST supported verbs */
 198 /*
 199  * Get the no devices that can be connected to a port on the Pin widget.
 200  */
 201 static int hdac_hdmi_get_port_len(struct hdac_ext_device *edev, hda_nid_t nid)
 202 {
 203         unsigned int caps;
 204         unsigned int type, param;
 205
 206         caps = get_wcaps(&edev->hdev, nid);
 207         type = get_wcaps_type(caps);
 208
 209         if (!(caps & AC_WCAP_DIGITAL) || (type != AC_WID_PIN))
 210                 return 0;
 211
 212         param = snd_hdac_read_parm_uncached(&edev->hdev, nid,
 213                                         AC_PAR_DEVLIST_LEN);
 214         if (param == -1)
 215                 return param;
 216
 217         return param & AC_DEV_LIST_LEN_MASK;
 218 }
 219
 220 /*
 221  * Get the port entry select on the pin. Return the port entry
 222  * id selected on the pin. Return 0 means the first port entry
 223  * is selected or MST is not supported.
 224  */
 225 static int hdac_hdmi_port_select_get(struct hdac_ext_device *edev,
 226                                         struct hdac_hdmi_port *port)
 227 {
 228         return snd_hdac_codec_read(&edev->hdev, port->pin->nid,
 229                                 0, AC_VERB_GET_DEVICE_SEL, 0);
 230 }
 231
 232 /*
 233  * Sets the selected port entry for the configuring Pin widget verb.
 234  * returns error if port set is not equal to port get otherwise success
 235  */
 236 static int hdac_hdmi_port_select_set(struct hdac_ext_device *edev,
 237                                         struct hdac_hdmi_port *port)
 238 {
 239         int num_ports;
 240
 241         if (!port->pin->mst_capable)
 242                 return 0;
 243
 244         /* AC_PAR_DEVLIST_LEN is 0 based. */
 245         num_ports = hdac_hdmi_get_port_len(edev, port->pin->nid);
 246
 247         if (num_ports < 0)
 248                 return -EIO;
 249         /*
 250          * Device List Length is a 0 based integer value indicating the
 251          * number of sink device that a MST Pin Widget can support.
 252          */
 253         if (num_ports + 1  < port->id)
 254                 return 0;
 255
 256         snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 257                         AC_VERB_SET_DEVICE_SEL, port->id);
 258
 259         if (port->id != hdac_hdmi_port_select_get(edev, port))
 260                 return -EIO;
 261
 262         dev_dbg(&edev->hdev.dev, "Selected the port=%d\n", port->id);
 263
 264         return 0;
 265 }
 266
 267 static struct hdac_hdmi_pcm *get_hdmi_pcm_from_id(struct hdac_hdmi_priv *hdmi,
 268                                                 int pcm_idx)
 269 {
 270         struct hdac_hdmi_pcm *pcm;
 271
 272         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 273                 if (pcm->pcm_id == pcm_idx)
 274                         return pcm;
 275         }
 276
 277         return NULL;
 278 }
 279
 280 static inline struct hdac_ext_device *to_hda_ext_device(struct device *dev)
 281 {
 282         struct hdac_device *hdev = dev_to_hdac_dev(dev);
 283
 284         return to_ehdac_device(hdev);
 285 }
 286
 287 static unsigned int sad_format(const u8 *sad)
 288 {
 289         return ((sad[0] >> 0x3) & 0x1f);
 290 }
 291
 292 static unsigned int sad_sample_bits_lpcm(const u8 *sad)
 293 {
 294         return (sad[2] & 7);
 295 }
 296
 297 static int hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime *runtime,
 298                                                 void *eld)
 299 {
 300         u64 formats = SNDRV_PCM_FMTBIT_S16;
 301         int i;
 302         const u8 *sad, *eld_buf = eld;
 303
 304         sad = drm_eld_sad(eld_buf);
 305         if (!sad)
 306                 goto format_constraint;
 307
 308         for (i = drm_eld_sad_count(eld_buf); i > 0; i--, sad += 3) {
 309                 if (sad_format(sad) == 1) { /* AUDIO_CODING_TYPE_LPCM */
 310
 311                         /*
 312                          * the controller support 20 and 24 bits in 32 bit
 313                          * container so we set S32
 314                          */
 315                         if (sad_sample_bits_lpcm(sad) & 0x6)
 316                                 formats |= SNDRV_PCM_FMTBIT_S32;
 317                 }
 318         }
 319
 320 format_constraint:
 321         return snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT,
 322                                 formats);
 323
 324 }
 325
 326 static void
 327 hdac_hdmi_set_dip_index(struct hdac_ext_device *edev, hda_nid_t pin_nid,
 328                                 int packet_index, int byte_index)
 329 {
 330         int val;
 331
 332         val = (packet_index << 5) | (byte_index & 0x1f);
 333
 334         snd_hdac_codec_write(&edev->hdev, pin_nid, 0,
 335                                 AC_VERB_SET_HDMI_DIP_INDEX, val);
 336 }
 337
 338 struct dp_audio_infoframe {
 339         u8 type; /* 0x84 */
 340         u8 len;  /* 0x1b */
 341         u8 ver;  /* 0x11 << 2 */
 342
 343         u8 CC02_CT47;   /* match with HDMI infoframe from this on */
 344         u8 SS01_SF24;
 345         u8 CXT04;
 346         u8 CA;
 347         u8 LFEPBL01_LSV36_DM_INH7;
 348 };
 349
 350 static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device *edev,
 351                    struct hdac_hdmi_pcm *pcm, struct hdac_hdmi_port *port)
 352 {
 353         uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE];
 354         struct hdmi_audio_infoframe frame;
 355         struct hdac_hdmi_pin *pin = port->pin;
 356         struct dp_audio_infoframe dp_ai;
 357         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 358         struct hdac_hdmi_cvt *cvt = pcm->cvt;
 359         u8 *dip;
 360         int ret;
 361         int i;
 362         const u8 *eld_buf;
 363         u8 conn_type;
 364         int channels, ca;
 365
 366         ca = snd_hdac_channel_allocation(&edev->hdev, port->eld.info.spk_alloc,
 367                         pcm->channels, pcm->chmap_set, true, pcm->chmap);
 368
 369         channels = snd_hdac_get_active_channels(ca);
 370         hdmi->chmap.ops.set_channel_count(&edev->hdev, cvt->nid, channels);
 371
 372         snd_hdac_setup_channel_mapping(&hdmi->chmap, pin->nid, false, ca,
 373                                 pcm->channels, pcm->chmap, pcm->chmap_set);
 374
 375         eld_buf = port->eld.eld_buffer;
 376         conn_type = drm_eld_get_conn_type(eld_buf);
 377
 378         switch (conn_type) {
 379         case DRM_ELD_CONN_TYPE_HDMI:
 380                 hdmi_audio_infoframe_init(&frame);
 381
 382                 frame.channels = channels;
 383                 frame.channel_allocation = ca;
 384
 385                 ret = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer));
 386                 if (ret < 0)
 387                         return ret;
 388
 389                 break;
 390
 391         case DRM_ELD_CONN_TYPE_DP:
 392                 memset(&dp_ai, 0, sizeof(dp_ai));
 393                 dp_ai.type      = 0x84;
 394                 dp_ai.len       = 0x1b;
 395                 dp_ai.ver       = 0x11 << 2;
 396                 dp_ai.CC02_CT47 = channels - 1;
 397                 dp_ai.CA        = ca;
 398
 399                 dip = (u8 *)&dp_ai;
 400                 break;
 401
 402         default:
 403                 dev_err(&edev->hdev.dev, "Invalid connection type: %d\n",
 404                                                 conn_type);
 405                 return -EIO;
 406         }
 407
 408         /* stop infoframe transmission */
 409         hdac_hdmi_set_dip_index(edev, pin->nid, 0x0, 0x0);
 410         snd_hdac_codec_write(&edev->hdev, pin->nid, 0,
 411                         AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_DISABLE);
 412
 413
 414         /*  Fill infoframe. Index auto-incremented */
 415         hdac_hdmi_set_dip_index(edev, pin->nid, 0x0, 0x0);
 416         if (conn_type == DRM_ELD_CONN_TYPE_HDMI) {
 417                 for (i = 0; i < sizeof(buffer); i++)
 418                         snd_hdac_codec_write(&edev->hdev, pin->nid, 0,
 419                                 AC_VERB_SET_HDMI_DIP_DATA, buffer[i]);
 420         } else {
 421                 for (i = 0; i < sizeof(dp_ai); i++)
 422                         snd_hdac_codec_write(&edev->hdev, pin->nid, 0,
 423                                 AC_VERB_SET_HDMI_DIP_DATA, dip[i]);
 424         }
 425
 426         /* Start infoframe */
 427         hdac_hdmi_set_dip_index(edev, pin->nid, 0x0, 0x0);
 428         snd_hdac_codec_write(&edev->hdev, pin->nid, 0,
 429                         AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_BEST);
 430
 431         return 0;
 432 }
 433
 434 static int hdac_hdmi_set_tdm_slot(struct snd_soc_dai *dai,
 435                 unsigned int tx_mask, unsigned int rx_mask,
 436                 int slots, int slot_width)
 437 {
 438         struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
 439         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 440         struct hdac_hdmi_dai_port_map *dai_map;
 441         struct hdac_hdmi_pcm *pcm;
 442
 443         dev_dbg(&edev->hdev.dev, "%s: strm_tag: %d\n", __func__, tx_mask);
 444
 445         dai_map = &hdmi->dai_map[dai->id];
 446
 447         pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
 448
 449         if (pcm)
 450                 pcm->stream_tag = (tx_mask << 4);
 451
 452         return 0;
 453 }
 454
 455 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream *substream,
 456         struct snd_pcm_hw_params *hparams, struct snd_soc_dai *dai)
 457 {
 458         struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
 459         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 460         struct hdac_hdmi_dai_port_map *dai_map;
 461         struct hdac_hdmi_port *port;
 462         struct hdac_hdmi_pcm *pcm;
 463         int format;
 464
 465         dai_map = &hdmi->dai_map[dai->id];
 466         port = dai_map->port;
 467
 468         if (!port)
 469                 return -ENODEV;
 470
 471         if ((!port->eld.monitor_present) || (!port->eld.eld_valid)) {
 472                 dev_err(&edev->hdev.dev,
 473                         "device is not configured for this pin:port%d:%d\n",
 474                                         port->pin->nid, port->id);
 475                 return -ENODEV;
 476         }
 477
 478         format = snd_hdac_calc_stream_format(params_rate(hparams),
 479                         params_channels(hparams), params_format(hparams),
 480                         dai->driver->playback.sig_bits, 0);
 481
 482         pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
 483         if (!pcm)
 484                 return -EIO;
 485
 486         pcm->format = format;
 487         pcm->channels = params_channels(hparams);
 488
 489         return 0;
 490 }
 491
 492 static int hdac_hdmi_query_port_connlist(struct hdac_ext_device *edev,
 493                                         struct hdac_hdmi_pin *pin,
 494                                         struct hdac_hdmi_port *port)
 495 {
 496         if (!(get_wcaps(&edev->hdev, pin->nid) & AC_WCAP_CONN_LIST)) {
 497                 dev_warn(&edev->hdev.dev,
 498                         "HDMI: pin %d wcaps %#x does not support connection list\n",
 499                         pin->nid, get_wcaps(&edev->hdev, pin->nid));
 500                 return -EINVAL;
 501         }
 502
 503         if (hdac_hdmi_port_select_set(edev, port) < 0)
 504                 return -EIO;
 505
 506         port->num_mux_nids = snd_hdac_get_connections(&edev->hdev, pin->nid,
 507                         port->mux_nids, HDA_MAX_CONNECTIONS);
 508         if (port->num_mux_nids == 0)
 509                 dev_warn(&edev->hdev.dev,
 510                         "No connections found for pin:port %d:%d\n",
 511                                                 pin->nid, port->id);
 512
 513         dev_dbg(&edev->hdev.dev, "num_mux_nids %d for pin:port %d:%d\n",
 514                         port->num_mux_nids, pin->nid, port->id);
 515
 516         return port->num_mux_nids;
 517 }
 518
 519 /*
 520  * Query pcm list and return port to which stream is routed.
 521  *
 522  * Also query connection list of the pin, to validate the cvt to port map.
 523  *
 524  * Same stream rendering to multiple ports simultaneously can be done
 525  * possibly, but not supported for now in driver. So return the first port
 526  * connected.
 527  */
 528 static struct hdac_hdmi_port *hdac_hdmi_get_port_from_cvt(
 529                         struct hdac_ext_device *edev,
 530                         struct hdac_hdmi_priv *hdmi,
 531                         struct hdac_hdmi_cvt *cvt)
 532 {
 533         struct hdac_hdmi_pcm *pcm;
 534         struct hdac_hdmi_port *port = NULL;
 535         int ret, i;
 536
 537         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 538                 if (pcm->cvt == cvt) {
 539                         if (list_empty(&pcm->port_list))
 540                                 continue;
 541
 542                         list_for_each_entry(port, &pcm->port_list, head) {
 543                                 mutex_lock(&pcm->lock);
 544                                 ret = hdac_hdmi_query_port_connlist(edev,
 545                                                         port->pin, port);
 546                                 mutex_unlock(&pcm->lock);
 547                                 if (ret < 0)
 548                                         continue;
 549
 550                                 for (i = 0; i < port->num_mux_nids; i++) {
 551                                         if (port->mux_nids[i] == cvt->nid &&
 552                                                 port->eld.monitor_present &&
 553                                                 port->eld.eld_valid)
 554                                                 return port;
 555                                 }
 556                         }
 557                 }
 558         }
 559
 560         return NULL;
 561 }
 562
 563 /*
 564  * This tries to get a valid pin and set the HW constraints based on the
 565  * ELD. Even if a valid pin is not found return success so that device open
 566  * doesn't fail.
 567  */
 568 static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
 569                         struct snd_soc_dai *dai)
 570 {
 571         struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
 572         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 573         struct hdac_hdmi_dai_port_map *dai_map;
 574         struct hdac_hdmi_cvt *cvt;
 575         struct hdac_hdmi_port *port;
 576         int ret;
 577
 578         dai_map = &hdmi->dai_map[dai->id];
 579
 580         cvt = dai_map->cvt;
 581         port = hdac_hdmi_get_port_from_cvt(edev, hdmi, cvt);
 582
 583         /*
 584          * To make PA and other userland happy.
 585          * userland scans devices so returning error does not help.
 586          */
 587         if (!port)
 588                 return 0;
 589         if ((!port->eld.monitor_present) ||
 590                         (!port->eld.eld_valid)) {
 591
 592                 dev_warn(&edev->hdev.dev,
 593                         "Failed: present?:%d ELD valid?:%d pin:port: %d:%d\n",
 594                         port->eld.monitor_present, port->eld.eld_valid,
 595                         port->pin->nid, port->id);
 596
 597                 return 0;
 598         }
 599
 600         dai_map->port = port;
 601
 602         ret = hdac_hdmi_eld_limit_formats(substream->runtime,
 603                                 port->eld.eld_buffer);
 604         if (ret < 0)
 605                 return ret;
 606
 607         return snd_pcm_hw_constraint_eld(substream->runtime,
 608                                 port->eld.eld_buffer);
 609 }
 610
 611 static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
 612                 struct snd_soc_dai *dai)
 613 {
 614         struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
 615         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 616         struct hdac_hdmi_dai_port_map *dai_map;
 617         struct hdac_hdmi_pcm *pcm;
 618
 619         dai_map = &hdmi->dai_map[dai->id];
 620
 621         pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
 622
 623         if (pcm) {
 624                 mutex_lock(&pcm->lock);
 625                 pcm->chmap_set = false;
 626                 memset(pcm->chmap, 0, sizeof(pcm->chmap));
 627                 pcm->channels = 0;
 628                 mutex_unlock(&pcm->lock);
 629         }
 630
 631         if (dai_map->port)
 632                 dai_map->port = NULL;
 633 }
 634
 635 static int
 636 hdac_hdmi_query_cvt_params(struct hdac_device *hdev, struct hdac_hdmi_cvt *cvt)
 637 {
 638         unsigned int chans;
 639         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
 640         int err;
 641
 642         chans = get_wcaps(hdev, cvt->nid);
 643         chans = get_wcaps_channels(chans);
 644
 645         cvt->params.channels_min = 2;
 646
 647         cvt->params.channels_max = chans;
 648         if (chans > hdmi->chmap.channels_max)
 649                 hdmi->chmap.channels_max = chans;
 650
 651         err = snd_hdac_query_supported_pcm(hdev, cvt->nid,
 652                         &cvt->params.rates,
 653                         &cvt->params.formats,
 654                         &cvt->params.maxbps);
 655         if (err < 0)
 656                 dev_err(&hdev->dev,
 657                         "Failed to query pcm params for nid %d: %d\n",
 658                         cvt->nid, err);
 659
 660         return err;
 661 }
 662
 663 static int hdac_hdmi_fill_widget_info(struct device *dev,
 664                 struct snd_soc_dapm_widget *w, enum snd_soc_dapm_type id,
 665                 void *priv, const char *wname, const char *stream,
 666                 struct snd_kcontrol_new *wc, int numkc,
 667                 int (*event)(struct snd_soc_dapm_widget *,
 668                 struct snd_kcontrol *, int), unsigned short event_flags)
 669 {
 670         w->id = id;
 671         w->name = devm_kstrdup(dev, wname, GFP_KERNEL);
 672         if (!w->name)
 673                 return -ENOMEM;
 674
 675         w->sname = stream;
 676         w->reg = SND_SOC_NOPM;
 677         w->shift = 0;
 678         w->kcontrol_news = wc;
 679         w->num_kcontrols = numkc;
 680         w->priv = priv;
 681         w->event = event;
 682         w->event_flags = event_flags;
 683
 684         return 0;
 685 }
 686
 687 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route *route,
 688                 const char *sink, const char *control, const char *src,
 689                 int (*handler)(struct snd_soc_dapm_widget *src,
 690                         struct snd_soc_dapm_widget *sink))
 691 {
 692         route->sink = sink;
 693         route->source = src;
 694         route->control = control;
 695         route->connected = handler;
 696 }
 697
 698 static struct hdac_hdmi_pcm *hdac_hdmi_get_pcm(struct hdac_ext_device *edev,
 699                                         struct hdac_hdmi_port *port)
 700 {
 701         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 702         struct hdac_hdmi_pcm *pcm = NULL;
 703         struct hdac_hdmi_port *p;
 704
 705         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 706                 if (list_empty(&pcm->port_list))
 707                         continue;
 708
 709                 list_for_each_entry(p, &pcm->port_list, head) {
 710                         if (p->id == port->id && port->pin == p->pin)
 711                                 return pcm;
 712                 }
 713         }
 714
 715         return NULL;
 716 }
 717
 718 static void hdac_hdmi_set_power_state(struct hdac_ext_device *edev,
 719                              hda_nid_t nid, unsigned int pwr_state)
 720 {
 721         int count;
 722         unsigned int state;
 723
 724         if (get_wcaps(&edev->hdev, nid) & AC_WCAP_POWER) {
 725                 if (!snd_hdac_check_power_state(&edev->hdev, nid, pwr_state)) {
 726                         for (count = 0; count < 10; count++) {
 727                                 snd_hdac_codec_read(&edev->hdev, nid, 0,
 728                                                 AC_VERB_SET_POWER_STATE,
 729                                                 pwr_state);
 730                                 state = snd_hdac_sync_power_state(&edev->hdev,
 731                                                 nid, pwr_state);
 732                                 if (!(state & AC_PWRST_ERROR))
 733                                         break;
 734                         }
 735                 }
 736
 737         }
 738 }
 739
 740 static void hdac_hdmi_set_amp(struct hdac_ext_device *edev,
 741                                    hda_nid_t nid, int val)
 742 {
 743         if (get_wcaps(&edev->hdev, nid) & AC_WCAP_OUT_AMP)
 744                 snd_hdac_codec_write(&edev->hdev, nid, 0,
 745                                         AC_VERB_SET_AMP_GAIN_MUTE, val);
 746 }
 747
 748
 749 static int hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget *w,
 750                                         struct snd_kcontrol *kc, int event)
 751 {
 752         struct hdac_hdmi_port *port = w->priv;
 753         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 754         struct hdac_hdmi_pcm *pcm;
 755
 756         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 757                         __func__, w->name, event);
 758
 759         pcm = hdac_hdmi_get_pcm(edev, port);
 760         if (!pcm)
 761                 return -EIO;
 762
 763         /* set the device if pin is mst_capable */
 764         if (hdac_hdmi_port_select_set(edev, port) < 0)
 765                 return -EIO;
 766
 767         switch (event) {
 768         case SND_SOC_DAPM_PRE_PMU:
 769                 hdac_hdmi_set_power_state(edev, port->pin->nid, AC_PWRST_D0);
 770
 771                 /* Enable out path for this pin widget */
 772                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 773                                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 774
 775                 hdac_hdmi_set_amp(edev, port->pin->nid, AMP_OUT_UNMUTE);
 776
 777                 return hdac_hdmi_setup_audio_infoframe(edev, pcm, port);
 778
 779         case SND_SOC_DAPM_POST_PMD:
 780                 hdac_hdmi_set_amp(edev, port->pin->nid, AMP_OUT_MUTE);
 781
 782                 /* Disable out path for this pin widget */
 783                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 784                                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 785
 786                 hdac_hdmi_set_power_state(edev, port->pin->nid, AC_PWRST_D3);
 787                 break;
 788
 789         }
 790
 791         return 0;
 792 }
 793
 794 static int hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget *w,
 795                                         struct snd_kcontrol *kc, int event)
 796 {
 797         struct hdac_hdmi_cvt *cvt = w->priv;
 798         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 799         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 800         struct hdac_hdmi_pcm *pcm;
 801
 802         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 803                         __func__, w->name, event);
 804
 805         pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, cvt);
 806         if (!pcm)
 807                 return -EIO;
 808
 809         switch (event) {
 810         case SND_SOC_DAPM_PRE_PMU:
 811                 hdac_hdmi_set_power_state(edev, cvt->nid, AC_PWRST_D0);
 812
 813                 /* Enable transmission */
 814                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 815                         AC_VERB_SET_DIGI_CONVERT_1, 1);
 816
 817                 /* Category Code (CC) to zero */
 818                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 819                         AC_VERB_SET_DIGI_CONVERT_2, 0);
 820
 821                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 822                                 AC_VERB_SET_CHANNEL_STREAMID, pcm->stream_tag);
 823                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 824                                 AC_VERB_SET_STREAM_FORMAT, pcm->format);
 825                 break;
 826
 827         case SND_SOC_DAPM_POST_PMD:
 828                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 829                                 AC_VERB_SET_CHANNEL_STREAMID, 0);
 830                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 831                                 AC_VERB_SET_STREAM_FORMAT, 0);
 832
 833                 hdac_hdmi_set_power_state(edev, cvt->nid, AC_PWRST_D3);
 834                 break;
 835
 836         }
 837
 838         return 0;
 839 }
 840
 841 static int hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget *w,
 842                                         struct snd_kcontrol *kc, int event)
 843 {
 844         struct hdac_hdmi_port *port = w->priv;
 845         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 846         int mux_idx;
 847
 848         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 849                         __func__, w->name, event);
 850
 851         if (!kc)
 852                 kc  = w->kcontrols[0];
 853
 854         mux_idx = dapm_kcontrol_get_value(kc);
 855
 856         /* set the device if pin is mst_capable */
 857         if (hdac_hdmi_port_select_set(edev, port) < 0)
 858                 return -EIO;
 859
 860         if (mux_idx > 0) {
 861                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 862                         AC_VERB_SET_CONNECT_SEL, (mux_idx - 1));
 863         }
 864
 865         return 0;
 866 }
 867
 868 /*
 869  * Based on user selection, map the PINs with the PCMs.
 870  */
 871 static int hdac_hdmi_set_pin_port_mux(struct snd_kcontrol *kcontrol,
 872                 struct snd_ctl_elem_value *ucontrol)
 873 {
 874         int ret;
 875         struct hdac_hdmi_port *p, *p_next;
 876         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 877         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
 878         struct snd_soc_dapm_context *dapm = w->dapm;
 879         struct hdac_hdmi_port *port = w->priv;
 880         struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev);
 881         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 882         struct hdac_hdmi_pcm *pcm = NULL;
 883         const char *cvt_name =  e->texts[ucontrol->value.enumerated.item[0]];
 884
 885         ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
 886         if (ret < 0)
 887                 return ret;
 888
 889         if (port == NULL)
 890                 return -EINVAL;
 891
 892         mutex_lock(&hdmi->pin_mutex);
 893         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 894                 if (list_empty(&pcm->port_list))
 895                         continue;
 896
 897                 list_for_each_entry_safe(p, p_next, &pcm->port_list, head) {
 898                         if (p == port && p->id == port->id &&
 899                                         p->pin == port->pin) {
 900                                 hdac_hdmi_jack_report(pcm, port, false);
 901                                 list_del(&p->head);
 902                         }
 903                 }
 904         }
 905
 906         /*
 907          * Jack status is not reported during device probe as the
 908          * PCMs are not registered by then. So report it here.
 909          */
 910         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 911                 if (!strcmp(cvt_name, pcm->cvt->name)) {
 912                         list_add_tail(&port->head, &pcm->port_list);
 913                         if (port->eld.monitor_present && port->eld.eld_valid) {
 914                                 hdac_hdmi_jack_report(pcm, port, true);
 915                                 mutex_unlock(&hdmi->pin_mutex);
 916                                 return ret;
 917                         }
 918                 }
 919         }
 920         mutex_unlock(&hdmi->pin_mutex);
 921
 922         return ret;
 923 }
 924
 925 /*
 926  * Ideally the Mux inputs should be based on the num_muxs enumerated, but
 927  * the display driver seem to be programming the connection list for the pin
 928  * widget runtime.
 929  *
 930  * So programming all the possible inputs for the mux, the user has to take
 931  * care of selecting the right one and leaving all other inputs selected to
 932  * "NONE"
 933  */
 934 static int hdac_hdmi_create_pin_port_muxs(struct hdac_ext_device *edev,
 935                                 struct hdac_hdmi_port *port,
 936                                 struct snd_soc_dapm_widget *widget,
 937                                 const char *widget_name)
 938 {
 939         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 940         struct hdac_hdmi_pin *pin = port->pin;
 941         struct snd_kcontrol_new *kc;
 942         struct hdac_hdmi_cvt *cvt;
 943         struct soc_enum *se;
 944         char kc_name[NAME_SIZE];
 945         char mux_items[NAME_SIZE];
 946         /* To hold inputs to the Pin mux */
 947         char *items[HDA_MAX_CONNECTIONS];
 948         int i = 0;
 949         int num_items = hdmi->num_cvt + 1;
 950
 951         kc = devm_kzalloc(&edev->hdev.dev, sizeof(*kc), GFP_KERNEL);
 952         if (!kc)
 953                 return -ENOMEM;
 954
 955         se = devm_kzalloc(&edev->hdev.dev, sizeof(*se), GFP_KERNEL);
 956         if (!se)
 957                 return -ENOMEM;
 958
 959         snprintf(kc_name, NAME_SIZE, "Pin %d port %d Input",
 960                                                 pin->nid, port->id);
 961         kc->name = devm_kstrdup(&edev->hdev.dev, kc_name, GFP_KERNEL);
 962         if (!kc->name)
 963                 return -ENOMEM;
 964
 965         kc->private_value = (long)se;
 966         kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 967         kc->access = 0;
 968         kc->info = snd_soc_info_enum_double;
 969         kc->put = hdac_hdmi_set_pin_port_mux;
 970         kc->get = snd_soc_dapm_get_enum_double;
 971
 972         se->reg = SND_SOC_NOPM;
 973
 974         /* enum texts: ["NONE", "cvt #", "cvt #", ...] */
 975         se->items = num_items;
 976         se->mask = roundup_pow_of_two(se->items) - 1;
 977
 978         sprintf(mux_items, "NONE");
 979         items[i] = devm_kstrdup(&edev->hdev.dev, mux_items, GFP_KERNEL);
 980         if (!items[i])
 981                 return -ENOMEM;
 982
 983         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
 984                 i++;
 985                 sprintf(mux_items, "cvt %d", cvt->nid);
 986                 items[i] = devm_kstrdup(&edev->hdev.dev, mux_items, GFP_KERNEL);
 987                 if (!items[i])
 988                         return -ENOMEM;
 989         }
 990
 991         se->texts = devm_kmemdup(&edev->hdev.dev, items,
 992                         (num_items  * sizeof(char *)), GFP_KERNEL);
 993         if (!se->texts)
 994                 return -ENOMEM;
 995
 996         return hdac_hdmi_fill_widget_info(&edev->hdev.dev, widget,
 997                         snd_soc_dapm_mux, port, widget_name, NULL, kc, 1,
 998                         hdac_hdmi_pin_mux_widget_event,
 999                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_REG);
1000 }
1001
1002 /* Add cvt <- input <- mux route map */
1003 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_ext_device *edev,
1004                         struct snd_soc_dapm_widget *widgets,
1005                         struct snd_soc_dapm_route *route, int rindex)
1006 {
1007         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1008         const struct snd_kcontrol_new *kc;
1009         struct soc_enum *se;
1010         int mux_index = hdmi->num_cvt + hdmi->num_ports;
1011         int i, j;
1012
1013         for (i = 0; i < hdmi->num_ports; i++) {
1014                 kc = widgets[mux_index].kcontrol_news;
1015                 se = (struct soc_enum *)kc->private_value;
1016                 for (j = 0; j < hdmi->num_cvt; j++) {
1017                         hdac_hdmi_fill_route(&route[rindex],
1018                                         widgets[mux_index].name,
1019                                         se->texts[j + 1],
1020                                         widgets[j].name, NULL);
1021
1022                         rindex++;
1023                 }
1024
1025                 mux_index++;
1026         }
1027 }
1028
1029 /*
1030  * Widgets are added in the below sequence
1031  *      Converter widgets for num converters enumerated
1032  *      Pin-port widgets for num ports for Pins enumerated
1033  *      Pin-port mux widgets to represent connenction list of pin widget
1034  *
1035  * For each port, one Mux and One output widget is added
1036  * Total widgets elements = num_cvt + (num_ports * 2);
1037  *
1038  * Routes are added as below:
1039  *      pin-port mux -> pin (based on num_ports)
1040  *      cvt -> "Input sel control" -> pin-port_mux
1041  *
1042  * Total route elements:
1043  *      num_ports + (pin_muxes * num_cvt)
1044  */
1045 static int create_fill_widget_route_map(struct snd_soc_dapm_context *dapm)
1046 {
1047         struct snd_soc_dapm_widget *widgets;
1048         struct snd_soc_dapm_route *route;
1049         struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev);
1050         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1051         struct snd_soc_dai_driver *dai_drv = hdmi->dai_drv;
1052         char widget_name[NAME_SIZE];
1053         struct hdac_hdmi_cvt *cvt;
1054         struct hdac_hdmi_pin *pin;
1055         int ret, i = 0, num_routes = 0, j;
1056
1057         if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list))
1058                 return -EINVAL;
1059
1060         widgets = devm_kzalloc(dapm->dev, (sizeof(*widgets) *
1061                                 ((2 * hdmi->num_ports) + hdmi->num_cvt)),
1062                                 GFP_KERNEL);
1063
1064         if (!widgets)
1065                 return -ENOMEM;
1066
1067         /* DAPM widgets to represent each converter widget */
1068         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1069                 sprintf(widget_name, "Converter %d", cvt->nid);
1070                 ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1071                         snd_soc_dapm_aif_in, cvt,
1072                         widget_name, dai_drv[i].playback.stream_name, NULL, 0,
1073                         hdac_hdmi_cvt_output_widget_event,
1074                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD);
1075                 if (ret < 0)
1076                         return ret;
1077                 i++;
1078         }
1079
1080         list_for_each_entry(pin, &hdmi->pin_list, head) {
1081                 for (j = 0; j < pin->num_ports; j++) {
1082                         sprintf(widget_name, "hif%d-%d Output",
1083                                 pin->nid, pin->ports[j].id);
1084                         ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1085                                         snd_soc_dapm_output, &pin->ports[j],
1086                                         widget_name, NULL, NULL, 0,
1087                                         hdac_hdmi_pin_output_widget_event,
1088                                         SND_SOC_DAPM_PRE_PMU |
1089                                         SND_SOC_DAPM_POST_PMD);
1090                         if (ret < 0)
1091                                 return ret;
1092                         pin->ports[j].output_pin = widgets[i].name;
1093                         i++;
1094                 }
1095         }
1096
1097         /* DAPM widgets to represent the connection list to pin widget */
1098         list_for_each_entry(pin, &hdmi->pin_list, head) {
1099                 for (j = 0; j < pin->num_ports; j++) {
1100                         sprintf(widget_name, "Pin%d-Port%d Mux",
1101                                 pin->nid, pin->ports[j].id);
1102                         ret = hdac_hdmi_create_pin_port_muxs(edev,
1103                                                 &pin->ports[j], &widgets[i],
1104                                                 widget_name);
1105                         if (ret < 0)
1106                                 return ret;
1107                         i++;
1108
1109                         /* For cvt to pin_mux mapping */
1110                         num_routes += hdmi->num_cvt;
1111
1112                         /* For pin_mux to pin mapping */
1113                         num_routes++;
1114                 }
1115         }
1116
1117         route = devm_kzalloc(dapm->dev, (sizeof(*route) * num_routes),
1118                                                         GFP_KERNEL);
1119         if (!route)
1120                 return -ENOMEM;
1121
1122         i = 0;
1123         /* Add pin <- NULL <- mux route map */
1124         list_for_each_entry(pin, &hdmi->pin_list, head) {
1125                 for (j = 0; j < pin->num_ports; j++) {
1126                         int sink_index = i + hdmi->num_cvt;
1127                         int src_index = sink_index + pin->num_ports *
1128                                                 hdmi->num_pin;
1129
1130                         hdac_hdmi_fill_route(&route[i],
1131                                 widgets[sink_index].name, NULL,
1132                                 widgets[src_index].name, NULL);
1133                         i++;
1134                 }
1135         }
1136
1137         hdac_hdmi_add_pinmux_cvt_route(edev, widgets, route, i);
1138
1139         snd_soc_dapm_new_controls(dapm, widgets,
1140                 ((2 * hdmi->num_ports) + hdmi->num_cvt));
1141
1142         snd_soc_dapm_add_routes(dapm, route, num_routes);
1143         snd_soc_dapm_new_widgets(dapm->card);
1144
1145         return 0;
1146
1147 }
1148
1149 static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
1150 {
1151         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1152         struct hdac_hdmi_dai_port_map *dai_map;
1153         struct hdac_hdmi_cvt *cvt;
1154         int dai_id = 0;
1155
1156         if (list_empty(&hdmi->cvt_list))
1157                 return -EINVAL;
1158
1159         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1160                 dai_map = &hdmi->dai_map[dai_id];
1161                 dai_map->dai_id = dai_id;
1162                 dai_map->cvt = cvt;
1163
1164                 dai_id++;
1165
1166                 if (dai_id == HDA_MAX_CVTS) {
1167                         dev_warn(&edev->hdev.dev,
1168                                 "Max dais supported: %d\n", dai_id);
1169                         break;
1170                 }
1171         }
1172
1173         return 0;
1174 }
1175
1176 static int hdac_hdmi_add_cvt(struct hdac_ext_device *edev, hda_nid_t nid)
1177 {
1178         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1179         struct hdac_hdmi_cvt *cvt;
1180         char name[NAME_SIZE];
1181
1182         cvt = kzalloc(sizeof(*cvt), GFP_KERNEL);
1183         if (!cvt)
1184                 return -ENOMEM;
1185
1186         cvt->nid = nid;
1187         sprintf(name, "cvt %d", cvt->nid);
1188         cvt->name = kstrdup(name, GFP_KERNEL);
1189
1190         list_add_tail(&cvt->head, &hdmi->cvt_list);
1191         hdmi->num_cvt++;
1192
1193         return hdac_hdmi_query_cvt_params(&edev->hdev, cvt);
1194 }
1195
1196 static int hdac_hdmi_parse_eld(struct hdac_ext_device *edev,
1197                         struct hdac_hdmi_port *port)
1198 {
1199         unsigned int ver, mnl;
1200
1201         ver = (port->eld.eld_buffer[DRM_ELD_VER] & DRM_ELD_VER_MASK)
1202                                                 >> DRM_ELD_VER_SHIFT;
1203
1204         if (ver != ELD_VER_CEA_861D && ver != ELD_VER_PARTIAL) {
1205                 dev_err(&edev->hdev.dev, "HDMI: Unknown ELD version %d\n", ver);
1206                 return -EINVAL;
1207         }
1208
1209         mnl = (port->eld.eld_buffer[DRM_ELD_CEA_EDID_VER_MNL] &
1210                 DRM_ELD_MNL_MASK) >> DRM_ELD_MNL_SHIFT;
1211
1212         if (mnl > ELD_MAX_MNL) {
1213                 dev_err(&edev->hdev.dev, "HDMI: MNL Invalid %d\n", mnl);
1214                 return -EINVAL;
1215         }
1216
1217         port->eld.info.spk_alloc = port->eld.eld_buffer[DRM_ELD_SPEAKER];
1218
1219         return 0;
1220 }
1221
1222 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin *pin,
1223                                     struct hdac_hdmi_port *port)
1224 {
1225         struct hdac_ext_device *edev = pin->edev;
1226         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1227         struct hdac_hdmi_pcm *pcm;
1228         int size = 0;
1229         int port_id = -1;
1230
1231         if (!hdmi)
1232                 return;
1233
1234         /*
1235          * In case of non MST pin, get_eld info API expectes port
1236          * to be -1.
1237          */
1238         mutex_lock(&hdmi->pin_mutex);
1239         port->eld.monitor_present = false;
1240
1241         if (pin->mst_capable)
1242                 port_id = port->id;
1243
1244         size = snd_hdac_acomp_get_eld(&edev->hdev, pin->nid, port_id,
1245                                 &port->eld.monitor_present,
1246                                 port->eld.eld_buffer,
1247                                 ELD_MAX_SIZE);
1248
1249         if (size > 0) {
1250                 size = min(size, ELD_MAX_SIZE);
1251                 if (hdac_hdmi_parse_eld(edev, port) < 0)
1252                         size = -EINVAL;
1253         }
1254
1255         if (size > 0) {
1256                 port->eld.eld_valid = true;
1257                 port->eld.eld_size = size;
1258         } else {
1259                 port->eld.eld_valid = false;
1260                 port->eld.eld_size = 0;
1261         }
1262
1263         pcm = hdac_hdmi_get_pcm(edev, port);
1264
1265         if (!port->eld.monitor_present || !port->eld.eld_valid) {
1266
1267                 dev_err(&edev->hdev.dev, "%s: disconnect for pin:port %d:%d\n",
1268                                                 __func__, pin->nid, port->id);
1269
1270                 /*
1271                  * PCMs are not registered during device probe, so don't
1272                  * report jack here. It will be done in usermode mux
1273                  * control select.
1274                  */
1275                 if (pcm)
1276                         hdac_hdmi_jack_report(pcm, port, false);
1277
1278                 mutex_unlock(&hdmi->pin_mutex);
1279                 return;
1280         }
1281
1282         if (port->eld.monitor_present && port->eld.eld_valid) {
1283                 if (pcm)
1284                         hdac_hdmi_jack_report(pcm, port, true);
1285
1286                 print_hex_dump_debug("ELD: ", DUMP_PREFIX_OFFSET, 16, 1,
1287                           port->eld.eld_buffer, port->eld.eld_size, false);
1288
1289         }
1290         mutex_unlock(&hdmi->pin_mutex);
1291 }
1292
1293 static int hdac_hdmi_add_ports(struct hdac_hdmi_priv *hdmi,
1294                                 struct hdac_hdmi_pin *pin)
1295 {
1296         struct hdac_hdmi_port *ports;
1297         int max_ports = HDA_MAX_PORTS;
1298         int i;
1299
1300         /*
1301          * FIXME: max_port may vary for each platform, so pass this as
1302          * as driver data or query from i915 interface when this API is
1303          * implemented.
1304          */
1305
1306         ports = kcalloc(max_ports, sizeof(*ports), GFP_KERNEL);
1307         if (!ports)
1308                 return -ENOMEM;
1309
1310         for (i = 0; i < max_ports; i++) {
1311                 ports[i].id = i;
1312                 ports[i].pin = pin;
1313         }
1314         pin->ports = ports;
1315         pin->num_ports = max_ports;
1316         return 0;
1317 }
1318
1319 static int hdac_hdmi_add_pin(struct hdac_ext_device *edev, hda_nid_t nid)
1320 {
1321         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1322         struct hdac_hdmi_pin *pin;
1323         int ret;
1324
1325         pin = kzalloc(sizeof(*pin), GFP_KERNEL);
1326         if (!pin)
1327                 return -ENOMEM;
1328
1329         pin->nid = nid;
1330         pin->mst_capable = false;
1331         pin->edev = edev;
1332         ret = hdac_hdmi_add_ports(hdmi, pin);
1333         if (ret < 0)
1334                 return ret;
1335
1336         list_add_tail(&pin->head, &hdmi->pin_list);
1337         hdmi->num_pin++;
1338         hdmi->num_ports += pin->num_ports;
1339
1340         return 0;
1341 }
1342
1343 #define INTEL_VENDOR_NID 0x08
1344 #define INTEL_GLK_VENDOR_NID 0x0b
1345 #define INTEL_GET_VENDOR_VERB 0xf81
1346 #define INTEL_SET_VENDOR_VERB 0x781
1347 #define INTEL_EN_DP12                   0x02 /* enable DP 1.2 features */
1348 #define INTEL_EN_ALL_PIN_CVTS   0x01 /* enable 2nd & 3rd pins and convertors */
1349
1350 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device *hdev)
1351 {
1352         unsigned int vendor_param;
1353         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1354         unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1355
1356         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1357                                 INTEL_GET_VENDOR_VERB, 0);
1358         if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS)
1359                 return;
1360
1361         vendor_param |= INTEL_EN_ALL_PIN_CVTS;
1362         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1363                                 INTEL_SET_VENDOR_VERB, vendor_param);
1364         if (vendor_param == -1)
1365                 return;
1366 }
1367
1368 static void hdac_hdmi_skl_enable_dp12(struct hdac_device *hdev)
1369 {
1370         unsigned int vendor_param;
1371         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1372         unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1373
1374         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1375                                 INTEL_GET_VENDOR_VERB, 0);
1376         if (vendor_param == -1 || vendor_param & INTEL_EN_DP12)
1377                 return;
1378
1379         /* enable DP1.2 mode */
1380         vendor_param |= INTEL_EN_DP12;
1381         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1382                                 INTEL_SET_VENDOR_VERB, vendor_param);
1383         if (vendor_param == -1)
1384                 return;
1385
1386 }
1387
1388 static const struct snd_soc_dai_ops hdmi_dai_ops = {
1389         .startup = hdac_hdmi_pcm_open,
1390         .shutdown = hdac_hdmi_pcm_close,
1391         .hw_params = hdac_hdmi_set_hw_params,
1392         .set_tdm_slot = hdac_hdmi_set_tdm_slot,
1393 };
1394
1395 /*
1396  * Each converter can support a stream independently. So a dai is created
1397  * based on the number of converter queried.
1398  */
1399 static int hdac_hdmi_create_dais(struct hdac_device *hdev,
1400                 struct snd_soc_dai_driver **dais,
1401                 struct hdac_hdmi_priv *hdmi, int num_dais)
1402 {
1403         struct snd_soc_dai_driver *hdmi_dais;
1404         struct hdac_hdmi_cvt *cvt;
1405         char name[NAME_SIZE], dai_name[NAME_SIZE];
1406         int i = 0;
1407         u32 rates, bps;
1408         unsigned int rate_max = 384000, rate_min = 8000;
1409         u64 formats;
1410         int ret;
1411
1412         hdmi_dais = devm_kzalloc(&hdev->dev,
1413                         (sizeof(*hdmi_dais) * num_dais),
1414                         GFP_KERNEL);
1415         if (!hdmi_dais)
1416                 return -ENOMEM;
1417
1418         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1419                 ret = snd_hdac_query_supported_pcm(hdev, cvt->nid,
1420                                         &rates, &formats, &bps);
1421                 if (ret)
1422                         return ret;
1423
1424                 sprintf(dai_name, "intel-hdmi-hifi%d", i+1);
1425                 hdmi_dais[i].name = devm_kstrdup(&hdev->dev,
1426                                         dai_name, GFP_KERNEL);
1427
1428                 if (!hdmi_dais[i].name)
1429                         return -ENOMEM;
1430
1431                 snprintf(name, sizeof(name), "hifi%d", i+1);
1432                 hdmi_dais[i].playback.stream_name =
1433                                 devm_kstrdup(&hdev->dev, name, GFP_KERNEL);
1434                 if (!hdmi_dais[i].playback.stream_name)
1435                         return -ENOMEM;
1436
1437                 /*
1438                  * Set caps based on capability queried from the converter.
1439                  * It will be constrained runtime based on ELD queried.
1440                  */
1441                 hdmi_dais[i].playback.formats = formats;
1442                 hdmi_dais[i].playback.rates = rates;
1443                 hdmi_dais[i].playback.rate_max = rate_max;
1444                 hdmi_dais[i].playback.rate_min = rate_min;
1445                 hdmi_dais[i].playback.channels_min = 2;
1446                 hdmi_dais[i].playback.channels_max = 2;
1447                 hdmi_dais[i].playback.sig_bits = bps;
1448                 hdmi_dais[i].ops = &hdmi_dai_ops;
1449                 i++;
1450         }
1451
1452         *dais = hdmi_dais;
1453         hdmi->dai_drv = hdmi_dais;
1454
1455         return 0;
1456 }
1457
1458 /*
1459  * Parse all nodes and store the cvt/pin nids in array
1460  * Add one time initialization for pin and cvt widgets
1461  */
1462 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device *edev,
1463                 struct snd_soc_dai_driver **dais, int *num_dais)
1464 {
1465         hda_nid_t nid;
1466         int i, num_nodes;
1467         struct hdac_hdmi_cvt *temp_cvt, *cvt_next;
1468         struct hdac_hdmi_pin *temp_pin, *pin_next;
1469         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1470         struct hdac_device *hdev = &edev->hdev;
1471         int ret;
1472
1473         hdac_hdmi_skl_enable_all_pins(hdev);
1474         hdac_hdmi_skl_enable_dp12(hdev);
1475
1476         num_nodes = snd_hdac_get_sub_nodes(hdev, hdev->afg, &nid);
1477         if (!nid || num_nodes <= 0) {
1478                 dev_warn(&hdev->dev, "HDMI: failed to get afg sub nodes\n");
1479                 return -EINVAL;
1480         }
1481
1482         for (i = 0; i < num_nodes; i++, nid++) {
1483                 unsigned int caps;
1484                 unsigned int type;
1485
1486                 caps = get_wcaps(hdev, nid);
1487                 type = get_wcaps_type(caps);
1488
1489                 if (!(caps & AC_WCAP_DIGITAL))
1490                         continue;
1491
1492                 switch (type) {
1493
1494                 case AC_WID_AUD_OUT:
1495                         ret = hdac_hdmi_add_cvt(edev, nid);
1496                         if (ret < 0)
1497                                 goto free_widgets;
1498                         break;
1499
1500                 case AC_WID_PIN:
1501                         ret = hdac_hdmi_add_pin(edev, nid);
1502                         if (ret < 0)
1503                                 goto free_widgets;
1504                         break;
1505                 }
1506         }
1507
1508         if (!hdmi->num_pin || !hdmi->num_cvt) {
1509                 ret = -EIO;
1510                 goto free_widgets;
1511         }
1512
1513         ret = hdac_hdmi_create_dais(hdev, dais, hdmi, hdmi->num_cvt);
1514         if (ret) {
1515                 dev_err(&hdev->dev, "Failed to create dais with err: %d\n",
1516                                                         ret);
1517                 goto free_widgets;
1518         }
1519
1520         *num_dais = hdmi->num_cvt;
1521         ret = hdac_hdmi_init_dai_map(edev);
1522         if (ret < 0)
1523                 goto free_widgets;
1524
1525         return ret;
1526
1527 free_widgets:
1528         list_for_each_entry_safe(temp_cvt, cvt_next, &hdmi->cvt_list, head) {
1529                 list_del(&temp_cvt->head);
1530                 kfree(temp_cvt->name);
1531                 kfree(temp_cvt);
1532         }
1533
1534         list_for_each_entry_safe(temp_pin, pin_next, &hdmi->pin_list, head) {
1535                 for (i = 0; i < temp_pin->num_ports; i++)
1536                         temp_pin->ports[i].pin = NULL;
1537                 kfree(temp_pin->ports);
1538                 list_del(&temp_pin->head);
1539                 kfree(temp_pin);
1540         }
1541
1542         return ret;
1543 }
1544
1545 static void hdac_hdmi_eld_notify_cb(void *aptr, int port, int pipe)
1546 {
1547         struct hdac_ext_device *edev = aptr;
1548         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1549         struct hdac_hdmi_pin *pin = NULL;
1550         struct hdac_hdmi_port *hport = NULL;
1551         struct snd_soc_component *component = edev->scodec;
1552         int i;
1553
1554         /* Don't know how this mapping is derived */
1555         hda_nid_t pin_nid = port + 0x04;
1556
1557         dev_dbg(&edev->hdev.dev, "%s: for pin:%d port=%d\n", __func__,
1558                                                         pin_nid, pipe);
1559
1560         /*
1561          * skip notification during system suspend (but not in runtime PM);
1562          * the state will be updated at resume. Also since the ELD and
1563          * connection states are updated in anyway at the end of the resume,
1564          * we can skip it when received during PM process.
1565          */
1566         if (snd_power_get_state(component->card->snd_card) !=
1567                         SNDRV_CTL_POWER_D0)
1568                 return;
1569
1570         if (atomic_read(&edev->hdev.in_pm))
1571                 return;
1572
1573         list_for_each_entry(pin, &hdmi->pin_list, head) {
1574                 if (pin->nid != pin_nid)
1575                         continue;
1576
1577                 /* In case of non MST pin, pipe is -1 */
1578                 if (pipe == -1) {
1579                         pin->mst_capable = false;
1580                         /* if not MST, default is port[0] */
1581                         hport = &pin->ports[0];
1582                 } else {
1583                         for (i = 0; i < pin->num_ports; i++) {
1584                                 pin->mst_capable = true;
1585                                 if (pin->ports[i].id == pipe) {
1586                                         hport = &pin->ports[i];
1587                                         break;
1588                                 }
1589                         }
1590                 }
1591
1592                 if (hport)
1593                         hdac_hdmi_present_sense(pin, hport);
1594         }
1595
1596 }
1597
1598 static struct i915_audio_component_audio_ops aops = {
1599         .pin_eld_notify = hdac_hdmi_eld_notify_cb,
1600 };
1601
1602 static struct snd_pcm *hdac_hdmi_get_pcm_from_id(struct snd_soc_card *card,
1603                                                 int device)
1604 {
1605         struct snd_soc_pcm_runtime *rtd;
1606
1607         list_for_each_entry(rtd, &card->rtd_list, list) {
1608                 if (rtd->pcm && (rtd->pcm->device == device))
1609                         return rtd->pcm;
1610         }
1611
1612         return NULL;
1613 }
1614
1615 /* create jack pin kcontrols */
1616 static int create_fill_jack_kcontrols(struct snd_soc_card *card,
1617                                     struct hdac_ext_device *edev)
1618 {
1619         struct hdac_hdmi_pin *pin;
1620         struct snd_kcontrol_new *kc;
1621         char kc_name[NAME_SIZE], xname[NAME_SIZE];
1622         char *name;
1623         int i = 0, j;
1624         struct snd_soc_component *component = edev->scodec;
1625         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1626
1627         kc = devm_kcalloc(component->dev, hdmi->num_ports,
1628                                 sizeof(*kc), GFP_KERNEL);
1629
1630         if (!kc)
1631                 return -ENOMEM;
1632
1633         list_for_each_entry(pin, &hdmi->pin_list, head) {
1634                 for (j = 0; j < pin->num_ports; j++) {
1635                         snprintf(xname, sizeof(xname), "hif%d-%d Jack",
1636                                                 pin->nid, pin->ports[j].id);
1637                         name = devm_kstrdup(component->dev, xname, GFP_KERNEL);
1638                         if (!name)
1639                                 return -ENOMEM;
1640                         snprintf(kc_name, sizeof(kc_name), "%s Switch", xname);
1641                         kc[i].name = devm_kstrdup(component->dev, kc_name,
1642                                                         GFP_KERNEL);
1643                         if (!kc[i].name)
1644                                 return -ENOMEM;
1645
1646                         kc[i].private_value = (unsigned long)name;
1647                         kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1648                         kc[i].access = 0;
1649                         kc[i].info = snd_soc_dapm_info_pin_switch;
1650                         kc[i].put = snd_soc_dapm_put_pin_switch;
1651                         kc[i].get = snd_soc_dapm_get_pin_switch;
1652                         i++;
1653                 }
1654         }
1655
1656         return snd_soc_add_card_controls(card, kc, i);
1657 }
1658
1659 int hdac_hdmi_jack_port_init(struct snd_soc_component *component,
1660                         struct snd_soc_dapm_context *dapm)
1661 {
1662         struct hdac_ext_device *edev = snd_soc_component_get_drvdata(component);
1663         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1664         struct hdac_hdmi_pin *pin;
1665         struct snd_soc_dapm_widget *widgets;
1666         struct snd_soc_dapm_route *route;
1667         char w_name[NAME_SIZE];
1668         int i = 0, j, ret;
1669
1670         widgets = devm_kcalloc(dapm->dev, hdmi->num_ports,
1671                                 sizeof(*widgets), GFP_KERNEL);
1672
1673         if (!widgets)
1674                 return -ENOMEM;
1675
1676         route = devm_kcalloc(dapm->dev, hdmi->num_ports,
1677                                 sizeof(*route), GFP_KERNEL);
1678         if (!route)
1679                 return -ENOMEM;
1680
1681         /* create Jack DAPM widget */
1682         list_for_each_entry(pin, &hdmi->pin_list, head) {
1683                 for (j = 0; j < pin->num_ports; j++) {
1684                         snprintf(w_name, sizeof(w_name), "hif%d-%d Jack",
1685                                                 pin->nid, pin->ports[j].id);
1686
1687                         ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1688                                         snd_soc_dapm_spk, NULL,
1689                                         w_name, NULL, NULL, 0, NULL, 0);
1690                         if (ret < 0)
1691                                 return ret;
1692
1693                         pin->ports[j].jack_pin = widgets[i].name;
1694                         pin->ports[j].dapm = dapm;
1695
1696                         /* add to route from Jack widget to output */
1697                         hdac_hdmi_fill_route(&route[i], pin->ports[j].jack_pin,
1698                                         NULL, pin->ports[j].output_pin, NULL);
1699
1700                         i++;
1701                 }
1702         }
1703
1704         /* Add Route from Jack widget to the output widget */
1705         ret = snd_soc_dapm_new_controls(dapm, widgets, hdmi->num_ports);
1706         if (ret < 0)
1707                 return ret;
1708
1709         ret = snd_soc_dapm_add_routes(dapm, route, hdmi->num_ports);
1710         if (ret < 0)
1711                 return ret;
1712
1713         ret = snd_soc_dapm_new_widgets(dapm->card);
1714         if (ret < 0)
1715                 return ret;
1716
1717         /* Add Jack Pin switch Kcontrol */
1718         ret = create_fill_jack_kcontrols(dapm->card, edev);
1719
1720         if (ret < 0)
1721                 return ret;
1722
1723         /* default set the Jack Pin switch to OFF */
1724         list_for_each_entry(pin, &hdmi->pin_list, head) {
1725                 for (j = 0; j < pin->num_ports; j++)
1726                         snd_soc_dapm_disable_pin(pin->ports[j].dapm,
1727                                                 pin->ports[j].jack_pin);
1728         }
1729
1730         return 0;
1731 }
1732 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_port_init);
1733
1734 int hdac_hdmi_jack_init(struct snd_soc_dai *dai, int device,
1735                                 struct snd_soc_jack *jack)
1736 {
1737         struct snd_soc_component *component = dai->component;
1738         struct hdac_ext_device *edev = snd_soc_component_get_drvdata(component);
1739         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1740         struct hdac_hdmi_pcm *pcm;
1741         struct snd_pcm *snd_pcm;
1742         int err;
1743
1744         /*
1745          * this is a new PCM device, create new pcm and
1746          * add to the pcm list
1747          */
1748         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
1749         if (!pcm)
1750                 return -ENOMEM;
1751         pcm->pcm_id = device;
1752         pcm->cvt = hdmi->dai_map[dai->id].cvt;
1753         pcm->jack_event = 0;
1754         pcm->jack = jack;
1755         mutex_init(&pcm->lock);
1756         INIT_LIST_HEAD(&pcm->port_list);
1757         snd_pcm = hdac_hdmi_get_pcm_from_id(dai->component->card, device);
1758         if (snd_pcm) {
1759                 err = snd_hdac_add_chmap_ctls(snd_pcm, device, &hdmi->chmap);
1760                 if (err < 0) {
1761                         dev_err(&edev->hdev.dev,
1762                                 "chmap control add failed with err: %d for pcm: %d\n",
1763                                 err, device);
1764                         kfree(pcm);
1765                         return err;
1766                 }
1767         }
1768
1769         list_add_tail(&pcm->head, &hdmi->pcm_list);
1770
1771         return 0;
1772 }
1773 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init);
1774
1775 static void hdac_hdmi_present_sense_all_pins(struct hdac_ext_device *edev,
1776                         struct hdac_hdmi_priv *hdmi, bool detect_pin_caps)
1777 {
1778         int i;
1779         struct hdac_hdmi_pin *pin;
1780
1781         list_for_each_entry(pin, &hdmi->pin_list, head) {
1782                 if (detect_pin_caps) {
1783
1784                         if (hdac_hdmi_get_port_len(edev, pin->nid)  == 0)
1785                                 pin->mst_capable = false;
1786                         else
1787                                 pin->mst_capable = true;
1788                 }
1789
1790                 for (i = 0; i < pin->num_ports; i++) {
1791                         if (!pin->mst_capable && i > 0)
1792                                 continue;
1793
1794                         hdac_hdmi_present_sense(pin, &pin->ports[i]);
1795                 }
1796         }
1797 }
1798
1799 static int hdmi_codec_probe(struct snd_soc_component *component)
1800 {
1801         struct hdac_ext_device *edev = snd_soc_component_get_drvdata(component);
1802         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1803         struct snd_soc_dapm_context *dapm =
1804                 snd_soc_component_get_dapm(component);
1805         struct hdac_ext_link *hlink = NULL;
1806         int ret;
1807
1808         edev->scodec = component;
1809
1810         /*
1811          * hold the ref while we probe, also no need to drop the ref on
1812          * exit, we call pm_runtime_suspend() so that will do for us
1813          */
1814         hlink = snd_hdac_ext_bus_get_link(edev->ebus, dev_name(&edev->hdev.dev));
1815         if (!hlink) {
1816                 dev_err(&edev->hdev.dev, "hdac link not found\n");
1817                 return -EIO;
1818         }
1819
1820         snd_hdac_ext_bus_link_get(edev->ebus, hlink);
1821
1822         ret = create_fill_widget_route_map(dapm);
1823         if (ret < 0)
1824                 return ret;
1825
1826         aops.audio_ptr = edev;
1827         ret = snd_hdac_i915_register_notifier(&aops);
1828         if (ret < 0) {
1829                 dev_err(&edev->hdev.dev, "notifier register failed: err: %d\n",
1830                                 ret);
1831                 return ret;
1832         }
1833
1834         hdac_hdmi_present_sense_all_pins(edev, hdmi, true);
1835         /* Imp: Store the card pointer in hda_codec */
1836         edev->card = dapm->card->snd_card;
1837
1838         /*
1839          * hdac_device core already sets the state to active and calls
1840          * get_noresume. So enable runtime and set the device to suspend.
1841          */
1842         pm_runtime_enable(&edev->hdev.dev);
1843         pm_runtime_put(&edev->hdev.dev);
1844         pm_runtime_suspend(&edev->hdev.dev);
1845
1846         return 0;
1847 }
1848
1849 static void hdmi_codec_remove(struct snd_soc_component *component)
1850 {
1851         struct hdac_ext_device *edev = snd_soc_component_get_drvdata(component);
1852
1853         pm_runtime_disable(&edev->hdev.dev);
1854 }
1855
1856 #ifdef CONFIG_PM
1857 static int hdmi_codec_prepare(struct device *dev)
1858 {
1859         struct hdac_ext_device *edev = to_hda_ext_device(dev);
1860         struct hdac_device *hdev = &edev->hdev;
1861
1862         pm_runtime_get_sync(&edev->hdev.dev);
1863
1864         /*
1865          * Power down afg.
1866          * codec_read is preferred over codec_write to set the power state.
1867          * This way verb is send to set the power state and response
1868          * is received. So setting power state is ensured without using loop
1869          * to read the state.
1870          */
1871         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
1872                                                         AC_PWRST_D3);
1873
1874         return 0;
1875 }
1876
1877 static void hdmi_codec_complete(struct device *dev)
1878 {
1879         struct hdac_ext_device *edev = to_hda_ext_device(dev);
1880         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1881         struct hdac_device *hdev = &edev->hdev;
1882
1883         /* Power up afg */
1884         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
1885                                                         AC_PWRST_D0);
1886
1887         hdac_hdmi_skl_enable_all_pins(&edev->hdev);
1888         hdac_hdmi_skl_enable_dp12(&edev->hdev);
1889
1890         /*
1891          * As the ELD notify callback request is not entertained while the
1892          * device is in suspend state. Need to manually check detection of
1893          * all pins here. pin capablity change is not support, so use the
1894          * already set pin caps.
1895          */
1896         hdac_hdmi_present_sense_all_pins(edev, hdmi, false);
1897
1898         pm_runtime_put_sync(&edev->hdev.dev);
1899 }
1900 #else
1901 #define hdmi_codec_prepare NULL
1902 #define hdmi_codec_complete NULL
1903 #endif
1904
1905 static const struct snd_soc_component_driver hdmi_hda_codec = {
1906         .probe                  = hdmi_codec_probe,
1907         .remove                 = hdmi_codec_remove,
1908         .use_pmdown_time        = 1,
1909         .endianness             = 1,
1910         .non_legacy_dai_naming  = 1,
1911 };
1912
1913 static void hdac_hdmi_get_chmap(struct hdac_device *hdev, int pcm_idx,
1914                                         unsigned char *chmap)
1915 {
1916         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1917         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1918
1919         memcpy(chmap, pcm->chmap, ARRAY_SIZE(pcm->chmap));
1920 }
1921
1922 static void hdac_hdmi_set_chmap(struct hdac_device *hdev, int pcm_idx,
1923                                 unsigned char *chmap, int prepared)
1924 {
1925         struct hdac_ext_device *edev = to_ehdac_device(hdev);
1926         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1927         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1928         struct hdac_hdmi_port *port;
1929
1930         if (!pcm)
1931                 return;
1932
1933         if (list_empty(&pcm->port_list))
1934                 return;
1935
1936         mutex_lock(&pcm->lock);
1937         pcm->chmap_set = true;
1938         memcpy(pcm->chmap, chmap, ARRAY_SIZE(pcm->chmap));
1939         list_for_each_entry(port, &pcm->port_list, head)
1940                 if (prepared)
1941                         hdac_hdmi_setup_audio_infoframe(edev, pcm, port);
1942         mutex_unlock(&pcm->lock);
1943 }
1944
1945 static bool is_hdac_hdmi_pcm_attached(struct hdac_device *hdev, int pcm_idx)
1946 {
1947         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1948         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1949
1950         if (!pcm)
1951                 return false;
1952
1953         if (list_empty(&pcm->port_list))
1954                 return false;
1955
1956         return true;
1957 }
1958
1959 static int hdac_hdmi_get_spk_alloc(struct hdac_device *hdev, int pcm_idx)
1960 {
1961         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1962         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1963         struct hdac_hdmi_port *port;
1964
1965         if (!pcm)
1966                 return 0;
1967
1968         if (list_empty(&pcm->port_list))
1969                 return 0;
1970
1971         port = list_first_entry(&pcm->port_list, struct hdac_hdmi_port, head);
1972
1973         if (!port)
1974                 return 0;
1975
1976         if (!port || !port->eld.eld_valid)
1977                 return 0;
1978
1979         return port->eld.info.spk_alloc;
1980 }
1981
1982 static struct hdac_hdmi_drv_data intel_glk_drv_data  = {
1983         .vendor_nid = INTEL_GLK_VENDOR_NID,
1984 };
1985
1986 static struct hdac_hdmi_drv_data intel_drv_data  = {
1987         .vendor_nid = INTEL_VENDOR_NID,
1988 };
1989
1990 static int hdac_hdmi_dev_probe(struct hdac_ext_device *edev)
1991 {
1992         struct hdac_device *hdev = &edev->hdev;
1993         struct hdac_hdmi_priv *hdmi_priv;
1994         struct snd_soc_dai_driver *hdmi_dais = NULL;
1995         struct hdac_ext_link *hlink = NULL;
1996         int num_dais = 0;
1997         int ret = 0;
1998         struct hdac_driver *hdrv = drv_to_hdac_driver(hdev->dev.driver);
1999         const struct hda_device_id *hdac_id = hdac_get_device_id(hdev, hdrv);
2000
2001         /* hold the ref while we probe */
2002         hlink = snd_hdac_ext_bus_get_link(edev->ebus, dev_name(&edev->hdev.dev));
2003         if (!hlink) {
2004                 dev_err(&edev->hdev.dev, "hdac link not found\n");
2005                 return -EIO;
2006         }
2007
2008         snd_hdac_ext_bus_link_get(edev->ebus, hlink);
2009
2010         hdmi_priv = devm_kzalloc(&hdev->dev, sizeof(*hdmi_priv), GFP_KERNEL);
2011         if (hdmi_priv == NULL)
2012                 return -ENOMEM;
2013
2014         edev->private_data = hdmi_priv;
2015         snd_hdac_register_chmap_ops(hdev, &hdmi_priv->chmap);
2016         hdmi_priv->chmap.ops.get_chmap = hdac_hdmi_get_chmap;
2017         hdmi_priv->chmap.ops.set_chmap = hdac_hdmi_set_chmap;
2018         hdmi_priv->chmap.ops.is_pcm_attached = is_hdac_hdmi_pcm_attached;
2019         hdmi_priv->chmap.ops.get_spk_alloc = hdac_hdmi_get_spk_alloc;
2020
2021         if (!hdac_id)
2022                 return -ENODEV;
2023
2024         if (hdac_id->driver_data)
2025                 hdmi_priv->drv_data =
2026                         (struct hdac_hdmi_drv_data *)hdac_id->driver_data;
2027         else
2028                 hdmi_priv->drv_data = &intel_drv_data;
2029
2030         dev_set_drvdata(&hdev->dev, edev);
2031
2032         INIT_LIST_HEAD(&hdmi_priv->pin_list);
2033         INIT_LIST_HEAD(&hdmi_priv->cvt_list);
2034         INIT_LIST_HEAD(&hdmi_priv->pcm_list);
2035         mutex_init(&hdmi_priv->pin_mutex);
2036
2037         /*
2038          * Turned off in the runtime_suspend during the first explicit
2039          * pm_runtime_suspend call.
2040          */
2041         ret = snd_hdac_display_power(edev->hdev.bus, true);
2042         if (ret < 0) {
2043                 dev_err(&edev->hdev.dev,
2044                         "Cannot turn on display power on i915 err: %d\n",
2045                         ret);
2046                 return ret;
2047         }
2048
2049         ret = hdac_hdmi_parse_and_map_nid(edev, &hdmi_dais, &num_dais);
2050         if (ret < 0) {
2051                 dev_err(&hdev->dev,
2052                         "Failed in parse and map nid with err: %d\n", ret);
2053                 return ret;
2054         }
2055         snd_hdac_refresh_widgets(hdev, true);
2056
2057         /* ASoC specific initialization */
2058         ret = devm_snd_soc_register_component(&hdev->dev, &hdmi_hda_codec,
2059                                         hdmi_dais, num_dais);
2060
2061         snd_hdac_ext_bus_link_put(edev->ebus, hlink);
2062
2063         return ret;
2064 }
2065
2066 static int hdac_hdmi_dev_remove(struct hdac_ext_device *edev)
2067 {
2068         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
2069         struct hdac_hdmi_pin *pin, *pin_next;
2070         struct hdac_hdmi_cvt *cvt, *cvt_next;
2071         struct hdac_hdmi_pcm *pcm, *pcm_next;
2072         struct hdac_hdmi_port *port, *port_next;
2073         int i;
2074
2075         list_for_each_entry_safe(pcm, pcm_next, &hdmi->pcm_list, head) {
2076                 pcm->cvt = NULL;
2077                 if (list_empty(&pcm->port_list))
2078                         continue;
2079
2080                 list_for_each_entry_safe(port, port_next,
2081                                         &pcm->port_list, head)
2082                         list_del(&port->head);
2083
2084                 list_del(&pcm->head);
2085                 kfree(pcm);
2086         }
2087
2088         list_for_each_entry_safe(cvt, cvt_next, &hdmi->cvt_list, head) {
2089                 list_del(&cvt->head);
2090                 kfree(cvt->name);
2091                 kfree(cvt);
2092         }
2093
2094         list_for_each_entry_safe(pin, pin_next, &hdmi->pin_list, head) {
2095                 for (i = 0; i < pin->num_ports; i++)
2096                         pin->ports[i].pin = NULL;
2097                 kfree(pin->ports);
2098                 list_del(&pin->head);
2099                 kfree(pin);
2100         }
2101
2102         return 0;
2103 }
2104
2105 #ifdef CONFIG_PM
2106 static int hdac_hdmi_runtime_suspend(struct device *dev)
2107 {
2108         struct hdac_ext_device *edev = to_hda_ext_device(dev);
2109         struct hdac_device *hdev = &edev->hdev;
2110         struct hdac_bus *bus = hdev->bus;
2111         struct hdac_ext_bus *ebus = hbus_to_ebus(bus);
2112         struct hdac_ext_link *hlink = NULL;
2113         int err;
2114
2115         dev_dbg(dev, "Enter: %s\n", __func__);
2116
2117         /* controller may not have been initialized for the first time */
2118         if (!bus)
2119                 return 0;
2120
2121         /*
2122          * Power down afg.
2123          * codec_read is preferred over codec_write to set the power state.
2124          * This way verb is send to set the power state and response
2125          * is received. So setting power state is ensured without using loop
2126          * to read the state.
2127          */
2128         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
2129                                                         AC_PWRST_D3);
2130         err = snd_hdac_display_power(bus, false);
2131         if (err < 0) {
2132                 dev_err(bus->dev, "Cannot turn on display power on i915\n");
2133                 return err;
2134         }
2135
2136         hlink = snd_hdac_ext_bus_get_link(ebus, dev_name(dev));
2137         if (!hlink) {
2138                 dev_err(dev, "hdac link not found\n");
2139                 return -EIO;
2140         }
2141
2142         snd_hdac_ext_bus_link_put(ebus, hlink);
2143
2144         return 0;
2145 }
2146
2147 static int hdac_hdmi_runtime_resume(struct device *dev)
2148 {
2149         struct hdac_ext_device *edev = to_hda_ext_device(dev);
2150         struct hdac_device *hdev = &edev->hdev;
2151         struct hdac_bus *bus = hdev->bus;
2152         struct hdac_ext_bus *ebus = hbus_to_ebus(bus);
2153         struct hdac_ext_link *hlink = NULL;
2154         int err;
2155
2156         dev_dbg(dev, "Enter: %s\n", __func__);
2157
2158         /* controller may not have been initialized for the first time */
2159         if (!bus)
2160                 return 0;
2161
2162         hlink = snd_hdac_ext_bus_get_link(ebus, dev_name(dev));
2163         if (!hlink) {
2164                 dev_err(dev, "hdac link not found\n");
2165                 return -EIO;
2166         }
2167
2168         snd_hdac_ext_bus_link_get(ebus, hlink);
2169
2170         err = snd_hdac_display_power(bus, true);
2171         if (err < 0) {
2172                 dev_err(bus->dev, "Cannot turn on display power on i915\n");
2173                 return err;
2174         }
2175
2176         hdac_hdmi_skl_enable_all_pins(&edev->hdev);
2177         hdac_hdmi_skl_enable_dp12(&edev->hdev);
2178
2179         /* Power up afg */
2180         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
2181                                                         AC_PWRST_D0);
2182
2183         return 0;
2184 }
2185 #else
2186 #define hdac_hdmi_runtime_suspend NULL
2187 #define hdac_hdmi_runtime_resume NULL
2188 #endif
2189
2190 static const struct dev_pm_ops hdac_hdmi_pm = {
2191         SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL)
2192         .prepare = hdmi_codec_prepare,
2193         .complete = hdmi_codec_complete,
2194 };
2195
2196 static const struct hda_device_id hdmi_list[] = {
2197         HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
2198         HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0),
2199         HDA_CODEC_EXT_ENTRY(0x8086280b, 0x100000, "Kabylake HDMI", 0),
2200         HDA_CODEC_EXT_ENTRY(0x8086280c, 0x100000, "Cannonlake HDMI",
2201                                                    &intel_glk_drv_data),
2202         HDA_CODEC_EXT_ENTRY(0x8086280d, 0x100000, "Geminilake HDMI",
2203                                                    &intel_glk_drv_data),
2204         {}
2205 };
2206
2207 MODULE_DEVICE_TABLE(hdaudio, hdmi_list);
2208
2209 static struct hdac_ext_driver hdmi_driver = {
2210         . hdac = {
2211                 .driver = {
2212                         .name   = "HDMI HDA Codec",
2213                         .pm = &hdac_hdmi_pm,
2214                 },
2215                 .id_table       = hdmi_list,
2216         },
2217         .probe          = hdac_hdmi_dev_probe,
2218         .remove         = hdac_hdmi_dev_remove,
2219 };
2220
2221 static int __init hdmi_init(void)
2222 {
2223         return snd_hda_ext_driver_register(&hdmi_driver);
2224 }
2225
2226 static void __exit hdmi_exit(void)
2227 {
2228         snd_hda_ext_driver_unregister(&hdmi_driver);
2229 }
2230
2231 module_init(hdmi_init);
2232 module_exit(hdmi_exit);
2233
2234 MODULE_LICENSE("GPL v2");
2235 MODULE_DESCRIPTION("HDMI HD codec");
2236 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
2237 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");