2019-05-27 06:55:05 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Universal Interface for Intel High Definition Audio Codec
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __SOUND_HDA_CODEC_H
|
|
|
|
|
#define __SOUND_HDA_CODEC_H
|
|
|
|
|
|
2015-02-27 16:43:19 +00:00
|
|
|
#include <linux/kref.h>
|
2015-10-01 14:20:04 +00:00
|
|
|
#include <linux/mod_devicetable.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <sound/info.h>
|
|
|
|
|
#include <sound/control.h>
|
|
|
|
|
#include <sound/pcm.h>
|
2007-07-27 16:58:06 +00:00
|
|
|
#include <sound/hwdep.h>
|
2015-02-17 20:46:37 +00:00
|
|
|
#include <sound/hdaudio.h>
|
2013-12-09 13:28:36 +00:00
|
|
|
#include <sound/hda_verbs.h>
|
ALSA: hda - Add regmap support
This patch adds an infrastructure to support regmap-based verb
accesses. Because o the asymmetric nature of HD-audio verbs,
especially the amp verbs, we need to translate the verbs as a sort of
pseudo registers to be mapped uniquely in regmap.
In this patch, a pseudo register is built from the NID, the
AC_VERB_GET_* and 8bit parameters, i.e. almost in the form to be sent
to HD-audio bus but without codec address field. OTOH, for writing,
the same pseudo register is translated to AC_VERB_SET_* automatically.
The AC_VERB_SET_AMP_* verb is re-encoded from the corresponding
AC_VERB_GET_AMP_* verb and parameter at writing.
Some verbs has a single command for read but multiple for writes. A
write for such a verb is split automatically to multiple verbs.
The patch provides also a few handy helper functions. They are
designed to be accessible even without regmap. When no regmap is set
up (e.g. before the codec device instantiation), the direct hardware
access is used. Also, it tries to avoid the unnecessary power-up.
The power up/down sequence is performed only on demand.
The codec driver needs to call snd_hdac_regmap_exit() and
snd_hdac_regmap_exit() at probe and remove if it wants the regmap
access.
There is one flag added to hdac_device. When the flag lazy_cache is
set, regmap helper ignores a write for a suspended device and returns
as if it was actually written. It reduces the hardware access pretty
much, e.g. when adjusting the mixer volume while in idle. This
assumes that the driver will sync the cache later at resume properly,
so use it carefully.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-02-25 13:42:38 +00:00
|
|
|
#include <sound/hda_regmap.h>
|
2008-11-10 15:24:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Structures
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
struct hda_bus;
|
2008-07-18 16:20:52 +00:00
|
|
|
struct hda_beep;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct hda_codec;
|
|
|
|
|
struct hda_pcm;
|
|
|
|
|
struct hda_pcm_stream;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* codec bus
|
|
|
|
|
*
|
|
|
|
|
* each controller needs to creata a hda_bus to assign the accessor.
|
|
|
|
|
* A hda_bus contains several codecs in the list codec_list.
|
|
|
|
|
*/
|
|
|
|
|
struct hda_bus {
|
2015-03-02 22:22:59 +00:00
|
|
|
struct hdac_bus core;
|
|
|
|
|
|
2005-11-17 13:57:47 +00:00
|
|
|
struct snd_card *card;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct pci_dev *pci;
|
|
|
|
|
const char *modelname;
|
|
|
|
|
|
2010-08-20 07:44:36 +00:00
|
|
|
struct mutex prepare_mutex;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-11-27 13:17:01 +00:00
|
|
|
/* assigned PCMs */
|
|
|
|
|
DECLARE_BITMAP(pcm_dev_bits, SNDRV_PCM_DEVICES);
|
|
|
|
|
|
2008-01-16 15:09:47 +00:00
|
|
|
/* misc op flags */
|
|
|
|
|
unsigned int needs_damn_long_delay :1;
|
2009-06-01 23:20:22 +00:00
|
|
|
unsigned int allow_bus_reset:1; /* allow bus reset at fatal error */
|
|
|
|
|
/* status for codec/controller */
|
2008-11-21 08:08:06 +00:00
|
|
|
unsigned int shutdown :1; /* being unloaded */
|
2009-06-01 23:16:07 +00:00
|
|
|
unsigned int response_reset:1; /* controller was reset */
|
|
|
|
|
unsigned int in_reset:1; /* during reset operation */
|
2013-06-06 12:20:19 +00:00
|
|
|
unsigned int no_response_fallback:1; /* don't fallback at RIRB error */
|
2019-01-30 16:46:03 +00:00
|
|
|
unsigned int bus_probing :1; /* during probing process */
|
ALSA: hda - Fix broken workaround for HDMI/SPDIF conflicts
The commit [dcda58061: ALSA: hda - Add workaround for conflicting
IEC958 controls] introduced a workaround for cards that have both
SPDIF and HDMI devices for giving device=1 to SPDIF control elements.
It turned out, however, that this workaround doesn't work well -
- The workaround checks only conflicts in a single codec, but SPDIF
and HDMI are provided by multiple codecs in many cases, and
- ALSA mixer abstraction doesn't care about the device number in ctl
elements, thus you'll get errors from amixer such as
% amixer scontrols -c 0
ALSA lib simple_none.c:1551:(simple_add1) helem (MIXER,'IEC958
Playback Switch',0,1,0) appears twice or more
amixer: Mixer hw:0 load error: Invalid argument
This patch fixes the previous broken workaround. Instead of changing
the device number of SPDIF ctl elements, shift the element indices of
such controls up to 16. Also, the conflict check is performed over
all codecs found on the bus.
HDMI devices will be put to dev=0,index=0 as before. Only the
conflicting SPDIF device is moved to a different place. The new place
of SPDIF device is supposed by the updated alsa-lib HDA-Intel.conf,
respectively.
Reported-by: Stephan Raue <stephan@openelec.tv>
Reported-by: Anssi Hannula <anssi.hannula@iki.fi>
Cc: <stable@vger.kernel.org> [v3.8]
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2013-02-12 16:02:41 +00:00
|
|
|
|
|
|
|
|
int primary_dig_out_type; /* primary digital out PCM type */
|
2015-10-17 16:25:38 +00:00
|
|
|
unsigned int mixer_assigned; /* codec addr for mixer name */
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2015-04-14 14:55:31 +00:00
|
|
|
/* from hdac_bus to hda_bus */
|
|
|
|
|
#define to_hda_bus(bus) container_of(bus, struct hda_bus, core)
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* codec preset
|
|
|
|
|
*
|
|
|
|
|
* Known codecs have the patch to build and set up the controls/PCMs
|
|
|
|
|
* better than the generic parser.
|
|
|
|
|
*/
|
2015-10-01 14:20:04 +00:00
|
|
|
typedef int (*hda_codec_patch_t)(struct hda_codec *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-06-27 07:54:46 +00:00
|
|
|
#define HDA_CODEC_ID_SKIP_PROBE 0x00000001
|
2015-02-17 14:25:37 +00:00
|
|
|
#define HDA_CODEC_ID_GENERIC_HDMI 0x00000101
|
|
|
|
|
#define HDA_CODEC_ID_GENERIC 0x00000201
|
|
|
|
|
|
2015-10-01 14:20:04 +00:00
|
|
|
#define HDA_CODEC_REV_ENTRY(_vid, _rev, _name, _patch) \
|
|
|
|
|
{ .vendor_id = (_vid), .rev_id = (_rev), .name = (_name), \
|
|
|
|
|
.api_version = HDA_DEV_LEGACY, \
|
|
|
|
|
.driver_data = (unsigned long)(_patch) }
|
|
|
|
|
#define HDA_CODEC_ENTRY(_vid, _name, _patch) \
|
|
|
|
|
HDA_CODEC_REV_ENTRY(_vid, 0, _name, _patch)
|
|
|
|
|
|
2015-02-17 14:25:37 +00:00
|
|
|
struct hda_codec_driver {
|
2015-02-17 20:46:37 +00:00
|
|
|
struct hdac_driver core;
|
2015-10-01 14:20:04 +00:00
|
|
|
const struct hda_device_id *id;
|
2008-11-27 14:47:11 +00:00
|
|
|
};
|
|
|
|
|
|
2015-02-17 14:25:37 +00:00
|
|
|
int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name,
|
|
|
|
|
struct module *owner);
|
|
|
|
|
#define hda_codec_driver_register(drv) \
|
|
|
|
|
__hda_codec_driver_register(drv, KBUILD_MODNAME, THIS_MODULE)
|
|
|
|
|
void hda_codec_driver_unregister(struct hda_codec_driver *drv);
|
|
|
|
|
#define module_hda_codec_driver(drv) \
|
|
|
|
|
module_driver(drv, hda_codec_driver_register, \
|
|
|
|
|
hda_codec_driver_unregister)
|
2008-11-27 14:47:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* ops set by the preset patch */
|
|
|
|
|
struct hda_codec_ops {
|
|
|
|
|
int (*build_controls)(struct hda_codec *codec);
|
|
|
|
|
int (*build_pcms)(struct hda_codec *codec);
|
|
|
|
|
int (*init)(struct hda_codec *codec);
|
|
|
|
|
void (*free)(struct hda_codec *codec);
|
|
|
|
|
void (*unsol_event)(struct hda_codec *codec, unsigned int res);
|
2011-07-26 08:33:10 +00:00
|
|
|
void (*set_power_state)(struct hda_codec *codec, hda_nid_t fg,
|
|
|
|
|
unsigned int power_state);
|
2011-07-26 07:52:50 +00:00
|
|
|
#ifdef CONFIG_PM
|
2012-07-02 13:20:37 +00:00
|
|
|
int (*suspend)(struct hda_codec *codec);
|
2005-04-16 22:20:36 +00:00
|
|
|
int (*resume)(struct hda_codec *codec);
|
2007-08-10 15:21:45 +00:00
|
|
|
int (*check_power_status)(struct hda_codec *codec, hda_nid_t nid);
|
|
|
|
|
#endif
|
2009-11-10 15:02:29 +00:00
|
|
|
void (*reboot_notify)(struct hda_codec *codec);
|
ALSA: hda - Support advanced power state controls
This patch enables the finer power state control of each widget
depending on the jack plug state and streaming state in addition to
the existing power_down_unused power optimization. The new feature is
enabled only when codec->power_mgmt flag is set.
Two new flags, pin_enabled and stream_enabled, are introduced in
nid_path struct for marking the two individual power states: the pin
plug/unplug and DAC/ADC stream, respectively. They can be set
statically in case they are static routes (e.g. some mixer paths),
too.
The power up and down events for each pin are triggered via the
standard hda_jack table. The call order is hard-coded, relying on the
current implementation of jack event chain (a la FILO/stack order).
One point to be dealt carefully is that DAC/ADC cannot be powered
on/off while streaming. They are pinned as long as the stream is
running. For controlling the power of DAC/ADC, a new patch_ops is
added. The generic parser provides the default callback for that.
As of this patch, only IDT/Sigmatel codec driver enables the flag.
The support on other codecs will follow.
An assumption we made in this code is that the widget state (e.g. amp,
pinctl, connections) remains after the widget power transition (not
about FG power transition). This is true for IDT codecs, at least.
But if the widget state is lost at widget power transition, we'd need
to implement additional code to sync the cached amp/verbs for the
specific NID.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-03-16 20:32:11 +00:00
|
|
|
void (*stream_pm)(struct hda_codec *codec, hda_nid_t nid, bool on);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* PCM callbacks */
|
|
|
|
|
struct hda_pcm_ops {
|
|
|
|
|
int (*open)(struct hda_pcm_stream *info, struct hda_codec *codec,
|
2005-11-17 13:57:47 +00:00
|
|
|
struct snd_pcm_substream *substream);
|
2005-04-16 22:20:36 +00:00
|
|
|
int (*close)(struct hda_pcm_stream *info, struct hda_codec *codec,
|
2005-11-17 13:57:47 +00:00
|
|
|
struct snd_pcm_substream *substream);
|
2005-04-16 22:20:36 +00:00
|
|
|
int (*prepare)(struct hda_pcm_stream *info, struct hda_codec *codec,
|
|
|
|
|
unsigned int stream_tag, unsigned int format,
|
2005-11-17 13:57:47 +00:00
|
|
|
struct snd_pcm_substream *substream);
|
2005-04-16 22:20:36 +00:00
|
|
|
int (*cleanup)(struct hda_pcm_stream *info, struct hda_codec *codec,
|
2005-11-17 13:57:47 +00:00
|
|
|
struct snd_pcm_substream *substream);
|
2013-04-05 05:27:45 +00:00
|
|
|
unsigned int (*get_delay)(struct hda_pcm_stream *info,
|
|
|
|
|
struct hda_codec *codec,
|
|
|
|
|
struct snd_pcm_substream *substream);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* PCM information for each substream */
|
|
|
|
|
struct hda_pcm_stream {
|
2007-07-27 14:52:19 +00:00
|
|
|
unsigned int substreams; /* number of substreams, 0 = not exist*/
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int channels_min; /* min. number of channels */
|
|
|
|
|
unsigned int channels_max; /* max. number of channels */
|
|
|
|
|
hda_nid_t nid; /* default NID to query rates/formats/bps, or set up */
|
|
|
|
|
u32 rates; /* supported rates */
|
|
|
|
|
u64 formats; /* supported formats (SNDRV_PCM_FMTBIT_) */
|
|
|
|
|
unsigned int maxbps; /* supported max. bit per sample */
|
2012-11-08 16:12:10 +00:00
|
|
|
const struct snd_pcm_chmap_elem *chmap; /* chmap to override */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct hda_pcm_ops ops;
|
|
|
|
|
};
|
|
|
|
|
|
[ALSA] hda-intel - Fix PCM device number assignment
In the current scheme, PCM device numbers are assigned incrementally
in the order of codecs. This causes problems when the codec number
is irregular, e.g. codec #0 for HDMI and codec #1 for analog. Then
the HDMI becomes the first PCM, which is picked up as the default
output device. Unfortuantely this doesn't work well with normal
setups.
This patch introduced the fixed device numbers for the PCM types,
namely, analog, SPDIF, HDMI and modem. The PCM devices are assigned
according to the corresponding PCM type. After this patch, HDMI will
be always assigned to PCM #3, SPDIF to PCM #1, and the first analog
to PCM #0, etc.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2008-02-06 13:03:20 +00:00
|
|
|
/* PCM types */
|
|
|
|
|
enum {
|
|
|
|
|
HDA_PCM_TYPE_AUDIO,
|
|
|
|
|
HDA_PCM_TYPE_SPDIF,
|
|
|
|
|
HDA_PCM_TYPE_HDMI,
|
|
|
|
|
HDA_PCM_TYPE_MODEM,
|
|
|
|
|
HDA_PCM_NTYPES
|
|
|
|
|
};
|
|
|
|
|
|
2017-09-03 13:18:49 +00:00
|
|
|
#define SNDRV_PCM_INVALID_DEVICE (-1)
|
2005-04-16 22:20:36 +00:00
|
|
|
/* for PCM creation */
|
|
|
|
|
struct hda_pcm {
|
|
|
|
|
char *name;
|
|
|
|
|
struct hda_pcm_stream stream[2];
|
[ALSA] hda-intel - Fix PCM device number assignment
In the current scheme, PCM device numbers are assigned incrementally
in the order of codecs. This causes problems when the codec number
is irregular, e.g. codec #0 for HDMI and codec #1 for analog. Then
the HDMI becomes the first PCM, which is picked up as the default
output device. Unfortuantely this doesn't work well with normal
setups.
This patch introduced the fixed device numbers for the PCM types,
namely, analog, SPDIF, HDMI and modem. The PCM devices are assigned
according to the corresponding PCM type. After this patch, HDMI will
be always assigned to PCM #3, SPDIF to PCM #1, and the first analog
to PCM #0, etc.
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2008-02-06 13:03:20 +00:00
|
|
|
unsigned int pcm_type; /* HDA_PCM_TYPE_XXX */
|
2008-07-30 13:01:44 +00:00
|
|
|
int device; /* device number to assign */
|
|
|
|
|
struct snd_pcm *pcm; /* assigned PCM instance */
|
2012-07-31 09:35:35 +00:00
|
|
|
bool own_chmap; /* codec driver provides own channel maps */
|
2015-02-27 16:43:19 +00:00
|
|
|
/* private: */
|
|
|
|
|
struct hda_codec *codec;
|
|
|
|
|
struct kref kref;
|
|
|
|
|
struct list_head list;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* codec information */
|
|
|
|
|
struct hda_codec {
|
2015-02-17 20:46:37 +00:00
|
|
|
struct hdac_device core;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct hda_bus *bus;
|
2015-02-27 15:09:22 +00:00
|
|
|
struct snd_card *card;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int addr; /* codec addr*/
|
2015-02-17 14:25:37 +00:00
|
|
|
u32 probe_id; /* overridden id for probing */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* detected preset */
|
2015-10-01 14:20:04 +00:00
|
|
|
const struct hda_device_id *preset;
|
2008-07-30 13:01:45 +00:00
|
|
|
const char *modelname; /* model name for preset */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* set by patch */
|
|
|
|
|
struct hda_codec_ops patch_ops;
|
|
|
|
|
|
|
|
|
|
/* PCM to create, set by patch_ops.build_pcms callback */
|
2015-02-27 16:43:19 +00:00
|
|
|
struct list_head pcm_list_head;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* codec specific info */
|
|
|
|
|
void *spec;
|
|
|
|
|
|
2008-07-18 16:20:52 +00:00
|
|
|
/* beep device */
|
|
|
|
|
struct hda_beep *beep;
|
2009-11-13 17:41:52 +00:00
|
|
|
unsigned int beep_mode;
|
2008-07-18 16:20:52 +00:00
|
|
|
|
2005-11-21 15:33:22 +00:00
|
|
|
/* widget capabilities cache */
|
|
|
|
|
u32 *wcaps;
|
|
|
|
|
|
2008-07-30 13:01:45 +00:00
|
|
|
struct snd_array mixers; /* list of assigned mixer elements */
|
2009-12-08 15:13:32 +00:00
|
|
|
struct snd_array nids; /* list of mapped mixer elements */
|
2008-07-30 13:01:45 +00:00
|
|
|
|
2013-01-03 14:25:11 +00:00
|
|
|
struct list_head conn_list; /* linked-list of connection-list */
|
2011-04-07 13:55:15 +00:00
|
|
|
|
2006-01-16 15:34:20 +00:00
|
|
|
struct mutex spdif_mutex;
|
2009-01-09 08:45:24 +00:00
|
|
|
struct mutex control_mutex;
|
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-01 17:14:17 +00:00
|
|
|
struct snd_array spdif_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int spdif_in_enable; /* SPDIF input enable? */
|
2011-05-02 09:29:30 +00:00
|
|
|
const hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
|
2009-02-20 13:11:16 +00:00
|
|
|
struct snd_array init_pins; /* initial (BIOS) pin configurations */
|
2009-02-23 08:42:57 +00:00
|
|
|
struct snd_array driver_pins; /* pin configs set by codec parser */
|
2010-08-06 11:48:11 +00:00
|
|
|
struct snd_array cvt_setups; /* audio convert setups */
|
2007-07-27 16:58:06 +00:00
|
|
|
|
2013-01-10 17:21:56 +00:00
|
|
|
struct mutex user_mutex;
|
2014-02-25 10:54:06 +00:00
|
|
|
#ifdef CONFIG_SND_HDA_RECONFIG
|
2008-07-30 13:01:46 +00:00
|
|
|
struct snd_array init_verbs; /* additional init verbs */
|
2008-07-30 13:01:46 +00:00
|
|
|
struct snd_array hints; /* additional hints */
|
2009-02-23 08:42:57 +00:00
|
|
|
struct snd_array user_pins; /* default pin configs to override */
|
2008-07-30 13:01:46 +00:00
|
|
|
#endif
|
2007-08-10 15:21:45 +00:00
|
|
|
|
2014-02-25 09:38:13 +00:00
|
|
|
#ifdef CONFIG_SND_HDA_HWDEP
|
|
|
|
|
struct snd_hwdep *hwdep; /* assigned hwdep device */
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-08-11 08:04:40 +00:00
|
|
|
/* misc flags */
|
2015-02-27 17:17:28 +00:00
|
|
|
unsigned int in_freeing:1; /* being released */
|
2015-03-03 16:22:12 +00:00
|
|
|
unsigned int registered:1; /* codec was registered */
|
2018-12-08 16:31:49 +00:00
|
|
|
unsigned int display_power_control:1; /* needs display power */
|
2008-08-11 08:04:40 +00:00
|
|
|
unsigned int spdif_status_reset :1; /* needs to toggle SPDIF for each
|
|
|
|
|
* status change
|
|
|
|
|
* (e.g. Realtek codecs)
|
|
|
|
|
*/
|
2009-03-12 16:06:07 +00:00
|
|
|
unsigned int pin_amp_workaround:1; /* pin out-amp takes index
|
|
|
|
|
* (e.g. Conexant codecs)
|
|
|
|
|
*/
|
2012-04-06 13:34:15 +00:00
|
|
|
unsigned int single_adc_amp:1; /* adc in-amp takes no index
|
|
|
|
|
* (e.g. CX20549 codec)
|
|
|
|
|
*/
|
2010-10-25 08:37:11 +00:00
|
|
|
unsigned int no_sticky_stream:1; /* no sticky-PCM stream assignment */
|
2010-07-05 14:50:13 +00:00
|
|
|
unsigned int pins_shutup:1; /* pins are shut up */
|
2009-12-25 21:49:01 +00:00
|
|
|
unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */
|
2012-02-13 10:55:02 +00:00
|
|
|
unsigned int no_jack_detect:1; /* Machine has no jack-detection */
|
2012-12-21 14:23:01 +00:00
|
|
|
unsigned int inv_eapd:1; /* broken h/w: inverted EAPD control */
|
2012-12-21 14:31:41 +00:00
|
|
|
unsigned int inv_jack_detect:1; /* broken h/w: inverted detection bit */
|
2012-08-08 15:12:52 +00:00
|
|
|
unsigned int pcm_format_first:1; /* PCM format must be set first */
|
2012-12-13 17:30:04 +00:00
|
|
|
unsigned int cached_write:1; /* write only to caches */
|
2013-08-27 01:35:21 +00:00
|
|
|
unsigned int dp_mst:1; /* support DP1.2 Multi-stream transport */
|
2014-01-29 09:37:10 +00:00
|
|
|
unsigned int dump_coef:1; /* dump processing coefs in codec proc file */
|
2015-03-20 17:21:03 +00:00
|
|
|
unsigned int power_save_node:1; /* advanced PM for each widget */
|
2015-06-09 08:50:38 +00:00
|
|
|
unsigned int auto_runtime_pm:1; /* enable automatic codec runtime pm */
|
2017-04-10 15:12:33 +00:00
|
|
|
unsigned int force_pin_prefix:1; /* Add location prefix */
|
2018-06-21 11:33:53 +00:00
|
|
|
unsigned int link_down_at_suspend:1; /* link down at runtime suspend */
|
2012-08-24 16:38:08 +00:00
|
|
|
#ifdef CONFIG_PM
|
2009-11-11 08:34:25 +00:00
|
|
|
unsigned long power_on_acct;
|
|
|
|
|
unsigned long power_off_acct;
|
|
|
|
|
unsigned long power_jiffies;
|
2007-08-10 15:21:45 +00:00
|
|
|
#endif
|
2008-11-28 11:55:36 +00:00
|
|
|
|
2013-01-24 16:23:35 +00:00
|
|
|
/* filter the requested power state per nid */
|
|
|
|
|
unsigned int (*power_filter)(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
unsigned int power_state);
|
|
|
|
|
|
2008-11-28 11:55:36 +00:00
|
|
|
/* codec-specific additional proc output */
|
|
|
|
|
void (*proc_widget_hook)(struct snd_info_buffer *buffer,
|
|
|
|
|
struct hda_codec *codec, hda_nid_t nid);
|
2011-03-03 13:40:14 +00:00
|
|
|
|
2011-10-27 20:12:46 +00:00
|
|
|
/* jack detection */
|
|
|
|
|
struct snd_array jacktbl;
|
2012-10-09 13:04:21 +00:00
|
|
|
unsigned long jackpoll_interval; /* In jiffies. Zero means no poll, rely on unsol events */
|
|
|
|
|
struct delayed_work jackpoll_work;
|
2011-10-27 20:12:46 +00:00
|
|
|
|
2011-03-03 13:40:14 +00:00
|
|
|
/* jack detection */
|
|
|
|
|
struct snd_array jacks;
|
2012-12-18 17:12:44 +00:00
|
|
|
|
2013-11-29 06:48:45 +00:00
|
|
|
int depop_delay; /* depop delay in ms, -1 for default delay time */
|
|
|
|
|
|
2012-12-18 17:12:44 +00:00
|
|
|
/* fix-up list */
|
|
|
|
|
int fixup_id;
|
|
|
|
|
const struct hda_fixup *fixup_list;
|
|
|
|
|
const char *fixup_name;
|
|
|
|
|
|
|
|
|
|
/* additional init verbs */
|
|
|
|
|
struct snd_array verbs;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2015-02-17 20:46:37 +00:00
|
|
|
#define dev_to_hda_codec(_dev) container_of(_dev, struct hda_codec, core.dev)
|
|
|
|
|
#define hda_codec_dev(_dev) (&(_dev)->core.dev)
|
2015-02-17 14:25:37 +00:00
|
|
|
|
2015-03-02 22:22:59 +00:00
|
|
|
#define list_for_each_codec(c, bus) \
|
|
|
|
|
list_for_each_entry(c, &(bus)->core.codec_list, core.list)
|
2017-06-28 10:02:02 +00:00
|
|
|
#define list_for_each_codec_safe(c, n, bus) \
|
|
|
|
|
list_for_each_entry_safe(c, n, &(bus)->core.codec_list, core.list)
|
2015-03-02 22:22:59 +00:00
|
|
|
|
2013-06-06 12:20:19 +00:00
|
|
|
/* snd_hda_codec_read/write optional flags */
|
|
|
|
|
#define HDA_RW_NO_RESPONSE_FALLBACK (1 << 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* constructors
|
|
|
|
|
*/
|
2015-02-27 15:09:22 +00:00
|
|
|
int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
|
|
|
|
|
unsigned int codec_addr, struct hda_codec **codecp);
|
2018-06-02 03:53:56 +00:00
|
|
|
int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
|
|
|
|
|
unsigned int codec_addr, struct hda_codec *codec);
|
2009-06-17 07:33:52 +00:00
|
|
|
int snd_hda_codec_configure(struct hda_codec *codec);
|
2013-02-08 22:09:31 +00:00
|
|
|
int snd_hda_codec_update_widgets(struct hda_codec *codec);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* low level functions
|
|
|
|
|
*/
|
2015-10-08 08:48:06 +00:00
|
|
|
static inline unsigned int
|
|
|
|
|
snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
|
2013-06-06 12:00:23 +00:00
|
|
|
int flags,
|
2015-10-08 08:48:06 +00:00
|
|
|
unsigned int verb, unsigned int parm)
|
|
|
|
|
{
|
|
|
|
|
return snd_hdac_codec_read(&codec->core, nid, flags, verb, parm);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
|
snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
|
|
|
|
|
unsigned int verb, unsigned int parm)
|
|
|
|
|
{
|
|
|
|
|
return snd_hdac_codec_write(&codec->core, nid, flags, verb, parm);
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-27 14:52:19 +00:00
|
|
|
#define snd_hda_param_read(codec, nid, param) \
|
2015-02-26 12:57:47 +00:00
|
|
|
snd_hdac_read_parm(&(codec)->core, nid, param)
|
2015-03-03 09:07:24 +00:00
|
|
|
#define snd_hda_get_sub_nodes(codec, nid, start_nid) \
|
|
|
|
|
snd_hdac_get_sub_nodes(&(codec)->core, nid, start_nid)
|
2007-07-27 14:52:19 +00:00
|
|
|
int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
hda_nid_t *conn_list, int max_conns);
|
2012-05-19 15:21:25 +00:00
|
|
|
static inline int
|
|
|
|
|
snd_hda_get_num_conns(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
|
{
|
|
|
|
|
return snd_hda_get_connections(codec, nid, NULL, 0);
|
|
|
|
|
}
|
2015-03-03 09:07:24 +00:00
|
|
|
|
|
|
|
|
#define snd_hda_get_raw_connections(codec, nid, list, max_conns) \
|
|
|
|
|
snd_hdac_get_connections(&(codec)->core, nid, list, max_conns)
|
|
|
|
|
#define snd_hda_get_num_raw_conns(codec, nid) \
|
|
|
|
|
snd_hdac_get_connections(&(codec)->core, nid, NULL, 0);
|
|
|
|
|
|
2013-01-03 14:25:11 +00:00
|
|
|
int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
const hda_nid_t **listp);
|
2011-07-04 14:23:26 +00:00
|
|
|
int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums,
|
|
|
|
|
const hda_nid_t *list);
|
2011-06-28 10:45:47 +00:00
|
|
|
int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
|
|
|
|
|
hda_nid_t nid, int recursive);
|
2017-01-12 08:04:52 +00:00
|
|
|
unsigned int snd_hda_get_num_devices(struct hda_codec *codec, hda_nid_t nid);
|
2013-08-27 01:35:21 +00:00
|
|
|
int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
u8 *dev_list, int max_devices);
|
2017-01-12 08:04:52 +00:00
|
|
|
int snd_hda_get_dev_select(struct hda_codec *codec, hda_nid_t nid);
|
|
|
|
|
int snd_hda_set_dev_select(struct hda_codec *codec, hda_nid_t nid, int dev_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
struct hda_verb {
|
|
|
|
|
hda_nid_t nid;
|
|
|
|
|
u32 verb;
|
|
|
|
|
u32 param;
|
|
|
|
|
};
|
|
|
|
|
|
2007-07-27 14:52:19 +00:00
|
|
|
void snd_hda_sequence_write(struct hda_codec *codec,
|
|
|
|
|
const struct hda_verb *seq);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* unsolicited event */
|
2015-03-02 22:22:59 +00:00
|
|
|
static inline void
|
|
|
|
|
snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
|
|
|
|
|
{
|
|
|
|
|
snd_hdac_bus_queue_event(&bus->core, res, res_ex);
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-10 15:03:40 +00:00
|
|
|
/* cached write */
|
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 11:34:49 +00:00
|
|
|
static inline int
|
|
|
|
|
snd_hda_codec_write_cache(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
int flags, unsigned int verb, unsigned int parm)
|
|
|
|
|
{
|
|
|
|
|
return snd_hdac_regmap_write(&codec->core, nid, verb, parm);
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-20 13:11:16 +00:00
|
|
|
/* the struct for codec->pin_configs */
|
|
|
|
|
struct hda_pincfg {
|
|
|
|
|
hda_nid_t nid;
|
2013-01-10 07:38:04 +00:00
|
|
|
unsigned char ctrl; /* original pin control value */
|
|
|
|
|
unsigned char target; /* target pin control value */
|
2010-07-05 14:50:13 +00:00
|
|
|
unsigned int cfg; /* default configuration */
|
2009-02-20 13:11:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid);
|
|
|
|
|
int snd_hda_codec_set_pincfg(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
unsigned int cfg);
|
|
|
|
|
int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
|
|
|
|
|
hda_nid_t nid, unsigned int cfg); /* for hwdep */
|
2009-12-27 10:18:59 +00:00
|
|
|
void snd_hda_shutup_pins(struct hda_codec *codec);
|
2009-02-20 13:11:16 +00:00
|
|
|
|
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-01 17:14:17 +00:00
|
|
|
/* SPDIF controls */
|
|
|
|
|
struct hda_spdif_out {
|
|
|
|
|
hda_nid_t nid; /* Converter nid values relate to */
|
|
|
|
|
unsigned int status; /* IEC958 status bits */
|
|
|
|
|
unsigned short ctls; /* SPDIF control bits */
|
|
|
|
|
};
|
|
|
|
|
struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
|
|
|
|
|
hda_nid_t nid);
|
2011-06-01 17:14:18 +00:00
|
|
|
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx);
|
|
|
|
|
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid);
|
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-01 17:14:17 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Mixer
|
|
|
|
|
*/
|
2008-07-30 13:01:45 +00:00
|
|
|
int snd_hda_codec_build_controls(struct hda_codec *codec);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* PCM
|
|
|
|
|
*/
|
2015-02-24 10:50:11 +00:00
|
|
|
int snd_hda_codec_parse_pcms(struct hda_codec *codec);
|
2008-11-27 13:17:01 +00:00
|
|
|
int snd_hda_codec_build_pcms(struct hda_codec *codec);
|
2010-08-06 11:48:11 +00:00
|
|
|
|
2015-02-27 16:43:19 +00:00
|
|
|
__printf(2, 3)
|
|
|
|
|
struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
|
|
|
|
|
const char *fmt, ...);
|
|
|
|
|
|
|
|
|
|
static inline void snd_hda_codec_pcm_get(struct hda_pcm *pcm)
|
|
|
|
|
{
|
|
|
|
|
kref_get(&pcm->kref);
|
|
|
|
|
}
|
|
|
|
|
void snd_hda_codec_pcm_put(struct hda_pcm *pcm);
|
|
|
|
|
|
2010-08-06 11:48:11 +00:00
|
|
|
int snd_hda_codec_prepare(struct hda_codec *codec,
|
|
|
|
|
struct hda_pcm_stream *hinfo,
|
|
|
|
|
unsigned int stream,
|
|
|
|
|
unsigned int format,
|
|
|
|
|
struct snd_pcm_substream *substream);
|
|
|
|
|
void snd_hda_codec_cleanup(struct hda_codec *codec,
|
|
|
|
|
struct hda_pcm_stream *hinfo,
|
|
|
|
|
struct snd_pcm_substream *substream);
|
|
|
|
|
|
2007-07-27 14:52:19 +00:00
|
|
|
void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
u32 stream_tag,
|
2005-04-16 22:20:36 +00:00
|
|
|
int channel_id, int format);
|
2010-08-13 09:56:53 +00:00
|
|
|
void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
|
int do_now);
|
|
|
|
|
#define snd_hda_codec_cleanup_stream(codec, nid) \
|
|
|
|
|
__snd_hda_codec_cleanup_stream(codec, nid, 0)
|
2015-04-16 06:19:06 +00:00
|
|
|
|
|
|
|
|
#define snd_hda_query_supported_pcm(codec, nid, ratesp, fmtsp, bpsp) \
|
|
|
|
|
snd_hdac_query_supported_pcm(&(codec)->core, nid, ratesp, fmtsp, bpsp)
|
|
|
|
|
#define snd_hda_is_supported_format(codec, nid, fmt) \
|
|
|
|
|
snd_hdac_is_supported_format(&(codec)->core, nid, fmt)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-11-08 16:12:10 +00:00
|
|
|
extern const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[];
|
|
|
|
|
|
2015-04-16 21:25:02 +00:00
|
|
|
int snd_hda_attach_pcm_stream(struct hda_bus *_bus, struct hda_codec *codec,
|
|
|
|
|
struct hda_pcm *cpcm);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Misc
|
|
|
|
|
*/
|
|
|
|
|
void snd_hda_get_codec_name(struct hda_codec *codec, char *name, int namelen);
|
2011-07-26 08:33:10 +00:00
|
|
|
void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
|
2013-01-24 16:23:35 +00:00
|
|
|
unsigned int power_state);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-26 10:11:44 +00:00
|
|
|
int snd_hda_lock_devices(struct hda_bus *bus);
|
|
|
|
|
void snd_hda_unlock_devices(struct hda_bus *bus);
|
2015-02-18 14:39:59 +00:00
|
|
|
void snd_hda_bus_reset(struct hda_bus *bus);
|
2015-04-16 21:25:02 +00:00
|
|
|
void snd_hda_bus_reset_codecs(struct hda_bus *bus);
|
2012-04-26 10:11:44 +00:00
|
|
|
|
2015-10-01 15:59:43 +00:00
|
|
|
int snd_hda_codec_set_name(struct hda_codec *codec, const char *name);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* power management
|
|
|
|
|
*/
|
2015-02-18 14:39:59 +00:00
|
|
|
extern const struct dev_pm_ops hda_codec_driver_pm;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-21 07:57:06 +00:00
|
|
|
static inline
|
|
|
|
|
int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
|
{
|
2012-08-24 16:38:08 +00:00
|
|
|
#ifdef CONFIG_PM
|
2010-09-21 07:57:06 +00:00
|
|
|
if (codec->patch_ops.check_power_status)
|
|
|
|
|
return codec->patch_ops.check_power_status(codec, nid);
|
2011-06-28 06:59:30 +00:00
|
|
|
#endif
|
2010-09-21 07:57:06 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-10 15:21:45 +00:00
|
|
|
/*
|
|
|
|
|
* power saving
|
|
|
|
|
*/
|
2015-03-03 09:07:24 +00:00
|
|
|
#define snd_hda_power_up(codec) snd_hdac_power_up(&(codec)->core)
|
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 09:43:14 +00:00
|
|
|
#define snd_hda_power_up_pm(codec) snd_hdac_power_up_pm(&(codec)->core)
|
2015-03-03 09:07:24 +00:00
|
|
|
#define snd_hda_power_down(codec) snd_hdac_power_down(&(codec)->core)
|
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 09:43:14 +00:00
|
|
|
#define snd_hda_power_down_pm(codec) snd_hdac_power_down_pm(&(codec)->core)
|
2012-08-24 16:38:08 +00:00
|
|
|
#ifdef CONFIG_PM
|
2015-02-20 08:26:04 +00:00
|
|
|
void snd_hda_set_power_save(struct hda_bus *bus, int delay);
|
2009-11-11 08:34:25 +00:00
|
|
|
void snd_hda_update_power_acct(struct hda_codec *codec);
|
2007-08-10 15:21:45 +00:00
|
|
|
#else
|
2015-02-20 08:26:04 +00:00
|
|
|
static inline void snd_hda_set_power_save(struct hda_bus *bus, int delay) {}
|
2007-08-10 15:21:45 +00:00
|
|
|
#endif
|
|
|
|
|
|
2009-06-17 07:52:54 +00:00
|
|
|
#ifdef CONFIG_SND_HDA_PATCH_LOADER
|
|
|
|
|
/*
|
|
|
|
|
* patch firmware
|
|
|
|
|
*/
|
2012-08-09 10:33:28 +00:00
|
|
|
int snd_hda_load_patch(struct hda_bus *bus, size_t size, const void *buf);
|
2009-06-17 07:52:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
2012-09-21 03:29:13 +00:00
|
|
|
#ifdef CONFIG_SND_HDA_DSP_LOADER
|
2015-04-16 21:25:02 +00:00
|
|
|
int snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
struct snd_dma_buffer *bufp);
|
|
|
|
|
void snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start);
|
|
|
|
|
void snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec,
|
|
|
|
|
struct snd_dma_buffer *dmab);
|
2012-09-21 03:29:13 +00:00
|
|
|
#else
|
|
|
|
|
static inline int
|
|
|
|
|
snd_hda_codec_load_dsp_prepare(struct hda_codec *codec, unsigned int format,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
struct snd_dma_buffer *bufp)
|
|
|
|
|
{
|
2012-09-21 03:29:19 +00:00
|
|
|
return -ENOSYS;
|
2012-09-21 03:29:13 +00:00
|
|
|
}
|
|
|
|
|
static inline void
|
|
|
|
|
snd_hda_codec_load_dsp_trigger(struct hda_codec *codec, bool start) {}
|
|
|
|
|
static inline void
|
|
|
|
|
snd_hda_codec_load_dsp_cleanup(struct hda_codec *codec,
|
|
|
|
|
struct snd_dma_buffer *dmab) {}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __SOUND_HDA_CODEC_H */
|