2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Universal Interface for Intel High Definition Audio Codec
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This driver 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 driver 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
|
|
|
|
*/
|
|
|
|
|
2012-03-09 09:51:10 -07:00
|
|
|
#include <linux/mm.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
2006-01-16 08:34:20 -07:00
|
|
|
#include <linux/mutex.h>
|
2011-07-15 10:38:28 -06:00
|
|
|
#include <linux/module.h>
|
2013-12-05 03:55:05 -07:00
|
|
|
#include <linux/async.h>
|
2015-02-19 08:00:22 -07:00
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/pm_runtime.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include "hda_codec.h"
|
|
|
|
#include <sound/asoundef.h>
|
2006-07-05 09:39:49 -06:00
|
|
|
#include <sound/tlv.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <sound/initval.h>
|
2011-03-03 06:40:14 -07:00
|
|
|
#include <sound/jack.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "hda_local.h"
|
2009-10-21 06:48:23 -06:00
|
|
|
#include "hda_beep.h"
|
2011-10-27 14:12:46 -06:00
|
|
|
#include "hda_jack.h"
|
2007-07-27 10:58:06 -06:00
|
|
|
#include <sound/hda_hwdep.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-24 10:38:08 -06:00
|
|
|
#ifdef CONFIG_PM
|
2015-03-03 02:07:24 -07:00
|
|
|
#define codec_in_pm(codec) atomic_read(&(codec)->core.in_pm)
|
2015-02-19 08:00:22 -07:00
|
|
|
#define hda_codec_is_power_on(codec) \
|
|
|
|
(!pm_runtime_suspended(hda_codec_dev(codec)))
|
2007-08-10 09:21:45 -06:00
|
|
|
#else
|
2012-11-24 03:58:24 -07:00
|
|
|
#define codec_in_pm(codec) 0
|
2011-07-26 02:19:20 -06:00
|
|
|
#define hda_codec_is_power_on(codec) 1
|
2007-08-10 09:21:45 -06:00
|
|
|
#endif
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
#define codec_has_epss(codec) \
|
|
|
|
((codec)->core.power_caps & AC_PWRST_EPSS)
|
|
|
|
#define codec_has_clkstop(codec) \
|
|
|
|
((codec)->core.power_caps & AC_PWRST_CLKSTOP)
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_get_jack_location - Give a location string of the jack
|
|
|
|
* @cfg: pin default config value
|
|
|
|
*
|
|
|
|
* Parse the pin default config value and returns the string of the
|
|
|
|
* jack location, e.g. "Rear", "Front", etc.
|
|
|
|
*/
|
2008-10-24 23:05:45 -06:00
|
|
|
const char *snd_hda_get_jack_location(u32 cfg)
|
|
|
|
{
|
|
|
|
static char *bases[7] = {
|
|
|
|
"N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
|
|
|
|
};
|
|
|
|
static unsigned char specials_idx[] = {
|
|
|
|
0x07, 0x08,
|
|
|
|
0x17, 0x18, 0x19,
|
|
|
|
0x37, 0x38
|
|
|
|
};
|
|
|
|
static char *specials[] = {
|
|
|
|
"Rear Panel", "Drive Bar",
|
|
|
|
"Riser", "HDMI", "ATAPI",
|
|
|
|
"Mobile-In", "Mobile-Out"
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
|
|
|
|
if ((cfg & 0x0f) < 7)
|
|
|
|
return bases[cfg & 0x0f];
|
|
|
|
for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
|
|
|
|
if (cfg == specials_idx[i])
|
|
|
|
return specials[i];
|
|
|
|
}
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_jack_location);
|
2008-10-24 23:05:45 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_get_jack_connectivity - Give a connectivity string of the jack
|
|
|
|
* @cfg: pin default config value
|
|
|
|
*
|
|
|
|
* Parse the pin default config value and returns the string of the
|
|
|
|
* jack connectivity, i.e. external or internal connection.
|
|
|
|
*/
|
2008-10-24 23:05:45 -06:00
|
|
|
const char *snd_hda_get_jack_connectivity(u32 cfg)
|
|
|
|
{
|
|
|
|
static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
|
|
|
|
|
|
|
|
return jack_locations[(cfg >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3];
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_jack_connectivity);
|
2008-10-24 23:05:45 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_get_jack_type - Give a type string of the jack
|
|
|
|
* @cfg: pin default config value
|
|
|
|
*
|
|
|
|
* Parse the pin default config value and returns the string of the
|
|
|
|
* jack type, i.e. the purpose of the jack, such as Line-Out or CD.
|
|
|
|
*/
|
2008-10-24 23:05:45 -06:00
|
|
|
const char *snd_hda_get_jack_type(u32 cfg)
|
|
|
|
{
|
|
|
|
static char *jack_types[16] = {
|
|
|
|
"Line Out", "Speaker", "HP Out", "CD",
|
|
|
|
"SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
|
|
|
|
"Line In", "Aux", "Mic", "Telephony",
|
2013-04-04 03:47:13 -06:00
|
|
|
"SPDIF In", "Digital In", "Reserved", "Other"
|
2008-10-24 23:05:45 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
return jack_types[(cfg & AC_DEFCFG_DEVICE)
|
|
|
|
>> AC_DEFCFG_DEVICE_SHIFT];
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_jack_type);
|
2008-10-24 23:05:45 -06:00
|
|
|
|
2009-05-26 08:07:57 -06:00
|
|
|
/*
|
2015-03-03 07:40:08 -07:00
|
|
|
* Send and receive a verb - passed to exec_verb override for hdac_device
|
2009-05-26 08:07:57 -06:00
|
|
|
*/
|
2015-03-03 07:40:08 -07:00
|
|
|
static int codec_exec_verb(struct hdac_device *dev, unsigned int cmd,
|
|
|
|
unsigned int flags, unsigned int *res)
|
2009-05-26 08:07:57 -06:00
|
|
|
{
|
2015-03-03 07:40:08 -07:00
|
|
|
struct hda_codec *codec = container_of(dev, struct hda_codec, core);
|
2009-05-26 08:07:57 -06:00
|
|
|
struct hda_bus *bus = codec->bus;
|
2009-06-01 17:16:07 -06:00
|
|
|
int err;
|
2009-05-26 08:07:57 -06:00
|
|
|
|
2009-07-17 02:49:19 -06:00
|
|
|
if (cmd == ~0)
|
|
|
|
return -1;
|
|
|
|
|
2009-06-01 17:16:07 -06:00
|
|
|
again:
|
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 03:43:14 -06:00
|
|
|
snd_hda_power_up_pm(codec);
|
2015-03-02 15:22:59 -07:00
|
|
|
mutex_lock(&bus->core.cmd_mutex);
|
2013-06-06 06:20:19 -06:00
|
|
|
if (flags & HDA_RW_NO_RESPONSE_FALLBACK)
|
|
|
|
bus->no_response_fallback = 1;
|
2015-03-02 15:22:59 -07:00
|
|
|
err = snd_hdac_bus_exec_verb_unlocked(&bus->core, codec->core.addr,
|
|
|
|
cmd, res);
|
2013-06-06 06:20:19 -06:00
|
|
|
bus->no_response_fallback = 0;
|
2015-03-02 15:22:59 -07:00
|
|
|
mutex_unlock(&bus->core.cmd_mutex);
|
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 03:43:14 -06:00
|
|
|
snd_hda_power_down_pm(codec);
|
2015-03-25 10:57:00 -06:00
|
|
|
if (!codec_in_pm(codec) && res && err == -EAGAIN) {
|
2009-06-01 17:16:07 -06:00
|
|
|
if (bus->response_reset) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"resetting BUS due to fatal communication error\n");
|
2015-04-16 15:25:02 -06:00
|
|
|
snd_hda_bus_reset(bus);
|
2009-06-01 17:16:07 -06:00
|
|
|
}
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
/* clear reset-flag when the communication gets recovered */
|
2012-11-24 03:58:24 -07:00
|
|
|
if (!err || codec_in_pm(codec))
|
2009-06-01 17:16:07 -06:00
|
|
|
bus->response_reset = 0;
|
2009-05-26 08:07:57 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_read - send a command and get the response
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to send the command
|
2013-06-06 06:00:23 -06:00
|
|
|
* @flags: optional bit flags
|
2005-04-16 16:20:36 -06:00
|
|
|
* @verb: the verb to send
|
|
|
|
* @parm: the parameter for the verb
|
|
|
|
*
|
|
|
|
* Send a single command and read the corresponding response.
|
|
|
|
*
|
|
|
|
* Returns the obtained response value, or -1 for an error.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
|
2013-06-06 06:00:23 -06:00
|
|
|
int flags,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int verb, unsigned int parm)
|
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
|
2009-05-26 08:07:57 -06:00
|
|
|
unsigned int res;
|
2015-03-03 07:40:08 -07:00
|
|
|
if (snd_hdac_exec_verb(&codec->core, cmd, flags, &res))
|
2011-06-13 08:45:45 -06:00
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_read);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_codec_write - send a single command without waiting for response
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to send the command
|
2013-06-06 06:00:23 -06:00
|
|
|
* @flags: optional bit flags
|
2005-04-16 16:20:36 -06:00
|
|
|
* @verb: the verb to send
|
|
|
|
* @parm: the parameter for the verb
|
|
|
|
*
|
|
|
|
* Send a single command without waiting for response.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
2013-06-06 06:00:23 -06:00
|
|
|
int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int flags,
|
|
|
|
unsigned int verb, unsigned int parm)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
unsigned int cmd = snd_hdac_make_cmd(&codec->core, nid, verb, parm);
|
2015-03-03 07:40:08 -07:00
|
|
|
return snd_hdac_exec_verb(&codec->core, cmd, flags, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_write);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_sequence_write - sequence writes
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @seq: VERB array to send
|
|
|
|
*
|
|
|
|
* Send the commands sequentially from the given array.
|
|
|
|
* The array must be terminated with NID=0.
|
|
|
|
*/
|
|
|
|
void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
|
|
|
|
{
|
|
|
|
for (; seq->nid; seq++)
|
|
|
|
snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_sequence_write);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
/* connection list element */
|
|
|
|
struct hda_conn_list {
|
|
|
|
struct list_head list;
|
|
|
|
int len;
|
|
|
|
hda_nid_t nid;
|
|
|
|
hda_nid_t conns[0];
|
|
|
|
};
|
|
|
|
|
2011-07-04 08:23:26 -06:00
|
|
|
/* look up the cached results */
|
2013-01-03 07:25:11 -07:00
|
|
|
static struct hda_conn_list *
|
|
|
|
lookup_conn_list(struct hda_codec *codec, hda_nid_t nid)
|
2011-07-04 08:23:26 -06:00
|
|
|
{
|
2013-01-03 07:25:11 -07:00
|
|
|
struct hda_conn_list *p;
|
|
|
|
list_for_each_entry(p, &codec->conn_list, list) {
|
|
|
|
if (p->nid == nid)
|
2011-07-04 08:23:26 -06:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-07 07:55:15 -06:00
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
static int add_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
|
|
|
|
const hda_nid_t *list)
|
|
|
|
{
|
|
|
|
struct hda_conn_list *p;
|
|
|
|
|
|
|
|
p = kmalloc(sizeof(*p) + len * sizeof(hda_nid_t), GFP_KERNEL);
|
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
p->len = len;
|
|
|
|
p->nid = nid;
|
|
|
|
memcpy(p->conns, list, len * sizeof(hda_nid_t));
|
|
|
|
list_add(&p->list, &codec->conn_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_conn_list(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
while (!list_empty(&codec->conn_list)) {
|
|
|
|
struct hda_conn_list *p;
|
|
|
|
p = list_first_entry(&codec->conn_list, typeof(*p), list);
|
|
|
|
list_del(&p->list);
|
|
|
|
kfree(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-19 09:21:25 -06:00
|
|
|
/* read the connection and add to the cache */
|
|
|
|
static int read_and_add_raw_conns(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
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-07 10:18:19 -07:00
|
|
|
hda_nid_t list[32];
|
|
|
|
hda_nid_t *result = list;
|
2012-05-19 09:21:25 -06:00
|
|
|
int len;
|
|
|
|
|
|
|
|
len = snd_hda_get_raw_connections(codec, nid, list, ARRAY_SIZE(list));
|
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-07 10:18:19 -07:00
|
|
|
if (len == -ENOSPC) {
|
|
|
|
len = snd_hda_get_num_raw_conns(codec, nid);
|
|
|
|
result = kmalloc(sizeof(hda_nid_t) * len, GFP_KERNEL);
|
|
|
|
if (!result)
|
|
|
|
return -ENOMEM;
|
|
|
|
len = snd_hda_get_raw_connections(codec, nid, result, len);
|
|
|
|
}
|
|
|
|
if (len >= 0)
|
|
|
|
len = snd_hda_override_conn_list(codec, nid, len, result);
|
|
|
|
if (result != list)
|
|
|
|
kfree(result);
|
|
|
|
return len;
|
2012-05-19 09:21:25 -06:00
|
|
|
}
|
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_get_conn_list - get connection list
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to parse
|
|
|
|
* @listp: the pointer to store NID list
|
|
|
|
*
|
|
|
|
* Parses the connection list of the given widget and stores the pointer
|
|
|
|
* to the list of NIDs.
|
|
|
|
*
|
|
|
|
* Returns the number of connections, or a negative error code.
|
|
|
|
*
|
|
|
|
* Note that the returned pointer isn't protected against the list
|
|
|
|
* modification. If snd_hda_override_conn_list() might be called
|
|
|
|
* concurrently, protect with a mutex appropriately.
|
|
|
|
*/
|
|
|
|
int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
const hda_nid_t **listp)
|
|
|
|
{
|
|
|
|
bool added = false;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int err;
|
|
|
|
const struct hda_conn_list *p;
|
|
|
|
|
|
|
|
/* if the connection-list is already cached, read it */
|
|
|
|
p = lookup_conn_list(codec, nid);
|
|
|
|
if (p) {
|
|
|
|
if (listp)
|
|
|
|
*listp = p->conns;
|
|
|
|
return p->len;
|
|
|
|
}
|
|
|
|
if (snd_BUG_ON(added))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = read_and_add_raw_conns(codec, nid);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
added = true;
|
|
|
|
}
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_conn_list);
|
2013-01-03 07:25:11 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2012-05-19 09:21:25 -06:00
|
|
|
* snd_hda_get_connections - copy connection list
|
2005-04-16 16:20:36 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to parse
|
2012-05-19 09:21:25 -06:00
|
|
|
* @conn_list: connection list array; when NULL, checks only the size
|
|
|
|
* @max_conns: max. number of connections to store
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Parses the connection list of the given widget and stores the list
|
|
|
|
* of NIDs.
|
|
|
|
*
|
|
|
|
* Returns the number of connections, or a negative error code.
|
|
|
|
*/
|
2012-05-19 09:21:25 -06:00
|
|
|
int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
hda_nid_t *conn_list, int max_conns)
|
2011-04-07 07:55:15 -06:00
|
|
|
{
|
2013-01-03 07:25:11 -07:00
|
|
|
const hda_nid_t *list;
|
|
|
|
int len = snd_hda_get_conn_list(codec, nid, &list);
|
2011-04-07 07:55:15 -06:00
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
if (len > 0 && conn_list) {
|
|
|
|
if (len > max_conns) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_err(codec, "Too many connections %d for NID 0x%x\n",
|
2012-05-19 09:21:25 -06:00
|
|
|
len, nid);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-01-03 07:25:11 -07:00
|
|
|
memcpy(conn_list, list, len * sizeof(hda_nid_t));
|
2011-04-07 07:55:15 -06:00
|
|
|
}
|
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
return len;
|
2011-04-07 07:55:15 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_connections);
|
2011-04-07 07:55:15 -06:00
|
|
|
|
2011-07-04 08:23:26 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_override_conn_list - add/modify the connection-list to cache
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to parse
|
|
|
|
* @len: number of connection list entries
|
|
|
|
* @list: the list of connection entries
|
|
|
|
*
|
|
|
|
* Add or modify the given connection-list to the cache. If the corresponding
|
|
|
|
* cache already exists, invalidate it and append a new one.
|
|
|
|
*
|
|
|
|
* Returns zero or a negative error code.
|
|
|
|
*/
|
|
|
|
int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
|
|
|
|
const hda_nid_t *list)
|
|
|
|
{
|
2013-01-03 07:25:11 -07:00
|
|
|
struct hda_conn_list *p;
|
2011-07-04 08:23:26 -06:00
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
p = lookup_conn_list(codec, nid);
|
|
|
|
if (p) {
|
|
|
|
list_del(&p->list);
|
|
|
|
kfree(p);
|
|
|
|
}
|
2011-07-04 08:23:26 -06:00
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
return add_conn_list(codec, nid, len, list);
|
2011-07-04 08:23:26 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_override_conn_list);
|
2011-07-04 08:23:26 -06:00
|
|
|
|
2011-06-28 04:45:47 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_get_conn_index - get the connection index of the given NID
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mux: NID containing the list
|
|
|
|
* @nid: NID to select
|
|
|
|
* @recursive: 1 when searching NID recursively, otherwise 0
|
|
|
|
*
|
|
|
|
* Parses the connection list of the widget @mux and checks whether the
|
|
|
|
* widget @nid is present. If it is, return the connection index.
|
|
|
|
* Otherwise it returns -1.
|
|
|
|
*/
|
|
|
|
int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
|
|
|
|
hda_nid_t nid, int recursive)
|
2011-04-07 07:55:15 -06:00
|
|
|
{
|
2013-01-03 07:25:11 -07:00
|
|
|
const hda_nid_t *conn;
|
2011-06-28 04:45:47 -06:00
|
|
|
int i, nums;
|
|
|
|
|
2013-01-03 07:25:11 -07:00
|
|
|
nums = snd_hda_get_conn_list(codec, mux, &conn);
|
2011-06-28 04:45:47 -06:00
|
|
|
for (i = 0; i < nums; i++)
|
|
|
|
if (conn[i] == nid)
|
|
|
|
return i;
|
|
|
|
if (!recursive)
|
|
|
|
return -1;
|
2012-12-20 06:42:42 -07:00
|
|
|
if (recursive > 10) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_dbg(codec, "too deep connection for 0x%x\n", nid);
|
2011-06-28 04:45:47 -06:00
|
|
|
return -1;
|
2011-04-07 07:55:15 -06:00
|
|
|
}
|
2011-06-28 04:45:47 -06:00
|
|
|
recursive++;
|
2011-09-13 02:33:16 -06:00
|
|
|
for (i = 0; i < nums; i++) {
|
|
|
|
unsigned int type = get_wcaps_type(get_wcaps(codec, conn[i]));
|
|
|
|
if (type == AC_WID_PIN || type == AC_WID_AUD_OUT)
|
|
|
|
continue;
|
2011-06-28 04:45:47 -06:00
|
|
|
if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
|
|
|
|
return i;
|
2011-09-13 02:33:16 -06:00
|
|
|
}
|
2011-06-28 04:45:47 -06:00
|
|
|
return -1;
|
2011-04-07 07:55:15 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_conn_index);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-26 19:35:21 -06:00
|
|
|
|
|
|
|
/* return DEVLIST_LEN parameter of the given widget */
|
|
|
|
static unsigned int get_num_devices(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
unsigned int wcaps = get_wcaps(codec, nid);
|
|
|
|
unsigned int parm;
|
|
|
|
|
|
|
|
if (!codec->dp_mst || !(wcaps & AC_WCAP_DIGITAL) ||
|
|
|
|
get_wcaps_type(wcaps) != AC_WID_PIN)
|
|
|
|
return 0;
|
|
|
|
|
2015-03-25 10:57:00 -06:00
|
|
|
if (_snd_hdac_read_parm(&codec->core, nid, AC_PAR_DEVLIST_LEN, &parm))
|
|
|
|
return 0; /* error */
|
2013-08-26 19:35:21 -06:00
|
|
|
return parm & AC_DEV_LIST_LEN_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_get_devices - copy device list without cache
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID of the pin to parse
|
|
|
|
* @dev_list: device list array
|
|
|
|
* @max_devices: max. number of devices to store
|
|
|
|
*
|
|
|
|
* Copy the device list. This info is dynamic and so not cached.
|
|
|
|
* Currently called only from hda_proc.c, so not exported.
|
|
|
|
*/
|
|
|
|
int snd_hda_get_devices(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
u8 *dev_list, int max_devices)
|
|
|
|
{
|
|
|
|
unsigned int parm;
|
|
|
|
int i, dev_len, devices;
|
|
|
|
|
|
|
|
parm = get_num_devices(codec, nid);
|
|
|
|
if (!parm) /* not multi-stream capable */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev_len = parm + 1;
|
|
|
|
dev_len = dev_len < max_devices ? dev_len : max_devices;
|
|
|
|
|
|
|
|
devices = 0;
|
|
|
|
while (devices < dev_len) {
|
2015-03-25 10:57:00 -06:00
|
|
|
if (snd_hdac_read(&codec->core, nid,
|
|
|
|
AC_VERB_GET_DEVICE_LIST, devices, &parm))
|
|
|
|
break; /* error */
|
2013-08-26 19:35:21 -06:00
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
dev_list[devices] = (u8)parm;
|
|
|
|
parm >>= 4;
|
|
|
|
devices++;
|
|
|
|
if (devices >= dev_len)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return devices;
|
|
|
|
}
|
|
|
|
|
2005-11-21 08:33:22 -07:00
|
|
|
/*
|
|
|
|
* read widget caps for each widget and store in cache
|
|
|
|
*/
|
|
|
|
static int read_widget_caps(struct hda_codec *codec, hda_nid_t fg_node)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
hda_nid_t nid;
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
codec->wcaps = kmalloc(codec->core.num_nodes * 4, GFP_KERNEL);
|
2007-04-16 03:29:14 -06:00
|
|
|
if (!codec->wcaps)
|
2005-11-21 08:33:22 -07:00
|
|
|
return -ENOMEM;
|
2015-03-03 02:07:24 -07:00
|
|
|
nid = codec->core.start_nid;
|
|
|
|
for (i = 0; i < codec->core.num_nodes; i++, nid++)
|
2015-03-03 15:29:47 -07:00
|
|
|
codec->wcaps[i] = snd_hdac_read_parm_uncached(&codec->core,
|
|
|
|
nid, AC_PAR_AUDIO_WIDGET_CAP);
|
2005-11-21 08:33:22 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-20 06:11:16 -07:00
|
|
|
/* read all pin default configurations and save codec->init_pins */
|
|
|
|
static int read_pin_defaults(struct hda_codec *codec)
|
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
hda_nid_t nid;
|
2009-02-20 06:11:16 -07:00
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
for_each_hda_codec_node(nid, codec) {
|
2009-02-20 06:11:16 -07:00
|
|
|
struct hda_pincfg *pin;
|
|
|
|
unsigned int wcaps = get_wcaps(codec, nid);
|
2009-07-27 04:54:26 -06:00
|
|
|
unsigned int wid_type = get_wcaps_type(wcaps);
|
2009-02-20 06:11:16 -07:00
|
|
|
if (wid_type != AC_WID_PIN)
|
|
|
|
continue;
|
|
|
|
pin = snd_array_new(&codec->init_pins);
|
|
|
|
if (!pin)
|
|
|
|
return -ENOMEM;
|
|
|
|
pin->nid = nid;
|
|
|
|
pin->cfg = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_CONFIG_DEFAULT, 0);
|
2010-07-05 08:50:13 -06:00
|
|
|
pin->ctrl = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL,
|
|
|
|
0);
|
2009-02-20 06:11:16 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* look up the given pin config list and return the item matching with NID */
|
|
|
|
static struct hda_pincfg *look_up_pincfg(struct hda_codec *codec,
|
|
|
|
struct snd_array *array,
|
|
|
|
hda_nid_t nid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < array->used; i++) {
|
|
|
|
struct hda_pincfg *pin = snd_array_elem(array, i);
|
|
|
|
if (pin->nid == nid)
|
|
|
|
return pin;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the current pin config value for the given NID.
|
|
|
|
* the value is cached, and read via snd_hda_codec_get_pincfg()
|
|
|
|
*/
|
|
|
|
int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
|
|
|
|
hda_nid_t nid, unsigned int cfg)
|
|
|
|
{
|
|
|
|
struct hda_pincfg *pin;
|
|
|
|
|
2013-04-18 01:59:28 -06:00
|
|
|
/* the check below may be invalid when pins are added by a fixup
|
|
|
|
* dynamically (e.g. via snd_hda_codec_update_widgets()), so disabled
|
|
|
|
* for now
|
|
|
|
*/
|
|
|
|
/*
|
2009-12-27 03:24:56 -07:00
|
|
|
if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
|
|
|
|
return -EINVAL;
|
2013-04-18 01:59:28 -06:00
|
|
|
*/
|
2009-12-27 03:24:56 -07:00
|
|
|
|
2009-02-20 06:11:16 -07:00
|
|
|
pin = look_up_pincfg(codec, list, nid);
|
|
|
|
if (!pin) {
|
|
|
|
pin = snd_array_new(list);
|
|
|
|
if (!pin)
|
|
|
|
return -ENOMEM;
|
|
|
|
pin->nid = nid;
|
|
|
|
}
|
|
|
|
pin->cfg = cfg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_set_pincfg - Override a pin default configuration
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to set the pin config
|
|
|
|
* @cfg: the pin default config value
|
|
|
|
*
|
|
|
|
* Override a pin default configuration value in the cache.
|
|
|
|
* This value can be read by snd_hda_codec_get_pincfg() in a higher
|
|
|
|
* priority than the real hardware value.
|
|
|
|
*/
|
2009-02-20 06:11:16 -07:00
|
|
|
int snd_hda_codec_set_pincfg(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid, unsigned int cfg)
|
|
|
|
{
|
2009-02-23 01:42:57 -07:00
|
|
|
return snd_hda_add_pincfg(codec, &codec->driver_pins, nid, cfg);
|
2009-02-20 06:11:16 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pincfg);
|
2009-02-20 06:11:16 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_get_pincfg - Obtain a pin-default configuration
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to get the pin config
|
|
|
|
*
|
|
|
|
* Get the current pin config value of the given pin NID.
|
|
|
|
* If the pincfg value is cached or overridden via sysfs or driver,
|
|
|
|
* returns the cached value.
|
|
|
|
*/
|
2009-02-20 06:11:16 -07:00
|
|
|
unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct hda_pincfg *pin;
|
|
|
|
|
2014-02-25 02:38:13 -07:00
|
|
|
#ifdef CONFIG_SND_HDA_RECONFIG
|
2013-01-10 10:21:56 -07:00
|
|
|
{
|
|
|
|
unsigned int cfg = 0;
|
|
|
|
mutex_lock(&codec->user_mutex);
|
|
|
|
pin = look_up_pincfg(codec, &codec->user_pins, nid);
|
|
|
|
if (pin)
|
|
|
|
cfg = pin->cfg;
|
|
|
|
mutex_unlock(&codec->user_mutex);
|
|
|
|
if (cfg)
|
|
|
|
return cfg;
|
|
|
|
}
|
2009-02-20 06:11:16 -07:00
|
|
|
#endif
|
2009-02-23 01:45:59 -07:00
|
|
|
pin = look_up_pincfg(codec, &codec->driver_pins, nid);
|
|
|
|
if (pin)
|
|
|
|
return pin->cfg;
|
2009-02-20 06:11:16 -07:00
|
|
|
pin = look_up_pincfg(codec, &codec->init_pins, nid);
|
|
|
|
if (pin)
|
|
|
|
return pin->cfg;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pincfg);
|
2009-02-20 06:11:16 -07:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_set_pin_target - remember the current pinctl target value
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID
|
|
|
|
* @val: assigned pinctl value
|
|
|
|
*
|
|
|
|
* This function stores the given value to a pinctl target value in the
|
|
|
|
* pincfg table. This isn't always as same as the actually written value
|
|
|
|
* but can be referred at any time via snd_hda_codec_get_pin_target().
|
|
|
|
*/
|
2013-01-10 00:38:04 -07:00
|
|
|
int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
unsigned int val)
|
|
|
|
{
|
|
|
|
struct hda_pincfg *pin;
|
|
|
|
|
|
|
|
pin = look_up_pincfg(codec, &codec->init_pins, nid);
|
|
|
|
if (!pin)
|
|
|
|
return -EINVAL;
|
|
|
|
pin->target = val;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_set_pin_target);
|
2013-01-10 00:38:04 -07:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_get_pin_target - return the current pinctl target value
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: pin NID
|
|
|
|
*/
|
2013-01-10 00:38:04 -07:00
|
|
|
int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct hda_pincfg *pin;
|
|
|
|
|
|
|
|
pin = look_up_pincfg(codec, &codec->init_pins, nid);
|
|
|
|
if (!pin)
|
|
|
|
return 0;
|
|
|
|
return pin->target;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_get_pin_target);
|
2013-01-10 00:38:04 -07:00
|
|
|
|
2009-12-27 03:18:59 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_shutup_pins - Shut up all pins
|
|
|
|
* @codec: the HDA codec
|
|
|
|
*
|
|
|
|
* Clear all pin controls to shup up before suspend for avoiding click noise.
|
|
|
|
* The controls aren't cached so that they can be resumed properly.
|
|
|
|
*/
|
|
|
|
void snd_hda_shutup_pins(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int i;
|
2010-07-05 08:50:13 -06:00
|
|
|
/* don't shut up pins when unloading the driver; otherwise it breaks
|
|
|
|
* the default pin setup at the next load of the driver
|
|
|
|
*/
|
|
|
|
if (codec->bus->shutdown)
|
|
|
|
return;
|
2009-12-27 03:18:59 -07:00
|
|
|
for (i = 0; i < codec->init_pins.used; i++) {
|
|
|
|
struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
|
|
|
|
/* use read here for syncing after issuing each verb */
|
|
|
|
snd_hda_codec_read(codec, pin->nid, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
|
|
|
|
}
|
2010-07-05 08:50:13 -06:00
|
|
|
codec->pins_shutup = 1;
|
2009-12-27 03:18:59 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_shutup_pins);
|
2009-12-27 03:18:59 -07:00
|
|
|
|
2011-07-26 01:52:50 -06:00
|
|
|
#ifdef CONFIG_PM
|
2010-07-05 08:50:13 -06:00
|
|
|
/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
|
|
|
|
static void restore_shutup_pins(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (!codec->pins_shutup)
|
|
|
|
return;
|
|
|
|
if (codec->bus->shutdown)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < codec->init_pins.used; i++) {
|
|
|
|
struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
|
|
|
|
snd_hda_codec_write(codec, pin->nid, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
|
|
pin->ctrl);
|
|
|
|
}
|
|
|
|
codec->pins_shutup = 0;
|
|
|
|
}
|
2011-04-20 13:04:36 -06:00
|
|
|
#endif
|
2010-07-05 08:50:13 -06:00
|
|
|
|
2012-10-09 07:04:21 -06:00
|
|
|
static void hda_jackpoll_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec =
|
|
|
|
container_of(work, struct hda_codec, jackpoll_work.work);
|
|
|
|
|
|
|
|
snd_hda_jack_set_dirty_all(codec);
|
|
|
|
snd_hda_jack_poll_all(codec);
|
2013-07-25 21:34:45 -06:00
|
|
|
|
|
|
|
if (!codec->jackpoll_interval)
|
|
|
|
return;
|
|
|
|
|
2015-02-27 14:43:26 -07:00
|
|
|
schedule_delayed_work(&codec->jackpoll_work,
|
|
|
|
codec->jackpoll_interval);
|
2012-10-09 07:04:21 -06:00
|
|
|
}
|
|
|
|
|
2012-11-22 00:16:31 -07:00
|
|
|
/* release all pincfg lists */
|
|
|
|
static void free_init_pincfgs(struct hda_codec *codec)
|
2009-02-20 06:11:16 -07:00
|
|
|
{
|
2009-02-23 01:42:57 -07:00
|
|
|
snd_array_free(&codec->driver_pins);
|
2014-02-25 02:38:13 -07:00
|
|
|
#ifdef CONFIG_SND_HDA_RECONFIG
|
2009-02-23 01:42:57 -07:00
|
|
|
snd_array_free(&codec->user_pins);
|
2009-02-20 06:11:16 -07:00
|
|
|
#endif
|
|
|
|
snd_array_free(&codec->init_pins);
|
|
|
|
}
|
|
|
|
|
2010-08-06 05:48:11 -06:00
|
|
|
/*
|
|
|
|
* audio-converter setup caches
|
|
|
|
*/
|
|
|
|
struct hda_cvt_setup {
|
|
|
|
hda_nid_t nid;
|
|
|
|
u8 stream_tag;
|
|
|
|
u8 channel_id;
|
|
|
|
u16 format_id;
|
|
|
|
unsigned char active; /* cvt is currently used */
|
|
|
|
unsigned char dirty; /* setups should be cleared */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* get or create a cache entry for the given audio converter NID */
|
|
|
|
static struct hda_cvt_setup *
|
|
|
|
get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct hda_cvt_setup *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < codec->cvt_setups.used; i++) {
|
|
|
|
p = snd_array_elem(&codec->cvt_setups, i);
|
|
|
|
if (p->nid == nid)
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
p = snd_array_new(&codec->cvt_setups);
|
|
|
|
if (p)
|
|
|
|
p->nid = nid;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2015-02-27 09:43:19 -07:00
|
|
|
/*
|
|
|
|
* PCM device
|
|
|
|
*/
|
|
|
|
static void release_pcm(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct hda_pcm *pcm = container_of(kref, struct hda_pcm, kref);
|
|
|
|
|
|
|
|
if (pcm->pcm)
|
|
|
|
snd_device_free(pcm->codec->card, pcm->pcm);
|
|
|
|
clear_bit(pcm->device, pcm->codec->bus->pcm_dev_bits);
|
|
|
|
kfree(pcm->name);
|
|
|
|
kfree(pcm);
|
|
|
|
}
|
|
|
|
|
|
|
|
void snd_hda_codec_pcm_put(struct hda_pcm *pcm)
|
|
|
|
{
|
|
|
|
kref_put(&pcm->kref, release_pcm);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_put);
|
|
|
|
|
|
|
|
struct hda_pcm *snd_hda_codec_pcm_new(struct hda_codec *codec,
|
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
|
|
|
struct hda_pcm *pcm;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
|
|
|
|
if (!pcm)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pcm->codec = codec;
|
|
|
|
kref_init(&pcm->kref);
|
|
|
|
pcm->name = kvasprintf(GFP_KERNEL, fmt, args);
|
|
|
|
if (!pcm->name) {
|
|
|
|
kfree(pcm);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&pcm->list, &codec->pcm_list_head);
|
|
|
|
return pcm;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_pcm_new);
|
|
|
|
|
2015-02-27 10:17:28 -07:00
|
|
|
/*
|
|
|
|
* codec destructor
|
|
|
|
*/
|
2015-02-27 09:43:19 -07:00
|
|
|
static void codec_release_pcms(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
struct hda_pcm *pcm, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(pcm, n, &codec->pcm_list_head, list) {
|
|
|
|
list_del_init(&pcm->list);
|
2015-02-27 10:17:28 -07:00
|
|
|
if (pcm->pcm)
|
|
|
|
snd_device_disconnect(codec->card, pcm->pcm);
|
2015-02-27 09:43:19 -07:00
|
|
|
snd_hda_codec_pcm_put(pcm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-27 10:17:28 -07:00
|
|
|
void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
|
|
|
|
{
|
2015-03-03 09:22:12 -07:00
|
|
|
if (codec->registered) {
|
|
|
|
/* pm_runtime_put() is called in snd_hdac_device_exit() */
|
|
|
|
pm_runtime_get_noresume(hda_codec_dev(codec));
|
|
|
|
pm_runtime_disable(hda_codec_dev(codec));
|
|
|
|
codec->registered = 0;
|
|
|
|
}
|
|
|
|
|
2015-02-27 10:17:28 -07:00
|
|
|
cancel_delayed_work_sync(&codec->jackpoll_work);
|
|
|
|
if (!codec->in_freeing)
|
|
|
|
snd_hda_ctls_clear(codec);
|
|
|
|
codec_release_pcms(codec);
|
|
|
|
snd_hda_detach_beep_device(codec);
|
|
|
|
memset(&codec->patch_ops, 0, sizeof(codec->patch_ops));
|
|
|
|
snd_hda_jack_tbl_clear(codec);
|
|
|
|
codec->proc_widget_hook = NULL;
|
|
|
|
codec->spec = NULL;
|
|
|
|
|
|
|
|
/* free only driver_pins so that init_pins + user_pins are restored */
|
|
|
|
snd_array_free(&codec->driver_pins);
|
|
|
|
snd_array_free(&codec->cvt_setups);
|
|
|
|
snd_array_free(&codec->spdif_out);
|
|
|
|
snd_array_free(&codec->verbs);
|
|
|
|
codec->preset = NULL;
|
|
|
|
codec->slave_dig_outs = NULL;
|
|
|
|
codec->spdif_status_reset = 0;
|
|
|
|
snd_array_free(&codec->mixers);
|
|
|
|
snd_array_free(&codec->nids);
|
|
|
|
remove_conn_list(codec);
|
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 06:42:38 -07:00
|
|
|
snd_hdac_regmap_exit(&codec->core);
|
2015-02-27 10:17:28 -07:00
|
|
|
}
|
|
|
|
|
2012-08-31 08:54:38 -06:00
|
|
|
static unsigned int hda_set_power_state(struct hda_codec *codec,
|
2009-03-13 02:02:42 -06:00
|
|
|
unsigned int power_state);
|
|
|
|
|
2015-03-03 09:22:12 -07:00
|
|
|
/* also called from hda_bind.c */
|
|
|
|
void snd_hda_codec_register(struct hda_codec *codec)
|
2014-02-24 23:53:47 -07:00
|
|
|
{
|
2015-03-03 09:22:12 -07:00
|
|
|
if (codec->registered)
|
|
|
|
return;
|
|
|
|
if (device_is_registered(hda_codec_dev(codec))) {
|
|
|
|
snd_hda_register_beep_device(codec);
|
2015-02-19 08:00:22 -07:00
|
|
|
pm_runtime_enable(hda_codec_dev(codec));
|
2015-03-03 09:22:12 -07:00
|
|
|
/* it was powered up in snd_hda_codec_new(), now all done */
|
|
|
|
snd_hda_power_down(codec);
|
|
|
|
codec->registered = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_hda_codec_dev_register(struct snd_device *device)
|
|
|
|
{
|
|
|
|
snd_hda_codec_register(device->device_data);
|
2014-02-28 05:42:09 -07:00
|
|
|
return 0;
|
2014-02-24 23:53:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int snd_hda_codec_dev_disconnect(struct snd_device *device)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = device->device_data;
|
|
|
|
|
2014-02-28 05:42:09 -07:00
|
|
|
snd_hda_detach_beep_device(codec);
|
2014-02-24 23:53:47 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-19 03:41:09 -07:00
|
|
|
static int snd_hda_codec_dev_free(struct snd_device *device)
|
|
|
|
{
|
2015-02-27 15:25:35 -07:00
|
|
|
struct hda_codec *codec = device->device_data;
|
|
|
|
|
|
|
|
codec->in_freeing = 1;
|
ALSA: hda - Add widget sysfs tree
This patch changes the sysfs files assigned to the codec device on the
bus which were formerly identical with hwdep sysfs files. Now it
shows only a few core parameter, vendor_id, subsystem_id, revision_id,
afg, mfg, vendor_name and chip_name.
In addition, now a widget tree is added to the bus device sysfs
directory for showing the widget topology and attributes. It's just a
flat tree consisting of subdirectories named as the widget NID
including various attributes like widget capability bits. The AFG
(usually NID 0x01) is always found there, and it contains always
amp_in_caps, amp_out_caps and power_caps files. Each of these
attributes show a single value. The rest are the widget nodes
belonging to that AFG. Note that the child node might not start from
0x02 but from another value like 0x0a.
Each child node may contain caps, pin_caps, amp_in_caps, amp_out_caps,
power_caps and connections files. The caps (representing the widget
capability bits) always contain a value. The rest may contain
value(s) if the attribute exists on the node. Only connections file
show multiple values while other attributes have zero or one single
value.
An example of ls -R output is like below:
% ls -R /sys/bus/hdaudio/devices/hdaudioC0D0/
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/:
01/ 04/ 07/ 0a/ 0d/ 10/ 13/ 16/ 19/ 1c/ 1f/ 22/
02/ 05/ 08/ 0b/ 0e/ 11/ 14/ 17/ 1a/ 1d/ 20/ 23/
03/ 06/ 09/ 0c/ 0f/ 12/ 15/ 18/ 1b/ 1e/ 21/
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/01:
amp_in_caps amp_out_caps power_caps
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/02:
amp_in_caps amp_out_caps caps connections pin_caps pin_cfg
power_caps
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/03:
.....
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-02-24 06:59:42 -07:00
|
|
|
snd_hdac_device_unregister(&codec->core);
|
2015-02-27 15:25:35 -07:00
|
|
|
put_device(hda_codec_dev(codec));
|
2014-02-19 03:41:09 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-24 23:53:47 -07:00
|
|
|
static void snd_hda_codec_dev_release(struct device *dev)
|
|
|
|
{
|
2015-02-27 15:25:35 -07:00
|
|
|
struct hda_codec *codec = dev_to_hda_codec(dev);
|
|
|
|
|
|
|
|
free_init_pincfgs(codec);
|
2015-03-03 02:07:24 -07:00
|
|
|
snd_hdac_device_exit(&codec->core);
|
2015-02-27 15:25:35 -07:00
|
|
|
snd_hda_sysfs_clear(codec);
|
|
|
|
kfree(codec->modelname);
|
|
|
|
kfree(codec->wcaps);
|
|
|
|
kfree(codec);
|
2014-02-24 23:53:47 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_new - create a HDA codec
|
|
|
|
* @bus: the bus to assign
|
|
|
|
* @codec_addr: the codec address
|
|
|
|
* @codecp: the pointer to store the generated codec
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
2015-02-27 08:09:22 -07:00
|
|
|
int snd_hda_codec_new(struct hda_bus *bus, struct snd_card *card,
|
|
|
|
unsigned int codec_addr, struct hda_codec **codecp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec;
|
2008-08-13 12:55:32 -06:00
|
|
|
char component[31];
|
2012-08-31 08:54:38 -06:00
|
|
|
hda_nid_t fg;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
2014-02-19 03:41:09 -07:00
|
|
|
static struct snd_device_ops dev_ops = {
|
2014-02-24 23:53:47 -07:00
|
|
|
.dev_register = snd_hda_codec_dev_register,
|
|
|
|
.dev_disconnect = snd_hda_codec_dev_disconnect,
|
2014-02-19 03:41:09 -07:00
|
|
|
.dev_free = snd_hda_codec_dev_free,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-08 09:12:14 -06:00
|
|
|
if (snd_BUG_ON(!bus))
|
|
|
|
return -EINVAL;
|
|
|
|
if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS))
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[ALSA] Replace with kzalloc() - pci stuff
AD1889 driver,ATIIXP driver,ATIIXP-modem driver,AZT3328 driver
BT87x driver,CMIPCI driver,CS4281 driver,ENS1370/1+ driver
ES1938 driver,ES1968 driver,FM801 driver,Intel8x0 driver
Intel8x0-modem driver,Maestro3 driver,SonicVibes driver,VIA82xx driver
VIA82xx-modem driver,AC97 Codec,AK4531 codec,au88x0 driver
CA0106 driver,CS46xx driver,EMU10K1/EMU10K2 driver,HDA Codec driver
HDA generic driver,HDA Intel driver,ICE1712 driver,ICE1724 driver
KORG1212 driver,MIXART driver,NM256 driver,Trident driver,YMFPCI driver
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 06:21:46 -06:00
|
|
|
codec = kzalloc(sizeof(*codec), GFP_KERNEL);
|
2015-02-27 08:17:18 -07:00
|
|
|
if (!codec)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
sprintf(component, "hdaudioC%dD%d", card->number, codec_addr);
|
|
|
|
err = snd_hdac_device_init(&codec->core, &bus->core, component,
|
|
|
|
codec_addr);
|
|
|
|
if (err < 0) {
|
|
|
|
kfree(codec);
|
|
|
|
return err;
|
|
|
|
}
|
2015-03-02 15:22:59 -07:00
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
codec->core.dev.release = snd_hda_codec_dev_release;
|
|
|
|
codec->core.type = HDA_DEV_LEGACY;
|
2015-03-03 07:40:08 -07:00
|
|
|
codec->core.exec_verb = codec_exec_verb;
|
2014-02-24 23:53:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
codec->bus = bus;
|
2015-02-27 08:09:22 -07:00
|
|
|
codec->card = card;
|
2005-04-16 16:20:36 -06:00
|
|
|
codec->addr = codec_addr;
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_init(&codec->spdif_mutex);
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_init(&codec->control_mutex);
|
2009-12-08 08:13:32 -07:00
|
|
|
snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
|
|
|
|
snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
|
2009-02-20 06:11:16 -07:00
|
|
|
snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
|
2009-02-23 01:42:57 -07:00
|
|
|
snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
|
2010-08-06 05:48:11 -06:00
|
|
|
snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
|
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 11:14:17 -06:00
|
|
|
snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
|
2012-05-09 06:35:27 -06:00
|
|
|
snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16);
|
2012-12-18 10:12:44 -07:00
|
|
|
snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8);
|
2013-01-03 07:25:11 -07:00
|
|
|
INIT_LIST_HEAD(&codec->conn_list);
|
2015-02-27 09:43:19 -07:00
|
|
|
INIT_LIST_HEAD(&codec->pcm_list_head);
|
2013-01-03 07:25:11 -07:00
|
|
|
|
2012-10-09 07:04:21 -06:00
|
|
|
INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work);
|
2013-11-28 23:48:45 -07:00
|
|
|
codec->depop_delay = -1;
|
2014-07-22 06:09:34 -06:00
|
|
|
codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-24 10:38:08 -06:00
|
|
|
#ifdef CONFIG_PM
|
2015-02-19 08:00:22 -07:00
|
|
|
codec->power_jiffies = jiffies;
|
2007-08-10 09:21:45 -06:00
|
|
|
#endif
|
|
|
|
|
2014-02-25 02:38:13 -07:00
|
|
|
snd_hda_sysfs_init(codec);
|
|
|
|
|
2012-05-07 07:01:02 -06:00
|
|
|
if (codec->bus->modelname) {
|
|
|
|
codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
|
|
|
|
if (!codec->modelname) {
|
2014-02-24 23:53:47 -07:00
|
|
|
err = -ENODEV;
|
|
|
|
goto error;
|
2012-05-07 07:01:02 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
|
2012-08-31 08:54:38 -06:00
|
|
|
err = read_widget_caps(codec, fg);
|
2015-02-27 08:17:18 -07:00
|
|
|
if (err < 0)
|
2009-02-20 06:11:16 -07:00
|
|
|
goto error;
|
|
|
|
err = read_pin_defaults(codec);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
2005-11-21 08:33:22 -07:00
|
|
|
|
2009-03-13 02:02:42 -06:00
|
|
|
/* power-up all before initialization */
|
2012-08-31 08:54:38 -06:00
|
|
|
hda_set_power_state(codec, AC_PWRST_D0);
|
2009-03-13 02:02:42 -06:00
|
|
|
|
2008-07-30 07:01:45 -06:00
|
|
|
snd_hda_codec_proc_new(codec);
|
|
|
|
|
|
|
|
snd_hda_create_hwdep(codec);
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
sprintf(component, "HDA:%08x,%08x,%08x", codec->core.vendor_id,
|
|
|
|
codec->core.subsystem_id, codec->core.revision_id);
|
2015-02-27 08:09:22 -07:00
|
|
|
snd_component_add(card, component);
|
2008-07-30 07:01:45 -06:00
|
|
|
|
2015-02-27 08:09:22 -07:00
|
|
|
err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
|
2014-02-19 03:41:09 -07:00
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
|
2008-07-30 07:01:45 -06:00
|
|
|
if (codecp)
|
|
|
|
*codecp = codec;
|
|
|
|
return 0;
|
2009-02-20 06:11:16 -07:00
|
|
|
|
|
|
|
error:
|
2015-02-27 15:25:35 -07:00
|
|
|
put_device(hda_codec_dev(codec));
|
2009-02-20 06:11:16 -07:00
|
|
|
return err;
|
2008-07-30 07:01:45 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_new);
|
2008-07-30 07:01:45 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_update_widgets - Refresh widget caps and pin defaults
|
|
|
|
* @codec: the HDA codec
|
|
|
|
*
|
|
|
|
* Forcibly refresh the all widget caps and the init pin configurations of
|
|
|
|
* the given codec.
|
|
|
|
*/
|
2013-02-08 15:09:31 -07:00
|
|
|
int snd_hda_codec_update_widgets(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
hda_nid_t fg;
|
|
|
|
int err;
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
err = snd_hdac_refresh_widgets(&codec->core);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2013-02-08 15:09:31 -07:00
|
|
|
/* Assume the function group node does not change,
|
|
|
|
* only the widget nodes may change.
|
|
|
|
*/
|
|
|
|
kfree(codec->wcaps);
|
2015-03-03 02:07:24 -07:00
|
|
|
fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
|
2013-02-08 15:09:31 -07:00
|
|
|
err = read_widget_caps(codec, fg);
|
2015-02-27 08:17:18 -07:00
|
|
|
if (err < 0)
|
2013-02-08 15:09:31 -07:00
|
|
|
return err;
|
|
|
|
|
|
|
|
snd_array_free(&codec->init_pins);
|
|
|
|
err = read_pin_defaults(codec);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_update_widgets);
|
2013-02-08 15:09:31 -07:00
|
|
|
|
2012-08-08 09:12:52 -06:00
|
|
|
/* update the stream-id if changed */
|
|
|
|
static void update_pcm_stream_id(struct hda_codec *codec,
|
|
|
|
struct hda_cvt_setup *p, hda_nid_t nid,
|
|
|
|
u32 stream_tag, int channel_id)
|
|
|
|
{
|
|
|
|
unsigned int oldval, newval;
|
|
|
|
|
|
|
|
if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
|
|
|
|
oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
|
|
|
|
newval = (stream_tag << 4) | channel_id;
|
|
|
|
if (oldval != newval)
|
|
|
|
snd_hda_codec_write(codec, nid, 0,
|
|
|
|
AC_VERB_SET_CHANNEL_STREAMID,
|
|
|
|
newval);
|
|
|
|
p->stream_tag = stream_tag;
|
|
|
|
p->channel_id = channel_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update the format-id if changed */
|
|
|
|
static void update_pcm_format(struct hda_codec *codec, struct hda_cvt_setup *p,
|
|
|
|
hda_nid_t nid, int format)
|
|
|
|
{
|
|
|
|
unsigned int oldval;
|
|
|
|
|
|
|
|
if (p->format_id != format) {
|
|
|
|
oldval = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_STREAM_FORMAT, 0);
|
|
|
|
if (oldval != format) {
|
|
|
|
msleep(1);
|
|
|
|
snd_hda_codec_write(codec, nid, 0,
|
|
|
|
AC_VERB_SET_STREAM_FORMAT,
|
|
|
|
format);
|
|
|
|
}
|
|
|
|
p->format_id = format;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_setup_stream - set up the codec for streaming
|
|
|
|
* @codec: the CODEC to set up
|
|
|
|
* @nid: the NID to set up
|
|
|
|
* @stream_tag: stream tag to pass, it's between 0x1 and 0xf.
|
|
|
|
* @channel_id: channel id to pass, zero based.
|
|
|
|
* @format: stream format.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
u32 stream_tag,
|
2005-04-16 16:20:36 -06:00
|
|
|
int channel_id, int format)
|
|
|
|
{
|
2010-08-20 01:44:36 -06:00
|
|
|
struct hda_codec *c;
|
2010-08-06 05:48:11 -06:00
|
|
|
struct hda_cvt_setup *p;
|
2010-10-22 09:15:47 -06:00
|
|
|
int type;
|
2010-08-06 05:48:11 -06:00
|
|
|
int i;
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
if (!nid)
|
2005-04-20 05:45:55 -06:00
|
|
|
return;
|
|
|
|
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_dbg(codec,
|
|
|
|
"hda_codec_setup_stream: NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
|
|
|
|
nid, stream_tag, channel_id, format);
|
2010-08-06 05:48:11 -06:00
|
|
|
p = get_hda_cvt_setup(codec, nid);
|
2013-05-10 05:39:50 -06:00
|
|
|
if (!p)
|
2010-08-06 05:48:11 -06:00
|
|
|
return;
|
2012-08-08 09:12:52 -06:00
|
|
|
|
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 14:32:11 -06:00
|
|
|
if (codec->patch_ops.stream_pm)
|
|
|
|
codec->patch_ops.stream_pm(codec, nid, true);
|
2012-08-08 09:12:52 -06:00
|
|
|
if (codec->pcm_format_first)
|
|
|
|
update_pcm_format(codec, p, nid, format);
|
|
|
|
update_pcm_stream_id(codec, p, nid, stream_tag, channel_id);
|
|
|
|
if (!codec->pcm_format_first)
|
|
|
|
update_pcm_format(codec, p, nid, format);
|
|
|
|
|
2010-08-06 05:48:11 -06:00
|
|
|
p->active = 1;
|
|
|
|
p->dirty = 0;
|
|
|
|
|
|
|
|
/* make other inactive cvts with the same stream-tag dirty */
|
2010-10-22 09:15:47 -06:00
|
|
|
type = get_wcaps_type(get_wcaps(codec, nid));
|
2015-03-02 15:22:59 -07:00
|
|
|
list_for_each_codec(c, codec->bus) {
|
2010-08-20 01:44:36 -06:00
|
|
|
for (i = 0; i < c->cvt_setups.used; i++) {
|
|
|
|
p = snd_array_elem(&c->cvt_setups, i);
|
2010-10-22 09:15:47 -06:00
|
|
|
if (!p->active && p->stream_tag == stream_tag &&
|
2012-02-01 04:05:41 -07:00
|
|
|
get_wcaps_type(get_wcaps(c, p->nid)) == type)
|
2010-08-20 01:44:36 -06:00
|
|
|
p->dirty = 1;
|
|
|
|
}
|
2010-08-06 05:48:11 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_setup_stream);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-08-13 03:56:53 -06:00
|
|
|
static void really_cleanup_stream(struct hda_codec *codec,
|
|
|
|
struct hda_cvt_setup *q);
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
2010-08-13 03:56:53 -06:00
|
|
|
* __snd_hda_codec_cleanup_stream - clean up the codec for closing
|
2009-11-16 06:58:17 -07:00
|
|
|
* @codec: the CODEC to clean up
|
|
|
|
* @nid: the NID to clean up
|
2010-08-13 03:56:53 -06:00
|
|
|
* @do_now: really clean up the stream instead of clearing the active flag
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2010-08-13 03:56:53 -06:00
|
|
|
void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int do_now)
|
2008-03-18 02:57:50 -06:00
|
|
|
{
|
2010-08-06 05:48:11 -06:00
|
|
|
struct hda_cvt_setup *p;
|
|
|
|
|
2008-03-18 02:57:50 -06:00
|
|
|
if (!nid)
|
|
|
|
return;
|
|
|
|
|
2010-10-25 02:37:11 -06:00
|
|
|
if (codec->no_sticky_stream)
|
|
|
|
do_now = 1;
|
|
|
|
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_dbg(codec, "hda_codec_cleanup_stream: NID=0x%x\n", nid);
|
2010-08-06 05:48:11 -06:00
|
|
|
p = get_hda_cvt_setup(codec, nid);
|
2013-05-10 05:39:50 -06:00
|
|
|
if (p) {
|
2010-08-13 03:56:53 -06:00
|
|
|
/* here we just clear the active flag when do_now isn't set;
|
|
|
|
* actual clean-ups will be done later in
|
|
|
|
* purify_inactive_streams() called from snd_hda_codec_prpapre()
|
|
|
|
*/
|
|
|
|
if (do_now)
|
|
|
|
really_cleanup_stream(codec, p);
|
|
|
|
else
|
|
|
|
p->active = 0;
|
|
|
|
}
|
2010-08-06 05:48:11 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(__snd_hda_codec_cleanup_stream);
|
2010-08-06 05:48:11 -06:00
|
|
|
|
|
|
|
static void really_cleanup_stream(struct hda_codec *codec,
|
|
|
|
struct hda_cvt_setup *q)
|
|
|
|
{
|
|
|
|
hda_nid_t nid = q->nid;
|
2011-09-27 09:33:45 -06:00
|
|
|
if (q->stream_tag || q->channel_id)
|
|
|
|
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
|
|
|
|
if (q->format_id)
|
|
|
|
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0
|
|
|
|
);
|
2010-08-06 05:48:11 -06:00
|
|
|
memset(q, 0, sizeof(*q));
|
|
|
|
q->nid = nid;
|
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 14:32:11 -06:00
|
|
|
if (codec->patch_ops.stream_pm)
|
|
|
|
codec->patch_ops.stream_pm(codec, nid, false);
|
2010-08-06 05:48:11 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* clean up the all conflicting obsolete streams */
|
|
|
|
static void purify_inactive_streams(struct hda_codec *codec)
|
|
|
|
{
|
2010-08-20 01:44:36 -06:00
|
|
|
struct hda_codec *c;
|
2010-08-06 05:48:11 -06:00
|
|
|
int i;
|
|
|
|
|
2015-03-02 15:22:59 -07:00
|
|
|
list_for_each_codec(c, codec->bus) {
|
2010-08-20 01:44:36 -06:00
|
|
|
for (i = 0; i < c->cvt_setups.used; i++) {
|
|
|
|
struct hda_cvt_setup *p;
|
|
|
|
p = snd_array_elem(&c->cvt_setups, i);
|
|
|
|
if (p->dirty)
|
|
|
|
really_cleanup_stream(c, p);
|
|
|
|
}
|
2010-08-06 05:48:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-26 01:52:50 -06:00
|
|
|
#ifdef CONFIG_PM
|
2010-08-06 05:48:11 -06:00
|
|
|
/* clean up all streams; called from suspend */
|
|
|
|
static void hda_cleanup_all_streams(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < codec->cvt_setups.used; i++) {
|
|
|
|
struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
|
|
|
|
if (p->stream_tag)
|
|
|
|
really_cleanup_stream(codec, p);
|
|
|
|
}
|
2008-03-18 02:57:50 -06:00
|
|
|
}
|
2011-04-20 13:04:36 -06:00
|
|
|
#endif
|
2008-03-18 02:57:50 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* amp access functions
|
|
|
|
*/
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* query_amp_caps - query AMP capabilities
|
|
|
|
* @codec: the HD-auio codec
|
|
|
|
* @nid: the NID to query
|
|
|
|
* @direction: either #HDA_INPUT or #HDA_OUTPUT
|
|
|
|
*
|
|
|
|
* Query AMP capabilities for the given widget and direction.
|
|
|
|
* Returns the obtained capability bits.
|
|
|
|
*
|
|
|
|
* When cap bits have been already read, this doesn't read again but
|
|
|
|
* returns the cached value.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-01-24 03:49:21 -07:00
|
|
|
u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-02-26 00:54:56 -07:00
|
|
|
if (!(get_wcaps(codec, nid) & AC_WCAP_AMP_OVRD))
|
|
|
|
nid = codec->core.afg;
|
|
|
|
return snd_hda_param_read(codec, nid,
|
|
|
|
direction == HDA_OUTPUT ?
|
|
|
|
AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(query_amp_caps);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-09-23 02:38:17 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_check_amp_caps - query AMP capabilities
|
|
|
|
* @codec: the HD-audio codec
|
|
|
|
* @nid: the NID to query
|
|
|
|
* @dir: either #HDA_INPUT or #HDA_OUTPUT
|
2014-10-29 08:06:01 -06:00
|
|
|
* @bits: bit mask to check the result
|
2014-09-23 02:38:17 -06:00
|
|
|
*
|
|
|
|
* Check whether the widget has the given amp capability for the direction.
|
|
|
|
*/
|
|
|
|
bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int dir, unsigned int bits)
|
|
|
|
{
|
|
|
|
if (!nid)
|
|
|
|
return false;
|
|
|
|
if (get_wcaps(codec, nid) & (1 << (dir + 1)))
|
|
|
|
if (query_amp_caps(codec, nid, dir) & bits)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_check_amp_caps);
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_override_amp_caps - Override the AMP capabilities
|
|
|
|
* @codec: the CODEC to clean up
|
|
|
|
* @nid: the NID to clean up
|
2014-10-29 08:06:01 -06:00
|
|
|
* @dir: either #HDA_INPUT or #HDA_OUTPUT
|
2009-11-16 06:58:17 -07:00
|
|
|
* @caps: the capability bits to set
|
|
|
|
*
|
|
|
|
* Override the cached AMP caps bits value by the given one.
|
|
|
|
* This function is useful if the driver needs to adjust the AMP ranges,
|
|
|
|
* e.g. limit to 0dB, etc.
|
|
|
|
*
|
|
|
|
* Returns zero if successful or a negative error code.
|
|
|
|
*/
|
2007-05-29 11:01:37 -06:00
|
|
|
int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
|
|
|
|
unsigned int caps)
|
|
|
|
{
|
2015-02-26 00:54:56 -07:00
|
|
|
unsigned int parm;
|
2007-05-29 11:01:37 -06:00
|
|
|
|
2015-02-26 00:54:56 -07:00
|
|
|
snd_hda_override_wcaps(codec, nid,
|
|
|
|
get_wcaps(codec, nid) | AC_WCAP_AMP_OVRD);
|
|
|
|
parm = dir == HDA_OUTPUT ? AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP;
|
|
|
|
return snd_hdac_override_parm(&codec->core, nid, parm, caps);
|
2011-08-15 04:49:07 -06:00
|
|
|
}
|
2015-02-26 00:54:56 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_override_amp_caps);
|
2011-08-15 04:49:07 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_amp_stereo - update the AMP stereo values
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @nid: NID to read the AMP value
|
|
|
|
* @direction: #HDA_INPUT or #HDA_OUTPUT
|
|
|
|
* @idx: the index value (only for input direction)
|
|
|
|
* @mask: bit mask to set
|
|
|
|
* @val: the bits value to set
|
|
|
|
*
|
|
|
|
* Update the AMP values like snd_hda_codec_amp_update(), but for a
|
|
|
|
* stereo widget with the same mask and value.
|
2007-08-10 09:11:07 -06:00
|
|
|
*/
|
|
|
|
int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int direction, int idx, int mask, int val)
|
|
|
|
{
|
|
|
|
int ch, ret = 0;
|
2010-03-29 01:19:38 -06:00
|
|
|
|
|
|
|
if (snd_BUG_ON(mask & ~0xff))
|
|
|
|
mask &= 0xff;
|
2007-08-10 09:11:07 -06:00
|
|
|
for (ch = 0; ch < 2; ch++)
|
|
|
|
ret |= snd_hda_codec_amp_update(codec, nid, ch, direction,
|
|
|
|
idx, mask, val);
|
|
|
|
return ret;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_stereo);
|
2007-08-10 09:11:07 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_amp_init - initialize the AMP value
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to read the AMP value
|
|
|
|
* @ch: channel (left=0 or right=1)
|
|
|
|
* @dir: #HDA_INPUT or #HDA_OUTPUT
|
|
|
|
* @idx: the index value (only for input direction)
|
|
|
|
* @mask: bit mask to set
|
|
|
|
* @val: the bits value to set
|
|
|
|
*
|
|
|
|
* Works like snd_hda_codec_amp_update() but it writes the value only at
|
2012-12-14 02:32:21 -07:00
|
|
|
* the first access. If the amp was already initialized / updated beforehand,
|
|
|
|
* this does nothing.
|
|
|
|
*/
|
|
|
|
int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
|
|
|
|
int dir, int idx, int mask, int val)
|
|
|
|
{
|
2015-02-25 07:18:50 -07:00
|
|
|
int orig;
|
|
|
|
|
|
|
|
if (!codec->core.regmap)
|
|
|
|
return -EINVAL;
|
|
|
|
regcache_cache_only(codec->core.regmap, true);
|
|
|
|
orig = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
|
|
|
|
regcache_cache_only(codec->core.regmap, false);
|
|
|
|
if (orig >= 0)
|
|
|
|
return 0;
|
|
|
|
return snd_hda_codec_amp_update(codec, nid, ch, dir, idx, mask, val);
|
2012-12-14 02:32:21 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init);
|
2012-12-14 02:32:21 -07:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_amp_init_stereo - initialize the stereo AMP value
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: NID to read the AMP value
|
|
|
|
* @dir: #HDA_INPUT or #HDA_OUTPUT
|
|
|
|
* @idx: the index value (only for input direction)
|
|
|
|
* @mask: bit mask to set
|
|
|
|
* @val: the bits value to set
|
|
|
|
*
|
|
|
|
* Call snd_hda_codec_amp_init() for both stereo channels.
|
|
|
|
*/
|
2012-12-14 02:32:21 -07:00
|
|
|
int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int dir, int idx, int mask, int val)
|
|
|
|
{
|
|
|
|
int ch, ret = 0;
|
|
|
|
|
|
|
|
if (snd_BUG_ON(mask & ~0xff))
|
|
|
|
mask &= 0xff;
|
|
|
|
for (ch = 0; ch < 2; ch++)
|
|
|
|
ret |= snd_hda_codec_amp_init(codec, nid, ch, dir,
|
|
|
|
idx, mask, val);
|
|
|
|
return ret;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_amp_init_stereo);
|
2012-12-14 02:32:21 -07:00
|
|
|
|
2010-07-08 10:40:37 -06:00
|
|
|
static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
|
|
|
|
unsigned int ofs)
|
|
|
|
{
|
|
|
|
u32 caps = query_amp_caps(codec, nid, dir);
|
|
|
|
/* get num steps */
|
|
|
|
caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
|
|
|
|
if (ofs < caps)
|
|
|
|
caps -= ofs;
|
|
|
|
return caps;
|
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: referred ctl element
|
|
|
|
* @uinfo: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
u16 nid = get_amp_nid(kcontrol);
|
|
|
|
u8 chs = get_amp_channels(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
2009-01-20 05:07:55 -07:00
|
|
|
unsigned int ofs = get_amp_offset(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-07-08 10:40:37 -06:00
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = chs == 3 ? 2 : 1;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
|
|
|
|
if (!uinfo->value.integer.max) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_warn(codec,
|
|
|
|
"num_steps = 0 for NID=0x%x (ctl = %s)\n",
|
|
|
|
nid, kcontrol->id.name);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_info);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-20 05:07:55 -07:00
|
|
|
|
|
|
|
static inline unsigned int
|
|
|
|
read_amp_value(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int ch, int dir, int idx, unsigned int ofs)
|
|
|
|
{
|
|
|
|
unsigned int val;
|
|
|
|
val = snd_hda_codec_amp_read(codec, nid, ch, dir, idx);
|
|
|
|
val &= HDA_AMP_VOLMASK;
|
|
|
|
if (val >= ofs)
|
|
|
|
val -= ofs;
|
|
|
|
else
|
|
|
|
val = 0;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
update_amp_value(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int ch, int dir, int idx, unsigned int ofs,
|
|
|
|
unsigned int val)
|
|
|
|
{
|
2010-07-08 10:40:37 -06:00
|
|
|
unsigned int maxval;
|
|
|
|
|
2009-01-20 05:07:55 -07:00
|
|
|
if (val > 0)
|
|
|
|
val += ofs;
|
2010-07-26 09:00:15 -06:00
|
|
|
/* ofs = 0: raw max value */
|
|
|
|
maxval = get_amp_max_value(codec, nid, dir, 0);
|
2010-07-08 10:40:37 -06:00
|
|
|
if (val > maxval)
|
|
|
|
val = maxval;
|
2015-02-25 07:18:50 -07:00
|
|
|
return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
|
|
|
|
HDA_AMP_VOLMASK, val);
|
2009-01-20 05:07:55 -07:00
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_volume_get - Get callback for a standard AMP mixer volume
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = get_amp_nid(kcontrol);
|
|
|
|
int chs = get_amp_channels(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
|
|
|
int idx = get_amp_index(kcontrol);
|
2009-01-20 05:07:55 -07:00
|
|
|
unsigned int ofs = get_amp_offset(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
long *valp = ucontrol->value.integer.value;
|
|
|
|
|
|
|
|
if (chs & 1)
|
2009-01-20 05:07:55 -07:00
|
|
|
*valp++ = read_amp_value(codec, nid, 0, dir, idx, ofs);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (chs & 2)
|
2009-01-20 05:07:55 -07:00
|
|
|
*valp = read_amp_value(codec, nid, 1, dir, idx, ofs);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_get);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_volume_put - Put callback for a standard AMP mixer volume
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = get_amp_nid(kcontrol);
|
|
|
|
int chs = get_amp_channels(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
|
|
|
int idx = get_amp_index(kcontrol);
|
2009-01-20 05:07:55 -07:00
|
|
|
unsigned int ofs = get_amp_offset(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
long *valp = ucontrol->value.integer.value;
|
|
|
|
int change = 0;
|
|
|
|
|
2005-07-29 04:17:20 -06:00
|
|
|
if (chs & 1) {
|
2009-01-20 05:07:55 -07:00
|
|
|
change = update_amp_value(codec, nid, 0, dir, idx, ofs, *valp);
|
2005-07-29 04:17:20 -06:00
|
|
|
valp++;
|
|
|
|
}
|
2005-06-08 06:43:58 -06:00
|
|
|
if (chs & 2)
|
2009-01-20 05:07:55 -07:00
|
|
|
change |= update_amp_value(codec, nid, 1, dir, idx, ofs, *valp);
|
2005-04-16 16:20:36 -06:00
|
|
|
return change;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_volume_put);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_volume_put - TLV callback for a standard AMP mixer volume
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @op_flag: operation flag
|
|
|
|
* @size: byte size of input TLV
|
|
|
|
* @_tlv: TLV data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2006-07-05 09:39:49 -06:00
|
|
|
int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
unsigned int size, unsigned int __user *_tlv)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = get_amp_nid(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
2009-01-20 05:07:55 -07:00
|
|
|
unsigned int ofs = get_amp_offset(kcontrol);
|
2010-10-15 02:32:50 -06:00
|
|
|
bool min_mute = get_amp_min_mute(kcontrol);
|
2006-07-05 09:39:49 -06:00
|
|
|
u32 caps, val1, val2;
|
|
|
|
|
|
|
|
if (size < 4 * sizeof(unsigned int))
|
|
|
|
return -ENOMEM;
|
|
|
|
caps = query_amp_caps(codec, nid, dir);
|
2007-04-16 03:29:14 -06:00
|
|
|
val2 = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
|
|
|
|
val2 = (val2 + 1) * 25;
|
2006-07-05 09:39:49 -06:00
|
|
|
val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT);
|
2009-01-20 05:07:55 -07:00
|
|
|
val1 += ofs;
|
2006-07-05 09:39:49 -06:00
|
|
|
val1 = ((int)val1) * ((int)val2);
|
2012-02-27 07:00:58 -07:00
|
|
|
if (min_mute || (caps & AC_AMPCAP_MIN_MUTE))
|
2010-10-17 02:40:53 -06:00
|
|
|
val2 |= TLV_DB_SCALE_MUTE;
|
2006-07-05 09:39:49 -06:00
|
|
|
if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv))
|
|
|
|
return -EFAULT;
|
|
|
|
if (put_user(2 * sizeof(unsigned int), _tlv + 1))
|
|
|
|
return -EFAULT;
|
|
|
|
if (put_user(val1, _tlv + 2))
|
|
|
|
return -EFAULT;
|
|
|
|
if (put_user(val2, _tlv + 3))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_tlv);
|
2006-07-05 09:39:49 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_set_vmaster_tlv - Set TLV for a virtual master control
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @nid: NID of a reference widget
|
|
|
|
* @dir: #HDA_INPUT or #HDA_OUTPUT
|
|
|
|
* @tlv: TLV data to be stored, at least 4 elements
|
|
|
|
*
|
|
|
|
* Set (static) TLV data for a virtual master volume using the AMP caps
|
|
|
|
* obtained from the reference NID.
|
|
|
|
* The volume range is recalculated as if the max volume is 0dB.
|
2008-01-10 08:53:55 -07:00
|
|
|
*/
|
|
|
|
void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
|
|
|
|
unsigned int *tlv)
|
|
|
|
{
|
|
|
|
u32 caps;
|
|
|
|
int nums, step;
|
|
|
|
|
|
|
|
caps = query_amp_caps(codec, nid, dir);
|
|
|
|
nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
|
|
|
|
step = (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT;
|
|
|
|
step = (step + 1) * 25;
|
|
|
|
tlv[0] = SNDRV_CTL_TLVT_DB_SCALE;
|
|
|
|
tlv[1] = 2 * sizeof(unsigned int);
|
|
|
|
tlv[2] = -nums * step;
|
|
|
|
tlv[3] = step;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_set_vmaster_tlv);
|
2008-01-10 08:53:55 -07:00
|
|
|
|
|
|
|
/* find a mixer control element with the given name */
|
2008-02-04 04:31:13 -07:00
|
|
|
static struct snd_kcontrol *
|
2012-10-12 09:24:51 -06:00
|
|
|
find_mixer_ctl(struct hda_codec *codec, const char *name, int dev, int idx)
|
2008-01-10 08:53:55 -07:00
|
|
|
{
|
|
|
|
struct snd_ctl_elem_id id;
|
|
|
|
memset(&id, 0, sizeof(id));
|
|
|
|
id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
|
2012-10-12 09:24:51 -06:00
|
|
|
id.device = dev;
|
2008-02-04 04:31:13 -07:00
|
|
|
id.index = idx;
|
2009-04-16 02:22:24 -06:00
|
|
|
if (snd_BUG_ON(strlen(name) >= sizeof(id.name)))
|
|
|
|
return NULL;
|
2008-01-10 08:53:55 -07:00
|
|
|
strcpy(id.name, name);
|
2015-02-27 08:09:22 -07:00
|
|
|
return snd_ctl_find_id(codec->card, &id);
|
2008-01-10 08:53:55 -07:00
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_find_mixer_ctl - Find a mixer control element with the given name
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @name: ctl id name string
|
|
|
|
*
|
|
|
|
* Get the control element with the given id string and IFACE_MIXER.
|
|
|
|
*/
|
2008-02-04 04:31:13 -07:00
|
|
|
struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
|
|
|
|
const char *name)
|
|
|
|
{
|
2012-10-12 09:24:51 -06:00
|
|
|
return find_mixer_ctl(codec, name, 0, 0);
|
2008-02-04 04:31:13 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_find_mixer_ctl);
|
2008-02-04 04:31:13 -07:00
|
|
|
|
2012-10-12 09:24:51 -06:00
|
|
|
static int find_empty_mixer_ctl_idx(struct hda_codec *codec, const char *name,
|
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 09:02:41 -07:00
|
|
|
int start_idx)
|
2010-12-23 02:17:52 -07:00
|
|
|
{
|
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 09:02:41 -07:00
|
|
|
int i, idx;
|
|
|
|
/* 16 ctlrs should be large enough */
|
|
|
|
for (i = 0, idx = start_idx; i < 16; i++, idx++) {
|
|
|
|
if (!find_mixer_ctl(codec, name, 0, idx))
|
2010-12-23 02:17:52 -07:00
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
2009-12-08 08:13:32 -07:00
|
|
|
* snd_hda_ctl_add - Add a control element and assign to the codec
|
2009-11-16 06:58:17 -07:00
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @nid: corresponding NID (optional)
|
|
|
|
* @kctl: the control element to assign
|
|
|
|
*
|
|
|
|
* Add the given control element to an array inside the codec instance.
|
|
|
|
* All control elements belonging to a codec are supposed to be added
|
|
|
|
* by this function so that a proper clean-up works at the free or
|
|
|
|
* reconfiguration time.
|
|
|
|
*
|
|
|
|
* If non-zero @nid is passed, the NID is assigned to the control element.
|
|
|
|
* The assignment is shown in the codec proc file.
|
|
|
|
*
|
|
|
|
* snd_hda_ctl_add() checks the control subdev id field whether
|
|
|
|
* #HDA_SUBDEV_NID_FLAG bit is set. If set (and @nid is zero), the lower
|
ALSA: hda - introduce HDA_SUBDEV_AMP_FLAG (ControlAmp in proc)
The purpose of this changeset is to show information about amplifier
setting in the codec proc file. Something like:
Control: name="Front Playback Volume", index=0, device=0
ControlAmp: chs=3, dir=Out, idx=0, ofs=0
Control: name="Front Playback Switch", index=0, device=0
ControlAmp: chs=3, dir=In, idx=2, ofs=0
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2009-12-08 09:45:25 -07:00
|
|
|
* bits value is taken as the NID to assign. The #HDA_NID_ITEM_AMP bit
|
|
|
|
* specifies if kctl->private_value is a HDA amplifier value.
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2009-11-11 05:43:01 -07:00
|
|
|
int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
struct snd_kcontrol *kctl)
|
2008-07-30 07:01:45 -06:00
|
|
|
{
|
|
|
|
int err;
|
ALSA: hda - introduce HDA_SUBDEV_AMP_FLAG (ControlAmp in proc)
The purpose of this changeset is to show information about amplifier
setting in the codec proc file. Something like:
Control: name="Front Playback Volume", index=0, device=0
ControlAmp: chs=3, dir=Out, idx=0, ofs=0
Control: name="Front Playback Switch", index=0, device=0
ControlAmp: chs=3, dir=In, idx=2, ofs=0
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2009-12-08 09:45:25 -07:00
|
|
|
unsigned short flags = 0;
|
2009-11-11 05:43:01 -07:00
|
|
|
struct hda_nid_item *item;
|
2008-07-30 07:01:45 -06:00
|
|
|
|
2009-12-10 05:57:01 -07:00
|
|
|
if (kctl->id.subdevice & HDA_SUBDEV_AMP_FLAG) {
|
ALSA: hda - introduce HDA_SUBDEV_AMP_FLAG (ControlAmp in proc)
The purpose of this changeset is to show information about amplifier
setting in the codec proc file. Something like:
Control: name="Front Playback Volume", index=0, device=0
ControlAmp: chs=3, dir=Out, idx=0, ofs=0
Control: name="Front Playback Switch", index=0, device=0
ControlAmp: chs=3, dir=In, idx=2, ofs=0
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2009-12-08 09:45:25 -07:00
|
|
|
flags |= HDA_NID_ITEM_AMP;
|
2009-12-10 05:57:01 -07:00
|
|
|
if (nid == 0)
|
|
|
|
nid = get_amp_nid_(kctl->private_value);
|
|
|
|
}
|
ALSA: hda - introduce HDA_SUBDEV_AMP_FLAG (ControlAmp in proc)
The purpose of this changeset is to show information about amplifier
setting in the codec proc file. Something like:
Control: name="Front Playback Volume", index=0, device=0
ControlAmp: chs=3, dir=Out, idx=0, ofs=0
Control: name="Front Playback Switch", index=0, device=0
ControlAmp: chs=3, dir=In, idx=2, ofs=0
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2009-12-08 09:45:25 -07:00
|
|
|
if ((kctl->id.subdevice & HDA_SUBDEV_NID_FLAG) != 0 && nid == 0)
|
|
|
|
nid = kctl->id.subdevice & 0xffff;
|
2009-12-10 05:57:01 -07:00
|
|
|
if (kctl->id.subdevice & (HDA_SUBDEV_NID_FLAG|HDA_SUBDEV_AMP_FLAG))
|
2009-11-12 02:15:48 -07:00
|
|
|
kctl->id.subdevice = 0;
|
2015-02-27 08:09:22 -07:00
|
|
|
err = snd_ctl_add(codec->card, kctl);
|
2008-07-30 07:01:45 -06:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2009-11-11 05:43:01 -07:00
|
|
|
item = snd_array_new(&codec->mixers);
|
|
|
|
if (!item)
|
2008-07-30 07:01:45 -06:00
|
|
|
return -ENOMEM;
|
2009-11-11 05:43:01 -07:00
|
|
|
item->kctl = kctl;
|
|
|
|
item->nid = nid;
|
ALSA: hda - introduce HDA_SUBDEV_AMP_FLAG (ControlAmp in proc)
The purpose of this changeset is to show information about amplifier
setting in the codec proc file. Something like:
Control: name="Front Playback Volume", index=0, device=0
ControlAmp: chs=3, dir=Out, idx=0, ofs=0
Control: name="Front Playback Switch", index=0, device=0
ControlAmp: chs=3, dir=In, idx=2, ofs=0
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
2009-12-08 09:45:25 -07:00
|
|
|
item->flags = flags;
|
2008-07-30 07:01:45 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_ctl_add);
|
2008-07-30 07:01:45 -06:00
|
|
|
|
2009-12-08 08:13:32 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_add_nid - Assign a NID to a control element
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @nid: corresponding NID (optional)
|
|
|
|
* @kctl: the control element to assign
|
|
|
|
* @index: index to kctl
|
|
|
|
*
|
|
|
|
* Add the given control element to an array inside the codec instance.
|
|
|
|
* This function is used when #snd_hda_ctl_add cannot be used for 1:1
|
|
|
|
* NID:KCTL mapping - for example "Capture Source" selector.
|
|
|
|
*/
|
|
|
|
int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
|
|
|
|
unsigned int index, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
struct hda_nid_item *item;
|
|
|
|
|
|
|
|
if (nid > 0) {
|
|
|
|
item = snd_array_new(&codec->nids);
|
|
|
|
if (!item)
|
|
|
|
return -ENOMEM;
|
|
|
|
item->kctl = kctl;
|
|
|
|
item->index = index;
|
|
|
|
item->nid = nid;
|
|
|
|
return 0;
|
|
|
|
}
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_err(codec, "no NID for mapping control %s:%d:%d\n",
|
|
|
|
kctl->id.name, kctl->id.index, index);
|
2009-12-08 08:13:32 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_add_nid);
|
2009-12-08 08:13:32 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_ctls_clear - Clear all controls assigned to the given codec
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
*/
|
2008-07-30 07:01:45 -06:00
|
|
|
void snd_hda_ctls_clear(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int i;
|
2009-11-11 05:43:01 -07:00
|
|
|
struct hda_nid_item *items = codec->mixers.list;
|
2008-07-30 07:01:45 -06:00
|
|
|
for (i = 0; i < codec->mixers.used; i++)
|
2015-02-27 08:09:22 -07:00
|
|
|
snd_ctl_remove(codec->card, items[i].kctl);
|
2008-07-30 07:01:45 -06:00
|
|
|
snd_array_free(&codec->mixers);
|
2009-12-08 08:13:32 -07:00
|
|
|
snd_array_free(&codec->nids);
|
2008-07-30 07:01:45 -06:00
|
|
|
}
|
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_lock_devices - pseudo device locking
|
|
|
|
* @bus: the BUS
|
|
|
|
*
|
2009-02-23 08:57:04 -07:00
|
|
|
* toggle card->shutdown to allow/disallow the device access (as a hack)
|
|
|
|
*/
|
2012-04-26 04:11:44 -06:00
|
|
|
int snd_hda_lock_devices(struct hda_bus *bus)
|
2008-07-30 07:01:45 -06:00
|
|
|
{
|
2012-04-26 04:11:44 -06:00
|
|
|
struct snd_card *card = bus->card;
|
|
|
|
struct hda_codec *codec;
|
|
|
|
|
2009-02-23 08:57:04 -07:00
|
|
|
spin_lock(&card->files_lock);
|
2012-04-26 04:11:44 -06:00
|
|
|
if (card->shutdown)
|
|
|
|
goto err_unlock;
|
2009-02-23 08:57:04 -07:00
|
|
|
card->shutdown = 1;
|
2012-04-26 04:11:44 -06:00
|
|
|
if (!list_empty(&card->ctl_files))
|
|
|
|
goto err_clear;
|
|
|
|
|
2015-03-02 15:22:59 -07:00
|
|
|
list_for_each_codec(codec, bus) {
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm *cpcm;
|
|
|
|
list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
|
2012-04-26 04:11:44 -06:00
|
|
|
if (!cpcm->pcm)
|
|
|
|
continue;
|
|
|
|
if (cpcm->pcm->streams[0].substream_opened ||
|
|
|
|
cpcm->pcm->streams[1].substream_opened)
|
|
|
|
goto err_clear;
|
|
|
|
}
|
|
|
|
}
|
2009-02-23 08:57:04 -07:00
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
return 0;
|
2012-04-26 04:11:44 -06:00
|
|
|
|
|
|
|
err_clear:
|
|
|
|
card->shutdown = 0;
|
|
|
|
err_unlock:
|
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
return -EINVAL;
|
2009-02-23 08:57:04 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_lock_devices);
|
2009-02-23 08:57:04 -07:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_unlock_devices - pseudo device unlocking
|
|
|
|
* @bus: the BUS
|
|
|
|
*/
|
2012-04-26 04:11:44 -06:00
|
|
|
void snd_hda_unlock_devices(struct hda_bus *bus)
|
2009-02-23 08:57:04 -07:00
|
|
|
{
|
2012-04-26 04:11:44 -06:00
|
|
|
struct snd_card *card = bus->card;
|
|
|
|
|
2009-02-23 08:57:04 -07:00
|
|
|
spin_lock(&card->files_lock);
|
|
|
|
card->shutdown = 0;
|
|
|
|
spin_unlock(&card->files_lock);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_unlock_devices);
|
2009-02-23 08:57:04 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_reset - Clear all objects assigned to the codec
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
*
|
|
|
|
* This frees the all PCM and control elements assigned to the codec, and
|
|
|
|
* clears the caches and restores the pin default configurations.
|
|
|
|
*
|
|
|
|
* When a device is being used, it returns -EBSY. If successfully freed,
|
|
|
|
* returns zero.
|
|
|
|
*/
|
2009-02-23 08:57:04 -07:00
|
|
|
int snd_hda_codec_reset(struct hda_codec *codec)
|
|
|
|
{
|
2012-04-26 04:11:44 -06:00
|
|
|
struct hda_bus *bus = codec->bus;
|
2009-02-23 08:57:04 -07:00
|
|
|
|
2012-04-26 04:11:44 -06:00
|
|
|
if (snd_hda_lock_devices(bus) < 0)
|
2009-02-23 08:57:04 -07:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* OK, let it free */
|
ALSA: hda - Add widget sysfs tree
This patch changes the sysfs files assigned to the codec device on the
bus which were formerly identical with hwdep sysfs files. Now it
shows only a few core parameter, vendor_id, subsystem_id, revision_id,
afg, mfg, vendor_name and chip_name.
In addition, now a widget tree is added to the bus device sysfs
directory for showing the widget topology and attributes. It's just a
flat tree consisting of subdirectories named as the widget NID
including various attributes like widget capability bits. The AFG
(usually NID 0x01) is always found there, and it contains always
amp_in_caps, amp_out_caps and power_caps files. Each of these
attributes show a single value. The rest are the widget nodes
belonging to that AFG. Note that the child node might not start from
0x02 but from another value like 0x0a.
Each child node may contain caps, pin_caps, amp_in_caps, amp_out_caps,
power_caps and connections files. The caps (representing the widget
capability bits) always contain a value. The rest may contain
value(s) if the attribute exists on the node. Only connections file
show multiple values while other attributes have zero or one single
value.
An example of ls -R output is like below:
% ls -R /sys/bus/hdaudio/devices/hdaudioC0D0/
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/:
01/ 04/ 07/ 0a/ 0d/ 10/ 13/ 16/ 19/ 1c/ 1f/ 22/
02/ 05/ 08/ 0b/ 0e/ 11/ 14/ 17/ 1a/ 1d/ 20/ 23/
03/ 06/ 09/ 0c/ 0f/ 12/ 15/ 18/ 1b/ 1e/ 21/
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/01:
amp_in_caps amp_out_caps power_caps
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/02:
amp_in_caps amp_out_caps caps connections pin_caps pin_cfg
power_caps
/sys/bus/hdaudio/devices/hdaudioC0D0/widgets/03:
.....
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2015-02-24 06:59:42 -07:00
|
|
|
snd_hdac_device_unregister(&codec->core);
|
2015-02-17 07:25:37 -07:00
|
|
|
|
2009-02-23 08:57:04 -07:00
|
|
|
/* allow device access again */
|
2012-04-26 04:11:44 -06:00
|
|
|
snd_hda_unlock_devices(bus);
|
2009-02-23 08:57:04 -07:00
|
|
|
return 0;
|
2008-07-30 07:01:45 -06:00
|
|
|
}
|
|
|
|
|
2014-06-06 10:12:16 -06:00
|
|
|
typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *);
|
2011-11-10 04:28:38 -07:00
|
|
|
|
|
|
|
/* apply the function to all matching slave ctls in the mixer list */
|
|
|
|
static int map_slaves(struct hda_codec *codec, const char * const *slaves,
|
2012-02-03 06:28:01 -07:00
|
|
|
const char *suffix, map_slave_func_t func, void *data)
|
2011-11-10 04:28:38 -07:00
|
|
|
{
|
|
|
|
struct hda_nid_item *items;
|
|
|
|
const char * const *s;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
items = codec->mixers.list;
|
|
|
|
for (i = 0; i < codec->mixers.used; i++) {
|
|
|
|
struct snd_kcontrol *sctl = items[i].kctl;
|
2013-10-28 05:00:35 -06:00
|
|
|
if (!sctl || sctl->id.iface != SNDRV_CTL_ELEM_IFACE_MIXER)
|
2011-11-10 04:28:38 -07:00
|
|
|
continue;
|
|
|
|
for (s = slaves; *s; s++) {
|
2012-02-03 06:28:01 -07:00
|
|
|
char tmpname[sizeof(sctl->id.name)];
|
|
|
|
const char *name = *s;
|
|
|
|
if (suffix) {
|
|
|
|
snprintf(tmpname, sizeof(tmpname), "%s %s",
|
|
|
|
name, suffix);
|
|
|
|
name = tmpname;
|
|
|
|
}
|
|
|
|
if (!strcmp(sctl->id.name, name)) {
|
2014-06-06 10:12:16 -06:00
|
|
|
err = func(codec, data, sctl);
|
2011-11-10 04:28:38 -07:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-06 10:12:16 -06:00
|
|
|
static int check_slave_present(struct hda_codec *codec,
|
|
|
|
void *data, struct snd_kcontrol *sctl)
|
2011-11-10 04:28:38 -07:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-03-09 09:51:10 -07:00
|
|
|
/* guess the value corresponding to 0dB */
|
2014-06-06 10:12:16 -06:00
|
|
|
static int get_kctl_0dB_offset(struct hda_codec *codec,
|
|
|
|
struct snd_kcontrol *kctl, int *step_to_check)
|
2012-03-09 09:51:10 -07:00
|
|
|
{
|
|
|
|
int _tlv[4];
|
|
|
|
const int *tlv = NULL;
|
|
|
|
int val = -1;
|
|
|
|
|
|
|
|
if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) {
|
|
|
|
/* FIXME: set_fs() hack for obtaining user-space TLV data */
|
|
|
|
mm_segment_t fs = get_fs();
|
|
|
|
set_fs(get_ds());
|
|
|
|
if (!kctl->tlv.c(kctl, 0, sizeof(_tlv), _tlv))
|
|
|
|
tlv = _tlv;
|
|
|
|
set_fs(fs);
|
|
|
|
} else if (kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_READ)
|
|
|
|
tlv = kctl->tlv.p;
|
2013-11-04 07:44:09 -07:00
|
|
|
if (tlv && tlv[0] == SNDRV_CTL_TLVT_DB_SCALE) {
|
|
|
|
int step = tlv[3];
|
|
|
|
step &= ~TLV_DB_SCALE_MUTE;
|
|
|
|
if (!step)
|
|
|
|
return -1;
|
2013-11-04 07:51:00 -07:00
|
|
|
if (*step_to_check && *step_to_check != step) {
|
2014-06-06 10:12:16 -06:00
|
|
|
codec_err(codec, "Mismatching dB step for vmaster slave (%d!=%d)\n",
|
2014-02-25 04:21:03 -07:00
|
|
|
- *step_to_check, step);
|
2013-11-04 07:51:00 -07:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*step_to_check = step;
|
2013-11-04 07:44:09 -07:00
|
|
|
val = -tlv[2] / step;
|
|
|
|
}
|
2012-03-09 09:51:10 -07:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* call kctl->put with the given value(s) */
|
|
|
|
static int put_kctl_with_value(struct snd_kcontrol *kctl, int val)
|
|
|
|
{
|
|
|
|
struct snd_ctl_elem_value *ucontrol;
|
|
|
|
ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
|
|
|
|
if (!ucontrol)
|
|
|
|
return -ENOMEM;
|
|
|
|
ucontrol->value.integer.value[0] = val;
|
|
|
|
ucontrol->value.integer.value[1] = val;
|
|
|
|
kctl->put(kctl, ucontrol);
|
|
|
|
kfree(ucontrol);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* initialize the slave volume with 0dB */
|
2014-06-06 10:12:16 -06:00
|
|
|
static int init_slave_0dB(struct hda_codec *codec,
|
|
|
|
void *data, struct snd_kcontrol *slave)
|
2012-03-09 09:51:10 -07:00
|
|
|
{
|
2014-06-06 10:12:16 -06:00
|
|
|
int offset = get_kctl_0dB_offset(codec, slave, data);
|
2012-03-09 09:51:10 -07:00
|
|
|
if (offset > 0)
|
|
|
|
put_kctl_with_value(slave, offset);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unmute the slave */
|
2014-06-06 10:12:16 -06:00
|
|
|
static int init_slave_unmute(struct hda_codec *codec,
|
|
|
|
void *data, struct snd_kcontrol *slave)
|
2012-03-09 09:51:10 -07:00
|
|
|
{
|
|
|
|
return put_kctl_with_value(slave, 1);
|
|
|
|
}
|
|
|
|
|
2014-06-30 06:02:39 -06:00
|
|
|
static int add_slave(struct hda_codec *codec,
|
|
|
|
void *data, struct snd_kcontrol *slave)
|
|
|
|
{
|
|
|
|
return snd_ctl_add_slave(data, slave);
|
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
2014-10-29 09:03:58 -06:00
|
|
|
* __snd_hda_add_vmaster - create a virtual master control and add slaves
|
2009-11-16 06:58:17 -07:00
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @name: vmaster control name
|
|
|
|
* @tlv: TLV data (optional)
|
|
|
|
* @slaves: slave control names (optional)
|
2012-02-03 06:28:01 -07:00
|
|
|
* @suffix: suffix string to each slave name (optional)
|
2012-03-09 09:51:10 -07:00
|
|
|
* @init_slave_vol: initialize slaves to unmute/0dB
|
2012-03-12 05:25:03 -06:00
|
|
|
* @ctl_ret: store the vmaster kcontrol in return
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* Create a virtual master control with the given name. The TLV data
|
|
|
|
* must be either NULL or a valid data.
|
|
|
|
*
|
|
|
|
* @slaves is a NULL-terminated array of strings, each of which is a
|
|
|
|
* slave control name. All controls with these names are assigned to
|
|
|
|
* the new virtual master control.
|
|
|
|
*
|
|
|
|
* This function returns zero if successful or a negative error code.
|
|
|
|
*/
|
2012-03-09 09:51:10 -07:00
|
|
|
int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
|
2012-02-03 06:28:01 -07:00
|
|
|
unsigned int *tlv, const char * const *slaves,
|
2012-03-12 05:25:03 -06:00
|
|
|
const char *suffix, bool init_slave_vol,
|
|
|
|
struct snd_kcontrol **ctl_ret)
|
2008-01-10 08:53:55 -07:00
|
|
|
{
|
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
int err;
|
|
|
|
|
2012-03-12 05:25:03 -06:00
|
|
|
if (ctl_ret)
|
|
|
|
*ctl_ret = NULL;
|
|
|
|
|
2012-02-03 06:28:01 -07:00
|
|
|
err = map_slaves(codec, slaves, suffix, check_slave_present, NULL);
|
2011-11-10 04:28:38 -07:00
|
|
|
if (err != 1) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_dbg(codec, "No slave found for %s\n", name);
|
2008-02-22 10:43:50 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-10 08:53:55 -07:00
|
|
|
kctl = snd_ctl_make_virtual_master(name, tlv);
|
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
2009-11-11 05:43:01 -07:00
|
|
|
err = snd_hda_ctl_add(codec, 0, kctl);
|
2008-01-10 08:53:55 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-02-28 12:16:53 -07:00
|
|
|
|
2014-06-30 06:02:39 -06:00
|
|
|
err = map_slaves(codec, slaves, suffix, add_slave, kctl);
|
2011-11-10 04:28:38 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-03-09 09:51:10 -07:00
|
|
|
|
|
|
|
/* init with master mute & zero volume */
|
|
|
|
put_kctl_with_value(kctl, 0);
|
2013-11-04 07:51:00 -07:00
|
|
|
if (init_slave_vol) {
|
|
|
|
int step = 0;
|
2012-03-09 09:51:10 -07:00
|
|
|
map_slaves(codec, slaves, suffix,
|
2013-11-04 07:51:00 -07:00
|
|
|
tlv ? init_slave_0dB : init_slave_unmute, &step);
|
|
|
|
}
|
2012-03-09 09:51:10 -07:00
|
|
|
|
2012-03-12 05:25:03 -06:00
|
|
|
if (ctl_ret)
|
|
|
|
*ctl_ret = kctl;
|
2008-01-10 08:53:55 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(__snd_hda_add_vmaster);
|
2008-01-10 08:53:55 -07:00
|
|
|
|
2012-03-12 09:59:58 -06:00
|
|
|
/*
|
|
|
|
* mute-LED control using vmaster
|
|
|
|
*/
|
|
|
|
static int vmaster_mute_mode_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
static const char * const texts[] = {
|
2013-01-03 06:12:29 -07:00
|
|
|
"On", "Off", "Follow Master"
|
2012-03-12 09:59:58 -06:00
|
|
|
};
|
|
|
|
|
2014-10-20 10:17:28 -06:00
|
|
|
return snd_ctl_enum_info(uinfo, 1, 3, texts);
|
2012-03-12 09:59:58 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int vmaster_mute_mode_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.enumerated.item[0] = hook->mute_mode;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vmaster_mute_mode_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_vmaster_mute_hook *hook = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned int old_mode = hook->mute_mode;
|
|
|
|
|
|
|
|
hook->mute_mode = ucontrol->value.enumerated.item[0];
|
|
|
|
if (hook->mute_mode > HDA_VMUTE_FOLLOW_MASTER)
|
|
|
|
hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
|
|
|
|
if (old_mode == hook->mute_mode)
|
|
|
|
return 0;
|
|
|
|
snd_hda_sync_vmaster_hook(hook);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new vmaster_mute_mode = {
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Mute-LED Mode",
|
|
|
|
.info = vmaster_mute_mode_info,
|
|
|
|
.get = vmaster_mute_mode_get,
|
|
|
|
.put = vmaster_mute_mode_put,
|
|
|
|
};
|
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_add_vmaster_hook - Add a vmaster hook for mute-LED
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @hook: the vmaster hook object
|
|
|
|
* @expose_enum_ctl: flag to create an enum ctl
|
|
|
|
*
|
|
|
|
* Add a mute-LED hook with the given vmaster switch kctl.
|
|
|
|
* When @expose_enum_ctl is set, "Mute-LED Mode" control is automatically
|
|
|
|
* created and associated with the given hook.
|
2012-03-12 09:59:58 -06:00
|
|
|
*/
|
|
|
|
int snd_hda_add_vmaster_hook(struct hda_codec *codec,
|
2012-03-13 00:55:10 -06:00
|
|
|
struct hda_vmaster_mute_hook *hook,
|
|
|
|
bool expose_enum_ctl)
|
2012-03-12 09:59:58 -06:00
|
|
|
{
|
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
|
|
|
|
if (!hook->hook || !hook->sw_kctl)
|
|
|
|
return 0;
|
|
|
|
snd_ctl_add_vmaster_hook(hook->sw_kctl, hook->hook, codec);
|
|
|
|
hook->codec = codec;
|
|
|
|
hook->mute_mode = HDA_VMUTE_FOLLOW_MASTER;
|
2012-03-13 00:55:10 -06:00
|
|
|
if (!expose_enum_ctl)
|
|
|
|
return 0;
|
2012-03-12 09:59:58 -06:00
|
|
|
kctl = snd_ctl_new1(&vmaster_mute_mode, hook);
|
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
|
|
|
return snd_hda_ctl_add(codec, 0, kctl);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_add_vmaster_hook);
|
2012-03-12 09:59:58 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_sync_vmaster_hook - Sync vmaster hook
|
|
|
|
* @hook: the vmaster hook
|
|
|
|
*
|
|
|
|
* Call the hook with the current value for synchronization.
|
|
|
|
* Should be called in init callback.
|
2012-03-12 09:59:58 -06:00
|
|
|
*/
|
|
|
|
void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook)
|
|
|
|
{
|
|
|
|
if (!hook->hook || !hook->codec)
|
|
|
|
return;
|
2013-04-17 10:16:05 -06:00
|
|
|
/* don't call vmaster hook in the destructor since it might have
|
|
|
|
* been already destroyed
|
|
|
|
*/
|
|
|
|
if (hook->codec->bus->shutdown)
|
|
|
|
return;
|
2012-03-12 09:59:58 -06:00
|
|
|
switch (hook->mute_mode) {
|
|
|
|
case HDA_VMUTE_FOLLOW_MASTER:
|
|
|
|
snd_ctl_sync_vmaster_hook(hook->sw_kctl);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
hook->hook(hook->codec, hook->mute_mode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_sync_vmaster_hook);
|
2012-03-12 09:59:58 -06:00
|
|
|
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_switch_info - Info callback for a standard AMP mixer switch
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: referred ctl element
|
|
|
|
* @uinfo: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int chs = get_amp_channels(kcontrol);
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
|
|
|
uinfo->count = chs == 3 ? 2 : 1;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_info);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_switch_get - Get callback for a standard AMP mixer switch
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = get_amp_nid(kcontrol);
|
|
|
|
int chs = get_amp_channels(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
|
|
|
int idx = get_amp_index(kcontrol);
|
|
|
|
long *valp = ucontrol->value.integer.value;
|
|
|
|
|
|
|
|
if (chs & 1)
|
2007-04-16 03:29:14 -06:00
|
|
|
*valp++ = (snd_hda_codec_amp_read(codec, nid, 0, dir, idx) &
|
2007-08-10 09:11:07 -06:00
|
|
|
HDA_AMP_MUTE) ? 0 : 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (chs & 2)
|
2007-04-16 03:29:14 -06:00
|
|
|
*valp = (snd_hda_codec_amp_read(codec, nid, 1, dir, idx) &
|
2007-08-10 09:11:07 -06:00
|
|
|
HDA_AMP_MUTE) ? 0 : 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_amp_switch_put - Put callback for a standard AMP mixer switch
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_COMPOSE_AMP_VAL*() or related macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = get_amp_nid(kcontrol);
|
|
|
|
int chs = get_amp_channels(kcontrol);
|
|
|
|
int dir = get_amp_direction(kcontrol);
|
|
|
|
int idx = get_amp_index(kcontrol);
|
|
|
|
long *valp = ucontrol->value.integer.value;
|
|
|
|
int change = 0;
|
|
|
|
|
2005-07-29 04:17:20 -06:00
|
|
|
if (chs & 1) {
|
2015-02-25 07:18:50 -07:00
|
|
|
change = snd_hda_codec_amp_update(codec, nid, 0, dir, idx,
|
|
|
|
HDA_AMP_MUTE,
|
|
|
|
*valp ? 0 : HDA_AMP_MUTE);
|
2005-07-29 04:17:20 -06:00
|
|
|
valp++;
|
|
|
|
}
|
2005-06-08 06:43:58 -06:00
|
|
|
if (chs & 2)
|
2015-02-25 07:18:50 -07:00
|
|
|
change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx,
|
|
|
|
HDA_AMP_MUTE,
|
|
|
|
*valp ? 0 : HDA_AMP_MUTE);
|
2010-09-21 01:57:06 -06:00
|
|
|
hda_call_check_power_status(codec, nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
return change;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-02 10:26:49 -07:00
|
|
|
/*
|
|
|
|
* bound volume controls
|
|
|
|
*
|
|
|
|
* bind multiple volumes (# indices, from 0)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define AMP_VAL_IDX_SHIFT 19
|
|
|
|
#define AMP_VAL_IDX_MASK (0x0f<<19)
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_switch_get - Get callback for a bound volume control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_MUTE*() macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_bind_switch_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-11-02 10:26:49 -07:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned long pval;
|
|
|
|
int err;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2005-11-02 10:26:49 -07:00
|
|
|
pval = kcontrol->private_value;
|
|
|
|
kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
|
|
|
|
err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
|
|
|
|
kcontrol->private_value = pval;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2005-11-02 10:26:49 -07:00
|
|
|
return err;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_get);
|
2005-11-02 10:26:49 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_switch_put - Put callback for a bound volume control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_MUTE*() macros.
|
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_mixer_bind_switch_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-11-02 10:26:49 -07:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
unsigned long pval;
|
|
|
|
int i, indices, err = 0, change = 0;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2005-11-02 10:26:49 -07:00
|
|
|
pval = kcontrol->private_value;
|
|
|
|
indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
|
|
|
|
for (i = 0; i < indices; i++) {
|
2007-04-16 03:29:14 -06:00
|
|
|
kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |
|
|
|
|
(i << AMP_VAL_IDX_SHIFT);
|
2005-11-02 10:26:49 -07:00
|
|
|
err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
|
|
|
|
if (err < 0)
|
|
|
|
break;
|
|
|
|
change |= err;
|
|
|
|
}
|
|
|
|
kcontrol->private_value = pval;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2005-11-02 10:26:49 -07:00
|
|
|
return err < 0 ? err : change;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_switch_put);
|
2005-11-02 10:26:49 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_ctls_info - Info callback for a generic bound control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: referred ctl element
|
|
|
|
* @uinfo: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
|
2007-07-27 11:02:40 -06:00
|
|
|
*/
|
|
|
|
int snd_hda_mixer_bind_ctls_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_bind_ctls *c;
|
|
|
|
int err;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2008-02-22 10:43:16 -07:00
|
|
|
c = (struct hda_bind_ctls *)kcontrol->private_value;
|
2007-07-27 11:02:40 -06:00
|
|
|
kcontrol->private_value = *c->values;
|
|
|
|
err = c->ops->info(kcontrol, uinfo);
|
|
|
|
kcontrol->private_value = (long)c;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2007-07-27 11:02:40 -06:00
|
|
|
return err;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_info);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_ctls_get - Get callback for a generic bound control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
|
|
|
|
*/
|
2007-07-27 11:02:40 -06:00
|
|
|
int snd_hda_mixer_bind_ctls_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_bind_ctls *c;
|
|
|
|
int err;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2008-02-22 10:43:16 -07:00
|
|
|
c = (struct hda_bind_ctls *)kcontrol->private_value;
|
2007-07-27 11:02:40 -06:00
|
|
|
kcontrol->private_value = *c->values;
|
|
|
|
err = c->ops->get(kcontrol, ucontrol);
|
|
|
|
kcontrol->private_value = (long)c;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2007-07-27 11:02:40 -06:00
|
|
|
return err;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_get);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_ctls_put - Put callback for a generic bound control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @ucontrol: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_VOL() or HDA_BIND_SW() macros.
|
|
|
|
*/
|
2007-07-27 11:02:40 -06:00
|
|
|
int snd_hda_mixer_bind_ctls_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_bind_ctls *c;
|
|
|
|
unsigned long *vals;
|
|
|
|
int err = 0, change = 0;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2008-02-22 10:43:16 -07:00
|
|
|
c = (struct hda_bind_ctls *)kcontrol->private_value;
|
2007-07-27 11:02:40 -06:00
|
|
|
for (vals = c->values; *vals; vals++) {
|
|
|
|
kcontrol->private_value = *vals;
|
|
|
|
err = c->ops->put(kcontrol, ucontrol);
|
|
|
|
if (err < 0)
|
|
|
|
break;
|
|
|
|
change |= err;
|
|
|
|
}
|
|
|
|
kcontrol->private_value = (long)c;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2007-07-27 11:02:40 -06:00
|
|
|
return err < 0 ? err : change;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_ctls_put);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_mixer_bind_tlv - TLV callback for a generic bound control
|
2014-10-29 08:06:01 -06:00
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @op_flag: operation flag
|
|
|
|
* @size: byte size of input TLV
|
|
|
|
* @tlv: TLV data
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* The control element is supposed to have the private_value field
|
|
|
|
* set up via HDA_BIND_VOL() macro.
|
|
|
|
*/
|
2007-07-27 11:02:40 -06:00
|
|
|
int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
|
|
|
unsigned int size, unsigned int __user *tlv)
|
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
struct hda_bind_ctls *c;
|
|
|
|
int err;
|
|
|
|
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_lock(&codec->control_mutex);
|
2008-02-22 10:43:16 -07:00
|
|
|
c = (struct hda_bind_ctls *)kcontrol->private_value;
|
2007-07-27 11:02:40 -06:00
|
|
|
kcontrol->private_value = *c->values;
|
|
|
|
err = c->ops->tlv(kcontrol, op_flag, size, tlv);
|
|
|
|
kcontrol->private_value = (long)c;
|
2009-01-09 01:45:24 -07:00
|
|
|
mutex_unlock(&codec->control_mutex);
|
2007-07-27 11:02:40 -06:00
|
|
|
return err;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_mixer_bind_tlv);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
|
|
|
struct hda_ctl_ops snd_hda_bind_vol = {
|
|
|
|
.info = snd_hda_mixer_amp_volume_info,
|
|
|
|
.get = snd_hda_mixer_amp_volume_get,
|
|
|
|
.put = snd_hda_mixer_amp_volume_put,
|
|
|
|
.tlv = snd_hda_mixer_amp_tlv
|
|
|
|
};
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_bind_vol);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
|
|
|
struct hda_ctl_ops snd_hda_bind_sw = {
|
|
|
|
.info = snd_hda_mixer_amp_switch_info,
|
|
|
|
.get = snd_hda_mixer_amp_switch_get,
|
|
|
|
.put = snd_hda_mixer_amp_switch_put,
|
|
|
|
.tlv = snd_hda_mixer_amp_tlv
|
|
|
|
};
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_bind_sw);
|
2007-07-27 11:02:40 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* SPDIF out controls
|
|
|
|
*/
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_mask_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
|
|
|
|
uinfo->count = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_cmask_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
|
|
|
|
IEC958_AES0_NONAUDIO |
|
|
|
|
IEC958_AES0_CON_EMPHASIS_5015 |
|
|
|
|
IEC958_AES0_CON_NOT_COPYRIGHT;
|
|
|
|
ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
|
|
|
|
IEC958_AES1_CON_ORIGINAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_pmask_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
|
|
|
|
IEC958_AES0_NONAUDIO |
|
|
|
|
IEC958_AES0_PRO_EMPHASIS_5015;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
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 11:14:17 -06:00
|
|
|
int idx = kcontrol->private_value;
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-10 02:21:29 -06:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
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 11:14:17 -06:00
|
|
|
ucontrol->value.iec958.status[0] = spdif->status & 0xff;
|
|
|
|
ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
|
|
|
|
ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
|
|
|
|
ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
|
2012-05-10 02:21:29 -06:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* convert from SPDIF status bits to HDA SPDIF bits
|
|
|
|
* bit 0 (DigEn) is always set zero (to be filled later)
|
|
|
|
*/
|
|
|
|
static unsigned short convert_from_spdif_status(unsigned int sbits)
|
|
|
|
{
|
|
|
|
unsigned short val = 0;
|
|
|
|
|
|
|
|
if (sbits & IEC958_AES0_PROFESSIONAL)
|
2007-04-16 03:29:14 -06:00
|
|
|
val |= AC_DIG1_PROFESSIONAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sbits & IEC958_AES0_NONAUDIO)
|
2007-04-16 03:29:14 -06:00
|
|
|
val |= AC_DIG1_NONAUDIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sbits & IEC958_AES0_PROFESSIONAL) {
|
2007-04-16 03:29:14 -06:00
|
|
|
if ((sbits & IEC958_AES0_PRO_EMPHASIS) ==
|
|
|
|
IEC958_AES0_PRO_EMPHASIS_5015)
|
|
|
|
val |= AC_DIG1_EMPHASIS;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-04-16 03:29:14 -06:00
|
|
|
if ((sbits & IEC958_AES0_CON_EMPHASIS) ==
|
|
|
|
IEC958_AES0_CON_EMPHASIS_5015)
|
|
|
|
val |= AC_DIG1_EMPHASIS;
|
|
|
|
if (!(sbits & IEC958_AES0_CON_NOT_COPYRIGHT))
|
|
|
|
val |= AC_DIG1_COPYRIGHT;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sbits & (IEC958_AES1_CON_ORIGINAL << 8))
|
2007-04-16 03:29:14 -06:00
|
|
|
val |= AC_DIG1_LEVEL;
|
2005-04-16 16:20:36 -06:00
|
|
|
val |= sbits & (IEC958_AES1_CON_CATEGORY << 8);
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* convert to SPDIF status bits from HDA SPDIF bits
|
|
|
|
*/
|
|
|
|
static unsigned int convert_to_spdif_status(unsigned short val)
|
|
|
|
{
|
|
|
|
unsigned int sbits = 0;
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
if (val & AC_DIG1_NONAUDIO)
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= IEC958_AES0_NONAUDIO;
|
2007-04-16 03:29:14 -06:00
|
|
|
if (val & AC_DIG1_PROFESSIONAL)
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= IEC958_AES0_PROFESSIONAL;
|
|
|
|
if (sbits & IEC958_AES0_PROFESSIONAL) {
|
2013-03-20 08:42:00 -06:00
|
|
|
if (val & AC_DIG1_EMPHASIS)
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= IEC958_AES0_PRO_EMPHASIS_5015;
|
|
|
|
} else {
|
2007-04-16 03:29:14 -06:00
|
|
|
if (val & AC_DIG1_EMPHASIS)
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= IEC958_AES0_CON_EMPHASIS_5015;
|
2007-04-16 03:29:14 -06:00
|
|
|
if (!(val & AC_DIG1_COPYRIGHT))
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= IEC958_AES0_CON_NOT_COPYRIGHT;
|
2007-04-16 03:29:14 -06:00
|
|
|
if (val & AC_DIG1_LEVEL)
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits |= (IEC958_AES1_CON_ORIGINAL << 8);
|
|
|
|
sbits |= val & (0x7f << 8);
|
|
|
|
}
|
|
|
|
return sbits;
|
|
|
|
}
|
|
|
|
|
2008-09-25 08:32:41 -06:00
|
|
|
/* set digital convert verbs both for the given NID and its slaves */
|
|
|
|
static void set_dig_out(struct hda_codec *codec, hda_nid_t nid,
|
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 04:34:49 -07:00
|
|
|
int mask, int val)
|
2008-09-25 08:32:41 -06:00
|
|
|
{
|
2011-05-02 03:29:30 -06:00
|
|
|
const hda_nid_t *d;
|
2008-09-25 08:32:41 -06:00
|
|
|
|
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 04:34:49 -07:00
|
|
|
snd_hdac_regmap_update(&codec->core, nid, AC_VERB_SET_DIGI_CONVERT_1,
|
|
|
|
mask, val);
|
2008-09-25 08:32:41 -06:00
|
|
|
d = codec->slave_dig_outs;
|
|
|
|
if (!d)
|
|
|
|
return;
|
|
|
|
for (; *d; d++)
|
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 04:34:49 -07:00
|
|
|
snd_hdac_regmap_update(&codec->core, nid,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1, mask, val);
|
2008-09-25 08:32:41 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_dig_out_convert(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int dig1, int dig2)
|
|
|
|
{
|
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 04:34:49 -07:00
|
|
|
unsigned int mask = 0;
|
|
|
|
unsigned int val = 0;
|
|
|
|
|
|
|
|
if (dig1 != -1) {
|
|
|
|
mask |= 0xff;
|
|
|
|
val = dig1;
|
|
|
|
}
|
|
|
|
if (dig2 != -1) {
|
|
|
|
mask |= 0xff00;
|
|
|
|
val |= dig2 << 8;
|
|
|
|
}
|
|
|
|
set_dig_out(codec, nid, mask, val);
|
2008-09-25 08:32:41 -06:00
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
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 11:14:17 -06:00
|
|
|
int idx = kcontrol->private_value;
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
|
|
|
hda_nid_t nid;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned short val;
|
|
|
|
int change;
|
|
|
|
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2012-05-10 02:21:29 -06:00
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
|
|
|
nid = spdif->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 11:14:17 -06:00
|
|
|
spdif->status = ucontrol->value.iec958.status[0] |
|
2005-04-16 16:20:36 -06:00
|
|
|
((unsigned int)ucontrol->value.iec958.status[1] << 8) |
|
|
|
|
((unsigned int)ucontrol->value.iec958.status[2] << 16) |
|
|
|
|
((unsigned int)ucontrol->value.iec958.status[3] << 24);
|
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 11:14:17 -06:00
|
|
|
val = convert_from_spdif_status(spdif->status);
|
|
|
|
val |= spdif->ctls & 1;
|
|
|
|
change = spdif->ctls != val;
|
|
|
|
spdif->ctls = val;
|
2011-06-01 11:14:18 -06:00
|
|
|
if (change && nid != (u16)-1)
|
2008-09-25 08:32:41 -06:00
|
|
|
set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return change;
|
|
|
|
}
|
|
|
|
|
2007-07-23 07:42:26 -06:00
|
|
|
#define snd_hda_spdif_out_switch_info snd_ctl_boolean_mono_info
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
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 11:14:17 -06:00
|
|
|
int idx = kcontrol->private_value;
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-10 02:21:29 -06:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
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 11:14:17 -06:00
|
|
|
ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
|
2012-05-10 02:21:29 -06:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-01 11:14:18 -06:00
|
|
|
static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
int dig1, int dig2)
|
|
|
|
{
|
|
|
|
set_dig_out_convert(codec, nid, dig1, dig2);
|
|
|
|
/* unmute amp switch (if any) */
|
|
|
|
if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
|
|
|
|
(dig1 & AC_DIG1_ENABLE))
|
|
|
|
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
|
|
|
HDA_AMP_MUTE, 0);
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
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 11:14:17 -06:00
|
|
|
int idx = kcontrol->private_value;
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
|
|
|
hda_nid_t nid;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned short val;
|
|
|
|
int change;
|
|
|
|
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2012-05-10 02:21:29 -06:00
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
|
|
|
nid = spdif->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 11:14:17 -06:00
|
|
|
val = spdif->ctls & ~AC_DIG1_ENABLE;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ucontrol->value.integer.value[0])
|
2007-04-16 03:29:14 -06:00
|
|
|
val |= AC_DIG1_ENABLE;
|
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 11:14:17 -06:00
|
|
|
change = spdif->ctls != val;
|
2011-06-01 11:14:18 -06:00
|
|
|
spdif->ctls = val;
|
|
|
|
if (change && nid != (u16)-1)
|
|
|
|
set_spdif_ctls(codec, nid, val & 0xff, -1);
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return change;
|
|
|
|
}
|
|
|
|
|
2005-11-17 06:57:47 -07:00
|
|
|
static struct snd_kcontrol_new dig_mixes[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_mask_info,
|
|
|
|
.get = snd_hda_spdif_cmask_get,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PRO_MASK),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_mask_info,
|
|
|
|
.get = snd_hda_spdif_pmask_get,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_mask_info,
|
|
|
|
.get = snd_hda_spdif_default_get,
|
|
|
|
.put = snd_hda_spdif_default_put,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_out_switch_info,
|
|
|
|
.get = snd_hda_spdif_out_switch_get,
|
|
|
|
.put = snd_hda_spdif_out_switch_put,
|
|
|
|
},
|
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2012-10-12 09:24:51 -06:00
|
|
|
* snd_hda_create_dig_out_ctls - create Output SPDIF-related controls
|
2005-04-16 16:20:36 -06:00
|
|
|
* @codec: the HDA codec
|
2012-10-12 09:24:51 -06:00
|
|
|
* @associated_nid: NID that new ctls associated with
|
|
|
|
* @cvt_nid: converter NID
|
|
|
|
* @type: HDA_PCM_TYPE_*
|
|
|
|
* Creates controls related with the digital output.
|
|
|
|
* Called from each patch supporting the digital out.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
2012-10-12 09:24:51 -06:00
|
|
|
int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
|
|
|
|
hda_nid_t associated_nid,
|
|
|
|
hda_nid_t cvt_nid,
|
|
|
|
int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
struct snd_kcontrol_new *dig_mix;
|
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 09:02:41 -07:00
|
|
|
int idx = 0;
|
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 04:34:49 -07:00
|
|
|
int val = 0;
|
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 09:02:41 -07:00
|
|
|
const int spdif_index = 16;
|
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 11:14:17 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
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 09:02:41 -07:00
|
|
|
struct hda_bus *bus = codec->bus;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
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 09:02:41 -07:00
|
|
|
if (bus->primary_dig_out_type == HDA_PCM_TYPE_HDMI &&
|
2012-10-12 09:24:51 -06:00
|
|
|
type == HDA_PCM_TYPE_SPDIF) {
|
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 09:02:41 -07:00
|
|
|
idx = spdif_index;
|
|
|
|
} else if (bus->primary_dig_out_type == HDA_PCM_TYPE_SPDIF &&
|
2012-10-12 09:24:51 -06:00
|
|
|
type == HDA_PCM_TYPE_HDMI) {
|
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 09:02:41 -07:00
|
|
|
/* suppose a single SPDIF device */
|
|
|
|
for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
|
|
|
|
kctl = find_mixer_ctl(codec, dig_mix->name, 0, 0);
|
|
|
|
if (!kctl)
|
|
|
|
break;
|
|
|
|
kctl->id.index = spdif_index;
|
2012-10-12 09:24:51 -06:00
|
|
|
}
|
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 09:02:41 -07:00
|
|
|
bus->primary_dig_out_type = HDA_PCM_TYPE_HDMI;
|
2012-10-12 09:24:51 -06:00
|
|
|
}
|
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 09:02:41 -07:00
|
|
|
if (!bus->primary_dig_out_type)
|
|
|
|
bus->primary_dig_out_type = type;
|
2012-10-12 09:24:51 -06:00
|
|
|
|
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 09:02:41 -07:00
|
|
|
idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch", idx);
|
2010-12-23 02:17:52 -07:00
|
|
|
if (idx < 0) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_err(codec, "too many IEC958 outputs\n");
|
2008-02-04 04:31:13 -07:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
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 11:14:17 -06:00
|
|
|
spdif = snd_array_new(&codec->spdif_out);
|
2013-03-07 12:10:25 -07:00
|
|
|
if (!spdif)
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
|
|
|
|
kctl = snd_ctl_new1(dig_mix, codec);
|
2008-11-04 00:43:08 -07:00
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
2008-02-04 04:31:13 -07:00
|
|
|
kctl->id.index = idx;
|
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 11:14:17 -06:00
|
|
|
kctl->private_value = codec->spdif_out.used - 1;
|
2011-06-01 11:14:18 -06:00
|
|
|
err = snd_hda_ctl_add(codec, associated_nid, kctl);
|
2007-04-16 03:29:14 -06:00
|
|
|
if (err < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
2011-06-01 11:14:18 -06:00
|
|
|
spdif->nid = cvt_nid;
|
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 04:34:49 -07:00
|
|
|
snd_hdac_regmap_read(&codec->core, cvt_nid,
|
|
|
|
AC_VERB_GET_DIGI_CONVERT_1, &val);
|
|
|
|
spdif->ctls = val;
|
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 11:14:17 -06:00
|
|
|
spdif->status = convert_to_spdif_status(spdif->ctls);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_create_dig_out_ctls);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_spdif_out_of_nid - get the hda_spdif_out entry from the given NID
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: widget NID
|
|
|
|
*
|
2012-05-10 02:21:29 -06:00
|
|
|
* call within spdif_mutex lock
|
|
|
|
*/
|
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 11:14:17 -06:00
|
|
|
struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < codec->spdif_out.used; i++) {
|
|
|
|
struct hda_spdif_out *spdif =
|
|
|
|
snd_array_elem(&codec->spdif_out, i);
|
|
|
|
if (spdif->nid == nid)
|
|
|
|
return spdif;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_spdif_out_of_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 11:14:17 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_spdif_ctls_unassign - Unassign the given SPDIF ctl
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @idx: the SPDIF ctl index
|
|
|
|
*
|
|
|
|
* Unassign the widget from the given SPDIF control.
|
|
|
|
*/
|
2011-06-01 11:14:18 -06:00
|
|
|
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
|
|
|
|
{
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
2011-06-01 11:14:18 -06:00
|
|
|
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2012-05-10 02:21:29 -06:00
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
2011-06-01 11:14:18 -06:00
|
|
|
spdif->nid = (u16)-1;
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_unassign);
|
2011-06-01 11:14:18 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_spdif_ctls_assign - Assign the SPDIF controls to the given NID
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @idx: the SPDIF ctl idx
|
|
|
|
* @nid: widget NID
|
|
|
|
*
|
|
|
|
* Assign the widget to the SPDIF control with the given index.
|
|
|
|
*/
|
2011-06-01 11:14:18 -06:00
|
|
|
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
|
|
|
|
{
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
2011-06-01 11:14:18 -06:00
|
|
|
unsigned short val;
|
|
|
|
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2012-05-10 02:21:29 -06:00
|
|
|
spdif = snd_array_elem(&codec->spdif_out, idx);
|
2011-06-01 11:14:18 -06:00
|
|
|
if (spdif->nid != nid) {
|
|
|
|
spdif->nid = nid;
|
|
|
|
val = spdif->ctls;
|
|
|
|
set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
|
|
|
}
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_spdif_ctls_assign);
|
2011-06-01 11:14:18 -06:00
|
|
|
|
2008-02-12 10:37:26 -07:00
|
|
|
/*
|
|
|
|
* SPDIF sharing with analog output
|
|
|
|
*/
|
|
|
|
static int spdif_share_sw_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.integer.value[0] = mout->share_spdif;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spdif_share_sw_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
|
|
{
|
|
|
|
struct hda_multi_out *mout = snd_kcontrol_chip(kcontrol);
|
|
|
|
mout->share_spdif = !!ucontrol->value.integer.value[0];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new spdif_share_sw = {
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "IEC958 Default PCM Playback Switch",
|
|
|
|
.info = snd_ctl_boolean_mono_info,
|
|
|
|
.get = spdif_share_sw_get,
|
|
|
|
.put = spdif_share_sw_put,
|
|
|
|
};
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_create_spdif_share_sw - create Default PCM switch
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: multi-out instance
|
|
|
|
*/
|
2008-02-12 10:37:26 -07:00
|
|
|
int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout)
|
|
|
|
{
|
2013-03-07 12:11:05 -07:00
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
|
2008-02-12 10:37:26 -07:00
|
|
|
if (!mout->dig_out_nid)
|
|
|
|
return 0;
|
2013-03-07 12:11:05 -07:00
|
|
|
|
|
|
|
kctl = snd_ctl_new1(&spdif_share_sw, mout);
|
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
2008-02-12 10:37:26 -07:00
|
|
|
/* ATTENTION: here mout is passed as private_data, instead of codec */
|
2013-03-07 12:11:05 -07:00
|
|
|
return snd_hda_ctl_add(codec, mout->dig_out_nid, kctl);
|
2008-02-12 10:37:26 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_share_sw);
|
2008-02-12 10:37:26 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* SPDIF input
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define snd_hda_spdif_in_switch_info snd_hda_spdif_out_switch_info
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_in_switch_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] = codec->spdif_in_enable;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_in_switch_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = kcontrol->private_value;
|
|
|
|
unsigned int val = !!ucontrol->value.integer.value[0];
|
|
|
|
int change;
|
|
|
|
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
change = codec->spdif_in_enable != val;
|
2007-08-10 09:09:26 -06:00
|
|
|
if (change) {
|
2005-04-16 16:20:36 -06:00
|
|
|
codec->spdif_in_enable = val;
|
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 04:34:49 -07:00
|
|
|
snd_hdac_regmap_write(&codec->core, nid,
|
|
|
|
AC_VERB_SET_DIGI_CONVERT_1, val);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return change;
|
|
|
|
}
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
static int snd_hda_spdif_in_status_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *ucontrol)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
|
|
hda_nid_t nid = kcontrol->private_value;
|
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 04:34:49 -07:00
|
|
|
unsigned int val;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int sbits;
|
|
|
|
|
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 04:34:49 -07:00
|
|
|
snd_hdac_regmap_read(&codec->core, nid,
|
|
|
|
AC_VERB_GET_DIGI_CONVERT_1, &val);
|
2005-04-16 16:20:36 -06:00
|
|
|
sbits = convert_to_spdif_status(val);
|
|
|
|
ucontrol->value.iec958.status[0] = sbits;
|
|
|
|
ucontrol->value.iec958.status[1] = sbits >> 8;
|
|
|
|
ucontrol->value.iec958.status[2] = sbits >> 16;
|
|
|
|
ucontrol->value.iec958.status[3] = sbits >> 24;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 06:57:47 -07:00
|
|
|
static struct snd_kcontrol_new dig_in_ctls[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, SWITCH),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_in_switch_info,
|
|
|
|
.get = snd_hda_spdif_in_switch_get,
|
|
|
|
.put = snd_hda_spdif_in_switch_put,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
2010-02-28 12:16:53 -07:00
|
|
|
.name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = snd_hda_spdif_mask_info,
|
|
|
|
.get = snd_hda_spdif_in_status_get,
|
|
|
|
},
|
|
|
|
{ } /* end */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_create_spdif_in_ctls - create Input SPDIF-related controls
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: audio in widget NID
|
|
|
|
*
|
|
|
|
* Creates controls related with the SPDIF input.
|
|
|
|
* Called from each patch supporting the SPDIF in.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
2007-08-02 07:51:59 -06:00
|
|
|
int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_kcontrol *kctl;
|
|
|
|
struct snd_kcontrol_new *dig_mix;
|
2008-02-04 04:31:13 -07:00
|
|
|
int idx;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-10-12 09:24:51 -06:00
|
|
|
idx = find_empty_mixer_ctl_idx(codec, "IEC958 Capture Switch", 0);
|
2010-12-23 02:17:52 -07:00
|
|
|
if (idx < 0) {
|
2014-02-25 04:21:03 -07:00
|
|
|
codec_err(codec, "too many IEC958 inputs\n");
|
2008-02-04 04:31:13 -07:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
for (dig_mix = dig_in_ctls; dig_mix->name; dig_mix++) {
|
|
|
|
kctl = snd_ctl_new1(dig_mix, codec);
|
2009-02-06 08:21:20 -07:00
|
|
|
if (!kctl)
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
kctl->private_value = nid;
|
2009-11-11 05:43:01 -07:00
|
|
|
err = snd_hda_ctl_add(codec, nid, kctl);
|
2007-04-16 03:29:14 -06:00
|
|
|
if (err < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
2007-04-16 03:29:14 -06:00
|
|
|
codec->spdif_in_enable =
|
2007-12-19 04:13:44 -07:00
|
|
|
snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_DIGI_CONVERT_1, 0) &
|
2007-04-16 03:29:14 -06:00
|
|
|
AC_DIG1_ENABLE;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_create_spdif_in_ctls);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_set_power_to_all - Set the power state to all widgets
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @fg: function group (not used now)
|
|
|
|
* @power_state: the power state to set (AC_PWRST_*)
|
|
|
|
*
|
|
|
|
* Set the given power state to all widgets that have the power control.
|
|
|
|
* If the codec has power_filter set, it evaluates the power state and
|
|
|
|
* filter out if it's unchanged as D3.
|
|
|
|
*/
|
2011-07-26 02:33:10 -06:00
|
|
|
void snd_hda_codec_set_power_to_all(struct hda_codec *codec, hda_nid_t fg,
|
2013-01-24 09:23:35 -07:00
|
|
|
unsigned int power_state)
|
2005-11-21 08:33:22 -07:00
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
hda_nid_t nid;
|
2005-11-21 08:33:22 -07:00
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
for_each_hda_codec_node(nid, codec) {
|
2007-11-14 06:53:42 -07:00
|
|
|
unsigned int wcaps = get_wcaps(codec, nid);
|
2013-01-24 09:23:35 -07:00
|
|
|
unsigned int state = power_state;
|
2011-07-26 02:33:10 -06:00
|
|
|
if (!(wcaps & AC_WCAP_POWER))
|
|
|
|
continue;
|
2013-01-24 09:23:35 -07:00
|
|
|
if (codec->power_filter) {
|
|
|
|
state = codec->power_filter(codec, nid, power_state);
|
|
|
|
if (state != power_state && power_state == AC_PWRST_D3)
|
2011-07-26 02:33:10 -06:00
|
|
|
continue;
|
2007-10-10 02:04:26 -06:00
|
|
|
}
|
2011-07-26 02:33:10 -06:00
|
|
|
snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE,
|
2013-01-24 09:23:35 -07:00
|
|
|
state);
|
2005-11-21 08:33:22 -07:00
|
|
|
}
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_set_power_to_all);
|
2011-07-26 02:33:10 -06:00
|
|
|
|
2012-08-28 10:59:20 -06:00
|
|
|
/*
|
|
|
|
* wait until the state is reached, returns the current state
|
|
|
|
*/
|
|
|
|
static unsigned int hda_sync_power_state(struct hda_codec *codec,
|
|
|
|
hda_nid_t fg,
|
|
|
|
unsigned int power_state)
|
|
|
|
{
|
|
|
|
unsigned long end_time = jiffies + msecs_to_jiffies(500);
|
|
|
|
unsigned int state, actual_state;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
state = snd_hda_codec_read(codec, fg, 0,
|
|
|
|
AC_VERB_GET_POWER_STATE, 0);
|
|
|
|
if (state & AC_PWRST_ERROR)
|
|
|
|
break;
|
|
|
|
actual_state = (state >> 4) & 0x0f;
|
|
|
|
if (actual_state == power_state)
|
|
|
|
break;
|
|
|
|
if (time_after_eq(jiffies, end_time))
|
|
|
|
break;
|
|
|
|
/* wait until the codec reachs to the target state */
|
|
|
|
msleep(1);
|
|
|
|
}
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_eapd_power_filter - A power filter callback for EAPD
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @nid: widget NID
|
|
|
|
* @power_state: power state to evalue
|
|
|
|
*
|
|
|
|
* Don't power down the widget if it controls eapd and EAPD_BTLENABLE is set.
|
|
|
|
* This can be used a codec power_filter callback.
|
|
|
|
*/
|
2013-03-13 07:47:21 -06:00
|
|
|
unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
|
|
|
|
hda_nid_t nid,
|
|
|
|
unsigned int power_state)
|
2013-01-24 09:23:35 -07:00
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
if (nid == codec->core.afg || nid == codec->core.mfg)
|
2014-01-13 08:09:57 -07:00
|
|
|
return power_state;
|
2013-01-24 09:23:35 -07:00
|
|
|
if (power_state == AC_PWRST_D3 &&
|
|
|
|
get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_PIN &&
|
|
|
|
(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) {
|
|
|
|
int eapd = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_EAPD_BTLENABLE, 0);
|
|
|
|
if (eapd & 0x02)
|
|
|
|
return AC_PWRST_D0;
|
|
|
|
}
|
|
|
|
return power_state;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_eapd_power_filter);
|
2013-01-24 09:23:35 -07:00
|
|
|
|
2011-07-26 02:33:10 -06:00
|
|
|
/*
|
2012-08-31 08:46:56 -06:00
|
|
|
* set power state of the codec, and return the power state
|
2011-07-26 02:33:10 -06:00
|
|
|
*/
|
2012-08-31 08:54:38 -06:00
|
|
|
static unsigned int hda_set_power_state(struct hda_codec *codec,
|
2012-08-31 08:46:56 -06:00
|
|
|
unsigned int power_state)
|
2011-07-26 02:33:10 -06:00
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
hda_nid_t fg = codec->core.afg ? codec->core.afg : codec->core.mfg;
|
2012-06-07 20:26:08 -06:00
|
|
|
int count;
|
|
|
|
unsigned int state;
|
2013-06-06 06:20:19 -06:00
|
|
|
int flags = 0;
|
2012-06-07 20:26:08 -06:00
|
|
|
|
2011-07-26 02:33:10 -06:00
|
|
|
/* this delay seems necessary to avoid click noise at power-down */
|
2012-06-07 02:51:33 -06:00
|
|
|
if (power_state == AC_PWRST_D3) {
|
2013-11-28 23:48:45 -07:00
|
|
|
if (codec->depop_delay < 0)
|
2015-03-03 02:07:24 -07:00
|
|
|
msleep(codec_has_epss(codec) ? 10 : 100);
|
2013-11-28 23:48:45 -07:00
|
|
|
else if (codec->depop_delay > 0)
|
|
|
|
msleep(codec->depop_delay);
|
2013-06-06 06:20:19 -06:00
|
|
|
flags = HDA_RW_NO_RESPONSE_FALLBACK;
|
2012-06-07 02:51:33 -06:00
|
|
|
}
|
2012-06-07 20:26:08 -06:00
|
|
|
|
|
|
|
/* repeat power states setting at most 10 times*/
|
|
|
|
for (count = 0; count < 10; count++) {
|
2012-08-28 10:59:20 -06:00
|
|
|
if (codec->patch_ops.set_power_state)
|
|
|
|
codec->patch_ops.set_power_state(codec, fg,
|
|
|
|
power_state);
|
|
|
|
else {
|
2014-01-13 08:09:57 -07:00
|
|
|
state = power_state;
|
|
|
|
if (codec->power_filter)
|
|
|
|
state = codec->power_filter(codec, fg, state);
|
|
|
|
if (state == power_state || power_state != AC_PWRST_D3)
|
|
|
|
snd_hda_codec_read(codec, fg, flags,
|
|
|
|
AC_VERB_SET_POWER_STATE,
|
|
|
|
state);
|
2013-01-24 09:23:35 -07:00
|
|
|
snd_hda_codec_set_power_to_all(codec, fg, power_state);
|
2012-08-28 10:59:20 -06:00
|
|
|
}
|
|
|
|
state = hda_sync_power_state(codec, fg, power_state);
|
2012-06-07 20:26:08 -06:00
|
|
|
if (!(state & AC_PWRST_ERROR))
|
|
|
|
break;
|
|
|
|
}
|
2012-08-23 03:32:30 -06:00
|
|
|
|
2012-08-31 08:46:56 -06:00
|
|
|
return state;
|
2011-07-26 02:33:10 -06:00
|
|
|
}
|
2007-08-10 09:21:45 -06:00
|
|
|
|
2013-01-24 09:27:32 -07:00
|
|
|
/* sync power states of all widgets;
|
|
|
|
* this is called at the end of codec parsing
|
|
|
|
*/
|
|
|
|
static void sync_power_up_states(struct hda_codec *codec)
|
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
hda_nid_t nid;
|
2013-01-24 09:27:32 -07:00
|
|
|
|
2013-03-13 07:47:21 -06:00
|
|
|
/* don't care if no filter is used */
|
|
|
|
if (!codec->power_filter)
|
2013-01-24 09:27:32 -07:00
|
|
|
return;
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
for_each_hda_codec_node(nid, codec) {
|
2013-01-24 09:27:32 -07:00
|
|
|
unsigned int wcaps = get_wcaps(codec, nid);
|
2013-01-24 09:47:17 -07:00
|
|
|
unsigned int target;
|
2013-01-24 09:27:32 -07:00
|
|
|
if (!(wcaps & AC_WCAP_POWER))
|
|
|
|
continue;
|
|
|
|
target = codec->power_filter(codec, nid, AC_PWRST_D0);
|
|
|
|
if (target == AC_PWRST_D0)
|
|
|
|
continue;
|
2013-01-24 09:47:17 -07:00
|
|
|
if (!snd_hda_check_power_state(codec, nid, target))
|
2013-01-24 09:27:32 -07:00
|
|
|
snd_hda_codec_write(codec, nid, 0,
|
|
|
|
AC_VERB_SET_POWER_STATE, target);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-25 02:38:13 -07:00
|
|
|
#ifdef CONFIG_SND_HDA_RECONFIG
|
2008-07-30 07:01:46 -06:00
|
|
|
/* execute additional init verbs */
|
|
|
|
static void hda_exec_init_verbs(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
if (codec->init_verbs.list)
|
|
|
|
snd_hda_sequence_write(codec, codec->init_verbs.list);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void hda_exec_init_verbs(struct hda_codec *codec) {}
|
|
|
|
#endif
|
|
|
|
|
2011-07-26 01:52:50 -06:00
|
|
|
#ifdef CONFIG_PM
|
2015-02-19 08:00:22 -07:00
|
|
|
/* update the power on/off account with the current jiffies */
|
|
|
|
static void update_power_acct(struct hda_codec *codec, bool on)
|
|
|
|
{
|
|
|
|
unsigned long delta = jiffies - codec->power_jiffies;
|
|
|
|
|
|
|
|
if (on)
|
|
|
|
codec->power_on_acct += delta;
|
|
|
|
else
|
|
|
|
codec->power_off_acct += delta;
|
|
|
|
codec->power_jiffies += delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
void snd_hda_update_power_acct(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
update_power_acct(codec, hda_codec_is_power_on(codec));
|
|
|
|
}
|
|
|
|
|
2007-08-10 09:21:45 -06:00
|
|
|
/*
|
|
|
|
* call suspend and power-down; used both from PM and power-save
|
2012-08-31 08:46:56 -06:00
|
|
|
* this function returns the power state in the end
|
2007-08-10 09:21:45 -06:00
|
|
|
*/
|
2015-02-19 08:00:22 -07:00
|
|
|
static unsigned int hda_call_codec_suspend(struct hda_codec *codec)
|
2007-08-10 09:21:45 -06:00
|
|
|
{
|
2012-08-31 08:46:56 -06:00
|
|
|
unsigned int state;
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
atomic_inc(&codec->core.in_pm);
|
2012-11-19 06:14:58 -07:00
|
|
|
|
2007-08-10 09:21:45 -06:00
|
|
|
if (codec->patch_ops.suspend)
|
2012-07-02 07:20:37 -06:00
|
|
|
codec->patch_ops.suspend(codec);
|
2010-08-06 05:48:11 -06:00
|
|
|
hda_cleanup_all_streams(codec);
|
2012-08-31 08:54:38 -06:00
|
|
|
state = hda_set_power_state(codec, AC_PWRST_D3);
|
2015-02-19 08:00:22 -07:00
|
|
|
update_power_acct(codec, true);
|
2015-03-03 02:07:24 -07:00
|
|
|
atomic_dec(&codec->core.in_pm);
|
2012-08-31 08:46:56 -06:00
|
|
|
return state;
|
2005-11-21 08:33:22 -07:00
|
|
|
}
|
|
|
|
|
2007-08-10 09:21:45 -06:00
|
|
|
/*
|
|
|
|
* kick up codec; used both from PM and power-save
|
|
|
|
*/
|
|
|
|
static void hda_call_codec_resume(struct hda_codec *codec)
|
|
|
|
{
|
2015-03-03 02:07:24 -07:00
|
|
|
atomic_inc(&codec->core.in_pm);
|
2012-11-19 06:14:58 -07:00
|
|
|
|
2015-02-25 07:18:50 -07:00
|
|
|
if (codec->core.regmap)
|
|
|
|
regcache_mark_dirty(codec->core.regmap);
|
|
|
|
|
2015-02-19 08:00:22 -07:00
|
|
|
codec->power_jiffies = jiffies;
|
|
|
|
|
2012-08-31 08:54:38 -06:00
|
|
|
hda_set_power_state(codec, AC_PWRST_D0);
|
2010-07-05 08:50:13 -06:00
|
|
|
restore_shutup_pins(codec);
|
2008-07-30 07:01:46 -06:00
|
|
|
hda_exec_init_verbs(codec);
|
2013-01-23 07:58:40 -07:00
|
|
|
snd_hda_jack_set_dirty_all(codec);
|
2007-08-10 09:21:45 -06:00
|
|
|
if (codec->patch_ops.resume)
|
|
|
|
codec->patch_ops.resume(codec);
|
|
|
|
else {
|
2007-08-14 07:15:52 -06:00
|
|
|
if (codec->patch_ops.init)
|
|
|
|
codec->patch_ops.init(codec);
|
2015-02-25 07:18:50 -07:00
|
|
|
if (codec->core.regmap)
|
|
|
|
regcache_sync(codec->core.regmap);
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
2012-10-09 07:04:21 -06:00
|
|
|
|
|
|
|
if (codec->jackpoll_interval)
|
|
|
|
hda_jackpoll_work(&codec->jackpoll_work.work);
|
2013-01-23 07:58:40 -07:00
|
|
|
else
|
2012-10-09 07:04:21 -06:00
|
|
|
snd_hda_jack_report_sync(codec);
|
2015-03-03 02:07:24 -07:00
|
|
|
atomic_dec(&codec->core.in_pm);
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
2015-02-18 07:39:59 -07:00
|
|
|
|
2015-02-19 08:00:22 -07:00
|
|
|
static int hda_codec_runtime_suspend(struct device *dev)
|
2015-02-18 07:39:59 -07:00
|
|
|
{
|
|
|
|
struct hda_codec *codec = dev_to_hda_codec(dev);
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm *pcm;
|
2015-02-19 08:00:22 -07:00
|
|
|
unsigned int state;
|
2015-02-18 07:39:59 -07:00
|
|
|
|
|
|
|
cancel_delayed_work_sync(&codec->jackpoll_work);
|
2015-02-27 09:43:19 -07:00
|
|
|
list_for_each_entry(pcm, &codec->pcm_list_head, list)
|
|
|
|
snd_pcm_suspend_all(pcm->pcm);
|
2015-02-19 08:00:22 -07:00
|
|
|
state = hda_call_codec_suspend(codec);
|
2015-03-03 02:07:24 -07:00
|
|
|
if (codec_has_clkstop(codec) && codec_has_epss(codec) &&
|
|
|
|
(state & AC_PWRST_CLK_STOP_OK))
|
|
|
|
snd_hdac_codec_link_down(&codec->core);
|
2015-02-18 07:39:59 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-19 08:00:22 -07:00
|
|
|
static int hda_codec_runtime_resume(struct device *dev)
|
2015-02-18 07:39:59 -07:00
|
|
|
{
|
2015-02-19 09:35:32 -07:00
|
|
|
struct hda_codec *codec = dev_to_hda_codec(dev);
|
|
|
|
|
2015-03-03 02:07:24 -07:00
|
|
|
snd_hdac_codec_link_up(&codec->core);
|
2015-02-19 09:35:32 -07:00
|
|
|
hda_call_codec_resume(codec);
|
2015-02-19 08:00:22 -07:00
|
|
|
pm_runtime_mark_last_busy(dev);
|
2015-02-18 07:39:59 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2011-07-26 01:52:50 -06:00
|
|
|
#endif /* CONFIG_PM */
|
2007-08-10 09:21:45 -06:00
|
|
|
|
2015-02-18 07:39:59 -07:00
|
|
|
/* referred in hda_bind.c */
|
|
|
|
const struct dev_pm_ops hda_codec_driver_pm = {
|
2015-02-19 08:00:22 -07:00
|
|
|
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
|
|
|
|
pm_runtime_force_resume)
|
|
|
|
SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
|
|
|
|
NULL)
|
2015-02-18 07:39:59 -07:00
|
|
|
};
|
2005-11-21 08:33:22 -07:00
|
|
|
|
2012-07-31 03:35:35 -06:00
|
|
|
/*
|
|
|
|
* add standard channel maps if not specified
|
|
|
|
*/
|
|
|
|
static int add_std_chmaps(struct hda_codec *codec)
|
|
|
|
{
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm *pcm;
|
|
|
|
int str, err;
|
2012-07-31 03:35:35 -06:00
|
|
|
|
2015-02-27 09:43:19 -07:00
|
|
|
list_for_each_entry(pcm, &codec->pcm_list_head, list) {
|
2012-07-31 03:35:35 -06:00
|
|
|
for (str = 0; str < 2; str++) {
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm_stream *hinfo = &pcm->stream[str];
|
2012-07-31 03:35:35 -06:00
|
|
|
struct snd_pcm_chmap *chmap;
|
2012-11-08 09:12:10 -07:00
|
|
|
const struct snd_pcm_chmap_elem *elem;
|
2012-07-31 03:35:35 -06:00
|
|
|
|
2015-04-02 05:21:43 -06:00
|
|
|
if (!pcm || pcm->own_chmap ||
|
|
|
|
!hinfo->substreams)
|
2012-07-31 03:35:35 -06:00
|
|
|
continue;
|
2012-11-08 09:12:10 -07:00
|
|
|
elem = hinfo->chmap ? hinfo->chmap : snd_pcm_std_chmaps;
|
2015-02-27 09:43:19 -07:00
|
|
|
err = snd_pcm_add_chmap_ctls(pcm->pcm, str, elem,
|
2012-07-31 03:35:35 -06:00
|
|
|
hinfo->channels_max,
|
|
|
|
0, &chmap);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-08 09:12:10 -07:00
|
|
|
/* default channel maps for 2.1 speakers;
|
|
|
|
* since HD-audio supports only stereo, odd number channels are omitted
|
|
|
|
*/
|
|
|
|
const struct snd_pcm_chmap_elem snd_pcm_2_1_chmaps[] = {
|
|
|
|
{ .channels = 2,
|
|
|
|
.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
|
|
|
|
{ .channels = 4,
|
|
|
|
.map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
|
|
|
|
SNDRV_CHMAP_LFE, SNDRV_CHMAP_LFE } },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL_GPL(snd_pcm_2_1_chmaps);
|
|
|
|
|
2008-07-30 07:01:45 -06:00
|
|
|
int snd_hda_codec_build_controls(struct hda_codec *codec)
|
|
|
|
{
|
|
|
|
int err = 0;
|
2008-07-30 07:01:46 -06:00
|
|
|
hda_exec_init_verbs(codec);
|
2008-07-30 07:01:45 -06:00
|
|
|
/* continue to initialize... */
|
|
|
|
if (codec->patch_ops.init)
|
|
|
|
err = codec->patch_ops.init(codec);
|
|
|
|
if (!err && codec->patch_ops.build_controls)
|
|
|
|
err = codec->patch_ops.build_controls(codec);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2012-07-31 03:35:35 -06:00
|
|
|
|
|
|
|
/* we create chmaps here instead of build_pcms */
|
|
|
|
err = add_std_chmaps(codec);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2012-10-09 07:04:21 -06:00
|
|
|
if (codec->jackpoll_interval)
|
|
|
|
hda_jackpoll_work(&codec->jackpoll_work.work);
|
|
|
|
else
|
|
|
|
snd_hda_jack_report_sync(codec); /* call at the last init point */
|
2013-01-24 09:27:32 -07:00
|
|
|
sync_power_up_states(codec);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PCM stuff
|
|
|
|
*/
|
|
|
|
static int hda_pcm_default_open_close(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hda_pcm_default_prepare(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hda_pcm_default_cleanup(struct hda_pcm_stream *hinfo,
|
|
|
|
struct hda_codec *codec,
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-18 02:57:50 -06:00
|
|
|
snd_hda_codec_cleanup_stream(codec, hinfo->nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-30 07:01:45 -06:00
|
|
|
static int set_pcm_default_values(struct hda_codec *codec,
|
|
|
|
struct hda_pcm_stream *info)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-03-17 07:30:31 -06:00
|
|
|
int err;
|
|
|
|
|
2007-04-16 03:29:14 -06:00
|
|
|
/* query support PCM information from the given NID */
|
|
|
|
if (info->nid && (!info->rates || !info->formats)) {
|
2009-03-17 07:30:31 -06:00
|
|
|
err = snd_hda_query_supported_pcm(codec, info->nid,
|
2007-04-16 03:29:14 -06:00
|
|
|
info->rates ? NULL : &info->rates,
|
|
|
|
info->formats ? NULL : &info->formats,
|
|
|
|
info->maxbps ? NULL : &info->maxbps);
|
2009-03-17 07:30:31 -06:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (info->ops.open == NULL)
|
|
|
|
info->ops.open = hda_pcm_default_open_close;
|
|
|
|
if (info->ops.close == NULL)
|
|
|
|
info->ops.close = hda_pcm_default_open_close;
|
|
|
|
if (info->ops.prepare == NULL) {
|
2008-08-08 09:12:14 -06:00
|
|
|
if (snd_BUG_ON(!info->nid))
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
info->ops.prepare = hda_pcm_default_prepare;
|
|
|
|
}
|
|
|
|
if (info->ops.cleanup == NULL) {
|
2008-08-08 09:12:14 -06:00
|
|
|
if (snd_BUG_ON(!info->nid))
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
info->ops.cleanup = hda_pcm_default_cleanup;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-06 05:48:11 -06:00
|
|
|
/*
|
|
|
|
* codec prepare/cleanup entries
|
|
|
|
*/
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_prepare - Prepare a stream
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @hinfo: PCM information
|
|
|
|
* @stream: stream tag to assign
|
|
|
|
* @format: format id to assign
|
|
|
|
* @substream: PCM substream to assign
|
|
|
|
*
|
|
|
|
* Calls the prepare callback set by the codec with the given arguments.
|
|
|
|
* Clean up the inactive streams when successful.
|
|
|
|
*/
|
2010-08-06 05:48:11 -06: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)
|
|
|
|
{
|
|
|
|
int ret;
|
2010-08-20 01:44:36 -06:00
|
|
|
mutex_lock(&codec->bus->prepare_mutex);
|
2015-02-27 09:57:55 -07:00
|
|
|
if (hinfo->ops.prepare)
|
|
|
|
ret = hinfo->ops.prepare(hinfo, codec, stream, format,
|
|
|
|
substream);
|
|
|
|
else
|
|
|
|
ret = -ENODEV;
|
2010-08-06 05:48:11 -06:00
|
|
|
if (ret >= 0)
|
|
|
|
purify_inactive_streams(codec);
|
2010-08-20 01:44:36 -06:00
|
|
|
mutex_unlock(&codec->bus->prepare_mutex);
|
2010-08-06 05:48:11 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_prepare);
|
2010-08-06 05:48:11 -06:00
|
|
|
|
2014-10-29 09:03:58 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_codec_cleanup - Prepare a stream
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @hinfo: PCM information
|
|
|
|
* @substream: PCM substream
|
|
|
|
*
|
|
|
|
* Calls the cleanup callback set by the codec with the given arguments.
|
|
|
|
*/
|
2010-08-06 05:48:11 -06:00
|
|
|
void snd_hda_codec_cleanup(struct hda_codec *codec,
|
|
|
|
struct hda_pcm_stream *hinfo,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
2010-08-20 01:44:36 -06:00
|
|
|
mutex_lock(&codec->bus->prepare_mutex);
|
2015-02-27 09:57:55 -07:00
|
|
|
if (hinfo->ops.cleanup)
|
|
|
|
hinfo->ops.cleanup(hinfo, codec, substream);
|
2010-08-20 01:44:36 -06:00
|
|
|
mutex_unlock(&codec->bus->prepare_mutex);
|
2010-08-06 05:48:11 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_codec_cleanup);
|
2010-08-06 05:48:11 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/* global */
|
2009-11-10 06:53:02 -07:00
|
|
|
const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
|
|
|
|
"Audio", "SPDIF", "HDMI", "Modem"
|
|
|
|
};
|
|
|
|
|
2008-11-27 06:17:01 -07:00
|
|
|
/*
|
|
|
|
* get the empty PCM device number to assign
|
|
|
|
*/
|
2013-06-06 04:10:24 -06:00
|
|
|
static int get_empty_pcm_device(struct hda_bus *bus, unsigned int type)
|
2008-11-27 06:17:01 -07:00
|
|
|
{
|
2009-10-30 04:38:26 -06:00
|
|
|
/* audio device indices; not linear to keep compatibility */
|
2013-06-06 04:10:24 -06:00
|
|
|
/* assigned to static slots up to dev#10; if more needed, assign
|
|
|
|
* the later slot dynamically (when CONFIG_SND_DYNAMIC_MINORS=y)
|
|
|
|
*/
|
2009-10-30 04:38:26 -06:00
|
|
|
static int audio_idx[HDA_PCM_NTYPES][5] = {
|
|
|
|
[HDA_PCM_TYPE_AUDIO] = { 0, 2, 4, 5, -1 },
|
|
|
|
[HDA_PCM_TYPE_SPDIF] = { 1, -1 },
|
2009-10-30 04:40:03 -06:00
|
|
|
[HDA_PCM_TYPE_HDMI] = { 3, 7, 8, 9, -1 },
|
2009-10-30 04:38:26 -06:00
|
|
|
[HDA_PCM_TYPE_MODEM] = { 6, -1 },
|
2008-11-27 06:17:01 -07:00
|
|
|
};
|
2009-10-30 04:38:26 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (type >= HDA_PCM_NTYPES) {
|
2014-02-25 04:21:03 -07:00
|
|
|
dev_err(bus->card->dev, "Invalid PCM type %d\n", type);
|
2008-11-27 06:17:01 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-10-30 04:38:26 -06:00
|
|
|
|
2013-06-06 04:10:24 -06:00
|
|
|
for (i = 0; audio_idx[type][i] >= 0; i++) {
|
|
|
|
#ifndef CONFIG_SND_DYNAMIC_MINORS
|
|
|
|
if (audio_idx[type][i] >= 8)
|
|
|
|
break;
|
|
|
|
#endif
|
2009-10-30 04:38:26 -06:00
|
|
|
if (!test_and_set_bit(audio_idx[type][i], bus->pcm_dev_bits))
|
|
|
|
return audio_idx[type][i];
|
2013-06-06 04:10:24 -06:00
|
|
|
}
|
2009-10-30 04:38:26 -06:00
|
|
|
|
2013-06-06 04:10:24 -06:00
|
|
|
#ifdef CONFIG_SND_DYNAMIC_MINORS
|
2011-11-24 06:31:46 -07:00
|
|
|
/* non-fixed slots starting from 10 */
|
|
|
|
for (i = 10; i < 32; i++) {
|
|
|
|
if (!test_and_set_bit(i, bus->pcm_dev_bits))
|
|
|
|
return i;
|
|
|
|
}
|
2013-06-06 04:10:24 -06:00
|
|
|
#endif
|
2011-11-24 06:31:46 -07:00
|
|
|
|
2014-02-25 04:21:03 -07:00
|
|
|
dev_warn(bus->card->dev, "Too many %s devices\n",
|
2010-02-28 12:16:53 -07:00
|
|
|
snd_hda_pcm_type_name[type]);
|
2013-06-06 04:10:24 -06:00
|
|
|
#ifndef CONFIG_SND_DYNAMIC_MINORS
|
2014-02-25 04:21:03 -07:00
|
|
|
dev_warn(bus->card->dev,
|
|
|
|
"Consider building the kernel with CONFIG_SND_DYNAMIC_MINORS=y\n");
|
2013-06-06 04:10:24 -06:00
|
|
|
#endif
|
2009-10-30 04:38:26 -06:00
|
|
|
return -EAGAIN;
|
2008-11-27 06:17:01 -07:00
|
|
|
}
|
|
|
|
|
2015-02-24 03:50:11 -07:00
|
|
|
/* call build_pcms ops of the given codec and set up the default parameters */
|
|
|
|
int snd_hda_codec_parse_pcms(struct hda_codec *codec)
|
2008-07-30 07:01:44 -06:00
|
|
|
{
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm *cpcm;
|
2015-02-24 03:50:11 -07:00
|
|
|
int err;
|
2008-07-30 07:01:44 -06:00
|
|
|
|
2015-02-27 09:43:19 -07:00
|
|
|
if (!list_empty(&codec->pcm_list_head))
|
2015-02-24 03:50:11 -07:00
|
|
|
return 0; /* already parsed */
|
|
|
|
|
|
|
|
if (!codec->patch_ops.build_pcms)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = codec->patch_ops.build_pcms(codec);
|
|
|
|
if (err < 0) {
|
|
|
|
codec_err(codec, "cannot build PCMs for #%d (error %d)\n",
|
2015-03-02 15:22:59 -07:00
|
|
|
codec->core.addr, err);
|
2015-02-24 03:50:11 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-02-27 09:43:19 -07:00
|
|
|
list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
|
2015-02-24 03:50:11 -07:00
|
|
|
int stream;
|
|
|
|
|
|
|
|
for (stream = 0; stream < 2; stream++) {
|
|
|
|
struct hda_pcm_stream *info = &cpcm->stream[stream];
|
|
|
|
|
|
|
|
if (!info->substreams)
|
|
|
|
continue;
|
2008-07-30 07:01:44 -06:00
|
|
|
err = set_pcm_default_values(codec, info);
|
2015-02-24 03:50:11 -07:00
|
|
|
if (err < 0) {
|
|
|
|
codec_warn(codec,
|
|
|
|
"fail to setup default for PCM %s\n",
|
|
|
|
cpcm->name);
|
2008-07-30 07:01:44 -06:00
|
|
|
return err;
|
2015-02-24 03:50:11 -07:00
|
|
|
}
|
2008-07-30 07:01:44 -06:00
|
|
|
}
|
|
|
|
}
|
2015-02-24 03:50:11 -07:00
|
|
|
|
|
|
|
return 0;
|
2008-07-30 07:01:44 -06:00
|
|
|
}
|
|
|
|
|
2008-11-27 06:17:01 -07:00
|
|
|
/* assign all PCMs of the given codec */
|
|
|
|
int snd_hda_codec_build_pcms(struct hda_codec *codec)
|
|
|
|
{
|
2015-02-24 03:50:11 -07:00
|
|
|
struct hda_bus *bus = codec->bus;
|
2015-02-27 09:43:19 -07:00
|
|
|
struct hda_pcm *cpcm;
|
2015-02-24 03:50:11 -07:00
|
|
|
int dev, err;
|
2008-11-27 06:17:01 -07:00
|
|
|
|
2015-02-24 03:50:11 -07:00
|
|
|
err = snd_hda_codec_parse_pcms(codec);
|
|
|
|
if (err < 0) {
|
|
|
|
snd_hda_codec_reset(codec);
|
|
|
|
return err;
|
2008-11-27 06:17:01 -07:00
|
|
|
}
|
2015-02-24 03:50:11 -07:00
|
|
|
|
|
|
|
/* attach a new PCM streams */
|
2015-02-27 09:43:19 -07:00
|
|
|
list_for_each_entry(cpcm, &codec->pcm_list_head, list) {
|
2015-02-24 03:50:11 -07:00
|
|
|
if (cpcm->pcm)
|
|
|
|
continue; /* already attached */
|
2008-11-27 06:17:01 -07:00
|
|
|
if (!cpcm->stream[0].substreams && !cpcm->stream[1].substreams)
|
2009-01-20 10:21:23 -07:00
|
|
|
continue; /* no substreams assigned */
|
2008-11-27 06:17:01 -07:00
|
|
|
|
2015-02-24 03:50:11 -07:00
|
|
|
dev = get_empty_pcm_device(bus, cpcm->pcm_type);
|
|
|
|
if (dev < 0)
|
|
|
|
continue; /* no fatal error */
|
|
|
|
cpcm->device = dev;
|
2015-04-16 15:25:02 -06:00
|
|
|
err = snd_hda_attach_pcm_stream(bus, codec, cpcm);
|
2015-02-24 03:50:11 -07:00
|
|
|
if (err < 0) {
|
|
|
|
codec_err(codec,
|
|
|
|
"cannot attach PCM stream %d for codec #%d\n",
|
2015-03-02 15:22:59 -07:00
|
|
|
dev, codec->core.addr);
|
2015-02-24 03:50:11 -07:00
|
|
|
continue; /* no fatal error */
|
2008-11-27 06:17:01 -07:00
|
|
|
}
|
|
|
|
}
|
2015-02-24 03:50:11 -07:00
|
|
|
|
2008-11-27 06:17:01 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_add_new_ctls - create controls from the array
|
|
|
|
* @codec: the HDA codec
|
2005-11-17 06:57:47 -07:00
|
|
|
* @knew: the array of struct snd_kcontrol_new
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This helper function creates and add new controls in the given array.
|
|
|
|
* The array must be terminated with an empty entry as terminator.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
2011-05-02 03:29:30 -06:00
|
|
|
int snd_hda_add_new_ctls(struct hda_codec *codec,
|
|
|
|
const struct snd_kcontrol_new *knew)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-11-12 02:15:48 -07:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (; knew->name; knew++) {
|
2005-11-21 08:33:22 -07:00
|
|
|
struct snd_kcontrol *kctl;
|
2010-12-23 02:17:52 -07:00
|
|
|
int addr = 0, idx = 0;
|
2009-12-08 08:13:32 -07:00
|
|
|
if (knew->iface == -1) /* skip this codec private value */
|
|
|
|
continue;
|
2010-12-23 02:17:52 -07:00
|
|
|
for (;;) {
|
2005-11-21 08:33:22 -07:00
|
|
|
kctl = snd_ctl_new1(knew, codec);
|
2007-04-16 03:29:14 -06:00
|
|
|
if (!kctl)
|
2005-11-21 08:33:22 -07:00
|
|
|
return -ENOMEM;
|
2010-12-23 02:17:52 -07:00
|
|
|
if (addr > 0)
|
|
|
|
kctl->id.device = addr;
|
|
|
|
if (idx > 0)
|
|
|
|
kctl->id.index = idx;
|
2009-11-11 05:43:01 -07:00
|
|
|
err = snd_hda_ctl_add(codec, 0, kctl);
|
2010-12-23 02:17:52 -07:00
|
|
|
if (!err)
|
|
|
|
break;
|
|
|
|
/* try first with another device index corresponding to
|
|
|
|
* the codec addr; if it still fails (or it's the
|
|
|
|
* primary codec), then try another control index
|
|
|
|
*/
|
2015-03-02 15:22:59 -07:00
|
|
|
if (!addr && codec->core.addr)
|
|
|
|
addr = codec->core.addr;
|
2010-12-23 02:17:52 -07:00
|
|
|
else if (!idx && !knew->index) {
|
|
|
|
idx = find_empty_mixer_ctl_idx(codec,
|
2012-10-12 09:24:51 -06:00
|
|
|
knew->name, 0);
|
2010-12-23 02:17:52 -07:00
|
|
|
if (idx <= 0)
|
|
|
|
return err;
|
|
|
|
} else
|
2005-11-21 08:33:22 -07:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_add_new_ctls);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-24 10:38:08 -06:00
|
|
|
#ifdef CONFIG_PM
|
2015-02-20 01:26:04 -07:00
|
|
|
static void codec_set_power_save(struct hda_codec *codec, int delay)
|
2007-08-10 09:21:45 -06:00
|
|
|
{
|
2015-02-19 08:00:22 -07:00
|
|
|
struct device *dev = hda_codec_dev(codec);
|
|
|
|
|
|
|
|
if (delay > 0) {
|
|
|
|
pm_runtime_set_autosuspend_delay(dev, delay);
|
|
|
|
pm_runtime_use_autosuspend(dev);
|
|
|
|
pm_runtime_allow(dev);
|
|
|
|
if (!pm_runtime_suspended(dev))
|
|
|
|
pm_runtime_mark_last_busy(dev);
|
|
|
|
} else {
|
|
|
|
pm_runtime_dont_use_autosuspend(dev);
|
|
|
|
pm_runtime_forbid(dev);
|
|
|
|
}
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
2015-02-20 01:26:04 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_set_power_save - reprogram autosuspend for the given delay
|
|
|
|
* @bus: HD-audio bus
|
|
|
|
* @delay: autosuspend delay in msec, 0 = off
|
|
|
|
*
|
|
|
|
* Synchronize the runtime PM autosuspend state from the power_save option.
|
|
|
|
*/
|
|
|
|
void snd_hda_set_power_save(struct hda_bus *bus, int delay)
|
|
|
|
{
|
|
|
|
struct hda_codec *c;
|
|
|
|
|
2015-03-02 15:22:59 -07:00
|
|
|
list_for_each_codec(c, bus)
|
2015-02-20 01:26:04 -07:00
|
|
|
codec_set_power_save(c, delay);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_set_power_save);
|
2007-08-10 09:21:45 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_check_amp_list_power - Check the amp list and update the power
|
|
|
|
* @codec: HD-audio codec
|
|
|
|
* @check: the object containing an AMP list and the status
|
|
|
|
* @nid: NID to check / update
|
|
|
|
*
|
|
|
|
* Check whether the given NID is in the amp list. If it's in the list,
|
|
|
|
* check the current AMP status, and update the the power-status according
|
|
|
|
* to the mute status.
|
|
|
|
*
|
|
|
|
* This function is supposed to be set or called from the check_power_status
|
|
|
|
* patch ops.
|
2010-02-28 12:16:53 -07:00
|
|
|
*/
|
2007-08-10 09:21:45 -06:00
|
|
|
int snd_hda_check_amp_list_power(struct hda_codec *codec,
|
|
|
|
struct hda_loopback_check *check,
|
|
|
|
hda_nid_t nid)
|
|
|
|
{
|
2011-05-02 03:29:30 -06:00
|
|
|
const struct hda_amp_list *p;
|
2007-08-10 09:21:45 -06:00
|
|
|
int ch, v;
|
|
|
|
|
|
|
|
if (!check->amplist)
|
|
|
|
return 0;
|
|
|
|
for (p = check->amplist; p->nid; p++) {
|
|
|
|
if (p->nid == nid)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!p->nid)
|
|
|
|
return 0; /* nothing changed */
|
|
|
|
|
|
|
|
for (p = check->amplist; p->nid; p++) {
|
|
|
|
for (ch = 0; ch < 2; ch++) {
|
|
|
|
v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
|
|
|
|
p->idx);
|
|
|
|
if (!(v & HDA_AMP_MUTE) && v > 0) {
|
|
|
|
if (!check->power_on) {
|
|
|
|
check->power_on = 1;
|
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 03:43:14 -06:00
|
|
|
snd_hda_power_up_pm(codec);
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (check->power_on) {
|
|
|
|
check->power_on = 0;
|
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 03:43:14 -06:00
|
|
|
snd_hda_power_down_pm(codec);
|
2007-08-10 09:21:45 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_check_amp_list_power);
|
2007-08-10 09:21:45 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* input MUX helper
|
|
|
|
*/
|
2009-11-16 06:58:17 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hda_input_mux_info_info - Info callback helper for the input-mux enum
|
2014-10-29 08:06:01 -06:00
|
|
|
* @imux: imux helper object
|
|
|
|
* @uinfo: pointer to get/store the data
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_input_mux_info(const struct hda_input_mux *imux,
|
|
|
|
struct snd_ctl_elem_info *uinfo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned int index;
|
|
|
|
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
|
|
uinfo->count = 1;
|
|
|
|
uinfo->value.enumerated.items = imux->num_items;
|
2007-10-09 03:58:41 -06:00
|
|
|
if (!imux->num_items)
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
index = uinfo->value.enumerated.item;
|
|
|
|
if (index >= imux->num_items)
|
|
|
|
index = imux->num_items - 1;
|
|
|
|
strcpy(uinfo->value.enumerated.name, imux->items[index].label);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_input_mux_info);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_input_mux_info_put - Put callback helper for the input-mux enum
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @imux: imux helper object
|
|
|
|
* @ucontrol: pointer to get/store the data
|
|
|
|
* @nid: input mux NID
|
|
|
|
* @cur_val: pointer to get/store the current imux value
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_input_mux_put(struct hda_codec *codec,
|
|
|
|
const struct hda_input_mux *imux,
|
|
|
|
struct snd_ctl_elem_value *ucontrol,
|
|
|
|
hda_nid_t nid,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int *cur_val)
|
|
|
|
{
|
|
|
|
unsigned int idx;
|
|
|
|
|
2007-10-09 03:58:41 -06:00
|
|
|
if (!imux->num_items)
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
idx = ucontrol->value.enumerated.item[0];
|
|
|
|
if (idx >= imux->num_items)
|
|
|
|
idx = imux->num_items - 1;
|
2007-08-10 09:09:26 -06:00
|
|
|
if (*cur_val == idx)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2007-08-10 09:09:26 -06:00
|
|
|
snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
|
|
|
|
imux->items[idx].index);
|
2005-04-16 16:20:36 -06:00
|
|
|
*cur_val = idx;
|
|
|
|
return 1;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_input_mux_put);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2014-10-29 08:06:01 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_enum_helper_info - Helper for simple enum ctls
|
|
|
|
* @kcontrol: ctl element
|
|
|
|
* @uinfo: pointer to get/store the data
|
|
|
|
* @num_items: number of enum items
|
|
|
|
* @texts: enum item string array
|
|
|
|
*
|
2012-11-30 10:34:38 -07:00
|
|
|
* process kcontrol info callback of a simple string enum array
|
|
|
|
* when @num_items is 0 or @texts is NULL, assume a boolean enum array
|
|
|
|
*/
|
|
|
|
int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *uinfo,
|
|
|
|
int num_items, const char * const *texts)
|
|
|
|
{
|
|
|
|
static const char * const texts_default[] = {
|
|
|
|
"Disabled", "Enabled"
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!texts || !num_items) {
|
|
|
|
num_items = 2;
|
|
|
|
texts = texts_default;
|
|
|
|
}
|
|
|
|
|
2014-10-20 10:17:28 -06:00
|
|
|
return snd_ctl_enum_info(uinfo, 1, num_items, texts);
|
2012-11-30 10:34:38 -07:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_enum_helper_info);
|
2012-11-30 10:34:38 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Multi-channel / digital-out PCM helper functions
|
|
|
|
*/
|
|
|
|
|
2007-04-05 06:51:48 -06:00
|
|
|
/* setup SPDIF output stream */
|
|
|
|
static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
|
|
|
|
unsigned int stream_tag, unsigned int format)
|
|
|
|
{
|
2012-11-03 11:00:06 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
|
|
|
unsigned int curr_fmt;
|
|
|
|
bool reset;
|
|
|
|
|
|
|
|
spdif = snd_hda_spdif_out_of_nid(codec, nid);
|
|
|
|
curr_fmt = snd_hda_codec_read(codec, nid, 0,
|
|
|
|
AC_VERB_GET_STREAM_FORMAT, 0);
|
|
|
|
reset = codec->spdif_status_reset &&
|
|
|
|
(spdif->ctls & AC_DIG1_ENABLE) &&
|
|
|
|
curr_fmt != format;
|
|
|
|
|
|
|
|
/* turn off SPDIF if needed; otherwise the IEC958 bits won't be
|
|
|
|
updated */
|
|
|
|
if (reset)
|
2010-02-28 12:16:53 -07:00
|
|
|
set_dig_out_convert(codec, 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 11:14:17 -06:00
|
|
|
spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
|
2008-09-25 08:32:41 -06:00
|
|
|
-1);
|
2007-04-05 06:51:48 -06:00
|
|
|
snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
|
2008-09-25 08:32:41 -06:00
|
|
|
if (codec->slave_dig_outs) {
|
2011-05-02 03:29:30 -06:00
|
|
|
const hda_nid_t *d;
|
2008-09-25 08:32:41 -06:00
|
|
|
for (d = codec->slave_dig_outs; *d; d++)
|
|
|
|
snd_hda_codec_setup_stream(codec, *d, stream_tag, 0,
|
|
|
|
format);
|
|
|
|
}
|
2007-04-05 06:51:48 -06:00
|
|
|
/* turn on again (if needed) */
|
2012-11-03 11:00:06 -06:00
|
|
|
if (reset)
|
2008-09-25 08:32:41 -06:00
|
|
|
set_dig_out_convert(codec, 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 11:14:17 -06:00
|
|
|
spdif->ctls & 0xff, -1);
|
2008-09-25 08:32:41 -06:00
|
|
|
}
|
2008-09-07 12:31:40 -06:00
|
|
|
|
2008-09-25 08:32:41 -06:00
|
|
|
static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
snd_hda_codec_cleanup_stream(codec, nid);
|
|
|
|
if (codec->slave_dig_outs) {
|
2011-05-02 03:29:30 -06:00
|
|
|
const hda_nid_t *d;
|
2008-09-25 08:32:41 -06:00
|
|
|
for (d = codec->slave_dig_outs; *d; d++)
|
|
|
|
snd_hda_codec_cleanup_stream(codec, *d);
|
2008-09-07 12:31:40 -06:00
|
|
|
}
|
2007-04-05 06:51:48 -06:00
|
|
|
}
|
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_dig_open - open the digital out in the exclusive mode
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_multi_out_dig_open(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2007-04-16 03:23:56 -06:00
|
|
|
if (mout->dig_out_used == HDA_DIG_ANALOG_DUP)
|
|
|
|
/* already opened as analog dup; reset it once */
|
2008-09-25 08:32:41 -06:00
|
|
|
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
mout->dig_out_used = HDA_DIG_EXCLUSIVE;
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_open);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_dig_prepare - prepare the digital out stream
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
|
|
|
* @stream_tag: stream tag to assign
|
|
|
|
* @format: format id to assign
|
|
|
|
* @substream: PCM substream to assign
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2007-04-05 06:51:48 -06:00
|
|
|
int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout,
|
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
|
|
|
struct snd_pcm_substream *substream)
|
|
|
|
{
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
setup_dig_out_stream(codec, mout->dig_out_nid, stream_tag, format);
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_prepare);
|
2007-04-05 06:51:48 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_dig_cleanup - clean-up the digital out stream
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
2009-11-16 06:58:17 -07:00
|
|
|
*/
|
2009-02-13 03:32:28 -07:00
|
|
|
int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout)
|
|
|
|
{
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_cleanup);
|
2009-02-13 03:32:28 -07:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_dig_close - release the digital out stream
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_multi_out_dig_close(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
mout->dig_out_used = 0;
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_dig_close);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_analog_open - open analog outputs
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
|
|
|
* @substream: PCM substream to assign
|
|
|
|
* @hinfo: PCM information to assign
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* Open analog outputs and set up the hw-constraints.
|
|
|
|
* If the digital outputs can be opened as slave, open the digital
|
|
|
|
* outputs, too.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_multi_out_analog_open(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout,
|
2008-02-12 10:37:26 -07:00
|
|
|
struct snd_pcm_substream *substream,
|
|
|
|
struct hda_pcm_stream *hinfo)
|
|
|
|
{
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
|
|
runtime->hw.channels_max = mout->max_channels;
|
|
|
|
if (mout->dig_out_nid) {
|
|
|
|
if (!mout->analog_rates) {
|
|
|
|
mout->analog_rates = hinfo->rates;
|
|
|
|
mout->analog_formats = hinfo->formats;
|
|
|
|
mout->analog_maxbps = hinfo->maxbps;
|
|
|
|
} else {
|
|
|
|
runtime->hw.rates = mout->analog_rates;
|
|
|
|
runtime->hw.formats = mout->analog_formats;
|
|
|
|
hinfo->maxbps = mout->analog_maxbps;
|
|
|
|
}
|
|
|
|
if (!mout->spdif_rates) {
|
|
|
|
snd_hda_query_supported_pcm(codec, mout->dig_out_nid,
|
|
|
|
&mout->spdif_rates,
|
|
|
|
&mout->spdif_formats,
|
|
|
|
&mout->spdif_maxbps);
|
|
|
|
}
|
|
|
|
mutex_lock(&codec->spdif_mutex);
|
|
|
|
if (mout->share_spdif) {
|
2009-07-03 15:03:30 -06:00
|
|
|
if ((runtime->hw.rates & mout->spdif_rates) &&
|
|
|
|
(runtime->hw.formats & mout->spdif_formats)) {
|
|
|
|
runtime->hw.rates &= mout->spdif_rates;
|
|
|
|
runtime->hw.formats &= mout->spdif_formats;
|
|
|
|
if (mout->spdif_maxbps < hinfo->maxbps)
|
|
|
|
hinfo->maxbps = mout->spdif_maxbps;
|
|
|
|
} else {
|
|
|
|
mout->share_spdif = 0;
|
|
|
|
/* FIXME: need notify? */
|
|
|
|
}
|
2008-02-12 10:37:26 -07:00
|
|
|
}
|
2008-04-14 05:11:44 -06:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2008-02-12 10:37:26 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return snd_pcm_hw_constraint_step(substream->runtime, 0,
|
|
|
|
SNDRV_PCM_HW_PARAM_CHANNELS, 2);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_open);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_analog_prepare - Preapre the analog outputs.
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
|
|
|
* @stream_tag: stream tag to assign
|
|
|
|
* @format: format id to assign
|
|
|
|
* @substream: PCM substream to assign
|
2009-11-16 06:58:17 -07:00
|
|
|
*
|
|
|
|
* Set up the i/o for analog out.
|
|
|
|
* When the digital out is available, copy the front out to digital out, too.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int stream_tag,
|
|
|
|
unsigned int format,
|
2005-11-17 06:57:47 -07:00
|
|
|
struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-02 03:29:30 -06:00
|
|
|
const hda_nid_t *nids = mout->dac_nids;
|
2005-04-16 16:20:36 -06:00
|
|
|
int chs = substream->runtime->channels;
|
2012-05-10 02:21:29 -06:00
|
|
|
struct hda_spdif_out *spdif;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2012-05-10 02:21:29 -06:00
|
|
|
spdif = snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
|
2008-02-12 10:37:26 -07:00
|
|
|
if (mout->dig_out_nid && mout->share_spdif &&
|
|
|
|
mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (chs == 2 &&
|
2007-04-16 03:29:14 -06:00
|
|
|
snd_hda_is_supported_format(codec, mout->dig_out_nid,
|
|
|
|
format) &&
|
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 11:14:17 -06:00
|
|
|
!(spdif->status & IEC958_AES0_NONAUDIO)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
mout->dig_out_used = HDA_DIG_ANALOG_DUP;
|
2007-04-05 06:51:48 -06:00
|
|
|
setup_dig_out_stream(codec, mout->dig_out_nid,
|
|
|
|
stream_tag, format);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
mout->dig_out_used = 0;
|
2008-09-25 08:32:41 -06:00
|
|
|
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* front */
|
2007-04-16 03:29:14 -06:00
|
|
|
snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
|
|
|
|
0, format);
|
2007-10-26 04:35:56 -06:00
|
|
|
if (!mout->no_share_stream &&
|
|
|
|
mout->hp_nid && mout->hp_nid != nids[HDA_FRONT])
|
2005-04-16 16:20:36 -06:00
|
|
|
/* headphone out will just decode front left/right (stereo) */
|
2007-04-16 03:29:14 -06:00
|
|
|
snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
|
|
|
|
0, format);
|
2006-03-21 03:24:42 -07:00
|
|
|
/* extra outputs copied from front */
|
2011-08-23 10:16:13 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
|
|
|
|
if (!mout->no_share_stream && mout->hp_out_nid[i])
|
|
|
|
snd_hda_codec_setup_stream(codec,
|
|
|
|
mout->hp_out_nid[i],
|
|
|
|
stream_tag, 0, format);
|
2006-03-21 03:24:42 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* surrounds */
|
|
|
|
for (i = 1; i < mout->num_dacs; i++) {
|
2005-06-10 11:48:10 -06:00
|
|
|
if (chs >= (i + 1) * 2) /* independent out */
|
2007-04-16 03:29:14 -06:00
|
|
|
snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
|
|
|
|
i * 2, format);
|
2007-10-26 04:35:56 -06:00
|
|
|
else if (!mout->no_share_stream) /* copy front */
|
2007-04-16 03:29:14 -06:00
|
|
|
snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
|
|
|
|
0, format);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2013-10-10 01:01:25 -06:00
|
|
|
|
|
|
|
/* extra surrounds */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++) {
|
|
|
|
int ch = 0;
|
|
|
|
if (!mout->extra_out_nid[i])
|
|
|
|
break;
|
|
|
|
if (chs >= (i + 1) * 2)
|
|
|
|
ch = i * 2;
|
|
|
|
else if (!mout->no_share_stream)
|
|
|
|
break;
|
|
|
|
snd_hda_codec_setup_stream(codec, mout->extra_out_nid[i],
|
|
|
|
stream_tag, ch, format);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_prepare);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_hda_multi_out_analog_cleanup - clean up the setting for analog out
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @mout: hda_multi_out object
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-04-16 03:29:14 -06:00
|
|
|
int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
|
|
|
|
struct hda_multi_out *mout)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-05-02 03:29:30 -06:00
|
|
|
const hda_nid_t *nids = mout->dac_nids;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mout->num_dacs; i++)
|
2008-03-18 02:57:50 -06:00
|
|
|
snd_hda_codec_cleanup_stream(codec, nids[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (mout->hp_nid)
|
2008-03-18 02:57:50 -06:00
|
|
|
snd_hda_codec_cleanup_stream(codec, mout->hp_nid);
|
2011-08-23 10:16:13 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(mout->hp_out_nid); i++)
|
|
|
|
if (mout->hp_out_nid[i])
|
|
|
|
snd_hda_codec_cleanup_stream(codec,
|
|
|
|
mout->hp_out_nid[i]);
|
2006-03-21 03:24:42 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
|
|
|
|
if (mout->extra_out_nid[i])
|
2008-03-18 02:57:50 -06:00
|
|
|
snd_hda_codec_cleanup_stream(codec,
|
|
|
|
mout->extra_out_nid[i]);
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_lock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (mout->dig_out_nid && mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
|
2008-09-25 08:32:41 -06:00
|
|
|
cleanup_dig_out_stream(codec, mout->dig_out_nid);
|
2005-04-16 16:20:36 -06:00
|
|
|
mout->dig_out_used = 0;
|
|
|
|
}
|
2006-01-16 08:34:20 -07:00
|
|
|
mutex_unlock(&codec->spdif_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_multi_out_analog_cleanup);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-20 05:06:53 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_get_default_vref - Get the default (mic) VREF pin bits
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @pin: referred pin NID
|
2012-04-20 05:06:53 -06:00
|
|
|
*
|
|
|
|
* Guess the suitable VREF pin bits to be set as the pin-control value.
|
|
|
|
* Note: the function doesn't set the AC_PINCTL_IN_EN bit.
|
|
|
|
*/
|
|
|
|
unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin)
|
|
|
|
{
|
|
|
|
unsigned int pincap;
|
|
|
|
unsigned int oldval;
|
|
|
|
oldval = snd_hda_codec_read(codec, pin, 0,
|
|
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
|
|
|
|
pincap = snd_hda_query_pin_caps(codec, pin);
|
|
|
|
pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
|
|
|
|
/* Exception: if the default pin setup is vref50, we give it priority */
|
|
|
|
if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
|
|
|
|
return AC_PINCTL_VREF_80;
|
|
|
|
else if (pincap & AC_PINCAP_VREF_50)
|
|
|
|
return AC_PINCTL_VREF_50;
|
|
|
|
else if (pincap & AC_PINCAP_VREF_100)
|
|
|
|
return AC_PINCTL_VREF_100;
|
|
|
|
else if (pincap & AC_PINCAP_VREF_GRD)
|
|
|
|
return AC_PINCTL_VREF_GRD;
|
|
|
|
return AC_PINCTL_VREF_HIZ;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_get_default_vref);
|
2012-04-20 05:06:53 -06:00
|
|
|
|
2014-10-29 08:06:01 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_correct_pin_ctl - correct the pin ctl value for matching with the pin cap
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @pin: referred pin NID
|
|
|
|
* @val: pin ctl value to audit
|
|
|
|
*/
|
2013-01-10 00:56:46 -07:00
|
|
|
unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
|
|
|
|
hda_nid_t pin, unsigned int val)
|
|
|
|
{
|
|
|
|
static unsigned int cap_lists[][2] = {
|
|
|
|
{ AC_PINCTL_VREF_100, AC_PINCAP_VREF_100 },
|
|
|
|
{ AC_PINCTL_VREF_80, AC_PINCAP_VREF_80 },
|
|
|
|
{ AC_PINCTL_VREF_50, AC_PINCAP_VREF_50 },
|
|
|
|
{ AC_PINCTL_VREF_GRD, AC_PINCAP_VREF_GRD },
|
|
|
|
};
|
|
|
|
unsigned int cap;
|
|
|
|
|
|
|
|
if (!val)
|
|
|
|
return 0;
|
|
|
|
cap = snd_hda_query_pin_caps(codec, pin);
|
|
|
|
if (!cap)
|
|
|
|
return val; /* don't know what to do... */
|
|
|
|
|
|
|
|
if (val & AC_PINCTL_OUT_EN) {
|
|
|
|
if (!(cap & AC_PINCAP_OUT))
|
|
|
|
val &= ~(AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
|
|
|
|
else if ((val & AC_PINCTL_HP_EN) && !(cap & AC_PINCAP_HP_DRV))
|
|
|
|
val &= ~AC_PINCTL_HP_EN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val & AC_PINCTL_IN_EN) {
|
|
|
|
if (!(cap & AC_PINCAP_IN))
|
|
|
|
val &= ~(AC_PINCTL_IN_EN | AC_PINCTL_VREFEN);
|
|
|
|
else {
|
|
|
|
unsigned int vcap, vref;
|
|
|
|
int i;
|
|
|
|
vcap = (cap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
|
|
|
|
vref = val & AC_PINCTL_VREFEN;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cap_lists); i++) {
|
|
|
|
if (vref == cap_lists[i][0] &&
|
|
|
|
!(vcap & cap_lists[i][1])) {
|
|
|
|
if (i == ARRAY_SIZE(cap_lists) - 1)
|
|
|
|
vref = AC_PINCTL_VREF_HIZ;
|
|
|
|
else
|
|
|
|
vref = cap_lists[i + 1][0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val &= ~AC_PINCTL_VREFEN;
|
|
|
|
val |= vref;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_correct_pin_ctl);
|
2013-01-10 00:56:46 -07:00
|
|
|
|
2014-10-29 08:06:01 -06:00
|
|
|
/**
|
|
|
|
* _snd_hda_pin_ctl - Helper to set pin ctl value
|
|
|
|
* @codec: the HDA codec
|
|
|
|
* @pin: referred pin NID
|
|
|
|
* @val: pin control value to set
|
|
|
|
* @cached: access over codec pinctl cache or direct write
|
|
|
|
*
|
|
|
|
* This function is a helper to set a pin ctl value more safely.
|
|
|
|
* It corrects the pin ctl value via snd_hda_correct_pin_ctl(), stores the
|
|
|
|
* value in pin target array via snd_hda_codec_set_pin_target(), then
|
|
|
|
* actually writes the value via either snd_hda_codec_update_cache() or
|
|
|
|
* snd_hda_codec_write() depending on @cached flag.
|
|
|
|
*/
|
2012-04-20 04:34:50 -06:00
|
|
|
int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
|
|
|
|
unsigned int val, bool cached)
|
|
|
|
{
|
2013-01-10 00:56:46 -07:00
|
|
|
val = snd_hda_correct_pin_ctl(codec, pin, val);
|
2013-01-10 00:38:04 -07:00
|
|
|
snd_hda_codec_set_pin_target(codec, pin, val);
|
2012-04-20 04:34:50 -06:00
|
|
|
if (cached)
|
|
|
|
return snd_hda_codec_update_cache(codec, pin, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL, val);
|
|
|
|
else
|
|
|
|
return snd_hda_codec_write(codec, pin, 0,
|
|
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL, val);
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(_snd_hda_set_pin_ctl);
|
2012-04-20 04:34:50 -06:00
|
|
|
|
2010-09-09 14:08:44 -06:00
|
|
|
/**
|
|
|
|
* snd_hda_add_imux_item - Add an item to input_mux
|
2014-10-29 08:06:01 -06:00
|
|
|
* @codec: the HDA codec
|
|
|
|
* @imux: imux helper object
|
|
|
|
* @label: the name of imux item to assign
|
|
|
|
* @index: index number of imux item to assign
|
|
|
|
* @type_idx: pointer to store the resultant label index
|
2010-09-09 14:08:44 -06:00
|
|
|
*
|
|
|
|
* When the same label is used already in the existing items, the number
|
|
|
|
* suffix is appended to the label. This label index number is stored
|
|
|
|
* to type_idx when non-NULL pointer is given.
|
|
|
|
*/
|
2014-06-06 10:12:16 -06:00
|
|
|
int snd_hda_add_imux_item(struct hda_codec *codec,
|
|
|
|
struct hda_input_mux *imux, const char *label,
|
2010-09-09 08:28:02 -06:00
|
|
|
int index, int *type_idx)
|
|
|
|
{
|
|
|
|
int i, label_idx = 0;
|
|
|
|
if (imux->num_items >= HDA_MAX_NUM_INPUTS) {
|
2014-06-06 10:12:16 -06:00
|
|
|
codec_err(codec, "hda_codec: Too many imux items!\n");
|
2010-09-09 08:28:02 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
for (i = 0; i < imux->num_items; i++) {
|
|
|
|
if (!strncmp(label, imux->items[i].label, strlen(label)))
|
|
|
|
label_idx++;
|
2010-08-30 05:00:16 -06:00
|
|
|
}
|
2010-09-09 08:28:02 -06:00
|
|
|
if (type_idx)
|
|
|
|
*type_idx = label_idx;
|
|
|
|
if (label_idx > 0)
|
|
|
|
snprintf(imux->items[imux->num_items].label,
|
|
|
|
sizeof(imux->items[imux->num_items].label),
|
|
|
|
"%s %d", label, label_idx);
|
2010-09-09 06:21:17 -06:00
|
|
|
else
|
2010-09-09 08:28:02 -06:00
|
|
|
strlcpy(imux->items[imux->num_items].label, label,
|
|
|
|
sizeof(imux->items[imux->num_items].label));
|
|
|
|
imux->items[imux->num_items].index = index;
|
|
|
|
imux->num_items++;
|
|
|
|
return 0;
|
2010-08-30 05:00:16 -06:00
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hda_add_imux_item);
|
2010-08-30 05:00:16 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2015-04-16 15:25:02 -06:00
|
|
|
* snd_hda_bus_reset_codecs - Reset the bus
|
2015-02-18 07:39:59 -07:00
|
|
|
* @bus: HD-audio bus
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2015-04-16 15:25:02 -06:00
|
|
|
void snd_hda_bus_reset_codecs(struct hda_bus *bus)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-04-16 03:29:14 -06:00
|
|
|
struct hda_codec *codec;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-03-02 15:22:59 -07:00
|
|
|
list_for_each_codec(codec, bus) {
|
2015-02-18 07:39:59 -07:00
|
|
|
/* FIXME: maybe a better way needed for forced reset */
|
2012-10-09 07:04:21 -06:00
|
|
|
cancel_delayed_work_sync(&codec->jackpoll_work);
|
2015-02-18 07:39:59 -07:00
|
|
|
#ifdef CONFIG_PM
|
2013-11-26 21:00:51 -07:00
|
|
|
if (hda_codec_is_power_on(codec)) {
|
2015-02-19 08:00:22 -07:00
|
|
|
hda_call_codec_suspend(codec);
|
2013-11-26 21:32:23 -07:00
|
|
|
hda_call_codec_resume(codec);
|
2015-02-18 07:39:59 -07:00
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2008-07-30 07:01:44 -06:00
|
|
|
|
2009-11-16 06:58:17 -07:00
|
|
|
/**
|
|
|
|
* snd_print_pcm_bits - Print the supported PCM fmt bits to the string buffer
|
|
|
|
* @pcm: PCM caps bits
|
|
|
|
* @buf: the string buffer to write
|
|
|
|
* @buflen: the max buffer length
|
|
|
|
*
|
|
|
|
* used by hda_proc.c and hda_eld.c
|
|
|
|
*/
|
2008-11-21 13:24:03 -07:00
|
|
|
void snd_print_pcm_bits(int pcm, char *buf, int buflen)
|
|
|
|
{
|
|
|
|
static unsigned int bits[] = { 8, 16, 20, 24, 32 };
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < ARRAY_SIZE(bits); i++)
|
|
|
|
if (pcm & (AC_SUPPCM_BITS_8 << i))
|
|
|
|
j += snprintf(buf + j, buflen - j, " %d", bits[i]);
|
|
|
|
|
|
|
|
buf[j] = '\0'; /* necessary when j == 0 */
|
|
|
|
}
|
2013-12-17 23:45:52 -07:00
|
|
|
EXPORT_SYMBOL_GPL(snd_print_pcm_bits);
|
2008-11-27 07:47:11 -07:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("HDA codec core");
|
|
|
|
MODULE_LICENSE("GPL");
|