brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Universal Interface for Intel High Definition Audio Codec4 *5 * Generic widget tree parser6 *7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>8 */9 10#include <linux/init.h>11#include <linux/slab.h>12#include <linux/export.h>13#include <linux/sort.h>14#include <linux/delay.h>15#include <linux/ctype.h>16#include <linux/string.h>17#include <linux/bitops.h>18#include <linux/module.h>19#include <linux/leds.h>20#include <sound/core.h>21#include <sound/jack.h>22#include <sound/tlv.h>23#include <sound/hda_codec.h>24#include "hda_local.h"25#include "hda_auto_parser.h"26#include "hda_jack.h"27#include "hda_beep.h"28#include "hda_generic.h"29 30 31/**32 * snd_hda_gen_spec_init - initialize hda_gen_spec struct33 * @spec: hda_gen_spec object to initialize34 *35 * Initialize the given hda_gen_spec object.36 */37int snd_hda_gen_spec_init(struct hda_gen_spec *spec)38{39	snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);40	snd_array_init(&spec->paths, sizeof(struct nid_path), 8);41	snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8);42	mutex_init(&spec->pcm_mutex);43	return 0;44}45EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init);46 47/**48 * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template49 * @spec: hda_gen_spec object50 * @name: name string to override the template, NULL if unchanged51 * @temp: template for the new kctl52 *53 * Add a new kctl (actually snd_kcontrol_new to be instantiated later)54 * element based on the given snd_kcontrol_new template @temp and the55 * name string @name to the list in @spec.56 * Returns the newly created object or NULL as error.57 */58struct snd_kcontrol_new *59snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name,60		     const struct snd_kcontrol_new *temp)61{62	struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls);63	if (!knew)64		return NULL;65	*knew = *temp;66	if (name)67		knew->name = kstrdup(name, GFP_KERNEL);68	else if (knew->name)69		knew->name = kstrdup(knew->name, GFP_KERNEL);70	if (!knew->name)71		return NULL;72	return knew;73}74EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl);75 76static void free_kctls(struct hda_gen_spec *spec)77{78	if (spec->kctls.list) {79		struct snd_kcontrol_new *kctl = spec->kctls.list;80		int i;81		for (i = 0; i < spec->kctls.used; i++)82			kfree(kctl[i].name);83	}84	snd_array_free(&spec->kctls);85}86 87static void snd_hda_gen_spec_free(struct hda_gen_spec *spec)88{89	if (!spec)90		return;91	free_kctls(spec);92	snd_array_free(&spec->paths);93	snd_array_free(&spec->loopback_list);94#ifdef CONFIG_SND_HDA_GENERIC_LEDS95	if (spec->led_cdevs[LED_AUDIO_MUTE])96		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MUTE]);97	if (spec->led_cdevs[LED_AUDIO_MICMUTE])98		led_classdev_unregister(spec->led_cdevs[LED_AUDIO_MICMUTE]);99#endif100}101 102/*103 * store user hints104 */105static void parse_user_hints(struct hda_codec *codec)106{107	struct hda_gen_spec *spec = codec->spec;108	int val;109 110	val = snd_hda_get_bool_hint(codec, "jack_detect");111	if (val >= 0)112		codec->no_jack_detect = !val;113	val = snd_hda_get_bool_hint(codec, "inv_jack_detect");114	if (val >= 0)115		codec->inv_jack_detect = !!val;116	val = snd_hda_get_bool_hint(codec, "trigger_sense");117	if (val >= 0)118		codec->no_trigger_sense = !val;119	val = snd_hda_get_bool_hint(codec, "inv_eapd");120	if (val >= 0)121		codec->inv_eapd = !!val;122	val = snd_hda_get_bool_hint(codec, "pcm_format_first");123	if (val >= 0)124		codec->pcm_format_first = !!val;125	val = snd_hda_get_bool_hint(codec, "sticky_stream");126	if (val >= 0)127		codec->no_sticky_stream = !val;128	val = snd_hda_get_bool_hint(codec, "spdif_status_reset");129	if (val >= 0)130		codec->spdif_status_reset = !!val;131	val = snd_hda_get_bool_hint(codec, "pin_amp_workaround");132	if (val >= 0)133		codec->pin_amp_workaround = !!val;134	val = snd_hda_get_bool_hint(codec, "single_adc_amp");135	if (val >= 0)136		codec->single_adc_amp = !!val;137	val = snd_hda_get_bool_hint(codec, "power_save_node");138	if (val >= 0)139		codec->power_save_node = !!val;140 141	val = snd_hda_get_bool_hint(codec, "auto_mute");142	if (val >= 0)143		spec->suppress_auto_mute = !val;144	val = snd_hda_get_bool_hint(codec, "auto_mic");145	if (val >= 0)146		spec->suppress_auto_mic = !val;147	val = snd_hda_get_bool_hint(codec, "line_in_auto_switch");148	if (val >= 0)149		spec->line_in_auto_switch = !!val;150	val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp");151	if (val >= 0)152		spec->auto_mute_via_amp = !!val;153	val = snd_hda_get_bool_hint(codec, "need_dac_fix");154	if (val >= 0)155		spec->need_dac_fix = !!val;156	val = snd_hda_get_bool_hint(codec, "primary_hp");157	if (val >= 0)158		spec->no_primary_hp = !val;159	val = snd_hda_get_bool_hint(codec, "multi_io");160	if (val >= 0)161		spec->no_multi_io = !val;162	val = snd_hda_get_bool_hint(codec, "multi_cap_vol");163	if (val >= 0)164		spec->multi_cap_vol = !!val;165	val = snd_hda_get_bool_hint(codec, "inv_dmic_split");166	if (val >= 0)167		spec->inv_dmic_split = !!val;168	val = snd_hda_get_bool_hint(codec, "indep_hp");169	if (val >= 0)170		spec->indep_hp = !!val;171	val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input");172	if (val >= 0)173		spec->add_stereo_mix_input = !!val;174	/* the following two are just for compatibility */175	val = snd_hda_get_bool_hint(codec, "add_out_jack_modes");176	if (val >= 0)177		spec->add_jack_modes = !!val;178	val = snd_hda_get_bool_hint(codec, "add_in_jack_modes");179	if (val >= 0)180		spec->add_jack_modes = !!val;181	val = snd_hda_get_bool_hint(codec, "add_jack_modes");182	if (val >= 0)183		spec->add_jack_modes = !!val;184	val = snd_hda_get_bool_hint(codec, "power_down_unused");185	if (val >= 0)186		spec->power_down_unused = !!val;187	val = snd_hda_get_bool_hint(codec, "add_hp_mic");188	if (val >= 0)189		spec->hp_mic = !!val;190	val = snd_hda_get_bool_hint(codec, "hp_mic_detect");191	if (val >= 0)192		spec->suppress_hp_mic_detect = !val;193	val = snd_hda_get_bool_hint(codec, "vmaster");194	if (val >= 0)195		spec->suppress_vmaster = !val;196 197	if (!snd_hda_get_int_hint(codec, "mixer_nid", &val))198		spec->mixer_nid = val;199}200 201/*202 * pin control value accesses203 */204 205#define update_pin_ctl(codec, pin, val) \206	snd_hda_codec_write_cache(codec, pin, 0, \207				   AC_VERB_SET_PIN_WIDGET_CONTROL, val)208 209/* restore the pinctl based on the cached value */210static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin)211{212	update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin));213}214 215/* set the pinctl target value and write it if requested */216static void set_pin_target(struct hda_codec *codec, hda_nid_t pin,217			   unsigned int val, bool do_write)218{219	if (!pin)220		return;221	val = snd_hda_correct_pin_ctl(codec, pin, val);222	snd_hda_codec_set_pin_target(codec, pin, val);223	if (do_write)224		update_pin_ctl(codec, pin, val);225}226 227/* set pinctl target values for all given pins */228static void set_pin_targets(struct hda_codec *codec, int num_pins,229			    hda_nid_t *pins, unsigned int val)230{231	int i;232	for (i = 0; i < num_pins; i++)233		set_pin_target(codec, pins[i], val, false);234}235 236/*237 * parsing paths238 */239 240/* return the position of NID in the list, or -1 if not found */241static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)242{243	int i;244	for (i = 0; i < nums; i++)245		if (list[i] == nid)246			return i;247	return -1;248}249 250/* return true if the given NID is contained in the path */251static bool is_nid_contained(struct nid_path *path, hda_nid_t nid)252{253	return find_idx_in_nid_list(nid, path->path, path->depth) >= 0;254}255 256static struct nid_path *get_nid_path(struct hda_codec *codec,257				     hda_nid_t from_nid, hda_nid_t to_nid,258				     int anchor_nid)259{260	struct hda_gen_spec *spec = codec->spec;261	struct nid_path *path;262	int i;263 264	snd_array_for_each(&spec->paths, i, path) {265		if (path->depth <= 0)266			continue;267		if ((!from_nid || path->path[0] == from_nid) &&268		    (!to_nid || path->path[path->depth - 1] == to_nid)) {269			if (!anchor_nid ||270			    (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) ||271			    (anchor_nid < 0 && !is_nid_contained(path, anchor_nid)))272				return path;273		}274	}275	return NULL;276}277 278/**279 * snd_hda_get_path_idx - get the index number corresponding to the path280 * instance281 * @codec: the HDA codec282 * @path: nid_path object283 *284 * The returned index starts from 1, i.e. the actual array index with offset 1,285 * and zero is handled as an invalid path286 */287int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path)288{289	struct hda_gen_spec *spec = codec->spec;290	struct nid_path *array = spec->paths.list;291	ssize_t idx;292 293	if (!spec->paths.used)294		return 0;295	idx = path - array;296	if (idx < 0 || idx >= spec->paths.used)297		return 0;298	return idx + 1;299}300EXPORT_SYMBOL_GPL(snd_hda_get_path_idx);301 302/**303 * snd_hda_get_path_from_idx - get the path instance corresponding to the304 * given index number305 * @codec: the HDA codec306 * @idx: the path index307 */308struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx)309{310	struct hda_gen_spec *spec = codec->spec;311 312	if (idx <= 0 || idx > spec->paths.used)313		return NULL;314	return snd_array_elem(&spec->paths, idx - 1);315}316EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx);317 318/* check whether the given DAC is already found in any existing paths */319static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid)320{321	struct hda_gen_spec *spec = codec->spec;322	const struct nid_path *path;323	int i;324 325	snd_array_for_each(&spec->paths, i, path) {326		if (path->path[0] == nid)327			return true;328	}329	return false;330}331 332/* check whether the given two widgets can be connected */333static bool is_reachable_path(struct hda_codec *codec,334			      hda_nid_t from_nid, hda_nid_t to_nid)335{336	if (!from_nid || !to_nid)337		return false;338	return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0;339}340 341/* nid, dir and idx */342#define AMP_VAL_COMPARE_MASK	(0xffff | (1U << 18) | (0x0f << 19))343 344/* check whether the given ctl is already assigned in any path elements */345static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type)346{347	struct hda_gen_spec *spec = codec->spec;348	const struct nid_path *path;349	int i;350 351	val &= AMP_VAL_COMPARE_MASK;352	snd_array_for_each(&spec->paths, i, path) {353		if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val)354			return true;355	}356	return false;357}358 359/* check whether a control with the given (nid, dir, idx) was assigned */360static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid,361			      int dir, int idx, int type)362{363	unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);364	return is_ctl_used(codec, val, type);365}366 367static void print_nid_path(struct hda_codec *codec,368			   const char *pfx, struct nid_path *path)369{370	char buf[40];371	char *pos = buf;372	int i;373 374	*pos = 0;375	for (i = 0; i < path->depth; i++)376		pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x",377				 pos != buf ? ":" : "",378				 path->path[i]);379 380	codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf);381}382 383/* called recursively */384static bool __parse_nid_path(struct hda_codec *codec,385			     hda_nid_t from_nid, hda_nid_t to_nid,386			     int anchor_nid, struct nid_path *path,387			     int depth)388{389	const hda_nid_t *conn;390	int i, nums;391 392	if (to_nid == anchor_nid)393		anchor_nid = 0; /* anchor passed */394	else if (to_nid == (hda_nid_t)(-anchor_nid))395		return false; /* hit the exclusive nid */396 397	nums = snd_hda_get_conn_list(codec, to_nid, &conn);398	for (i = 0; i < nums; i++) {399		if (conn[i] != from_nid) {400			/* special case: when from_nid is 0,401			 * try to find an empty DAC402			 */403			if (from_nid ||404			    get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT ||405			    is_dac_already_used(codec, conn[i]))406				continue;407		}408		/* anchor is not requested or already passed? */409		if (anchor_nid <= 0)410			goto found;411	}412	if (depth >= MAX_NID_PATH_DEPTH)413		return false;414	for (i = 0; i < nums; i++) {415		unsigned int type;416		type = get_wcaps_type(get_wcaps(codec, conn[i]));417		if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN ||418		    type == AC_WID_PIN)419			continue;420		if (__parse_nid_path(codec, from_nid, conn[i],421				     anchor_nid, path, depth + 1))422			goto found;423	}424	return false;425 426 found:427	path->path[path->depth] = conn[i];428	path->idx[path->depth + 1] = i;429	if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX)430		path->multi[path->depth + 1] = 1;431	path->depth++;432	return true;433}434 435/*436 * snd_hda_parse_nid_path - parse the widget path from the given nid to437 * the target nid438 * @codec: the HDA codec439 * @from_nid: the NID where the path start from440 * @to_nid: the NID where the path ends at441 * @anchor_nid: the anchor indication442 * @path: the path object to store the result443 *444 * Returns true if a matching path is found.445 *446 * The parsing behavior depends on parameters:447 * when @from_nid is 0, try to find an empty DAC;448 * when @anchor_nid is set to a positive value, only paths through the widget449 * with the given value are evaluated.450 * when @anchor_nid is set to a negative value, paths through the widget451 * with the negative of given value are excluded, only other paths are chosen.452 * when @anchor_nid is zero, no special handling about path selection.453 */454static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid,455			    hda_nid_t to_nid, int anchor_nid,456			    struct nid_path *path)457{458	if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) {459		path->path[path->depth] = to_nid;460		path->depth++;461		return true;462	}463	return false;464}465 466/**467 * snd_hda_add_new_path - parse the path between the given NIDs and468 * add to the path list469 * @codec: the HDA codec470 * @from_nid: the NID where the path start from471 * @to_nid: the NID where the path ends at472 * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path()473 *474 * If no valid path is found, returns NULL.475 */476struct nid_path *477snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid,478		     hda_nid_t to_nid, int anchor_nid)479{480	struct hda_gen_spec *spec = codec->spec;481	struct nid_path *path;482 483	if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid))484		return NULL;485 486	/* check whether the path has been already added */487	path = get_nid_path(codec, from_nid, to_nid, anchor_nid);488	if (path)489		return path;490 491	path = snd_array_new(&spec->paths);492	if (!path)493		return NULL;494	memset(path, 0, sizeof(*path));495	if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path))496		return path;497	/* push back */498	spec->paths.used--;499	return NULL;500}501EXPORT_SYMBOL_GPL(snd_hda_add_new_path);502 503/* clear the given path as invalid so that it won't be picked up later */504static void invalidate_nid_path(struct hda_codec *codec, int idx)505{506	struct nid_path *path = snd_hda_get_path_from_idx(codec, idx);507	if (!path)508		return;509	memset(path, 0, sizeof(*path));510}511 512/* return a DAC if paired to the given pin by codec driver */513static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin)514{515	struct hda_gen_spec *spec = codec->spec;516	const hda_nid_t *list = spec->preferred_dacs;517 518	if (!list)519		return 0;520	for (; *list; list += 2)521		if (*list == pin)522			return list[1];523	return 0;524}525 526/* look for an empty DAC slot */527static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin,528			      bool is_digital)529{530	struct hda_gen_spec *spec = codec->spec;531	bool cap_digital;532	int i;533 534	for (i = 0; i < spec->num_all_dacs; i++) {535		hda_nid_t nid = spec->all_dacs[i];536		if (!nid || is_dac_already_used(codec, nid))537			continue;538		cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL);539		if (is_digital != cap_digital)540			continue;541		if (is_reachable_path(codec, nid, pin))542			return nid;543	}544	return 0;545}546 547/* replace the channels in the composed amp value with the given number */548static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs)549{550	val &= ~(0x3U << 16);551	val |= chs << 16;552	return val;553}554 555static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1,556			  hda_nid_t nid2, int dir)557{558	if (!(get_wcaps(codec, nid1) & (1 << (dir + 1))))559		return !(get_wcaps(codec, nid2) & (1 << (dir + 1)));560	return (query_amp_caps(codec, nid1, dir) ==561		query_amp_caps(codec, nid2, dir));562}563 564/* look for a widget suitable for assigning a mute switch in the path */565static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec,566				       struct nid_path *path)567{568	int i;569 570	for (i = path->depth - 1; i >= 0; i--) {571		if (nid_has_mute(codec, path->path[i], HDA_OUTPUT))572			return path->path[i];573		if (i != path->depth - 1 && i != 0 &&574		    nid_has_mute(codec, path->path[i], HDA_INPUT))575			return path->path[i];576	}577	return 0;578}579 580/* look for a widget suitable for assigning a volume ctl in the path */581static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec,582				      struct nid_path *path)583{584	struct hda_gen_spec *spec = codec->spec;585	int i;586 587	for (i = path->depth - 1; i >= 0; i--) {588		hda_nid_t nid = path->path[i];589		if ((spec->out_vol_mask >> nid) & 1)590			continue;591		if (nid_has_volume(codec, nid, HDA_OUTPUT))592			return nid;593	}594	return 0;595}596 597/*598 * path activation / deactivation599 */600 601/* can have the amp-in capability? */602static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx)603{604	hda_nid_t nid = path->path[idx];605	unsigned int caps = get_wcaps(codec, nid);606	unsigned int type = get_wcaps_type(caps);607 608	if (!(caps & AC_WCAP_IN_AMP))609		return false;610	if (type == AC_WID_PIN && idx > 0) /* only for input pins */611		return false;612	return true;613}614 615/* can have the amp-out capability? */616static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx)617{618	hda_nid_t nid = path->path[idx];619	unsigned int caps = get_wcaps(codec, nid);620	unsigned int type = get_wcaps_type(caps);621 622	if (!(caps & AC_WCAP_OUT_AMP))623		return false;624	if (type == AC_WID_PIN && !idx) /* only for output pins */625		return false;626	return true;627}628 629/* check whether the given (nid,dir,idx) is active */630static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid,631			  unsigned int dir, unsigned int idx)632{633	struct hda_gen_spec *spec = codec->spec;634	int type = get_wcaps_type(get_wcaps(codec, nid));635	const struct nid_path *path;636	int i, n;637 638	if (nid == codec->core.afg)639		return true;640 641	snd_array_for_each(&spec->paths, n, path) {642		if (!path->active)643			continue;644		if (codec->power_save_node) {645			if (!path->stream_enabled)646				continue;647			/* ignore unplugged paths except for DAC/ADC */648			if (!(path->pin_enabled || path->pin_fixed) &&649			    type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN)650				continue;651		}652		for (i = 0; i < path->depth; i++) {653			if (path->path[i] == nid) {654				if (dir == HDA_OUTPUT || idx == -1 ||655				    path->idx[i] == idx)656					return true;657				break;658			}659		}660	}661	return false;662}663 664/* check whether the NID is referred by any active paths */665#define is_active_nid_for_any(codec, nid) \666	is_active_nid(codec, nid, HDA_OUTPUT, -1)667 668/* get the default amp value for the target state */669static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid,670				   int dir, unsigned int caps, bool enable)671{672	unsigned int val = 0;673 674	if (caps & AC_AMPCAP_NUM_STEPS) {675		/* set to 0dB */676		if (enable)677			val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;678	}679	if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {680		if (!enable)681			val |= HDA_AMP_MUTE;682	}683	return val;684}685 686/* is this a stereo widget or a stereo-to-mono mix? */687static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir)688{689	unsigned int wcaps = get_wcaps(codec, nid);690	hda_nid_t conn;691 692	if (wcaps & AC_WCAP_STEREO)693		return true;694	if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX)695		return false;696	if (snd_hda_get_num_conns(codec, nid) != 1)697		return false;698	if (snd_hda_get_connections(codec, nid, &conn, 1) < 0)699		return false;700	return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO);701}702 703/* initialize the amp value (only at the first time) */704static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx)705{706	unsigned int caps = query_amp_caps(codec, nid, dir);707	int val = get_amp_val_to_activate(codec, nid, dir, caps, false);708 709	if (is_stereo_amps(codec, nid, dir))710		snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val);711	else712		snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val);713}714 715/* update the amp, doing in stereo or mono depending on NID */716static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx,717		      unsigned int mask, unsigned int val)718{719	if (is_stereo_amps(codec, nid, dir))720		return snd_hda_codec_amp_stereo(codec, nid, dir, idx,721						mask, val);722	else723		return snd_hda_codec_amp_update(codec, nid, 0, dir, idx,724						mask, val);725}726 727/* calculate amp value mask we can modify;728 * if the given amp is controlled by mixers, don't touch it729 */730static unsigned int get_amp_mask_to_modify(struct hda_codec *codec,731					   hda_nid_t nid, int dir, int idx,732					   unsigned int caps)733{734	unsigned int mask = 0xff;735 736	if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) {737		if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL))738			mask &= ~0x80;739	}740	if (caps & AC_AMPCAP_NUM_STEPS) {741		if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||742		    is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))743			mask &= ~0x7f;744	}745	return mask;746}747 748static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir,749			 int idx, int idx_to_check, bool enable)750{751	unsigned int caps;752	unsigned int mask, val;753 754	caps = query_amp_caps(codec, nid, dir);755	val = get_amp_val_to_activate(codec, nid, dir, caps, enable);756	mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps);757	if (!mask)758		return;759 760	val &= mask;761	update_amp(codec, nid, dir, idx, mask, val);762}763 764static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid,765				   int dir, int idx, int idx_to_check,766				   bool enable)767{768	/* check whether the given amp is still used by others */769	if (!enable && is_active_nid(codec, nid, dir, idx_to_check))770		return;771	activate_amp(codec, nid, dir, idx, idx_to_check, enable);772}773 774static void activate_amp_out(struct hda_codec *codec, struct nid_path *path,775			     int i, bool enable)776{777	hda_nid_t nid = path->path[i];778	init_amp(codec, nid, HDA_OUTPUT, 0);779	check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable);780}781 782static void activate_amp_in(struct hda_codec *codec, struct nid_path *path,783			    int i, bool enable, bool add_aamix)784{785	struct hda_gen_spec *spec = codec->spec;786	const hda_nid_t *conn;787	int n, nums, idx;788	int type;789	hda_nid_t nid = path->path[i];790 791	nums = snd_hda_get_conn_list(codec, nid, &conn);792	if (nums < 0)793		return;794	type = get_wcaps_type(get_wcaps(codec, nid));795	if (type == AC_WID_PIN ||796	    (type == AC_WID_AUD_IN && codec->single_adc_amp)) {797		nums = 1;798		idx = 0;799	} else800		idx = path->idx[i];801 802	for (n = 0; n < nums; n++)803		init_amp(codec, nid, HDA_INPUT, n);804 805	/* here is a little bit tricky in comparison with activate_amp_out();806	 * when aa-mixer is available, we need to enable the path as well807	 */808	for (n = 0; n < nums; n++) {809		if (n != idx) {810			if (conn[n] != spec->mixer_merge_nid)811				continue;812			/* when aamix is disabled, force to off */813			if (!add_aamix) {814				activate_amp(codec, nid, HDA_INPUT, n, n, false);815				continue;816			}817		}818		check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable);819	}820}821 822/* sync power of each widget in the given path */823static hda_nid_t path_power_update(struct hda_codec *codec,824				   struct nid_path *path,825				   bool allow_powerdown)826{827	hda_nid_t nid, changed = 0;828	int i, state, power;829 830	for (i = 0; i < path->depth; i++) {831		nid = path->path[i];832		if (!(get_wcaps(codec, nid) & AC_WCAP_POWER))833			continue;834		if (nid == codec->core.afg)835			continue;836		if (!allow_powerdown || is_active_nid_for_any(codec, nid))837			state = AC_PWRST_D0;838		else839			state = AC_PWRST_D3;840		power = snd_hda_codec_read(codec, nid, 0,841					   AC_VERB_GET_POWER_STATE, 0);842		if (power != (state | (state << 4))) {843			snd_hda_codec_write(codec, nid, 0,844					    AC_VERB_SET_POWER_STATE, state);845			changed = nid;846			/* all known codecs seem to be capable to handl847			 * widgets state even in D3, so far.848			 * if any new codecs need to restore the widget849			 * states after D0 transition, call the function850			 * below.851			 */852#if 0 /* disabled */853			if (state == AC_PWRST_D0)854				snd_hdac_regmap_sync_node(&codec->core, nid);855#endif856		}857	}858	return changed;859}860 861/* do sync with the last power state change */862static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid)863{864	if (nid) {865		msleep(10);866		snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0);867	}868}869 870/**871 * snd_hda_activate_path - activate or deactivate the given path872 * @codec: the HDA codec873 * @path: the path to activate/deactivate874 * @enable: flag to activate or not875 * @add_aamix: enable the input from aamix NID876 *877 * If @add_aamix is set, enable the input from aa-mix NID as well (if any).878 */879void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path,880			   bool enable, bool add_aamix)881{882	struct hda_gen_spec *spec = codec->spec;883	int i;884 885	path->active = enable;886 887	/* make sure the widget is powered up */888	if (enable && (spec->power_down_unused || codec->power_save_node))889		path_power_update(codec, path, codec->power_save_node);890 891	for (i = path->depth - 1; i >= 0; i--) {892		hda_nid_t nid = path->path[i];893 894		if (enable && path->multi[i])895			snd_hda_codec_write_cache(codec, nid, 0,896					    AC_VERB_SET_CONNECT_SEL,897					    path->idx[i]);898		if (has_amp_in(codec, path, i))899			activate_amp_in(codec, path, i, enable, add_aamix);900		if (has_amp_out(codec, path, i))901			activate_amp_out(codec, path, i, enable);902	}903}904EXPORT_SYMBOL_GPL(snd_hda_activate_path);905 906/* if the given path is inactive, put widgets into D3 (only if suitable) */907static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path)908{909	struct hda_gen_spec *spec = codec->spec;910 911	if (!(spec->power_down_unused || codec->power_save_node) || path->active)912		return;913	sync_power_state_change(codec, path_power_update(codec, path, true));914}915 916/* turn on/off EAPD on the given pin */917static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable)918{919	struct hda_gen_spec *spec = codec->spec;920	if (spec->own_eapd_ctl ||921	    !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD))922		return;923	if (spec->keep_eapd_on && !enable)924		return;925	if (codec->inv_eapd)926		enable = !enable;927	snd_hda_codec_write_cache(codec, pin, 0,928				   AC_VERB_SET_EAPD_BTLENABLE,929				   enable ? 0x02 : 0x00);930}931 932/* re-initialize the path specified by the given path index */933static void resume_path_from_idx(struct hda_codec *codec, int path_idx)934{935	struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);936	if (path)937		snd_hda_activate_path(codec, path, path->active, false);938}939 940 941/*942 * Helper functions for creating mixer ctl elements943 */944 945static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,946				  struct snd_ctl_elem_value *ucontrol);947static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,948				 struct snd_ctl_elem_value *ucontrol);949static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,950				 struct snd_ctl_elem_value *ucontrol);951 952enum {953	HDA_CTL_WIDGET_VOL,954	HDA_CTL_WIDGET_MUTE,955	HDA_CTL_BIND_MUTE,956};957static const struct snd_kcontrol_new control_templates[] = {958	HDA_CODEC_VOLUME(NULL, 0, 0, 0),959	/* only the put callback is replaced for handling the special mute */960	{961		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,962		.subdevice = HDA_SUBDEV_AMP_FLAG,963		.info = snd_hda_mixer_amp_switch_info,964		.get = snd_hda_mixer_amp_switch_get,965		.put = hda_gen_mixer_mute_put, /* replaced */966		.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),967	},968	{969		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,970		.info = snd_hda_mixer_amp_switch_info,971		.get = hda_gen_bind_mute_get,972		.put = hda_gen_bind_mute_put, /* replaced */973		.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0),974	},975};976 977/* add dynamic controls from template */978static struct snd_kcontrol_new *979add_control(struct hda_gen_spec *spec, int type, const char *name,980		       int cidx, unsigned long val)981{982	struct snd_kcontrol_new *knew;983 984	knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]);985	if (!knew)986		return NULL;987	knew->index = cidx;988	if (get_amp_nid_(val))989		knew->subdevice = HDA_SUBDEV_AMP_FLAG;990	if (knew->access == 0)991		knew->access = SNDRV_CTL_ELEM_ACCESS_READWRITE;992	knew->private_value = val;993	return knew;994}995 996static int add_control_with_pfx(struct hda_gen_spec *spec, int type,997				const char *pfx, const char *dir,998				const char *sfx, int cidx, unsigned long val)999{1000	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];1001	int len;1002 1003	len = snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);1004	if (snd_BUG_ON(len >= sizeof(name)))1005		return -EINVAL;1006	if (!add_control(spec, type, name, cidx, val))1007		return -ENOMEM;1008	return 0;1009}1010 1011#define add_pb_vol_ctrl(spec, type, pfx, val)			\1012	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)1013#define add_pb_sw_ctrl(spec, type, pfx, val)			\1014	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)1015#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\1016	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)1017#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\1018	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)1019 1020static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx,1021		       unsigned int chs, struct nid_path *path)1022{1023	unsigned int val;1024	if (!path)1025		return 0;1026	val = path->ctls[NID_PATH_VOL_CTL];1027	if (!val)1028		return 0;1029	val = amp_val_replace_channels(val, chs);1030	return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val);1031}1032 1033/* return the channel bits suitable for the given path->ctls[] */1034static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path,1035			       int type)1036{1037	int chs = 1; /* mono (left only) */1038	if (path) {1039		hda_nid_t nid = get_amp_nid_(path->ctls[type]);1040		if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO))1041			chs = 3; /* stereo */1042	}1043	return chs;1044}1045 1046static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx,1047			  struct nid_path *path)1048{1049	int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL);1050	return add_vol_ctl(codec, pfx, cidx, chs, path);1051}1052 1053/* create a mute-switch for the given mixer widget;1054 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute1055 */1056static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx,1057		      unsigned int chs, struct nid_path *path)1058{1059	unsigned int val;1060	int type = HDA_CTL_WIDGET_MUTE;1061 1062	if (!path)1063		return 0;1064	val = path->ctls[NID_PATH_MUTE_CTL];1065	if (!val)1066		return 0;1067	val = amp_val_replace_channels(val, chs);1068	if (get_amp_direction_(val) == HDA_INPUT) {1069		hda_nid_t nid = get_amp_nid_(val);1070		int nums = snd_hda_get_num_conns(codec, nid);1071		if (nums > 1) {1072			type = HDA_CTL_BIND_MUTE;1073			val |= nums << 19;1074		}1075	}1076	return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);1077}1078 1079static int add_stereo_sw(struct hda_codec *codec, const char *pfx,1080				  int cidx, struct nid_path *path)1081{1082	int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL);1083	return add_sw_ctl(codec, pfx, cidx, chs, path);1084}1085 1086/* playback mute control with the software mute bit check */1087static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol,1088				struct snd_ctl_elem_value *ucontrol)1089{1090	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);1091	struct hda_gen_spec *spec = codec->spec;1092 1093	if (spec->auto_mute_via_amp) {1094		hda_nid_t nid = get_amp_nid(kcontrol);1095		bool enabled = !((spec->mute_bits >> nid) & 1);1096		ucontrol->value.integer.value[0] &= enabled;1097		ucontrol->value.integer.value[1] &= enabled;1098	}1099}1100 1101static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol,1102				  struct snd_ctl_elem_value *ucontrol)1103{1104	sync_auto_mute_bits(kcontrol, ucontrol);1105	return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);1106}1107 1108/*1109 * Bound mute controls1110 */1111#define AMP_VAL_IDX_SHIFT	191112#define AMP_VAL_IDX_MASK	(0x0f<<19)1113 1114static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol,1115				 struct snd_ctl_elem_value *ucontrol)1116{1117	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);1118	unsigned long pval;1119	int err;1120 1121	mutex_lock(&codec->control_mutex);1122	pval = kcontrol->private_value;1123	kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */1124	err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);1125	kcontrol->private_value = pval;1126	mutex_unlock(&codec->control_mutex);1127	return err;1128}1129 1130static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol,1131				 struct snd_ctl_elem_value *ucontrol)1132{1133	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);1134	unsigned long pval;1135	int i, indices, err = 0, change = 0;1136 1137	sync_auto_mute_bits(kcontrol, ucontrol);1138 1139	mutex_lock(&codec->control_mutex);1140	pval = kcontrol->private_value;1141	indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;1142	for (i = 0; i < indices; i++) {1143		kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) |1144			(i << AMP_VAL_IDX_SHIFT);1145		err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);1146		if (err < 0)1147			break;1148		change |= err;1149	}1150	kcontrol->private_value = pval;1151	mutex_unlock(&codec->control_mutex);1152	return err < 0 ? err : change;1153}1154 1155/* any ctl assigned to the path with the given index? */1156static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type)1157{1158	struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx);1159	return path && path->ctls[ctl_type];1160}1161 1162static const char * const channel_name[] = {1163	"Front", "Surround", "CLFE", "Side", "Back",1164};1165 1166/* give some appropriate ctl name prefix for the given line out channel */1167static const char *get_line_out_pfx(struct hda_codec *codec, int ch,1168				    int *index, int ctl_type)1169{1170	struct hda_gen_spec *spec = codec->spec;1171	struct auto_pin_cfg *cfg = &spec->autocfg;1172 1173	*index = 0;1174	if (cfg->line_outs == 1 && !spec->multi_ios &&1175	    !codec->force_pin_prefix &&1176	    !cfg->hp_outs && !cfg->speaker_outs)1177		return spec->vmaster_mute.hook ? "PCM" : "Master";1178 1179	/* if there is really a single DAC used in the whole output paths,1180	 * use it master (or "PCM" if a vmaster hook is present)1181	 */1182	if (spec->multiout.num_dacs == 1 && !spec->mixer_nid &&1183	    !codec->force_pin_prefix &&1184	    !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0])1185		return spec->vmaster_mute.hook ? "PCM" : "Master";1186 1187	/* multi-io channels */1188	if (ch >= cfg->line_outs)1189		goto fixed_name;1190 1191	switch (cfg->line_out_type) {1192	case AUTO_PIN_SPEAKER_OUT:1193		/* if the primary channel vol/mute is shared with HP volume,1194		 * don't name it as Speaker1195		 */1196		if (!ch && cfg->hp_outs &&1197		    !path_has_mixer(codec, spec->hp_paths[0], ctl_type))1198			break;1199		if (cfg->line_outs == 1)1200			return "Speaker";1201		if (cfg->line_outs == 2)1202			return ch ? "Bass Speaker" : "Speaker";1203		break;1204	case AUTO_PIN_HP_OUT:1205		/* if the primary channel vol/mute is shared with spk volume,1206		 * don't name it as Headphone1207		 */1208		if (!ch && cfg->speaker_outs &&1209		    !path_has_mixer(codec, spec->speaker_paths[0], ctl_type))1210			break;1211		/* for multi-io case, only the primary out */1212		if (ch && spec->multi_ios)1213			break;1214		*index = ch;1215		return "Headphone";1216	case AUTO_PIN_LINE_OUT:1217		/* This deals with the case where one HP or one Speaker or1218		 * one HP + one Speaker need to share the DAC with LO1219		 */1220		if (!ch) {1221			bool hp_lo_shared = false, spk_lo_shared = false;1222 1223			if (cfg->speaker_outs)1224				spk_lo_shared = !path_has_mixer(codec,1225								spec->speaker_paths[0],	ctl_type);1226			if (cfg->hp_outs)1227				hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type);1228			if (hp_lo_shared && spk_lo_shared)1229				return spec->vmaster_mute.hook ? "PCM" : "Master";1230			if (hp_lo_shared)1231				return "Headphone+LO";1232			if (spk_lo_shared)1233				return "Speaker+LO";1234		}1235	}1236 1237	/* for a single channel output, we don't have to name the channel */1238	if (cfg->line_outs == 1 && !spec->multi_ios)1239		return "Line Out";1240 1241 fixed_name:1242	if (ch >= ARRAY_SIZE(channel_name)) {1243		snd_BUG();1244		return "PCM";1245	}1246 1247	return channel_name[ch];1248}1249 1250/*1251 * Parse output paths1252 */1253 1254/* badness definition */1255enum {1256	/* No primary DAC is found for the main output */1257	BAD_NO_PRIMARY_DAC = 0x10000,1258	/* No DAC is found for the extra output */1259	BAD_NO_DAC = 0x4000,1260	/* No possible multi-ios */1261	BAD_MULTI_IO = 0x120,1262	/* No individual DAC for extra output */1263	BAD_NO_EXTRA_DAC = 0x102,1264	/* No individual DAC for extra surrounds */1265	BAD_NO_EXTRA_SURR_DAC = 0x101,1266	/* Primary DAC shared with main surrounds */1267	BAD_SHARED_SURROUND = 0x100,1268	/* No independent HP possible */1269	BAD_NO_INDEP_HP = 0x10,1270	/* Primary DAC shared with main CLFE */1271	BAD_SHARED_CLFE = 0x10,1272	/* Primary DAC shared with extra surrounds */1273	BAD_SHARED_EXTRA_SURROUND = 0x10,1274	/* Volume widget is shared */1275	BAD_SHARED_VOL = 0x10,1276};1277 1278/* look for widgets in the given path which are appropriate for1279 * volume and mute controls, and assign the values to ctls[].1280 *1281 * When no appropriate widget is found in the path, the badness value1282 * is incremented depending on the situation.  The function returns the1283 * total badness for both volume and mute controls.1284 */1285static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path)1286{1287	struct hda_gen_spec *spec = codec->spec;1288	hda_nid_t nid;1289	unsigned int val;1290	int badness = 0;1291 1292	if (!path)1293		return BAD_SHARED_VOL * 2;1294 1295	if (path->ctls[NID_PATH_VOL_CTL] ||1296	    path->ctls[NID_PATH_MUTE_CTL])1297		return 0; /* already evaluated */1298 1299	nid = look_for_out_vol_nid(codec, path);1300	if (nid) {1301		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);1302		if (spec->dac_min_mute)1303			val |= HDA_AMP_VAL_MIN_MUTE;1304		if (is_ctl_used(codec, val, NID_PATH_VOL_CTL))1305			badness += BAD_SHARED_VOL;1306		else1307			path->ctls[NID_PATH_VOL_CTL] = val;1308	} else1309		badness += BAD_SHARED_VOL;1310	nid = look_for_out_mute_nid(codec, path);1311	if (nid) {1312		unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid));1313		if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT ||1314		    nid_has_mute(codec, nid, HDA_OUTPUT))1315			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);1316		else1317			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT);1318		if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL))1319			badness += BAD_SHARED_VOL;1320		else1321			path->ctls[NID_PATH_MUTE_CTL] = val;1322	} else1323		badness += BAD_SHARED_VOL;1324	return badness;1325}1326 1327const struct badness_table hda_main_out_badness = {1328	.no_primary_dac = BAD_NO_PRIMARY_DAC,1329	.no_dac = BAD_NO_DAC,1330	.shared_primary = BAD_NO_PRIMARY_DAC,1331	.shared_surr = BAD_SHARED_SURROUND,1332	.shared_clfe = BAD_SHARED_CLFE,1333	.shared_surr_main = BAD_SHARED_SURROUND,1334};1335EXPORT_SYMBOL_GPL(hda_main_out_badness);1336 1337const struct badness_table hda_extra_out_badness = {1338	.no_primary_dac = BAD_NO_DAC,1339	.no_dac = BAD_NO_DAC,1340	.shared_primary = BAD_NO_EXTRA_DAC,1341	.shared_surr = BAD_SHARED_EXTRA_SURROUND,1342	.shared_clfe = BAD_SHARED_EXTRA_SURROUND,1343	.shared_surr_main = BAD_NO_EXTRA_SURR_DAC,1344};1345EXPORT_SYMBOL_GPL(hda_extra_out_badness);1346 1347/* get the DAC of the primary output corresponding to the given array index */1348static hda_nid_t get_primary_out(struct hda_codec *codec, int idx)1349{1350	struct hda_gen_spec *spec = codec->spec;1351	struct auto_pin_cfg *cfg = &spec->autocfg;1352 1353	if (cfg->line_outs > idx)1354		return spec->private_dac_nids[idx];1355	idx -= cfg->line_outs;1356	if (spec->multi_ios > idx)1357		return spec->multi_io[idx].dac;1358	return 0;1359}1360 1361/* return the DAC if it's reachable, otherwise zero */1362static inline hda_nid_t try_dac(struct hda_codec *codec,1363				hda_nid_t dac, hda_nid_t pin)1364{1365	return is_reachable_path(codec, dac, pin) ? dac : 0;1366}1367 1368/* try to assign DACs to pins and return the resultant badness */1369static int try_assign_dacs(struct hda_codec *codec, int num_outs,1370			   const hda_nid_t *pins, hda_nid_t *dacs,1371			   int *path_idx,1372			   const struct badness_table *bad)1373{1374	struct hda_gen_spec *spec = codec->spec;1375	int i, j;1376	int badness = 0;1377	hda_nid_t dac;1378 1379	if (!num_outs)1380		return 0;1381 1382	for (i = 0; i < num_outs; i++) {1383		struct nid_path *path;1384		hda_nid_t pin = pins[i];1385 1386		if (!spec->preferred_dacs) {1387			path = snd_hda_get_path_from_idx(codec, path_idx[i]);1388			if (path) {1389				badness += assign_out_path_ctls(codec, path);1390				continue;1391			}1392		}1393 1394		dacs[i] = get_preferred_dac(codec, pin);1395		if (dacs[i]) {1396			if (is_dac_already_used(codec, dacs[i]))1397				badness += bad->shared_primary;1398		} else if (spec->preferred_dacs) {1399			badness += BAD_NO_PRIMARY_DAC;1400		}1401 1402		if (!dacs[i])1403			dacs[i] = look_for_dac(codec, pin, false);1404		if (!dacs[i] && !i) {1405			/* try to steal the DAC of surrounds for the front */1406			for (j = 1; j < num_outs; j++) {1407				if (is_reachable_path(codec, dacs[j], pin)) {1408					dacs[0] = dacs[j];1409					dacs[j] = 0;1410					invalidate_nid_path(codec, path_idx[j]);1411					path_idx[j] = 0;1412					break;1413				}1414			}1415		}1416		dac = dacs[i];1417		if (!dac) {1418			if (num_outs > 2)1419				dac = try_dac(codec, get_primary_out(codec, i), pin);1420			if (!dac)1421				dac = try_dac(codec, dacs[0], pin);1422			if (!dac)1423				dac = try_dac(codec, get_primary_out(codec, i), pin);1424			if (dac) {1425				if (!i)1426					badness += bad->shared_primary;1427				else if (i == 1)1428					badness += bad->shared_surr;1429				else1430					badness += bad->shared_clfe;1431			} else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) {1432				dac = spec->private_dac_nids[0];1433				badness += bad->shared_surr_main;1434			} else if (!i)1435				badness += bad->no_primary_dac;1436			else1437				badness += bad->no_dac;1438		}1439		if (!dac)1440			continue;1441		path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid);1442		if (!path && !i && spec->mixer_nid) {1443			/* try with aamix */1444			path = snd_hda_add_new_path(codec, dac, pin, 0);1445		}1446		if (!path) {1447			dacs[i] = 0;1448			badness += bad->no_dac;1449		} else {1450			/* print_nid_path(codec, "output", path); */1451			path->active = true;1452			path_idx[i] = snd_hda_get_path_idx(codec, path);1453			badness += assign_out_path_ctls(codec, path);1454		}1455	}1456 1457	return badness;1458}1459 1460/* return NID if the given pin has only a single connection to a certain DAC */1461static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)1462{1463	struct hda_gen_spec *spec = codec->spec;1464	int i;1465	hda_nid_t nid_found = 0;1466 1467	for (i = 0; i < spec->num_all_dacs; i++) {1468		hda_nid_t nid = spec->all_dacs[i];1469		if (!nid || is_dac_already_used(codec, nid))1470			continue;1471		if (is_reachable_path(codec, nid, pin)) {1472			if (nid_found)1473				return 0;1474			nid_found = nid;1475		}1476	}1477	return nid_found;1478}1479 1480/* check whether the given pin can be a multi-io pin */1481static bool can_be_multiio_pin(struct hda_codec *codec,1482			       unsigned int location, hda_nid_t nid)1483{1484	unsigned int defcfg, caps;1485 1486	defcfg = snd_hda_codec_get_pincfg(codec, nid);1487	if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)1488		return false;1489	if (location && get_defcfg_location(defcfg) != location)1490		return false;1491	caps = snd_hda_query_pin_caps(codec, nid);1492	if (!(caps & AC_PINCAP_OUT))1493		return false;1494	return true;1495}1496 1497/* count the number of input pins that are capable to be multi-io */1498static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin)1499{1500	struct hda_gen_spec *spec = codec->spec;1501	struct auto_pin_cfg *cfg = &spec->autocfg;1502	unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);1503	unsigned int location = get_defcfg_location(defcfg);1504	int type, i;1505	int num_pins = 0;1506 1507	for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {1508		for (i = 0; i < cfg->num_inputs; i++) {1509			if (cfg->inputs[i].type != type)1510				continue;1511			if (can_be_multiio_pin(codec, location,1512					       cfg->inputs[i].pin))1513				num_pins++;1514		}1515	}1516	return num_pins;1517}1518 1519/*1520 * multi-io helper1521 *1522 * When hardwired is set, try to fill ony hardwired pins, and returns1523 * zero if any pins are filled, non-zero if nothing found.1524 * When hardwired is off, try to fill possible input pins, and returns1525 * the badness value.1526 */1527static int fill_multi_ios(struct hda_codec *codec,1528			  hda_nid_t reference_pin,1529			  bool hardwired)1530{1531	struct hda_gen_spec *spec = codec->spec;1532	struct auto_pin_cfg *cfg = &spec->autocfg;1533	int type, i, j, num_pins, old_pins;1534	unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin);1535	unsigned int location = get_defcfg_location(defcfg);1536	int badness = 0;1537	struct nid_path *path;1538 1539	old_pins = spec->multi_ios;1540	if (old_pins >= 2)1541		goto end_fill;1542 1543	num_pins = count_multiio_pins(codec, reference_pin);1544	if (num_pins < 2)1545		goto end_fill;1546 1547	for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {1548		for (i = 0; i < cfg->num_inputs; i++) {1549			hda_nid_t nid = cfg->inputs[i].pin;1550			hda_nid_t dac = 0;1551 1552			if (cfg->inputs[i].type != type)1553				continue;1554			if (!can_be_multiio_pin(codec, location, nid))1555				continue;1556			for (j = 0; j < spec->multi_ios; j++) {1557				if (nid == spec->multi_io[j].pin)1558					break;1559			}1560			if (j < spec->multi_ios)1561				continue;1562 1563			if (hardwired)1564				dac = get_dac_if_single(codec, nid);1565			else if (!dac)1566				dac = look_for_dac(codec, nid, false);1567			if (!dac) {1568				badness++;1569				continue;1570			}1571			path = snd_hda_add_new_path(codec, dac, nid,1572						    -spec->mixer_nid);1573			if (!path) {1574				badness++;1575				continue;1576			}1577			/* print_nid_path(codec, "multiio", path); */1578			spec->multi_io[spec->multi_ios].pin = nid;1579			spec->multi_io[spec->multi_ios].dac = dac;1580			spec->out_paths[cfg->line_outs + spec->multi_ios] =1581				snd_hda_get_path_idx(codec, path);1582			spec->multi_ios++;1583			if (spec->multi_ios >= 2)1584				break;1585		}1586	}1587 end_fill:1588	if (badness)1589		badness = BAD_MULTI_IO;1590	if (old_pins == spec->multi_ios) {1591		if (hardwired)1592			return 1; /* nothing found */1593		else1594			return badness; /* no badness if nothing found */1595	}1596	if (!hardwired && spec->multi_ios < 2) {1597		/* cancel newly assigned paths */1598		spec->paths.used -= spec->multi_ios - old_pins;1599		spec->multi_ios = old_pins;1600		return badness;1601	}1602 1603	/* assign volume and mute controls */1604	for (i = old_pins; i < spec->multi_ios; i++) {1605		path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]);1606		badness += assign_out_path_ctls(codec, path);1607	}1608 1609	return badness;1610}1611 1612/* map DACs for all pins in the list if they are single connections */1613static bool map_singles(struct hda_codec *codec, int outs,1614			const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx)1615{1616	struct hda_gen_spec *spec = codec->spec;1617	int i;1618	bool found = false;1619	for (i = 0; i < outs; i++) {1620		struct nid_path *path;1621		hda_nid_t dac;1622		if (dacs[i])1623			continue;1624		dac = get_dac_if_single(codec, pins[i]);1625		if (!dac)1626			continue;1627		path = snd_hda_add_new_path(codec, dac, pins[i],1628					    -spec->mixer_nid);1629		if (!path && !i && spec->mixer_nid)1630			path = snd_hda_add_new_path(codec, dac, pins[i], 0);1631		if (path) {1632			dacs[i] = dac;1633			found = true;1634			/* print_nid_path(codec, "output", path); */1635			path->active = true;1636			path_idx[i] = snd_hda_get_path_idx(codec, path);1637		}1638	}1639	return found;1640}1641 1642static inline bool has_aamix_out_paths(struct hda_gen_spec *spec)1643{1644	return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] ||1645		spec->aamix_out_paths[2];1646}1647 1648/* create a new path including aamix if available, and return its index */1649static int check_aamix_out_path(struct hda_codec *codec, int path_idx)1650{1651	struct hda_gen_spec *spec = codec->spec;1652	struct nid_path *path;1653	hda_nid_t path_dac, dac, pin;1654 1655	path = snd_hda_get_path_from_idx(codec, path_idx);1656	if (!path || !path->depth ||1657	    is_nid_contained(path, spec->mixer_nid))1658		return 0;1659	path_dac = path->path[0];1660	dac = spec->private_dac_nids[0];1661	pin = path->path[path->depth - 1];1662	path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid);1663	if (!path) {1664		if (dac != path_dac)1665			dac = path_dac;1666		else if (spec->multiout.hp_out_nid[0])1667			dac = spec->multiout.hp_out_nid[0];1668		else if (spec->multiout.extra_out_nid[0])1669			dac = spec->multiout.extra_out_nid[0];1670		else1671			dac = 0;1672		if (dac)1673			path = snd_hda_add_new_path(codec, dac, pin,1674						    spec->mixer_nid);1675	}1676	if (!path)1677		return 0;1678	/* print_nid_path(codec, "output-aamix", path); */1679	path->active = false; /* unused as default */1680	path->pin_fixed = true; /* static route */1681	return snd_hda_get_path_idx(codec, path);1682}1683 1684/* check whether the independent HP is available with the current config */1685static bool indep_hp_possible(struct hda_codec *codec)1686{1687	struct hda_gen_spec *spec = codec->spec;1688	struct auto_pin_cfg *cfg = &spec->autocfg;1689	struct nid_path *path;1690	int i, idx;1691 1692	if (cfg->line_out_type == AUTO_PIN_HP_OUT)1693		idx = spec->out_paths[0];1694	else1695		idx = spec->hp_paths[0];1696	path = snd_hda_get_path_from_idx(codec, idx);1697	if (!path)1698		return false;1699 1700	/* assume no path conflicts unless aamix is involved */1701	if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid))1702		return true;1703 1704	/* check whether output paths contain aamix */1705	for (i = 0; i < cfg->line_outs; i++) {1706		if (spec->out_paths[i] == idx)1707			break;1708		path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);1709		if (path && is_nid_contained(path, spec->mixer_nid))1710			return false;1711	}1712	for (i = 0; i < cfg->speaker_outs; i++) {1713		path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]);1714		if (path && is_nid_contained(path, spec->mixer_nid))1715			return false;1716	}1717 1718	return true;1719}1720 1721/* fill the empty entries in the dac array for speaker/hp with the1722 * shared dac pointed by the paths1723 */1724static void refill_shared_dacs(struct hda_codec *codec, int num_outs,1725			       hda_nid_t *dacs, int *path_idx)1726{1727	struct nid_path *path;1728	int i;1729 1730	for (i = 0; i < num_outs; i++) {1731		if (dacs[i])1732			continue;1733		path = snd_hda_get_path_from_idx(codec, path_idx[i]);1734		if (!path)1735			continue;1736		dacs[i] = path->path[0];1737	}1738}1739 1740/* fill in the dac_nids table from the parsed pin configuration */1741static int fill_and_eval_dacs(struct hda_codec *codec,1742			      bool fill_hardwired,1743			      bool fill_mio_first)1744{1745	struct hda_gen_spec *spec = codec->spec;1746	struct auto_pin_cfg *cfg = &spec->autocfg;1747	int i, err, badness;1748 1749	/* set num_dacs once to full for look_for_dac() */1750	spec->multiout.num_dacs = cfg->line_outs;1751	spec->multiout.dac_nids = spec->private_dac_nids;1752	memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));1753	memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid));1754	memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid));1755	spec->multi_ios = 0;1756	snd_array_free(&spec->paths);1757 1758	/* clear path indices */1759	memset(spec->out_paths, 0, sizeof(spec->out_paths));1760	memset(spec->hp_paths, 0, sizeof(spec->hp_paths));1761	memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths));1762	memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths));1763	memset(spec->digout_paths, 0, sizeof(spec->digout_paths));1764	memset(spec->input_paths, 0, sizeof(spec->input_paths));1765	memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths));1766	memset(&spec->digin_path, 0, sizeof(spec->digin_path));1767 1768	badness = 0;1769 1770	/* fill hard-wired DACs first */1771	if (fill_hardwired) {1772		bool mapped;1773		do {1774			mapped = map_singles(codec, cfg->line_outs,1775					     cfg->line_out_pins,1776					     spec->private_dac_nids,1777					     spec->out_paths);1778			mapped |= map_singles(codec, cfg->hp_outs,1779					      cfg->hp_pins,1780					      spec->multiout.hp_out_nid,1781					      spec->hp_paths);1782			mapped |= map_singles(codec, cfg->speaker_outs,1783					      cfg->speaker_pins,1784					      spec->multiout.extra_out_nid,1785					      spec->speaker_paths);1786			if (!spec->no_multi_io &&1787			    fill_mio_first && cfg->line_outs == 1 &&1788			    cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {1789				err = fill_multi_ios(codec, cfg->line_out_pins[0], true);1790				if (!err)1791					mapped = true;1792			}1793		} while (mapped);1794	}1795 1796	badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins,1797				   spec->private_dac_nids, spec->out_paths,1798				   spec->main_out_badness);1799 1800	if (!spec->no_multi_io && fill_mio_first &&1801	    cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {1802		/* try to fill multi-io first */1803		err = fill_multi_ios(codec, cfg->line_out_pins[0], false);1804		if (err < 0)1805			return err;1806		/* we don't count badness at this stage yet */1807	}1808 1809	if (cfg->line_out_type != AUTO_PIN_HP_OUT) {1810		err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins,1811				      spec->multiout.hp_out_nid,1812				      spec->hp_paths,1813				      spec->extra_out_badness);1814		if (err < 0)1815			return err;1816		badness += err;1817	}1818	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {1819		err = try_assign_dacs(codec, cfg->speaker_outs,1820				      cfg->speaker_pins,1821				      spec->multiout.extra_out_nid,1822				      spec->speaker_paths,1823				      spec->extra_out_badness);1824		if (err < 0)1825			return err;1826		badness += err;1827	}1828	if (!spec->no_multi_io &&1829	    cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {1830		err = fill_multi_ios(codec, cfg->line_out_pins[0], false);1831		if (err < 0)1832			return err;1833		badness += err;1834	}1835 1836	if (spec->mixer_nid) {1837		spec->aamix_out_paths[0] =1838			check_aamix_out_path(codec, spec->out_paths[0]);1839		if (cfg->line_out_type != AUTO_PIN_HP_OUT)1840			spec->aamix_out_paths[1] =1841				check_aamix_out_path(codec, spec->hp_paths[0]);1842		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)1843			spec->aamix_out_paths[2] =1844				check_aamix_out_path(codec, spec->speaker_paths[0]);1845	}1846 1847	if (!spec->no_multi_io &&1848	    cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)1849		if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2)1850			spec->multi_ios = 1; /* give badness */1851 1852	/* re-count num_dacs and squash invalid entries */1853	spec->multiout.num_dacs = 0;1854	for (i = 0; i < cfg->line_outs; i++) {1855		if (spec->private_dac_nids[i])1856			spec->multiout.num_dacs++;1857		else {1858			memmove(spec->private_dac_nids + i,1859				spec->private_dac_nids + i + 1,1860				sizeof(hda_nid_t) * (cfg->line_outs - i - 1));1861			spec->private_dac_nids[cfg->line_outs - 1] = 0;1862		}1863	}1864 1865	spec->ext_channel_count = spec->min_channel_count =1866		spec->multiout.num_dacs * 2;1867 1868	if (spec->multi_ios == 2) {1869		for (i = 0; i < 2; i++)1870			spec->private_dac_nids[spec->multiout.num_dacs++] =1871				spec->multi_io[i].dac;1872	} else if (spec->multi_ios) {1873		spec->multi_ios = 0;1874		badness += BAD_MULTI_IO;1875	}1876 1877	if (spec->indep_hp && !indep_hp_possible(codec))1878		badness += BAD_NO_INDEP_HP;1879 1880	/* re-fill the shared DAC for speaker / headphone */1881	if (cfg->line_out_type != AUTO_PIN_HP_OUT)1882		refill_shared_dacs(codec, cfg->hp_outs,1883				   spec->multiout.hp_out_nid,1884				   spec->hp_paths);1885	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)1886		refill_shared_dacs(codec, cfg->speaker_outs,1887				   spec->multiout.extra_out_nid,1888				   spec->speaker_paths);1889 1890	return badness;1891}1892 1893#define DEBUG_BADNESS1894 1895#ifdef DEBUG_BADNESS1896#define debug_badness(fmt, ...)						\1897	codec_dbg(codec, fmt, ##__VA_ARGS__)1898#else1899#define debug_badness(fmt, ...)						\1900	do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0)1901#endif1902 1903#ifdef DEBUG_BADNESS1904static inline void print_nid_path_idx(struct hda_codec *codec,1905				      const char *pfx, int idx)1906{1907	struct nid_path *path;1908 1909	path = snd_hda_get_path_from_idx(codec, idx);1910	if (path)1911		print_nid_path(codec, pfx, path);1912}1913 1914static void debug_show_configs(struct hda_codec *codec,1915			       struct auto_pin_cfg *cfg)1916{1917	struct hda_gen_spec *spec = codec->spec;1918	static const char * const lo_type[3] = { "LO", "SP", "HP" };1919	int i;1920 1921	debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n",1922		      cfg->line_out_pins[0], cfg->line_out_pins[1],1923		      cfg->line_out_pins[2], cfg->line_out_pins[3],1924		      spec->multiout.dac_nids[0],1925		      spec->multiout.dac_nids[1],1926		      spec->multiout.dac_nids[2],1927		      spec->multiout.dac_nids[3],1928		      lo_type[cfg->line_out_type]);1929	for (i = 0; i < cfg->line_outs; i++)1930		print_nid_path_idx(codec, "  out", spec->out_paths[i]);1931	if (spec->multi_ios > 0)1932		debug_badness("multi_ios(%d) = %x/%x : %x/%x\n",1933			      spec->multi_ios,1934			      spec->multi_io[0].pin, spec->multi_io[1].pin,1935			      spec->multi_io[0].dac, spec->multi_io[1].dac);1936	for (i = 0; i < spec->multi_ios; i++)1937		print_nid_path_idx(codec, "  mio",1938				   spec->out_paths[cfg->line_outs + i]);1939	if (cfg->hp_outs)1940		debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",1941		      cfg->hp_pins[0], cfg->hp_pins[1],1942		      cfg->hp_pins[2], cfg->hp_pins[3],1943		      spec->multiout.hp_out_nid[0],1944		      spec->multiout.hp_out_nid[1],1945		      spec->multiout.hp_out_nid[2],1946		      spec->multiout.hp_out_nid[3]);1947	for (i = 0; i < cfg->hp_outs; i++)1948		print_nid_path_idx(codec, "  hp ", spec->hp_paths[i]);1949	if (cfg->speaker_outs)1950		debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n",1951		      cfg->speaker_pins[0], cfg->speaker_pins[1],1952		      cfg->speaker_pins[2], cfg->speaker_pins[3],1953		      spec->multiout.extra_out_nid[0],1954		      spec->multiout.extra_out_nid[1],1955		      spec->multiout.extra_out_nid[2],1956		      spec->multiout.extra_out_nid[3]);1957	for (i = 0; i < cfg->speaker_outs; i++)1958		print_nid_path_idx(codec, "  spk", spec->speaker_paths[i]);1959	for (i = 0; i < 3; i++)1960		print_nid_path_idx(codec, "  mix", spec->aamix_out_paths[i]);1961}1962#else1963#define debug_show_configs(codec, cfg) /* NOP */1964#endif1965 1966/* find all available DACs of the codec */1967static void fill_all_dac_nids(struct hda_codec *codec)1968{1969	struct hda_gen_spec *spec = codec->spec;1970	hda_nid_t nid;1971 1972	spec->num_all_dacs = 0;1973	memset(spec->all_dacs, 0, sizeof(spec->all_dacs));1974	for_each_hda_codec_node(nid, codec) {1975		if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT)1976			continue;1977		if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) {1978			codec_err(codec, "Too many DACs!\n");1979			break;1980		}1981		spec->all_dacs[spec->num_all_dacs++] = nid;1982	}1983}1984 1985static int parse_output_paths(struct hda_codec *codec)1986{1987	struct hda_gen_spec *spec = codec->spec;1988	struct auto_pin_cfg *cfg = &spec->autocfg;1989	struct auto_pin_cfg *best_cfg;1990	unsigned int val;1991	int best_badness = INT_MAX;1992	int badness;1993	bool fill_hardwired = true, fill_mio_first = true;1994	bool best_wired = true, best_mio = true;1995	bool hp_spk_swapped = false;1996 1997	best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL);1998	if (!best_cfg)1999		return -ENOMEM;2000	*best_cfg = *cfg;2001 2002	for (;;) {2003		badness = fill_and_eval_dacs(codec, fill_hardwired,2004					     fill_mio_first);2005		if (badness < 0) {2006			kfree(best_cfg);2007			return badness;2008		}2009		debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n",2010			      cfg->line_out_type, fill_hardwired, fill_mio_first,2011			      badness);2012		debug_show_configs(codec, cfg);2013		if (badness < best_badness) {2014			best_badness = badness;2015			*best_cfg = *cfg;2016			best_wired = fill_hardwired;2017			best_mio = fill_mio_first;2018		}2019		if (!badness)2020			break;2021		fill_mio_first = !fill_mio_first;2022		if (!fill_mio_first)2023			continue;2024		fill_hardwired = !fill_hardwired;2025		if (!fill_hardwired)2026			continue;2027		if (hp_spk_swapped)2028			break;2029		hp_spk_swapped = true;2030		if (cfg->speaker_outs > 0 &&2031		    cfg->line_out_type == AUTO_PIN_HP_OUT) {2032			cfg->hp_outs = cfg->line_outs;2033			memcpy(cfg->hp_pins, cfg->line_out_pins,2034			       sizeof(cfg->hp_pins));2035			cfg->line_outs = cfg->speaker_outs;2036			memcpy(cfg->line_out_pins, cfg->speaker_pins,2037			       sizeof(cfg->speaker_pins));2038			cfg->speaker_outs = 0;2039			memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));2040			cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;2041			fill_hardwired = true;2042			continue;2043		}2044		if (cfg->hp_outs > 0 &&2045		    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {2046			cfg->speaker_outs = cfg->line_outs;2047			memcpy(cfg->speaker_pins, cfg->line_out_pins,2048			       sizeof(cfg->speaker_pins));2049			cfg->line_outs = cfg->hp_outs;2050			memcpy(cfg->line_out_pins, cfg->hp_pins,2051			       sizeof(cfg->hp_pins));2052			cfg->hp_outs = 0;2053			memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));2054			cfg->line_out_type = AUTO_PIN_HP_OUT;2055			fill_hardwired = true;2056			continue;2057		}2058		break;2059	}2060 2061	if (badness) {2062		debug_badness("==> restoring best_cfg\n");2063		*cfg = *best_cfg;2064		fill_and_eval_dacs(codec, best_wired, best_mio);2065	}2066	debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n",2067		      cfg->line_out_type, best_wired, best_mio);2068	debug_show_configs(codec, cfg);2069 2070	if (cfg->line_out_pins[0]) {2071		struct nid_path *path;2072		path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]);2073		if (path)2074			spec->vmaster_nid = look_for_out_vol_nid(codec, path);2075		if (spec->vmaster_nid) {2076			snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,2077						HDA_OUTPUT, spec->vmaster_tlv);2078			if (spec->dac_min_mute)2079				spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE;2080		}2081	}2082 2083	/* set initial pinctl targets */2084	if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT)2085		val = PIN_HP;2086	else2087		val = PIN_OUT;2088	set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val);2089	if (cfg->line_out_type != AUTO_PIN_HP_OUT)2090		set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP);2091	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {2092		val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT;2093		set_pin_targets(codec, cfg->speaker_outs,2094				cfg->speaker_pins, val);2095	}2096 2097	/* clear indep_hp flag if not available */2098	if (spec->indep_hp && !indep_hp_possible(codec))2099		spec->indep_hp = 0;2100 2101	kfree(best_cfg);2102	return 0;2103}2104 2105/* add playback controls from the parsed DAC table */2106static int create_multi_out_ctls(struct hda_codec *codec,2107				 const struct auto_pin_cfg *cfg)2108{2109	struct hda_gen_spec *spec = codec->spec;2110	int i, err, noutputs;2111 2112	noutputs = cfg->line_outs;2113	if (spec->multi_ios > 0 && cfg->line_outs < 3)2114		noutputs += spec->multi_ios;2115 2116	for (i = 0; i < noutputs; i++) {2117		const char *name;2118		int index;2119		struct nid_path *path;2120 2121		path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]);2122		if (!path)2123			continue;2124 2125		name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL);2126		if (!name || !strcmp(name, "CLFE")) {2127			/* Center/LFE */2128			err = add_vol_ctl(codec, "Center", 0, 1, path);2129			if (err < 0)2130				return err;2131			err = add_vol_ctl(codec, "LFE", 0, 2, path);2132			if (err < 0)2133				return err;2134		} else {2135			err = add_stereo_vol(codec, name, index, path);2136			if (err < 0)2137				return err;2138		}2139 2140		name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL);2141		if (!name || !strcmp(name, "CLFE")) {2142			err = add_sw_ctl(codec, "Center", 0, 1, path);2143			if (err < 0)2144				return err;2145			err = add_sw_ctl(codec, "LFE", 0, 2, path);2146			if (err < 0)2147				return err;2148		} else {2149			err = add_stereo_sw(codec, name, index, path);2150			if (err < 0)2151				return err;2152		}2153	}2154	return 0;2155}2156 2157static int create_extra_out(struct hda_codec *codec, int path_idx,2158			    const char *pfx, int cidx)2159{2160	struct nid_path *path;2161	int err;2162 2163	path = snd_hda_get_path_from_idx(codec, path_idx);2164	if (!path)2165		return 0;2166	err = add_stereo_vol(codec, pfx, cidx, path);2167	if (err < 0)2168		return err;2169	err = add_stereo_sw(codec, pfx, cidx, path);2170	if (err < 0)2171		return err;2172	return 0;2173}2174 2175/* add playback controls for speaker and HP outputs */2176static int create_extra_outs(struct hda_codec *codec, int num_pins,2177			     const int *paths, const char *pfx)2178{2179	int i;2180 2181	for (i = 0; i < num_pins; i++) {2182		const char *name;2183		char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];2184		int err, idx = 0;2185 2186		if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker"))2187			name = "Bass Speaker";2188		else if (num_pins >= 3) {2189			snprintf(tmp, sizeof(tmp), "%s %s",2190				 pfx, channel_name[i]);2191			name = tmp;2192		} else {2193			name = pfx;2194			idx = i;2195		}2196		err = create_extra_out(codec, paths[i], name, idx);2197		if (err < 0)2198			return err;2199	}2200	return 0;2201}2202 2203static int create_hp_out_ctls(struct hda_codec *codec)2204{2205	struct hda_gen_spec *spec = codec->spec;2206	return create_extra_outs(codec, spec->autocfg.hp_outs,2207				 spec->hp_paths,2208				 "Headphone");2209}2210 2211static int create_speaker_out_ctls(struct hda_codec *codec)2212{2213	struct hda_gen_spec *spec = codec->spec;2214	return create_extra_outs(codec, spec->autocfg.speaker_outs,2215				 spec->speaker_paths,2216				 "Speaker");2217}2218 2219/*2220 * independent HP controls2221 */2222 2223static void call_hp_automute(struct hda_codec *codec,2224			     struct hda_jack_callback *jack);2225static int indep_hp_info(struct snd_kcontrol *kcontrol,2226			 struct snd_ctl_elem_info *uinfo)2227{2228	return snd_hda_enum_bool_helper_info(kcontrol, uinfo);2229}2230 2231static int indep_hp_get(struct snd_kcontrol *kcontrol,2232			struct snd_ctl_elem_value *ucontrol)2233{2234	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2235	struct hda_gen_spec *spec = codec->spec;2236	ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled;2237	return 0;2238}2239 2240static void update_aamix_paths(struct hda_codec *codec, bool do_mix,2241			       int nomix_path_idx, int mix_path_idx,2242			       int out_type);2243 2244static int indep_hp_put(struct snd_kcontrol *kcontrol,2245			struct snd_ctl_elem_value *ucontrol)2246{2247	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2248	struct hda_gen_spec *spec = codec->spec;2249	unsigned int select = ucontrol->value.enumerated.item[0];2250	int ret = 0;2251 2252	mutex_lock(&spec->pcm_mutex);2253	if (spec->active_streams) {2254		ret = -EBUSY;2255		goto unlock;2256	}2257 2258	if (spec->indep_hp_enabled != select) {2259		hda_nid_t *dacp;2260		if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)2261			dacp = &spec->private_dac_nids[0];2262		else2263			dacp = &spec->multiout.hp_out_nid[0];2264 2265		/* update HP aamix paths in case it conflicts with indep HP */2266		if (spec->have_aamix_ctl) {2267			if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)2268				update_aamix_paths(codec, spec->aamix_mode,2269						   spec->out_paths[0],2270						   spec->aamix_out_paths[0],2271						   spec->autocfg.line_out_type);2272			else2273				update_aamix_paths(codec, spec->aamix_mode,2274						   spec->hp_paths[0],2275						   spec->aamix_out_paths[1],2276						   AUTO_PIN_HP_OUT);2277		}2278 2279		spec->indep_hp_enabled = select;2280		if (spec->indep_hp_enabled)2281			*dacp = 0;2282		else2283			*dacp = spec->alt_dac_nid;2284 2285		call_hp_automute(codec, NULL);2286		ret = 1;2287	}2288 unlock:2289	mutex_unlock(&spec->pcm_mutex);2290	return ret;2291}2292 2293static const struct snd_kcontrol_new indep_hp_ctl = {2294	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,2295	.name = "Independent HP",2296	.info = indep_hp_info,2297	.get = indep_hp_get,2298	.put = indep_hp_put,2299};2300 2301 2302static int create_indep_hp_ctls(struct hda_codec *codec)2303{2304	struct hda_gen_spec *spec = codec->spec;2305	hda_nid_t dac;2306 2307	if (!spec->indep_hp)2308		return 0;2309	if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)2310		dac = spec->multiout.dac_nids[0];2311	else2312		dac = spec->multiout.hp_out_nid[0];2313	if (!dac) {2314		spec->indep_hp = 0;2315		return 0;2316	}2317 2318	spec->indep_hp_enabled = false;2319	spec->alt_dac_nid = dac;2320	if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl))2321		return -ENOMEM;2322	return 0;2323}2324 2325/*2326 * channel mode enum control2327 */2328 2329static int ch_mode_info(struct snd_kcontrol *kcontrol,2330			struct snd_ctl_elem_info *uinfo)2331{2332	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2333	struct hda_gen_spec *spec = codec->spec;2334	int chs;2335 2336	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;2337	uinfo->count = 1;2338	uinfo->value.enumerated.items = spec->multi_ios + 1;2339	if (uinfo->value.enumerated.item > spec->multi_ios)2340		uinfo->value.enumerated.item = spec->multi_ios;2341	chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count;2342	sprintf(uinfo->value.enumerated.name, "%dch", chs);2343	return 0;2344}2345 2346static int ch_mode_get(struct snd_kcontrol *kcontrol,2347		       struct snd_ctl_elem_value *ucontrol)2348{2349	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2350	struct hda_gen_spec *spec = codec->spec;2351	ucontrol->value.enumerated.item[0] =2352		(spec->ext_channel_count - spec->min_channel_count) / 2;2353	return 0;2354}2355 2356static inline struct nid_path *2357get_multiio_path(struct hda_codec *codec, int idx)2358{2359	struct hda_gen_spec *spec = codec->spec;2360	return snd_hda_get_path_from_idx(codec,2361		spec->out_paths[spec->autocfg.line_outs + idx]);2362}2363 2364static void update_automute_all(struct hda_codec *codec);2365 2366/* Default value to be passed as aamix argument for snd_hda_activate_path();2367 * used for output paths2368 */2369static bool aamix_default(struct hda_gen_spec *spec)2370{2371	return !spec->have_aamix_ctl || spec->aamix_mode;2372}2373 2374static int set_multi_io(struct hda_codec *codec, int idx, bool output)2375{2376	struct hda_gen_spec *spec = codec->spec;2377	hda_nid_t nid = spec->multi_io[idx].pin;2378	struct nid_path *path;2379 2380	path = get_multiio_path(codec, idx);2381	if (!path)2382		return -EINVAL;2383 2384	if (path->active == output)2385		return 0;2386 2387	if (output) {2388		set_pin_target(codec, nid, PIN_OUT, true);2389		snd_hda_activate_path(codec, path, true, aamix_default(spec));2390		set_pin_eapd(codec, nid, true);2391	} else {2392		set_pin_eapd(codec, nid, false);2393		snd_hda_activate_path(codec, path, false, aamix_default(spec));2394		set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true);2395		path_power_down_sync(codec, path);2396	}2397 2398	/* update jack retasking in case it modifies any of them */2399	update_automute_all(codec);2400 2401	return 0;2402}2403 2404static int ch_mode_put(struct snd_kcontrol *kcontrol,2405		       struct snd_ctl_elem_value *ucontrol)2406{2407	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2408	struct hda_gen_spec *spec = codec->spec;2409	int i, ch;2410 2411	ch = ucontrol->value.enumerated.item[0];2412	if (ch < 0 || ch > spec->multi_ios)2413		return -EINVAL;2414	if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2)2415		return 0;2416	spec->ext_channel_count = ch * 2 + spec->min_channel_count;2417	for (i = 0; i < spec->multi_ios; i++)2418		set_multi_io(codec, i, i < ch);2419	spec->multiout.max_channels = max(spec->ext_channel_count,2420					  spec->const_channel_count);2421	if (spec->need_dac_fix)2422		spec->multiout.num_dacs = spec->multiout.max_channels / 2;2423	return 1;2424}2425 2426static const struct snd_kcontrol_new channel_mode_enum = {2427	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,2428	.name = "Channel Mode",2429	.info = ch_mode_info,2430	.get = ch_mode_get,2431	.put = ch_mode_put,2432};2433 2434static int create_multi_channel_mode(struct hda_codec *codec)2435{2436	struct hda_gen_spec *spec = codec->spec;2437 2438	if (spec->multi_ios > 0) {2439		if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum))2440			return -ENOMEM;2441	}2442	return 0;2443}2444 2445/*2446 * aamix loopback enable/disable switch2447 */2448 2449#define loopback_mixing_info	indep_hp_info2450 2451static int loopback_mixing_get(struct snd_kcontrol *kcontrol,2452			       struct snd_ctl_elem_value *ucontrol)2453{2454	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2455	struct hda_gen_spec *spec = codec->spec;2456	ucontrol->value.enumerated.item[0] = spec->aamix_mode;2457	return 0;2458}2459 2460static void update_aamix_paths(struct hda_codec *codec, bool do_mix,2461			       int nomix_path_idx, int mix_path_idx,2462			       int out_type)2463{2464	struct hda_gen_spec *spec = codec->spec;2465	struct nid_path *nomix_path, *mix_path;2466 2467	nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx);2468	mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx);2469	if (!nomix_path || !mix_path)2470		return;2471 2472	/* if HP aamix path is driven from a different DAC and the2473	 * independent HP mode is ON, can't turn on aamix path2474	 */2475	if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled &&2476	    mix_path->path[0] != spec->alt_dac_nid)2477		do_mix = false;2478 2479	if (do_mix) {2480		snd_hda_activate_path(codec, nomix_path, false, true);2481		snd_hda_activate_path(codec, mix_path, true, true);2482		path_power_down_sync(codec, nomix_path);2483	} else {2484		snd_hda_activate_path(codec, mix_path, false, false);2485		snd_hda_activate_path(codec, nomix_path, true, false);2486		path_power_down_sync(codec, mix_path);2487	}2488}2489 2490/* re-initialize the output paths; only called from loopback_mixing_put() */2491static void update_output_paths(struct hda_codec *codec, int num_outs,2492				const int *paths)2493{2494	struct hda_gen_spec *spec = codec->spec;2495	struct nid_path *path;2496	int i;2497 2498	for (i = 0; i < num_outs; i++) {2499		path = snd_hda_get_path_from_idx(codec, paths[i]);2500		if (path)2501			snd_hda_activate_path(codec, path, path->active,2502					      spec->aamix_mode);2503	}2504}2505 2506static int loopback_mixing_put(struct snd_kcontrol *kcontrol,2507			       struct snd_ctl_elem_value *ucontrol)2508{2509	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2510	struct hda_gen_spec *spec = codec->spec;2511	const struct auto_pin_cfg *cfg = &spec->autocfg;2512	unsigned int val = ucontrol->value.enumerated.item[0];2513 2514	if (val == spec->aamix_mode)2515		return 0;2516	spec->aamix_mode = val;2517	if (has_aamix_out_paths(spec)) {2518		update_aamix_paths(codec, val, spec->out_paths[0],2519				   spec->aamix_out_paths[0],2520				   cfg->line_out_type);2521		update_aamix_paths(codec, val, spec->hp_paths[0],2522				   spec->aamix_out_paths[1],2523				   AUTO_PIN_HP_OUT);2524		update_aamix_paths(codec, val, spec->speaker_paths[0],2525				   spec->aamix_out_paths[2],2526				   AUTO_PIN_SPEAKER_OUT);2527	} else {2528		update_output_paths(codec, cfg->line_outs, spec->out_paths);2529		if (cfg->line_out_type != AUTO_PIN_HP_OUT)2530			update_output_paths(codec, cfg->hp_outs, spec->hp_paths);2531		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)2532			update_output_paths(codec, cfg->speaker_outs,2533					    spec->speaker_paths);2534	}2535	return 1;2536}2537 2538static const struct snd_kcontrol_new loopback_mixing_enum = {2539	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,2540	.name = "Loopback Mixing",2541	.info = loopback_mixing_info,2542	.get = loopback_mixing_get,2543	.put = loopback_mixing_put,2544};2545 2546static int create_loopback_mixing_ctl(struct hda_codec *codec)2547{2548	struct hda_gen_spec *spec = codec->spec;2549 2550	if (!spec->mixer_nid)2551		return 0;2552	if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum))2553		return -ENOMEM;2554	spec->have_aamix_ctl = 1;2555	return 0;2556}2557 2558/*2559 * shared headphone/mic handling2560 */2561 2562static void call_update_outputs(struct hda_codec *codec);2563 2564/* for shared I/O, change the pin-control accordingly */2565static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force)2566{2567	struct hda_gen_spec *spec = codec->spec;2568	bool as_mic;2569	unsigned int val;2570	hda_nid_t pin;2571 2572	pin = spec->hp_mic_pin;2573	as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx;2574 2575	if (!force) {2576		val = snd_hda_codec_get_pin_target(codec, pin);2577		if (as_mic) {2578			if (val & PIN_IN)2579				return;2580		} else {2581			if (val & PIN_OUT)2582				return;2583		}2584	}2585 2586	val = snd_hda_get_default_vref(codec, pin);2587	/* if the HP pin doesn't support VREF and the codec driver gives an2588	 * alternative pin, set up the VREF on that pin instead2589	 */2590	if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) {2591		const hda_nid_t vref_pin = spec->shared_mic_vref_pin;2592		unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin);2593		if (vref_val != AC_PINCTL_VREF_HIZ)2594			snd_hda_set_pin_ctl_cache(codec, vref_pin,2595						  PIN_IN | (as_mic ? vref_val : 0));2596	}2597 2598	if (!spec->hp_mic_jack_modes) {2599		if (as_mic)2600			val |= PIN_IN;2601		else2602			val = PIN_HP;2603		set_pin_target(codec, pin, val, true);2604		call_hp_automute(codec, NULL);2605	}2606}2607 2608/* create a shared input with the headphone out */2609static int create_hp_mic(struct hda_codec *codec)2610{2611	struct hda_gen_spec *spec = codec->spec;2612	struct auto_pin_cfg *cfg = &spec->autocfg;2613	unsigned int defcfg;2614	hda_nid_t nid;2615 2616	if (!spec->hp_mic) {2617		if (spec->suppress_hp_mic_detect)2618			return 0;2619		/* automatic detection: only if no input or a single internal2620		 * input pin is found, try to detect the shared hp/mic2621		 */2622		if (cfg->num_inputs > 1)2623			return 0;2624		else if (cfg->num_inputs == 1) {2625			defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);2626			if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)2627				return 0;2628		}2629	}2630 2631	spec->hp_mic = 0; /* clear once */2632	if (cfg->num_inputs >= AUTO_CFG_MAX_INS)2633		return 0;2634 2635	nid = 0;2636	if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0)2637		nid = cfg->line_out_pins[0];2638	else if (cfg->hp_outs > 0)2639		nid = cfg->hp_pins[0];2640	if (!nid)2641		return 0;2642 2643	if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))2644		return 0; /* no input */2645 2646	cfg->inputs[cfg->num_inputs].pin = nid;2647	cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC;2648	cfg->inputs[cfg->num_inputs].is_headphone_mic = 1;2649	cfg->num_inputs++;2650	spec->hp_mic = 1;2651	spec->hp_mic_pin = nid;2652	/* we can't handle auto-mic together with HP-mic */2653	spec->suppress_auto_mic = 1;2654	codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid);2655	return 0;2656}2657 2658/*2659 * output jack mode2660 */2661 2662static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin);2663 2664static const char * const out_jack_texts[] = {2665	"Line Out", "Headphone Out",2666};2667 2668static int out_jack_mode_info(struct snd_kcontrol *kcontrol,2669			      struct snd_ctl_elem_info *uinfo)2670{2671	return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts);2672}2673 2674static int out_jack_mode_get(struct snd_kcontrol *kcontrol,2675			     struct snd_ctl_elem_value *ucontrol)2676{2677	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2678	hda_nid_t nid = kcontrol->private_value;2679	if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP)2680		ucontrol->value.enumerated.item[0] = 1;2681	else2682		ucontrol->value.enumerated.item[0] = 0;2683	return 0;2684}2685 2686static int out_jack_mode_put(struct snd_kcontrol *kcontrol,2687			     struct snd_ctl_elem_value *ucontrol)2688{2689	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2690	hda_nid_t nid = kcontrol->private_value;2691	unsigned int val;2692 2693	val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT;2694	if (snd_hda_codec_get_pin_target(codec, nid) == val)2695		return 0;2696	snd_hda_set_pin_ctl_cache(codec, nid, val);2697	return 1;2698}2699 2700static const struct snd_kcontrol_new out_jack_mode_enum = {2701	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,2702	.info = out_jack_mode_info,2703	.get = out_jack_mode_get,2704	.put = out_jack_mode_put,2705};2706 2707static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx)2708{2709	struct hda_gen_spec *spec = codec->spec;2710	const struct snd_kcontrol_new *kctl;2711	int i;2712 2713	snd_array_for_each(&spec->kctls, i, kctl) {2714		if (!strcmp(kctl->name, name) && kctl->index == idx)2715			return true;2716	}2717	return false;2718}2719 2720static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin,2721			       char *name, size_t name_len)2722{2723	struct hda_gen_spec *spec = codec->spec;2724	int idx = 0;2725 2726	snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx);2727	strlcat(name, " Jack Mode", name_len);2728 2729	for (; find_kctl_name(codec, name, idx); idx++)2730		;2731}2732 2733static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin)2734{2735	struct hda_gen_spec *spec = codec->spec;2736	if (spec->add_jack_modes) {2737		unsigned int pincap = snd_hda_query_pin_caps(codec, pin);2738		if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV))2739			return 2;2740	}2741	return 1;2742}2743 2744static int create_out_jack_modes(struct hda_codec *codec, int num_pins,2745				 hda_nid_t *pins)2746{2747	struct hda_gen_spec *spec = codec->spec;2748	int i;2749 2750	for (i = 0; i < num_pins; i++) {2751		hda_nid_t pin = pins[i];2752		if (pin == spec->hp_mic_pin)2753			continue;2754		if (get_out_jack_num_items(codec, pin) > 1) {2755			struct snd_kcontrol_new *knew;2756			char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];2757			get_jack_mode_name(codec, pin, name, sizeof(name));2758			knew = snd_hda_gen_add_kctl(spec, name,2759						    &out_jack_mode_enum);2760			if (!knew)2761				return -ENOMEM;2762			knew->private_value = pin;2763		}2764	}2765 2766	return 0;2767}2768 2769/*2770 * input jack mode2771 */2772 2773/* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */2774#define NUM_VREFS	62775 2776static const char * const vref_texts[NUM_VREFS] = {2777	"Line In", "Mic 50pc Bias", "Mic 0V Bias",2778	"", "Mic 80pc Bias", "Mic 100pc Bias"2779};2780 2781static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin)2782{2783	unsigned int pincap;2784 2785	pincap = snd_hda_query_pin_caps(codec, pin);2786	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;2787	/* filter out unusual vrefs */2788	pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100);2789	return pincap;2790}2791 2792/* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */2793static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx)2794{2795	unsigned int i, n = 0;2796 2797	for (i = 0; i < NUM_VREFS; i++) {2798		if (vref_caps & (1 << i)) {2799			if (n == item_idx)2800				return i;2801			n++;2802		}2803	}2804	return 0;2805}2806 2807/* convert back from the vref ctl index to the enum item index */2808static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx)2809{2810	unsigned int i, n = 0;2811 2812	for (i = 0; i < NUM_VREFS; i++) {2813		if (i == idx)2814			return n;2815		if (vref_caps & (1 << i))2816			n++;2817	}2818	return 0;2819}2820 2821static int in_jack_mode_info(struct snd_kcontrol *kcontrol,2822			     struct snd_ctl_elem_info *uinfo)2823{2824	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2825	hda_nid_t nid = kcontrol->private_value;2826	unsigned int vref_caps = get_vref_caps(codec, nid);2827 2828	snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps),2829				 vref_texts);2830	/* set the right text */2831	strcpy(uinfo->value.enumerated.name,2832	       vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]);2833	return 0;2834}2835 2836static int in_jack_mode_get(struct snd_kcontrol *kcontrol,2837			    struct snd_ctl_elem_value *ucontrol)2838{2839	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2840	hda_nid_t nid = kcontrol->private_value;2841	unsigned int vref_caps = get_vref_caps(codec, nid);2842	unsigned int idx;2843 2844	idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN;2845	ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx);2846	return 0;2847}2848 2849static int in_jack_mode_put(struct snd_kcontrol *kcontrol,2850			    struct snd_ctl_elem_value *ucontrol)2851{2852	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2853	hda_nid_t nid = kcontrol->private_value;2854	unsigned int vref_caps = get_vref_caps(codec, nid);2855	unsigned int val, idx;2856 2857	val = snd_hda_codec_get_pin_target(codec, nid);2858	idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN);2859	if (idx == ucontrol->value.enumerated.item[0])2860		return 0;2861 2862	val &= ~AC_PINCTL_VREFEN;2863	val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]);2864	snd_hda_set_pin_ctl_cache(codec, nid, val);2865	return 1;2866}2867 2868static const struct snd_kcontrol_new in_jack_mode_enum = {2869	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,2870	.info = in_jack_mode_info,2871	.get = in_jack_mode_get,2872	.put = in_jack_mode_put,2873};2874 2875static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin)2876{2877	struct hda_gen_spec *spec = codec->spec;2878	int nitems = 0;2879	if (spec->add_jack_modes)2880		nitems = hweight32(get_vref_caps(codec, pin));2881	return nitems ? nitems : 1;2882}2883 2884static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin)2885{2886	struct hda_gen_spec *spec = codec->spec;2887	struct snd_kcontrol_new *knew;2888	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];2889	unsigned int defcfg;2890 2891	if (pin == spec->hp_mic_pin)2892		return 0; /* already done in create_out_jack_mode() */2893 2894	/* no jack mode for fixed pins */2895	defcfg = snd_hda_codec_get_pincfg(codec, pin);2896	if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)2897		return 0;2898 2899	/* no multiple vref caps? */2900	if (get_in_jack_num_items(codec, pin) <= 1)2901		return 0;2902 2903	get_jack_mode_name(codec, pin, name, sizeof(name));2904	knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum);2905	if (!knew)2906		return -ENOMEM;2907	knew->private_value = pin;2908	return 0;2909}2910 2911/*2912 * HP/mic shared jack mode2913 */2914static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol,2915				 struct snd_ctl_elem_info *uinfo)2916{2917	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2918	hda_nid_t nid = kcontrol->private_value;2919	int out_jacks = get_out_jack_num_items(codec, nid);2920	int in_jacks = get_in_jack_num_items(codec, nid);2921	const char *text = NULL;2922	int idx;2923 2924	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;2925	uinfo->count = 1;2926	uinfo->value.enumerated.items = out_jacks + in_jacks;2927	if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)2928		uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;2929	idx = uinfo->value.enumerated.item;2930	if (idx < out_jacks) {2931		if (out_jacks > 1)2932			text = out_jack_texts[idx];2933		else2934			text = "Headphone Out";2935	} else {2936		idx -= out_jacks;2937		if (in_jacks > 1) {2938			unsigned int vref_caps = get_vref_caps(codec, nid);2939			text = vref_texts[get_vref_idx(vref_caps, idx)];2940		} else2941			text = "Mic In";2942	}2943 2944	strcpy(uinfo->value.enumerated.name, text);2945	return 0;2946}2947 2948static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid)2949{2950	int out_jacks = get_out_jack_num_items(codec, nid);2951	int in_jacks = get_in_jack_num_items(codec, nid);2952	unsigned int val = snd_hda_codec_get_pin_target(codec, nid);2953	int idx = 0;2954 2955	if (val & PIN_OUT) {2956		if (out_jacks > 1 && val == PIN_HP)2957			idx = 1;2958	} else if (val & PIN_IN) {2959		idx = out_jacks;2960		if (in_jacks > 1) {2961			unsigned int vref_caps = get_vref_caps(codec, nid);2962			val &= AC_PINCTL_VREFEN;2963			idx += cvt_from_vref_idx(vref_caps, val);2964		}2965	}2966	return idx;2967}2968 2969static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol,2970				struct snd_ctl_elem_value *ucontrol)2971{2972	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2973	hda_nid_t nid = kcontrol->private_value;2974	ucontrol->value.enumerated.item[0] =2975		get_cur_hp_mic_jack_mode(codec, nid);2976	return 0;2977}2978 2979static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol,2980				struct snd_ctl_elem_value *ucontrol)2981{2982	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);2983	hda_nid_t nid = kcontrol->private_value;2984	int out_jacks = get_out_jack_num_items(codec, nid);2985	int in_jacks = get_in_jack_num_items(codec, nid);2986	unsigned int val, oldval, idx;2987 2988	oldval = get_cur_hp_mic_jack_mode(codec, nid);2989	idx = ucontrol->value.enumerated.item[0];2990	if (oldval == idx)2991		return 0;2992 2993	if (idx < out_jacks) {2994		if (out_jacks > 1)2995			val = idx ? PIN_HP : PIN_OUT;2996		else2997			val = PIN_HP;2998	} else {2999		idx -= out_jacks;3000		if (in_jacks > 1) {3001			unsigned int vref_caps = get_vref_caps(codec, nid);3002			val = snd_hda_codec_get_pin_target(codec, nid);3003			val &= ~(AC_PINCTL_VREFEN | PIN_HP);3004			val |= get_vref_idx(vref_caps, idx) | PIN_IN;3005		} else3006			val = snd_hda_get_default_vref(codec, nid) | PIN_IN;3007	}3008	snd_hda_set_pin_ctl_cache(codec, nid, val);3009	call_hp_automute(codec, NULL);3010 3011	return 1;3012}3013 3014static const struct snd_kcontrol_new hp_mic_jack_mode_enum = {3015	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,3016	.info = hp_mic_jack_mode_info,3017	.get = hp_mic_jack_mode_get,3018	.put = hp_mic_jack_mode_put,3019};3020 3021static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin)3022{3023	struct hda_gen_spec *spec = codec->spec;3024	struct snd_kcontrol_new *knew;3025 3026	knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode",3027				    &hp_mic_jack_mode_enum);3028	if (!knew)3029		return -ENOMEM;3030	knew->private_value = pin;3031	spec->hp_mic_jack_modes = 1;3032	return 0;3033}3034 3035/*3036 * Parse input paths3037 */3038 3039/* add the powersave loopback-list entry */3040static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx)3041{3042	struct hda_amp_list *list;3043 3044	list = snd_array_new(&spec->loopback_list);3045	if (!list)3046		return -ENOMEM;3047	list->nid = mix;3048	list->dir = HDA_INPUT;3049	list->idx = idx;3050	spec->loopback.amplist = spec->loopback_list.list;3051	return 0;3052}3053 3054/* return true if either a volume or a mute amp is found for the given3055 * aamix path; the amp has to be either in the mixer node or its direct leaf3056 */3057static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid,3058				   hda_nid_t pin, unsigned int *mix_val,3059				   unsigned int *mute_val)3060{3061	int idx, num_conns;3062	const hda_nid_t *list;3063	hda_nid_t nid;3064 3065	idx = snd_hda_get_conn_index(codec, mix_nid, pin, true);3066	if (idx < 0)3067		return false;3068 3069	*mix_val = *mute_val = 0;3070	if (nid_has_volume(codec, mix_nid, HDA_INPUT))3071		*mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);3072	if (nid_has_mute(codec, mix_nid, HDA_INPUT))3073		*mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT);3074	if (*mix_val && *mute_val)3075		return true;3076 3077	/* check leaf node */3078	num_conns = snd_hda_get_conn_list(codec, mix_nid, &list);3079	if (num_conns < idx)3080		return false;3081	nid = list[idx];3082	if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) &&3083	    !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL))3084		*mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);3085	if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) &&3086	    !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL))3087		*mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);3088 3089	return *mix_val || *mute_val;3090}3091 3092/* create input playback/capture controls for the given pin */3093static int new_analog_input(struct hda_codec *codec, int input_idx,3094			    hda_nid_t pin, const char *ctlname, int ctlidx,3095			    hda_nid_t mix_nid)3096{3097	struct hda_gen_spec *spec = codec->spec;3098	struct nid_path *path;3099	unsigned int mix_val, mute_val;3100	int err, idx;3101 3102	if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val))3103		return 0;3104 3105	path = snd_hda_add_new_path(codec, pin, mix_nid, 0);3106	if (!path)3107		return -EINVAL;3108	print_nid_path(codec, "loopback", path);3109	spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path);3110 3111	idx = path->idx[path->depth - 1];3112	if (mix_val) {3113		err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val);3114		if (err < 0)3115			return err;3116		path->ctls[NID_PATH_VOL_CTL] = mix_val;3117	}3118 3119	if (mute_val) {3120		err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val);3121		if (err < 0)3122			return err;3123		path->ctls[NID_PATH_MUTE_CTL] = mute_val;3124	}3125 3126	path->active = true;3127	path->stream_enabled = true; /* no DAC/ADC involved */3128	err = add_loopback_list(spec, mix_nid, idx);3129	if (err < 0)3130		return err;3131 3132	if (spec->mixer_nid != spec->mixer_merge_nid &&3133	    !spec->loopback_merge_path) {3134		path = snd_hda_add_new_path(codec, spec->mixer_nid,3135					    spec->mixer_merge_nid, 0);3136		if (path) {3137			print_nid_path(codec, "loopback-merge", path);3138			path->active = true;3139			path->pin_fixed = true; /* static route */3140			path->stream_enabled = true; /* no DAC/ADC involved */3141			spec->loopback_merge_path =3142				snd_hda_get_path_idx(codec, path);3143		}3144	}3145 3146	return 0;3147}3148 3149static int is_input_pin(struct hda_codec *codec, hda_nid_t nid)3150{3151	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);3152	return (pincap & AC_PINCAP_IN) != 0;3153}3154 3155/* Parse the codec tree and retrieve ADCs */3156static int fill_adc_nids(struct hda_codec *codec)3157{3158	struct hda_gen_spec *spec = codec->spec;3159	hda_nid_t nid;3160	hda_nid_t *adc_nids = spec->adc_nids;3161	int max_nums = ARRAY_SIZE(spec->adc_nids);3162	int nums = 0;3163 3164	for_each_hda_codec_node(nid, codec) {3165		unsigned int caps = get_wcaps(codec, nid);3166		int type = get_wcaps_type(caps);3167 3168		if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))3169			continue;3170		adc_nids[nums] = nid;3171		if (++nums >= max_nums)3172			break;3173	}3174	spec->num_adc_nids = nums;3175 3176	/* copy the detected ADCs to all_adcs[] */3177	spec->num_all_adcs = nums;3178	memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t));3179 3180	return nums;3181}3182 3183/* filter out invalid adc_nids that don't give all active input pins;3184 * if needed, check whether dynamic ADC-switching is available3185 */3186static int check_dyn_adc_switch(struct hda_codec *codec)3187{3188	struct hda_gen_spec *spec = codec->spec;3189	struct hda_input_mux *imux = &spec->input_mux;3190	unsigned int ok_bits;3191	int i, n, nums;3192 3193	nums = 0;3194	ok_bits = 0;3195	for (n = 0; n < spec->num_adc_nids; n++) {3196		for (i = 0; i < imux->num_items; i++) {3197			if (!spec->input_paths[i][n])3198				break;3199		}3200		if (i >= imux->num_items) {3201			ok_bits |= (1 << n);3202			nums++;3203		}3204	}3205 3206	if (!ok_bits) {3207		/* check whether ADC-switch is possible */3208		for (i = 0; i < imux->num_items; i++) {3209			for (n = 0; n < spec->num_adc_nids; n++) {3210				if (spec->input_paths[i][n]) {3211					spec->dyn_adc_idx[i] = n;3212					break;3213				}3214			}3215		}3216 3217		codec_dbg(codec, "enabling ADC switching\n");3218		spec->dyn_adc_switch = 1;3219	} else if (nums != spec->num_adc_nids) {3220		/* shrink the invalid adcs and input paths */3221		nums = 0;3222		for (n = 0; n < spec->num_adc_nids; n++) {3223			if (!(ok_bits & (1 << n)))3224				continue;3225			if (n != nums) {3226				spec->adc_nids[nums] = spec->adc_nids[n];3227				for (i = 0; i < imux->num_items; i++) {3228					invalidate_nid_path(codec,3229						spec->input_paths[i][nums]);3230					spec->input_paths[i][nums] =3231						spec->input_paths[i][n];3232					spec->input_paths[i][n] = 0;3233				}3234			}3235			nums++;3236		}3237		spec->num_adc_nids = nums;3238	}3239 3240	if (imux->num_items == 1 ||3241	    (imux->num_items == 2 && spec->hp_mic)) {3242		codec_dbg(codec, "reducing to a single ADC\n");3243		spec->num_adc_nids = 1; /* reduce to a single ADC */3244	}3245 3246	/* single index for individual volumes ctls */3247	if (!spec->dyn_adc_switch && spec->multi_cap_vol)3248		spec->num_adc_nids = 1;3249 3250	return 0;3251}3252 3253/* parse capture source paths from the given pin and create imux items */3254static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin,3255				int cfg_idx, int num_adcs,3256				const char *label, int anchor)3257{3258	struct hda_gen_spec *spec = codec->spec;3259	struct hda_input_mux *imux = &spec->input_mux;3260	int imux_idx = imux->num_items;3261	bool imux_added = false;3262	int c;3263 3264	for (c = 0; c < num_adcs; c++) {3265		struct nid_path *path;3266		hda_nid_t adc = spec->adc_nids[c];3267 3268		if (!is_reachable_path(codec, pin, adc))3269			continue;3270		path = snd_hda_add_new_path(codec, pin, adc, anchor);3271		if (!path)3272			continue;3273		print_nid_path(codec, "input", path);3274		spec->input_paths[imux_idx][c] =3275			snd_hda_get_path_idx(codec, path);3276 3277		if (!imux_added) {3278			if (spec->hp_mic_pin == pin)3279				spec->hp_mic_mux_idx = imux->num_items;3280			spec->imux_pins[imux->num_items] = pin;3281			snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL);3282			imux_added = true;3283			if (spec->dyn_adc_switch)3284				spec->dyn_adc_idx[imux_idx] = c;3285		}3286	}3287 3288	return 0;3289}3290 3291/*3292 * create playback/capture controls for input pins3293 */3294 3295/* fill the label for each input at first */3296static int fill_input_pin_labels(struct hda_codec *codec)3297{3298	struct hda_gen_spec *spec = codec->spec;3299	const struct auto_pin_cfg *cfg = &spec->autocfg;3300	int i;3301 3302	for (i = 0; i < cfg->num_inputs; i++) {3303		hda_nid_t pin = cfg->inputs[i].pin;3304		const char *label;3305		int j, idx;3306 3307		if (!is_input_pin(codec, pin))3308			continue;3309 3310		label = hda_get_autocfg_input_label(codec, cfg, i);3311		idx = 0;3312		for (j = i - 1; j >= 0; j--) {3313			if (spec->input_labels[j] &&3314			    !strcmp(spec->input_labels[j], label)) {3315				idx = spec->input_label_idxs[j] + 1;3316				break;3317			}3318		}3319 3320		spec->input_labels[i] = label;3321		spec->input_label_idxs[i] = idx;3322	}3323 3324	return 0;3325}3326 3327#define CFG_IDX_MIX	99	/* a dummy cfg->input idx for stereo mix */3328 3329static int create_input_ctls(struct hda_codec *codec)3330{3331	struct hda_gen_spec *spec = codec->spec;3332	const struct auto_pin_cfg *cfg = &spec->autocfg;3333	hda_nid_t mixer = spec->mixer_nid;3334	int num_adcs;3335	int i, err;3336	unsigned int val;3337 3338	num_adcs = fill_adc_nids(codec);3339	if (num_adcs < 0)3340		return 0;3341 3342	err = fill_input_pin_labels(codec);3343	if (err < 0)3344		return err;3345 3346	for (i = 0; i < cfg->num_inputs; i++) {3347		hda_nid_t pin;3348 3349		pin = cfg->inputs[i].pin;3350		if (!is_input_pin(codec, pin))3351			continue;3352 3353		val = PIN_IN;3354		if (cfg->inputs[i].type == AUTO_PIN_MIC)3355			val |= snd_hda_get_default_vref(codec, pin);3356		if (pin != spec->hp_mic_pin &&3357		    !snd_hda_codec_get_pin_target(codec, pin))3358			set_pin_target(codec, pin, val, false);3359 3360		if (mixer) {3361			if (is_reachable_path(codec, pin, mixer)) {3362				err = new_analog_input(codec, i, pin,3363						       spec->input_labels[i],3364						       spec->input_label_idxs[i],3365						       mixer);3366				if (err < 0)3367					return err;3368			}3369		}3370 3371		err = parse_capture_source(codec, pin, i, num_adcs,3372					   spec->input_labels[i], -mixer);3373		if (err < 0)3374			return err;3375 3376		if (spec->add_jack_modes) {3377			err = create_in_jack_mode(codec, pin);3378			if (err < 0)3379				return err;3380		}3381	}3382 3383	/* add stereo mix when explicitly enabled via hint */3384	if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) {3385		err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs,3386					   "Stereo Mix", 0);3387		if (err < 0)3388			return err;3389		else3390			spec->suppress_auto_mic = 1;3391	}3392 3393	return 0;3394}3395 3396 3397/*3398 * input source mux3399 */3400 3401/* get the input path specified by the given adc and imux indices */3402static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx)3403{3404	struct hda_gen_spec *spec = codec->spec;3405	if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) {3406		snd_BUG();3407		return NULL;3408	}3409	if (spec->dyn_adc_switch)3410		adc_idx = spec->dyn_adc_idx[imux_idx];3411	if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) {3412		snd_BUG();3413		return NULL;3414	}3415	return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]);3416}3417 3418static int mux_select(struct hda_codec *codec, unsigned int adc_idx,3419		      unsigned int idx);3420 3421static int mux_enum_info(struct snd_kcontrol *kcontrol,3422			 struct snd_ctl_elem_info *uinfo)3423{3424	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);3425	struct hda_gen_spec *spec = codec->spec;3426	return snd_hda_input_mux_info(&spec->input_mux, uinfo);3427}3428 3429static int mux_enum_get(struct snd_kcontrol *kcontrol,3430			struct snd_ctl_elem_value *ucontrol)3431{3432	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);3433	struct hda_gen_spec *spec = codec->spec;3434	/* the ctls are created at once with multiple counts */3435	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);3436 3437	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];3438	return 0;3439}3440 3441static int mux_enum_put(struct snd_kcontrol *kcontrol,3442			    struct snd_ctl_elem_value *ucontrol)3443{3444	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);3445	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);3446	return mux_select(codec, adc_idx,3447			  ucontrol->value.enumerated.item[0]);3448}3449 3450static const struct snd_kcontrol_new cap_src_temp = {3451	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,3452	.name = "Input Source",3453	.info = mux_enum_info,3454	.get = mux_enum_get,3455	.put = mux_enum_put,3456};3457 3458/*3459 * capture volume and capture switch ctls3460 */3461 3462typedef int (*put_call_t)(struct snd_kcontrol *kcontrol,3463			  struct snd_ctl_elem_value *ucontrol);3464 3465/* call the given amp update function for all amps in the imux list at once */3466static int cap_put_caller(struct snd_kcontrol *kcontrol,3467			  struct snd_ctl_elem_value *ucontrol,3468			  put_call_t func, int type)3469{3470	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);3471	struct hda_gen_spec *spec = codec->spec;3472	const struct hda_input_mux *imux;3473	struct nid_path *path;3474	int i, adc_idx, ret, err = 0;3475 3476	imux = &spec->input_mux;3477	adc_idx = kcontrol->id.index;3478	mutex_lock(&codec->control_mutex);3479	for (i = 0; i < imux->num_items; i++) {3480		path = get_input_path(codec, adc_idx, i);3481		if (!path || !path->ctls[type])3482			continue;3483		kcontrol->private_value = path->ctls[type];3484		ret = func(kcontrol, ucontrol);3485		if (ret < 0) {3486			err = ret;3487			break;3488		}3489		if (ret > 0)3490			err = 1;3491	}3492	mutex_unlock(&codec->control_mutex);3493	if (err >= 0 && spec->cap_sync_hook)3494		spec->cap_sync_hook(codec, kcontrol, ucontrol);3495	return err;3496}3497 3498/* capture volume ctl callbacks */3499#define cap_vol_info		snd_hda_mixer_amp_volume_info3500#define cap_vol_get		snd_hda_mixer_amp_volume_get3501#define cap_vol_tlv		snd_hda_mixer_amp_tlv3502 3503static int cap_vol_put(struct snd_kcontrol *kcontrol,3504		       struct snd_ctl_elem_value *ucontrol)3505{3506	return cap_put_caller(kcontrol, ucontrol,3507			      snd_hda_mixer_amp_volume_put,3508			      NID_PATH_VOL_CTL);3509}3510 3511static const struct snd_kcontrol_new cap_vol_temp = {3512	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,3513	.name = "Capture Volume",3514	.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |3515		   SNDRV_CTL_ELEM_ACCESS_TLV_READ |3516		   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK),3517	.info = cap_vol_info,3518	.get = cap_vol_get,3519	.put = cap_vol_put,3520	.tlv = { .c = cap_vol_tlv },3521};3522 3523/* capture switch ctl callbacks */3524#define cap_sw_info		snd_ctl_boolean_stereo_info3525#define cap_sw_get		snd_hda_mixer_amp_switch_get3526 3527static int cap_sw_put(struct snd_kcontrol *kcontrol,3528		      struct snd_ctl_elem_value *ucontrol)3529{3530	return cap_put_caller(kcontrol, ucontrol,3531			      snd_hda_mixer_amp_switch_put,3532			      NID_PATH_MUTE_CTL);3533}3534 3535static const struct snd_kcontrol_new cap_sw_temp = {3536	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,3537	.name = "Capture Switch",3538	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,3539	.info = cap_sw_info,3540	.get = cap_sw_get,3541	.put = cap_sw_put,3542};3543 3544static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path)3545{3546	hda_nid_t nid;3547	int i, depth;3548 3549	path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0;3550	for (depth = 0; depth < 3; depth++) {3551		if (depth >= path->depth)3552			return -EINVAL;3553		i = path->depth - depth - 1;3554		nid = path->path[i];3555		if (!path->ctls[NID_PATH_VOL_CTL]) {3556			if (nid_has_volume(codec, nid, HDA_OUTPUT))3557				path->ctls[NID_PATH_VOL_CTL] =3558					HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);3559			else if (nid_has_volume(codec, nid, HDA_INPUT)) {3560				int idx = path->idx[i];3561				if (!depth && codec->single_adc_amp)3562					idx = 0;3563				path->ctls[NID_PATH_VOL_CTL] =3564					HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);3565			}3566		}3567		if (!path->ctls[NID_PATH_MUTE_CTL]) {3568			if (nid_has_mute(codec, nid, HDA_OUTPUT))3569				path->ctls[NID_PATH_MUTE_CTL] =3570					HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);3571			else if (nid_has_mute(codec, nid, HDA_INPUT)) {3572				int idx = path->idx[i];3573				if (!depth && codec->single_adc_amp)3574					idx = 0;3575				path->ctls[NID_PATH_MUTE_CTL] =3576					HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT);3577			}3578		}3579	}3580	return 0;3581}3582 3583static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid)3584{3585	struct hda_gen_spec *spec = codec->spec;3586	struct auto_pin_cfg *cfg = &spec->autocfg;3587	unsigned int val;3588	int i;3589 3590	if (!spec->inv_dmic_split)3591		return false;3592	for (i = 0; i < cfg->num_inputs; i++) {3593		if (cfg->inputs[i].pin != nid)3594			continue;3595		if (cfg->inputs[i].type != AUTO_PIN_MIC)3596			return false;3597		val = snd_hda_codec_get_pincfg(codec, nid);3598		return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT;3599	}3600	return false;3601}3602 3603/* capture switch put callback for a single control with hook call */3604static int cap_single_sw_put(struct snd_kcontrol *kcontrol,3605			     struct snd_ctl_elem_value *ucontrol)3606{3607	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);3608	struct hda_gen_spec *spec = codec->spec;3609	int ret;3610 3611	ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);3612	if (ret < 0)3613		return ret;3614 3615	if (spec->cap_sync_hook)3616		spec->cap_sync_hook(codec, kcontrol, ucontrol);3617 3618	return ret;3619}3620 3621static int add_single_cap_ctl(struct hda_codec *codec, const char *label,3622			      int idx, bool is_switch, unsigned int ctl,3623			      bool inv_dmic)3624{3625	struct hda_gen_spec *spec = codec->spec;3626	char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];3627	int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL;3628	const char *sfx = is_switch ? "Switch" : "Volume";3629	unsigned int chs = inv_dmic ? 1 : 3;3630	struct snd_kcontrol_new *knew;3631 3632	if (!ctl)3633		return 0;3634 3635	if (label)3636		snprintf(tmpname, sizeof(tmpname),3637			 "%s Capture %s", label, sfx);3638	else3639		snprintf(tmpname, sizeof(tmpname),3640			 "Capture %s", sfx);3641	knew = add_control(spec, type, tmpname, idx,3642			   amp_val_replace_channels(ctl, chs));3643	if (!knew)3644		return -ENOMEM;3645	if (is_switch) {3646		knew->put = cap_single_sw_put;3647		if (spec->mic_mute_led)3648			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;3649	}3650	if (!inv_dmic)3651		return 0;3652 3653	/* Make independent right kcontrol */3654	if (label)3655		snprintf(tmpname, sizeof(tmpname),3656			 "Inverted %s Capture %s", label, sfx);3657	else3658		snprintf(tmpname, sizeof(tmpname),3659			 "Inverted Capture %s", sfx);3660	knew = add_control(spec, type, tmpname, idx,3661			   amp_val_replace_channels(ctl, 2));3662	if (!knew)3663		return -ENOMEM;3664	if (is_switch) {3665		knew->put = cap_single_sw_put;3666		if (spec->mic_mute_led)3667			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;3668	}3669	return 0;3670}3671 3672/* create single (and simple) capture volume and switch controls */3673static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx,3674				     unsigned int vol_ctl, unsigned int sw_ctl,3675				     bool inv_dmic)3676{3677	int err;3678	err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic);3679	if (err < 0)3680		return err;3681	err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic);3682	if (err < 0)3683		return err;3684	return 0;3685}3686 3687/* create bound capture volume and switch controls */3688static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx,3689				   unsigned int vol_ctl, unsigned int sw_ctl)3690{3691	struct hda_gen_spec *spec = codec->spec;3692	struct snd_kcontrol_new *knew;3693 3694	if (vol_ctl) {3695		knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp);3696		if (!knew)3697			return -ENOMEM;3698		knew->index = idx;3699		knew->private_value = vol_ctl;3700		knew->subdevice = HDA_SUBDEV_AMP_FLAG;3701	}3702	if (sw_ctl) {3703		knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp);3704		if (!knew)3705			return -ENOMEM;3706		knew->index = idx;3707		knew->private_value = sw_ctl;3708		knew->subdevice = HDA_SUBDEV_AMP_FLAG;3709		if (spec->mic_mute_led)3710			knew->access |= SNDRV_CTL_ELEM_ACCESS_MIC_LED;3711	}3712	return 0;3713}3714 3715/* return the vol ctl when used first in the imux list */3716static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type)3717{3718	struct nid_path *path;3719	unsigned int ctl;3720	int i;3721 3722	path = get_input_path(codec, 0, idx);3723	if (!path)3724		return 0;3725	ctl = path->ctls[type];3726	if (!ctl)3727		return 0;3728	for (i = 0; i < idx - 1; i++) {3729		path = get_input_path(codec, 0, i);3730		if (path && path->ctls[type] == ctl)3731			return 0;3732	}3733	return ctl;3734}3735 3736/* create individual capture volume and switch controls per input */3737static int create_multi_cap_vol_ctl(struct hda_codec *codec)3738{3739	struct hda_gen_spec *spec = codec->spec;3740	struct hda_input_mux *imux = &spec->input_mux;3741	int i, err, type;3742 3743	for (i = 0; i < imux->num_items; i++) {3744		bool inv_dmic;3745		int idx;3746 3747		idx = imux->items[i].index;3748		if (idx >= spec->autocfg.num_inputs)3749			continue;3750		inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]);3751 3752		for (type = 0; type < 2; type++) {3753			err = add_single_cap_ctl(codec,3754						 spec->input_labels[idx],3755						 spec->input_label_idxs[idx],3756						 type,3757						 get_first_cap_ctl(codec, i, type),3758						 inv_dmic);3759			if (err < 0)3760				return err;3761		}3762	}3763	return 0;3764}3765 3766static int create_capture_mixers(struct hda_codec *codec)3767{3768	struct hda_gen_spec *spec = codec->spec;3769	struct hda_input_mux *imux = &spec->input_mux;3770	int i, n, nums, err;3771 3772	if (spec->dyn_adc_switch)3773		nums = 1;3774	else3775		nums = spec->num_adc_nids;3776 3777	if (!spec->auto_mic && imux->num_items > 1) {3778		struct snd_kcontrol_new *knew;3779		const char *name;3780		name = nums > 1 ? "Input Source" : "Capture Source";3781		knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp);3782		if (!knew)3783			return -ENOMEM;3784		knew->count = nums;3785	}3786 3787	for (n = 0; n < nums; n++) {3788		bool multi = false;3789		bool multi_cap_vol = spec->multi_cap_vol;3790		bool inv_dmic = false;3791		int vol, sw;3792 3793		vol = sw = 0;3794		for (i = 0; i < imux->num_items; i++) {3795			struct nid_path *path;3796			path = get_input_path(codec, n, i);3797			if (!path)3798				continue;3799			parse_capvol_in_path(codec, path);3800			if (!vol)3801				vol = path->ctls[NID_PATH_VOL_CTL];3802			else if (vol != path->ctls[NID_PATH_VOL_CTL]) {3803				multi = true;3804				if (!same_amp_caps(codec, vol,3805				    path->ctls[NID_PATH_VOL_CTL], HDA_INPUT))3806					multi_cap_vol = true;3807			}3808			if (!sw)3809				sw = path->ctls[NID_PATH_MUTE_CTL];3810			else if (sw != path->ctls[NID_PATH_MUTE_CTL]) {3811				multi = true;3812				if (!same_amp_caps(codec, sw,3813				    path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT))3814					multi_cap_vol = true;3815			}3816			if (is_inv_dmic_pin(codec, spec->imux_pins[i]))3817				inv_dmic = true;3818		}3819 3820		if (!multi)3821			err = create_single_cap_vol_ctl(codec, n, vol, sw,3822							inv_dmic);3823		else if (!multi_cap_vol && !inv_dmic)3824			err = create_bind_cap_vol_ctl(codec, n, vol, sw);3825		else3826			err = create_multi_cap_vol_ctl(codec);3827		if (err < 0)3828			return err;3829	}3830 3831	return 0;3832}3833 3834/*3835 * add mic boosts if needed3836 */3837 3838/* check whether the given amp is feasible as a boost volume */3839static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid,3840			    int dir, int idx)3841{3842	unsigned int step;3843 3844	if (!nid_has_volume(codec, nid, dir) ||3845	    is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) ||3846	    is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL))3847		return false;3848 3849	step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE)3850		>> AC_AMPCAP_STEP_SIZE_SHIFT;3851	if (step < 0x20)3852		return false;3853	return true;3854}3855 3856/* look for a boost amp in a widget close to the pin */3857static unsigned int look_for_boost_amp(struct hda_codec *codec,3858				       struct nid_path *path)3859{3860	unsigned int val = 0;3861	hda_nid_t nid;3862	int depth;3863 3864	for (depth = 0; depth < 3; depth++) {3865		if (depth >= path->depth - 1)3866			break;3867		nid = path->path[depth];3868		if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) {3869			val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);3870			break;3871		} else if (check_boost_vol(codec, nid, HDA_INPUT,3872					   path->idx[depth])) {3873			val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth],3874						  HDA_INPUT);3875			break;3876		}3877	}3878 3879	return val;3880}3881 3882static int parse_mic_boost(struct hda_codec *codec)3883{3884	struct hda_gen_spec *spec = codec->spec;3885	struct auto_pin_cfg *cfg = &spec->autocfg;3886	struct hda_input_mux *imux = &spec->input_mux;3887	int i;3888 3889	if (!spec->num_adc_nids)3890		return 0;3891 3892	for (i = 0; i < imux->num_items; i++) {3893		struct nid_path *path;3894		unsigned int val;3895		int idx;3896		char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];3897 3898		idx = imux->items[i].index;3899		if (idx >= imux->num_items)3900			continue;3901 3902		/* check only line-in and mic pins */3903		if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)3904			continue;3905 3906		path = get_input_path(codec, 0, i);3907		if (!path)3908			continue;3909 3910		val = look_for_boost_amp(codec, path);3911		if (!val)3912			continue;3913 3914		/* create a boost control */3915		snprintf(boost_label, sizeof(boost_label),3916			 "%s Boost Volume", spec->input_labels[idx]);3917		if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label,3918				 spec->input_label_idxs[idx], val))3919			return -ENOMEM;3920 3921		path->ctls[NID_PATH_BOOST_CTL] = val;3922	}3923	return 0;3924}3925 3926#ifdef CONFIG_SND_HDA_GENERIC_LEDS3927/*3928 * vmaster mute LED hook helpers3929 */3930 3931static int create_mute_led_cdev(struct hda_codec *codec,3932				int (*callback)(struct led_classdev *,3933						enum led_brightness),3934				bool micmute)3935{3936	struct hda_gen_spec *spec = codec->spec;3937	struct led_classdev *cdev;3938	int idx = micmute ? LED_AUDIO_MICMUTE : LED_AUDIO_MUTE;3939	int err;3940 3941	cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL);3942	if (!cdev)3943		return -ENOMEM;3944 3945	cdev->name = micmute ? "hda::micmute" : "hda::mute";3946	cdev->max_brightness = 1;3947	cdev->default_trigger = micmute ? "audio-micmute" : "audio-mute";3948	cdev->brightness_set_blocking = callback;3949	cdev->flags = LED_CORE_SUSPENDRESUME;3950 3951	err = led_classdev_register(&codec->core.dev, cdev);3952	if (err < 0)3953		return err;3954	spec->led_cdevs[idx] = cdev;3955	return 0;3956}3957 3958/**3959 * snd_hda_gen_add_mute_led_cdev - Create a LED classdev and enable as vmaster mute LED3960 * @codec: the HDA codec3961 * @callback: the callback for LED classdev brightness_set_blocking3962 */3963int snd_hda_gen_add_mute_led_cdev(struct hda_codec *codec,3964				  int (*callback)(struct led_classdev *,3965						  enum led_brightness))3966{3967	struct hda_gen_spec *spec = codec->spec;3968	int err;3969 3970	if (callback) {3971		err = create_mute_led_cdev(codec, callback, false);3972		if (err) {3973			codec_warn(codec, "failed to create a mute LED cdev\n");3974			return err;3975		}3976	}3977 3978	if (spec->vmaster_mute.hook)3979		codec_err(codec, "vmaster hook already present before cdev!\n");3980 3981	spec->vmaster_mute_led = 1;3982	return 0;3983}3984EXPORT_SYMBOL_GPL(snd_hda_gen_add_mute_led_cdev);3985 3986/**3987 * snd_hda_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED3988 * @codec: the HDA codec3989 * @callback: the callback for LED classdev brightness_set_blocking3990 *3991 * Called from the codec drivers for offering the mic mute LED controls.3992 * This creates a LED classdev and sets up the cap_sync_hook that is called at3993 * each time when the capture mixer switch changes.3994 *3995 * When NULL is passed to @callback, no classdev is created but only the3996 * LED-trigger is set up.3997 *3998 * Returns 0 or a negative error.3999 */4000int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec,4001				     int (*callback)(struct led_classdev *,4002						     enum led_brightness))4003{4004	struct hda_gen_spec *spec = codec->spec;4005	int err;4006 4007	if (callback) {4008		err = create_mute_led_cdev(codec, callback, true);4009		if (err) {4010			codec_warn(codec, "failed to create a mic-mute LED cdev\n");4011			return err;4012		}4013	}4014 4015	spec->mic_mute_led = 1;4016	return 0;4017}4018EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev);4019#endif /* CONFIG_SND_HDA_GENERIC_LEDS */4020 4021/*4022 * parse digital I/Os and set up NIDs in BIOS auto-parse mode4023 */4024static void parse_digital(struct hda_codec *codec)4025{4026	struct hda_gen_spec *spec = codec->spec;4027	struct nid_path *path;4028	int i, nums;4029	hda_nid_t dig_nid, pin;4030 4031	/* support multiple SPDIFs; the secondary is set up as a follower */4032	nums = 0;4033	for (i = 0; i < spec->autocfg.dig_outs; i++) {4034		pin = spec->autocfg.dig_out_pins[i];4035		dig_nid = look_for_dac(codec, pin, true);4036		if (!dig_nid)4037			continue;4038		path = snd_hda_add_new_path(codec, dig_nid, pin, 0);4039		if (!path)4040			continue;4041		print_nid_path(codec, "digout", path);4042		path->active = true;4043		path->pin_fixed = true; /* no jack detection */4044		spec->digout_paths[i] = snd_hda_get_path_idx(codec, path);4045		set_pin_target(codec, pin, PIN_OUT, false);4046		if (!nums) {4047			spec->multiout.dig_out_nid = dig_nid;4048			spec->dig_out_type = spec->autocfg.dig_out_type[0];4049		} else {4050			spec->multiout.follower_dig_outs = spec->follower_dig_outs;4051			if (nums >= ARRAY_SIZE(spec->follower_dig_outs) - 1)4052				break;4053			spec->follower_dig_outs[nums - 1] = dig_nid;4054		}4055		nums++;4056	}4057 4058	if (spec->autocfg.dig_in_pin) {4059		pin = spec->autocfg.dig_in_pin;4060		for_each_hda_codec_node(dig_nid, codec) {4061			unsigned int wcaps = get_wcaps(codec, dig_nid);4062			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)4063				continue;4064			if (!(wcaps & AC_WCAP_DIGITAL))4065				continue;4066			path = snd_hda_add_new_path(codec, pin, dig_nid, 0);4067			if (path) {4068				print_nid_path(codec, "digin", path);4069				path->active = true;4070				path->pin_fixed = true; /* no jack */4071				spec->dig_in_nid = dig_nid;4072				spec->digin_path = snd_hda_get_path_idx(codec, path);4073				set_pin_target(codec, pin, PIN_IN, false);4074				break;4075			}4076		}4077	}4078}4079 4080 4081/*4082 * input MUX handling4083 */4084 4085static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur);4086 4087/* select the given imux item; either unmute exclusively or select the route */4088static int mux_select(struct hda_codec *codec, unsigned int adc_idx,4089		      unsigned int idx)4090{4091	struct hda_gen_spec *spec = codec->spec;4092	const struct hda_input_mux *imux;4093	struct nid_path *old_path, *path;4094 4095	imux = &spec->input_mux;4096	if (!imux->num_items)4097		return 0;4098 4099	if (idx >= imux->num_items)4100		idx = imux->num_items - 1;4101	if (spec->cur_mux[adc_idx] == idx)4102		return 0;4103 4104	old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]);4105	if (!old_path)4106		return 0;4107	if (old_path->active)4108		snd_hda_activate_path(codec, old_path, false, false);4109 4110	spec->cur_mux[adc_idx] = idx;4111 4112	if (spec->hp_mic)4113		update_hp_mic(codec, adc_idx, false);4114 4115	if (spec->dyn_adc_switch)4116		dyn_adc_pcm_resetup(codec, idx);4117 4118	path = get_input_path(codec, adc_idx, idx);4119	if (!path)4120		return 0;4121	if (path->active)4122		return 0;4123	snd_hda_activate_path(codec, path, true, false);4124	if (spec->cap_sync_hook)4125		spec->cap_sync_hook(codec, NULL, NULL);4126	path_power_down_sync(codec, old_path);4127	return 1;4128}4129 4130/* power up/down widgets in the all paths that match with the given NID4131 * as terminals (either start- or endpoint)4132 *4133 * returns the last changed NID, or zero if unchanged.4134 */4135static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid,4136				int pin_state, int stream_state)4137{4138	struct hda_gen_spec *spec = codec->spec;4139	hda_nid_t last, changed = 0;4140	struct nid_path *path;4141	int n;4142 4143	snd_array_for_each(&spec->paths, n, path) {4144		if (!path->depth)4145			continue;4146		if (path->path[0] == nid ||4147		    path->path[path->depth - 1] == nid) {4148			bool pin_old = path->pin_enabled;4149			bool stream_old = path->stream_enabled;4150 4151			if (pin_state >= 0)4152				path->pin_enabled = pin_state;4153			if (stream_state >= 0)4154				path->stream_enabled = stream_state;4155			if ((!path->pin_fixed && path->pin_enabled != pin_old)4156			    || path->stream_enabled != stream_old) {4157				last = path_power_update(codec, path, true);4158				if (last)4159					changed = last;4160			}4161		}4162	}4163	return changed;4164}4165 4166/* check the jack status for power control */4167static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin)4168{4169	if (!is_jack_detectable(codec, pin))4170		return true;4171	return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT;4172}4173 4174/* power up/down the paths of the given pin according to the jack state;4175 * power = 0/1 : only power up/down if it matches with the jack state,4176 *       < 0   : force power up/down to follow the jack sate4177 *4178 * returns the last changed NID, or zero if unchanged.4179 */4180static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin,4181				    int power)4182{4183	bool on;4184 4185	if (!codec->power_save_node)4186		return 0;4187 4188	on = detect_pin_state(codec, pin);4189 4190	if (power >= 0 && on != power)4191		return 0;4192	return set_path_power(codec, pin, on, -1);4193}4194 4195static void pin_power_callback(struct hda_codec *codec,4196			       struct hda_jack_callback *jack,4197			       bool on)4198{4199	if (jack && jack->nid)4200		sync_power_state_change(codec,4201					set_pin_power_jack(codec, jack->nid, on));4202}4203 4204/* callback only doing power up -- called at first */4205static void pin_power_up_callback(struct hda_codec *codec,4206				  struct hda_jack_callback *jack)4207{4208	pin_power_callback(codec, jack, true);4209}4210 4211/* callback only doing power down -- called at last */4212static void pin_power_down_callback(struct hda_codec *codec,4213				    struct hda_jack_callback *jack)4214{4215	pin_power_callback(codec, jack, false);4216}4217 4218/* set up the power up/down callbacks */4219static void add_pin_power_ctls(struct hda_codec *codec, int num_pins,4220			       const hda_nid_t *pins, bool on)4221{4222	int i;4223	hda_jack_callback_fn cb =4224		on ? pin_power_up_callback : pin_power_down_callback;4225 4226	for (i = 0; i < num_pins && pins[i]; i++) {4227		if (is_jack_detectable(codec, pins[i]))4228			snd_hda_jack_detect_enable_callback(codec, pins[i], cb);4229		else4230			set_path_power(codec, pins[i], true, -1);4231	}4232}4233 4234/* enabled power callback to each available I/O pin with jack detections;4235 * the digital I/O pins are excluded because of the unreliable detectsion4236 */4237static void add_all_pin_power_ctls(struct hda_codec *codec, bool on)4238{4239	struct hda_gen_spec *spec = codec->spec;4240	struct auto_pin_cfg *cfg = &spec->autocfg;4241	int i;4242 4243	if (!codec->power_save_node)4244		return;4245	add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on);4246	if (cfg->line_out_type != AUTO_PIN_HP_OUT)4247		add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on);4248	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)4249		add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on);4250	for (i = 0; i < cfg->num_inputs; i++)4251		add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on);4252}4253 4254/* sync path power up/down with the jack states of given pins */4255static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins,4256				const hda_nid_t *pins)4257{4258	int i;4259 4260	for (i = 0; i < num_pins && pins[i]; i++)4261		if (is_jack_detectable(codec, pins[i]))4262			set_pin_power_jack(codec, pins[i], -1);4263}4264 4265/* sync path power up/down with pins; called at init and resume */4266static void sync_all_pin_power_ctls(struct hda_codec *codec)4267{4268	struct hda_gen_spec *spec = codec->spec;4269	struct auto_pin_cfg *cfg = &spec->autocfg;4270	int i;4271 4272	if (!codec->power_save_node)4273		return;4274	sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins);4275	if (cfg->line_out_type != AUTO_PIN_HP_OUT)4276		sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins);4277	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)4278		sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins);4279	for (i = 0; i < cfg->num_inputs; i++)4280		sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin);4281}4282 4283/* add fake paths if not present yet */4284static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid,4285			   int num_pins, const hda_nid_t *pins)4286{4287	struct hda_gen_spec *spec = codec->spec;4288	struct nid_path *path;4289	int i;4290 4291	for (i = 0; i < num_pins; i++) {4292		if (!pins[i])4293			break;4294		if (get_nid_path(codec, nid, pins[i], 0))4295			continue;4296		path = snd_array_new(&spec->paths);4297		if (!path)4298			return -ENOMEM;4299		memset(path, 0, sizeof(*path));4300		path->depth = 2;4301		path->path[0] = nid;4302		path->path[1] = pins[i];4303		path->active = true;4304	}4305	return 0;4306}4307 4308/* create fake paths to all outputs from beep */4309static int add_fake_beep_paths(struct hda_codec *codec)4310{4311	struct hda_gen_spec *spec = codec->spec;4312	struct auto_pin_cfg *cfg = &spec->autocfg;4313	hda_nid_t nid = spec->beep_nid;4314	int err;4315 4316	if (!codec->power_save_node || !nid)4317		return 0;4318	err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins);4319	if (err < 0)4320		return err;4321	if (cfg->line_out_type != AUTO_PIN_HP_OUT) {4322		err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins);4323		if (err < 0)4324			return err;4325	}4326	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {4327		err = add_fake_paths(codec, nid, cfg->speaker_outs,4328				     cfg->speaker_pins);4329		if (err < 0)4330			return err;4331	}4332	return 0;4333}4334 4335/* power up/down beep widget and its output paths */4336static void beep_power_hook(struct hda_beep *beep, bool on)4337{4338	set_path_power(beep->codec, beep->nid, -1, on);4339}4340 4341/**4342 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D04343 * @codec: the HDA codec4344 * @pin: NID of pin to fix4345 */4346int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin)4347{4348	struct hda_gen_spec *spec = codec->spec;4349	struct nid_path *path;4350 4351	path = snd_array_new(&spec->paths);4352	if (!path)4353		return -ENOMEM;4354	memset(path, 0, sizeof(*path));4355	path->depth = 1;4356	path->path[0] = pin;4357	path->active = true;4358	path->pin_fixed = true;4359	path->stream_enabled = true;4360	return 0;4361}4362EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power);4363 4364/*4365 * Jack detections for HP auto-mute and mic-switch4366 */4367 4368/* check each pin in the given array; returns true if any of them is plugged */4369static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins)4370{4371	int i;4372	bool present = false;4373 4374	for (i = 0; i < num_pins; i++) {4375		hda_nid_t nid = pins[i];4376		if (!nid)4377			break;4378		/* don't detect pins retasked as inputs */4379		if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN)4380			continue;4381		if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT)4382			present = true;4383	}4384	return present;4385}4386 4387/* standard HP/line-out auto-mute helper */4388static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins,4389			int *paths, bool mute)4390{4391	struct hda_gen_spec *spec = codec->spec;4392	int i;4393 4394	for (i = 0; i < num_pins; i++) {4395		hda_nid_t nid = pins[i];4396		unsigned int val, oldval;4397		if (!nid)4398			break;4399 4400		oldval = snd_hda_codec_get_pin_target(codec, nid);4401		if (oldval & PIN_IN)4402			continue; /* no mute for inputs */4403 4404		if (spec->auto_mute_via_amp) {4405			struct nid_path *path;4406			hda_nid_t mute_nid;4407 4408			path = snd_hda_get_path_from_idx(codec, paths[i]);4409			if (!path)4410				continue;4411			mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]);4412			if (!mute_nid)4413				continue;4414			if (mute)4415				spec->mute_bits |= (1ULL << mute_nid);4416			else4417				spec->mute_bits &= ~(1ULL << mute_nid);4418			continue;4419		} else {4420			/* don't reset VREF value in case it's controlling4421			 * the amp (see alc861_fixup_asus_amp_vref_0f())4422			 */4423			if (spec->keep_vref_in_automute)4424				val = oldval & ~PIN_HP;4425			else4426				val = 0;4427			if (!mute)4428				val |= oldval;4429			/* here we call update_pin_ctl() so that the pinctl is4430			 * changed without changing the pinctl target value;4431			 * the original target value will be still referred at4432			 * the init / resume again4433			 */4434			update_pin_ctl(codec, nid, val);4435		}4436 4437		set_pin_eapd(codec, nid, !mute);4438		if (codec->power_save_node) {4439			bool on = !mute;4440			if (on)4441				on = detect_pin_state(codec, nid);4442			set_path_power(codec, nid, on, -1);4443		}4444	}4445}4446 4447/**4448 * snd_hda_gen_update_outputs - Toggle outputs muting4449 * @codec: the HDA codec4450 *4451 * Update the mute status of all outputs based on the current jack states.4452 */4453void snd_hda_gen_update_outputs(struct hda_codec *codec)4454{4455	struct hda_gen_spec *spec = codec->spec;4456	int *paths;4457	int on;4458 4459	/* Control HP pins/amps depending on master_mute state;4460	 * in general, HP pins/amps control should be enabled in all cases,4461	 * but currently set only for master_mute, just to be safe4462	 */4463	if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)4464		paths = spec->out_paths;4465	else4466		paths = spec->hp_paths;4467	do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),4468		    spec->autocfg.hp_pins, paths, spec->master_mute);4469 4470	if (!spec->automute_speaker)4471		on = 0;4472	else4473		on = spec->hp_jack_present | spec->line_jack_present;4474	on |= spec->master_mute;4475	spec->speaker_muted = on;4476	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)4477		paths = spec->out_paths;4478	else4479		paths = spec->speaker_paths;4480	do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),4481		    spec->autocfg.speaker_pins, paths, on);4482 4483	/* toggle line-out mutes if needed, too */4484	/* if LO is a copy of either HP or Speaker, don't need to handle it */4485	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||4486	    spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])4487		return;4488	if (!spec->automute_lo)4489		on = 0;4490	else4491		on = spec->hp_jack_present;4492	on |= spec->master_mute;4493	spec->line_out_muted = on;4494	paths = spec->out_paths;4495	do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),4496		    spec->autocfg.line_out_pins, paths, on);4497}4498EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs);4499 4500static void call_update_outputs(struct hda_codec *codec)4501{4502	struct hda_gen_spec *spec = codec->spec;4503	if (spec->automute_hook)4504		spec->automute_hook(codec);4505	else4506		snd_hda_gen_update_outputs(codec);4507 4508	/* sync the whole vmaster followers to reflect the new auto-mute status */4509	if (spec->auto_mute_via_amp && !codec->bus->shutdown)4510		snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false);4511}4512 4513/**4514 * snd_hda_gen_hp_automute - standard HP-automute helper4515 * @codec: the HDA codec4516 * @jack: jack object, NULL for the whole4517 */4518void snd_hda_gen_hp_automute(struct hda_codec *codec,4519			     struct hda_jack_callback *jack)4520{4521	struct hda_gen_spec *spec = codec->spec;4522	hda_nid_t *pins = spec->autocfg.hp_pins;4523	int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins);4524 4525	/* No detection for the first HP jack during indep-HP mode */4526	if (spec->indep_hp_enabled) {4527		pins++;4528		num_pins--;4529	}4530 4531	spec->hp_jack_present = detect_jacks(codec, num_pins, pins);4532	if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))4533		return;4534	call_update_outputs(codec);4535}4536EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute);4537 4538/**4539 * snd_hda_gen_line_automute - standard line-out-automute helper4540 * @codec: the HDA codec4541 * @jack: jack object, NULL for the whole4542 */4543void snd_hda_gen_line_automute(struct hda_codec *codec,4544			       struct hda_jack_callback *jack)4545{4546	struct hda_gen_spec *spec = codec->spec;4547 4548	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)4549		return;4550	/* check LO jack only when it's different from HP */4551	if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])4552		return;4553 4554	spec->line_jack_present =4555		detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),4556			     spec->autocfg.line_out_pins);4557	if (!spec->automute_speaker || !spec->detect_lo)4558		return;4559	call_update_outputs(codec);4560}4561EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute);4562 4563/**4564 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper4565 * @codec: the HDA codec4566 * @jack: jack object, NULL for the whole4567 */4568void snd_hda_gen_mic_autoswitch(struct hda_codec *codec,4569				struct hda_jack_callback *jack)4570{4571	struct hda_gen_spec *spec = codec->spec;4572	int i;4573 4574	if (!spec->auto_mic)4575		return;4576 4577	for (i = spec->am_num_entries - 1; i > 0; i--) {4578		hda_nid_t pin = spec->am_entry[i].pin;4579		/* don't detect pins retasked as outputs */4580		if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN)4581			continue;4582		if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) {4583			mux_select(codec, 0, spec->am_entry[i].idx);4584			return;4585		}4586	}4587	mux_select(codec, 0, spec->am_entry[0].idx);4588}4589EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch);4590 4591/* call appropriate hooks */4592static void call_hp_automute(struct hda_codec *codec,4593			     struct hda_jack_callback *jack)4594{4595	struct hda_gen_spec *spec = codec->spec;4596	if (spec->hp_automute_hook)4597		spec->hp_automute_hook(codec, jack);4598	else4599		snd_hda_gen_hp_automute(codec, jack);4600}4601 4602static void call_line_automute(struct hda_codec *codec,4603			       struct hda_jack_callback *jack)4604{4605	struct hda_gen_spec *spec = codec->spec;4606	if (spec->line_automute_hook)4607		spec->line_automute_hook(codec, jack);4608	else4609		snd_hda_gen_line_automute(codec, jack);4610}4611 4612static void call_mic_autoswitch(struct hda_codec *codec,4613				struct hda_jack_callback *jack)4614{4615	struct hda_gen_spec *spec = codec->spec;4616	if (spec->mic_autoswitch_hook)4617		spec->mic_autoswitch_hook(codec, jack);4618	else4619		snd_hda_gen_mic_autoswitch(codec, jack);4620}4621 4622/* update jack retasking */4623static void update_automute_all(struct hda_codec *codec)4624{4625	call_hp_automute(codec, NULL);4626	call_line_automute(codec, NULL);4627	call_mic_autoswitch(codec, NULL);4628}4629 4630/*4631 * Auto-Mute mode mixer enum support4632 */4633static int automute_mode_info(struct snd_kcontrol *kcontrol,4634			      struct snd_ctl_elem_info *uinfo)4635{4636	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);4637	struct hda_gen_spec *spec = codec->spec;4638	static const char * const texts3[] = {4639		"Disabled", "Speaker Only", "Line Out+Speaker"4640	};4641 4642	if (spec->automute_speaker_possible && spec->automute_lo_possible)4643		return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);4644	return snd_hda_enum_bool_helper_info(kcontrol, uinfo);4645}4646 4647static int automute_mode_get(struct snd_kcontrol *kcontrol,4648			     struct snd_ctl_elem_value *ucontrol)4649{4650	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);4651	struct hda_gen_spec *spec = codec->spec;4652	unsigned int val = 0;4653	if (spec->automute_speaker)4654		val++;4655	if (spec->automute_lo)4656		val++;4657 4658	ucontrol->value.enumerated.item[0] = val;4659	return 0;4660}4661 4662static int automute_mode_put(struct snd_kcontrol *kcontrol,4663			     struct snd_ctl_elem_value *ucontrol)4664{4665	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);4666	struct hda_gen_spec *spec = codec->spec;4667 4668	switch (ucontrol->value.enumerated.item[0]) {4669	case 0:4670		if (!spec->automute_speaker && !spec->automute_lo)4671			return 0;4672		spec->automute_speaker = 0;4673		spec->automute_lo = 0;4674		break;4675	case 1:4676		if (spec->automute_speaker_possible) {4677			if (!spec->automute_lo && spec->automute_speaker)4678				return 0;4679			spec->automute_speaker = 1;4680			spec->automute_lo = 0;4681		} else if (spec->automute_lo_possible) {4682			if (spec->automute_lo)4683				return 0;4684			spec->automute_lo = 1;4685		} else4686			return -EINVAL;4687		break;4688	case 2:4689		if (!spec->automute_lo_possible || !spec->automute_speaker_possible)4690			return -EINVAL;4691		if (spec->automute_speaker && spec->automute_lo)4692			return 0;4693		spec->automute_speaker = 1;4694		spec->automute_lo = 1;4695		break;4696	default:4697		return -EINVAL;4698	}4699	call_update_outputs(codec);4700	return 1;4701}4702 4703static const struct snd_kcontrol_new automute_mode_enum = {4704	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,4705	.name = "Auto-Mute Mode",4706	.info = automute_mode_info,4707	.get = automute_mode_get,4708	.put = automute_mode_put,4709};4710 4711static int add_automute_mode_enum(struct hda_codec *codec)4712{4713	struct hda_gen_spec *spec = codec->spec;4714 4715	if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum))4716		return -ENOMEM;4717	return 0;4718}4719 4720/*4721 * Check the availability of HP/line-out auto-mute;4722 * Set up appropriately if really supported4723 */4724static int check_auto_mute_availability(struct hda_codec *codec)4725{4726	struct hda_gen_spec *spec = codec->spec;4727	struct auto_pin_cfg *cfg = &spec->autocfg;4728	int present = 0;4729	int i, err;4730 4731	if (spec->suppress_auto_mute)4732		return 0;4733 4734	if (cfg->hp_pins[0])4735		present++;4736	if (cfg->line_out_pins[0])4737		present++;4738	if (cfg->speaker_pins[0])4739		present++;4740	if (present < 2) /* need two different output types */4741		return 0;4742 4743	if (!cfg->speaker_pins[0] &&4744	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {4745		memcpy(cfg->speaker_pins, cfg->line_out_pins,4746		       sizeof(cfg->speaker_pins));4747		cfg->speaker_outs = cfg->line_outs;4748	}4749 4750	if (!cfg->hp_pins[0] &&4751	    cfg->line_out_type == AUTO_PIN_HP_OUT) {4752		memcpy(cfg->hp_pins, cfg->line_out_pins,4753		       sizeof(cfg->hp_pins));4754		cfg->hp_outs = cfg->line_outs;4755	}4756 4757	for (i = 0; i < cfg->hp_outs; i++) {4758		hda_nid_t nid = cfg->hp_pins[i];4759		if (!is_jack_detectable(codec, nid))4760			continue;4761		codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid);4762		snd_hda_jack_detect_enable_callback(codec, nid,4763						    call_hp_automute);4764		spec->detect_hp = 1;4765	}4766 4767	if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {4768		if (cfg->speaker_outs)4769			for (i = 0; i < cfg->line_outs; i++) {4770				hda_nid_t nid = cfg->line_out_pins[i];4771				if (!is_jack_detectable(codec, nid))4772					continue;4773				codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid);4774				snd_hda_jack_detect_enable_callback(codec, nid,4775								    call_line_automute);4776				spec->detect_lo = 1;4777			}4778		spec->automute_lo_possible = spec->detect_hp;4779	}4780 4781	spec->automute_speaker_possible = cfg->speaker_outs &&4782		(spec->detect_hp || spec->detect_lo);4783 4784	spec->automute_lo = spec->automute_lo_possible;4785	spec->automute_speaker = spec->automute_speaker_possible;4786 4787	if (spec->automute_speaker_possible || spec->automute_lo_possible) {4788		/* create a control for automute mode */4789		err = add_automute_mode_enum(codec);4790		if (err < 0)4791			return err;4792	}4793	return 0;4794}4795 4796/* check whether all auto-mic pins are valid; setup indices if OK */4797static bool auto_mic_check_imux(struct hda_codec *codec)4798{4799	struct hda_gen_spec *spec = codec->spec;4800	const struct hda_input_mux *imux;4801	int i;4802 4803	imux = &spec->input_mux;4804	for (i = 0; i < spec->am_num_entries; i++) {4805		spec->am_entry[i].idx =4806			find_idx_in_nid_list(spec->am_entry[i].pin,4807					     spec->imux_pins, imux->num_items);4808		if (spec->am_entry[i].idx < 0)4809			return false; /* no corresponding imux */4810	}4811 4812	/* we don't need the jack detection for the first pin */4813	for (i = 1; i < spec->am_num_entries; i++)4814		snd_hda_jack_detect_enable_callback(codec,4815						    spec->am_entry[i].pin,4816						    call_mic_autoswitch);4817	return true;4818}4819 4820static int compare_attr(const void *ap, const void *bp)4821{4822	const struct automic_entry *a = ap;4823	const struct automic_entry *b = bp;4824	return (int)(a->attr - b->attr);4825}4826 4827/*4828 * Check the availability of auto-mic switch;4829 * Set up if really supported4830 */4831static int check_auto_mic_availability(struct hda_codec *codec)4832{4833	struct hda_gen_spec *spec = codec->spec;4834	struct auto_pin_cfg *cfg = &spec->autocfg;4835	unsigned int types;4836	int i, num_pins;4837 4838	if (spec->suppress_auto_mic)4839		return 0;4840 4841	types = 0;4842	num_pins = 0;4843	for (i = 0; i < cfg->num_inputs; i++) {4844		hda_nid_t nid = cfg->inputs[i].pin;4845		unsigned int attr;4846		attr = snd_hda_codec_get_pincfg(codec, nid);4847		attr = snd_hda_get_input_pin_attr(attr);4848		if (types & (1 << attr))4849			return 0; /* already occupied */4850		switch (attr) {4851		case INPUT_PIN_ATTR_INT:4852			if (cfg->inputs[i].type != AUTO_PIN_MIC)4853				return 0; /* invalid type */4854			break;4855		case INPUT_PIN_ATTR_UNUSED:4856			return 0; /* invalid entry */4857		default:4858			if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)4859				return 0; /* invalid type */4860			if (!spec->line_in_auto_switch &&4861			    cfg->inputs[i].type != AUTO_PIN_MIC)4862				return 0; /* only mic is allowed */4863			if (!is_jack_detectable(codec, nid))4864				return 0; /* no unsol support */4865			break;4866		}4867		if (num_pins >= MAX_AUTO_MIC_PINS)4868			return 0;4869		types |= (1 << attr);4870		spec->am_entry[num_pins].pin = nid;4871		spec->am_entry[num_pins].attr = attr;4872		num_pins++;4873	}4874 4875	if (num_pins < 2)4876		return 0;4877 4878	spec->am_num_entries = num_pins;4879	/* sort the am_entry in the order of attr so that the pin with a4880	 * higher attr will be selected when the jack is plugged.4881	 */4882	sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]),4883	     compare_attr, NULL);4884 4885	if (!auto_mic_check_imux(codec))4886		return 0;4887 4888	spec->auto_mic = 1;4889	spec->num_adc_nids = 1;4890	spec->cur_mux[0] = spec->am_entry[0].idx;4891	codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",4892		    spec->am_entry[0].pin,4893		    spec->am_entry[1].pin,4894		    spec->am_entry[2].pin);4895 4896	return 0;4897}4898 4899/**4900 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets4901 * into power down4902 * @codec: the HDA codec4903 * @nid: NID to evalute4904 * @power_state: target power state4905 */4906unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec,4907						  hda_nid_t nid,4908						  unsigned int power_state)4909{4910	struct hda_gen_spec *spec = codec->spec;4911 4912	if (!spec->power_down_unused && !codec->power_save_node)4913		return power_state;4914	if (power_state != AC_PWRST_D0 || nid == codec->core.afg)4915		return power_state;4916	if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER)4917		return power_state;4918	if (is_active_nid_for_any(codec, nid))4919		return power_state;4920	return AC_PWRST_D3;4921}4922EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter);4923 4924/* mute all aamix inputs initially; parse up to the first leaves */4925static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix)4926{4927	int i, nums;4928	const hda_nid_t *conn;4929	bool has_amp;4930 4931	nums = snd_hda_get_conn_list(codec, mix, &conn);4932	has_amp = nid_has_mute(codec, mix, HDA_INPUT);4933	for (i = 0; i < nums; i++) {4934		if (has_amp)4935			update_amp(codec, mix, HDA_INPUT, i,4936				   0xff, HDA_AMP_MUTE);4937		else if (nid_has_volume(codec, conn[i], HDA_OUTPUT))4938			update_amp(codec, conn[i], HDA_OUTPUT, 0,4939				   0xff, HDA_AMP_MUTE);4940	}4941}4942 4943/**4944 * snd_hda_gen_stream_pm - Stream power management callback4945 * @codec: the HDA codec4946 * @nid: audio widget4947 * @on: power on/off flag4948 *4949 * Set this in patch_ops.stream_pm.  Only valid with power_save_node flag.4950 */4951void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on)4952{4953	if (codec->power_save_node)4954		set_path_power(codec, nid, -1, on);4955}4956EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm);4957 4958/* forcibly mute the speaker output without caching; return true if updated */4959static bool force_mute_output_path(struct hda_codec *codec, hda_nid_t nid)4960{4961	if (!nid)4962		return false;4963	if (!nid_has_mute(codec, nid, HDA_OUTPUT))4964		return false; /* no mute, skip */4965	if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &4966	    snd_hda_codec_amp_read(codec, nid, 1, HDA_OUTPUT, 0) &4967	    HDA_AMP_MUTE)4968		return false; /* both channels already muted, skip */4969 4970	/* direct amp update without caching */4971	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,4972			    AC_AMP_SET_OUTPUT | AC_AMP_SET_LEFT |4973			    AC_AMP_SET_RIGHT | HDA_AMP_MUTE);4974	return true;4975}4976 4977/**4978 * snd_hda_gen_shutup_speakers - Forcibly mute the speaker outputs4979 * @codec: the HDA codec4980 *4981 * Forcibly mute the speaker outputs, to be called at suspend or shutdown.4982 *4983 * The mute state done by this function isn't cached, hence the original state4984 * will be restored at resume.4985 *4986 * Return true if the mute state has been changed.4987 */4988bool snd_hda_gen_shutup_speakers(struct hda_codec *codec)4989{4990	struct hda_gen_spec *spec = codec->spec;4991	const int *paths;4992	const struct nid_path *path;4993	int i, p, num_paths;4994	bool updated = false;4995 4996	/* if already powered off, do nothing */4997	if (!snd_hdac_is_power_on(&codec->core))4998		return false;4999 5000	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) {5001		paths = spec->out_paths;5002		num_paths = spec->autocfg.line_outs;5003	} else {5004		paths = spec->speaker_paths;5005		num_paths = spec->autocfg.speaker_outs;5006	}5007 5008	for (i = 0; i < num_paths; i++) {5009		path = snd_hda_get_path_from_idx(codec, paths[i]);5010		if (!path)5011			continue;5012		for (p = 0; p < path->depth; p++)5013			if (force_mute_output_path(codec, path->path[p]))5014				updated = true;5015	}5016 5017	return updated;5018}5019EXPORT_SYMBOL_GPL(snd_hda_gen_shutup_speakers);5020 5021/**5022 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and5023 * set up the hda_gen_spec5024 * @codec: the HDA codec5025 * @cfg: Parsed pin configuration5026 *5027 * return 1 if successful, 0 if the proper config is not found,5028 * or a negative error code5029 */5030int snd_hda_gen_parse_auto_config(struct hda_codec *codec,5031				  struct auto_pin_cfg *cfg)5032{5033	struct hda_gen_spec *spec = codec->spec;5034	int err;5035 5036	parse_user_hints(codec);5037 5038	if (spec->vmaster_mute_led || spec->mic_mute_led)5039		snd_ctl_led_request();5040 5041	if (spec->mixer_nid && !spec->mixer_merge_nid)5042		spec->mixer_merge_nid = spec->mixer_nid;5043 5044	if (cfg != &spec->autocfg) {5045		spec->autocfg = *cfg;5046		cfg = &spec->autocfg;5047	}5048 5049	if (!spec->main_out_badness)5050		spec->main_out_badness = &hda_main_out_badness;5051	if (!spec->extra_out_badness)5052		spec->extra_out_badness = &hda_extra_out_badness;5053 5054	fill_all_dac_nids(codec);5055 5056	if (!cfg->line_outs) {5057		if (cfg->dig_outs || cfg->dig_in_pin) {5058			spec->multiout.max_channels = 2;5059			spec->no_analog = 1;5060			goto dig_only;5061		}5062		if (!cfg->num_inputs && !cfg->dig_in_pin)5063			return 0; /* can't find valid BIOS pin config */5064	}5065 5066	if (!spec->no_primary_hp &&5067	    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&5068	    cfg->line_outs <= cfg->hp_outs) {5069		/* use HP as primary out */5070		cfg->speaker_outs = cfg->line_outs;5071		memcpy(cfg->speaker_pins, cfg->line_out_pins,5072		       sizeof(cfg->speaker_pins));5073		cfg->line_outs = cfg->hp_outs;5074		memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));5075		cfg->hp_outs = 0;5076		memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));5077		cfg->line_out_type = AUTO_PIN_HP_OUT;5078	}5079 5080	err = parse_output_paths(codec);5081	if (err < 0)5082		return err;5083	err = create_multi_channel_mode(codec);5084	if (err < 0)5085		return err;5086	err = create_multi_out_ctls(codec, cfg);5087	if (err < 0)5088		return err;5089	err = create_hp_out_ctls(codec);5090	if (err < 0)5091		return err;5092	err = create_speaker_out_ctls(codec);5093	if (err < 0)5094		return err;5095	err = create_indep_hp_ctls(codec);5096	if (err < 0)5097		return err;5098	err = create_loopback_mixing_ctl(codec);5099	if (err < 0)5100		return err;5101	err = create_hp_mic(codec);5102	if (err < 0)5103		return err;5104	err = create_input_ctls(codec);5105	if (err < 0)5106		return err;5107 5108	/* add power-down pin callbacks at first */5109	add_all_pin_power_ctls(codec, false);5110 5111	spec->const_channel_count = spec->ext_channel_count;5112	/* check the multiple speaker and headphone pins */5113	if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)5114		spec->const_channel_count = max(spec->const_channel_count,5115						cfg->speaker_outs * 2);5116	if (cfg->line_out_type != AUTO_PIN_HP_OUT)5117		spec->const_channel_count = max(spec->const_channel_count,5118						cfg->hp_outs * 2);5119	spec->multiout.max_channels = max(spec->ext_channel_count,5120					  spec->const_channel_count);5121 5122	err = check_auto_mute_availability(codec);5123	if (err < 0)5124		return err;5125 5126	err = check_dyn_adc_switch(codec);5127	if (err < 0)5128		return err;5129 5130	err = check_auto_mic_availability(codec);5131	if (err < 0)5132		return err;5133 5134	/* add stereo mix if available and not enabled yet */5135	if (!spec->auto_mic && spec->mixer_nid &&5136	    spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO &&5137	    spec->input_mux.num_items > 1) {5138		err = parse_capture_source(codec, spec->mixer_nid,5139					   CFG_IDX_MIX, spec->num_all_adcs,5140					   "Stereo Mix", 0);5141		if (err < 0)5142			return err;5143	}5144 5145 5146	err = create_capture_mixers(codec);5147	if (err < 0)5148		return err;5149 5150	err = parse_mic_boost(codec);5151	if (err < 0)5152		return err;5153 5154	/* create "Headphone Mic Jack Mode" if no input selection is5155	 * available (or user specifies add_jack_modes hint)5156	 */5157	if (spec->hp_mic_pin &&5158	    (spec->auto_mic || spec->input_mux.num_items == 1 ||5159	     spec->add_jack_modes)) {5160		err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin);5161		if (err < 0)5162			return err;5163	}5164 5165	if (spec->add_jack_modes) {5166		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {5167			err = create_out_jack_modes(codec, cfg->line_outs,5168						    cfg->line_out_pins);5169			if (err < 0)5170				return err;5171		}5172		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {5173			err = create_out_jack_modes(codec, cfg->hp_outs,5174						    cfg->hp_pins);5175			if (err < 0)5176				return err;5177		}5178	}5179 5180	/* add power-up pin callbacks at last */5181	add_all_pin_power_ctls(codec, true);5182 5183	/* mute all aamix input initially */5184	if (spec->mixer_nid)5185		mute_all_mixer_nid(codec, spec->mixer_nid);5186 5187 dig_only:5188	parse_digital(codec);5189 5190	if (spec->power_down_unused || codec->power_save_node) {5191		if (!codec->power_filter)5192			codec->power_filter = snd_hda_gen_path_power_filter;5193		if (!codec->patch_ops.stream_pm)5194			codec->patch_ops.stream_pm = snd_hda_gen_stream_pm;5195	}5196 5197	if (!spec->no_analog && spec->beep_nid) {5198		err = snd_hda_attach_beep_device(codec, spec->beep_nid);5199		if (err < 0)5200			return err;5201		if (codec->beep && codec->power_save_node) {5202			err = add_fake_beep_paths(codec);5203			if (err < 0)5204				return err;5205			codec->beep->power_hook = beep_power_hook;5206		}5207	}5208 5209	return 1;5210}5211EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config);5212 5213 5214/*5215 * Build control elements5216 */5217 5218/* follower controls for virtual master */5219static const char * const follower_pfxs[] = {5220	"Front", "Surround", "Center", "LFE", "Side",5221	"Headphone", "Speaker", "Mono", "Line Out",5222	"CLFE", "Bass Speaker", "PCM",5223	"Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side",5224	"Headphone Front", "Headphone Surround", "Headphone CLFE",5225	"Headphone Side", "Headphone+LO", "Speaker+LO",5226	NULL,5227};5228 5229/**5230 * snd_hda_gen_build_controls - Build controls from the parsed results5231 * @codec: the HDA codec5232 *5233 * Pass this to build_controls patch_ops.5234 */5235int snd_hda_gen_build_controls(struct hda_codec *codec)5236{5237	struct hda_gen_spec *spec = codec->spec;5238	int err;5239 5240	if (spec->kctls.used) {5241		err = snd_hda_add_new_ctls(codec, spec->kctls.list);5242		if (err < 0)5243			return err;5244	}5245 5246	if (spec->multiout.dig_out_nid) {5247		err = snd_hda_create_dig_out_ctls(codec,5248						  spec->multiout.dig_out_nid,5249						  spec->multiout.dig_out_nid,5250						  spec->pcm_rec[1]->pcm_type);5251		if (err < 0)5252			return err;5253		if (!spec->no_analog) {5254			err = snd_hda_create_spdif_share_sw(codec,5255							    &spec->multiout);5256			if (err < 0)5257				return err;5258			spec->multiout.share_spdif = 1;5259		}5260	}5261	if (spec->dig_in_nid) {5262		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);5263		if (err < 0)5264			return err;5265	}5266 5267	/* if we have no master control, let's create it */5268	if (!spec->no_analog && !spec->suppress_vmaster &&5269	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {5270		err = snd_hda_add_vmaster(codec, "Master Playback Volume",5271					  spec->vmaster_tlv, follower_pfxs,5272					  "Playback Volume", 0);5273		if (err < 0)5274			return err;5275	}5276	if (!spec->no_analog && !spec->suppress_vmaster &&5277	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {5278		err = __snd_hda_add_vmaster(codec, "Master Playback Switch",5279					    NULL, follower_pfxs,5280					    "Playback Switch", true,5281					    spec->vmaster_mute_led ?5282						SNDRV_CTL_ELEM_ACCESS_SPK_LED : 0,5283					    &spec->vmaster_mute.sw_kctl);5284		if (err < 0)5285			return err;5286		if (spec->vmaster_mute.hook) {5287			snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute);5288			snd_hda_sync_vmaster_hook(&spec->vmaster_mute);5289		}5290	}5291 5292	free_kctls(spec); /* no longer needed */5293 5294	err = snd_hda_jack_add_kctls(codec, &spec->autocfg);5295	if (err < 0)5296		return err;5297 5298	return 0;5299}5300EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls);5301 5302 5303/*5304 * PCM definitions5305 */5306 5307static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo,5308				   struct hda_codec *codec,5309				   struct snd_pcm_substream *substream,5310				   int action)5311{5312	struct hda_gen_spec *spec = codec->spec;5313	if (spec->pcm_playback_hook)5314		spec->pcm_playback_hook(hinfo, codec, substream, action);5315}5316 5317static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo,5318				  struct hda_codec *codec,5319				  struct snd_pcm_substream *substream,5320				  int action)5321{5322	struct hda_gen_spec *spec = codec->spec;5323	if (spec->pcm_capture_hook)5324		spec->pcm_capture_hook(hinfo, codec, substream, action);5325}5326 5327/*5328 * Analog playback callbacks5329 */5330static int playback_pcm_open(struct hda_pcm_stream *hinfo,5331			     struct hda_codec *codec,5332			     struct snd_pcm_substream *substream)5333{5334	struct hda_gen_spec *spec = codec->spec;5335	int err;5336 5337	mutex_lock(&spec->pcm_mutex);5338	err = snd_hda_multi_out_analog_open(codec,5339					    &spec->multiout, substream,5340					     hinfo);5341	if (!err) {5342		spec->active_streams |= 1 << STREAM_MULTI_OUT;5343		call_pcm_playback_hook(hinfo, codec, substream,5344				       HDA_GEN_PCM_ACT_OPEN);5345	}5346	mutex_unlock(&spec->pcm_mutex);5347	return err;5348}5349 5350static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,5351				struct hda_codec *codec,5352				unsigned int stream_tag,5353				unsigned int format,5354				struct snd_pcm_substream *substream)5355{5356	struct hda_gen_spec *spec = codec->spec;5357	int err;5358 5359	err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout,5360					       stream_tag, format, substream);5361	if (!err)5362		call_pcm_playback_hook(hinfo, codec, substream,5363				       HDA_GEN_PCM_ACT_PREPARE);5364	return err;5365}5366 5367static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,5368				struct hda_codec *codec,5369				struct snd_pcm_substream *substream)5370{5371	struct hda_gen_spec *spec = codec->spec;5372	int err;5373 5374	err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);5375	if (!err)5376		call_pcm_playback_hook(hinfo, codec, substream,5377				       HDA_GEN_PCM_ACT_CLEANUP);5378	return err;5379}5380 5381static int playback_pcm_close(struct hda_pcm_stream *hinfo,5382			      struct hda_codec *codec,5383			      struct snd_pcm_substream *substream)5384{5385	struct hda_gen_spec *spec = codec->spec;5386	mutex_lock(&spec->pcm_mutex);5387	spec->active_streams &= ~(1 << STREAM_MULTI_OUT);5388	call_pcm_playback_hook(hinfo, codec, substream,5389			       HDA_GEN_PCM_ACT_CLOSE);5390	mutex_unlock(&spec->pcm_mutex);5391	return 0;5392}5393 5394static int capture_pcm_open(struct hda_pcm_stream *hinfo,5395			    struct hda_codec *codec,5396			    struct snd_pcm_substream *substream)5397{5398	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN);5399	return 0;5400}5401 5402static int capture_pcm_prepare(struct hda_pcm_stream *hinfo,5403			       struct hda_codec *codec,5404			       unsigned int stream_tag,5405			       unsigned int format,5406			       struct snd_pcm_substream *substream)5407{5408	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);5409	call_pcm_capture_hook(hinfo, codec, substream,5410			      HDA_GEN_PCM_ACT_PREPARE);5411	return 0;5412}5413 5414static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo,5415			       struct hda_codec *codec,5416			       struct snd_pcm_substream *substream)5417{5418	snd_hda_codec_cleanup_stream(codec, hinfo->nid);5419	call_pcm_capture_hook(hinfo, codec, substream,5420			      HDA_GEN_PCM_ACT_CLEANUP);5421	return 0;5422}5423 5424static int capture_pcm_close(struct hda_pcm_stream *hinfo,5425			     struct hda_codec *codec,5426			     struct snd_pcm_substream *substream)5427{5428	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE);5429	return 0;5430}5431 5432static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo,5433				 struct hda_codec *codec,5434				 struct snd_pcm_substream *substream)5435{5436	struct hda_gen_spec *spec = codec->spec;5437	int err = 0;5438 5439	mutex_lock(&spec->pcm_mutex);5440	if (spec->indep_hp && !spec->indep_hp_enabled)5441		err = -EBUSY;5442	else5443		spec->active_streams |= 1 << STREAM_INDEP_HP;5444	call_pcm_playback_hook(hinfo, codec, substream,5445			       HDA_GEN_PCM_ACT_OPEN);5446	mutex_unlock(&spec->pcm_mutex);5447	return err;5448}5449 5450static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo,5451				  struct hda_codec *codec,5452				  struct snd_pcm_substream *substream)5453{5454	struct hda_gen_spec *spec = codec->spec;5455	mutex_lock(&spec->pcm_mutex);5456	spec->active_streams &= ~(1 << STREAM_INDEP_HP);5457	call_pcm_playback_hook(hinfo, codec, substream,5458			       HDA_GEN_PCM_ACT_CLOSE);5459	mutex_unlock(&spec->pcm_mutex);5460	return 0;5461}5462 5463static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,5464				    struct hda_codec *codec,5465				    unsigned int stream_tag,5466				    unsigned int format,5467				    struct snd_pcm_substream *substream)5468{5469	snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format);5470	call_pcm_playback_hook(hinfo, codec, substream,5471			       HDA_GEN_PCM_ACT_PREPARE);5472	return 0;5473}5474 5475static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,5476				    struct hda_codec *codec,5477				    struct snd_pcm_substream *substream)5478{5479	snd_hda_codec_cleanup_stream(codec, hinfo->nid);5480	call_pcm_playback_hook(hinfo, codec, substream,5481			       HDA_GEN_PCM_ACT_CLEANUP);5482	return 0;5483}5484 5485/*5486 * Digital out5487 */5488static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo,5489				 struct hda_codec *codec,5490				 struct snd_pcm_substream *substream)5491{5492	struct hda_gen_spec *spec = codec->spec;5493	return snd_hda_multi_out_dig_open(codec, &spec->multiout);5494}5495 5496static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,5497				    struct hda_codec *codec,5498				    unsigned int stream_tag,5499				    unsigned int format,5500				    struct snd_pcm_substream *substream)5501{5502	struct hda_gen_spec *spec = codec->spec;5503	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,5504					     stream_tag, format, substream);5505}5506 5507static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,5508				    struct hda_codec *codec,5509				    struct snd_pcm_substream *substream)5510{5511	struct hda_gen_spec *spec = codec->spec;5512	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);5513}5514 5515static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo,5516				  struct hda_codec *codec,5517				  struct snd_pcm_substream *substream)5518{5519	struct hda_gen_spec *spec = codec->spec;5520	return snd_hda_multi_out_dig_close(codec, &spec->multiout);5521}5522 5523/*5524 * Analog capture5525 */5526#define alt_capture_pcm_open	capture_pcm_open5527#define alt_capture_pcm_close	capture_pcm_close5528 5529static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,5530				   struct hda_codec *codec,5531				   unsigned int stream_tag,5532				   unsigned int format,5533				   struct snd_pcm_substream *substream)5534{5535	struct hda_gen_spec *spec = codec->spec;5536 5537	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],5538				   stream_tag, 0, format);5539	call_pcm_capture_hook(hinfo, codec, substream,5540			      HDA_GEN_PCM_ACT_PREPARE);5541	return 0;5542}5543 5544static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,5545				   struct hda_codec *codec,5546				   struct snd_pcm_substream *substream)5547{5548	struct hda_gen_spec *spec = codec->spec;5549 5550	snd_hda_codec_cleanup_stream(codec,5551				     spec->adc_nids[substream->number + 1]);5552	call_pcm_capture_hook(hinfo, codec, substream,5553			      HDA_GEN_PCM_ACT_CLEANUP);5554	return 0;5555}5556 5557/*5558 */5559static const struct hda_pcm_stream pcm_analog_playback = {5560	.substreams = 1,5561	.channels_min = 2,5562	.channels_max = 8,5563	/* NID is set in build_pcms */5564	.ops = {5565		.open = playback_pcm_open,5566		.close = playback_pcm_close,5567		.prepare = playback_pcm_prepare,5568		.cleanup = playback_pcm_cleanup5569	},5570};5571 5572static const struct hda_pcm_stream pcm_analog_capture = {5573	.substreams = 1,5574	.channels_min = 2,5575	.channels_max = 2,5576	/* NID is set in build_pcms */5577	.ops = {5578		.open = capture_pcm_open,5579		.close = capture_pcm_close,5580		.prepare = capture_pcm_prepare,5581		.cleanup = capture_pcm_cleanup5582	},5583};5584 5585static const struct hda_pcm_stream pcm_analog_alt_playback = {5586	.substreams = 1,5587	.channels_min = 2,5588	.channels_max = 2,5589	/* NID is set in build_pcms */5590	.ops = {5591		.open = alt_playback_pcm_open,5592		.close = alt_playback_pcm_close,5593		.prepare = alt_playback_pcm_prepare,5594		.cleanup = alt_playback_pcm_cleanup5595	},5596};5597 5598static const struct hda_pcm_stream pcm_analog_alt_capture = {5599	.substreams = 2, /* can be overridden */5600	.channels_min = 2,5601	.channels_max = 2,5602	/* NID is set in build_pcms */5603	.ops = {5604		.open = alt_capture_pcm_open,5605		.close = alt_capture_pcm_close,5606		.prepare = alt_capture_pcm_prepare,5607		.cleanup = alt_capture_pcm_cleanup5608	},5609};5610 5611static const struct hda_pcm_stream pcm_digital_playback = {5612	.substreams = 1,5613	.channels_min = 2,5614	.channels_max = 2,5615	/* NID is set in build_pcms */5616	.ops = {5617		.open = dig_playback_pcm_open,5618		.close = dig_playback_pcm_close,5619		.prepare = dig_playback_pcm_prepare,5620		.cleanup = dig_playback_pcm_cleanup5621	},5622};5623 5624static const struct hda_pcm_stream pcm_digital_capture = {5625	.substreams = 1,5626	.channels_min = 2,5627	.channels_max = 2,5628	/* NID is set in build_pcms */5629};5630 5631/* Used by build_pcms to flag that a PCM has no playback stream */5632static const struct hda_pcm_stream pcm_null_stream = {5633	.substreams = 0,5634	.channels_min = 0,5635	.channels_max = 0,5636};5637 5638/*5639 * dynamic changing ADC PCM streams5640 */5641static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)5642{5643	struct hda_gen_spec *spec = codec->spec;5644	hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];5645 5646	if (spec->cur_adc && spec->cur_adc != new_adc) {5647		/* stream is running, let's swap the current ADC */5648		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);5649		spec->cur_adc = new_adc;5650		snd_hda_codec_setup_stream(codec, new_adc,5651					   spec->cur_adc_stream_tag, 0,5652					   spec->cur_adc_format);5653		return true;5654	}5655	return false;5656}5657 5658/* analog capture with dynamic dual-adc changes */5659static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,5660				       struct hda_codec *codec,5661				       unsigned int stream_tag,5662				       unsigned int format,5663				       struct snd_pcm_substream *substream)5664{5665	struct hda_gen_spec *spec = codec->spec;5666	spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];5667	spec->cur_adc_stream_tag = stream_tag;5668	spec->cur_adc_format = format;5669	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);5670	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);5671	return 0;5672}5673 5674static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,5675				       struct hda_codec *codec,5676				       struct snd_pcm_substream *substream)5677{5678	struct hda_gen_spec *spec = codec->spec;5679	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);5680	spec->cur_adc = 0;5681	call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP);5682	return 0;5683}5684 5685static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {5686	.substreams = 1,5687	.channels_min = 2,5688	.channels_max = 2,5689	.nid = 0, /* fill later */5690	.ops = {5691		.prepare = dyn_adc_capture_pcm_prepare,5692		.cleanup = dyn_adc_capture_pcm_cleanup5693	},5694};5695 5696static void fill_pcm_stream_name(char *str, size_t len, const char *sfx,5697				 const char *chip_name)5698{5699	char *p;5700 5701	if (*str)5702		return;5703	strscpy(str, chip_name, len);5704 5705	/* drop non-alnum chars after a space */5706	for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) {5707		if (!isalnum(p[1])) {5708			*p = 0;5709			break;5710		}5711	}5712	strlcat(str, sfx, len);5713}5714 5715/* copy PCM stream info from @default_str, and override non-NULL entries5716 * from @spec_str and @nid5717 */5718static void setup_pcm_stream(struct hda_pcm_stream *str,5719			     const struct hda_pcm_stream *default_str,5720			     const struct hda_pcm_stream *spec_str,5721			     hda_nid_t nid)5722{5723	*str = *default_str;5724	if (nid)5725		str->nid = nid;5726	if (spec_str) {5727		if (spec_str->substreams)5728			str->substreams = spec_str->substreams;5729		if (spec_str->channels_min)5730			str->channels_min = spec_str->channels_min;5731		if (spec_str->channels_max)5732			str->channels_max = spec_str->channels_max;5733		if (spec_str->rates)5734			str->rates = spec_str->rates;5735		if (spec_str->formats)5736			str->formats = spec_str->formats;5737		if (spec_str->maxbps)5738			str->maxbps = spec_str->maxbps;5739	}5740}5741 5742/**5743 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results5744 * @codec: the HDA codec5745 *5746 * Pass this to build_pcms patch_ops.5747 */5748int snd_hda_gen_build_pcms(struct hda_codec *codec)5749{5750	struct hda_gen_spec *spec = codec->spec;5751	struct hda_pcm *info;5752	bool have_multi_adcs;5753 5754	if (spec->no_analog)5755		goto skip_analog;5756 5757	fill_pcm_stream_name(spec->stream_name_analog,5758			     sizeof(spec->stream_name_analog),5759			     " Analog", codec->core.chip_name);5760	info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog);5761	if (!info)5762		return -ENOMEM;5763	spec->pcm_rec[0] = info;5764 5765	if (spec->multiout.num_dacs > 0) {5766		setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],5767				 &pcm_analog_playback,5768				 spec->stream_analog_playback,5769				 spec->multiout.dac_nids[0]);5770		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =5771			spec->multiout.max_channels;5772		if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&5773		    spec->autocfg.line_outs == 2)5774			info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =5775				snd_pcm_2_1_chmaps;5776	}5777	if (spec->num_adc_nids) {5778		setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],5779				 (spec->dyn_adc_switch ?5780				  &dyn_adc_pcm_analog_capture : &pcm_analog_capture),5781				 spec->stream_analog_capture,5782				 spec->adc_nids[0]);5783	}5784 5785 skip_analog:5786	/* SPDIF for stream index #1 */5787	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {5788		fill_pcm_stream_name(spec->stream_name_digital,5789				     sizeof(spec->stream_name_digital),5790				     " Digital", codec->core.chip_name);5791		info = snd_hda_codec_pcm_new(codec, "%s",5792					     spec->stream_name_digital);5793		if (!info)5794			return -ENOMEM;5795		codec->follower_dig_outs = spec->multiout.follower_dig_outs;5796		spec->pcm_rec[1] = info;5797		if (spec->dig_out_type)5798			info->pcm_type = spec->dig_out_type;5799		else5800			info->pcm_type = HDA_PCM_TYPE_SPDIF;5801		if (spec->multiout.dig_out_nid)5802			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],5803					 &pcm_digital_playback,5804					 spec->stream_digital_playback,5805					 spec->multiout.dig_out_nid);5806		if (spec->dig_in_nid)5807			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],5808					 &pcm_digital_capture,5809					 spec->stream_digital_capture,5810					 spec->dig_in_nid);5811	}5812 5813	if (spec->no_analog)5814		return 0;5815 5816	/* If the use of more than one ADC is requested for the current5817	 * model, configure a second analog capture-only PCM.5818	 */5819	have_multi_adcs = (spec->num_adc_nids > 1) &&5820		!spec->dyn_adc_switch && !spec->auto_mic;5821	/* Additional Analaog capture for index #2 */5822	if (spec->alt_dac_nid || have_multi_adcs) {5823		fill_pcm_stream_name(spec->stream_name_alt_analog,5824				     sizeof(spec->stream_name_alt_analog),5825			     " Alt Analog", codec->core.chip_name);5826		info = snd_hda_codec_pcm_new(codec, "%s",5827					     spec->stream_name_alt_analog);5828		if (!info)5829			return -ENOMEM;5830		spec->pcm_rec[2] = info;5831		if (spec->alt_dac_nid)5832			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],5833					 &pcm_analog_alt_playback,5834					 spec->stream_analog_alt_playback,5835					 spec->alt_dac_nid);5836		else5837			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK],5838					 &pcm_null_stream, NULL, 0);5839		if (have_multi_adcs) {5840			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],5841					 &pcm_analog_alt_capture,5842					 spec->stream_analog_alt_capture,5843					 spec->adc_nids[1]);5844			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =5845				spec->num_adc_nids - 1;5846		} else {5847			setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE],5848					 &pcm_null_stream, NULL, 0);5849		}5850	}5851 5852	return 0;5853}5854EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms);5855 5856 5857/*5858 * Standard auto-parser initializations5859 */5860 5861/* configure the given path as a proper output */5862static void set_output_and_unmute(struct hda_codec *codec, int path_idx)5863{5864	struct nid_path *path;5865	hda_nid_t pin;5866 5867	path = snd_hda_get_path_from_idx(codec, path_idx);5868	if (!path || !path->depth)5869		return;5870	pin = path->path[path->depth - 1];5871	restore_pin_ctl(codec, pin);5872	snd_hda_activate_path(codec, path, path->active,5873			      aamix_default(codec->spec));5874	set_pin_eapd(codec, pin, path->active);5875}5876 5877/* initialize primary output paths */5878static void init_multi_out(struct hda_codec *codec)5879{5880	struct hda_gen_spec *spec = codec->spec;5881	int i;5882 5883	for (i = 0; i < spec->autocfg.line_outs; i++)5884		set_output_and_unmute(codec, spec->out_paths[i]);5885}5886 5887 5888static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths)5889{5890	int i;5891 5892	for (i = 0; i < num_outs; i++)5893		set_output_and_unmute(codec, paths[i]);5894}5895 5896/* initialize hp and speaker paths */5897static void init_extra_out(struct hda_codec *codec)5898{5899	struct hda_gen_spec *spec = codec->spec;5900 5901	if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT)5902		__init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths);5903	if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT)5904		__init_extra_out(codec, spec->autocfg.speaker_outs,5905				 spec->speaker_paths);5906}5907 5908/* initialize multi-io paths */5909static void init_multi_io(struct hda_codec *codec)5910{5911	struct hda_gen_spec *spec = codec->spec;5912	int i;5913 5914	for (i = 0; i < spec->multi_ios; i++) {5915		hda_nid_t pin = spec->multi_io[i].pin;5916		struct nid_path *path;5917		path = get_multiio_path(codec, i);5918		if (!path)5919			continue;5920		if (!spec->multi_io[i].ctl_in)5921			spec->multi_io[i].ctl_in =5922				snd_hda_codec_get_pin_target(codec, pin);5923		snd_hda_activate_path(codec, path, path->active,5924				      aamix_default(spec));5925	}5926}5927 5928static void init_aamix_paths(struct hda_codec *codec)5929{5930	struct hda_gen_spec *spec = codec->spec;5931 5932	if (!spec->have_aamix_ctl)5933		return;5934	if (!has_aamix_out_paths(spec))5935		return;5936	update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0],5937			   spec->aamix_out_paths[0],5938			   spec->autocfg.line_out_type);5939	update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0],5940			   spec->aamix_out_paths[1],5941			   AUTO_PIN_HP_OUT);5942	update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0],5943			   spec->aamix_out_paths[2],5944			   AUTO_PIN_SPEAKER_OUT);5945}5946 5947/* set up input pins and loopback paths */5948static void init_analog_input(struct hda_codec *codec)5949{5950	struct hda_gen_spec *spec = codec->spec;5951	struct auto_pin_cfg *cfg = &spec->autocfg;5952	int i;5953 5954	for (i = 0; i < cfg->num_inputs; i++) {5955		hda_nid_t nid = cfg->inputs[i].pin;5956		if (is_input_pin(codec, nid))5957			restore_pin_ctl(codec, nid);5958 5959		/* init loopback inputs */5960		if (spec->mixer_nid) {5961			resume_path_from_idx(codec, spec->loopback_paths[i]);5962			resume_path_from_idx(codec, spec->loopback_merge_path);5963		}5964	}5965}5966 5967/* initialize ADC paths */5968static void init_input_src(struct hda_codec *codec)5969{5970	struct hda_gen_spec *spec = codec->spec;5971	struct hda_input_mux *imux = &spec->input_mux;5972	struct nid_path *path;5973	int i, c, nums;5974 5975	if (spec->dyn_adc_switch)5976		nums = 1;5977	else5978		nums = spec->num_adc_nids;5979 5980	for (c = 0; c < nums; c++) {5981		for (i = 0; i < imux->num_items; i++) {5982			path = get_input_path(codec, c, i);5983			if (path) {5984				bool active = path->active;5985				if (i == spec->cur_mux[c])5986					active = true;5987				snd_hda_activate_path(codec, path, active, false);5988			}5989		}5990		if (spec->hp_mic)5991			update_hp_mic(codec, c, true);5992	}5993 5994	if (spec->cap_sync_hook)5995		spec->cap_sync_hook(codec, NULL, NULL);5996}5997 5998/* set right pin controls for digital I/O */5999static void init_digital(struct hda_codec *codec)6000{6001	struct hda_gen_spec *spec = codec->spec;6002	int i;6003	hda_nid_t pin;6004 6005	for (i = 0; i < spec->autocfg.dig_outs; i++)6006		set_output_and_unmute(codec, spec->digout_paths[i]);6007	pin = spec->autocfg.dig_in_pin;6008	if (pin) {6009		restore_pin_ctl(codec, pin);6010		resume_path_from_idx(codec, spec->digin_path);6011	}6012}6013 6014/* clear unsol-event tags on unused pins; Conexant codecs seem to leave6015 * invalid unsol tags by some reason6016 */6017static void clear_unsol_on_unused_pins(struct hda_codec *codec)6018{6019	const struct hda_pincfg *pin;6020	int i;6021 6022	snd_array_for_each(&codec->init_pins, i, pin) {6023		hda_nid_t nid = pin->nid;6024		if (is_jack_detectable(codec, nid) &&6025		    !snd_hda_jack_tbl_get(codec, nid))6026			snd_hda_codec_write_cache(codec, nid, 0,6027					AC_VERB_SET_UNSOLICITED_ENABLE, 0);6028	}6029}6030 6031/**6032 * snd_hda_gen_init - initialize the generic spec6033 * @codec: the HDA codec6034 *6035 * This can be put as patch_ops init function.6036 */6037int snd_hda_gen_init(struct hda_codec *codec)6038{6039	struct hda_gen_spec *spec = codec->spec;6040 6041	if (spec->init_hook)6042		spec->init_hook(codec);6043 6044	if (!spec->skip_verbs)6045		snd_hda_apply_verbs(codec);6046 6047	init_multi_out(codec);6048	init_extra_out(codec);6049	init_multi_io(codec);6050	init_aamix_paths(codec);6051	init_analog_input(codec);6052	init_input_src(codec);6053	init_digital(codec);6054 6055	clear_unsol_on_unused_pins(codec);6056 6057	sync_all_pin_power_ctls(codec);6058 6059	/* call init functions of standard auto-mute helpers */6060	update_automute_all(codec);6061 6062	snd_hda_regmap_sync(codec);6063 6064	if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook)6065		snd_hda_sync_vmaster_hook(&spec->vmaster_mute);6066 6067	hda_call_check_power_status(codec, 0x01);6068	return 0;6069}6070EXPORT_SYMBOL_GPL(snd_hda_gen_init);6071 6072/**6073 * snd_hda_gen_free - free the generic spec6074 * @codec: the HDA codec6075 *6076 * This can be put as patch_ops free function.6077 */6078void snd_hda_gen_free(struct hda_codec *codec)6079{6080	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);6081	snd_hda_gen_spec_free(codec->spec);6082	kfree(codec->spec);6083	codec->spec = NULL;6084}6085EXPORT_SYMBOL_GPL(snd_hda_gen_free);6086 6087/**6088 * snd_hda_gen_check_power_status - check the loopback power save state6089 * @codec: the HDA codec6090 * @nid: NID to inspect6091 *6092 * This can be put as patch_ops check_power_status function.6093 */6094int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid)6095{6096	struct hda_gen_spec *spec = codec->spec;6097	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);6098}6099EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status);6100 6101 6102/*6103 * the generic codec support6104 */6105 6106static const struct hda_codec_ops generic_patch_ops = {6107	.build_controls = snd_hda_gen_build_controls,6108	.build_pcms = snd_hda_gen_build_pcms,6109	.init = snd_hda_gen_init,6110	.free = snd_hda_gen_free,6111	.unsol_event = snd_hda_jack_unsol_event,6112	.check_power_status = snd_hda_gen_check_power_status,6113};6114 6115/*6116 * snd_hda_parse_generic_codec - Generic codec parser6117 * @codec: the HDA codec6118 */6119static int snd_hda_parse_generic_codec(struct hda_codec *codec)6120{6121	struct hda_gen_spec *spec;6122	int err;6123 6124	spec = kzalloc(sizeof(*spec), GFP_KERNEL);6125	if (!spec)6126		return -ENOMEM;6127	snd_hda_gen_spec_init(spec);6128	codec->spec = spec;6129 6130	err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0);6131	if (err < 0)6132		goto error;6133 6134	err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg);6135	if (err < 0)6136		goto error;6137 6138	codec->patch_ops = generic_patch_ops;6139	return 0;6140 6141error:6142	snd_hda_gen_free(codec);6143	return err;6144}6145 6146static const struct hda_device_id snd_hda_id_generic[] = {6147	HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec),6148	{} /* terminator */6149};6150MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic);6151 6152static struct hda_codec_driver generic_driver = {6153	.id = snd_hda_id_generic,6154};6155 6156module_hda_codec_driver(generic_driver);6157 6158MODULE_LICENSE("GPL");6159MODULE_DESCRIPTION("Generic HD-audio codec parser");6160