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