2015-03-03 17:07:24 +08:00
|
|
|
/*
|
|
|
|
* HD-audio codec core device
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/export.h>
|
|
|
|
#include <linux/pm_runtime.h>
|
|
|
|
#include <sound/hdaudio.h>
|
2015-02-26 20:57:47 +08:00
|
|
|
#include <sound/hda_regmap.h>
|
2015-03-03 17:07:24 +08:00
|
|
|
#include "local.h"
|
|
|
|
|
|
|
|
static void setup_fg_nodes(struct hdac_device *codec);
|
|
|
|
static int get_codec_vendor_name(struct hdac_device *codec);
|
|
|
|
|
|
|
|
static void default_release(struct device *dev)
|
|
|
|
{
|
|
|
|
snd_hdac_device_exit(container_of(dev, struct hdac_device, dev));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_device_init - initialize the HD-audio codec base device
|
|
|
|
* @codec: device to initialize
|
|
|
|
* @bus: but to attach
|
|
|
|
* @name: device name string
|
|
|
|
* @addr: codec address
|
|
|
|
*
|
|
|
|
* Returns zero for success or a negative error code.
|
|
|
|
*
|
|
|
|
* This function increments the runtime PM counter and marks it active.
|
|
|
|
* The caller needs to turn it off appropriately later.
|
|
|
|
*
|
|
|
|
* The caller needs to set the device's release op properly by itself.
|
|
|
|
*/
|
|
|
|
int snd_hdac_device_init(struct hdac_device *codec, struct hdac_bus *bus,
|
|
|
|
const char *name, unsigned int addr)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
hda_nid_t fg;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
dev = &codec->dev;
|
|
|
|
device_initialize(dev);
|
|
|
|
dev->parent = bus->dev;
|
|
|
|
dev->bus = &snd_hda_bus_type;
|
|
|
|
dev->release = default_release;
|
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 21:59:42 +08:00
|
|
|
dev->groups = hdac_dev_attr_groups;
|
2015-03-03 17:07:24 +08:00
|
|
|
dev_set_name(dev, "%s", name);
|
|
|
|
device_enable_async_suspend(dev);
|
|
|
|
|
|
|
|
codec->bus = bus;
|
|
|
|
codec->addr = addr;
|
|
|
|
codec->type = HDA_DEV_CORE;
|
|
|
|
pm_runtime_set_active(&codec->dev);
|
|
|
|
pm_runtime_get_noresume(&codec->dev);
|
|
|
|
atomic_set(&codec->in_pm, 0);
|
|
|
|
|
|
|
|
err = snd_hdac_bus_add_device(bus, codec);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* fill parameters */
|
|
|
|
codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,
|
|
|
|
AC_PAR_VENDOR_ID);
|
|
|
|
if (codec->vendor_id == -1) {
|
|
|
|
/* read again, hopefully the access method was corrected
|
|
|
|
* in the last read...
|
|
|
|
*/
|
|
|
|
codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,
|
|
|
|
AC_PAR_VENDOR_ID);
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->subsystem_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,
|
|
|
|
AC_PAR_SUBSYSTEM_ID);
|
|
|
|
codec->revision_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,
|
|
|
|
AC_PAR_REV_ID);
|
|
|
|
|
|
|
|
setup_fg_nodes(codec);
|
|
|
|
if (!codec->afg && !codec->mfg) {
|
|
|
|
dev_err(dev, "no AFG or MFG node found\n");
|
|
|
|
err = -ENODEV;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
fg = codec->afg ? codec->afg : codec->mfg;
|
|
|
|
|
|
|
|
err = snd_hdac_refresh_widgets(codec);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
codec->power_caps = snd_hdac_read_parm(codec, fg, AC_PAR_POWER_STATE);
|
|
|
|
/* reread ssid if not set by parameter */
|
2015-04-01 18:43:00 +08:00
|
|
|
if (codec->subsystem_id == -1 || codec->subsystem_id == 0)
|
2015-03-03 17:07:24 +08:00
|
|
|
snd_hdac_read(codec, fg, AC_VERB_GET_SUBSYSTEM_ID, 0,
|
|
|
|
&codec->subsystem_id);
|
|
|
|
|
|
|
|
err = get_codec_vendor_name(codec);
|
|
|
|
if (err < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
codec->chip_name = kasprintf(GFP_KERNEL, "ID %x",
|
|
|
|
codec->vendor_id & 0xffff);
|
|
|
|
if (!codec->chip_name) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
put_device(&codec->dev);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_device_init);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_device_exit - clean up the HD-audio codec base device
|
|
|
|
* @codec: device to clean up
|
|
|
|
*/
|
|
|
|
void snd_hdac_device_exit(struct hdac_device *codec)
|
|
|
|
{
|
2015-03-04 00:22:12 +08:00
|
|
|
pm_runtime_put_noidle(&codec->dev);
|
2015-03-03 17:07:24 +08:00
|
|
|
snd_hdac_bus_remove_device(codec->bus, codec);
|
|
|
|
kfree(codec->vendor_name);
|
|
|
|
kfree(codec->chip_name);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_device_exit);
|
|
|
|
|
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 21:59:42 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_device_register - register the hd-audio codec base device
|
|
|
|
* codec: the device to register
|
|
|
|
*/
|
|
|
|
int snd_hdac_device_register(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = device_add(&codec->dev);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
err = hda_widget_sysfs_init(codec);
|
|
|
|
if (err < 0) {
|
|
|
|
device_del(&codec->dev);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_device_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_device_unregister - unregister the hd-audio codec base device
|
|
|
|
* codec: the device to unregister
|
|
|
|
*/
|
|
|
|
void snd_hdac_device_unregister(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
if (device_is_registered(&codec->dev)) {
|
|
|
|
hda_widget_sysfs_exit(codec);
|
|
|
|
device_del(&codec->dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_device_unregister);
|
|
|
|
|
2015-03-03 17:07:24 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_make_cmd - compose a 32bit command word to be sent to the
|
|
|
|
* HD-audio controller
|
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID to encode
|
|
|
|
* @verb: verb to encode
|
|
|
|
* @parm: parameter to encode
|
|
|
|
*
|
|
|
|
* Return an encoded command verb or -1 for error.
|
|
|
|
*/
|
|
|
|
unsigned int snd_hdac_make_cmd(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
unsigned int verb, unsigned int parm)
|
|
|
|
{
|
|
|
|
u32 val, addr;
|
|
|
|
|
|
|
|
addr = codec->addr;
|
|
|
|
if ((addr & ~0xf) || (nid & ~0x7f) ||
|
|
|
|
(verb & ~0xfff) || (parm & ~0xffff)) {
|
|
|
|
dev_err(&codec->dev, "out of range cmd %x:%x:%x:%x\n",
|
|
|
|
addr, nid, verb, parm);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = addr << 28;
|
|
|
|
val |= (u32)nid << 20;
|
|
|
|
val |= verb << 8;
|
|
|
|
val |= parm;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_make_cmd);
|
|
|
|
|
2015-03-03 22:40:08 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_exec_verb - execute an encoded verb
|
|
|
|
* @codec: the codec object
|
|
|
|
* @cmd: encoded verb to execute
|
|
|
|
* @flags: optional flags, pass zero for default
|
|
|
|
* @res: the pointer to store the result, NULL if running async
|
|
|
|
*
|
|
|
|
* Returns zero if successful, or a negative error code.
|
|
|
|
*
|
|
|
|
* This calls the exec_verb op when set in hdac_codec. If not,
|
|
|
|
* call the default snd_hdac_bus_exec_verb().
|
|
|
|
*/
|
|
|
|
int snd_hdac_exec_verb(struct hdac_device *codec, unsigned int cmd,
|
|
|
|
unsigned int flags, unsigned int *res)
|
|
|
|
{
|
|
|
|
if (codec->exec_verb)
|
|
|
|
return codec->exec_verb(codec, cmd, flags, res);
|
|
|
|
return snd_hdac_bus_exec_verb(codec->bus, codec->addr, cmd, res);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_exec_verb);
|
|
|
|
|
|
|
|
|
2015-03-03 17:07:24 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_read - execute a verb
|
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID to execute a verb
|
|
|
|
* @verb: verb to execute
|
|
|
|
* @parm: parameter for a verb
|
|
|
|
* @res: the pointer to store the result, NULL if running async
|
|
|
|
*
|
|
|
|
* Returns zero if successful, or a negative error code.
|
|
|
|
*/
|
|
|
|
int snd_hdac_read(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
unsigned int verb, unsigned int parm, unsigned int *res)
|
|
|
|
{
|
|
|
|
unsigned int cmd = snd_hdac_make_cmd(codec, nid, verb, parm);
|
|
|
|
|
2015-03-03 22:40:08 +08:00
|
|
|
return snd_hdac_exec_verb(codec, cmd, 0, res);
|
2015-03-03 17:07:24 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_read);
|
|
|
|
|
|
|
|
/**
|
2015-02-26 20:57:47 +08:00
|
|
|
* _snd_hdac_read_parm - read a parmeter
|
2015-03-03 17:07:24 +08:00
|
|
|
*
|
2015-02-26 20:57:47 +08:00
|
|
|
* This function returns zero or an error unlike snd_hdac_read_parm().
|
2015-03-03 17:07:24 +08:00
|
|
|
*/
|
2015-02-26 20:57:47 +08:00
|
|
|
int _snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm,
|
|
|
|
unsigned int *res)
|
2015-03-03 17:07:24 +08:00
|
|
|
{
|
2015-02-26 20:57:47 +08:00
|
|
|
unsigned int cmd;
|
2015-03-03 17:07:24 +08:00
|
|
|
|
2015-02-26 20:57:47 +08:00
|
|
|
cmd = snd_hdac_regmap_encode_verb(nid, AC_VERB_PARAMETERS) | parm;
|
|
|
|
return snd_hdac_regmap_read_raw(codec, cmd, res);
|
2015-03-03 17:07:24 +08:00
|
|
|
}
|
2015-02-26 20:57:47 +08:00
|
|
|
EXPORT_SYMBOL_GPL(_snd_hdac_read_parm);
|
2015-03-03 17:07:24 +08:00
|
|
|
|
2015-03-04 06:29:47 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_read_parm_uncached - read a codec parameter without caching
|
2015-03-03 17:07:24 +08:00
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID to read a parameter
|
|
|
|
* @parm: parameter to read
|
|
|
|
*
|
|
|
|
* Returns -1 for error. If you need to distinguish the error more
|
|
|
|
* strictly, use snd_hdac_read() directly.
|
|
|
|
*/
|
2015-03-04 06:29:47 +08:00
|
|
|
int snd_hdac_read_parm_uncached(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
int parm)
|
2015-03-03 17:07:24 +08:00
|
|
|
{
|
|
|
|
int val;
|
|
|
|
|
2015-03-04 06:29:47 +08:00
|
|
|
if (codec->regmap)
|
|
|
|
regcache_cache_bypass(codec->regmap, true);
|
|
|
|
val = snd_hdac_read_parm(codec, nid, parm);
|
|
|
|
if (codec->regmap)
|
|
|
|
regcache_cache_bypass(codec->regmap, false);
|
2015-03-03 17:07:24 +08:00
|
|
|
return val;
|
|
|
|
}
|
2015-03-04 06:29:47 +08:00
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_read_parm_uncached);
|
|
|
|
|
2015-02-26 15:54:56 +08:00
|
|
|
/**
|
|
|
|
* snd_hdac_override_parm - override read-only parameters
|
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID for the parameter
|
|
|
|
* @parm: the parameter to change
|
|
|
|
* @val: the parameter value to overwrite
|
|
|
|
*/
|
|
|
|
int snd_hdac_override_parm(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
unsigned int parm, unsigned int val)
|
|
|
|
{
|
|
|
|
unsigned int verb = (AC_VERB_PARAMETERS << 8) | (nid << 20) | parm;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!codec->regmap)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
codec->caps_overwriting = true;
|
|
|
|
err = snd_hdac_regmap_write_raw(codec, verb, val);
|
|
|
|
codec->caps_overwriting = false;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_override_parm);
|
2015-03-03 17:07:24 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_get_sub_nodes - get start NID and number of subtree nodes
|
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID to inspect
|
|
|
|
* @start_id: the pointer to store the starting NID
|
|
|
|
*
|
|
|
|
* Returns the number of subtree nodes or zero if not found.
|
2015-03-04 06:29:47 +08:00
|
|
|
* This function reads parameters always without caching.
|
2015-03-03 17:07:24 +08:00
|
|
|
*/
|
|
|
|
int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
hda_nid_t *start_id)
|
|
|
|
{
|
|
|
|
unsigned int parm;
|
|
|
|
|
2015-03-04 06:29:47 +08:00
|
|
|
parm = snd_hdac_read_parm_uncached(codec, nid, AC_PAR_NODE_COUNT);
|
2015-03-03 17:07:24 +08:00
|
|
|
if (parm == -1) {
|
|
|
|
*start_id = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
*start_id = (parm >> 16) & 0x7fff;
|
|
|
|
return (int)(parm & 0x7fff);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_get_sub_nodes);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* look for an AFG and MFG nodes
|
|
|
|
*/
|
|
|
|
static void setup_fg_nodes(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
int i, total_nodes, function_id;
|
|
|
|
hda_nid_t nid;
|
|
|
|
|
|
|
|
total_nodes = snd_hdac_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
|
|
|
|
for (i = 0; i < total_nodes; i++, nid++) {
|
|
|
|
function_id = snd_hdac_read_parm(codec, nid,
|
|
|
|
AC_PAR_FUNCTION_TYPE);
|
|
|
|
switch (function_id & 0xff) {
|
|
|
|
case AC_GRP_AUDIO_FUNCTION:
|
|
|
|
codec->afg = nid;
|
|
|
|
codec->afg_function_id = function_id & 0xff;
|
|
|
|
codec->afg_unsol = (function_id >> 8) & 1;
|
|
|
|
break;
|
|
|
|
case AC_GRP_MODEM_FUNCTION:
|
|
|
|
codec->mfg = nid;
|
|
|
|
codec->mfg_function_id = function_id & 0xff;
|
|
|
|
codec->mfg_unsol = (function_id >> 8) & 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_refresh_widgets - Reset the widget start/end nodes
|
|
|
|
* @codec: the codec object
|
|
|
|
*/
|
|
|
|
int snd_hdac_refresh_widgets(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
hda_nid_t start_nid;
|
|
|
|
int nums;
|
|
|
|
|
|
|
|
nums = snd_hdac_get_sub_nodes(codec, codec->afg, &start_nid);
|
|
|
|
if (!start_nid || nums <= 0 || nums >= 0xff) {
|
|
|
|
dev_err(&codec->dev, "cannot read sub nodes for FG 0x%02x\n",
|
|
|
|
codec->afg);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->num_nodes = nums;
|
|
|
|
codec->start_nid = start_nid;
|
|
|
|
codec->end_nid = start_nid + nums;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_refresh_widgets);
|
|
|
|
|
|
|
|
/* return CONNLIST_LEN parameter of the given widget */
|
|
|
|
static unsigned int get_num_conns(struct hdac_device *codec, hda_nid_t nid)
|
|
|
|
{
|
|
|
|
unsigned int wcaps = get_wcaps(codec, nid);
|
|
|
|
unsigned int parm;
|
|
|
|
|
|
|
|
if (!(wcaps & AC_WCAP_CONN_LIST) &&
|
|
|
|
get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
parm = snd_hdac_read_parm(codec, nid, AC_PAR_CONNLIST_LEN);
|
|
|
|
if (parm == -1)
|
|
|
|
parm = 0;
|
|
|
|
return parm;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_get_connections - get a widget connection list
|
|
|
|
* @codec: the codec object
|
|
|
|
* @nid: NID
|
|
|
|
* @conn_list: the array to store the results, can be NULL
|
|
|
|
* @max_conns: the max size of the given array
|
|
|
|
*
|
|
|
|
* Returns the number of connected widgets, zero for no connection, or a
|
|
|
|
* negative error code. When the number of elements don't fit with the
|
|
|
|
* given array size, it returns -ENOSPC.
|
|
|
|
*
|
|
|
|
* When @conn_list is NULL, it just checks the number of connections.
|
|
|
|
*/
|
|
|
|
int snd_hdac_get_connections(struct hdac_device *codec, hda_nid_t nid,
|
|
|
|
hda_nid_t *conn_list, int max_conns)
|
|
|
|
{
|
|
|
|
unsigned int parm;
|
|
|
|
int i, conn_len, conns, err;
|
|
|
|
unsigned int shift, num_elems, mask;
|
|
|
|
hda_nid_t prev_nid;
|
|
|
|
int null_count = 0;
|
|
|
|
|
|
|
|
parm = get_num_conns(codec, nid);
|
|
|
|
if (!parm)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (parm & AC_CLIST_LONG) {
|
|
|
|
/* long form */
|
|
|
|
shift = 16;
|
|
|
|
num_elems = 2;
|
|
|
|
} else {
|
|
|
|
/* short form */
|
|
|
|
shift = 8;
|
|
|
|
num_elems = 4;
|
|
|
|
}
|
|
|
|
conn_len = parm & AC_CLIST_LENGTH;
|
|
|
|
mask = (1 << (shift-1)) - 1;
|
|
|
|
|
|
|
|
if (!conn_len)
|
|
|
|
return 0; /* no connection */
|
|
|
|
|
|
|
|
if (conn_len == 1) {
|
|
|
|
/* single connection */
|
|
|
|
err = snd_hdac_read(codec, nid, AC_VERB_GET_CONNECT_LIST, 0,
|
|
|
|
&parm);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (conn_list)
|
|
|
|
conn_list[0] = parm & mask;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* multi connection */
|
|
|
|
conns = 0;
|
|
|
|
prev_nid = 0;
|
|
|
|
for (i = 0; i < conn_len; i++) {
|
|
|
|
int range_val;
|
|
|
|
hda_nid_t val, n;
|
|
|
|
|
|
|
|
if (i % num_elems == 0) {
|
|
|
|
err = snd_hdac_read(codec, nid,
|
|
|
|
AC_VERB_GET_CONNECT_LIST, i,
|
|
|
|
&parm);
|
|
|
|
if (err < 0)
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
range_val = !!(parm & (1 << (shift-1))); /* ranges */
|
|
|
|
val = parm & mask;
|
|
|
|
if (val == 0 && null_count++) { /* no second chance */
|
|
|
|
dev_dbg(&codec->dev,
|
|
|
|
"invalid CONNECT_LIST verb %x[%i]:%x\n",
|
|
|
|
nid, i, parm);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
parm >>= shift;
|
|
|
|
if (range_val) {
|
|
|
|
/* ranges between the previous and this one */
|
|
|
|
if (!prev_nid || prev_nid >= val) {
|
|
|
|
dev_warn(&codec->dev,
|
|
|
|
"invalid dep_range_val %x:%x\n",
|
|
|
|
prev_nid, val);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
for (n = prev_nid + 1; n <= val; n++) {
|
|
|
|
if (conn_list) {
|
|
|
|
if (conns >= max_conns)
|
|
|
|
return -ENOSPC;
|
|
|
|
conn_list[conns] = n;
|
|
|
|
}
|
|
|
|
conns++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (conn_list) {
|
|
|
|
if (conns >= max_conns)
|
|
|
|
return -ENOSPC;
|
|
|
|
conn_list[conns] = val;
|
|
|
|
}
|
|
|
|
conns++;
|
|
|
|
}
|
|
|
|
prev_nid = val;
|
|
|
|
}
|
|
|
|
return conns;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_get_connections);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/**
|
|
|
|
* snd_hdac_power_up - increment the runtime pm counter
|
|
|
|
* @codec: the codec object
|
|
|
|
*/
|
|
|
|
void snd_hdac_power_up(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
struct device *dev = &codec->dev;
|
|
|
|
|
|
|
|
if (atomic_read(&codec->in_pm))
|
|
|
|
return;
|
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_power_up);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* snd_hdac_power_up - decrement the runtime pm counter
|
|
|
|
* @codec: the codec object
|
|
|
|
*/
|
|
|
|
void snd_hdac_power_down(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
struct device *dev = &codec->dev;
|
|
|
|
|
|
|
|
if (atomic_read(&codec->in_pm))
|
|
|
|
return;
|
|
|
|
pm_runtime_mark_last_busy(dev);
|
|
|
|
pm_runtime_put_autosuspend(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(snd_hdac_power_down);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* codec vendor labels */
|
|
|
|
struct hda_vendor_id {
|
|
|
|
unsigned int id;
|
|
|
|
const char *name;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct hda_vendor_id hda_vendor_ids[] = {
|
|
|
|
{ 0x1002, "ATI" },
|
|
|
|
{ 0x1013, "Cirrus Logic" },
|
|
|
|
{ 0x1057, "Motorola" },
|
|
|
|
{ 0x1095, "Silicon Image" },
|
|
|
|
{ 0x10de, "Nvidia" },
|
|
|
|
{ 0x10ec, "Realtek" },
|
|
|
|
{ 0x1102, "Creative" },
|
|
|
|
{ 0x1106, "VIA" },
|
|
|
|
{ 0x111d, "IDT" },
|
|
|
|
{ 0x11c1, "LSI" },
|
|
|
|
{ 0x11d4, "Analog Devices" },
|
|
|
|
{ 0x13f6, "C-Media" },
|
|
|
|
{ 0x14f1, "Conexant" },
|
|
|
|
{ 0x17e8, "Chrontel" },
|
|
|
|
{ 0x1854, "LG" },
|
|
|
|
{ 0x1aec, "Wolfson Microelectronics" },
|
|
|
|
{ 0x1af4, "QEMU" },
|
|
|
|
{ 0x434d, "C-Media" },
|
|
|
|
{ 0x8086, "Intel" },
|
|
|
|
{ 0x8384, "SigmaTel" },
|
|
|
|
{} /* terminator */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* store the codec vendor name */
|
|
|
|
static int get_codec_vendor_name(struct hdac_device *codec)
|
|
|
|
{
|
|
|
|
const struct hda_vendor_id *c;
|
|
|
|
u16 vendor_id = codec->vendor_id >> 16;
|
|
|
|
|
|
|
|
for (c = hda_vendor_ids; c->id; c++) {
|
|
|
|
if (c->id == vendor_id) {
|
|
|
|
codec->vendor_name = kstrdup(c->name, GFP_KERNEL);
|
|
|
|
return codec->vendor_name ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
codec->vendor_name = kasprintf(GFP_KERNEL, "Generic %04x", vendor_id);
|
|
|
|
return codec->vendor_name ? 0 : -ENOMEM;
|
|
|
|
}
|