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         if (get_wcaps(&edev->hdev, nid) & AC_WCAP_POWER) {
 722                 if (!snd_hdac_check_power_state(&edev->hdev, nid, pwr_state))
 723                         snd_hdac_codec_write(&edev->hdev, nid, 0,
 724                                 AC_VERB_SET_POWER_STATE, pwr_state);
 725         }
 726 }
 727
 728 static void hdac_hdmi_set_amp(struct hdac_ext_device *edev,
 729                                    hda_nid_t nid, int val)
 730 {
 731         if (get_wcaps(&edev->hdev, nid) & AC_WCAP_OUT_AMP)
 732                 snd_hdac_codec_write(&edev->hdev, nid, 0,
 733                                         AC_VERB_SET_AMP_GAIN_MUTE, val);
 734 }
 735
 736
 737 static int hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget *w,
 738                                         struct snd_kcontrol *kc, int event)
 739 {
 740         struct hdac_hdmi_port *port = w->priv;
 741         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 742         struct hdac_hdmi_pcm *pcm;
 743
 744         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 745                         __func__, w->name, event);
 746
 747         pcm = hdac_hdmi_get_pcm(edev, port);
 748         if (!pcm)
 749                 return -EIO;
 750
 751         /* set the device if pin is mst_capable */
 752         if (hdac_hdmi_port_select_set(edev, port) < 0)
 753                 return -EIO;
 754
 755         switch (event) {
 756         case SND_SOC_DAPM_PRE_PMU:
 757                 hdac_hdmi_set_power_state(edev, port->pin->nid, AC_PWRST_D0);
 758
 759                 /* Enable out path for this pin widget */
 760                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 761                                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
 762
 763                 hdac_hdmi_set_amp(edev, port->pin->nid, AMP_OUT_UNMUTE);
 764
 765                 return hdac_hdmi_setup_audio_infoframe(edev, pcm, port);
 766
 767         case SND_SOC_DAPM_POST_PMD:
 768                 hdac_hdmi_set_amp(edev, port->pin->nid, AMP_OUT_MUTE);
 769
 770                 /* Disable out path for this pin widget */
 771                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 772                                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 773
 774                 hdac_hdmi_set_power_state(edev, port->pin->nid, AC_PWRST_D3);
 775                 break;
 776
 777         }
 778
 779         return 0;
 780 }
 781
 782 static int hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget *w,
 783                                         struct snd_kcontrol *kc, int event)
 784 {
 785         struct hdac_hdmi_cvt *cvt = w->priv;
 786         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 787         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 788         struct hdac_hdmi_pcm *pcm;
 789
 790         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 791                         __func__, w->name, event);
 792
 793         pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, cvt);
 794         if (!pcm)
 795                 return -EIO;
 796
 797         switch (event) {
 798         case SND_SOC_DAPM_PRE_PMU:
 799                 hdac_hdmi_set_power_state(edev, cvt->nid, AC_PWRST_D0);
 800
 801                 /* Enable transmission */
 802                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 803                         AC_VERB_SET_DIGI_CONVERT_1, 1);
 804
 805                 /* Category Code (CC) to zero */
 806                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 807                         AC_VERB_SET_DIGI_CONVERT_2, 0);
 808
 809                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 810                                 AC_VERB_SET_CHANNEL_STREAMID, pcm->stream_tag);
 811                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 812                                 AC_VERB_SET_STREAM_FORMAT, pcm->format);
 813                 break;
 814
 815         case SND_SOC_DAPM_POST_PMD:
 816                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 817                                 AC_VERB_SET_CHANNEL_STREAMID, 0);
 818                 snd_hdac_codec_write(&edev->hdev, cvt->nid, 0,
 819                                 AC_VERB_SET_STREAM_FORMAT, 0);
 820
 821                 hdac_hdmi_set_power_state(edev, cvt->nid, AC_PWRST_D3);
 822                 break;
 823
 824         }
 825
 826         return 0;
 827 }
 828
 829 static int hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget *w,
 830                                         struct snd_kcontrol *kc, int event)
 831 {
 832         struct hdac_hdmi_port *port = w->priv;
 833         struct hdac_ext_device *edev = to_hda_ext_device(w->dapm->dev);
 834         int mux_idx;
 835
 836         dev_dbg(&edev->hdev.dev, "%s: widget: %s event: %x\n",
 837                         __func__, w->name, event);
 838
 839         if (!kc)
 840                 kc  = w->kcontrols[0];
 841
 842         mux_idx = dapm_kcontrol_get_value(kc);
 843
 844         /* set the device if pin is mst_capable */
 845         if (hdac_hdmi_port_select_set(edev, port) < 0)
 846                 return -EIO;
 847
 848         if (mux_idx > 0) {
 849                 snd_hdac_codec_write(&edev->hdev, port->pin->nid, 0,
 850                         AC_VERB_SET_CONNECT_SEL, (mux_idx - 1));
 851         }
 852
 853         return 0;
 854 }
 855
 856 /*
 857  * Based on user selection, map the PINs with the PCMs.
 858  */
 859 static int hdac_hdmi_set_pin_port_mux(struct snd_kcontrol *kcontrol,
 860                 struct snd_ctl_elem_value *ucontrol)
 861 {
 862         int ret;
 863         struct hdac_hdmi_port *p, *p_next;
 864         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 865         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
 866         struct snd_soc_dapm_context *dapm = w->dapm;
 867         struct hdac_hdmi_port *port = w->priv;
 868         struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev);
 869         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 870         struct hdac_hdmi_pcm *pcm = NULL;
 871         const char *cvt_name =  e->texts[ucontrol->value.enumerated.item[0]];
 872
 873         ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
 874         if (ret < 0)
 875                 return ret;
 876
 877         if (port == NULL)
 878                 return -EINVAL;
 879
 880         mutex_lock(&hdmi->pin_mutex);
 881         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 882                 if (list_empty(&pcm->port_list))
 883                         continue;
 884
 885                 list_for_each_entry_safe(p, p_next, &pcm->port_list, head) {
 886                         if (p == port && p->id == port->id &&
 887                                         p->pin == port->pin) {
 888                                 hdac_hdmi_jack_report(pcm, port, false);
 889                                 list_del(&p->head);
 890                         }
 891                 }
 892         }
 893
 894         /*
 895          * Jack status is not reported during device probe as the
 896          * PCMs are not registered by then. So report it here.
 897          */
 898         list_for_each_entry(pcm, &hdmi->pcm_list, head) {
 899                 if (!strcmp(cvt_name, pcm->cvt->name)) {
 900                         list_add_tail(&port->head, &pcm->port_list);
 901                         if (port->eld.monitor_present && port->eld.eld_valid) {
 902                                 hdac_hdmi_jack_report(pcm, port, true);
 903                                 mutex_unlock(&hdmi->pin_mutex);
 904                                 return ret;
 905                         }
 906                 }
 907         }
 908         mutex_unlock(&hdmi->pin_mutex);
 909
 910         return ret;
 911 }
 912
 913 /*
 914  * Ideally the Mux inputs should be based on the num_muxs enumerated, but
 915  * the display driver seem to be programming the connection list for the pin
 916  * widget runtime.
 917  *
 918  * So programming all the possible inputs for the mux, the user has to take
 919  * care of selecting the right one and leaving all other inputs selected to
 920  * "NONE"
 921  */
 922 static int hdac_hdmi_create_pin_port_muxs(struct hdac_ext_device *edev,
 923                                 struct hdac_hdmi_port *port,
 924                                 struct snd_soc_dapm_widget *widget,
 925                                 const char *widget_name)
 926 {
 927         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 928         struct hdac_hdmi_pin *pin = port->pin;
 929         struct snd_kcontrol_new *kc;
 930         struct hdac_hdmi_cvt *cvt;
 931         struct soc_enum *se;
 932         char kc_name[NAME_SIZE];
 933         char mux_items[NAME_SIZE];
 934         /* To hold inputs to the Pin mux */
 935         char *items[HDA_MAX_CONNECTIONS];
 936         int i = 0;
 937         int num_items = hdmi->num_cvt + 1;
 938
 939         kc = devm_kzalloc(&edev->hdev.dev, sizeof(*kc), GFP_KERNEL);
 940         if (!kc)
 941                 return -ENOMEM;
 942
 943         se = devm_kzalloc(&edev->hdev.dev, sizeof(*se), GFP_KERNEL);
 944         if (!se)
 945                 return -ENOMEM;
 946
 947         snprintf(kc_name, NAME_SIZE, "Pin %d port %d Input",
 948                                                 pin->nid, port->id);
 949         kc->name = devm_kstrdup(&edev->hdev.dev, kc_name, GFP_KERNEL);
 950         if (!kc->name)
 951                 return -ENOMEM;
 952
 953         kc->private_value = (long)se;
 954         kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 955         kc->access = 0;
 956         kc->info = snd_soc_info_enum_double;
 957         kc->put = hdac_hdmi_set_pin_port_mux;
 958         kc->get = snd_soc_dapm_get_enum_double;
 959
 960         se->reg = SND_SOC_NOPM;
 961
 962         /* enum texts: ["NONE", "cvt #", "cvt #", ...] */
 963         se->items = num_items;
 964         se->mask = roundup_pow_of_two(se->items) - 1;
 965
 966         sprintf(mux_items, "NONE");
 967         items[i] = devm_kstrdup(&edev->hdev.dev, mux_items, GFP_KERNEL);
 968         if (!items[i])
 969                 return -ENOMEM;
 970
 971         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
 972                 i++;
 973                 sprintf(mux_items, "cvt %d", cvt->nid);
 974                 items[i] = devm_kstrdup(&edev->hdev.dev, mux_items, GFP_KERNEL);
 975                 if (!items[i])
 976                         return -ENOMEM;
 977         }
 978
 979         se->texts = devm_kmemdup(&edev->hdev.dev, items,
 980                         (num_items  * sizeof(char *)), GFP_KERNEL);
 981         if (!se->texts)
 982                 return -ENOMEM;
 983
 984         return hdac_hdmi_fill_widget_info(&edev->hdev.dev, widget,
 985                         snd_soc_dapm_mux, port, widget_name, NULL, kc, 1,
 986                         hdac_hdmi_pin_mux_widget_event,
 987                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_REG);
 988 }
 989
 990 /* Add cvt <- input <- mux route map */
 991 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_ext_device *edev,
 992                         struct snd_soc_dapm_widget *widgets,
 993                         struct snd_soc_dapm_route *route, int rindex)
 994 {
 995         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
 996         const struct snd_kcontrol_new *kc;
 997         struct soc_enum *se;
 998         int mux_index = hdmi->num_cvt + hdmi->num_ports;
 999         int i, j;
1000
1001         for (i = 0; i < hdmi->num_ports; i++) {
1002                 kc = widgets[mux_index].kcontrol_news;
1003                 se = (struct soc_enum *)kc->private_value;
1004                 for (j = 0; j < hdmi->num_cvt; j++) {
1005                         hdac_hdmi_fill_route(&route[rindex],
1006                                         widgets[mux_index].name,
1007                                         se->texts[j + 1],
1008                                         widgets[j].name, NULL);
1009
1010                         rindex++;
1011                 }
1012
1013                 mux_index++;
1014         }
1015 }
1016
1017 /*
1018  * Widgets are added in the below sequence
1019  *      Converter widgets for num converters enumerated
1020  *      Pin-port widgets for num ports for Pins enumerated
1021  *      Pin-port mux widgets to represent connenction list of pin widget
1022  *
1023  * For each port, one Mux and One output widget is added
1024  * Total widgets elements = num_cvt + (num_ports * 2);
1025  *
1026  * Routes are added as below:
1027  *      pin-port mux -> pin (based on num_ports)
1028  *      cvt -> "Input sel control" -> pin-port_mux
1029  *
1030  * Total route elements:
1031  *      num_ports + (pin_muxes * num_cvt)
1032  */
1033 static int create_fill_widget_route_map(struct snd_soc_dapm_context *dapm)
1034 {
1035         struct snd_soc_dapm_widget *widgets;
1036         struct snd_soc_dapm_route *route;
1037         struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev);
1038         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1039         struct snd_soc_dai_driver *dai_drv = hdmi->dai_drv;
1040         char widget_name[NAME_SIZE];
1041         struct hdac_hdmi_cvt *cvt;
1042         struct hdac_hdmi_pin *pin;
1043         int ret, i = 0, num_routes = 0, j;
1044
1045         if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list))
1046                 return -EINVAL;
1047
1048         widgets = devm_kzalloc(dapm->dev, (sizeof(*widgets) *
1049                                 ((2 * hdmi->num_ports) + hdmi->num_cvt)),
1050                                 GFP_KERNEL);
1051
1052         if (!widgets)
1053                 return -ENOMEM;
1054
1055         /* DAPM widgets to represent each converter widget */
1056         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1057                 sprintf(widget_name, "Converter %d", cvt->nid);
1058                 ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1059                         snd_soc_dapm_aif_in, cvt,
1060                         widget_name, dai_drv[i].playback.stream_name, NULL, 0,
1061                         hdac_hdmi_cvt_output_widget_event,
1062                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD);
1063                 if (ret < 0)
1064                         return ret;
1065                 i++;
1066         }
1067
1068         list_for_each_entry(pin, &hdmi->pin_list, head) {
1069                 for (j = 0; j < pin->num_ports; j++) {
1070                         sprintf(widget_name, "hif%d-%d Output",
1071                                 pin->nid, pin->ports[j].id);
1072                         ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1073                                         snd_soc_dapm_output, &pin->ports[j],
1074                                         widget_name, NULL, NULL, 0,
1075                                         hdac_hdmi_pin_output_widget_event,
1076                                         SND_SOC_DAPM_PRE_PMU |
1077                                         SND_SOC_DAPM_POST_PMD);
1078                         if (ret < 0)
1079                                 return ret;
1080                         pin->ports[j].output_pin = widgets[i].name;
1081                         i++;
1082                 }
1083         }
1084
1085         /* DAPM widgets to represent the connection list to pin widget */
1086         list_for_each_entry(pin, &hdmi->pin_list, head) {
1087                 for (j = 0; j < pin->num_ports; j++) {
1088                         sprintf(widget_name, "Pin%d-Port%d Mux",
1089                                 pin->nid, pin->ports[j].id);
1090                         ret = hdac_hdmi_create_pin_port_muxs(edev,
1091                                                 &pin->ports[j], &widgets[i],
1092                                                 widget_name);
1093                         if (ret < 0)
1094                                 return ret;
1095                         i++;
1096
1097                         /* For cvt to pin_mux mapping */
1098                         num_routes += hdmi->num_cvt;
1099
1100                         /* For pin_mux to pin mapping */
1101                         num_routes++;
1102                 }
1103         }
1104
1105         route = devm_kzalloc(dapm->dev, (sizeof(*route) * num_routes),
1106                                                         GFP_KERNEL);
1107         if (!route)
1108                 return -ENOMEM;
1109
1110         i = 0;
1111         /* Add pin <- NULL <- mux route map */
1112         list_for_each_entry(pin, &hdmi->pin_list, head) {
1113                 for (j = 0; j < pin->num_ports; j++) {
1114                         int sink_index = i + hdmi->num_cvt;
1115                         int src_index = sink_index + pin->num_ports *
1116                                                 hdmi->num_pin;
1117
1118                         hdac_hdmi_fill_route(&route[i],
1119                                 widgets[sink_index].name, NULL,
1120                                 widgets[src_index].name, NULL);
1121                         i++;
1122                 }
1123         }
1124
1125         hdac_hdmi_add_pinmux_cvt_route(edev, widgets, route, i);
1126
1127         snd_soc_dapm_new_controls(dapm, widgets,
1128                 ((2 * hdmi->num_ports) + hdmi->num_cvt));
1129
1130         snd_soc_dapm_add_routes(dapm, route, num_routes);
1131         snd_soc_dapm_new_widgets(dapm->card);
1132
1133         return 0;
1134
1135 }
1136
1137 static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
1138 {
1139         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1140         struct hdac_hdmi_dai_port_map *dai_map;
1141         struct hdac_hdmi_cvt *cvt;
1142         int dai_id = 0;
1143
1144         if (list_empty(&hdmi->cvt_list))
1145                 return -EINVAL;
1146
1147         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1148                 dai_map = &hdmi->dai_map[dai_id];
1149                 dai_map->dai_id = dai_id;
1150                 dai_map->cvt = cvt;
1151
1152                 dai_id++;
1153
1154                 if (dai_id == HDA_MAX_CVTS) {
1155                         dev_warn(&edev->hdev.dev,
1156                                 "Max dais supported: %d\n", dai_id);
1157                         break;
1158                 }
1159         }
1160
1161         return 0;
1162 }
1163
1164 static int hdac_hdmi_add_cvt(struct hdac_ext_device *edev, hda_nid_t nid)
1165 {
1166         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1167         struct hdac_hdmi_cvt *cvt;
1168         char name[NAME_SIZE];
1169
1170         cvt = kzalloc(sizeof(*cvt), GFP_KERNEL);
1171         if (!cvt)
1172                 return -ENOMEM;
1173
1174         cvt->nid = nid;
1175         sprintf(name, "cvt %d", cvt->nid);
1176         cvt->name = kstrdup(name, GFP_KERNEL);
1177
1178         list_add_tail(&cvt->head, &hdmi->cvt_list);
1179         hdmi->num_cvt++;
1180
1181         return hdac_hdmi_query_cvt_params(&edev->hdev, cvt);
1182 }
1183
1184 static int hdac_hdmi_parse_eld(struct hdac_ext_device *edev,
1185                         struct hdac_hdmi_port *port)
1186 {
1187         unsigned int ver, mnl;
1188
1189         ver = (port->eld.eld_buffer[DRM_ELD_VER] & DRM_ELD_VER_MASK)
1190                                                 >> DRM_ELD_VER_SHIFT;
1191
1192         if (ver != ELD_VER_CEA_861D && ver != ELD_VER_PARTIAL) {
1193                 dev_err(&edev->hdev.dev, "HDMI: Unknown ELD version %d\n", ver);
1194                 return -EINVAL;
1195         }
1196
1197         mnl = (port->eld.eld_buffer[DRM_ELD_CEA_EDID_VER_MNL] &
1198                 DRM_ELD_MNL_MASK) >> DRM_ELD_MNL_SHIFT;
1199
1200         if (mnl > ELD_MAX_MNL) {
1201                 dev_err(&edev->hdev.dev, "HDMI: MNL Invalid %d\n", mnl);
1202                 return -EINVAL;
1203         }
1204
1205         port->eld.info.spk_alloc = port->eld.eld_buffer[DRM_ELD_SPEAKER];
1206
1207         return 0;
1208 }
1209
1210 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin *pin,
1211                                     struct hdac_hdmi_port *port)
1212 {
1213         struct hdac_ext_device *edev = pin->edev;
1214         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1215         struct hdac_hdmi_pcm *pcm;
1216         int size = 0;
1217         int port_id = -1;
1218
1219         if (!hdmi)
1220                 return;
1221
1222         /*
1223          * In case of non MST pin, get_eld info API expectes port
1224          * to be -1.
1225          */
1226         mutex_lock(&hdmi->pin_mutex);
1227         port->eld.monitor_present = false;
1228
1229         if (pin->mst_capable)
1230                 port_id = port->id;
1231
1232         size = snd_hdac_acomp_get_eld(&edev->hdev, pin->nid, port_id,
1233                                 &port->eld.monitor_present,
1234                                 port->eld.eld_buffer,
1235                                 ELD_MAX_SIZE);
1236
1237         if (size > 0) {
1238                 size = min(size, ELD_MAX_SIZE);
1239                 if (hdac_hdmi_parse_eld(edev, port) < 0)
1240                         size = -EINVAL;
1241         }
1242
1243         if (size > 0) {
1244                 port->eld.eld_valid = true;
1245                 port->eld.eld_size = size;
1246         } else {
1247                 port->eld.eld_valid = false;
1248                 port->eld.eld_size = 0;
1249         }
1250
1251         pcm = hdac_hdmi_get_pcm(edev, port);
1252
1253         if (!port->eld.monitor_present || !port->eld.eld_valid) {
1254
1255                 dev_err(&edev->hdev.dev, "%s: disconnect for pin:port %d:%d\n",
1256                                                 __func__, pin->nid, port->id);
1257
1258                 /*
1259                  * PCMs are not registered during device probe, so don't
1260                  * report jack here. It will be done in usermode mux
1261                  * control select.
1262                  */
1263                 if (pcm)
1264                         hdac_hdmi_jack_report(pcm, port, false);
1265
1266                 mutex_unlock(&hdmi->pin_mutex);
1267                 return;
1268         }
1269
1270         if (port->eld.monitor_present && port->eld.eld_valid) {
1271                 if (pcm)
1272                         hdac_hdmi_jack_report(pcm, port, true);
1273
1274                 print_hex_dump_debug("ELD: ", DUMP_PREFIX_OFFSET, 16, 1,
1275                           port->eld.eld_buffer, port->eld.eld_size, false);
1276
1277         }
1278         mutex_unlock(&hdmi->pin_mutex);
1279 }
1280
1281 static int hdac_hdmi_add_ports(struct hdac_hdmi_priv *hdmi,
1282                                 struct hdac_hdmi_pin *pin)
1283 {
1284         struct hdac_hdmi_port *ports;
1285         int max_ports = HDA_MAX_PORTS;
1286         int i;
1287
1288         /*
1289          * FIXME: max_port may vary for each platform, so pass this as
1290          * as driver data or query from i915 interface when this API is
1291          * implemented.
1292          */
1293
1294         ports = kcalloc(max_ports, sizeof(*ports), GFP_KERNEL);
1295         if (!ports)
1296                 return -ENOMEM;
1297
1298         for (i = 0; i < max_ports; i++) {
1299                 ports[i].id = i;
1300                 ports[i].pin = pin;
1301         }
1302         pin->ports = ports;
1303         pin->num_ports = max_ports;
1304         return 0;
1305 }
1306
1307 static int hdac_hdmi_add_pin(struct hdac_ext_device *edev, hda_nid_t nid)
1308 {
1309         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1310         struct hdac_hdmi_pin *pin;
1311         int ret;
1312
1313         pin = kzalloc(sizeof(*pin), GFP_KERNEL);
1314         if (!pin)
1315                 return -ENOMEM;
1316
1317         pin->nid = nid;
1318         pin->mst_capable = false;
1319         pin->edev = edev;
1320         ret = hdac_hdmi_add_ports(hdmi, pin);
1321         if (ret < 0)
1322                 return ret;
1323
1324         list_add_tail(&pin->head, &hdmi->pin_list);
1325         hdmi->num_pin++;
1326         hdmi->num_ports += pin->num_ports;
1327
1328         return 0;
1329 }
1330
1331 #define INTEL_VENDOR_NID 0x08
1332 #define INTEL_GLK_VENDOR_NID 0x0b
1333 #define INTEL_GET_VENDOR_VERB 0xf81
1334 #define INTEL_SET_VENDOR_VERB 0x781
1335 #define INTEL_EN_DP12                   0x02 /* enable DP 1.2 features */
1336 #define INTEL_EN_ALL_PIN_CVTS   0x01 /* enable 2nd & 3rd pins and convertors */
1337
1338 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device *hdev)
1339 {
1340         unsigned int vendor_param;
1341         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1342         unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1343
1344         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1345                                 INTEL_GET_VENDOR_VERB, 0);
1346         if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS)
1347                 return;
1348
1349         vendor_param |= INTEL_EN_ALL_PIN_CVTS;
1350         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1351                                 INTEL_SET_VENDOR_VERB, vendor_param);
1352         if (vendor_param == -1)
1353                 return;
1354 }
1355
1356 static void hdac_hdmi_skl_enable_dp12(struct hdac_device *hdev)
1357 {
1358         unsigned int vendor_param;
1359         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1360         unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1361
1362         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1363                                 INTEL_GET_VENDOR_VERB, 0);
1364         if (vendor_param == -1 || vendor_param & INTEL_EN_DP12)
1365                 return;
1366
1367         /* enable DP1.2 mode */
1368         vendor_param |= INTEL_EN_DP12;
1369         vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1370                                 INTEL_SET_VENDOR_VERB, vendor_param);
1371         if (vendor_param == -1)
1372                 return;
1373
1374 }
1375
1376 static const struct snd_soc_dai_ops hdmi_dai_ops = {
1377         .startup = hdac_hdmi_pcm_open,
1378         .shutdown = hdac_hdmi_pcm_close,
1379         .hw_params = hdac_hdmi_set_hw_params,
1380         .set_tdm_slot = hdac_hdmi_set_tdm_slot,
1381 };
1382
1383 /*
1384  * Each converter can support a stream independently. So a dai is created
1385  * based on the number of converter queried.
1386  */
1387 static int hdac_hdmi_create_dais(struct hdac_device *hdev,
1388                 struct snd_soc_dai_driver **dais,
1389                 struct hdac_hdmi_priv *hdmi, int num_dais)
1390 {
1391         struct snd_soc_dai_driver *hdmi_dais;
1392         struct hdac_hdmi_cvt *cvt;
1393         char name[NAME_SIZE], dai_name[NAME_SIZE];
1394         int i = 0;
1395         u32 rates, bps;
1396         unsigned int rate_max = 384000, rate_min = 8000;
1397         u64 formats;
1398         int ret;
1399
1400         hdmi_dais = devm_kzalloc(&hdev->dev,
1401                         (sizeof(*hdmi_dais) * num_dais),
1402                         GFP_KERNEL);
1403         if (!hdmi_dais)
1404                 return -ENOMEM;
1405
1406         list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1407                 ret = snd_hdac_query_supported_pcm(hdev, cvt->nid,
1408                                         &rates, &formats, &bps);
1409                 if (ret)
1410                         return ret;
1411
1412                 sprintf(dai_name, "intel-hdmi-hifi%d", i+1);
1413                 hdmi_dais[i].name = devm_kstrdup(&hdev->dev,
1414                                         dai_name, GFP_KERNEL);
1415
1416                 if (!hdmi_dais[i].name)
1417                         return -ENOMEM;
1418
1419                 snprintf(name, sizeof(name), "hifi%d", i+1);
1420                 hdmi_dais[i].playback.stream_name =
1421                                 devm_kstrdup(&hdev->dev, name, GFP_KERNEL);
1422                 if (!hdmi_dais[i].playback.stream_name)
1423                         return -ENOMEM;
1424
1425                 /*
1426                  * Set caps based on capability queried from the converter.
1427                  * It will be constrained runtime based on ELD queried.
1428                  */
1429                 hdmi_dais[i].playback.formats = formats;
1430                 hdmi_dais[i].playback.rates = rates;
1431                 hdmi_dais[i].playback.rate_max = rate_max;
1432                 hdmi_dais[i].playback.rate_min = rate_min;
1433                 hdmi_dais[i].playback.channels_min = 2;
1434                 hdmi_dais[i].playback.channels_max = 2;
1435                 hdmi_dais[i].playback.sig_bits = bps;
1436                 hdmi_dais[i].ops = &hdmi_dai_ops;
1437                 i++;
1438         }
1439
1440         *dais = hdmi_dais;
1441         hdmi->dai_drv = hdmi_dais;
1442
1443         return 0;
1444 }
1445
1446 /*
1447  * Parse all nodes and store the cvt/pin nids in array
1448  * Add one time initialization for pin and cvt widgets
1449  */
1450 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device *edev,
1451                 struct snd_soc_dai_driver **dais, int *num_dais)
1452 {
1453         hda_nid_t nid;
1454         int i, num_nodes;
1455         struct hdac_hdmi_cvt *temp_cvt, *cvt_next;
1456         struct hdac_hdmi_pin *temp_pin, *pin_next;
1457         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1458         struct hdac_device *hdev = &edev->hdev;
1459         int ret;
1460
1461         hdac_hdmi_skl_enable_all_pins(hdev);
1462         hdac_hdmi_skl_enable_dp12(hdev);
1463
1464         num_nodes = snd_hdac_get_sub_nodes(hdev, hdev->afg, &nid);
1465         if (!nid || num_nodes <= 0) {
1466                 dev_warn(&hdev->dev, "HDMI: failed to get afg sub nodes\n");
1467                 return -EINVAL;
1468         }
1469
1470         for (i = 0; i < num_nodes; i++, nid++) {
1471                 unsigned int caps;
1472                 unsigned int type;
1473
1474                 caps = get_wcaps(hdev, nid);
1475                 type = get_wcaps_type(caps);
1476
1477                 if (!(caps & AC_WCAP_DIGITAL))
1478                         continue;
1479
1480                 switch (type) {
1481
1482                 case AC_WID_AUD_OUT:
1483                         ret = hdac_hdmi_add_cvt(edev, nid);
1484                         if (ret < 0)
1485                                 goto free_widgets;
1486                         break;
1487
1488                 case AC_WID_PIN:
1489                         ret = hdac_hdmi_add_pin(edev, nid);
1490                         if (ret < 0)
1491                                 goto free_widgets;
1492                         break;
1493                 }
1494         }
1495
1496         if (!hdmi->num_pin || !hdmi->num_cvt) {
1497                 ret = -EIO;
1498                 goto free_widgets;
1499         }
1500
1501         ret = hdac_hdmi_create_dais(hdev, dais, hdmi, hdmi->num_cvt);
1502         if (ret) {
1503                 dev_err(&hdev->dev, "Failed to create dais with err: %d\n",
1504                                                         ret);
1505                 goto free_widgets;
1506         }
1507
1508         *num_dais = hdmi->num_cvt;
1509         ret = hdac_hdmi_init_dai_map(edev);
1510         if (ret < 0)
1511                 goto free_widgets;
1512
1513         return ret;
1514
1515 free_widgets:
1516         list_for_each_entry_safe(temp_cvt, cvt_next, &hdmi->cvt_list, head) {
1517                 list_del(&temp_cvt->head);
1518                 kfree(temp_cvt->name);
1519                 kfree(temp_cvt);
1520         }
1521
1522         list_for_each_entry_safe(temp_pin, pin_next, &hdmi->pin_list, head) {
1523                 for (i = 0; i < temp_pin->num_ports; i++)
1524                         temp_pin->ports[i].pin = NULL;
1525                 kfree(temp_pin->ports);
1526                 list_del(&temp_pin->head);
1527                 kfree(temp_pin);
1528         }
1529
1530         return ret;
1531 }
1532
1533 static void hdac_hdmi_eld_notify_cb(void *aptr, int port, int pipe)
1534 {
1535         struct hdac_ext_device *edev = aptr;
1536         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1537         struct hdac_hdmi_pin *pin = NULL;
1538         struct hdac_hdmi_port *hport = NULL;
1539         struct snd_soc_codec *codec = edev->scodec;
1540         int i;
1541
1542         /* Don't know how this mapping is derived */
1543         hda_nid_t pin_nid = port + 0x04;
1544
1545         dev_dbg(&edev->hdev.dev, "%s: for pin:%d port=%d\n", __func__,
1546                                                         pin_nid, pipe);
1547
1548         /*
1549          * skip notification during system suspend (but not in runtime PM);
1550          * the state will be updated at resume. Also since the ELD and
1551          * connection states are updated in anyway at the end of the resume,
1552          * we can skip it when received during PM process.
1553          */
1554         if (snd_power_get_state(codec->component.card->snd_card) !=
1555                         SNDRV_CTL_POWER_D0)
1556                 return;
1557
1558         if (atomic_read(&edev->hdev.in_pm))
1559                 return;
1560
1561         list_for_each_entry(pin, &hdmi->pin_list, head) {
1562                 if (pin->nid != pin_nid)
1563                         continue;
1564
1565                 /* In case of non MST pin, pipe is -1 */
1566                 if (pipe == -1) {
1567                         pin->mst_capable = false;
1568                         /* if not MST, default is port[0] */
1569                         hport = &pin->ports[0];
1570                 } else {
1571                         for (i = 0; i < pin->num_ports; i++) {
1572                                 pin->mst_capable = true;
1573                                 if (pin->ports[i].id == pipe) {
1574                                         hport = &pin->ports[i];
1575                                         break;
1576                                 }
1577                         }
1578                 }
1579
1580                 if (hport)
1581                         hdac_hdmi_present_sense(pin, hport);
1582         }
1583
1584 }
1585
1586 static struct i915_audio_component_audio_ops aops = {
1587         .pin_eld_notify = hdac_hdmi_eld_notify_cb,
1588 };
1589
1590 static struct snd_pcm *hdac_hdmi_get_pcm_from_id(struct snd_soc_card *card,
1591                                                 int device)
1592 {
1593         struct snd_soc_pcm_runtime *rtd;
1594
1595         list_for_each_entry(rtd, &card->rtd_list, list) {
1596                 if (rtd->pcm && (rtd->pcm->device == device))
1597                         return rtd->pcm;
1598         }
1599
1600         return NULL;
1601 }
1602
1603 /* create jack pin kcontrols */
1604 static int create_fill_jack_kcontrols(struct snd_soc_card *card,
1605                                     struct hdac_ext_device *edev)
1606 {
1607         struct hdac_hdmi_pin *pin;
1608         struct snd_kcontrol_new *kc;
1609         char kc_name[NAME_SIZE], xname[NAME_SIZE];
1610         char *name;
1611         int i = 0, j;
1612         struct snd_soc_codec *codec = edev->scodec;
1613         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1614
1615         kc = devm_kcalloc(codec->dev, hdmi->num_ports,
1616                                 sizeof(*kc), GFP_KERNEL);
1617
1618         if (!kc)
1619                 return -ENOMEM;
1620
1621         list_for_each_entry(pin, &hdmi->pin_list, head) {
1622                 for (j = 0; j < pin->num_ports; j++) {
1623                         snprintf(xname, sizeof(xname), "hif%d-%d Jack",
1624                                                 pin->nid, pin->ports[j].id);
1625                         name = devm_kstrdup(codec->dev, xname, GFP_KERNEL);
1626                         if (!name)
1627                                 return -ENOMEM;
1628                         snprintf(kc_name, sizeof(kc_name), "%s Switch", xname);
1629                         kc[i].name = devm_kstrdup(codec->dev, kc_name,
1630                                                         GFP_KERNEL);
1631                         if (!kc[i].name)
1632                                 return -ENOMEM;
1633
1634                         kc[i].private_value = (unsigned long)name;
1635                         kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1636                         kc[i].access = 0;
1637                         kc[i].info = snd_soc_dapm_info_pin_switch;
1638                         kc[i].put = snd_soc_dapm_put_pin_switch;
1639                         kc[i].get = snd_soc_dapm_get_pin_switch;
1640                         i++;
1641                 }
1642         }
1643
1644         return snd_soc_add_card_controls(card, kc, i);
1645 }
1646
1647 int hdac_hdmi_jack_port_init(struct snd_soc_codec *codec,
1648                         struct snd_soc_dapm_context *dapm)
1649 {
1650         struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
1651         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1652         struct hdac_hdmi_pin *pin;
1653         struct snd_soc_dapm_widget *widgets;
1654         struct snd_soc_dapm_route *route;
1655         char w_name[NAME_SIZE];
1656         int i = 0, j, ret;
1657
1658         widgets = devm_kcalloc(dapm->dev, hdmi->num_ports,
1659                                 sizeof(*widgets), GFP_KERNEL);
1660
1661         if (!widgets)
1662                 return -ENOMEM;
1663
1664         route = devm_kcalloc(dapm->dev, hdmi->num_ports,
1665                                 sizeof(*route), GFP_KERNEL);
1666         if (!route)
1667                 return -ENOMEM;
1668
1669         /* create Jack DAPM widget */
1670         list_for_each_entry(pin, &hdmi->pin_list, head) {
1671                 for (j = 0; j < pin->num_ports; j++) {
1672                         snprintf(w_name, sizeof(w_name), "hif%d-%d Jack",
1673                                                 pin->nid, pin->ports[j].id);
1674
1675                         ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1676                                         snd_soc_dapm_spk, NULL,
1677                                         w_name, NULL, NULL, 0, NULL, 0);
1678                         if (ret < 0)
1679                                 return ret;
1680
1681                         pin->ports[j].jack_pin = widgets[i].name;
1682                         pin->ports[j].dapm = dapm;
1683
1684                         /* add to route from Jack widget to output */
1685                         hdac_hdmi_fill_route(&route[i], pin->ports[j].jack_pin,
1686                                         NULL, pin->ports[j].output_pin, NULL);
1687
1688                         i++;
1689                 }
1690         }
1691
1692         /* Add Route from Jack widget to the output widget */
1693         ret = snd_soc_dapm_new_controls(dapm, widgets, hdmi->num_ports);
1694         if (ret < 0)
1695                 return ret;
1696
1697         ret = snd_soc_dapm_add_routes(dapm, route, hdmi->num_ports);
1698         if (ret < 0)
1699                 return ret;
1700
1701         ret = snd_soc_dapm_new_widgets(dapm->card);
1702         if (ret < 0)
1703                 return ret;
1704
1705         /* Add Jack Pin switch Kcontrol */
1706         ret = create_fill_jack_kcontrols(dapm->card, edev);
1707
1708         if (ret < 0)
1709                 return ret;
1710
1711         /* default set the Jack Pin switch to OFF */
1712         list_for_each_entry(pin, &hdmi->pin_list, head) {
1713                 for (j = 0; j < pin->num_ports; j++)
1714                         snd_soc_dapm_disable_pin(pin->ports[j].dapm,
1715                                                 pin->ports[j].jack_pin);
1716         }
1717
1718         return 0;
1719 }
1720 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_port_init);
1721
1722 int hdac_hdmi_jack_init(struct snd_soc_dai *dai, int device,
1723                                 struct snd_soc_jack *jack)
1724 {
1725         struct snd_soc_codec *codec = dai->codec;
1726         struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
1727         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1728         struct hdac_hdmi_pcm *pcm;
1729         struct snd_pcm *snd_pcm;
1730         int err;
1731
1732         /*
1733          * this is a new PCM device, create new pcm and
1734          * add to the pcm list
1735          */
1736         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
1737         if (!pcm)
1738                 return -ENOMEM;
1739         pcm->pcm_id = device;
1740         pcm->cvt = hdmi->dai_map[dai->id].cvt;
1741         pcm->jack_event = 0;
1742         pcm->jack = jack;
1743         mutex_init(&pcm->lock);
1744         INIT_LIST_HEAD(&pcm->port_list);
1745         snd_pcm = hdac_hdmi_get_pcm_from_id(dai->component->card, device);
1746         if (snd_pcm) {
1747                 err = snd_hdac_add_chmap_ctls(snd_pcm, device, &hdmi->chmap);
1748                 if (err < 0) {
1749                         dev_err(&edev->hdev.dev,
1750                                 "chmap control add failed with err: %d for pcm: %d\n",
1751                                 err, device);
1752                         kfree(pcm);
1753                         return err;
1754                 }
1755         }
1756
1757         list_add_tail(&pcm->head, &hdmi->pcm_list);
1758
1759         return 0;
1760 }
1761 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init);
1762
1763 static void hdac_hdmi_present_sense_all_pins(struct hdac_ext_device *edev,
1764                         struct hdac_hdmi_priv *hdmi, bool detect_pin_caps)
1765 {
1766         int i;
1767         struct hdac_hdmi_pin *pin;
1768
1769         list_for_each_entry(pin, &hdmi->pin_list, head) {
1770                 if (detect_pin_caps) {
1771
1772                         if (hdac_hdmi_get_port_len(edev, pin->nid)  == 0)
1773                                 pin->mst_capable = false;
1774                         else
1775                                 pin->mst_capable = true;
1776                 }
1777
1778                 for (i = 0; i < pin->num_ports; i++) {
1779                         if (!pin->mst_capable && i > 0)
1780                                 continue;
1781
1782                         hdac_hdmi_present_sense(pin, &pin->ports[i]);
1783                 }
1784         }
1785 }
1786
1787 static int hdmi_codec_probe(struct snd_soc_codec *codec)
1788 {
1789         struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
1790         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1791         struct snd_soc_dapm_context *dapm =
1792                 snd_soc_component_get_dapm(&codec->component);
1793         struct hdac_ext_link *hlink = NULL;
1794         int ret;
1795
1796         edev->scodec = codec;
1797
1798         /*
1799          * hold the ref while we probe, also no need to drop the ref on
1800          * exit, we call pm_runtime_suspend() so that will do for us
1801          */
1802         hlink = snd_hdac_ext_bus_get_link(edev->ebus, dev_name(&edev->hdev.dev));
1803         if (!hlink) {
1804                 dev_err(&edev->hdev.dev, "hdac link not found\n");
1805                 return -EIO;
1806         }
1807
1808         snd_hdac_ext_bus_link_get(edev->ebus, hlink);
1809
1810         ret = create_fill_widget_route_map(dapm);
1811         if (ret < 0)
1812                 return ret;
1813
1814         aops.audio_ptr = edev;
1815         ret = snd_hdac_i915_register_notifier(&aops);
1816         if (ret < 0) {
1817                 dev_err(&edev->hdev.dev, "notifier register failed: err: %d\n",
1818                                 ret);
1819                 return ret;
1820         }
1821
1822         hdac_hdmi_present_sense_all_pins(edev, hdmi, true);
1823         /* Imp: Store the card pointer in hda_codec */
1824         edev->card = dapm->card->snd_card;
1825
1826         /*
1827          * hdac_device core already sets the state to active and calls
1828          * get_noresume. So enable runtime and set the device to suspend.
1829          */
1830         pm_runtime_enable(&edev->hdev.dev);
1831         pm_runtime_put(&edev->hdev.dev);
1832         pm_runtime_suspend(&edev->hdev.dev);
1833
1834         return 0;
1835 }
1836
1837 static int hdmi_codec_remove(struct snd_soc_codec *codec)
1838 {
1839         struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
1840
1841         pm_runtime_disable(&edev->hdev.dev);
1842         return 0;
1843 }
1844
1845 #ifdef CONFIG_PM
1846 static int hdmi_codec_prepare(struct device *dev)
1847 {
1848         struct hdac_ext_device *edev = to_hda_ext_device(dev);
1849         struct hdac_device *hdev = &edev->hdev;
1850
1851         pm_runtime_get_sync(&edev->hdev.dev);
1852
1853         /*
1854          * Power down afg.
1855          * codec_read is preferred over codec_write to set the power state.
1856          * This way verb is send to set the power state and response
1857          * is received. So setting power state is ensured without using loop
1858          * to read the state.
1859          */
1860         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
1861                                                         AC_PWRST_D3);
1862
1863         return 0;
1864 }
1865
1866 static void hdmi_codec_complete(struct device *dev)
1867 {
1868         struct hdac_ext_device *edev = to_hda_ext_device(dev);
1869         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
1870         struct hdac_device *hdev = &edev->hdev;
1871
1872         /* Power up afg */
1873         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
1874                                                         AC_PWRST_D0);
1875
1876         hdac_hdmi_skl_enable_all_pins(&edev->hdev);
1877         hdac_hdmi_skl_enable_dp12(&edev->hdev);
1878
1879         /*
1880          * As the ELD notify callback request is not entertained while the
1881          * device is in suspend state. Need to manually check detection of
1882          * all pins here. pin capablity change is not support, so use the
1883          * already set pin caps.
1884          */
1885         hdac_hdmi_present_sense_all_pins(edev, hdmi, false);
1886
1887         pm_runtime_put_sync(&edev->hdev.dev);
1888 }
1889 #else
1890 #define hdmi_codec_prepare NULL
1891 #define hdmi_codec_complete NULL
1892 #endif
1893
1894 static const struct snd_soc_codec_driver hdmi_hda_codec = {
1895         .probe          = hdmi_codec_probe,
1896         .remove         = hdmi_codec_remove,
1897         .idle_bias_off  = true,
1898 };
1899
1900 static void hdac_hdmi_get_chmap(struct hdac_device *hdev, int pcm_idx,
1901                                         unsigned char *chmap)
1902 {
1903         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1904         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1905
1906         memcpy(chmap, pcm->chmap, ARRAY_SIZE(pcm->chmap));
1907 }
1908
1909 static void hdac_hdmi_set_chmap(struct hdac_device *hdev, int pcm_idx,
1910                                 unsigned char *chmap, int prepared)
1911 {
1912         struct hdac_ext_device *edev = to_ehdac_device(hdev);
1913         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1914         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1915         struct hdac_hdmi_port *port;
1916
1917         if (!pcm)
1918                 return;
1919
1920         if (list_empty(&pcm->port_list))
1921                 return;
1922
1923         mutex_lock(&pcm->lock);
1924         pcm->chmap_set = true;
1925         memcpy(pcm->chmap, chmap, ARRAY_SIZE(pcm->chmap));
1926         list_for_each_entry(port, &pcm->port_list, head)
1927                 if (prepared)
1928                         hdac_hdmi_setup_audio_infoframe(edev, pcm, port);
1929         mutex_unlock(&pcm->lock);
1930 }
1931
1932 static bool is_hdac_hdmi_pcm_attached(struct hdac_device *hdev, int pcm_idx)
1933 {
1934         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1935         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1936
1937         if (!pcm)
1938                 return false;
1939
1940         if (list_empty(&pcm->port_list))
1941                 return false;
1942
1943         return true;
1944 }
1945
1946 static int hdac_hdmi_get_spk_alloc(struct hdac_device *hdev, int pcm_idx)
1947 {
1948         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1949         struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
1950         struct hdac_hdmi_port *port;
1951
1952         if (!pcm)
1953                 return 0;
1954
1955         if (list_empty(&pcm->port_list))
1956                 return 0;
1957
1958         port = list_first_entry(&pcm->port_list, struct hdac_hdmi_port, head);
1959
1960         if (!port)
1961                 return 0;
1962
1963         if (!port || !port->eld.eld_valid)
1964                 return 0;
1965
1966         return port->eld.info.spk_alloc;
1967 }
1968
1969 static struct hdac_hdmi_drv_data intel_glk_drv_data  = {
1970         .vendor_nid = INTEL_GLK_VENDOR_NID,
1971 };
1972
1973 static struct hdac_hdmi_drv_data intel_drv_data  = {
1974         .vendor_nid = INTEL_VENDOR_NID,
1975 };
1976
1977 static int hdac_hdmi_dev_probe(struct hdac_ext_device *edev)
1978 {
1979         struct hdac_device *hdev = &edev->hdev;
1980         struct hdac_hdmi_priv *hdmi_priv;
1981         struct snd_soc_dai_driver *hdmi_dais = NULL;
1982         struct hdac_ext_link *hlink = NULL;
1983         int num_dais = 0;
1984         int ret = 0;
1985         struct hdac_driver *hdrv = drv_to_hdac_driver(hdev->dev.driver);
1986         const struct hda_device_id *hdac_id = hdac_get_device_id(hdev, hdrv);
1987
1988         /* hold the ref while we probe */
1989         hlink = snd_hdac_ext_bus_get_link(edev->ebus, dev_name(&edev->hdev.dev));
1990         if (!hlink) {
1991                 dev_err(&edev->hdev.dev, "hdac link not found\n");
1992                 return -EIO;
1993         }
1994
1995         snd_hdac_ext_bus_link_get(edev->ebus, hlink);
1996
1997         hdmi_priv = devm_kzalloc(&hdev->dev, sizeof(*hdmi_priv), GFP_KERNEL);
1998         if (hdmi_priv == NULL)
1999                 return -ENOMEM;
2000
2001         edev->private_data = hdmi_priv;
2002         snd_hdac_register_chmap_ops(hdev, &hdmi_priv->chmap);
2003         hdmi_priv->chmap.ops.get_chmap = hdac_hdmi_get_chmap;
2004         hdmi_priv->chmap.ops.set_chmap = hdac_hdmi_set_chmap;
2005         hdmi_priv->chmap.ops.is_pcm_attached = is_hdac_hdmi_pcm_attached;
2006         hdmi_priv->chmap.ops.get_spk_alloc = hdac_hdmi_get_spk_alloc;
2007
2008         if (!hdac_id)
2009                 return -ENODEV;
2010
2011         if (hdac_id->driver_data)
2012                 hdmi_priv->drv_data =
2013                         (struct hdac_hdmi_drv_data *)hdac_id->driver_data;
2014         else
2015                 hdmi_priv->drv_data = &intel_drv_data;
2016
2017         dev_set_drvdata(&hdev->dev, edev);
2018
2019         INIT_LIST_HEAD(&hdmi_priv->pin_list);
2020         INIT_LIST_HEAD(&hdmi_priv->cvt_list);
2021         INIT_LIST_HEAD(&hdmi_priv->pcm_list);
2022         mutex_init(&hdmi_priv->pin_mutex);
2023
2024         /*
2025          * Turned off in the runtime_suspend during the first explicit
2026          * pm_runtime_suspend call.
2027          */
2028         ret = snd_hdac_display_power(edev->hdev.bus, true);
2029         if (ret < 0) {
2030                 dev_err(&edev->hdev.dev,
2031                         "Cannot turn on display power on i915 err: %d\n",
2032                         ret);
2033                 return ret;
2034         }
2035
2036         ret = hdac_hdmi_parse_and_map_nid(edev, &hdmi_dais, &num_dais);
2037         if (ret < 0) {
2038                 dev_err(&hdev->dev,
2039                         "Failed in parse and map nid with err: %d\n", ret);
2040                 return ret;
2041         }
2042         snd_hdac_refresh_widgets(hdev, true);
2043
2044         /* ASoC specific initialization */
2045         ret = snd_soc_register_codec(&hdev->dev, &hdmi_hda_codec,
2046                                         hdmi_dais, num_dais);
2047
2048         snd_hdac_ext_bus_link_put(edev->ebus, hlink);
2049
2050         return ret;
2051 }
2052
2053 static int hdac_hdmi_dev_remove(struct hdac_ext_device *edev)
2054 {
2055         struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(&edev->hdev);
2056         struct hdac_hdmi_pin *pin, *pin_next;
2057         struct hdac_hdmi_cvt *cvt, *cvt_next;
2058         struct hdac_hdmi_pcm *pcm, *pcm_next;
2059         struct hdac_hdmi_port *port, *port_next;
2060         int i;
2061
2062         snd_soc_unregister_codec(&edev->hdev.dev);
2063
2064         list_for_each_entry_safe(pcm, pcm_next, &hdmi->pcm_list, head) {
2065                 pcm->cvt = NULL;
2066                 if (list_empty(&pcm->port_list))
2067                         continue;
2068
2069                 list_for_each_entry_safe(port, port_next,
2070                                         &pcm->port_list, head)
2071                         list_del(&port->head);
2072
2073                 list_del(&pcm->head);
2074                 kfree(pcm);
2075         }
2076
2077         list_for_each_entry_safe(cvt, cvt_next, &hdmi->cvt_list, head) {
2078                 list_del(&cvt->head);
2079                 kfree(cvt->name);
2080                 kfree(cvt);
2081         }
2082
2083         list_for_each_entry_safe(pin, pin_next, &hdmi->pin_list, head) {
2084                 for (i = 0; i < pin->num_ports; i++)
2085                         pin->ports[i].pin = NULL;
2086                 kfree(pin->ports);
2087                 list_del(&pin->head);
2088                 kfree(pin);
2089         }
2090
2091         return 0;
2092 }
2093
2094 #ifdef CONFIG_PM
2095 static int hdac_hdmi_runtime_suspend(struct device *dev)
2096 {
2097         struct hdac_ext_device *edev = to_hda_ext_device(dev);
2098         struct hdac_device *hdev = &edev->hdev;
2099         struct hdac_bus *bus = hdev->bus;
2100         struct hdac_ext_bus *ebus = hbus_to_ebus(bus);
2101         struct hdac_ext_link *hlink = NULL;
2102         int err;
2103
2104         dev_dbg(dev, "Enter: %s\n", __func__);
2105
2106         /* controller may not have been initialized for the first time */
2107         if (!bus)
2108                 return 0;
2109
2110         /*
2111          * Power down afg.
2112          * codec_read is preferred over codec_write to set the power state.
2113          * This way verb is send to set the power state and response
2114          * is received. So setting power state is ensured without using loop
2115          * to read the state.
2116          */
2117         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
2118                                                         AC_PWRST_D3);
2119         err = snd_hdac_display_power(bus, false);
2120         if (err < 0) {
2121                 dev_err(bus->dev, "Cannot turn on display power on i915\n");
2122                 return err;
2123         }
2124
2125         hlink = snd_hdac_ext_bus_get_link(ebus, dev_name(dev));
2126         if (!hlink) {
2127                 dev_err(dev, "hdac link not found\n");
2128                 return -EIO;
2129         }
2130
2131         snd_hdac_ext_bus_link_put(ebus, hlink);
2132
2133         return 0;
2134 }
2135
2136 static int hdac_hdmi_runtime_resume(struct device *dev)
2137 {
2138         struct hdac_ext_device *edev = to_hda_ext_device(dev);
2139         struct hdac_device *hdev = &edev->hdev;
2140         struct hdac_bus *bus = hdev->bus;
2141         struct hdac_ext_bus *ebus = hbus_to_ebus(bus);
2142         struct hdac_ext_link *hlink = NULL;
2143         int err;
2144
2145         dev_dbg(dev, "Enter: %s\n", __func__);
2146
2147         /* controller may not have been initialized for the first time */
2148         if (!bus)
2149                 return 0;
2150
2151         hlink = snd_hdac_ext_bus_get_link(ebus, dev_name(dev));
2152         if (!hlink) {
2153                 dev_err(dev, "hdac link not found\n");
2154                 return -EIO;
2155         }
2156
2157         snd_hdac_ext_bus_link_get(ebus, hlink);
2158
2159         err = snd_hdac_display_power(bus, true);
2160         if (err < 0) {
2161                 dev_err(bus->dev, "Cannot turn on display power on i915\n");
2162                 return err;
2163         }
2164
2165         hdac_hdmi_skl_enable_all_pins(&edev->hdev);
2166         hdac_hdmi_skl_enable_dp12(&edev->hdev);
2167
2168         /* Power up afg */
2169         snd_hdac_codec_read(hdev, hdev->afg, 0, AC_VERB_SET_POWER_STATE,
2170                                                         AC_PWRST_D0);
2171
2172         return 0;
2173 }
2174 #else
2175 #define hdac_hdmi_runtime_suspend NULL
2176 #define hdac_hdmi_runtime_resume NULL
2177 #endif
2178
2179 static const struct dev_pm_ops hdac_hdmi_pm = {
2180         SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL)
2181         .prepare = hdmi_codec_prepare,
2182         .complete = hdmi_codec_complete,
2183 };
2184
2185 static const struct hda_device_id hdmi_list[] = {
2186         HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
2187         HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0),
2188         HDA_CODEC_EXT_ENTRY(0x8086280b, 0x100000, "Kabylake HDMI", 0),
2189         HDA_CODEC_EXT_ENTRY(0x8086280c, 0x100000, "Cannonlake HDMI",
2190                                                    &intel_glk_drv_data),
2191         HDA_CODEC_EXT_ENTRY(0x8086280d, 0x100000, "Geminilake HDMI",
2192                                                    &intel_glk_drv_data),
2193         {}
2194 };
2195
2196 MODULE_DEVICE_TABLE(hdaudio, hdmi_list);
2197
2198 static struct hdac_ext_driver hdmi_driver = {
2199         . hdac = {
2200                 .driver = {
2201                         .name   = "HDMI HDA Codec",
2202                         .pm = &hdac_hdmi_pm,
2203                 },
2204                 .id_table       = hdmi_list,
2205         },
2206         .probe          = hdac_hdmi_dev_probe,
2207         .remove         = hdac_hdmi_dev_remove,
2208 };
2209
2210 static int __init hdmi_init(void)
2211 {
2212         return snd_hda_ext_driver_register(&hdmi_driver);
2213 }
2214
2215 static void __exit hdmi_exit(void)
2216 {
2217         snd_hda_ext_driver_unregister(&hdmi_driver);
2218 }
2219
2220 module_init(hdmi_init);
2221 module_exit(hdmi_exit);
2222
2223 MODULE_LICENSE("GPL v2");
2224 MODULE_DESCRIPTION("HDMI HD codec");
2225 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
2226 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");