2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* patch_hdmi.c - routines for HDMI/DisplayPort codecs
|
|
|
|
*
|
|
|
|
* Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
|
2010-09-07 17:27:25 +07:00
|
|
|
* Copyright (c) 2006 ATI Technologies Inc.
|
|
|
|
* Copyright (c) 2008 NVIDIA Corp. All rights reserved.
|
|
|
|
* Copyright (c) 2008 Wei Ni <wni@nvidia.com>
|
2013-10-25 01:10:35 +07:00
|
|
|
* Copyright (c) 2013 Anssi Hannula <anssi.hannula@iki.fi>
|
2010-03-08 09:44:23 +07:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Wu Fengguang <wfg@linux.intel.com>
|
|
|
|
*
|
|
|
|
* Maintained by:
|
|
|
|
* Wu Fengguang <wfg@linux.intel.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
* for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
2011-07-16 00:13:37 +07:00
|
|
|
#include <linux/module.h>
|
2010-09-07 17:27:25 +07:00
|
|
|
#include <sound/core.h>
|
2011-05-19 16:46:03 +07:00
|
|
|
#include <sound/jack.h>
|
2012-09-06 09:02:37 +07:00
|
|
|
#include <sound/asoundef.h>
|
2012-07-31 16:36:00 +07:00
|
|
|
#include <sound/tlv.h>
|
2015-08-19 15:48:58 +07:00
|
|
|
#include <sound/hdaudio.h>
|
|
|
|
#include <sound/hda_i915.h>
|
2010-09-07 17:27:25 +07:00
|
|
|
#include "hda_codec.h"
|
|
|
|
#include "hda_local.h"
|
2011-10-28 03:12:46 +07:00
|
|
|
#include "hda_jack.h"
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2011-01-12 00:11:04 +07:00
|
|
|
static bool static_hdmi_pcm;
|
|
|
|
module_param(static_hdmi_pcm, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info");
|
|
|
|
|
2015-03-03 16:07:24 +07:00
|
|
|
#define is_haswell(codec) ((codec)->core.vendor_id == 0x80862807)
|
|
|
|
#define is_broadwell(codec) ((codec)->core.vendor_id == 0x80862808)
|
|
|
|
#define is_skylake(codec) ((codec)->core.vendor_id == 0x80862809)
|
2014-12-16 12:17:34 +07:00
|
|
|
#define is_haswell_plus(codec) (is_haswell(codec) || is_broadwell(codec) \
|
|
|
|
|| is_skylake(codec))
|
2014-01-09 03:55:32 +07:00
|
|
|
|
2015-03-03 16:07:24 +07:00
|
|
|
#define is_valleyview(codec) ((codec)->core.vendor_id == 0x80862882)
|
|
|
|
#define is_cherryview(codec) ((codec)->core.vendor_id == 0x80862883)
|
2014-08-19 15:20:12 +07:00
|
|
|
#define is_valleyview_plus(codec) (is_valleyview(codec) || is_cherryview(codec))
|
2013-09-05 03:36:57 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_spec_per_cvt {
|
|
|
|
hda_nid_t cvt_nid;
|
|
|
|
int assigned;
|
|
|
|
unsigned int channels_min;
|
|
|
|
unsigned int channels_max;
|
|
|
|
u32 rates;
|
|
|
|
u64 formats;
|
|
|
|
unsigned int maxbps;
|
|
|
|
};
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda - Remove limit of widget connections
Currently we set the max number of connections to be 32, but there
seems codec that gives longer connection lists like AD1988, and we see
errors in proc output and else. (Though, in the case of AD1988, it's
a list of all codecs connected to a single vendor widget, so this must
be something fishy, but it's still valid from the h/w design POV.)
This patch tries to remove this restriction. For efficiency, we still
use the fixed size array in the parser, but takes a dynamic array when
the size is reported to be greater than that.
Now the fixed array size is found only in patch_hdmi.c, but it should
be fine, as the codec itself can't support so many pins.
Reported-by: Raymond Yau <superquad.vortex2@gmail.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-02-08 00:18:19 +07:00
|
|
|
/* max. connections to a widget */
|
|
|
|
#define HDA_MAX_CONNECTIONS 32
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_spec_per_pin {
|
|
|
|
hda_nid_t pin_nid;
|
|
|
|
int num_mux_nids;
|
|
|
|
hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
|
2014-03-20 12:01:06 +07:00
|
|
|
int mux_idx;
|
ALSA: hda - hdmi: Fix programmed active channel count
Currently the converter channel count is set to the number of actual
input channels. The audio infoframe channel count field is set
similarly.
However, sometimes the used channel map does not map all input channels
to outputs. Notably, 3 channel modes (e.g. 2.1) require a dummy input
channel so there are 4 input channels. According to the HDA
specification, converter channel count should be programmed according to
the number of _active_ channels.
On Intel HDMI codecs (but not on NVIDIA), setting the converter channel
to a higher value than there are actually mapped channels to HDMI slots
will cause no audio to be output at all.
Note that the effects of this issue are currently partially masked by
other bugs that prevent the driver from actually unmapping channels in
certain cases. For example, if a 4 channel stream is first created and
prepared, it gets a FL,FR,RL,RR mapping (ALSA->HDMI slot mapping 0->0,
1->1, 2->4, 3->5). If one thereafter assigns a FR,FL,FC mapping to it,
the driver will remap 2->3 but fail to unmap 2->4 and 3->5, so there are
still 4 active channels and the issue will not trigger in this case.
These bugs will be fixed separately.
Fix the channel counts in the converter channel count field and in the
audio infoframe channel count field to match the actual number of active
channels.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:40 +07:00
|
|
|
hda_nid_t cvt_nid;
|
2011-11-16 15:29:47 +07:00
|
|
|
|
|
|
|
struct hda_codec *codec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_eld sink_eld;
|
2013-10-17 23:21:12 +07:00
|
|
|
struct mutex lock;
|
2011-11-16 15:29:47 +07:00
|
|
|
struct delayed_work work;
|
2013-02-19 22:11:26 +07:00
|
|
|
struct snd_kcontrol *eld_ctl;
|
2011-11-19 05:59:32 +07:00
|
|
|
int repoll_count;
|
2013-09-02 17:33:02 +07:00
|
|
|
bool setup; /* the stream has been set up by prepare callback */
|
|
|
|
int channels; /* current number of channels */
|
2012-09-06 22:42:08 +07:00
|
|
|
bool non_pcm;
|
2012-07-31 16:36:00 +07:00
|
|
|
bool chmap_set; /* channel-map override by ALSA API? */
|
|
|
|
unsigned char chmap[8]; /* ALSA API channel-map */
|
2015-05-27 18:45:45 +07:00
|
|
|
#ifdef CONFIG_SND_PROC_FS
|
2013-10-17 23:21:12 +07:00
|
|
|
struct snd_info_entry *proc_entry;
|
|
|
|
#endif
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
};
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
struct cea_channel_speaker_allocation;
|
|
|
|
|
|
|
|
/* operations used by generic code that can be overridden by patches */
|
|
|
|
struct hdmi_ops {
|
|
|
|
int (*pin_get_eld)(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
unsigned char *buf, int *eld_size);
|
|
|
|
|
|
|
|
/* get and set channel assigned to each HDMI ASP (audio sample packet) slot */
|
|
|
|
int (*pin_get_slot_channel)(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int asp_slot);
|
|
|
|
int (*pin_set_slot_channel)(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int asp_slot, int channel);
|
|
|
|
|
|
|
|
void (*pin_setup_infoframe)(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int ca, int active_channels, int conn_type);
|
|
|
|
|
|
|
|
/* enable/disable HBR (HD passthrough) */
|
|
|
|
int (*pin_hbr_setup)(struct hda_codec *codec, hda_nid_t pin_nid, bool hbr);
|
|
|
|
|
|
|
|
int (*setup_stream)(struct hda_codec *codec, hda_nid_t cvt_nid,
|
|
|
|
hda_nid_t pin_nid, u32 stream_tag, int format);
|
|
|
|
|
|
|
|
/* Helpers for producing the channel map TLVs. These can be overridden
|
|
|
|
* for devices that have non-standard mapping requirements. */
|
|
|
|
int (*chmap_cea_alloc_validate_get_type)(struct cea_channel_speaker_allocation *cap,
|
|
|
|
int channels);
|
|
|
|
void (*cea_alloc_to_tlv_chmap)(struct cea_channel_speaker_allocation *cap,
|
|
|
|
unsigned int *chmap, int channels);
|
|
|
|
|
|
|
|
/* check that the user-given chmap is supported */
|
|
|
|
int (*chmap_validate)(int ca, int channels, unsigned char *chmap);
|
|
|
|
};
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_spec {
|
|
|
|
int num_cvts;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct snd_array cvts; /* struct hdmi_spec_per_cvt */
|
|
|
|
hda_nid_t cvt_nids[4]; /* only for haswell fix */
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int num_pins;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct snd_array pins; /* struct hdmi_spec_per_pin */
|
2015-02-27 23:43:19 +07:00
|
|
|
struct hda_pcm *pcm_rec[16];
|
2012-07-31 16:36:00 +07:00
|
|
|
unsigned int channels_max; /* max over all cvts */
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2013-02-19 22:11:25 +07:00
|
|
|
struct hdmi_eld temp_eld;
|
2013-10-25 01:10:34 +07:00
|
|
|
struct hdmi_ops ops;
|
2014-01-31 01:52:16 +07:00
|
|
|
|
|
|
|
bool dyn_pin_out;
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
2013-10-25 01:10:35 +07:00
|
|
|
* Non-generic VIA/NVIDIA specific
|
2010-03-08 09:44:23 +07:00
|
|
|
*/
|
|
|
|
struct hda_multi_out multiout;
|
2012-06-15 19:34:42 +07:00
|
|
|
struct hda_pcm_stream pcm_playback;
|
2015-08-19 15:48:58 +07:00
|
|
|
|
|
|
|
/* i915/powerwell (Haswell+/Valleyview+) specific */
|
|
|
|
struct i915_audio_component_audio_ops i915_audio_ops;
|
2010-03-08 09:44:23 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct hdmi_audio_infoframe {
|
|
|
|
u8 type; /* 0x84 */
|
|
|
|
u8 ver; /* 0x01 */
|
|
|
|
u8 len; /* 0x0a */
|
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
u8 checksum;
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
u8 CC02_CT47; /* CC in bits 0:2, CT in 4:7 */
|
|
|
|
u8 SS01_SF24;
|
|
|
|
u8 CXT04;
|
|
|
|
u8 CA;
|
|
|
|
u8 LFEPBL01_LSV36_DM_INH7;
|
2010-09-21 13:25:49 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct dp_audio_infoframe {
|
|
|
|
u8 type; /* 0x84 */
|
|
|
|
u8 len; /* 0x1b */
|
|
|
|
u8 ver; /* 0x11 << 2 */
|
|
|
|
|
|
|
|
u8 CC02_CT47; /* match with HDMI infoframe from this on */
|
|
|
|
u8 SS01_SF24;
|
|
|
|
u8 CXT04;
|
|
|
|
u8 CA;
|
|
|
|
u8 LFEPBL01_LSV36_DM_INH7;
|
2010-03-08 09:44:23 +07:00
|
|
|
};
|
|
|
|
|
2011-02-11 18:17:30 +07:00
|
|
|
union audio_infoframe {
|
|
|
|
struct hdmi_audio_infoframe hdmi;
|
|
|
|
struct dp_audio_infoframe dp;
|
|
|
|
u8 bytes[0];
|
|
|
|
};
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
* CEA speaker placement:
|
|
|
|
*
|
|
|
|
* FLH FCH FRH
|
|
|
|
* FLW FL FLC FC FRC FR FRW
|
|
|
|
*
|
|
|
|
* LFE
|
|
|
|
* TC
|
|
|
|
*
|
|
|
|
* RL RLC RC RRC RR
|
|
|
|
*
|
|
|
|
* The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
|
|
|
|
* CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
|
|
|
|
*/
|
|
|
|
enum cea_speaker_placement {
|
|
|
|
FL = (1 << 0), /* Front Left */
|
|
|
|
FC = (1 << 1), /* Front Center */
|
|
|
|
FR = (1 << 2), /* Front Right */
|
|
|
|
FLC = (1 << 3), /* Front Left Center */
|
|
|
|
FRC = (1 << 4), /* Front Right Center */
|
|
|
|
RL = (1 << 5), /* Rear Left */
|
|
|
|
RC = (1 << 6), /* Rear Center */
|
|
|
|
RR = (1 << 7), /* Rear Right */
|
|
|
|
RLC = (1 << 8), /* Rear Left Center */
|
|
|
|
RRC = (1 << 9), /* Rear Right Center */
|
|
|
|
LFE = (1 << 10), /* Low Frequency Effect */
|
|
|
|
FLW = (1 << 11), /* Front Left Wide */
|
|
|
|
FRW = (1 << 12), /* Front Right Wide */
|
|
|
|
FLH = (1 << 13), /* Front Left High */
|
|
|
|
FCH = (1 << 14), /* Front Center High */
|
|
|
|
FRH = (1 << 15), /* Front Right High */
|
|
|
|
TC = (1 << 16), /* Top Center */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ELD SA bits in the CEA Speaker Allocation data block
|
|
|
|
*/
|
|
|
|
static int eld_speaker_allocation_bits[] = {
|
|
|
|
[0] = FL | FR,
|
|
|
|
[1] = LFE,
|
|
|
|
[2] = FC,
|
|
|
|
[3] = RL | RR,
|
|
|
|
[4] = RC,
|
|
|
|
[5] = FLC | FRC,
|
|
|
|
[6] = RLC | RRC,
|
|
|
|
/* the following are not defined in ELD yet */
|
|
|
|
[7] = FLW | FRW,
|
|
|
|
[8] = FLH | FRH,
|
|
|
|
[9] = TC,
|
|
|
|
[10] = FCH,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cea_channel_speaker_allocation {
|
|
|
|
int ca_index;
|
|
|
|
int speakers[8];
|
|
|
|
|
|
|
|
/* derived values, just for convenience */
|
|
|
|
int channels;
|
|
|
|
int spk_mask;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ALSA sequence is:
|
|
|
|
*
|
|
|
|
* surround40 surround41 surround50 surround51 surround71
|
|
|
|
* ch0 front left = = = =
|
|
|
|
* ch1 front right = = = =
|
|
|
|
* ch2 rear left = = = =
|
|
|
|
* ch3 rear right = = = =
|
|
|
|
* ch4 LFE center center center
|
|
|
|
* ch5 LFE LFE
|
|
|
|
* ch6 side left
|
|
|
|
* ch7 side right
|
|
|
|
*
|
|
|
|
* surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
|
|
|
|
*/
|
|
|
|
static int hdmi_channel_mapping[0x32][8] = {
|
|
|
|
/* stereo */
|
|
|
|
[0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
|
|
|
|
/* 2.1 */
|
|
|
|
[0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
|
|
|
|
/* Dolby Surround */
|
|
|
|
[0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
|
|
|
|
/* surround40 */
|
|
|
|
[0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
|
|
|
|
/* 4ch */
|
|
|
|
[0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
|
|
|
|
/* surround41 */
|
2010-09-21 13:44:51 +07:00
|
|
|
[0x09] = { 0x00, 0x11, 0x24, 0x35, 0x42, 0xf3, 0xf6, 0xf7 },
|
2010-03-08 09:44:23 +07:00
|
|
|
/* surround50 */
|
|
|
|
[0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
|
|
|
|
/* surround51 */
|
|
|
|
[0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
|
|
|
|
/* 7.1 */
|
|
|
|
[0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is an ordered list!
|
|
|
|
*
|
|
|
|
* The preceding ones have better chances to be selected by
|
2010-09-21 13:25:49 +07:00
|
|
|
* hdmi_channel_allocation().
|
2010-03-08 09:44:23 +07:00
|
|
|
*/
|
|
|
|
static struct cea_channel_speaker_allocation channel_allocations[] = {
|
|
|
|
/* channel: 7 6 5 4 3 2 1 0 */
|
|
|
|
{ .ca_index = 0x00, .speakers = { 0, 0, 0, 0, 0, 0, FR, FL } },
|
|
|
|
/* 2.1 */
|
|
|
|
{ .ca_index = 0x01, .speakers = { 0, 0, 0, 0, 0, LFE, FR, FL } },
|
|
|
|
/* Dolby Surround */
|
|
|
|
{ .ca_index = 0x02, .speakers = { 0, 0, 0, 0, FC, 0, FR, FL } },
|
|
|
|
/* surround40 */
|
|
|
|
{ .ca_index = 0x08, .speakers = { 0, 0, RR, RL, 0, 0, FR, FL } },
|
|
|
|
/* surround41 */
|
|
|
|
{ .ca_index = 0x09, .speakers = { 0, 0, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
/* surround50 */
|
|
|
|
{ .ca_index = 0x0a, .speakers = { 0, 0, RR, RL, FC, 0, FR, FL } },
|
|
|
|
/* surround51 */
|
|
|
|
{ .ca_index = 0x0b, .speakers = { 0, 0, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
/* 6.1 */
|
|
|
|
{ .ca_index = 0x0f, .speakers = { 0, RC, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
/* surround71 */
|
|
|
|
{ .ca_index = 0x13, .speakers = { RRC, RLC, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
|
|
|
|
{ .ca_index = 0x03, .speakers = { 0, 0, 0, 0, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x04, .speakers = { 0, 0, 0, RC, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x05, .speakers = { 0, 0, 0, RC, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x06, .speakers = { 0, 0, 0, RC, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x07, .speakers = { 0, 0, 0, RC, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x0c, .speakers = { 0, RC, RR, RL, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x0d, .speakers = { 0, RC, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x0e, .speakers = { 0, RC, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x10, .speakers = { RRC, RLC, RR, RL, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x11, .speakers = { RRC, RLC, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x12, .speakers = { RRC, RLC, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x14, .speakers = { FRC, FLC, 0, 0, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x15, .speakers = { FRC, FLC, 0, 0, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x16, .speakers = { FRC, FLC, 0, 0, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x17, .speakers = { FRC, FLC, 0, 0, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x18, .speakers = { FRC, FLC, 0, RC, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x19, .speakers = { FRC, FLC, 0, RC, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x1a, .speakers = { FRC, FLC, 0, RC, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x1b, .speakers = { FRC, FLC, 0, RC, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x1c, .speakers = { FRC, FLC, RR, RL, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x1d, .speakers = { FRC, FLC, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x1e, .speakers = { FRC, FLC, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x1f, .speakers = { FRC, FLC, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x20, .speakers = { 0, FCH, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x21, .speakers = { 0, FCH, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x22, .speakers = { TC, 0, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x23, .speakers = { TC, 0, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x24, .speakers = { FRH, FLH, RR, RL, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x25, .speakers = { FRH, FLH, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x26, .speakers = { FRW, FLW, RR, RL, 0, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x27, .speakers = { FRW, FLW, RR, RL, 0, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x28, .speakers = { TC, RC, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x29, .speakers = { TC, RC, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x2a, .speakers = { FCH, RC, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x2b, .speakers = { FCH, RC, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x2c, .speakers = { TC, FCH, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x2d, .speakers = { TC, FCH, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x2e, .speakers = { FRH, FLH, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x2f, .speakers = { FRH, FLH, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
{ .ca_index = 0x30, .speakers = { FRW, FLW, RR, RL, FC, 0, FR, FL } },
|
|
|
|
{ .ca_index = 0x31, .speakers = { FRW, FLW, RR, RL, FC, LFE, FR, FL } },
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HDMI routines
|
|
|
|
*/
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
#define get_pin(spec, idx) \
|
|
|
|
((struct hdmi_spec_per_pin *)snd_array_elem(&spec->pins, idx))
|
|
|
|
#define get_cvt(spec, idx) \
|
|
|
|
((struct hdmi_spec_per_cvt *)snd_array_elem(&spec->cvts, idx))
|
2015-02-27 23:43:19 +07:00
|
|
|
#define get_pcm_rec(spec, idx) ((spec)->pcm_rec[idx])
|
2013-03-13 20:40:31 +07:00
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
static int pin_nid_to_pin_index(struct hda_codec *codec, hda_nid_t pin_nid)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2014-02-25 18:21:03 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++)
|
2013-03-13 20:40:31 +07:00
|
|
|
if (get_pin(spec, pin_idx)->pin_nid == pin_nid)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return pin_idx;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_warn(codec, "HDMI: pin nid %d not registered\n", pin_nid);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
static int hinfo_to_pin_index(struct hda_codec *codec,
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hda_pcm_stream *hinfo)
|
|
|
|
{
|
2014-02-25 18:21:03 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
|
|
|
|
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++)
|
2013-03-13 20:40:31 +07:00
|
|
|
if (get_pcm_rec(spec, pin_idx)->stream == hinfo)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return pin_idx;
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_warn(codec, "HDMI: hinfo %p not registered\n", hinfo);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
static int cvt_nid_to_cvt_index(struct hda_codec *codec, hda_nid_t cvt_nid)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
{
|
2014-02-25 18:21:03 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int cvt_idx;
|
|
|
|
|
|
|
|
for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++)
|
2013-03-13 20:40:31 +07:00
|
|
|
if (get_cvt(spec, cvt_idx)->cvt_nid == cvt_nid)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return cvt_idx;
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_warn(codec, "HDMI: cvt nid %d not registered\n", cvt_nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-10-01 04:35:41 +07:00
|
|
|
static int hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
2013-02-19 22:11:23 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-10-17 23:21:12 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
2013-02-19 22:11:23 +07:00
|
|
|
struct hdmi_eld *eld;
|
2011-10-01 04:35:41 +07:00
|
|
|
int pin_idx;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
|
|
|
|
|
|
|
|
pin_idx = kcontrol->private_value;
|
2013-10-17 23:21:12 +07:00
|
|
|
per_pin = get_pin(spec, pin_idx);
|
|
|
|
eld = &per_pin->sink_eld;
|
2013-02-19 22:11:23 +07:00
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2013-02-19 22:11:23 +07:00
|
|
|
uinfo->count = eld->eld_valid ? eld->eld_size : 0;
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
2011-10-01 04:35:41 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
2013-02-19 22:11:23 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-10-17 23:21:12 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
2013-02-19 22:11:23 +07:00
|
|
|
struct hdmi_eld *eld;
|
2011-10-01 04:35:41 +07:00
|
|
|
int pin_idx;
|
|
|
|
|
|
|
|
pin_idx = kcontrol->private_value;
|
2013-10-17 23:21:12 +07:00
|
|
|
per_pin = get_pin(spec, pin_idx);
|
|
|
|
eld = &per_pin->sink_eld;
|
2013-02-19 22:11:23 +07:00
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2013-02-19 22:11:23 +07:00
|
|
|
if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data)) {
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
2013-02-19 22:11:23 +07:00
|
|
|
snd_BUG();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(ucontrol->value.bytes.data, 0,
|
|
|
|
ARRAY_SIZE(ucontrol->value.bytes.data));
|
|
|
|
if (eld->eld_valid)
|
|
|
|
memcpy(ucontrol->value.bytes.data, eld->eld_buffer,
|
|
|
|
eld->eld_size);
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
2011-10-01 04:35:41 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new eld_bytes_ctl = {
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
|
|
.name = "ELD",
|
|
|
|
.info = hdmi_eld_ctl_info,
|
|
|
|
.get = hdmi_eld_ctl_get,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int hdmi_create_eld_ctl(struct hda_codec *codec, int pin_idx,
|
|
|
|
int device)
|
|
|
|
{
|
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
kctl = snd_ctl_new1(&eld_bytes_ctl, codec);
|
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
|
|
|
kctl->private_value = pin_idx;
|
|
|
|
kctl->id.device = device;
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
err = snd_hda_ctl_add(codec, get_pin(spec, pin_idx)->pin_nid, kctl);
|
2011-10-01 04:35:41 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
get_pin(spec, pin_idx)->eld_ctl = kctl;
|
2011-10-01 04:35:41 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
#ifdef BE_PARANOID
|
|
|
|
static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int *packet_index, int *byte_index)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_DIP_INDEX, 0);
|
|
|
|
|
|
|
|
*packet_index = val >> 5;
|
|
|
|
*byte_index = val & 0x1f;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int packet_index, int byte_index)
|
|
|
|
{
|
|
|
|
int val;
|
|
|
|
|
|
|
|
val = (packet_index << 5) | (byte_index & 0x1f);
|
|
|
|
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
unsigned char val)
|
|
|
|
{
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
|
|
|
|
}
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
static void hdmi_init_pin(struct hda_codec *codec, hda_nid_t pin_nid)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2014-01-31 01:52:16 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int pin_out;
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/* Unmute */
|
|
|
|
if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0,
|
|
|
|
AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
|
2014-01-31 01:52:16 +07:00
|
|
|
|
|
|
|
if (spec->dyn_pin_out)
|
|
|
|
/* Disable pin out until stream is active */
|
|
|
|
pin_out = 0;
|
|
|
|
else
|
|
|
|
/* Enable pin out: some machines with GM965 gets broken output
|
|
|
|
* when the pin is disabled or changed while using with HDMI
|
|
|
|
*/
|
|
|
|
pin_out = PIN_OUT;
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
snd_hda_codec_write(codec, pin_nid, 0,
|
2014-01-31 01:52:16 +07:00
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL, pin_out);
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t cvt_nid)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return 1 + snd_hda_codec_read(codec, cvt_nid, 0,
|
2010-03-08 09:44:23 +07:00
|
|
|
AC_VERB_GET_CVT_CHAN_COUNT, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_set_channel_count(struct hda_codec *codec,
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hda_nid_t cvt_nid, int chs)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (chs != hdmi_get_channel_count(codec, cvt_nid))
|
|
|
|
snd_hda_codec_write(codec, cvt_nid, 0,
|
2010-03-08 09:44:23 +07:00
|
|
|
AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
|
|
|
|
}
|
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
/*
|
|
|
|
* ELD proc files
|
|
|
|
*/
|
|
|
|
|
2015-05-27 18:45:45 +07:00
|
|
|
#ifdef CONFIG_SND_PROC_FS
|
2013-10-17 23:21:12 +07:00
|
|
|
static void print_eld_info(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
|
|
|
struct hdmi_spec_per_pin *per_pin = entry->private_data;
|
|
|
|
|
|
|
|
mutex_lock(&per_pin->lock);
|
|
|
|
snd_hdmi_print_eld_info(&per_pin->sink_eld, buffer);
|
|
|
|
mutex_unlock(&per_pin->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_eld_info(struct snd_info_entry *entry,
|
|
|
|
struct snd_info_buffer *buffer)
|
|
|
|
{
|
|
|
|
struct hdmi_spec_per_pin *per_pin = entry->private_data;
|
|
|
|
|
|
|
|
mutex_lock(&per_pin->lock);
|
|
|
|
snd_hdmi_write_eld_info(&per_pin->sink_eld, buffer);
|
|
|
|
mutex_unlock(&per_pin->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int eld_proc_new(struct hdmi_spec_per_pin *per_pin, int index)
|
|
|
|
{
|
|
|
|
char name[32];
|
|
|
|
struct hda_codec *codec = per_pin->codec;
|
|
|
|
struct snd_info_entry *entry;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
snprintf(name, sizeof(name), "eld#%d.%d", codec->addr, index);
|
2015-02-27 22:09:22 +07:00
|
|
|
err = snd_card_proc_new(codec->card, name, &entry);
|
2013-10-17 23:21:12 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
snd_info_set_text_ops(entry, per_pin, print_eld_info);
|
|
|
|
entry->c.text.write = write_eld_info;
|
|
|
|
entry->mode |= S_IWUSR;
|
|
|
|
per_pin->proc_entry = entry;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void eld_proc_free(struct hdmi_spec_per_pin *per_pin)
|
|
|
|
{
|
2015-06-28 16:15:28 +07:00
|
|
|
if (!per_pin->codec->bus->shutdown) {
|
2015-04-22 23:26:38 +07:00
|
|
|
snd_info_free_entry(per_pin->proc_entry);
|
2013-10-17 23:21:12 +07:00
|
|
|
per_pin->proc_entry = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2013-10-21 21:31:45 +07:00
|
|
|
static inline int eld_proc_new(struct hdmi_spec_per_pin *per_pin,
|
|
|
|
int index)
|
2013-10-17 23:21:12 +07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2013-10-21 21:31:45 +07:00
|
|
|
static inline void eld_proc_free(struct hdmi_spec_per_pin *per_pin)
|
2013-10-17 23:21:12 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Channel mapping routines
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute derived values in channel_allocations[].
|
|
|
|
*/
|
|
|
|
static void init_channel_allocations(void)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
struct cea_channel_speaker_allocation *p;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
|
|
|
|
p = channel_allocations + i;
|
|
|
|
p->channels = 0;
|
|
|
|
p->spk_mask = 0;
|
|
|
|
for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
|
|
|
|
if (p->speakers[j]) {
|
|
|
|
p->channels++;
|
|
|
|
p->spk_mask |= p->speakers[j];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-06 09:02:36 +07:00
|
|
|
static int get_channel_allocation_order(int ca)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
|
|
|
|
if (channel_allocations[i].ca_index == ca)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
* The transformation takes two steps:
|
|
|
|
*
|
|
|
|
* eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
|
|
|
|
* spk_mask => (channel_allocations[]) => ai->CA
|
|
|
|
*
|
|
|
|
* TODO: it could select the wrong CA from multiple candidates.
|
|
|
|
*/
|
2014-06-06 23:04:34 +07:00
|
|
|
static int hdmi_channel_allocation(struct hda_codec *codec,
|
|
|
|
struct hdmi_eld *eld, int channels)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
int i;
|
2010-09-21 13:25:49 +07:00
|
|
|
int ca = 0;
|
2010-03-08 09:44:23 +07:00
|
|
|
int spk_mask = 0;
|
|
|
|
char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CA defaults to 0 for basic stereo audio
|
|
|
|
*/
|
|
|
|
if (channels <= 2)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* expand ELD's speaker allocation mask
|
|
|
|
*
|
|
|
|
* ELD tells the speaker mask in a compact(paired) form,
|
|
|
|
* expand ELD's notions to match the ones used by Audio InfoFrame.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
|
2013-02-19 22:11:24 +07:00
|
|
|
if (eld->info.spk_alloc & (1 << i))
|
2010-03-08 09:44:23 +07:00
|
|
|
spk_mask |= eld_speaker_allocation_bits[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* search for the first working match in the CA table */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
|
|
|
|
if (channels == channel_allocations[i].channels &&
|
|
|
|
(spk_mask & channel_allocations[i].spk_mask) ==
|
|
|
|
channel_allocations[i].spk_mask) {
|
2010-09-21 13:25:49 +07:00
|
|
|
ca = channel_allocations[i].ca_index;
|
2010-03-08 09:44:23 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-01 18:36:47 +07:00
|
|
|
if (!ca) {
|
|
|
|
/* if there was no match, select the regular ALSA channel
|
|
|
|
* allocation with the matching number of channels */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
|
|
|
|
if (channels == channel_allocations[i].channels) {
|
|
|
|
ca = channel_allocations[i].ca_index;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-19 22:11:24 +07:00
|
|
|
snd_print_channel_allocation(eld->info.spk_alloc, buf, sizeof(buf));
|
2014-06-06 23:04:34 +07:00
|
|
|
codec_dbg(codec, "HDMI: select CA 0x%x for %d-channel allocation: %s\n",
|
2010-09-21 13:25:49 +07:00
|
|
|
ca, channels, buf);
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
return ca;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_debug_channel_mapping(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
2013-10-25 01:10:34 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2010-03-08 09:44:23 +07:00
|
|
|
int i;
|
2013-10-25 01:10:34 +07:00
|
|
|
int channel;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
2013-10-25 01:10:34 +07:00
|
|
|
channel = spec->ops.pin_get_slot_channel(codec, pin_nid, i);
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "HDMI: ASP channel %d => slot %d\n",
|
2013-10-25 01:10:34 +07:00
|
|
|
channel, i);
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
static void hdmi_std_setup_channel_mapping(struct hda_codec *codec,
|
2010-03-08 09:44:23 +07:00
|
|
|
hda_nid_t pin_nid,
|
2012-09-06 09:02:37 +07:00
|
|
|
bool non_pcm,
|
2010-09-21 13:25:49 +07:00
|
|
|
int ca)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2013-10-25 01:10:34 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-10-05 06:25:39 +07:00
|
|
|
struct cea_channel_speaker_allocation *ch_alloc;
|
2010-03-08 09:44:23 +07:00
|
|
|
int i;
|
|
|
|
int err;
|
2012-09-06 09:02:36 +07:00
|
|
|
int order;
|
2012-09-06 09:02:37 +07:00
|
|
|
int non_pcm_mapping[8];
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2012-09-06 09:02:36 +07:00
|
|
|
order = get_channel_allocation_order(ca);
|
2013-10-05 06:25:39 +07:00
|
|
|
ch_alloc = &channel_allocations[order];
|
2012-09-06 09:02:37 +07:00
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
if (hdmi_channel_mapping[ca][1] == 0) {
|
2013-10-05 06:25:39 +07:00
|
|
|
int hdmi_slot = 0;
|
|
|
|
/* fill actual channel mappings in ALSA channel (i) order */
|
|
|
|
for (i = 0; i < ch_alloc->channels; i++) {
|
|
|
|
while (!ch_alloc->speakers[7 - hdmi_slot] && !WARN_ON(hdmi_slot >= 8))
|
|
|
|
hdmi_slot++; /* skip zero slots */
|
|
|
|
|
|
|
|
hdmi_channel_mapping[ca][i] = (i << 4) | hdmi_slot++;
|
|
|
|
}
|
|
|
|
/* fill the rest of the slots with ALSA channel 0xf */
|
|
|
|
for (hdmi_slot = 0; hdmi_slot < 8; hdmi_slot++)
|
|
|
|
if (!ch_alloc->speakers[7 - hdmi_slot])
|
|
|
|
hdmi_channel_mapping[ca][i++] = (0xf << 4) | hdmi_slot;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
2012-09-06 09:02:37 +07:00
|
|
|
if (non_pcm) {
|
2013-10-05 06:25:39 +07:00
|
|
|
for (i = 0; i < ch_alloc->channels; i++)
|
2013-10-05 06:25:41 +07:00
|
|
|
non_pcm_mapping[i] = (i << 4) | i;
|
2012-09-06 09:02:37 +07:00
|
|
|
for (; i < 8; i++)
|
2013-10-05 06:25:41 +07:00
|
|
|
non_pcm_mapping[i] = (0xf << 4) | i;
|
2012-09-06 09:02:37 +07:00
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
for (i = 0; i < 8; i++) {
|
2013-10-25 01:10:34 +07:00
|
|
|
int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i];
|
|
|
|
int hdmi_slot = slotsetup & 0x0f;
|
|
|
|
int channel = (slotsetup & 0xf0) >> 4;
|
|
|
|
err = spec->ops.pin_set_slot_channel(codec, pin_nid, hdmi_slot, channel);
|
2010-03-08 09:44:23 +07:00
|
|
|
if (err) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "HDMI: channel mapping failed\n");
|
2010-03-08 09:44:23 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
struct channel_map_table {
|
|
|
|
unsigned char map; /* ALSA API channel map position */
|
|
|
|
int spk_mask; /* speaker position bit mask */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct channel_map_table map_tables[] = {
|
2013-10-05 06:25:42 +07:00
|
|
|
{ SNDRV_CHMAP_FL, FL },
|
|
|
|
{ SNDRV_CHMAP_FR, FR },
|
|
|
|
{ SNDRV_CHMAP_RL, RL },
|
|
|
|
{ SNDRV_CHMAP_RR, RR },
|
|
|
|
{ SNDRV_CHMAP_LFE, LFE },
|
|
|
|
{ SNDRV_CHMAP_FC, FC },
|
|
|
|
{ SNDRV_CHMAP_RLC, RLC },
|
|
|
|
{ SNDRV_CHMAP_RRC, RRC },
|
|
|
|
{ SNDRV_CHMAP_RC, RC },
|
|
|
|
{ SNDRV_CHMAP_FLC, FLC },
|
|
|
|
{ SNDRV_CHMAP_FRC, FRC },
|
2013-11-11 02:24:04 +07:00
|
|
|
{ SNDRV_CHMAP_TFL, FLH },
|
|
|
|
{ SNDRV_CHMAP_TFR, FRH },
|
2013-10-05 06:25:42 +07:00
|
|
|
{ SNDRV_CHMAP_FLW, FLW },
|
|
|
|
{ SNDRV_CHMAP_FRW, FRW },
|
|
|
|
{ SNDRV_CHMAP_TC, TC },
|
2013-11-11 02:24:04 +07:00
|
|
|
{ SNDRV_CHMAP_TFC, FCH },
|
2012-07-31 16:36:00 +07:00
|
|
|
{} /* terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* from ALSA API channel position to speaker bit mask */
|
|
|
|
static int to_spk_mask(unsigned char c)
|
|
|
|
{
|
|
|
|
struct channel_map_table *t = map_tables;
|
|
|
|
for (; t->map; t++) {
|
|
|
|
if (t->map == c)
|
|
|
|
return t->spk_mask;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* from ALSA API channel position to CEA slot */
|
2013-10-05 06:25:42 +07:00
|
|
|
static int to_cea_slot(int ordered_ca, unsigned char pos)
|
2012-07-31 16:36:00 +07:00
|
|
|
{
|
2013-10-05 06:25:42 +07:00
|
|
|
int mask = to_spk_mask(pos);
|
|
|
|
int i;
|
2012-07-31 16:36:00 +07:00
|
|
|
|
2013-10-05 06:25:42 +07:00
|
|
|
if (mask) {
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
if (channel_allocations[ordered_ca].speakers[7 - i] == mask)
|
|
|
|
return i;
|
|
|
|
}
|
2012-07-31 16:36:00 +07:00
|
|
|
}
|
2013-10-05 06:25:42 +07:00
|
|
|
|
|
|
|
return -1;
|
2012-07-31 16:36:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* from speaker bit mask to ALSA API channel position */
|
|
|
|
static int spk_to_chmap(int spk)
|
|
|
|
{
|
|
|
|
struct channel_map_table *t = map_tables;
|
|
|
|
for (; t->map; t++) {
|
|
|
|
if (t->spk_mask == spk)
|
|
|
|
return t->map;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-05 06:25:42 +07:00
|
|
|
/* from CEA slot to ALSA API channel position */
|
|
|
|
static int from_cea_slot(int ordered_ca, unsigned char slot)
|
|
|
|
{
|
|
|
|
int mask = channel_allocations[ordered_ca].speakers[7 - slot];
|
|
|
|
|
|
|
|
return spk_to_chmap(mask);
|
|
|
|
}
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
/* get the CA index corresponding to the given ALSA API channel map */
|
|
|
|
static int hdmi_manual_channel_allocation(int chs, unsigned char *map)
|
|
|
|
{
|
|
|
|
int i, spks = 0, spk_mask = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < chs; i++) {
|
|
|
|
int mask = to_spk_mask(map[i]);
|
|
|
|
if (mask) {
|
|
|
|
spk_mask |= mask;
|
|
|
|
spks++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
|
|
|
|
if ((chs == channel_allocations[i].channels ||
|
|
|
|
spks == channel_allocations[i].channels) &&
|
|
|
|
(spk_mask & channel_allocations[i].spk_mask) ==
|
|
|
|
channel_allocations[i].spk_mask)
|
|
|
|
return channel_allocations[i].ca_index;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set up the channel slots for the given ALSA API channel map */
|
|
|
|
static int hdmi_manual_setup_channel_mapping(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid,
|
2013-10-05 06:25:42 +07:00
|
|
|
int chs, unsigned char *map,
|
|
|
|
int ca)
|
2012-07-31 16:36:00 +07:00
|
|
|
{
|
2013-10-25 01:10:34 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-10-05 06:25:42 +07:00
|
|
|
int ordered_ca = get_channel_allocation_order(ca);
|
2013-10-05 06:25:41 +07:00
|
|
|
int alsa_pos, hdmi_slot;
|
|
|
|
int assignments[8] = {[0 ... 7] = 0xf};
|
|
|
|
|
|
|
|
for (alsa_pos = 0; alsa_pos < chs; alsa_pos++) {
|
|
|
|
|
2013-10-05 06:25:42 +07:00
|
|
|
hdmi_slot = to_cea_slot(ordered_ca, map[alsa_pos]);
|
2013-10-05 06:25:41 +07:00
|
|
|
|
|
|
|
if (hdmi_slot < 0)
|
|
|
|
continue; /* unassigned channel */
|
|
|
|
|
|
|
|
assignments[hdmi_slot] = alsa_pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (hdmi_slot = 0; hdmi_slot < 8; hdmi_slot++) {
|
2013-10-25 01:10:34 +07:00
|
|
|
int err;
|
2013-10-05 06:25:41 +07:00
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
err = spec->ops.pin_set_slot_channel(codec, pin_nid, hdmi_slot,
|
|
|
|
assignments[hdmi_slot]);
|
2012-07-31 16:36:00 +07:00
|
|
|
if (err)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* store ALSA API channel map from the current default map */
|
|
|
|
static void hdmi_setup_fake_chmap(unsigned char *map, int ca)
|
|
|
|
{
|
|
|
|
int i;
|
ALSA: hda - hdmi: Fix reported channel map on common default layouts
hdmi_setup_fake_chmap() is supposed to set the reported channel map when
the channel map is not specified by the user.
However, the function indexes channel_allocations[] with a wrong value
and extracts the wrong nibble from hdmi_channel_mapping[], causing wrong
channel maps to be shown.
Fix those issues.
Tested on Intel HDMI to correctly generate various channel maps, for
example 3,4,14,15,7,8,5,6 (instead of incorrect 3,4,8,7,5,6,14,0) for
standard 7.1 channel audio. (Note that the side and rear channels are
reported as RL/RR and RLC/RRC, respectively, as per the CEA-861
standard, instead of the more traditional SL/SR and RL/RR.)
Note that this only fixes the layouts that only contain traditional 7.1
speakers (2.0, 2.1, 4.0, 5.1, 7.1, etc.). E.g. the rear center of 6.1
is still being shown wrongly due to an issue with from_cea_slot()
which will be fixed in a later patch.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:38 +07:00
|
|
|
int ordered_ca = get_channel_allocation_order(ca);
|
2012-07-31 16:36:00 +07:00
|
|
|
for (i = 0; i < 8; i++) {
|
ALSA: hda - hdmi: Fix reported channel map on common default layouts
hdmi_setup_fake_chmap() is supposed to set the reported channel map when
the channel map is not specified by the user.
However, the function indexes channel_allocations[] with a wrong value
and extracts the wrong nibble from hdmi_channel_mapping[], causing wrong
channel maps to be shown.
Fix those issues.
Tested on Intel HDMI to correctly generate various channel maps, for
example 3,4,14,15,7,8,5,6 (instead of incorrect 3,4,8,7,5,6,14,0) for
standard 7.1 channel audio. (Note that the side and rear channels are
reported as RL/RR and RLC/RRC, respectively, as per the CEA-861
standard, instead of the more traditional SL/SR and RL/RR.)
Note that this only fixes the layouts that only contain traditional 7.1
speakers (2.0, 2.1, 4.0, 5.1, 7.1, etc.). E.g. the rear center of 6.1
is still being shown wrongly due to an issue with from_cea_slot()
which will be fixed in a later patch.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:38 +07:00
|
|
|
if (i < channel_allocations[ordered_ca].channels)
|
2013-10-05 06:25:42 +07:00
|
|
|
map[i] = from_cea_slot(ordered_ca, hdmi_channel_mapping[ca][i] & 0x0f);
|
2012-07-31 16:36:00 +07:00
|
|
|
else
|
|
|
|
map[i] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_setup_channel_mapping(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid, bool non_pcm, int ca,
|
2013-02-03 22:55:45 +07:00
|
|
|
int channels, unsigned char *map,
|
|
|
|
bool chmap_set)
|
2012-07-31 16:36:00 +07:00
|
|
|
{
|
2013-02-03 22:55:45 +07:00
|
|
|
if (!non_pcm && chmap_set) {
|
2012-07-31 16:36:00 +07:00
|
|
|
hdmi_manual_setup_channel_mapping(codec, pin_nid,
|
2013-10-05 06:25:42 +07:00
|
|
|
channels, map, ca);
|
2012-07-31 16:36:00 +07:00
|
|
|
} else {
|
|
|
|
hdmi_std_setup_channel_mapping(codec, pin_nid, non_pcm, ca);
|
|
|
|
hdmi_setup_fake_chmap(map, ca);
|
|
|
|
}
|
2013-10-05 06:25:44 +07:00
|
|
|
|
|
|
|
hdmi_debug_channel_mapping(codec, pin_nid);
|
2012-07-31 16:36:00 +07:00
|
|
|
}
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
static int hdmi_pin_set_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int asp_slot, int channel)
|
|
|
|
{
|
|
|
|
return snd_hda_codec_write(codec, pin_nid, 0,
|
|
|
|
AC_VERB_SET_HDMI_CHAN_SLOT,
|
|
|
|
(channel << 4) | asp_slot);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_pin_get_slot_channel(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int asp_slot)
|
|
|
|
{
|
|
|
|
return (snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_CHAN_SLOT,
|
|
|
|
asp_slot) & 0xf0) >> 4;
|
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
* Audio InfoFrame routines
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable Audio InfoFrame Transmission
|
|
|
|
*/
|
|
|
|
static void hdmi_start_infoframe_trans(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
|
|
|
|
AC_DIPXMIT_BEST);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable Audio InfoFrame Transmission
|
|
|
|
*/
|
|
|
|
static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
|
|
|
|
AC_DIPXMIT_DISABLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SND_DEBUG_VERBOSE
|
|
|
|
int i;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
size = snd_hdmi_get_eld_size(codec, pin_nid);
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "HDMI: ELD buf size is %d\n", size);
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
size = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_DIP_SIZE, i);
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "HDMI: DIP GP[%d] buf size is %d\n", i, size);
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
#ifdef BE_PARANOID
|
|
|
|
int i, j;
|
|
|
|
int size;
|
|
|
|
int pi, bi;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
size = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_DIP_SIZE, i);
|
|
|
|
if (size == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hdmi_set_dip_index(codec, pin_nid, i, 0x0);
|
|
|
|
for (j = 1; j < 1000; j++) {
|
|
|
|
hdmi_write_dip_byte(codec, pin_nid, 0x0);
|
|
|
|
hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
|
|
|
|
if (pi != i)
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "dip index %d: %d != %d\n",
|
2010-03-08 09:44:23 +07:00
|
|
|
bi, pi, i);
|
|
|
|
if (bi == 0) /* byte index wrapped around */
|
|
|
|
break;
|
|
|
|
}
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
2010-03-08 09:44:23 +07:00
|
|
|
"HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
|
|
|
|
i, size, j);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *hdmi_ai)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2010-09-21 13:25:49 +07:00
|
|
|
u8 *bytes = (u8 *)hdmi_ai;
|
2010-03-08 09:44:23 +07:00
|
|
|
u8 sum = 0;
|
|
|
|
int i;
|
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
hdmi_ai->checksum = 0;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
for (i = 0; i < sizeof(*hdmi_ai); i++)
|
2010-03-08 09:44:23 +07:00
|
|
|
sum += bytes[i];
|
|
|
|
|
2010-09-21 13:25:49 +07:00
|
|
|
hdmi_ai->checksum = -sum;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid,
|
2010-09-21 13:25:49 +07:00
|
|
|
u8 *dip, int size)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
hdmi_debug_dip_size(codec, pin_nid);
|
|
|
|
hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
|
|
|
|
|
|
|
|
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
|
2010-09-21 13:25:49 +07:00
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
hdmi_write_dip_byte(codec, pin_nid, dip[i]);
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
|
2010-09-21 13:25:49 +07:00
|
|
|
u8 *dip, int size)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
u8 val;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
|
|
|
|
!= AC_DIPXMIT_BEST)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
|
2010-09-21 13:25:49 +07:00
|
|
|
for (i = 0; i < size; i++) {
|
2010-03-08 09:44:23 +07:00
|
|
|
val = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_HDMI_DIP_DATA, 0);
|
2010-09-21 13:25:49 +07:00
|
|
|
if (val != dip[i])
|
2010-03-08 09:44:23 +07:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
static void hdmi_pin_setup_infoframe(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin_nid,
|
|
|
|
int ca, int active_channels,
|
|
|
|
int conn_type)
|
|
|
|
{
|
|
|
|
union audio_infoframe ai;
|
|
|
|
|
2014-03-12 04:12:52 +07:00
|
|
|
memset(&ai, 0, sizeof(ai));
|
2013-10-25 01:10:34 +07:00
|
|
|
if (conn_type == 0) { /* HDMI */
|
|
|
|
struct hdmi_audio_infoframe *hdmi_ai = &ai.hdmi;
|
|
|
|
|
|
|
|
hdmi_ai->type = 0x84;
|
|
|
|
hdmi_ai->ver = 0x01;
|
|
|
|
hdmi_ai->len = 0x0a;
|
|
|
|
hdmi_ai->CC02_CT47 = active_channels - 1;
|
|
|
|
hdmi_ai->CA = ca;
|
|
|
|
hdmi_checksum_audio_infoframe(hdmi_ai);
|
|
|
|
} else if (conn_type == 1) { /* DisplayPort */
|
|
|
|
struct dp_audio_infoframe *dp_ai = &ai.dp;
|
|
|
|
|
|
|
|
dp_ai->type = 0x84;
|
|
|
|
dp_ai->len = 0x1b;
|
|
|
|
dp_ai->ver = 0x11 << 2;
|
|
|
|
dp_ai->CC02_CT47 = active_channels - 1;
|
|
|
|
dp_ai->CA = ca;
|
|
|
|
} else {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "HDMI: unknown connection type at pin %d\n",
|
2013-10-25 01:10:34 +07:00
|
|
|
pin_nid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sizeof(ai) is used instead of sizeof(*hdmi_ai) or
|
|
|
|
* sizeof(*dp_ai) to avoid partial match/update problems when
|
|
|
|
* the user switches between HDMI/DP monitors.
|
|
|
|
*/
|
|
|
|
if (!hdmi_infoframe_uptodate(codec, pin_nid, ai.bytes,
|
|
|
|
sizeof(ai))) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"hdmi_pin_setup_infoframe: pin=%d channels=%d ca=0x%02x\n",
|
2013-10-25 01:10:34 +07:00
|
|
|
pin_nid,
|
|
|
|
active_channels, ca);
|
|
|
|
hdmi_stop_infoframe_trans(codec, pin_nid);
|
|
|
|
hdmi_fill_audio_infoframe(codec, pin_nid,
|
|
|
|
ai.bytes, sizeof(ai));
|
|
|
|
hdmi_start_infoframe_trans(codec, pin_nid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-02 17:33:02 +07:00
|
|
|
static void hdmi_setup_audio_infoframe(struct hda_codec *codec,
|
|
|
|
struct hdmi_spec_per_pin *per_pin,
|
|
|
|
bool non_pcm)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2013-10-25 01:10:34 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
2013-09-02 17:33:02 +07:00
|
|
|
int channels = per_pin->channels;
|
ALSA: hda - hdmi: Fix programmed active channel count
Currently the converter channel count is set to the number of actual
input channels. The audio infoframe channel count field is set
similarly.
However, sometimes the used channel map does not map all input channels
to outputs. Notably, 3 channel modes (e.g. 2.1) require a dummy input
channel so there are 4 input channels. According to the HDA
specification, converter channel count should be programmed according to
the number of _active_ channels.
On Intel HDMI codecs (but not on NVIDIA), setting the converter channel
to a higher value than there are actually mapped channels to HDMI slots
will cause no audio to be output at all.
Note that the effects of this issue are currently partially masked by
other bugs that prevent the driver from actually unmapping channels in
certain cases. For example, if a 4 channel stream is first created and
prepared, it gets a FL,FR,RL,RR mapping (ALSA->HDMI slot mapping 0->0,
1->1, 2->4, 3->5). If one thereafter assigns a FR,FL,FC mapping to it,
the driver will remap 2->3 but fail to unmap 2->4 and 3->5, so there are
still 4 active channels and the issue will not trigger in this case.
These bugs will be fixed separately.
Fix the channel counts in the converter channel count field and in the
audio infoframe channel count field to match the actual number of active
channels.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:40 +07:00
|
|
|
int active_channels;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_eld *eld;
|
ALSA: hda - hdmi: Fix programmed active channel count
Currently the converter channel count is set to the number of actual
input channels. The audio infoframe channel count field is set
similarly.
However, sometimes the used channel map does not map all input channels
to outputs. Notably, 3 channel modes (e.g. 2.1) require a dummy input
channel so there are 4 input channels. According to the HDA
specification, converter channel count should be programmed according to
the number of _active_ channels.
On Intel HDMI codecs (but not on NVIDIA), setting the converter channel
to a higher value than there are actually mapped channels to HDMI slots
will cause no audio to be output at all.
Note that the effects of this issue are currently partially masked by
other bugs that prevent the driver from actually unmapping channels in
certain cases. For example, if a 4 channel stream is first created and
prepared, it gets a FL,FR,RL,RR mapping (ALSA->HDMI slot mapping 0->0,
1->1, 2->4, 3->5). If one thereafter assigns a FR,FL,FC mapping to it,
the driver will remap 2->3 but fail to unmap 2->4 and 3->5, so there are
still 4 active channels and the issue will not trigger in this case.
These bugs will be fixed separately.
Fix the channel counts in the converter channel count field and in the
audio infoframe channel count field to match the actual number of active
channels.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:40 +07:00
|
|
|
int ca, ordered_ca;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2013-09-02 17:33:02 +07:00
|
|
|
if (!channels)
|
|
|
|
return;
|
|
|
|
|
2014-01-09 03:55:32 +07:00
|
|
|
if (is_haswell_plus(codec))
|
2013-09-05 03:37:12 +07:00
|
|
|
snd_hda_codec_write(codec, pin_nid, 0,
|
|
|
|
AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AMP_OUT_UNMUTE);
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
eld = &per_pin->sink_eld;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
if (!non_pcm && per_pin->chmap_set)
|
|
|
|
ca = hdmi_manual_channel_allocation(channels, per_pin->chmap);
|
|
|
|
else
|
2014-06-06 23:04:34 +07:00
|
|
|
ca = hdmi_channel_allocation(codec, eld, channels);
|
2012-07-31 16:36:00 +07:00
|
|
|
if (ca < 0)
|
|
|
|
ca = 0;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
ALSA: hda - hdmi: Fix programmed active channel count
Currently the converter channel count is set to the number of actual
input channels. The audio infoframe channel count field is set
similarly.
However, sometimes the used channel map does not map all input channels
to outputs. Notably, 3 channel modes (e.g. 2.1) require a dummy input
channel so there are 4 input channels. According to the HDA
specification, converter channel count should be programmed according to
the number of _active_ channels.
On Intel HDMI codecs (but not on NVIDIA), setting the converter channel
to a higher value than there are actually mapped channels to HDMI slots
will cause no audio to be output at all.
Note that the effects of this issue are currently partially masked by
other bugs that prevent the driver from actually unmapping channels in
certain cases. For example, if a 4 channel stream is first created and
prepared, it gets a FL,FR,RL,RR mapping (ALSA->HDMI slot mapping 0->0,
1->1, 2->4, 3->5). If one thereafter assigns a FR,FL,FC mapping to it,
the driver will remap 2->3 but fail to unmap 2->4 and 3->5, so there are
still 4 active channels and the issue will not trigger in this case.
These bugs will be fixed separately.
Fix the channel counts in the converter channel count field and in the
audio infoframe channel count field to match the actual number of active
channels.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:40 +07:00
|
|
|
ordered_ca = get_channel_allocation_order(ca);
|
|
|
|
active_channels = channel_allocations[ordered_ca].channels;
|
|
|
|
|
|
|
|
hdmi_set_channel_count(codec, per_pin->cvt_nid, active_channels);
|
|
|
|
|
2013-10-07 23:24:52 +07:00
|
|
|
/*
|
|
|
|
* always configure channel mapping, it may have been changed by the
|
|
|
|
* user in the meantime
|
|
|
|
*/
|
|
|
|
hdmi_setup_channel_mapping(codec, pin_nid, non_pcm, ca,
|
|
|
|
channels, per_pin->chmap,
|
|
|
|
per_pin->chmap_set);
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
spec->ops.pin_setup_infoframe(codec, pin_nid, ca, active_channels,
|
|
|
|
eld->info.conn_type);
|
2012-09-06 09:02:37 +07:00
|
|
|
|
2012-09-06 22:42:08 +07:00
|
|
|
per_pin->non_pcm = non_pcm;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unsolicited events
|
|
|
|
*/
|
|
|
|
|
2013-11-07 19:38:23 +07:00
|
|
|
static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll);
|
2010-07-28 19:21:55 +07:00
|
|
|
|
2014-09-11 20:22:46 +07:00
|
|
|
static void check_presence_and_report(struct hda_codec *codec, hda_nid_t nid)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2014-09-11 20:22:46 +07:00
|
|
|
int pin_idx = pin_nid_to_pin_index(codec, nid);
|
|
|
|
|
2013-12-04 09:19:41 +07:00
|
|
|
if (pin_idx < 0)
|
|
|
|
return;
|
|
|
|
if (hdmi_present_sense(get_pin(spec, pin_idx), 1))
|
|
|
|
snd_hda_jack_report_sync(codec);
|
|
|
|
}
|
|
|
|
|
2014-09-11 20:22:46 +07:00
|
|
|
static void jack_callback(struct hda_codec *codec,
|
|
|
|
struct hda_jack_callback *jack)
|
|
|
|
{
|
|
|
|
check_presence_and_report(codec, jack->tbl->nid);
|
|
|
|
}
|
|
|
|
|
2013-12-04 09:19:41 +07:00
|
|
|
static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
|
|
|
|
{
|
2011-10-28 06:16:55 +07:00
|
|
|
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
|
|
|
|
struct hda_jack_tbl *jack;
|
2013-08-27 08:35:49 +07:00
|
|
|
int dev_entry = (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;
|
2011-10-28 06:16:55 +07:00
|
|
|
|
|
|
|
jack = snd_hda_jack_tbl_get_from_tag(codec, tag);
|
|
|
|
if (!jack)
|
|
|
|
return;
|
|
|
|
jack->jack_dirty = 1;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
2013-08-27 08:35:49 +07:00
|
|
|
"HDMI hot plug event: Codec=%d Pin=%d Device=%d Inactive=%d Presence_Detect=%d ELD_Valid=%d\n",
|
2013-12-04 09:19:41 +07:00
|
|
|
codec->addr, jack->nid, dev_entry, !!(res & AC_UNSOL_RES_IA),
|
2012-04-10 16:00:35 +07:00
|
|
|
!!(res & AC_UNSOL_RES_PD), !!(res & AC_UNSOL_RES_ELDV));
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2014-09-11 20:22:46 +07:00
|
|
|
check_presence_and_report(codec, jack->nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
|
|
|
|
{
|
|
|
|
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
|
|
|
|
int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
|
|
|
|
int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
|
|
|
|
int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_info(codec,
|
2012-06-21 16:41:05 +07:00
|
|
|
"HDMI CP event: CODEC=%d TAG=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
codec->addr,
|
2010-03-08 09:44:23 +07:00
|
|
|
tag,
|
|
|
|
subtag,
|
|
|
|
cp_state,
|
|
|
|
cp_ready);
|
|
|
|
|
|
|
|
/* TODO */
|
|
|
|
if (cp_state)
|
|
|
|
;
|
|
|
|
if (cp_ready)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
|
|
|
|
{
|
|
|
|
int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
|
|
|
|
int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
|
|
|
|
|
2011-10-28 06:16:55 +07:00
|
|
|
if (!snd_hda_jack_tbl_get_from_tag(codec, tag)) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "Unexpected HDMI event tag 0x%x\n", tag);
|
2010-03-08 09:44:23 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (subtag == 0)
|
|
|
|
hdmi_intrinsic_event(codec, res);
|
|
|
|
else
|
|
|
|
hdmi_non_intrinsic_event(codec, res);
|
|
|
|
}
|
|
|
|
|
2013-09-05 03:37:12 +07:00
|
|
|
static void haswell_verify_D0(struct hda_codec *codec,
|
2013-06-18 09:41:53 +07:00
|
|
|
hda_nid_t cvt_nid, hda_nid_t nid)
|
2013-04-10 17:26:07 +07:00
|
|
|
{
|
2013-09-05 03:37:12 +07:00
|
|
|
int pwr;
|
2013-04-10 17:26:07 +07:00
|
|
|
|
2013-06-18 09:41:53 +07:00
|
|
|
/* For Haswell, the converter 1/2 may keep in D3 state after bootup,
|
|
|
|
* thus pins could only choose converter 0 for use. Make sure the
|
|
|
|
* converters are in correct power state */
|
2013-06-18 21:28:36 +07:00
|
|
|
if (!snd_hda_check_power_state(codec, cvt_nid, AC_PWRST_D0))
|
2013-06-18 09:41:53 +07:00
|
|
|
snd_hda_codec_write(codec, cvt_nid, 0, AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
|
|
|
|
|
2013-06-18 21:28:36 +07:00
|
|
|
if (!snd_hda_check_power_state(codec, nid, AC_PWRST_D0)) {
|
2013-04-10 17:26:07 +07:00
|
|
|
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
|
|
|
|
AC_PWRST_D0);
|
|
|
|
msleep(40);
|
|
|
|
pwr = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);
|
|
|
|
pwr = (pwr & AC_PWRST_ACTUAL) >> AC_PWRST_ACTUAL_SHIFT;
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "Haswell HDMI audio: Power for pin 0x%x is now D%d\n", nid, pwr);
|
2013-04-10 17:26:07 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
* Callbacks
|
|
|
|
*/
|
|
|
|
|
2010-08-03 19:21:00 +07:00
|
|
|
/* HBR should be Non-PCM, 8 channels */
|
|
|
|
#define is_hbr_format(format) \
|
|
|
|
((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
static int hdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
bool hbr)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2013-10-25 01:10:34 +07:00
|
|
|
int pinctl, new_pinctl;
|
2013-04-10 17:26:07 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (snd_hda_query_pin_caps(codec, pin_nid) & AC_PINCAP_HBR) {
|
|
|
|
pinctl = snd_hda_codec_read(codec, pin_nid, 0,
|
2010-08-03 17:28:58 +07:00
|
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
|
|
|
|
|
2013-11-11 01:56:10 +07:00
|
|
|
if (pinctl < 0)
|
|
|
|
return hbr ? -EINVAL : 0;
|
|
|
|
|
2010-08-03 17:28:58 +07:00
|
|
|
new_pinctl = pinctl & ~AC_PINCTL_EPT;
|
2013-10-25 01:10:34 +07:00
|
|
|
if (hbr)
|
2010-08-03 17:28:58 +07:00
|
|
|
new_pinctl |= AC_PINCTL_EPT_HBR;
|
|
|
|
else
|
|
|
|
new_pinctl |= AC_PINCTL_EPT_NATIVE;
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"hdmi_pin_hbr_setup: NID=0x%x, %spinctl=0x%x\n",
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
pin_nid,
|
2010-08-03 17:28:58 +07:00
|
|
|
pinctl == new_pinctl ? "" : "new-",
|
|
|
|
new_pinctl);
|
|
|
|
|
|
|
|
if (pinctl != new_pinctl)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
snd_hda_codec_write(codec, pin_nid, 0,
|
2010-08-03 17:28:58 +07:00
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
|
|
new_pinctl);
|
2013-10-25 01:10:34 +07:00
|
|
|
} else if (hbr)
|
|
|
|
return -EINVAL;
|
2010-08-03 17:28:58 +07:00
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
|
|
|
|
hda_nid_t pin_nid, u32 stream_tag, int format)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int err;
|
|
|
|
|
2014-01-09 03:55:32 +07:00
|
|
|
if (is_haswell_plus(codec))
|
2013-10-25 01:10:34 +07:00
|
|
|
haswell_verify_D0(codec, cvt_nid, pin_nid);
|
|
|
|
|
|
|
|
err = spec->ops.pin_hbr_setup(codec, pin_nid, is_hbr_format(format));
|
|
|
|
|
|
|
|
if (err) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "hdmi_setup_stream: HBR is not supported\n");
|
2013-10-25 01:10:34 +07:00
|
|
|
return err;
|
2010-08-03 17:28:58 +07:00
|
|
|
}
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
snd_hda_codec_setup_stream(codec, cvt_nid, stream_tag, 0, format);
|
2010-08-03 17:28:58 +07:00
|
|
|
return 0;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
2013-06-18 20:42:14 +07:00
|
|
|
static int hdmi_choose_cvt(struct hda_codec *codec,
|
|
|
|
int pin_idx, int *cvt_id, int *mux_id)
|
2010-08-13 13:45:23 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
|
|
|
struct hdmi_spec_per_cvt *per_cvt = NULL;
|
2013-06-18 20:42:14 +07:00
|
|
|
int cvt_idx, mux_idx = 0;
|
2010-08-13 13:45:23 +07:00
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
per_pin = get_pin(spec, pin_idx);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
/* Dynamically assign converter to stream */
|
|
|
|
for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = get_cvt(spec, cvt_idx);
|
2010-08-13 13:45:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
/* Must not already be assigned */
|
|
|
|
if (per_cvt->assigned)
|
|
|
|
continue;
|
|
|
|
/* Must be in pin's mux's list of converters */
|
|
|
|
for (mux_idx = 0; mux_idx < per_pin->num_mux_nids; mux_idx++)
|
|
|
|
if (per_pin->mux_nids[mux_idx] == per_cvt->cvt_nid)
|
|
|
|
break;
|
|
|
|
/* Not in mux list */
|
|
|
|
if (mux_idx == per_pin->num_mux_nids)
|
|
|
|
continue;
|
|
|
|
break;
|
|
|
|
}
|
2013-06-18 20:42:14 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
/* No free converters */
|
|
|
|
if (cvt_idx == spec->num_cvts)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2014-03-20 12:01:06 +07:00
|
|
|
per_pin->mux_idx = mux_idx;
|
|
|
|
|
2013-06-18 20:42:14 +07:00
|
|
|
if (cvt_id)
|
|
|
|
*cvt_id = cvt_idx;
|
|
|
|
if (mux_id)
|
|
|
|
*mux_id = mux_idx;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-20 12:01:06 +07:00
|
|
|
/* Assure the pin select the right convetor */
|
|
|
|
static void intel_verify_pin_cvt_connect(struct hda_codec *codec,
|
|
|
|
struct hdmi_spec_per_pin *per_pin)
|
|
|
|
{
|
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
|
|
|
int mux_idx, curr;
|
|
|
|
|
|
|
|
mux_idx = per_pin->mux_idx;
|
|
|
|
curr = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_CONNECT_SEL, 0);
|
|
|
|
if (curr != mux_idx)
|
|
|
|
snd_hda_codec_write_cache(codec, pin_nid, 0,
|
|
|
|
AC_VERB_SET_CONNECT_SEL,
|
|
|
|
mux_idx);
|
|
|
|
}
|
|
|
|
|
2013-11-04 13:13:13 +07:00
|
|
|
/* Intel HDMI workaround to fix audio routing issue:
|
|
|
|
* For some Intel display codecs, pins share the same connection list.
|
|
|
|
* So a conveter can be selected by multiple pins and playback on any of these
|
|
|
|
* pins will generate sound on the external display, because audio flows from
|
|
|
|
* the same converter to the display pipeline. Also muting one pin may make
|
|
|
|
* other pins have no sound output.
|
|
|
|
* So this function assures that an assigned converter for a pin is not selected
|
|
|
|
* by any other pins.
|
|
|
|
*/
|
|
|
|
static void intel_not_share_assigned_cvt(struct hda_codec *codec,
|
2013-09-22 07:34:45 +07:00
|
|
|
hda_nid_t pin_nid, int mux_idx)
|
2013-06-18 20:42:14 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2015-03-03 16:07:24 +07:00
|
|
|
hda_nid_t nid;
|
2013-09-22 07:34:45 +07:00
|
|
|
int cvt_idx, curr;
|
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
2013-06-18 20:42:14 +07:00
|
|
|
|
2013-09-22 07:34:45 +07:00
|
|
|
/* configure all pins, including "no physical connection" ones */
|
2015-03-03 16:07:24 +07:00
|
|
|
for_each_hda_codec_node(nid, codec) {
|
2013-09-22 07:34:45 +07:00
|
|
|
unsigned int wid_caps = get_wcaps(codec, nid);
|
|
|
|
unsigned int wid_type = get_wcaps_type(wid_caps);
|
|
|
|
|
|
|
|
if (wid_type != AC_WID_PIN)
|
|
|
|
continue;
|
2013-06-18 20:42:14 +07:00
|
|
|
|
2013-09-22 07:34:45 +07:00
|
|
|
if (nid == pin_nid)
|
2013-06-18 20:42:14 +07:00
|
|
|
continue;
|
|
|
|
|
2013-09-22 07:34:45 +07:00
|
|
|
curr = snd_hda_codec_read(codec, nid, 0,
|
2013-06-18 20:42:14 +07:00
|
|
|
AC_VERB_GET_CONNECT_SEL, 0);
|
2013-09-22 07:34:45 +07:00
|
|
|
if (curr != mux_idx)
|
|
|
|
continue;
|
2013-06-18 20:42:14 +07:00
|
|
|
|
2013-09-22 07:34:45 +07:00
|
|
|
/* choose an unassigned converter. The conveters in the
|
|
|
|
* connection list are in the same order as in the codec.
|
|
|
|
*/
|
|
|
|
for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
|
|
|
|
per_cvt = get_cvt(spec, cvt_idx);
|
|
|
|
if (!per_cvt->assigned) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"choose cvt %d for pin nid %d\n",
|
2013-09-22 07:34:45 +07:00
|
|
|
cvt_idx, nid);
|
|
|
|
snd_hda_codec_write_cache(codec, nid, 0,
|
2013-06-18 20:42:14 +07:00
|
|
|
AC_VERB_SET_CONNECT_SEL,
|
2013-09-22 07:34:45 +07:00
|
|
|
cvt_idx);
|
|
|
|
break;
|
|
|
|
}
|
2013-06-18 20:42:14 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HDA PCM callbacks
|
|
|
|
*/
|
|
|
|
static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
int pin_idx, cvt_idx, mux_idx = 0;
|
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
|
|
|
struct hdmi_eld *eld;
|
|
|
|
struct hdmi_spec_per_cvt *per_cvt = NULL;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* Validate hinfo */
|
2014-02-25 18:21:03 +07:00
|
|
|
pin_idx = hinfo_to_pin_index(codec, hinfo);
|
2013-06-18 20:42:14 +07:00
|
|
|
if (snd_BUG_ON(pin_idx < 0))
|
|
|
|
return -EINVAL;
|
|
|
|
per_pin = get_pin(spec, pin_idx);
|
|
|
|
eld = &per_pin->sink_eld;
|
|
|
|
|
|
|
|
err = hdmi_choose_cvt(codec, pin_idx, &cvt_idx, &mux_idx);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
per_cvt = get_cvt(spec, cvt_idx);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
/* Claim converter */
|
|
|
|
per_cvt->assigned = 1;
|
ALSA: hda - hdmi: Fix programmed active channel count
Currently the converter channel count is set to the number of actual
input channels. The audio infoframe channel count field is set
similarly.
However, sometimes the used channel map does not map all input channels
to outputs. Notably, 3 channel modes (e.g. 2.1) require a dummy input
channel so there are 4 input channels. According to the HDA
specification, converter channel count should be programmed according to
the number of _active_ channels.
On Intel HDMI codecs (but not on NVIDIA), setting the converter channel
to a higher value than there are actually mapped channels to HDMI slots
will cause no audio to be output at all.
Note that the effects of this issue are currently partially masked by
other bugs that prevent the driver from actually unmapping channels in
certain cases. For example, if a 4 channel stream is first created and
prepared, it gets a FL,FR,RL,RR mapping (ALSA->HDMI slot mapping 0->0,
1->1, 2->4, 3->5). If one thereafter assigns a FR,FL,FC mapping to it,
the driver will remap 2->3 but fail to unmap 2->4 and 3->5, so there are
still 4 active channels and the issue will not trigger in this case.
These bugs will be fixed separately.
Fix the channel counts in the converter channel count field and in the
audio infoframe channel count field to match the actual number of active
channels.
Signed-off-by: Anssi Hannula <anssi.hannula@iki.fi>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-10-05 06:25:40 +07:00
|
|
|
per_pin->cvt_nid = per_cvt->cvt_nid;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hinfo->nid = per_cvt->cvt_nid;
|
|
|
|
|
2013-06-18 21:14:22 +07:00
|
|
|
snd_hda_codec_write_cache(codec, per_pin->pin_nid, 0,
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
AC_VERB_SET_CONNECT_SEL,
|
|
|
|
mux_idx);
|
2013-06-18 20:42:14 +07:00
|
|
|
|
|
|
|
/* configure unused pins to choose other converters */
|
2014-08-19 15:20:12 +07:00
|
|
|
if (is_haswell_plus(codec) || is_valleyview_plus(codec))
|
2013-11-04 13:13:13 +07:00
|
|
|
intel_not_share_assigned_cvt(codec, per_pin->pin_nid, mux_idx);
|
2013-06-18 20:42:14 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
snd_hda_spdif_ctls_assign(codec, pin_idx, per_cvt->cvt_nid);
|
2010-08-13 13:45:23 +07:00
|
|
|
|
2011-06-02 00:14:20 +07:00
|
|
|
/* Initially set the converter's capabilities */
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hinfo->channels_min = per_cvt->channels_min;
|
|
|
|
hinfo->channels_max = per_cvt->channels_max;
|
|
|
|
hinfo->rates = per_cvt->rates;
|
|
|
|
hinfo->formats = per_cvt->formats;
|
|
|
|
hinfo->maxbps = per_cvt->maxbps;
|
2011-06-02 00:14:20 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
/* Restrict capabilities by ELD if this isn't disabled */
|
2011-06-02 00:14:16 +07:00
|
|
|
if (!static_hdmi_pcm && eld->eld_valid) {
|
2013-02-19 22:11:24 +07:00
|
|
|
snd_hdmi_eld_update_pcm_info(&eld->info, hinfo);
|
2010-08-13 13:45:23 +07:00
|
|
|
if (hinfo->channels_min > hinfo->channels_max ||
|
2013-02-01 20:01:27 +07:00
|
|
|
!hinfo->rates || !hinfo->formats) {
|
|
|
|
per_cvt->assigned = 0;
|
|
|
|
hinfo->nid = 0;
|
|
|
|
snd_hda_spdif_ctls_unassign(codec, pin_idx);
|
2010-08-13 13:45:23 +07:00
|
|
|
return -ENODEV;
|
2013-02-01 20:01:27 +07:00
|
|
|
}
|
2010-08-13 13:45:23 +07:00
|
|
|
}
|
2011-06-02 00:14:20 +07:00
|
|
|
|
|
|
|
/* Store the updated parameters */
|
2011-01-14 16:30:46 +07:00
|
|
|
runtime->hw.channels_min = hinfo->channels_min;
|
|
|
|
runtime->hw.channels_max = hinfo->channels_max;
|
|
|
|
runtime->hw.formats = hinfo->formats;
|
|
|
|
runtime->hw.rates = hinfo->rates;
|
2011-01-14 16:33:26 +07:00
|
|
|
|
|
|
|
snd_pcm_hw_constraint_step(substream->runtime, 0,
|
|
|
|
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
|
2010-08-13 13:45:23 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
/*
|
|
|
|
* HDA/HDMI auto parsing
|
|
|
|
*/
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
static int hdmi_read_pin_conn(struct hda_codec *codec, int pin_idx)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_warn(codec,
|
|
|
|
"HDMI: pin %d wcaps %#x does not support connection list\n",
|
2010-03-08 09:44:23 +07:00
|
|
|
pin_nid, get_wcaps(codec, pin_nid));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
per_pin->num_mux_nids = snd_hda_get_connections(codec, pin_nid,
|
|
|
|
per_pin->mux_nids,
|
|
|
|
HDA_MAX_CONNECTIONS);
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-07 19:38:23 +07:00
|
|
|
static bool hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
2013-11-07 19:38:25 +07:00
|
|
|
struct hda_jack_tbl *jack;
|
2011-11-16 15:29:47 +07:00
|
|
|
struct hda_codec *codec = per_pin->codec;
|
2013-02-19 22:11:25 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
struct hdmi_eld *eld = &spec->temp_eld;
|
|
|
|
struct hdmi_eld *pin_eld = &per_pin->sink_eld;
|
2011-11-16 15:29:47 +07:00
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
ALSA: HDA: Unify HDMI hotplug handling.
This change unifies the initial handling of a pin's state with the code to
update a pin's state after a hotplug (unsolicited response) event. The
initial probing, and all updates, are now routed through hdmi_present_sense.
The stored PD and ELDV status is now always derived from GetPinSense verb
execution, and not from the data in the unsolicited response. This means:
a) The WAR for NVIDIA codec's UR.PD values ("old_pin_detect") can be
removed, since this only affected the no-longer-used unsolicited
response payload.
b) In turn, this means that most NVIDIA codecs can simply use
patch_generic_hdmi instead of having a custom variant just to set
old_pin_detect.
c) When PD && ELDV becomes true, no extra verbs are executed, because the
GetPinSense that was previously executed by snd_hdmi_get_eld (really,
hdmi_eld_valid) has simply moved into hdmi_present_sense.
d) When PD && ELDV becomes false, there is a single extra GetPinSense verb
executed for codecs where old_pin_detect wasn't set, i.e. some NVIDIA,
and all ATI/AMD and Intel codecs. I doubt this will be a performance
issue.
The new unified code in hdmi_present_sense also ensures that eld->eld_valid
is not set unless eld->monitor_present is also set. This protects against
potential invalid combinations of PD and ELDV received from HW, and
transitively from a graphics driver.
Also, print the derived PD/ELDV bits from hdmi_present_sense so the kernel
log always displays the actual state stored, which will differ from the
values in the unsolicited response for NVIDIA HW where old_pin_detect was
previously set.
Finally, a couple of small tweaks originally by Takashi:
* Clear the ELD content to zero before reading it, so that if it's not
read (i.e. when !(PD && ELDV)) it's in a known state.
* Don't show ELD fields in /proc ELD files when the ELD isn't valid.
The only possibility I can see for regression here is a codec where the
GetPinSense verb returns incorrect data. However, we're already exposed
to that, since that data is used (a) from hdmi_add_pin to set up the
initial pin state, and (b) within snd_hda_input_jack_report to query
a pin's presence value. As such, I don't believe any HW has bugs here.
Includes-changes-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-05-25 06:11:17 +07:00
|
|
|
/*
|
|
|
|
* Always execute a GetPinSense verb here, even when called from
|
|
|
|
* hdmi_intrinsic_event; for some NVIDIA HW, the unsolicited
|
|
|
|
* response's PD bit is not the real PD value, but indicates that
|
|
|
|
* the real PD value changed. An older version of the HD-audio
|
|
|
|
* specification worked this way. Hence, we just ignore the data in
|
|
|
|
* the unsolicited response to avoid custom WARs.
|
|
|
|
*/
|
2013-12-18 16:46:04 +07:00
|
|
|
int present;
|
2013-02-19 22:11:25 +07:00
|
|
|
bool update_eld = false;
|
|
|
|
bool eld_changed = false;
|
2013-11-07 19:38:23 +07:00
|
|
|
bool ret;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda - Work around races of power up/down with runtime PM
Currently, snd_hdac_power_up()/down() helpers checks whether the codec
is being in pm (suspend/resume), and skips the call of runtime get/put
during it. This is needed as there are lots of power up/down
sequences called in the paths that are also used in the PM itself. An
example is found in hda_codec.c::codec_exec_verb(), where this can
power up the codec while it may be called again in its power up
sequence, too.
The above works in most cases, but sometimes we really want to wait
for the real power up. For example, the control element get/put may
want explicit power up so that the value change is assured to reach to
the hardware. Using the current snd_hdac_power_up(), however,
results in a race, e.g. when it's called during the runtime suspend is
being performed. In the worst case, as found in patch_ca0132.c, it
can even lead to the deadlock because the code assumes the power up
while it was skipped due to the check above.
For dealing with such cases, this patch makes snd_hdac_power_up() and
_down() to two variants: with and without in_pm flag check. The
version with pm flag check is named as snd_hdac_power_up_pm() while
the version without pm flag check is still kept as
snd_hdac_power_up(). (Just because the usage of the former is fewer.)
Then finally, the patch replaces each call potentially done in PM with
the new _pm() variant.
In theory, we can implement a unified version -- if we can distinguish
the current context whether it's in the pm path. But such an
implementation is cumbersome, so leave the code like this a bit messy
way for now...
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=96271
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-04-08 16:43:14 +07:00
|
|
|
snd_hda_power_up_pm(codec);
|
2013-12-18 16:46:04 +07:00
|
|
|
present = snd_hda_pin_sense(codec, pin_nid);
|
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2013-02-19 22:11:25 +07:00
|
|
|
pin_eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE);
|
|
|
|
if (pin_eld->monitor_present)
|
|
|
|
eld->eld_valid = !!(present & AC_PINSENSE_ELDV);
|
|
|
|
else
|
|
|
|
eld->eld_valid = false;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
"HDMI status: Codec=%d Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
|
2013-03-28 16:21:28 +07:00
|
|
|
codec->addr, pin_nid, pin_eld->monitor_present, eld->eld_valid);
|
ALSA: HDA: Unify HDMI hotplug handling.
This change unifies the initial handling of a pin's state with the code to
update a pin's state after a hotplug (unsolicited response) event. The
initial probing, and all updates, are now routed through hdmi_present_sense.
The stored PD and ELDV status is now always derived from GetPinSense verb
execution, and not from the data in the unsolicited response. This means:
a) The WAR for NVIDIA codec's UR.PD values ("old_pin_detect") can be
removed, since this only affected the no-longer-used unsolicited
response payload.
b) In turn, this means that most NVIDIA codecs can simply use
patch_generic_hdmi instead of having a custom variant just to set
old_pin_detect.
c) When PD && ELDV becomes true, no extra verbs are executed, because the
GetPinSense that was previously executed by snd_hdmi_get_eld (really,
hdmi_eld_valid) has simply moved into hdmi_present_sense.
d) When PD && ELDV becomes false, there is a single extra GetPinSense verb
executed for codecs where old_pin_detect wasn't set, i.e. some NVIDIA,
and all ATI/AMD and Intel codecs. I doubt this will be a performance
issue.
The new unified code in hdmi_present_sense also ensures that eld->eld_valid
is not set unless eld->monitor_present is also set. This protects against
potential invalid combinations of PD and ELDV received from HW, and
transitively from a graphics driver.
Also, print the derived PD/ELDV bits from hdmi_present_sense so the kernel
log always displays the actual state stored, which will differ from the
values in the unsolicited response for NVIDIA HW where old_pin_detect was
previously set.
Finally, a couple of small tweaks originally by Takashi:
* Clear the ELD content to zero before reading it, so that if it's not
read (i.e. when !(PD && ELDV)) it's in a known state.
* Don't show ELD fields in /proc ELD files when the ELD isn't valid.
The only possibility I can see for regression here is a codec where the
GetPinSense verb returns incorrect data. However, we're already exposed
to that, since that data is used (a) from hdmi_add_pin to set up the
initial pin state, and (b) within snd_hda_input_jack_report to query
a pin's presence value. As such, I don't believe any HW has bugs here.
Includes-changes-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-05-25 06:11:17 +07:00
|
|
|
|
2013-02-19 22:11:25 +07:00
|
|
|
if (eld->eld_valid) {
|
2013-10-25 01:10:34 +07:00
|
|
|
if (spec->ops.pin_get_eld(codec, pin_nid, eld->eld_buffer,
|
2013-02-19 22:11:24 +07:00
|
|
|
&eld->eld_size) < 0)
|
2013-02-19 22:11:25 +07:00
|
|
|
eld->eld_valid = false;
|
2013-02-19 22:11:24 +07:00
|
|
|
else {
|
|
|
|
memset(&eld->info, 0, sizeof(struct parsed_hdmi_eld));
|
2014-06-06 23:04:34 +07:00
|
|
|
if (snd_hdmi_parse_eld(codec, &eld->info, eld->eld_buffer,
|
2013-02-19 22:11:24 +07:00
|
|
|
eld->eld_size) < 0)
|
2013-02-19 22:11:25 +07:00
|
|
|
eld->eld_valid = false;
|
2013-02-19 22:11:24 +07:00
|
|
|
}
|
|
|
|
|
2013-02-19 22:11:25 +07:00
|
|
|
if (eld->eld_valid) {
|
2014-06-06 23:04:34 +07:00
|
|
|
snd_hdmi_show_eld(codec, &eld->info);
|
2013-02-19 22:11:25 +07:00
|
|
|
update_eld = true;
|
2013-02-19 22:11:24 +07:00
|
|
|
}
|
2011-11-19 05:59:32 +07:00
|
|
|
else if (repoll) {
|
2015-02-28 04:43:26 +07:00
|
|
|
schedule_delayed_work(&per_pin->work,
|
|
|
|
msecs_to_jiffies(300));
|
2013-10-17 23:03:24 +07:00
|
|
|
goto unlock;
|
2011-11-16 15:29:47 +07:00
|
|
|
}
|
|
|
|
}
|
2013-02-19 22:11:25 +07:00
|
|
|
|
2014-10-19 23:25:19 +07:00
|
|
|
if (pin_eld->eld_valid != eld->eld_valid)
|
2013-02-19 22:11:26 +07:00
|
|
|
eld_changed = true;
|
2014-10-19 23:25:19 +07:00
|
|
|
|
|
|
|
if (pin_eld->eld_valid && !eld->eld_valid)
|
|
|
|
update_eld = true;
|
|
|
|
|
2013-02-19 22:11:25 +07:00
|
|
|
if (update_eld) {
|
2013-09-02 17:33:02 +07:00
|
|
|
bool old_eld_valid = pin_eld->eld_valid;
|
2013-02-19 22:11:25 +07:00
|
|
|
pin_eld->eld_valid = eld->eld_valid;
|
2014-10-19 23:25:19 +07:00
|
|
|
if (pin_eld->eld_size != eld->eld_size ||
|
2013-02-19 22:11:26 +07:00
|
|
|
memcmp(pin_eld->eld_buffer, eld->eld_buffer,
|
2014-10-19 23:25:19 +07:00
|
|
|
eld->eld_size) != 0) {
|
2013-02-19 22:11:25 +07:00
|
|
|
memcpy(pin_eld->eld_buffer, eld->eld_buffer,
|
|
|
|
eld->eld_size);
|
2014-10-19 23:25:19 +07:00
|
|
|
eld_changed = true;
|
|
|
|
}
|
2013-02-19 22:11:25 +07:00
|
|
|
pin_eld->eld_size = eld->eld_size;
|
|
|
|
pin_eld->info = eld->info;
|
2013-09-02 17:33:02 +07:00
|
|
|
|
2013-10-25 05:45:18 +07:00
|
|
|
/*
|
|
|
|
* Re-setup pin and infoframe. This is needed e.g. when
|
|
|
|
* - sink is first plugged-in (infoframe is not set up if !monitor_present)
|
|
|
|
* - transcoder can change during stream playback on Haswell
|
2014-06-12 13:42:25 +07:00
|
|
|
* and this can make HW reset converter selection on a pin.
|
2013-09-02 17:33:02 +07:00
|
|
|
*/
|
2014-06-12 13:42:25 +07:00
|
|
|
if (eld->eld_valid && !old_eld_valid && per_pin->setup) {
|
2014-08-19 15:20:12 +07:00
|
|
|
if (is_haswell_plus(codec) ||
|
|
|
|
is_valleyview_plus(codec)) {
|
2014-06-12 13:42:25 +07:00
|
|
|
intel_verify_pin_cvt_connect(codec, per_pin);
|
|
|
|
intel_not_share_assigned_cvt(codec, pin_nid,
|
|
|
|
per_pin->mux_idx);
|
|
|
|
}
|
|
|
|
|
2013-09-02 17:33:02 +07:00
|
|
|
hdmi_setup_audio_infoframe(codec, per_pin,
|
|
|
|
per_pin->non_pcm);
|
2014-06-12 13:42:25 +07:00
|
|
|
}
|
2013-02-19 22:11:25 +07:00
|
|
|
}
|
2013-02-19 22:11:26 +07:00
|
|
|
|
|
|
|
if (eld_changed)
|
2015-02-27 22:09:22 +07:00
|
|
|
snd_ctl_notify(codec->card,
|
2013-02-19 22:11:26 +07:00
|
|
|
SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
|
|
|
|
&per_pin->eld_ctl->id);
|
2013-10-17 23:03:24 +07:00
|
|
|
unlock:
|
2013-11-07 22:39:37 +07:00
|
|
|
ret = !repoll || !pin_eld->monitor_present || pin_eld->eld_valid;
|
2013-11-07 19:38:25 +07:00
|
|
|
|
|
|
|
jack = snd_hda_jack_tbl_get(codec, pin_nid);
|
|
|
|
if (jack)
|
|
|
|
jack->block_report = !ret;
|
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
ALSA: hda - Work around races of power up/down with runtime PM
Currently, snd_hdac_power_up()/down() helpers checks whether the codec
is being in pm (suspend/resume), and skips the call of runtime get/put
during it. This is needed as there are lots of power up/down
sequences called in the paths that are also used in the PM itself. An
example is found in hda_codec.c::codec_exec_verb(), where this can
power up the codec while it may be called again in its power up
sequence, too.
The above works in most cases, but sometimes we really want to wait
for the real power up. For example, the control element get/put may
want explicit power up so that the value change is assured to reach to
the hardware. Using the current snd_hdac_power_up(), however,
results in a race, e.g. when it's called during the runtime suspend is
being performed. In the worst case, as found in patch_ca0132.c, it
can even lead to the deadlock because the code assumes the power up
while it was skipped due to the check above.
For dealing with such cases, this patch makes snd_hdac_power_up() and
_down() to two variants: with and without in_pm flag check. The
version with pm flag check is named as snd_hdac_power_up_pm() while
the version without pm flag check is still kept as
snd_hdac_power_up(). (Just because the usage of the former is fewer.)
Then finally, the patch replaces each call potentially done in PM with
the new _pm() variant.
In theory, we can implement a unified version -- if we can distinguish
the current context whether it's in the pm path. But such an
implementation is cumbersome, so leave the code like this a bit messy
way for now...
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=96271
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-04-08 16:43:14 +07:00
|
|
|
snd_hda_power_down_pm(codec);
|
2013-11-07 19:38:23 +07:00
|
|
|
return ret;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
2011-11-16 15:29:47 +07:00
|
|
|
static void hdmi_repoll_eld(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hdmi_spec_per_pin *per_pin =
|
|
|
|
container_of(to_delayed_work(work), struct hdmi_spec_per_pin, work);
|
|
|
|
|
2011-11-19 05:59:32 +07:00
|
|
|
if (per_pin->repoll_count++ > 6)
|
|
|
|
per_pin->repoll_count = 0;
|
|
|
|
|
2013-11-07 19:38:23 +07:00
|
|
|
if (hdmi_present_sense(per_pin, per_pin->repoll_count))
|
|
|
|
snd_hda_jack_report_sync(per_pin->codec);
|
2011-11-16 15:29:47 +07:00
|
|
|
}
|
|
|
|
|
2013-02-09 05:10:04 +07:00
|
|
|
static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid);
|
|
|
|
|
2010-03-08 09:44:23 +07:00
|
|
|
static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
unsigned int caps, config;
|
|
|
|
int pin_idx;
|
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
2011-05-19 16:46:03 +07:00
|
|
|
int err;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
2012-11-21 20:27:37 +07:00
|
|
|
caps = snd_hda_query_pin_caps(codec, pin_nid);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
|
|
|
|
return 0;
|
|
|
|
|
2012-11-21 20:27:37 +07:00
|
|
|
config = snd_hda_codec_get_pincfg(codec, pin_nid);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (get_defcfg_connect(config) == AC_JACK_PORT_NONE)
|
|
|
|
return 0;
|
|
|
|
|
2014-01-09 03:55:32 +07:00
|
|
|
if (is_haswell_plus(codec))
|
2013-02-09 05:10:04 +07:00
|
|
|
intel_haswell_fixup_connect_list(codec, pin_nid);
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
pin_idx = spec->num_pins;
|
2013-03-13 20:40:31 +07:00
|
|
|
per_pin = snd_array_new(&spec->pins);
|
|
|
|
if (!per_pin)
|
|
|
|
return -ENOMEM;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
per_pin->pin_nid = pin_nid;
|
2012-09-06 22:42:08 +07:00
|
|
|
per_pin->non_pcm = false;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
err = hdmi_read_pin_conn(codec, pin_idx);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
spec->num_pins++;
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return 0;
|
2010-03-08 09:44:23 +07:00
|
|
|
}
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t cvt_nid)
|
2010-03-08 09:44:23 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
|
|
|
unsigned int chans;
|
|
|
|
int err;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
chans = get_wcaps(codec, cvt_nid);
|
|
|
|
chans = get_wcaps_channels(chans);
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = snd_array_new(&spec->cvts);
|
|
|
|
if (!per_cvt)
|
|
|
|
return -ENOMEM;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
per_cvt->cvt_nid = cvt_nid;
|
|
|
|
per_cvt->channels_min = 2;
|
2012-07-31 16:36:00 +07:00
|
|
|
if (chans <= 16) {
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
per_cvt->channels_max = chans;
|
2012-07-31 16:36:00 +07:00
|
|
|
if (chans > spec->channels_max)
|
|
|
|
spec->channels_max = chans;
|
|
|
|
}
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
err = snd_hda_query_supported_pcm(codec, cvt_nid,
|
|
|
|
&per_cvt->rates,
|
|
|
|
&per_cvt->formats,
|
|
|
|
&per_cvt->maxbps);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
if (spec->num_cvts < ARRAY_SIZE(spec->cvt_nids))
|
|
|
|
spec->cvt_nids[spec->num_cvts] = cvt_nid;
|
|
|
|
spec->num_cvts++;
|
2010-03-08 09:44:23 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_parse_codec(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
hda_nid_t nid;
|
|
|
|
int i, nodes;
|
|
|
|
|
2015-03-03 16:07:24 +07:00
|
|
|
nodes = snd_hda_get_sub_nodes(codec, codec->core.afg, &nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
if (!nid || nodes < 0) {
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_warn(codec, "HDMI: failed to get afg sub nodes\n");
|
2010-03-08 09:44:23 +07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nodes; i++, nid++) {
|
|
|
|
unsigned int caps;
|
|
|
|
unsigned int type;
|
|
|
|
|
2012-11-21 20:27:37 +07:00
|
|
|
caps = get_wcaps(codec, nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
type = get_wcaps_type(caps);
|
|
|
|
|
|
|
|
if (!(caps & AC_WCAP_DIGITAL))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case AC_WID_AUD_OUT:
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hdmi_add_cvt(codec, nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
break;
|
|
|
|
case AC_WID_PIN:
|
2010-05-14 15:36:15 +07:00
|
|
|
hdmi_add_pin(codec, nid);
|
2010-03-08 09:44:23 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
/*
|
|
|
|
*/
|
2012-09-06 22:42:08 +07:00
|
|
|
static bool check_non_pcm_per_cvt(struct hda_codec *codec, hda_nid_t cvt_nid)
|
|
|
|
{
|
|
|
|
struct hda_spdif_out *spdif;
|
|
|
|
bool non_pcm;
|
|
|
|
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
spdif = snd_hda_spdif_out_of_nid(codec, cvt_nid);
|
|
|
|
non_pcm = !!(spdif->status & IEC958_AES0_NONAUDIO);
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
return non_pcm;
|
|
|
|
}
|
|
|
|
|
2015-09-02 13:11:40 +07:00
|
|
|
/* There is a fixed mapping between audio pin node and display port
|
|
|
|
* on current Intel platforms:
|
|
|
|
* Pin Widget 5 - PORT B (port = 1 in i915 driver)
|
|
|
|
* Pin Widget 6 - PORT C (port = 2 in i915 driver)
|
|
|
|
* Pin Widget 7 - PORT D (port = 3 in i915 driver)
|
|
|
|
*/
|
|
|
|
static int intel_pin2port(hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
return pin_nid - 4;
|
|
|
|
}
|
2012-09-06 22:42:08 +07:00
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
/*
|
|
|
|
* HDMI callbacks
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
hda_nid_t cvt_nid = hinfo->nid;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2014-02-25 18:21:03 +07:00
|
|
|
int pin_idx = hinfo_to_pin_index(codec, hinfo);
|
2013-09-02 17:33:02 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
2015-09-02 13:11:40 +07:00
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
struct i915_audio_component *acomp = codec->bus->core.audio_component;
|
2012-09-06 22:42:08 +07:00
|
|
|
bool non_pcm;
|
2014-01-31 01:52:16 +07:00
|
|
|
int pinctl;
|
2012-09-06 22:42:08 +07:00
|
|
|
|
2014-08-19 15:20:12 +07:00
|
|
|
if (is_haswell_plus(codec) || is_valleyview_plus(codec)) {
|
2014-03-20 12:01:06 +07:00
|
|
|
/* Verify pin:cvt selections to avoid silent audio after S3.
|
|
|
|
* After S3, the audio driver restores pin:cvt selections
|
|
|
|
* but this can happen before gfx is ready and such selection
|
|
|
|
* is overlooked by HW. Thus multiple pins can share a same
|
|
|
|
* default convertor and mute control will affect each other,
|
|
|
|
* which can cause a resumed audio playback become silent
|
|
|
|
* after S3.
|
|
|
|
*/
|
|
|
|
intel_verify_pin_cvt_connect(codec, per_pin);
|
|
|
|
intel_not_share_assigned_cvt(codec, pin_nid, per_pin->mux_idx);
|
|
|
|
}
|
|
|
|
|
2015-09-02 13:11:40 +07:00
|
|
|
/* Call sync_audio_rate to set the N/CTS/M manually if necessary */
|
|
|
|
/* Todo: add DP1.2 MST audio support later */
|
|
|
|
if (acomp && acomp->ops && acomp->ops->sync_audio_rate)
|
|
|
|
acomp->ops->sync_audio_rate(acomp->dev,
|
|
|
|
intel_pin2port(pin_nid),
|
|
|
|
runtime->rate);
|
|
|
|
|
2012-09-06 22:42:08 +07:00
|
|
|
non_pcm = check_non_pcm_per_cvt(codec, cvt_nid);
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2013-09-02 17:33:02 +07:00
|
|
|
per_pin->channels = substream->runtime->channels;
|
|
|
|
per_pin->setup = true;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
2013-09-02 17:33:02 +07:00
|
|
|
hdmi_setup_audio_infoframe(codec, per_pin, non_pcm);
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2014-01-31 01:52:16 +07:00
|
|
|
if (spec->dyn_pin_out) {
|
|
|
|
pinctl = snd_hda_codec_read(codec, pin_nid, 0,
|
|
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
|
|
|
|
snd_hda_codec_write(codec, pin_nid, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
|
|
pinctl | PIN_OUT);
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
return spec->ops.setup_stream(codec, cvt_nid, pin_nid, stream_tag, format);
|
2010-09-07 17:27:25 +07:00
|
|
|
}
|
|
|
|
|
2012-08-06 19:49:36 +07:00
|
|
|
static int generic_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
snd_hda_codec_cleanup_stream(codec, hinfo->nid);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-26 23:08:14 +07:00
|
|
|
static int hdmi_pcm_close(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int cvt_idx, pin_idx;
|
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
2014-01-31 01:52:16 +07:00
|
|
|
int pinctl;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
if (hinfo->nid) {
|
2014-02-25 18:21:03 +07:00
|
|
|
cvt_idx = cvt_nid_to_cvt_index(codec, hinfo->nid);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (snd_BUG_ON(cvt_idx < 0))
|
|
|
|
return -EINVAL;
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = get_cvt(spec, cvt_idx);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
|
|
|
snd_BUG_ON(!per_cvt->assigned);
|
|
|
|
per_cvt->assigned = 0;
|
|
|
|
hinfo->nid = 0;
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
pin_idx = hinfo_to_pin_index(codec, hinfo);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
if (snd_BUG_ON(pin_idx < 0))
|
|
|
|
return -EINVAL;
|
2013-03-13 20:40:31 +07:00
|
|
|
per_pin = get_pin(spec, pin_idx);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
2014-01-31 01:52:16 +07:00
|
|
|
if (spec->dyn_pin_out) {
|
|
|
|
pinctl = snd_hda_codec_read(codec, per_pin->pin_nid, 0,
|
|
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
|
|
|
|
snd_hda_codec_write(codec, per_pin->pin_nid, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
|
|
pinctl & ~PIN_OUT);
|
|
|
|
}
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
snd_hda_spdif_ctls_unassign(codec, pin_idx);
|
2013-10-17 23:03:24 +07:00
|
|
|
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2012-07-31 16:36:00 +07:00
|
|
|
per_pin->chmap_set = false;
|
|
|
|
memset(per_pin->chmap, 0, sizeof(per_pin->chmap));
|
2013-09-02 17:33:02 +07:00
|
|
|
|
|
|
|
per_pin->setup = false;
|
|
|
|
per_pin->channels = 0;
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
}
|
2012-07-31 16:36:00 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct hda_pcm_ops generic_ops = {
|
|
|
|
.open = hdmi_pcm_open,
|
2012-07-26 23:08:14 +07:00
|
|
|
.close = hdmi_pcm_close,
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
.prepare = generic_hdmi_playback_pcm_prepare,
|
2012-08-06 19:49:36 +07:00
|
|
|
.cleanup = generic_hdmi_playback_pcm_cleanup,
|
2010-09-07 17:27:25 +07:00
|
|
|
};
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
/*
|
|
|
|
* ALSA API channel-map control callbacks
|
|
|
|
*/
|
|
|
|
static int hdmi_chmap_ctl_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_codec *codec = info->private_data;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = spec->channels_max;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = SNDRV_CHMAP_LAST;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
static int hdmi_chmap_cea_alloc_validate_get_type(struct cea_channel_speaker_allocation *cap,
|
|
|
|
int channels)
|
|
|
|
{
|
|
|
|
/* If the speaker allocation matches the channel count, it is OK.*/
|
|
|
|
if (cap->channels != channels)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* all channels are remappable freely */
|
|
|
|
return SNDRV_CTL_TLVT_CHMAP_VAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_cea_alloc_to_tlv_chmap(struct cea_channel_speaker_allocation *cap,
|
|
|
|
unsigned int *chmap, int channels)
|
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
int c;
|
|
|
|
|
|
|
|
for (c = 7; c >= 0; c--) {
|
|
|
|
int spk = cap->speakers[c];
|
|
|
|
if (!spk)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
chmap[count++] = spk_to_chmap(spk);
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(count != channels);
|
|
|
|
}
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
static int hdmi_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
unsigned int size, unsigned int __user *tlv)
|
|
|
|
{
|
|
|
|
struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_codec *codec = info->private_data;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
unsigned int __user *dst;
|
|
|
|
int chs, count = 0;
|
|
|
|
|
|
|
|
if (size < 8)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv))
|
|
|
|
return -EFAULT;
|
|
|
|
size -= 8;
|
|
|
|
dst = tlv + 2;
|
2012-09-10 21:08:40 +07:00
|
|
|
for (chs = 2; chs <= spec->channels_max; chs++) {
|
2013-10-25 01:10:34 +07:00
|
|
|
int i;
|
2012-07-31 16:36:00 +07:00
|
|
|
struct cea_channel_speaker_allocation *cap;
|
|
|
|
cap = channel_allocations;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(channel_allocations); i++, cap++) {
|
|
|
|
int chs_bytes = chs * 4;
|
2013-10-25 01:10:34 +07:00
|
|
|
int type = spec->ops.chmap_cea_alloc_validate_get_type(cap, chs);
|
|
|
|
unsigned int tlv_chmap[8];
|
|
|
|
|
|
|
|
if (type < 0)
|
2012-07-31 16:36:00 +07:00
|
|
|
continue;
|
|
|
|
if (size < 8)
|
|
|
|
return -ENOMEM;
|
2013-10-25 01:10:34 +07:00
|
|
|
if (put_user(type, dst) ||
|
2012-07-31 16:36:00 +07:00
|
|
|
put_user(chs_bytes, dst + 1))
|
|
|
|
return -EFAULT;
|
|
|
|
dst += 2;
|
|
|
|
size -= 8;
|
|
|
|
count += 8;
|
|
|
|
if (size < chs_bytes)
|
|
|
|
return -ENOMEM;
|
|
|
|
size -= chs_bytes;
|
|
|
|
count += chs_bytes;
|
2013-10-25 01:10:34 +07:00
|
|
|
spec->ops.cea_alloc_to_tlv_chmap(cap, tlv_chmap, chs);
|
|
|
|
if (copy_to_user(dst, tlv_chmap, chs_bytes))
|
|
|
|
return -EFAULT;
|
|
|
|
dst += chs;
|
2012-07-31 16:36:00 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (put_user(count, tlv + 1))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_chmap_ctl_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_codec *codec = info->private_data;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int pin_idx = kcontrol->private_value;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2012-07-31 16:36:00 +07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(per_pin->chmap); i++)
|
|
|
|
ucontrol->value.integer.value[i] = per_pin->chmap[i];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_chmap_ctl_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_codec *codec = info->private_data;
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int pin_idx = kcontrol->private_value;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2012-07-31 16:36:00 +07:00
|
|
|
unsigned int ctl_idx;
|
|
|
|
struct snd_pcm_substream *substream;
|
|
|
|
unsigned char chmap[8];
|
2013-10-25 01:10:34 +07:00
|
|
|
int i, err, ca, prepared = 0;
|
2012-07-31 16:36:00 +07:00
|
|
|
|
|
|
|
ctl_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
|
|
|
|
substream = snd_pcm_chmap_substream(info, ctl_idx);
|
|
|
|
if (!substream || !substream->runtime)
|
2013-01-15 20:44:41 +07:00
|
|
|
return 0; /* just for avoiding error from alsactl restore */
|
2012-07-31 16:36:00 +07:00
|
|
|
switch (substream->runtime->status->state) {
|
|
|
|
case SNDRV_PCM_STATE_OPEN:
|
|
|
|
case SNDRV_PCM_STATE_SETUP:
|
|
|
|
break;
|
|
|
|
case SNDRV_PCM_STATE_PREPARED:
|
|
|
|
prepared = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
memset(chmap, 0, sizeof(chmap));
|
|
|
|
for (i = 0; i < ARRAY_SIZE(chmap); i++)
|
|
|
|
chmap[i] = ucontrol->value.integer.value[i];
|
|
|
|
if (!memcmp(chmap, per_pin->chmap, sizeof(chmap)))
|
|
|
|
return 0;
|
|
|
|
ca = hdmi_manual_channel_allocation(ARRAY_SIZE(chmap), chmap);
|
|
|
|
if (ca < 0)
|
|
|
|
return -EINVAL;
|
2013-10-25 01:10:34 +07:00
|
|
|
if (spec->ops.chmap_validate) {
|
|
|
|
err = spec->ops.chmap_validate(ca, ARRAY_SIZE(chmap), chmap);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_lock(&per_pin->lock);
|
2012-07-31 16:36:00 +07:00
|
|
|
per_pin->chmap_set = true;
|
|
|
|
memcpy(per_pin->chmap, chmap, sizeof(chmap));
|
|
|
|
if (prepared)
|
2013-09-02 17:33:02 +07:00
|
|
|
hdmi_setup_audio_infoframe(codec, per_pin, per_pin->non_pcm);
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_unlock(&per_pin->lock);
|
2012-07-31 16:36:00 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int generic_hdmi_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
2010-09-07 17:27:25 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
|
|
|
struct hda_pcm *info;
|
2010-09-07 17:27:25 +07:00
|
|
|
struct hda_pcm_stream *pstr;
|
2013-03-13 20:40:31 +07:00
|
|
|
|
2015-02-27 23:43:19 +07:00
|
|
|
info = snd_hda_codec_pcm_new(codec, "HDMI %d", pin_idx);
|
2013-03-13 20:40:31 +07:00
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
2015-02-27 23:43:19 +07:00
|
|
|
spec->pcm_rec[pin_idx] = info;
|
2010-09-07 17:27:25 +07:00
|
|
|
info->pcm_type = HDA_PCM_TYPE_HDMI;
|
2012-07-31 16:36:00 +07:00
|
|
|
info->own_chmap = true;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
pstr->substreams = 1;
|
|
|
|
pstr->ops = generic_ops;
|
|
|
|
/* other pstr fields are set in open */
|
2010-09-07 17:27:25 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-23 21:56:03 +07:00
|
|
|
static int generic_hdmi_build_jack(struct hda_codec *codec, int pin_idx)
|
|
|
|
{
|
2011-12-01 23:41:36 +07:00
|
|
|
char hdmi_str[32] = "HDMI/DP";
|
2011-08-23 21:56:03 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
|
|
|
int pcmdev = get_pcm_rec(spec, pin_idx)->device;
|
2011-08-23 21:56:03 +07:00
|
|
|
|
2011-12-01 23:41:36 +07:00
|
|
|
if (pcmdev > 0)
|
|
|
|
sprintf(hdmi_str + strlen(hdmi_str), ",pcm=%d", pcmdev);
|
2013-02-22 16:16:28 +07:00
|
|
|
if (!is_jack_detectable(codec, per_pin->pin_nid))
|
|
|
|
strncat(hdmi_str, " Phantom",
|
|
|
|
sizeof(hdmi_str) - strlen(hdmi_str) - 1);
|
2011-08-23 21:56:03 +07:00
|
|
|
|
2015-04-27 20:20:59 +07:00
|
|
|
return snd_hda_jack_add_kctl(codec, per_pin->pin_nid, hdmi_str);
|
2011-08-23 21:56:03 +07:00
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int generic_hdmi_build_controls(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int err;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
2010-09-07 17:27:25 +07:00
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2011-08-23 21:56:03 +07:00
|
|
|
|
|
|
|
err = generic_hdmi_build_jack(codec, pin_idx);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2012-10-12 22:24:51 +07:00
|
|
|
err = snd_hda_create_dig_out_ctls(codec,
|
|
|
|
per_pin->pin_nid,
|
|
|
|
per_pin->mux_nids[0],
|
|
|
|
HDA_PCM_TYPE_HDMI);
|
2010-09-07 17:27:25 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
snd_hda_spdif_ctls_unassign(codec, pin_idx);
|
2011-10-01 04:35:41 +07:00
|
|
|
|
|
|
|
/* add control for ELD Bytes */
|
2013-03-13 20:40:31 +07:00
|
|
|
err = hdmi_create_eld_ctl(codec, pin_idx,
|
|
|
|
get_pcm_rec(spec, pin_idx)->device);
|
2011-10-01 04:35:41 +07:00
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2011-12-01 23:41:36 +07:00
|
|
|
|
2011-12-20 21:53:07 +07:00
|
|
|
hdmi_present_sense(per_pin, 0);
|
2010-09-07 17:27:25 +07:00
|
|
|
}
|
|
|
|
|
2012-07-31 16:36:00 +07:00
|
|
|
/* add channel maps */
|
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
2015-02-27 23:43:19 +07:00
|
|
|
struct hda_pcm *pcm;
|
2012-07-31 16:36:00 +07:00
|
|
|
struct snd_pcm_chmap *chmap;
|
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
int i;
|
2013-08-22 14:55:36 +07:00
|
|
|
|
2015-02-27 23:43:19 +07:00
|
|
|
pcm = spec->pcm_rec[pin_idx];
|
|
|
|
if (!pcm || !pcm->pcm)
|
2013-08-22 14:55:36 +07:00
|
|
|
break;
|
2015-02-27 23:43:19 +07:00
|
|
|
err = snd_pcm_add_chmap_ctls(pcm->pcm,
|
2012-07-31 16:36:00 +07:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
NULL, 0, pin_idx, &chmap);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
/* override handlers */
|
|
|
|
chmap->private_data = codec;
|
|
|
|
kctl = chmap->kctl;
|
|
|
|
for (i = 0; i < kctl->count; i++)
|
|
|
|
kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
|
|
|
|
kctl->info = hdmi_chmap_ctl_info;
|
|
|
|
kctl->get = hdmi_chmap_ctl_get;
|
|
|
|
kctl->put = hdmi_chmap_ctl_put;
|
|
|
|
kctl->tlv.c = hdmi_chmap_ctl_tlv;
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-20 21:32:22 +07:00
|
|
|
static int generic_hdmi_init_per_pins(struct hda_codec *codec)
|
2010-09-07 17:27:25 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
|
|
|
|
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2011-11-16 15:29:47 +07:00
|
|
|
per_pin->codec = codec;
|
2013-10-17 23:21:12 +07:00
|
|
|
mutex_init(&per_pin->lock);
|
2011-11-16 15:29:47 +07:00
|
|
|
INIT_DELAYED_WORK(&per_pin->work, hdmi_repoll_eld);
|
2013-10-17 23:21:12 +07:00
|
|
|
eld_proc_new(per_pin, pin_idx);
|
2010-09-07 17:27:25 +07:00
|
|
|
}
|
2012-06-20 21:32:22 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int generic_hdmi_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int pin_idx;
|
|
|
|
|
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2012-06-20 21:32:22 +07:00
|
|
|
hda_nid_t pin_nid = per_pin->pin_nid;
|
|
|
|
|
|
|
|
hdmi_init_pin(codec, pin_nid);
|
2014-09-11 19:06:53 +07:00
|
|
|
snd_hda_jack_detect_enable_callback(codec, pin_nid,
|
2013-12-04 09:19:41 +07:00
|
|
|
codec->jackpoll_interval > 0 ? jack_callback : NULL);
|
2012-06-20 21:32:22 +07:00
|
|
|
}
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
static void hdmi_array_init(struct hdmi_spec *spec, int nums)
|
|
|
|
{
|
|
|
|
snd_array_init(&spec->pins, sizeof(struct hdmi_spec_per_pin), nums);
|
|
|
|
snd_array_init(&spec->cvts, sizeof(struct hdmi_spec_per_cvt), nums);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_array_free(struct hdmi_spec *spec)
|
|
|
|
{
|
|
|
|
snd_array_free(&spec->pins);
|
|
|
|
snd_array_free(&spec->cvts);
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static void generic_hdmi_free(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
int pin_idx;
|
|
|
|
|
2015-08-19 15:48:58 +07:00
|
|
|
if (is_haswell_plus(codec) || is_valleyview_plus(codec))
|
|
|
|
snd_hdac_i915_register_notifier(NULL);
|
|
|
|
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2015-02-28 04:43:26 +07:00
|
|
|
cancel_delayed_work_sync(&per_pin->work);
|
2013-10-17 23:21:12 +07:00
|
|
|
eld_proc_free(per_pin);
|
ALSA: hda: HDMI: Support codecs with fewer cvts than pins
The general concept of this change is to create a PCM device for each
pin widget instead of each converter widget. Whenever a PCM is opened,
a converter is dynamically selected to drive that pin based on those
available for muxing into the pin.
The one thing this model doesn't support is a single PCM/converter
sending audio to multiple pin widgets at once.
Note that this means that a struct hda_pcm_stream's nid variable is
set to 0 except between a stream's open and cleanup calls. The dynamic
de-assignment of converters to PCMs occurs within cleanup, not close,
in order for it to co-incide with when controller stream IDs are
cleaned up from converters.
While the PCM for a pin is not open, the pin is disabled (its widget
control's PIN_OUT bit is cleared) so that if the currently routed
converter is used to drive a different PCM/pin, that audio does not
leak out over a disabled pin.
We use the recently added SPDIF virtualization feature in order to
create SPDIF controls for each pin widget instead of each converter
widget, so that state is specific to a PCM.
In order to support this, a number of more mechanical changes are made:
* s/nid/pin_nid/ or s/nid/cvt_nid/ in many places in order to make it
clear exactly what the code is dealing with.
* We now have per_pin and per_cvt arrays in hdmi_spec to store relevant
data. In particular, we store a converter's capabilities in the per_cvt
entry, rather than relying on a combination of codec_pcm_pars and
the struct hda_pcm_stream.
* ELD-related workarounds were removed from hdmi_channel_allocation
into hdmi_instrinsic in order to simplifiy infoframe calculations and
remove HW dependencies.
* Various functions only apply to a single pin, since there is now
only 1 pin per PCM. For example, hdmi_setup_infoframe,
hdmi_setup_stream.
* hdmi_add_pin and hdmi_add_cvt are more oriented at pure codec parsing
and data retrieval, rather than determining which pins/converters
are to be used for creating PCMs.
This is quite a large change; it may be appropriate to simply read the
result of the patch rather than the diffs. Some small parts of the change
might be separable into different patches, but I think the bulk of the
change will probably always be one large patch. Hopefully the change
isn't too opaque!
This has been tested on:
* NVIDIA GeForce 400 series discrete graphics card. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM
audio to a PC monitor that supports audio.
* NVIDIA GeForce 520 discrete graphics card. This model is the new
1 codec n converters m pins m>n model. Tested stereo PCM audio to a
PC monitor that supports audio.
* NVIDIA GeForce 400 series laptop graphics chip. This model has the
classical 1:1:1 codec:converter:pcm widget model. Tested stereo PCM,
multi-channel PCM, and AC3 pass-through to an AV receiver.
* Intel Ibex Peak laptop. This model is the new 1 codec n converters m
pins m>n model. Tested stereo PCM, multi-channel PCM, and AC3 pass-
through to an AV receiver.
Note that I'm not familiar at all with AC3 pass-through. Hence, I may
not have covered all possible mechanisms that are applicable here. I do
know that my receiver definitely received AC3, not decoded PCM. I tested
with mplayer's "-afm hwac3" and/or "-af lavcac3enc" options, and alsa a
WAV file that I believe has AC3 content rather than PCM.
I also tested:
* Play a stream
* Mute while playing
* Stop stream
* Play some other streams to re-assign the converter to a different
pin, PCM, set of SPDIF controls, ... hence hopefully triggering
cleanup for the original PCM.
* Unmute original stream while not playing
* Play a stream on the original pin/PCM.
This was to test SPDIF control virtualization.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:21 +07:00
|
|
|
}
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
hdmi_array_free(spec);
|
2010-09-07 17:27:25 +07:00
|
|
|
kfree(spec);
|
|
|
|
}
|
|
|
|
|
2013-06-24 18:45:23 +07:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int generic_hdmi_resume(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int pin_idx;
|
|
|
|
|
2014-06-19 02:48:09 +07:00
|
|
|
codec->patch_ops.init(codec);
|
2015-02-25 21:18:50 +07:00
|
|
|
regcache_sync(codec->core.regmap);
|
2013-06-24 18:45:23 +07:00
|
|
|
|
|
|
|
for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
|
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);
|
|
|
|
hdmi_present_sense(per_pin, 1);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-05-02 17:17:41 +07:00
|
|
|
static const struct hda_codec_ops generic_hdmi_patch_ops = {
|
2010-09-07 17:27:25 +07:00
|
|
|
.init = generic_hdmi_init,
|
|
|
|
.free = generic_hdmi_free,
|
|
|
|
.build_pcms = generic_hdmi_build_pcms,
|
|
|
|
.build_controls = generic_hdmi_build_controls,
|
|
|
|
.unsol_event = hdmi_unsol_event,
|
2013-06-24 18:45:23 +07:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
.resume = generic_hdmi_resume,
|
|
|
|
#endif
|
2010-09-07 17:27:25 +07:00
|
|
|
};
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
static const struct hdmi_ops generic_standard_hdmi_ops = {
|
|
|
|
.pin_get_eld = snd_hdmi_get_eld,
|
|
|
|
.pin_get_slot_channel = hdmi_pin_get_slot_channel,
|
|
|
|
.pin_set_slot_channel = hdmi_pin_set_slot_channel,
|
|
|
|
.pin_setup_infoframe = hdmi_pin_setup_infoframe,
|
|
|
|
.pin_hbr_setup = hdmi_pin_hbr_setup,
|
|
|
|
.setup_stream = hdmi_setup_stream,
|
|
|
|
.chmap_cea_alloc_validate_get_type = hdmi_chmap_cea_alloc_validate_get_type,
|
|
|
|
.cea_alloc_to_tlv_chmap = hdmi_cea_alloc_to_tlv_chmap,
|
|
|
|
};
|
|
|
|
|
2012-12-19 04:59:15 +07:00
|
|
|
|
2013-02-09 05:10:04 +07:00
|
|
|
static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
hda_nid_t conns[4];
|
|
|
|
int nconns;
|
2012-12-19 04:59:15 +07:00
|
|
|
|
2013-02-09 05:10:04 +07:00
|
|
|
nconns = snd_hda_get_connections(codec, nid, conns, ARRAY_SIZE(conns));
|
|
|
|
if (nconns == spec->num_cvts &&
|
|
|
|
!memcmp(conns, spec->cvt_nids, spec->num_cvts * sizeof(hda_nid_t)))
|
2012-12-19 04:59:15 +07:00
|
|
|
return;
|
|
|
|
|
2013-02-09 05:10:04 +07:00
|
|
|
/* override pins connection list */
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec, "hdmi: haswell: override pin connection 0x%x\n", nid);
|
2013-02-09 05:10:04 +07:00
|
|
|
snd_hda_override_conn_list(codec, nid, spec->num_cvts, spec->cvt_nids);
|
2012-12-19 04:59:15 +07:00
|
|
|
}
|
|
|
|
|
2013-02-09 05:09:52 +07:00
|
|
|
#define INTEL_VENDOR_NID 0x08
|
|
|
|
#define INTEL_GET_VENDOR_VERB 0xf81
|
|
|
|
#define INTEL_SET_VENDOR_VERB 0x781
|
|
|
|
#define INTEL_EN_DP12 0x02 /* enable DP 1.2 features */
|
|
|
|
#define INTEL_EN_ALL_PIN_CVTS 0x01 /* enable 2nd & 3rd pins and convertors */
|
|
|
|
|
|
|
|
static void intel_haswell_enable_all_pins(struct hda_codec *codec,
|
2013-05-08 13:09:34 +07:00
|
|
|
bool update_tree)
|
2013-02-09 05:09:52 +07:00
|
|
|
{
|
|
|
|
unsigned int vendor_param;
|
|
|
|
|
|
|
|
vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
|
|
|
|
INTEL_GET_VENDOR_VERB, 0);
|
|
|
|
if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vendor_param |= INTEL_EN_ALL_PIN_CVTS;
|
|
|
|
vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
|
|
|
|
INTEL_SET_VENDOR_VERB, vendor_param);
|
|
|
|
if (vendor_param == -1)
|
|
|
|
return;
|
|
|
|
|
2013-05-08 13:09:34 +07:00
|
|
|
if (update_tree)
|
|
|
|
snd_hda_codec_update_widgets(codec);
|
2013-02-09 05:09:52 +07:00
|
|
|
}
|
|
|
|
|
2013-02-09 05:10:04 +07:00
|
|
|
static void intel_haswell_fixup_enable_dp12(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
unsigned int vendor_param;
|
|
|
|
|
|
|
|
vendor_param = snd_hda_codec_read(codec, INTEL_VENDOR_NID, 0,
|
|
|
|
INTEL_GET_VENDOR_VERB, 0);
|
|
|
|
if (vendor_param == -1 || vendor_param & INTEL_EN_DP12)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* enable DP1.2 mode */
|
|
|
|
vendor_param |= INTEL_EN_DP12;
|
ALSA: hda - Use regmap for command verb caches, too
Like the previous patches, this patch converts also to the regmap, at
this time, the cached verb writes are the target. But this conversion
needs a bit more caution than before.
- In the old code, we just record any verbs as is, and restore them at
resume. For the regmap scheme, this doesn't work, since a few verbs
like AMP or DIGI_CONVERT are asymmetrical. Such verbs are converted
either to the dedicated function (snd_hda_regmap_xxx_amp()) or
changed to the unified verb.
- Some verbs have to be declared as vendor-specific ones before
accessing via regmap.
Also, the minor optimization with codec->cached_write flag is dropped
in a few places, as this would confuse the operation. Further
optimizations will be brought in the later patches, if any.
This conversion ends up with a drop of significant amount of codes,
mostly the helper codes that are no longer used.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-02-26 18:34:49 +07:00
|
|
|
snd_hdac_regmap_add_vendor_verb(&codec->core, INTEL_SET_VENDOR_VERB);
|
2013-02-09 05:10:04 +07:00
|
|
|
snd_hda_codec_write_cache(codec, INTEL_VENDOR_NID, 0,
|
|
|
|
INTEL_SET_VENDOR_VERB, vendor_param);
|
|
|
|
}
|
|
|
|
|
2013-05-08 13:09:34 +07:00
|
|
|
/* Haswell needs to re-issue the vendor-specific verbs before turning to D0.
|
|
|
|
* Otherwise you may get severe h/w communication errors.
|
|
|
|
*/
|
|
|
|
static void haswell_set_power_state(struct hda_codec *codec, hda_nid_t fg,
|
|
|
|
unsigned int power_state)
|
|
|
|
{
|
|
|
|
if (power_state == AC_PWRST_D0) {
|
|
|
|
intel_haswell_enable_all_pins(codec, false);
|
|
|
|
intel_haswell_fixup_enable_dp12(codec);
|
|
|
|
}
|
2013-02-09 05:10:04 +07:00
|
|
|
|
2013-05-08 13:09:34 +07:00
|
|
|
snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, power_state);
|
|
|
|
snd_hda_codec_set_power_to_all(codec, fg, power_state);
|
|
|
|
}
|
2012-12-19 04:59:15 +07:00
|
|
|
|
2015-09-03 16:51:34 +07:00
|
|
|
static void intel_pin_eld_notify(void *audio_ptr, int port)
|
2015-08-19 15:48:58 +07:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = audio_ptr;
|
|
|
|
int pin_nid = port + 0x04;
|
|
|
|
|
|
|
|
check_presence_and_report(codec, pin_nid);
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int patch_generic_hdmi(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
|
|
|
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
|
|
if (spec == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-10-25 01:10:34 +07:00
|
|
|
spec->ops = generic_standard_hdmi_ops;
|
2010-09-07 17:27:25 +07:00
|
|
|
codec->spec = spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
hdmi_array_init(spec, 4);
|
2012-12-19 04:59:15 +07:00
|
|
|
|
2014-01-09 03:55:32 +07:00
|
|
|
if (is_haswell_plus(codec)) {
|
2013-05-08 13:09:34 +07:00
|
|
|
intel_haswell_enable_all_pins(codec, true);
|
2013-02-09 05:10:04 +07:00
|
|
|
intel_haswell_fixup_enable_dp12(codec);
|
2013-05-08 13:09:34 +07:00
|
|
|
}
|
2012-12-19 04:59:15 +07:00
|
|
|
|
2015-04-29 16:43:43 +07:00
|
|
|
/* For Valleyview/Cherryview, only the display codec is in the display
|
|
|
|
* power well and can use link_power ops to request/release the power.
|
|
|
|
* For Haswell/Broadwell, the controller is also in the power well and
|
|
|
|
* can cover the codec power request, and so need not set this flag.
|
|
|
|
* For previous platforms, there is no such power well feature.
|
|
|
|
*/
|
2015-06-03 08:30:15 +07:00
|
|
|
if (is_valleyview_plus(codec) || is_skylake(codec))
|
2015-04-29 16:43:43 +07:00
|
|
|
codec->core.link_power_control = 1;
|
|
|
|
|
2015-08-19 15:48:58 +07:00
|
|
|
if (is_haswell_plus(codec) || is_valleyview_plus(codec)) {
|
2013-12-06 06:35:48 +07:00
|
|
|
codec->depop_delay = 0;
|
2015-08-19 15:48:58 +07:00
|
|
|
spec->i915_audio_ops.audio_ptr = codec;
|
|
|
|
spec->i915_audio_ops.pin_eld_notify = intel_pin_eld_notify;
|
|
|
|
snd_hdac_i915_register_notifier(&spec->i915_audio_ops);
|
|
|
|
}
|
2013-12-06 06:35:48 +07:00
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
if (hdmi_parse_codec(codec) < 0) {
|
|
|
|
codec->spec = NULL;
|
|
|
|
kfree(spec);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
codec->patch_ops = generic_hdmi_patch_ops;
|
2014-01-09 03:55:32 +07:00
|
|
|
if (is_haswell_plus(codec)) {
|
2013-05-08 13:09:34 +07:00
|
|
|
codec->patch_ops.set_power_state = haswell_set_power_state;
|
2013-08-27 08:35:41 +07:00
|
|
|
codec->dp_mst = true;
|
|
|
|
}
|
2013-05-08 13:09:34 +07:00
|
|
|
|
2015-06-09 15:50:38 +07:00
|
|
|
/* Enable runtime pm for HDMI audio codec of HSW/BDW/SKL/BYT/BSW */
|
|
|
|
if (is_haswell_plus(codec) || is_valleyview_plus(codec))
|
|
|
|
codec->auto_runtime_pm = 1;
|
|
|
|
|
2012-06-20 21:32:22 +07:00
|
|
|
generic_hdmi_init_per_pins(codec);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
init_channel_allocations();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-02 00:14:19 +07:00
|
|
|
/*
|
|
|
|
* Shared non-generic implementations
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int simple_playback_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hda_pcm *info;
|
2012-06-21 13:23:27 +07:00
|
|
|
unsigned int chans;
|
|
|
|
struct hda_pcm_stream *pstr;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
2011-06-02 00:14:19 +07:00
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = get_cvt(spec, 0);
|
|
|
|
chans = get_wcaps(codec, per_cvt->cvt_nid);
|
2012-06-21 13:23:27 +07:00
|
|
|
chans = get_wcaps_channels(chans);
|
2011-06-02 00:14:19 +07:00
|
|
|
|
2015-02-27 23:43:19 +07:00
|
|
|
info = snd_hda_codec_pcm_new(codec, "HDMI 0");
|
2013-03-13 20:40:31 +07:00
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
2015-02-27 23:43:19 +07:00
|
|
|
spec->pcm_rec[0] = info;
|
2012-06-21 13:23:27 +07:00
|
|
|
info->pcm_type = HDA_PCM_TYPE_HDMI;
|
|
|
|
pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK];
|
|
|
|
*pstr = spec->pcm_playback;
|
2013-03-13 20:40:31 +07:00
|
|
|
pstr->nid = per_cvt->cvt_nid;
|
2012-06-21 13:23:27 +07:00
|
|
|
if (pstr->channels_max <= 2 && chans && chans <= 16)
|
|
|
|
pstr->channels_max = chans;
|
2011-06-02 00:14:19 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-15 16:53:32 +07:00
|
|
|
/* unsolicited event for jack sensing */
|
|
|
|
static void simple_hdmi_unsol_event(struct hda_codec *codec,
|
|
|
|
unsigned int res)
|
|
|
|
{
|
2012-06-21 15:43:15 +07:00
|
|
|
snd_hda_jack_set_dirty_all(codec);
|
2012-06-15 16:53:32 +07:00
|
|
|
snd_hda_jack_report_sync(codec);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* generic_hdmi_build_jack can be used for simple_hdmi, too,
|
|
|
|
* as long as spec->pins[] is set correctly
|
|
|
|
*/
|
|
|
|
#define simple_hdmi_build_jack generic_hdmi_build_jack
|
|
|
|
|
2011-06-02 00:14:19 +07:00
|
|
|
static int simple_playback_build_controls(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
2011-06-02 00:14:19 +07:00
|
|
|
int err;
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = get_cvt(spec, 0);
|
2013-12-11 03:46:34 +07:00
|
|
|
err = snd_hda_create_dig_out_ctls(codec, per_cvt->cvt_nid,
|
|
|
|
per_cvt->cvt_nid,
|
|
|
|
HDA_PCM_TYPE_HDMI);
|
2012-06-21 13:23:27 +07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
return simple_hdmi_build_jack(codec, 0);
|
2011-06-02 00:14:19 +07:00
|
|
|
}
|
|
|
|
|
2012-06-15 17:45:43 +07:00
|
|
|
static int simple_playback_init(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_pin *per_pin = get_pin(spec, 0);
|
|
|
|
hda_nid_t pin = per_pin->pin_nid;
|
2012-06-21 13:23:27 +07:00
|
|
|
|
|
|
|
snd_hda_codec_write(codec, pin, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
|
|
|
|
/* some codecs require to unmute the pin */
|
|
|
|
if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
|
|
|
|
snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
|
|
|
|
AMP_OUT_UNMUTE);
|
2014-09-11 19:06:53 +07:00
|
|
|
snd_hda_jack_detect_enable(codec, pin);
|
2012-06-15 17:45:43 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-02 00:14:19 +07:00
|
|
|
static void simple_playback_free(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
|
2013-03-13 20:40:31 +07:00
|
|
|
hdmi_array_free(spec);
|
2011-06-02 00:14:19 +07:00
|
|
|
kfree(spec);
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
/*
|
|
|
|
* Nvidia specific implementations
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define Nv_VERB_SET_Channel_Allocation 0xF79
|
|
|
|
#define Nv_VERB_SET_Info_Frame_Checksum 0xF7A
|
|
|
|
#define Nv_VERB_SET_Audio_Protection_On 0xF98
|
|
|
|
#define Nv_VERB_SET_Audio_Protection_Off 0xF99
|
|
|
|
|
|
|
|
#define nvhdmi_master_con_nid_7x 0x04
|
|
|
|
#define nvhdmi_master_pin_nid_7x 0x05
|
|
|
|
|
2011-05-02 17:17:41 +07:00
|
|
|
static const hda_nid_t nvhdmi_con_nids_7x[4] = {
|
2010-09-07 17:27:25 +07:00
|
|
|
/*front, rear, clfe, rear_surr */
|
|
|
|
0x6, 0x8, 0xa, 0xc,
|
|
|
|
};
|
|
|
|
|
2012-06-15 19:38:31 +07:00
|
|
|
static const struct hda_verb nvhdmi_basic_init_7x_2ch[] = {
|
|
|
|
/* set audio protect on */
|
|
|
|
{ 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
|
|
|
|
/* enable digital output on pin widget */
|
|
|
|
{ 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{} /* terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct hda_verb nvhdmi_basic_init_7x_8ch[] = {
|
2010-09-07 17:27:25 +07:00
|
|
|
/* set audio protect on */
|
|
|
|
{ 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1},
|
|
|
|
/* enable digital output on pin widget */
|
|
|
|
{ 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{ 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{ 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{ 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{ 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 },
|
|
|
|
{} /* terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef LIMITED_RATE_FMT_SUPPORT
|
|
|
|
/* support only the safe format and rate */
|
|
|
|
#define SUPPORTED_RATES SNDRV_PCM_RATE_48000
|
|
|
|
#define SUPPORTED_MAXBPS 16
|
|
|
|
#define SUPPORTED_FORMATS SNDRV_PCM_FMTBIT_S16_LE
|
|
|
|
#else
|
|
|
|
/* support all rates and formats */
|
|
|
|
#define SUPPORTED_RATES \
|
|
|
|
(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
|
|
|
|
SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
|
|
|
|
SNDRV_PCM_RATE_192000)
|
|
|
|
#define SUPPORTED_MAXBPS 24
|
|
|
|
#define SUPPORTED_FORMATS \
|
|
|
|
(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
|
|
|
|
#endif
|
|
|
|
|
2012-06-15 19:38:31 +07:00
|
|
|
static int nvhdmi_7x_init_2ch(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
snd_hda_sequence_write(codec, nvhdmi_basic_init_7x_2ch);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nvhdmi_7x_init_8ch(struct hda_codec *codec)
|
2010-09-07 17:27:25 +07:00
|
|
|
{
|
2012-06-15 19:38:31 +07:00
|
|
|
snd_hda_sequence_write(codec, nvhdmi_basic_init_7x_8ch);
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-10 23:19:31 +07:00
|
|
|
static unsigned int channels_2_6_8[] = {
|
|
|
|
2, 6, 8
|
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned int channels_2_8[] = {
|
|
|
|
2, 8
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_pcm_hw_constraint_list hw_constraints_2_6_8_channels = {
|
|
|
|
.count = ARRAY_SIZE(channels_2_6_8),
|
|
|
|
.list = channels_2_6_8,
|
|
|
|
.mask = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_pcm_hw_constraint_list hw_constraints_2_8_channels = {
|
|
|
|
.count = ARRAY_SIZE(channels_2_8),
|
|
|
|
.list = channels_2_8,
|
|
|
|
.mask = 0,
|
|
|
|
};
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int simple_playback_pcm_open(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2011-01-10 23:19:31 +07:00
|
|
|
struct snd_pcm_hw_constraint_list *hw_constraints_channels = NULL;
|
|
|
|
|
|
|
|
switch (codec->preset->id) {
|
|
|
|
case 0x10de0002:
|
|
|
|
case 0x10de0003:
|
|
|
|
case 0x10de0005:
|
|
|
|
case 0x10de0006:
|
|
|
|
hw_constraints_channels = &hw_constraints_2_8_channels;
|
|
|
|
break;
|
|
|
|
case 0x10de0007:
|
|
|
|
hw_constraints_channels = &hw_constraints_2_6_8_channels;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hw_constraints_channels != NULL) {
|
|
|
|
snd_pcm_hw_constraint_list(substream->runtime, 0,
|
|
|
|
SNDRV_PCM_HW_PARAM_CHANNELS,
|
|
|
|
hw_constraints_channels);
|
2011-01-14 15:42:27 +07:00
|
|
|
} else {
|
|
|
|
snd_pcm_hw_constraint_step(substream->runtime, 0,
|
|
|
|
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
|
2011-01-10 23:19:31 +07:00
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return snd_hda_multi_out_dig_open(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int simple_playback_pcm_close(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_dig_close(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int simple_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
|
|
|
|
stream_tag, format, substream);
|
|
|
|
}
|
|
|
|
|
2012-06-15 19:34:42 +07:00
|
|
|
static const struct hda_pcm_stream simple_pcm_playback = {
|
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.ops = {
|
|
|
|
.open = simple_playback_pcm_open,
|
|
|
|
.close = simple_playback_pcm_close,
|
|
|
|
.prepare = simple_playback_pcm_prepare
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct hda_codec_ops simple_hdmi_patch_ops = {
|
|
|
|
.build_controls = simple_playback_build_controls,
|
|
|
|
.build_pcms = simple_playback_build_pcms,
|
|
|
|
.init = simple_playback_init,
|
|
|
|
.free = simple_playback_free,
|
2012-06-15 19:40:21 +07:00
|
|
|
.unsol_event = simple_hdmi_unsol_event,
|
2012-06-15 19:34:42 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int patch_simple_hdmi(struct hda_codec *codec,
|
|
|
|
hda_nid_t cvt_nid, hda_nid_t pin_nid)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
|
|
|
struct hdmi_spec_per_pin *per_pin;
|
2012-06-15 19:34:42 +07:00
|
|
|
|
|
|
|
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
|
|
|
|
if (!spec)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
codec->spec = spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
hdmi_array_init(spec, 1);
|
2012-06-15 19:34:42 +07:00
|
|
|
|
|
|
|
spec->multiout.num_dacs = 0; /* no analog */
|
|
|
|
spec->multiout.max_channels = 2;
|
|
|
|
spec->multiout.dig_out_nid = cvt_nid;
|
|
|
|
spec->num_cvts = 1;
|
|
|
|
spec->num_pins = 1;
|
2013-03-13 20:40:31 +07:00
|
|
|
per_pin = snd_array_new(&spec->pins);
|
|
|
|
per_cvt = snd_array_new(&spec->cvts);
|
|
|
|
if (!per_pin || !per_cvt) {
|
|
|
|
simple_playback_free(codec);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
per_cvt->cvt_nid = cvt_nid;
|
|
|
|
per_pin->pin_nid = pin_nid;
|
2012-06-15 19:34:42 +07:00
|
|
|
spec->pcm_playback = simple_pcm_playback;
|
|
|
|
|
|
|
|
codec->patch_ops = simple_hdmi_patch_ops;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-07 07:19:04 +07:00
|
|
|
static void nvhdmi_8ch_7x_set_info_frame_parameters(struct hda_codec *codec,
|
|
|
|
int channels)
|
|
|
|
{
|
|
|
|
unsigned int chanmask;
|
|
|
|
int chan = channels ? (channels - 1) : 1;
|
|
|
|
|
|
|
|
switch (channels) {
|
|
|
|
default:
|
|
|
|
case 0:
|
|
|
|
case 2:
|
|
|
|
chanmask = 0x00;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
chanmask = 0x08;
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
chanmask = 0x0b;
|
|
|
|
break;
|
|
|
|
case 8:
|
|
|
|
chanmask = 0x13;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the audio infoframe channel allocation and checksum fields. The
|
|
|
|
* channel count is computed implicitly by the hardware. */
|
|
|
|
snd_hda_codec_write(codec, 0x1, 0,
|
|
|
|
Nv_VERB_SET_Channel_Allocation, chanmask);
|
|
|
|
|
|
|
|
snd_hda_codec_write(codec, 0x1, 0,
|
|
|
|
Nv_VERB_SET_Info_Frame_Checksum,
|
|
|
|
(0x71 - chan - chanmask));
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x,
|
|
|
|
0, AC_VERB_SET_CHANNEL_STREAMID, 0);
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
/* set the stream id */
|
|
|
|
snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
|
|
|
|
AC_VERB_SET_CHANNEL_STREAMID, 0);
|
|
|
|
/* set the stream format */
|
|
|
|
snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0,
|
|
|
|
AC_VERB_SET_STREAM_FORMAT, 0);
|
|
|
|
}
|
|
|
|
|
2011-04-07 07:19:04 +07:00
|
|
|
/* The audio hardware sends a channel count of 0x7 (8ch) when all the
|
|
|
|
* streams are disabled. */
|
|
|
|
nvhdmi_8ch_7x_set_info_frame_parameters(codec, 8);
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return snd_hda_multi_out_dig_close(codec, &spec->multiout);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
int chs;
|
2011-11-03 03:40:06 +07:00
|
|
|
unsigned int dataDCC2, channel_id;
|
2010-09-07 17:27:25 +07:00
|
|
|
int i;
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2012-05-10 15:21:29 +07:00
|
|
|
struct hda_spdif_out *spdif;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2013-03-13 20:40:31 +07:00
|
|
|
per_cvt = get_cvt(spec, 0);
|
|
|
|
spdif = snd_hda_spdif_out_of_nid(codec, per_cvt->cvt_nid);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
chs = substream->runtime->channels;
|
|
|
|
|
|
|
|
dataDCC2 = 0x2;
|
|
|
|
|
|
|
|
/* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_master_con_nid_7x,
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1,
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
spdif->ctls & ~AC_DIG1_ENABLE & 0xff);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
/* set the stream id */
|
|
|
|
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
|
|
|
|
AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0);
|
|
|
|
|
|
|
|
/* set the stream format */
|
|
|
|
snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0,
|
|
|
|
AC_VERB_SET_STREAM_FORMAT, format);
|
|
|
|
|
|
|
|
/* turn on again (if needed) */
|
|
|
|
/* enable and set the channel status audio/data flag */
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE)) {
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_master_con_nid_7x,
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1,
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
spdif->ctls & 0xff);
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_master_con_nid_7x,
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if (chs == 2)
|
|
|
|
channel_id = 0;
|
|
|
|
else
|
|
|
|
channel_id = i * 2;
|
|
|
|
|
|
|
|
/* turn off SPDIF once;
|
|
|
|
*otherwise the IEC958 bits won't be updated
|
|
|
|
*/
|
|
|
|
if (codec->spdif_status_reset &&
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
(spdif->ctls & AC_DIG1_ENABLE))
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_con_nids_7x[i],
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1,
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
spdif->ctls & ~AC_DIG1_ENABLE & 0xff);
|
2010-09-07 17:27:25 +07:00
|
|
|
/* set the stream id */
|
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_con_nids_7x[i],
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_CHANNEL_STREAMID,
|
|
|
|
(stream_tag << 4) | channel_id);
|
|
|
|
/* set the stream format */
|
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_con_nids_7x[i],
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_STREAM_FORMAT,
|
|
|
|
format);
|
|
|
|
/* turn on again (if needed) */
|
|
|
|
/* enable and set the channel status audio/data flag */
|
|
|
|
if (codec->spdif_status_reset &&
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
(spdif->ctls & AC_DIG1_ENABLE)) {
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_con_nids_7x[i],
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1,
|
ALSA: hda: Allow multple SPDIF controls per codec
Currently, the data that backs the kcontrols created by
snd_hda_create_spdif_out_ctls is stored directly in struct hda_codec. When
multiple sets of these controls are stored, they will all manipulate the
same data, causing confusion. Instead, store an array of this data, one
copy per converter, to isolate the controls.
This patch would cause a behavioural change in the case where
snd_hda_create_spdif_out_ctls was called multiple times for a single codec.
As best I can tell, this is never the case for any codec.
This will be relevant at least for some HDMI audio codecs, such as the
NVIDIA GeForce 520 and Intel Ibex Peak. A future change will modify the
driver's handling of those codecs to create multiple PCMs per codec. Note
that this issue isn't affected by whether one creates a PCM-per-converter
or PCM-per-pin; there are multiple of both within a single codec in both
of those codecs.
Note that those codecs don't currently create multiple PCMs for the codec
due to the default HW mux state of all pins being to point at the same
converter, hence there is only a single converter routed to any pin, and
hence only a single PCM.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-06-02 00:14:17 +07:00
|
|
|
spdif->ctls & 0xff);
|
2010-09-07 17:27:25 +07:00
|
|
|
snd_hda_codec_write(codec,
|
|
|
|
nvhdmi_con_nids_7x[i],
|
|
|
|
0,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_2, dataDCC2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-07 07:19:04 +07:00
|
|
|
nvhdmi_8ch_7x_set_info_frame_parameters(codec, chs);
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-02 17:17:41 +07:00
|
|
|
static const struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x = {
|
2010-09-07 17:27:25 +07:00
|
|
|
.substreams = 1,
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 8,
|
|
|
|
.nid = nvhdmi_master_con_nid_7x,
|
|
|
|
.rates = SUPPORTED_RATES,
|
|
|
|
.maxbps = SUPPORTED_MAXBPS,
|
|
|
|
.formats = SUPPORTED_FORMATS,
|
|
|
|
.ops = {
|
|
|
|
.open = simple_playback_pcm_open,
|
|
|
|
.close = nvhdmi_8ch_7x_pcm_close,
|
|
|
|
.prepare = nvhdmi_8ch_7x_pcm_prepare
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int patch_nvhdmi_2ch(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
2012-06-15 19:34:42 +07:00
|
|
|
int err = patch_simple_hdmi(codec, nvhdmi_master_con_nid_7x,
|
|
|
|
nvhdmi_master_pin_nid_7x);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2012-06-15 19:38:31 +07:00
|
|
|
codec->patch_ops.init = nvhdmi_7x_init_2ch;
|
2012-06-15 19:34:42 +07:00
|
|
|
/* override the PCM rates, etc, as the codec doesn't give full list */
|
|
|
|
spec = codec->spec;
|
|
|
|
spec->pcm_playback.rates = SUPPORTED_RATES;
|
|
|
|
spec->pcm_playback.maxbps = SUPPORTED_MAXBPS;
|
|
|
|
spec->pcm_playback.formats = SUPPORTED_FORMATS;
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-01 17:17:41 +07:00
|
|
|
static int nvhdmi_7x_8ch_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
int err = simple_playback_build_pcms(codec);
|
2013-03-13 20:40:31 +07:00
|
|
|
if (!err) {
|
|
|
|
struct hda_pcm *info = get_pcm_rec(spec, 0);
|
|
|
|
info->own_chmap = true;
|
|
|
|
}
|
2012-08-01 17:17:41 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nvhdmi_7x_8ch_build_controls(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-03-13 20:40:31 +07:00
|
|
|
struct hda_pcm *info;
|
2012-08-01 17:17:41 +07:00
|
|
|
struct snd_pcm_chmap *chmap;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = simple_playback_build_controls(codec);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* add channel maps */
|
2013-03-13 20:40:31 +07:00
|
|
|
info = get_pcm_rec(spec, 0);
|
|
|
|
err = snd_pcm_add_chmap_ctls(info->pcm,
|
2012-08-01 17:17:41 +07:00
|
|
|
SNDRV_PCM_STREAM_PLAYBACK,
|
|
|
|
snd_pcm_alt_chmaps, 8, 0, &chmap);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
switch (codec->preset->id) {
|
|
|
|
case 0x10de0002:
|
|
|
|
case 0x10de0003:
|
|
|
|
case 0x10de0005:
|
|
|
|
case 0x10de0006:
|
|
|
|
chmap->channel_mask = (1U << 2) | (1U << 8);
|
|
|
|
break;
|
|
|
|
case 0x10de0007:
|
|
|
|
chmap->channel_mask = (1U << 2) | (1U << 6) | (1U << 8);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
|
|
|
int err = patch_nvhdmi_2ch(codec);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
spec = codec->spec;
|
|
|
|
spec->multiout.max_channels = 8;
|
2012-06-15 19:34:42 +07:00
|
|
|
spec->pcm_playback = nvhdmi_pcm_playback_8ch_7x;
|
2012-06-15 19:38:31 +07:00
|
|
|
codec->patch_ops.init = nvhdmi_7x_init_8ch;
|
2012-08-01 17:17:41 +07:00
|
|
|
codec->patch_ops.build_pcms = nvhdmi_7x_8ch_build_pcms;
|
|
|
|
codec->patch_ops.build_controls = nvhdmi_7x_8ch_build_controls;
|
2011-04-07 07:19:04 +07:00
|
|
|
|
|
|
|
/* Initialize the audio infoframe channel mask and checksum to something
|
|
|
|
* valid */
|
|
|
|
nvhdmi_8ch_7x_set_info_frame_parameters(codec, 8);
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-03 22:15:00 +07:00
|
|
|
/*
|
|
|
|
* NVIDIA codecs ignore ASP mapping for 2ch - confirmed on:
|
|
|
|
* - 0x10de0015
|
|
|
|
* - 0x10de0040
|
|
|
|
*/
|
|
|
|
static int nvhdmi_chmap_cea_alloc_validate_get_type(struct cea_channel_speaker_allocation *cap,
|
|
|
|
int channels)
|
|
|
|
{
|
|
|
|
if (cap->ca_index == 0x00 && channels == 2)
|
|
|
|
return SNDRV_CTL_TLVT_CHMAP_FIXED;
|
|
|
|
|
|
|
|
return hdmi_chmap_cea_alloc_validate_get_type(cap, channels);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nvhdmi_chmap_validate(int ca, int chs, unsigned char *map)
|
|
|
|
{
|
|
|
|
if (ca == 0x00 && (map[0] != SNDRV_CHMAP_FL || map[1] != SNDRV_CHMAP_FR))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int patch_nvhdmi(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = patch_generic_hdmi(codec);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
spec = codec->spec;
|
2014-01-31 01:52:16 +07:00
|
|
|
spec->dyn_pin_out = true;
|
2013-11-03 22:15:00 +07:00
|
|
|
|
|
|
|
spec->ops.chmap_cea_alloc_validate_get_type =
|
|
|
|
nvhdmi_chmap_cea_alloc_validate_get_type;
|
|
|
|
spec->ops.chmap_validate = nvhdmi_chmap_validate;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-05 19:56:20 +07:00
|
|
|
/*
|
|
|
|
* The HDA codec on NVIDIA Tegra contains two scratch registers that are
|
|
|
|
* accessed using vendor-defined verbs. These registers can be used for
|
|
|
|
* interoperability between the HDA and HDMI drivers.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Audio Function Group node */
|
|
|
|
#define NVIDIA_AFG_NID 0x01
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The SCRATCH0 register is used to notify the HDMI codec of changes in audio
|
|
|
|
* format. On Tegra, bit 31 is used as a trigger that causes an interrupt to
|
|
|
|
* be raised in the HDMI codec. The remainder of the bits is arbitrary. This
|
|
|
|
* implementation stores the HDA format (see AC_FMT_*) in bits [15:0] and an
|
|
|
|
* additional bit (at position 30) to signal the validity of the format.
|
|
|
|
*
|
|
|
|
* | 31 | 30 | 29 16 | 15 0 |
|
|
|
|
* +---------+-------+--------+--------+
|
|
|
|
* | TRIGGER | VALID | UNUSED | FORMAT |
|
|
|
|
* +-----------------------------------|
|
|
|
|
*
|
|
|
|
* Note that for the trigger bit to take effect it needs to change value
|
|
|
|
* (i.e. it needs to be toggled).
|
|
|
|
*/
|
|
|
|
#define NVIDIA_GET_SCRATCH0 0xfa6
|
|
|
|
#define NVIDIA_SET_SCRATCH0_BYTE0 0xfa7
|
|
|
|
#define NVIDIA_SET_SCRATCH0_BYTE1 0xfa8
|
|
|
|
#define NVIDIA_SET_SCRATCH0_BYTE2 0xfa9
|
|
|
|
#define NVIDIA_SET_SCRATCH0_BYTE3 0xfaa
|
|
|
|
#define NVIDIA_SCRATCH_TRIGGER (1 << 7)
|
|
|
|
#define NVIDIA_SCRATCH_VALID (1 << 6)
|
|
|
|
|
|
|
|
#define NVIDIA_GET_SCRATCH1 0xfab
|
|
|
|
#define NVIDIA_SET_SCRATCH1_BYTE0 0xfac
|
|
|
|
#define NVIDIA_SET_SCRATCH1_BYTE1 0xfad
|
|
|
|
#define NVIDIA_SET_SCRATCH1_BYTE2 0xfae
|
|
|
|
#define NVIDIA_SET_SCRATCH1_BYTE3 0xfaf
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The format parameter is the HDA audio format (see AC_FMT_*). If set to 0,
|
|
|
|
* the format is invalidated so that the HDMI codec can be disabled.
|
|
|
|
*/
|
|
|
|
static void tegra_hdmi_set_format(struct hda_codec *codec, unsigned int format)
|
|
|
|
{
|
|
|
|
unsigned int value;
|
|
|
|
|
|
|
|
/* bits [31:30] contain the trigger and valid bits */
|
|
|
|
value = snd_hda_codec_read(codec, NVIDIA_AFG_NID, 0,
|
|
|
|
NVIDIA_GET_SCRATCH0, 0);
|
|
|
|
value = (value >> 24) & 0xff;
|
|
|
|
|
|
|
|
/* bits [15:0] are used to store the HDA format */
|
|
|
|
snd_hda_codec_write(codec, NVIDIA_AFG_NID, 0,
|
|
|
|
NVIDIA_SET_SCRATCH0_BYTE0,
|
|
|
|
(format >> 0) & 0xff);
|
|
|
|
snd_hda_codec_write(codec, NVIDIA_AFG_NID, 0,
|
|
|
|
NVIDIA_SET_SCRATCH0_BYTE1,
|
|
|
|
(format >> 8) & 0xff);
|
|
|
|
|
|
|
|
/* bits [16:24] are unused */
|
|
|
|
snd_hda_codec_write(codec, NVIDIA_AFG_NID, 0,
|
|
|
|
NVIDIA_SET_SCRATCH0_BYTE2, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bit 30 signals that the data is valid and hence that HDMI audio can
|
|
|
|
* be enabled.
|
|
|
|
*/
|
|
|
|
if (format == 0)
|
|
|
|
value &= ~NVIDIA_SCRATCH_VALID;
|
|
|
|
else
|
|
|
|
value |= NVIDIA_SCRATCH_VALID;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Whenever the trigger bit is toggled, an interrupt is raised in the
|
|
|
|
* HDMI codec. The HDMI driver will use that as trigger to update its
|
|
|
|
* configuration.
|
|
|
|
*/
|
|
|
|
value ^= NVIDIA_SCRATCH_TRIGGER;
|
|
|
|
|
|
|
|
snd_hda_codec_write(codec, NVIDIA_AFG_NID, 0,
|
|
|
|
NVIDIA_SET_SCRATCH0_BYTE3, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_hdmi_pcm_prepare(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = generic_hdmi_playback_pcm_prepare(hinfo, codec, stream_tag,
|
|
|
|
format, substream);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* notify the HDMI codec of the format change */
|
|
|
|
tegra_hdmi_set_format(codec, format);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_hdmi_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
/* invalidate the format in the HDMI codec */
|
|
|
|
tegra_hdmi_set_format(codec, 0);
|
|
|
|
|
|
|
|
return generic_hdmi_playback_pcm_cleanup(hinfo, codec, substream);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hda_pcm *hda_find_pcm_by_type(struct hda_codec *codec, int type)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < spec->num_pins; i++) {
|
|
|
|
struct hda_pcm *pcm = get_pcm_rec(spec, i);
|
|
|
|
|
|
|
|
if (pcm->pcm_type == type)
|
|
|
|
return pcm;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tegra_hdmi_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hda_pcm_stream *stream;
|
|
|
|
struct hda_pcm *pcm;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = generic_hdmi_build_pcms(codec);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
pcm = hda_find_pcm_by_type(codec, HDA_PCM_TYPE_HDMI);
|
|
|
|
if (!pcm)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Override ->prepare() and ->cleanup() operations to notify the HDMI
|
|
|
|
* codec about format changes.
|
|
|
|
*/
|
|
|
|
stream = &pcm->stream[SNDRV_PCM_STREAM_PLAYBACK];
|
|
|
|
stream->ops.prepare = tegra_hdmi_pcm_prepare;
|
|
|
|
stream->ops.cleanup = tegra_hdmi_pcm_cleanup;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int patch_tegra_hdmi(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = patch_generic_hdmi(codec);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
codec->patch_ops.build_pcms = tegra_hdmi_build_pcms;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
/*
|
2013-10-25 01:10:35 +07:00
|
|
|
* ATI/AMD-specific implementations
|
2010-09-07 17:27:25 +07:00
|
|
|
*/
|
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
#define is_amdhdmi_rev3_or_later(codec) \
|
2015-03-03 16:07:24 +07:00
|
|
|
((codec)->core.vendor_id == 0x1002aa01 && \
|
|
|
|
((codec)->core.revision_id & 0xff00) >= 0x0300)
|
2013-10-25 01:10:35 +07:00
|
|
|
#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
|
2013-10-25 01:10:37 +07:00
|
|
|
#define ATI_VERB_SET_HBR_CONTROL 0x77c
|
2013-10-25 01:10:35 +07:00
|
|
|
#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
|
2013-10-25 01:10:37 +07:00
|
|
|
#define ATI_VERB_GET_HBR_CONTROL 0xf7c
|
2013-10-25 01:10:35 +07:00
|
|
|
#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
|
|
|
|
|
2013-10-25 01:10:38 +07:00
|
|
|
/* AMD specific HDA cvt verbs */
|
|
|
|
#define ATI_VERB_SET_RAMP_RATE 0x770
|
|
|
|
#define ATI_VERB_GET_RAMP_RATE 0xf70
|
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
#define ATI_OUT_ENABLE 0x1
|
|
|
|
|
|
|
|
#define ATI_MULTICHANNEL_MODE_PAIRED 0
|
|
|
|
#define ATI_MULTICHANNEL_MODE_SINGLE 1
|
|
|
|
|
2013-10-25 01:10:37 +07:00
|
|
|
#define ATI_HBR_CAPABLE 0x01
|
|
|
|
#define ATI_HBR_ENABLE 0x10
|
|
|
|
|
2013-10-25 01:10:36 +07:00
|
|
|
static int atihdmi_pin_get_eld(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
unsigned char *buf, int *eld_size)
|
|
|
|
{
|
|
|
|
/* call hda_eld.c ATI/AMD-specific function */
|
|
|
|
return snd_hdmi_get_eld_ati(codec, nid, buf, eld_size,
|
|
|
|
is_amdhdmi_rev3_or_later(codec));
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
static void atihdmi_pin_setup_infoframe(struct hda_codec *codec, hda_nid_t pin_nid, int ca,
|
|
|
|
int active_channels, int conn_type)
|
|
|
|
{
|
|
|
|
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: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int atihdmi_paired_chmap_validate(int ca, int chs, unsigned char *map)
|
|
|
|
{
|
|
|
|
struct cea_channel_speaker_allocation *cap;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
/* check that only channel pairs need to be remapped on old pre-rev3 ATI/AMD */
|
|
|
|
|
|
|
|
cap = &channel_allocations[get_channel_allocation_order(ca)];
|
|
|
|
for (i = 0; i < chs; ++i) {
|
|
|
|
int mask = 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 = 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 hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int hdmi_slot, int stream_channel)
|
|
|
|
{
|
|
|
|
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 hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
int asp_slot)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
static int atihdmi_paired_chmap_cea_alloc_validate_get_type(struct 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 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++] = spk_to_chmap(spk);
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(count != channels);
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:37 +07:00
|
|
|
static int atihdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,
|
|
|
|
bool hbr)
|
|
|
|
{
|
|
|
|
int hbr_ctl, hbr_ctl_new;
|
|
|
|
|
|
|
|
hbr_ctl = snd_hda_codec_read(codec, pin_nid, 0, ATI_VERB_GET_HBR_CONTROL, 0);
|
2013-11-11 01:56:10 +07:00
|
|
|
if (hbr_ctl >= 0 && (hbr_ctl & ATI_HBR_CAPABLE)) {
|
2013-10-25 01:10:37 +07:00
|
|
|
if (hbr)
|
|
|
|
hbr_ctl_new = hbr_ctl | ATI_HBR_ENABLE;
|
|
|
|
else
|
|
|
|
hbr_ctl_new = hbr_ctl & ~ATI_HBR_ENABLE;
|
|
|
|
|
2014-02-25 18:21:03 +07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"atihdmi_pin_hbr_setup: NID=0x%x, %shbr-ctl=0x%x\n",
|
2013-10-25 01:10:37 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:10:38 +07:00
|
|
|
static int atihdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
|
|
|
|
hda_nid_t pin_nid, 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 hdmi_setup_stream(codec, cvt_nid, pin_nid, stream_tag, format);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
static int atihdmi_init(struct hda_codec *codec)
|
2010-09-07 17:27:25 +07:00
|
|
|
{
|
|
|
|
struct hdmi_spec *spec = codec->spec;
|
2013-10-25 01:10:35 +07:00
|
|
|
int pin_idx, err;
|
2010-09-07 17:27:25 +07:00
|
|
|
|
2013-10-25 01:10:35 +07:00
|
|
|
err = generic_hdmi_init(codec);
|
|
|
|
|
|
|
|
if (err)
|
2010-09-07 17:27:25 +07:00
|
|
|
return err;
|
2013-10-25 01:10:35 +07:00
|
|
|
|
|
|
|
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);
|
2010-09-07 17:27:25 +07:00
|
|
|
}
|
2013-10-25 01:10:35 +07:00
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int patch_atihdmi(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hdmi_spec *spec;
|
2013-10-25 01:10:35 +07:00
|
|
|
struct hdmi_spec_per_cvt *per_cvt;
|
|
|
|
int err, cvt_idx;
|
|
|
|
|
|
|
|
err = patch_generic_hdmi(codec);
|
|
|
|
|
|
|
|
if (err)
|
2012-06-15 19:34:42 +07:00
|
|
|
return err;
|
2013-10-25 01:10:35 +07:00
|
|
|
|
|
|
|
codec->patch_ops.init = atihdmi_init;
|
|
|
|
|
2012-06-15 19:34:42 +07:00
|
|
|
spec = codec->spec;
|
2013-10-25 01:10:35 +07:00
|
|
|
|
2013-10-25 01:10:36 +07:00
|
|
|
spec->ops.pin_get_eld = atihdmi_pin_get_eld;
|
2013-10-25 01:10:35 +07:00
|
|
|
spec->ops.pin_get_slot_channel = atihdmi_pin_get_slot_channel;
|
|
|
|
spec->ops.pin_set_slot_channel = atihdmi_pin_set_slot_channel;
|
|
|
|
spec->ops.pin_setup_infoframe = atihdmi_pin_setup_infoframe;
|
2013-10-25 01:10:37 +07:00
|
|
|
spec->ops.pin_hbr_setup = atihdmi_pin_hbr_setup;
|
2013-10-25 01:10:38 +07:00
|
|
|
spec->ops.setup_stream = atihdmi_setup_stream;
|
2013-10-25 01:10:35 +07:00
|
|
|
|
|
|
|
if (!has_amd_full_remap_support(codec)) {
|
|
|
|
/* override to ATI/AMD-specific versions with pairwise mapping */
|
|
|
|
spec->ops.chmap_cea_alloc_validate_get_type =
|
|
|
|
atihdmi_paired_chmap_cea_alloc_validate_get_type;
|
|
|
|
spec->ops.cea_alloc_to_tlv_chmap = atihdmi_paired_cea_alloc_to_tlv_chmap;
|
|
|
|
spec->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->channels_max = max(spec->channels_max, 8u);
|
|
|
|
|
2010-09-07 17:27:25 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-08 18:18:42 +07:00
|
|
|
/* VIA HDMI Implementation */
|
|
|
|
#define VIAHDMI_CVT_NID 0x02 /* audio converter1 */
|
|
|
|
#define VIAHDMI_PIN_NID 0x03 /* HDMI output pin1 */
|
|
|
|
|
|
|
|
static int patch_via_hdmi(struct hda_codec *codec)
|
|
|
|
{
|
2012-06-15 19:40:21 +07:00
|
|
|
return patch_simple_hdmi(codec, VIAHDMI_CVT_NID, VIAHDMI_PIN_NID);
|
2012-06-08 18:18:42 +07:00
|
|
|
}
|
2010-09-07 17:27:25 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* patch entries
|
|
|
|
*/
|
2011-05-02 17:17:41 +07:00
|
|
|
static const struct hda_codec_preset snd_hda_preset_hdmi[] = {
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x1002793c, .name = "RS600 HDMI", .patch = patch_atihdmi },
|
|
|
|
{ .id = 0x10027919, .name = "RS600 HDMI", .patch = patch_atihdmi },
|
|
|
|
{ .id = 0x1002791a, .name = "RS690/780 HDMI", .patch = patch_atihdmi },
|
2013-10-25 01:10:35 +07:00
|
|
|
{ .id = 0x1002aa01, .name = "R6xx HDMI", .patch = patch_atihdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x10951390, .name = "SiI1390 HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x17e80047, .name = "Chrontel HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x10de0002, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
|
|
|
|
{ .id = 0x10de0003, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
|
|
|
|
{ .id = 0x10de0005, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
|
|
|
|
{ .id = 0x10de0006, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x },
|
|
|
|
{ .id = 0x10de0007, .name = "MCP79/7A HDMI", .patch = patch_nvhdmi_8ch_7x },
|
2013-11-03 22:15:00 +07:00
|
|
|
{ .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de000c, .name = "MCP89 HDMI", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0015, .name = "GPU 15 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0016, .name = "GPU 16 HDMI/DP", .patch = patch_nvhdmi },
|
2011-03-03 18:46:13 +07:00
|
|
|
/* 17 is known to be absent */
|
2013-11-03 22:15:00 +07:00
|
|
|
{ .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi },
|
2015-05-05 19:56:22 +07:00
|
|
|
{ .id = 0x10de0020, .name = "Tegra30 HDMI", .patch = patch_tegra_hdmi },
|
2015-05-05 19:56:23 +07:00
|
|
|
{ .id = 0x10de0022, .name = "Tegra114 HDMI", .patch = patch_tegra_hdmi },
|
2015-05-05 19:56:20 +07:00
|
|
|
{ .id = 0x10de0028, .name = "Tegra124 HDMI", .patch = patch_tegra_hdmi },
|
2015-05-05 19:56:24 +07:00
|
|
|
{ .id = 0x10de0029, .name = "Tegra210 HDMI/DP", .patch = patch_tegra_hdmi },
|
2013-11-03 22:15:00 +07:00
|
|
|
{ .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0051, .name = "GPU 51 HDMI/DP", .patch = patch_nvhdmi },
|
|
|
|
{ .id = 0x10de0060, .name = "GPU 60 HDMI/DP", .patch = patch_nvhdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
|
2014-07-08 14:21:38 +07:00
|
|
|
{ .id = 0x10de0070, .name = "GPU 70 HDMI/DP", .patch = patch_nvhdmi },
|
2014-05-13 10:05:02 +07:00
|
|
|
{ .id = 0x10de0071, .name = "GPU 71 HDMI/DP", .patch = patch_nvhdmi },
|
2015-01-07 04:40:14 +07:00
|
|
|
{ .id = 0x10de0072, .name = "GPU 72 HDMI/DP", .patch = patch_nvhdmi },
|
2015-07-21 07:14:14 +07:00
|
|
|
{ .id = 0x10de007d, .name = "GPU 7d HDMI/DP", .patch = patch_nvhdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch },
|
2012-06-08 18:18:42 +07:00
|
|
|
{ .id = 0x11069f80, .name = "VX900 HDMI/DP", .patch = patch_via_hdmi },
|
|
|
|
{ .id = 0x11069f81, .name = "VX900 HDMI/DP", .patch = patch_via_hdmi },
|
|
|
|
{ .id = 0x11069f84, .name = "VX11 HDMI/DP", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x11069f85, .name = "VX11 HDMI/DP", .patch = patch_generic_hdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x80860054, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x80862801, .name = "Bearlake HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x80862802, .name = "Cantiga HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x80862803, .name = "Eaglelake HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x80862804, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi },
|
|
|
|
{ .id = 0x80862805, .name = "CougarPoint HDMI", .patch = patch_generic_hdmi },
|
2011-05-20 14:35:43 +07:00
|
|
|
{ .id = 0x80862806, .name = "PantherPoint HDMI", .patch = patch_generic_hdmi },
|
2012-06-13 09:23:52 +07:00
|
|
|
{ .id = 0x80862807, .name = "Haswell HDMI", .patch = patch_generic_hdmi },
|
2014-01-09 03:55:24 +07:00
|
|
|
{ .id = 0x80862808, .name = "Broadwell HDMI", .patch = patch_generic_hdmi },
|
2014-12-15 11:49:42 +07:00
|
|
|
{ .id = 0x80862809, .name = "Skylake HDMI", .patch = patch_generic_hdmi },
|
2015-07-06 09:44:26 +07:00
|
|
|
{ .id = 0x8086280a, .name = "Broxton HDMI", .patch = patch_generic_hdmi },
|
2012-02-23 14:07:44 +07:00
|
|
|
{ .id = 0x80862880, .name = "CedarTrail HDMI", .patch = patch_generic_hdmi },
|
2013-10-21 10:03:31 +07:00
|
|
|
{ .id = 0x80862882, .name = "Valleyview2 HDMI", .patch = patch_generic_hdmi },
|
2014-08-04 08:22:45 +07:00
|
|
|
{ .id = 0x80862883, .name = "Braswell HDMI", .patch = patch_generic_hdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_generic_hdmi },
|
2015-02-17 21:25:37 +07:00
|
|
|
/* special ID for generic HDMI */
|
|
|
|
{ .id = HDA_CODEC_ID_GENERIC_HDMI, .patch = patch_generic_hdmi },
|
2010-09-07 17:27:25 +07:00
|
|
|
{} /* terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:1002793c");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10027919");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:1002791a");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:1002aa01");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10951390");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10951392");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0002");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0003");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0005");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0006");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0007");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de000a");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de000b");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de000c");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de000d");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0010");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0011");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0012");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0013");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0014");
|
2011-03-03 18:46:13 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0015");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0016");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0018");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0019");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de001a");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de001b");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de001c");
|
2014-05-20 09:17:39 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0028");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0040");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0041");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0042");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0043");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0044");
|
2012-07-17 07:10:04 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0051");
|
2013-07-13 01:01:37 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0060");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0067");
|
2014-07-08 14:21:38 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0070");
|
2014-05-13 10:05:02 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0071");
|
2015-01-07 04:40:14 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de0072");
|
2015-07-21 07:14:14 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de007d");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:10de8001");
|
2012-06-08 18:18:42 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:11069f80");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:11069f81");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:11069f84");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:11069f85");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:17e80047");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80860054");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862801");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862802");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862803");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862804");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862805");
|
2011-05-20 14:35:43 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862806");
|
2012-06-13 09:23:52 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862807");
|
2014-01-09 03:55:24 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862808");
|
2014-12-15 11:49:42 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862809");
|
2015-07-06 09:44:26 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:8086280a");
|
2012-02-23 14:07:44 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862880");
|
2013-10-21 10:03:31 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862882");
|
2014-08-04 08:22:45 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:80862883");
|
2010-09-07 17:27:25 +07:00
|
|
|
MODULE_ALIAS("snd-hda-codec-id:808629fb");
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("HDMI HD-audio codec");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-intelhdmi");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-nvhdmi");
|
|
|
|
MODULE_ALIAS("snd-hda-codec-atihdmi");
|
|
|
|
|
2015-02-17 21:25:37 +07:00
|
|
|
static struct hda_codec_driver hdmi_driver = {
|
2010-09-07 17:27:25 +07:00
|
|
|
.preset = snd_hda_preset_hdmi,
|
|
|
|
};
|
|
|
|
|
2015-02-17 21:25:37 +07:00
|
|
|
module_hda_codec_driver(hdmi_driver);
|