?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[cris-mirror.git] / sound / soc / codecs / hdac_hdmi.c
blobdba6f4c5074aeb09575f94f3adab20d6d7ec3f2f
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>");
CRIS linux kernel tree