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