Lines Matching +full:hdmi +full:- +full:dp1
1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * hdmi.c - routines for HDMI/DisplayPort codecs
6 * Copyright(c) 2008-2010 Intel Corporation
53 struct hdmi_spec *spec = codec->spec;
58 * (dev_id == -1) means it is NON-MST pin
61 if (dev_id == -1)
64 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
66 if ((per_pin->pin_nid == pin_nid) &&
67 (per_pin->dev_id == dev_id))
71 codec_warn(codec, "HDMI: pin NID 0x%x not registered\n", pin_nid);
72 return -EINVAL;
79 struct hdmi_spec *spec = codec->spec;
82 for (pcm_idx = 0; pcm_idx < spec->pcm_used; pcm_idx++)
83 if (get_pcm_rec(spec, pcm_idx)->stream == hinfo)
86 codec_warn(codec, "HDMI: hinfo %p not tied to a PCM\n", hinfo);
87 return -EINVAL;
93 struct hdmi_spec *spec = codec->spec;
97 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
99 if (per_pin->pcm &&
100 per_pin->pcm->pcm->stream == hinfo)
104 codec_dbg(codec, "HDMI: hinfo %p (pcm %d) not registered\n", hinfo,
106 return -EINVAL;
115 for (i = 0; i < spec->num_pins; i++) {
117 if (per_pin->pcm_idx == pcm_idx)
125 struct hdmi_spec *spec = codec->spec;
128 for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++)
129 if (get_cvt(spec, cvt_idx)->cvt_nid == cvt_nid)
132 codec_warn(codec, "HDMI: cvt NID 0x%x not registered\n", cvt_nid);
133 return -EINVAL;
140 struct hdmi_spec *spec = codec->spec;
145 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
147 pcm_idx = kcontrol->private_value;
148 guard(mutex)(&spec->pcm_lock);
152 uinfo->count = 0;
155 eld = &per_pin->sink_eld;
156 uinfo->count = eld->eld_valid ? eld->eld_size : 0;
164 struct hdmi_spec *spec = codec->spec;
169 pcm_idx = kcontrol->private_value;
170 guard(mutex)(&spec->pcm_lock);
174 memset(ucontrol->value.bytes.data, 0,
175 ARRAY_SIZE(ucontrol->value.bytes.data));
179 eld = &per_pin->sink_eld;
180 if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data) ||
181 eld->eld_size > ELD_MAX_SIZE) {
183 return -EINVAL;
186 memset(ucontrol->value.bytes.data, 0,
187 ARRAY_SIZE(ucontrol->value.bytes.data));
188 if (eld->eld_valid)
189 memcpy(ucontrol->value.bytes.data, eld->eld_buffer,
190 eld->eld_size);
207 struct hdmi_spec *spec = codec->spec;
212 return -ENOMEM;
213 kctl->private_value = pcm_idx;
214 kctl->id.device = device;
223 get_hdmi_pcm(spec, pcm_idx)->eld_ctl = kctl;
259 struct hdmi_spec *spec = codec->spec;
267 if (spec->dyn_pin_out)
272 * when the pin is disabled or changed while using with HDMI
288 struct hdmi_spec_per_pin *per_pin = entry->private_data;
290 guard(mutex)(&per_pin->lock);
291 snd_hdmi_print_eld_info(&per_pin->sink_eld, buffer, per_pin->pin_nid,
292 per_pin->dev_id, per_pin->cvt_nid);
298 struct hdmi_spec_per_pin *per_pin = entry->private_data;
300 guard(mutex)(&per_pin->lock);
301 snd_hdmi_write_eld_info(&per_pin->sink_eld, buffer);
307 struct hda_codec *codec = per_pin->codec;
311 snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
312 err = snd_card_proc_new(codec->card, name, &entry);
317 entry->c.text.write = write_eld_info;
318 entry->mode |= 0200;
319 per_pin->proc_entry = entry;
326 if (!per_pin->codec->bus->shutdown) {
327 snd_info_free_entry(per_pin->proc_entry);
328 per_pin->proc_entry = NULL;
375 codec_dbg(codec, "HDMI: ELD buf size is %d\n", size);
380 codec_dbg(codec, "HDMI: DIP GP[%d] buf size is %d\n", i, size);
408 "HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
420 hdmi_ai->checksum = 0;
425 hdmi_ai->checksum = -sum;
476 struct hdmi_spec *spec = codec->spec;
480 if ((conn_type == 0) || /* HDMI */
481 /* Nvidia DisplayPort: Nvidia HW expects same layout as HDMI */
482 (conn_type == 1 && spec->nv_dp_workaround)) {
483 struct hdmi_audio_infoframe *hdmi_ai = &ai.hdmi;
485 if (conn_type == 0) { /* HDMI */
486 hdmi_ai->type = 0x84;
487 hdmi_ai->ver = 0x01;
488 hdmi_ai->len = 0x0a;
490 hdmi_ai->type = 0x84;
491 hdmi_ai->ver = 0x1b;
492 hdmi_ai->len = 0x11 << 2;
494 hdmi_ai->CC02_CT47 = active_channels - 1;
495 hdmi_ai->CA = ca;
500 dp_ai->type = 0x84;
501 dp_ai->len = 0x1b;
502 dp_ai->ver = 0x11 << 2;
503 dp_ai->CC02_CT47 = active_channels - 1;
504 dp_ai->CA = ca;
506 codec_dbg(codec, "HDMI: unknown connection type at pin NID 0x%x\n", pin_nid);
515 * the user switches between HDMI/DP monitors.
532 struct hdmi_spec *spec = codec->spec;
533 struct hdac_chmap *chmap = &spec->chmap;
534 hda_nid_t pin_nid = per_pin->pin_nid;
535 int dev_id = per_pin->dev_id;
536 int channels = per_pin->channels;
552 eld = &per_pin->sink_eld;
554 ca = snd_hdac_channel_allocation(&codec->core,
555 eld->info.spk_alloc, channels,
556 per_pin->chmap_set, non_pcm, per_pin->chmap);
560 chmap->ops.set_channel_count(&codec->core, per_pin->cvt_nid,
567 snd_hdac_setup_channel_mapping(&spec->chmap,
569 per_pin->chmap, per_pin->chmap_set);
571 spec->ops.pin_setup_infoframe(codec, pin_nid, dev_id,
572 ca, active_channels, eld->info.conn_type);
574 per_pin->non_pcm = non_pcm;
587 struct hdmi_spec *spec = codec->spec;
592 guard(mutex)(&spec->pcm_lock);
605 snd_hda_hdmi_check_presence_and_report(codec, jack->nid, jack->dev_id);
611 jack->jack_dirty = 1;
614 "HDMI hot plug event: Codec=%d NID=0x%x Device=%d Inactive=%d Presence_Detect=%d ELD_Valid=%d\n",
615 codec->addr, jack->nid, jack->dev_id, !!(res & AC_UNSOL_RES_IA),
618 snd_hda_hdmi_check_presence_and_report(codec, jack->nid, jack->dev_id);
629 "HDMI CP event: CODEC=%d TAG=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
630 codec->addr,
654 if (codec->dp_mst) {
664 codec_dbg(codec, "Unexpected HDMI event tag 0x%x\n", tag);
679 /* HBR should be Non-PCM, 8 channels */
694 return hbr ? -EINVAL : 0;
705 pinctl == new_pinctl ? "" : "new-",
713 return -EINVAL;
723 struct hdmi_spec *spec = codec->spec;
727 err = spec->ops.pin_hbr_setup(codec, pin_nid, dev_id,
735 if (spec->intel_hsw_fixup) {
769 struct hdmi_spec *spec = codec->spec;
780 if (per_pin && per_pin->silent_stream) {
781 cvt_idx = cvt_nid_to_cvt_index(codec, per_pin->cvt_nid);
783 if (per_cvt->assigned && !silent)
784 return -EBUSY;
791 for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
795 if (per_cvt->assigned || per_cvt->silent_stream)
800 for (mux_idx = 0; mux_idx < per_pin->num_mux_nids; mux_idx++)
801 if (per_pin->mux_nids[mux_idx] == per_cvt->cvt_nid)
804 if (mux_idx == per_pin->num_mux_nids)
810 if (cvt_idx == spec->num_cvts)
811 return -EBUSY;
814 per_pin->mux_idx = mux_idx;
827 struct hdmi_spec *spec = codec->spec;
829 if (spec->ops.pin_cvt_fixup)
830 spec->ops.pin_cvt_fixup(codec, per_pin, cvt_nid);
838 struct hdmi_spec *spec = codec->spec;
839 struct snd_pcm_runtime *runtime = substream->runtime;
846 return -EINVAL;
848 err = hdmi_choose_cvt(codec, -1, &cvt_idx, false);
853 per_cvt->assigned = true;
854 hinfo->nid = per_cvt->cvt_nid;
856 pin_cvt_fixup(codec, NULL, per_cvt->cvt_nid);
858 set_bit(pcm_idx, &spec->pcm_in_use);
862 hinfo->channels_min = per_cvt->channels_min;
863 hinfo->channels_max = per_cvt->channels_max;
864 hinfo->rates = per_cvt->rates;
865 hinfo->formats = per_cvt->formats;
866 hinfo->maxbps = per_cvt->maxbps;
869 runtime->hw.channels_min = hinfo->channels_min;
870 runtime->hw.channels_max = hinfo->channels_max;
871 runtime->hw.formats = hinfo->formats;
872 runtime->hw.rates = hinfo->rates;
874 snd_pcm_hw_constraint_step(substream->runtime, 0,
886 struct hdmi_spec *spec = codec->spec;
887 struct snd_pcm_runtime *runtime = substream->runtime;
897 return -EINVAL;
899 guard(mutex)(&spec->pcm_lock);
913 per_cvt->assigned = true;
915 set_bit(pcm_idx, &spec->pcm_in_use);
917 per_pin->cvt_nid = per_cvt->cvt_nid;
918 hinfo->nid = per_cvt->cvt_nid;
921 if (get_wcaps(codec, per_cvt->cvt_nid) & AC_WCAP_STRIPE)
922 azx_stream(get_azx_dev(substream))->stripe = 1;
924 snd_hda_set_dev_select(codec, per_pin->pin_nid, per_pin->dev_id);
925 snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
927 per_pin->mux_idx);
932 snd_hda_spdif_ctls_assign(codec, pcm_idx, per_cvt->cvt_nid);
935 hinfo->channels_min = per_cvt->channels_min;
936 hinfo->channels_max = per_cvt->channels_max;
937 hinfo->rates = per_cvt->rates;
938 hinfo->formats = per_cvt->formats;
939 hinfo->maxbps = per_cvt->maxbps;
941 eld = &per_pin->sink_eld;
943 if (!static_hdmi_pcm && eld->eld_valid) {
944 snd_hdmi_eld_update_pcm_info(&eld->info, hinfo);
945 if (hinfo->channels_min > hinfo->channels_max ||
946 !hinfo->rates || !hinfo->formats) {
947 per_cvt->assigned = false;
948 hinfo->nid = 0;
950 return -ENODEV;
955 runtime->hw.channels_min = hinfo->channels_min;
956 runtime->hw.channels_max = hinfo->channels_max;
957 runtime->hw.formats = hinfo->formats;
958 runtime->hw.rates = hinfo->rates;
960 snd_pcm_hw_constraint_step(substream->runtime, 0,
966 * HDA/HDMI auto parsing
970 struct hdmi_spec *spec = codec->spec;
972 hda_nid_t pin_nid = per_pin->pin_nid;
973 int dev_id = per_pin->dev_id;
978 "HDMI: pin NID 0x%x wcaps %#x does not support connection list\n",
980 return -EINVAL;
985 if (spec->intel_hsw_fixup) {
986 conns = spec->num_cvts;
987 memcpy(per_pin->mux_nids, spec->cvt_nids,
991 per_pin->mux_nids,
996 per_pin->num_mux_nids = conns;
1006 for (i = 0; i < spec->pcm_used; i++) {
1007 if (!test_bit(i, &spec->pcm_bitmap))
1010 return -EBUSY;
1019 if (per_pin->pcm)
1022 idx = per_pin->prev_pcm_idx;
1024 if (!test_bit(idx, &spec->pcm_bitmap))
1026 per_pin->prev_pcm_idx = -1; /* no longer valid, clear it */
1029 if (idx == -EBUSY)
1032 per_pin->pcm_idx = idx;
1033 per_pin->pcm = get_hdmi_pcm(spec, idx);
1034 set_bit(idx, &spec->pcm_bitmap);
1043 if (!per_pin->pcm)
1045 idx = per_pin->pcm_idx;
1046 per_pin->pcm_idx = -1;
1047 per_pin->prev_pcm_idx = idx; /* remember the previous index */
1048 per_pin->pcm = NULL;
1049 if (idx >= 0 && idx < spec->pcm_used)
1050 clear_bit(idx, &spec->pcm_bitmap);
1058 for (mux_idx = 0; mux_idx < per_pin->num_mux_nids; mux_idx++)
1059 if (per_pin->mux_nids[mux_idx] == cvt_nid)
1069 struct hda_codec *codec = per_pin->codec;
1076 if (per_pin->pcm_idx < 0 || per_pin->pcm_idx >= spec->pcm_used)
1078 pcm = get_pcm_rec(spec, per_pin->pcm_idx);
1079 if (!pcm->pcm)
1081 if (!test_bit(per_pin->pcm_idx, &spec->pcm_in_use))
1084 /* hdmi audio only uses playback and one substream */
1085 hinfo = pcm->stream;
1086 substream = pcm->pcm->streams[0].substream;
1088 per_pin->cvt_nid = hinfo->nid;
1090 mux_idx = hdmi_get_pin_cvt_mux(spec, per_pin, hinfo->nid);
1091 if (mux_idx < per_pin->num_mux_nids) {
1092 snd_hda_set_dev_select(codec, per_pin->pin_nid,
1093 per_pin->dev_id);
1094 snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
1098 snd_hda_spdif_ctls_assign(codec, per_pin->pcm_idx, hinfo->nid);
1100 non_pcm = check_non_pcm_per_cvt(codec, hinfo->nid);
1101 if (substream->runtime)
1102 per_pin->channels = substream->runtime->channels;
1103 per_pin->setup = true;
1104 per_pin->mux_idx = mux_idx;
1112 if (per_pin->pcm_idx >= 0 && per_pin->pcm_idx < spec->pcm_used)
1113 snd_hda_spdif_ctls_unassign(per_pin->codec, per_pin->pcm_idx);
1115 per_pin->chmap_set = false;
1116 memset(per_pin->chmap, 0, sizeof(per_pin->chmap));
1118 per_pin->setup = false;
1119 per_pin->channels = 0;
1125 struct hdmi_spec *spec = codec->spec;
1127 if (per_pin->pcm_idx >= 0)
1128 return spec->pcm_rec[per_pin->pcm_idx].jack;
1142 struct hdmi_eld *pin_eld = &per_pin->sink_eld;
1143 struct hdmi_spec *spec = codec->spec;
1145 bool old_eld_valid = pin_eld->eld_valid;
1149 if (eld->eld_valid) {
1150 if (eld->eld_size <= 0 ||
1151 snd_parse_eld(hda_codec_dev(codec), &eld->info,
1152 eld->eld_buffer, eld->eld_size) < 0) {
1153 eld->eld_valid = false;
1155 schedule_delayed_work(&per_pin->work,
1162 if (!eld->eld_valid || eld->eld_size <= 0 || eld->info.sad_count <= 0) {
1163 eld->eld_valid = false;
1164 eld->eld_size = 0;
1168 pcm_idx = per_pin->pcm_idx;
1176 if (!spec->static_pcm_mapping) {
1177 if (eld->eld_valid) {
1186 /* if pcm_idx == -1, it means this is in monitor connection event
1189 if (pcm_idx == -1)
1190 pcm_idx = per_pin->pcm_idx;
1194 if (eld->eld_valid)
1195 snd_show_eld(hda_codec_dev(codec), &eld->info);
1197 eld_changed = (pin_eld->eld_valid != eld->eld_valid);
1198 eld_changed |= (pin_eld->monitor_present != eld->monitor_present);
1199 if (!eld_changed && eld->eld_valid && pin_eld->eld_valid)
1200 if (pin_eld->eld_size != eld->eld_size ||
1201 memcmp(pin_eld->eld_buffer, eld->eld_buffer,
1202 eld->eld_size) != 0)
1206 pin_eld->monitor_present = eld->monitor_present;
1207 pin_eld->eld_valid = eld->eld_valid;
1208 pin_eld->eld_size = eld->eld_size;
1209 if (eld->eld_valid)
1210 memcpy(pin_eld->eld_buffer, eld->eld_buffer,
1211 eld->eld_size);
1212 pin_eld->info = eld->info;
1216 * Re-setup pin and infoframe. This is needed e.g. when
1217 * - sink is first plugged-in
1218 * - transcoder can change during stream playback on Haswell
1221 if (eld->eld_valid && !old_eld_valid && per_pin->setup) {
1223 snd_hda_hdmi_setup_audio_infoframe(codec, per_pin, per_pin->non_pcm);
1227 snd_ctl_notify(codec->card,
1230 &get_hdmi_pcm(spec, pcm_idx)->eld_ctl->id);
1234 (eld->monitor_present && eld->eld_valid) ?
1238 /* update ELD and jack state via HD-audio verbs */
1242 struct hda_codec *codec = per_pin->codec;
1243 struct hdmi_spec *spec = codec->spec;
1244 struct hdmi_eld *eld = &spec->temp_eld;
1246 hda_nid_t pin_nid = per_pin->pin_nid;
1247 int dev_id = per_pin->dev_id;
1252 * the real PD value changed. An older version of the HD-audio
1259 if (dev->power.runtime_status == RPM_SUSPENDING)
1269 guard(mutex)(&per_pin->lock);
1270 eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE);
1271 if (eld->monitor_present)
1272 eld->eld_valid = !!(present & AC_PINSENSE_ELDV);
1274 eld->eld_valid = false;
1277 "HDMI status: Codec=%d NID=0x%x Presence_Detect=%d ELD_Valid=%d\n",
1278 codec->addr, pin_nid, eld->monitor_present, eld->eld_valid);
1280 if (eld->eld_valid) {
1281 if (spec->ops.pin_get_eld(codec, pin_nid, dev_id,
1282 eld->eld_buffer, &eld->eld_size) < 0)
1283 eld->eld_valid = false;
1292 struct hdmi_spec *spec = codec->spec;
1297 * Power-up will call hdmi_present_sense, so the PM calls
1302 if (pm.err < 0 && pm.err != -EACCES) {
1308 guard(mutex)(&per_pin->lock);
1310 if (per_pin->setup) {
1311 codec_dbg(codec, "hdmi: PCM already open, no silent stream\n");
1315 pin_idx = pin_id_to_pin_index(codec, per_pin->pin_nid, per_pin->dev_id);
1318 codec_err(codec, "hdmi: no free converter to enable silent mode\n");
1323 per_cvt->silent_stream = true;
1324 per_pin->cvt_nid = per_cvt->cvt_nid;
1325 per_pin->silent_stream = true;
1327 codec_dbg(codec, "hdmi: enabling silent stream pin-NID=0x%x cvt-NID=0x%x\n",
1328 per_pin->pin_nid, per_cvt->cvt_nid);
1330 snd_hda_set_dev_select(codec, per_pin->pin_nid, per_pin->dev_id);
1331 snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
1333 per_pin->mux_idx);
1338 spec->ops.silent_stream(codec, per_pin, true);
1344 struct hdmi_spec *spec = codec->spec;
1349 if (pm.err < 0 && pm.err != -EACCES) {
1356 guard(mutex)(&per_pin->lock);
1357 if (!per_pin->silent_stream)
1360 codec_dbg(codec, "HDMI: disable silent stream on pin-NID=0x%x cvt-NID=0x%x\n",
1361 per_pin->pin_nid, per_pin->cvt_nid);
1363 cvt_idx = cvt_nid_to_cvt_index(codec, per_pin->cvt_nid);
1364 if (cvt_idx >= 0 && cvt_idx < spec->num_cvts) {
1366 per_cvt->silent_stream = false;
1369 spec->ops.silent_stream(codec, per_pin, false);
1371 per_pin->cvt_nid = 0;
1372 per_pin->silent_stream = false;
1379 struct hdmi_spec *spec = codec->spec;
1380 struct hdmi_eld *eld = &spec->temp_eld;
1383 scoped_guard(mutex, &per_pin->lock) {
1384 eld->monitor_present = false;
1385 monitor_prev = per_pin->sink_eld.monitor_present;
1386 eld->eld_size = snd_hdac_acomp_get_eld(&codec->core, per_pin->pin_nid,
1387 per_pin->dev_id, &eld->monitor_present,
1388 eld->eld_buffer, ELD_MAX_SIZE);
1389 eld->eld_valid = (eld->eld_size > 0);
1391 monitor_next = per_pin->sink_eld.monitor_present;
1394 if (spec->silent_stream_type) {
1404 struct hda_codec *codec = per_pin->codec;
1416 struct hda_codec *codec = per_pin->codec;
1417 struct hdmi_spec *spec = codec->spec;
1420 jack = snd_hda_jack_tbl_get_mst(codec, per_pin->pin_nid,
1421 per_pin->dev_id);
1423 jack->jack_dirty = 1;
1425 if (per_pin->repoll_count++ > 6)
1426 per_pin->repoll_count = 0;
1428 guard(mutex)(&spec->pcm_lock);
1429 hdmi_present_sense(per_pin, per_pin->repoll_count);
1434 struct hdmi_spec *spec = codec->spec;
1451 !spec->force_connect)
1458 if (spec->intel_hsw_fixup) {
1465 dev_num = spec->dev_num;
1466 } else if (codec->dp_mst) {
1469 * spec->dev_num is the maxinum number of device entries
1472 spec->dev_num = (spec->dev_num > dev_num) ?
1473 spec->dev_num : dev_num;
1481 spec->dev_num = 1;
1485 pin_idx = spec->num_pins;
1486 per_pin = snd_array_new(&spec->pins);
1489 return -ENOMEM;
1491 per_pin->pcm = NULL;
1492 per_pin->pcm_idx = -1;
1493 per_pin->prev_pcm_idx = -1;
1494 per_pin->pin_nid = pin_nid;
1495 per_pin->pin_nid_idx = spec->num_nids;
1496 per_pin->dev_id = i;
1497 per_pin->non_pcm = false;
1503 codec_warn(codec, "HDMI: pin NID 0x%x - jack not detectable\n", pin_nid);
1504 spec->num_pins++;
1506 spec->num_nids++;
1513 struct hdmi_spec *spec = codec->spec;
1521 per_cvt = snd_array_new(&spec->cvts);
1523 return -ENOMEM;
1525 per_cvt->cvt_nid = cvt_nid;
1526 per_cvt->channels_min = 2;
1528 per_cvt->channels_max = chans;
1529 if (chans > spec->chmap.channels_max)
1530 spec->chmap.channels_max = chans;
1534 &per_cvt->rates,
1535 &per_cvt->formats,
1537 &per_cvt->maxbps);
1541 if (spec->num_cvts < ARRAY_SIZE(spec->cvt_nids))
1542 spec->cvt_nids[spec->num_cvts] = cvt_nid;
1543 spec->num_cvts++;
1559 SND_PCI_QUIRK(0x1462, 0xec94, "MS-7C94", 1),
1567 struct hdmi_spec *spec = codec->spec;
1573 nodes = snd_hda_get_sub_nodes(codec, codec->core.afg, &start_nid);
1575 codec_warn(codec, "HDMI: failed to get afg sub nodes\n");
1576 return -EINVAL;
1580 spec->force_connect = true;
1582 q = snd_pci_quirk_lookup(codec->bus->pci, force_connect_list);
1584 if (q && q->value)
1585 spec->force_connect = true;
1626 guard(mutex)(&codec->spdif_mutex);
1633 return !!(spdif->status & IEC958_AES0_NONAUDIO);
1637 * HDMI callbacks
1646 hda_nid_t cvt_nid = hinfo->nid;
1647 struct hdmi_spec *spec = codec->spec;
1650 struct snd_pcm_runtime *runtime = substream->runtime;
1654 guard(mutex)(&spec->pcm_lock);
1679 /* Todo: add DP1.2 MST audio support later */
1681 snd_hdac_sync_audio_rate(&codec->core, per_pin->pin_nid,
1682 per_pin->dev_id, runtime->rate);
1685 scoped_guard(mutex, &per_pin->lock) {
1686 per_pin->channels = substream->runtime->channels;
1687 per_pin->setup = true;
1690 stripe = snd_hdac_get_stream_stripe_ctl(&codec->bus->core,
1699 if (spec->dyn_pin_out) {
1700 snd_hda_set_dev_select(codec, per_pin->pin_nid,
1701 per_pin->dev_id);
1702 pinctl = snd_hda_codec_read(codec, per_pin->pin_nid, 0,
1704 snd_hda_codec_write(codec, per_pin->pin_nid, 0,
1710 return spec->ops.setup_stream(codec, cvt_nid, per_pin->pin_nid,
1711 per_pin->dev_id, stream_tag, format);
1719 snd_hda_codec_cleanup_stream(codec, hinfo->nid);
1728 struct hdmi_spec *spec = codec->spec;
1734 guard(mutex)(&spec->pcm_lock);
1735 if (hinfo->nid) {
1738 return -EINVAL;
1739 cvt_idx = cvt_nid_to_cvt_index(codec, hinfo->nid);
1741 return -EINVAL;
1743 per_cvt->assigned = false;
1744 hinfo->nid = 0;
1746 azx_stream(get_azx_dev(substream))->stripe = 0;
1749 clear_bit(pcm_idx, &spec->pcm_in_use);
1760 if (spec->dyn_pin_out) {
1761 snd_hda_set_dev_select(codec, per_pin->pin_nid,
1762 per_pin->dev_id);
1763 pinctl = snd_hda_codec_read(codec, per_pin->pin_nid, 0,
1765 snd_hda_codec_write(codec, per_pin->pin_nid, 0,
1770 guard(mutex)(&per_pin->lock);
1771 per_pin->chmap_set = false;
1772 memset(per_pin->chmap, 0, sizeof(per_pin->chmap));
1774 per_pin->setup = false;
1775 per_pin->channels = 0;
1791 struct hdmi_spec *spec = codec->spec;
1797 return per_pin->sink_eld.info.spk_alloc;
1804 struct hdmi_spec *spec = codec->spec;
1811 memcpy(chmap, per_pin->chmap, ARRAY_SIZE(per_pin->chmap));
1818 struct hdmi_spec *spec = codec->spec;
1823 guard(mutex)(&per_pin->lock);
1824 per_pin->chmap_set = true;
1825 memcpy(per_pin->chmap, chmap, ARRAY_SIZE(per_pin->chmap));
1827 snd_hda_hdmi_setup_audio_infoframe(codec, per_pin, per_pin->non_pcm);
1833 struct hdmi_spec *spec = codec->spec;
1841 struct hdmi_spec *spec = codec->spec;
1845 pcm_num = min(spec->num_cvts, spec->num_pins);
1846 codec_dbg(codec, "hdmi: pcm_num set to %d\n", pcm_num);
1853 info = snd_hda_codec_pcm_new(codec, "HDMI %d", idx);
1855 return -ENOMEM;
1857 spec->pcm_rec[idx].pcm = info;
1858 spec->pcm_used++;
1859 info->pcm_type = HDA_PCM_TYPE_HDMI;
1860 info->own_chmap = true;
1862 pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
1863 pstr->substreams = 1;
1864 pstr->ops = generic_ops;
1867 pstr->channels_min = per_cvt->channels_min;
1868 pstr->channels_max = per_cvt->channels_max;
1871 if (spec->pcm_used >= ARRAY_SIZE(spec->pcm_rec))
1882 struct hdmi_pcm *pcm = jack->private_data;
1884 pcm->jack = NULL;
1889 char hdmi_str[32] = "HDMI/DP";
1890 struct hdmi_spec *spec = codec->spec;
1892 int pcmdev = get_pcm_rec(spec, pcm_idx)->device;
1898 err = snd_jack_new(codec->card, hdmi_str, SND_JACK_AVOUT, &jack,
1903 spec->pcm_rec[pcm_idx].jack = jack;
1904 jack->private_data = &spec->pcm_rec[pcm_idx];
1905 jack->private_free = free_hdmi_jack_priv;
1911 struct hdmi_spec *spec = codec->spec;
1915 for (pcm_idx = 0; pcm_idx < spec->pcm_used; pcm_idx++) {
1916 if (!get_pcm_rec(spec, pcm_idx)->pcm) {
1918 set_bit(pcm_idx, &spec->pcm_bitmap);
1930 0, spec->cvt_nids[0],
1936 dev = get_pcm_rec(spec, pcm_idx)->device;
1945 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
1947 struct hdmi_eld *pin_eld = &per_pin->sink_eld;
1949 if (spec->static_pcm_mapping) {
1954 pin_eld->eld_valid = false;
1959 for (pcm_idx = 0; pcm_idx < spec->pcm_used; pcm_idx++) {
1963 if (!pcm || !pcm->pcm)
1965 err = snd_hdac_add_chmap_ctls(pcm->pcm, pcm_idx, &spec->chmap);
1976 struct hdmi_spec *spec = codec->spec;
1979 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
1982 per_pin->codec = codec;
1983 mutex_init(&per_pin->lock);
1984 INIT_DELAYED_WORK(&per_pin->work, hdmi_repoll_eld);
1993 struct hdmi_spec *spec = codec->spec;
1996 guard(mutex)(&spec->bind_lock);
1997 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
1999 hda_nid_t pin_nid = per_pin->pin_nid;
2000 int dev_id = per_pin->dev_id;
2015 snd_array_init(&spec->pins, sizeof(struct hdmi_spec_per_pin), nums);
2016 snd_array_init(&spec->cvts, sizeof(struct hdmi_spec_per_cvt), nums);
2021 snd_array_free(&spec->pins);
2022 snd_array_free(&spec->cvts);
2027 struct hdmi_spec *spec = codec->spec;
2032 codec->spec = NULL;
2034 codec->dp_mst = false;
2040 struct hdmi_spec *spec = codec->spec;
2043 if (spec->acomp_registered) {
2044 snd_hdac_acomp_exit(&codec->bus->core);
2046 snd_hdac_acomp_register_notifier(&codec->bus->core, NULL);
2048 codec->relaxed_resume = 0;
2050 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2052 cancel_delayed_work_sync(&per_pin->work);
2056 for (pcm_idx = 0; pcm_idx < spec->pcm_used; pcm_idx++) {
2057 if (spec->pcm_rec[pcm_idx].jack == NULL)
2059 snd_device_free(codec->card, spec->pcm_rec[pcm_idx].jack);
2068 struct hdmi_spec *spec = codec->spec;
2071 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2073 cancel_delayed_work_sync(&per_pin->work);
2081 struct hdmi_spec *spec = codec->spec;
2087 for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
2102 /* allocate codec->spec and assign/initialize generic parser ops */
2109 return -ENOMEM;
2111 spec->codec = codec;
2112 spec->ops = generic_standard_hdmi_ops;
2113 spec->dev_num = 1; /* initialize to 1 */
2114 mutex_init(&spec->pcm_lock);
2115 mutex_init(&spec->bind_lock);
2116 snd_hdac_register_chmap_ops(&codec->core, &spec->chmap);
2118 spec->chmap.ops.get_chmap = hdmi_get_chmap;
2119 spec->chmap.ops.set_chmap = hdmi_set_chmap;
2120 spec->chmap.ops.is_pcm_attached = is_hdmi_pcm_attached;
2121 spec->chmap.ops.get_spk_alloc = hdmi_get_spk_alloc;
2123 codec->spec = spec;
2130 /* generic HDMI parser */
2162 /* clear unsol even if component notifier is used, or re-enable
2165 unsigned int val = use_acomp ? 0 : (AC_USRSP_EN | tbl->tag);
2178 spec = container_of(acomp->audio_ops, struct hdmi_spec, drm_audio_ops);
2179 guard(mutex)(&spec->bind_lock);
2180 spec->use_acomp_notifier = use_acomp;
2181 spec->codec->relaxed_resume = use_acomp;
2182 spec->codec->bus->keep_power = 0;
2184 for (i = 0; i < spec->num_pins; i++)
2185 reprogram_jack_detect(spec->codec,
2186 get_pin(spec, i)->pin_nid,
2187 get_pin(spec, i)->dev_id,
2207 /* check whether both HD-audio and DRM PCI devices belong to the same bus */
2213 if (!dev_is_pci(dev) || !dev_is_pci(bus->dev))
2215 master = to_pci_dev(bus->dev);
2217 return master->bus == pci->bus;
2220 /* audio component notifier for AMD/Nvidia HDMI codecs */
2224 struct hdmi_spec *spec = codec->spec;
2225 hda_nid_t pin_nid = spec->port2pin(codec, port);
2234 if (codec->core.dev.power.power_state.event == PM_EVENT_SUSPEND)
2245 struct hdmi_spec *spec = codec->spec;
2247 spec->drm_audio_ops.audio_ptr = codec;
2253 spec->drm_audio_ops.pin2port = ops->pin2port;
2254 spec->drm_audio_ops.pin_eld_notify = ops->pin_eld_notify;
2255 spec->drm_audio_ops.master_bind = ops->master_bind;
2256 spec->drm_audio_ops.master_unbind = ops->master_unbind;
2260 /* initialize the generic HDMI audio component */
2265 struct hdmi_spec *spec = codec->spec;
2272 spec->port2pin = port2pin;
2274 if (!snd_hdac_acomp_init(&codec->bus->core, &spec->drm_audio_ops,
2276 spec->acomp_registered = true;
2299 * another, need to do actual clean-ups in codec_cleanup_stream
2301 if (id->driver_data == MODEL_GF)
2302 codec->no_sticky_stream = 1;
2321 HDA_CODEC_ID_MODEL(0x00147a47, "Loongson HDMI", MODEL_GENERIC),
2322 HDA_CODEC_ID_MODEL(0x10951390, "SiI1390 HDMI", MODEL_GENERIC),
2323 HDA_CODEC_ID_MODEL(0x10951392, "SiI1392 HDMI", MODEL_GENERIC),
2324 HDA_CODEC_ID_MODEL(0x11069f84, "VX11 HDMI/DP", MODEL_GENERIC),
2325 HDA_CODEC_ID_MODEL(0x11069f85, "VX11 HDMI/DP", MODEL_GENERIC),
2326 HDA_CODEC_ID_MODEL(0x17e80047, "Chrontel HDMI", MODEL_GENERIC),
2327 HDA_CODEC_ID_MODEL(0x1d179f86, "ZX-100S HDMI/DP", MODEL_GF),
2328 HDA_CODEC_ID_MODEL(0x1d179f87, "ZX-100S HDMI/DP", MODEL_GF),
2329 HDA_CODEC_ID_MODEL(0x1d179f88, "KX-5000 HDMI/DP", MODEL_GF),
2330 HDA_CODEC_ID_MODEL(0x1d179f89, "KX-5000 HDMI/DP", MODEL_GF),
2331 HDA_CODEC_ID_MODEL(0x1d179f8a, "KX-6000 HDMI/DP", MODEL_GF),
2332 HDA_CODEC_ID_MODEL(0x1d179f8b, "KX-6000 HDMI/DP", MODEL_GF),
2333 HDA_CODEC_ID_MODEL(0x1d179f8c, "KX-6000G HDMI/DP", MODEL_GF),
2334 HDA_CODEC_ID_MODEL(0x1d179f8d, "KX-6000G HDMI/DP", MODEL_GF),
2335 HDA_CODEC_ID_MODEL(0x1d179f8e, "KX-7000 HDMI/DP", MODEL_GF),
2336 HDA_CODEC_ID_MODEL(0x1d179f8f, "KX-7000 HDMI/DP", MODEL_GF),
2337 HDA_CODEC_ID_MODEL(0x1d179f90, "KX-7000 HDMI/DP", MODEL_GF),
2338 HDA_CODEC_ID_MODEL(0x67663d82, "Arise 82 HDMI/DP", MODEL_GF),
2339 HDA_CODEC_ID_MODEL(0x67663d83, "Arise 83 HDMI/DP", MODEL_GF),
2340 HDA_CODEC_ID_MODEL(0x67663d84, "Arise 84 HDMI/DP", MODEL_GF),
2341 HDA_CODEC_ID_MODEL(0x67663d85, "Arise 85 HDMI/DP", MODEL_GF),
2342 HDA_CODEC_ID_MODEL(0x67663d86, "Arise 86 HDMI/DP", MODEL_GF),
2343 HDA_CODEC_ID_MODEL(0x67663d87, "Arise 87 HDMI/DP", MODEL_GF),
2344 HDA_CODEC_ID_MODEL(0x80862801, "Bearlake HDMI", MODEL_GENERIC),
2345 HDA_CODEC_ID_MODEL(0x80862802, "Cantiga HDMI", MODEL_GENERIC),
2346 HDA_CODEC_ID_MODEL(0x80862803, "Eaglelake HDMI", MODEL_GENERIC),
2347 HDA_CODEC_ID_MODEL(0x80862880, "CedarTrail HDMI", MODEL_GENERIC),
2348 HDA_CODEC_ID_MODEL(0x808629fb, "Crestline HDMI", MODEL_GENERIC),
2349 /* special ID for generic HDMI */
2350 HDA_CODEC_ID_MODEL(HDA_CODEC_ID_GENERIC_HDMI, "Generic HDMI", MODEL_GENERIC),
2356 MODULE_DESCRIPTION("Generic HDMI HD-audio codec");