Commit 73cd0490 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: hda/hdmi: Split vendor codec drivers 



In the past, we unified HD-audio HDMI codec driver once with a slight
hope that more vendors will follow the standard, but in reality, the
driver received more and more vendor-specific code.  In order to make
the messy code a bit more understandable, this patch splits the HDMI
codec driver into multiple drivers again.

Namely, the vendor-specific code for Intel, AMD and Nvidia are moved
into the own drivers, while we split the common HDMI code to two
drivers, the generic HDMI driver and the simple HDMI driver.
So, now we have:

- The generic HDMI driver (snd-hda-codec-hdmi):
  providing the common helpers, also supports Glenfly HDMI codecs and
  some other codecs that don't need vendor-specific stuff

- The simple HDMI driver (snd-hda-codec-simplehdmi):
  devices with no dynamic PCM assignment and with fixed channels,
  mostly used by some other drivers, but this driver alone suffices
  for VIA HDMI codec support, too

- Intel HDMI driver (snd-hda-codec-intelhdmi):
  bound with i915 / Xe DRM, based on the generic HDMI driver

- AMD/ATI HDMI driver (snd-hda-codec-atihdmi):
  optionally bound with radeon / amdgpu DRM, based on the generic HDMI
  driver

- Nvidia HDMI driver (snd-hda-codec-nvhdmi);
  optionally bound with nouveau DRM, based on the generic HDMI driver

- Legacy Nvidia HDMI driver (snd-hda-codec-nvhdmi-mcp):
  for 2ch or 8ch outputs, based on the simple HDMI driver

- Nvidia Tegra HDMI driver (snd-hda-codec-tegrahdmi):
  based on the generic HDMI driver

Along with the driver split, the enable_silent_stream module option is
moved to snd-hda-codec-intelhdmi, too, as it's an Intel-specific
feature.

Most of the changes here are just to split and move the code to
different files, as well as to rename/expose the functions that are
commonly used by drivers.

The silent stream handling code is slightly modified for putting the
stuff into Intel driver; now a new callback "silent_stream" is defined
in hdmi_ops, and it's called in silent_stream_enable() and *_disable()
functions.  The runtime-PM handling in silent_stream_enable() was
cleaned up, and rather taking the runtime PM refcount in the
silent_stream() callback appropriately, instead.

Other than that, there should be no functional changes.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
Link: https://patch.msgid.link/20250709160434.1859-9-tiwai@suse.de
parent aeeb85f2

sound/hda/codecs/Kconfig

+1 −30
Original line number Diff line number Diff line
@@ -35,21 +35,6 @@ config SND_HDA_CODEC_VIA 
comment "Set to Y if you want auto-loading the codec driver"

	depends on SND_HDA=y && SND_HDA_CODEC_VIA=m



config SND_HDA_CODEC_HDMI

	tristate "Build HDMI/DisplayPort HD-audio codec support"

	select SND_DYNAMIC_MINORS

	select SND_PCM_ELD

	help

	  Say Y or M here to include HDMI and DisplayPort HD-audio codec

	  support in snd-hda-intel driver.  This includes all AMD/ATI,

	  Intel and Nvidia HDMI/DisplayPort codecs.



	  Note that this option mandatorily enables CONFIG_SND_DYNAMIC_MINORS

	  to assure the multiple streams for DP-MST support.



comment "Set to Y if you want auto-loading the codec driver"

	depends on SND_HDA=y && SND_HDA_CODEC_HDMI=m



config SND_HDA_CODEC_CONEXANT

	tristate "Build Conexant HD-audio codec support"

	select SND_HDA_GENERIC
@@ -134,23 +119,9 @@ config SND_HDA_GENERIC 
comment "Set to Y if you want auto-loading the codec driver"

	depends on SND_HDA=y && SND_HDA_GENERIC=m



config SND_HDA_INTEL_HDMI_SILENT_STREAM

	bool "Enable Silent Stream always for HDMI"

	depends on SND_HDA_INTEL

	help

	  Say Y to enable HD-Audio Keep Alive (KAE) aka Silent Stream

	  for HDMI on hardware that supports the feature.



	  When enabled, the HDMI/DisplayPort codec will continue to provide

	  a continuous clock and a valid but silent data stream to

	  any connected external receiver. This allows to avoid gaps

	  at start of playback. Many receivers require multiple seconds

	  to start playing audio after the clock has been stopped.

	  This feature can impact power consumption as resources

	  are kept reserved both at transmitter and receiver.



source "sound/hda/codecs/realtek/Kconfig"

source "sound/hda/codecs/cirrus/Kconfig"

source "sound/hda/codecs/hdmi/Kconfig"

source "sound/hda/codecs/side-codecs/Kconfig"



endif # SND_HDA

sound/hda/codecs/hdmi/Kconfig

0 → 100644
+68 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only



config SND_HDA_CODEC_HDMI

	tristate "Generic HDMI/DisplayPort HD-audio codec support"

	select SND_DYNAMIC_MINORS

	select SND_PCM_ELD

	help

	  Say Y or M here to include Generic HDMI and DisplayPort HD-audio

	  codec support.



	  Note that this option mandatorily enables CONFIG_SND_DYNAMIC_MINORS

	  to assure the multiple streams for DP-MST support.



config SND_HDA_CODEC_HDMI_SIMPLE

	tristate "Simple HDMI/DisplayPort HD-audio codec support"

	help

	  Say Y or M here to include Simple HDMI and DisplayPort HD-audio

	  codec support for VIA and other codecs.



config SND_HDA_CODEC_HDMI_INTEL

	tristate "Intel HDMI/DisplayPort HD-audio codec support"

	select SND_HDA_CODEC_HDMI

	help

	  Say Y or M here to include Intel graphics HDMI and DisplayPort

	  HD-audio codec support.



config SND_HDA_INTEL_HDMI_SILENT_STREAM

	bool "Enable Silent Stream always for HDMI"

	depends on SND_HDA_CODEC_HDMI_INTEL

	help

	  Say Y to enable HD-Audio Keep Alive (KAE) aka Silent Stream

	  for HDMI on hardware that supports the feature.



	  When enabled, the HDMI/DisplayPort codec will continue to provide

	  a continuous clock and a valid but silent data stream to

	  any connected external receiver. This allows to avoid gaps

	  at start of playback. Many receivers require multiple seconds

	  to start playing audio after the clock has been stopped.

	  This feature can impact power consumption as resources

	  are kept reserved both at transmitter and receiver.



config SND_HDA_CODEC_HDMI_ATI

	tristate "AMD/ATI HDMI/DisplayPort HD-audio codec support"

	select SND_HDA_CODEC_HDMI

	help

	  Say Y or M here to include AMD/ATI graphics HDMI and DisplayPort

	  HD-audio codec support.



config SND_HDA_CODEC_HDMI_NVIDIA

	tristate "Nvidia HDMI/DisplayPort HD-audio codec support"

	select SND_HDA_CODEC_HDMI

	help

	  Say Y or M here to include HDMI and DisplayPort HD-audio codec

	  support for the recent Nvidia graphics cards.



config SND_HDA_CODEC_HDMI_NVIDIA_MCP

	tristate "Legacy Nvidia HDMI/DisplayPort HD-audio codec support"

	select SND_HDA_CODEC_HDMI_SIMPLE

	help

	  Say Y or M here to include HDMI and DisplayPort HD-audio codec

	  support for the legacy Nvidia graphics like MCP73, MCP67, MCP77/78.



config SND_HDA_CODEC_HDMI_TEGRA

	tristate "Nvidia Tegra HDMI/DisplayPort HD-audio codec support"

	select SND_HDA_CODEC_HDMI

	help

	  Say Y or M here to include HDMI and DisplayPort HD-audio codec

	  support for Nvidia Tegra.

sound/hda/codecs/hdmi/Makefile

+12 −0
Original line number Diff line number Diff line
@@ -2,5 +2,17 @@ 
subdir-ccflags-y += -I$(src)/../../common



snd-hda-codec-hdmi-y :=		hdmi.o eld.o

snd-hda-codec-simplehdmi-y :=	simplehdmi.o

snd-hda-codec-intelhdmi-y :=	intelhdmi.o

snd-hda-codec-atihdmi-y :=	atihdmi.o

snd-hda-codec-nvhdmi-y :=	nvhdmi.o

snd-hda-codec-nvhdmi-mcp-y :=	nvhdmi-mcp.o

snd-hda-codec-tegrahdmi-y :=	tegrahdmi.o



obj-$(CONFIG_SND_HDA_CODEC_HDMI) += snd-hda-codec-hdmi.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_SIMPLE) += snd-hda-codec-simplehdmi.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_INTEL) += snd-hda-codec-intelhdmi.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_ATI) += snd-hda-codec-atihdmi.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_NVIDIA) += snd-hda-codec-nvhdmi.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_NVIDIA_MCP) += snd-hda-codec-nvhdmi-mcp.o

obj-$(CONFIG_SND_HDA_CODEC_HDMI_TEGRA) += snd-hda-codec-tegrahdmi.o

sound/hda/codecs/hdmi/atihdmi.c

0 → 100644
+606 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * ATI/AMD codec support

 */



#include <linux/init.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/unaligned.h>

#include <sound/core.h>

#include <sound/tlv.h>

#include <sound/hdaudio.h>

#include <sound/hda_codec.h>

#include "hda_local.h"

#include "hdmi_local.h"



#define is_amdhdmi_rev3_or_later(codec) \

	((codec)->core.vendor_id == 0x1002aa01 && \

	 ((codec)->core.revision_id & 0xff00) >= 0x0300)

#define has_amd_full_remap_support(codec) is_amdhdmi_rev3_or_later(codec)



/* ATI/AMD specific HDA pin verbs, see the AMD HDA Verbs specification */

#define ATI_VERB_SET_CHANNEL_ALLOCATION	0x771

#define ATI_VERB_SET_DOWNMIX_INFO	0x772

#define ATI_VERB_SET_MULTICHANNEL_01	0x777

#define ATI_VERB_SET_MULTICHANNEL_23	0x778

#define ATI_VERB_SET_MULTICHANNEL_45	0x779

#define ATI_VERB_SET_MULTICHANNEL_67	0x77a

#define ATI_VERB_SET_HBR_CONTROL	0x77c

#define ATI_VERB_SET_MULTICHANNEL_1	0x785

#define ATI_VERB_SET_MULTICHANNEL_3	0x786

#define ATI_VERB_SET_MULTICHANNEL_5	0x787

#define ATI_VERB_SET_MULTICHANNEL_7	0x788

#define ATI_VERB_SET_MULTICHANNEL_MODE	0x789

#define ATI_VERB_GET_CHANNEL_ALLOCATION	0xf71

#define ATI_VERB_GET_DOWNMIX_INFO	0xf72

#define ATI_VERB_GET_MULTICHANNEL_01	0xf77

#define ATI_VERB_GET_MULTICHANNEL_23	0xf78

#define ATI_VERB_GET_MULTICHANNEL_45	0xf79

#define ATI_VERB_GET_MULTICHANNEL_67	0xf7a

#define ATI_VERB_GET_HBR_CONTROL	0xf7c

#define ATI_VERB_GET_MULTICHANNEL_1	0xf85

#define ATI_VERB_GET_MULTICHANNEL_3	0xf86

#define ATI_VERB_GET_MULTICHANNEL_5	0xf87

#define ATI_VERB_GET_MULTICHANNEL_7	0xf88

#define ATI_VERB_GET_MULTICHANNEL_MODE	0xf89



/* AMD specific HDA cvt verbs */

#define ATI_VERB_SET_RAMP_RATE		0x770

#define ATI_VERB_GET_RAMP_RATE		0xf70



#define ATI_OUT_ENABLE 0x1



#define ATI_MULTICHANNEL_MODE_PAIRED	0

#define ATI_MULTICHANNEL_MODE_SINGLE	1



#define ATI_HBR_CAPABLE 0x01

#define ATI_HBR_ENABLE 0x10



/* ATI/AMD specific ELD emulation */



#define ATI_VERB_SET_AUDIO_DESCRIPTOR	0x776

#define ATI_VERB_SET_SINK_INFO_INDEX	0x780

#define ATI_VERB_GET_SPEAKER_ALLOCATION	0xf70

#define ATI_VERB_GET_AUDIO_DESCRIPTOR	0xf76

#define ATI_VERB_GET_AUDIO_VIDEO_DELAY	0xf7b

#define ATI_VERB_GET_SINK_INFO_INDEX	0xf80

#define ATI_VERB_GET_SINK_INFO_DATA	0xf81



#define ATI_SPKALLOC_SPKALLOC		0x007f

#define ATI_SPKALLOC_TYPE_HDMI		0x0100

#define ATI_SPKALLOC_TYPE_DISPLAYPORT	0x0200



/* first three bytes are just standard SAD */

#define ATI_AUDIODESC_CHANNELS		0x00000007

#define ATI_AUDIODESC_RATES		0x0000ff00

#define ATI_AUDIODESC_LPCM_STEREO_RATES	0xff000000



/* in standard HDMI VSDB format */

#define ATI_DELAY_VIDEO_LATENCY		0x000000ff

#define ATI_DELAY_AUDIO_LATENCY		0x0000ff00



enum ati_sink_info_idx {

	ATI_INFO_IDX_MANUFACTURER_ID	= 0,

	ATI_INFO_IDX_PRODUCT_ID		= 1,

	ATI_INFO_IDX_SINK_DESC_LEN	= 2,

	ATI_INFO_IDX_PORT_ID_LOW	= 3,

	ATI_INFO_IDX_PORT_ID_HIGH	= 4,

	ATI_INFO_IDX_SINK_DESC_FIRST	= 5,

	ATI_INFO_IDX_SINK_DESC_LAST	= 22, /* max len 18 bytes */

};



static int get_eld_ati(struct hda_codec *codec, hda_nid_t nid,

		       unsigned char *buf, int *eld_size, bool rev3_or_later)

{

	int spkalloc, ati_sad, aud_synch;

	int sink_desc_len = 0;

	int pos, i;



	/* ATI/AMD does not have ELD, emulate it */



	spkalloc = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SPEAKER_ALLOCATION, 0);



	if (spkalloc <= 0) {

		codec_info(codec, "HDMI ATI/AMD: no speaker allocation for ELD\n");

		return -EINVAL;

	}



	memset(buf, 0, ELD_FIXED_BYTES + ELD_MAX_MNL + ELD_MAX_SAD * 3);



	/* version */

	buf[0] = ELD_VER_CEA_861D << 3;



	/* speaker allocation from EDID */

	buf[7] = spkalloc & ATI_SPKALLOC_SPKALLOC;



	/* is DisplayPort? */

	if (spkalloc & ATI_SPKALLOC_TYPE_DISPLAYPORT)

		buf[5] |= 0x04;



	pos = ELD_FIXED_BYTES;



	if (rev3_or_later) {

		int sink_info;



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_LOW);

		sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

		put_unaligned_le32(sink_info, buf + 8);



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_HIGH);

		sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

		put_unaligned_le32(sink_info, buf + 12);



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_MANUFACTURER_ID);

		sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

		put_unaligned_le16(sink_info, buf + 16);



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PRODUCT_ID);

		sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

		put_unaligned_le16(sink_info, buf + 18);



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_LEN);

		sink_desc_len = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);



		if (sink_desc_len > ELD_MAX_MNL) {

			codec_info(codec, "HDMI ATI/AMD: Truncating HDMI sink description with length %d\n",

				   sink_desc_len);

			sink_desc_len = ELD_MAX_MNL;

		}



		buf[4] |= sink_desc_len;



		for (i = 0; i < sink_desc_len; i++) {

			snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_FIRST + i);

			buf[pos++] = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

		}

	}



	for (i = AUDIO_CODING_TYPE_LPCM; i <= AUDIO_CODING_TYPE_WMAPRO; i++) {

		if (i == AUDIO_CODING_TYPE_SACD || i == AUDIO_CODING_TYPE_DST)

			continue; /* not handled by ATI/AMD */



		snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_AUDIO_DESCRIPTOR, i << 3);

		ati_sad = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_DESCRIPTOR, 0);



		if (ati_sad <= 0)

			continue;



		if (ati_sad & ATI_AUDIODESC_RATES) {

			/* format is supported, copy SAD as-is */

			buf[pos++] = (ati_sad & 0x0000ff) >> 0;

			buf[pos++] = (ati_sad & 0x00ff00) >> 8;

			buf[pos++] = (ati_sad & 0xff0000) >> 16;

		}



		if (i == AUDIO_CODING_TYPE_LPCM

		    && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES)

		    && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES) >> 16 != (ati_sad & ATI_AUDIODESC_RATES)) {

			/* for PCM there is a separate stereo rate mask */

			buf[pos++] = ((ati_sad & 0x000000ff) & ~ATI_AUDIODESC_CHANNELS) | 0x1;

			/* rates from the extra byte */

			buf[pos++] = (ati_sad & 0xff000000) >> 24;

			buf[pos++] = (ati_sad & 0x00ff0000) >> 16;

		}

	}



	if (pos == ELD_FIXED_BYTES + sink_desc_len) {

		codec_info(codec, "HDMI ATI/AMD: no audio descriptors for ELD\n");

		return -EINVAL;

	}



	/*

	 * HDMI VSDB latency format:

	 * separately for both audio and video:

	 *  0          field not valid or unknown latency

	 *  [1..251]   msecs = (x-1)*2  (max 500ms with x = 251 = 0xfb)

	 *  255        audio/video not supported

	 *

	 * HDA latency format:

	 * single value indicating video latency relative to audio:

	 *  0          unknown or 0ms

	 *  [1..250]   msecs = x*2  (max 500ms with x = 250 = 0xfa)

	 *  [251..255] reserved

	 */

	aud_synch = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_VIDEO_DELAY, 0);

	if ((aud_synch & ATI_DELAY_VIDEO_LATENCY) && (aud_synch & ATI_DELAY_AUDIO_LATENCY)) {

		int video_latency_hdmi = (aud_synch & ATI_DELAY_VIDEO_LATENCY);

		int audio_latency_hdmi = (aud_synch & ATI_DELAY_AUDIO_LATENCY) >> 8;



		if (video_latency_hdmi <= 0xfb && audio_latency_hdmi <= 0xfb &&

		    video_latency_hdmi > audio_latency_hdmi)

			buf[6] = video_latency_hdmi - audio_latency_hdmi;

		/* else unknown/invalid or 0ms or video ahead of audio, so use zero */

	}



	/* SAD count */

	buf[5] |= ((pos - ELD_FIXED_BYTES - sink_desc_len) / 3) << 4;



	/* Baseline ELD block length is 4-byte aligned */

	pos = round_up(pos, 4);



	/* Baseline ELD length (4-byte header is not counted in) */

	buf[2] = (pos - 4) / 4;



	*eld_size = pos;



	return 0;

}



static int atihdmi_pin_get_eld(struct hda_codec *codec, hda_nid_t nid,

			       int dev_id, unsigned char *buf, int *eld_size)

{

	WARN_ON(dev_id != 0);

	/* call hda_eld.c ATI/AMD-specific function */

	return get_eld_ati(codec, nid, buf, eld_size,

			   is_amdhdmi_rev3_or_later(codec));

}



static void atihdmi_pin_setup_infoframe(struct hda_codec *codec,

					hda_nid_t pin_nid, int dev_id, int ca,

					int active_channels, int conn_type)

{

	WARN_ON(dev_id != 0);

	snd_hda_codec_write(codec, pin_nid, 0, ATI_VERB_SET_CHANNEL_ALLOCATION, ca);

}



static int atihdmi_paired_swap_fc_lfe(int pos)

{

	/*

	 * ATI/AMD have automatic FC/LFE swap built-in

	 * when in pairwise mapping mode.

	 */



	switch (pos) {

	/* see channel_allocations[].speakers[] */

	case 2: return 3;

	case 3: return 2;

	default: return pos;

	}

}



static int atihdmi_paired_chmap_validate(struct hdac_chmap *chmap,

			int ca, int chs, unsigned char *map)

{

	struct hdac_cea_channel_speaker_allocation *cap;

	int i, j;



	/* check that only channel pairs need to be remapped on old pre-rev3 ATI/AMD */



	cap = snd_hdac_get_ch_alloc_from_ca(ca);

	for (i = 0; i < chs; ++i) {

		int mask = snd_hdac_chmap_to_spk_mask(map[i]);

		bool ok = false;

		bool companion_ok = false;



		if (!mask)

			continue;



		for (j = 0 + i % 2; j < 8; j += 2) {

			int chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j);



			if (cap->speakers[chan_idx] == mask) {

				/* channel is in a supported position */

				ok = true;



				if (i % 2 == 0 && i + 1 < chs) {

					/* even channel, check the odd companion */

					int comp_chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j + 1);

					int comp_mask_req = snd_hdac_chmap_to_spk_mask(map[i+1]);

					int comp_mask_act = cap->speakers[comp_chan_idx];



					if (comp_mask_req == comp_mask_act)

						companion_ok = true;

					else

						return -EINVAL;

				}

				break;

			}

		}



		if (!ok)

			return -EINVAL;



		if (companion_ok)

			i++; /* companion channel already checked */

	}



	return 0;

}



static int atihdmi_pin_set_slot_channel(struct hdac_device *hdac,

		hda_nid_t pin_nid, int hdmi_slot, int stream_channel)

{

	struct hda_codec *codec = hdac_to_hda_codec(hdac);

	int verb;

	int ati_channel_setup = 0;



	if (hdmi_slot > 7)

		return -EINVAL;



	if (!has_amd_full_remap_support(codec)) {

		hdmi_slot = atihdmi_paired_swap_fc_lfe(hdmi_slot);



		/* In case this is an odd slot but without stream channel, do not

		 * disable the slot since the corresponding even slot could have a

		 * channel. In case neither have a channel, the slot pair will be

		 * disabled when this function is called for the even slot.

		 */

		if (hdmi_slot % 2 != 0 && stream_channel == 0xf)

			return 0;



		hdmi_slot -= hdmi_slot % 2;



		if (stream_channel != 0xf)

			stream_channel -= stream_channel % 2;

	}



	verb = ATI_VERB_SET_MULTICHANNEL_01 + hdmi_slot/2 + (hdmi_slot % 2) * 0x00e;



	/* ati_channel_setup format: [7..4] = stream_channel_id, [1] = mute, [0] = enable */



	if (stream_channel != 0xf)

		ati_channel_setup = (stream_channel << 4) | ATI_OUT_ENABLE;



	return snd_hda_codec_write(codec, pin_nid, 0, verb, ati_channel_setup);

}



static int atihdmi_pin_get_slot_channel(struct hdac_device *hdac,

				hda_nid_t pin_nid, int asp_slot)

{

	struct hda_codec *codec = hdac_to_hda_codec(hdac);

	bool was_odd = false;

	int ati_asp_slot = asp_slot;

	int verb;

	int ati_channel_setup;



	if (asp_slot > 7)

		return -EINVAL;



	if (!has_amd_full_remap_support(codec)) {

		ati_asp_slot = atihdmi_paired_swap_fc_lfe(asp_slot);

		if (ati_asp_slot % 2 != 0) {

			ati_asp_slot -= 1;

			was_odd = true;

		}

	}



	verb = ATI_VERB_GET_MULTICHANNEL_01 + ati_asp_slot/2 + (ati_asp_slot % 2) * 0x00e;



	ati_channel_setup = snd_hda_codec_read(codec, pin_nid, 0, verb, 0);



	if (!(ati_channel_setup & ATI_OUT_ENABLE))

		return 0xf;



	return ((ati_channel_setup & 0xf0) >> 4) + !!was_odd;

}



static int atihdmi_paired_chmap_cea_alloc_validate_get_type(

		struct hdac_chmap *chmap,

		struct hdac_cea_channel_speaker_allocation *cap,

		int channels)

{

	int c;



	/*

	 * Pre-rev3 ATI/AMD codecs operate in a paired channel mode, so

	 * we need to take that into account (a single channel may take 2

	 * channel slots if we need to carry a silent channel next to it).

	 * On Rev3+ AMD codecs this function is not used.

	 */

	int chanpairs = 0;



	/* We only produce even-numbered channel count TLVs */

	if ((channels % 2) != 0)

		return -1;



	for (c = 0; c < 7; c += 2) {

		if (cap->speakers[c] || cap->speakers[c+1])

			chanpairs++;

	}



	if (chanpairs * 2 != channels)

		return -1;



	return SNDRV_CTL_TLVT_CHMAP_PAIRED;

}



static void atihdmi_paired_cea_alloc_to_tlv_chmap(struct hdac_chmap *hchmap,

		struct hdac_cea_channel_speaker_allocation *cap,

		unsigned int *chmap, int channels)

{

	/* produce paired maps for pre-rev3 ATI/AMD codecs */

	int count = 0;

	int c;



	for (c = 7; c >= 0; c--) {

		int chan = 7 - atihdmi_paired_swap_fc_lfe(7 - c);

		int spk = cap->speakers[chan];



		if (!spk) {

			/* add N/A channel if the companion channel is occupied */

			if (cap->speakers[chan + (chan % 2 ? -1 : 1)])

				chmap[count++] = SNDRV_CHMAP_NA;



			continue;

		}



		chmap[count++] = snd_hdac_spk_to_chmap(spk);

	}



	WARN_ON(count != channels);

}



static int atihdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,

				 int dev_id, bool hbr)

{

	int hbr_ctl, hbr_ctl_new;



	WARN_ON(dev_id != 0);



	hbr_ctl = snd_hda_codec_read(codec, pin_nid, 0, ATI_VERB_GET_HBR_CONTROL, 0);

	if (hbr_ctl >= 0 && (hbr_ctl & ATI_HBR_CAPABLE)) {

		if (hbr)

			hbr_ctl_new = hbr_ctl | ATI_HBR_ENABLE;

		else

			hbr_ctl_new = hbr_ctl & ~ATI_HBR_ENABLE;



		codec_dbg(codec,

			  "%s: NID=0x%x, %shbr-ctl=0x%x\n",

			  __func__,

			  pin_nid,

			  hbr_ctl == hbr_ctl_new ? "" : "new-",

			  hbr_ctl_new);



		if (hbr_ctl != hbr_ctl_new)

			snd_hda_codec_write(codec, pin_nid, 0,

						ATI_VERB_SET_HBR_CONTROL,

						hbr_ctl_new);



	} else if (hbr)

		return -EINVAL;



	return 0;

}



static int atihdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,

				hda_nid_t pin_nid, int dev_id,

				u32 stream_tag, int format)

{

	if (is_amdhdmi_rev3_or_later(codec)) {

		int ramp_rate = 180; /* default as per AMD spec */

		/* disable ramp-up/down for non-pcm as per AMD spec */

		if (format & AC_FMT_TYPE_NON_PCM)

			ramp_rate = 0;



		snd_hda_codec_write(codec, cvt_nid, 0, ATI_VERB_SET_RAMP_RATE, ramp_rate);

	}



	return snd_hda_hdmi_setup_stream(codec, cvt_nid, pin_nid, dev_id,

					 stream_tag, format);

}





static int atihdmi_init(struct hda_codec *codec)

{

	struct hdmi_spec *spec = codec->spec;

	int pin_idx, err;



	err = snd_hda_hdmi_generic_init(codec);



	if (err)

		return err;



	for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {

		struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);



		/* make sure downmix information in infoframe is zero */

		snd_hda_codec_write(codec, per_pin->pin_nid, 0, ATI_VERB_SET_DOWNMIX_INFO, 0);



		/* enable channel-wise remap mode if supported */

		if (has_amd_full_remap_support(codec))

			snd_hda_codec_write(codec, per_pin->pin_nid, 0,

					    ATI_VERB_SET_MULTICHANNEL_MODE,

					    ATI_MULTICHANNEL_MODE_SINGLE);

	}

	codec->auto_runtime_pm = 1;



	return 0;

}



/* map from pin NID to port; port is 0-based */

/* for AMD: assume widget NID starting from 3, with step 2 (3, 5, 7, ...) */

static int atihdmi_pin2port(void *audio_ptr, int pin_nid)

{

	return pin_nid / 2 - 1;

}



/* reverse-map from port to pin NID: see above */

static int atihdmi_port2pin(struct hda_codec *codec, int port)

{

	return port * 2 + 3;

}



static const struct drm_audio_component_audio_ops atihdmi_audio_ops = {

	.pin2port = atihdmi_pin2port,

	.pin_eld_notify = snd_hda_hdmi_acomp_pin_eld_notify,

	.master_bind = snd_hda_hdmi_acomp_master_bind,

	.master_unbind = snd_hda_hdmi_acomp_master_unbind,

};



static int patch_atihdmi(struct hda_codec *codec)

{

	struct hdmi_spec *spec;

	struct hdmi_spec_per_cvt *per_cvt;

	int err, cvt_idx;



	err = patch_generic_hdmi(codec);



	if (err)

		return err;



	codec->patch_ops.init = atihdmi_init;



	spec = codec->spec;



	spec->static_pcm_mapping = true;



	spec->ops.pin_get_eld = atihdmi_pin_get_eld;

	spec->ops.pin_setup_infoframe = atihdmi_pin_setup_infoframe;

	spec->ops.pin_hbr_setup = atihdmi_pin_hbr_setup;

	spec->ops.setup_stream = atihdmi_setup_stream;



	spec->chmap.ops.pin_get_slot_channel = atihdmi_pin_get_slot_channel;

	spec->chmap.ops.pin_set_slot_channel = atihdmi_pin_set_slot_channel;



	if (!has_amd_full_remap_support(codec)) {

		/* override to ATI/AMD-specific versions with pairwise mapping */

		spec->chmap.ops.chmap_cea_alloc_validate_get_type =

			atihdmi_paired_chmap_cea_alloc_validate_get_type;

		spec->chmap.ops.cea_alloc_to_tlv_chmap =

				atihdmi_paired_cea_alloc_to_tlv_chmap;

		spec->chmap.ops.chmap_validate = atihdmi_paired_chmap_validate;

	}



	/* ATI/AMD converters do not advertise all of their capabilities */

	for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {

		per_cvt = get_cvt(spec, cvt_idx);

		per_cvt->channels_max = max(per_cvt->channels_max, 8u);

		per_cvt->rates |= SUPPORTED_RATES;

		per_cvt->formats |= SUPPORTED_FORMATS;

		per_cvt->maxbps = max(per_cvt->maxbps, 24u);

	}



	spec->chmap.channels_max = max(spec->chmap.channels_max, 8u);



	/* AMD GPUs have neither EPSS nor CLKSTOP bits, hence preventing

	 * the link-down as is.  Tell the core to allow it.

	 */

	codec->link_down_at_suspend = 1;



	snd_hda_hdmi_acomp_init(codec, &atihdmi_audio_ops, atihdmi_port2pin);



	return 0;

}



/*

 * patch entries

 */

static const struct hda_device_id snd_hda_id_atihdmi[] = {

HDA_CODEC_ENTRY(0x1002793c, "RS600 HDMI",	patch_atihdmi),

HDA_CODEC_ENTRY(0x10027919, "RS600 HDMI",	patch_atihdmi),

HDA_CODEC_ENTRY(0x1002791a, "RS690/780 HDMI",	patch_atihdmi),

HDA_CODEC_ENTRY(0x1002aa01, "R6xx HDMI",	patch_atihdmi),

{} /* terminator */

};

MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_atihdmi);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("AMD/ATI HDMI HD-audio codec");

MODULE_IMPORT_NS("SND_HDA_CODEC_HDMI");



static struct hda_codec_driver atihdmi_driver = {

	.id = snd_hda_id_atihdmi,

};



module_hda_codec_driver(atihdmi_driver);

sound/hda/codecs/hdmi/eld.c

+0 −172

File changed.

Preview size limit exceeded, changes collapsed.