/* * Universal Interface for Intel High Definition Audio Codec * * Generic widget tree parser * * 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 */#include <sound/driver.h>#include <linux/init.h>#include <linux/slab.h>#include <sound/core.h>#include "hda_codec.h"#include "hda_local.h"/* widget node for parsing */struct hda_gnode {	hda_nid_t nid;		/* NID of this widget */	unsigned short nconns;	/* number of input connections */	hda_nid_t *conn_list;	hda_nid_t slist[2];	/* temporay list */	unsigned int wid_caps;	/* widget capabilities */	unsigned char type;	/* widget type */	unsigned char pin_ctl;	/* pin controls */	unsigned char checked;	/* the flag indicates that the node is already parsed */	unsigned int pin_caps;	/* pin widget capabilities */	unsigned int def_cfg;	/* default configuration */	unsigned int amp_out_caps;	/* AMP out capabilities */	unsigned int amp_in_caps;	/* AMP in capabilities */	struct list_head list;};/* patch-specific record */#define MAX_PCM_VOLS	2struct pcm_vol {	struct hda_gnode *node;	/* Node for PCM volume */	unsigned int index;	/* connection of PCM volume */};struct hda_gspec {	struct hda_gnode *dac_node[2];	/* DAC node */	struct hda_gnode *out_pin_node[2];	/* Output pin (Line-Out) node */	struct pcm_vol pcm_vol[MAX_PCM_VOLS];	/* PCM volumes */	unsigned int pcm_vol_nodes;	/* number of PCM volumes */	struct hda_gnode *adc_node;	/* ADC node */	struct hda_gnode *cap_vol_node;	/* Node for capture volume */	unsigned int cur_cap_src;	/* current capture source */	struct hda_input_mux input_mux;	char cap_labels[HDA_MAX_NUM_INPUTS][16];	unsigned int def_amp_in_caps;	unsigned int def_amp_out_caps;	struct hda_pcm pcm_rec;		/* PCM information */	struct list_head nid_list;	/* list of widgets */#ifdef CONFIG_SND_HDA_POWER_SAVE#define MAX_LOOPBACK_AMPS	7	struct hda_loopback_check loopback;	int num_loopbacks;	struct hda_amp_list loopback_list[MAX_LOOPBACK_AMPS + 1];#endif};/* * retrieve the default device type from the default config value */#define defcfg_type(node) (((node)->def_cfg & AC_DEFCFG_DEVICE) >> \			   AC_DEFCFG_DEVICE_SHIFT)#define defcfg_location(node) (((node)->def_cfg & AC_DEFCFG_LOCATION) >> \			       AC_DEFCFG_LOCATION_SHIFT)#define defcfg_port_conn(node) (((node)->def_cfg & AC_DEFCFG_PORT_CONN) >> \				AC_DEFCFG_PORT_CONN_SHIFT)/* * destructor */static void snd_hda_generic_free(struct hda_codec *codec){	struct hda_gspec *spec = codec->spec;	struct hda_gnode *node, *n;	if (! spec)		return;	/* free all widgets */	list_for_each_entry_safe(node, n, &spec->nid_list, list) {		if (node->conn_list != node->slist)			kfree(node->conn_list);		kfree(node);	}	kfree(spec);}/* * add a new widget node and read its attributes */static int add_new_node(struct hda_codec *codec, struct hda_gspec *spec, hda_nid_t nid){	struct hda_gnode *node;	int nconns;	hda_nid_t conn_list[HDA_MAX_CONNECTIONS];	node = kzalloc(sizeof(*node), GFP_KERNEL);	if (node == NULL)		return -ENOMEM;	node->nid = nid;	nconns = snd_hda_get_connections(codec, nid, conn_list,					 HDA_MAX_CONNECTIONS);	if (nconns < 0) {		kfree(node);		return nconns;	}	if (nconns <= ARRAY_SIZE(node->slist))		node->conn_list = node->slist;	else {		node->conn_list = kmalloc(sizeof(hda_nid_t) * nconns,					  GFP_KERNEL);		if (! node->conn_list) {			snd_printk(KERN_ERR "hda-generic: cannot malloc\n");			kfree(node);			return -ENOMEM;		}	}	memcpy(node->conn_list, conn_list, nconns * sizeof(hda_nid_t));	node->nconns = nconns;	node->wid_caps = get_wcaps(codec, nid);	node->type = (node->wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;	if (node->type == AC_WID_PIN) {		node->pin_caps = snd_hda_param_read(codec, node->nid, AC_PAR_PIN_CAP);		node->pin_ctl = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);		node->def_cfg = snd_hda_codec_read(codec, node->nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);	}	if (node->wid_caps & AC_WCAP_OUT_AMP) {		if (node->wid_caps & AC_WCAP_AMP_OVRD)			node->amp_out_caps = snd_hda_param_read(codec, node->nid, AC_PAR_AMP_OUT_CAP);		if (! node->amp_out_caps)			node->amp_out_caps = spec->def_amp_out_caps;	}	if (node->wid_caps & AC_WCAP_IN_AMP) {		if (node->wid_caps & AC_WCAP_AMP_OVRD)			node->amp_in_caps = snd_hda_param_read(codec, node->nid, AC_PAR_AMP_IN_CAP);		if (! node->amp_in_caps)			node->amp_in_caps = spec->def_amp_in_caps;	}	list_add_tail(&node->list, &spec->nid_list);	return 0;}/* * build the AFG subtree */static int build_afg_tree(struct hda_codec *codec){	struct hda_gspec *spec = codec->spec;	int i, nodes, err;	hda_nid_t nid;	snd_assert(spec, return -EINVAL);	spec->def_amp_out_caps = snd_hda_param_read(codec, codec->afg, AC_PAR_AMP_OUT_CAP);	spec->def_amp_in_caps = snd_hda_param_read(codec, codec->afg, AC_PAR_AMP_IN_CAP);	nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);	if (! nid || nodes < 0) {		printk(KERN_ERR "Invalid AFG subtree\n");		return -EINVAL;	}	/* parse all nodes belonging to the AFG */	for (i = 0; i < nodes; i++, nid++) {		if ((err = add_new_node(codec, spec, nid)) < 0)			return err;	}	return 0;}/* * look for the node record for the given NID *//* FIXME: should avoid the braindead linear search */static struct hda_gnode *hda_get_node(struct hda_gspec *spec, hda_nid_t nid){	struct hda_gnode *node;	list_for_each_entry(node, &spec->nid_list, list) {		if (node->nid == nid)			return node;	}	return NULL;}/* * unmute (and set max vol) the output amplifier */static int unmute_output(struct hda_codec *codec, struct hda_gnode *node){	unsigned int val, ofs;	snd_printdd("UNMUTE OUT: NID=0x%x\n", node->nid);	val = (node->amp_out_caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;	ofs = (node->amp_out_caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;	if (val >= ofs)		val -= ofs;	snd_hda_codec_amp_stereo(codec, node->nid, HDA_OUTPUT, 0, 0xff, val);	return 0;}/* * unmute (and set max vol) the input amplifier */static int unmute_input(struct hda_codec *codec, struct hda_gnode *node, unsigned int index){	unsigned int val, ofs;	snd_printdd("UNMUTE IN: NID=0x%x IDX=0x%x\n", node->nid, index);	val = (node->amp_in_caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;	ofs = (node->amp_in_caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;	if (val >= ofs)		val -= ofs;	snd_hda_codec_amp_stereo(codec, node->nid, HDA_INPUT, index, 0xff, val);	return 0;}/* * select the input connection of the given node. */static int select_input_connection(struct hda_codec *codec, struct hda_gnode *node,				   unsigned int index){	snd_printdd("CONNECT: NID=0x%x IDX=0x%x\n", node->nid, index);	return snd_hda_codec_write_cache(codec, node->nid, 0,					 AC_VERB_SET_CONNECT_SEL, index);}/* * clear checked flag of each node in the node list */static void clear_check_flags(struct hda_gspec *spec){	struct hda_gnode *node;	list_for_each_entry(node, &spec->nid_list, list) {		node->checked = 0;	}}/* * parse the output path recursively until reach to an audio output widget * * returns 0 if not found, 1 if found, or a negative error code. */static int parse_output_path(struct hda_codec *codec, struct hda_gspec *spec,			     struct hda_gnode *node, int dac_idx){	int i, err;	struct hda_gnode *child;	if (node->checked)		return 0;	node->checked = 1;	if (node->type == AC_WID_AUD_OUT) {		if (node->wid_caps & AC_WCAP_DIGITAL) {			snd_printdd("Skip Digital OUT node %x\n", node->nid);			return 0;		}		snd_printdd("AUD_OUT found %x\n", node->nid);		if (spec->dac_node[dac_idx]) {			/* already DAC node is assigned, just unmute & connect */			return node == spec->dac_node[dac_idx];		}		spec->dac_node[dac_idx] = node;		if ((node->wid_caps & AC_WCAP_OUT_AMP) &&		    spec->pcm_vol_nodes < MAX_PCM_VOLS) {			spec->pcm_vol[spec->pcm_vol_nodes].node = node;			spec->pcm_vol[spec->pcm_vol_nodes].index = 0;			spec->pcm_vol_nodes++;		}		return 1; /* found */	}	for (i = 0; i < node->nconns; i++) {		child = hda_get_node(spec, node->conn_list[i]);		if (! child)			continue;		err = parse_output_path(codec, spec, child, dac_idx);		if (err < 0)			return err;		else if (err > 0) {			/* found one,			 * select the path, unmute both input and output			 */			if (node->nconns > 1)				select_input_connection(codec, node, i);			unmute_input(codec, node, i);			unmute_output(codec, node);			if (spec->dac_node[dac_idx] &&			    spec->pcm_vol_nodes < MAX_PCM_VOLS &&			    !(spec->dac_node[dac_idx]->wid_caps &			      AC_WCAP_OUT_AMP)) {				if ((node->wid_caps & AC_WCAP_IN_AMP) ||				    (node->wid_caps & AC_WCAP_OUT_AMP)) {					int n = spec->pcm_vol_nodes;					spec->pcm_vol[n].node = node;					spec->pcm_vol[n].index = i;					spec->pcm_vol_nodes++;				}			}			return 1;		}	}	return 0;}/* * Look for the output PIN widget with the given jack type * and parse the output path to that PIN. * * Returns the PIN node when the path to DAC is established. */static struct hda_gnode *parse_output_jack(struct hda_codec *codec,					   struct hda_gspec *spec,					   int jack_type){	struct hda_gnode *node;	int err;	list_for_each_entry(node, &spec->nid_list, list) {		if (node->type != AC_WID_PIN)			continue;		/* output capable? */		if (! (node->pin_caps & AC_PINCAP_OUT))			continue;		if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)			continue; /* unconnected */		if (jack_type >= 0) {			if (jack_type != defcfg_type(node))				continue;			if (node->wid_caps & AC_WCAP_DIGITAL)				continue; /* skip SPDIF */		} else {			/* output as default? */			if (! (node->pin_ctl & AC_PINCTL_OUT_EN))				continue;		}		clear_check_flags(spec);		err = parse_output_path(codec, spec, node, 0);		if (err < 0)			return NULL;		if (! err && spec->out_pin_node[0]) {			err = parse_output_path(codec, spec, node, 1);			if (err < 0)				return NULL;		}		if (err > 0) {			/* unmute the PIN output */			unmute_output(codec, node);			/* set PIN-Out enable */			snd_hda_codec_write_cache(codec, node->nid, 0,					    AC_VERB_SET_PIN_WIDGET_CONTROL,					    AC_PINCTL_OUT_EN |					    ((node->pin_caps & AC_PINCAP_HP_DRV) ?					     AC_PINCTL_HP_EN : 0));			return node;		}	}	return NULL;}/* * parse outputs */static int parse_output(struct hda_codec *codec){	struct hda_gspec *spec = codec->spec;	struct hda_gnode *node;	/*	 * Look for the output PIN widget	 */	/* first, look for the line-out pin */	node = parse_output_jack(codec, spec, AC_JACK_LINE_OUT);	if (node) /* found, remember the PIN node */		spec->out_pin_node[0] = node;	else {		/* if no line-out is found, try speaker out */		node = parse_output_jack(codec, spec, AC_JACK_SPEAKER);		if (node)			spec->out_pin_node[0] = node;	}	/* look for the HP-out pin */	node = parse_output_jack(codec, spec, AC_JACK_HP_OUT);	if (node) {		if (! spec->out_pin_node[0])			spec->out_pin_node[0] = node;		else			spec->out_pin_node[1] = node;	}	if (! spec->out_pin_node[0]) {		/* no line-out or HP pins found,		 * then choose for the first output pin		 */		spec->out_pin_node[0] = parse_output_jack(codec, spec, -1);		if (! spec->out_pin_node[0])			snd_printd("hda_generic: no proper output path found\n");	}	return 0;}/* * input MUX *//* control callbacks */static int capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo){	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);	struct hda_gspec *spec = codec->spec;	return snd_hda_input_mux_info(&spec->input_mux, uinfo);}static int capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol){	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);	struct hda_gspec *spec = codec->spec;	ucontrol->value.enumerated.item[0] = spec->cur_cap_src;	return 0;}static int capture_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol){	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);	struct hda_gspec *spec = codec->spec;	return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,				     spec->adc_node->nid, &spec->cur_cap_src);}/* * return the string name of the given input PIN widget */static const char *get_input_type(struct hda_gnode *node, unsigned int *pinctl){	unsigned int location = defcfg_location(node);	switch (defcfg_type(node)) {	case AC_JACK_LINE_IN:		if ((location & 0x0f) == AC_JACK_LOC_FRONT)			return "Front Line";		return "Line";	case AC_JACK_CD:#if 0		if (pinctl)			*pinctl |= AC_PINCTL_VREF_GRD;#endif		return "CD";	case AC_JACK_AUX:		if ((location & 0x0f) == AC_JACK_LOC_FRONT)			return "Front Aux";		return "Aux";	case AC_JACK_MIC_IN:		if (pinctl &&		    (node->pin_caps &		     (AC_PINCAP_VREF_80 << AC_PINCAP_VREF_SHIFT)))			*pinctl |= AC_PINCTL_VREF_80;		if ((location & 0x0f) == AC_JACK_LOC_FRONT)			return "Front Mic";		return "Mic";	case AC_JACK_SPDIF_IN:		return "SPDIF";	case AC_JACK_DIG_OTHER_IN:		return "Digital";	}	return NULL;}/* * parse the nodes recursively until reach to the input PIN * * returns 0 if not found, 1 if found, or a negative error code. */static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec,			       struct hda_gnode *node){	int i, err;	unsigned int pinctl;	char *label;	const char *type;	if (node->checked)		return 0;	node->checked = 1;	if (node->type != AC_WID_PIN) {		for (i = 0; i < node->nconns; i++) {			struct hda_gnode *child;			child = hda_get_node(spec, node->conn_list[i]);			if (! child)				continue;			err = parse_adc_sub_nodes(codec, spec, child);			if (err < 0)				return err;			if (err > 0) {				/* found one,				 * select the path, unmute both input and output				 */				if (node->nconns > 1)					select_input_connection(codec, node, i);				unmute_input(codec, node, i);				unmute_output(codec, node);				return err;			}		}		return 0;	}	/* input capable? */	if (! (node->pin_caps & AC_PINCAP_IN))		return 0;	if (defcfg_port_conn(node) == AC_JACK_PORT_NONE)		return 0; /* unconnected */	if (node->wid_caps & AC_WCAP_DIGITAL)		return 0; /* skip SPDIF */	if (spec->input_mux.num_items >= HDA_MAX_NUM_INPUTS) {		snd_printk(KERN_ERR "hda_generic: Too many items for capture\n");